@jpdutoit/squelchy 0.0.1

package/index.js

@@ -0,0 +1,4846 @@
+import {
+  adsr_envelope_default,
+  bitcrusher_default,
+  comb_filter_default,
+  env_follower_default,
+  fdn_reverb_default,
+  flanger_default,
+  formant_table_default,
+  freq_divider_default,
+  freq_shifter_default,
+  glide_default,
+  ladder_filter_default,
+  map_res_default,
+  map_voct_to_freq_default,
+  map_voct_to_period_default,
+  ping_pong_default,
+  pitch_shifter_default,
+  spring_reverb_default,
+  tape_delay_default,
+  tape_stop_default,
+  vca_default,
+  waveshaper_default
+} from "./chunk-NDUSYSHF.js";
+
+// src/lib-runtime/core.ts
+var pendingSources = {};
+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-MUVFLGPY.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" }));
+      try {
+        await ctx.audioWorklet.addModule(url);
+      } catch (err) {
+        throw new Error(`squelchy: failed to register worklet "${name}": ${err}`);
+      } finally {
+        URL.revokeObjectURL(url);
+      }
+    }))
+  ).then(() => {
+  });
+  registrations.set(ctx, promise);
+  return promise;
+}
+var instanceCounter = 0;
+function defineModule(desc, opts) {
+  if (opts?.worklets) Object.assign(pendingSources, opts.worklets);
+  const meta = { type: desc.type, ports: desc.ports, params: desc.params ?? {} };
+  return {
+    meta,
+    create(ctx, params50 = {}) {
+      const module = { ...desc.createModule(`lib-${desc.type}-${instanceCounter++}`, { x: 0, y: 0 }), ...params50 };
+      const nodes = desc.createNodes(ctx, module);
+      return withPortProperties(new Instance(desc, module, nodes), desc);
+    }
+  };
+}
+var RESERVED_PROPS = /* @__PURE__ */ new Set(["input", "output", "set", "dispose", "params", "then"]);
+function withPortProperties(inst, desc) {
+  const props = /* @__PURE__ */ new Map();
+  for (const [slug, p] of Object.entries(desc.ports)) {
+    if (RESERVED_PROPS.has(slug) || props.has(slug)) continue;
+    props.set(slug, p.type === "output" ? () => inst.output(slug) : () => inst.input(slug));
+  }
+  return new Proxy(inst, {
+    get(target, key, receiver) {
+      if (typeof key === "string") {
+        const hit = props.get(key);
+        if (hit) return hit();
+      }
+      return Reflect.get(target, key, receiver);
+    }
+  });
+}
+var Instance = class {
+  constructor(desc, module, nodes) {
+    this.desc = desc;
+    this.module = module;
+    this.nodes = nodes;
+  }
+  port(slug) {
+    const p = this.desc.ports[slug];
+    if (!p) throw new Error(`squelchy: unknown port "${slug}" on ${this.desc.type}`);
+    return p;
+  }
+  nodeFor(slug) {
+    const p = this.port(slug);
+    const node = p.node ? this.nodes[p.node] : void 0;
+    if (!node) throw new Error(`squelchy: port "${slug}" on ${this.desc.type} has no audio node`);
+    return node;
+  }
+  input(slug) {
+    const p = this.port(slug);
+    const node = this.nodeFor(slug);
+    if (!p.field) return node;
+    return this.resolveParam(p.node, p.field, `port "${slug}"`);
+  }
+  output(slug) {
+    return this.nodeFor(slug);
+  }
+  /** Native AudioParams behind params declaring `node` + `field` (1:1 mapped,
+   *  no conversion) — full Web Audio automation: ramps, curves, CV. */
+  get params() {
+    const out = {};
+    for (const [key, spec] of Object.entries(this.desc.params ?? {})) {
+      if (!spec.node || !spec.field) continue;
+      Object.defineProperty(out, key, { enumerable: true, get: () => this.resolveParam(spec.node, spec.field, `param "${key}"`) });
+    }
+    return out;
+  }
+  resolveParam(nodeKey, field, what) {
+    const node = this.nodes[nodeKey];
+    const param = node?.[field] ?? node?.parameters?.get(field);
+    if (!param || typeof param.setValueAtTime !== "function") throw new Error(`squelchy: ${what} on ${this.desc.type} has no AudioParam "${nodeKey}.${field}"`);
+    return param;
+  }
+  set(key, value) {
+    this.module[key] = value;
+    this.desc.updateParam(this.nodes, this.module, key, value);
+  }
+  dispose() {
+    this.desc.dispose?.(this.nodes);
+    for (const node of Object.values(this.nodes)) {
+      if (typeof node.stop === "function") {
+        try {
+          node.stop();
+        } catch {
+        }
+      }
+      try {
+        node.disconnect();
+      } catch {
+      }
+    }
+  }
+};
+
+// src/lib-runtime/time/transport.ts
+var EPS = 1e-9;
+function isRest(v) {
+  return v == null || v === false || v === 0 || v === "." || v === "-";
+}
+function normStep(s) {
+  if (isRest(s)) return null;
+  if (typeof s === "object" && s !== null && "value" in s) {
+    const o = s;
+    return isRest(o.value) ? null : o;
+  }
+  return { value: s };
+}
+function callVoice(voice2, hit) {
+  if (typeof voice2 === "function") voice2(hit.time, hit);
+  else voice2.trigger(hit.time, hit);
+}
+function createTransport(ctx, opts = {}) {
+  const beatsPerBar = opts.beatsPerBar ?? 4;
+  const lookahead = opts.lookahead ?? 0.1;
+  const offline = typeof ctx.length === "number" && typeof ctx.close !== "function";
+  let bpm = opts.bpm ?? 120;
+  let aBeat = 0;
+  let aTime = 0;
+  let running = false;
+  let horizon = 0;
+  let timer = null;
+  const jobs = /* @__PURE__ */ new Set();
+  const taps = /* @__PURE__ */ new Set();
+  const tapTimers = /* @__PURE__ */ new Set();
+  const spb = () => 60 / bpm;
+  const beatAt = (t2) => aBeat + (t2 - aTime) / spb();
+  const timeAt = (b) => aTime + (b - aBeat) * spb();
+  const current = () => running ? Math.max(0, beatAt(ctx.currentTime + 5e-3)) : 0;
+  function resolve(at) {
+    return resolveNum(at);
+  }
+  function resolveNum(at) {
+    const now2 = current();
+    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;
+    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);
+    };
+    if (offline) {
+      fire();
+      return;
+    }
+    const delay = Math.max(0, (hit.time - ctx.currentTime + latency()) * 1e3);
+    const id = setTimeout(() => {
+      tapTimers.delete(id);
+      fire();
+    }, delay);
+    tapTimers.add(id);
+  }
+  function horizonBeat() {
+    if (offline) return beatAt(ctx.length / ctx.sampleRate);
+    return beatAt(ctx.currentTime + lookahead);
+  }
+  function tick() {
+    if (!running) return;
+    const until = horizonBeat();
+    for (const job of jobs) if (!job.run(until)) jobs.delete(job);
+    horizon = Math.max(horizon, until);
+  }
+  const t = {
+    ctx,
+    beatsPerBar,
+    get bpm() {
+      return bpm;
+    },
+    set bpm(v) {
+      if (!(v > 0)) throw new RangeError("bpm must be > 0");
+      if (running) {
+        const b = Math.max(horizon, beatAt(ctx.currentTime));
+        aTime = timeAt(b);
+        aBeat = b;
+      }
+      bpm = v;
+    },
+    get running() {
+      return running;
+    },
+    start(when = ctx.currentTime + 0.05) {
+      if (running) return;
+      aBeat = 0;
+      aTime = when;
+      horizon = 0;
+      running = true;
+      tick();
+      if (!offline && opts.clock !== "manual") timer = setInterval(tick, 25);
+    },
+    stop() {
+      running = false;
+      if (timer) clearInterval(timer);
+      timer = null;
+      for (const id of tapTimers) clearTimeout(id);
+      tapTimers.clear();
+      jobs.clear();
+    },
+    beatAt,
+    timeAt,
+    resolve,
+    play(pattern, voice2, o = {}) {
+      const every = o.every ?? 0.25;
+      const gate = o.gate ?? 0.5;
+      const swing = o.swing ?? 0;
+      const maxCycles = o.loop === false ? 1 : o.loop === true || o.loop === void 0 ? Infinity : o.loop;
+      let pat = pattern;
+      let pending = null;
+      const startBeat = resolve(o.start ?? "bar");
+      let stopBeat = Infinity;
+      let k = 0;
+      let done = false;
+      const stepBeat = (i) => startBeat + i * every + (i % 2 === 1 ? swing * every * 0.5 : 0);
+      const job = {
+        nextBeat: () => stepBeat(k),
+        run(until) {
+          while (!done) {
+            if (pat.length === 0) {
+              done = true;
+              break;
+            }
+            const idx = k % pat.length;
+            if (idx === 0 && pending) {
+              pat = pending;
+              pending = null;
+              continue;
+            }
+            const cycle = Math.floor(k / pat.length);
+            const b = stepBeat(k);
+            if (cycle >= maxCycles || b >= stopBeat - EPS) {
+              done = true;
+              break;
+            }
+            if (b >= until) break;
+            const s = normStep(pat[idx]);
+            if (s) {
+              const time = timeAt(b);
+              const hit = {
+                time,
+                beat: b,
+                step: idx,
+                cycle,
+                value: s.value,
+                velocity: s.velocity ?? 1,
+                duration: (s.length ?? gate) * every * spb()
+              };
+              callVoice(voice2, hit);
+              emitTap(hit, o.onHit);
+            }
+            k++;
+          }
+          return !done;
+        }
+      };
+      jobs.add(job);
+      if (running) job.run(horizonBeat());
+      return {
+        set(p) {
+          pending = p;
+        },
+        stop(at) {
+          if (at) stopBeat = resolve(at);
+          else {
+            done = true;
+            jobs.delete(job);
+          }
+        },
+        get done() {
+          return done;
+        }
+      };
+    },
+    at(when, fn) {
+      const b = typeof when === "number" ? when : resolve(when);
+      let fired = false;
+      const job = {
+        nextBeat: () => b,
+        run(until) {
+          if (fired) return false;
+          if (b < until) {
+            fired = true;
+            fn(timeAt(b));
+            return false;
+          }
+          return true;
+        }
+      };
+      jobs.add(job);
+      if (running) tick();
+      return () => {
+        fired = true;
+        jobs.delete(job);
+      };
+    },
+    onHit(cb) {
+      taps.add(cb);
+      return () => {
+        taps.delete(cb);
+      };
+    },
+    tick,
+    dispose() {
+      t.stop();
+      taps.clear();
+    }
+  };
+  return t;
+}
+function steps(s) {
+  return [...s.replace(/[\s|]/g, "")].map((c) => c === "x" || c === "X");
+}
+var NOTE_RE = /^([A-Ga-g])([#b]?)(-?\d+)$/;
+var PC = { c: 0, d: 2, e: 4, f: 5, g: 7, a: 9, b: 11 };
+function note(name) {
+  if (typeof name === "number") return name;
+  const m = NOTE_RE.exec(name.trim());
+  if (!m) throw new Error(`note(): can't parse "${name}"`);
+  return (parseInt(m[3], 10) + 1) * 12 + PC[m[1].toLowerCase()] + (m[2] === "#" ? 1 : m[2] === "b" ? -1 : 0);
+}
+function notes(s) {
+  return s.trim().split(/\s+/).map((tok) => tok === "." || tok === "-" ? null : note(tok));
+}
+
+// src/lib/dsp/prng.ts
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function noiseSource(seed) {
+  const rand = mulberry32(seed);
+  return () => rand() * 2 - 1;
+}
+var NOISE_SEEDS = {
+  noiseWhite: 2654435769,
+  noisePink: 2246822507,
+  noiseBrown: 3266489909,
+  loFiCrackle: 668265263,
+  drumSnare: 374761393,
+  drumHat: 3550635116,
+  d808Snare: 4251993797,
+  d808ClosedHat: 3042594569,
+  d808OpenHat: 724231106
+};
+
+// src/lib-runtime/time/voices.ts
+function voice(output, trigger) {
+  return {
+    output,
+    trigger,
+    connect: (d) => {
+      output.connect(d);
+      return d;
+    },
+    disconnect: () => output.disconnect()
+  };
+}
+function noiseBuffer(ctx, seconds, seed) {
+  const n = Math.floor(ctx.sampleRate * seconds);
+  const buf = ctx.createBuffer(1, n, ctx.sampleRate);
+  const d = buf.getChannelData(0);
+  const rand = noiseSource(seed);
+  for (let i = 0; i < n; i++) d[i] = rand();
+  return buf;
+}
+var vel = (h) => Math.max(0, Math.min(1, h?.velocity ?? 1));
+var Kick = {
+  create(ctx) {
+    const out = ctx.createGain();
+    return voice(out, (when, h) => {
+      const osc = ctx.createOscillator();
+      const g = ctx.createGain();
+      osc.frequency.setValueAtTime(150, when);
+      osc.frequency.exponentialRampToValueAtTime(40, when + 0.1);
+      g.gain.setValueAtTime(0.8 * vel(h) + 1e-4, when);
+      g.gain.exponentialRampToValueAtTime(1e-4, when + 0.3);
+      osc.connect(g).connect(out);
+      osc.start(when);
+      osc.stop(when + 0.3);
+    });
+  }
+};
+var Snare = {
+  create(ctx) {
+    const out = ctx.createGain();
+    const buf = noiseBuffer(ctx, 0.15, NOISE_SEEDS.drumSnare);
+    return voice(out, (when, h) => {
+      const v = vel(h);
+      const n = ctx.createBufferSource();
+      n.buffer = buf;
+      const ng = ctx.createGain();
+      ng.gain.setValueAtTime(0.4 * v + 1e-4, when);
+      ng.gain.exponentialRampToValueAtTime(1e-4, when + 0.15);
+      n.connect(ng).connect(out);
+      const osc = ctx.createOscillator();
+      osc.type = "triangle";
+      const og = ctx.createGain();
+      osc.frequency.setValueAtTime(200, when);
+      osc.frequency.exponentialRampToValueAtTime(80, when + 0.05);
+      og.gain.setValueAtTime(0.5 * v + 1e-4, when);
+      og.gain.exponentialRampToValueAtTime(1e-4, when + 0.08);
+      osc.connect(og).connect(out);
+      n.start(when);
+      osc.start(when);
+      osc.stop(when + 0.15);
+    });
+  }
+};
+var Hat = {
+  create(ctx) {
+    const out = ctx.createGain();
+    const buf = noiseBuffer(ctx, 0.05, NOISE_SEEDS.drumHat);
+    return voice(out, (when, h) => {
+      const n = ctx.createBufferSource();
+      n.buffer = buf;
+      const f = ctx.createBiquadFilter();
+      f.type = "highpass";
+      f.frequency.value = 8e3;
+      const g = ctx.createGain();
+      g.gain.setValueAtTime(0.2 * vel(h) + 1e-4, when);
+      g.gain.exponentialRampToValueAtTime(1e-4, when + 0.05);
+      n.connect(f).connect(g).connect(out);
+      n.start(when);
+    });
+  }
+};
+var NoteCv = {
+  create(ctx) {
+    const gate = ctx.createConstantSource();
+    gate.offset.value = 0;
+    gate.start();
+    const pitch = ctx.createConstantSource();
+    pitch.offset.value = 60;
+    pitch.start();
+    return {
+      gate,
+      pitch,
+      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);
+        gate.offset.setValueAtTime(0, time + (h?.duration ?? 0.1));
+      },
+      dispose() {
+        gate.stop();
+        pitch.stop();
+        gate.disconnect();
+        pitch.disconnect();
+      }
+    };
+  }
+};
+
+// src/lib-runtime/units.ts
+var sec = (v) => v;
+var ms = (v) => v;
+var beats = (v) => v;
+var hz = (v) => v;
+var semitones = (v) => v;
+var cents = (v) => v;
+var db = (v) => v;
+var noteToHz = (n) => 440 * 2 ** ((n - 69) / 12);
+var hzToNote = (f) => 69 + 12 * Math.log2(f / 440);
+var transpose = (n, by) => n + by;
+var interval = (a, b) => b - a;
+var centsToSemitones = (c) => c / 100;
+var msToSeconds = (ms2) => ms2 / 1e3;
+var dbToGain = (db2) => 10 ** (db2 / 20);
+var gainToDb = (g) => 20 * Math.log10(g);
+var now = (ctx) => ctx.currentTime;
+var asPitch = (n) => n;
+
+// src/lib/dsp/pulse.ts
+var PULSE_S = 1e-3;
+function pulse(target, when) {
+  const ctx = target.context;
+  const at = Math.max(when ?? 0, ctx.currentTime);
+  const src = ctx.createConstantSource();
+  src.offset.value = 1;
+  src.connect(target);
+  src.start(at);
+  src.stop(at + PULSE_S);
+  src.onended = () => src.disconnect();
+}
+
+// src/lib/samples/types.ts
+var VOICE_KEYS = [
+  "bd",
+  "sd",
+  "rim",
+  "clap",
+  "ch",
+  "oh",
+  "lt",
+  "mt",
+  "ht",
+  "cym",
+  "perc"
+];
+var VOICE_FALLBACKS = {
+  bd: ["lt", "mt"],
+  sd: ["clap", "rim"],
+  rim: ["perc", "ch"],
+  clap: ["sd", "perc"],
+  ch: ["perc", "rim"],
+  oh: ["ch", "cym"],
+  lt: ["mt", "bd"],
+  mt: ["lt", "ht"],
+  ht: ["mt", "lt"],
+  cym: ["oh", "ch"],
+  perc: ["rim", "ch"]
+};
+
+// src/lib-runtime/samples.ts
+var DEFAULT_SAMPLE_BASE_URL = "https://squelchy.studio";
+function defineSampleSets(sets) {
+  return sets;
+}
+async function loadSampleSet(ctx, set, opts = {}) {
+  const base = opts.baseUrl ?? DEFAULT_SAMPLE_BASE_URL;
+  const f = opts.fetch ?? fetch;
+  const buffers = {};
+  await Promise.all(
+    Object.entries(set.voices).map(async ([key, path]) => {
+      const res = await f(new URL(path, base).href);
+      if (!res.ok) throw new Error(`loadSampleSet: ${key} ${res.status}`);
+      buffers[key] = await ctx.decodeAudioData(await res.arrayBuffer());
+    })
+  );
+  return {
+    set,
+    buffers,
+    buffer(key) {
+      return buffers[key] ?? VOICE_FALLBACKS[key].map((k) => buffers[k]).find(Boolean);
+    }
+  };
+}
+var SampleVoice = {
+  create(ctx, kit, key) {
+    const out = ctx.createGain();
+    const buf = kit.buffer(key);
+    const trigger = (when, h) => {
+      if (!buf) return;
+      const src = ctx.createBufferSource();
+      const g = ctx.createGain();
+      src.buffer = buf;
+      if (typeof h?.value === "number") src.playbackRate.value = 2 ** (h.value / 12);
+      g.gain.value = Math.max(0, Math.min(1, h?.velocity ?? 1));
+      src.connect(g).connect(out);
+      src.start(when);
+      if (h?.duration) src.stop(when + h.duration);
+    };
+    return {
+      output: out,
+      trigger,
+      connect: (d) => {
+        out.connect(d);
+        return d;
+      },
+      disconnect: () => out.disconnect()
+    };
+  }
+};
+
+// src/lib-runtime/generated/sample-sets.ts
+var SampleSets = /* @__PURE__ */ defineSampleSets({
+  "roland-808": {
+    "name": "Roland TR-808",
+    "blurb": "The original machine, sampled from hardware. Deep sub kick, ticking hats.",
+    "family": "Machines",
+    "credit": "Michael Fischer / Technopolis TR-808 sample set, released to the public domain",
+    "license": "CC0 1.0 / public domain \u2014 free to use, no attribution required",
+    "licenseUrl": "https://creativecommons.org/publicdomain/zero/1.0/",
+    "voices": {
+      "bd": "/__l5e/assets-v1/c4b2fc55-dcf1-4248-a7fb-2cd3653a659b/roland-808-bd.flac",
+      "ch": "/__l5e/assets-v1/c1ec3b3d-571f-46a6-9d05-12b2fe5f6fc5/roland-808-ch.flac",
+      "clap": "/__l5e/assets-v1/8bd15e4b-96b7-46b6-b26a-35283c816f1e/roland-808-clap.flac",
+      "cym": "/__l5e/assets-v1/033f0719-913a-4a7a-998e-92a7319d806f/roland-808-cym.flac",
+      "ht": "/__l5e/assets-v1/ca555782-7544-446a-a461-9b56b4d30072/roland-808-ht.flac",
+      "lt": "/__l5e/assets-v1/8e100e1c-3844-42aa-bbe7-9eb52b9d704e/roland-808-lt.flac",
+      "mt": "/__l5e/assets-v1/93dd309f-9347-4ea1-909f-56196b08dc88/roland-808-mt.flac",
+      "oh": "/__l5e/assets-v1/4881941c-b558-4159-babd-fe224b0f1543/roland-808-oh.flac",
+      "perc": "/__l5e/assets-v1/d13076b5-50ca-4675-9d4e-70afd6e6203d/roland-808-perc.flac",
+      "rim": "/__l5e/assets-v1/ce82e0e9-402d-4a5e-bf01-59dfb922d1ba/roland-808-rim.flac",
+      "sd": "/__l5e/assets-v1/67a799c9-e019-442b-8025-99d69bc493b9/roland-808-sd.flac"
+    }
+  },
+  "tr-909": {
+    "name": "Roland TR-909",
+    "blurb": "Punchy transistor kick, snappy sampled snare, sizzling metal hats. House and techno.",
+    "family": "Machines",
+    "credit": "MckAudio TR8 sample pack, dedicated to the public domain (CC0)",
+    "license": "CC0 1.0 / public domain \u2014 free to use, no attribution required",
+    "licenseUrl": "https://creativecommons.org/publicdomain/zero/1.0/",
+    "voices": {
+      "bd": "/__l5e/assets-v1/fd3911bb-6783-4db6-bee2-bb8c5a589f26/tr-909-bd.flac",
+      "ch": "/__l5e/assets-v1/6f795c20-fb89-4cd5-b696-3a505d487baa/tr-909-ch.flac",
+      "clap": "/__l5e/assets-v1/7b1ccf8e-0dd6-4189-82d7-03a910e895f2/tr-909-clap.flac",
+      "cym": "/__l5e/assets-v1/f0d5ce25-3238-4e89-bb09-f5b7118fa0a7/tr-909-cym.flac",
+      "ht": "/__l5e/assets-v1/5f9b4c37-25a7-492c-aaed-f7fe24fbfe2c/tr-909-ht.flac",
+      "lt": "/__l5e/assets-v1/8477dddd-b9ed-4957-9a48-b5501bc77056/tr-909-lt.flac",
+      "mt": "/__l5e/assets-v1/92d461e5-d74a-4ba2-a899-4dea1ad06d13/tr-909-mt.flac",
+      "oh": "/__l5e/assets-v1/20c51259-d8d1-4ee3-a1d6-e850c3227b1a/tr-909-oh.flac",
+      "perc": "/__l5e/assets-v1/147d346e-9ae7-4413-a50a-de4f03ef7342/tr-909-perc.flac",
+      "rim": "/__l5e/assets-v1/0c9f157d-1329-4804-aa12-6819651d69fb/tr-909-rim.flac",
+      "sd": "/__l5e/assets-v1/bd8069c2-e07c-4d5c-b05a-fb5b9a31eadb/tr-909-sd.flac"
+    }
+  },
+  "tr-707": {
+    "name": "Roland TR-707",
+    "blurb": "Twelve-bit sampled kit with early-digital crunch. Big eighties snare and claps.",
+    "family": "Machines",
+    "credit": "MckAudio TR8 sample pack, dedicated to the public domain (CC0)",
+    "license": "CC0 1.0 / public domain \u2014 free to use, no attribution required",
+    "licenseUrl": "https://creativecommons.org/publicdomain/zero/1.0/",
+    "voices": {
+      "bd": "/__l5e/assets-v1/825b2c7c-5c5f-411c-8191-306549ee26f2/tr-707-bd.flac",
+      "ch": "/__l5e/assets-v1/6b35b393-7e9c-462d-8d2f-dc834417062b/tr-707-ch.flac",
+      "clap": "/__l5e/assets-v1/efbe819a-b13e-4bf2-a6bd-9bc15a09ff3f/tr-707-clap.flac",
+      "cym": "/__l5e/assets-v1/4a34902b-8592-46d8-b339-05a0648cac4f/tr-707-cym.flac",
+      "ht": "/__l5e/assets-v1/e58beee9-45e5-4b65-af99-a05fcb96f55b/tr-707-ht.flac",
+      "lt": "/__l5e/assets-v1/a0d6f499-4af6-4d34-96de-5ad7c2397229/tr-707-lt.flac",
+      "mt": "/__l5e/assets-v1/6c4bd12b-78ff-4f70-863b-cd482f684eb6/tr-707-mt.flac",
+      "oh": "/__l5e/assets-v1/c07159f3-d763-4698-a786-aeae60d38ac9/tr-707-oh.flac",
+      "perc": "/__l5e/assets-v1/2f8cffcb-8e86-4f65-99db-a705727ed3ab/tr-707-perc.flac",
+      "rim": "/__l5e/assets-v1/3d6445b1-38bd-4e9f-b048-db8c079b3c03/tr-707-rim.flac",
+      "sd": "/__l5e/assets-v1/aaf70dd8-c740-4b05-9369-feb80f3e26be/tr-707-sd.flac"
+    }
+  },
+  "tr-606": {
+    "name": "Roland TR-606",
+    "blurb": "Tiny Drumatix voices \u2014 thin kick, spitty snare, ticking hats. Perfect with a 303.",
+    "family": "Machines",
+    "credit": "MckAudio TR8 sample pack, dedicated to the public domain (CC0)",
+    "license": "CC0 1.0 / public domain \u2014 free to use, no attribution required",
+    "licenseUrl": "https://creativecommons.org/publicdomain/zero/1.0/",
+    "voices": {
+      "bd": "/__l5e/assets-v1/f46ec897-9319-4c25-b63b-74df979de508/tr-606-bd.flac",
+      "ch": "/__l5e/assets-v1/f4c57254-c711-43b0-82c6-52b011e205ba/tr-606-ch.flac",
+      "cym": "/__l5e/assets-v1/db524ec1-36d3-43db-bfc4-fd84a1ddd2ac/tr-606-cym.flac",
+      "ht": "/__l5e/assets-v1/74b486cf-c1f1-45c7-bd2a-4fd0c3794e1a/tr-606-ht.flac",
+      "lt": "/__l5e/assets-v1/6b1a564f-6388-40c1-8028-3ea9b6824256/tr-606-lt.flac",
+      "mt": "/__l5e/assets-v1/d871a86a-fcc8-45a6-b5a4-83977a689593/tr-606-mt.flac",
+      "oh": "/__l5e/assets-v1/a4c607d2-d62c-49b5-ac99-549fd6262468/tr-606-oh.flac",
+      "sd": "/__l5e/assets-v1/2062f1d4-e34f-406f-911b-2eb2ec523a89/tr-606-sd.flac"
+    }
+  },
+  "compu-78": {
+    "name": "Compu-78",
+    "blurb": "Tiny, dry preset-box percussion. Bossa nova organ rhythm energy.",
+    "family": "Machines",
+    "credit": "Synthesised for Squelchy",
+    "license": "CC0 1.0 / public domain \u2014 free to use, no attribution required",
+    "licenseUrl": "https://creativecommons.org/publicdomain/zero/1.0/",
+    "voices": {
+      "bd": "/__l5e/assets-v1/150a91e2-8b92-40f2-80e0-10b30f10976b/compu-78-bd.flac",
+      "ch": "/__l5e/assets-v1/da9dcfc4-5f29-43b9-979f-9679edeb09ed/compu-78-ch.flac",
+      "clap": "/__l5e/assets-v1/f3b5d485-44bc-4b34-b2bc-d37f436dffc2/compu-78-clap.flac",
+      "cym": "/__l5e/assets-v1/627db2bf-08d5-4054-8de9-b8ec0ca4436a/compu-78-cym.flac",
+      "ht": "/__l5e/assets-v1/1323f20c-3c98-45fb-abd1-e4b1e4be158f/compu-78-ht.flac",
+      "lt": "/__l5e/assets-v1/ba67ce5c-3f01-4e1b-9fd8-a96bb5428cf4/compu-78-lt.flac",
+      "mt": "/__l5e/assets-v1/f8cd42d6-2f98-4e9d-9428-ba091ec125cf/compu-78-mt.flac",
+      "oh": "/__l5e/assets-v1/b4a1d5b2-0022-4f1b-ac52-1618ba03ea67/compu-78-oh.flac",
+      "perc": "/__l5e/assets-v1/55e15a92-ba17-48cb-aec0-47e5198f073f/compu-78-perc.flac",
+      "rim": "/__l5e/assets-v1/698aaf24-8e84-4b3b-8f13-dc95f2b3f157/compu-78-rim.flac",
+      "sd": "/__l5e/assets-v1/41357245-d767-410e-8415-08dbb9e7503e/compu-78-sd.flac"
+    }
+  },
+  "dr5-studio": {
+    "name": "Studio Kit",
+    "blurb": "Acoustic drums in a small dry room. Skin, air and a little ambience.",
+    "family": "Acoustic",
+    "credit": "MckAudio DR5 sample pack, dedicated to the public domain (CC0)",
+    "license": "CC0 1.0 / public domain \u2014 free to use, no attribution required",
+    "licenseUrl": "https://creativecommons.org/publicdomain/zero/1.0/",
+    "voices": {
+      "bd": "/__l5e/assets-v1/9bc4c40f-432c-4fd1-98f8-dc3343b5dd31/dr5-studio-bd.flac",
+      "ch": "/__l5e/assets-v1/862411a4-6d87-45e7-a3a2-2c4062f8e79b/dr5-studio-ch.flac",
+      "clap": "/__l5e/assets-v1/2feebc4f-49d2-4ea0-9b5a-890059c24a9c/dr5-studio-clap.flac",
+      "cym": "/__l5e/assets-v1/5abff1b5-b403-403b-b681-9ac37a394442/dr5-studio-cym.flac",
+      "ht": "/__l5e/assets-v1/4e6883a5-e310-4035-a6ae-ee4033c7a0a1/dr5-studio-ht.flac",
+      "lt": "/__l5e/assets-v1/faf35ae9-f89f-4ceb-ad5e-c562dd5d261a/dr5-studio-lt.flac",
+      "mt": "/__l5e/assets-v1/4b923b44-9e79-4aa0-a9ef-4178a9f0279b/dr5-studio-mt.flac",
+      "oh": "/__l5e/assets-v1/5a5e6d0c-4c8f-4dc5-9dea-55f90083a55a/dr5-studio-oh.flac",
+      "perc": "/__l5e/assets-v1/8d286dd0-4201-49f6-9738-0a39e3a3d860/dr5-studio-perc.flac",
+      "rim": "/__l5e/assets-v1/1d139e86-288e-48bd-baba-f7d2502271a5/dr5-studio-rim.flac",
+      "sd": "/__l5e/assets-v1/eb7b02d6-7063-4350-9515-40010dd583cb/dr5-studio-sd.flac"
+    }
+  },
+  "tape-dust": {
+    "name": "Tape Dust",
+    "blurb": "Wobbly, hissy and rolled-off. Everything through a tired cassette.",
+    "family": "Character",
+    "credit": "Synthesised for Squelchy",
+    "license": "CC0 1.0 / public domain \u2014 free to use, no attribution required",
+    "licenseUrl": "https://creativecommons.org/publicdomain/zero/1.0/",
+    "voices": {
+      "bd": "/__l5e/assets-v1/7e90ada0-1da8-4930-9c05-48c395e8a863/tape-dust-bd.flac",
+      "ch": "/__l5e/assets-v1/538fd73f-f7ee-408e-ab69-f8865506f4f5/tape-dust-ch.flac",
+      "clap": "/__l5e/assets-v1/21b5b5ea-6dce-495d-b740-e7162941c972/tape-dust-clap.flac",
+      "cym": "/__l5e/assets-v1/ac1a7f2d-9a96-4f61-b2ec-743854f15bbe/tape-dust-cym.flac",
+      "ht": "/__l5e/assets-v1/93dd3f9c-8267-4f4e-b292-807cf0022c9e/tape-dust-ht.flac",
+      "lt": "/__l5e/assets-v1/7a51ff67-62ec-408b-b6c3-4a0cae248eaf/tape-dust-lt.flac",
+      "mt": "/__l5e/assets-v1/ba3340c5-6ead-419a-836a-a041448f06da/tape-dust-mt.flac",
+      "oh": "/__l5e/assets-v1/e924553d-ac9a-427e-a69a-2939032ee618/tape-dust-oh.flac",
+      "perc": "/__l5e/assets-v1/abfad1e6-998b-47a8-8c98-6f511c151143/tape-dust-perc.flac",
+      "rim": "/__l5e/assets-v1/c86262d8-9711-41d4-b866-19a1ffcaf443/tape-dust-rim.flac",
+      "sd": "/__l5e/assets-v1/2d1090cf-0284-4c33-9ba2-430c5c7b4730/tape-dust-sd.flac"
+    }
+  },
+  "hard-cell": {
+    "name": "Hard Cell",
+    "blurb": "Overdriven and bit-crushed. Industrial techno with no headroom left.",
+    "family": "Character",
+    "credit": "Synthesised for Squelchy",
+    "license": "CC0 1.0 / public domain \u2014 free to use, no attribution required",
+    "licenseUrl": "https://creativecommons.org/publicdomain/zero/1.0/",
+    "voices": {
+      "bd": "/__l5e/assets-v1/d8f1c5cf-8e07-4a1e-a519-d7f69781329b/hard-cell-bd.flac",
+      "ch": "/__l5e/assets-v1/c3275e9a-dd79-4ac8-b4b9-84ebe25b5529/hard-cell-ch.flac",
+      "clap": "/__l5e/assets-v1/160a5d2c-01e0-49da-a998-149a0cf08317/hard-cell-clap.flac",
+      "cym": "/__l5e/assets-v1/910f3623-0209-439f-9e34-0c0f842bc78f/hard-cell-cym.flac",
+      "ht": "/__l5e/assets-v1/36f5b37b-9d44-49b8-a57b-bf5d2a1aa523/hard-cell-ht.flac",
+      "lt": "/__l5e/assets-v1/6065e512-578b-477f-88d9-49b3ccccacea/hard-cell-lt.flac",
+      "mt": "/__l5e/assets-v1/4e33c147-b8da-4b03-abca-4fd254d5006d/hard-cell-mt.flac",
+      "oh": "/__l5e/assets-v1/3e5b3bce-f21b-4ecb-8f28-375ce871427f/hard-cell-oh.flac",
+      "perc": "/__l5e/assets-v1/ab27e781-3d41-4e04-8f44-f7a568543586/hard-cell-perc.flac",
+      "rim": "/__l5e/assets-v1/ea2989c5-2354-4574-ae38-4786deeee151/hard-cell-rim.flac",
+      "sd": "/__l5e/assets-v1/5bd3dca9-bdb7-4618-8e0b-9ed1c0b062c7/hard-cell-sd.flac"
+    }
+  },
+  "rx5-fm": {
+    "name": "Yamaha RX5",
+    "blurb": "FM percussion \u2014 glassy, bell-like, unmistakably late-eighties digital.",
+    "family": "Digital",
+    "credit": "MckAudio RX5 sample pack, dedicated to the public domain (CC0)",
+    "license": "CC0 1.0 / public domain \u2014 free to use, no attribution required",
+    "licenseUrl": "https://creativecommons.org/publicdomain/zero/1.0/",
+    "voices": {
+      "bd": "/__l5e/assets-v1/22b27f9f-d301-48e2-a0e4-e6b6e538ec31/rx5-fm-bd.flac",
+      "ch": "/__l5e/assets-v1/236fb4f5-7d2a-48c0-be18-bc3777a6be91/rx5-fm-ch.flac",
+      "clap": "/__l5e/assets-v1/58402fc0-996c-4577-9074-bb40b585c26e/rx5-fm-clap.flac",
+      "cym": "/__l5e/assets-v1/d3e6ba9b-a2b8-4467-8923-97594723720e/rx5-fm-cym.flac",
+      "ht": "/__l5e/assets-v1/a5edef5d-7861-4b3a-99bc-10ece111ca64/rx5-fm-ht.flac",
+      "lt": "/__l5e/assets-v1/7151d30d-fe90-4ac5-9c9f-e91a808a1efa/rx5-fm-lt.flac",
+      "mt": "/__l5e/assets-v1/46119925-9ecd-431a-94ee-2135c8ce4382/rx5-fm-mt.flac",
+      "oh": "/__l5e/assets-v1/9fe4938f-fda7-43f8-84c6-c53325fd674c/rx5-fm-oh.flac",
+      "perc": "/__l5e/assets-v1/1aa471d4-4737-45e6-9070-6301892dcdfa/rx5-fm-perc.flac",
+      "rim": "/__l5e/assets-v1/2b0409a0-1aa6-41a4-9593-553247a2e624/rx5-fm-rim.flac",
+      "sd": "/__l5e/assets-v1/3d9c426c-7783-4106-940f-1e6b6405bdd5/rx5-fm-sd.flac"
+    }
+  },
+  "micro-click": {
+    "name": "Micro Click",
+    "blurb": "Clicks, ticks and pops. Minimal and micro-house, nothing sustains.",
+    "family": "Digital",
+    "credit": "Synthesised for Squelchy",
+    "license": "CC0 1.0 / public domain \u2014 free to use, no attribution required",
+    "licenseUrl": "https://creativecommons.org/publicdomain/zero/1.0/",
+    "voices": {
+      "bd": "/__l5e/assets-v1/58e3ce80-d300-47c6-8d79-52b00376550f/micro-click-bd.flac",
+      "ch": "/__l5e/assets-v1/1c12e400-5c5f-4aae-b006-5a3fe3c6ef2c/micro-click-ch.flac",
+      "clap": "/__l5e/assets-v1/b1f402f6-a85d-421b-9684-4b78719726d5/micro-click-clap.flac",
+      "cym": "/__l5e/assets-v1/fe501055-43d7-427f-9ab4-5efd0423292e/micro-click-cym.flac",
+      "ht": "/__l5e/assets-v1/3aab93cb-cd84-4600-a3e5-458fa74a2a86/micro-click-ht.flac",
+      "lt": "/__l5e/assets-v1/b09a0d61-c9a2-4b31-b0f2-10d3c10ef83c/micro-click-lt.flac",
+      "mt": "/__l5e/assets-v1/988e7a56-e914-43ad-aff1-71ec3a04b8e4/micro-click-mt.flac",
+      "oh": "/__l5e/assets-v1/122a3f93-4542-471b-b390-996665248653/micro-click-oh.flac",
+      "perc": "/__l5e/assets-v1/cae413d7-a68c-411a-a4b4-b7c20a83946d/micro-click-perc.flac",
+      "rim": "/__l5e/assets-v1/41922292-1c6e-4bef-ac8e-fa1ce09eefca/micro-click-rim.flac",
+      "sd": "/__l5e/assets-v1/6218ccdd-cba1-466e-af8b-665d7a2d4640/micro-click-sd.flac"
+    }
+  },
+  "deep-analogue": {
+    "name": "Deep Analogue",
+    "blurb": "Long sub kick, soft snare, warm hats. Deep house at three in the morning.",
+    "family": "Acoustic",
+    "credit": "Synthesised for Squelchy",
+    "license": "CC0 1.0 / public domain \u2014 free to use, no attribution required",
+    "licenseUrl": "https://creativecommons.org/publicdomain/zero/1.0/",
+    "voices": {
+      "bd": "/__l5e/assets-v1/93c55e12-44f1-4cf9-8b19-82833257a68f/deep-analogue-bd.flac",
+      "ch": "/__l5e/assets-v1/7c881111-83d8-4c1a-b4af-4f09d2a09f4b/deep-analogue-ch.flac",
+      "clap": "/__l5e/assets-v1/e8b67bb8-8f7f-4b87-9ee4-d9cb7bc43efe/deep-analogue-clap.flac",
+      "cym": "/__l5e/assets-v1/b329f9e1-3eb0-471c-b7c7-8ad7f639323f/deep-analogue-cym.flac",
+      "ht": "/__l5e/assets-v1/a381a6b5-fd09-4fa6-b88e-86a29b8f25d9/deep-analogue-ht.flac",
+      "lt": "/__l5e/assets-v1/c9ebc90a-20aa-4f76-9e79-f440258d4bac/deep-analogue-lt.flac",
+      "mt": "/__l5e/assets-v1/5e1b803c-748e-4f09-bed7-c7b4511dc8b0/deep-analogue-mt.flac",
+      "oh": "/__l5e/assets-v1/289d67f2-6d55-4a04-8607-302442465e81/deep-analogue-oh.flac",
+      "perc": "/__l5e/assets-v1/8ef1f592-a3a4-45a5-9ea4-80362953aee4/deep-analogue-perc.flac",
+      "rim": "/__l5e/assets-v1/102a1c23-6e5f-468e-95c8-e414ce849884/deep-analogue-rim.flac",
+      "sd": "/__l5e/assets-v1/9be98c57-13c4-4337-bb2f-53c0b2ff7150/deep-analogue-sd.flac"
+    }
+  }
+});
+
+// src/modules/ModuleDescriptor.ts
+function paramDefaults(params50) {
+  const out = {};
+  for (const k in params50) out[k] = params50[k].default;
+  return out;
+}
+function defineDescriptor(desc) {
+  if (desc.params && !desc.controlDescriptions) {
+    const cd = {};
+    for (const p of Object.values(desc.params)) {
+      if (p.kind !== "enum" && p.label) cd[p.label] = { short: p.short, long: p.long };
+    }
+    return { ...desc, controlDescriptions: cd };
+  }
+  return desc;
+}
+
+// src/lib-runtime/generated/worklet-factories.ts
+function createVoctFreqNode(ctx) {
+  return new AudioWorkletNode(ctx, "map-voct-to-freq", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    outputChannelCount: [1]
+  });
+}
+function createVoctPeriodNode(ctx) {
+  return new AudioWorkletNode(ctx, "map-voct-to-period", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    outputChannelCount: [1]
+  });
+}
+function createAdsrNode(ctx, init) {
+  const node = new AudioWorkletNode(ctx, "adsr-envelope", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    outputChannelCount: [1]
+  });
+  if (init) {
+    for (const [k, v] of Object.entries(init)) {
+      if (v === void 0) continue;
+      const p = node.parameters.get(k);
+      if (p) p.value = v;
+    }
+  }
+  return node;
+}
+function createFormantNode(ctx) {
+  return new AudioWorkletNode(ctx, "formant-table", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    outputChannelCount: [5]
+  });
+}
+function createBitcrusherNode(ctx) {
+  return new AudioWorkletNode(ctx, "bitcrusher", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    outputChannelCount: [1]
+  });
+}
+function createSubOctaveNode(ctx) {
+  return new AudioWorkletNode(ctx, "freq-divider", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    outputChannelCount: [1]
+  });
+}
+function createEnvFollowerNode(ctx) {
+  return new AudioWorkletNode(ctx, "env-follower", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    outputChannelCount: [1]
+  });
+}
+function createWaveshaperNode(ctx) {
+  return new AudioWorkletNode(ctx, "waveshaper", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    outputChannelCount: [1]
+  });
+}
+function createGlideNode(ctx) {
+  return new AudioWorkletNode(ctx, "glide", {
+    numberOfInputs: 2,
+    numberOfOutputs: 1,
+    outputChannelCount: [1]
+  });
+}
+function createTapeStopNode(ctx, time = 0.5, mix = 1) {
+  return new AudioWorkletNode(ctx, "tape-stop", {
+    numberOfInputs: 2,
+    numberOfOutputs: 1,
+    outputChannelCount: [2],
+    channelCount: 2,
+    channelCountMode: "explicit",
+    parameterData: { time, mix }
+  });
+}
+function createSpringReverbNode(ctx, params50) {
+  return new AudioWorkletNode(ctx, "spring-reverb", {
+    numberOfInputs: 2,
+    numberOfOutputs: 1,
+    outputChannelCount: [2],
+    channelCount: 2,
+    channelCountMode: "explicit",
+    parameterData: { decay: params50.decay, tone: params50.tone, drip: params50.drip }
+  });
+}
+function createFdnReverbNode(ctx, opts) {
+  return new AudioWorkletNode(ctx, "fdn-reverb", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    // Stereo tank: L/R in (mono upmixes to L=R → identical mid), L/R out.
+    outputChannelCount: [2],
+    channelCount: 2,
+    channelCountMode: "explicit",
+    parameterData: { rt60: opts.rt60, damping: opts.damping },
+    processorOptions: {
+      size: opts.size ?? 1,
+      feedbackCeiling: opts.feedbackCeiling ?? 0.97
+    }
+  });
+}
+function createFreqShifterNode(ctx, shift = 0) {
+  return new AudioWorkletNode(ctx, "freq-shifter", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    outputChannelCount: [1],
+    parameterData: { shift }
+  });
+}
+function createOctaverDividerNode(ctx) {
+  return new AudioWorkletNode(ctx, "freq-divider", {
+    numberOfInputs: 1,
+    numberOfOutputs: 3,
+    outputChannelCount: [1, 2, 1]
+  });
+}
+function createPitchShifterNode(ctx, semitones2 = 12) {
+  return new AudioWorkletNode(ctx, "pitch-shifter", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    outputChannelCount: [1],
+    channelCount: 1,
+    channelCountMode: "explicit",
+    parameterData: { semitones: semitones2 }
+  });
+}
+function createVcaNode(ctx, gain = 0.5, cvAmount = 1) {
+  return new AudioWorkletNode(ctx, "vca", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    parameterData: { gain, cvAmount }
+  });
+}
+function createLadderFilterNode(ctx, init) {
+  return new AudioWorkletNode(ctx, "ladder-filter", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    parameterData: {
+      cutoff: 0,
+      resonance: init?.resonance ?? 0.6,
+      drive: init?.drive ?? 0.3
+    }
+  });
+}
+function createMapResNode(ctx, init) {
+  const qMin = init?.qMin ?? 0.1;
+  const qMax = init?.qMax ?? 20;
+  return new AudioWorkletNode(ctx, "map-res", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    parameterData: {
+      base: init?.base ?? 1,
+      cvScale: init?.cvScale ?? qMax - qMin,
+      qMin,
+      qMax,
+      dbOut: init?.dbOut === false ? 0 : 1
+    }
+  });
+}
+function createCombFilterNode(ctx, feedback = 0.7, maxPeriod = 0.1, channels = 1) {
+  return new AudioWorkletNode(ctx, "comb-filter", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    outputChannelCount: [channels],
+    channelCount: channels,
+    channelCountMode: "explicit",
+    channelInterpretation: "speakers",
+    parameterData: { period: 0, feedback },
+    processorOptions: { maxPeriod }
+  });
+}
+function createFlangerNode(ctx, opts) {
+  return new AudioWorkletNode(ctx, "flanger", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    parameterData: { rate: opts.rate, depth: opts.depth, feedback: opts.feedback }
+  });
+}
+function createTapeDelayNode(ctx, opts) {
+  return new AudioWorkletNode(ctx, "tape-delay", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    parameterData: { ...opts }
+  });
+}
+function createPingPongNode(ctx, opts) {
+  return new AudioWorkletNode(ctx, "ping-pong", {
+    numberOfInputs: 1,
+    numberOfOutputs: 2,
+    parameterData: { ...opts }
+  });
+}
+
+// src/lib-runtime/generated/modules/303-filter.tsx
+var params = {
+  note: { node: "_cutoffVoct", field: "transpose", unit: "note", default: 67, min: 15, max: 135 },
+  // Split across two cascaded biquads' Q (0.7x / 0.4x) — not a single
+  // AudioParam — so this stays set-only.
+  resonance: { unit: "factor", default: 8, min: 0, max: 15, scale: "sqrt" },
+  envMod: { unit: "factor", default: 0.7, min: 0, max: 1 },
+  accent: { unit: "factor", default: 0.5, min: 0, max: 1 },
+  decay: { node: "envSmoother", field: "decay", unit: "s", default: 0.2, min: 0.05, max: 1, scale: "log" }
+};
+var filter303Descriptor = /* @__PURE__ */ defineDescriptor({
+  type: "303-filter",
+  params,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "trigger": { type: "input", signal: "gate", node: "trigInput" },
+    "modFreq": { type: "modulation", signal: "modulation", node: "_cutoffVoct" }
+  },
+  createModule(id, position) {
+    return { id, type: "303-filter", position, ...paramDefaults(params) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const filter1 = ctx.createBiquadFilter();
+    filter1.type = "lowpass";
+    filter1.frequency.value = 0;
+    filter1.Q.value = module.resonance * 0.7;
+    const filter2 = ctx.createBiquadFilter();
+    filter2.type = "lowpass";
+    filter2.frequency.value = 0;
+    filter2.Q.value = module.resonance * 0.4;
+    const accentVCA = ctx.createGain();
+    accentVCA.gain.value = 1;
+    const output = ctx.createGain();
+    const _cutoffVoct = createVoctFreqNode(ctx);
+    _cutoffVoct.parameters.get("transpose").value = module.note;
+    const _cutoffBase = ctx.createConstantSource();
+    _cutoffBase.offset.value = 0;
+    _cutoffBase.start();
+    _cutoffBase.connect(_cutoffVoct);
+    _cutoffVoct.connect(filter1.frequency);
+    _cutoffVoct.connect(filter2.frequency);
+    const trigInput = ctx.createGain();
+    const envSmoother = createAdsrNode(ctx, {
+      attack: 3e-3,
+      decay: module.decay,
+      sustain: 0,
+      release: 0.01
+    });
+    const envDepth = ctx.createGain();
+    envDepth.gain.value = module.envMod * (1 + module.accent) * 36;
+    const accentEnvGain = ctx.createGain();
+    accentEnvGain.gain.value = module.accent * 0.5;
+    input.connect(filter1);
+    filter1.connect(filter2);
+    filter2.connect(accentVCA);
+    accentVCA.connect(output);
+    trigInput.connect(envSmoother);
+    envSmoother.connect(envDepth);
+    envDepth.connect(_cutoffVoct);
+    envSmoother.connect(accentEnvGain);
+    accentEnvGain.connect(accentVCA.gain);
+    return { input, output, trigInput, filter1, filter2, accentVCA, accentEnvGain, envSmoother, envDepth, _cutoffVoct, _cutoffBase };
+  },
+  updateParam(nodes, module, param, value) {
+    switch (param) {
+      case "note":
+        nodes._cutoffVoct.parameters.get("transpose").value = value;
+        break;
+      case "resonance": {
+        const q = value;
+        nodes.filter1.Q.value = q * 0.7;
+        nodes.filter2.Q.value = q * 0.4;
+        break;
+      }
+      case "envMod":
+        nodes.envDepth.gain.value = value * (1 + module.accent) * 36;
+        break;
+      case "accent": {
+        const acc = value;
+        nodes.envDepth.gain.value = module.envMod * (1 + acc) * 36;
+        nodes.accentEnvGain.gain.value = acc * 0.5;
+        break;
+      }
+      case "decay": {
+        const p = nodes.envSmoother.parameters.get("decay");
+        if (p) p.value = value;
+        break;
+      }
+    }
+  },
+  dispose(nodes) {
+    nodes._cutoffBase.stop();
+  }
+});
+
+// src/lib-runtime/generated/modules/303-filter.wrapper.ts
+var AcidFilter = /* @__PURE__ */ defineModule(filter303Descriptor, {
+  worklets: {
+    "adsr-envelope": adsr_envelope_default,
+    "map-voct-to-freq": map_voct_to_freq_default
+  }
+});
+
+// src/lib-runtime/generated/modules/auto-pan.tsx
+var shapes = ["sine", "triangle", "square"];
+var params2 = {
+  rate: { node: "lfo", field: "frequency", 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" }
+};
+var autoPanDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "auto-pan",
+  params: params2,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "modRate": { type: "modulation", signal: "modulation", node: "lfo", field: "frequency" },
+    "modDepth": { type: "modulation", signal: "modulation", node: "lfoGain", field: "gain" }
+  },
+  createModule(id, position) {
+    return { id, type: "auto-pan", position, ...paramDefaults(params2) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const panner = ctx.createStereoPanner();
+    const output = ctx.createGain();
+    const lfo = ctx.createOscillator();
+    const lfoGain = ctx.createGain();
+    lfo.type = module.shape;
+    lfo.frequency.value = module.rate;
+    lfoGain.gain.value = module.depth;
+    lfo.connect(lfoGain);
+    lfoGain.connect(panner.pan);
+    lfo.start();
+    input.connect(panner);
+    panner.connect(output);
+    return { input, output, lfo, lfoGain };
+  },
+  updateParam(nodes, _m, param, value) {
+    if (param === "rate") {
+      nodes.lfo.frequency.value = value;
+    } else if (param === "depth") {
+      nodes.lfoGain.gain.value = value;
+    } else if (param === "shape") {
+      nodes.lfo.type = value;
+    }
+  },
+  dispose(nodes) {
+    nodes.lfo.stop();
+  }
+});
+
+// src/lib-runtime/generated/modules/auto-pan.wrapper.ts
+var AutoPan = /* @__PURE__ */ defineModule(autoPanDescriptor);
+
+// src/lib/dsp/mix.ts
+var CURVE_POINTS = 2049;
+function lawCurve(fn) {
+  const c = new Float32Array(CURVE_POINTS);
+  for (let i = 0; i < CURVE_POINTS; i++) {
+    const x = -1 + 2 * i / (CURVE_POINTS - 1);
+    c[i] = fn(Math.min(1, Math.max(0, x)));
+  }
+  return c;
+}
+function createMix(ctx, dry, wet, value, law, wetScale = 1) {
+  const mix = ctx.createConstantSource();
+  mix.offset.value = value;
+  let toWet = mix;
+  if (law === "linear") {
+    dry.gain.value = 1;
+    const invert = ctx.createGain();
+    invert.gain.value = -1;
+    mix.connect(invert).connect(dry.gain);
+  } else {
+    dry.gain.value = 0;
+    const cos = ctx.createWaveShaper();
+    cos.curve = lawCurve((m) => Math.cos(m * 0.5 * Math.PI));
+    const sin = ctx.createWaveShaper();
+    sin.curve = lawCurve((m) => Math.sin(m * 0.5 * Math.PI));
+    mix.connect(cos).connect(dry.gain);
+    toWet = mix.connect(sin);
+  }
+  wet.gain.value = 0;
+  if (wetScale !== 1) {
+    const scale = ctx.createGain();
+    scale.gain.value = wetScale;
+    toWet = toWet.connect(scale);
+  }
+  toWet.connect(wet.gain);
+  mix.start();
+  return mix;
+}
+
+// src/lib-runtime/generated/modules/bitcrusher.tsx
+var params3 = {
+  bits: { node: "crusher", field: "bits", unit: "factor", default: 8, min: 1, max: 16 },
+  rate: { node: "crusher", field: "rate", unit: "factor", default: 0.5, min: 0.01, max: 1, scale: "log" },
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 1, min: 0, max: 1 }
+};
+var bitcrusherDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "bitcrusher",
+  params: params3,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "bitcrusher", position, ...paramDefaults(params3) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const crusher = createBitcrusherNode(ctx);
+    const cp = crusher.parameters;
+    cp.get("bits").value = module.bits;
+    cp.get("rate").value = module.rate;
+    const _mix = createMix(ctx, dryGain, wetGain, module.mix, "linear");
+    input.connect(dryGain);
+    input.connect(crusher);
+    crusher.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return { input, output, crusher, dryGain, wetGain, _mix };
+  },
+  updateParam(nodes, _m, param, value) {
+    if (param === "bits") {
+      nodes.crusher.parameters.get("bits").value = value;
+    } else if (param === "rate") {
+      nodes.crusher.parameters.get("rate").value = value;
+    } else if (param === "mix") {
+      nodes._mix.offset.value = value;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/bitcrusher.wrapper.ts
+var Bitcrusher = /* @__PURE__ */ defineModule(bitcrusherDescriptor, {
+  worklets: {
+    "bitcrusher": bitcrusher_default
+  }
+});
+
+// src/lib-runtime/generated/modules/chorus.tsx
+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 },
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 0.5, min: 0, max: 1 }
+};
+var chorusDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "chorus",
+  params: params4,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "modRate": { type: "modulation", signal: "modulation", node: "lfo", field: "frequency" },
+    "modMix": { type: "modulation", signal: "modulation", node: "_mix", field: "offset" }
+  },
+  createModule(id, position) {
+    return { id, type: "chorus", position, ...paramDefaults(params4) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const monoIn = ctx.createGain();
+    monoIn.channelCount = 1;
+    monoIn.channelCountMode = "explicit";
+    monoIn.channelInterpretation = "speakers";
+    const delayL = ctx.createDelay(0.1);
+    const delayR = ctx.createDelay(0.1);
+    const lfo = ctx.createOscillator();
+    const lfoGain = ctx.createGain();
+    const lfoInv = ctx.createGain();
+    const merger = ctx.createChannelMerger(2);
+    delayL.delayTime.value = 0.02;
+    delayR.delayTime.value = 0.02;
+    const _mix = ctx.createConstantSource();
+    _mix.offset.value = module.mix;
+    dryGain.gain.value = 1;
+    const dryTap = ctx.createGain();
+    dryTap.gain.value = -0.5;
+    _mix.connect(dryTap).connect(dryGain.gain);
+    wetGain.gain.value = 0;
+    _mix.connect(wetGain.gain);
+    _mix.start();
+    lfo.type = "sine";
+    lfo.frequency.value = module.rate;
+    lfoGain.gain.value = module.depth * 0.01;
+    lfoInv.gain.value = -1;
+    lfo.connect(lfoGain);
+    lfoGain.connect(delayL.delayTime);
+    lfoGain.connect(lfoInv);
+    lfoInv.connect(delayR.delayTime);
+    lfo.start();
+    input.connect(dryGain);
+    input.connect(monoIn);
+    monoIn.connect(delayL);
+    monoIn.connect(delayR);
+    delayL.connect(merger, 0, 0);
+    delayR.connect(merger, 0, 1);
+    merger.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return { input, output, lfo, lfoGain, lfoInv, dryGain, wetGain, monoIn, delayL, delayR, merger, _mix };
+  },
+  updateParam(nodes, _m, param, value) {
+    switch (param) {
+      case "rate":
+        nodes.lfo.frequency.value = value;
+        break;
+      case "depth":
+        nodes.lfoGain.gain.value = value * 0.01;
+        break;
+      case "mix":
+        nodes._mix.offset.value = value;
+        break;
+    }
+  },
+  dispose(nodes) {
+    nodes.lfo.stop();
+    nodes._mix.stop();
+  }
+});
+
+// src/lib-runtime/generated/modules/chorus.wrapper.ts
+var Chorus = /* @__PURE__ */ defineModule(chorusDescriptor);
+
+// src/types/synth.ts
+function hzToMidi(hz2) {
+  return 12 * Math.log2(hz2 / 440) + 69;
+}
+
+// src/lib-runtime/generated/modules/comb-filter.tsx
+var params5 = {
+  offset: { node: "_freqVoct", field: "transpose", default: 55, min: -48, max: 96, unit: "semitone" },
+  feedback: { node: "comb", field: "feedback", unit: "factor", default: 0.7, min: 0, max: 0.95 },
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 0.5, min: 0, max: 1 },
+  tuning: { kind: "enum", options: ["chromatic", "free"], default: "chromatic" }
+};
+var patchCount = /* @__PURE__ */ new WeakMap();
+var combFilterDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "comb-filter",
+  params: params5,
+  // Panel controls diverge from params (the ribbon edits two memories that
+  // feed `offset`), so they are listed here, not derived from labels.
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "voct": { type: "input", signal: "pitch", node: "_freqVoct" },
+    "modFreq": { type: "modulation", signal: "modulation", node: "_freqVoct" }
+  },
+  createModule(id, position) {
+    const { offset: _dsp, ...rest } = paramDefaults(params5);
+    return { id, type: "comb-filter", position, ...rest, frequency: 200, transpose: 0 };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const comb = createCombFilterNode(ctx, module.feedback);
+    const _freqVoct = createVoctPeriodNode(ctx);
+    _freqVoct.parameters.get("transpose").value = module.offset ?? hzToMidi(module.frequency);
+    const periodParam = comb.parameters.get("period");
+    periodParam.value = 0;
+    _freqVoct.connect(periodParam);
+    const _mix = createMix(ctx, dryGain, wetGain, module.mix, "linear");
+    input.connect(dryGain);
+    input.connect(comb);
+    comb.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return { input, output, comb, dryGain, wetGain, _freqVoct, _mix };
+  },
+  updateParam(nodes, _m, param, value) {
+    const t = nodes._freqVoct.parameters.get("transpose");
+    if (param === "offset") {
+      t.value = value;
+    } else if (param === "frequency") {
+      if (!patchCount.get(nodes)) t.value = hzToMidi(value);
+    } else if (param === "transpose") {
+      if (patchCount.get(nodes)) t.value = value;
+    } else if (param === "feedback") {
+      nodes.comb.parameters.get("feedback").value = value;
+    } else if (param === "mix") {
+      nodes._mix.offset.value = value;
+    }
+  },
+  // App-only: plain summing connect; the hooks only swap which panel memory
+  // drives the offset.
+  onConnect(nodes, module, portId, sourceNode) {
+    if (portId !== "voct") return false;
+    const v = nodes._freqVoct;
+    sourceNode.connect(v);
+    patchCount.set(nodes, (patchCount.get(nodes) ?? 0) + 1);
+    v.parameters.get("transpose").value = module.transpose ?? 0;
+    return true;
+  },
+  onDisconnect(nodes, module, portId, sourceNode) {
+    if (portId !== "voct") return false;
+    const v = nodes._freqVoct;
+    try {
+      sourceNode.disconnect(v);
+    } catch (e) {
+    }
+    const n = Math.max(0, (patchCount.get(nodes) ?? 0) - 1);
+    patchCount.set(nodes, n);
+    if (!n) v.parameters.get("transpose").value = hzToMidi(module.frequency);
+    return true;
+  }
+});
+
+// src/lib-runtime/generated/modules/comb-filter.wrapper.ts
+var CombFilter = /* @__PURE__ */ defineModule(combFilterDescriptor, {
+  worklets: {
+    "map-voct-to-period": map_voct_to_period_default,
+    "comb-filter": comb_filter_default
+  }
+});
+
+// src/lib-runtime/generated/modules/comp.tsx
+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" },
+  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 }
+};
+var compressorDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "compressor",
+  params: params6,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "comp" },
+    "out": { type: "output", signal: "audio", node: "makeup" }
+  },
+  createModule(id, position) {
+    return { id, type: "compressor", position, ...paramDefaults(params6) };
+  },
+  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 };
+  },
+  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;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/comp.wrapper.ts
+var Compressor = /* @__PURE__ */ defineModule(compressorDescriptor);
+
+// src/lib-runtime/generated/modules/crossfade.tsx
+var params7 = {
+  blend: { node: "_mix", field: "offset", unit: "factor", default: 0.5, min: 0, max: 1 },
+  curve: { kind: "enum", default: "equal-power", options: ["linear", "equal-power"] }
+};
+var CURVE_POINTS2 = 2049;
+function lawCurve2(fn) {
+  const c = new Float32Array(CURVE_POINTS2);
+  for (let i = 0; i < CURVE_POINTS2; i++) {
+    const x = -1 + 2 * i / (CURVE_POINTS2 - 1);
+    c[i] = fn(Math.min(1, Math.max(0, x)));
+  }
+  return c;
+}
+function curvesFor(curve) {
+  if (curve === "equal-power") {
+    return {
+      a: lawCurve2((m) => Math.cos(m * Math.PI / 2)),
+      b: lawCurve2((m) => Math.sin(m * Math.PI / 2))
+    };
+  }
+  return {
+    a: lawCurve2((m) => 1 - m),
+    b: lawCurve2((m) => m)
+  };
+}
+var crossfadeDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "crossfade",
+  params: params7,
+  ports: {
+    "a": { type: "input", signal: "audio", node: "inputA" },
+    "b": { type: "input", signal: "audio", node: "inputB" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "crossfade", position, ...paramDefaults(params7) };
+  },
+  createNodes(ctx, module) {
+    const inputA = ctx.createGain();
+    const inputB = ctx.createGain();
+    const output = ctx.createGain();
+    inputA.gain.value = 0;
+    inputB.gain.value = 0;
+    const _mix = ctx.createConstantSource();
+    _mix.offset.value = module.blend;
+    const { a, b } = curvesFor(module.curve);
+    const curveA = ctx.createWaveShaper();
+    curveA.curve = a;
+    const curveB = ctx.createWaveShaper();
+    curveB.curve = b;
+    _mix.connect(curveA).connect(inputA.gain);
+    _mix.connect(curveB).connect(inputB.gain);
+    _mix.start();
+    inputA.connect(output);
+    inputB.connect(output);
+    return { inputA, inputB, output, _mix, curveA, curveB };
+  },
+  updateParam(nodes, module, param, value) {
+    if (param === "blend") {
+      nodes._mix.offset.value = value;
+    } else if (param === "curve") {
+      const { a, b } = curvesFor(value);
+      nodes.curveA.curve = a;
+      nodes.curveB.curve = b;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/crossfade.wrapper.ts
+var Crossfade = /* @__PURE__ */ defineModule(crossfadeDescriptor);
+
+// src/lib-runtime/generated/modules/delay.tsx
+var params8 = {
+  time: { node: "delay", field: "period", default: 0.3, min: 0.01, max: 1, scale: "log", unit: "s" },
+  feedback: { node: "delay", field: "feedback", unit: "factor", default: 0.4, min: 0, max: 0.95 },
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 0.5, min: 0, max: 1 }
+};
+var delayDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "delay",
+  params: params8,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "delay", position, ...paramDefaults(params8) };
+  },
+  createNodes(ctx, module) {
+    const delay = createCombFilterNode(ctx, module.feedback, 5, 2);
+    delay.parameters.get("period").value = module.time;
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const _mix = createMix(ctx, dryGain, wetGain, module.mix, "linear");
+    input.connect(dryGain);
+    input.connect(delay);
+    delay.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return { input, output, delay, dryGain, wetGain, _mix };
+  },
+  updateParam(nodes, _m, param, value) {
+    switch (param) {
+      case "time":
+        nodes.delay.parameters.get("period").value = value;
+        break;
+      case "feedback":
+        nodes.delay.parameters.get("feedback").value = value;
+        break;
+      case "mix":
+        nodes._mix.offset.value = value;
+        break;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/delay.wrapper.ts
+var Delay = /* @__PURE__ */ defineModule(delayDescriptor, {
+  worklets: {
+    "comb-filter": comb_filter_default
+  }
+});
+
+// src/lib-runtime/generated/modules/dimension.tsx
+var params9 = {
+  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 }
+};
+var dimensionDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "dimension",
+  params: params9,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "modRate": { type: "modulation", signal: "modulation", node: "lfo", field: "frequency" }
+  },
+  createModule(id, position) {
+    return { id, type: "dimension", position, ...paramDefaults(params9) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    input.channelCount = 2;
+    input.channelCountMode = "explicit";
+    input.channelInterpretation = "speakers";
+    const output = ctx.createGain();
+    const splitter = ctx.createChannelSplitter(2);
+    const merger = ctx.createChannelMerger(2);
+    const leftDelay = ctx.createDelay(0.05);
+    const rightDelay = ctx.createDelay(0.05);
+    const lfo = ctx.createOscillator();
+    const lfoGainL = ctx.createGain();
+    const lfoGainR = 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";
+    lfo.frequency.value = module.rate;
+    lfoGainL.gain.value = module.depth * 2e-3;
+    lfoGainR.gain.value = -module.depth * 2e-3;
+    lfo.connect(lfoGainL);
+    lfo.connect(lfoGainR);
+    lfoGainL.connect(leftDelay.delayTime);
+    lfoGainR.connect(rightDelay.delayTime);
+    lfo.start();
+    input.connect(splitter);
+    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);
+    merger.connect(output);
+    return { input, output, splitter, merger, leftDelay, rightDelay, lfo, lfoGainL, lfoGainR, 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;
+    else if (param === "depth") {
+      nodes.lfoGainL.gain.value = value * 2e-3;
+      nodes.lfoGainR.gain.value = -value * 2e-3;
+    }
+  },
+  dispose(nodes) {
+    nodes.lfo.stop();
+  }
+});
+
+// src/lib-runtime/generated/modules/dimension.wrapper.ts
+var Dimension = /* @__PURE__ */ defineModule(dimensionDescriptor);
+
+// src/lib-runtime/generated/modules/distortion.tsx
+var params10 = {
+  distortionType: { kind: "enum", default: "soft", options: ["soft", "hard", "fuzz"] },
+  drive: { unit: "factor", default: 5, min: 1, max: 20, scale: "log" },
+  frequency: { node: "toneFilter", field: "frequency", unit: "Hz", default: 16e3, min: 500, max: 16e3, scale: "log" },
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 0.8, min: 0, max: 1 }
+};
+var FUZZ_BIAS = 0.7;
+function transfer(type, k, x) {
+  if (type === "soft") return Math.tanh(k * x);
+  if (type === "hard") return Math.max(-1, Math.min(1, k * x));
+  const f = (u) => Math.sign(u) * (1 - Math.exp(-Math.abs(u)));
+  return (f(k * x + FUZZ_BIAS) - f(FUZZ_BIAS)) / (1 + f(FUZZ_BIAS));
+}
+var CURVE_LEN = 16384;
+function makeDistortionCurve(type, drive) {
+  const k = Math.max(1, Math.min(20, drive));
+  const curve = new Float32Array(CURVE_LEN);
+  for (let i = 0; i < CURVE_LEN; i++) {
+    const x = i * 2 / (CURVE_LEN - 1) - 1;
+    curve[i] = transfer(type, k, x);
+  }
+  return curve;
+}
+function computeMakeup(type, drive) {
+  const k = Math.max(1, Math.min(20, drive));
+  const N = 512;
+  let sum = 0;
+  let sumSq = 0;
+  for (let i = 0; i < N; i++) {
+    const y = transfer(type, k, 0.5 * Math.sin(2 * Math.PI * i / N));
+    sum += y;
+    sumSq += y * y;
+  }
+  const mean = sum / N;
+  const acRms = Math.sqrt(Math.max(0, sumSq / N - mean * mean));
+  const rmsIn = 0.5 / Math.SQRT2;
+  if (acRms < 1e-6) return 1;
+  return Math.min(4, Math.max(0.25, rmsIn / acRms));
+}
+var distortionTypes = params10.distortionType.options;
+var distortionDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "distortion",
+  params: params10,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return {
+      id,
+      type: "distortion",
+      position,
+      ...paramDefaults(params10)
+    };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const waveshaper = ctx.createWaveShaper();
+    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;
+    dcBlock.Q.value = 0.707;
+    toneFilter.type = "lowpass";
+    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);
+    makeup.connect(dcBlock);
+    dcBlock.connect(toneFilter);
+    toneFilter.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return { input, output, waveshaper, makeup, dcBlock, toneFilter, dryGain, wetGain, _mix };
+  },
+  updateParam(nodes, module, param, value) {
+    if (param === "drive" || param === "distortionType") {
+      nodes.waveshaper.curve = makeDistortionCurve(module.distortionType, module.drive);
+      nodes.makeup.gain.value = computeMakeup(module.distortionType, module.drive);
+    }
+    if (param === "frequency") {
+      nodes.toneFilter.frequency.value = value;
+    }
+    if (param === "mix") {
+      nodes._mix.offset.value = value;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/distortion.wrapper.ts
+var Distortion = /* @__PURE__ */ defineModule(distortionDescriptor);
+
+// src/lib-runtime/generated/modules/ducker.tsx
+var params11 = {
+  // Feeds scInput.gain via 1/10^(threshold/20) — a conversion, not a 1:1
+  // AudioParam write — so no node/field.
+  threshold: { unit: "dB", default: -24, min: -60, max: 0 },
+  // Feeds invertGain.gain via negation (-amount) — no node/field.
+  amount: { unit: "factor", default: 0.7, min: 0, max: 1 },
+  attack: { node: "envFollower", field: "attack", unit: "s", default: 0.01, min: 1e-3, max: 0.1, scale: "log" },
+  release: { node: "envFollower", field: "release", unit: "s", default: 0.2, min: 1e-3, max: 1, scale: "log" }
+};
+var duckerDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "ducker",
+  params: params11,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "sc": { type: "input", signal: "audio", node: "scInput" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "ducker", position, ...paramDefaults(params11) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const scInput = ctx.createGain();
+    const output = ctx.createGain();
+    const duckGain = ctx.createGain();
+    scInput.gain.value = 1 / Math.max(1e-3, Math.pow(10, module.threshold / 20));
+    const scClamp = ctx.createWaveShaper();
+    scClamp.oversample = "none";
+    const SAT = 1.2;
+    const curve = new Float32Array(1024);
+    for (let i = 0; i < curve.length; i++) {
+      const x = i / (curve.length - 1) * 2 - 1;
+      curve[i] = SAT * Math.tanh(x / SAT);
+    }
+    scClamp.curve = curve;
+    const envFollower = createEnvFollowerNode(ctx);
+    envFollower.parameters.get("attack").value = module.attack;
+    envFollower.parameters.get("release").value = module.release;
+    const envDrive = ctx.createGain();
+    envDrive.gain.value = 1.2;
+    const envClamp = ctx.createWaveShaper();
+    envClamp.curve = new Float32Array([0, 0, 1]);
+    const invertGain = ctx.createGain();
+    invertGain.gain.value = -module.amount;
+    const constantSource = ctx.createConstantSource();
+    constantSource.offset.value = 1;
+    constantSource.start();
+    scInput.connect(scClamp);
+    scClamp.connect(envFollower);
+    envFollower.connect(envDrive);
+    envDrive.connect(envClamp);
+    envClamp.connect(invertGain);
+    invertGain.connect(duckGain.gain);
+    constantSource.connect(duckGain.gain);
+    duckGain.gain.value = 0;
+    input.connect(duckGain);
+    duckGain.connect(output);
+    return { input, scInput, scClamp, output, invertGain, envFollower, envDrive, envClamp, constantSource };
+  },
+  updateParam(nodes, _m, param, value) {
+    if (param === "threshold") {
+      nodes.scInput.gain.value = 1 / Math.max(1e-3, Math.pow(10, value / 20));
+    } else if (param === "amount") {
+      nodes.invertGain.gain.value = -value;
+    } else if (param === "attack") {
+      nodes.envFollower.parameters.get("attack").value = value;
+    } else if (param === "release") {
+      nodes.envFollower.parameters.get("release").value = value;
+    }
+  },
+  dispose(nodes) {
+    nodes.constantSource.stop();
+  }
+});
+
+// src/lib-runtime/generated/modules/ducker.wrapper.ts
+var Ducker = /* @__PURE__ */ defineModule(duckerDescriptor, {
+  worklets: {
+    "env-follower": env_follower_default
+  }
+});
+
+// src/lib-runtime/generated/modules/env-follow.tsx
+var params12 = {
+  attack: { node: "envFollower", field: "attack", unit: "s", default: 0.01, min: 1e-3, max: 0.5, scale: "log" },
+  release: { node: "envFollower", field: "release", unit: "s", default: 0.1, min: 1e-3, max: 2, scale: "log" },
+  // sensitivityGain.gain = sensitivity * 4 — a scaled conversion, not a 1:1
+  // AudioParam write — so no node/field.
+  sensitivity: { unit: "factor", default: 0.5, min: 0, max: 1 },
+  depth: { node: "depthGain", field: "gain", unit: "semitone", default: 48, min: 0, max: 96, scale: "sqrt" }
+};
+var envFollowDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "env-follow",
+  params: params12,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "env": { type: "output", node: "depthGain", signal: "modulation" }
+  },
+  createModule(id, position) {
+    return { id, type: "env-follow", position, ...paramDefaults(params12) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const depthGain = ctx.createGain();
+    const sensitivityGain = ctx.createGain();
+    sensitivityGain.gain.value = module.sensitivity * 4;
+    depthGain.gain.value = module.depth;
+    const envFollower = createEnvFollowerNode(ctx);
+    envFollower.parameters.get("attack").value = module.attack;
+    envFollower.parameters.get("release").value = module.release;
+    input.connect(sensitivityGain);
+    sensitivityGain.connect(envFollower);
+    envFollower.connect(depthGain);
+    return { input, depthGain, sensitivityGain, envFollower };
+  },
+  updateParam(nodes, _m, param, value) {
+    if (param === "sensitivity") {
+      nodes.sensitivityGain.gain.value = value * 4;
+    } else if (param === "depth") {
+      nodes.depthGain.gain.value = value;
+    } else if (param === "attack") {
+      nodes.envFollower.parameters.get("attack").value = value;
+    } else if (param === "release") {
+      nodes.envFollower.parameters.get("release").value = value;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/env-follow.wrapper.ts
+var EnvelopeFollower = /* @__PURE__ */ defineModule(envFollowDescriptor, {
+  worklets: {
+    "env-follower": env_follower_default
+  }
+});
+
+// src/lib-runtime/generated/modules/envelope.tsx
+var params13 = {
+  attack: { node: "adsrNode", field: "attack", default: 0.01, min: 1e-3, max: 2, scale: "log", unit: "s" },
+  decay: { node: "adsrNode", field: "decay", default: 0.1, min: 1e-3, max: 2, scale: "log", unit: "s" },
+  sustain: { node: "adsrNode", field: "sustain", unit: "factor", default: 0.7, min: 0, max: 1 },
+  release: { node: "adsrNode", field: "release", default: 0.3, min: 1e-3, max: 3, scale: "log", unit: "s" },
+  depth: { node: "envOut", field: "gain", default: 48, min: 0, max: 96, scale: "sqrt", unit: "semitone" }
+};
+var envelopeDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "envelope",
+  params: params13,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "mainGain" },
+    "out": { type: "output", signal: "audio", node: "mainGain" },
+    "env": { type: "output", signal: "modulation", node: "envOut" },
+    "trigger": { type: "input", signal: "gate", node: "adsrNode" }
+  },
+  createModule(id, position) {
+    return { id, type: "envelope", position, ...paramDefaults(params13) };
+  },
+  createNodes(ctx, module) {
+    const mainGain = ctx.createGain();
+    mainGain.gain.value = 0;
+    const adsrNode = createAdsrNode(ctx);
+    adsrNode.parameters.get("attack").value = module.attack;
+    adsrNode.parameters.get("decay").value = module.decay;
+    adsrNode.parameters.get("sustain").value = module.sustain;
+    adsrNode.parameters.get("release").value = module.release;
+    adsrNode.connect(mainGain.gain);
+    const depth = module.depth ?? 48;
+    const envOut = ctx.createGain();
+    envOut.gain.value = depth;
+    adsrNode.connect(envOut);
+    return { mainGain, adsrNode, envOut };
+  },
+  updateParam(nodes, _module, param, value) {
+    const v = value;
+    const p = nodes.adsrNode.parameters;
+    switch (param) {
+      case "attack":
+        p.get("attack").value = v;
+        break;
+      case "decay":
+        p.get("decay").value = v;
+        break;
+      case "sustain":
+        p.get("sustain").value = v;
+        break;
+      case "release":
+        p.get("release").value = v;
+        break;
+      case "depth":
+        nodes.envOut.gain.value = v;
+        break;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/envelope.wrapper.ts
+var Envelope = /* @__PURE__ */ defineModule(envelopeDescriptor, {
+  worklets: {
+    "adsr-envelope": adsr_envelope_default
+  }
+});
+
+// src/lib-runtime/generated/modules/eq3.tsx
+var params14 = {
+  low: { node: "lowShelf", field: "gain", unit: "dB", default: 0, min: -12, max: 12 },
+  mid: { node: "midPeak", field: "gain", unit: "dB", default: 0, min: -12, max: 12 },
+  high: { node: "highShelf", field: "gain", unit: "dB", default: 0, min: -12, max: 12 },
+  midFreq: { node: "midPeak", field: "frequency", unit: "Hz", default: 1e3, min: 200, max: 5e3, scale: "log" }
+};
+var eq3Descriptor = /* @__PURE__ */ defineDescriptor({
+  type: "eq3",
+  params: params14,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "eq3", position, ...paramDefaults(params14) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const lowShelf = ctx.createBiquadFilter();
+    const midPeak = ctx.createBiquadFilter();
+    const highShelf = ctx.createBiquadFilter();
+    lowShelf.type = "lowshelf";
+    lowShelf.frequency.value = 320;
+    lowShelf.gain.value = module.low;
+    midPeak.type = "peaking";
+    midPeak.frequency.value = module.midFreq;
+    midPeak.Q.value = 1.5;
+    midPeak.gain.value = module.mid;
+    highShelf.type = "highshelf";
+    highShelf.frequency.value = 3200;
+    highShelf.gain.value = module.high;
+    input.connect(lowShelf);
+    lowShelf.connect(midPeak);
+    midPeak.connect(highShelf);
+    highShelf.connect(output);
+    return { input, output, lowShelf, midPeak, highShelf };
+  },
+  updateParam(nodes, _m, param, value) {
+    switch (param) {
+      case "low":
+        nodes.lowShelf.gain.value = value;
+        break;
+      case "mid":
+        nodes.midPeak.gain.value = value;
+        break;
+      case "high":
+        nodes.highShelf.gain.value = value;
+        break;
+      case "midFreq":
+        nodes.midPeak.frequency.value = value;
+        break;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/eq3.wrapper.ts
+var ThreeBandEq = /* @__PURE__ */ defineModule(eq3Descriptor);
+
+// src/lib-runtime/generated/modules/exciter.tsx
+var params15 = {
+  // drive rebuilds the saturation curve AND scales highshelf.gain — not a
+  // 1:1 AudioParam write, so no node/field.
+  drive: { unit: "factor", default: 0.5, min: 0, max: 1 },
+  // frequency writes BOTH highpass.frequency and highshelf.frequency — two
+  // AudioParams, so no single node/field mapping.
+  frequency: { unit: "Hz", default: 4e3, min: 2e3, max: 8e3, scale: "log" },
+  // Additive blend, not a dry/wet crossfade: dry stays at unity while wetGain
+  // scales the excited signal — a genuine 1:1 AudioParam write.
+  mix: { node: "wetGain", field: "gain", unit: "factor", default: 0.5, min: 0, max: 1 }
+};
+function makeExciterCurve(amount) {
+  const samples = 44100;
+  const curve = new Float32Array(samples);
+  const k = 1 + amount * 8;
+  const norm = 0.5 / (Math.tanh(k * 0.5) * 1.15);
+  for (let i = 0; i < samples; i++) {
+    const x = i * 2 / samples - 1;
+    curve[i] = Math.tanh(k * x) * (1 + Math.abs(x) * 0.3) * norm;
+  }
+  return curve;
+}
+var exciterDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "exciter",
+  params: params15,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "exciter", position, ...paramDefaults(params15) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const highpass = ctx.createBiquadFilter();
+    const saturation = ctx.createWaveShaper();
+    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(highpass);
+    highpass.connect(saturation);
+    saturation.connect(highshelf);
+    highshelf.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return { input, output, highpass, saturation, highshelf, wetGain };
+  },
+  updateParam(nodes, _m, param, value) {
+    if (param === "drive") {
+      nodes.saturation.curve = makeExciterCurve(value);
+      nodes.highshelf.gain.value = 6 + value * 6;
+    } else if (param === "frequency") {
+      nodes.highpass.frequency.value = value;
+      nodes.highshelf.frequency.value = value;
+    } else if (param === "mix") {
+      nodes.wetGain.gain.value = value;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/exciter.wrapper.ts
+var Exciter = /* @__PURE__ */ defineModule(exciterDescriptor);
+
+// src/lib-runtime/generated/modules/flanger.tsx
+var params16 = {
+  rate: { node: "flanger", field: "rate", unit: "Hz", default: 0.5, min: 0.1, max: 5 },
+  depth: { node: "flanger", field: "depth", unit: "factor", default: 0.7, min: 0, max: 1 },
+  feedback: { node: "flanger", field: "feedback", unit: "factor", default: 0.7, min: 0, max: 0.95 },
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 0.5, min: 0, max: 1 }
+};
+var flangerDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "flanger",
+  params: params16,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "modRate": { type: "modulation", signal: "modulation", node: "flanger", field: "rate" },
+    "modDepth": { type: "modulation", signal: "modulation", node: "flanger", field: "depth" },
+    "modFeedback": { type: "modulation", signal: "modulation", node: "flanger", field: "feedback" },
+    "modMix": { type: "modulation", signal: "modulation", node: "_mix", field: "offset" }
+  },
+  createModule(id, position) {
+    return { id, type: "flanger", position, ...paramDefaults(params16) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const flanger = createFlangerNode(ctx, {
+      rate: module.rate,
+      depth: module.depth,
+      feedback: module.feedback
+    });
+    const _mix = createMix(ctx, dryGain, wetGain, module.mix, "linear");
+    input.connect(dryGain);
+    input.connect(flanger);
+    flanger.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return { input, output, flanger, dryGain, wetGain, _mix };
+  },
+  updateParam(nodes, _m, param, value) {
+    switch (param) {
+      case "rate":
+      case "depth":
+      case "feedback":
+        nodes.flanger.parameters.get(param).value = value;
+        break;
+      case "mix":
+        nodes._mix.offset.value = value;
+        break;
+    }
+  },
+  dispose(nodes) {
+    nodes._mix.stop();
+  }
+});
+
+// src/lib-runtime/generated/modules/flanger.wrapper.ts
+var Flanger = /* @__PURE__ */ defineModule(flangerDescriptor, {
+  worklets: {
+    "flanger": flanger_default
+  }
+});
+
+// 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" },
+  mix: { unit: "factor", default: 1, min: 0, max: 1 }
+};
+var formantDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "formant",
+  params: params17,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "modVowel": { type: "modulation", signal: "modulation", node: "vowelCV" }
+  },
+  createModule(id, position) {
+    return { id, type: "formant", position, ...paramDefaults(params17) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    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 formantWorklet = createFormantNode(ctx);
+    formantWorklet.parameters.get("baseMorph").value = module.morph;
+    const vowelCV = ctx.createGain();
+    vowelCV.gain.value = 1;
+    vowelCV.connect(formantWorklet);
+    const splitter = ctx.createChannelSplitter(5);
+    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;
+    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);
+    return { input, output, vowelCV, f1, f2, f3, f4, f5, f4Gain, f5Gain, dryGain, wetGain, formantWorklet };
+  },
+  updateParam(nodes, _module, param, value) {
+    if (param === "morph") {
+      nodes.formantWorklet.parameters.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;
+    } else if (param === "mix") {
+      nodes.dryGain.gain.value = 1 - value;
+      nodes.wetGain.gain.value = value;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/formant.wrapper.ts
+var Formant = /* @__PURE__ */ defineModule(formantDescriptor, {
+  worklets: {
+    "formant-table": formant_table_default
+  }
+});
+
+// src/lib-runtime/generated/modules/freq-shifter.tsx
+var params18 = {
+  shift: { node: "shifter", field: "shift", unit: "Hz", default: 0, min: -500, max: 500 },
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 1, min: 0, max: 1 }
+};
+var freqShifterDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "freq-shifter",
+  params: params18,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "modShift": { type: "modulation", signal: "modulation", node: "shifter", field: "shift" }
+  },
+  createModule(id, position) {
+    return { id, type: "freq-shifter", position, ...paramDefaults(params18) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const shifter = createFreqShifterNode(ctx, module.shift);
+    const _mix = createMix(ctx, dryGain, wetGain, module.mix, "linear");
+    input.connect(dryGain);
+    input.connect(shifter);
+    shifter.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return { input, output, shifter, dryGain, wetGain, _mix };
+  },
+  updateParam(nodes, _m, param, value) {
+    if (param === "shift") {
+      const p = nodes.shifter.parameters.get("shift");
+      p.setTargetAtTime(value, nodes.shifter.context.currentTime, 0.01);
+    } else if (param === "mix") {
+      nodes._mix.offset.value = value;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/freq-shifter.wrapper.ts
+var FrequencyShifter = /* @__PURE__ */ defineModule(freqShifterDescriptor, {
+  worklets: {
+    "freq-shifter": freq_shifter_default
+  }
+});
+
+// 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" }
+};
+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" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "gate", position, ...paramDefaults(params19) };
+  },
+  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 };
+  },
+  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;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/gate.wrapper.ts
+var Gate = /* @__PURE__ */ defineModule(gateDescriptor, {
+  worklets: {
+    "env-follower": env_follower_default
+  }
+});
+
+// src/lib-runtime/generated/modules/glide.tsx
+var params20 = {
+  time: { node: "_glide", field: "time", unit: "s", default: 0.1, min: 0.01, max: 10, scale: "log" }
+};
+var glideDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "glide",
+  params: params20,
+  ports: {
+    "in": { type: "input", signal: "pitch", node: "_glide" },
+    "gate": { type: "input", signal: "gate", node: "_gateIn" },
+    "out": { type: "output", signal: "pitch", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "glide", position, ...paramDefaults(params20) };
+  },
+  createNodes(ctx, module) {
+    const _glide = createGlideNode(ctx);
+    _glide.parameters.get("time").value = module.time;
+    const output = ctx.createGain();
+    output.gain.value = 1;
+    _glide.connect(output);
+    const _gateIn = ctx.createGain();
+    _gateIn.gain.value = 1;
+    _gateIn.connect(_glide, 0, 1);
+    return { _glide, _gateIn, output };
+  },
+  updateParam(nodes, _m, param, value) {
+    if (param === "time") {
+      nodes._glide.parameters.get("time").value = value;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/glide.wrapper.ts
+var Glide = /* @__PURE__ */ defineModule(glideDescriptor, {
+  worklets: {
+    "glide": glide_default
+  }
+});
+
+// src/lib-runtime/generated/modules/haas.tsx
+var params21 = {
+  delay: { unit: "ms", default: 15, min: 1, max: 35 },
+  side: { kind: "enum", default: "right", options: ["left", "right"] },
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 1, min: 0, max: 1 }
+};
+var haasDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "haas",
+  params: params21,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "haas", position, ...paramDefaults(params21) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const delayNode = ctx.createDelay(0.05);
+    const directGain = ctx.createGain();
+    const delayedGain = ctx.createGain();
+    const directBleed = ctx.createGain();
+    const merger = ctx.createChannelMerger(2);
+    const _mix = createMix(ctx, directBleed, delayedGain, module.mix, "linear");
+    delayNode.delayTime.value = module.delay / 1e3;
+    directGain.gain.value = 1;
+    input.connect(directGain);
+    input.connect(directBleed);
+    input.connect(delayNode);
+    delayNode.connect(delayedGain);
+    if (module.side === "right") {
+      directGain.connect(merger, 0, 0);
+      delayedGain.connect(merger, 0, 1);
+      directBleed.connect(merger, 0, 1);
+    } else {
+      delayedGain.connect(merger, 0, 0);
+      directBleed.connect(merger, 0, 0);
+      directGain.connect(merger, 0, 1);
+    }
+    merger.connect(output);
+    return { input, output, delayNode, directGain, delayedGain, directBleed, merger, _mix };
+  },
+  updateParam(nodes, _m, param, value) {
+    if (param === "delay") {
+      nodes.delayNode.delayTime.value = value / 1e3;
+    } else if (param === "mix") {
+      nodes._mix.offset.value = value;
+    } else if (param === "side") {
+      try {
+        nodes.directGain.disconnect(nodes.merger);
+      } catch (_) {
+      }
+      try {
+        nodes.delayedGain.disconnect(nodes.merger);
+      } catch (_) {
+      }
+      try {
+        nodes.directBleed.disconnect(nodes.merger);
+      } catch (_) {
+      }
+      if (value === "right") {
+        nodes.directGain.connect(nodes.merger, 0, 0);
+        nodes.delayedGain.connect(nodes.merger, 0, 1);
+        nodes.directBleed.connect(nodes.merger, 0, 1);
+      } else {
+        nodes.delayedGain.connect(nodes.merger, 0, 0);
+        nodes.directBleed.connect(nodes.merger, 0, 0);
+        nodes.directGain.connect(nodes.merger, 0, 1);
+      }
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/haas.wrapper.ts
+var HaasWidener = /* @__PURE__ */ defineModule(haasDescriptor);
+
+// src/lib-runtime/generated/modules/harmonic-trem.tsx
+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 }
+};
+var harmonicTremDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "harmonic-trem",
+  params: params22,
+  ports: {
+    "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" }
+  },
+  createModule(id, position) {
+    return { id, type: "harmonic-trem", position, ...paramDefaults(params22) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const lowpass = ctx.createBiquadFilter();
+    const lpInvert = ctx.createGain();
+    const highBand = ctx.createGain();
+    const lowGain = ctx.createGain();
+    const highGain = ctx.createGain();
+    const lfo = ctx.createOscillator();
+    const lfoGainLow = ctx.createGain();
+    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;
+    lfo.type = "sine";
+    lfo.frequency.value = module.rate;
+    lfoGainLow.gain.value = module.depth * 0.5;
+    lfoGainHigh.gain.value = module.depth * 0.5;
+    lfoInvert.gain.value = -1;
+    lowGain.gain.value = 1;
+    highGain.gain.value = 1;
+    input.connect(lowpass);
+    input.connect(highBand);
+    lowpass.connect(lpInvert);
+    lpInvert.connect(highBand);
+    lfo.connect(lfoGainLow);
+    lfo.connect(lfoInvert);
+    lfoInvert.connect(lfoGainHigh);
+    lfoGainLow.connect(lowGain.gain);
+    lfoGainHigh.connect(highGain.gain);
+    lowpass.connect(lowGain);
+    highBand.connect(highGain);
+    lowGain.connect(output);
+    highGain.connect(output);
+    lfo.start();
+    return { input, output, lfo, lfoGainLow, lfoGainHigh, lowpass, lpInvert, highBand };
+  },
+  updateParam(nodes, _m, param, value) {
+    if (param === "rate") nodes.lfo.frequency.value = value;
+    else if (param === "depth") {
+      nodes.lfoGainLow.gain.value = value * 0.5;
+      nodes.lfoGainHigh.gain.value = value * 0.5;
+    } else if (param === "crossover") {
+      nodes.lowpass.frequency.value = value;
+    }
+  },
+  dispose(nodes) {
+    nodes.lfo.stop();
+  }
+});
+
+// src/lib-runtime/generated/modules/harmonic-trem.wrapper.ts
+var HarmonicTremolo = /* @__PURE__ */ defineModule(harmonicTremDescriptor);
+
+// src/lib-runtime/generated/modules/ladder-filter.tsx
+var RES_TOP = 1.1;
+var params23 = {
+  note: { node: "_cutoffVoct", field: "transpose", unit: "note", default: 83, min: 15, max: 135 },
+  // Stored 0–4 (UI shows % of travel) but the worklet's resonance param is
+  // resonance/4·RES_TOP — a scale, not a 1:1 mapping — so this stays set-only.
+  resonance: { unit: "factor", default: 2.5, min: 0, max: 4, scale: "sqrt" },
+  drive: { node: "ladder", field: "drive", unit: "factor", default: 0.3, min: 0, max: 1 }
+};
+var ladderFilterDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "ladder-filter",
+  params: params23,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "modFreq": { type: "modulation", signal: "modulation", node: "_cutoffVoct" },
+    "modRes": { type: "modulation", signal: "modulation", node: "ladder", field: "resonance" }
+  },
+  createModule(id, position) {
+    return { id, type: "ladder-filter", position, ...paramDefaults(params23) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const ladder = createLadderFilterNode(ctx, {
+      resonance: module.resonance / 4 * RES_TOP,
+      drive: module.drive
+    });
+    const _cutoffVoct = createVoctFreqNode(ctx);
+    _cutoffVoct.parameters.get("transpose").value = module.note;
+    const _cutoffBase = ctx.createConstantSource();
+    _cutoffBase.offset.value = 0;
+    _cutoffBase.start();
+    _cutoffBase.connect(_cutoffVoct);
+    _cutoffVoct.connect(ladder.parameters.get("cutoff"));
+    input.connect(ladder);
+    ladder.connect(output);
+    return { input, output, ladder, _cutoffVoct, _cutoffBase };
+  },
+  updateParam(nodes, _module, param, value) {
+    switch (param) {
+      case "note":
+        nodes._cutoffVoct.parameters.get("transpose").value = value;
+        break;
+      case "resonance":
+        nodes.ladder.parameters.get("resonance").value = value / 4 * RES_TOP;
+        break;
+      case "drive":
+        nodes.ladder.parameters.get("drive").value = value;
+        break;
+    }
+  },
+  dispose(nodes) {
+    try {
+      nodes._cutoffBase.stop();
+    } catch (_) {
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/ladder-filter.wrapper.ts
+var LadderFilter = /* @__PURE__ */ defineModule(ladderFilterDescriptor, {
+  worklets: {
+    "ladder-filter": ladder_filter_default,
+    "map-voct-to-freq": map_voct_to_freq_default
+  }
+});
+
+// src/lib-runtime/generated/modules/lfo.tsx
+var params24 = {
+  skew: { node: "_ws", field: "skew", unit: "factor", default: 0, min: -1, max: 1 },
+  shape: { node: "_ws", field: "shape", unit: "factor", default: 1, min: -1, max: 1 },
+  frequency: { node: "_freqSrc", field: "offset", default: 2, min: -10, max: 20, unit: "Hz" },
+  amount: { node: "gain", field: "gain", unit: "semitone", default: 12, min: 0, max: 500, scale: "sqrt" }
+};
+var lfoDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "lfo",
+  params: params24,
+  ports: {
+    "out": { type: "output", node: "gain", signal: "modulation" },
+    "modRate": { type: "modulation", signal: "modulation", node: "_freqSrc", field: "offset" },
+    "modAmount": { type: "modulation", signal: "modulation", node: "gain", field: "gain" },
+    "modSkew": { type: "modulation", signal: "modulation", node: "_ws", field: "skew" },
+    "modShape": { type: "modulation", signal: "modulation", node: "_ws", field: "shape" }
+  },
+  createModule(id, position) {
+    return { id, type: "lfo", position, ...paramDefaults(params24) };
+  },
+  createNodes(ctx, module) {
+    const _ws = createWaveshaperNode(ctx);
+    const gain = ctx.createGain();
+    const _freqSrc = ctx.createConstantSource();
+    _freqSrc.offset.value = module.frequency;
+    _freqSrc.start();
+    _freqSrc.connect(_ws);
+    _ws.parameters.get("skew").value = module.skew;
+    _ws.parameters.get("shape").value = module.shape;
+    gain.gain.value = module.amount;
+    _ws.connect(gain);
+    return { gain, _ws, _freqSrc };
+  },
+  updateParam(nodes, _module, param, value) {
+    switch (param) {
+      case "skew":
+        nodes._ws.parameters.get("skew").value = value;
+        break;
+      case "shape":
+        nodes._ws.parameters.get("shape").value = value;
+        break;
+      case "frequency":
+        nodes._freqSrc.offset.value = value;
+        break;
+      case "amount":
+        nodes.gain.gain.value = value;
+        break;
+    }
+  },
+  dispose(nodes) {
+    nodes._freqSrc.stop();
+  }
+});
+
+// src/lib-runtime/generated/modules/lfo.wrapper.ts
+var Lfo = /* @__PURE__ */ defineModule(lfoDescriptor, {
+  worklets: {
+    "waveshaper": waveshaper_default
+  }
+});
+
+// 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);
+  }
+  return curve;
+}
+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 }
+};
+var loFiDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "lo-fi",
+  params: params25,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "modCutoff": { type: "modulation", signal: "modulation", node: "lowpass", field: "frequency" }
+  },
+  createModule(id, position) {
+    return { id, type: "lo-fi", position, ...paramDefaults(params25) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const saturation = ctx.createWaveShaper();
+    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;
+    wobbleLfo.type = "sine";
+    wobbleLfo.frequency.value = 0.73;
+    wobbleGain.gain.value = module.wobble * 2e-3;
+    wobbleLfo.connect(wobbleGain);
+    wobbleGain.connect(wobbleDelay.delayTime);
+    wobbleLfo.start();
+    input.connect(saturation);
+    saturation.connect(lowpass);
+    lowpass.connect(wobbleDelay);
+    wobbleDelay.connect(output);
+    noiseGain.connect(output);
+    return { input, output, saturation, lowpass, wobbleDelay, noiseGain, wobbleGain, wobbleLfo, noiseSrc };
+  },
+  updateParam(nodes, _m, param, value) {
+    if (param === "drive") {
+      nodes.saturation.curve = makeLoFiSaturationCurve(value);
+    } else if (param === "cutoff") {
+      nodes.lowpass.frequency.value = value;
+    } else if (param === "noise") {
+      nodes.noiseGain.gain.value = value * 0.05;
+    } else if (param === "wobble") {
+      nodes.wobbleGain.gain.value = value * 2e-3;
+    }
+  },
+  dispose(nodes) {
+    nodes.wobbleLfo.stop();
+    nodes.noiseSrc.stop();
+  }
+});
+
+// src/lib-runtime/generated/modules/lo-fi.wrapper.ts
+var LoFi = /* @__PURE__ */ defineModule(loFiDescriptor);
+
+// 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 }
+};
+var midSideDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "mid-side",
+  params: params26,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "mid-side", position, ...paramDefaults(params26) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    input.channelCount = 2;
+    input.channelCountMode = "explicit";
+    input.channelInterpretation = "speakers";
+    const output = ctx.createGain();
+    const splitter = ctx.createChannelSplitter(2);
+    const merger = ctx.createChannelMerger(2);
+    const midSum = ctx.createGain();
+    midSum.gain.value = 0.5;
+    const sideSum = ctx.createGain();
+    sideSum.gain.value = 0.5;
+    const rInvEnc = ctx.createGain();
+    rInvEnc.gain.value = -1;
+    input.connect(splitter);
+    splitter.connect(midSum, 0);
+    splitter.connect(midSum, 1);
+    splitter.connect(sideSum, 0);
+    splitter.connect(rInvEnc, 1);
+    rInvEnc.connect(sideSum);
+    const midGainNode = ctx.createGain();
+    midGainNode.gain.value = module.midGain;
+    const sideGainNode = ctx.createGain();
+    sideGainNode.gain.value = module.sideGain;
+    const widthNode = ctx.createGain();
+    widthNode.gain.value = module.width;
+    midSum.connect(midGainNode);
+    sideSum.connect(sideGainNode);
+    sideGainNode.connect(widthNode);
+    const leftOut = ctx.createGain();
+    const rightOut = ctx.createGain();
+    const sideInvDec = ctx.createGain();
+    sideInvDec.gain.value = -1;
+    midGainNode.connect(leftOut);
+    midGainNode.connect(rightOut);
+    widthNode.connect(leftOut);
+    widthNode.connect(sideInvDec);
+    sideInvDec.connect(rightOut);
+    leftOut.connect(merger, 0, 0);
+    rightOut.connect(merger, 0, 1);
+    merger.connect(output);
+    return { input, output, midGainNode, sideGainNode, widthNode };
+  },
+  updateParam(nodes, _module, param, value) {
+    if (param === "midGain") nodes.midGainNode.gain.value = value;
+    else if (param === "sideGain") nodes.sideGainNode.gain.value = value;
+    else if (param === "width") nodes.widthNode.gain.value = value;
+  }
+});
+
+// src/lib-runtime/generated/modules/mid-side.wrapper.ts
+var MidSide = /* @__PURE__ */ defineModule(midSideDescriptor);
+
+// src/lib-runtime/generated/modules/noise.tsx
+var params27 = {
+  noiseType: { kind: "enum", default: "white", options: ["white", "pink", "brown"] },
+  gain: { node: "output", field: "gain", unit: "factor", default: 0.3, min: 0, max: 1 }
+};
+function generateNoiseBuffer(ctx, type) {
+  const bufferSize = 2 * ctx.sampleRate;
+  const buffer = ctx.createBuffer(1, bufferSize, ctx.sampleRate);
+  const data = buffer.getChannelData(0);
+  if (type === "white") {
+    const rand = noiseSource(NOISE_SEEDS.noiseWhite);
+    for (let i = 0; i < bufferSize; i++) data[i] = rand();
+  } else if (type === "pink") {
+    const rand = noiseSource(NOISE_SEEDS.noisePink);
+    let b0 = 0, b1 = 0, b2 = 0, b3 = 0, b4 = 0, b5 = 0, b6 = 0;
+    for (let i = 0; i < bufferSize; i++) {
+      const w = rand();
+      b0 = 0.99886 * b0 + w * 0.0555179;
+      b1 = 0.99332 * b1 + w * 0.0750759;
+      b2 = 0.969 * b2 + w * 0.153852;
+      b3 = 0.8665 * b3 + w * 0.3104856;
+      b4 = 0.55 * b4 + w * 0.5329522;
+      b5 = -0.7616 * b5 - w * 0.016898;
+      data[i] = (b0 + b1 + b2 + b3 + b4 + b5 + b6 + w * 0.5362) * 0.11;
+      b6 = w * 0.115926;
+    }
+  } else {
+    const rand = noiseSource(NOISE_SEEDS.noiseBrown);
+    let lastOut = 0;
+    for (let i = 0; i < bufferSize; i++) {
+      const w = rand();
+      data[i] = (lastOut + 0.02 * w) / 1.02;
+      lastOut = data[i];
+      data[i] *= 3.5;
+    }
+  }
+  return buffer;
+}
+var noiseDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "noise",
+  params: params27,
+  ports: {
+    "out": { type: "output", signal: "audio", node: "output" },
+    "modLevel": { type: "modulation", signal: "modulation", node: "output", field: "gain" }
+  },
+  createModule(id, position) {
+    return { id, type: "noise", position, ...paramDefaults(params27) };
+  },
+  createNodes(ctx, module) {
+    const whiteSrc = ctx.createBufferSource();
+    whiteSrc.buffer = generateNoiseBuffer(ctx, "white");
+    whiteSrc.loop = true;
+    const pinkSrc = ctx.createBufferSource();
+    pinkSrc.buffer = generateNoiseBuffer(ctx, "pink");
+    pinkSrc.loop = true;
+    const brownSrc = ctx.createBufferSource();
+    brownSrc.buffer = generateNoiseBuffer(ctx, "brown");
+    brownSrc.loop = true;
+    const whiteGain = ctx.createGain();
+    const pinkGain = ctx.createGain();
+    const brownGain = ctx.createGain();
+    whiteGain.gain.value = module.noiseType === "white" ? 1 : 0;
+    pinkGain.gain.value = module.noiseType === "pink" ? 1 : 0;
+    brownGain.gain.value = module.noiseType === "brown" ? 1 : 0;
+    const output = ctx.createGain();
+    output.gain.value = module.gain;
+    whiteSrc.connect(whiteGain);
+    pinkSrc.connect(pinkGain);
+    brownSrc.connect(brownGain);
+    whiteGain.connect(output);
+    pinkGain.connect(output);
+    brownGain.connect(output);
+    whiteSrc.start(0);
+    pinkSrc.start(0);
+    brownSrc.start(0);
+    return { output, whiteGain, pinkGain, brownGain, _whiteSrc: whiteSrc, _pinkSrc: pinkSrc, _brownSrc: brownSrc };
+  },
+  updateParam(nodes, _module, param, value) {
+    const t = nodes.output.context.currentTime;
+    switch (param) {
+      case "noiseType":
+        nodes.whiteGain.gain.setTargetAtTime(value === "white" ? 1 : 0, t, 5e-3);
+        nodes.pinkGain.gain.setTargetAtTime(value === "pink" ? 1 : 0, t, 5e-3);
+        nodes.brownGain.gain.setTargetAtTime(value === "brown" ? 1 : 0, t, 5e-3);
+        break;
+      case "gain":
+        nodes.output.gain.setTargetAtTime(value, t, 5e-3);
+        break;
+    }
+  },
+  dispose(nodes) {
+    try {
+      nodes._whiteSrc.stop();
+    } catch (_) {
+    }
+    try {
+      nodes._pinkSrc.stop();
+    } catch (_) {
+    }
+    try {
+      nodes._brownSrc.stop();
+    } catch (_) {
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/noise.wrapper.ts
+var Noise = /* @__PURE__ */ defineModule(noiseDescriptor);
+
+// src/lib-runtime/generated/modules/octaver.tsx
+var params28 = {
+  octDown2: { node: "oct2Gain", field: "gain", unit: "factor", default: 0.3, min: 0, max: 1 },
+  octDown1: { node: "oct1Gain", field: "gain", unit: "factor", default: 0.5, min: 0, max: 1 },
+  dry: { node: "dryGain", field: "gain", unit: "factor", default: 0.7, min: 0, max: 1 },
+  octUp: { node: "octUpGain", field: "gain", unit: "factor", default: 0, min: 0, max: 1 }
+};
+function makeFullWaveRectifierCurve() {
+  const samples = 8192;
+  const curve = new Float32Array(samples);
+  for (let i = 0; i < samples; i++) {
+    const x = i * 2 / samples - 1;
+    curve[i] = Math.abs(x) * 2 - 1;
+  }
+  return curve;
+}
+var octaverDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "octaver",
+  params: params28,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "octaver", position, ...paramDefaults(params28) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const oct1Gain = ctx.createGain();
+    const oct2Gain = ctx.createGain();
+    const octUpGain = ctx.createGain();
+    const divider = createOctaverDividerNode(ctx);
+    divider.parameters.get("oct1Level").value = 1;
+    divider.parameters.get("oct2Level").value = 1;
+    const splitter = ctx.createChannelSplitter(2);
+    const lowpass1 = ctx.createBiquadFilter();
+    lowpass1.type = "lowpass";
+    lowpass1.frequency.value = 1200;
+    lowpass1.Q.value = 0.7;
+    const lowpass2 = ctx.createBiquadFilter();
+    lowpass2.type = "lowpass";
+    lowpass2.frequency.value = 600;
+    lowpass2.Q.value = 0.7;
+    const waveshaperUp = ctx.createWaveShaper();
+    waveshaperUp.curve = makeFullWaveRectifierCurve();
+    const bpUp = ctx.createBiquadFilter();
+    bpUp.type = "bandpass";
+    bpUp.frequency.value = 20;
+    bpUp.Q.value = 2.5;
+    const freqTrack = ctx.createGain();
+    freqTrack.gain.value = 2;
+    dryGain.gain.value = module.dry;
+    oct1Gain.gain.value = module.octDown1;
+    oct2Gain.gain.value = module.octDown2;
+    octUpGain.gain.value = module.octUp;
+    input.connect(dryGain);
+    input.connect(divider);
+    divider.connect(splitter, 1, 0);
+    splitter.connect(lowpass1, 0);
+    splitter.connect(lowpass2, 1);
+    lowpass1.connect(oct1Gain);
+    lowpass2.connect(oct2Gain);
+    divider.connect(freqTrack, 2, 0);
+    freqTrack.connect(bpUp.frequency);
+    input.connect(waveshaperUp);
+    waveshaperUp.connect(bpUp);
+    bpUp.connect(octUpGain);
+    dryGain.connect(output);
+    oct1Gain.connect(output);
+    oct2Gain.connect(output);
+    octUpGain.connect(output);
+    return { input, output, dryGain, oct1Gain, oct2Gain, octUpGain, divider, bpUp, freqTrack };
+  },
+  updateParam(nodes, _m, param, value) {
+    if (param === "dry") nodes.dryGain.gain.value = value;
+    else if (param === "octDown1") nodes.oct1Gain.gain.value = value;
+    else if (param === "octDown2") nodes.oct2Gain.gain.value = value;
+    else if (param === "octUp") nodes.octUpGain.gain.value = value;
+  }
+});
+
+// src/lib-runtime/generated/modules/octaver.wrapper.ts
+var Octaver = /* @__PURE__ */ defineModule(octaverDescriptor, {
+  worklets: {
+    "freq-divider": freq_divider_default
+  }
+});
+
+// src/lib-runtime/generated/modules/phaser.tsx
+var params29 = {
+  rate: { node: "lfo", field: "frequency", unit: "Hz", default: 0.5, min: 0.1, max: 10 },
+  depth: { unit: "factor", default: 0.7, min: 0, max: 1 },
+  feedback: { node: "feedback", field: "gain", unit: "factor", default: 0.6, min: 0, max: 0.9 },
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 0.5, min: 0, max: 1 }
+};
+var phaserDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "phaser",
+  params: params29,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "modRate": { type: "modulation", signal: "modulation", node: "lfo", field: "frequency" },
+    "modFeedback": { type: "modulation", signal: "modulation", node: "feedback", field: "gain" },
+    "modMix": { type: "modulation", signal: "modulation", node: "_mix", field: "offset" }
+  },
+  createModule(id, position) {
+    return { id, type: "phaser", position, ...paramDefaults(params29) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const lfo = ctx.createOscillator();
+    const feedback = ctx.createGain();
+    const stageBases = [200, 400, 600, 800];
+    const allpasses = stageBases.map((base) => {
+      const ap = ctx.createBiquadFilter();
+      ap.type = "allpass";
+      ap.frequency.value = base;
+      ap.Q.value = 0.5;
+      return ap;
+    });
+    const stageGains = stageBases.map((base) => {
+      const g = ctx.createGain();
+      g.gain.value = module.depth * base * 0.8;
+      return g;
+    });
+    const _mix = createMix(ctx, dryGain, wetGain, module.mix, "linear");
+    feedback.gain.value = module.feedback;
+    lfo.type = "sine";
+    lfo.frequency.value = module.rate;
+    allpasses.forEach((ap, i) => {
+      lfo.connect(stageGains[i]);
+      stageGains[i].connect(ap.frequency);
+    });
+    lfo.start();
+    input.connect(dryGain);
+    input.connect(allpasses[0]);
+    allpasses[0].connect(allpasses[1]);
+    allpasses[1].connect(allpasses[2]);
+    allpasses[2].connect(allpasses[3]);
+    allpasses[3].connect(feedback);
+    feedback.connect(allpasses[0]);
+    allpasses[3].connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return {
+      input,
+      output,
+      lfo,
+      feedback,
+      dryGain,
+      wetGain,
+      _mix,
+      stageGain0: stageGains[0],
+      stageGain1: stageGains[1],
+      stageGain2: stageGains[2],
+      stageGain3: stageGains[3]
+    };
+  },
+  updateParam(nodes, _m, param, value) {
+    switch (param) {
+      case "rate":
+        nodes.lfo.frequency.value = value;
+        break;
+      case "depth": {
+        const d = value;
+        [200, 400, 600, 800].forEach((base, i) => {
+          const g = nodes[`stageGain${i}`];
+          g.gain.value = d * base * 0.8;
+        });
+        break;
+      }
+      case "feedback":
+        nodes.feedback.gain.value = value;
+        break;
+      case "mix":
+        nodes._mix.offset.value = value;
+        break;
+    }
+  },
+  dispose(nodes) {
+    nodes.lfo.stop();
+    nodes._mix.stop();
+  }
+});
+
+// src/lib-runtime/generated/modules/phaser.wrapper.ts
+var Phaser = /* @__PURE__ */ defineModule(phaserDescriptor);
+
+// src/lib-runtime/generated/modules/ping-pong.tsx
+var params30 = {
+  time: { node: "worklet", field: "time", unit: "s", default: 0.3, min: 0.1, max: 1, scale: "log" },
+  feedback: { node: "worklet", field: "feedback", unit: "factor", default: 0.4, min: 0, max: 0.9 },
+  spread: { unit: "factor", default: 1, min: 0, max: 1 },
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 0.5, min: 0, max: 1 }
+};
+var pingPongDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "ping-pong",
+  params: params30,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "ping-pong", position, ...paramDefaults(params30) };
+  },
+  // The delay lines and cross-feedback live in the 'ping-pong' AudioWorklet
+  // (src/worklets/ping-pong.ts) as of 2026-08-08. A native two-DelayNode
+  // cycle carries ONE render quantum of hidden latency at an UNSTABLE
+  // position: identical code measured +3.01 dB (coherent grid) on one run
+  // and −0.19 dB (right leg off by a quantum) on the next, so no static
+  // delayTime compensation can hold the tap grid. The worklet's grid is
+  // exact by construction. Pans, spread, and dry/wet mix stay native.
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const panL = ctx.createStereoPanner();
+    const panR = ctx.createStereoPanner();
+    const worklet = createPingPongNode(ctx, {
+      time: module.time,
+      feedback: module.feedback
+    });
+    panL.pan.value = -module.spread;
+    panR.pan.value = module.spread;
+    const _mix = createMix(ctx, dryGain, wetGain, module.mix, "linear");
+    input.connect(dryGain);
+    input.connect(worklet);
+    worklet.connect(panL, 0);
+    worklet.connect(panR, 1);
+    panL.connect(wetGain);
+    panR.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return { input, output, worklet, dryGain, wetGain, panL, panR, _mix };
+  },
+  updateParam(nodes, _m, param, value) {
+    if (param === "time" || param === "feedback") {
+      const p = nodes.worklet.parameters.get(param);
+      if (p) p.value = value;
+    } else if (param === "spread") {
+      nodes.panL.pan.value = -value;
+      nodes.panR.pan.value = value;
+    } else if (param === "mix") {
+      nodes._mix.offset.value = value;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/ping-pong.wrapper.ts
+var PingPong = /* @__PURE__ */ defineModule(pingPongDescriptor, {
+  worklets: {
+    "ping-pong": ping_pong_default
+  }
+});
+
+// src/lib/dsp/modal.ts
+var MODAL_Q_MAX = 1e3;
+var MODAL_Q_MIN = 2;
+var T60_PER_Q_HZ = 3 * Math.LN10 / Math.PI;
+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 modalMakeup(q) {
+  return Math.sqrt(Math.max(1, q));
+}
+
+// src/lib-runtime/generated/modules/resonator.tsx
+var params31 = {
+  // Root pitch = V/OCT input (absolute notes, silence = 0) + MOD (semitones) + offset.
+  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 }
+};
+function partialOffset(partial, structure) {
+  return 12 * (1 + structure) * Math.log2(partial);
+}
+var patchCount2 = /* @__PURE__ */ new WeakMap();
+var resonatorDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "resonator",
+  params: params31,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "voct": { type: "input", signal: "pitch", node: "_pitch" },
+    "modFreq": { type: "modulation", signal: "modulation", node: "_pitch" }
+  },
+  createModule(id, position) {
+    const { offset: _dsp, ...rest } = paramDefaults(params31);
+    return { id, type: "resonator", position, ...rest, note: 57, transpose: 0 };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const _root = ctx.createConstantSource();
+    _root.offset.value = module.offset ?? module.note;
+    _root.start();
+    const _pitch = ctx.createGain();
+    _root.connect(_pitch);
+    const filters = [];
+    const partialGains = [];
+    const voct = [];
+    const q = dampingToQ(module.damping);
+    const makeup = modalMakeup(q);
+    for (let i = 1; i <= 5; i++) {
+      const v = createVoctFreqNode(ctx);
+      v.parameters.get("transpose").value = partialOffset(i, module.structure);
+      _pitch.connect(v);
+      const filter = ctx.createBiquadFilter();
+      filter.type = "bandpass";
+      filter.frequency.value = 0;
+      v.connect(filter.frequency);
+      filter.Q.value = q;
+      filters.push(filter);
+      voct.push(v);
+      input.connect(filter);
+      const partialGain = ctx.createGain();
+      partialGain.gain.value = makeup / Math.sqrt(i);
+      filter.connect(partialGain);
+      partialGain.connect(wetGain);
+      partialGains.push(partialGain);
+    }
+    const _mix = createMix(ctx, dryGain, wetGain, module.mix, "linear", 0.6);
+    input.connect(dryGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return {
+      input,
+      output,
+      dryGain,
+      wetGain,
+      _mix,
+      _root,
+      _pitch,
+      v1: voct[0],
+      v2: voct[1],
+      v3: voct[2],
+      v4: voct[3],
+      v5: voct[4],
+      f1: filters[0],
+      f2: filters[1],
+      f3: filters[2],
+      f4: filters[3],
+      f5: filters[4],
+      g1: partialGains[0],
+      g2: partialGains[1],
+      g3: partialGains[2],
+      g4: partialGains[3],
+      g5: partialGains[4]
+    };
+  },
+  updateParam(nodes, _module, param, value) {
+    const filters = [nodes.f1, nodes.f2, nodes.f3, nodes.f4, nodes.f5];
+    if (param === "offset") {
+      nodes._root.offset.value = value;
+    } else if (param === "note") {
+      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 === "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);
+      }
+    } else if (param === "mix") {
+      nodes._mix.offset.value = value;
+    }
+  },
+  // App-only: plain summing connect; the hooks only swap which panel memory
+  // drives the offset.
+  onConnect(nodes, module, portId, sourceNode) {
+    if (portId !== "voct") return false;
+    sourceNode.connect(nodes._pitch);
+    patchCount2.set(nodes, (patchCount2.get(nodes) ?? 0) + 1);
+    nodes._root.offset.value = module.transpose ?? 0;
+    return true;
+  },
+  onDisconnect(nodes, module, portId, sourceNode) {
+    if (portId !== "voct") return false;
+    try {
+      sourceNode.disconnect(nodes._pitch);
+    } catch (_) {
+    }
+    const n = Math.max(0, (patchCount2.get(nodes) ?? 0) - 1);
+    patchCount2.set(nodes, n);
+    if (!n) nodes._root.offset.value = module.note;
+    return true;
+  },
+  dispose(nodes) {
+    nodes._root.stop();
+  }
+});
+
+// src/lib-runtime/generated/modules/resonator.wrapper.ts
+var Resonator = /* @__PURE__ */ defineModule(resonatorDescriptor, {
+  worklets: {
+    "map-voct-to-freq": map_voct_to_freq_default
+  }
+});
+
+// src/lib/dsp/fdnTank.ts
+function createFdnTank(ctx, opts) {
+  const input = ctx.createGain();
+  const output = ctx.createGain();
+  const node = createFdnReverbNode(ctx, opts);
+  input.connect(node);
+  node.connect(output);
+  return { input, output, node };
+}
+function setTankDecay(tank, rt60, now2, t = 0.02) {
+  tank.node.parameters.get("rt60").setTargetAtTime(rt60, now2, t);
+}
+
+// src/lib-runtime/generated/modules/reverb.tsx
+var params32 = {
+  decay: { node: "tankNode", field: "rt60", default: 2, min: 0.1, max: 8, scale: "log", unit: "s" },
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 0.3, min: 0, max: 1 }
+};
+var reverbDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "reverb",
+  params: params32,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return {
+      id,
+      type: "reverb",
+      position,
+      ...paramDefaults(params32)
+    };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const _mix = createMix(ctx, dryGain, wetGain, module.mix, "equal-power");
+    const preDelay = ctx.createDelay(0.5);
+    preDelay.delayTime.value = 0.02;
+    const tank = createFdnTank(ctx, { rt60: module.decay, damping: 0.55 });
+    input.connect(dryGain);
+    input.connect(preDelay);
+    preDelay.connect(tank.input);
+    tank.output.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return {
+      input,
+      output,
+      dryGain,
+      wetGain,
+      _mix,
+      preDelay,
+      tankInput: tank.input,
+      tankOutput: tank.output,
+      tankNode: tank.node
+    };
+  },
+  updateParam(nodes, _m, param, value) {
+    const now2 = nodes.input.context.currentTime;
+    if (param === "mix") {
+      nodes._mix.offset.setTargetAtTime(value, now2, 0.02);
+    } else if (param === "decay") {
+      setTankDecay({ node: nodes.tankNode }, value, now2);
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/reverb.wrapper.ts
+var Reverb = /* @__PURE__ */ defineModule(reverbDescriptor, {
+  worklets: {
+    "fdn-reverb": fdn_reverb_default
+  }
+});
+
+// src/lib-runtime/generated/modules/ring-mod.tsx
+var params33 = {
+  // Carrier pitch = V/OCT input (absolute notes, silence = 0) + MOD (semitones) + offset.
+  offset: { node: "_carrierVoct", field: "transpose", unit: "semitone", default: 69, min: -48, max: 108 },
+  // Dry/wet is split across two gain nodes, not one AudioParam — set-only.
+  mix: { unit: "factor", default: 0.5, min: 0, max: 1 }
+};
+var patchCount3 = /* @__PURE__ */ new WeakMap();
+var ringModDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "ring-mod",
+  params: params33,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "voct": { type: "input", signal: "pitch", node: "_carrierVoct" },
+    "modFreq": { type: "modulation", signal: "modulation", node: "_carrierVoct" }
+  },
+  createModule(id, position) {
+    const { offset: _dsp, ...rest } = paramDefaults(params33);
+    return { id, type: "ring-mod", position, ...rest, note: 69, transpose: 0 };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const carrier = ctx.createOscillator();
+    const ringMod = ctx.createGain();
+    dryGain.gain.value = 1 - module.mix;
+    wetGain.gain.value = module.mix;
+    carrier.type = "sine";
+    ringMod.gain.value = 0;
+    carrier.connect(ringMod.gain);
+    carrier.start();
+    carrier.frequency.value = 0;
+    const _carrierVoct = createVoctFreqNode(ctx);
+    _carrierVoct.parameters.get("transpose").value = module.offset ?? module.note;
+    const _carrierBase = ctx.createConstantSource();
+    _carrierBase.offset.value = 0;
+    _carrierBase.start();
+    _carrierBase.connect(_carrierVoct);
+    _carrierVoct.connect(carrier.frequency);
+    input.connect(dryGain);
+    input.connect(ringMod);
+    ringMod.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return { input, output, carrier, ringMod, dryGain, wetGain, _carrierVoct, _carrierBase };
+  },
+  updateParam(nodes, _m, param, value) {
+    const t = nodes._carrierVoct.parameters.get("transpose");
+    if (param === "offset") t.value = value;
+    else if (param === "note") {
+      if (!patchCount3.get(nodes)) t.value = value;
+    } else if (param === "transpose") {
+      if (patchCount3.get(nodes)) t.value = value;
+    } else if (param === "mix") {
+      nodes.dryGain.gain.value = 1 - value;
+      nodes.wetGain.gain.value = value;
+    }
+  },
+  // App-only: plain summing connect; the hooks only swap which panel memory
+  // drives the offset.
+  onConnect(nodes, module, portId, sourceNode) {
+    if (portId !== "voct") return false;
+    sourceNode.connect(nodes._carrierVoct);
+    patchCount3.set(nodes, (patchCount3.get(nodes) ?? 0) + 1);
+    nodes._carrierVoct.parameters.get("transpose").value = module.transpose ?? 0;
+    return true;
+  },
+  onDisconnect(nodes, module, portId, sourceNode) {
+    if (portId !== "voct") return false;
+    try {
+      sourceNode.disconnect(nodes._carrierVoct);
+    } catch (_) {
+    }
+    const n = Math.max(0, (patchCount3.get(nodes) ?? 0) - 1);
+    patchCount3.set(nodes, n);
+    if (!n) nodes._carrierVoct.parameters.get("transpose").value = module.note;
+    return true;
+  },
+  dispose(nodes) {
+    try {
+      nodes.carrier.stop();
+    } catch (_) {
+    }
+    try {
+      nodes._carrierBase.stop();
+    } catch (_) {
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/ring-mod.wrapper.ts
+var RingModulator = /* @__PURE__ */ defineModule(ringModDescriptor, {
+  worklets: {
+    "map-voct-to-freq": map_voct_to_freq_default
+  }
+});
+
+// src/lib-runtime/generated/modules/rotary.tsx
+var CROSSOVER_HZ = 800;
+var BUTTERWORTH_Q_DB = -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 params34 = {
+  speed: { kind: "enum", options: ["slow", "fast"], default: "slow" },
+  slowRate: { unit: "Hz", default: 0.8, min: 0.5, max: 2 },
+  fastRate: { unit: "Hz", default: 6, min: 4, max: 8 },
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 0.7, min: 0, max: 1 }
+};
+var rotaryDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "rotary",
+  params: params34,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "modMix": { type: "modulation", signal: "modulation", node: "_mix", field: "offset" }
+  },
+  createModule(id, position) {
+    return { id, type: "rotary", position, ...paramDefaults(params34) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const monoIn = ctx.createGain();
+    monoIn.channelCount = 1;
+    monoIn.channelCountMode = "explicit";
+    monoIn.channelInterpretation = "speakers";
+    const merger = ctx.createChannelMerger(2);
+    const MIC_DEG = 60;
+    const biquad = (type) => {
+      const f = ctx.createBiquadFilter();
+      f.type = type;
+      f.frequency.value = CROSSOVER_HZ;
+      f.Q.value = BUTTERWORTH_Q_DB;
+      return f;
+    };
+    const lp1 = biquad("lowpass"), lp2 = biquad("lowpass");
+    const hp1 = biquad("highpass"), hp2 = biquad("highpass");
+    monoIn.connect(lp1);
+    lp1.connect(lp2);
+    monoIn.connect(hp1);
+    hp1.connect(hp2);
+    const hornRate = module.speed === "slow" ? module.slowRate : module.fastRate;
+    const sources = [];
+    const rotor = (band, spec, rate) => {
+      const speed = ctx.createConstantSource();
+      speed.offset.value = rate;
+      sources.push(speed);
+      [MIC_DEG, -MIC_DEG].forEach((micDeg, ch) => {
+        const phi = (micDeg + spec.phaseDeg) * Math.PI / 180;
+        const wave = ctx.createPeriodicWave(
+          new Float32Array([0, Math.cos(phi)]),
+          new Float32Array([0, Math.sin(phi)]),
+          { disableNormalization: true }
+        );
+        const osc = ctx.createOscillator();
+        osc.setPeriodicWave(wave);
+        osc.frequency.value = 0;
+        speed.connect(osc.frequency);
+        sources.push(osc);
+        const delay = ctx.createDelay(0.02);
+        delay.delayTime.value = spec.baseDelay;
+        const dop = ctx.createGain();
+        dop.gain.value = -spec.dopplerSec;
+        osc.connect(dop);
+        dop.connect(delay.delayTime);
+        const amp = ctx.createGain();
+        amp.gain.value = spec.ampBase;
+        const am = ctx.createGain();
+        am.gain.value = spec.ampDepth;
+        osc.connect(am);
+        am.connect(amp.gain);
+        band.connect(delay);
+        delay.connect(amp);
+        amp.connect(merger, 0, ch);
+      });
+      return speed;
+    };
+    const hornSpeed = rotor(hp2, HORN, hornRate);
+    const drumSpeed = rotor(lp2, DRUM, hornRate * DRUM_RATIO);
+    sources.forEach((n) => n.start());
+    const _mix = createMix(ctx, dryGain, wetGain, module.mix, "linear");
+    input.connect(dryGain);
+    input.connect(monoIn);
+    merger.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    const srcNodes = Object.fromEntries(sources.map((n, i) => [`src${i}`, n]));
+    return { input, output, dryGain, wetGain, hornSpeed, drumSpeed, _mix, ...srcNodes };
+  },
+  updateParam(nodes, module, param, value) {
+    const now2 = nodes.input.context.currentTime;
+    const setRate = (horn, inertia) => {
+      const hs = nodes.hornSpeed;
+      const ds = nodes.drumSpeed;
+      const up = horn > hs.offset.value;
+      const tH = inertia ? up ? HORN.tauUp : HORN.tauDown : 0.05;
+      const tD = inertia ? up ? DRUM.tauUp : DRUM.tauDown : 0.05;
+      hs.offset.cancelScheduledValues(now2);
+      ds.offset.cancelScheduledValues(now2);
+      hs.offset.setTargetAtTime(horn, now2, tH);
+      ds.offset.setTargetAtTime(horn * DRUM_RATIO, now2, tD);
+    };
+    if (param === "speed") {
+      setRate(value === "slow" ? module.slowRate : module.fastRate, true);
+    } else if (param === "slowRate") {
+      if (module.speed === "slow") setRate(value, false);
+    } else if (param === "fastRate") {
+      if (module.speed === "fast") setRate(value, false);
+    } else if (param === "mix") {
+      nodes._mix.offset.value = value;
+    }
+  },
+  dispose(nodes) {
+    for (const [k, n] of Object.entries(nodes)) {
+      if (k.startsWith("src")) n.stop();
+    }
+    nodes._mix.stop();
+  }
+});
+
+// src/lib-runtime/generated/modules/rotary.wrapper.ts
+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: { 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);
+  }
+  return curve;
+}
+var saturatorDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "saturator",
+  params: params35,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "saturator", position, ...paramDefaults(params35) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const driveGain = ctx.createGain();
+    const waveshaper = ctx.createWaveShaper();
+    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);
+    warmthFilter.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return { input, output, driveGain, waveshaper, warmthFilter, dryGain, wetGain, _mix };
+  },
+  updateParam(nodes, _m, param, value) {
+    if (param === "drive") {
+      nodes.driveGain.gain.value = 1 + value * 4;
+      nodes.waveshaper.curve = makeSaturationCurve(value);
+    } else if (param === "warmth") {
+      nodes.warmthFilter.gain.value = value * 6;
+    } else if (param === "mix") {
+      nodes._mix.offset.value = value;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/saturator.wrapper.ts
+var Saturator = /* @__PURE__ */ defineModule(saturatorDescriptor);
+
+// src/lib-runtime/generated/modules/shimmer.tsx
+var params36 = {
+  decay: { unit: "s", default: 3, min: 0.5, max: 10, scale: "log" },
+  pitch: { unit: "semitone", default: 12, min: -12, max: 24 },
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 0.5, min: 0, max: 1 },
+  shimmer: { node: "regenGain", field: "gain", unit: "factor", default: 0.5, min: 0, max: 0.95 }
+};
+var shimmerDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "shimmer",
+  params: params36,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "shimmer", position, ...paramDefaults(params36) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const _mix = createMix(ctx, dryGain, wetGain, module.mix, "equal-power");
+    const tank = createFdnTank(ctx, { rt60: module.decay, damping: 0.5, feedbackCeiling: 0.93 });
+    const splitter = ctx.createChannelSplitter(2);
+    const merger = ctx.createChannelMerger(2);
+    const mkRegenTap = () => {
+      const hp = ctx.createBiquadFilter();
+      hp.type = "highpass";
+      hp.frequency.value = 300;
+      const shifter = createPitchShifterNode(ctx, module.pitch);
+      return { hp, shifter };
+    };
+    const tapL = mkRegenTap();
+    const tapR = mkRegenTap();
+    const regenGain = ctx.createGain();
+    regenGain.gain.value = module.shimmer;
+    const regenDelay = ctx.createDelay(0.1);
+    regenDelay.delayTime.value = 0.02;
+    tank.output.connect(splitter);
+    splitter.connect(tapL.hp, 0);
+    splitter.connect(tapR.hp, 1);
+    tapL.hp.connect(tapL.shifter);
+    tapR.hp.connect(tapR.shifter);
+    tapL.shifter.connect(merger, 0, 0);
+    tapR.shifter.connect(merger, 0, 1);
+    merger.connect(regenGain);
+    regenGain.connect(regenDelay);
+    regenDelay.connect(tank.input);
+    input.connect(dryGain);
+    input.connect(tank.input);
+    tank.output.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return {
+      input,
+      output,
+      dryGain,
+      wetGain,
+      _mix,
+      splitter,
+      merger,
+      highpassL: tapL.hp,
+      highpassR: tapR.hp,
+      pitchShifterL: tapL.shifter,
+      pitchShifterR: tapR.shifter,
+      regenGain,
+      regenDelay,
+      tankInput: tank.input,
+      tankOutput: tank.output,
+      tankNode: tank.node
+    };
+  },
+  updateParam(nodes, _m, param, value) {
+    const now2 = nodes.input.context.currentTime;
+    if (param === "mix") {
+      nodes._mix.offset.value = value;
+    } else if (param === "shimmer") {
+      nodes.regenGain.gain.setTargetAtTime(value, now2, 0.02);
+    } else if (param === "pitch") {
+      for (const key of ["pitchShifterL", "pitchShifterR"]) {
+        nodes[key].parameters.get("semitones").setTargetAtTime(value, now2, 0.02);
+      }
+    } else if (param === "decay") {
+      setTankDecay({ node: nodes.tankNode }, value, now2);
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/shimmer.wrapper.ts
+var Shimmer = /* @__PURE__ */ defineModule(shimmerDescriptor, {
+  worklets: {
+    "pitch-shifter": pitch_shifter_default,
+    "fdn-reverb": fdn_reverb_default
+  }
+});
+
+// src/lib-runtime/generated/modules/soft-limit.tsx
+var params37 = {
+  drive: { unit: "factor", default: 0.5, min: 0, max: 1 },
+  knee: { unit: "factor", default: 0.5, min: 0, max: 1 },
+  ceiling: { unit: "dB", default: -0.5, min: -12, max: 0 }
+};
+function makeSoftLimitCurve(knee, drive) {
+  const samples = 44100;
+  const curve = new Float32Array(samples);
+  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;
+    } else {
+      const sign = x > 0 ? 1 : -1;
+      curve[i] = sign * (k + (1 - k) * Math.tanh((Math.abs(x) - k) / (1 - k)));
+    }
+  }
+  return curve;
+}
+var softLimitDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "soft-limit",
+  params: params37,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "soft-limit", position, ...paramDefaults(params37) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const waveshaper = ctx.createWaveShaper();
+    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);
+    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);
+    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);
+
+// src/lib-runtime/generated/modules/spring-reverb.tsx
+var params38 = {
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 0.35, min: 0, max: 1 },
+  decay: { node: "_worklet", field: "decay", default: 1.5, min: 0.3, max: 4, scale: "log", unit: "s" },
+  tone: { node: "_worklet", field: "tone", unit: "factor", default: 0.6, min: 0, max: 1 },
+  drip: { node: "_worklet", field: "drip", unit: "factor", default: 0.5, min: 0, max: 1 }
+};
+var springReverbDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "spring-reverb",
+  params: params38,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "knock": { type: "input", signal: "gate", node: "_knockIn" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "spring-reverb", position, ...paramDefaults(params38) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const _worklet = createSpringReverbNode(ctx, {
+      decay: module.decay,
+      tone: module.tone,
+      drip: module.drip
+    });
+    const _knockIn = ctx.createGain();
+    _knockIn.gain.value = 1;
+    _knockIn.connect(_worklet, 0, 1);
+    const _mix = createMix(ctx, dryGain, wetGain, module.mix, "equal-power");
+    input.connect(dryGain);
+    input.connect(_worklet, 0, 0);
+    _worklet.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return { input, output, dryGain, wetGain, _mix, _worklet, _knockIn };
+  },
+  updateParam(nodes, _module, param, value, when) {
+    const worklet = nodes._worklet;
+    if (param === "mix") {
+      nodes._mix.offset.value = value;
+    } else if (param === "decay" || param === "tone" || param === "drip") {
+      worklet.parameters.get(param).value = value;
+    } else if (param === "knock") {
+      pulse(nodes._knockIn, when);
+    }
+  },
+  dispose(_nodes) {
+  }
+});
+
+// src/lib-runtime/generated/modules/spring-reverb.wrapper.ts
+var SpringReverb = /* @__PURE__ */ defineModule(springReverbDescriptor, {
+  worklets: {
+    "spring-reverb": spring_reverb_default
+  }
+});
+
+// src/lib-runtime/generated/modules/stereo-spread.tsx
+var params39 = {
+  spread: { unit: "factor", default: 0.7, min: 0, max: 1 },
+  center: { unit: "Hz", default: 800, min: 200, max: 2e3, scale: "log" }
+};
+var stereoSpreadDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "stereo-spread",
+  params: params39,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "stereo-spread", position, ...paramDefaults(params39) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const lowpass = ctx.createBiquadFilter();
+    const highpass = ctx.createBiquadFilter();
+    lowpass.type = "lowpass";
+    lowpass.frequency.value = module.center;
+    highpass.type = "highpass";
+    highpass.frequency.value = module.center;
+    const panLeft = ctx.createStereoPanner();
+    const panRight = ctx.createStereoPanner();
+    const haasDelay = ctx.createDelay(0.02);
+    panLeft.pan.value = -module.spread;
+    panRight.pan.value = module.spread;
+    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);
+    haasDelay.connect(panRight);
+    panLeft.connect(wetGain);
+    panRight.connect(wetGain);
+    wetGain.connect(output);
+    return { input, output, lowpass, highpass, panLeft, panRight, haasDelay, wetGain };
+  },
+  updateParam(nodes, _m, param, value) {
+    if (param === "spread") {
+      nodes.panLeft.pan.value = -value;
+      nodes.panRight.pan.value = value;
+      nodes.haasDelay.delayTime.value = value * 5e-3;
+    } else if (param === "width") {
+      nodes.wetGain.gain.value = value;
+    } else if (param === "center") {
+      nodes.lowpass.frequency.value = value;
+      nodes.highpass.frequency.value = value;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/stereo-spread.wrapper.ts
+var StereoSpread = /* @__PURE__ */ defineModule(stereoSpreadDescriptor);
+
+// src/lib-runtime/generated/modules/sub-harm.tsx
+var params40 = {
+  direct: { node: "dryGain", field: "gain", unit: "factor", default: 1, min: 0, max: 1 },
+  octave1: { node: "subOctave", field: "oct1Level", unit: "factor", default: 0.5, min: 0, max: 1 },
+  octave2: { node: "subOctave", field: "oct2Level", unit: "factor", default: 0.3, min: 0, max: 1 }
+};
+var subHarmDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "sub-harm",
+  params: params40,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "sub-harm", position, ...paramDefaults(params40) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const subOctave = createSubOctaveNode(ctx);
+    subOctave.parameters.get("oct1Level").value = module.octave1;
+    subOctave.parameters.get("oct2Level").value = module.octave2;
+    const subFilter = ctx.createBiquadFilter();
+    subFilter.type = "lowpass";
+    subFilter.frequency.value = 400;
+    subFilter.Q.value = 0.7;
+    dryGain.gain.value = module.direct;
+    wetGain.gain.value = 1;
+    input.connect(dryGain);
+    input.connect(subOctave);
+    subOctave.connect(subFilter);
+    subFilter.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return { input, output, subOctave, dryGain, wetGain };
+  },
+  updateParam(nodes, _m, param, value) {
+    if (param === "octave1") {
+      nodes.subOctave.parameters.get("oct1Level").value = value;
+    } else if (param === "octave2") {
+      nodes.subOctave.parameters.get("oct2Level").value = value;
+    } else if (param === "direct") {
+      nodes.dryGain.gain.value = value;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/sub-harm.wrapper.ts
+var Subharmonic = /* @__PURE__ */ defineModule(subHarmDescriptor, {
+  worklets: {
+    "freq-divider": freq_divider_default
+  }
+});
+
+// src/lib-runtime/generated/modules/tape-delay.tsx
+var params41 = {
+  time: { node: "worklet", field: "time", unit: "s", default: 0.375, min: 0.05, max: 1.5, scale: "log" },
+  feedback: { node: "worklet", field: "feedback", unit: "factor", default: 0.5, min: 0, max: 0.95 },
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 0.4, min: 0, max: 1 },
+  flutter: { node: "worklet", field: "flutter", unit: "factor", default: 0.3, min: 0, max: 1 },
+  saturation: { node: "worklet", field: "saturation", unit: "factor", default: 0.4, min: 0, max: 1 }
+};
+var tapeDelayDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "tape-delay",
+  params: params41,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "tape-delay", position, ...paramDefaults(params41) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const dryGain = ctx.createGain();
+    const wetGain = ctx.createGain();
+    const worklet = createTapeDelayNode(ctx, {
+      time: module.time,
+      feedback: module.feedback,
+      saturation: module.saturation,
+      flutter: module.flutter
+    });
+    const _mix = createMix(ctx, dryGain, wetGain, module.mix, "linear");
+    input.connect(dryGain);
+    input.connect(worklet);
+    worklet.connect(wetGain);
+    dryGain.connect(output);
+    wetGain.connect(output);
+    return { input, output, worklet, dryGain, wetGain, _mix };
+  },
+  updateParam(nodes, _m, param, value) {
+    const worklet = nodes.worklet;
+    if (param === "time" || param === "feedback" || param === "saturation" || param === "flutter") {
+      const p = worklet.parameters.get(param);
+      if (p) p.value = value;
+    } else if (param === "mix") {
+      nodes._mix.offset.value = value;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/tape-delay.wrapper.ts
+var TapeDelay = /* @__PURE__ */ defineModule(tapeDelayDescriptor, {
+  worklets: {
+    "tape-delay": tape_delay_default
+  }
+});
+
+// src/lib-runtime/generated/modules/tape-stop.tsx
+var params42 = {
+  time: { node: "_worklet", field: "time", default: 0.5, min: 0.01, max: 4, scale: "log", unit: "s" },
+  mix: { node: "_worklet", field: "mix", unit: "factor", default: 1, min: 0, max: 1 }
+};
+var tapeStopDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "tape-stop",
+  params: params42,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "_worklet" },
+    "trigger": { type: "input", signal: "gate", node: "_trigIn" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "tape-stop", position, ...paramDefaults(params42) };
+  },
+  createNodes(ctx, module) {
+    const _worklet = createTapeStopNode(ctx, module.time, module.mix);
+    const _trigIn = ctx.createGain();
+    _trigIn.gain.value = 1;
+    _trigIn.connect(_worklet, 0, 1);
+    const output = ctx.createGain();
+    _worklet.connect(output);
+    return { _worklet, _trigIn, output };
+  },
+  updateParam(nodes, _module, param, value, when) {
+    if (param === "time") {
+      nodes._worklet.parameters.get("time").value = value;
+    } else if (param === "mix") {
+      nodes._worklet.parameters.get("mix").value = value;
+    } else if (param === "trigger") {
+      pulse(nodes._trigIn, when);
+    }
+  },
+  dispose(_nodes) {
+  }
+});
+
+// src/lib-runtime/generated/modules/tape-stop.wrapper.ts
+var TapeStop = /* @__PURE__ */ defineModule(tapeStopDescriptor, {
+  worklets: {
+    "tape-stop": tape_stop_default
+  }
+});
+
+// src/lib-runtime/generated/modules/tilt.tsx
+var params43 = {
+  tilt: { unit: "dB", default: 0, min: -12, max: 12 },
+  frequency: { unit: "Hz", default: 1e3, min: 200, max: 5e3 }
+};
+var tiltEqDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "tilt-eq",
+  params: params43,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "tilt-eq", position, ...paramDefaults(params43) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const lowShelf = ctx.createBiquadFilter();
+    const highShelf = ctx.createBiquadFilter();
+    lowShelf.type = "lowshelf";
+    lowShelf.frequency.value = module.frequency;
+    lowShelf.gain.value = -module.tilt;
+    highShelf.type = "highshelf";
+    highShelf.frequency.value = module.frequency;
+    highShelf.gain.value = module.tilt;
+    input.connect(lowShelf);
+    lowShelf.connect(highShelf);
+    highShelf.connect(output);
+    return { input, output, lowShelf, highShelf };
+  },
+  updateParam(nodes, _m, param, value) {
+    if (param === "tilt") {
+      nodes.lowShelf.gain.value = -value;
+      nodes.highShelf.gain.value = value;
+    } else if (param === "frequency") {
+      nodes.lowShelf.frequency.value = value;
+      nodes.highShelf.frequency.value = value;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/tilt.wrapper.ts
+var Tilt = /* @__PURE__ */ defineModule(tiltEqDescriptor);
+
+// src/lib-runtime/generated/modules/tremolo.tsx
+var shapes2 = ["sine", "triangle", "square"];
+var params44 = {
+  rate: { node: "lfo", field: "frequency", unit: "Hz", default: 5, min: 0.5, max: 20 },
+  depth: { unit: "factor", default: 0.5, min: 0, max: 1 },
+  shape: { kind: "enum", options: shapes2, default: "sine" }
+};
+var tremoloDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "tremolo",
+  params: params44,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "modRate": { type: "modulation", signal: "modulation", node: "lfo", field: "frequency" }
+  },
+  createModule(id, position) {
+    return { id, type: "tremolo", position, ...paramDefaults(params44) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const tremGain = ctx.createGain();
+    const lfo = ctx.createOscillator();
+    const lfoGain = ctx.createGain();
+    const dcOffset = ctx.createConstantSource();
+    tremGain.gain.value = 0;
+    lfo.type = module.shape;
+    lfo.frequency.value = module.rate;
+    lfoGain.gain.value = module.depth * 0.5;
+    dcOffset.offset.value = 1 - module.depth * 0.5;
+    lfo.connect(lfoGain);
+    lfoGain.connect(tremGain.gain);
+    dcOffset.connect(tremGain.gain);
+    lfo.start();
+    dcOffset.start();
+    input.connect(tremGain);
+    tremGain.connect(output);
+    return { input, output, lfo, lfoGain, dcOffset };
+  },
+  updateParam(nodes, _m, param, value) {
+    switch (param) {
+      case "rate":
+        nodes.lfo.frequency.value = value;
+        break;
+      case "depth":
+        nodes.lfoGain.gain.value = value * 0.5;
+        nodes.dcOffset.offset.value = 1 - value * 0.5;
+        break;
+      case "shape":
+        nodes.lfo.type = value;
+        break;
+    }
+  },
+  dispose(nodes) {
+    nodes.lfo.stop();
+    nodes.dcOffset.stop();
+  }
+});
+
+// src/lib-runtime/generated/modules/tremolo.wrapper.ts
+var Tremolo = /* @__PURE__ */ defineModule(tremoloDescriptor);
+
+// src/lib-runtime/generated/modules/vca.tsx
+var params45 = {
+  gain: { node: "gain", field: "gain", unit: "factor", default: 0.5, min: 0, max: 2 },
+  cvAmount: { node: "gain", field: "cvAmount", unit: "factor", default: 1, min: -1, max: 1 }
+};
+var gainDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "gain",
+  params: params45,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "gain" },
+    "out": { type: "output", signal: "audio", node: "gain" },
+    "modGain": { type: "modulation", signal: "modulation", node: "gain", field: "cv" }
+  },
+  createModule(id, position) {
+    return { id, type: "gain", position, ...paramDefaults(params45) };
+  },
+  createNodes(ctx, module) {
+    const gain = createVcaNode(ctx, module.gain, module.cvAmount ?? 1);
+    return { gain };
+  },
+  updateParam(nodes, _module, param, value) {
+    if (param === "gain" || param === "cvAmount") {
+      const p = nodes.gain.parameters.get(param);
+      if (p) p.value = value;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/vca.wrapper.ts
+var Vca = /* @__PURE__ */ defineModule(gainDescriptor, {
+  worklets: {
+    "vca": vca_default
+  }
+});
+
+// src/lib/dsp/gainComp.ts
+function bandpassMakeup(q, cap = 4) {
+  if (!Number.isFinite(q) || q <= 1) return 1;
+  return Math.min(Math.sqrt(q), cap);
+}
+
+// src/lib-runtime/generated/modules/vcf.tsx
+var makeupFor = (type, q) => type === "bandpass" ? bandpassMakeup(q) : 1;
+var qIsDb = (type) => type === "lowpass" || type === "highpass";
+var params46 = {
+  filterType: { kind: "enum", options: ["lowpass", "highpass", "bandpass", "notch"], default: "lowpass" },
+  note: { node: "_cutoffVoct", field: "transpose", unit: "note", default: 83, min: 15, max: 135 },
+  // Resonance is split across the map-res worklet AND a compensation gain,
+  // so it cannot honestly declare a single AudioParam — see lib/dsp/mix.ts
+  // convention: rebuild or leave set-only. It stays set-only here.
+  resonance: { unit: "factor", default: 1, min: 0.1, max: 20, scale: "sqrt" }
+};
+var filterDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "filter",
+  params: params46,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "filter" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "modFreq": { type: "modulation", signal: "modulation", node: "_cutoffVoct" },
+    "modQ": { type: "modulation", signal: "modulation", node: "_resMap" }
+  },
+  createModule(id, position) {
+    return { id, type: "filter", position, resUnit: "q", ...paramDefaults(params46) };
+  },
+  createNodes(ctx, module) {
+    const filter = ctx.createBiquadFilter();
+    filter.type = module.filterType;
+    filter.frequency.value = 0;
+    filter.Q.value = 0;
+    const output = ctx.createGain();
+    output.gain.value = makeupFor(module.filterType, module.resonance);
+    filter.connect(output);
+    const _cutoffVoct = createVoctFreqNode(ctx);
+    _cutoffVoct.parameters.get("transpose").value = module.note;
+    const _cutoffBase = ctx.createConstantSource();
+    _cutoffBase.offset.value = 0;
+    _cutoffBase.start();
+    _cutoffBase.connect(_cutoffVoct);
+    _cutoffVoct.connect(filter.frequency);
+    const _resMap = createMapResNode(ctx, {
+      base: module.resonance,
+      dbOut: qIsDb(module.filterType)
+    });
+    _resMap.connect(filter.Q);
+    return { filter, output, _cutoffVoct, _cutoffBase, _resMap };
+  },
+  dispose(nodes) {
+    try {
+      nodes._cutoffBase.stop();
+    } catch (_) {
+    }
+  },
+  updateParam(nodes, module, param, value) {
+    switch (param) {
+      case "filterType":
+        nodes.filter.type = value;
+        nodes._resMap.parameters.get("dbOut").value = qIsDb(value) ? 1 : 0;
+        nodes.output.gain.value = makeupFor(value, module.resonance);
+        break;
+      case "note":
+        nodes._cutoffVoct.parameters.get("transpose").value = value;
+        break;
+      case "resonance":
+        nodes._resMap.parameters.get("base").value = value;
+        nodes.output.gain.value = makeupFor(module.filterType, value);
+        break;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/vcf.wrapper.ts
+var Vcf = /* @__PURE__ */ defineModule(filterDescriptor, {
+  worklets: {
+    "map-res": map_res_default,
+    "map-voct-to-freq": map_voct_to_freq_default
+  }
+});
+
+// src/lib-runtime/generated/modules/vco.tsx
+var params47 = {
+  skew: { node: "_ws", field: "skew", unit: "factor", default: 1, min: -1, max: 1 },
+  shape: { node: "_ws", field: "shape", unit: "factor", default: 0, min: -1, max: 1 },
+  offset: { node: "_voct", field: "transpose", default: 69, min: -48, max: 108, unit: "semitone" },
+  detune: { node: "_detune", field: "offset", default: 0, min: -1, max: 1, unit: "semitone" },
+  gain: { node: "gain", field: "gain", unit: "factor", default: 0.5, min: 0, max: 1 }
+};
+var patchCount4 = /* @__PURE__ */ new WeakMap();
+var oscillatorDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "oscillator",
+  ports: {
+    "voct": { type: "input", node: "_voct", signal: "pitch" },
+    "out": { type: "output", signal: "audio", node: "gain" },
+    "modSkew": { type: "modulation", signal: "modulation", node: "_ws", field: "skew" },
+    "modShape": { type: "modulation", signal: "modulation", node: "_ws", field: "shape" },
+    "modDetune": { type: "modulation", signal: "modulation", node: "_detune", field: "offset" }
+  },
+  params: params47,
+  // ─── Factory ─────────────────────────────────────────────────────
+  createModule(id, position) {
+    const { offset: _dsp, ...rest } = paramDefaults(params47);
+    return { id, type: "oscillator", position, ...rest, note: 69, transpose: 0 };
+  },
+  // ─── Audio Engine ────────────────────────────────────────────────
+  createNodes(ctx, module) {
+    const _ws = createWaveshaperNode(ctx);
+    const gain = ctx.createGain();
+    const _detune = ctx.createConstantSource();
+    _detune.offset.value = module.detune;
+    _detune.start();
+    const _voct = createVoctFreqNode(ctx);
+    _detune.connect(_voct);
+    _voct.connect(_ws);
+    _voct.parameters.get("transpose").value = module.offset ?? module.note;
+    _ws.parameters.get("skew").value = module.skew;
+    _ws.parameters.get("shape").value = module.shape;
+    _ws.parameters.get("normalize").value = 1;
+    gain.gain.value = module.gain;
+    _ws.connect(gain);
+    return { gain, _ws, _voct, _detune };
+  },
+  updateParam(nodes, _module, param, value) {
+    switch (param) {
+      case "skew":
+        nodes._ws.parameters.get("skew").value = value;
+        break;
+      case "shape":
+        nodes._ws.parameters.get("shape").value = value;
+        break;
+      case "offset":
+        nodes._voct.parameters.get("transpose").value = value;
+        break;
+      // App panel memories: only the one matching the patch state is live.
+      case "note":
+        if (!patchCount4.get(nodes)) nodes._voct.parameters.get("transpose").value = value;
+        break;
+      case "transpose":
+        if (patchCount4.get(nodes)) nodes._voct.parameters.get("transpose").value = value;
+        break;
+      case "detune":
+        nodes._detune.offset.value = value;
+        break;
+      case "gain":
+        nodes.gain.gain.value = value;
+        break;
+    }
+  },
+  // App-only: the connection is a plain summing connect; these hooks only
+  // swap which panel memory drives the offset.
+  onConnect(nodes, module, portId, sourceNode) {
+    if (portId !== "voct") return false;
+    sourceNode.connect(nodes._voct);
+    patchCount4.set(nodes, (patchCount4.get(nodes) ?? 0) + 1);
+    nodes._voct.parameters.get("transpose").value = module.transpose ?? 0;
+    return true;
+  },
+  onDisconnect(nodes, module, portId, sourceNode) {
+    if (portId !== "voct") return false;
+    try {
+      sourceNode.disconnect(nodes._voct);
+    } catch (e) {
+    }
+    const n = Math.max(0, (patchCount4.get(nodes) ?? 0) - 1);
+    patchCount4.set(nodes, n);
+    if (!n) nodes._voct.parameters.get("transpose").value = module.note;
+    return true;
+  },
+  dispose(nodes) {
+    nodes._detune.stop();
+  }
+});
+
+// src/lib-runtime/generated/modules/vco.wrapper.ts
+var Vco = /* @__PURE__ */ defineModule(oscillatorDescriptor, {
+  worklets: {
+    "map-voct-to-freq": map_voct_to_freq_default,
+    "waveshaper": waveshaper_default
+  }
+});
+
+// src/lib-runtime/generated/modules/wah.tsx
+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: { unit: "factor", default: 0.6, min: 0, max: 1 }
+};
+var wahDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "wah",
+  params: params48,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" },
+    "modFreq": { type: "modulation", signal: "modulation", node: "_cutoffVoct" }
+  },
+  createModule(id, position) {
+    return { id, type: "wah", position, ...paramDefaults(params48) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    const output = ctx.createGain();
+    const filter = ctx.createBiquadFilter();
+    const lfo = ctx.createOscillator();
+    const lfoGain = ctx.createGain();
+    filter.type = "bandpass";
+    filter.frequency.value = 0;
+    filter.Q.value = module.resonance;
+    const makeup = ctx.createGain();
+    makeup.gain.value = bandpassMakeup(module.resonance);
+    const _cutoffVoct = createVoctFreqNode(ctx);
+    _cutoffVoct.parameters.get("transpose").value = module.note;
+    const _cutoffBase = ctx.createConstantSource();
+    _cutoffBase.offset.value = 0;
+    _cutoffBase.start();
+    _cutoffBase.connect(_cutoffVoct);
+    _cutoffVoct.connect(filter.frequency);
+    lfo.type = "sine";
+    lfo.frequency.value = module.rate;
+    lfoGain.gain.value = module.depth * 36;
+    lfo.connect(lfoGain);
+    lfoGain.connect(_cutoffVoct);
+    lfo.start();
+    input.connect(filter);
+    filter.connect(makeup);
+    makeup.connect(output);
+    return { input, output, filter, makeup, lfo, lfoGain, _cutoffVoct, _cutoffBase };
+  },
+  updateParam(nodes, _module, param, value) {
+    if (param === "note") {
+      nodes._cutoffVoct.parameters.get("transpose").value = value;
+    } else if (param === "resonance") {
+      nodes.filter.Q.value = value;
+      nodes.makeup.gain.value = bandpassMakeup(value);
+    } else if (param === "rate") {
+      nodes.lfo.frequency.value = value;
+    } else if (param === "depth") {
+      nodes.lfoGain.gain.value = value * 36;
+    }
+  },
+  dispose(nodes) {
+    nodes.lfo.stop();
+    nodes._cutoffBase.stop();
+  }
+});
+
+// src/lib-runtime/generated/modules/wah.wrapper.ts
+var Wah = /* @__PURE__ */ defineModule(wahDescriptor, {
+  worklets: {
+    "map-voct-to-freq": map_voct_to_freq_default
+  }
+});
+
+// src/lib-runtime/generated/modules/wavefolder.tsx
+var params49 = {
+  folds: { unit: "factor", default: 2, min: 1, max: 10 },
+  symmetry: { unit: "factor", default: 0, min: -1, max: 1 },
+  mix: { node: "_mix", field: "offset", unit: "factor", default: 1, min: 0, max: 1 }
+};
+function makeWavefoldCurve(folds, symmetry) {
+  const samples = 65536;
+  const curve = new Float32Array(samples);
+  const bias = symmetry * 0.2;
+  const w = Math.PI / 2 * folds;
+  const dc = Math.sin(w * bias);
+  let peak = 0;
+  for (let i = 0; i < samples; i++) {
+    const x = i * 2 / samples - 1;
+    const y = Math.sin(w * (x + bias)) - dc;
+    curve[i] = y;
+    const a = Math.abs(y);
+    if (a > peak) peak = a;
+  }
+  if (peak > 1) {
+    const inv = 1 / peak;
+    for (let i = 0; i < samples; i++) curve[i] *= inv;
+  }
+  return curve;
+}
+var wavefolderDescriptor = /* @__PURE__ */ defineDescriptor({
+  type: "wavefolder",
+  params: params49,
+  ports: {
+    "in": { type: "input", signal: "audio", node: "input" },
+    "out": { type: "output", signal: "audio", node: "output" }
+  },
+  createModule(id, position) {
+    return { id, type: "wavefolder", position, ...paramDefaults(params49) };
+  },
+  createNodes(ctx, module) {
+    const input = ctx.createGain();
+    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 _mix = createMix(ctx, dryGain, wetGain, module.mix, "linear");
+    input.connect(dryGain);
+    input.connect(waveshaper);
+    waveshaper.connect(wetGain);
+    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);
+    } else if (param === "mix") {
+      nodes._mix.offset.value = value;
+    }
+  }
+});
+
+// src/lib-runtime/generated/modules/wavefolder.wrapper.ts
+var Wavefolder = /* @__PURE__ */ defineModule(wavefolderDescriptor);
+export {
+  AcidFilter,
+  AutoPan,
+  Bitcrusher,
+  Chorus,
+  CombFilter,
+  Compressor,
+  Crossfade,
+  DEFAULT_SAMPLE_BASE_URL,
+  Delay,
+  Dimension,
+  Distortion,
+  Ducker,
+  Envelope,
+  EnvelopeFollower,
+  Exciter,
+  Flanger,
+  Formant,
+  FrequencyShifter,
+  Gate,
+  Glide,
+  HaasWidener,
+  HarmonicTremolo,
+  Hat,
+  Kick,
+  LadderFilter,
+  Lfo,
+  LoFi,
+  MidSide,
+  Noise,
+  NoteCv,
+  Octaver,
+  Phaser,
+  PingPong,
+  Resonator,
+  Reverb,
+  RingModulator,
+  Rotary,
+  SampleSets,
+  SampleVoice,
+  Saturator,
+  Shimmer,
+  Snare,
+  SoftLimiter,
+  SpringReverb,
+  StereoSpread,
+  Subharmonic,
+  TapeDelay,
+  TapeStop,
+  ThreeBandEq,
+  Tilt,
+  Tremolo,
+  VOICE_KEYS,
+  Vca,
+  Vcf,
+  Vco,
+  Wah,
+  Wavefolder,
+  asPitch,
+  beats,
+  cents,
+  centsToSemitones,
+  createTransport,
+  db,
+  dbToGain,
+  gainToDb,
+  hz,
+  hzToNote,
+  interval,
+  isRest,
+  loadSampleSet,
+  ms,
+  msToSeconds,
+  note,
+  noteToHz,
+  notes,
+  now,
+  preload,
+  pulse,
+  sec,
+  semitones,
+  steps,
+  transpose
+};
+//# sourceMappingURL=index.js.map