aimeat 1.40.1 → 2.1.0

package/dist/static/sdk-libs/dist/aimeat-audio.js

@@ -0,0 +1,979 @@
+// GENERATED FILE — do not edit directly. Source: src/static/sdk-libs/audio/ (+ _core/).
+// Rebuild: pnpm build:sdk  ·  Served at /v1/libs/aimeat-audio.js (with a per-node config prelude).
+"use strict";
+(() => {
+  // src/static/sdk-libs/_core/config.js
+  function cfg() {
+    return window.__AIMEAT_SDK_CFG__ || { nodeId: "", baseUrl: "" };
+  }
+  function resolveNodeUrl() {
+    const meta = document.querySelector('meta[name="aimeat-node"]');
+    if (meta) return (meta.getAttribute("content") || "").replace(/\/$/, "");
+    if (location.protocol === "http:" || location.protocol === "https:") return location.origin;
+    return cfg().baseUrl;
+  }
+  var NODE_URL = resolveNodeUrl();
+  var APEX_URL = cfg().baseUrl;
+  var NODE_ID = cfg().nodeId;
+  var HEARTBEAT_MS = cfg().heartbeatMs || 3e4;
+
+  // src/static/sdk-libs/_core/namespace.js
+  function namespace() {
+    if (!window.AIMEAT) window.AIMEAT = {};
+    return window.AIMEAT;
+  }
+  function attach(key, value) {
+    const ns = namespace();
+    ns[key] = value;
+    return ns;
+  }
+
+  // src/static/sdk-libs/audio/core.js
+  var _ctx = null;
+  function ctx() {
+    if (!_ctx) {
+      _ctx = new (window.AudioContext || window.webkitAudioContext)();
+      if (_ctx.state === "suspended") {
+        var resume = function() {
+          if (_ctx && _ctx.state === "suspended") _ctx.resume();
+        };
+        ["click", "touchstart", "keydown"].forEach(function(e) {
+          document.addEventListener(e, resume, { once: false, passive: true });
+        });
+      }
+    }
+    return _ctx;
+  }
+  var NOTE_NAMES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
+  var FLAT_MAP = { "Db": "C#", "Eb": "D#", "Gb": "F#", "Ab": "G#", "Bb": "A#", "Cs": "C#", "Ds": "D#", "Fs": "F#", "Gs": "G#", "As": "A#" };
+  var _freqCache = {};
+  function noteToFreq(note) {
+    if (_freqCache[note]) return _freqCache[note];
+    var n = note.trim();
+    var flatKey = n.slice(0, 2);
+    if (FLAT_MAP[flatKey]) n = FLAT_MAP[flatKey] + n.slice(2);
+    var match = n.match(/^([A-G]#?)(\d)$/);
+    if (!match) return null;
+    var name = match[1];
+    var octave = parseInt(match[2]);
+    var semitone = NOTE_NAMES.indexOf(name);
+    if (semitone < 0) return null;
+    var midi = (octave + 1) * 12 + semitone;
+    var freq = 440 * Math.pow(2, (midi - 69) / 12);
+    _freqCache[note] = freq;
+    return freq;
+  }
+  var _masterGain = null;
+  function masterNode() {
+    if (!_masterGain) {
+      _masterGain = ctx().createGain();
+      _masterGain.connect(ctx().destination);
+    }
+    return _masterGain;
+  }
+  var master = {
+    get volume() {
+      return masterNode().gain.value;
+    },
+    set volume(v) {
+      masterNode().gain.value = Math.max(0, Math.min(1, v));
+    },
+    _muted: false,
+    _premuteVol: 1,
+    get mute() {
+      return master._muted;
+    },
+    set mute(v) {
+      if (v && !master._muted) {
+        master._premuteVol = masterNode().gain.value;
+        masterNode().gain.value = 0;
+        master._muted = true;
+      } else if (!v && master._muted) {
+        masterNode().gain.value = master._premuteVol;
+        master._muted = false;
+      }
+    }
+  };
+  var _active = {};
+  function registerActive(instrument, note, nodes, stopFn) {
+    var key = instrument + ":" + (note || "*");
+    if (_active[key]) _active[key].stop();
+    _active[key] = { nodes, stop: stopFn };
+  }
+  function stopActive(instrument, note) {
+    if (!instrument) {
+      Object.keys(_active).forEach(function(k) {
+        _active[k].stop();
+        delete _active[k];
+      });
+      return;
+    }
+    if (note) {
+      var key = instrument + ":" + note;
+      if (_active[key]) {
+        _active[key].stop();
+        delete _active[key];
+      }
+    } else {
+      Object.keys(_active).forEach(function(k) {
+        if (k.startsWith(instrument + ":")) {
+          _active[k].stop();
+          delete _active[k];
+        }
+      });
+    }
+  }
+  var instruments = {};
+  var sampleBuffers = {};
+  var customSynths = {};
+
+  // src/static/sdk-libs/audio/instruments.js
+  instruments.piano = {
+    play: function(note, opts) {
+      var freq = noteToFreq(note);
+      if (!freq) return;
+      var t = ctx().currentTime;
+      var vel = opts && opts.velocity !== void 0 ? opts.velocity : 0.7;
+      var dur = opts && opts.duration || 2;
+      var mod = ctx().createOscillator();
+      mod.type = "sine";
+      mod.frequency.value = freq * 2;
+      var modGain = ctx().createGain();
+      modGain.gain.setValueAtTime(freq * 1.5 * vel, t);
+      modGain.gain.exponentialRampToValueAtTime(freq * 0.01, t + dur * 0.8);
+      mod.connect(modGain);
+      var car = ctx().createOscillator();
+      car.type = "sine";
+      car.frequency.value = freq;
+      modGain.connect(car.frequency);
+      var env = ctx().createGain();
+      env.gain.setValueAtTime(0, t);
+      env.gain.linearRampToValueAtTime(vel * 0.4, t + 5e-3);
+      env.gain.exponentialRampToValueAtTime(vel * 0.15, t + 0.1);
+      env.gain.exponentialRampToValueAtTime(1e-3, t + dur);
+      car.connect(env);
+      env.connect(masterNode());
+      mod.start(t);
+      car.start(t);
+      mod.stop(t + dur + 0.1);
+      car.stop(t + dur + 0.1);
+      registerActive("piano", note, [mod, car], function() {
+        try {
+          env.gain.cancelScheduledValues(ctx().currentTime);
+          env.gain.setValueAtTime(env.gain.value, ctx().currentTime);
+          env.gain.linearRampToValueAtTime(0, ctx().currentTime + 0.05);
+          mod.stop(ctx().currentTime + 0.1);
+          car.stop(ctx().currentTime + 0.1);
+        } catch {
+        }
+      });
+    }
+  };
+  instruments.guitar = {
+    play: function(note, opts) {
+      var freq = noteToFreq(note);
+      if (!freq) return;
+      var t = ctx().currentTime;
+      var vel = opts && opts.velocity !== void 0 ? opts.velocity : 0.7;
+      var dur = opts && opts.duration || 1.5;
+      var bufSize = Math.round(ctx().sampleRate / freq);
+      var noiseBuffer = ctx().createBuffer(1, bufSize, ctx().sampleRate);
+      var data = noiseBuffer.getChannelData(0);
+      for (var i = 0; i < bufSize; i++) data[i] = (Math.random() * 2 - 1) * vel;
+      var noise = ctx().createBufferSource();
+      noise.buffer = noiseBuffer;
+      noise.loop = true;
+      var filter = ctx().createBiquadFilter();
+      filter.type = "lowpass";
+      filter.frequency.value = freq * 4;
+      filter.Q.value = 0.5;
+      var env = ctx().createGain();
+      env.gain.setValueAtTime(vel * 0.5, t);
+      env.gain.exponentialRampToValueAtTime(1e-3, t + dur);
+      noise.connect(filter);
+      filter.connect(env);
+      env.connect(masterNode());
+      noise.start(t);
+      noise.stop(t + dur + 0.05);
+      registerActive("guitar", note, [noise], function() {
+        try {
+          env.gain.cancelScheduledValues(ctx().currentTime);
+          env.gain.linearRampToValueAtTime(0, ctx().currentTime + 0.05);
+          noise.stop(ctx().currentTime + 0.1);
+        } catch {
+        }
+      });
+    }
+  };
+  instruments.bass = {
+    play: function(note, opts) {
+      var freq = noteToFreq(note);
+      if (!freq) return;
+      var t = ctx().currentTime;
+      var vel = opts && opts.velocity !== void 0 ? opts.velocity : 0.7;
+      var dur = opts && opts.duration || 0.8;
+      var osc = ctx().createOscillator();
+      osc.type = "sawtooth";
+      osc.frequency.value = freq;
+      var sub = ctx().createOscillator();
+      sub.type = "sine";
+      sub.frequency.value = freq / 2;
+      var subGain = ctx().createGain();
+      subGain.gain.value = 0.5;
+      sub.connect(subGain);
+      var mix = ctx().createGain();
+      osc.connect(mix);
+      subGain.connect(mix);
+      var filter = ctx().createBiquadFilter();
+      filter.type = "lowpass";
+      filter.frequency.setValueAtTime(freq * 3, t);
+      filter.frequency.exponentialRampToValueAtTime(freq * 1.2, t + 0.15);
+      filter.Q.value = 2;
+      var env = ctx().createGain();
+      env.gain.setValueAtTime(0, t);
+      env.gain.linearRampToValueAtTime(vel * 0.5, t + 0.01);
+      env.gain.setValueAtTime(vel * 0.5, t + dur * 0.7);
+      env.gain.exponentialRampToValueAtTime(1e-3, t + dur);
+      mix.connect(filter);
+      filter.connect(env);
+      env.connect(masterNode());
+      osc.start(t);
+      sub.start(t);
+      osc.stop(t + dur + 0.05);
+      sub.stop(t + dur + 0.05);
+      registerActive("bass", note, [osc, sub], function() {
+        try {
+          env.gain.cancelScheduledValues(ctx().currentTime);
+          env.gain.linearRampToValueAtTime(0, ctx().currentTime + 0.05);
+          osc.stop(ctx().currentTime + 0.1);
+          sub.stop(ctx().currentTime + 0.1);
+        } catch {
+        }
+      });
+    }
+  };
+  instruments.drums = {
+    play: function(hit, opts) {
+      var t = ctx().currentTime;
+      var vel = opts && opts.velocity !== void 0 ? opts.velocity : 0.7;
+      function makeTom(freq) {
+        var osc = ctx().createOscillator();
+        osc.type = "sine";
+        osc.frequency.setValueAtTime(freq, t);
+        osc.frequency.exponentialRampToValueAtTime(freq * 0.6, t + 0.15);
+        var g = ctx().createGain();
+        g.gain.setValueAtTime(vel * 0.5, t);
+        g.gain.exponentialRampToValueAtTime(1e-3, t + 0.3);
+        osc.connect(g);
+        g.connect(masterNode());
+        osc.start(t);
+        osc.stop(t + 0.4);
+        return [osc];
+      }
+      var synths = {
+        "kick": function() {
+          var osc = ctx().createOscillator();
+          osc.type = "sine";
+          osc.frequency.setValueAtTime(150, t);
+          osc.frequency.exponentialRampToValueAtTime(50, t + 0.1);
+          var g = ctx().createGain();
+          g.gain.setValueAtTime(vel, t);
+          g.gain.exponentialRampToValueAtTime(1e-3, t + 0.4);
+          osc.connect(g);
+          g.connect(masterNode());
+          var click = ctx().createOscillator();
+          click.type = "square";
+          click.frequency.value = 800;
+          var cg = ctx().createGain();
+          cg.gain.setValueAtTime(vel * 0.3, t);
+          cg.gain.exponentialRampToValueAtTime(1e-3, t + 0.02);
+          click.connect(cg);
+          cg.connect(masterNode());
+          osc.start(t);
+          osc.stop(t + 0.5);
+          click.start(t);
+          click.stop(t + 0.05);
+          return [osc, click];
+        },
+        "snare": function() {
+          var bufLen = Math.round(ctx().sampleRate * 0.15);
+          var buf = ctx().createBuffer(1, bufLen, ctx().sampleRate);
+          var d = buf.getChannelData(0);
+          for (var i = 0; i < bufLen; i++) d[i] = Math.random() * 2 - 1;
+          var noise = ctx().createBufferSource();
+          noise.buffer = buf;
+          var nf = ctx().createBiquadFilter();
+          nf.type = "highpass";
+          nf.frequency.value = 1e3;
+          var ng = ctx().createGain();
+          ng.gain.setValueAtTime(vel * 0.6, t);
+          ng.gain.exponentialRampToValueAtTime(1e-3, t + 0.15);
+          noise.connect(nf);
+          nf.connect(ng);
+          ng.connect(masterNode());
+          var osc = ctx().createOscillator();
+          osc.type = "sine";
+          osc.frequency.value = 200;
+          var og = ctx().createGain();
+          og.gain.setValueAtTime(vel * 0.5, t);
+          og.gain.exponentialRampToValueAtTime(1e-3, t + 0.08);
+          osc.connect(og);
+          og.connect(masterNode());
+          noise.start(t);
+          osc.start(t);
+          osc.stop(t + 0.2);
+          return [noise, osc];
+        },
+        "hihat": function() {
+          var bufLen = Math.round(ctx().sampleRate * 0.05);
+          var buf = ctx().createBuffer(1, bufLen, ctx().sampleRate);
+          var d = buf.getChannelData(0);
+          for (var i = 0; i < bufLen; i++) d[i] = Math.random() * 2 - 1;
+          var noise = ctx().createBufferSource();
+          noise.buffer = buf;
+          var f = ctx().createBiquadFilter();
+          f.type = "highpass";
+          f.frequency.value = 7e3;
+          var g = ctx().createGain();
+          g.gain.setValueAtTime(vel * 0.3, t);
+          g.gain.exponentialRampToValueAtTime(1e-3, t + 0.05);
+          noise.connect(f);
+          f.connect(g);
+          g.connect(masterNode());
+          noise.start(t);
+          return [noise];
+        },
+        "hihat-open": function() {
+          var bufLen = Math.round(ctx().sampleRate * 0.3);
+          var buf = ctx().createBuffer(1, bufLen, ctx().sampleRate);
+          var d = buf.getChannelData(0);
+          for (var i = 0; i < bufLen; i++) d[i] = Math.random() * 2 - 1;
+          var noise = ctx().createBufferSource();
+          noise.buffer = buf;
+          var f = ctx().createBiquadFilter();
+          f.type = "highpass";
+          f.frequency.value = 6e3;
+          var g = ctx().createGain();
+          g.gain.setValueAtTime(vel * 0.3, t);
+          g.gain.exponentialRampToValueAtTime(1e-3, t + 0.3);
+          noise.connect(f);
+          f.connect(g);
+          g.connect(masterNode());
+          noise.start(t);
+          return [noise];
+        },
+        "crash": function() {
+          var bufLen = Math.round(ctx().sampleRate * 1);
+          var buf = ctx().createBuffer(1, bufLen, ctx().sampleRate);
+          var d = buf.getChannelData(0);
+          for (var i = 0; i < bufLen; i++) d[i] = Math.random() * 2 - 1;
+          var noise = ctx().createBufferSource();
+          noise.buffer = buf;
+          var f = ctx().createBiquadFilter();
+          f.type = "highpass";
+          f.frequency.value = 4e3;
+          var g = ctx().createGain();
+          g.gain.setValueAtTime(vel * 0.5, t);
+          g.gain.exponentialRampToValueAtTime(1e-3, t + 1);
+          noise.connect(f);
+          f.connect(g);
+          g.connect(masterNode());
+          noise.start(t);
+          return [noise];
+        },
+        "ride": function() {
+          var bufLen = Math.round(ctx().sampleRate * 0.8);
+          var buf = ctx().createBuffer(1, bufLen, ctx().sampleRate);
+          var d = buf.getChannelData(0);
+          for (var i = 0; i < bufLen; i++) d[i] = Math.random() * 2 - 1;
+          var noise = ctx().createBufferSource();
+          noise.buffer = buf;
+          var f = ctx().createBiquadFilter();
+          f.type = "bandpass";
+          f.frequency.value = 8e3;
+          f.Q.value = 1;
+          var g = ctx().createGain();
+          g.gain.setValueAtTime(vel * 0.3, t);
+          g.gain.exponentialRampToValueAtTime(1e-3, t + 0.8);
+          noise.connect(f);
+          f.connect(g);
+          g.connect(masterNode());
+          noise.start(t);
+          return [noise];
+        },
+        "tom-high": function() {
+          return makeTom(300);
+        },
+        "tom-mid": function() {
+          return makeTom(220);
+        },
+        "tom-low": function() {
+          return makeTom(150);
+        },
+        "clap": function() {
+          var nodes2 = [];
+          for (var ci = 0; ci < 3; ci++) {
+            var delay = ci * 0.01;
+            var bufLen = Math.round(ctx().sampleRate * 0.02);
+            var buf = ctx().createBuffer(1, bufLen, ctx().sampleRate);
+            var d = buf.getChannelData(0);
+            for (var j = 0; j < bufLen; j++) d[j] = Math.random() * 2 - 1;
+            var noise = ctx().createBufferSource();
+            noise.buffer = buf;
+            var f = ctx().createBiquadFilter();
+            f.type = "bandpass";
+            f.frequency.value = 2500;
+            f.Q.value = 3;
+            var g = ctx().createGain();
+            g.gain.setValueAtTime(vel * 0.4, t + delay);
+            g.gain.exponentialRampToValueAtTime(1e-3, t + delay + 0.08);
+            noise.connect(f);
+            f.connect(g);
+            g.connect(masterNode());
+            noise.start(t + delay);
+            nodes2.push(noise);
+          }
+          return nodes2;
+        },
+        "cowbell": function() {
+          var osc1 = ctx().createOscillator();
+          osc1.type = "square";
+          osc1.frequency.value = 587;
+          var osc2 = ctx().createOscillator();
+          osc2.type = "square";
+          osc2.frequency.value = 845;
+          var g = ctx().createGain();
+          g.gain.setValueAtTime(vel * 0.3, t);
+          g.gain.exponentialRampToValueAtTime(1e-3, t + 0.4);
+          var f = ctx().createBiquadFilter();
+          f.type = "bandpass";
+          f.frequency.value = 700;
+          f.Q.value = 3;
+          osc1.connect(g);
+          osc2.connect(g);
+          g.connect(f);
+          f.connect(masterNode());
+          osc1.start(t);
+          osc2.start(t);
+          osc1.stop(t + 0.5);
+          osc2.stop(t + 0.5);
+          return [osc1, osc2];
+        }
+      };
+      var fn = synths[hit];
+      if (!fn) {
+        console.warn("[aimeat-audio] Unknown drum hit:", hit);
+        return;
+      }
+      var nodes = fn();
+      registerActive("drums", hit, nodes, function() {
+        nodes.forEach(function(n) {
+          try {
+            n.stop(ctx().currentTime + 0.01);
+          } catch {
+          }
+        });
+      });
+    }
+  };
+  instruments.flute = {
+    play: function(note, opts) {
+      var freq = noteToFreq(note);
+      if (!freq) return;
+      var t = ctx().currentTime;
+      var vel = opts && opts.velocity !== void 0 ? opts.velocity : 0.6;
+      var dur = opts && opts.duration || 1.5;
+      var vibDepth = opts && opts.vibrato !== void 0 ? opts.vibrato : 0.15;
+      var osc = ctx().createOscillator();
+      osc.type = "sine";
+      osc.frequency.value = freq;
+      var lfo = ctx().createOscillator();
+      lfo.type = "sine";
+      lfo.frequency.value = 5.5;
+      var lfoGain = ctx().createGain();
+      lfoGain.gain.value = freq * vibDepth * 0.02;
+      lfo.connect(lfoGain);
+      lfoGain.connect(osc.frequency);
+      var noiseBufLen = Math.round(ctx().sampleRate * dur);
+      var noiseBuf = ctx().createBuffer(1, noiseBufLen, ctx().sampleRate);
+      var nd = noiseBuf.getChannelData(0);
+      for (var i = 0; i < noiseBufLen; i++) nd[i] = Math.random() * 2 - 1;
+      var noiseNode = ctx().createBufferSource();
+      noiseNode.buffer = noiseBuf;
+      var noiseFilt = ctx().createBiquadFilter();
+      noiseFilt.type = "bandpass";
+      noiseFilt.frequency.value = freq;
+      noiseFilt.Q.value = 2;
+      var noiseGain = ctx().createGain();
+      noiseGain.gain.value = vel * 0.06;
+      noiseNode.connect(noiseFilt);
+      noiseFilt.connect(noiseGain);
+      var env = ctx().createGain();
+      env.gain.setValueAtTime(0, t);
+      env.gain.linearRampToValueAtTime(vel * 0.3, t + 0.08);
+      env.gain.setValueAtTime(vel * 0.3, t + dur - 0.1);
+      env.gain.linearRampToValueAtTime(0, t + dur);
+      osc.connect(env);
+      noiseGain.connect(env);
+      env.connect(masterNode());
+      lfo.start(t);
+      osc.start(t);
+      noiseNode.start(t);
+      lfo.stop(t + dur + 0.1);
+      osc.stop(t + dur + 0.1);
+      registerActive("flute", note, [osc, lfo, noiseNode], function() {
+        try {
+          env.gain.cancelScheduledValues(ctx().currentTime);
+          env.gain.linearRampToValueAtTime(0, ctx().currentTime + 0.05);
+          osc.stop(ctx().currentTime + 0.1);
+          lfo.stop(ctx().currentTime + 0.1);
+        } catch {
+        }
+      });
+    }
+  };
+  instruments.synth = {
+    play: function(note, opts) {
+      var freq = noteToFreq(note);
+      if (!freq) return;
+      var t = ctx().currentTime;
+      var vel = opts && opts.velocity !== void 0 ? opts.velocity : 0.7;
+      var dur = opts && opts.duration || 1;
+      var wave = opts && opts.wave || "sawtooth";
+      var filterFreq = opts && opts.filter || 2e3;
+      var osc = ctx().createOscillator();
+      osc.type = wave;
+      osc.frequency.value = freq;
+      var osc2 = ctx().createOscillator();
+      osc2.type = wave;
+      osc2.frequency.value = freq;
+      osc2.detune.value = 7;
+      var osc2Gain = ctx().createGain();
+      osc2Gain.gain.value = 0.5;
+      osc2.connect(osc2Gain);
+      var filter = ctx().createBiquadFilter();
+      filter.type = "lowpass";
+      filter.frequency.value = filterFreq;
+      filter.Q.value = 1;
+      var env = ctx().createGain();
+      env.gain.setValueAtTime(0, t);
+      env.gain.linearRampToValueAtTime(vel * 0.3, t + 0.02);
+      env.gain.setValueAtTime(vel * 0.3, t + dur * 0.7);
+      env.gain.exponentialRampToValueAtTime(1e-3, t + dur);
+      osc.connect(filter);
+      osc2Gain.connect(filter);
+      filter.connect(env);
+      env.connect(masterNode());
+      osc.start(t);
+      osc2.start(t);
+      osc.stop(t + dur + 0.05);
+      osc2.stop(t + dur + 0.05);
+      registerActive("synth", note, [osc, osc2], function() {
+        try {
+          env.gain.cancelScheduledValues(ctx().currentTime);
+          env.gain.linearRampToValueAtTime(0, ctx().currentTime + 0.05);
+          osc.stop(ctx().currentTime + 0.1);
+          osc2.stop(ctx().currentTime + 0.1);
+        } catch {
+        }
+      });
+    }
+  };
+
+  // src/static/sdk-libs/audio/index.js
+  var _soundboardBuffers = {};
+  var _soundboardSources = {};
+  var soundboard = {
+    load: function(name, url) {
+      return fetch(url).then(function(resp) {
+        if (!resp.ok) throw new Error("Failed to load sound: " + url);
+        return resp.arrayBuffer();
+      }).then(function(arrayBuf) {
+        return ctx().decodeAudioData(arrayBuf);
+      }).then(function(decoded) {
+        _soundboardBuffers[name] = decoded;
+      });
+    },
+    loadAll: function(map) {
+      var entries = Object.keys(map);
+      return Promise.all(entries.map(function(k) {
+        return soundboard.load(k, map[k]);
+      }));
+    },
+    play: function(name, opts) {
+      var buf = _soundboardBuffers[name];
+      if (!buf) {
+        console.warn("[aimeat-audio] Sound not loaded:", name);
+        return;
+      }
+      var source = ctx().createBufferSource();
+      source.buffer = buf;
+      source.loop = opts && opts.loop || false;
+      var gain = ctx().createGain();
+      gain.gain.value = opts && opts.volume !== void 0 ? opts.volume : 1;
+      source.connect(gain);
+      gain.connect(masterNode());
+      source.start();
+      _soundboardSources[name] = source;
+      source.onended = function() {
+        if (_soundboardSources[name] === source) delete _soundboardSources[name];
+      };
+    },
+    stop: function(name) {
+      if (_soundboardSources[name]) {
+        try {
+          _soundboardSources[name].stop();
+        } catch {
+        }
+        delete _soundboardSources[name];
+      }
+    }
+  };
+  var SAMPLE_NOTES = {
+    piano: ["A2", "C3", "Ds3", "A3", "C4", "Ds4", "A4", "C5", "Ds5", "C6", "C7"],
+    guitar: ["E2", "A2", "D3", "G3", "B3", "E4", "A4", "E5"],
+    "guitar-steel": ["E2", "A2", "D3", "G3", "B3", "E4", "A4", "E5"],
+    "guitar-el": ["E2", "A2", "D3", "G3", "B3", "E4", "A4", "E5"],
+    bass: ["E1", "A1", "D2", "G2", "B2", "E3"],
+    flute: ["C4", "E4", "A4", "C5", "E5", "A5", "C6"],
+    strings: ["C2", "G2", "C3", "G3", "C4", "G4", "C5", "G5", "C6"],
+    organ: ["C2", "G2", "C3", "G3", "C4", "G4", "C5", "G5", "C6"],
+    epiano: ["C2", "G2", "C3", "G3", "C4", "G4", "C5", "G5", "C6"],
+    trumpet: ["E3", "A3", "C4", "E4", "A4", "C5", "E5", "A5"],
+    drums: ["kick", "snare", "hihat", "hihat-open", "crash", "ride", "tom-high", "tom-mid", "tom-low", "clap", "cowbell"]
+  };
+  function loadSamples(instrument, opts) {
+    var source = opts && opts.source || NODE_URL + "/lib/samples/" + instrument + "/";
+    var notes = SAMPLE_NOTES[instrument];
+    if (!notes) {
+      console.warn("[aimeat-audio] No sample map for:", instrument);
+      return Promise.resolve();
+    }
+    if (!sampleBuffers[instrument]) sampleBuffers[instrument] = {};
+    return Promise.all(notes.map(function(note) {
+      var url = source + note + ".mp3";
+      return fetch(url).then(function(resp) {
+        if (!resp.ok) return null;
+        return resp.arrayBuffer();
+      }).then(function(buf) {
+        if (!buf) return;
+        return ctx().decodeAudioData(buf);
+      }).then(function(decoded) {
+        if (decoded) sampleBuffers[instrument][note] = decoded;
+      }).catch(function() {
+        console.warn("[aimeat-audio] Failed to load sample:", url);
+      });
+    }));
+  }
+  function hasSamples(instrument) {
+    return !!sampleBuffers[instrument] && Object.keys(sampleBuffers[instrument]).length > 0;
+  }
+  function findNearestSample(instrument, note) {
+    var samples = sampleBuffers[instrument];
+    if (!samples) return null;
+    if (instrument === "drums") return samples[note] ? { buffer: samples[note], rate: 1 } : null;
+    var targetFreq = noteToFreq(note);
+    if (!targetFreq) return null;
+    var nearest = null;
+    var nearestDist = Infinity;
+    Object.keys(samples).forEach(function(sn) {
+      var sf = noteToFreq(sn);
+      if (!sf) return;
+      var dist = Math.abs(Math.log2(targetFreq / sf));
+      if (dist < nearestDist) {
+        nearestDist = dist;
+        nearest = { buffer: samples[sn], rate: targetFreq / sf };
+      }
+    });
+    return nearest;
+  }
+  function playSample(instrument, note, opts) {
+    var s = findNearestSample(instrument, note);
+    if (!s) return false;
+    var vel = opts && opts.velocity !== void 0 ? opts.velocity : 0.7;
+    var source = ctx().createBufferSource();
+    source.buffer = s.buffer;
+    source.playbackRate.value = s.rate;
+    var gain = ctx().createGain();
+    gain.gain.value = vel;
+    source.connect(gain);
+    gain.connect(masterNode());
+    source.start();
+    registerActive(instrument, note, [source], function() {
+      try {
+        source.stop();
+      } catch {
+      }
+    });
+    return true;
+  }
+  function createCustomSynth(config) {
+    var name = config.name || "custom-" + Date.now();
+    var oscConfigs = config.oscillators || [{ wave: "sawtooth", detune: 0 }];
+    var envConfig = config.envelope || { attack: 0.01, decay: 0.1, sustain: 0.7, release: 0.1 };
+    var filterConfig = config.filter || null;
+    var pitchEnvConfig = config.pitchEnvelope || null;
+    var effectsConfig = config.effects || [];
+    function buildEffectChain(input) {
+      var current = input;
+      effectsConfig.forEach(function(fx) {
+        if (fx.type === "distortion") {
+          var ws = ctx().createWaveShaper();
+          var amount = fx.amount || 0.5;
+          var k = amount * 400;
+          var samples = 44100;
+          var curve = new Float32Array(samples);
+          for (var i = 0; i < samples; i++) {
+            var x = i * 2 / samples - 1;
+            curve[i] = (3 + k) * x * 20 * (Math.PI / 180) / (Math.PI + k * Math.abs(x));
+          }
+          ws.curve = curve;
+          current.connect(ws);
+          current = ws;
+        } else if (fx.type === "delay") {
+          var dryG = ctx().createGain();
+          dryG.gain.value = 1 - (fx.mix || 0.3);
+          var wetG = ctx().createGain();
+          wetG.gain.value = fx.mix || 0.3;
+          var dly = ctx().createDelay(5);
+          dly.delayTime.value = fx.time || 0.3;
+          var fb = ctx().createGain();
+          fb.gain.value = fx.feedback || 0.4;
+          current.connect(dryG);
+          current.connect(dly);
+          dly.connect(fb);
+          fb.connect(dly);
+          dly.connect(wetG);
+          var merge = ctx().createGain();
+          dryG.connect(merge);
+          wetG.connect(merge);
+          current = merge;
+        } else if (fx.type === "chorus") {
+          var cDry = ctx().createGain();
+          cDry.gain.value = 1 - (fx.mix || 0.5);
+          var cWet = ctx().createGain();
+          cWet.gain.value = fx.mix || 0.5;
+          var cDelay = ctx().createDelay();
+          cDelay.delayTime.value = 0.02;
+          var cLfo = ctx().createOscillator();
+          cLfo.type = "sine";
+          cLfo.frequency.value = fx.rate || 1.5;
+          var cDepth = ctx().createGain();
+          cDepth.gain.value = (fx.depth || 0.7) * 0.01;
+          cLfo.connect(cDepth);
+          cDepth.connect(cDelay.delayTime);
+          cLfo.start();
+          current.connect(cDry);
+          current.connect(cDelay);
+          cDelay.connect(cWet);
+          var cMerge = ctx().createGain();
+          cDry.connect(cMerge);
+          cWet.connect(cMerge);
+          current = cMerge;
+        } else if (fx.type === "tremolo") {
+          var trem = ctx().createGain();
+          var tLfo = ctx().createOscillator();
+          tLfo.type = "sine";
+          tLfo.frequency.value = fx.rate || 4;
+          var tDepth = ctx().createGain();
+          tDepth.gain.value = fx.depth || 0.5;
+          tLfo.connect(tDepth);
+          tDepth.connect(trem.gain);
+          tLfo.start();
+          trem.gain.value = 1 - (fx.depth || 0.5) / 2;
+          current.connect(trem);
+          current = trem;
+        } else if (fx.type === "reverb") {
+          var rDry = ctx().createGain();
+          rDry.gain.value = 1 - (fx.mix || 0.5);
+          var rWet = ctx().createGain();
+          rWet.gain.value = fx.mix || 0.5;
+          var d1 = ctx().createDelay();
+          d1.delayTime.value = 0.037;
+          var d2 = ctx().createDelay();
+          d2.delayTime.value = 0.053;
+          var d3 = ctx().createDelay();
+          d3.delayTime.value = 0.071;
+          var rFb = Math.min(0.85, (fx.decay || 2) / 5);
+          var fg1 = ctx().createGain();
+          fg1.gain.value = rFb;
+          var fg2 = ctx().createGain();
+          fg2.gain.value = rFb * 0.9;
+          var fg3 = ctx().createGain();
+          fg3.gain.value = rFb * 0.8;
+          d1.connect(fg1);
+          fg1.connect(d1);
+          d2.connect(fg2);
+          fg2.connect(d2);
+          d3.connect(fg3);
+          fg3.connect(d3);
+          current.connect(rDry);
+          current.connect(d1);
+          current.connect(d2);
+          current.connect(d3);
+          var rMerge = ctx().createGain();
+          rDry.connect(rMerge);
+          d1.connect(rWet);
+          d2.connect(rWet);
+          d3.connect(rWet);
+          rWet.connect(rMerge);
+          current = rMerge;
+        } else if (fx.type === "filter") {
+          var ff = ctx().createBiquadFilter();
+          ff.type = fx.filterType || "lowpass";
+          ff.frequency.value = fx.frequency || 1e3;
+          ff.Q.value = fx.Q || 1;
+          current.connect(ff);
+          current = ff;
+        }
+      });
+      return current;
+    }
+    var synth = {
+      name,
+      play: function(note, opts) {
+        var freq = noteToFreq(note);
+        if (!freq) return;
+        var t = ctx().currentTime;
+        var vel = opts && opts.velocity !== void 0 ? opts.velocity : 0.7;
+        var dur = opts && opts.duration || 1;
+        var allOscs = [];
+        var mix = ctx().createGain();
+        mix.gain.value = vel * 0.4 / oscConfigs.length;
+        oscConfigs.forEach(function(oc) {
+          var o = ctx().createOscillator();
+          o.type = oc.wave || "sawtooth";
+          o.frequency.value = freq;
+          o.detune.value = oc.detune || 0;
+          if (oc.gain !== void 0) {
+            var og = ctx().createGain();
+            og.gain.value = oc.gain;
+            o.connect(og);
+            og.connect(mix);
+          } else {
+            o.connect(mix);
+          }
+          allOscs.push(o);
+        });
+        var chain = mix;
+        if (filterConfig) {
+          var cf = ctx().createBiquadFilter();
+          cf.type = filterConfig.type || "lowpass";
+          cf.frequency.value = filterConfig.frequency || 1e3;
+          cf.Q.value = filterConfig.Q || 1;
+          mix.connect(cf);
+          chain = cf;
+        }
+        chain = buildEffectChain(chain);
+        var env = ctx().createGain();
+        var a = envConfig.attack || 0.01;
+        var d = envConfig.decay || 0.1;
+        var s = envConfig.sustain !== void 0 ? envConfig.sustain : 0.7;
+        var r = envConfig.release || 0.1;
+        env.gain.setValueAtTime(0, t);
+        env.gain.linearRampToValueAtTime(1, t + a);
+        env.gain.linearRampToValueAtTime(s, t + a + d);
+        if (dur) {
+          env.gain.setValueAtTime(s, t + dur - r);
+          env.gain.linearRampToValueAtTime(0, t + dur);
+        }
+        chain.connect(env);
+        env.connect(masterNode());
+        if (pitchEnvConfig) {
+          allOscs.forEach(function(o) {
+            o.frequency.setValueAtTime(pitchEnvConfig.start || freq, t);
+            o.frequency.exponentialRampToValueAtTime(pitchEnvConfig.end || freq, t + (pitchEnvConfig.time || 0.1));
+          });
+        }
+        allOscs.forEach(function(o) {
+          o.start(t);
+          if (dur) o.stop(t + dur + 0.1);
+        });
+        registerActive(name, note, allOscs, function() {
+          try {
+            env.gain.cancelScheduledValues(ctx().currentTime);
+            env.gain.linearRampToValueAtTime(0, ctx().currentTime + 0.05);
+            allOscs.forEach(function(o) {
+              try {
+                o.stop(ctx().currentTime + 0.1);
+              } catch {
+              }
+            });
+          } catch {
+          }
+        });
+      },
+      stop: function(note) {
+        stopActive(name, note);
+      }
+    };
+    instruments[name] = synth;
+    customSynths[name] = synth;
+    return synth;
+  }
+  var _rtInstance = null;
+  var _rtHandlerBroadcast = null;
+  var _rtHandlerPeerData = null;
+  function connectRealtime(rt) {
+    if (_rtInstance) disconnectRealtime();
+    _rtInstance = rt;
+    _rtHandlerBroadcast = function(msg) {
+      var d = msg.data || msg.payload || msg;
+      if (d && d.instrument && (d.note || d.hit)) {
+        audio.play(d.instrument, d.note || d.hit, d);
+      }
+    };
+    _rtHandlerPeerData = function(msg) {
+      var d = msg.data;
+      if (d && d.instrument && (d.note || d.hit)) {
+        audio.play(d.instrument, d.note || d.hit, d);
+      }
+    };
+    rt.on("broadcast", _rtHandlerBroadcast);
+    rt.on("peer-data", _rtHandlerPeerData);
+  }
+  function disconnectRealtime() {
+    if (_rtInstance) {
+      if (_rtHandlerBroadcast) _rtInstance.off("broadcast", _rtHandlerBroadcast);
+      if (_rtHandlerPeerData) _rtInstance.off("peer-data", _rtHandlerPeerData);
+      _rtInstance = null;
+      _rtHandlerBroadcast = null;
+      _rtHandlerPeerData = null;
+    }
+  }
+  var audio = {
+    play: function(instrument, note, opts) {
+      if (sampleBuffers[instrument] && Object.keys(sampleBuffers[instrument]).length > 0) {
+        if (playSample(instrument, note, opts)) return;
+      }
+      if (customSynths[instrument]) {
+        customSynths[instrument].play(note, opts);
+        return;
+      }
+      var inst = instruments[instrument];
+      if (!inst) {
+        console.warn("[aimeat-audio] Unknown instrument:", instrument);
+        return;
+      }
+      inst.play(note, opts);
+    },
+    stop: function(instrument, note) {
+      stopActive(instrument, note);
+    },
+    get instruments() {
+      var list = Object.keys(instruments);
+      Object.keys(customSynths).forEach(function(k) {
+        if (list.indexOf(k) < 0) list.push(k);
+      });
+      return list;
+    },
+    loadSamples,
+    hasSamples,
+    synth: createCustomSynth,
+    soundboard,
+    master,
+    connectRealtime,
+    disconnectRealtime
+  };
+  attach("audio", audio);
+})();