@gentbajko/slopify 4.1.0 → 4.3.0

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

@@ -0,0 +1,318 @@
+import { parsePronunciationGlossary, pronunciationMatches, pronunciationSpans, } from "./pronunciation.js";
+import { libraryGlossary } from "./pronunciations-library.js";
+import { withSharedGlossary } from "./shared-glossary.js";
+// Measured over the 30 finished videos in this install: "Do'Urden" spreads 0.36 in both videos
+// that say it and is heard several ways, while "Gygax" — a rare name the aligner always scores
+// low — never spreads past 0.29 in the 26 videos that say it, so a low score on its own never
+// 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
+// name at all — a hyphenated term rules 1 had to skip is still a name this video says.
+export function pronunciationEntries(sources) {
+    const under = (rules) => {
+        const own = parsePronunciationGlossary(sources.glossary, sources.language, rules);
+        const list = libraryGlossary(sources.list, sources.language, rules);
+        return withSharedGlossary(list.ok ? list.entries : [], withSharedGlossary(own.ok ? own.entries : [], sources.shared));
+    };
+    return { guiding: under(sources.rules), listed: under(2) };
+}
+// Delivery tags are the preparation's instructions to the voice, not words it reads, so a name
+// inside one is not a mention. Blanked, not removed, so every offset still points at the text.
+function withoutTags(source) {
+    return source.replace(/\[[^\]\n]*\]/gu, (tag) => " ".repeat(tag.length));
+}
+// Everything between a pair of slashes already reached the voice as IPA. Whitespace inside is
+// never IPA, which keeps an "and/or … his/her" in ordinary prose from reading as a span.
+function ipaRanges(source) {
+    return Array.from(source.matchAll(/\/[^/\s]+\//gu), (match) => [match.index, match.index + match[0].length]);
+}
+// The names to look for: every term the sources name, and — because a two-word term never
+// matches one of its words said alone ("Belwar Dissengulp" listed, "Belwar" spoken) — each
+// capitalised word of a longer term as a name of its own.
+//
+// A one-word name of four letters or more that the text also writes in lower case is an
+// ordinary English word here, not a name: the pooled copy of the other projects' glossaries
+// carries "Hall" (of "Mithral Hall"), "Quick" and "Claw", and an article that also says "halls"
+// or "quickly" is not mispronouncing them. An ending of one or two letters counts as the same
+// word, which is why "quickly" speaks for "Quick"; more than that does not, so "torment" leaves
+// the god Torm alone. A term of several words, or a short one like "Bel", is never read this way.
+function lowercaseWords(source) {
+    const words = new Set();
+    for (const match of source.matchAll(/(?<![\p{L}\p{N}'’-])\p{Ll}[\p{L}'’-]*/gu)) {
+        const word = match[0];
+        words.add(word);
+        if (word.length > 1)
+            words.add(word.slice(0, -1));
+        if (word.length > 2)
+            words.add(word.slice(0, -2));
+    }
+    return words;
+}
+function ordinaryWord(term, lowercased) {
+    return (term.length >= 4 &&
+        !term.includes(" ") &&
+        // Only a name written with a capital can be mistaken for one: a term the glossary itself
+        // writes in lower case ("drow", "lich", "tiefling") is a common word by its own spelling,
+        // and is told apart by `proper` rather than left out.
+        /^\p{Lu}/u.test(term) &&
+        lowercased.has(term.toLowerCase()));
+}
+function nameCandidates(entries, source) {
+    const lowercased = lowercaseWords(source);
+    const candidates = new Map();
+    for (const entry of entries) {
+        if (ordinaryWord(entry.term, lowercased))
+            continue;
+        candidates.set(entry.term.toLowerCase(), entry);
+    }
+    for (const entry of entries) {
+        const words = entry.term.split(" ");
+        if (words.length < 2)
+            continue;
+        for (const [index, word] of words.entries()) {
+            const key = word.toLowerCase();
+            if (word.length < 3 || !/^\p{Lu}/u.test(word))
+                continue;
+            if (candidates.has(key) || ordinaryWord(word, lowercased))
+                continue;
+            candidates.set(key, { term: word, ipa: [entry.ipa[index] ?? ""] });
+        }
+    }
+    return [...candidates.values()];
+}
+function countUnguided(source, entries, guided) {
+    const text = withoutTags(source);
+    const rows = new Map();
+    // Possessives are always matched here, whatever the project's rules: a possessive the rules
+    // never wrapped is exactly the mention that reached the voice as written.
+    for (const match of pronunciationMatches(text, nameCandidates(entries, text), true)) {
+        if (guided.some(([from, to]) => match.start < to && match.end > from))
+            continue;
+        // Named by what the text says, not by the glossary's spelling of the term.
+        const said = text.slice(match.start, match.end);
+        const name = said.replace(/['’]s$/u, "");
+        const row = rows.get(name) ?? { plain: 0, possessive: 0, proper: /^\p{Lu}/u.test(name) };
+        if (match.possessive === undefined)
+            row.plain++;
+        else
+            row.possessive++;
+        rows.set(name, row);
+    }
+    const total = (row) => row.plain + row.possessive;
+    const names = [...rows.entries()]
+        .map(([name, row]) => ({ name, ...row }))
+        .sort((a, b) => Number(b.proper) - Number(a.proper) ||
+        total(b) - total(a) ||
+        a.name.localeCompare(b.name, "en"));
+    return {
+        names,
+        mentions: names.reduce((sum, row) => sum + total(row), 0),
+        proper: names.filter((row) => row.proper).reduce((sum, row) => sum + total(row), 0),
+    };
+}
+// Before the narration runs: the names this text says that the voice will have to invent. What
+// narration will wrap is `pronunciationSpans` itself, under the project's own rules, so a
+// project that narrates without possessives is told about its possessives and a newer one is not.
+export function namesAhead(text, sources, possessives) {
+    const { guiding, listed } = pronunciationEntries(sources);
+    const plain = withoutTags(text);
+    const guided = pronunciationSpans(plain, guiding, possessives).map((span) => [span.start, span.end]);
+    return countUnguided(plain, listed, guided);
+}
+// After the render: the same names, counted from the voice script, which is exactly the text the
+// voice was sent. A name with no IPA in front of it there was guessed, whatever the glossary says.
+export function namesNarrated(script, sources) {
+    const { listed } = pronunciationEntries(sources);
+    return countUnguided(script, listed, ipaRanges(withoutTags(script)));
+}
+// A word as the aligner read it: "Do'Urden," is the name, "Drizzt's" is the name too.
+function spokenName(text) {
+    return text
+        .replace(/^[^\p{L}\p{N}]+/u, "")
+        .replace(/[^\p{L}\p{N}'’-]+$/u, "")
+        .replace(/['’]s$/u, "");
+}
+function percentile(sorted, fraction) {
+    const at = Math.round(fraction * (sorted.length - 1));
+    return sorted[Math.min(sorted.length - 1, Math.max(0, at))] ?? 0;
+}
+// How the finished narration was heard saying each name, from the confidence the subtitle timing
+// already carries. Nothing here is listened to again and nothing is re-aligned: the numbers are
+// the ones written when the captions were timed.
+export function heardNames(words, sources, 
+// The narration as it was written: the corpus the candidates are judged against, so a pooled
+// "Hall" is left alone in a video that also says "hall" (see `nameCandidates`). The words as
+// the aligner wrote them down stand in when the narration itself is not at hand.
+corpus) {
+    const { listed } = pronunciationEntries(sources);
+    const heardText = corpus ?? words.map((word) => word.text).join(" ");
+    const lowercased = lowercaseWords(heardText);
+    const wanted = new Map();
+    // 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 [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 found = wanted.get(spokenName(word.text).toLowerCase());
+        if (found === undefined)
+            continue;
+        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, 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,
+            mean: sorted.reduce((sum, value) => sum + value, 0) / sorted.length,
+            low,
+            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,
+    };
+}
+const list = (names, most = 6) => {
+    const shown = names.slice(0, most).map((row) => row.name);
+    const rest = names.length - shown.length;
+    return rest === 0 ? shown.join(", ") : `${shown.join(", ")} and ${String(rest)} more`;
+};
+// The one line before the narration is paid for. Names the names, says what will happen to them,
+// and says the one place that fixes them for every video at once.
+export function namesAheadNotice(result) {
+    const proper = result.names.filter((row) => row.proper);
+    if (proper.length === 0)
+        return null;
+    return (`${proper.length === 1 ? "1 name" : `${String(proper.length)} names`} in this article ` +
+        `${proper.length === 1 ? "has" : "have"} no pronunciation anywhere, so the voice will guess ` +
+        `${proper.length === 1 ? "it" : "them"}: ${list(proper)}. ` +
+        `To decide how they are said, add them to Settings → Voices → Name pronunciations, then make ` +
+        `the narration.`);
+}
+// The one line on the upload section, after the render: what the voice guessed, and what it was
+// 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.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)})`);
+    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/narration/pronunciation.js

@@ -3,6 +3,10 @@ import remarkGfm from "remark-gfm";
 import { internalError } from "../../kernel/errors.js";
 import { createRows, editSettings } from "../../kernel/ports/settings-places.js";
 import { remembered } from "../../kernel/remembered.js";
+// How long Settings → Voices → Pronunciation's own list may be, and with it the copy a project
+// carries (`slices/narration/pronunciations-library.ts`). Long enough for a channel's whole cast
+// of names.
+export const libraryPronunciationsMax = 100_000;
 export const currentPronunciationRules = 2;
 export function pronunciationRulesOf(config) {
     return config.pronunciationRules ?? 1;

package/dist/slices/narration/pronunciations-library.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { fingerprint } from "../../kernel/runner/work.js";
+import { actors } from "../agents/model.js";
+import { deleteSetting, readJsonSetting, readSetting, writeSetting } from "../settings/repo.js";
+import { libraryPronunciationsMax, parsePronunciationGlossary, } from "./pronunciation.js";
+// Settings → Voices → Name pronunciations: one Pronunciation Glossary of your own, in the same
+// `Term: /ipa/` lines an article's own glossary uses. Its entries come before the article's, so
+// a name keeps the same pronunciation in every video however each article spells it out. A
+// project takes a copy when it starts (and again when Edit project refreshes it), so a change
+// here never alters a project's narration behind its back. Aliases on the Pronunciation page are
+// the other half: they change the words, this changes the sounds.
+export const libraryPronunciationsKey = "narration.pronunciations";
+const savedKey = "narration.pronunciations.saved";
+const savedRow = z
+    .object({ at: z.string().min(1).max(40), by: z.enum(actors) })
+    .strict()
+    .readonly();
+export function readLibraryPronunciations(db) {
+    const saved = readJsonSetting(db, savedKey, savedRow, undefined);
+    return {
+        ...describeLibraryPronunciations(readSetting(db, libraryPronunciationsKey) ?? ""),
+        ...(saved === undefined ? {} : { savedAt: saved.at, savedBy: saved.by }),
+    };
+}
+export function describeLibraryPronunciations(text) {
+    const parsed = parsePronunciationGlossary(text);
+    return {
+        text,
+        terms: parsed.ok ? parsed.entries.length : 0,
+        version: versionOf(text),
+        ...(parsed.ok && parsed.skipped !== undefined ? { skipped: parsed.skipped } : {}),
+        ...(parsed.ok && parsed.unpronounced !== undefined
+            ? { unpronounced: parsed.unpronounced }
+            : {}),
+    };
+}
+// Short enough to pass around and read in a refusal, long enough never to collide.
+export function versionOf(text) {
+    return fingerprint({ pronunciations: text.trim() }).slice(0, 16);
+}
+// `version` is the list the save was made from. It is required once a list exists: a save
+// without it, or from an older one, is refused rather than replacing what somebody else wrote
+// in another window or through an agent.
+export function saveLibraryPronunciations(deps, text, version, by = "person") {
+    if (typeof text !== "string")
+        return {
+            ok: false,
+            reason: "refused",
+            detail: "Write the list as Term: /ipa/ lines, one name per line.",
+        };
+    if (text.length > libraryPronunciationsMax)
+        return {
+            ok: false,
+            reason: "refused",
+            detail: `Keep the list under ${String(libraryPronunciationsMax)} characters; it is ${String(text.length)} now. Remove the names you no longer narrate, then Save.`,
+        };
+    const current = readLibraryPronunciations(deps.db);
+    if (current.text !== "" && version !== current.version)
+        return {
+            ok: false,
+            reason: "conflict",
+            detail: conflictDetail(current, version),
+            current,
+        };
+    const trimmed = text.trim();
+    if (trimmed === "")
+        deleteSetting(deps.db, libraryPronunciationsKey);
+    else
+        writeSetting(deps.db, libraryPronunciationsKey, trimmed);
+    writeSetting(deps.db, savedKey, JSON.stringify({ at: deps.clock.now().toISOString(), by }));
+    return { ok: true, list: readLibraryPronunciations(deps.db) };
+}
+// Said to whoever sent the save: the person at the page, or an agent reading a refusal. It
+// names what the list is now and the one step that keeps their own work.
+function conflictDetail(current, version) {
+    const who = current.savedBy === "agent"
+        ? " by an agent"
+        : current.savedBy === "assistant"
+            ? " by the assistant"
+            : "";
+    const when = current.savedAt === undefined ? "" : ` at ${current.savedAt}`;
+    const names = `${String(current.terms)} ${current.terms === 1 ? "name" : "names"}`;
+    return version === undefined
+        ? `The list has ${names} already, saved${who}${when}. Read it first and send your save with the version it gives, so this one does not replace what is there.`
+        : `The list changed since this save was prepared: it has ${names} now, saved${who}${when}. Read it again and save with the version it gives; on the page, Save mine anyway keeps what is on screen.`;
+}
+// The entries a project's copy pronounces, under the project's own language and rules. An
+// unparseable list is never fatal: its bad rows are skipped, and the editor is where they are
+// named (the run's notices number the rows of the article's glossary, not of this list).
+export function libraryGlossary(text, language, rules) {
+    if (text === undefined || text.trim() === "")
+        return { ok: true, entries: [] };
+    return parsePronunciationGlossary(text, language, rules);
+}

package/dist/slices/rebuild/recipe-text.js

@@ -12,6 +12,7 @@ import { splitEndMatter } from "../article/split.js";
 import { withEarlierEpisodes } from "../episodes/related.js";
 import { withoutSlopifyScene } from "../images/scenes.js";
 import { parsePronunciationGlossary, pronunciationRulesOf, } from "../narration/pronunciation.js";
+import { libraryGlossary } from "../narration/pronunciations-library.js";
 import { withSharedGlossary } from "../narration/shared-glossary.js";
 import { researchDocuments } from "../research/documents.js";
 import { plannerMessages, subAgentMessages } from "../research/planner.js";
@@ -333,12 +334,23 @@ export function narrationGlossary(context) {
     const markdown = articleMarkdownOf(context);
     return glossaryOf(context, markdown === null ? null : splitEndMatter(markdown));
 }
-// The project's own glossary, then the other projects' pronunciations it copied, when it
-// shares them. Rows the own glossary had to skip are still reported.
+// Your own pronunciation list first, then the project's own glossary, then the other projects'
+// pronunciations it copied, when it shares them. The list wins so a name is said the same way in
+// every video however this article spelled it out. Rows the own glossary had to skip are still
+// reported; rows the list had to skip are named in its editor, where they can be fixed.
 function withShared(own, config) {
-    if (!own.ok || config.audio?.shareGlossary !== true)
+    if (!own.ok)
         return own;
-    return { ...own, entries: withSharedGlossary(own.entries, config.sharedGlossary) };
+    const list = libraryGlossary(config.libraryPronunciations, config.language, pronunciationRulesOf(config));
+    const shared = config.audio?.shareGlossary === true ? config.sharedGlossary : undefined;
+    if (!list.ok)
+        return list;
+    if (list.entries.length === 0 && shared === undefined)
+        return own;
+    return {
+        ...own,
+        entries: withSharedGlossary(list.entries, withSharedGlossary(own.entries, shared)),
+    };
 }
 function withSampleScope(prompt, sample) {
     return sample === undefined || sample.fullScript

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/Create-Narration.md

@@ -83,7 +83,7 @@ It needs the Inworld TTS-2 model. With several speakers it works per speaker: ea
 
 | Option | What it does | Default |
 | --- | --- | --- |
-| **Use the article's pronunciation glossary** | Shown only for voices that read it. Reads names with the IPA in the article's Pronunciation Glossary, such as `Arda: /ˈɑɹdə/`, with no extra AI call. Works with Inworld TTS-2 and TTS-2 Flash. The written text stays unchanged. | On |
+| **Use pronunciations** | Shown only for voices that read IPA. Reads names with the IPA they are given, with no extra AI call: your **Name pronunciations** list first, so a listed name sounds the same in every video, then the article's own Pronunciation Glossary, such as `Arda: /ˈɑɹdə/`. Works with Inworld TTS-2 and TTS-2 Flash. The written text stays unchanged. | On |
 | **Also use pronunciations from my other projects** | Adds every term from your other projects' glossaries, copied when this project starts. This project's own glossary wins where they differ. Turn it off to use only this article's glossary. | On |
 
 With another service or model the tick is not shown; your choice is kept for when you pick an Inworld TTS-2 voice.

package/dist/tutorials/Editing-a-Project.md

@@ -62,6 +62,7 @@ When the narration was spoken as one whole request, the section says so: editing
 
 | Control | What it does |
 | --- | --- |
+| **Use pronunciations** → **Copy the list again** | Copies your **Name pronunciations** (Settings → Voices) into this project again, so a name you corrected there is said the new way here too. A change to the list reaches the project only when you press this. After you save, only the chunks where a changed name appears are spoken again, paid per character. |
 | **Also use pronunciations from my other projects** → **Update from other projects** | Copies your other projects' Pronunciation Glossary terms into this project again, picking up any added since the last copy. After you save, only the chunks whose words those terms change are spoken again, paid per character. |
 | **Use your pronunciation list** → **Copy the list again** | Copies your Pronunciation list (Settings → Voices → **Pronunciation**) into this project again. A change to the list reaches the project only when you press this. After you save, only the chunks the changed aliases touch are spoken again. |
 | **Describe tables and figures in the narration** | The AI writes a short spoken passage for each table, figure, equation and code block. Turning it on costs one AI call per block, and after you save the chunks that contain a block are spoken again (the whole narration when it is spoken as one request). **Leave code out** skips code blocks. |