diff --git a/README.md b/README.md
index e56a048..dd8d61d 100644
--- a/README.md
+++ b/README.md
@@ -21,11 +21,11 @@ The earlier ChatGPT discussion, **Discuss Application Vision** (conversation `6a
 
 ## Planning entry point
 
-Phase 0 is complete, the production runtime is implemented through Phase 3c slice 3 (automation), and the audio subsystem contract is written through Phase 3c. Work is stopped at the user-requested slice-3 checkpoint. The next slice is 3c-4 (measured master protection), which requires user-observed hardware measurements and listening; it has not been started. The Phase 1 direct-file two-fixture restart and Phase 3 audible acceptance remain open — no sound has been heard from a production build. Workload measurements and release soak tests remain later explicit gates.
+Phase 0 is complete, and the production runtime is implemented through Phase 3c slice 4 (master protection), with 102 automated tests passing. Slice 4's hardware measurement and listening acceptance remain pending; the [standalone audio acceptance page](prototypes/phase3/XZBT-audio-acceptance.html) and [run instructions](prototypes/phase3/README.md) are ready for user testing. The Phase 1 direct-file two-fixture restart and Phase 3 audible acceptance remain open — no sound has been heard from a production build. Combined workload measurements and release soak tests remain later explicit gates.
 
 The full PRD completion criteria remain the 0.1 release target. Early integrated demonstrations are milestones, not completed MVPs. Reference exhibits develop alongside the engine; Phase 9 completes and audits the suite.
 
-All 10 Phase 0 direct-file feasibility checks in GC1 are verified, and the GC2–GC5 contract oracles pass. Phase 1 turns those contracts into a standalone runtime shell with import, caching, activation control, diagnostics, and production seeded RNG. Phase 2 adds parameters, state, signals, values, conditions, actions, bindings, transitions, overrides, and per-exhibit parameter persistence. Phases 3a and 3b add the audio graph contract and engine; Phase 3c slices 1–3 add the remaining audio contract, lifecycle/voice management, and automation. Master protection, visual, cadence, scenario, UI, library-hardening, benchmark, and soak gates remain explicit in the implementation plan.
+All 10 Phase 0 direct-file feasibility checks in GC1 are verified, and the GC2–GC5 contract oracles pass. Phase 1 turns those contracts into a standalone runtime shell with import, caching, activation control, diagnostics, and production seeded RNG. Phase 2 adds parameters, state, signals, values, conditions, actions, bindings, transitions, overrides, and per-exhibit parameter persistence. Phases 3a and 3b add the audio graph contract and engine; Phase 3c adds the remaining audio contract, lifecycle/voice management, automation and master protection. Measured protection acceptance, visual, cadence, scenario, UI, library-hardening, benchmark, and soak gates remain explicit in the implementation plan.
 
 ## Repository configuration
 
@@ -71,7 +71,7 @@ The active performance supports typed parameters and state, read-only runtime si
 
 The runtime implements recipe `release`, the seven-state lifecycle, determinable one-shot endings, voice ceilings, and graph-local `automation`. Tracks support `absolute`, `offset`, and `scale`, with `step`, `linear`, `exponential`, and `smooth` interpolation. Values are sampled once from the owning sound's seeded stream; duplicate targets and expanded limits are validated. Exposed component parameters participate without exposing component internals. Bus gains now use the shared binding → automation → override → modulation → clamp resolver. Bus automation/modulation registration is internal: the contract does not add document fields to buses or permit external node bindings/overrides.
 
-Master protection is still the placeholder chain. No sound has yet been heard from a production build; measured protection, the audio acceptance challenge, real GC4 synchronization, peak/finite-sample capture, and listening observations remain open Phase 3 gates. Visuals, cadence, events, scenarios, and the final schema-driven UI remain assigned to later phases.
+Master protection now uses an engine-owned AudioWorklet limiter with finite-sample guards and output measurement support. `npm run build:audio-acceptance` builds the self-contained hardware capture page using the production engine and frozen stress/challenge fixtures. No sound has yet been heard from a production build; real-browser measured protection, the audio acceptance challenge, real GC4 synchronization and listening observations remain open Phase 3 gates. See the [slice-4 evidence](docs/evidence/phase3/2026-09-05-phase3c-protection.md). Visuals, cadence, events, scenarios, and the final schema-driven UI remain assigned to later phases.
 
 ## Local development server
 
diff --git a/XZBT.html b/XZBT.html
index e6d7df1..31c2348 100644
--- a/XZBT.html
+++ b/XZBT.html
@@ -554,6 +554,16 @@ class ConditionEvaluator {
 const AUDIO_STATIC_MAX_FREQUENCY = 24000;
 const AUDIO_NYQUIST_FACTOR = 0.45;
 
+// Engine-owned candidate values; hardware/listening acceptance remains GC6.
+const AUDIO_PROTECTION = Object.freeze({
+  ceilingDb: -1,
+  toleranceDb: 0.1,
+  lookaheadMs: 5,
+  attackMs: 0.5,
+  releaseMs: 250,
+  channels: 2
+});
+
 const AUDIO_LIMITS = Object.freeze({
   nodesPerSound: 128,
   routesPerSound: 256,
@@ -784,6 +794,145 @@ function isSourceType(type) {
   return entry?.class === 'source' || entry?.class === 'control';
 }
 
+/* src/runtime/audio-protection.js */
+// This exact class is serialized into the embedded worklet and exercised in tests.
+// No browser globals or imports are used by the DSP core.
+class MasterProtectionDSP {
+  constructor(rate, settings) {
+    this.ceiling = 10 ** (settings.ceilingDb / 20);
+    this.delayFrames = Math.max(1, Math.ceil(rate * settings.lookaheadMs / 1000));
+    this.delay = Array.from({ length: settings.channels }, () => new Float32Array(this.delayFrames));
+    this.attack = Math.exp(-1 / (rate * settings.attackMs / 1000));
+    this.release = Math.exp(-1 / (rate * settings.releaseMs / 1000));
+    this.position = 0;
+    this.gain = 1;
+    this.heldPeak = 0;
+    this.hold = 0;
+    this.affectedBlocks = 0;
+  }
+
+  process(input, output, fault = false) {
+    let badSamples = 0;
+    for (const channel of input) for (const sample of channel) if (!Number.isFinite(sample)) badSamples++;
+    const muted = fault || badSamples > 0;
+    if (muted) {
+      // Flush pending audio as well: no corrupted history can reappear later.
+      for (const channel of this.delay) channel.fill(0);
+      for (const channel of output) channel.fill(0);
+      this.heldPeak = 0;
+      this.hold = 0;
+      this.affectedBlocks++;
+      return { muted, badSamples, peak: 0, clampedSamples: 0 };
+    }
+    let peak = 0, clampedSamples = 0;
+    for (let i = 0; i < output[0].length; i++) {
+      let incomingPeak = 0;
+      for (const channel of input) incomingPeak = Math.max(incomingPeak, Math.abs(channel[i] ?? 0));
+      if (incomingPeak >= this.heldPeak) {
+        this.heldPeak = incomingPeak;
+        this.hold = this.delayFrames;
+      } else if (this.hold > 0) this.hold--;
+      else this.heldPeak = incomingPeak;
+      const target = this.heldPeak > this.ceiling ? this.ceiling / this.heldPeak : 1;
+      const coefficient = target < this.gain ? this.attack : this.release;
+      this.gain = target + coefficient * (this.gain - target);
+      for (let c = 0; c < output.length; c++) {
+        const delayed = this.delay[c][this.position];
+        this.delay[c][this.position] = input[c]?.[i] ?? 0;
+        const value = delayed * this.gain;
+        if (Math.abs(value) > this.ceiling) clampedSamples++;
+        // Final sample clamp is required even during attack and extreme overload.
+        output[c][i] = Math.max(-this.ceiling, Math.min(this.ceiling, value));
+        peak = Math.max(peak, Math.abs(output[c][i]));
+      }
+      this.position = (this.position + 1) % this.delayFrames;
+    }
+    return { muted, badSamples, peak, clampedSamples };
+  }
+}
+
+function protectionWorkletSource() {
+  return `const SETTINGS = ${JSON.stringify(AUDIO_PROTECTION)};
+${MasterProtectionDSP.toString()}
+class XZBTProtectionProcessor extends AudioWorkletProcessor {
+  constructor(options) {
+    super();
+    this.guard = options.processorOptions?.guard === true;
+    this.dsp = this.guard ? null : new MasterProtectionDSP(sampleRate, SETTINGS);
+    this.warned = false;
+    this.capture = null;
+    this.port.onmessage = ({ data }) => {
+      if (data.type === 'capture' && !this.guard) {
+        this.capture = { id: data.id, skip: data.warmupFrames, remaining: data.frames,
+          frames: 0, peak: 0, affectedBlocks: 0, nonfiniteSamples: 0, clampedSamples: 0 };
+      }
+    };
+  }
+  process(inputs, outputs) {
+    const input = inputs[0] ?? [], output = outputs[0];
+    let result;
+    if (this.guard) {
+      let badSamples = 0;
+      for (const channel of input) for (const sample of channel) if (!Number.isFinite(sample)) badSamples++;
+      for (let c = 0; c < output.length; c++) {
+        output[c].fill(0);
+        if (!badSamples && input[c]) output[c].set(input[c]);
+      }
+      // Separate finite fault lane lets the final master mute the same whole
+      // render quantum, while attribution remains attached to this voice.
+      outputs[1][0].fill(badSamples);
+      result = { badSamples, muted: badSamples > 0 };
+    } else {
+      const fault = (inputs[1] ?? []).some(channel => channel.some(value => value !== 0));
+      result = this.dsp.process(input, output, fault);
+      const capture = this.capture;
+      if (capture) {
+        const start = Math.min(capture.skip, output[0].length);
+        capture.skip -= start;
+        const count = Math.min(capture.remaining, output[0].length - start);
+        if (count > 0) {
+          for (const channel of output) for (let i = start; i < start + count; i++) capture.peak = Math.max(capture.peak, Math.abs(channel[i]));
+          capture.frames += count;
+          capture.remaining -= count;
+          capture.affectedBlocks += result.muted ? 1 : 0;
+          capture.nonfiniteSamples += result.badSamples + (inputs[1]?.[0]?.[0] ?? 0);
+          capture.clampedSamples += result.clampedSamples;
+        }
+        if (capture.remaining === 0) {
+          this.port.postMessage({ type: 'capture', ...capture, sampleRate });
+          this.capture = null;
+        }
+      }
+    }
+    if (result.badSamples > 0 && !this.warned) {
+      this.warned = true;
+      this.port.postMessage({ type: 'nonfinite' });
+    }
+    return true;
+  }
+}
+registerProcessor('xzbt-protection', XZBTProtectionProcessor);`;
+}
+
+async function loadProtectionWorklet(context) {
+  if (!context.audioWorklet || typeof globalThis.AudioWorkletNode !== 'function') {
+    throw new Error('AudioWorklet master protection is unavailable.');
+  }
+  // The Phase 0 direct-file probe verified this embedded data-URL loading path.
+  await context.audioWorklet.addModule(`data:text/javascript;charset=utf-8,${encodeURIComponent(protectionWorkletSource())}`);
+}
+
+function createProtectionNode(context, guard = false) {
+  return new AudioWorkletNode(context, 'xzbt-protection', {
+    numberOfInputs: guard ? 1 : 2,
+    numberOfOutputs: guard ? 2 : 1,
+    outputChannelCount: guard ? [AUDIO_PROTECTION.channels, 1] : [AUDIO_PROTECTION.channels],
+    channelCount: AUDIO_PROTECTION.channels,
+    channelCountMode: 'explicit',
+    processorOptions: { guard }
+  });
+}
+
 /* src/runtime/audio-automation.js */
 // Shared numeric stages and immutable, once-sampled automation (spec 8.1 / 16.1).
 
@@ -2956,6 +3105,7 @@ class ActivationController {
 
 
 
+
 function soundInstanceKey(soundId, ordinal) {
   return `${soundId}#${ordinal}`;
 }
@@ -3508,7 +3658,10 @@ class SoundInstance {
   }
 
   realize(context, destination) {
-    this.realized = realizeSoundGraph(context, this.plan, destination);
+    const guard = this.subsystem?.createVoiceGuard(this);
+    this.guard = guard;
+    if (guard) guard.connect(destination);
+    this.realized = realizeSoundGraph(context, this.plan, guard ?? destination);
     return this.realized;
   }
 
@@ -3617,6 +3770,13 @@ class SoundInstance {
       this.realized = null;
     }
     this.plan = null;
+    if (this.guard) {
+      this.guard.port.onmessage = null;
+      this.guard.onprocessorerror = null;
+      this.guard.port.close();
+      this.guard.disconnect();
+      this.guard = null;
+    }
     this.bus = null;
     this.context = null;
   }
@@ -3627,11 +3787,11 @@ class SoundInstance {
  * ------------------------------------------------------------------ */
 
 // Owns the AudioContext, the declared buses, and the engine master chain, and turns a
-// sound definition into a realized voice. The lifecycle state machine (PRD 57), voice
-// ceilings (16.6), and the measured master-protection contract (PRD 58) are Phase 3c;
-// the master chain built here is engine-owned and unbypassable.
+// sound definition into a realized voice. All buses and volume controls are upstream
+// of the final protection worklet; hardware/listening acceptance is tracked in GC6.
 class AudioSubsystem {
-  constructor({ document, rng, diagnostics = null, contextFactory = null, voiceLimits = null, resolutionEngine = null } = {}) {
+  constructor({ document, rng, diagnostics = null, contextFactory = null, voiceLimits = null, resolutionEngine = null,
+    protectionFactory = { load: loadProtectionWorklet, create: createProtectionNode } } = {}) {
     this.document = document;
     this.rng = rng;
     this.diagnostics = diagnostics;
@@ -3651,6 +3811,13 @@ class AudioSubsystem {
     this.ordinals = new Map();
     this.nextCreationOrder = 0;
     this.masterVolume = 0.8;
+    this.protectionFactory = protectionFactory;
+    this.ready = false;
+    this.disposed = false;
+    this.unlockPending = null;
+    this.capturePending = null;
+    this.captureSequence = 0;
+    this.unavailableWarned = false;
   }
 
   get available() {
@@ -3658,35 +3825,123 @@ class AudioSubsystem {
   }
 
   get unlocked() {
-    return this.context !== null && this.context.state === 'running';
+    return this.ready && this.context !== null && this.context.state === 'running';
   }
 
   // Must be called from a user gesture; browsers refuse to start audio otherwise.
   async unlock() {
-    if (!this.available) {
-      this.diagnostics?.warn('WARN_AUDIO_UNAVAILABLE', 'This browser exposes no AudioContext; audio is disabled.', { section: 'audio' });
-      return false;
-    }
-    if (!this.context) {
-      this.context = this.contextFactory();
-      this.buildMaster();
-      this.buildBuses();
-    }
-    if (this.context.state === 'suspended') await this.context.resume();
-    return this.unlocked;
+    if (this.disposed) return false;
+    if (this.unlockPending) return this.unlockPending;
+    this.unlockPending = this.initializeAudio();
+    try { return await this.unlockPending; }
+    finally { this.unlockPending = null; }
   }
 
-  buildMaster() {
+  async initializeAudio() {
+    try {
+      if (this.protectionFailed) throw new Error('Master protection failed; reactivate the exhibit to restart audio.');
+      if (!this.available) throw new Error('This browser exposes no AudioContext.');
+      if (!this.context) this.context = this.contextFactory();
+      const context = this.context;
+      // Resume synchronously with the gesture before awaiting module loading.
+      const resume = context.state === 'suspended' ? context.resume() : Promise.resolve();
+      await Promise.all([resume, this.ready ? Promise.resolve() : this.buildMaster()]);
+      if (this.disposed || this.context !== context) return false;
+      if (context.state !== 'running') throw new Error('The audio context did not enter the running state.');
+      if (!this.ready) this.buildBuses();
+      this.ready = true;
+      return this.unlocked;
+    } catch (error) {
+      this.ready = false;
+      for (const instance of [...this.oneshotVoices, ...this.continuousVoices]) instance.dispose();
+      this.disconnectMaster();
+      const context = this.context;
+      this.context = null;
+      try { await context?.close(); } catch { /* already closed */ }
+      if (!this.unavailableWarned && !this.disposed) {
+        this.unavailableWarned = true;
+        this.diagnostics?.warn('WARN_AUDIO_UNAVAILABLE', `Audio disabled: ${error.message}`, { section: 'audio' });
+      }
+      return false;
+    }
+  }
+
+  async buildMaster() {
     const context = this.context;
-    this.protection = context.createDynamicsCompressor();
-    this.protection.threshold.value = -3;
-    this.protection.knee.value = 0;
-    this.protection.ratio.value = 20;
-    this.protection.attack.value = 0.003;
-    this.protection.release.value = 0.25;
+    await this.protectionFactory.load(context);
+    if (this.disposed || this.context !== context) return;
+    this.protection = this.protectionFactory.create(context, false);
+    this.protection.port.onmessage = ({ data }) => {
+      if (data.type === 'nonfinite') this.warnNonfinite('master');
+      if (data.type === 'capture' && data.id === this.capturePending?.id) {
+        const pending = this.capturePending;
+        this.capturePending = null;
+        pending.resolve(data);
+      }
+    };
+    this.protection.onprocessorerror = () => {
+      this.ready = false;
+      this.protectionFailed = true;
+      this.capturePending?.reject(new Error('Master protection processor failed.'));
+      this.capturePending = null;
+      this.protection?.disconnect();
+      this.diagnostics?.warn('WARN_AUDIO_UNAVAILABLE', 'Master protection failed; output is muted.', { section: 'audio' });
+    };
     this.master = context.createGain();
     this.master.gain.value = this.masterVolume;
-    this.protection.connect(this.master).connect(context.destination);
+    this.master.connect(this.protection).connect(context.destination);
+  }
+
+  warnNonfinite(instanceId) {
+    this.diagnostics?.warn('WARN_AUDIO_NONFINITE', 'A non-finite audio sample was detected; the containing output block was muted.', { section: 'audio', objectId: instanceId });
+  }
+
+  createVoiceGuard(instance) {
+    const guard = this.protectionFactory.create(this.context, true);
+    const instanceId = instance.plan?.instanceKey ?? soundInstanceKey(instance.soundId, instance.creationOrder);
+    guard.port.onmessage = ({ data }) => {
+      if (data.type === 'nonfinite') this.warnNonfinite(instanceId);
+    };
+    guard.onprocessorerror = () => {
+      instance.dispose();
+      this.diagnostics?.warn('WARN_AUDIO_UNAVAILABLE', `Audio guard failed for '${instance.soundId}'; voice disposed.`, { section: 'audio', objectId: instance.soundId });
+    };
+    try { guard.connect(this.protection, 1, 1); }
+    catch (error) {
+      guard.port.onmessage = null;
+      guard.onprocessorerror = null;
+      guard.port.close();
+      guard.disconnect();
+      throw error;
+    }
+    return guard;
+  }
+
+  captureOutput({ seconds = 120, warmupSeconds = 30 } = {}) {
+    if (!this.unlocked) return Promise.reject(new Error('Unlock protected audio before capturing.'));
+    if (this.capturePending) return Promise.reject(new Error('An output capture is already running.'));
+    if (!Number.isFinite(seconds) || seconds <= 0 || !Number.isFinite(warmupSeconds) || warmupSeconds < 0) return Promise.reject(new Error('Invalid capture duration.'));
+    return new Promise((resolve, reject) => {
+      const id = ++this.captureSequence;
+      this.capturePending = { id, resolve, reject };
+      this.protection.port.postMessage({ type: 'capture', id,
+        frames: Math.max(1, Math.round(seconds * this.context.sampleRate)),
+        warmupFrames: Math.round(warmupSeconds * this.context.sampleRate) });
+    });
+  }
+
+  disconnectMaster() {
+    for (const bus of this.buses.values()) bus.disconnect();
+    this.buses.clear();
+    this.master?.disconnect();
+    if (this.protection) {
+      this.protection.port.onmessage = null;
+      this.protection.port.close();
+      this.protection.onprocessorerror = null;
+      this.protection.disconnect();
+    }
+    this.master = null;
+    this.protection = null;
   }
 
   buildBuses() {
@@ -3694,14 +3949,14 @@ class AudioSubsystem {
     for (const id of Object.keys(declared)) {
       const gain = this.context.createGain();
       gain.gain.value = this.resolution.get(`audio.buses.${id}.gain`);
-      gain.connect(this.protection);
+      gain.connect(this.master);
       this.buses.set(id, gain);
     }
   }
 
   busFor(soundId) {
     const name = this.document?.sounds?.[soundId]?.bus;
-    return (name && this.buses.get(name)) || this.protection;
+    return (name && this.buses.get(name)) || this.master;
   }
 
   setBusGain(id, value) {
@@ -3713,6 +3968,7 @@ class AudioSubsystem {
   }
 
   setMasterVolume(value) {
+    if (!Number.isFinite(value)) return;
     this.masterVolume = Math.min(1, Math.max(0, value));
     if (this.master) this.master.gain.value = this.masterVolume;
   }
@@ -3830,12 +4086,16 @@ class AudioSubsystem {
   }
 
   async dispose() {
+    this.disposed = true;
+    this.ready = false;
+    this.capturePending?.reject(new Error('Audio disposed during output capture.'));
+    this.capturePending = null;
     this.unsubscribeResolution?.();
     this.unsubscribeResolution = null;
     this.stopAll();
     for (const instance of [...this.oneshotVoices]) instance.dispose();
     for (const instance of [...this.continuousVoices]) instance.dispose();
-    this.buses.clear();
+    this.disconnectMaster();
     if (this.context) {
       try { await this.context.close(); } catch { /* already closed */ }
     }
diff --git a/docs/IMPLEMENTATION_STATUS.md b/docs/IMPLEMENTATION_STATUS.md
index 516cd67..94c7ce6 100644
--- a/docs/IMPLEMENTATION_STATUS.md
+++ b/docs/IMPLEMENTATION_STATUS.md
@@ -1,10 +1,10 @@
 # XZBT implementation status
 
 **Updated:** September 5, 2026
-**State:** Phase 3c slices 1–3 complete; stopped at the user-requested slice-3 checkpoint. Master protection (slice 4), the Phase 3 audible gates, and the Phase 1 direct-file import/restart observation remain pending
+**State:** Phase 3c slices 1–3 complete; slice 4 master protection implemented and automatically verified. Slice 4 hardware measurement/listening acceptance, the Phase 3 audible gates, and the Phase 1 direct-file import/restart observation remain pending
 **Planning baseline:** `05fe2b4e021ba86e4a290d05b63c7cae0e386128`
 
-**Exact demarcation:** GC1 direct-file feasibility (10/10 checks), GC2 shared format contracts, GC3 resolution semantics, GC4 clock/PRNG semantics, and GC5 ownership/failure semantics are complete at the Phase 0 contract-oracle level. The Phase 1 production runtime skeleton, Phase 2 common grammar, and audio engine through Phase 3c slice 3 pass automated checks. Phase 1's direct-file two-fixture restart observation, Phase 3's audible acceptance (no sound has been heard from a production build), and measured master protection remain open. Visual, cadence/event, scenario, final generated-UI, performance, and soak work remains assigned to later phases.
+**Exact demarcation:** GC1 direct-file feasibility (10/10 checks), GC2 shared format contracts, GC3 resolution semantics, GC4 clock/PRNG semantics, and GC5 ownership/failure semantics are complete at the Phase 0 contract-oracle level. The Phase 1 production runtime skeleton, Phase 2 common grammar, and audio engine through Phase 3c slice 4's implementation pass automated checks. Phase 1's direct-file two-fixture restart observation, Phase 3's audible acceptance (no sound has been heard from a production build), and real-browser measured master protection remain open. Visual, cadence/event, scenario, final generated-UI, performance, and soak work remains assigned to later phases.
 
 The user requested sequential implementation with a stop on problems. The [manual version 3 evidence](evidence/phase0/2026-09-04-user-run-v3.md) verifies embedded data-URL worklet loading in direct-file Chrome. The subsequent [user-performed restart test](evidence/phase0/2026-09-04-user-restart.md) restored Blue Study activity 0.37 and master volume 0.19 immediately on reopening. Native tone output and AudioContext suspend/resume are also observed. Ordinary file import, selection of both exhibits, regular Chrome mode, and [directory cancellation/denial fallback](evidence/phase0/2026-09-05-user-directory-fallback.md) have been confirmed.
 
@@ -13,7 +13,7 @@ The user requested sequential implementation with a stop on problems. The [manua
 | 0 — Contracts and feasibility | Complete | GC1 passed; GC2–GC5 shared contracts and traces passed; GC6/GC7 later gates scheduled and mapped |
 | 1 — Runtime skeleton | Implemented; acceptance pending | [Automated evidence](evidence/phase1/2026-09-05-runtime-skeleton.md) passes production-module, lifecycle, PRNG-vector, cache/restore, fixture-validation, and deterministic-build tests. Direct-file two-fixture import/restart remains a user-observed gate. |
 | 2 — Common grammar | Complete | [Automated evidence](evidence/phase2/2026-09-05-common-grammar.md) covers production GC2 conformance, typed values, signals, actions, same-tick bindings, transitions, override precedence/release, and parameter restoration. |
-| 3 — Audio engine | Slices 3c-1 (contract), 3c-2 (lifecycle/voices), and 3c-3 (automation) complete; stopped before slice 4 | [Audio authoring evidence](evidence/phase3/2026-09-05-audio-authoring-contract.md), [contract evidence](evidence/phase3/2026-09-05-phase3c-contract.md), [lifecycle/voice evidence](evidence/phase3/2026-09-05-phase3c-lifecycle-voices.md), and [automation evidence](evidence/phase3/2026-09-05-phase3c-automation.md). Slice 4 requires measured master protection and user listening; PRD 129 and real GC4 audio acceptance remain open. |
+| 3 — Audio engine | Slices 3c-1–3 complete; 3c-4 implementation verified, user acceptance pending | [Contract](evidence/phase3/2026-09-05-phase3c-contract.md), [lifecycle/voices](evidence/phase3/2026-09-05-phase3c-lifecycle-voices.md), [automation](evidence/phase3/2026-09-05-phase3c-automation.md), and [protection evidence](evidence/phase3/2026-09-05-phase3c-protection.md). Slice 4 requires real-browser measurement and user listening; PRD 129 and real GC4 audio acceptance remain open. |
 | 4 — Visual engine | Not started | Earlier phases and visual contracts |
 | 5 — Events and cadence | Not started | Earlier phases and event/cadence contracts |
 | 6 — Scenario director | Not started | Earlier phases and scenario contracts |
@@ -63,7 +63,7 @@ At the Phase 3a/3b checkpoint, automation, lifecycle/voices, and measured protec
 
 ## Phase 3c contract (slice 1)
 
-Format Specification section 16 completes the audio subsystem contract. Phase 3c is delivered in four slices, recorded in the implementation plan: the contract (done), lifecycle and voices (done), automation (done), and measured master protection (pending). Each slice ends green and committable.
+Format Specification section 16 completes the audio subsystem contract. Phase 3c is delivered in four slices, recorded in the implementation plan: the contract (done), lifecycle and voices (done), automation (done), and measured master protection (implementation done; user acceptance pending). Each slice ends green and committable.
 
 Section 16 was contract only at slice 1.
 
@@ -81,4 +81,12 @@ Slice 3c-3 implements section 16.1 graph-local tracks, all three modes and four
 
 `npm test` passes **88 tests**, including 21 new slice-3 tests. The self-contained build is deterministic; the artifact digest is `6aa1b659e1f06ca3175ac62a4544cc3342e8731f6d6f186c68fcd667cf683d97`. See the [slice-3 evidence](evidence/phase3/2026-09-05-phase3c-automation.md) for exact coverage, scheduling precision, and the test boundary.
 
-**Stop:** Slice 3 is complete; wait for the user before starting slice 4. The master chain is unchanged. Measured protection, audible acceptance, and real GC4 synchronization are not claimed by the automated tests.
+**Historical checkpoint:** Slice 3 ended with the master chain unchanged. The user subsequently authorized slice 4, recorded below.
+
+## Phase 3c master protection (slice 4)
+
+The placeholder compressor is replaced by an embedded AudioWorklet with stereo-linked lookahead limiting, a final sample clamp, and per-instance finite-sample guards. Every bus and master-volume gain precedes final protection. Nonfinite input mutes the complete mixed block and raises one warning per instance; measurement records repeat affected blocks. Initialization fails closed when protection is unavailable, and disposal owns all worklet nodes and ports.
+
+`npm test` passes **102 tests**, including 14 slice-4 tests. Production and acceptance builds are deterministic and self-contained. The [protection evidence](evidence/phase3/2026-09-05-phase3c-protection.md) records coverage and limits. A [standalone user-run page](../prototypes/phase3/XZBT-audio-acceptance.html) provides a frozen overlap workload, exact audio-frame capture, twelve challenge recipes and JSON export; see [run instructions](../prototypes/phase3/README.md).
+
+**Acceptance checkpoint:** Implementation is ready for user testing. The candidate −1 dBFS ceiling, 0.1 dB tolerance and audible release behavior remain provisional. No production audio has been heard or measured; traces 15–17, PRD 129, reference-exhibit listening and real GC4 synchronization remain open. Phase 3 is not accepted, and later phases have not started.
diff --git a/docs/XZBT_0-1_Format_Specification.md b/docs/XZBT_0-1_Format_Specification.md
index b484cd7..f00b9cd 100644
--- a/docs/XZBT_0-1_Format_Specification.md
+++ b/docs/XZBT_0-1_Format_Specification.md
@@ -1260,7 +1260,7 @@ This section closes the audio subsystem. It covers automation tracks and their p
 
 Sections 14 and 15 define what an exhibit may *declare*. This section defines what the runtime *does* with it over time. Where an earlier section deferred a rule to "Phase 3c", this section is the referent.
 
-**Implementation status.** Phase 3c slices 1–3 are implemented: the runtime accepts graph-local `automation` and recipe `release`, implements lifecycle/voice management, and resolves automation before override and modulation. Slice 4 (measured master protection) and the user-observed audio acceptance gates remain open. See the implementation status and slice evidence; the current master chain is still a placeholder, not proof of the protection contract.
+**Implementation status.** Phase 3c slices 1–3 and the slice-4 protection implementation pass automated checks. The runtime accepts graph-local `automation` and recipe `release`, implements lifecycle/voice management, resolves automation before override and modulation, and routes audio through an engine-owned finite-sample guard and final limiter. Slice 4's real-browser measurement and user-observed listening gates remain open. See the implementation status and slice evidence; the implemented limiter is not proof of the measured protection contract.
 
 ### 16.1 Automation tracks
 
diff --git a/docs/evidence/phase3/2026-09-05-phase3c-protection.md b/docs/evidence/phase3/2026-09-05-phase3c-protection.md
new file mode 100644
index 0000000..c593e76
--- /dev/null
+++ b/docs/evidence/phase3/2026-09-05-phase3c-protection.md
@@ -0,0 +1,27 @@
+# Phase 3c slice 4 — Master protection implementation
+
+Date: September 5, 2026. Contract: PRD 58, 118–120, 129 and Format Specification 16.7, 16.11. **Implementation and automated verification complete; hardware measurement and listening acceptance pending.** This supersedes the slice-3 stop for the newly authorized slice-4 work.
+
+## Runtime changes
+
+The placeholder compressor is replaced by an embedded AudioWorklet. The only audible route is voice → internal release gain → voice finite-sample guard → declared bus (when present) → master volume → final protection → destination. The engine creates these nodes; the document cannot target them, and `audio.master` remains rejected.
+
+The candidate settings are centralized in `AUDIO_PROTECTION`: −1 dBFS ceiling, 0.1 dB tolerance, 5 ms lookahead, 0.5 ms attack and 250 ms exponential gain-recovery time constant. A stereo-linked peak detector holds incoming peaks through the lookahead interval, smooths gain reduction/recovery, and a final hard sample clamp bounds attack overshoot and extreme overload. Stereo is explicitly two channels; quiet samples retain their values after the lookahead delay. Float32 rounding may put the mathematical ceiling a fraction above −1 dBFS, within the provisional tolerance. This algorithm and its numerical tests do not establish freedom from audible artifacts.
+
+A nonfinite sample anywhere in a voice guard mutes that entire stereo render quantum. A separate finite fault lane reaches the final master and mutes its entire mixed block, including healthy voices. The master also scans its summed input, and flushes delayed history when it mutes a block. Voice warnings use the production sound instance key; each guard and the final master warn once for their lifetime. The capture counts all affected blocks, including repeat faults after the first warning.
+
+Unlock resumes from the gesture, loads the embedded data-URL worklet, and exposes playable audio only after protected routing is ready. Concurrent unlocks share initialization. Unsupported/rejected worklet loading or resume fails silently with `WARN_AUDIO_UNAVAILABLE`; no unprotected fallback is connected. Disposal during loading cannot resurrect output. Processor failure disconnects output and rejects an active measurement. Guards, ports, master nodes and buses are disconnected/closed with their owners.
+
+## Verification
+
+`npm test`: **102 passed, 0 failed**, including 14 new slice-4 tests. The first sandboxed invocation could not spawn Node test workers (`EPERM`); the authorized escalated run passed. No browser or audio device was opened.
+
+The tests execute the exact serialized production worklet processor in a VM, exercising finite output and peak bounds at 8, 44.1, 48, 96 and 192 kHz under DC, alternating full-scale floating-point overload, sine overlap, transients and silence. They verify quiet stereo preservation and delay, monotonic release recovery, complete block muting for NaN and both infinities, once-per-instance warnings, fault-lane propagation, affected-block counts, capture-window boundaries, routing, async initialization failures/races, capture completion/disposal/failure, and missing AudioContext behavior (16.11 traces 12 and 14).
+
+Both new `.xzbt` fixtures validate and instantiate deterministically. The twelve challenge recipes cover the authored PRD 129 candidates. The overload fixture has finite transient ending bounds shorter than the 2-second burst cadence. Production and acceptance HTML builds are self-contained and deterministic; the acceptance build records the exact production and fixture hashes in its page and exported report.
+
+## User-run evidence still required
+
+[The standalone acceptance page](../../../prototypes/phase3/XZBT-audio-acceptance.html) and [run instructions](../../../prototypes/phase3/README.md) provide a frozen 16-continuous/64-one-shot workload, 30-second warmup, 120-second output capture, environment fields, actual burst/voice logs and JSON export. The meter measures the final worklet's Float32 samples before the destination. It cannot measure downstream browser/OS resampling or analog output. Counts apply to blocks intersecting the window; the sample peak covers exactly the requested frames.
+
+No production-build audio has been heard or measured in this work. The −1 dBFS / 0.1 dB values and audible release behavior remain provisional. Format Specification 16.11 traces 15–17, reference-exhibit listening, full PRD 129, real GC4 synchronization and the Phase 1 direct-file restart observation remain open. Slice 4 and Phase 3 are not accepted until the required user-performed evidence is reviewed. Later phases have not started.
diff --git a/exhibits/audio-challenge.xzbt b/exhibits/audio-challenge.xzbt
new file mode 100644
index 0000000..8cfd96a
--- /dev/null
+++ b/exhibits/audio-challenge.xzbt
@@ -0,0 +1,667 @@
+{
+  "xzbt": "0.1",
+  "meta": {
+    "id": "audio-challenge",
+    "name": "Audio Acceptance Challenge v1"
+  },
+  "runtime": {
+    "seed": 42
+  },
+  "sounds": {
+    "chirp": {
+      "name": "01 · Electronic chirp",
+      "recipe": {
+        "mode": "oneshot",
+        "release": "200ms",
+        "nodes": {
+          "hit": {
+            "type": "impulse",
+            "duration": "160ms",
+            "color": "white"
+          },
+          "ring": {
+            "type": "resonator",
+            "fundamental": 400,
+            "modes": [
+              {
+                "ratio": 1,
+                "decay": "80ms"
+              }
+            ]
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.4
+          }
+        },
+        "routes": [
+          {
+            "from": "hit",
+            "to": "ring"
+          },
+          {
+            "from": "ring",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ],
+        "automation": [
+          {
+            "target": "ring.fundamental",
+            "interpolation": "exponential",
+            "points": [
+              {
+                "at": "0ms",
+                "value": 400
+              },
+              {
+                "at": "160ms",
+                "value": 2400
+              }
+            ]
+          }
+        ]
+      }
+    },
+    "relay": {
+      "name": "02 · Relay / switch click",
+      "recipe": {
+        "mode": "oneshot",
+        "release": "200ms",
+        "nodes": {
+          "hit": {
+            "type": "impulse",
+            "duration": "3ms",
+            "color": "white"
+          },
+          "shape": {
+            "type": "filter",
+            "mode": "highpass",
+            "frequency": 1300,
+            "q": 1
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.3
+          }
+        },
+        "routes": [
+          {
+            "from": "hit",
+            "to": "shape"
+          },
+          {
+            "from": "shape",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ]
+      }
+    },
+    "siren": {
+      "name": "03 · Alarm / siren",
+      "recipe": {
+        "mode": "continuous",
+        "release": "200ms",
+        "nodes": {
+          "tone": {
+            "type": "oscillator",
+            "frequency": 650,
+            "waveform": "triangle"
+          },
+          "sweep": {
+            "type": "lfo",
+            "frequency": 0.7,
+            "polarity": "bipolar"
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.12
+          }
+        },
+        "routes": [
+          {
+            "from": "tone",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          },
+          {
+            "from": "sweep",
+            "to": "tone.frequency",
+            "depth": 250
+          }
+        ]
+      }
+    },
+    "airflow": {
+      "name": "04 · Airflow loop",
+      "recipe": {
+        "mode": "continuous",
+        "release": "200ms",
+        "nodes": {
+          "air": {
+            "type": "noise",
+            "color": "pink"
+          },
+          "shape": {
+            "type": "filter",
+            "mode": "lowpass",
+            "frequency": 1600,
+            "q": 0.7
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.25
+          }
+        },
+        "routes": [
+          {
+            "from": "air",
+            "to": "shape"
+          },
+          {
+            "from": "shape",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ]
+      }
+    },
+    "machinery": {
+      "name": "05 · Machinery drone",
+      "recipe": {
+        "mode": "continuous",
+        "release": "200ms",
+        "nodes": {
+          "low": {
+            "type": "oscillator",
+            "frequency": 65,
+            "waveform": "sawtooth"
+          },
+          "high": {
+            "type": "oscillator",
+            "frequency": 130.7,
+            "waveform": "triangle"
+          },
+          "shape": {
+            "type": "filter",
+            "mode": "lowpass",
+            "frequency": 400,
+            "q": 1
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.1
+          }
+        },
+        "routes": [
+          {
+            "from": "high",
+            "to": "shape"
+          },
+          {
+            "from": "low",
+            "to": "shape"
+          },
+          {
+            "from": "shape",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ]
+      }
+    },
+    "pressure": {
+      "name": "06 · Pressure release",
+      "recipe": {
+        "mode": "oneshot",
+        "release": "200ms",
+        "nodes": {
+          "hit": {
+            "type": "impulse",
+            "duration": "500ms",
+            "color": "white"
+          },
+          "shape": {
+            "type": "filter",
+            "mode": "bandpass",
+            "frequency": 2000,
+            "q": 0.7
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.4
+          }
+        },
+        "routes": [
+          {
+            "from": "hit",
+            "to": "shape"
+          },
+          {
+            "from": "shape",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ],
+        "automation": [
+          {
+            "target": "shape.frequency",
+            "interpolation": "linear",
+            "points": [
+              {
+                "at": "0ms",
+                "value": 3500
+              },
+              {
+                "at": "500ms",
+                "value": 500
+              }
+            ]
+          }
+        ]
+      }
+    },
+    "groan": {
+      "name": "07 · Structural groan",
+      "recipe": {
+        "mode": "oneshot",
+        "release": "200ms",
+        "nodes": {
+          "hit": {
+            "type": "impulse",
+            "duration": "400ms",
+            "color": "brown"
+          },
+          "body": {
+            "type": "resonator",
+            "fundamental": 95,
+            "modes": [
+              {
+                "ratio": 1,
+                "decay": "2s"
+              },
+              {
+                "ratio": 1.43,
+                "gain": 0.5,
+                "decay": "1500ms"
+              },
+              {
+                "ratio": 2.71,
+                "gain": 0.2,
+                "decay": "1s"
+              }
+            ]
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.4
+          }
+        },
+        "routes": [
+          {
+            "from": "hit",
+            "to": "body"
+          },
+          {
+            "from": "body",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ],
+        "automation": [
+          {
+            "target": "body.fundamental",
+            "interpolation": "linear",
+            "points": [
+              {
+                "at": "0ms",
+                "value": 95
+              },
+              {
+                "at": "2s",
+                "value": 55
+              }
+            ]
+          }
+        ]
+      }
+    },
+    "electrical": {
+      "name": "08 · Electrical buzz / arcing",
+      "recipe": {
+        "mode": "continuous",
+        "release": "200ms",
+        "nodes": {
+          "buzz": {
+            "type": "oscillator",
+            "frequency": 120,
+            "waveform": "sawtooth"
+          },
+          "arc": {
+            "type": "noise",
+            "color": "white"
+          },
+          "shape": {
+            "type": "filter",
+            "mode": "highpass",
+            "frequency": 1500,
+            "q": 1
+          },
+          "steps": {
+            "type": "sample-hold",
+            "rate": 14,
+            "min": 0,
+            "max": 1,
+            "slew": "5ms"
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.035
+          }
+        },
+        "routes": [
+          {
+            "from": "arc",
+            "to": "shape"
+          },
+          {
+            "from": "shape",
+            "to": "level"
+          },
+          {
+            "from": "buzz",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          },
+          {
+            "from": "steps",
+            "to": "level.gain",
+            "depth": 0.06
+          }
+        ]
+      }
+    },
+    "impact": {
+      "name": "09 · Impact transient",
+      "recipe": {
+        "mode": "oneshot",
+        "release": "200ms",
+        "nodes": {
+          "hit": {
+            "type": "impulse",
+            "duration": "12ms",
+            "color": "white"
+          },
+          "body": {
+            "type": "resonator",
+            "fundamental": 110,
+            "modes": [
+              {
+                "ratio": 1,
+                "decay": "600ms"
+              },
+              {
+                "ratio": 2.7,
+                "gain": 0.4,
+                "decay": "200ms"
+              }
+            ]
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.5
+          }
+        },
+        "routes": [
+          {
+            "from": "hit",
+            "to": "body"
+          },
+          {
+            "from": "body",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ]
+      }
+    },
+    "sequence": {
+      "name": "10 · Tonal sequence",
+      "recipe": {
+        "mode": "continuous",
+        "release": "200ms",
+        "nodes": {
+          "tone": {
+            "type": "oscillator",
+            "frequency": 261.63,
+            "waveform": "sine"
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.13
+          }
+        },
+        "routes": [
+          {
+            "from": "tone",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ],
+        "automation": [
+          {
+            "target": "tone.frequency",
+            "interpolation": "step",
+            "points": [
+              {
+                "at": "0ms",
+                "value": 261.63
+              },
+              {
+                "at": "300ms",
+                "value": 329.63
+              },
+              {
+                "at": "600ms",
+                "value": 392
+              },
+              {
+                "at": "900ms",
+                "value": 523.25
+              }
+            ]
+          },
+          {
+            "target": "level.gain",
+            "interpolation": "linear",
+            "points": [
+              {
+                "at": "0ms",
+                "value": 0
+              },
+              {
+                "at": "15ms",
+                "value": 0.13
+              },
+              {
+                "at": "1100ms",
+                "value": 0.13
+              },
+              {
+                "at": "1200ms",
+                "value": 0
+              }
+            ]
+          }
+        ]
+      }
+    },
+    "breathing": {
+      "name": "11 · Organic pulse / breathing",
+      "recipe": {
+        "mode": "continuous",
+        "release": "200ms",
+        "nodes": {
+          "air": {
+            "type": "noise",
+            "color": "pink"
+          },
+          "shape": {
+            "type": "filter",
+            "mode": "lowpass",
+            "frequency": 900,
+            "q": 0.7
+          },
+          "breath": {
+            "type": "lfo",
+            "frequency": 0.22,
+            "polarity": "unipolar"
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.02
+          }
+        },
+        "routes": [
+          {
+            "from": "air",
+            "to": "shape"
+          },
+          {
+            "from": "shape",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          },
+          {
+            "from": "breath",
+            "to": "level.gain",
+            "depth": 0.3
+          }
+        ]
+      }
+    },
+    "atmosphere": {
+      "name": "12 · Evolving atmospheric texture",
+      "recipe": {
+        "mode": "continuous",
+        "release": "200ms",
+        "nodes": {
+          "air": {
+            "type": "noise",
+            "color": "brown"
+          },
+          "tone": {
+            "type": "oscillator",
+            "frequency": 180,
+            "waveform": "sine"
+          },
+          "shape": {
+            "type": "filter",
+            "mode": "bandpass",
+            "frequency": 400,
+            "q": 0.6
+          },
+          "space": {
+            "type": "reverb",
+            "decay": "4s",
+            "mix": 0.6
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.15
+          }
+        },
+        "routes": [
+          {
+            "from": "tone",
+            "to": "shape"
+          },
+          {
+            "from": "air",
+            "to": "shape"
+          },
+          {
+            "from": "shape",
+            "to": "space"
+          },
+          {
+            "from": "space",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ],
+        "automation": [
+          {
+            "target": "shape.frequency",
+            "interpolation": "smooth",
+            "points": [
+              {
+                "at": "0ms",
+                "value": 250
+              },
+              {
+                "at": "10s",
+                "value": 2000
+              },
+              {
+                "at": "25s",
+                "value": 450
+              }
+            ]
+          },
+          {
+            "target": "tone.frequency",
+            "interpolation": "smooth",
+            "points": [
+              {
+                "at": "0ms",
+                "value": 180
+              },
+              {
+                "at": "25s",
+                "value": 270
+              }
+            ]
+          }
+        ]
+      }
+    }
+  }
+}
diff --git a/exhibits/audio-protection-stress.xzbt b/exhibits/audio-protection-stress.xzbt
new file mode 100644
index 0000000..980a29e
--- /dev/null
+++ b/exhibits/audio-protection-stress.xzbt
@@ -0,0 +1,87 @@
+{
+  "xzbt": "0.1",
+  "meta": {
+    "id": "audio-protection-stress",
+    "name": "Master Protection Overlap v1"
+  },
+  "runtime": {
+    "seed": 42
+  },
+  "audio": {
+    "buses": {
+      "load": {
+        "gain": 4
+      }
+    }
+  },
+  "sounds": {
+    "bed": {
+      "name": "Continuous overload",
+      "recipe": {
+        "mode": "continuous",
+        "release": "200ms",
+        "nodes": {
+          "tone": {
+            "type": "oscillator",
+            "frequency": 110,
+            "waveform": "square"
+          },
+          "boost": {
+            "type": "gain",
+            "gain": 4
+          }
+        },
+        "routes": [
+          {
+            "from": "tone",
+            "to": "boost"
+          },
+          {
+            "from": "boost",
+            "to": "output"
+          }
+        ]
+      },
+      "bus": "load"
+    },
+    "hit": {
+      "name": "Overlapping transient",
+      "recipe": {
+        "mode": "oneshot",
+        "release": "200ms",
+        "nodes": {
+          "hit": {
+            "type": "impulse",
+            "duration": "500ms",
+            "color": "white"
+          },
+          "boost": {
+            "type": "gain",
+            "gain": 4
+          },
+          "echo": {
+            "type": "delay",
+            "time": "50ms",
+            "feedback": 0.2,
+            "mix": 0.5
+          }
+        },
+        "routes": [
+          {
+            "from": "hit",
+            "to": "boost"
+          },
+          {
+            "from": "boost",
+            "to": "echo"
+          },
+          {
+            "from": "echo",
+            "to": "output"
+          }
+        ]
+      },
+      "bus": "load"
+    }
+  }
+}
diff --git a/package.json b/package.json
index 3c7d023..624282e 100644
--- a/package.json
+++ b/package.json
@@ -8,10 +8,12 @@
   },
   "scripts": {
     "build": "node tools/build-xzbt.mjs",
+    "build:audio-acceptance": "node tools/build-audio-acceptance.mjs",
     "test:phase1": "node test/phase1-runtime.test.mjs",
     "test:phase2": "node test/phase2-common-grammar.test.mjs",
     "test:phase3": "node --test test/phase3-*.test.mjs",
     "test:phase3c3": "node test/phase3-automation.test.mjs",
+    "test:phase3c4": "node test/phase3-protection.test.mjs",
     "test": "node --test test/*.test.mjs"
   }
 }
diff --git a/prototypes/phase3/README.md b/prototypes/phase3/README.md
new file mode 100644
index 0000000..ef9ade4
--- /dev/null
+++ b/prototypes/phase3/README.md
@@ -0,0 +1,17 @@
+# Phase 3c slice 4: user-run audio acceptance
+
+Open [XZBT-audio-acceptance.html](XZBT-audio-acceptance.html) directly from disk in Chrome. It is self-contained and embeds the same audio runtime and protection processor as the production `XZBT.html`. Rebuild both with `npm run build:audio-acceptance` after runtime or fixture changes.
+
+1. Record the reference computer, CPU, GPU/driver, RAM, OS and exact browser version, power mode, output device and OS volume. Use a 1920 × 1080 viewport. The report adds viewport, DPR, sample rate, latency, fixture hashes and production artifact SHA-256.
+2. Lower the **device** volume before the overlap run. The engine master stays at 1 and the declared stress bus stays at 4 to exercise protection. Click **Run 150-second peak capture** and keep the page visible. The workload is `phase3c4-overlap-v1`, seed 42: 16 continuous square-wave voices, each boosted by 4, plus 64 noise transients with delay every 2 seconds. There are 30 seconds of warmup followed by 120 seconds of measured audio frames. Changing visibility or cancelling invalidates the run. Repeated bursts dispose completed voices through the production voice-limit policy; those warnings are expected.
+3. Check that the output is audible, the peak is nonzero and at most **−0.9 dBFS** (candidate ceiling −1 dBFS plus 0.1 dB tolerance), and affected-block/nonfinite counts are zero. Review actual burst timestamps and voice counts, and note glitches or missed bursts. An interrupted run or missing workload is not acceptable evidence even if its numeric peak passes.
+4. Listen to all twelve challenge buttons. Stop or release continuous voices between examples as needed. Record each sound's recognizability and any clicks, clipping or pumping. Layer sounds, release them, and exercise pause/resume. The numbered recipes map directly to PRD 129. These are authored candidates; validation is not listening acceptance.
+5. Download the JSON report after entering observations. Supply the report for review and record it under `docs/evidence/phase3/` with the actual run date. Do not mark GC6 or Phase 3 accepted solely because the report's `candidateDigitalPeakPass` is true.
+
+The peak tap is the final protection worklet's Float32 output, after every engine gain, immediately before `AudioContext.destination`. It is a digital sample-peak measurement, not a capture after browser/OS resampling, an intersample true-peak measurement, or an analog-device measurement. Record output-device and listening observations separately. The ceiling/tolerance remain provisional until the evidence is reviewed.
+
+The capture records peak over exactly the requested frames. Affected-block, nonfinite-sample and clamp counters include every render block intersecting that window (including a partial first/last block). Nonfinite counts include voice-guard detections and detections in the summed master input. Warnings occur once per voice guard/master processor; repeated affected blocks are still counted. The fixed normal workload contains no intentional nonfinite injection; fault injection is covered by the automated worklet tests.
+
+The remaining Format Specification 16.11 traces 15–17 also require production reference Exhibits A/B, lifecycle eviction/unlock/pause observations, and full PRD 129 listening. Import `exhibits/audio-challenge.xzbt` into production `XZBT.html` to audition the same recipes there. The probe's manual pause/resume and overlapping voices do not implement or certify GC4 current-logical-time alignment. Those gates and Phase 1's direct-file two-fixture restart observation remain open.
+
+No agent-controlled browser or hardware audio run was used to prepare this page. The recorded user-performed browser test boundary remains in force.
diff --git a/prototypes/phase3/XZBT-audio-acceptance.html b/prototypes/phase3/XZBT-audio-acceptance.html
new file mode 100644
index 0000000..c84ff34
--- /dev/null
+++ b/prototypes/phase3/XZBT-audio-acceptance.html
@@ -0,0 +1,4867 @@
+<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>XZBT audio acceptance</title>
+<style>
+  :root { color-scheme: dark; font: 16px/1.5 system-ui,sans-serif; background: #10161e; color: #e3ebf4; }
+  body { max-width: 1000px; margin: 32px auto; padding: 0 24px; } h1 { margin-bottom: 8px; }
+  section { border: 1px solid #3d4c5e; border-radius: 10px; padding: 20px; margin: 24px 0; }
+  button { font: inherit; background: #284763; color: white; border: 1px solid #748da6; border-radius: 6px; padding: 8px 12px; margin: 4px; cursor: pointer; }
+  button:disabled { opacity: .45; cursor: default; } textarea { box-sizing: border-box; width: 100%; min-height: 110px; font: inherit; padding: 10px; background: #172331; color: inherit; }
+  label { display: block; margin-top: 14px; } pre { overflow-wrap: anywhere; white-space: pre-wrap; background: #172331; padding: 14px; } #state { color: #b7dfec; } small { color: #bcc9d7; }
+</style></head><body>
+<h1>Audio acceptance · Phase 3c slice 4</h1>
+<p>This page embeds the production audio engine and frozen exhibit fixtures. Open it directly from disk in Chrome. Results measure samples at the final worklet output; device playback and listening must be recorded separately.</p>
+<p id="state" role="status" aria-live="polite">Ready. Audio starts only when you press a button.</p>
+<section><h2>1. Record the environment</h2>
+<p>Use a 1920 × 1080 viewport for GC6. Start with a low device volume: the overlap test deliberately drives the engine at full master and bus gain.</p>
+<label for="environment">Computer, CPU, GPU/driver, RAM, OS, exact browser version, power mode, audio device and OS volume</label>
+<textarea id="environment" placeholder="Record the reference computer and output device here."></textarea>
+</section>
+<section><h2>2. Capture overlapping recipes</h2>
+<p>16 continuous voices and bursts of 64 one-shots. Warm up for 30 seconds, then capture 120 seconds on the audio clock. Keep this page visible. The report includes actual burst times and voice counts; any interrupted run is invalid.</p>
+<button id="capture">Run 150-second peak capture</button><button id="cancel">Stop audio / cancel capture</button>
+<pre id="measurement">No measurement yet.</pre>
+</section>
+<section><h2>3. Listen to the audio challenge</h2>
+<p>Each button plays a declarative recipe from audio-challenge.xzbt. Layer continuous sounds, then release them; listen for clicks, clipping and pumping. The gain recovery time constant is 250 ms, with 5 ms lookahead. These are candidate settings awaiting listening acceptance.</p>
+<div id="sounds"></div><button id="release">Release all voices</button><button id="pause">Pause audio</button><button id="resume">Resume audio</button>
+<label for="observations">Listening results</label>
+<textarea id="observations" placeholder="For each of the 12 sounds: recognizable / needs work, clicks, clipping, pumping. Also record overlap, release, eviction, unlock, pause/resume, reference exhibits A/B, and any audio glitches. Unperformed checks stay pending."></textarea>
+<p><small>The reference exhibits and current-logical-time GC4 unlock checks require their own production runs. This capture page does not certify them.</small></p>
+</section>
+<section><h2>4. Save the evidence</h2><button id="save">Download JSON report</button><pre id="build"></pre></section>
+<script>'use strict';
+(() => {
+
+/* src/runtime/constants.js */
+const XZBT_FORMAT_VERSION = '0.1';
+const XZBT_RUNTIME_VERSION = '0.1.0-phase3b';
+const UINT32_RANGE = 0x1_0000_0000;
+const RNG_DOMAINS = Object.freeze([
+  'cadence',
+  'scenario',
+  'visual',
+  'sound',
+  'manual-sample'
+]);
+
+const DATABASE = Object.freeze({
+  name: 'xzbt-runtime-0.1',
+  version: 1,
+  exhibits: 'exhibits',
+  preferences: 'preferences'
+});
+
+const ID_PATTERN = /^[a-z][a-z0-9_-]*$/;
+const ALLOWED_TOP_LEVEL_FIELDS = Object.freeze([
+  'xzbt', 'meta', 'runtime', 'parameters', 'ui', 'state', 'signals',
+  'components', 'visuals', 'audio', 'sounds', 'cadence', 'modulators',
+  'bindings', 'events', 'scenarios'
+]);
+const ALLOWED_META_FIELDS = Object.freeze([
+  'id', 'name', 'version', 'author', 'description', 'license', 'tags'
+]);
+
+/* src/runtime/diagnostics.js */
+class Diagnostics {
+  constructor({ limit = 250, onChange = () => {} } = {}) {
+    this.limit = limit;
+    this.onChange = onChange;
+    this.entries = [];
+    this.sequence = 0;
+  }
+
+  add(severity, code, message, context = {}) {
+    const entry = Object.freeze({
+      sequence: ++this.sequence,
+      timestamp: new Date().toISOString(),
+      severity,
+      code,
+      exhibitId: context.exhibitId ?? null,
+      section: context.section ?? null,
+      objectId: context.objectId ?? null,
+      property: context.property ?? null,
+      message
+    });
+    this.entries.push(entry);
+    if (this.entries.length > this.limit) this.entries.shift();
+    this.onChange(this.list());
+    return entry;
+  }
+
+  info(code, message, context) { return this.add('info', code, message, context); }
+  warn(code, message, context) { return this.add('warning', code, message, context); }
+  error(code, message, context) { return this.add('error', code, message, context); }
+  list() { return [...this.entries]; }
+  clear() { this.entries.length = 0; this.onChange([]); }
+}
+
+/* src/runtime/rng.js */
+function rotateLeft(value, count) {
+  return ((value << count) | (value >>> (32 - count))) >>> 0;
+}
+
+function multiply32(left, right) {
+  return Math.imul(left, right) >>> 0;
+}
+
+function fnv1a32(text) {
+  let hash = 0x811c9dc5;
+  for (const byte of new TextEncoder().encode(text)) {
+    hash ^= byte;
+    hash = multiply32(hash, 0x01000193);
+  }
+  return hash >>> 0;
+}
+
+function splitMix32(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = (state + 0x9e3779b9) >>> 0;
+    let value = state;
+    value = multiply32(value ^ (value >>> 16), 0x21f0aaad);
+    value = multiply32(value ^ (value >>> 15), 0x735a2d97);
+    return (value ^ (value >>> 15)) >>> 0;
+  };
+}
+
+function deriveStreamState(rootSeed, domain, stableInstanceKey) {
+  validateRootSeed(rootSeed);
+  if (!RNG_DOMAINS.includes(domain)) throw new RangeError(`Unknown XZBT random domain: ${domain}.`);
+  if (typeof stableInstanceKey !== 'string' || stableInstanceKey.length === 0) {
+    throw new TypeError('A non-empty stable instance key is required.');
+  }
+  const hash = fnv1a32(`xzbt-0.1\0${rootSeed}\0${domain}\0${stableInstanceKey}`);
+  const expand = splitMix32(hash);
+  const state = [expand(), expand(), expand(), expand()];
+  if (state.every((word) => word === 0)) state[3] = 1;
+  return state;
+}
+
+class RandomStream {
+  constructor(state) {
+    if (!Array.isArray(state) || state.length !== 4 || state.some((word) => !Number.isInteger(word))) {
+      throw new TypeError('xoshiro128** state must contain four integer words.');
+    }
+    this.state = state.map((word) => word >>> 0);
+    if (this.state.every((word) => word === 0)) throw new RangeError('xoshiro128** state cannot be all zero.');
+  }
+
+  nextUint32() {
+    const state = this.state;
+    const result = multiply32(rotateLeft(multiply32(state[1], 5), 7), 9);
+    const temporary = (state[1] << 9) >>> 0;
+    state[2] ^= state[0];
+    state[3] ^= state[1];
+    state[1] ^= state[2];
+    state[0] ^= state[3];
+    state[2] ^= temporary;
+    state[3] = rotateLeft(state[3], 11);
+    for (let index = 0; index < 4; index++) state[index] >>>= 0;
+    return result >>> 0;
+  }
+
+  nextFloat() { return this.nextUint32() / UINT32_RANGE; }
+
+  nextInteger(minimum, maximum) {
+    if (!Number.isSafeInteger(minimum) || !Number.isSafeInteger(maximum) || maximum < minimum) {
+      throw new RangeError('Integer bounds must be safe integers with maximum >= minimum.');
+    }
+    const span = maximum - minimum + 1;
+    if (span > UINT32_RANGE) throw new RangeError('Integer range cannot exceed 2^32 values.');
+    const limit = UINT32_RANGE - (UINT32_RANGE % span);
+    let value;
+    do value = this.nextUint32(); while (value >= limit);
+    return minimum + (value % span);
+  }
+}
+
+class SeededRNG {
+  constructor(rootSeed) {
+    this.rootSeed = validateRootSeed(rootSeed);
+  }
+
+  stream(domain, stableInstanceKey) {
+    return new RandomStream(deriveStreamState(this.rootSeed, domain, stableInstanceKey));
+  }
+}
+
+function validateRootSeed(seed) {
+  if (!Number.isInteger(seed) || seed < 0 || seed >= UINT32_RANGE) {
+    throw new RangeError('Root seed must be an unsigned 32-bit integer.');
+  }
+  return seed >>> 0;
+}
+
+function resolveRootSeed(authoredSeed = 'random', cryptoProvider = globalThis.crypto) {
+  if (authoredSeed !== 'random') return validateRootSeed(authoredSeed);
+  if (!cryptoProvider?.getRandomValues) throw new Error('Cryptographic entropy is unavailable; a random exhibit seed cannot be resolved.');
+  return cryptoProvider.getRandomValues(new Uint32Array(1))[0] >>> 0;
+}
+
+/* src/runtime/types.js */
+const PARAMETER_TYPES = Object.freeze(['number', 'integer', 'boolean', 'string', 'color', 'enum']);
+const STATE_TYPES = Object.freeze(['number', 'integer', 'boolean', 'string']);
+const EASINGS = Object.freeze(['linear', 'ease-in', 'ease-out', 'ease-in-out']);
+const DURATION_PATTERN = /^([0-9]+(?:\.[0-9]+)?)(ms|s|m|h)$/;
+const RUNTIME_SIGNAL_TYPES = Object.freeze({
+  'signals.time.elapsed': 'number',
+  'signals.time.delta': 'number',
+  'signals.audio.low': 'number',
+  'signals.audio.mid': 'number',
+  'signals.audio.high': 'number',
+  'signals.audio.energy': 'number',
+  'signals.pointer.x': 'number',
+  'signals.pointer.y': 'number',
+  'signals.viewport.width': 'number',
+  'signals.viewport.height': 'number',
+  'signals.scenario.active': 'boolean'
+});
+
+class RuntimeFault extends Error {
+  constructor(code, message, path = '$') {
+    super(message);
+    this.name = 'RuntimeFault';
+    this.code = code;
+    this.path = path;
+  }
+}
+
+function isRecord(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function isNumericType(type) { return type === 'number' || type === 'integer'; }
+
+function clamp(value, minimum = -Infinity, maximum = Infinity) {
+  return Math.min(maximum, Math.max(minimum, value));
+}
+
+function roundHalfAwayFromZero(value) {
+  return Math.sign(value) * Math.floor(Math.abs(value) + 0.5);
+}
+
+function easingValue(name, progress) {
+  const value = clamp(progress, 0, 1);
+  switch (name) {
+    case 'linear': return value;
+    case 'ease-in': return value * value;
+    case 'ease-out': return 1 - ((1 - value) * (1 - value));
+    case 'ease-in-out': return value < 0.5 ? 2 * value * value : 1 - (((-2 * value + 2) ** 2) / 2);
+    default: throw new RuntimeFault('ERR_INVALID_TRANSITION', `Unsupported easing '${name}'.`);
+  }
+}
+
+function lerp(from, to, amount) { return from + ((to - from) * amount); }
+
+function parseDuration(value, path = '$') {
+  if (typeof value !== 'string') throw new RuntimeFault('ERR_INVALID_DURATION', 'Duration must be a single-unit string.', path);
+  const match = DURATION_PATTERN.exec(value);
+  if (!match) throw new RuntimeFault('ERR_INVALID_DURATION', `Invalid duration '${value}'.`, path);
+  const scalar = Number(match[1]);
+  const multipliers = { ms: 1, s: 1000, m: 60_000, h: 3_600_000 };
+  const milliseconds = scalar * multipliers[match[2]];
+  if (!Number.isFinite(milliseconds)) throw new RuntimeFault('ERR_INVALID_DURATION', `Duration '${value}' is not finite.`, path);
+  return milliseconds;
+}
+
+function valueMatchesType(type, value, spec = {}) {
+  if (type === 'number') return typeof value === 'number' && Number.isFinite(value);
+  if (type === 'integer') return Number.isInteger(value);
+  if (type === 'boolean') return typeof value === 'boolean';
+  if (type === 'string') return typeof value === 'string';
+  if (type === 'color') return typeof value === 'string' && value.trim().length > 0;
+  if (type === 'enum') return typeof value === 'string' && Array.isArray(spec.values) && spec.values.includes(value);
+  return false;
+}
+
+function normalizeForSpec(spec, value, { clampNumeric = false } = {}) {
+  if (!valueMatchesType(spec.type, value, spec)) {
+    throw new RuntimeFault('ERR_TYPE_MISMATCH', `Value ${JSON.stringify(value)} does not match type '${spec.type}'.`);
+  }
+  if (isNumericType(spec.type)) {
+    let result = value;
+    if (spec.type === 'integer') result = roundHalfAwayFromZero(result);
+    const minimum = spec.min ?? -Infinity;
+    const maximum = spec.max ?? Infinity;
+    if (!clampNumeric && (result < minimum || result > maximum)) {
+      throw new RuntimeFault('ERR_OUT_OF_BOUNDS', `Value ${result} is outside [${minimum}, ${maximum}].`);
+    }
+    result = clamp(result, minimum, maximum);
+    return result;
+  }
+  return value;
+}
+
+/* src/runtime/values.js */
+const OPERATOR_ARITY = Object.freeze({
+  abs: 1, negate: 1, round: 1, floor: 1, ceil: 1,
+  add: 2, subtract: 2, multiply: 2, divide: 2, min: 2, max: 2,
+  clamp: 3, lerp: 3
+});
+
+class ValueResolver {
+  constructor(resolveReference) {
+    this.resolveReference = resolveReference;
+  }
+
+  // Freeze procedural choices once, retaining only explicitly live component
+  // input references. Re-evaluating this tree never draws from an RNG.
+  sample(spec, stream, path = '$', retainReference = () => false) {
+    if (!isRecord(spec)) return this.evaluate(spec, stream, path);
+    if (Object.hasOwn(spec, 'ref')) return retainReference(spec.ref) ? { ref: spec.ref } : this.evaluate(spec, stream, path);
+    if (Object.hasOwn(spec, 'random')) return this.evaluate(spec, stream, path);
+    if (Object.hasOwn(spec, 'choose')) {
+      const index = this.evaluate({ choose: spec.choose.map((option, i) => ({ weight: option.weight, value: i })) }, stream, path);
+      return this.sample(spec.choose[index].value, stream, `${path}.choose[${index}].value`, retainReference);
+    }
+    if (Object.hasOwn(spec, 'op')) return { op: spec.op, args: spec.args.map((arg, i) => this.sample(arg, stream, `${path}.args[${i}]`, retainReference)) };
+    return this.evaluate(spec, stream, path);
+  }
+
+  evaluate(spec, stream, path = '$') {
+    if (typeof spec === 'number') {
+      if (!Number.isFinite(spec)) throw new RuntimeFault('ERR_TYPE_MISMATCH', 'Numeric literals must be finite.', path);
+      return spec;
+    }
+    if (typeof spec === 'string' || typeof spec === 'boolean') return spec;
+    if (!isRecord(spec)) throw new RuntimeFault('ERR_SCHEMA_VALIDATION', 'Invalid ValueSpec.', path);
+
+    if (Object.hasOwn(spec, 'ref')) return this.resolveReference(spec.ref);
+    if (Object.hasOwn(spec, 'random')) {
+      if (!stream) throw new RuntimeFault('ERR_SCHEMA_VALIDATION', 'Random ValueSpec requires an owning random stream.', path);
+      const { min, max, integer = false } = spec.random;
+      if (!Number.isFinite(min) || !Number.isFinite(max) || max < min || typeof integer !== 'boolean') {
+        throw new RuntimeFault('ERR_OUT_OF_BOUNDS', 'Random range requires finite min <= max and an optional boolean integer flag.', `${path}.random`);
+      }
+      if (integer && Math.ceil(min) > Math.floor(max)) throw new RuntimeFault('ERR_OUT_OF_BOUNDS', 'Integer random range contains no integers.', `${path}.random`);
+      return integer ? stream.nextInteger(Math.ceil(min), Math.floor(max)) : min + (stream.nextFloat() * (max - min));
+    }
+    if (Object.hasOwn(spec, 'choose')) {
+      if (!stream || !Array.isArray(spec.choose) || spec.choose.length === 0) throw new RuntimeFault('ERR_SCHEMA_VALIDATION', 'Weighted choice requires a non-empty list and an owning stream.', `${path}.choose`);
+      let total = 0;
+      for (const option of spec.choose) {
+        if (!isRecord(option) || !Number.isFinite(option.weight) || option.weight <= 0 || !Object.hasOwn(option, 'value')) throw new RuntimeFault('ERR_SCHEMA_VALIDATION', 'Every choice requires a value and a finite positive weight.', `${path}.choose`);
+        total += option.weight;
+      }
+      const selected = stream.nextFloat() * total;
+      let cumulative = 0;
+      for (let index = 0; index < spec.choose.length; index += 1) {
+        cumulative += spec.choose[index].weight;
+        if (selected < cumulative || index === spec.choose.length - 1) return this.evaluate(spec.choose[index].value, stream, `${path}.choose[${index}].value`);
+      }
+    }
+    if (Object.hasOwn(spec, 'op')) {
+      const arity = OPERATOR_ARITY[spec.op];
+      if (!arity) throw new RuntimeFault('ERR_INVALID_OPERATOR', `Unsupported ValueSpec operator '${spec.op}'.`, `${path}.op`);
+      if (!Array.isArray(spec.args) || spec.args.length !== arity) throw new RuntimeFault('ERR_INVALID_ARITY', `Operator '${spec.op}' requires ${arity} arguments.`, `${path}.args`);
+      const values = spec.args.map((argument, index) => this.evaluate(argument, stream, `${path}.args[${index}]`));
+      if (values.some((value) => typeof value !== 'number' || !Number.isFinite(value))) throw new RuntimeFault('ERR_TYPE_MISMATCH', `Operator '${spec.op}' requires finite numbers.`, path);
+      let result;
+      switch (spec.op) {
+        case 'abs': result = Math.abs(values[0]); break;
+        case 'negate': result = -values[0]; break;
+        case 'round': result = Math.round(values[0]); break;
+        case 'floor': result = Math.floor(values[0]); break;
+        case 'ceil': result = Math.ceil(values[0]); break;
+        case 'add': result = values[0] + values[1]; break;
+        case 'subtract': result = values[0] - values[1]; break;
+        case 'multiply': result = values[0] * values[1]; break;
+        case 'divide': result = values[1] === 0 ? 0 : values[0] / values[1]; break;
+        case 'min': result = Math.min(values[0], values[1]); break;
+        case 'max': result = Math.max(values[0], values[1]); break;
+        case 'clamp':
+          if (values[1] > values[2]) throw new RuntimeFault('ERR_OUT_OF_BOUNDS', 'Clamp minimum cannot exceed maximum.', path);
+          result = clamp(values[0], values[1], values[2]);
+          break;
+        case 'lerp': result = values[0] + ((values[1] - values[0]) * values[2]); break;
+      }
+      if (!Number.isFinite(result)) throw new RuntimeFault('ERR_OUT_OF_BOUNDS', `Operator '${spec.op}' produced a non-finite result.`, path);
+      return result;
+    }
+    throw new RuntimeFault('ERR_SCHEMA_VALIDATION', 'Unrecognized ValueSpec form.', path);
+  }
+}
+
+class ConditionEvaluator {
+  constructor(valueResolver) { this.values = valueResolver; }
+
+  evaluate(condition, stream, path = '$') {
+    if (!isRecord(condition)) throw new RuntimeFault('ERR_SCHEMA_VALIDATION', 'ConditionSpec must be an object.', path);
+    if (Object.hasOwn(condition, 'and')) {
+      if (!Array.isArray(condition.and) || condition.and.length === 0) throw new RuntimeFault('ERR_SCHEMA_VALIDATION', 'and requires a non-empty array.', `${path}.and`);
+      return condition.and.every((child, index) => this.evaluate(child, stream, `${path}.and[${index}]`));
+    }
+    if (Object.hasOwn(condition, 'or')) {
+      if (!Array.isArray(condition.or) || condition.or.length === 0) throw new RuntimeFault('ERR_SCHEMA_VALIDATION', 'or requires a non-empty array.', `${path}.or`);
+      return condition.or.some((child, index) => this.evaluate(child, stream, `${path}.or[${index}]`));
+    }
+    if (Object.hasOwn(condition, 'not')) return !this.evaluate(condition.not, stream, `${path}.not`);
+    const comparisons = ['eq', 'ne', 'gt', 'gte', 'lt', 'lte'];
+    if (!comparisons.includes(condition.op) || !Object.hasOwn(condition, 'left') || !Object.hasOwn(condition, 'right')) throw new RuntimeFault('ERR_INVALID_OPERATOR', `Unsupported comparison operator '${condition.op}'.`, `${path}.op`);
+    const left = this.values.evaluate(condition.left, stream, `${path}.left`);
+    const right = this.values.evaluate(condition.right, stream, `${path}.right`);
+    if (typeof left !== typeof right || !['number', 'boolean', 'string'].includes(typeof left)) throw new RuntimeFault('ERR_TYPE_MISMATCH', 'Condition operands must have compatible primitive types.', path);
+    switch (condition.op) {
+      case 'eq': return left === right;
+      case 'ne': return left !== right;
+      case 'gt': return left > right;
+      case 'gte': return left >= right;
+      case 'lt': return left < right;
+      case 'lte': return left <= right;
+    }
+  }
+}
+
+/* src/runtime/audio-contract.js */
+// Audio Subsystem Contract 0.1 - declarative tables shared by validation, expansion,
+// instantiation, and realization. Format Specification 0.1 revision 0.4, sections 14-15.
+
+const AUDIO_STATIC_MAX_FREQUENCY = 24000;
+const AUDIO_NYQUIST_FACTOR = 0.45;
+
+// Engine-owned candidate values; hardware/listening acceptance remains GC6.
+const AUDIO_PROTECTION = Object.freeze({
+  ceilingDb: -1,
+  toleranceDb: 0.1,
+  lookaheadMs: 5,
+  attackMs: 0.5,
+  releaseMs: 250,
+  channels: 2
+});
+
+const AUDIO_LIMITS = Object.freeze({
+  nodesPerSound: 128,
+  routesPerSound: 256,
+  componentDepth: 8,
+  resonatorModes: 16,
+  oscillatorPartials: 64,
+  automationTracks: 64,
+  automationPoints: 256
+});
+
+const AUDIO_NOISE_COLORS = Object.freeze(['white', 'pink', 'brown']);
+const AUDIO_RESERVED_NODE_KEYS = Object.freeze(['output', 'input']);
+
+function num(min, max, fallback, extra = {}) {
+  return { kind: 'number', min, max, default: fallback, valuespec: true, ...extra };
+}
+function enumeration(values, fallback) {
+  return { kind: 'enum', values: Object.freeze(values), default: fallback, valuespec: false };
+}
+function duration(minMs, maxMs, fallback) {
+  return { kind: 'duration', min: minMs, max: maxMs, default: fallback, valuespec: false };
+}
+
+// `ceiling: 'audio'` marks a field validated against AUDIO_STATIC_MAX_FREQUENCY at the
+// semantic stage and clamped to the live audioMaxFrequency at instantiation (section 14.5).
+const AUDIO_NODE_TYPES = Object.freeze({
+  oscillator: {
+    class: 'source', acceptsAudio: false,
+    fields: {
+      waveform: enumeration(['sine', 'triangle', 'square', 'sawtooth', 'custom'], 'sine'),
+      frequency: num(0.1, AUDIO_STATIC_MAX_FREQUENCY, 440, { ceiling: 'audio' }),
+      detune: num(-4800, 4800, 0),
+      harmonics: { kind: 'partials', valuespec: false, requiredWhen: { waveform: 'custom' } }
+    }
+  },
+  noise: {
+    class: 'source', acceptsAudio: false,
+    fields: { color: enumeration(AUDIO_NOISE_COLORS, 'white') }
+  },
+  impulse: {
+    class: 'source', acceptsAudio: false,
+    fields: {
+      color: enumeration(AUDIO_NOISE_COLORS, 'white'),
+      duration: duration(1, 500, '10ms'),
+      amplitude: num(0, 1, 1),
+      decay: enumeration(['flat', 'linear', 'exponential'], 'exponential')
+    }
+  },
+  constant: {
+    class: 'control', acceptsAudio: false,
+    fields: { value: num(-1000, 1000, 1) }
+  },
+  lfo: {
+    class: 'control', acceptsAudio: false,
+    fields: {
+      waveform: enumeration(['sine', 'triangle', 'square', 'sawtooth'], 'sine'),
+      frequency: num(0.001, 40, 1),
+      amplitude: num(0, 1000, 1),
+      polarity: enumeration(['bipolar', 'unipolar'], 'bipolar'),
+      phase: num(0, 360, 0, { exclusiveMax: true })
+    }
+  },
+  'sample-hold': {
+    class: 'control', acceptsAudio: false,
+    fields: {
+      rate: num(0.01, 100, 2),
+      min: num(-1000, 1000, -1),
+      max: num(-1000, 1000, 1),
+      slew: duration(0, 1000, '0ms')
+    },
+    rangeOrder: ['min', 'max']
+  },
+  gain: {
+    class: 'processing', acceptsAudio: true,
+    fields: { gain: num(0, 4, 1) }
+  },
+  filter: {
+    class: 'processing', acceptsAudio: true,
+    fields: {
+      mode: enumeration(['lowpass', 'highpass', 'bandpass', 'notch', 'peaking', 'lowshelf', 'highshelf', 'allpass'], 'lowpass'),
+      frequency: num(10, AUDIO_STATIC_MAX_FREQUENCY, 1000, { ceiling: 'audio' }),
+      q: num(0.0001, 100, 1),
+      gain: num(-40, 40, 0),
+      detune: num(-4800, 4800, 0)
+    }
+  },
+  compressor: {
+    class: 'processing', acceptsAudio: true,
+    fields: {
+      threshold: num(-100, 0, -24),
+      knee: num(0, 40, 30),
+      ratio: num(1, 20, 12),
+      attack: duration(0, 1000, '3ms'),
+      release: duration(10, 1000, '250ms')
+    }
+  },
+  waveshaper: {
+    class: 'processing', acceptsAudio: true,
+    fields: {
+      shape: enumeration(['soft-clip', 'hard-clip', 'saturation'], 'soft-clip'),
+      amount: num(0, 1, 0.5),
+      oversample: enumeration(['none', '2x', '4x'], 'none')
+    }
+  },
+  delay: {
+    class: 'processing', acceptsAudio: true,
+    fields: {
+      time: duration(0, 10000, '250ms'),
+      feedback: num(0, 0.95, 0.2),
+      mix: num(0, 1, 0.5)
+    }
+  },
+  reverb: {
+    class: 'processing', acceptsAudio: true,
+    fields: {
+      size: num(0, 1, 0.5),
+      decay: duration(50, 30000, '2s'),
+      damping: num(0, 1, 0.5),
+      predelay: duration(0, 500, '0ms'),
+      mix: num(0, 1, 0.25)
+    }
+  },
+  'stereo-pan': {
+    class: 'processing', acceptsAudio: true,
+    fields: { pan: num(-1, 1, 0) }
+  },
+  mixer: {
+    class: 'routing', acceptsAudio: true,
+    fields: {}
+  },
+  resonator: {
+    class: 'processing', acceptsAudio: true,
+    fields: {
+      fundamental: num(0.1, AUDIO_STATIC_MAX_FREQUENCY, 120, { ceiling: 'audio' }),
+      modes: { kind: 'modes', valuespec: false, required: true },
+      mix: num(0, 1, 1)
+    }
+  },
+  component: {
+    class: 'composite', acceptsAudio: 'declared',
+    fields: {
+      use: { kind: 'component-ref', valuespec: false, required: true },
+      values: { kind: 'component-values', valuespec: false }
+    }
+  }
+});
+
+const AUDIO_NODE_TYPE_NAMES = Object.freeze(Object.keys(AUDIO_NODE_TYPES));
+
+const AUDIO_PARTIAL_FIELDS = Object.freeze({
+  ratio: { min: 0.001, max: 256, required: true },
+  gain: { min: 0, max: 1, required: true },
+  phase: { min: 0, max: 360, default: 0, exclusiveMax: true }
+});
+
+const AUDIO_MODE_FIELDS = Object.freeze({
+  ratio: { min: 0.001, max: 256 },
+  frequency: { min: 0.1, max: AUDIO_STATIC_MAX_FREQUENCY, ceiling: 'audio' },
+  gain: { min: 0, max: 1, default: 1 },
+  decay: { kind: 'duration', min: 10, max: 20000, default: '1s' }
+});
+
+// Section 15.13. Depth is expressed in the listed unit; anything absent is ERR_UNSUPPORTED_TARGET.
+const AUDIO_MODULATABLE = Object.freeze({
+  oscillator: Object.freeze({ frequency: 'hz', detune: 'cents' }),
+  gain: Object.freeze({ gain: 'linear' }),
+  filter: Object.freeze({ frequency: 'hz', q: 'unitless', gain: 'db', detune: 'cents' }),
+  delay: Object.freeze({ time: 'ms' }),
+  'stereo-pan': Object.freeze({ pan: 'pan' }),
+  resonator: Object.freeze({ fundamental: 'hz' })
+});
+
+const AUDIO_MODULATION_SOURCE_TYPES = Object.freeze(['constant', 'lfo', 'sample-hold', 'oscillator']);
+
+const AUDIO_SOUND_FIELDS = Object.freeze(['name', 'tags', 'usage', 'cadence', 'bus', 'recipe']);
+const AUDIO_SOUND_USAGE = Object.freeze(['automatic', 'manual', 'scenario']);
+const AUDIO_RECIPE_MODES = Object.freeze(['oneshot', 'continuous']);
+const AUDIO_GRAPH_FIELDS = Object.freeze(['nodes', 'routes', 'automation']);
+const AUDIO_RECIPE_FIELDS = Object.freeze(['nodes', 'routes', 'automation', 'mode', 'release']);
+const AUDIO_COMPONENT_FIELDS = Object.freeze(['nodes', 'routes', 'automation', 'parameters', 'input']);
+const AUDIO_AUTOMATION_FIELDS = Object.freeze(['target', 'mode', 'interpolation', 'points']);
+const AUDIO_AUTOMATION_MODES = Object.freeze(['absolute', 'offset', 'scale']);
+const AUDIO_AUTOMATION_CURVES = Object.freeze(['step', 'linear', 'exponential', 'smooth']);
+const AUDIO_COMPONENT_PARAMETER_FIELDS = Object.freeze(['type', 'default', 'min', 'max', 'unit']);
+const AUDIO_BUS_FIELDS = Object.freeze(['gain']);
+const AUDIO_BUS_GAIN_RANGE = Object.freeze({ min: 0, max: 4, default: 1 });
+const AUDIO_ROUTE_FIELDS = Object.freeze(['from', 'to', 'depth']);
+
+const AUDIO_VOICE_LIMITS = Object.freeze({
+  oneshot: 64,
+  continuous: 16
+});
+
+const AUDIO_DEFAULT_RELEASE_MS = 50;
+const AUDIO_MAX_RELEASE_MS = 10000;
+
+const AUDIO_LIFECYCLE_STATES = Object.freeze([
+  'CREATED',
+  'SCHEDULED',
+  'ACTIVE',
+  'RELEASING',
+  'FINISHED',
+  'DISPOSED',
+  'FAILED'
+]);
+
+const AUDIO_LIFECYCLE_TRANSITIONS = Object.freeze({
+  CREATED: Object.freeze(['SCHEDULED', 'FINISHED', 'FAILED']),
+  SCHEDULED: Object.freeze(['ACTIVE', 'RELEASING', 'FAILED']),
+  ACTIVE: Object.freeze(['RELEASING', 'FINISHED', 'FAILED']),
+  RELEASING: Object.freeze(['FINISHED', 'FAILED']),
+  FINISHED: Object.freeze(['DISPOSED']),
+  DISPOSED: Object.freeze([]),
+  FAILED: Object.freeze([])
+});
+
+function audioMaxFrequency(sampleRate) {
+  if (!Number.isFinite(sampleRate) || sampleRate <= 0) return AUDIO_STATIC_MAX_FREQUENCY;
+  return Math.min(AUDIO_STATIC_MAX_FREQUENCY, sampleRate * AUDIO_NYQUIST_FACTOR);
+}
+
+function isControlSourceType(type) {
+  return AUDIO_NODE_TYPES[type]?.class === 'control';
+}
+
+function isSourceType(type) {
+  const entry = AUDIO_NODE_TYPES[type];
+  return entry?.class === 'source' || entry?.class === 'control';
+}
+
+/* src/runtime/audio-protection.js */
+// This exact class is serialized into the embedded worklet and exercised in tests.
+// No browser globals or imports are used by the DSP core.
+class MasterProtectionDSP {
+  constructor(rate, settings) {
+    this.ceiling = 10 ** (settings.ceilingDb / 20);
+    this.delayFrames = Math.max(1, Math.ceil(rate * settings.lookaheadMs / 1000));
+    this.delay = Array.from({ length: settings.channels }, () => new Float32Array(this.delayFrames));
+    this.attack = Math.exp(-1 / (rate * settings.attackMs / 1000));
+    this.release = Math.exp(-1 / (rate * settings.releaseMs / 1000));
+    this.position = 0;
+    this.gain = 1;
+    this.heldPeak = 0;
+    this.hold = 0;
+    this.affectedBlocks = 0;
+  }
+
+  process(input, output, fault = false) {
+    let badSamples = 0;
+    for (const channel of input) for (const sample of channel) if (!Number.isFinite(sample)) badSamples++;
+    const muted = fault || badSamples > 0;
+    if (muted) {
+      // Flush pending audio as well: no corrupted history can reappear later.
+      for (const channel of this.delay) channel.fill(0);
+      for (const channel of output) channel.fill(0);
+      this.heldPeak = 0;
+      this.hold = 0;
+      this.affectedBlocks++;
+      return { muted, badSamples, peak: 0, clampedSamples: 0 };
+    }
+    let peak = 0, clampedSamples = 0;
+    for (let i = 0; i < output[0].length; i++) {
+      let incomingPeak = 0;
+      for (const channel of input) incomingPeak = Math.max(incomingPeak, Math.abs(channel[i] ?? 0));
+      if (incomingPeak >= this.heldPeak) {
+        this.heldPeak = incomingPeak;
+        this.hold = this.delayFrames;
+      } else if (this.hold > 0) this.hold--;
+      else this.heldPeak = incomingPeak;
+      const target = this.heldPeak > this.ceiling ? this.ceiling / this.heldPeak : 1;
+      const coefficient = target < this.gain ? this.attack : this.release;
+      this.gain = target + coefficient * (this.gain - target);
+      for (let c = 0; c < output.length; c++) {
+        const delayed = this.delay[c][this.position];
+        this.delay[c][this.position] = input[c]?.[i] ?? 0;
+        const value = delayed * this.gain;
+        if (Math.abs(value) > this.ceiling) clampedSamples++;
+        // Final sample clamp is required even during attack and extreme overload.
+        output[c][i] = Math.max(-this.ceiling, Math.min(this.ceiling, value));
+        peak = Math.max(peak, Math.abs(output[c][i]));
+      }
+      this.position = (this.position + 1) % this.delayFrames;
+    }
+    return { muted, badSamples, peak, clampedSamples };
+  }
+}
+
+function protectionWorkletSource() {
+  return `const SETTINGS = ${JSON.stringify(AUDIO_PROTECTION)};
+${MasterProtectionDSP.toString()}
+class XZBTProtectionProcessor extends AudioWorkletProcessor {
+  constructor(options) {
+    super();
+    this.guard = options.processorOptions?.guard === true;
+    this.dsp = this.guard ? null : new MasterProtectionDSP(sampleRate, SETTINGS);
+    this.warned = false;
+    this.capture = null;
+    this.port.onmessage = ({ data }) => {
+      if (data.type === 'capture' && !this.guard) {
+        this.capture = { id: data.id, skip: data.warmupFrames, remaining: data.frames,
+          frames: 0, peak: 0, affectedBlocks: 0, nonfiniteSamples: 0, clampedSamples: 0 };
+      }
+    };
+  }
+  process(inputs, outputs) {
+    const input = inputs[0] ?? [], output = outputs[0];
+    let result;
+    if (this.guard) {
+      let badSamples = 0;
+      for (const channel of input) for (const sample of channel) if (!Number.isFinite(sample)) badSamples++;
+      for (let c = 0; c < output.length; c++) {
+        output[c].fill(0);
+        if (!badSamples && input[c]) output[c].set(input[c]);
+      }
+      // Separate finite fault lane lets the final master mute the same whole
+      // render quantum, while attribution remains attached to this voice.
+      outputs[1][0].fill(badSamples);
+      result = { badSamples, muted: badSamples > 0 };
+    } else {
+      const fault = (inputs[1] ?? []).some(channel => channel.some(value => value !== 0));
+      result = this.dsp.process(input, output, fault);
+      const capture = this.capture;
+      if (capture) {
+        const start = Math.min(capture.skip, output[0].length);
+        capture.skip -= start;
+        const count = Math.min(capture.remaining, output[0].length - start);
+        if (count > 0) {
+          for (const channel of output) for (let i = start; i < start + count; i++) capture.peak = Math.max(capture.peak, Math.abs(channel[i]));
+          capture.frames += count;
+          capture.remaining -= count;
+          capture.affectedBlocks += result.muted ? 1 : 0;
+          capture.nonfiniteSamples += result.badSamples + (inputs[1]?.[0]?.[0] ?? 0);
+          capture.clampedSamples += result.clampedSamples;
+        }
+        if (capture.remaining === 0) {
+          this.port.postMessage({ type: 'capture', ...capture, sampleRate });
+          this.capture = null;
+        }
+      }
+    }
+    if (result.badSamples > 0 && !this.warned) {
+      this.warned = true;
+      this.port.postMessage({ type: 'nonfinite' });
+    }
+    return true;
+  }
+}
+registerProcessor('xzbt-protection', XZBTProtectionProcessor);`;
+}
+
+async function loadProtectionWorklet(context) {
+  if (!context.audioWorklet || typeof globalThis.AudioWorkletNode !== 'function') {
+    throw new Error('AudioWorklet master protection is unavailable.');
+  }
+  // The Phase 0 direct-file probe verified this embedded data-URL loading path.
+  await context.audioWorklet.addModule(`data:text/javascript;charset=utf-8,${encodeURIComponent(protectionWorkletSource())}`);
+}
+
+function createProtectionNode(context, guard = false) {
+  return new AudioWorkletNode(context, 'xzbt-protection', {
+    numberOfInputs: guard ? 1 : 2,
+    numberOfOutputs: guard ? 2 : 1,
+    outputChannelCount: guard ? [AUDIO_PROTECTION.channels, 1] : [AUDIO_PROTECTION.channels],
+    channelCount: AUDIO_PROTECTION.channels,
+    channelCountMode: 'explicit',
+    processorOptions: { guard }
+  });
+}
+
+/* src/runtime/audio-automation.js */
+// Shared numeric stages and immutable, once-sampled automation (spec 8.1 / 16.1).
+
+
+function sampleAutomationTrack(definition, evaluate, warn = () => {}) {
+  const mode = definition.mode ?? 'absolute';
+  const interpolation = definition.interpolation ?? 'linear';
+  if (!AUDIO_AUTOMATION_MODES.includes(mode) || !AUDIO_AUTOMATION_CURVES.includes(interpolation)) {
+    throw new RuntimeFault('ERR_TYPE_MISMATCH', 'Invalid automation mode or interpolation.', definition.path);
+  }
+  if (!Array.isArray(definition.points) || definition.points.length < 2) {
+    throw new RuntimeFault('ERR_SCHEMA_VALIDATION', 'Automation requires at least two points.', definition.path);
+  }
+  if (definition.points.length > AUDIO_LIMITS.automationPoints) {
+    throw new RuntimeFault('ERR_NODE_LIMIT_EXCEEDED', 'Automation exceeds the point limit.', definition.path);
+  }
+  let previous = -1;
+  const points = definition.points.map((point, index) => {
+    const path = `${definition.path ?? definition.target}.points[${index}]`;
+    if (typeof point.at !== 'string') throw new RuntimeFault('ERR_TYPE_MISMATCH', 'Automation time must be a duration literal.', path);
+    const at = parseDuration(point.at, path);
+    if (at <= previous) throw new RuntimeFault('ERR_INVALID_RANGE_ORDER', 'Automation times must strictly increase.', path);
+    previous = at;
+    const value = evaluate(point.value, `${path}.value`);
+    if (typeof value !== 'number' || !Number.isFinite(value)) throw new RuntimeFault('ERR_TYPE_MISMATCH', 'Automation values must resolve to finite numbers.', path);
+    return Object.freeze({ at, value });
+  });
+  if (interpolation === 'exponential' && points.some((point) => point.value <= 0)) {
+    warn({ code: 'WARN_AUTOMATION_FALLBACK', path: definition.path ?? definition.target, message: 'Nonpositive exponential endpoints use linear interpolation (once per track).' });
+  }
+  return Object.freeze({ ...definition, mode, interpolation, points: Object.freeze(points) });
+}
+
+function interpolateAutomation(curve, v0, v1, t) {
+  if (curve === 'step') return v0;
+  if (curve === 'exponential' && v0 > 0 && v1 > 0) return Math.exp(Math.log(v0) * (1 - t) + Math.log(v1) * t);
+  const progress = curve === 'smooth' ? t * t * (3 - 2 * t) : t;
+  return v0 * (1 - progress) + v1 * progress;
+}
+
+function automationValueAt(track, milliseconds) {
+  const points = track.points;
+  if (milliseconds <= points[0].at) return points[0].value;
+  for (let index = 1; index < points.length; index += 1) {
+    const left = points[index - 1], right = points[index];
+    if (milliseconds < right.at) return interpolateAutomation(track.interpolation, left.value, right.value, (milliseconds - left.at) / (right.at - left.at));
+  }
+  return points[points.length - 1].value;
+}
+
+function applyAutomationMode(base, value, mode) {
+  return mode === 'offset' ? base + value : mode === 'scale' ? base * value : value;
+}
+
+// Callers supply only stages their target exposes; the override sees the current
+// lower value on every evaluation, even while it masks automation.
+function resolveNumericStages(base, { binding, automation, override, modulation = 0, min = -Infinity, max = Infinity, round } = {}) {
+  let value = binding ? binding(base) : base;
+  if (automation) value = automation(value);
+  if (override) value = override(value);
+  value += modulation;
+  if (!Number.isFinite(value)) throw new RuntimeFault('ERR_OUT_OF_BOUNDS', 'Numeric resolution produced a non-finite value.');
+  if (round) value = round(value);
+  return clamp(value, min, max);
+}
+
+/* src/runtime/audio-graph.js */
+// Audio graph validation, component expansion, legality checking, and deterministic
+// instantiation. Pure: never touches an AudioContext (Format Specification 14.5).
+
+
+
+
+const DURATION_UNITS = Object.freeze({ ms: 1, s: 1000, m: 60_000, h: 3_600_000 });
+
+function isObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function durationMilliseconds(value) {
+  if (typeof value !== 'string') return null;
+  const match = DURATION_PATTERN.exec(value);
+  if (!match) return null;
+  const milliseconds = Number(match[1]) * DURATION_UNITS[match[2]];
+  return Number.isFinite(milliseconds) ? milliseconds : null;
+}
+
+function fail(errors, code, path, message) {
+  errors.push({ code, path, message });
+}
+
+/* ------------------------------------------------------------------ *
+ * Structural validation of a single graph object (section 14.3)
+ * ------------------------------------------------------------------ */
+
+function validateNumericField(document, value, spec, path, errors, helpers, scope) {
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) return fail(errors, 'ERR_TYPE_MISMATCH', path, 'Numeric field must be finite.');
+    const overMax = spec.exclusiveMax ? value >= spec.max : value > spec.max;
+    if (value < spec.min || overMax) {
+      fail(errors, 'ERR_OUT_OF_BOUNDS', path, `Value ${value} is outside [${spec.min}, ${spec.max}${spec.exclusiveMax ? ')' : ']'}.`);
+    }
+    return;
+  }
+  if (!spec.valuespec) return fail(errors, 'ERR_TYPE_MISMATCH', path, 'Field requires a literal number.');
+  helpers.validateValueSpec(document, value, path, errors, scope);
+}
+
+function validateDurationField(value, spec, path, errors) {
+  const milliseconds = durationMilliseconds(value);
+  if (milliseconds === null) return fail(errors, 'ERR_INVALID_DURATION', path, `Invalid duration ${JSON.stringify(value)}.`);
+  if (milliseconds < spec.min || milliseconds > spec.max) {
+    fail(errors, 'ERR_OUT_OF_BOUNDS', path, `Duration ${value} is outside [${spec.min}ms, ${spec.max}ms].`);
+  }
+}
+
+function validatePartials(document, node, path, errors, helpers, scope) {
+  const waveform = node.waveform ?? 'sine';
+  const present = Object.hasOwn(node, 'harmonics');
+  if (waveform !== 'custom') {
+    if (present) fail(errors, 'ERR_UNKNOWN_FIELD', `${path}.harmonics`, "harmonics is only declared when waveform is 'custom'.");
+    return;
+  }
+  if (!present) return fail(errors, 'ERR_SCHEMA_VALIDATION', `${path}.harmonics`, "waveform 'custom' requires harmonics.");
+  const partials = node.harmonics;
+  if (!Array.isArray(partials) || partials.length === 0) return fail(errors, 'ERR_SCHEMA_VALIDATION', `${path}.harmonics`, 'harmonics must be a non-empty array.');
+  if (partials.length > AUDIO_LIMITS.oscillatorPartials) {
+    fail(errors, 'ERR_NODE_LIMIT_EXCEEDED', `${path}.harmonics`, `At most ${AUDIO_LIMITS.oscillatorPartials} partials are permitted.`);
+  }
+  partials.forEach((partial, index) => {
+    const entryPath = `${path}.harmonics[${index}]`;
+    if (!isObject(partial)) return fail(errors, 'ERR_SCHEMA_VALIDATION', entryPath, 'Partial must be an object.');
+    for (const field of Object.keys(partial)) {
+      if (!Object.hasOwn(AUDIO_PARTIAL_FIELDS, field)) fail(errors, 'ERR_UNKNOWN_FIELD', `${entryPath}.${field}`, `Unrecognized partial field '${field}'.`);
+    }
+    for (const [field, rule] of Object.entries(AUDIO_PARTIAL_FIELDS)) {
+      if (!Object.hasOwn(partial, field)) {
+        if (rule.required) fail(errors, 'ERR_SCHEMA_VALIDATION', `${entryPath}.${field}`, `Partial requires '${field}'.`);
+        continue;
+      }
+      validateNumericField(document, partial[field], { ...rule, valuespec: true }, `${entryPath}.${field}`, errors, helpers, scope);
+    }
+  });
+}
+
+function validateModes(document, node, path, errors, helpers, scope) {
+  const modes = node.modes;
+  if (!Array.isArray(modes) || modes.length === 0) return fail(errors, 'ERR_SCHEMA_VALIDATION', `${path}.modes`, 'resonator requires a non-empty modes array.');
+  if (modes.length > AUDIO_LIMITS.resonatorModes) {
+    fail(errors, 'ERR_NODE_LIMIT_EXCEEDED', `${path}.modes`, `At most ${AUDIO_LIMITS.resonatorModes} resonator modes are permitted.`);
+  }
+  modes.forEach((mode, index) => {
+    const entryPath = `${path}.modes[${index}]`;
+    if (!isObject(mode)) return fail(errors, 'ERR_SCHEMA_VALIDATION', entryPath, 'Mode must be an object.');
+    for (const field of Object.keys(mode)) {
+      if (!Object.hasOwn(AUDIO_MODE_FIELDS, field)) fail(errors, 'ERR_UNKNOWN_FIELD', `${entryPath}.${field}`, `Unrecognized mode field '${field}'.`);
+    }
+    const hasRatio = Object.hasOwn(mode, 'ratio');
+    const hasFrequency = Object.hasOwn(mode, 'frequency');
+    if (hasRatio === hasFrequency) {
+      fail(errors, 'ERR_SCHEMA_VALIDATION', entryPath, 'Each mode declares exactly one of ratio or frequency.');
+    }
+    if (hasRatio) validateNumericField(document, mode.ratio, { ...AUDIO_MODE_FIELDS.ratio, valuespec: true }, `${entryPath}.ratio`, errors, helpers, scope);
+    if (hasFrequency) validateNumericField(document, mode.frequency, { ...AUDIO_MODE_FIELDS.frequency, valuespec: true }, `${entryPath}.frequency`, errors, helpers, scope);
+    if (Object.hasOwn(mode, 'gain')) validateNumericField(document, mode.gain, { ...AUDIO_MODE_FIELDS.gain, valuespec: true }, `${entryPath}.gain`, errors, helpers, scope);
+    if (Object.hasOwn(mode, 'decay')) validateDurationField(mode.decay, AUDIO_MODE_FIELDS.decay, `${entryPath}.decay`, errors);
+  });
+}
+
+function validateComponentInstance(document, node, path, errors, helpers, scope) {
+  const components = document.components?.audio;
+  if (typeof node.use !== 'string' || !isObject(components?.[node.use])) {
+    return fail(errors, 'ERR_INVALID_REFERENCE', `${path}.use`, `Component '${node.use}' is not declared.`);
+  }
+  const declared = components[node.use].parameters ?? {};
+  const values = node.values;
+  if (values !== undefined && !isObject(values)) return fail(errors, 'ERR_SCHEMA_VALIDATION', `${path}.values`, 'values must be an object.');
+  for (const [key, value] of Object.entries(values ?? {})) {
+    const rule = declared[key];
+    if (!isObject(rule)) {
+      fail(errors, 'ERR_UNKNOWN_FIELD', `${path}.values.${key}`, `Component '${node.use}' does not expose '${key}'.`);
+      continue;
+    }
+    validateNumericField(document, value, {
+      min: rule.min ?? -Infinity, max: rule.max ?? Infinity, valuespec: true
+    }, `${path}.values.${key}`, errors, helpers, scope);
+  }
+  for (const [key, rule] of Object.entries(declared)) {
+    if (!Object.hasOwn(values ?? {}, key) && !Object.hasOwn(rule, 'default')) {
+      fail(errors, 'ERR_SCHEMA_VALIDATION', `${path}.values.${key}`, `Exposed parameter '${key}' has no default and no supplied value.`);
+    }
+  }
+}
+
+function validateNode(document, key, node, path, errors, helpers, scope) {
+  if (!ID_PATTERN.test(key)) fail(errors, 'ERR_INVALID_ID', path, `Node key '${key}' is not a valid identifier.`);
+  if (key === 'output') fail(errors, 'ERR_INVALID_ID', path, "'output' is reserved and cannot be declared as a node.");
+  if (key === 'input') fail(errors, 'ERR_INVALID_ID', path, "'input' is reserved and cannot be declared as a node.");
+  if (!isObject(node)) return fail(errors, 'ERR_SCHEMA_VALIDATION', path, 'Node must be an object.');
+  const contract = AUDIO_NODE_TYPES[node.type];
+  if (!contract) return fail(errors, 'ERR_INVALID_NODE_TYPE', `${path}.type`, `Unrecognized audio node type '${node.type}'.`);
+
+  for (const field of Object.keys(node)) {
+    if (field === 'type') continue;
+    if (!Object.hasOwn(contract.fields, field)) fail(errors, 'ERR_UNKNOWN_FIELD', `${path}.${field}`, `Node type '${node.type}' does not declare '${field}'.`);
+  }
+
+  for (const [field, spec] of Object.entries(contract.fields)) {
+    if (spec.kind === 'partials' || spec.kind === 'modes' || spec.kind === 'component-ref' || spec.kind === 'component-values') continue;
+    if (!Object.hasOwn(node, field)) continue;
+    const value = node[field];
+    const fieldPath = `${path}.${field}`;
+    if (spec.kind === 'enum') {
+      if (typeof value !== 'string' || !spec.values.includes(value)) fail(errors, 'ERR_TYPE_MISMATCH', fieldPath, `'${field}' must be one of: ${spec.values.join(', ')}.`);
+    } else if (spec.kind === 'duration') {
+      validateDurationField(value, spec, fieldPath, errors);
+    } else {
+      validateNumericField(document, value, spec, fieldPath, errors, helpers, scope);
+    }
+  }
+
+  if (node.type === 'oscillator') validatePartials(document, node, path, errors, helpers, scope);
+  if (node.type === 'resonator') validateModes(document, node, path, errors, helpers, scope);
+  if (node.type === 'component') validateComponentInstance(document, node, path, errors, helpers, scope);
+
+  if (contract.rangeOrder) {
+    const [lowField, highField] = contract.rangeOrder;
+    const low = node[lowField] ?? contract.fields[lowField].default;
+    const high = node[highField] ?? contract.fields[highField].default;
+    if (typeof low === 'number' && typeof high === 'number' && low >= high) {
+      fail(errors, 'ERR_INVALID_RANGE_ORDER', `${path}.${lowField}`, `${lowField} must be strictly less than ${highField}.`);
+    }
+  }
+}
+
+function validateRoute(document, route, path, errors, helpers, scope) {
+  if (!isObject(route)) return fail(errors, 'ERR_SCHEMA_VALIDATION', path, 'Route must be an object.');
+  for (const field of Object.keys(route)) {
+    if (!AUDIO_ROUTE_FIELDS.includes(field)) fail(errors, 'ERR_UNKNOWN_FIELD', `${path}.${field}`, `Unrecognized route field '${field}'.`);
+  }
+  for (const field of ['from', 'to']) {
+    if (typeof route[field] !== 'string' || route[field].length === 0) fail(errors, 'ERR_SCHEMA_VALIDATION', `${path}.${field}`, `Route '${field}' must be a non-empty string.`);
+  }
+  const isModulation = typeof route.to === 'string' && route.to.includes('.');
+  if (isModulation && !Object.hasOwn(route, 'depth')) {
+    fail(errors, 'ERR_SCHEMA_VALIDATION', `${path}.depth`, 'A modulation route requires depth.');
+  }
+  if (!isModulation && Object.hasOwn(route, 'depth')) {
+    fail(errors, 'ERR_UNKNOWN_FIELD', `${path}.depth`, 'depth is only declared on a modulation route.');
+  }
+  if (Object.hasOwn(route, 'depth')) {
+    validateNumericField(document, route.depth, { min: -Infinity, max: Infinity, valuespec: true }, `${path}.depth`, errors, helpers, scope);
+  }
+}
+
+function automationTarget(document, graph, name, path, errors) {
+  if (typeof name !== 'string') { fail(errors, 'ERR_SCHEMA_VALIDATION', path, 'Automation requires a target string.'); return null; }
+  const [key, property, extra] = name.split('.');
+  const node = graph.nodes?.[key];
+  if (!isObject(node)) { fail(errors, 'ERR_INVALID_REFERENCE', path, `Automation node '${key}' is not declared in this graph.`); return null; }
+  if (node.type === 'component' && extra !== undefined) {
+    fail(errors, 'ERR_INVALID_REFERENCE', path, `Component internals are encapsulated; '${name}' is not reachable.`);
+    return null;
+  }
+  const registry = node.type === 'component' ? document.components?.audio?.[node.use]?.parameters : AUDIO_MODULATABLE[node.type];
+  if (extra !== undefined || !Object.hasOwn(registry ?? {}, property)) {
+    fail(errors, 'ERR_UNSUPPORTED_TARGET', path, `'${name}' is not an automatable property.`);
+    return null;
+  }
+  return { key, property };
+}
+
+// Structural ValueSpec checks are shared with each validator. This additional
+// expected-number walk rejects string/boolean leaves and references, including
+// branches of a choice which might not be sampled in a particular run.
+function validateAutomationNumber(document, value, path, errors) {
+  if (typeof value === 'string' || typeof value === 'boolean') return fail(errors, 'ERR_TYPE_MISMATCH', path, 'Automation requires a numeric ValueSpec.');
+  if (!isObject(value)) return;
+  if (typeof value.ref === 'string') {
+    const [namespace, id] = value.ref.split('.');
+    const type = document[namespace]?.[id]?.type;
+    if (type && !['number', 'integer'].includes(type) || value.ref === 'signals.scenario.active') fail(errors, 'ERR_TYPE_MISMATCH', path, 'Automation reference must be numeric.');
+  }
+  if (Array.isArray(value.args)) value.args.forEach((child, i) => validateAutomationNumber(document, child, `${path}.args[${i}]`, errors));
+  if (Array.isArray(value.choose)) value.choose.forEach((child, i) => validateAutomationNumber(document, child?.value, `${path}.choose[${i}].value`, errors));
+}
+
+function validateAutomation(document, graph, path, errors, helpers, scope) {
+  if (graph.automation === undefined) return;
+  if (!Array.isArray(graph.automation)) return fail(errors, 'ERR_SCHEMA_VALIDATION', path, 'automation must be an array.');
+  const targets = new Set();
+  graph.automation.forEach((track, index) => {
+    const location = `${path}[${index}]`;
+    if (!isObject(track)) return fail(errors, 'ERR_SCHEMA_VALIDATION', location, 'Automation track must be an object.');
+    for (const key of Object.keys(track)) if (!AUDIO_AUTOMATION_FIELDS.includes(key)) fail(errors, 'ERR_UNKNOWN_FIELD', `${location}.${key}`, `Unknown automation field '${key}'.`);
+    if (automationTarget(document, graph, track.target, `${location}.target`, errors)) {
+      if (targets.has(track.target)) fail(errors, 'ERR_AUTOMATION_CONFLICT', location, `More than one track controls '${track.target}'.`);
+      targets.add(track.target);
+    }
+    if (track.mode !== undefined && !AUDIO_AUTOMATION_MODES.includes(track.mode)) fail(errors, 'ERR_TYPE_MISMATCH', `${location}.mode`, 'Unsupported automation mode.');
+    if (track.interpolation !== undefined && !AUDIO_AUTOMATION_CURVES.includes(track.interpolation)) fail(errors, 'ERR_TYPE_MISMATCH', `${location}.interpolation`, 'Unsupported automation interpolation.');
+    if (!Array.isArray(track.points) || track.points.length < 2) return fail(errors, 'ERR_SCHEMA_VALIDATION', `${location}.points`, 'Automation requires at least two points.');
+    let previous = -1;
+    track.points.forEach((point, i) => {
+      const pointPath = `${location}.points[${i}]`;
+      if (!isObject(point)) return fail(errors, 'ERR_SCHEMA_VALIDATION', pointPath, 'Automation point must be an object.');
+      for (const key of Object.keys(point)) if (!['at', 'value'].includes(key)) fail(errors, 'ERR_UNKNOWN_FIELD', `${pointPath}.${key}`, `Unknown point field '${key}'.`);
+      const at = durationMilliseconds(point.at);
+      if (typeof point.at !== 'string') fail(errors, 'ERR_TYPE_MISMATCH', `${pointPath}.at`, 'Automation times must be duration literals, not TimeSpecs.');
+      else if (at === null) fail(errors, 'ERR_INVALID_DURATION', `${pointPath}.at`, 'Invalid automation duration.');
+      else {
+        if (at <= previous) fail(errors, 'ERR_INVALID_RANGE_ORDER', `${pointPath}.at`, 'Automation times must strictly increase.');
+        previous = at;
+      }
+      helpers.validateValueSpec(document, point.value, `${pointPath}.value`, errors, scope);
+      validateAutomationNumber(document, point.value, `${pointPath}.value`, errors);
+    });
+  });
+  checkAutomationLimits(graph.automation, path, errors);
+}
+
+function checkAutomationLimits(tracks, path, errors) {
+  const count = tracks.reduce((sum, track) => sum + (Array.isArray(track?.points) ? track.points.length : 0), 0);
+  if (tracks.length > AUDIO_LIMITS.automationTracks || count > AUDIO_LIMITS.automationPoints) fail(errors, 'ERR_NODE_LIMIT_EXCEEDED', path, `Automation exceeds ${AUDIO_LIMITS.automationTracks} tracks or ${AUDIO_LIMITS.automationPoints} total points per expanded sound.`);
+}
+
+function validateGraphObject(document, graph, path, errors, helpers, { allowedFields, scope }) {
+  if (!isObject(graph)) return fail(errors, 'ERR_SCHEMA_VALIDATION', path, 'Audio graph must be an object.');
+  for (const field of Object.keys(graph)) {
+    if (!allowedFields.includes(field)) fail(errors, 'ERR_UNKNOWN_FIELD', `${path}.${field}`, `Unrecognized audio graph field '${field}'.`);
+  }
+  if (!isObject(graph.nodes) || Object.keys(graph.nodes).length === 0) {
+    fail(errors, 'ERR_SCHEMA_VALIDATION', `${path}.nodes`, 'An audio graph requires a non-empty nodes object.');
+  } else {
+    for (const [key, node] of Object.entries(graph.nodes)) validateNode(document, key, node, `${path}.nodes.${key}`, errors, helpers, scope);
+  }
+  if (graph.routes !== undefined) {
+    if (!Array.isArray(graph.routes)) fail(errors, 'ERR_SCHEMA_VALIDATION', `${path}.routes`, 'routes must be an array.');
+    else graph.routes.forEach((route, index) => validateRoute(document, route, `${path}.routes[${index}]`, errors, helpers, scope));
+  }
+  validateAutomation(document, graph, `${path}.automation`, errors, helpers, scope);
+}
+
+/* ------------------------------------------------------------------ *
+ * Expansion (section 15.11 / 15.15) and legality (section 15.14)
+ * ------------------------------------------------------------------ */
+
+function recipeGraphFor(document, sound, path, errors) {
+  const recipe = sound?.recipe;
+  if (!isObject(recipe)) {
+    fail(errors, 'ERR_SCHEMA_VALIDATION', `${path}.recipe`, 'A sound requires a recipe object.');
+    return null;
+  }
+  if (Object.hasOwn(recipe, 'use')) {
+    if (Object.keys(recipe).some((field) => field !== 'use')) {
+      fail(errors, 'ERR_SCHEMA_VALIDATION', `${path}.recipe`, 'A recipe reference declares only use.');
+      return null;
+    }
+    const shared = document.audio?.recipes?.[recipe.use];
+    if (!isObject(shared)) {
+      fail(errors, 'ERR_INVALID_REFERENCE', `${path}.recipe.use`, `Recipe '${recipe.use}' is not declared.`);
+      return null;
+    }
+    return { graph: shared, path: `$.audio.recipes.${recipe.use}` };
+  }
+  return { graph: recipe, path: `${path}.recipe` };
+}
+
+function expandSoundGraph(document, soundId) {
+  const errors = [];
+  const sound = document.sounds?.[soundId];
+  const soundPath = `$.sounds.${soundId}`;
+  const located = recipeGraphFor(document, sound, soundPath, errors);
+  if (!located) return { nodes: [], routes: [], automation: [], samplingOrder: [], errors, mode: 'oneshot', release: AUDIO_DEFAULT_RELEASE_MS };
+
+  const nodes = new Map();
+  const routes = [];
+  const automation = [];
+  const samplingOrder = [];
+  const components = document.components?.audio ?? {};
+
+  const join = (prefix, key) => (prefix ? `${prefix}.${key}` : key);
+
+  function expand(graph, prefix, depth, trail, graphPath) {
+    if (depth > AUDIO_LIMITS.componentDepth) {
+      fail(errors, 'ERR_COMPONENT_RECURSION', graphPath, `Component nesting exceeds ${AUDIO_LIMITS.componentDepth} levels.`);
+      return;
+    }
+    const declared = isObject(graph.nodes) ? graph.nodes : {};
+    for (const [key, node] of Object.entries(declared)) {
+      if (!isObject(node)) continue;
+      const path = join(prefix, key);
+      samplingOrder.push({ kind: 'node', path });
+      if (node.type === 'component') {
+        const component = components[node.use];
+        if (!isObject(component)) continue;
+        if (trail.includes(node.use)) {
+          fail(errors, 'ERR_COMPONENT_RECURSION', `${graphPath}.nodes.${key}`, `Component '${node.use}' instantiates itself.`);
+          continue;
+        }
+        nodes.set(`${path}.output`, { path: `${path}.output`, type: 'gain', spec: { type: 'gain' }, implicit: true, scope: path });
+        if (component.input === true) {
+          nodes.set(`${path}.input`, { path: `${path}.input`, type: 'gain', spec: { type: 'gain' }, implicit: true, scope: path });
+        }
+        nodes.set(path, {
+          path, type: 'component', spec: node, implicit: false, scope: prefix || null,
+          component: node.use, acceptsAudio: component.input === true, exposes: component.parameters ?? {}
+        });
+        expand(component, path, depth + 1, [...trail, node.use], `$.components.audio.${node.use}`);
+      } else {
+        nodes.set(path, { path, type: node.type, spec: node, implicit: false, scope: prefix || null });
+      }
+    }
+
+    const declaresInput = prefix ? graph.input === true : false;
+    const resolve = (name, side, routePath) => {
+      if (typeof name !== 'string') return null;
+      if (name === 'output') return prefix ? `${prefix}.output` : 'output';
+      if (name === 'input') {
+        if (!declaresInput) {
+          fail(errors, 'ERR_INVALID_ROUTE', routePath, "'input' is only available inside a component declaring input: true.");
+          return null;
+        }
+        return `${prefix}.input`;
+      }
+      const head = name.split('.')[0];
+      const local = declared[head];
+      if (!isObject(local)) {
+        fail(errors, 'ERR_INVALID_REFERENCE', routePath, `Route endpoint '${name}' does not resolve in this graph.`);
+        return null;
+      }
+      const localPath = join(prefix, head);
+      const property = name.includes('.') ? name.slice(head.length + 1) : null;
+      if (local.type !== 'component') {
+        if (side === 'from' && property !== null) {
+          fail(errors, 'ERR_INVALID_ROUTE', routePath, `Route source '${name}' names a property; only nodes emit signal.`);
+          return null;
+        }
+        return property === null ? localPath : `${localPath}::${property}`;
+      }
+      if (side === 'from') {
+        if (property !== null) {
+          fail(errors, 'ERR_INVALID_REFERENCE', routePath, `Component internals are encapsulated; '${name}' is not reachable.`);
+          return null;
+        }
+        return `${localPath}.output`;
+      }
+      if (property !== null) return `${localPath}::${property}`;
+      const component = components[local.use];
+      if (component?.input !== true) {
+        fail(errors, 'ERR_INVALID_ROUTE', routePath, `Component '${local.use}' declares no audio input.`);
+        return null;
+      }
+      return `${localPath}.input`;
+    };
+
+    const declaredRoutes = Array.isArray(graph.routes) ? graph.routes : [];
+    declaredRoutes.forEach((route, index) => {
+      if (!isObject(route)) return;
+      const routePath = `${graphPath}.routes[${index}]`;
+      const from = resolve(route.from, 'from', routePath);
+      if (from === null) return;
+      if (from === 'output' || from.endsWith('.output') && route.from === 'output') {
+        fail(errors, 'ERR_INVALID_ROUTE', routePath, "'output' is sink-only and cannot be a route source.");
+        return;
+      }
+      const isModulation = typeof route.to === 'string' && route.to.includes('.');
+      const to = resolve(route.to, 'to', routePath);
+      if (to === null) return;
+      if (isModulation) {
+        const [target, property] = to.includes('::') ? to.split('::') : [to, null];
+        if (property === null) {
+          fail(errors, 'ERR_INVALID_ROUTE', routePath, `Modulation target '${route.to}' does not name a node property.`);
+          return;
+        }
+        routes.push({ kind: 'modulation', from, to: target, property, depth: route.depth, scope: prefix || null, path: routePath });
+      } else {
+        if (to.includes('::')) {
+          fail(errors, 'ERR_INVALID_ROUTE', routePath, `Audio route target '${route.to}' names a property.`);
+          return;
+        }
+        routes.push({ kind: 'audio', from, to, path: routePath });
+      }
+      samplingOrder.push({ kind: 'route', index: routes.length - 1 });
+    });
+    for (const [index, track] of (Array.isArray(graph.automation) ? graph.automation : []).entries()) {
+      if (!isObject(track)) continue;
+      const trackPath = `${graphPath}.automation[${index}]`;
+      const target = automationTarget(document, graph, track.target, `${trackPath}.target`, errors);
+      if (!target) continue;
+      automation.push({ ...track, target: join(prefix, target.key), property: target.property, scope: prefix || null, path: trackPath });
+      samplingOrder.push({ kind: 'automation', index: automation.length - 1 });
+    }
+  }
+
+  expand(located.graph, '', 1, [], located.path);
+  const mode = AUDIO_RECIPE_MODES.includes(located.graph.mode) ? located.graph.mode : 'oneshot';
+  const release = Object.hasOwn(located.graph, 'release')
+    ? (durationMilliseconds(located.graph.release) ?? AUDIO_DEFAULT_RELEASE_MS)
+    : AUDIO_DEFAULT_RELEASE_MS;
+  checkAutomationLimits(automation, located.path, errors);
+  const seen = new Set();
+  for (const track of automation) {
+    const target = `${track.target}::${track.property}`;
+    if (seen.has(target)) fail(errors, 'ERR_AUTOMATION_CONFLICT', track.path, `More than one track controls '${target}'.`);
+    seen.add(target);
+  }
+  return { nodes: [...nodes.values()], routes, automation, samplingOrder, errors, mode, release, graphPath: located.path };
+}
+
+function detectCycle(adjacency) {
+  const visiting = new Set();
+  const done = new Set();
+  let cycle = null;
+  const visit = (node, trail) => {
+    if (cycle) return;
+    if (visiting.has(node)) { cycle = [...trail, node]; return; }
+    if (done.has(node)) return;
+    visiting.add(node);
+    for (const next of adjacency.get(node) ?? []) visit(next, [...trail, node]);
+    visiting.delete(node);
+    done.add(node);
+  };
+  for (const node of adjacency.keys()) visit(node, []);
+  return cycle;
+}
+
+function checkGraphLegality(document, soundId, expansion, errors) {
+  const { nodes, routes, graphPath } = expansion;
+  const byPath = new Map(nodes.map((node) => [node.path, node]));
+  const audible = new Map();
+  const combined = new Map();
+  const link = (map, from, to) => {
+    if (!map.has(from)) map.set(from, []);
+    map.get(from).push(to);
+  };
+
+  const authored = nodes.filter((node) => !node.implicit && node.type !== 'component');
+  if (authored.length > AUDIO_LIMITS.nodesPerSound) {
+    fail(errors, 'ERR_NODE_LIMIT_EXCEEDED', graphPath, `Expanded graph declares ${authored.length} nodes; the limit is ${AUDIO_LIMITS.nodesPerSound}.`);
+  }
+  if (routes.length > AUDIO_LIMITS.routesPerSound) {
+    fail(errors, 'ERR_NODE_LIMIT_EXCEEDED', graphPath, `Expanded graph declares ${routes.length} routes; the limit is ${AUDIO_LIMITS.routesPerSound}.`);
+  }
+
+  for (const route of routes) {
+    if (route.from === route.to) {
+      fail(errors, 'ERR_INVALID_ROUTE', route.path, 'A route cannot connect a node to itself.');
+      continue;
+    }
+    if (route.kind === 'audio') {
+      const target = byPath.get(route.to);
+      if (route.to !== 'output') {
+        if (!target) { fail(errors, 'ERR_INVALID_REFERENCE', route.path, `Route target '${route.to}' does not resolve.`); continue; }
+        const contract = AUDIO_NODE_TYPES[target.type];
+        const accepts = target.implicit || (target.type === 'component' ? target.acceptsAudio : contract?.acceptsAudio === true);
+        if (!accepts) { fail(errors, 'ERR_INVALID_ROUTE', route.path, `Node '${route.to}' does not accept audio input.`); continue; }
+      }
+      link(audible, route.from, route.to);
+      link(combined, route.from, route.to);
+      continue;
+    }
+    const target = byPath.get(route.to);
+    if (!target) { fail(errors, 'ERR_INVALID_REFERENCE', route.path, `Modulation target '${route.to}' does not resolve.`); continue; }
+    const source = byPath.get(route.from);
+    if (!source) { fail(errors, 'ERR_INVALID_REFERENCE', route.path, `Modulation source '${route.from}' does not resolve.`); continue; }
+    const sourceType = source.implicit ? 'gain' : source.type;
+    if (!AUDIO_MODULATION_SOURCE_TYPES.includes(sourceType)) {
+      fail(errors, 'ERR_INVALID_ROUTE', route.path, `Node type '${sourceType}' cannot drive a modulation route.`);
+      continue;
+    }
+    const permitted = target.type === 'component'
+      ? Object.hasOwn(target.exposes ?? {}, route.property)
+      : Object.hasOwn(AUDIO_MODULATABLE[target.type] ?? {}, route.property);
+    if (!permitted) {
+      fail(errors, 'ERR_UNSUPPORTED_TARGET', route.path, `'${target.type}.${route.property}' is not a modulatable property.`);
+      continue;
+    }
+    link(combined, route.from, route.to);
+  }
+
+  const audioCycle = detectCycle(audible);
+  if (audioCycle) fail(errors, 'ERR_CYCLIC_DEPENDENCY', graphPath, `Audio route cycle: ${audioCycle.join(' -> ')}.`);
+  const combinedCycle = detectCycle(combined);
+  if (!audioCycle && combinedCycle) fail(errors, 'ERR_CYCLIC_DEPENDENCY', graphPath, `Modulation dependency cycle: ${combinedCycle.join(' -> ')}.`);
+
+  if (audioCycle) return;
+  const reaches = (start) => {
+    const seen = new Set();
+    const queue = [start];
+    while (queue.length) {
+      const current = queue.shift();
+      if (current === 'output') return true;
+      if (seen.has(current)) continue;
+      seen.add(current);
+      for (const next of audible.get(current) ?? []) queue.push(next);
+    }
+    return false;
+  };
+
+  let audiblePath = false;
+  for (const node of nodes) {
+    if (node.implicit || node.type === 'component') continue;
+    const contract = AUDIO_NODE_TYPES[node.type];
+    if (!contract) continue;
+    if (contract.acceptsAudio === false && reaches(node.path)) {
+      if (contract.class === 'control') {
+        fail(errors, 'ERR_INVALID_ROUTE', node.path, `Control source '${node.path}' reaches audible output.`);
+      } else {
+        audiblePath = true;
+        if (expansion.mode === 'oneshot' && (node.type === 'oscillator' || node.type === 'noise')) {
+          fail(errors, 'ERR_INDETERMINATE_ONESHOT', graphPath, `Sound '${soundId}' is a oneshot with an unbounded audible path from '${node.path}' (${node.type}).`);
+        }
+      }
+    }
+    if (contract.acceptsAudio === false) {
+      for (const route of routes) {
+        if (route.kind === 'audio' && route.to === node.path) {
+          fail(errors, 'ERR_INVALID_ROUTE', route.path, `Source node '${node.path}' cannot receive audio input.`);
+        }
+      }
+    }
+  }
+  if (!audiblePath) fail(errors, 'ERR_NO_AUDIBLE_PATH', graphPath, `Sound '${soundId}' has no audio path from a source to output.`);
+}
+
+/* ------------------------------------------------------------------ *
+ * Document-level entry point
+ * ------------------------------------------------------------------ */
+
+function validateAudioSubsystem(document, errors, helpers) {
+  const audio = document.audio;
+  if (audio !== undefined) {
+    if (!isObject(audio)) fail(errors, 'ERR_SCHEMA_VALIDATION', '$.audio', 'audio must be an object.');
+    else {
+      for (const field of Object.keys(audio)) {
+        if (field === 'master') fail(errors, 'ERR_UNKNOWN_FIELD', '$.audio.master', 'audio.master is engine-provided and is reserved for the Phase 3c master-protection contract.');
+        else if (!['buses', 'recipes'].includes(field)) fail(errors, 'ERR_UNKNOWN_FIELD', `$.audio.${field}`, `Unrecognized audio field '${field}'.`);
+      }
+      if (audio.buses !== undefined) {
+        if (!isObject(audio.buses)) fail(errors, 'ERR_SCHEMA_VALIDATION', '$.audio.buses', 'buses must be an object.');
+        else for (const [id, bus] of Object.entries(audio.buses)) {
+          const path = `$.audio.buses.${id}`;
+          if (!ID_PATTERN.test(id)) fail(errors, 'ERR_INVALID_ID', path, `Bus ID '${id}' is not a valid identifier.`);
+          if (id === 'master') fail(errors, 'ERR_INVALID_ID', path, "'master' is engine-provided and cannot be declared.");
+          if (!isObject(bus)) { fail(errors, 'ERR_SCHEMA_VALIDATION', path, 'Bus must be an object.'); continue; }
+          for (const field of Object.keys(bus)) if (!AUDIO_BUS_FIELDS.includes(field)) fail(errors, 'ERR_UNKNOWN_FIELD', `${path}.${field}`, `Unrecognized bus field '${field}'.`);
+          if (Object.hasOwn(bus, 'gain')) {
+            validateNumericField(document, bus.gain, { min: AUDIO_BUS_GAIN_RANGE.min, max: AUDIO_BUS_GAIN_RANGE.max, valuespec: true }, `${path}.gain`, errors, helpers, null);
+          }
+        }
+      }
+      if (audio.recipes !== undefined) {
+        if (!isObject(audio.recipes)) fail(errors, 'ERR_SCHEMA_VALIDATION', '$.audio.recipes', 'recipes must be an object.');
+        else for (const [id, recipe] of Object.entries(audio.recipes)) {
+          const path = `$.audio.recipes.${id}`;
+          if (!ID_PATTERN.test(id)) fail(errors, 'ERR_INVALID_ID', path, `Recipe ID '${id}' is not a valid identifier.`);
+          validateGraphObject(document, recipe, path, errors, helpers, { allowedFields: AUDIO_RECIPE_FIELDS, scope: null });
+          if (Object.hasOwn(recipe, 'mode') && !AUDIO_RECIPE_MODES.includes(recipe.mode)) {
+            fail(errors, 'ERR_TYPE_MISMATCH', `${path}.mode`, `Recipe mode must be one of: ${AUDIO_RECIPE_MODES.join(', ')}.`);
+          }
+          if (Object.hasOwn(recipe, 'release')) {
+            validateDurationField(recipe.release, { min: 0, max: AUDIO_MAX_RELEASE_MS }, `${path}.release`, errors);
+          }
+        }
+      }
+    }
+  }
+
+  const componentRoot = document.components?.audio;
+  if (componentRoot !== undefined) {
+    if (!isObject(componentRoot)) fail(errors, 'ERR_SCHEMA_VALIDATION', '$.components.audio', 'components.audio must be an object.');
+    else for (const [id, component] of Object.entries(componentRoot)) {
+      const path = `$.components.audio.${id}`;
+      if (!ID_PATTERN.test(id)) fail(errors, 'ERR_INVALID_ID', path, `Component ID '${id}' is not a valid identifier.`);
+      if (!isObject(component)) { fail(errors, 'ERR_SCHEMA_VALIDATION', path, 'Component must be an object.'); continue; }
+      const exposed = new Set();
+      if (component.parameters !== undefined) {
+        if (!isObject(component.parameters)) fail(errors, 'ERR_SCHEMA_VALIDATION', `${path}.parameters`, 'parameters must be an object.');
+        else for (const [name, rule] of Object.entries(component.parameters)) {
+          const rulePath = `${path}.parameters.${name}`;
+          if (!ID_PATTERN.test(name)) fail(errors, 'ERR_INVALID_ID', rulePath, `Exposed parameter '${name}' is not a valid identifier.`);
+          if (!isObject(rule)) { fail(errors, 'ERR_SCHEMA_VALIDATION', rulePath, 'Exposed parameter must be an object.'); continue; }
+          for (const field of Object.keys(rule)) if (!AUDIO_COMPONENT_PARAMETER_FIELDS.includes(field)) fail(errors, 'ERR_UNKNOWN_FIELD', `${rulePath}.${field}`, `Unrecognized parameter field '${field}'.`);
+          if (rule.type !== 'number') fail(errors, 'ERR_TYPE_MISMATCH', `${rulePath}.type`, "Exposed audio parameters must declare type 'number' in 0.1.");
+          for (const field of ['default', 'min', 'max']) {
+            if (Object.hasOwn(rule, field) && !Number.isFinite(rule[field])) fail(errors, 'ERR_TYPE_MISMATCH', `${rulePath}.${field}`, `${field} must be a finite number.`);
+          }
+          if (Number.isFinite(rule.min) && Number.isFinite(rule.max) && rule.min > rule.max) fail(errors, 'ERR_OUT_OF_BOUNDS', `${rulePath}.min`, 'min cannot exceed max.');
+          exposed.add(name);
+        }
+      }
+      if (Object.hasOwn(component, 'input') && typeof component.input !== 'boolean') {
+        fail(errors, 'ERR_TYPE_MISMATCH', `${path}.input`, 'input must be a boolean.');
+      }
+      validateGraphObject(document, component, path, errors, helpers, {
+        allowedFields: AUDIO_COMPONENT_FIELDS,
+        scope: { componentParameters: exposed }
+      });
+    }
+  }
+
+  const sounds = document.sounds;
+  if (sounds === undefined) return;
+  if (!isObject(sounds)) return fail(errors, 'ERR_SCHEMA_VALIDATION', '$.sounds', 'sounds must be an object.');
+  for (const [id, sound] of Object.entries(sounds)) {
+    const path = `$.sounds.${id}`;
+    if (!ID_PATTERN.test(id)) fail(errors, 'ERR_INVALID_ID', path, `Sound ID '${id}' is not a valid identifier.`);
+    if (!isObject(sound)) { fail(errors, 'ERR_SCHEMA_VALIDATION', path, 'Sound must be an object.'); continue; }
+    for (const field of Object.keys(sound)) if (!AUDIO_SOUND_FIELDS.includes(field)) fail(errors, 'ERR_UNKNOWN_FIELD', `${path}.${field}`, `Unrecognized sound field '${field}'.`);
+    if (typeof sound.name !== 'string' || sound.name.trim().length === 0 || sound.name.length > 128) {
+      fail(errors, 'ERR_SCHEMA_VALIDATION', `${path}.name`, 'Sound name must be a non-empty string of at most 128 characters.');
+    }
+    if (sound.tags !== undefined && (!Array.isArray(sound.tags) || sound.tags.length > 16 || sound.tags.some((tag) => typeof tag !== 'string' || tag.length > 32))) {
+      fail(errors, 'ERR_TYPE_MISMATCH', `${path}.tags`, 'Tags must contain at most 16 strings of at most 32 characters.');
+    }
+    if (sound.usage !== undefined && (!Array.isArray(sound.usage) || sound.usage.length === 0 || sound.usage.some((entry) => !AUDIO_SOUND_USAGE.includes(entry)))) {
+      fail(errors, 'ERR_TYPE_MISMATCH', `${path}.usage`, `usage entries must be among: ${AUDIO_SOUND_USAGE.join(', ')}.`);
+    }
+    if (sound.cadence !== undefined && !isObject(sound.cadence)) {
+      fail(errors, 'ERR_SCHEMA_VALIDATION', `${path}.cadence`, 'cadence must be an object.');
+    }
+    if (sound.bus !== undefined && !isObject(document.audio?.buses?.[sound.bus])) {
+      fail(errors, 'ERR_INVALID_REFERENCE', `${path}.bus`, `Bus '${sound.bus}' is not declared.`);
+    }
+    if (isObject(sound.recipe) && !Object.hasOwn(sound.recipe, 'use')) {
+      validateGraphObject(document, sound.recipe, `${path}.recipe`, errors, helpers, { allowedFields: AUDIO_RECIPE_FIELDS, scope: null });
+      if (Object.hasOwn(sound.recipe, 'mode') && !AUDIO_RECIPE_MODES.includes(sound.recipe.mode)) {
+        fail(errors, 'ERR_TYPE_MISMATCH', `${path}.recipe.mode`, `Recipe mode must be one of: ${AUDIO_RECIPE_MODES.join(', ')}.`);
+      }
+      if (Object.hasOwn(sound.recipe, 'release')) {
+        validateDurationField(sound.recipe.release, { min: 0, max: AUDIO_MAX_RELEASE_MS }, `${path}.recipe.release`, errors);
+      }
+    }
+    const expansion = expandSoundGraph(document, id);
+    errors.push(...expansion.errors);
+    if (expansion.nodes.length > 0) checkGraphLegality(document, id, expansion, errors);
+  }
+}
+
+function computeDeterminableEndingBound(expansion, resolvedNodes = null) {
+  const { nodes, routes, release = AUDIO_DEFAULT_RELEASE_MS } = expansion;
+  const resolvedMap = resolvedNodes instanceof Map
+    ? resolvedNodes
+    : Array.isArray(resolvedNodes)
+      ? new Map(resolvedNodes.map((n) => [n.path, n]))
+      : null;
+
+  const nodeMap = new Map(nodes.map((n) => [n.path, n]));
+
+  function nodeContribution(path) {
+    if (path === 'output') return 0;
+    const node = nodeMap.get(path);
+    if (!node || node.implicit || node.type === 'component') return 0;
+    const type = node.type;
+    const resolved = resolvedMap?.get(path)?.values;
+
+    if (type === 'impulse') {
+      if (resolved && typeof resolved.duration === 'number') return resolved.duration;
+      return durationMilliseconds(node.spec?.duration ?? '10ms') ?? 10;
+    }
+    if (type === 'oscillator' || type === 'noise') {
+      return Infinity;
+    }
+    if (type === 'delay') {
+      let time, feedback;
+      if (resolved) {
+        time = resolved.time ?? 250;
+        feedback = resolved.feedback ?? 0.2;
+      } else {
+        time = durationMilliseconds(node.spec?.time ?? '250ms') ?? 250;
+        feedback = typeof node.spec?.feedback === 'number' ? node.spec.feedback : 0.2;
+      }
+      if (feedback > 0) {
+        const clampedFeedback = Math.min(0.9999, Math.max(1e-6, feedback));
+        const multiplier = Math.ceil(Math.log(0.001) / Math.log(clampedFeedback));
+        return time * multiplier;
+      }
+      return time;
+    }
+    if (type === 'reverb') {
+      let predelay, decay;
+      if (resolved) {
+        predelay = resolved.predelay ?? 0;
+        decay = resolved.decay ?? 2000;
+      } else {
+        predelay = durationMilliseconds(node.spec?.predelay ?? '0ms') ?? 0;
+        decay = durationMilliseconds(node.spec?.decay ?? '2s') ?? 2000;
+      }
+      return predelay + decay;
+    }
+    if (type === 'resonator') {
+      if (resolved?.modes && Array.isArray(resolved.modes) && resolved.modes.length > 0) {
+        return Math.max(...resolved.modes.map((m) => m.decay ?? 1000));
+      }
+      const modes = node.spec?.modes ?? [];
+      if (modes.length > 0) {
+        return Math.max(...modes.map((m) => durationMilliseconds(m.decay ?? '1s') ?? 1000));
+      }
+      return 1000;
+    }
+    return 0;
+  }
+
+  const audioAdjacency = new Map();
+  const inDegree = new Map();
+  const allNodes = new Set();
+  for (const n of nodes) allNodes.add(n.path);
+  allNodes.add('output');
+
+  for (const n of allNodes) {
+    audioAdjacency.set(n, []);
+    inDegree.set(n, 0);
+  }
+
+  for (const route of routes) {
+    if (route.kind === 'audio') {
+      if (!audioAdjacency.has(route.from)) audioAdjacency.set(route.from, []);
+      audioAdjacency.get(route.from).push(route.to);
+      inDegree.set(route.to, (inDegree.get(route.to) ?? 0) + 1);
+    }
+  }
+
+  const dist = new Map();
+  for (const n of allNodes) dist.set(n, -Infinity);
+
+  for (const n of nodes) {
+    if (n.implicit || n.type === 'component') continue;
+    if (n.type === 'impulse' || n.type === 'oscillator' || n.type === 'noise') {
+      dist.set(n.path, nodeContribution(n.path));
+    }
+  }
+
+  const queue = [];
+  for (const [node, deg] of inDegree.entries()) {
+    if (deg === 0) queue.push(node);
+  }
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const currentDist = dist.get(current);
+    for (const next of audioAdjacency.get(current) ?? []) {
+      if (currentDist !== -Infinity) {
+        const nextContrib = nodeContribution(next);
+        const newDist = currentDist === Infinity ? Infinity : currentDist + nextContrib;
+        if (newDist > dist.get(next)) dist.set(next, newDist);
+      }
+      inDegree.set(next, inDegree.get(next) - 1);
+      if (inDegree.get(next) === 0) queue.push(next);
+    }
+  }
+
+  const outDist = dist.get('output');
+  if (outDist === Infinity) return Infinity;
+  if (outDist === -Infinity) return release;
+  return outDist + release;
+}
+
+/* src/runtime/audio-controls.js */
+// Native control-signal graph. Automation is scheduled once on the audio clock;
+// modulation sums before the final clamp, not directly on an unclamped AudioParam.
+
+
+
+
+function audioPropertyRange(node, property, ceiling) {
+  const rule = node.type === 'component' ? node.exposes[property] : AUDIO_NODE_TYPES[node.type].fields[property];
+  return { min: rule.min ?? -Infinity, max: rule.ceiling === 'audio' ? Math.min(rule.max, ceiling) : rule.max ?? Infinity };
+}
+
+// Exact reference evaluator used by traces and by callers inspecting a voice.
+// Source samples are supplied in their own units; sampling this function draws no RNG.
+function audioPropertyAt(plan, target, property, milliseconds, sourceValues = {}) {
+  const visiting = new Set();
+  const cache = new Map();
+  const resolve = (path, field) => {
+    const key = `${path}::${field}`;
+    if (cache.has(key)) return cache.get(key);
+    if (visiting.has(key)) throw new RuntimeFault('ERR_CYCLIC_DEPENDENCY', `Audio control cycle at '${key}'.`);
+    const node = plan.nodes.find((item) => item.path === path);
+    if (!node || !Object.hasOwn(node.type === 'component' ? node.exposes : AUDIO_MODULATABLE[node.type] ?? {}, field)) throw new RuntimeFault('ERR_UNSUPPORTED_TARGET', `Unsupported audio property '${key}'.`);
+    visiting.add(key);
+    const resolver = new ValueResolver((ref) => resolve(node.scope, ref.slice('inputs.'.length)));
+    const base = resolver.evaluate(node.expressions?.[field] ?? node.values[field], null);
+    const track = plan.automation?.find((item) => item.target === path && item.property === field);
+    const modulation = plan.routes.filter((route) => route.kind === 'modulation' && route.to === path && route.property === field)
+      .reduce((sum, route) => sum + (sourceValues[route.from] ?? 0) * route.depth, 0);
+    const value = resolveNumericStages(base, {
+      automation: track ? (lower) => applyAutomationMode(lower, automationValueAt(track, milliseconds), track.mode) : undefined,
+      modulation, ...audioPropertyRange(node, field, plan.ceiling)
+    });
+    visiting.delete(key);
+    cache.set(key, value);
+    return value;
+  };
+  return resolve(target, property);
+}
+
+function scheduleNativeAutomation(param, track, startTime) {
+  if (track.interpolation === 'smooth') throw new RuntimeFault('ERR_UNSUPPORTED_TARGET', 'Smooth automation requires the polynomial control graph.');
+  const points = track.points;
+  param.setValueAtTime(points[0].value, startTime);
+  param.setValueAtTime(points[0].value, startTime + points[0].at / 1000);
+  for (let i = 1; i < points.length; i += 1) {
+    const left = points[i - 1], right = points[i];
+    const end = startTime + right.at / 1000;
+    if (track.interpolation === 'step') param.setValueAtTime(right.value, end);
+    else if (track.interpolation === 'exponential' && left.value > 0 && right.value > 0) param.exponentialRampToValueAtTime(right.value, end);
+    else param.linearRampToValueAtTime(right.value, end);
+  }
+}
+
+function createAudioControls(context, plan, entries, disposeWith, startTime) {
+  const nodes = new Map(plan.nodes.map((node) => [node.path, node]));
+  const cache = new Map();
+  const building = new Set();
+  const constants = new Map();
+  const literal = (value) => ({ value, min: value, max: value });
+  const own = (node) => { disposeWith(() => node.disconnect()); return node; };
+  const scheduledSource = (value, min, max, schedule) => {
+    const source = own(context.createConstantSource());
+    source.offset.value = value;
+    disposeWith(() => { source.offset.cancelScheduledValues?.(context.currentTime); try { source.stop(); } catch { /* not started */ } });
+    schedule?.(source.offset);
+    source.start(startTime);
+    return { output: source, min, max };
+  };
+  const constant = (value, track) => {
+    if (track?.interpolation === 'smooth') return smoothSignal(track);
+    if (!track && constants.has(value)) return constants.get(value);
+    const values = track ? track.points.map((point) => point.value) : [value];
+    const signal = scheduledSource(value, Math.min(...values), Math.max(...values), track ? (param) => scheduleNativeAutomation(param, track, startTime) : undefined);
+    if (!track) constants.set(value, signal);
+    return signal;
+  };
+  const materialize = (signal) => signal.output ? signal : constant(signal.value);
+  const scale = (signal, factor) => {
+    if (signal.value !== undefined) return literal(signal.value * factor);
+    if (factor === 0) return literal(0);
+    if (factor === 1) return signal;
+    const gain = own(context.createGain());
+    gain.gain.value = factor;
+    signal.output.connect(gain);
+    return { output: gain, min: Math.min(signal.min * factor, signal.max * factor), max: Math.max(signal.min * factor, signal.max * factor) };
+  };
+  const add = (a, b) => {
+    if (a.value !== undefined && b.value !== undefined) return literal(a.value + b.value);
+    if (a.value === 0) return b;
+    if (b.value === 0) return a;
+    const sum = own(context.createGain());
+    materialize(a).output.connect(sum);
+    materialize(b).output.connect(sum);
+    return { output: sum, min: a.min + b.min, max: a.max + b.max };
+  };
+  const multiply = (a, b) => {
+    if (a.value !== undefined) return scale(b, a.value);
+    if (b.value !== undefined) return scale(a, b.value);
+    const gain = own(context.createGain());
+    gain.gain.value = 0;
+    a.output.connect(gain);
+    b.output.connect(gain.gain);
+    const bounds = [a.min * b.min, a.min * b.max, a.max * b.min, a.max * b.max];
+    return { output: gain, min: Math.min(...bounds), max: Math.max(...bounds) };
+  };
+  const smoothSignal = (track) => {
+    const points = track.points;
+    const spans = points.slice(1).map((point, i) => point.value - points[i].value);
+    const values = points.map((point) => point.value);
+    const low = Math.min(...values), high = Math.max(...values);
+    const progress = scheduledSource(0, 0, 1, (param) => {
+      param.setValueAtTime(0, startTime);
+      for (let i = 1; i < points.length; i++) {
+        param.setValueAtTime(0, startTime + points[i - 1].at / 1000);
+        param.linearRampToValueAtTime(1, startTime + points[i].at / 1000);
+      }
+    });
+    const steps = (initial, min, max, valueAt) => scheduledSource(initial, min, max, (param) => {
+      param.setValueAtTime(initial, startTime);
+      for (let i = 0; i < points.length - 1; i++) param.setValueAtTime(valueAt(i), startTime + points[i].at / 1000);
+    });
+    const origin = steps(points[0].value, low, high, (i) => points[i].value);
+    const excursion = steps(spans[0], Math.min(...spans), Math.max(...spans), (i) => spans[i]);
+    // a-rate polynomial 3t² - 2t³, not a sampled approximation of the curve.
+    const smooth = multiply(multiply(progress, progress), add(literal(3), scale(progress, -2)));
+    return { ...add(origin, multiply(excursion, smooth)), min: low, max: high };
+  };
+  const shape = (signal, fn, lower = signal.min, upper = signal.max, samples = 4097) => {
+    if (signal.value !== undefined || lower === upper) return literal(fn(signal.value ?? lower));
+    if (!Number.isFinite(lower) || !Number.isFinite(upper)) throw new RuntimeFault('ERR_OUT_OF_BOUNDS', 'Audio control bounds must be finite.');
+    const half = (upper - lower) / 2;
+    const normalized = add(scale(signal, 1 / half), literal(-lower / half - 1));
+    const shaper = own(context.createWaveShaper());
+    shaper.curve = Float32Array.from({ length: samples }, (_, i) => fn(lower + (upper - lower) * i / (samples - 1)));
+    const bounds = [...shaper.curve];
+    materialize(normalized).output.connect(shaper);
+    disposeWith(() => { shaper.curve = null; });
+    return { output: shaper, min: Math.min(...bounds), max: Math.max(...bounds) };
+  };
+  const bounded = (signal, min, max) => {
+    const lower = Math.max(signal.min, min), upper = Math.min(signal.max, max);
+    if (signal.max <= min) return literal(min);
+    if (signal.min >= max) return literal(max);
+    if (signal.min >= min && signal.max <= max) return signal;
+    // WaveShaper saturates outside [-1,1]; these three collinear points make
+    // the property safety clamp exact, including after an arbitrary route sum.
+    return shape(signal, (value) => value, lower, upper, 3);
+  };
+  const abs = (signal) => signal.min >= 0 ? signal : signal.max <= 0 ? scale(signal, -1) : shape(signal, Math.abs, -Math.max(-signal.min, signal.max), Math.max(-signal.min, signal.max), 3);
+  const minimum = (a, b) => scale(add(add(a, b), scale(abs(add(a, scale(b, -1))), -1)), 0.5);
+  const maximum = (a, b) => scale(add(add(a, b), abs(add(a, scale(b, -1)))), 0.5);
+
+  const expression = (spec, scope) => {
+    if (typeof spec === 'number') return literal(spec);
+    if (spec.ref) return property(scope, spec.ref.slice('inputs.'.length));
+    const args = spec.args.map((arg) => expression(arg, scope));
+    if (args.every((arg) => arg.value !== undefined)) return literal(new ValueResolver(() => {}).evaluate({ op: spec.op, args: args.map((arg) => arg.value) }, null));
+    const [a, b, c] = args;
+    switch (spec.op) {
+      case 'add': return add(a, b);
+      case 'subtract': return add(a, scale(b, -1));
+      case 'negate': return scale(a, -1);
+      case 'multiply': return multiply(a, b);
+      case 'divide': return multiply(a, shape(b, (value) => value === 0 ? 0 : 1 / value));
+      case 'abs': return abs(a);
+      case 'min': return minimum(a, b);
+      case 'max': return maximum(a, b);
+      case 'clamp': return minimum(maximum(a, b), c);
+      case 'lerp': return add(a, multiply(add(b, scale(a, -1)), c));
+      case 'round': case 'floor': case 'ceil': return shape(a, Math[spec.op]);
+      default: throw new RuntimeFault('ERR_INVALID_OPERATOR', `Unsupported audio expression '${spec.op}'.`);
+    }
+  };
+  const modulationSource = (route) => {
+    const node = nodes.get(route.from), output = entries.get(route.from)?.output;
+    if (!output) throw new RuntimeFault('ERR_INVALID_REFERENCE', `Missing modulation source '${route.from}'.`);
+    const v = node.values;
+    const range = node.type === 'constant' ? [v.value, v.value]
+      : node.type === 'sample-hold' ? [Math.min(0, v.min), Math.max(0, v.max)]
+      : node.type === 'lfo' ? [v.polarity === 'unipolar' ? 0 : -v.amplitude, v.amplitude] : [-1, 1];
+    return { output, min: range[0], max: range[1] };
+  };
+  const property = (path, field) => {
+    const key = `${path}::${field}`;
+    if (cache.has(key)) return cache.get(key);
+    if (building.has(key)) throw new RuntimeFault('ERR_CYCLIC_DEPENDENCY', `Audio control cycle at '${key}'.`);
+    building.add(key);
+    const node = nodes.get(path);
+    let signal = expression(node.expressions?.[field] ?? node.values[field], node.scope);
+    const track = plan.automation?.find((item) => item.target === path && item.property === field);
+    if (track) {
+      const curve = constant(track.points[0].value, track);
+      signal = track.mode === 'offset' ? add(signal, curve) : track.mode === 'scale' ? multiply(signal, curve) : curve;
+    }
+    for (const route of plan.routes) if (route.kind === 'modulation' && route.to === path && route.property === field) signal = add(signal, scale(modulationSource(route), route.depth));
+    const { min, max } = audioPropertyRange(node, field, plan.ceiling);
+    signal = bounded(signal, min, max);
+    cache.set(key, signal);
+    building.delete(key);
+    return signal;
+  };
+  const connect = (signal, param, factor = 1) => {
+    if (signal.value !== undefined) param.value = signal.value * factor;
+    else {
+      param.value = 0;
+      scale(signal, factor).output.connect(param);
+    }
+    disposeWith(() => param.cancelScheduledValues?.(context.currentTime));
+  };
+  return {
+    apply() {
+      for (const node of plan.nodes) {
+        if (node.implicit || node.type === 'component') continue;
+        const entry = entries.get(node.path);
+        for (const field of Object.keys(AUDIO_MODULATABLE[node.type] ?? {})) {
+          const signal = property(node.path, field);
+          if (field === 'fundamental') {
+            for (const band of entry.bands ?? []) if (band.ratio !== undefined) {
+              const frequency = bounded(scale(signal, band.ratio), 0.1, plan.ceiling);
+              connect(frequency, band.frequency);
+              connect(maximum(literal(1), scale(frequency, band.decay / 3000)), band.q);
+            }
+          } else connect(signal, entry.params[field], field === 'time' ? 0.001 : 1);
+        }
+      }
+    },
+    dispose() { cache.clear(); constants.clear(); nodes.clear(); building.clear(); }
+  };
+}
+
+/* src/runtime/validator.js */
+function issue(code, path, message, context = {}) {
+  return { code, path, message, ...context };
+}
+
+function isPlainObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function parseExhibit(source, filename = 'document.xzbt') {
+  if (typeof source !== 'string') {
+    return { valid: false, document: null, errors: [issue('ERR_SCHEMA_VALIDATION', '$', 'Exhibit source must be UTF-8 JSON text.')], filename };
+  }
+  const normalizedSource = source.charCodeAt(0) === 0xfeff ? source.slice(1) : source;
+  try {
+    return { valid: true, document: JSON.parse(normalizedSource), errors: [], filename, source: normalizedSource };
+  } catch (error) {
+    return { valid: false, document: null, errors: [issue('ERR_SCHEMA_VALIDATION', '$', `Malformed JSON: ${error.message}`)], filename, source: normalizedSource };
+  }
+}
+
+function validateExhibit(document, filename = 'document.xzbt') {
+  const errors = [];
+  const add = (code, path, message, context) => errors.push(issue(code, path, message, context));
+  if (!isPlainObject(document)) {
+    add('ERR_SCHEMA_VALIDATION', '$', 'Top-level document must be a JSON object.');
+    return { valid: false, errors, warnings: [], filename };
+  }
+
+  if (document.xzbt !== XZBT_FORMAT_VERSION) {
+    add('ERR_UNSUPPORTED_VERSION', '$.xzbt', `Unsupported XZBT format version: '${document.xzbt}'. Expected '${XZBT_FORMAT_VERSION}'.`, { property: 'xzbt' });
+  }
+  for (const field of Object.keys(document)) {
+    if (!ALLOWED_TOP_LEVEL_FIELDS.includes(field)) add('ERR_UNKNOWN_FIELD', `$.${field}`, `Unrecognized top-level field: '${field}'.`, { section: field });
+  }
+
+  if (!isPlainObject(document.meta)) {
+    add('ERR_SCHEMA_VALIDATION', '$.meta', 'Missing or invalid required object: meta.', { section: 'meta' });
+  } else {
+    for (const field of Object.keys(document.meta)) {
+      if (!ALLOWED_META_FIELDS.includes(field)) add('ERR_UNKNOWN_FIELD', `$.meta.${field}`, `Unrecognized metadata field: '${field}'.`, { section: 'meta', property: field });
+    }
+    const { id, name, version, author, description, license, tags } = document.meta;
+    if (typeof id !== 'string' || !ID_PATTERN.test(id) || id.length > 64) {
+      add('ERR_INVALID_ID', '$.meta.id', "Exhibit id must match ^[a-z][a-z0-9_-]*$ and contain at most 64 characters.", { section: 'meta', property: 'id' });
+    }
+    if (typeof name !== 'string' || name.trim().length === 0 || name.length > 128) {
+      add('ERR_SCHEMA_VALIDATION', '$.meta.name', 'Exhibit name must be a non-empty string of at most 128 characters.', { section: 'meta', property: 'name' });
+    }
+    if (version !== undefined && typeof version !== 'string') add('ERR_TYPE_MISMATCH', '$.meta.version', 'Exhibit version must be a string.', { section: 'meta', property: 'version' });
+    if (author !== undefined && (typeof author !== 'string' || author.length > 128)) add('ERR_TYPE_MISMATCH', '$.meta.author', 'Author must be a string of at most 128 characters.', { section: 'meta', property: 'author' });
+    if (description !== undefined && (typeof description !== 'string' || description.length > 1024)) add('ERR_TYPE_MISMATCH', '$.meta.description', 'Description must be a string of at most 1024 characters.', { section: 'meta', property: 'description' });
+    if (license !== undefined && typeof license !== 'string') add('ERR_TYPE_MISMATCH', '$.meta.license', 'License must be a string.', { section: 'meta', property: 'license' });
+    if (tags !== undefined && (!Array.isArray(tags) || tags.length > 16 || tags.some((tag) => typeof tag !== 'string' || tag.length > 32))) {
+      add('ERR_TYPE_MISMATCH', '$.meta.tags', 'Tags must contain at most 16 strings of at most 32 characters.', { section: 'meta', property: 'tags' });
+    }
+  }
+
+  if (document.runtime !== undefined) {
+    if (!isPlainObject(document.runtime)) {
+      add('ERR_SCHEMA_VALIDATION', '$.runtime', 'runtime must be an object.', { section: 'runtime' });
+    } else {
+      for (const field of Object.keys(document.runtime)) {
+        if (field !== 'seed') add('ERR_UNKNOWN_FIELD', `$.runtime.${field}`, `Unrecognized runtime field: '${field}'.`, { section: 'runtime', property: field });
+      }
+      const seed = document.runtime.seed;
+      if (seed !== undefined && seed !== 'random' && (!Number.isInteger(seed) || seed < 0 || seed >= UINT32_RANGE)) {
+        add('ERR_OUT_OF_BOUNDS', '$.runtime.seed', "Seed must be 'random' or an unsigned 32-bit integer.", { section: 'runtime', property: 'seed' });
+      }
+    }
+  }
+
+  validateDefinitions(document, errors);
+  validateBindings(document, errors);
+  validateAudioSubsystem(document, errors, { validateValueSpec, pushError });
+
+  return { valid: errors.length === 0, errors, warnings: [], filename };
+}
+
+const PARAMETER_FIELDS = new Set(['type', 'default', 'min', 'max', 'step', 'values', 'label', 'unit']);
+const STATE_FIELDS = new Set(['type', 'initial', 'min', 'max']);
+const BINDING_FIELDS = new Set(['source', 'target', 'scale', 'offset', 'clamp', 'smoothing', 'when']);
+const VALUE_OPERATORS = Object.freeze({ abs: 1, negate: 1, round: 1, floor: 1, ceil: 1, add: 2, subtract: 2, multiply: 2, divide: 2, min: 2, max: 2, clamp: 3, lerp: 3 });
+const COMPARISONS = new Set(['eq', 'ne', 'gt', 'gte', 'lt', 'lte']);
+
+function pushError(errors, code, path, message) { errors.push(issue(code, path, message)); }
+
+function validateDefinitions(document, errors) {
+  validateDefinitionMap(document.parameters, 'parameters', PARAMETER_TYPES, 'default', PARAMETER_FIELDS, errors);
+  validateDefinitionMap(document.state, 'state', STATE_TYPES, 'initial', STATE_FIELDS, errors);
+}
+
+function validateDefinitionMap(definitions, namespace, allowedTypes, valueField, allowedFields, errors) {
+  if (definitions === undefined) return;
+  if (!isPlainObject(definitions)) {
+    pushError(errors, 'ERR_SCHEMA_VALIDATION', `$.${namespace}`, `${namespace} must be an object.`);
+    return;
+  }
+  for (const [id, spec] of Object.entries(definitions)) {
+    const path = `$.${namespace}.${id}`;
+    if (!ID_PATTERN.test(id)) pushError(errors, 'ERR_INVALID_ID', path, `${namespace} ID '${id}' is invalid.`);
+    if (!isPlainObject(spec)) {
+      pushError(errors, 'ERR_SCHEMA_VALIDATION', path, `${namespace} definition must be an object.`);
+      continue;
+    }
+    for (const field of Object.keys(spec)) if (!allowedFields.has(field)) pushError(errors, 'ERR_UNKNOWN_FIELD', `${path}.${field}`, `Unrecognized ${namespace} field '${field}'.`);
+    if (!allowedTypes.includes(spec.type)) pushError(errors, 'ERR_TYPE_MISMATCH', `${path}.type`, `Unsupported ${namespace} type '${spec.type}'.`);
+    if (!Object.hasOwn(spec, valueField)) pushError(errors, 'ERR_SCHEMA_VALIDATION', `${path}.${valueField}`, `Missing required field '${valueField}'.`);
+    else if (!valueMatchesType(spec.type, spec[valueField], spec)) pushError(errors, 'ERR_TYPE_MISMATCH', `${path}.${valueField}`, `Value does not match declared type '${spec.type}'.`);
+    if (spec.min !== undefined && !Number.isFinite(spec.min)) pushError(errors, 'ERR_TYPE_MISMATCH', `${path}.min`, 'min must be a finite number.');
+    if (spec.max !== undefined && !Number.isFinite(spec.max)) pushError(errors, 'ERR_TYPE_MISMATCH', `${path}.max`, 'max must be a finite number.');
+    if (Number.isFinite(spec.min) && Number.isFinite(spec.max) && spec.min > spec.max) pushError(errors, 'ERR_OUT_OF_BOUNDS', `${path}.min`, 'min cannot exceed max.');
+    if (isNumericType(spec.type) && typeof spec[valueField] === 'number') {
+      if (spec.min !== undefined && spec[valueField] < spec.min) pushError(errors, 'ERR_OUT_OF_BOUNDS', `${path}.${valueField}`, `${valueField} is below min.`);
+      if (spec.max !== undefined && spec[valueField] > spec.max) pushError(errors, 'ERR_OUT_OF_BOUNDS', `${path}.${valueField}`, `${valueField} is above max.`);
+    }
+    if (namespace === 'parameters' && spec.step !== undefined && (!Number.isFinite(spec.step) || spec.step <= 0)) pushError(errors, 'ERR_OUT_OF_BOUNDS', `${path}.step`, 'step must be a finite positive number.');
+    if (spec.type === 'enum') {
+      if (!Array.isArray(spec.values) || spec.values.length === 0 || spec.values.some((value) => typeof value !== 'string')) pushError(errors, 'ERR_SCHEMA_VALIDATION', `${path}.values`, 'Enum values must be a non-empty string array.');
+      else if (!spec.values.includes(spec[valueField])) pushError(errors, 'ERR_OUT_OF_BOUNDS', `${path}.${valueField}`, 'Enum default is not declared in values.');
+    }
+  }
+}
+
+function referenceType(document, path, scope = null) {
+  if (typeof path !== 'string') return null;
+  const parts = path.split('.');
+  if (parts[0] === 'inputs') return parts.length === 2 && scope?.componentParameters?.has(parts[1]) ? 'number' : null;
+  if (parts.length === 2 && parts[0] === 'parameters') return document.parameters?.[parts[1]]?.type ?? null;
+  if (parts.length === 2 && parts[0] === 'state') return document.state?.[parts[1]]?.type ?? null;
+  if (parts[0] === 'signals') return RUNTIME_SIGNAL_TYPES[path] ?? null;
+  if (parts.length === 2 && parts[0] === 'modulators') return document.modulators?.[parts[1]] ? 'number' : null;
+  if (parts.length === 4 && parts[0] === 'audio' && parts[1] === 'buses' && parts[3] === 'gain') return document.audio?.buses?.[parts[2]] ? 'number' : null;
+  return null;
+}
+
+function validateReference(document, path, location, errors, scope = null) {
+  if (typeof path !== 'string' || !/^[a-z][a-z0-9_-]*(\.[a-z][a-z0-9_-]*)+$/.test(path) || !referenceType(document, path, scope)) pushError(errors, 'ERR_INVALID_REFERENCE', location, `Reference '${path}' does not resolve.`);
+}
+
+function validateValueSpec(document, spec, path, errors, scope = null) {
+  if (typeof spec === 'number') {
+    if (!Number.isFinite(spec)) pushError(errors, 'ERR_TYPE_MISMATCH', path, 'Number must be finite.');
+    return;
+  }
+  if (typeof spec === 'string' || typeof spec === 'boolean') return;
+  if (!isPlainObject(spec)) {
+    pushError(errors, 'ERR_SCHEMA_VALIDATION', path, 'Invalid ValueSpec.');
+    return;
+  }
+  const forms = ['ref', 'random', 'choose', 'op'].filter((field) => Object.hasOwn(spec, field));
+  if (forms.length !== 1) {
+    pushError(errors, 'ERR_SCHEMA_VALIDATION', path, 'ValueSpec must use exactly one recognized form.');
+    return;
+  }
+  const form = forms[0];
+  for (const field of Object.keys(spec)) if (field !== form && !(form === 'op' && field === 'args')) pushError(errors, 'ERR_UNKNOWN_FIELD', `${path}.${field}`, `Unrecognized ValueSpec field '${field}'.`);
+  if (form === 'ref') return validateReference(document, spec.ref, `${path}.ref`, errors, scope);
+  if (form === 'random') {
+    const random = spec.random;
+    if (!isPlainObject(random)) return pushError(errors, 'ERR_SCHEMA_VALIDATION', `${path}.random`, 'random must be an object.');
+    for (const field of Object.keys(random)) if (!['min', 'max', 'integer', 'distribution'].includes(field)) pushError(errors, 'ERR_UNKNOWN_FIELD', `${path}.random.${field}`, `Unknown random field '${field}'.`);
+    if (!Number.isFinite(random.min) || !Number.isFinite(random.max)) pushError(errors, 'ERR_TYPE_MISMATCH', `${path}.random`, 'random min and max must be finite numbers.');
+    else if (random.min > random.max) pushError(errors, 'ERR_OUT_OF_BOUNDS', `${path}.random`, 'random min cannot exceed max.');
+    if (random.integer !== undefined && typeof random.integer !== 'boolean') pushError(errors, 'ERR_TYPE_MISMATCH', `${path}.random.integer`, 'integer must be boolean.');
+    if (random.distribution !== undefined && !['uniform', 'gaussian'].includes(random.distribution)) pushError(errors, 'ERR_SCHEMA_VALIDATION', `${path}.random.distribution`, 'Unsupported distribution.');
+    return;
+  }
+  if (form === 'choose') {
+    if (!Array.isArray(spec.choose) || spec.choose.length === 0) return pushError(errors, 'ERR_SCHEMA_VALIDATION', `${path}.choose`, 'choose must be a non-empty array.');
+    spec.choose.forEach((option, index) => {
+      if (!isPlainObject(option) || !Object.hasOwn(option, 'value') || !Number.isFinite(option.weight) || option.weight <= 0) pushError(errors, 'ERR_SCHEMA_VALIDATION', `${path}.choose[${index}]`, 'Choice requires value and a finite positive weight.');
+      else validateValueSpec(document, option.value, `${path}.choose[${index}].value`, errors, scope);
+    });
+    return;
+  }
+  if (!Object.hasOwn(VALUE_OPERATORS, spec.op)) pushError(errors, 'ERR_INVALID_OPERATOR', `${path}.op`, `Unknown operator '${spec.op}'.`);
+  if (!Array.isArray(spec.args)) pushError(errors, 'ERR_SCHEMA_VALIDATION', `${path}.args`, 'Operator args must be an array.');
+  else {
+    if (spec.args.length !== VALUE_OPERATORS[spec.op]) pushError(errors, 'ERR_INVALID_ARITY', `${path}.args`, `Operator '${spec.op}' has invalid arity.`);
+    spec.args.forEach((argument, index) => validateValueSpec(document, argument, `${path}.args[${index}]`, errors, scope));
+  }
+}
+
+function validateCondition(document, condition, path, errors) {
+  if (!isPlainObject(condition)) return pushError(errors, 'ERR_SCHEMA_VALIDATION', path, 'ConditionSpec must be an object.');
+  if (Object.hasOwn(condition, 'and') || Object.hasOwn(condition, 'or')) {
+    const key = Object.hasOwn(condition, 'and') ? 'and' : 'or';
+    if (Object.keys(condition).length !== 1) pushError(errors, 'ERR_UNKNOWN_FIELD', path, 'Logical condition contains extra fields.');
+    if (!Array.isArray(condition[key]) || condition[key].length === 0) pushError(errors, 'ERR_SCHEMA_VALIDATION', `${path}.${key}`, `${key} requires a non-empty array.`);
+    else condition[key].forEach((child, index) => validateCondition(document, child, `${path}.${key}[${index}]`, errors));
+    return;
+  }
+  if (Object.hasOwn(condition, 'not')) {
+    if (Object.keys(condition).length !== 1) pushError(errors, 'ERR_UNKNOWN_FIELD', path, 'not condition contains extra fields.');
+    return validateCondition(document, condition.not, `${path}.not`, errors);
+  }
+  if (!COMPARISONS.has(condition.op)) pushError(errors, 'ERR_INVALID_OPERATOR', `${path}.op`, `Unknown comparison '${condition.op}'.`);
+  if (!Object.hasOwn(condition, 'left') || !Object.hasOwn(condition, 'right')) pushError(errors, 'ERR_SCHEMA_VALIDATION', path, 'Comparison requires left and right.');
+  else {
+    validateValueSpec(document, condition.left, `${path}.left`, errors);
+    validateValueSpec(document, condition.right, `${path}.right`, errors);
+  }
+}
+
+function validateBindings(document, errors) {
+  if (document.bindings === undefined) return;
+  if (!Array.isArray(document.bindings)) return pushError(errors, 'ERR_SCHEMA_VALIDATION', '$.bindings', 'bindings must be an array.');
+  const writers = new Map();
+  const dependencies = new Map();
+  document.bindings.forEach((binding, index) => {
+    const path = `$.bindings[${index}]`;
+    if (!isPlainObject(binding)) return pushError(errors, 'ERR_SCHEMA_VALIDATION', path, 'Binding must be an object.');
+    for (const field of Object.keys(binding)) if (!BINDING_FIELDS.has(field)) pushError(errors, 'ERR_UNKNOWN_FIELD', `${path}.${field}`, `Unknown binding field '${field}'.`);
+    validateReference(document, binding.source, `${path}.source`, errors);
+    validateReference(document, binding.target, `${path}.target`, errors);
+    if (!(typeof binding.target === 'string' && (/^(parameters|state)\.[a-z][a-z0-9_-]*$/.test(binding.target) || /^audio\.buses\.[a-z][a-z0-9_-]*\.gain$/.test(binding.target)))) pushError(errors, 'ERR_UNSUPPORTED_TARGET', `${path}.target`, `Binding target '${binding.target}' is not exposed.`);
+    for (const field of ['scale', 'offset']) if (binding[field] !== undefined && !Number.isFinite(binding[field])) pushError(errors, 'ERR_TYPE_MISMATCH', `${path}.${field}`, `${field} must be finite.`);
+    if (binding.clamp !== undefined && (!Array.isArray(binding.clamp) || binding.clamp.length !== 2 || binding.clamp.some((value) => !Number.isFinite(value)))) pushError(errors, 'ERR_SCHEMA_VALIDATION', `${path}.clamp`, 'clamp must contain two finite numbers.');
+    else if (binding.clamp?.[0] > binding.clamp?.[1]) pushError(errors, 'ERR_OUT_OF_BOUNDS', `${path}.clamp`, 'clamp minimum cannot exceed maximum.');
+    if (binding.smoothing !== undefined && (typeof binding.smoothing !== 'string' || !DURATION_PATTERN.test(binding.smoothing))) pushError(errors, 'ERR_INVALID_DURATION', `${path}.smoothing`, 'Invalid smoothing duration.');
+    if (binding.when !== undefined) validateCondition(document, binding.when, `${path}.when`, errors);
+    const sourceType = referenceType(document, binding.source);
+    const targetType = referenceType(document, binding.target);
+    if (sourceType && targetType) {
+      const transformed = binding.scale !== undefined || binding.offset !== undefined || binding.clamp !== undefined || (binding.smoothing !== undefined && binding.smoothing !== '0ms');
+      if (transformed && (!isNumericType(sourceType) || !isNumericType(targetType))) pushError(errors, 'ERR_TYPE_MISMATCH', path, 'Binding transforms require numeric endpoints.');
+      else if (!transformed && sourceType !== targetType && !(isNumericType(sourceType) && isNumericType(targetType))) pushError(errors, 'ERR_TYPE_MISMATCH', path, 'Binding endpoint types do not match.');
+    }
+    if (typeof binding.target === 'string') {
+      if (writers.has(binding.target)) pushError(errors, 'ERR_CONFLICTING_BINDING', `${path}.target`, `Target already written by binding ${writers.get(binding.target)}.`);
+      else writers.set(binding.target, index);
+      if (!dependencies.has(binding.target)) dependencies.set(binding.target, []);
+      if (typeof binding.source === 'string') dependencies.get(binding.target).push(binding.source);
+    }
+  });
+  const visiting = new Set();
+  const visited = new Set();
+  const visit = (node, trail) => {
+    if (visiting.has(node)) return pushError(errors, 'ERR_CYCLIC_DEPENDENCY', '$.bindings', `Binding cycle: ${[...trail, node].join(' -> ')}.`);
+    if (visited.has(node)) return;
+    visiting.add(node);
+    for (const source of dependencies.get(node) ?? []) visit(source, [...trail, node]);
+    visiting.delete(node);
+    visited.add(node);
+  };
+  for (const target of dependencies.keys()) visit(target, []);
+}
+
+function parseAndValidateExhibit(source, filename) {
+  const parsed = parseExhibit(source, filename);
+  if (!parsed.valid) return parsed;
+  return { ...validateExhibit(parsed.document, filename), document: parsed.document, source: parsed.source };
+}
+
+/* src/runtime/persistence.js */
+function requestResult(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error('IndexedDB request failed.'));
+  });
+}
+
+function transactionDone(transaction) {
+  return new Promise((resolve, reject) => {
+    transaction.oncomplete = () => resolve();
+    transaction.onabort = () => reject(transaction.error ?? new Error('IndexedDB transaction aborted.'));
+    transaction.onerror = () => reject(transaction.error ?? new Error('IndexedDB transaction failed.'));
+  });
+}
+
+class PersistenceManager {
+  constructor({ indexedDBProvider = globalThis.indexedDB, diagnostics } = {}) {
+    this.indexedDB = indexedDBProvider;
+    this.diagnostics = diagnostics;
+    this.database = null;
+    this.available = false;
+  }
+
+  async open() {
+    if (!this.indexedDB) return this.failOpen('IndexedDB is unavailable in this browser context.');
+    try {
+      const request = this.indexedDB.open(DATABASE.name, DATABASE.version);
+      request.onupgradeneeded = () => {
+        const database = request.result;
+        if (!database.objectStoreNames.contains(DATABASE.exhibits)) database.createObjectStore(DATABASE.exhibits, { keyPath: 'id' });
+        if (!database.objectStoreNames.contains(DATABASE.preferences)) database.createObjectStore(DATABASE.preferences, { keyPath: 'key' });
+      };
+      this.database = await requestResult(request);
+      this.database.onversionchange = () => {
+        this.database.close();
+        this.database = null;
+        this.available = false;
+      };
+      this.available = true;
+      this.diagnostics?.info('INFO_STORAGE_READY', 'Local exhibit storage is ready.', { section: 'persistence' });
+      return true;
+    } catch (error) {
+      return this.failOpen(error.message);
+    }
+  }
+
+  failOpen(reason) {
+    this.available = false;
+    this.diagnostics?.warn('WARN_STORAGE_UNAVAILABLE', `Session-only mode: ${reason} Imported exhibits must be imported again on a later launch.`, { section: 'persistence' });
+    return false;
+  }
+
+  async loadSnapshot() {
+    if (!this.available) return { exhibits: [], preferences: {} };
+    const transaction = this.database.transaction([DATABASE.exhibits, DATABASE.preferences], 'readonly');
+    const exhibitsRequest = transaction.objectStore(DATABASE.exhibits).getAll();
+    const preferencesRequest = transaction.objectStore(DATABASE.preferences).getAll();
+    const [exhibits, rows] = await Promise.all([requestResult(exhibitsRequest), requestResult(preferencesRequest), transactionDone(transaction)]);
+    return { exhibits, preferences: Object.fromEntries(rows.map(({ key, value }) => [key, value])) };
+  }
+
+  async saveExhibit(record) {
+    if (!this.available) return false;
+    const transaction = this.database.transaction(DATABASE.exhibits, 'readwrite');
+    transaction.objectStore(DATABASE.exhibits).put(record);
+    await transactionDone(transaction);
+    return true;
+  }
+
+  async savePreference(key, value) {
+    if (!this.available) return false;
+    const transaction = this.database.transaction(DATABASE.preferences, 'readwrite');
+    transaction.objectStore(DATABASE.preferences).put({ key, value });
+    await transactionDone(transaction);
+    return true;
+  }
+}
+
+/* src/runtime/library.js */
+function bytesToHex(bytes) {
+  return [...bytes].map((byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+
+async function sha256(source, cryptoProvider = globalThis.crypto) {
+  if (!cryptoProvider?.subtle) throw new Error('Web Crypto SHA-256 is unavailable.');
+  const digest = await cryptoProvider.subtle.digest('SHA-256', new TextEncoder().encode(source));
+  return bytesToHex(new Uint8Array(digest));
+}
+
+class LibraryManager {
+  constructor({ persistence, diagnostics, cryptoProvider = globalThis.crypto } = {}) {
+    this.persistence = persistence;
+    this.diagnostics = diagnostics;
+    this.crypto = cryptoProvider;
+    this.records = new Map();
+  }
+
+  list() {
+    return [...this.records.values()].sort((left, right) => left.document.meta.name.localeCompare(right.document.meta.name));
+  }
+
+  get(id) { return this.records.get(id) ?? null; }
+
+  restore(records) {
+    for (const record of records) {
+      const checked = validateStoredRecord(record);
+      if (!checked.valid) {
+        this.diagnostics?.error('ERR_CACHE_INVALID', `Cached exhibit was ignored: ${checked.message}`, { exhibitId: record?.id ?? null, section: 'persistence' });
+        continue;
+      }
+      this.records.set(record.id, record);
+    }
+    if (this.records.size > 0) this.diagnostics?.info('INFO_LIBRARY_RESTORED', `Restored ${this.records.size} cached exhibit${this.records.size === 1 ? '' : 's'}.`, { section: 'library' });
+  }
+
+  async importSource(source, filename, { confirmReplacement = async () => false } = {}) {
+    const result = parseAndValidateExhibit(source, filename);
+    if (!result.valid) {
+      for (const error of result.errors) this.diagnostics?.error(error.code, error.message, { exhibitId: result.document?.meta?.id ?? null, section: error.section ?? 'loader', objectId: error.objectId, property: error.property });
+      return { status: 'invalid', ...result };
+    }
+
+    let digest;
+    try {
+      digest = await sha256(result.source, this.crypto);
+    } catch (error) {
+      this.diagnostics?.error('ERR_IMPORT_DIGEST', error.message, { exhibitId: result.document.meta.id, section: 'loader' });
+      return { status: 'invalid', valid: false, errors: [{ code: 'ERR_IMPORT_DIGEST', path: '$', message: error.message }] };
+    }
+
+    const id = result.document.meta.id;
+    const existing = this.records.get(id);
+    if (existing?.digest === digest) {
+      this.diagnostics?.info('INFO_IMPORT_IDENTICAL', `${result.document.meta.name} is already in the library; no changes were made.`, { exhibitId: id, section: 'library' });
+      return { status: 'identical', record: existing };
+    }
+    if (existing && !(await confirmReplacement(existing, result.document))) {
+      this.diagnostics?.info('INFO_IMPORT_REPLACEMENT_CANCELLED', `Replacement of ${existing.document.meta.name} was cancelled.`, { exhibitId: id, section: 'library' });
+      return { status: 'cancelled', record: existing };
+    }
+
+    const record = Object.freeze({
+      id,
+      digest,
+      source: result.source,
+      document: result.document,
+      sourceInfo: { kind: 'file', name: filename },
+      importedAt: new Date().toISOString()
+    });
+    this.records.set(id, record);
+    try {
+      await this.persistence?.saveExhibit(record);
+    } catch (error) {
+      this.diagnostics?.warn('WARN_STORAGE_WRITE_FAILED', `The exhibit is available for this session but could not be cached: ${error.message}`, { exhibitId: id, section: 'persistence' });
+    }
+    this.diagnostics?.info(existing ? 'INFO_EXHIBIT_REPLACED' : 'INFO_EXHIBIT_IMPORTED', `${result.document.meta.name} ${existing ? 'replaced' : 'imported'}.`, { exhibitId: id, section: 'library' });
+    return { status: existing ? 'replaced' : 'imported', record };
+  }
+}
+
+function validateStoredRecord(record) {
+  if (!record || typeof record.source !== 'string' || typeof record.digest !== 'string' || record.id !== record.document?.meta?.id) {
+    return { valid: false, message: 'record shape is invalid.' };
+  }
+  const result = parseAndValidateExhibit(record.source, record.sourceInfo?.name ?? 'cached.xzbt');
+  if (!result.valid || result.document.meta.id !== record.id) return { valid: false, message: 'definition no longer validates.' };
+  return { valid: true };
+}
+
+/* src/runtime/resolution.js */
+const STEP_SECONDS = 1 / 60;
+
+class SignalProvider {
+  constructor() {
+    this.values = new Map([
+      ['signals.time.elapsed', 0], ['signals.time.delta', 0],
+      ['signals.audio.low', 0], ['signals.audio.mid', 0], ['signals.audio.high', 0], ['signals.audio.energy', 0],
+      ['signals.pointer.x', 0], ['signals.pointer.y', 0],
+      ['signals.viewport.width', globalThis.innerWidth ?? 0], ['signals.viewport.height', globalThis.innerHeight ?? 0],
+      ['signals.scenario.active', false]
+    ]);
+  }
+
+  get(path) {
+    if (!this.values.has(path)) throw new RuntimeFault('ERR_INVALID_REFERENCE', `Unknown runtime signal '${path}'.`, path);
+    return this.values.get(path);
+  }
+
+  set(path, value) {
+    const type = RUNTIME_SIGNAL_TYPES[path];
+    if (!type) throw new RuntimeFault('ERR_INVALID_REFERENCE', `Unknown runtime signal '${path}'.`, path);
+    if ((type === 'number' && (!Number.isFinite(value))) || (type === 'boolean' && typeof value !== 'boolean')) throw new RuntimeFault('ERR_TYPE_MISMATCH', `Signal '${path}' requires ${type}.`, path);
+    this.values.set(path, value);
+  }
+
+  updateTime(elapsedSeconds, deltaSeconds) {
+    this.values.set('signals.time.elapsed', elapsedSeconds);
+    this.values.set('signals.time.delta', deltaSeconds);
+  }
+}
+
+class OverrideStack {
+  constructor(engine) {
+    this.engine = engine;
+    this.instances = new Map();
+    this.activationSequence = 0;
+  }
+
+  add(action, sampledValue, { owner = 'performance', inheritedPriority = 0 } = {}) {
+    const target = this.engine.target(action.target);
+    if (!target) throw new RuntimeFault('ERR_UNSUPPORTED_TARGET', `Override target '${action.target}' is not exposed.`, action.target);
+    const normalized = normalizeForSpec(target.spec, sampledValue);
+    if (action.scope !== 'scenario' && action.scope !== 'duration') throw new RuntimeFault('ERR_SCHEMA_VALIDATION', "Override scope must be 'scenario' or 'duration'.");
+    const durationMs = action.scope === 'duration' ? parseDuration(action.duration, '$.duration') : null;
+    if (action.scope === 'duration' && durationMs <= 0) throw new RuntimeFault('ERR_INVALID_DURATION', 'Duration overrides require duration greater than 0ms.');
+    if (action.scope === 'scenario' && action.duration !== undefined) throw new RuntimeFault('ERR_SCHEMA_VALIDATION', 'Scenario-scoped overrides cannot declare duration.');
+    const priority = action.priority ?? inheritedPriority;
+    if (!Number.isInteger(priority) || priority < -1000 || priority > 1000) throw new RuntimeFault('ERR_OUT_OF_BOUNDS', 'Override priority must be an integer from -1000 through 1000.');
+    const transition = action.transition ?? {};
+    const attackMs = parseDuration(transition.in ?? '0ms', '$.transition.in');
+    const releaseMs = parseDuration(transition.out ?? '0ms', '$.transition.out');
+    const easing = transition.easing ?? 'linear';
+    easingValue(easing, 0);
+    if (!isNumericType(target.spec.type) && (attackMs > 0 || releaseMs > 0)) throw new RuntimeFault('ERR_INVALID_TRANSITION', 'Non-numeric overrides require zero-duration transitions.');
+    const sequence = ++this.activationSequence;
+    const instance = {
+      id: `instances.override-${sequence}`,
+      authorId: action.id ?? null,
+      target: action.target,
+      owner,
+      scope: action.scope,
+      priority,
+      activationSequence: sequence,
+      sampledValue: normalized,
+      attackOrigin: this.engine.preModulationValue(action.target),
+      attackMs,
+      releaseMs,
+      easing,
+      activatedAt: this.engine.logicalMilliseconds,
+      expiresAt: durationMs === null ? null : this.engine.logicalMilliseconds + durationMs,
+      phase: 'active',
+      releaseStartedAt: null,
+      releaseStartValue: null,
+      lastValue: null
+    };
+    this.instances.set(instance.id, instance);
+    this.engine.invalidate();
+    return instance.id;
+  }
+
+  beginRelease(id) {
+    const instance = this.instances.get(id);
+    if (!instance || instance.phase === 'releasing') return false;
+    if (instance.releaseMs === 0) {
+      this.instances.delete(id);
+    } else {
+      instance.phase = 'releasing';
+      instance.releaseStartedAt = this.engine.logicalMilliseconds;
+      instance.releaseStartValue = instance.lastValue ?? instance.sampledValue;
+    }
+    this.engine.invalidate();
+    return true;
+  }
+
+  releaseOwner(owner) {
+    for (const instance of [...this.instances.values()]) if (instance.owner === owner && instance.scope === 'scenario') this.beginRelease(instance.id);
+  }
+
+  advance() {
+    const now = this.engine.logicalMilliseconds;
+    for (const instance of [...this.instances.values()]) {
+      if (instance.phase === 'active' && instance.expiresAt !== null && now >= instance.expiresAt) this.beginRelease(instance.id);
+      if (instance.phase === 'releasing' && now - instance.releaseStartedAt >= instance.releaseMs) this.instances.delete(instance.id);
+    }
+  }
+
+  forTarget(path) { return [...this.instances.values()].filter((instance) => instance.target === path); }
+  has(path) { return this.forTarget(path).length > 0; }
+
+  select(path) {
+    return this.forTarget(path).reduce((winner, candidate) => {
+      if (!winner || candidate.priority > winner.priority || (candidate.priority === winner.priority && candidate.activationSequence > winner.activationSequence)) return candidate;
+      return winner;
+    }, null);
+  }
+
+  value(instance, lowerValue) {
+    const now = this.engine.logicalMilliseconds;
+    let value = instance.sampledValue;
+    if (instance.phase === 'releasing') {
+      const progress = (now - instance.releaseStartedAt) / instance.releaseMs;
+      value = lerp(lowerValue, instance.releaseStartValue, 1 - easingValue(instance.easing, progress));
+    } else if (instance.attackMs > 0) {
+      const progress = (now - instance.activatedAt) / instance.attackMs;
+      value = lerp(instance.attackOrigin, instance.sampledValue, easingValue(instance.easing, progress));
+    }
+    instance.lastValue = value;
+    return value;
+  }
+
+  clear() { this.instances.clear(); this.engine.invalidate(); }
+}
+
+class ResolutionEngine {
+  constructor(document, rootRng, { diagnostics, initialParameters = {}, onParameterChange = () => {} } = {}) {
+    this.document = document;
+    this.rng = rootRng;
+    this.diagnostics = diagnostics;
+    this.onParameterChange = onParameterChange;
+    this.parameters = new Map();
+    this.state = new Map();
+    this.busValues = new Map();
+    this.automation = new Map();
+    this.modulation = new Map();
+    this.preModulation = new Map();
+    this.listeners = new Set();
+    this.signals = new SignalProvider();
+    this.bindings = (document.bindings ?? []).map((binding, index) => ({ definition: binding, index, smoother: undefined, enabled: false, lastTick: -1 }));
+    this.transitions = new Map();
+    this.resolved = new Map();
+    this.resolving = new Set();
+    this.tickIndex = 0;
+    this.logicalMilliseconds = 0;
+    this.valueResolver = new ValueResolver((path) => this.get(path));
+    this.conditions = new ConditionEvaluator(this.valueResolver);
+    this.overrides = new OverrideStack(this);
+    for (const [id, spec] of Object.entries(document.parameters ?? {})) {
+      const candidate = Object.hasOwn(initialParameters, id) ? initialParameters[id] : spec.default;
+      this.parameters.set(id, valueMatchesType(spec.type, candidate, spec) ? normalizeForSpec(spec, candidate, { clampNumeric: true }) : spec.default);
+    }
+    for (const [id, spec] of Object.entries(document.state ?? {})) this.state.set(id, spec.initial);
+    // Bus ValueSpecs are sampled once, lazily, so references may resolve through
+    // the same dependency graph as bindings (and cycles are diagnosed there).
+    this.resolveAll();
+  }
+
+  target(path) {
+    const parts = path.split('.');
+    if (parts.length === 4 && parts[0] === 'audio' && parts[1] === 'buses' && parts[3] === 'gain' && this.document.audio?.buses?.[parts[2]]) {
+      return { namespace: 'buses', id: parts[2], spec: { type: 'number', min: 0, max: 4 } };
+    }
+    const [namespace, id, extra] = path.split('.');
+    if (extra !== undefined) return null;
+    if (namespace === 'parameters' && this.document.parameters?.[id]) return { namespace, id, spec: this.document.parameters[id] };
+    if (namespace === 'state' && this.document.state?.[id]) return { namespace, id, spec: this.document.state[id] };
+    return null;
+  }
+
+  base(path) {
+    const target = this.target(path);
+    if (!target) throw new RuntimeFault('ERR_INVALID_REFERENCE', `Unknown value reference '${path}'.`, path);
+    if (target.namespace === 'buses') {
+      if (!this.busValues.has(target.id)) this.busValues.set(target.id, this.valueResolver.evaluate(this.document.audio.buses[target.id].gain ?? 1, this.rng.stream('sound', `bus:${target.id}`), path));
+      return this.busValues.get(target.id);
+    }
+    return target.namespace === 'parameters' ? this.parameters.get(target.id) : this.state.get(target.id);
+  }
+
+  get(path) {
+    if (path.startsWith('signals.')) return this.signals.get(path);
+    if (this.resolved.has(path)) return this.resolved.get(path);
+    return this.resolveTarget(path);
+  }
+
+  resolveAll() {
+    this.resolved.clear();
+    for (const id of Object.keys(this.document.parameters ?? {})) this.resolveTarget(`parameters.${id}`);
+    for (const id of Object.keys(this.document.state ?? {})) this.resolveTarget(`state.${id}`);
+    for (const id of Object.keys(this.document.audio?.buses ?? {})) this.resolveTarget(`audio.buses.${id}.gain`);
+    for (const listener of this.listeners) listener(this);
+    return this.snapshot();
+  }
+
+  resolveTarget(path) {
+    if (this.resolved.has(path)) return this.resolved.get(path);
+    const target = this.target(path);
+    if (!target) throw new RuntimeFault('ERR_INVALID_REFERENCE', `Unknown or unsupported reference '${path}'.`, path);
+    if (this.resolving.has(path)) throw new RuntimeFault('ERR_CYCLIC_DEPENDENCY', `Resolution cycle reached '${path}'.`, path);
+    this.resolving.add(path);
+    try {
+      let lower = this.base(path);
+      const binding = this.bindings.find((item) => item.definition.target === path);
+      const winner = this.overrides.select(path);
+      let value;
+      if (isNumericType(target.spec.type)) {
+        const track = target.namespace === 'buses' ? this.automation.get(path) : null;
+        value = resolveNumericStages(lower, {
+          binding: binding ? (base) => this.bindingValue(binding, target, base) : undefined,
+          automation: track ? (base) => applyAutomationMode(base, automationValueAt(track, this.logicalMilliseconds - track.startedAt), track.mode) : undefined,
+          override: (currentLower) => {
+            const preModulation = winner ? this.overrides.value(winner, currentLower) : currentLower;
+            this.preModulation.set(path, preModulation);
+            return preModulation;
+          },
+          modulation: target.namespace === 'buses' ? [...(this.modulation.get(path)?.values() ?? [])].reduce((sum, contribution) => sum + contribution, 0) : 0,
+          min: target.spec.min, max: target.spec.max,
+          round: target.spec.type === 'integer' ? roundHalfAwayFromZero : undefined
+        });
+      } else {
+        if (binding) lower = this.bindingValue(binding, target, lower);
+        value = winner ? this.overrides.value(winner, lower) : lower;
+        this.preModulation.set(path, value);
+      }
+      this.resolved.set(path, value);
+      return value;
+    } finally {
+      this.resolving.delete(path);
+    }
+  }
+
+  bindingValue(binding, target, baseValue) {
+    const definition = binding.definition;
+    const conditionStream = this.rng.stream('scenario', `binding-${binding.index}:condition`);
+    const enabled = definition.when === undefined || this.conditions.evaluate(definition.when, conditionStream, `$.bindings[${binding.index}].when`);
+    if (!enabled) {
+      binding.enabled = false;
+      binding.smoother = undefined;
+      return baseValue;
+    }
+    const source = this.get(definition.source);
+    const numeric = typeof source === 'number' && isNumericType(target.spec.type);
+    let value = source;
+    if (numeric) {
+      value = (source * (definition.scale ?? 1)) + (definition.offset ?? 0);
+      if (definition.clamp) value = clamp(value, definition.clamp[0], definition.clamp[1]);
+      const tau = parseDuration(definition.smoothing ?? '0ms') / 1000;
+      if (tau === 0 || !binding.enabled || binding.smoother === undefined) {
+        binding.smoother = value;
+        binding.lastTick = this.tickIndex;
+      } else if (binding.lastTick !== this.tickIndex) {
+        binding.smoother += (1 - Math.exp(-STEP_SECONDS / tau)) * (value - binding.smoother);
+        binding.lastTick = this.tickIndex;
+      }
+      value = binding.smoother;
+    }
+    binding.enabled = true;
+    if (numeric) return value;
+    return normalizeForSpec(target.spec, value, { clampNumeric: true });
+  }
+
+  preModulationValue(path) { this.get(path); return this.preModulation.get(path); }
+
+  requireAudioStage(path) {
+    if (this.target(path)?.namespace !== 'buses') throw new RuntimeFault('ERR_UNSUPPORTED_TARGET', `Automation/modulation is not exposed for '${path}'.`, path);
+  }
+
+  // Internal engine registration surface. The graph-only authoring syntax does
+  // not introduce new bus document fields, or external node targets.
+  addAutomation(path, definition, { startedAt = this.logicalMilliseconds, stream = this.rng.stream('sound', `bus:${path}:automation`) } = {}) {
+    this.requireAudioStage(path);
+    if (!Number.isFinite(startedAt)) throw new RuntimeFault('ERR_TYPE_MISMATCH', 'Automation start time must be finite.', path);
+    if (this.automation.has(path)) throw new RuntimeFault('ERR_AUTOMATION_CONFLICT', `More than one track controls '${path}'.`, path);
+    const track = sampleAutomationTrack({ ...definition, target: path }, (value, location) => this.evaluateValue(value, stream, location), (warning) => this.diagnostics?.warn(warning.code, warning.message, { path: warning.path, section: 'audio' }));
+    const registration = { ...track, startedAt };
+    this.automation.set(path, registration);
+    this.invalidate();
+    this.resolveAll();
+    return () => {
+      if (this.automation.get(path) !== registration) return;
+      this.automation.delete(path); this.invalidate(); this.resolveAll();
+    };
+  }
+
+  setModulation(path, id, value) {
+    this.requireAudioStage(path);
+    if (!Number.isFinite(value)) throw new RuntimeFault('ERR_TYPE_MISMATCH', 'Modulation contribution must be finite.', path);
+    if (!this.modulation.has(path)) this.modulation.set(path, new Map());
+    this.modulation.get(path).set(id, value);
+    this.invalidate();
+    return this.resolveAll();
+  }
+
+  removeModulation(path, id) {
+    this.requireAudioStage(path);
+    this.modulation.get(path)?.delete(id);
+    this.invalidate();
+    return this.resolveAll();
+  }
+
+  setBusBase(id, value) {
+    const path = `audio.buses.${id}.gain`;
+    this.requireAudioStage(path);
+    this.busValues.set(id, normalizeForSpec(this.target(path).spec, value));
+    this.invalidate();
+    return this.resolveAll();
+  }
+
+  subscribe(listener) { this.listeners.add(listener); return () => this.listeners.delete(listener); }
+
+  setParameter(id, value) {
+    const spec = this.document.parameters?.[id];
+    if (!spec) throw new RuntimeFault('ERR_INVALID_REFERENCE', `Unknown parameter '${id}'.`, `parameters.${id}`);
+    this.parameters.set(id, normalizeForSpec(spec, value));
+    this.invalidate();
+    this.onParameterChange(this.parameterSnapshot());
+    return this.resolveAll();
+  }
+
+  setState(path, value, transition = {}) {
+    const target = this.target(path);
+    if (!target || target.namespace !== 'state') throw new RuntimeFault('ERR_UNSUPPORTED_TARGET', `set may target state only; got '${path}'.`, path);
+    const normalized = normalizeForSpec(target.spec, value);
+    const durationMs = parseDuration(transition.duration ?? '0ms', '$.transition.duration');
+    const easing = transition.easing ?? 'linear';
+    easingValue(easing, 0);
+    if (!isNumericType(target.spec.type) && durationMs > 0) throw new RuntimeFault('ERR_INVALID_TRANSITION', 'Non-numeric state values require zero-duration transitions.');
+    if (durationMs === 0) {
+      this.state.set(target.id, normalized);
+      this.transitions.delete(path);
+    } else {
+      this.transitions.set(path, { path, from: this.base(path), to: normalized, start: this.logicalMilliseconds, durationMs, easing, spec: target.spec });
+    }
+    this.invalidate();
+    return this.resolveAll();
+  }
+
+  advance(milliseconds = 1000 / 60) {
+    if (!Number.isFinite(milliseconds) || milliseconds < 0) throw new RangeError('Advance duration must be finite and nonnegative.');
+    this.logicalMilliseconds += milliseconds;
+    this.tickIndex += 1;
+    this.signals.updateTime(this.logicalMilliseconds / 1000, milliseconds / 1000);
+    for (const [path, transition] of [...this.transitions]) {
+      const progress = clamp((this.logicalMilliseconds - transition.start) / transition.durationMs, 0, 1);
+      let value = lerp(transition.from, transition.to, easingValue(transition.easing, progress));
+      if (transition.spec.type === 'integer') value = roundHalfAwayFromZero(value);
+      value = normalizeForSpec(transition.spec, value, { clampNumeric: true });
+      this.state.set(path.split('.')[1], value);
+      if (progress >= 1) this.transitions.delete(path);
+    }
+    this.overrides.advance();
+    return this.resolveAll();
+  }
+
+  evaluateValue(spec, stream, path) { return this.valueResolver.evaluate(spec, stream, path); }
+  evaluateCondition(spec, stream, path) { return this.conditions.evaluate(spec, stream, path); }
+  invalidate() { this.resolved.clear(); }
+  parameterSnapshot() { return Object.fromEntries(this.parameters); }
+  stateSnapshot() { return Object.fromEntries(this.state); }
+  snapshot() { return Object.fromEntries(this.resolved); }
+  dispose() {
+    this.listeners.clear(); this.automation.clear(); this.modulation.clear(); this.busValues.clear(); this.preModulation.clear();
+    this.overrides.clear(); this.transitions.clear(); this.resolved.clear();
+  }
+}
+
+/* src/runtime/actions.js */
+class ActionExecutor {
+  constructor(engine, { diagnostics } = {}) {
+    this.engine = engine;
+    this.diagnostics = diagnostics;
+    this.invocationOrdinal = 0;
+  }
+
+  execute(actions, context = {}) {
+    if (!Array.isArray(actions)) throw new RuntimeFault('ERR_SCHEMA_VALIDATION', 'Actions must be an array.');
+    const stream = this.engine.rng.stream('scenario', `actions:${++this.invocationOrdinal}`);
+    const results = [];
+    for (let index = 0; index < actions.length; index += 1) {
+      const action = actions[index];
+      try {
+        results.push(this.executeOne(action, stream, context, `$.actions[${index}]`));
+      } catch (error) {
+        const fault = error instanceof RuntimeFault ? error : new RuntimeFault('ERR_ACTION_FAILURE', error.message);
+        this.diagnostics?.error(fault.code, fault.message, { exhibitId: this.engine.document.meta.id, section: 'actions', objectId: action?.id ?? null, property: fault.path });
+        results.push({ status: 'failed', error: fault });
+        if (action?.critical !== false) throw fault;
+      }
+    }
+    return results;
+  }
+
+  executeOne(action, stream, context, path) {
+    if (!isRecord(action) || typeof action.type !== 'string') throw new RuntimeFault('ERR_SCHEMA_VALIDATION', 'Action requires a type.', path);
+    if (action.when !== undefined && !this.engine.evaluateCondition(action.when, stream, `${path}.when`)) return { status: 'skipped', reason: 'condition' };
+    if (action.chance !== undefined) {
+      if (!Number.isFinite(action.chance) || action.chance < 0 || action.chance > 1) throw new RuntimeFault('ERR_OUT_OF_BOUNDS', 'Action chance must be from 0 through 1.', `${path}.chance`);
+      if (stream.nextFloat() >= action.chance) return { status: 'skipped', reason: 'chance' };
+    }
+
+    if (action.type === 'set') {
+      const value = this.engine.evaluateValue(action.value, stream, `${path}.value`);
+      this.engine.setState(action.target, value, action.transition);
+      return { status: 'executed', type: 'set', target: action.target, value };
+    }
+    if (action.type === 'override') {
+      const value = this.engine.evaluateValue(action.value, stream, `${path}.value`);
+      const instanceId = this.engine.overrides.add(action, value, { owner: context.owner, inheritedPriority: context.priority });
+      this.engine.resolveAll();
+      return { status: 'executed', type: 'override', target: action.target, value, instanceId };
+    }
+    throw new RuntimeFault('ERR_UNSUPPORTED_TARGET', `Action '${action.type}' belongs to a later subsystem phase.`, `${path}.type`);
+  }
+}
+
+/* src/runtime/performance.js */
+class CommonGrammarPerformance {
+  constructor(record, rootSeed, options = {}) {
+    this.record = record;
+    this.rootSeed = rootSeed;
+    this.rng = new SeededRNG(rootSeed);
+    this.diagnostics = options.diagnostics;
+    this.onUpdate = options.onUpdate ?? (() => {});
+    this.engine = new ResolutionEngine(record.document, this.rng, {
+      diagnostics: this.diagnostics,
+      initialParameters: options.initialParameters,
+      onParameterChange: options.onParameterChange
+    });
+    this.actions = new ActionExecutor(this.engine, { diagnostics: this.diagnostics });
+    this.state = 'prepared';
+    this.resources = new Set();
+    this.frameRequest = null;
+    this.lastFrame = undefined;
+    this.accumulator = 0;
+    this.boundFrame = (now) => this.frame(now);
+    this.boundPointer = (event) => {
+      this.engine.signals.set('signals.pointer.x', event.clientX);
+      this.engine.signals.set('signals.pointer.y', event.clientY);
+      this.engine.invalidate();
+    };
+    this.boundResize = () => {
+      this.engine.signals.set('signals.viewport.width', globalThis.innerWidth ?? 0);
+      this.engine.signals.set('signals.viewport.height', globalThis.innerHeight ?? 0);
+      this.engine.invalidate();
+    };
+  }
+
+  async activate() {
+    if (this.state !== 'prepared') throw new Error(`Cannot activate a performance in state ${this.state}.`);
+    this.state = 'active';
+    this.onUpdate(this.engine);
+    if (typeof globalThis.addEventListener === 'function') {
+      globalThis.addEventListener('pointermove', this.boundPointer, { passive: true });
+      globalThis.addEventListener('resize', this.boundResize, { passive: true });
+    }
+    if (typeof globalThis.requestAnimationFrame === 'function') this.frameRequest = globalThis.requestAnimationFrame(this.boundFrame);
+  }
+
+  frame(now) {
+    if (this.state !== 'active') return;
+    if (this.lastFrame === undefined) this.lastFrame = now;
+    const observed = Math.max(0, now - this.lastFrame);
+    this.lastFrame = now;
+    const accepted = Math.min(observed, 250);
+    this.accumulator += accepted;
+    const step = 1000 / 60;
+    let ticks = 0;
+    while (this.accumulator + 1e-9 >= step && ticks < 8) {
+      this.engine.advance(step);
+      this.accumulator -= step;
+      ticks += 1;
+    }
+    if (observed > 250 || this.accumulator >= step) {
+      this.accumulator = Math.min(this.accumulator, step - 1e-9);
+      this.diagnostics?.warn('WARN_CLOCK_STALL', 'Discarded excess elapsed time to preserve the fixed-step work bound.', { exhibitId: this.record.id, section: 'scheduler' });
+    }
+    if (ticks > 0) this.onUpdate(this.engine);
+    this.frameRequest = globalThis.requestAnimationFrame(this.boundFrame);
+  }
+
+  setParameter(id, value) {
+    const result = this.engine.setParameter(id, value);
+    this.onUpdate(this.engine);
+    return result;
+  }
+
+  execute(actionArray, context) {
+    const result = this.actions.execute(actionArray, context);
+    this.onUpdate(this.engine);
+    return result;
+  }
+
+  releaseOverride(id) {
+    const released = this.engine.overrides.beginRelease(id);
+    this.engine.resolveAll();
+    this.onUpdate(this.engine);
+    return released;
+  }
+
+  async deactivate() {
+    if (this.frameRequest !== null && typeof globalThis.cancelAnimationFrame === 'function') globalThis.cancelAnimationFrame(this.frameRequest);
+    this.frameRequest = null;
+    this.lastFrame = undefined;
+    if (typeof globalThis.removeEventListener === 'function') {
+      globalThis.removeEventListener('pointermove', this.boundPointer);
+      globalThis.removeEventListener('resize', this.boundResize);
+    }
+    if (this.state === 'active') this.state = 'inactive';
+    this.engine.overrides.clear();
+    this.resources.clear();
+  }
+
+  async dispose() {
+    if (this.frameRequest !== null && typeof globalThis.cancelAnimationFrame === 'function') globalThis.cancelAnimationFrame(this.frameRequest);
+    this.frameRequest = null;
+    if (typeof globalThis.removeEventListener === 'function') {
+      globalThis.removeEventListener('pointermove', this.boundPointer);
+      globalThis.removeEventListener('resize', this.boundResize);
+    }
+    this.engine.dispose();
+    this.resources.clear();
+    this.state = 'disposed';
+  }
+}
+
+/* src/runtime/activation.js */
+class InertPerformance {
+  constructor(record, rootSeed) {
+    this.record = record;
+    this.rootSeed = rootSeed;
+    this.rng = new SeededRNG(rootSeed);
+    this.state = 'prepared';
+    this.resources = new Set();
+  }
+
+  async activate() {
+    if (this.state !== 'prepared') throw new Error(`Cannot activate a performance in state ${this.state}.`);
+    this.state = 'active';
+  }
+
+  async deactivate() {
+    if (this.state === 'active') this.state = 'inactive';
+    this.resources.clear();
+  }
+
+  async dispose() {
+    this.resources.clear();
+    this.state = 'disposed';
+  }
+}
+
+class ActivationController {
+  constructor({ diagnostics, persistence, performanceFactory, cryptoProvider = globalThis.crypto } = {}) {
+    this.diagnostics = diagnostics;
+    this.persistence = persistence;
+    this.crypto = cryptoProvider;
+    this.performanceFactory = performanceFactory ?? ((record, seed) => new CommonGrammarPerformance(record, seed));
+    this.current = null;
+  }
+
+  prepare(record) {
+    const seed = resolveRootSeed(record.document.runtime?.seed ?? 'random', this.crypto);
+    const performance = this.performanceFactory(record, seed);
+    if (!performance || typeof performance.activate !== 'function' || typeof performance.deactivate !== 'function' || typeof performance.dispose !== 'function') {
+      throw new TypeError('Performance factory returned an invalid lifecycle object.');
+    }
+    return { record, seed, performance };
+  }
+
+  async activate(record) {
+    let candidate;
+    try {
+      candidate = this.prepare(record);
+    } catch (error) {
+      this.diagnostics?.error('ERR_ACTIVATION_PREPARE', `Could not prepare exhibit: ${error.message}`, { exhibitId: record.id, section: 'activation' });
+      return false;
+    }
+
+    const previous = this.current;
+    if (previous) {
+      try {
+        await previous.performance.deactivate('replacement');
+        await previous.performance.dispose();
+      } catch (error) {
+        await candidate.performance.dispose();
+        this.diagnostics?.error('ERR_DEACTIVATION', `Could not safely deactivate the current exhibit: ${error.message}`, { exhibitId: previous.record.id, section: 'activation' });
+        return false;
+      }
+      this.current = null;
+    }
+
+    try {
+      await candidate.performance.activate();
+      this.current = candidate;
+      try {
+        await this.persistence?.savePreference('lastExhibitId', record.id);
+      } catch (error) {
+        this.diagnostics?.warn('WARN_STORAGE_WRITE_FAILED', `The active selection could not be remembered: ${error.message}`, { exhibitId: record.id, section: 'persistence' });
+      }
+      this.diagnostics?.info('INFO_EXHIBIT_ACTIVATED', `${record.document.meta.name} activated with resolved seed ${candidate.seed}.`, { exhibitId: record.id, section: 'activation', property: 'runtime.seed' });
+      return true;
+    } catch (error) {
+      await candidate.performance.dispose();
+      this.diagnostics?.error('ERR_ACTIVATION', `Activation failed: ${error.message}`, { exhibitId: record.id, section: 'activation' });
+      if (previous) await this.recover(previous);
+      return false;
+    }
+  }
+
+  async recover(previous) {
+    try {
+      const recovery = this.prepare(previous.record);
+      await recovery.performance.activate();
+      this.current = recovery;
+      this.diagnostics?.warn('WARN_ACTIVATION_RECOVERED', `The previous exhibit was restarted after activation failure.`, { exhibitId: previous.record.id, section: 'activation' });
+    } catch (error) {
+      this.diagnostics?.error('ERR_ACTIVATION_RECOVERY', `The previous exhibit could not be restarted: ${error.message}`, { exhibitId: previous.record.id, section: 'activation' });
+    }
+  }
+
+  async deactivate() {
+    if (!this.current) return true;
+    const current = this.current;
+    this.current = null;
+    try {
+      await current.performance.deactivate('manual');
+      await current.performance.dispose();
+      this.diagnostics?.info('INFO_EXHIBIT_DEACTIVATED', `${current.record.document.meta.name} deactivated.`, { exhibitId: current.record.id, section: 'activation' });
+      return true;
+    } catch (error) {
+      this.diagnostics?.error('ERR_DEACTIVATION', `Exhibit teardown failed: ${error.message}`, { exhibitId: current.record.id, section: 'activation' });
+      return false;
+    }
+  }
+}
+
+/* src/runtime/audio-engine.js */
+// Deterministic instantiation of an expanded audio graph, plus its Web Audio realization.
+// Instantiation is pure and testable without an AudioContext (Format Specification 14.4-14.6).
+
+
+
+
+
+
+
+
+
+
+function soundInstanceKey(soundId, ordinal) {
+  return `${soundId}#${ordinal}`;
+}
+
+function sampleHoldStreamKey(instanceKey, nodePath) {
+  return `${instanceKey}|node|${nodePath}`;
+}
+
+function instantiateSoundGraph(document, soundId, options = {}) {
+  const {
+    sampleRate = 48000,
+    rng = null,
+    ordinal = 0,
+    resolveReference = () => { throw new RuntimeFault('ERR_INVALID_REFERENCE', 'No reference resolver supplied.'); }
+  } = options;
+
+  const expansion = options.expansion ?? expandSoundGraph(document, soundId);
+  if (expansion.errors.length > 0) {
+    return {
+      nodes: [],
+      routes: [],
+      warnings: [],
+      errors: expansion.errors,
+      mode: expansion.mode,
+      release: expansion.release,
+      endingBoundMs: null
+    };
+  }
+
+  const ceiling = audioMaxFrequency(sampleRate);
+  const instanceKey = soundInstanceKey(soundId, ordinal);
+  const stream = rng ? rng.stream('sound', instanceKey) : null;
+  const warnings = [];
+  const componentValues = new Map();
+
+  const resolver = new ValueResolver((reference) => {
+    if (typeof reference === 'string' && reference.startsWith('inputs.')) {
+      const scope = resolver.currentScope;
+      const values = componentValues.get(scope);
+      const name = reference.slice('inputs.'.length);
+      if (!values || !Object.hasOwn(values, name)) {
+        throw new RuntimeFault('ERR_INVALID_REFERENCE', `Component input '${name}' is not available here.`);
+      }
+      return values[name];
+    }
+    return resolveReference(reference);
+  });
+
+  const evaluate = (spec, scope, path) => {
+    resolver.currentScope = scope;
+    return resolver.evaluate(spec, stream, path);
+  };
+  const sample = (spec, scope, path) => {
+    resolver.currentScope = scope;
+    return resolver.sample(spec, stream, path, (ref) => scope && ref.startsWith('inputs.'));
+  };
+
+  const clampField = (value, spec, nodePath, field) => {
+    let limitMax = spec.max;
+    if (spec.ceiling === 'audio' && ceiling < spec.max) limitMax = ceiling;
+    const bounded = clamp(value, spec.min, limitMax);
+    if (spec.ceiling === 'audio' && value > limitMax) {
+      warnings.push({ code: 'WARN_AUDIO_RATE_CLAMP', path: `${nodePath}.${field}`, message: `Clamped ${value} Hz to the device ceiling ${limitMax} Hz.` });
+    }
+    return bounded;
+  };
+
+  const nodes = expansion.nodes.filter((node) => node.implicit).map((node) => ({ path: node.path, type: 'gain', implicit: true, values: { gain: 1 } }));
+  const routes = [];
+  const automation = [];
+  const expandedNodes = new Map(expansion.nodes.map((node) => [node.path, node]));
+  for (const item of expansion.samplingOrder) {
+    if (item.kind === 'route') {
+      const route = expansion.routes[item.index];
+      routes.push(route.kind === 'audio' ? { ...route } : { ...route, depth: evaluate(route.depth, route.scope, `${route.path}.depth`) });
+      continue;
+    }
+    if (item.kind === 'automation') {
+      const track = expansion.automation[item.index];
+      automation.push(sampleAutomationTrack(track, (value, path) => evaluate(value, track.scope, path), (warning) => warnings.push(warning)));
+      continue;
+    }
+    const node = expandedNodes.get(item.path);
+    if (!node) continue;
+    const contract = AUDIO_NODE_TYPES[node.type];
+    if (!contract) continue;
+    const scope = node.scope;
+    const values = {};
+    const expressions = {};
+
+    if (node.type === 'component') {
+      const declared = node.exposes ?? {};
+      const supplied = node.spec.values ?? {};
+      const resolved = {};
+      const names = [...Object.keys(supplied), ...Object.keys(declared).filter((name) => !Object.hasOwn(supplied, name))];
+      for (const name of names) {
+        const rule = declared[name];
+        const raw = Object.hasOwn(supplied, name) ? supplied[name] : rule.default;
+        expressions[name] = sample(raw, scope, `${node.path}.values.${name}`);
+        const value = evaluate(expressions[name], scope, `${node.path}.values.${name}`);
+        resolved[name] = clamp(value, rule.min ?? -Infinity, rule.max ?? Infinity);
+      }
+      componentValues.set(node.path, resolved);
+      nodes.push({ path: node.path, type: 'component', component: node.component, values: resolved, expressions, exposes: declared, scope, passthrough: true });
+      continue;
+    }
+
+    const fields = [...Object.keys(node.spec).filter((field) => Object.hasOwn(contract.fields, field)), ...Object.keys(contract.fields).filter((field) => !Object.hasOwn(node.spec, field))];
+    for (const field of fields) {
+      const spec = contract.fields[field];
+      if (spec.kind === 'partials' || spec.kind === 'modes') {
+        const table = spec.kind === 'partials' ? AUDIO_PARTIAL_FIELDS : AUDIO_MODE_FIELDS;
+        values[field] = (node.spec[field] ?? []).map((entry, index) => {
+          const sampled = {};
+          const names = [...Object.keys(entry), ...Object.keys(table).filter((name) => !Object.hasOwn(entry, name) && table[name].default !== undefined)];
+          for (const name of names) {
+            const value = Object.hasOwn(entry, name) ? entry[name] : table[name].default;
+            sampled[name] = name === 'decay' ? durationMilliseconds(value) : evaluate(value, scope, `${node.path}.${field}[${index}].${name}`);
+          }
+          return sampled;
+        });
+        continue;
+      }
+      const authored = Object.hasOwn(node.spec, field) ? node.spec[field] : spec.default;
+      if (authored === undefined) continue;
+      if (spec.kind === 'enum') { values[field] = authored; continue; }
+      if (spec.kind === 'duration') { values[field] = durationMilliseconds(authored); continue; }
+      const frozen = sample(authored, scope, `${node.path}.${field}`);
+      const raw = evaluate(frozen, scope, `${node.path}.${field}`);
+      if (Object.hasOwn(AUDIO_MODULATABLE[node.type] ?? {}, field)) expressions[field] = frozen;
+      values[field] = clampField(raw, spec, node.path, field);
+    }
+
+    if (node.type === 'oscillator' && values.waveform === 'custom') {
+      values.harmonics = values.harmonics.filter((partial) => partial.ratio * values.frequency <= ceiling);
+    }
+
+    if (node.type === 'resonator') {
+      values.modes = values.modes.map((mode) => ({ ...mode, frequency: mode.frequency ?? mode.ratio * values.fundamental })).filter((mode) => mode.frequency <= ceiling);
+    }
+
+    if (node.type === 'sample-hold') {
+      const slewLimit = 1000 / values.rate;
+      values.slew = Math.min(values.slew, slewLimit);
+      values.streamKey = sampleHoldStreamKey(instanceKey, node.path);
+      values.stream = rng ? rng.stream('sound', values.streamKey) : null;
+    }
+
+    nodes.push({ path: node.path, type: node.type, values, expressions, scope });
+  }
+
+  let endingBoundMs = null;
+  if (expansion.mode === 'oneshot') {
+    const boundedNodes = nodes.map((node) => {
+      if (node.type !== 'delay') return node;
+      const track = automation.find((item) => item.target === node.path && item.property === 'time');
+      const modulated = routes.some((route) => route.kind === 'modulation' && route.to === node.path && route.property === 'time');
+      // A varying delay must not dispose its voice at the shorter base-time tail.
+      const maximumTime = modulated ? 10000 : track ? clamp(Math.max(...track.points.map((point) => applyAutomationMode(node.values.time, point.value, track.mode))), 0, 10000) : node.values.time;
+      return { ...node, values: { ...node.values, time: maximumTime } };
+    });
+    endingBoundMs = computeDeterminableEndingBound(expansion, boundedNodes);
+  }
+
+  return {
+    nodes,
+    routes,
+    automation,
+    warnings,
+    errors: [],
+    mode: expansion.mode,
+    release: expansion.release,
+    endingBoundMs,
+    instanceKey,
+    ceiling
+  };
+}
+
+/* ------------------------------------------------------------------ *
+ * Web Audio realization
+ * ------------------------------------------------------------------ */
+
+const NOISE_SECONDS = 2;
+
+function noiseBuffer(context, color) {
+  const length = Math.floor(context.sampleRate * NOISE_SECONDS);
+  const buffer = context.createBuffer(1, length, context.sampleRate);
+  const data = buffer.getChannelData(0);
+  if (color === 'white') {
+    for (let index = 0; index < length; index += 1) data[index] = (Math.random() * 2) - 1;
+  } else if (color === 'pink') {
+    let b0 = 0, b1 = 0, b2 = 0, b3 = 0, b4 = 0, b5 = 0, b6 = 0;
+    for (let index = 0; index < length; index += 1) {
+      const white = (Math.random() * 2) - 1;
+      b0 = 0.99886 * b0 + white * 0.0555179;
+      b1 = 0.99332 * b1 + white * 0.0750759;
+      b2 = 0.969 * b2 + white * 0.153852;
+      b3 = 0.8665 * b3 + white * 0.3104856;
+      b4 = 0.55 * b4 + white * 0.5329522;
+      b5 = -0.7616 * b5 - white * 0.016898;
+      data[index] = b0 + b1 + b2 + b3 + b4 + b5 + b6 + white * 0.5362;
+      b6 = white * 0.115926;
+    }
+  } else {
+    let last = 0;
+    for (let index = 0; index < length; index += 1) {
+      const white = (Math.random() * 2) - 1;
+      last = (last + 0.02 * white) / 1.02;
+      data[index] = last;
+    }
+  }
+  let sum = 0;
+  for (let index = 0; index < length; index += 1) sum += data[index] * data[index];
+  const rms = Math.sqrt(sum / length) || 1;
+  for (let index = 0; index < length; index += 1) data[index] = clamp(data[index] / rms * 0.2, -1, 1);
+  return buffer;
+}
+
+function shaperCurve(shape, amount) {
+  const points = 1024;
+  const curve = new Float32Array(points);
+  const drive = 1 + (amount * 24);
+  for (let index = 0; index < points; index += 1) {
+    const x = (index * 2 / (points - 1)) - 1;
+    if (amount === 0) curve[index] = x;
+    else if (shape === 'hard-clip') curve[index] = clamp(x * drive, -1, 1);
+    else if (shape === 'saturation') curve[index] = Math.tanh(x * drive);
+    else curve[index] = Math.sign(x) * (1 - Math.exp(-Math.abs(x * drive))) / (1 - Math.exp(-drive));
+  }
+  return curve;
+}
+
+function reverbBuffer(context, { size, decay, damping }) {
+  const seconds = Math.max(0.05, (decay / 1000) * (0.4 + (size * 0.6)));
+  const length = Math.max(1, Math.floor(context.sampleRate * seconds));
+  const buffer = context.createBuffer(2, length, context.sampleRate);
+  for (let channel = 0; channel < 2; channel += 1) {
+    const data = buffer.getChannelData(channel);
+    let smoothed = 0;
+    for (let index = 0; index < length; index += 1) {
+      const envelope = (1 - (index / length)) ** (2 + (damping * 4));
+      const impulse = ((Math.random() * 2) - 1) * envelope;
+      smoothed += (impulse - smoothed) * (1 - (damping * 0.7));
+      data[index] = smoothed;
+    }
+  }
+  return buffer;
+}
+
+function periodicWave(context, partials) {
+  const count = Math.max(2, partials.reduce((highest, partial) => Math.max(highest, Math.round(partial.ratio)), 1) + 1);
+  const real = new Float32Array(count);
+  const imaginary = new Float32Array(count);
+  for (const partial of partials) {
+    const index = Math.round(partial.ratio);
+    if (index < 1 || index >= count) continue;
+    const radians = (partial.phase ?? 0) * Math.PI / 180;
+    real[index] += partial.gain * Math.cos(radians);
+    imaginary[index] += partial.gain * Math.sin(radians);
+  }
+  return context.createPeriodicWave(real, imaginary, { disableNormalization: false });
+}
+
+// Builds one voice and its audio-clock automation; partial construction is also
+// disposable, so a failed scheduler cannot leave connected or running sources.
+function realizeSoundGraph(context, plan, destination) {
+  const created = new Map();
+  const disposers = [];
+  const starters = [];
+  const sink = context.createGain();
+  sink.gain.value = 1;
+  const releaseGain = context.createGain();
+  releaseGain.gain.value = 1;
+  sink.connect(releaseGain).connect(destination);
+  disposers.push(() => releaseGain.disconnect());
+  created.set('output', { input: sink, output: sink });
+
+  const now = () => context.currentTime;
+  const startTime = now();
+  const dispose = () => {
+    for (const release of disposers.splice(0).reverse()) {
+      try { release(); } catch { /* disposal is best effort */ }
+    }
+    sink.disconnect();
+    releaseGain.disconnect();
+    created.clear();
+    starters.length = 0;
+  };
+
+  try {
+    for (const node of plan.nodes) {
+      const { path, type, values } = node;
+      if (type === 'component') continue;
+      let entry = null;
+
+      if (type === 'oscillator') {
+        const oscillator = context.createOscillator();
+        if (values.waveform === 'custom') oscillator.setPeriodicWave(periodicWave(context, values.harmonics ?? []));
+        else oscillator.type = values.waveform;
+        oscillator.frequency.value = values.frequency;
+        oscillator.detune.value = values.detune;
+        entry = { input: null, output: oscillator, params: { frequency: oscillator.frequency, detune: oscillator.detune } };
+        starters.push(() => oscillator.start(startTime));
+        disposers.push(() => { try { oscillator.stop(); } catch { /* already stopped */ } oscillator.disconnect(); });
+      } else if (type === 'noise') {
+        const source = context.createBufferSource();
+        source.buffer = noiseBuffer(context, values.color);
+        source.loop = true;
+        entry = { input: null, output: source, params: {} };
+        starters.push(() => source.start(startTime));
+        disposers.push(() => { try { source.stop(); } catch { /* already stopped */ } source.disconnect(); });
+      } else if (type === 'impulse') {
+        const source = context.createBufferSource();
+        source.buffer = noiseBuffer(context, values.color);
+        const envelope = context.createGain();
+        const seconds = values.duration / 1000;
+        const fade = Math.min(0.001, seconds * 0.1);
+        const start = startTime;
+        envelope.gain.setValueAtTime(values.amplitude, start);
+        if (values.decay === 'linear') envelope.gain.linearRampToValueAtTime(0, start + seconds);
+        else if (values.decay === 'exponential') {
+          envelope.gain.exponentialRampToValueAtTime(Math.max(1e-4, values.amplitude * 0.001), start + seconds - fade);
+          envelope.gain.linearRampToValueAtTime(0, start + seconds);
+        } else {
+          envelope.gain.setValueAtTime(values.amplitude, start + seconds - fade);
+          envelope.gain.linearRampToValueAtTime(0, start + seconds);
+        }
+        source.connect(envelope);
+        entry = { input: null, output: envelope, params: {} };
+        starters.push(() => source.start(startTime, 0, seconds));
+        disposers.push(() => { try { source.stop(); } catch { /* already stopped */ } source.disconnect(); envelope.disconnect(); });
+      } else if (type === 'constant') {
+        const source = context.createConstantSource();
+        source.offset.value = values.value;
+        entry = { input: null, output: source, params: { value: source.offset } };
+        starters.push(() => source.start(startTime));
+        disposers.push(() => { try { source.stop(); } catch { /* already stopped */ } source.disconnect(); });
+      } else if (type === 'lfo') {
+        const oscillator = context.createOscillator();
+        oscillator.type = values.waveform;
+        oscillator.frequency.value = values.frequency;
+        const depth = context.createGain();
+        depth.gain.value = values.polarity === 'unipolar' ? values.amplitude / 2 : values.amplitude;
+        oscillator.connect(depth);
+        let output = depth;
+        if (values.polarity === 'unipolar') {
+          const offset = context.createConstantSource();
+          offset.offset.value = values.amplitude / 2;
+          const sum = context.createGain();
+          depth.connect(sum);
+          offset.connect(sum);
+          output = sum;
+          starters.push(() => offset.start(startTime));
+          disposers.push(() => { try { offset.stop(); } catch { /* already stopped */ } offset.disconnect(); sum.disconnect(); });
+        }
+        entry = { input: null, output, params: {} };
+        starters.push(() => oscillator.start(startTime + ((values.phase / 360) / Math.max(values.frequency, 1e-6))));
+        disposers.push(() => { try { oscillator.stop(); } catch { /* already stopped */ } oscillator.disconnect(); depth.disconnect(); });
+      } else if (type === 'sample-hold') {
+        const source = context.createConstantSource();
+        const period = 1 / values.rate;
+        const slew = values.slew / 1000;
+        let held = 0;
+        source.offset.value = 0;
+        const schedule = (index) => {
+          const target = values.stream
+            ? values.min + (values.stream.nextFloat() * (values.max - values.min))
+            : values.min;
+          const at = now() + (index * period);
+          if (slew > 0) source.offset.linearRampToValueAtTime(target, at + slew);
+          else source.offset.setValueAtTime(target, at);
+          held = target;
+          return held;
+        };
+        let tick = 0;
+        const timer = setInterval(() => { schedule(0); tick += 1; }, Math.max(10, period * 1000));
+        if (typeof timer.unref === 'function') timer.unref();
+        schedule(0);
+        entry = { input: null, output: source, params: {} };
+        starters.push(() => source.start(startTime));
+        disposers.push(() => { clearInterval(timer); try { source.stop(); } catch { /* already stopped */ } source.disconnect(); void tick; });
+      } else if (type === 'gain') {
+        const gain = context.createGain();
+        gain.gain.value = values.gain ?? 1;
+        entry = { input: gain, output: gain, params: { gain: gain.gain } };
+        disposers.push(() => gain.disconnect());
+      } else if (type === 'filter') {
+        const filter = context.createBiquadFilter();
+        filter.type = values.mode;
+        filter.frequency.value = values.frequency;
+        filter.Q.value = values.q;
+        filter.gain.value = values.gain;
+        filter.detune.value = values.detune;
+        entry = { input: filter, output: filter, params: { frequency: filter.frequency, q: filter.Q, gain: filter.gain, detune: filter.detune } };
+        disposers.push(() => filter.disconnect());
+      } else if (type === 'compressor') {
+        const compressor = context.createDynamicsCompressor();
+        compressor.threshold.value = values.threshold;
+        compressor.knee.value = values.knee;
+        compressor.ratio.value = values.ratio;
+        compressor.attack.value = values.attack / 1000;
+        compressor.release.value = values.release / 1000;
+        entry = { input: compressor, output: compressor, params: {} };
+        disposers.push(() => compressor.disconnect());
+      } else if (type === 'waveshaper') {
+        const shaper = context.createWaveShaper();
+        shaper.curve = shaperCurve(values.shape, values.amount);
+        shaper.oversample = values.oversample;
+        entry = { input: shaper, output: shaper, params: {} };
+        disposers.push(() => shaper.disconnect());
+      } else if (type === 'delay') {
+        const input = context.createGain();
+        const delay = context.createDelay(10);
+        delay.delayTime.value = values.time / 1000;
+        const feedback = context.createGain();
+        feedback.gain.value = values.feedback;
+        const dry = context.createGain();
+        const wet = context.createGain();
+        const output = context.createGain();
+        dry.gain.value = 1 - values.mix;
+        wet.gain.value = values.mix;
+        input.connect(dry).connect(output);
+        input.connect(delay);
+        delay.connect(feedback).connect(delay);
+        delay.connect(wet).connect(output);
+        entry = { input, output, params: { time: delay.delayTime } };
+        disposers.push(() => [input, delay, feedback, dry, wet, output].forEach((item) => item.disconnect()));
+      } else if (type === 'reverb') {
+        const input = context.createGain();
+        const convolver = context.createConvolver();
+        convolver.buffer = reverbBuffer(context, values);
+        const predelay = context.createDelay(1);
+        predelay.delayTime.value = values.predelay / 1000;
+        const dry = context.createGain();
+        const wet = context.createGain();
+        const output = context.createGain();
+        dry.gain.value = 1 - values.mix;
+        wet.gain.value = values.mix;
+        input.connect(dry).connect(output);
+        input.connect(predelay).connect(convolver).connect(wet).connect(output);
+        entry = { input, output, params: {} };
+        disposers.push(() => [input, convolver, predelay, dry, wet, output].forEach((item) => item.disconnect()));
+      } else if (type === 'stereo-pan') {
+        const panner = context.createStereoPanner();
+        panner.pan.value = values.pan;
+        entry = { input: panner, output: panner, params: { pan: panner.pan } };
+        disposers.push(() => panner.disconnect());
+      } else if (type === 'mixer') {
+        const mixer = context.createGain();
+        mixer.gain.value = 1;
+        entry = { input: mixer, output: mixer, params: {} };
+        disposers.push(() => mixer.disconnect());
+      } else if (type === 'resonator') {
+        const input = context.createGain();
+        const output = context.createGain();
+        const dry = context.createGain();
+        dry.gain.value = 1 - values.mix;
+        input.connect(dry).connect(output);
+        const wet = context.createGain();
+        wet.gain.value = values.mix;
+        wet.connect(output);
+        const bands = [];
+        const controls = [];
+        for (const mode of values.modes ?? []) {
+          const band = context.createBiquadFilter();
+          band.type = 'bandpass';
+          band.frequency.value = mode.frequency;
+          band.Q.value = Math.max(1, (mode.frequency * (mode.decay / 1000)) / 3);
+          const level = context.createGain();
+          level.gain.value = mode.gain;
+          input.connect(band).connect(level).connect(wet);
+          bands.push(band, level);
+          controls.push({ ratio: mode.ratio, decay: mode.decay, frequency: band.frequency, q: band.Q });
+        }
+        entry = { input, output, params: {}, bands: controls };
+        disposers.push(() => [input, output, dry, wet, ...bands].forEach((item) => item.disconnect()));
+      }
+
+      if (entry) created.set(path, entry);
+    }
+
+    for (const route of plan.routes) {
+      const source = created.get(route.from);
+      if (!source?.output) continue;
+      if (route.kind === 'audio') {
+        const target = created.get(route.to);
+        if (target?.input) source.output.connect(target.input);
+        continue;
+      }
+      // Modulation routes are connected by the final, clamped control pipeline.
+    }
+
+    const controls = createAudioControls(context, plan, created, (release) => disposers.push(release), startTime);
+    disposers.push(() => controls.dispose());
+    controls.apply();
+
+    for (const start of starters) start();
+
+    return {
+      sink,
+      releaseGain,
+      startTime,
+      dispose
+    };
+  } catch (error) {
+    dispose();
+    throw error;
+  }
+}
+
+class SoundInstance {
+  constructor({
+    soundId,
+    mode = 'oneshot',
+    releaseMs = AUDIO_DEFAULT_RELEASE_MS,
+    endingBoundMs = null,
+    plan = null,
+    subsystem = null,
+    bus = null,
+    context = null,
+    creationOrder = 0
+  } = {}) {
+    this.soundId = soundId;
+    this.mode = mode;
+    this.releaseMs = releaseMs ?? AUDIO_DEFAULT_RELEASE_MS;
+    this.endingBoundMs = endingBoundMs;
+    this.plan = plan;
+    this.subsystem = subsystem;
+    this.bus = bus;
+    this.context = context;
+    this.creationOrder = creationOrder;
+    this.state = 'CREATED';
+    this.realized = null;
+    this.startTime = null;
+    this.releaseTimer = null;
+    this.endingTimer = null;
+  }
+
+  canTransition(nextState) {
+    const allowed = AUDIO_LIFECYCLE_TRANSITIONS[this.state] ?? [];
+    return allowed.includes(nextState);
+  }
+
+  transition(nextState) {
+    if (!this.canTransition(nextState)) {
+      throw new RuntimeFault('ERR_RUNTIME_FAULT', `Invalid lifecycle transition from '${this.state}' to '${nextState}'.`);
+    }
+    this.state = nextState;
+    return true;
+  }
+
+  realize(context, destination) {
+    const guard = this.subsystem?.createVoiceGuard(this);
+    this.guard = guard;
+    if (guard) guard.connect(destination);
+    this.realized = realizeSoundGraph(context, this.plan, guard ?? destination);
+    return this.realized;
+  }
+
+  stop() {
+    if (this.state === 'RELEASING' || this.state === 'FINISHED' || this.state === 'DISPOSED' || this.state === 'FAILED') {
+      return;
+    }
+    if (this.subsystem) {
+      this.subsystem.voices.delete(this);
+    }
+    if (this.state === 'CREATED') {
+      this.transition('FINISHED');
+      return;
+    }
+    if (this.state === 'SCHEDULED') {
+      this.transition('RELEASING');
+      if (this.releaseMs === 0) {
+        this.transition('FINISHED');
+      } else {
+        this.releaseTimer = setTimeout(() => {
+          if (this.state === 'RELEASING') {
+            this.transition('FINISHED');
+          }
+        }, this.releaseMs);
+        if (typeof this.releaseTimer?.unref === 'function') this.releaseTimer.unref();
+      }
+      return;
+    }
+    if (this.state === 'ACTIVE') {
+      if (this.endingTimer) {
+        clearTimeout(this.endingTimer);
+        this.endingTimer = null;
+      }
+      this.transition('RELEASING');
+      if (this.releaseMs === 0) {
+        if (this.realized?.releaseGain?.gain) {
+          const now = this.context?.currentTime ?? 0;
+          this.realized.releaseGain.gain.cancelScheduledValues?.(now);
+          this.realized.releaseGain.gain.setValueAtTime?.(0, now);
+        }
+        this.transition('FINISHED');
+      } else {
+        const now = this.context?.currentTime ?? 0;
+        const durationSec = this.releaseMs / 1000;
+        const gainParam = this.realized?.releaseGain?.gain;
+        if (gainParam) {
+          gainParam.cancelScheduledValues?.(now);
+          gainParam.setValueAtTime?.(gainParam.value, now);
+          gainParam.linearRampToValueAtTime?.(0, now + durationSec);
+        }
+        this.releaseTimer = setTimeout(() => {
+          if (this.state === 'RELEASING') {
+            this.transition('FINISHED');
+          }
+        }, this.releaseMs);
+        if (typeof this.releaseTimer?.unref === 'function') this.releaseTimer.unref();
+      }
+    }
+  }
+
+  forceFinishAndDispose() {
+    if (this.state === 'RELEASING') {
+      if (this.releaseTimer) {
+        clearTimeout(this.releaseTimer);
+        this.releaseTimer = null;
+      }
+      if (this.realized?.releaseGain?.gain) {
+        const now = this.context?.currentTime ?? 0;
+        this.realized.releaseGain.gain.cancelScheduledValues?.(now);
+        this.realized.releaseGain.gain.setValueAtTime?.(0, now);
+      }
+      this.transition('FINISHED');
+    }
+    this.dispose();
+  }
+
+  dispose() {
+    if (this.state === 'DISPOSED') return;
+    if (this.releaseTimer) {
+      clearTimeout(this.releaseTimer);
+      this.releaseTimer = null;
+    }
+    if (this.endingTimer) {
+      clearTimeout(this.endingTimer);
+      this.endingTimer = null;
+    }
+    if (this.subsystem) {
+      this.subsystem.voices.delete(this);
+      this.subsystem.oneshotVoices?.delete(this);
+      this.subsystem.continuousVoices?.delete(this);
+    }
+    if (this.state !== 'FINISHED' && this.state !== 'FAILED') {
+      if (this.state === 'ACTIVE' || this.state === 'SCHEDULED') {
+        this.transition('RELEASING');
+        this.transition('FINISHED');
+      } else if (this.state === 'CREATED') {
+        this.transition('FINISHED');
+      } else if (this.state === 'RELEASING') {
+        this.transition('FINISHED');
+      }
+    }
+    // FAILED is terminal, but still owns the same resource cleanup obligation.
+    if (this.state !== 'FAILED') this.transition('DISPOSED');
+    if (this.realized) {
+      try { this.realized.dispose(); } catch { /* best effort */ }
+      this.realized = null;
+    }
+    this.plan = null;
+    if (this.guard) {
+      this.guard.port.onmessage = null;
+      this.guard.onprocessorerror = null;
+      this.guard.port.close();
+      this.guard.disconnect();
+      this.guard = null;
+    }
+    this.bus = null;
+    this.context = null;
+  }
+}
+
+/* ------------------------------------------------------------------ *
+ * Runtime subsystem
+ * ------------------------------------------------------------------ */
+
+// Owns the AudioContext, the declared buses, and the engine master chain, and turns a
+// sound definition into a realized voice. All buses and volume controls are upstream
+// of the final protection worklet; hardware/listening acceptance is tracked in GC6.
+class AudioSubsystem {
+  constructor({ document, rng, diagnostics = null, contextFactory = null, voiceLimits = null, resolutionEngine = null,
+    protectionFactory = { load: loadProtectionWorklet, create: createProtectionNode } } = {}) {
+    this.document = document;
+    this.rng = rng;
+    this.diagnostics = diagnostics;
+    this.ownsResolution = !resolutionEngine;
+    this.resolution = resolutionEngine ?? new ResolutionEngine(document ?? {}, rng ?? new SeededRNG(0), { diagnostics });
+    this.unsubscribeResolution = this.resolution.subscribe(() => this.updateBusGains());
+    this.hasCustomContext = Boolean(contextFactory);
+    this.contextFactory = contextFactory ?? (() => new (globalThis.AudioContext ?? globalThis.webkitAudioContext)());
+    this.context = null;
+    this.master = null;
+    this.protection = null;
+    this.buses = new Map();
+    this.voices = new Set();
+    this.oneshotVoices = new Set();
+    this.continuousVoices = new Set();
+    this.voiceLimits = voiceLimits ?? { ...AUDIO_VOICE_LIMITS };
+    this.ordinals = new Map();
+    this.nextCreationOrder = 0;
+    this.masterVolume = 0.8;
+    this.protectionFactory = protectionFactory;
+    this.ready = false;
+    this.disposed = false;
+    this.unlockPending = null;
+    this.capturePending = null;
+    this.captureSequence = 0;
+    this.unavailableWarned = false;
+  }
+
+  get available() {
+    return this.hasCustomContext || typeof (globalThis.AudioContext ?? globalThis.webkitAudioContext) === 'function';
+  }
+
+  get unlocked() {
+    return this.ready && this.context !== null && this.context.state === 'running';
+  }
+
+  // Must be called from a user gesture; browsers refuse to start audio otherwise.
+  async unlock() {
+    if (this.disposed) return false;
+    if (this.unlockPending) return this.unlockPending;
+    this.unlockPending = this.initializeAudio();
+    try { return await this.unlockPending; }
+    finally { this.unlockPending = null; }
+  }
+
+  async initializeAudio() {
+    try {
+      if (this.protectionFailed) throw new Error('Master protection failed; reactivate the exhibit to restart audio.');
+      if (!this.available) throw new Error('This browser exposes no AudioContext.');
+      if (!this.context) this.context = this.contextFactory();
+      const context = this.context;
+      // Resume synchronously with the gesture before awaiting module loading.
+      const resume = context.state === 'suspended' ? context.resume() : Promise.resolve();
+      await Promise.all([resume, this.ready ? Promise.resolve() : this.buildMaster()]);
+      if (this.disposed || this.context !== context) return false;
+      if (context.state !== 'running') throw new Error('The audio context did not enter the running state.');
+      if (!this.ready) this.buildBuses();
+      this.ready = true;
+      return this.unlocked;
+    } catch (error) {
+      this.ready = false;
+      for (const instance of [...this.oneshotVoices, ...this.continuousVoices]) instance.dispose();
+      this.disconnectMaster();
+      const context = this.context;
+      this.context = null;
+      try { await context?.close(); } catch { /* already closed */ }
+      if (!this.unavailableWarned && !this.disposed) {
+        this.unavailableWarned = true;
+        this.diagnostics?.warn('WARN_AUDIO_UNAVAILABLE', `Audio disabled: ${error.message}`, { section: 'audio' });
+      }
+      return false;
+    }
+  }
+
+  async buildMaster() {
+    const context = this.context;
+    await this.protectionFactory.load(context);
+    if (this.disposed || this.context !== context) return;
+    this.protection = this.protectionFactory.create(context, false);
+    this.protection.port.onmessage = ({ data }) => {
+      if (data.type === 'nonfinite') this.warnNonfinite('master');
+      if (data.type === 'capture' && data.id === this.capturePending?.id) {
+        const pending = this.capturePending;
+        this.capturePending = null;
+        pending.resolve(data);
+      }
+    };
+    this.protection.onprocessorerror = () => {
+      this.ready = false;
+      this.protectionFailed = true;
+      this.capturePending?.reject(new Error('Master protection processor failed.'));
+      this.capturePending = null;
+      this.protection?.disconnect();
+      this.diagnostics?.warn('WARN_AUDIO_UNAVAILABLE', 'Master protection failed; output is muted.', { section: 'audio' });
+    };
+    this.master = context.createGain();
+    this.master.gain.value = this.masterVolume;
+    this.master.connect(this.protection).connect(context.destination);
+  }
+
+  warnNonfinite(instanceId) {
+    this.diagnostics?.warn('WARN_AUDIO_NONFINITE', 'A non-finite audio sample was detected; the containing output block was muted.', { section: 'audio', objectId: instanceId });
+  }
+
+  createVoiceGuard(instance) {
+    const guard = this.protectionFactory.create(this.context, true);
+    const instanceId = instance.plan?.instanceKey ?? soundInstanceKey(instance.soundId, instance.creationOrder);
+    guard.port.onmessage = ({ data }) => {
+      if (data.type === 'nonfinite') this.warnNonfinite(instanceId);
+    };
+    guard.onprocessorerror = () => {
+      instance.dispose();
+      this.diagnostics?.warn('WARN_AUDIO_UNAVAILABLE', `Audio guard failed for '${instance.soundId}'; voice disposed.`, { section: 'audio', objectId: instance.soundId });
+    };
+    try { guard.connect(this.protection, 1, 1); }
+    catch (error) {
+      guard.port.onmessage = null;
+      guard.onprocessorerror = null;
+      guard.port.close();
+      guard.disconnect();
+      throw error;
+    }
+    return guard;
+  }
+
+  captureOutput({ seconds = 120, warmupSeconds = 30 } = {}) {
+    if (!this.unlocked) return Promise.reject(new Error('Unlock protected audio before capturing.'));
+    if (this.capturePending) return Promise.reject(new Error('An output capture is already running.'));
+    if (!Number.isFinite(seconds) || seconds <= 0 || !Number.isFinite(warmupSeconds) || warmupSeconds < 0) return Promise.reject(new Error('Invalid capture duration.'));
+    return new Promise((resolve, reject) => {
+      const id = ++this.captureSequence;
+      this.capturePending = { id, resolve, reject };
+      this.protection.port.postMessage({ type: 'capture', id,
+        frames: Math.max(1, Math.round(seconds * this.context.sampleRate)),
+        warmupFrames: Math.round(warmupSeconds * this.context.sampleRate) });
+    });
+  }
+
+  disconnectMaster() {
+    for (const bus of this.buses.values()) bus.disconnect();
+    this.buses.clear();
+    this.master?.disconnect();
+    if (this.protection) {
+      this.protection.port.onmessage = null;
+      this.protection.port.close();
+      this.protection.onprocessorerror = null;
+      this.protection.disconnect();
+    }
+    this.master = null;
+    this.protection = null;
+  }
+
+  buildBuses() {
+    const declared = this.document?.audio?.buses ?? {};
+    for (const id of Object.keys(declared)) {
+      const gain = this.context.createGain();
+      gain.gain.value = this.resolution.get(`audio.buses.${id}.gain`);
+      gain.connect(this.master);
+      this.buses.set(id, gain);
+    }
+  }
+
+  busFor(soundId) {
+    const name = this.document?.sounds?.[soundId]?.bus;
+    return (name && this.buses.get(name)) || this.master;
+  }
+
+  setBusGain(id, value) {
+    if (this.document?.audio?.buses?.[id]) this.resolution.setBusBase(id, Math.min(4, Math.max(0, value)));
+  }
+
+  updateBusGains() {
+    for (const [id, bus] of this.buses) bus.gain.value = this.resolution.get(`audio.buses.${id}.gain`);
+  }
+
+  setMasterVolume(value) {
+    if (!Number.isFinite(value)) return;
+    this.masterVolume = Math.min(1, Math.max(0, value));
+    if (this.master) this.master.gain.value = this.masterVolume;
+  }
+
+  nextOrdinal(soundId) {
+    const next = (this.ordinals.get(soundId) ?? -1) + 1;
+    this.ordinals.set(soundId, next);
+    return next;
+  }
+
+  play(soundId, { resolveReference = (path) => this.resolution.get(path) } = {}) {
+    if (!this.unlocked) return null;
+    const sound = this.document?.sounds?.[soundId];
+    if (!sound) return null;
+
+    const expansion = expandSoundGraph(this.document, soundId);
+    if (expansion.errors.length > 0) {
+      for (const error of expansion.errors) this.diagnostics?.error(error.code, error.message, { section: 'audio', objectId: soundId });
+      return null;
+    }
+
+    const mode = expansion.mode ?? 'oneshot';
+    const pool = mode === 'oneshot' ? this.oneshotVoices : this.continuousVoices;
+    const ceiling = mode === 'oneshot' ? this.voiceLimits.oneshot : this.voiceLimits.continuous;
+
+    if (pool.size >= ceiling) {
+      // 16.6 Eviction policy applied in strict order:
+      // 1. Dispose the oldest instance already in FINISHED.
+      const finishedInstances = [...pool].filter((i) => i.state === 'FINISHED');
+      if (finishedInstances.length > 0) {
+        finishedInstances.sort((a, b) => a.creationOrder - b.creationOrder);
+        const candidate = finishedInstances[0];
+        candidate.dispose();
+        this.diagnostics?.warn('WARN_VOICE_LIMIT', `Voice ceiling (${ceiling}) reached for '${soundId}'; disposed oldest FINISHED instance of '${candidate.soundId}'.`, { section: 'audio', objectId: soundId });
+      } else {
+        // 2. Evict the oldest instance in RELEASING by advancing its release ramp to immediate completion and disposing it.
+        const releasingInstances = [...pool].filter((i) => i.state === 'RELEASING');
+        if (releasingInstances.length > 0) {
+          releasingInstances.sort((a, b) => a.creationOrder - b.creationOrder);
+          const candidate = releasingInstances[0];
+          candidate.forceFinishAndDispose();
+          this.diagnostics?.warn('WARN_VOICE_LIMIT', `Voice ceiling (${ceiling}) reached for '${soundId}'; evicted oldest RELEASING instance of '${candidate.soundId}'.`, { section: 'audio', objectId: soundId });
+        } else if (mode === 'oneshot') {
+          // 3. For a one-shot request only: evict the oldest ACTIVE one-shot by starting its release.
+          const activeInstances = [...pool].filter((i) => i.state === 'ACTIVE' || i.state === 'SCHEDULED');
+          if (activeInstances.length > 0) {
+            activeInstances.sort((a, b) => a.creationOrder - b.creationOrder);
+            const candidate = activeInstances[0];
+            candidate.stop();
+            this.diagnostics?.warn('WARN_VOICE_LIMIT', `Voice ceiling (${ceiling}) reached for '${soundId}'; evicting oldest ACTIVE oneshot instance of '${candidate.soundId}' via release.`, { section: 'audio', objectId: soundId });
+          } else {
+            this.diagnostics?.warn('WARN_VOICE_LIMIT', `Voice ceiling (${ceiling}) reached for '${soundId}'; request refused.`, { section: 'audio', objectId: soundId });
+            return null;
+          }
+        } else {
+          // 4. Otherwise refuse the new instance.
+          this.diagnostics?.warn('WARN_VOICE_LIMIT', `Voice ceiling (${ceiling}) reached for '${soundId}'; continuous request refused.`, { section: 'audio', objectId: soundId });
+          return null;
+        }
+      }
+    }
+
+    const plan = instantiateSoundGraph(this.document, soundId, {
+      sampleRate: this.context.sampleRate,
+      rng: this.rng,
+      ordinal: this.nextOrdinal(soundId),
+      resolveReference,
+      expansion
+    });
+    for (const error of plan.errors) this.diagnostics?.error(error.code, error.message, { section: 'audio', objectId: soundId });
+    if (plan.errors.length > 0) return null;
+    for (const warning of plan.warnings) this.diagnostics?.warn(warning.code, warning.message, { section: 'audio', objectId: soundId, property: warning.path });
+
+    const instance = new SoundInstance({
+      soundId,
+      mode: plan.mode,
+      releaseMs: plan.release,
+      endingBoundMs: plan.endingBoundMs,
+      plan,
+      subsystem: this,
+      bus: this.busFor(soundId),
+      context: this.context,
+      creationOrder: this.nextCreationOrder++
+    });
+    pool.add(instance);
+
+    try {
+      instance.transition('SCHEDULED');
+      instance.realize(this.context, this.busFor(soundId));
+      instance.transition('ACTIVE');
+      instance.startTime = instance.realized.startTime;
+      this.voices.add(instance);
+    } catch (error) {
+      this.diagnostics?.error('ERR_AUDIO_REALIZATION', `Sound '${soundId}' could not be realized: ${error.message}`, { section: 'audio', objectId: soundId });
+      instance.transition('FAILED');
+      instance.dispose();
+      return null;
+    }
+
+    if (mode === 'oneshot' && instance.endingBoundMs != null && Number.isFinite(instance.endingBoundMs)) {
+      instance.endingTimer = setTimeout(() => {
+        if (instance.state === 'ACTIVE') {
+          this.voices.delete(instance);
+          instance.transition('FINISHED');
+        }
+      }, instance.endingBoundMs);
+      if (typeof instance.endingTimer?.unref === 'function') instance.endingTimer.unref();
+    }
+
+    return instance;
+  }
+
+  stopAll() {
+    for (const instance of [...this.voices]) instance.stop();
+  }
+
+  async dispose() {
+    this.disposed = true;
+    this.ready = false;
+    this.capturePending?.reject(new Error('Audio disposed during output capture.'));
+    this.capturePending = null;
+    this.unsubscribeResolution?.();
+    this.unsubscribeResolution = null;
+    this.stopAll();
+    for (const instance of [...this.oneshotVoices]) instance.dispose();
+    for (const instance of [...this.continuousVoices]) instance.dispose();
+    this.disconnectMaster();
+    if (this.context) {
+      try { await this.context.close(); } catch { /* already closed */ }
+    }
+    this.context = null;
+    this.master = null;
+    this.protection = null;
+    if (this.ownsResolution) this.resolution.dispose();
+  }
+}
+
+const ACCEPTANCE_BUILD = {"runtimeSha256":"1c37267a90be4424b7160ee4c2c842e0ab634a3c58895aed435183244605a4a4","challengeSha256":"3ed7d017b126159a3e7f9b363d6853de184924a944b46eb90f2a62f131dd0c32","stressSha256":"bcdc07129d3401d64ac678bbd8f95110ddcc36944e5a1e6b1f6137cadabff875","workload":"phase3c4-overlap-v1","seed":42,"warmupSeconds":30,"measurementSeconds":120};
+const CHALLENGE = {
+  "xzbt": "0.1",
+  "meta": {
+    "id": "audio-challenge",
+    "name": "Audio Acceptance Challenge v1"
+  },
+  "runtime": {
+    "seed": 42
+  },
+  "sounds": {
+    "chirp": {
+      "name": "01 · Electronic chirp",
+      "recipe": {
+        "mode": "oneshot",
+        "release": "200ms",
+        "nodes": {
+          "hit": {
+            "type": "impulse",
+            "duration": "160ms",
+            "color": "white"
+          },
+          "ring": {
+            "type": "resonator",
+            "fundamental": 400,
+            "modes": [
+              {
+                "ratio": 1,
+                "decay": "80ms"
+              }
+            ]
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.4
+          }
+        },
+        "routes": [
+          {
+            "from": "hit",
+            "to": "ring"
+          },
+          {
+            "from": "ring",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ],
+        "automation": [
+          {
+            "target": "ring.fundamental",
+            "interpolation": "exponential",
+            "points": [
+              {
+                "at": "0ms",
+                "value": 400
+              },
+              {
+                "at": "160ms",
+                "value": 2400
+              }
+            ]
+          }
+        ]
+      }
+    },
+    "relay": {
+      "name": "02 · Relay / switch click",
+      "recipe": {
+        "mode": "oneshot",
+        "release": "200ms",
+        "nodes": {
+          "hit": {
+            "type": "impulse",
+            "duration": "3ms",
+            "color": "white"
+          },
+          "shape": {
+            "type": "filter",
+            "mode": "highpass",
+            "frequency": 1300,
+            "q": 1
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.3
+          }
+        },
+        "routes": [
+          {
+            "from": "hit",
+            "to": "shape"
+          },
+          {
+            "from": "shape",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ]
+      }
+    },
+    "siren": {
+      "name": "03 · Alarm / siren",
+      "recipe": {
+        "mode": "continuous",
+        "release": "200ms",
+        "nodes": {
+          "tone": {
+            "type": "oscillator",
+            "frequency": 650,
+            "waveform": "triangle"
+          },
+          "sweep": {
+            "type": "lfo",
+            "frequency": 0.7,
+            "polarity": "bipolar"
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.12
+          }
+        },
+        "routes": [
+          {
+            "from": "tone",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          },
+          {
+            "from": "sweep",
+            "to": "tone.frequency",
+            "depth": 250
+          }
+        ]
+      }
+    },
+    "airflow": {
+      "name": "04 · Airflow loop",
+      "recipe": {
+        "mode": "continuous",
+        "release": "200ms",
+        "nodes": {
+          "air": {
+            "type": "noise",
+            "color": "pink"
+          },
+          "shape": {
+            "type": "filter",
+            "mode": "lowpass",
+            "frequency": 1600,
+            "q": 0.7
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.25
+          }
+        },
+        "routes": [
+          {
+            "from": "air",
+            "to": "shape"
+          },
+          {
+            "from": "shape",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ]
+      }
+    },
+    "machinery": {
+      "name": "05 · Machinery drone",
+      "recipe": {
+        "mode": "continuous",
+        "release": "200ms",
+        "nodes": {
+          "low": {
+            "type": "oscillator",
+            "frequency": 65,
+            "waveform": "sawtooth"
+          },
+          "high": {
+            "type": "oscillator",
+            "frequency": 130.7,
+            "waveform": "triangle"
+          },
+          "shape": {
+            "type": "filter",
+            "mode": "lowpass",
+            "frequency": 400,
+            "q": 1
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.1
+          }
+        },
+        "routes": [
+          {
+            "from": "high",
+            "to": "shape"
+          },
+          {
+            "from": "low",
+            "to": "shape"
+          },
+          {
+            "from": "shape",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ]
+      }
+    },
+    "pressure": {
+      "name": "06 · Pressure release",
+      "recipe": {
+        "mode": "oneshot",
+        "release": "200ms",
+        "nodes": {
+          "hit": {
+            "type": "impulse",
+            "duration": "500ms",
+            "color": "white"
+          },
+          "shape": {
+            "type": "filter",
+            "mode": "bandpass",
+            "frequency": 2000,
+            "q": 0.7
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.4
+          }
+        },
+        "routes": [
+          {
+            "from": "hit",
+            "to": "shape"
+          },
+          {
+            "from": "shape",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ],
+        "automation": [
+          {
+            "target": "shape.frequency",
+            "interpolation": "linear",
+            "points": [
+              {
+                "at": "0ms",
+                "value": 3500
+              },
+              {
+                "at": "500ms",
+                "value": 500
+              }
+            ]
+          }
+        ]
+      }
+    },
+    "groan": {
+      "name": "07 · Structural groan",
+      "recipe": {
+        "mode": "oneshot",
+        "release": "200ms",
+        "nodes": {
+          "hit": {
+            "type": "impulse",
+            "duration": "400ms",
+            "color": "brown"
+          },
+          "body": {
+            "type": "resonator",
+            "fundamental": 95,
+            "modes": [
+              {
+                "ratio": 1,
+                "decay": "2s"
+              },
+              {
+                "ratio": 1.43,
+                "gain": 0.5,
+                "decay": "1500ms"
+              },
+              {
+                "ratio": 2.71,
+                "gain": 0.2,
+                "decay": "1s"
+              }
+            ]
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.4
+          }
+        },
+        "routes": [
+          {
+            "from": "hit",
+            "to": "body"
+          },
+          {
+            "from": "body",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ],
+        "automation": [
+          {
+            "target": "body.fundamental",
+            "interpolation": "linear",
+            "points": [
+              {
+                "at": "0ms",
+                "value": 95
+              },
+              {
+                "at": "2s",
+                "value": 55
+              }
+            ]
+          }
+        ]
+      }
+    },
+    "electrical": {
+      "name": "08 · Electrical buzz / arcing",
+      "recipe": {
+        "mode": "continuous",
+        "release": "200ms",
+        "nodes": {
+          "buzz": {
+            "type": "oscillator",
+            "frequency": 120,
+            "waveform": "sawtooth"
+          },
+          "arc": {
+            "type": "noise",
+            "color": "white"
+          },
+          "shape": {
+            "type": "filter",
+            "mode": "highpass",
+            "frequency": 1500,
+            "q": 1
+          },
+          "steps": {
+            "type": "sample-hold",
+            "rate": 14,
+            "min": 0,
+            "max": 1,
+            "slew": "5ms"
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.035
+          }
+        },
+        "routes": [
+          {
+            "from": "arc",
+            "to": "shape"
+          },
+          {
+            "from": "shape",
+            "to": "level"
+          },
+          {
+            "from": "buzz",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          },
+          {
+            "from": "steps",
+            "to": "level.gain",
+            "depth": 0.06
+          }
+        ]
+      }
+    },
+    "impact": {
+      "name": "09 · Impact transient",
+      "recipe": {
+        "mode": "oneshot",
+        "release": "200ms",
+        "nodes": {
+          "hit": {
+            "type": "impulse",
+            "duration": "12ms",
+            "color": "white"
+          },
+          "body": {
+            "type": "resonator",
+            "fundamental": 110,
+            "modes": [
+              {
+                "ratio": 1,
+                "decay": "600ms"
+              },
+              {
+                "ratio": 2.7,
+                "gain": 0.4,
+                "decay": "200ms"
+              }
+            ]
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.5
+          }
+        },
+        "routes": [
+          {
+            "from": "hit",
+            "to": "body"
+          },
+          {
+            "from": "body",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ]
+      }
+    },
+    "sequence": {
+      "name": "10 · Tonal sequence",
+      "recipe": {
+        "mode": "continuous",
+        "release": "200ms",
+        "nodes": {
+          "tone": {
+            "type": "oscillator",
+            "frequency": 261.63,
+            "waveform": "sine"
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.13
+          }
+        },
+        "routes": [
+          {
+            "from": "tone",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ],
+        "automation": [
+          {
+            "target": "tone.frequency",
+            "interpolation": "step",
+            "points": [
+              {
+                "at": "0ms",
+                "value": 261.63
+              },
+              {
+                "at": "300ms",
+                "value": 329.63
+              },
+              {
+                "at": "600ms",
+                "value": 392
+              },
+              {
+                "at": "900ms",
+                "value": 523.25
+              }
+            ]
+          },
+          {
+            "target": "level.gain",
+            "interpolation": "linear",
+            "points": [
+              {
+                "at": "0ms",
+                "value": 0
+              },
+              {
+                "at": "15ms",
+                "value": 0.13
+              },
+              {
+                "at": "1100ms",
+                "value": 0.13
+              },
+              {
+                "at": "1200ms",
+                "value": 0
+              }
+            ]
+          }
+        ]
+      }
+    },
+    "breathing": {
+      "name": "11 · Organic pulse / breathing",
+      "recipe": {
+        "mode": "continuous",
+        "release": "200ms",
+        "nodes": {
+          "air": {
+            "type": "noise",
+            "color": "pink"
+          },
+          "shape": {
+            "type": "filter",
+            "mode": "lowpass",
+            "frequency": 900,
+            "q": 0.7
+          },
+          "breath": {
+            "type": "lfo",
+            "frequency": 0.22,
+            "polarity": "unipolar"
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.02
+          }
+        },
+        "routes": [
+          {
+            "from": "air",
+            "to": "shape"
+          },
+          {
+            "from": "shape",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          },
+          {
+            "from": "breath",
+            "to": "level.gain",
+            "depth": 0.3
+          }
+        ]
+      }
+    },
+    "atmosphere": {
+      "name": "12 · Evolving atmospheric texture",
+      "recipe": {
+        "mode": "continuous",
+        "release": "200ms",
+        "nodes": {
+          "air": {
+            "type": "noise",
+            "color": "brown"
+          },
+          "tone": {
+            "type": "oscillator",
+            "frequency": 180,
+            "waveform": "sine"
+          },
+          "shape": {
+            "type": "filter",
+            "mode": "bandpass",
+            "frequency": 400,
+            "q": 0.6
+          },
+          "space": {
+            "type": "reverb",
+            "decay": "4s",
+            "mix": 0.6
+          },
+          "level": {
+            "type": "gain",
+            "gain": 0.15
+          }
+        },
+        "routes": [
+          {
+            "from": "tone",
+            "to": "shape"
+          },
+          {
+            "from": "air",
+            "to": "shape"
+          },
+          {
+            "from": "shape",
+            "to": "space"
+          },
+          {
+            "from": "space",
+            "to": "level"
+          },
+          {
+            "from": "level",
+            "to": "output"
+          }
+        ],
+        "automation": [
+          {
+            "target": "shape.frequency",
+            "interpolation": "smooth",
+            "points": [
+              {
+                "at": "0ms",
+                "value": 250
+              },
+              {
+                "at": "10s",
+                "value": 2000
+              },
+              {
+                "at": "25s",
+                "value": 450
+              }
+            ]
+          },
+          {
+            "target": "tone.frequency",
+            "interpolation": "smooth",
+            "points": [
+              {
+                "at": "0ms",
+                "value": 180
+              },
+              {
+                "at": "25s",
+                "value": 270
+              }
+            ]
+          }
+        ]
+      }
+    }
+  }
+}
+;
+const STRESS = {
+  "xzbt": "0.1",
+  "meta": {
+    "id": "audio-protection-stress",
+    "name": "Master Protection Overlap v1"
+  },
+  "runtime": {
+    "seed": 42
+  },
+  "audio": {
+    "buses": {
+      "load": {
+        "gain": 4
+      }
+    }
+  },
+  "sounds": {
+    "bed": {
+      "name": "Continuous overload",
+      "recipe": {
+        "mode": "continuous",
+        "release": "200ms",
+        "nodes": {
+          "tone": {
+            "type": "oscillator",
+            "frequency": 110,
+            "waveform": "square"
+          },
+          "boost": {
+            "type": "gain",
+            "gain": 4
+          }
+        },
+        "routes": [
+          {
+            "from": "tone",
+            "to": "boost"
+          },
+          {
+            "from": "boost",
+            "to": "output"
+          }
+        ]
+      },
+      "bus": "load"
+    },
+    "hit": {
+      "name": "Overlapping transient",
+      "recipe": {
+        "mode": "oneshot",
+        "release": "200ms",
+        "nodes": {
+          "hit": {
+            "type": "impulse",
+            "duration": "500ms",
+            "color": "white"
+          },
+          "boost": {
+            "type": "gain",
+            "gain": 4
+          },
+          "echo": {
+            "type": "delay",
+            "time": "50ms",
+            "feedback": 0.2,
+            "mix": 0.5
+          }
+        },
+        "routes": [
+          {
+            "from": "hit",
+            "to": "boost"
+          },
+          {
+            "from": "boost",
+            "to": "echo"
+          },
+          {
+            "from": "echo",
+            "to": "output"
+          }
+        ]
+      },
+      "bus": "load"
+    }
+  }
+}
+;
+// Bundled by build-audio-acceptance.mjs with the production runtime and fixtures.
+const acceptanceElement = id => document.getElementById(id);
+let acceptanceAudio = null, acceptanceTimer = null, acceptanceRunning = false;
+let acceptanceMeasurement = null, acceptanceDiagnostics = null;
+const acceptanceListeningLog = [];
+const acceptanceStatus = message => { acceptanceElement('state').textContent = message; };
+function acceptanceLock(running) {
+  acceptanceRunning = running;
+  acceptanceElement('capture').disabled = running;
+  for (const button of acceptanceElement('sounds').querySelectorAll('button')) button.disabled = running;
+  for (const id of ['release', 'pause', 'resume']) acceptanceElement(id).disabled = running;
+}
+async function acceptanceStop() {
+  clearInterval(acceptanceTimer); acceptanceTimer = null;
+  const previous = acceptanceAudio; acceptanceAudio = null;
+  if (previous?.context) previous.context.onstatechange = null;
+  await previous?.dispose();
+}
+function acceptanceMakeAudio(fixture) {
+  const result = validateExhibit(fixture);
+  if (!result.valid) throw new Error(JSON.stringify(result.errors));
+  acceptanceDiagnostics = new Diagnostics();
+  const audio = new AudioSubsystem({ document: fixture, rng: new SeededRNG(42), diagnostics: acceptanceDiagnostics });
+  audio.setMasterVolume(1);
+  acceptanceAudio = audio;
+  return audio;
+}
+function acceptanceEnvironment() {
+  return {
+    notes: acceptanceElement('environment').value,
+    userAgent: navigator.userAgent,
+    viewport: { width: innerWidth, height: innerHeight },
+    devicePixelRatio, hardwareConcurrency: navigator.hardwareConcurrency,
+    deviceMemoryGiB: navigator.deviceMemory ?? null,
+    protocol: location.protocol
+  };
+}
+acceptanceElement('build').textContent = JSON.stringify(ACCEPTANCE_BUILD, null, 2);
+acceptanceElement('capture').onclick = async () => {
+  acceptanceLock(true);
+  acceptanceMeasurement = null;
+  acceptanceElement('measurement').textContent = 'Initializing protected audio…';
+  await acceptanceStop();
+  let audio;
+  try {
+    audio = acceptanceMakeAudio(STRESS);
+    if (!await audio.unlock()) throw new Error('Protected audio could not start. See diagnostics in the report.');
+    const context = audio.context, bursts = [], start = context.currentTime;
+    context.onstatechange = () => {
+      if (context.state !== 'running') void acceptanceStop();
+    };
+    const environment = acceptanceEnvironment();
+    for (let i = 0; i < 16; i++) if (!audio.play('bed')) throw new Error('Continuous stress voice refused.');
+    const capture = audio.captureOutput();
+    // Attach a rejection handler immediately, including synchronous burst failures.
+    capture.catch(() => {});
+    const burst = () => {
+      for (let i = 0; i < 64; i++) if (!audio.play('hit')) throw new Error('Transient stress voice refused.');
+      bursts.push({ seconds: context.currentTime - start, oneshots: audio.oneshotVoices.size, continuous: audio.continuousVoices.size,
+        expandedGraphNodes: [...audio.oneshotVoices, ...audio.continuousVoices].reduce((count, voice) => count + (voice.plan?.nodes.length ?? 0), 0) });
+      const elapsed = context.currentTime - start;
+      acceptanceStatus(elapsed < 30 ? `Warming up · ${elapsed.toFixed(0)} / 30 seconds` : `Capturing · ${(elapsed - 30).toFixed(0)} / 120 seconds`);
+    };
+    burst();
+    acceptanceTimer = setInterval(() => {
+      try { burst(); } catch (error) { acceptanceStatus(error.message); void acceptanceStop(); }
+    }, 2000);
+    const result = await capture;
+    const peakDb = result.peak > 0 ? 20 * Math.log10(result.peak) : null;
+    acceptanceMeasurement = {
+      capturedAt: new Date().toISOString(), environment, ...result, peakDb,
+      ceilingDb: AUDIO_PROTECTION.ceilingDb, toleranceDb: AUDIO_PROTECTION.toleranceDb,
+      lookaheadFrames: Math.ceil(context.sampleRate * AUDIO_PROTECTION.lookaheadMs / 1000),
+      baseLatency: context.baseLatency ?? null, outputLatency: context.outputLatency ?? null,
+      bursts, maxBurstGapSeconds: Math.max(0, ...bursts.slice(1).map((item, i) => item.seconds - bursts[i].seconds)),
+      candidateDigitalPeakPass: result.peak > 0.01 && peakDb <= AUDIO_PROTECTION.ceilingDb + AUDIO_PROTECTION.toleranceDb && result.affectedBlocks === 0,
+      diagnostics: acceptanceDiagnostics.list(),
+      acceptance: 'Pending user review of workload timing, environment, listening, and production reference/challenge runs.'
+    };
+    acceptanceElement('measurement').textContent = JSON.stringify(acceptanceMeasurement, null, 2);
+    acceptanceStatus('Digital capture finished. Record listening observations and download the report.');
+  } catch (error) {
+    acceptanceMeasurement = { interrupted: true, reason: error.message, diagnostics: acceptanceDiagnostics?.list() ?? [] };
+    acceptanceElement('measurement').textContent = JSON.stringify(acceptanceMeasurement, null, 2);
+    acceptanceStatus(`Capture incomplete: ${error.message}`);
+  } finally {
+    await acceptanceStop();
+    acceptanceLock(false);
+  }
+};
+acceptanceElement('cancel').onclick = async () => {
+  await acceptanceStop();
+  acceptanceListeningLog.push({ action: 'stop', at: new Date().toISOString() });
+  acceptanceStatus('Audio stopped.');
+};
+for (const [id, sound] of Object.entries(CHALLENGE.sounds)) {
+  const button = document.createElement('button'); button.textContent = sound.name;
+  button.onclick = async () => {
+    try {
+      if (!acceptanceAudio) acceptanceMakeAudio(CHALLENGE);
+      const audio = acceptanceAudio;
+      if (!await audio.unlock()) throw new Error('Protected audio could not start.');
+      if (!audio.play(id)) throw new Error('Voice could not start; release or stop existing voices.');
+      acceptanceListeningLog.push({ action: 'play', sound: id, at: new Date().toISOString() });
+      acceptanceStatus(`Playing ${sound.name}.`);
+    } catch (error) { acceptanceStatus(error.message); }
+  };
+  acceptanceElement('sounds').append(button);
+}
+acceptanceElement('release').onclick = () => {
+  acceptanceAudio?.stopAll();
+  acceptanceListeningLog.push({ action: 'release', at: new Date().toISOString() });
+  acceptanceStatus('All voices releasing.');
+};
+for (const [id, method] of [['pause', 'suspend'], ['resume', 'resume']]) {
+  acceptanceElement(id).onclick = async () => {
+    try {
+      await acceptanceAudio?.context?.[method]();
+      acceptanceListeningLog.push({ action: id, at: new Date().toISOString() });
+      acceptanceStatus(id === 'pause' ? 'Audio paused.' : 'Audio resumed.');
+    } catch (error) { acceptanceStatus(error.message); }
+  };
+}
+document.addEventListener('visibilitychange', () => {
+  if (document.hidden && acceptanceRunning) void acceptanceStop();
+});
+acceptanceElement('save').onclick = () => {
+  const report = { build: ACCEPTANCE_BUILD, exportedAt: new Date().toISOString(), environment: acceptanceEnvironment(),
+    measurement: acceptanceMeasurement, listeningLog: acceptanceListeningLog,
+    listeningObservations: acceptanceElement('observations').value, diagnostics: acceptanceDiagnostics?.list() ?? [],
+    phase3Acceptance: 'Pending user review; this report does not automatically close GC6 or PRD 129.' };
+  const url = URL.createObjectURL(new Blob([JSON.stringify(report, null, 2)], { type: 'application/json' }));
+  const anchor = document.createElement('a'); anchor.href = url; anchor.download = 'xzbt-phase3c4-evidence.json'; anchor.click();
+  setTimeout(() => URL.revokeObjectURL(url), 1000);
+};
+
+})();</script></body></html>
diff --git a/prototypes/phase3/acceptance.template.html b/prototypes/phase3/acceptance.template.html
new file mode 100644
index 0000000..d781048
--- /dev/null
+++ b/prototypes/phase3/acceptance.template.html
@@ -0,0 +1,32 @@
+<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>XZBT audio acceptance</title>
+<style>
+  :root { color-scheme: dark; font: 16px/1.5 system-ui,sans-serif; background: #10161e; color: #e3ebf4; }
+  body { max-width: 1000px; margin: 32px auto; padding: 0 24px; } h1 { margin-bottom: 8px; }
+  section { border: 1px solid #3d4c5e; border-radius: 10px; padding: 20px; margin: 24px 0; }
+  button { font: inherit; background: #284763; color: white; border: 1px solid #748da6; border-radius: 6px; padding: 8px 12px; margin: 4px; cursor: pointer; }
+  button:disabled { opacity: .45; cursor: default; } textarea { box-sizing: border-box; width: 100%; min-height: 110px; font: inherit; padding: 10px; background: #172331; color: inherit; }
+  label { display: block; margin-top: 14px; } pre { overflow-wrap: anywhere; white-space: pre-wrap; background: #172331; padding: 14px; } #state { color: #b7dfec; } small { color: #bcc9d7; }
+</style></head><body>
+<h1>Audio acceptance · Phase 3c slice 4</h1>
+<p>This page embeds the production audio engine and frozen exhibit fixtures. Open it directly from disk in Chrome. Results measure samples at the final worklet output; device playback and listening must be recorded separately.</p>
+<p id="state" role="status" aria-live="polite">Ready. Audio starts only when you press a button.</p>
+<section><h2>1. Record the environment</h2>
+<p>Use a 1920 × 1080 viewport for GC6. Start with a low device volume: the overlap test deliberately drives the engine at full master and bus gain.</p>
+<label for="environment">Computer, CPU, GPU/driver, RAM, OS, exact browser version, power mode, audio device and OS volume</label>
+<textarea id="environment" placeholder="Record the reference computer and output device here."></textarea>
+</section>
+<section><h2>2. Capture overlapping recipes</h2>
+<p>16 continuous voices and bursts of 64 one-shots. Warm up for 30 seconds, then capture 120 seconds on the audio clock. Keep this page visible. The report includes actual burst times and voice counts; any interrupted run is invalid.</p>
+<button id="capture">Run 150-second peak capture</button><button id="cancel">Stop audio / cancel capture</button>
+<pre id="measurement">No measurement yet.</pre>
+</section>
+<section><h2>3. Listen to the audio challenge</h2>
+<p>Each button plays a declarative recipe from audio-challenge.xzbt. Layer continuous sounds, then release them; listen for clicks, clipping and pumping. The gain recovery time constant is 250 ms, with 5 ms lookahead. These are candidate settings awaiting listening acceptance.</p>
+<div id="sounds"></div><button id="release">Release all voices</button><button id="pause">Pause audio</button><button id="resume">Resume audio</button>
+<label for="observations">Listening results</label>
+<textarea id="observations" placeholder="For each of the 12 sounds: recognizable / needs work, clicks, clipping, pumping. Also record overlap, release, eviction, unlock, pause/resume, reference exhibits A/B, and any audio glitches. Unperformed checks stay pending."></textarea>
+<p><small>The reference exhibits and current-logical-time GC4 unlock checks require their own production runs. This capture page does not certify them.</small></p>
+</section>
+<section><h2>4. Save the evidence</h2><button id="save">Download JSON report</button><pre id="build"></pre></section>
+<script>/*__ACCEPTANCE_SCRIPT__*/</script></body></html>
diff --git a/src/runtime/audio-contract.js b/src/runtime/audio-contract.js
index f99a336..e34459a 100644
--- a/src/runtime/audio-contract.js
+++ b/src/runtime/audio-contract.js
@@ -4,6 +4,16 @@
 export const AUDIO_STATIC_MAX_FREQUENCY = 24000;
 export const AUDIO_NYQUIST_FACTOR = 0.45;
 
+// Engine-owned candidate values; hardware/listening acceptance remains GC6.
+export const AUDIO_PROTECTION = Object.freeze({
+  ceilingDb: -1,
+  toleranceDb: 0.1,
+  lookaheadMs: 5,
+  attackMs: 0.5,
+  releaseMs: 250,
+  channels: 2
+});
+
 export const AUDIO_LIMITS = Object.freeze({
   nodesPerSound: 128,
   routesPerSound: 256,
diff --git a/src/runtime/audio-engine.js b/src/runtime/audio-engine.js
index d84d725..4d8b113 100644
--- a/src/runtime/audio-engine.js
+++ b/src/runtime/audio-engine.js
@@ -19,6 +19,7 @@ import {
 } from './audio-graph.js';
 import { applyAutomationMode, sampleAutomationTrack } from './audio-automation.js';
 import { createAudioControls } from './audio-controls.js';
+import { createProtectionNode, loadProtectionWorklet } from './audio-protection.js';
 import { ValueResolver } from './values.js';
 import { ResolutionEngine } from './resolution.js';
 import { SeededRNG } from './rng.js';
@@ -576,7 +577,10 @@ export class SoundInstance {
   }
 
   realize(context, destination) {
-    this.realized = realizeSoundGraph(context, this.plan, destination);
+    const guard = this.subsystem?.createVoiceGuard(this);
+    this.guard = guard;
+    if (guard) guard.connect(destination);
+    this.realized = realizeSoundGraph(context, this.plan, guard ?? destination);
     return this.realized;
   }
 
@@ -685,6 +689,13 @@ export class SoundInstance {
       this.realized = null;
     }
     this.plan = null;
+    if (this.guard) {
+      this.guard.port.onmessage = null;
+      this.guard.onprocessorerror = null;
+      this.guard.port.close();
+      this.guard.disconnect();
+      this.guard = null;
+    }
     this.bus = null;
     this.context = null;
   }
@@ -695,11 +706,11 @@ export class SoundInstance {
  * ------------------------------------------------------------------ */
 
 // Owns the AudioContext, the declared buses, and the engine master chain, and turns a
-// sound definition into a realized voice. The lifecycle state machine (PRD 57), voice
-// ceilings (16.6), and the measured master-protection contract (PRD 58) are Phase 3c;
-// the master chain built here is engine-owned and unbypassable.
+// sound definition into a realized voice. All buses and volume controls are upstream
+// of the final protection worklet; hardware/listening acceptance is tracked in GC6.
 export class AudioSubsystem {
-  constructor({ document, rng, diagnostics = null, contextFactory = null, voiceLimits = null, resolutionEngine = null } = {}) {
+  constructor({ document, rng, diagnostics = null, contextFactory = null, voiceLimits = null, resolutionEngine = null,
+    protectionFactory = { load: loadProtectionWorklet, create: createProtectionNode } } = {}) {
     this.document = document;
     this.rng = rng;
     this.diagnostics = diagnostics;
@@ -719,6 +730,13 @@ export class AudioSubsystem {
     this.ordinals = new Map();
     this.nextCreationOrder = 0;
     this.masterVolume = 0.8;
+    this.protectionFactory = protectionFactory;
+    this.ready = false;
+    this.disposed = false;
+    this.unlockPending = null;
+    this.capturePending = null;
+    this.captureSequence = 0;
+    this.unavailableWarned = false;
   }
 
   get available() {
@@ -726,35 +744,123 @@ export class AudioSubsystem {
   }
 
   get unlocked() {
-    return this.context !== null && this.context.state === 'running';
+    return this.ready && this.context !== null && this.context.state === 'running';
   }
 
   // Must be called from a user gesture; browsers refuse to start audio otherwise.
   async unlock() {
-    if (!this.available) {
-      this.diagnostics?.warn('WARN_AUDIO_UNAVAILABLE', 'This browser exposes no AudioContext; audio is disabled.', { section: 'audio' });
-      return false;
-    }
-    if (!this.context) {
-      this.context = this.contextFactory();
-      this.buildMaster();
-      this.buildBuses();
-    }
-    if (this.context.state === 'suspended') await this.context.resume();
-    return this.unlocked;
+    if (this.disposed) return false;
+    if (this.unlockPending) return this.unlockPending;
+    this.unlockPending = this.initializeAudio();
+    try { return await this.unlockPending; }
+    finally { this.unlockPending = null; }
   }
 
-  buildMaster() {
+  async initializeAudio() {
+    try {
+      if (this.protectionFailed) throw new Error('Master protection failed; reactivate the exhibit to restart audio.');
+      if (!this.available) throw new Error('This browser exposes no AudioContext.');
+      if (!this.context) this.context = this.contextFactory();
+      const context = this.context;
+      // Resume synchronously with the gesture before awaiting module loading.
+      const resume = context.state === 'suspended' ? context.resume() : Promise.resolve();
+      await Promise.all([resume, this.ready ? Promise.resolve() : this.buildMaster()]);
+      if (this.disposed || this.context !== context) return false;
+      if (context.state !== 'running') throw new Error('The audio context did not enter the running state.');
+      if (!this.ready) this.buildBuses();
+      this.ready = true;
+      return this.unlocked;
+    } catch (error) {
+      this.ready = false;
+      for (const instance of [...this.oneshotVoices, ...this.continuousVoices]) instance.dispose();
+      this.disconnectMaster();
+      const context = this.context;
+      this.context = null;
+      try { await context?.close(); } catch { /* already closed */ }
+      if (!this.unavailableWarned && !this.disposed) {
+        this.unavailableWarned = true;
+        this.diagnostics?.warn('WARN_AUDIO_UNAVAILABLE', `Audio disabled: ${error.message}`, { section: 'audio' });
+      }
+      return false;
+    }
+  }
+
+  async buildMaster() {
     const context = this.context;
-    this.protection = context.createDynamicsCompressor();
-    this.protection.threshold.value = -3;
-    this.protection.knee.value = 0;
-    this.protection.ratio.value = 20;
-    this.protection.attack.value = 0.003;
-    this.protection.release.value = 0.25;
+    await this.protectionFactory.load(context);
+    if (this.disposed || this.context !== context) return;
+    this.protection = this.protectionFactory.create(context, false);
+    this.protection.port.onmessage = ({ data }) => {
+      if (data.type === 'nonfinite') this.warnNonfinite('master');
+      if (data.type === 'capture' && data.id === this.capturePending?.id) {
+        const pending = this.capturePending;
+        this.capturePending = null;
+        pending.resolve(data);
+      }
+    };
+    this.protection.onprocessorerror = () => {
+      this.ready = false;
+      this.protectionFailed = true;
+      this.capturePending?.reject(new Error('Master protection processor failed.'));
+      this.capturePending = null;
+      this.protection?.disconnect();
+      this.diagnostics?.warn('WARN_AUDIO_UNAVAILABLE', 'Master protection failed; output is muted.', { section: 'audio' });
+    };
     this.master = context.createGain();
     this.master.gain.value = this.masterVolume;
-    this.protection.connect(this.master).connect(context.destination);
+    this.master.connect(this.protection).connect(context.destination);
+  }
+
+  warnNonfinite(instanceId) {
+    this.diagnostics?.warn('WARN_AUDIO_NONFINITE', 'A non-finite audio sample was detected; the containing output block was muted.', { section: 'audio', objectId: instanceId });
+  }
+
+  createVoiceGuard(instance) {
+    const guard = this.protectionFactory.create(this.context, true);
+    const instanceId = instance.plan?.instanceKey ?? soundInstanceKey(instance.soundId, instance.creationOrder);
+    guard.port.onmessage = ({ data }) => {
+      if (data.type === 'nonfinite') this.warnNonfinite(instanceId);
+    };
+    guard.onprocessorerror = () => {
+      instance.dispose();
+      this.diagnostics?.warn('WARN_AUDIO_UNAVAILABLE', `Audio guard failed for '${instance.soundId}'; voice disposed.`, { section: 'audio', objectId: instance.soundId });
+    };
+    try { guard.connect(this.protection, 1, 1); }
+    catch (error) {
+      guard.port.onmessage = null;
+      guard.onprocessorerror = null;
+      guard.port.close();
+      guard.disconnect();
+      throw error;
+    }
+    return guard;
+  }
+
+  captureOutput({ seconds = 120, warmupSeconds = 30 } = {}) {
+    if (!this.unlocked) return Promise.reject(new Error('Unlock protected audio before capturing.'));
+    if (this.capturePending) return Promise.reject(new Error('An output capture is already running.'));
+    if (!Number.isFinite(seconds) || seconds <= 0 || !Number.isFinite(warmupSeconds) || warmupSeconds < 0) return Promise.reject(new Error('Invalid capture duration.'));
+    return new Promise((resolve, reject) => {
+      const id = ++this.captureSequence;
+      this.capturePending = { id, resolve, reject };
+      this.protection.port.postMessage({ type: 'capture', id,
+        frames: Math.max(1, Math.round(seconds * this.context.sampleRate)),
+        warmupFrames: Math.round(warmupSeconds * this.context.sampleRate) });
+    });
+  }
+
+  disconnectMaster() {
+    for (const bus of this.buses.values()) bus.disconnect();
+    this.buses.clear();
+    this.master?.disconnect();
+    if (this.protection) {
+      this.protection.port.onmessage = null;
+      this.protection.port.close();
+      this.protection.onprocessorerror = null;
+      this.protection.disconnect();
+    }
+    this.master = null;
+    this.protection = null;
   }
 
   buildBuses() {
@@ -762,14 +868,14 @@ export class AudioSubsystem {
     for (const id of Object.keys(declared)) {
       const gain = this.context.createGain();
       gain.gain.value = this.resolution.get(`audio.buses.${id}.gain`);
-      gain.connect(this.protection);
+      gain.connect(this.master);
       this.buses.set(id, gain);
     }
   }
 
   busFor(soundId) {
     const name = this.document?.sounds?.[soundId]?.bus;
-    return (name && this.buses.get(name)) || this.protection;
+    return (name && this.buses.get(name)) || this.master;
   }
 
   setBusGain(id, value) {
@@ -781,6 +887,7 @@ export class AudioSubsystem {
   }
 
   setMasterVolume(value) {
+    if (!Number.isFinite(value)) return;
     this.masterVolume = Math.min(1, Math.max(0, value));
     if (this.master) this.master.gain.value = this.masterVolume;
   }
@@ -898,12 +1005,16 @@ export class AudioSubsystem {
   }
 
   async dispose() {
+    this.disposed = true;
+    this.ready = false;
+    this.capturePending?.reject(new Error('Audio disposed during output capture.'));
+    this.capturePending = null;
     this.unsubscribeResolution?.();
     this.unsubscribeResolution = null;
     this.stopAll();
     for (const instance of [...this.oneshotVoices]) instance.dispose();
     for (const instance of [...this.continuousVoices]) instance.dispose();
-    this.buses.clear();
+    this.disconnectMaster();
     if (this.context) {
       try { await this.context.close(); } catch { /* already closed */ }
     }
diff --git a/src/runtime/audio-protection.js b/src/runtime/audio-protection.js
new file mode 100644
index 0000000..9a43b36
--- /dev/null
+++ b/src/runtime/audio-protection.js
@@ -0,0 +1,139 @@
+import { AUDIO_PROTECTION } from './audio-contract.js';
+
+// This exact class is serialized into the embedded worklet and exercised in tests.
+// No browser globals or imports are used by the DSP core.
+export class MasterProtectionDSP {
+  constructor(rate, settings) {
+    this.ceiling = 10 ** (settings.ceilingDb / 20);
+    this.delayFrames = Math.max(1, Math.ceil(rate * settings.lookaheadMs / 1000));
+    this.delay = Array.from({ length: settings.channels }, () => new Float32Array(this.delayFrames));
+    this.attack = Math.exp(-1 / (rate * settings.attackMs / 1000));
+    this.release = Math.exp(-1 / (rate * settings.releaseMs / 1000));
+    this.position = 0;
+    this.gain = 1;
+    this.heldPeak = 0;
+    this.hold = 0;
+    this.affectedBlocks = 0;
+  }
+
+  process(input, output, fault = false) {
+    let badSamples = 0;
+    for (const channel of input) for (const sample of channel) if (!Number.isFinite(sample)) badSamples++;
+    const muted = fault || badSamples > 0;
+    if (muted) {
+      // Flush pending audio as well: no corrupted history can reappear later.
+      for (const channel of this.delay) channel.fill(0);
+      for (const channel of output) channel.fill(0);
+      this.heldPeak = 0;
+      this.hold = 0;
+      this.affectedBlocks++;
+      return { muted, badSamples, peak: 0, clampedSamples: 0 };
+    }
+    let peak = 0, clampedSamples = 0;
+    for (let i = 0; i < output[0].length; i++) {
+      let incomingPeak = 0;
+      for (const channel of input) incomingPeak = Math.max(incomingPeak, Math.abs(channel[i] ?? 0));
+      if (incomingPeak >= this.heldPeak) {
+        this.heldPeak = incomingPeak;
+        this.hold = this.delayFrames;
+      } else if (this.hold > 0) this.hold--;
+      else this.heldPeak = incomingPeak;
+      const target = this.heldPeak > this.ceiling ? this.ceiling / this.heldPeak : 1;
+      const coefficient = target < this.gain ? this.attack : this.release;
+      this.gain = target + coefficient * (this.gain - target);
+      for (let c = 0; c < output.length; c++) {
+        const delayed = this.delay[c][this.position];
+        this.delay[c][this.position] = input[c]?.[i] ?? 0;
+        const value = delayed * this.gain;
+        if (Math.abs(value) > this.ceiling) clampedSamples++;
+        // Final sample clamp is required even during attack and extreme overload.
+        output[c][i] = Math.max(-this.ceiling, Math.min(this.ceiling, value));
+        peak = Math.max(peak, Math.abs(output[c][i]));
+      }
+      this.position = (this.position + 1) % this.delayFrames;
+    }
+    return { muted, badSamples, peak, clampedSamples };
+  }
+}
+
+export function protectionWorkletSource() {
+  return `const SETTINGS = ${JSON.stringify(AUDIO_PROTECTION)};
+${MasterProtectionDSP.toString()}
+class XZBTProtectionProcessor extends AudioWorkletProcessor {
+  constructor(options) {
+    super();
+    this.guard = options.processorOptions?.guard === true;
+    this.dsp = this.guard ? null : new MasterProtectionDSP(sampleRate, SETTINGS);
+    this.warned = false;
+    this.capture = null;
+    this.port.onmessage = ({ data }) => {
+      if (data.type === 'capture' && !this.guard) {
+        this.capture = { id: data.id, skip: data.warmupFrames, remaining: data.frames,
+          frames: 0, peak: 0, affectedBlocks: 0, nonfiniteSamples: 0, clampedSamples: 0 };
+      }
+    };
+  }
+  process(inputs, outputs) {
+    const input = inputs[0] ?? [], output = outputs[0];
+    let result;
+    if (this.guard) {
+      let badSamples = 0;
+      for (const channel of input) for (const sample of channel) if (!Number.isFinite(sample)) badSamples++;
+      for (let c = 0; c < output.length; c++) {
+        output[c].fill(0);
+        if (!badSamples && input[c]) output[c].set(input[c]);
+      }
+      // Separate finite fault lane lets the final master mute the same whole
+      // render quantum, while attribution remains attached to this voice.
+      outputs[1][0].fill(badSamples);
+      result = { badSamples, muted: badSamples > 0 };
+    } else {
+      const fault = (inputs[1] ?? []).some(channel => channel.some(value => value !== 0));
+      result = this.dsp.process(input, output, fault);
+      const capture = this.capture;
+      if (capture) {
+        const start = Math.min(capture.skip, output[0].length);
+        capture.skip -= start;
+        const count = Math.min(capture.remaining, output[0].length - start);
+        if (count > 0) {
+          for (const channel of output) for (let i = start; i < start + count; i++) capture.peak = Math.max(capture.peak, Math.abs(channel[i]));
+          capture.frames += count;
+          capture.remaining -= count;
+          capture.affectedBlocks += result.muted ? 1 : 0;
+          capture.nonfiniteSamples += result.badSamples + (inputs[1]?.[0]?.[0] ?? 0);
+          capture.clampedSamples += result.clampedSamples;
+        }
+        if (capture.remaining === 0) {
+          this.port.postMessage({ type: 'capture', ...capture, sampleRate });
+          this.capture = null;
+        }
+      }
+    }
+    if (result.badSamples > 0 && !this.warned) {
+      this.warned = true;
+      this.port.postMessage({ type: 'nonfinite' });
+    }
+    return true;
+  }
+}
+registerProcessor('xzbt-protection', XZBTProtectionProcessor);`;
+}
+
+export async function loadProtectionWorklet(context) {
+  if (!context.audioWorklet || typeof globalThis.AudioWorkletNode !== 'function') {
+    throw new Error('AudioWorklet master protection is unavailable.');
+  }
+  // The Phase 0 direct-file probe verified this embedded data-URL loading path.
+  await context.audioWorklet.addModule(`data:text/javascript;charset=utf-8,${encodeURIComponent(protectionWorkletSource())}`);
+}
+
+export function createProtectionNode(context, guard = false) {
+  return new AudioWorkletNode(context, 'xzbt-protection', {
+    numberOfInputs: guard ? 1 : 2,
+    numberOfOutputs: guard ? 2 : 1,
+    outputChannelCount: guard ? [AUDIO_PROTECTION.channels, 1] : [AUDIO_PROTECTION.channels],
+    channelCount: AUDIO_PROTECTION.channels,
+    channelCountMode: 'explicit',
+    processorOptions: { guard }
+  });
+}
diff --git a/test/helpers/protection-fake.mjs b/test/helpers/protection-fake.mjs
new file mode 100644
index 0000000..3478127
--- /dev/null
+++ b/test/helpers/protection-fake.mjs
@@ -0,0 +1,10 @@
+// Recording tests inject this explicitly. Production never substitutes a gain for
+// protection when AudioWorklet is missing; DSP tests execute the real processor.
+export const fakeProtectionFactory = {
+  async load() {},
+  create(context) {
+    const node = context.createGain();
+    node.port = { onmessage: null, postMessage() {}, close() {} };
+    return node;
+  }
+};
diff --git a/test/phase3-audio.test.mjs b/test/phase3-audio.test.mjs
index 1e67ceb..0c34125 100644
--- a/test/phase3-audio.test.mjs
+++ b/test/phase3-audio.test.mjs
@@ -1,3 +1,4 @@
+import { fakeProtectionFactory } from './helpers/protection-fake.mjs';
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import {
@@ -485,7 +486,7 @@ test('every node type realizes against an AudioContext stand-in and disposes cle
   voice.dispose();
   assert.equal(context.log.stopped, context.log.started);
 
-  const subsystem = new AudioSubsystem({ document, rng: new SeededRNG(42), contextFactory: () => mockContext() });
+  const subsystem = new AudioSubsystem({ document, rng: new SeededRNG(42), protectionFactory: fakeProtectionFactory, contextFactory: () => mockContext() });
   await subsystem.unlock();
   const handle = subsystem.play('probe');
   assert.equal(handle.soundId, 'probe');
@@ -867,7 +868,7 @@ test('trace 10: eviction order is followed at ceiling, WARN_VOICE_LIMIT raised,
   const subsystem = new AudioSubsystem({
     document: doc,
     rng: new SeededRNG(42),
-    contextFactory: () => mockContext(),
+    protectionFactory: fakeProtectionFactory, contextFactory: () => mockContext(),
     diagnostics,
     voiceLimits: limits
   });
@@ -954,7 +955,7 @@ test('trace 11: disposal releases all nodes/connections/buffers, and a FINISHED
   const subsystem = new AudioSubsystem({
     document: doc,
     rng: new SeededRNG(42),
-    contextFactory: () => context,
+    protectionFactory: fakeProtectionFactory, contextFactory: () => context,
     voiceLimits: { oneshot: 2, continuous: 2 }
   });
   await subsystem.unlock();
diff --git a/test/phase3-automation.test.mjs b/test/phase3-automation.test.mjs
index 281e49c..3a158e0 100644
--- a/test/phase3-automation.test.mjs
+++ b/test/phase3-automation.test.mjs
@@ -1,3 +1,4 @@
+import { fakeProtectionFactory } from './helpers/protection-fake.mjs';
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import { readFileSync } from 'node:fs';
@@ -174,7 +175,7 @@ test('trace 8: bus binding -> automation -> override -> modulation -> clamp, inc
   doc.parameters = { amount: { type: 'number', default: 1, min: 0, max: 10 } };
   doc.bindings = [{ source: 'parameters.amount', target: 'audio.buses.main.gain', scale: 2 }];
   const engine = new ResolutionEngine(doc, new SeededRNG(42));
-  const audio = new AudioSubsystem({ document: doc, rng: new SeededRNG(42), resolutionEngine: engine, contextFactory: recordingContext });
+  const audio = new AudioSubsystem({ document: doc, rng: new SeededRNG(42), resolutionEngine: engine, protectionFactory: fakeProtectionFactory, contextFactory: recordingContext });
   await audio.unlock();
   const path = 'audio.buses.main.gain';
   const remove = engine.addAutomation(path, track(path, [0.5, 1.5], { mode: 'scale' }));
@@ -363,7 +364,7 @@ test('automation extends determinable delay tails without mutating sampled base
 test('trace 11: disposal and scheduler failure cancel automation and release all voice resources', async () => {
   const doc = fixture([track(undefined, [100, 400], { interpolation: 'smooth' })]);
   const context = recordingContext();
-  const audio = new AudioSubsystem({ document: doc, rng: new SeededRNG(42), contextFactory: () => context });
+  const audio = new AudioSubsystem({ document: doc, rng: new SeededRNG(42), protectionFactory: fakeProtectionFactory, contextFactory: () => context });
   await audio.unlock();
   const voice = audio.play('probe');
   voice.dispose();
diff --git a/test/phase3-protection.test.mjs b/test/phase3-protection.test.mjs
new file mode 100644
index 0000000..3581cdb
--- /dev/null
+++ b/test/phase3-protection.test.mjs
@@ -0,0 +1,260 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import vm from 'node:vm';
+import { mkdtempSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { AUDIO_PROTECTION } from '../src/runtime/audio-contract.js';
+import { MasterProtectionDSP, protectionWorkletSource, loadProtectionWorklet, createProtectionNode } from '../src/runtime/audio-protection.js';
+import { AudioSubsystem, instantiateSoundGraph } from '../src/runtime/audio-engine.js';
+import { validateExhibit } from '../src/runtime/validator.js';
+import { buildAudioAcceptance } from '../tools/build-audio-acceptance.mjs';
+import { Diagnostics } from '../src/runtime/diagnostics.js';
+import { SeededRNG } from '../src/runtime/rng.js';
+
+const block = (value = 0, length = 128) => [new Float32Array(length).fill(value), new Float32Array(length).fill(value)];
+const limit = 10 ** ((AUDIO_PROTECTION.ceilingDb + AUDIO_PROTECTION.toleranceDb) / 20);
+function processor(rate = 48000, guard = false) {
+  let Processor;
+  vm.runInNewContext(protectionWorkletSource(), {
+    sampleRate: rate,
+    AudioWorkletProcessor: class { constructor() { this.messages = []; this.port = { postMessage: data => this.messages.push(data) }; } },
+    registerProcessor(name, implementation) { assert.equal(name, 'xzbt-protection'); Processor = implementation; }
+  });
+  return new Processor({ processorOptions: { guard } });
+}
+
+test('the shipped worklet bounds overload, DC, alternating peaks, transients and silence at multiple sample rates', () => {
+  for (const rate of [8000, 44100, 48000, 96000, 192000]) {
+    const p = processor(rate), output = block();
+    let observed = 0;
+    for (let n = 0; n < 300; n++) {
+      const input = block();
+      for (let i = 0; i < 128; i++) {
+        const t = (n * 128 + i) / rate;
+        input[0][i] = n < 50 ? 0 : n < 100 ? 1024 : n < 150 ? 4096 * Math.sin(2 * Math.PI * 440 * t) : n < 200 ? (i % 2 ? -3.4e38 : 3.4e38) : n < 250 ? (i === 63 ? 10000 : 0.1) : 0;
+        input[1][i] = input[0][i] * -0.5;
+      }
+      assert.equal(p.process([input, []], [output]), true);
+      for (const channel of output) for (const sample of channel) {
+        assert.ok(Number.isFinite(sample));
+        assert.ok(Math.abs(sample) <= limit);
+        observed = Math.max(observed, Math.abs(sample));
+      }
+    }
+    assert.ok(observed > 0.8, `rate ${rate} must produce audio, not silently pass`);
+  }
+});
+
+test('quiet stereo audio retains its samples and polarity after exactly the lookahead delay', () => {
+  const dsp = new MasterProtectionDSP(48000, AUDIO_PROTECTION);
+  const input = block(0, 1024), output = block(0, 1024);
+  for (let i = 0; i < 1024; i++) { input[0][i] = Math.sin(i) * 0.2; input[1][i] = input[0][i] * -0.5; }
+  dsp.process(input, output);
+  for (let c = 0; c < 2; c++) for (let i = 0; i < 1024; i++) assert.equal(output[c][i], i < dsp.delayFrames ? 0 : input[c][i - dsp.delayFrames]);
+});
+
+test('gain recovers monotonically with the configured release time constant, shared across stereo', () => {
+  const dsp = new MasterProtectionDSP(48000, AUDIO_PROTECTION), output = block();
+  for (let i = 0; i < 200; i++) dsp.process(block(100), output);
+  let previous = dsp.gain;
+  for (let i = 0; i < 400; i++) {
+    dsp.process(block(0.1), output);
+    assert.ok(dsp.gain >= previous - 1e-12);
+    assert.ok(dsp.gain <= 1);
+    previous = dsp.gain;
+  }
+  assert.ok(dsp.gain > 0.98);
+  assert.deepEqual(output[0], output[1]);
+});
+
+test('trace 12: nonfinite at the master mutes the entire stereo block, flushes history and warns once', () => {
+  const p = processor(), output = block();
+  p.process([block(0.3)], [output]);
+  for (const invalid of [NaN, Infinity, -Infinity]) {
+    const input = block(0.3); input[1][127] = invalid;
+    p.process([input], [output]);
+    assert.ok(output.every(channel => channel.every(value => value === 0)));
+  }
+  assert.equal(p.messages.filter(message => message.type === 'nonfinite').length, 1);
+  assert.equal(p.dsp.affectedBlocks, 3);
+  p.process([block()], [output]);
+  assert.ok(output.every(channel => channel.every(value => value === 0)));
+});
+
+test('voice guards attribute once per instance and a fault mutes the mixed output even with healthy voices', () => {
+  const master = processor(), guards = [processor(48000, true), processor(48000, true)];
+  master.port.onmessage({ data: { type: 'capture', id: 1, warmupFrames: 0, frames: 384 } });
+  for (let b = 0; b < 3; b++) {
+    const fault = block(0, 128), output = block();
+    for (const guard of guards) {
+      const input = block(0.1), guarded = block(), lane = [new Float32Array(128)];
+      input[0][127] = NaN;
+      guard.process([input], [guarded, lane]);
+      assert.ok(guarded.every(channel => channel.every(value => value === 0)));
+      for (let i = 0; i < 128; i++) fault[0][i] += lane[0][i];
+    }
+    master.process([block(10), fault], [output]);
+    assert.ok(output.every(channel => channel.every(value => value === 0)));
+  }
+  for (const guard of guards) assert.equal(guard.messages.length, 1);
+  const capture = master.messages.find(message => message.type === 'capture');
+  assert.equal(capture.affectedBlocks, 3);
+  assert.equal(capture.nonfiniteSamples, 6);
+  assert.equal(master.messages.filter(message => message.type === 'nonfinite').length, 0);
+});
+
+test('capture excludes warmup and measures exact output frames including partial boundary blocks', () => {
+  const p = processor(), output = block();
+  p.port.onmessage({ data: { type: 'capture', id: 12, warmupFrames: 300, frames: 257 } });
+  for (let n = 0; n < 4; n++) p.process([block(0.2)], [output]);
+  assert.equal(p.messages.length, 0);
+  p.process([block(0.2)], [output]);
+  const result = p.messages[0];
+  assert.equal(result.id, 12);
+  assert.equal(result.frames, 257);
+  assert.equal(result.peak, Math.fround(0.2));
+  assert.equal(result.affectedBlocks, 0);
+});
+
+function recordingSetup(load = async () => {}) {
+  const nodes = [];
+  const node = kind => {
+    const result = { kind, connections: [], gain: { value: 1 }, port: { messages: [], postMessage(data) { this.messages.push(data); }, close() { this.closed = true; } },
+      connect(target, output = 0, input = 0) { this.connections.push({ target, output, input }); return target; },
+      disconnect() { this.connections = []; this.disconnected = true; } };
+    nodes.push(result); return result;
+  };
+  const context = { state: 'suspended', sampleRate: 48000, currentTime: 0, destination: node('destination'),
+    createGain: () => node('gain'), async resume() { this.state = 'running'; }, async close() { this.state = 'closed'; } };
+  const diagnostics = new Diagnostics();
+  const audio = new AudioSubsystem({ document: { audio: { buses: { bed: { gain: 1 } } } }, rng: new SeededRNG(42), diagnostics,
+    contextFactory: () => context, protectionFactory: { load, create: (ctx, guard) => node(guard ? 'guard' : 'master-protection') } });
+  return { audio, context, diagnostics, nodes };
+}
+
+test('all buses and direct sounds route through volume then final protection; guard fault lane is separate', async () => {
+  const { audio, context, nodes } = recordingSetup();
+  assert.equal(await audio.unlock(), true);
+  assert.equal(audio.busFor('direct'), audio.master);
+  assert.equal(audio.buses.get('bed').connections[0].target, audio.master);
+  assert.equal(audio.master.connections[0].target, audio.protection);
+  const outputEdges = nodes.flatMap(node => node.connections.map(edge => ({ node, ...edge }))).filter(edge => edge.target === context.destination);
+  assert.equal(outputEdges.length, 1);
+  assert.equal(outputEdges[0].node, audio.protection);
+  const guard = audio.createVoiceGuard({ soundId: 'probe', creationOrder: 7 });
+  assert.deepEqual(guard.connections[0], { target: audio.protection, output: 1, input: 1 });
+  guard.port.onmessage({ data: { type: 'nonfinite' } });
+  assert.equal(audio.diagnostics.list()[0].objectId, 'probe#7');
+  guard.disconnect(); guard.port.close();
+  audio.setMasterVolume(NaN);
+  assert.equal(audio.master.gain.value, 0.8);
+  await audio.dispose();
+  assert.ok(nodes.filter(node => node.kind !== 'destination').every(node => node.disconnected));
+});
+
+test('missing worklets and rejected resume/load fail closed, warn once, and create no voice', async () => {
+  for (const failure of ['load', 'resume']) {
+    const { audio, context, diagnostics, nodes } = recordingSetup(async () => { if (failure === 'load') throw new Error('load rejected'); });
+    if (failure === 'resume') context.resume = async () => { throw new Error('resume rejected'); };
+    assert.equal(await audio.unlock(), false);
+    assert.equal(await audio.unlock(), false);
+    assert.equal(audio.play('probe'), null);
+    assert.equal(audio.unlocked, false);
+    assert.equal(diagnostics.list().filter(entry => entry.code === 'WARN_AUDIO_UNAVAILABLE').length, 1);
+    assert.ok(nodes.every(node => node.connections.length === 0));
+    await audio.dispose();
+  }
+  await assert.rejects(loadProtectionWorklet({}), /unavailable/);
+});
+
+test('concurrent unlocks share initialization; disposal during module loading cannot resurrect output', async () => {
+  let finish, loads = 0;
+  const pending = new Promise(resolve => { finish = resolve; });
+  const { audio, nodes } = recordingSetup(() => { loads++; return pending; });
+  const first = audio.unlock(), second = audio.unlock();
+  assert.equal(audio.unlocked, false);
+  assert.equal(loads, 1);
+  await audio.dispose(); finish();
+  assert.deepEqual(await Promise.all([first, second]), [false, false]);
+  assert.equal(nodes.filter(node => node.kind === 'master-protection').length, 0);
+});
+
+test('capture resolves only its own result, prevents overlap, and rejects on disposal or processor failure', async () => {
+  for (const ending of ['complete', 'dispose', 'error']) {
+    const { audio } = recordingSetup();
+    await audio.unlock();
+    const pending = audio.captureOutput({ seconds: 1, warmupSeconds: 0 });
+    await assert.rejects(audio.captureOutput(), /already running/);
+    const request = audio.protection.port.messages[0];
+    assert.equal(request.frames, 48000);
+    if (ending === 'complete') {
+      audio.protection.port.onmessage({ data: { type: 'capture', id: request.id + 1 } });
+      assert.ok(audio.capturePending);
+      audio.protection.port.onmessage({ data: { type: 'capture', id: request.id, peak: 0.8 } });
+      assert.equal((await pending).peak, 0.8);
+    } else {
+      const rejected = assert.rejects(pending, /disposed|failed/);
+      if (ending === 'dispose') await audio.dispose();
+      else audio.protection.onprocessorerror();
+      await rejected;
+      assert.equal(audio.unlocked, false);
+    }
+    await audio.dispose();
+  }
+});
+
+test('production loader embeds the exact processor and constructs explicit stereo worklets', async () => {
+  const previous = globalThis.AudioWorkletNode;
+  const calls = [];
+  try {
+    globalThis.AudioWorkletNode = class { constructor(...args) { calls.push(args); } };
+    const context = { audioWorklet: { async addModule(url) {
+      assert.equal(decodeURIComponent(url.split(',').slice(1).join(',')), protectionWorkletSource());
+    } } };
+    await loadProtectionWorklet(context);
+    createProtectionNode(context); createProtectionNode(context, true);
+    assert.deepEqual(calls[0][2].outputChannelCount, [2]);
+    assert.equal(calls[0][2].numberOfInputs, 2);
+    assert.deepEqual(calls[1][2].outputChannelCount, [2, 1]);
+  } finally { globalThis.AudioWorkletNode = previous; }
+});
+
+test('trace 14: absent AudioContext stays silent, creates no instance, and warns once', async () => {
+  const diagnostics = new Diagnostics();
+  const audio = new AudioSubsystem({ document: {}, rng: new SeededRNG(42), diagnostics });
+  assert.equal(await audio.unlock(), false);
+  assert.equal(await audio.unlock(), false);
+  assert.equal(audio.play('probe'), null);
+  assert.equal(audio.voices.size, 0);
+  assert.equal(diagnostics.list().length, 1);
+  assert.equal(diagnostics.list()[0].code, 'WARN_AUDIO_UNAVAILABLE');
+  await audio.dispose();
+});
+
+test('the twelve challenge recipes and frozen overload workload validate and instantiate deterministically', () => {
+  for (const file of ['audio-challenge', 'audio-protection-stress']) {
+    const document = JSON.parse(readFileSync(`exhibits/${file}.xzbt`, 'utf8'));
+    assert.deepEqual(validateExhibit(document).errors, []);
+    if (file === 'audio-challenge') assert.equal(Object.keys(document.sounds).length, 12);
+    for (const [id, sound] of Object.entries(document.sounds)) {
+      const plan = instantiateSoundGraph(document, id, { rng: new SeededRNG(42) });
+      assert.deepEqual(plan.errors, [], id);
+      assert.deepEqual(plan, instantiateSoundGraph(document, id, { rng: new SeededRNG(42) }));
+      if (sound.recipe.mode === 'oneshot') assert.ok(Number.isFinite(plan.endingBoundMs));
+      if (file === 'audio-protection-stress' && id === 'hit') assert.ok(plan.endingBoundMs < 2000);
+    }
+  }
+});
+
+test('the direct-file acceptance build is deterministic, self-contained, and embeds the production processor', () => {
+  const directory = mkdtempSync(join(tmpdir(), 'xzbt-protection-'));
+  const first = buildAudioAcceptance(join(directory, 'first.html'));
+  const second = buildAudioAcceptance(join(directory, 'second.html'));
+  assert.equal(first.sha256, second.sha256);
+  const html = readFileSync(first.outputPath, 'utf8');
+  assert.doesNotMatch(html, /<(script|link)[^>]+(?:src|href)=/i);
+  assert.ok(html.includes(MasterProtectionDSP.toString()));
+  const source = html.match(/<script>([\s\S]*)<\/script>/)[1];
+  assert.doesNotThrow(() => new vm.Script(source));
+});
diff --git a/tools/audio-acceptance.js b/tools/audio-acceptance.js
new file mode 100644
index 0000000..693dde9
--- /dev/null
+++ b/tools/audio-acceptance.js
@@ -0,0 +1,135 @@
+// Bundled by build-audio-acceptance.mjs with the production runtime and fixtures.
+const acceptanceElement = id => document.getElementById(id);
+let acceptanceAudio = null, acceptanceTimer = null, acceptanceRunning = false;
+let acceptanceMeasurement = null, acceptanceDiagnostics = null;
+const acceptanceListeningLog = [];
+const acceptanceStatus = message => { acceptanceElement('state').textContent = message; };
+function acceptanceLock(running) {
+  acceptanceRunning = running;
+  acceptanceElement('capture').disabled = running;
+  for (const button of acceptanceElement('sounds').querySelectorAll('button')) button.disabled = running;
+  for (const id of ['release', 'pause', 'resume']) acceptanceElement(id).disabled = running;
+}
+async function acceptanceStop() {
+  clearInterval(acceptanceTimer); acceptanceTimer = null;
+  const previous = acceptanceAudio; acceptanceAudio = null;
+  if (previous?.context) previous.context.onstatechange = null;
+  await previous?.dispose();
+}
+function acceptanceMakeAudio(fixture) {
+  const result = validateExhibit(fixture);
+  if (!result.valid) throw new Error(JSON.stringify(result.errors));
+  acceptanceDiagnostics = new Diagnostics();
+  const audio = new AudioSubsystem({ document: fixture, rng: new SeededRNG(42), diagnostics: acceptanceDiagnostics });
+  audio.setMasterVolume(1);
+  acceptanceAudio = audio;
+  return audio;
+}
+function acceptanceEnvironment() {
+  return {
+    notes: acceptanceElement('environment').value,
+    userAgent: navigator.userAgent,
+    viewport: { width: innerWidth, height: innerHeight },
+    devicePixelRatio, hardwareConcurrency: navigator.hardwareConcurrency,
+    deviceMemoryGiB: navigator.deviceMemory ?? null,
+    protocol: location.protocol
+  };
+}
+acceptanceElement('build').textContent = JSON.stringify(ACCEPTANCE_BUILD, null, 2);
+acceptanceElement('capture').onclick = async () => {
+  acceptanceLock(true);
+  acceptanceMeasurement = null;
+  acceptanceElement('measurement').textContent = 'Initializing protected audio…';
+  await acceptanceStop();
+  let audio;
+  try {
+    audio = acceptanceMakeAudio(STRESS);
+    if (!await audio.unlock()) throw new Error('Protected audio could not start. See diagnostics in the report.');
+    const context = audio.context, bursts = [], start = context.currentTime;
+    context.onstatechange = () => {
+      if (context.state !== 'running') void acceptanceStop();
+    };
+    const environment = acceptanceEnvironment();
+    for (let i = 0; i < 16; i++) if (!audio.play('bed')) throw new Error('Continuous stress voice refused.');
+    const capture = audio.captureOutput();
+    // Attach a rejection handler immediately, including synchronous burst failures.
+    capture.catch(() => {});
+    const burst = () => {
+      for (let i = 0; i < 64; i++) if (!audio.play('hit')) throw new Error('Transient stress voice refused.');
+      bursts.push({ seconds: context.currentTime - start, oneshots: audio.oneshotVoices.size, continuous: audio.continuousVoices.size,
+        expandedGraphNodes: [...audio.oneshotVoices, ...audio.continuousVoices].reduce((count, voice) => count + (voice.plan?.nodes.length ?? 0), 0) });
+      const elapsed = context.currentTime - start;
+      acceptanceStatus(elapsed < 30 ? `Warming up · ${elapsed.toFixed(0)} / 30 seconds` : `Capturing · ${(elapsed - 30).toFixed(0)} / 120 seconds`);
+    };
+    burst();
+    acceptanceTimer = setInterval(() => {
+      try { burst(); } catch (error) { acceptanceStatus(error.message); void acceptanceStop(); }
+    }, 2000);
+    const result = await capture;
+    const peakDb = result.peak > 0 ? 20 * Math.log10(result.peak) : null;
+    acceptanceMeasurement = {
+      capturedAt: new Date().toISOString(), environment, ...result, peakDb,
+      ceilingDb: AUDIO_PROTECTION.ceilingDb, toleranceDb: AUDIO_PROTECTION.toleranceDb,
+      lookaheadFrames: Math.ceil(context.sampleRate * AUDIO_PROTECTION.lookaheadMs / 1000),
+      baseLatency: context.baseLatency ?? null, outputLatency: context.outputLatency ?? null,
+      bursts, maxBurstGapSeconds: Math.max(0, ...bursts.slice(1).map((item, i) => item.seconds - bursts[i].seconds)),
+      candidateDigitalPeakPass: result.peak > 0.01 && peakDb <= AUDIO_PROTECTION.ceilingDb + AUDIO_PROTECTION.toleranceDb && result.affectedBlocks === 0,
+      diagnostics: acceptanceDiagnostics.list(),
+      acceptance: 'Pending user review of workload timing, environment, listening, and production reference/challenge runs.'
+    };
+    acceptanceElement('measurement').textContent = JSON.stringify(acceptanceMeasurement, null, 2);
+    acceptanceStatus('Digital capture finished. Record listening observations and download the report.');
+  } catch (error) {
+    acceptanceMeasurement = { interrupted: true, reason: error.message, diagnostics: acceptanceDiagnostics?.list() ?? [] };
+    acceptanceElement('measurement').textContent = JSON.stringify(acceptanceMeasurement, null, 2);
+    acceptanceStatus(`Capture incomplete: ${error.message}`);
+  } finally {
+    await acceptanceStop();
+    acceptanceLock(false);
+  }
+};
+acceptanceElement('cancel').onclick = async () => {
+  await acceptanceStop();
+  acceptanceListeningLog.push({ action: 'stop', at: new Date().toISOString() });
+  acceptanceStatus('Audio stopped.');
+};
+for (const [id, sound] of Object.entries(CHALLENGE.sounds)) {
+  const button = document.createElement('button'); button.textContent = sound.name;
+  button.onclick = async () => {
+    try {
+      if (!acceptanceAudio) acceptanceMakeAudio(CHALLENGE);
+      const audio = acceptanceAudio;
+      if (!await audio.unlock()) throw new Error('Protected audio could not start.');
+      if (!audio.play(id)) throw new Error('Voice could not start; release or stop existing voices.');
+      acceptanceListeningLog.push({ action: 'play', sound: id, at: new Date().toISOString() });
+      acceptanceStatus(`Playing ${sound.name}.`);
+    } catch (error) { acceptanceStatus(error.message); }
+  };
+  acceptanceElement('sounds').append(button);
+}
+acceptanceElement('release').onclick = () => {
+  acceptanceAudio?.stopAll();
+  acceptanceListeningLog.push({ action: 'release', at: new Date().toISOString() });
+  acceptanceStatus('All voices releasing.');
+};
+for (const [id, method] of [['pause', 'suspend'], ['resume', 'resume']]) {
+  acceptanceElement(id).onclick = async () => {
+    try {
+      await acceptanceAudio?.context?.[method]();
+      acceptanceListeningLog.push({ action: id, at: new Date().toISOString() });
+      acceptanceStatus(id === 'pause' ? 'Audio paused.' : 'Audio resumed.');
+    } catch (error) { acceptanceStatus(error.message); }
+  };
+}
+document.addEventListener('visibilitychange', () => {
+  if (document.hidden && acceptanceRunning) void acceptanceStop();
+});
+acceptanceElement('save').onclick = () => {
+  const report = { build: ACCEPTANCE_BUILD, exportedAt: new Date().toISOString(), environment: acceptanceEnvironment(),
+    measurement: acceptanceMeasurement, listeningLog: acceptanceListeningLog,
+    listeningObservations: acceptanceElement('observations').value, diagnostics: acceptanceDiagnostics?.list() ?? [],
+    phase3Acceptance: 'Pending user review; this report does not automatically close GC6 or PRD 129.' };
+  const url = URL.createObjectURL(new Blob([JSON.stringify(report, null, 2)], { type: 'application/json' }));
+  const anchor = document.createElement('a'); anchor.href = url; anchor.download = 'xzbt-phase3c4-evidence.json'; anchor.click();
+  setTimeout(() => URL.revokeObjectURL(url), 1000);
+};
diff --git a/tools/build-audio-acceptance.mjs b/tools/build-audio-acceptance.mjs
new file mode 100644
index 0000000..eb50937
--- /dev/null
+++ b/tools/build-audio-acceptance.mjs
@@ -0,0 +1,21 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { buildStandalone, bundleRuntime } from './build-xzbt.mjs';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+export function buildAudioAcceptance(outputPath = resolve(root, 'prototypes/phase3/XZBT-audio-acceptance.html')) {
+  const runtime = buildStandalone();
+  const challengeSource = readFileSync(resolve(root, 'exhibits/audio-challenge.xzbt'), 'utf8');
+  const stressSource = readFileSync(resolve(root, 'exhibits/audio-protection-stress.xzbt'), 'utf8');
+  const digest = source => createHash('sha256').update(source).digest('hex');
+  const metadata = { runtimeSha256: runtime.sha256, challengeSha256: digest(challengeSource), stressSha256: digest(stressSource), workload: 'phase3c4-overlap-v1', seed: 42, warmupSeconds: 30, measurementSeconds: 120 };
+  const source = `${bundleRuntime(false)}\nconst ACCEPTANCE_BUILD = ${JSON.stringify(metadata)};\nconst CHALLENGE = ${challengeSource};\nconst STRESS = ${stressSource};\n${readFileSync(resolve(root, 'tools/audio-acceptance.js'), 'utf8')}`;
+  const template = readFileSync(resolve(root, 'prototypes/phase3/acceptance.template.html'), 'utf8');
+  const artifact = template.replace('/*__ACCEPTANCE_SCRIPT__*/', () => `'use strict';\n(() => {\n${source}\n})();`).replace(/\r\n/g, '\n');
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, artifact);
+  return { outputPath, sha256: digest(artifact), bytes: Buffer.byteLength(artifact) };
+}
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) console.log(JSON.stringify(buildAudioAcceptance(), null, 2));
diff --git a/tools/build-xzbt.mjs b/tools/build-xzbt.mjs
index 301b696..1e17c55 100644
--- a/tools/build-xzbt.mjs
+++ b/tools/build-xzbt.mjs
@@ -12,6 +12,7 @@ const sourceFiles = Object.freeze([
   'src/runtime/types.js',
   'src/runtime/values.js',
   'src/runtime/audio-contract.js',
+  'src/runtime/audio-protection.js',
   'src/runtime/audio-automation.js',
   'src/runtime/audio-graph.js',
   'src/runtime/audio-controls.js',
@@ -36,10 +37,15 @@ function bundleModule(source, path) {
   return `\n/* ${path} */\n${withoutExports.trim()}\n`;
 }
 
+export function bundleRuntime(includeApp = true) {
+  return sourceFiles.filter(path => includeApp || path !== 'src/runtime/app.js')
+    .map(path => bundleModule(normalized(path), path)).join('');
+}
+
 export function buildStandalone(outputPath = resolve(repositoryRoot, 'XZBT.html')) {
   const template = normalized('src/XZBT.template.html');
   const styles = normalized('src/styles.css').trim();
-  const script = `'use strict';\n(() => {\n${sourceFiles.map((path) => bundleModule(normalized(path), path)).join('')}\n})();`;
+  const script = `'use strict';\n(() => {\n${bundleRuntime()}\n})();`;
   if (!template.includes('/*__XZBT_STYLES__*/') || !template.includes('/*__XZBT_SCRIPT__*/')) {
     throw new Error('Standalone template is missing a build placeholder.');
   }