@openmixer/omx-contract 1.0.0 → 1.2.0

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
@@ -95,6 +158,103 @@ export declare const PROGRAM_RELEASE: {
   };
 };
 
+/**
+ * The detector band's CENTRE, in Hz. Sibilance lives at 5–10 kHz on most voices; 7 kHz with the default width covers 4 950–9 900 Hz, which is where an "s" and a "t" sit on a close vocal mic. The travel is wider than the come-up on both sides on purpose: a bright female vocal wants the band up near 9 kHz and a chesty male one down at 5, and a surface narrower than the row removes reach the console genuinely has (the same reasoning core's `REVERB_CUT_RANGE` records).
+ * @see data/kernels/deesser.json
+ */
+export declare const DEESS_FREQ_RANGE: {
+  readonly min: 2000;
+  readonly max: 16000;
+  readonly step: 10;
+  readonly unit: "Hz";
+  readonly default: 7000;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The band's WIDTH, in OCTAVES around the centre: the edges are `f / 2^(w/2)` and `f · 2^(w/2)`, which is what makes the centre the geometric middle at every width. Octaves and not a Q, because a Q is a property of one section and this band is TWO (a highpass and a lowpass, `mix_deesser.h`) — an operator asked to dial a Q would be dialling a number neither filter carries. One octave is the classic de-esser band: wide enough for a sibilant that moves with the vowel, narrow enough that a 1 kHz vowel sits 27.8 dB down the skirt.
+ * @see data/kernels/deesser.json
+ */
+export declare const DEESS_WIDTH_RANGE: {
+  readonly min: 0.25;
+  readonly max: 4;
+  readonly step: 0.05;
+  readonly unit: "oct";
+  readonly default: 1;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * Where reduction starts — the level of the BAND, not of the strip, which is why the come-up is so much lower than the compressor's. A vocal peaking −12 dBFS carries roughly −30 dBFS in a one-octave band at 7 kHz on its sibilants and under −40 on its vowels, so −30 sits between the two and the stage opens on an "s" and stays shut on an "ah".
+ * @see data/kernels/deesser.json
+ */
+export declare const DEESS_THRESHOLD_RANGE: {
+  readonly min: -60;
+  readonly max: 0;
+  readonly step: 0.5;
+  readonly unit: "dB";
+  readonly default: -30;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * How hard the band is held once it is over the threshold. 4:1 is the textbook de-esser ratio: firm on the "s", short of a limiter.
+ * @see data/kernels/deesser.json
+ */
+export declare const DEESS_RATIO_RANGE: {
+  readonly min: 1;
+  readonly max: 20;
+  readonly step: 0.1;
+  readonly unit: "";
+  readonly default: 4;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The FLOOR on the reduction, in dB and never positive — the deepest cut the stage may reach however loud the sibilant is (`mix_deesser.h`'s clamp, §4c). 12 dB tames a hard sibilant; past that a voice starts to lisp, and a de-esser with NO floor turns a shouted "s" into a hole. The ceiling is 0, which switches the reduction off without switching the stage off — a legitimate thing to want while dialling the band in by ear.
+ * @see data/kernels/deesser.json
+ */
+export declare const DEESS_RANGE_RANGE: {
+  readonly min: -24;
+  readonly max: 0;
+  readonly step: 0.5;
+  readonly unit: "dB";
+  readonly default: -12;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The detector's ATTACK, in ms. A sibilant's onset is a few milliseconds; 1 ms catches it without the detector chattering on the band's own waveform.
+ * @see data/kernels/deesser.json
+ */
+export declare const DEESS_ATTACK_RANGE: {
+  readonly min: 0.1;
+  readonly max: 50;
+  readonly step: 0.1;
+  readonly unit: "ms";
+  readonly default: 1;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The detector's RELEASE, in ms. 60 ms is long enough not to modulate inside one "s" and short enough to be open again for the next syllable.
+ * @see data/kernels/deesser.json
+ */
+export declare const DEESS_RELEASE_RANGE: {
+  readonly min: 5;
+  readonly max: 500;
+  readonly step: 1;
+  readonly unit: "ms";
+  readonly default: 60;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The knee, in dB — a CONSTANT of the stage and not a row field (`2026-09-22-native-deesser-stage.md` §4b): a de-esser without a soft knee latches audibly on the first sibilant of a phrase, and no other value of this number is a de-esser anyone would dial. The controller pushes it to the node and this is the same number; a second spelling would be a picture that disagrees with the audio about where the reduction starts.
+ * @see data/kernels/deesser.json
+ */
+export declare const DEESS_KNEE_DB: 6;
+
 /**
  * The FX delay's time travel. `max` is the NATIVE ring's ceiling — the same number as `OMX_FXDELAY_MAX_MS` in `omx_delay.h`, pinned to it by `output-delay-ceiling.test.ts`. Distinct from the per-route ALIGNMENT delay (`OUTPUT_DELAY_RANGE`, 1 s, `OMX_DELAY_MAX_MS`): one is a musical echo with feedback and mix, the other is a pure latency. Two facts, two rings, two ceilings — sharing the word "delay" is why they keep being confused for each other.
  * @see data/kernels/delay.json
@@ -162,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
@@ -180,6 +405,124 @@ 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
+ */
+export declare const FLANGER_RATE_RANGE: {
+  readonly min: 0.05;
+  readonly max: 5;
+  readonly step: 0.01;
+  readonly unit: "Hz";
+  readonly default: 0.25;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The flanger's peak-to-peak excursion above its declared 0.5 ms base (§3b).
+ * @see data/kernels/flanger.json
+ */
+export declare const FLANGER_DEPTH_RANGE: {
+  readonly min: 0;
+  readonly max: 5;
+  readonly step: 0.1;
+  readonly unit: "ms";
+  readonly default: 2;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The flanger's SIGNED resonance (§3b). The ±0.95 clamp is DECLARED here — a PATCH asking for 1.0 is answered by this travel — and the kernel's own clamp is the enforcement half.
+ * @see data/kernels/flanger.json
+ */
+export declare const FLANGER_FEEDBACK_RANGE: {
+  readonly min: -0.95;
+  readonly max: 0.95;
+  readonly step: 0.01;
+  readonly unit: "";
+  readonly default: 0.6;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The flanger's wet/dry, as an instance of DRIVE_MIX_RANGE: 50 %, equal dry and wet, where the comb is deepest (§3b).
+ * @see data/kernels/flanger.json
+ */
+export declare const FLANGER_MIX_RANGE: {
+  readonly min: 0;
+  readonly max: 100;
+  readonly step: 0.1;
+  readonly unit: "%";
+  readonly default: 50;
+  readonly defaultFrom: "desk";
+};
+
 /**
  * The legal range of each gate field (engineering units). The widget clamps drags to these, `normalizeGate` enforces them, the row's codec refuses by them and the travel sheet publishes them — one source of truth. `rangeDb` reaches GATE_RANGE_FLOOR_DB, shown as "−∞" in readouts (a gate fully closed is silence).
  * @see data/kernels/gate.json
@@ -259,6 +602,37 @@ export declare const GATE_LIMITS: {
   };
 };
 
+/**
+ * One graphic-EQ fader's travel: EQ_GAIN_RANGE by reference (a graphic fader is an EQ gain), with the come-up value it needs as a row field — flat, 0 dB (graphic-eq-31 spec §3).
+ * @see data/kernels/geq.json
+ */
+export declare const GEQ_BAND_RANGE: {
+  readonly min: -15;
+  readonly max: 15;
+  readonly step: 0.5;
+  readonly unit: "dB";
+  readonly default: 0;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The graphic EQ's band Q: the ISO third-octave bandwidth, `2^(1/6)/(2^(1/3) − 1) ≈ 4.318`, to one decimal as the M32 GEQ carries it. Read by the `geq31` preset and the graphic EQ's section design (graphic-eq-31 spec §3).
+ * @see data/kernels/geq.json
+ */
+export declare const GEQ_BAND_Q: 4.3;
+
+/**
+ * The prototype gain the `true` solve's first interaction matrix is evaluated at (spec §2, §3): the middle of the travel's magnitude, where a matched-Z section's dB response per dB of gain is closest to its average.
+ * @see data/kernels/geq.json
+ */
+export declare const GEQ_PROTO_DB: 12;
+
+/**
+ * The ceiling on a section gain the `true` solve may ask for (spec §3): above the travel's worst case (26.0 dB, the alternating ±15 set) with margin. A solve past it clamps and the row says so (`designClamped`), never silently.
+ * @see data/kernels/geq.json
+ */
+export declare const GEQ_DESIGN_GAIN_MAX_DB: 30;
+
 /**
  * The precision limiter's travels (`2026-09-27-precision-limiter.md` §2), rendered into `omx_contract_limits.h` as `OMX_LIMITER_*` by `harness/contract-limits-gen.mjs`, so `mix_limiter.h` reads them and never restates one (R-094). The ceiling is a TRUE peak in dBFS (the ×4 detector); the look-ahead sets the declared latency; the release is the envelope's time constant on the gain depth.
  * @see data/kernels/limiter.json
@@ -291,55 +665,558 @@ export declare const LIMITER_LIMITS: {
 };
 
 /**
- * PITCH_LIMITS, moved from openmixer.
- * @see data/kernels/pitch.json
+ * The phaser's sweep speed (§3). `omx_lfo_inc` freezes at Nyquist; this travel stays far below.
+ * @see data/kernels/phaser.json
  */
-export declare const PITCH_LIMITS: {
-  readonly semitones: {
-    readonly min: -12;
-    readonly max: 12;
-    readonly default: 0;
-  };
-  readonly cents: {
-    readonly min: -50;
-    readonly max: 50;
-    readonly default: 0;
-  };
-  readonly mix: {
-    readonly min: 0;
-    readonly max: 100;
-    readonly default: 100;
-  };
+export declare const PHASER_RATE_RANGE: {
+  readonly min: 0.05;
+  readonly max: 5;
+  readonly step: 0.01;
+  readonly unit: "Hz";
+  readonly default: 0.5;
+  readonly defaultFrom: "desk";
 };
 
 /**
- * PITCH_KERNEL, moved from openmixer.
- * @see data/kernels/pitch.json
+ * The phaser's lowest centre frequency; the sweep runs upward from it (§3).
+ * @see data/kernels/phaser.json
  */
-export declare const PITCH_KERNEL: {
-  readonly windowMs: 40;
-  readonly prefilterCeilingHz: 20000;
-  readonly prefilterQ: 0.7071067811865476;
+export declare const PHASER_BASE_RANGE: {
+  readonly min: 50;
+  readonly max: 2000;
+  readonly step: 1;
+  readonly unit: "Hz";
+  readonly default: 200;
+  readonly defaultFrom: "desk";
 };
 
 /**
- * PLATE's tank MODULATION DEPTH, in percent of Dattorro's own excursion (±8 samples at his 29 761 Hz tuning rate, scaled to the live rate the way the tank lengths are). 100 is the depth the plate has always run at, so the come-up is bit-identical to the plate before the field; 0 brings back the unmodulated tank's ring; 400 is the wide, chorused EMT-style swing. The rate stays 1 Hz. Only PLATE reads it (`2026-09-26-native-fx-catalogue.md` §2, Reverb).
- * @see data/kernels/reverb.json
+ * The sweep's span above `base`, in octaves; 0 is a static phaser at `base` (§3).
+ * @see data/kernels/phaser.json
  */
-export declare const REVERB_PLATE_MOD_DEPTH_RANGE: {
+export declare const PHASER_DEPTH_RANGE: {
   readonly min: 0;
-  readonly max: 400;
-  readonly step: 1;
+  readonly max: 6;
+  readonly step: 0.1;
+  readonly unit: "oct";
+  readonly default: 4;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The phaser's section count per leg — EVEN, 2 … 12 (§2: two sections per notch). Its ends are the kernel's state capacity (`OMX_PHASER_MAX_STAGES` reads `OMX_PHASER_STAGES_RANGE_MAX`); the row moves it through the closed member set PHASER_STAGE_COUNTS, which is derived from it.
+ * @see data/kernels/phaser.json
+ */
+export declare const PHASER_STAGES_RANGE: {
+  readonly min: 2;
+  readonly max: 12;
+  readonly step: 2;
+  readonly unit: "";
+  readonly default: 6;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The member set the `stages` field accepts: PHASER_STAGES_RANGE walked by its step.
+ * @see data/kernels/phaser.json
+ */
+export declare const PHASER_STAGE_COUNTS: readonly [2, 4, 6, 8, 10, 12];
+
+/**
+ * The phaser's SIGNED resonance (§3). ±0.9, tighter than the flanger's ±0.95: the loop runs through a time-varying chain. Declared here (the refusal half); the kernel's clamp is the enforcement half.
+ * @see data/kernels/phaser.json
+ */
+export declare const PHASER_FEEDBACK_RANGE: {
+  readonly min: -0.9;
+  readonly max: 0.9;
+  readonly step: 0.01;
+  readonly unit: "";
+  readonly default: 0.4;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The phaser's wet/dry, as an instance of DRIVE_MIX_RANGE: 50 %, where the notch is complete (§3).
+ * @see data/kernels/phaser.json
+ */
+export declare const PHASER_MIX_RANGE: {
+  readonly min: 0;
+  readonly max: 100;
+  readonly step: 0.1;
   readonly unit: "%";
-  readonly default: 100;
+  readonly default: 50;
   readonly defaultFrom: "desk";
 };
 
 /**
- * The legal range of each transient-designer field (engineering units), transient spec §3. Every kind comes up flat: no per-kind default differs. `harness/contract-limits-gen.mjs` emits each as `OMX_TRANSIENT_<FIELD>_{MIN,MAX,DEFAULT}` for `mix_transient.h`'s resolve; the row publishes them on OPTIONS when it lands (issue #921).
- * @see data/kernels/transient.json
+ * The phaser's continuous travels by row field — the ONE map its control bounds and its row travels both read (§3). `stages` is not here: it moves through PHASER_STAGE_COUNTS.
+ * @see data/kernels/phaser.json
  */
-export declare const TRANSIENT_LIMITS: {
+export declare const PHASER_TRAVELS: {
+  readonly rateHz: {
+    readonly min: 0.05;
+    readonly max: 5;
+    readonly step: 0.01;
+    readonly unit: "Hz";
+    readonly default: 0.5;
+    readonly defaultFrom: "desk";
+  };
+  readonly baseHz: {
+    readonly min: 50;
+    readonly max: 2000;
+    readonly step: 1;
+    readonly unit: "Hz";
+    readonly default: 200;
+    readonly defaultFrom: "desk";
+  };
+  readonly depthOct: {
+    readonly min: 0;
+    readonly max: 6;
+    readonly step: 0.1;
+    readonly unit: "oct";
+    readonly default: 4;
+    readonly defaultFrom: "desk";
+  };
+  readonly feedback: {
+    readonly min: -0.9;
+    readonly max: 0.9;
+    readonly step: 0.01;
+    readonly unit: "";
+    readonly default: 0.4;
+    readonly defaultFrom: "desk";
+  };
+  readonly mix: {
+    readonly min: 0;
+    readonly max: 100;
+    readonly step: 0.1;
+    readonly unit: "%";
+    readonly default: 50;
+    readonly defaultFrom: "desk";
+  };
+};
+
+/**
+ * PITCH_LIMITS, moved from openmixer.
+ * @see data/kernels/pitch.json
+ */
+export declare const PITCH_LIMITS: {
+  readonly semitones: {
+    readonly min: -12;
+    readonly max: 12;
+    readonly default: 0;
+  };
+  readonly cents: {
+    readonly min: -50;
+    readonly max: 50;
+    readonly default: 0;
+  };
+  readonly mix: {
+    readonly min: 0;
+    readonly max: 100;
+    readonly default: 100;
+  };
+};
+
+/**
+ * PITCH_KERNEL, moved from openmixer.
+ * @see data/kernels/pitch.json
+ */
+export declare const PITCH_KERNEL: {
+  readonly windowMs: 40;
+  readonly prefilterCeilingHz: 20000;
+  readonly prefilterQ: 0.7071067811865476;
+};
+
+/**
+ * PLATE's tank MODULATION DEPTH, in percent of Dattorro's own excursion (±8 samples at his 29 761 Hz tuning rate, scaled to the live rate the way the tank lengths are). 100 is the depth the plate has always run at, so the come-up is bit-identical to the plate before the field; 0 brings back the unmodulated tank's ring; 400 is the wide, chorused EMT-style swing. The rate stays 1 Hz. Only PLATE reads it (`2026-09-26-native-fx-catalogue.md` §2, Reverb).
+ * @see data/kernels/reverb.json
+ */
+export declare const REVERB_PLATE_MOD_DEPTH_RANGE: {
+  readonly min: 0;
+  readonly max: 400;
+  readonly step: 1;
+  readonly unit: "%";
+  readonly default: 100;
+  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
+ */
+export declare const ROTARY_HORN_SLOW_RANGE: {
+  readonly min: 0.1;
+  readonly max: 2;
+  readonly step: 0.01;
+  readonly unit: "Hz";
+  readonly default: 0.8;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The horn's tremolo (fast) rate, Hz.
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_HORN_FAST_RANGE: {
+  readonly min: 3;
+  readonly max: 10;
+  readonly step: 0.01;
+  readonly unit: "Hz";
+  readonly default: 6.8;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The drum's chorale (slow) rate, Hz.
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_DRUM_SLOW_RANGE: {
+  readonly min: 0.1;
+  readonly max: 2;
+  readonly step: 0.01;
+  readonly unit: "Hz";
+  readonly default: 0.7;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The drum's tremolo (fast) rate, Hz.
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_DRUM_FAST_RANGE: {
+  readonly min: 3;
+  readonly max: 10;
+  readonly step: 0.01;
+  readonly unit: "Hz";
+  readonly default: 5.9;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The scale on every speed-change time constant (`ROTARY_*_ACCEL_MS`/`_DECEL_MS`): 2 is twice as slow.
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_ACCEL_RANGE: {
+  readonly min: 0.25;
+  readonly max: 4;
+  readonly step: 0.01;
+  readonly unit: "x";
+  readonly default: 1;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The drum/horn balance, percent: −100 drum only, +100 horn only; the law attenuates, never boosts.
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_BALANCE_RANGE: {
+  readonly min: -100;
+  readonly max: 100;
+  readonly step: 1;
+  readonly unit: "%";
+  readonly default: 0;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The rotary's wet/dry, as an instance of DRIVE_MIX_RANGE: 100 %, because a rotary on an insert IS the sound (it replaces the cabinet) and an `fxReturn` wants it wet too (§3).
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_MIX_RANGE: {
+  readonly min: 0;
+  readonly max: 100;
+  readonly step: 0.1;
+  readonly unit: "%";
+  readonly default: 100;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The rotary's numeric travels, field → declaration: the ONE map the row's state, its bounds, its OPTIONS and its controller read (`speed` is a member set, ROTARY_SPEEDS, beside it).
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_TRAVELS: {
+  readonly hornSlowHz: {
+    readonly min: 0.1;
+    readonly max: 2;
+    readonly step: 0.01;
+    readonly unit: "Hz";
+    readonly default: 0.8;
+    readonly defaultFrom: "desk";
+  };
+  readonly hornFastHz: {
+    readonly min: 3;
+    readonly max: 10;
+    readonly step: 0.01;
+    readonly unit: "Hz";
+    readonly default: 6.8;
+    readonly defaultFrom: "desk";
+  };
+  readonly drumSlowHz: {
+    readonly min: 0.1;
+    readonly max: 2;
+    readonly step: 0.01;
+    readonly unit: "Hz";
+    readonly default: 0.7;
+    readonly defaultFrom: "desk";
+  };
+  readonly drumFastHz: {
+    readonly min: 3;
+    readonly max: 10;
+    readonly step: 0.01;
+    readonly unit: "Hz";
+    readonly default: 5.9;
+    readonly defaultFrom: "desk";
+  };
+  readonly accel: {
+    readonly min: 0.25;
+    readonly max: 4;
+    readonly step: 0.01;
+    readonly unit: "x";
+    readonly default: 1;
+    readonly defaultFrom: "desk";
+  };
+  readonly balance: {
+    readonly min: -100;
+    readonly max: 100;
+    readonly step: 1;
+    readonly unit: "%";
+    readonly default: 0;
+    readonly defaultFrom: "desk";
+  };
+  readonly mix: {
+    readonly min: 0;
+    readonly max: 100;
+    readonly step: 0.1;
+    readonly unit: "%";
+    readonly default: 100;
+    readonly defaultFrom: "desk";
+  };
+};
+
+/**
+ * The complementary split's low-pass corner, Hz: the Leslie 122's passive crossover.
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_CROSSOVER_HZ: 800;
+
+/**
+ * The shortest Doppler read, ms — above the order-3 read's one-sample reach at every rate.
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_BASE_MS: 0.1;
+
+/**
+ * The horn's Doppler excursion `D_horn`, ms: a 0.15 m radius over 343 m/s.
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_HORN_DOPPLER_MS: 0.44;
+
+/**
+ * The drum's Doppler excursion `D_drum`, ms: its baffle turns over a fixed woofer.
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_DRUM_DOPPLER_MS: 0.29;
+
+/**
+ * The horn's amplitude swing `m_horn` (a −6 dB directivity dip), a ratio.
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_HORN_AM: 0.5;
+
+/**
+ * The drum baffle's amplitude swing `m_drum`, a ratio.
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_DRUM_AM: 0.3;
+
+/**
+ * The horn rotor's speed-up time constant, ms (at `accel` 1).
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_HORN_ACCEL_MS: 330;
+
+/**
+ * The horn rotor's slow-down time constant, ms (at `accel` 1).
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_HORN_DECEL_MS: 500;
+
+/**
+ * The drum rotor's speed-up time constant, ms (at `accel` 1).
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_DRUM_ACCEL_MS: 1700;
+
+/**
+ * The drum rotor's slow-down time constant, ms (at `accel` 1).
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_DRUM_DECEL_MS: 1800;
+
+/**
+ * Below this rate, Hz, a rotor coasting toward `stop` is snapped to exactly 0.
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_STOP_EPS: 0.0001;
+
+/**
+ * One inline ring per rotor per leg, floats — at least the 192 kHz need of the horn's sweep.
+ * @see data/kernels/rotary.json
+ */
+export declare const ROTARY_RING_FLOATS: 256;
+
+/**
+ * The legal range of each transient-designer field (engineering units), transient spec §3. Every kind comes up flat: no per-kind default differs. `harness/contract-limits-gen.mjs` emits each as `OMX_TRANSIENT_<FIELD>_{MIN,MAX,DEFAULT}` for `mix_transient.h`'s resolve; the row publishes them on OPTIONS when it lands (issue #921).
+ * @see data/kernels/transient.json
+ */
+export declare const TRANSIENT_LIMITS: {
   readonly attackDb: {
     readonly min: -24;
     readonly max: 24;
@@ -407,56 +1284,73 @@ export declare const TRANSIENT_REF_DB: 6;
 export declare const TRANSIENT_FLOOR_LIN: 0.00001;
 
 /**
- * The delay plugin's parameters, in append-only order: DPF's parameter index is the CLAP param id and the LV2 port order (omx-plugins-dpf §3b). Moved from openmixer's packages/omx-plugins/tools/params-gen.mjs PLUGINS.delay.
- *
- * Why: mix is per instance on the desk (insert or fxReturn); a plugin racked in a foreign host is an INSERT, so it reads the input kind's default (omx-plugins-dpf §3a).
- * @see data/plugins/delay.json
+ * The tremolo's LFO rate (the catalogue row's 0.1..20 Hz); 4 Hz is the classic amp tremolo.
+ * @see data/kernels/tremolo.json
  */
-export declare const DELAY_PLUGIN: {
-  readonly plugin: "delay";
-  readonly header: "omx_delay_params.h";
-  readonly prefix: "OMX_DELAY";
-  readonly params: readonly [{
-    readonly symbol: "timeMs";
-    readonly min: 0;
-    readonly max: 2000;
-    readonly def: 300;
-    readonly step: 1;
-    readonly unit: "ms";
-    readonly toggle: false;
-  }, {
-    readonly symbol: "feedback";
-    readonly min: 0;
-    readonly max: 0.99;
-    readonly def: 0.3;
-    readonly step: 0;
-    readonly unit: "";
-    readonly toggle: false;
-  }, {
-    readonly symbol: "mix";
-    readonly min: 0;
-    readonly max: 1;
-    readonly def: 0.3;
-    readonly step: 0;
-    readonly unit: "";
-    readonly toggle: false;
-  }, {
-    readonly symbol: "tone";
+export declare const TREMOLO_RATE_RANGE: {
+  readonly min: 0.1;
+  readonly max: 20;
+  readonly step: 0.01;
+  readonly unit: "Hz";
+  readonly default: 4;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The tremolo's modulation depth: the gain's trough is `1 − mix·depth`.
+ * @see data/kernels/tremolo.json
+ */
+export declare const TREMOLO_DEPTH_RANGE: {
+  readonly min: 0;
+  readonly max: 100;
+  readonly step: 0.1;
+  readonly unit: "%";
+  readonly default: 50;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The tremolo's wet/dry, as an instance of DRIVE_MIX_RANGE: 100 %. The kernel folds the wet/dry into its one gain, so a strip tremolo IS the sound (as the rotary's mix 100 % is).
+ * @see data/kernels/tremolo.json
+ */
+export declare const TREMOLO_MIX_RANGE: {
+  readonly min: 0;
+  readonly max: 100;
+  readonly step: 0.1;
+  readonly unit: "%";
+  readonly default: 100;
+  readonly defaultFrom: "desk";
+};
+
+/**
+ * The tremolo's numeric travels, field → declaration: the ONE map the row's state, its bounds, its OPTIONS and its controller read (`mode` is a member set, TREMOLO_MODES, beside it).
+ * @see data/kernels/tremolo.json
+ */
+export declare const TREMOLO_TRAVELS: {
+  readonly rateHz: {
+    readonly min: 0.1;
+    readonly max: 20;
+    readonly step: 0.01;
+    readonly unit: "Hz";
+    readonly default: 4;
+    readonly defaultFrom: "desk";
+  };
+  readonly depth: {
     readonly min: 0;
-    readonly max: 1;
-    readonly def: 0.3;
-    readonly step: 0;
-    readonly unit: "";
-    readonly toggle: false;
-  }, {
-    readonly symbol: "pingpong";
+    readonly max: 100;
+    readonly step: 0.1;
+    readonly unit: "%";
+    readonly default: 50;
+    readonly defaultFrom: "desk";
+  };
+  readonly mix: {
     readonly min: 0;
-    readonly max: 1;
-    readonly def: 0;
-    readonly step: 1;
-    readonly unit: "";
-    readonly toggle: true;
-  }];
+    readonly max: 100;
+    readonly step: 0.1;
+    readonly unit: "%";
+    readonly default: 100;
+    readonly defaultFrom: "desk";
+  };
 };
 
 /**
@@ -495,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