@qvac/tts-ggml 0.12.0 → 0.14.0

package/lib/pocketLifecycle.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PocketLifecycle = void 0;
+const pocketConfig_1 = require("./pocketConfig");
+const sentenceStream_1 = require("./sentenceStream");
+class PocketLifecycle {
+    host;
+    /** The native job awaiting its terminal callback, or null. */
+    jobPending = null;
+    cancelPromise = null;
+    inProgress = false;
+    constructor(host) {
+        this.host = host;
+    }
+    /** A cancel in flight finishes, terminal callback included, before anything else starts. */
+    async waitCancel() {
+        if (this.cancelPromise)
+            await this.cancelPromise;
+    }
+    /** One lifecycle operation at a time; requests are refused while one runs. */
+    checkReload() {
+        if (this.inProgress) {
+            throw new Error("Pocket lifecycle operation is already in progress");
+        }
+    }
+    /** A synthesis request needs a loaded instance and no job in flight. */
+    checkRequest() {
+        const { state } = this.host;
+        if (state.destroyed)
+            throw new Error("Pocket instance was destroyed");
+        if (!state.weightsLoaded || !this.host.optionalAddon()) {
+            throw new Error("Pocket model is not loaded");
+        }
+        if (this.host.activeJob() || this.jobPending) {
+            throw new Error("Pocket synthesis is already in progress");
+        }
+        this.checkReload();
+    }
+    async withLifecycle(action) {
+        await this.waitCancel();
+        this.checkReload();
+        this.inProgress = true;
+        try {
+            await action();
+        }
+        finally {
+            this.inProgress = false;
+        }
+    }
+    /** Runs the job behind a completion barrier that its terminal callback releases. */
+    async runJob(addon, input) {
+        if (this.jobPending)
+            throw new Error("Pocket native job is already in progress");
+        let resolve = () => { };
+        const promise = new Promise((done) => {
+            resolve = done;
+        });
+        const pending = { promise, resolve };
+        this.jobPending = pending;
+        try {
+            await addon.runJob(input);
+        }
+        catch (error) {
+            if (this.jobPending === pending)
+                this.jobPending = null;
+            resolve();
+            throw error;
+        }
+    }
+    /** A terminal native callback (error or stats) releases the completion barrier. */
+    onNativeEvent(data, error) {
+        const pending = this.jobPending;
+        if (!pending)
+            return;
+        if ((typeof error === "string" && error.length > 0) || (0, sentenceStream_1.isStatsEvent)(data)) {
+            this.jobPending = null;
+            pending.resolve();
+        }
+    }
+    /**
+     * Fails `response` with the caller's reason and stops native work. The
+     * completion barrier stays until the terminal callback arrives.
+     */
+    attachAbort(response, signal) {
+        const onAbort = () => {
+            if (this.host.activeJob() !== response)
+                return;
+            const reason = signal.reason;
+            const error = reason instanceof Error
+                ? reason
+                : new Error(typeof reason === "string" ? `Aborted: ${reason}` : "Aborted");
+            try {
+                response.failed(error);
+            }
+            finally {
+                void this.cancel().catch((error) => this.host.logger().error("Pocket abort cancellation failed", error));
+            }
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        const detach = () => signal.removeEventListener("abort", onAbort);
+        void response.await().then(detach, detach);
+    }
+    /** Stops native work and waits for the job in flight to report its end. */
+    async cancel() {
+        if (this.cancelPromise)
+            return this.cancelPromise;
+        const addon = this.host.optionalAddon();
+        const pending = this.jobPending;
+        this.cancelPromise = (async () => {
+            this.host.failStream("Synthesis cancelled");
+            if (addon?.cancel)
+                await addon.cancel();
+            // Joining the worker can precede delivery of its terminal callback.
+            if (pending)
+                await pending.promise;
+        })();
+        try {
+            await this.cancelPromise;
+        }
+        finally {
+            this.cancelPromise = null;
+        }
+    }
+    /**
+     * Replaces the native instance with one built from the merged options.
+     * Native work is drained and the old model released before the replacement
+     * is allocated; a failed activation leaves the instance unloaded with its
+     * last good configuration.
+     */
+    async reload(newConfig) {
+        await this.waitCancel();
+        this.checkReload();
+        const { setup, state } = this.host;
+        if (state.destroyed)
+            throw new Error("Pocket instance was destroyed");
+        const pocket = setup.pocket;
+        if (!pocket)
+            throw new Error("Pocket engine is not configured");
+        const options = { ...pocket.options, ...newConfig };
+        const config = { ...setup.config, ...newConfig };
+        const params = (0, pocketConfig_1.buildPocketParams)(pocket.files, options, config);
+        this.inProgress = true;
+        let replacement = null;
+        try {
+            await this.host.unloadModel();
+            replacement = this.host.createAddon(params);
+            await replacement.activate();
+            this.host.setAddon(replacement);
+            replacement = null;
+            setup.pocket = { files: pocket.files, options, params };
+            setup.config.language = "en";
+            setup.config.useGPU = false;
+            setup.outputSampleRate =
+                typeof params.outputSampleRate === "number" ? params.outputSampleRate : null;
+            setup.config.outputSampleRate = setup.outputSampleRate ?? undefined;
+            state.configLoaded = true;
+            state.weightsLoaded = true;
+        }
+        finally {
+            try {
+                if (replacement)
+                    await replacement.destroyInstance();
+            }
+            finally {
+                this.inProgress = false;
+            }
+        }
+    }
+}
+exports.PocketLifecycle = PocketLifecycle;

package/lib/reload.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `reload()` configuration: which settings a reload may rewrite, applied
+ * against a snapshot so a rejected reload leaves the instance untouched.
+ */
+import type { TTSConfigurationParams } from "../tts";
+import type { EngineSetup } from "./engineSetup";
+/**
+ * Apply the new configuration and build the native parameters from it. A
+ * rejected value leaves the instance exactly as it was, so a later partial
+ * reload is not validated against state the caller never accepted.
+ */
+export declare function applyReloadableConfig(setup: EngineSetup, newConfig: Record<string, unknown>): TTSConfigurationParams;

package/lib/reload.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyReloadableConfig = applyReloadableConfig;
+const conditioning_1 = require("./conditioning");
+const engineParams_1 = require("./engineParams");
+const audio8_1 = require("./engines/audio8");
+const moss_1 = require("./engines/moss");
+const parler_1 = require("./engines/parler");
+const setup_1 = require("./setup");
+function captureReloadableState(setup) {
+    return {
+        language: setup.config.language,
+        useGPU: setup.config.useGPU,
+        outputSampleRate: setup.outputSampleRate,
+        settings: { ...setup.settings },
+    };
+}
+function restoreReloadableState(setup, state) {
+    setup.config.language = state.language;
+    setup.config.useGPU = state.useGPU;
+    setup.outputSampleRate = state.outputSampleRate;
+    const live = setup.settings;
+    const snapshot = state.settings;
+    for (const key of new Set([...Object.keys(live), ...Object.keys(snapshot)])) {
+        live[key] = snapshot[key];
+    }
+}
+function applyReloadableRuntimeConfig(setup, newConfig) {
+    (0, moss_1.assertMossReloadKeepsVoice)(setup, newConfig);
+    const runtimeConfig = newConfig;
+    if (runtimeConfig.language !== undefined) {
+        setup.config.language = runtimeConfig.language;
+    }
+    if (runtimeConfig.useGPU !== undefined) {
+        setup.config.useGPU = runtimeConfig.useGPU;
+    }
+    if (runtimeConfig.outputSampleRate !== undefined) {
+        setup.outputSampleRate = (0, setup_1.validateOutputSampleRate)(runtimeConfig.outputSampleRate);
+    }
+    (0, audio8_1.applyAudio8Reload)(setup, newConfig);
+    (0, moss_1.applyMossReload)(setup, newConfig);
+}
+// Cross-engine conditioning is reloadable on every engine that supports it,
+// so both families change emotion the same way.
+function applyReloadableConditioning(setup, newConfig) {
+    const conditioning = newConfig;
+    if (conditioning.emotion === undefined &&
+        conditioning.pace === undefined) {
+        return;
+    }
+    if (conditioning.emotion !== undefined) {
+        setup.settings.emotion = conditioning.emotion;
+    }
+    if (conditioning.pace !== undefined) {
+        setup.settings.pace = conditioning.pace;
+    }
+    (0, conditioning_1.assertConditioningConsistency)(setup, "reload");
+}
+/**
+ * Apply the new configuration and build the native parameters from it. A
+ * rejected value leaves the instance exactly as it was, so a later partial
+ * reload is not validated against state the caller never accepted.
+ */
+function applyReloadableConfig(setup, newConfig) {
+    const snapshot = captureReloadableState(setup);
+    try {
+        applyReloadableRuntimeConfig(setup, newConfig);
+        applyReloadableConditioning(setup, newConfig);
+        (0, parler_1.applyParlerReload)(setup, newConfig);
+        return (0, engineParams_1.buildNativeParams)(setup);
+    }
+    catch (error) {
+        restoreReloadableState(setup, snapshot);
+        throw error;
+    }
+}

package/lib/sentenceStream.d.ts

@@ -0,0 +1,85 @@
+import type { QvacResponse } from "@qvac/infer-base";
+import type { TTSJobData } from "../tts";
+import type { JobFields } from "./jobFields";
+import type { NativeOutputChunk, NativeStats, RunStreamingOptions, RuntimeStats, SentenceStreamChunkMeta, SentenceStreamOptions, TextStreamInput, TTSOutputChunk } from "./types";
+export type SentenceStreamResponse = QvacResponse<TTSOutputChunk & SentenceStreamChunkMeta>;
+export interface ChunkResolver {
+    resolve(): void;
+    reject(error: unknown): void;
+}
+export interface StreamAccumulator {
+    firstAudioMs?: number;
+    totalTime: number;
+    audioDurationMs: number;
+    totalSamples: number;
+    generatedFrames: number;
+    codecSidecarLoaded?: number;
+    codecOnCoreml?: number;
+}
+export interface SentenceStreamContext {
+    textStreamMode?: boolean;
+    asyncTextSource?: AsyncIterable<string>;
+    chunks: string[];
+    chunkIdx: number;
+    acc: StreamAccumulator;
+    chunkResolver: ChunkResolver | null;
+    jobFields?: JobFields;
+}
+export declare function normalizeError(error: unknown): string | Error;
+export declare function ttsOutputDebugString(data: unknown): string;
+export declare function isAudioOutputEvent(data: unknown): data is NativeOutputChunk;
+export declare function isStatsEvent(data: unknown): data is NativeStats;
+/**
+ * What `tokensPerSecond` counts. Audio8 paces on the codec frame grid and
+ * reports frames per second in batch synthesis; the text-paced engines report
+ * characters per second. Streaming has to keep the same unit as `run()` or the
+ * number silently changes meaning between the two entry points.
+ */
+export declare function emptyStreamAccumulator(): StreamAccumulator;
+export declare function computeSentenceStreamStats(chunks: string[], accumulator: StreamAccumulator, countsFrames: boolean): RuntimeStats;
+export declare function resolveRunStreamingOptions(textStream: TextStreamInput, options: RunStreamingOptions): Required<Pick<RunStreamingOptions, "accumulateSentences" | "sentenceDelimiterPreset" | "flushAfterMs">> & Pick<RunStreamingOptions, "maxBufferScalars" | "sentenceDelimiter">;
+export declare function normalizeTextStream(textStream: TextStreamInput): AsyncIterable<string>;
+/** `run({ streamOutput: true })` splits its text, so it needs a non-empty string. */
+export declare function requireStreamOutputText(input: unknown): string;
+/** The sentence chunks of `text`; an input that yields none is an error. */
+export declare function splitSentenceChunks(text: string, options: SentenceStreamOptions, language: string | undefined): string[];
+/** What the stream driver needs from the wrapper that owns the job handler. */
+export interface SentenceStreamHost {
+    /** Opens the response the whole stream reports through. */
+    startJob(): SentenceStreamResponse;
+    dispatchJob(job: TTSJobData): Promise<void>;
+    endJob(stats: RuntimeStats | NativeStats): void;
+    failJob(error: string | Error): void;
+    /**
+     * Audio8 and MOSS report `tokensPerSecond` as codec frames per second, so
+     * the streaming aggregate has to count frames too rather than characters.
+     */
+    countsFrames(): boolean;
+}
+/**
+ * Drives one sentence stream at a time. The wrapper routes native output and
+ * stats events here while a context is active; a newer stream, a cancel or a
+ * reload replaces or clears the context, and the driver of the old stream
+ * notices and stops.
+ */
+export declare class SentenceStreamer {
+    private readonly host;
+    /** The active stream, or null between streams. */
+    ctx: SentenceStreamContext | null;
+    constructor(host: SentenceStreamHost);
+    streamChunks(chunks: string[], jobFields?: JobFields): SentenceStreamResponse;
+    streamText(source: AsyncIterable<string>, jobFields?: JobFields): SentenceStreamResponse;
+    rejectActiveChunk(error: unknown): void;
+    fail(reason: string | Error): void;
+    enrich(data: NativeOutputChunk): TTSOutputChunk & SentenceStreamChunkMeta;
+    /**
+     * Folds a chunk's stats into the aggregate and releases the chunk; after the
+     * last pre-chunked sentence, ends the job. Returns false when no stream is
+     * active, so the caller can end a plain job with the stats as they are.
+     */
+    onStats(data: NativeStats): boolean;
+    private abort;
+    private driveChunks;
+    private driveText;
+    private synthesizeChunk;
+}