supersonic-scsynth 0.1.8 → 0.2.0

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": "20251112-224002",
+  "buildTime": "2025-11-12T22:40:02Z",
+  "gitHash": "82a71b5"
 }

package/dist/workers/debug_worker.js

@@ -29,6 +29,13 @@ var CONTROL_INDICES = {};
 // Worker state
 var running = false;
 
+var DEBUG_DEBUGWORKER_LOGS = false;
+function debugWorkerLog() {
+    if (DEBUG_DEBUGWORKER_LOGS) {
+        console.log.apply(console, arguments);
+    }
+}
+
 // Statistics
 var stats = {
     messagesReceived: 0,
@@ -69,12 +76,18 @@ function readDebugMessages() {
     var messages = [];
     var currentTail = tail;
     var messagesRead = 0;
-    var maxMessages = 10; // Process up to 10 messages per wake
+    var maxMessages = 1000; // Process up to 1000 messages per wake
 
     while (currentTail !== head && messagesRead < maxMessages) {
+        var bytesToEnd = bufferConstants.DEBUG_BUFFER_SIZE - currentTail;
+        if (bytesToEnd < bufferConstants.MESSAGE_HEADER_SIZE) {
+            currentTail = 0;
+            continue;
+        }
+
         var readPos = ringBufferBase + bufferConstants.DEBUG_BUFFER_START + currentTail;
 
-        // Read message header (now always contiguous due to padding)
+        // Read message header (now contiguous or wrapped)
         var magic = dataView.getUint32(readPos, true);
 
         // Check for padding marker - skip to beginning
@@ -271,4 +284,4 @@ self.onmessage = function(event) {
     }
 };
 
-console.log('[DebugWorker] Script loaded');
+debugWorkerLog('[DebugWorker] Script loaded');

package/dist/workers/osc_in_worker.js

@@ -29,6 +29,13 @@ var CONTROL_INDICES = {};
 // Worker state
 var running = false;
 
+var DEBUG_OSCIN_LOGS = false;
+function oscInLog() {
+    if (DEBUG_OSCIN_LOGS) {
+        console.log.apply(console, arguments);
+    }
+}
+
 // Statistics
 var stats = {
     messagesReceived: 0,
@@ -71,16 +78,18 @@ 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 bytesToEnd = bufferConstants.OUT_BUFFER_SIZE - currentTail;
+        if (bytesToEnd < bufferConstants.MESSAGE_HEADER_SIZE) {
+            currentTail = 0;
+            continue;
+        }
+
         var readPos = ringBufferBase + bufferConstants.OUT_BUFFER_START + currentTail;
 
-        // Read message header (now always contiguous due to padding)
+        // Read message header (now contiguous or wrapped)
         var magic = dataView.getUint32(readPos, true);
 
         // Check for padding marker - skip to beginning
@@ -115,7 +124,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;
                 }
             }
@@ -271,4 +280,4 @@ self.onmessage = function(event) {
     }
 };
 
-console.log('[OSCInWorker] Script loaded');
+oscInLog('[OSCInWorker] Script loaded');

package/dist/workers/osc_out_prescheduler_worker.js

@@ -0,0 +1,575 @@
+/*
+    SuperSonic - OSC Pre-Scheduler Worker
+    Ports the Bleep pre-scheduler design:
+    - Single priority queue of future bundles/events
+    - One timer driving dispatch (no per-event setTimeout storm)
+    - Tag-based cancellation to drop pending runs before they hit WASM
+*/
+
+// Shared memory for ring buffer writing
+var sharedBuffer = null;
+var ringBufferBase = null;
+var bufferConstants = null;
+var atomicView = null;
+var dataView = null;
+var uint8View = null;
+
+// Ring buffer control indices
+var CONTROL_INDICES = {};
+
+// Priority queue implemented as binary min-heap
+// Entries: { ntpTime, seq, editorId, runTag, oscData }
+var eventHeap = [];
+var periodicTimer = null;    // Single periodic timer (25ms interval)
+var sequenceCounter = 0;
+var isDispatching = false;  // Prevent reentrancy into dispatch loop
+
+// Statistics
+var stats = {
+    bundlesScheduled: 0,
+    bundlesWritten: 0,
+    bundlesDropped: 0,
+    bufferOverruns: 0,
+    eventsPending: 0,
+    maxEventsPending: 0,
+    eventsCancelled: 0,
+    totalDispatches: 0,
+    totalLateDispatchMs: 0,
+    maxLateDispatchMs: 0,
+    totalSendTasks: 0,
+    totalSendProcessMs: 0,
+    maxSendProcessMs: 0
+};
+
+// Timing constants
+var NTP_EPOCH_OFFSET = 2208988800;  // Seconds from 1900-01-01 to 1970-01-01
+var POLL_INTERVAL_MS = 25;           // Check every 25ms
+var LOOKAHEAD_S = 0.100;             // 100ms lookahead window
+
+function schedulerLog() {
+    // Toggle to true for verbose diagnostics
+    var DEBUG = true;  // Enable for debugging
+    if (DEBUG) {
+        console.log.apply(console, arguments);
+    }
+}
+
+// ============================================================================
+// NTP TIME HELPERS
+// ============================================================================
+
+/**
+ * Get current NTP time from system clock
+ *
+ * Bundles contain full NTP timestamps. We just need to compare them against
+ * current NTP time (system clock) to know when to dispatch.
+ *
+ * AudioContext timing, drift correction, etc. are handled by the C++ side.
+ * The prescheduler only needs to know "what time is it now in NTP?"
+ */
+function getCurrentNTP() {
+    // Convert current system time to NTP
+    var perfTimeMs = performance.timeOrigin + performance.now();
+    return (perfTimeMs / 1000) + NTP_EPOCH_OFFSET;
+}
+
+/**
+ * Extract NTP timestamp from OSC bundle
+ * Returns NTP time in seconds (double), or null if not a bundle
+ */
+function extractNTPFromBundle(oscData) {
+    if (oscData.length >= 16 && oscData[0] === 0x23) {  // '#bundle'
+        var view = new DataView(oscData.buffer, oscData.byteOffset);
+        var ntpSeconds = view.getUint32(8, false);
+        var ntpFraction = view.getUint32(12, false);
+        return ntpSeconds + ntpFraction / 0x100000000;
+    }
+    return null;
+}
+
+/**
+ * Legacy wrapper for backwards compatibility
+ */
+function getBundleTimestamp(oscMessage) {
+    return extractNTPFromBundle(oscMessage);
+}
+
+// ============================================================================
+// SHARED ARRAY BUFFER ACCESS
+// ============================================================================
+
+/**
+ * Initialize ring buffer access for writing directly to SharedArrayBuffer
+ */
+function initSharedBuffer() {
+    if (!sharedBuffer || !bufferConstants) {
+        console.error('[PreScheduler] Cannot init - missing buffer or constants');
+        return;
+    }
+
+    atomicView = new Int32Array(sharedBuffer);
+    dataView = new DataView(sharedBuffer);
+    uint8View = new Uint8Array(sharedBuffer);
+
+    // Calculate control indices for ring buffer
+    CONTROL_INDICES = {
+        IN_HEAD: (ringBufferBase + bufferConstants.CONTROL_START + 0) / 4,
+        IN_TAIL: (ringBufferBase + bufferConstants.CONTROL_START + 4) / 4
+    };
+
+    console.log('[PreScheduler] SharedArrayBuffer initialized with direct ring buffer writing');
+}
+
+/**
+ * Write OSC message directly to ring buffer (replaces MessagePort to writer worker)
+ * This is now the ONLY place that writes to the ring buffer
+ */
+function writeToRingBuffer(oscMessage) {
+    if (!sharedBuffer || !atomicView) {
+        console.error('[PreScheduler] Not initialized for ring buffer writing');
+        stats.bundlesDropped++;
+        return false;
+    }
+
+    var payloadSize = oscMessage.length;
+    var totalSize = bufferConstants.MESSAGE_HEADER_SIZE + payloadSize;
+
+    // Check if message fits in buffer at all
+    if (totalSize > bufferConstants.IN_BUFFER_SIZE - bufferConstants.MESSAGE_HEADER_SIZE) {
+        console.error('[PreScheduler] Message too large:', totalSize);
+        stats.bundlesDropped++;
+        return false;
+    }
+
+    // Try to write (non-blocking, single attempt)
+    var head = Atomics.load(atomicView, CONTROL_INDICES.IN_HEAD);
+    var tail = Atomics.load(atomicView, CONTROL_INDICES.IN_TAIL);
+
+    // Calculate available space
+    var available = (bufferConstants.IN_BUFFER_SIZE - 1 - head + tail) % bufferConstants.IN_BUFFER_SIZE;
+
+    if (available < totalSize) {
+        // Buffer full - drop message (prescheduler should not block)
+        stats.bufferOverruns++;
+        stats.bundlesDropped++;
+        console.warn('[PreScheduler] Ring buffer full, dropping message');
+        return false;
+    }
+
+    // Check if message fits contiguously
+    var spaceToEnd = bufferConstants.IN_BUFFER_SIZE - head;
+
+    if (totalSize > spaceToEnd) {
+        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;
+            }
+        }
+
+        // Wrap to beginning
+        head = 0;
+    }
+
+    // Write message
+    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 payload
+    uint8View.set(oscMessage, writePos + bufferConstants.MESSAGE_HEADER_SIZE);
+
+    // Update head pointer (publish message)
+    var newHead = (head + totalSize) % bufferConstants.IN_BUFFER_SIZE;
+    Atomics.store(atomicView, CONTROL_INDICES.IN_HEAD, newHead);
+
+    stats.bundlesWritten++;
+    return true;
+}
+
+/**
+ * Schedule an OSC bundle by its NTP timestamp
+ * Non-bundles or bundles without timestamps are dispatched immediately
+ */
+function scheduleEvent(oscData, editorId, runTag) {
+    var ntpTime = extractNTPFromBundle(oscData);
+
+    if (ntpTime === null) {
+        // Not a bundle - dispatch immediately to ring buffer
+        schedulerLog('[PreScheduler] Non-bundle message, dispatching immediately');
+        writeToRingBuffer(oscData);
+        return;
+    }
+
+    var currentNTP = getCurrentNTP();
+    var timeUntilExec = ntpTime - currentNTP;
+
+    // Create event with NTP timestamp
+    var event = {
+        ntpTime: ntpTime,
+        seq: sequenceCounter++,
+        editorId: editorId || 0,
+        runTag: runTag || '',
+        oscData: oscData
+    };
+
+    heapPush(event);
+
+    stats.bundlesScheduled++;
+    stats.eventsPending = eventHeap.length;
+    if (stats.eventsPending > stats.maxEventsPending) {
+        stats.maxEventsPending = stats.eventsPending;
+    }
+
+    schedulerLog('[PreScheduler] Scheduled bundle:',
+                 'NTP=' + ntpTime.toFixed(3),
+                 'current=' + currentNTP.toFixed(3),
+                 'wait=' + (timeUntilExec * 1000).toFixed(1) + 'ms',
+                 'pending=' + stats.eventsPending);
+}
+
+function heapPush(event) {
+    eventHeap.push(event);
+    siftUp(eventHeap.length - 1);
+}
+
+function heapPeek() {
+    return eventHeap.length > 0 ? eventHeap[0] : null;
+}
+
+function heapPop() {
+    if (eventHeap.length === 0) {
+        return null;
+    }
+    var top = eventHeap[0];
+    var last = eventHeap.pop();
+    if (eventHeap.length > 0) {
+        eventHeap[0] = last;
+        siftDown(0);
+    }
+    return top;
+}
+
+function siftUp(index) {
+    while (index > 0) {
+        var parent = Math.floor((index - 1) / 2);
+        if (compareEvents(eventHeap[index], eventHeap[parent]) >= 0) {
+            break;
+        }
+        swap(index, parent);
+        index = parent;
+    }
+}
+
+function siftDown(index) {
+    var length = eventHeap.length;
+    while (true) {
+        var left = 2 * index + 1;
+        var right = 2 * index + 2;
+        var smallest = index;
+
+        if (left < length && compareEvents(eventHeap[left], eventHeap[smallest]) < 0) {
+            smallest = left;
+        }
+        if (right < length && compareEvents(eventHeap[right], eventHeap[smallest]) < 0) {
+            smallest = right;
+        }
+        if (smallest === index) {
+            break;
+        }
+        swap(index, smallest);
+        index = smallest;
+    }
+}
+
+function compareEvents(a, b) {
+    if (a.ntpTime === b.ntpTime) {
+        return a.seq - b.seq;
+    }
+    return a.ntpTime - b.ntpTime;
+}
+
+function swap(i, j) {
+    var tmp = eventHeap[i];
+    eventHeap[i] = eventHeap[j];
+    eventHeap[j] = tmp;
+}
+
+/**
+ * Start periodic polling (called once on init)
+ */
+function startPeriodicPolling() {
+    if (periodicTimer !== null) {
+        console.warn('[PreScheduler] Polling already started');
+        return;
+    }
+
+    console.log('[PreScheduler] Starting periodic polling (every ' + POLL_INTERVAL_MS + 'ms)');
+    checkAndDispatch();  // Start immediately
+}
+
+/**
+ * Stop periodic polling
+ */
+function stopPeriodicPolling() {
+    if (periodicTimer !== null) {
+        clearTimeout(periodicTimer);
+        periodicTimer = null;
+        console.log('[PreScheduler] Stopped periodic polling');
+    }
+}
+
+/**
+ * Periodic check and dispatch function
+ * Uses NTP timestamps and global offset for drift-free timing
+ */
+function checkAndDispatch() {
+    isDispatching = true;
+
+    var currentNTP = getCurrentNTP();
+    var lookaheadTime = currentNTP + LOOKAHEAD_S;
+    var dispatchCount = 0;
+    var dispatchStart = performance.now();
+
+    // Dispatch all bundles that are ready
+    while (eventHeap.length > 0) {
+        var nextEvent = heapPeek();
+
+        if (nextEvent.ntpTime <= lookaheadTime) {
+            // Ready to dispatch
+            heapPop();
+            stats.eventsPending = eventHeap.length;
+
+            var timeUntilExec = nextEvent.ntpTime - currentNTP;
+            stats.totalDispatches++;
+
+            schedulerLog('[PreScheduler] Dispatching bundle:',
+                        'NTP=' + nextEvent.ntpTime.toFixed(3),
+                        'current=' + currentNTP.toFixed(3),
+                        'early=' + (timeUntilExec * 1000).toFixed(1) + 'ms',
+                        'remaining=' + stats.eventsPending);
+
+            writeToRingBuffer(nextEvent.oscData);
+            dispatchCount++;
+        } else {
+            // Rest aren't ready yet (heap is sorted)
+            break;
+        }
+    }
+
+    if (dispatchCount > 0 || eventHeap.length > 0) {
+        schedulerLog('[PreScheduler] Dispatch cycle complete:',
+                    'dispatched=' + dispatchCount,
+                    'pending=' + eventHeap.length);
+    }
+
+    isDispatching = false;
+
+    // Reschedule for next check (fixed interval)
+    periodicTimer = setTimeout(checkAndDispatch, POLL_INTERVAL_MS);
+}
+
+function cancelBy(predicate) {
+    if (eventHeap.length === 0) {
+        return;
+    }
+
+    var before = eventHeap.length;
+    var remaining = [];
+
+    for (var i = 0; i < eventHeap.length; i++) {
+        var event = eventHeap[i];
+        if (!predicate(event)) {
+            remaining.push(event);
+        }
+    }
+
+    var removed = before - remaining.length;
+    if (removed > 0) {
+        eventHeap = remaining;
+        heapify();
+        stats.eventsCancelled += removed;
+        stats.eventsPending = eventHeap.length;
+        console.log('[PreScheduler] Cancelled ' + removed + ' events, ' + eventHeap.length + ' remaining');
+    }
+}
+
+function heapify() {
+    for (var i = Math.floor(eventHeap.length / 2) - 1; i >= 0; i--) {
+        siftDown(i);
+    }
+}
+
+function cancelEditorTag(editorId, runTag) {
+    cancelBy(function(event) {
+        return event.editorId === editorId && event.runTag === runTag;
+    });
+}
+
+function cancelEditor(editorId) {
+    cancelBy(function(event) {
+        return event.editorId === editorId;
+    });
+}
+
+function cancelAllTags() {
+    if (eventHeap.length === 0) {
+        return;
+    }
+    var cancelled = eventHeap.length;
+    stats.eventsCancelled += cancelled;
+    eventHeap = [];
+    stats.eventsPending = 0;
+    console.log('[PreScheduler] Cancelled all ' + cancelled + ' events');
+    // Note: Periodic timer continues running (it will just find empty queue)
+}
+
+// Helpers reused from legacy worker for immediate send
+function isBundle(data) {
+    if (!data || data.length < 8) {
+        return false;
+    }
+    return data[0] === 0x23 && data[1] === 0x62 && data[2] === 0x75 && data[3] === 0x6e &&
+        data[4] === 0x64 && data[5] === 0x6c && data[6] === 0x65 && data[7] === 0x00;
+}
+
+function extractMessagesFromBundle(data) {
+    var messages = [];
+    var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    var offset = 16; // skip "#bundle\0" + timetag
+
+    while (offset < data.length) {
+        var messageSize = view.getInt32(offset, false);
+        offset += 4;
+
+        if (messageSize <= 0 || offset + messageSize > data.length) {
+            break;
+        }
+
+        var messageData = data.slice(offset, offset + messageSize);
+        messages.push(messageData);
+        offset += messageSize;
+
+        while (offset % 4 !== 0 && offset < data.length) {
+            offset++;
+        }
+    }
+
+    return messages;
+}
+
+function processImmediate(oscData) {
+    if (isBundle(oscData)) {
+        var messages = extractMessagesFromBundle(oscData);
+        for (var i = 0; i < messages.length; i++) {
+            writeToRingBuffer(messages[i]);
+        }
+    } else {
+        writeToRingBuffer(oscData);
+    }
+}
+
+// Message handling
+self.onmessage = function(event) {
+    var data = event.data;
+
+    try {
+        switch (data.type) {
+            case 'init':
+                sharedBuffer = data.sharedBuffer;
+                ringBufferBase = data.ringBufferBase;
+                bufferConstants = data.bufferConstants;
+
+                // Initialize SharedArrayBuffer views (including offset)
+                initSharedBuffer();
+
+                // Start periodic polling
+                startPeriodicPolling();
+
+                schedulerLog('[OSCPreSchedulerWorker] Initialized with NTP-based scheduling and direct ring buffer writing');
+                self.postMessage({ type: 'initialized' });
+                break;
+
+            case 'send':
+                var sendStart = performance.now();
+
+                // New NTP-based scheduling: extract NTP from bundle
+                // scheduleEvent() will dispatch immediately if not a bundle
+                scheduleEvent(
+                    data.oscData,
+                    data.editorId || 0,
+                    data.runTag || ''
+                );
+
+                var sendDuration = performance.now() - sendStart;
+                stats.totalSendTasks++;
+                stats.totalSendProcessMs += sendDuration;
+                if (sendDuration > stats.maxSendProcessMs) {
+                    stats.maxSendProcessMs = sendDuration;
+                }
+                break;
+
+            case 'sendImmediate':
+                processImmediate(data.oscData);
+                break;
+
+            case 'cancelEditorTag':
+                if (data.runTag !== undefined && data.runTag !== null && data.runTag !== '') {
+                    cancelEditorTag(data.editorId || 0, data.runTag);
+                }
+                break;
+
+            case 'cancelEditor':
+                cancelEditor(data.editorId || 0);
+                break;
+
+            case 'cancelAll':
+                cancelAllTags();
+                break;
+
+            case 'getStats':
+                self.postMessage({
+                    type: 'stats',
+                    stats: {
+                        bundlesScheduled: stats.bundlesScheduled,
+                        bundlesWritten: stats.bundlesWritten,
+                        bundlesDropped: stats.bundlesDropped,
+                        bufferOverruns: stats.bufferOverruns,
+                        eventsPending: stats.eventsPending,
+                        maxEventsPending: stats.maxEventsPending,
+                        eventsCancelled: stats.eventsCancelled,
+                        totalDispatches: stats.totalDispatches,
+                        totalLateDispatchMs: stats.totalLateDispatchMs,
+                        maxLateDispatchMs: stats.maxLateDispatchMs,
+                        totalSendTasks: stats.totalSendTasks,
+                        totalSendProcessMs: stats.totalSendProcessMs,
+                        maxSendProcessMs: stats.maxSendProcessMs
+                    }
+                });
+                break;
+
+            default:
+                console.warn('[OSCPreSchedulerWorker] Unknown message type:', data.type);
+        }
+    } catch (error) {
+        console.error('[OSCPreSchedulerWorker] Error:', error);
+        self.postMessage({
+            type: 'error',
+            error: error.message
+        });
+    }
+};
+
+schedulerLog('[OSCPreSchedulerWorker] Script loaded');