@gentbajko/slopify 2.4.0 → 3.0.0

package/dist/slices/narration/chunk.js

@@ -20,9 +20,20 @@ export function chunkNarration(text, chunking) {
     }
 }
 // What "N words" counts: runs of non-space. Exported because it is half of the rule -
-// a test that asserts a chunk fits in N has to count the same way the cut did.
+// a test that asserts a chunk fits in N has to count the same way the cut did. Chinese,
+// Japanese, Thai and the other scripts written without spaces are counted by the platform's
+// own word breaker instead, or a whole paragraph would be one "word"; text without them
+// (every English narration) is counted exactly as before.
+const unspaced = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Thai}\p{Script=Lao}\p{Script=Khmer}\p{Script=Myanmar}]/u;
 export function wordsIn(text) {
-    return text.split(/\s+/).filter((word) => word !== "").length;
+    if (!unspaced.test(text))
+        return text.split(/\s+/).filter((word) => word !== "").length;
+    const segmenter = new Intl.Segmenter("en", { granularity: "word" });
+    let count = 0;
+    for (const part of segmenter.segment(text))
+        if (part.isWordLike === true)
+            count += 1;
+    return count;
 }
 export function sameChunking(left, right) {
     const a = left ?? defaultChunking;
@@ -52,11 +63,12 @@ function sentenceRuns(text, budget, measure) {
     // The provider-specific planning layer applies any hard request limit afterwards.
     return nonEmpty(chunks);
 }
-// ceiling: segmented as English. `Intl.Segmenter` is the platform's own sentence breaker
-// (ICU ships with Node), so no dependency and no regex full of abbreviations; the locale
-// is fixed because a run carries no language and the default one varies by machine. The
-// upgrade is a language on the run configuration, passed through to here.
-function* sentences(text) {
+// `Intl.Segmenter` is the platform's own sentence breaker (ICU ships with Node), so no
+// dependency and no regex full of abbreviations. Its sentence rules are Unicode's (UAX #29)
+// for every language: "。", "！", "।", "؟" and "¿…?" end or open sentences whatever the
+// locale, so the project language needs no locale here, and "en" keeps it the same on every
+// machine (the default locale varies).
+export function* sentences(text) {
     // Built per call rather than held at module scope: the standards forbid a module-level
     // singleton, and constructing one costs microseconds against a call that just read an
     // article off disk.

package/dist/slices/narration/concat.js

@@ -46,10 +46,10 @@ export async function joinNarration(deps, input) {
     const first = input.files[0];
     if (first === undefined) {
         // The stage refuses an empty narration before it gets here, so this is a bug.
-        throw new Error("Slopify hit an internal error (there is no narration audio to join). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (there is no narration audio to join). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     }
     mkdirSync(dirname(input.output), { recursive: true, mode: 0o700 });
-    if (input.files.length === 1) {
+    if (input.files.length === 1 && input.reencode !== true) {
         // Whole-text mode, and any run whose article is one paragraph: there is nothing to
         // join, and re-encoding the only chunk would lose quality for no reason.
         input.signal.throwIfAborted();

package/dist/slices/narration/describe.js

@@ -0,0 +1,45 @@
+import { withLanguage } from "../../kernel/ports/languages.js";
+const instructions = {
+    table: "Describe this table for a listener in 1–4 sentences in the narration's language and tone; give the pattern and the notable values, not every cell; never read it row by row.",
+    figure: "Describe this figure for a listener in 1–3 sentences in the narration's language and tone, from its caption, alt text and legend (and the attached picture, when there is one): say what it shows and what to take from it. Never say that a figure shows something without saying what; explain colours or symbols only through what they stand for.",
+    diagram: "Describe this diagram or chart for a listener in 1–3 sentences in the narration's language and tone: what it connects or compares and what it tells us. Never read labels, arrows or axis ticks one by one.",
+    math: "Say what this equation means for a listener in 1–3 sentences in the narration's language and tone: how the quantities depend on each other (for example, “evaporation grows with temperature and falls with humidity”), not symbol by symbol. A single short symbol may be read as it is.",
+    code: "Summarise what this code does for a listener in one or two sentences in the narration's language and tone, naming the language when it helps (for example, “a Rust function that carves river channels by lowering the terrain along the flow”). Never read code, symbols or names of variables aloud.",
+};
+const inlineMath = "Rewrite this paragraph so it can be read aloud, in the narration's language and tone: keep its words, but say each formula's meaning in words rather than symbol by symbol. A single short symbol may be read as it is.";
+const answerRules = "Answer with the spoken passage only: plain sentences a narrator reads out, no Markdown, no lists, no headings, no quotation marks around the whole answer, no preamble such as “Here is”.";
+export function describeInstruction(block) {
+    return block.kind === "math" && block.inline === true ? inlineMath : instructions[block.kind];
+}
+export function describeMessages(block, style, language) {
+    const guidance = style.trim();
+    const system = [
+        describeInstruction(block),
+        answerRules,
+        ...(guidance === ""
+            ? []
+            : [
+                `Style guidance for the narration (follow its tone; ignore anything about formats or cues):\n${guidance}`,
+            ]),
+    ].join("\n\n");
+    const user = [
+        ...(block.section === null ? [] : [`Section: ${block.section}`]),
+        ...(block.lang === undefined ? [] : [`Language of the code: ${block.lang}`]),
+        block.source,
+    ].join("\n\n");
+    return withLanguage([
+        { role: "system", content: system },
+        { role: "user", content: user },
+    ], language);
+}
+// The passage as the narration says it: one paragraph, no Markdown a voice would read out.
+export function spokenPassage(answer) {
+    return answer
+        .replace(/```[\s\S]*?```/g, " ")
+        .replace(/^\s*(?:[-*+]|\d+[.)]|#{1,6})\s+/gm, "")
+        .replace(/[*_`#|]/g, "")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/^["“](.*)["”]$/s, "$1")
+        .trim();
+}

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

@@ -0,0 +1,63 @@
+// Pauses between sentences. Some voices (Inworld's TTS-2 among them) run one sentence into the
+// next with barely a breath, so a narration sounds rushed. With a minimum set, the join finds
+// the quiet after each sentence in every narration piece and lengthens it to at least that
+// long by adding silence in the middle of it (`pauses.ts`): an existing pause is never
+// shortened and a word is never cut. It happens in the join, before the word timing reads the
+// narration, so the captions, the word-by-word highlights, the cuts, the shorts' clips, the
+// chapters and the M4B's marks are timed on the paced narration and stay in step with it.
+//
+// A paragraph's minimum is separate and 0 (the sentence minimum only) unless set: the pause
+// between paragraphs is mostly the narration prompt's and the voice's to make.
+//
+// Browser-safe: Play and Edit project read these limits. A run without either has neither on
+// its config, which is what every project saved before them was, and the joins keep their
+// fingerprints then.
+// ceiling: a quarter second reads brisk, 0.35 to 0.45 natural or documentary, 0.5 to 0.8 an
+// audiobook's relaxed pace, and above 0.8 sleep content; beyond 2 s it stops sounding like a
+// pause between sentences.
+export const defaultSentencePauseSeconds = 0.4;
+export const pauseSecondsMax = 2;
+export const pauseSecondsStep = 0.05;
+// What a run's config asks for; undefined when neither minimum is set.
+export function pausesOf(config) {
+    const sentenceSeconds = config.sentencePauseSeconds ?? 0;
+    const paragraphSeconds = config.paragraphPauseSeconds ?? 0;
+    return sentenceSeconds > 0 || paragraphSeconds > 0
+        ? { sentenceSeconds, paragraphSeconds }
+        : undefined;
+}
+export function pauseProblem(value, name) {
+    const steps = value / pauseSecondsStep;
+    return Number.isFinite(value) &&
+        value >= 0 &&
+        value <= pauseSecondsMax &&
+        Math.abs(steps - Math.round(steps)) < 1e-6
+        ? undefined
+        : `The pause between ${name} must be between 0 and ${String(pauseSecondsMax)} seconds, in steps of ${String(pauseSecondsStep)}. Change it under Play → Outputs → Export, or Edit project → Pauses and volume.`;
+}
+export function pauseFields(config) {
+    const fields = [];
+    if (config.sentencePauseSeconds !== undefined) {
+        const problem = pauseProblem(config.sentencePauseSeconds, "sentences");
+        if (problem !== undefined)
+            fields.push({ field: "sentencePauseSeconds", message: problem });
+    }
+    if (config.paragraphPauseSeconds !== undefined) {
+        const problem = pauseProblem(config.paragraphPauseSeconds, "paragraphs");
+        if (problem !== undefined)
+            fields.push({ field: "paragraphPauseSeconds", message: problem });
+    }
+    return fields;
+}
+// Play's typed pauses as a run's config holds them: absent text is the default (the sentence
+// default, no paragraph minimum), a value of 0 is left off, and text that is not a number is
+// NaN, which the rule refuses in place.
+export function pausesOfForm(form) {
+    const typed = (raw, fallback) => raw === undefined || raw.trim() === "" ? fallback : Number(raw.trim().replace(",", "."));
+    const sentence = typed(form.sentencePause, defaultSentencePauseSeconds);
+    const paragraph = typed(form.paragraphPause, 0);
+    return {
+        ...(sentence === 0 ? {} : { sentencePauseSeconds: sentence }),
+        ...(paragraph === 0 ? {} : { paragraphPauseSeconds: paragraph }),
+    };
+}

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 }