@gentbajko/slopify 3.20.0 → 3.22.0

package/SUBTITLES.md

@@ -3,7 +3,7 @@
 1. In Play, enable narration or provide matching English audio and article text.
 2. In Subtitles, choose **Subtitle files (.srt + .vtt)** or **Burn into video + files**.
 3. For burned captions, select a bundled or system font, or upload a `.ttf` or `.otf` file (up to 32 MiB). Choose a size from 16 to 120 and a position: top, upper-middle, center, lower-middle or bottom. The side preview shows the selected font, size and position in a 16:9 or 9:16 frame.
-4. Start the run. Slopify times the article against the actual narration on your computer. The first use downloads an approximately 95 MB English speech model; later runs work offline with the cached model. Allow roughly 1 GB of available memory during alignment. No extra API key, Python, or compiler is needed.
+4. Start the run. Slopify times the article against the actual narration on your computer. The first use downloads the English speech model chosen in Settings → Production defaults → **Subtitle timing model** (378 MB unless changed); later runs work offline with the cached model. Allow roughly 1.2 GB of available memory during alignment (0.7 GB with Smallest). No extra API key, Python, or compiler is needed.
 5. Download SRT/VTT beside the final export. Files mode adds an optional native caption track to the in-app video preview. Burned captions remain visible in the downloaded MP4.
 
 For a completed project, open its final Video or Audio export section, set subtitles, and click **Save subtitles**. This rebuilds only the local export from saved narration and images. Changing font, size or position reuses word timing when the audio and spoken text are unchanged. A paused run saves these choices until Resume; pause an active run before editing. Failed alignment or rendering keeps the previous finished export.
@@ -18,6 +18,14 @@ Fonts are copied into the completed project's caption assets, so an existing exp
 
 Speech inference uses MIT-licensed `onnxruntime-node@1.30.0` (native CPU) in a separate process, with `min(8, CPUs − 1)` threads; set `SLOPIFY_SUBTITLE_THREADS` to override. The npm package bundles CPU builds for Linux x64/arm64, Windows x64/arm64 and Apple silicon macOS (about 220 MB unpacked); Intel Macs have no build, so subtitle timing falls back to the slower single-threaded `onnxruntime-web` there. Its postinstall script only fetches optional CUDA files on Linux x64 and is not needed (the Docker image installs with `--ignore-scripts`); model weights are downloaded lazily into `<data-dir>/models/english-subtitles/`.
 
-Model: [Xenova/wav2vec2-base-960h](https://huggingface.co/Xenova/wav2vec2-base-960h/tree/a19f851b3d42865797e410752b4c570c871e4825), an ONNX conversion of [facebook/wav2vec2-base-960h](https://huggingface.co/facebook/wav2vec2-base-960h), licensed Apache-2.0. Pinned revision: `a19f851b3d42865797e410752b4c570c871e4825`. The quantized model is 95,286,046 bytes, SHA256 `cd5040c147381580ed73258143dd8e0c28e800a09e74ee42ee2b3e8cb4d760a3`; every cached/downloaded model is verified before use.
+Model: [Xenova/wav2vec2-base-960h](https://huggingface.co/Xenova/wav2vec2-base-960h/tree/a19f851b3d42865797e410752b4c570c871e4825), an ONNX conversion of [facebook/wav2vec2-base-960h](https://huggingface.co/facebook/wav2vec2-base-960h), licensed Apache-2.0. Pinned revision: `a19f851b3d42865797e410752b4c570c871e4825`. Three precisions of that revision can be chosen per computer, each verified before use and kept under its own file name so they can sit side by side:
+
+| Setting | File | Bytes | SHA256 |
+|---|---|---|---|
+| Most accurate (default) | `onnx/model.onnx` (fp32) | 377,887,594 | `e46614273f03ff4b87923a965e417fa72004825522cb007c9c25633b8475490d` |
+| Balanced | `onnx/model_fp16.onnx` | 189,192,204 | `378348ee38b739cc77e77e3fb8502f0f40ed53da0dbf7401b24c25c8fafe03de` |
+| Smallest | `onnx/model_quantized.onnx` (int8) | 95,286,046 | `cd5040c147381580ed73258143dd8e0c28e800a09e74ee42ee2b3e8cb4d760a3` |
+
+On a 2 h 28 min narration fp32 aligned in 2 min 40 s (1.1 GB peak) and fp16 in 3 min 16 s (1.2 GB), both hearing every line; int8 took 5 min 35 s (0.7 GB) and misheard two lines, stopping the run with a false "Subtitles stopped matching the audio".
 
 The bundled Barlow font uses the SIL Open Font License; its license and source record ship in `dist/assets/fonts/`. Uploaded/system font licensing remains with its author.

package/dist/adapters/alignment/cache.js

@@ -5,13 +5,36 @@ import { join } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { setTimeout as delay } from "node:timers/promises";
+import { defaultEnglishSubtitleModel, } from "../../kernel/ports/subtitles.js";
+// Xenova/wav2vec2-base-960h at one pinned revision, which carries the same model at three
+// precisions. Each keeps its own file name so the cache can hold any of them at once; int8
+// keeps the name every install used before the choice existed.
 const revision = "a19f851b3d42865797e410752b4c570c871e4825";
-export const alignmentModel = {
-    filename: "wav2vec2-base-960h-cd5040c1.onnx",
-    url: `https://huggingface.co/Xenova/wav2vec2-base-960h/resolve/${revision}/onnx/model_quantized.onnx`,
-    bytes: 95_286_046,
-    sha256: "cd5040c147381580ed73258143dd8e0c28e800a09e74ee42ee2b3e8cb4d760a3",
+const repo = `https://huggingface.co/Xenova/wav2vec2-base-960h/resolve/${revision}/onnx`;
+export const englishModels = {
+    fp32: {
+        filename: "wav2vec2-base-960h-fp32-e4661427.onnx",
+        url: `${repo}/model.onnx`,
+        bytes: 377_887_594,
+        sha256: "e46614273f03ff4b87923a965e417fa72004825522cb007c9c25633b8475490d",
+        timeoutMs: 1_800_000,
+    },
+    fp16: {
+        filename: "wav2vec2-base-960h-fp16-378348ee.onnx",
+        url: `${repo}/model_fp16.onnx`,
+        bytes: 189_192_204,
+        sha256: "378348ee38b739cc77e77e3fb8502f0f40ed53da0dbf7401b24c25c8fafe03de",
+        timeoutMs: 1_200_000,
+    },
+    int8: {
+        filename: "wav2vec2-base-960h-cd5040c1.onnx",
+        url: `${repo}/model_quantized.onnx`,
+        bytes: 95_286_046,
+        sha256: "cd5040c147381580ed73258143dd8e0c28e800a09e74ee42ee2b3e8cb4d760a3",
+    },
 };
+// The default English model, and the one the Docker image ships as its seed.
+export const alignmentModel = englishModels[defaultEnglishSubtitleModel];
 export async function prepareModel(input, deps = { model: alignmentModel, fetch: globalThis.fetch }) {
     input.signal.throwIfAborted();
     await mkdir(input.cacheDir, { recursive: true, mode: 0o700 });
@@ -38,7 +61,7 @@ export async function prepareModel(input, deps = { model: alignmentModel, fetch:
             }
         }
     }
-    throw new Error("The free subtitle model download was interrupted after 3 attempts. Check your connection and retry.", { cause: lastFailure });
+    throw new Error(`The free subtitle model download (${megabytes(deps.model.bytes)}) was interrupted after 3 attempts, so the captions could not be timed. Check your internet connection, then Continue the run.${deps.model === alignmentModel || deps.model === englishModels.fp16 ? smaller : ""}`, { cause: lastFailure });
 }
 async function downloadModel(input, deps, target) {
     input.signal.throwIfAborted();
@@ -58,7 +81,7 @@ async function downloadModel(input, deps, target) {
             throw interrupted(error);
         }
         if (!response.ok || response.body === null) {
-            const error = new Error(`The free subtitle model could not be downloaded (HTTP ${response.status}). Check your connection and try again.`);
+            const error = new Error(`The free subtitle model could not be downloaded (HTTP ${response.status}) from Hugging Face, so the captions could not be timed. Check your internet connection, then Continue the run.`);
             let failure = error;
             try {
                 if (response.body !== null)
@@ -91,7 +114,7 @@ async function downloadModel(input, deps, target) {
                         break;
                     current += result.value.length;
                     if (current > deps.model.bytes)
-                        throw new Error("The subtitle model failed download size verification.");
+                        throw new Error("The subtitle model failed download size verification: more arrived than the file Slopify expects, so it was thrown away. Continue the run to download it again.");
                     hash.update(result.value);
                     input.onProgress?.(current, deps.model.bytes);
                     yield result.value;
@@ -112,7 +135,7 @@ async function downloadModel(input, deps, target) {
         });
         input.signal.throwIfAborted();
         if (current !== deps.model.bytes || hash.digest("hex") !== deps.model.sha256)
-            throw new Error("The subtitle model failed download verification. Please try again.");
+            throw new Error("The subtitle model failed download verification: the file that arrived is not the one Slopify expects, so it was thrown away. Continue the run to download it again.");
         // Each caller writes in its own directory. On Windows a completed concurrent download
         // may already own the final filename; reuse it only after the same verification.
         try {
@@ -146,6 +169,10 @@ async function seedModel(input, seed, target) {
         await rm(staging, { recursive: true, force: true });
     }
 }
+const smaller = " To download less, pick a smaller model in Settings → Production defaults → Subtitle timing model.";
+function megabytes(bytes) {
+    return `${String(Math.round(bytes / 1_000_000))} MB`;
+}
 function interrupted(cause) {
     const error = new Error("The subtitle model download was interrupted.", { cause });
     error.name = "SubtitleModelDownloadInterrupted";

package/dist/adapters/alignment/index.js

@@ -1,13 +1,25 @@
 import { mkdir, mkdtemp, readFile, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { languageInfo } from "../../kernel/ports/languages.js";
+import { defaultEnglishSubtitleModel, } from "../../kernel/ports/subtitles.js";
 import { decodeAudio } from "./audio.js";
-import { alignmentModel, prepareModel } from "./cache.js";
+import { englishModels, prepareModel } from "./cache.js";
 import { claimWorker } from "./lock.js";
 import { alignmentSpecFor, multilingualModel } from "./multilingual.js";
 import { runAlignmentWorker } from "./runner.js";
 import { sentenceTiming, speechShape } from "./sentences.js";
-export const alignSubtitles = async (request) => {
+// The model file that times a language: English with the model chosen in Settings, every other
+// word-timed language with the multilingual one.
+export function modelFor(language, english) {
+    return language === undefined || language === "en" ? englishModels[english] : multilingualModel;
+}
+// `chosen` is asked once per alignment, when it starts: an alignment already running keeps the
+// model it opened, and the next one uses whatever Settings says then.
+export function alignSubtitlesWith(chosen) {
+    return (request) => align(request, chosen);
+}
+export const alignSubtitles = alignSubtitlesWith(() => defaultEnglishSubtitleModel);
+async function align(request, chosen) {
     request.signal.throwIfAborted();
     if (languageInfo(request.language).timing === "sentences")
         return timeSentences(request);
@@ -20,7 +32,7 @@ export const alignSubtitles = async (request) => {
             cacheDir: request.cacheDir,
             signal: request.signal,
             onProgress: (current, total) => request.onProgress?.(Math.round((current / total) * 20), 100),
-        }, { model: english ? alignmentModel : multilingualModel, fetch: globalThis.fetch });
+        }, { model: modelFor(request.language, chosen()), fetch: globalThis.fetch });
         request.onProgress?.(20, 100);
         const working = await mkdtemp(join(request.cacheDir, ".alignment-audio-"));
         try {
@@ -42,7 +54,7 @@ export const alignSubtitles = async (request) => {
     finally {
         await release();
     }
-};
+}
 // No model and no download: the narration's loudness says where it pauses, and the sentences
 // are laid over it (`sentences.ts`).
 async function timeSentences(request) {

package/dist/adapters/alignment/prefetch.js

@@ -1,16 +1,21 @@
 import { mkdir, readFile, rm } from "node:fs/promises";
 import { join } from "node:path";
-import { prepareModel } from "./cache.js";
+import { defaultEnglishSubtitleModel, } from "../../kernel/ports/subtitles.js";
+import { englishModels, prepareModel } from "./cache.js";
 import { claimWorker } from "./lock.js";
-// Readies the subtitle model when the app starts, so the first captioned render never waits
-// on a 95 MB download in the middle of a run. It takes the worker lock, so a render that
-// starts meanwhile waits for this copy rather than fetching a second one.
-export async function prefetchModel(input, deps) {
+// Readies the chosen English subtitle model when the app starts, so the first captioned render
+// never waits on a download of up to 378 MB in the middle of a run. It takes the worker lock,
+// so a render that starts meanwhile waits for this copy rather than fetching a second one.
+export async function prefetchModel(input, deps = {}) {
     await mkdir(input.cacheDir, { recursive: true, mode: 0o700 });
     await clearOwnLock(input.cacheDir);
     const release = await claimWorker(input.cacheDir, input.signal);
     try {
-        return await prepareModel({ cacheDir: input.cacheDir, seed: input.seed, signal: input.signal }, deps);
+        return await prepareModel({ cacheDir: input.cacheDir, seed: input.seed, signal: input.signal }, {
+            ...deps,
+            model: deps.model ?? englishModels[input.choice ?? defaultEnglishSubtitleModel],
+            fetch: deps.fetch ?? globalThis.fetch,
+        });
     }
     finally {
         await release();

package/dist/edge/http/settings.js

@@ -1,6 +1,7 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { englishSubtitleModels } from "../../kernel/ports/subtitles.js";
 import { lastAgentConnection } from "../../slices/agents/connection.js";
 import { recentAgentActions } from "../../slices/agents/repo.js";
 import { notificationUrlMax, notificationUrlProblem, testNotice, webhookBody, } from "../../slices/notifications/address.js";
@@ -42,6 +43,8 @@ const playbackBody = z.object({
     loudness: z
         .object({ enabled: z.boolean(), videoLufs: z.number(), audioFilesLufs: z.number() })
         .optional(),
+    // Absent keeps what is saved, as with loudness.
+    subtitleModel: z.enum(englishSubtitleModels).optional(),
 });
 // The return type is inferred so Hono keeps the route types the SPA's client is
 // generated from; see stagingRoutes.
@@ -53,9 +56,11 @@ export function settingsRoutes(deps) {
         .get("/", (c) => c.json(readSettings(playback)))
         .put("/", zValidator("json", playbackBody, onInvalid), (c) => {
         const body = c.req.valid("json");
+        const saved = readSettings(playback);
         const result = saveSettings(playback, {
             ...body,
-            loudness: body.loudness ?? readSettings(playback).loudness,
+            loudness: body.loudness ?? saved.loudness,
+            subtitleModel: body.subtitleModel ?? saved.subtitleModel,
         });
         if (!result.ok) {
             return problem(c, {

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

@@ -52,13 +52,13 @@ const settings = [
         name: "get_settings",
         route: "GET /api/settings",
         title: "Read production defaults",
-        description: "Settings → Production defaults: silence gap, appearance and loudness.",
+        description: "Settings → Production defaults: silence gap, appearance, loudness and the English subtitle timing model.",
     },
     {
         name: "update_settings",
         route: "PUT /api/settings",
         title: "Save production defaults",
-        description: "Body: {silenceGapSeconds, appearance: system | light | dark, loudness?: {enabled, videoLufs, audioFilesLufs}}.",
+        description: "Body: {silenceGapSeconds, appearance: system | light | dark, loudness?: {enabled, videoLufs, audioFilesLufs}, subtitleModel?: fp32 | fp16 | int8}. subtitleModel is this computer's English caption-timing model (fp32 378 MB most accurate, the default; fp16 189 MB; int8 95 MB, less accurate); it never marks subtitles outdated.",
     },
     {
         name: "get_default_channel_links",

package/dist/kernel/ports/subtitles.js

@@ -1,3 +1,9 @@
+// The English timing model, chosen per computer in Settings → Production defaults: the same
+// pinned wav2vec2 conversion at three precisions. Bigger hears more accurately and, on most
+// computers, also runs faster. The choice never enters a fingerprint: every precision times the
+// same words, so switching must not mark finished subtitles outdated.
+export const englishSubtitleModels = ["fp32", "fp16", "int8"];
+export const defaultEnglishSubtitleModel = "fp32";
 // Where the audio stopped matching its transcript: seconds into the aligned file, the
 // transcript words it expected there and what the model heard instead (either may be empty).
 // The aligner throws it so the caller can say which part of the narration to redo.

package/dist/main.js

@@ -5,7 +5,7 @@ import { fileURLToPath } from "node:url";
 import { serve } from "@hono/node-server";
 import ffmpegStatic from "ffmpeg-static";
 import { buildRegistry } from "./adapter-registry.js";
-import { alignSubtitles } from "./adapters/alignment/index.js";
+import { alignSubtitlesWith } from "./adapters/alignment/index.js";
 import { prefetchModel } from "./adapters/alignment/prefetch.js";
 import { prepareFfmpeg } from "./adapters/ffmpeg.js";
 import { createHostCliClient } from "./adapters/host-cli/index.js";
@@ -72,6 +72,7 @@ import { settleTerminalScheduleRuns } from "./slices/schedules/repo.js";
 import { createScheduleRunner } from "./slices/schedules/scheduler.js";
 import { nodeCliProbe } from "./slices/settings/cli-status.js";
 import { isLocalCliProvider, localCliConcurrency } from "./slices/settings/model.js";
+import { readSettings } from "./slices/settings/playback.js";
 import { providerStatuses } from "./slices/settings/readiness.js";
 import { readSetting } from "./slices/settings/repo.js";
 import { arrangeChanged } from "./slices/storage/arrange.js";
@@ -692,6 +693,7 @@ export async function boot(config, options = {}) {
             ? prefetchModel({
                 cacheDir: subtitleModelDir(paths.dataDir),
                 seed: options.subtitleModelSeed,
+                choice: readSettings({ db, log }).subtitleModel,
                 signal: modelPrefetch.signal,
             }).then(() => log.write("info", "subtitle-model.ready"), (error) => {
                 // Not fatal: the first captioned render tries again and says why on its row.
@@ -762,7 +764,9 @@ export async function boot(config, options = {}) {
         throw error;
     }
 }
-export function wireRunner({ onFinished, audioPreviews, db, paths, clock, ids, log, hub, telemetry, flusher, registry, catalogue, ffmpeg, alignSubtitles: aligner = alignSubtitles, }) {
+export function wireRunner({ onFinished, audioPreviews, db, paths, clock, ids, log, hub, telemetry, flusher, registry, catalogue, ffmpeg, 
+// Settings → Production defaults → Subtitle timing model, read as each alignment starts.
+alignSubtitles: aligner = alignSubtitlesWith(() => readSettings({ db, log }).subtitleModel), }) {
     // A stage counts what it did and the queue is flushed after each new event. `record`
     // swallows its own failures, so this can neither fail a stage nor widen what leaves the
     // machine - the payload allow-list is checked inside it.

package/dist/patch-notes/3.21.0.md

@@ -0,0 +1,11 @@
+# Slopify 3.21.0
+
+Released 13 October 2026.
+
+- **Captions are timed with a more accurate speech model by default.** The old 95 MB model sometimes misheard a line of narration, stopped the run with "Subtitles stopped matching the audio" and recorded a good narration chunk again at a cost. The full-precision version of the same model hears those lines correctly. On a 2½-hour narration it was also faster: 2 min 40 s instead of 5 min 35 s.
+- **Choose the subtitle timing model** in Settings → Production defaults: Most accurate (378 MB, the default), Balanced (189 MB) or Smallest (95 MB, less accurate). The choice belongs to this computer and downloads once, the first time captions are timed.
+
+## Upgrading from 3.20.0
+
+- The first video you make downloads the 378 MB model once. To keep the smaller model, choose Smallest in Settings → Production defaults.
+- Nothing becomes outdated: the model choice doesn't change any word timings already made.

package/dist/patch-notes/3.22.0.md

@@ -0,0 +1,12 @@
+# Slopify 3.22.0
+
+Released 13 October 2026.
+
+- **Names keep their pronunciation in possessives.** "Gygax's", "Lolth's" and every other possessive of a name in the Pronunciation Glossary were read without the glossary's pronunciation. They now get it, with the right ending sound added.
+- **Hyphenated names work in the glossary.** Names like "Arach-Tinilith" or "Catti-brie" with one pronunciation per part were refused; they are now used.
+- **Blank glossary entries are no longer reported as errors.** When the article leaves a name's pronunciation blank ("—"), the Pronunciation tab now says how many names are read as written, instead of listing them as broken entries.
+- **A project's page no longer scrolls into an empty screen.** On wide screens, scrolling outside the columns of a project (most of all on Video) could slide the whole page up past its content.
+
+## Upgrading from 3.21.0
+
+- The new glossary rules apply to projects made from now on. Projects already made keep the old rules, so nothing already voiced becomes outdated.

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.22.0",
+    "title": "Slopify 3.22.0",
+    "version": "3.22.0",
+    "date": "2026-10-13"
+  },
+  {
+    "id": "3.21.0",
+    "title": "Slopify 3.21.0",
+    "version": "3.21.0",
+    "date": "2026-10-12"
+  },
   {
     "id": "3.20.0",
     "title": "Slopify 3.20.0",

package/dist/slices/admission/schema.js

@@ -70,6 +70,7 @@ export const runDraftSchema = z.object({
     })
         .optional(),
     narrationAliases: narrationAliasesSchema.optional(),
+    pronunciationRules: z.union([z.literal(1), z.literal(2)]).optional(),
     sharedGlossary: z
         .array(z.object({
         term: z.string().min(1).max(200),

package/dist/slices/admission/start.js

@@ -5,6 +5,7 @@ import { resolveChannelId, setProjectChannel } from "../channels/repo.js";
 import { defaultDocumentTheme } from "../document/model.js";
 import { earlierEpisodesFor } from "../episodes/related.js";
 import { listNarrationAliases } from "../narration/aliases-library.js";
+import { currentPronunciationRules } from "../narration/pronunciation.js";
 import { collectSharedGlossary } from "../narration/shared-glossary.js";
 import { admitInitialRevision } from "../rebuild/runtime-admission.js";
 import { adoptBaseline } from "../revisions/adopt.js";
@@ -60,6 +61,7 @@ export function startRun(deps, draft, rendered, retainStaged = false, templates)
         rendered,
         ...(shared.length === 0 ? {} : { sharedGlossary: shared }),
         ...(aliases.length === 0 ? {} : { narrationAliases: aliases }),
+        pronunciationRules: currentPronunciationRules,
         ...(earlier === undefined ? {} : { earlierEpisodes: earlier }),
     };
     const project = {

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

@@ -15,7 +15,7 @@ export function chunkingFingerprintOf(chunking) {
 export function narrationChunkTexts(source, chunking, anchors) {
     return anchoredChunks(source, chunking, anchors?.chunkingFingerprint === chunkingFingerprintOf(chunking) ? anchors.texts : undefined);
 }
-export function pronunciationChunks(source, chunking, entries, overriddenKeys = new Set(), sources = {}, anchors) {
+export function pronunciationChunks(source, chunking, entries, overriddenKeys = new Set(), sources = {}, anchors, possessives = false) {
     const occurrences = new Map();
     const usedKeys = new Set();
     const nextKey = (text) => {
@@ -67,7 +67,7 @@ export function pronunciationChunks(source, chunking, entries, overriddenKeys =
         })),
     ].sort((a, b) => a.start - b.start);
     let blockedIndex = 0;
-    const matches = pronunciationMatches(source, entries).filter((match) => {
+    const matches = pronunciationMatches(source, entries, possessives).filter((match) => {
         while ((blocked[blockedIndex]?.end ?? Infinity) <= match.start)
             blockedIndex++;
         return (blocked[blockedIndex]?.start ?? Infinity) >= match.end;

package/dist/slices/narration/pronunciation.js

@@ -1,6 +1,15 @@
 import { remark } from "remark";
 import remarkGfm from "remark-gfm";
 import { remembered } from "../../kernel/remembered.js";
+export const currentPronunciationRules = 2;
+export function pronunciationRulesOf(config) {
+    return config.pronunciationRules ?? 1;
+}
+// "'s" after a name is English; another language's glossary has no such ending to add.
+export function readsPossessives(config) {
+    return (pronunciationRulesOf(config) === 2 &&
+        (config.language === undefined || config.language === "en"));
+}
 // Inworld requires English IPA, not every symbol in Unicode's IPA Extensions block.
 // https://docs.inworld.ai/tts/capabilities/custom-pronunciation
 const ipaAtom = "[ˈˌ]?[abdefghijklmnoprstuvwxzæðŋθɑɒɔəɚɛɜɝɡɪɹʃʊʌʒʔɫɾ][\\u0303\\u031a\\u0325\\u0329\\u032a\\u032c\\u032f\\u035c\\u0361ʰʲʷ]*[ːˑ]?";
@@ -50,8 +59,29 @@ function termIdentity(term) {
 }
 // `language` is the project's (`kernel/ports/languages.ts`): absent or English accepts the
 // standard-English IPA Inworld asks for, as it always did; any other accepts full IPA.
-export const parsePronunciationGlossary = remembered(8, (markdown, language) => `${language ?? ""}\u0000${markdown}`, parseGlossary);
-function parseGlossary(markdown, language) {
+export const parsePronunciationGlossary = remembered(8, (markdown, language, rules) => `${rules ?? currentPronunciationRules}\u0000${language ?? ""}\u0000${markdown}`, parseGlossary);
+// A cell the writer left out on purpose: empty, a dash, or "n/a", with or without slashes.
+const blankIpa = /^(?:\/\s*(?:[—–-]+|n\/a)\s*\/|[—–-]+|n\/a)?$/iu;
+const hyphens = /[-\u2010\u2011]/u;
+// One IPA word per written word. A hyphenated name is one written word, so its parts' IPA words
+// are joined with "." (a syllable break) into the one word Inworld wants between a pair of slashes.
+function pairWords(term, ipa) {
+    const words = term.split(" ");
+    if (words.length === ipa.length)
+        return ipa;
+    const parts = words.map((word) => word.split(hyphens).filter((part) => part !== "").length || 1);
+    if (parts.reduce((sum, count) => sum + count, 0) !== ipa.length)
+        return null;
+    let next = 0;
+    return parts.map((count) => {
+        const joined = ipa.slice(next, next + count).join(".");
+        next += count;
+        return joined;
+    });
+}
+function parseGlossary(markdown, language, rules = currentPronunciationRules) {
+    const modern = rules === 2;
+    let unpronounced = 0;
     const english = language === undefined || language === "en";
     const symbols = english ? ipaSymbols : worldSymbols;
     const kind = english ? "standard-English IPA" : "IPA";
@@ -65,7 +95,7 @@ function parseGlossary(markdown, language) {
         const trimmed = row.trim();
         if (trimmed === "" || /^pronunciation glossary:?\s*$/iu.test(trimmed))
             continue;
-        const pair = /^([^:]+):\s*(.+)$/u.exec(trimmed);
+        const pair = (modern ? /^([^:]+):\s*(.*)$/u : /^([^:]+):\s*(.+)$/u).exec(trimmed);
         const term = pair?.[1]?.trim().replace(/\s+/gu, " ");
         const pronunciation = pair?.[2];
         if (term === undefined ||
@@ -75,6 +105,10 @@ function parseGlossary(markdown, language) {
             skip("use Term: /IPA/ or a Term | IPA table");
             continue;
         }
+        if (modern && blankIpa.test(pronunciation.trim())) {
+            unpronounced++;
+            continue;
+        }
         const notation = /^(\/[^/]+\/(?:\s+\/[^/]+\/)*)(?:\s+[^/]+)?$/u.exec(pronunciation);
         if (notation?.[1] === undefined) {
             skip(`use slash-delimited ${kind}`);
@@ -87,37 +121,54 @@ function parseGlossary(markdown, language) {
                 : "use IPA, not ARPAbet or delivery tags");
             continue;
         }
-        if (term.split(" ").length !== ipa.length) {
-            skip("supply one IPA word for each written word");
+        const paired = modern
+            ? pairWords(term, ipa)
+            : term.split(" ").length === ipa.length
+                ? ipa
+                : null;
+        if (paired === null) {
+            skip(modern
+                ? "supply one IPA word for each written word, or for each hyphen-separated part of it"
+                : "supply one IPA word for each written word");
             continue;
         }
         const key = termIdentity(term);
         const previous = entries.get(key);
-        if (previous !== undefined && previous.ipa.join(" ") !== ipa.join(" ")) {
+        if (previous !== undefined && previous.ipa.join(" ") !== paired.join(" ")) {
             skip("an earlier entry already gives this term a different pronunciation");
             continue;
         }
         if (previous === undefined)
-            entries.set(key, { term, ipa });
+            entries.set(key, { term, ipa: paired });
     }
-    return skipped.length === 0
-        ? { ok: true, entries: [...entries.values()] }
-        : { ok: true, entries: [...entries.values()], skipped };
+    return {
+        ok: true,
+        entries: [...entries.values()],
+        ...(unpronounced === 0 ? {} : { unpronounced }),
+        ...(skipped.length === 0 ? {} : { skipped }),
+    };
 }
-// What a person reads about the skipped rows: where they are and why, never their text.
-export function skippedGlossaryNotice(skipped) {
-    if (skipped.length === 0)
+// What a person reads about the skipped rows: where they are and why, never their text. Names
+// left without a pronunciation on purpose are not errors, so they get one calm line of their own.
+export function skippedGlossaryNotice(skipped, unpronounced = 0) {
+    if (skipped.length === 0 && unpronounced === 0)
         return null;
+    const where = "in the Pronunciation Glossary at the end of the article in Edit project → Article";
+    const blank = unpronounced === 0
+        ? ""
+        : `${unpronounced === 1 ? "1 name has" : `${unpronounced} names have`} no pronunciation given and ${unpronounced === 1 ? "is" : "are"} read as written. To give ${unpronounced === 1 ? "it one" : "them one"}, fill in its IPA ${where}.`;
+    if (skipped.length === 0)
+        return `Pronunciation Glossary: ${blank}`;
     const rows = skipped.map((one) => `entry ${one.row}: ${one.reason}`).join("; ");
     return (`Pronunciation Glossary: ${skipped.length === 1 ? "1 entry is" : `${skipped.length} entries are`} ` +
         `skipped and read as ordinary text (${rows}). The rest of the glossary is used. ` +
-        "To use them, fix those entries in the Pronunciation Glossary at the end of the article in Edit project → Article.");
+        `To use them, fix those entries ${where}.${blank === "" ? "" : ` ${blank}`}`);
 }
-export function skippedSpeakerPronunciations(speakers, language) {
+export function skippedSpeakerPronunciations(speakers, language, rules) {
     return speakers.flatMap((speaker) => {
         if (!speaker.pronunciations?.trim())
             return [];
-        const parsed = parsePronunciationGlossary(speaker.pronunciations, language);
+        const parsed = parsePronunciationGlossary(speaker.pronunciations, language, rules);
         const skipped = parsed.ok ? (parsed.skipped ?? []) : [];
         return skipped.length === 0 ? [] : [{ speaker: speaker.name.trim() || "A speaker", skipped }];
     });
@@ -130,8 +181,8 @@ export function skippedSpeakerPronunciationsNotice(rows) {
         "The rest are used. To use them, fix those entries under Speakers → Pronunciations for that speaker (Play → Narration, or Edit project → Providers).");
 }
 // Remembered (`kernel/remembered.ts`): every plan rebuild matches the whole narration again.
-export const pronunciationMatches = remembered(1024, (source, entries) => `${source}\u0000${JSON.stringify(entries)}`, matchPronunciations);
-function matchPronunciations(source, entries) {
+export const pronunciationMatches = remembered(1024, (source, entries, possessives) => `${possessives === true ? "p" : "-"}\u0000${source}\u0000${JSON.stringify(entries)}`, matchPronunciations);
+function matchPronunciations(source, entries, possessives = false) {
     if (entries.length === 0)
         return [];
     const ordered = [...entries].sort((a, b) => b.term.length - a.term.length);
@@ -140,11 +191,15 @@ function matchPronunciations(source, entries) {
         .map((word) => word.replace(/[|\\{}()[\]^$+*?.]/gu, "\\$&"))
         .join("\\s+"));
     const boundary = "[\\p{L}\\p{M}\\p{N}_\\-\u00ad\u2010\u2011\ufe63\uff0d]";
+    // A bare trailing apostrophe ("Iuz' henchmen") is never a possessive here: it can't be told
+    // from a closing quote, and a wrong "z" is worse than a name read as written.
     const expression = new RegExp("(?<!" +
         boundary +
         "['’]?)(?:" +
         patterns.map((pattern) => `(${pattern})`).join("|") +
-        ")(?!['’]?" +
+        ")" +
+        (possessives ? "(['’]s)?" : "") +
+        "(?!['’]?" +
         boundary +
         ")", "giu");
     const matches = [];
@@ -157,20 +212,35 @@ function matchPronunciations(source, entries) {
         const entry = ordered.find((_, index) => match[index + 1] !== undefined);
         if (entry === undefined)
             throw new Error("Slopify hit an internal error (a pronunciation glossary term has no pronunciation). Try again; if it happens again, use Download diagnostics in Settings and report it.");
-        matches.push({ start: match.index, end, entry });
+        const possessive = possessives ? match[ordered.length + 1] : undefined;
+        matches.push({
+            start: match.index,
+            end,
+            entry,
+            ...(possessive === undefined ? {} : { possessive }),
+        });
     }
     return matches;
 }
-export function pronunciationSpans(source, entries) {
+// The sound a possessive adds to the last sound of the name: "iz" after s z sh zh ch j,
+// "s" after the other voiceless sounds, "z" after everything else.
+function withPossessive(ipa) {
+    const last = ipa.replace(/[\u0300-\u036fʰʲʷːˑ]+$/u, "").slice(-1);
+    if ("sz\u0283\u0292".includes(last))
+        return `${ipa}\u026az`;
+    return `${ipa}${"ptkfθ".includes(last) ? "s" : "z"}`;
+}
+export function pronunciationSpans(source, entries, possessives = false) {
     const spans = [];
-    for (const match of pronunciationMatches(source, entries)) {
-        const words = source.slice(match.start, match.end).matchAll(/\S+/gu);
-        for (const [index, word] of Array.from(words).entries()) {
+    for (const match of pronunciationMatches(source, entries, possessives)) {
+        const words = Array.from(source.slice(match.start, match.end).matchAll(/\S+/gu));
+        for (const [index, word] of words.entries()) {
             const ipa = match.entry.ipa[index];
             if (ipa === undefined)
                 throw new Error("Slopify hit an internal error (a pronunciation glossary term is missing a word). Try again; if it happens again, use Download diagnostics in Settings and report it.");
             const start = match.start + word.index;
-            spans.push({ start, end: start + word[0].length, text: `/${ipa}/` });
+            const spoken = match.possessive !== undefined && index === words.length - 1 ? withPossessive(ipa) : ipa;
+            spans.push({ start, end: start + word[0].length, text: `/${spoken}/` });
         }
     }
     return spans;

package/dist/slices/rebuild/recipe-audio-parts.js

@@ -2,7 +2,7 @@ import { aliasMatches } from "../../kernel/ports/narration-aliases.js";
 import { narrationAliasesOf, usesNarrationPreparation, usesPronunciationGlossary, } from "../admission/rules.js";
 import { aliasSpans, withAliasSpans } from "../narration/aliases.js";
 import { narrationRegenerationToken, normalizeNarrationText, planNarration, } from "../narration/plan.js";
-import { pronunciationSpans } from "../narration/pronunciation.js";
+import { pronunciationSpans, readsPossessives, } from "../narration/pronunciation.js";
 import { prepareRequests } from "../narration/steering.js";
 import { recipe } from "./recipe-model.js";
 import { preparationForGroup } from "./recipe-preparation.js";
@@ -25,7 +25,7 @@ export function narrationParts(context, logicalKey, originalText, segment, depen
     // Aliases first: where one applies, the glossary does not.
     const aliases = narrationAliasesOf(context.config);
     const matches = aliasMatches(logicalText, aliases);
-    const spans = withAliasSpans(pronunciationSpans(logicalText, glossary.entries), aliasSpans(logicalText, aliases));
+    const spans = withAliasSpans(pronunciationSpans(logicalText, glossary.entries, readsPossessives(context.config)), aliasSpans(logicalText, aliases));
     const wholeRequest = segment !== "body" || (context.config.chunking?.mode ?? "whole") === "whole";
     const choice = context.config.audio;
     // A retired model's character limit is still its limit: the automatic catalogue check marks
@@ -128,7 +128,7 @@ export function pronunciationFutureValues(context, glossary, article, logicalKey
                 ],
             ];
     const clean = normalizeNarrationText(override?.kind === "text" ? override.text : source);
-    const spans = pronunciationSpans(clean, glossary.entries);
+    const spans = pronunciationSpans(clean, glossary.entries, readsPossessives(context.config));
     return spans.length === 0
         ? []
         : [