@lmk1010/speech-streaming-sherpa 0.0.0-stage → 0.2.2-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/index.js

@@ -0,0 +1,588 @@
+import { isAbsolute, join } from "node:path";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { mkdir, rename, rm, stat } from "node:fs/promises";
+import { Agent, request } from "node:http";
+import { fileURLToPath } from "node:url";
+import { MAX_TIMER_DELAY_MS, deadline } from "@deepseek-ai/dsh-timeout";
+import { Channel } from "@lmk1010/speech-streaming";
+import { z } from "zod";
+import { createReadStream, createWriteStream, readFileSync } from "node:fs";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import z$1 from "@deepseek-ai/schemastery";
+//#region lib/types/models.js
+/** Pinned model files: inspection, verified download with origin fallback, and atomic publication. */
+/** Locked model files shipped with the package. */
+function readLock() {
+	return JSON.parse(readFileSync(new URL("../runtime/assets.json", import.meta.url), "utf8"));
+}
+/**
+* Resolve model file locations without touching the disk.
+* @param config - data root or explicit model directory.
+* @param lock - pinned file names.
+* @returns absolute model paths.
+*/
+function modelPaths(config, lock = readLock()) {
+	const root = config.modelDirectory ?? join(config.dataRoot, "models", "paraformer-streaming-zh-en");
+	return {
+		encoder: join(root, lock.encoder.name),
+		decoder: join(root, lock.decoder.name),
+		tokens: join(root, lock.tokens.name)
+	};
+}
+async function matches(path, asset, signal) {
+	signal.throwIfAborted();
+	try {
+		const info = await stat(path);
+		if (!info.isFile() || info.size !== asset.bytes) return false;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+	const digest = createHash("sha256");
+	for await (const chunk of createReadStream(path, { signal })) digest.update(chunk);
+	return digest.digest("hex") === asset.sha256;
+}
+/**
+* Check whether every pinned file is present and intact; an explicit model directory is trusted as configured.
+* @param config - model location.
+* @param signal - inspection cancellation.
+* @returns paths when ready, otherwise `undefined`.
+*/
+async function inspectModels(config, signal) {
+	const lock = readLock(), paths = modelPaths(config, lock);
+	if (config.modelDirectory !== void 0) return paths;
+	for (const key of [
+		"encoder",
+		"decoder",
+		"tokens"
+	]) if (!await matches(paths[key], lock[key], signal)) return void 0;
+	return paths;
+}
+/**
+* Download one file into a unique partial file, verify size and SHA-256, then rename it into place.
+* @param asset - pinned identity; `url` is the concrete source.
+* @param destination - final path.
+* @param signal - preparation cancellation.
+* @param report - download progress.
+*/
+async function download(asset, destination, signal, report) {
+	const partial = `${destination}.${randomUUID()}.part`;
+	try {
+		const response = await fetch(asset.url, { signal });
+		if (!response.ok || !response.body) {
+			await response.body?.cancel();
+			throw new Error(`HTTP ${response.status} from ${new URL(asset.url).origin}`);
+		}
+		const digest = createHash("sha256");
+		let completed = 0;
+		const hashing = new Transform({ transform(chunk, _encoding, callback) {
+			completed += chunk.length;
+			if (completed > asset.bytes) {
+				callback(/* @__PURE__ */ new Error(`${asset.name} is larger than expected`));
+				return;
+			}
+			digest.update(chunk);
+			report(completed);
+			callback(null, chunk);
+		} });
+		await pipeline(response.body, hashing, createWriteStream(partial, {
+			flags: "wx",
+			mode: 384
+		}), { signal });
+		if (completed !== asset.bytes || digest.digest("hex") !== asset.sha256) throw new Error(`${asset.name} failed integrity verification`);
+		await rename(partial, destination);
+	} finally {
+		await rm(partial, { force: true });
+	}
+}
+/**
+* Ensure every pinned file is present, downloading missing or corrupted files from the configured origins in order.
+* @param config - data root and origins.
+* @param signal - preparation cancellation or deadline.
+* @param report - preparation progress.
+* @returns verified model paths.
+*/
+async function prepareModels(config, signal, report) {
+	const lock = readLock(), paths = modelPaths(config, lock);
+	if (config.modelDirectory !== void 0) return paths;
+	await mkdir(join(config.dataRoot, "models", "paraformer-streaming-zh-en"), { recursive: true });
+	for (const key of [
+		"encoder",
+		"decoder",
+		"tokens"
+	]) {
+		const asset = lock[key];
+		report({
+			phase: "checking",
+			step: "check",
+			startedAt: Date.now()
+		});
+		if (await matches(paths[key], asset, signal)) continue;
+		const path = new URL(asset.url).pathname;
+		const failures = [];
+		for (const origin of config.modelOrigins) try {
+			await download({
+				...asset,
+				url: new URL(path, origin).href
+			}, paths[key], signal, (completedBytes) => {
+				report({
+					phase: "downloading",
+					step: "model",
+					resource: asset.name,
+					completedBytes,
+					totalBytes: asset.bytes
+				});
+			});
+			break;
+		} catch (error) {
+			signal.throwIfAborted();
+			failures.push(`${origin}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (failures.length === config.modelOrigins.length) throw new Error(`Could not download ${asset.name}; ${failures.join("; ")}`);
+	}
+	report({
+		phase: "checking",
+		step: "verify",
+		startedAt: Date.now()
+	});
+	if (await inspectModels(config, signal) === void 0) throw new Error("Streaming model verification failed");
+	return paths;
+}
+//#endregion
+//#region lib/types/provider.js
+/** Host side of the local streaming recognizer: preparation, recognition process lifetime and duplex streams. */
+var __addDisposableResource = function(env, value, async) {
+	if (value !== null && value !== void 0) {
+		if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+		var dispose, inner;
+		if (async) {
+			if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+			dispose = value[Symbol.asyncDispose];
+		}
+		if (dispose === void 0) {
+			if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+			dispose = value[Symbol.dispose];
+			if (async) inner = dispose;
+		}
+		if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+		if (inner) dispose = function() {
+			try {
+				inner.call(this);
+			} catch (e) {
+				return Promise.reject(e);
+			}
+		};
+		env.stack.push({
+			value,
+			dispose,
+			async
+		});
+	} else if (async) env.stack.push({ async: true });
+	return value;
+};
+var __disposeResources = (function(SuppressedError) {
+	return function(env) {
+		function fail(e) {
+			env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+			env.hasError = true;
+		}
+		var r, s = 0;
+		function next() {
+			while (r = env.stack.pop()) try {
+				if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+				if (r.dispose) {
+					var result = r.dispose.call(r.value);
+					if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+						fail(e);
+						return next();
+					});
+				} else s |= 1;
+			} catch (e) {
+				fail(e);
+			}
+			if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+			if (env.hasError) throw env.error;
+		}
+		return next();
+	};
+})(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+	var e = new Error(message);
+	return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+const ready = z.object({ port: z.number().int().min(1).max(65535) }).strict();
+const event = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("partial"),
+		segment: z.number().int().min(0),
+		text: z.string()
+	}),
+	z.object({
+		type: z.literal("final"),
+		segment: z.number().int().min(0),
+		text: z.string()
+	}),
+	z.object({
+		type: z.literal("end"),
+		text: z.string(),
+		audioSeconds: z.number().min(0)
+	}),
+	z.object({
+		type: z.literal("error"),
+		message: z.string()
+	})
+]);
+async function readReady(handle, limit, signal) {
+	const stdout = handle.stdout;
+	if (!stdout) throw new Error("Streaming recognizer stdout is unavailable");
+	const pending = Promise.withResolvers();
+	let text = "";
+	const data = (chunk) => {
+		text += chunk.toString("utf8");
+		if (Buffer.byteLength(text) > limit) {
+			pending.reject(/* @__PURE__ */ new Error("Streaming recognizer readiness exceeded its byte limit"));
+			return;
+		}
+		const end = text.indexOf("\n");
+		if (end < 0) return;
+		try {
+			pending.resolve(ready.parse(JSON.parse(text.slice(0, end))).port);
+		} catch (error) {
+			pending.reject(new Error("Invalid streaming recognizer readiness", { cause: error }));
+		}
+	};
+	const abort = () => {
+		pending.reject(signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("Streaming recognizer start cancelled"));
+	};
+	stdout.on("data", data);
+	signal.addEventListener("abort", abort, { once: true });
+	handle.done.then(() => {
+		pending.reject(/* @__PURE__ */ new Error(`Streaming recognizer exited: ${handle.collected.stderr?.readFrom(0).text ?? ""}`));
+	}, pending.reject);
+	try {
+		return await pending.promise;
+	} finally {
+		stdout.off("data", data);
+		signal.removeEventListener("abort", abort);
+		stdout.resume();
+	}
+}
+/** Local streaming Paraformer provider; the recognition process starts on prepare, warm or first stream. */
+var SherpaStreaming = class {
+	ctx;
+	config;
+	info;
+	preparation = {
+		snapshot: () => this.state,
+		subscribe: (listener) => {
+			this.listeners.add(listener);
+			return () => {
+				this.listeners.delete(listener);
+			};
+		},
+		prepare: (_options) => {
+			this.run(async (signal) => {
+				await this.start(signal, true);
+			});
+		},
+		cancel: async () => {
+			this.task?.abort.abort(/* @__PURE__ */ new Error("Streaming model preparation cancelled"));
+			await this.task?.settled;
+		}
+	};
+	state = { phase: "unprepared" };
+	listeners = /* @__PURE__ */ new Set();
+	lifetime = new AbortController();
+	paths;
+	running;
+	starting;
+	task;
+	open_ = 0;
+	idle;
+	lastProgress = 0;
+	constructor(ctx, config) {
+		this.ctx = ctx;
+		this.config = config;
+		this.info = {
+			id: config.providerId,
+			name: "Paraformer streaming (zh/en, local)",
+			location: "host-local",
+			languages: [
+				"auto",
+				"zh",
+				"en"
+			],
+			downloadSources: config.modelDirectory === void 0 ? config.modelOrigins : [],
+			setupEstimate: {
+				recommendedDiskBytes: 3e8,
+				expectedMemoryBytes: 6e8,
+				minimumMinutes: 1,
+				maximumMinutes: 10
+			}
+		};
+	}
+	/** Read disk state without downloading or starting the recognition process. */
+	inspect() {
+		this.run(async (signal) => {
+			this.publish({
+				phase: "checking",
+				step: "check",
+				startedAt: Date.now()
+			});
+			this.paths = await inspectModels(this.config, signal);
+			this.publish({ phase: this.paths ? "standby" : "unprepared" });
+		});
+	}
+	warm() {
+		if (this.paths === void 0 || this.running !== void 0 || this.task !== void 0) return;
+		this.run(async (signal) => {
+			await this.start(signal, false);
+		});
+	}
+	async open(options, signal) {
+		if (this.paths === void 0) throw new Error("Download the local streaming model before recording");
+		const running = await this.start(AbortSignal.any([signal, this.lifetime.signal]), false);
+		clearTimeout(this.idle);
+		this.open_++;
+		const events = new Channel();
+		const request$1 = request({
+			host: "127.0.0.1",
+			port: running.port,
+			path: "/stream",
+			method: "POST",
+			agent: new Agent(),
+			headers: {
+				authorization: `Bearer ${running.token}`,
+				"content-type": "application/octet-stream",
+				"x-language": options.language
+			},
+			signal
+		});
+		const settle = () => {
+			if (--this.open_ === 0) this.scheduleIdle();
+		};
+		request$1.on("error", (error) => {
+			events.fail(error);
+		});
+		request$1.on("response", (response) => {
+			let buffered = "";
+			response.setEncoding("utf8");
+			response.on("data", (chunk) => {
+				buffered += chunk;
+				for (let end = buffered.indexOf("\n"); end >= 0; end = buffered.indexOf("\n")) {
+					const parsed = event.safeParse(JSON.parse(buffered.slice(0, end)));
+					buffered = buffered.slice(end + 1);
+					if (!parsed.success) {
+						events.fail(new Error("Invalid streaming recognizer event", { cause: parsed.error }));
+						continue;
+					}
+					if (parsed.data.type === "error") {
+						events.fail(new Error(parsed.data.message));
+						continue;
+					}
+					events.push(parsed.data);
+				}
+			});
+			response.on("end", () => {
+				events.close();
+			});
+			response.on("error", (error) => {
+				events.fail(error);
+			});
+		});
+		request$1.on("close", settle);
+		request$1.flushHeaders();
+		return {
+			write: (pcm) => {
+				request$1.write(Buffer.from(pcm.buffer, pcm.byteOffset, pcm.byteLength));
+			},
+			finish: () => {
+				request$1.end();
+			},
+			events
+		};
+	}
+	/** Stop the recognition process and pending preparation. */
+	async dispose() {
+		this.listeners.clear();
+		this.lifetime.abort(/* @__PURE__ */ new Error("Streaming provider disposed"));
+		clearTimeout(this.idle);
+		await this.task?.settled;
+		await this.stop();
+	}
+	run(work) {
+		if (this.task) return;
+		const abort = new AbortController();
+		const signal = AbortSignal.any([abort.signal, this.lifetime.signal]);
+		const task = {
+			abort,
+			settled: Promise.resolve()
+		};
+		this.task = task;
+		task.settled = work(signal).catch((error) => {
+			if (this.lifetime.signal.aborted) return;
+			this.publish(abort.signal.aborted ? { phase: "cancelled" } : {
+				phase: "failed",
+				message: error instanceof Error ? error.message : String(error)
+			});
+		}).finally(() => {
+			this.task = void 0;
+		});
+	}
+	async start(caller, download) {
+		if (this.running && !this.running.closed) return this.running;
+		this.starting ??= (async () => {
+			const env_1 = {
+				stack: [],
+				error: void 0,
+				hasError: false
+			};
+			try {
+				const setup = __addDisposableResource(env_1, deadline(caller, this.config.prepareTimeoutMs, "SPEECH_PREPARE_TIMEOUT"), false);
+				const cached = this.paths !== void 0;
+				this.paths ??= download ? await prepareModels(this.config, setup.signal, (state) => {
+					this.publish(state);
+				}) : void 0;
+				if (this.paths === void 0) throw new Error("Download the local streaming model before recording");
+				this.publish({
+					phase: cached ? "waking" : "loading",
+					step: "load",
+					startedAt: Date.now()
+				});
+				await mkdir(this.config.dataRoot, { recursive: true });
+				const token = randomBytes(32).toString("hex");
+				const worker = fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "./worker.ts" : "./worker.js", import.meta.url));
+				const handle = this.ctx.subprocess.spawn({
+					argv: [
+						process.execPath,
+						...worker.endsWith(".ts") ? ["--import", import.meta.resolve("tsx/esm")] : [],
+						worker,
+						JSON.stringify({
+							...this.config,
+							...this.paths
+						})
+					],
+					cwd: this.config.dataRoot,
+					graceMs: this.config.graceMs,
+					env: {
+						DSH_SPEECH_TOKEN: token,
+						ELECTRON_RUN_AS_NODE: "1"
+					},
+					stdio: {
+						stdin: "ignore",
+						stdout: "pipe",
+						stderr: { maxBytes: this.config.maxLogBytes }
+					}
+				});
+				try {
+					const running = {
+						handle,
+						port: await readReady(handle, this.config.maxLogBytes, setup.signal),
+						token,
+						closed: false
+					};
+					const exited = () => {
+						if (!running.closed) {
+							running.closed = true;
+							this.running = void 0;
+							this.publish({ phase: "standby" });
+						}
+					};
+					handle.done.then(exited, exited);
+					this.running = running;
+					this.publish({ phase: "ready" });
+					this.scheduleIdle();
+					return running;
+				} catch (error) {
+					handle.terminate();
+					await handle.waitForExit();
+					this.publish(this.paths ? { phase: "standby" } : { phase: "unprepared" });
+					throw error;
+				}
+			} catch (e_1) {
+				env_1.error = e_1;
+				env_1.hasError = true;
+			} finally {
+				__disposeResources(env_1);
+			}
+		})().finally(() => {
+			this.starting = void 0;
+		});
+		return await this.starting;
+	}
+	scheduleIdle() {
+		clearTimeout(this.idle);
+		if (this.config.idleTimeoutMs === 0 || this.open_ > 0) return;
+		this.idle = setTimeout(() => {
+			this.stop().catch((error) => {
+				this.ctx.logger.warn("Streaming recognizer idle stop failed", error);
+			});
+		}, this.config.idleTimeoutMs);
+	}
+	async stop() {
+		const running = this.running;
+		if (!running) return;
+		running.closed = true;
+		this.running = void 0;
+		running.handle.terminate();
+		await running.handle.waitForExit();
+		if (!this.lifetime.signal.aborted) this.publish({ phase: "standby" });
+	}
+	publish(state) {
+		const now = performance.now();
+		if (state.phase === "downloading" && this.state.phase === "downloading" && state.completedBytes !== state.totalBytes && now - this.lastProgress < this.config.progressIntervalMs) {
+			this.state = state;
+			return;
+		}
+		this.lastProgress = now;
+		this.state = state;
+		for (const listener of this.listeners) listener();
+	}
+};
+//#endregion
+//#region lib/types/config.js
+/** Validated settings shared by the Host provider and its recognition process. */
+const origin = z$1.string().pattern(/^https?:\/\/[^/\s?#@]+\/?$/);
+const Config = z$1.object({
+	providerId: z$1.string().min(1).default("paraformer-streaming-local"),
+	dataRoot: z$1.string().min(1).required(),
+	modelDirectory: z$1.string().min(1),
+	modelOrigins: z$1.array(origin).min(1).default(["https://huggingface.co", "https://hf-mirror.com"]),
+	threads: z$1.natural().min(1).default(2),
+	segmentOnEndpoint: z$1.boolean().default(false),
+	endpointSilenceSeconds: z$1.number().min(.1).default(2.4),
+	endpointSilenceAfterTextSeconds: z$1.number().min(.1).default(.8),
+	endpointMaxSegmentSeconds: z$1.number().min(1).default(20),
+	tailPaddingSeconds: z$1.number().min(0).max(2).default(.5),
+	maxStreamSeconds: z$1.natural().min(1).default(300),
+	prepareTimeoutMs: z$1.natural().min(1).max(MAX_TIMER_DELAY_MS).default(36e5),
+	idleTimeoutMs: z$1.natural().max(MAX_TIMER_DELAY_MS).default(6e5),
+	graceMs: z$1.natural().min(1).max(MAX_TIMER_DELAY_MS).default(1e3),
+	maxLogBytes: z$1.natural().min(1).default(64 * 1024),
+	progressIntervalMs: z$1.natural().min(1).max(MAX_TIMER_DELAY_MS).default(100)
+});
+//#endregion
+//#region lib/types/index.js
+/** Optional local streaming recognizer; activation inspects the model cache without downloading or loading. */
+const name = "speech-streaming-sherpa";
+const inject = ["speechStreaming", "subprocess"];
+/**
+* Register the local streaming provider.
+* @param ctx - streaming registry and subprocess owner.
+* @param config - validated runtime configuration.
+*/
+function apply(ctx, config) {
+	for (const path of [config.dataRoot, config.modelDirectory]) if (path !== void 0 && !isAbsolute(path)) throw new Error(`Streaming model paths must be absolute: ${path}`);
+	const provider = new SherpaStreaming(ctx, config);
+	ctx.effect(() => {
+		const unregister = ctx.speechStreaming.register(provider);
+		provider.inspect();
+		return async () => {
+			const removing = unregister();
+			await provider.dispose();
+			await removing;
+		};
+	});
+}
+//#endregion
+export { Config, apply, inject, name };

package/lib/types/config.d.ts

@@ -0,0 +1,45 @@
+/** Validated settings shared by the Host provider and its recognition process. */
+import z from '@deepseek-ai/schemastery';
+/** Local streaming Paraformer settings. */
+export interface Config {
+    /** Registered provider id. */
+    providerId: string;
+    /** Provider-owned directory for downloaded models. */
+    dataRoot: string;
+    /** Directory already holding `encoder.int8.onnx`, `decoder.int8.onnx` and `tokens.txt`; skips download and hash checks. */
+    modelDirectory?: string;
+    /** Hugging Face-compatible origins tried in order for each pinned file. */
+    modelOrigins: string[];
+    /** ONNX Runtime CPU threads in the recognition process. */
+    threads: number;
+    /** Close a segment and reset decoding at detected pauses; resetting mid-sentence loses context, so press-to-talk keeps it off. */
+    segmentOnEndpoint: boolean;
+    /** Trailing silence that ends a segment when nothing was recognized yet. */
+    endpointSilenceSeconds: number;
+    /** Trailing silence that ends a segment after text was recognized. */
+    endpointSilenceAfterTextSeconds: number;
+    /** Segment length that forces an endpoint. */
+    endpointMaxSegmentSeconds: number;
+    /** Silence appended at finish so the last chunk is decoded. */
+    tailPaddingSeconds: number;
+    /** Longest accepted stream. */
+    maxStreamSeconds: number;
+    /** Download and process start deadline. */
+    prepareTimeoutMs: number;
+    /** Stop the idle recognition process after this delay; `0` keeps it running. */
+    idleTimeoutMs: number;
+    /** Grace period before the recognition process is killed. */
+    graceMs: number;
+    /** Retained recognition process stderr bytes. */
+    maxLogBytes: number;
+    /** Minimum interval between download progress notifications. */
+    progressIntervalMs: number;
+}
+export declare const Config: z<Partial<Config>, Config>;
+/** Verified model files passed to the recognition process. */
+export interface ModelPaths {
+    readonly encoder: string;
+    readonly decoder: string;
+    readonly tokens: string;
+}
+//# sourceMappingURL=config.d.ts.map

package/lib/types/config.js

@@ -0,0 +1,23 @@
+/** Validated settings shared by the Host provider and its recognition process. */
+import z from '@deepseek-ai/schemastery';
+import { MAX_TIMER_DELAY_MS } from '@deepseek-ai/dsh-timeout';
+const origin = z.string().pattern(/^https?:\/\/[^/\s?#@]+\/?$/);
+export const Config = z.object({
+    providerId: z.string().min(1).default('paraformer-streaming-local'),
+    dataRoot: z.string().min(1).required(),
+    modelDirectory: z.string().min(1),
+    modelOrigins: z.array(origin).min(1).default(['https://huggingface.co', 'https://hf-mirror.com']),
+    threads: z.natural().min(1).default(2),
+    segmentOnEndpoint: z.boolean().default(false),
+    endpointSilenceSeconds: z.number().min(0.1).default(2.4),
+    endpointSilenceAfterTextSeconds: z.number().min(0.1).default(0.8),
+    endpointMaxSegmentSeconds: z.number().min(1).default(20),
+    tailPaddingSeconds: z.number().min(0).max(2).default(0.5),
+    maxStreamSeconds: z.natural().min(1).default(300),
+    prepareTimeoutMs: z.natural().min(1).max(MAX_TIMER_DELAY_MS).default(3_600_000),
+    idleTimeoutMs: z.natural().max(MAX_TIMER_DELAY_MS).default(600_000),
+    graceMs: z.natural().min(1).max(MAX_TIMER_DELAY_MS).default(1000),
+    maxLogBytes: z.natural().min(1).default(64 * 1024),
+    progressIntervalMs: z.natural().min(1).max(MAX_TIMER_DELAY_MS).default(100),
+});
+//# sourceMappingURL=config.js.map