@gentbajko/slopify 0.5.1 → 0.7.0

package/README.md

@@ -1,4 +1,15 @@
-# Slopify
+<h1 align="center">
+  <a href="https://slopify.stream"><img src="https://slopify.stream/assets/favicon.svg" width="40" height="40" align="middle" alt="" /></a>
+  Slopify
+</h1>
+
+<p align="center">
+  <a href="https://slopify.stream">slopify.stream</a>
+  &nbsp;·&nbsp;
+  <a href="https://www.patreon.com/cw/GentBajko"><img src="https://slopify.stream/assets/patreon-green.svg" width="14" height="14" align="middle" alt="" /> Patreon</a>
+  &nbsp;·&nbsp;
+  <a href="https://buymeacoffee.com/gentbajko"><img src="https://slopify.stream/assets/buymeacoffee-green.svg" width="14" height="14" align="middle" alt="" /> Buy Me a Coffee</a>
+</p>
 
 A prompt and a few keywords in. A narrated slideshow video out. Your keys, your machine, free.
 
@@ -14,6 +25,23 @@ Six stages run as a graph: research, article, narration, images, thumbnail, vide
 Generate any of them, or provide the output yourself and that stage is skipped. The
 video is a slideshow with alternating zoom over the narration, rendered with ffmpeg.
 
+## Inworld narration
+
+In Settings, add the **Base64 credentials** from Inworld's API Keys page, then add an
+Inworld voice ID (for example `Dennis`, or a voice from your workspace). In Play,
+choose **Realtime TTS-2** or **Realtime TTS-2 Flash** and that voice.
+
+Short text streams immediately. TTS-2 text over 4,000 characters uses one async job,
+up to 100,000 characters; Inworld caps On-Demand accounts at 10,000. Audio becomes
+available once that job finishes. Flash uses streamed parts of at most 4,000 characters.
+For longer articles, select paragraph chunking. Successful status checks keep long jobs
+alive, and automatic polling/download retries reuse the accepted job. Pausing stops
+local requests; Inworld may still finish and bill an accepted job. Resuming after a
+pause or app restart starts a new request for unfinished narration.
+
+See [Inworld's async API](https://docs.inworld.ai/api-reference/ttsAPI/texttospeech/synthesize-speech-async)
+for account limits. Both model IDs are bundled; Inworld's LLM catalogue does not list TTS models.
+
 ## Options
 
 | Flag | Environment variable | Default |
@@ -67,6 +95,13 @@ Never your keys, prompts, keywords, titles, article text, filenames, or anything
 your machine. A notice says all of this the first time you run it, before the machine
 id exists, and the Usage screen shows you your own numbers at any time.
 
+## Supporting the project
+
+Slopify is free and always will be. If it is worth something to you, there is
+[Patreon](https://www.patreon.com/cw/GentBajko) and
+[Buy Me a Coffee](https://buymeacoffee.com/gentbajko). The people who do are listed
+in [SUPPORTERS.md](https://github.com/GentBajko/slopify/blob/main/SUPPORTERS.md).
+
 ## Licence
 
 MIT. The ffmpeg binary fetched at install time is a separate GPL-3.0-or-later program,

package/SUBTITLES.md

@@ -0,0 +1,21 @@
+# Subtitles in Slopify
+
+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). Choose a size from 16 to 120 and a position: top, upper-middle, center, lower-middle or bottom. The side preview shows the selected font, size and position in a 16:9 or 9:16 frame.
+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, size or position 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,15 @@ 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 { nodeCodexModels } from "./adapters/llm/codex-models.js";
+import { geminiLlm } from "./adapters/llm/gemini.js";
+import { nodeGeminiModels } from "./adapters/llm/gemini-models.js";
 import { openRouterLlm } from "./adapters/llm/openrouter.js";
 import { cartesiaTts } from "./adapters/tts/cartesia.js";
 import { elevenLabsTts } from "./adapters/tts/elevenlabs.js";
+import { inworldTts } from "./adapters/tts/inworld.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 +23,20 @@ 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"), readModels: () => nodeCodexModels() })],
+        [
+            "gemini",
+            geminiLlm({
+                run: cliFor("gemini"),
+                readModels: () => nodeGeminiModels(cliBinary(deps.db, "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
@@ -31,6 +45,7 @@ export function buildRegistry(deps) {
         ["elevenlabs", elevenLabsTts({ fetch: deps.fetch, key: keyOf("elevenlabs") })],
         ["openai-tts", openAiTts({ fetch: deps.fetch, key: keyOf("openai-tts") })],
         ["cartesia", cartesiaTts({ fetch: deps.fetch, key: keyOf("cartesia") })],
+        ["inworld", inworldTts({ fetch: deps.fetch, key: keyOf("inworld"), clock: deps.clock })],
     ]);
     // Four image providers behind one port, each handed the reader for its own key row.
     // Replicate also takes the clock: `Prefer: wait` gives up after 60 s and the prediction has

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;
+}