@seawork/server 1.0.0

package/dist/server/server/speech/provider-resolver.d.ts

@@ -0,0 +1,3 @@
+export type Resolvable<T> = T | (() => T);
+export declare function toResolver<T>(value: Resolvable<T>): () => T;
+//# sourceMappingURL=provider-resolver.d.ts.map

package/dist/server/server/speech/provider-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-resolver.d.ts","sourceRoot":"","sources":["../../../../src/server/speech/provider-resolver.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;AAE1C,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAK3D"}

package/dist/server/server/speech/provider-resolver.js

@@ -0,0 +1,7 @@
+export function toResolver(value) {
+    if (typeof value === "function") {
+        return value;
+    }
+    return () => value;
+}
+//# sourceMappingURL=provider-resolver.js.map

package/dist/server/server/speech/provider-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-resolver.js","sourceRoot":"","sources":["../../../../src/server/speech/provider-resolver.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,UAAU,CAAI,KAAoB;IAChD,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;QAChC,OAAO,KAAgB,CAAC;IAC1B,CAAC;IACD,OAAO,GAAG,EAAE,CAAC,KAAK,CAAC;AACrB,CAAC"}

package/dist/server/server/speech/providers/local/config.d.ts

@@ -0,0 +1,25 @@
+import type { PersistedConfig } from "../../../persisted-config.js";
+import type { RequestedSpeechProviders } from "../../speech-types.js";
+import { type LocalSpeechModelId, type LocalSttModelId, type LocalTtsModelId } from "./models.js";
+export type LocalSpeechModelConfig = {
+    dictationStt: LocalSttModelId;
+    voiceStt: LocalSttModelId;
+    voiceTts: LocalTtsModelId;
+    voiceTtsSpeakerId?: number;
+    voiceTtsSpeed?: number;
+};
+export type LocalSpeechProviderConfig = {
+    modelsDir: string;
+    models: LocalSpeechModelConfig;
+};
+export type ResolvedLocalSpeechConfig = {
+    local: LocalSpeechProviderConfig | undefined;
+};
+export type { LocalSpeechModelId, LocalSttModelId, LocalTtsModelId };
+export declare function resolveLocalSpeechConfig(params: {
+    seaworkHome: string;
+    env: NodeJS.ProcessEnv;
+    persisted: PersistedConfig;
+    providers: RequestedSpeechProviders;
+}): ResolvedLocalSpeechConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/server/server/speech/providers/local/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../../../src/server/speech/providers/local/config.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAKL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,eAAe,EACrB,MAAM,aAAa,CAAC;AAErB,MAAM,MAAM,sBAAsB,GAAG;IACnC,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,sBAAsB,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,KAAK,EAAE,yBAAyB,GAAG,SAAS,CAAC;CAC9C,CAAC;AAEF,YAAY,EAAE,kBAAkB,EAAE,eAAe,EAAE,eAAe,EAAE,CAAC;AAkDrE,wBAAgB,wBAAwB,CAAC,MAAM,EAAE;IAC/C,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,SAAS,EAAE,eAAe,CAAC;IAC3B,SAAS,EAAE,wBAAwB,CAAC;CACrC,GAAG,yBAAyB,CA8D5B"}

package/dist/server/server/speech/providers/local/config.js

@@ -0,0 +1,74 @@
+import path from "node:path";
+import { z } from "zod";
+import { DEFAULT_LOCAL_STT_MODEL, DEFAULT_LOCAL_TTS_MODEL, LocalSttModelIdSchema, LocalTtsModelIdSchema, } from "./models.js";
+const DEFAULT_LOCAL_MODELS_SUBDIR = path.join("models", "local-speech");
+const NumberLikeSchema = z.union([z.number(), z.string().trim().min(1)]);
+const OptionalFiniteNumberSchema = NumberLikeSchema.pipe(z.coerce.number().finite()).optional();
+const OptionalIntegerSchema = NumberLikeSchema.pipe(z.coerce.number().int()).optional();
+const LocalSpeechResolutionSchema = z.object({
+    includeProviderConfig: z.boolean(),
+    modelsDir: z.string().trim().min(1),
+    dictationLocalSttModel: LocalSttModelIdSchema.default(DEFAULT_LOCAL_STT_MODEL),
+    voiceLocalSttModel: LocalSttModelIdSchema.default(DEFAULT_LOCAL_STT_MODEL),
+    voiceLocalTtsModel: LocalTtsModelIdSchema.default(DEFAULT_LOCAL_TTS_MODEL),
+    voiceLocalTtsSpeakerId: OptionalIntegerSchema,
+    voiceLocalTtsSpeed: OptionalFiniteNumberSchema,
+});
+function persistedLocalFeatureModel(provider, enabled, model) {
+    if (provider !== "local" || enabled === false) {
+        return undefined;
+    }
+    return model;
+}
+function shouldIncludeLocalProviderConfig(params) {
+    const localRequestedByFeature = (params.providers.dictationStt.enabled !== false &&
+        params.providers.dictationStt.provider === "local") ||
+        (params.providers.voiceStt.enabled !== false &&
+            params.providers.voiceStt.provider === "local") ||
+        (params.providers.voiceTts.enabled !== false && params.providers.voiceTts.provider === "local");
+    return (localRequestedByFeature ||
+        params.env.SEAWORK_LOCAL_MODELS_DIR !== undefined ||
+        params.persisted.providers?.local?.modelsDir !== undefined);
+}
+export function resolveLocalSpeechConfig(params) {
+    const includeProviderConfig = shouldIncludeLocalProviderConfig(params);
+    const parsed = LocalSpeechResolutionSchema.parse({
+        includeProviderConfig,
+        modelsDir: params.env.SEAWORK_LOCAL_MODELS_DIR ??
+            params.persisted.providers?.local?.modelsDir ??
+            path.join(params.seaworkHome, DEFAULT_LOCAL_MODELS_SUBDIR),
+        dictationLocalSttModel: params.env.SEAWORK_DICTATION_LOCAL_STT_MODEL ??
+            persistedLocalFeatureModel(params.providers.dictationStt.provider, params.providers.dictationStt.enabled, params.persisted.features?.dictation?.stt?.model) ??
+            DEFAULT_LOCAL_STT_MODEL,
+        voiceLocalSttModel: params.env.SEAWORK_VOICE_LOCAL_STT_MODEL ??
+            persistedLocalFeatureModel(params.providers.voiceStt.provider, params.providers.voiceStt.enabled, params.persisted.features?.voiceMode?.stt?.model) ??
+            DEFAULT_LOCAL_STT_MODEL,
+        voiceLocalTtsModel: params.env.SEAWORK_VOICE_LOCAL_TTS_MODEL ??
+            persistedLocalFeatureModel(params.providers.voiceTts.provider, params.providers.voiceTts.enabled, params.persisted.features?.voiceMode?.tts?.model) ??
+            DEFAULT_LOCAL_TTS_MODEL,
+        voiceLocalTtsSpeakerId: params.env.SEAWORK_VOICE_LOCAL_TTS_SPEAKER_ID ??
+            params.persisted.features?.voiceMode?.tts?.speakerId,
+        voiceLocalTtsSpeed: params.env.SEAWORK_VOICE_LOCAL_TTS_SPEED ?? params.persisted.features?.voiceMode?.tts?.speed,
+    });
+    const resolvedVoiceTtsSpeakerId = parsed.voiceLocalTtsSpeakerId ??
+        (parsed.voiceLocalTtsModel === "kokoro-en-v0_19" ? 0 : undefined);
+    return {
+        local: parsed.includeProviderConfig
+            ? {
+                modelsDir: parsed.modelsDir,
+                models: {
+                    dictationStt: parsed.dictationLocalSttModel,
+                    voiceStt: parsed.voiceLocalSttModel,
+                    voiceTts: parsed.voiceLocalTtsModel,
+                    ...(resolvedVoiceTtsSpeakerId !== undefined
+                        ? { voiceTtsSpeakerId: resolvedVoiceTtsSpeakerId }
+                        : {}),
+                    ...(parsed.voiceLocalTtsSpeed !== undefined
+                        ? { voiceTtsSpeed: parsed.voiceLocalTtsSpeed }
+                        : {}),
+                },
+            }
+            : undefined,
+    };
+}
+//# sourceMappingURL=config.js.map

package/dist/server/server/speech/providers/local/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../../../../src/server/speech/providers/local/config.ts"],"names":[],"mappings":"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"}

package/dist/server/server/speech/providers/local/models.d.ts

@@ -0,0 +1,11 @@
+import { DEFAULT_LOCAL_STT_MODEL, DEFAULT_LOCAL_TTS_MODEL, LocalSttModelIdSchema, LocalTtsModelIdSchema, listSherpaOnnxModels, type LocalSpeechModelId, type LocalSttModelId, type LocalTtsModelId } from "./sherpa/model-catalog.js";
+export { DEFAULT_LOCAL_STT_MODEL, DEFAULT_LOCAL_TTS_MODEL, LocalSttModelIdSchema, LocalTtsModelIdSchema, type LocalSpeechModelId, type LocalSttModelId, type LocalTtsModelId, };
+export type LocalSpeechModelSpec = ReturnType<typeof listSherpaOnnxModels>[number];
+export declare function listLocalSpeechModels(): LocalSpeechModelSpec[];
+export declare function getLocalSpeechModelDir(modelsDir: string, modelId: LocalSpeechModelId): string;
+export declare function ensureLocalSpeechModels(options: {
+    modelsDir: string;
+    modelIds: LocalSpeechModelId[];
+    logger: import("pino").Logger;
+}): Promise<Record<LocalSpeechModelId, string>>;
+//# sourceMappingURL=models.d.ts.map

package/dist/server/server/speech/providers/local/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../../../../src/server/speech/providers/local/models.ts"],"names":[],"mappings":"AACA,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACpB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,eAAe,EACrB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,eAAe,GACrB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnF,wBAAgB,qBAAqB,IAAI,oBAAoB,EAAE,CAE9D;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAE7F;AAED,wBAAsB,uBAAuB,CAAC,OAAO,EAAE;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,kBAAkB,EAAE,CAAC;IAC/B,MAAM,EAAE,OAAO,MAAM,EAAE,MAAM,CAAC;CAC/B,GAAG,OAAO,CAAC,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC,CAM9C"}

package/dist/server/server/speech/providers/local/models.js

@@ -0,0 +1,17 @@
+import { ensureSherpaOnnxModels, getSherpaOnnxModelDir } from "./sherpa/model-downloader.js";
+import { DEFAULT_LOCAL_STT_MODEL, DEFAULT_LOCAL_TTS_MODEL, LocalSttModelIdSchema, LocalTtsModelIdSchema, listSherpaOnnxModels, } from "./sherpa/model-catalog.js";
+export { DEFAULT_LOCAL_STT_MODEL, DEFAULT_LOCAL_TTS_MODEL, LocalSttModelIdSchema, LocalTtsModelIdSchema, };
+export function listLocalSpeechModels() {
+    return listSherpaOnnxModels();
+}
+export function getLocalSpeechModelDir(modelsDir, modelId) {
+    return getSherpaOnnxModelDir(modelsDir, modelId);
+}
+export async function ensureLocalSpeechModels(options) {
+    return ensureSherpaOnnxModels({
+        modelsDir: options.modelsDir,
+        modelIds: options.modelIds,
+        logger: options.logger,
+    });
+}
+//# sourceMappingURL=models.js.map

package/dist/server/server/speech/providers/local/models.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.js","sourceRoot":"","sources":["../../../../../../src/server/speech/providers/local/models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAC7F,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,GAIrB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,qBAAqB,EACrB,qBAAqB,GAItB,CAAC;AAIF,MAAM,UAAU,qBAAqB;IACnC,OAAO,oBAAoB,EAAE,CAAC;AAChC,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,SAAiB,EAAE,OAA2B;IACnF,OAAO,qBAAqB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;AACnD,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAAC,OAI7C;IACC,OAAO,sBAAsB,CAAC;QAC5B,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,MAAM,EAAE,OAAO,CAAC,MAAM;KACvB,CAAC,CAAC;AACL,CAAC"}

package/dist/server/server/speech/providers/local/pocket/pocket-tts-onnx.d.ts

@@ -0,0 +1,24 @@
+import type pino from "pino";
+import type { SpeechStreamResult, TextToSpeechProvider } from "../../../speech-provider.js";
+export type PocketTtsOnnxConfig = {
+    modelDir: string;
+    precision?: "int8" | "fp32";
+    device?: "auto" | "cpu" | "cuda";
+    temperature?: number;
+    lsdSteps?: number;
+    maxFrames?: number;
+    framesAfterEos?: number;
+    firstChunkFrames?: number;
+    maxChunkFrames?: number;
+    targetChunkMs?: number;
+    referenceAudioFile?: string;
+};
+export declare class PocketTtsOnnxTTS implements TextToSpeechProvider {
+    private readonly engine;
+    private readonly chunkMs;
+    private readonly logger;
+    private constructor();
+    static create(config: PocketTtsOnnxConfig, logger: pino.Logger): Promise<PocketTtsOnnxTTS>;
+    synthesizeSpeech(text: string): Promise<SpeechStreamResult>;
+}
+//# sourceMappingURL=pocket-tts-onnx.d.ts.map

package/dist/server/server/speech/providers/local/pocket/pocket-tts-onnx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pocket-tts-onnx.d.ts","sourceRoot":"","sources":["../../../../../../../src/server/speech/providers/local/pocket/pocket-tts-onnx.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AA+L5F,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;IACjC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AA6UF,qBAAa,gBAAiB,YAAW,oBAAoB;IAC3D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IAErC,OAAO;WAMM,MAAM,CAAC,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAM1F,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAyBlE"}

package/dist/server/server/speech/providers/local/pocket/pocket-tts-onnx.js

@@ -0,0 +1,436 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { Readable } from "node:stream";
+import { chunkBuffer, float32ToPcm16le, parsePcm16MonoWav, pcm16leToFloat32, } from "../../../audio.js";
+import { Pcm16MonoResampler } from "../../../../agent/pcm16-resampler.js";
+function assertFileExists(filePath, label) {
+    if (!existsSync(filePath)) {
+        throw new Error(`Missing ${label}: ${filePath}`);
+    }
+}
+function product(dims) {
+    let out = 1;
+    for (const d of dims)
+        out *= d;
+    return out;
+}
+function normalizeDims(dims) {
+    // ONNX metadata can contain dynamic dimensions as strings (e.g. "batch") or -1.
+    // For state tensors we want a valid minimal shape, so coerce unknown/invalid dims to 1.
+    // Preserve explicit 0 dims (some models use empty initial state buffers with shape [0]).
+    return dims.map((d) => {
+        if (typeof d === "number" && Number.isFinite(d)) {
+            if (d === 0)
+                return 0;
+            if (d > 0)
+                return d;
+            return 1;
+        }
+        return 1;
+    });
+}
+function getSessionInputMeta(session, inputName) {
+    const metaAny = session.inputMetadata;
+    if (Array.isArray(metaAny)) {
+        const entry = metaAny.find((m) => m && typeof m === "object" && m.name === inputName);
+        if (!entry)
+            return undefined;
+        return { type: entry.type, dims: entry.shape };
+    }
+    if (metaAny && typeof metaAny === "object" && inputName in metaAny) {
+        const entry = metaAny[inputName];
+        return { type: entry?.type, dims: entry?.dimensions ?? entry?.shape };
+    }
+    return undefined;
+}
+function toBigInt64(values) {
+    const out = new BigInt64Array(values.length);
+    for (let i = 0; i < values.length; i += 1) {
+        out[i] = BigInt(values[i]);
+    }
+    return out;
+}
+function randn() {
+    // Box–Muller
+    let u = 0;
+    let v = 0;
+    while (u === 0)
+        u = Math.random();
+    while (v === 0)
+        v = Math.random();
+    return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+}
+function normalizeTextForPocket(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        throw new Error("Cannot synthesize empty text");
+    }
+    let out = trimmed;
+    if (out.length > 0 && /[A-Za-z0-9]$/.test(out)) {
+        out = `${out}.`;
+    }
+    if (out.length > 0 && /[a-z]/.test(out[0])) {
+        out = out[0].toUpperCase() + out.slice(1);
+    }
+    return out;
+}
+async function loadOrt() {
+    return (await import("onnxruntime-node"));
+}
+async function loadSentencePiece(tokenizerModelPath) {
+    const mod = await import("@sctg/sentencepiece-js");
+    const Processor = mod.SentencePieceProcessor ??
+        mod.default?.SentencePieceProcessor ??
+        mod.default;
+    if (!Processor) {
+        throw new Error("Failed to load SentencePiece processor from @sctg/sentencepiece-js");
+    }
+    const sp = new Processor();
+    if (typeof sp.load === "function") {
+        await sp.load(tokenizerModelPath);
+    }
+    else if (typeof sp.Load === "function") {
+        sp.Load(tokenizerModelPath);
+    }
+    else {
+        throw new Error("SentencePiece processor does not expose load()/Load()");
+    }
+    return sp;
+}
+function getOrtProviders(ort, device) {
+    // NOTE: onnxruntime-node uses backend names like "cpu"/"coreml"/"webgpu" (not "CPUExecutionProvider").
+    if (device === "cpu")
+        return ["cpu"];
+    if (device === "cuda")
+        return ["cuda", "cpu"];
+    // auto
+    // CoreML EP does not support some dynamic/zero-length shapes used by Pocket TTS (e.g. [1, 0, 32]).
+    // Default to CPU to keep behavior predictable across platforms.
+    void ort;
+    return ["cpu"];
+}
+function createZeroTensorForInput(ort, session, inputName) {
+    const meta = getSessionInputMeta(session, inputName);
+    const dims = normalizeDims(meta?.dims ?? []);
+    if (dims.length === 0) {
+        throw new Error(`Missing input metadata shape for ${inputName}`);
+    }
+    const type = (meta?.type ?? "float32").toLowerCase();
+    const size = product(dims);
+    if (type.includes("int64")) {
+        return new ort.Tensor("int64", new BigInt64Array(size), dims);
+    }
+    if (type.includes("bool")) {
+        return new ort.Tensor("bool", new Uint8Array(size), dims);
+    }
+    return new ort.Tensor("float32", new Float32Array(size), dims);
+}
+function initState(session, ort) {
+    const out = {};
+    for (const name of session.inputNames) {
+        if (name.startsWith("state_")) {
+            out[name] = createZeroTensorForInput(ort, session, name);
+        }
+    }
+    return out;
+}
+function updateStateFromOutputs(state, outputs) {
+    for (const [name, tensor] of Object.entries(outputs)) {
+        if (!name.startsWith("out_state_"))
+            continue;
+        const idx = Number.parseInt(name.replace("out_state_", ""), 10);
+        if (Number.isFinite(idx)) {
+            state[`state_${idx}`] = tensor;
+        }
+    }
+}
+function tensorDataFloat32(t) {
+    const data = t.data;
+    if (data instanceof Float32Array)
+        return data;
+    if (Array.isArray(data))
+        return Float32Array.from(data);
+    throw new Error("Unexpected tensor data type (expected Float32Array)");
+}
+class PocketTtsOnnxEngine {
+    constructor(args) {
+        this.ort = args.ort;
+        this.temperature = args.temperature;
+        this.lsdSteps = args.lsdSteps;
+        this.maxFrames = args.maxFrames;
+        this.framesAfterEos = args.framesAfterEos;
+        this.firstChunkFrames = args.firstChunkFrames;
+        this.maxChunkFrames = args.maxChunkFrames;
+        this.tokenizer = args.tokenizer;
+        this.textConditioner = args.textConditioner;
+        this.flowLmMain = args.flowLmMain;
+        this.flowLmFlow = args.flowLmFlow;
+        this.mimiDecoder = args.mimiDecoder;
+        this.stBuffers = args.stBuffers;
+        this.voiceEmbeddings = args.voiceEmbeddings;
+    }
+    static async create(config, logger) {
+        const log = logger.child({
+            module: "speech",
+            provider: "pocket-tts",
+            component: "onnx-engine",
+        });
+        const modelDir = config.modelDir;
+        const onnxDir = `${modelDir}/onnx`;
+        const precision = config.precision ?? "int8";
+        const device = config.device ?? "auto";
+        const temperature = config.temperature ?? 0.7;
+        const lsdSteps = config.lsdSteps ?? 10;
+        const maxFrames = config.maxFrames ?? 500;
+        const framesAfterEos = config.framesAfterEos ?? 3;
+        const firstChunkFrames = config.firstChunkFrames ?? 2;
+        const maxChunkFrames = config.maxChunkFrames ?? 15;
+        const tokenizerPath = `${modelDir}/tokenizer.model`;
+        const referenceAudioFile = config.referenceAudioFile ?? `${modelDir}/reference_sample.wav`;
+        const flowMainFile = precision === "int8" ? "flow_lm_main_int8.onnx" : "flow_lm_main.onnx";
+        const flowFlowFile = precision === "int8" ? "flow_lm_flow_int8.onnx" : "flow_lm_flow.onnx";
+        const decoderFile = precision === "int8" ? "mimi_decoder_int8.onnx" : "mimi_decoder.onnx";
+        assertFileExists(`${onnxDir}/mimi_encoder.onnx`, "PocketTTS mimi_encoder");
+        assertFileExists(`${onnxDir}/text_conditioner.onnx`, "PocketTTS text_conditioner");
+        assertFileExists(`${onnxDir}/${flowMainFile}`, "PocketTTS flow_lm_main");
+        assertFileExists(`${onnxDir}/${flowFlowFile}`, "PocketTTS flow_lm_flow");
+        assertFileExists(`${onnxDir}/${decoderFile}`, "PocketTTS mimi_decoder");
+        assertFileExists(tokenizerPath, "PocketTTS tokenizer.model");
+        assertFileExists(referenceAudioFile, "PocketTTS reference_sample.wav");
+        const ort = await loadOrt();
+        const providers = getOrtProviders(ort, device);
+        const [tokenizer, mimiEncoder, textConditioner, flowLmMain, flowLmFlow, mimiDecoder] = await Promise.all([
+            loadSentencePiece(tokenizerPath),
+            ort.InferenceSession.create(`${onnxDir}/mimi_encoder.onnx`, {
+                executionProviders: providers,
+            }),
+            ort.InferenceSession.create(`${onnxDir}/text_conditioner.onnx`, {
+                executionProviders: providers,
+            }),
+            ort.InferenceSession.create(`${onnxDir}/${flowMainFile}`, {
+                executionProviders: providers,
+            }),
+            ort.InferenceSession.create(`${onnxDir}/${flowFlowFile}`, {
+                executionProviders: providers,
+            }),
+            ort.InferenceSession.create(`${onnxDir}/${decoderFile}`, { executionProviders: providers }),
+        ]);
+        // Precompute flow matching time-step buffers.
+        const stBuffers = [];
+        for (let j = 0; j < lsdSteps; j += 1) {
+            const s = j / lsdSteps;
+            const t = s + 1.0 / lsdSteps;
+            stBuffers.push({
+                s: new ort.Tensor("float32", new Float32Array([s]), [1, 1]),
+                t: new ort.Tensor("float32", new Float32Array([t]), [1, 1]),
+            });
+        }
+        // Precompute reference voice embeddings once.
+        const refWav = await readFile(referenceAudioFile);
+        const parsed = parsePcm16MonoWav(refWav);
+        let pcm16 = parsed.pcm16;
+        if (parsed.sampleRate !== PocketTtsOnnxEngine.SAMPLE_RATE) {
+            const resampler = new Pcm16MonoResampler({
+                inputRate: parsed.sampleRate,
+                outputRate: PocketTtsOnnxEngine.SAMPLE_RATE,
+            });
+            pcm16 = resampler.processChunk(pcm16);
+        }
+        const floatAudio = pcm16leToFloat32(pcm16);
+        const audioTensor = new ort.Tensor("float32", floatAudio, [1, 1, floatAudio.length]);
+        const encoded = await mimiEncoder.run({ audio: audioTensor });
+        const firstOutName = mimiEncoder.outputNames?.[0];
+        const voiceEmb = firstOutName
+            ? encoded[firstOutName]
+            : Object.values(encoded)[0];
+        if (!voiceEmb) {
+            throw new Error("PocketTTS mimi_encoder: missing output");
+        }
+        log.info({ precision, device, providers, lsdSteps, temperature }, "PocketTTS ONNX initialized");
+        return new PocketTtsOnnxEngine({
+            ort,
+            temperature,
+            lsdSteps,
+            maxFrames,
+            framesAfterEos,
+            firstChunkFrames,
+            maxChunkFrames,
+            tokenizer,
+            textConditioner,
+            flowLmMain,
+            flowLmFlow,
+            mimiDecoder,
+            stBuffers,
+            voiceEmbeddings: voiceEmb,
+        });
+    }
+    tokenize(text) {
+        const normalized = normalizeTextForPocket(text);
+        const ids = this.tokenizer.encodeIds(normalized);
+        const data = toBigInt64(ids ?? []);
+        return new this.ort.Tensor("int64", data, [1, data.length]);
+    }
+    async runTextConditioner(tokenIds) {
+        const out = await this.textConditioner.run({ token_ids: tokenIds });
+        const firstOutName = this.textConditioner.outputNames?.[0];
+        const t = firstOutName ? out[firstOutName] : Object.values(out)[0];
+        if (!t)
+            throw new Error("PocketTTS text_conditioner: missing output");
+        return t;
+    }
+    async *runFlowLm(textEmbeddings) {
+        const ort = this.ort;
+        const state = initState(this.flowLmMain, ort);
+        const emptySeq = new ort.Tensor("float32", new Float32Array(0), [1, 0, 32]);
+        const emptyText = new ort.Tensor("float32", new Float32Array(0), [1, 0, 1024]);
+        // Voice conditioning pass
+        const resVoice = await this.flowLmMain.run({
+            sequence: emptySeq,
+            text_embeddings: this.voiceEmbeddings,
+            ...state,
+        });
+        updateStateFromOutputs(state, resVoice);
+        // Text conditioning pass
+        const resText = await this.flowLmMain.run({
+            sequence: emptySeq,
+            text_embeddings: textEmbeddings,
+            ...state,
+        });
+        updateStateFromOutputs(state, resText);
+        // Autoregressive generation
+        const curr = new Float32Array(32);
+        curr.fill(Number.NaN);
+        let currTensor = new ort.Tensor("float32", curr, [1, 1, 32]);
+        const dt = 1.0 / this.lsdSteps;
+        let eosStep = null;
+        for (let step = 0; step < this.maxFrames; step += 1) {
+            const resStep = await this.flowLmMain.run({
+                sequence: currTensor,
+                text_embeddings: emptyText,
+                ...state,
+            });
+            const outputNames = this.flowLmMain.outputNames;
+            const conditioningName = outputNames?.[0] ?? Object.keys(resStep)[0];
+            const eosName = outputNames?.[1] ?? Object.keys(resStep)[1];
+            const conditioning = resStep[conditioningName];
+            const eos = resStep[eosName];
+            if (!conditioning || !eos) {
+                throw new Error("PocketTTS flow_lm_main: missing conditioning/EOS outputs");
+            }
+            updateStateFromOutputs(state, resStep);
+            const eosData = tensorDataFloat32(eos);
+            if (eosData[0] > -4.0 && eosStep === null) {
+                eosStep = step;
+            }
+            if (eosStep !== null && step >= eosStep + this.framesAfterEos) {
+                break;
+            }
+            // Flow matching with external Euler loop.
+            const std = this.temperature > 0 ? Math.sqrt(this.temperature) : 0;
+            const x = new Float32Array(32);
+            if (std > 0) {
+                for (let i = 0; i < x.length; i += 1) {
+                    x[i] = randn() * std;
+                }
+            }
+            for (const st of this.stBuffers) {
+                const xTensor = new ort.Tensor("float32", x, [1, 32]);
+                const flowOut = await this.flowLmFlow.run({
+                    c: conditioning,
+                    s: st.s,
+                    t: st.t,
+                    x: xTensor,
+                });
+                const first = this.flowLmFlow.outputNames?.[0];
+                const flowTensor = first ? flowOut[first] : Object.values(flowOut)[0];
+                if (!flowTensor)
+                    throw new Error("PocketTTS flow_lm_flow: missing output");
+                const delta = tensorDataFloat32(flowTensor);
+                for (let i = 0; i < x.length; i += 1) {
+                    x[i] = x[i] + delta[i] * dt;
+                }
+            }
+            yield x;
+            currTensor = new ort.Tensor("float32", x, [1, 1, 32]);
+        }
+    }
+    async decodeLatentsChunk(frames, state) {
+        const ort = this.ort;
+        const frameCount = frames.length;
+        const flattened = new Float32Array(frameCount * 32);
+        for (let i = 0; i < frameCount; i += 1) {
+            flattened.set(frames[i], i * 32);
+        }
+        const latent = new ort.Tensor("float32", flattened, [1, frameCount, 32]);
+        const out = await this.mimiDecoder.run({ latent, ...state });
+        updateStateFromOutputs(state, out);
+        const firstOutName = this.mimiDecoder.outputNames?.[0];
+        const audioTensor = firstOutName ? out[firstOutName] : Object.values(out)[0];
+        if (!audioTensor) {
+            throw new Error("PocketTTS mimi_decoder: missing audio output");
+        }
+        return tensorDataFloat32(audioTensor);
+    }
+    async *streamAudio(text) {
+        const tokenIds = this.tokenize(text);
+        const textEmb = await this.runTextConditioner(tokenIds);
+        const decoderState = initState(this.mimiDecoder, this.ort);
+        const generated = [];
+        let decodedFrames = 0;
+        for await (const latent of this.runFlowLm(textEmb)) {
+            generated.push(latent);
+            const pending = generated.length - decodedFrames;
+            let chunkSize = 0;
+            if (decodedFrames === 0) {
+                if (pending >= this.firstChunkFrames) {
+                    chunkSize = this.firstChunkFrames;
+                }
+            }
+            else if (pending >= this.maxChunkFrames) {
+                chunkSize = this.maxChunkFrames;
+            }
+            if (chunkSize > 0) {
+                const audio = await this.decodeLatentsChunk(generated.slice(decodedFrames, decodedFrames + chunkSize), decoderState);
+                decodedFrames += chunkSize;
+                yield audio;
+            }
+        }
+        if (decodedFrames < generated.length) {
+            const audio = await this.decodeLatentsChunk(generated.slice(decodedFrames), decoderState);
+            yield audio;
+        }
+    }
+}
+PocketTtsOnnxEngine.SAMPLE_RATE = 24000;
+PocketTtsOnnxEngine.SAMPLES_PER_FRAME = 1920;
+export class PocketTtsOnnxTTS {
+    constructor(engine, logger, chunkMs) {
+        this.engine = engine;
+        this.chunkMs = chunkMs;
+        this.logger = logger.child({ module: "speech", provider: "pocket-tts", component: "tts" });
+    }
+    static async create(config, logger) {
+        const engine = await PocketTtsOnnxEngine.create(config, logger);
+        const chunkMs = config.targetChunkMs ?? 50;
+        return new PocketTtsOnnxTTS(engine, logger, chunkMs);
+    }
+    async synthesizeSpeech(text) {
+        const start = Date.now();
+        const sampleRate = PocketTtsOnnxEngine.SAMPLE_RATE;
+        const pcmChunkBytes = Math.max(2, Math.round((sampleRate * this.chunkMs) / 1000) * 2);
+        const iterable = (async function* (engine) {
+            for await (const floatChunk of engine.streamAudio(text)) {
+                const pcm = float32ToPcm16le(floatChunk);
+                for (const chunk of chunkBuffer(pcm, pcmChunkBytes)) {
+                    yield chunk;
+                }
+            }
+        })(this.engine);
+        this.logger.debug({ ms: Date.now() - start, textLength: text.length }, "PocketTTS stream ready");
+        return {
+            stream: Readable.from(iterable),
+            format: `pcm;rate=${sampleRate}`,
+        };
+    }
+}
+//# sourceMappingURL=pocket-tts-onnx.js.map