@elizaos/plugin-local-inference 2.0.0-beta.1 → 2.0.3-beta.3

package/src/services/voice/streaming-asr/streaming-pipeline-adapter.ts

@@ -0,0 +1,292 @@
+/**
+ * Streaming-ASR pipeline adapter (item A1 / W7).
+ *
+ * The base `VoicePipeline` in `voice/pipeline.ts` drives a `StreamingTranscriber`
+ * as a batch: it pushes the WHOLE VAD-gated utterance buffer in a single
+ * `feed()` call, awaits `flush()`, and only then splits the final transcript
+ * into tokens for the drafter/verifier loop. That works for the fused
+ * batch decoder, but it leaves the biggest
+ * H2 UX seam (incremental partials → planner / barge-in word-confirm /
+ * speculative-on-pause) untapped when the fused build is in streaming mode.
+ *
+ * Rather than rewrite `pipeline.ts` (the Phase 0/1 agent owns it), this
+ * module is a small WRAPPER the engine bridge can use to deliver PCM
+ * chunks to a `StreamingTranscriber` as they arrive from the mic / VAD,
+ * surface every `partial` event to the turn controller via `onPartial`,
+ * and only finalize on `speech-end`. Behind a flag — when the fused
+ * library advertises `asrStreamSupported() === false` or the flag is off
+ * the caller keeps using `VoicePipeline.transcribeAll` exactly as today.
+ *
+ * Integration point (documented for the Phase 0/1 agent so they can wire
+ * it without merge friction):
+ *
+ *   1. `EngineVoiceBridge` decides whether streaming is available via
+ *      `pickStreamingMode({ ffi, asrBundlePresent, flag })`. When the
+ *      mode is `"streaming"`, the bridge constructs `StreamingAsrFeeder`
+ *      once per turn (passing the same transcriber that would have been
+ *      handed to `VoicePipeline`) and routes mic PCM frames through
+ *      `feeder.feedFrame(frame)` instead of buffering them.
+ *   2. The feeder forwards every transcriber `partial` event to
+ *      `onPartial(update)`. When VAD reports `speech-end` the caller
+ *      calls `await feeder.finalize()`; the returned `TranscriptUpdate`
+ *      is the final and is used to seed the drafter/verifier loop exactly
+ *      as before (`splitTranscriptToTokens(final.partial, 0, final.tokens)`).
+ *   3. The batch path (`VoicePipeline.transcribeAll`) is unchanged for
+ *      every other adapter — there is no fork in `pipeline.ts` itself.
+ *
+ * This file is intentionally small and side-effect-free so it can land
+ * during the merge window without touching files other agents own.
+ */
+
+import { splitTranscriptToTokens } from "../pipeline";
+import type {
+	PcmFrame,
+	StreamingTranscriber,
+	TextToken,
+	TranscriptUpdate,
+} from "../types";
+
+/* ==================================================================== *
+ * LocalAgreementBuffer — word-level streaming-ASR partial stabilizer.
+ *
+ * Streaming ASR emits a fresh word-sequence hypothesis on every audio
+ * frame. Individual words near the end of the hypothesis can change
+ * across frames ("sat" → "cap" → "sat") before settling. This buffer
+ * applies LocalAgreement-n (n=2 default) at the word level: a word is
+ * emitted to downstream only when it appears at the same position in n
+ * consecutive hypotheses. The committed stable prefix is monotonically
+ * non-decreasing — once a word is committed it is never retracted.
+ *
+ * Word-level (not character-level): suited for the VAD pipeline adapter
+ * where downstream consumers (drafter, verifier) operate on word tokens.
+ * For the character-level prefix variant, see `partial-stabilizer.ts`.
+ * ==================================================================== */
+
+/**
+ * LocalAgreement-n word-level partial stabilizer.
+ *
+ * Usage:
+ *   const buf = new LocalAgreementBuffer();
+ *   const stable = buf.stable(["hello", "there", "world"]);
+ *   // → [] on first call (need n=2 consecutive identical prefix)
+ *   const stable2 = buf.stable(["hello", "there", "how"]);
+ *   // → ["hello", "there"] (matched across two consecutive hypotheses)
+ */
+export class LocalAgreementBuffer {
+	private readonly n: number;
+	/** Rolling window of the last `n` hypotheses, oldest first. */
+	private window: string[][] = [];
+	/** Monotonically growing committed word list. */
+	private committed: string[] = [];
+
+	constructor(n = 2) {
+		if (!Number.isFinite(n) || n < 1) {
+			throw new Error(
+				`[LocalAgreementBuffer] n must be a finite integer >= 1; got ${String(n)}`,
+			);
+		}
+		this.n = Math.floor(n);
+	}
+
+	/**
+	 * Feed the latest word-level hypothesis. Returns the stable committed
+	 * prefix — the longest leading word sequence that has appeared
+	 * identically in `n` consecutive calls. Monotonically non-decreasing.
+	 *
+	 * A rolling window of the last `n` hypotheses is maintained. Once the
+	 * window is full, the agreed prefix is the intersection across all `n`
+	 * entries — word i is in the agreed prefix only if it is identical in
+	 * every hypothesis in the window.
+	 */
+	stable(current: string[]): string[] {
+		this.window.push(current);
+		if (this.window.length > this.n) {
+			this.window.shift();
+		}
+		// Need a full window of `n` hypotheses before any word can be agreed.
+		if (this.window.length < this.n) {
+			return this.committed;
+		}
+		// Intersect: the agreed prefix is the longest common leading prefix
+		// across all entries in the window.
+		const first = this.window[0];
+		if (!first) {
+			throw new Error("hypothesis window unexpectedly empty");
+		}
+		let agreedLen = first.length;
+		for (let i = 1; i < this.window.length; i++) {
+			const h = this.window[i];
+			if (!h) {
+				throw new Error(`missing hypothesis at index ${i}`);
+			}
+			let matchLen = 0;
+			const limit = Math.min(agreedLen, h.length);
+			for (let j = 0; j < limit; j++) {
+				if (first[j] === h[j]) matchLen++;
+				else break;
+			}
+			agreedLen = matchLen;
+			if (agreedLen === 0) break;
+		}
+		// Extend committed if the new agreement is longer.
+		if (agreedLen > this.committed.length) {
+			this.committed = first.slice(0, agreedLen);
+		}
+		return this.committed;
+	}
+
+	/** Clear all state. Call at utterance boundaries. */
+	reset(): void {
+		this.window = [];
+		this.committed = [];
+	}
+
+	/** The current committed stable word list (read-only view). */
+	getCommitted(): string[] {
+		return this.committed;
+	}
+}
+
+/** Available transcription drive modes. */
+export type StreamingPipelineMode = "streaming" | "batch";
+
+export interface PickStreamingModeArgs {
+	/** True only when the loaded fused library advertises a working streaming decoder. */
+	ffiSupportsStreaming: boolean;
+	/** True only when the bundled ASR model is present on disk. */
+	asrBundlePresent: boolean;
+	/**
+	 * Feature flag — defaults to FALSE so the streaming path stays opt-in
+	 * until the Phase 0/1 partial-stabilizer wiring lands. Once that lands
+	 * the engine bridge flips this default to true.
+	 */
+	enableStreaming: boolean;
+}
+
+/**
+ * Choose the transcription drive mode. Streaming is selected only when:
+ *   - the loaded fused library advertises a working streaming decoder
+ *     (`asr_stream_supported() === 1`), AND
+ *   - the bundled ASR model is present, AND
+ *   - the engine bridge has opted in via `enableStreaming`.
+ *
+ * Any other combination falls back to the existing batch path
+ * (`VoicePipeline.transcribeAll`).
+ */
+export function pickStreamingMode(
+	args: PickStreamingModeArgs,
+): StreamingPipelineMode {
+	if (!args.enableStreaming) return "batch";
+	if (!args.ffiSupportsStreaming) return "batch";
+	if (!args.asrBundlePresent) return "batch";
+	return "streaming";
+}
+
+export interface StreamingAsrFeederEvents {
+	/**
+	 * Called for every transcriber `partial` event the feeder observes
+	 * BEFORE the segment is finalized. Includes the running `partial`
+	 * text, `isFinal: false`, and (when the fused build supplied them)
+	 * the shared text-model token ids.
+	 */
+	onPartial?(update: TranscriptUpdate): void;
+	/**
+	 * Called the first time ≥1 real word is recognized in the segment.
+	 * Wired into the turn controller's word-confirm gate so the agent
+	 * only barge-in-cancels on real speech, not blips.
+	 */
+	onWords?(words: ReadonlyArray<string>): void;
+	/**
+	 * Called once, after `finalize()` returns, with the final transcript
+	 * split into contiguous text tokens (`splitTranscriptToTokens`). The
+	 * batch path delivers the same shape via `transcribeAll`, so the
+	 * downstream drafter/verifier loop sees an identical signal.
+	 */
+	onFinalTokens?(
+		tokens: ReadonlyArray<TextToken>,
+		final: TranscriptUpdate,
+	): void;
+}
+
+/**
+ * Drives a `StreamingTranscriber` chunk-by-chunk on behalf of the engine
+ * bridge / turn controller. One instance per active speech segment;
+ * `finalize()` returns the final transcript and the feeder is disposed.
+ *
+ * Construction takes a `StreamingTranscriber` (already constructed via
+ * `createStreamingTranscriber` with the same options used for batch).
+ * The feeder does NOT own the transcriber's lifecycle — disposal still
+ * runs through the engine bridge so the same path is used when the
+ * batch fallback is taken.
+ */
+export class StreamingAsrFeeder {
+	private readonly transcriber: StreamingTranscriber;
+	private readonly events: StreamingAsrFeederEvents;
+	private latestPartial: TranscriptUpdate | null = null;
+	private finalized = false;
+	private unsubscribe: (() => void) | null = null;
+
+	constructor(args: {
+		transcriber: StreamingTranscriber;
+		events?: StreamingAsrFeederEvents;
+	}) {
+		this.transcriber = args.transcriber;
+		this.events = args.events ?? {};
+		this.unsubscribe = this.transcriber.on((event) => {
+			switch (event.kind) {
+				case "partial":
+					this.latestPartial = event.update;
+					this.events.onPartial?.(event.update);
+					break;
+				case "words":
+					this.events.onWords?.(event.words);
+					break;
+				case "final":
+					// Final events are surfaced via `finalize()`'s return value so
+					// the caller has a single point of truth. We do not re-emit
+					// them here.
+					break;
+			}
+		});
+	}
+
+	/**
+	 * Feed one PCM frame as it arrives from the mic / connector. Drops
+	 * frames received after `finalize()` (the segment is over).
+	 */
+	feedFrame(frame: PcmFrame): void {
+		if (this.finalized) return;
+		this.transcriber.feed(frame);
+	}
+
+	/**
+	 * Force-finalize on `speech-end`. Resolves with the final transcript
+	 * and emits `onFinalTokens` so the caller can seed the drafter /
+	 * verifier loop without re-running the surface split itself.
+	 *
+	 * Calling `finalize()` twice is a hard error — the segment is over.
+	 */
+	async finalize(): Promise<TranscriptUpdate> {
+		if (this.finalized) {
+			throw new Error(
+				"[streaming-asr] finalize() called twice on the same feeder",
+			);
+		}
+		this.finalized = true;
+		const final = await this.transcriber.flush();
+		const tokens = splitTranscriptToTokens(final.partial, 0, final.tokens);
+		this.events.onFinalTokens?.(tokens, final);
+		return final;
+	}
+
+	/** The most recent `partial` snapshot observed, or `null` until the first decode lands. */
+	getLatestPartial(): TranscriptUpdate | null {
+		return this.latestPartial;
+	}
+
+	/** Detach the transcriber subscription. Does NOT dispose the transcriber itself. */
+	dispose(): void {
+		this.unsubscribe?.();
+		this.unsubscribe = null;
+	}
+}

package/src/services/voice/system-audio-sink.test.ts

@@ -0,0 +1,29 @@
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { WavFileAudioSink } from "./system-audio-sink";
+
+describe("WavFileAudioSink", () => {
+	it("drain resets buffered samples without dropping artifact chunks", async () => {
+		const dir = mkdtempSync(path.join(tmpdir(), "eliza-audio-sink-"));
+		const filePath = path.join(dir, "out.wav");
+		try {
+			const sink = new WavFileAudioSink({ sampleRate: 24_000, filePath });
+			sink.write(new Float32Array([0.1, 0.2, 0.3]), 24_000);
+			expect(sink.bufferedSamples()).toBe(3);
+
+			sink.drain();
+			expect(sink.bufferedSamples()).toBe(0);
+			await sink.finalize();
+
+			const wav = readFileSync(filePath);
+			expect(wav.subarray(0, 4).toString("ascii")).toBe("RIFF");
+			expect(wav.subarray(8, 12).toString("ascii")).toBe("WAVE");
+			expect(wav.readUInt32LE(40)).toBe(6);
+			expect(wav.length).toBe(50);
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+});

package/src/services/voice/system-audio-sink.ts

@@ -0,0 +1,366 @@
+/**
+ * System audio sinks for the interactive voice harness.
+ *
+ * The voice scheduler writes synthesized PCM (`Float32Array` mono in
+ * [-1, 1] at the bridge sample rate) into an {@link AudioSink}. For tests
+ * and headless runs `InMemoryAudioSink` (in `./ring-buffer`) captures the
+ * samples; for an interactive session the harness needs the audio to
+ * actually come out of the speakers.
+ *
+ * `SystemAudioSink` shells out to a long-lived player that reads raw 16-bit
+ * signed-LE PCM on stdin. Per-platform selection (priority order):
+ *   - Linux:   `aplay` (alsa-utils), else `paplay` (PulseAudio), else
+ *              `play`/`sox` (sox), else `ffplay` (ffmpeg).
+ *   - macOS:   `play`/`sox` (sox), else `ffplay` (ffmpeg). `afplay` needs a
+ *              file (no stdin) so it cannot be used for streaming.
+ *   - Windows: `ffplay` (ffmpeg), else `play`/`sox` if installed. PowerShell's
+ *              `Media.SoundPlayer` also needs a file, not a stream, so it's not
+ *              used here — the renderer's `AudioContext` path (feeding nothing
+ *              here; the renderer plays directly) is the no-ffmpeg route.
+ * If no player is on `PATH`, `available()` returns false and the harness
+ * falls back to `WavFileAudioSink` (writes a rolling WAV) — never silence.
+ *
+ * `WavFileAudioSink` accumulates everything written and serializes a
+ * single mono PCM16 WAV on `finalize()` — used by `--no-audio` and as the
+ * no-player fallback.
+ */
+
+import { type ChildProcessByStdio, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import type { Writable } from "node:stream";
+import type { AudioSink } from "./types";
+
+function which(bin: string): string | null {
+	const pathEnv = process.env.PATH ?? "";
+	const exts =
+		process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+	for (const dir of pathEnv.split(path.delimiter)) {
+		for (const ext of exts) {
+			const candidate = path.join(dir, bin + ext);
+			if (existsSync(candidate)) return candidate;
+		}
+	}
+	return null;
+}
+
+function floatToPcm16(pcm: Float32Array): Buffer {
+	const out = Buffer.allocUnsafe(pcm.length * 2);
+	for (let i = 0; i < pcm.length; i++) {
+		let s = pcm[i];
+		if (s > 1) s = 1;
+		else if (s < -1) s = -1;
+		out.writeInt16LE((s * 0x7fff) | 0, i * 2);
+	}
+	return out;
+}
+
+function soxRawArgs(sampleRate: number): string[] {
+	return [
+		"-q",
+		"-t",
+		"raw",
+		"-r",
+		String(sampleRate),
+		"-e",
+		"signed",
+		"-b",
+		"16",
+		"-c",
+		"1",
+		"-",
+	];
+}
+
+function ffplayRawArgs(sampleRate: number): string[] {
+	// ffplay reads raw PCM with -f s16le; -nodisp suppresses the window,
+	// -autoexit quits at EOF, -i - reads stdin.
+	return [
+		"-loglevel",
+		"error",
+		"-nodisp",
+		"-autoexit",
+		"-f",
+		"s16le",
+		"-ar",
+		String(sampleRate),
+		"-ac",
+		"1",
+		"-i",
+		"-",
+	];
+}
+
+/** Pick a CLI player that reads raw PCM16-LE on stdin, for the host platform. */
+function resolvePlayer(
+	sampleRate: number,
+): { bin: string; args: string[] } | null {
+	if (process.platform === "linux") {
+		const aplay = which("aplay");
+		if (aplay) {
+			return {
+				bin: aplay,
+				args: [
+					"-q",
+					"-f",
+					"S16_LE",
+					"-c",
+					"1",
+					"-r",
+					String(sampleRate),
+					"-t",
+					"raw",
+					"-",
+				],
+			};
+		}
+		const paplay = which("paplay");
+		if (paplay) {
+			return {
+				bin: paplay,
+				args: [
+					"--raw",
+					`--format=s16le`,
+					"--channels=1",
+					`--rate=${sampleRate}`,
+				],
+			};
+		}
+		const play = which("play");
+		if (play) return { bin: play, args: soxRawArgs(sampleRate) };
+		const sox = which("sox");
+		if (sox) return { bin: sox, args: [...soxRawArgs(sampleRate), "-d"] };
+		const ffplay = which("ffplay");
+		if (ffplay) return { bin: ffplay, args: ffplayRawArgs(sampleRate) };
+		return null;
+	}
+	if (process.platform === "darwin") {
+		// `afplay` needs a file (no stdin), so it can't stream — use sox/ffplay.
+		const play = which("play");
+		if (play) return { bin: play, args: soxRawArgs(sampleRate) };
+		const sox = which("sox");
+		if (sox) return { bin: sox, args: [...soxRawArgs(sampleRate), "-d"] };
+		const ffplay = which("ffplay");
+		if (ffplay) return { bin: ffplay, args: ffplayRawArgs(sampleRate) };
+		return null;
+	}
+	if (process.platform === "win32") {
+		const ffplay = which("ffplay");
+		if (ffplay) return { bin: ffplay, args: ffplayRawArgs(sampleRate) };
+		const play = which("play");
+		if (play) return { bin: play, args: soxRawArgs(sampleRate) };
+		const sox = which("sox");
+		if (sox) return { bin: sox, args: [...soxRawArgs(sampleRate), "-d"] };
+		return null;
+	}
+	// Other (BSD, etc.) — best-effort sox/ffplay.
+	const play = which("play");
+	if (play) return { bin: play, args: soxRawArgs(sampleRate) };
+	const ffplay = which("ffplay");
+	if (ffplay) return { bin: ffplay, args: ffplayRawArgs(sampleRate) };
+	return null;
+}
+
+/**
+ * Exported view of {@link resolvePlayer} for the cross-platform preflight
+ * (`voice:interactive --platform-report`). Returns the bare program name
+ * (no args) the host would stream synthesized audio to, or `null`.
+ */
+export function resolveSystemPlayerName(sampleRate = 24_000): string | null {
+	const spec = resolvePlayer(sampleRate);
+	return spec ? path.basename(spec.bin) : null;
+}
+
+export interface SystemAudioSinkOptions {
+	sampleRate: number;
+}
+
+/**
+ * Streams synthesized PCM to a long-lived CLI player (`aplay` / `paplay` /
+ * sox `play`). `write()` is non-blocking — PCM is buffered into the
+ * player's stdin pipe. `drain()` is a barge-in hook: it kills the current
+ * player so queued audio stops within a tick, then a fresh player is
+ * spawned lazily on the next `write()`.
+ */
+type StdinPipeProcess = ChildProcessByStdio<Writable, null, null>;
+
+export class SystemAudioSink implements AudioSink {
+	private readonly sampleRate: number;
+	private readonly playerSpec: { bin: string; args: string[] } | null;
+	private proc: StdinPipeProcess | null = null;
+	private buffered = 0;
+
+	constructor(opts: SystemAudioSinkOptions) {
+		this.sampleRate = opts.sampleRate;
+		this.playerSpec = resolvePlayer(opts.sampleRate);
+	}
+
+	available(): boolean {
+		return this.playerSpec !== null;
+	}
+
+	player(): string {
+		return this.playerSpec ? path.basename(this.playerSpec.bin) : "(none)";
+	}
+
+	private ensureProc(): StdinPipeProcess | null {
+		if (!this.playerSpec) return null;
+		if (this.proc && !this.proc.killed && this.proc.exitCode === null)
+			return this.proc;
+		const child = spawn(this.playerSpec.bin, this.playerSpec.args, {
+			stdio: ["pipe", "ignore", "ignore"] as const,
+		});
+		child.on("error", () => {
+			// Player vanished mid-stream — drop it; next write retries.
+			if (this.proc === child) this.proc = null;
+		});
+		child.on("exit", () => {
+			if (this.proc === child) this.proc = null;
+			this.buffered = 0;
+		});
+		this.proc = child;
+		return child;
+	}
+
+	write(pcm: Float32Array, _sampleRate: number): void {
+		const child = this.ensureProc();
+		if (!child?.stdin.writable) return;
+		const bytes = floatToPcm16(pcm);
+		this.buffered += pcm.length;
+		child.stdin.write(bytes, () => {
+			this.buffered = Math.max(0, this.buffered - pcm.length);
+		});
+	}
+
+	drain(): void {
+		// Barge-in: stop the player immediately. The next write spawns a fresh
+		// one so the new turn's audio isn't queued behind cancelled audio.
+		if (this.proc) {
+			try {
+				this.proc.stdin.destroy();
+			} catch {
+				/* ignore */
+			}
+			try {
+				this.proc.kill("SIGKILL");
+			} catch {
+				/* ignore */
+			}
+			this.proc = null;
+		}
+		this.buffered = 0;
+	}
+
+	bufferedSamples(): number {
+		return this.buffered;
+	}
+
+	/** Flush + close the player. Idempotent. */
+	async dispose(): Promise<void> {
+		const child = this.proc;
+		this.proc = null;
+		if (!child) return;
+		await new Promise<void>((resolve) => {
+			let done = false;
+			const finish = () => {
+				if (done) return;
+				done = true;
+				resolve();
+			};
+			child.on("exit", finish);
+			child.on("error", finish);
+			try {
+				child.stdin.end();
+			} catch {
+				finish();
+			}
+			// Don't hang on a stuck player.
+			setTimeout(() => {
+				try {
+					child.kill("SIGKILL");
+				} catch {
+					/* ignore */
+				}
+				finish();
+			}, 1500);
+		});
+	}
+}
+
+export interface WavFileAudioSinkOptions {
+	sampleRate: number;
+	filePath: string;
+}
+
+/**
+ * Accumulates all written PCM and serializes a single mono PCM16 WAV on
+ * {@link finalize}. Used by `--no-audio` and as the no-player fallback so
+ * a headless run still produces an inspectable artifact (never silence).
+ */
+export class WavFileAudioSink implements AudioSink {
+	private readonly sampleRate: number;
+	private readonly filePath: string;
+	private readonly chunks: Float32Array[] = [];
+	private buffered = 0;
+
+	constructor(opts: WavFileAudioSinkOptions) {
+		this.sampleRate = opts.sampleRate;
+		this.filePath = opts.filePath;
+	}
+
+	write(pcm: Float32Array, _sampleRate: number): void {
+		this.chunks.push(pcm.slice());
+		this.buffered += pcm.length;
+	}
+
+	drain(): void {
+		// The WAV sink keeps everything (it's an artifact, not a live stream),
+		// so `drain()` only resets the "buffered" counter the scheduler reads.
+		this.buffered = 0;
+	}
+
+	bufferedSamples(): number {
+		return this.buffered;
+	}
+
+	totalSamples(): number {
+		let n = 0;
+		for (const c of this.chunks) n += c.length;
+		return n;
+	}
+
+	async finalize(): Promise<string> {
+		const total = this.totalSamples();
+		const dataBytes = total * 2;
+		const header = Buffer.allocUnsafe(44);
+		header.write("RIFF", 0, "ascii");
+		header.writeUInt32LE(36 + dataBytes, 4);
+		header.write("WAVE", 8, "ascii");
+		header.write("fmt ", 12, "ascii");
+		header.writeUInt32LE(16, 16); // PCM fmt chunk size
+		header.writeUInt16LE(1, 20); // PCM
+		header.writeUInt16LE(1, 22); // mono
+		header.writeUInt32LE(this.sampleRate, 24);
+		header.writeUInt32LE(this.sampleRate * 2, 28); // byte rate
+		header.writeUInt16LE(2, 32); // block align
+		header.writeUInt16LE(16, 34); // bits per sample
+		header.write("data", 36, "ascii");
+		header.writeUInt32LE(dataBytes, 40);
+		const body = Buffer.allocUnsafe(dataBytes);
+		let off = 0;
+		for (const chunk of this.chunks) {
+			for (let i = 0; i < chunk.length; i++) {
+				let s = chunk[i];
+				if (s > 1) s = 1;
+				else if (s < -1) s = -1;
+				body.writeInt16LE((s * 0x7fff) | 0, off);
+				off += 2;
+			}
+		}
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.writeFile(this.filePath, Buffer.concat([header, body]));
+		return this.filePath;
+	}
+}