openmixer — generated API reference
    Preparing search index...

    Type Alias OwnershipRule

    OwnershipRule:
        | { fansOutToMembers: boolean; kind: "lane"; onMasterLane: boolean }
        | { kind: "device" }
        | { kind: "engine" }
        | {
            field: string;
            kind: "peer";
            otherwise: OwnershipRule;
            peer: string;
            when: (ctx: FactOwnershipContext) => boolean;
        }
        | { kind: "entity" }
        | { kind: "none"; reason: string }

    WHO 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). PHASE 3: the column is EVALUABLE — ownerOf resolves a fact's owner against live context, and every consumer (the server's ControlDomain wiring, the surface's gainOwnerOf) reads THIS declaration instead of hand-coding its own copy of the rule, so they cannot disagree.

    Type Declaration

    • { fansOutToMembers: boolean; kind: "lane"; onMasterLane: boolean }

      A native mixer lane carries it — the C ctrl[lane] array, resolved per channel by ownerOfControl (control-ownership.ts). onMasterLane mirrors ControlDomain.onMasterLane (does MAIN's lane carry it too); fansOutToMembers mirrors ControlDomain.fansOutToMembers (does a control-domain group — DCA/muteGroup — reach it only through its members' own lanes, never a lane of its own).

    • { kind: "device" }

      An external actuator outside the native lane array carries it, gated on THAT actuator's own presence — a hardware device (the REAC/RME head-amp writer) or the LV2 plugin host (mod-host). Never applied: true without a readback through that actuator (the southbound contract, §6c).

    • { kind: "engine" }

      A dedicated engine door carries it directly — not the native ctrl[lane] array, not a hardware actuator (the software mixer's structural routing ledger: sends, matrix crosspoints).

    • {
          field: string;
          kind: "peer";
          otherwise: OwnershipRule;
          peer: string;
          when: (ctx: FactOwnershipContext) => boolean;
      }

      Another entity claims the fact UNDER A CONDITION — writing the fact's own row while the condition holds would be a second door onto it (ControlOwnership's peer, e.g. the head-amp entity's claim over /gain). The condition is a FUNCTION of live context, not prose: ownerOf evaluates it, so the server's refusal and the surface's routing read one expression and cannot drift.

      • Readonlyfield: string

        The FIELD the peer row carries this fact as (the gain fact rides /headAmp as gainDb) — what makes a peer-row write attributable to this fact by a detector.

      • Readonlykind: "peer"
      • Readonlyotherwise: OwnershipRule

        Who owns the fact while the condition does NOT hold.

      • Readonlypeer: string

        The claiming entity, as a refusal names it (OWNED_BY_PEER's peer arg) and as the peer row spells its path suffix (/channel/{kind}/{index}/headAmp).

      • Readonlywhen: (ctx: FactOwnershipContext) => boolean

        The peer owns the fact exactly while this holds, evaluated against live context.

    • { kind: "entity" }

      Lives entirely in TS state — a store/entity the server owns, with no southbound write to reconcile at all (most persisted metadata, control-domain membership, every transient UI-only fact).

    • { kind: "none"; reason: string }

      Declared but genuinely unowned today — a known gap, not a design.

    Settings
    Member Visibility