@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/narration/pauses.js

@@ -0,0 +1,269 @@
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { measureFile } from "../loudness/loudnorm.js";
+import { pieceLufs, pieceTruePeak } from "../loudness/model.js";
+import { probeDurationMs, runFfmpeg } from "../video/ffmpeg.js";
+import { sentences } from "./chunk.js";
+// The sentence ends inside a text, not counting its last.
+export function textBoundaries(text) {
+    const parts = [...sentences(text)];
+    const total = Array.from(text).length;
+    if (parts.length < 2 || total === 0)
+        return [];
+    const boundaries = [];
+    let offset = 0;
+    for (const part of parts.slice(0, -1)) {
+        offset += Array.from(part).length;
+        const trailing = /\s*$/.exec(part)?.[0] ?? "";
+        // Only a real sentence: text that is only spacing is no sentence of its own.
+        if (part.trim() === "")
+            continue;
+        boundaries.push({
+            ratio: offset / total,
+            kind: /\n[ \t\r]*\n/.test(trailing) || /\n/.test(trailing) ? "paragraph" : "sentence",
+        });
+    }
+    return boundaries;
+}
+// silencedetect prints `silence_start: 1.23` and `silence_end: 1.56 | silence_duration: 0.33`.
+// A stretch still open at the end runs to the end of the piece.
+export function parseSilences(stderr, durationSeconds) {
+    const silences = [];
+    let open;
+    for (const match of stderr.matchAll(/silence_(start|end):\s*(-?[0-9.]+)/g)) {
+        const value = Math.max(0, Number(match[2]));
+        if (!Number.isFinite(value))
+            continue;
+        if (match[1] === "start")
+            open = value;
+        else if (open !== undefined) {
+            silences.push({ start: open, end: Math.min(durationSeconds, value) });
+            open = undefined;
+        }
+    }
+    if (open !== undefined && open < durationSeconds)
+        silences.push({ start: open, end: durationSeconds });
+    return silences;
+}
+// ceiling: a sentence end more than two seconds (or a fifth of the piece) from where its words
+// put it is not trusted to be that sentence's pause.
+const windowSeconds = 2;
+const windowShare = 0.2;
+// ceiling: a second of quiet counts for three seconds of distance, so a full stop's pause wins
+// over a comma's breath a little nearer to where the words put the end.
+const durationWeight = 3;
+// A stretch this near either end of the piece is the piece's own lead-in or tail.
+const edgeSeconds = 0.02;
+export function planPauses(input) {
+    const { durationSeconds, silences, boundaries, settings } = input;
+    const leadingSilence = silences.find((one) => one.start <= edgeSeconds);
+    const trailingSilence = silences.find((one) => one.end >= durationSeconds - edgeSeconds);
+    const leading = leadingSilence === undefined ? 0 : leadingSilence.end;
+    const trailing = trailingSilence === undefined || trailingSilence === leadingSilence
+        ? 0
+        : durationSeconds - trailingSilence.start;
+    const speechStart = leading;
+    const speechEnd = Math.max(speechStart, durationSeconds - trailing);
+    const speech = speechEnd - speechStart;
+    const inner = silences.filter((one) => one !== leadingSilence && one !== trailingSilence);
+    if (speech <= 0 || inner.length === 0 || boundaries.length === 0)
+        return { inserts: [], leading, trailing };
+    const window = Math.max(windowSeconds, speech * windowShare);
+    const expected = boundaries.map((one) => speechStart + one.ratio * speech);
+    // The best in-order matching: every sentence end takes a later stretch than the one before,
+    // or none. Cost is the distance from where the words put the end, less the stretch's length
+    // weighted (a full stop's pause is longer than a comma's); leaving an end unmatched costs the
+    // window.
+    const m = boundaries.length;
+    const n = inner.length;
+    const cost = Array.from({ length: m + 1 }, () => Array.from({ length: n + 1 }, () => Number.POSITIVE_INFINITY));
+    const choice = Array.from({ length: m + 1 }, () => Array.from({ length: n + 1 }, () => "skip-end"));
+    for (let j = 0; j <= n; j += 1) {
+        const row = cost[0];
+        if (row !== undefined)
+            row[j] = 0;
+    }
+    for (let i = 1; i <= m; i += 1) {
+        const row = cost[i];
+        const previous = cost[i - 1];
+        const picks = choice[i];
+        row[0] = (previous[0] ?? 0) + window;
+        picks[0] = "skip-end";
+        for (let j = 1; j <= n; j += 1) {
+            const silence = inner[j - 1];
+            const middle = (silence.start + silence.end) / 2;
+            const distance = Math.abs(middle - (expected[i - 1] ?? 0));
+            const options = [
+                [(previous[j] ?? 0) + window, "skip-end"],
+                [row[j - 1] ?? Number.POSITIVE_INFINITY, "skip-silence"],
+            ];
+            if (distance <= window)
+                options.push([
+                    (previous[j - 1] ?? 0) + distance - durationWeight * (silence.end - silence.start),
+                    "match",
+                ]);
+            const best = options.reduce((low, one) => (one[0] < low[0] ? one : low));
+            row[j] = best[0];
+            picks[j] = best[1];
+        }
+    }
+    const matched = [];
+    let i = m;
+    let j = n;
+    while (i > 0) {
+        const pick = choice[i]?.[j] ?? "skip-end";
+        if (j > 0 && pick === "match") {
+            matched.push({
+                boundary: boundaries[i - 1],
+                silence: inner[j - 1],
+            });
+            i -= 1;
+            j -= 1;
+        }
+        else if (j > 0 && pick === "skip-silence")
+            j -= 1;
+        else
+            i -= 1;
+    }
+    const inserts = matched.reverse().flatMap(({ boundary, silence }) => {
+        const wanted = minimumFor(boundary.kind, settings);
+        const have = silence.end - silence.start;
+        return wanted > have
+            ? [{ at: round((silence.start + silence.end) / 2), seconds: round(wanted - have) }]
+            : [];
+    });
+    return { inserts, leading, trailing };
+}
+export function minimumFor(kind, settings) {
+    return kind === "paragraph"
+        ? Math.max(settings.sentenceSeconds, settings.paragraphSeconds)
+        : settings.sentenceSeconds;
+}
+// The piece with its silences added and `padEnd` seconds of silence after it, as 16-bit PCM
+// WAV. Every stretch between two inserts is cut out of the piece as it is and played in order.
+export function insertArgs(input, output, inserts, padEnd, format) {
+    const layout = format.channels === 1 ? "mono" : "stereo";
+    const base = `aformat=sample_fmts=fltp:sample_rates=${String(format.sampleRate)}:channel_layouts=${layout}`;
+    const chains = [
+        `[0:a]${base},asplit=${String(inserts.length + 1)}${inserts.map((_one, at) => `[s${String(at)}]`).join("")}[s${String(inserts.length)}]`,
+    ];
+    const cuts = [0, ...inserts.map((one) => one.at)];
+    cuts.forEach((from, at) => {
+        const to = inserts[at]?.at;
+        const trim = `atrim=start=${from.toFixed(6)}${to === undefined ? "" : `:end=${to.toFixed(6)}`},asetpts=PTS-STARTPTS`;
+        const before = at === 0 ? undefined : inserts[at - 1]?.seconds;
+        const delay = before === undefined ? "" : `,adelay=delays=${Math.round(before * 1000)}:all=1`;
+        const pad = to === undefined && padEnd > 0 ? `,apad=pad_dur=${padEnd.toFixed(3)}` : "";
+        chains.push(`[s${String(at)}]${trim}${delay}${pad}[p${String(at)}]`);
+    });
+    chains.push(`${cuts.map((_one, at) => `[p${String(at)}]`).join("")}concat=n=${String(cuts.length)}:v=0:a=1[a]`);
+    return [
+        "-hide_banner",
+        "-nostdin",
+        "-loglevel",
+        "error",
+        "-nostats",
+        "-y",
+        "-i",
+        input,
+        "-filter_complex",
+        chains.join(";"),
+        "-map",
+        "[a]",
+        "-c:a",
+        "pcm_s16le",
+        "-f",
+        "wav",
+        output,
+    ];
+}
+// ceiling: quiet is 22 dB under the piece's own loudness (never above -35 dBFS), held for at
+// least 60 ms: under a sentence's breath, over a room's hiss.
+const quietBelow = 22;
+const quietFloor = -35;
+const quietSeconds = 0.06;
+// Where a piece is quiet, measured on the piece as spoken.
+export async function measurePiece(run, file) {
+    const durationSeconds = (await probeDurationMs(run.bin, file, run.signal, run.log)) / 1000;
+    const loudness = await measureFile(run, file, { lufs: pieceLufs, truePeak: pieceTruePeak });
+    const noise = Number.isFinite(loudness.integrated)
+        ? Math.min(quietFloor, loudness.integrated - quietBelow)
+        : quietFloor;
+    let stderr = "";
+    await runFfmpeg({
+        bin: run.bin,
+        args: [
+            "-hide_banner",
+            "-nostdin",
+            "-loglevel",
+            "info",
+            "-nostats",
+            "-i",
+            file,
+            "-af",
+            `silencedetect=noise=${noise.toFixed(1)}dB:d=${String(quietSeconds)}`,
+            "-f",
+            "null",
+            "-",
+        ],
+        signal: run.signal,
+        log: run.log,
+        onProgress: () => { },
+        onStderr: (text) => {
+            stderr += text;
+        },
+    });
+    return { durationSeconds, silences: parseSilences(stderr, durationSeconds) };
+}
+// Every piece's plan, from the pieces as spoken: silences inside, and at each piece's end what
+// the gap to the next piece lacks.
+export async function planPieces(run, pieces, settings) {
+    const measured = [];
+    for (const piece of pieces) {
+        run.signal.throwIfAborted();
+        const { durationSeconds, silences } = await measurePiece(run, piece.file);
+        measured.push(planPauses({
+            durationSeconds,
+            silences,
+            boundaries: textBoundaries(piece.text),
+            settings,
+        }));
+    }
+    return measured.map((pauses, at) => {
+        const piece = pieces[at];
+        const following = measured[at + 1];
+        if (piece.next === "end" || piece.next === "turn" || following === undefined)
+            return { pauses, padEnd: 0 };
+        const gap = pauses.trailing + following.leading;
+        return { pauses, padEnd: round(Math.max(0, minimumFor(piece.next, settings) - gap)) };
+    });
+}
+// The pieces written again with their pauses, as WAVs in `directory`, in the order given.
+// `files` are what is joined (the spoken pieces, or their levelled copies); `plans` are from
+// the spoken pieces.
+export async function applyPauses(run, files, plans, directory) {
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const written = [];
+    let added = 0;
+    for (const [index, file] of files.entries()) {
+        run.signal.throwIfAborted();
+        const plan = plans[index];
+        const output = join(directory, `paced-${String(index + 1).padStart(4, "0")}.wav`);
+        await runFfmpeg({
+            bin: run.bin,
+            args: insertArgs(file, output, plan?.pauses.inserts ?? [], plan?.padEnd ?? 0, {
+                sampleRate: 44100,
+                channels: 1,
+            }),
+            signal: run.signal,
+            log: run.log,
+            onProgress: () => { },
+        });
+        added += (plan?.pauses.inserts.length ?? 0) + ((plan?.padEnd ?? 0) > 0 ? 1 : 0);
+        written.push(output);
+    }
+    return { files: written, added };
+}
+function round(value) {
+    return Math.round(value * 1000) / 1000;
+}

package/dist/slices/narration/peaks-model.js

@@ -0,0 +1 @@
+export {};

package/dist/slices/narration/peaks.js

@@ -0,0 +1,94 @@
+import { execFile } from "node:child_process";
+// The live view's narration waveform: each finished narration piece as a row of peaks, in the
+// order it is spoken, growing as pieces land. Once the whole narration is joined (or was
+// uploaded) that one file replaces the pieces.
+// ceiling: ten bars a second draws a two-minute short in 1200 bars and a two-hour video in
+// 72000, which the browser scales down to the width it has.
+export const peaksPerSecond = 10;
+// The rate the audio is decoded at for peaks only; loudness needs no more than this.
+const decodeRate = 4000;
+// ceiling: three hours of narration at the decode rate, 16-bit mono.
+const decodeMaxBytes = 3 * 3600 * decodeRate * 2;
+// The saved narration audio of a revision, in spoken order: the joined narration when it is
+// ready, else each finished request of the intro, the body and the outro.
+export function narrationAudio(view) {
+    const joined = view.outputs.find((row) => row.selected && row.available && row.state === "ready" && row.output.role === "audio_body");
+    if (joined !== undefined)
+        return {
+            complete: true,
+            pieces: [{ key: joined.workKey, assetId: joined.assetId }],
+        };
+    const order = (key) => key.startsWith("audio:intro") ? 0 : key.startsWith("audio:outro") ? 2 : 1;
+    return {
+        complete: false,
+        pieces: view.pieces
+            .filter((row) => row.selected &&
+            row.available &&
+            row.stageKind === "audio" &&
+            row.piece.state === "done" &&
+            row.assetId !== null &&
+            row.piece.payload !== null &&
+            spoken(row.piece.payload))
+            .toSorted((left, right) => order(left.key) - order(right.key) ||
+            left.key.localeCompare(right.key, "en", { numeric: true }))
+            .flatMap((row) => (row.assetId === null ? [] : [{ key: row.key, assetId: row.assetId }])),
+    };
+}
+function spoken(payload) {
+    try {
+        const value = JSON.parse(payload);
+        return typeof value === "object" && value !== null && "segment" in value;
+    }
+    catch {
+        return false;
+    }
+}
+// The loudest sample of each slice of `perSecond` a second, from 0 to 1.
+export function peaksOf(samples, sampleRate, perSecond) {
+    const size = Math.max(1, Math.round(sampleRate / perSecond));
+    const peaks = [];
+    for (let at = 0; at < samples.length; at += size) {
+        let loudest = 0;
+        const end = Math.min(samples.length, at + size);
+        for (let index = at; index < end; index++) {
+            const value = Math.abs(samples[index] ?? 0);
+            if (value > loudest)
+                loudest = value;
+        }
+        peaks.push(Math.round((loudest / 32768) * 1000) / 1000);
+    }
+    return peaks;
+}
+// Decodes an audio file with ffmpeg to mono 16-bit samples and returns its peaks.
+export function decodePeaks(ffmpeg, path, signal) {
+    return new Promise((resolve, reject) => {
+        execFile(ffmpeg, [
+            "-hide_banner",
+            "-nostdin",
+            "-loglevel",
+            "error",
+            "-i",
+            path,
+            "-ac",
+            "1",
+            "-ar",
+            String(decodeRate),
+            "-f",
+            "s16le",
+            "pipe:1",
+        ], { encoding: "buffer", maxBuffer: decodeMaxBytes, signal, windowsHide: true }, (error, stdout) => {
+            if (error !== null) {
+                reject(new Error(`ffmpeg could not read the narration audio (${error.message}).`));
+                return;
+            }
+            // Copied so the samples start on an even byte, which a pooled Buffer may not.
+            const bytes = new Uint8Array(stdout.byteLength - (stdout.byteLength % 2));
+            bytes.set(stdout.subarray(0, bytes.byteLength));
+            const samples = new Int16Array(bytes.buffer);
+            resolve({
+                seconds: samples.length / decodeRate,
+                peaks: peaksOf(samples, decodeRate, peaksPerSecond),
+            });
+        });
+    });
+}

package/dist/slices/narration/preparation.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { languageInfo } from "../../kernel/ports/languages.js";
+import { aliasedSentences } from "./aliases.js";
 const sentence = z.number().int().positive();
 const instruction = z
     .string()
@@ -64,12 +66,28 @@ const contract = [
     "Never return or rewrite narration. Do not translate, correct, abbreviate or add dialogue.",
     "Use cues sparingly; an empty cues array is valid. Combine simultaneous directions.",
 ].join("\n");
-export function preparationMessages(prompt, source) {
+// `aliases` are the narration aliases found in `source`: the model reads the sentences as
+// they will be said. Without any, the request is exactly what it always was. A narration in
+// another `language`: its directions still steer the voice in English, but the model has to
+// know the sentences are not English and must stay as they are. English gets the contract
+// alone, as it always did. A turn of a multi-voice script names its `speaker` too, so the
+// directions suit a narrator, a host or the character saying the line; one voice names none.
+export function preparationMessages(prompt, source, aliases = [], language, speaker) {
+    const name = language === undefined || language === "en" ? undefined : languageInfo(language);
     return [
-        { role: "system", content: contract },
+        {
+            role: "system",
+            content: name === undefined
+                ? contract
+                : `${contract}\nThe narration is in ${name.name}; keep it in ${name.name}. Directions stay in English.`,
+        },
         {
             role: "user",
-            content: JSON.stringify({ direction: prompt, sentences: sourceSentences(source) }),
+            content: JSON.stringify({
+                direction: prompt,
+                ...(speaker === undefined ? {} : { speaker: `${speaker.name} (${speaker.role})` }),
+                sentences: aliasedSentences(sourceSentences(source), aliases),
+            }),
         },
     ];
 }

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

@@ -18,7 +18,7 @@ export function pronunciationChunks(source, chunking, entries, overriddenKeys =
     const chunks = chunkNarration(source, chunking).map((text) => {
         const start = source.indexOf(text, offset);
         if (start < 0)
-            throw new Error("Slopify hit an internal error (a narration chunk isn't in the article text). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error("Slopify hit an internal error (a narration chunk isn't in the article text). Try again; if it happens again, use Download diagnostics in Settings and report it.");
         offset = start + text.length;
         return { key: nextKey(text), text, start, end: offset };
     });
@@ -78,7 +78,7 @@ export function pronunciationChunks(source, chunking, entries, overriddenKeys =
         }
         const chunk = chunks[index];
         if (chunk === undefined)
-            throw new Error("Slopify hit an internal error (a narration chunk went missing). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error("Slopify hit an internal error (a narration chunk went missing). Try again; if it happens again, use Download diagnostics in Settings and report it.");
         while ((matches[matchIndex]?.end ?? Infinity) <= chunk.end)
             matchIndex++;
         const match = matches[matchIndex];
@@ -90,7 +90,7 @@ export function pronunciationChunks(source, chunking, entries, overriddenKeys =
             continue;
         const first = chunks[from];
         if (first === undefined)
-            throw new Error("Slopify hit an internal error (a group of narration chunks is empty). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error("Slopify hit an internal error (a group of narration chunks is empty). Try again; if it happens again, use Download diagnostics in Settings and report it.");
         const text = source.slice(first.start, chunk.end);
         result.push(from === index
             ? { key: chunk.key, text }

package/dist/slices/narration/pronunciation.js

@@ -4,6 +4,10 @@ import remarkGfm from "remark-gfm";
 // https://docs.inworld.ai/tts/capabilities/custom-pronunciation
 const ipaAtom = "[ˈˌ]?[abdefghijklmnoprstuvwxzæðŋθɑɒɔəɚɛɜɝɡɪɹʃʊʌʒʔɫɾ][\\u0303\\u031a\\u0325\\u0329\\u032a\\u032c\\u032f\\u035c\\u0361ʰʲʷ]*[ːˑ]?";
 const ipaSymbols = new RegExp(`^(?:${ipaAtom})+(?:\\.(?:${ipaAtom})+)*$`, "u");
+// Another language's glossary needs that language's sounds: the full IPA consonant and vowel
+// charts (ç, ʁ, ø, y, ɲ, ʎ, x, β, …) and its diacritics, still never ARPAbet or tags.
+const worldAtom = "[ˈˌ]?[a-zæçðøħŋœɐɑɒɓɔɕɖɗɘəɚɛɜɝɞɟɠɡɢɣɤɥɦɧɨɪɫɬɭɮɯɰɱɲɳɴɵɶɸɹɺɻɽɾʀʁʂʃʄʈʉʊʋʌʍʎʏʐʑʒʔʕʙʛʜʝʟʡʢβθχ][\\u0300-\\u036fʰʱʲʷʼˠˤ˞]*[ːˑ]?";
+const worldSymbols = new RegExp(`^(?:${worldAtom})+(?:\\.(?:${worldAtom})+)*$`, "u");
 function textOf(node) {
     if (node.type === "break")
         return "\n";
@@ -18,7 +22,12 @@ function rowsOf(node) {
         const rows = node.children ?? [];
         return rows.slice(1).map((row) => {
             const cells = row.children ?? [];
-            return cells.length >= 2 ? cells.slice(0, 2).map(textOf).join(": ") : textOf(row);
+            if (cells.length < 2)
+                return textOf(row);
+            const [term, ipa] = cells.slice(0, 2).map((cell) => textOf(cell).trim());
+            // A table's IPA column is often written without the slashes ("| Cleopatra | kliːəˈpætrə |");
+            // the column already says what the cell is, so a bare cell reads as one /…/ pronunciation.
+            return `${term}: ${ipa !== undefined && ipa !== "" && !ipa.includes("/") ? `/${ipa}/` : ipa}`;
         });
     }
     if (node.type === "paragraph")
@@ -27,16 +36,6 @@ function rowsOf(node) {
         return (node.children ?? []).flatMap(rowsOf);
     return ["(unsupported glossary block)"];
 }
-function refused(row, reason) {
-    return {
-        ok: false,
-        reason: "Pronunciation Glossary entry " +
-            row +
-            ": " +
-            reason +
-            ". Edit the glossary or turn off Use Pronunciation Glossary.",
-    };
-}
 function termIdentity(term) {
     return Array.from(term, (character) => {
         const lower = character.toLowerCase();
@@ -48,10 +47,19 @@ function termIdentity(term) {
         return match.test(folded) ? folded : match.test(lower) ? lower : character;
     }).join("");
 }
-export function parsePronunciationGlossary(markdown) {
+// `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 function parsePronunciationGlossary(markdown, language) {
+    const english = language === undefined || language === "en";
+    const symbols = english ? ipaSymbols : worldSymbols;
+    const kind = english ? "standard-English IPA" : "IPA";
     const rows = rowsOf(remark().use(remarkGfm).parse(markdown));
     const entries = new Map();
+    const skipped = [];
     for (const [index, row] of rows.entries()) {
+        const skip = (reason) => {
+            skipped.push({ row: index + 1, reason });
+        };
         const trimmed = row.trim();
         if (trimmed === "" || /^pronunciation glossary:?\s*$/iu.test(trimmed))
             continue;
@@ -61,24 +69,63 @@ export function parsePronunciationGlossary(markdown) {
         if (term === undefined ||
             pronunciation === undefined ||
             !/[\p{L}\p{N}]/u.test(term) ||
-            /[/[\]<>\p{Cc}]/u.test(term))
-            return refused(index + 1, "use Term: /IPA/ or a Term | IPA table");
+            /[/[\]<>\p{Cc}]/u.test(term)) {
+            skip("use Term: /IPA/ or a Term | IPA table");
+            continue;
+        }
         const notation = /^(\/[^/]+\/(?:\s+\/[^/]+\/)*)(?:\s+[^/]+)?$/u.exec(pronunciation);
-        if (notation?.[1] === undefined)
-            return refused(index + 1, "use slash-delimited standard-English IPA");
+        if (notation?.[1] === undefined) {
+            skip(`use slash-delimited ${kind}`);
+            continue;
+        }
         const ipa = Array.from(notation[1].matchAll(/\/([^/]+)\//gu)).flatMap((match) => (match[1] ?? "").trim().split(/\s+/u));
-        if (ipa.length === 0 || ipa.some((word) => !ipaSymbols.test(word)))
-            return refused(index + 1, "use standard-English IPA, not ARPAbet or delivery tags");
-        if (term.split(" ").length !== ipa.length)
-            return refused(index + 1, "supply one IPA word for each written word");
+        if (ipa.length === 0 || ipa.some((word) => !symbols.test(word))) {
+            skip(english
+                ? "use standard-English IPA only, not ARPAbet, delivery tags or non-English sounds; give a foreign name an English approximation"
+                : "use IPA, not ARPAbet or delivery tags");
+            continue;
+        }
+        if (term.split(" ").length !== ipa.length) {
+            skip("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(" "))
-            return refused(index + 1, "conflicting pronunciations were supplied for the same term");
+        if (previous !== undefined && previous.ipa.join(" ") !== ipa.join(" ")) {
+            skip("an earlier entry already gives this term a different pronunciation");
+            continue;
+        }
         if (previous === undefined)
             entries.set(key, { term, ipa });
     }
-    return { ok: true, entries: [...entries.values()] };
+    return skipped.length === 0
+        ? { ok: true, entries: [...entries.values()] }
+        : { ok: true, entries: [...entries.values()], 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)
+        return null;
+    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.");
+}
+export function skippedSpeakerPronunciations(speakers, language) {
+    return speakers.flatMap((speaker) => {
+        if (!speaker.pronunciations?.trim())
+            return [];
+        const parsed = parsePronunciationGlossary(speaker.pronunciations, language);
+        const skipped = parsed.ok ? (parsed.skipped ?? []) : [];
+        return skipped.length === 0 ? [] : [{ speaker: speaker.name.trim() || "A speaker", skipped }];
+    });
+}
+export function skippedSpeakerPronunciationsNotice(rows) {
+    if (rows.length === 0)
+        return null;
+    const parts = rows.map((row) => `${row.speaker}: ${row.skipped.map((one) => `entry ${one.row}: ${one.reason}`).join("; ")}`);
+    return (`Speaker pronunciations: some entries are skipped and read as ordinary text (${parts.join(". ")}). ` +
+        "The rest are used. To use them, fix those entries under Speakers → Pronunciations for that speaker (Play → Narration, or Edit project → Providers).");
 }
 export function pronunciationMatches(source, entries) {
     if (entries.length === 0)
@@ -105,7 +152,7 @@ export function pronunciationMatches(source, entries) {
             continue;
         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). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+            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 });
     }
     return matches;
@@ -117,7 +164,7 @@ export function pronunciationSpans(source, entries) {
         for (const [index, word] of Array.from(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). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+                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}/` });
         }

package/dist/slices/narration/run.js

@@ -14,7 +14,7 @@ import { planLegacyNarration } from "./legacy-plan.js";
 import { observeNarration } from "./live.js";
 // An empty narration source fails the stage immediately with no retries. Thrown from the
 // slice rather than from a provider call, so the attempt wrapper never sees it.
-export const nothingToNarrate = "There is nothing to narrate because the article is empty. Add article text in Edit project → Article, then Retry stage.";
+export const nothingToNarrate = "There is nothing to narrate because the article is empty. Add article text in Edit project → Article, then Try again.";
 // What a chunk piece carries between runs: the text that was sent, and the file it came
 // back as once the provider answered. That is the whole of the resume.
 const chunkPayload = z.object({ text: z.string(), file: z.string().optional() });
@@ -41,7 +41,7 @@ export async function runNarration(deps, context, providers) {
     if (choice === undefined) {
         // Admission refuses a run whose audio is Generate without a provider and a voice, so
         // reaching here is a bug in admission rather than something the user did.
-        throw new Error("No voice is set for the narration. Choose a voice in Edit project → Providers, then Retry stage.");
+        throw new Error("No voice is set for the narration. Choose a voice in Edit project → Providers, then Try again.");
     }
     // Read once, before anything is written: the segment steps below ask it what a previous
     // run already stored, and the body step is the only thing that adds to it.
@@ -168,7 +168,7 @@ async function speakSegments(deps, context, providers, choice, outputs) {
         if (text === "") {
             // The same rule, applied to a segment: there is nothing to say, and silently
             // dropping an intro the user picked would lose it without telling anyone.
-            throw new Error(`The ${segment.category} is empty, so there is nothing to narrate for it. Write the ${segment.category} or remove it in Edit project, then Retry stage.`);
+            throw new Error(`The ${segment.category} is empty, so there is nothing to narrate for it. Write the ${segment.category} or remove it in Edit project, then Try again.`);
         }
         const spoken = await providers.forPiece(piece.id).tts({
             provider: choice.provider,
@@ -200,7 +200,7 @@ function segmentPieces(deps, projectId) {
     if (article === undefined) {
         // Admission writes all six stage rows with the project, so a project without an article
         // stage is a bug rather than a run the user configured.
-        throw new Error("Slopify hit an internal error (the project has no article stage). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the project has no article stage). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     }
     return piecesOf(deps.db, article.id, "segment");
 }
@@ -257,13 +257,13 @@ function store(deps, projectId, role, path, durationMs, choice) {
 }
 function chunkOf(piece) {
     if (piece.payload === null) {
-        throw new Error("Slopify hit an internal error (a saved narration chunk is empty). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (a saved narration chunk is empty). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     }
     return chunkPayload.parse(JSON.parse(piece.payload));
 }
 function segmentOf(piece) {
     if (piece.payload === null) {
-        throw new Error("Slopify hit an internal error (a saved intro or outro is empty). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (a saved intro or outro is empty). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     }
     return segmentPayload.parse(JSON.parse(piece.payload));
 }

package/dist/slices/narration/shared-glossary.js

@@ -22,7 +22,7 @@ export function collectSharedGlossary(deps, exceptProjectId) {
             continue;
         }
         const parsed = parsePronunciationGlossary(text);
-        // A glossary that doesn't parse can't be trusted in someone else's narration either.
+        // Rows it had to skip are left out; a glossary that does not parse at all shares nothing.
         if (!parsed.ok)
             continue;
         for (const entry of parsed.entries) {