supersonic-scsynth 0.3.0 → 0.4.0

package/dist/supersonic.js

@@ -2098,6 +2098,12 @@ var SuperSonic = class _SuperSonic {
         this._handleBufferFreed(msg.args);
       } else if (msg.address === "/buffer/allocated") {
         this._handleBufferAllocated(msg.args);
+      } else if (msg.address === "/synced" && msg.args.length > 0) {
+        const syncId = msg.args[0];
+        if (this._syncListeners && this._syncListeners.has(syncId)) {
+          const listener = this._syncListeners.get(syncId);
+          listener(msg);
+        }
       }
       if (this.onMessage) {
         this.stats.messagesReceived++;
@@ -2512,7 +2518,7 @@ var SuperSonic = class _SuperSonic {
       if (synthName) {
         this.loadedSynthDefs.add(synthName);
       }
-      console.log(`[SuperSonic] Loaded synthdef from ${path} (${synthdefData.length} bytes)`);
+      console.log(`[SuperSonic] Sent synthdef from ${path} (${synthdefData.length} bytes)`);
     } catch (error) {
       console.error("[SuperSonic] Failed to load synthdef:", error);
       throw error;
@@ -2548,9 +2554,45 @@ var SuperSonic = class _SuperSonic {
       })
     );
     const successCount = Object.values(results).filter((r) => r.success).length;
-    console.log(`[SuperSonic] Loaded ${successCount}/${names.length} synthdefs`);
+    console.log(`[SuperSonic] Sent ${successCount}/${names.length} synthdef loads`);
     return results;
   }
+  /**
+   * Send /sync command and wait for /synced response
+   * Use this to ensure all previous asynchronous commands have completed
+   * @param {number} syncId - Unique integer identifier for this sync operation
+   * @returns {Promise<void>}
+   * @example
+   * await sonic.loadSynthDefs(['synth1', 'synth2']);
+   * await sonic.sync(12345); // Wait for all synthdefs to be processed
+   */
+  async sync(syncId) {
+    if (!this.initialized) {
+      throw new Error("SuperSonic not initialized. Call init() first.");
+    }
+    if (!Number.isInteger(syncId)) {
+      throw new Error("sync() requires an integer syncId parameter");
+    }
+    const syncPromise = new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        if (this._syncListeners) {
+          this._syncListeners.delete(syncId);
+        }
+        reject(new Error("Timeout waiting for /synced response"));
+      }, 1e4);
+      const messageHandler = (msg) => {
+        clearTimeout(timeout);
+        this._syncListeners.delete(syncId);
+        resolve();
+      };
+      if (!this._syncListeners) {
+        this._syncListeners = /* @__PURE__ */ new Map();
+      }
+      this._syncListeners.set(syncId, messageHandler);
+    });
+    await this.send("/sync", syncId);
+    await syncPromise;
+  }
   /**
    * Allocate memory for an audio buffer (includes guard samples)
    * @param {number} numSamples - Number of Float32 samples to allocate

package/dist/wasm/manifest.json

@@ -1,6 +1,6 @@
 {
   "wasmFile": "scsynth-nrt.wasm",
-  "buildId": "20251117-205541",
-  "buildTime": "2025-11-17T20:55:41Z",
-  "gitHash": "264e2ae"
+  "buildId": "20251118-093603",
+  "buildTime": "2025-11-18T09:36:03Z",
+  "gitHash": "d43c4be"
 }

package/dist/workers/osc_out_prescheduler_worker.js

@@ -171,40 +171,55 @@ function writeToRingBuffer(oscMessage, isRetry) {
         return false;
     }
 
-    // Check if message fits contiguously
+    // ringbuf.js approach: split writes across wrap boundary
+    // No padding markers - just split the write into two parts if it wraps
+
     var spaceToEnd = bufferConstants.IN_BUFFER_SIZE - head;
 
     if (totalSize > spaceToEnd) {
+        // Message will wrap - write in two parts
+        // Create header as byte array to simplify split writes
+        var headerBytes = new Uint8Array(bufferConstants.MESSAGE_HEADER_SIZE);
+        var headerView = new DataView(headerBytes.buffer);
+        headerView.setUint32(0, bufferConstants.MESSAGE_MAGIC, true);
+        headerView.setUint32(4, totalSize, true);
+        headerView.setUint32(8, stats.bundlesWritten, true);
+        headerView.setUint32(12, 0, true);
+
+        var writePos1 = ringBufferBase + bufferConstants.IN_BUFFER_START + head;
+        var writePos2 = ringBufferBase + bufferConstants.IN_BUFFER_START;
+
+        // Write header (may be split)
         if (spaceToEnd >= bufferConstants.MESSAGE_HEADER_SIZE) {
-            // Write padding marker and wrap
-            var paddingPos = ringBufferBase + bufferConstants.IN_BUFFER_START + head;
-            dataView.setUint32(paddingPos, bufferConstants.PADDING_MAGIC, true);
-            dataView.setUint32(paddingPos + 4, 0, true);
-            dataView.setUint32(paddingPos + 8, 0, true);
-            dataView.setUint32(paddingPos + 12, 0, true);
-        } else if (spaceToEnd > 0) {
-            // Not enough room for a padding header - clear remaining bytes
-            var padStart = ringBufferBase + bufferConstants.IN_BUFFER_START + head;
-            for (var i = 0; i < spaceToEnd; i++) {
-                uint8View[padStart + i] = 0;
-            }
-        }
+            // Header fits contiguously
+            uint8View.set(headerBytes, writePos1);
 
-        // Wrap to beginning
-        head = 0;
-    }
+            // Write payload (split across boundary)
+            var payloadBytesInFirstPart = spaceToEnd - bufferConstants.MESSAGE_HEADER_SIZE;
+            uint8View.set(oscMessage.subarray(0, payloadBytesInFirstPart), writePos1 + bufferConstants.MESSAGE_HEADER_SIZE);
+            uint8View.set(oscMessage.subarray(payloadBytesInFirstPart), writePos2);
+        } else {
+            // Header is split across boundary
+            uint8View.set(headerBytes.subarray(0, spaceToEnd), writePos1);
+            uint8View.set(headerBytes.subarray(spaceToEnd), writePos2);
 
-    // Write message
-    var writePos = ringBufferBase + bufferConstants.IN_BUFFER_START + head;
+            // All payload goes at beginning
+            var payloadOffset = bufferConstants.MESSAGE_HEADER_SIZE - spaceToEnd;
+            uint8View.set(oscMessage, writePos2 + payloadOffset);
+        }
+    } else {
+        // Message fits contiguously - write normally
+        var writePos = ringBufferBase + bufferConstants.IN_BUFFER_START + head;
 
-    // Write header
-    dataView.setUint32(writePos, bufferConstants.MESSAGE_MAGIC, true);
-    dataView.setUint32(writePos + 4, totalSize, true);
-    dataView.setUint32(writePos + 8, stats.bundlesWritten, true); // sequence
-    dataView.setUint32(writePos + 12, 0, true); // padding
+        // Write header
+        dataView.setUint32(writePos, bufferConstants.MESSAGE_MAGIC, true);
+        dataView.setUint32(writePos + 4, totalSize, true);
+        dataView.setUint32(writePos + 8, stats.bundlesWritten, true);
+        dataView.setUint32(writePos + 12, 0, true);
 
-    // Write payload
-    uint8View.set(oscMessage, writePos + bufferConstants.MESSAGE_HEADER_SIZE);
+        // Write payload
+        uint8View.set(oscMessage, writePos + bufferConstants.MESSAGE_HEADER_SIZE);
+    }
 
     // Diagnostic: Log first few writes
     if (stats.bundlesWritten < 5) {

package/package.json

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