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

package/src/services/voice/speaker/diarizer-fused.real.test.ts

@@ -0,0 +1,100 @@
+/**
+ * Real-FFI tests for `FusedDiarizer`: run against the ACTUAL fused
+ * `libelizainference` — loaded, `create`d, and probed for `diarizSupported()`
+ * — never a stub. The pyannote diarizer is the SOLE on-device diarization
+ * runtime (the `eliza_inference_diariz_*` ABI off the one fused handle), feeding
+ * its per-frame powerset labels through the shared pure `classifyFramesToSegments`
+ * reducer.
+ *
+ * Skipped (not faked) when the fused lib is not resolvable, or when it does not
+ * link the pyannote diarizer graph. To run them, point `ELIZA_INFERENCE_LIBRARY`
+ * (or `ELIZA_INFERENCE_LIB_DIR`) at a built `libelizainference` with the diarizer
+ * ABI, or build one via `packages/app-core/scripts/build-llama-cpp-mtp.mjs`.
+ * Runs in the post-merge `bun test` lane (`*.real.test.ts` is excluded from the
+ * default lane in `vitest.config.ts`).
+ */
+
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+	afterAll,
+	afterEach,
+	beforeAll,
+	beforeEach,
+	describe,
+	expect,
+	it,
+} from "vitest";
+
+import { resolveFusedLibraryPath } from "../../desktop-fused-ffi-backend-runtime";
+import {
+	type ElizaInferenceContextHandle,
+	type ElizaInferenceFfi,
+	loadElizaInferenceFfi,
+} from "../ffi-bindings";
+import { FusedDiarizer } from "./diarizer-fused";
+
+const DIARIZ_WINDOW_SAMPLES = 16_000 * 5; // 5 s @ 16 kHz
+
+const isBun = typeof (globalThis as { Bun?: unknown }).Bun !== "undefined";
+const LIB_PATH = resolveFusedLibraryPath(null, process.env);
+// The native diariz_open needs a pyannote-segmentation GGUF. Provide one via
+// ELIZA_TEST_DIARIZ_GGUF; the diarize assertion skips honestly when it isn't
+// supplied — it is never faked.
+const DIARIZ_GGUF = process.env.ELIZA_TEST_DIARIZ_GGUF?.trim();
+const HAVE_MODEL = !!DIARIZ_GGUF && existsSync(DIARIZ_GGUF);
+
+describe.skipIf(!isBun || !LIB_PATH)("FusedDiarizer — real FFI", () => {
+	let ffi: ElizaInferenceFfi;
+	let ctx: ElizaInferenceContextHandle;
+	let tmp: string;
+
+	beforeAll(() => {
+		// LIB_PATH is non-null inside the skipIf-guarded block.
+		ffi = loadElizaInferenceFfi(LIB_PATH as string);
+	});
+	afterAll(() => {
+		ffi?.close();
+	});
+	beforeEach(() => {
+		tmp = mkdtempSync(path.join(os.tmpdir(), "diarizer-fused-real-"));
+		ctx = ffi.create(tmp);
+	});
+	afterEach(() => {
+		ffi.destroy(ctx);
+		rmSync(tmp, { recursive: true, force: true });
+	});
+
+	it("isSupported() reflects the loaded build's diarizer ABI", () => {
+		expect(typeof FusedDiarizer.isSupported(ffi)).toBe("boolean");
+	});
+
+	it.skipIf(!HAVE_MODEL)(
+		"diarizeWindow() reduces real native labels into bounded segments",
+		async () => {
+			const dia = await FusedDiarizer.load({ ffi, ctx, ggufPath: DIARIZ_GGUF });
+			expect(dia.sampleRate).toBe(16_000);
+			expect(dia.modelId).toBe("pyannote-segmentation-3.0-int8");
+			// 5 s of a 180 Hz tone — a real, finite window the native graph accepts.
+			const pcm = new Float32Array(DIARIZ_WINDOW_SAMPLES);
+			for (let i = 0; i < pcm.length; i += 1) {
+				pcm[i] = 0.2 * Math.sin((2 * Math.PI * 180 * i) / 16_000);
+			}
+			const out = await dia.diarizeWindow(pcm);
+			// Every reduced segment must be well-formed: start < end, a valid local
+			// speaker id, and a confidence in [0, 1]. The exact speaker count is
+			// content-dependent and not asserted here.
+			expect(out.localSpeakerCount).toBe(
+				new Set(out.segments.map((s) => s.localSpeakerId)).size,
+			);
+			for (const seg of out.segments) {
+				expect(seg.endMs).toBeGreaterThanOrEqual(seg.startMs);
+				expect(seg.localSpeakerId).toBeGreaterThanOrEqual(0);
+				expect(seg.confidence).toBeGreaterThanOrEqual(0);
+				expect(seg.confidence).toBeLessThanOrEqual(1);
+			}
+			await dia.dispose();
+		},
+	);
+});

package/src/services/voice/speaker/diarizer-fused.ts

@@ -0,0 +1,154 @@
+/**
+ * pyannote-segmentation-3.0 diarizer — fused `libelizainference` binding
+ * (ABI v6).
+ *
+ * Drives the native pyannote diarizer through the single fused-FFI
+ * `libelizainference` handle (the merged llama.cpp fork — see
+ * `plugins/plugin-local-inference/native/CLAUDE.md` §1) via the
+ * `eliza_inference_diariz_*` ABI. This is the SOLE on-device diarizer runtime —
+ * the same `ffi`/`ctx` pair powers VAD / wake-word / speaker / TTS / ASR.
+ *
+ * The native call returns a per-frame powerset-label sequence (293 int8
+ * labels per 5 s window, each in `[0, 7)`). Agglomerative clustering and the
+ * frame→segment reduction stay JS-side: this class one-hots the labels and
+ * feeds them through the shared pure `classifyFramesToSegments` reducer.
+ *
+ * No silent fallback: when the fused build does not export the diarizer ABI
+ * (`eliza_inference_diariz_supported() == 0`) `load()` throws a structured
+ * `DiarizerUnavailableError` (AGENTS.md §3 — never fabricate a label
+ * sequence, no standalone-lib fallback).
+ */
+
+import type {
+	ElizaInferenceContextHandle,
+	ElizaInferenceFfi,
+	NativeDiarizHandle,
+} from "../ffi-bindings";
+import {
+	classifyFramesToSegments,
+	type Diarizer,
+	type DiarizerOutput,
+	DiarizerUnavailableError,
+	PYANNOTE_CLASS_COUNT,
+	PYANNOTE_FRAME_STRIDE_MS,
+	PYANNOTE_SAMPLE_RATE,
+	PYANNOTE_SEGMENTATION_3_INT8_MODEL_ID,
+	type PyannoteDiarizerModelId,
+} from "./diarizer";
+
+export interface FusedDiarizerOptions {
+	ffi: ElizaInferenceFfi;
+	ctx: ElizaInferenceContextHandle | (() => ElizaInferenceContextHandle);
+	/**
+	 * Optional explicit pyannote GGUF path. `null` lets the native runtime
+	 * resolve the bundle's `diariz/` dir (the default).
+	 */
+	ggufPath?: string | null;
+	/** Stored model id (purely informational). */
+	modelId?: PyannoteDiarizerModelId;
+}
+
+/**
+ * Fused-`libelizainference` pyannote-3 diarizer. Owns one
+ * `eliza_inference_diariz_*` session; `diarizeWindow()` runs one forward pass
+ * over a ~5 s window and reduces the powerset labels into speaker segments.
+ */
+export class FusedDiarizer implements Diarizer {
+	readonly sampleRate = PYANNOTE_SAMPLE_RATE;
+	readonly modelId: PyannoteDiarizerModelId;
+	private disposed = false;
+
+	private constructor(
+		private readonly ffi: ElizaInferenceFfi,
+		private readonly handle: NativeDiarizHandle,
+		modelId: PyannoteDiarizerModelId,
+	) {
+		this.modelId = modelId;
+	}
+
+	/**
+	 * True only when the fused `libelizainference` build exports the diarizer
+	 * ABI and advertises support at runtime.
+	 */
+	static isSupported(ffi: ElizaInferenceFfi | null | undefined): boolean {
+		if (!ffi || typeof ffi.diarizSupported !== "function") return false;
+		return ffi.diarizSupported();
+	}
+
+	/**
+	 * Open a native diarizer session. Throws `DiarizerUnavailableError` when
+	 * the runtime is not present.
+	 */
+	static async load(opts: FusedDiarizerOptions): Promise<FusedDiarizer> {
+		if (!FusedDiarizer.isSupported(opts.ffi)) {
+			throw new DiarizerUnavailableError(
+				"native-missing",
+				"[diarizer-fused] The native diarizer is not present in this libelizainference build. Rebuild with the pyannote forward graph linked in (eliza_inference_diariz_* symbols).",
+			);
+		}
+		if (
+			!opts.ffi.diarizOpen ||
+			!opts.ffi.diarizSegment ||
+			!opts.ffi.diarizClose
+		) {
+			throw new DiarizerUnavailableError(
+				"model-load-failed",
+				"[diarizer-fused] Diarizer support probe succeeded, but the required FFI methods are missing on the binding.",
+			);
+		}
+		const ctx = typeof opts.ctx === "function" ? opts.ctx() : opts.ctx;
+		const handle = opts.ffi.diarizOpen({
+			ctx,
+			ggufPath: opts.ggufPath ?? null,
+		});
+		return new FusedDiarizer(
+			opts.ffi,
+			handle,
+			opts.modelId ?? PYANNOTE_SEGMENTATION_3_INT8_MODEL_ID,
+		);
+	}
+
+	async diarizeWindow(pcm: Float32Array): Promise<DiarizerOutput> {
+		if (this.disposed) {
+			throw new DiarizerUnavailableError(
+				"model-load-failed",
+				"[diarizer-fused] diarizeWindow called after dispose()",
+			);
+		}
+		const segment = this.ffi.diarizSegment;
+		if (!segment) {
+			throw new DiarizerUnavailableError(
+				"model-load-failed",
+				"[diarizer-fused] diarizeWindow missing FFI method",
+			);
+		}
+		const labels = segment({ diariz: this.handle, pcm });
+		const frames = labels.length;
+		// One-hot the powerset labels into the frame×class tensor the shared
+		// pure reducer expects (it argmaxes back out, so the one-hot is exact).
+		const probs = new Float32Array(frames * PYANNOTE_CLASS_COUNT);
+		for (let frame = 0; frame < frames; frame += 1) {
+			const label = labels[frame] ?? -1;
+			if (label < 0 || label >= PYANNOTE_CLASS_COUNT) {
+				throw new DiarizerUnavailableError(
+					"model-load-failed",
+					`[diarizer-fused] native diarizer emitted invalid class ${label} at frame ${frame}`,
+				);
+			}
+			probs[frame * PYANNOTE_CLASS_COUNT + label] = 1;
+		}
+		return classifyFramesToSegments(
+			probs,
+			frames,
+			PYANNOTE_CLASS_COUNT,
+			0,
+			PYANNOTE_FRAME_STRIDE_MS,
+		);
+	}
+
+	async dispose(): Promise<void> {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.ffi.diarizClose?.(this.handle);
+	}
+}

package/src/services/voice/speaker/diarizer.ts

@@ -0,0 +1,218 @@
+/**
+ * pyannote-segmentation-3.0 shared types and pure segmentation logic.
+ *
+ * Diarization runs EXCLUSIVELY through the fused `libelizainference`
+ * `eliza_inference_diariz_*` ABI (`FusedDiarizer` in `diarizer-fused.ts`).
+ * The standalone `libvoice_classifier` binding has been removed — there is one
+ * on-device voice runtime.
+ *
+ * This file holds the shared types (`Diarizer`, `LocalSpeakerSegment`,
+ * `DiarizerOutput`), the model-id / window constants, the structured
+ * `DiarizerUnavailableError`, and the pure `classifyFramesToSegments` reducer
+ * the fused diarizer feeds its per-frame labels through.
+ */
+
+export const PYANNOTE_SEGMENTATION_3_INT8_MODEL_ID =
+	"pyannote-segmentation-3.0-int8" as const;
+export const PYANNOTE_SEGMENTATION_3_FP32_MODEL_ID =
+	"pyannote-segmentation-3.0-fp32" as const;
+export type PyannoteDiarizerModelId =
+	| typeof PYANNOTE_SEGMENTATION_3_INT8_MODEL_ID
+	| typeof PYANNOTE_SEGMENTATION_3_FP32_MODEL_ID;
+
+/** pyannote 3.0 segmentation window length (seconds) — model-fixed. */
+export const PYANNOTE_WINDOW_SECONDS = 5;
+/** Required mono sample rate (matches upstream training config). */
+export const PYANNOTE_SAMPLE_RATE = 16_000;
+/** Number of output frames per 5 s window (= 293 in the upstream export). */
+export const PYANNOTE_FRAMES_PER_WINDOW = 293;
+/** Per-frame stride in milliseconds (5_000ms / 293 frames ≈ 17.06 ms). */
+export const PYANNOTE_FRAME_STRIDE_MS =
+	(1_000 * PYANNOTE_WINDOW_SECONDS) / PYANNOTE_FRAMES_PER_WINDOW;
+/** Output class count — 3 single + 3 overlap + 1 silence = 7. */
+export const PYANNOTE_CLASS_COUNT = 7;
+
+/**
+ * Powerset mapping of pyannote-3 segmentation classes. Each class is
+ * the set of local speaker indices active in that frame. Class 0 is the
+ * silence/no-speaker frame. This matches the upstream `Powerset` head
+ * with `max_speakers_per_chunk=3, max_speakers_per_frame=2`.
+ */
+export const PYANNOTE_CLASS_TO_SPEAKERS: ReadonlyArray<ReadonlyArray<number>> =
+	[
+		[], // 0: silence
+		[0], // 1: speaker 0 only
+		[1], // 2: speaker 1 only
+		[2], // 3: speaker 2 only
+		[0, 1], // 4: speakers 0+1 overlap
+		[0, 2], // 5: speakers 0+2 overlap
+		[1, 2], // 6: speakers 1+2 overlap
+	];
+
+/** Thrown when the diarizer cannot be constructed. */
+export class DiarizerUnavailableError extends Error {
+	readonly code:
+		| "ort-missing"
+		| "native-missing"
+		| "library-missing"
+		| "model-missing"
+		| "model-unavailable"
+		| "model-load-failed"
+		| "model-shape-mismatch"
+		| "forward-not-implemented"
+		| "invalid-input";
+	constructor(code: DiarizerUnavailableError["code"], message: string) {
+		super(message);
+		this.name = "DiarizerUnavailableError";
+		this.code = code;
+	}
+}
+
+/**
+ * One speaker-tagged span within a diarized window. `localSpeakerId` is
+ * **window-local** (0..2): the same physical speaker gets different
+ * local ids in different windows. The profile store re-clusters local
+ * ids into stable identities via the WeSpeaker embedding cosine.
+ */
+export interface LocalSpeakerSegment {
+	startMs: number;
+	endMs: number;
+	localSpeakerId: number;
+	/** Best class confidence over the span (max softmax). */
+	confidence: number;
+	/** True if the span contains any overlap-class frames. */
+	hasOverlap: boolean;
+}
+
+export interface DiarizerOutput {
+	segments: LocalSpeakerSegment[];
+	/** Number of distinct local speakers observed in the window. */
+	localSpeakerCount: number;
+	/** Total speech (any-speaker) duration in milliseconds. */
+	speechMs: number;
+}
+
+export interface Diarizer {
+	readonly modelId: PyannoteDiarizerModelId;
+	readonly sampleRate: number;
+	/** Process one ~5 s window of PCM. */
+	diarizeWindow(pcm: Float32Array): Promise<DiarizerOutput>;
+	dispose(): Promise<void>;
+}
+
+/** Numerically-stable softmax over the last axis. */
+function softmax(row: Float32Array): Float32Array {
+	let max = -Infinity;
+	for (let i = 0; i < row.length; i += 1) {
+		if (row[i] > max) max = row[i];
+	}
+	const out = new Float32Array(row.length);
+	let sum = 0;
+	for (let i = 0; i < row.length; i += 1) {
+		out[i] = Math.exp(row[i] - max);
+		sum += out[i];
+	}
+	if (sum === 0) return out;
+	for (let i = 0; i < row.length; i += 1) out[i] /= sum;
+	return out;
+}
+
+/**
+ * Reduce a per-frame class probability tensor into one segment per
+ * (local speaker × contiguous frame run). Frames where the silence
+ * class wins are excluded; frames in overlap classes contribute to
+ * **all** speakers in that class.
+ */
+export function classifyFramesToSegments(
+	classProbs: Float32Array,
+	frames: number,
+	classCount: number,
+	startMs: number,
+	frameStrideMs: number,
+): DiarizerOutput {
+	if (classProbs.length !== frames * classCount) {
+		throw new DiarizerUnavailableError(
+			"model-load-failed",
+			`[pyannote] frame×class tensor mismatch: have ${classProbs.length}, expected ${frames * classCount}`,
+		);
+	}
+	type Active = {
+		startFrame: number;
+		endFrame: number;
+		confSum: number;
+		count: number;
+		hasOverlap: boolean;
+	};
+	// Per-speaker active runs. The pyannote-3 head supports 3 speakers.
+	const open = new Map<number, Active>();
+	const closed: Array<Active & { speakerId: number }> = [];
+
+	let speechFrames = 0;
+
+	for (let f = 0; f < frames; f += 1) {
+		const offset = f * classCount;
+		const row = classProbs.subarray(offset, offset + classCount);
+		const probs = softmax(row);
+		// Pick winning class.
+		let winner = 0;
+		let winnerProb = probs[0];
+		for (let c = 1; c < classCount; c += 1) {
+			if (probs[c] > winnerProb) {
+				winner = c;
+				winnerProb = probs[c];
+			}
+		}
+		const activeSpeakers = PYANNOTE_CLASS_TO_SPEAKERS[winner] ?? [];
+		const isOverlap = activeSpeakers.length > 1;
+		if (activeSpeakers.length > 0) speechFrames += 1;
+
+		// Close runs for speakers not active this frame.
+		for (const [sid, run] of open.entries()) {
+			if (!activeSpeakers.includes(sid)) {
+				closed.push({ ...run, speakerId: sid });
+				open.delete(sid);
+			}
+		}
+		// Open / extend runs for active speakers.
+		for (const sid of activeSpeakers) {
+			const existing = open.get(sid);
+			if (existing) {
+				existing.endFrame = f + 1;
+				existing.confSum += winnerProb;
+				existing.count += 1;
+				existing.hasOverlap = existing.hasOverlap || isOverlap;
+			} else {
+				open.set(sid, {
+					startFrame: f,
+					endFrame: f + 1,
+					confSum: winnerProb,
+					count: 1,
+					hasOverlap: isOverlap,
+				});
+			}
+		}
+	}
+	// Flush remaining open runs.
+	for (const [sid, run] of open.entries()) {
+		closed.push({ ...run, speakerId: sid });
+	}
+
+	const segments = closed
+		.map<LocalSpeakerSegment>((run) => ({
+			startMs: Math.round(startMs + run.startFrame * frameStrideMs),
+			endMs: Math.round(startMs + run.endFrame * frameStrideMs),
+			localSpeakerId: run.speakerId,
+			confidence: run.count > 0 ? run.confSum / run.count : 0,
+			hasOverlap: run.hasOverlap,
+		}))
+		.sort((a, b) =>
+			a.startMs !== b.startMs ? a.startMs - b.startMs : a.endMs - b.endMs,
+		);
+
+	const localSpeakers = new Set(segments.map((s) => s.localSpeakerId));
+	return {
+		segments,
+		localSpeakerCount: localSpeakers.size,
+		speechMs: Math.round(speechFrames * frameStrideMs),
+	};
+}

package/src/services/voice/speaker/encoder-fused.real.test.ts

@@ -0,0 +1,113 @@
+/**
+ * Real-FFI tests for `FusedSpeakerEncoder`: run against the ACTUAL fused
+ * `libelizainference` — loaded, `create`d, and probed for `speakerSupported()`
+ * — never a stub. The speaker encoder is the SOLE on-device speaker runtime
+ * (the `eliza_inference_speaker_*` ABI off the one fused handle).
+ *
+ * Skipped (not faked) when the fused lib is not resolvable, or when it does not
+ * link the WeSpeaker speaker graph. To run them, point `ELIZA_INFERENCE_LIBRARY`
+ * (or `ELIZA_INFERENCE_LIB_DIR`) at a built `libelizainference` with the speaker
+ * ABI, or build one via `packages/app-core/scripts/build-llama-cpp-mtp.mjs`.
+ * Runs in the post-merge `bun test` lane (`*.real.test.ts` is excluded from the
+ * default lane in `vitest.config.ts`).
+ */
+
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+	afterAll,
+	afterEach,
+	beforeAll,
+	beforeEach,
+	describe,
+	expect,
+	it,
+} from "vitest";
+
+import { resolveFusedLibraryPath } from "../../desktop-fused-ffi-backend-runtime";
+import {
+	type ElizaInferenceContextHandle,
+	type ElizaInferenceFfi,
+	loadElizaInferenceFfi,
+} from "../ffi-bindings";
+import { FusedSpeakerEncoder } from "./encoder-fused";
+
+const EMB_DIM = 256;
+const MIN_SAMPLES = 16_000;
+
+const isBun = typeof (globalThis as { Bun?: unknown }).Bun !== "undefined";
+const LIB_PATH = resolveFusedLibraryPath(null, process.env);
+// The native speaker_open needs a WeSpeaker GGUF. Provide one via
+// ELIZA_TEST_SPEAKER_GGUF (e.g. wespeaker-resnet34-lm.gguf); the encode
+// assertions skip honestly when it isn't supplied — they are never faked.
+const SPEAKER_GGUF = process.env.ELIZA_TEST_SPEAKER_GGUF?.trim();
+const HAVE_MODEL = !!SPEAKER_GGUF && existsSync(SPEAKER_GGUF);
+
+describe.skipIf(!isBun || !LIB_PATH)("FusedSpeakerEncoder — real FFI", () => {
+	let ffi: ElizaInferenceFfi;
+	let ctx: ElizaInferenceContextHandle;
+	let tmp: string;
+
+	beforeAll(() => {
+		// LIB_PATH is non-null inside the skipIf-guarded block.
+		ffi = loadElizaInferenceFfi(LIB_PATH as string);
+	});
+	afterAll(() => {
+		ffi?.close();
+	});
+	beforeEach(() => {
+		tmp = mkdtempSync(path.join(os.tmpdir(), "speaker-fused-real-"));
+		ctx = ffi.create(tmp);
+	});
+	afterEach(() => {
+		ffi.destroy(ctx);
+		rmSync(tmp, { recursive: true, force: true });
+	});
+
+	it("isSupported() reflects the loaded build's speaker ABI", () => {
+		expect(typeof FusedSpeakerEncoder.isSupported(ffi)).toBe("boolean");
+	});
+
+	it.skipIf(!HAVE_MODEL)(
+		"encode() returns a finite 256-d embedding off the real WeSpeaker graph",
+		async () => {
+			const enc = await FusedSpeakerEncoder.load({
+				ffi,
+				ctx,
+				ggufPath: SPEAKER_GGUF,
+			});
+			expect(enc.embeddingDim).toBe(EMB_DIM);
+			expect(enc.sampleRate).toBe(MIN_SAMPLES);
+			// 1 s of a 220 Hz tone — a real, finite input the native graph accepts.
+			const pcm = new Float32Array(MIN_SAMPLES);
+			for (let i = 0; i < pcm.length; i += 1) {
+				pcm[i] = 0.2 * Math.sin((2 * Math.PI * 220 * i) / MIN_SAMPLES);
+			}
+			const emb = await enc.encode(pcm);
+			expect(emb.length).toBe(EMB_DIM);
+			expect(emb.every((v) => Number.isFinite(v))).toBe(true);
+			// A non-degenerate embedding has real magnitude.
+			let norm = 0;
+			for (const v of emb) norm += v * v;
+			expect(Math.sqrt(norm)).toBeGreaterThan(0);
+			await enc.dispose();
+		},
+	);
+
+	it.skipIf(!HAVE_MODEL)(
+		"rejects pcm shorter than the minimum window before hitting the native graph",
+		async () => {
+			const enc = await FusedSpeakerEncoder.load({
+				ffi,
+				ctx,
+				ggufPath: SPEAKER_GGUF,
+			});
+			await expect(enc.encode(new Float32Array(100))).rejects.toMatchObject({
+				name: "SpeakerEncoderGgmlUnavailableError",
+				code: "invalid-input",
+			});
+			await enc.dispose();
+		},
+	);
+});