@openmixer/omx-contract 1.1.0 → 1.2.1

package/dist/ts/omx-contract.d.ts

@@ -2,6 +2,17 @@
 // Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
 // GENERATED by `omx-contract render --target ts` from FreeMixer/omx-contract's data/ — do not edit.
 
+/**
+ * The PAN travel — −1 (hard left) … 0 (center) … +1 (hard right). A property of the pan law itself, not of any desk, so it is declared once. Continuous: a pan position has no quantum, and panGains clamps to these bounds.
+ * @see data/kernels/balance.json
+ */
+export declare const PAN_RANGE: {
+  readonly min: -1;
+  readonly max: 1;
+  readonly step: 0;
+  readonly unit: "";
+};
+
 /**
  * The chorus's right-leg phase offset, in TURNS of its one oscillator (§2, §3a; the native-FX catalogue's M32 Dimension row). The right leg's voice k reads the LFO at k/N + spread: 0 is both legs one phase (the stage without the field, bit for bit), 0.25 quadrature, 0.5 the Dimension's opposed sweep. A fraction of a cycle carries no engineering symbol, so the unit is ''.
  * @see data/kernels/chorus.json
@@ -15,6 +26,58 @@ export declare const CHORUS_SPREAD_RANGE: {
   readonly defaultFrom: "desk";
 };
 
+/**
+ * The chorus sweep's speed (§3a). Above ~3 Hz it stops being a chorus and becomes a vibrato.
+ * @see data/kernels/chorus.json
+ */
+export declare const CHORUS_RATE_RANGE: {
+  readonly min: 0.05;
+  readonly max: 8;
+  readonly step: 0.01;
+  readonly unit: "Hz";
+  readonly default: 0.6;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The chorus's peak-to-peak excursion above its declared 10 ms base (§3a).
+ * @see data/kernels/chorus.json
+ */
+export declare const CHORUS_DEPTH_RANGE: {
+  readonly min: 0;
+  readonly max: 12;
+  readonly step: 0.1;
+  readonly unit: "ms";
+  readonly default: 4;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The chorus's tap count — one oscillator read at k/N (§3a).
+ * @see data/kernels/chorus.json
+ */
+export declare const CHORUS_VOICES_RANGE: {
+  readonly min: 1;
+  readonly max: 4;
+  readonly step: 1;
+  readonly unit: "";
+  readonly default: 3;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The chorus's wet/dry, as an instance of DRIVE_MIX_RANGE — the same percent travel, its own come-up value: 35 %, a colour under the dry on a strip (§3a). The REVERB_LOWCUT_RANGE-over- REVERB_CUT_RANGE shape: one travel, one declared default per field that reads it.
+ * @see data/kernels/chorus.json
+ */
+export declare const CHORUS_MIX_RANGE: {
+  readonly min: 0;
+  readonly max: 100;
+  readonly step: 0.1;
+  readonly unit: "%";
+  readonly default: 35;
+  readonly defaultFrom: "desk";
+};
+
 /**
  * The legal range of each compressor field (engineering units). The widget clamps drags to these, `normalizeComp` enforces them, the row's codec refuses by them and the travel sheet publishes them. `default`/`defaultFrom` are the come-up values `defaultCompState` seeds a fresh strip with, read BACK from here rather than restated there.
  * @see data/kernels/comp.json
@@ -259,6 +322,71 @@ export declare const FX_DELAY_PINGPONG_DEFAULT: false;
  */
 export declare const DRIVE_BIAS_MAX: 0.7071067811865476;
 
+/**
+ * The PRE-CURVE gain, in dB. 0 dB is unity into the curve, so a stage switched on at its defaults changes almost nothing — which is what an `on` switch should mean. The ceiling is where every curve is saturating hard on any signal a console carries.
+ * @see data/kernels/drive.json
+ */
+export declare const DRIVE_AMOUNT_RANGE: {
+  readonly min: 0;
+  readonly max: 36;
+  readonly step: 0.1;
+  readonly unit: "dB";
+  readonly default: 0;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The EVEN/ODD harmonic balance. −1 is pure odd (the curve itself), +1 is pure even, 0 an equal blend — the kernel splits its own distortion residue into an odd and an even half and fades between them, so the two ends are exact rather than approximate (`mix_drive.h`, measured: H2 at −317 dBc at −1, H3 at −118 dBc at +1). Unitless, and signed by construction. NOT NORMALIZED_RANGE: this is a BALANCE with a meaningful centre, and a 0..1 travel would put its centre at 0.5 and its neutral nowhere.
+ * @see data/kernels/drive.json
+ */
+export declare const DRIVE_CHARACTER_RANGE: {
+  readonly min: -1;
+  readonly max: 1;
+  readonly step: 0.01;
+  readonly unit: "";
+  readonly default: 0;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The band split / tilt corner, in Hz. ONE travel for all three band modes, because the C imposes one constraint on all of them: it is the corner of a single biquad, and the split's other half is `x − LP(x)`. The full audio band, not the channel filters' narrower HPF/LPF pair — the same reasoning REVERB_CUT_RANGE records: a surface narrower than the row removes reach the console genuinely has.
+ * @see data/kernels/drive.json
+ */
+export declare const DRIVE_BAND_FREQ_RANGE: {
+  readonly min: 20;
+  readonly max: 20000;
+  readonly step: 1;
+  readonly unit: "Hz";
+  readonly default: 2000;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The wet/dry, as a PERCENT — the unit a drive control is read in on every desk that has one. Deliberately not NORMALIZED_RANGE (which is unitless 0..1): a mix a surface must label "0.35" when the operator thinks in "35 %" is a control whose declaration is fighting its reader. The kernel divides by 100 where it resolves the atom, in one place. The come-up is 100 %, not the reverb's modest 30: a saturator's insert use is IN the path. The `exciter` curve seeds itself lower (DRIVE_EXCITER_SEED), because that is a property of the TOPOLOGY and not of the travel.
+ * @see data/kernels/drive.json
+ */
+export declare const DRIVE_MIX_RANGE: {
+  readonly min: 0;
+  readonly max: 100;
+  readonly step: 0.1;
+  readonly unit: "%";
+  readonly default: 100;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The POST-stage make-up, in dB. Symmetric enough either way that an operator can null the stage in and out against the bypass, which is how a colour stage is actually judged.
+ * @see data/kernels/drive.json
+ */
+export declare const DRIVE_TRIM_RANGE: {
+  readonly min: -24;
+  readonly max: 12;
+  readonly step: 0.1;
+  readonly unit: "dB";
+  readonly default: 0;
+  readonly defaultFrom: "desk";
+};
+
 /**
  * The maximum number of parametric bands a channel EQ may hold — the operator can add up to this many. Generated into `omx_contract_limits.h` as `OMX_EQ_MAX_BANDS`, which `omx_biquad.h` reads (`output-delay-ceiling.test.ts` reads the header): the native lane allocates exactly this many biquad slots per channel and silently clamps above it, so the model, the wire, and the DSP agree by test, not by memory.
  * @see data/kernels/eq.json
@@ -277,6 +405,72 @@ export declare const ISO_THIRD_OCTAVE_CENTRES_HZ: readonly [20, 25, 31.5, 40, 50
  */
 export declare const GEQ_BANDS: 31;
 
+/**
+ * The frequency band a parametric band can be dragged across.
+ * @see data/kernels/eq.json
+ */
+export declare const EQ_FREQ_RANGE: {
+  readonly min: 20;
+  readonly max: 20000;
+  readonly step: 10;
+  readonly unit: "Hz";
+};
+
+/**
+ * The parametric-band gain travel, in dB. The ± scalar `clampEqGain` enforces is READ off this (`core/src/eq.ts` derives `EQ_GAIN_LIMIT_DB` from `max`), so the bound is stated once and a surface cannot draw a wider knob than the clamp will honour.
+ * @see data/kernels/eq.json
+ */
+export declare const EQ_GAIN_RANGE: {
+  readonly min: -15;
+  readonly max: 15;
+  readonly step: 0.5;
+  readonly unit: "dB";
+};
+
+/**
+ * The Q (resonance) extent of a parametric band.
+ * @see data/kernels/eq.json
+ */
+export declare const EQ_Q_RANGE: {
+  readonly min: 0.3;
+  readonly max: 8;
+  readonly step: 0.1;
+  readonly unit: "";
+};
+
+/**
+ * The Q extent of a NOTCH band. Wider than EQ_Q_RANGE on purpose (#116, operator decision): an ultra-narrow surgical cut is the notch shape's whole point — the FBS ring-out pool plants dbx-AFS-style ring killers at Q ≈ 116 (~1/80 octave), inaudible on program yet fatal to a single ringing frequency. Gain-carrying shapes stay bounded at EQ_Q_RANGE — a Q-116 bell is a resonator, not an EQ move.
+ * @see data/kernels/eq.json
+ */
+export declare const EQ_NOTCH_Q_RANGE: {
+  readonly min: 0.3;
+  readonly max: 116;
+  readonly step: 1;
+  readonly unit: "";
+};
+
+/**
+ * Where the HPF cutoff can sit (low end); mirrors the drawn low-frequency handle.
+ * @see data/kernels/eq.json
+ */
+export declare const HPF_FREQ_RANGE: {
+  readonly min: 20;
+  readonly max: 1000;
+  readonly step: 10;
+  readonly unit: "Hz";
+};
+
+/**
+ * Where the LPF cutoff can sit (high end).
+ * @see data/kernels/eq.json
+ */
+export declare const LPF_FREQ_RANGE: {
+  readonly min: 1000;
+  readonly max: 20000;
+  readonly step: 10;
+  readonly unit: "Hz";
+};
+
 /**
  * The flanger's jet sweep (§3b).
  * @see data/kernels/flanger.json
@@ -646,6 +840,152 @@ export declare const REVERB_PLATE_MOD_DEPTH_RANGE: {
   readonly defaultFrom: "desk";
 };
 
+/**
+ * The REVERB's wet/dry. An insert keeps the dry signal (0.3); an `fxReturn` is wet-only (1), so the return carries only the effect. Both numbers live HERE and nowhere else: the row's `mix` limit, `ReverbController`'s seed and its fresh state read them through limitForKind.
+ * @see data/kernels/reverb.json
+ */
+export declare const REVERB_MIX_RANGE: {
+  readonly min: 0;
+  readonly max: 1;
+  readonly step: 0;
+  readonly unit: "";
+  readonly default: 0.3;
+  readonly defaultFrom: "desk";
+  readonly byKind: {
+    readonly fxReturn: 1;
+  };
+};
+
+/**
+ * The reverb's SIZE/DAMPING/WIDTH — each a NORMALIZED_RANGE instance with its own come-up value, matching `DEFAULT_REVERB_STATE`. Three separate constants rather than one shared default on `NORMALIZED_RANGE`: that range is the bare 0..1 REPRESENTATION, reused by fields across the whole console whose come-up values disagree (a fader position is not a reverb's damping), so a default belongs on the NAMED field, never on the shape it borrows.
+ * @see data/kernels/reverb.json
+ */
+export declare const REVERB_SIZE_RANGE: {
+  readonly min: 0;
+  readonly max: 1;
+  readonly step: 0;
+  readonly unit: "";
+  readonly default: 0.7;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The reverb's DAMPING — a NORMALIZED_RANGE instance with its own come-up value, matching `DEFAULT_REVERB_STATE`. Declared with SIZE and WIDTH (see REVERB_SIZE_RANGE for why each is a named constant rather than a default on the shared 0..1 shape).
+ * @see data/kernels/reverb.json
+ */
+export declare const REVERB_DAMPING_RANGE: {
+  readonly min: 0;
+  readonly max: 1;
+  readonly step: 0;
+  readonly unit: "";
+  readonly default: 0.5;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The reverb's stereo WIDTH — a NORMALIZED_RANGE instance with its own come-up value, matching `DEFAULT_REVERB_STATE`. Declared with SIZE and DAMPING (see REVERB_SIZE_RANGE for why each is a named constant rather than a default on the shared 0..1 shape).
+ * @see data/kernels/reverb.json
+ */
+export declare const REVERB_WIDTH_RANGE: {
+  readonly min: 0;
+  readonly max: 1;
+  readonly step: 0;
+  readonly unit: "";
+  readonly default: 1;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The reverb's PRE-DELAY travel — the gap before the first reflection, in milliseconds. Declared here so the unit crosses with the bounds: a `finiteNumber(0, 100)` codec publishes `unit: ''`, and a surface binding that draws a millisecond control it cannot label. The panel knowing better than the wire is the wrong way round.
+ * @see data/kernels/reverb.json
+ */
+export declare const REVERB_PREDELAY_RANGE: {
+  readonly min: 0;
+  readonly max: 100;
+  readonly step: 1;
+  readonly unit: "ms";
+  readonly default: 0;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The reverb's LOW cut, as an instance of REVERB_CUT_RANGE — same bounds, its own come-up value. `0` reads as "none" (`mix_reverb.h`), which is also `DEFAULT_REVERB_STATE`'s seed, so a fresh reverb's low cut and its declared default are the same fact stated once. Split from REVERB_CUT_RANGE rather than adding `default` there: the low and high cut share ONE travel (the C imposes one constraint on both) but do NOT share one come-up value, and a `default` on the shared range could only be honest for one of the two fields that read it.
+ * @see data/kernels/reverb.json
+ */
+export declare const REVERB_LOWCUT_RANGE: {
+  readonly min: 0;
+  readonly max: 20000;
+  readonly step: 10;
+  readonly unit: "Hz";
+  readonly default: 0;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The reverb's HIGH cut, as an instance of REVERB_CUT_RANGE — same bounds, its own come-up value. The top of the travel reads as "open" (`mix_reverb.h`), matching `DEFAULT_REVERB_STATE`'s seed.
+ * @see data/kernels/reverb.json
+ */
+export declare const REVERB_HIGHCUT_RANGE: {
+  readonly min: 0;
+  readonly max: 20000;
+  readonly step: 10;
+  readonly unit: "Hz";
+  readonly default: 20000;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * REVERSE's MIRROR WINDOW — how long a slice of the wet is played backward, in milliseconds (`2026-07-15-native-delay-reverb.md`, Amendment 2026-09-17 §B). A DECLARED travel and never derived from `size`'s RT60: an RT60 of seconds cannot be buffered at 192 kHz, and a window silently clamped to fit is the silent-clamp defect. The ceiling is what `mix_reverb.h`'s pool budgets a ring for (`OMX_REVERB_REVERSE_MAX_MS`), so the console offers exactly the travel the kernel accepts — nothing wider, nothing narrower.
+ * @see data/kernels/reverb.json
+ */
+export declare const REVERB_REVERSE_RANGE: {
+  readonly min: 50;
+  readonly max: 500;
+  readonly step: 10;
+  readonly unit: "ms";
+  readonly default: 300;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * GATED's HOLD — how long the wet stays at full level after the key falls away, in milliseconds. The Phil-Collins tail is cut where the operator puts the cut, so this is the control that decides the effect's length; `size` still decides what is being cut off.
+ * @see data/kernels/reverb.json
+ */
+export declare const REVERB_HOLD_RANGE: {
+  readonly min: 10;
+  readonly max: 2000;
+  readonly step: 10;
+  readonly unit: "ms";
+  readonly default: 120;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * GATED's RELEASE — how long the held wet takes to reach zero, in milliseconds. A straight line down, short by design: a long release is a reverb tail again, which is the thing a gated reverb exists to remove.
+ * @see data/kernels/reverb.json
+ */
+export declare const REVERB_RELEASE_RANGE: {
+  readonly min: 1;
+  readonly max: 500;
+  readonly step: 1;
+  readonly unit: "ms";
+  readonly default: 20;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * GATED's ARM THRESHOLD — the level the reverb's own mono feed must reach to arm the hold, in dBFS. Declared, because the alternative is a hidden onset detector: the kernel compares `|input|` against exactly this number and nothing else.
+ * @see data/kernels/reverb.json
+ */
+export declare const REVERB_GATE_THRESHOLD_RANGE: {
+  readonly min: -80;
+  readonly max: 0;
+  readonly step: 1;
+  readonly unit: "dBFS";
+  readonly default: -40;
+  readonly defaultFrom: "desk";
+};
+
 /**
  * The horn's chorale (slow) rate, Hz.
  * @see data/kernels/rotary.json
@@ -1049,6 +1389,83 @@ export declare const FDELAY_MOD_READ_ORDER: 3;
  */
 export declare const FDELAY_READ_L1_NORM: 1.25;
 
+/**
+ * The gate's threshold, range, release and ratio as a plugin host draws them: GATE_LIMITS' bounds, units and defaults with no step. The console's row quantises these four to whole steps (1 dB, 10 ms, 1:1), and a travel whose step is 1 or more reads as an integer control; the omx-strip plugin has always offered them continuous, so it reads this table instead. Every number but the step is GATE_LIMITS', held equal by test/continuous-travels.test.mjs. Not rendered to C: no C reader needs a second spelling of the gate's bounds.
+ * @see data/primitives.json
+ */
+export declare const GATE_CONTINUOUS_TRAVELS: {
+  readonly thresholdDb: {
+    readonly min: -80;
+    readonly max: 0;
+    readonly step: 0;
+    readonly unit: "dB";
+    readonly default: -40;
+    readonly defaultFrom: "desk";
+  };
+  readonly rangeDb: {
+    readonly min: -90;
+    readonly max: 0;
+    readonly step: 0;
+    readonly unit: "dB";
+    readonly default: -90;
+    readonly defaultFrom: "desk";
+  };
+  readonly releaseMs: {
+    readonly min: 0;
+    readonly max: 5000;
+    readonly step: 0;
+    readonly unit: "ms";
+    readonly default: 100;
+    readonly defaultFrom: "desk";
+  };
+  readonly ratio: {
+    readonly min: 1;
+    readonly max: 100;
+    readonly step: 0;
+    readonly unit: "";
+    readonly default: 16;
+    readonly defaultFrom: "desk";
+  };
+};
+
+/**
+ * The compressor's threshold and release as a plugin host draws them: COMP_LIMITS' bounds, units and defaults with no step. The console's row quantises them to whole steps (1 dB, 10 ms), and a travel whose step is 1 or more reads as an integer control; the omx-strip plugin has always offered them continuous, so it reads this table instead. Every number but the step is COMP_LIMITS', held equal by test/continuous-travels.test.mjs. Not rendered to C: no C reader needs a second spelling of the compressor's bounds.
+ * @see data/primitives.json
+ */
+export declare const COMP_CONTINUOUS_TRAVELS: {
+  readonly thresholdDb: {
+    readonly min: -60;
+    readonly max: 0;
+    readonly step: 0;
+    readonly unit: "dB";
+    readonly default: -18;
+    readonly defaultFrom: "desk";
+  };
+  readonly releaseMs: {
+    readonly min: 5;
+    readonly max: 3000;
+    readonly step: 0;
+    readonly unit: "ms";
+    readonly default: 200;
+    readonly defaultFrom: "desk";
+  };
+};
+
+/**
+ * The digital input trim as a travel: openmixer's TRIM_RANGE (packages/declarations, -24..+24 dB in 0.1 dB steps, spelled minDb/maxDb/stepDb there and OMX_TRIM_RANGE_*_DB in omx-dsp's header), coming up at 0 dB, the trim a channel has when none is set. The omx-strip plugin's trim reads it. A table with the one field `trimDb`, the name the trim row and the plugin store; not rendered to C, which already spells TRIM_RANGE its own way.
+ * @see data/primitives.json
+ */
+export declare const TRIM_TRAVELS: {
+  readonly trimDb: {
+    readonly min: -24;
+    readonly max: 24;
+    readonly step: 0.1;
+    readonly unit: "dB";
+    readonly default: 0;
+    readonly defaultFrom: "desk";
+  };
+};
+
 /**
  * The standard sample rates (Hz) the desk recognises — the pro-audio superset. One source of truth for the clock controller's `clock.allowed-rates` seed, the force row's validation ceiling and the device-rate probe fallback. What the operator is OFFERED is always the DEVICE's own `supportedRates` (`2026-07-15-clock-rate-honest-force-rate.md`) — this is the ceiling a write is refused by, never a menu.
  * @see data/rates.json