Class EngineConsoleStateProvider

Apply a captured chain + processing onto a channel atomically and broadcast it.

Apply exactly the fields a snapshot CARRIES onto a channel — the session restore's own door with its defaults left off.

A restore of a whole show resolves absent fields to their kind defaults (a channel the operator never overrode comes back at the default, not at last night's value). A PASTE must not: an absent field there means "the operator did not copy this", and defaulting it would silently move state nobody asked about. Same door, same order, same announce — the defaults are the caller's, which is why they live in applyChannelSnapshot and not here.

Apply a snapshot atomically, replacing current state. The provider is responsible for ordering (faders/mutes/pans then chains, etc.) and for broadcasting the result; the caller only awaits completion.

Restore the console-wide cue state from a snapshot — the applyMatrixSnapshot counterpart for the one cue bus, driven through the engine so a restore fans out to every client exactly like a live cue.setMode / cue.setMonitor.

Re-apply a stored routing graph. Each channel's first stored endpoint is set as its primary (replace-semantics, clearing any prior patch), the rest are added as summed crosspoint sources; each output's ONE stored destination is routed (replace-semantics), and an output whose out is ABSENT is routed NOWHERE — the unpatch round-trips rather than leaving the console on whatever it held. Channels absent from the snapshot are left untouched. A no-op without a structural surface.

Capture one channel's chain + processing (for a channel config).

ONE channel's persisted state, exactly as a session capture sees it.

Through captureConsole rather than a second assembly pass: a channel's snapshot is built by five passes (the strip, the processor stores, sends, links, routing) and picking one channel out of the finished walk is the only way a copy and a save can be held to the same answer. A copy is one operator gesture, so walking the console for it is not a cost worth a second capture path.

Capture the entire console as a serialisable snapshot.

Capture the console-wide cue state (mode + monitor-output designation) into a snapshot — the matrix-shaped CueSnapshotJson for the ONE cue bus.

Capture just the live routing graph — each input channel's source patch (the crosspoint multi-in, [primary, ...extras] by port name) + each bus / main output's routed sink. No mix state (faders / sends / chains). Empty when this server has no structural surface (the routing graph is a software-mixer concept).

The PEER that owns fact on this channel, or nothing where the desk's own stage owns it — ConsoleStateProvider.peerOwnerOfFact over the live topology.

ownerOf is the contract's own ownership expression, and it is the SAME call the gain row's field gate resolves through (channel-strip-rows.ts's contractPeerOf). One resolution: a whole-state door and the row it writes behind can never disagree about who owns a fact.

The shape scheduled for the next boot; undefined when none is.

Record — or, with undefined, clear — the shape the next boot builds at. Writing it moves NOTHING: no bus is created, no strip resized. That is the whole of the restart path, and it is why this is a plain stash and not a door onto the structural layer.