gentle-pi 4.2.0 → 4.4.0

package/tests/voice-install.test.ts

@@ -0,0 +1,323 @@
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { gzipSync } from "node:zlib";
+import { gentlePiConfigHome } from "../lib/agent-home.ts";
+import type { VoiceModelManifest, VoiceNpmPackage, VoiceRuntimeManifest } from "../lib/voice-artifacts.ts";
+import {
+	installVoiceModel,
+	installVoiceRuntime,
+	readVoiceComponentStatus,
+	resolveVoiceHome,
+	VoiceInstallError,
+	type VoiceFetch,
+	type VoiceInstallProgress,
+} from "../lib/voice-install.ts";
+
+// Optional voice acquisition (S1-S3): the runtime and the Parakeet model are
+// downloaded only on explicit request, verified by size and digest while they
+// stream, staged privately and published with one rename. Every rejection must
+// leave no published component and no staging behind, and never touch an
+// install that already exists. The network is injected; scratch stays in tmp/.
+
+const repoRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+
+function scratch(t: test.TestContext): string {
+	const base = join(repoRoot, "tmp");
+	mkdirSync(base, { recursive: true });
+	const dir = mkdtempSync(join(base, "voice-tests-"));
+	t.after(() => rmSync(dir, { recursive: true, force: true }));
+	return join(dir, "voice");
+}
+
+const sha256 = (data: Buffer) => createHash("sha256").update(data).digest("hex");
+const sha512 = (data: Buffer) => `sha512-${createHash("sha512").update(data).digest("base64")}`;
+
+interface Route { status?: number; headers?: Record<string, string>; chunks?: Buffer[]; stallAfter?: number }
+
+function fakeFetch(routes: Record<string, Route>): { fetch: VoiceFetch; calls: string[] } {
+	const calls: string[] = [];
+	const fetch: VoiceFetch = async (url, init) => {
+		calls.push(url);
+		assert.equal(init.redirect, "manual");
+		const route = routes[url];
+		if (!route) return new Response("missing", { status: 404 });
+		const chunks = route.chunks ?? [];
+		let index = 0;
+		const body = route.status && route.status >= 300 && route.status < 400 ? null : new ReadableStream<Uint8Array>({
+			pull(controller) {
+				if (route.stallAfter !== undefined && index >= route.stallAfter) return new Promise<void>(() => {});
+				if (index >= chunks.length) { controller.close(); return; }
+				controller.enqueue(new Uint8Array(chunks[index++]!));
+			},
+		});
+		return new Response(body, { status: route.status ?? 200, headers: route.headers });
+	};
+	return { fetch, calls };
+}
+
+const halves = (data: Buffer) => [data.subarray(0, data.length >> 1), data.subarray(data.length >> 1)];
+
+const HF = "https://huggingface.co/acme/tiny/resolve/0123456789abcdef0123456789abcdef01234567";
+const CDN = "https://us.aws.cdn.hf.co/xet-bridge-us/blob";
+
+function modelFixture(files: Record<string, Buffer>): VoiceModelManifest {
+	return {
+		id: "tiny-model-0123456",
+		revision: "0123456789abcdef0123456789abcdef01234567",
+		baseUrl: HF,
+		files: Object.entries(files).map(([name, data]) => ({ name, size: data.length, sha256: sha256(data) })),
+		redirects: [
+			{ origin: "https://huggingface.co", pathPrefix: "/api/resolve-cache/models/acme/tiny/0123456789abcdef0123456789abcdef01234567/" },
+			{ origin: "https://us.aws.cdn.hf.co", pathPrefix: "/xet-bridge-us/" },
+		],
+	};
+}
+
+const encoder = Buffer.from("encoder-bytes-".repeat(64));
+const tokens = Buffer.from("a 0\nb 1\n");
+
+function modelRoutes(overrides: Record<string, Route> = {}): Record<string, Route> {
+	return {
+		// The observed Hugging Face shapes: a relative 307 into resolve-cache for
+		// plain files and an absolute 302 to the regional Xet CDN for LFS files.
+		[`${HF}/encoder.onnx`]: { status: 302, headers: { location: `${CDN}/encoder?sig=1` } },
+		[`${CDN}/encoder?sig=1`]: { headers: { "content-length": String(encoder.length) }, chunks: halves(encoder) },
+		[`${HF}/tokens.txt`]: { status: 307, headers: { location: "/api/resolve-cache/models/acme/tiny/0123456789abcdef0123456789abcdef01234567/tokens.txt?x=1" } },
+		["https://huggingface.co/api/resolve-cache/models/acme/tiny/0123456789abcdef0123456789abcdef01234567/tokens.txt?x=1"]: { chunks: [tokens] },
+		...overrides,
+	};
+}
+
+const modelManifest = () => modelFixture({ "encoder.onnx": encoder, "tokens.txt": tokens });
+
+function leftovers(voiceHome: string): string[] {
+	if (!existsSync(voiceHome)) return [];
+	return readdirSync(voiceHome).filter((name) => name.startsWith(".staging"));
+}
+
+async function rejects(promise: Promise<unknown>, code: string): Promise<VoiceInstallError> {
+	try { await promise; } catch (error) {
+		assert.ok(error instanceof VoiceInstallError, String(error));
+		assert.equal(error.code, code, error.message);
+		return error;
+	}
+	assert.fail(`expected ${code}`);
+}
+
+test("the voice home lives under the Gentle AI config home and reports components as missing", async (t) => {
+	const env = { GENTLE_PI_CONFIG_HOME: join(repoRoot, "tmp", "voice-config") };
+	assert.equal(resolveVoiceHome(env), join(gentlePiConfigHome(env), "voice"));
+	const voiceHome = scratch(t);
+	const status = await readVoiceComponentStatus({ voiceHome, kind: "model", manifest: modelManifest() });
+	assert.equal(status.state, "missing");
+	assert.equal(existsSync(voiceHome), false, "status never creates the voice home");
+});
+
+test("the model streams through permitted redirects, is verified and published atomically", async (t) => {
+	const voiceHome = scratch(t);
+	const { fetch } = fakeFetch(modelRoutes());
+	const progress: VoiceInstallProgress[] = [];
+	const result = await installVoiceModel({ voiceHome, manifest: modelManifest(), fetch, onProgress: (p) => progress.push(p) });
+	assert.equal(result.alreadyInstalled, false);
+	assert.equal(readFileSync(join(result.path, "encoder.onnx")).equals(encoder), true);
+	assert.equal(readFileSync(join(result.path, "tokens.txt")).equals(tokens), true);
+	assert.equal((await readVoiceComponentStatus({ voiceHome, kind: "model", manifest: modelManifest() })).state, "installed");
+	assert.deepEqual(leftovers(voiceHome), []);
+	const downloads = progress.filter((p) => p.phase === "download");
+	assert.ok(downloads.length >= 3);
+	assert.equal(downloads.at(-1)!.overallReceivedBytes, encoder.length + tokens.length);
+	assert.equal(downloads.at(-1)!.overallTotalBytes, encoder.length + tokens.length);
+	assert.ok(downloads.every((p, i) => i === 0 || p.overallReceivedBytes >= downloads[i - 1]!.overallReceivedBytes));
+	if (process.platform !== "win32") assert.equal(statSync(voiceHome).mode & 0o077, 0, "voice home is private");
+});
+
+test("an installed component is reported as such without any network access", async (t) => {
+	const voiceHome = scratch(t);
+	await installVoiceModel({ voiceHome, manifest: modelManifest(), fetch: fakeFetch(modelRoutes()).fetch });
+	const second = fakeFetch(modelRoutes());
+	const result = await installVoiceModel({ voiceHome, manifest: modelManifest(), fetch: second.fetch });
+	assert.equal(result.alreadyInstalled, true);
+	assert.deepEqual(second.calls, []);
+});
+
+test("a digest mismatch is rejected and leaves nothing published or staged", async (t) => {
+	const voiceHome = scratch(t);
+	const tampered = Buffer.from(tokens); tampered[0] = 0x7a;
+	const { fetch } = fakeFetch(modelRoutes({ ["https://huggingface.co/api/resolve-cache/models/acme/tiny/0123456789abcdef0123456789abcdef01234567/tokens.txt?x=1"]: { chunks: [tampered] } }));
+	await rejects(installVoiceModel({ voiceHome, manifest: modelManifest(), fetch }), "integrity");
+	assert.equal((await readVoiceComponentStatus({ voiceHome, kind: "model", manifest: modelManifest() })).state, "missing");
+	assert.deepEqual(leftovers(voiceHome), []);
+});
+
+test("a body longer than the pinned size is cut off as a size violation", async (t) => {
+	const voiceHome = scratch(t);
+	const { fetch } = fakeFetch(modelRoutes({ [`${CDN}/encoder?sig=1`]: { chunks: [encoder, Buffer.from("extra")] } }));
+	await rejects(installVoiceModel({ voiceHome, manifest: modelManifest(), fetch }), "size");
+	const mismatchedLength = fakeFetch(modelRoutes({ [`${CDN}/encoder?sig=1`]: { headers: { "content-length": "1" }, chunks: [encoder] } }));
+	await rejects(installVoiceModel({ voiceHome, manifest: modelManifest(), fetch: mismatchedLength.fetch }), "size");
+	assert.deepEqual(leftovers(voiceHome), []);
+});
+
+test("redirects outside the permitted hosts, paths or HTTPS are refused before they are followed", async (t) => {
+	const voiceHome = scratch(t);
+	for (const location of ["https://evil.example/xet-bridge-us/blob", "http://us.aws.cdn.hf.co/xet-bridge-us/blob", "https://us.aws.cdn.hf.co/other/blob"]) {
+		const { fetch, calls } = fakeFetch(modelRoutes({ [`${HF}/encoder.onnx`]: { status: 302, headers: { location } } }));
+		await rejects(installVoiceModel({ voiceHome, manifest: modelManifest(), fetch }), "redirect");
+		assert.equal(calls.includes(location), false, location);
+	}
+	assert.deepEqual(leftovers(voiceHome), []);
+});
+
+test("cancelling mid-download aborts, cleans the staging and publishes nothing", async (t) => {
+	const voiceHome = scratch(t);
+	const controller = new AbortController();
+	const { fetch } = fakeFetch(modelRoutes({ [`${CDN}/encoder?sig=1`]: { chunks: halves(encoder), stallAfter: 1 } }));
+	const pending = installVoiceModel({
+		voiceHome, manifest: modelManifest(), fetch, signal: controller.signal,
+		onProgress: (p) => { if (p.phase === "download") controller.abort(); },
+	});
+	await rejects(pending, "aborted");
+	assert.equal((await readVoiceComponentStatus({ voiceHome, kind: "model", manifest: modelManifest() })).state, "missing");
+	assert.deepEqual(leftovers(voiceHome), []);
+});
+
+test("a stalled download is aborted by the idle time bound", async (t) => {
+	const voiceHome = scratch(t);
+	const { fetch } = fakeFetch(modelRoutes({ [`${CDN}/encoder?sig=1`]: { chunks: halves(encoder), stallAfter: 1 } }));
+	await rejects(installVoiceModel({ voiceHome, manifest: modelManifest(), fetch, timeouts: { idleMs: 30, totalMs: 5_000 } }), "timeout");
+	assert.deepEqual(leftovers(voiceHome), []);
+});
+
+test("a failed install never disturbs an existing component directory", async (t) => {
+	const voiceHome = scratch(t);
+	const finalPath = join(voiceHome, "models", modelManifest().id);
+	mkdirSync(finalPath, { recursive: true });
+	writeFileSync(join(finalPath, "encoder.onnx"), "previous");
+	assert.equal((await readVoiceComponentStatus({ voiceHome, kind: "model", manifest: modelManifest() })).state, "invalid");
+	const { fetch } = fakeFetch(modelRoutes({ [`${CDN}/encoder?sig=1`]: { chunks: [Buffer.from("wrong")] } }));
+	await rejects(installVoiceModel({ voiceHome, manifest: modelManifest(), fetch }), "size");
+	assert.equal(readFileSync(join(finalPath, "encoder.onnx"), "utf8"), "previous");
+	assert.deepEqual(readdirSync(finalPath), ["encoder.onnx"]);
+	// A verified install replaces the invalid one only as a whole.
+	const result = await installVoiceModel({ voiceHome, manifest: modelManifest(), fetch: fakeFetch(modelRoutes()).fetch });
+	assert.equal(readFileSync(join(result.path, "encoder.onnx")).equals(encoder), true);
+	assert.deepEqual(leftovers(voiceHome), []);
+});
+
+// --- Runtime packages -------------------------------------------------------
+
+interface TarEntry { name: string; data?: Buffer; type?: string; mode?: number; linkname?: string; prefix?: string; size?: number }
+
+function tarHeader(entry: TarEntry, size: number): Buffer {
+	const header = Buffer.alloc(512);
+	header.write(entry.name, 0, 100);
+	header.write(`${(entry.mode ?? 0o644).toString(8).padStart(6, "0")} \0`, 100);
+	header.write("000000 \0", 108);
+	header.write("000000 \0", 116);
+	header.write(`${size.toString(8).padStart(11, "0")} `, 124);
+	header.write("00000000000 ", 136);
+	header.fill(" ", 148, 156);
+	header.write(entry.type ?? "0", 156);
+	header.write(entry.linkname ?? "", 157, 100);
+	header.write("ustar\0", 257);
+	header.write("00", 263);
+	header.write(entry.prefix ?? "", 345, 155);
+	let sum = 0;
+	for (const byte of header) sum += byte;
+	header.write(`${sum.toString(8).padStart(6, "0")}\0 `, 148);
+	return header;
+}
+
+function tgz(entries: TarEntry[]): Buffer {
+	const blocks: Buffer[] = [];
+	for (const entry of entries) {
+		const data = entry.data ?? Buffer.alloc(0);
+		blocks.push(tarHeader(entry, entry.size ?? data.length), data, Buffer.alloc((512 - (data.length % 512)) % 512));
+	}
+	blocks.push(Buffer.alloc(1024));
+	return gzipSync(Buffer.concat(blocks));
+}
+
+function npmPackage(name: string, entries: TarEntry[], requiredFiles: string[], limits: { fileCount?: number; unpackedSize?: number } = {}): { pkg: VoiceNpmPackage; tarball: Buffer } {
+	const tarball = tgz(entries);
+	const unpacked = entries.reduce((total, e) => total + (e.size ?? e.data?.length ?? 0), 0);
+	return {
+		tarball,
+		pkg: {
+			name, version: "1.0.0", license: "Apache-2.0", requiredFiles,
+			tarball: `https://registry.npmjs.org/${name}/-/${name}-1.0.0.tgz`,
+			size: tarball.length, integrity: sha512(tarball),
+			fileCount: limits.fileCount ?? entries.length, unpackedSize: limits.unpackedSize ?? unpacked,
+		},
+	};
+}
+
+const loader = Buffer.from("module.exports = require('../fake-native-darwin-arm64/addon.node');\n");
+const addon = Buffer.from("\x7fnative");
+
+function runtimeFixture(nativeEntries: TarEntry[] = [{ name: "package/addon.node", data: addon, mode: 0o755 }, { name: "package/package.json", data: Buffer.from("{}") }]) {
+	const node = npmPackage("fake-node", [{ name: "package/package.json", data: Buffer.from("{}") }, { name: "package/lib/addon.js", data: loader }], ["package.json", "lib/addon.js"]);
+	const native = npmPackage("fake-native-darwin-arm64", nativeEntries, ["addon.node"]);
+	const manifest: VoiceRuntimeManifest = { id: "fake-runtime-1.0.0-darwin-arm64", target: "darwin-arm64", packages: [node.pkg, native.pkg], redirects: [] };
+	const routes: Record<string, Route> = {
+		[node.pkg.tarball]: { chunks: [node.tarball] },
+		[native.pkg.tarball]: { chunks: halves(native.tarball) },
+	};
+	return { manifest, routes };
+}
+
+test("runtime packages are verified and extracted as sibling node_modules directories", async (t) => {
+	const voiceHome = scratch(t);
+	const { manifest, routes } = runtimeFixture();
+	const result = await installVoiceRuntime({ voiceHome, target: "darwin-arm64", manifest, fetch: fakeFetch(routes).fetch });
+	assert.equal(readFileSync(join(result.path, "node_modules", "fake-node", "lib", "addon.js")).equals(loader), true);
+	const native = join(result.path, "node_modules", "fake-native-darwin-arm64", "addon.node");
+	assert.equal(readFileSync(native).equals(addon), true);
+	if (process.platform !== "win32") assert.equal(statSync(native).mode & 0o111, 0o111, "executable bit is kept");
+	assert.equal((await readVoiceComponentStatus({ voiceHome, kind: "runtime", manifest })).state, "installed");
+	assert.deepEqual(readdirSync(join(result.path, "node_modules")).sort(), ["fake-native-darwin-arm64", "fake-node"]);
+	assert.deepEqual(leftovers(voiceHome), []);
+});
+
+test("unsafe archive entries are rejected before anything is extracted", async (t) => {
+	const voiceHome = scratch(t);
+	const good = { name: "package/addon.node", data: addon };
+	const cases: Array<[string, RegExp, TarEntry[], { fileCount?: number; unpackedSize?: number }?]> = [
+		["symlink", /entry type '2'/, [good, { name: "package/link", type: "2", linkname: "/etc/passwd" }]],
+		["hardlink", /entry type '1'/, [good, { name: "package/hard", type: "1", linkname: "package/addon.node" }]],
+		["directory", /entry type '5'/, [good, { name: "package/dir/", type: "5" }]],
+		["traversal", /not a safe relative path/, [good, { name: "package/../../escape.txt", data: Buffer.from("x") }]],
+		["Windows device name", /not a safe relative path/, [good, { name: "package/lib/aux.js", data: Buffer.from("x") }]],
+		["absolute", /outside package\//, [good, { name: "/abs/escape.txt", data: Buffer.from("x") }]],
+		["outside package/", /outside package\//, [good, { name: "other/file.txt", data: Buffer.from("x") }]],
+		["duplicate", /duplicated/, [good, { name: "package/ADDON.node", data: addon }]],
+		["file used as directory", /uses a file as a directory/, [good, { name: "package/addon.node/inner", data: Buffer.from("x") }]],
+		["too many entries", /more than 1 entries/, [good, { name: "package/b.txt", data: Buffer.from("x") }], { fileCount: 1 }],
+		["too many bytes", /unpacked bytes/, [good, { name: "package/b.txt", data: Buffer.alloc(600) }], { unpackedSize: addon.length + 10 }],
+		["missing required file", /addon\.node is missing/, [{ name: "package/other.node", data: addon }]],
+	];
+	for (const [label, reason, entries, limits] of cases) {
+		const fixture = runtimeFixture();
+		const native = npmPackage("fake-native-darwin-arm64", entries, ["addon.node"], limits);
+		fixture.manifest.packages[1] = native.pkg;
+		fixture.routes[native.pkg.tarball] = { chunks: [native.tarball] };
+		const error = await rejects(installVoiceRuntime({ voiceHome, target: "darwin-arm64", manifest: fixture.manifest, fetch: fakeFetch(fixture.routes).fetch }), "archive");
+		assert.match(error.message, reason, label);
+		assert.equal((await readVoiceComponentStatus({ voiceHome, kind: "runtime", manifest: fixture.manifest })).state, "missing", label);
+		assert.deepEqual(leftovers(voiceHome), [], label);
+	}
+	assert.equal(existsSync(join(dirname(voiceHome), "escape.txt")), false);
+	assert.equal(existsSync(join(voiceHome, "escape.txt")), false);
+});
+
+test("a runtime is refused for a target outside the five known ones", async (t) => {
+	const voiceHome = scratch(t);
+	const { fetch, calls } = fakeFetch({});
+	await rejects(installVoiceRuntime({ voiceHome, target: "win32-arm64" as never, fetch }), "unsupported");
+	assert.deepEqual(calls, []);
+	assert.equal(existsSync(voiceHome), false);
+});

package/tests/voice-platform.test.ts

@@ -0,0 +1,176 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import { syncBuiltinESMExports } from "node:module";
+import test from "node:test";
+import {
+	NODE_CPAL,
+	PARAKEET_MODEL_MANIFEST,
+	SHERPA_ONNX_NODE,
+	VOICE_NOTICES,
+	VOICE_TARGETS,
+	voiceRuntimeManifest,
+} from "../lib/voice-artifacts.ts";
+import { diagnoseVoicePlatform, readVoicePlatformProbe } from "../lib/voice-platform.ts";
+
+// Optional voice (S1-S3): the platform diagnosis decides what /gentle:voice may offer.
+// It must name the five researched targets without ever claiming hardware-verified
+// support, and refuse the unproven ones with a reason instead of a broken install.
+
+const glibc = "2.35";
+
+test("the five researched targets resolve to a runtime target that is never reported as hardware verified", () => {
+	const probes = [
+		{ platform: "darwin", arch: "x64", target: "darwin-x64" },
+		{ platform: "darwin", arch: "arm64", target: "darwin-arm64" },
+		{ platform: "linux", arch: "x64", glibcVersion: glibc, target: "linux-x64" },
+		{ platform: "linux", arch: "arm64", glibcVersion: glibc, target: "linux-arm64" },
+		{ platform: "win32", arch: "x64", target: "win32-x64" },
+	];
+	assert.deepEqual(probes.map((p) => p.target), [...VOICE_TARGETS]);
+	for (const { target, ...probe } of probes) {
+		const diagnosis = diagnoseVoicePlatform(probe);
+		assert.equal(diagnosis.support, "known", target);
+		assert.equal(diagnosis.target, target);
+		assert.equal(diagnosis.transcription.available, true, target);
+		assert.equal(diagnosis.hardwareVerified, false, target);
+		assert.ok(diagnosis.limitations.some((line) => /not been verified on hardware/.test(line)), target);
+	}
+});
+
+test("Windows ARM64, musl Linux and other platforms are unsupported with a stated reason", () => {
+	const cases = [
+		{ probe: { platform: "win32", arch: "arm64" }, reason: /Windows ARM64/ },
+		{ probe: { platform: "linux", arch: "x64" }, reason: /glibc/ },
+		{ probe: { platform: "linux", arch: "ia32", glibcVersion: glibc }, reason: /linux-ia32/ },
+		{ probe: { platform: "freebsd", arch: "x64" }, reason: /freebsd-x64/ },
+	];
+	for (const { probe, reason } of cases) {
+		const diagnosis = diagnoseVoicePlatform(probe);
+		assert.equal(diagnosis.support, "unsupported", probe.platform + probe.arch);
+		assert.equal(diagnosis.target, undefined);
+		assert.equal(diagnosis.transcription.available, false);
+		assert.equal(diagnosis.microphone.available, false);
+		assert.match(diagnosis.transcription.reason ?? "", reason);
+	}
+});
+
+test("WSL keeps its Linux target but is reported as unproven rather than supported", () => {
+	const diagnosis = diagnoseVoicePlatform({ platform: "linux", arch: "x64", glibcVersion: glibc, wsl: true });
+	assert.equal(diagnosis.support, "unproven");
+	assert.equal(diagnosis.target, "linux-x64");
+	assert.ok(diagnosis.limitations.some((line) => /WSL/.test(line)));
+});
+
+test("every known target ships the pinned node-cpal capture binary for its own architecture", () => {
+	for (const target of VOICE_TARGETS) {
+		const [platform, arch] = target.split("-");
+		const diagnosis = diagnoseVoicePlatform({ platform: platform!, arch: arch!, glibcVersion: glibc });
+		assert.equal(diagnosis.microphone.available, true, target);
+		const manifest = voiceRuntimeManifest(target);
+		const capture = manifest.packages.find((p) => p.name === NODE_CPAL.name);
+		assert.equal(capture?.version, "1.0.0", target);
+		assert.ok(capture!.requiredFiles.includes(`bin/${target}/index.node`), target);
+		// The capture version is part of the runtime identity, so a runtime
+		// installed with an older node-cpal is never mistaken for this one.
+		assert.match(manifest.id, /node-cpal-1\.0\.0/, target);
+	}
+});
+
+test("native prerequisites that are not probed are stated as limitations", () => {
+	const linux = diagnoseVoicePlatform({ platform: "linux", arch: "x64", glibcVersion: glibc });
+	assert.ok(linux.limitations.some((line) => /libasound\.so\.2/.test(line)));
+	const windows = diagnoseVoicePlatform({ platform: "win32", arch: "x64" });
+	assert.ok(windows.limitations.some((line) => /vcruntime140\.dll/.test(line) && /not checked/.test(line)));
+});
+
+test("Linux with a glibc older than 2.34 is unsupported with the version it needs", () => {
+	for (const glibcVersion of ["2.31", "2.33", "1.99"]) {
+		const diagnosis = diagnoseVoicePlatform({ platform: "linux", arch: "x64", glibcVersion });
+		assert.equal(diagnosis.support, "unsupported", glibcVersion);
+		assert.equal(diagnosis.microphone.available, false);
+		assert.match(diagnosis.transcription.reason ?? "", new RegExp(`glibc 2\\.34.*${glibcVersion.replace(".", "\\.")}`));
+	}
+	for (const glibcVersion of ["2.34", "2.39", "3.0"]) {
+		assert.equal(diagnoseVoicePlatform({ platform: "linux", arch: "arm64", glibcVersion }).support, "known", glibcVersion);
+	}
+});
+
+test("the pinned manifest uses exact versions, sibling platform packages and the fixed model revision", () => {
+	for (const target of VOICE_TARGETS) {
+		const manifest = voiceRuntimeManifest(target);
+		const names = manifest.packages.map((p) => p.name);
+		const platformName = `sherpa-onnx-${target.replace(/^win32-/, "win-")}`;
+		assert.deepEqual(names.slice(0, 2), [SHERPA_ONNX_NODE.name, platformName], target);
+		for (const pkg of manifest.packages) {
+			assert.match(pkg.version, /^\d+\.\d+\.\d+$/);
+			assert.match(pkg.integrity, /^sha512-[A-Za-z0-9+/]{86}==$/);
+			assert.equal(pkg.tarball, `https://registry.npmjs.org/${pkg.name}/-/${pkg.name}-${pkg.version}.tgz`);
+			assert.ok(pkg.size > 0 && pkg.unpackedSize > 0 && pkg.fileCount > 0);
+		}
+		assert.equal(manifest.packages[1]!.version, "1.13.8");
+	}
+	assert.equal(SHERPA_ONNX_NODE.version, "1.13.8");
+	assert.equal(NODE_CPAL.version, "1.0.0");
+	assert.equal(NODE_CPAL.integrity, "sha512-d71jIzKDjw1HepqaJQMPd+/k3ZLqYZWhLAv6a8aafIGnYoA1QWlShA5iB5CgijIJtQxq9PdQAk99JQKspqlnTA==");
+	assert.deepEqual([NODE_CPAL.size, NODE_CPAL.unpackedSize, NODE_CPAL.fileCount], [7723259, 20363834, 40]);
+	assert.equal(PARAKEET_MODEL_MANIFEST.revision, "2bda32ec70b097a55adaa07d9a7173915b43cc78");
+	assert.deepEqual(
+		PARAKEET_MODEL_MANIFEST.files.map((f) => [f.name, f.size, f.sha256]),
+		[
+			["encoder.int8.onnx", 652184281, "acfc2b4456377e15d04f0243af540b7fe7c992f8d898d751cf134c3a55fd2247"],
+			["decoder.int8.onnx", 11845275, "179e50c43d1a9de79c8a24149a2f9bac6eb5981823f2a2ed88d655b24248db4e"],
+			["joiner.int8.onnx", 6355277, "3164c13fc2821009440d20fcb5fdc78bff28b4db2f8d0f0b329101719c0948b3"],
+			["tokens.txt", 93939, "d58544679ea4bc6ac563d1f545eb7d474bd6cfa467f0a6e2c1dc1c7d37e3c35d"],
+		],
+	);
+});
+
+test("the notices attribute the model, runtime and capture licenses and flag what is unresolved", () => {
+	const byComponent = new Map(VOICE_NOTICES.map((n) => [n.component, n]));
+	assert.equal(byComponent.get("parakeet-tdt-0.6b-v3")?.license, "CC-BY-4.0");
+	assert.match(byComponent.get("parakeet-tdt-0.6b-v3")?.attribution ?? "", /NVIDIA/);
+	assert.equal(byComponent.get("sherpa-onnx-node")?.license, "Apache-2.0");
+	assert.equal(byComponent.get("node-cpal")?.license, "ISC");
+	assert.ok(VOICE_NOTICES.some((n) => n.unresolved !== undefined));
+});
+
+test("readVoicePlatformProbe reports the running platform only when called", () => {
+	const probe = readVoicePlatformProbe();
+	assert.equal(probe.platform, process.platform);
+	assert.equal(probe.arch, process.arch);
+});
+
+test("importing the voice modules performs no filesystem or network IO", async (t) => {
+	// The module loader reads the sources through fs itself, so only calls made
+	// from a repository lib/ frame count as import-time IO.
+	const libFrame = new URL("../lib/", import.meta.url).href;
+	const calls: string[] = [];
+	const restore: Array<() => void> = [];
+	const trap = (target: Record<string, unknown>, label: string) => {
+		for (const key of Object.keys(target)) {
+			const original = target[key];
+			if (typeof original !== "function" || /^[A-Z]/.test(key)) continue;
+			target[key] = (...args: unknown[]) => {
+				if (new Error().stack?.includes(libFrame)) calls.push(`${label}.${key}`);
+				return (original as (...a: unknown[]) => unknown)(...args);
+			};
+			restore.push(() => { target[key] = original; });
+		}
+	};
+	trap(fs as unknown as Record<string, unknown>, "fs");
+	trap(fsPromises as unknown as Record<string, unknown>, "fs/promises");
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = (async () => { calls.push("fetch"); throw new Error("no network"); }) as typeof fetch;
+	syncBuiltinESMExports();
+	t.after(() => {
+		for (const undo of restore) undo();
+		globalThis.fetch = originalFetch;
+		syncBuiltinESMExports();
+	});
+	const fresh = `?import-io-${process.pid}-${Date.now()}`;
+	await import(`../lib/voice-artifacts.ts${fresh}`);
+	await import(`../lib/voice-platform.ts${fresh}`);
+	await import(`../lib/voice-install.ts${fresh}`);
+	assert.deepEqual(calls, []);
+});