@openmixer/omx-dsp 0.30.0 → 0.31.0

package/dist/curve.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 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[];
+};
+/** 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;
+}
+/** 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[];
+}
+/** 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[];
+} | {
+    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,208 @@
+// 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_POINTS_MAX, CURVE_ROLES, CURVE_SHAPES, CURVE_UNITS, GATE_RANGE_DB_RANGE, GATE_RATIO_RANGE, LIN_TO_DB_FLOOR, } from './definitions.js';
+import { 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),
+};
+/** 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',
+};
+/** 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)))
+        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 = [];
+    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' };
+        if (shape === 'off')
+            continue;
+        const kind = SHAPE_TYPE[shape];
+        if (!kind)
+            return { code: 'kindUnknown' };
+        if (!q)
+            return { code: 'termMissing' };
+        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, q: valueOf(q) });
+    }
+    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;
+        if (!fr || !sl)
+            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 points = curveFreqs(drawn, lo, hi, rq.points).map((x) => ({
+        x,
+        y: magnitudeSumDb(drawn, x < top ? x : top, rq.sampleRate, CURVE_EXTENTS.eqFloorDb),
+    }));
+    return { points };
+}
+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');
+    if (!thr || !ratio || (below && !range) || (below && !ks !== !ke))
+        return { code: 'termMissing' };
+    const f = Math.fround;
+    const r = f(valueOf(ratio)), 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 { points };
+}

package/dist/definitions.d.ts

@@ -13,6 +13,34 @@ export declare const LOWPASS_HANDOVER: {
     readonly hiAtLoQ: 0.9;
     readonly hiAtPeakQ: 0.8;
 };
+/** 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; `unshaped`, spelt `-` on the wire, a choice value with no closed form, which no curve is drawn from. The others design the band through omx_eq_design: a bell, the two shelves, the pass filters and the notch. @see data/primitives/curve.json */
+export declare const CURVE_SHAPES: readonly ["off", "bell", "lowshelf", "highshelf", "highpass", "lowpass", "notch", "unshaped"];
+/** What omx_curve_points answers in its code: `ok`, a curve; `kindUnknown`, a kind, family, shape or slope with no closed form; `termMissing`, a term the model needs is not in the request (a band's frequency, shape and Q, a bell's or shelf's gain, a head filter's corner and slope; threshold and ratio for an ABOVE family; 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 for the points. No curve is drawn from a guess: a missing term is a code, never a default. @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;
+};
 /** 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 +51,23 @@ export declare const EQ_NOTCH_Q_RANGE: {
     readonly min: 0.3;
     readonly max: 116;
 };
+/** 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,43 @@ export const LOWPASS_HANDOVER = {
     hiAtLoQ: 0.9,
     hiAtPeakQ: 0.8,
 };
+/** 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; `unshaped`, spelt `-` on the wire, a choice value with no closed form, which no curve is drawn from. The others design the band through omx_eq_design: a bell, the two shelves, the pass filters and the notch. @see data/primitives/curve.json */
+export const CURVE_SHAPES = ['off', 'bell', 'lowshelf', 'highshelf', 'highpass', 'lowpass', 'notch', 'unshaped'];
+/** What omx_curve_points answers in its code: `ok`, a curve; `kindUnknown`, a kind, family, shape or slope with no closed form; `termMissing`, a term the model needs is not in the request (a band's frequency, shape and Q, a bell's or shelf's gain, a head filter's corner and slope; threshold and ratio for an ABOVE family; 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 for the points. No curve is drawn from a guess: a missing term is a code, never a default. @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,
+};
 /** 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 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 };

package/dist/gaincomp.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The gain computer twins: omx_gaincomp_db, omx_gaincomp_db_shifted and omx_gate_knee (omx_gaincomp.h, omx_gate.h),
+ * the static characteristic a dynamics curve draws. The kernel is float; each step here is rounded to float by
+ * Math.fround as the kernel rounds it (every operation is one IEEE single operation, and a double result rounded
+ * once to single is the single result for +, -, *, / and sqrt), so the twin is the kernel's value, bit for bit,
+ * where the kernel is built without contraction (-ffp-contract=off, as omxdsp.pc says). Pinned by
+ * test/agreement.test.mjs.
+ */
+/** The gain computer's mode: act ABOVE the threshold (comp, limiter), BELOW it (gate, expander), or raise the
+ *  signal below it (UPWARD). omx_gaincomp.h's OMX_DYN_ABOVE, OMX_DYN_BELOW and OMX_DYN_UPWARD. */
+export type GaincompMode = 'above' | 'below' | 'upward';
+/** The gain computer's parameters, omx_gaincomp_params: each value is narrowed to float as the kernel stores it. */
+export interface GaincompParams {
+    readonly mode: GaincompMode;
+    /** The threshold, dB. */
+    readonly threshDb: number;
+    /** The ratio, at least the mode's minimum. */
+    readonly ratio: number;
+    /** The knee width, dB, not negative; 0 is a hard knee. */
+    readonly kneeDb: number;
+    /** BELOW: the attenuation floor, dB, at most 0. UPWARD: the largest boost, dB. Not read in ABOVE. */
+    readonly rangeDb: number;
+}
+/**
+ * The static gain, dB, at detector level `levelDb`: the twin of omx_gaincomp_db (its per-sample form).
+ * @param p The parameters.
+ * @param levelDb The detector level, dB; finite.
+ */
+export declare function gaincompDb(p: GaincompParams, levelDb: number): number;
+/**
+ * The BELOW static gain, dB, with the knee's centre moved `shiftDb` off the threshold: the twin of
+ * omx_gaincomp_db_shifted. A shift of 0 is {@link gaincompDb} itself.
+ * @param p The parameters, `mode` 'below'.
+ * @param shiftDb The knee centre's offset from the threshold, dB, inside half the knee.
+ * @param levelDb The detector level, dB; finite.
+ */
+export declare function gaincompDbShifted(p: GaincompParams, shiftDb: number, levelDb: number): number;
+/**
+ * The knee range of a gate as the kernel resolves it, omx_gate_knee: the width of the range and its centre's offset
+ * from the threshold, held inside half the width; equal ends are the hard knee wherever they sit.
+ * @param threshDb The threshold, dB.
+ * @param kneeStartDb One end of the range, dB.
+ * @param kneeEndDb The other end, dB.
+ */
+export declare function gateKnee(threshDb: number, kneeStartDb: number, kneeEndDb: number): {
+    kneeDb: number;
+    shiftDb: number;
+};

package/dist/gaincomp.js

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * The gain computer twins: omx_gaincomp_db, omx_gaincomp_db_shifted and omx_gate_knee (omx_gaincomp.h, omx_gate.h),
+ * the static characteristic a dynamics curve draws. The kernel is float; each step here is rounded to float by
+ * Math.fround as the kernel rounds it (every operation is one IEEE single operation, and a double result rounded
+ * once to single is the single result for +, -, *, / and sqrt), so the twin is the kernel's value, bit for bit,
+ * where the kernel is built without contraction (-ffp-contract=off, as omxdsp.pc says). Pinned by
+ * test/agreement.test.mjs.
+ */
+const f = Math.fround;
+/**
+ * The static gain, dB, at detector level `levelDb`: the twin of omx_gaincomp_db (its per-sample form).
+ * @param p The parameters.
+ * @param levelDb The detector level, dB; finite.
+ */
+export function gaincompDb(p, levelDb) {
+    const thresh = f(p.threshDb), ratio = f(p.ratio), knee = f(p.kneeDb), range = f(p.rangeDb);
+    const x = f(f(levelDb) - thresh);
+    const half = f(0.5 * knee);
+    const soft = knee > 0;
+    const k2 = soft ? f(2 * knee) : 1;
+    const eb = f(x - half);
+    const kb = f(f(f(f(1 - ratio) * eb) * eb) / k2);
+    let gb = soft && x > -half ? kb : f(f(ratio - 1) * x);
+    gb = x >= half ? 0 : gb;
+    gb = gb < range ? range : gb;
+    const slope = f(f(1 / ratio) - 1);
+    const ea = f(x + half);
+    const ka = f(f(f(slope * ea) * ea) / k2);
+    let ga = soft && x < half ? ka : f(slope * x);
+    ga = x <= -half ? 0 : ga;
+    const eu = f(half - x);
+    const ku = f(f(f(slope * eu) * eu) / k2);
+    let gu = soft && -x < half ? ku : f(slope * -x);
+    gu = -x <= -half ? 0 : -gu;
+    gu = gu > range ? range : gu;
+    return p.mode === 'below' ? gb : p.mode === 'upward' ? gu : ga;
+}
+/** The gate's off-centre knee, omx_gaincomp_knee_shifted: the quadratic Bezier between the expander's line and
+ *  0 dB at `x`, for `xl < x < xh`, every value already a float. */
+function kneeShifted(ratio, xl, xh, x) {
+    const a = f(xl + xh), b = f(-2 * xl), d = f(x - xl);
+    const disc0 = f(f(b * b) + f(f(4 * a) * d));
+    const disc = disc0 > 0 ? disc0 : 0;
+    const den0 = f(b + f(Math.sqrt(disc)));
+    const den = den0 > 0 ? den0 : 1;
+    const u = f(f(2 * d) / den);
+    const w = f(1 - u);
+    return f(f(f(w * w) * f(ratio - 1)) * xl);
+}
+/**
+ * The BELOW static gain, dB, with the knee's centre moved `shiftDb` off the threshold: the twin of
+ * omx_gaincomp_db_shifted. A shift of 0 is {@link gaincompDb} itself.
+ * @param p The parameters, `mode` 'below'.
+ * @param shiftDb The knee centre's offset from the threshold, dB, inside half the knee.
+ * @param levelDb The detector level, dB; finite.
+ */
+export function gaincompDbShifted(p, shiftDb, levelDb) {
+    const shift = f(shiftDb);
+    if (shift === 0)
+        return gaincompDb(p, levelDb);
+    const thresh = f(p.threshDb), ratio = f(p.ratio), range = f(p.rangeDb);
+    const half = f(0.5 * f(p.kneeDb));
+    const x = f(f(levelDb) - thresh);
+    const xl = f(shift - half), xh = f(shift + half);
+    let g;
+    if (x <= xl)
+        g = f(f(ratio - 1) * x);
+    else if (x >= xh)
+        g = 0;
+    else
+        g = kneeShifted(ratio, xl, xh, x);
+    return g < range ? range : g;
+}
+/**
+ * The knee range of a gate as the kernel resolves it, omx_gate_knee: the width of the range and its centre's offset
+ * from the threshold, held inside half the width; equal ends are the hard knee wherever they sit.
+ * @param threshDb The threshold, dB.
+ * @param kneeStartDb One end of the range, dB.
+ * @param kneeEndDb The other end, dB.
+ */
+export function gateKnee(threshDb, kneeStartDb, kneeEndDb) {
+    const s = f(kneeStartDb), e = f(kneeEndDb);
+    const lo = s < e ? s : e, hi = s < e ? e : s;
+    const width = f(hi - lo);
+    const half = f(0.5 * width);
+    let shift = width > 0 ? f(f(lo + half) - f(threshDb)) : 0;
+    shift = shift < -half ? -half : shift > half ? half : shift;
+    return { kneeDb: width, shiftDb: shift };
+}

package/dist/index.d.ts

@@ -5,5 +5,7 @@
  */
 export { ANALYSIS_FLOOR_DB, dbToLinearGain, linearGainToDb, linearToDbFloored } from './units.js';
 export { biquadMagnitudeDb, clampEqQFor, lowpassHandover, magnitudeSumDb, matchedPair, octavesToQ, rbjSection, sectionMagnitudeDb, type BiquadBand, type BiquadKind, type BiquadSection, type BiquadType, } from './eq.js';
-export { EQ_NOTCH_Q_RANGE, EQ_Q_RANGE, LOWPASS_HANDOVER, RTA_FFT_SIZE_MAX, RTA_TARGET_BIN_HZ } from './definitions.js';
+export { COMP_KNEE_DB_RANGE, COMP_RATIO_RANGE, CURVE_CODES, CURVE_DISPLAYS, CURVE_EXTENTS, CURVE_FAMILIES, CURVE_POINTS_MAX, CURVE_ROLES, CURVE_SHAPES, CURVE_UNITS, EQ_NOTCH_Q_RANGE, EQ_Q_RANGE, GATE_RANGE_DB_RANGE, GATE_RATIO_RANGE, LIN_TO_DB_FLOOR, LOWPASS_HANDOVER, RTA_FFT_SIZE_MAX, RTA_TARGET_BIN_HZ, } from './definitions.js';
 export { fftSizeForRate } from './rta.js';
+export { gaincompDb, gaincompDbShifted, gateKnee, type GaincompMode, type GaincompParams } from './gaincomp.js';
+export { CURVE_WORDS, butterworthQs, curvePoints, type CurveAnswer, type CurveCode, type CurvePoint, type CurveRequest, type CurveTerm, } from './curve.js';

package/dist/index.js

@@ -7,5 +7,7 @@
  */
 export { ANALYSIS_FLOOR_DB, dbToLinearGain, linearGainToDb, linearToDbFloored } from './units.js';
 export { biquadMagnitudeDb, clampEqQFor, lowpassHandover, magnitudeSumDb, matchedPair, octavesToQ, rbjSection, sectionMagnitudeDb, } from './eq.js';
-export { EQ_NOTCH_Q_RANGE, EQ_Q_RANGE, LOWPASS_HANDOVER, RTA_FFT_SIZE_MAX, RTA_TARGET_BIN_HZ } from './definitions.js';
+export { COMP_KNEE_DB_RANGE, COMP_RATIO_RANGE, CURVE_CODES, CURVE_DISPLAYS, CURVE_EXTENTS, CURVE_FAMILIES, CURVE_POINTS_MAX, CURVE_ROLES, CURVE_SHAPES, CURVE_UNITS, EQ_NOTCH_Q_RANGE, EQ_Q_RANGE, GATE_RANGE_DB_RANGE, GATE_RATIO_RANGE, LIN_TO_DB_FLOOR, LOWPASS_HANDOVER, RTA_FFT_SIZE_MAX, RTA_TARGET_BIN_HZ, } from './definitions.js';
 export { fftSizeForRate } from './rta.js';
+export { gaincompDb, gaincompDbShifted, gateKnee } from './gaincomp.js';
+export { CURVE_WORDS, butterworthQs, curvePoints, } from './curve.js';

package/oracle/ts-twin-oracle.c

@@ -34,6 +34,7 @@
 #include <omxdsp/mix/omx_pan_law.h>
 #include <omxdsp/omx_balance_law.h>
 #include <omxdsp/omx_contract.h>
+#include <omxdsp/omx_curve.h>
 #include <omxdsp/omx_dyn.h>
 #include <omxdsp/omx_eq_design.h>
 #include <omxdsp/omx_magnitude.h>
@@ -136,6 +137,64 @@ static int h_eq_magnitude_sum_db(const double *in, int n, double *out) {
   return 1;
 }
 
+/* curve_points: kind family rate points has_extents x_min x_max nterms { role index value unit shape }*nterms
+ *               -> code count { x y }*count (shape -1 for none; the enums are omx_curve.h's, by value) */
+static int h_curve_points(const double *in, int n, double *out) {
+  if (n < 8) return -1;
+  const int nt = (int)in[7];
+  if (nt < 0 || nt > 512 || n != 8 + 5 * nt) return -1;
+  static struct omx_curve_term terms[512];
+  for (int i = 0; i < nt; i++) {
+    const double *t = in + 8 + 5 * i;
+    terms[i].role = (enum omx_curve_roles)(int)t[0];
+    terms[i].index = (uint32_t)t[1];
+    terms[i].value = t[2];
+    terms[i].unit = (enum omx_curve_units)(int)t[3];
+    terms[i].shape = (int)t[4];
+  }
+  const struct omx_curve_request rq = {(enum omx_curve_displays)(int)in[0], (enum omx_curve_families)(int)in[1], in[2],
+                                       (uint32_t)in[3], in[4] != 0.0, in[5], in[6], terms, (uint32_t)nt};
+  double x[OMX_CURVE_POINTS_MAX], y[OMX_CURVE_POINTS_MAX];
+  int code = -1;
+  const uint32_t cnt = omx_curve_points(&rq, x, y, OMX_CURVE_POINTS_MAX, &code);
+  out[0] = code;
+  out[1] = cnt;
+  for (uint32_t i = 0; i < cnt; i++) {
+    out[2 + 2 * i] = x[i];
+    out[3 + 2 * i] = y[i];
+  }
+  return 2 + 2 * (int)cnt;
+}
+
+/* gaincomp_db: mode thresh_db ratio knee_db range_db level_db -> dB (float, the per-sample form) */
+static int h_gaincomp_db(const double *in, int n, double *out) {
+  if (n != 6) return -1;
+  const struct omx_gaincomp_params p = {(int)in[0], (float)in[1], (float)in[2], (float)in[3], (float)in[4], 1.0f};
+  out[0] = omx_gaincomp_db(&p, (float)in[5]);
+  return 1;
+}
+
+/* gaincomp_db_shifted: thresh_db ratio knee_db range_db shift_db level_db -> dB (float, BELOW mode) */
+static int h_gaincomp_db_shifted(const double *in, int n, double *out) {
+  if (n != 6) return -1;
+  const struct omx_gaincomp_params p = {OMX_DYN_BELOW, (float)in[0], (float)in[1], (float)in[2], (float)in[3], 1.0f};
+  out[0] = omx_gaincomp_db_shifted(&p, (float)in[4], (float)in[5]);
+  return 1;
+}
+
+/* gate_knee: thresh_db knee_start_db knee_end_db -> knee_db shift_db (float) */
+static int h_gate_knee(const double *in, int n, double *out) {
+  if (n != 3) return -1;
+  struct omx_dyn d;
+  memset(&d, 0, sizeof d);
+  d.gc.mode = OMX_DYN_BELOW;
+  d.gc.thresh_db = (float)in[0];
+  omx_gate_knee(&d, (float)in[1], (float)in[2]);
+  out[0] = d.gc.knee_db;
+  out[1] = d.knee_shift_db;
+  return 2;
+}
+
 /* hrp_cut_db: excess_db amount max_cut_db -> cut_db (float) */
 static int h_hrp_cut_db(const double *in, int n, double *out) {
   if (n != 3) return -1;
@@ -312,6 +371,10 @@ static const struct {
     {"eq_pass", h_eq_pass},
     {"eq_band_magnitude_db", h_eq_band_magnitude_db},
     {"eq_magnitude_sum_db", h_eq_magnitude_sum_db},
+    {"curve_points", h_curve_points},
+    {"gaincomp_db", h_gaincomp_db},
+    {"gaincomp_db_shifted", h_gaincomp_db_shifted},
+    {"gate_knee", h_gate_knee},
     {"hrp_cut_db", h_hrp_cut_db},
     {"hrp_resonance_score", h_hrp_resonance_score},
     {"hrp_cents_between", h_hrp_cents_between},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmixer/omx-dsp",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "description": "The TypeScript twins of omx-dsp kernels, each pinned to its C kernel by an agreement test, and the oracle that pins them",
   "type": "module",
   "license": "GPL-3.0-or-later",

package/src/curve.ts

@@ -0,0 +1,245 @@
+// 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_CODES,
+  CURVE_DISPLAYS,
+  CURVE_EXTENTS,
+  CURVE_FAMILIES,
+  CURVE_POINTS_MAX,
+  CURVE_ROLES,
+  CURVE_SHAPES,
+  CURVE_UNITS,
+  GATE_RANGE_DB_RANGE,
+  GATE_RATIO_RANGE,
+  LIN_TO_DB_FLOOR,
+} from './definitions.js';
+import { magnitudeSumDb, octavesToQ, type BiquadBand, type BiquadType } 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: string): string => (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),
+} as const;
+
+/** 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;
+}
+
+/** 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[];
+}
+
+/** 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[] } | { readonly code: CurveCode };
+
+/** The units each role converts from (omx_curve_unit_accepted). */
+const ACCEPTS: Readonly<Record<string, readonly string[]>> = {
+  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: number): number => {
+  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: CurveTerm): number => {
+  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: Readonly<Record<string, BiquadType>> = {
+  bell: 'bell', lowshelf: 'lowshelf', highshelf: 'highshelf', highpass: 'highpass', lowpass: 'lowpass', notch: 'notch',
+};
+
+/** 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: boolean): readonly number[] {
+  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: readonly BiquadBand[], fMin: number, fMax: number, points: number): number[] {
+  const g = Math.max(points, 2);
+  const out: number[] = [];
+  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: CurveRequest): CurveAnswer {
+  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))) return { code: 'unitRefused' };
+  let lo: number, hi: number;
+  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: string, index = 0): CurveTerm | undefined => {
+    let found: CurveTerm | undefined;
+    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);
+}
+
+type Find = (role: string, index?: number) => CurveTerm | undefined;
+
+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: CurveRequest, find: Find, lo: number, hi: number): CurveAnswer {
+  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: BiquadBand[] = [];
+  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' };
+    if (shape === 'off') continue;
+    const kind = SHAPE_TYPE[shape];
+    if (!kind) return { code: 'kindUnknown' };
+    if (!q) return { code: 'termMissing' };
+    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, q: valueOf(q) });
+  }
+  const pass: BiquadBand[] = [];
+  let present = false;
+  for (const [type, pre] of [['highpass', 'hpf'], ['lowpass', 'lpf']] as const) {
+    const fr = find(`${pre}_freq`), sl = find(`${pre}_slope`), on = find(`${pre}_on`);
+    if (!fr && !sl && !on) continue;
+    present = true;
+    if (!fr || !sl) 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 points = curveFreqs(drawn, lo, hi, rq.points).map((x) => ({
+    x,
+    y: magnitudeSumDb(drawn, x < top ? x : top, rq.sampleRate, CURVE_EXTENTS.eqFloorDb),
+  }));
+  return { points };
+}
+
+function transferPoints(rq: CurveRequest, find: Find, lo: number, hi: number): CurveAnswer {
+  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');
+  if (!thr || !ratio || (below && !range) || (below && !ks !== !ke)) return { code: 'termMissing' };
+  const f = Math.fround;
+  const r = f(valueOf(ratio)), 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' as const) : ('above' as const), threshDb: thresh, ratio: r < rmin ? rmin : r, kneeDb, rangeDb };
+  const mk = makeup ? valueOf(makeup) : 0;
+  const n = rq.points;
+  const points: CurvePoint[] = [];
+  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 { points };
+}

package/src/definitions.ts

@@ -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;
@@ -20,8 +20,57 @@ export const LOWPASS_HANDOVER = {
   hiAtPeakQ: 0.8,
 } as const;
 
+/** 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'] as const;
+
+/** 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'] as const;
+
+/** 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'] as const;
+
+/** 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'] as const;
+
+/** 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; `unshaped`, spelt `-` on the wire, a choice value with no closed form, which no curve is drawn from. The others design the band through omx_eq_design: a bell, the two shelves, the pass filters and the notch. @see data/primitives/curve.json */
+export const CURVE_SHAPES = ['off', 'bell', 'lowshelf', 'highshelf', 'highpass', 'lowpass', 'notch', 'unshaped'] as const;
+
+/** What omx_curve_points answers in its code: `ok`, a curve; `kindUnknown`, a kind, family, shape or slope with no closed form; `termMissing`, a term the model needs is not in the request (a band's frequency, shape and Q, a bell's or shelf's gain, a head filter's corner and slope; threshold and ratio for an ABOVE family; 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 for the points. No curve is drawn from a guess: a missing term is a code, never a default. @see data/primitives/curve.json */
+export const CURVE_CODES = ['ok', 'kindUnknown', 'termMissing', 'unitRefused', 'valueNotFinite', 'pointsRange', 'room'] as const;
+
+/** 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,
+} as const;
+
+/** 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,
+} as const;
+
 /** The Q (resonance) extent of a parametric band. @see data/kernels/eq.json */
 export const EQ_Q_RANGE = { min: 0.3, max: 8 } as const;
 
 /** 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 } as const;
+
+/** The travel of ratio, from its table COMP_LIMITS. @see data/kernels/comp.json */
+export const COMP_RATIO_RANGE = { min: 1, max: 20 } as const;
+
+/** The travel of kneeDb, from its table COMP_LIMITS. @see data/kernels/comp.json */
+export const COMP_KNEE_DB_RANGE = { min: 0, max: 24 } as const;
+
+/** The travel of ratio, from its table GATE_LIMITS. @see data/kernels/gate.json */
+export const GATE_RATIO_RANGE = { min: 1, max: 100 } as const;
+
+/** The travel of rangeDb, from its table GATE_LIMITS. @see data/kernels/gate.json */
+export const GATE_RANGE_DB_RANGE = { min: -90, max: 0 } as const;

package/src/gaincomp.ts

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * The gain computer twins: omx_gaincomp_db, omx_gaincomp_db_shifted and omx_gate_knee (omx_gaincomp.h, omx_gate.h),
+ * the static characteristic a dynamics curve draws. The kernel is float; each step here is rounded to float by
+ * Math.fround as the kernel rounds it (every operation is one IEEE single operation, and a double result rounded
+ * once to single is the single result for +, -, *, / and sqrt), so the twin is the kernel's value, bit for bit,
+ * where the kernel is built without contraction (-ffp-contract=off, as omxdsp.pc says). Pinned by
+ * test/agreement.test.mjs.
+ */
+
+const f = Math.fround;
+
+/** The gain computer's mode: act ABOVE the threshold (comp, limiter), BELOW it (gate, expander), or raise the
+ *  signal below it (UPWARD). omx_gaincomp.h's OMX_DYN_ABOVE, OMX_DYN_BELOW and OMX_DYN_UPWARD. */
+export type GaincompMode = 'above' | 'below' | 'upward';
+
+/** The gain computer's parameters, omx_gaincomp_params: each value is narrowed to float as the kernel stores it. */
+export interface GaincompParams {
+  readonly mode: GaincompMode;
+  /** The threshold, dB. */
+  readonly threshDb: number;
+  /** The ratio, at least the mode's minimum. */
+  readonly ratio: number;
+  /** The knee width, dB, not negative; 0 is a hard knee. */
+  readonly kneeDb: number;
+  /** BELOW: the attenuation floor, dB, at most 0. UPWARD: the largest boost, dB. Not read in ABOVE. */
+  readonly rangeDb: number;
+}
+
+/**
+ * The static gain, dB, at detector level `levelDb`: the twin of omx_gaincomp_db (its per-sample form).
+ * @param p The parameters.
+ * @param levelDb The detector level, dB; finite.
+ */
+export function gaincompDb(p: GaincompParams, levelDb: number): number {
+  const thresh = f(p.threshDb), ratio = f(p.ratio), knee = f(p.kneeDb), range = f(p.rangeDb);
+  const x = f(f(levelDb) - thresh);
+  const half = f(0.5 * knee);
+  const soft = knee > 0;
+  const k2 = soft ? f(2 * knee) : 1;
+  const eb = f(x - half);
+  const kb = f(f(f(f(1 - ratio) * eb) * eb) / k2);
+  let gb = soft && x > -half ? kb : f(f(ratio - 1) * x);
+  gb = x >= half ? 0 : gb;
+  gb = gb < range ? range : gb;
+  const slope = f(f(1 / ratio) - 1);
+  const ea = f(x + half);
+  const ka = f(f(f(slope * ea) * ea) / k2);
+  let ga = soft && x < half ? ka : f(slope * x);
+  ga = x <= -half ? 0 : ga;
+  const eu = f(half - x);
+  const ku = f(f(f(slope * eu) * eu) / k2);
+  let gu = soft && -x < half ? ku : f(slope * -x);
+  gu = -x <= -half ? 0 : -gu;
+  gu = gu > range ? range : gu;
+  return p.mode === 'below' ? gb : p.mode === 'upward' ? gu : ga;
+}
+
+/** The gate's off-centre knee, omx_gaincomp_knee_shifted: the quadratic Bezier between the expander's line and
+ *  0 dB at `x`, for `xl < x < xh`, every value already a float. */
+function kneeShifted(ratio: number, xl: number, xh: number, x: number): number {
+  const a = f(xl + xh), b = f(-2 * xl), d = f(x - xl);
+  const disc0 = f(f(b * b) + f(f(4 * a) * d));
+  const disc = disc0 > 0 ? disc0 : 0;
+  const den0 = f(b + f(Math.sqrt(disc)));
+  const den = den0 > 0 ? den0 : 1;
+  const u = f(f(2 * d) / den);
+  const w = f(1 - u);
+  return f(f(f(w * w) * f(ratio - 1)) * xl);
+}
+
+/**
+ * The BELOW static gain, dB, with the knee's centre moved `shiftDb` off the threshold: the twin of
+ * omx_gaincomp_db_shifted. A shift of 0 is {@link gaincompDb} itself.
+ * @param p The parameters, `mode` 'below'.
+ * @param shiftDb The knee centre's offset from the threshold, dB, inside half the knee.
+ * @param levelDb The detector level, dB; finite.
+ */
+export function gaincompDbShifted(p: GaincompParams, shiftDb: number, levelDb: number): number {
+  const shift = f(shiftDb);
+  if (shift === 0) return gaincompDb(p, levelDb);
+  const thresh = f(p.threshDb), ratio = f(p.ratio), range = f(p.rangeDb);
+  const half = f(0.5 * f(p.kneeDb));
+  const x = f(f(levelDb) - thresh);
+  const xl = f(shift - half), xh = f(shift + half);
+  let g: number;
+  if (x <= xl) g = f(f(ratio - 1) * x);
+  else if (x >= xh) g = 0;
+  else g = kneeShifted(ratio, xl, xh, x);
+  return g < range ? range : g;
+}
+
+/**
+ * The knee range of a gate as the kernel resolves it, omx_gate_knee: the width of the range and its centre's offset
+ * from the threshold, held inside half the width; equal ends are the hard knee wherever they sit.
+ * @param threshDb The threshold, dB.
+ * @param kneeStartDb One end of the range, dB.
+ * @param kneeEndDb The other end, dB.
+ */
+export function gateKnee(threshDb: number, kneeStartDb: number, kneeEndDb: number): { kneeDb: number; shiftDb: number } {
+  const s = f(kneeStartDb), e = f(kneeEndDb);
+  const lo = s < e ? s : e, hi = s < e ? e : s;
+  const width = f(hi - lo);
+  const half = f(0.5 * width);
+  let shift = width > 0 ? f(f(lo + half) - f(threshDb)) : 0;
+  shift = shift < -half ? -half : shift > half ? half : shift;
+  return { kneeDb: width, shiftDb: shift };
+}

package/src/index.ts

@@ -20,5 +20,35 @@ export {
   type BiquadSection,
   type BiquadType,
 } from './eq.js';
-export { EQ_NOTCH_Q_RANGE, EQ_Q_RANGE, LOWPASS_HANDOVER, RTA_FFT_SIZE_MAX, RTA_TARGET_BIN_HZ } from './definitions.js';
+export {
+  COMP_KNEE_DB_RANGE,
+  COMP_RATIO_RANGE,
+  CURVE_CODES,
+  CURVE_DISPLAYS,
+  CURVE_EXTENTS,
+  CURVE_FAMILIES,
+  CURVE_POINTS_MAX,
+  CURVE_ROLES,
+  CURVE_SHAPES,
+  CURVE_UNITS,
+  EQ_NOTCH_Q_RANGE,
+  EQ_Q_RANGE,
+  GATE_RANGE_DB_RANGE,
+  GATE_RATIO_RANGE,
+  LIN_TO_DB_FLOOR,
+  LOWPASS_HANDOVER,
+  RTA_FFT_SIZE_MAX,
+  RTA_TARGET_BIN_HZ,
+} from './definitions.js';
 export { fftSizeForRate } from './rta.js';
+export { gaincompDb, gaincompDbShifted, gateKnee, type GaincompMode, type GaincompParams } from './gaincomp.js';
+export {
+  CURVE_WORDS,
+  butterworthQs,
+  curvePoints,
+  type CurveAnswer,
+  type CurveCode,
+  type CurvePoint,
+  type CurveRequest,
+  type CurveTerm,
+} from './curve.js';