supersonic-scsynth 0.1.8 → 0.1.9

package/README.md

@@ -21,11 +21,11 @@ A WebAssembly port of SuperCollider's scsynth audio synthesis engine for the bro
   await sonic.loadSynthDefs(['sonic-pi-beep']);
 
   // Trigger the synth
-  sonic.send('/s_new', 'sonic-pi-beep', -1, 0, 1, 'note', 60);
+  sonic.send('/s_new', 'sonic-pi-beep', -1, 0, 0, 'note', 60);
 
   // Load and play a sample
   sonic.send('/b_allocRead', 0, 'bd_haus.flac');
-  sonic.send('/s_new', 'sonic-pi-basic_mono_player', -1, 0, 1, 'buf', 0);
+  sonic.send('/s_new', 'sonic-pi-basic_mono_player', -1, 0, 0, 'buf', 0);
 </script>
 ```
 
@@ -90,7 +90,7 @@ const sonic = new SuperSonic({
 **Common OSC commands:**
 ```javascript
 sonic.send('/notify', 1);                              // Enable notifications
-sonic.send('/s_new', 'synth-name', -1, 0, 1);         // Create synth
+sonic.send('/s_new', 'synth-name', -1, 0, 0);         // Create synth
 sonic.send('/n_set', 1000, 'freq', 440.0, 'amp', 0.5); // Set parameters
 sonic.send('/n_free', 1000);                            // Free node
 sonic.send('/b_allocRead', 0, 'sample.flac');          // Load audio buffer

package/dist/supersonic.js

@@ -1,301 +1,3 @@
-// js/lib/scsynth_osc.js
-var ScsynthOSC = class {
-  constructor() {
-    this.workers = {
-      oscOut: null,
-      oscIn: null,
-      debug: null
-    };
-    this.callbacks = {
-      onOSCMessage: null,
-      onDebugMessage: null,
-      onError: null,
-      onInitialized: null
-    };
-    this.initialized = false;
-    this.sharedBuffer = null;
-    this.ringBufferBase = null;
-    this.bufferConstants = null;
-  }
-  /**
-   * Initialize all workers with SharedArrayBuffer
-   */
-  async init(sharedBuffer, ringBufferBase, bufferConstants) {
-    if (this.initialized) {
-      console.warn("[ScsynthOSC] Already initialized");
-      return;
-    }
-    this.sharedBuffer = sharedBuffer;
-    this.ringBufferBase = ringBufferBase;
-    this.bufferConstants = bufferConstants;
-    try {
-      this.workers.oscOut = new Worker("./dist/workers/osc_out_worker.js");
-      this.workers.oscIn = new Worker("./dist/workers/osc_in_worker.js");
-      this.workers.debug = new Worker("./dist/workers/debug_worker.js");
-      this.setupWorkerHandlers();
-      const initPromises = [
-        this.initWorker(this.workers.oscOut, "OSC OUT"),
-        this.initWorker(this.workers.oscIn, "OSC IN"),
-        this.initWorker(this.workers.debug, "DEBUG")
-      ];
-      await Promise.all(initPromises);
-      this.workers.oscIn.postMessage({ type: "start" });
-      this.workers.debug.postMessage({ type: "start" });
-      this.initialized = true;
-      if (this.callbacks.onInitialized) {
-        this.callbacks.onInitialized();
-      }
-    } catch (error) {
-      console.error("[ScsynthOSC] Initialization failed:", error);
-      if (this.callbacks.onError) {
-        this.callbacks.onError(error);
-      }
-      throw error;
-    }
-  }
-  /**
-   * Initialize a single worker
-   */
-  initWorker(worker, name) {
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error(`${name} worker initialization timeout`));
-      }, 5e3);
-      const handler = (event) => {
-        if (event.data.type === "initialized") {
-          clearTimeout(timeout);
-          worker.removeEventListener("message", handler);
-          resolve();
-        }
-      };
-      worker.addEventListener("message", handler);
-      worker.postMessage({
-        type: "init",
-        sharedBuffer: this.sharedBuffer,
-        ringBufferBase: this.ringBufferBase,
-        bufferConstants: this.bufferConstants
-      });
-    });
-  }
-  /**
-   * Set up message handlers for all workers
-   */
-  setupWorkerHandlers() {
-    this.workers.oscIn.onmessage = (event) => {
-      const data = event.data;
-      switch (data.type) {
-        case "messages":
-          if (this.callbacks.onOSCMessage) {
-            data.messages.forEach((msg) => {
-              this.callbacks.onOSCMessage(msg);
-            });
-          }
-          break;
-        case "error":
-          console.error("[ScsynthOSC] OSC IN error:", data.error);
-          if (this.callbacks.onError) {
-            this.callbacks.onError(data.error, "oscIn");
-          }
-          break;
-      }
-    };
-    this.workers.debug.onmessage = (event) => {
-      const data = event.data;
-      switch (data.type) {
-        case "debug":
-          if (this.callbacks.onDebugMessage) {
-            data.messages.forEach((msg) => {
-              this.callbacks.onDebugMessage(msg);
-            });
-          }
-          break;
-        case "error":
-          console.error("[ScsynthOSC] DEBUG error:", data.error);
-          if (this.callbacks.onError) {
-            this.callbacks.onError(data.error, "debug");
-          }
-          break;
-      }
-    };
-    this.workers.oscOut.onmessage = (event) => {
-      const data = event.data;
-      switch (data.type) {
-        case "error":
-          console.error("[ScsynthOSC] OSC OUT error:", data.error);
-          if (this.callbacks.onError) {
-            this.callbacks.onError(data.error, "oscOut");
-          }
-          break;
-      }
-    };
-  }
-  /**
-   * Send OSC data (message or bundle)
-   * - OSC messages are sent immediately
-   * - OSC bundles are scheduled based on waitTimeMs (calculated by SuperSonic)
-   *
-   * @param {Uint8Array} oscData - Binary OSC data (message or bundle)
-   * @param {Object} options - Optional metadata (editorId, runTag, waitTimeMs)
-   */
-  send(oscData, options = {}) {
-    if (!this.initialized) {
-      console.error("[ScsynthOSC] Not initialized");
-      return;
-    }
-    const { editorId = 0, runTag = "", waitTimeMs = null } = options;
-    this.workers.oscOut.postMessage({
-      type: "send",
-      oscData,
-      editorId,
-      runTag,
-      waitTimeMs
-    });
-  }
-  /**
-   * Send OSC data immediately, ignoring any bundle timestamps
-   * - Extracts all messages from bundles
-   * - Sends all messages immediately to scsynth
-   * - For applications that don't expect server-side scheduling
-   *
-   * @param {Uint8Array} oscData - Binary OSC data (message or bundle)
-   */
-  sendImmediate(oscData) {
-    if (!this.initialized) {
-      console.error("[ScsynthOSC] Not initialized");
-      return;
-    }
-    this.workers.oscOut.postMessage({
-      type: "sendImmediate",
-      oscData
-    });
-  }
-  /**
-   * Cancel scheduled OSC bundles by editor and tag
-   */
-  cancelEditorTag(editorId, runTag) {
-    if (!this.initialized) return;
-    this.workers.oscOut.postMessage({
-      type: "cancelEditorTag",
-      editorId,
-      runTag
-    });
-  }
-  /**
-   * Cancel all scheduled OSC bundles from an editor
-   */
-  cancelEditor(editorId) {
-    if (!this.initialized) return;
-    this.workers.oscOut.postMessage({
-      type: "cancelEditor",
-      editorId
-    });
-  }
-  /**
-   * Cancel all scheduled OSC bundles
-   */
-  cancelAll() {
-    if (!this.initialized) return;
-    this.workers.oscOut.postMessage({
-      type: "cancelAll"
-    });
-  }
-  /**
-   * Clear debug buffer
-   */
-  clearDebug() {
-    if (!this.initialized) return;
-    this.workers.debug.postMessage({
-      type: "clear"
-    });
-  }
-  /**
-   * Get statistics from all workers
-   */
-  async getStats() {
-    if (!this.initialized) {
-      return null;
-    }
-    const statsPromises = [
-      this.getWorkerStats(this.workers.oscOut, "oscOut"),
-      this.getWorkerStats(this.workers.oscIn, "oscIn"),
-      this.getWorkerStats(this.workers.debug, "debug")
-    ];
-    const results = await Promise.all(statsPromises);
-    return {
-      oscOut: results[0],
-      oscIn: results[1],
-      debug: results[2]
-    };
-  }
-  /**
-   * Get stats from a single worker
-   */
-  getWorkerStats(worker, name) {
-    return new Promise((resolve) => {
-      const timeout = setTimeout(() => {
-        resolve({ error: "Timeout getting stats" });
-      }, 1e3);
-      const handler = (event) => {
-        if (event.data.type === "stats") {
-          clearTimeout(timeout);
-          worker.removeEventListener("message", handler);
-          resolve(event.data.stats);
-        }
-      };
-      worker.addEventListener("message", handler);
-      worker.postMessage({ type: "getStats" });
-    });
-  }
-  /**
-   * Set callback for OSC messages received from scsynth
-   */
-  onOSCMessage(callback) {
-    this.callbacks.onOSCMessage = callback;
-  }
-  /**
-   * Set callback for debug messages
-   */
-  onDebugMessage(callback) {
-    this.callbacks.onDebugMessage = callback;
-  }
-  /**
-   * Set callback for errors
-   */
-  onError(callback) {
-    this.callbacks.onError = callback;
-  }
-  /**
-   * Set callback for initialization complete
-   */
-  onInitialized(callback) {
-    this.callbacks.onInitialized = callback;
-  }
-  /**
-   * Terminate all workers and cleanup
-   */
-  terminate() {
-    if (this.workers.oscOut) {
-      this.workers.oscOut.postMessage({ type: "stop" });
-      this.workers.oscOut.terminate();
-    }
-    if (this.workers.oscIn) {
-      this.workers.oscIn.postMessage({ type: "stop" });
-      this.workers.oscIn.terminate();
-    }
-    if (this.workers.debug) {
-      this.workers.debug.postMessage({ type: "stop" });
-      this.workers.debug.terminate();
-    }
-    this.workers = {
-      oscOut: null,
-      oscIn: null,
-      debug: null
-    };
-    this.initialized = false;
-    console.log("[ScsynthOSC] All workers terminated");
-  }
-};
-
 // js/vendor/osc.js/osc.js
 var osc = {};
 var osc = osc || {};
@@ -879,188 +581,494 @@ EventEmitter.prototype.removeListener = function() {
       osc.fireBundleEvents(port, packet, timeTag, packetInfo);
     }
   };
-  osc.fireBundleEvents = function(port, bundle, timeTag, packetInfo) {
-    port.emit("bundle", bundle, timeTag, packetInfo);
-    for (var i = 0; i < bundle.packets.length; i++) {
-      var packet = bundle.packets[i];
-      osc.firePacketEvents(port, packet, bundle.timeTag, packetInfo);
+  osc.fireBundleEvents = function(port, bundle, timeTag, packetInfo) {
+    port.emit("bundle", bundle, timeTag, packetInfo);
+    for (var i = 0; i < bundle.packets.length; i++) {
+      var packet = bundle.packets[i];
+      osc.firePacketEvents(port, packet, bundle.timeTag, packetInfo);
+    }
+  };
+  osc.fireClosedPortSendError = function(port, msg) {
+    msg = msg || "Can't send packets on a closed osc.Port object. Please open (or reopen) this Port by calling open().";
+    port.emit("error", msg);
+  };
+  osc.Port = function(options) {
+    this.options = options || {};
+    this.on("data", this.decodeOSC.bind(this));
+  };
+  var p = osc.Port.prototype = Object.create(EventEmitter.prototype);
+  p.constructor = osc.Port;
+  p.send = function(oscPacket) {
+    var args = Array.prototype.slice.call(arguments), encoded = this.encodeOSC(oscPacket), buf = osc.nativeBuffer(encoded);
+    args[0] = buf;
+    this.sendRaw.apply(this, args);
+  };
+  p.encodeOSC = function(packet) {
+    packet = packet.buffer ? packet.buffer : packet;
+    var encoded;
+    try {
+      encoded = osc.writePacket(packet, this.options);
+    } catch (err) {
+      this.emit("error", err);
+    }
+    return encoded;
+  };
+  p.decodeOSC = function(data, packetInfo) {
+    data = osc.byteArray(data);
+    this.emit("raw", data, packetInfo);
+    try {
+      var packet = osc.readPacket(data, this.options);
+      this.emit("osc", packet, packetInfo);
+      osc.firePacketEvents(this, packet, void 0, packetInfo);
+    } catch (err) {
+      this.emit("error", err);
+    }
+  };
+  osc.SLIPPort = function(options) {
+    var that = this;
+    var o = this.options = options || {};
+    o.useSLIP = o.useSLIP === void 0 ? true : o.useSLIP;
+    this.decoder = new slip.Decoder({
+      onMessage: this.decodeOSC.bind(this),
+      onError: function(err) {
+        that.emit("error", err);
+      }
+    });
+    var decodeHandler = o.useSLIP ? this.decodeSLIPData : this.decodeOSC;
+    this.on("data", decodeHandler.bind(this));
+  };
+  p = osc.SLIPPort.prototype = Object.create(osc.Port.prototype);
+  p.constructor = osc.SLIPPort;
+  p.encodeOSC = function(packet) {
+    packet = packet.buffer ? packet.buffer : packet;
+    var framed;
+    try {
+      var encoded = osc.writePacket(packet, this.options);
+      framed = slip.encode(encoded);
+    } catch (err) {
+      this.emit("error", err);
+    }
+    return framed;
+  };
+  p.decodeSLIPData = function(data, packetInfo) {
+    this.decoder.decode(data, packetInfo);
+  };
+  osc.relay = function(from, to, eventName, sendFnName, transformFn, sendArgs) {
+    eventName = eventName || "message";
+    sendFnName = sendFnName || "send";
+    transformFn = transformFn || function() {
+    };
+    sendArgs = sendArgs ? [null].concat(sendArgs) : [];
+    var listener = function(data) {
+      sendArgs[0] = data;
+      data = transformFn(data);
+      to[sendFnName].apply(to, sendArgs);
+    };
+    from.on(eventName, listener);
+    return {
+      eventName,
+      listener
+    };
+  };
+  osc.relayPorts = function(from, to, o) {
+    var eventName = o.raw ? "raw" : "osc", sendFnName = o.raw ? "sendRaw" : "send";
+    return osc.relay(from, to, eventName, sendFnName, o.transform);
+  };
+  osc.stopRelaying = function(from, relaySpec) {
+    from.removeListener(relaySpec.eventName, relaySpec.listener);
+  };
+  osc.Relay = function(port1, port2, options) {
+    var o = this.options = options || {};
+    o.raw = false;
+    this.port1 = port1;
+    this.port2 = port2;
+    this.listen();
+  };
+  p = osc.Relay.prototype = Object.create(EventEmitter.prototype);
+  p.constructor = osc.Relay;
+  p.open = function() {
+    this.port1.open();
+    this.port2.open();
+  };
+  p.listen = function() {
+    if (this.port1Spec && this.port2Spec) {
+      this.close();
+    }
+    this.port1Spec = osc.relayPorts(this.port1, this.port2, this.options);
+    this.port2Spec = osc.relayPorts(this.port2, this.port1, this.options);
+    var closeListener = this.close.bind(this);
+    this.port1.on("close", closeListener);
+    this.port2.on("close", closeListener);
+  };
+  p.close = function() {
+    osc.stopRelaying(this.port1, this.port1Spec);
+    osc.stopRelaying(this.port2, this.port2Spec);
+    this.emit("close", this.port1, this.port2);
+  };
+})();
+(function() {
+  "use strict";
+  osc.WebSocket = typeof WebSocket !== "undefined" ? WebSocket : void 0;
+  osc.WebSocketPort = function(options) {
+    osc.Port.call(this, options);
+    this.on("open", this.listen.bind(this));
+    this.socket = options.socket;
+    if (this.socket) {
+      if (this.socket.readyState === 1) {
+        osc.WebSocketPort.setupSocketForBinary(this.socket);
+        this.emit("open", this.socket);
+      } else {
+        this.open();
+      }
+    }
+  };
+  var p = osc.WebSocketPort.prototype = Object.create(osc.Port.prototype);
+  p.constructor = osc.WebSocketPort;
+  p.open = function() {
+    if (!this.socket || this.socket.readyState > 1) {
+      this.socket = new osc.WebSocket(this.options.url);
     }
+    osc.WebSocketPort.setupSocketForBinary(this.socket);
+    var that = this;
+    this.socket.onopen = function() {
+      that.emit("open", that.socket);
+    };
+    this.socket.onerror = function(err) {
+      that.emit("error", err);
+    };
   };
-  osc.fireClosedPortSendError = function(port, msg) {
-    msg = msg || "Can't send packets on a closed osc.Port object. Please open (or reopen) this Port by calling open().";
-    port.emit("error", msg);
+  p.listen = function() {
+    var that = this;
+    this.socket.onmessage = function(e) {
+      that.emit("data", e.data, e);
+    };
+    this.socket.onclose = function(e) {
+      that.emit("close", e);
+    };
+    that.emit("ready");
   };
-  osc.Port = function(options) {
-    this.options = options || {};
-    this.on("data", this.decodeOSC.bind(this));
+  p.sendRaw = function(encoded) {
+    if (!this.socket || this.socket.readyState !== 1) {
+      osc.fireClosedPortSendError(this);
+      return;
+    }
+    this.socket.send(encoded);
   };
-  var p = osc.Port.prototype = Object.create(EventEmitter.prototype);
-  p.constructor = osc.Port;
-  p.send = function(oscPacket) {
-    var args = Array.prototype.slice.call(arguments), encoded = this.encodeOSC(oscPacket), buf = osc.nativeBuffer(encoded);
-    args[0] = buf;
-    this.sendRaw.apply(this, args);
+  p.close = function(code, reason) {
+    this.socket.close(code, reason);
   };
-  p.encodeOSC = function(packet) {
-    packet = packet.buffer ? packet.buffer : packet;
-    var encoded;
-    try {
-      encoded = osc.writePacket(packet, this.options);
-    } catch (err) {
-      this.emit("error", err);
-    }
-    return encoded;
+  osc.WebSocketPort.setupSocketForBinary = function(socket) {
+    socket.binaryType = osc.isNode ? "nodebuffer" : "arraybuffer";
   };
-  p.decodeOSC = function(data, packetInfo) {
-    data = osc.byteArray(data);
-    this.emit("raw", data, packetInfo);
+})();
+var osc_default = osc;
+var { readPacket, writePacket, readMessage, writeMessage, readBundle, writeBundle } = osc;
+
+// js/lib/scsynth_osc.js
+var ScsynthOSC = class {
+  constructor() {
+    this.workers = {
+      oscOut: null,
+      oscIn: null,
+      debug: null
+    };
+    this.callbacks = {
+      onOSCMessage: null,
+      onDebugMessage: null,
+      onError: null,
+      onInitialized: null
+    };
+    this.initialized = false;
+    this.sharedBuffer = null;
+    this.ringBufferBase = null;
+    this.bufferConstants = null;
+  }
+  /**
+   * Initialize all workers with SharedArrayBuffer
+   */
+  async init(sharedBuffer, ringBufferBase, bufferConstants) {
+    if (this.initialized) {
+      console.warn("[ScsynthOSC] Already initialized");
+      return;
+    }
+    this.sharedBuffer = sharedBuffer;
+    this.ringBufferBase = ringBufferBase;
+    this.bufferConstants = bufferConstants;
     try {
-      var packet = osc.readPacket(data, this.options);
-      this.emit("osc", packet, packetInfo);
-      osc.firePacketEvents(this, packet, void 0, packetInfo);
-    } catch (err) {
-      this.emit("error", err);
+      this.workers.oscOut = new Worker("./dist/workers/osc_out_worker.js");
+      this.workers.oscIn = new Worker("./dist/workers/osc_in_worker.js");
+      this.workers.debug = new Worker("./dist/workers/debug_worker.js");
+      this.setupWorkerHandlers();
+      const initPromises = [
+        this.initWorker(this.workers.oscOut, "OSC OUT"),
+        this.initWorker(this.workers.oscIn, "OSC IN"),
+        this.initWorker(this.workers.debug, "DEBUG")
+      ];
+      await Promise.all(initPromises);
+      this.workers.oscIn.postMessage({ type: "start" });
+      this.workers.debug.postMessage({ type: "start" });
+      this.initialized = true;
+      if (this.callbacks.onInitialized) {
+        this.callbacks.onInitialized();
+      }
+    } catch (error) {
+      console.error("[ScsynthOSC] Initialization failed:", error);
+      if (this.callbacks.onError) {
+        this.callbacks.onError(error);
+      }
+      throw error;
     }
-  };
-  osc.SLIPPort = function(options) {
-    var that = this;
-    var o = this.options = options || {};
-    o.useSLIP = o.useSLIP === void 0 ? true : o.useSLIP;
-    this.decoder = new slip.Decoder({
-      onMessage: this.decodeOSC.bind(this),
-      onError: function(err) {
-        that.emit("error", err);
+  }
+  /**
+   * Initialize a single worker
+   */
+  initWorker(worker, name) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`${name} worker initialization timeout`));
+      }, 5e3);
+      const handler = (event) => {
+        if (event.data.type === "initialized") {
+          clearTimeout(timeout);
+          worker.removeEventListener("message", handler);
+          resolve();
+        }
+      };
+      worker.addEventListener("message", handler);
+      worker.postMessage({
+        type: "init",
+        sharedBuffer: this.sharedBuffer,
+        ringBufferBase: this.ringBufferBase,
+        bufferConstants: this.bufferConstants
+      });
+    });
+  }
+  /**
+   * Set up message handlers for all workers
+   */
+  setupWorkerHandlers() {
+    this.workers.oscIn.onmessage = (event) => {
+      const data = event.data;
+      switch (data.type) {
+        case "messages":
+          if (this.callbacks.onOSCMessage) {
+            data.messages.forEach((msg) => {
+              if (msg.oscData) {
+                try {
+                  const options = { metadata: false, unpackSingleArgs: false };
+                  const decoded = osc_default.readPacket(msg.oscData, options);
+                  this.callbacks.onOSCMessage(decoded);
+                } catch (e) {
+                  console.error("[ScsynthOSC] Failed to decode OSC message:", e, msg);
+                }
+              }
+            });
+          }
+          break;
+        case "error":
+          console.error("[ScsynthOSC] OSC IN error:", data.error);
+          if (this.callbacks.onError) {
+            this.callbacks.onError(data.error, "oscIn");
+          }
+          break;
+      }
+    };
+    this.workers.debug.onmessage = (event) => {
+      const data = event.data;
+      switch (data.type) {
+        case "debug":
+          if (this.callbacks.onDebugMessage) {
+            data.messages.forEach((msg) => {
+              this.callbacks.onDebugMessage(msg);
+            });
+          }
+          break;
+        case "error":
+          console.error("[ScsynthOSC] DEBUG error:", data.error);
+          if (this.callbacks.onError) {
+            this.callbacks.onError(data.error, "debug");
+          }
+          break;
+      }
+    };
+    this.workers.oscOut.onmessage = (event) => {
+      const data = event.data;
+      switch (data.type) {
+        case "error":
+          console.error("[ScsynthOSC] OSC OUT error:", data.error);
+          if (this.callbacks.onError) {
+            this.callbacks.onError(data.error, "oscOut");
+          }
+          break;
       }
+    };
+  }
+  /**
+   * Send OSC data (message or bundle)
+   * - OSC messages are sent immediately
+   * - OSC bundles are scheduled based on waitTimeMs (calculated by SuperSonic)
+   *
+   * @param {Uint8Array} oscData - Binary OSC data (message or bundle)
+   * @param {Object} options - Optional metadata (editorId, runTag, waitTimeMs)
+   */
+  send(oscData, options = {}) {
+    if (!this.initialized) {
+      console.error("[ScsynthOSC] Not initialized");
+      return;
+    }
+    const { editorId = 0, runTag = "", waitTimeMs = null } = options;
+    this.workers.oscOut.postMessage({
+      type: "send",
+      oscData,
+      editorId,
+      runTag,
+      waitTimeMs
+    });
+  }
+  /**
+   * Send OSC data immediately, ignoring any bundle timestamps
+   * - Extracts all messages from bundles
+   * - Sends all messages immediately to scsynth
+   * - For applications that don't expect server-side scheduling
+   *
+   * @param {Uint8Array} oscData - Binary OSC data (message or bundle)
+   */
+  sendImmediate(oscData) {
+    if (!this.initialized) {
+      console.error("[ScsynthOSC] Not initialized");
+      return;
+    }
+    this.workers.oscOut.postMessage({
+      type: "sendImmediate",
+      oscData
     });
-    var decodeHandler = o.useSLIP ? this.decodeSLIPData : this.decodeOSC;
-    this.on("data", decodeHandler.bind(this));
-  };
-  p = osc.SLIPPort.prototype = Object.create(osc.Port.prototype);
-  p.constructor = osc.SLIPPort;
-  p.encodeOSC = function(packet) {
-    packet = packet.buffer ? packet.buffer : packet;
-    var framed;
-    try {
-      var encoded = osc.writePacket(packet, this.options);
-      framed = slip.encode(encoded);
-    } catch (err) {
-      this.emit("error", err);
+  }
+  /**
+   * Cancel scheduled OSC bundles by editor and tag
+   */
+  cancelEditorTag(editorId, runTag) {
+    if (!this.initialized) return;
+    this.workers.oscOut.postMessage({
+      type: "cancelEditorTag",
+      editorId,
+      runTag
+    });
+  }
+  /**
+   * Cancel all scheduled OSC bundles from an editor
+   */
+  cancelEditor(editorId) {
+    if (!this.initialized) return;
+    this.workers.oscOut.postMessage({
+      type: "cancelEditor",
+      editorId
+    });
+  }
+  /**
+   * Cancel all scheduled OSC bundles
+   */
+  cancelAll() {
+    if (!this.initialized) return;
+    this.workers.oscOut.postMessage({
+      type: "cancelAll"
+    });
+  }
+  /**
+   * Clear debug buffer
+   */
+  clearDebug() {
+    if (!this.initialized) return;
+    this.workers.debug.postMessage({
+      type: "clear"
+    });
+  }
+  /**
+   * Get statistics from all workers
+   */
+  async getStats() {
+    if (!this.initialized) {
+      return null;
     }
-    return framed;
-  };
-  p.decodeSLIPData = function(data, packetInfo) {
-    this.decoder.decode(data, packetInfo);
-  };
-  osc.relay = function(from, to, eventName, sendFnName, transformFn, sendArgs) {
-    eventName = eventName || "message";
-    sendFnName = sendFnName || "send";
-    transformFn = transformFn || function() {
-    };
-    sendArgs = sendArgs ? [null].concat(sendArgs) : [];
-    var listener = function(data) {
-      sendArgs[0] = data;
-      data = transformFn(data);
-      to[sendFnName].apply(to, sendArgs);
-    };
-    from.on(eventName, listener);
+    const statsPromises = [
+      this.getWorkerStats(this.workers.oscOut, "oscOut"),
+      this.getWorkerStats(this.workers.oscIn, "oscIn"),
+      this.getWorkerStats(this.workers.debug, "debug")
+    ];
+    const results = await Promise.all(statsPromises);
     return {
-      eventName,
-      listener
+      oscOut: results[0],
+      oscIn: results[1],
+      debug: results[2]
     };
-  };
-  osc.relayPorts = function(from, to, o) {
-    var eventName = o.raw ? "raw" : "osc", sendFnName = o.raw ? "sendRaw" : "send";
-    return osc.relay(from, to, eventName, sendFnName, o.transform);
-  };
-  osc.stopRelaying = function(from, relaySpec) {
-    from.removeListener(relaySpec.eventName, relaySpec.listener);
-  };
-  osc.Relay = function(port1, port2, options) {
-    var o = this.options = options || {};
-    o.raw = false;
-    this.port1 = port1;
-    this.port2 = port2;
-    this.listen();
-  };
-  p = osc.Relay.prototype = Object.create(EventEmitter.prototype);
-  p.constructor = osc.Relay;
-  p.open = function() {
-    this.port1.open();
-    this.port2.open();
-  };
-  p.listen = function() {
-    if (this.port1Spec && this.port2Spec) {
-      this.close();
+  }
+  /**
+   * Get stats from a single worker
+   */
+  getWorkerStats(worker, name) {
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        resolve({ error: "Timeout getting stats" });
+      }, 1e3);
+      const handler = (event) => {
+        if (event.data.type === "stats") {
+          clearTimeout(timeout);
+          worker.removeEventListener("message", handler);
+          resolve(event.data.stats);
+        }
+      };
+      worker.addEventListener("message", handler);
+      worker.postMessage({ type: "getStats" });
+    });
+  }
+  /**
+   * Set callback for OSC messages received from scsynth
+   */
+  onOSCMessage(callback) {
+    this.callbacks.onOSCMessage = callback;
+  }
+  /**
+   * Set callback for debug messages
+   */
+  onDebugMessage(callback) {
+    this.callbacks.onDebugMessage = callback;
+  }
+  /**
+   * Set callback for errors
+   */
+  onError(callback) {
+    this.callbacks.onError = callback;
+  }
+  /**
+   * Set callback for initialization complete
+   */
+  onInitialized(callback) {
+    this.callbacks.onInitialized = callback;
+  }
+  /**
+   * Terminate all workers and cleanup
+   */
+  terminate() {
+    if (this.workers.oscOut) {
+      this.workers.oscOut.postMessage({ type: "stop" });
+      this.workers.oscOut.terminate();
     }
-    this.port1Spec = osc.relayPorts(this.port1, this.port2, this.options);
-    this.port2Spec = osc.relayPorts(this.port2, this.port1, this.options);
-    var closeListener = this.close.bind(this);
-    this.port1.on("close", closeListener);
-    this.port2.on("close", closeListener);
-  };
-  p.close = function() {
-    osc.stopRelaying(this.port1, this.port1Spec);
-    osc.stopRelaying(this.port2, this.port2Spec);
-    this.emit("close", this.port1, this.port2);
-  };
-})();
-(function() {
-  "use strict";
-  osc.WebSocket = typeof WebSocket !== "undefined" ? WebSocket : void 0;
-  osc.WebSocketPort = function(options) {
-    osc.Port.call(this, options);
-    this.on("open", this.listen.bind(this));
-    this.socket = options.socket;
-    if (this.socket) {
-      if (this.socket.readyState === 1) {
-        osc.WebSocketPort.setupSocketForBinary(this.socket);
-        this.emit("open", this.socket);
-      } else {
-        this.open();
-      }
+    if (this.workers.oscIn) {
+      this.workers.oscIn.postMessage({ type: "stop" });
+      this.workers.oscIn.terminate();
     }
-  };
-  var p = osc.WebSocketPort.prototype = Object.create(osc.Port.prototype);
-  p.constructor = osc.WebSocketPort;
-  p.open = function() {
-    if (!this.socket || this.socket.readyState > 1) {
-      this.socket = new osc.WebSocket(this.options.url);
+    if (this.workers.debug) {
+      this.workers.debug.postMessage({ type: "stop" });
+      this.workers.debug.terminate();
     }
-    osc.WebSocketPort.setupSocketForBinary(this.socket);
-    var that = this;
-    this.socket.onopen = function() {
-      that.emit("open", that.socket);
-    };
-    this.socket.onerror = function(err) {
-      that.emit("error", err);
-    };
-  };
-  p.listen = function() {
-    var that = this;
-    this.socket.onmessage = function(e) {
-      that.emit("data", e.data, e);
-    };
-    this.socket.onclose = function(e) {
-      that.emit("close", e);
+    this.workers = {
+      oscOut: null,
+      oscIn: null,
+      debug: null
     };
-    that.emit("ready");
-  };
-  p.sendRaw = function(encoded) {
-    if (!this.socket || this.socket.readyState !== 1) {
-      osc.fireClosedPortSendError(this);
-      return;
-    }
-    this.socket.send(encoded);
-  };
-  p.close = function(code, reason) {
-    this.socket.close(code, reason);
-  };
-  osc.WebSocketPort.setupSocketForBinary = function(socket) {
-    socket.binaryType = osc.isNode ? "nodebuffer" : "arraybuffer";
-  };
-})();
-var osc_default = osc;
-var { readPacket, writePacket, readMessage, writeMessage, readBundle, writeBundle } = osc;
+    this.initialized = false;
+    console.log("[ScsynthOSC] All workers terminated");
+  }
+};
 
 // node_modules/@thi.ng/api/typedarray.js
 var GL2TYPE = {
@@ -1596,6 +1604,7 @@ var SuperSonic = class {
     this.wasmModule = null;
     this.wasmInstance = null;
     this.bufferPool = null;
+    this.pendingBufferOps = /* @__PURE__ */ new Map();
     this.wasmTimeOffset = null;
     this._timeOffsetPromise = null;
     this._resolveTimeOffset = null;
@@ -1790,6 +1799,8 @@ var SuperSonic = class {
     this.osc.onOSCMessage((msg) => {
       if (msg.address === "/buffer/freed") {
         this._handleBufferFreed(msg.args);
+      } else if (msg.address === "/buffer/allocated") {
+        this._handleBufferAllocated(msg.args);
       }
       if (this.onMessageReceived) {
         this.stats.messagesReceived++;
@@ -2077,14 +2088,24 @@ var SuperSonic = class {
         ptr: allocatedPtr,
         size: bytesNeeded
       });
+      const uuid = crypto.randomUUID();
+      const allocationComplete = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          this.pendingBufferOps.delete(uuid);
+          reject(new Error(`Timeout waiting for buffer ${bufnum} allocation`));
+        }, 5e3);
+        this.pendingBufferOps.set(uuid, { resolve, reject, timeout });
+      });
       await this.send(
         "/b_allocPtr",
         bufnum,
         allocatedPtr,
         framesToRead,
         numChannels,
-        audioBuffer.sampleRate
+        audioBuffer.sampleRate,
+        uuid
       );
+      await allocationComplete;
       if (completionMsg) {
       }
     } catch (error) {
@@ -2114,10 +2135,6 @@ var SuperSonic = class {
    * Handle /buffer/freed message from WASM
    */
   _handleBufferFreed(args) {
-    if (args.length < 2) {
-      console.warn("[SuperSonic] Invalid /buffer/freed message:", args);
-      return;
-    }
     const bufnum = args[0];
     const offset = args[1];
     const bufferInfo = this.allocatedBuffers.get(bufnum);
@@ -2126,6 +2143,19 @@ var SuperSonic = class {
       this.allocatedBuffers.delete(bufnum);
     }
   }
+  /**
+   * Handle /buffer/allocated message with UUID correlation
+   */
+  _handleBufferAllocated(args) {
+    const uuid = args[0];
+    const bufnum = args[1];
+    const pending = this.pendingBufferOps.get(uuid);
+    if (pending) {
+      clearTimeout(pending.timeout);
+      pending.resolve({ bufnum });
+      this.pendingBufferOps.delete(uuid);
+    }
+  }
   /**
    * /b_allocReadChannel bufnum path [startFrame numFrames channel1 channel2 ... completion]
    * Load specific channels from an audio file
@@ -2287,6 +2317,18 @@ var SuperSonic = class {
     this.initialized = false;
     console.log("[SuperSonic] Destroyed");
   }
+  /**
+   * Load a sample into a buffer and wait for confirmation
+   * @param {number} bufnum - Buffer number
+   * @param {string} path - Audio file path
+   * @returns {Promise} Resolves when buffer is ready
+   */
+  async loadSample(bufnum, path, startFrame = 0, numFrames = 0) {
+    if (!this.initialized) {
+      throw new Error("SuperSonic not initialized. Call init() first.");
+    }
+    await this._allocReadBuffer(bufnum, path, startFrame, numFrames);
+  }
   /**
    * Load a binary synthdef file and send it to scsynth
    * @param {string} path - Path or URL to the .scsyndef file

package/dist/wasm/manifest.json

@@ -1,6 +1,6 @@
 {
   "wasmFile": "scsynth-nrt.wasm",
-  "buildId": "20251104-230238",
-  "buildTime": "2025-11-04T23:02:38Z",
-  "gitHash": "5d25004"
+  "buildId": "20251105-102519",
+  "buildTime": "2025-11-05T10:25:19Z",
+  "gitHash": "4ea9bb5"
 }

package/dist/workers/osc_in_worker.js

@@ -71,11 +71,7 @@ function readMessages() {
 
     var currentTail = tail;
     var messagesRead = 0;
-    // Process up to 10 messages per wake to balance:
-    // - Low latency (don't block too long processing)
-    // - Efficiency (batch processing when busy)
-    // - Prevents starvation of other tasks
-    var maxMessages = 10;
+    var maxMessages = 100;
 
     while (currentTail !== head && messagesRead < maxMessages) {
         var readPos = ringBufferBase + bufferConstants.OUT_BUFFER_START + currentTail;
@@ -115,7 +111,7 @@ function readMessages() {
             if (sequence !== expectedSeq) {
                 var dropped = (sequence - expectedSeq + 0x100000000) & 0xFFFFFFFF;
                 if (dropped < 1000) { // Sanity check
-                    console.warn('[OSCInWorker] Detected', dropped, 'dropped messages');
+                    console.warn('[OSCInWorker] Detected', dropped, 'dropped messages (expected seq', expectedSeq, 'got', sequence, ')');
                     stats.droppedMessages += dropped;
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supersonic-scsynth",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "SuperCollider scsynth WebAssembly port for AudioWorklet - Run SuperCollider synthesis in the browser",
   "main": "dist/supersonic.js",
   "unpkg": "dist/supersonic.js",