speechflow 2.0.0 → 2.0.2

package/speechflow-cli/dst/speechflow-node-t2a-supertonic.js

@@ -42,398 +42,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 /*  standard dependencies  */
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
 const node_stream_1 = __importDefault(require("node:stream"));
 /*  external dependencies  */
-const mkdirp_1 = require("mkdirp");
-const HF = __importStar(require("@huggingface/hub"));
+const Transformers = __importStar(require("@huggingface/transformers"));
 const speex_resampler_1 = __importDefault(require("speex-resampler"));
 const luxon_1 = require("luxon");
-/*  @ts-expect-error no type available  */
-const ORT = __importStar(require("onnxruntime-node"));
 /*  internal dependencies  */
 const speechflow_node_1 = __importDefault(require("./speechflow-node"));
 const util = __importStar(require("./speechflow-util"));
-/*  convert lengths to binary mask  */
-function lengthToMask(lengths, maxLen = null) {
-    /*  handle empty input  */
-    if (lengths.length === 0)
-        return [];
-    /*  determine maximum length  */
-    maxLen = maxLen ?? Math.max(...lengths);
-    /*  build mask array  */
-    const mask = [];
-    for (let i = 0; i < lengths.length; i++) {
-        const row = [];
-        for (let j = 0; j < maxLen; j++)
-            row.push(j < lengths[i] ? 1.0 : 0.0);
-        mask.push([row]);
-    }
-    return mask;
-}
-/*  get latent mask from wav lengths  */
-function getLatentMask(wavLengths, baseChunkSize, chunkCompressFactor) {
-    /*  calculate latent size and lengths  */
-    const latentSize = baseChunkSize * chunkCompressFactor;
-    const latentLengths = wavLengths.map((len) => Math.floor((len + latentSize - 1) / latentSize));
-    /*  generate mask from latent lengths  */
-    return lengthToMask(latentLengths);
-}
-/*  convert array to ONNX tensor  */
-function arrayToTensor(array, dims) {
-    /*  flatten array and create float32 tensor  */
-    const flat = array.flat(Infinity);
-    return new ORT.Tensor("float32", Float32Array.from(flat), dims);
-}
-/*  convert int array to ONNX tensor  */
-function intArrayToTensor(array, dims) {
-    /*  flatten array and create int64 tensor  */
-    const flat = array.flat(Infinity);
-    return new ORT.Tensor("int64", BigInt64Array.from(flat.map(BigInt)), dims);
-}
-/*  chunk text into manageable segments  */
-function chunkText(text, maxLen = 300) {
-    /*  validate input type  */
-    if (typeof text !== "string")
-        throw new Error(`chunkText expects a string, got ${typeof text}`);
-    /*  split by paragraph (two or more newlines)  */
-    const paragraphs = text.trim().split(/\n\s*\n+/).filter((p) => p.trim());
-    /*  process each paragraph into chunks  */
-    const chunks = [];
-    for (let paragraph of paragraphs) {
-        paragraph = paragraph.trim();
-        if (!paragraph)
-            continue;
-        /*  split by sentence boundaries (period, question mark, exclamation mark followed by space)
-            but exclude common abbreviations like Mr., Mrs., Dr., etc. and single capital letters like F.  */
-        const sentences = paragraph.split(/(?<!Mr\.|Mrs\.|Ms\.|Dr\.|Prof\.|Sr\.|Jr\.|Ph\.D\.|etc\.|e\.g\.|i\.e\.|vs\.|Inc\.|Ltd\.|Co\.|Corp\.|St\.|Ave\.|Blvd\.)(?<!\b[A-Z]\.)(?<=[.!?])\s+/);
-        /*  accumulate sentences into chunks respecting max length  */
-        let currentChunk = "";
-        for (const sentence of sentences) {
-            if (currentChunk.length + sentence.length + 1 <= maxLen)
-                currentChunk += (currentChunk ? " " : "") + sentence;
-            else {
-                if (currentChunk)
-                    chunks.push(currentChunk.trim());
-                currentChunk = sentence;
-            }
-        }
-        /*  push remaining chunk  */
-        if (currentChunk)
-            chunks.push(currentChunk.trim());
-    }
-    return chunks;
-}
-/*  unicode text processor class  */
-class SupertonicTextProcessor {
-    indexer;
-    constructor(unicodeIndexerJsonPath) {
-        /*  load and parse unicode indexer JSON  */
-        try {
-            this.indexer = JSON.parse(node_fs_1.default.readFileSync(unicodeIndexerJsonPath, "utf8"));
-        }
-        catch (err) {
-            throw new Error(`failed to parse unicode indexer JSON "${unicodeIndexerJsonPath}"`, { cause: err });
-        }
-    }
-    preprocessText(text) {
-        /*  normalize text  */
-        text = text.normalize("NFKD");
-        /*  remove emojis (wide Unicode range)  */
-        const emojiPattern = /[\u{1F600}-\u{1F64F}\u{1F300}-\u{1F5FF}\u{1F680}-\u{1F6FF}\u{1F700}-\u{1F77F}\u{1F780}-\u{1F7FF}\u{1F800}-\u{1F8FF}\u{1F900}-\u{1F9FF}\u{1FA00}-\u{1FA6F}\u{1FA70}-\u{1FAFF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{1F1E6}-\u{1F1FF}]+/gu;
-        text = text.replace(emojiPattern, "");
-        /*  replace various dashes and symbols  */
-        const replacements = {
-            "–": "-",
-            "‑": "-",
-            "—": "-",
-            "¯": " ",
-            "_": " ",
-            "\u201C": "\"",
-            "\u201D": "\"",
-            "\u2018": "'",
-            "\u2019": "'",
-            "´": "'",
-            "`": "'",
-            "[": " ",
-            "]": " ",
-            "|": " ",
-            "/": " ",
-            "#": " ",
-            "→": " ",
-            "←": " "
-        };
-        for (const [k, v] of Object.entries(replacements))
-            text = text.replaceAll(k, v);
-        /*  remove combining diacritics  */
-        text = text.replace(/[\u0302\u0303\u0304\u0305\u0306\u0307\u0308\u030A\u030B\u030C\u0327\u0328\u0329\u032A\u032B\u032C\u032D\u032E\u032F]/g, "");
-        /*  remove special symbols  */
-        text = text.replace(/[♥☆♡©\\]/g, "");
-        /*  replace known expressions  */
-        const exprReplacements = {
-            "@": " at ",
-            "e.g.,": "for example, ",
-            "i.e.,": "that is, "
-        };
-        for (const [k, v] of Object.entries(exprReplacements))
-            text = text.replaceAll(k, v);
-        /*  fix spacing around punctuation  */
-        text = text.replace(/ ,/g, ",");
-        text = text.replace(/ \./g, ".");
-        text = text.replace(/ !/g, "!");
-        text = text.replace(/ \?/g, "?");
-        text = text.replace(/ ;/g, ";");
-        text = text.replace(/ :/g, ":");
-        text = text.replace(/ '/g, "'");
-        /*  remove duplicate quotes  */
-        text = text.replace(/""+/g, "\"");
-        text = text.replace(/''+/g, "'");
-        text = text.replace(/``+/g, "`");
-        /*  remove extra spaces  */
-        text = text.replace(/\s+/g, " ").trim();
-        /*  if text doesn't end with punctuation, add a period  */
-        if (!/[.!?;:,'"')\]}…。」』】〉》›»]$/.test(text))
-            text += ".";
-        return text;
-    }
-    textToUnicodeValues(text) {
-        /*  convert text characters to unicode code points  */
-        return Array.from(text).map((char) => char.charCodeAt(0));
-    }
-    call(textList) {
-        /*  handle empty input  */
-        if (textList.length === 0)
-            return { textIds: [], textMask: [] };
-        /*  preprocess all texts  */
-        const processedTexts = textList.map((t) => this.preprocessText(t));
-        const textIdsLengths = processedTexts.map((t) => t.length);
-        const maxLen = Math.max(...textIdsLengths);
-        /*  convert texts to indexed token arrays  */
-        const textIds = [];
-        for (let i = 0; i < processedTexts.length; i++) {
-            const row = Array.from({ length: maxLen }).fill(0);
-            const unicodeVals = this.textToUnicodeValues(processedTexts[i]);
-            for (let j = 0; j < unicodeVals.length; j++)
-                row[j] = this.indexer[unicodeVals[j]] ?? 0;
-            textIds.push(row);
-        }
-        /*  generate text mask from lengths  */
-        const textMask = lengthToMask(textIdsLengths);
-        return { textIds, textMask };
-    }
-}
-/*  Supertonic TTS engine class  */
-class SupertonicTTS {
-    sampleRate;
-    cfgs;
-    textProcessor;
-    dpOrt;
-    textEncOrt;
-    vectorEstOrt;
-    vocoderOrt;
-    baseChunkSize;
-    chunkCompressFactor;
-    latentDim;
-    constructor(cfgs, textProcessor, dpOrt, textEncOrt, vectorEstOrt, vocoderOrt) {
-        /*  store configuration and dependencies  */
-        this.cfgs = cfgs;
-        this.textProcessor = textProcessor;
-        this.dpOrt = dpOrt;
-        this.textEncOrt = textEncOrt;
-        this.vectorEstOrt = vectorEstOrt;
-        this.vocoderOrt = vocoderOrt;
-        /*  extract configuration values  */
-        this.sampleRate = cfgs.ae.sample_rate;
-        this.baseChunkSize = cfgs.ae.base_chunk_size;
-        this.chunkCompressFactor = cfgs.ttl.chunk_compress_factor;
-        this.latentDim = cfgs.ttl.latent_dim;
-    }
-    sampleNoisyLatent(duration) {
-        /*  calculate dimensions for latent space  */
-        const wavLenMax = Math.max(...duration) * this.sampleRate;
-        const wavLengths = duration.map((d) => Math.floor(d * this.sampleRate));
-        const chunkSize = this.baseChunkSize * this.chunkCompressFactor;
-        const latentLen = Math.floor((wavLenMax + chunkSize - 1) / chunkSize);
-        const latentDimExpanded = this.latentDim * this.chunkCompressFactor;
-        /*  generate random noise (pre-allocate arrays for performance)  */
-        const noisyLatent = Array.from({ length: duration.length });
-        for (let b = 0; b < duration.length; b++) {
-            const batch = Array.from({ length: latentDimExpanded });
-            for (let d = 0; d < latentDimExpanded; d++) {
-                const row = Array.from({ length: latentLen });
-                for (let t = 0; t < latentLen; t++) {
-                    /*  Box-Muller transform for normal distribution  */
-                    const eps = 1e-10;
-                    const u1 = Math.max(eps, Math.random());
-                    const u2 = Math.random();
-                    row[t] = Math.sqrt(-2.0 * Math.log(u1)) * Math.cos(2.0 * Math.PI * u2);
-                }
-                batch[d] = row;
-            }
-            noisyLatent[b] = batch;
-        }
-        /*  apply mask  */
-        const latentMask = getLatentMask(wavLengths, this.baseChunkSize, this.chunkCompressFactor);
-        for (let b = 0; b < noisyLatent.length; b++) {
-            for (let d = 0; d < noisyLatent[b].length; d++) {
-                for (let t = 0; t < noisyLatent[b][d].length; t++)
-                    noisyLatent[b][d][t] *= latentMask[b][0][t];
-            }
-        }
-        return { noisyLatent, latentMask };
-    }
-    async infer(textList, style, totalStep, speed) {
-        /*  validate batch size matches style vectors  */
-        if (textList.length !== style.ttl.dims[0])
-            throw new Error("Number of texts must match number of style vectors");
-        /*  process text into token IDs and masks  */
-        const batchSize = textList.length;
-        const { textIds, textMask } = this.textProcessor.call(textList);
-        const textIdsShape = [batchSize, textIds[0].length];
-        const textMaskShape = [batchSize, 1, textMask[0][0].length];
-        const textMaskTensor = arrayToTensor(textMask, textMaskShape);
-        /*  run duration predictor model  */
-        const dpResult = await this.dpOrt.run({
-            text_ids: intArrayToTensor(textIds, textIdsShape),
-            style_dp: style.dp,
-            text_mask: textMaskTensor
-        });
-        const predictedDurations = Array.from(dpResult.duration.data);
-        /*  apply speed factor to duration  */
-        for (let i = 0; i < predictedDurations.length; i++)
-            predictedDurations[i] /= speed;
-        /*  run text encoder model  */
-        const textEncResult = await this.textEncOrt.run({
-            text_ids: intArrayToTensor(textIds, textIdsShape),
-            style_ttl: style.ttl,
-            text_mask: textMaskTensor
-        });
-        const textEmbTensor = textEncResult.text_emb;
-        /*  sample initial noisy latent vectors  */
-        const { noisyLatent, latentMask } = this.sampleNoisyLatent(predictedDurations);
-        const latentShape = [batchSize, noisyLatent[0].length, noisyLatent[0][0].length];
-        const latentMaskShape = [batchSize, 1, latentMask[0][0].length];
-        const latentMaskTensor = arrayToTensor(latentMask, latentMaskShape);
-        /*  prepare step tensors  */
-        const totalStepArray = Array.from({ length: batchSize }).fill(totalStep);
-        const scalarShape = [batchSize];
-        const totalStepTensor = arrayToTensor(totalStepArray, scalarShape);
-        /*  iteratively denoise latent vectors  */
-        for (let step = 0; step < totalStep; step++) {
-            const currentStepArray = Array.from({ length: batchSize }).fill(step);
-            /*  run vector estimator model  */
-            const vectorEstResult = await this.vectorEstOrt.run({
-                noisy_latent: arrayToTensor(noisyLatent, latentShape),
-                text_emb: textEmbTensor,
-                style_ttl: style.ttl,
-                text_mask: textMaskTensor,
-                latent_mask: latentMaskTensor,
-                total_step: totalStepTensor,
-                current_step: arrayToTensor(currentStepArray, scalarShape)
-            });
-            const denoisedLatent = Array.from(vectorEstResult.denoised_latent.data);
-            /*  update latent with the denoised output  */
-            let idx = 0;
-            for (let b = 0; b < noisyLatent.length; b++)
-                for (let d = 0; d < noisyLatent[b].length; d++)
-                    for (let t = 0; t < noisyLatent[b][d].length; t++)
-                        noisyLatent[b][d][t] = denoisedLatent[idx++];
-        }
-        /*  run vocoder to generate audio waveform  */
-        const vocoderResult = await this.vocoderOrt.run({
-            latent: arrayToTensor(noisyLatent, latentShape)
-        });
-        const wav = Array.from(vocoderResult.wav_tts.data);
-        return { wav, duration: predictedDurations };
-    }
-    async synthesize(text, style, totalStep, speed, silenceDuration = 0.3) {
-        /*  validate single speaker mode  */
-        if (style.ttl.dims[0] !== 1)
-            throw new Error("Single speaker text to speech only supports single style");
-        /*  chunk text into segments  */
-        const textList = chunkText(text);
-        if (textList.length === 0)
-            return { wav: [], duration: 0 };
-        /*  synthesize each chunk and concatenate with silence  */
-        const wavParts = [];
-        let totalDuration = 0;
-        for (const chunk of textList) {
-            const { wav, duration } = await this.infer([chunk], style, totalStep, speed);
-            /*  insert silence between chunks  */
-            if (wavParts.length > 0) {
-                const silenceLen = Math.floor(silenceDuration * this.sampleRate);
-                wavParts.push(Array.from({ length: silenceLen }).fill(0));
-                totalDuration += silenceDuration;
-            }
-            wavParts.push(wav);
-            totalDuration += duration[0];
-        }
-        return { wav: wavParts.flat(), duration: totalDuration };
-    }
-    async release() {
-        /*  release all ONNX inference sessions  */
-        await Promise.all([
-            this.dpOrt.release(),
-            this.textEncOrt.release(),
-            this.vectorEstOrt.release(),
-            this.vocoderOrt.release()
-        ]);
-    }
-}
-/*  load voice style from JSON file  */
-async function loadVoiceStyle(voiceStylePath) {
-    /*  read and parse voice style JSON  */
-    let voiceStyle;
-    try {
-        voiceStyle = JSON.parse(await node_fs_1.default.promises.readFile(voiceStylePath, "utf8"));
-    }
-    catch (err) {
-        throw new Error(`failed to parse voice style JSON "${voiceStylePath}"`, { cause: err });
-    }
-    /*  extract dimensions and data  */
-    const ttlDims = voiceStyle.style_ttl.dims;
-    const dpDims = voiceStyle.style_dp.dims;
-    const ttlData = voiceStyle.style_ttl.data.flat(Infinity);
-    const dpData = voiceStyle.style_dp.data.flat(Infinity);
-    /*  create ONNX tensors for style vectors  */
-    const ttlStyle = new ORT.Tensor("float32", Float32Array.from(ttlData), ttlDims);
-    const dpStyle = new ORT.Tensor("float32", Float32Array.from(dpData), dpDims);
-    return { ttl: ttlStyle, dp: dpStyle };
-}
-/*  load TTS engine from ONNX models  */
-async function loadSupertonic(assetsDir) {
-    /*  load configuration  */
-    const cfgPath = node_path_1.default.join(assetsDir, "onnx", "tts.json");
-    let cfgs;
-    try {
-        cfgs = JSON.parse(await node_fs_1.default.promises.readFile(cfgPath, "utf8"));
-    }
-    catch (err) {
-        throw new Error(`failed to parse TTS config JSON "${cfgPath}"`, { cause: err });
-    }
-    /*  load text processor  */
-    const unicodeIndexerPath = node_path_1.default.join(assetsDir, "onnx", "unicode_indexer.json");
-    const textProcessor = new SupertonicTextProcessor(unicodeIndexerPath);
-    /*  load ONNX models  */
-    const opts = {};
-    const [dpOrt, textEncOrt, vectorEstOrt, vocoderOrt] = await Promise.all([
-        ORT.InferenceSession.create(node_path_1.default.join(assetsDir, "onnx", "duration_predictor.onnx"), opts),
-        ORT.InferenceSession.create(node_path_1.default.join(assetsDir, "onnx", "text_encoder.onnx"), opts),
-        ORT.InferenceSession.create(node_path_1.default.join(assetsDir, "onnx", "vector_estimator.onnx"), opts),
-        ORT.InferenceSession.create(node_path_1.default.join(assetsDir, "onnx", "vocoder.onnx"), opts)
-    ]);
-    return new SupertonicTTS(cfgs, textProcessor, dpOrt, textEncOrt, vectorEstOrt, vocoderOrt);
-}
-/*  ==== SPEECHFLOW NODE IMPLEMENTATION ====  */
 /*  SpeechFlow node for Supertonic text-to-speech conversion  */
 class SpeechFlowNodeT2ASupertonic extends speechflow_node_1.default {
     /*  declare official node name  */
     static name = "t2a-supertonic";
     /*  internal state  */
-    supertonic = null;
-    style = null;
+    tts = null;
     resampler = null;
+    sampleRate = 44100;
     closing = false;
     /*  construct node  */
     constructor(id, cfg, opts, args) {
@@ -452,75 +76,98 @@ class SpeechFlowNodeT2ASupertonic extends speechflow_node_1.default {
     async status() {
         return {};
     }
-    /*  download HuggingFace assets  */
-    async downloadAssets() {
-        /*  define HuggingFace repository and required files  */
-        const assetRepo = "Supertone/supertonic";
-        const assetFiles = [
-            "voice_styles/F1.json",
-            "voice_styles/F2.json",
-            "voice_styles/M1.json",
-            "voice_styles/M2.json",
-            "onnx/tts.json",
-            "onnx/duration_predictor.onnx",
-            "onnx/text_encoder.onnx",
-            "onnx/unicode_indexer.json",
-            "onnx/vector_estimator.onnx",
-            "onnx/vocoder.onnx",
-        ];
-        /*  create asset directories  */
-        const assetDir = node_path_1.default.join(this.config.cacheDir, "supertonic");
-        await (0, mkdirp_1.mkdirp)(node_path_1.default.join(assetDir, "voice_styles"), { mode: 0o750 });
-        await (0, mkdirp_1.mkdirp)(node_path_1.default.join(assetDir, "onnx"), { mode: 0o750 });
-        /*  download missing asset files  */
-        for (const assetFile of assetFiles) {
-            const url = `${assetRepo}/${assetFile}`;
-            const file = node_path_1.default.join(assetDir, assetFile);
-            const stat = await node_fs_1.default.promises.stat(file).catch((_err) => null);
-            if (stat === null || !stat.isFile()) {
-                this.log("info", `downloading from HuggingFace "${url}"`);
-                const response = await HF.downloadFile({ repo: assetRepo, path: assetFile });
-                if (!response)
-                    throw new Error(`failed to download from HuggingFace "${url}"`);
-                const buffer = Buffer.from(await response.arrayBuffer());
-                await node_fs_1.default.promises.writeFile(file, buffer);
-            }
-        }
-        return assetDir;
-    }
     /*  open node  */
     async open() {
         this.closing = false;
-        /*  download assets  */
-        const assetsDir = await this.downloadAssets();
-        /*  download ONNX models  */
-        this.log("info", `loading ONNX models (asset dir: "${assetsDir}")`);
-        this.supertonic = await loadSupertonic(assetsDir);
-        this.log("info", `loaded ONNX models (sample rate: ${this.supertonic.sampleRate}Hz)`);
-        /*  load voice style  */
-        const voiceStylePath = node_path_1.default.join(assetsDir, "voice_styles", `${this.params.voice}.json`);
-        if (!node_fs_1.default.existsSync(voiceStylePath))
-            throw new Error(`voice style not found: ${voiceStylePath}`);
-        this.log("info", `loading voice style "${this.params.voice}"`);
-        this.style = await loadVoiceStyle(voiceStylePath);
-        this.log("info", `loaded voice style "${this.params.voice}"`);
+        /*  load Supertonic TTS pipeline via transformers.js  */
+        const model = "onnx-community/Supertonic-TTS-ONNX";
+        this.log("info", `loading Supertonic TTS model "${model}"`);
+        /*  track download progress  */
+        const progressState = new Map();
+        const progressCallback = (progress) => {
+            let artifact = model;
+            if (typeof progress.file === "string")
+                artifact += `:${progress.file}`;
+            let percent = 0;
+            if (typeof progress.loaded === "number" && typeof progress.total === "number")
+                percent = (progress.loaded / progress.total) * 100;
+            else if (typeof progress.progress === "number")
+                percent = progress.progress;
+            if (percent > 0)
+                progressState.set(artifact, percent);
+        };
+        let interval = setInterval(() => {
+            for (const [artifact, percent] of progressState) {
+                this.log("info", `downloaded ${percent.toFixed(2)}% of artifact "${artifact}"`);
+                if (percent >= 100.0)
+                    progressState.delete(artifact);
+            }
+            if (progressState.size === 0 && interval !== null) {
+                clearInterval(interval);
+                interval = null;
+            }
+        }, 1000);
+        /*  create TTS pipeline  */
+        try {
+            const tts = Transformers.pipeline("text-to-speech", model, {
+                dtype: "fp32",
+                progress_callback: progressCallback
+            });
+            this.tts = await tts;
+        }
+        finally {
+            if (interval !== null) {
+                clearInterval(interval);
+                interval = null;
+            }
+        }
+        if (this.tts === null)
+            throw new Error("failed to instantiate Supertonic TTS pipeline");
+        /*  determine sample rate from model config  */
+        const config = this.tts.model?.config;
+        if (config?.sampling_rate)
+            this.sampleRate = config.sampling_rate;
+        this.log("info", `loaded Supertonic TTS model (sample rate: ${this.sampleRate}Hz)`);
         /*  establish resampler from Supertonic's output sample rate to our standard audio sample rate (48kHz)  */
-        this.resampler = new speex_resampler_1.default(1, this.supertonic.sampleRate, this.config.audioSampleRate, 7);
+        this.resampler = new speex_resampler_1.default(1, this.sampleRate, this.config.audioSampleRate, 7);
+        /*  map voice names to speaker embedding URLs  */
+        const voiceUrls = {
+            "M1": "https://huggingface.co/onnx-community/Supertonic-TTS-ONNX/resolve/main/voices/M1.bin",
+            "M2": "https://huggingface.co/onnx-community/Supertonic-TTS-ONNX/resolve/main/voices/M2.bin",
+            "F1": "https://huggingface.co/onnx-community/Supertonic-TTS-ONNX/resolve/main/voices/F1.bin",
+            "F2": "https://huggingface.co/onnx-community/Supertonic-TTS-ONNX/resolve/main/voices/F2.bin"
+        };
+        const speakerEmbeddings = voiceUrls[this.params.voice];
+        if (speakerEmbeddings === undefined)
+            throw new Error(`invalid Supertonic voice "${this.params.voice}"`);
+        this.log("info", `using voice "${this.params.voice}"`);
         /*  perform text-to-speech operation with Supertonic  */
         const text2speech = async (text) => {
-            /*  synthesize speech from text  */
             this.log("info", `Supertonic: input: "${text}"`);
-            const { wav, duration } = await this.supertonic.synthesize(text, this.style, this.params.steps, this.params.speed);
+            /*  generate speech using transformers.js pipeline  */
+            const result = await this.tts(text, {
+                speaker_embeddings: speakerEmbeddings,
+                num_inference_steps: this.params.steps,
+                speed: this.params.speed
+            });
+            /*  extract audio samples and sample rate  */
+            if (!(result.audio instanceof Float32Array))
+                throw new Error("unexpected Supertonic result: audio is not a Float32Array");
+            if (typeof result.sampling_rate !== "number")
+                throw new Error("unexpected Supertonic result: sampling_rate is not a number");
+            const samples = result.audio;
+            const outputSampleRate = result.sampling_rate;
+            if (outputSampleRate !== this.sampleRate)
+                this.log("warn", `unexpected sample rate ${outputSampleRate}Hz (expected ${this.sampleRate}Hz)`);
+            /*  calculate duration  */
+            const duration = samples.length / outputSampleRate;
             this.log("info", `Supertonic: synthesized ${duration.toFixed(2)}s of audio`);
             /*  convert audio samples from PCM/F32 to PCM/I16  */
-            const buffer1 = Buffer.alloc(wav.length * 2);
-            for (let i = 0; i < wav.length; i++) {
-                const sample = Math.max(-1, Math.min(1, wav[i]));
-                buffer1.writeInt16LE(sample * 0x7FFF, i * 2);
-            }
-            /*  resample audio samples from 44.1kHz to 48kHz  */
-            const buffer2 = this.resampler.processChunk(buffer1);
-            return buffer2;
+            const buffer1 = util.convertF32ToBuf(samples);
+            /*  resample audio samples from Supertonic sample rate to 48kHz  */
+            if (this.resampler === null)
+                throw new Error("resampler destroyed during TTS processing");
+            return this.resampler.processChunk(buffer1);
         };
         /*  create transform stream and connect it to the Supertonic TTS  */
         const self = this;
@@ -529,11 +176,13 @@ class SpeechFlowNodeT2ASupertonic extends speechflow_node_1.default {
             readableObjectMode: true,
             decodeStrings: false,
             highWaterMark: 1,
-            async transform(chunk, encoding, callback) {
+            transform(chunk, encoding, callback) {
                 if (self.closing)
                     callback(new Error("stream already destroyed"));
                 else if (Buffer.isBuffer(chunk.payload))
                     callback(new Error("invalid chunk payload type"));
+                else if (chunk.payload === "")
+                    callback();
                 else {
                     let processTimeout = setTimeout(() => {
                         processTimeout = null;
@@ -545,13 +194,7 @@ class SpeechFlowNodeT2ASupertonic extends speechflow_node_1.default {
                             processTimeout = null;
                         }
                     };
-                    try {
-                        if (self.closing) {
-                            clearProcessTimeout();
-                            callback(new Error("stream destroyed during processing"));
-                            return;
-                        }
-                        const buffer = await text2speech(chunk.payload);
+                    text2speech(chunk.payload).then((buffer) => {
                         if (self.closing) {
                             clearProcessTimeout();
                             callback(new Error("stream destroyed during processing"));
@@ -565,16 +208,13 @@ class SpeechFlowNodeT2ASupertonic extends speechflow_node_1.default {
                         chunkNew.type = "audio";
                         chunkNew.payload = buffer;
                         chunkNew.timestampEnd = luxon_1.Duration.fromMillis(chunkNew.timestampStart.toMillis() + durationMs);
-                        /*  push chunk and complete transform  */
                         clearProcessTimeout();
                         this.push(chunkNew);
                         callback();
-                    }
-                    catch (error) {
-                        /*  handle processing errors  */
+                    }).catch((error) => {
                         clearProcessTimeout();
                         callback(util.ensureError(error, "Supertonic processing failed"));
-                    }
+                    });
                 }
             },
             final(callback) {
@@ -591,16 +231,14 @@ class SpeechFlowNodeT2ASupertonic extends speechflow_node_1.default {
             await util.destroyStream(this.stream);
             this.stream = null;
         }
-        /*  destroy voice style  */
-        if (this.style !== null)
-            this.style = null;
         /*  destroy resampler  */
         if (this.resampler !== null)
             this.resampler = null;
-        /*  destroy Supertonic TTS  */
-        if (this.supertonic !== null) {
-            await this.supertonic.release();
-            this.supertonic = null;
+        /*  destroy TTS pipeline  */
+        if (this.tts !== null) {
+            /*  dispose of the pipeline if possible  */
+            await this.tts.dispose();
+            this.tts = null;
         }
     }
 }