@qvac/tts-ggml 0.14.1 → 0.15.0

package/lib/fit.d.ts

@@ -4,16 +4,13 @@
  * the same keys and applies the same defaults as the load it describes.
  */
 interface TtsFitCommon {
+    backend?: string;
     /** Layers to offload. Unset defers to `useGPU`. */
     nGpuLayers?: number;
     /** All layers or none, when `nGpuLayers` is unset. */
     useGPU?: boolean;
     vulkanDevice?: number;
     backendsDir?: string;
-    /** LavaSR enhancer; a non-empty path turns enhancement on. */
-    lavasrEnhancerPath?: string;
-    /** LavaSR denoiser, applied before the enhancer. */
-    lavasrDenoiserPath?: string;
     /** Free memory that must remain for the projection to count as fitting. Defaults to 256 MiB. */
     marginBytes?: number;
 }
@@ -32,6 +29,8 @@ export interface SupertonicFitRequest extends TtsFitCommon {
 export interface ParlerFitRequest extends TtsFitCommon {
     engineType: 'parler';
     parlerModelPath: string;
+    /** Match the Parler decoder-sidecar load policy. */
+    coremlDecoder?: boolean;
     descriptionTokens?: number;
     promptTokens?: number;
     /** 0 takes the checkpoint's default generation length. */
@@ -67,6 +66,8 @@ export interface CosyvoiceFitRequest extends TtsFitCommon {
     speechTokens?: number;
 }
 export interface MossFitRequest extends TtsFitCommon {
+    nCtx?: number;
+    maxNewTokens?: number;
     engineType: 'moss';
     mossBackbonePath: string;
     mossCodecDecoderPath: string;
@@ -92,41 +93,50 @@ export interface MossSoundEffectFitRequest extends TtsFitCommon {
     shift?: number;
     threads?: number;
 }
-export type TtsFitRequest = SupertonicFitRequest | ParlerFitRequest | ChatterboxFitRequest | Audio8FitRequest | CosyvoiceFitRequest | MossFitRequest | MossSoundEffectFitRequest;
+export interface PocketFitRequest extends TtsFitCommon {
+    engineType: 'pocket';
+    pocketFlowModelPath: string;
+    pocketMimiModelPath: string;
+    pocketFrontendPath: string;
+    pocketVoicePath?: string;
+    referenceAudio?: string;
+    text: string;
+    threads?: number;
+    nCtx?: number;
+    maxTokens?: number;
+    steps?: number;
+    framesAfterEos?: number;
+    memoryBudgetBytes?: number;
+}
+export type TtsFitRequest = PocketFitRequest | SupertonicFitRequest | ParlerFitRequest | ChatterboxFitRequest | Audio8FitRequest | CosyvoiceFitRequest | MossFitRequest | MossSoundEffectFitRequest;
 /** The voice engines a fit can be asked for, read off the request union. */
 export type TtsFitEngine = TtsFitRequest['engineType'];
-export type TtsFitStatus = 'fits' | 'does-not-fit' | 'error';
+/**
+ * `unknown` is a load the fitter cannot size: supertonic outside the fused
+ * graph path it models, a CosyVoice3 or Parler load with Core ML sidecars, or a failed
+ * measurement.
+ */
+export type TtsFitStatus = 'fits' | 'does-not-fit' | 'unknown';
+export interface TtsFitDevice {
+    /** The PCI bus ID when the backend reports one, the device name otherwise. */
+    id: string;
+    name: string;
+    /** Memory the host owns: the host CPU, and a GPU that shares the host's memory. */
+    unified: boolean;
+    /** Memory the load takes on this device. */
+    usedBytes: number;
+    freeBytes: number;
+    totalBytes: number;
+}
+export type TtsFitStats = Record<string, never>;
 export interface TtsFitResult {
     status: TtsFitStatus;
     /**
-     * The engine's own wording, e.g. `model-unreadable`, `workload-too-large`.
-     * `unsupported-engine` names a voice the addon loads and the fitter does
-     * not cover.
-     */
-    reason: string;
-    /** Which pipeline was projected, e.g. `chatterbox-t3-turbo`. */
-    modelVariant: string;
-    deviceName: string;
-    deviceIsCpu: boolean;
-    /** The device pool is system RAM, so host bytes compete with device bytes. */
-    deviceSharesHostMemory: boolean;
-    deviceFreeBytes: number;
-    deviceTotalBytes: number;
-    deviceBytes: number;
-    weightsBytes: number;
-    stateBytes: number;
-    /** 0 for a pipeline with no language-model stage, such as supertonic. */
-    lmComputeBytes: number;
-    /** 0 for a pipeline with no separate codec stage. */
-    codecComputeBytes: number;
-    hostBytes: number;
-    /**
-     * The LavaSR stages' size on disk, 0 when none was named. They have no
-     * fitter, so this is a size on disk. It is counted in neither `deviceBytes`
-     * nor `hostBytes`.
+     * The device the load resolves to, then the host CPU. One CPU row for a load
+     * on the CPU, and none for `unknown`.
      */
-    lavasrFileBytes: number;
-    report: string;
+    devices: TtsFitDevice[];
+    stats: TtsFitStats;
 }
 /**
  * Projects one voice against the memory free right now, reading GGUF metadata
@@ -139,9 +149,9 @@ export interface TtsFitResult {
  *
  * `engineType` picks the fitter, the same key a load uses, and is required
  * here: a fit request carries none of the file keys a load is inferred from.
- * A model the engine cannot read resolves to `status: "error"`, as does a
- * voice with no fitter; a broken request, or a host with no native binding,
- * rejects. Fits run one at a time within this addon.
+ * A model the engine cannot read, a voice with no fitter, an invalid request,
+ * or a host with no native binding rejects. Fits run one at a time within this
+ * addon.
  */
 export declare function assessFit(request: TtsFitRequest): Promise<TtsFitResult>;
 export {};

package/lib/fit.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assessFit = assessFit;
+const fabricOptions_1 = require("./fabricOptions");
 /**
  * Projects one voice against the memory free right now, reading GGUF metadata
  * and never weight data. The registry's weightless copy of each file answers
@@ -12,11 +13,12 @@ exports.assessFit = assessFit;
  *
  * `engineType` picks the fitter, the same key a load uses, and is required
  * here: a fit request carries none of the file keys a load is inferred from.
- * A model the engine cannot read resolves to `status: "error"`, as does a
- * voice with no fitter; a broken request, or a host with no native binding,
- * rejects. Fits run one at a time within this addon.
+ * A model the engine cannot read, a voice with no fitter, an invalid request,
+ * or a host with no native binding rejects. Fits run one at a time within this
+ * addon.
  */
 async function assessFit(request) {
+    (0, fabricOptions_1.validateBackendOption)(request.engineType, request.backend);
     // eslint-disable-next-line @typescript-eslint/no-require-imports -- the native binding loads on first use.
     const binding = require('../binding.js');
     return await binding.assessFit(request);

package/lib/jobFields.js

@@ -50,6 +50,7 @@ function assertNoOtherEngineFields(setup, source, where) {
  * and every engine the cross-engine conditioning it supports.
  */
 function resolveJobFields(setup, source, where) {
+    (0, parler_1.assertNoPerCallParlerCoreml)(source, where);
     if (setup.engineType === engineIds_1.ENGINE_MOSS_SPEECH) {
         assertNoOtherEngineFields(setup, source, where);
         return (0, mossSpeech_1.resolveSpeechJobFields)(source, where);

package/lib/nativeParams.js

@@ -70,4 +70,16 @@ function assignLavasrParams(setup, parameters) {
     if (setup.backend.denoiserGgufPath) {
         parameters.lavasrDenoiserPath = setup.backend.denoiserGgufPath;
     }
+    if (setup.backend.enhancerCoremlModelPath !== undefined) {
+        parameters.lavasrEnhancerCoremlModelPath =
+            setup.backend.enhancerCoremlModelPath;
+        parameters.lavasrEnhancerCoremlComputeUnits =
+            setup.backend.enhancerCoremlComputeUnits;
+    }
+    if (setup.backend.denoiserCoremlModelPath !== undefined) {
+        parameters.lavasrDenoiserCoremlModelPath =
+            setup.backend.denoiserCoremlModelPath;
+        parameters.lavasrDenoiserCoremlComputeUnits =
+            setup.backend.denoiserCoremlComputeUnits;
+    }
 }

package/lib/pocketConfig.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildPocketParams = buildPocketParams;
 const bare_path_1 = __importDefault(require("bare-path"));
+const fabricOptions_1 = require("./fabricOptions");
 const DEFAULT_SAMPLING_STEPS = 1;
 const UNSUPPORTED_OPTIONS = [
     'voice',
@@ -36,6 +37,9 @@ const UNSUPPORTED_OPTIONS = [
     'maxFrames',
     'minNewTokens',
     'normalizeNumbers',
+    'coremlDecoder',
+    'coremlComputeUnits',
+    'coremlStrict',
     'enhancer',
     'denoiser'
 ];
@@ -69,14 +73,21 @@ function resolveModelFiles(files, options) {
     };
 }
 function validateEngineOptions(options, config) {
+    (0, fabricOptions_1.resolveFabricOptions)('pocket', options);
+    (0, fabricOptions_1.validateBackendOption)('pocket', config.backend);
+    if (config.useGPU !== undefined && typeof config.useGPU !== 'boolean')
+        throw new Error('Pocket useGPU must be a boolean');
+    if (options.nGpuLayers !== undefined &&
+        (typeof options.nGpuLayers !== 'number' || !Number.isInteger(options.nGpuLayers) ||
+            options.nGpuLayers < -2147483648 || options.nGpuLayers > 2147483647))
+        throw new Error('Pocket nGpuLayers must be a 32-bit integer');
+    if (typeof config.useGPU === 'boolean' && typeof options.nGpuLayers === 'number' &&
+        config.useGPU !== (options.nGpuLayers !== 0))
+        throw new Error('Pocket useGPU conflicts with nGpuLayers');
     if (options.referenceAudio !== undefined && typeof options.referenceAudio !== 'string')
         throw new Error('Pocket referenceAudio must be a path string');
     if (config.language !== undefined && config.language !== 'en')
         throw new Error('Pocket currently supports English (en) only');
-    if (config.useGPU !== undefined && config.useGPU !== false)
-        throw new Error('Pocket currently supports CPU only (useGPU: false)');
-    if (options.nGpuLayers !== undefined && options.nGpuLayers !== 0)
-        throw new Error('Pocket requires nGpuLayers: 0');
     if (options.steps !== undefined &&
         options.numInferenceSteps !== undefined &&
         options.steps !== options.numInferenceSteps)
@@ -138,6 +149,18 @@ function buildPocketParams(files, optionInput, configInput) {
     validateEngineOptions(options, config);
     rejectUnsupportedOptions(options);
     const params = resolveModelFiles(files, options);
+    if (config.useGPU !== undefined)
+        params.useGPU = config.useGPU;
+    if (options.nGpuLayers !== undefined)
+        params.nGpuLayers = options.nGpuLayers;
+    if (options.nGpuLayers !== undefined && config.useGPU === undefined)
+        params.useGPU = options.nGpuLayers !== 0;
+    if (config.backendsDir !== undefined)
+        params.backendsDir = config.backendsDir;
+    if (options.backendsDir !== undefined)
+        params.backendsDir = options.backendsDir;
+    if (config.backend !== undefined)
+        params.backend = config.backend;
     applyNumericOptions(params, options, config);
     validateRequiredFiles(params);
     validateVoiceConditioning(params);

package/lib/pocketLifecycle.js

@@ -138,6 +138,12 @@ class PocketLifecycle {
             throw new Error("Pocket engine is not configured");
         const options = { ...pocket.options, ...newConfig };
         const config = { ...setup.config, ...newConfig };
+        if (newConfig.nGpuLayers !== undefined && newConfig.useGPU === undefined) {
+            config.useGPU = undefined;
+        }
+        if (newConfig.useGPU !== undefined && newConfig.nGpuLayers === undefined) {
+            options.nGpuLayers = undefined;
+        }
         const params = (0, pocketConfig_1.buildPocketParams)(pocket.files, options, config);
         this.inProgress = true;
         let replacement = null;
@@ -149,7 +155,9 @@ class PocketLifecycle {
             replacement = null;
             setup.pocket = { files: pocket.files, options, params };
             setup.config.language = "en";
-            setup.config.useGPU = false;
+            setup.config.useGPU = params.useGPU;
+            setup.config.backend = params.backend;
+            setup.settings.nGpuLayers = params.nGpuLayers;
             setup.outputSampleRate =
                 typeof params.outputSampleRate === "number" ? params.outputSampleRate : null;
             setup.config.outputSampleRate = setup.outputSampleRate ?? undefined;

package/lib/reload.js

@@ -5,12 +5,15 @@ const conditioning_1 = require("./conditioning");
 const engineParams_1 = require("./engineParams");
 const audio8_1 = require("./engines/audio8");
 const moss_1 = require("./engines/moss");
+const fabricOptions_1 = require("./fabricOptions");
+const engineIds_1 = require("./engineIds");
 const parler_1 = require("./engines/parler");
 const setup_1 = require("./setup");
 function captureReloadableState(setup) {
     return {
         language: setup.config.language,
         useGPU: setup.config.useGPU,
+        backend: setup.config.backend,
         outputSampleRate: setup.outputSampleRate,
         settings: { ...setup.settings },
     };
@@ -18,6 +21,7 @@ function captureReloadableState(setup) {
 function restoreReloadableState(setup, state) {
     setup.config.language = state.language;
     setup.config.useGPU = state.useGPU;
+    setup.config.backend = state.backend;
     setup.outputSampleRate = state.outputSampleRate;
     const live = setup.settings;
     const snapshot = state.settings;
@@ -28,6 +32,18 @@ function restoreReloadableState(setup, state) {
 function applyReloadableRuntimeConfig(setup, newConfig) {
     (0, moss_1.assertMossReloadKeepsVoice)(setup, newConfig);
     const runtimeConfig = newConfig;
+    (0, fabricOptions_1.validateBackendOption)(setup.engineType, runtimeConfig.backend);
+    if (runtimeConfig.backend !== undefined)
+        setup.config.backend = runtimeConfig.backend;
+    Object.assign(setup.settings, (0, fabricOptions_1.resolveFabricOptions)(setup.engineType, { ...setup.settings, ...newConfig }));
+    if (setup.engineType === engineIds_1.ENGINE_MOSS && newConfig.nCtx !== undefined) {
+        setup.settings.nCtx = newConfig.nCtx;
+    }
+    if (setup.engineType === engineIds_1.ENGINE_COSYVOICE3 && newConfig.greedy !== undefined) {
+        if (typeof newConfig.greedy !== "boolean")
+            throw new Error("greedy must be a boolean");
+        setup.settings.greedy = newConfig.greedy;
+    }
     if (runtimeConfig.language !== undefined) {
         setup.config.language = runtimeConfig.language;
     }
@@ -39,6 +55,9 @@ function applyReloadableRuntimeConfig(setup, newConfig) {
     }
     (0, audio8_1.applyAudio8Reload)(setup, newConfig);
     (0, moss_1.applyMossReload)(setup, newConfig);
+    if (setup.engineType === engineIds_1.ENGINE_MOSS) {
+        (0, moss_1.assertMossDurationTokens)(setup.settings.durationTokens, "reload", setup.settings.maxNewTokens);
+    }
 }
 // Cross-engine conditioning is reloadable on every engine that supports it,
 // so both families change emotion the same way.

package/lib/sentenceStream.d.ts

@@ -7,14 +7,26 @@ export interface ChunkResolver {
     resolve(): void;
     reject(error: unknown): void;
 }
-export interface StreamAccumulator {
+/**
+ * Stats a stream keeps from the last chunk that reported them instead of
+ * summing: where the synthesis ran, whether the Audio8 codec used its Core ML
+ * sidecar, and which Parler sidecars were still loaded.
+ */
+export declare const LAST_REPORTED_STREAM_STATS: readonly ["backendDevice", "backendId", "gpuUnsupported", "enhancerBackendDevice", "enhancerBackendId", "denoiserBackendDevice", "denoiserBackendId", "codecSidecarLoaded", "codecOnCoreml", "decoderSidecarLoaded", "dacSidecarLoaded"];
+export type LastReportedStreamStat = (typeof LAST_REPORTED_STREAM_STATS)[number];
+/**
+ * Stats a stream keeps at the lowest value any chunk reported. Complete
+ * Core ML execution requires every sentence to have used it: a capacity
+ * fallback can leave the sidecar attached for the next sentence.
+ */
+export declare const EVERY_CHUNK_STREAM_STATS: readonly ["decoderOnCoreml", "dacOnCoreml"];
+export type EveryChunkStreamStat = (typeof EVERY_CHUNK_STREAM_STATS)[number];
+export interface StreamAccumulator extends Partial<Pick<RuntimeStats, LastReportedStreamStat | EveryChunkStreamStat>> {
     firstAudioMs?: number;
     totalTime: number;
     audioDurationMs: number;
     totalSamples: number;
     generatedFrames: number;
-    codecSidecarLoaded?: number;
-    codecOnCoreml?: number;
 }
 export interface SentenceStreamContext {
     textStreamMode?: boolean;

package/lib/sentenceStream.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SentenceStreamer = void 0;
+exports.SentenceStreamer = exports.EVERY_CHUNK_STREAM_STATS = exports.LAST_REPORTED_STREAM_STATS = void 0;
 exports.normalizeError = normalizeError;
 exports.ttsOutputDebugString = ttsOutputDebugString;
 exports.isAudioOutputEvent = isAudioOutputEvent;
@@ -14,6 +14,33 @@ exports.splitSentenceChunks = splitSentenceChunks;
 const error_1 = require("./error");
 const textChunker_1 = require("./textChunker");
 const textStreamAccumulator_1 = require("./textStreamAccumulator");
+/**
+ * Stats a stream keeps from the last chunk that reported them instead of
+ * summing: where the synthesis ran, whether the Audio8 codec used its Core ML
+ * sidecar, and which Parler sidecars were still loaded.
+ */
+exports.LAST_REPORTED_STREAM_STATS = [
+    "backendDevice",
+    "backendId",
+    "gpuUnsupported",
+    "enhancerBackendDevice",
+    "enhancerBackendId",
+    "denoiserBackendDevice",
+    "denoiserBackendId",
+    "codecSidecarLoaded",
+    "codecOnCoreml",
+    "decoderSidecarLoaded",
+    "dacSidecarLoaded",
+];
+/**
+ * Stats a stream keeps at the lowest value any chunk reported. Complete
+ * Core ML execution requires every sentence to have used it: a capacity
+ * fallback can leave the sidecar attached for the next sentence.
+ */
+exports.EVERY_CHUNK_STREAM_STATS = [
+    "decoderOnCoreml",
+    "dacOnCoreml",
+];
 function normalizeError(error) {
     return typeof error === "string"
         ? error
@@ -209,13 +236,27 @@ function mergeSentenceStreamStats(accumulator, data) {
         typeof data.totalSamples === "number" ? data.totalSamples : 0;
     accumulator.generatedFrames +=
         typeof data.generatedFrames === "number" ? data.generatedFrames : 0;
-    if (typeof data.codecSidecarLoaded === "number") {
-        accumulator.codecSidecarLoaded = data.codecSidecarLoaded;
+    retainLastReportedStats(accumulator, data);
+    retainLowestReportedStats(accumulator, data);
+}
+function retainLastReportedStats(accumulator, data) {
+    for (const field of exports.LAST_REPORTED_STREAM_STATS) {
+        const value = data[field];
+        if (typeof value === "number")
+            accumulator[field] = value;
     }
-    if (typeof data.codecOnCoreml === "number") {
-        accumulator.codecOnCoreml = data.codecOnCoreml;
+}
+function retainLowestReportedStats(accumulator, data) {
+    for (const field of exports.EVERY_CHUNK_STREAM_STATS) {
+        const value = data[field];
+        if (typeof value === "number") {
+            accumulator[field] = lowestReported(accumulator[field], value);
+        }
     }
 }
+function lowestReported(previous, value) {
+    return previous === undefined ? value : Math.min(previous, value);
+}
 /**
  * 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
@@ -283,6 +324,9 @@ class SentenceStreamer {
         if (data.sampleRate != null) {
             enriched.sampleRate = data.sampleRate;
         }
+        if (data.speechTokenIds !== undefined) {
+            enriched.speechTokenIds = data.speechTokenIds;
+        }
         if (!context.textStreamMode) {
             enriched.isLast = index >= context.chunks.length - 1 && data.isLast !== false;
         }

package/lib/setup.js

@@ -17,12 +17,35 @@ const engineDetection_1 = require("./engineDetection");
 const engineIds_1 = require("./engineIds");
 const cosyvoice_1 = require("./engines/cosyvoice");
 const moss_1 = require("./engines/moss");
+const fabricOptions_1 = require("./fabricOptions");
 const modelFiles_1 = require("./modelFiles");
 const optionValidation_1 = require("./optionValidation");
 const pocketConfig_1 = require("./pocketConfig");
 const { platform } = bareOs;
 const MIN_OUTPUT_SAMPLE_RATE = 8000;
 const MAX_OUTPUT_SAMPLE_RATE = 192000;
+const LAVASR_COREML_COMPUTE_UNITS = [
+    "CPU_ONLY",
+    "CPU_AND_GPU",
+    "CPU_AND_NE",
+    "ALL",
+];
+function validateLavaSRCoreML(options, ggufPath, stage) {
+    const modelPath = options?.coremlModelPath;
+    const computeUnits = options?.coremlComputeUnits;
+    if (modelPath === undefined && computeUnits === undefined)
+        return;
+    if (typeof modelPath !== "string" || modelPath.trim().length === 0) {
+        throw new Error(`${stage}.coremlModelPath must be a non-empty string`);
+    }
+    if (typeof computeUnits !== "string" ||
+        !LAVASR_COREML_COMPUTE_UNITS.includes(computeUnits)) {
+        throw new Error(`${stage}.coremlComputeUnits must be CPU_ONLY, CPU_AND_GPU, CPU_AND_NE or ALL`);
+    }
+    if (!ggufPath) {
+        throw new Error(`${stage} Core ML requires the corresponding LavaSR GGUF path`);
+    }
+}
 function resolveDefaultLazySessionLoading(lazySessionLoading) {
     if (lazySessionLoading != null)
         return lazySessionLoading;
@@ -111,13 +134,24 @@ function settingsFromOptions(options) {
         maxFrames: options.maxFrames,
         minNewTokens: options.minNewTokens,
         normalizeNumbers: options.normalizeNumbers,
+        coremlDecoder: options.coremlDecoder,
+        coremlComputeUnits: options.coremlComputeUnits,
+        coremlStrict: options.coremlStrict,
         ...(0, moss_1.mossVoiceSettings)(options),
     };
 }
 function resolveBackendPaths(files, options, config) {
+    const enhancerGgufPath = resolveEnhancerGgufPath(files, options.enhancer);
+    const denoiserGgufPath = resolveDenoiserGgufPath(files, options.denoiser);
+    validateLavaSRCoreML(options.enhancer, enhancerGgufPath, "enhancer");
+    validateLavaSRCoreML(options.denoiser, denoiserGgufPath, "denoiser");
     return {
-        enhancerGgufPath: resolveEnhancerGgufPath(files, options.enhancer),
-        denoiserGgufPath: resolveDenoiserGgufPath(files, options.denoiser),
+        enhancerGgufPath,
+        denoiserGgufPath,
+        enhancerCoremlModelPath: options.enhancer?.coremlModelPath,
+        enhancerCoremlComputeUnits: options.enhancer?.coremlComputeUnits,
+        denoiserCoremlModelPath: options.denoiser?.coremlModelPath,
+        denoiserCoremlComputeUnits: options.denoiser?.coremlComputeUnits,
         backendsDir: (0, modelFiles_1.firstNonEmpty)(options.backendsDir, config.backendsDir),
         openclCacheDir: (0, modelFiles_1.firstNonEmpty)(options.openclCacheDir, config.openclCacheDir),
         vulkanCacheDir: (0, modelFiles_1.firstNonEmpty)(options.vulkanCacheDir, config.vulkanCacheDir),
@@ -139,6 +173,7 @@ function resolveEngineSetup(options) {
     const config = { ...(options.config || {}) };
     const outputSampleRate = validateOutputSampleRate(config.outputSampleRate);
     const engineType = (0, engineDetection_1.detectEngineType)(options.engine, files);
+    (0, fabricOptions_1.validateBackendOption)(engineType, config.backend);
     const mossVoice = (0, moss_1.mossVoiceSettings)(options);
     const pocket = engineType === engineIds_1.ENGINE_POCKET
         ? resolvePocketSetup(files, options, config)
@@ -150,6 +185,7 @@ function resolveEngineSetup(options) {
         dialogue: mossVoice.dialogueReferences !== undefined,
     });
     const settings = settingsFromOptions(options);
+    Object.assign(settings, (0, fabricOptions_1.resolveFabricOptions)(engineType, options));
     const backend = resolveBackendPaths(files, options, config);
     const setup = {
         engineType,

package/lib/types.d.ts

@@ -1,22 +1,28 @@
 import type { TTSConditioningFields } from "./conditioning";
 import type { EngineType } from "./engineIds";
+import type { FabricOptions } from "./fabricOptions";
 import type { TTSGgmlRuntimeConfig } from "./engineSetup";
 import type { Audio8VoiceFields } from "./engines/audio8";
 import type { CosyvoiceInstruct, CosyvoiceJobFields } from "./engines/cosyvoice";
 import type { MossSoundEffectFields } from "./engines/mossSoundEffect";
 import type { MossSpeechFields } from "./engines/mossSpeech";
-import type { ParlerDescriptionFields } from "./engines/parler";
+import type { ParlerCoremlFields, ParlerDescriptionFields } from "./engines/parler";
 import type { TTSGgmlFiles } from "./modelFiles";
 import type { SentenceDelimiterPreset } from "./textStreamAccumulator";
-export type { Audio8VoiceFields, CosyvoiceInstruct, CosyvoiceJobFields, MossSoundEffectFields, MossSpeechFields, ParlerDescriptionFields, TTSConditioningFields, TTSGgmlFiles, TTSGgmlRuntimeConfig, };
+export type { Audio8VoiceFields, CosyvoiceInstruct, CosyvoiceJobFields, MossSoundEffectFields, MossSpeechFields, ParlerDescriptionFields, ParlerCoremlFields, TTSConditioningFields, TTSGgmlFiles, TTSGgmlRuntimeConfig, };
 export type { MossSpeechJobFields, MossSpeechMessage, MossSpeechPcm, } from "./engines/mossSpeech";
 export type { Audio8SamplingFields } from "./engines/audio8";
+export type LavaSRCoreMLComputeUnits = "CPU_ONLY" | "CPU_AND_GPU" | "CPU_AND_NE" | "ALL";
+export interface LavaSRCoreMLOptions {
+    coremlModelPath?: string;
+    coremlComputeUnits?: LavaSRCoreMLComputeUnits;
+}
 /**
  * LavaSR enhancer config. The discriminated `type` leaves room for future
  * enhancer kinds; v1 ships `lavasr`. Enhancement is enabled by providing a
  * GGUF path here or via `files.lavasrEnhancer`.
  */
-export interface LavaSREnhancerOptions {
+export interface LavaSREnhancerOptions extends LavaSRCoreMLOptions {
     type: "lavasr";
     /** Enhancer GGUF path (alternative to `files.lavasrEnhancer`). */
     enhancerPath?: string;
@@ -26,12 +32,12 @@ export interface LavaSREnhancerOptions {
  * is enabled by providing a GGUF path here or via `files.lavasrDenoiser`.
  * It runs before the enhancer and preserves the sample rate.
  */
-export interface LavaSRDenoiserOptions {
+export interface LavaSRDenoiserOptions extends LavaSRCoreMLOptions {
     type: "lavasr";
     /** Denoiser GGUF path (alternative to `files.lavasrDenoiser`). */
     denoiserPath?: string;
 }
-export interface TTSGgmlOptions extends ParlerDescriptionFields, Audio8VoiceFields, TTSConditioningFields {
+export interface TTSGgmlOptions extends FabricOptions, ParlerDescriptionFields, ParlerCoremlFields, Audio8VoiceFields, TTSConditioningFields {
     /** Pocket: generation/context controls; native sampling uses a portable RNG. */
     maxTokens?: number;
     noiseClamp?: number;
@@ -68,6 +74,7 @@ export interface TTSGgmlOptions extends ParlerDescriptionFields, Audio8VoiceFiel
      * front at this length, so the cap directly bounds memory. Pass 0 to use
      * the GGUF's full context; negative values are rejected.
      * Pocket: FlowLM context capacity; accepts integers from 1 to 8192.
+     * MOSS / TTSD: context capacity; omission retains the native value.
      */
     nCtx?: number;
     /**
@@ -274,12 +281,13 @@ export interface TTSGgmlOptions extends ParlerDescriptionFields, Audio8VoiceFiel
      * ~86 frames/s, Audio8 ~21.5.
      */
     maxFrames?: number;
-    /** Audio8: take the argmax instead of sampling. */
+    /** Audio8 / CosyVoice3: take the argmax instead of sampling. */
     greedy?: boolean;
     /**
-     * MOSS: target length in codec frames (12.5 per second), from 0 to 2015
-     * (about 161 s); 0 or unset keeps the length free. Set at construction or
-     * with `reload()`, not per call.
+     * MOSS: target length in codec frames (12.5 per second), up to
+     * maxNewTokens minus 33 native delay/EOS rows. The native token budget is
+     * 2048 when omitted. Zero keeps the length free. Set at construction or
+     * with reload(), not per call.
      */
     durationTokens?: number;
     /**
@@ -304,6 +312,7 @@ export interface InferenceState {
     destroyed: boolean;
 }
 export interface TTSOutputChunk {
+    speechTokenIds?: number[];
     chunkIndex?: number;
     isLast?: boolean;
     /** Signed 16-bit mono PCM audio payload. */
@@ -318,6 +327,7 @@ export interface TTSOutputChunk {
     sampleRate?: number;
 }
 export interface NativeOutputChunk {
+    speechTokenIds?: number[];
     outputArray: Int16Array;
     text?: string;
     isLast?: boolean;
@@ -330,15 +340,15 @@ export interface RuntimeStats {
     realTimeFactor: number;
     audioDurationMs: number;
     totalSamples: number;
-    /** Active compute device after load-time backend selection. 0 = CPU, 1 = GPU. */
+    /** Active compute device: 0 = CPU, 1 = GPU, 3 = NPU, 99 = other. */
     backendDevice?: number;
-    /** Stable backend code: 0=CPU, 1=Metal, 2=CUDA, 3=Vulkan, 4=OpenCL, 99=other GPU. */
+    /** Backend: 0=CPU, 1=Metal, 2=CUDA, 3=Vulkan, 4=OpenCL, 5=WebGPU, 99=other. */
     backendId?: number;
-    /** LavaSR enhancer compute device. -1 = not loaded, 0 = CPU, 1 = GPU. */
+    /** LavaSR enhancer device. -1 = off, 0 = CPU, 1 = GPU, 2 = Core ML-managed. */
     enhancerBackendDevice?: number;
     /** LavaSR enhancer backend code, using the same values as `backendId`. */
     enhancerBackendId?: number;
-    /** LavaSR denoiser compute device. -1 = not loaded, 0 = CPU, 1 = GPU. */
+    /** LavaSR denoiser device. -1 = off, 0 = CPU, 1 = GPU, 2 = Core ML-managed. */
     denoiserBackendDevice?: number;
     /** LavaSR denoiser backend code, using the same values as `backendId`. */
     denoiserBackendId?: number;
@@ -366,6 +376,17 @@ export interface RuntimeStats {
      * Streams report the last chunk that supplied this field, not a sum.
      */
     codecOnCoreml?: number;
+    /** Parler only: 1 while the decoder sidecar is attached; 0 after fallback retires it. */
+    decoderSidecarLoaded?: number;
+    /** Parler only: 1 while the DAC sidecar is attached; 0 after fallback retires it. */
+    dacSidecarLoaded?: number;
+    /** Parler only: 1 when this synthesis used the Core ML decoder; 0 for ggml or mixed fallback. */
+    decoderOnCoreml?: number;
+    /** Parler only: 1 when this synthesis used the Core ML DAC; 0 for ggml or mixed fallback.
+     * Sentence streams retain the latest availability flags and require all reported sentences to use Core ML for a use flag of 1.
+     * These flags do not identify the hardware Core ML scheduled work on.
+     */
+    dacOnCoreml?: number;
     /** Chatterbox only: T3 decode wall time of the last synthesis, in ms. */
     t3Ms?: number;
     /** Chatterbox only: S3Gen + HiFT wall time of the last synthesis, in ms. */