@ultrst-armada/kloks 0.0.0-stage → 1.0.0

package/packages/audio-midi/dist/chunk-3GRGELA4.js

@@ -0,0 +1,2533 @@
+// src/engine/audio/audioInputManager/types.ts
+var DEFAULT_NAMED_BUSSES = [
+  {
+    id: "bus-in-1",
+    busType: "input",
+    deviceId: "default",
+    name: "Main Mic / Line In 1",
+    channel: 1,
+    gain: 1,
+    isMuted: false,
+    color: "#f59e0b"
+  },
+  {
+    id: "bus-in-2",
+    busType: "input",
+    deviceId: "default",
+    name: "Instrument / Line In 2",
+    channel: 2,
+    gain: 1,
+    isMuted: false,
+    color: "#06b6d4"
+  },
+  {
+    id: "bus-out-1",
+    busType: "output",
+    deviceId: "default",
+    name: "Main Monitors Out L/R",
+    outputChannels: "Ch 1 / 2 (Main L/R)",
+    gain: 1,
+    isMuted: false,
+    color: "#10b981"
+  }
+];
+
+// src/engine/audio/synthEngine/synthEngine.ts
+import { midiToFreq } from "@ultrst-armada/kloks/state-graph";
+
+// src/engine/audio/outputRouter.ts
+var MultiChannelOutputRouter = class {
+  ctx = null;
+  mergerNode = null;
+  splitterNode = null;
+  routeGainL = null;
+  routeGainR = null;
+  currentChannelRouting = "Ch 1 / 2 (Main L/R)";
+  maxChannels = 2;
+  init(ctx, initialChannels = 6) {
+    this.ctx = ctx;
+    this.maxChannels = Math.max(2, Math.min(32, initialChannels));
+    try {
+      if (this.ctx.destination.maxChannelCount >= this.maxChannels) {
+        this.ctx.destination.channelCount = this.maxChannels;
+        this.ctx.destination.channelCountMode = "explicit";
+        this.ctx.destination.channelInterpretation = "discrete";
+      }
+    } catch (e) {
+      console.warn("Could not set multi-channel destination mode:", e);
+    }
+    this.setupMerger();
+  }
+  setupMerger() {
+    if (!this.ctx) return;
+    try {
+      this.mergerNode = this.ctx.createChannelMerger(this.maxChannels);
+      this.splitterNode = this.ctx.createChannelSplitter(2);
+      this.routeGainL = this.ctx.createGain();
+      this.routeGainR = this.ctx.createGain();
+      this.splitterNode.connect(this.routeGainL, 0);
+      this.splitterNode.connect(this.routeGainR, 1);
+      this.mergerNode.connect(this.ctx.destination);
+      this.applyRouting(this.currentChannelRouting);
+    } catch (e) {
+      console.warn("Error setting up multi-channel output merger:", e);
+    }
+  }
+  connectInput(sourceNode) {
+    if (this.splitterNode) {
+      sourceNode.connect(this.splitterNode);
+    }
+  }
+  setMaxChannels(channels) {
+    this.maxChannels = Math.max(2, Math.min(32, channels));
+    if (this.ctx) {
+      try {
+        if (this.ctx.destination.maxChannelCount >= this.maxChannels) {
+          this.ctx.destination.channelCount = this.maxChannels;
+        }
+      } catch (e) {
+      }
+      this.setupMerger();
+    }
+  }
+  applyRouting(routingId) {
+    this.currentChannelRouting = routingId;
+    if (!this.routeGainL || !this.routeGainR || !this.mergerNode || !this.ctx) return;
+    try {
+      this.routeGainL.disconnect();
+      this.routeGainR.disconnect();
+      if (!routingId || routingId === "none") {
+        return;
+      }
+      let targetL = 0;
+      let targetR = 1;
+      if (routingId.includes("3 / 4") || routingId.includes("3/4")) {
+        targetL = Math.min(2, this.maxChannels - 1);
+        targetR = Math.min(3, this.maxChannels - 1);
+      } else if (routingId.includes("5 / 6") || routingId.includes("5/6")) {
+        targetL = Math.min(4, this.maxChannels - 1);
+        targetR = Math.min(5, this.maxChannels - 1);
+      } else if (routingId.includes("7 / 8") || routingId.includes("7/8")) {
+        targetL = Math.min(6, this.maxChannels - 1);
+        targetR = Math.min(7, this.maxChannels - 1);
+      } else if (routingId.includes("Ch 1 (Mono") || routingId === "Ch 1") {
+        targetL = 0;
+        targetR = 0;
+      } else if (routingId.includes("Ch 2 (Mono") || routingId === "Ch 2") {
+        targetL = Math.min(1, this.maxChannels - 1);
+        targetR = Math.min(1, this.maxChannels - 1);
+      } else if (routingId.includes("Ch 3")) {
+        targetL = Math.min(2, this.maxChannels - 1);
+        targetR = Math.min(2, this.maxChannels - 1);
+      } else if (routingId.includes("Ch 4")) {
+        targetL = Math.min(3, this.maxChannels - 1);
+        targetR = Math.min(3, this.maxChannels - 1);
+      } else if (routingId.includes("Ch 5")) {
+        targetL = Math.min(4, this.maxChannels - 1);
+        targetR = Math.min(4, this.maxChannels - 1);
+      } else if (routingId.includes("Ch 6")) {
+        targetL = Math.min(5, this.maxChannels - 1);
+        targetR = Math.min(5, this.maxChannels - 1);
+      }
+      this.routeGainL.connect(this.mergerNode, 0, targetL);
+      this.routeGainR.connect(this.mergerNode, 0, targetR);
+    } catch (e) {
+      console.warn("Could not re-route output channels:", e);
+    }
+  }
+  async setOutputSinkId(deviceId) {
+    if (this.ctx && typeof this.ctx.setSinkId === "function") {
+      try {
+        await this.ctx.setSinkId(deviceId === "default" ? "" : deviceId);
+        return true;
+      } catch (e) {
+        console.warn("setSinkId failed:", e);
+        return false;
+      }
+    }
+    return false;
+  }
+};
+var multiChannelOutputRouter = new MultiChannelOutputRouter();
+
+// src/engine/audio/synthVoiceHelper.ts
+function createCosmicImpulseBuffer(ctx, duration, decay) {
+  const rate = ctx.sampleRate;
+  const length = rate * duration;
+  const impulse = ctx.createBuffer(2, length, rate);
+  for (let channel = 0; channel < 2; channel++) {
+    const channelData = impulse.getChannelData(channel);
+    for (let i = 0; i < length; i++) {
+      const n = i / length;
+      channelData[i] = (Math.random() * 2 - 1) * Math.pow(1 - n, decay);
+    }
+  }
+  return impulse;
+}
+function playSyntheticDrumVoice(ctx, masterGain, noteNumber, vel, time) {
+  const osc = ctx.createOscillator();
+  const gain = ctx.createGain();
+  const isKick = noteNumber <= 38;
+  if (isKick) {
+    osc.frequency.setValueAtTime(150, time);
+    osc.frequency.exponentialRampToValueAtTime(38, time + 0.12);
+    gain.gain.setValueAtTime(vel * 0.8, time);
+    gain.gain.exponentialRampToValueAtTime(1e-3, time + 0.35);
+    osc.connect(gain);
+    gain.connect(masterGain);
+    osc.start(time);
+    osc.stop(time + 0.36);
+  } else {
+    osc.type = "triangle";
+    osc.frequency.setValueAtTime(280, time);
+    osc.frequency.exponentialRampToValueAtTime(80, time + 0.1);
+    gain.gain.setValueAtTime(vel * 0.5, time);
+    gain.gain.exponentialRampToValueAtTime(1e-3, time + 0.2);
+    osc.connect(gain);
+    gain.connect(masterGain);
+    osc.start(time);
+    osc.stop(time + 0.21);
+  }
+}
+
+// src/engine/audio/AudioGraphNodes.ts
+var BaseAudioGraphNode = class {
+  /**
+   * Root capability flag.
+   * By rule, base nodes CANNOT emit directly to the master output.
+   */
+  canEmitDirectlyToMaster() {
+    return false;
+  }
+  /**
+   * Evaluates if this node is structurally authorized to emit audio.
+   * Standard nodes must prove reachability to a MasterAudioOutputGraphNode
+   * through the active graph connection topology.
+   */
+  isAuthorizedToEmit(graphReachabilityChecker) {
+    if (this.canEmitDirectlyToMaster()) {
+      return true;
+    }
+    return graphReachabilityChecker(this.id);
+  }
+};
+var MasterAudioOutputGraphNode = class extends BaseAudioGraphNode {
+  constructor(id, active = true) {
+    super();
+    this.id = id;
+    this.active = active;
+  }
+  id;
+  active;
+  nodeType = "output_strip";
+  canEmitDirectlyToMaster() {
+    return this.active;
+  }
+};
+var BaseSourceAudioGraphNode = class extends BaseAudioGraphNode {
+  isSourceNode = true;
+};
+var MidiInstrumentGraphNode = class extends BaseSourceAudioGraphNode {
+  constructor(id, pluginId = "grand_piano", volume = 1) {
+    super();
+    this.id = id;
+    this.pluginId = pluginId;
+    this.volume = volume;
+  }
+  id;
+  pluginId;
+  volume;
+  nodeType = "instrument";
+};
+var AudioContainerGraphNode = class extends BaseSourceAudioGraphNode {
+  constructor(id, audioFormat = "mono") {
+    super();
+    this.id = id;
+    this.audioFormat = audioFormat;
+  }
+  id;
+  audioFormat;
+  nodeType = "audio";
+};
+var MidiContainerGraphNode = class extends BaseSourceAudioGraphNode {
+  constructor(id) {
+    super();
+    this.id = id;
+  }
+  id;
+  nodeType = "midi";
+};
+var BaseProcessorAudioGraphNode = class extends BaseAudioGraphNode {
+  isProcessorNode = true;
+};
+var EffectProcessorGraphNode = class extends BaseProcessorAudioGraphNode {
+  constructor(id, effectType, active = true) {
+    super();
+    this.id = id;
+    this.effectType = effectType;
+    this.active = active;
+  }
+  id;
+  effectType;
+  active;
+  nodeType = "effect";
+};
+var SignalRouterGraphNode = class extends BaseProcessorAudioGraphNode {
+  constructor(id, type, active = true) {
+    super();
+    this.id = id;
+    this.active = active;
+    this.nodeType = type;
+  }
+  id;
+  active;
+  nodeType;
+};
+function createAudioGraphNode(node) {
+  switch (node.type) {
+    case "container": {
+      const cont = node;
+      const cType = cont.containerType || "midi";
+      if (cType === "instrument") {
+        return new MidiInstrumentGraphNode(cont.id, cont.selectedPluginId, cont.volume);
+      }
+      if (cType === "audio") {
+        return new AudioContainerGraphNode(cont.id, cont.audioFormat);
+      }
+      return new MidiContainerGraphNode(cont.id);
+    }
+    case "effect": {
+      const eff = node;
+      return new EffectProcessorGraphNode(eff.id, eff.effectType, eff.active !== false);
+    }
+    case "combiner":
+    case "multiplexer":
+    case "converter": {
+      return new SignalRouterGraphNode(node.id, node.type, node.active !== false);
+    }
+    case "output_strip": {
+      return new MasterAudioOutputGraphNode(node.id, node.active !== false);
+    }
+    default:
+      if (node.id === "output-strip-node") {
+        return new MasterAudioOutputGraphNode(node.id, node.active !== false);
+      }
+      return new class GenericGraphNode extends BaseAudioGraphNode {
+        id = node.id;
+        nodeType = node.type;
+      }();
+  }
+}
+
+// src/engine/audio/synthEngine/synthEngine.ts
+import { getActiveEffectsForNode } from "@ultrst-armada/kloks/state-graph";
+
+// src/engine/audio/dsp/saturationCurves.ts
+function generateSaturationCurve(type, drive = 1.5, samples = 4096) {
+  const curve = new Float32Array(samples);
+  const k = Math.max(0.1, drive);
+  const deg = Math.PI / 180;
+  for (let i = 0; i < samples; i++) {
+    const x = i * 2 / samples - 1;
+    let y = x;
+    switch (type) {
+      case "soft_clip": {
+        const absX = Math.abs(x * k);
+        if (absX < 1) {
+          y = x * k - (x * k) ** 3 / 3;
+        } else {
+          y = x > 0 ? 2 / 3 : -2 / 3;
+        }
+        y *= 1.2;
+        break;
+      }
+      case "tube": {
+        const inVal = x * k;
+        if (inVal > 0) {
+          y = 1 - Math.exp(-inVal);
+        } else {
+          y = -(1 - Math.exp(inVal * 0.8));
+        }
+        y *= 1.1;
+        break;
+      }
+      case "hard_clip": {
+        const threshold = 1 / Math.max(1, k);
+        y = Math.max(-threshold, Math.min(threshold, x)) * k;
+        break;
+      }
+      case "foldback": {
+        y = Math.sin(x * k * Math.PI * 0.5);
+        break;
+      }
+      case "tape":
+      default: {
+        y = Math.tanh(x * k * 1.2);
+        break;
+      }
+    }
+    curve[i] = Math.max(-1, Math.min(1, y));
+  }
+  return curve;
+}
+
+// src/engine/audio/dsp/reverbImpulse.ts
+function generateReverbImpulse(ctx, durationSec = 2.5, decayFactor = 2, dampingFreq = 6e3) {
+  const sampleRate = ctx.sampleRate;
+  const length = Math.floor(sampleRate * Math.max(0.2, Math.min(10, durationSec)));
+  const impulse = ctx.createBuffer(2, length, sampleRate);
+  const left = impulse.getChannelData(0);
+  const right = impulse.getChannelData(1);
+  const dampingRatio = Math.min(1, dampingFreq / (sampleRate / 2));
+  let prevL = 0;
+  let prevR = 0;
+  for (let i = 0; i < length; i++) {
+    const t = i / length;
+    const env = Math.pow(1 - t, decayFactor);
+    const noiseL = (Math.random() * 2 - 1) * env;
+    const noiseR = (Math.random() * 2 - 1) * env;
+    prevL = prevL + dampingRatio * (noiseL - prevL);
+    prevR = prevR + dampingRatio * (noiseR - prevR);
+    const earlyEcho = i < sampleRate * 0.04 && i % 400 === 0 ? 0.3 * env : 0;
+    left[i] = prevL + earlyEcho;
+    right[i] = prevR - earlyEcho;
+  }
+  return impulse;
+}
+
+// src/engine/audio/dsp/sidechainCompressor.ts
+function createSidechainCompressor(ctx, initialConfig) {
+  const input = ctx.createGain();
+  const output = ctx.createGain();
+  const sidechainInput = ctx.createGain();
+  const comp = ctx.createDynamicsCompressor();
+  const vcaGain = ctx.createGain();
+  const makeupGainNode = ctx.createGain();
+  const dryGain = ctx.createGain();
+  const wetGain = ctx.createGain();
+  const scAnalyser = ctx.createAnalyser();
+  scAnalyser.fftSize = 256;
+  scAnalyser.smoothingTimeConstant = 0.3;
+  sidechainInput.connect(scAnalyser);
+  let isSidechainActive = false;
+  let duckAmount = 0;
+  let rafId = null;
+  let currentConfig = {
+    threshold: -20,
+    ratio: 4,
+    attack: 0.01,
+    release: 0.15,
+    knee: 5,
+    makeupGain: 0,
+    mix: 1,
+    sidechainEnabled: false,
+    ...initialConfig
+  };
+  input.connect(dryGain);
+  dryGain.connect(output);
+  input.connect(comp);
+  comp.connect(vcaGain);
+  vcaGain.connect(makeupGainNode);
+  makeupGainNode.connect(wetGain);
+  wetGain.connect(output);
+  const applyConfig = (cfg) => {
+    currentConfig = { ...currentConfig, ...cfg };
+    const now = ctx.currentTime;
+    comp.threshold.setValueAtTime(currentConfig.threshold, now);
+    comp.ratio.setValueAtTime(Math.max(1, currentConfig.ratio), now);
+    comp.attack.setValueAtTime(Math.max(1e-3, currentConfig.attack), now);
+    comp.release.setValueAtTime(Math.max(0.01, currentConfig.release), now);
+    comp.knee.setValueAtTime(Math.max(0, currentConfig.knee), now);
+    const makeupLinear = Math.pow(10, (currentConfig.makeupGain || 0) / 20);
+    makeupGainNode.gain.setValueAtTime(makeupLinear, now);
+    const mix = Math.max(0, Math.min(1, currentConfig.mix ?? 1));
+    wetGain.gain.setValueAtTime(mix, now);
+    dryGain.gain.setValueAtTime(1 - mix, now);
+    const prevSidechain = isSidechainActive;
+    isSidechainActive = !!currentConfig.sidechainEnabled;
+    if (isSidechainActive && !prevSidechain) {
+      startSidechainLoop();
+    } else if (!isSidechainActive && prevSidechain) {
+      stopSidechainLoop();
+    }
+  };
+  const pcmBuffer = new Float32Array(scAnalyser.fftSize);
+  let smoothedGain = 1;
+  const processSidechainTick = () => {
+    if (!isSidechainActive) {
+      stopSidechainLoop();
+      return;
+    }
+    scAnalyser.getFloatTimeDomainData(pcmBuffer);
+    let peak = 0;
+    for (let i = 0; i < pcmBuffer.length; i++) {
+      const abs = Math.abs(pcmBuffer[i]);
+      if (abs > peak) peak = abs;
+    }
+    const peakDb = peak > 1e-4 ? 20 * Math.log10(peak) : -100;
+    const threshold = currentConfig.threshold;
+    let targetGain = 1;
+    if (peakDb > threshold) {
+      const overDb = peakDb - threshold;
+      const reductionDb = overDb * (1 - 1 / Math.max(1, currentConfig.ratio));
+      duckAmount = reductionDb;
+      targetGain = Math.max(0.01, Math.pow(10, -reductionDb / 20));
+    } else {
+      duckAmount = 0;
+    }
+    const att = Math.max(5e-3, currentConfig.attack);
+    const rel = Math.max(0.02, currentConfig.release);
+    const coeff = targetGain < smoothedGain ? Math.min(1, 0.05 / att) : Math.min(1, 0.05 / rel);
+    smoothedGain += (targetGain - smoothedGain) * coeff;
+    vcaGain.gain.setValueAtTime(smoothedGain, ctx.currentTime);
+    rafId = requestAnimationFrame(processSidechainTick);
+  };
+  const startSidechainLoop = () => {
+    if (rafId !== null) return;
+    if (typeof window !== "undefined") {
+      rafId = requestAnimationFrame(processSidechainTick);
+    }
+  };
+  const stopSidechainLoop = () => {
+    if (rafId !== null) {
+      cancelAnimationFrame(rafId);
+      rafId = null;
+    }
+    duckAmount = 0;
+    smoothedGain = 1;
+    vcaGain.gain.setValueAtTime(1, ctx.currentTime);
+  };
+  applyConfig(currentConfig);
+  const getReductionDb = () => {
+    if (isSidechainActive) {
+      return duckAmount;
+    }
+    return Math.abs(comp.reduction);
+  };
+  const dispose = () => {
+    if (rafId) cancelAnimationFrame(rafId);
+    try {
+      input.disconnect();
+      dryGain.disconnect();
+      comp.disconnect();
+      vcaGain.disconnect();
+      makeupGainNode.disconnect();
+      wetGain.disconnect();
+      output.disconnect();
+      sidechainInput.disconnect();
+      scAnalyser.disconnect();
+    } catch {
+    }
+  };
+  return {
+    input,
+    output,
+    sidechainInput,
+    compressorNode: comp,
+    updateConfig: applyConfig,
+    getReductionDb,
+    dispose
+  };
+}
+
+// src/engine/audio/dsp/crossoverFilter.ts
+function create3BandCrossover(ctx, initialLowFreq = 150, initialHighFreq = 2500) {
+  const input = ctx.createGain();
+  const sumOutput = ctx.createGain();
+  const lowFilter1 = ctx.createBiquadFilter();
+  lowFilter1.type = "lowpass";
+  lowFilter1.frequency.value = initialLowFreq;
+  lowFilter1.Q.value = 0.707;
+  const lowFilter2 = ctx.createBiquadFilter();
+  lowFilter2.type = "lowpass";
+  lowFilter2.frequency.value = initialLowFreq;
+  lowFilter2.Q.value = 0.707;
+  input.connect(lowFilter1);
+  lowFilter1.connect(lowFilter2);
+  const highFilter1 = ctx.createBiquadFilter();
+  highFilter1.type = "highpass";
+  highFilter1.frequency.value = initialHighFreq;
+  highFilter1.Q.value = 0.707;
+  const highFilter2 = ctx.createBiquadFilter();
+  highFilter2.type = "highpass";
+  highFilter2.frequency.value = initialHighFreq;
+  highFilter2.Q.value = 0.707;
+  input.connect(highFilter1);
+  highFilter1.connect(highFilter2);
+  const midHp = ctx.createBiquadFilter();
+  midHp.type = "highpass";
+  midHp.frequency.value = initialLowFreq;
+  midHp.Q.value = 0.707;
+  const midLp = ctx.createBiquadFilter();
+  midLp.type = "lowpass";
+  midLp.frequency.value = initialHighFreq;
+  midLp.Q.value = 0.707;
+  input.connect(midHp);
+  midHp.connect(midLp);
+  const setFrequencies = (lowFreq, highFreq) => {
+    const lF = Math.max(20, Math.min(highFreq - 50, lowFreq));
+    const hF = Math.max(lF + 50, Math.min(2e4, highFreq));
+    lowFilter1.frequency.setValueAtTime(lF, ctx.currentTime);
+    lowFilter2.frequency.setValueAtTime(lF, ctx.currentTime);
+    midHp.frequency.setValueAtTime(lF, ctx.currentTime);
+    highFilter1.frequency.setValueAtTime(hF, ctx.currentTime);
+    highFilter2.frequency.setValueAtTime(hF, ctx.currentTime);
+    midLp.frequency.setValueAtTime(hF, ctx.currentTime);
+  };
+  const dispose = () => {
+    try {
+      input.disconnect();
+      lowFilter1.disconnect();
+      lowFilter2.disconnect();
+      midHp.disconnect();
+      midLp.disconnect();
+      highFilter1.disconnect();
+      highFilter2.disconnect();
+      sumOutput.disconnect();
+    } catch {
+    }
+  };
+  return {
+    input,
+    lowOutput: lowFilter2,
+    midOutput: midLp,
+    highOutput: highFilter2,
+    sumOutput,
+    setFrequencies,
+    dispose
+  };
+}
+
+// src/engine/audio/dsp/sidechainMultibandCompressor.ts
+function createMultibandCompressor(ctx, initialConfig) {
+  const input = ctx.createGain();
+  const output = ctx.createGain();
+  const sidechainInput = ctx.createGain();
+  const crossover = create3BandCrossover(
+    ctx,
+    initialConfig?.crossoverLow ?? 150,
+    initialConfig?.crossoverHigh ?? 2500
+  );
+  input.connect(crossover.input);
+  const lowComp = createSidechainCompressor(ctx, {
+    threshold: initialConfig?.lowBand?.threshold ?? -20,
+    ratio: initialConfig?.lowBand?.ratio ?? 3,
+    attack: initialConfig?.lowBand?.attack ?? 0.02,
+    release: initialConfig?.lowBand?.release ?? 0.15,
+    knee: initialConfig?.lowBand?.knee ?? 4,
+    makeupGain: initialConfig?.lowBand?.makeupGain ?? 0,
+    mix: 1
+  });
+  const midComp = createSidechainCompressor(ctx, {
+    threshold: initialConfig?.midBand?.threshold ?? -18,
+    ratio: initialConfig?.midBand?.ratio ?? 2.5,
+    attack: initialConfig?.midBand?.attack ?? 0.015,
+    release: initialConfig?.midBand?.release ?? 0.12,
+    knee: initialConfig?.midBand?.knee ?? 4,
+    makeupGain: initialConfig?.midBand?.makeupGain ?? 0,
+    mix: 1
+  });
+  const highComp = createSidechainCompressor(ctx, {
+    threshold: initialConfig?.highBand?.threshold ?? -16,
+    ratio: initialConfig?.highBand?.ratio ?? 2,
+    attack: initialConfig?.highBand?.attack ?? 8e-3,
+    release: initialConfig?.highBand?.release ?? 0.08,
+    knee: initialConfig?.highBand?.knee ?? 4,
+    makeupGain: initialConfig?.highBand?.makeupGain ?? 0,
+    mix: 1
+  });
+  crossover.lowOutput.connect(lowComp.input);
+  crossover.midOutput.connect(midComp.input);
+  crossover.highOutput.connect(highComp.input);
+  const lowGain = ctx.createGain();
+  const midGain = ctx.createGain();
+  const highGain = ctx.createGain();
+  lowComp.output.connect(lowGain);
+  midComp.output.connect(midGain);
+  highComp.output.connect(highGain);
+  const sumNode = ctx.createGain();
+  lowGain.connect(sumNode);
+  midGain.connect(sumNode);
+  highGain.connect(sumNode);
+  const dryGain = ctx.createGain();
+  const wetGain = ctx.createGain();
+  input.connect(dryGain);
+  dryGain.connect(output);
+  sumNode.connect(wetGain);
+  wetGain.connect(output);
+  const lowScGain = ctx.createGain();
+  const midScGain = ctx.createGain();
+  const highScGain = ctx.createGain();
+  sidechainInput.connect(lowScGain);
+  sidechainInput.connect(midScGain);
+  sidechainInput.connect(highScGain);
+  lowScGain.connect(lowComp.sidechainInput);
+  midScGain.connect(midComp.sidechainInput);
+  highScGain.connect(highComp.sidechainInput);
+  const applyConfig = (cfg) => {
+    const now = ctx.currentTime;
+    crossover.setFrequencies(cfg.crossoverLow, cfg.crossoverHigh);
+    const hasSolo = cfg.lowBand.solo || cfg.midBand.solo || cfg.highBand.solo;
+    const lowActive = !cfg.lowBand.muted && (!hasSolo || !!cfg.lowBand.solo);
+    lowGain.gain.setValueAtTime(lowActive ? 1 : 0, now);
+    lowComp.updateConfig({
+      ...cfg.lowBand,
+      knee: cfg.lowBand.knee ?? 4,
+      mix: 1,
+      sidechainEnabled: cfg.sidechainEnabled && (cfg.sidechainBands === "all" || cfg.sidechainBands === "low")
+    });
+    const midActive = !cfg.midBand.muted && (!hasSolo || !!cfg.midBand.solo);
+    midGain.gain.setValueAtTime(midActive ? 1 : 0, now);
+    midComp.updateConfig({
+      ...cfg.midBand,
+      knee: cfg.midBand.knee ?? 4,
+      mix: 1,
+      sidechainEnabled: cfg.sidechainEnabled && (cfg.sidechainBands === "all" || cfg.sidechainBands === "mid")
+    });
+    const highActive = !cfg.highBand.muted && (!hasSolo || !!cfg.highBand.solo);
+    highGain.gain.setValueAtTime(highActive ? 1 : 0, now);
+    highComp.updateConfig({
+      ...cfg.highBand,
+      knee: cfg.highBand.knee ?? 4,
+      mix: 1,
+      sidechainEnabled: cfg.sidechainEnabled && (cfg.sidechainBands === "all" || cfg.sidechainBands === "high")
+    });
+    const mix = Math.max(0, Math.min(1, cfg.mix ?? 1));
+    wetGain.gain.setValueAtTime(mix * (cfg.outputGain ?? 1), now);
+    dryGain.gain.setValueAtTime(1 - mix, now);
+  };
+  if (initialConfig) {
+    applyConfig(initialConfig);
+  }
+  const getReductionDb = () => ({
+    low: lowComp.getReductionDb(),
+    mid: midComp.getReductionDb(),
+    high: highComp.getReductionDb()
+  });
+  const dispose = () => {
+    try {
+      crossover.dispose();
+      lowComp.dispose();
+      midComp.dispose();
+      highComp.dispose();
+      input.disconnect();
+      output.disconnect();
+      sumNode.disconnect();
+      sidechainInput.disconnect();
+    } catch {
+    }
+  };
+  return {
+    input,
+    output,
+    sidechainInput,
+    updateConfig: applyConfig,
+    getReductionDb,
+    dispose
+  };
+}
+
+// src/engine/audio/dsp/effectProcessorManager/effectProcessorManager.ts
+function createAudioEffectProcessor(ctx, effect) {
+  const masterIn = ctx.createGain();
+  const masterOut = ctx.createGain();
+  let sidechainInputNode;
+  let sidechainComp = null;
+  let multibandComp = null;
+  const nodesToClean = [masterIn, masterOut];
+  let eqFilters = [];
+  let limiterComp = null;
+  let limiterCeiling = null;
+  let reverbWetGain = null;
+  let reverbDryGain = null;
+  let delayNode = null;
+  let delayFeedbackGain = null;
+  let delayFilter = null;
+  let delayWetGain = null;
+  let delayDryGain = null;
+  let satShaper = null;
+  let satTone = null;
+  let satOut = null;
+  let gainNode = null;
+  switch (effect.effectType) {
+    case "eq": {
+      const defaultBands = effect.eqConfig?.bands || [
+        { id: "b1", type: "lowshelf", frequency: 100, gain: 0, q: 0.7, enabled: true },
+        { id: "b2", type: "peaking", frequency: 500, gain: 0, q: 1, enabled: true },
+        { id: "b3", type: "peaking", frequency: 2500, gain: 0, q: 1, enabled: true },
+        { id: "b4", type: "highshelf", frequency: 8e3, gain: 0, q: 0.7, enabled: true }
+      ];
+      eqFilters = defaultBands.map((band) => {
+        const f = ctx.createBiquadFilter();
+        f.type = band.type;
+        f.frequency.value = band.frequency;
+        f.gain.value = band.enabled ? band.gain : 0;
+        f.Q.value = band.q;
+        nodesToClean.push(f);
+        return { bandId: band.id, filter: f };
+      });
+      let prev = masterIn;
+      eqFilters.forEach((item) => {
+        prev.connect(item.filter);
+        prev = item.filter;
+      });
+      prev.connect(masterOut);
+      break;
+    }
+    case "compressor": {
+      sidechainComp = createSidechainCompressor(ctx, effect.compressorConfig);
+      sidechainInputNode = sidechainComp.sidechainInput;
+      masterIn.connect(sidechainComp.input);
+      sidechainComp.output.connect(masterOut);
+      break;
+    }
+    case "multiband_compressor": {
+      multibandComp = createMultibandCompressor(ctx, effect.multibandCompressorConfig);
+      sidechainInputNode = multibandComp.sidechainInput;
+      masterIn.connect(multibandComp.input);
+      multibandComp.output.connect(masterOut);
+      break;
+    }
+    case "limiter": {
+      limiterComp = ctx.createDynamicsCompressor();
+      limiterComp.threshold.value = effect.limiterConfig?.threshold ?? -2;
+      limiterComp.knee.value = 0;
+      limiterComp.ratio.value = 20;
+      limiterComp.attack.value = 2e-3;
+      limiterComp.release.value = effect.limiterConfig?.release ?? 0.05;
+      const shaper = ctx.createWaveShaper();
+      shaper.curve = generateSaturationCurve("soft_clip", 1);
+      shaper.oversample = "2x";
+      limiterCeiling = ctx.createGain();
+      const ceilingDb = effect.limiterConfig?.ceiling ?? -0.1;
+      limiterCeiling.gain.value = Math.pow(10, ceilingDb / 20);
+      masterIn.connect(limiterComp);
+      limiterComp.connect(shaper);
+      shaper.connect(limiterCeiling);
+      limiterCeiling.connect(masterOut);
+      nodesToClean.push(limiterComp, shaper, limiterCeiling);
+      break;
+    }
+    case "reverb": {
+      const convolver = ctx.createConvolver();
+      const impulse = generateReverbImpulse(
+        ctx,
+        effect.reverbConfig?.decayTime ?? 2.5,
+        2,
+        effect.reverbConfig?.damping ?? 6e3
+      );
+      convolver.buffer = impulse;
+      reverbWetGain = ctx.createGain();
+      reverbDryGain = ctx.createGain();
+      const wetMix = effect.reverbConfig?.wetMix ?? 0.4;
+      reverbWetGain.gain.value = wetMix;
+      reverbDryGain.gain.value = 1 - wetMix;
+      masterIn.connect(reverbDryGain);
+      reverbDryGain.connect(masterOut);
+      masterIn.connect(convolver);
+      convolver.connect(reverbWetGain);
+      reverbWetGain.connect(masterOut);
+      nodesToClean.push(convolver, reverbWetGain, reverbDryGain);
+      break;
+    }
+    case "delay": {
+      delayNode = ctx.createDelay(5);
+      const delaySec = (effect.delayConfig?.delayBeats ?? 0.5) * 0.5;
+      delayNode.delayTime.value = delaySec;
+      delayFeedbackGain = ctx.createGain();
+      delayFeedbackGain.gain.value = Math.min(0.9, effect.delayConfig?.feedback ?? 0.4);
+      delayFilter = ctx.createBiquadFilter();
+      delayFilter.type = "lowpass";
+      delayFilter.frequency.value = effect.delayConfig?.highCut ?? 6e3;
+      delayWetGain = ctx.createGain();
+      delayDryGain = ctx.createGain();
+      const wetMix = effect.delayConfig?.wetMix ?? 0.5;
+      delayWetGain.gain.value = wetMix;
+      delayDryGain.gain.value = 1 - wetMix;
+      masterIn.connect(delayDryGain);
+      delayDryGain.connect(masterOut);
+      masterIn.connect(delayNode);
+      delayNode.connect(delayFilter);
+      delayFilter.connect(delayFeedbackGain);
+      delayFeedbackGain.connect(delayNode);
+      delayFilter.connect(delayWetGain);
+      delayWetGain.connect(masterOut);
+      nodesToClean.push(delayNode, delayFeedbackGain, delayFilter, delayWetGain, delayDryGain);
+      break;
+    }
+    case "saturation": {
+      satShaper = ctx.createWaveShaper();
+      const satType = effect.saturationConfig?.saturationType || "tape";
+      const drive = effect.saturationConfig?.drive ?? 1.5;
+      satShaper.curve = generateSaturationCurve(satType, drive);
+      satShaper.oversample = "4x";
+      satTone = ctx.createBiquadFilter();
+      satTone.type = "lowpass";
+      satTone.frequency.value = effect.saturationConfig?.tone ?? 8e3;
+      satOut = ctx.createGain();
+      satOut.gain.value = effect.saturationConfig?.outputGain ?? 1;
+      masterIn.connect(satShaper);
+      satShaper.connect(satTone);
+      satTone.connect(satOut);
+      satOut.connect(masterOut);
+      nodesToClean.push(satShaper, satTone, satOut);
+      break;
+    }
+    case "gain":
+    default: {
+      gainNode = ctx.createGain();
+      gainNode.gain.value = effect.gainConfig?.gain ?? 1;
+      masterIn.connect(gainNode);
+      gainNode.connect(masterOut);
+      nodesToClean.push(gainNode);
+      break;
+    }
+  }
+  const updateEffect = (updated) => {
+    if (sidechainComp && updated.compressorConfig) {
+      sidechainComp.updateConfig(updated.compressorConfig);
+    }
+    if (multibandComp && updated.multibandCompressorConfig) {
+      multibandComp.updateConfig(updated.multibandCompressorConfig);
+    }
+    if (updated.eqConfig?.bands && eqFilters.length > 0) {
+      updated.eqConfig.bands.forEach((b) => {
+        const found = eqFilters.find((f) => f.bandId === b.id);
+        if (found) {
+          found.filter.frequency.setValueAtTime(b.frequency, ctx.currentTime);
+          found.filter.gain.setValueAtTime(b.enabled ? b.gain : 0, ctx.currentTime);
+          found.filter.Q.setValueAtTime(b.q, ctx.currentTime);
+        }
+      });
+    }
+    if (limiterComp && updated.limiterConfig) {
+      limiterComp.threshold.setValueAtTime(updated.limiterConfig.threshold ?? -2, ctx.currentTime);
+      limiterComp.release.setValueAtTime(updated.limiterConfig.release ?? 0.05, ctx.currentTime);
+      if (limiterCeiling) {
+        const ceilingDb = updated.limiterConfig.ceiling ?? -0.1;
+        limiterCeiling.gain.setValueAtTime(Math.pow(10, ceilingDb / 20), ctx.currentTime);
+      }
+    }
+    if (updated.reverbConfig && reverbWetGain && reverbDryGain) {
+      const wet = updated.reverbConfig.wetMix ?? 0.4;
+      reverbWetGain.gain.setValueAtTime(wet, ctx.currentTime);
+      reverbDryGain.gain.setValueAtTime(1 - wet, ctx.currentTime);
+    }
+    if (updated.delayConfig && delayNode && delayFeedbackGain && delayFilter && delayWetGain && delayDryGain) {
+      delayNode.delayTime.setValueAtTime((updated.delayConfig.delayBeats ?? 0.5) * 0.5, ctx.currentTime);
+      delayFeedbackGain.gain.setValueAtTime(Math.min(0.9, updated.delayConfig.feedback ?? 0.4), ctx.currentTime);
+      delayFilter.frequency.setValueAtTime(updated.delayConfig.highCut ?? 6e3, ctx.currentTime);
+      const wet = updated.delayConfig.wetMix ?? 0.5;
+      delayWetGain.gain.setValueAtTime(wet, ctx.currentTime);
+      delayDryGain.gain.setValueAtTime(1 - wet, ctx.currentTime);
+    }
+    if (updated.saturationConfig && satShaper && satTone && satOut) {
+      const satType = updated.saturationConfig.saturationType || "tape";
+      const drive = updated.saturationConfig.drive ?? 1.5;
+      satShaper.curve = generateSaturationCurve(satType, drive);
+      satTone.frequency.setValueAtTime(updated.saturationConfig.tone ?? 8e3, ctx.currentTime);
+      satOut.gain.setValueAtTime(updated.saturationConfig.outputGain ?? 1, ctx.currentTime);
+    }
+    if (updated.gainConfig && gainNode) {
+      gainNode.gain.setValueAtTime(updated.gainConfig.gain ?? 1, ctx.currentTime);
+    }
+  };
+  const getReductionDb = () => {
+    if (sidechainComp) return sidechainComp.getReductionDb();
+    if (multibandComp) return multibandComp.getReductionDb();
+    return 0;
+  };
+  const dispose = () => {
+    sidechainComp?.dispose();
+    multibandComp?.dispose();
+    nodesToClean.forEach((n) => {
+      try {
+        n.disconnect();
+      } catch {
+      }
+    });
+  };
+  return {
+    input: masterIn,
+    output: masterOut,
+    sidechainInput: sidechainInputNode,
+    updateEffect,
+    getReductionDb,
+    dispose
+  };
+}
+
+// src/engine/audio/entities/AudioEffects/AudioEffects.ts
+var AudioEffects = class {
+  state = {
+    activeEffectIds: [],
+    processors: /* @__PURE__ */ new Map()
+  };
+  eventListeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(listener);
+    return () => this.off(event, listener);
+  }
+  off(event, listener) {
+    this.eventListeners.get(event)?.delete(listener);
+  }
+  emit(event, payload) {
+    this.eventListeners.get(event)?.forEach((l) => {
+      try {
+        l(payload);
+      } catch (err) {
+        console.error(`[AudioEffects] Error in event listener '${event}':`, err);
+      }
+    });
+  }
+  getOrCreateProcessor(ctx, effect) {
+    let proc = this.state.processors.get(effect.id);
+    if (!proc) {
+      proc = createAudioEffectProcessor(ctx, effect);
+      this.state.processors.set(effect.id, proc);
+      if (!this.state.activeEffectIds.includes(effect.id)) {
+        this.state.activeEffectIds.push(effect.id);
+      }
+      this.emit("processor:created", { effectId: effect.id, effectType: effect.effectType });
+    } else {
+      proc.updateEffect(effect);
+    }
+    return proc;
+  }
+  removeProcessor(effectId) {
+    const proc = this.state.processors.get(effectId);
+    if (proc) {
+      proc.dispose();
+      this.state.processors.delete(effectId);
+      this.state.activeEffectIds = this.state.activeEffectIds.filter((id) => id !== effectId);
+      this.emit("processor:disposed", { effectId });
+    }
+  }
+  getActiveEffectIds() {
+    return [...this.state.activeEffectIds];
+  }
+  getReductionDb(effectId) {
+    const proc = this.state.processors.get(effectId);
+    return proc?.getReductionDb?.() ?? 0;
+  }
+  disposeAll() {
+    this.state.processors.forEach((proc) => proc.dispose());
+    this.state.processors.clear();
+    this.state.activeEffectIds = [];
+  }
+};
+var audioEffectsEntity = new AudioEffects();
+
+// src/engine/audio/synthEngine/synthEngine.ts
+var STORAGE_KEY_AUDIO_CONFIG = "celestial_audio_engine_config";
+var DEFAULT_AUDIO_CONFIG = {
+  sampleRate: 0,
+  bufferSize: 256
+};
+var SynthEngine = class {
+  ctx = null;
+  masterGain = null;
+  delayNode = null;
+  delayFeedback = null;
+  delayGain = null;
+  reverbNode = null;
+  reverbGain = null;
+  analyser = null;
+  analyserL = null;
+  analyserR = null;
+  analyserBuffer = new Uint8Array(256);
+  analyserBufferL = new Uint8Array(256);
+  analyserBufferR = new Uint8Array(256);
+  masterSplitter = null;
+  nodeVisuals = null;
+  isInitialized = false;
+  nodeActiveUntilMap = /* @__PURE__ */ new Map();
+  audioEngineConfig = this.loadAudioConfig();
+  graphNodeMap = /* @__PURE__ */ new Map();
+  loadAudioConfig() {
+    try {
+      const raw = localStorage.getItem(STORAGE_KEY_AUDIO_CONFIG);
+      if (raw) {
+        const parsed = JSON.parse(raw);
+        return {
+          sampleRate: typeof parsed.sampleRate === "number" ? parsed.sampleRate : DEFAULT_AUDIO_CONFIG.sampleRate,
+          bufferSize: typeof parsed.bufferSize === "number" ? parsed.bufferSize : DEFAULT_AUDIO_CONFIG.bufferSize
+        };
+      }
+    } catch (e) {
+      console.warn("Failed to load audio engine config:", e);
+    }
+    return { ...DEFAULT_AUDIO_CONFIG };
+  }
+  getAudioEngineConfig() {
+    return { ...this.audioEngineConfig };
+  }
+  async updateAudioSettings(newConfig) {
+    this.audioEngineConfig = { ...this.audioEngineConfig, ...newConfig };
+    try {
+      localStorage.setItem(STORAGE_KEY_AUDIO_CONFIG, JSON.stringify(this.audioEngineConfig));
+    } catch (e) {
+    }
+    await this.reinitContext();
+  }
+  async reinitContext() {
+    if (this.ctx) {
+      try {
+        await this.ctx.close();
+      } catch (e) {
+      }
+      this.ctx = null;
+      this.isInitialized = false;
+    }
+    this.init(true);
+    try {
+      const { audioInputManager: audioInputManager2 } = await import("./audioInputManager-BLDGGLAR.js");
+      await audioInputManager2.reconnectStream();
+    } catch (e) {
+    }
+  }
+  activeNodes = [];
+  activeConnections = [];
+  lastPlayedMidiNote = null;
+  updateActiveGraph(nodes, connections) {
+    this.activeNodes = nodes;
+    this.activeConnections = connections;
+    this.graphNodeMap.clear();
+    nodes.forEach((node) => {
+      this.graphNodeMap.set(node.id, createAudioGraphNode(node));
+    });
+    const currentEffectIds = new Set(nodes.filter((n) => n.type === "effect").map((n) => n.id));
+    for (const effId of audioEffectsEntity.getActiveEffectIds()) {
+      if (!currentEffectIds.has(effId)) {
+        audioEffectsEntity.removeProcessor(effId);
+      }
+    }
+  }
+  /**
+   * Evaluates reachability from a given nodeId to an active, unmuted AudioOutputNode.
+   * Traverses activeConnections, effect/routing chains, and module boundaries.
+   */
+  checkGraphReachabilityToOutput(nodeId) {
+    const startNode = this.activeNodes.find((n) => n.id === nodeId);
+    if (!startNode || startNode.active === false) return false;
+    if (startNode.id === "output-strip-node" || startNode.type === "output_strip") {
+      return true;
+    }
+    const outputStripNode = this.activeNodes.find(
+      (n) => (n.id === "output-strip-node" || n.type === "output_strip") && n.active !== false
+    );
+    if (!outputStripNode) return false;
+    const visited = /* @__PURE__ */ new Set([nodeId]);
+    const queue = [nodeId];
+    while (queue.length > 0) {
+      const currentId = queue.shift();
+      for (const conn of this.activeConnections) {
+        if (conn.fromNodeId === currentId) {
+          const nextId = conn.toNodeId;
+          if (nextId === outputStripNode.id) {
+            return true;
+          }
+          const nextNode = this.activeNodes.find((n) => n.id === nextId);
+          if (nextNode && nextNode.active !== false && !visited.has(nextId)) {
+            if (nextNode.id === "output-strip-node" || nextNode.type === "output_strip") {
+              return true;
+            }
+            visited.add(nextId);
+            queue.push(nextId);
+          }
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Authority Check:
+   * Queries the BaseAudioGraphNode instance. Structural rule enforces that no node
+   * is allowed to emit sound to master unless authorized via an active connection to AudioOutputNode.
+   */
+  isNodeConnectedToOutput(nodeId) {
+    let graphNode = this.graphNodeMap.get(nodeId);
+    if (!graphNode) {
+      const spaceNode = this.activeNodes.find((n) => n.id === nodeId);
+      if (spaceNode) {
+        graphNode = createAudioGraphNode(spaceNode);
+        this.graphNodeMap.set(nodeId, graphNode);
+      }
+    }
+    if (!graphNode) return false;
+    return graphNode.isAuthorizedToEmit((id) => this.checkGraphReachabilityToOutput(id));
+  }
+  init(forceRecreate = false) {
+    if (!forceRecreate && this.isInitialized && this.ctx) {
+      if (this.ctx.state === "suspended") this.ctx.resume();
+      return;
+    }
+    const AudioCtx = window.AudioContext || window.webkitAudioContext;
+    const options = {};
+    if (typeof this.audioEngineConfig.sampleRate === "number" && isFinite(this.audioEngineConfig.sampleRate) && this.audioEngineConfig.sampleRate > 0) {
+      options.sampleRate = this.audioEngineConfig.sampleRate;
+    }
+    if (typeof this.audioEngineConfig.bufferSize === "number" && isFinite(this.audioEngineConfig.bufferSize) && this.audioEngineConfig.bufferSize > 0) {
+      const targetRate = typeof this.audioEngineConfig.sampleRate === "number" && isFinite(this.audioEngineConfig.sampleRate) && this.audioEngineConfig.sampleRate > 0 ? this.audioEngineConfig.sampleRate : 44100;
+      const hint = this.audioEngineConfig.bufferSize / targetRate;
+      if (typeof hint === "number" && isFinite(hint) && hint > 0) {
+        options.latencyHint = hint;
+      }
+    }
+    try {
+      this.ctx = new AudioCtx(options);
+    } catch (err) {
+      console.warn("Could not instantiate AudioContext with custom options, falling back to defaults:", err);
+      this.ctx = new AudioCtx();
+    }
+    this.masterGain = this.ctx.createGain();
+    const curTime = isFinite(this.ctx.currentTime) ? this.ctx.currentTime : 0;
+    this.masterGain.gain.setValueAtTime(0.8, curTime);
+    this.analyser = this.ctx.createAnalyser();
+    this.analyser.fftSize = 256;
+    this.masterSplitter = this.ctx.createChannelSplitter(2);
+    this.analyserL = this.ctx.createAnalyser();
+    this.analyserL.fftSize = 256;
+    this.analyserR = this.ctx.createAnalyser();
+    this.analyserR.fftSize = 256;
+    this.delayNode = this.ctx.createDelay();
+    this.delayNode.delayTime.value = 0.35;
+    this.delayFeedback = this.ctx.createGain();
+    this.delayFeedback.gain.value = 0.45;
+    this.delayGain = this.ctx.createGain();
+    this.delayGain.gain.value = 0.3;
+    this.delayNode.connect(this.delayFeedback);
+    this.delayFeedback.connect(this.delayNode);
+    this.delayNode.connect(this.delayGain);
+    this.delayGain.connect(this.masterGain);
+    this.reverbNode = this.ctx.createConvolver();
+    this.reverbNode.buffer = createCosmicImpulseBuffer(this.ctx, 2.5, 2);
+    this.reverbGain = this.ctx.createGain();
+    this.reverbGain.gain.value = 0.35;
+    this.reverbNode.connect(this.reverbGain);
+    this.reverbGain.connect(this.masterGain);
+    this.masterGain.connect(this.analyser);
+    this.masterGain.connect(this.masterSplitter);
+    this.masterSplitter.connect(this.analyserL, 0);
+    this.masterSplitter.connect(this.analyserR, 1);
+    multiChannelOutputRouter.init(this.ctx, 6);
+    multiChannelOutputRouter.connectInput(this.masterGain);
+    this.isInitialized = true;
+  }
+  playAuditionTestPulse() {
+    this.init();
+    if (!this.ctx || !this.masterGain) return;
+    const now = this.ctx.currentTime;
+    const osc = this.ctx.createOscillator();
+    const gain = this.ctx.createGain();
+    osc.type = "sine";
+    osc.frequency.setValueAtTime(440, now);
+    osc.frequency.exponentialRampToValueAtTime(880, now + 0.15);
+    gain.gain.setValueAtTime(1e-3, now);
+    gain.gain.exponentialRampToValueAtTime(0.3, now + 0.02);
+    gain.gain.exponentialRampToValueAtTime(1e-3, now + 0.25);
+    osc.connect(gain);
+    gain.connect(this.masterGain);
+    osc.start(now);
+    osc.stop(now + 0.26);
+  }
+  getAudioLevel() {
+    if (!this.analyser) return 0;
+    const binCount = this.analyser.frequencyBinCount || 128;
+    if (this.analyserBuffer.length !== binCount) {
+      this.analyserBuffer = new Uint8Array(binCount);
+    }
+    const data = this.analyserBuffer;
+    this.analyser.getByteFrequencyData(data);
+    let sum = 0;
+    let max = 0;
+    for (let i = 0; i < data.length; i++) {
+      sum += data[i];
+      if (data[i] > max) max = data[i];
+    }
+    const avg = sum / data.length;
+    const peak = max / 255;
+    const norm = avg / 128 * 0.4 + peak * 0.6;
+    return Math.min(1, Math.max(0, norm));
+  }
+  getStereoLevels() {
+    if (!this.analyserL || !this.analyserR) {
+      if (this.analyser) {
+        const lvl = this.getAudioLevel();
+        return { left: lvl, right: lvl };
+      }
+      return { left: 0, right: 0 };
+    }
+    const binCountL = this.analyserL.frequencyBinCount || 128;
+    const binCountR = this.analyserR.frequencyBinCount || 128;
+    if (this.analyserBufferL.length !== binCountL) {
+      this.analyserBufferL = new Uint8Array(binCountL);
+    }
+    if (this.analyserBufferR.length !== binCountR) {
+      this.analyserBufferR = new Uint8Array(binCountR);
+    }
+    const dataL = this.analyserBufferL;
+    const dataR = this.analyserBufferR;
+    this.analyserL.getByteFrequencyData(dataL);
+    this.analyserR.getByteFrequencyData(dataR);
+    let sumL = 0;
+    let maxL = 0;
+    for (let i = 0; i < dataL.length; i++) {
+      sumL += dataL[i];
+      if (dataL[i] > maxL) maxL = dataL[i];
+    }
+    const avgL = sumL / dataL.length;
+    let sumR = 0;
+    let maxR = 0;
+    for (let i = 0; i < dataR.length; i++) {
+      sumR += dataR[i];
+      if (dataR[i] > maxR) maxR = dataR[i];
+    }
+    const avgR = sumR / dataR.length;
+    if (maxL < 2 && avgL < 0.5 && maxR < 2 && avgR < 0.5) {
+      return { left: 0, right: 0 };
+    }
+    const peakL = maxL / 255;
+    const peakR = maxR / 255;
+    const normAvgL = avgL / 128;
+    const normAvgR = avgR / 128;
+    const leftVal = normAvgL * 0.35 + peakL * 0.65;
+    const rightVal = normAvgR * 0.35 + peakR * 0.65;
+    return {
+      left: leftVal > 0.01 ? Math.min(1, leftVal) : 0,
+      right: rightVal > 0.01 ? Math.min(1, rightVal) : 0
+    };
+  }
+  isNodeActive(nodeId) {
+    if (!this.ctx) return false;
+    const until = this.nodeActiveUntilMap.get(nodeId) || 0;
+    return this.ctx.currentTime < until;
+  }
+  markNodeActive(nodeId, durationSec = 0.5) {
+    if (!this.ctx) this.init();
+    const now = this.ctx?.currentTime || performance.now() / 1e3;
+    this.nodeActiveUntilMap.set(nodeId, now + durationSec);
+  }
+  audioInputLevelProvider = null;
+  registerAudioInputLevelProvider(provider) {
+    this.audioInputLevelProvider = provider;
+  }
+  getWireSignalLevel(sourceNode, fromPort) {
+    if (!sourceNode) return { left: 0, right: 0 };
+    if (sourceNode.id === "input-strip-node" || sourceNode.type === "input_strip") {
+      const inputs = sourceNode.mapIoConfig?.inputs || [];
+      const matchedChannel = inputs.find(
+        (c) => fromPort ? fromPort === `out-${c.id}` || fromPort === c.id : c.type === "audio"
+      );
+      const busId = matchedChannel?.sourceId || "bus-in-1";
+      const lvl = this.audioInputLevelProvider ? this.audioInputLevelProvider(busId) : audioInputManager.getInputLevel(busId);
+      return { left: lvl, right: matchedChannel?.audioFormat === "mono" ? 0 : lvl };
+    }
+    if (sourceNode.type === "output_strip") {
+      return this.getStereoLevels();
+    }
+    if (this.isNodeActive(sourceNode.id)) {
+      return this.getStereoLevels();
+    }
+    return { left: 0, right: 0 };
+  }
+  setOutputRouting(routingId) {
+    this.init();
+    multiChannelOutputRouter.applyRouting(routingId);
+  }
+  async setOutputDevice(deviceId) {
+    this.init();
+    return multiChannelOutputRouter.setOutputSinkId(deviceId);
+  }
+  setMasterVolume(vol) {
+    if (this.masterGain && this.ctx) {
+      const safeVol = typeof vol === "number" && isFinite(vol) ? Math.max(0, Math.min(1, vol)) : 0.8;
+      const safeTime = isFinite(this.ctx.currentTime) ? this.ctx.currentTime : 0;
+      this.masterGain.gain.setValueAtTime(safeVol, safeTime);
+    }
+  }
+  getContext() {
+    this.init();
+    if (this.ctx?.state === "suspended") {
+      this.ctx.resume().catch(() => {
+      });
+    }
+    return this.ctx;
+  }
+  getMasterNode() {
+    this.init();
+    return this.masterGain;
+  }
+  getGainAndPanForNode(nodeId) {
+    let volumeScale = 1;
+    let panOffset = 0;
+    const effectIds = [];
+    const container = this.activeNodes.find((n) => n.id === nodeId);
+    if (!container) return { volumeScale, panOffset, effectIds };
+    const activeEffects = getActiveEffectsForNode(container, this.activeNodes, this.activeConnections);
+    const gainEffects = activeEffects.filter((e) => e.effectType === "gain" && e.active !== false);
+    for (const eff of gainEffects) {
+      if (eff.gainConfig?.gain !== void 0) {
+        volumeScale *= eff.gainConfig.gain;
+        effectIds.push(eff.id);
+      }
+    }
+    const panEffects = activeEffects.filter((e) => e.effectType === "pan" && e.active !== false);
+    for (const eff of panEffects) {
+      if (eff.panConfig?.pan !== void 0) {
+        panOffset += eff.panConfig.pan;
+        effectIds.push(eff.id);
+      }
+    }
+    panOffset = Math.max(-1, Math.min(1, panOffset));
+    return { volumeScale, panOffset, effectIds };
+  }
+  /**
+   * Chains audio through all active DSP effect nodes (EQ, Compressor, Multiband, Limiter, Reverb, Delay, Saturation)
+   * and fans out to any compressors/multiband compressors that have sidechain active with this node as source.
+   */
+  routeAudioThroughNodeEffects(audioNode, nodeId) {
+    if (!this.ctx || !nodeId) return audioNode;
+    const container = this.activeNodes.find((n) => n.id === nodeId);
+    if (!container) return audioNode;
+    const activeEffects = getActiveEffectsForNode(container, this.activeNodes, this.activeConnections);
+    const dspEffects = activeEffects.filter(
+      (e) => e.active !== false && ["eq", "compressor", "multiband_compressor", "limiter", "reverb", "delay", "saturation"].includes(
+        e.effectType
+      )
+    );
+    let currentOut = audioNode;
+    for (const eff of dspEffects) {
+      const proc = audioEffectsEntity.getOrCreateProcessor(this.ctx, eff);
+      currentOut.connect(proc.input);
+      currentOut = proc.output;
+      this.nodeVisuals?.triggerNodeFlash(eff.id);
+    }
+    for (const node of this.activeNodes) {
+      if (node.type === "effect") {
+        const eff = node;
+        if ((eff.effectType === "compressor" || eff.effectType === "multiband_compressor") && eff.active !== false) {
+          const hasSidechainWire = this.activeConnections.some(
+            (c) => c.fromNodeId === nodeId && c.toNodeId === eff.id && (c.toPort === "sidechain_in" || c.toSocketIndex === 1)
+          );
+          const hasConfigMatch = eff.compressorConfig?.sidechainEnabled && eff.compressorConfig?.sidechainSourceId === nodeId || eff.multibandCompressorConfig?.sidechainEnabled && eff.multibandCompressorConfig?.sidechainSourceId === nodeId;
+          if (hasSidechainWire || hasConfigMatch) {
+            const proc = audioEffectsEntity.getOrCreateProcessor(this.ctx, eff);
+            if (proc.sidechainInput) {
+              audioNode.connect(proc.sidechainInput);
+            }
+          }
+        }
+      }
+    }
+    return currentOut;
+  }
+  playNote(note, preset, startTimeOffset = 0, containerId) {
+    this.init();
+    if (!this.ctx || !this.masterGain) return;
+    if (!containerId || !this.isNodeConnectedToOutput(containerId)) return;
+    this.lastPlayedMidiNote = { note: note.note, velocity: note.velocity, timestamp: Date.now() };
+    const triggeredNode = containerId ? this.activeNodes.find((n) => n.id === containerId) : void 0;
+    if (triggeredNode && triggeredNode.type === "sampler") {
+      this.playSamplerNote(note, triggeredNode, startTimeOffset);
+      return;
+    }
+    const container = triggeredNode && triggeredNode.type === "container" ? triggeredNode : void 0;
+    if (container && container.containerType === "instrument") {
+      this.playInstrumentNote(note, container, startTimeOffset);
+      return;
+    }
+    const now = this.ctx.currentTime + startTimeOffset;
+    const freq = midiToFreq(note.note);
+    const duration = Math.max(0.05, note.duration * 0.45);
+    const att = Math.max(5e-3, preset.attack || 0.02);
+    const dec = Math.max(0.05, preset.decay || 0.2);
+    const sus = Math.max(0.01, preset.sustain || 0.5);
+    const rel = Math.max(0.05, preset.release || 0.5);
+    let volumeScale = 1;
+    let panOffset = 0;
+    if (containerId) {
+      this.markNodeActive(containerId, duration + rel + 0.1);
+      const recordEvent = this.nodeVisuals?.recordSocketSignalEvent;
+      if (typeof recordEvent === "function") {
+        recordEvent(containerId, "in_midi", { velocity: note.velocity, note: note.note });
+        recordEvent(containerId, "out-audio", { velocity: note.velocity, note: note.note });
+        recordEvent(containerId, "midi", { velocity: note.velocity, note: note.note });
+        recordEvent(containerId, "audio", { velocity: note.velocity, note: note.note });
+      }
+      const g = this.getGainAndPanForNode(containerId);
+      volumeScale = g.volumeScale;
+      panOffset = g.panOffset;
+      g.effectIds.forEach((id) => this.nodeVisuals?.triggerNodeFlash(id));
+    }
+    if (preset.synthType === "drums") {
+      playSyntheticDrumVoice(this.ctx, this.masterGain, note.note, note.velocity * volumeScale, now);
+      return;
+    }
+    const osc1 = this.ctx.createOscillator();
+    const osc2 = this.ctx.createOscillator();
+    const filter = this.ctx.createBiquadFilter();
+    const voiceGain = this.ctx.createGain();
+    const isPlucked = preset.synthType === "plucked";
+    const isBass = preset.synthType === "bass";
+    const isPad = preset.synthType === "pad";
+    osc1.type = isBass ? "triangle" : isPad ? "sine" : isPlucked ? "triangle" : "sawtooth";
+    osc2.type = isBass ? "sine" : isPad ? "triangle" : "square";
+    osc1.frequency.setValueAtTime(freq, now);
+    osc2.frequency.setValueAtTime(freq * 1.004, now);
+    filter.type = "lowpass";
+    filter.frequency.setValueAtTime(preset.cutoff || 2e3, now);
+    filter.Q.setValueAtTime(preset.resonance || 2, now);
+    const peakGain = note.velocity * 0.4 * volumeScale;
+    voiceGain.gain.setValueAtTime(1e-4, now);
+    voiceGain.gain.exponentialRampToValueAtTime(peakGain, now + att);
+    voiceGain.gain.exponentialRampToValueAtTime(peakGain * sus, now + att + dec);
+    voiceGain.gain.setValueAtTime(peakGain * sus, now + duration);
+    voiceGain.gain.exponentialRampToValueAtTime(1e-4, now + duration + rel);
+    osc1.connect(filter);
+    osc2.connect(filter);
+    filter.connect(voiceGain);
+    const routedVoice = this.routeAudioThroughNodeEffects(voiceGain, containerId);
+    if (panOffset !== 0 && this.ctx.createStereoPanner) {
+      const panner = this.ctx.createStereoPanner();
+      panner.pan.setValueAtTime(Math.max(-1, Math.min(1, panOffset)), now);
+      routedVoice.connect(panner);
+      panner.connect(this.masterGain);
+    } else {
+      routedVoice.connect(this.masterGain);
+    }
+    if (this.delayNode && preset.delay > 0.05) {
+      const sendGain = this.ctx.createGain();
+      sendGain.gain.value = preset.delay * 0.7;
+      voiceGain.connect(sendGain);
+      sendGain.connect(this.delayNode);
+    }
+    if (this.reverbNode && preset.reverb > 0.05) {
+      const revSend = this.ctx.createGain();
+      revSend.gain.value = preset.reverb * 0.8;
+      voiceGain.connect(revSend);
+      revSend.connect(this.reverbNode);
+    }
+    osc1.start(now);
+    osc2.start(now);
+    const stopTime = now + duration + rel + 0.1;
+    osc1.stop(stopTime);
+    osc2.stop(stopTime);
+  }
+  async playSamplerNote(note, container, startTimeOffset = 0) {
+    if (!this.ctx || !this.masterGain) return;
+    if (!this.isNodeConnectedToOutput(container.id)) return;
+    const compConns = this.activeConnections.filter(
+      (c) => c.toNodeId === container.id && (c.toPort === "component_in" || c.toPort === "store_in" || c.signalType === "audio_packet" || c.signalType === "component" || c.toSocketIndex === 0 || c.toSocketIndex === 2)
+    );
+    const connectedContainers = compConns.map((c) => this.activeNodes.find((n) => n.id === c.fromNodeId && n.type === "container" && n.containerType === "audio")).filter((n) => !!n);
+    if (connectedContainers.length === 0) return;
+    let targetTrack = void 0;
+    let centerNote = 60;
+    const zones = container.sampleZones || [];
+    const matchingZone = zones.find(
+      (z) => note.note >= z.minNote && note.note <= z.maxNote
+    );
+    if (matchingZone) {
+      const matchingContainer = connectedContainers.find((c) => c.id === matchingZone.containerId);
+      if (matchingContainer && matchingContainer.audioTrack) {
+        targetTrack = matchingContainer.audioTrack;
+        centerNote = matchingZone.centerNote ?? 60;
+      } else if (matchingZone.sampleType) {
+        targetTrack = {
+          id: matchingZone.id,
+          name: matchingZone.sampleName,
+          sampleType: matchingZone.sampleType,
+          durationBeats: 1,
+          gain: 1,
+          pan: 0,
+          pitchShift: 0,
+          filterCutoff: 2e4,
+          fadeInBeats: 0,
+          fadeOutBeats: 0,
+          trimStartBeats: 0,
+          trimEndBeats: 1,
+          isReversed: false
+        };
+        centerNote = matchingZone.centerNote ?? 60;
+      }
+    } else {
+      const fallbackContainer = connectedContainers[0];
+      if (fallbackContainer && fallbackContainer.audioTrack) {
+        targetTrack = fallbackContainer.audioTrack;
+        centerNote = 60;
+      }
+    }
+    if (!targetTrack) return;
+    try {
+      const { audioClipEngine } = await import("./audioClipEngine-BOT33JKI.js");
+      const buffer = await audioClipEngine.getOrLoadBuffer(
+        targetTrack.sampleType,
+        targetTrack.customAudioUrl
+      );
+      if (!buffer) return;
+      const now = this.ctx.currentTime + startTimeOffset;
+      const source = this.ctx.createBufferSource();
+      source.buffer = buffer;
+      const startOffsetSec = Math.max(0, Math.min(buffer.duration, matchingZone?.startTime ?? 0));
+      const endOffsetSec = Math.max(startOffsetSec + 0.01, Math.min(buffer.duration, matchingZone?.endTime ?? buffer.duration));
+      const sampleDurationSec = endOffsetSec - startOffsetSec;
+      const semitonesFromCenter = note.note - centerNote;
+      const rate = Math.pow(2, semitonesFromCenter / 12);
+      source.playbackRate.setValueAtTime(Math.max(0.05, Math.min(8, rate)), now);
+      const playbackDurationSec = sampleDurationSec / rate;
+      const noteCutoffSec = Math.min(playbackDurationSec, Math.max(0.1, (note.duration || 0.5) * 0.6));
+      const { volumeScale, panOffset, effectIds } = this.getGainAndPanForNode(container.id);
+      this.markNodeActive(container.id, noteCutoffSec + 0.1);
+      effectIds.forEach((id) => this.nodeVisuals?.triggerNodeFlash(id));
+      const voiceGain = this.ctx.createGain();
+      const peakGain = (note.velocity || 0.85) * (targetTrack.gain || 1) * volumeScale * 0.75;
+      voiceGain.gain.setValueAtTime(1e-3, now);
+      voiceGain.gain.exponentialRampToValueAtTime(Math.max(1e-3, peakGain), now + 5e-3);
+      voiceGain.gain.setValueAtTime(peakGain, now + Math.max(0.01, noteCutoffSec - 0.02));
+      voiceGain.gain.exponentialRampToValueAtTime(1e-3, now + noteCutoffSec);
+      source.connect(voiceGain);
+      const routedSampler = this.routeAudioThroughNodeEffects(voiceGain, container.id);
+      if (panOffset !== 0 && this.ctx.createStereoPanner) {
+        const panner = this.ctx.createStereoPanner();
+        panner.pan.setValueAtTime(Math.max(-1, Math.min(1, panOffset)), now);
+        routedSampler.connect(panner);
+        panner.connect(this.masterGain);
+      } else {
+        routedSampler.connect(this.masterGain);
+      }
+      source.start(now, startOffsetSec, sampleDurationSec);
+      source.stop(now + noteCutoffSec);
+      if (typeof window !== "undefined") {
+        const event = new CustomEvent("sampler-note-triggered", {
+          detail: {
+            containerId: container.id,
+            note: note.note,
+            velocity: note.velocity || 0.85,
+            duration: noteCutoffSec,
+            // real playback time in seconds
+            startTime: startOffsetSec,
+            endTime: endOffsetSec,
+            playbackRate: rate
+          }
+        });
+        window.dispatchEvent(event);
+      }
+    } catch (err) {
+      console.warn("Sampler playback failed:", err);
+    }
+  }
+  playInstrumentNote(note, container, startTimeOffset = 0) {
+    if (!this.ctx || !this.masterGain) return;
+    if (!this.isNodeConnectedToOutput(container.id)) return;
+    const now = this.ctx.currentTime + startTimeOffset;
+    const freq = midiToFreq(note.note);
+    const duration = Math.max(0.1, note.duration * 0.55);
+    const velocity = note.velocity || 0.85;
+    const pluginId = container.selectedPluginId || "grand_piano";
+    const { volumeScale, panOffset, effectIds } = this.getGainAndPanForNode(container.id);
+    this.markNodeActive(container.id, duration + 0.3);
+    effectIds.forEach((id) => this.nodeVisuals?.triggerNodeFlash(id));
+    const volumeCoeff = (container.volume !== void 0 ? container.volume : 1) * volumeScale;
+    const connectToOutput = (vGainNode) => {
+      const routedInstr = this.routeAudioThroughNodeEffects(vGainNode, container.id);
+      if (panOffset !== 0 && this.ctx?.createStereoPanner) {
+        const panner = this.ctx.createStereoPanner();
+        panner.pan.setValueAtTime(Math.max(-1, Math.min(1, panOffset)), now);
+        routedInstr.connect(panner);
+        panner.connect(this.masterGain);
+      } else {
+        routedInstr.connect(this.masterGain);
+      }
+    };
+    if (pluginId === "grand_piano") {
+      const carrier = this.ctx.createOscillator();
+      const overtone1 = this.ctx.createOscillator();
+      const overtone2 = this.ctx.createOscillator();
+      const vGain = this.ctx.createGain();
+      carrier.type = "triangle";
+      overtone1.type = "sine";
+      overtone2.type = "sine";
+      carrier.frequency.setValueAtTime(freq, now);
+      overtone1.frequency.setValueAtTime(freq * 2, now);
+      overtone2.frequency.setValueAtTime(freq * 3, now);
+      const peak = velocity * volumeCoeff * 0.45;
+      vGain.gain.setValueAtTime(1e-3, now);
+      vGain.gain.linearRampToValueAtTime(peak, now + 4e-3);
+      vGain.gain.exponentialRampToValueAtTime(peak * 0.4, now + 0.12);
+      vGain.gain.exponentialRampToValueAtTime(peak * 0.05, now + duration);
+      vGain.gain.exponentialRampToValueAtTime(1e-4, now + duration + 0.2);
+      carrier.connect(vGain);
+      overtone1.connect(vGain);
+      overtone2.connect(vGain);
+      connectToOutput(vGain);
+      if (this.reverbNode) {
+        const pianoHall = this.ctx.createGain();
+        pianoHall.gain.value = 0.5;
+        vGain.connect(pianoHall);
+        pianoHall.connect(this.reverbNode);
+      }
+      carrier.start(now);
+      overtone1.start(now);
+      overtone2.start(now);
+      carrier.stop(now + duration + 0.25);
+      overtone1.stop(now + duration + 0.25);
+      overtone2.stop(now + duration + 0.25);
+    } else if (pluginId === "juno_pad") {
+      const osc1 = this.ctx.createOscillator();
+      const osc2 = this.ctx.createOscillator();
+      const lfo = this.ctx.createOscillator();
+      const lfoGain = this.ctx.createGain();
+      const filter = this.ctx.createBiquadFilter();
+      const vGain = this.ctx.createGain();
+      osc1.type = "sawtooth";
+      osc2.type = "sawtooth";
+      lfo.type = "sine";
+      osc1.frequency.setValueAtTime(freq * 0.996, now);
+      osc2.frequency.setValueAtTime(freq * 1.004, now);
+      lfo.frequency.setValueAtTime(4.8, now);
+      lfoGain.gain.setValueAtTime(1.8, now);
+      filter.type = "lowpass";
+      filter.frequency.setValueAtTime(200, now);
+      filter.frequency.exponentialRampToValueAtTime(1800, now + 0.8);
+      filter.frequency.exponentialRampToValueAtTime(1200, now + duration);
+      filter.Q.setValueAtTime(4, now);
+      const peak = velocity * volumeCoeff * 0.25;
+      vGain.gain.setValueAtTime(1e-3, now);
+      vGain.gain.linearRampToValueAtTime(peak, now + 0.4);
+      vGain.gain.setValueAtTime(peak, now + duration);
+      vGain.gain.exponentialRampToValueAtTime(1e-3, now + duration + 1.2);
+      lfo.connect(lfoGain);
+      lfoGain.connect(osc1.frequency);
+      lfoGain.connect(osc2.frequency);
+      osc1.connect(filter);
+      osc2.connect(filter);
+      filter.connect(vGain);
+      connectToOutput(vGain);
+      if (this.reverbNode) {
+        const revSend = this.ctx.createGain();
+        revSend.gain.value = 0.65;
+        vGain.connect(revSend);
+        revSend.connect(this.reverbNode);
+      }
+      if (this.delayNode) {
+        const delSend = this.ctx.createGain();
+        delSend.gain.value = 0.45;
+        vGain.connect(delSend);
+        delSend.connect(this.delayNode);
+      }
+      lfo.start(now);
+      osc1.start(now);
+      osc2.start(now);
+      lfo.stop(now + duration + 1.3);
+      osc1.stop(now + duration + 1.3);
+      osc2.stop(now + duration + 1.3);
+    } else if (pluginId === "moog_bass") {
+      const osc1 = this.ctx.createOscillator();
+      const osc2 = this.ctx.createOscillator();
+      const subOsc = this.ctx.createOscillator();
+      const filter = this.ctx.createBiquadFilter();
+      const vGain = this.ctx.createGain();
+      osc1.type = "sawtooth";
+      osc2.type = "sawtooth";
+      subOsc.type = "square";
+      osc1.frequency.setValueAtTime(freq * 0.991, now);
+      osc2.frequency.setValueAtTime(freq * 1.009, now);
+      subOsc.frequency.setValueAtTime(freq * 0.5, now);
+      filter.type = "lowpass";
+      filter.frequency.setValueAtTime(2800, now);
+      filter.frequency.exponentialRampToValueAtTime(250, now + 0.14);
+      filter.Q.setValueAtTime(6, now);
+      const peak = velocity * volumeCoeff * 0.38;
+      vGain.gain.setValueAtTime(1e-3, now);
+      vGain.gain.linearRampToValueAtTime(peak, now + 5e-3);
+      vGain.gain.exponentialRampToValueAtTime(peak * 0.6, now + 0.15);
+      vGain.gain.setValueAtTime(peak * 0.6, now + duration);
+      vGain.gain.exponentialRampToValueAtTime(1e-3, now + duration + 0.1);
+      osc1.connect(filter);
+      osc2.connect(filter);
+      subOsc.connect(filter);
+      filter.connect(vGain);
+      connectToOutput(vGain);
+      osc1.start(now);
+      osc2.start(now);
+      subOsc.start(now);
+      osc1.stop(now + duration + 0.15);
+      osc2.stop(now + duration + 0.15);
+      subOsc.stop(now + duration + 0.15);
+    } else if (pluginId === "dx7_tines") {
+      const carrier = this.ctx.createOscillator();
+      const modulator = this.ctx.createOscillator();
+      const modGain = this.ctx.createGain();
+      const vGain = this.ctx.createGain();
+      carrier.type = "sine";
+      modulator.type = "sine";
+      carrier.frequency.setValueAtTime(freq, now);
+      modulator.frequency.setValueAtTime(freq * 5, now);
+      modGain.gain.setValueAtTime(2500, now);
+      modGain.gain.exponentialRampToValueAtTime(10, now + 0.08);
+      const peak = velocity * volumeCoeff * 0.45;
+      vGain.gain.setValueAtTime(1e-3, now);
+      vGain.gain.linearRampToValueAtTime(peak, now + 6e-3);
+      vGain.gain.exponentialRampToValueAtTime(peak * 0.2, now + 0.6);
+      vGain.gain.exponentialRampToValueAtTime(1e-3, now + duration + 0.15);
+      modulator.connect(modGain);
+      modGain.connect(carrier.frequency);
+      carrier.connect(vGain);
+      connectToOutput(vGain);
+      if (this.reverbNode) {
+        const revSend = this.ctx.createGain();
+        revSend.gain.value = 0.45;
+        vGain.connect(revSend);
+        revSend.connect(this.reverbNode);
+      }
+      modulator.start(now);
+      carrier.start(now);
+      modulator.stop(now + duration + 0.2);
+      carrier.stop(now + duration + 0.2);
+    } else if (pluginId === "orchestral_strings") {
+      const osc1 = this.ctx.createOscillator();
+      const osc2 = this.ctx.createOscillator();
+      const osc3 = this.ctx.createOscillator();
+      const filter = this.ctx.createBiquadFilter();
+      const lfo = this.ctx.createOscillator();
+      const lfoGain = this.ctx.createGain();
+      const vGain = this.ctx.createGain();
+      osc1.type = "sawtooth";
+      osc2.type = "sawtooth";
+      osc3.type = "sawtooth";
+      lfo.type = "sine";
+      lfo.frequency.setValueAtTime(5.5, now);
+      lfoGain.gain.setValueAtTime(2.2, now);
+      osc1.frequency.setValueAtTime(freq * 0.995, now);
+      osc2.frequency.setValueAtTime(freq * 1.005, now);
+      osc3.frequency.setValueAtTime(freq * 2 * 1.001, now);
+      filter.type = "lowpass";
+      filter.frequency.setValueAtTime(1400, now);
+      filter.Q.setValueAtTime(1, now);
+      const peak = velocity * volumeCoeff * 0.22;
+      vGain.gain.setValueAtTime(1e-3, now);
+      vGain.gain.linearRampToValueAtTime(peak, now + 0.25);
+      vGain.gain.setValueAtTime(peak, now + duration);
+      vGain.gain.exponentialRampToValueAtTime(1e-3, now + duration + 0.7);
+      lfo.connect(lfoGain);
+      lfoGain.connect(osc1.frequency);
+      lfoGain.connect(osc2.frequency);
+      osc1.connect(filter);
+      osc2.connect(filter);
+      osc3.connect(filter);
+      filter.connect(vGain);
+      connectToOutput(vGain);
+      if (this.reverbNode) {
+        const stringsHall = this.ctx.createGain();
+        stringsHall.gain.value = 0.6;
+        vGain.connect(stringsHall);
+        stringsHall.connect(this.reverbNode);
+      }
+      lfo.start(now);
+      osc1.start(now);
+      osc2.start(now);
+      osc3.start(now);
+      lfo.stop(now + duration + 0.85);
+      osc1.stop(now + duration + 0.85);
+      osc2.stop(now + duration + 0.85);
+      osc3.stop(now + duration + 0.85);
+    } else if (pluginId === "cyber_lead") {
+      const osc1 = this.ctx.createOscillator();
+      const osc2 = this.ctx.createOscillator();
+      const filter = this.ctx.createBiquadFilter();
+      const vGain = this.ctx.createGain();
+      osc1.type = "sawtooth";
+      osc2.type = "square";
+      osc1.frequency.setValueAtTime(freq * 0.994, now);
+      osc2.frequency.setValueAtTime(freq * 1.006, now);
+      filter.type = "lowpass";
+      filter.frequency.setValueAtTime(3200, now);
+      filter.Q.setValueAtTime(4, now);
+      const peak = velocity * volumeCoeff * 0.28;
+      vGain.gain.setValueAtTime(1e-3, now);
+      vGain.gain.linearRampToValueAtTime(peak, now + 0.02);
+      vGain.gain.exponentialRampToValueAtTime(peak * 0.7, now + 0.25);
+      vGain.gain.setValueAtTime(peak * 0.7, now + duration);
+      vGain.gain.exponentialRampToValueAtTime(1e-3, now + duration + 0.35);
+      osc1.connect(filter);
+      osc2.connect(filter);
+      filter.connect(vGain);
+      connectToOutput(vGain);
+      if (this.delayNode) {
+        const delaySend = this.ctx.createGain();
+        delaySend.gain.value = 0.55;
+        vGain.connect(delaySend);
+        delaySend.connect(this.delayNode);
+      }
+      osc1.start(now);
+      osc2.start(now);
+      osc1.stop(now + duration + 0.4);
+      osc2.stop(now + duration + 0.4);
+    }
+  }
+};
+var synthEngine = new SynthEngine();
+
+// src/engine/audio/devicePatterns.ts
+var KNOWN_PATTERNS = [
+  {
+    pattern: /scarlett\s*6i6/i,
+    name: "Focusrite Scarlett 6i6",
+    inChannels: 6,
+    outChannels: 6,
+    inNames: {
+      1: "Mic 1 / Line 1 (Front Combo)",
+      2: "Inst 2 / Line 2 (Front Combo)",
+      3: "Line 3 (Rear Balanced)",
+      4: "Line 4 (Rear Balanced)",
+      5: "S/PDIF 5 (Digital In L)",
+      6: "S/PDIF 6 (Digital In R)"
+    },
+    outNames: {
+      "Ch 1 / 2 (Main L/R)": "Ch 1/2 (Main Monitor Out L/R)",
+      "Ch 3 / 4 (Sub / Cue)": "Ch 3/4 (Headphone 1 / Line Out 3-4)",
+      "Ch 5 / 6 (Aux Out)": "Ch 5/6 (Headphone 2 / S/PDIF Out 5-6)",
+      "Ch 1 (Mono Left)": "Ch 1 (Direct Monitor Left)",
+      "Ch 2 (Mono Right)": "Ch 2 (Direct Monitor Right)",
+      "Ch 3 (Mono)": "Ch 3 (Line Out 3 Direct)",
+      "Ch 4 (Mono)": "Ch 4 (Line Out 4 Direct)",
+      "Ch 5 (Mono)": "Ch 5 (S/PDIF Out L)",
+      "Ch 6 (Mono)": "Ch 6 (S/PDIF Out R)"
+    }
+  },
+  {
+    pattern: /scarlett\s*18i20/i,
+    name: "Focusrite Scarlett 18i20",
+    inChannels: 18,
+    outChannels: 20
+  },
+  {
+    pattern: /scarlett\s*18i8/i,
+    name: "Focusrite Scarlett 18i8",
+    inChannels: 18,
+    outChannels: 8
+  },
+  {
+    pattern: /scarlett\s*8i6/i,
+    name: "Focusrite Scarlett 8i6",
+    inChannels: 8,
+    outChannels: 6
+  },
+  {
+    pattern: /scarlett\s*4i4/i,
+    name: "Focusrite Scarlett 4i4",
+    inChannels: 4,
+    outChannels: 4
+  },
+  {
+    pattern: /scarlett\s*2i4/i,
+    name: "Focusrite Scarlett 2i4",
+    inChannels: 2,
+    outChannels: 4
+  },
+  {
+    pattern: /scarlett\s*(2i2|solo)/i,
+    name: "Focusrite Scarlett 2i2",
+    inChannels: 2,
+    outChannels: 2
+  },
+  {
+    pattern: /umc\s*1820/i,
+    name: "Behringer U-Phoria UMC1820",
+    inChannels: 18,
+    outChannels: 20
+  },
+  {
+    pattern: /umc\s*404(hd)?/i,
+    name: "Behringer U-Phoria UMC404HD",
+    inChannels: 4,
+    outChannels: 4
+  },
+  {
+    pattern: /umc\s*204(hd)?/i,
+    name: "Behringer U-Phoria UMC204HD",
+    inChannels: 2,
+    outChannels: 4
+  },
+  {
+    pattern: /apollo\s*(twin|x4|x8|x16)/i,
+    name: "Universal Audio Apollo",
+    inChannels: 10,
+    outChannels: 6
+  },
+  {
+    pattern: /motu\s*(m4|m2|ultralite)/i,
+    name: "MOTU Audio Interface",
+    inChannels: 4,
+    outChannels: 4
+  },
+  {
+    pattern: /komplete\s*audio\s*6/i,
+    name: "Native Instruments Komplete Audio 6",
+    inChannels: 6,
+    outChannels: 6
+  }
+];
+
+// src/engine/audio/deviceProfiles.ts
+function detectHardwareProfile(inputLabel, outputLabel, trackSettings, trackCapabilities, destMaxChannels) {
+  const combinedLabel = `${inputLabel || "} ${outputLabel || "}`;
+  let matchedPattern = null;
+  for (const kp of KNOWN_PATTERNS) {
+    if (kp.pattern.test(combinedLabel)) {
+      matchedPattern = kp;
+      break;
+    }
+  }
+  const trackChannelCount = trackSettings?.channelCount || trackCapabilities?.channelCount?.max;
+  let inCount = matchedPattern ? matchedPattern.inChannels : trackChannelCount && trackChannelCount > 1 ? trackChannelCount : 2;
+  let outCount = matchedPattern ? matchedPattern.outChannels : destMaxChannels && destMaxChannels > 1 ? destMaxChannels : 2;
+  if (!matchedPattern) {
+    const channelMatch = combinedLabel.match(/(\d+)\s*(?:in|ch|channel|i)/i);
+    if (channelMatch && channelMatch[1]) {
+      const parsed = parseInt(channelMatch[1], 10);
+      if (!isNaN(parsed) && parsed >= 2 && parsed <= 64) {
+        inCount = Math.max(inCount, parsed);
+      }
+    }
+  }
+  return {
+    detectedInputChannels: Math.max(2, inCount),
+    detectedOutputChannels: Math.max(2, outCount),
+    interfaceModelName: matchedPattern ? matchedPattern.name : inputLabel || "Standard Audio Interface",
+    isKnownInterface: !!matchedPattern,
+    channelDescriptions: matchedPattern?.inNames || {},
+    outputDescriptions: matchedPattern?.outNames || {}
+  };
+}
+function buildInputChannelList(totalChannels, descriptions = {}) {
+  const count = Math.max(2, totalChannels);
+  const result = [];
+  for (let ch = 1; ch <= count; ch++) {
+    const customDesc = descriptions[ch];
+    const defaultRole = ch === 1 ? "Mic 1 / Line In 1" : ch === 2 ? "Inst 2 / Line In 2" : `Line In ${ch}`;
+    const label = customDesc || `Input ${ch} (${defaultRole} - Mono)`;
+    result.push({
+      id: ch,
+      label,
+      shortLabel: `Ch ${ch}`,
+      isStereo: false,
+      channels: [ch]
+    });
+  }
+  result.push({
+    id: 0,
+    label: `Stereo Pair 1+2 (${descriptions[1] ? "Main L/R Stereo" : "In 1/2 Stereo"})`,
+    shortLabel: "Ch 1/2 Stereo",
+    isStereo: true,
+    channels: [1, 2]
+  });
+  for (let pairStart = 3; pairStart < count; pairStart += 2) {
+    const pairEnd = pairStart + 1;
+    const pairId = pairStart * 100 + pairEnd;
+    result.push({
+      id: pairId,
+      label: `Stereo Pair ${pairStart}+${pairEnd} (In ${pairStart}/${pairEnd})`,
+      shortLabel: `Ch ${pairStart}/${pairEnd}`,
+      isStereo: true,
+      channels: [pairStart, pairEnd]
+    });
+  }
+  return result;
+}
+function buildOutputChannelList(totalChannels, descriptions = {}) {
+  const count = Math.max(2, totalChannels);
+  const list = [];
+  list.push({
+    id: "Ch 1 / 2 (Main L/R)",
+    label: descriptions["Ch 1 / 2 (Main L/R)"] || "Ch 1/2 (Main Stereo Master Out)",
+    shortLabel: "Ch 1/2 Main",
+    isStereo: true,
+    channels: [1, 2]
+  });
+  if (count >= 4) {
+    list.push({
+      id: "Ch 3 / 4 (Sub / Cue)",
+      label: descriptions["Ch 3 / 4 (Sub / Cue)"] || "Ch 3/4 (Sub / Cue / Line Out 3-4)",
+      shortLabel: "Ch 3/4 Cue",
+      isStereo: true,
+      channels: [3, 4]
+    });
+  }
+  if (count >= 6) {
+    list.push({
+      id: "Ch 5 / 6 (Aux Out)",
+      label: descriptions["Ch 5 / 6 (Aux Out)"] || "Ch 5/6 (Aux / Headphone 2 / S/PDIF Out)",
+      shortLabel: "Ch 5/6 Aux",
+      isStereo: true,
+      channels: [5, 6]
+    });
+  }
+  if (count >= 8) {
+    list.push({
+      id: "Ch 7 / 8 (Out 7/8)",
+      label: descriptions["Ch 7 / 8 (Out 7/8)"] || "Ch 7/8 (Line 7/8 Direct Out)",
+      shortLabel: "Ch 7/8 Out",
+      isStereo: true,
+      channels: [7, 8]
+    });
+  }
+  for (let ch = 1; ch <= count; ch++) {
+    const monoKey = `Ch ${ch} (Mono${ch === 1 ? " Left" : ch === 2 ? " Right" : ""})`;
+    list.push({
+      id: monoKey,
+      label: descriptions[monoKey] || `Ch ${ch} (Mono ${ch === 1 ? "Left" : ch === 2 ? "Right" : `Direct Out ${ch}`})`,
+      shortLabel: `Ch ${ch} Mono`,
+      isStereo: false,
+      channels: [ch]
+    });
+  }
+  return list;
+}
+
+// src/engine/audio/audioInputManager/audioInputManager.ts
+import { topLevelIoRegistry } from "@ultrst-armada/kloks/state-graph";
+import {
+  loadStoredConfig,
+  saveStoredConfig,
+  enumerateSystemAudioDevices
+} from "@ultrst-armada/kloks/state-graph";
+import { acquireAudioInputStream, stopAudioMediaStream } from "@ultrst-armada/kloks/state-graph";
+import { AudioBusDriver } from "@ultrst-armada/kloks/state-graph";
+var DEFAULT_NAMED_INPUTS = DEFAULT_NAMED_BUSSES;
+var AudioInputManager = class {
+  audioCtx = null;
+  mediaStream = null;
+  sourceNode = null;
+  busDriver = new AudioBusDriver();
+  isListening = false;
+  listeners = /* @__PURE__ */ new Set();
+  namedInputs = [...DEFAULT_NAMED_BUSSES];
+  selectedDeviceId = "default";
+  selectedOutputDeviceId = "default";
+  hardwareChannelCount = 6;
+  detectedTrackChannelCount = 2;
+  isHardwareAutoDetected = false;
+  detectedInterfaceName = "";
+  activeProfile = null;
+  availableDevices = [];
+  availableOutputDevices = [];
+  lastError = null;
+  constructor() {
+    this.loadConfig();
+    this.initDeviceChangeListener();
+    this.enumerateAudioDevices().catch((err) => {
+      console.warn("Initial enumerateAudioDevices failed:", err);
+    });
+    this.registerWithSynthEngine();
+  }
+  registerWithSynthEngine() {
+    queueMicrotask(() => {
+      try {
+        if (typeof synthEngine !== "undefined" && synthEngine?.registerAudioInputLevelProvider) {
+          synthEngine.registerAudioInputLevelProvider((busId) => this.getInputLevel(busId));
+        } else {
+          setTimeout(() => {
+            if (typeof synthEngine !== "undefined" && synthEngine?.registerAudioInputLevelProvider) {
+              synthEngine.registerAudioInputLevelProvider((busId) => this.getInputLevel(busId));
+            }
+          }, 0);
+        }
+      } catch (e) {
+        setTimeout(() => {
+          try {
+            if (typeof synthEngine !== "undefined" && synthEngine?.registerAudioInputLevelProvider) {
+              synthEngine.registerAudioInputLevelProvider((busId) => this.getInputLevel(busId));
+            }
+          } catch (err) {
+          }
+        }, 0);
+      }
+    });
+  }
+  initDeviceChangeListener() {
+    if (typeof navigator !== "undefined" && navigator.mediaDevices?.addEventListener) {
+      navigator.mediaDevices.addEventListener("devicechange", async () => {
+        await this.enumerateAudioDevices();
+        this.notifyListeners();
+      });
+    }
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  notifyListeners() {
+    this.listeners.forEach((fn) => {
+      try {
+        fn();
+      } catch (err) {
+        console.error("Error in audioInputManager listener:", err);
+      }
+    });
+  }
+  isConnected() {
+    if (!this.isListening || !this.mediaStream) return false;
+    const tracks = this.mediaStream.getAudioTracks();
+    return tracks.length > 0 && tracks.some((t) => t.readyState === "live");
+  }
+  get isAudioActive() {
+    return this.isConnected();
+  }
+  loadConfig() {
+    const config = loadStoredConfig(this.namedInputs, this.selectedDeviceId, this.selectedOutputDeviceId);
+    this.namedInputs = config.namedAudioInputs;
+    this.selectedDeviceId = config.selectedAudioDeviceId;
+    this.selectedOutputDeviceId = config.selectedAudioOutputDeviceId;
+    return config;
+  }
+  saveConfig(config) {
+    if (config?.namedAudioInputs !== void 0) this.namedInputs = config.namedAudioInputs;
+    if (config?.selectedAudioDeviceId !== void 0) this.selectedDeviceId = config.selectedAudioDeviceId;
+    if (config?.selectedAudioOutputDeviceId !== void 0) this.selectedOutputDeviceId = config.selectedAudioOutputDeviceId;
+    saveStoredConfig({
+      selectedAudioDeviceId: this.selectedDeviceId,
+      selectedAudioOutputDeviceId: this.selectedOutputDeviceId,
+      namedAudioInputs: this.namedInputs,
+      selectedMidiDeviceId: null,
+      midiConfigs: {}
+    });
+  }
+  async enumerateAudioDevices() {
+    const res = await enumerateSystemAudioDevices();
+    this.availableDevices = res.inputs;
+    this.availableOutputDevices = res.outputs;
+    this.refreshHardwareProfile();
+    return res;
+  }
+  refreshHardwareProfile() {
+    const inputDev = this.availableDevices.find((d) => d.deviceId === this.selectedDeviceId);
+    const outputDev = this.availableOutputDevices.find((d) => d.deviceId === this.selectedOutputDeviceId);
+    let trackSettings;
+    let trackCaps;
+    if (this.mediaStream) {
+      const trk = this.mediaStream.getAudioTracks()[0];
+      if (trk) {
+        trackSettings = trk.getSettings();
+        trackCaps = trk.getCapabilities ? trk.getCapabilities() : void 0;
+      }
+    }
+    const ctx = synthEngine.getContext();
+    const rawDestMax = ctx?.destination?.maxChannelCount;
+    const destMax = typeof rawDestMax === "number" && isFinite(rawDestMax) ? rawDestMax : 2;
+    const profile = detectHardwareProfile(
+      inputDev?.label || "",
+      outputDev?.label || "",
+      trackSettings,
+      trackCaps,
+      destMax
+    );
+    this.activeProfile = profile;
+    this.detectedInterfaceName = profile.interfaceModelName;
+    if (profile.isKnownInterface || trackSettings?.channelCount && trackSettings.channelCount > 2) {
+      this.hardwareChannelCount = profile.detectedInputChannels;
+      this.isHardwareAutoDetected = true;
+      multiChannelOutputRouter.setMaxChannels(profile.detectedOutputChannels);
+    }
+  }
+  async selectNativeAudioOutput() {
+    const nav = navigator;
+    if (nav.mediaDevices && typeof nav.mediaDevices.selectAudioOutput === "function") {
+      try {
+        const device = await nav.mediaDevices.selectAudioOutput();
+        if (device && device.deviceId) {
+          await this.setOutputDevice(device.deviceId);
+          await this.enumerateAudioDevices();
+          this.notifyListeners();
+          return true;
+        }
+      } catch (err) {
+        console.warn("selectAudioOutput was cancelled or failed:", err);
+      }
+    }
+    return false;
+  }
+  getLastError() {
+    return this.lastError;
+  }
+  clearError() {
+    this.lastError = null;
+    this.notifyListeners();
+  }
+  async initAudioStream(deviceId) {
+    const targetDevId = deviceId || this.selectedDeviceId;
+    stopAudioMediaStream(this.mediaStream);
+    try {
+      this.lastError = null;
+      const acquired = await acquireAudioInputStream(targetDevId);
+      if (!acquired) {
+        this.lastError = "Audio hardware stream not available.";
+        this.notifyListeners();
+        return false;
+      }
+      this.mediaStream = acquired.mediaStream;
+      this.detectedTrackChannelCount = acquired.detectedTrackChannelCount;
+      this.selectedDeviceId = targetDevId;
+      this.saveConfig({ selectedAudioDeviceId: targetDevId });
+      this.audioCtx = synthEngine.getContext();
+      if (this.audioCtx.state === "suspended") {
+        await this.audioCtx.resume();
+      }
+      this.sourceNode = this.audioCtx.createMediaStreamSource(this.mediaStream);
+      await this.enumerateAudioDevices();
+      this.busDriver.setupSplitter(this.audioCtx, this.sourceNode, this.hardwareChannelCount);
+      this.busDriver.setupNamedAnalysers(this.audioCtx, this.namedInputs);
+      this.isListening = true;
+      this.syncEndpointsToRegistry();
+      topLevelIoRegistry.logTrace("AUDIO", "DEVICE_DETECTED", {
+        deviceId: this.selectedDeviceId,
+        label: this.getActiveDeviceLabel()
+      });
+      topLevelIoRegistry.logTrace("AUDIO", "AUDIO_STREAM_OPEN", {
+        channelCount: this.hardwareChannelCount,
+        streamId: this.mediaStream.id
+      });
+      this.lastError = null;
+      this.notifyListeners();
+      return true;
+    } catch (err) {
+      const errStr = String(err?.message || err?.name || err || "").toLowerCase();
+      if (err?.name === "NotAllowedError" || err?.name === "SecurityError" || errStr.includes("permission denied") || errStr.includes("not allowed") || errStr.includes("blocked")) {
+        this.lastError = "Hardware access requires allow='microphone; midi' or new tab";
+      } else {
+        this.lastError = `Audio stream init failed: ${err?.message || "Permission denied"}`;
+      }
+      console.warn("Audio hardware stream init failed:", this.lastError);
+      this.notifyListeners();
+      return false;
+    }
+  }
+  async reconnectStream() {
+    if (this.mediaStream && this.isListening) {
+      try {
+        if (this.sourceNode) {
+          try {
+            this.sourceNode.disconnect();
+          } catch (e) {
+          }
+        }
+        this.audioCtx = synthEngine.getContext();
+        if (this.audioCtx.state === "suspended") {
+          await this.audioCtx.resume();
+        }
+        this.sourceNode = this.audioCtx.createMediaStreamSource(this.mediaStream);
+        this.busDriver.setupSplitter(this.audioCtx, this.sourceNode, this.hardwareChannelCount);
+        this.busDriver.setupNamedAnalysers(this.audioCtx, this.namedInputs);
+      } catch (err) {
+        console.warn("Error reconnecting stream to new AudioContext:", err);
+      }
+    }
+  }
+  async setOutputDevice(deviceId) {
+    this.selectedOutputDeviceId = deviceId;
+    this.saveConfig({ selectedAudioOutputDeviceId: deviceId });
+    await synthEngine.setOutputDevice(deviceId);
+    this.refreshHardwareProfile();
+    this.notifyListeners();
+    return true;
+  }
+  getAvailableInputChannels() {
+    return buildInputChannelList(this.hardwareChannelCount, this.activeProfile?.channelDescriptions);
+  }
+  getAvailableOutputChannels() {
+    const outChannels = this.activeProfile?.detectedOutputChannels || this.hardwareChannelCount;
+    return buildOutputChannelList(outChannels, this.activeProfile?.outputDescriptions);
+  }
+  getActiveDeviceLabel() {
+    const dev = this.availableDevices.find((d) => d.deviceId === this.selectedDeviceId);
+    return dev?.label || "Default System Audio Interface";
+  }
+  getActiveOutputDeviceLabel() {
+    const dev = this.availableOutputDevices.find((d) => d.deviceId === this.selectedOutputDeviceId);
+    return dev?.label || "Default System Audio Output";
+  }
+  getChannelLevel(channel) {
+    if (channel === 0) {
+      return Math.max(this.busDriver.getChannelLevel(1), this.busDriver.getChannelLevel(2));
+    }
+    if (channel > 100) {
+      const ch1 = Math.floor(channel / 100);
+      const ch2 = channel % 100;
+      return Math.max(this.busDriver.getChannelLevel(ch1), this.busDriver.getChannelLevel(ch2));
+    }
+    return this.busDriver.getChannelLevel(channel);
+  }
+  syncEndpointsToRegistry() {
+    const isLive = this.isConnected();
+    this.namedInputs.forEach((bus) => {
+      if (bus.busType === "input") {
+        const ep = topLevelIoRegistry.getOrCreateAudioEndpoint(bus.id, bus.name, bus.channel ?? 1);
+        ep.gain = bus.gain ?? 1;
+        ep.isMuted = !!bus.isMuted;
+        ep.analyser = this.busDriver.namedAnalyserMap.get(bus.id) || null;
+        ep.audioNode = this.busDriver.namedGainMap.get(bus.id) || null;
+        ep.setConnected(isLive);
+      }
+    });
+  }
+  getBusLevel(busId) {
+    return this.getInputLevel(busId);
+  }
+  getInputLevel(inputId) {
+    const bus = this.namedInputs.find((b) => b.id === inputId);
+    if (!bus || bus.isMuted) return 0;
+    const ep = topLevelIoRegistry.getAudioEndpoint(inputId);
+    if (ep) {
+      ep.gain = bus.gain ?? 1;
+      ep.isMuted = !!bus.isMuted;
+      if (!ep.analyser) {
+        ep.analyser = this.busDriver.namedAnalyserMap.get(inputId) || null;
+      }
+      if (!ep.audioNode) {
+        ep.audioNode = this.busDriver.namedGainMap.get(inputId) || null;
+      }
+      ep.sampleFromAnalyser();
+      if (ep.level > 5e-3) {
+        return Math.min(1, ep.level * (bus.gain ?? 1));
+      }
+      return 0;
+    }
+    const channelNum = bus.channel ?? 1;
+    const rawLevel = this.busDriver.getNamedBusLevel(inputId, channelNum);
+    if (rawLevel > 5e-3) {
+      return Math.min(1, rawLevel * (bus.gain ?? 1));
+    }
+    return 0;
+  }
+  setNamedInputs(inputs) {
+    this.namedInputs = [...inputs];
+    this.saveConfig();
+    if (this.audioCtx) this.busDriver.setupNamedAnalysers(this.audioCtx, this.namedInputs);
+    this.syncEndpointsToRegistry();
+    this.notifyListeners();
+  }
+  addNamedBus(bus) {
+    this.namedInputs = [...this.namedInputs, bus];
+    this.saveConfig();
+    if (bus.busType === "input" && this.audioCtx) {
+      this.busDriver.setupNamedAnalysers(this.audioCtx, this.namedInputs);
+    }
+    this.syncEndpointsToRegistry();
+    this.notifyListeners();
+  }
+  addNamedInput(input) {
+    this.addNamedBus(input);
+  }
+  addInputBus() {
+    const existingInputs = this.namedInputs.filter((b) => b.busType === "input");
+    const nextIdx = existingInputs.length + 1;
+    const availChannels = this.getAvailableInputChannels();
+    const defaultCh = availChannels[(nextIdx - 1) % availChannels.length]?.id ?? 1;
+    const colors = ["#f59e0b", "#06b6d4", "#10b981", "#ec4899", "#8b5cf6", "#3b82f6"];
+    const newBus = {
+      id: `bus-in-${Date.now()}-${Math.random().toString(36).substr(2, 4)}`,
+      busType: "input",
+      deviceId: this.selectedDeviceId,
+      name: `Input Bus ${nextIdx}`,
+      channel: defaultCh,
+      gain: 1,
+      isMuted: false,
+      color: colors[(nextIdx - 1) % colors.length]
+    };
+    this.addNamedBus(newBus);
+    return newBus;
+  }
+  addOutputBus() {
+    const existingOutputs = this.namedInputs.filter((b) => b.busType === "output");
+    const nextIdx = existingOutputs.length + 1;
+    const availChannels = this.getAvailableOutputChannels();
+    const defaultOut = availChannels[(nextIdx - 1) % availChannels.length]?.id ?? "Ch 1 / 2 (Main L/R)";
+    const colors = ["#10b981", "#3b82f6", "#8b5cf6", "#f59e0b", "#ec4899", "#06b6d4"];
+    const newBus = {
+      id: `bus-out-${Date.now()}-${Math.random().toString(36).substr(2, 4)}`,
+      busType: "output",
+      deviceId: this.selectedOutputDeviceId,
+      name: `Output Bus ${nextIdx}`,
+      outputChannels: defaultOut,
+      gain: 1,
+      isMuted: false,
+      color: colors[(nextIdx - 1) % colors.length]
+    };
+    this.addNamedBus(newBus);
+    return newBus;
+  }
+  updateNamedInput(updated) {
+    this.namedInputs = this.namedInputs.map((i) => i.id === updated.id ? { ...updated } : i);
+    const gainNode = this.busDriver.namedGainMap.get(updated.id);
+    if (gainNode) {
+      gainNode.gain.value = updated.isMuted ? 0 : updated.gain;
+    }
+    this.saveConfig();
+    this.notifyListeners();
+  }
+  deleteNamedInput(id) {
+    this.namedInputs = this.namedInputs.filter((i) => i.id !== id);
+    this.saveConfig();
+    if (this.audioCtx) this.busDriver.setupNamedAnalysers(this.audioCtx, this.namedInputs);
+    this.notifyListeners();
+  }
+  updateMonitoringConnections(nodes, connections) {
+    if (!this.audioCtx) return;
+    this.busDriver.updateMonitoring(
+      this.audioCtx,
+      synthEngine.getMasterNode(),
+      nodes,
+      connections,
+      (id) => synthEngine.isNodeConnectedToOutput(id)
+    );
+  }
+  stopStream() {
+    stopAudioMediaStream(this.mediaStream);
+    this.mediaStream = null;
+    this.isListening = false;
+    this.lastError = null;
+    this.notifyListeners();
+  }
+};
+var audioInputManager = new AudioInputManager();
+
+export {
+  MultiChannelOutputRouter,
+  multiChannelOutputRouter,
+  createCosmicImpulseBuffer,
+  playSyntheticDrumVoice,
+  BaseAudioGraphNode,
+  MasterAudioOutputGraphNode,
+  BaseSourceAudioGraphNode,
+  MidiInstrumentGraphNode,
+  AudioContainerGraphNode,
+  MidiContainerGraphNode,
+  BaseProcessorAudioGraphNode,
+  EffectProcessorGraphNode,
+  SignalRouterGraphNode,
+  createAudioGraphNode,
+  generateSaturationCurve,
+  generateReverbImpulse,
+  createSidechainCompressor,
+  create3BandCrossover,
+  createMultibandCompressor,
+  createAudioEffectProcessor,
+  AudioEffects,
+  audioEffectsEntity,
+  DEFAULT_NAMED_BUSSES,
+  KNOWN_PATTERNS,
+  detectHardwareProfile,
+  buildInputChannelList,
+  buildOutputChannelList,
+  DEFAULT_NAMED_INPUTS,
+  AudioInputManager,
+  audioInputManager,
+  SynthEngine,
+  synthEngine
+};