@gentbajko/slopify 0.5.1 → 0.6.1

package/SUBTITLES.md

@@ -0,0 +1,21 @@
+# Subtitles in Slopify 0.6
+
+1. In Play, enable narration or provide matching English audio and article text.
+2. In Subtitles, choose **Subtitle files (.srt + .vtt)** or **Burn into video + files**.
+3. For burned captions, select a bundled or system font, or upload a `.ttf` or `.otf` file (up to 32 MiB). Preview the font and choose a size from 16 to 120.
+4. Start the run. Slopify times the article against the actual narration on your computer. The first use downloads an approximately 95 MB English speech model; later runs work offline with the cached model. Allow roughly 1 GB of available memory during alignment. No extra API key, Python, or compiler is needed.
+5. Download SRT/VTT beside the final export. Files mode adds an optional native caption track to the in-app video preview. Burned captions remain visible in the downloaded MP4.
+
+For a completed project, open its final Video or Audio export section, set subtitles, and click **Save subtitles**. This rebuilds only the local export from saved narration and images. Changing font or size reuses word timing when the audio and spoken text are unchanged. A paused run saves these choices until Resume; pause an active run before editing. Failed alignment or rendering keeps the previous finished export.
+
+Audio Off disables subtitles. Video Off produces WAV audio with separate subtitle files. Uploaded audio must match the article; substantial mismatches fail with a message to correct the transcript. Review timing and spelling before publishing. English is supported first; unusual pronunciations and non-English passages can fail alignment.
+
+Fonts are copied into the completed project's caption assets, so an existing export can reuse its chosen font even after the original system font is removed. Installed fonts and uploaded fonts stay local. SRT/VTT are portable text/timing files and do not embed a font; the chosen font is used in burned video captions.
+
+## Local model and licenses
+
+Speech inference uses MIT-licensed `onnxruntime-web@1.24.3` in a separate WASM process. The runtime is installed with the package (about 138 MB on disk); model weights are downloaded lazily into `<data-dir>/models/english-subtitles/`.
+
+Model: [Xenova/wav2vec2-base-960h](https://huggingface.co/Xenova/wav2vec2-base-960h/tree/a19f851b3d42865797e410752b4c570c871e4825), an ONNX conversion of [facebook/wav2vec2-base-960h](https://huggingface.co/facebook/wav2vec2-base-960h), licensed Apache-2.0. Pinned revision: `a19f851b3d42865797e410752b4c570c871e4825`. The quantized model is 95,286,046 bytes, SHA256 `cd5040c147381580ed73258143dd8e0c28e800a09e74ee42ee2b3e8cb4d760a3`; every cached/downloaded model is verified before use.
+
+The bundled Barlow font uses the SIL Open Font License; its license and source record ship in `dist/assets/fonts/`. Uploaded/system font licensing remains with its author.

package/dist/adapter-registry.js

@@ -4,10 +4,12 @@ import { openAiImage } from "./adapters/image/openai.js";
 import { replicateImage } from "./adapters/image/replicate.js";
 import { claudeCodeLlm } from "./adapters/llm/claude-code.js";
 import { codexLlm } from "./adapters/llm/codex.js";
+import { geminiLlm } from "./adapters/llm/gemini.js";
 import { openRouterLlm } from "./adapters/llm/openrouter.js";
 import { cartesiaTts } from "./adapters/tts/cartesia.js";
 import { elevenLabsTts } from "./adapters/tts/elevenlabs.js";
 import { openAiTts } from "./adapters/tts/openai.js";
+import { cliBinary } from "./slices/settings/cli-paths.js";
 import { keyForAttempt } from "./slices/settings/keys.js";
 import { providerStatuses } from "./slices/settings/readiness.js";
 export function buildRegistry(deps) {
@@ -18,11 +20,14 @@ export function buildRegistry(deps) {
         const found = keyForAttempt({ db: deps.db, clock: deps.clock }, provider);
         return found.ok ? found.key : undefined;
     };
+    // Resolve at invocation time so saved path changes apply to the next attempt.
+    const cliFor = (provider) => (_binary, args, signal, ...options) => deps.spawn(cliBinary(deps.db, provider), args, signal, ...options);
     const llms = new Map([
         ["openrouter", openRouterLlm({ fetch: deps.fetch, key: keyOf("openrouter") })],
-        // No key: both CLIs authenticate with their own login.
-        ["claude-code", claudeCodeLlm({ run: deps.spawn })],
-        ["codex", codexLlm({ run: deps.spawn })],
+        // Each CLI authenticates with its own login.
+        ["claude-code", claudeCodeLlm({ run: cliFor("claude-code") })],
+        ["codex", codexLlm({ run: cliFor("codex") })],
+        ["gemini", geminiLlm({ run: cliFor("gemini") })],
     ]);
     // One key per provider, so each adapter is handed the reader for its own row and no other.
     // OpenAI keeps two rows because it ships an adapter in two families and a user may key one

package/dist/adapters/alignment/audio.js

@@ -0,0 +1,45 @@
+import { spawn } from "node:child_process";
+export async function decodeAudio(ffmpeg, source, output, signal) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const child = spawn(ffmpeg, [
+            "-hide_banner",
+            "-nostdin",
+            "-loglevel",
+            "error",
+            "-y",
+            "-i",
+            source,
+            "-map",
+            "0:a:0",
+            "-vn",
+            "-ar",
+            "16000",
+            "-ac",
+            "1",
+            "-f",
+            "f32le",
+            output,
+        ], { stdio: ["ignore", "ignore", "pipe"], windowsHide: true });
+        let errorText = "";
+        const abort = () => {
+            child.kill("SIGKILL");
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        child.stderr.on("data", (data) => {
+            errorText = (errorText + data.toString("utf8")).slice(-2000);
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            signal.removeEventListener("abort", abort);
+            if (signal.aborted)
+                reject(new Error("Subtitle audio preparation was canceled."));
+            else if (code !== 0)
+                reject(new Error(`Could not prepare the narration for subtitles. ${errorText}`));
+            else
+                resolve();
+        });
+        if (signal.aborted)
+            abort();
+    });
+}

package/dist/adapters/alignment/cache.js

@@ -0,0 +1,91 @@
+import { createHash } from "node:crypto";
+import { createReadStream, createWriteStream } from "node:fs";
+import { mkdir, mkdtemp, rename, rm, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+const revision = "a19f851b3d42865797e410752b4c570c871e4825";
+export const alignmentModel = {
+    filename: "wav2vec2-base-960h-cd5040c1.onnx",
+    url: `https://huggingface.co/Xenova/wav2vec2-base-960h/resolve/${revision}/onnx/model_quantized.onnx`,
+    bytes: 95_286_046,
+    sha256: "cd5040c147381580ed73258143dd8e0c28e800a09e74ee42ee2b3e8cb4d760a3",
+};
+export async function prepareModel(input, deps = { model: alignmentModel, fetch: globalThis.fetch }) {
+    input.signal.throwIfAborted();
+    await mkdir(input.cacheDir, { recursive: true, mode: 0o700 });
+    const target = join(input.cacheDir, deps.model.filename);
+    if (await verified(target, deps.model, input.signal))
+        return target;
+    const staging = await mkdtemp(join(input.cacheDir, ".alignment-download-"));
+    const part = join(staging, "model.part");
+    try {
+        const response = await deps.fetch(deps.model.url, {
+            signal: AbortSignal.any([input.signal, AbortSignal.timeout(300_000)]),
+        });
+        if (!response.ok || response.body === null)
+            throw new Error(`The free subtitle model could not be downloaded (HTTP ${response.status}). Check your connection and try again.`);
+        let current = 0;
+        const hash = createHash("sha256");
+        const reader = response.body.getReader();
+        async function* chunks() {
+            try {
+                for (;;) {
+                    input.signal.throwIfAborted();
+                    const result = await reader.read();
+                    if (result.done)
+                        break;
+                    current += result.value.length;
+                    if (current > deps.model.bytes)
+                        throw new Error("The subtitle model failed download size verification.");
+                    hash.update(result.value);
+                    input.onProgress?.(current, deps.model.bytes);
+                    yield result.value;
+                }
+            }
+            finally {
+                await reader.cancel();
+            }
+        }
+        await pipeline(Readable.from(chunks()), createWriteStream(part, { mode: 0o600 }), {
+            signal: input.signal,
+        });
+        input.signal.throwIfAborted();
+        if (current !== deps.model.bytes || hash.digest("hex") !== deps.model.sha256)
+            throw new Error("The subtitle model failed download verification. Please try again.");
+        // Each caller writes in its own directory. On Windows a completed concurrent download
+        // may already own the final filename; reuse it only after the same verification.
+        try {
+            await rename(part, target);
+        }
+        catch (error) {
+            if (await verified(target, deps.model, input.signal))
+                return target;
+            if (!isCode(error, "EEXIST") && !isCode(error, "EPERM"))
+                throw error;
+            await rm(target, { force: true });
+            await rename(part, target);
+        }
+        return target;
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+}
+async function verified(path, model, signal) {
+    try {
+        if ((await stat(path)).size !== model.bytes)
+            return false;
+        const hash = createHash("sha256");
+        await pipeline(createReadStream(path), hash, { signal });
+        return hash.digest("hex") === model.sha256;
+    }
+    catch (error) {
+        if (isCode(error, "ENOENT"))
+            return false;
+        throw error;
+    }
+}
+function isCode(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
+}

package/dist/adapters/alignment/ctc.js

@@ -0,0 +1,128 @@
+import { vocabulary } from "./vocabulary.js";
+export const frameSeconds = 0.02;
+export const mismatch = "The audio does not closely match the English transcript. Check the article and audio, including any intro or outro, before generating subtitles.";
+export function alignWindow(logits, frames, words, complete) {
+    if (frames < 1 || frames > 1100 || logits.length !== frames * 32)
+        throw new Error("The subtitle alignment window exceeds its safe size.");
+    const tokens = tokenize(words);
+    if (tokens.ids.length === 0 || tokens.ids.length > 1500)
+        throw new Error("The subtitle transcript window exceeds its safe size.");
+    const states = [0];
+    for (const id of tokens.ids)
+        states.push(id, 0);
+    const probabilities = logSoftmax(logits, frames);
+    const width = states.length;
+    const back = new Uint8Array(frames * width);
+    let previous = new Float32Array(width).fill(-Infinity);
+    previous[0] = 0;
+    for (let frame = 0; frame < frames; frame += 1) {
+        const current = new Float32Array(width).fill(-Infinity);
+        for (let state = 0; state < Math.min(width, frame * 2 + 3); state += 1) {
+            let score = previous[state] ?? -Infinity;
+            let step = 0;
+            if (state > 0 && (previous[state - 1] ?? -Infinity) > score) {
+                score = previous[state - 1] ?? -Infinity;
+                step = 1;
+            }
+            if (state > 1 &&
+                states[state] !== 0 &&
+                states[state] !== states[state - 2] &&
+                (previous[state - 2] ?? -Infinity) > score) {
+                score = previous[state - 2] ?? -Infinity;
+                step = 2;
+            }
+            current[state] = score + (probabilities[frame * 32 + (states[state] ?? 0)] ?? -Infinity);
+            back[frame * width + state] = step;
+        }
+        previous = current;
+    }
+    const state = endState(previous, tokens, complete);
+    if (!Number.isFinite(previous[state]))
+        throw new Error(mismatch);
+    const traced = trace(back, states, tokens, words, probabilities, frames, state);
+    if (traced.length === 0)
+        throw new Error(mismatch);
+    const confidence = traced.reduce((sum, word) => sum + (word.confidence ?? 0), 0) / traced.length;
+    const poor = traced.filter((word) => (word.confidence ?? 0) < 0.2).length / traced.length;
+    if (confidence < 0.48 || poor > 0.3)
+        throw new Error(mismatch);
+    return { words: traced, confidence };
+}
+function tokenize(words) {
+    const ids = [], owners = [], ends = [];
+    for (const [index, word] of words.entries()) {
+        if (index > 0) {
+            ids.push(4);
+            owners.push(-1);
+        }
+        for (const letter of word.spoken.replaceAll(" ", "|")) {
+            const id = vocabulary[letter];
+            if (id !== undefined) {
+                ids.push(id);
+                owners.push(index);
+            }
+        }
+        ends.push(ids.length * 2 - 1);
+    }
+    return { ids, owners, ends };
+}
+function endState(scores, tokens, complete) {
+    if (complete)
+        return (scores.at(-1) ?? -Infinity) > (scores.at(-2) ?? -Infinity)
+            ? scores.length - 1
+            : scores.length - 2;
+    let best = 0;
+    for (const end of tokens.ends) {
+        for (const state of [end, end + 1, end + 2]) {
+            if ((scores[state] ?? -Infinity) > (scores[best] ?? -Infinity))
+                best = state;
+        }
+    }
+    return best;
+}
+function trace(back, states, tokens, words, probabilities, frames, finalState) {
+    const found = words.map((word) => ({
+        text: word.text,
+        start: Infinity,
+        end: 0,
+        score: 0,
+        count: 0,
+    }));
+    let state = finalState;
+    for (let frame = frames - 1; frame >= 0; frame -= 1) {
+        if (state % 2 === 1) {
+            const owner = tokens.owners[(state - 1) / 2] ?? -1;
+            const word = found[owner];
+            if (word !== undefined) {
+                word.start = Math.min(word.start, frame * frameSeconds);
+                word.end = Math.max(word.end, (frame + 1) * frameSeconds);
+                word.score += Math.exp(probabilities[frame * 32 + (states[state] ?? 0)] ?? -Infinity);
+                word.count += 1;
+            }
+        }
+        state -= back[frame * states.length + state] ?? 0;
+    }
+    return found.flatMap((word, index) => {
+        if (word.count === 0 || (tokens.ends[index] ?? Infinity) > finalState)
+            return [];
+        return [
+            { text: word.text, start: word.start, end: word.end, confidence: word.score / word.count },
+        ];
+    });
+}
+function logSoftmax(logits, frames) {
+    const result = new Float32Array(logits.length);
+    for (let frame = 0; frame < frames; frame += 1) {
+        const offset = frame * 32;
+        let max = -Infinity;
+        for (let label = 0; label < 32; label += 1)
+            max = Math.max(max, logits[offset + label] ?? -Infinity);
+        let sum = 0;
+        for (let label = 0; label < 32; label += 1)
+            sum += Math.exp((logits[offset + label] ?? -Infinity) - max);
+        const divisor = max + Math.log(sum);
+        for (let label = 0; label < 32; label += 1)
+            result[offset + label] = (logits[offset + label] ?? -Infinity) - divisor;
+    }
+    return result;
+}

package/dist/adapters/alignment/index.js

@@ -0,0 +1,34 @@
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { decodeAudio } from "./audio.js";
+import { prepareModel } from "./cache.js";
+import { claimWorker } from "./lock.js";
+import { runAlignmentWorker } from "./runner.js";
+import { speechWords } from "./text.js";
+export const alignSubtitles = async (request) => {
+    request.signal.throwIfAborted();
+    speechWords(request.text);
+    await mkdir(request.cacheDir, { recursive: true, mode: 0o700 });
+    const release = await claimWorker(request.cacheDir, request.signal);
+    try {
+        const modelPath = await prepareModel({
+            cacheDir: request.cacheDir,
+            signal: request.signal,
+            onProgress: (current, total) => request.onProgress?.(Math.round((current / total) * 20), 100),
+        });
+        request.onProgress?.(20, 100);
+        const working = await mkdtemp(join(request.cacheDir, ".alignment-audio-"));
+        try {
+            const pcmPath = join(working, "audio.f32");
+            await decodeAudio(request.ffmpeg, request.audioPath, pcmPath, request.signal);
+            request.onProgress?.(25, 100);
+            return await runAlignmentWorker({ modelPath, pcmPath, text: request.text }, request.signal, (current, total) => request.onProgress?.(25 + Math.round((current / total) * 75), 100));
+        }
+        finally {
+            await rm(working, { recursive: true, force: true });
+        }
+    }
+    finally {
+        await release();
+    }
+};

package/dist/adapters/alignment/lock.js

@@ -0,0 +1,58 @@
+import { open, readFile, rm, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { setTimeout } from "node:timers/promises";
+// Models run one at a time per data directory, including requests from separate app
+// processes. A canceled waiter never removes another request's lock.
+export async function claimWorker(cacheDir, signal) {
+    const path = join(cacheDir, "alignment-worker.lock");
+    for (;;) {
+        signal.throwIfAborted();
+        try {
+            const file = await open(path, "wx", 0o600);
+            try {
+                try {
+                    await file.writeFile(String(process.pid));
+                }
+                finally {
+                    await file.close();
+                }
+            }
+            catch (error) {
+                await rm(path, { force: true });
+                throw error;
+            }
+            return async () => {
+                await rm(path, { force: true });
+            };
+        }
+        catch (error) {
+            if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
+                throw error;
+        }
+        try {
+            const owner = Number(await readFile(path, "utf8"));
+            if ((!Number.isInteger(owner) || owner <= 0) &&
+                Date.now() - (await stat(path)).mtimeMs > 10_000) {
+                await rm(path, { force: true });
+                continue;
+            }
+            if (Number.isInteger(owner) && owner > 0) {
+                try {
+                    process.kill(owner, 0);
+                }
+                catch (error) {
+                    if (error instanceof Error && "code" in error && error.code === "ESRCH") {
+                        await rm(path, { force: true });
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+                throw error;
+        }
+        await setTimeout(250, undefined, { signal });
+    }
+}

package/dist/adapters/alignment/numbers.js

@@ -0,0 +1,91 @@
+const small = [
+    "ZERO",
+    "ONE",
+    "TWO",
+    "THREE",
+    "FOUR",
+    "FIVE",
+    "SIX",
+    "SEVEN",
+    "EIGHT",
+    "NINE",
+    "TEN",
+    "ELEVEN",
+    "TWELVE",
+    "THIRTEEN",
+    "FOURTEEN",
+    "FIFTEEN",
+    "SIXTEEN",
+    "SEVENTEEN",
+    "EIGHTEEN",
+    "NINETEEN",
+];
+const tens = [
+    "",
+    "",
+    "TWENTY",
+    "THIRTY",
+    "FORTY",
+    "FIFTY",
+    "SIXTY",
+    "SEVENTY",
+    "EIGHTY",
+    "NINETY",
+];
+const ordinal = {
+    ONE: "FIRST",
+    TWO: "SECOND",
+    THREE: "THIRD",
+    FIVE: "FIFTH",
+    EIGHT: "EIGHTH",
+    NINE: "NINTH",
+    TWELVE: "TWELFTH",
+};
+export function cardinal(value) {
+    if (value < 20)
+        return small[value] ?? "";
+    if (value < 100)
+        return `${tens[Math.floor(value / 10)] ?? ""} ${value % 10 === 0 ? "" : cardinal(value % 10)}`.trim();
+    for (const [size, name] of [
+        [1_000_000_000, "BILLION"],
+        [1_000_000, "MILLION"],
+        [1000, "THOUSAND"],
+        [100, "HUNDRED"],
+    ]) {
+        if (value >= size)
+            return `${cardinal(Math.floor(value / size))} ${name}${value % size === 0 ? "" : ` ${cardinal(value % size)}`}`;
+    }
+    return "";
+}
+export function numberForms(raw) {
+    const match = /^(\d[\d,]*)(?:\.(\d+))?(s|st|nd|rd|th)?$/i.exec(raw);
+    if (match === null)
+        return [raw.replace(/\d/g, (digit) => ` ${small[Number(digit)] ?? ""} `)];
+    const digits = (match[1] ?? "").replaceAll(",", "");
+    const value = Number(digits);
+    if (!Number.isSafeInteger(value) || value >= 1_000_000_000_000)
+        return [
+            digits
+                .split("")
+                .map((digit) => small[Number(digit)])
+                .join(" "),
+        ];
+    const fraction = match[2];
+    const suffix = match[3]?.toLowerCase();
+    const decimal = fraction === undefined
+        ? ""
+        : ` POINT ${fraction
+            .split("")
+            .map((digit) => small[Number(digit)])
+            .join(" ")}`;
+    const ordinary = `${cardinal(value)}${decimal}`;
+    const year = value >= 1900 && value <= 2099 && value % 100 >= 10
+        ? `${cardinal(Math.floor(value / 100))} ${cardinal(value % 100)}`
+        : undefined;
+    const forms = year === undefined ? [ordinary] : [year, ordinary];
+    if (suffix === "s")
+        return forms.map((form) => `${form.replace(/Y$/, "IE")}S`);
+    if (suffix !== undefined)
+        return forms.map((form) => form.replace(/[A-Z]+$/, (word) => ordinal[word] ?? (word.endsWith("Y") ? `${word.slice(0, -1)}IETH` : `${word}TH`)));
+    return forms;
+}

package/dist/adapters/alignment/protocol.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export const workerInput = z.object({
+    modelPath: z.string(),
+    pcmPath: z.string(),
+    text: z.string(),
+});
+export const workerMessage = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("progress"),
+        current: z.number().finite().nonnegative(),
+        total: z.number().finite().positive(),
+    }),
+    z.object({
+        type: z.literal("done"),
+        words: z.array(z.object({
+            text: z.string(),
+            start: z.number().finite().nonnegative(),
+            end: z.number().finite().nonnegative(),
+            confidence: z.number().finite().min(0).max(1).optional(),
+        })),
+    }),
+    z.object({ type: z.literal("error"), message: z.string() }),
+]);

package/dist/adapters/alignment/quality.js

@@ -0,0 +1,17 @@
+// Compare acoustic recognition with the already aligned transcript. This catches extra
+// speech and missing phrases even when a few forced words individually score well.
+export function agreesWithSpeech(expected, observed) {
+    const left = expected.toUpperCase().replace(/[^A-Z']/g, "");
+    const right = observed.toUpperCase().replace(/[^A-Z']/g, "");
+    if (left.length === 0 || right.length === 0)
+        return false;
+    let previous = Uint16Array.from({ length: right.length + 1 }, (_, index) => index);
+    for (let row = 1; row <= left.length; row += 1) {
+        const current = new Uint16Array(right.length + 1);
+        current[0] = row;
+        for (let column = 1; column <= right.length; column += 1)
+            current[column] = Math.min((previous[column] ?? 0) + 1, (current[column - 1] ?? 0) + 1, (previous[column - 1] ?? 0) + (left[row - 1] === right[column - 1] ? 0 : 1));
+        previous = current;
+    }
+    return (previous[right.length] ?? Infinity) / Math.max(left.length, right.length) <= 0.42;
+}

package/dist/adapters/alignment/runner.js

@@ -0,0 +1,76 @@
+import { fork } from "node:child_process";
+import { workerMessage } from "./protocol.js";
+export async function runAlignmentWorker(input, signal, onProgress, worker = new URL("./worker.js", import.meta.url)) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const options = {
+            stdio: ["ignore", "ignore", "pipe", "ipc"],
+            windowsHide: true,
+            execArgv: [],
+            serialization: "advanced",
+        };
+        const child = fork(worker, [], options);
+        let finishing = false;
+        let failure;
+        let output = [];
+        let stderr = "";
+        const finish = (error, words) => {
+            if (finishing)
+                return;
+            finishing = true;
+            failure = error;
+            output = words ?? [];
+            signal.removeEventListener("abort", abort);
+            child.kill("SIGKILL");
+        };
+        const abort = () => finish(new Error("Subtitle alignment was canceled."));
+        signal.addEventListener("abort", abort, { once: true });
+        child.stderr?.on("data", (data) => {
+            stderr = (stderr + data.toString("utf8")).slice(-2000);
+        });
+        child.on("error", (error) => finish(error));
+        // Wait for close, not only the IPC answer: Windows still owns the decoded audio
+        // handle until the worker has actually exited, so early cleanup can fail with EPERM.
+        child.on("close", (code) => {
+            if (!finishing)
+                finish(new Error(`Local subtitle alignment stopped (exit ${String(code)}). ${stderr}`.trim()));
+            if (failure !== undefined)
+                reject(failure);
+            else
+                resolve(output);
+        });
+        child.on("message", (raw) => {
+            if (finishing)
+                return;
+            const parsed = workerMessage.safeParse(raw);
+            if (!parsed.success) {
+                finish(new Error("The local subtitle worker returned invalid timing data."));
+                return;
+            }
+            const message = parsed.data;
+            if (message.type === "progress") {
+                try {
+                    onProgress?.(message.current, message.total);
+                }
+                catch (error) {
+                    finish(error instanceof Error ? error : new Error(String(error)));
+                }
+            }
+            else if (message.type === "error")
+                finish(new Error(message.message));
+            else
+                finish(undefined, message.words.map(({ confidence, ...word }) => ({
+                    ...word,
+                    ...(confidence === undefined ? {} : { confidence }),
+                })));
+        });
+        if (signal.aborted) {
+            abort();
+            return;
+        }
+        child.send(input, (error) => {
+            if (error !== null)
+                finish(error);
+        });
+    });
+}