gate: hysteresis + look-ahead merged from denoise-gate (delay-line emission, declared latency); deesser: mode 'band' dynamic peaking EQ merged from denoise-deesser — gate 0.1.4, deesser 0.2.3, umbrella 0.2.2

Author: dy

README.md

@@ -105,22 +105,24 @@ limiter(data, { ceiling: -1, lookahead: 10, release: 100 })
 
 ## gate
 
-Noise gate with hold-then-close logic. Below threshold, signal is attenuated by `range` dB. A `hold` timer keeps the gate open after a drop-out to avoid chatter; attack/release smooth the gain transitions.
+Noise gate with hysteresis, hold-then-close logic and look-ahead. Opens above `threshold`, closes only below `closeThreshold` (hysteresis prevents chatter around a single threshold); below it, signal is attenuated by `range` dB. A `hold` timer keeps the gate open after a drop-out; attack/release smooth the gain transitions. `lookahead` runs detection ahead of emission so the gate is already opening when a transient reaches the output — batch calls stay sample-aligned (no silence prefix, no dropped tail); block hosts get the delay declared as atom `latency`.
 
 ```js
 import { gate } from '@audio/dynamics'
 
 gate(data, { threshold: -40 })
-gate(data, { threshold: -35, range: -80, hold: 20, attack: 1, release: 150 })
+gate(data, { threshold: -35, range: -80, hold: 20, attack: 1, release: 150, lookahead: 5 })
 ```
 
 | Param | Default | |
 |---|---|---|
-| `threshold` | `-40` | dB |
+| `threshold` | `-40` | dB, open above |
+| `closeThreshold` | `threshold − 6` | dB, close below (hysteresis) |
 | `range` | `-60` | dB attenuation when closed |
 | `hold` | `10` | ms |
 | `attack` | `0.1` | ms (opening) |
 | `release` | `100` | ms (closing) |
+| `lookahead` | `0` | ms, detection leads emission |
 
 **Use when:** drum mics, voice dialogue with ambient noise, removing hiss between phrases.<br>
 **Not for:** subtle low-level reduction — use [expander](#expander).
@@ -151,26 +153,28 @@ expander(data, { threshold: -30, ratio: 2 })
 
 ## deesser
 
-Sibilance compressor. A biquad bandpass drives the envelope follower; the resulting gain reduction is applied broadband. Simple and transparent.
+Sibilance reduction, two architectures behind `mode`: **broadband** (default) — a biquad bandpass drives the envelope follower and the gain reduction is applied broadband; simple and transparent. **band** — an HP-filtered sidechain drives a dynamic peaking EQ at `freq`, so only the sibilance band is cut and program below it stays untouched even during deep reduction (wideband/split-band precedent).
 
 ```js
 import { deesser } from '@audio/dynamics'
 
 deesser(data, { freq: 6500, threshold: -20 })
 deesser(data, { freq: 5500, q: 3, threshold: -24, ratio: 6 })
+deesser(data, { mode: 'band', freq: 7000, threshold: -30, ratio: 8 })
 ```
 
 | Param | Default | |
 |---|---|---|
+| `mode` | `'broadband'` | `'broadband'` \| `'band'` |
 | `freq` | `6500` | Hz, sibilance center |
-| `q` | `2` | bandpass Q |
+| `q` | `2` | bandpass Q (broadband) / `1.4` peaking-cut Q (band) |
 | `threshold` | `-20` | dB (on sidechain level) |
 | `ratio` | `4` | — |
-| `knee` | `6` | dB |
+| `knee` | `6` | dB (broadband only) |
 | `attack` | `1` | ms |
 | `release` | `40` | ms |
 
-**Use when:** harsh 's' / 't' / 'sh' in close-miked voice, bright vocal takes.<br>
+**Use when:** harsh 's' / 't' / 'sh' in close-miked voice, bright vocal takes; `mode: 'band'` when the voice sits with program that must not pump.<br>
 **Not for:** broadband brightness — use an EQ. Generic compression — use [compressor](#compressor).
 
 
@@ -254,7 +258,7 @@ compand(data, {
 
 ## See also
 
-* [denoise](https://github.com/audiojs/denoise) — gate belongs here too; umbrella for everything noise
+* [denoise](https://github.com/audiojs/denoise) — umbrella for everything noise; its `gate`/`deesser` are seconds-unit adapters over this package (2026-07 near-dupe merge)
 * [filter](https://github.com/audiojs/filter) — biquads for deesser sidechain
 * [effect](https://github.com/audiojs/effect) — modulation effects
 * [stretch](https://github.com/audiojs/stretch) — sibling package

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@audio/dynamics",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "types": "index.d.ts",
   "description": "Dynamics processing — umbrella for @audio/dynamics-* atoms (compressor, limiter, gate, expander, de-esser, ducker, softclip, compand, transient shaper)",

package.json

@@ -1,13 +1,15 @@
 // atom manifest — wraps the de-esser kernel per @audio/compile CONTRACT.
-// Bandpass sidechain drives broadband gain reduction; all params seed the
-// stream at construction (flags: restart).
+// `mode` picks the architecture: broadband (bandpass sidechain → broadband
+// gain reduction) or band (HP sidechain → dynamic peaking-EQ cut at freq).
+// All params seed the stream at construction (flags: restart).
 
 import { deesserStream } from './deesser.js'
 
 export const deesser = (ctx) => {
 	const streams = []
 	const opts = {
 		sampleRate: ctx.sampleRate,
+		mode: ctx.params.mode,
 		freq: ctx.params.freq[0],
 		q: ctx.params.q[0],
 		threshold: ctx.params.threshold[0],
@@ -25,6 +27,7 @@ export const deesser = (ctx) => {
 }
 deesser.channels = 'any'
 deesser.params = {
+	mode:      { type: 'enum', values: ['broadband', 'band'], default: 'broadband', flags: ['restart'] },
 	freq:      { type: 'number', min: 2000, max: 16000, default: 6500, unit: 'Hz', flags: ['restart'] },
 	q:         { type: 'number', min: 0.3, max: 10, default: 2, flags: ['restart'] },
 	threshold: { type: 'number', min: -60, max: 0, default: -20, unit: 'dB', flags: ['restart'] },

packages/dynamics-deesser/audio.js

@@ -1,17 +1,25 @@
 import { envelope } from '@audio/dynamics-envelope'
-import { bandpass, step, state } from '@audio/biquad'
+import { bandpass, highpass, peaking, step, state, process as biquad } from '@audio/biquad'
 import { compressorGain } from '@audio/dynamics-compressor'
 import { writer, concat, db2lin, lin2db } from './util.js'
 
-// De-esser: bandpass sidechain (sibilance band) drives a compressor whose gain
-// reduction is applied broadband — simple and transparent.
+// De-esser — two canonical architectures behind one entry, picked by `mode`:
+//  - broadband (default): bandpass sidechain (sibilance band) drives a
+//    compressor whose gain reduction is applied broadband — simple, transparent.
+//  - band: HP-filtered sidechain drives a dynamic peaking EQ at `freq` — only
+//    the sibilance band is cut, so program below the band stays untouched even
+//    during deep reduction (wideband/split-band precedent).
 export default function deesser(data, opts) {
   if (!(data instanceof Float32Array)) return writer(deesserStream(data))
   let s = deesserStream(opts)
   return concat(s.write(data), s.flush())
 }
 
 export function deesserStream(opts = {}) {
+  return (opts.mode ?? 'broadband') === 'band' ? bandStream(opts) : broadbandStream(opts)
+}
+
+function broadbandStream(opts = {}) {
   let sr = opts.sampleRate || 44100
   let freq = opts.freq ?? 6500
   let q = opts.q ?? 2
@@ -37,3 +45,58 @@ export function deesserStream(opts = {}) {
     flush() { return new Float32Array(0) }
   }
 }
+
+// Dynamic peaking-EQ de-esser: detection runs on an HP copy (above `freq`);
+// when the envelope exceeds threshold, a negative peaking gain at `freq`
+// engages on the audio path. EQ gain follows the envelope continuously —
+// recomputed every `block` samples for smoothness without per-sample coef
+// cost. Unlike a static shelf, the cut only engages on loud 's' / 'sh'
+// events, so dark consonants aren't thinned.
+function bandStream(opts = {}) {
+  let sr = opts.sampleRate || 44100
+  let freq = opts.freq ?? 6500
+  let q = opts.q ?? 1.4
+  let threshold = opts.threshold ?? -20
+  let ratio = opts.ratio ?? 4
+  let attackMs = opts.attack ?? 1
+  let releaseMs = opts.release ?? 40
+  let block = opts.block ?? 64
+
+  let scC = highpass(freq, 0.707, sr)
+  let scS = state()
+  let eqS = state()
+  let aA = Math.exp(-1 / (attackMs * 0.001 * sr))
+  let aR = Math.exp(-1 / (releaseMs * 0.001 * sr))
+  // EQ-gain smoothing runs once per block, so its coefficients are per-block:
+  // deepening the cut follows `attack`, recovering follows `release`.
+  let aBlkA = Math.exp(-block / (attackMs * 0.001 * sr))
+  let aBlkR = Math.exp(-block / (releaseMs * 0.001 * sr))
+  let thLin = db2lin(threshold)
+  let env = 0, eqDb = 0
+
+  return {
+    write(chunk) {
+      let out = new Float32Array(chunk.length)
+      out.set(chunk)
+      let sc = new Float32Array(chunk.length)
+      sc.set(chunk)
+      biquad(sc, scC, scS)
+      for (let pos = 0; pos < out.length; pos += block) {
+        let end = Math.min(out.length, pos + block)
+        // update envelope across block, take peak
+        let peakEnv = env
+        for (let i = pos; i < end; i++) {
+          let x = Math.abs(sc[i])
+          env = x > env ? aA * env + (1 - aA) * x : aR * env + (1 - aR) * x
+          if (env > peakEnv) peakEnv = env
+        }
+        let target = 0
+        if (peakEnv > thLin) target = -lin2db(peakEnv / thLin) * (1 - 1 / ratio)  // negative dB cut
+        eqDb = target < eqDb ? aBlkA * eqDb + (1 - aBlkA) * target : aBlkR * eqDb + (1 - aBlkR) * target
+        biquad(out.subarray(pos, end), peaking(freq, q, sr, eqDb), eqS)
+      }
+      return out
+    },
+    flush() { return new Float32Array(0) }
+  }
+}

packages/dynamics-deesser/deesser.js

@@ -1,6 +1,6 @@
 {
   "name": "@audio/dynamics-deesser",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "De-esser: bandpass sidechain (sibilance band) drives a compressor whose gain",
   "type": "module",
   "sideEffects": false,