@openmixer/omx-dsp 0.31.0 → 0.32.1

package/oracle/ts-twin-oracle.c

@@ -31,6 +31,7 @@
 #include <omxdsp/analysis/omx_room.h>
 #include <omxdsp/analysis/omx_rta.h>
 #include <omxdsp/fx/omx_eq_instance.h>
+#include <omxdsp/mix/omx_meter_view.h>
 #include <omxdsp/mix/omx_pan_law.h>
 #include <omxdsp/omx_balance_law.h>
 #include <omxdsp/omx_contract.h>
@@ -151,9 +152,10 @@ static int h_curve_points(const double *in, int n, double *out) {
     terms[i].value = t[2];
     terms[i].unit = (enum omx_curve_units)(int)t[3];
     terms[i].shape = (int)t[4];
+    terms[i].origin = OMX_CURVE_ORIGINS_USER;
   }
   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};
+                                       (uint32_t)in[3], in[4] != 0.0, in[5], in[6], terms, (uint32_t)nt, 0};
   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);
@@ -166,6 +168,49 @@ static int h_curve_points(const double *in, int n, double *out) {
   return 2 + 2 * (int)cnt;
 }
 
+/* curve_points_marked: kind family rate points has_extents x_min x_max user_only nterms
+ *                      { role index value unit shape origin }*nterms
+ *                      -> code count { x y }*count nmarks { freq depth_db q origin }*nmarks [{ y_user }*count] */
+static int h_curve_points_marked(const double *in, int n, double *out) {
+  if (n < 9) return -1;
+  const int nt = (int)in[8];
+  if (nt < 0 || nt > 512 || n != 9 + 6 * nt) return -1;
+  static struct omx_curve_term terms[512];
+  for (int i = 0; i < nt; i++) {
+    const double *t = in + 9 + 6 * 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];
+    terms[i].origin = (enum omx_curve_origins)(int)t[5];
+  }
+  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, in[7] != 0.0};
+  double x[OMX_CURVE_POINTS_MAX], y[OMX_CURVE_POINTS_MAX], yu[OMX_CURVE_POINTS_MAX];
+  struct omx_curve_mark marks[OMX_CURVE_BANDS_MAX];
+  struct omx_curve_extra ex = {yu, marks, OMX_CURVE_BANDS_MAX, 0u};
+  int code = -1;
+  const uint32_t cnt = omx_curve_points_marked(&rq, x, y, OMX_CURVE_POINTS_MAX, &ex, &code);
+  int k = 0;
+  out[k++] = code;
+  out[k++] = cnt;
+  for (uint32_t i = 0; i < cnt; i++) {
+    out[k++] = x[i];
+    out[k++] = y[i];
+  }
+  out[k++] = cnt ? ex.nmarks : 0;
+  for (uint32_t i = 0; cnt && i < ex.nmarks; i++) {
+    out[k++] = marks[i].freq_hz;
+    out[k++] = marks[i].depth_db;
+    out[k++] = marks[i].q;
+    out[k++] = marks[i].origin;
+  }
+  if (cnt && rq.user_only)
+    for (uint32_t i = 0; i < cnt; i++) out[k++] = yu[i];
+  return k;
+}
+
 /* 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;
@@ -359,6 +404,86 @@ static int h_room_mode_set_stable(const double *in, int n, double *out) {
   return 1;
 }
 
+/* meter_view_fill_db: db floor_db -> fill */
+static int h_meter_view_fill_db(const double *in, int n, double *out) {
+  if (n != 2) return -1;
+  out[0] = omx_meter_view_fill_db(in[0], in[1]);
+  return 1;
+}
+
+/* meter_view_fill: level floor_db -> fill */
+static int h_meter_view_fill(const double *in, int n, double *out) {
+  if (n != 2) return -1;
+  out[0] = omx_meter_view_fill(in[0], in[1]);
+  return 1;
+}
+
+/* meter_view_step: fall_db_per_s floor_db { fill dt_s }*k -> the marker at each tick, from a fresh view */
+static int h_meter_view_step(const double *in, int n, double *out) {
+  if (n < 2 || (n - 2) % 2 != 0) return -1;
+  struct omx_meter_view v = {0};
+  const int k = (n - 2) / 2;
+  for (int i = 0; i < k; i++) out[i] = omx_meter_view_step(&v, in[2 + 2 * i], in[3 + 2 * i], in[0], in[1]);
+  return k;
+}
+
+/* meter_view_clip: { clip clear }*k -> the clip word at each tick (a clear is taken before the tick's clip) */
+static int h_meter_view_clip(const double *in, int n, double *out) {
+  if (n % 2 != 0) return -1;
+  struct omx_meter_view v = {0};
+  for (int i = 0; i < n / 2; i++) {
+    if (in[2 * i + 1] != 0.0) omx_meter_view_clip_clear(&v);
+    out[i] = omx_meter_view_clip(&v, in[2 * i] != 0.0);
+  }
+  return n / 2;
+}
+
+/* meter_view_ladder: steps hysteresis prev fill -> count (prev negative: none) */
+static int h_meter_view_ladder(const double *in, int n, double *out) {
+  if (n != 4) return -1;
+  out[0] = omx_meter_view_ladder((int32_t)in[2], in[3], (uint32_t)in[0], in[1]);
+  return 1;
+}
+
+/* meter_view_bar_step: steps prev level -> count */
+static int h_meter_view_bar_step(const double *in, int n, double *out) {
+  if (n != 3) return -1;
+  out[0] = omx_meter_view_bar_step((int32_t)in[1], in[2], (uint32_t)in[0]);
+  return 1;
+}
+
+/* meter_view_decimate: kind kept value -> kept */
+static int h_meter_view_decimate(const double *in, int n, double *out) {
+  if (n != 3) return -1;
+  out[0] = omx_meter_view_decimate((enum omx_meter_kinds)(int)in[0], in[1], in[2]);
+  return 1;
+}
+
+/* meter_view_gr: rate pole { deepest_db dt_s }*k -> the reading at each tick, from no reduction */
+static int h_meter_view_gr(const double *in, int n, double *out) {
+  if (n < 2 || (n - 2) % 2 != 0) return -1;
+  struct omx_meter_gr m = {0.0f, 0.0f};
+  const int k = (n - 2) / 2;
+  for (int i = 0; i < k; i++)
+    out[i] = (double)omx_meter_view_gr(&m, (float)in[2 + 2 * i], in[3 + 2 * i], (float)in[0], (float)in[1]);
+  return k;
+}
+
+/* meter_view_unit_of: kind measurement -> unit (METER_UNITS position; the count for none) */
+static int h_meter_view_unit_of(const double *in, int n, double *out) {
+  if (n != 2) return -1;
+  out[0] = (double)omx_meter_view_unit_of((enum omx_meter_kinds)(int)in[0], (enum omx_meter_measurements)(int)in[1]);
+  return 1;
+}
+
+/* meter_gr_hold_ms: -> OMX_METER_GR_HOLD_MS */
+static int h_meter_gr_hold_ms(const double *in, int n, double *out) {
+  (void)in;
+  if (n != 0) return -1;
+  out[0] = (double)OMX_METER_GR_HOLD_MS;
+  return 1;
+}
+
 static const struct {
   const char *name;
   handler fn;
@@ -372,6 +497,7 @@ static const struct {
     {"eq_band_magnitude_db", h_eq_band_magnitude_db},
     {"eq_magnitude_sum_db", h_eq_magnitude_sum_db},
     {"curve_points", h_curve_points},
+    {"curve_points_marked", h_curve_points_marked},
     {"gaincomp_db", h_gaincomp_db},
     {"gaincomp_db_shifted", h_gaincomp_db_shifted},
     {"gate_knee", h_gate_knee},
@@ -390,6 +516,16 @@ static const struct {
     {"room_mode_eq_proposals", h_room_mode_eq_proposals},
     {"room_mode_residual_db", h_room_mode_residual_db},
     {"room_mode_set_stable", h_room_mode_set_stable},
+    {"meter_view_fill_db", h_meter_view_fill_db},
+    {"meter_view_fill", h_meter_view_fill},
+    {"meter_view_step", h_meter_view_step},
+    {"meter_view_clip", h_meter_view_clip},
+    {"meter_view_ladder", h_meter_view_ladder},
+    {"meter_view_bar_step", h_meter_view_bar_step},
+    {"meter_view_decimate", h_meter_view_decimate},
+    {"meter_view_gr", h_meter_view_gr},
+    {"meter_view_unit_of", h_meter_view_unit_of},
+    {"meter_gr_hold_ms", h_meter_gr_hold_ms},
 };
 
 /* The kernels the table answers, for a test that asks "is the oracle really here". */

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@openmixer/omx-dsp",
-  "version": "0.31.0",
+  "version": "0.32.1",
   "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",
   "author": "Pau Aliagas <linuxnow@gmail.com>",
-  "homepage": "https://github.com/FreeMixer/omx-dsp",
+  "homepage": "https://github.com/Open-Mixer/omx-dsp",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/FreeMixer/omx-dsp.git",
+    "url": "git+https://github.com/Open-Mixer/omx-dsp.git",
     "directory": "ts"
   },
   "exports": {

package/src/curve.ts

@@ -13,15 +13,17 @@ import {
   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 { magnitudeSumDb, octavesToQ, type BiquadBand, type BiquadType } from './eq.js';
+import { clampEqQFor, 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 `-`. */
@@ -34,6 +36,8 @@ export const CURVE_WORDS = {
   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()}`)),
 } as const;
 
 /** What curvePoints answers when it draws nothing: a CURVE_CODES id other than `ok`. */
@@ -51,6 +55,8 @@ export interface CurveTerm {
   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. */
@@ -67,6 +73,16 @@ export interface CurveRequest {
   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. */
@@ -76,7 +92,15 @@ export interface CurvePoint {
 }
 
 /** 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 };
+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 units each role converts from (omx_curve_unit_accepted). */
 const ACCEPTS: Readonly<Record<string, readonly string[]>> = {
@@ -108,6 +132,7 @@ const valueOf = (t: CurveTerm): number => {
 
 const SHAPE_TYPE: Readonly<Record<string, BiquadType>> = {
   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
@@ -148,7 +173,8 @@ export function curvePoints(rq: CurveRequest): CurveAnswer {
   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' };
+  if (rq.terms.some((t) => !ACCEPTS[t.role]?.includes(t.unit) || !CURVE_WORDS.origins.includes(t.origin ?? 'user')))
+    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)];
@@ -176,20 +202,22 @@ function eqPoints(rq: CurveRequest, find: Find, lo: number, hi: number): CurveAn
     nb = Math.max(nb, i + 1);
   }
   const bands: BiquadBand[] = [];
+  const origin: string[] = [];
   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' };
+    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, q: valueOf(q) });
+    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: BiquadBand[] = [];
   let present = false;
@@ -197,7 +225,8 @@ function eqPoints(rq: CurveRequest, find: Find, lo: number, hi: number): CurveAn
     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' };
+    // 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;
@@ -208,20 +237,25 @@ function eqPoints(rq: CurveRequest, find: Find, lo: number, hi: number): CurveAn
   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 };
+  const xs = curveFreqs(drawn, lo, hi, rq.points);
+  const sum = (set: readonly BiquadBand[]) =>
+    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: 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' };
+  // 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 = f(valueOf(ratio)), k = knee ? f(valueOf(knee)) : 0;
+  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;
@@ -241,5 +275,5 @@ function transferPoints(rq: CurveRequest, find: Find, lo: number, hi: number): C
     const g = below ? gaincompDbShifted(p, shiftDb, lv) : gaincompDb(p, lv);
     points.push({ x: lv, y: lv + g + mk });
   }
-  return { points };
+  return rq.userOnly ? { points, marks: [], userPoints: points } : { points, marks: [] };
 }

package/src/definitions.ts

@@ -20,6 +20,66 @@ export const LOWPASS_HANDOVER = {
   hiAtPeakQ: 0.8,
 } as const;
 
+/** 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,
+} as const;
+
+/** 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'] as const;
 
@@ -32,10 +92,13 @@ export const CURVE_ROLES = ['bandType', 'bandFreq', 'bandGain', 'bandQ', 'bandOn
 /** 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;
+/** 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'] 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 */
+/** 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'] as const;
+
+/** 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'] 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 */
@@ -57,12 +120,54 @@ export const LIN_TO_DB_FLOOR = {
   db: -180,
 } as const;
 
+/** 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,
+} as const;
+
+/** 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'] as const;
+
+/** 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'] as const;
+
+/** 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'] as const;
+
+/** The labels of METER_UNITS, in its order. @see data/primitives/meter.json */
+export const METER_UNITS_LABELS = ['dBFS', 'dBTP', 'LUFS', 'LU', 'dB'] as const;
+
+/** 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'] 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 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 } as const;
+
+/** The frequency band a parametric band can be dragged across. @see data/kernels/eq.json */
+export const EQ_FREQ_RANGE = { min: 20, max: 20000 } as const;
+
+/** 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 } as const;
+
+/** 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 } as const;
+
+/** The merge radius, in cents. An integer control. @see data/kernels/fbs.json */
+export const FBS_MERGE_RANGE = { min: 0, max: 600 } as const;
+
+/** 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 } 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;