@qvac/tts-ggml 0.14.1 → 0.15.0

package/examples/lavasr-coreml.js

@@ -0,0 +1,76 @@
+'use strict'
+
+const proc = require('bare-process')
+const TTSGgml = require('../')
+const { createWav } = require('./wav-helper')
+
+async function main() {
+  const [
+    modelPath,
+    denoiserPath,
+    enhancerPath,
+    denoiserCoreml,
+    enhancerCoreml,
+    units,
+    text,
+    output
+  ] = proc.argv.slice(2)
+  if (
+    !modelPath ||
+    !denoiserPath ||
+    !enhancerPath ||
+    !denoiserCoreml ||
+    !enhancerCoreml ||
+    !units ||
+    !text ||
+    !output
+  ) {
+    throw new Error(
+      'Usage: bare examples/lavasr-coreml.js <supertonic.gguf> <denoiser.gguf> <enhancer.gguf> <denoiser.mlmodelc> <enhancer.mlmodelc> <compute-units> "<text>" <output.wav>'
+    )
+  }
+  const model = new TTSGgml({
+    engine: TTSGgml.ENGINE_SUPERTONIC,
+    files: { supertonicModel: modelPath },
+    denoiser: {
+      type: 'lavasr',
+      denoiserPath,
+      coremlModelPath: denoiserCoreml,
+      coremlComputeUnits: units
+    },
+    enhancer: {
+      type: 'lavasr',
+      enhancerPath,
+      coremlModelPath: enhancerCoreml,
+      coremlComputeUnits: units
+    },
+    opts: { stats: true }
+  })
+  try {
+    await model.load()
+    const response = await model.run({ input: text, type: 'text' })
+    const chunks = []
+    let sampleRate
+    const stats = await response
+      .onUpdate((chunk) => {
+        if (!chunk.outputArray) return
+        chunks.push(chunk.outputArray)
+        sampleRate = chunk.sampleRate
+      })
+      .await()
+    createWav(
+      chunks.flatMap((chunk) => Array.from(chunk)),
+      sampleRate,
+      output
+    )
+    console.log(output, stats)
+  } finally {
+    await model.unload()
+  }
+}
+
+main().catch((error) => {
+  console.error(error)
+  if (global.Bare) global.Bare.exit(1)
+  else process.exitCode = 1
+})

package/examples/moss-sfx-fit.js

@@ -16,7 +16,7 @@ async function main() {
     seconds: Number(seconds),
     useGPU: false
   })
-  console.log(fit.report || `${fit.status}: ${fit.reason}`)
+  console.log(JSON.stringify(fit, null, 2))
 }
 
 main().catch((err) => {

package/index.d.ts

@@ -84,6 +84,7 @@ declare class TTSGgml {
     private _runInternal;
     private _addonOutputCallback;
     private _dispatchJob;
+    warmUp(text: string): Promise<void>;
     cancel(): Promise<void>;
     reload(newConfig?: Record<string, unknown>): Promise<void>;
     static getModelKey(_params?: unknown): string;
@@ -105,6 +106,8 @@ declare namespace TTSGgml {
     type TTSGgmlRuntimeConfig = PublicTypes.TTSGgmlRuntimeConfig;
     type TTSGgmlOptions = PublicTypes.TTSGgmlOptions;
     type LavaSREnhancerOptions = PublicTypes.LavaSREnhancerOptions;
+    type LavaSRCoreMLComputeUnits = PublicTypes.LavaSRCoreMLComputeUnits;
+    type LavaSRCoreMLOptions = PublicTypes.LavaSRCoreMLOptions;
     type LavaSRDenoiserOptions = PublicTypes.LavaSRDenoiserOptions;
     type RuntimeStats = PublicTypes.RuntimeStats;
     type TTSOutputChunk = PublicTypes.TTSOutputChunk;
@@ -118,8 +121,11 @@ declare namespace TTSGgml {
     type VoiceControlsCatalog = PublicTypes.VoiceControlsCatalog;
     type TtsFitEngine = Fit.TtsFitEngine;
     type TtsFitRequest = Fit.TtsFitRequest;
+    type PocketFitRequest = Fit.PocketFitRequest;
     type TtsFitResult = Fit.TtsFitResult;
     type TtsFitStatus = Fit.TtsFitStatus;
+    type TtsFitDevice = Fit.TtsFitDevice;
+    type TtsFitStats = Fit.TtsFitStats;
     type SupertonicFitRequest = Fit.SupertonicFitRequest;
     type ParlerFitRequest = Fit.ParlerFitRequest;
     type ChatterboxFitRequest = Fit.ChatterboxFitRequest;

package/index.js

@@ -197,6 +197,7 @@ class TTSGgml {
         await this._pocket?.waitCancel();
         this._pocket?.checkReload();
         const normalized = options == null || typeof options !== "object" ? {} : options;
+        (0, parler_1.assertNoPerCallParlerCoreml)(normalized, "runStream");
         if (this._setup.engineType === engineIds_1.ENGINE_POCKET) {
             return this._startStream(() => this._runStreamOrchestrator(text, normalized, (0, jobFields_1.resolveJobFields)(this._setup, normalized, "runStream")));
         }
@@ -346,6 +347,18 @@ class TTSGgml {
         }
         return this._pocket ? this._pocket.runJob(addon, input) : addon.runJob(input);
     }
+    async warmUp(text) {
+        if (this._setup.engineType !== engineIds_1.ENGINE_SUPERTONIC) {
+            throw new Error("warmUp is supported by Supertonic only");
+        }
+        if (typeof text !== "string")
+            throw new Error("warmUp text must be a string");
+        await this._runExclusive(async () => {
+            await this._job.active?.await().catch(() => { });
+            const response = await this._runInternal({ input: text, type: "warmUp" });
+            await response.await();
+        });
+    }
     async cancel() {
         if (this._pocket)
             return this._pocket.cancel();
@@ -363,8 +376,17 @@ class TTSGgml {
         const existingAddon = this._optionalAddon();
         if (existingAddon)
             await existingAddon.destroyInstance();
-        this.addon = this._spawnAddon(parameters);
-        await this._requireAddon().activate();
+        const addon = this._spawnAddon(parameters);
+        this.addon = addon;
+        try {
+            await addon.activate();
+        }
+        catch (error) {
+            if (this.addon === addon)
+                this.addon = null;
+            await addon.destroyInstance();
+            throw error;
+        }
     }
     static getModelKey(_params) {
         void _params;

package/lib/engineParams.js

@@ -10,7 +10,21 @@ const mossSoundEffect_1 = require("./engines/mossSoundEffect");
 const mossSpeech_1 = require("./engines/mossSpeech");
 const parler_1 = require("./engines/parler");
 const supertonic_1 = require("./engines/supertonic");
+const fabricOptions_1 = require("./fabricOptions");
 function buildNativeParams(setup) {
+    const parameters = buildEngineParams(setup);
+    (0, fabricOptions_1.assignFabricOptions)(setup.settings, parameters);
+    if (setup.config.backend !== undefined)
+        parameters.backend = setup.config.backend;
+    if (setup.engineType === engineIds_1.ENGINE_MOSS && setup.settings.nCtx !== undefined) {
+        parameters.nCtx = setup.settings.nCtx;
+    }
+    if (setup.engineType === engineIds_1.ENGINE_COSYVOICE3 && setup.settings.greedy !== undefined) {
+        parameters.greedy = setup.settings.greedy;
+    }
+    return parameters;
+}
+function buildEngineParams(setup) {
     if (setup.pocket)
         return { ...setup.pocket.params };
     switch (setup.engineType) {

package/lib/engineSetup.d.ts

@@ -4,10 +4,13 @@
  * or applies a reload reads (and, for reloadable fields, writes) one of these
  * groups instead of the wrapper instance itself.
  */
+import type { ParlerCoremlFields } from "./engines/parler";
 import type { EngineType } from "./engineIds";
+import type { FabricOptions } from "./fabricOptions";
 import type { NormalizedFiles } from "./modelFiles";
 import type { TTSConfigurationParams } from "../tts";
 export interface TTSGgmlRuntimeConfig {
+    backend?: string;
     /**
      * Language code; default "en". Chatterbox MTL accepts
      * es/fr/de/pt/it/zh/ja/ko/... CosyVoice3: reserved / not yet effective — the
@@ -73,7 +76,7 @@ export interface ModelPaths {
  * CosyVoice3 instruct rendered to its string. Reload rewrites the reloadable
  * subset in place and rolls the whole object back when a reload is rejected.
  */
-export interface SynthesisSettings {
+export interface SynthesisSettings extends FabricOptions, ParlerCoremlFields {
     referenceAudio?: string;
     referenceText?: string;
     greedy?: boolean;
@@ -132,6 +135,10 @@ export interface SynthesisSettings {
 export interface BackendPaths {
     enhancerGgufPath?: string;
     denoiserGgufPath?: string;
+    enhancerCoremlModelPath?: string;
+    enhancerCoremlComputeUnits?: string;
+    denoiserCoremlModelPath?: string;
+    denoiserCoremlComputeUnits?: string;
     backendsDir?: string;
     openclCacheDir?: string;
     vulkanCacheDir?: string;

package/lib/engines/audio8.js

@@ -121,7 +121,7 @@ function assertAudio8Options(setup) {
     }
     const audio8Only = (0, options_1.setOptionNames)({
         referenceText: setup.settings.referenceText,
-        greedy: setup.settings.greedy,
+        greedy: setup.engineType === engineIds_1.ENGINE_COSYVOICE3 ? undefined : setup.settings.greedy,
     });
     if (audio8Only.length > 0) {
         throw new Error(`tts-ggml: ${audio8Only.join(", ")} are audio8-only options ` +

package/lib/engines/moss.d.ts

@@ -12,7 +12,7 @@ export declare const MOSS_MAX_CHANNELS = 32;
 export declare const MOSS_TERMINATION_ROWS = 2;
 export declare const MOSS_MAX_DURATION_TOKENS: number;
 export declare const MOSS_INSTANCE_VOICE_KEYS: readonly ["referenceAudio", "dialogueReferences"];
-export declare function assertMossDurationTokens(value: number | null | undefined, where: string): void;
+export declare function assertMossDurationTokens(value: number | null | undefined, where: string, maxNewTokens?: number): void;
 export declare function resolveMossModelPaths(files: NormalizedFiles, dialogue: boolean): Pick<ModelPaths, "mossBackbonePath" | "mossCodecDecoderPath" | "mossCodecEncoderPath">;
 /** The MOSS voice and length options, read before model paths are resolved. */
 export declare function mossVoiceSettings(options: {

package/lib/engines/moss.js

@@ -24,14 +24,15 @@ exports.MOSS_MAX_CHANNELS = 32;
 exports.MOSS_TERMINATION_ROWS = 2;
 exports.MOSS_MAX_DURATION_TOKENS = exports.MOSS_MAX_NEW_TOKENS - (exports.MOSS_MAX_CHANNELS - 1) - exports.MOSS_TERMINATION_ROWS;
 exports.MOSS_INSTANCE_VOICE_KEYS = ["referenceAudio", "dialogueReferences"];
-function isValidDurationTokens(value) {
-    return Number.isInteger(value) && value >= 0 && value <= exports.MOSS_MAX_DURATION_TOKENS;
+function isValidDurationTokens(value, maximum) {
+    return Number.isInteger(value) && value >= 0 && (value === 0 || value <= maximum);
 }
-function assertMossDurationTokens(value, where) {
-    if (value == null || isValidDurationTokens(value))
+function assertMossDurationTokens(value, where, maxNewTokens = exports.MOSS_MAX_NEW_TOKENS) {
+    const maximum = maxNewTokens - (exports.MOSS_MAX_CHANNELS - 1) - exports.MOSS_TERMINATION_ROWS;
+    if (value == null || isValidDurationTokens(value, maximum))
         return;
     throw new Error(`tts-ggml: ${where}: durationTokens must be an integer from 0 to ` +
-        `${exports.MOSS_MAX_DURATION_TOKENS} (0 = free length)`);
+        `${Math.max(0, maximum)} (0 = free length)`);
 }
 function copyDialogueReferences(references) {
     if (references == null)
@@ -86,7 +87,7 @@ function assertMossOptions(setup) {
     }
     assertMossOutputRate(setup);
     assertMossVoiceConsistent(setup);
-    assertMossDurationTokens(setup.settings.durationTokens, "constructor");
+    assertMossDurationTokens(setup.settings.durationTokens, "constructor", setup.settings.maxNewTokens);
     assertMossDialogueReferences(setup);
 }
 function assertNoMossOnlyOptions(setup) {
@@ -172,6 +173,6 @@ function applyMossReload(setup, newConfig) {
         .durationTokens;
     if (durationTokens === undefined)
         return;
-    assertMossDurationTokens(durationTokens, "reload");
+    assertMossDurationTokens(durationTokens, "reload", setup.settings.maxNewTokens);
     setup.settings.durationTokens = durationTokens ?? undefined;
 }

package/lib/engines/parler.d.ts

@@ -13,6 +13,19 @@ export declare const PARLER_ONLY_KEYS: readonly ["description", "voiceDescriptio
 export type ParlerFieldKey = (typeof PARLER_FIELD_KEYS)[number];
 export type ParlerDescFields = Partial<Record<ParlerFieldKey, string>>;
 export type ParlerJobSource = ParlerDescriptionFields & TTSConditioningFields;
+export declare const PARLER_COREML_KEYS: readonly ["coremlDecoder", "coremlComputeUnits", "coremlStrict"];
+export declare const PARLER_COREML_COMPUTE_UNITS: readonly ["all", "cpu_and_ane", "cpu_and_gpu", "cpu_only"];
+/** Parler-only load/reload controls; never accepted per synthesis job. */
+export interface ParlerCoremlFields {
+    /** Enable the optional decoder sidecar. Omit to keep the engine default. */
+    coremlDecoder?: boolean;
+    /** Omit to inherit the engine's environment/default compute-unit policy. */
+    coremlComputeUnits?: (typeof PARLER_COREML_COMPUTE_UNITS)[number];
+    /** Omit to inherit strict mode; false explicitly permits fallback. */
+    coremlStrict?: boolean;
+}
+export declare function assertParlerCoremlOptions(engine: string, source: object | null | undefined, where: string): void;
+export declare function assertNoPerCallParlerCoreml(source: object | null | undefined, where: string): void;
 /**
  * Parler voice-description inputs. Either a free-text `description` (alias
  * `voiceDescription`) or the template fields, rendered natively through

package/lib/engines/parler.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PARLER_ONLY_KEYS = exports.PARLER_FIELD_KEYS = exports.PARLER_ONLY_TEMPLATE_KEYS = exports.PARLER_TEMPLATE_KEYS = exports.PARLER_DESCRIPTION_KEYS = exports.PARLER_QUANT_ORDER = exports.PARLER_VARIANT_ORDER = exports.PARLER_RE = void 0;
+exports.PARLER_COREML_COMPUTE_UNITS = exports.PARLER_COREML_KEYS = exports.PARLER_ONLY_KEYS = exports.PARLER_FIELD_KEYS = exports.PARLER_ONLY_TEMPLATE_KEYS = exports.PARLER_TEMPLATE_KEYS = exports.PARLER_DESCRIPTION_KEYS = exports.PARLER_QUANT_ORDER = exports.PARLER_VARIANT_ORDER = exports.PARLER_RE = void 0;
+exports.assertParlerCoremlOptions = assertParlerCoremlOptions;
+exports.assertNoPerCallParlerCoreml = assertNoPerCallParlerCoreml;
 exports.findParlerInDir = findParlerInDir;
 exports.pickParlerDescFields = pickParlerDescFields;
 exports.assertParlerDescFieldsConsistent = assertParlerDescFieldsConsistent;
@@ -54,6 +56,49 @@ exports.PARLER_ONLY_KEYS = [
     ...exports.PARLER_DESCRIPTION_KEYS,
     ...exports.PARLER_ONLY_TEMPLATE_KEYS,
 ];
+exports.PARLER_COREML_KEYS = [
+    "coremlDecoder",
+    "coremlComputeUnits",
+    "coremlStrict",
+];
+exports.PARLER_COREML_COMPUTE_UNITS = [
+    "all",
+    "cpu_and_ane",
+    "cpu_and_gpu",
+    "cpu_only",
+];
+function assertParlerCoremlOptions(engine, source, where) {
+    if (!source)
+        return;
+    const values = source;
+    const keys = exports.PARLER_COREML_KEYS.filter((key) => values[key] !== undefined);
+    if (keys.length === 0)
+        return;
+    if (engine !== engineIds_1.ENGINE_PARLER) {
+        throw new Error(`tts-ggml: ${where}: ${keys.join(", ")} are parler-only options ` +
+            `(engine is ${engine})`);
+    }
+    for (const key of ["coremlDecoder", "coremlStrict"]) {
+        if (values[key] !== undefined && typeof values[key] !== "boolean") {
+            throw new Error(`tts-ggml: ${where}: ${key} must be a boolean`);
+        }
+    }
+    if (values.coremlComputeUnits !== undefined &&
+        !exports.PARLER_COREML_COMPUTE_UNITS.some((value) => value === values.coremlComputeUnits)) {
+        throw new Error(`tts-ggml: ${where}: coremlComputeUnits must be one of ` +
+            exports.PARLER_COREML_COMPUTE_UNITS.join(", "));
+    }
+}
+function assertNoPerCallParlerCoreml(source, where) {
+    if (!source)
+        return;
+    const values = source;
+    const keys = exports.PARLER_COREML_KEYS.filter((key) => values[key] !== undefined);
+    if (keys.length > 0) {
+        throw new Error(`tts-ggml: ${where}: ${keys.join(", ")} must be set in the ` +
+            "constructor or reload(), not per call");
+    }
+}
 /**
  * Find a Parler GGUF in `modelDir`, ranked by variant (mini before large
  * before indic) and, within a variant, by quant tier (q8_0 > q6_k > f16 > f32;
@@ -132,6 +177,7 @@ function resolveParlerModelPaths(files) {
  * rejected by name.
  */
 function assertParlerOptions(setup) {
+    assertParlerCoremlOptions(setup.engineType, setup.settings, "constructor");
     if (setup.engineType === engineIds_1.ENGINE_PARLER) {
         assertParlerDescFieldsConsistent(pickParlerDescFields({
             description: setup.settings.description,
@@ -188,6 +234,7 @@ function resolveParlerJobFields(setup, source, where) {
     return fields;
 }
 function buildParlerParams(setup) {
+    assertParlerCoremlOptions(setup.engineType, setup.settings, "configuration");
     // Re-checked here (not only in the constructor) so reload({...}) cannot
     // smuggle in a description/template conflict.
     if (setup.settings.description != null) {
@@ -246,6 +293,10 @@ function buildParlerParams(setup) {
     if (setup.settings.normalizeNumbers != null) {
         parameters.normalizeNumbers = !!setup.settings.normalizeNumbers;
     }
+    for (const key of exports.PARLER_COREML_KEYS) {
+        if (setup.settings[key] !== undefined)
+            parameters[key] = setup.settings[key];
+    }
     (0, nativeParams_1.assignBackendParams)(setup, parameters);
     return parameters;
 }
@@ -263,6 +314,7 @@ const PARLER_RELOADABLE_KEYS = [
     "maxFrames",
     "minNewTokens",
     "normalizeNumbers",
+    ...exports.PARLER_COREML_KEYS,
     "seed",
 ];
 /**
@@ -272,6 +324,7 @@ const PARLER_RELOADABLE_KEYS = [
  * reload still throws (and the caller rolls the settings back).
  */
 function applyParlerReload(setup, newConfig) {
+    assertParlerCoremlOptions(setup.engineType, newConfig, "reload");
     if (setup.engineType !== engineIds_1.ENGINE_PARLER)
         return;
     const config = newConfig;

package/lib/fabricOptions.d.ts

@@ -0,0 +1,29 @@
+import type { TTSConfigurationParams } from "../tts";
+import type { EngineType } from "./engineIds";
+export interface FabricOptions {
+    maxNewTokens?: number;
+    textTemperature?: number;
+    textTopP?: number;
+    textTopK?: number;
+    audioTemperature?: number;
+    audioTopP?: number;
+    audioTopK?: number;
+    audioRepetitionPenalty?: number;
+    coremlDecoder?: boolean;
+    coremlComputeUnits?: "all" | "cpu_and_ane" | "cpu_and_gpu" | "cpu_only";
+    coremlStrict?: boolean;
+    precision?: "auto" | "f32" | "f16" | "q8_0";
+    f16Attn?: number;
+    f16Weights?: number;
+    f16WeightsDenyList?: string[];
+    kvAttnType?: number;
+    vulkanEnvOverrides?: Record<string, string>;
+    voiceStyleTtl?: number[] | Float32Array;
+    voiceStyleDp?: number[] | Float32Array;
+    forceSpeechTokens?: number[];
+}
+export declare function validateBackendOption(engine: EngineType, backend: unknown): void;
+export declare function resolveFabricOptions(engine: EngineType, options: FabricOptions & {
+    nCtx?: number;
+}): FabricOptions;
+export declare function assignFabricOptions(settings: FabricOptions, parameters: TTSConfigurationParams): void;

package/lib/fabricOptions.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBackendOption = validateBackendOption;
+exports.resolveFabricOptions = resolveFabricOptions;
+exports.assignFabricOptions = assignFabricOptions;
+const ENGINE_OPTION_KEYS = {
+    moss: [
+        "maxNewTokens", "textTemperature", "textTopP", "textTopK",
+        "audioTemperature", "audioTopP", "audioTopK", "audioRepetitionPenalty",
+    ],
+    parler: ["coremlDecoder", "coremlComputeUnits", "coremlStrict"],
+    supertonic: [
+        "precision", "f16Attn", "f16Weights", "f16WeightsDenyList", "kvAttnType",
+        "vulkanEnvOverrides", "voiceStyleTtl", "voiceStyleDp",
+    ],
+    cosyvoice3: ["forceSpeechTokens"],
+};
+const INT32_MIN = -2147483648;
+const INT32_MAX = 2147483647;
+const INTEGER_KEYS = new Set(["maxNewTokens", "textTopK", "audioTopK", "f16Attn", "f16Weights", "kvAttnType"]);
+const BOOLEAN_KEYS = new Set(["coremlDecoder", "coremlStrict"]);
+const WEBGPU_ENGINES = ["supertonic", "parler", "cosyvoice3", "audio8"];
+function validInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= INT32_MIN && value <= INT32_MAX;
+}
+function validateOptionValue(key, value) {
+    if (BOOLEAN_KEYS.has(key)) {
+        if (typeof value !== "boolean")
+            throw new Error(`${key} must be a boolean`);
+        return;
+    }
+    if (key === "coremlComputeUnits") {
+        if (!["all", "cpu_and_ane", "cpu_and_gpu", "cpu_only"].includes(value)) {
+            throw new Error("coremlComputeUnits must be all, cpu_and_ane, cpu_and_gpu or cpu_only");
+        }
+        return;
+    }
+    if (key === "precision") {
+        if (!["auto", "f32", "f16", "q8_0"].includes(value))
+            throw new Error("Invalid precision");
+        return;
+    }
+    if (key === "vulkanEnvOverrides") {
+        if (!value || typeof value !== "object" || Array.isArray(value) ||
+            !Object.values(value).every((entry) => typeof entry === "string")) {
+            throw new Error("vulkanEnvOverrides must be an object with string values");
+        }
+        return;
+    }
+    if (key === "f16WeightsDenyList") {
+        if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) {
+            throw new Error("f16WeightsDenyList must be an array of strings");
+        }
+        return;
+    }
+    if (key === "voiceStyleTtl" || key === "voiceStyleDp" || key === "forceSpeechTokens") {
+        validateVector(key, value);
+        return;
+    }
+    if (INTEGER_KEYS.has(key)) {
+        if (!validInteger(value))
+            throw new Error(`${key} must be a 32-bit integer`);
+    }
+    else if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`${key} must be a finite number`);
+    }
+}
+function validateVector(key, value) {
+    if (!Array.isArray(value) && !(value instanceof Float32Array))
+        throw new Error(`${key} must be an array`);
+    const entries = Array.from(value);
+    const valid = key === "forceSpeechTokens"
+        ? entries.every(validInteger)
+        : entries.every((entry) => typeof entry === "number" && Number.isFinite(entry));
+    if (!valid)
+        throw new Error(`${key} contains an invalid number`);
+}
+function validateBackendOption(engine, backend) {
+    if (backend === undefined)
+        return;
+    if (typeof backend !== "string")
+        throw new Error("backend must be a string");
+    if (/^webgpu/i.test(backend) && !WEBGPU_ENGINES.includes(engine)) {
+        throw new Error(`tts-ggml: WebGPU has no established support for ${engine}`);
+    }
+}
+function copyValue(value) {
+    if (Array.isArray(value) || value instanceof Float32Array)
+        return Array.from(value);
+    if (value !== null && typeof value === "object")
+        return { ...value };
+    return value;
+}
+function resolveFabricOptions(engine, options) {
+    if (engine === "moss")
+        validateMossCounts(options);
+    const result = {};
+    copyEngineOptions(engine, options, result);
+    if (engine === "supertonic" && ((options.voiceStyleTtl === undefined) !== (options.voiceStyleDp === undefined))) {
+        throw new Error("voiceStyleTtl and voiceStyleDp must be supplied together");
+    }
+    return result;
+}
+function validateMossCounts(options) {
+    if (options.nCtx !== undefined && (!validInteger(options.nCtx) || options.nCtx < 1)) {
+        throw new Error("nCtx must be a positive 32-bit integer for MOSS");
+    }
+    if (options.maxNewTokens !== undefined && (!validInteger(options.maxNewTokens) || options.maxNewTokens < 1)) {
+        throw new Error("maxNewTokens must be a positive 32-bit integer");
+    }
+}
+function copyEngineOptions(engine, options, result) {
+    for (const [owner, keys] of Object.entries(ENGINE_OPTION_KEYS)) {
+        for (const key of keys) {
+            const value = options[key];
+            if (value === undefined)
+                continue;
+            if (owner !== engine)
+                throw new Error(`tts-ggml: ${key} is ${owner}-only`);
+            validateOptionValue(key, value);
+            result[key] = copyValue(value);
+        }
+    }
+}
+function assignFabricOptions(settings, parameters) {
+    for (const keys of Object.values(ENGINE_OPTION_KEYS)) {
+        for (const key of keys) {
+            const value = settings[key];
+            if (value !== undefined)
+                parameters[key] = copyValue(value);
+        }
+    }
+}