openmixer — generated API reference
    Preparing search index...

    Interface StructuralDspControllerOptions

    interface StructuralDspControllerOptions {
        compFor?: (channel: ChannelId) => CompState | undefined;
        dsp: StructuralDsp;
        expectedLatency?: ExpectedLatencyResolver;
        faderScale: FaderScale;
        insertGuard?: InsertLatencyGuard;
        io?: IoEnumerator;
        outputChains?: PluginChainController;
        pluginControls?: (uri: string) => readonly PluginParam[] | undefined;
        pluginLegs?: (uri: string) => number | undefined;
        pluginName?: (uri: string) => string | undefined;
        pluginRoster?: () => readonly string[];
        resolveStageboxId?: (key: string) => string | undefined;
        resolveStageboxName?: (key: string) => string | undefined;
    }
    Index
    compFor?: (channel: ChannelId) => CompState | undefined

    Reads one strip's stored compressor, so the expected-latency figure can carry what the DETECTOR is spending (detectorLatencySamplesOf). A reader, never the store: the compressor belongs to CompController and this controller only asks it a question. When absent the figure is what it always was — every other term, and no detector term.

    The live structural-DSP surface (the SoftwareMixer).

    expectedLatency?: ExpectedLatencyResolver

    Optional expected-latency resolver — the catalog and clock reads behind /channel/{kind}/{index}/latency. When absent the row has nothing to derive from and every instance is honestly absent; the controller's own behaviour is unchanged either way, because nothing here judges or refuses on the figure.

    faderScale: FaderScale

    Fader taper used to map a wire 0..1 position to dB (then to linear amplitude).

    insertGuard?: InsertLatencyGuard

    Optional role-aware insert-suitability guard (issue #339). When present, every insert edit is judged against its DESTINATION's budget before anything is applied: a chain a monitor bus cannot afford is refused with a coded reason and nothing reaches the engine. Absent → inserts are applied unjudged, exactly as before.

    Optional live-I/O enumerator for the patchbay (patchbay.list). When absent the patchbay.list verb returns empty source/sink lists (the assign / output verbs still work — they wire by the endpoint the client picked).

    outputChains?: PluginChainController

    Optional output-insert chain controller. Reused PluginChainController (addressed by the bus id) so a bus's rack resolves its plugin descriptors the same way a strip's does. When absent the controller still drives the engine's setOutputInserts from the raw URIs.

    pluginControls?: (uri: string) => readonly PluginParam[] | undefined

    A plugin's CONTROL ports as the served descriptor declares them, so the parameter row can enumerate a racked plugin's parameters and publish each one's travel (StructuralDspController.insertControlsOf). Pass the descriptor's params narrowed to kind: 'control'. Absent, the row enumerates nothing and declares no travel.

    pluginLegs?: (uri: string) => number | undefined

    Resolve a plugin URI to its audio OUTPUT leg count, so the rack door can refuse a plugin too wide for the strip (ruling 2026-09-02). Pass catalog.get(uri)?.audioOutputs. Absent, or answering undefined for a URI, no width is judged — absence is not a finding.

    pluginName?: (uri: string) => string | undefined

    Resolve a plugin URI to its display name for the channel-insert plugin.chain echo (Bug G path). Defaults to echoing the URI. Pass catalog.get(uri)?.name.

    pluginRoster?: () => readonly string[]

    The plugin OFFER's roster — what the console lists at /plugins — so a strip's rack door can publish the members that fit it (StructuralDspController.insertOffer). Absent, no offer is published and the door accepts what it accepts.

    resolveStageboxId?: (key: string) => string | undefined

    Resolve a box's registry IDENTITY from its recognition key — what a stored patch names.

    resolveStageboxName?: (key: string) => string | undefined

    Resolve a stagebox's stored operator name from its recognition key (the persistent registry, Build A), so every detected/listed stagebox carries the name the operator gave the physical box — matched by identity, restored across sessions and reconnects. Absent → boxes keep their autodetected labels.