expo-juce 0.5.2-rc.1 → 0.5.2

package/README.md

@@ -24,7 +24,7 @@ iOS only for now; the Android and web modules are scaffolds.
  juce::AudioDeviceManager ─► GraphPlayer (AudioIODeviceCallback: graph, peaks, NaNs, test tone)
         │
  juce::AudioProcessorGraph  PolySynthProcessor ─► audio output node
-                            ├─ SPSC note queue (256) drained at block start
+                            ├─ NoteEventQueue: note-on ring (256) drained at block start; releases as marks
                             ├─ 8 × Voice: dsp::Oscillator → StateVariableTPTFilter (LP) → ADSR
                             └─ TransportEngine (tempo / position / beat crossings)
 ```
@@ -39,7 +39,7 @@ expo-juce is being built toward full audio workstation capabilities. The work is
 Replaced the mono SynthEngine + AVAudioEngine with a JUCE-owned audio stack built on `AudioProcessorGraph`. 8-voice polyphonic synth with per-voice oscillator, SVF filter, and full ADSR envelope. MIDI-style API (`noteOn(note, velocity)` / `noteOff(note)`). JUCE owns device management and output for cross-platform support (iOS, macOS, Windows, Linux).
 
 ### Diagnostics, recovery and latency
-**Status:** Diagnostics done (0.5.2-diag.x); recovery and latency margin in 0.5.2 — see the [latency guide](docs/latency.md)
+**Status:** Diagnostics done (0.5.2-diag.x); recovery and latency margin in 0.5.2 — see the [latency guide](docs/latency.md). TODO: latency measurement and interruption / route-change device checks ([list](docs/latency.md#todo-device-checks-pending-for-052))
 
 `setup()` rejects with the failing step, `getDiagnostics()` exposes every layer from device callbacks to synth peak, `playTestTone()` bypasses the graph, an offline harness reproduces the device callback on Linux. Root causes of the first on-device silence (fixed 2026-10-22): a stale Metro bundle running the app on stubs, infinite recursion in `-setBeatCallback:`, `setup()` always resolving, and expo-av switching the shared session to Ambient. 0.5.2 adds: 128-sample buffer, no allocation on the audio thread, native `JucePadView` touch path, 2 ms default attack, session re-assert and interruption / media-reset recovery (keeping synth settings and transport state across rebuilds).
 
@@ -92,7 +92,8 @@ await ExpoJuce.setup();
 // 0.5.2+: optional device request (defaults 128 samples / 48 kHz; actual values may differ)
 // await ExpoJuce.setup({ bufferSize: 128, sampleRate: 48000 });
 
-// Notes — synchronous; pushed onto a lock-free single-producer queue read by the audio thread
+// Notes — synchronous, never wait on a lock; the audio thread picks them up at the next block
+// (note-offs and allNotesOff are never dropped, even mid-recovery)
 ExpoJuce.noteOn(60, 127);   // note 0–127, velocity 0–127
 ExpoJuce.noteOff(60);
 ExpoJuce.allNotesOff();

package/ios/ExpoJuce.podspec

@@ -42,6 +42,7 @@ Pod::Spec.new do |s|
     "PolySynthProcessor.h",
     "TransportEngine.h",
     "GraphPlayer.h",
+    "NoteEventQueue.h",
   ]
 
   # JUCE modules: each compiled as its own translation unit (separate .mm file)

package/ios/ExpoJuceAudioEngine.mm

@@ -72,7 +72,8 @@ static TransportEngine* sTransport = nullptr;
 // ── Engine lifecycle lock ──
 // Guards the pointers above (and isReady) between the lifecycle code, which runs only on the
 // main thread and takes the lock blocking (setup / teardown / rebuild / device restart), and the
-// users that dereference them (JS thread, and JucePadView on the main thread).
+// users that dereference them (JS thread, and JucePadView on the main thread). Note input
+// (noteOn / noteOff / allNotesOff) does not use it: it goes through sNoteQueue below.
 // Rules that keep it deadlock-free:
 //  - Lifecycle sections take it at exactly one level (setupWithBufferSize, shutdown, dead-device reopen,
 //    rebuild, device restart); everything they call under it is a *Locked helper that never
@@ -83,13 +84,23 @@ static TransportEngine* sTransport = nullptr;
 //    section at the same time, so the only other holder is a short user section). Users on
 //    other threads use try_lock: if the lifecycle holds it, the call is dropped (safe default
 //    returned) and counted in lockBusyDrops. A short user section on another thread is waited
-//    out with a bounded retry so a note-off is not dropped for a microsecond of contention.
+//    out with a bounded retry so a parameter change is not dropped for a microsecond of contention.
 // The audio thread never takes this lock.
 static std::mutex sEngineLock;
 static std::atomic<bool> sLifecycleBusy{false};       // true while a lifecycle section holds sEngineLock
 static std::atomic<uint64_t> sLockBusyDrops{0};
 static std::atomic<uint64_t> sDeadDeviceRestarts{0};
 
+// ── Note input ──
+// One queue for the life of the process (never deleted, unlike the synth), so producers need
+// no lock: note-ons go into its ring, releases are marks the synth applies every block (see
+// NoteEventQueue.h). A release can therefore not be dropped by lock contention, a full ring, or
+// a device reopen (the synth applies it on the first block after the device restarts).
+// Note-ons are accepted only while the engine is ready (sAcceptingNotes); setup discards
+// note-ons left in the ring before the new synth is attached, so nothing stale plays.
+static NoteEventQueue sNoteQueue;
+static std::atomic<bool> sAcceptingNotes{false};
+
 // RAII: holds sEngineLock for a lifecycle section (main thread, blocking) and flags it busy.
 struct LifecycleLock {
     std::lock_guard<std::mutex> guard;
@@ -185,7 +196,11 @@ static void withTransport(ExpoJuceAudioEngine *engine, void (^body)(TransportEng
         LifecycleLock lifecycle;
         ok = [self setupEngineLocked];
         // Setup after a failed rebuild (retry pending or given up) continues that recovery.
-        if (ok) [self restoreRecoveryStateLocked];
+        // Note-ons are accepted only once the restored settings are in place.
+        if (ok) {
+            [self restoreRecoveryStateLocked];
+            sAcceptingNotes.store(true, std::memory_order_release);
+        }
     }
     if (ok) {
         [self registerSessionObservers];
@@ -320,6 +335,10 @@ static void withTransport(ExpoJuceAudioEngine *engine, void (^body)(TransportEng
     auto synthProcessor = std::make_unique<PolySynthProcessor>();
     sSynth = synthProcessor.get();
     sSynth->setTransport(sTransport);
+    // Nothing drains sNoteQueue until the player is attached (step 11), so this thread may act
+    // as its consumer here: note-ons left from before (a failed or replaced engine) are dropped.
+    sNoteQueue.discardPending();
+    sSynth->setNoteQueue(&sNoteQueue);
 
     self.setupStep = 7;
     NSLog(@"[ExpoJuceAudioEngine] Step 7: addNode (synth)");
@@ -402,6 +421,7 @@ static void withTransport(ExpoJuceAudioEngine *engine, void (^body)(TransportEng
 // Main thread, caller holds sEngineLock. Deletes everything doSetup built (any subset).
 - (void)teardownEngineLocked {
     NSLog(@"[ExpoJuceAudioEngine] Tearing down engine...");
+    sAcceptingNotes.store(false, std::memory_order_release);
     self.isReady = false;
     if (sDeviceManager && sPlayer) sDeviceManager->removeAudioCallback(sPlayer);
     delete sPlayer; sPlayer = nullptr;
@@ -444,7 +464,7 @@ static void withTransport(ExpoJuceAudioEngine *engine, void (^body)(TransportEng
     [self stopBeatTimer];
     {
         LifecycleLock lifecycle;
-        if (sSynth) sSynth->allNotesOff();
+        sNoteQueue.pushAllNotesOff();
         [self teardownEngineLocked];
     }
     NSLog(@"[ExpoJuceAudioEngine] Shutdown complete");
@@ -701,10 +721,13 @@ static void withTransport(ExpoJuceAudioEngine *engine, void (^body)(TransportEng
     BOOL ok = NO;
     {
         LifecycleLock lifecycle;
-        if (sSynth) sSynth->allNotesOff();
+        sNoteQueue.pushAllNotesOff();
         [self teardownEngineLocked];
         ok = [self setupEngineLocked];
-        if (ok) [self restoreRecoveryStateLocked];
+        if (ok) {
+            [self restoreRecoveryStateLocked];
+            sAcceptingNotes.store(true, std::memory_order_release);
+        }
     }
 
     if (ok) {
@@ -794,15 +817,16 @@ static void withTransport(ExpoJuceAudioEngine *engine, void (^body)(TransportEng
             if (synth) {
                 synthProcessCount = (double)synth->diag.processCount.load(relaxed);
                 synthPeak = (double)synth->diag.peak.load(relaxed);
-                notesQueued = (double)synth->diag.notesQueued.load(relaxed);
-                notesConsumed = (double)synth->diag.notesConsumed.load(relaxed);
-                notesDropped = (double)synth->diag.notesDropped.load(relaxed);
                 activeVoices = synth->diag.activeVoices.load(relaxed);
                 lastNoteToRenderMs = synth->diag.lastNoteToRenderMs.load(relaxed);
                 lastTouchToRenderMs = synth->diag.lastTouchToRenderMs.load(relaxed);
             }
         }
     }
+    // Note counters: cumulative since launch, read from the process-lifetime queue (no lock).
+    notesQueued = (double)sNoteQueue.notesQueued.load(std::memory_order_relaxed);
+    notesConsumed = (double)sNoteQueue.notesConsumed.load(std::memory_order_relaxed);
+    notesDropped = (double)sNoteQueue.notesDropped.load(std::memory_order_relaxed);
 
     d[@"isReady"] = @(ready);
     d[@"setupStep"] = @(self.setupStep);
@@ -877,14 +901,13 @@ static void withTransport(ExpoJuceAudioEngine *engine, void (^body)(TransportEng
 }
 
 // ── Synth forwarding ──
-// Each call holds sEngineLock (acquireUserLock) while it dereferences sSynth / sTransport; if
-// the lifecycle holds it, the call is dropped and the safe default returned.
+// Notes go through sNoteQueue without the lock (see "Note input"). Every other call holds
+// sEngineLock (acquireUserLock) while it dereferences sSynth / sTransport; if the lifecycle
+// holds it, the call is dropped and the safe default returned.
 
 - (void)noteOn:(int)note velocity:(int)velocity {
-    std::unique_lock<std::mutex> lock(sEngineLock, std::defer_lock);
-    if (!acquireUserLock(lock)) return;
-    if (!self.isReady || !sSynth) return;
-    sSynth->noteOn(note, velocity);
+    if (!sAcceptingNotes.load(std::memory_order_acquire)) return;
+    sNoteQueue.pushNoteOn(note, velocity);
 }
 
 - (void)noteOn:(int)note velocity:(int)velocity touchTimestamp:(double)touchTimestamp {
@@ -893,25 +916,14 @@ static void withTransport(ExpoJuceAudioEngine *engine, void (^body)(TransportEng
     const juce::int64 touchTicks = (touchTimestamp > 0.0)
         ? juce::Time::secondsToHighResolutionTicks(touchTimestamp)
         : (juce::int64)0;
-    std::unique_lock<std::mutex> lock(sEngineLock, std::defer_lock);
-    if (!acquireUserLock(lock)) return;
-    if (!self.isReady || !sSynth) return;
-    sSynth->noteOn(note, velocity, touchTicks);
+    if (!sAcceptingNotes.load(std::memory_order_acquire)) return;
+    sNoteQueue.pushNoteOn(note, velocity, touchTicks);
 }
 
-- (void)noteOff:(int)note {
-    std::unique_lock<std::mutex> lock(sEngineLock, std::defer_lock);
-    if (!acquireUserLock(lock)) return;
-    if (!self.isReady || !sSynth) return;
-    sSynth->noteOff(note);
-}
-
-- (void)allNotesOff {
-    std::unique_lock<std::mutex> lock(sEngineLock, std::defer_lock);
-    if (!acquireUserLock(lock)) return;
-    if (!self.isReady || !sSynth) return;
-    sSynth->allNotesOff();
-}
+// Releases are always recorded, ready or not: a release must reach a voice that is still
+// sounding whatever the engine is doing (a mark with nothing to release is harmless).
+- (void)noteOff:(int)note { sNoteQueue.pushNoteOff(note); }
+- (void)allNotesOff { sNoteQueue.pushAllNotesOff(); }
 
 - (void)setWaveform:(NSString *)waveform {
     Waveform wf = Waveform::Sine;

package/ios/GraphPlayer.h

@@ -17,6 +17,10 @@
 // No allocation on the audio thread: the render buffer is sized in
 // audioDeviceAboutToStart (>= 2x the device buffer, >= 1024 samples). A device block
 // larger than that is rendered in chunks of at most the preallocated capacity.
+// The graph's own render is allocation-free only with the vendored JUCE patch
+// graph-output-buffer-no-realloc (src/scripts/juce-patches.cjs): unpatched,
+// AudioProcessorGraph reallocates its output buffer whenever the block length changes.
+// The harness counts allocations inside this callback and fails on any.
 class GraphPlayer : public juce::AudioIODeviceCallback {
 public:
     static constexpr int minCapacitySamples = 1024;

package/ios/JucePadView.swift

@@ -11,8 +11,11 @@ class JucePadView: ExpoView {
 
   var note: Int = 60
   var velocity: Int = 100
+  // Disabled pads leave hit-testing entirely, so touches reach the views underneath (forwarding
+  // to super would only walk the responder chain, which does not include siblings).
   var enabled: Bool = true {
     didSet {
+      isUserInteractionEnabled = enabled
       if !enabled {
         releaseAllTouches()
       }

package/ios/NoteEventQueue.h

@@ -0,0 +1,143 @@
+#pragma once
+
+// Pure C++ (no Objective-C): used by PolySynthProcessor, ExpoJuceAudioEngine.mm and the
+// offline harness (test/harness).
+
+#include "JuceConfig.h"
+#include <juce_core/juce_core.h>
+#include <algorithm>
+#include <atomic>
+#include <cstdint>
+#include <thread>
+
+// A note-on waiting for the audio thread.
+struct NoteEvent {
+    int note;               // 0–127
+    int velocity;
+    uint64_t seq;           // NoteEventQueue sequence number (1, 2, …), compared with the release marks
+    juce::int64 stampTicks; // juce::Time::getHighResolutionTicks() at enqueue
+    juce::int64 touchTicks; // originating UITouch.timestamp in high-res ticks (same clock); 0 if not a touch
+};
+
+// Note input for the synth: note-ons travel in a ring, releases are marks.
+//
+// Note-ons: multi-producer (main thread + JS thread, serialised by a spinlock), single consumer
+// (the audio thread, lock-free). A full ring drops the note-on (counted in notesDropped).
+//
+// Releases are level-triggered marks, not queued events, so nothing can drop them: noteOff(n)
+// raises releasedUpTo[n] to the sequence number of the latest note-on of n, allNotesOff raises
+// allReleasedUpTo to the latest note-on of any note. Every block the synth stops each held voice
+// whose note-on is at or below its mark (PolySynthProcessor::processBlock). A note-on pushed after
+// a release has a higher sequence number, so a release never cuts a later note. Producers only
+// store atomics: no lock to wait for, no slot to run out of.
+//
+// The engine keeps one queue for the life of the process, outside the objects a rebuild replaces,
+// so note input never needs the engine lock, and a release sent while the device is stopped or
+// being reopened is applied on the first block after it.
+class NoteEventQueue {
+public:
+    static constexpr int kSize = 256;
+
+    // ── Producers (any thread) ──
+
+    // Returns false if the ring is full (counted in notesDropped).
+    bool pushNoteOn(int note, int velocity, juce::int64 touchTicks = 0) {
+        note = std::clamp(note, 0, 127);
+        SpinGuard guard(producerLock);
+        const int wp = writePos.load(std::memory_order_relaxed);
+        const int next = (wp + 1) % kSize;
+        if (next == readPos.load(std::memory_order_acquire)) {
+            notesDropped.fetch_add(1, std::memory_order_relaxed);
+            return false;
+        }
+        const uint64_t seq = lastSeq.load(std::memory_order_relaxed) + 1;
+        ring[wp] = { note, velocity, seq, juce::Time::getHighResolutionTicks(), touchTicks };
+        lastOnSeq[note].store(seq, std::memory_order_release);
+        lastSeq.store(seq, std::memory_order_release);
+        // Count before publishing: the release-store below orders this increment ahead of the
+        // consumer's notesConsumed increment for the same event (consumed never exceeds queued).
+        notesQueued.fetch_add(1, std::memory_order_relaxed);
+        writePos.store(next, std::memory_order_release);
+        return true;
+    }
+
+    // Releases every note-on of `note` pushed so far.
+    void pushNoteOff(int note) {
+        if (note < 0 || note > 127) return;
+        raise(releasedUpTo[note], lastOnSeq[note].load(std::memory_order_acquire));
+    }
+
+    // Releases every note-on pushed so far.
+    void pushAllNotesOff() {
+        raise(allReleasedUpTo, lastSeq.load(std::memory_order_acquire));
+    }
+
+    // ── Consumer (the audio thread) ──
+
+    template <typename Handler>
+    void drainNoteOns(Handler&& onNoteOn) {
+        int rp = readPos.load(std::memory_order_relaxed);
+        const int wp = writePos.load(std::memory_order_acquire);
+        while (rp != wp) {
+            onNoteOn(ring[rp]);
+            notesConsumed.fetch_add(1, std::memory_order_relaxed);
+            rp = (rp + 1) % kSize;
+        }
+        readPos.store(rp, std::memory_order_release);
+    }
+
+    // True if the note-on `seq` of `note` has been released (seq 0 = not from this queue).
+    bool isReleased(int note, uint64_t seq) const {
+        if (seq == 0) return false;
+        uint64_t mark = allReleasedUpTo.load(std::memory_order_acquire);
+        if (note >= 0 && note <= 127)
+            mark = std::max(mark, releasedUpTo[note].load(std::memory_order_acquire));
+        return seq <= mark;
+    }
+
+    // Drops queued note-ons (counted in notesDiscarded). Consumer side: call only while no audio
+    // thread drains the queue (engine setup, before the device callback is attached).
+    void discardPending() {
+        const int rp = readPos.load(std::memory_order_relaxed);
+        const int wp = writePos.load(std::memory_order_acquire);
+        notesDiscarded.fetch_add((uint32_t)((wp - rp + kSize) % kSize), std::memory_order_relaxed);
+        readPos.store(wp, std::memory_order_release);
+    }
+
+    // Cumulative counters (relaxed). notesQueued == notesConsumed + notesDiscarded + still queued;
+    // attempted note-ons == notesQueued + notesDropped.
+    std::atomic<uint32_t> notesQueued{0};
+    std::atomic<uint32_t> notesConsumed{0};
+    std::atomic<uint32_t> notesDropped{0};   // note-on rejected: ring full
+    std::atomic<uint32_t> notesDiscarded{0}; // dropped by discardPending (engine setup)
+
+private:
+    // Spinlock guard for the producer side (test_and_set acquire / clear release). Critical
+    // sections are a few stores; yield in case the holder was preempted.
+    struct SpinGuard {
+        std::atomic_flag& flag;
+        explicit SpinGuard(std::atomic_flag& f) : flag(f) {
+            while (flag.test_and_set(std::memory_order_acquire)) std::this_thread::yield();
+        }
+        ~SpinGuard() { flag.clear(std::memory_order_release); }
+        SpinGuard(const SpinGuard&) = delete;
+        SpinGuard& operator=(const SpinGuard&) = delete;
+    };
+
+    static void raise(std::atomic<uint64_t>& mark, uint64_t value) {
+        uint64_t current = mark.load(std::memory_order_relaxed);
+        while (current < value
+               && !mark.compare_exchange_weak(current, value, std::memory_order_release,
+                                              std::memory_order_relaxed)) {}
+    }
+
+    NoteEvent ring[kSize];
+    std::atomic<int> writePos{0};
+    std::atomic<int> readPos{0};
+    std::atomic_flag producerLock = ATOMIC_FLAG_INIT;
+
+    std::atomic<uint64_t> lastSeq{0};          // latest note-on sequence number (any note)
+    std::atomic<uint64_t> lastOnSeq[128] = {}; // latest note-on sequence number per note
+    std::atomic<uint64_t> releasedUpTo[128] = {};
+    std::atomic<uint64_t> allReleasedUpTo{0};
+};

package/ios/PolySynthProcessor.h

@@ -5,6 +5,7 @@
 #include "Voice.h"
 #include "VoiceAllocator.h"
 #include "TransportEngine.h"
+#include "NoteEventQueue.h"
 #include <atomic>
 #include <cmath>
 #include <cstdint>
@@ -15,17 +16,11 @@ struct BeatState {
     std::atomic<double> bpm{120.0};
 };
 
-// Diagnostics counters. Written on the audio thread (except notesQueued and
-// notesDropped, which the noteOn producers write), read from any thread. Relaxed
-// loads only; notesQueued is incremented before the release-store that publishes
-// the event, so a reader never sees notesConsumed > notesQueued. notesQueued counts
-// accepted NoteOns only: attempted NoteOns == notesQueued + notesDropped.
+// Diagnostics counters. Written on the audio thread, read from any thread (relaxed loads
+// only). The note counters live in the NoteEventQueue.
 struct SynthDiagnostics {
     std::atomic<uint64_t> processCount{0};
     std::atomic<float> peak{0.0f};                // decaying hold of block max |x|
-    std::atomic<uint32_t> notesQueued{0};
-    std::atomic<uint32_t> notesConsumed{0};
-    std::atomic<uint32_t> notesDropped{0};        // noteOn rejected: event queue full
     std::atomic<int> activeVoices{0};
     std::atomic<double> lastNoteToRenderMs{-1.0}; // -1 = no NoteOn consumed yet
     std::atomic<double> lastTouchToRenderMs{-1.0}; // -1 = no touch-stamped NoteOn consumed yet
@@ -38,17 +33,6 @@ inline float diagPeakDecay(int numSamples, double sampleRate) {
     return (float)std::exp(-(double)numSamples / (0.43 * sampleRate));
 }
 
-// Note event queue: multi-producer (main thread + JS thread, serialised by a spinlock),
-// single consumer (audio thread, lock-free).
-struct NoteEvent {
-    enum Type : uint8_t { NoteOn, NoteOff, AllNotesOff };
-    Type type;
-    int note;
-    int velocity;
-    juce::int64 stampTicks; // juce::Time::getHighResolutionTicks() at enqueue (0 if unused)
-    juce::int64 touchTicks; // originating UITouch.timestamp in high-res ticks (same clock); 0 if not a touch
-};
-
 // Every user-settable synth parameter, as stored (after clamping). getSettings / applySettings
 // carry the configuration across an engine rebuild, which replaces the processor.
 struct SynthSettings {
@@ -82,13 +66,17 @@ public:
     void getStateInformation(juce::MemoryBlock&) override {}
     void setStateInformation(const void*, int) override {}
 
-    // Thread-safe: callable from any number of threads (producers are serialised by
-    // producerLock), queued for the audio thread.
+    // Thread-safe, any number of threads: forwarded to the note queue (see NoteEventQueue).
     // touchTicks: originating UITouch timestamp in juce::Time high-resolution ticks
     // (mach_absolute_time on Apple), or 0 when the note did not come from a touch.
-    void noteOn(int note, int velocity, juce::int64 touchTicks = 0);
-    void noteOff(int note);
-    void allNotesOff();
+    void noteOn(int note, int velocity, juce::int64 touchTicks = 0) { queue->pushNoteOn(note, velocity, touchTicks); }
+    void noteOff(int note) { queue->pushNoteOff(note); }
+    void allNotesOff() { queue->pushAllNotesOff(); }
+
+    // The queue this synth reads its notes from: its own by default; the engine passes its
+    // process-lifetime queue (before the synth is attached to a device). nullptr = own queue.
+    void setNoteQueue(NoteEventQueue* q) { queue = q ? q : &ownQueue; }
+    NoteEventQueue& noteQueue() { return *queue; }
 
     void setWaveform(Waveform wf);
     void setFilterCutoff(double hz);
@@ -109,7 +97,7 @@ public:
     SynthDiagnostics diag;
 
 private:
-    void processNoteEvent(const NoteEvent& event);
+    void startQueuedNote(const NoteEvent& event);
 
     Voice voices[MAX_VOICES];
     VoiceAllocator allocator;
@@ -121,12 +109,6 @@ private:
     std::atomic<float> detuneCents{0.0f};
     std::atomic<float> masterLevel{0.5f};
 
-    // Ring buffer for note events (producers → audio thread). Producers (noteOn / noteOff /
-    // allNotesOff, from the main thread and the JS thread) hold producerLock while they
-    // write; the consumer (processBlock) never touches it.
-    static constexpr int EVENT_QUEUE_SIZE = 256;
-    NoteEvent eventQueue[EVENT_QUEUE_SIZE];
-    std::atomic<int> eventWritePos{0};
-    std::atomic<int> eventReadPos{0};
-    std::atomic_flag producerLock = ATOMIC_FLAG_INIT;
+    NoteEventQueue ownQueue;
+    NoteEventQueue* queue = &ownQueue;
 };

package/ios/PolySynthProcessor.mm

@@ -1,21 +1,6 @@
 #include "PolySynthProcessor.h"
 #include <cmath>
 #include <algorithm>
-#include <thread>
-
-namespace {
-// Spinlock guard for the note queue's producer side (test_and_set acquire / clear release).
-// Critical sections are a few stores; yield in case the holder was preempted.
-struct ProducerSpinGuard {
-    std::atomic_flag& flag;
-    explicit ProducerSpinGuard(std::atomic_flag& f) : flag(f) {
-        while (flag.test_and_set(std::memory_order_acquire)) std::this_thread::yield();
-    }
-    ~ProducerSpinGuard() { flag.clear(std::memory_order_release); }
-    ProducerSpinGuard(const ProducerSpinGuard&) = delete;
-    ProducerSpinGuard& operator=(const ProducerSpinGuard&) = delete;
-};
-}
 
 PolySynthProcessor::PolySynthProcessor()
     : AudioProcessor(BusesProperties()
@@ -34,29 +19,14 @@ void PolySynthProcessor::processBlock(juce::AudioBuffer<float>& buffer,
                                        juce::MidiBuffer& /*midiMessages*/) {
     buffer.clear();
 
-    // Drain note event FIFO (audio thread side)
-    int rp = eventReadPos.load(std::memory_order_relaxed);
-    int wp = eventWritePos.load(std::memory_order_acquire);
-    while (rp != wp) {
-        const NoteEvent& event = eventQueue[rp];
-        processNoteEvent(event);
-        if (event.type == NoteEvent::NoteOn) {
-            diag.notesConsumed.fetch_add(1, std::memory_order_relaxed);
-            const juce::int64 nowTicks = juce::Time::getHighResolutionTicks();
-            if (event.stampTicks != 0) {
-                const juce::int64 elapsed = nowTicks - event.stampTicks;
-                diag.lastNoteToRenderMs.store(juce::Time::highResolutionTicksToSeconds(elapsed) * 1000.0,
-                                              std::memory_order_relaxed);
-            }
-            if (event.touchTicks != 0 && nowTicks >= event.touchTicks) {
-                const juce::int64 elapsed = nowTicks - event.touchTicks;
-                diag.lastTouchToRenderMs.store(juce::Time::highResolutionTicksToSeconds(elapsed) * 1000.0,
-                                               std::memory_order_relaxed);
-            }
-        }
-        rp = (rp + 1) % EVENT_QUEUE_SIZE;
+    // Note-ons waiting in the queue, then releases: every held voice whose note-on is at or
+    // below its release mark stops (see NoteEventQueue). Applied every block, so a release sent
+    // while the device was stopped or reopening takes effect on the first block after it.
+    queue->drainNoteOns([this](const NoteEvent& event) { startQueuedNote(event); });
+    for (int v = 0; v < MAX_VOICES; v++) {
+        if (voices[v].isHeld() && queue->isReleased(voices[v].getNoteNumber(), voices[v].startSeq))
+            voices[v].stopNote();
     }
-    eventReadPos.store(rp, std::memory_order_release);
 
     int numSamples = buffer.getNumSamples();
     double sr = getSampleRate();
@@ -118,62 +88,27 @@ void PolySynthProcessor::processBlock(juce::AudioBuffer<float>& buffer,
     }
 }
 
-// Called on audio thread from processBlock
-void PolySynthProcessor::processNoteEvent(const NoteEvent& event) {
-    switch (event.type) {
-        case NoteEvent::NoteOn: {
-            int clampedNote = std::clamp(event.note, 0, 127);
-            int clampedVel = std::clamp(event.velocity, 0, 127);
-            allocator.noteOn(clampedNote, (float)clampedVel, voices,
-                             static_cast<Waveform>(waveform.load()),
-                             (double)detuneCents.load(),
-                             filterCutoff.load(), filterResonance.load(),
-                             masterLevel.load());
-            break;
-        }
-        case NoteEvent::NoteOff: {
-            int clampedNote = std::clamp(event.note, 0, 127);
-            allocator.noteOff(clampedNote, voices);
-            break;
-        }
-        case NoteEvent::AllNotesOff:
-            allocator.allNotesOff(voices);
-            break;
+// Audio thread (processBlock): start a queued note-on and record its latency.
+void PolySynthProcessor::startQueuedNote(const NoteEvent& event) {
+    const int clampedNote = std::clamp(event.note, 0, 127);
+    const int clampedVel = std::clamp(event.velocity, 0, 127);
+    allocator.noteOn(clampedNote, (float)clampedVel, voices,
+                     static_cast<Waveform>(waveform.load()),
+                     (double)detuneCents.load(),
+                     filterCutoff.load(), filterResonance.load(),
+                     masterLevel.load(), event.seq);
+
+    const juce::int64 nowTicks = juce::Time::getHighResolutionTicks();
+    if (event.stampTicks != 0) {
+        const juce::int64 elapsed = nowTicks - event.stampTicks;
+        diag.lastNoteToRenderMs.store(juce::Time::highResolutionTicksToSeconds(elapsed) * 1000.0,
+                                      std::memory_order_relaxed);
     }
-}
-
-// Producers (main thread, JS thread): push an event to the FIFO under producerLock.
-void PolySynthProcessor::noteOn(int note, int velocity, juce::int64 touchTicks) {
-    ProducerSpinGuard guard(producerLock);
-    int wp = eventWritePos.load(std::memory_order_relaxed);
-    int nextWp = (wp + 1) % EVENT_QUEUE_SIZE;
-    if (nextWp == eventReadPos.load(std::memory_order_acquire)) { // full, drop event
-        diag.notesDropped.fetch_add(1, std::memory_order_relaxed);
-        return;
+    if (event.touchTicks != 0 && nowTicks >= event.touchTicks) {
+        const juce::int64 elapsed = nowTicks - event.touchTicks;
+        diag.lastTouchToRenderMs.store(juce::Time::highResolutionTicksToSeconds(elapsed) * 1000.0,
+                                       std::memory_order_relaxed);
     }
-    eventQueue[wp] = { NoteEvent::NoteOn, note, velocity, juce::Time::getHighResolutionTicks(), touchTicks };
-    // Count before publishing: the release-store below orders this increment
-    // ahead of the consumer's notesConsumed increment for the same event.
-    diag.notesQueued.fetch_add(1, std::memory_order_relaxed);
-    eventWritePos.store(nextWp, std::memory_order_release);
-}
-
-void PolySynthProcessor::noteOff(int note) {
-    ProducerSpinGuard guard(producerLock);
-    int wp = eventWritePos.load(std::memory_order_relaxed);
-    int nextWp = (wp + 1) % EVENT_QUEUE_SIZE;
-    if (nextWp == eventReadPos.load(std::memory_order_acquire)) return;
-    eventQueue[wp] = { NoteEvent::NoteOff, note, 0, 0, 0 };
-    eventWritePos.store(nextWp, std::memory_order_release);
-}
-
-void PolySynthProcessor::allNotesOff() {
-    ProducerSpinGuard guard(producerLock);
-    int wp = eventWritePos.load(std::memory_order_relaxed);
-    int nextWp = (wp + 1) % EVENT_QUEUE_SIZE;
-    if (nextWp == eventReadPos.load(std::memory_order_acquire)) return;
-    eventQueue[wp] = { NoteEvent::AllNotesOff, 0, 0, 0, 0 };
-    eventWritePos.store(nextWp, std::memory_order_release);
 }
 
 void PolySynthProcessor::setWaveform(Waveform wf) { waveform.store(static_cast<int>(wf)); }

package/ios/Voice.h

@@ -22,6 +22,11 @@ public:
     void startNote(int note, float velocity);
     void stopNote();
 
+    // Held: between startNote and stopNote (a voice in its release stage is not held).
+    bool isHeld() const { return held && noteNumber >= 0; }
+    // NoteEventQueue sequence number of the note-on that started this voice (0 = none).
+    uint64_t startSeq = 0;
+
     void captureAndRelease(Waveform waveform, double frequency,
                            float filterCutoff, float filterResonance,
                            float masterLevel);
@@ -52,6 +57,7 @@ private:
     juce::ADSR adsr;
 
     int noteNumber = -1;
+    bool held = false;
     float velocityGain = 0.0f;
     float currentLevel = 0.0f;
     double cachedSampleRate = 44100.0;

package/ios/Voice.mm

@@ -52,10 +52,12 @@ void Voice::startNote(int note, float velocity) {
     filter.reset();
 
     updateADSR();
+    held = true;
     adsr.noteOn();
 }
 
 void Voice::stopNote() {
+    held = false;
     adsr.noteOff();
 }
 
@@ -88,6 +90,7 @@ void Voice::captureAndRelease(Waveform waveform, double frequency,
     }
 
     noteNumber = -1;
+    held = false;
     currentLevel = 0.0f;
 }
 

package/ios/VoiceAllocator.h

@@ -11,7 +11,7 @@ public:
     int noteOn(int note, float velocity, Voice* voices,
                Waveform waveform, double detuneCents,
                float filterCutoff, float filterResonance,
-               float masterLevel);
+               float masterLevel, uint64_t seq = 0);
 
     void noteOff(int note, Voice* voices);
     void allNotesOff(Voice* voices);

package/ios/VoiceAllocator.mm

@@ -28,7 +28,7 @@ int VoiceAllocator::findVoice(Voice* voices) {
 int VoiceAllocator::noteOn(int note, float velocity, Voice* voices,
                            Waveform waveform, double detuneCents,
                            float filterCutoff, float filterResonance,
-                           float masterLevel) {
+                           float masterLevel, uint64_t seq) {
     if (note >= 0 && note < 128 && noteMap[note] >= 0) {
         int existing = noteMap[note];
         if (existing < MAX_VOICES && voices[existing].getNoteNumber() == note) {
@@ -58,6 +58,7 @@ int VoiceAllocator::noteOn(int note, float velocity, Voice* voices,
     }
 
     voice.startNote(note, velocity);
+    voice.startSeq = seq;
 
     if (note >= 0 && note < 128) {
         noteMap[note] = voiceIdx;

package/ios/juce_modules/juce_audio_processors/processors/juce_AudioProcessorGraph.cpp

@@ -551,7 +551,7 @@ struct GraphRenderSequence
             return;
         }
 
-        currentAudioOutputBuffer.setSize (jmax (1, buffer.getNumChannels()), numSamples);
+        currentAudioOutputBuffer.setSize (jmax (1, buffer.getNumChannels()), numSamples, false, false, true); // expo-juce patch: graph-output-buffer-no-realloc
         currentAudioOutputBuffer.clear();
         currentMidiOutputBuffer.clear();
 
@@ -798,7 +798,7 @@ struct GraphRenderSequence
     {
         renderingBuffer.setSize (numBuffersNeeded + 1, blockSize);
         renderingBuffer.clear();
-        currentAudioOutputBuffer.setSize (numBuffersNeeded + 1, blockSize);
+        currentAudioOutputBuffer.setSize (jmax (numBuffersNeeded + 1, 8), blockSize); // expo-juce patch: graph-output-buffer-no-realloc
         currentAudioOutputBuffer.clear();
 
         currentMidiOutputBuffer.clear();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-juce",
-  "version": "0.5.2-rc.1",
+  "version": "0.5.2",
   "description": "Realtime DSP w/C++ & JUCE",
   "type": "module",
   "main": "build/index.js",