@qvac/sdk 0.11.0 → 0.12.0

package/dist/commands/verify/node-modules-source.js

@@ -0,0 +1,76 @@
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { deduplicateAddons, readAddonPackageJson, } from "./addon-source.js";
+export class InvalidNodeModulesSourceError extends Error {
+    nodeModulesPath;
+    constructor(nodeModulesPath, cause) {
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        super(`node_modules at ${nodeModulesPath} could not be read.\n\n` +
+            `  Reason: ${reason}\n\n` +
+            "  Run `npm install` before invoking verifyBundle against a node_modules tree.");
+        this.name = "InvalidNodeModulesSourceError";
+        this.nodeModulesPath = nodeModulesPath;
+    }
+}
+export async function collectAddonsFromNodeModules(options) {
+    const { nodeModulesRoot, diagnostics } = options;
+    const addons = [];
+    await walkNodeModules(nodeModulesRoot, addons, diagnostics, true);
+    return deduplicateAddons(addons);
+}
+async function walkNodeModules(nodeModulesDir, addons, diagnostics, isRoot) {
+    let entries;
+    try {
+        entries = await fsp.readdir(nodeModulesDir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (isRoot)
+            throw new InvalidNodeModulesSourceError(nodeModulesDir, error);
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith("."))
+            continue;
+        if (!isPackageEntry(entry))
+            continue;
+        if (entry.name.startsWith("@")) {
+            await walkScopeDirectory(path.join(nodeModulesDir, entry.name), addons, diagnostics);
+            continue;
+        }
+        await visitPackageDirectory(path.join(nodeModulesDir, entry.name), entry.name, addons, diagnostics);
+    }
+}
+async function walkScopeDirectory(scopeDir, addons, diagnostics) {
+    const scope = path.basename(scopeDir);
+    let entries;
+    try {
+        entries = await fsp.readdir(scopeDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith("."))
+            continue;
+        if (!isPackageEntry(entry))
+            continue;
+        await visitPackageDirectory(path.join(scopeDir, entry.name), `${scope}/${entry.name}`, addons, diagnostics);
+    }
+}
+function isPackageEntry(entry) {
+    return entry.isDirectory() || entry.isSymbolicLink();
+}
+async function visitPackageDirectory(packageDir, packageName, addons, diagnostics) {
+    const result = await readAddonPackageJson({
+        packageJsonPath: path.join(packageDir, "package.json"),
+        expectedName: packageName,
+    });
+    if (result.isAddon && result.addon) {
+        addons.push(result.addon);
+    }
+    else if (result.invalid !== undefined && diagnostics !== undefined) {
+        diagnostics.invalidPackageJsons.push(result.invalid);
+    }
+    const nestedNodeModules = path.join(packageDir, "node_modules");
+    await walkNodeModules(nestedNodeModules, addons, diagnostics, false);
+}

package/dist/commands/verify/prebuilds.d.ts

@@ -0,0 +1,15 @@
+import { type NativeAddon } from "./addon-source";
+export interface MissingPrebuildIssue {
+    code: "missing-prebuild";
+    level: "error";
+    addon: string;
+    host: string;
+    message: string;
+    packageRoot: string;
+}
+export interface CheckPrebuildsOptions {
+    addon: NativeAddon;
+    hosts: string[];
+}
+export declare function checkPrebuilds(options: CheckPrebuildsOptions): Promise<MissingPrebuildIssue[]>;
+//# sourceMappingURL=prebuilds.d.ts.map

package/dist/commands/verify/prebuilds.js

@@ -0,0 +1,39 @@
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { formatAddonId } from "./addon-source.js";
+export async function checkPrebuilds(options) {
+    const { addon, hosts } = options;
+    const issues = [];
+    for (const host of hosts) {
+        const hostDir = path.join(addon.packageRoot, "prebuilds", host);
+        const present = await hasBarePrebuild(hostDir);
+        if (!present) {
+            issues.push({
+                code: "missing-prebuild",
+                level: "error",
+                addon: formatAddonId(addon),
+                host,
+                packageRoot: addon.packageRoot,
+                message: `${formatAddonId(addon)} is missing a prebuild for ${host} ` +
+                    `(expected ${path.join(hostDir, "*.bare")}).`,
+            });
+        }
+    }
+    return issues;
+}
+async function hasBarePrebuild(hostDir) {
+    let entries;
+    try {
+        entries = await fsp.readdir(hostDir, { withFileTypes: true });
+    }
+    catch {
+        return false;
+    }
+    for (const entry of entries) {
+        if (!entry.isFile() && !entry.isSymbolicLink())
+            continue;
+        if (entry.name.endsWith(".bare"))
+            return true;
+    }
+    return false;
+}

package/dist/examples/classification/classify-image.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=classify-image.d.ts.map

package/dist/examples/classification/classify-image.js

@@ -0,0 +1,23 @@
+import fs from "fs";
+import { startQVACProvider, stopQVACProvider, loadModel, classify, unloadModel } from "@qvac/sdk";
+/**
+ * Classify an image using the bundled MobileNetV3-Small model.
+ *
+ * The bundled model produces three classes: "food", "report", "other".
+ * No modelSrc is needed — the model ships inside @qvac/classification-ggml.
+ */
+async function main() {
+    await startQVACProvider({});
+    const modelId = await loadModel({
+        modelType: "ggml-classification",
+    });
+    const image = fs.readFileSync("image.jpg");
+    const results = await classify({ modelId, image });
+    console.log("Classification results:");
+    for (const { label, confidence } of results) {
+        console.log(`  ${label}: ${(confidence * 100).toFixed(1)}%`);
+    }
+    await unloadModel({ modelId });
+    await stopQVACProvider();
+}
+main().catch(console.error);

package/dist/examples/diffusion-txt2vid.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=diffusion-txt2vid.d.ts.map

package/dist/examples/diffusion-txt2vid.js

@@ -0,0 +1,81 @@
+import { loadModel, unloadModel, video, WAN2_1_T2V_1_3B_FP16, UMT5_XXL_FP16, WAN_2_1_COMFYUI_REPACKAGED_VAE, } from "@qvac/sdk";
+import fs from "fs";
+import path from "path";
+// Text-to-video with Wan 2.1 T2V 1.3B. Wan uses a split layout:
+// a diffusion model + a UMT5-XXL text encoder + a VAE.
+// This example needs powerful hardware: at least 16 GB of video memory or
+// 20 GB of unified memory.
+const diffusionModelSrc = process.argv[2] || WAN2_1_T2V_1_3B_FP16;
+const t5XxlModelSrc = process.argv[3] || UMT5_XXL_FP16;
+const vaeModelSrc = process.argv[4] || WAN_2_1_COMFYUI_REPACKAGED_VAE;
+// Prompt tip: Wan 1.3B is small and has weak temporal priors. Use motion-
+// explicit verbs and avoid static framing words like "standing", "still",
+// or "portrait" in the positive prompt.
+const prompt = process.argv[5] ||
+    "a colorful bird flapping its wings";
+const outputDir = process.argv[6] || ".";
+try {
+    console.log("Loading Wan 2.1 T2V model (diffusion + UMT5-XXL + VAE)...");
+    const modelId = await loadModel({
+        modelSrc: diffusionModelSrc,
+        modelType: "diffusion",
+        modelConfig: {
+            mode: "video",
+            device: "gpu",
+            threads: 4,
+            t5XxlModelSrc,
+            vaeModelSrc,
+            diffusion_fa: true,
+            offload_to_cpu: true,
+            vae_on_cpu: true,
+            vae_tiling: true,
+        },
+        onProgress: (p) => console.log(`Loading: ${p.percentage.toFixed(1)}%`),
+    });
+    console.log(`Model loaded: ${modelId}`);
+    console.log(`\nGenerating video for: "${prompt}"`);
+    const { progressStream, outputs, stats } = video({
+        modelId,
+        mode: "txt2vid",
+        prompt,
+        negative_prompt: "blurry, low quality, static, jittery, watermark",
+        width: 480,
+        height: 832,
+        // Frame count must satisfy (4*k + 1), k >= 1. Common values at 16 fps:
+        // 17 frames ~= 1.06s (very fast, ~6 min on M3 Ultra Metal)
+        // 33 frames ~= 2.06s (default in this example, ~11 min)
+        // 49 frames ~= 3.06s (~17 min)
+        // 65 frames ~= 4.06s (~22 min)
+        // 81 frames ~= 5.06s (Wan 1.3B native training length, best motion
+        // quality, ~28 min)
+        // Going beyond 81 can degrade quality because it exceeds the model's
+        // positional embeddings.
+        video_frames: 33,
+        fps: 16,
+        steps: 30,
+        cfg_scale: 6.0,
+        // Wan 2.1 T2V needs flow_shift=3.0 for visible motion. Higher values can
+        // make consecutive frames near-identical, which looks like a frozen video.
+        flow_shift: 3.0,
+        seed: 42,
+        vae_tiling: true,
+    });
+    for await (const { step, totalSteps } of progressStream) {
+        process.stdout.write(`\rStep ${step}/${totalSteps}`);
+    }
+    console.log();
+    const buffers = await outputs;
+    for (let i = 0; i < buffers.length; i++) {
+        const outputPath = path.join(outputDir, `wan_t2v_${i}.avi`);
+        fs.writeFileSync(outputPath, buffers[i]);
+        console.log(`Saved: ${outputPath}`);
+    }
+    console.log("\nStats:", await stats);
+    await unloadModel({ modelId, clearStorage: false });
+    console.log("Done.");
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/plugins.js

@@ -10,7 +10,7 @@
  *   3. Embeddings        -> fails (plugin not selected)
  *
  */
-import { execSync } from "child_process";
+import { bundleSdk } from "../commands/index.js";
 import { existsSync, rmSync } from "fs";
 import path from "path";
 const configDir = import.meta.dirname ?? process.cwd();
@@ -23,14 +23,10 @@ console.log(`⚠️  This example will generate a worker bundle in ${qvacOutputD
 console.log("   If you have an existing qvac/ folder with bundled files, they will be overwritten and removed.\n");
 console.log("🔨 Generating worker bundle from plugins config...\n");
 try {
-    execSync(`npx @qvac/cli bundle sdk --config "${configPath}" --quiet`, {
-        cwd: projectRoot,
-        stdio: "inherit",
-    });
+    await bundleSdk({ projectRoot, configPath, quiet: true });
 }
 catch (error) {
-    console.error("❌ Failed to generate worker bundle. Ensure @qvac/cli is installed:");
-    console.error("   npm install -D @qvac/cli");
+    console.error("❌ Failed to generate worker bundle.");
     console.error("❌ Error:", error);
     process.exit(1);
 }

package/dist/examples/tools/llamacpp-tools-gemma4.js

@@ -15,12 +15,9 @@
  * Usage:
  *   bun run bare:example dist/examples/tools/llamacpp-tools-gemma4.js <model-url>
  */
-import { completion, loadModel, unloadModel, } from "@qvac/sdk";
+import { completion, loadModel, unloadModel, GEMMA4_2B_MULTIMODAL_Q4_K_M, } from "@qvac/sdk";
 import { tools, mockExecute } from "./shared.js";
-// bartowski's pack tags <eos> as the EOG token (matching the base tokenizer),
-// ensuring generation stops correctly; unsloth's variant maps it differently.
-const GEMMA4_HF = "https://huggingface.co/bartowski/google_gemma-4-E2B-it-GGUF/resolve/main/google_gemma-4-E2B-it-Q4_K_M.gguf";
-const modelSrc = process.argv[2] ?? GEMMA4_HF;
+const modelSrc = process.argv[2] ?? GEMMA4_2B_MULTIMODAL_Q4_K_M;
 let modelId;
 try {
     modelId = await loadModel({

package/dist/examples/tools/llamacpp-tools-qwen35.js

@@ -11,10 +11,9 @@
  * Usage:
  *   bun run bare:example dist/examples/tools/llamacpp-tools-qwen35.js <model-url>
  */
-import { completion, loadModel, unloadModel, } from "@qvac/sdk";
+import { completion, loadModel, unloadModel, QWEN3_5_0_8B_MULTIMODAL_Q8_0, } from "@qvac/sdk";
 import { tools, mockExecute } from "./shared.js";
-const QWEN35_HF = "https://huggingface.co/unsloth/Qwen3.5-0.8B-GGUF/resolve/main/Qwen3.5-0.8B-Q8_0.gguf";
-const modelSrc = process.argv[2] ?? QWEN35_HF;
+const modelSrc = process.argv[2] ?? QWEN3_5_0_8B_MULTIMODAL_Q8_0;
 let modelId;
 try {
     modelId = await loadModel({

package/dist/examples/transcription/parakeet-ctc-filesystem.js

@@ -1,24 +1,30 @@
-import { loadModel, unloadModel, transcribe, PARAKEET_CTC_FP32, PARAKEET_CTC_TOKENIZER, } from "@qvac/sdk";
+/**
+ * Parakeet CTC transcription from a WAV file.
+ *
+ * Usage:
+ *   bun run examples/transcription/parakeet-ctc-filesystem.ts <wav-file> [parakeet-ctc-gguf]
+ *
+ * Loads a single GGUF checkpoint (`PARAKEET_CTC_0_6B_Q8_0` by default) and
+ * transcribes the file with the batch `transcribe` API. Omit the model
+ * argument to use the registry constant.
+ *
+ * Audio should be 16 kHz mono PCM in a WAV container.
+ */
+import { loadModel, unloadModel, transcribe, PARAKEET_CTC_0_6B_Q8_0, } from "@qvac/sdk";
 const args = process.argv.slice(2);
 if (!args[0]) {
     console.error("Usage: bun run examples/transcription/parakeet-ctc-filesystem.ts <wav-file> " +
-        "[model.onnx] [tokenizer.json]");
-    console.error("\nIf model paths are omitted, defaults to registry models.");
+        "[parakeet-ctc-gguf]");
+    console.error("\nIf the model path is omitted, defaults to the registry model.");
     process.exit(1);
 }
 const audioFilePath = args[0];
-const parakeetCtcModelSrc = args[1] ?? PARAKEET_CTC_FP32;
-const parakeetTokenizerSrc = args[2] ?? PARAKEET_CTC_TOKENIZER;
+const parakeetModelSrc = args[1] ?? PARAKEET_CTC_0_6B_Q8_0;
 try {
     console.log("Loading Parakeet CTC model...");
     const modelId = await loadModel({
-        modelSrc: parakeetCtcModelSrc,
+        modelSrc: parakeetModelSrc,
         modelType: "parakeet",
-        modelConfig: {
-            modelType: "ctc",
-            parakeetCtcModelSrc,
-            parakeetTokenizerSrc,
-        },
         onProgress: (progress) => {
             console.log(`Download progress: ${progress.percentage.toFixed(1)}%`);
         },
@@ -33,6 +39,6 @@ try {
     console.log("Done");
 }
 catch (error) {
-    console.error("Error:", error);
+    console.error("❌ Error:", error);
     process.exit(1);
 }

package/dist/examples/transcription/parakeet-microphone-record.js

@@ -1,14 +1,15 @@
 /**
- * Microphone → Parakeet transcription using chunked `transcribe` calls.
+ * Microphone → Parakeet batch transcription (chunked `transcribe`).
  *
- * Usage: bun run examples/transcription/parakeet-microphone-record.ts
+ * Usage:
+ *   bun run examples/transcription/parakeet-microphone-record.ts
  *
- * Captures 3-second audio chunks from the microphone and sends each to the
- * batch `transcribe` API. Press Ctrl+C to quit.
+ * Captures 3 s s16le chunks from the microphone and sends each to `transcribe`
+ * with the TDT model. Press Ctrl+C to stop.
  *
  * Requirements: FFmpeg installed, microphone access.
  */
-import { loadModel, unloadModel, transcribe, PARAKEET_TDT_ENCODER_FP32, PARAKEET_TDT_DECODER_FP32, PARAKEET_TDT_VOCAB, PARAKEET_TDT_PREPROCESSOR_FP32, } from "@qvac/sdk";
+import { loadModel, unloadModel, transcribe, PARAKEET_TDT_0_6B_V3_Q8_0, } from "@qvac/sdk";
 import { spawnSync } from "child_process";
 import { startMicrophone } from "../audio/mic-input";
 const SAMPLE_RATE = 16000;
@@ -27,14 +28,8 @@ catch {
 }
 console.log("Loading Parakeet model...");
 const modelId = await loadModel({
-    modelSrc: PARAKEET_TDT_ENCODER_FP32,
+    modelSrc: PARAKEET_TDT_0_6B_V3_Q8_0,
     modelType: "parakeet",
-    modelConfig: {
-        parakeetEncoderSrc: PARAKEET_TDT_ENCODER_FP32,
-        parakeetDecoderSrc: PARAKEET_TDT_DECODER_FP32,
-        parakeetVocabSrc: PARAKEET_TDT_VOCAB,
-        parakeetPreprocessorSrc: PARAKEET_TDT_PREPROCESSOR_FP32,
-    },
     onProgress: (p) => console.log(`Download: ${p.percentage.toFixed(1)}%`),
 });
 console.log("Model loaded.\n");

package/dist/examples/transcription/parakeet-microphone-stream.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parakeet-microphone-stream.d.ts.map

package/dist/examples/transcription/parakeet-microphone-stream.js

@@ -0,0 +1,79 @@
+/**
+ * Microphone → Parakeet duplex streaming (`transcribeStream`).
+ *
+ * Usage:
+ *   bun run examples/transcription/parakeet-microphone-stream.ts
+ *
+ * Streams microphone audio through `transcribeStream` with
+ * `parakeetStreamingConfig`. Uses the EOU checkpoint so you may see
+ * `{ type: "endOfTurn", source: "parakeet" }` events; CTC/TDT models
+ * emit transcript text only. Parakeet does not yield standalone VAD events.
+ *
+ * Requirements: FFmpeg installed, microphone access.
+ */
+import { loadModel, unloadModel, transcribeStream, PARAKEET_EOU_120M_V1_Q8_0, } from "@qvac/sdk";
+import { spawnSync } from "child_process";
+import { startMicrophone } from "../audio/mic-input";
+const SAMPLE_RATE = 16000;
+try {
+    const r = spawnSync("ffmpeg", ["-version"], { stdio: "ignore" });
+    if (r.error || r.status !== 0)
+        throw new Error("FFmpeg not found");
+}
+catch {
+    console.error("Error: FFmpeg is required. Install it and try again.");
+    process.exit(1);
+}
+let modelId = null;
+let ffmpeg = null;
+async function cleanup() {
+    console.log("\n\nStopping...");
+    ffmpeg?.kill();
+    if (modelId)
+        await unloadModel({ modelId });
+    console.log("Done.");
+}
+process.on("SIGINT", () => {
+    void cleanup().finally(() => process.exit(0));
+});
+process.on("SIGTERM", () => {
+    void cleanup().finally(() => process.exit(0));
+});
+try {
+    console.log("Loading Parakeet (EOU) streaming model...");
+    modelId = await loadModel({
+        modelSrc: PARAKEET_EOU_120M_V1_Q8_0,
+        modelType: "parakeet",
+        onProgress: (p) => console.log(`Download: ${p.percentage.toFixed(1)}%`),
+    });
+    console.log("Model loaded.\n");
+    ffmpeg = startMicrophone({ sampleRate: SAMPLE_RATE, format: "s16le" });
+    const session = await transcribeStream({
+        modelId,
+        parakeetStreamingConfig: {
+            chunkMs: 1000,
+            emitPartials: true,
+        },
+    });
+    ffmpeg.stdout.on("data", (chunk) => session.write(chunk));
+    console.log("Listening... speak and pause to see transcripts. End-of-turn boundaries fire when the EOU model emits an <EOU> token.\n");
+    for await (const event of session) {
+        switch (event.type) {
+            case "text":
+                if (event.text.trim()) {
+                    process.stdout.write(`${event.text}`);
+                }
+                break;
+            case "endOfTurn":
+                console.log("\n[endOfTurn] turn boundary detected\n");
+                break;
+        }
+    }
+    await cleanup();
+    process.exit(0);
+}
+catch (error) {
+    console.error("Error:", error);
+    await cleanup();
+    process.exit(1);
+}

package/dist/examples/transcription/parakeet-sortformer-streaming.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parakeet-sortformer-streaming.d.ts.map

package/dist/examples/transcription/parakeet-sortformer-streaming.js

@@ -0,0 +1,121 @@
+/**
+ * Sortformer v2.1 streaming diarization via duplex `transcribeStream` + AOSC.
+ *
+ * Usage:
+ *   bun run examples/transcription/parakeet-sortformer-streaming.ts <wav-file> [sortformer-gguf]
+ *
+ * Streams 16 kHz mono s16le audio in real-time-paced chunks (required for parakeet
+ * duplex streaming). Loads v2.1 with AOSC knobs in `modelConfig`. Omit the model
+ * argument to use `PARAKEET_SORTFORMER_4SPK_V2_1_Q8_0`.
+ *
+ * For offline batch diarization (Sortformer + TDT), see `parakeet-sortformer.ts`.
+ */
+import { loadModel, unloadModel, transcribeStream, PARAKEET_SORTFORMER_4SPK_V2_1_Q8_0, } from "@qvac/sdk";
+import { spawn } from "child_process";
+const SAMPLE_RATE = 16000;
+const BYTES_PER_S16_SAMPLE = 2;
+const STREAM_CHUNK_MS = 2000;
+/** NeMo-port AOSC defaults for v2.1 Sortformer (`parakeet.model_variant` in GGUF). */
+const SORTFORMER_V21_AOSC_LOAD_CONFIG = {
+    streaming: true,
+    streamingChunkMs: 2000,
+    streamingChunkRightContextMs: 560,
+    streamingSpkCacheEnable: true,
+    streamingSpkCacheLen: 188,
+    streamingFifoLen: 188,
+    streamingChunkLeftContextMs: 80,
+    streamingSpkCacheUpdatePeriod: 144,
+};
+const args = process.argv.slice(2);
+if (!args[0]) {
+    console.error("Usage: bun run examples/transcription/parakeet-sortformer-streaming.ts <wav-file-path> [sortformer-gguf]");
+    console.error("\nDefaults to the v2.1 q8_0 registry model (PARAKEET_SORTFORMER_4SPK_V2_1_Q8_0).");
+    process.exit(1);
+}
+const audioFilePath = args[0];
+const sortformerOverride = args[1];
+const chunkBytes = Math.floor((STREAM_CHUNK_MS / 1000) * SAMPLE_RATE) * BYTES_PER_S16_SAMPLE;
+let modelId = null;
+async function cleanup() {
+    if (modelId) {
+        await unloadModel({ modelId });
+    }
+}
+function readS16leFromWav(wavPath) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        const proc = spawn("ffmpeg", [
+            "-i",
+            wavPath,
+            "-ar",
+            String(SAMPLE_RATE),
+            "-ac",
+            "1",
+            "-f",
+            "s16le",
+            "pipe:1",
+        ], { stdio: ["ignore", "pipe", "ignore"] });
+        proc.stdout.on("data", (buf) => chunks.push(buf));
+        proc.on("error", reject);
+        proc.on("close", (code) => {
+            if (code !== 0) {
+                reject(new Error(`ffmpeg exited with code ${code}`));
+                return;
+            }
+            const merged = Buffer.concat(chunks);
+            resolve(new Uint8Array(merged.buffer, merged.byteOffset, merged.byteLength));
+        });
+    });
+}
+const loadOptions = {
+    modelType: "parakeet-transcription",
+    modelConfig: { ...SORTFORMER_V21_AOSC_LOAD_CONFIG },
+    onProgress: (p) => console.log(`Download: ${p.percentage.toFixed(1)}%`),
+    ...(sortformerOverride
+        ? { modelSrc: sortformerOverride }
+        : { modelSrc: PARAKEET_SORTFORMER_4SPK_V2_1_Q8_0 }),
+};
+try {
+    console.log("Loading Sortformer v2.1 with streaming + AOSC (load-time config)...");
+    modelId = await loadModel(loadOptions);
+    console.log(`Model loaded: ${modelId}\n`);
+    const session = await transcribeStream({
+        modelId,
+        parakeetStreamingConfig: { chunkMs: STREAM_CHUNK_MS },
+    });
+    console.log(`Streaming ${audioFilePath} in ${STREAM_CHUNK_MS}ms chunks (wall-clock paced)...\n`);
+    const pcm = await readS16leFromWav(audioFilePath);
+    const trailingSilenceMs = 1500;
+    const trailingBytes = new Uint8Array(Math.floor((trailingSilenceMs / 1000) * SAMPLE_RATE) * BYTES_PER_S16_SAMPLE);
+    for (let offset = 0; offset < pcm.length; offset += chunkBytes) {
+        const end = Math.min(offset + chunkBytes, pcm.length);
+        session.write(pcm.subarray(offset, end));
+        if (end < pcm.length) {
+            await new Promise((resolve) => setTimeout(resolve, STREAM_CHUNK_MS));
+        }
+    }
+    for (let offset = 0; offset < trailingBytes.length; offset += chunkBytes) {
+        const end = Math.min(offset + chunkBytes, trailingBytes.length);
+        session.write(trailingBytes.subarray(offset, end));
+        if (end < trailingBytes.length) {
+            await new Promise((resolve) => setTimeout(resolve, STREAM_CHUNK_MS));
+        }
+    }
+    session.end();
+    const lines = [];
+    for await (const event of session) {
+        if (event.type === "text" && event.text.trim()) {
+            lines.push(event.text.trim());
+            console.log(event.text.trim());
+        }
+    }
+    console.log("\n=== Streaming diarization transcript ===");
+    console.log(lines.join("\n") || "(no speaker lines emitted)");
+    await cleanup();
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    await cleanup();
+    process.exit(1);
+}