Tech docs — Abstractions catalog

Every reusable element, in one place.

Two kinds of code exist here: a reusable element, or configuration composing one. This page is the inventory of the first kind — types, components, widgets, libraries and modules — so a change reaches for what already exists before it writes something new.

The web-ui and native-C halves below are curated by hand, because typedoc reads TSDoc, not Vue single-file components or C headers. The @openmixer/core and @openmixer/server halves are generated straight from their TSDoc comments — 1354 exported symbols, 1290 of them with a summary.

Composables — packages/web-ui

useResource

The one write/read client for a REST row: optimistic hold, refusal surfacing, supersede-by-later-write.

useContract

Reads a row's declared OPTIONS contract — the writable fields, ranges and enumerated options.

useStripRow

Write-backed binding to one channel strip's row.

strip-view-store

Read-only per-channel row binding, split out to break an import cycle with useStripRow.

row-store-registry

The central registry every declared row store joins, so a test can reset every store and stream in one call.

useVisibleDemand

Turns a widget's on-screen visibility into the demand signal that lets nothing compute unwatched.

useConsoleStream

The one EventSource connection to the console — every SSE stream in the surface goes through it.

useNumberFormat

Locale-aware numeric display formatting.

useDeclaration

Reads a resource's declared schema and limits.

useTraceDemand

Demand-gates a trace-buffer subscription.

useScreenClass

Responsive breakpoint classification.

useTheme

Reads the active theme's tokens.

useControlDescriptor

Generic control metadata — label, unit and range — for a declared field.

Components & widgets — packages/web-ui

ConfirmButton

Arm-then-fire two-tap confirmation for an unrecoverable action, including the global no-confirmation escape hatch.

db.ts / FADER_TAPER

The one canonical fader position↔dB taper, shared by the fader widget, the channel tile and the model.

controls/Fader.vue

The base fader widget — taper, drag and keyboard nudge — wrapped by the gain fader and the fader bank.

controls/Encoder.vue, EncoderRow.vue

A rotary parameter control, alone or as a labelled row.

controls/Meter.vue

The per-strip level meter.

controls/ConsoleSelect.vue

A styled select control with contrast handling built in.

Stepper.vue

A stepped +/- numeric control.

NudgeField.vue

A numeric field with nudge buttons.

SchemaForm.vue / SchemaField.vue

Generic form rendering from a declared schema.

C libraries — packages/pipewire-native

mix_dsp.h

The shared DSP kernel library: click-free gain ramps, gate/EQ/compressor primitives, bus summing, output delay and the real-FFT analyser.

mixer_state.h

The node's state layout and its concurrency contract — which fields are word-atomic, real-time-owned, or release/acquire.

omx_napi.h / .c

The one JS-boundary argument-fetch-and-validate shape every native binding declares its signature through.

mix_bus.h

The summing bus: width folding, sparsity skipping, one send struct for every bus in the desk.

mix_lane.h

The one processing-lane stage walk shared verbatim by every channel strip and the master lane.

mix_order.h

The data-driven, allocation-free per-strip stage order — a reorderable chain of gate, EQ, compressor, delay, reverb and insert steps.

mix_host.h

The addon's one shared, refcounted PipeWire client and thread loop.

mix_delay.h

The real-time-safe stereo delay-line kernel, used as a send/return or an insert.

mix_reverb.h

One Schroeder-Moorer comb-and-allpass kernel serving both room and hall reverbs, plus a Dattorro plate kernel.

mix_tap.h

The named tap-point bank: post-trim, pre-EQ, post-EQ, pre-fader, post-fader.

mix_insert.h

The in-lane hosted-plugin send/return detour.

mix_rec.h

The real-time-safe capture ring: monotonic cursors, a counted gap standing in for silence.

mix_pb.h

The playback ring counterpart to mix_rec.h — lockstep multitrack reads, silence on a stall.

mix_loop.h

Routing-loop (howl-round) graph detection, kept as the one topology mirror in the codebase.

mix_rf64.h

The WAV/RF64 grammar — the single writer and reader for every take file.

hrp_baseline.h, hrp_attribute.h, hrp_pitch.h, hrp_track.h, hrp_analyze.c

The composed HRP (harmonic reference pitch) pipeline: pitch, then attribution, then baseline, then tracking, one contract per stage.

generator.h / .c

Talkback and test-signal source nodes, sharing mix_host.h's client.

Resource molds — packages/core, instantiated from packages/server

DerivedResource

A read-only row recomputed on every read.

ScalarRecordResource

One writable scalar or record per address.

CollectionResource

An addressable multi-item collection, such as a set of EQ bands.

LatchResource

Momentary or latched state, extending ScalarRecordResource.

OperationResource

An action-style, POST-shaped resource.

ConsoleResource<S>

The umbrella interface every row satisfies, for the rare row that needs more than a mold provides.

stripFieldRow()

A generic builder that turns a strip field, its wire codec and its engine door into a full row.

StripStateController<...>

The shared base behind the compressor, delay, reverb and gate controllers.

Controllers — packages/server

State plus a broadcastable frame, with no I/O of their own.

BpmControllerClockControllerCompControllerDelayControllerDiscoveryControllerGateControllerHeadAmpLifecycleControllerRecordControllerReverbControllerRmeTotalmixControllerSafetyControllerStripStateControllerVscControllerWarningsController

Stores — packages/server

Persisted state, one module per concern.

ChannelConfigStoreChannelEqStoreChannelPatchStoreClockOwnershipStoreJsonSettingsStoreMeasurementStoreNetworkSettingsStorePatchbaySettingsStorePatchStoreReacConfigStoreSceneStoreSessionStoreTakeStoreTouchedStore

Transport — packages/server

protocol.ts

Every outbound wire frame shape, each with its own builder function — the one declared home for what goes out on the wire.

rest-router.ts

The single REST door. It names no entity itself, which is what lets every row be plain configuration instead of wiring its own HTTP verbs.

Generated — core + server

The TypeScript public surface.

Functions (592)

NamePackageSummary

absentDeviceArgs

@openmixer/coreThe `args` a ABSENT_DEVICE_REFUSAL carries.

accumulateChainLatency

@openmixer/coreSum a chain's insert latency.

aggregateSpectrumBands

@openmixer/coreReduce `high` (and `low`, where a band is under the crossover) to `nBands` log-spaced bands.

alignCorrection

@openmixer/coreThe correction a fit implies for THIS channel, against the line it already holds.

allocateConsole

@openmixer/coreBuild a ConsoleAllocation from a source count (the gig's N) + the per-bus-type counts.

allocatedBusIds

@openmixer/coreEvery bus ChannelId the allocation declares, grouped by kind.

allocationWarnings

@openmixer/coreEvery operator-facing warning an allocation carries — the one call a caller needs so a new warning becomes visible everywhere at once instead of at whichever site remembered it.

allocationWithinProfile

@openmixer/coreTrue when the allocation already fits the appliance (no clamp would change it) — used to WARN, not to block.

alsaDeviceKey

@openmixer/coreAn ALSA node name minus its trailing PROFILE token — the profile-INDEPENDENT device identity two profiles of the same card share.

annotateStageboxGroups

@openmixer/coreTag the reac-pw nodes in a source/sink pair with a `group` label (their owning StageboxDevice's name), leaving every other node — and any group already set, e.g.

applyParts

@openmixer/coreApply the selected parts of a clipboard entry onto a target channel.

asComp

@openmixer/coreThe typed **compressor view** of a `dynamics` node — the derived CompState for the comp curve.

asEq

@openmixer/coreThe typed **EQ view** of an `eq` node — the derived EqState the curve maths bind (`paramsToState('eq', …)`).

asGate

@openmixer/coreThe typed **gate view** of a `gate` node — the derived GateState for the gate curve.

assessRtHeadroom

@openmixer/coreAssess the engine's RT headroom from one reading.

audioFabricFits

@openmixer/coreDoes a box's AUDIO placement of `width` channels starting at fabric slot `base` fit inside the 40 slots the wire carries?

audioFabricRemaining

@openmixer/coreHow many AUDIO fabric slots are still free above `base` — what a caller reports when a placement is refused, so the operator sees the real headroom rather than a bare "no".

availableSurfaceTemplates

@openmixer/coreTemplates whose `adapterType` is among the server's currently registered types (as reported by `adapter.types`) — the ones the Setup menu can actually add today.

balanceGains

@openmixer/coreThe L/R gain a `pan` position acts as a **balance** on a *stereo* signal (a linked stereo strip — M32 / Roland model).

bandFMax

@openmixer/coreThe highest frequency worth drawing at `sampleRate`: the cap, or Nyquist where that is lower.

bandHasGain

@openmixer/coreTrue when a band type has an adjustable gain (bell + shelves); pass + notch shapes don't.

bandLabel

@openmixer/coreA short display label for a band: its free EqBand.label, else its legacy console EqBand.name, else its origin-prefixed name if a planter owns it (bandOriginLabel — `F3`, `H7`), else THE NUMBER ALONE.

bandOriginLabel

@openmixer/coreThe declared display name for a machine-planted band — `F3`, `H7` — its origin's short prefix plus its own stable EqBand.id, the same id `/eq/bands/{id}` already addresses it by.

bankAlignment

@openmixer/coreMeasure a BusAllocation against the surface's banks (see BankAlignment).

bankAlignmentWarning

@openmixer/coreThe operator-facing warning for an allocation whose banked strips do not fill their banks, or `undefined` when they do.

bankedStripCount

@openmixer/coreThe number of **banked strips** an allocation occupies — every tier whose descriptor is BusTypeDescriptor.banked, summed.

bindTapPoints

@openmixer/coreBuild a desk's set by BINDING catalogue points, optionally under the desk's own spellings.

binToHz

@openmixer/coreFrequency (Hz) of FFT bin `bin` — the bin→Hz law every PersistenceTracker consumer needs (mirrors the web-ui's `spectrum.ts`, which keeps its own copy for its wider display maths).

biquadMagnitudeDb

@openmixer/coreMagnitude of one biquad band at `freq` (Hz), in dB.

boundsOf

@openmixer/coreFollow ChannelFactDecl.range for one fact (and, where the source is a table, one field) to the bounds a control draws with.

boxesReferenced

@openmixer/coreEvery box a stored patch depends on — what a show needs on stage, derived from the patch.

budgetMsFor

@openmixer/coreThe accumulated-latency budget for a destination: the per-bus override, else the role's.

buildHardwareManifest

@openmixer/coreBuild the HardwareManifest recorded in a session at save time (issue #154).

buildLatencyPath

@openmixer/coreSum a path's steps into a LatencyPath.

buildOpenApiDocument

@openmixer/coreBuild the OpenAPI 3.1 document.

buildTopology

@openmixer/coreBuild a MixerTopology from a TopologySpec.

busAllocationOf

@openmixer/coreBuild a BusAllocation by asking `count` for each type — the one spelling of the field-by-field construction (compile-checked total by the return type), so a builder in another module cannot silently skip a newly added…

busAudioPaths

@openmixer/coreAudio paths the allocated buses draw: every summing bus + main, excluding DCA — a DCA is control-domain coupling and carries no audio.

busCapWarning

@openmixer/coreThe operator-facing warning for an allocation whose N exceeds BUS_INPUT_CAP, or `undefined` when it fits.

busInputCount

@openmixer/coreThe size a summing bus is created with for a gig of `inputChannels` = N: N capped at BUS_INPUT_CAP, so every input can send to every bus (gig-input-configuration.md).

busTypeAllowed

@openmixer/coreA bus type is offered iff its per-type max > 0.

busTypeBanked

@openmixer/coreWhether a channel kind is a bus type the surface BANKS (see BusTypeDescriptor.banked); `undefined` for a kind that is not an allocatable bus at all.

busTypeRoleLabel

@openmixer/coreThe surface role word for a channel kind that IS an allocatable bus type (from the BUS_TYPES table); `undefined` for a non-bus kind.

butterworthSlopeQs

@openmixer/coreThe per-section Q values that realise a Butterworth pass filter of the given slope: a 12 dB/oct filter is one maximally-flat 2nd-order section (Q = 1/√2); a 24 dB/oct filter is two cascaded sections (Q = 0.5412, 1.306…

canonicalChainFor

@openmixer/coreThe CANONICAL arrangement for a strip kind -- what a freshly built strip of that kind carries: defaultBusChain for a bus master, defaultChannelChain otherwise.

capAllocation

@openmixer/coreClamp a whole allocation to the appliance: channels to `caps.inputChannels`, each bus to its per-type max, then — if `caps.pathPool` is set — trim so Σ(paths) ≤ pathPool, keeping the highest-priority paths (input chan…

capBusAllocation

@openmixer/coreClamp each bus count to the profile's per-type maximum (no pool trim).

carriedInstanceOf

@openmixer/coreOne instance's values out of the collection's state — each declared series the state carries, decoded through its own window into a plain number and keyed by the series' field name.

carriedLookupOf

@openmixer/coreEvery instance's values out of the collection's state, decoded ONCE: each declared series the state carries is decoded through its own window one time, and the lookup answers an id by position.

carriedSeriesCodecs

@openmixer/coreThe series codecs a declaration publishes — one `levelSeriesU8` per series, over its window.

catalogueTapPoint

@openmixer/coreThe catalogue entry for `id`, or `undefined` — the one question a binding asks.

censusGaps

@openmixer/coreThe facts with a gap on either axis — what the mission shrinks, as `contract.fact` strings.

censusTotals

@openmixer/coreTally a census.

chainFromSlotState

@openmixer/coreProject a whole strip's typed processing state onto a normalized Processor chain — the complete strip→chain direction (extends populateChainParams with inserts).

chainFromSnapshot

@openmixer/coreRebuild a live Processor chain from its persisted ProcessorSnapshotJson form, then normalizeChain it for the strip `kind` — so a loaded chain always satisfies the always-present-EQ invariant (and the structural fader …

channelCapabilityOf

@openmixer/coreTHE derivation: the contract's kind-level truth intersected with the patched instance's.

channelConfigMovesNothing

@openmixer/coreTrue when the apply moves nothing the channel holds — the surface applies without asking.

channelConfigMovesOf

@openmixer/coreThe moves a preview state lists, narrowed entry by entry — what `applyMoves` answers, or what rides a `CONFIRM_REQUIRED` refusal as `preview`.

channelDisplayLabel

@openmixer/coreThe full surface label for a bus / channel: its numbered role, plus the custom name when the operator has set one that adds information.

channelFactAddressOf

@openmixer/coreThe concrete URL path a fact answers at for ONE channel — factRowAddress with the address bound.

channelIdOf

@openmixer/coreThe `{kind}/{index}` pair of a ResourceId as a ChannelId, or `undefined` when it addresses nothing (issue #438).

channelIds

@openmixer/coreThe canonical **1-based `{kind, index}` id list** for a channel kind and count — `channelIds('input', 3)` → `input/1, input/2, input/3`.

channelInSubgroup

@openmixer/coreWhether a channel is assigned into a subgroup.

channelKey

@openmixer/core—

channelMainGainViaSubgroups

@openmixer/coreA single channel's composite linear gain to the main mix through the subgroups it is assigned to: its own fader gain times the SUM of each containing group's group→main gain.

channelPairAddress

@openmixer/coreThe `channel × channel` address one pair-shaped row is registered under.

channelRecordArmed

@openmixer/coreWhether a captured channel is armed for the multitrack recorder — the stored ChannelSnapshotJson.record wish, or the kind's own default where the show is silent.

channelRecordTaps

@openmixer/coreThe tap points a captured channel records at — the stored wish, or the kind's default where the show is silent.

channelRefOf

@openmixer/coreOne unknown element as a channel ref — validated narrowing, no assertion anywhere.

channelRoleSlot

@openmixer/coreThe native `role_slot` for a role — its index in CHANNEL_ROLE_ORDER (L=0, R=1).

channelRoutesToMain

@openmixer/coreWhether a captured channel is assigned to the main mix.

channelSafeFor

@openmixer/coreThe recall-safe entry for a channel, or `undefined` when it carries none.

channelSafeOf

@openmixer/coreONE channel's row state as the recall filter's ChannelSafe entry, or `undefined` when the channel safes nothing — a channel that exempts nothing contributes no entry, exactly as the old mask dropped a cleared channel …

channelScopeLabel

@openmixer/coreMAIN carries no index because there is exactly one of it; every other kind is abbreviation + index.

channelSlotKeyAddress

@openmixer/coreThe `channel × slot × key` address, with the KEY's member name given by the caller: the same shape spells a control port (`symbol`) and an `lv2:Parameter` (`property`), and naming the member keeps them different addre…

channelSlotTargetAddress

@openmixer/coreThe `channel × slot × target-channel` address: an operation whose subject is one numbered route of a strip and whose object is a second strip — the matrix promotion of a MAIN fan-out destination.

channelTailAddress

@openmixer/coreThe `channel × <field>` address, `field` naming the tail's OWN wire key (`processorId`, `filter`, `band`, …) so two different tail-shaped rows never collide on the same segment name.

channelTailKeyAddress

@openmixer/coreThe `channel × tail × key` address — channelSlotKeyAddress's shape for a rack whose members are named rather than positioned.

clamp

@openmixer/coreClamp `n` into `[lo, hi]`.

clamp01

@openmixer/coreClamp `n` into `[0, 1]`.

clampBpm

@openmixer/coreClamp a BPM to the accepted range.

clampEqFreq

@openmixer/coreClamp a band frequency into the audio band.

clampEqGain

@openmixer/coreClamp a band gain into ±EQ_GAIN_LIMIT_DB.

clampEqQ

@openmixer/coreClamp a band Q into EQ_Q_RANGE.

clampEqQFor

@openmixer/coreClamp a band Q into the extent its SHAPE allows: a notch may go ultra-narrow (EQ_NOTCH_Q_RANGE); every other shape keeps EQ_Q_RANGE.

clampFbsCooldownMinutes

@openmixer/coreClamp the ring-memory window into FBS_COOLDOWN_MINUTES_RANGE; junk → the default.

clampFbsCut

@openmixer/coreClamp an FBS band's gain into its own cut authority: [FBS_MAX_CUT_DB, 0].

clampFbsHold

@openmixer/coreClamp a hold time: `'never'` passes through; a number is clamped into FBS_HOLD_SECONDS_RANGE (NaN/negative junk → the default).

clampFbsMaxAutoBands

@openmixer/coreClamp the auto-band cap into FBS_AUTO_BANDS_RANGE; junk → the default.

clampFbsMergeCents

@openmixer/coreClamp the merge radius into FBS_MERGE_CENTS_RANGE; junk → the default.

clampFbsNotchQ

@openmixer/coreClamp a planted-notch width (Q) into the notch shape's extent (EQ_NOTCH_Q_RANGE, 0.3..116); junk → `116`, today's plant.

clampFbsSensitivity

@openmixer/coreClamp a detection sensitivity into [0..1]; junk (NaN/±∞) → `0`, the SAFE default (an unreadable value must never silently raise aggression).

clampFilterFreq

@openmixer/coreClamp a pass-filter cutoff into its allowed band (HPF low, LPF high).

clampFreq

@openmixer/coreClamp a frequency into the audible band; NaN → the default reference tone.

clampGainDb

@openmixer/coreQuantize to the preamp's step and clamp into its travel — the ONE place a GAIN is made representable, so a stored value, a knob and a southbound write cannot round differently.

clampGroupGain

@openmixer/coreClamp a group's linear gain to be non-negative (a negative gain is nonsense; `0` = silence).

clampHrpAmount

@openmixer/coreThe operator's authority, clamped into its declared travel.

clampHrpMaxAutoBands

@openmixer/coreThe per-channel band cap, clamped into its declared travel and never fractional.

clampLevel

@openmixer/coreClamp a level into the 0..1 range (a linear generator volume); NaN → 0.

clearOnAbsentFactsOf

@openmixer/coreThe facts whose declared absence semantics is `clear` (spec revision 3, #665): on a whole-state restore, each of these returns to its fresh-strip state THROUGH ITS OWN DOOR whenever the file carries none of its snapsh…

clipboardPartsOf

@openmixer/coreReplaces `PART_FIELDS`: which facts each AtomicChannelPart carries, grouped from CHANNEL_CONTRACT.clipboard rather than hand-listed.

coarseDelayOf

@openmixer/coreThe COARSE delay: where the cross-correlation of the pair peaks.

codedMessage

@openmixer/coreBuild a coded message.

coerceBusesToQuantum

@openmixer/coreBring an arbitrary BusAllocation onto the STRIP_QUANTUM grid, **reporting** every count it had to move.

collapsePhysicalInputs

@openmixer/coreCollapse a stored input-patch set to **at most one physical input** — the load-time migration for the settled one-physical-input-per-channel rule (see InputPatchbay).

compParamOf

@openmixer/coreValidate a generic compressor control id + value against the `compToParams` vocabulary: numeric ids reject strings and booleans, `on` needs a boolean, `kind` one of the two enum members.

compToParams

@openmixer/coreA CompState as the generic param list (the standard view).

consoleMuteGroups

@openmixer/coreThe console's mute groups as a load must apply them: the snapshot's own list, plus any group a LEGACY `safety.muteGroups` still declares that the body does not (audit D6).

consolePersistsAnyFact

@openmixer/coreDoes ANY console fact ride the session?

consoleProfileById

@openmixer/coreThe profile for an id, or the default `openmixer` profile when unknown/absent.

contractCensus

@openmixer/coreEvery enumerable contract's facts, both axes.

contractDeclares

@openmixer/coreDoes the contract declare fact `fact` on kind `kind`?

contradictionSignature

@openmixer/coreA stable signature for a set of contradictions, so a caller surfaces each one ONCE rather than on every poll of an unchanged disagreement.

countRange

@openmixer/coreThe travel of a control over an INTEGER COUNT — how many channels, how many buses, which channel a stagebox starts at, how many bands the corrector may place.

createdAt

@openmixer/coreThe item exists now, under this id.

dbFromJson

@openmixer/coreDecode a JSON `db` back to a number (`null` → `-Infinity`).

dbToJson

@openmixer/coreEncode a `db` (which may be `-Infinity`) for JSON.

dbToLinearGain

@openmixer/coredB → linear amplitude (0 dB → 1, −6 dB → ~0.501).

dcaMasterGain

@openmixer/coreThe composed linear gain of a DCA master including its parents (VCA nesting): `master · Π parentEffective`.

dcaScaleFor

@openmixer/coreThe product of every DCA master a channel belongs to (each master itself composed with its VCA parents).

decibels

@openmixer/coreTag `n` as Decibels.

decodeOscMessage

@openmixer/coreDecode a single (non-bundled) OSC message.

defaultAllocation

@openmixer/coreA sensible **default console allocation** for a fresh server / new session — a small live console the operator can mix on immediately: DEFAULT_INPUT_CHANNELS input channels, a stereo main, 8 aux (monitor) sends, 8 sub…

defaultBusChain

@openmixer/coreThe default **bus-master** processor order — the Roland R5 finding: an AUX / group / main / matrix output bus carries the same EQ + dynamics + inserts + DYN↔EQ swap as an input channel ("as on the other output buses, …

defaultBusStereo

@openmixer/coreWhether a bus of a given kind defaults to **stereo** (distinct L/R).

defaultChannelChain

@openmixer/coreThe default channel processor order — our canonical layout, now the DEFAULT (NOT fixed): `trim/HPF → insert A → gate → EQ → dynamics → insert B → fader → insert post`.

defaultCompState

@openmixer/coreThe default console compressor (the model-shape CompState, the sibling of `defaultEqState`): off, a firm 4:1 ratio at −18 dB with a fast 5 ms attack and a musical 200 ms release, no make-up.

defaultEqState

@openmixer/coreThe default console EQ: a sensible flat starter set of generic bands — a low shelf, two bells, and a high shelf, all on at 0 dB — over the desk's dedicated HPF/LPF pass filters (parked and off).

defaultMixerApiUrl

@openmixer/coreThe base URL of the entity door a client dials when nothing is configured — reads and writes alike (`?watch=1` on any GET is the stream).

deriveInsertPlacement

@openmixer/coreWHERE this chain's hosted plugins actually cut the lane — one entry per DISTINCT native insert point that hosts at least one live plugin, in walk order.

deriveStageOrder

@openmixer/coreDerive the native stage-order step list from a strip's chain — the built-in stage nodes AND the strip's racked insert points, in chain order, as their stage ids.

descriptorOf

@openmixer/coreBuild a ControlDescriptor from a declared range plus the availability the caller resolved — a thin read of descriptorOfLimit, the one constructor, through the one range→limit transcription (`gainTravelOf`).

descriptorOfLimit

@openmixer/coreThe descriptor for a control whose travel is DECLARED — a processor's limit table entry.

detectGPUs

@openmixer/coreEnumerate the local GPUs.

detectStageboxes

@openmixer/coreDetect the REAC stageboxes among the patchbay's live sources + sinks, grouping each box's capture node (inputs) and playback node (outputs) into one StageboxDevice.

differingFields

@openmixer/coreThe state fields whose values differ between two readings of one row, sorted.

diffHardware

@openmixer/coreDiff a session's HardwareManifest against what is present, returning the absent devices with what the restored show depends on each for (issue #154).

diffKeys

@openmixer/coreCompares two objects and returns an array of keys where their JSON.stringify values differ.

directOutTapPointsOf

@openmixer/coreThe point ids a DIRECT OUT may feed from, in signal order — the desk's own second offer where it has one (Roland), and sendTapPointsOf where it does not.

discoveryOutcome

@openmixer/coreClassify a discovery pass into its DiscoveryOutcome.

effectiveChannelGain

@openmixer/coreA channel's effective linear gain: its own fader gain times the combined DCA scaling (dcaScaleFor).

effectiveChannelMute

@openmixer/coreA channel's effective (audible) mute: its own individual mute OR any active mute group it belongs to OR a held panic (#404, #178).

effectiveSafeScopes

@openmixer/coreThe scopes a recall exempts, given one channel's decision — `all` means all of them.

emptyPatch

@openmixer/coreAn empty routing graph (nothing patched).

emptyRecallSafe

@openmixer/coreAn empty mask (nothing safed).

emptySafety

@openmixer/coreA safety snapshot with everything empty and the default panic target.

emptyTapState

@openmixer/core—

encodeOscMessage

@openmixer/coreEncode a complete OSC message (address + typed args) into one datagram-ready Buffer.

enumMap

@openmixer/coreA PARTIAL map from one closed key vocabulary to one closed value vocabulary — the value an "override per case" field carries (the processing view's arrangement pinned per screen class, `2026-08-04-processing-view-layo…

enumOf

@openmixer/coreOne of a closed set of string values.

enumParam

@openmixer/coreBuild an enum (choice) processor param.

enumSet

@openmixer/coreA SET drawn from a closed vocabulary — canonically ordered and deduplicated.

enumValue

@openmixer/coreRead an enum param's value by id.

eqBandIsIdentity

@openmixer/coreTrue when `band`, as currently configured, is mathematically IDENTITY — its RBJ cookbook section reduces to `H(z) ≡ 1` for every sample, whatever its frequency or Q, so running it changes nothing.

eqCoeffs

@openmixer/coreFold an EqState into the ordered biquad-coefficient cascade the native mixer runs — the coefficient counterpart of the engine's `eqSections`.

eqCurveDb

@openmixer/coreThe summed response of a set of bands across a log-spaced frequency axis.

eqPresetById

@openmixer/coreLook up a preset by id from the FULL definition set (including a layout not currently OFFERED because its nominal count exceeds EQ_MAX_BANDS, e.g.

eqPresetPassFilters

@openmixer/coreEvery preset seeds the SAME parked HPF/LPF (operator amendment): 80 Hz / 12 kHz, OFF until the operator engages them.

eqToParams

@openmixer/coreAn EqState as the generic param list.

evaluateInsertSuitability

@openmixer/coreRun a check set over a chain and fold the findings.

exceedsBusCap

@openmixer/coreWhether the gig's N exceeds the single-tier mixer-tree cap (so buses get clamped and a deeper tree would be needed for "every input → every bus").

expandParts

@openmixer/coreResolve a selection to the atomic parts it covers.

factCarriedBy

@openmixer/coreThe one question the paste asks about a fact: does this channel carry it right now?

factCasesOf

@openmixer/coreGENERATE the persistence obligation from CHANNEL_CONTRACT: one FactPersistenceCase per (fact, kind) pair the contract actually declares — every kind in `kinds`, crossed with the fact's own `persisted` bit.

factRowAddress

@openmixer/coreWHERE a fact is served — its ChannelFactDecl.servedAs mold, or the default `/channel/{kind}/{index}/{fact}` when it declares none.

factsServedAt

@openmixer/coreThe facts served at one address mold — the UNION a consumer needs, because two facts can share a row (`sends` and `toMain`; `members` and `parents`).

faderDbOnWire

@openmixer/coreA level as the WIRE carries it: brought inside the travel the row DECLARES.

faderFromDb

@openmixer/core—

faderFromPosition

@openmixer/core—

faderScale

@openmixer/coreView a dB-valued Param as the model's FaderScale — the fader's value IS dB, so position→dB is `fromNorm` and dB→position is `toNorm`.

fbsPoolFor

@openmixer/coreThe detector pool an arming mode's finds belong to (`off` arms nothing).

fbsTagFor

@openmixer/coreThe origin tag for a find from the given detector pool.

featureMatrixOf

@openmixer/coreTHE per-kind feature matrix — the default feature rows as a pure function of CHANNEL_CONTRACT, never a hand-kept table.

featureMatrixWith

@openmixer/coreThe contract's default matrix (featureMatrixOf) with per-kind **deviations** applied — the "counts + deviations" idiom for a desk that mostly matches the contract but genuinely differs on a kind or two: a device with …

featureWordsOfFact

@openmixer/coreThe capability WORDS a fact projects into the 15-word feature vocabulary — empty for the majority of facts, which is the asymmetry this spec names outright ("the contract serves ~30 facts through 15 feature words").

fftInPlace

@openmixer/coreTransform `re`/`im` in place, length `n = re.length`.

fieldsFor

@openmixer/coreThe fields a selection would read or write.

filterSnapshotForRecall

@openmixer/coreProduce the snapshot that a recall would actually apply, with the recall-safed channels / scopes removed.

finiteNumber

@openmixer/coreA finite number, CLAMPED into [min, max] — the desk's legal travel has the last word.

finiteNumberOf

@openmixer/coreThe codec for a field whose travel is DECLARED — the declaration passed WHOLE, not transcribed field by field.

fitAlignment

@openmixer/coreFold a run of paired frames into the four numbers.

fixedKindChannelAddress

@openmixer/coreThe channel address of a template that fixes the kind literally — `/channel/muteGroup/{i}`, `/channel/dca/{i}/members`.

formatBoxModel

@openmixer/coreFormat reac-pw's `reac.box-model` prop into its display form — the Roland model number (`'s0808'` → `'S-0808'`, `'S-4000S'` → `'S-4000S'`).

formatRefusal

@openmixer/coreOne prose rendering of a refusal, for logs and legacy `reason` fields — never for clients.

framesToMs

@openmixer/coreConvert a latency expressed in audio frames to milliseconds at a given rate.

gainDescriptorOf

@openmixer/coreThe GAIN control descriptor for a preamp that declares `range` — the head-amp answer to "how far does this knob go, how finely, and may I move it?".

gainTravelOf

@openmixer/coreA declared dB travel's three numeric columns in the ControlLimit vocabulary — the ONE spelling of the `minDb`/`maxDb`/`stepDb` → `min`/`max`/`step` transcription.

gateToParams

@openmixer/coreA GateState as the generic param list (the standard view).

generatorByKind

@openmixer/coreLook up a generator by its kind.

generatorNodeName

@openmixer/coreThe PipeWire node.name each generator is published under.

generatorsOf

@openmixer/coreThe three generators as an ordered list (oscillator, white, pink).

ghostStageboxes

@openmixer/coreThe devices a patchbay must DRAW that no live node backs, from two independent sources.

groupsContaining

@openmixer/coreThe groups (of any kind carrying a `members` list) that contain a channel, in the order they are given.

growthSlope

@openmixer/coreLeast-squares slope (dB per frame) of a short trailing history of dB levels, oldest first — the "is this bin RUNNING AWAY" signal that separates real feedback from a sustained musical tone (see the module doc).

hardwarePresence

@openmixer/coreThe presence of an entity from the two independent facts.

harmonicBands

@openmixer/coreThe `hrp`-tagged band set describing one fundamental's correction.

harmonicDeviationGainsDb

@openmixer/coreA gain table for harmonicBands — `gainsDb[k]` is harmonic **k + 1**, negative for a cut, `0` for a partial that needs none.

hasOutputLeg

@openmixer/coreWhether an endpoint carries at least one leg (the ≥1-role invariant the schema enforces).

headAmpCapabilityOf

@openmixer/coreRead an input's analog head-amp capability from its declared `*Capable` flags.

headAmpCapabilityOfSource

@openmixer/coreThe analog head-amp capability a Source advertises — its captured Source.headAmp (resolved from the patched AdapterInput at patch time), or NO_HEAD_AMP when the source declares none (a raw/implicit endpoint, a legacy …

headAmpChannel

@openmixer/coreThe HEAD-AMP wire channel for a box input: `CH = modelBase + (boxInput - 1)`, decoded off an M-200 driving an S-0808 / S-1608 (`reac-firmware-re`, op `04 03` TAG `01 01`).

headAmpFeatureOf

@openmixer/coreIs this capability word one the patched INPUT declares, rather than one the desk's own DSP carries?

headAmpGainDefaultOf

@openmixer/coreThe declared reset/fresh target for a gain control over `range`, or `undefined` where that travel cannot hold it.

headAmpGainLimitOf

@openmixer/coreA preamp's declared travel as the ControlLimit that rides OPTIONS — the ONE translation between the capability's vocabulary and the wire's, so a row publishing a gain travel and a row clamping one cannot spell it two …

headAmpGainRangeOf

@openmixer/coreThe GAIN travel a declared head-amp covers **at a given pad setting** — the capability's own HeadAmpGainRange, or the REAC travel for a capability that predates the field.

headAmpOf

@openmixer/coreExtract the HeadAmp props from a Source (what the engine applies at the head).

headAmpRowOf

@openmixer/coreCompose the HeadAmpRow a client reads, from the stored record plus the capability the patched input declared.

holdOf

@openmixer/coreThe codec for a hold field: one of the declared scopes, or `null` for all-clear.

hostsInsertPlugin

@openmixer/coreWhether this processor HOSTS a live plugin — a slot carrying an LV2 URI that is not bypassed to a pass-through.

hrpLadder

@openmixer/coreA per-harmonic array of `length` entries built from a sparse list of (harmonic, value) pairs — the shape HrpVoiceMeasurement wants, from the shape both measuring tiers produce.

hrpMinConfidenceFor

@openmixer/coreThe confidence floor that goes with a search budget of `maxVoices` — half a voice's fair share.

hrpResonanceScore

@openmixer/core§24's resonance score, the documented formula: the AUTHORISED CUT (which already folds in the measured deviation, the excess threshold and the operator's amount — see `harmonicDeviationGainsDb`) weighted by how sure t…

hrpSearchFor

@openmixer/coreThe search hint for a channel's assigned instrument family, or `undefined` where none is assigned — and `undefined` is the honest answer, not a copy of the wide defaults: the C's `omx_hrp_config_default` is their one …

hrpVoiceCandidates

@openmixer/coreEvery voice's scored correction candidates, unranked and uncapped.

hzToBin

@openmixer/coreThe (fractional) bin holding `hz` in a transform of `fftSize` at `sampleRate`.

inputChannelIds

@openmixer/coreThe input ChannelIds the allocation declares (`input/1 … input/N`).

inputWidthOf

@openmixer/coreThe width of input channel `index` (1-based) in an allocation — `stereo` when declared, else `mono` (the default; an allocation with no `inputWidths` is an all-mono console).

insertDestinationFor

@openmixer/coreThe destination record for a bus: its policy-declared role if the operator set one, otherwise the role its kind defaults to, plus the rate the judgement will use and where that rate came from.

insertPointRealised

@openmixer/coreWhether a hosted plugin declared at `at` RUNS there.

insertPointSlug

@openmixer/coreThe port-name slug for insert point `point` — `Post-Trim` becomes `post_trim`, so the node's ports read `insert_post_trim_send_9_L` and an operator looking at the graph sees WHICH channel's insert, at WHICH declared p…

insertRoleForKind

@openmixer/coreThe default InsertRole for a bus kind (see INSERT_ROLE_BY_KIND).

insertStageId

@openmixer/coreThe stage id that names insert point `point` (0-based).

insertWidthFits

@openmixer/coreWhether a plugin with `legs` audio output legs RUNS on a strip of this width without the substrate inventing a fold.

insertWidthRefusal

@openmixer/coreThe refusal for a plugin too wide for the strip it is racked on (ruling 2026-09-02, tap-points spec): one builder, so the rack door and OPTIONS carry identical args.

instrumentFamilyOf

@openmixer/coreThe family a factory template belongs to, or `undefined` for an id this desk does not know.

intWithin

@openmixer/coreAn INTEGER within [min, max].

isBandId

@openmixer/coreWhether this is a band ID — a BARE POSITIVE INTEGER, spelled without a sign, a leading zero or anything else (`"1"`, `"12"`; never `"0"`, `"01"`, `"1.5"`, `"sort"`).

isBandOrigin

@openmixer/coreNarrow an arbitrary tag to a known BandOrigin.

isBoxInput

@openmixer/coreWhether a leg names a box input rather than a port.

isBusKind

@openmixer/coreIs `kind` an **audio bus** — a channel kind that carries and sums audio (a routing/summing node with a master strip)?

isCandidateBin

@openmixer/coreA bin passes the instantaneous multi-criteria test (before persistence confirms it).

isChannelConfigMove

@openmixer/coreWhether an unknown wire value is one ChannelConfigMove — a fact this contract names, a snapshot field a config carries, and scalar sides when present.

isChannelFact

@openmixer/coreIs this name a declared ChannelFact?

isChannelFullySafe

@openmixer/coreWhether the whole channel is safed (nothing on it is overwritten by a recall).

isChannelKind

@openmixer/coreType guard: is `s` a valid ChannelKind?

isChannelPart

@openmixer/coreIs this name a selectable ChannelPart?

isCodedMessage

@openmixer/coreWire guard: is `v` a well-formed coded message — a known code plus a flat record of scalars?

isCodedRefusal

@openmixer/coreIs `err` a coded refusal (carrying a translatable code + structured params)?

isConsoleProfileId

@openmixer/coreNarrow an arbitrary string to a known console-profile id.

isCorrectionNotice

@openmixer/coreTrue when a wire value spells a CorrectionNotice.

isDefaultEqState

@openmixer/coreTrue when `eq` is exactly the fresh defaultEqState — the flat starter every channel is seeded with.

isEmptyPatch

@openmixer/coreWhether a patch snapshot carries no routing at all.

isEqBandType

@openmixer/coreNarrow an arbitrary string to a known EqBandType.

isFbsTag

@openmixer/coreTrue when `tag` marks a band as FBS-planted — the ONLY bands the corrector may ever modify or remove.

isFftLength

@openmixer/coreWhether `n` is a length this transform accepts: a power of two, at least 2.

isFieldKey

@openmixer/coreisKeyOf over a scalar field table.

isFoldOutputEndpoint

@openmixer/coreWhether an endpoint folds a stereo bus onto ONE mono port — see outputEndpointFoldPort.

isGrowing

@openmixer/coreWhether a bin's trailing dB history shows a genuine RUN-AWAY trend — the ramp gate PersistenceTracker.push confirms on.

isHeadAmpChannel

@openmixer/coreIs `ch` a legal HEAD-AMP / chanmap wire channel (`0x00..0x2f`)?

isInMuteGroup

@openmixer/coreWhether a channel is a member of a given mute group.

isInputChannel

@openmixer/coreIs the channel address an **input** (source) channel, as opposed to any bus/group/monitor?

isInsertRefusedError

@openmixer/coreIs `err` a refused insert?

isKeyOf

@openmixer/coreValidated narrowing of a wire key into ANY exhaustive per-field table — the audited bridge.

isMagnitudeSeries

@openmixer/coreWhether `value` is a magnitude series of either shape — the ONE guard, so no reader keeps an `Array.isArray` that a typed array silently fails.

isMessageCode

@openmixer/coreIs `code` a code this bridge knows (and therefore one the catalog carries)?

isMonoOutputEndpoint

@openmixer/coreWhether an endpoint is a single-leg (mono) destination — exactly one role present.

isNativeStageKind

@openmixer/coreWhether `kind` is one of the reorderable NATIVE stages (and so has a stage id).

isPhysicalInputPort

@openmixer/coreWhether a source port is a PHYSICAL INPUT — a preamp channel that OWNS a head-amp — as opposed to an app or internal stream.

isPlantableRingHz

@openmixer/coreWhether a detected ring frequency may plant at all — the edge-clamp refusal.

isPositionTap

@openmixer/coreWhether a SendTapSpec is an explicit `{ position }` (vs a preset/legacy string).

isRecord

@openmixer/corePlain-object check for parsed/unknown JSON — the boundary guard every intake narrows with.

isResourceId

@openmixer/coreWhether a wire value is a ResourceId — a record of strings and numbers.

isRoutableOutputKind

@openmixer/coreIs `kind` a **routable output** — a channel kind whose tail can be routed to a physical sink through the output crosspoint (`patchbay.output`)?

isSaturatedPlateau

@openmixer/core#140 SATURATED-PLATEAU route — the second, opt-in confirm path for the explosive ring the ramp gate structurally rejects (a loop that jumps to near-clip in one hop, then HOLDS there, has no distributed multi-frame ris…

isScopeSafe

@openmixer/coreWhether a given scope is safed on a channel (`all` safes every scope).

isSnapshot

@openmixer/coreType guard to check if a given object is a Snapshot.

isSpectrumBandSeries

@openmixer/coreWhether a wire value is a SpectrumBandSeries — the shape, not its validity.

isStageboxAssignError

@openmixer/coreIs `err` a refused stagebox assignment (carrying a code + structured params)?

isStageboxKey

@openmixer/coreIs `value` a well-formed key?

isStageboxPort

@openmixer/coreDoes this port name a STAGEBOX?

isStereoEndpoint

@openmixer/coreWhether an endpoint is a **stereo pair** — two distinct ports (FL/FR, or any L≠R pair) from a source.

isStereoPatch

@openmixer/coreWhether a channel's patched source set is **stereo** — true when ANY of its summed sources is a stereo pair (isStereoEndpoint).

isTalkbackGeneratorPort

@openmixer/coreWhether a graph port belongs to a talkback GENERATOR node — the one predicate every reader shares (#177).

isTemplateVariable

@openmixer/coreWhether a template segment is a variable — `{index}` rather than `headAmp`.

isUndoSetParam

@openmixer/coreIs `param` one this bridge has an undo label for?

iterOscPacket

@openmixer/coreEvery message in a received packet.

jobLedgerRows

@openmixer/coreEvery row of the ledger table in `markdown`, in file order.

judgeChainLatency

@openmixer/coreJudge a chain's accumulated latency against its destination's budget.

keepOnePhysicalInput

@openmixer/coreSplit a channel's patch set by the one-physical-input rule (`2026-08-07-one-summing-bus.md` §3c): the FIRST physical input is kept, any later one is dropped, and soft sources always ride along — an application stream …

laneRuleOf

@openmixer/coreTHE lane rule behind a fact — the declaration a server `ControlDomain` spreads instead of hand-setting `onMasterLane` / `fansOutToMembers` beside the table (phase 3's deletion).

legacyTapPreset

@openmixer/coreMap a legacy two-way tap onto the preset it is an alias of.

legKey

@openmixer/coreA stored leg as a comparable STRING — the identity of the thing written down, not of the hardware it currently reaches.

legPort

@openmixer/coreThe port a stored leg points at RIGHT NOW, or `undefined` when it names an absent box.

levelSeriesSubset

@openmixer/coreThe bytes of a level series at `positions`, in that order, as a new series — a BYTE subset: no value is decoded and none re-quantised, so a client reading the subset through the same declared window reads exactly the …

levelSeriesU8

@openmixer/coreThe one-byte level series over `span` — SPECTRUM_LEVEL_LIMIT by default.

lifecycleOf

@openmixer/coreBuild a mold's lifecycle view, or `undefined` when the row declared no doors at all.

linearGain

@openmixer/coreTag `n` as a LinearGain.

linearGainToDb

@openmixer/coreLinear amplitude → dB — the exact inverse of dbToLinearGain, and the reason this one exists: without it the inverse direction was hand-rolled at every call site, which is how three different silence conventions (`1e-1…

linearOfDbfs

@openmixer/coreA dBFS level as the linear 0..1 peak a meter draws; the codec's floor (and below) is silence.

linearOfPosition

@openmixer/coreThe inverse of positionOfLinear — a surface position as a linear amplitude.

lowTierGainDb

@openmixer/coreThe dB correction that level-matches a LOW-tier band to the HIGH tier's reference (issue #97).

machineOwnedBands

@openmixer/coreEvery band on a channel owned by SOME known planter — the numerator of the joint machine-band budget, whose denominator is the channel's free-slot count.

magToDb

@openmixer/coreLinear magnitude to dBFS.

mainSumViaSubgroups

@openmixer/coreThe total signal reaching the main mix through every subgroup: each group's bus level, scaled by its group→main send, all summed.

makeBandId

@openmixer/coreA fresh band id: the LOWEST number not already used in `existing` — deterministic, so add/remove keeps stable, collision-free ids without a shared counter or a clock read.

makeFbsChannelState

@openmixer/coreA fresh, disarmed FBS state with the operator defaults.

makeHrpChannelState

@openmixer/coreOFF, and correcting nothing.

makeParam

@openmixer/coreBuild a live Param from its spec.

makeSource

@openmixer/coreBuild a Source with neutral preamp defaults (normal gain, pad/phantom off) for a given id + patch.

makeSourceFromInput

@openmixer/coreBuild a Source patched to a specific AdapterInput, stamping the input's DECLARED head-amp capability (headAmpCapabilityOf) onto Source.headAmp — the honest, capability-driven way to register a source, so the channel i…

makeTalkbackSection

@openmixer/coreA fresh talkback section: a stopped 1 kHz sine + stopped white/pink noise, mic idle.

matchTemplate

@openmixer/coreMatch one template against already-split segments, capturing the braced ones.

memberContains

@openmixer/coreWhether a channel is a member of a group's member list.

meterFill

@openmixer/coreA linear peak (0..1, where 1 = 0 dBFS) → display fill (0..1) on a **dB** scale, linear-in-dB between METER_FLOOR_DB and 0 dBFS.

micRoutesAudible

@openmixer/coreWhether the measurement microphone can reach a loudspeaker — the door's safety test.

moveToIndex

@openmixer/coreExpress "put this processor at flat index `to`" as the PLACEMENT that produces it — the one translation a drag-and-drop surface needs, and the only way an index-shaped request reaches the model now.

mutedByGroup

@openmixer/coreWhether any **active** mute group masks this channel.

muteGroupMembers

@openmixer/coreThe members of a mute group by id, or an empty array if no such group.

namedIndexAddress

@openmixer/coreA one-segment address whose value is a dense 0-BASED INDEX under `key` — a position in an ordered set the console keeps (a USER page in `/surface/pages/{index}`).

namedTextAddress

@openmixer/coreA one-segment address whose value is opaque TEXT under `key` — a stored id, a graph node id, anything the console addresses by a name it did not invent.

nativeAttempt

@openmixer/coreRun ONE native actuation and report what the audio did — the boolean→refusal narrowing, written once.

nativeInsertPointOf

@openmixer/coreThe native insert point index a declared tap point names, or `undefined` if the walk has no cut there (`Top-Of-Ch`, `Post-Fader`, an undeclared point, or none at all).

noClip

@openmixer/coreThe latch of a channel that has not clipped since its last clear — the row's fresh state.

nonEmptyText

@openmixer/coreOperator text that must actually say something — the NAME a stored item is created under.

noRecallSafe

@openmixer/coreA channel nobody has safed: not exempt from anything.

normalizeChain

@openmixer/coreEnforce the chain's structural invariants — the **G-EQ discipline** (task #101) plus the structural fader — returning a NEW normalized chain (pure; input untouched): - **Exactly one `eq` node.** Duplicate EQ nodes col…

normalizeEqBand

@openmixer/coreA band in its canonical shape: the identity it was given, its parameters, and the display and origin data it carries.

normalizeEqState

@openmixer/coreBring a persisted/session EqState to its canonical shape: every band carries an id (withBandIds), the pass filters carry through untouched.

normalizeFbsChannelState

@openmixer/coreLoad a persisted FbsChannelStateJson gracefully (the `normalizeEqBand` idiom): a pre-#116 `holdMinutes` becomes seconds, a current shape passes through untouched, and a shape with neither key gets the default hold.

normalizeHrpChannelState

@openmixer/coreA stored state read back into the model, with every field clamped and an unknown mode falling back to OFF — a session written by a newer desk must never arm a corrector this one cannot run.

notCreated

@openmixer/coreNothing was created, and this is why.

notProjected

@openmixer/coreDid not reach the audio.

notRemoved

@openmixer/coreThe item is still there, and this is why.

nullableEnumOf

@openmixer/coreOne of a closed set of string values, or `null` — the value a HELD-scope latch carries: `/safety/panic`'s engaged scope, where `null` IS the released state, a real value distinct from every member of the vocabulary.

nullableFiniteNumberOf

@openmixer/coreA finite number CLAMPED into a declared travel, or `null` — the value of an OPTIONAL level: `null` says nothing is set, so whatever the declaration derives (a floor, a default, a lower layer) wins again.

nullableIntWithin

@openmixer/coreAn INTEGER within [min, max], or `null` — the value an OPTIONAL numeric setting carries (a persisted port override; `null` is the value that says nothing is set, so a lower config layer wins again).

nullableToken

@openmixer/coreAn identifier token, or `null` — the value a "which registered thing backs this" field carries.

numberedRoleLabel

@openmixer/coreThe role + 1-based number for a channel: "Aux 3", "Group 2", "Matrix 1", "DCA 4".

numberEnum

@openmixer/coreOne of a closed set of NUMERIC values — a sample-rate menu, a quantum ladder.

numberOrText

@openmixer/coreA value that is a number OR a string, which is what an `lv2:Parameter` (the LV2 Patch extension) carries: a threshold is a float, a cabinet impulse is a path.

numberParam

@openmixer/coreBuild a numeric processor param.

numberValue

@openmixer/coreRead a numeric param's value by id (throws if absent or wrong kind — the layout is fixed per kind).

offersOnlyDeclaredTapPoints

@openmixer/coreWhether every point a profile OFFERS is one its skeleton DECLARES.

orderPlaced

@openmixer/coreTHE DERIVATION: the effective processing order — point order first, then sort within point.

orphanedHotInputs

@openmixer/coreThe physical inputs in `hot` that NO channel sources any more — the honest set difference behind "48 V is still on a socket nothing is patched to" (#384).

oscString

@openmixer/coreEncode an OSC string: UTF-8 bytes, a NUL terminator, then NUL padding to the next 4-byte boundary.

outputEndpointFoldPort

@openmixer/coreThe single MONO port a multi-leg endpoint FOLDS onto — the port every present leg names — or `undefined` when the endpoint's legs address distinct ports (a real per-leg destination).

outputEndpointLegs

@openmixer/coreThe present legs of an endpoint in canonical role order — the forward-compatible iterator every consumer uses instead of assuming exactly `L`/`R`.

outputRouteDelayMs

@openmixer/coreA route's per-destination delay in ms — the persisted `delayMs`, or 0 (no delay) when absent.

outputRouteEndpoint

@openmixer/coreThe leg-aware endpoint of a persisted route (its role→port map without the trim fields).

outputRouteIsMono

@openmixer/coreWhether a route addresses a single (mono) destination leg — the fold candidate.

outputRouteLegs

@openmixer/coreA route's present legs in canonical role order.

outputRouteMonoFoldDb

@openmixer/coreA route's per-leg mono-fold attenuation in dB — the persisted `monoFoldDb`, or DEFAULT_MONO_FOLD_DB when absent.

outputRouteMuted

@openmixer/coreWhether a route is muted — the persisted `mute`, or `false` when absent.

outputRouteTrimDb

@openmixer/coreA route's trim in dB — the persisted `trimDb`, or 0 (unity) when absent.

overlayStageboxContradictions

@openmixer/coreOverlay each detected box with the disagreements between what was WRITTEN DOWN about it and what it reports — the same single seam overlayStageboxNames occupies for the registry name, so every stagebox-producing path …

overlayStageboxIds

@openmixer/coreOverlay each detected box with its registry identity — the stable `boxId` the console minted when the box enrolled — resolved from its recognition key.

overlayStageboxNames

@openmixer/coreOverlay operator names from the persistent registry onto a freshly-detected device list: each box whose KEY resolves to a stored name is re-labelled through stageboxWithOperatorName; every other device passes through …

overlayStageboxPresence

@openmixer/coreOverlay each detected box with its StageboxDevice.presence — the third seam beside overlayStageboxNames and overlayStageboxContradictions, for the same reason: one place computes it, so every stagebox-producing path p…

owedJobs

@openmixer/coreThe jobs still owed a round-trip proof, in ledger order.

ownerOf

@openmixer/coreWHO OWNS fact `fact` in context `ctx` — the contract's `owner` column made evaluable (phase 3).

ownsBand

@openmixer/coreDoes `origin` own `band`?

panGains

@openmixer/coreThe L/R gain a `pan` position distributes a signal to when it feeds a **stereo** bus (constant-power / −3 dB pan law).

panicEngaged

@openmixer/coreWhether a held panic silences this channel.

panicMains

@openmixer/coreThe channels a MAINS-MUTE panic silences: the session's configured mains, or the default main bus when none is configured.

papr

@openmixer/corePAPR — peak-to-average power ratio, in dB.

paramOf

@openmixer/coreHydrate a numeric param's spec into a live Param (for rendering / formatting).

paramsToComp

@openmixer/coreReconstruct a CompState from the generic param list — inverse of compToParams.

paramsToEq

@openmixer/coreReconstruct an EqState from the generic param list — inverse of eqToParams.

paramsToGate

@openmixer/coreReconstruct a GateState from the generic param list — inverse of gateToParams.

paramsToState

@openmixer/coreReconstruct a processor's typed state from the generic param list, dispatched by chain kind.

parseChannelKey

@openmixer/coreInverse of channelKey: parse a `"${kind}/${index}"` key back into a ChannelId.

parsePhysicalInputKey

@openmixer/coreThe inverse of physicalInputKey — recover the patch a key was built from, so a layer holding only the identity (the head-amp ledgers) can still name the PORT an operator sees.

parseSavedTake

@openmixer/coreNarrow a parsed JSON document to a SavedTake, or `undefined` when it is not one.

parseTakePrint

@openmixer/coreOne TakePrint, validated rather than asserted.

parseTakeRender

@openmixer/coreThe TakeRender block, or `undefined` when it is not a well-formed one.

partCarriage

@openmixer/coreHow one part fares against one target.

passFilter

@openmixer/coreThe pass filter of the given kind, defaulted (off, at its default cutoff) when unset.

patchFor

@openmixer/coreBuild a SourcePatch referencing an InputProvider's input.

pathBudgetRemaining

@openmixer/coreRemaining path budget for an O.H.R.C.A.

pdcCompensation

@openmixer/corePlugin-delay-compensation (PDC) math for one summing point (a bus).

permutationOf

@openmixer/coreA list that must be exactly a REORDERING of a live set — the roster's `strips`.

persistedFactsOf

@openmixer/coreReplaces `ChannelSnapshotJson`'s hand-listed field set: the facts the session persists, derived from CHANNEL_CONTRACT.persisted rather than kept as a second spelling.

persistedSnapshotFields

@openmixer/coreThe `ChannelSnapshotJson` fields the session persists — persistedFactsOf mapped through SNAPSHOT_FIELDS_OF_FACT.

phpr

@openmixer/corePHPR — peak-to-harmonic power ratio, in dB.

physicalInputKey

@openmixer/coreThe PhysicalInputId of a patch — the port identity that owns the head-amp.

piecewiseFromNorm

@openmixer/core—

piecewiseToNorm

@openmixer/coreEvaluate a piecewise taper directly on its breakpoints — the primitive behind a `{ kind: 'piecewise' }` Param.

placeChain

@openmixer/coreGive every node in `chain` a placement, leaving the ones that already carry a declared point untouched — the total read of a chain authored before the placements existed, or by hand.

planGhostReplacement

@openmixer/coreMove every channel patched to a departed box onto a present one, port for port.

planStageboxAssign

@openmixer/coreCompute the **bulk assignment** of a whole stagebox onto channels, each port keyed by **its own channel number**: `capture_NN → channel[startChannel + NN − 1]` for every port on the chosen side.

planStageboxFabric

@openmixer/corePlace every detected box's audio in the **40-slot AUDIO fabric**, the way the wire packs it: inputs front-packed from slot 0 up, outputs back-packed from slot 39 down — the ENROLL group map's own layout (input region …

pnpr

@openmixer/corePNPR — peak-to-neighbouring power ratio, in dB.

populateChainParams

@openmixer/coreReturn the chain with each bridged node's `params` populated from the strip's typed state.

position

@openmixer/coreTag `n` as a Position.

positionOfLinear

@openmixer/coreThe position ↔ dB ↔ linear round trip, written once.

presenceAdmitsWrite

@openmixer/coreMay a write to a hardware-backed entity in this state reach hardware?

presetAllocation

@openmixer/coreBuild a full ConsoleAllocation for an `IN:OUT` console size (see presetBuses).

presetBuses

@openmixer/coreMap an `IN:OUT` console size to a BusAllocation.

profileHasSection

@openmixer/coreWhether a processing section exists on this appliance (the gate for tabs/panels).

projectCarried

@openmixer/coreThe collection's state narrowed to the instances `keep` admits: the index subset (the entries as written, untouched) and, for every declared series the state carries, the SAME positions' bytes.

provenanceOf

@openmixer/coreThe provenance verdict for ANY contract's declaration, from its presentation columns alone — the one precedence, so a second contract cannot grow a second reading of the same two columns.

prunedToPersisted

@openmixer/coreA channel snapshot reduced to the address plus the contract's persisted fields — the walk session capture runs over every assembled channel row, so capture CANNOT emit a field the contract does not declare persisted, …

pshr

@openmixer/corePSHR — peak-to-subharmonic power ratio, in dB: the candidate bin's level minus the strongest spectral line near bin/2 or bin/3 (±SUBHARMONIC_RADIUS_BINS bins).

quantumLatencyMs

@openmixer/coreThe base buffering latency of one PipeWire processing cycle, in milliseconds: `quantum / sampleRate * 1000`.

rbjCoeffs

@openmixer/coreThe RBJ cookbook section, normalised (a0 folded to 1) to the `[b0, b1, b2, a1, a2]` tuple the engine runs — the native mixer's `omx_biquad` consumes exactly this.

rbjSection

@openmixer/coreThe RBJ Audio-EQ-Cookbook section for one biquad.

readChainParams

@openmixer/coreRead a populated chain's node params back into the strip's typed state — the inverse of populateChainParams for the bridged kinds.

readOnlyCodeOf

@openmixer/coreThe code `OPTIONS` publishes and a `PATCH` refuses with — see REFUSAL_BY_OWNER.

recallKeepsNothing

@openmixer/coreTrue when the recall governs everything it would touch — nothing is left standing.

recallKeptCollections

@openmixer/coreDiff the LIVE console against the SNAPSHOT a recall is about to apply, and return the console-level collections that would be KEPT rather than restored — the surprise the operator's double-confirm guards.

recallSafeMaskOf

@openmixer/coreDERIVE the console-wide RecallSafeMask from the per-channel rows.

reconcileStagebox

@openmixer/coreReconcile a written-down stagebox against the one on the wire.

recordDefaultFor

@openmixer/coreThe kind-based RECORD-ARMING default — what a channel answers before anyone touches its `/record` row (recording-vsc §0.2: "every PATCHED input + MAIN armed by default … Aux/matrix are NOT recorded unless asked").

recordOf

@openmixer/coreA keyed record whose every value narrows through ONE member codec — `source → policy`, a name-keyed table of enum members.

recordTapsDefaultFor

@openmixer/coreThe kind's DEFAULT tap set — what a channel nobody has touched captures.

recordTapsOfferedFor

@openmixer/coreThe tap points THIS KIND offers the recorder — an ordered subset of RECORD_TAP_POINTS.

reduceSpectrumBands

@openmixer/coreReduce an already-banded reading to `nOut` bands over the same range.

referencedAssetUrls

@openmixer/coreEvery same-origin asset URL a prerendered page references — the stylesheet, the entry chunk, the module preloads, the payload, the icon.

refused

@openmixer/coreThe refused arm of a PatchOutcome — `accepted: false` plus its code, spelled once.

reorderAllowed

@openmixer/coreWhether the appliance's ProcessingOrderMode PERMITS a reorder that changes the relative order of two processing stages `a` and `b` — the gate that makes `processingOrder` real (the server rejects a `chain.reorder` / `…

requireSuitable

@openmixer/coreThrow the first blocking finding of a report as an InsertRefusedError, unless the operator explicitly overrode it.

resolveEndpoint

@openmixer/coreResolve a stored endpoint against the live graph.

resolveInsertSuitabilityPolicy

@openmixer/coreFill a partial InsertSuitabilityPolicy out to a ResolvedInsertSuitabilityPolicy.

resolveOutputEndpointOntoActiveProfile

@openmixer/coreRe-point `ep`'s legs onto the ACTIVE profile of each named device, given the live sink `inventory` (#181).

resolvePhysicalInput

@openmixer/coreResolve a `<node>:<port>` capture port to the physical input it carries, or `undefined` when no adapter declares it (an app stream, a line/ADAT port, any non-preamp source — the actuators no-op on those).

resolveRecordTaps

@openmixer/core**THE TAP-SET DERIVATION** — the points a channel records at, from whatever it has stored.

resolveResourcePolicy

@openmixer/coreFill a row's declared policy in with the defaults.

resolveTap

@openmixer/coreResolve a SendTapSpec against a live channel chain to a ResolvedTap.

resolveTemplate

@openmixer/coreResolve a concrete path against a set of templates — **the most LITERAL match wins.** So a future `/channel/main/{index}/mute` beats the generic `/channel/{kind}/{index}/mute` without either declaration knowing about …

resourceIdOf

@openmixer/coreInverse of channelIdOf: the ResourceId a broadcast frame carries for a channel.

restore

@openmixer/coreRestores the data from a snapshot.

roleLabel

@openmixer/coreThe role label for a channel kind: "Aux", "Group", "Matrix", "DCA", "Main", …

roundToNearestQuantum

@openmixer/coreRound a **derived** bus count to the *nearest* whole STRIP_QUANTUM (ties round up), with a floor of one quantum so a tier never vanishes entirely.

roundUpToQuantum

@openmixer/coreRound a bus count **up** to a whole STRIP_QUANTUM.

routeChainParam

@openmixer/coreResolve a generic control on a chain node of `kind`.

routeCompParam

@openmixer/coreResolve a generic compressor control onto the `/dynamics` row's field.

routeEqParam

@openmixer/coreResolve a generic EQ control onto the EQ row that owns it.

routeGateParam

@openmixer/coreResolve a generic gate control onto the `/gate` row's field.

rowKey

@openmixer/coreOne row's ledger key: the path plus the id spelled loosely (`3` and `"3"` are one instance).

rtBudgetCodedMessage

@openmixer/coreThe `rt.budget` message for a reading — the wire/display form of rtBudgetMessage.

rtBudgetMessage

@openmixer/coreThe log/debug message shape for an RT load reading (task #121); UIs render their own localised sentence from the ratio — this string is not a display contract.

rtBudgetPercent

@openmixer/coreThe percentage of its real-time budget a busy ratio represents — the `rt.budget` param.

rtHeadroomProvider

@openmixer/coreBuild an RtHeadroomProvider over a live RtLoadSource.

safesSomething

@openmixer/coreWhether this channel's decision safes anything at all — what puts it in a derived mask.

sameArrangement

@openmixer/coreWhether two chains are the SAME ARRANGEMENT -- the same nodes in the same order, each carrying the same persisted fields.

sameOutputEndpoint

@openmixer/coreWhether two OUTPUT endpoints address the same legs — each role present in either maps to the same port, so a mono `{L:x}` differs from `{R:x}` and from `{L:x, R:y}`.

samePhysicalInput

@openmixer/coreWhether two patches address the SAME physical input (the same stagebox/reac-capture port).

sameResourceId

@openmixer/coreTwo ids address one instance when their fields spell the same values.

scalarRecord

@openmixer/coreAn open record of operator-entered SCALARS — an adapter's `settings`, any bag whose keys a per-type schema (not this codec) owns.

selectGPU

@openmixer/corePick the GPU to run on: the caller's `preference` (a GpuVendorName) when one of that vendor is present, otherwise the highest-DetectedGpu.rank card.

selectHrpCorrections

@openmixer/coreThe globally ranked, collision-free correction list (§29 + §30).

selectionCarriage

@openmixer/coreHow a whole SELECTION fares against one target — composites expanded, in the vocabulary's own order so two clients listing the same paste list it identically.

selectParts

@openmixer/coreCapture the selected parts of a channel.

sendTapPointsOf

@openmixer/coreThe point ids a SEND may feed from on this model, in signal order — what `OPTIONS …/send/{busKind}/{busIndex}` publishes as the `tap` field's `values`, and what its codec refuses everything outside of.

servedTap

@openmixer/coreThe ONE spelling a tap is SERVED as — the resolved TapPreset, or an explicit `{ position }` unchanged.

setGeneratorParams

@openmixer/coreApply a validated parameter update to a generator in-place, clamping level/frequency and ignoring oscillator-only fields on the noise generators.

setTalkbackRoute

@openmixer/coreSet (or clear, with `to === undefined`) the route of a generator or the mic slot.

sharedLaneRuleOf

@openmixer/coreThe ONE lane rule a family of facts shares — laneRuleOf over each, REFUSING at load if any two disagree.

sipSilenced

@openmixer/coreThe strip-level SIP predicate — the wire's half of `mixer_rt.c`'s `(cue_mode == OMX_CUE_SIP) && any_solo && !solo && !solo_safe`.

slotStateFromChain

@openmixer/coreRead a populated chain back into the strip's typed slot state `{ eq?, dynamics?, inserts?

snapshot

@openmixer/coreCreates a snapshot of the given data.

snapshotFromChain

@openmixer/coreSerialise a live Processor chain to its on-disk ProcessorSnapshotJson form — the strip's whole processing ARRANGEMENT as one ordered list.

soloSafeDefaultFor

@openmixer/coreThe kind-based solo-safe default (ChannelSnapshotJson.soloSafe is absent on a pre-feature session, or on any channel the operator hasn't explicitly overridden) — FX returns and matrix buses default exempt from SIP mut…

sortBandsByFrequency

@openmixer/coreThe same bands ordered by FREQUENCY and renumbered `1..n` in that order — the whole of the sort operation, as a pure function of the list.

sortBetween

@openmixer/coreA sort key that puts a node BETWEEN `before` and `after` within one point's segment.

spareFor

@openmixer/coreThe pre-declared spare input for a channel, or `undefined` when none is set.

speakerAlignAim

@openmixer/coreWHERE TO READ THE REFERENCE NEXT — the aim, and the whole of how the reach stopped being the overlap's.

speakerAlignCorrection

@openmixer/coreThe delay one output needs so its arrival at the microphone matches the REFERENCE output's.

speakerAlignOverlapReachMs

@openmixer/coreHow far ONE PAIR OF WINDOWS carries evidence: the delay at which the analysis window's own overlap drives coherence down to ALIGN_TRUST_COHERENCE, in ms.

speakerAlignReachMs

@openmixer/coreThe largest arrival the fit can express, in ms, for a window of `fftSize` at `sampleRate`.

speakerArrivalIsPhysical

@openmixer/coreWhether a measured arrival can be an acoustic one.

specOfLimit

@openmixer/coreA DECLARED TRAVEL as the ParamSpec a control renders — the one direction between the two shapes.

spectrumBandCentres

@openmixer/coreThe band tiling every consumer shares: `nBands` log-spaced bands from `fMin` to `fMax`, each answered by its GEOMETRIC centre.

spectrumBandsOf

@openmixer/coreA banded tap as the client draws it, from the wire's two series and the declaration the row published (`limit`) — the inverse of the desk's encoding.

spectrumSum

@openmixer/coreThe sum of a magnitude spectrum — computed ONCE per frame and handed to every per-bin papr so the floor is O(1) per candidate, not a scan of the whole spectrum.

splitPath

@openmixer/coreThe non-empty segments of a path.

stageboxAssignCollisions

@openmixer/coreWhich of a plan's ops would land on a channel that is already carrying something else.

stageboxConnected

@openmixer/coreIs a detected StageboxDevice backed by a REAL connected box, or is it just the reac-pw **bridge** probing an empty wire (issue #201)?

stageboxFabricPlacement

@openmixer/coreThe placement for one box side in a planStageboxFabric result, if it has one.

stageboxGroupLabel

@openmixer/coreThe patchbay group label a stagebox's nodes should carry so the I/O list buckets them under the device instead of listing them loose (satisfies "the detected nodes are added to the patchbay, grouped under the device").

stageboxKeyed

@openmixer/coreGive a detected REAC device its recognition key and address.

stageboxKeyOf

@openmixer/coreBuild a key from a transport and the parts that identify a box within it.

stageboxPatchIndex

@openmixer/coreThe two translations a stored patch needs, built from the boxes the desk currently sees: a live port → the box input it carries, and a box input → the port carrying it right now.

stageboxPortAt

@openmixer/coreThe group a 1-based port index falls in, or `undefined` when the box has no such port.

stageboxPortCount

@openmixer/coreHow many ports the groups describe in total.

stageboxPortHasControl

@openmixer/coreWhether the port at a 1-based index offers `control`.

stageboxTransportOf

@openmixer/coreThe transport a key was built for.

stageboxWithOperatorName

@openmixer/coreRe-label a detected StageboxDevice with an operator-supplied `name`, as if the box had advertised it — the seam the server's persistent registry (Build A) uses to restore a box's name by MAC.

stateToParams

@openmixer/coreA processor's typed state → the generic param list, dispatched by chain kind.

stationInstances

@openmixer/coreA station's instances as the wire spells them — the one place a mold turns "which addresses exist" into "which ids exist", so no mold re-derives the canonical spelling of an enumeration.

storeEndpoint

@openmixer/corestoreLeg for a whole endpoint, keeping `r` absent when the source is mono.

storeLeg

@openmixer/coreTurn a live port into what should be WRITTEN DOWN for it.

strandedInsertOf

@openmixer/coreThe first live plugin in `chain` racked at a point it does not run at, or `undefined` — the slot that makes every capture on the strip carry a plugin the arrangement puts elsewhere.

subgroupBusLevel

@openmixer/coreThe group bus's own output level: the sum of its members' post-fader signals, scaled by the group output gain (master · mute).

subgroupFeedsMain

@openmixer/coreWhether a captured bus folds back into the main mix.

subgroupOutputGain

@openmixer/coreThe gain the group applies to its summed input: the master, scaled by the mute (0 when muted, else the master).

subgroupsContaining

@openmixer/coreThe subgroups a channel is assigned into, in the order they are given.

subgroupsFromAllocation

@openmixer/coreThe default Subgroup set an allocation implies: one subgroup per allocated group (`mix`) bus, at unity master, un-muted, with no members yet and folding into main.

subgroupToMainGain

@openmixer/coreThe gain the group contributes to the main mix: its output gain times the group→main send, or 0 when the group does not feed main.

subsampleToCap

@openmixer/coreEvenly subsample `items` down to `cap` entries, keeping the first and last — so a layout that outgrows a hard cap loses DENSITY, not spectrum coverage.

substituteTemplate

@openmixer/coreThe inverse: the concrete path this id names under this template.

takeFileName

@openmixer/coreThe filename for the `index`-th track of a take: `ch01.post-trim.wav`, `ch02.post-fader.wav`, … — 1-based, because ChannelId is, and the operator reading the folder counts from one.

takePrintFileName

@openmixer/coreThe print's name, derived from the MAIN stem it was made from: `ch09.post-fader.wav` prints to `ch09.post-fader.print.wav`.

takeRenderFileName

@openmixer/core—

takeSummary

@openmixer/coreThe header of one stored take.

tap

@openmixer/coreFold one tap (timestamp `atMs`) into `state`.

taperOfScale

@openmixer/coreA FaderScale sampled into a piecewise Taper — the curve as DATA, so a client can draw a throw it does not implement.

tapLatencyPrefix

@openmixer/coreThe processors a tap's latency accumulates over: the chain prefix up to and **including** the tapped processor (index 0…tapIndex).

tapPointBoundary

@openmixer/coreResolve a tap point against an ordered, placed chain: the index of the LAST processor that runs strictly before the point, or TAP_AT_CHAIN_INPUT when nothing does.

tapPointCaptured

@openmixer/coreWhether the native substrate can take this point's audio.

tapPointDeclared

@openmixer/coreWhether `set` declares a point called `id`.

tapPointDefining

@openmixer/coreThe point a processor of `kind` is PINNED to, or `undefined` when nothing pins it.

tapPointIds

@openmixer/coreThe point ids of `set`, in signal order — what a contract publishes and a picker renders.

tapPointIndexOf

@openmixer/core`id`'s position in `set`, or `-1` when the set does not declare it.

tapPointSet

@openmixer/coreThe set with this id, or `undefined` — absence is a fact, not a fallback.

tapPointsOf

@openmixer/core**THE FUNCTION A ROW CALLS** to publish the tap vocabulary: the SKELETON this console model exposes, by profile id.

templateGateMatchesLaw

@openmixer/coreTrue when `t`'s gate arm state matches FACTORY_GATE_ON_IDS — gated ON only for a close-miked drum shell, off everywhere else.

templateLawViolations

@openmixer/coreOne template's law violations, empty when it fully complies.

templateLiteralCount

@openmixer/coreHow many of a template's segments are literal — the specificity a tie-break is decided on.

templateOpensOnHpf

@openmixer/coreTrue when `t` arms its high-pass — every template opens on a corner tuned to its source (the one universal move: cut what the source can't produce).

templateRatioWithinFamilyBounds

@openmixer/coreTrue when `t`'s compressor ratio falls within its family's curated bounds (FAMILY_COMP_RATIO_BOUNDS).

templatesOverlap

@openmixer/coreCould one concrete path match both templates AND leave no principled winner?

templateVariableName

@openmixer/coreThe name a variable segment captures under: `{index}` → `index`.

templateVariables

@openmixer/coreEvery variable a template captures, in the order it captures them.

text

@openmixer/coreOperator text, length-capped, control characters refused.

thresholdsFor

@openmixer/coreMap a per-channel `sensitivity` ∈ [0, 1] and the channel's pool to a DetectThresholds.

toDb

@openmixer/coreLinear magnitude → dBFS-ish, floored so a zero bin doesn't blow up to −Infinity.

toggleParam

@openmixer/coreBuild a toggle (on/off) processor param.

toggleValue

@openmixer/coreRead a toggle param's value by id.

tokenArray

@openmixer/coreAn array of short identifier tokens — a processor id, a slot key: the element type an ORDERED collection names its members by.

totalAudioPaths

@openmixer/coreThe total number of allocated audio paths (input channels + every bus, excl.

trimDescriptorOf

@openmixer/coreThe TRIM control descriptor — the desk's own declared travel, so a component binds this and never imports `TRIM_MIN_DB`/`TRIM_MAX_DB` itself.

uniformFeatureMatrix

@openmixer/coreA feature matrix where **every** kind exposes the same feature set — for a mixer whose capability doesn't vary by kind: the software engine (fader/mute/gain/inserts on every strip), the hardware-free mock and the surf…

unrealisedInsertPointRefusal

@openmixer/coreThe refusal for a plugin that would sit at `at` (ruling 2026-09-02, tap-points spec): one builder, so the processor door, the send door and both OPTIONS carry identical args.

upgradeEndpoint

@openmixer/coreRe-store a port-string leg as the BOX it names, whenever the desk can name one.

uriArray

@openmixer/coreAn ORDERED rack of plugin URIs — an insert chain, a bus output rack.

uriText

@openmixer/coreONE plugin URI — a rack member, a preset.

validateAllocationAgainstProfile

@openmixer/coreValidate a ConsoleAllocation against a ConsoleProfile appliance — the gate for a hand-, AI- or third-party-authored allocation that a restricting profile must never accept.

validateConsole

@openmixer/coreValidates an unknown value against the console schema.

validateKeyBinding

@openmixer/coreValidates an unknown value against the KeyBinding shape.

withBandIds

@openmixer/coreThe same bands, each carrying an id — minted through makeBandId for any that arrives without one, against the bands ALREADY accepted so a fresh id can collide with neither a declared one nor another fresh one.

writeField

@openmixer/coreThe one assignment of a decoded value into a draft state — key and value co-typed by K.

buildDemoTopology

@openmixer/serverBuild a working demo console over freshly-created virtual PipeWire nodes: N input nodes (one per input channel), M output nodes (one per output bus — the allocation's aux buses), and a stereo main node.

buildNativeCueControl

@openmixer/serverAdapt a NativeConsoleMixer to the engine's NativeCueControl seam for cue ROUTING (#191): the reconcile publishes the cue bus, pushes its master stage (monitor level + DIM), and reads its own `cue_L`/`cue_R` tail throu…

buildNativeMatrixControl

@openmixer/serverAdapt a NativeConsoleMixer to the engine's NativeMatrixControl seam (#146, ADR 0017 layer 2): the reconcile declares the native matrix set (`syncMatrices`), pushes each matrix's per-source send coefficients (`setMatri…

buildNativeOutputRouteControl

@openmixer/serverAdapt a NativeConsoleMixer to the engine's NativeOutputRouteControl seam (#158, phase 2): the reconcile lays each EXTRA MAIN output destination on its OWN native `out_<idx>` port (`syncExtraRoutes` / `routePorts`) and…

buildNativeStripWidthHook

@openmixer/serverBuild the import('./software-mixer-loader.js').SoftwareMixerDeps.reconfigureNativeStrip hook over a native mixer: map input channel N → strip N-1, reconfigure that strip's width IN PLACE, and hand back the (post-recon…

capabilitySignature

@openmixer/serverThe stable identity of one channel's capability — what the re-publish delta cache compares.

channelConfigClearFacts

@openmixer/serverThe facts a CHANNEL CONFIG's declared-absence pass clears (spec revision 3, #665) — every `onAbsent: 'clear'` fact ALL of whose snapshot fields the config carries.

channelConfigFieldOf

@openmixer/serverRead one persisted field out of a config, wherever it rides — `undefined` both for a field the config does not carry at all and for one it is silent about, which is the same fact to the clear pass: the config says not…

channelConfigStates

@openmixer/serverWhether a config document makes a STATEMENT about `fact` at all — every block its fields ride is present (spec revision 4).

channelKey

@openmixer/serverRe-export for callers that key channels the same way the engine does.

classifyResources

@openmixer/serverSort a live source + sink node list into a DetectedResources inventory.

compStateToNativeDyn

@openmixer/serverMap a CompState to the native COMP dynamics slot — an ACT-ABOVE atom with the compressor's threshold/ratio/attack/release/make-up.

configFromEnv

@openmixer/serverBuild a ServerConfig from `process.env`-style variables (see configOverridesFromEnv for the recognised keys).

configOverridesFromEnv

@openmixer/serverThe SPARSE config overrides a `process.env` carries — only the keys that are actually set appear, so the result can overlay a config file without unset env fields clobbering set file fields (see overlayConfig).

consoleRigPlan

@openmixer/serverResolve the demo rig's build decisions from a ServerConfig — pure (no PipeWire, no fs), so tests can prove the bundled default install config plans the exact console the bespoke demo bin used to build.

createServer

@openmixer/serverConvenience factory mirroring the MixerServer constructor.

declaredChainOf

@openmixer/serverA strip's DECLARED chain, read off the same engine door the `/chain` row reads — the bus master's for a bus kind, the input strip's otherwise.

defaultInsertPoint

@openmixer/serverDefault stereo insert point for a strip: capture pair in, playback pair out, keyed off a 1-based channel index.

delayStateToNativeDelay

@openmixer/serverMap a console DelayState to the native FX-delay insert.

demoAllocation

@openmixer/serverBuild the demo console allocation for a detected/chosen size (the preset mapping).

detectConsoleSize

@openmixer/serverDecide the demo console size.

detectForeignConsole

@openmixer/serverThe single-instance guard's probe (2026-07-13 deploy incident): the PipeWire global id of a node named `nodeName` already LIVE on the graph — i.e.

detectResources

@openmixer/serverRead the live PipeWire I/O, classify it into a DetectedResources inventory, fold any discovered network devices into the network bucket, and log a one-line human summary ("detected: 2 mics, 4 outputs, 2 app streams, R…

eqStateToNativeEq

@openmixer/serverMap a console EqState to the native mixer's EQ coefficient set — RBJ curves → biquad coeffs computed in TS (eqCoeffs), plus the whole-EQ `on` flag.

gateStateToNativeDyn

@openmixer/serverMap a GateState to the native GATE dynamics slot — an ACT-BELOW atom whose threshold is the gate's fully-open point (`kneeEndDb`) and whose expansion `ratio` is now the state's OWN GateState.ratio field (an explicit o…

installBuiltinDspNativeMixerMirror

@openmixer/serverBuilt-in-processor control bridge: mirror every `eq.set` / `gate.set` / `comp` (dynamics) state change onto the native strip's biquad cascade + gate/comp slots — the EQ/Gate/Comp counterpart of the fader/mute/pan/gain…

installCueNativeMirror

@openmixer/serverMirror MixerEngine's solo / soloSafe / cueMode / soloClear state onto the native strip DSP — the `setSolo` integration point the cue/solo-to-monitor spec's whole design hangs off of.

installHeadStageNativeMirror

@openmixer/serverHEAD-STAGE control bridge: wrap the adapter's `setGain` / `setPolarity` so each still runs (canonical state + surface events) and then mirrors the value onto the lane THE OWNERSHIP RESOLUTION names — an input strip, o…

loadAdapter

@openmixer/serverInstantiate the adapter named in `config`.

loadConfigFile

@openmixer/serverLoad + validate a JSON config file into a ServerConfig (defaults applied).

metersMessageOf

@openmixer/serverThe `/meters` reading for an engine event, or `null` for every other event — each of those lands on its own row (`publishEngineEventRow`), and meters are the one periodic reading the feed records whole.

missingNativeEngineMessage

@openmixer/serverThe refusal startConsole throws when the native engine is not there.

networkOverridesFromConfig

@openmixer/serverThe config file's `web` block as a SPARSE network layer — only the fields the file actually sets, so the network resolver can rank it below env/CLI (see `network-config.ts`).

networkOverridesFromEnv

@openmixer/serverExtract the env layer from `process.env`-style variables.

overlayConfig

@openmixer/serverOverlay one sparse config over another, per SECTION FIELD: a field the overlay sets wins; a field it leaves out keeps the base value (schema defaults only apply to fields neither layer set — apply them by parseConfigi…

parseConfig

@openmixer/serverParse and validate an arbitrary object into a ServerConfig, applying defaults.

parseDefaultSinkName

@openmixer/serverThe default sink's node name from `pw-metadata -n default` output, or `undefined` when the key is absent / malformed / empty.

parseServerCli

@openmixer/serverParse a bin's argv (without the node/script prefix — pass `process.argv.slice(2)`).

peakCachingMeterSource

@openmixer/serverWrap a MeterSource with a read-through **latest-peak cache**, so the flow watchdog samples the very peaks the adapter's own meter poll already reads — no second meter pipeline, no extra probe subprocess.

pickAutorouteSink

@openmixer/serverPick the sink the main mix should auto-route to, from the patchbay's enumerated sinks: the host's default sink when it is enumerated, else the first local-hardware sink, else the first sink at all.

pinnedConsoleSize

@openmixer/serverParse an explicit `IN:OUT` console-size pin (e.g.

planStereoSourcePatch

@openmixer/server**Patchbay stereo-source split — the mapping for a stereo (2-port) source patched onto the mixer.** DEFAULT (`asStereoChannel` omitted/`false`): a genuine stereo source (both `endpoint.l` AND `endpoint.r` present) SPL…

reacTypeRegistration

@openmixer/serverThe `reac` type's AdapterTypeRegistration — a first-class, server-owned transport (writes `reac.env` + drives the `reac-pw-master` systemd unit), unlike the peer-package console adapters (x32/midas/roland).

readConfigFileJson

@openmixer/serverRead + JSON-parse a config file WITHOUT applying schema defaults, so the caller can still tell "the operator set this" from "the schema filled it in".

resolveBinNetwork

@openmixer/serverresolveRuntimeNetwork for a bin's `main`: `--help` prints the shared help and exits 0; a CliUsageError prints the message + help and exits 2.

resolveConfigFilePath

@openmixer/serverThe config file a bin should read: `--config` > `OPENMIXER_CONFIG` > none.

resolveDefaultSinkName

@openmixer/serverResolve the host's CURRENT default Audio/Sink node name via `pw-metadata`.

resolveNetworkConfig

@openmixer/serverResolve the effective web binding from the four override layers, per field: persisted > CLI > env > config file > built-in default.

resolveRuntimeNetwork

@openmixer/serverResolve a bin's runtime network from its argv + env.

resolveServerConfig

@openmixer/serverResolve the effective ServerConfig for a bin: config file (named by `--config` / `OPENMIXER_CONFIG`, optional) < env overrides, with the runtime-network `web` overlay applied last.

resolveStateDir

@openmixer/serverResolve the state dir: CLI > env > XDG default.

retiredPresetNotice

@openmixer/serverWhat to tell the operator at boot about a `rig.preset` an installed config still names, or `undefined` when there is nothing to say.

reverbStateToNativeReverb

@openmixer/serverMap a console ReverbState to the native reverb insert (room/plate/hall, one control set).

settleStripPorts

@openmixer/serverBlock until the registry mirror agrees with a width reconfigure that has ALREADY happened in the daemon: every `present` port name resolves and every `retired` one no longer does.

startConformanceDesk

@openmixer/serverBoot the conformance desk: the production composition in `startConsole`'s order — resources first (the server registers routes in its constructor), then the server, then the engine-bound mirrors, then the boot re-proj…

startConsole

@openmixer/serverBuild + start the console from its config, wiring signal handlers for a clean node teardown.

wireFlowWatchdog

@openmixer/serverArm task #68's per-channel **flow watchdog** (manifestation 2): detect a channel whose meter tap reads silence while its source link is provably live in the graph — the exact contradiction the 2026-07-06 wave left on …

wireRouteHealing

@openmixer/serverArm task #68's event-driven route healing over the native registry feed: every settled burst of **Node/Port** changes re-runs the mixer's reconcile, so a routed sink whose node was recreated by a USB re-enumeration ge…

withGhostedNodes

@openmixer/serverGhost a node whose ports are absent — a stopped stream keeps its node in the enumeration but its ports unregister (#168's present-node-unregistered-ports case).

Interfaces (481)

NamePackageSummary

AbsentDevice

@openmixer/coreThe identity of an absent device, for the refusal a client renders: what it is and which one.

AdapterConfig

@openmixer/coreOne declarative adapter entry — exactly what is persisted to the config file.

AdapterInput

@openmixer/coreOne enumerable **input** an adapter exposes — what a Source's patch can reference.

AdapterInstance

@openmixer/coreA live adapter instance: a startable/stoppable binding with a status.

AdapterSettingsField

@openmixer/coreOne field in an adapter type's settings form.

AdapterSettingsSchema

@openmixer/coreThe full settings schema for one adapter type — the menu form generator reads this.

AdapterStatusReport

@openmixer/coreAn AdapterConfig plus its live status, as returned by `adapter.list`.

AdapterTypeRegistration

@openmixer/coreOne registered adapter type: its factory + the schema that drives its form.

AddressCodec

@openmixer/coreHow a mold turns a wire ResourceId into its typed address and back.

AlignApplied

@openmixer/coreThe alignment state a correction is computed against — this channel's line as it stands.

AlignBand

@openmixer/coreThe band the fit is taken over, in Hz.

AlignCorrection

@openmixer/coreWhat APPLY would write, and whether the desk can write all of it.

AlignFit

@openmixer/coreWhat a fit answers with when it CAN answer.

AlignFrame

@openmixer/coreOne paired reading, both sides snapshotted in the same pass (the pair is the unit).

AlignRefusal

@openmixer/coreWhy a fit could not be taken.

AllocationCaps

@openmixer/coreThe allocation ceiling: per-bus-type maxima, and/or a shared O.H.R.C.A.

AssignableKey

@openmixer/coreOne user-assignable key: an id, a printed label, and its binding.

BankAlignment

@openmixer/coreHow a BusAllocation's banked strips line up against the surface's banks.

BiquadBand

@openmixer/coreOne EQ band, in engineering units, ready to evaluate.

BiquadSection

@openmixer/coreOne biquad section as the cookbook writes it, BEFORE normalisation: the raw numerator (`b*`) and denominator (`a*`) coefficients with `a0` still carried.

Block

@openmixer/coreA named, reusable JSON snapshot of a sub-tree at one composition level.

BoundsContext

@openmixer/coreThe live facts a pointer may need in order to reach real bounds.

BrokenLeg

@openmixer/coreOne leg whose DEVICE is present but which has no equivalent port on the active profile.

BusAllocation

@openmixer/coreThe bus types a gig can allocate, one fixed count each.

BusCoercion

@openmixer/coreOne tier's count being moved onto the STRIP_QUANTUM grid by coerceBusesToQuantum.

BusSnapshotJson

@openmixer/coreA bus: an output channel summing a subset of inputs (aux / group / main).

BusTypeDescriptor

@openmixer/coreOne entry in the BUS_TYPES descriptor table: the single, canonical record of the per-bus-type facts the console used to enumerate by hand in ~5 parallel places (the `BusAllocation` field, the id synthesis in allocated…

CarriedIndexCodec

@openmixer/coreThe index entry codec: a key over the carried row's id.

CarriedSeriesDeclaration

@openmixer/coreHow a collection row carries a per-instance row — the ONE declaration, on the collection.

CensusTotals

@openmixer/coreHow many facts landed on each verdict, per axis.

ChainControlState

@openmixer/core`…/params/{symbol}` and `…/properties/{property}` — one control of the hosted plugin.

ChainLatencyTotal

@openmixer/coreThe accumulated latency of a chain, with the ambiguity kept.

ChainOrderState

@openmixer/core`/channel/{kind}/{index}/chain` — the processors' stable ids, in signal order.

ChainProcessorState

@openmixer/core`/channel/{kind}/{index}/chain/processors/{processorId}` — one stage.

ChannelCapabilities

@openmixer/core—

ChannelCapabilityState

@openmixer/coreWhat `/channel/{kind}/{index}/capability` serves: which controls this channel carries right now, which of them can be moved, which hold a real value, and how far the gain travels.

ChannelClipboardEntry

@openmixer/coreWhat was copied: the captured fields plus enough provenance for the UI to name it.

ChannelClipState

@openmixer/coreOne channel's clip latch as the row serves it.

ChannelConfig

@openmixer/coreA named, reusable per-channel config as stored on disk.

ChannelConfigMove

@openmixer/coreOne fact-field this apply would move off what the channel currently holds.

ChannelConfigMoves

@openmixer/coreWhat the preview row answers: the moving fields, in the config's own field order.

ChannelConfigProcessing

@openmixer/coreOne channel's processing captured for reuse: its plugin chain (ordered plugins + params + presets) + channel processing (gain/trim/pan/phantom/pad/SENS/polarity).

ChannelConfigSummary

@openmixer/coreThe list-row a `channelConfig.list` returns.

ChannelFactDecl

@openmixer/core—

ChannelId

@openmixer/core1-based channel address within its kind.

ChannelLink

@openmixer/coreStereo-link state on a channel (M32 / Roland paradigm).

ChannelLinkJson

@openmixer/coreA channel's stereo-link state as stored: the ChannelLink flattened.

ChannelMuteSink

@openmixer/coreThe southbound half: what puts the composed value onto the audio.

ChannelMuteState

@openmixer/coreA channel's mute, as the console holds it: the one writable latch, the two latches owned by other entities, and the composed value the audio must follow.

ChannelMuteStrips

@openmixer/coreWhere the ONE state lives.

ChannelPairAddress

@openmixer/coreTWO channels naming one audio connection: where the signal comes FROM and where it goes TO.

ChannelPairSpec

@openmixer/coreHow one pair-shaped path spells its two ends.

ChannelPatchJson

@openmixer/coreOne channel's input patch: the ordered set of source endpoints feeding its head, `[primary, ...extras]`.

ChannelRecallSafeState

@openmixer/coreONE channel's recall-safe decision.

ChannelRefJson

@openmixer/coreA wire/disk channel address: `{ kind, index }`, mirrored from ChannelId.

ChannelSafe

@openmixer/coreOne channel's recall-safe flags.

ChannelSlot

@openmixer/coreA strip plus a POSITION in one of its racks — `/channel/{kind}/{index}/inserts/{slot}`.

ChannelSlotKey

@openmixer/coreOne named control of one racked plugin — a control port's symbol, a property's URI.

ChannelSlotTarget

@openmixer/coreA strip's numbered slot plus the OTHER strip that slot is about (a promotion's target).

ChannelSnapshotJson

@openmixer/coreA single channel's full snapshot.

ChannelStrip

@openmixer/core—

ChannelTailAddress

@openmixer/coreA channel plus ONE tail segment — a processor id, a pass-filter kind, a band ref: the shape a row earns a local `AddressCodec` for right up until a SECOND row needs the same "one channel, one tail" pattern (the row-gr…

ChannelTailKey

@openmixer/coreOne named control of a plugin addressed by a NAMED tail — a chain processor's id.

ClipCapture

@openmixer/coreThe clip capture door: ONE read-and-clear call over the engine's sticky over flags.

CoarseDelay

@openmixer/coreWhere the cross-correlation peaked, and how strongly.

CoarseDelayRead

@openmixer/coreWhat band of a cross-spectrum a correlation is taken over, and under which physics.

CodedMessage

@openmixer/coreOne message on the wire: a code plus exactly the parameters that code's sentence needs.

CoercedBuses

@openmixer/coreThe result of coerceBusesToQuantum — the on-grid counts plus what had to move.

CollectionConfig

@openmixer/core—

CollectionFieldSpec

@openmixer/coreOne collection-valued field: a codec that narrows the WHOLE replacement value.

ComplexSpectrum

@openmixer/coreOne side's complex spectrum: `fftSize / 2` bins, bin k at `k * sampleRate / fftSize` Hz.

CompState

@openmixer/core—

ConfiguredHardware

@openmixer/coreWhat the RIG is configured for, as a source of expectation in its own right (the rig defect).

ConfiguredStagebox

@openmixer/coreA REAC box the RIG IS CONFIGURED FOR, independent of any session — read from the operator's `reac.env` (`REAC_BOX=s0808:S-0808` on `REAC_LIVE_IFACE`), the same binding the `reac-pw-master` unit runs on.

ConfirmGate

@openmixer/coreOne operation row's confirm gate — read before honouring its fire, keyed by the operation row's own path template (`2026-08-22-osc-surface.md` §"Confirm-gated operations").

ConsoleAllocation

@openmixer/coreA per-gig console allocation: the input-channel count + the per-bus-type counts, declared up front and fixed for the show.

ConsoleClientConfig

@openmixer/coreConfiguration for ConsoleClient.

ConsoleContract

@openmixer/coreThe whole desk's declaration, as `OPTIONS <base>/` answers it.

ConsoleDeclaration

@openmixer/coreOne instance's declaration, as `OPTIONS <base><instance>` answers it.

ConsoleDef

@openmixer/coreA whole console definition.

ConsoleFactDecl

@openmixer/coreWhat one console-level fact declares.

ConsoleFrame

@openmixer/coreA stream event: a row, plus the console revision as of the read.

ConsolePreset

@openmixer/coreA standard console size offered as a one-click preset: `inputs` in, `outputs` out.

ConsoleProfile

@openmixer/coreA console appliance: the whole-console restriction envelope.

ConsoleResource

@openmixer/core—

ConsoleRow

@openmixer/coreOne entity instance as the console holds it: the root stream's event body, unserialised.

ConsoleRowFeed

@openmixer/coreWatch the console's rows in process.

ConsoleSnapshot

@openmixer/coreThe full console body — every addressable element of state.

ConsoleWatch

@openmixer/coreOne open watch: the in-process twin of the root stream's own `/streams/{id}/demand` row.

ConsoleWatchHandlers

@openmixer/coreHow a watcher learns the stream's own state, apart from the rows it carries.

ControlAvailability

@openmixer/coreWhat a caller may say about a control's availability when building a descriptor.

ControlDescriptor

@openmixer/coreEverything a numeric control needs in order to draw itself — produced from a declaration plus the current state, bound whole by the component.

ControlLimit

@openmixer/coreThe declared travel of ONE numeric control — bounds, resolution and unit together.

ConvergenceClientHost

@openmixer/coreWhat the engine needs from its host — the two side effects it may never do itself.

ConvergenceClientOptions

@openmixer/core—

ConvergenceCorrection

@openmixer/coreOne recorded correction — the report plus the instrument's own bookkeeping.

ConvergenceCorrectionsState

@openmixer/coreThe `/telemetry/convergence/corrections` row's state — the log, newest last.

ConvergenceFrame

@openmixer/coreOne console-stream event, as the intake hands it over: the GET body plus the `rev` stamp.

ConvergenceInstrumentOptions

@openmixer/core—

ConvergenceState

@openmixer/coreThe `/telemetry/convergence` row's state — what every heartbeat frame carries.

CorrectionReport

@openmixer/coreWhat a client reports when it corrected one row it had wrong.

CrossSpectrum

@openmixer/coreAn averaged cross-spectrum, `fftSize / 2` bins — what coarseDelayOf reads.

CueSnapshotJson

@openmixer/coreThe cue bus's persisted state (cue/solo-to-monitor spec) — fader/mute/balance mirror MatrixSnapshotJson's shape; mode + monitorOutput are console-wide but stored here (there is exactly one cue bus, so this is the natu…

CurveOptions

@openmixer/coreOptions for eqCurveDb: axis extents, sample rate and resolution.

CurvePoint

@openmixer/coreOne point on the response curve: frequency (Hz) and summed magnitude (dB).

DcaGroup

@openmixer/coreOne DCA group: a stable id, its current master linear gain (1 = unity, 0 = silence), the member channels it scales, and — for VCA nesting — the ids of the DCA groups whose masters additionally scale *this* group's mas…

DcaSnapshotJson

@openmixer/coreA DCA/VCA group: control-domain gain coupling, carries no audio.

DeclaredStagebox

@openmixer/coreA stagebox as something WROTE IT DOWN — an adapter's `boxModel` setting, a `reac.env` pin, a session manifest entry, a registry row.

DelayState

@openmixer/coreA native FX delay (send/return or channel insert).

DerivedConfig

@openmixer/core—

DetectedGpu

@openmixer/coreOne detected GPU.

DetectThresholds

@openmixer/coreThe full detector contract — every gate PersistenceTracker.push confirms on, promoted here from the module consts so a per-channel `sensitivity` can relax them (via thresholdsFor) without touching the corpus-tuned SAF…

DiscoveredDevice

@openmixer/coreA device found on the network by a discovery probe.

DiscoveryDeviceAddress

@openmixer/coreOne discovered device, as `/discovery/device/{protocol}/{id}…` rows address it.

DiscoveryEvents

@openmixer/coreEvents a DiscoveryProvider emits.

DiscoveryOptions

@openmixer/corePer-protocol scan options; each probe is independently enable-able.

DiscoveryProbeAddress

@openmixer/coreOne protocol's probe, scoped to a NIC or to DISCOVERY_GLOBAL_SCOPE.

DiscoveryProvider

@openmixer/coreThe discovery service the server consumes.

DynamicsProfile

@openmixer/core—

DynamicsState

@openmixer/core—

EqBand

@openmixer/core—

EqCoeffBand

@openmixer/coreOne section of an EQ coefficient set: its coefficients + whether it is active.

EqCoeffSet

@openmixer/coreA whole strip's EQ as an ordered biquad-coefficient cascade (bands low→high, then the HPF/LPF Butterworth sections) — the shape the native mixer's `mixerSetStripEq` takes.

EqHeadroomAssessment

@openmixer/coreThe answer to "can `desiredAddCount` more bands be added right now?" — `ok` gates the add affordance, `reason` is the HONEST explanation shown once refused (a disabled control must never leave the operator guessing why).

EqPreset

@openmixer/coreOne selectable band-count preset (#120): a classic console layout offered by the EQ tab's picker.

EqPresetBandSeed

@openmixer/coreA preset's band seed — the same fields a hand-added band takes (freq/type/gain/Q), minus the id (assigned on apply, exactly like makeBandId assigns one).

EqProfile

@openmixer/core—

EqState

@openmixer/core—

ExpectedSoundcard

@openmixer/coreOne local sound card the session EXPECTS.

ExpectedStagebox

@openmixer/coreOne stagebox the session EXPECTS to be present (issue #154 hardware manifest).

ExpectedSurface

@openmixer/coreOne control surface the session EXPECTS (an X-Touch etc.).

FactCensus

@openmixer/coreOne fact, both axes.

FactOwnershipContext

@openmixer/coreThe LIVE context a per-instance ownership condition reads — the computed law's input.

FactPersistenceCase

@openmixer/coreOne (fact, kind) pair the contract declares, carrying that fact's own persistence bit.

FactPresentation

@openmixer/coreThe two PRESENTATION columns every contract declares — what kind of control carries the fact, and where its travel comes from.

FaderLevel

@openmixer/coreFader position: opaque 0..1 surface scalar + derived dB.

FaderLevelJson

@openmixer/coreA fader position as stored: opaque 0..1 surface scalar + its derived dB.

FaderScale

@openmixer/core—

FbsChannelState

@openmixer/coreOne channel's FBS arming state (persisted with the channel, restored on boot).

FbsChannelStateJson

@openmixer/coreA persisted FBS state as an OLDER build may have written it: pre-#116 the hold rode the session (and the wire) in MINUTES under `holdMinutes`.

FieldCapability

@openmixer/coreWhether one field of a resource can be read or written **on this instance** — per-instance, not per-type.

FieldCodec

@openmixer/coreA field decoder.

FieldTravel

@openmixer/coreOne field's travel BEFORE any instance is named — the desk-wide half of FieldCapability.

FxProfile

@openmixer/core—

GainLevel

@openmixer/core—

GateState

@openmixer/coreA downward gate / expander, in engineering units.

GeneratorParams

@openmixer/coreA partial parameter update for a generator (only the fields a `talkback.set` carries).

GhostIdentityLeg

@openmixer/coreOne `{box, input}` leg a patch still refers to — the shape `ChannelPatchStore.identityLegs()` reports for a box no live device answers.

GhostNaming

@openmixer/coreThe stagebox nodes the desk still POINTS AT but the graph no longer has.

GhostReplacementPlan

@openmixer/coreWhat a replacement would do, and what it cannot do.

GhostReplacementWrite

@openmixer/coreOne channel's move in a ghost replacement.

GpuDetector

@openmixer/coreThe pair a consumer binds to.

GpuProbes

@openmixer/coreInjectable reads so the detector runs deterministically in tests.

HardwareContradiction

@openmixer/coreOne disagreement between what was written down and what the hardware reports.

HardwareManifest

@openmixer/coreThe session's **expected hardware set** (issue #154): the stageboxes, soundcards, and control surfaces present when the show was saved.

HardwareManifestInputs

@openmixer/coreInputs to buildHardwareManifest — the present rig, captured at save.

HarmonicBandLimits

@openmixer/coreThe authority one call to harmonicBands is given, supplied by the CALLER.

HeadAmp

@openmixer/coreThe PHYSICAL preamp properties a source carries, applied at the head: the analog box trio (gain/pad/phantom) only — what the engine fans out to the box's adapter.

HeadAmpCapability

@openmixer/coreThe analog head-amp controls an input physically implements — the honest capability an enumerated AdapterInput declares.

HeadAmpGainRange

@openmixer/coreThe travel of one preamp's input GAIN — min, max and the step it actually resolves, all in dB of gain.

HeadAmpInstance

@openmixer/coreWhat the console can say about ONE channel's head stage at this instant — the per-instance half of the intersection, supplied by whoever holds the `/headAmp` row.

HeadAmpPortJson

@openmixer/coreOne physical input's desired head-amp, as a session names it: the port by its stable identity (StoredPatchLeg — a stagebox input by `{box, input}`, or a bare port name for a source no box owns, the SAME identity Chann…

HeadAmpRow

@openmixer/coreWhat the `/channel/{kind}/{index}/headAmp` row PUBLISHES: the record (HeadAmp) plus the preamp's declared GAIN travel.

HrpCandidate

@openmixer/coreOne voice's one correctable partial, as the corrector proposes it — the band the placement law described, plus the identity and weight the selection needs.

HrpChannelState

@openmixer/coreEverything an operator decides about HRP on one channel.

HrpProposalLimits

@openmixer/coreThe declared authority one proposal runs under.

HrpSearchHint

@openmixer/coreThe SEARCH one channel's analyser runs — how many voices to look for and where to look for them.

HrpVoiceMeasurement

@openmixer/coreOne voice's measured harmonic ladder, as either corrector observes it.

InputProvider

@openmixer/coreThe contract an input adapter implements to expose its enumerable inputs to the source layer.

InsertChain

@openmixer/coreOrdered insert chain for a channel.

InsertChainEntry

@openmixer/coreOne plugin in the chain being judged, reduced to the facts the checks read.

InsertDestination

@openmixer/coreThe destination a chain is being judged against.

InsertProfile

@openmixer/core—

InsertSuitabilityPolicy

@openmixer/coreOperator/site configuration.

InsertSuitabilityReport

@openmixer/coreThe whole judgement for one chain on one destination.

InstrumentTemplate

@openmixer/coreOne factory instrument template: a stable id + i18n name key + a full built-in EQ/gate/comp chain, ready to apply to any channel exactly like a saved channel config.

JobLedgerRow

@openmixer/coreOne row of the ledger.

JobProbe

@openmixer/coreA cheap read against the shadow console: row-shape reachability, never the job itself.

JobProofCitation

@openmixer/coreThe test a tier-1 row stands on.

KeyBinding

@openmixer/coreThe stored client-message template a key fires.

KindCount

@openmixer/coreOne ordered entry in a TopologyLayout: `count` channels of `kind`, in surface order.

LabelVocabulary

@openmixer/coreThe WORDS a display label is built from, injected so the rule below can be stated once.

LaneRule

@openmixer/coreThe two lane booleans a ControlDomain-shaped consumer spreads.

LatchConfig

@openmixer/coreEverything a latch row declares: a scalar record, plus the query, plus mandatory ripples.

LatchState

@openmixer/coreThe hold every latch state carries.

LatencyPath

@openmixer/coreThe end-to-end latency of one signal path (input channel → inserts → bus → out).

LatencyReport

@openmixer/coreA real-time latency + health snapshot of the running mix engine.

LatencyReportSource

@openmixer/coreThe measurement source the server polls.

LatencyStep

@openmixer/coreOne element's latency contribution along a signal path, in milliseconds.

LedgerRow

@openmixer/coreOne row as the ledger holds it — enough to re-report and to compare across boundaries.

LevelSeriesCodec

@openmixer/coreA FieldCodec that also ENCODES — the wire is written by the desk and read by the client, and both halves live here so neither can drift from the declared quantum.

LifecycleDoors

@openmixer/coreThe lifecycle doors a row declares.

LoudnessReadout

@openmixer/coreEBU R128 / ITU-R BS.1770 loudness of one output (the MAIN mix), measured in the engine and broadcast on the meter channel beside the peak levels.

MatrixSnapshotJson

@openmixer/coreA matrix node: a mix of buses/groups feeding a matrix output.

MeterLevel

@openmixer/core—

MeterTick

@openmixer/coreOne READ of an adapter's meters, offered to the console as a tick it drives — the demand-gate's seam (`an internal spec` §4).

MicRouting

@openmixer/coreHow the measurement channel is routed — the two ways a microphone reaches a loudspeaker.

MissingHardware

@openmixer/coreOne absent expected device + what the restored session depends on it for (issue #154).

MixerAdapter

@openmixer/core—

MixerReceiver

@openmixer/coreReads are a push observer (not promises): desks stream state after subscribe.

MixerTopology

@openmixer/core—

MsSpan

@openmixer/coreA millisecond span a figure is known to lie in.

MuteGroup

@openmixer/coreOne mute group: a stable id, whether it is currently muting its members, and the member channels it mutes when active.

MuteGroupJson

@openmixer/coreA named, assignable mute group as the SAFETY section speaks it: string-keyed, with no live `active` flag.

MuteGroupSnapshotJson

@openmixer/coreA mute group: channels muted / un-muted together (the SSL / Waves overlay model, the live import('./mute-group.js').MuteGroup).

MuteHoldSource

@openmixer/coreThe two holds, read from the entities that own them — never cached here.

NoiseGenerator

@openmixer/coreA noise generator (white or pink) — just a level, no waveform / frequency.

NotchCandidate

@openmixer/coreA confirmed feedback candidate the model turns into a notch, or an alert.

NumberSpecDef

@openmixer/coreRange spec for a number param.

ObservedStagebox

@openmixer/coreA stagebox as the WIRE reports it — reac-pw's `reac.box-model` / `reac.box-width` / `reac.headamp.channels`, read off the node it publishes.

OpenApiFamilySpec

@openmixer/coreOne resource family — the same grouping the REST reference pages use.

OpenApiFieldSpec

@openmixer/coreOne field's declared travel, exactly as the REST reference already carries it.

OpenApiRefusalCode

@openmixer/coreOne refusal or undo-label code, as `message-code.ts` documents it.

OpenApiRefusalSection

@openmixer/coreA section of the refusal-code registry (mirrors `message-code.ts`'s own dividers).

OpenApiRowSpec

@openmixer/coreOne addressable row — a path template plus the fields it carries.

OpenApiSourceData

@openmixer/coreEverything buildOpenApiDocument needs — the REST reference's own normalised shape.

OperationConfig

@openmixer/core—

OperationParams

@openmixer/coreThe decoded arguments a run is handed — an accessor rather than the plain record, because "every declared key is present" is a fact the mold ENFORCES (`PARAM_MISSING` refuses the fire otherwise) and TypeScript cannot …

OperationRun

@openmixer/coreThe handle one run reports through.

OperationState

@openmixer/coreThe one operation state shape.

OscillatorGenerator

@openmixer/coreThe oscillator generator: a selectable waveform at a chosen frequency + level.

OscMessage

@openmixer/coreA decoded OSC message: an address pattern plus its typed arguments.

OutputEndpointLeg

@openmixer/coreOne present leg of an OutputEndpoint: its role + the port it feeds.

OutputPatchJson

@openmixer/coreOne output's routing: the ONE sink endpoint a bus / main feeds, or NONE.

OutputSnapshotJson

@openmixer/coreAn output: physical/loudspeaker-management routing + its own insert chain.

PanicState

@openmixer/coreA held panic latch, as the pure composition model sees it.

PanicTargetsJson

@openmixer/coreWhat a panic affordance silences.

Param

@openmixer/coreA live parameter: its spec plus the value/position/format functions derived from it.

ParamSpec

@openmixer/coreThe declarative spec of a parameter — everything a control needs to render + edit it.

PartCarriage

@openmixer/coreWhat one part's facts did against one target.

PassFilter

@openmixer/coreThe channel's built-in high-pass (low-cut) or low-pass (high-cut) filter: a cutoff frequency, an on switch, and a slope.

PatchEndpointJson

@openmixer/coreA stereo (or mono) endpoint by port name — a mirror of the engine's `StereoEndpoint`, but serialisable and id-free.

PatchSnapshot

@openmixer/coreThe routing graph only — the input patch per channel + the output sink per bus.

PatchSummary

@openmixer/coreThe list-row a `patch.list` returns (header only, body omitted).

PerfOpSnapshot

@openmixer/coreOne named op's snapshot, as reported over REST/WS.

PerfRegistryOptions

@openmixer/coreOptions for PerfRegistry.

PerfSnapshot

@openmixer/coreA point-in-time read of one PerfHistogram.

PerfTelemetryState

@openmixer/core`/telemetry/perf`'s served shape (see `packages/server/src/perf-telemetry-resource.ts`): whether recording is on, and every op recorded so far.

PhysicalInputPortMap

@openmixer/coreOne adapter's declaration of how its capture ports map to physical inputs.

PhysicalInputRef

@openmixer/coreA capture port resolved to the physical input it carries.

Placed

@openmixer/coreA node carrying a (possibly absent) placement — what orderPlaced sorts.

PlannedEntity

@openmixer/coreAn entity the design names and the console does not serve.

PluginInsert

@openmixer/coreA software plugin instance inserted into a channel's signal chain.

PluginSlotJson

@openmixer/coreOne plugin slot, serialised by URI (never by mod-host instance id).

PresentHardware

@openmixer/coreWhat is actually present on the rig now, for the restore-time diff.

PresentStagebox

@openmixer/coreA detected reac-pw stagebox as the diff reads it now — its id + the live link/box props.

ProbeUnavailable

@openmixer/coreA probe that COULD NOT SCAN, and why.

ProcessLoadState

@openmixer/coreThe engine PROCESS's resource load — a periodic gauge answering the operator's "what is eating our CPU".

Processor

@openmixer/coreOne processor node in a channel chain.

ProcessorDef

@openmixer/coreOne processor in a strip's chain.

ProcessorPlacement

@openmixer/coreWHERE a processor sits: the point whose segment it runs in, plus its sort among the others in that segment.

ProcessorSnapshotJson

@openmixer/coreOne Processor node serialised for a snapshot — the recursive-snapshot leaf of the chain-on-strip model.

ProjectionResult

@openmixer/coreThe outcome of projecting state onto the audio.

ReacSegmentConfigJson

@openmixer/coreOne REAC segment's DESIRED config as the session carries it — EXACTLY the writable set of `/reac/segment/{name}` (`2026-08-26-reac-runtime-config.md` §4), under that row's own address.

ReacSegmentsConfigJson

@openmixer/coreThe session block behind the REAC segments' desired config: one entry per asserted segment.

ReadView

@openmixer/coreWhat one READER of a row is: its resolution and its demand — the two things a served body may be narrowed by.

RecallKeeps

@openmixer/coreThe collections a recall would leave standing because the snapshot does not declare them.

RecallSafeMask

@openmixer/coreThe console-wide view of recall-safe: which channels (and which scopes on them) a recall leaves alone.

ReceivedRefusal

@openmixer/coreA refusal AS RECEIVED — the code exactly as the wire spelled it.

Refusal

@openmixer/coreA refusal: the code plus the named parameters a client needs to render or act on it.

RemappedLeg

@openmixer/coreOne leg re-pointed from an inactive profile onto the active one.

RenderedBand

@openmixer/coreOne correction an offline render applied to one track — what was cut, and the measurement that justified it.

RenderedTrack

@openmixer/coreWhat one track's offline render produced.

ResolvedInsertSuitabilityPolicy

@openmixer/coreA policy with every role resolved — what checks read.

ResolvedOutputEndpoint

@openmixer/coreThe outcome of resolveOutputEndpointOntoActiveProfile.

ResolvedResourcePolicy

@openmixer/coreResourcePolicy with every default filled in — what the registry acts on.

ResolvedTap

@openmixer/coreA resolved tap: the position whose **output port** the send picks off.

ResourceBroadcast

@openmixer/coreWhat every client is told after a successful patch or a reproject.

ResourceCommit

@openmixer/coreOne COMMITTED write, reported by the registry to every observer — the single seam through which a host drives autosave and undo for EVERY door at once (REST `PATCH`/`POST`/`DELETE`, a control surface's entity write, a…

ResourceCreateResult

@openmixer/coreThe result of a POST.

ResourceHandle

@openmixer/coreThe typed view of one registered entity, for internal callers — reads and writes go through the SAME pipeline as the transport, so there is no second dispatch path to drift.

ResourceInverseSteps

@openmixer/coreA row's own answer to "what puts the console back?", when the generic inverse cannot answer.

ResourceLifecycle

@openmixer/coreThe erased lifecycle view the registry dispatches on — id-in, outcome-out, with the address codec already applied.

ResourceMoldConfig

@openmixer/coreThe config members every mold declares — the trunk the shared base reads.

ResourceOptions

@openmixer/coreWhat `OPTIONS` answers: the methods allowed and the per-field capabilities.

ResourcePatchResult

@openmixer/coreThe result of a patch — the write, the projection, the broadcast and the ripples, together.

ResourcePatchStep

@openmixer/coreOne PATCH on one instance, as a replayable step — what a row-declared inverse is made of.

ResourceReadResult

@openmixer/coreThe result of a read.

ResourceRemoveResult

@openmixer/coreThe result of a DELETE.

ReverbState

@openmixer/coreA native algorithmic reverb (room/plate/hall behind one control surface).

RippleTarget

@openmixer/coreA cross-entity consequence of a write: after this instance commits, the registry re-projects and re-broadcasts the named instance.

RtHeadroomConfig

@openmixer/corePer-deployment overrides for the two documented thresholds (ratios of the RT budget).

RtHeadroomVerdict

@openmixer/coreOne headroom assessment.

RtLoadReading

@openmixer/coreOne RT load reading from the engine.

RtLoadSource

@openmixer/coreThe measurement source the server (and the headroom provider) polls — the RT-load counterpart of import('./telemetry.js').LatencyReportSource.

SafetySnapshot

@openmixer/coreThe session's gig-safety pre-loads.

SavedPatch

@openmixer/coreA standalone patchbay snapshot as stored on disk.

SavedScene

@openmixer/coreA whole-mix snapshot stored on disk.

SavedSession

@openmixer/coreA whole-console session as stored on disk (ZestBay `SavedSession` envelope).

SavedTake

@openmixer/core—

ScalarRecordConfig

@openmixer/coreEverything a row declares.

ScaleQuantity

@openmixer/coreOne tagged numeric quantity.

SceneSummary

@openmixer/coreThe list-row a `scene.list` returns (header only, body omitted).

SendJson

@openmixer/coreOne send: the destination output + the send level (and its tap point).

SendMatrixSpec

@openmixer/core—

ServedPatchEndpoint

@openmixer/coreA patch endpoint AS THE CONSOLE SERVES IT: the patch, plus what the live graph says about it right now.

SessionSummary

@openmixer/coreThe list-row a `session.list` returns (header only, body omitted).

SinkPortInventory

@openmixer/coreOne live SINK node as the resolver needs it: its node name and its playback ports **in canonical role order** — `ports[0]` is the L leg, `ports[1]` the R (the order `parsePwDump` already emits, FL/FR first, then the r…

SipCondition

@openmixer/coreThe two console-wide facts that decide whether solo-in-place is silencing anything at all.

SlotState

@openmixer/coreThe typed processing state a chain's nodes project to and from, held one concern at a time.

Snapshot

@openmixer/core—

Source

@openmixer/coreA named input with **physical preamp** identity, decoupled from any channel.

SourcePatch

@openmixer/coreWhere a source physically picks its signal up: an input on a named adapter.

SourceWidthInstance

@openmixer/coreWhat the PATCH says about ONE channel's width at this instant — the other per-instance half, supplied by whoever holds the crosspoint ledger (`channelSourceStereo`).

SpareInputJson

@openmixer/coreA pre-declared spare for a channel, and the SWAP LATCH over it: if the primary mic/DI dies mid-show, one tap re-points the strip onto the spare input and REMEMBERS what it displaced, so the reverse is one tap too (`20…

SpeakerAlignAim

@openmixer/coreWhere to read next, and what it costs.

SpeakerAlignAimState

@openmixer/coreWhere the reference window is being read, and whether that aim has been refined yet.

SpeakerAlignApplied

@openmixer/coreWhat one output's leg delay currently holds — the line a correction is a DELTA on.

SpeakerAlignCorrection

@openmixer/coreWhat APPLY would write on one output's leg delay, and whether the desk can write all of it.

SpectrumBand

@openmixer/coreOne log-spaced band.

SpectrumBandOptions

@openmixer/coreWhat aggregateSpectrumBands may be asked to vary; everything else is declared above.

SpectrumBandSeries

@openmixer/coreOne banded tap's two series on the wire: the RMS level per band, and its peak bin.

SpectrumTierInput

@openmixer/coreOne tier of a reading: the magnitudes, and the transform that produced them.

SrcDstAddress

@openmixer/coreOne crosspoint of a routing fabric, as `/{src}/{dst}` rows address it.

StageboxAssignCollision

@openmixer/coreOne destination the bulk assign would land on TOP of something.

StageboxAssignOp

@openmixer/coreOne `channel ↔ stagebox-port` mapping in a bulk plan.

StageboxAssignOptions

@openmixer/coreOptions for planStageboxAssign.

StageboxAssignPlan

@openmixer/coreThe computed bulk assignment (or clear) plan — pure data the server applies.

StageboxDevice

@openmixer/coreA REAC stagebox grouped as **one logical device**: its capture ports become the desk's inputs, its playback ports the desk's outputs.

StageboxEndpointGroup

@openmixer/coreOne side of a stagebox — its capture (input) or playback (output) channel bank.

StageboxFabricPlacement

@openmixer/coreWhere one side of one box lands in the 40-slot AUDIO fabric.

StageboxNodeView

@openmixer/coreThe minimal I/O-node shape the detector reads.

StageboxReconciliation

@openmixer/coreThe outcome of reconciling a declaration against an observation.

StateCell

@openmixer/coreOne instance's state slot: read a copy-safe view, write the whole next state.

StateStation

@openmixer/coreWhere a mold's state lives.

StereoPair

@openmixer/core—

StoredBoxInput

@openmixer/coreA stagebox input by IDENTITY: the registry's `boxId`, and a 1-based input on that box.

StoredPatchEndpoint

@openmixer/coreA stored endpoint: its left/mono leg, plus a right leg when the source is a stereo pair.

StripDef

@openmixer/coreOne console strip.

Subgroup

@openmixer/coreOne audio subgroup: the group bus id (a `mix`-kind channel), its master linear gain, its mute, the input channels assigned into it, and how it folds into the main mix.

SuitabilityCheck

@openmixer/coreOne dimension of suitability.

SuitabilityContext

@openmixer/coreWhat a check is handed.

SuitabilityFinding

@openmixer/coreOne check's result.

SurfaceEntityWrites

@openmixer/core—

SurfaceHost

@openmixer/coreThe north-side contract a **control surface** (a physical MIDI desk like the Behringer X-Touch / a Mackie MCU, an OSC client, or the web UI) binds to.

SurfaceMapJson

@openmixer/coreA surface map: one control surface's channel assignment (e.g.

SurfacePageJson

@openmixer/coreOne USER page — the operator's curated strip set on the bay (USER 1–4 on a Midas PRO, "user banks" on an X32).

SurfacePagesJson

@openmixer/coreThe session block behind `/surface/pages`: the ordered page set.

SurfacePreferencesJson

@openmixer/coreEvery operator view selection the console remembers — the LOOK of the desk, as opposed to the state of the mix.

SurfaceTemplate

@openmixer/coreOne ready-made preset for a control surface, selectable in the Setup menu.

TakePrint

@openmixer/core**THE SHOW'S DELIVERABLE** — the take's MAIN capture written out as a fixed-point print.

TakeRender

@openmixer/coreThe offline HRP render of a take — additive, versioned, and absent on every take recorded before one was run.

TakeSummary

@openmixer/coreONE TAKE AS THE LIBRARY PUBLISHES IT — the header `/takes` and `/takes/{id}` answer.

TakeTrack

@openmixer/core—

TalkbackMicSlot

@openmixer/coreThe talkback mic slot — a **placeholder** for a real talkback microphone.

TalkbackRoute

@openmixer/coreWhere a generator / the talkback mic feeds: a channel, bus or monitor head.

TalkbackSection

@openmixer/coreThe whole talkback section: the three generators keyed by role, plus the mic slot.

TaperPoint

@openmixer/coreOne breakpoint on a piecewise taper: normalized position ↔ engineering value.

TaperPointDef

@openmixer/coreOne breakpoint of a piecewise taper: normalized surface position ↔ engineering value.

TapPoint

@openmixer/coreOne named reference point in a strip's signal path.

TapPointSet

@openmixer/coreThe ordered tap points a model exposes — the desk's SKELETON.

TapState

@openmixer/coreThe accumulator: recent tap timestamps (ms), oldest→newest, bounded to TAP_WINDOW+1.

TemplateMatch

@openmixer/coreOne template resolved against a concrete path: which entity, and which instance.

TopologySpec

@openmixer/coreThe spec buildTopology consumes: what channels, what features, what routing.

UdpEndpointConfig

@openmixer/coreConfiguration for UdpEndpoint.

UdpPeer

@openmixer/coreWhere a datagram came from — the return address a reply is sent to.

UdpServerSocketLike

@openmixer/coreThe slice of a `dgram.Socket` a listening endpoint uses.

UdpSocketLike

@openmixer/coreThe slice of a `dgram.Socket` this transport uses.

UdpTransportConfig

@openmixer/coreConfiguration for UdpTransport.

UnenumerableContract

@openmixer/coreA contract that has no runtime table of facts to walk at all.

WorkflowProfile

@openmixer/core—

AdapterDeviceConfig

@openmixer/serverDevice wiring passed to an external adapter's factory/constructor.

AdapterFileShape

@openmixer/serverThe on-disk shape of the adapter config file.

AdapterLiveStatus

@openmixer/serverThe LIVE half of one adapter — status, never settings (rest-entity-map §5: `/adapter/{id}` — `/settings` · `/status` (live, never persisted — the half conflated into `adapter.list`)).

AdapterManagerOptions

@openmixer/serverOptions for AdapterManager.

AutorouteSinkCandidate

@openmixer/serverThe sink shape pickAutorouteSink needs (both `IoNode` and the wire node satisfy it).

AwaitableScanProvider

@openmixer/serverA DiscoveryProvider that can additionally run ONE awaitable scan pass.

BuiltinDspMirror

@openmixer/serverThe handle installBuiltinDspNativeMixerMirror returns (task #125).

BuiltinDspNative

@openmixer/serverThe native strip DSP surface the built-in-processor bridge drives (setStripEq/setStripDyn), as a structural subset so it is unit-testable with a fake.

BusStateMessage

@openmixer/serverBroadcast after a bus-master move: the bus's new master level (+ whether it is stereo).

CapturedChannel

@openmixer/serverOne channel's reusable processing, as captured/applied by the provider.

ChainProcessorState

@openmixer/serverOne processor in a reorderable chain, as broadcast to clients.

ChainReading

@openmixer/serverThe chain AS READ — the ordered stages plus the resolved index of every named tap preset, with no wire envelope.

ChannelAddress

@openmixer/serverA `{ kind, index }` channel address as it arrives on the wire.

ChannelConfigStoreOptions

@openmixer/serverOptions for ChannelConfigStore.

ChannelRef

@openmixer/serverCompact `{ kind, index }` reference sent on the wire.

ChannelSnapshotJson

@openmixer/serverA single channel's full snapshot.

ConformanceDesk

@openmixer/serverA running conformance desk.

ConformanceDeskOptions

@openmixer/serverHow the conformance desk is dimensioned and where it keeps its state.

ConsolePresenceGraph

@openmixer/serverThe narrow graph read detectForeignConsole needs (satisfied by `PwGraph`): the live registry mirror's objects, pw-dump-shaped.

ConsoleRigPlan

@openmixer/serverThe pure, testable decisions startConsole builds from — resolved off a config.

ConsoleSnapshot

@openmixer/serverThe full console body — every addressable element of state.

ConsoleStateProvider

@openmixer/serverReads + writes the live console state for the persistence stores.

CueNative

@openmixer/serverThe native strip-solo + console-wide cue surface the cue mirror drives (a structural subset of NativeConsoleMixer).

CueNativeMirror

@openmixer/serverThe handle installCueNativeMirror returns — mirrors BuiltinDspMirror's shape (currently empty; a poll-style method would go here if one becomes necessary).

CueRoutingNative

@openmixer/serverThe native-node surface buildNativeCueControl adapts — the subset of NativeConsoleMixer the cue/monitor ROUTING control (#191) drives: publish the cue bus (`addCue`), push its master stage (`setCue` — the monitor leve…

DcaStateReport

@openmixer/serverOne DCA's whole state; `removed` is the teardown echo.

DemoBusOutput

@openmixer/serverA per-bus output routing: which output bus feeds which demo output endpoint.

DemoNode

@openmixer/serverOne created virtual PipeWire node: its base name, both port pairs, and the kill handle.

DemoNodeFactory

@openmixer/serverCreates the demo's virtual I/O nodes.

DemoNodes

@openmixer/serverThe full set of nodes a demo topology created, for logging + teardown.

DemoTopology

@openmixer/serverThe result of buildDemoTopology: the software options + node handles + routing.

DetectConsoleSizeOptions

@openmixer/serverOptions for detectConsoleSize.

DetectedConsoleSize

@openmixer/serverThe size the demo console was built at, and whether it came from detection or the default.

DetectedResources

@openmixer/serverThe host's audio I/O sorted into buckets the operator/lab cares about.

DetectResourcesOptions

@openmixer/serverOptions for detectResources.

DiscoveryControllerHooks

@openmixer/serverCallbacks the controller fires so the server can broadcast device changes.

DiscoveryControllerOptions

@openmixer/serverOptions for DiscoveryController.

EngineConsoleStateProviderOptions

@openmixer/serverOptions for EngineConsoleStateProvider.

ExclusiveTakeoverReport

@openmixer/serverWhat an exclusive takeover ANSWERS with: the latch's new value and what it released.

FeedbackLoopFrame

@openmixer/serverThe routing loop (howl-round) the engine's TOPOLOGY detector currently sees — a ring in the desired audio graph, e.g.

FlowLinkEdge

@openmixer/serverOne live link edge the flow sampler matches on (a structural subset of the native `PwLinkEdge` / the engine's `Edge`, so tests inject plain objects).

FlowWatchableMixer

@openmixer/serverThe mixer surface the flow watchdog samples + bounces (a structural subset of import('@openmixer/audio-engine').SoftwareMixer so tests inject a fake).

FlowWatchdogWiringOptions

@openmixer/serverOptions for wireFlowWatchdog.

FxDelayStore

@openmixer/serverThe structural shape of the server's DelayController the native mirror consumes (native-FX spec).

FxReverbStore

@openmixer/serverThe structural shape of the server's ReverbController the native mirror consumes.

GroupAssignedReport

@openmixer/serverWhat a stagebox bulk-assign did: what landed, what it skipped, and why.

HeadAmpSessionDoor

@openmixer/serverThe head-amp entity as session persistence consumes it: the typed registry handle plus the KNOWN-set read (`HeadAmpResource.knownFieldsFor`).

HeadStageAdapter

@openmixer/serverThe head-stage WRITERS the mirror wraps — the ADAPTER's, not the software mixer's.

HeadStageNative

@openmixer/serverThe native strip stage the head mirror drives — just its per-lane `setStrip`.

HeadStageRestore

@openmixer/serverThe canonical head-stage state the install-time push replays (#122) — read from the software mixer, whose per-strip records the session restore has already written by install time.

HealableMixer

@openmixer/serverThe reconcile-bearing mixer surface route healing drives (a structural subset of import('@openmixer/audio-engine').SoftwareMixer so tests inject a fake).

MainAutorouteOptions

@openmixer/serverOptions for MixerServer.autorouteMainOutput (the startup main → default-sink route).

MatrixNative

@openmixer/serverThe native-node surface buildNativeMatrixControl adapts — the subset of NativeConsoleMixer the first-class MATRIX strip control (#146) drives.

MeasurementRunSummary

@openmixer/serverOne measurement run, as a surface needs to describe it: enough provenance for an operator to judge a figure without opening a JSON file, and no prose the server had to invent.

MeasurementSourceCounts

@openmixer/serverHow many plugins take each dimension's figure from each source.

MetersMessage

@openmixer/serverA meter frame: per-channel 0..1 peak levels, broadcast a few Hz while signal flows (the surface animates each strip's meter from it).

MixerServerOptions

@openmixer/serverOptions for MixerServer.

MuteGroupStateReport

@openmixer/serverOne mute group's whole state; `removed` is the teardown echo.

NativeEngineAvailability

@openmixer/serverWhat missingNativeEngineMessage was handed — which half of the engine loaded.

NativeEngineLoaders

@openmixer/serverThe two halves of the native engine, as loaders.

NetworkConfigLayers

@openmixer/serverThe four override layers, highest precedence first.

NetworkValueSources

@openmixer/serverThe winning layer per resolved field.

OutputRouteNative

@openmixer/serverThe native-node surface buildNativeOutputRouteControl adapts — the subset of NativeConsoleMixer the per-destination output-route control (#158) drives.

OutputRouteState

@openmixer/serverOne output destination in a PatchbayOutputStateMessage: its role-keyed sink legs (`L` / `R`, at least one) + the per-destination trim (issue #158) + delay (issue #183).

OutputStateReport

@openmixer/serverA bus's output routing: its PRIMARY sink, and every sink it feeds with its own trim.

PatchbayAssignmentMessage

@openmixer/serverBroadcast after a crosspoint write (PATCH /patch/input/{kind}/{index}): a channel's current source assignment — either the registered source id it now references, or the raw endpoint it reads (for an implicit source).

PatchbayDevicesMessage

@openmixer/serverServed at `GET /patchbay/devices` / broadcast on device hot-plug: every patchable Device the desk sees, unified — local interfaces (a card's Sink + Source folded by `device.id`), REAC stageboxes, and loose app streams…

PatchbayLinksMessage

@openmixer/serverBroadcast after any crosspoint change (PATCH /patch/input/{kind}/{index}): the FULL set of input endpoints now feeding a channel's head — the crosspoint patchbay's multi-in state.

PatchbayStageboxesMessage

@openmixer/serverServed at `GET /patchbay/stageboxes` / broadcast on stagebox hot-plug: the REAC stageboxes currently detected among the live patchbay nodes, each grouped as one logical device (its import('@openmixer/core').StageboxDe…

PatchSnapshot

@openmixer/serverThe routing graph only — the input patch per channel + the output sink per bus.

PatchStateProvider

@openmixer/serverReads + writes just the live routing graph for the standalone patch store.

PipeWireDemoNodeFactoryOptions

@openmixer/serverOptions for PipeWireDemoNodeFactory.

PluginChainControllerOptions

@openmixer/serverOptions for PluginChainController.

PluginChainState

@openmixer/serverThe full ordered plugin chain for one strip — what every rack mutation answers with, and what `/channel/{kind}/{index}/inserts` publishes.

PluginSlotState

@openmixer/serverOne plugin slot in a strip's chain, as broadcast to clients.

ResolvedNetworkConfig

@openmixer/serverThe resolver's result: the effective binding plus the per-field provenance.

ResolvedWebConfig

@openmixer/serverThe fully-resolved web binding.

ResolveServerConfigOptions

@openmixer/serverOptions for resolveServerConfig.

RestCreateBody

@openmixer/serverA successful `POST`: `item` is the id the store minted, which is the whole reason this door cannot be a `PATCH` — until the store answered, there was no address to write to.

RestErrorBody

@openmixer/serverAnything that did not succeed.

RestIndexBody

@openmixer/serverThe resource index at the router's root — how a client discovers what this desk declares.

RestOptionsBody

@openmixer/serverA successful `OPTIONS`: the methods, and what each field can do ON THIS INSTANCE.

RestPatchBody

@openmixer/serverA successful `PATCH`: the state after the write, plus what reaching the audio actually did.

RestRemoveBody

@openmixer/serverA successful `DELETE`: the item is gone.

RestRequest

@openmixer/serverOne HTTP request, reduced to what the router needs.

RestResponse

@openmixer/serverWhat the host should write back.

RestRouterOptions

@openmixer/serverWiring for RestRouter.

RestStateBody

@openmixer/serverA successful `GET`: the ONE state, as the entity's owner holds it.

RouteHealingOptions

@openmixer/serverOptions for wireRouteHealing.

RouteMatch

@openmixer/serverWhat a concrete request path resolved to.

RouteStateReport

@openmixer/serverA strip's summing assignment: MAIN, plus the `mix` groups it feeds.

RtaOverlayMessage

@openmixer/serverA real-time-analyzer frame for the EQ-CURVE OVERLAY (the /rta rows over ?watch=1): a compact, log-frequency-aggregated, 0..1-normalised band set — cheap enough to redraw every poll behind a live-dragged EQ curve.

RtLoadState

@openmixer/serverThe engine's RT load on the wire (task #121): the measured busy-per-quantum reading (see core `RtLoadReading` — ratios of the real cycle budget) plus the headroom verdict's honest operator copy.

RuntimeNetwork

@openmixer/serverA bin's fully-resolved network runtime: the binding + provenance + the state paths.

SafetyConfigState

@openmixer/serverThe gig's safety pre-loads as a client sees them (`GET /safety` is the row).

SendStateReport

@openmixer/serverTHE STRUCTURAL CONTROLLER'S ANSWER SHAPES — payloads, not wire frames.

ServerCli

@openmixer/serverThe parsed CLI layer: network overrides + the state dir + config file + help request.

SessionStoreOptions

@openmixer/serverOptions for SessionStore.

SpectrumMessage

@openmixer/serverA real-time-analyzer frame for the STANDALONE panel (the /rta rows over ?watch=1): raw linear-magnitude FFT bins for one channel (any lane the desk is analysing — see `/channel/{kind}/{index}/rta`).

SpectrumTap

@openmixer/serverOne tap of a SpectrumMessage: a HIGH tier (inline) + an OPTIONAL decimated LOW tier (issue #95).

SpectrumTier

@openmixer/serverA LOW-tier spectrum, riding alongside a SpectrumMessage's HIGH-tier top-level fields (issue #95, "zoom-FFT"): same shape, same `fftSize`, a ~8× lower `sampleRate` — see `mix_dsp.h`'s decimated LOW tier.

StartConsoleOptions

@openmixer/serverOptions for startConsole.

StereoSourcePatchOp

@openmixer/serverOne planned `channel <- endpoint` patch op (planStereoSourcePatch).

StripPortMirror

@openmixer/serverThe registry-mirror read the width barrier gates on (satisfied by `PwGraph`): resolve a JACK-style `node.name:port.name` to its live port id, or `undefined` when the mirror does not (yet, or any longer) hold it.

StripWidthNative

@openmixer/serverThe narrow native surface buildNativeStripWidthHook drives — the strip-width subset of NativeConsoleMixer: the in-place width reconfigure (which reports success — `false` on a failed port swap) and the live per-strip …

StructuralDsp

@openmixer/serverThe structural-DSP capability the server drives — exactly the structural surface of import('@openmixer/audio-engine').SoftwareMixer.

StructuralDspControllerOptions

@openmixer/serverOptions for StructuralDspController.

SurfaceDetection

@openmixer/serverOne first-run autodetect hit — a surface type whose default settings probed present.

SurfaceWatchdogOptions

@openmixer/serverOptions for SurfaceWatchdog.

TelemetryBroadcasterOptions

@openmixer/serverOptions for TelemetryBroadcaster.

TelemetryMessage

@openmixer/serverA periodic latency-telemetry frame — the tick is held open by `?watch=1` streams of the telemetry rows.

WireCueSection

@openmixer/serverThe whole cue section on the wire — mirrors WireTalkbackSection's shape.

WireCueSoloSafeEntry

@openmixer/serverPer-channel solo-safe entry on the wire cue section.

WireFbsChannel

@openmixer/serverOne channel's FBS arming + pool usage on the wire.

WireHotInput

@openmixer/serverOne physical input still holding +48 V that no channel sources any more (#384).

WireIoNode

@openmixer/serverOne live PipeWire I/O endpoint on the wire (a patchbay source or sink).

WireIoNodeFilter

@openmixer/serverThe operator's node-filter overrides, echoed on the wire.

WireTalkbackGenerator

@openmixer/serverOne generator on the wire (its params + route + PipeWire node name).

WireTalkbackMic

@openmixer/serverThe talkback mic slot on the wire (a placeholder until a real mic source is chosen).

WireTalkbackSection

@openmixer/serverThe whole talkback section on the wire.

Types (237)

NamePackageSummary

AbsentDeviceParams

@openmixer/coreA hardware-backed entity whose device is not on the rig: what it is, and which one.

AdapterFactory

@openmixer/coreA factory that turns validated settings into a live AdapterInstance.

AdapterFieldWidget

@openmixer/coreThe widget a settings field renders as (same metadata→widget idea as plugin params).

AdapterKind

@openmixer/coreWhat an adapter type binds: an I/O endpoint (`io` — PipeWire, a stagebox) or a control surface (`surface` — MCU/X-Touch).

AdapterPresenceProbe

@openmixer/coreA cheap, never-throwing presence probe: whether the physical endpoint the settings describe currently exists (a MIDI port on the seq list, a rawmidi char device).

AdapterRole

@openmixer/coreThe DSP-ownership role of a south-side adapter (the client/server axis of the I/O + control architecture — see `an internal spec` §3).

AdapterStatus

@openmixer/coreRuntime status of an instantiated adapter (reported, not persisted).

AdapterType

@openmixer/coreThe adapter families the framework can drive.

AlignArrival

@openmixer/coreWhich of a correlation peak's two names is true for THIS pair — the physics the arithmetic cannot know (see the module doc).

AlignFitRefusalCode

@openmixer/coreOne of the arithmetic's own refusals — see ALIGN_FIT_REFUSALS.

AlignRefusalCode

@openmixer/coreWhy a measurement has no fit — see ALIGN_REFUSALS.

AlignResult

@openmixer/core—

AnyCodedMessage

@openmixer/coreThe discriminated union over EVERY code — what a field or a wire frame is typed as when it can carry any message.

AtomicChannelPart

@openmixer/coreA part that maps directly onto a set of stored fields.

BandOrigin

@openmixer/coreThe closed set of machine band owners.

BayMenuPosition

@openmixer/core—

BiquadCoeffs

@openmixer/coreOne biquad section's normalised coefficients `[b0, b1, b2, a1, a2]` (a0 folded to 1).

BiquadKind

@openmixer/coreThe RBJ biquad kind that realises an EQ section.

BiquadType

@openmixer/coreThe filter shapes a drawn band can take — the PLUGIN/surface spelling, as it comes off an LV2 filter-type enum or a UI band picker.

BlindGlobalParams

@openmixer/coreA discovery protocol that could not scan at all (no link scope).

BlindLinkParams

@openmixer/coreA discovery protocol that could not scan a specific link.

BlockLevel

@openmixer/core—

BoundsResolution

@openmixer/coreWhat following a fact's pointer produced.

BridgedKind

@openmixer/coreThe chain-`ProcessorKind`s that carry a bridged typed state (eq · gate · dynamics=compressor).

BusyLinkParams

@openmixer/coreA link too busy to active-probe, with what the listen window actually saw.

CensusVerdict

@openmixer/coreWhat one axis of one fact answered.

ChainParamRoute

@openmixer/coreWhere one generic control lands: the row that owns the fact, its field, and the stored value.

ChannelConfigMoveValue

@openmixer/coreOne moving value as the wire spells it.

ChannelFact

@openmixer/coreA fact a channel can carry.

ChannelFeature

@openmixer/coreEvery per-channel capability feature — DERIVED from FACT_FEATURES's declared words.

ChannelKind

@openmixer/core—

ChannelPart

@openmixer/coreA part the operator can select, including the convenience groupings.

ChannelProcessor

@openmixer/core—

ChannelRole

@openmixer/coreA destination channel ROLE — which leg of a (stereo, later surround) bus a port carries.

ChannelWidth

@openmixer/coreA channel's audio **width**: a single **mono** input, or a **stereo** L/R pair carried on ONE strip (the strip's fader is the level, its pan is the balance).

ClockDriverParams

@openmixer/coreThe node driving the PipeWire graph.

ClockOwnerParams

@openmixer/coreThe device observed owning the clock pace alongside openmixer.

CodedRefusalParams

@openmixer/coreThe named fields a refusal carries for the client to interpolate into its own text.

CollectionFieldSpecs

@openmixer/core—

CompField

@openmixer/coreThe dynamics (compressor) row's fields: its engineering-unit state, whole.

CompositeChannelPart

@openmixer/coreA grouping of atomic parts under one operator-facing word.

CompParamId

@openmixer/coreThe generic compressor control ids — `compToParams`' layout, the compressor's only vocabulary.

ConfiguredIfaceParams

@openmixer/coreThe NIC an absent box is configured on.

ConfirmSheet

@openmixer/coreEvery confirm-gated operation this console declares, keyed by the operation row's path.

ConsoleFact

@openmixer/coreEvery fact the console itself holds.

ConsoleFetch

@openmixer/coreThe `fetch` this client dials with.

ConsoleProfileId

@openmixer/coreThe console appliances openmixer ships.

ConsoleRowListener

@openmixer/coreNotified once per row: the opening snapshot first, then every committed change.

ConsoleWriteOutcome

@openmixer/coreWhat a write did, in the three answers that are genuinely different.

ContractName

@openmixer/coreA contract the census can be asked about.

ContradictionCountParams

@openmixer/coreThe same, for a fact counted rather than named (a width, a channel count).

ContradictionParams

@openmixer/coreA stored value that disagrees with what the hardware reports.

ControlUnit

@openmixer/coreOne declared travel's unit.

CopyableField

@openmixer/coreAny field a part may carry.

CorrectionNotice

@openmixer/coreHow a client noticed the divergence it corrected — a CLOSED union, extended deliberately.

CreateOutcome

@openmixer/coreA creation either minted an id or was refused with a code.

Decibels

@openmixer/coreA level in DECIBELS — the operator-facing quantity, and the only one that is device-neutral.

Decoded

@openmixer/coreA decode either produced a narrowed value or a coded refusal — nothing in between.

DemandSheet

@openmixer/coreWhich rows are PUMP-FED — the rows a client must DECLARE before it is sent them, keyed by path template, each `true` (demand gate §3d, `an internal spec`).

DensityPreference

@openmixer/core—

DependentCountParams

@openmixer/coreA count of restored patches/routes that depend on an absent device.

DiscoveryOutcome

@openmixer/coreThe outcome of a discovery pass — the three states that must never collapse into one: - `found` — N devices positively identified.

DiscoveryProtocol

@openmixer/coreThe network audio protocols a probe can discover.

DynamicsKind

@openmixer/coreThe dynamics processor kinds an appliance can offer per stage.

EnforcementMode

@openmixer/coreWhat an OBJECTIVE failure does on a given role.

EngineEvent

@openmixer/core—

EngineListener

@openmixer/core—

EqBandField

@openmixer/coreOne band row's settable fields — the band entity's own names.

EqBandName

@openmixer/coreLegacy console-band names (Low … High).

EqBandType

@openmixer/coreWhat SHAPE a parametric band takes.

EqCharacter

@openmixer/coreChannel-EQ band character an appliance offers.

EqFillMode

@openmixer/core—

EqFilterField

@openmixer/coreOne pass-filter row's settable fields (`slope` is what makes a filter not a band).

EqHeadroomProvider

@openmixer/coreA pluggable check for whether `desiredAddCount` more bands can be added to `eq` right now.

EqParamRoute

@openmixer/coreAn EQ route — the subset routeEqParam answers with.

EqPresetId

@openmixer/coreThe identifiers of the selectable band-count presets, in picker order.

FactAbsenceRule

@openmixer/coreWhat a whole-state RESTORE does when a persisted fact is ABSENT from the file (spec revision 3, #665).

FactControl

@openmixer/coreWhat KIND of control carries a fact, in `ProcessorParam`'s own words.

FbsAction

@openmixer/coreWhat the corrector did — the trace log's action column.

FbsHold

@openmixer/coreA live notch's clean-hold time before it lifts: SECONDS, or `'never'`.

FbsMode

@openmixer/coreA channel's FBS arming mode: `ringout` = soundcheck assistant (finds stay put), `live` = show protection (finds may lift again after a clean hold).

FieldSpec

@openmixer/coreOne cell of a field table.

FieldSpecs

@openmixer/core—

FilterSlope

@openmixer/coreA pass filter's roll-off steepness, in dB per octave (12 = one biquad, 24 = two cascaded).

Freshness

@openmixer/coreThe freshness verdict the surface renders.

FxCategory

@openmixer/coreInternal-FX engine categories an appliance's rack can host.

GateField

@openmixer/coreThe gate row's fields: its engineering-unit state, whole.

GeneratorKind

@openmixer/coreThe three built-in generators.

GpuVendorName

@openmixer/coreThe GPU vendors this probe recognises; anything else is reported honestly as unknown.

HardwareFact

@openmixer/coreWhich observable fact a stored value disagrees with.

HardwarePresence

@openmixer/coreWhere a hardware-backed entity stands right now.

HeadAmpFeature

@openmixer/coreThe three CONTROLS a head-amp capability declares — the boolean fields of HeadAmpCapability, named as a type so a caller that ranges over "which head-amp features does this input have?" cannot accidentally range over …

HeadAmpField

@openmixer/coreOne writable param of a preamp record — the fields a `/channel/{kind}/{index}/headAmp` PATCH may name, and the keys the known-set is kept per.

HrpChannelStateJson

@openmixer/coreThe persisted shape.

HrpMode

@openmixer/coreThe operator's word, straight from the UI spec (§27): `monitor` analyses and SHOWS — detected note, measured harmonics, the cut it would make — and never touches the EQ; `adaptive` applies safe corrections automatically.

IdentifyPort

@openmixer/coreHow a live port is identified for STORAGE: the box input it carries, or `undefined` when no enrolled box owns it (an app stream, a loopback, a sound-card input).

InputInit

@openmixer/coreHead-amp VALUE + name/icon overrides accepted when a physical input is FIRST registered (mirrors makeSource's init).

InsertLatencyCode

@openmixer/coreOne of the INSERT_LATENCY_CODE codes.

InsertPlacement

@openmixer/coreInsert placement vocabulary; `movable` = a free-reorder desk.

InsertRole

@openmixer/coreWhat a destination is FOR — the axis every suitability budget is keyed on.

InstrumentFamily

@openmixer/coreThe instrument family a template belongs to — groups templates for a picker and bounds a family's expected compressor ratio (see FAMILY_COMP_RATIO_BOUNDS).

LatchAudit

@openmixer/coreThe audit's verdict.

LatencyBudgetParams

@openmixer/coreThe named fields a latency finding carries, for the client to interpolate.

LegacyTap

@openmixer/coreThe legacy two-way tap, kept as an alias of the TapPreset it maps to.

LinearGain

@openmixer/coreA LINEAR amplitude coefficient: what a summing stage multiplies a sample by.

MagnitudeSeries

@openmixer/coreA magnitude series as any consumer receives it: the addon hands bins over as ONE `Float32Array` (2026-08-29 — a JS array built one property set per bin was ~10 % of the engine's CPU), and the wire, a test or the offli…

MeasurementBusyParams

@openmixer/coreHow busy the engine was when a plugin analysis was refused.

MessageCode

@openmixer/coreEvery code this bridge knows.

MessageParamRecord

@openmixer/coreThe parameter record shape every MessageParams entry conforms to.

MessageParams

@openmixer/coreEvery message code, mapped to the parameters its localised sentence interpolates.

MessageParamValue

@openmixer/coreWhat a localised sentence may interpolate: wire-serialisable scalars only.

MissingHardwareKind

@openmixer/coreThe kind of a missing device (mirrors the manifest's three categories).

MissingHardwareParams

@openmixer/coreA device absent from a restored show, with its dependency clauses already joined.

NativeStageId

@openmixer/coreA native stage id — the value the native walk indexes its kernels by, matching `mix_order.h`'s `enum omx_stage` and `@openmixer/pipewire-native`'s `MIXER_STAGE`.

NativeStageKind

@openmixer/coreA processor kind that maps to a native reorderable stage.

NoMessageParams

@openmixer/coreThe parameter type of a code whose sentence interpolates nothing.

NoOperationColumn

@openmixer/coreA mold generic that carries nothing — the shape of "this operation declares no such column".

OccupiedPatchMode

@openmixer/core—

OperationParamCodecs

@openmixer/coreAn operation's declared parameters: one core FieldCodec per argument.

OscArg

@openmixer/coreOne typed OSC argument to encode.

OscDecodedArg

@openmixer/coreOne argument off the wire.

OscTag

@openmixer/coreThe OSC type tags a message can be ENCODED with — all any supported desk accepts.

OtherScopesParams

@openmixer/coreThe NIC scopes reac-pw IS watching, for a NIC it is not.

OutputEndpoint

@openmixer/coreA leg-aware sink endpoint: an OPEN map from channel ROLE to the physical sink port that leg feeds.

OutputRoute

@openmixer/coreOne output destination: the leg-aware sink endpoint (OutputEndpoint — role→port) plus an optional per-destination `trimDb` / `mute` / `delayMs`, and — only when a stereo bus folds onto a single mono leg — the per-leg …

OutputRouteJson

@openmixer/coreThe persisted form of one output route — the OutputRoute object (role-keyed).

OwnershipRule

@openmixer/coreWHO ACTUATES A WRITE to a fact, declared once per fact rather than hand-coded per control (control-ownership.ts's `ControlOwnership`/`ControlDomain` generalised into a static declaration; #563's union).

PanelPlacement

@openmixer/core—

PanicScope

@openmixer/coreWhich targets a panic silences: the main bus(es), or every input channel.

PasteLabelParams

@openmixer/coreAn undo entry for a paste: how many channels it landed on, so the affordance can say "undo paste (3 channels)" without the client counting anything itself.

PatchOutcome

@openmixer/coreThe outcome of applying a patch to the one state: it either happened, with the state after, or it was refused, with the code.

PerKindFeatureMatrix

@openmixer/coreA per-channel-kind feature matrix: the set of ChannelFeatures each kind exposes.

PersonalityId

@openmixer/coreA personality (skin) id — the canonical union, owned here in core.

PhysicalInputId

@openmixer/coreA stable, comparable **physical-input identity** — the key that says *"this stagebox / reac-capture port"* independent of any channel.

PluginInstancesParams

@openmixer/coreWhy the plugin host has no instance slot left: how many ids mod-host has (`max`, its own declared `0 ~ N` range) and how many of them are LEAKED — bypassed, un-racked, and still holding their id because mod-host's `re…

Position

@openmixer/coreA surface fader POSITION: where the cap sits on its throw, 0..1, with 0.75 the unity detent on `NormalizedScale`.

ProbeErrorParams

@openmixer/coreA probe that failed with a host/system error, named for the operator.

ProcessingOrderMode

@openmixer/coreHow the operator may reorder the processing chain.

ProcessingPanelPins

@openmixer/coreThe operator's placement PINS, one per screen class.

ProcessingSection

@openmixer/coreThe processing sections that EXIST on this appliance; absent ⇒ the section is hidden.

ProcessorKind

@openmixer/core—

ProcessorParam

@openmixer/coreOne processor control: a numeric (with a Param spec), a toggle, or an enum choice.

ProcessorParamDef

@openmixer/coreA processor parameter — discriminated on `kind`.

RangeSource

@openmixer/coreWhere a fact's presentation LIMITS come from — never a hardcoded constant (#66's precedent, `HeadAmpCapability.gainRange` / `headAmpGainRangeOf`).

RateBasis

@openmixer/coreWhere the sample rate a judgement used came from — the honesty field.

ReacCfgRateRefusal

@openmixer/core—

ReacCfgRateState

@openmixer/core—

RecordSpaceParams

@openmixer/coreWhat the record gate found short: the bytes it wants before it will start, and the bytes the disk actually has.

RefusalCode

@openmixer/coreWhy a write (or a field) is refused — a CLOSED union.

RegisteredPath

@openmixer/coreAn entity that is registered today.

RemoveOutcome

@openmixer/coreA removal either happened or was refused with a code — there is no third shape.

RenderSpaceParams

@openmixer/coreWhat a render needs and what the disk has.

ResolveBoxInput

@openmixer/coreHow a stored box input is resolved back to a live port: the port that box currently exposes for that input, or `undefined` when the box is ABSENT — not plugged in, or on no segment.

ResolvedEndpoint

@openmixer/coreWhat resolving a stored endpoint produced.

ResolvedFactOwner

@openmixer/coreA fact's owner with every CONDITION EVALUATED — OwnershipRule minus the conditional `peer` wrapper: what actually owns the fact for THIS context, one answer.

ResourceCommitListener

@openmixer/coreNotified after every committed write.

ResourceCommitMethod

@openmixer/coreWhich door of an entity committed — a write, a removal, or a creation.

ResourceFault

@openmixer/coreWhy a request could not be served, in a form a transport can map to a status.

ResourceId

@openmixer/coreThe path variables selecting one instance — e.g.

ResourceMethod

@openmixer/coreWhat a client may do to a resource instance.

ResourcePolicy

@openmixer/coreWhat a COMMITTED write to this entity means for the console's bookkeeping — the session's dirtiness and the operator's history — declared once beside ConsoleResource.path, ConsoleResource.ripples and ConsoleResource.l…

ResourceTravels

@openmixer/coreEvery travel one row declares, keyed by field name — a row's half of the desk's declaration.

RouteLabelParams

@openmixer/coreAn undo entry naming a route between two scopes.

RtBudgetParams

@openmixer/coreHow much of the real-time budget the engine is spending.

RtHeadroomLevel

@openmixer/coreHow much headroom the engine has: `ok` (plenty), `warn` (spending it), `refuse` (non-essential DSP adds endanger the RT budget).

RtHeadroomProvider

@openmixer/coreThe headroom provider the add-band guard consumes (task #120 defines the seam; this is the REAL provider satisfying it — #120's own default is always-allow-under-cap, so the integrator swaps that default for this).

SafeScope

@openmixer/coreThe parameter groups a channel can be recall-safed independently.

ScopeLabelParams

@openmixer/coreAn undo entry naming one console scope (`CH3`, `Main`, `Aux2`).

ScreenClass

@openmixer/core—

SendSpec

@openmixer/coreA declarative **send matrix** description: a cross-product of source kinds → destination kinds (a cross-point exists when the source is one of `from`, the destination one of `to`, and both are real channels present in…

SendTap

@openmixer/coreA send's tap point relative to the channel fader.

SendTapSpec

@openmixer/coreWhere a send taps the channel.

ServerSocketFactory

@openmixer/coreFactory that produces a listening UDP socket.

Settlement

@openmixer/coreWhat a write left IN FLIGHT — `undefined` when the store committed within the call, the landing's promise when it did not.

SnapshotChannelField

@openmixer/coreAny `ChannelSnapshotJson` field a fact can ride — everything but the address.

SocketFactory

@openmixer/coreFactory that produces a UDP socket.

SourceId

@openmixer/coreA stable source identifier, unique within a console (e.g.

SpeakerAlignRefusalCode

@openmixer/coreWhy a loudspeaker-alignment reading has no fit — see SPEAKER_ALIGN_REFUSALS.

SpecPresentation

@openmixer/coreWhat a spec may add to a declared travel: how the throw MAPS and how the number READS.

StageboxAssignRefusal

@openmixer/coreOne of the STAGEBOX_ASSIGN_REFUSAL codes.

StageboxAssignRefusalParams

@openmixer/coreThe structured fields a refusal carries, for the client to interpolate into its own text.

StageboxDirection

@openmixer/coreWhich side of a stagebox a bulk assignment targets.

StageboxKey

@openmixer/coreAn opaque recognition key.

StageboxPresenceView

@openmixer/coreThe subset of StageboxDevice the presence check reads (link state + box identity).

StaleProbeParams

@openmixer/coreA reac-pw whose published sightings have all aged out.

StoredPatchLeg

@openmixer/coreOne leg of a stored endpoint.

StripKind

@openmixer/coreStrip kinds a console may contain — the model's own `ChannelKind` vocabulary (`model.ts`), reused so a validated definition can always address the engine.

SuitabilityKind

@openmixer/coreIs a finding physics or taste?

SuitabilityVerdict

@openmixer/coreA check's answer for one chain on one destination.

SurfaceTheme

@openmixer/core—

SurfaceWriteFact

@openmixer/coreWhich fact a surface gesture wrote — the closed set the door declares, one name per physical control.

SurfaceWriteOutcome

@openmixer/coreWhat the console did with one surface gesture, resolved at the LANDING: - `applied` — the row took it; the broadcast that repaints every surface is on its way.

TakeTrackLeg

@openmixer/coreThe strip leg a mono track file holds.

TalkbackGenerator

@openmixer/coreOne of the three built-in generators.

TalkbackTarget

@openmixer/coreThe routable talkback slots: the three generators plus the talkback mic.

Taper

@openmixer/coreHow a param's value maps to/from its 0..1 position: - `linear` — value is linear in position (`v = min + p·(max−min)`).

TaperKind

@openmixer/coreTaper kinds a number param spec may declare.

TapMode

@openmixer/core—

TapPointId

@openmixer/coreA tap point's id — the token that crosses the wire and keys a placement.

TapPreset

@openmixer/coreThe named tap-point presets — the **default tap landmark set**.

TopologyLayout

@openmixer/coreAn ordered per-kind channel allocation — the channels a topology presents, in surface order.

UdpDatagramHandler

@openmixer/coreOne inbound datagram, with the return address attached.

UnconfirmedReason

@openmixer/coreWhy the surface cannot currently vouch for what it renders.

UndoCoalesce

@openmixer/coreHow a same-scope undo record folds into its predecessor: `continuous` for a value that streams during a drag (a fader, a knob) so one gesture is one entry; `discrete` for a single deliberate action, which never folds.

UndoSetLabelCode

@openmixer/coreThe code family for a `set` undo label — `undo.label.set.<param>`.

UndoSetParam

@openmixer/coreOne of UNDO_SET_PARAMS.

UnknownProbeStateParams

@openmixer/coreA reac-pw publishing a discovery state this build has no meaning for.

VscRateParams

@openmixer/coreThe two rates a virtual soundcheck could not reconcile — the take's and the graph's.

Waveform

@openmixer/coreAn oscillator waveform.

WireDelta

@openmixer/coreA PATCH body exactly as the wire delivered it: unknown JSON.

WriteSource

@openmixer/coreWHO wrote — carried on the write, reported on the commit, and journaled on the entry.

XrunGraphParams

@openmixer/coreThe graph facts every xrun-growing detail carries: the running total, and what the graph is currently trading (quantum in frames + ms, and the rate those ms are measured at).

XrunRaiseHolderParams

@openmixer/coreXrunRaiseParams plus which node's request explains the current quantum.

XrunRaiseParams

@openmixer/coreXrunGraphParams plus the one free step up the quantum ladder.

XrunRateParams

@openmixer/coreHow fast xruns are landing right now (issue #657) — a RATE, never the running total.

XrunRelaxParams

@openmixer/coreXrunGraphParams plus which node's request explains the current quantum, with no room left to raise (the ceiling is already reached).

AdapterName

@openmixer/serverA console family the server can drive.

ChainTarget

@openmixer/serverWhether a chain verb targets a channel strip or a bus-master chain.

DcaEntry

@openmixer/server—

DelayField

@openmixer/serverEditable delay fields; the REST delay row carries the same set.

DemoLogger

@openmixer/serverA minimal logger sink (defaults to `console`), so size detection can report its verdict.

GateField

@openmixer/serverAn editable channel-gate field name (`on` or a numeric transfer/envelope field).

InsertPointResolver

@openmixer/serverResolve a strip's audio insert point (source + sink port pairs).

IoEnumerator

@openmixer/serverEnumerates the live PipeWire sources + sinks the patchbay offers (the import('@openmixer/audio-engine').PipeWireGraphProvider `.list()` shape).

MainAutorouteResult

@openmixer/serverThe verdict of MixerServer.autorouteMainOutput.

NetworkOverrides

@openmixer/serverA single layer's partial overrides (persisted file, CLI flags, or env vars).

NetworkValueSource

@openmixer/serverWhere a resolved network value came from.

OutputInsertSlot

@openmixer/serverOne desired output-insert slot (URI string or `{ uri, bypassed?

RestBody

@openmixer/server—

RestFault

@openmixer/serverFaults this layer can add to ResourceFault.

RetiredRigPreset

@openmixer/serverA retired preset name an installed config file may still carry.

ReverbField

@openmixer/serverEditable reverb fields; the REST reverb row carries the same set.

SendEntry

@openmixer/serverThe structural read shapes are the real SoftwareMixer ones, re-exported so the server (and its tests' fake) speak exactly what the live mixer returns — no narrowed twin to drift apart from it.

ServerConfig

@openmixer/serverFully-resolved, validated server configuration.

ServerConfigInput

@openmixer/serverThe pre-validation input shape of ServerConfigSchema (every field optional).

TelemetrySink

@openmixer/serverWhat one tick delivers: the polled report, or `undefined` on a console that has no latency source — the tick still fires, because the other gauges ride it.

WireSendTapSpec

@openmixer/serverA rich send tap spec on the wire (preset / position / legacy).

Classs (44)

NamePackageSummary

AssignableKeys

@openmixer/coreIn-memory store for assignable keys, keyed by `id`.

BaseAdapterInstance

@openmixer/coreThe `stopped → starting → running/error` (and back to `stopped`) machine every AdapterInstance re-derives, written once: `start()` flips to `starting`, runs bringUp, and lands on `running` — or catches, flips to `erro…

BlockLibrary

@openmixer/coreIn-memory store for blocks, keyed by `${level}/${name}`.

ChannelMuteResource

@openmixer/coreChannel mute as a ConsoleResource: `/channel/{kind}/{index}/mute`.

CodedRefusal

@openmixer/coreA refusal identified by a stable code.

CollectionResource

@openmixer/core—

ConsoleClient

@openmixer/coreA remote console, addressed the way it declares itself.

ConvergenceClient

@openmixer/core—

ConvergenceInstrument

@openmixer/coreThe counters and the log, pure and synchronous — the server registers the rows over it and calls observe from its one commit listener.

DerivedResource

@openmixer/core—

InputPatchbay

@openmixer/coreThe stateful input patchbay: channel → its single physical input, and physical input → its head-amp home.

InsertRefusedError

@openmixer/coreA refused insert: the destination cannot afford this chain and the role's enforcement is `refuse`.

LatchResource

@openmixer/core—

LifecycleGate

@openmixer/coreThe one lifecycle implementation: parse the id, refuse in codes when the address or the door is missing, otherwise call the row's door.

MapStation

@openmixer/coreA plain in-memory station: seeded instances, peek = claim, string-keyed.

MixerEngine

@openmixer/coreReads are a push observer (not promises): desks stream state after subscribe.

NormalizedScale

@openmixer/coreThe default console fader taper: a log-shaped throw with a unity detent at position 0.75, a +10 dB boost region above it, and a cut region that steepens toward TAPER_FLOOR_DB at the bottom.

OperationResource

@openmixer/core—

PerfHistogram

@openmixer/coreOne op's latency histogram.

PerfRegistry

@openmixer/coreA server's whole collection of named op histograms.

PersistenceTracker

@openmixer/coreInterframe persistence + growth tracker (IPMP + the #91 growth gate + the #116 sub-harmonic rejector).

ResourceMoldBase

@openmixer/core—

ResourceRegistry

@openmixer/coreHolds every declared entity and serves every request against them.

ScalarRecordResource

@openmixer/core—

StageboxAssignError

@openmixer/coreA refused stagebox assignment.

UdpEndpoint

@openmixer/coreA bound UDP socket that reports the sender, and sends to any peer.

UdpTransport

@openmixer/coreFire-and-forget UDP sender plus an inbound message pump.

AdapterManager

@openmixer/serverOwns the adapter registry, the live instances, and the config file.

ChannelConfigStore

@openmixer/serverPersists named per-channel configs and drives save/apply over a provider; also serves the read-only factory instrument templates through the same list/get/apply doors.

CliUsageError

@openmixer/serverA bad flag value — the bins print the message + help and exit non-zero.

CodedError

@openmixer/serverAn `Error` carrying a stable operator-facing ErrorMessage.code.

DiscoveryController

@openmixer/serverBridges a DiscoveryProvider to the AdapterManager + the server.

EngineConsoleStateProvider

@openmixer/serverReads/writes console state over the engine + plugin chains for the stores.

MixerServer

@openmixer/server—

NetworkSettingsStore

@openmixer/serverLoads + saves the persisted NetworkOverrides JSON file at a fixed path — the JsonSettingsStore discipline over the override shape.

PipeWireDemoNodeFactory

@openmixer/serverProduction DemoNodeFactory: spawns a `pw-loopback` per node (via loopbackArgs, the same audio-safe args the fader nodes use — `node.autoconnect=false` so a demo node never grabs the default sink on its own) and waits …

PluginChainController

@openmixer/serverOwns the plugin chains for every strip.

RateWatchingNativeMeterSource

@openmixer/serverThe native meter source with a per-poll hook: the adapter's EXISTING meter interval (`SoftwareMixerAdapter.startMeterPoll`) calls `read()` a few times a second, which makes it the free periodic path the built-in-DSP m…

RestRouter

@openmixer/serverMaps HTTP onto a ResourceRegistry, and does nothing else.

SessionStore

@openmixer/serverPersists whole-console sessions as JSON files and drives save/load over a ConsoleStateProvider.

StructuralDspController

@openmixer/serverDrives the structural-DSP operations onto the live mixer and produces the broadcast frame for each.

SurfaceWatchdog

@openmixer/serverSupervises presence-probeable adapter entries on a fixed cadence.

TelemetryBroadcaster

@openmixer/serverTicks while there are subscribers, polling the LatencyReportSource when there is one.

VirtualDemoNodeFactory

@openmixer/serverA NON-SPAWNING DemoNodeFactory: returns the same deterministic loopbackPorts port names as PipeWireDemoNodeFactory but starts NO `pw-loopback` process.

openmixer

A software mixing console for Linux. The desk is the software; the browser is the surface.

Pages

Licence

OpenMixer is free software under the GPL-3.0-or-later. Every package in the workspace carries the same licence.

Roland, Midas, Behringer, RME and the product names used here belong to their respective owners. OpenMixer is an independent project and is not affiliated with any of them.