@gentbajko/slopify 4.2.0 → 4.3.0

package/SUBTITLES.md

@@ -12,6 +12,8 @@ If narration omits a short phrase, alignment can skip that transcript span when
 
 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, Spanish, German, French, Italian, Portuguese, Dutch, Catalan, Polish and Czech are timed word by word (the other nine with a separate 248 MB multilingual model, downloaded on first use into `<data-dir>/models/multilingual-subtitles/`, about 1.1 GB of memory while aligning); other project languages are timed sentence by sentence. See docs/multilingual-timing.md. Unusual pronunciations and passages in another language than the project's can fail alignment.
 
+Timing also records, word by word, the letters the model heard where they are not the word it was given to place. Nothing extra is computed for it and nothing changes about the captions: it is the decode the aligner already runs to check the audio against the transcript, kept per word instead of discarded. It is what lets the project page answer whether a name was said right rather than merely said clearly, and it is why `subtitles.json` carries a `heard` field on some words and `listened: true` at the top. Captions timed by an earlier version have neither, and the name check reports those as unlistened rather than right.
+
 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

package/dist/adapters/alignment/protocol.js

@@ -32,6 +32,7 @@ export const workerMessage = z.discriminatedUnion("type", [
             start: z.number().finite().nonnegative(),
             end: z.number().finite().nonnegative(),
             confidence: z.number().finite().min(0).max(1).optional(),
+            heard: z.string().max(200).optional(),
         })),
     }),
     omissionSchema.extend({ type: z.literal("omission") }),

package/dist/adapters/alignment/window.js

@@ -152,9 +152,7 @@ export function saidTheirWay(logits, frames, candidate, complete, cutoff, spec,
     }
     if (keep < holdingWords)
         return undefined;
-    return words
-        .slice(0, keep)
-        .map((word, index) => (matches[index] ? word : { ...word, confidence: 0 }));
+    return withHeard(logits, frames, words.slice(0, keep), candidate, spec).map((word, index) => matches[index] ? word : { ...word, confidence: 0 });
 }
 function accepted(logits, frames, candidate, complete, cutoff, spec, maximumError = spec.gates.maximumError) {
     const words = alignWindow(logits, frames, candidate, complete, spec).words.filter((word) => word.end <= cutoff);
@@ -165,13 +163,13 @@ function accepted(logits, frames, candidate, complete, cutoff, spec, maximumErro
             .map((word) => word.spoken)
             .join(" "), greedy(logits, Math.min(frames, Math.ceil(last.end / frameSeconds)), spec), maximumError, spec.comparable))
         throw new Error(spec.mismatch);
-    return words;
+    return withHeard(logits, frames, words, candidate, spec);
 }
 export function greedy(logits, frames, spec = englishSpec) {
     return greedyBetween(logits, 0, frames, spec);
 }
 // What the model heard between two frames.
-function greedyBetween(logits, from, to, spec = englishSpec) {
+export function greedyBetween(logits, from, to, spec = englishSpec) {
     const labels = spec.labels;
     let previous = -1;
     let text = "";
@@ -186,3 +184,29 @@ function greedyBetween(logits, from, to, spec = englishSpec) {
     }
     return text.trim().replace(/\s+/g, " ");
 }
+// What the model heard over one word's own frames, when that is not the word it was given to
+// place. Forced alignment is only ever asked where a word is, never which word it was, so a
+// name said wrong the same way every time scores as well as one said right; these letters are
+// the one place the difference shows. Kept only on a word that disagrees, so the timing file
+// stays a timing file: a word the model heard as written carries nothing.
+export function heardAs(logits, frames, word, expected, spec) {
+    // Too short to tell apart: "the" heard as "th" says nothing about anything.
+    if (spec.lettersOnly(expected).length < 3)
+        return undefined;
+    const heard = greedyBetween(logits, Math.floor(word.start / frameSeconds), Math.min(frames, Math.ceil(word.end / frameSeconds)), spec);
+    // Anything that is not the word itself, not only what is far from it: "Loth" for "Lolth" is
+    // one letter out and is exactly the mistake worth catching. Whether a difference means
+    // anything is for the reader to judge from how often it repeats, not for one word to decide,
+    // so this records and the name check counts (`slices/narration/pronunciation-check.ts`).
+    const letters = spec.comparable(heard);
+    if (letters === "" || letters === spec.comparable(expected))
+        return undefined;
+    return heard.slice(0, 60);
+}
+// Every word of an accepted window, carrying what the model heard wherever that disagrees.
+export function withHeard(logits, frames, words, candidate, spec) {
+    return words.map((word, index) => {
+        const heard = heardAs(logits, frames, word, candidate[index]?.spoken ?? "", spec);
+        return heard === undefined ? word : { ...word, heard };
+    });
+}

package/dist/edge/http/pronunciation-check.js

@@ -49,7 +49,8 @@ function timingWords(deps, projectId, view) {
     if (timing === undefined)
         return null;
     try {
-        return wordsSchema.parse(JSON.parse(readFileSync(outputPath(deps.paths, projectId, timing.output.path), "utf8"))).words;
+        const parsed = wordsSchema.parse(JSON.parse(readFileSync(outputPath(deps.paths, projectId, timing.output.path), "utf8")));
+        return { words: parsed.words, listened: parsed.listened };
     }
     catch {
         // Timing that is missing or unreadable means there is nothing to say about how it was heard.
@@ -115,18 +116,22 @@ export function pronunciationCheckRoutes(deps) {
                 revisionId: null,
                 narrated: null,
                 heard: null,
+                listened: false,
                 notice: null,
             });
         const sources = sourcesOf(view.revision.config, view);
         const script = narrationText(deps, projectId, view, "tts_script");
         const written = narrationText(deps, projectId, view, "narration_txt");
-        const words = timingWords(deps, projectId, view);
+        const timing = timingWords(deps, projectId, view);
         const narrated = script === null ? null : namesNarrated(script, sources);
-        const heard = words === null ? null : heardNames(words, sources, written ?? script ?? undefined);
+        const heard = timing === null
+            ? null
+            : heardNames(timing.words, sources, written ?? script ?? undefined);
         return c.json({
             revisionId: view.revision.id,
             narrated,
             heard,
+            listened: timing?.listened ?? false,
             notice: narratedNotice(narrated, heard),
         });
     }));

package/dist/edge/mcp/tools-library.js

@@ -170,7 +170,7 @@ export const libraryTools = [
         name: "check_narration_names",
         route: "GET /api/projects/:projectId/pronunciations/heard",
         title: "Check how the finished narration said a project's names",
-        description: "Two answers about a rendered project, from files it already has. `narrated` counts the names that reached the voice as written rather than as IPA, from the voice script itself, so it is what the voice was really sent. `heard` reads the per-word confidence of the subtitle timing: each name's mean and the spread across its mentions, and `uneven` for the names whose mentions disagree with each other, which is the sign a name was not said the same way twice. A rare name scores low even when it is said perfectly, so a low score alone never flags. Nothing is listened to again, re-aligned or changed.",
+        description: "Two answers about a rendered project, from files it already has. `narrated` counts the names that reached the voice as written rather than as IPA, from the voice script itself, so it is what the voice was really sent. `heard` reads the subtitle timing: each name's mean confidence and the spread across its mentions, `uneven` for the names whose mentions disagree with each other, and `saidAs` for the letters the timing model heard over a mention where they were not the name itself (spelling that is only spelling is folded away first, so CREEG for Kreeg and BELL for Bel are never reported), `ipa` for the pronunciation the sources asked for, and `different` for the names most of whose mentions came out as a sound the name does not spell, which is the only part of the check that says how a name was said rather than how clearly. A rare name scores low even when it is said perfectly, so a low score alone never flags. `listened` is false for captions timed before Slopify recorded what it heard: there an empty `saidAs` means nobody listened, not that the name came out right, and making the captions again fills it in for nothing but time. Nothing is listened to again, re-aligned or changed by this tool.",
     },
     {
         name: "get_narration_aliases",

package/dist/patch-notes/4.3.0.md

@@ -0,0 +1,21 @@
+# Slopify 4.3.0
+
+Released 9 November 2026.
+
+4.2.0 could tell you how *clearly* the voice said a name. It could not tell you *which* name it said. This release closes that, using something the computer was already working out and throwing away.
+
+## What the voice actually said
+
+- **The YouTube section now lists the names that came out as another sound,** with the letters the timing model heard, how many of its mentions came out that way, and the IPA you asked for beside them — `Lolth · 28 said · “loth” · 25 of 28 · you asked for /lɒlθ/`. This is the one thing confidence can never show: a name mispronounced the same way in every mention scores as well as one said right, so the spread in 4.2.0 saw nothing.
+- **It costs nothing and listens to nothing twice.** Timing the captions already decodes every window to check the audio against the transcript at all; that same decode over one word's own frames is the letters the model heard there. Slopify now keeps them wherever they are not the word itself. On a two-hour narration about five words in a hundred carry them.
+- **Spelling that is only spelling is folded away first.** The model writes what it hears and has no idea how a name is spelled: on a real two-hour narration it wrote “creeg” for Kreeg, “bell” for Bel, “tier” for Tyr, “drist” for Drizzt and “fandelver” for Phandelver — every one of them the name said correctly. All of those are folded out and none is reported, while a name heard as a sound it does not spell is kept.
+- **One mention never decides.** A name is listed only where one other sound covers six in ten of at least three mentions. On that same video it names three of the hundred and fifty names the video tracks, and leaves the rest alone — `Elturel` among them, heard as “elterel” thirty-three times of a hundred and forty-five, which is real and is not most of them.
+- **The letters are a second model listening, not a verdict,** and the page says so. A name whose spelling is nothing like its sound can be listed although the voice read it correctly; read the letters against the IPA, and if what came out is wrong, change that name's IPA in **Name pronunciations** and narrate again.
+
+## An older video says so instead of passing
+
+Captions timed before this release carry none of this, and a name with nothing against it there was never listened to — which is not the same as a name that came out right. The check says that plainly rather than calling the video clean. Making its captions again fills it in and costs nothing but time.
+
+## For agents
+
+- `check_narration_names` gains `saidAs` and `ipa` on every name, `different` for the names most of whose mentions came out as another sound, and `listened` for whether the timing was ever listened to at all.

package/dist/patch-notes/index.json

@@ -1,4 +1,10 @@
 [
+  {
+    "id": "4.3.0",
+    "title": "Slopify 4.3.0",
+    "version": "4.3.0",
+    "date": "2026-11-09"
+  },
   {
     "id": "4.2.0",
     "title": "Slopify 4.2.0",

package/dist/slices/narration/pronunciation-check.js

@@ -7,6 +7,47 @@ import { withSharedGlossary } from "./shared-glossary.js";
 // flags. Eight mentions is the fewest from which the 10th and 90th percentiles mean anything.
 export const heardMinMentions = 8;
 export const heardSpreadFlag = 0.3;
+// A name counts as said differently when most of its mentions came out as the same other sound.
+// Three mentions is the fewest where "every time" means anything, and six in ten keeps a name
+// the voice says both ways out of it: that one belongs under `uneven`, which is about mentions
+// disagreeing with each other.
+export const differentMinMentions = 3;
+export const differentShare = 0.6;
+// Pairs of letters that spell one sound, folded so that a spelling and a sound are comparable.
+// The timing model writes down what it hears, letter by letter, with no idea how the name is
+// spelled: it writes CREEG for Kreeg, BELL for Bel, TIER for Tyr and DRIST for Drizzt, all of
+// which are the name said correctly. Only the pairs that are the same sound in English however
+// they are written are here — EA is not (heart, beat), nor CH (chair, loch) — so a fold that
+// cancels is good evidence and one that does not is still only evidence.
+const sameSound = [
+    ["PH", "F"],
+    ["CK", "K"],
+    ["QU", "KW"],
+    ["X", "KS"],
+    ["EE", "I"],
+    ["OO", "U"],
+    ["OU", "U"],
+    ["AI", "A"],
+    ["AY", "A"],
+    ["IE", "I"],
+    ["OA", "O"],
+    ["AU", "O"],
+    ["AW", "O"],
+    ["C", "K"],
+    ["Z", "S"],
+    ["Y", "I"],
+];
+// One name or one hearing of it, reduced to roughly the sounds in it: everything that is only
+// spelling is dropped, so two spellings of the same sound meet here and two sounds do not.
+export function soundKey(text) {
+    let key = text.toUpperCase().replace(/[^\p{Lu}]+/gu, "");
+    for (const [pair, sound] of sameSound)
+        key = key.replaceAll(pair, sound);
+    return key
+        .replace(/(.)\1+/gu, "$1")
+        .replace(/E$/u, "")
+        .replace(/E?S$/u, "");
+}
 // The entries narration pronounces with, assembled the way `recipe-text.ts` assembles them.
 // Parsed twice: once under the rules the project narrates with, which is what actually guides
 // the voice, and once under the current rules, which is the fullest list of names the sources
@@ -154,25 +195,56 @@ corpus) {
     // A word of the timing is one word, so a term of several reaches it a part at a time, and a
     // hyphenated name may arrive whole or in parts. A part that is an ordinary word of this text
     // ("Hall" of "Mithral Hall", in a video that also says "hall") is left out, as it is above.
+    // A term stands as it is written, in lower case too ("tiefling"), but a part of a longer
+    // term has to look like a name on its own: the "and" of a term that has one is a word.
     for (const entry of nameCandidates(listed, heardText))
-        for (const part of [entry.term, ...entry.term.split(/[\s‐‑-]+/u)])
-            if (part.length >= 3 && !wanted.has(part.toLowerCase()) && !ordinaryWord(part, lowercased))
-                wanted.set(part.toLowerCase(), part);
+        for (const [at, part] of [entry.term, ...entry.term.split(/[\s‐‑-]+/u)].entries())
+            if (part.length >= 3 &&
+                (at === 0 || /^\p{Lu}/u.test(part)) &&
+                !wanted.has(part.toLowerCase()) &&
+                !ordinaryWord(part, lowercased))
+                // The IPA belongs to the whole term, so only the term itself carries it: a part said
+                // alone is exactly the mention nothing pronounced.
+                wanted.set(part.toLowerCase(), { name: part, ipa: part === entry.term ? entry.ipa : [] });
     const scored = words.flatMap((word) => typeof word.confidence === "number" ? [word.confidence] : []);
     const by = new Map();
     for (const word of words) {
         if (typeof word.confidence !== "number")
             continue;
-        const name = wanted.get(spokenName(word.text).toLowerCase());
-        if (name === undefined)
+        const found = wanted.get(spokenName(word.text).toLowerCase());
+        if (found === undefined)
             continue;
-        by.set(name, [...(by.get(name) ?? []), word.confidence]);
+        const row = by.get(found.name) ?? {
+            ipa: found.ipa,
+            scores: [],
+            said: new Map(),
+        };
+        row.scores.push(word.confidence);
+        // Letters only, so one mention's punctuation never splits a spelling in two.
+        const letters = word.heard?.toUpperCase().replace(/[^\p{L}' ]+/gu, "");
+        if (letters !== undefined && letters !== "")
+            row.said.set(letters, (row.said.get(letters) ?? 0) + 1);
+        by.set(found.name, row);
     }
     const names = [...by.entries()]
-        .map(([name, values]) => {
-        const sorted = [...values].sort((a, b) => a - b);
+        .map(([name, row]) => {
+        const sorted = [...row.scores].sort((a, b) => a - b);
         const low = percentile(sorted, 0.1);
         const high = percentile(sorted, 0.9);
+        // Only the hearings that are another sound: a decode that spells the name differently
+        // (CREEG for Kreeg) is the name, and saying so would be noise, not a finding.
+        const saidAs = [...row.said.entries()]
+            .filter(([letters]) => soundKey(letters) !== soundKey(name))
+            .map(([letters, mentions]) => ({ letters, mentions }))
+            .sort((a, b) => b.mentions - a.mentions || a.letters.localeCompare(b.letters, "en"));
+        // The mentions that came out as one sound, whichever ways they were spelled, against the
+        // name's own: CREEG and KREEG are one hearing of Kreeg, and that hearing is the name.
+        const key = soundKey(name);
+        const sounds = new Map();
+        for (const [letters, mentions] of row.said)
+            if (soundKey(letters) !== key)
+                sounds.set(soundKey(letters), (sounds.get(soundKey(letters)) ?? 0) + mentions);
+        const elsewhere = [...sounds.values()].sort((a, b) => b - a)[0] ?? 0;
         return {
             name,
             mentions: sorted.length,
@@ -181,12 +253,21 @@ corpus) {
             high,
             spread: high - low,
             uneven: sorted.length >= heardMinMentions && high - low >= heardSpreadFlag,
+            saidAs,
+            ipa: row.ipa,
+            different: sorted.length >= differentMinMentions && elsewhere >= sorted.length * differentShare,
         };
     })
         .sort((a, b) => b.spread - a.spread || a.name.localeCompare(b.name, "en"));
     return {
         names,
         uneven: names.filter((row) => row.uneven),
+        // A name the voice renamed outright is worse than one it said two ways, so the worst share
+        // of mentions leads.
+        different: names
+            .filter((row) => row.different)
+            .toSorted((a, b) => (b.saidAs[0]?.mentions ?? 0) / b.mentions - (a.saidAs[0]?.mentions ?? 0) / a.mentions ||
+            b.mentions - a.mentions),
         words: scored.length,
         confidence: scored.length === 0 ? 0 : scored.reduce((sum, value) => sum + value, 0) / scored.length,
     };
@@ -212,15 +293,26 @@ export function namesAheadNotice(result) {
 // heard saying more than one way. Null when there is nothing to say.
 export function narratedNotice(narrated, heard) {
     const guessed = narrated?.names.filter((row) => row.proper) ?? [];
-    const uneven = heard?.uneven ?? [];
-    if (guessed.length === 0 && uneven.length === 0)
+    const uneven = heard?.uneven.filter((row) => !row.different) ?? [];
+    const different = heard?.different ?? [];
+    if (guessed.length === 0 && uneven.length === 0 && different.length === 0)
         return null;
     const parts = [];
+    // First, because it is the only finding that says the video is wrong rather than unguided.
+    if (different.length > 0)
+        parts.push(`${different.length === 1 ? "1 name came" : `${String(different.length)} names came`} out ` +
+            `as another sound (${different
+                .slice(0, 4)
+                .map((row) => `${row.name} as “${(row.saidAs[0]?.letters ?? "").toLowerCase()}”`)
+                .join(", ")}${different.length > 4 ? ` and ${String(different.length - 4)} more` : ""})`);
     if (guessed.length > 0)
         parts.push(`the voice guessed ${guessed.length === 1 ? "1 name" : `${String(guessed.length)} names`} ` +
             `(${list(guessed)})`);
     if (uneven.length > 0)
         parts.push(`${uneven.length === 1 ? "1 name was" : `${String(uneven.length)} names were`} heard more ` +
             `than one way (${list(uneven)})`);
-    return `Names in this narration: ${parts.join(", and ")}. Open the check to see every mention.`;
+    const sentence = parts.length === 1
+        ? (parts[0] ?? "")
+        : `${parts.slice(0, -1).join(", ")}, and ${parts.at(-1) ?? ""}`;
+    return `Names in this narration: ${sentence}. Open the check to see every mention.`;
 }

package/dist/slices/rebuild/runtime-subtitles.js

@@ -33,6 +33,9 @@ export const wordsSchema = z.object({
         start: z.number().finite().nonnegative(),
         end: z.number().finite().positive(),
         confidence: z.number().optional(),
+        // What the timing model heard here, when that is not this word (`window.ts#heardAs`).
+        // Older timing files have it nowhere; a word said as written has it either way.
+        heard: z.string().optional(),
         // A multi-voice run's speaker id and script turn (`voices/timing.ts`).
         speaker: z.string().optional(),
         turn: z.number().int().positive().optional(),
@@ -40,6 +43,10 @@ export const wordsSchema = z.object({
     omissions: z
         .array(z.object({ start: z.number().finite().nonnegative(), text: z.string() }))
         .default([]),
+    // Whether this timing was written by a build that records what the model heard. Without it,
+    // a name with nothing against it was never listened to, which is not the same as a name that
+    // came out right, and the name check says so instead of guessing.
+    listened: z.boolean().default(false),
 });
 const cuesSchema = z.object({
     cues: z.array(z.object({
@@ -124,7 +131,12 @@ async function timing(deps, context, piece, snapshot) {
     if (captionCues(words).length === 0)
         throw new Error(`None of the narration could be matched to the article text, so captions can't be timed. The narration must be in the project's language (${editSettings.language}); if you uploaded your own audio, make sure it reads the article text, then Try again.`);
     context.signal.throwIfAborted();
-    const output = preparedText(deps, context, piece, "subtitle_words", "subtitles.json", JSON.stringify({ key: piece.logicalFingerprint ?? piece.fingerprint, words, omissions }));
+    const output = preparedText(deps, context, piece, "subtitle_words", "subtitles.json", JSON.stringify({
+        key: piece.logicalFingerprint ?? piece.fingerprint,
+        words,
+        omissions,
+        listened: true,
+    }));
     await publishResult(deps, context, piece, [output], { words, omissions }, output.asset);
     return "done";
 }

package/dist/tutorials/Narration-Aliases-and-Glossary.md

@@ -181,6 +181,14 @@ The **YouTube** section carries the same line, saying two things.
 
 The spread is the signal, not a low score. A rare name is heard poorly even when it is said perfectly, so only a name whose own mentions disagree with each other is flagged: eight mentions or more, and a spread of 0.30 or more between its 10th and 90th percentile.
 
+**What came out.** The timing model writes down the letters it heard over a word whenever they are not the word itself, so **Came out as** shows how a name was actually said, next to how many of its mentions came out that way — `“eltarel” · 21 of 21` — and **You asked for** shows the IPA your glossary gave it. This is the one part of the check that can catch a name said wrong the *same* way every time: that name scores high and scores evenly, so nothing above it would ever flag.
+
+Spelling is folded away before anything is compared, because the model writes what it hears and has no idea how the name is spelled. It writes “creeg” for Kreeg, “bell” for Bel, “tier” for Tyr and “drist” for Drizzt — all of them the name said correctly — and none of those is reported. What is reported is a sound the name does not spell, in most of its mentions: six in ten or more, over at least three.
+
+Read the letters rather than trust them: they come from a second model listening, not from a verdict, and a word that is spelled unlike how it sounds can still be named although it was said right. If what came out is wrong, change the name's IPA in **Name pronunciations** and narrate again; if it sounds right to you, nothing needs doing.
+
+If the captions were timed before Slopify started keeping this, the check says so instead of calling the names right. Making the captions again fills it in and costs nothing but time.
+
 A name read as an ordinary English word is left out of both checks: a one-word name that the same text also writes in lower case is a word here and not a name, which is why "Hall" stays quiet in a video that also says "hall".
 
 ## Which one do I use?