diff --git a/.claude/skills/thread-safety-itc/SKILL.md b/.claude/skills/thread-safety-itc/SKILL.md
index 1e13b88b4..83a029480 100644
--- a/.claude/skills/thread-safety-itc/SKILL.md
+++ b/.claude/skills/thread-safety-itc/SKILL.md
@@ -195,6 +195,30 @@ together in the `ContextPromise` resolve task (CallInvoker), after driver work 
 still reads the prior value until settlement (needed when `resume()` then `suspend()` are issued
 back-to-back).
 
+**Context `statechange` event:** `BaseAudioContext::dispatchStateChange(state)` fires
+`AudioEvent::STATE_CHANGE` (payload `{state: "..."}`), deduped against the last dispatched state so
+the two paths that both reach RUNNING (implicit `tryStartDriver` from a source start, then the
+`resume()` promise) emit once. Call it *after* the `jsiPromise->resolve(...)` enqueue in the
+`ContextPromiseResolver` factory lambdas — the registry worker can only enqueue its own
+`invokeAsync` later, so the event's JS task always lands behind the resolve task and its
+microtasks (spec's promise-then-statechange order). Carry the state by value: `getState()` may
+still report SUSPENDED until the driver settles. On the TS side the event handler is
+notification-only — it must NOT write the `state` attribute; a rapid `resume()+suspend()` settles
+both operations before either event arrives, and a handler write would roll the attribute back to
+the stale event's value. The attribute is fully native: `BaseAudioContext::publishedState_` is read
+by the JSI `state` getter and written by `setPublishedState()` **inside each promise's own
+resolution lambda** (the callback passed to `jsiPromise->resolve`, which runs on the JS thread in
+that promise's resolve task) — never from the worker/render thread directly, where a later
+operation's write can land before an earlier operation's continuations read. The statechange event
+must use `EventCaller::dispatchOnJSQueue` (registry `dispatchEventOnJSQueue`, straight
+`invokeAsync`), NOT the worker-queue `dispatch`: FIFO placement right behind its own resolve task
+makes the handler observe each intermediate state instead of only the final one. Do not dispatch
+statechange from mid-lifecycle bodies (`tryStartDriver`) — that enqueues the event before the
+resolve task, so the handler reads the pre-transition state; the resolver's dispatch covers the
+implicit-start path because TS always issues `resume()` for it. Verified with WPT
+`suspend-after-construct` (5/0) and a probe asserting `resume.then→running, event→running,
+suspend.then→suspended, event→suspended`.
+
 ---
 
 ## Common Mistakes
diff --git a/packages/audiodocs/docs/core/audio-context.mdx b/packages/audiodocs/docs/core/audio-context.mdx
index befc54774..45eaebeca 100644
--- a/packages/audiodocs/docs/core/audio-context.mdx
+++ b/packages/audiodocs/docs/core/audio-context.mdx
@@ -71,3 +71,7 @@ Resumes a previously suspended audio context.
 
 #### Returns `Promise<undefined>`.
 
+## Events
+
+Inherits [`onstatechange`](./base-audio-context.mdx#onstatechange) from [`BaseAudioContext`](./base-audio-context.mdx#events); `close`, `suspend` and `resume` each fire it once their returned promise has resolved.
+
diff --git a/packages/audiodocs/docs/core/base-audio-context.mdx b/packages/audiodocs/docs/core/base-audio-context.mdx
index b92e87cd9..4821aae0f 100644
--- a/packages/audiodocs/docs/core/base-audio-context.mdx
+++ b/packages/audiodocs/docs/core/base-audio-context.mdx
@@ -227,6 +227,33 @@ const buffer = await this.audioContext.decodeAudioData(data, 4800, 2, false);
 ```
 </details>
 
+## Events
+
+### `onstatechange`
+
+Sets (or removes, when `null` is assigned) a callback fired whenever the context's [`state`](./base-audio-context.mdx#properties) changes to a different value.
+
+The event is dispatched by the native audio engine once a transition is **acknowledged** — after the promise of the operation that caused it ([`resume`](./audio-context.mdx#resume), [`suspend`](./audio-context.mdx#suspend), [`close`](./audio-context.mdx#close), [`OfflineAudioContext.startRendering`](./offline-audio-context.mdx#startrendering)) has resolved. Code awaiting that promise always observes the new `state` value first; the `statechange` callback runs in a later task.
+
+It also fires for transitions no method call requested, e.g. when the context starts running implicitly because a source node's `start()` engaged the audio driver.
+
+The callback receives an event object:
+
+| Field | Type | Description |
+| :---: | :---: | :---- |
+| `type` | `string` | Always `'statechange'`. |
+| `target` | [`BaseAudioContext`](./base-audio-context.mdx) | The context whose state changed. |
+
+```tsx
+const audioContext = new AudioContext();
+
+audioContext.onstatechange = (event) => {
+  console.log(`state is now ${event.target.state}`);
+};
+
+await audioContext.resume(); // logs "state is now running" shortly after
+```
+
 ## Remarks
 
 #### `currentTime`
diff --git a/packages/audiodocs/docs/core/offline-audio-context.mdx b/packages/audiodocs/docs/core/offline-audio-context.mdx
index 62834e6fc..6c876f2ac 100644
--- a/packages/audiodocs/docs/core/offline-audio-context.mdx
+++ b/packages/audiodocs/docs/core/offline-audio-context.mdx
@@ -49,3 +49,31 @@ Resume time progression in audio context when it has been suspended.
 Starts rendering the audio, taking into account the current connections and the current scheduled changes.
 
 #### Returns `Promise<AudioBuffer>`.
+
+## Events
+
+Inherits [`onstatechange`](./base-audio-context.mdx#onstatechange) from [`BaseAudioContext`](./base-audio-context.mdx#events). It fires when rendering starts (`running`), when a scheduled [`suspend`](./offline-audio-context.mdx#suspend) point is reached (`suspended`), after [`resume`](./offline-audio-context.mdx#resume) (`running`), and when rendering finishes (`closed`).
+
+### `oncomplete`
+
+Sets (or removes, when `null` is assigned) a callback fired when rendering has finished. It is dispatched after the `closed` [`statechange`](./base-audio-context.mdx#onstatechange), so the two events always arrive in spec order. The callback receives an event object:
+
+| Field | Type | Description |
+| :---: | :---: | :---- |
+| `type` | `string` | Always `'complete'`. |
+| `target` | [`OfflineAudioContext`](./offline-audio-context.mdx) | The context that finished rendering. |
+| `renderedBuffer` | [`AudioBuffer`](../sources/audio-buffer.mdx) | The rendered audio. |
+
+```tsx
+const offlineContext = new OfflineAudioContext({
+  numberOfChannels: 2,
+  length: 44100,
+  sampleRate: 44100,
+});
+
+offlineContext.oncomplete = (event) => {
+  console.log(`rendered ${event.renderedBuffer.duration}s of audio`);
+};
+
+await offlineContext.startRendering();
+```
diff --git a/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/AudioEvent.kt b/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/AudioEvent.kt
index 398a93c0f..324fac4e2 100644
--- a/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/AudioEvent.kt
+++ b/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/AudioEvent.kt
@@ -26,4 +26,5 @@ enum class AudioEvent {
   BUFFER_ENDED,
   RECORDER_ERROR,
   BUFFERING_STATE_CHANGE,
+  STATE_CHANGE,
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
index fadced0ca..53d91784c 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
@@ -48,7 +48,10 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
       JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, destination),
       JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, listener),
       JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, sampleRate),
-      JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, currentTime));
+      JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, currentTime),
+      JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, state));
+
+  addSetters(JSI_EXPORT_PROPERTY_SETTER(BaseAudioContextHostObject, onstatechange));
 
   addFunctions(
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createRecorderAdapter),
@@ -74,7 +77,19 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
 // "key function" for the audio classes - this allow for RTTI to work
 // properly across dynamic library boundaries (i.e. dynamic_cast that is used by
 // isHostObject method), android specific issue
-BaseAudioContextHostObject::~BaseAudioContextHostObject() = default;
+BaseAudioContextHostObject::~BaseAudioContextHostObject() {
+  // The C++ context can outlive this HostObject (lifecycle promises hold it);
+  // never let it fire statechange into a GC'd JSI function.
+  context_->assignOnStateChangeCallbackId(0);
+}
+
+JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, state) {
+  return jsi::String::createFromUtf8(runtime, contextStateToString(context_->getPublishedState()));
+}
+
+JSI_PROPERTY_SETTER_IMPL(BaseAudioContextHostObject, onstatechange) {
+  context_->assignOnStateChangeCallbackId(std::stoull(value.getString(runtime).utf8(runtime)));
+}
 
 JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, destination) {
   return jsi::Object::createFromHostObject(runtime, destination_);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h
index d79425db0..e3824d126 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h
@@ -26,6 +26,9 @@ class BaseAudioContextHostObject : public HostObject {
   ~BaseAudioContextHostObject() override;
 
   JSI_PROPERTY_GETTER_DECL(destination);
+  JSI_PROPERTY_GETTER_DECL(state);
+  JSI_PROPERTY_SETTER_DECL(onstatechange);
+
   JSI_PROPERTY_GETTER_DECL(listener);
   JSI_PROPERTY_GETTER_DECL(sampleRate);
   JSI_PROPERTY_GETTER_DECL(currentTime);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/OfflineAudioContextHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/OfflineAudioContextHostObject.cpp
index a00cbad9b..9838c326f 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/OfflineAudioContextHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/OfflineAudioContextHostObject.cpp
@@ -51,6 +51,9 @@ JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, suspend) {
 }
 
 JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, startRendering) {
+  // No promise acknowledges this first transition; rendering counts as
+  // running from the moment it is requested, synchronously with the call.
+  context_->setPublishedState(ContextState::RUNNING);
   return promiseVendor_->createPromise([this](Promise &&promise) {
     auto resultPromise = OfflineAudioContextResultPromise::makeOfflineAudioContextResultResolver(
         std::move(promise), context_);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/JsEnumParser.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/JsEnumParser.cpp
index a2259b7db..aed6aaea5 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/JsEnumParser.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/JsEnumParser.cpp
@@ -150,6 +150,8 @@ AudioEvent audioEventFromString(const std::string &event) {
     return AudioEvent::RECORDER_ERROR;
   if (event == "bufferingStateChanged")
     return AudioEvent::BUFFERING_STATE_CHANGE;
+  if (event == "stateChange")
+    return AudioEvent::STATE_CHANGE;
 
   throw std::invalid_argument("Unknown audio event: " + event);
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/JsEnumParser.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/JsEnumParser.h
index d9bb1969d..5735276c8 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/JsEnumParser.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/JsEnumParser.h
@@ -11,6 +11,7 @@
 #include <string>
 
 namespace audioapi::js_enum_parser {
+
 std::string overSampleTypeToString(OverSampleType type);
 OverSampleType overSampleTypeFromString(const std::string &type);
 std::string oscillatorTypeToString(OscillatorType type);
@@ -18,7 +19,6 @@ OscillatorType oscillatorTypeFromString(const std::string &type);
 std::string filterTypeToString(BiquadFilterType type);
 BiquadFilterType filterTypeFromString(const std::string &type);
 AudioEvent audioEventFromString(const std::string &event);
-std::string contextStateToString(ContextState state);
 std::string channelCountModeToString(ChannelCountMode mode);
 ChannelCountMode channelCountModeFromString(const std::string &mode);
 std::string channelInterpretationToString(ChannelInterpretation interpretation);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp
index c7a038e48..4f4c90504 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp
@@ -70,10 +70,10 @@ bool AudioContext::tryStartDriver() {
 
   if (audioPlayer_->start()) {
     isInitialized_.store(true, std::memory_order_release);
-    // The driver also starts implicitly, from the first
-    // `AudioScheduledSourceNode::start()`. Publish RUNNING here so the visible state
+    // Publish RUNNING here so the visible state
     // never reports SUSPENDED while the graph is actually rendering; `resume()`
-    // reaches the same state through its promise task.
+    // reaches the same state through its promise task (its dispatch then
+    // dedupes against this one).
     setState(ContextState::RUNNING);
     return true;
   }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
index a845a8230..0ecc83a2b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
@@ -18,6 +18,7 @@ BaseAudioContext::BaseAudioContext(
     : state_(ContextState::SUSPENDED),
       sampleRate_(sampleRate),
       audioEventHandlerRegistry_(audioEventHandlerRegistry),
+      stateChangeEvent_(audioEventHandlerRegistry),
       pendingPromisesOffloader_(
           std::make_unique<task_offloader::TaskOffloader<
               ContextPromiseTask,
@@ -64,6 +65,21 @@ double BaseAudioContext::getCurrentTime() const {
   return static_cast<double>(getCurrentSampleFrame()) / getSampleRate();
 }
 
+void BaseAudioContext::assignOnStateChangeCallbackId(uint64_t callbackId) {
+  stateChangeEvent_.assignCallbackId(callbackId);
+}
+
+void BaseAudioContext::dispatchStateChange(ContextState state) {
+  if (lastDispatchedState_.exchange(state, std::memory_order_acq_rel) == state) {
+    return;
+  }
+
+  // FIFO with the promise resolution the caller just enqueued, so the event
+  // fires between this transition's continuations and the next transition's —
+  // the handler observes each state, not just the final one.
+  stateChangeEvent_.dispatch(StringPayload{.name = "state", .reason = contextStateToString(state)});
+}
+
 void BaseAudioContext::setState(ContextState state) {
   state_.store(state, std::memory_order_release);
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
index a6c4c17ba..ad2c216ec 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
@@ -8,6 +8,7 @@
 #include <audioapi/core/utils/graph/Graph.h>
 #include <audioapi/events/AudioEvent.h>
 #include <audioapi/events/DeferredEventQueue.hpp>
+#include <audioapi/events/EventCaller.hpp>
 #include <audioapi/utils/AudioBuffer.hpp>
 #include <audioapi/utils/CrossThreadEventScheduler.hpp>
 #include <audioapi/utils/TaskOffloader.hpp>
@@ -47,6 +48,30 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
 
   void setState(ContextState state);
 
+  /// The value behind the JS `state` attribute. Read from the JSI getter on
+  /// the JS thread.
+  [[nodiscard]] ContextState getPublishedState() const {
+    return publishedState_.load(std::memory_order_acquire);
+  }
+
+  /// Publishes an acknowledged transition to the JS-visible state. JS thread
+  /// only, and for promise-driven transitions only from the operation's own
+  /// resolution continuation (the TS `publishedState` setter): CallInvokers
+  /// may batch queued resolve tasks ahead of the first microtask checkpoint,
+  /// so any earlier write point lets a rapid resume()+suspend() pair publish
+  /// both states before either continuation reads. Native-originated
+  /// transitions with no acknowledging promise (planned `interrupted`) write
+  /// here from a CallInvoker task instead.
+  void setPublishedState(ContextState state) {
+    publishedState_.store(state, std::memory_order_release);
+  }
+
+  /// JS thread. Wires the `statechange` listener registered by the TS context.
+  void assignOnStateChangeCallbackId(uint64_t callbackId);
+
+  /// Fires `statechange` for an acknowledged transition to @p state.
+  void dispatchStateChange(ContextState state);
+
   [[nodiscard]] std::shared_ptr<PeriodicWave> createPeriodicWave(
       const std::vector<std::complex<float>> &complexData,
       bool disableNormalization,
@@ -159,6 +184,12 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
   std::atomic<float> sampleRate_;
   std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
 
+  EventCaller<AudioEvent::STATE_CHANGE> stateChangeEvent_;
+  /// Ledger backing dispatchStateChange()'s dedupe; contexts start suspended.
+  std::atomic<ContextState> lastDispatchedState_{ContextState::SUSPENDED};
+  /// Backs the JS `state` attribute; written only via setPublishedState().
+  std::atomic<ContextState> publishedState_{ContextState::SUSPENDED};
+
   std::shared_ptr<PeriodicWave> cachedSineWave_ = nullptr;
   std::shared_ptr<PeriodicWave> cachedSquareWave_ = nullptr;
   std::shared_ptr<PeriodicWave> cachedSawtoothWave_ = nullptr;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/OfflineAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/OfflineAudioContext.cpp
index f75b104c3..b069d9ef7 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/OfflineAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/OfflineAudioContext.cpp
@@ -163,7 +163,12 @@ void OfflineAudioContext::startRendering(
   renderingStarted_ = true;
   resultPromise_ = promise;
   auto runningStatePromise = std::make_shared<ContextPromiseResolver<void>>(
-      [self = shared_from_this()]() { self->setState(ContextState::RUNNING); },
+      [self = shared_from_this()]() {
+        self->setState(ContextState::RUNNING);
+        // startRendering has no acknowledging promise for this transition;
+        // the render thread actually starting is the acknowledgment.
+        self->dispatchStateChange(ContextState::RUNNING);
+      },
       [](const std::string &) {});
   renderAudio(runningStatePromise);
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/types/ContextState.h b/packages/react-native-audio-api/common/cpp/audioapi/core/types/ContextState.h
index c40d7070f..acf3f9bad 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/types/ContextState.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/types/ContextState.h
@@ -6,4 +6,18 @@ namespace audioapi {
 
 enum class ContextState : std::uint8_t { SUSPENDED, RUNNING, CLOSED };
 
+/// The Web Audio API `AudioContextState` string for @p state, as carried by
+/// the `statechange` event payload and the JS `state` attribute.
+inline const char *contextStateToString(ContextState state) {
+  switch (state) {
+    case ContextState::SUSPENDED:
+      return "suspended";
+    case ContextState::RUNNING:
+      return "running";
+    case ContextState::CLOSED:
+      return "closed";
+  }
+  return "suspended";
 }
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/events/AudioEvent.h b/packages/react-native-audio-api/common/cpp/audioapi/events/AudioEvent.h
index e11dc5262..beb125403 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/events/AudioEvent.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/events/AudioEvent.h
@@ -29,5 +29,6 @@ enum class AudioEvent : uint8_t {
   BUFFER_ENDED,
   RECORDER_ERROR,
   BUFFERING_STATE_CHANGE,
+  STATE_CHANGE,
 };
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/events/AudioEventPayloadMapping.hpp b/packages/react-native-audio-api/common/cpp/audioapi/events/AudioEventPayloadMapping.hpp
index bf26da887..eb44b720c 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/events/AudioEventPayloadMapping.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/events/AudioEventPayloadMapping.hpp
@@ -41,6 +41,7 @@ AUDIOAPI_DEFINE_EVENT_PAYLOAD(AudioEvent::POSITION_CHANGED, DoubleValuePayload);
 AUDIOAPI_DEFINE_EVENT_PAYLOAD(AudioEvent::BUFFER_ENDED, BufferEndedPayload);
 AUDIOAPI_DEFINE_EVENT_PAYLOAD(AudioEvent::RECORDER_ERROR, StringPayload);
 AUDIOAPI_DEFINE_EVENT_PAYLOAD(AudioEvent::BUFFERING_STATE_CHANGE, BoolValuePayload);
+AUDIOAPI_DEFINE_EVENT_PAYLOAD(AudioEvent::STATE_CHANGE, StringPayload);
 
 #undef AUDIOAPI_DEFINE_EVENT_PAYLOAD
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/jsi/ContextPromiseResolver.cpp b/packages/react-native-audio-api/common/cpp/audioapi/jsi/ContextPromiseResolver.cpp
index e62275f24..0295f32db 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/jsi/ContextPromiseResolver.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/jsi/ContextPromiseResolver.cpp
@@ -25,7 +25,12 @@ std::shared_ptr<ContextPromiseResolver<void>> ContextPromiseResolver<T>::makeCon
         // Spec: update the state attribute in the same follow-up task that
         // resolves the lifecycle promise (before statechange reactions).
         audioContext->setState(nextState);
-        jsiPromise->resolve([](jsi::Runtime &runtime) { return jsi::Value::undefined(); });
+        // Publishes the JS-visible state on the JS thread
+        jsiPromise->resolve([audioContext, nextState](jsi::Runtime &runtime) {
+          audioContext->setPublishedState(nextState);
+          return jsi::Value::undefined();
+        });
+        audioContext->dispatchStateChange(nextState);
       },
       [jsiPromise](const std::string &message) { jsiPromise->reject(message); });
 }
@@ -44,9 +49,14 @@ ContextPromiseResolver<T>::makeOfflineAudioContextResultResolver(
         // resolves the startRendering promise (before statechange reactions).
         audioContext->setState(ContextState::CLOSED);
         auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(audioBuffer);
-        jsiPromise->resolve([audioBufferHostObject](jsi::Runtime &runtime) {
+        // Published in the resolution task, as above.
+        jsiPromise->resolve([audioContext, audioBufferHostObject](jsi::Runtime &runtime) {
+          audioContext->setPublishedState(ContextState::CLOSED);
           return jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
         });
+        // Behind the resolve enqueue, as above; the TS layer orders the
+        // `complete` event after this statechange lands.
+        audioContext->dispatchStateChange(ContextState::CLOSED);
       },
       [jsiPromise](const std::string &message) { jsiPromise->reject(message); });
 }
diff --git a/packages/react-native-audio-api/src/core/AudioContext.ts b/packages/react-native-audio-api/src/core/AudioContext.ts
index 8941e656c..5a8e52f05 100644
--- a/packages/react-native-audio-api/src/core/AudioContext.ts
+++ b/packages/react-native-audio-api/src/core/AudioContext.ts
@@ -33,8 +33,8 @@ export default class AudioContext extends BaseAudioContext {
       throw new InvalidStateError('Cannot close a closed audio context.');
     }
 
-    this._state = 'closed';
-    return (this.context as IAudioContext).close();
+    this.setControlState('closed');
+    await (this.context as IAudioContext).close();
   }
 
   async resume(): Promise<undefined> {
@@ -42,8 +42,8 @@ export default class AudioContext extends BaseAudioContext {
       throw new InvalidStateError('Cannot resume a closed audio context.');
     }
 
-    this._state = 'running';
-    return (this.context as IAudioContext).resume();
+    this.setControlState('running');
+    await (this.context as IAudioContext).resume();
   }
 
   async suspend(): Promise<undefined> {
@@ -51,8 +51,8 @@ export default class AudioContext extends BaseAudioContext {
       throw new InvalidStateError('Cannot suspend a closed audio context.');
     }
 
-    this._state = 'suspended';
-    return (this.context as IAudioContext).suspend();
+    this.setControlState('suspended');
+    await (this.context as IAudioContext).suspend();
   }
 
   /**
@@ -62,8 +62,10 @@ export default class AudioContext extends BaseAudioContext {
    */
   public override markRunningOnSourceStart(): void {
     if (this._state === 'suspended') {
-      this._state = 'running';
-      (this.context as IAudioContext).resume();
+      this.setControlState('running');
+      (this.context as IAudioContext).resume().catch(() => {
+        // The driver refused to start; the attribute keeps reporting reality.
+      });
     }
   }
 
diff --git a/packages/react-native-audio-api/src/core/BaseAudioContext.ts b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
index aa20c53ef..b62b20eb7 100644
--- a/packages/react-native-audio-api/src/core/BaseAudioContext.ts
+++ b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
@@ -1,4 +1,6 @@
 import { InvalidStateError, NotSupportedError } from '../errors';
+import { AudioEventEmitter } from '../events';
+import { OnStateChangeEventType } from '../events/types';
 import { IBaseAudioContext } from '../jsi-interfaces';
 import {
   ContextState,
@@ -25,6 +27,11 @@ import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
 import WaveShaperNode from './WaveShaperNode';
 
+export interface ContextStateChangeEvent {
+  type: 'statechange';
+  target: BaseAudioContext;
+}
+
 export default class BaseAudioContext {
   readonly destination: AudioDestinationNode;
   readonly listener: AudioListener;
@@ -36,16 +43,87 @@ export default class BaseAudioContext {
     this.destination = new AudioDestinationNode(this, context.destination);
     this.listener = new AudioListener(this, context.listener);
     this.sampleRate = context.sampleRate;
+
+    // The native context owns statechange: it dispatches once per acknowledged
+    // transition, after settling the operation's promise, so the event always
+    // lands in a later task than the promise continuations. This subscription
+    // lives as long as the context; native transitions that no JS call
+    // requested (e.g. a future interrupted state) flow through the same path.
+    this.stateChangeSubscription = this.audioEventEmitter.addAudioEventListener(
+      'stateChange',
+      (event: OnStateChangeEventType) => this.onNativeStateChange(event)
+    );
+    this.context.onstatechange = this.stateChangeSubscription.subscriptionId;
   }
 
+  /**
+   * The spec's [[control thread state]]: written synchronously the moment an
+   * operation is accepted, so the NEXT call validates against what has already
+   * been requested (e.g. close() right after resume() must see 'running').
+   * Never exposed — the `state` attribute reports acknowledged reality
+   * instead.
+   */
   protected _state: ContextState = 'suspended';
 
+  protected readonly audioEventEmitter = new AudioEventEmitter(
+    globalThis.AudioEventEmitter
+  );
+
+  private stateChangeSubscription: ReturnType<
+    AudioEventEmitter['addAudioEventListener']
+  >;
+
+  private onstatechangeCallback:
+    | ((event: ContextStateChangeEvent) => void)
+    | null = null;
+
+  /**
+   * Web Audio API `statechange` event handler. Dispatched by the native context
+   * from a queued task after the `state` attribute changes — after the
+   * operation's promise resolution and all of its microtasks, matching the
+   * spec's media-element-task order.
+   */
+  public get onstatechange():
+    | ((event: ContextStateChangeEvent) => void)
+    | null {
+    return this.onstatechangeCallback;
+  }
+
+  public set onstatechange(
+    callback: ((event: ContextStateChangeEvent) => void) | null
+  ) {
+    this.onstatechangeCallback = callback;
+  }
+
+  /**
+   * Terminal handler for the native statechange dispatch. Deliberately does NOT
+   * write `state`: the attribute is published in the resolution task of the
+   * operation that caused the transition (spec order), and a rapid
+   * resume()+suspend() pair acknowledges both before either event lands — a
+   * write here would roll the attribute back to the stale event's value. When a
+   * native-originated state with no acknowledging promise arrives (the planned
+   * `interrupted`), its attribute update must be added here explicitly.
+   * Subclasses extend this to order dependent events (offline `complete`) after
+   * `statechange`.
+   */
+  protected onNativeStateChange(_event: OnStateChangeEventType): void {
+    this.onstatechangeCallback?.({ type: 'statechange', target: this });
+  }
+
+  /**
+   * Record that a state transition has been requested ([[control thread
+   * state]]).
+   */
+  protected setControlState(nextState: ContextState): void {
+    this._state = nextState;
+  }
+
   public get currentTime(): number {
     return this.context.currentTime;
   }
 
   public get state(): ContextState {
-    return this._state;
+    return this.context.state as ContextState;
   }
 
   /**
diff --git a/packages/react-native-audio-api/src/core/OfflineAudioContext.ts b/packages/react-native-audio-api/src/core/OfflineAudioContext.ts
index d715a84d7..eb35a82d1 100644
--- a/packages/react-native-audio-api/src/core/OfflineAudioContext.ts
+++ b/packages/react-native-audio-api/src/core/OfflineAudioContext.ts
@@ -1,13 +1,29 @@
 import { InvalidStateError, NotSupportedError } from '../errors';
 import { assertSupportedSampleRate } from '../utils/validation';
+import { OnStateChangeEventType } from '../events/types';
 import { IOfflineAudioContext } from '../jsi-interfaces';
 import { OfflineAudioContextOptions } from '../types';
 import AudioBuffer from './AudioBuffer';
 import BaseAudioContext from './BaseAudioContext';
 
+export interface OfflineAudioCompletionEvent {
+  type: 'complete';
+  target: OfflineAudioContext;
+  renderedBuffer: AudioBuffer;
+}
+
 export default class OfflineAudioContext extends BaseAudioContext {
   private isRendering: boolean;
   private duration: number;
+  /** Set when startRendering() resolves; consumed by the `closed` statechange. */
+  private pendingRenderedBuffer: AudioBuffer | null;
+
+  /**
+   * Web Audio API `complete` event handler, dispatched when startRendering()
+   * finishes. Kept alongside the promise because plenty of code (and the WPT
+   * suite) never awaits the promise and relies on this event alone.
+   */
+  public oncomplete: ((event: OfflineAudioCompletionEvent) => void) | null;
 
   constructor(options: OfflineAudioContextOptions);
   constructor(numberOfChannels: number, length: number, sampleRate: number);
@@ -41,6 +57,8 @@ export default class OfflineAudioContext extends BaseAudioContext {
     }
 
     this.isRendering = false;
+    this.oncomplete = null;
+    this.pendingRenderedBuffer = null;
   }
 
   async resume(): Promise<undefined> {
@@ -56,8 +74,8 @@ export default class OfflineAudioContext extends BaseAudioContext {
       );
     }
 
-    this._state = 'running';
-    return (this.context as IOfflineAudioContext).resume();
+    this.setControlState('running');
+    await (this.context as IOfflineAudioContext).resume();
   }
 
   async suspend(suspendTime: number): Promise<undefined> {
@@ -81,10 +99,12 @@ export default class OfflineAudioContext extends BaseAudioContext {
       throw new InvalidStateError('the rendering is already finished');
     }
 
+    // The suspend promise resolves when rendering reaches the suspend point —
+    // the acknowledgment the spec publishes the state change on.
     const result = await (this.context as IOfflineAudioContext).suspend(
       suspendTime
     );
-    this._state = 'suspended';
+    this.setControlState('suspended');
     return result;
   }
 
@@ -94,12 +114,34 @@ export default class OfflineAudioContext extends BaseAudioContext {
     }
 
     this.isRendering = true;
-    this._state = 'running';
+    this.setControlState('running');
     const audioBuffer = await (
       this.context as IOfflineAudioContext
     ).startRendering();
-    this._state = 'closed';
+    this.setControlState('closed');
+
+    const renderedBuffer = new AudioBuffer(audioBuffer);
+    // `complete` is fired by onNativeStateChange when the native `closed`
+    // statechange lands — a strictly later task than this continuation — so
+    // `statechange` always precedes `complete`, per the spec's ordering.
+    this.pendingRenderedBuffer = renderedBuffer;
+
+    return renderedBuffer;
+  }
+
+  protected override onNativeStateChange(event: OnStateChangeEventType): void {
+    super.onNativeStateChange(event);
+
+    if (event.state !== 'closed' || this.pendingRenderedBuffer === null) {
+      return;
+    }
 
-    return new AudioBuffer(audioBuffer);
+    const renderedBuffer = this.pendingRenderedBuffer;
+    this.pendingRenderedBuffer = null;
+    this.oncomplete?.({
+      type: 'complete',
+      target: this,
+      renderedBuffer,
+    });
   }
 }
diff --git a/packages/react-native-audio-api/src/events/types.ts b/packages/react-native-audio-api/src/events/types.ts
index 34aff0d1a..94c620e46 100644
--- a/packages/react-native-audio-api/src/events/types.ts
+++ b/packages/react-native-audio-api/src/events/types.ts
@@ -1,5 +1,6 @@
 import AudioBuffer from '../core/AudioBuffer';
 import { NotificationEvents } from '../system';
+import { ContextState } from '../types';
 
 export interface EventEmptyType {}
 
@@ -36,6 +37,10 @@ export interface OnRecorderErrorEventType {
   message: string;
 }
 
+export interface OnStateChangeEventType {
+  state: ContextState;
+}
+
 type SystemEvents = {
   volumeChange: EventTypeWithValue;
   interruption: OnInterruptionEventType;
@@ -81,6 +86,7 @@ interface AudioAPIEvents {
   recorderError: OnRecorderErrorEventType;
   /** `value` is true while an `<Audio>` source is stalled on decoded data. */
   bufferingStateChanged: EventTypeWithBool;
+  stateChange: OnStateChangeEventType;
 }
 
 type AudioEvents = SystemEvents & AudioAPIEvents & NotificationEvents;
diff --git a/packages/react-native-audio-api/src/jsi-interfaces.ts b/packages/react-native-audio-api/src/jsi-interfaces.ts
index 9a9a2a552..2004332e1 100644
--- a/packages/react-native-audio-api/src/jsi-interfaces.ts
+++ b/packages/react-native-audio-api/src/jsi-interfaces.ts
@@ -43,6 +43,14 @@ export interface IBaseAudioContext {
   readonly currentTime: number;
   readonly decoder: IAudioDecoder;
 
+  /**
+   * Web Audio `AudioContextState` string; native storage behind the JS `state`
+   * attribute.
+   */
+  readonly state: string;
+  // passing subscriptionId(uint_64 in cpp, string in js) to the cpp
+  onstatechange: string;
+
   createRecorderAdapter(): IRecorderAdapterNode;
   createOscillator(oscillatorOptions: IOscillatorOptions): IOscillatorNode;
   createConstantSource(
diff --git a/packages/react-native-audio-api/wpt_tests/README.md b/packages/react-native-audio-api/wpt_tests/README.md
index 0901f2f50..41c0ed6ca 100644
--- a/packages/react-native-audio-api/wpt_tests/README.md
+++ b/packages/react-native-audio-api/wpt_tests/README.md
@@ -8,6 +8,9 @@ This directory contains the Node.js bootstrap for running Web Audio WPT against
 - Native Node addon (`wpt_tests/src`) using JSI HostObjects via `node-api-jsi`.
 - JSI-backed runtime installation (`jsi_install.cpp`).
 - Smoke WPT harness (`wpt_tests/wpt/wpt-harness.mjs`) with allowlist + skip policy.
+  Test files run in short-lived worker processes (`wpt-worker.mjs`, 25 files per
+  worker by default): a native crash or hang costs one file instead of the run,
+  and the parent process never loads the native module, so its exit is instant.
 - Vendored Web Audio API tests under `wpt_tests/webaudio/` (~3 MB, full `webaudio` subtree).
 - Manual conformance reporting (`wpt-results.mjs`) that produces a [wpt.fyi](https://wpt.fyi/results/webaudio/the-audio-api?label=experimental&label=master&aligned)-style markdown table.
 
@@ -68,7 +71,11 @@ run always produces identical, complete numbers.
 CI helpers:
 
 - `yarn wpt:ci-report`: build + smoke run with `--allow-failures` (always writes JSON)
-- `yarn wpt:compare --baseline <base.json> --candidate <head.json>`: non-regression gate
+- `yarn wpt:compare --baseline <base.json> --candidate <head.json>`: non-regression gate.
+  When both reports carry per-file data (`files` array, including failing subtest
+  names), the gate is exact: it also fails on new failing subtests hidden behind
+  unchanged pass counts, and on files that crashed, hung, or disappeared. Older
+  reports without `files` fall back to the category-count comparison.
 
 Useful flags:
 
@@ -76,6 +83,10 @@ Useful flags:
 - `--profile full`: entire vendored `webaudio/` tree
 - `--report-json <path>` / `--write-markdown <path>`: custom output locations
 - `--allow-failures`: exit 0 after a completed run even when assertions fail
+- `--batch-size <n>`: files per worker process (default 25); `0` disables
+  isolation and runs everything in one process
+- `--inactivity-timeout <seconds>`: kill a worker that emits no events for this
+  long, record the stuck file as `timeout`, and resume after it (default 120)
 - `--update-docs`: rewrite the summary block in the audiodocs coverage page
 - `yarn wpt:markdown`: regenerate markdown from an existing JSON report
 
@@ -89,7 +100,12 @@ The published conformance summary lives in the docs, not here:
 - **Device-related instability in CI**
   - Node test backend is sink-less; keep tests within the smoke profile.
 - **Runner appears hung**
-  - Kill stale processes: `pkill -f wpt-harness.mjs`
+  - The inactivity watchdog kills a silent worker after `--inactivity-timeout`
+    and resumes past the stuck file, so a hang costs one file, not the run.
+  - A worker whose native teardown hangs after finishing its batch is killed
+    after a grace period — the log line "native teardown hung; killed" is
+    informational, not a test failure.
+  - Kill stale processes: `pkill -f wpt-harness.mjs; pkill -f wpt-worker.mjs`
   - Some tests are excluded in `wpt/skip-list.json` (crashtests, AudioWorklet, known engine hangs).
 - **Subset runs**
   - `yarn wpt --filter gain` or `node ./wpt_tests/wpt/wpt-harness.mjs --filter the-analysernode-interface`
diff --git a/packages/react-native-audio-api/wpt_tests/src/SyncCallInvoker.cpp b/packages/react-native-audio-api/wpt_tests/src/SyncCallInvoker.cpp
index 9e007da64..0e835e169 100644
--- a/packages/react-native-audio-api/wpt_tests/src/SyncCallInvoker.cpp
+++ b/packages/react-native-audio-api/wpt_tests/src/SyncCallInvoker.cpp
@@ -78,16 +78,31 @@ void SyncCallInvoker::invokeAsync(facebook::react::CallFunc &&func) noexcept {
     return;
   }
 
-  if (std::this_thread::get_id() == mainThreadId_ || tsfn_ == nullptr) {
+  // Before initialize() only the main thread exists; run inline.
+  if (tsfn_ == nullptr) {
     func(*runtime_);
     return;
   }
 
+  // Always queue — even from the JS thread. Running main-thread posts inline
+  // let them jump ahead of audio-thread posts already sitting in the queue, so
+  // promise-resolution order depended on which thread happened to enqueue
+  // first (the suspend-after-construct WPT flake). One queue gives one FIFO
+  // order, matching React Native's CallInvoker contract that invokeAsync never
+  // executes synchronously.
   auto *callFunc = new facebook::react::CallFunc(std::move(func));
   napi_call_threadsafe_function(tsfn_, callFunc, napi_tsfn_blocking);
 }
 
 void SyncCallInvoker::invokeSync(facebook::react::CallFunc &&func) {
+  // Genuinely synchronous only on the JS thread. From any other thread a
+  // blocking wait would deadlock against the event loop this queue drains on,
+  // so those posts degrade to async FIFO — a documented harness limitation.
+  if (std::this_thread::get_id() == mainThreadId_ && runtime_ != nullptr) {
+    func(*runtime_);
+    return;
+  }
+
   invokeAsync(std::move(func));
 }
 
diff --git a/packages/react-native-audio-api/wpt_tests/src/jsi_install.cpp b/packages/react-native-audio-api/wpt_tests/src/jsi_install.cpp
index 7b2cbc674..dccc27672 100644
--- a/packages/react-native-audio-api/wpt_tests/src/jsi_install.cpp
+++ b/packages/react-native-audio-api/wpt_tests/src/jsi_install.cpp
@@ -54,6 +54,24 @@ void cleanupInstallState(void *data) {
   gInstallStates.erase(env);
 }
 
+/// Advertised GC cost of one audio context HostObject. A context owns worker
+/// threads (promise offloader, disposer, per-context pools) and buffers that
+/// live outside the V8 heap; without this hint V8 sees a tiny object and lets
+/// abandoned contexts linger for the rest of the process.
+constexpr size_t kAudioContextExternalMemoryPressure = 8 * 1024 * 1024;
+
+Object makeContextObject(
+    Runtime &rt,
+    const std::shared_ptr<facebook::jsi::HostObject> &hostObject) {
+  auto object = Object::createFromHostObject(rt, hostObject);
+  try {
+    object.setExternalMemoryPressure(rt, kAudioContextExternalMemoryPressure);
+  } catch (...) {
+    // Runtimes without instrumentation support just skip the hint.
+  }
+  return object;
+}
+
 napi_value makeBoolean(napi_env env, bool value) {
   napi_value result;
   napi_get_boolean(env, value, &result);
@@ -135,7 +153,7 @@ void installOfflineBindings(
             &rt,
             callInvoker);
 
-        return Object::createFromHostObject(rt, hostObject);
+        return makeContextObject(rt, hostObject);
       });
   runtime.global().setProperty(runtime, "createOfflineAudioContext", createOfflineAudioContext);
 
@@ -189,7 +207,7 @@ void installAudioContextBinding(
             &rt,
             callInvoker);
 
-        return Object::createFromHostObject(rt, hostObject);
+        return makeContextObject(rt, hostObject);
       });
 
   runtime.global().setProperty(runtime, "createAudioContext", createAudioContext);
diff --git a/packages/react-native-audio-api/wpt_tests/wpt/skip-list.json b/packages/react-native-audio-api/wpt_tests/wpt/skip-list.json
index 2a50a129a..12f91711e 100644
--- a/packages/react-native-audio-api/wpt_tests/wpt/skip-list.json
+++ b/packages/react-native-audio-api/wpt_tests/wpt/skip-list.json
@@ -54,5 +54,17 @@
   {
     "pattern": "the-channelmergernode-interface/active-processing.https.html",
     "reason": "requires AudioWorklet"
+  },
+  {
+    "pattern": "the-audiocontext-interface/constructor-allowed-to-start",
+    "reason": "waits for the autoplay suspended->running statechange; this library starts the native driver lazily (first source start() or resume()), never from the constructor, so the transition never happens and every subtest hangs to the 10s harness timeout"
+  },
+  {
+    "pattern": "the-audiocontext-interface/audiocontext-suspend-resume-close",
+    "reason": "waits for the autoplay suspended->running statechange; this library starts the native driver lazily (first source start() or resume()), never from the constructor, so the transition never happens and every subtest hangs to the 10s harness timeout"
+  },
+  {
+    "pattern": "the-audiocontext-interface/audiocontext-state-change-after-close",
+    "reason": "waits for the autoplay suspended->running statechange; this library starts the native driver lazily (first source start() or resume()), never from the constructor, so the transition never happens and every subtest hangs to the 10s harness timeout"
   }
 ]
diff --git a/packages/react-native-audio-api/wpt_tests/wpt/wpt-compare.mjs b/packages/react-native-audio-api/wpt_tests/wpt/wpt-compare.mjs
index 153a69af7..53516044d 100644
--- a/packages/react-native-audio-api/wpt_tests/wpt/wpt-compare.mjs
+++ b/packages/react-native-audio-api/wpt_tests/wpt/wpt-compare.mjs
@@ -98,6 +98,67 @@ const candidate = loadReport(options.candidate);
 const baselineCategories = categoryPassMap(baseline);
 const candidateCategories = categoryPassMap(candidate);
 
+/**
+ * The audit harness interleaves real assertion failures (`X <assertion>`) with
+ * roll-up lines that embed a running count — `< [task] 3 out of 3 assertions
+ * were failed.` and `# AUDIT TASK RUNNER FINISHED: 6 out of 17 tasks were
+ * failed.`. Fixing an assertion rewrites those counts, so a literal set
+ * difference reads the improved roll-up as a brand-new failure. Only the
+ * assertion lines identify a subtest, so only they gate the comparison.
+ */
+const isAssertionFailure = (message) => message.startsWith('X ');
+
+/**
+ * Exact per-file comparison. Category pass counts cannot see an equal-count
+ * swap (test X regresses while test Y starts passing), so when both reports
+ * carry per-file data — reports written before it exists fall back to the
+ * category-level gate — the failing-subtest sets are compared directly.
+ */
+function compareFiles(baselineReport, candidateReport) {
+  if (!Array.isArray(baselineReport.files) || !Array.isArray(candidateReport.files)) {
+    return null;
+  }
+
+  const toMap = (report) =>
+    new Map(report.files.map((file) => [file.path, file]));
+  const baseFiles = toMap(baselineReport);
+  const headFiles = toMap(candidateReport);
+
+  const newFailures = []; // { path, subtests: string[] }
+  const brokenFiles = []; // { path, status } — crashed/hung/missing in candidate
+  const newFiles = []; // informational: files only the candidate ran
+
+  for (const [filePath, base] of baseFiles) {
+    const head = headFiles.get(filePath);
+    if (head == null) {
+      brokenFiles.push({ path: filePath, status: 'missing' });
+      continue;
+    }
+    if (head.status !== 'ok' && base.status === 'ok') {
+      brokenFiles.push({ path: filePath, status: head.status });
+      continue;
+    }
+
+    const baseFailures = new Set((base.failures ?? []).filter(isAssertionFailure));
+    const subtests = (head.failures ?? [])
+      .filter(isAssertionFailure)
+      .filter((message) => !baseFailures.has(message));
+    if (subtests.length > 0) {
+      newFailures.push({ path: filePath, subtests });
+    }
+  }
+
+  for (const filePath of headFiles.keys()) {
+    if (!baseFiles.has(filePath)) {
+      newFiles.push(filePath);
+    }
+  }
+
+  return { newFailures, brokenFiles, newFiles };
+}
+
+const fileComparison = compareFiles(baseline, candidate);
+
 const regressions = [];
 const improvements = [];
 const unchanged = [];
@@ -142,7 +203,10 @@ const summaryDelta = candidateSummaryPass - baselineSummaryPass;
 // pass maps, so the per-category diff stays clean while the overall pass count falls.
 // The summary therefore needs a regression check of its own.
 const summaryRegressed = summaryDelta < 0;
-const hasRegression = regressions.length > 0 || summaryRegressed;
+const fileRegressed =
+  fileComparison != null &&
+  (fileComparison.newFailures.length > 0 || fileComparison.brokenFiles.length > 0);
+const hasRegression = regressions.length > 0 || summaryRegressed || fileRegressed;
 
 const signed = (delta) => `${delta > 0 ? '+' : ''}${delta}`;
 
@@ -154,8 +218,24 @@ const tableHeader = [
   '| --- | ---: | ---: | ---: |',
 ];
 
+const regressionParts = [];
+if (regressions.length > 0) {
+  regressionParts.push(`${regressions.length} regressed section(s)`);
+}
+if (fileComparison != null && fileComparison.newFailures.length > 0) {
+  regressionParts.push(
+    `${fileComparison.newFailures.length} file(s) with new failing subtests`
+  );
+}
+if (fileComparison != null && fileComparison.brokenFiles.length > 0) {
+  regressionParts.push(`${fileComparison.brokenFiles.length} broken file(s)`);
+}
+if (regressionParts.length === 0 && summaryRegressed) {
+  regressionParts.push('overall pass count dropped');
+}
+
 const verdict = hasRegression
-  ? `**FAIL** — ${regressions.length} regressed section(s)`
+  ? `**FAIL** — ${regressionParts.join(', ')}`
   : '**PASS** — no regressions';
 
 const lines = [
@@ -170,6 +250,54 @@ if (changed.length > 0) {
   lines.push(...tableHeader, ...changed.map(formatRow), '');
 }
 
+if (fileComparison == null) {
+  lines.push(
+    '_Per-file data unavailable in one of the reports — category-level comparison only._',
+    ''
+  );
+} else {
+  const MAX_LISTED_SUBTESTS = 30;
+  const { newFailures, brokenFiles, newFiles } = fileComparison;
+
+  if (brokenFiles.length > 0) {
+    lines.push('**Broken test files:**', '');
+    for (const { path: filePath, status } of brokenFiles) {
+      lines.push(`- \`${filePath}\` — ${status}`);
+    }
+    lines.push('');
+  }
+
+  if (newFailures.length > 0) {
+    lines.push('**New failing subtests:**', '');
+    let listed = 0;
+    for (const { path: filePath, subtests } of newFailures) {
+      lines.push(`- \`${filePath}\``);
+      for (const subtest of subtests) {
+        if (listed >= MAX_LISTED_SUBTESTS) {
+          break;
+        }
+        lines.push(`  - ${subtest}`);
+        listed += 1;
+      }
+    }
+    const totalSubtests = newFailures.reduce(
+      (acc, { subtests }) => acc + subtests.length,
+      0
+    );
+    if (totalSubtests > MAX_LISTED_SUBTESTS) {
+      lines.push(`  - _…and ${totalSubtests - MAX_LISTED_SUBTESTS} more_`);
+    }
+    lines.push('');
+  }
+
+  if (newFiles.length > 0) {
+    lines.push(
+      `<sub>${newFiles.length} test file(s) ran only in the candidate (informational).</sub>`,
+      ''
+    );
+  }
+}
+
 // Unchanged sections outnumber changed ones on almost every run, so they are collapsed
 // to keep the PR comment readable without dropping the full picture.
 if (unchanged.length > 0) {
@@ -193,6 +321,17 @@ if (hasRegression) {
   for (const row of regressions) {
     console.error(`  - ${row.label}: ${row.head} pass (was ${row.base}, delta ${row.delta})`);
   }
+  if (fileComparison != null) {
+    for (const { path: filePath, status } of fileComparison.brokenFiles) {
+      console.error(`  - ${filePath}: ${status}`);
+    }
+    for (const { path: filePath, subtests } of fileComparison.newFailures) {
+      console.error(`  - ${filePath}: ${subtests.length} new failing subtest(s)`);
+      for (const subtest of subtests.slice(0, 5)) {
+        console.error(`      ${subtest}`);
+      }
+    }
+  }
   if (summaryRegressed) {
     console.error(
       `  - Overall summary: ${candidateSummaryPass} pass (was ${baselineSummaryPass}, delta ${summaryDelta})`
diff --git a/packages/react-native-audio-api/wpt_tests/wpt/wpt-harness.mjs b/packages/react-native-audio-api/wpt_tests/wpt/wpt-harness.mjs
index 1103ee0ac..42fd63c87 100644
--- a/packages/react-native-audio-api/wpt_tests/wpt/wpt-harness.mjs
+++ b/packages/react-native-audio-api/wpt_tests/wpt/wpt-harness.mjs
@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { fork } from 'node:child_process';
 
 import chalk from 'chalk';
 import { program } from 'commander';
@@ -10,6 +11,7 @@ import {
   createSequentialFilter,
   createWptEnvironment,
   getProfileAllowlist,
+  normalizeTestPath,
   printSummary,
   runSequentialWpt,
 } from './wpt-shared.mjs';
@@ -23,6 +25,7 @@ import {
 } from './wpt-results.mjs';
 
 const harnessDir = path.dirname(fileURLToPath(import.meta.url));
+const workerPath = path.join(harnessDir, 'wpt-worker.mjs');
 const defaultJsonReportPath = path.join(harnessDir, '..', 'results', 'latest.json');
 const defaultMarkdownReportPath = path.join(harnessDir, '..', 'results', 'latest.md');
 const defaultDocsPath = path.join(
@@ -36,6 +39,16 @@ const defaultDocsPath = path.join(
   'web-audio-api-coverage.mdx'
 );
 
+// How long a worker may stay silent (no reporter event) before the parent
+// assumes a native hang, kills it, and resumes past the stuck file. Generous
+// against the 10s per-test testharness timeout — a file holds many tests.
+const DEFAULT_INACTIVITY_TIMEOUT_S = 120;
+
+// After a worker reports its batch done, its process.exit() still has to tear
+// down native state. Give it this long to die on its own before SIGKILL — the
+// parent already holds every result, so a hung teardown costs nothing.
+const WORKER_EXIT_GRACE_MS = 10_000;
+
 program
   .option('--list', 'List test files only')
   .option('--filter <regexp>', 'Additional regex filter for tests', '.*')
@@ -45,6 +58,18 @@ program
     'Test selection profile: smoke (the-audio-api) or full (entire webaudio tree)',
     'smoke'
   )
+  .option(
+    '--batch-size <n>',
+    'Files per worker process; 0 runs everything in this process without isolation',
+    (value) => Number.parseInt(value, 10),
+    25
+  )
+  .option(
+    '--inactivity-timeout <seconds>',
+    'Kill a worker that produces no events for this long and resume past the stuck file',
+    (value) => Number.parseInt(value, 10),
+    DEFAULT_INACTIVITY_TIMEOUT_S
+  )
   .option(
     '--report-json <path>',
     'Write structured JSON results for markdown generation',
@@ -85,6 +110,7 @@ let numPass = 0;
 let numFail = 0;
 let timerStarted = false;
 let summaryPrinted = false;
+let activeWorker = null;
 const resultsCollector = new WptResultsCollector();
 const startedAt = Date.now();
 
@@ -141,6 +167,7 @@ const signalExitCode = {
 
 const handleSignal = signal => {
   console.error(chalk.yellow(`\nReceived ${signal}; printing partial summary.`));
+  activeWorker?.kill('SIGKILL');
   printHarnessSummary();
   writeReports();
   // Interrupted runs always exit non-zero; --allow-failures only applies to completed runs.
@@ -172,8 +199,152 @@ if (options.list) {
   process.exit(0);
 }
 
-// Warm up the native module in the parent before running.
-createWptEnvironment();
+/**
+ * Run one batch of files in a forked worker, forwarding its reporter events.
+ *
+ * @returns {Promise<{
+ *   startedFiles: string[],
+ *   outcome: 'done' | 'crashed' | 'timeout',
+ *   fileFailures: number,
+ * }>} `startedFiles` lists files the worker began, in order; on 'crashed' or
+ * 'timeout' the last entry (if any) is the file that never finished.
+ */
+function runWorkerBatch(files, reporter) {
+  return new Promise((resolve) => {
+    const worker = fork(workerPath, [], {
+      stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+    });
+    activeWorker = worker;
+
+    const startedFiles = [];
+    let fileFailures = 0;
+    let doneReceived = false;
+    let settled = false;
+    let outcome = 'crashed';
+    let inactivityTimer = null;
+    let exitGraceTimer = null;
+
+    const settle = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(inactivityTimer);
+      clearTimeout(exitGraceTimer);
+      activeWorker = null;
+      resolve({ startedFiles, outcome, fileFailures });
+    };
+
+    const armInactivityTimer = () => {
+      clearTimeout(inactivityTimer);
+      if (options.inactivityTimeout <= 0) {
+        return;
+      }
+      inactivityTimer = setTimeout(() => {
+        outcome = 'timeout';
+        worker.kill('SIGKILL');
+      }, options.inactivityTimeout * 1000);
+    };
+
+    worker.on('message', (message) => {
+      armInactivityTimer();
+      switch (message.type) {
+        case 'suite-start':
+          startedFiles.push(normalizeTestPath(message.name));
+          reporter.startSuite(message.name);
+          break;
+        case 'pass':
+          reporter.pass(message.message);
+          break;
+        case 'fail':
+          reporter.fail(message.message);
+          break;
+        case 'stack':
+          reporter.reportStack(message.stack);
+          break;
+        case 'done':
+          doneReceived = true;
+          outcome = 'done';
+          fileFailures = message.fileFailures ?? 0;
+          clearTimeout(inactivityTimer);
+          exitGraceTimer = setTimeout(() => {
+            console.error(
+              chalk.yellow(
+                '[wpt] worker finished its batch but its native teardown hung; killed.'
+              )
+            );
+            worker.kill('SIGKILL');
+          }, WORKER_EXIT_GRACE_MS);
+          break;
+        default:
+          break;
+      }
+    });
+
+    worker.on('error', () => {
+      worker.kill('SIGKILL');
+    });
+
+    worker.on('exit', () => {
+      // 'done' already fixed the outcome; otherwise the child died mid-batch
+      // (native crash) unless the watchdog set 'timeout' first.
+      if (!doneReceived && outcome !== 'timeout') {
+        outcome = 'crashed';
+      }
+      settle();
+    });
+
+    armInactivityTimer();
+    worker.send({ files });
+  });
+}
+
+/**
+ * Run all selected files through short-lived worker processes.
+ *
+ * A worker that crashes or hangs costs exactly one file: it is recorded as
+ * crashed and the remaining files of its batch are re-queued for a fresh
+ * worker. The parent never loads the native module, so its own exit is
+ * instant no matter what the audio engine's teardown does.
+ */
+async function runBatched(reporter) {
+  const queue = collectSelectedTestPaths({
+    filterRegexp: options.filter,
+    includeCrashtests: options.includeCrashtests,
+    profile: options.profile,
+  });
+
+  let totalFileFailures = 0;
+  let crashedFiles = 0;
+
+  while (queue.length > 0) {
+    const batch = queue.splice(0, options.batchSize);
+    const { startedFiles, outcome, fileFailures } = await runWorkerBatch(
+      batch,
+      reporter
+    );
+    totalFileFailures += fileFailures;
+
+    if (outcome === 'done') {
+      continue;
+    }
+
+    // The file that never finished: the last one started, or — when the worker
+    // died before starting anything (e.g. the addon failed to load) — the first
+    // of the batch, so the queue always shrinks and the run always terminates.
+    const crashed =
+      startedFiles.length > 0 ? startedFiles[startedFiles.length - 1] : batch[0];
+    const label = outcome === 'timeout' ? 'hung (no events)' : 'crashed the worker';
+    console.error(chalk.red(`\n  × ${crashed} ${label}; resuming after it.\n`));
+    resultsCollector.markFileCrashed(crashed, outcome);
+    crashedFiles += 1;
+
+    const crashedIndex = batch.indexOf(crashed);
+    queue.unshift(...batch.slice(crashedIndex + 1));
+  }
+
+  return { totalFileFailures, crashedFiles };
+}
 
 try {
   console.time('wpt-duration');
@@ -181,19 +352,36 @@ try {
 
   const numPassRef = { value: 0 };
   const numFailRef = { value: 0 };
-  const filter = createSequentialFilter({
-    filterRegexp: options.filter,
-    includeCrashtests: options.includeCrashtests,
-    listOnly: false,
-    profile: options.profile,
-  });
   const reporter = wrapReporter(
     createConsoleReporter({ numPassRef, numFailRef }),
     resultsCollector
   );
-  const fileFailures = await runSequentialWpt({ filter, reporter });
+
+  let fileFailures = 0;
+  let crashedFiles = 0;
+
+  if (options.batchSize > 0) {
+    ({ totalFileFailures: fileFailures, crashedFiles } =
+      await runBatched(reporter));
+  } else {
+    // Legacy single-process mode: everything shares this process, including
+    // whatever native teardown process.exit() runs into.
+    createWptEnvironment();
+    const filter = createSequentialFilter({
+      filterRegexp: options.filter,
+      includeCrashtests: options.includeCrashtests,
+      listOnly: false,
+      profile: options.profile,
+    });
+    fileFailures = await runSequentialWpt({ filter, reporter });
+  }
+
   numPass = numPassRef.value;
   numFail = numFailRef.value;
+  // A crashed file lost at least one test, and a file-level failure with no
+  // recorded subtest failures (a file that errored before producing subtests)
+  // must still fail the run.
+  numFail += crashedFiles;
   if (fileFailures > 0 && numFail === 0) {
     numFail = fileFailures;
   }
diff --git a/packages/react-native-audio-api/wpt_tests/wpt/wpt-only/channel-merger-splitter-attribute-locks.mjs b/packages/react-native-audio-api/wpt_tests/wpt/wpt-only/channel-merger-splitter-attribute-locks.mjs
index 0a20f13b0..2a0ae09b6 100644
--- a/packages/react-native-audio-api/wpt_tests/wpt/wpt-only/channel-merger-splitter-attribute-locks.mjs
+++ b/packages/react-native-audio-api/wpt_tests/wpt/wpt-only/channel-merger-splitter-attribute-locks.mjs
@@ -10,6 +10,11 @@
  * library's core constructors.
  */
 
+import {
+  getCurrentTestWindow,
+  patchPrototypeOnce,
+} from '../wpt-utils.mjs';
+
 /**
  * @param {object} node
  * @param {{
@@ -93,13 +98,16 @@ function lockMergerOrSplitterInstance(instance, window) {
   return instance;
 }
 
-function wrapFactory(original, window) {
+function wrapFactory(original) {
   if (typeof original !== 'function') {
     return original;
   }
 
   return function (...args) {
-    return lockMergerOrSplitterInstance(original.apply(this, args), window);
+    return lockMergerOrSplitterInstance(
+      original.apply(this, args),
+      getCurrentTestWindow()
+    );
   };
 }
 
@@ -136,18 +144,19 @@ export function applyChannelMergerSplitterAttributeLocks(window) {
       continue;
     }
 
+    // Context prototypes are shared by every test window; patch them once.
     const proto = Ctor.prototype;
-    if (typeof proto.createChannelMerger === 'function') {
-      proto.createChannelMerger = wrapFactory(
-        proto.createChannelMerger,
-        window
-      );
-    }
-    if (typeof proto.createChannelSplitter === 'function') {
-      proto.createChannelSplitter = wrapFactory(
-        proto.createChannelSplitter,
-        window
-      );
-    }
+    patchPrototypeOnce(
+      proto,
+      'createChannelMerger',
+      wrapFactory,
+      'merger-splitter-lock'
+    );
+    patchPrototypeOnce(
+      proto,
+      'createChannelSplitter',
+      wrapFactory,
+      'merger-splitter-lock'
+    );
   }
 }
diff --git a/packages/react-native-audio-api/wpt_tests/wpt/wpt-results.mjs b/packages/react-native-audio-api/wpt_tests/wpt/wpt-results.mjs
index 3333f51a2..2f3ce92e8 100644
--- a/packages/react-native-audio-api/wpt_tests/wpt/wpt-results.mjs
+++ b/packages/react-native-audio-api/wpt_tests/wpt/wpt-results.mjs
@@ -142,6 +142,7 @@ function createEmptyCategoryStats() {
     files: 0,
     filesPassed: 0,
     filesFailed: 0,
+    filesCrashed: 0,
     runnableFiles: 0,
     skippedFiles: 0,
     skipReason: null,
@@ -182,12 +183,15 @@ export function discoverAudioApiCategories({
     .map(([key, meta]) => ({ key, ...meta }));
 }
 
+// Bounds for the per-file failure lists stored in the JSON report, so a
+// catastrophic run cannot balloon the CI artifact.
+const MAX_FAILURES_PER_FILE = 100;
+const MAX_FAILURE_MESSAGE_LENGTH = 200;
+
 export class WptResultsCollector {
   #categories = new Map();
-  #currentSuite = null;
-  #currentCategory = null;
-  #currentSuitePass = 0;
-  #currentSuiteFail = 0;
+  #files = [];
+  #currentFile = null;
 
   #ensureCategory(categoryKey) {
     if (!this.#categories.has(categoryKey)) {
@@ -197,56 +201,117 @@ export class WptResultsCollector {
   }
 
   startSuite(name) {
-    if (this.#currentSuite != null) {
-      this.#finishSuite();
-    }
+    this.#finishFile('ok');
 
-    this.#currentSuite = normalizeTestPath(name);
-    this.#currentCategory = getCategoryKey(this.#currentSuite);
-    this.#currentSuitePass = 0;
-    this.#currentSuiteFail = 0;
+    const suitePath = normalizeTestPath(name);
+    this.#currentFile = {
+      path: suitePath,
+      category: getCategoryKey(suitePath),
+      pass: 0,
+      fail: 0,
+      failures: [],
+      startedAt: Date.now(),
+    };
 
-    const category = this.#ensureCategory(this.#currentCategory);
+    const category = this.#ensureCategory(this.#currentFile.category);
     category.files += 1;
   }
 
   pass() {
-    this.#currentSuitePass += 1;
-    if (this.#currentCategory != null) {
-      this.#ensureCategory(this.#currentCategory).pass += 1;
+    if (this.#currentFile == null) {
+      return;
     }
+    this.#currentFile.pass += 1;
+    this.#ensureCategory(this.#currentFile.category).pass += 1;
   }
 
-  fail() {
-    this.#currentSuiteFail += 1;
-    if (this.#currentCategory != null) {
-      this.#ensureCategory(this.#currentCategory).fail += 1;
+  fail(message) {
+    if (this.#currentFile == null) {
+      return;
     }
+    this.#currentFile.fail += 1;
+    if (
+      typeof message === 'string' &&
+      this.#currentFile.failures.length < MAX_FAILURES_PER_FILE
+    ) {
+      this.#currentFile.failures.push(
+        message.slice(0, MAX_FAILURE_MESSAGE_LENGTH)
+      );
+    }
+    this.#ensureCategory(this.#currentFile.category).fail += 1;
   }
 
-  #finishSuite() {
-    if (this.#currentCategory == null) {
+  /**
+   * Record that the file currently running (or the named file, if none is
+   * in flight) died without finishing — the worker process crashed or the
+   * inactivity watchdog killed it. Counted as a failed file in its category.
+   *
+   * @param {string} path
+   * @param {'crashed' | 'timeout'} status
+   */
+  markFileCrashed(path, status) {
+    const suitePath = normalizeTestPath(path);
+    if (this.#currentFile?.path === suitePath) {
+      this.#finishFile(status);
       return;
     }
 
-    const category = this.#ensureCategory(this.#currentCategory);
-    if (this.#currentSuiteFail === 0 && this.#currentSuitePass > 0) {
+    const category = this.#ensureCategory(getCategoryKey(suitePath));
+    category.files += 1;
+    category.filesFailed += 1;
+    category.filesCrashed += 1;
+    this.#files.push({
+      path: suitePath,
+      pass: 0,
+      fail: 0,
+      failures: [],
+      status,
+      durationMs: null,
+    });
+  }
+
+  #finishFile(status) {
+    if (this.#currentFile == null) {
+      return;
+    }
+
+    const file = this.#currentFile;
+    this.#currentFile = null;
+
+    const category = this.#ensureCategory(file.category);
+    if (status !== 'ok') {
+      category.filesFailed += 1;
+      category.filesCrashed += 1;
+    } else if (file.fail === 0 && file.pass > 0) {
       category.filesPassed += 1;
-    } else if (this.#currentSuiteFail > 0) {
+    } else if (file.fail > 0) {
       category.filesFailed += 1;
     }
+
+    this.#files.push({
+      path: file.path,
+      pass: file.pass,
+      fail: file.fail,
+      failures: file.failures,
+      status,
+      durationMs: Date.now() - file.startedAt,
+    });
   }
 
   finalize() {
-    this.#finishSuite();
-    this.#currentSuite = null;
-    this.#currentCategory = null;
+    this.#finishFile('ok');
   }
 
   getCategoryStats() {
     this.finalize();
     return this.#categories;
   }
+
+  /** Per-file outcomes in run order, for the exact non-regression compare. */
+  getFileResults() {
+    this.finalize();
+    return this.#files;
+  }
 }
 
 function formatRate(pass, total) {
@@ -301,6 +366,7 @@ export function buildReport({
         files: run.files,
         filesPassed: run.filesPassed,
         filesFailed: run.filesFailed,
+        filesCrashed: run.filesCrashed,
         runnableFiles,
         skippedFiles,
         skipped,
@@ -320,6 +386,7 @@ export function buildReport({
       acc.files += category.files;
       acc.filesPassed += category.filesPassed;
       acc.filesFailed += category.filesFailed;
+      acc.filesCrashed += category.filesCrashed;
       acc.runnableFiles += category.runnableFiles;
       return acc;
     },
@@ -329,6 +396,7 @@ export function buildReport({
       files: 0,
       filesPassed: 0,
       filesFailed: 0,
+      filesCrashed: 0,
       runnableFiles: 0,
       skippedCategories: 0,
     }
@@ -359,6 +427,7 @@ export function buildReport({
     durationMs,
     summary,
     categories,
+    files: collector.getFileResults(),
   };
 }
 
@@ -673,7 +742,7 @@ export function wrapReporter(reporter, collector) {
       reporter.pass?.(message);
     },
     fail: (message) => {
-      collector.fail();
+      collector.fail(message);
       reporter.fail?.(message);
     },
     reportStack: (stack) => {
diff --git a/packages/react-native-audio-api/wpt_tests/wpt/wpt-shared.mjs b/packages/react-native-audio-api/wpt_tests/wpt/wpt-shared.mjs
index ee07843ab..19741e1a6 100644
--- a/packages/react-native-audio-api/wpt_tests/wpt/wpt-shared.mjs
+++ b/packages/react-native-audio-api/wpt_tests/wpt/wpt-shared.mjs
@@ -9,6 +9,7 @@ import wptRunner from 'wpt-runner';
 import { wrapAudioNodeConstructors } from './wrap-audio-node-constructors.mjs';
 import { applyChannelMergerSplitterAttributeLocks } from './wpt-only/channel-merger-splitter-attribute-locks.mjs';
 import {
+  setCurrentTestWindow,
   wrapAudioBufferCopyMethods,
   wrapWebAudioRealmErrors,
 } from './wpt-utils.mjs';
@@ -58,6 +59,11 @@ export function walkHtmlFiles(rootDir, prefix = '') {
       files = files.concat(walkHtmlFiles(rootDir, rel));
     } else if (entry.name.endsWith('.html')) {
       files.push(rel);
+    } else if (entry.name.endsWith('.window.js')) {
+      // wpt-runner serves each .window.js as a synthesized <name>.window.html
+      // test and reports it under that name; enumerate it the same way so
+      // batch scheduling and --list see what actually runs.
+      files.push(rel.replace(/\.window\.js$/, '.window.html'));
     }
   }
   return files;
@@ -142,18 +148,60 @@ export function alignGlobalRealmConstructors(window) {
   }
 }
 
+/**
+ * Record every realtime AudioContext a test constructs, so the harness can close
+ * the ones the test abandoned. Each context owns native worker threads that only
+ * a close() (or GC, eventually) releases; without this, leaked contexts pile up
+ * across files and the process ends the run holding hundreds of threads.
+ * OfflineAudioContext has no close() and winds down when its render finishes.
+ */
+function trackRealtimeAudioContexts(window, liveContexts) {
+  const Previous = window.AudioContext;
+  if (typeof Previous !== 'function') {
+    return;
+  }
+
+  function Tracked(...args) {
+    const instance = Reflect.construct(Previous, args, new.target ?? Tracked);
+    liveContexts.add(instance);
+    return instance;
+  }
+  Tracked.prototype = Previous.prototype;
+  Object.defineProperty(Tracked, 'name', { value: Previous.name });
+  window.AudioContext = Tracked;
+}
+
 export function createWptEnvironment() {
   const cleanupEmitter = new EventEmitter();
   const { nodeAudioApi, audioApiForWindow } = loadNodeAudioApi();
   let cancelPendingAnimationFrames = () => {};
+  const liveAudioContexts = new Set();
 
   cleanupEmitter.on('cleanup', () => {
     cancelPendingAnimationFrames();
+
+    // Close whatever realtime contexts the finished test left running. Tests
+    // that closed their own context make close() reject — swallowed on purpose.
+    for (const context of liveAudioContexts) {
+      try {
+        const result = context.close();
+        if (typeof result?.catch === 'function') {
+          result.catch(() => {});
+        }
+      } catch {
+        // Already closed or torn down.
+      }
+    }
+    liveAudioContexts.clear();
   });
 
   const setup = (window) => {
     cleanupEmitter.emit('cleanup');
 
+    // Shared-prototype patches resolve the window through this rather than closing
+    // over it, so a finished test's window stays collectable.
+    setCurrentTestWindow(window);
+
     setFloat32ArrayViewFactory(
       (buffer, byteOffset, length) =>
         new window.Float32Array(buffer, byteOffset, length)
@@ -174,6 +222,9 @@ export function createWptEnvironment() {
     window.requestAnimationFrame = animationFrame.requestAnimationFrame;
     window.cancelAnimationFrame = animationFrame.cancelAnimationFrame;
     cancelPendingAnimationFrames = animationFrame.cancelAll;
+
+    // Last, so it wraps the outermost constructor and records real instances.
+    trackRealtimeAudioContexts(window, liveAudioContexts);
   };
 
   return { setup, cleanupEmitter };
@@ -209,8 +260,17 @@ export function createSequentialFilter({
 }
 
 export async function runSequentialWpt({ filter, reporter }) {
-  const { setup } = createWptEnvironment();
-  return wptRunner(testsPath, { rootURL, setup, filter, reporter });
+  const { setup, cleanupEmitter } = createWptEnvironment();
+  const failures = await wptRunner(testsPath, {
+    rootURL,
+    setup,
+    filter,
+    reporter,
+  });
+  // One final sweep for the last file — 'cleanup' otherwise only fires when the
+  // NEXT file's setup() runs.
+  cleanupEmitter.emit('cleanup');
+  return failures;
 }
 
 export function createReporter(handlers) {
diff --git a/packages/react-native-audio-api/wpt_tests/wpt/wpt-utils.mjs b/packages/react-native-audio-api/wpt_tests/wpt/wpt-utils.mjs
index cf3cf9042..850be8c26 100644
--- a/packages/react-native-audio-api/wpt_tests/wpt/wpt-utils.mjs
+++ b/packages/react-native-audio-api/wpt_tests/wpt/wpt-utils.mjs
@@ -46,6 +46,71 @@ const WEB_AUDIO_CLASSES = [
   'WaveShaperNode',
 ];
 
+/**
+ * The jsdom window of the test file currently running.
+ *
+ * The Web Audio classes are loaded once and shared by every test window, so their
+ * prototypes must be patched once, not per window. A patch that closed over its
+ * `window` would keep that window — and every AudioContext created in it — alive for
+ * the rest of the run, so the shared patches read the current window from here instead.
+ */
+let currentTestWindow = null;
+
+export function setCurrentTestWindow(window) {
+  currentTestWindow = window;
+}
+
+export function getCurrentTestWindow() {
+  return currentTestWindow;
+}
+
+/** Prototype -> "layer:member" pairs already patched, so setup() cannot chain wrappers. */
+const patchedPrototypeMembers = new WeakMap();
+
+/**
+ * Claim `prototype[key]` for one patch layer. Returns false if that layer already
+ * claimed it, which is how repeated setup() calls avoid stacking a new wrapper on the
+ * previous one.
+ *
+ * Layers are independent and compose: several of them legitimately wrap the same member
+ * (realm errors around the Float32Array assertion, say), and each must land exactly once.
+ */
+function claimPrototypeMember(prototype, key, layer) {
+  let patched = patchedPrototypeMembers.get(prototype);
+  if (patched == null) {
+    patched = new Set();
+    patchedPrototypeMembers.set(prototype, patched);
+  }
+  const claim = `${layer}:${key}`;
+  if (patched.has(claim)) {
+    return false;
+  }
+  patched.add(claim);
+  return true;
+}
+
+/**
+ * Install `wrap(original)` as `prototype[methodName]`, at most once per prototype.
+ * Later calls are no-ops, which keeps the wrapper depth at one however many test
+ * files run.
+ *
+ * @param {object} prototype
+ * @param {string} methodName
+ * @param {(original: Function) => Function} wrap
+ * @param {string} layer identifies the patch, so independent layers can each apply once
+ */
+export function patchPrototypeOnce(prototype, methodName, wrap, layer) {
+  if (prototype == null || typeof prototype[methodName] !== 'function') {
+    return;
+  }
+
+  if (!claimPrototypeMember(prototype, methodName, layer)) {
+    return;
+  }
+
+  prototype[methodName] = wrap(prototype[methodName]);
+}
+
 /** Node constructors already wrapped for invalid-argument TypeErrors. */
 export const WRAPPED_NODE_CONSTRUCTORS = new Set([
   'AnalyserNode',
@@ -116,21 +181,26 @@ function toWindowRealmPromise(window, thenable) {
   });
 }
 
-function wrapWithRealmErrors(window, fn) {
+function wrapWithRealmErrors(fn) {
   return function (...args) {
     try {
       const result = fn.apply(this, args);
       if (isThenable(result)) {
-        return toWindowRealmPromise(window, result);
+        return toWindowRealmPromise(getCurrentTestWindow(), result);
       }
       return result;
     } catch (error) {
-      throw toWindowRealmError(window, error);
+      throw toWindowRealmError(getCurrentTestWindow(), error);
     }
   };
 }
 
-function wrapPrototypeMembers(window, ctor) {
+/**
+ * Wrap every method and accessor on `ctor.prototype` so errors surface in the test's
+ * realm. The Web Audio classes are shared by all test windows, so each member is
+ * wrapped once and the wrapper looks the window up per call.
+ */
+function wrapPrototypeMembers(ctor) {
   if (typeof ctor !== 'function') {
     return;
   }
@@ -146,24 +216,30 @@ function wrapPrototypeMembers(window, ctor) {
       continue;
     }
 
-    if (desc.get != null || desc.set != null) {
+    const isAccessor = desc.get != null || desc.set != null;
+    if (!isAccessor && typeof desc.value !== 'function') {
+      continue;
+    }
+    if (!claimPrototypeMember(proto, key, 'realm-errors')) {
+      continue;
+    }
+
+    if (isAccessor) {
       const replacement = { ...desc };
       if (desc.get != null) {
-        replacement.get = wrapWithRealmErrors(window, desc.get);
+        replacement.get = wrapWithRealmErrors(desc.get);
       }
       if (desc.set != null) {
-        replacement.set = wrapWithRealmErrors(window, desc.set);
+        replacement.set = wrapWithRealmErrors(desc.set);
       }
       Object.defineProperty(proto, key, replacement);
       continue;
     }
 
-    if (typeof desc.value === 'function') {
-      Object.defineProperty(proto, key, {
-        ...desc,
-        value: wrapWithRealmErrors(window, desc.value),
-      });
-    }
+    Object.defineProperty(proto, key, {
+      ...desc,
+      value: wrapWithRealmErrors(desc.value),
+    });
   }
 }
 
@@ -188,7 +264,7 @@ function wrapConstructorWithRealmErrors(window, name) {
 
 export function wrapWebAudioRealmErrors(window) {
   for (const name of WEB_AUDIO_CLASSES) {
-    wrapPrototypeMembers(window, window[name]);
+    wrapPrototypeMembers(window[name]);
 
     if (!WRAPPED_NODE_CONSTRUCTORS.has(name)) {
       wrapConstructorWithRealmErrors(window, name);
@@ -224,29 +300,25 @@ export function wrapAudioBufferCopyMethods(window) {
     return;
   }
 
-  const originalCopyFromChannel = AudioBuffer.prototype.copyFromChannel;
-  const originalCopyToChannel = AudioBuffer.prototype.copyToChannel;
+  patchPrototypeOnce(
+    AudioBuffer.prototype,
+    'copyFromChannel',
+    (original) =>
+      function copyFromChannel(destination, channelNumber, startInChannel = 0) {
+        assertFloat32Array(destination, 'destination', getCurrentTestWindow());
+        return original.call(this, destination, channelNumber, startInChannel);
+      },
+    'float32-assert'
+  );
 
-  AudioBuffer.prototype.copyFromChannel = function copyFromChannel(
-    destination,
-    channelNumber,
-    startInChannel = 0
-  ) {
-    assertFloat32Array(destination, 'destination', window);
-    return originalCopyFromChannel.call(
-      this,
-      destination,
-      channelNumber,
-      startInChannel
-    );
-  };
-
-  AudioBuffer.prototype.copyToChannel = function copyToChannel(
-    source,
-    channelNumber,
-    startInChannel = 0
-  ) {
-    assertFloat32Array(source, 'source', window);
-    return originalCopyToChannel.call(this, source, channelNumber, startInChannel);
-  };
+  patchPrototypeOnce(
+    AudioBuffer.prototype,
+    'copyToChannel',
+    (original) =>
+      function copyToChannel(source, channelNumber, startInChannel = 0) {
+        assertFloat32Array(source, 'source', getCurrentTestWindow());
+        return original.call(this, source, channelNumber, startInChannel);
+      },
+    'float32-assert'
+  );
 }
diff --git a/packages/react-native-audio-api/wpt_tests/wpt/wpt-worker.mjs b/packages/react-native-audio-api/wpt_tests/wpt/wpt-worker.mjs
new file mode 100644
index 000000000..43f7b568e
--- /dev/null
+++ b/packages/react-native-audio-api/wpt_tests/wpt/wpt-worker.mjs
@@ -0,0 +1,84 @@
+/**
+ * Child process entry for batched WPT runs (see wpt-harness.mjs).
+ *
+ * Runs one batch of test files in-process and streams reporter events to the
+ * parent over IPC. Keeping batches in short-lived children means native state
+ * (audio threads, event-registry entries) accumulates only across a batch, a
+ * native crash loses one file instead of the whole run, and the final
+ * process.exit() of each child tears down a small heap — the parent survives
+ * even if that teardown hangs.
+ *
+ * Protocol (child -> parent):
+ *   { type: 'suite-start', name }   a test file began
+ *   { type: 'pass', message }       one subtest passed
+ *   { type: 'fail', message }       one subtest failed
+ *   { type: 'stack', stack }        stack trace for the preceding failure
+ *   { type: 'done', fileFailures }  batch finished; parent may kill us
+ *
+ * Parent -> child: a single { files: string[] } message starts the batch.
+ */
+
+import {
+  createReporter,
+  normalizeTestPath,
+  runSequentialWpt,
+} from './wpt-shared.mjs';
+import { getCurrentTestWindow } from './wpt-utils.mjs';
+
+// In a browser, an exception thrown from an event handler (e.g. an assert
+// inside `oncomplete`) surfaces as a window `error` event, which testharness
+// turns into a fast harness failure. In Node the same throw would kill this
+// worker. Forward it into the running test's window so the file fails
+// immediately instead of crashing the batch or idling into the 10s timeout.
+process.on('uncaughtException', (error) => {
+  const window = getCurrentTestWindow();
+  try {
+    window.dispatchEvent(
+      new window.ErrorEvent('error', {
+        error,
+        message: String(error?.message ?? error),
+      })
+    );
+  } catch {
+    console.error('uncaught exception with no active test window:', error);
+  }
+});
+
+function send(message) {
+  // The parent may already have killed us (e.g. its inactivity watchdog fired
+  // while an event was in flight); losing that race is fine.
+  try {
+    process.send(message);
+  } catch {
+    // Channel closed — nothing left to report to.
+  }
+}
+
+process.on('message', async ({ files }) => {
+  const batch = new Set(files.map(normalizeTestPath));
+
+  const reporter = createReporter({
+    startSuite: (name) => send({ type: 'suite-start', name }),
+    pass: (message) => send({ type: 'pass', message }),
+    fail: (message) => send({ type: 'fail', message }),
+    reportStack: (stack) => send({ type: 'stack', stack }),
+  });
+
+  let fileFailures = 0;
+  try {
+    fileFailures = await runSequentialWpt({
+      filter: (name) => batch.has(normalizeTestPath(name)),
+      reporter,
+    });
+  } catch (error) {
+    send({ type: 'fail', message: `worker error: ${error.message}` });
+    send({ type: 'stack', stack: error.stack ?? String(error) });
+    fileFailures = Math.max(fileFailures, 1);
+  }
+
+  send({ type: 'done', fileFailures });
+  // Native teardown (audio thread joins, registry destruction) happens inside
+  // this exit. The parent holds every result already, waits briefly, and
+  // SIGKILLs us if teardown hangs — the historical CI "exit code 129" mode.
+  process.exit(0);
+});
diff --git a/packages/react-native-audio-api/wpt_tests/wpt/wrap-audio-node-constructors.mjs b/packages/react-native-audio-api/wpt_tests/wpt/wrap-audio-node-constructors.mjs
index 26b773f8e..871643b5f 100644
--- a/packages/react-native-audio-api/wpt_tests/wpt/wrap-audio-node-constructors.mjs
+++ b/packages/react-native-audio-api/wpt_tests/wpt/wrap-audio-node-constructors.mjs
@@ -5,6 +5,8 @@
  */
 
 import {
+  getCurrentTestWindow,
+  patchPrototypeOnce,
   toWindowRealmError,
   WRAPPED_NODE_CONSTRUCTORS,
 } from './wpt-utils.mjs';
@@ -92,22 +94,21 @@ function wrapAudioNodeConnectDisconnect(window) {
     return;
   }
 
-  const originalConnect = AudioNode.prototype.connect;
-  const originalDisconnect = AudioNode.prototype.disconnect;
-
-  AudioNode.prototype.connect = function connect(...args) {
-    try {
-      return originalConnect.apply(this, args);
-    } catch (error) {
-      throw toWindowRealmError(window, error);
-    }
-  };
-
-  AudioNode.prototype.disconnect = function disconnect(...args) {
-    try {
-      return originalDisconnect.apply(this, args);
-    } catch (error) {
-      throw toWindowRealmError(window, error);
-    }
-  };
+  // AudioNode is shared by every test window, so these go on once and resolve the
+  // window at call time — see patchPrototypeOnce.
+  for (const methodName of ['connect', 'disconnect']) {
+    patchPrototypeOnce(
+      AudioNode.prototype,
+      methodName,
+      (original) =>
+        function (...args) {
+          try {
+            return original.apply(this, args);
+          } catch (error) {
+            throw toWindowRealmError(getCurrentTestWindow(), error);
+          }
+        },
+      'connect-realm-errors'
+    );
+  }
 }