@memberjunction/ng-conversations 6.2.0-edge.3 → 6.2.0-edge.5

package/dist/lib/services/realtime-audio-recorder.js

@@ -1,36 +1,46 @@
-import { EncodePcm16Wav, PeakAccumulator } from './realtime-pcm-wav';
+import { RECORDING_SAMPLE_RATE } from '@memberjunction/ai-core-plus';
+import { LinearResampler } from './recording/linear-resampler';
+import { SelectOpusPacketEncoder } from './recording/opus-packet-encoder';
 /**
- * Browser-side audio recorder for a CLIENT-DIRECT realtime voice session.
+ * Browser-side audio recorder for a CLIENT-DIRECT realtime voice session, implementing the
+ * runtime's {@link IRealtimeSessionRecorder} contract directly.
  *
- * Mixes the user's microphone stream with the agent's remote-audio stream (when the driver
- * exposes one — `OpenAIRealtimeClient.GetRemoteMediaStream()`) into a single mono **WAV** (16-bit
- * PCM) blob via the Web Audio API. Rather than a `MediaRecorder` (which only emits webm/opus —
- * header-less, no duration/cues, so HTTP-range seeking is unreliable), the mix is routed into an
- * {@link AudioWorkletNode} (preferred) or a {@link ScriptProcessorNode} (fallback) that captures
- * Float32 PCM frames. PCM is accumulated in memory and encoded as a seekable RIFF/WAVE file at
- * {@link Stop}. WAV's header carries the exact duration and maps byte-offset → time linearly, so
- * range seeking is exact and waveform peaks are computed cheaply during capture. The tradeoff is
- * size (PCM WAV is larger than opus) — acceptable for these short session recordings.
+ * Mixes the user's microphone with the agent's remote-audio stream (every driver exposes one via
+ * `GetRemoteMediaStream()`: WebRTC drivers publish their remote track, PCM drivers — Gemini,
+ * ElevenLabs, AssemblyAI, xAI, HuggingFace — publish their playout engine's output) in a Web Audio
+ * graph, captures the mix as mono Float32 frames through an {@link AudioWorkletNode} (preferred) or a
+ * {@link ScriptProcessorNode} (fallback), and feeds them to ONE continuous Opus encoder for the whole
+ * call. The runtime pulls the encoded packets with {@link TakeEncodedPackets}, cuts them into shards
+ * and uploads them as the call goes, so nothing is held in memory until the end.
  *
- * Robust + MVP by design — every step degrades gracefully:
+ * Timing is the 48 kHz sample clock: the graph asks for a 48 kHz context, and when the browser
+ * refuses (or reports another rate) every frame is resampled to 48 kHz before encoding. The
+ * captured-sample count drives {@link NowOffsetMs} and is what {@link Stop} resolves.
+ *
+ * Robust by design — every step degrades gracefully:
  * - No `AudioContext` (server-side render / unsupported env) → the recorder disables itself
- *   ({@link IsRecording} stays `false`, {@link Stop} resolves `null`); the voice call proceeds.
+ *   ({@link IsRecording} stays `false`, {@link Stop} resolves 0); the voice call proceeds.
  * - No `AudioWorkletNode` AND no `ScriptProcessorNode` → disables itself rather than throwing.
- * - No remote stream (non-WebRTC drivers, or the track hasn't landed yet) → records mic only.
- * - Any construction/start error is logged and disables the recorder rather than throwing into
- *   the session-start path.
+ * - A forced-48 kHz context that cannot take the microphone (Firefox rejects a source whose rate
+ *   differs from its context's) → rebuilt once at the device rate with resampling.
+ * - No remote stream yet (e.g. the WebRTC track hasn't landed) → records mic only until it does.
+ * - A remote stream that can't be connected (e.g. a cross-sample-rate `createMediaStreamSource`
+ *   rejection) → warns and records mic only; the mic recording is never lost to the agent stream.
+ * - No usable encoder → logged, recording disabled for the call.
  *
- * Not an Angular service: it owns transient per-session media plumbing the
- * {@link RealtimeSessionService} creates and discards per call, so a plain class is the right
- * shape (no DI, no singleton).
+ * Not an Angular service: it owns transient per-session media plumbing the runtime creates and
+ * discards per call, so a plain class is the right shape (no DI, no singleton).
  */
 export class RealtimeAudioRecorder {
-    /** The container/codec we now produce — a seekable mono 16-bit PCM WAV. */
-    static wavMimeType = 'audio/wav';
-    /** Target waveform-peak resolution (buckets) across the whole recording. */
-    static peakBuckets = 600;
+    selectEncoder;
     /** PCM frame size for the ScriptProcessor fallback (worklet uses its native 128-frame quantum). */
     static scriptProcessorBufferSize = 4096;
+    /**
+     * Most 48 kHz audio held while the encoder is still being selected / loaded (10 s). Selection is
+     * normally well under a second; past this the encoder is stuck, and later frames are dropped
+     * (see {@link captureFrame} for why they are not counted either).
+     */
+    static maxPendingSamples = 10 * RECORDING_SAMPLE_RATE;
     /** Inline AudioWorklet processor: forwards each 128-frame mono input block to the main thread. */
     static workletProcessorSource = `
         class MJPcmCaptureProcessor extends AudioWorkletProcessor {
@@ -49,52 +59,48 @@ export class RealtimeAudioRecorder {
     destination = null;
     workletNode = null;
     scriptNode = null;
-    /** Captured mono Float32 PCM frames (in capture order); concatenated + encoded to WAV at Stop. */
-    pcmFrames = [];
-    /** Total captured sample count across {@link pcmFrames} (kept in step to avoid re-summing). */
-    totalSamples = 0;
-    /** Streaming waveform-peak accumulator — bounded regardless of recording length. */
-    peaks = new PeakAccumulator(RealtimeAudioRecorder.peakBuckets);
-    /** Final normalized peaks, snapshotted at {@link Stop} so {@link GetPeaks} survives cleanup. */
-    finalPeaks = [];
+    /** Converts the context's rate to 48 kHz; `null` when the context already runs at 48 kHz. */
+    resampler = null;
     recording = false;
     /** True once the agent's remote stream has been wired into the mix (prevents double-attach). */
     remoteAttached = false;
     /** A remote stream handed to AttachRemoteStream before the audio graph was ready; wired at setup. */
     pendingRemoteStream = null;
-    /** Sample index up to which crash-recovery shards have already been emitted (the segment cursor). */
-    flushedSampleCount = 0;
-    /** Wall-clock ms at recording start; anchors {@link NowOffsetMs}. 0 before {@link Start}. */
-    startedAtMs = 0;
-    /** Sample rate of the capturing {@link AudioContext}; 0 before {@link Start}. Needed to wrap shards. */
-    sampleRate = 0;
-    /** True while a recorder is actively capturing. */
-    get IsRecording() {
-        return this.recording;
-    }
-    /** Wall-clock ms when recording started (0 before {@link Start}). */
-    get StartedAtMs() {
-        return this.startedAtMs;
-    }
+    /** The microphone to record: the latest stream given to Start or ReplaceMicrophone. Setup connects it. */
+    micStream = null;
+    /** The source node reading the microphone, swapped by ReplaceMicrophone. */
+    micSource = null;
+    /** 48 kHz samples captured (post-resample) — the recording's clock. */
+    capturedSamples = 0;
+    /** The call's encoder once selected; `null` while selecting, after a failure, or when not recording. */
+    encoder = null;
+    /** Resolves to the encoder (or `null` on failure) — Stop awaits it so buffered audio still gets encoded. */
+    encoderReady = null;
+    /** 48 kHz frames captured before the encoder was ready, fed to it in order once it is. */
+    pendingFrames = [];
+    pendingSamples = 0;
+    pendingOverflowWarned = false;
+    /** The first Stop's promise; later calls return it (idempotent). */
+    stopping = null;
     /**
-     * The container/codec the active recording uses. Always `'audio/wav'` once recording (empty
-     * string before {@link Start} / when disabled) — the consolidated upload and the WAV-wrapped
-     * crash-recovery shards are all 16-bit PCM WAV.
+     * Bumped whenever the audio graph is released. The async graph setup snapshots it and, after each
+     * await, gives up if it moved: a {@link Stop} that lands mid-setup can only release what setup has
+     * already published, so setup must release the rest itself rather than build a live graph on a
+     * stopped recorder.
      */
-    get MimeType() {
-        return this.recording ? RealtimeAudioRecorder.wavMimeType : '';
+    setupGeneration = 0;
+    /** @param selectEncoder picks the call's Opus encoder; injectable for tests. */
+    constructor(selectEncoder = () => SelectOpusPacketEncoder()) {
+        this.selectEncoder = selectEncoder;
     }
-    /**
-     * The captured AudioContext sample rate (0 before {@link Start} / when disabled). Exposed so a
-     * recovery path can WAV-wrap the raw-PCM shards with the correct rate.
-     */
-    get SampleRate() {
-        return this.sampleRate;
+    /** True while a recorder is actively capturing. */
+    get IsRecording() {
+        return this.recording;
     }
     /**
      * Begins recording a mix of `micStream` and (when present) `remoteStream`. Best-effort:
      * a missing `AudioContext` / no worklet+scriptprocessor support / any setup failure disables
-     * the recorder silently (logged) so the live call is never blocked.
+     * the recorder (logged) so the live call is never blocked.
      *
      * @param micStream The user's microphone capture stream (required).
      * @param remoteStream The agent's remote-audio stream, or `null` for mic-only capture.
@@ -107,18 +113,19 @@ export class RealtimeAudioRecorder {
             console.warn('[RealtimeAudioRecorder] AudioContext unavailable — recording disabled for this session.');
             return;
         }
-        // Mark recording + stamp t0 SYNCHRONOUSLY so a caller that checks IsRecording immediately after
-        // Start() (the session service does) sees `true`, even though the audio-graph setup
-        // (AudioContext.resume + worklet module load) completes asynchronously below. Without this the
-        // caller discards the recorder before it finishes starting and nothing is ever uploaded.
-        this.startedAtMs = Date.now();
-        this.finalPeaks = [];
+        // Mark recording SYNCHRONOUSLY so a caller that checks IsRecording immediately after Start()
+        // (the runtime does) sees `true`, even though the audio graph and the encoder are set up
+        // asynchronously below.
         this.recording = true;
+        this.stopping = null;
+        this.capturedSamples = 0;
+        this.encoderReady = this.prepareEncoder();
+        this.micStream = micStream;
         // Fire-and-forget the async setup (it must `await audioContext.resume()` + worklet load); any
         // failure disables the recorder rather than throwing into the session-start path.
         void this.startMixedRecording(micStream, remoteStream).catch((error) => {
             console.warn('[RealtimeAudioRecorder] Failed to start recording — disabling for this session:', error);
-            this.cleanup();
+            this.disable();
         });
     }
     /**
@@ -132,8 +139,7 @@ export class RealtimeAudioRecorder {
             return;
         }
         if (this.audioContext && this.captureNode()) {
-            this.connectStream(this.audioContext, stream);
-            this.remoteAttached = true;
+            this.remoteAttached = this.connectRemoteStream(this.audioContext, stream);
         }
         else {
             // Audio-graph setup still in flight (awaiting resume / worklet load) — connect at setup.
@@ -141,84 +147,177 @@ export class RealtimeAudioRecorder {
         }
     }
     /**
-     * Returns a Blob of the raw PCM captured since the last call (a window of header-less,
-     * little-endian PCM16 bytes), advancing the segment cursor. `null` when nothing new. Used to
-     * upload crash-recovery shards mid-call. NOTE: shards are header-less raw PCM (NOT individually
-     * playable WAV) — recovery is concatenation in order, then WAV-wrapping with {@link SampleRate}.
-     * The canonical consolidated file is still authored as a single WAV from full memory at {@link Stop}.
+     * Records the microphone stream's current track from now on: call it after the track changes (a
+     * device switch). A source node reads the track it was created with, so the recording would otherwise
+     * carry silence from the old device. Safe before the audio graph is ready (setup connects the latest
+     * stream, and Start replaces it); a stream without an audio track keeps the current one.
      */
-    SnapshotNewSegment() {
-        if (!this.recording || this.flushedSampleCount >= this.totalSamples) {
-            return null;
+    ReplaceMicrophone(micStream) {
+        this.micStream = micStream;
+        if (!this.audioContext || !this.captureNode()) {
+            return;
         }
-        const fresh = this.collectSamples(this.flushedSampleCount, this.totalSamples);
-        this.flushedSampleCount = this.totalSamples;
-        if (fresh.length === 0) {
-            return null;
+        const replacement = this.connectStream(this.audioContext, micStream);
+        if (replacement) {
+            this.micSource?.disconnect();
+            this.micSource = replacement;
         }
-        const pcm16 = this.floatToPcm16Bytes(fresh);
-        return new Blob([pcm16], { type: 'application/octet-stream' });
     }
-    /** Ms elapsed since recording started (>= 0); 0 when not recording. */
+    /** Milliseconds of audio captured so far, on the 48 kHz sample clock (never wall clock). */
     NowOffsetMs() {
-        if (this.startedAtMs === 0) {
-            return 0;
-        }
-        return Math.max(0, Date.now() - this.startedAtMs);
+        return (this.capturedSamples * 1000) / RECORDING_SAMPLE_RATE;
+    }
+    /** The Opus packets the encoder produced since the last call (also its final packets after {@link Stop}). */
+    TakeEncodedPackets() {
+        return this.encoder ? this.encoder.TakePackets() : [];
     }
     /**
-     * The downsampled waveform peaks (each 0..1, max-abs per bucket, ~{@link RealtimeAudioRecorder.PeakBuckets}
-     * buckets across the whole recording). Computed incrementally during capture so it's cheap and
-     * bounded regardless of length. Returns `[]` before any audio / for a silent recording. Safe to
-     * call after {@link Stop} — the peaks are snapshotted there before {@link cleanup} clears state.
+     * Stops capture, waits for the encoder (encoding any audio buffered while it loaded), flushes and
+     * closes it, and resolves the 48 kHz samples captured. The final packets stay available to
+     * {@link TakeEncodedPackets}. Idempotent: every call resolves the same count; 0 when the recorder
+     * never started.
      */
-    GetPeaks() {
-        return this.recording ? this.peaks.Normalize() : this.finalPeaks;
+    Stop() {
+        if (!this.stopping) {
+            this.stopping = this.stopOnce();
+        }
+        return this.stopping;
+    }
+    async stopOnce() {
+        this.recording = false;
+        this.releaseGraph();
+        const encoderReady = this.encoderReady;
+        if (!encoderReady) {
+            return this.capturedSamples;
+        }
+        const encoder = await encoderReady;
+        if (encoder) {
+            await encoder.Flush();
+            encoder.Close();
+        }
+        return this.capturedSamples;
     }
     /**
-     * Stops recording and resolves the captured audio as a single mono 16-bit PCM **WAV**
-     * {@link Blob}, then releases the audio graph. Resolves `null` when nothing was recorded
-     * (recorder disabled, or no samples captured). Safe to call when not recording.
+     * Selects the encoder and feeds it what was captured meanwhile. A selection failure disables the
+     * recorder: with no encoder nothing captured could ever reach the server.
      */
-    async Stop() {
-        if (!this.recording) {
-            this.cleanup();
+    async prepareEncoder() {
+        let encoder;
+        try {
+            encoder = await this.selectEncoder();
+        }
+        catch (error) {
+            console.warn('[RealtimeAudioRecorder] No Opus encoder available — recording disabled for this session:', error);
+            this.disable();
+            // Nothing captured can be encoded now, so report nothing recorded rather than a count with no audio.
+            this.pendingFrames = [];
+            this.pendingSamples = 0;
+            this.capturedSamples = 0;
             return null;
         }
-        // Detach the capture node so no further frames arrive while we assemble the file. Snapshot the
-        // peaks BEFORE cleanup so GetPeaks() still returns them for the post-Stop upload.
-        this.recording = false;
-        this.finalPeaks = this.peaks.Normalize();
-        const blob = this.encodeWavBlob();
-        this.cleanup();
-        return blob;
+        this.encoder = encoder;
+        for (const frame of this.pendingFrames) {
+            encoder.Encode(frame);
+        }
+        this.pendingFrames = [];
+        this.pendingSamples = 0;
+        return encoder;
     }
-    /** Wires up the Web Audio mix graph + PCM capture node (worklet preferred) and starts capture. */
+    /** Builds the mix graph + capture node, retrying once at the device rate if 48 kHz cannot take the mic. */
     async startMixedRecording(micStream, remoteStream) {
-        const audioContext = new AudioContext();
+        const built = await this.buildGraph(micStream, remoteStream, true);
+        if (built === 'mic-rejected') {
+            await this.buildGraph(micStream, remoteStream, false);
+        }
+    }
+    /**
+     * Wires up the Web Audio mix graph + PCM capture node (worklet preferred) and starts capture.
+     * Resolves `'mic-rejected'` when a forced-48 kHz context refused the microphone source (the graph
+     * is released so the caller can rebuild at the device rate); otherwise `'done'`.
+     */
+    async buildGraph(micStream, remoteStream, prefer48k) {
+        const generation = this.setupGeneration;
+        const audioContext = this.createAudioContext(prefer48k);
+        const forced48k = prefer48k && audioContext.sampleRate === RECORDING_SAMPLE_RATE;
         // CRITICAL: browsers create an AudioContext in the `suspended` state under the autoplay policy.
         // Without resuming it, the mix graph never processes audio and we capture only silence. Starting
         // a voice call is a user gesture, so resume() succeeds here.
         if (audioContext.state === 'suspended') {
             await audioContext.resume();
         }
+        if (generation !== this.setupGeneration) {
+            // Stopped while resuming: the context was never published, so releaseGraph() could not close it.
+            this.closeContext(audioContext);
+            return 'done';
+        }
         const destination = audioContext.createMediaStreamDestination();
-        // Publish the context + sample rate BEFORE wiring the remote so a concurrent AttachRemoteStream()
-        // (the agent track can land during the awaits above) sees a ready graph to connect to.
+        // Publish the context BEFORE wiring the remote so a concurrent AttachRemoteStream() (the agent
+        // track can land during the awaits above) sees a ready graph to connect to.
         this.audioContext = audioContext;
         this.destination = destination;
-        this.sampleRate = audioContext.sampleRate;
+        this.resampler = audioContext.sampleRate === RECORDING_SAMPLE_RATE ? null : new LinearResampler(audioContext.sampleRate, RECORDING_SAMPLE_RATE);
         // Build the PCM capture node: AudioWorklet preferred, ScriptProcessor fallback. Either way the
         // node both pulls audio from the mix AND drives the destination so the graph keeps processing.
         await this.createCaptureNode(audioContext, destination);
-        this.connectStream(audioContext, micStream);
+        if (generation !== this.setupGeneration) {
+            return 'done'; // Stopped while the capture node loaded: releaseGraph() already closed the published context.
+        }
+        try {
+            // The microphone may have been replaced while the graph was being built.
+            this.micSource = this.connectStream(audioContext, this.micStream ?? micStream);
+        }
+        catch (error) {
+            if (!forced48k) {
+                throw error;
+            }
+            console.warn('[RealtimeAudioRecorder] The 48 kHz context rejected the microphone — rebuilding at the device rate with resampling:', error);
+            // releaseGraph() forgets a stashed agent stream and a replaced microphone; the rebuild still has to connect both.
+            const stashedRemote = this.pendingRemoteStream;
+            const stashedMic = this.micStream;
+            this.releaseGraph();
+            this.pendingRemoteStream = stashedRemote;
+            this.micStream = stashedMic;
+            return 'mic-rejected';
+        }
         // Connect the agent's stream if it was passed now, or if AttachRemoteStream() stashed one while
         // we were setting up. Either way, capture the agent voice — not just the mic.
         const remote = remoteStream ?? this.pendingRemoteStream;
         this.pendingRemoteStream = null;
         if (remote && remote.getAudioTracks().length > 0) {
-            this.connectStream(audioContext, remote);
-            this.remoteAttached = true;
+            this.remoteAttached = this.connectRemoteStream(audioContext, remote);
+        }
+        return 'done';
+    }
+    /**
+     * A 48 kHz context when asked for and the browser allows it, else the device-rate default. A
+     * browser that silently picks another rate is fine too: the resampler is chosen from the rate the
+     * context actually reports.
+     */
+    createAudioContext(prefer48k) {
+        if (prefer48k) {
+            try {
+                return new AudioContext({ sampleRate: RECORDING_SAMPLE_RATE });
+            }
+            catch (error) {
+                console.warn('[RealtimeAudioRecorder] 48 kHz AudioContext refused — capturing at the device rate with resampling:', error);
+            }
+        }
+        return new AudioContext();
+    }
+    /**
+     * Connects the agent stream, degrading to mic-only on failure. Unlike the mic (whose failure
+     * rightly disables the recorder), the agent stream is best-effort: a browser may reject it
+     * (cross-sample-rate `NotSupportedError`) and that must not discard the user's recording.
+     * Returns whether it was connected, so the caller only marks it attached on success.
+     */
+    connectRemoteStream(audioContext, stream) {
+        try {
+            this.connectStream(audioContext, stream);
+            return true;
+        }
+        catch (error) {
+            console.warn('[RealtimeAudioRecorder] Could not mix the agent stream into the recording — continuing mic-only:', error);
+            return false;
         }
     }
     /**
@@ -263,10 +362,7 @@ export class RealtimeAudioRecorder {
             throw new Error('Neither AudioWorklet nor ScriptProcessor is supported');
         }
         const node = audioContext.createScriptProcessor(RealtimeAudioRecorder.scriptProcessorBufferSize, 1, 1);
-        node.onaudioprocess = (event) => {
-            // Copy out of the reused input buffer before retaining.
-            this.captureFrame(event.inputBuffer.getChannelData(0).slice(0));
-        };
+        node.onaudioprocess = (event) => this.captureFrame(event.inputBuffer.getChannelData(0));
         // ScriptProcessor only fires onaudioprocess while connected to the destination.
         node.connect(destination);
         this.scriptNode = node;
@@ -275,105 +371,96 @@ export class RealtimeAudioRecorder {
     captureNode() {
         return this.workletNode ?? this.scriptNode;
     }
-    /** Absorbs one captured PCM frame: accumulate samples + update the bounded peak array. */
+    /**
+     * Absorbs one captured frame: resample to 48 kHz, count it, and hand it to the encoder (or buffer
+     * it while the encoder loads).
+     *
+     * Past the pending-buffer cap a frame is dropped AND not counted. Keeping the count equal to the
+     * audio actually handed to the encoder is what lets the runtime trust `packets × 960 ≥ captured`
+     * when it trims the final shard; a few lost seconds at the start of a call whose encoder never
+     * loaded is the smaller harm.
+     */
     captureFrame(frame) {
         if (!this.recording || frame.length === 0) {
             return;
         }
-        // Defensive copy — worklet/script buffers are reused by the engine.
-        const copy = frame.slice(0);
-        this.pcmFrames.push(copy);
-        this.totalSamples += copy.length;
-        this.peaks.Push(copy);
+        // Copy out of the engine's reused buffer (a resampler output is already a fresh array).
+        const samples = this.resampler ? this.resampler.Process(frame) : frame.slice(0);
+        if (samples.length === 0) {
+            return;
+        }
+        if (this.encoder) {
+            this.encoder.Encode(samples);
+        }
+        else if (this.pendingSamples + samples.length <= RealtimeAudioRecorder.maxPendingSamples) {
+            this.pendingFrames.push(samples);
+            this.pendingSamples += samples.length;
+        }
+        else {
+            if (!this.pendingOverflowWarned) {
+                this.pendingOverflowWarned = true;
+                console.warn(`[RealtimeAudioRecorder] Opus encoder still not ready after ${RealtimeAudioRecorder.maxPendingSamples / RECORDING_SAMPLE_RATE} s of audio — dropping audio until it is.`);
+            }
+            return;
+        }
+        this.capturedSamples += samples.length;
     }
-    /** Routes one stream's audio tracks into the capture node (no-op when track-less / no node). */
+    /** Routes one stream's audio tracks into the capture node; returns the source, or null when track-less / no node. */
     connectStream(audioContext, stream) {
         const node = this.captureNode();
         if (!node || stream.getAudioTracks().length === 0) {
-            return;
+            return null;
         }
         const source = audioContext.createMediaStreamSource(stream);
         source.connect(node);
-    }
-    /** Concatenates a half-open sample range [from, to) across the captured frames into one Float32Array. */
-    collectSamples(from, to) {
-        const out = new Float32Array(Math.max(0, to - from));
-        if (out.length === 0) {
-            return out;
-        }
-        let cursor = 0; // absolute sample index at the start of the current frame
-        let written = 0;
-        for (const frame of this.pcmFrames) {
-            const frameStart = cursor;
-            const frameEnd = cursor + frame.length;
-            cursor = frameEnd;
-            if (frameEnd <= from) {
-                continue; // entirely before the window
-            }
-            if (frameStart >= to) {
-                break; // entirely after the window
-            }
-            const sliceStart = Math.max(0, from - frameStart);
-            const sliceEnd = Math.min(frame.length, to - frameStart);
-            for (let i = sliceStart; i < sliceEnd; i++) {
-                out[written++] = frame[i];
-            }
-        }
-        return written === out.length ? out : out.subarray(0, written);
+        return source;
     }
     /**
-     * Converts a mono Float32 buffer to a little-endian PCM16 `ArrayBuffer` (for raw crash-recovery
-     * shards). Returns the backing `ArrayBuffer` directly so it's a valid `BlobPart`.
+     * Turns recording off after a setup failure and releases the graph. Audio already captured stays
+     * queued for the encoder, so a graph failure mid-call still keeps what was recorded before it.
      */
-    floatToPcm16Bytes(samples) {
-        const buffer = new ArrayBuffer(samples.length * 2);
-        const view = new DataView(buffer);
-        for (let i = 0; i < samples.length; i++) {
-            const s = samples[i] < -1 ? -1 : samples[i] > 1 ? 1 : samples[i];
-            view.setInt16(i * 2, s < 0 ? s * 0x8000 : s * 0x7fff, true);
-        }
-        return buffer;
-    }
-    /** Encodes all accumulated PCM into a single seekable WAV blob, or `null` when nothing captured. */
-    encodeWavBlob() {
-        if (this.totalSamples === 0 || this.sampleRate === 0) {
-            return null;
-        }
-        const all = this.collectSamples(0, this.totalSamples);
-        const wav = EncodePcm16Wav(all, this.sampleRate);
-        return new Blob([wav], { type: RealtimeAudioRecorder.wavMimeType });
-    }
-    /** Releases the audio graph + capture node and resets state. Idempotent. */
-    cleanup() {
+    disable() {
         this.recording = false;
-        this.pcmFrames = [];
-        this.totalSamples = 0;
-        this.flushedSampleCount = 0;
-        this.sampleRate = 0;
-        this.peaks = new PeakAccumulator(RealtimeAudioRecorder.peakBuckets);
+        this.releaseGraph();
+    }
+    /** Releases the audio graph + capture node. Idempotent; leaves the encoder and the sample count alone. */
+    releaseGraph() {
+        this.setupGeneration++;
         this.remoteAttached = false;
         this.pendingRemoteStream = null;
+        this.micStream = null;
+        this.micSource = null;
         if (this.workletNode) {
             this.workletNode.port.onmessage = null;
-            try {
-                this.workletNode.disconnect();
-            }
-            catch { /* already disconnected */ }
+            this.disconnectNode(this.workletNode);
             this.workletNode = null;
         }
         if (this.scriptNode) {
             this.scriptNode.onaudioprocess = null;
-            try {
-                this.scriptNode.disconnect();
-            }
-            catch { /* already disconnected */ }
+            this.disconnectNode(this.scriptNode);
             this.scriptNode = null;
         }
         this.destination = null;
+        this.resampler = null;
         if (this.audioContext) {
-            void this.audioContext.close().catch(() => { });
+            this.closeContext(this.audioContext);
             this.audioContext = null;
         }
     }
+    disconnectNode(node) {
+        try {
+            node.disconnect();
+        }
+        catch (error) {
+            // Expected when the node was never connected or is already disconnected; nothing to release.
+            console.debug('[RealtimeAudioRecorder] Capture node disconnect skipped:', error);
+        }
+    }
+    closeContext(audioContext) {
+        void audioContext.close().catch((error) => {
+            // A context that is already closed rejects here; the graph is released either way.
+            console.debug('[RealtimeAudioRecorder] AudioContext close skipped:', error);
+        });
+    }
 }
 //# sourceMappingURL=realtime-audio-recorder.js.map