@gentbajko/slopify 4.1.0 → 4.2.0

package/dist/edge/http/app.js

@@ -39,6 +39,7 @@ import { problem, problemFromError } from "./problem.js";
 import { projectTemplateRoutes } from "./project-templates.js";
 import { projectRoutes } from "./projects.js";
 import { promptRoutes } from "./prompts.js";
+import { pronunciationCheckRoutes } from "./pronunciation-check.js";
 import { pronunciationRoutes } from "./pronunciations.js";
 import { providerRoutes } from "./providers.js";
 import { remoteAccessRoutes } from "./remote-access.js";
@@ -103,6 +104,7 @@ function apiRoutes(deps, startedAt, runAllowed) {
         .route("/projects", openFolderRoutes(deps))
         .route("/projects", audioPreviewRoutes(deps))
         .route("/projects", narrationPeakRoutes(deps))
+        .route("/projects", pronunciationCheckRoutes(deps))
         .route("/projects", runCostRoutes(deps))
         .route("/projects", uploadedRoutes(deps))
         .route("/home", homeRoutes(deps))

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

@@ -0,0 +1,133 @@
+import { readFileSync } from "node:fs";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { usesPronunciationGlossary } from "../../slices/admission/rules.js";
+import { splitEndMatter } from "../../slices/article/split.js";
+import { pronunciationRulesOf, readsPossessives } from "../../slices/narration/pronunciation.js";
+import { heardNames, namesAhead, namesAheadNotice, namesNarrated, narratedNotice, } from "../../slices/narration/pronunciation-check.js";
+import { wordsSchema } from "../../slices/rebuild/runtime-subtitles.js";
+import { currentRevisionId } from "../../slices/revisions/repo.js";
+import { getRevisionView, isReadyOutput, readyOutput } from "../../slices/revisions/view.js";
+import { outputPath } from "../../slices/storage/layout.js";
+import { projectTitle } from "../../slices/storage/repo.js";
+import { projectIdParam } from "./ids.js";
+import { onInvalid, problem } from "./problem.js";
+function sourcesOf(config, view) {
+    const glossary = usesPronunciationGlossary(config) && view.articleMarkdown !== null
+        ? splitEndMatter(view.articleMarkdown).glossary
+        : "";
+    return {
+        glossary,
+        ...(config.libraryPronunciations === undefined ? {} : { list: config.libraryPronunciations }),
+        ...(config.audio?.shareGlossary === true && config.sharedGlossary !== undefined
+            ? { shared: config.sharedGlossary }
+            : {}),
+        ...(config.language === undefined ? {} : { language: config.language }),
+        rules: pronunciationRulesOf(config),
+    };
+}
+// Every segment of one kind of narration file, in spoken order, joined: the intro, the body and
+// the outro are one piece of narration for counting.
+function narrationText(deps, projectId, view, role) {
+    const order = (segment) => segment === "intro" ? 0 : segment === "outro" ? 2 : 1;
+    const parts = view.outputs
+        .filter((row) => isReadyOutput(row, { role }))
+        .toSorted((left, right) => order(left.output.meta.segment) - order(right.output.meta.segment))
+        .flatMap((row) => {
+        try {
+            return [readFileSync(outputPath(deps.paths, projectId, row.output.path), "utf8")];
+        }
+        catch {
+            // A narration file removed by hand has nothing to count.
+            return [];
+        }
+    });
+    return parts.length === 0 ? null : parts.join("\n\n");
+}
+function timingWords(deps, projectId, view) {
+    const timing = readyOutput(view, { workKey: "subtitles:timing", role: "subtitle_words" });
+    if (timing === undefined)
+        return null;
+    try {
+        return wordsSchema.parse(JSON.parse(readFileSync(outputPath(deps.paths, projectId, timing.output.path), "utf8"))).words;
+    }
+    catch {
+        // Timing that is missing or unreadable means there is nothing to say about how it was heard.
+        return null;
+    }
+}
+export function pronunciationCheckRoutes(deps) {
+    const viewOf = (projectId) => {
+        const revisionId = currentRevisionId(deps.db, projectId);
+        return revisionId === undefined ? undefined : getRevisionView(deps, projectId, revisionId);
+    };
+    const missing = "This project no longer exists. Go back to Projects to pick another.";
+    return (new Hono()
+        // Before the narration is paid for: the names this article says that nothing pronounces,
+        // so the voice will invent them. Read from the narration text where the run has prepared
+        // it, else from the article itself.
+        .get("/:projectId/pronunciations/gaps", zValidator("param", projectIdParam, onInvalid), (c) => {
+        const { projectId } = c.req.valid("param");
+        if (projectTitle(deps.db, projectId) === undefined)
+            return problem(c, { status: 404, detail: missing });
+        c.header("Cache-Control", "no-store");
+        const view = viewOf(projectId);
+        if (view === undefined)
+            return c.json({
+                revisionId: null,
+                ready: false,
+                narrated: false,
+                ahead: null,
+                notice: null,
+            });
+        const config = view.revision.config;
+        const written = narrationText(deps, projectId, view, "narration_txt");
+        const text = written ??
+            (view.articleMarkdown === null ? null : splitEndMatter(view.articleMarkdown).body);
+        if (text === null || text.trim() === "")
+            return c.json({
+                revisionId: view.revision.id,
+                ready: false,
+                narrated: false,
+                ahead: null,
+                notice: null,
+            });
+        const ahead = namesAhead(text, sourcesOf(config, view), readsPossessives(config));
+        return c.json({
+            revisionId: view.revision.id,
+            ready: true,
+            narrated: narrationText(deps, projectId, view, "tts_script") !== null,
+            ahead,
+            notice: namesAheadNotice(ahead),
+        });
+    })
+        // After the render, before the upload: what reached the voice as written, counted from the
+        // voice script itself, and how the finished narration was heard saying each name, from the
+        // confidence the subtitle timing already carries.
+        .get("/:projectId/pronunciations/heard", zValidator("param", projectIdParam, onInvalid), (c) => {
+        const { projectId } = c.req.valid("param");
+        if (projectTitle(deps.db, projectId) === undefined)
+            return problem(c, { status: 404, detail: missing });
+        c.header("Cache-Control", "no-store");
+        const view = viewOf(projectId);
+        if (view === undefined)
+            return c.json({
+                revisionId: null,
+                narrated: null,
+                heard: null,
+                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 narrated = script === null ? null : namesNarrated(script, sources);
+        const heard = words === null ? null : heardNames(words, sources, written ?? script ?? undefined);
+        return c.json({
+            revisionId: view.revision.id,
+            narrated,
+            heard,
+            notice: narratedNotice(narrated, heard),
+        });
+    }));
+}

package/dist/edge/http/pronunciations.js

@@ -3,7 +3,10 @@ import { Hono } from "hono";
 import { z } from "zod";
 import { aliasCountMax } from "../../kernel/ports/narration-aliases.js";
 import { listNarrationAliases, saveNarrationAliases, } from "../../slices/narration/aliases-library.js";
+import { libraryPronunciationsMax } from "../../slices/narration/pronunciation.js";
+import { readLibraryPronunciations, saveLibraryPronunciations, } from "../../slices/narration/pronunciations-library.js";
 import { collectSharedGlossary } from "../../slices/narration/shared-glossary.js";
+import { actorOf } from "./actor.js";
 import { onInvalid, problem } from "./problem.js";
 // The pronunciations of every project's glossary, merged, for Edit project to copy into a
 // project that shares them. `except` leaves out the project being edited, whose own glossary
@@ -19,6 +22,29 @@ export function pronunciationRoutes(deps) {
             .regex(/^[0-9A-Za-z_-]*$/)
             .optional(),
     }), onInvalid), (c) => c.json(collectSharedGlossary(deps, c.req.valid("query").except)))
+        // Name pronunciations, the other half of the same page: one glossary of your own, whose
+        // names come before the glossary each article writes. Saved whole, like the aliases; the
+        // reply says what narration makes of it.
+        .get("/library", (c) => c.json(readLibraryPronunciations(deps.db)))
+        // `version` is the list the save was made from, as the read above gives it. Once a list
+        // exists a save without it, or from an older one, is refused with the list as it stands,
+        // so a second window or an agent can't quietly replace what somebody wrote.
+        .put("/library", zValidator("json", z.object({
+        text: z.string().max(libraryPronunciationsMax),
+        version: z.string().max(64).optional(),
+    }), onInvalid), (c) => {
+        const body = c.req.valid("json");
+        const result = saveLibraryPronunciations(deps, body.text, body.version, actorOf(c));
+        if (result.ok)
+            return c.json(result.list);
+        if (result.reason === "conflict")
+            return problem(c, {
+                status: 409,
+                detail: result.detail,
+                extensions: { current: result.current },
+            });
+        return problem(c, { status: 400, detail: result.detail });
+    })
         .get("/aliases", (c) => c.json({ aliases: listNarrationAliases(deps.db) }))
         // The editor saves the whole ordered list at once; each row is checked in the slice, so
         // the editor gets "Alias 3: …" sentences rather than schema paths.

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

@@ -148,6 +148,30 @@ export const libraryTools = [
         title: "Read the shared glossary",
         description: "The pronunciation glossary shared by every project.",
     },
+    {
+        name: "get_library_pronunciations",
+        route: "GET /api/pronunciations/library",
+        title: "Read your pronunciation list",
+        description: "Settings → Voices → Name pronunciations: your own glossary of Term: /ipa/ lines, whose names come before each article's glossary, with the rows narration skips and the version a save must carry.",
+    },
+    {
+        name: "set_library_pronunciations",
+        route: "PUT /api/pronunciations/library",
+        title: "Save your pronunciation list",
+        description: "Saves the whole list, like Save pronunciations. Body: {text} of Term: /ipa/ lines (or a Term | IPA table), and {version} as get_library_pronunciations gave it, so this save replaces nothing written meanwhile. A refusal (409) names what the list is now and hands it back: read its version, fold your change into that text, and send it again. New projects use the list; a project already started keeps its copy until Edit settings → Narration copies it again.",
+    },
+    {
+        name: "check_pronunciations",
+        route: "GET /api/projects/:projectId/pronunciations/gaps",
+        title: "Check a project's names before the narration is paid for",
+        description: "The names this article says that nothing pronounces — not its own Pronunciation Glossary, not your Name pronunciations list, not the pooled copy of the other projects' glossaries — so the voice will invent them. Each name with how often it is said plain and as a possessive, proper names first, and `notice` as the one line the project page shows. Read it while the narration is still unmade: adding the names with set_library_pronunciations settles them for every later video too. It changes nothing and costs nothing.",
+    },
+    {
+        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.",
+    },
     {
         name: "get_narration_aliases",
         route: "GET /api/pronunciations/aliases",

package/dist/patch-notes/4.2.0.md

@@ -0,0 +1,28 @@
+# Slopify 4.2.0
+
+Released 8 November 2026.
+
+This release is about names: deciding once how each one is said, and finding out — before you pay for a narration, and before you upload — whether the video said them right.
+
+## One list decides how a name is said
+
+- **Settings → Voices → Name pronunciations** takes a Pronunciation Glossary of your own, one `Term: /IPA/` per line, and its names come before the glossary each article writes. A name listed there sounds the same in every video, however that video's article spelled it out, so `Gygax` never drifts to `Gigax` between episodes. The page says how many names the list pronounces and names any line narration has to skip, by number and reason.
+- **Each project keeps the copy it started with,** like the narration aliases, so editing the list never changes a project behind its back. **Edit settings → Narration → Use pronunciations → Copy the list again** brings the new list in, and only the narration where a changed name appears is made again.
+- **The order, where two disagree:** an alias (it changes the words), then your Name pronunciations, then the article's own Pronunciation Glossary, then other projects' pronunciations while they are shared.
+- **"Use the article's pronunciation glossary" is now "Use pronunciations",** because the one switch covers both your list and the article's glossary. Inworld TTS-2 and TTS-2 Flash read IPA, as before; for any other voice an alias is still the way to fix a word.
+- **One save never replaces another.** Each save carries the version of the list it was made from. When a second window or an agent saved meanwhile, the save is refused with the list as it stands: the page names what changed, keeps what you typed, and offers **Save mine anyway** or **Load theirs instead**.
+
+## Does this video say the names right?
+
+Two checks on the project page, over files it already has. Neither blocks the run or the upload, neither costs anything, and neither changes a thing.
+
+- **Before the narration is paid for,** the **Narration** section says in one line which names this article uses that nothing pronounces — not its own Pronunciation Glossary, not your Name pronunciations list, not the pooled copy of the other projects' glossaries — and **Every mention** opens the table: each name, how often it is said as written and how often as a possessive, proper names first. It is the cheapest moment to settle a name, because adding it to the list costs nothing and the voice has not been paid yet.
+- **It catches the names a glossary looks like it covers and doesn't.** A two-word term is never matched by one of its words said alone, so an article that lists `Belwar Dissengulp` and then says `Belwar` on its own is named. So are possessives and hyphenated names in a project narrated under the old pronunciation rules, which never wrapped either: a project is judged by the rules it was voiced under, not by today's.
+- **After the render, before the upload,** the same line sits on the **YouTube** section and says two things. What the voice was actually sent, counted from the voice script itself — a name with no IPA in front of it there was guessed, whatever the glossary says. And how the finished narration was heard saying each name, read from the per-word confidence the subtitle timing already wrote when the captions were made.
+- **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 tenth and ninetieth percentile. Nothing is listened to again and nothing is re-aligned.
+- **Ordinary English words are left out of both.** A one-word name of four letters or more, written with a capital, that the same text also writes in lower case is a word there and not a name — so a pooled `Hall` stays quiet in a video that also says "hall", while a god called `Torm` does not.
+
+## For agents
+
+- `get_library_pronunciations` and `set_library_pronunciations` read and write the list, the save carrying `{text, version}`; a 409 names what the list is now and hands it back to save from.
+- `check_pronunciations` answers before the narration, `check_narration_names` after the render.

package/dist/patch-notes/index.json

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

package/dist/slices/admission/schema.js

@@ -7,6 +7,7 @@ import { documentSettingsSchema } from "../document/theme-schema.js";
 import { keywordFactsSchema } from "../keywords/schema.js";
 import { narrationAliasesSchema } from "../narration/aliases-schema.js";
 import { chunkModes } from "../narration/chunk.js";
+import { libraryPronunciationsMax } from "../narration/pronunciation.js";
 import { reviewModes, reviewStages } from "../reviews/model.js";
 import { socialSettingsSchema } from "../social/schema.js";
 import { subtitleConfigSchema } from "../subtitles/model.js";
@@ -72,6 +73,7 @@ export const runDraftSchema = z.object({
     })
         .optional(),
     narrationAliases: narrationAliasesSchema.optional(),
+    libraryPronunciations: z.string().max(libraryPronunciationsMax).optional(),
     pronunciationRules: z.union([z.literal(1), z.literal(2)]).optional(),
     sharedGlossary: z
         .array(z.object({

package/dist/slices/admission/start.js

@@ -8,6 +8,7 @@ import { keywordFactsFor } from "../keywords/facts.js";
 import { usesFacts } from "../keywords/rules.js";
 import { listNarrationAliases } from "../narration/aliases-library.js";
 import { currentPronunciationRules } from "../narration/pronunciation.js";
+import { readLibraryPronunciations } from "../narration/pronunciations-library.js";
 import { collectSharedGlossary } from "../narration/shared-glossary.js";
 import { admitInitialRevision } from "../rebuild/runtime-admission.js";
 import { adoptBaseline } from "../revisions/adopt.js";
@@ -117,6 +118,11 @@ projectId) {
     const aliases = draft.sources.audio === "generate" && draft.audio?.useNarrationAliases === true
         ? listNarrationAliases(deps.db)
         : [];
+    // Settings → Voices → Pronunciation's own glossary as it is now: the names this channel
+    // always says the same way, ahead of whatever this article's glossary spells out.
+    const pronunciations = usesPronunciationGlossary(draft)
+        ? readLibraryPronunciations(deps.db).text
+        : "";
     // The title may name keywords too ("History: {{Topic}}"), filled like a prompt's, so a
     // template or Play keeps the pattern and each project gets its own title.
     const title = render(draft.title, draft.values).trim() || draft.title;
@@ -142,6 +148,7 @@ projectId) {
         rendered,
         ...(shared.length === 0 ? {} : { sharedGlossary: shared }),
         ...(aliases.length === 0 ? {} : { narrationAliases: aliases }),
+        ...(pronunciations === "" ? {} : { libraryPronunciations: pronunciations }),
         pronunciationRules: currentPronunciationRules,
         ...(earlier === undefined ? {} : { earlierEpisodes: earlier }),
         ...(facts === undefined ? {} : { keywordFacts: facts }),

package/dist/slices/assistant/gate.js

@@ -159,6 +159,7 @@ export const assistantFreeTools = [
     "create_document_theme",
     "update_document_theme",
     "set_narration_aliases",
+    "set_library_pronunciations",
     "update_settings",
     "set_default_channel_links",
     "add_voice",

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

@@ -0,0 +1,226 @@
+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;
+// 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.
+    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);
+    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)
+            continue;
+        by.set(name, [...(by.get(name) ?? []), word.confidence]);
+    }
+    const names = [...by.entries()]
+        .map(([name, values]) => {
+        const sorted = [...values].sort((a, b) => a - b);
+        const low = percentile(sorted, 0.1);
+        const high = percentile(sorted, 0.9);
+        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,
+        };
+    })
+        .sort((a, b) => b.spread - a.spread || a.name.localeCompare(b.name, "en"));
+    return {
+        names,
+        uneven: names.filter((row) => row.uneven),
+        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 ?? [];
+    if (guessed.length === 0 && uneven.length === 0)
+        return null;
+    const parts = [];
+    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.`;
+}

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;