Struct Engine 

pub struct Engine<S: EffectSink, O: StepObserver = ()> { /* private fields */ }

The reducer, its state, and where its commands go.

Implementations

impl<S: EffectSink> Engine<S, ()>

pub const fn new(state: State, sink: S) -> Self

An engine that pumps the reducer and nothing else.

impl<S: EffectSink, O: StepObserver> Engine<S, O>

pub fn with_observer<O2: StepObserver>(self, observer: O2) -> Engine<S, O2>

Attach something that watches every message before the reducer sees it.

pub const fn state(&self) -> &State

The current reducer state.

Panics

Only if an earlier reduction panicked inside the reducer, which is what would leave the engine without a state. Every use of the engine after that is already a bug.

pub const fn state_mut(&mut self) -> &mut State

Direct state access for the bootstrap window — seeding a conversation, stamping a scratchpad path — before the first message is pumped.

Panics

As Engine::state.

pub const fn sink_mut(&mut self) -> &mut S

pub fn into_parts(self) -> (State, S, O)

Give everything back, so the caller can build its result, seal whatever its observer was writing, and shut the runner down.

Panics

As Engine::state.

pub const fn is_idle(&self) -> bool

No turn in flight.

pub fn is_settled(&self) -> bool

Idle, with no user prompt waiting to seed the next turn. What every headless driver means by “done”.

pub fn reduce(&mut self, now: DateTime<Local>, msg: Msg) -> StepOutcome

The kernel: stamp the clock, reduce, route the commands.

Synchronous and observer-free — --replay folds an entire recorded log through this with no runtime, stamping each entry’s recorded timestamp instead of reading a clock.

pub async fn step(&mut self, msg: Msg) -> StepOutcome

One message under the current wall clock, shown to the observer first.

pub async fn step_at(&mut self, now: DateTime<Local>, msg: Msg) -> StepOutcome

Engine::step with the clock supplied by the caller — used where a single timestamp is shared with something else, such as the recorder line that must carry the exact now its message was reduced under.

pub async fn drive( &mut self, inbox: &mut Inbox<'_>, policy: &DrivePolicy, ) -> DriveExit

Pump inbox until policy says stop.

The select! is biased: cancellation and the deadline are one-shot arms that must win against a saturated message channel. (The interactive loop’s fairness requirement — #112, where a hot channel starved terminal input — does not apply here, because there is no input arm to starve.)