@juspay/neurolink 13.6.5 → 13.8.0

package/dist/voice/vad/assets.js

@@ -0,0 +1,142 @@
+/**
+ * The Silero VAD model file: the pinned revision, where it lives and the
+ * first-use download. The same rules as Whistle's assets, for one file
+ * instead of three: an explicit directory, then `NEUROLINK_VAD_DIR`, then
+ * `NEUROLINK_MODEL_DIR/silero-vad`, then the copy shipped with the package
+ * (`models/silero-vad`), then `~/.neurolink/models/silero-vad`, the only
+ * directory a download ever writes to.
+ *
+ * Upstream: `snakers4/silero-vad`, MIT.
+ *
+ * @module voice/vad/assets
+ */
+import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { ErrorCategory, ErrorSeverity } from "../../constants/enums.js";
+import { STT_ERROR_CODES } from "../../types/index.js";
+import { logger } from "../../utils/logger.js";
+import { STTError } from "../errors.js";
+import { checkModelFile, downloadModelAsset, packageModelsDir, } from "../modelAssets.js";
+const SILERO_VAD_REVISION = "bfdc0193023f121ea5b3cc7b176dbed570a68a59";
+/** The pinned model: Silero VAD v6.2, 2.3 MB, 8 and 16 kHz. */
+export const SILERO_VAD_ASSET = {
+    name: "silero_vad.onnx",
+    url: `https://raw.githubusercontent.com/snakers4/silero-vad/${SILERO_VAD_REVISION}/src/silero_vad/data/silero_vad.onnx`,
+    sha256: "1a153a22f4509e292a94e67d6f9b85e8deb25b4988682b7e174c65279d8788e3",
+    bytes: 2_327_524,
+};
+/** One in-flight preparation per directory, shared by concurrent callers. */
+const inFlight = new Map();
+/** Directories already verified in this process. */
+const verified = new Map();
+/**
+ * Where the model lives: `options.modelDir` → `NEUROLINK_VAD_DIR` →
+ * `NEUROLINK_MODEL_DIR/silero-vad` → the copy shipped with the package →
+ * `~/.neurolink/models/silero-vad`.
+ */
+export function resolveVadDir(options) {
+    const explicit = options?.modelDir?.trim() || process.env.NEUROLINK_VAD_DIR?.trim();
+    if (explicit) {
+        return resolve(explicit);
+    }
+    const modelRoot = process.env.NEUROLINK_MODEL_DIR?.trim();
+    if (modelRoot) {
+        return resolve(modelRoot, "silero-vad");
+    }
+    const root = packageModelsDir();
+    if (root) {
+        const bundled = join(root, "silero-vad");
+        if (vadModelPresent(bundled)) {
+            return bundled;
+        }
+    }
+    return join(homedir(), ".neurolink", "models", "silero-vad");
+}
+/**
+ * Whether a missing model may be fetched: on unless `options.autoDownload`
+ * is `false` or `NEUROLINK_VAD_AUTO_DOWNLOAD` is `0` / `false` / `off` / `no`.
+ */
+export function vadAutoDownloadEnabled(options) {
+    if (options?.autoDownload !== undefined) {
+        return options.autoDownload;
+    }
+    const env = process.env.NEUROLINK_VAD_AUTO_DOWNLOAD?.trim().toLowerCase();
+    return !(env === "0" || env === "false" || env === "off" || env === "no");
+}
+/** Cheap presence check (no hashing). */
+export function vadModelPresent(dir) {
+    return existsSync(join(dir, SILERO_VAD_ASSET.name));
+}
+/**
+ * Makes sure the model is in `dir` and matches its pinned hash, downloading
+ * it when missing and allowed. Resolves to the model's path. Concurrent
+ * calls for the same directory share one preparation.
+ */
+export function ensureVadModel(dir, autoDownload) {
+    const done = verified.get(dir);
+    if (done) {
+        return Promise.resolve(done);
+    }
+    const pending = inFlight.get(dir);
+    if (pending) {
+        return pending;
+    }
+    const job = prepare(dir, autoDownload)
+        .then((path) => {
+        verified.set(dir, path);
+        return path;
+    })
+        .finally(() => {
+        inFlight.delete(dir);
+    });
+    inFlight.set(dir, job);
+    return job;
+}
+async function prepare(dir, autoDownload) {
+    const path = join(dir, SILERO_VAD_ASSET.name);
+    const state = await checkModelFile(path, SILERO_VAD_ASSET);
+    if (state !== "ok") {
+        if (!autoDownload) {
+            throw modelUnavailable(dir, state === "corrupt"
+                ? `${SILERO_VAD_ASSET.name} in ${dir} does not match its pinned SHA-256, and automatic download is off`
+                : "automatic download is off (NEUROLINK_VAD_AUTO_DOWNLOAD=0 or autoDownload: false)");
+        }
+        logger.info(`[silero-vad] downloading the Silero VAD model (${Math.max(1, Math.round(SILERO_VAD_ASSET.bytes / 1_000_000))} MB) to ${dir} — first use only`);
+        try {
+            await mkdir(dir, { recursive: true });
+            await downloadModelAsset(SILERO_VAD_ASSET, dir, "silero-vad");
+        }
+        catch (error) {
+            if (error instanceof STTError) {
+                throw error;
+            }
+            throw modelUnavailable(dir, `the download failed (${error instanceof Error ? error.message : String(error)})`, error instanceof Error ? error : undefined);
+        }
+    }
+    return path;
+}
+/** The "here is exactly what to put where" body of every "unusable" message. */
+export function describeVadModel(dir, reason) {
+    return (`The Silero speech detector needs its model file, and ${reason}.\n` +
+        `Place it here:\n  ${join(dir, SILERO_VAD_ASSET.name)}  ←  ${SILERO_VAD_ASSET.url}\n` +
+        "Or point NEUROLINK_VAD_DIR (or streaming.vad.modelDir) at a directory that has it " +
+        "(a full install of @juspay/neurolink ships a copy in its models/silero-vad directory), " +
+        'or set streaming.vad.engine (NEUROLINK_STT_VAD) to "energy" to stream without it.');
+}
+function modelUnavailable(dir, reason, originalError) {
+    return new STTError({
+        code: STT_ERROR_CODES.PROVIDER_NOT_CONFIGURED,
+        message: describeVadModel(dir, reason),
+        category: ErrorCategory.CONFIGURATION,
+        severity: ErrorSeverity.HIGH,
+        retriable: false,
+        context: {
+            provider: "silero-vad",
+            modelDir: dir,
+            files: [{ name: SILERO_VAD_ASSET.name, url: SILERO_VAD_ASSET.url }],
+        },
+        originalError,
+    });
+}

package/dist/voice/vad/frameScorer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Runs a speech detector over a stream's samples as they arrive and keeps
+ * its verdicts on the stream clock, so the endpointer (which works on 20 ms
+ * blocks at the input rate) can ask "was this moment speech?" without
+ * knowing the detector's frame size or sample rate. Audio at another rate is
+ * resampled to 16 kHz for scoring only; the engine path is untouched.
+ *
+ * @module voice/vad/frameScorer
+ */
+import type { STTSpeechDetector } from "../../types/index.js";
+export declare class SpeechFrameScorer {
+    readonly detector: STTSpeechDetector;
+    private readonly probs;
+    /** Frames scored so far: the detector's clock. */
+    private frames;
+    private readonly frame;
+    private frameFill;
+    private readonly resampler;
+    constructor(detector: STTSpeechDetector, inputRate: number);
+    /** Scores every full frame the samples complete; a partial frame waits for the next push. */
+    push(samples: Float32Array): Promise<void>;
+    /**
+     * The probability of the frame covering `seconds` on the stream clock; the
+     * newest frame when that one is not complete yet (a lag of at most one
+     * frame), `undefined` before anything was scored.
+     */
+    probabilityAt(seconds: number): number | undefined;
+}

package/dist/voice/vad/frameScorer.js

@@ -0,0 +1,90 @@
+/**
+ * Runs a speech detector over a stream's samples as they arrive and keeps
+ * its verdicts on the stream clock, so the endpointer (which works on 20 ms
+ * blocks at the input rate) can ask "was this moment speech?" without
+ * knowing the detector's frame size or sample rate. Audio at another rate is
+ * resampled to 16 kHz for scoring only; the engine path is untouched.
+ *
+ * @module voice/vad/frameScorer
+ */
+/** Verdicts kept: 8192 frames of 32 ms is about 4.4 minutes, far past what any block asks about. */
+const RING = 8192;
+const RATE = 16000;
+/** Linear-interpolation resampler that carries its position across pushes. */
+class StreamingResampler {
+    ratio;
+    carry = new Float32Array(0);
+    /** Position of the next output sample, in input samples, relative to `carry[0]`. */
+    phase = 0;
+    constructor(ratio) {
+        this.ratio = ratio;
+    }
+    push(input) {
+        const buf = new Float32Array(this.carry.length + input.length);
+        buf.set(this.carry, 0);
+        buf.set(input, this.carry.length);
+        const n = buf.length;
+        const out = new Float32Array(Math.ceil(n / this.ratio) + 1);
+        let count = 0;
+        let pos = this.phase;
+        while (Math.floor(pos) + 1 < n) {
+            const i0 = Math.floor(pos);
+            const f = pos - i0;
+            out[count++] = buf[i0] + (buf[i0 + 1] - buf[i0]) * f;
+            pos += this.ratio;
+        }
+        const keepFrom = Math.min(Math.floor(pos), n);
+        this.carry = buf.slice(keepFrom);
+        this.phase = pos - keepFrom;
+        return out.subarray(0, count);
+    }
+}
+export class SpeechFrameScorer {
+    detector;
+    probs = new Float32Array(RING);
+    /** Frames scored so far: the detector's clock. */
+    frames = 0;
+    frame;
+    frameFill = 0;
+    resampler;
+    constructor(detector, inputRate) {
+        this.detector = detector;
+        this.frame = new Float32Array(detector.frameSamples);
+        this.resampler =
+            inputRate === RATE ? null : new StreamingResampler(inputRate / RATE);
+        detector.reset();
+    }
+    /** Scores every full frame the samples complete; a partial frame waits for the next push. */
+    async push(samples) {
+        const pcm = this.resampler ? this.resampler.push(samples) : samples;
+        let i = 0;
+        while (i < pcm.length) {
+            const n = Math.min(pcm.length - i, this.frame.length - this.frameFill);
+            this.frame.set(pcm.subarray(i, i + n), this.frameFill);
+            this.frameFill += n;
+            i += n;
+            if (this.frameFill === this.frame.length) {
+                const p = await this.detector.score(this.frame);
+                this.probs[this.frames % RING] = p;
+                this.frames++;
+                this.frameFill = 0;
+            }
+        }
+    }
+    /**
+     * The probability of the frame covering `seconds` on the stream clock; the
+     * newest frame when that one is not complete yet (a lag of at most one
+     * frame), `undefined` before anything was scored.
+     */
+    probabilityAt(seconds) {
+        if (this.frames === 0) {
+            return undefined;
+        }
+        let k = Math.floor((seconds * RATE) / this.frame.length);
+        k = Math.min(Math.max(0, k), this.frames - 1);
+        if (k < this.frames - RING) {
+            return undefined;
+        }
+        return this.probs[k % RING];
+    }
+}

package/dist/voice/vad/sileroVad.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Silero VAD as the chunked stream's speech detector.
+ *
+ * A 2.3 MB ONNX model (MIT, trained on 6000+ languages) scores 32 ms frames
+ * of 16 kHz audio: the probability that the frame is a human voice, which an
+ * energy gate cannot tell from a chair, a keyboard or a far-away TV. It runs
+ * through `onnxruntime-node`, an optional dependency with prebuilt CPU
+ * binaries for Linux, macOS and Windows on x64 and arm64; measured at about
+ * 0.1 ms per frame on one thread, so a stream costs well under one percent
+ * of a core. One inference session per model file is shared by every stream
+ * in the process; each detector keeps only its own LSTM state and the 64
+ * samples of context the model wants in front of every frame.
+ *
+ * Nothing here is imported statically by the rest of the package: the
+ * adapter loads this module only when a stream needs it, and the runtime
+ * itself is imported through a variable specifier so a typecheck or a bundle
+ * does not need the native module present.
+ *
+ * @module voice/vad/sileroVad
+ */
+import type { STTSpeechDetector, STTVadEngine, STTVadOptions } from "../../types/index.js";
+/** Samples per frame at 16 kHz (32 ms). */
+export declare const SILERO_FRAME_SAMPLES = 512;
+/** Thresholds of `STTVadOptions` when the caller sets none. */
+export declare const VAD_DEFAULTS: {
+    readonly onset: 0.6;
+    readonly sustain: 0.35;
+    readonly startMs: 120;
+};
+/** `options.engine`, else `NEUROLINK_STT_VAD`, else `"auto"`. */
+export declare function resolveVadEngine(options?: STTVadOptions): STTVadEngine;
+/** The three thresholds with the defaults applied and nonsense clamped. */
+export declare function resolveVadThresholds(options?: STTVadOptions): {
+    onset: number;
+    sustain: number;
+    startMs: number;
+};
+/**
+ * A detector for one stream: the model file located (and fetched when
+ * allowed), the runtime loaded, the shared session created on first use.
+ * Throws an `STTError` saying exactly what is missing when it cannot.
+ */
+export declare function loadSileroDetector(options?: STTVadOptions): Promise<STTSpeechDetector>;

package/dist/voice/vad/sileroVad.js

@@ -0,0 +1,178 @@
+/**
+ * Silero VAD as the chunked stream's speech detector.
+ *
+ * A 2.3 MB ONNX model (MIT, trained on 6000+ languages) scores 32 ms frames
+ * of 16 kHz audio: the probability that the frame is a human voice, which an
+ * energy gate cannot tell from a chair, a keyboard or a far-away TV. It runs
+ * through `onnxruntime-node`, an optional dependency with prebuilt CPU
+ * binaries for Linux, macOS and Windows on x64 and arm64; measured at about
+ * 0.1 ms per frame on one thread, so a stream costs well under one percent
+ * of a core. One inference session per model file is shared by every stream
+ * in the process; each detector keeps only its own LSTM state and the 64
+ * samples of context the model wants in front of every frame.
+ *
+ * Nothing here is imported statically by the rest of the package: the
+ * adapter loads this module only when a stream needs it, and the runtime
+ * itself is imported through a variable specifier so a typecheck or a bundle
+ * does not need the native module present.
+ *
+ * @module voice/vad/sileroVad
+ */
+import { ErrorCategory, ErrorSeverity } from "../../constants/enums.js";
+import { STT_ERROR_CODES } from "../../types/index.js";
+import { STTError } from "../errors.js";
+import { ensureVadModel, resolveVadDir, vadAutoDownloadEnabled, } from "./assets.js";
+/** Samples per frame at 16 kHz (32 ms). */
+export const SILERO_FRAME_SAMPLES = 512;
+/** Samples of the previous frame the model wants in front of the new one. */
+const CONTEXT_SAMPLES = 64;
+const STATE_DIMS = [2, 1, 128];
+const STATE_SIZE = 2 * 128;
+/** Thresholds of `STTVadOptions` when the caller sets none. */
+export const VAD_DEFAULTS = {
+    onset: 0.6,
+    sustain: 0.35,
+    startMs: 120,
+};
+/** `options.engine`, else `NEUROLINK_STT_VAD`, else `"auto"`. */
+export function resolveVadEngine(options) {
+    const raw = (options?.engine ?? process.env.NEUROLINK_STT_VAD ?? "")
+        .trim()
+        .toLowerCase();
+    return raw === "silero" || raw === "energy" ? raw : "auto";
+}
+/** The three thresholds with the defaults applied and nonsense clamped. */
+export function resolveVadThresholds(options) {
+    const unit = (value, fallback) => typeof value === "number" && Number.isFinite(value)
+        ? Math.min(1, Math.max(0, value))
+        : fallback;
+    const onset = unit(options?.onset, VAD_DEFAULTS.onset);
+    const sustain = Math.min(unit(options?.sustain, VAD_DEFAULTS.sustain), onset);
+    const startMs = typeof options?.startMs === "number" &&
+        Number.isFinite(options.startMs) &&
+        options.startMs >= 0
+        ? options.startMs
+        : VAD_DEFAULTS.startMs;
+    return { onset, sustain, startMs };
+}
+let runtime;
+const sessions = new Map();
+function isRuntime(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const o = value;
+    const session = o.InferenceSession;
+    const create = typeof session === "function" ? Reflect.get(session, "create") : undefined;
+    return typeof create === "function" && typeof o.Tensor === "function";
+}
+async function loadRuntime() {
+    // A variable specifier: bundlers leave the native module alone, and a
+    // typecheck does not need the optional dependency installed.
+    const specifier = "onnxruntime-node";
+    let mod;
+    try {
+        mod = await import(specifier);
+    }
+    catch (error) {
+        throw new STTError({
+            code: STT_ERROR_CODES.PROVIDER_NOT_CONFIGURED,
+            message: "The Silero speech detector needs the optional dependency onnxruntime-node, which did not load " +
+                `(${error instanceof Error ? error.message : String(error)}). Install it (pnpm add onnxruntime-node), ` +
+                'or set streaming.vad.engine (NEUROLINK_STT_VAD) to "energy" to stream without it.',
+            category: ErrorCategory.CONFIGURATION,
+            severity: ErrorSeverity.HIGH,
+            retriable: false,
+            context: { provider: "silero-vad" },
+            originalError: error instanceof Error ? error : undefined,
+        });
+    }
+    const candidates = [mod, mod.default];
+    const found = candidates.find(isRuntime);
+    if (!found) {
+        throw new STTError({
+            code: STT_ERROR_CODES.PROVIDER_NOT_CONFIGURED,
+            message: "onnxruntime-node loaded but did not export InferenceSession and Tensor; the Silero speech detector cannot run.",
+            category: ErrorCategory.CONFIGURATION,
+            severity: ErrorSeverity.HIGH,
+            retriable: false,
+            context: { provider: "silero-vad" },
+        });
+    }
+    return found;
+}
+function sessionFor(rt, modelPath) {
+    let session = sessions.get(modelPath);
+    if (!session) {
+        session = rt.InferenceSession.create(modelPath, {
+            executionProviders: ["cpu"],
+            intraOpNumThreads: 1,
+            interOpNumThreads: 1,
+            logSeverityLevel: 3,
+        });
+        sessions.set(modelPath, session);
+        session.catch(() => sessions.delete(modelPath));
+    }
+    return session;
+}
+class SileroSpeechDetector {
+    rt;
+    session;
+    name = "silero";
+    frameSamples = SILERO_FRAME_SAMPLES;
+    state;
+    context = new Float32Array(CONTEXT_SAMPLES);
+    sr;
+    constructor(rt, session) {
+        this.rt = rt;
+        this.session = session;
+        this.sr = new rt.Tensor("int64", BigInt64Array.from([16000n]), []);
+        this.state = this.freshState();
+    }
+    reset() {
+        this.state = this.freshState();
+        this.context = new Float32Array(CONTEXT_SAMPLES);
+    }
+    async score(frame) {
+        if (frame.length !== SILERO_FRAME_SAMPLES) {
+            throw new Error(`Silero VAD scores ${SILERO_FRAME_SAMPLES}-sample frames, got ${frame.length}`);
+        }
+        const input = new Float32Array(CONTEXT_SAMPLES + SILERO_FRAME_SAMPLES);
+        input.set(this.context, 0);
+        input.set(frame, CONTEXT_SAMPLES);
+        const out = await this.session.run({
+            input: new this.rt.Tensor("float32", input, [1, input.length]),
+            state: this.state,
+            sr: this.sr,
+        });
+        const prob = out.output?.data[0];
+        const next = out.stateN;
+        if (typeof prob !== "number" || !next) {
+            throw new Error("Silero VAD returned no probability");
+        }
+        this.state = next;
+        this.context = frame.slice(SILERO_FRAME_SAMPLES - CONTEXT_SAMPLES);
+        return Math.min(1, Math.max(0, prob));
+    }
+    freshState() {
+        return new this.rt.Tensor("float32", new Float32Array(STATE_SIZE), STATE_DIMS);
+    }
+}
+/**
+ * A detector for one stream: the model file located (and fetched when
+ * allowed), the runtime loaded, the shared session created on first use.
+ * Throws an `STTError` saying exactly what is missing when it cannot.
+ */
+export async function loadSileroDetector(options) {
+    // The runtime first: without onnxruntime-node there is nothing to run the
+    // model on, so it must not be prepared (or downloaded) for nothing.
+    if (!runtime) {
+        runtime = loadRuntime().catch((error) => {
+            runtime = undefined;
+            throw error;
+        });
+    }
+    const rt = await runtime;
+    const modelPath = await ensureVadModel(resolveVadDir(options), vadAutoDownloadEnabled(options));
+    return new SileroSpeechDetector(rt, await sessionFor(rt, modelPath));
+}

package/dist/voice/whistle/assets.d.ts

@@ -23,10 +23,9 @@ export declare const WHISTLE_ASSETS: readonly WhistleAsset[];
  */
 export declare function resolveWhistleDir(slice?: STTCredentials["whistle"]): string;
 /**
- * The package's own `models/whistle`, found by walking up from this module
- * to the directory holding NeuroLink's `package.json`. Works from the source
- * tree, from `dist/` and from the single-file bundles, since all of them sit
- * below the package root; `null` when nothing above looks like the package.
+ * The package's own `models/whistle` (see `packageModelsDir`, which walks up
+ * from this module to the package root); `null` when nothing above looks
+ * like the package.
  */
 export declare function bundledWhistleDir(): string | null;
 /**

package/dist/voice/whistle/assets.js

@@ -12,16 +12,15 @@
  *
  * @module voice/whistle/assets
  */
-import { createHash, randomBytes } from "node:crypto";
-import { createReadStream, existsSync, readFileSync } from "node:fs";
-import { mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join, resolve } from "node:path";
 import { ErrorCategory, ErrorSeverity } from "../../constants/enums.js";
 import { STT_ERROR_CODES } from "../../types/index.js";
 import { logger } from "../../utils/logger.js";
 import { STTError } from "../errors.js";
+import { checkModelFile, downloadModelAsset, packageModelsDir, } from "../modelAssets.js";
 const NEEDLE_REVISION = "2ae11323dc000f5e70c49f7403efa6af12ba9e67";
 const WHISTLE_REVISION = "b358ddadd89b7a713b5aa131f23032d3cca1b251";
 /** Pinned files, in the order they are fetched. */
@@ -45,8 +44,6 @@ export const WHISTLE_ASSETS = [
         bytes: 16_919_407,
     },
 ];
-/** Per-file download deadline; generous because the model is 17 MB. */
-const DOWNLOAD_TIMEOUT_MS = 10 * 60_000;
 /** One in-flight preparation per directory, shared by concurrent callers. */
 const inFlight = new Map();
 /** Directories already verified in this process. */
@@ -72,46 +69,14 @@ export function resolveWhistleDir(slice) {
     }
     return join(homedir(), ".neurolink", "models", "whistle");
 }
-let bundledDir;
 /**
- * The package's own `models/whistle`, found by walking up from this module
- * to the directory holding NeuroLink's `package.json`. Works from the source
- * tree, from `dist/` and from the single-file bundles, since all of them sit
- * below the package root; `null` when nothing above looks like the package.
+ * The package's own `models/whistle` (see `packageModelsDir`, which walks up
+ * from this module to the package root); `null` when nothing above looks
+ * like the package.
  */
 export function bundledWhistleDir() {
-    if (bundledDir !== undefined) {
-        return bundledDir;
-    }
-    bundledDir = null;
-    let dir;
-    try {
-        dir = dirname(fileURLToPath(import.meta.url));
-    }
-    catch {
-        return bundledDir;
-    }
-    for (let depth = 0; depth < 8; depth += 1) {
-        const manifest = join(dir, "package.json");
-        if (existsSync(manifest)) {
-            try {
-                const parsed = JSON.parse(readFileSync(manifest, "utf8"));
-                if (parsed.name === "@juspay/neurolink") {
-                    bundledDir = join(dir, "models", "whistle");
-                    return bundledDir;
-                }
-            }
-            catch {
-                // Not a manifest we can read; keep walking up.
-            }
-        }
-        const parent = dirname(dir);
-        if (parent === dir) {
-            break;
-        }
-        dir = parent;
-    }
-    return bundledDir;
+    const root = packageModelsDir();
+    return root ? join(root, "whistle") : null;
 }
 /**
  * Whether missing files may be fetched: on unless `slice.autoDownload` is
@@ -157,7 +122,7 @@ async function prepare(dir, autoDownload) {
     const missing = [];
     const corrupt = [];
     for (const asset of WHISTLE_ASSETS) {
-        const state = await checkFile(join(dir, asset.name), asset);
+        const state = await checkModelFile(join(dir, asset.name), asset);
         if (state === "missing") {
             missing.push(asset);
         }
@@ -177,7 +142,7 @@ async function prepare(dir, autoDownload) {
         try {
             await mkdir(dir, { recursive: true });
             for (const asset of needed) {
-                await download(asset, dir);
+                await downloadModelAsset(asset, dir, "whistle");
             }
         }
         catch (error) {
@@ -193,55 +158,6 @@ async function prepare(dir, autoDownload) {
         "whistle.cact": join(dir, "whistle.cact"),
     };
 }
-async function checkFile(path, asset) {
-    try {
-        const info = await stat(path);
-        if (!info.isFile()) {
-            return "missing";
-        }
-        if (info.size !== asset.bytes) {
-            return "corrupt";
-        }
-    }
-    catch {
-        return "missing";
-    }
-    return (await hashFile(path)) === asset.sha256 ? "ok" : "corrupt";
-}
-function hashFile(path) {
-    return new Promise((resolvePromise, reject) => {
-        const hash = createHash("sha256");
-        createReadStream(path)
-            .on("data", (chunk) => hash.update(chunk))
-            .on("error", reject)
-            .on("end", () => resolvePromise(hash.digest("hex")));
-    });
-}
-async function download(asset, dir) {
-    const response = await fetch(asset.url, {
-        signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS),
-        redirect: "follow",
-    });
-    if (!response.ok) {
-        throw new Error(`${asset.name}: HTTP ${response.status}`);
-    }
-    const body = Buffer.from(await response.arrayBuffer());
-    const digest = createHash("sha256").update(body).digest("hex");
-    if (digest !== asset.sha256) {
-        throw new Error(`${asset.name}: SHA-256 mismatch (expected ${asset.sha256}, got ${digest})`);
-    }
-    const target = join(dir, asset.name);
-    const temp = join(dir, `.${asset.name}.${process.pid}.${randomBytes(4).toString("hex")}.part`);
-    try {
-        await writeFile(temp, body);
-        await rename(temp, target);
-    }
-    catch (error) {
-        await rm(temp, { force: true }).catch(() => undefined);
-        throw error;
-    }
-    logger.debug(`[whistle] ${asset.name} verified and saved to ${target}`);
-}
 /** The friendly "here is exactly what to put where" error. */
 /** The three files, where they go and where they come from — the body of every "unusable" message. */
 export function describeWhistleAssets(dir, reason) {