@openmixer/omx-dsp 0.32.0 → 0.32.2

package/dist/definitions.d.ts

@@ -2,6 +2,30 @@
 export declare 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 */
 export declare const RTA_FFT_SIZE_MAX = 32768;
+/** The lowest frequency any spectrum band covers; below it is infrasonic and not drawn. (Hz) @see data/kernels/rta.json */
+export declare const RTA_BAND_F_MIN = 20;
+/** The highest frequency any spectrum band covers, before the Nyquist clamp (omx_rta_band_f_max). (Hz) @see data/kernels/rta.json */
+export declare const RTA_BAND_F_MAX_CAP = 20000;
+/** A band centred below this samples the LOW (decimated) tier when the reading carries one; at or above it, the HIGH tier. Where the high tier's ~5.86 Hz bins still give ~51 bins per octave, above the finest panel's density. (Hz) @see data/kernels/rta.json */
+export declare const RTA_TIER_CROSSOVER_HZ = 300;
+/** Quiet gate of the band reduction: when no band rises above this, every band reads as silence, so a rig's idle floor never draws as a flat block. Keyed on the loudest band, not per band. (dB) @see data/kernels/rta.json */
+export declare const RTA_BAND_GATE_DB = -60;
+/** Quiet gate of a tap's raw spectrum, before any banding: when no bin rises above this the whole tap reads as the floor. The console's overlay frame applies it; a banded reading is gated by RTA_BAND_GATE_DB instead. (dB) @see data/kernels/rta.json */
+export declare const RTA_TAP_GATE_DB = -60;
+/** The floor of a spectrum display's level window: the bottom of the frame, every surface. (dB) @see data/kernels/rta.json */
+export declare const RTA_LEVEL_DB_MIN = -72;
+/** The ceiling of a spectrum display's level window: the top of the frame, where a band's peak reaching it draws a clip tick. (dB) @see data/kernels/rta.json */
+export declare const RTA_LEVEL_DB_MAX = 0;
+/** The spacing of a spectrum display's one dB graticule, from the ceiling down to the floor. (dB) @see data/kernels/rta.json */
+export declare const RTA_LEVEL_GRID_DB = 12;
+/** How often a watched spectrum is read and published: an operator-cadence poll, never the audio thread. (Hz) @see data/kernels/rta.json */
+export declare const RTA_HZ = 10;
+/** How far the low zoom's window must have advanced, as a fraction of that window, before it is recomputed; between recomputes the last zoom rides the fresh main spectrum unchanged. @see data/kernels/rta.json */
+export declare const RTA_LOW_ADVANCE = 0.25;
+/** The frequencies of a spectrum display's labelled vertical graticule lines, Hz, on the log frequency axis: the decades and their 2 and 5 steps from 20 Hz to 20 kHz, every surface. (Hz) @see data/kernels/rta.json */
+export declare const RTA_GRID_FREQS: readonly number[];
+/** The smallest difference between two taps of a spectrum, POST - PRE in dB, that draws a wedge: a pair of neighbouring bands is a wedge when either band's difference reaches it. The console's overlay held it as 0.004 of its 100 dB span. (dB) @see data/kernels/rta.json */
+export declare const RTA_DELTA_DEADBAND_DB = 0.4;
 /** Where the low-pass section hands its poles over from the matched pair to the prewarped bilinear pair, as fractions of Nyquist, and how that band moves with Q. At `qHi` (1/sqrt(2), the 12 dB Butterworth) the band runs from `loAtHiQ` to `hiAtHiQ`; at `qLo` (0.5412, the low-Q half of the 24 dB Butterworth) and below, from `loAtLoQ` to `hiAtLoQ`; between the two it moves linearly. Above `qHi` the prototype peaks, and the band's end moves down to `hiAtPeakQ` by `qPeak`, held above it. Below the band the low-pass is the matched design unchanged. @see data/kernels/eq.json */
 export declare const LOWPASS_HANDOVER: {
     readonly qHi: 0.7071067811865476;
@@ -54,6 +78,8 @@ export declare const FBS_DEFAULT_COOLDOWN_SECONDS = 600;
 export declare const FBS_DEFAULT_NOTCH_Q = 116;
 /** Released finds the ring memory holds at once. The console's list is unbounded and expires by FBS_DEFAULT_COOLDOWN_SECONDS; a full memory here forgets its oldest entry first, and counts it. @see data/kernels/fbs.json */
 export declare const FBS_RING_MEMORY_SLOTS = 32;
+/** How far ONE reconcile pass may move an HRP band's gain, in dB — the gain smoothing, done at the control level because the native cascade applies pushed coefficients verbatim and the design forbids interpolating there. An unbounded gain step is a waveform discontinuity — the click heard when a correction entered or left at full depth (found live, 2026-08-20, the evening increment 9 raised the enter/leave rate). Bounded, a correction ENTERS by deepening from silence and LEAVES by walking to exactly 0 dB — the provable parked identity (`eqBandIsIdentity`) — from which removal is bit-identical. Two decibels per pass at the corrector's 10 Hz cadence walks the full HRP_MAX_CUT_DB travel in ~300 ms: the same order as the tracker's stability hold and FBS's lift steps, while each individual move stays below audibility on a Q-5 bell. (dB) @see data/kernels/hrp.json */
+export declare const HRP_GAIN_STEP_DB = 2;
 /** 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 */

package/dist/definitions.js

@@ -5,6 +5,30 @@
 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 */
 export const RTA_FFT_SIZE_MAX = 32768;
+/** The lowest frequency any spectrum band covers; below it is infrasonic and not drawn. (Hz) @see data/kernels/rta.json */
+export const RTA_BAND_F_MIN = 20;
+/** The highest frequency any spectrum band covers, before the Nyquist clamp (omx_rta_band_f_max). (Hz) @see data/kernels/rta.json */
+export const RTA_BAND_F_MAX_CAP = 20000;
+/** A band centred below this samples the LOW (decimated) tier when the reading carries one; at or above it, the HIGH tier. Where the high tier's ~5.86 Hz bins still give ~51 bins per octave, above the finest panel's density. (Hz) @see data/kernels/rta.json */
+export const RTA_TIER_CROSSOVER_HZ = 300;
+/** Quiet gate of the band reduction: when no band rises above this, every band reads as silence, so a rig's idle floor never draws as a flat block. Keyed on the loudest band, not per band. (dB) @see data/kernels/rta.json */
+export const RTA_BAND_GATE_DB = -60;
+/** Quiet gate of a tap's raw spectrum, before any banding: when no bin rises above this the whole tap reads as the floor. The console's overlay frame applies it; a banded reading is gated by RTA_BAND_GATE_DB instead. (dB) @see data/kernels/rta.json */
+export const RTA_TAP_GATE_DB = -60;
+/** The floor of a spectrum display's level window: the bottom of the frame, every surface. (dB) @see data/kernels/rta.json */
+export const RTA_LEVEL_DB_MIN = -72;
+/** The ceiling of a spectrum display's level window: the top of the frame, where a band's peak reaching it draws a clip tick. (dB) @see data/kernels/rta.json */
+export const RTA_LEVEL_DB_MAX = 0;
+/** The spacing of a spectrum display's one dB graticule, from the ceiling down to the floor. (dB) @see data/kernels/rta.json */
+export const RTA_LEVEL_GRID_DB = 12;
+/** How often a watched spectrum is read and published: an operator-cadence poll, never the audio thread. (Hz) @see data/kernels/rta.json */
+export const RTA_HZ = 10;
+/** How far the low zoom's window must have advanced, as a fraction of that window, before it is recomputed; between recomputes the last zoom rides the fresh main spectrum unchanged. @see data/kernels/rta.json */
+export const RTA_LOW_ADVANCE = 0.25;
+/** The frequencies of a spectrum display's labelled vertical graticule lines, Hz, on the log frequency axis: the decades and their 2 and 5 steps from 20 Hz to 20 kHz, every surface. (Hz) @see data/kernels/rta.json */
+export const RTA_GRID_FREQS = [20, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000];
+/** The smallest difference between two taps of a spectrum, POST - PRE in dB, that draws a wedge: a pair of neighbouring bands is a wedge when either band's difference reaches it. The console's overlay held it as 0.004 of its 100 dB span. (dB) @see data/kernels/rta.json */
+export const RTA_DELTA_DEADBAND_DB = 0.4;
 /** Where the low-pass section hands its poles over from the matched pair to the prewarped bilinear pair, as fractions of Nyquist, and how that band moves with Q. At `qHi` (1/sqrt(2), the 12 dB Butterworth) the band runs from `loAtHiQ` to `hiAtHiQ`; at `qLo` (0.5412, the low-Q half of the 24 dB Butterworth) and below, from `loAtLoQ` to `hiAtLoQ`; between the two it moves linearly. Above `qHi` the prototype peaks, and the band's end moves down to `hiAtPeakQ` by `qPeak`, held above it. Below the band the low-pass is the matched design unchanged. @see data/kernels/eq.json */
 export const LOWPASS_HANDOVER = {
     qHi: 0.7071067811865476,
@@ -57,6 +81,8 @@ export const FBS_DEFAULT_COOLDOWN_SECONDS = 600;
 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;
+/** How far ONE reconcile pass may move an HRP band's gain, in dB — the gain smoothing, done at the control level because the native cascade applies pushed coefficients verbatim and the design forbids interpolating there. An unbounded gain step is a waveform discontinuity — the click heard when a correction entered or left at full depth (found live, 2026-08-20, the evening increment 9 raised the enter/leave rate). Bounded, a correction ENTERS by deepening from silence and LEAVES by walking to exactly 0 dB — the provable parked identity (`eqBandIsIdentity`) — from which removal is bit-identical. Two decibels per pass at the corrector's 10 Hz cadence walks the full HRP_MAX_CUT_DB travel in ~300 ms: the same order as the tracker's stability hold and FBS's lift steps, while each individual move stays below audibility on a Q-5 bell. (dB) @see data/kernels/hrp.json */
+export const HRP_GAIN_STEP_DB = 2;
 /** 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 */

package/dist/fbs-place.d.ts

@@ -63,6 +63,8 @@ interface Slot {
         dueMs: number;
         seq: number;
     } | null;
+    /** Seated or re-tagged live, adopted at the next tick. */
+    adopt: boolean;
 }
 /** The gain a band of `origin` may hold: fbs-* in [FBS_MAX_CUT_DB, 0] (NaN reads 0), every other origin in
  * EQ_GAIN_RANGE (NaN stays NaN) — the strip store's arm. */
@@ -81,6 +83,8 @@ export declare class FbsPlace {
     cooldownS: number;
     nowMs: number;
     memoryDropped: number;
+    /** Bands the strip's EQ holds that are not the placement's. */
+    others: number;
     protected slots: Slot[];
     protected memory: Array<{
         freqHz: number;
@@ -101,6 +105,14 @@ export declare class FbsPlace {
     advance(nowMs: number): void;
     /** One detector tick: the ramp steps due, a band per newly confirmed ring, then the clean holds. */
     tick(nowMs: number, snapshotHz: readonly number[], confirmed: readonly FbsFind[]): void;
+    /** How many bands the strip's EQ holds that the placement does not own (omx_fbs_place_set_others). */
+    setOthers(n: number): void;
+    /** The band in slot k left the EQ: the slot frees, nothing said or remembered (omx_fbs_place_remove). */
+    remove(k: number): boolean;
+    /** The operator re-tagged or re-gained slot k's band (omx_fbs_place_edit). */
+    edit(k: number, originIndex: number, gainDb: number): boolean;
+    /** A band the EQ already holds, seated in the lowest free slot (omx_fbs_place_seat); the slot, or -1. */
+    seat(originIndex: number, freqHz: number, gainDb: number, q: number): number;
     /** One find or another: the same-ring window, or the merge radius in cents (band first, find second). */
     protected sameRegion(bandHz: number, findHz: number): boolean;
     /** The pool a find goes to. */
@@ -115,6 +127,16 @@ export declare class FbsPlace {
     /** Occupied slots in plant order: the console's band order. */
     protected bySeq(): number[];
     protected correct(c: FbsFind): void;
+    /** The EQ's other bands, as the shared cap counts them. */
+    protected othersCounted(): number;
+    /** Every band seated or re-tagged live and not yet tracked, in band order: a fresh hold and its ring memory. */
+    protected adopt(): void;
+    /** The fixed pool never lifts: a band re-tagged fixed leaves the release ladder where the edit left it. */
+    protected leaveLadder(k: number): void;
+    /** Whether a pending band is adopted: only one whose origin is fbs-live at the tick. */
+    protected adoptsOrigin(originIndex: number): boolean;
+    /** The clock an adopted band's hold starts from. */
+    protected adoptClock(): number;
     protected holdSweep(snapshotHz: readonly number[]): void;
     protected reArm(k: number): void;
     protected beginStage(k: number, stage: number): void;

package/dist/fbs-place.js

@@ -27,7 +27,7 @@ export const SHAPE = { off: shape('off'), bell: shape('bell'), notch: shape('not
 export const FBS_PLACE_SLOTS = FBS_BANDS_RANGE.max;
 const freeSlot = () => ({
     freqHz: 0, gainDb: 0, q: 0, on: false, origin: ORIGIN.user, shape: SHAPE.off, seq: 0,
-    live: false, plantedDb: 0, lastRingMs: 0, stage: 0, dwellStartMs: null, reclamps: 0, ramp: null,
+    live: false, plantedDb: 0, lastRingMs: 0, stage: 0, dwellStartMs: null, reclamps: 0, ramp: null, adopt: false,
 });
 /** `n < lo ? lo : n > hi ? hi : n`: core's clamp, a NaN passing through. */
 const clamp = (n, lo, hi) => (n < lo ? lo : n > hi ? hi : n);
@@ -65,6 +65,8 @@ export class FbsPlace {
     cooldownS = FBS_DEFAULT_COOLDOWN_SECONDS;
     nowMs = 0;
     memoryDropped = 0;
+    /** Bands the strip's EQ holds that are not the placement's. */
+    others = 0;
     slots = Array.from({ length: FBS_PLACE_SLOTS }, freeSlot);
     memory = [];
     seq = 0;
@@ -115,10 +117,61 @@ export class FbsPlace {
     /** One detector tick: the ramp steps due, a band per newly confirmed ring, then the clean holds. */
     tick(nowMs, snapshotHz, confirmed) {
         this.advance(nowMs);
+        this.adopt();
         for (const c of confirmed)
             this.correct(c);
         this.holdSweep(snapshotHz);
     }
+    /** How many bands the strip's EQ holds that the placement does not own (omx_fbs_place_set_others). */
+    setOthers(n) {
+        this.others = n;
+    }
+    /** The band in slot k left the EQ: the slot frees, nothing said or remembered (omx_fbs_place_remove). */
+    remove(k) {
+        const s = this.slots[k];
+        if (!s || s.origin === ORIGIN.user)
+            return false;
+        this.release(k);
+        return true;
+    }
+    /** The operator re-tagged or re-gained slot k's band (omx_fbs_place_edit). */
+    edit(k, originIndex, gainDb) {
+        const s = this.slots[k];
+        if (!s || s.origin === ORIGIN.user || originIndex < 0 || originIndex >= ORIGIN_WORDS.length)
+            return false;
+        if (originIndex !== ORIGIN.fbsFixed && originIndex !== ORIGIN.fbsLive)
+            return this.remove(k);
+        s.origin = originIndex;
+        s.gainDb = this.capGain(originIndex, gainDb);
+        if (originIndex === ORIGIN.fbsLive && !s.live)
+            s.adopt = true;
+        if (originIndex === ORIGIN.fbsFixed)
+            this.leaveLadder(k);
+        return true;
+    }
+    /** A band the EQ already holds, seated in the lowest free slot (omx_fbs_place_seat); the slot, or -1. */
+    seat(originIndex, freqHz, gainDb, q) {
+        if (originIndex !== ORIGIN.fbsFixed && originIndex !== ORIGIN.fbsLive)
+            return -1;
+        if (!Number.isFinite(freqHz) || !Number.isFinite(gainDb) || !Number.isFinite(q))
+            return -1;
+        const k = this.slots.findIndex((x) => x.origin === ORIGIN.user);
+        if (k < 0)
+            return -1;
+        const fixed = originIndex === ORIGIN.fbsFixed;
+        const s = freeSlot();
+        s.origin = originIndex;
+        s.freqHz = clamp(freqHz, EQ_FREQ_RANGE.min, EQ_FREQ_RANGE.max);
+        s.shape = fixed ? SHAPE.notch : SHAPE.bell;
+        s.gainDb = this.capGain(originIndex, gainDb);
+        s.q = fixed ? clamp(q, EQ_NOTCH_Q_RANGE.min, EQ_NOTCH_Q_RANGE.max) : clamp(q, EQ_Q_RANGE.min, EQ_Q_RANGE.max);
+        s.on = true;
+        s.seq = ++this.seq;
+        s.plantedDb = s.gainDb;
+        s.adopt = !fixed;
+        this.slots[k] = s;
+        return k;
+    }
     // ---- the rules, one method each ----------------------------------------------------------------------------
     /** One find or another: the same-ring window, or the merge radius in cents (band first, find second). */
     sameRegion(bandHz, findHz) {
@@ -166,6 +219,9 @@ export class FbsPlace {
             this.emit('pool-full', c.freqHz, -1);
             return;
         }
+        // the strip's EQ is full (FBS_PLACE_SLOTS is the EQ's band count): its store refuses, and nothing is said
+        if (this.count() + this.othersCounted() >= FBS_PLACE_SLOTS)
+            return;
         const k = this.slots.findIndex((s) => s.origin === ORIGIN.user);
         if (k < 0)
             return;
@@ -188,6 +244,44 @@ export class FbsPlace {
         s.reclamps = fixed ? 0 : this.takeMemory(s.freqHz);
         this.emit('notched', c.freqHz, k);
     }
+    /** The EQ's other bands, as the shared cap counts them. */
+    othersCounted() {
+        return this.others;
+    }
+    /** Every band seated or re-tagged live and not yet tracked, in band order: a fresh hold and its ring memory. */
+    adopt() {
+        for (const k of this.bySeq()) {
+            const s = this.slots[k];
+            if (!s.adopt)
+                continue;
+            s.adopt = false;
+            if (!this.adoptsOrigin(s.origin))
+                continue;
+            s.live = true;
+            s.plantedDb = s.gainDb;
+            s.lastRingMs = this.adoptClock();
+            s.stage = 0;
+            s.dwellStartMs = null;
+            s.ramp = null;
+            s.reclamps = this.takeMemory(s.freqHz);
+        }
+    }
+    /** The fixed pool never lifts: a band re-tagged fixed leaves the release ladder where the edit left it. */
+    leaveLadder(k) {
+        const s = this.slots[k];
+        s.live = false;
+        s.ramp = null;
+        s.stage = 0;
+        s.dwellStartMs = null;
+    }
+    /** Whether a pending band is adopted: only one whose origin is fbs-live at the tick. */
+    adoptsOrigin(originIndex) {
+        return originIndex === ORIGIN.fbsLive;
+    }
+    /** The clock an adopted band's hold starts from. */
+    adoptClock() {
+        return this.nowMs;
+    }
     holdSweep(snapshotHz) {
         for (const k of this.bySeq()) {
             const s = this.slots[k];

package/dist/hrp-place.d.ts

@@ -0,0 +1,22 @@
+/** The authority one placement is given, by the caller. */
+export interface HrpPlaceLimits {
+    /** The largest cut, a positive magnitude. */
+    readonly maxCutDb: number;
+    /** The largest boost, a positive magnitude (0: cuts only). */
+    readonly maxBoostDb: number;
+    /** How many bands may be placed (a free-slot count). */
+    readonly maxBands: number;
+}
+/** One placed band: a bell at freqHz, gainDb (negative is a cut), q, for one harmonic (1 is the fundamental). */
+export interface HrpPlacedBand {
+    readonly harmonic: number;
+    readonly freqHz: number;
+    readonly gainDb: number;
+    readonly q: number;
+}
+/** The bands one voice's per-harmonic gains become (`gainsDb[k]` is harmonic k+1), in harmonic order. */
+export declare function hrpPlaceBands(f0Hz: number, gainsDb: readonly number[], q: number, limits: HrpPlaceLimits): HrpPlacedBand[];
+/** Is a band at freqHz placeable (inside EQ_FREQ_RANGE, both bounds kept)? A NaN is not. */
+export declare function hrpPlaceInRange(freqHz: number): boolean;
+/** One bounded move of `current` toward `target`, never further than HRP_GAIN_STEP_DB. */
+export declare function hrpStepToward(current: number, target: number): number;

package/dist/hrp-place.js

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * The twin of omx_hrp_place.h (src/omx_hrp_place.c): the harmonic resonance processor's placement and stepping.
+ * The C placement and this one read the same vector file (test/analysis/fixtures/hrp_place.vectors) in
+ * test/analysis/hrp_place.test.c and test/hrp-place.test.mjs, so the two are held to the same values, exactly.
+ *
+ * The rules are the header's, one function each, in the same order and arithmetic: the console's harmonicBands
+ * and the HRP planter's stepToward, term for term.
+ */
+import { EQ_FREQ_RANGE, EQ_Q_RANGE, HRP_GAIN_STEP_DB } from './definitions.js';
+/** A number that may take part in the arithmetic. */
+const usable = (v) => Number.isFinite(v);
+/** Below lo is lo, above hi is hi, anything else (a NaN too) passes through. */
+const clamp = (v, lo, hi) => (v < lo ? lo : v > hi ? hi : v);
+/** REFUSED WHOLE: an input the placement cannot honour places nothing. */
+function refused(f0Hz, q, l) {
+    if (!usable(f0Hz) || f0Hz <= 0)
+        return true;
+    if (!usable(q))
+        return true;
+    if (!usable(l.maxCutDb) || l.maxCutDb < 0)
+        return true;
+    if (!usable(l.maxBoostDb) || l.maxBoostDb < 0)
+        return true;
+    if (!usable(l.maxBands) || l.maxBands < 1)
+        return true;
+    return false;
+}
+/** The bands one voice's per-harmonic gains become (`gainsDb[k]` is harmonic k+1), in harmonic order. */
+export function hrpPlaceBands(f0Hz, gainsDb, q, limits) {
+    if (refused(f0Hz, q, limits))
+        return [];
+    const bandQ = clamp(q, EQ_Q_RANGE.min, EQ_Q_RANGE.max);
+    const placed = [];
+    for (let k = 0; k < gainsDb.length; k++) {
+        const requested = gainsDb[k];
+        if (!usable(requested))
+            continue;
+        const harmonic = k + 1;
+        const freqHz = harmonic * f0Hz;
+        if (!hrpPlaceInRange(freqHz))
+            continue;
+        const gainDb = clamp(requested, -limits.maxCutDb, limits.maxBoostDb);
+        if (gainDb === 0)
+            continue; // SPARSE: -0 is the same fact
+        placed.push({ harmonic, freqHz, gainDb, q: bandQ });
+    }
+    if (placed.length <= limits.maxBands)
+        return placed;
+    // THE CAP: the largest |gain| kept, ties to the lower harmonic, then back in harmonic order
+    return [...placed]
+        .sort((a, b) => Math.abs(b.gainDb) - Math.abs(a.gainDb) || a.harmonic - b.harmonic)
+        .slice(0, limits.maxBands)
+        .sort((a, b) => a.harmonic - b.harmonic);
+}
+/** Is a band at freqHz placeable (inside EQ_FREQ_RANGE, both bounds kept)? A NaN is not. */
+export function hrpPlaceInRange(freqHz) {
+    return !(freqHz < EQ_FREQ_RANGE.min || freqHz > EQ_FREQ_RANGE.max || Number.isNaN(freqHz));
+}
+/** One bounded move of `current` toward `target`, never further than HRP_GAIN_STEP_DB. */
+export function hrpStepToward(current, target) {
+    const delta = target - current;
+    if (Math.abs(delta) <= HRP_GAIN_STEP_DB)
+        return target;
+    return current + Math.sign(delta) * HRP_GAIN_STEP_DB;
+}

package/dist/index.d.ts

@@ -5,10 +5,12 @@
  */
 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 { COMP_KNEE_DB_RANGE, COMP_RATIO_RANGE, CURVE_CODES, CURVE_DISPLAYS, CURVE_EXTENTS, CURVE_FAMILIES, CURVE_POINTS_MAX, CURVE_ORIGINS, 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, METER_DECIMATION, METER_KINDS, METER_MEASUREMENTS, METER_UNITS, METER_UNITS_LABELS, METER_VIEW, RTA_FFT_SIZE_MAX, RTA_TARGET_BIN_HZ, } from './definitions.js';
-export { fftSizeForRate } from './rta.js';
+export { COMP_KNEE_DB_RANGE, COMP_RATIO_RANGE, CURVE_CODES, CURVE_DISPLAYS, CURVE_EXTENTS, CURVE_FAMILIES, CURVE_POINTS_MAX, CURVE_ORIGINS, 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, METER_DECIMATION, METER_KINDS, METER_MEASUREMENTS, METER_UNITS, METER_UNITS_LABELS, METER_VIEW, RTA_BAND_F_MAX_CAP, RTA_BAND_F_MIN, RTA_BAND_GATE_DB, RTA_DELTA_DEADBAND_DB, RTA_FFT_SIZE_MAX, RTA_GRID_FREQS, RTA_HZ, RTA_LEVEL_DB_MAX, RTA_LEVEL_DB_MIN, RTA_LEVEL_GRID_DB, RTA_LOW_ADVANCE, RTA_TAP_GATE_DB, RTA_TARGET_BIN_HZ, RTA_TIER_CROSSOVER_HZ, } from './definitions.js';
+export { aggregateSpectrumBands, bandDelta, bandFMax, fftSizeForRate, hzToBin, lowTierGainDb, spectrumBandCentres, type BandDelta, type BandWedge, type MagnitudeSeries, type SpectrumBand, type SpectrumBandOptions, type SpectrumTierInput, } from './rta.js';
 export { gaincompDb, gaincompDbShifted, gateKnee, type GaincompMode, type GaincompParams } from './gaincomp.js';
 export { CURVE_WORDS, butterworthQs, curvePoints, type CurveAnswer, type CurveCode, type CurveMark, type CurvePoint, type CurveRequest, type CurveTerm, } from './curve.js';
 export { FBS_ACTIONS, FBS_HOLD_NEVER, FBS_PLACE_SLOTS, FbsPlace, ORIGIN, ORIGIN_WORDS, SHAPE, SHAPE_WORDS, fbsCents, fbsGainCap, sameRingFreq, type BandReport, type FbsAction, type FbsEvent, type FbsFind, type FbsPool, } from './fbs-place.js';
+export { hrpPlaceBands, hrpPlaceInRange, hrpStepToward, type HrpPlaceLimits, type HrpPlacedBand } from './hrp-place.js';
+export { EQ_FREQ_RANGE, HRP_GAIN_STEP_DB } from './definitions.js';
 export { EQ_GAIN_RANGE, FBS_MAX_CUT_DB } from './definitions.js';
 export { METER_GR_EMPTY, METER_GR_HOLD_MS, METER_MARKER_EMPTY, METER_WORDS, meterBarStep, meterClip, meterDecimate, meterFill, meterFillDb, meterGrStep, meterGrView, meterMarker, meterStep, meterUnitOf, type MeterGr, type MeterKind, type MeterMarker, type MeterMeasurement, type MeterUnit, } from './meter.js';

package/dist/index.js

@@ -7,10 +7,12 @@
  */
 export { ANALYSIS_FLOOR_DB, dbToLinearGain, linearGainToDb, linearToDbFloored } from './units.js';
 export { biquadMagnitudeDb, clampEqQFor, lowpassHandover, magnitudeSumDb, matchedPair, octavesToQ, rbjSection, sectionMagnitudeDb, } from './eq.js';
-export { COMP_KNEE_DB_RANGE, COMP_RATIO_RANGE, CURVE_CODES, CURVE_DISPLAYS, CURVE_EXTENTS, CURVE_FAMILIES, CURVE_POINTS_MAX, CURVE_ORIGINS, 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, METER_DECIMATION, METER_KINDS, METER_MEASUREMENTS, METER_UNITS, METER_UNITS_LABELS, METER_VIEW, RTA_FFT_SIZE_MAX, RTA_TARGET_BIN_HZ, } from './definitions.js';
-export { fftSizeForRate } from './rta.js';
+export { COMP_KNEE_DB_RANGE, COMP_RATIO_RANGE, CURVE_CODES, CURVE_DISPLAYS, CURVE_EXTENTS, CURVE_FAMILIES, CURVE_POINTS_MAX, CURVE_ORIGINS, 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, METER_DECIMATION, METER_KINDS, METER_MEASUREMENTS, METER_UNITS, METER_UNITS_LABELS, METER_VIEW, RTA_BAND_F_MAX_CAP, RTA_BAND_F_MIN, RTA_BAND_GATE_DB, RTA_DELTA_DEADBAND_DB, RTA_FFT_SIZE_MAX, RTA_GRID_FREQS, RTA_HZ, RTA_LEVEL_DB_MAX, RTA_LEVEL_DB_MIN, RTA_LEVEL_GRID_DB, RTA_LOW_ADVANCE, RTA_TAP_GATE_DB, RTA_TARGET_BIN_HZ, RTA_TIER_CROSSOVER_HZ, } from './definitions.js';
+export { aggregateSpectrumBands, bandDelta, bandFMax, fftSizeForRate, hzToBin, lowTierGainDb, spectrumBandCentres, } from './rta.js';
 export { gaincompDb, gaincompDbShifted, gateKnee } from './gaincomp.js';
 export { CURVE_WORDS, butterworthQs, curvePoints, } from './curve.js';
 export { FBS_ACTIONS, FBS_HOLD_NEVER, FBS_PLACE_SLOTS, FbsPlace, ORIGIN, ORIGIN_WORDS, SHAPE, SHAPE_WORDS, fbsCents, fbsGainCap, sameRingFreq, } from './fbs-place.js';
+export { hrpPlaceBands, hrpPlaceInRange, hrpStepToward } from './hrp-place.js';
+export { EQ_FREQ_RANGE, HRP_GAIN_STEP_DB } from './definitions.js';
 export { EQ_GAIN_RANGE, FBS_MAX_CUT_DB } from './definitions.js';
 export { METER_GR_EMPTY, METER_GR_HOLD_MS, METER_MARKER_EMPTY, METER_WORDS, meterBarStep, meterClip, meterDecimate, meterFill, meterFillDb, meterGrStep, meterGrView, meterMarker, meterStep, meterUnitOf, } from './meter.js';

package/dist/rta.d.ts

@@ -1,4 +1,4 @@
-/** The twin of omx_rta.h omx_rta_fft_size_for, moved verbatim from the console (its spectrum bands); the two limits are omx-dsp's own (data/kernels/rta.json). */
+/** The twins of omx_rta.h omx_rta_fft_size_for and omx_rta_bands.h omx_rta_bands and omx_rta_band_delta, moved verbatim from the console (its spectrum bands and its EQ curve's delta wedges); every limit is omx-dsp's own (data/kernels/rta.json) or omx-contract's (EQ_GAIN_RANGE). */
 /**
  * The RTA FFT length for `rate` — the TypeScript mirror of `mix_dsp.h`'s `omx_rta_fft_size_for`:
  * the smallest power of two whose bins are at or under {@link RTA_TARGET_BIN_HZ} (44.1/48 kHz →
@@ -9,3 +9,73 @@
  * declaring one of its own.
  */
 export declare function fftSizeForRate(rate: number): number;
+/**
+ * A magnitude series as a consumer receives it: one `Float32Array` from a native reader, or a plain
+ * array from the wire, a test or an offline synth. Every reader indexes and measures length only.
+ */
+export type MagnitudeSeries = readonly number[] | Float32Array;
+/** One tier of a reading: the linear magnitudes (bin 0 = DC) and the transform that produced them. */
+export interface SpectrumTierInput {
+    readonly mags: MagnitudeSeries;
+    readonly sampleRate: number;
+    readonly fftSize: number;
+}
+/** One log-spaced band: its geometric centre (Hz), the RMS across its bins and its loudest bin (dBFS). */
+export interface SpectrumBand {
+    readonly hz: number;
+    readonly db: number;
+    readonly peakDb: number;
+}
+/** What {@link aggregateSpectrumBands} may be asked to vary; everything else is declared in rta.json. */
+export interface SpectrumBandOptions {
+    /** Lowest band edge, Hz. Defaults to RTA_BAND_F_MIN. */
+    readonly fMin?: number;
+    /** Highest band edge, Hz. Defaults to {@link bandFMax} of the high tier's rate. */
+    readonly fMax?: number;
+    /** The decimated tier, where the reading carries one. Bands centred under the crossover sample it. */
+    readonly low?: SpectrumTierInput;
+}
+/** The (fractional) bin holding `hz` in a transform of `fftSize` at `sampleRate`. */
+export declare function hzToBin(hz: number, sampleRate: number, fftSize: number): number;
+/** The twin of omx_rta_band_f_max: RTA_BAND_F_MAX_CAP, or the Nyquist where that is lower. */
+export declare function bandFMax(sampleRate: number): number;
+/**
+ * The twin of omx_rta_low_gain_db: the dB that level-matches a low-tier band to the high tier. A band's
+ * value is an RMS across its bins and the low tier packs more bins into the same Hz, so it reads lower by
+ * the bin-density ratio; a degenerate tier declines to correct rather than emit a NaN.
+ */
+export declare function lowTierGainDb(high: SpectrumTierInput, low: SpectrumTierInput): number;
+/**
+ * The band tiling: `nBands` log-even bands from `fMin` to `fMax`, each at its GEOMETRIC centre, by the
+ * expressions {@link aggregateSpectrumBands} tiles with, so a client can regenerate the centres of a banded
+ * frame without the frame carrying them.
+ */
+export declare function spectrumBandCentres(nBands: number, sampleRate: number, options?: Pick<SpectrumBandOptions, 'fMin' | 'fMax'>): number[];
+/**
+ * The twin of omx_rta_bands (analysis/omx_rta_bands.h), moved from the console unchanged: reduce `high` (and
+ * `low`, for a band centred under RTA_TIER_CROSSOVER_HZ) to `nBands` log-spaced bands. `db` is the RMS across
+ * a band's bins, `peakDb` its loudest bin, never tier-corrected; when no band rises above RTA_BAND_GATE_DB
+ * every band reads as silence (-Infinity). `nBands` below 1 answers an empty set. Held to the kernel by
+ * vectors/rta-bands.json (test/rta-bands.test.mjs).
+ */
+export declare function aggregateSpectrumBands(high: SpectrumTierInput, nBands: number, options?: SpectrumBandOptions): SpectrumBand[];
+/** One wedge of the difference: bands `band` and `band + 1`, a boost or a cut, its strength 0 to 1. */
+export interface BandWedge {
+    band: number;
+    boost: boolean;
+    strength: number;
+}
+/** The difference of two taps: POST − PRE per band (NaN where either is silent) and its wedges. */
+export interface BandDelta {
+    diff: number[];
+    wedges: BandWedge[];
+}
+/**
+ * The twin of omx_rta_bands.h's `omx_rta_band_delta`: POST − PRE of two tap readings' band levels (dB, silence
+ * -Infinity), NaN where either band is silent; then one wedge per pair of neighbouring bands whose larger |difference|
+ * reaches RTA_DELTA_DEADBAND_DB, none across a silent band: a boost when the pair sums to zero or more, else a cut, its
+ * strength the larger |difference| over EQ_GAIN_RANGE's maximum, clamped to 1. The two readings must have as many
+ * bands (a RangeError otherwise: the C has one count for both). Held to the kernel by vectors/rta-delta.json
+ * (test/rta-delta.test.mjs).
+ */
+export declare function bandDelta(preDb: readonly number[], postDb: readonly number[]): BandDelta;

package/dist/rta.js

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
-/** The twin of omx_rta.h omx_rta_fft_size_for, moved verbatim from the console (its spectrum bands); the two limits are omx-dsp's own (data/kernels/rta.json). */
-import { RTA_TARGET_BIN_HZ, RTA_FFT_SIZE_MAX } from './definitions.js';
+/** The twins of omx_rta.h omx_rta_fft_size_for and omx_rta_bands.h omx_rta_bands and omx_rta_band_delta, moved verbatim from the console (its spectrum bands and its EQ curve's delta wedges); every limit is omx-dsp's own (data/kernels/rta.json) or omx-contract's (EQ_GAIN_RANGE). */
+import { RTA_TARGET_BIN_HZ, RTA_FFT_SIZE_MAX, RTA_BAND_F_MIN, RTA_BAND_F_MAX_CAP, RTA_TIER_CROSSOVER_HZ, RTA_BAND_GATE_DB, RTA_DELTA_DEADBAND_DB, EQ_GAIN_RANGE, } from './definitions.js';
+import { linearGainToDb } from './units.js';
 /**
  * The RTA FFT length for `rate` — the TypeScript mirror of `mix_dsp.h`'s `omx_rta_fft_size_for`:
  * the smallest power of two whose bins are at or under {@link RTA_TARGET_BIN_HZ} (44.1/48 kHz →
@@ -17,3 +18,129 @@ export function fftSizeForRate(rate) {
         n *= 2;
     return n;
 }
+/** The (fractional) bin holding `hz` in a transform of `fftSize` at `sampleRate`. */
+export function hzToBin(hz, sampleRate, fftSize) {
+    return (hz * fftSize) / sampleRate;
+}
+/** The twin of omx_rta_band_f_max: RTA_BAND_F_MAX_CAP, or the Nyquist where that is lower. */
+export function bandFMax(sampleRate) {
+    return Math.min(RTA_BAND_F_MAX_CAP, sampleRate / 2);
+}
+/**
+ * The twin of omx_rta_low_gain_db: the dB that level-matches a low-tier band to the high tier. A band's
+ * value is an RMS across its bins and the low tier packs more bins into the same Hz, so it reads lower by
+ * the bin-density ratio; a degenerate tier declines to correct rather than emit a NaN.
+ */
+export function lowTierGainDb(high, low) {
+    const ratio = low.fftSize / low.sampleRate / (high.fftSize / high.sampleRate);
+    if (!Number.isFinite(ratio) || ratio <= 0)
+        return 0;
+    return 10 * Math.log10(ratio);
+}
+/** RMS and peak (linear) of `tier` over the bins covering [f0, f1); a band spanning none samples the nearest. DC never. */
+function tierBandStats(tier, f0, f1) {
+    const bins = tier.mags.length;
+    let i0 = Math.max(1, Math.floor(hzToBin(f0, tier.sampleRate, tier.fftSize)));
+    const i1 = Math.min(bins - 1, Math.ceil(hzToBin(f1, tier.sampleRate, tier.fftSize)));
+    if (i1 < i0)
+        i0 = i1;
+    let sumSq = 0;
+    let peak = 0;
+    let n = 0;
+    for (let i = i0; i <= i1; i++) {
+        const m = tier.mags[i] ?? 0;
+        sumSq += m * m;
+        if (m > peak)
+            peak = m;
+        n++;
+    }
+    return { rms: n > 0 ? Math.sqrt(sumSq / n) : 0, peak };
+}
+/**
+ * The band tiling: `nBands` log-even bands from `fMin` to `fMax`, each at its GEOMETRIC centre, by the
+ * expressions {@link aggregateSpectrumBands} tiles with, so a client can regenerate the centres of a banded
+ * frame without the frame carrying them.
+ */
+export function spectrumBandCentres(nBands, sampleRate, options = {}) {
+    if (!Number.isFinite(nBands) || nBands < 1)
+        return [];
+    const fMinV = options.fMin ?? RTA_BAND_F_MIN;
+    const fMaxV = Math.max(options.fMax ?? bandFMax(sampleRate), fMinV * 2);
+    const lo = Math.log10(fMinV);
+    const hi = Math.log10(fMaxV);
+    const centres = new Array(nBands);
+    for (let b = 0; b < nBands; b++) {
+        const f0 = 10 ** (lo + ((hi - lo) * b) / nBands);
+        const f1 = 10 ** (lo + ((hi - lo) * (b + 1)) / nBands);
+        centres[b] = Math.sqrt(f0 * f1);
+    }
+    return centres;
+}
+/**
+ * The twin of omx_rta_bands (analysis/omx_rta_bands.h), moved from the console unchanged: reduce `high` (and
+ * `low`, for a band centred under RTA_TIER_CROSSOVER_HZ) to `nBands` log-spaced bands. `db` is the RMS across
+ * a band's bins, `peakDb` its loudest bin, never tier-corrected; when no band rises above RTA_BAND_GATE_DB
+ * every band reads as silence (-Infinity). `nBands` below 1 answers an empty set. Held to the kernel by
+ * vectors/rta-bands.json (test/rta-bands.test.mjs).
+ */
+export function aggregateSpectrumBands(high, nBands, options = {}) {
+    if (!Number.isFinite(nBands) || nBands < 1)
+        return [];
+    const low = options.low;
+    const fMinV = options.fMin ?? RTA_BAND_F_MIN;
+    const fMaxV = Math.max(options.fMax ?? bandFMax(high.sampleRate), fMinV * 2);
+    const lo = Math.log10(fMinV);
+    const hi = Math.log10(fMaxV);
+    const lowGainDb = low ? lowTierGainDb(high, low) : 0;
+    const bands = new Array(nBands);
+    let maxDb = -Infinity;
+    for (let b = 0; b < nBands; b++) {
+        const f0 = 10 ** (lo + ((hi - lo) * b) / nBands);
+        const f1 = 10 ** (lo + ((hi - lo) * (b + 1)) / nBands);
+        const centre = Math.sqrt(f0 * f1);
+        const tier = low && centre < RTA_TIER_CROSSOVER_HZ ? low : high;
+        const { rms, peak } = tierBandStats(tier, f0, f1);
+        const db = linearGainToDb(rms) + (tier === low ? lowGainDb : 0);
+        if (db > maxDb)
+            maxDb = db;
+        bands[b] = { hz: centre, db, peakDb: linearGainToDb(peak) };
+    }
+    if (maxDb < RTA_BAND_GATE_DB) {
+        const silence = linearGainToDb(0);
+        return bands.map((x) => ({ hz: x.hz, db: silence, peakDb: silence }));
+    }
+    return bands;
+}
+/**
+ * The twin of omx_rta_bands.h's `omx_rta_band_delta`: POST − PRE of two tap readings' band levels (dB, silence
+ * -Infinity), NaN where either band is silent; then one wedge per pair of neighbouring bands whose larger |difference|
+ * reaches RTA_DELTA_DEADBAND_DB, none across a silent band: a boost when the pair sums to zero or more, else a cut, its
+ * strength the larger |difference| over EQ_GAIN_RANGE's maximum, clamped to 1. The two readings must have as many
+ * bands (a RangeError otherwise: the C has one count for both). Held to the kernel by vectors/rta-delta.json
+ * (test/rta-delta.test.mjs).
+ */
+export function bandDelta(preDb, postDb) {
+    const n = preDb.length;
+    if (postDb.length !== n)
+        throw new RangeError(`bandDelta: ${n} PRE bands and ${postDb.length} POST bands`);
+    const diff = new Array(n);
+    for (let i = 0; i < n; i++) {
+        const a = preDb[i];
+        const b = postDb[i];
+        diff[i] = !Number.isFinite(a) || !Number.isFinite(b) ? NaN : b - a;
+    }
+    const full = EQ_GAIN_RANGE.max;
+    const wedges = [];
+    for (let i = 0; i + 1 < n; i++) {
+        const d0 = diff[i];
+        const d1 = diff[i + 1];
+        if (Number.isNaN(d0) || Number.isNaN(d1))
+            continue;
+        const magnitude = Math.max(Math.abs(d0), Math.abs(d1));
+        if (magnitude < RTA_DELTA_DEADBAND_DB)
+            continue;
+        const strength = magnitude / full;
+        wedges.push({ band: i, boost: d0 + d1 >= 0, strength: strength < 1 ? strength : 1 });
+    }
+    return { diff, wedges };
+}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@openmixer/omx-dsp",
-  "version": "0.32.0",
+  "version": "0.32.2",
   "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/definitions.ts

@@ -8,6 +8,42 @@ 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 */
 export const RTA_FFT_SIZE_MAX = 32768;
 
+/** The lowest frequency any spectrum band covers; below it is infrasonic and not drawn. (Hz) @see data/kernels/rta.json */
+export const RTA_BAND_F_MIN = 20;
+
+/** The highest frequency any spectrum band covers, before the Nyquist clamp (omx_rta_band_f_max). (Hz) @see data/kernels/rta.json */
+export const RTA_BAND_F_MAX_CAP = 20000;
+
+/** A band centred below this samples the LOW (decimated) tier when the reading carries one; at or above it, the HIGH tier. Where the high tier's ~5.86 Hz bins still give ~51 bins per octave, above the finest panel's density. (Hz) @see data/kernels/rta.json */
+export const RTA_TIER_CROSSOVER_HZ = 300;
+
+/** Quiet gate of the band reduction: when no band rises above this, every band reads as silence, so a rig's idle floor never draws as a flat block. Keyed on the loudest band, not per band. (dB) @see data/kernels/rta.json */
+export const RTA_BAND_GATE_DB = -60;
+
+/** Quiet gate of a tap's raw spectrum, before any banding: when no bin rises above this the whole tap reads as the floor. The console's overlay frame applies it; a banded reading is gated by RTA_BAND_GATE_DB instead. (dB) @see data/kernels/rta.json */
+export const RTA_TAP_GATE_DB = -60;
+
+/** The floor of a spectrum display's level window: the bottom of the frame, every surface. (dB) @see data/kernels/rta.json */
+export const RTA_LEVEL_DB_MIN = -72;
+
+/** The ceiling of a spectrum display's level window: the top of the frame, where a band's peak reaching it draws a clip tick. (dB) @see data/kernels/rta.json */
+export const RTA_LEVEL_DB_MAX = 0;
+
+/** The spacing of a spectrum display's one dB graticule, from the ceiling down to the floor. (dB) @see data/kernels/rta.json */
+export const RTA_LEVEL_GRID_DB = 12;
+
+/** How often a watched spectrum is read and published: an operator-cadence poll, never the audio thread. (Hz) @see data/kernels/rta.json */
+export const RTA_HZ = 10;
+
+/** How far the low zoom's window must have advanced, as a fraction of that window, before it is recomputed; between recomputes the last zoom rides the fresh main spectrum unchanged. @see data/kernels/rta.json */
+export const RTA_LOW_ADVANCE = 0.25;
+
+/** The frequencies of a spectrum display's labelled vertical graticule lines, Hz, on the log frequency axis: the decades and their 2 and 5 steps from 20 Hz to 20 kHz, every surface. (Hz) @see data/kernels/rta.json */
+export const RTA_GRID_FREQS: readonly number[] = [20, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000];
+
+/** The smallest difference between two taps of a spectrum, POST - PRE in dB, that draws a wedge: a pair of neighbouring bands is a wedge when either band's difference reaches it. The console's overlay held it as 0.004 of its 100 dB span. (dB) @see data/kernels/rta.json */
+export const RTA_DELTA_DEADBAND_DB = 0.4;
+
 /** Where the low-pass section hands its poles over from the matched pair to the prewarped bilinear pair, as fractions of Nyquist, and how that band moves with Q. At `qHi` (1/sqrt(2), the 12 dB Butterworth) the band runs from `loAtHiQ` to `hiAtHiQ`; at `qLo` (0.5412, the low-Q half of the 24 dB Butterworth) and below, from `loAtLoQ` to `hiAtLoQ`; between the two it moves linearly. Above `qHi` the prototype peaks, and the band's end moves down to `hiAtPeakQ` by `qPeak`, held above it. Below the band the low-pass is the matched design unchanged. @see data/kernels/eq.json */
 export const LOWPASS_HANDOVER = {
   qHi: 0.7071067811865476,
@@ -80,6 +116,9 @@ 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;
 
+/** How far ONE reconcile pass may move an HRP band's gain, in dB — the gain smoothing, done at the control level because the native cascade applies pushed coefficients verbatim and the design forbids interpolating there. An unbounded gain step is a waveform discontinuity — the click heard when a correction entered or left at full depth (found live, 2026-08-20, the evening increment 9 raised the enter/leave rate). Bounded, a correction ENTERS by deepening from silence and LEAVES by walking to exactly 0 dB — the provable parked identity (`eqBandIsIdentity`) — from which removal is bit-identical. Two decibels per pass at the corrector's 10 Hz cadence walks the full HRP_MAX_CUT_DB travel in ~300 ms: the same order as the tracker's stability hold and FBS's lift steps, while each individual move stays below audibility on a Q-5 bell. (dB) @see data/kernels/hrp.json */
+export const HRP_GAIN_STEP_DB = 2;
+
 /** 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;
 

package/src/fbs-place.ts

@@ -102,11 +102,13 @@ interface Slot {
   dwellStartMs: number | null;
   reclamps: number;
   ramp: { step: number; stage: number; fromDb: number; toDb: number; dueMs: number; seq: number } | null;
+  /** Seated or re-tagged live, adopted at the next tick. */
+  adopt: boolean;
 }
 
 const freeSlot = (): Slot => ({
   freqHz: 0, gainDb: 0, q: 0, on: false, origin: ORIGIN.user, shape: SHAPE.off, seq: 0,
-  live: false, plantedDb: 0, lastRingMs: 0, stage: 0, dwellStartMs: null, reclamps: 0, ramp: null,
+  live: false, plantedDb: 0, lastRingMs: 0, stage: 0, dwellStartMs: null, reclamps: 0, ramp: null, adopt: false,
 });
 
 /** `n < lo ? lo : n > hi ? hi : n`: core's clamp, a NaN passing through. */
@@ -148,6 +150,8 @@ export class FbsPlace {
   cooldownS: number = FBS_DEFAULT_COOLDOWN_SECONDS;
   nowMs = 0;
   memoryDropped = 0;
+  /** Bands the strip's EQ holds that are not the placement's. */
+  others = 0;
   protected slots: Slot[] = Array.from({ length: FBS_PLACE_SLOTS }, freeSlot);
   protected memory: Array<{ freqHz: number; reclamps: number; releasedMs: number }> = [];
   protected seq = 0;
@@ -199,10 +203,57 @@ export class FbsPlace {
   /** One detector tick: the ramp steps due, a band per newly confirmed ring, then the clean holds. */
   tick(nowMs: number, snapshotHz: readonly number[], confirmed: readonly FbsFind[]): void {
     this.advance(nowMs);
+    this.adopt();
     for (const c of confirmed) this.correct(c);
     this.holdSweep(snapshotHz);
   }
 
+  /** How many bands the strip's EQ holds that the placement does not own (omx_fbs_place_set_others). */
+  setOthers(n: number): void {
+    this.others = n;
+  }
+
+  /** The band in slot k left the EQ: the slot frees, nothing said or remembered (omx_fbs_place_remove). */
+  remove(k: number): boolean {
+    const s = this.slots[k];
+    if (!s || s.origin === ORIGIN.user) return false;
+    this.release(k);
+    return true;
+  }
+
+  /** The operator re-tagged or re-gained slot k's band (omx_fbs_place_edit). */
+  edit(k: number, originIndex: number, gainDb: number): boolean {
+    const s = this.slots[k];
+    if (!s || s.origin === ORIGIN.user || originIndex < 0 || originIndex >= ORIGIN_WORDS.length) return false;
+    if (originIndex !== ORIGIN.fbsFixed && originIndex !== ORIGIN.fbsLive) return this.remove(k);
+    s.origin = originIndex;
+    s.gainDb = this.capGain(originIndex, gainDb);
+    if (originIndex === ORIGIN.fbsLive && !s.live) s.adopt = true;
+    if (originIndex === ORIGIN.fbsFixed) this.leaveLadder(k);
+    return true;
+  }
+
+  /** A band the EQ already holds, seated in the lowest free slot (omx_fbs_place_seat); the slot, or -1. */
+  seat(originIndex: number, freqHz: number, gainDb: number, q: number): number {
+    if (originIndex !== ORIGIN.fbsFixed && originIndex !== ORIGIN.fbsLive) return -1;
+    if (!Number.isFinite(freqHz) || !Number.isFinite(gainDb) || !Number.isFinite(q)) return -1;
+    const k = this.slots.findIndex((x) => x.origin === ORIGIN.user);
+    if (k < 0) return -1;
+    const fixed = originIndex === ORIGIN.fbsFixed;
+    const s = freeSlot();
+    s.origin = originIndex;
+    s.freqHz = clamp(freqHz, EQ_FREQ_RANGE.min, EQ_FREQ_RANGE.max);
+    s.shape = fixed ? SHAPE.notch : SHAPE.bell;
+    s.gainDb = this.capGain(originIndex, gainDb);
+    s.q = fixed ? clamp(q, EQ_NOTCH_Q_RANGE.min, EQ_NOTCH_Q_RANGE.max) : clamp(q, EQ_Q_RANGE.min, EQ_Q_RANGE.max);
+    s.on = true;
+    s.seq = ++this.seq;
+    s.plantedDb = s.gainDb;
+    s.adopt = !fixed;
+    this.slots[k] = s;
+    return k;
+  }
+
   // ---- the rules, one method each ----------------------------------------------------------------------------
 
   /** One find or another: the same-ring window, or the merge radius in cents (band first, find second). */
@@ -257,6 +308,8 @@ export class FbsPlace {
       this.emit('pool-full', c.freqHz, -1);
       return;
     }
+    // the strip's EQ is full (FBS_PLACE_SLOTS is the EQ's band count): its store refuses, and nothing is said
+    if (this.count() + this.othersCounted() >= FBS_PLACE_SLOTS) return;
     const k = this.slots.findIndex((s) => s.origin === ORIGIN.user);
     if (k < 0) return;
     const fixed = this.poolOfFind() === 'fixed';
@@ -279,6 +332,47 @@ export class FbsPlace {
     this.emit('notched', c.freqHz, k);
   }
 
+  /** The EQ's other bands, as the shared cap counts them. */
+  protected othersCounted(): number {
+    return this.others;
+  }
+
+  /** Every band seated or re-tagged live and not yet tracked, in band order: a fresh hold and its ring memory. */
+  protected adopt(): void {
+    for (const k of this.bySeq()) {
+      const s = this.slots[k]!;
+      if (!s.adopt) continue;
+      s.adopt = false;
+      if (!this.adoptsOrigin(s.origin)) continue;
+      s.live = true;
+      s.plantedDb = s.gainDb;
+      s.lastRingMs = this.adoptClock();
+      s.stage = 0;
+      s.dwellStartMs = null;
+      s.ramp = null;
+      s.reclamps = this.takeMemory(s.freqHz);
+    }
+  }
+
+  /** The fixed pool never lifts: a band re-tagged fixed leaves the release ladder where the edit left it. */
+  protected leaveLadder(k: number): void {
+    const s = this.slots[k]!;
+    s.live = false;
+    s.ramp = null;
+    s.stage = 0;
+    s.dwellStartMs = null;
+  }
+
+  /** Whether a pending band is adopted: only one whose origin is fbs-live at the tick. */
+  protected adoptsOrigin(originIndex: number): boolean {
+    return originIndex === ORIGIN.fbsLive;
+  }
+
+  /** The clock an adopted band's hold starts from. */
+  protected adoptClock(): number {
+    return this.nowMs;
+  }
+
   protected holdSweep(snapshotHz: readonly number[]): void {
     for (const k of this.bySeq()) {
       const s = this.slots[k]!;

package/src/hrp-place.ts

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * The twin of omx_hrp_place.h (src/omx_hrp_place.c): the harmonic resonance processor's placement and stepping.
+ * The C placement and this one read the same vector file (test/analysis/fixtures/hrp_place.vectors) in
+ * test/analysis/hrp_place.test.c and test/hrp-place.test.mjs, so the two are held to the same values, exactly.
+ *
+ * The rules are the header's, one function each, in the same order and arithmetic: the console's harmonicBands
+ * and the HRP planter's stepToward, term for term.
+ */
+import { EQ_FREQ_RANGE, EQ_Q_RANGE, HRP_GAIN_STEP_DB } from './definitions.js';
+
+/** The authority one placement is given, by the caller. */
+export interface HrpPlaceLimits {
+  /** The largest cut, a positive magnitude. */
+  readonly maxCutDb: number;
+  /** The largest boost, a positive magnitude (0: cuts only). */
+  readonly maxBoostDb: number;
+  /** How many bands may be placed (a free-slot count). */
+  readonly maxBands: number;
+}
+
+/** One placed band: a bell at freqHz, gainDb (negative is a cut), q, for one harmonic (1 is the fundamental). */
+export interface HrpPlacedBand {
+  readonly harmonic: number;
+  readonly freqHz: number;
+  readonly gainDb: number;
+  readonly q: number;
+}
+
+/** A number that may take part in the arithmetic. */
+const usable = (v: number): boolean => Number.isFinite(v);
+
+/** Below lo is lo, above hi is hi, anything else (a NaN too) passes through. */
+const clamp = (v: number, lo: number, hi: number): number => (v < lo ? lo : v > hi ? hi : v);
+
+/** REFUSED WHOLE: an input the placement cannot honour places nothing. */
+function refused(f0Hz: number, q: number, l: HrpPlaceLimits): boolean {
+  if (!usable(f0Hz) || f0Hz <= 0) return true;
+  if (!usable(q)) return true;
+  if (!usable(l.maxCutDb) || l.maxCutDb < 0) return true;
+  if (!usable(l.maxBoostDb) || l.maxBoostDb < 0) return true;
+  if (!usable(l.maxBands) || l.maxBands < 1) return true;
+  return false;
+}
+
+/** The bands one voice's per-harmonic gains become (`gainsDb[k]` is harmonic k+1), in harmonic order. */
+export function hrpPlaceBands(
+  f0Hz: number,
+  gainsDb: readonly number[],
+  q: number,
+  limits: HrpPlaceLimits,
+): HrpPlacedBand[] {
+  if (refused(f0Hz, q, limits)) return [];
+  const bandQ = clamp(q, EQ_Q_RANGE.min, EQ_Q_RANGE.max);
+  const placed: HrpPlacedBand[] = [];
+  for (let k = 0; k < gainsDb.length; k++) {
+    const requested = gainsDb[k]!;
+    if (!usable(requested)) continue;
+    const harmonic = k + 1;
+    const freqHz = harmonic * f0Hz;
+    if (!hrpPlaceInRange(freqHz)) continue;
+    const gainDb = clamp(requested, -limits.maxCutDb, limits.maxBoostDb);
+    if (gainDb === 0) continue; // SPARSE: -0 is the same fact
+    placed.push({ harmonic, freqHz, gainDb, q: bandQ });
+  }
+  if (placed.length <= limits.maxBands) return placed;
+  // THE CAP: the largest |gain| kept, ties to the lower harmonic, then back in harmonic order
+  return [...placed]
+    .sort((a, b) => Math.abs(b.gainDb) - Math.abs(a.gainDb) || a.harmonic - b.harmonic)
+    .slice(0, limits.maxBands)
+    .sort((a, b) => a.harmonic - b.harmonic);
+}
+
+/** Is a band at freqHz placeable (inside EQ_FREQ_RANGE, both bounds kept)? A NaN is not. */
+export function hrpPlaceInRange(freqHz: number): boolean {
+  return !(freqHz < EQ_FREQ_RANGE.min || freqHz > EQ_FREQ_RANGE.max || Number.isNaN(freqHz));
+}
+
+/** One bounded move of `current` toward `target`, never further than HRP_GAIN_STEP_DB. */
+export function hrpStepToward(current: number, target: number): number {
+  const delta = target - current;
+  if (Math.abs(delta) <= HRP_GAIN_STEP_DB) return target;
+  return current + Math.sign(delta) * HRP_GAIN_STEP_DB;
+}

package/src/index.ts

@@ -44,10 +44,36 @@ export {
   METER_UNITS,
   METER_UNITS_LABELS,
   METER_VIEW,
+  RTA_BAND_F_MAX_CAP,
+  RTA_BAND_F_MIN,
+  RTA_BAND_GATE_DB,
+  RTA_DELTA_DEADBAND_DB,
   RTA_FFT_SIZE_MAX,
+  RTA_GRID_FREQS,
+  RTA_HZ,
+  RTA_LEVEL_DB_MAX,
+  RTA_LEVEL_DB_MIN,
+  RTA_LEVEL_GRID_DB,
+  RTA_LOW_ADVANCE,
+  RTA_TAP_GATE_DB,
   RTA_TARGET_BIN_HZ,
+  RTA_TIER_CROSSOVER_HZ,
 } from './definitions.js';
-export { fftSizeForRate } from './rta.js';
+export {
+  aggregateSpectrumBands,
+  bandDelta,
+  bandFMax,
+  fftSizeForRate,
+  hzToBin,
+  lowTierGainDb,
+  spectrumBandCentres,
+  type BandDelta,
+  type BandWedge,
+  type MagnitudeSeries,
+  type SpectrumBand,
+  type SpectrumBandOptions,
+  type SpectrumTierInput,
+} from './rta.js';
 export { gaincompDb, gaincompDbShifted, gateKnee, type GaincompMode, type GaincompParams } from './gaincomp.js';
 export {
   CURVE_WORDS,
@@ -78,6 +104,8 @@ export {
   type FbsFind,
   type FbsPool,
 } from './fbs-place.js';
+export { hrpPlaceBands, hrpPlaceInRange, hrpStepToward, type HrpPlaceLimits, type HrpPlacedBand } from './hrp-place.js';
+export { EQ_FREQ_RANGE, HRP_GAIN_STEP_DB } from './definitions.js';
 export { EQ_GAIN_RANGE, FBS_MAX_CUT_DB } from './definitions.js';
 export {
   METER_GR_EMPTY,

package/src/rta.ts

@@ -1,8 +1,18 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
-/** The twin of omx_rta.h omx_rta_fft_size_for, moved verbatim from the console (its spectrum bands); the two limits are omx-dsp's own (data/kernels/rta.json). */
+/** The twins of omx_rta.h omx_rta_fft_size_for and omx_rta_bands.h omx_rta_bands and omx_rta_band_delta, moved verbatim from the console (its spectrum bands and its EQ curve's delta wedges); every limit is omx-dsp's own (data/kernels/rta.json) or omx-contract's (EQ_GAIN_RANGE). */
 
-import { RTA_TARGET_BIN_HZ, RTA_FFT_SIZE_MAX } from './definitions.js';
+import {
+  RTA_TARGET_BIN_HZ,
+  RTA_FFT_SIZE_MAX,
+  RTA_BAND_F_MIN,
+  RTA_BAND_F_MAX_CAP,
+  RTA_TIER_CROSSOVER_HZ,
+  RTA_BAND_GATE_DB,
+  RTA_DELTA_DEADBAND_DB,
+  EQ_GAIN_RANGE,
+} from './definitions.js';
+import { linearGainToDb } from './units.js';
 
 /**
  * The RTA FFT length for `rate` — the TypeScript mirror of `mix_dsp.h`'s `omx_rta_fft_size_for`:
@@ -18,3 +28,178 @@ export function fftSizeForRate(rate: number): number {
   while (n < RTA_FFT_SIZE_MAX && rate / n > RTA_TARGET_BIN_HZ) n *= 2;
   return n;
 }
+
+/**
+ * A magnitude series as a consumer receives it: one `Float32Array` from a native reader, or a plain
+ * array from the wire, a test or an offline synth. Every reader indexes and measures length only.
+ */
+export type MagnitudeSeries = readonly number[] | Float32Array;
+
+/** One tier of a reading: the linear magnitudes (bin 0 = DC) and the transform that produced them. */
+export interface SpectrumTierInput {
+  readonly mags: MagnitudeSeries;
+  readonly sampleRate: number;
+  readonly fftSize: number;
+}
+
+/** One log-spaced band: its geometric centre (Hz), the RMS across its bins and its loudest bin (dBFS). */
+export interface SpectrumBand {
+  readonly hz: number;
+  readonly db: number;
+  readonly peakDb: number;
+}
+
+/** What {@link aggregateSpectrumBands} may be asked to vary; everything else is declared in rta.json. */
+export interface SpectrumBandOptions {
+  /** Lowest band edge, Hz. Defaults to RTA_BAND_F_MIN. */
+  readonly fMin?: number;
+  /** Highest band edge, Hz. Defaults to {@link bandFMax} of the high tier's rate. */
+  readonly fMax?: number;
+  /** The decimated tier, where the reading carries one. Bands centred under the crossover sample it. */
+  readonly low?: SpectrumTierInput;
+}
+
+/** The (fractional) bin holding `hz` in a transform of `fftSize` at `sampleRate`. */
+export function hzToBin(hz: number, sampleRate: number, fftSize: number): number {
+  return (hz * fftSize) / sampleRate;
+}
+
+/** The twin of omx_rta_band_f_max: RTA_BAND_F_MAX_CAP, or the Nyquist where that is lower. */
+export function bandFMax(sampleRate: number): number {
+  return Math.min(RTA_BAND_F_MAX_CAP, sampleRate / 2);
+}
+
+/**
+ * The twin of omx_rta_low_gain_db: the dB that level-matches a low-tier band to the high tier. A band's
+ * value is an RMS across its bins and the low tier packs more bins into the same Hz, so it reads lower by
+ * the bin-density ratio; a degenerate tier declines to correct rather than emit a NaN.
+ */
+export function lowTierGainDb(high: SpectrumTierInput, low: SpectrumTierInput): number {
+  const ratio = low.fftSize / low.sampleRate / (high.fftSize / high.sampleRate);
+  if (!Number.isFinite(ratio) || ratio <= 0) return 0;
+  return 10 * Math.log10(ratio);
+}
+
+/** RMS and peak (linear) of `tier` over the bins covering [f0, f1); a band spanning none samples the nearest. DC never. */
+function tierBandStats(tier: SpectrumTierInput, f0: number, f1: number): { rms: number; peak: number } {
+  const bins = tier.mags.length;
+  let i0 = Math.max(1, Math.floor(hzToBin(f0, tier.sampleRate, tier.fftSize)));
+  const i1 = Math.min(bins - 1, Math.ceil(hzToBin(f1, tier.sampleRate, tier.fftSize)));
+  if (i1 < i0) i0 = i1;
+  let sumSq = 0;
+  let peak = 0;
+  let n = 0;
+  for (let i = i0; i <= i1; i++) {
+    const m = tier.mags[i] ?? 0;
+    sumSq += m * m;
+    if (m > peak) peak = m;
+    n++;
+  }
+  return { rms: n > 0 ? Math.sqrt(sumSq / n) : 0, peak };
+}
+
+/**
+ * The band tiling: `nBands` log-even bands from `fMin` to `fMax`, each at its GEOMETRIC centre, by the
+ * expressions {@link aggregateSpectrumBands} tiles with, so a client can regenerate the centres of a banded
+ * frame without the frame carrying them.
+ */
+export function spectrumBandCentres(
+  nBands: number,
+  sampleRate: number,
+  options: Pick<SpectrumBandOptions, 'fMin' | 'fMax'> = {},
+): number[] {
+  if (!Number.isFinite(nBands) || nBands < 1) return [];
+  const fMinV = options.fMin ?? RTA_BAND_F_MIN;
+  const fMaxV = Math.max(options.fMax ?? bandFMax(sampleRate), fMinV * 2);
+  const lo = Math.log10(fMinV);
+  const hi = Math.log10(fMaxV);
+  const centres = new Array<number>(nBands);
+  for (let b = 0; b < nBands; b++) {
+    const f0 = 10 ** (lo + ((hi - lo) * b) / nBands);
+    const f1 = 10 ** (lo + ((hi - lo) * (b + 1)) / nBands);
+    centres[b] = Math.sqrt(f0 * f1);
+  }
+  return centres;
+}
+
+/**
+ * The twin of omx_rta_bands (analysis/omx_rta_bands.h), moved from the console unchanged: reduce `high` (and
+ * `low`, for a band centred under RTA_TIER_CROSSOVER_HZ) to `nBands` log-spaced bands. `db` is the RMS across
+ * a band's bins, `peakDb` its loudest bin, never tier-corrected; when no band rises above RTA_BAND_GATE_DB
+ * every band reads as silence (-Infinity). `nBands` below 1 answers an empty set. Held to the kernel by
+ * vectors/rta-bands.json (test/rta-bands.test.mjs).
+ */
+export function aggregateSpectrumBands(
+  high: SpectrumTierInput,
+  nBands: number,
+  options: SpectrumBandOptions = {},
+): SpectrumBand[] {
+  if (!Number.isFinite(nBands) || nBands < 1) return [];
+  const low = options.low;
+  const fMinV = options.fMin ?? RTA_BAND_F_MIN;
+  const fMaxV = Math.max(options.fMax ?? bandFMax(high.sampleRate), fMinV * 2);
+  const lo = Math.log10(fMinV);
+  const hi = Math.log10(fMaxV);
+  const lowGainDb = low ? lowTierGainDb(high, low) : 0;
+  const bands = new Array<SpectrumBand>(nBands);
+  let maxDb = -Infinity;
+  for (let b = 0; b < nBands; b++) {
+    const f0 = 10 ** (lo + ((hi - lo) * b) / nBands);
+    const f1 = 10 ** (lo + ((hi - lo) * (b + 1)) / nBands);
+    const centre = Math.sqrt(f0 * f1);
+    const tier = low && centre < RTA_TIER_CROSSOVER_HZ ? low : high;
+    const { rms, peak } = tierBandStats(tier, f0, f1);
+    const db = linearGainToDb(rms) + (tier === low ? lowGainDb : 0);
+    if (db > maxDb) maxDb = db;
+    bands[b] = { hz: centre, db, peakDb: linearGainToDb(peak) };
+  }
+  if (maxDb < RTA_BAND_GATE_DB) {
+    const silence = linearGainToDb(0);
+    return bands.map((x) => ({ hz: x.hz, db: silence, peakDb: silence }));
+  }
+  return bands;
+}
+
+/** One wedge of the difference: bands `band` and `band + 1`, a boost or a cut, its strength 0 to 1. */
+export interface BandWedge {
+  band: number;
+  boost: boolean;
+  strength: number;
+}
+
+/** The difference of two taps: POST − PRE per band (NaN where either is silent) and its wedges. */
+export interface BandDelta {
+  diff: number[];
+  wedges: BandWedge[];
+}
+
+/**
+ * The twin of omx_rta_bands.h's `omx_rta_band_delta`: POST − PRE of two tap readings' band levels (dB, silence
+ * -Infinity), NaN where either band is silent; then one wedge per pair of neighbouring bands whose larger |difference|
+ * reaches RTA_DELTA_DEADBAND_DB, none across a silent band: a boost when the pair sums to zero or more, else a cut, its
+ * strength the larger |difference| over EQ_GAIN_RANGE's maximum, clamped to 1. The two readings must have as many
+ * bands (a RangeError otherwise: the C has one count for both). Held to the kernel by vectors/rta-delta.json
+ * (test/rta-delta.test.mjs).
+ */
+export function bandDelta(preDb: readonly number[], postDb: readonly number[]): BandDelta {
+  const n = preDb.length;
+  if (postDb.length !== n) throw new RangeError(`bandDelta: ${n} PRE bands and ${postDb.length} POST bands`);
+  const diff = new Array<number>(n);
+  for (let i = 0; i < n; i++) {
+    const a = preDb[i]!;
+    const b = postDb[i]!;
+    diff[i] = !Number.isFinite(a) || !Number.isFinite(b) ? NaN : b - a;
+  }
+  const full = EQ_GAIN_RANGE.max;
+  const wedges: BandWedge[] = [];
+  for (let i = 0; i + 1 < n; i++) {
+    const d0 = diff[i]!;
+    const d1 = diff[i + 1]!;
+    if (Number.isNaN(d0) || Number.isNaN(d1)) continue;
+    const magnitude = Math.max(Math.abs(d0), Math.abs(d1));
+    if (magnitude < RTA_DELTA_DEADBAND_DB) continue;
+    const strength = magnitude / full;
+    wedges.push({ band: i, boost: d0 + d1 >= 0, strength: strength < 1 ? strength : 1 });
+  }
+  return { diff, wedges };
+}