@gentbajko/slopify 2.4.0 → 3.0.0

package/dist/slices/video/plan.js

@@ -1,6 +1,6 @@
 import { chapterCuts, narrationShotFrames } from "./cuts.js";
 import { editListVersion, } from "./edit-list.js";
-import { chapterCardSeconds } from "./edit-settings.js";
+import { chapterCardSeconds, endScreenSeconds } from "./edit-settings.js";
 import { hasLook } from "./look.js";
 import { motionFor } from "./motion.js";
 import { withTransitions } from "./transitions.js";
@@ -31,13 +31,21 @@ export function decimal(thousandths) {
     const whole = String(Math.floor(thousandths / 1000));
     return fraction === "" ? whole : `${whole}.${fraction}`;
 }
+// ceiling: the owner's eye. A card comes up a moment before its description starts and stays
+// a moment after it ends; a gap between two cards, or before the first or after the last,
+// shorter than a second is given to the card rather than flashing an image.
+export const figureLeadSeconds = 0.3;
+export const figureTailSeconds = 0.3;
+const figureGapSeconds = 1;
 export function planRender(input) {
     if (input.images.length === 0) {
         // Admission permits Video only with an image source, so an empty set is a bug upstream.
-        throw new Error("The video needs at least one image, but there are none. Check the Images section in Edit project, then Retry stage.");
+        throw new Error("The video needs at least one image, but there are none. Check the Images section in Edit project, then Try again.");
     }
     const frame = frames[input.format];
-    const audio = input.body === undefined ? [] : audioTimeline({ ...input, body: input.body });
+    const bed = input.body === undefined ? undefined : input.bed;
+    const timeline = input.body === undefined ? [] : audioTimeline({ ...input, body: input.body });
+    const audio = bed === undefined ? timeline : withTail(timeline, bed.tailSeconds);
     // A silent video shows every image once, which is the one length it has to go on.
     const totalSeconds = input.body === undefined
         ? input.images.length * input.imageSeconds
@@ -45,20 +53,25 @@ export function planRender(input) {
     const totalFrames = Math.max(1, Math.round(totalSeconds * fps));
     const edit = input.edit;
     const narration = input.body === undefined ? undefined : edit?.narration;
-    const lengths = narration === undefined
-        ? everyLengths(Math.max(1, Math.round(input.imageSeconds * fps)), totalFrames)
+    const lengthsFor = (from, frameCount) => narration === undefined
+        ? everyLengths(Math.max(1, Math.round(input.imageSeconds * fps)), frameCount)
         : narrationShotFrames({
-            totalFrames,
+            totalFrames: frameCount,
             fps,
             imageSeconds: input.imageSeconds,
-            cutPoints: narration.cutPoints,
-            chapterStarts: narration.chapterStarts,
+            cutPoints: narration.cutPoints.map((point) => point - from / fps),
+            chapterStarts: narration.chapterStarts
+                .map((start) => start - from / fps)
+                .filter((start) => start >= 0 && start < frameCount / fps),
         });
-    const planned = shots(input, lengths);
+    const figures = figureFrames(edit?.figures ?? [], totalFrames);
+    const planned = figures.length === 0
+        ? shots(input, lengthsFor(0, totalFrames))
+        : aroundFigures(input, figures, totalFrames, lengthsFor);
     const transition = edit?.transition;
     const cards = edit?.cards === undefined
         ? []
-        : chapterCards(edit.cards.chapters, narration?.cutPoints ?? [], totalFrames);
+        : withEndScreen(chapterCards(edit.cards.chapters, narration?.cutPoints ?? [], totalFrames), edit.cards.endScreen, totalFrames);
     return {
         gapSeconds: input.gapSeconds,
         edgeSeconds: input.edgeSeconds,
@@ -76,14 +89,45 @@ export function planRender(input) {
                 : withTransitions(planned, transition.kind, Math.round(transition.seconds * fps)),
             ...(edit?.look !== undefined && hasLook(edit.look) ? { look: edit.look } : {}),
             ...(cards.length > 0 && edit?.cards !== undefined
-                ? { cards, cardFont: edit.cards.font }
+                ? {
+                    cards,
+                    cardFont: edit.cards.font,
+                    ...(edit.cards.color === undefined ? {} : { cardColor: edit.cards.color }),
+                }
                 : {}),
+            ...(bed === undefined
+                ? {}
+                : {
+                    bed: {
+                        source: bed.source,
+                        levelDb: bed.levelDb,
+                        fadeInSeconds: bed.fadeInSeconds,
+                        fadeOutAt: narrationEnd(timeline),
+                        fadeOutSeconds: bed.tailSeconds,
+                    },
+                }),
         },
         totalFrames,
         totalSeconds,
         output: input.output,
     };
 }
+// The timeline with the ambient bed's tail: the silence after the last spoken segment runs at
+// least `tail` seconds, so the bed can fade out under the end of the picture. A tail no longer
+// than that silence changes nothing, so the video keeps its length.
+export function withTail(audio, tail) {
+    const last = audio.at(-1);
+    if (last === undefined || tail <= 0)
+        return audio;
+    if (last.kind === "edge")
+        return last.seconds >= tail ? audio : [...audio.slice(0, -1), { ...last, seconds: tail }];
+    return [...audio, { kind: "edge", path: null, seconds: tail }];
+}
+// Where the last spoken segment ends, in seconds from the start of the video.
+function narrationEnd(audio) {
+    const trailing = audio.at(-1)?.kind === "edge" ? (audio.at(-1)?.seconds ?? 0) : 0;
+    return audio.reduce((sum, segment) => sum + segment.seconds, 0) - trailing;
+}
 // A card at each chapter start, on the cut the chapter's shot starts with (a chapter at the
 // very start stays there), for 2.5 s or what is left of the video.
 function chapterCards(chapters, cutPoints, totalFrames) {
@@ -104,6 +148,22 @@ function chapterCards(chapters, cutPoints, totalFrames) {
     }
     return cards;
 }
+// The end screen over the last seconds (or the whole of a shorter video). A chapter card that
+// would still be showing is cut short where the end screen starts; one starting inside it is
+// left out.
+export function withEndScreen(cards, text, totalFrames) {
+    const title = text?.trim() ?? "";
+    if (title === "")
+        return cards;
+    const frames = Math.min(totalFrames, Math.round(endScreenSeconds * fps));
+    const startFrame = totalFrames - frames;
+    return [
+        ...cards.flatMap((card) => card.startFrame >= startFrame
+            ? []
+            : [{ ...card, frames: Math.min(card.frames, startFrame - card.startFrame) }]),
+        { title, startFrame, frames },
+    ];
+}
 export function spoken(kind) {
     return kind !== "gap" && kind !== "edge";
 }
@@ -148,8 +208,9 @@ function everyLengths(each, totalFrames) {
 // the timeline is full. The motion goes by the shot's place, not the image (`motion.ts`), so
 // an image that comes round again may move another way. A moving clip in an image's place
 // plays as it is, with no motion of its own.
-function shots(input, lengths) {
-    return lengths.map((frames, at) => {
+function shots(input, lengths, first = 0) {
+    return lengths.map((frames, place) => {
+        const at = first + place;
         const index = at % input.images.length;
         const clip = input.edit?.clips?.[index];
         return clip === undefined
@@ -161,3 +222,54 @@ function shots(input, lengths) {
             : { source: clip, frames, motion: { kind: "still" } };
     });
 }
+// The cards on the frame grid, in order, with the lead-in and tail added, a card that would
+// overlap the one before it starting where that one ends, and gaps too short for an image
+// given to the card beside them.
+export function figureFrames(figures, totalFrames) {
+    const gap = Math.round(figureGapSeconds * fps);
+    const placed = [];
+    for (const figure of [...figures].toSorted((a, b) => a.start - b.start)) {
+        const previous = placed.at(-1);
+        const from = Math.max(previous?.to ?? 0, Math.round(Math.max(0, figure.start - figureLeadSeconds) * fps));
+        const to = Math.min(totalFrames, Math.round((figure.end + figureTailSeconds) * fps));
+        if (to - from < 1)
+            continue;
+        if (previous !== undefined && from - previous.to < gap)
+            previous.to = from;
+        placed.push({ path: figure.path, from, to });
+    }
+    const first = placed[0];
+    if (first !== undefined && first.from < gap)
+        first.from = 0;
+    const last = placed.at(-1);
+    if (last !== undefined && totalFrames - last.to < gap)
+        last.to = totalFrames;
+    return placed.map((one) => ({ path: one.path, startFrame: one.from, frames: one.to - one.from }));
+}
+// The images take turns in the stretches between the cards, laid as they would be over a
+// whole video of that length, and keep counting across them so no image or motion repeats
+// where a card interrupts. Each card is shown still, whole.
+function aroundFigures(input, figures, totalFrames, lengthsFor) {
+    const out = [];
+    let cursor = 0;
+    let slot = 0;
+    const stretch = (to) => {
+        if (to <= cursor)
+            return;
+        const lengths = lengthsFor(cursor, to - cursor);
+        out.push(...shots(input, lengths, slot));
+        slot += lengths.length;
+        cursor = to;
+    };
+    for (const figure of figures) {
+        stretch(figure.startFrame);
+        out.push({
+            source: { kind: "image", path: figure.path },
+            frames: figure.frames,
+            motion: { kind: "still" },
+        });
+        cursor = figure.startFrame + figure.frames;
+    }
+    stretch(totalFrames);
+    return out;
+}

package/dist/slices/video/run.js

@@ -16,7 +16,7 @@ export async function renderVideo(deps, context) {
         throw new Error("This project no longer exists; it may have been deleted while it was running.");
     if (project.config.sources.video === "off") {
         if (project.config.sources.audio === "off")
-            throw new Error("There is nothing to export because both video and narration are turned off for this project. Turn one on in Edit project, then Retry stage.");
+            throw new Error("There is nothing to export because both video and narration are turned off for this project. Turn one on in Edit project, then Try again.");
         await exportAudioWav(deps, context, project.config.silenceGapSeconds, project.config.edgeSilenceSeconds);
         return;
     }
@@ -44,17 +44,19 @@ export async function renderVideo(deps, context) {
         totalSeconds: plan.totalSeconds,
         record: { ...recorded(plan, dir), subtitles: project.config.subtitles ?? null },
         subtitles,
-        render: (part, onProgress) => renderSlideshow({
-            bin: deps.ffmpeg,
-            edit: plan.editList,
-            output: part,
-            burnSubtitles: subtitles?.burnIn ?? false,
-            cwd: subtitles?.directory,
-            scratch: dir,
-            signal: context.signal,
-            log: deps.log,
-            onProgress,
-        }),
+        render: async (part, onProgress) => {
+            await renderSlideshow({
+                bin: deps.ffmpeg,
+                edit: plan.editList,
+                output: part,
+                burnSubtitles: subtitles?.burnIn ?? false,
+                cwd: subtitles?.directory,
+                scratch: dir,
+                signal: context.signal,
+                log: deps.log,
+                onProgress,
+            });
+        },
     });
     deps.count("stage.completed", { stage: "video" });
 }

package/dist/slices/video/slideshow.js

@@ -1,12 +1,16 @@
 import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { extname, join } from "node:path";
+import { masterFile, masterReport } from "../loudness/loudnorm.js";
 import { cardsAss } from "./cards.js";
-import { concatList, joinArgs, runFfmpeg, segmentArgs, slideshowClips } from "./ffmpeg.js";
+import { audioMixArgs, concatList, joinArgs, runFfmpeg, segmentArgs, slideshowClips, } from "./ffmpeg.js";
 import { cardsIn } from "./look.js";
 // estimate: a zoompan frame from a 4x still costs several plain encoded frames, and a
 // copying join is nearly free, so progress is weighted by that rather than by clock time.
 const clipWeight = 4;
 const copyWeight = 0.05;
+// The sound the join plays, as the join itself brings every segment to it.
+const masterFormat = { sampleRate: 44100, channels: 2 };
+// What the master measured, when the run asked for one.
 export async function renderSlideshow(run) {
     const { edit } = run;
     const { clips, order } = slideshowClips(edit);
@@ -26,7 +30,7 @@ export async function renderSlideshow(run) {
         const font = edit.cardFont;
         if (cards.length > 0) {
             if (font === undefined)
-                throw new Error("Slopify hit an internal error (the chapter cards have no font). Use Re-run section on Video; if it happens again, use Download diagnostics in Settings and report it.");
+                throw new Error("Slopify hit an internal error (the chapter cards have no font). Use More → Render the video again in the Video section; if it happens again, use Download diagnostics in Settings and report it.");
             mkdirSync(join(workspace, "fonts"), { mode: 0o700 });
             copyFileSync(font.path, join(workspace, "fonts", `card${extname(font.path)}`));
         }
@@ -36,7 +40,7 @@ export async function renderSlideshow(run) {
             const script = clip.name.replace(/\.mp4$/, ".ass");
             const shown = cardsIn(cards, clip.segment.start, clip.segment.count);
             if (shown.length > 0 && font !== undefined)
-                writeFileSync(join(workspace, script), cardsAss(edit, shown, font.name, clip.segment.start), { mode: 0o600 });
+                writeFileSync(join(workspace, script), cardsAss(edit, shown, font.name, clip.segment.start, edit.cardColor), { mode: 0o600 });
             await runFfmpeg({
                 bin: run.bin,
                 ...(cards.length > 0 ? { cwd: workspace } : {}),
@@ -49,14 +53,45 @@ export async function renderSlideshow(run) {
         }
         const list = join(workspace, "slides.ffconcat");
         writeFileSync(list, concatList(order), { mode: 0o600 });
+        // Level the volume: the sound, with its bed, is mixed alone and mastered first, and the join
+        // plays that one file.
+        let joined = edit;
+        let master;
+        if (run.master !== undefined && edit.audio.length > 0) {
+            const mixed = join(workspace, "mix.wav");
+            await runFfmpeg({
+                bin: run.bin,
+                args: audioMixArgs(edit, mixed),
+                signal: run.signal,
+                log: run.log,
+                onProgress: () => { },
+            });
+            const mastered = join(workspace, "master.wav");
+            await masterFile(run, mixed, mastered, run.master, masterFormat);
+            joined = {
+                ...edit,
+                audio: [
+                    {
+                        kind: "body",
+                        path: mastered,
+                        seconds: edit.audio.reduce((sum, segment) => sum + segment.seconds, 0),
+                    },
+                ],
+                bed: undefined,
+            };
+        }
         await runFfmpeg({
             bin: run.bin,
             cwd: run.cwd,
-            args: joinArgs(edit, run.output, list, run.burnSubtitles),
+            args: joinArgs(joined, run.output, list, run.burnSubtitles, run.portraits),
             signal: run.signal,
             log: run.log,
             onProgress: (elapsedMs) => report(rendered + elapsedMs * (run.burnSubtitles ? 1 : copyWeight)),
         });
+        // What the finished video measures, after its AAC encode.
+        if (run.master !== undefined && edit.audio.length > 0)
+            master = await masterReport(run, run.output, run.master);
+        return master;
     }
     finally {
         rmSync(workspace, { recursive: true, force: true });

package/dist/slices/voices/attribution.js

@@ -0,0 +1,69 @@
+import { parseScript } from "./script.js";
+// Audiobooks from an existing text: the text model hands each passage to a speaker - the
+// narrator's prose to the narrator, each quoted line to the character who says it - and
+// answers in the script format. It may not write: the words it returns are checked against the
+// source, so a model that summarises or embellishes fails the attempt and is asked again.
+export function attributionMessages(source, speakers) {
+    const narrator = speakers.find((speaker) => speaker.role === "narrator")?.name.trim();
+    return [
+        {
+            role: "system",
+            content: [
+                "You split a text into speaker turns for an audiobook. You never write, shorten, reword or translate anything.",
+                "Speakers (name - role):",
+                ...speakers.map((speaker) => `- ${speaker.name.trim()} - ${speaker.role}`),
+                `Give narration, description and dialogue tags to ${narrator ?? "the narrator"}. Give each quoted line of dialogue, without its quotation marks, to the character who says it; a character not in the list is read by ${narrator ?? "the narrator"}.`,
+                "Answer only with the script, in this exact format:",
+                "- 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.",
+                "- Keep the text's own chapter headings as Markdown heading lines (`# Title`).",
+                "- Every word of the text appears exactly once, in order.",
+            ].join("\n"),
+        },
+        { role: "user", content: source },
+    ];
+}
+// The answer must parse as a script and keep the source's words: at least 90% of them in
+// order, and no more than 10% words of its own.
+export function parseAttribution(answer, source, speakers) {
+    const parsed = parseScript(answer, speakers);
+    if (!parsed.ok)
+        return parsed;
+    const expected = words(source);
+    const got = words(parsed.script.turns.map((turn) => turn.text).join(" "));
+    const kept = commonInOrder(expected, got);
+    if (expected.length > 0 && kept / expected.length < 0.9)
+        return {
+            ok: false,
+            reason: `The speaker split left out ${String(expected.length - kept)} of the text's ${String(expected.length)} words. The text model must hand every word to a speaker; Try again, or choose another model in Edit project → Providers.`,
+        };
+    if (got.length - kept > Math.max(3, expected.length * 0.1))
+        return {
+            ok: false,
+            reason: `The speaker split added ${String(got.length - kept)} words that are not in the text. The text model must not write anything of its own; Try again, or choose another model in Edit project → Providers.`,
+        };
+    return parsed;
+}
+function words(text) {
+    return text
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[^\p{L}\p{N}\s]/gu, " ")
+        .split(/\s+/)
+        .filter((word) => word !== "");
+}
+// A greedy walk rather than a full longest-common-subsequence: both lists are the same words in
+// the same order save for what a model dropped or added, and a book chapter is too long for
+// the quadratic table.
+function commonInOrder(expected, got) {
+    let at = 0;
+    let kept = 0;
+    for (const word of got) {
+        const found = expected.indexOf(word, at);
+        if (found === -1 || found - at > 40)
+            continue;
+        kept += 1;
+        at = found + 1;
+    }
+    return kept;
+}

package/dist/slices/voices/audio-files.js

@@ -0,0 +1,82 @@
+// One chapter per script section that was heard, each running to the next; the first starts
+// at zero so the lead-in and intro belong to it. A script without sections is one chapter.
+export function audioChapters(input) {
+    const totalMs = Math.max(1, Math.round(input.totalSeconds * 1000));
+    const points = [];
+    for (const section of input.sections) {
+        const start = input.turnStarts.get(section.firstTurn);
+        if (start === undefined)
+            continue;
+        const startMs = points.length === 0 ? 0 : Math.round(start * 1000);
+        const last = points.at(-1);
+        // Two sections starting at the same moment (an empty one) keep the later title.
+        if (last !== undefined && startMs <= last.startMs) {
+            points[points.length - 1] = { title: section.title, startMs: last.startMs };
+            continue;
+        }
+        if (startMs >= totalMs)
+            continue;
+        points.push({ title: section.title, startMs });
+    }
+    if (points.length === 0)
+        points.push({ title: input.title, startMs: 0 });
+    return points.map((point, at) => ({
+        title: point.title,
+        startMs: point.startMs,
+        endMs: points[at + 1]?.startMs ?? totalMs,
+    }));
+}
+// FFMETADATA1: `=`, `;`, `#`, `\` and line breaks are escaped with a backslash.
+export function ffmetadata(title, chapters) {
+    const lines = [";FFMETADATA1", `title=${escapeMeta(title)}`];
+    for (const chapter of chapters)
+        lines.push("", "[CHAPTER]", "TIMEBASE=1/1000", `START=${String(chapter.startMs)}`, `END=${String(chapter.endMs)}`, `title=${escapeMeta(chapter.title)}`);
+    return `${lines.join("\n")}\n`;
+}
+function escapeMeta(text) {
+    return text.replace(/[=;#\\\n]/g, (character) => `\\${character === "\n" ? "\n" : character}`);
+}
+const rate = 44100;
+export function audioFileArgs(audio, metadataPath, output, kind) {
+    const inputs = audio.flatMap((segment) => segment.path === null
+        ? [
+            "-f",
+            "lavfi",
+            "-t",
+            segment.seconds.toFixed(6),
+            "-i",
+            `anullsrc=r=${String(rate)}:cl=stereo`,
+        ]
+        : ["-i", segment.path]);
+    const metadataInput = audio.length;
+    const chains = audio.map((_segment, index) => `[${String(index)}:a]aformat=sample_fmts=fltp:sample_rates=${String(rate)}:channel_layouts=stereo,asetpts=PTS-STARTPTS[a${String(index)}]`);
+    chains.push(`${audio.map((_segment, index) => `[a${String(index)}]`).join("")}concat=n=${String(audio.length)}:v=0:a=1[a]`);
+    return [
+        "-hide_banner",
+        "-nostdin",
+        "-loglevel",
+        "error",
+        "-progress",
+        "pipe:1",
+        "-nostats",
+        "-y",
+        ...inputs,
+        "-f",
+        "ffmetadata",
+        "-i",
+        metadataPath,
+        "-filter_complex",
+        chains.join(";"),
+        "-map",
+        "[a]",
+        "-map_metadata",
+        String(metadataInput),
+        "-map_chapters",
+        String(metadataInput),
+        "-vn",
+        ...(kind === "mp3"
+            ? ["-c:a", "libmp3lame", "-b:a", "128k", "-id3v2_version", "3", "-f", "mp3"]
+            : ["-c:a", "aac", "-b:a", "96k", "-movflags", "+faststart", "-f", "mp4"]),
+        output,
+    ];
+}

package/dist/slices/voices/audition.js

@@ -0,0 +1,25 @@
+// What each speaker reads in an audition: their first line of the script, cut at a sentence
+// end near 200 characters, or a sample line in their name while there is no script yet.
+export const auditionLineMax = 300;
+export function auditionLine(speaker, script) {
+    const first = script?.turns.find((turn) => turn.speaker === speaker.id)?.text;
+    const text = first ?? sampleLine(speaker);
+    if (text.length <= 200)
+        return text;
+    const cut = text.slice(0, 200);
+    const end = Math.max(cut.lastIndexOf(". "), cut.lastIndexOf("? "), cut.lastIndexOf("! "));
+    return end > 60 ? cut.slice(0, end + 1) : `${cut.slice(0, cut.lastIndexOf(" "))}…`;
+}
+function sampleLine(speaker) {
+    const name = speaker.name.trim() || "your speaker";
+    switch (speaker.role) {
+        case "narrator":
+            return `The night was quiet, and the old house held its breath. I'm ${name}, and I'll be telling this story.`;
+        case "host":
+            return `Hi everyone, I'm ${name}, and welcome back to the show. Today's topic is a good one.`;
+        case "guest":
+            return `Thanks for having me. I'm ${name}, and I've been looking forward to this conversation.`;
+        case "character":
+            return `You really thought I wouldn't find out? My name is ${name}, and I always find out.`;
+    }
+}

package/dist/slices/voices/cast.js

@@ -0,0 +1,56 @@
+// The cast library as a source of speakers: every member of the channel with a voice can be
+// cast in a run. A speaker picked from the cast keeps the member's id, and every run started
+// later takes the member's voice as it is then, so a character or a host sounds the same in
+// every episode; editing the cast later changes no project already made.
+export function castSpeakers(members) {
+    return {
+        speakers: () => members.flatMap((member) => member.voice === undefined ? [] : [speakerFromCast(member, "character")]),
+    };
+}
+export function speakerFromCast(member, role) {
+    const voice = member.voice;
+    return {
+        id: `cast-${member.id
+            .slice(0, 8)
+            .toLowerCase()
+            .replace(/[^a-z0-9-]/g, "")}`,
+        name: member.name.slice(0, 40),
+        role,
+        voice: voice === undefined
+            ? { provider: "", model: "", voice: "" }
+            : { provider: voice.provider, model: voice.model, voice: voice.voice },
+        ...(voice?.pace === undefined || voice.pace === 1 ? {} : { pace: voice.pace }),
+        ...(voice?.pronunciations?.trim() ? { pronunciations: voice.pronunciations } : {}),
+        castId: member.id,
+        ...portraitOf(member),
+    };
+}
+// The member's first finished picture, the one the speaker panel shows. Nothing when they have
+// none, so a speaker without a picture is the speaker it always was.
+function portraitOf(member) {
+    const sha256 = member.images.find((one) => one.state === "ready" && one.sha256 !== null)?.sha256;
+    return sha256 === undefined || sha256 === null ? {} : { portrait: sha256 };
+}
+// A run's speakers with each cast speaker's voice, pace, pronunciations and portrait taken from
+// the cast as it is now. A member since deleted, or without a voice, leaves the speaker as saved.
+export function withCastVoices(settings, members) {
+    let changed = false;
+    const speakers = settings.speakers.map((speaker) => {
+        const member = speaker.castId === undefined ? undefined : members.find((one) => one.id === speaker.castId);
+        if (member?.voice === undefined)
+            return speaker;
+        const fresh = speakerFromCast(member, speaker.role);
+        const { pace: _pace, pronunciations: _pronunciations, portrait: _portrait, ...rest } = speaker;
+        const next = {
+            ...rest,
+            voice: fresh.voice,
+            ...(fresh.pace === undefined ? {} : { pace: fresh.pace }),
+            ...(fresh.pronunciations === undefined ? {} : { pronunciations: fresh.pronunciations }),
+            ...(fresh.portrait === undefined ? {} : { portrait: fresh.portrait }),
+        };
+        if (JSON.stringify(next) !== JSON.stringify(speaker))
+            changed = true;
+        return next;
+    });
+    return changed ? { ...settings, speakers } : settings;
+}

package/dist/slices/voices/grouping.js

@@ -0,0 +1,49 @@
+import { speakerPace } from "./model.js";
+export const dialogueCapabilities = [
+    { provider: "elevenlabs", models: ["eleven_v3"], maxVoices: 10, maxCharacters: 2000 },
+];
+export function dialogueCapability(provider, model) {
+    return dialogueCapabilities.find((capability) => capability.provider === provider && capability.models.includes(model));
+}
+// `spokenLength` is how long a turn's text is once it goes to the voice (narration aliases can
+// make it longer than the script), so a request never passes the provider's limit.
+export function groupTurns(turns, speakers, nativeDialogue, spokenLength = (text) => text.length) {
+    const byId = new Map(speakers.map((speaker) => [speaker.id, speaker]));
+    const groups = [];
+    let current = [];
+    let capability;
+    let signature = "";
+    const close = () => {
+        if (current.length > 0)
+            groups.push({ turns: current, native: current.length > 1 });
+        current = [];
+        capability = undefined;
+        signature = "";
+    };
+    for (const turn of turns) {
+        const speaker = byId.get(turn.speaker);
+        const own = nativeDialogue && speaker !== undefined
+            ? dialogueCapability(speaker.voice.provider, speaker.voice.model)
+            : undefined;
+        if (own === undefined || speaker === undefined || spokenLength(turn.text) > own.maxCharacters) {
+            close();
+            groups.push({ turns: [turn], native: false });
+            continue;
+        }
+        // One provider, one model and one pace per request: the pace is applied to the request's
+        // audio as a whole after it comes back.
+        const mine = `${speaker.voice.provider}\n${speaker.voice.model}\n${String(speakerPace(speaker))}`;
+        const voices = new Set([...current, turn].map((one) => byId.get(one.speaker)?.voice.voice ?? ""));
+        const characters = [...current, turn].reduce((sum, one) => sum + spokenLength(one.text), 0);
+        if (current.length > 0 &&
+            (mine !== signature ||
+                voices.size > (capability?.maxVoices ?? 0) ||
+                characters > (capability?.maxCharacters ?? 0)))
+            close();
+        current.push(turn);
+        capability = own;
+        signature = mine;
+    }
+    close();
+    return groups;
+}

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,
+    ];
+}