@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/voices/join.js

@@ -0,0 +1,35 @@
+// Joining a multi-voice narration: every part is brought to one format (the speakers' voices
+// may come from providers with different sample rates, which the concat demuxer would join
+// wrongly), played at its speaker's pace, and followed by the gap between turns unless the
+// next part continues the same turn. Hand-rolled like every ffmpeg argument list here.
+const rate = 44100;
+export function turnJoinArgs(parts, output) {
+    const chains = parts.map((part, index) => {
+        const filters = [
+            `aformat=sample_fmts=fltp:sample_rates=${String(rate)}:channel_layouts=mono`,
+            ...(part.pace === 1 ? [] : [`atempo=${String(part.pace)}`]),
+            ...(part.gapAfter > 0 ? [`apad=pad_dur=${part.gapAfter.toFixed(3)}`] : []),
+            "asetpts=PTS-STARTPTS",
+        ];
+        return `[${String(index)}:a]${filters.join(",")}[p${String(index)}]`;
+    });
+    chains.push(`${parts.map((_part, index) => `[p${String(index)}]`).join("")}concat=n=${String(parts.length)}:v=0:a=1[a]`);
+    return [
+        "-hide_banner",
+        "-nostdin",
+        "-loglevel",
+        "error",
+        "-nostats",
+        "-y",
+        ...parts.flatMap((part) => ["-i", part.path]),
+        "-filter_complex",
+        chains.join(";"),
+        "-map",
+        "[a]",
+        "-c:a",
+        "libmp3lame",
+        "-b:a",
+        "128k",
+        output,
+    ];
+}

package/dist/slices/voices/languages.js

@@ -0,0 +1,25 @@
+import { languageInfo } from "../../kernel/ports/languages.js";
+// Which saved voices speak a project's language. A voice whose languages are unknown (saved
+// before voices had any, or one the provider said nothing about) is offered for every
+// language: hiding it would hide most voices people already have.
+export function voiceSpeaks(voice, language) {
+    if (voice.languages === undefined)
+        return true;
+    return voice.languages.includes(languageInfo(language).code);
+}
+// The voice picker's list: the voices that speak the language, or every voice when the person
+// asked to see them all. The chosen voice always stays listed so the picker never goes blank.
+export function voicesForLanguage(voices, language, showAll, chosen) {
+    if (showAll)
+        return voices;
+    return voices.filter((voice) => voiceSpeaks(voice, language) || voice.voiceId === chosen);
+}
+// A warning, never a refusal: the provider's language list may be incomplete, and many voices
+// read other languages well. Undefined when there is nothing to say.
+export function voiceLanguageWarning(voice, language) {
+    if (voice === undefined || voiceSpeaks(voice, language))
+        return undefined;
+    const wanted = languageInfo(language).name;
+    const spoken = (voice.languages ?? []).map((code) => languageInfo(code).code === code ? languageInfo(code).name : code);
+    return `${voice.name} is listed for ${spoken.join(", ")}, not ${wanted}, so it may read the ${wanted} narration with the wrong accent. Pick a ${wanted} voice under Narration, or correct the voice's languages in Settings → Voices.`;
+}

package/dist/slices/voices/model.js

@@ -0,0 +1,218 @@
+import { z } from "zod";
+// Multiple voices: a run whose narration is a script of speaker turns rather than one voice
+// reading an article. Absent on a run is the Narration format, which is every project saved
+// before this existed, and nothing about such a run reads anything in this slice.
+export const voiceFormats = ["audiobook", "podcast", "drama", "interview"];
+export const voiceFormatLabels = {
+    audiobook: "Audiobook",
+    podcast: "Podcast",
+    drama: "Radio drama",
+    interview: "Interview",
+};
+export const speakerRoles = ["narrator", "host", "guest", "character"];
+// Where the script comes from. `script` asks the text model for speaker turns with a Script
+// prompt; `attribute` (audiobooks) writes or takes the article as usual and has the text model
+// hand its dialogue to the speakers.
+export const scriptSources = ["script", "attribute"];
+export const speakersMax = 10;
+export const speakerNameMax = 40;
+export const paceSteps = [0.8, 0.9, 1, 1.1, 1.2];
+export const turnGapSteps = [0, 0.2, 0.35, 0.5, 0.8, 1.2];
+export const defaultTurnGapSeconds = 0.35;
+const voiceChoiceSchema = z.object({
+    provider: z.string(),
+    model: z.string(),
+    voice: z.string(),
+});
+export const speakerSchema = z.object({
+    // Stable across renames, so a turn keeps its speaker when the name is edited.
+    id: z
+        .string()
+        .min(1)
+        .max(60)
+        .regex(/^[a-z0-9-]+$/),
+    name: z.string().max(speakerNameMax),
+    role: z.enum(speakerRoles),
+    voice: voiceChoiceSchema,
+    // Played faster or slower after synthesis, so a change re-joins the audio and pays for nothing.
+    pace: z.number().optional(),
+    // `Term: /IPA/` lines, the Pronunciation Glossary's own format, for this speaker only.
+    pronunciations: z.string().max(20_000).optional(),
+    // The cast entry this speaker was picked from, when the cast library holds it.
+    castId: z.string().max(200).optional(),
+    // SHA-256 of the cast member's first picture when the run started: the portrait in a podcast
+    // or interview's speaker panel. Absent is the initials tile.
+    portrait: z
+        .string()
+        .regex(/^[0-9a-f]{64}$/)
+        .optional(),
+});
+// A book: a series of audiobook projects, one per chapter, that share their speakers, voices,
+// cast and settings. "Make the next chapter" on a finished chapter starts the next one in Play.
+// The MP3 and M4B carry it as their album and track. Absent is a project on its own, which is
+// every project made before this.
+export const bookTitleMax = 200;
+export const bookChapterMax = 9999;
+export const bookSchema = z
+    .object({ title: z.string().max(bookTitleMax), chapter: z.number() })
+    .strict()
+    .readonly();
+export function bookLabel(book) {
+    return `${book.title.trim()} · Chapter ${String(book.chapter)}`;
+}
+export const voicesSettingsSchema = z.object({
+    format: z.enum(voiceFormats),
+    source: z.enum(scriptSources),
+    speakers: z.array(speakerSchema).max(speakersMax),
+    turnGapSeconds: z.number(),
+    // The speaker's name before their captions ("Ada: ...").
+    nameTags: z.boolean(),
+    // Consecutive turns go to a provider's own multi-speaker request where it has one.
+    nativeDialogue: z.boolean(),
+    // MP3 and M4B files with chapter markers beside the video.
+    audioFiles: z.boolean(),
+    // The book this project is a chapter of. Absent is none.
+    book: bookSchema.optional(),
+});
+// `hosts` are the channel's hosts as speakers (`castHosts`): a podcast or an interview starts
+// with them in place of the placeholder hosts, and the other formats ignore them.
+export function defaultVoicesSettings(format, hosts = []) {
+    return {
+        format,
+        source: "script",
+        speakers: withHosts(format, starterSpeakers(format), hosts),
+        turnGapSeconds: defaultTurnGapSeconds,
+        nameTags: format === "podcast" || format === "interview",
+        nativeDialogue: true,
+        audioFiles: true,
+    };
+}
+// A podcast keeps a placeholder host only while it has fewer than two; an interview keeps its
+// guest after the hosts.
+function withHosts(format, starters, hosts) {
+    if (hosts.length === 0 || (format !== "podcast" && format !== "interview"))
+        return [...starters];
+    const cast = hosts.slice(0, speakersMax - 1).map((host) => ({ ...host, role: "host" }));
+    const fill = format === "podcast"
+        ? starters.slice(0, Math.max(0, 2 - cast.length))
+        : starters.filter((one) => one.role !== "host");
+    return [...cast, ...fill.filter((one) => !cast.some((host) => host.id === one.id))];
+}
+function starterSpeakers(format) {
+    const blank = { provider: "", model: "", voice: "" };
+    const speaker = (id, name, role) => ({
+        id,
+        name,
+        role,
+        voice: blank,
+    });
+    switch (format) {
+        case "audiobook":
+            return [speaker("narrator", "Narrator", "narrator")];
+        case "podcast":
+            return [speaker("host-1", "Alex", "host"), speaker("host-2", "Sam", "host")];
+        case "drama":
+            return [
+                speaker("narrator", "Narrator", "narrator"),
+                speaker("character-1", "Mara", "character"),
+            ];
+        case "interview":
+            return [speaker("host-1", "Host", "host"), speaker("guest-1", "Guest", "guest")];
+    }
+}
+export function usesVoices(draft) {
+    return draft.voices !== undefined && draft.sources.audio === "generate";
+}
+// The article prompt a script run picks is a Script prompt, and the article is the script.
+export function usesScriptPrompt(draft) {
+    return usesVoices(draft) && draft.voices?.source === "script";
+}
+// The rules a multi-voice run must pass before it starts, named for the control to fix.
+export function voicesProblems(settings) {
+    const problems = [];
+    const { speakers } = settings;
+    if (speakers.length === 0)
+        problems.push({
+            field: "voices.speakers",
+            message: "Add at least one speaker under Speakers (Play → Narration, or Edit project → Providers).",
+        });
+    if (settings.source === "attribute" && settings.format !== "audiobook")
+        problems.push({
+            field: "voices.source",
+            message: "Only audiobooks can hand an existing text's dialogue to speakers. Choose Write a script under Speakers (Play → Narration, or Edit project → Providers).",
+        });
+    if ((settings.format === "podcast" || settings.format === "interview") && speakers.length < 2)
+        problems.push({
+            field: "voices.speakers",
+            message: `A ${voiceFormatLabels[settings.format].toLowerCase()} needs at least two speakers. Add one under Speakers (Play → Narration, or Edit project → Providers).`,
+        });
+    if ((settings.format === "audiobook" || settings.format === "drama") &&
+        !speakers.some((speaker) => speaker.role === "narrator"))
+        problems.push({
+            field: "voices.speakers",
+            message: `An ${settings.format === "drama" ? "radio drama" : "audiobook"} needs a narrator. Set one speaker's role to Narrator under Speakers (Play → Narration, or Edit project → Providers).`,
+        });
+    const names = new Set();
+    const ids = new Set();
+    for (const [index, speaker] of speakers.entries()) {
+        const field = `voices.speakers.${String(index)}`;
+        const name = speaker.name.trim();
+        if (name === "")
+            problems.push({ field: `${field}.name`, message: "Enter a name for this speaker." });
+        else if (!/^[\p{L}\p{N}][\p{L}\p{N} .'-]*$/u.test(name))
+            problems.push({
+                field: `${field}.name`,
+                message: "Use only letters, numbers, spaces, dots, apostrophes and hyphens in a speaker name, starting with a letter or number.",
+            });
+        else if (names.has(name.toLowerCase()))
+            problems.push({
+                field: `${field}.name`,
+                message: `Two speakers are called "${name}". Give each speaker a different name.`,
+            });
+        names.add(name.toLowerCase());
+        if (ids.has(speaker.id))
+            problems.push({
+                field: `${field}.name`,
+                message: "Two speakers share one id. Remove one of them and add it again.",
+            });
+        ids.add(speaker.id);
+        if (speaker.voice.provider.trim() === "" || speaker.voice.model.trim() === "")
+            problems.push({
+                field: `${field}.voice`,
+                message: `Choose a voice provider and model for ${name || "this speaker"}.`,
+            });
+        else if (speaker.voice.voice.trim() === "")
+            problems.push({
+                field: `${field}.voice.voice`,
+                message: `Choose a voice for ${name || "this speaker"}.`,
+            });
+        if (speaker.pace !== undefined && !paceSteps.includes(speaker.pace))
+            problems.push({
+                field: `${field}.pace`,
+                message: `Pick a pace from the list for ${name || "this speaker"}.`,
+            });
+    }
+    if (settings.book !== undefined) {
+        if (settings.book.title.trim() === "")
+            problems.push({
+                field: "voices.book.title",
+                message: "Enter the book's title under Speakers (Play → Narration), or remove the book to make a project on its own.",
+            });
+        if (!Number.isInteger(settings.book.chapter) ||
+            settings.book.chapter < 1 ||
+            settings.book.chapter > bookChapterMax)
+            problems.push({
+                field: "voices.book.chapter",
+                message: `Enter a chapter number from 1 to ${String(bookChapterMax)} under Speakers (Play → Narration).`,
+            });
+    }
+    if (!turnGapSteps.includes(settings.turnGapSeconds))
+        problems.push({
+            field: "voices.turnGapSeconds",
+            message: "Pick a gap between turns from the list under Speakers (Play → Narration, or Edit project → Providers).",
+        });
+    return problems;
+}
+export function speakerPace(speaker) {
+    return speaker.pace ?? 1;
+}

package/dist/slices/voices/palette.js

@@ -0,0 +1,26 @@
+// One colour per speaker, by their place in the speaker list, for captions, the speaker panel
+// and the script view. The same six values are the `--color-speaker-N` design tokens in
+// `packages/web/src/styles/index.css`; a seventh speaker starts the list again.
+export const speakerPalette = [
+    "#f2c14e",
+    "#6ec3f4",
+    "#f28482",
+    "#9bcb4f",
+    "#c39bd3",
+    "#f5a65b",
+];
+export function speakerColour(index) {
+    return (speakerPalette[((index % speakerPalette.length) + speakerPalette.length) % speakerPalette.length] ?? "#ffffff");
+}
+// ASS writes colours blue first: &HAABBGGRR in a style (alpha 00 is opaque) and &HBBGGRR& in
+// an inline override.
+export function assColour(hex, alpha = 0) {
+    return `&H${alpha.toString(16).padStart(2, "0")}${bgr(hex)}`.toUpperCase();
+}
+export function assInlineColour(hex) {
+    return `&H${bgr(hex)}&`.toUpperCase();
+}
+function bgr(hex) {
+    const value = hex.replace("#", "");
+    return `${value.slice(4, 6)}${value.slice(2, 4)}${value.slice(0, 2)}`;
+}

package/dist/slices/voices/panel.js

@@ -0,0 +1,91 @@
+import { assInlineColour } from "./palette.js";
+// The podcast and interview layout, drawn by libass with the captions: a row of speaker tiles
+// over the image flow, the speaker who is talking lit in their colour, and their name as a
+// lower third. A tile shows the speaker's initials, or, when their cast member has a picture,
+// is left empty for the renderer to lay the portrait into (`panelTiles` is where each tile
+// sits, `video/ffmpeg.ts` the overlay) and the lit outline is drawn over it.
+export function usesSpeakerPanel(format) {
+    return format === "podcast" || format === "interview";
+}
+// Consecutive cues of one speaker are one run; a pause under 1.5 s does not end it, so the
+// tile does not flicker between sentences.
+export function speakerRuns(cues) {
+    const runs = [];
+    for (const cue of cues) {
+        if (cue.speaker === undefined)
+            continue;
+        const last = runs.at(-1);
+        if (last !== undefined && last.speaker === cue.speaker && cue.start - last.end < 1.5)
+            runs[runs.length - 1] = { ...last, end: cue.end };
+        else
+            runs.push({ speaker: cue.speaker, start: cue.start, end: cue.end });
+    }
+    return runs;
+}
+export function initials(name) {
+    const parts = name.trim().split(/\s+/).filter(Boolean);
+    const letters = parts.length > 1
+        ? `${parts[0]?.[0] ?? ""}${parts.at(-1)?.[0] ?? ""}`
+        : (parts[0] ?? "").slice(0, 2);
+    return letters.toUpperCase();
+}
+// Where each speaker's square tile sits: one row, centred near the top of the frame.
+export function panelTiles(count, frame) {
+    const { width, height } = frame;
+    const size = Math.round(Math.min(width, height) * 0.11);
+    const gap = Math.round(size * 0.3);
+    const row = count * size + (count - 1) * gap;
+    const left = Math.round((width - row) / 2);
+    const y = Math.round(height * 0.05);
+    return Array.from({ length: count }, (_value, index) => ({
+        x: left + index * (size + gap),
+        y,
+        size,
+    }));
+}
+export function speakerPanelEvents(cues, speakers, frame, totalSeconds) {
+    if (speakers.length === 0 || totalSeconds <= 0)
+        return [];
+    const { width, height } = frame;
+    const tiles = panelTiles(speakers.length, frame);
+    const size = tiles[0]?.size ?? 0;
+    const top = tiles[0]?.y ?? 0;
+    const end = stamp(totalSeconds);
+    const box = (w, h) => `m 0 0 l ${w} 0 ${w} ${h} 0 ${h}`;
+    const events = [];
+    for (const [index, speaker] of speakers.entries()) {
+        const x = tiles[index]?.x ?? 0;
+        // The portrait fills this tile in the render; the initials would only cover it.
+        if (speaker.portrait === true)
+            continue;
+        events.push(`Dialogue: 1,0:00:00.00,${end},Default,,0,0,0,,{\\an7\\pos(${x},${top})\\p1\\bord0\\shad0\\1c&H202020&\\1a&H40&}${box(size, size)}{\\p0}`, `Dialogue: 3,0:00:00.00,${end},Default,,0,0,0,,{\\an5\\pos(${x + size / 2},${top + size / 2})\\fs${Math.round(size * 0.4)}\\b1\\bord0\\shad0\\1c${assInlineColour(speaker.colour)}}${plain(initials(speaker.name))}`);
+    }
+    const index = new Map(speakers.map((speaker, at) => [speaker.id, at]));
+    const lowerSize = Math.round(Math.min(width, height) * 0.045);
+    for (const run of speakerRuns(cues)) {
+        const at = index.get(run.speaker);
+        const speaker = at === undefined ? undefined : speakers[at];
+        if (at === undefined || speaker === undefined)
+            continue;
+        const x = tiles[at]?.x ?? 0;
+        const colour = assInlineColour(speaker.colour);
+        const from = stamp(run.start);
+        const to = stamp(run.end);
+        events.push(
+        // The lit tile: an outline in the speaker's colour round their tile.
+        `Dialogue: 2,${from},${to},Default,,0,0,0,,{\\an7\\pos(${x},${top})\\p1\\bord${Math.max(3, Math.round(size / 20))}\\shad0\\1a&HFF&\\3c${colour}}${box(size, size)}{\\p0}`, 
+        // The lower third: the name on a dark band at the left, above where captions sit.
+        `Dialogue: 2,${from},${to},Default,,0,0,0,,{\\an1\\pos(${Math.round(width * 0.05)},${Math.round(height * 0.74)})\\fs${lowerSize}\\b1\\bord${Math.round(lowerSize / 3)}\\3c&H101010&\\3a&H60&\\shad0\\1c${colour}\\fad(200,200)}${plain(speaker.name)}`);
+    }
+    return events;
+}
+function plain(text) {
+    return text
+        .replace(/[{}\\]/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function stamp(seconds) {
+    const cs = Math.max(0, Math.round(seconds * 100));
+    return `${Math.floor(cs / 360_000)}:${String(Math.floor(cs / 6000) % 60).padStart(2, "0")}:${String(Math.floor(cs / 100) % 60).padStart(2, "0")}.${String(cs % 100).padStart(2, "0")}`;
+}

package/dist/slices/voices/portraits.js

@@ -0,0 +1,55 @@
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { sniffImage } from "../channels/images.js";
+import { imageBlob } from "../channels/repo.js";
+import { usesVoices } from "./model.js";
+import { panelTiles, usesSpeakerPanel } from "./panel.js";
+export function panelPortraits(db, voices) {
+    if (voices === undefined || !usesSpeakerPanel(voices.format))
+        return [];
+    return voices.speakers.map((speaker) => {
+        if (speaker.portrait === undefined)
+            return undefined;
+        const blob = imageBlob(db, speaker.portrait);
+        const mime = blob === undefined ? undefined : sniffImage(blob.bytes);
+        return blob === undefined || mime === undefined
+            ? undefined
+            : {
+                sha256: speaker.portrait,
+                bytes: blob.bytes,
+                extension: mime === "image/png" ? ".png" : ".jpg",
+            };
+    });
+}
+// What the portraits add to the caption file's fingerprint: nothing unless a panel speaker has
+// one, so captions made before portraits (or without any) keep the fingerprint they had.
+export function portraitValues(voices) {
+    if (!usesSpeakerPanel(voices.format))
+        return undefined;
+    const values = voices.speakers.map((speaker) => speaker.portrait ?? null);
+    return values.some((value) => value !== null) ? values : undefined;
+}
+// The portraits written beside the caption file the join reads, at the tiles the caption file
+// left empty for them. Undefined when no speaker has one, so every other video renders with the
+// arguments it always had.
+export function writePortraits(db, config, directory) {
+    const voices = usesVoices(config) ? config.voices : undefined;
+    const portraits = panelPortraits(db, voices);
+    if (voices === undefined || portraits.every((one) => one === undefined))
+        return undefined;
+    // The caption file's frame (`rebuild/runtime-subtitles.ts`), so a portrait lands in its tile.
+    const tiles = panelTiles(voices.speakers.length, config.format === "16:9" ? { width: 1920, height: 1080 } : { width: 1080, height: 1920 });
+    const overlays = [];
+    const recorded = [];
+    portraits.forEach((portrait, index) => {
+        const tile = tiles[index];
+        const speaker = voices.speakers[index];
+        if (portrait === undefined || tile === undefined || speaker === undefined)
+            return;
+        const path = `portrait-${String(index)}${portrait.extension}`;
+        writeFileSync(join(directory, path), portrait.bytes, { mode: 0o600 });
+        overlays.push({ path, x: tile.x, y: tile.y, size: tile.size });
+        recorded.push({ speaker: speaker.id, sha256: portrait.sha256 });
+    });
+    return { overlays, recorded };
+}

package/dist/slices/voices/script.js

@@ -0,0 +1,136 @@
+import { voiceFormatLabels } from "./model.js";
+const heading = /^#{1,6}\s+(.+?)\s*#*\s*$/;
+const turnLine = /^\*{0,2}([^:*\n]{1,60}?)\*{0,2}\s*:\s*\*{0,2}\s*(.*)$/;
+// With `keepMarkdown`, every turn also carries its lines as written (`markdown`).
+export function parseScript(markdown, speakers, keepMarkdown = false) {
+    const byName = new Map(speakers.map((speaker) => [speaker.name.trim().toLowerCase(), speaker]));
+    const names = speakers.map((speaker) => speaker.name.trim()).join(", ");
+    const turns = [];
+    const sections = [];
+    let open = false;
+    for (const [at, raw] of markdown.replace(/\r\n?/g, "\n").split("\n").entries()) {
+        const line = raw.trim();
+        const number = at + 1;
+        if (line === "") {
+            open = false;
+            continue;
+        }
+        const title = heading.exec(line);
+        if (title !== null) {
+            sections.push({ title: clean(title[1] ?? ""), firstTurn: turns.length + 1 });
+            open = false;
+            continue;
+        }
+        // Horizontal rules and the like carry no words.
+        if (/^([-*_=~])\1{2,}$/.test(line)) {
+            open = false;
+            continue;
+        }
+        const turn = turnLine.exec(line);
+        const speaker = turn === null ? undefined : byName.get((turn[1] ?? "").trim().toLowerCase());
+        if (turn !== null && speaker !== undefined) {
+            turns.push({ speaker: speaker.id, lines: [turn[2] ?? ""], section: sections.length - 1 });
+            open = true;
+            continue;
+        }
+        const last = turns.at(-1);
+        if (open && last !== undefined) {
+            last.lines.push(line);
+            continue;
+        }
+        return {
+            ok: false,
+            reason: turn === null
+                ? `Line ${String(number)} of the script is not a turn. Start every turn with a speaker's name and a colon (${names}), one turn per paragraph.`
+                : `Line ${String(number)} of the script is spoken by "${(turn[1] ?? "").trim()}", who is not one of the speakers (${names}). Use only these names, or add the speaker under Speakers (Play → Narration, or Edit project → Providers).`,
+        };
+    }
+    const spoken = [];
+    for (const turn of turns) {
+        const text = clean(turn.lines.join(" "));
+        if (text === "")
+            continue;
+        spoken.push({
+            index: spoken.length + 1,
+            speaker: turn.speaker,
+            text,
+            section: turn.section,
+            ...(keepMarkdown ? { markdown: turn.lines.join("\n") } : {}),
+        });
+    }
+    if (spoken.length === 0)
+        return {
+            ok: false,
+            reason: `The script has no spoken turns. Write each turn as a speaker's name, a colon and their words (${names}).`,
+        };
+    // A section keeps its place by its first turn that has words; one without words is dropped.
+    const kept = [];
+    const sectionMap = new Map();
+    for (const [at, section] of sections.entries()) {
+        const first = spoken.find((turn) => turn.section === at);
+        if (first === undefined || section.title === "")
+            continue;
+        sectionMap.set(at, kept.length);
+        kept.push({ title: section.title, firstTurn: first.index });
+    }
+    return {
+        ok: true,
+        script: {
+            turns: spoken.map((turn) => ({ ...turn, section: sectionMap.get(turn.section) ?? -1 })),
+            sections: kept,
+        },
+    };
+}
+// Emphasis, links and stage directions come out; the words stay.
+function clean(text) {
+    return text
+        .replace(/\[[^\]]*\]\([^)]*\)/g, (link) => link.slice(1, link.indexOf("]")))
+        .replace(/\[[^\]]*\]/g, " ")
+        .replace(/(\*{1,3}|_{1,3})(\S(?:.*?\S)?)\1/g, "$2")
+        .replace(/`/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+// The script as plain text for the reading view and the Script download: the same format,
+// normalised, so it parses back to itself.
+export function formatScript(script, speakers) {
+    const names = new Map(speakers.map((speaker) => [speaker.id, speaker.name.trim()]));
+    const lines = [];
+    for (const turn of script.turns) {
+        const section = script.sections.find((one) => one.firstTurn === turn.index);
+        if (section !== undefined)
+            lines.push(`# ${section.title}`, "");
+        lines.push(`${names.get(turn.speaker) ?? turn.speaker}: ${turn.text}`, "");
+    }
+    return `${lines.join("\n").trim()}\n`;
+}
+const formatGuidance = {
+    audiobook: "An audiobook: the narrator reads the prose; characters speak only their own quoted dialogue.",
+    podcast: "A podcast: the hosts talk with each other naturally, taking short turns, reacting and building on what the other said.",
+    drama: "A radio drama: the narrator sets scenes briefly; the characters carry the story through what they say.",
+    interview: "An interview or debate: the host asks and steers; guests answer at length and may disagree.",
+};
+export function scriptContract(format, speakers) {
+    return [
+        `Write a script for ${voiceFormatLabels[format].toLowerCase()} narration. ${formatGuidance[format]}`,
+        "Speakers (name - role):",
+        ...speakers.map((speaker) => `- ${speaker.name.trim()} - ${speaker.role}`),
+        "Format rules, followed exactly:",
+        "- Every turn is one paragraph that starts with the speaker's name and a colon, e.g. `Name: words`.",
+        "- Separate turns with a blank line. Use only the names above.",
+        "- Start each section with a Markdown heading line (`# Title`); sections become chapters.",
+        "- Write only words to be spoken: no stage directions, no bracketed notes, no lists or tables.",
+    ].join("\n");
+}
+export function scriptMessages(format, speakers, prompt, notes) {
+    const trimmed = notes?.trim();
+    return [
+        { role: "system", content: scriptContract(format, speakers) },
+        {
+            role: "user",
+            content: trimmed === undefined || trimmed === ""
+                ? prompt
+                : `Research notes\n\n${trimmed}\n\n${prompt}`,
+        },
+    ];
+}

package/dist/slices/voices/timing.js

@@ -0,0 +1,58 @@
+// How far ahead a word is looked for: past it, the aligner is more likely to have left the
+// word out than the transcript to hold that many words it did not hear.
+const lookahead = 60;
+export function attributeWords(turns, words) {
+    const tokens = turns.flatMap((turn) => turn.text
+        .trim()
+        .split(/\s+/)
+        .filter((token) => token !== "")
+        .map((token) => ({ token, speaker: turn.speaker, turn: turn.turn })));
+    const first = tokens[0];
+    let at = 0;
+    let speaker = first?.speaker;
+    let turn = first?.turn;
+    return words.map((word) => {
+        const parts = word.text.trim().split(/\s+/);
+        const head = parts[0] ?? "";
+        for (let look = at; look < Math.min(tokens.length, at + lookahead); look += 1) {
+            const token = tokens[look];
+            if (token === undefined || token.token !== head)
+                continue;
+            speaker = token.speaker;
+            turn = token.turn;
+            at = look + parts.length;
+            break;
+        }
+        return speaker === undefined ? word : { ...word, speaker, turn };
+    });
+}
+// Who speaks a caption cue edited by hand: the speaker whose words fill most of its time, or,
+// for a cue moved into a pause, the speaker of the nearest word. Undefined when no word has a
+// speaker (a one-voice run).
+export function cueSpeaker(cue, words) {
+    const overlap = new Map();
+    let nearest;
+    for (const word of words) {
+        if (word.speaker === undefined)
+            continue;
+        const shared = Math.min(cue.end, word.end) - Math.max(cue.start, word.start);
+        if (shared > 0)
+            overlap.set(word.speaker, (overlap.get(word.speaker) ?? 0) + shared);
+        const distance = Math.max(0, word.start - cue.end, cue.start - word.end);
+        if (nearest === undefined || distance < nearest.distance)
+            nearest = { speaker: word.speaker, distance };
+    }
+    let best;
+    for (const entry of overlap)
+        if (best === undefined || entry[1] > best[1])
+            best = entry;
+    return best?.[0] ?? nearest?.speaker;
+}
+// Where each turn starts on the final timeline: its first timed word.
+export function turnStarts(words) {
+    const starts = new Map();
+    for (const word of words)
+        if (word.turn !== undefined && !starts.has(word.turn))
+            starts.set(word.turn, word.start);
+    return starts;
+}

package/dist/slices/youtube/answer.js

@@ -43,7 +43,7 @@ const answerSchema = z.object({
     hashtags: z.array(z.string()),
     tags: z.array(z.string()),
 });
-const fix = "Retry stage, or choose another model in Edit project → Providers.";
+const fix = "Try again, or choose another model in Edit project → Providers.";
 // Reads and checks the model's answer. The reason is the sentence the stage shows; the
 // provider wrapper's `check` asks the model again while attempts remain.
 export function checkDescriptionAnswer(text, durationSeconds) {