@jpdutoit/squelchy 0.0.4 → 0.0.6

package/index.js

@@ -2,12 +2,14 @@ import {
   adsr_envelope_default,
   bitcrusher_default,
   comb_filter_default,
+  compressor_default,
   env_follower_default,
   fdn_reverb_default,
   flanger_default,
   formant_table_default,
   freq_divider_default,
   freq_shifter_default,
+  gate_default,
   glide_default,
   ladder_filter_default,
   map_res_default,
@@ -15,12 +17,14 @@ import {
   map_voct_to_period_default,
   ping_pong_default,
   pitch_shifter_default,
+  shaper_default,
   spring_reverb_default,
   tape_delay_default,
   tape_stop_default,
   vca_default,
+  vinyl_noise_default,
   waveshaper_default
-} from "./chunk-N7J25N5J.js";
+} from "./chunk-PJDNZ52Q.js";
 
 // src/lib-runtime/core.ts
 var pendingSources = {};
@@ -28,7 +32,7 @@ var registrations = /* @__PURE__ */ new WeakMap();
 function preload(ctx, opts) {
   const existing = registrations.get(ctx);
   if (existing) return existing;
-  const sources = opts?.allWorklets ? import("./worklets-inline-EF3OTQ4D.js").then((m) => m.WORKLET_SOURCES) : Promise.resolve(pendingSources);
+  const sources = opts?.allWorklets ? import("./worklets-inline-NWG5PWND.js").then((m) => m.WORKLET_SOURCES) : Promise.resolve(pendingSources);
   const promise = sources.then(
     (map) => Promise.all(Object.entries(map).map(async ([name, src]) => {
       const url = URL.createObjectURL(new Blob([src], { type: "text/javascript" }));
@@ -180,26 +184,29 @@ function createTransport(ctx, opts = {}) {
     if (at === "now") return now2;
     if (at === "beat") return Math.ceil(now2 - EPS);
     if (at === "bar") return Math.ceil(now2 / beatsPerBar - EPS) * beatsPerBar;
-    if ("bar" in at) return at.bar * beatsPerBar;
+    if ("bar" in at) return at.bar * beatsPerBar + (at.beat ?? 0);
     return at.beat;
   }
   const latency = () => ctx.outputLatency || ctx.baseLatency || 0;
-  function emitTap(hit, local) {
-    if (!local && taps.size === 0) return;
-    const fire = () => {
-      local?.(hit);
-      for (const cb of taps) cb(hit);
-    };
+  function whenAudible(time, fire) {
     if (offline) {
       fire();
-      return;
+      return void 0;
     }
-    const delay = Math.max(0, (hit.time - ctx.currentTime + latency()) * 1e3);
+    const delay = Math.max(0, (time - ctx.currentTime + latency()) * 1e3);
     const id = setTimeout(() => {
       tapTimers.delete(id);
       fire();
     }, delay);
     tapTimers.add(id);
+    return id;
+  }
+  function emitTap(hit, local) {
+    if (!local && taps.size === 0) return;
+    whenAudible(hit.time, () => {
+      local?.(hit);
+      for (const cb of taps) cb(hit);
+    });
   }
   function horizonBeat() {
     if (offline) return beatAt(ctx.length / ctx.sampleRate);
@@ -320,16 +327,20 @@ function createTransport(ctx, opts = {}) {
         }
       };
     },
-    at(when, fn) {
+    at(when, fn, o = {}) {
       const b = typeof when === "number" ? when : resolve(when);
       let fired = false;
+      let audibleTimer;
       const job = {
         nextBeat: () => b,
         run(until) {
           if (fired) return false;
           if (b < until) {
             fired = true;
-            fn(timeAt(b));
+            const time = timeAt(b);
+            fn(time);
+            const onAudible = o.onAudible;
+            if (onAudible) audibleTimer = whenAudible(time, () => onAudible(time));
             return false;
           }
           return true;
@@ -340,6 +351,10 @@ function createTransport(ctx, opts = {}) {
       return () => {
         fired = true;
         jobs.delete(job);
+        if (audibleTimer !== void 0) {
+          clearTimeout(audibleTimer);
+          tapTimers.delete(audibleTimer);
+        }
       };
     },
     onHit(cb) {
@@ -491,20 +506,27 @@ var NoteCv = {
     const pitch = ctx.createConstantSource();
     pitch.offset.value = 60;
     pitch.start();
+    const velocity = ctx.createConstantSource();
+    velocity.offset.value = 0;
+    velocity.start();
     return {
       gate,
       pitch,
+      velocity,
       trigger(time, h) {
         if (typeof h?.value === "number") pitch.offset.setValueAtTime(h.value, time);
-        gate.offset.setValueAtTime(0, Math.max(0, time - 1 / ctx.sampleRate));
-        gate.offset.setValueAtTime(vel(h), time);
+        velocity.offset.setValueAtTime(vel(h), time);
+        const edge = Math.max(0, time - 1 / ctx.sampleRate);
+        gate.offset.cancelScheduledValues(edge);
+        gate.offset.setValueAtTime(0, edge);
+        gate.offset.setValueAtTime(1, time);
         gate.offset.setValueAtTime(0, time + (h?.duration ?? 0.1));
       },
       dispose() {
-        gate.stop();
-        pitch.stop();
-        gate.disconnect();
-        pitch.disconnect();
+        for (const n of [gate, pitch, velocity]) {
+          n.stop();
+          n.disconnect();
+        }
       }
     };
   }
@@ -604,8 +626,9 @@ async function loadSampleSet(ctx, set, opts = {}) {
 var SampleVoice = {
   create(ctx, kit, key, opts = {}) {
     const out = ctx.createGain();
-    const buf = kit.buffer(key);
     const root = opts.root ?? 60;
+    let current = kit;
+    let buf = kit.buffer(key);
     const trigger = (when, h) => {
       if (!buf) return;
       const src = ctx.createBufferSource();
@@ -619,6 +642,13 @@ var SampleVoice = {
     return {
       output: out,
       trigger,
+      get kit() {
+        return current;
+      },
+      setKit(next) {
+        current = next;
+        buf = next.buffer(key);
+      },
       connect: (d) => {
         out.connect(d);
         return d;
@@ -679,14 +709,33 @@ function createFormantNode(ctx) {
   return new AudioWorkletNode(ctx, "formant-table", {
     numberOfInputs: 1,
     numberOfOutputs: 1,
-    outputChannelCount: [5]
+    outputChannelCount: [11]
+  });
+}
+function createShaperNode(ctx, curve, opts = {}) {
+  return new AudioWorkletNode(ctx, "shaper", {
+    numberOfInputs: 2,
+    numberOfOutputs: 2,
+    channelCount: 2,
+    channelCountMode: "clamped-max",
+    outputChannelCount: [2, 2],
+    processorOptions: { curve, dry: opts.dry !== false }
+  });
+}
+function createVinylNoiseNode(ctx, seed) {
+  return new AudioWorkletNode(ctx, "vinyl-noise", {
+    numberOfInputs: 0,
+    numberOfOutputs: 1,
+    outputChannelCount: [1],
+    processorOptions: { seed }
   });
 }
 function createBitcrusherNode(ctx) {
   return new AudioWorkletNode(ctx, "bitcrusher", {
     numberOfInputs: 1,
     numberOfOutputs: 1,
-    outputChannelCount: [1]
+    channelCount: 2,
+    channelCountMode: "clamped-max"
   });
 }
 function createSubOctaveNode(ctx) {
@@ -703,6 +752,27 @@ function createEnvFollowerNode(ctx) {
     outputChannelCount: [1]
   });
 }
+function createGateNode(ctx) {
+  return new AudioWorkletNode(ctx, "gate", {
+    numberOfInputs: 2,
+    numberOfOutputs: 1,
+    outputChannelCount: [2],
+    channelCount: 2,
+    channelCountMode: "clamped-max",
+    channelInterpretation: "speakers"
+  });
+}
+function createCompressorNode(ctx, init) {
+  return new AudioWorkletNode(ctx, "compressor", {
+    numberOfInputs: 2,
+    numberOfOutputs: 1,
+    outputChannelCount: [2],
+    channelCount: 2,
+    channelCountMode: "clamped-max",
+    channelInterpretation: "speakers",
+    parameterData: init
+  });
+}
 function createWaveshaperNode(ctx) {
   return new AudioWorkletNode(ctx, "waveshaper", {
     numberOfInputs: 1,
@@ -908,7 +978,7 @@ var filter303Descriptor = /* @__PURE__ */ defineDescriptor({
     const envDepth = ctx.createGain();
     envDepth.gain.value = module.envMod * (1 + module.accent) * 36;
     const accentEnvGain = ctx.createGain();
-    accentEnvGain.gain.value = module.accent * 0.5;
+    accentEnvGain.gain.value = module.accent * 1;
     input.connect(filter1);
     filter1.connect(filter2);
     filter2.connect(accentVCA);
@@ -938,7 +1008,7 @@ var filter303Descriptor = /* @__PURE__ */ defineDescriptor({
       case "accent": {
         const acc = value;
         nodes.envDepth.gain.value = module.envMod * (1 + acc) * 36;
-        nodes.accentEnvGain.gain.value = acc * 0.5;
+        nodes.accentEnvGain.gain.value = acc * 1;
         break;
       }
       case "decay": {
@@ -964,8 +1034,9 @@ var AcidFilter = /* @__PURE__ */ defineModule(filter303Descriptor, {
 
 // src/lib-runtime/generated/modules/auto-pan.tsx
 var shapes = ["sine", "triangle", "square"];
+var SHAPE_VALUE = { square: -1, triangle: 0, sine: 1 };
 var params2 = {
-  rate: { node: "lfo", field: "frequency", unit: "Hz", default: 2, min: 0.1, max: 10 },
+  rate: { node: "_freqSrc", field: "offset", unit: "Hz", default: 2, min: 0.1, max: 10 },
   depth: { node: "lfoGain", field: "gain", unit: "factor", default: 0.8, min: 0, max: 1 },
   shape: { kind: "enum", options: shapes, default: "sine" }
 };
@@ -975,7 +1046,7 @@ var autoPanDescriptor = /* @__PURE__ */ defineDescriptor({
   ports: {
     "in": { type: "input", signal: "audio", node: "input" },
     "out": { type: "output", signal: "audio", node: "output" },
-    "modRate": { type: "modulation", signal: "modulation", node: "lfo", field: "frequency" },
+    "modRate": { type: "modulation", signal: "modulation", node: "_freqSrc", field: "offset" },
     "modDepth": { type: "modulation", signal: "modulation", node: "lfoGain", field: "gain" }
   },
   createModule(id, position) {
@@ -985,34 +1056,41 @@ var autoPanDescriptor = /* @__PURE__ */ defineDescriptor({
     const input = ctx.createGain();
     const panner = ctx.createStereoPanner();
     const output = ctx.createGain();
-    const lfo = ctx.createOscillator();
+    const _ws = createWaveshaperNode(ctx);
+    const _freqSrc = ctx.createConstantSource();
+    _freqSrc.offset.value = module.rate;
+    _freqSrc.start();
+    _freqSrc.connect(_ws);
+    _ws.parameters.get("skew").value = 0;
+    _ws.parameters.get("shape").value = SHAPE_VALUE[module.shape];
     const lfoGain = ctx.createGain();
-    lfo.type = module.shape;
-    lfo.frequency.value = module.rate;
     lfoGain.gain.value = module.depth;
-    lfo.connect(lfoGain);
+    _ws.connect(lfoGain);
     lfoGain.connect(panner.pan);
-    lfo.start();
     input.connect(panner);
     panner.connect(output);
-    return { input, output, lfo, lfoGain };
+    return { input, output, _ws, _freqSrc, lfoGain };
   },
   updateParam(nodes, _m, param, value) {
     if (param === "rate") {
-      nodes.lfo.frequency.value = value;
+      nodes._freqSrc.offset.value = value;
     } else if (param === "depth") {
       nodes.lfoGain.gain.value = value;
     } else if (param === "shape") {
-      nodes.lfo.type = value;
+      nodes._ws.parameters.get("shape").value = SHAPE_VALUE[value];
     }
   },
   dispose(nodes) {
-    nodes.lfo.stop();
+    nodes._freqSrc.stop();
   }
 });
 
 // src/lib-runtime/generated/modules/auto-pan.wrapper.ts
-var AutoPan = /* @__PURE__ */ defineModule(autoPanDescriptor);
+var AutoPan = /* @__PURE__ */ defineModule(autoPanDescriptor, {
+  worklets: {
+    "waveshaper": waveshaper_default
+  }
+});
 
 // src/lib/dsp/mix.ts
 var CURVE_POINTS = 2049;
@@ -1064,7 +1142,10 @@ var bitcrusherDescriptor = /* @__PURE__ */ defineDescriptor({
   params: params3,
   ports: {
     "in": { type: "input", signal: "audio", node: "input" },
-    "out": { type: "output", signal: "audio", node: "output" }
+    "out": { type: "output", signal: "audio", node: "output" },
+    "modBits": { type: "modulation", signal: "modulation", node: "crusher", field: "bits" },
+    "modRate": { type: "modulation", signal: "modulation", node: "crusher", field: "rate" },
+    "modMix": { type: "modulation", signal: "modulation", node: "_mix", field: "offset" }
   },
   createModule(id, position) {
     return { id, type: "bitcrusher", position, ...paramDefaults(params3) };
@@ -1105,6 +1186,8 @@ var Bitcrusher = /* @__PURE__ */ defineModule(bitcrusherDescriptor, {
 });
 
 // src/lib-runtime/generated/modules/chorus.tsx
+var CENTRE_S = 566e-5;
+var SWING_S = 4e-3;
 var params4 = {
   rate: { node: "lfo", field: "frequency", unit: "Hz", default: 1.5, min: 0.1, max: 5 },
   depth: { unit: "factor", default: 0.5, min: 0, max: 1 },
@@ -1137,8 +1220,8 @@ var chorusDescriptor = /* @__PURE__ */ defineDescriptor({
     const lfoGain = ctx.createGain();
     const lfoInv = ctx.createGain();
     const merger = ctx.createChannelMerger(2);
-    delayL.delayTime.value = 0.02;
-    delayR.delayTime.value = 0.02;
+    delayL.delayTime.value = CENTRE_S;
+    delayR.delayTime.value = CENTRE_S;
     const _mix = ctx.createConstantSource();
     _mix.offset.value = module.mix;
     dryGain.gain.value = 1;
@@ -1150,7 +1233,7 @@ var chorusDescriptor = /* @__PURE__ */ defineDescriptor({
     _mix.start();
     lfo.type = "sine";
     lfo.frequency.value = module.rate;
-    lfoGain.gain.value = module.depth * 0.01;
+    lfoGain.gain.value = module.depth * SWING_S;
     lfoInv.gain.value = -1;
     lfo.connect(lfoGain);
     lfoGain.connect(delayL.delayTime);
@@ -1174,7 +1257,7 @@ var chorusDescriptor = /* @__PURE__ */ defineDescriptor({
         nodes.lfo.frequency.value = value;
         break;
       case "depth":
-        nodes.lfoGain.gain.value = value * 0.01;
+        nodes.lfoGain.gain.value = value * SWING_S;
         break;
       case "mix":
         nodes._mix.offset.value = value;
@@ -1287,62 +1370,59 @@ var CombFilter = /* @__PURE__ */ defineModule(combFilterDescriptor, {
 var params6 = {
   threshold: { node: "comp", field: "threshold", unit: "dB", default: -24, min: -60, max: 0 },
   ratio: { node: "comp", field: "ratio", unit: "factor", default: 4, min: 1, max: 20, scale: "log" },
-  attack: { node: "comp", field: "attack", unit: "s", default: 3e-3, min: 1e-3, max: 1, scale: "log" },
+  attack: { node: "comp", field: "attack", unit: "s", default: 3e-3, min: 1e-4, max: 1, scale: "log" },
   release: { node: "comp", field: "release", unit: "s", default: 0.25, min: 0.01, max: 1, scale: "log" },
   knee: { node: "comp", field: "knee", unit: "dB", default: 10, min: 0, max: 40 },
-  // makeup is stored in dB but drives a linear gain node (Math.pow(10, v/20)) —
-  // not a 1:1 AudioParam mapping, so no node/field.
-  makeup: { unit: "dB", default: 0, min: 0, max: 30 }
+  makeup: { node: "comp", field: "makeup", unit: "dB", default: 0, min: 0, max: 30 },
+  // A switch, not jack sensing: the browser reports an input as empty
+  // whenever its source stops (e.g. between drum samples). See compressor.ts.
+  keySource: { kind: "enum", options: ["internal", "external"], default: "internal" }
 };
 var compressorDescriptor = /* @__PURE__ */ defineDescriptor({
   type: "compressor",
   params: params6,
   ports: {
     "in": { type: "input", signal: "audio", node: "comp" },
-    "out": { type: "output", signal: "audio", node: "makeup" }
+    "key": { type: "input", signal: "audio", node: "_keyIn" },
+    "out": { type: "output", signal: "audio", node: "comp" }
   },
   createModule(id, position) {
-    return { id, type: "compressor", position, ...paramDefaults(params6) };
+    return { id, type: "compressor", position, timeUnit: "tau", ...paramDefaults(params6) };
   },
+  // One worklet does detection, gain computing, smoothing and makeup — every
+  // knob is one of its AudioParams, 1:1. See src/worklets/compressor.ts.
   createNodes(ctx, module) {
-    const comp = ctx.createDynamicsCompressor();
-    comp.threshold.value = module.threshold;
-    comp.ratio.value = module.ratio;
-    comp.attack.value = module.attack;
-    comp.release.value = module.release;
-    comp.knee.value = module.knee;
-    const makeup = ctx.createGain();
-    makeup.gain.value = Math.pow(10, (module.makeup || 0) / 20);
-    comp.connect(makeup);
-    return { comp, makeup };
+    const comp = createCompressorNode(ctx, {
+      threshold: module.threshold,
+      ratio: module.ratio,
+      attack: module.attack,
+      release: module.release,
+      knee: module.knee,
+      makeup: module.makeup ?? 0,
+      keyExt: module.keySource === "external" ? 1 : 0
+    });
+    const _keyIn = ctx.createGain();
+    _keyIn.channelCount = 2;
+    _keyIn.channelCountMode = "clamped-max";
+    _keyIn.connect(comp, 0, 1);
+    return { comp, _keyIn };
   },
   updateParam(nodes, _m, param, value) {
-    const v = value;
-    switch (param) {
-      case "threshold":
-        nodes.comp.threshold.value = v;
-        break;
-      case "ratio":
-        nodes.comp.ratio.value = v;
-        break;
-      case "attack":
-        nodes.comp.attack.value = v;
-        break;
-      case "release":
-        nodes.comp.release.value = v;
-        break;
-      case "knee":
-        nodes.comp.knee.value = v;
-        break;
-      case "makeup":
-        nodes.makeup.gain.value = Math.pow(10, v / 20);
-        break;
+    if (param === "keySource") {
+      nodes.comp.parameters.get("keyExt").value = value === "external" ? 1 : 0;
+      return;
     }
+    const p = nodes.comp.parameters.get(param);
+    if (p) p.value = value;
   }
 });
 
 // src/lib-runtime/generated/modules/comp.wrapper.ts
-var Compressor = /* @__PURE__ */ defineModule(compressorDescriptor);
+var Compressor = /* @__PURE__ */ defineModule(compressorDescriptor, {
+  worklets: {
+    "compressor": compressor_default
+  }
+});
 
 // src/lib-runtime/generated/modules/crossfade.tsx
 var params7 = {
@@ -1469,7 +1549,19 @@ var Delay = /* @__PURE__ */ defineModule(delayDescriptor, {
 });
 
 // src/lib-runtime/generated/modules/dimension.tsx
+var CENTER_S = 35e-4;
+var SWING_S2 = 185e-5;
+var WET = 0.5;
+var CROSS_HPF_HZ = 200;
+var BUTTERWORTH_Q_DB = -3.0102999566;
+function setWidth(n, w) {
+  n.llGain.gain.value = (1 + w) / 2;
+  n.rrGain.gain.value = (1 + w) / 2;
+  n.rlGain.gain.value = (1 - w) / 2;
+  n.lrGain.gain.value = (1 - w) / 2;
+}
 var params9 = {
+  width: { unit: "factor", default: 1.5, min: 0, max: 2 },
   rate: { node: "lfo", field: "frequency", unit: "Hz", default: 0.5, min: 0.1, max: 5 },
   depth: { unit: "factor", default: 0.3, min: 0, max: 1 }
 };
@@ -1484,6 +1576,24 @@ var dimensionDescriptor = /* @__PURE__ */ defineDescriptor({
   createModule(id, position) {
     return { id, type: "dimension", position, ...paramDefaults(params9) };
   },
+  // Roland SDD-320 topology (Haible's service-schematic description, HSR 1984
+  // review, pendragon-andyh's Juno-60 BBD analysis — see
+  // reports/expectations/discussion/dimension.md): the dry signal anchors
+  // both outputs; each BBD line is mixed in phase into its own channel and
+  // inverted into the other, with the low end kept out of the cancellation.
+  // Two short BBD-range lines (1.65–5.35 ms at full DEPTH) swept by ONE
+  // triangle LFO in antiphase. Written out, that matrix is
+  //   A = dry_L + WET·HP(bbdA − bbdB),   B = dry_R − WET·HP(bbdA − bbdB)
+  // i.e. the moving DIFFERENCE of the two lines becomes side signal. Nothing
+  // reaches the mid, so there is no vibrato and the mono sum is exactly the
+  // dry input (the hardware's famed mono compatibility); the bass stays dry
+  // and centred. HP is a Linkwitz-Riley 4th-order low-cut at 200 Hz; since
+  // the side enters A and B in opposite polarity, the mono sum cancels it
+  // whatever its phase, so a steep filter costs no mono compatibility.
+  // Previously the module was 100% wet — two 10/12 ms modulated delays, i.e.
+  // a stereo vibrato with 10 ms of latency and nothing anchoring pitch.
+  // WIDTH then scales the side of (A, B): L = M + w·S, R = M − w·S, so
+  // 0 = mono, 1 = the hardware matrix, 2 = exaggerated.
   createNodes(ctx, module) {
     const input = ctx.createGain();
     input.channelCount = 2;
@@ -1497,51 +1607,62 @@ var dimensionDescriptor = /* @__PURE__ */ defineDescriptor({
     const lfo = ctx.createOscillator();
     const lfoGainL = ctx.createGain();
     const lfoGainR = ctx.createGain();
+    const invB = ctx.createGain();
+    invB.gain.value = -1;
+    const diff = ctx.createGain();
+    const hp1 = ctx.createBiquadFilter();
+    hp1.type = "highpass";
+    hp1.frequency.value = CROSS_HPF_HZ;
+    hp1.Q.value = BUTTERWORTH_Q_DB;
+    const hp2 = ctx.createBiquadFilter();
+    hp2.type = "highpass";
+    hp2.frequency.value = CROSS_HPF_HZ;
+    hp2.Q.value = BUTTERWORTH_Q_DB;
+    const side = ctx.createGain();
+    side.gain.value = WET;
+    const sideInv = ctx.createGain();
+    sideInv.gain.value = -1;
+    const aSum = ctx.createGain();
+    const bSum = ctx.createGain();
     const llGain = ctx.createGain();
     const lrGain = ctx.createGain();
     const rlGain = ctx.createGain();
     const rrGain = ctx.createGain();
-    const w = module.width;
-    llGain.gain.value = (1 + w) / 2;
-    rrGain.gain.value = (1 + w) / 2;
-    rlGain.gain.value = (1 - w) / 2;
-    lrGain.gain.value = (1 - w) / 2;
-    leftDelay.delayTime.value = 0.01;
-    rightDelay.delayTime.value = 0.012;
-    lfo.type = "sine";
+    setWidth({ llGain, lrGain, rlGain, rrGain }, module.width);
+    leftDelay.delayTime.value = CENTER_S;
+    rightDelay.delayTime.value = CENTER_S;
+    lfo.type = "triangle";
     lfo.frequency.value = module.rate;
-    lfoGainL.gain.value = module.depth * 2e-3;
-    lfoGainR.gain.value = -module.depth * 2e-3;
+    lfoGainL.gain.value = module.depth * SWING_S2;
+    lfoGainR.gain.value = -module.depth * SWING_S2;
     lfo.connect(lfoGainL);
     lfo.connect(lfoGainR);
     lfoGainL.connect(leftDelay.delayTime);
     lfoGainR.connect(rightDelay.delayTime);
     lfo.start();
     input.connect(splitter);
+    splitter.connect(aSum, 0);
+    splitter.connect(bSum, 1);
     splitter.connect(leftDelay, 0);
     splitter.connect(rightDelay, 1);
-    leftDelay.connect(llGain);
-    leftDelay.connect(lrGain);
-    rightDelay.connect(rrGain);
-    rightDelay.connect(rlGain);
-    llGain.connect(merger, 0, 0);
-    rlGain.connect(merger, 0, 0);
-    lrGain.connect(merger, 0, 1);
-    rrGain.connect(merger, 0, 1);
+    leftDelay.connect(diff);
+    rightDelay.connect(invB).connect(diff);
+    diff.connect(hp1).connect(hp2).connect(side);
+    side.connect(aSum);
+    side.connect(sideInv).connect(bSum);
+    aSum.connect(llGain).connect(merger, 0, 0);
+    aSum.connect(lrGain).connect(merger, 0, 1);
+    bSum.connect(rlGain).connect(merger, 0, 0);
+    bSum.connect(rrGain).connect(merger, 0, 1);
     merger.connect(output);
-    return { input, output, splitter, merger, leftDelay, rightDelay, lfo, lfoGainL, lfoGainR, llGain, rrGain, lrGain, rlGain };
+    return { input, output, splitter, merger, leftDelay, rightDelay, lfo, lfoGainL, lfoGainR, invB, diff, hp1, hp2, side, sideInv, aSum, bSum, llGain, rrGain, lrGain, rlGain };
   },
   updateParam(nodes, _m, param, value) {
-    if (param === "width") {
-      const w = value;
-      nodes.llGain.gain.value = (1 + w) / 2;
-      nodes.rrGain.gain.value = (1 + w) / 2;
-      nodes.rlGain.gain.value = (1 - w) / 2;
-      nodes.lrGain.gain.value = (1 - w) / 2;
-    } else if (param === "rate") nodes.lfo.frequency.value = value;
+    if (param === "width") setWidth(nodes, value);
+    else if (param === "rate") nodes.lfo.frequency.value = value;
     else if (param === "depth") {
-      nodes.lfoGainL.gain.value = value * 2e-3;
-      nodes.lfoGainR.gain.value = -value * 2e-3;
+      nodes.lfoGainL.gain.value = value * SWING_S2;
+      nodes.lfoGainR.gain.value = -value * SWING_S2;
     }
   },
   dispose(nodes) {
@@ -1613,12 +1734,10 @@ var distortionDescriptor = /* @__PURE__ */ defineDescriptor({
     const output = ctx.createGain();
     const dryGain = ctx.createGain();
     const wetGain = ctx.createGain();
-    const waveshaper = ctx.createWaveShaper();
+    const waveshaper = createShaperNode(ctx, makeDistortionCurve(module.distortionType, module.drive));
     const makeup = ctx.createGain();
     const dcBlock = ctx.createBiquadFilter();
     const toneFilter = ctx.createBiquadFilter();
-    waveshaper.curve = makeDistortionCurve(module.distortionType, module.drive);
-    waveshaper.oversample = "4x";
     makeup.gain.value = computeMakeup(module.distortionType, module.drive);
     dcBlock.type = "highpass";
     dcBlock.frequency.value = 10;
@@ -1627,9 +1746,9 @@ var distortionDescriptor = /* @__PURE__ */ defineDescriptor({
     toneFilter.frequency.value = module.frequency;
     toneFilter.Q.value = 0.707;
     const _mix = createMix(ctx, dryGain, wetGain, module.mix, "linear");
-    input.connect(dryGain);
     input.connect(waveshaper);
-    waveshaper.connect(makeup);
+    waveshaper.connect(dryGain, 1);
+    waveshaper.connect(makeup, 0);
     makeup.connect(dcBlock);
     dcBlock.connect(toneFilter);
     toneFilter.connect(wetGain);
@@ -1639,7 +1758,7 @@ var distortionDescriptor = /* @__PURE__ */ defineDescriptor({
   },
   updateParam(nodes, module, param, value) {
     if (param === "drive" || param === "distortionType") {
-      nodes.waveshaper.curve = makeDistortionCurve(module.distortionType, module.drive);
+      nodes.waveshaper.port.postMessage({ curve: makeDistortionCurve(module.distortionType, module.drive) });
       nodes.makeup.gain.value = computeMakeup(module.distortionType, module.drive);
     }
     if (param === "frequency") {
@@ -1652,7 +1771,11 @@ var distortionDescriptor = /* @__PURE__ */ defineDescriptor({
 });
 
 // src/lib-runtime/generated/modules/distortion.wrapper.ts
-var Distortion = /* @__PURE__ */ defineModule(distortionDescriptor);
+var Distortion = /* @__PURE__ */ defineModule(distortionDescriptor, {
+  worklets: {
+    "shaper": shaper_default
+  }
+});
 
 // src/lib-runtime/generated/modules/ducker.tsx
 var params11 = {
@@ -1954,22 +2077,21 @@ var exciterDescriptor = /* @__PURE__ */ defineDescriptor({
     const dryGain = ctx.createGain();
     const wetGain = ctx.createGain();
     const highpass = ctx.createBiquadFilter();
-    const saturation = ctx.createWaveShaper();
+    const saturation = createShaperNode(ctx, makeExciterCurve(module.drive));
     const highshelf = ctx.createBiquadFilter();
     highpass.type = "highpass";
     highpass.frequency.value = module.frequency;
     highpass.Q.value = 0.7;
-    saturation.curve = makeExciterCurve(module.drive);
-    saturation.oversample = "2x";
     highshelf.type = "highshelf";
     highshelf.frequency.value = module.frequency;
     highshelf.gain.value = 6 + module.drive * 6;
     dryGain.gain.value = 1;
     wetGain.gain.value = module.mix;
-    input.connect(dryGain);
+    input.connect(saturation, 0, 1);
+    saturation.connect(dryGain, 1);
     input.connect(highpass);
-    highpass.connect(saturation);
-    saturation.connect(highshelf);
+    highpass.connect(saturation, 0, 0);
+    saturation.connect(highshelf, 0);
     highshelf.connect(wetGain);
     dryGain.connect(output);
     wetGain.connect(output);
@@ -1977,7 +2099,7 @@ var exciterDescriptor = /* @__PURE__ */ defineDescriptor({
   },
   updateParam(nodes, _m, param, value) {
     if (param === "drive") {
-      nodes.saturation.curve = makeExciterCurve(value);
+      nodes.saturation.port.postMessage({ curve: makeExciterCurve(value) });
       nodes.highshelf.gain.value = 6 + value * 6;
     } else if (param === "frequency") {
       nodes.highpass.frequency.value = value;
@@ -1989,7 +2111,11 @@ var exciterDescriptor = /* @__PURE__ */ defineDescriptor({
 });
 
 // src/lib-runtime/generated/modules/exciter.wrapper.ts
-var Exciter = /* @__PURE__ */ defineModule(exciterDescriptor);
+var Exciter = /* @__PURE__ */ defineModule(exciterDescriptor, {
+  worklets: {
+    "shaper": shaper_default
+  }
+});
 
 // src/lib-runtime/generated/modules/flanger.tsx
 var params16 = {
@@ -2057,7 +2183,7 @@ var Flanger = /* @__PURE__ */ defineModule(flangerDescriptor, {
 // src/lib-runtime/generated/modules/formant.tsx
 var params17 = {
   morph: { unit: "factor", default: 0, min: 0, max: 5 },
-  resonance: { unit: "factor", default: 6, min: 1, max: 20, scale: "sqrt" },
+  resonance: { node: "formantWorklet", field: "resonance", unit: "factor", default: 6, min: 1, max: 20, scale: "sqrt" },
   mix: { unit: "factor", default: 1, min: 0, max: 1 }
 };
 var formantDescriptor = /* @__PURE__ */ defineDescriptor({
@@ -2076,75 +2202,54 @@ var formantDescriptor = /* @__PURE__ */ defineDescriptor({
     const output = ctx.createGain();
     const dryGain = ctx.createGain();
     const wetGain = ctx.createGain();
-    const f1 = ctx.createBiquadFilter();
-    const f2 = ctx.createBiquadFilter();
-    const f3 = ctx.createBiquadFilter();
-    const f4 = ctx.createBiquadFilter();
-    const f5 = ctx.createBiquadFilter();
-    const formantMix = ctx.createGain();
+    const bands = [0, 1, 2, 3, 4].map(() => {
+      const f = ctx.createBiquadFilter();
+      f.type = "bandpass";
+      f.frequency.value = 0;
+      f.Q.value = 0;
+      return f;
+    });
     const formantWorklet = createFormantNode(ctx);
-    formantWorklet.parameters.get("baseMorph").value = module.morph;
+    const wp = formantWorklet.parameters;
+    wp.get("baseMorph").value = module.morph;
+    wp.get("resonance").value = module.resonance;
     const vowelCV = ctx.createGain();
     vowelCV.gain.value = 1;
     vowelCV.connect(formantWorklet);
-    const splitter = ctx.createChannelSplitter(5);
+    const splitter = ctx.createChannelSplitter(11);
     formantWorklet.connect(splitter);
-    splitter.connect(f1.frequency, 0);
-    splitter.connect(f2.frequency, 1);
-    splitter.connect(f3.frequency, 2);
-    splitter.connect(f4.frequency, 3);
-    splitter.connect(f5.frequency, 4);
-    f1.frequency.value = 0;
-    f2.frequency.value = 0;
-    f3.frequency.value = 0;
-    f4.frequency.value = 0;
-    f5.frequency.value = 0;
-    f1.type = "bandpass";
-    f2.type = "bandpass";
-    f3.type = "bandpass";
-    f4.type = "bandpass";
-    f5.type = "bandpass";
-    f1.Q.value = module.resonance * 0.5;
-    f2.Q.value = module.resonance * 0.4;
-    f3.Q.value = module.resonance * 0.3;
-    f4.Q.value = module.resonance * 0.25;
-    f5.Q.value = module.resonance * 0.2;
+    bands.forEach((f, k) => {
+      splitter.connect(f.frequency, k);
+      splitter.connect(f.Q, 5 + k);
+    });
+    const BAND_GAIN = [1, -1, 1, -0.5, 0.35];
+    const bandGains = bands.map((f, k) => {
+      const g = ctx.createGain();
+      g.gain.value = BAND_GAIN[k];
+      input.connect(f);
+      f.connect(g);
+      return g;
+    });
+    const formantMix = ctx.createGain();
+    formantMix.gain.value = 0;
+    splitter.connect(formantMix.gain, 10);
+    bandGains.forEach((g) => g.connect(formantMix));
     dryGain.gain.value = 1 - module.mix;
     wetGain.gain.value = module.mix;
-    formantMix.gain.value = 2;
-    const f4Gain = ctx.createGain();
-    const f5Gain = ctx.createGain();
-    f4Gain.gain.value = 0.5;
-    f5Gain.gain.value = 0.35;
     input.connect(dryGain);
-    input.connect(f1);
-    input.connect(f2);
-    input.connect(f3);
-    input.connect(f4);
-    input.connect(f5);
-    f1.connect(formantMix);
-    f2.connect(formantMix);
-    f3.connect(formantMix);
-    f4.connect(f4Gain);
-    f5.connect(f5Gain);
-    f4Gain.connect(formantMix);
-    f5Gain.connect(formantMix);
     formantMix.connect(wetGain);
     dryGain.connect(output);
     wetGain.connect(output);
+    const [f1, f2, f3, f4, f5] = bands;
     const _alive = createKeepAlive(ctx, f1, f2, f3, f4, f5);
-    return { input, output, vowelCV, f1, f2, f3, f4, f5, f4Gain, f5Gain, dryGain, wetGain, formantWorklet, _alive };
+    return { input, output, vowelCV, f1, f2, f3, f4, f5, formantMix, dryGain, wetGain, formantWorklet, _alive };
   },
   updateParam(nodes, _module, param, value) {
+    const wp = nodes.formantWorklet.parameters;
     if (param === "morph") {
-      nodes.formantWorklet.parameters.get("baseMorph").value = value;
+      wp.get("baseMorph").value = value;
     } else if (param === "resonance") {
-      const r = value;
-      nodes.f1.Q.value = r * 0.5;
-      nodes.f2.Q.value = r * 0.4;
-      nodes.f3.Q.value = r * 0.3;
-      nodes.f4.Q.value = r * 0.25;
-      nodes.f5.Q.value = r * 0.2;
+      wp.get("resonance").value = value;
     } else if (param === "mix") {
       nodes.dryGain.gain.value = 1 - value;
       nodes.wetGain.gain.value = value;
@@ -2211,35 +2316,22 @@ var FrequencyShifter = /* @__PURE__ */ defineModule(freqShifterDescriptor, {
 
 // src/lib-runtime/generated/modules/gate.tsx
 var params19 = {
-  // threshold/range rebuild the gateShaper curve — not a 1:1 AudioParam
-  // write — so no node/field.
-  threshold: { unit: "dB", default: -40, min: -60, max: 0 },
-  range: { unit: "factor", default: 0.8, min: 0, max: 1 },
-  attack: { node: "envFollower", field: "attack", unit: "s", default: 5e-3, min: 1e-3, max: 0.05, scale: "log" },
-  release: { node: "envFollower", field: "release", unit: "s", default: 0.1, min: 0.01, max: 0.5, scale: "log" }
+  threshold: { node: "gate", field: "threshold", unit: "dB", default: -40, min: -60, max: 0 },
+  range: { node: "gate", field: "range", unit: "factor", default: 0.8, min: 0, max: 1 },
+  // ATK/REL shape the VCA gain's own attack/release ramp once the (fixed,
+  // fast) detector has decided open/closed — same separation as a real
+  // hardware gate (e.g. Drawmer DS201). See src/worklets/gate.ts.
+  attack: { node: "gate", field: "attack", unit: "s", default: 5e-3, min: 1e-3, max: 0.05, scale: "log" },
+  release: { node: "gate", field: "release", unit: "s", default: 0.1, min: 0.01, max: 0.5, scale: "log" },
+  // A switch, not jack sensing (see src/worklets/gate.ts).
+  keySource: { kind: "enum", options: ["internal", "external"], default: "internal" }
 };
-function makeGateCurve(threshold, range) {
-  const threshLinear = Math.pow(10, threshold / 20);
-  const kneeLow = Math.pow(10, (threshold - 2) / 20);
-  const closed = 1 - range;
-  const gsLen = 32768;
-  const gsCurve = new Float32Array(gsLen);
-  for (let i = 0; i < gsLen; i++) {
-    const x = i / (gsLen - 1) * 2 - 1;
-    const env = Math.max(0, x);
-    let g;
-    if (env >= threshLinear) g = 1;
-    else if (env <= kneeLow) g = closed;
-    else g = closed + (1 - closed) * ((env - kneeLow) / (threshLinear - kneeLow));
-    gsCurve[i] = g;
-  }
-  return gsCurve;
-}
 var gateDescriptor = /* @__PURE__ */ defineDescriptor({
   type: "gate",
   params: params19,
   ports: {
     "in": { type: "input", signal: "audio", node: "input" },
+    "key": { type: "input", signal: "audio", node: "_keyIn" },
     "out": { type: "output", signal: "audio", node: "output" }
   },
   createModule(id, position) {
@@ -2248,37 +2340,33 @@ var gateDescriptor = /* @__PURE__ */ defineDescriptor({
   createNodes(ctx, module) {
     const input = ctx.createGain();
     const output = ctx.createGain();
-    const gateGain = ctx.createGain();
-    const envFollower = createEnvFollowerNode(ctx);
-    envFollower.parameters.get("attack").value = module.attack;
-    envFollower.parameters.get("release").value = module.release;
-    const gateShaper = ctx.createWaveShaper();
-    gateShaper.curve = makeGateCurve(module.threshold, module.range);
-    gateGain.gain.value = 0;
-    input.connect(envFollower);
-    envFollower.connect(gateShaper);
-    gateShaper.connect(gateGain.gain);
-    input.connect(gateGain);
-    gateGain.connect(output);
-    return { input, output, envFollower, gateShaper };
+    const gate = createGateNode(ctx);
+    gate.parameters.get("threshold").value = module.threshold;
+    gate.parameters.get("range").value = module.range;
+    gate.parameters.get("attack").value = module.attack;
+    gate.parameters.get("release").value = module.release;
+    gate.parameters.get("keyExt").value = module.keySource === "external" ? 1 : 0;
+    const _keyIn = ctx.createGain();
+    _keyIn.channelCount = 2;
+    _keyIn.channelCountMode = "clamped-max";
+    input.connect(gate);
+    _keyIn.connect(gate, 0, 1);
+    gate.connect(output);
+    return { input, output, gate, _keyIn };
   },
   updateParam(nodes, module, param, value) {
-    if (param === "threshold" || param === "range") {
-      const thresh = param === "threshold" ? value : module.threshold;
-      const range = param === "range" ? value : module.range;
-      nodes.gateShaper.curve = makeGateCurve(thresh, range);
-    } else if (param === "attack") {
-      nodes.envFollower.parameters.get("attack").value = value;
-    } else if (param === "release") {
-      nodes.envFollower.parameters.get("release").value = value;
+    if (param === "keySource") {
+      nodes.gate.parameters.get("keyExt").value = value === "external" ? 1 : 0;
+      return;
     }
+    nodes.gate.parameters.get(param).value = value;
   }
 });
 
 // src/lib-runtime/generated/modules/gate.wrapper.ts
 var Gate = /* @__PURE__ */ defineModule(gateDescriptor, {
   worklets: {
-    "env-follower": env_follower_default
+    "gate": gate_default
   }
 });
 
@@ -2403,7 +2491,7 @@ var HaasWidener = /* @__PURE__ */ defineModule(haasDescriptor);
 var params22 = {
   rate: { node: "lfo", field: "frequency", unit: "Hz", default: 4, min: 1, max: 10 },
   depth: { unit: "factor", default: 0.7, min: 0, max: 1 },
-  crossover: { node: "lowpass", field: "frequency", unit: "Hz", default: 800, min: 200, max: 2e3 }
+  crossover: { node: "_xover", field: "offset", unit: "Hz", default: 800, min: 200, max: 2e3 }
 };
 var harmonicTremDescriptor = /* @__PURE__ */ defineDescriptor({
   type: "harmonic-trem",
@@ -2412,7 +2500,7 @@ var harmonicTremDescriptor = /* @__PURE__ */ defineDescriptor({
     "in": { type: "input", signal: "audio", node: "input" },
     "out": { type: "output", signal: "audio", node: "output" },
     "modRate": { type: "modulation", signal: "modulation", node: "lfo", field: "frequency" },
-    "modCrossover": { type: "modulation", signal: "modulation", node: "lowpass", field: "frequency" }
+    "modCrossover": { type: "modulation", signal: "modulation", node: "_xover", field: "offset" }
   },
   createModule(id, position) {
     return { id, type: "harmonic-trem", position, ...paramDefaults(params22) };
@@ -2421,8 +2509,9 @@ var harmonicTremDescriptor = /* @__PURE__ */ defineDescriptor({
     const input = ctx.createGain();
     const output = ctx.createGain();
     const lowpass = ctx.createBiquadFilter();
-    const lpInvert = ctx.createGain();
-    const highBand = ctx.createGain();
+    const highpass = ctx.createBiquadFilter();
+    const hpInvert = ctx.createGain();
+    const _xover = ctx.createConstantSource();
     const lowGain = ctx.createGain();
     const highGain = ctx.createGain();
     const lfo = ctx.createOscillator();
@@ -2430,10 +2519,14 @@ var harmonicTremDescriptor = /* @__PURE__ */ defineDescriptor({
     const lfoGainHigh = ctx.createGain();
     const lfoInvert = ctx.createGain();
     lowpass.type = "lowpass";
-    lowpass.frequency.value = module.crossover;
-    lowpass.Q.value = -6.0206;
-    lpInvert.gain.value = -1;
-    highBand.gain.value = 1;
+    highpass.type = "highpass";
+    for (const f of [lowpass, highpass]) {
+      f.Q.value = -6.0206;
+      f.frequency.value = 0;
+      _xover.connect(f.frequency);
+    }
+    _xover.offset.value = module.crossover;
+    hpInvert.gain.value = -1;
     lfo.type = "sine";
     lfo.frequency.value = module.rate;
     lfoGainLow.gain.value = module.depth * 0.5;
@@ -2442,20 +2535,20 @@ var harmonicTremDescriptor = /* @__PURE__ */ defineDescriptor({
     lowGain.gain.value = 1;
     highGain.gain.value = 1;
     input.connect(lowpass);
-    input.connect(highBand);
-    lowpass.connect(lpInvert);
-    lpInvert.connect(highBand);
+    input.connect(highpass);
+    highpass.connect(hpInvert);
     lfo.connect(lfoGainLow);
     lfo.connect(lfoInvert);
     lfoInvert.connect(lfoGainHigh);
     lfoGainLow.connect(lowGain.gain);
     lfoGainHigh.connect(highGain.gain);
     lowpass.connect(lowGain);
-    highBand.connect(highGain);
+    hpInvert.connect(highGain);
     lowGain.connect(output);
     highGain.connect(output);
     lfo.start();
-    return { input, output, lfo, lfoGainLow, lfoGainHigh, lowpass, lpInvert, highBand };
+    _xover.start();
+    return { input, output, lfo, lfoGainLow, lfoGainHigh, lowpass, highpass, hpInvert, _xover };
   },
   updateParam(nodes, _m, param, value) {
     if (param === "rate") nodes.lfo.frequency.value = value;
@@ -2463,10 +2556,11 @@ var harmonicTremDescriptor = /* @__PURE__ */ defineDescriptor({
       nodes.lfoGainLow.gain.value = value * 0.5;
       nodes.lfoGainHigh.gain.value = value * 0.5;
     } else if (param === "crossover") {
-      nodes.lowpass.frequency.value = value;
+      nodes._xover.offset.value = value;
     }
   },
   dispose(nodes) {
+    nodes._xover.stop();
     nodes.lfo.stop();
   }
 });
@@ -2604,21 +2698,27 @@ var Lfo = /* @__PURE__ */ defineModule(lfoDescriptor, {
 });
 
 // src/lib-runtime/generated/modules/lo-fi.tsx
-function makeLoFiSaturationCurve(amount) {
-  const samples = 44100;
-  const curve = new Float32Array(samples);
-  const k = 1 + amount * 5;
-  for (let i = 0; i < samples; i++) {
-    const x = i * 2 / samples - 1;
-    curve[i] = x >= 0 ? Math.tanh(k * x * 0.8) : Math.tanh(k * x * 1.2);
+var DRIVE_BIAS = 0.3;
+var INPUT_SPAN = 16;
+var CURVE_LEN2 = 32769;
+var WOBBLE_MAX_S = 2e-3;
+var driveK = (drive) => 0.125 * Math.pow(128, Math.max(0, Math.min(1, drive)));
+function loFiCurve(drive) {
+  const k = driveK(drive);
+  const t0 = Math.tanh(DRIVE_BIAS);
+  const slope0 = 1 - t0 * t0;
+  const c = new Float32Array(CURVE_LEN2);
+  for (let i = 0; i < CURVE_LEN2; i++) {
+    const v = i * 2 / (CURVE_LEN2 - 1) - 1;
+    c[i] = (Math.tanh(k * INPUT_SPAN * v + DRIVE_BIAS) - t0) / (k * slope0);
   }
-  return curve;
+  return c;
 }
 var params25 = {
   drive: { unit: "factor", default: 0.3, min: 0, max: 1 },
   cutoff: { node: "lowpass", field: "frequency", unit: "Hz", default: 4e3, min: 500, max: 8e3 },
-  noise: { unit: "factor", default: 0.2, min: 0, max: 1 },
-  wobble: { unit: "factor", default: 0.1, min: 0, max: 1 }
+  noise: { node: "noiseGain", field: "gain", unit: "factor", default: 0.2, min: 0, max: 1 },
+  wobble: { node: "wobbleAmt", field: "offset", unit: "factor", default: 0.1, min: 0, max: 1 }
 };
 var loFiDescriptor = /* @__PURE__ */ defineDescriptor({
   type: "lo-fi",
@@ -2634,73 +2734,78 @@ var loFiDescriptor = /* @__PURE__ */ defineDescriptor({
   createNodes(ctx, module) {
     const input = ctx.createGain();
     const output = ctx.createGain();
-    const saturation = ctx.createWaveShaper();
+    const preGain = ctx.createGain();
+    preGain.gain.value = 1 / INPUT_SPAN;
+    const saturation = createShaperNode(ctx, loFiCurve(module.drive), { dry: false });
+    const dcBlock = ctx.createBiquadFilter();
+    dcBlock.type = "highpass";
+    dcBlock.frequency.value = 10;
+    dcBlock.Q.value = Math.SQRT1_2;
     const lowpass = ctx.createBiquadFilter();
-    const noiseGain = ctx.createGain();
-    const wobbleLfo = ctx.createOscillator();
-    const wobbleGain = ctx.createGain();
-    saturation.curve = makeLoFiSaturationCurve(module.drive);
-    saturation.oversample = "2x";
     lowpass.type = "lowpass";
     lowpass.frequency.value = module.cutoff;
     lowpass.Q.value = 0.7;
-    const bufferSize = 2 * ctx.sampleRate;
-    const noiseBuffer2 = ctx.createBuffer(1, bufferSize, ctx.sampleRate);
-    const data = noiseBuffer2.getChannelData(0);
-    const rand = noiseSource(NOISE_SEEDS.loFiCrackle);
-    let b0 = 0, b1 = 0, b2 = 0;
-    for (let i = 0; i < bufferSize; i++) {
-      const white = rand();
-      b0 = 0.99765 * b0 + white * 0.099046;
-      b1 = 0.963 * b1 + white * 0.2965164;
-      b2 = 0.57 * b2 + white * 1.0526913;
-      data[i] = (b0 + b1 + b2) * 0.1;
-    }
-    const noiseSrc = ctx.createBufferSource();
-    noiseSrc.buffer = noiseBuffer2;
-    noiseSrc.loop = true;
-    noiseGain.gain.value = module.noise * 0.05;
-    noiseSrc.connect(noiseGain);
-    noiseSrc.start();
-    const wobbleDelay = ctx.createDelay(0.05);
-    wobbleDelay.delayTime.value = 0.01;
+    const wobbleAmt = ctx.createConstantSource();
+    wobbleAmt.offset.value = module.wobble;
+    const wobbleScale = ctx.createGain();
+    wobbleScale.gain.value = WOBBLE_MAX_S;
+    const wobbleLfo = ctx.createOscillator();
     wobbleLfo.type = "sine";
     wobbleLfo.frequency.value = 0.73;
-    wobbleGain.gain.value = module.wobble * 2e-3;
-    wobbleLfo.connect(wobbleGain);
-    wobbleGain.connect(wobbleDelay.delayTime);
+    const wobbleDepth = ctx.createGain();
+    wobbleDepth.gain.value = 0;
+    const wobbleDelay = ctx.createDelay(0.05);
+    wobbleDelay.delayTime.value = 0;
+    wobbleAmt.connect(wobbleScale);
+    wobbleScale.connect(wobbleDelay.delayTime);
+    wobbleScale.connect(wobbleDepth.gain);
+    wobbleLfo.connect(wobbleDepth);
+    wobbleDepth.connect(wobbleDelay.delayTime);
+    wobbleAmt.start();
     wobbleLfo.start();
-    input.connect(saturation);
-    saturation.connect(lowpass);
+    const noiseSrc = createVinylNoiseNode(ctx, NOISE_SEEDS.loFiCrackle);
+    const noiseGain = ctx.createGain();
+    noiseGain.gain.value = module.noise;
+    noiseSrc.connect(noiseGain);
+    input.connect(preGain);
+    preGain.connect(saturation);
+    saturation.connect(dcBlock, 0);
+    dcBlock.connect(lowpass);
     lowpass.connect(wobbleDelay);
     wobbleDelay.connect(output);
     noiseGain.connect(output);
-    return { input, output, saturation, lowpass, wobbleDelay, noiseGain, wobbleGain, wobbleLfo, noiseSrc };
+    return { input, output, preGain, saturation, dcBlock, lowpass, wobbleAmt, wobbleScale, wobbleLfo, wobbleDepth, wobbleDelay, noiseSrc, noiseGain };
   },
   updateParam(nodes, _m, param, value) {
     if (param === "drive") {
-      nodes.saturation.curve = makeLoFiSaturationCurve(value);
+      nodes.saturation.port.postMessage({ curve: loFiCurve(value) });
     } else if (param === "cutoff") {
       nodes.lowpass.frequency.value = value;
     } else if (param === "noise") {
-      nodes.noiseGain.gain.value = value * 0.05;
+      nodes.noiseGain.gain.value = value;
     } else if (param === "wobble") {
-      nodes.wobbleGain.gain.value = value * 2e-3;
+      nodes.wobbleAmt.offset.value = value;
     }
   },
   dispose(nodes) {
     nodes.wobbleLfo.stop();
-    nodes.noiseSrc.stop();
+    nodes.wobbleAmt.stop();
   }
 });
 
 // src/lib-runtime/generated/modules/lo-fi.wrapper.ts
-var LoFi = /* @__PURE__ */ defineModule(loFiDescriptor);
+var LoFi = /* @__PURE__ */ defineModule(loFiDescriptor, {
+  worklets: {
+    "shaper": shaper_default,
+    "vinyl-noise": vinyl_noise_default
+  }
+});
 
 // src/lib-runtime/generated/modules/mid-side.tsx
 var params26 = {
   midGain: { node: "midGainNode", field: "gain", unit: "factor", default: 1, min: 0, max: 2 },
-  sideGain: { node: "sideGainNode", field: "gain", unit: "factor", default: 1, min: 0, max: 2 }
+  sideGain: { node: "sideGainNode", field: "gain", unit: "factor", default: 1, min: 0, max: 2 },
+  width: { node: "widthNode", field: "gain", unit: "factor", default: 1, min: 0, max: 2 }
 };
 var midSideDescriptor = /* @__PURE__ */ defineDescriptor({
   type: "mid-side",
@@ -3143,9 +3248,58 @@ function dampingToQ(damping) {
   const d = Math.min(1, Math.max(0, Number.isFinite(damping) ? damping : 0.5));
   return MODAL_Q_MAX * Math.pow(MODAL_Q_MIN / MODAL_Q_MAX, d);
 }
+function modeT60(q, hz2) {
+  return T60_PER_Q_HZ * q / hz2;
+}
 function modalMakeup(q) {
   return Math.sqrt(Math.max(1, q));
 }
+var MODAL_PARTIALS = 5;
+var MODAL_REF_NOTE = 57;
+function partialEnergySum(structure) {
+  let s = 0;
+  for (let n = 1; n <= MODAL_PARTIALS; n++) s += Math.pow(n, -(1 + structure));
+  return s;
+}
+function modalPartialGain(n, q, structure) {
+  return modalMakeup(q) * Math.pow(n, -(1 + structure)) * Math.sqrt(MODAL_PARTIALS / partialEnergySum(structure)) * modalOverlapGain(q, structure);
+}
+var OVERLAP_REF_HZ = 220;
+var OVERLAP_SR = 48e3;
+var overlapCache = /* @__PURE__ */ new Map();
+function modalOverlapGain(q, structure) {
+  if (!(q < 40)) return 1;
+  const key = `${q.toFixed(4)}:${structure.toFixed(4)}`;
+  const hit = overlapCache.get(key);
+  if (hit !== void 0) return hit;
+  const n = Math.ceil(2 * modeT60(q, OVERLAP_REF_HZ) * OVERLAP_SR) + 64;
+  const sum = new Float64Array(n);
+  let incoherent = 0;
+  for (let p = 1; p <= MODAL_PARTIALS; p++) {
+    const f0 = Math.min(OVERLAP_SR * 0.45, OVERLAP_REF_HZ * Math.pow(p, 1 + structure));
+    const g = Math.pow(p, -(1 + structure));
+    const w0 = 2 * Math.PI * f0 / OVERLAP_SR;
+    const alpha = Math.sin(w0) / (2 * q);
+    const a0 = 1 + alpha;
+    const b0 = alpha / a0, a1 = -2 * Math.cos(w0) / a0, a2 = (1 - alpha) / a0;
+    let y2 = 0, y1 = 0;
+    for (let i = 0; i < n; i++) {
+      const x = i === 0 ? b0 : i === 2 ? -b0 : 0;
+      const y = x - a1 * y1 - a2 * y2;
+      y2 = y1;
+      y1 = y;
+      sum[i] += g * y;
+      incoherent += g * g * y * y;
+    }
+  }
+  let coherent = 0;
+  for (let i = 0; i < n; i++) coherent += sum[i] * sum[i];
+  const gain = coherent > 0 ? Math.sqrt(incoherent / coherent) : 1;
+  if (overlapCache.size > 4096) overlapCache.clear();
+  overlapCache.set(key, gain);
+  return gain;
+}
+var MODAL_PITCH_GAIN_TRANSPOSE = 69 + 12 * (MODAL_REF_NOTE / 24 - Math.log2(440));
 
 // src/lib-runtime/generated/modules/resonator.tsx
 var params31 = {
@@ -3153,12 +3307,13 @@ var params31 = {
   offset: { node: "_root", field: "offset", default: 57, min: -48, max: 108, unit: "semitone" },
   structure: { unit: "factor", default: 0, min: 0, max: 1 },
   damping: { unit: "factor", default: 0.5, min: 0, max: 1 },
-  mix: { node: "_mix", field: "offset", unit: "factor", default: 0.5, min: 0, max: 1 }
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 1, min: 0, max: 1 }
 };
 function partialOffset(partial, structure) {
   return 12 * (1 + structure) * Math.log2(partial);
 }
 var patchCount2 = /* @__PURE__ */ new WeakMap();
+var shape = /* @__PURE__ */ new WeakMap();
 var resonatorDescriptor = /* @__PURE__ */ defineDescriptor({
   type: "resonator",
   params: params31,
@@ -3186,7 +3341,17 @@ var resonatorDescriptor = /* @__PURE__ */ defineDescriptor({
     const partialGains = [];
     const voct = [];
     const q = dampingToQ(module.damping);
-    const makeup = modalMakeup(q);
+    shape.set(_pitch, { q, structure: module.structure });
+    const _halfPitch = ctx.createGain();
+    _halfPitch.gain.value = -0.5;
+    _pitch.connect(_halfPitch);
+    const _trackGain = createVoctFreqNode(ctx);
+    _trackGain.parameters.get("transpose").value = MODAL_PITCH_GAIN_TRANSPOSE;
+    _halfPitch.connect(_trackGain);
+    const _track = ctx.createGain();
+    _track.gain.value = 0;
+    _trackGain.connect(_track.gain);
+    _track.connect(wetGain);
     for (let i = 1; i <= 5; i++) {
       const v = createVoctFreqNode(ctx);
       v.parameters.get("transpose").value = partialOffset(i, module.structure);
@@ -3200,9 +3365,9 @@ var resonatorDescriptor = /* @__PURE__ */ defineDescriptor({
       voct.push(v);
       input.connect(filter);
       const partialGain = ctx.createGain();
-      partialGain.gain.value = makeup / Math.sqrt(i);
+      partialGain.gain.value = modalPartialGain(i, q, module.structure);
       filter.connect(partialGain);
-      partialGain.connect(wetGain);
+      partialGain.connect(_track);
       partialGains.push(partialGain);
     }
     const _alive = createKeepAlive(ctx, ...filters);
@@ -3219,6 +3384,9 @@ var resonatorDescriptor = /* @__PURE__ */ defineDescriptor({
       _root,
       _pitch,
       _alive,
+      _halfPitch,
+      _trackGain,
+      _track,
       v1: voct[0],
       v2: voct[1],
       v3: voct[2],
@@ -3244,19 +3412,20 @@ var resonatorDescriptor = /* @__PURE__ */ defineDescriptor({
       if (!patchCount2.get(nodes)) nodes._root.offset.value = value;
     } else if (param === "transpose") {
       if (patchCount2.get(nodes)) nodes._root.offset.value = value;
-    } else if (param === "structure") {
-      const voct = [nodes.v1, nodes.v2, nodes.v3, nodes.v4, nodes.v5];
-      for (let i = 1; i < 5; i++) {
-        voct[i].parameters.get("transpose").value = partialOffset(i + 1, value);
+    } else if (param === "structure" || param === "damping") {
+      const st = shape.get(nodes._pitch);
+      if (param === "structure") {
+        st.structure = value;
+        const voct = [nodes.v1, nodes.v2, nodes.v3, nodes.v4, nodes.v5];
+        for (let i = 1; i < 5; i++) {
+          voct[i].parameters.get("transpose").value = partialOffset(i + 1, st.structure);
+        }
+      } else {
+        st.q = dampingToQ(value);
+        for (const f of filters) f.Q.value = st.q;
       }
-    } else if (param === "damping") {
-      const q = dampingToQ(value);
-      const makeup = modalMakeup(q);
       const gains = [nodes.g1, nodes.g2, nodes.g3, nodes.g4, nodes.g5];
-      for (let i = 0; i < 5; i++) {
-        filters[i].Q.value = q;
-        gains[i].gain.value = makeup / Math.sqrt(i + 1);
-      }
+      for (let i = 0; i < 5; i++) gains[i].gain.value = modalPartialGain(i + 1, st.q, st.structure);
     } else if (param === "mix") {
       nodes._mix.offset.value = value;
     }
@@ -3295,13 +3464,30 @@ var Resonator = /* @__PURE__ */ defineModule(resonatorDescriptor, {
 });
 
 // src/lib/dsp/fdnTank.ts
-var COMB_TIMES_MS = [29.7, 37.1, 41.1, 43.7];
+var LINE_MS = [
+  32.479167,
+  32.645833,
+  39.354167,
+  37.979167,
+  44.854167,
+  46.729167,
+  54.854167,
+  54.020833,
+  64.354167,
+  65.020833,
+  77.770833,
+  76.229167,
+  90.770833,
+  91.854167,
+  108.520833,
+  108.270833
+];
 function tankEnergyGain500(rt60, size = 1) {
   let g2 = 0;
-  for (const ms2 of COMB_TIMES_MS) g2 += Math.pow(10, -6 * (ms2 / 1e3) * size / Math.max(rt60, 0.05));
-  g2 /= COMB_TIMES_MS.length;
+  for (const ms2 of LINE_MS) g2 += Math.pow(10, -6 * (ms2 / 1e3) * size / Math.max(rt60, 0.05));
+  g2 /= LINE_MS.length;
   const loss = 1 - g2;
-  return Math.max(0.05, 0.6422 / loss - 0.2406 - 11e-4 * loss);
+  return Math.max(0.01, 1.32117 / loss - 1.32832 - 0.01158 * loss);
 }
 function createFdnTank(ctx, opts) {
   const input = ctx.createGain();
@@ -3481,10 +3667,10 @@ var RingModulator = /* @__PURE__ */ defineModule(ringModDescriptor, {
 
 // src/lib-runtime/generated/modules/rotary.tsx
 var CROSSOVER_HZ = 800;
-var BUTTERWORTH_Q_DB = -3.0103;
+var BUTTERWORTH_Q_DB2 = -3.0103;
 var DRUM_RATIO = 0.85;
-var HORN = { baseDelay: 3e-3, dopplerSec: 44e-5, ampBase: 0.7, ampDepth: 0.3, phaseDeg: 0, tauUp: 0.35, tauDown: 0.55 };
-var DRUM = { baseDelay: 3e-3, dopplerSec: 2e-4, ampBase: 0.8, ampDepth: 0.2, phaseDeg: 90, tauUp: 1.5, tauDown: 1.7 };
+var HORN = { baseDelay: 3e-3, dopplerSec: 44e-5, ampBase: 0.54, ampDepth: 0.46, phaseDeg: 0, tauUp: 0.35, tauDown: 0.55 };
+var DRUM = { baseDelay: 3e-3, dopplerSec: 2e-4, ampBase: 0.6, ampDepth: 0.4, phaseDeg: 90, tauUp: 1.5, tauDown: 1.7 };
 var params34 = {
   speed: { kind: "enum", options: ["slow", "fast"], default: "slow" },
   slowRate: { unit: "Hz", default: 0.8, min: 0.5, max: 2 },
@@ -3517,7 +3703,7 @@ var rotaryDescriptor = /* @__PURE__ */ defineDescriptor({
       const f = ctx.createBiquadFilter();
       f.type = type;
       f.frequency.value = CROSSOVER_HZ;
-      f.Q.value = BUTTERWORTH_Q_DB;
+      f.Q.value = BUTTERWORTH_Q_DB2;
       return f;
     };
     const lp1 = biquad("lowpass"), lp2 = biquad("lowpass");
@@ -3610,22 +3796,24 @@ var Rotary = /* @__PURE__ */ defineModule(rotaryDescriptor);
 
 // src/lib-runtime/generated/modules/saturator.tsx
 var params35 = {
-  // drive feeds both driveGain.gain (1 + drive*4) and the waveshaper curve —
-  // a conversion, not a 1:1 AudioParam write, so no node/field.
+  // DRIVE reshapes the curve (hotter knee, output trimmed to match) — no
+  // single AudioParam carries it: set-only.
   drive: { unit: "factor", default: 0.5, min: 0, max: 1 },
   // warmthFilter.gain = warmth * 6 — a scaled conversion, so no node/field.
   warmth: { unit: "factor", default: 0.5, min: 0, max: 1 },
   mix: { node: "_mix", field: "offset", unit: "factor", default: 1, min: 0, max: 1 }
 };
-function makeSaturationCurve(amount) {
-  const samples = 44100;
-  const curve = new Float32Array(samples);
-  const k = 1 + amount * 10;
-  for (let i = 0; i < samples; i++) {
-    const x = i * 2 / samples - 1;
-    curve[i] = Math.tanh(k * x) / Math.tanh(k);
+var INPUT_SPAN2 = 16;
+var CURVE_LEN3 = 32769;
+var driveGain = (drive) => 0.25 * Math.pow(64, Math.max(0, Math.min(1, drive)));
+function saturationCurve(drive) {
+  const g = driveGain(drive);
+  const c = new Float32Array(CURVE_LEN3);
+  for (let i = 0; i < CURVE_LEN3; i++) {
+    const v = i * 2 / (CURVE_LEN3 - 1) - 1;
+    c[i] = Math.tanh(g * INPUT_SPAN2 * v) / g;
   }
-  return curve;
+  return c;
 }
 var saturatorDescriptor = /* @__PURE__ */ defineDescriptor({
   type: "saturator",
@@ -3642,29 +3830,29 @@ var saturatorDescriptor = /* @__PURE__ */ defineDescriptor({
     const output = ctx.createGain();
     const dryGain = ctx.createGain();
     const wetGain = ctx.createGain();
-    const driveGain = ctx.createGain();
-    const waveshaper = ctx.createWaveShaper();
+    const preGain = ctx.createGain();
+    preGain.gain.value = 1 / INPUT_SPAN2;
+    const shaper = createShaperNode(ctx, saturationCurve(module.drive));
+    const dryTrim = ctx.createGain();
+    dryTrim.gain.value = INPUT_SPAN2;
     const warmthFilter = ctx.createBiquadFilter();
-    driveGain.gain.value = 1 + module.drive * 4;
-    waveshaper.curve = makeSaturationCurve(module.drive);
-    waveshaper.oversample = "2x";
     warmthFilter.type = "lowshelf";
     warmthFilter.frequency.value = 300;
     warmthFilter.gain.value = module.warmth * 6;
     const _mix = createMix(ctx, dryGain, wetGain, module.mix, "linear");
-    input.connect(dryGain);
-    input.connect(driveGain);
-    driveGain.connect(waveshaper);
-    waveshaper.connect(warmthFilter);
+    input.connect(preGain);
+    preGain.connect(shaper);
+    shaper.connect(warmthFilter, 0);
     warmthFilter.connect(wetGain);
+    shaper.connect(dryTrim, 1);
+    dryTrim.connect(dryGain);
     dryGain.connect(output);
     wetGain.connect(output);
-    return { input, output, driveGain, waveshaper, warmthFilter, dryGain, wetGain, _mix };
+    return { input, output, preGain, shaper, dryTrim, warmthFilter, dryGain, wetGain, _mix };
   },
   updateParam(nodes, _m, param, value) {
     if (param === "drive") {
-      nodes.driveGain.gain.value = 1 + value * 4;
-      nodes.waveshaper.curve = makeSaturationCurve(value);
+      nodes.shaper.port.postMessage({ curve: saturationCurve(value) });
     } else if (param === "warmth") {
       nodes.warmthFilter.gain.value = value * 6;
     } else if (param === "mix") {
@@ -3674,7 +3862,11 @@ var saturatorDescriptor = /* @__PURE__ */ defineDescriptor({
 });
 
 // src/lib-runtime/generated/modules/saturator.wrapper.ts
-var Saturator = /* @__PURE__ */ defineModule(saturatorDescriptor);
+var Saturator = /* @__PURE__ */ defineModule(saturatorDescriptor, {
+  worklets: {
+    "shaper": shaper_default
+  }
+});
 
 // src/lib/dsp/shimmerRegen.ts
 var REGEN_HP_HZ = 300;
@@ -3684,13 +3876,13 @@ var SHIFTER_ENERGY = 0.75;
 var REGEN_DELAY_S = 0.02;
 var SHIFTER_SEEDS = [5370206, 739982445];
 var UNISON_FLOOR = [
-  [0.5, 0.68],
-  [1, 0.75],
-  [2, 0.76],
-  [3, 0.8],
-  [5, 0.84],
-  [7, 0.75],
-  [10, 0.6]
+  [0.5, 0.58],
+  [1, 0.67],
+  [2, 0.73],
+  [3, 0.77],
+  [5, 0.79],
+  [7, 0.77],
+  [10, 0.72]
 ];
 var UNISON_PITCH_SPAN = 0.75;
 function unisonFloor(decay) {
@@ -3832,9 +4024,9 @@ function makeSoftLimitCurve(knee, drive) {
   const k = 0.1 + knee * 0.9;
   const driveMul = 1 + drive * 3;
   for (let i = 0; i < samples; i++) {
-    const x = (i * 2 / samples - 1) * driveMul;
-    if (Math.abs(x) < k) {
-      curve[i] = x;
+    const x = (i * 2 / (samples - 1) - 1) * driveMul;
+    if (Math.abs(x) < k || 1 - k < 1e-9) {
+      curve[i] = Math.max(-1, Math.min(1, x));
     } else {
       const sign = x > 0 ? 1 : -1;
       curve[i] = sign * (k + (1 - k) * Math.tanh((Math.abs(x) - k) / (1 - k)));
@@ -3855,25 +4047,28 @@ var softLimitDescriptor = /* @__PURE__ */ defineDescriptor({
   createNodes(ctx, module) {
     const input = ctx.createGain();
     const output = ctx.createGain();
-    const waveshaper = ctx.createWaveShaper();
+    const waveshaper = createShaperNode(ctx, makeSoftLimitCurve(module.knee, module.drive), { dry: false });
     const ceiling = ctx.createGain();
-    waveshaper.curve = makeSoftLimitCurve(module.knee, module.drive);
-    waveshaper.oversample = "2x";
     ceiling.gain.value = Math.pow(10, module.ceiling / 20);
     input.connect(waveshaper);
-    waveshaper.connect(ceiling);
+    waveshaper.connect(ceiling, 0);
     ceiling.connect(output);
     return { input, output, waveshaper, ceiling };
   },
   updateParam(nodes, m, param, value) {
-    if (param === "drive") nodes.waveshaper.curve = makeSoftLimitCurve(m.knee, value);
-    else if (param === "knee") nodes.waveshaper.curve = makeSoftLimitCurve(value, m.drive);
+    const port = nodes.waveshaper.port;
+    if (param === "drive") port.postMessage({ curve: makeSoftLimitCurve(m.knee, value) });
+    else if (param === "knee") port.postMessage({ curve: makeSoftLimitCurve(value, m.drive) });
     else if (param === "ceiling") nodes.ceiling.gain.value = Math.pow(10, value / 20);
   }
 });
 
 // src/lib-runtime/generated/modules/soft-limit.wrapper.ts
-var SoftLimiter = /* @__PURE__ */ defineModule(softLimitDescriptor);
+var SoftLimiter = /* @__PURE__ */ defineModule(softLimitDescriptor, {
+  worklets: {
+    "shaper": shaper_default
+  }
+});
 
 // src/lib-runtime/generated/modules/spring-reverb.tsx
 var params38 = {
@@ -3938,6 +4133,7 @@ var SpringReverb = /* @__PURE__ */ defineModule(springReverbDescriptor, {
 // src/lib-runtime/generated/modules/stereo-spread.tsx
 var params39 = {
   spread: { unit: "factor", default: 0.7, min: 0, max: 1 },
+  width: { node: "wetGain", field: "gain", unit: "factor", default: 1, min: 0, max: 2 },
   center: { unit: "Hz", default: 800, min: 200, max: 2e3, scale: "log" }
 };
 var stereoSpreadDescriptor = /* @__PURE__ */ defineDescriptor({
@@ -3953,12 +4149,11 @@ var stereoSpreadDescriptor = /* @__PURE__ */ defineDescriptor({
   createNodes(ctx, module) {
     const input = ctx.createGain();
     const output = ctx.createGain();
-    const lowpass = ctx.createBiquadFilter();
+    input.connect(output);
     const highpass = ctx.createBiquadFilter();
-    lowpass.type = "lowpass";
-    lowpass.frequency.value = module.center;
     highpass.type = "highpass";
     highpass.frequency.value = module.center;
+    highpass.Q.value = -3.0102999566;
     const panLeft = ctx.createStereoPanner();
     const panRight = ctx.createStereoPanner();
     const haasDelay = ctx.createDelay(0.02);
@@ -3967,8 +4162,6 @@ var stereoSpreadDescriptor = /* @__PURE__ */ defineDescriptor({
     haasDelay.delayTime.value = module.spread * 5e-3;
     const wetGain = ctx.createGain();
     wetGain.gain.value = module.width;
-    input.connect(lowpass);
-    lowpass.connect(output);
     input.connect(highpass);
     highpass.connect(panLeft);
     highpass.connect(haasDelay);
@@ -3976,7 +4169,7 @@ var stereoSpreadDescriptor = /* @__PURE__ */ defineDescriptor({
     panLeft.connect(wetGain);
     panRight.connect(wetGain);
     wetGain.connect(output);
-    return { input, output, lowpass, highpass, panLeft, panRight, haasDelay, wetGain };
+    return { input, output, highpass, panLeft, panRight, haasDelay, wetGain };
   },
   updateParam(nodes, _m, param, value) {
     if (param === "spread") {
@@ -3986,7 +4179,6 @@ var stereoSpreadDescriptor = /* @__PURE__ */ defineDescriptor({
     } else if (param === "width") {
       nodes.wetGain.gain.value = value;
     } else if (param === "center") {
-      nodes.lowpass.frequency.value = value;
       nodes.highpass.frequency.value = value;
     }
   }
@@ -4483,12 +4675,13 @@ var Vco = /* @__PURE__ */ defineModule(oscillatorDescriptor, {
 });
 
 // src/lib-runtime/generated/modules/wah.tsx
+var DEPTH_ST = 18;
 var params48 = {
   note: { node: "_cutoffVoct", field: "transpose", unit: "note", default: 79, min: 55, max: 95 },
   // Resonance drives both the filter Q and a separate makeup gain — a split, so it stays set-only.
   resonance: { unit: "factor", default: 8, min: 1, max: 20, scale: "log" },
   rate: { node: "lfo", field: "frequency", unit: "Hz", default: 1, min: 0.1, max: 10, scale: "log" },
-  // Depth is stored 0-1 but scaled by 36 semitones onto lfoGain.gain — a conversion, so set-only.
+  // Depth is stored 0-1 but scaled by DEPTH_ST semitones onto lfoGain.gain — a conversion, so set-only.
   depth: { unit: "factor", default: 0.6, min: 0, max: 1 }
 };
 var wahDescriptor = /* @__PURE__ */ defineDescriptor({
@@ -4522,7 +4715,7 @@ var wahDescriptor = /* @__PURE__ */ defineDescriptor({
     _cutoffVoct.connect(filter.frequency);
     lfo.type = "sine";
     lfo.frequency.value = module.rate;
-    lfoGain.gain.value = module.depth * 36;
+    lfoGain.gain.value = module.depth * DEPTH_ST;
     lfo.connect(lfoGain);
     lfoGain.connect(_cutoffVoct);
     lfo.start();
@@ -4541,7 +4734,7 @@ var wahDescriptor = /* @__PURE__ */ defineDescriptor({
     } else if (param === "rate") {
       nodes.lfo.frequency.value = value;
     } else if (param === "depth") {
-      nodes.lfoGain.gain.value = value * 36;
+      nodes.lfoGain.gain.value = value * DEPTH_ST;
     }
   },
   dispose(nodes) {
@@ -4599,20 +4792,18 @@ var wavefolderDescriptor = /* @__PURE__ */ defineDescriptor({
     const output = ctx.createGain();
     const dryGain = ctx.createGain();
     const wetGain = ctx.createGain();
-    const waveshaper = ctx.createWaveShaper();
-    waveshaper.curve = makeWavefoldCurve(module.folds, module.symmetry);
-    waveshaper.oversample = "4x";
+    const waveshaper = createShaperNode(ctx, makeWavefoldCurve(module.folds, module.symmetry));
     const _mix = createMix(ctx, dryGain, wetGain, module.mix, "linear");
-    input.connect(dryGain);
     input.connect(waveshaper);
-    waveshaper.connect(wetGain);
+    waveshaper.connect(dryGain, 1);
+    waveshaper.connect(wetGain, 0);
     dryGain.connect(output);
     wetGain.connect(output);
     return { input, output, waveshaper, dryGain, wetGain, _mix };
   },
   updateParam(nodes, module, param, value) {
     if (param === "folds" || param === "symmetry") {
-      nodes.waveshaper.curve = makeWavefoldCurve(module.folds, module.symmetry);
+      nodes.waveshaper.port.postMessage({ curve: makeWavefoldCurve(module.folds, module.symmetry) });
     } else if (param === "mix") {
       nodes._mix.offset.value = value;
     }
@@ -4620,7 +4811,11 @@ var wavefolderDescriptor = /* @__PURE__ */ defineDescriptor({
 });
 
 // src/lib-runtime/generated/modules/wavefolder.wrapper.ts
-var Wavefolder = /* @__PURE__ */ defineModule(wavefolderDescriptor);
+var Wavefolder = /* @__PURE__ */ defineModule(wavefolderDescriptor, {
+  worklets: {
+    "shaper": shaper_default
+  }
+});
 export {
   AcidFilter,
   AutoPan,