@gentbajko/slopify 4.1.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/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,138 @@
+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 {
+        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.
+        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,
+                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 timing = timingWords(deps, projectId, view);
+        const narrated = script === null ? null : namesNarrated(script, sources);
+        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/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 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",
         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/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,16 @@
 [
+  {
+    "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",
+    "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",