@openmixer/omx-dsp 0.30.1 → 0.32.0

package/dist/curve.d.ts

@@ -0,0 +1,85 @@
+/**
+ * curvePoints, the twin of omx_curve_points (omx_curve.h): a panel description's display, bound to the current
+ * values and a rate, to its points. The same words (the description's display, family, role, unit and shape
+ * words) and the same codes (CURVE_CODES), checked in the same order. Pinned by test/agreement.test.mjs at the
+ * nine oracle rates: the EQ through the magnitude twins, the transfer curves through the gain computer twins.
+ */
+import { CURVE_CODES } from './definitions.js';
+/** The wire words of each set, in value order. */
+export declare const CURVE_WORDS: {
+    readonly displays: string[];
+    readonly families: string[];
+    readonly roles: string[];
+    readonly units: string[];
+    readonly shapes: string[];
+    /** fbs-fixed and fbs-live: the origins are spelt with a hyphen */
+    readonly origins: string[];
+};
+/** What curvePoints answers when it draws nothing: a CURVE_CODES id other than `ok`. */
+export type CurveCode = Exclude<(typeof CURVE_CODES)[number], 'ok'>;
+/** One bound term: a role of the description, its value now, in the unit the description gives it. */
+export interface CurveTerm {
+    /** The role word: `band_freq`, `threshold`, `knee_start`… */
+    readonly role: string;
+    /** The band's index for a `band_*` role; 0 (or absent) for any other. */
+    readonly index?: number;
+    /** The control's plain value. */
+    readonly value: number;
+    /** The unit token: `hz`, `khz`, `db`, `coef`, `oct`, `none`… */
+    readonly unit: string;
+    /** For `band_type`, the shape its value selects (from the role's `shapes`); for `band_freq`, the fixed shape. */
+    readonly shape?: string;
+    /** Where the band comes from: `user` (the default), `fbs-fixed` or `fbs-live`. A band's is its band_freq term's. */
+    readonly origin?: string;
+}
+/** A curve request: one display of the description, bound. */
+export interface CurveRequest {
+    /** The display's kind: `eq_response` or `transfer_curve`. */
+    readonly kind: string;
+    /** The family: `eq`, `dynamics`, `limiter`, `gate` or `deesser`. */
+    readonly family: string;
+    /** The instance's rate, Hz. */
+    readonly sampleRate: number;
+    /** The grid points, 2 to CURVE_POINTS_MAX (an EQ's anchors on top). */
+    readonly points: number;
+    /** The x extents; CURVE_EXTENTS when absent. */
+    readonly extents?: {
+        readonly min: number;
+        readonly max: number;
+    };
+    /** The terms; a later term of one role and index replaces an earlier. */
+    readonly terms: readonly CurveTerm[];
+    /** Also answer the curve over the `user` bands alone, at the same x. */
+    readonly userOnly?: boolean;
+}
+/** A band whose origin is not `user`: its centre (Hz), its own magnitude there (dB), its Q and its origin. */
+export interface CurveMark {
+    readonly freq: number;
+    readonly depthDb: number;
+    readonly q: number;
+    readonly origin: string;
+}
+/** One point: Hz and dB for an EQ, input dB and output dB for a transfer curve. */
+export interface CurvePoint {
+    readonly x: number;
+    readonly y: number;
+}
+/** The answer: the points, ascending in x, or the code of what is missing or refused. */
+export type CurveAnswer = {
+    readonly points: readonly CurvePoint[];
+    /** One per drawn band whose origin is not `user`, in band order; none for a transfer curve. */
+    readonly marks: readonly CurveMark[];
+    /** With `userOnly`: the curve over the user bands (and the head filters) alone, at the same x. */
+    readonly userPoints?: readonly CurvePoint[];
+} | {
+    readonly code: CurveCode;
+};
+/** The Q of each section of a Butterworth head filter (omx_eq_butterworth_qs): 12 dB/oct one at 1/sqrt(2), 24 dB/oct
+ *  two whose product is maximally flat, the kernel's own digits. */
+export declare function butterworthQs(slope24: boolean): readonly number[];
+/**
+ * The points of one display of a panel description: the twin of omx_curve_points, the same checks in the same
+ * order, the same codes.
+ * @param rq The request.
+ */
+export declare function curvePoints(rq: CurveRequest): CurveAnswer;

package/dist/curve.js

@@ -0,0 +1,216 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * curvePoints, the twin of omx_curve_points (omx_curve.h): a panel description's display, bound to the current
+ * values and a rate, to its points. The same words (the description's display, family, role, unit and shape
+ * words) and the same codes (CURVE_CODES), checked in the same order. Pinned by test/agreement.test.mjs at the
+ * nine oracle rates: the EQ through the magnitude twins, the transfer curves through the gain computer twins.
+ */
+import { COMP_KNEE_DB_RANGE, COMP_RATIO_RANGE, CURVE_DISPLAYS, CURVE_EXTENTS, CURVE_FAMILIES, CURVE_ORIGINS, CURVE_POINTS_MAX, CURVE_ROLES, CURVE_SHAPES, CURVE_UNITS, EQ_BAND_DEFAULTS, GATE_RANGE_DB_RANGE, GATE_RATIO_RANGE, LIN_TO_DB_FLOOR, } from './definitions.js';
+import { clampEqQFor, magnitudeSumDb, octavesToQ } from './eq.js';
+import { gaincompDb, gaincompDbShifted, gateKnee } from './gaincomp.js';
+/** A set id as the description spells it: `eqResponse` is `eq_response`; the unshaped band is `-`. */
+const wordOf = (id) => (id === 'unshaped' ? '-' : id.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`));
+/** The wire words of each set, in value order. */
+export const CURVE_WORDS = {
+    displays: CURVE_DISPLAYS.map(wordOf),
+    families: CURVE_FAMILIES.map(wordOf),
+    roles: CURVE_ROLES.map(wordOf),
+    units: CURVE_UNITS.map(wordOf),
+    shapes: CURVE_SHAPES.map(wordOf),
+    /** fbs-fixed and fbs-live: the origins are spelt with a hyphen */
+    origins: CURVE_ORIGINS.map((id) => id.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`)),
+};
+/** The units each role converts from (omx_curve_unit_accepted). */
+const ACCEPTS = {
+    band_freq: ['hz', 'khz'], hpf_freq: ['hz', 'khz'], lpf_freq: ['hz', 'khz'],
+    band_gain: ['db', 'coef'],
+    band_q: ['none', 'coef', 'oct'],
+    band_type: ['none'], band_on: ['none'], hpf_on: ['none'], lpf_on: ['none'],
+    hpf_slope: ['none', 'db'], lpf_slope: ['none', 'db'],
+    threshold: ['db', 'dbfs', 'dbu', 'lufs'],
+    ratio: ['ratio', 'coef'],
+    knee: ['db'], makeup: ['db'], range: ['db'], knee_start: ['db'], knee_end: ['db'],
+};
+/** omx_lin_to_db: a linear factor to dB, floored at LIN_TO_DB_FLOOR. */
+const linToDb = (lin) => {
+    const v = Math.fround(lin);
+    return Math.fround(20 * Math.log10(v < Math.fround(LIN_TO_DB_FLOOR.lin) ? Math.fround(LIN_TO_DB_FLOOR.lin) : v));
+};
+/** A term's value in the model's unit (omx_curve_term_value). */
+const valueOf = (t) => {
+    switch (t.unit) {
+        case 'khz': return t.value * 1000;
+        case 'coef': return t.role === 'band_gain' ? linToDb(t.value) : t.value;
+        case 'oct': return octavesToQ(t.value);
+        default: return t.value;
+    }
+};
+const SHAPE_TYPE = {
+    bell: 'bell', lowshelf: 'lowshelf', highshelf: 'highshelf', highpass: 'highpass', lowpass: 'lowpass', notch: 'notch',
+    allpass1: 'allpass1', allpass2: 'allpass2',
+};
+/** The Q of each section of a Butterworth head filter (omx_eq_butterworth_qs): 12 dB/oct one at 1/sqrt(2), 24 dB/oct
+ *  two whose product is maximally flat, the kernel's own digits. */
+export function butterworthQs(slope24) {
+    return slope24 ? [0.5411961, 1.306563] : [Math.SQRT1_2];
+}
+/** The frequencies a drawn curve is sampled at (omx_eq_curve_freqs): the log grid and the bands' anchors inside it,
+ *  ascending. */
+function curveFreqs(bands, fMin, fMax, points) {
+    const g = Math.max(points, 2);
+    const out = [];
+    for (let i = 0; i < g; i++)
+        out.push(fMin * Math.pow(fMax / fMin, i / (g - 1)));
+    for (const b of bands) {
+        const half = b.freq / (2 * (b.q > 0.1 ? b.q : 0.1));
+        for (const a of [b.freq - half, b.freq, b.freq + half])
+            if (a > fMin && a < fMax)
+                out.push(a);
+    }
+    for (let i = 1; i < out.length; i++) {
+        const v = out[i];
+        let j = i;
+        for (; j > 0 && out[j - 1] > v; j--)
+            out[j] = out[j - 1];
+        out[j] = v;
+    }
+    return out;
+}
+/**
+ * The points of one display of a panel description: the twin of omx_curve_points, the same checks in the same
+ * order, the same codes.
+ * @param rq The request.
+ */
+export function curvePoints(rq) {
+    const eq = rq.kind === 'eq_response';
+    if (!(eq ? rq.family === 'eq' : rq.kind === 'transfer_curve' && rq.family !== 'eq' && CURVE_WORDS.families.includes(rq.family)))
+        return { code: 'kindUnknown' };
+    if (!Number.isInteger(rq.points) || rq.points < 2 || rq.points > CURVE_POINTS_MAX)
+        return { code: 'pointsRange' };
+    if (!Number.isFinite(rq.sampleRate) || !(rq.sampleRate > 0) || (rq.extents && !(Number.isFinite(rq.extents.min) && Number.isFinite(rq.extents.max))))
+        return { code: 'valueNotFinite' };
+    if (rq.terms.some((t) => !Number.isFinite(t.value)))
+        return { code: 'valueNotFinite' };
+    if (rq.terms.some((t) => !ACCEPTS[t.role]?.includes(t.unit) || !CURVE_WORDS.origins.includes(t.origin ?? 'user')))
+        return { code: 'unitRefused' };
+    let lo, hi;
+    if (rq.extents)
+        [lo, hi] = [rq.extents.min, rq.extents.max];
+    else if (eq)
+        [lo, hi] = [CURVE_EXTENTS.freqMinHz, Math.min(CURVE_EXTENTS.freqMaxHz, (CURVE_EXTENTS.nyquistFraction * rq.sampleRate) / 2)];
+    else
+        [lo, hi] = [CURVE_EXTENTS.levelMinDb, CURVE_EXTENTS.levelMaxDb];
+    if (!(hi > lo) || (eq && !(lo > 0)))
+        return { code: 'pointsRange' };
+    const find = (role, index = 0) => {
+        let found;
+        for (const t of rq.terms)
+            if (t.role === role && (t.index ?? 0) === index)
+                found = t;
+        return found;
+    };
+    return eq ? eqPoints(rq, find, lo, hi) : transferPoints(rq, find, lo, hi);
+}
+const BANDS_MAX = Math.floor((CURVE_POINTS_MAX - 2) / 3);
+const BAND_ROLES = ['band_type', 'band_freq', 'band_gain', 'band_q', 'band_on'];
+function eqPoints(rq, find, lo, hi) {
+    let nb = 0;
+    for (const t of rq.terms) {
+        if (!BAND_ROLES.includes(t.role))
+            continue;
+        const i = t.index ?? 0;
+        if (i >= BANDS_MAX)
+            return { code: 'pointsRange' };
+        nb = Math.max(nb, i + 1);
+    }
+    const bands = [];
+    const origin = [];
+    for (let b = 0; b < nb; b++) {
+        const type = find('band_type', b), freq = find('band_freq', b), gain = find('band_gain', b), q = find('band_q', b), on = find('band_on', b);
+        if (!type && !freq && !gain && !q && !on)
+            continue;
+        if (!freq)
+            return { code: 'termMissing' };
+        const shape = type?.shape ?? freq.shape;
+        if (shape === undefined)
+            return { code: 'termMissing' };
+        const kind = SHAPE_TYPE[shape];
+        if (!kind)
+            continue; // off, or a choice with no shape (`-`): not drawn
+        const gains = kind === 'bell' || kind === 'lowshelf' || kind === 'highshelf';
+        if (gains && !gain)
+            return { code: 'termMissing' };
+        if (on && valueOf(on) === 0)
+            continue;
+        bands.push({ type: kind, freq: valueOf(freq), gainDb: gains && gain ? valueOf(gain) : 0,
+            // no Q control: the declared default (EQ_BAND_DEFAULTS), clamped for the shape as the kernel clamps it
+            q: q ? valueOf(q) : Math.fround(clampEqQFor(kind === 'notch' ? 'notch' : 'bell', EQ_BAND_DEFAULTS.q)) });
+        origin.push(freq.origin ?? 'user');
+    }
+    const pass = [];
+    let present = false;
+    for (const [type, pre] of [['highpass', 'hpf'], ['lowpass', 'lpf']]) {
+        const fr = find(`${pre}_freq`), sl = find(`${pre}_slope`), on = find(`${pre}_on`);
+        if (!fr && !sl && !on)
+            continue;
+        present = true;
+        // the slope in dB per octave, from the role's declared enumeration or a dB control; a bare choice value is none
+        if (!fr || !sl || sl.unit !== 'db')
+            return { code: 'termMissing' };
+        const slope = valueOf(sl);
+        if (slope !== 12 && slope !== 24)
+            return { code: 'kindUnknown' };
+        if (on && valueOf(on) === 0)
+            continue;
+        const corner = valueOf(fr);
+        if (corner > 0)
+            for (const q of butterworthQs(slope === 24))
+                pass.push({ type, freq: corner, gainDb: 0, q });
+    }
+    if (nb === 0 && !present)
+        return { code: 'termMissing' };
+    const drawn = [...bands, ...pass];
+    if (rq.points + 3 * drawn.length > CURVE_POINTS_MAX)
+        return { code: 'pointsRange' };
+    const top = (rq.sampleRate / 2) * 0.999;
+    const xs = curveFreqs(drawn, lo, hi, rq.points);
+    const sum = (set) => xs.map((x) => ({ x, y: magnitudeSumDb(set, x < top ? x : top, rq.sampleRate, CURVE_EXTENTS.eqFloorDb) }));
+    const marks = bands.flatMap((b, i) => origin[i] === 'user' ? [] : [{ freq: b.freq, depthDb: magnitudeSumDb([b], b.freq, rq.sampleRate, CURVE_EXTENTS.eqFloorDb), q: b.q, origin: origin[i] }]);
+    const points = sum(drawn);
+    if (!rq.userOnly)
+        return { points, marks };
+    return { points, marks, userPoints: sum([...bands.filter((_, i) => origin[i] === 'user'), ...pass]) };
+}
+function transferPoints(rq, find, lo, hi) {
+    const below = rq.family === 'gate';
+    const thr = find('threshold'), ratio = find('ratio'), knee = find('knee'), makeup = find('makeup'), range = find('range');
+    const ks = find('knee_start'), ke = find('knee_end');
+    // a limiter has no ratio role: the dynamics form at ratio infinity, a hard corner at the threshold
+    const limiter = rq.family === 'limiter';
+    if (!thr || (!ratio && !limiter) || (below && !range) || (below && !ks !== !ke))
+        return { code: 'termMissing' };
+    const f = Math.fround;
+    const r = ratio ? f(valueOf(ratio)) : Infinity, k = knee ? f(valueOf(knee)) : 0;
+    const rmin = f(below ? GATE_RATIO_RANGE.min : COMP_RATIO_RANGE.min);
+    const thresh = f(valueOf(thr));
+    let kneeDb = k < COMP_KNEE_DB_RANGE.min ? COMP_KNEE_DB_RANGE.min : k;
+    let shiftDb = 0;
+    let rangeDb = 0;
+    if (below && range) {
+        const rg = f(valueOf(range));
+        rangeDb = rg > GATE_RANGE_DB_RANGE.max ? GATE_RANGE_DB_RANGE.max : rg;
+        if (ks && ke)
+            ({ kneeDb, shiftDb } = gateKnee(thresh, valueOf(ks), valueOf(ke)));
+    }
+    const p = { mode: below ? 'below' : 'above', threshDb: thresh, ratio: r < rmin ? rmin : r, kneeDb, rangeDb };
+    const mk = makeup ? valueOf(makeup) : 0;
+    const n = rq.points;
+    const points = [];
+    for (let i = 0; i < n; i++) {
+        const lv = i + 1 === n ? hi : lo + ((hi - lo) * i) / (n - 1);
+        const g = below ? gaincompDbShifted(p, shiftDb, lv) : gaincompDb(p, lv);
+        points.push({ x: lv, y: lv + g + mk });
+    }
+    return rq.userOnly ? { points, marks: [], userPoints: points } : { points, marks: [] };
+}

package/dist/definitions.d.ts

@@ -13,6 +13,95 @@ export declare const LOWPASS_HANDOVER: {
     readonly hiAtLoQ: 0.9;
     readonly hiAtPeakQ: 0.8;
 };
+/** What every band of a fresh EQ comes up at, whatever its type and its strip: flat (0 dB) and Q 1. The band frequencies and types come from the default rule. @see data/kernels/eq.json */
+export declare const EQ_BAND_DEFAULTS: {
+    readonly gainDb: 0;
+    readonly q: 1;
+};
+/** The deepest cut a band of an fbs-* origin may hold, in dB: the feedback corrector's own safety bound, never the operator EQ's ±15 (EQ_GAIN_RANGE), which stays the bound of every other origin. Declared here as one value until the vocabulary owner (omx-contract) carries it as its own word, a new ref beside EQ_GAIN_RANGE and never a widening of it; this item then becomes that ref, and no second copy of the number is ever written. (dB) @see data/kernels/fbs.json */
+export declare const FBS_MAX_CUT_DB = -24;
+/** How much deeper a live band's full depth goes each time regrowth re-clamps a release, in dB, down to FBS_MAX_CUT_DB: regrowth at a depth is the measurement that the depth was not enough. (dB) @see data/kernels/fbs.json */
+export declare const FBS_RECLAMP_DEEPEN_DB = 3;
+/** The most times the clean hold doubles after re-clamps: the hold before the first release stage is the channel's hold times 2^min(re-clamps, this). @see data/kernels/fbs.json */
+export declare const FBS_RECLAMP_BACKOFF_CAP = 3;
+/** How long one release stage's gain ramp takes, in ms, from the depth the band stands at to the stage's depth. (ms) @see data/kernels/fbs.json */
+export declare const FBS_LIFT_RAMP_MS = 3000;
+/** The equal steps one release ramp takes, FBS_LIFT_RAMP_MS / this apart: the last step lands the stage's depth exactly. @see data/kernels/fbs.json */
+export declare const FBS_LIFT_RAMP_STEPS = 10;
+/** Each release stage holds the planted depth times this ratio to the stage's power: every stage releases a third of what remains. @see data/kernels/fbs.json */
+export declare const FBS_RELEASE_RATIO = 0.6666666666666666;
+/** A release stage whose depth is shallower than this, in dB, removes the band instead of holding it: the cut is inaudible. (dB) @see data/kernels/fbs.json */
+export declare const FBS_RELEASE_DONE_DB = 1;
+/** How long a band listens at an eased stage, clean, before the next stage begins, in ms. (ms) @see data/kernels/fbs.json */
+export declare const FBS_RELEASE_DWELL_MS = 8000;
+/** The lowest frequency a confirmed ring is planted at, in Hz; one below it is refused as rejected-edge, never clamped onto the EQ's edge. (Hz) @see data/kernels/fbs.json */
+export declare const FBS_RING_HZ_MIN = 60;
+/** The highest frequency a confirmed ring is planted at, in Hz; one above it is refused as rejected-edge. (Hz) @see data/kernels/fbs.json */
+export declare const FBS_RING_HZ_MAX = 16000;
+/** Two readings are the same ringing frequency within this many Hz, or FBS_SAME_RING_SHARE of the higher one, whichever is wider. (Hz) @see data/kernels/fbs.json */
+export declare const FBS_SAME_RING_HZ = 3;
+/** The share of the higher frequency within which two readings are the same ringing frequency, when it is wider than FBS_SAME_RING_HZ: FFT bin spacing grows with frequency. @see data/kernels/fbs.json */
+export declare const FBS_SAME_RING_SHARE = 0.015;
+/** The clean hold, in seconds, before a live band's first release stage. (s) @see data/kernels/fbs.json */
+export declare const FBS_DEFAULT_HOLD_SECONDS = 5;
+/** How many bands one corrector may plant when nobody set its cap; a full pool plants nothing and says pool-full. @see data/kernels/fbs.json */
+export declare const FBS_DEFAULT_MAX_AUTO_BANDS = 6;
+/** The merge radius, in cents: a confirmed ring this close to a band already planted is that band's find, and plants nothing. (cents) @see data/kernels/fbs.json */
+export declare const FBS_DEFAULT_MERGE_CENTS = 100;
+/** How long a fully released find's re-clamp count is remembered, in seconds, so a chronic ringer re-plants with its doubled holds. (s) @see data/kernels/fbs.json */
+export declare const FBS_DEFAULT_COOLDOWN_SECONDS = 600;
+/** Default planted-notch width (Q) — the dbx-AFS-style ultra-narrow notch the corrector plants. `addBand`'s per-shape clamp holds it at 116 for a fixed notch and narrows it to 8 for a live bell, so this is the declared starting point rather than the width every notch ends up with. @see data/kernels/fbs.json */
+export declare const FBS_DEFAULT_NOTCH_Q = 116;
+/** Released finds the ring memory holds at once. The console's list is unbounded and expires by FBS_DEFAULT_COOLDOWN_SECONDS; a full memory here forgets its oldest entry first, and counts it. @see data/kernels/fbs.json */
+export declare const FBS_RING_MEMORY_SLOTS = 32;
+/** The displays a panel description draws from a closed form, the kinds omx_curve_points answers: an EQ's magnitude response, x in Hz and y in dB, and a dynamics stage's static transfer curve, input dB to output dB. The wire spells each id in snake case (`eq_response`, `transfer_curve`), the description's own display word. @see data/primitives/curve.json */
+export declare const CURVE_DISPLAYS: readonly ["eqResponse", "transferCurve"];
+/** The panel families omx_curve_points draws, by the description's family word. `eq` draws an eq_response; the other four a transfer_curve, the family choosing the gain computer's mode: `dynamics`, `limiter` and `deesser` act ABOVE the threshold, `gate` BELOW it with the shifted knee of the gate's knee range. Any other family has no closed form here. @see data/primitives/curve.json */
+export declare const CURVE_FAMILIES: readonly ["eq", "dynamics", "limiter", "gate", "deesser"];
+/** The roles of a panel description a curve request reads, by the description's role word (the wire spells each id in snake case: `band_freq`, `knee_start`). The EQ's indexed band roles and head filters, and the gain computer's terms. A term of any other role is no term of the curve. @see data/primitives/curve.json */
+export declare const CURVE_ROLES: readonly ["bandType", "bandFreq", "bandGain", "bandQ", "bandOn", "hpfFreq", "hpfSlope", "hpfOn", "lpfFreq", "lpfSlope", "lpfOn", "threshold", "ratio", "knee", "makeup", "range", "kneeStart", "kneeEnd"];
+/** The units a curve term's value may come in, the param-contract extension's unit tokens the served description gives a role. omx_curve_points converts once: `coef` to dB for a gain, `oct` to Q for a bandwidth, `khz` to Hz; a level in `db`, `dbfs`, `dbu` or `lufs` is read as dB from the threshold's own scale; `none` is a plain number, a switch or a choice; `ratio` a ratio. A unit its role does not accept is refused. @see data/primitives/curve.json */
+export declare const CURVE_UNITS: readonly ["hz", "khz", "db", "dbfs", "dbu", "lufs", "coef", "oct", "none", "ratio"];
+/** The shape of an EQ band, as the caller resolves it from the description: a `band_type` role's `shapes` list indexed by the control's choice value, or the fixed `shape` of a band no control selects. `off` is a band that is not drawn, and so is `unshaped`, spelt `-` on the wire, a choice value with no shape. The others design the band through omx_eq_design: a bell, the two shelves, the pass filters, the notch, and the first- and second-order allpasses, which draw what they run, 0 dB. @see data/primitives/curve.json */
+export declare const CURVE_SHAPES: readonly ["off", "bell", "lowshelf", "highshelf", "highpass", "lowpass", "notch", "unshaped", "allpass1", "allpass2"];
+/** Where an EQ band of a curve request comes from, as the console's strip EQ state says it (its BAND_ORIGINS): `user`, the operator's own band, and the bands a planter put there, `fbsFixed` and `fbsLive` (the feedback corrector's ring-out and show pools), `hrp` (the harmonic resonance processor's cuts) and `roomMode` (a room mode's correction), spelt `user`, `fbs-fixed`, `fbs-live`, `hrp` and `room-mode` on the wire. The sum ignores it: every drawn band is in the curve. A band whose origin is not `user` is answered as a mark (its frequency, depth, Q and origin), and a request that asks for it also gets the curve over the `user` bands alone. A plugin's descriptor carries no origin: a request with none draws no marks. @see data/primitives/curve.json */
+export declare const CURVE_ORIGINS: readonly ["user", "fbsFixed", "fbsLive", "hrp", "roomMode"];
+/** What omx_curve_points answers in its code: `ok`, a curve; `kindUnknown`, a kind, family or head filter slope with no closed form; `termMissing`, a term the closed form has no default for is not in the request (a band's frequency and shape, a bell's or shelf's gain, a head filter's corner, and its slope unless it comes from the role's declared enumeration as dB per octave; threshold and ratio for dynamics and the de-esser, threshold for a limiter (its ratio is infinity, a hard corner), threshold, range and ratio for a gate; both ends of a gate's knee range or neither); `unitRefused`, a term in a unit its role does not accept; `valueNotFinite`, a value, the rate or an extent that is not finite, a rate that is not positive; `pointsRange`, grid points outside 2 to CURVE_POINTS_MAX (for an EQ, with three anchors a drawn band), a band index past what fits, or extents that bound nothing; `room`, a caller's buffers too small. Where omx-dsp declares a default the curve takes it: a band's Q is EQ_BAND_DEFAULTS q, clamped for its shape as clampEqQFor clamps it. No curve is drawn from a guess. @see data/primitives/curve.json */
+export declare const CURVE_CODES: readonly ["ok", "kindUnknown", "termMissing", "unitRefused", "valueNotFinite", "pointsRange", "room"];
+/** The most points one curve carries, an EQ's band anchors included: a reply of x with four significant digits and y to 0.01 dB, about 13 bytes a point, fits the 4096-byte line a host's reply is built in. Every caller reads it here; it moves with that buffer, in this one place. @see data/primitives/curve.json */
+export declare const CURVE_POINTS_MAX = 256;
+/** A curve's default extents, where a request gives none: an eq_response from `freqMinHz` to the lower of `freqMaxHz` and `nyquistFraction` of Nyquist, each band's dB floored at `eqFloorDb` so a notch's null stays finite (the console's EQ draws to -120 dB); a transfer_curve's input from `levelMinDb` to `levelMaxDb`. Hz and dB. @see data/primitives/curve.json */
+export declare const CURVE_EXTENTS: {
+    readonly freqMinHz: 20;
+    readonly freqMaxHz: 20000;
+    readonly nyquistFraction: 0.999;
+    readonly eqFloorDb: -120;
+    readonly levelMinDb: -80;
+    readonly levelMaxDb: 0;
+};
+/** The floor of the linear-to-decibel conversions (`omx_lin_to_db`, `omx_lin_to_db_poly`): an amplitude below `lin` reads as `lin`, so silence is `db` dB, never -inf or NaN. `db` is `20·log10(lin)`. A design constant, not a control. @see data/primitives/lin-to-db-floor.json */
+export declare const LIN_TO_DB_FLOOR: {
+    readonly lin: 1e-9;
+    readonly db: -180;
+};
+/** A meter's view law, the same on every surface: the fill is linear in dB from `floorDb` (dBFS, an empty display) to 0 dBFS (a full one); a stepped display (an LED ladder) holds its count until the level moves `stepHysteresis` of a step past the count's own rounding edge; the peak marker falls `fallDbPerSecond` dB for each second elapsed at the view's draw tick, whatever the tick's rate, silence included. A host reads a plugin's held meter at `hostReadHz`; the console streams meter values at `streamHz`. dBFS, a fraction of a step, dB per second and Hz. @see data/primitives/meter.json */
+export declare const METER_VIEW: {
+    readonly floorDb: -60;
+    readonly stepHysteresis: 0.25;
+    readonly fallDbPerSecond: 18;
+    readonly hostReadHz: 50;
+    readonly streamHz: 20;
+};
+/** What a meter measures, as a plugin's descriptor and the panel description spell it: `level`, a signal level (its measurement one of METER_MEASUREMENTS), and `gainReduction`, the gain a dynamics stage takes off, dB at or below 0. The wire spells them `level` and `gain-reduction`. `rms`, `vu` and `ppm` are not kinds. @see data/primitives/meter.json */
+export declare const METER_KINDS: readonly ["level", "gainReduction"];
+/** The measurement of a `level` meter: the sample peak (`peak`, dBFS), the true peak (`truePeak`, dBTP), and the loudness measures of omx_loudness.h: momentary, short-term and integrated loudness (`lufsM`, `lufsS`, `lufsI`, LUFS) and the loudness range (`lra`, LU). The wire spells them `peak`, `true-peak`, `lufs-m`, `lufs-s`, `lufs-i` and `lra`. A foreign meter's measurement is null, never guessed. @see data/primitives/meter.json */
+export declare const METER_MEASUREMENTS: readonly ["peak", "truePeak", "lufsM", "lufsS", "lufsI", "lra"];
+/** The unit a meter's values are in, spelt as its label: dBFS for a sample peak, dBTP for a true peak, LUFS for a loudness, LU for a loudness range, dB for a gain reduction. The scale a surface draws is captioned with it. @see data/primitives/meter.json */
+export declare const METER_UNITS: readonly ["dbfs", "dbtp", "lufs", "lu", "db"];
+/** The labels of METER_UNITS, in its order. @see data/primitives/meter.json */
+export declare const METER_UNITS_LABELS: readonly ["dBFS", "dBTP", "LUFS", "LU", "dB"];
+/** What a subscriber that decimates a meter stream keeps of the frames it drops, one per kind in METER_KINDS order, as the engine's slot keeps between two reads: a `level` keeps the `peak` (the largest value), a `gainReduction` the `deepest` (the smallest dB). Never the newest. @see data/primitives/meter.json */
+export declare const METER_DECIMATION: readonly ["peak", "deepest"];
 /** The Q (resonance) extent of a parametric band. @see data/kernels/eq.json */
 export declare const EQ_Q_RANGE: {
     readonly min: 0.3;
@@ -23,3 +112,53 @@ export declare const EQ_NOTCH_Q_RANGE: {
     readonly min: 0.3;
     readonly max: 116;
 };
+/** The parametric-band gain travel, in dB. The ± scalar `clampEqGain` enforces is READ off this (the engine derives its gain limit 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;
+};
+/** 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;
+};
+/** How many bands this corrector may plant at once (its pool), from one to the EQ's band count. An integer control. @see data/kernels/fbs.json */
+export declare const FBS_BANDS_RANGE: {
+    readonly min: 1;
+    readonly max: 24;
+};
+/** The clean hold, in seconds, before a live band's first release stage. @see data/kernels/fbs.json */
+export declare const FBS_HOLD_RANGE: {
+    readonly min: 1;
+    readonly max: 300;
+};
+/** The merge radius, in cents. An integer control. @see data/kernels/fbs.json */
+export declare const FBS_MERGE_RANGE: {
+    readonly min: 0;
+    readonly max: 600;
+};
+/** How long a released find's escalation is remembered, in seconds. An integer control. @see data/kernels/fbs.json */
+export declare const FBS_COOLDOWN_RANGE: {
+    readonly min: 0;
+    readonly max: 7200;
+};
+/** The travel of ratio, from its table COMP_LIMITS. @see data/kernels/comp.json */
+export declare const COMP_RATIO_RANGE: {
+    readonly min: 1;
+    readonly max: 20;
+};
+/** The travel of kneeDb, from its table COMP_LIMITS. @see data/kernels/comp.json */
+export declare const COMP_KNEE_DB_RANGE: {
+    readonly min: 0;
+    readonly max: 24;
+};
+/** The travel of ratio, from its table GATE_LIMITS. @see data/kernels/gate.json */
+export declare const GATE_RATIO_RANGE: {
+    readonly min: 1;
+    readonly max: 100;
+};
+/** The travel of rangeDb, from its table GATE_LIMITS. @see data/kernels/gate.json */
+export declare const GATE_RANGE_DB_RANGE: {
+    readonly min: -90;
+    readonly max: 0;
+};

package/dist/definitions.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
-// GENERATED by ts/tools/definitions.mjs from omx-dsp data/kernels/ - do not edit.
+// GENERATED by ts/tools/definitions.mjs from omx-dsp data/ - do not edit.
 /** The RTA's target bin resolution — generated into `omx_contract_limits.h` as `OMX_RTA_TARGET_BIN_HZ`, which `mix_dsp.h` reads; the engine's conformance test reads it back from the header. (Hz) @see data/kernels/rta.json */
 export const RTA_TARGET_BIN_HZ = 5.9;
 /** The largest RTA FFT the native ring holds — generated into `omx_contract_limits.h` as `OMX_RTA_FFT_SIZE_MAX`. @see data/kernels/rta.json */
@@ -16,7 +16,116 @@ export const LOWPASS_HANDOVER = {
     hiAtLoQ: 0.9,
     hiAtPeakQ: 0.8,
 };
+/** What every band of a fresh EQ comes up at, whatever its type and its strip: flat (0 dB) and Q 1. The band frequencies and types come from the default rule. @see data/kernels/eq.json */
+export const EQ_BAND_DEFAULTS = {
+    gainDb: 0,
+    q: 1,
+};
+/** The deepest cut a band of an fbs-* origin may hold, in dB: the feedback corrector's own safety bound, never the operator EQ's ±15 (EQ_GAIN_RANGE), which stays the bound of every other origin. Declared here as one value until the vocabulary owner (omx-contract) carries it as its own word, a new ref beside EQ_GAIN_RANGE and never a widening of it; this item then becomes that ref, and no second copy of the number is ever written. (dB) @see data/kernels/fbs.json */
+export const FBS_MAX_CUT_DB = -24;
+/** How much deeper a live band's full depth goes each time regrowth re-clamps a release, in dB, down to FBS_MAX_CUT_DB: regrowth at a depth is the measurement that the depth was not enough. (dB) @see data/kernels/fbs.json */
+export const FBS_RECLAMP_DEEPEN_DB = 3;
+/** The most times the clean hold doubles after re-clamps: the hold before the first release stage is the channel's hold times 2^min(re-clamps, this). @see data/kernels/fbs.json */
+export const FBS_RECLAMP_BACKOFF_CAP = 3;
+/** How long one release stage's gain ramp takes, in ms, from the depth the band stands at to the stage's depth. (ms) @see data/kernels/fbs.json */
+export const FBS_LIFT_RAMP_MS = 3000;
+/** The equal steps one release ramp takes, FBS_LIFT_RAMP_MS / this apart: the last step lands the stage's depth exactly. @see data/kernels/fbs.json */
+export const FBS_LIFT_RAMP_STEPS = 10;
+/** Each release stage holds the planted depth times this ratio to the stage's power: every stage releases a third of what remains. @see data/kernels/fbs.json */
+export const FBS_RELEASE_RATIO = 0.6666666666666666;
+/** A release stage whose depth is shallower than this, in dB, removes the band instead of holding it: the cut is inaudible. (dB) @see data/kernels/fbs.json */
+export const FBS_RELEASE_DONE_DB = 1;
+/** How long a band listens at an eased stage, clean, before the next stage begins, in ms. (ms) @see data/kernels/fbs.json */
+export const FBS_RELEASE_DWELL_MS = 8000;
+/** The lowest frequency a confirmed ring is planted at, in Hz; one below it is refused as rejected-edge, never clamped onto the EQ's edge. (Hz) @see data/kernels/fbs.json */
+export const FBS_RING_HZ_MIN = 60;
+/** The highest frequency a confirmed ring is planted at, in Hz; one above it is refused as rejected-edge. (Hz) @see data/kernels/fbs.json */
+export const FBS_RING_HZ_MAX = 16000;
+/** Two readings are the same ringing frequency within this many Hz, or FBS_SAME_RING_SHARE of the higher one, whichever is wider. (Hz) @see data/kernels/fbs.json */
+export const FBS_SAME_RING_HZ = 3;
+/** The share of the higher frequency within which two readings are the same ringing frequency, when it is wider than FBS_SAME_RING_HZ: FFT bin spacing grows with frequency. @see data/kernels/fbs.json */
+export const FBS_SAME_RING_SHARE = 0.015;
+/** The clean hold, in seconds, before a live band's first release stage. (s) @see data/kernels/fbs.json */
+export const FBS_DEFAULT_HOLD_SECONDS = 5;
+/** How many bands one corrector may plant when nobody set its cap; a full pool plants nothing and says pool-full. @see data/kernels/fbs.json */
+export const FBS_DEFAULT_MAX_AUTO_BANDS = 6;
+/** The merge radius, in cents: a confirmed ring this close to a band already planted is that band's find, and plants nothing. (cents) @see data/kernels/fbs.json */
+export const FBS_DEFAULT_MERGE_CENTS = 100;
+/** How long a fully released find's re-clamp count is remembered, in seconds, so a chronic ringer re-plants with its doubled holds. (s) @see data/kernels/fbs.json */
+export const FBS_DEFAULT_COOLDOWN_SECONDS = 600;
+/** Default planted-notch width (Q) — the dbx-AFS-style ultra-narrow notch the corrector plants. `addBand`'s per-shape clamp holds it at 116 for a fixed notch and narrows it to 8 for a live bell, so this is the declared starting point rather than the width every notch ends up with. @see data/kernels/fbs.json */
+export const FBS_DEFAULT_NOTCH_Q = 116;
+/** Released finds the ring memory holds at once. The console's list is unbounded and expires by FBS_DEFAULT_COOLDOWN_SECONDS; a full memory here forgets its oldest entry first, and counts it. @see data/kernels/fbs.json */
+export const FBS_RING_MEMORY_SLOTS = 32;
+/** The displays a panel description draws from a closed form, the kinds omx_curve_points answers: an EQ's magnitude response, x in Hz and y in dB, and a dynamics stage's static transfer curve, input dB to output dB. The wire spells each id in snake case (`eq_response`, `transfer_curve`), the description's own display word. @see data/primitives/curve.json */
+export const CURVE_DISPLAYS = ['eqResponse', 'transferCurve'];
+/** The panel families omx_curve_points draws, by the description's family word. `eq` draws an eq_response; the other four a transfer_curve, the family choosing the gain computer's mode: `dynamics`, `limiter` and `deesser` act ABOVE the threshold, `gate` BELOW it with the shifted knee of the gate's knee range. Any other family has no closed form here. @see data/primitives/curve.json */
+export const CURVE_FAMILIES = ['eq', 'dynamics', 'limiter', 'gate', 'deesser'];
+/** The roles of a panel description a curve request reads, by the description's role word (the wire spells each id in snake case: `band_freq`, `knee_start`). The EQ's indexed band roles and head filters, and the gain computer's terms. A term of any other role is no term of the curve. @see data/primitives/curve.json */
+export const CURVE_ROLES = ['bandType', 'bandFreq', 'bandGain', 'bandQ', 'bandOn', 'hpfFreq', 'hpfSlope', 'hpfOn', 'lpfFreq', 'lpfSlope', 'lpfOn', 'threshold', 'ratio', 'knee', 'makeup', 'range', 'kneeStart', 'kneeEnd'];
+/** The units a curve term's value may come in, the param-contract extension's unit tokens the served description gives a role. omx_curve_points converts once: `coef` to dB for a gain, `oct` to Q for a bandwidth, `khz` to Hz; a level in `db`, `dbfs`, `dbu` or `lufs` is read as dB from the threshold's own scale; `none` is a plain number, a switch or a choice; `ratio` a ratio. A unit its role does not accept is refused. @see data/primitives/curve.json */
+export const CURVE_UNITS = ['hz', 'khz', 'db', 'dbfs', 'dbu', 'lufs', 'coef', 'oct', 'none', 'ratio'];
+/** The shape of an EQ band, as the caller resolves it from the description: a `band_type` role's `shapes` list indexed by the control's choice value, or the fixed `shape` of a band no control selects. `off` is a band that is not drawn, and so is `unshaped`, spelt `-` on the wire, a choice value with no shape. The others design the band through omx_eq_design: a bell, the two shelves, the pass filters, the notch, and the first- and second-order allpasses, which draw what they run, 0 dB. @see data/primitives/curve.json */
+export const CURVE_SHAPES = ['off', 'bell', 'lowshelf', 'highshelf', 'highpass', 'lowpass', 'notch', 'unshaped', 'allpass1', 'allpass2'];
+/** Where an EQ band of a curve request comes from, as the console's strip EQ state says it (its BAND_ORIGINS): `user`, the operator's own band, and the bands a planter put there, `fbsFixed` and `fbsLive` (the feedback corrector's ring-out and show pools), `hrp` (the harmonic resonance processor's cuts) and `roomMode` (a room mode's correction), spelt `user`, `fbs-fixed`, `fbs-live`, `hrp` and `room-mode` on the wire. The sum ignores it: every drawn band is in the curve. A band whose origin is not `user` is answered as a mark (its frequency, depth, Q and origin), and a request that asks for it also gets the curve over the `user` bands alone. A plugin's descriptor carries no origin: a request with none draws no marks. @see data/primitives/curve.json */
+export const CURVE_ORIGINS = ['user', 'fbsFixed', 'fbsLive', 'hrp', 'roomMode'];
+/** What omx_curve_points answers in its code: `ok`, a curve; `kindUnknown`, a kind, family or head filter slope with no closed form; `termMissing`, a term the closed form has no default for is not in the request (a band's frequency and shape, a bell's or shelf's gain, a head filter's corner, and its slope unless it comes from the role's declared enumeration as dB per octave; threshold and ratio for dynamics and the de-esser, threshold for a limiter (its ratio is infinity, a hard corner), threshold, range and ratio for a gate; both ends of a gate's knee range or neither); `unitRefused`, a term in a unit its role does not accept; `valueNotFinite`, a value, the rate or an extent that is not finite, a rate that is not positive; `pointsRange`, grid points outside 2 to CURVE_POINTS_MAX (for an EQ, with three anchors a drawn band), a band index past what fits, or extents that bound nothing; `room`, a caller's buffers too small. Where omx-dsp declares a default the curve takes it: a band's Q is EQ_BAND_DEFAULTS q, clamped for its shape as clampEqQFor clamps it. No curve is drawn from a guess. @see data/primitives/curve.json */
+export const CURVE_CODES = ['ok', 'kindUnknown', 'termMissing', 'unitRefused', 'valueNotFinite', 'pointsRange', 'room'];
+/** The most points one curve carries, an EQ's band anchors included: a reply of x with four significant digits and y to 0.01 dB, about 13 bytes a point, fits the 4096-byte line a host's reply is built in. Every caller reads it here; it moves with that buffer, in this one place. @see data/primitives/curve.json */
+export const CURVE_POINTS_MAX = 256;
+/** A curve's default extents, where a request gives none: an eq_response from `freqMinHz` to the lower of `freqMaxHz` and `nyquistFraction` of Nyquist, each band's dB floored at `eqFloorDb` so a notch's null stays finite (the console's EQ draws to -120 dB); a transfer_curve's input from `levelMinDb` to `levelMaxDb`. Hz and dB. @see data/primitives/curve.json */
+export const CURVE_EXTENTS = {
+    freqMinHz: 20,
+    freqMaxHz: 20000,
+    nyquistFraction: 0.999,
+    eqFloorDb: -120,
+    levelMinDb: -80,
+    levelMaxDb: 0,
+};
+/** The floor of the linear-to-decibel conversions (`omx_lin_to_db`, `omx_lin_to_db_poly`): an amplitude below `lin` reads as `lin`, so silence is `db` dB, never -inf or NaN. `db` is `20·log10(lin)`. A design constant, not a control. @see data/primitives/lin-to-db-floor.json */
+export const LIN_TO_DB_FLOOR = {
+    lin: 1e-9,
+    db: -180,
+};
+/** A meter's view law, the same on every surface: the fill is linear in dB from `floorDb` (dBFS, an empty display) to 0 dBFS (a full one); a stepped display (an LED ladder) holds its count until the level moves `stepHysteresis` of a step past the count's own rounding edge; the peak marker falls `fallDbPerSecond` dB for each second elapsed at the view's draw tick, whatever the tick's rate, silence included. A host reads a plugin's held meter at `hostReadHz`; the console streams meter values at `streamHz`. dBFS, a fraction of a step, dB per second and Hz. @see data/primitives/meter.json */
+export const METER_VIEW = {
+    floorDb: -60,
+    stepHysteresis: 0.25,
+    fallDbPerSecond: 18,
+    hostReadHz: 50,
+    streamHz: 20,
+};
+/** What a meter measures, as a plugin's descriptor and the panel description spell it: `level`, a signal level (its measurement one of METER_MEASUREMENTS), and `gainReduction`, the gain a dynamics stage takes off, dB at or below 0. The wire spells them `level` and `gain-reduction`. `rms`, `vu` and `ppm` are not kinds. @see data/primitives/meter.json */
+export const METER_KINDS = ['level', 'gainReduction'];
+/** The measurement of a `level` meter: the sample peak (`peak`, dBFS), the true peak (`truePeak`, dBTP), and the loudness measures of omx_loudness.h: momentary, short-term and integrated loudness (`lufsM`, `lufsS`, `lufsI`, LUFS) and the loudness range (`lra`, LU). The wire spells them `peak`, `true-peak`, `lufs-m`, `lufs-s`, `lufs-i` and `lra`. A foreign meter's measurement is null, never guessed. @see data/primitives/meter.json */
+export const METER_MEASUREMENTS = ['peak', 'truePeak', 'lufsM', 'lufsS', 'lufsI', 'lra'];
+/** The unit a meter's values are in, spelt as its label: dBFS for a sample peak, dBTP for a true peak, LUFS for a loudness, LU for a loudness range, dB for a gain reduction. The scale a surface draws is captioned with it. @see data/primitives/meter.json */
+export const METER_UNITS = ['dbfs', 'dbtp', 'lufs', 'lu', 'db'];
+/** The labels of METER_UNITS, in its order. @see data/primitives/meter.json */
+export const METER_UNITS_LABELS = ['dBFS', 'dBTP', 'LUFS', 'LU', 'dB'];
+/** What a subscriber that decimates a meter stream keeps of the frames it drops, one per kind in METER_KINDS order, as the engine's slot keeps between two reads: a `level` keeps the `peak` (the largest value), a `gainReduction` the `deepest` (the smallest dB). Never the newest. @see data/primitives/meter.json */
+export const METER_DECIMATION = ['peak', 'deepest'];
 /** The Q (resonance) extent of a parametric band. @see data/kernels/eq.json */
 export const EQ_Q_RANGE = { min: 0.3, max: 8 };
 /** 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 const EQ_NOTCH_Q_RANGE = { min: 0.3, max: 116 };
+/** The parametric-band gain travel, in dB. The ± scalar `clampEqGain` enforces is READ off this (the engine derives its gain limit 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 const EQ_GAIN_RANGE = { min: -15, max: 15 };
+/** The frequency band a parametric band can be dragged across. @see data/kernels/eq.json */
+export const EQ_FREQ_RANGE = { min: 20, max: 20000 };
+/** How many bands this corrector may plant at once (its pool), from one to the EQ's band count. An integer control. @see data/kernels/fbs.json */
+export const FBS_BANDS_RANGE = { min: 1, max: 24 };
+/** The clean hold, in seconds, before a live band's first release stage. @see data/kernels/fbs.json */
+export const FBS_HOLD_RANGE = { min: 1, max: 300 };
+/** The merge radius, in cents. An integer control. @see data/kernels/fbs.json */
+export const FBS_MERGE_RANGE = { min: 0, max: 600 };
+/** How long a released find's escalation is remembered, in seconds. An integer control. @see data/kernels/fbs.json */
+export const FBS_COOLDOWN_RANGE = { min: 0, max: 7200 };
+/** The travel of ratio, from its table COMP_LIMITS. @see data/kernels/comp.json */
+export const COMP_RATIO_RANGE = { min: 1, max: 20 };
+/** The travel of kneeDb, from its table COMP_LIMITS. @see data/kernels/comp.json */
+export const COMP_KNEE_DB_RANGE = { min: 0, max: 24 };
+/** The travel of ratio, from its table GATE_LIMITS. @see data/kernels/gate.json */
+export const GATE_RATIO_RANGE = { min: 1, max: 100 };
+/** The travel of rangeDb, from its table GATE_LIMITS. @see data/kernels/gate.json */
+export const GATE_RANGE_DB_RANGE = { min: -90, max: 0 };