@gentbajko/slopify 2.4.0 → 3.0.0

package/dist/slices/rebuild/runtime-export.js

@@ -1,5 +1,8 @@
 import { copyFileSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import { extname, join, relative, sep } from "node:path";
+import { usesShortMode } from "../admission/short-mode.js";
+import { masterFile, masterReport } from "../loudness/loudnorm.js";
+import { masterGoal } from "../loudness/model.js";
 import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
 import { outputPath, projectDir } from "../storage/layout.js";
 import { audioExportArgs } from "../video/audio-export.js";
@@ -7,8 +10,11 @@ import { withPaths } from "../video/edit-list.js";
 import { runFfmpeg } from "../video/ffmpeg.js";
 import { planRender } from "../video/plan.js";
 import { renderSlideshow } from "../video/slideshow.js";
+import { writePortraits } from "../voices/portraits.js";
+import { exportBed } from "./runtime-export-bed.js";
 import { exportEdit } from "./runtime-export-edit.js";
 import { exportSnapshot, retainedOutput, revisionAudio, } from "./runtime-export-inputs.js";
+import { executeShortExport } from "./runtime-export-short.js";
 import { preparedResult, preparedText, publishResult } from "./runtime-publication.js";
 export async function executeExportRecipe(deps, context, piece) {
     if (deps.db
@@ -20,12 +26,14 @@ export async function executeExportRecipe(deps, context, piece) {
     context.signal.throwIfAborted();
     const snapshot = exportSnapshot(deps, context, piece);
     const { view } = snapshot;
-    const audio = await revisionAudio(deps, context, view);
+    const audio = await revisionAudio(deps, context, view, { levelled: true });
     const wav = piece.key === "export:wav";
     if (!wav && piece.key !== "export:video")
-        throw new Error("Slopify hit an internal error (unknown kind of export). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (unknown kind of export). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     if (wav && audio.length === 0)
-        throw new Error("The audio export has nothing to export because narration is turned off for this project. Turn narration on in Edit project, then Retry stage.");
+        throw new Error("The audio export has nothing to export because narration is turned off for this project. Turn narration on in Edit project, then Try again.");
+    if (!wav && usesShortMode(view.revision.config))
+        return executeShortExport(deps, context, piece, snapshot, audio);
     const filename = wav ? "audio.wav" : "video.mp4";
     const pending = allocateAsset(deps, context.work.projectId, filename);
     const prepared = [];
@@ -35,6 +43,9 @@ export async function executeExportRecipe(deps, context, piece) {
         const burn = !wav && view.revision.config.subtitles?.mode === "burn-in";
         if (burn)
             directory = captionDirectory(deps, context, snapshot);
+        const portraits = directory === undefined
+            ? undefined
+            : writePortraits(deps.db, view.revision.config, directory);
         const mode = burn
             ? "burn-in"
             : captions.some((row) => row.output.role === "subtitles_srt") &&
@@ -48,13 +59,9 @@ export async function executeExportRecipe(deps, context, piece) {
                 ? undefined
                 : { path: row.path, seconds: row.seconds };
         };
-        const images = (wav ? [] : view.revision.content.imageOrder).map((key) => {
-            const row = view.outputs.find((one) => one.workKey === `image:${key}` && one.selected && one.available && one.state === "ready");
-            if (row === undefined)
-                throw new Error("The video export can't find one of the slideshow images. Use Re-run section on Images (or regenerate that image in Edit project → Images), then Retry stage.");
-            return outputPath(deps.paths, context.work.projectId, row.output.path);
-        });
+        const images = wav ? [] : slideshowImages(deps, context, view);
         const edited = wav ? undefined : await exportEdit(deps, context, view, images);
+        const bed = wav ? undefined : await exportBed(deps, context, view);
         const plan = wav
             ? undefined
             : planRender({
@@ -70,6 +77,7 @@ export async function executeExportRecipe(deps, context, piece) {
                 images,
                 output: pending.absolutePath,
                 edit: edited?.edit,
+                bed,
             });
         const totalSeconds = plan?.totalSeconds ?? audio.reduce((sum, row) => sum + row.seconds, 0);
         const projectDirectory = projectDir(deps.paths, context.work.projectId);
@@ -93,6 +101,7 @@ export async function executeExportRecipe(deps, context, piece) {
                 output: pending.path,
                 editList: withPaths(plan.editList, relativePath),
                 subtitles: config.subtitles,
+                ...(portraits === undefined ? {} : { speakerPortraits: portraits.recorded }),
                 ...(edited?.settings === undefined ? {} : { videoEdit: edited.settings }),
                 ...(edited === undefined || edited.warnings.length === 0
                     ? {}
@@ -107,25 +116,71 @@ export async function executeExportRecipe(deps, context, piece) {
             current: Math.min(100, Math.round(elapsedMs / (totalSeconds * 10))),
             total: 100,
         });
-        if (plan === undefined)
-            await runFfmpeg({
-                bin: deps.ffmpeg,
-                args: audioExportArgs(audio, pending.absolutePath),
-                signal: context.signal,
-                log: deps.log,
-                onProgress,
-            });
+        // Level the volume: the audio-only file is mastered to the audio files' target, the video to
+        // the video's (`loudness/model.ts`).
+        const goal = masterGoal(config, plan === undefined ? "audioFiles" : "video");
+        let master;
+        if (plan === undefined) {
+            const mixed = goal === undefined ? pending.absolutePath : `${pending.absolutePath}.mix.wav`;
+            try {
+                await runFfmpeg({
+                    bin: deps.ffmpeg,
+                    args: audioExportArgs(audio, mixed),
+                    signal: context.signal,
+                    log: deps.log,
+                    onProgress,
+                });
+                if (goal !== undefined) {
+                    const run = { bin: deps.ffmpeg, log: deps.log, signal: context.signal };
+                    await masterFile(run, mixed, `${pending.absolutePath}.master.wav`, goal, {
+                        sampleRate: 48000,
+                        channels: 2,
+                    });
+                    // The export is 16-bit PCM, as it always was.
+                    await runFfmpeg({
+                        bin: deps.ffmpeg,
+                        args: [
+                            "-hide_banner",
+                            "-nostdin",
+                            "-loglevel",
+                            "error",
+                            "-nostats",
+                            "-y",
+                            "-i",
+                            `${pending.absolutePath}.master.wav`,
+                            "-c:a",
+                            "pcm_s16le",
+                            "-f",
+                            "wav",
+                            pending.absolutePath,
+                        ],
+                        signal: context.signal,
+                        log: deps.log,
+                        onProgress: () => { },
+                    });
+                    master = await masterReport(run, pending.absolutePath, goal);
+                }
+            }
+            finally {
+                if (goal !== undefined) {
+                    rmSync(mixed, { force: true });
+                    rmSync(`${pending.absolutePath}.master.wav`, { force: true });
+                }
+            }
+        }
         else
-            await renderSlideshow({
+            master = await renderSlideshow({
                 bin: deps.ffmpeg,
                 edit: plan.editList,
                 output: plan.output,
                 burnSubtitles: burn,
                 cwd: directory,
+                ...(portraits === undefined ? {} : { portraits: portraits.overlays }),
                 scratch: projectDirectory,
                 signal: context.signal,
                 log: deps.log,
                 onProgress,
+                ...(goal === undefined ? {} : { master: goal }),
             });
         context.signal.throwIfAborted();
         const asset = sealAsset(deps, pending);
@@ -134,6 +189,7 @@ export async function executeExportRecipe(deps, context, piece) {
             ...(edited === undefined || edited.warnings.length === 0
                 ? {}
                 : { warnings: edited.warnings }),
+            ...(master === undefined ? {} : { master }),
         }));
         prepared.push(preparedText(deps, context, piece, "render_params", "render.json", JSON.stringify(record)));
         prepared.push(...captions.map((row) => retainedOutput(deps, view, row)));
@@ -147,12 +203,21 @@ export async function executeExportRecipe(deps, context, piece) {
             rmSync(directory, { recursive: true, force: true });
     }
 }
+// The project's images in slideshow order, as files.
+export function slideshowImages(deps, context, view) {
+    return view.revision.content.imageOrder.map((key) => {
+        const row = view.outputs.find((one) => one.workKey === `image:${key}` && one.selected && one.available && one.state === "ready");
+        if (row === undefined)
+            throw new Error("The video export can't find one of the slideshow images. Use More → make it again in its section on Images (or regenerate that image in Edit project → Images), then Try again.");
+        return outputPath(deps.paths, context.work.projectId, row.output.path);
+    });
+}
 function captionDirectory(deps, context, snapshot) {
     const find = (role) => snapshot.view.outputs.find((row) => row.selected && row.available && row.state === "ready" && row.output.role === role);
     const ass = find("subtitle_ass");
     const font = find("subtitle_font");
     if (ass === undefined || font === undefined)
-        throw new Error("Burned-in captions are missing their caption file or font. Use Re-run section on Video (or choose the caption font again in Edit project → Subtitles), then Retry stage.");
+        throw new Error("Burned-in captions are missing their caption file or font. Use More → Render the video again in the Video section (or choose the caption font again in Edit project → Subtitles), then Try again.");
     const directory = mkdtempSync(join(projectDir(deps.paths, context.work.projectId), "render-"));
     try {
         mkdirSync(join(directory, "fonts"), { mode: 0o700 });

package/dist/slices/rebuild/runtime-figure-card.js

@@ -0,0 +1,87 @@
+import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { captionFont, captionFontDeps } from "../fonts/coverage.js";
+import { describedKinds } from "../narration/blocks.js";
+import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
+import { projectDir } from "../storage/layout.js";
+import { defaultCardStyle, renderCard } from "../video/figure-card.js";
+import { articlePicture } from "./runtime-pictures.js";
+import { executionView } from "./runtime-plan.js";
+import { preparedResult, publishResult } from "./runtime-publication.js";
+// A `figure:card:<n>` step: the block drawn as a card in each frame the project needs (the
+// video's, and upright for the Shorts of a 16:9 video), with the ffmpeg Slopify ships.
+const values = z.object({
+    kind: z.enum(describedKinds),
+    index: z.number().int().positive(),
+    source: z.string(),
+    section: z.string().nullable(),
+    image: z.string().nullable(),
+    formats: z.array(z.enum(["16:9", "9:16"])).min(1),
+    fontId: z.string(),
+    color: z.string().nullable(),
+    language: z.string(),
+});
+const frames = { "16:9": [1920, 1080], "9:16": [1080, 1920] };
+export async function executeFigureCard(deps, context, piece) {
+    if (piece.input.kind !== "local")
+        throw new Error("Slopify hit an internal error (a figure card step was set up wrongly). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+    const card = values.parse(piece.input.values);
+    const view = executionView(deps, context.work.projectId, context.work.revisionId);
+    // The article's own picture for a figure, when the project has it as an upload.
+    const picture = card.kind === "figure" && view !== undefined
+        ? articlePicture(deps, view, card.image ?? undefined)
+        : undefined;
+    const font = await captionFont(captionFontDeps(deps.paths), card.fontId, card.language === "en" ? undefined : card.language);
+    const workspace = mkdtempSync(join(projectDir(deps.paths, context.work.projectId), "card-"));
+    const pending = card.formats.map(() => allocateAsset(deps, context.work.projectId, `card-${String(card.index)}.png`));
+    const prepared = [];
+    try {
+        mkdirSync(join(workspace, "fonts"), { mode: 0o700 });
+        copyFileSync(font.path, join(workspace, "fonts", `card${font.extension}`));
+        for (const [at, format] of card.formats.entries()) {
+            const target = pending[at];
+            if (target === undefined)
+                continue;
+            const [width, height] = frames[format];
+            await renderCard({
+                bin: deps.ffmpeg,
+                input: {
+                    kind: card.kind,
+                    source: card.source,
+                    section: card.section,
+                    width,
+                    height,
+                    style: {
+                        ...defaultCardStyle,
+                        font: font.assName,
+                        ...(card.color === null ? {} : { accent: card.color }),
+                    },
+                    picture: picture !== undefined,
+                },
+                cwd: workspace,
+                output: target.absolutePath,
+                picture,
+                signal: context.signal,
+                log: deps.log,
+            }, (ass) => writeFileSync(join(workspace, "card.ass"), ass, { mode: 0o600 }));
+            context.signal.throwIfAborted();
+            const asset = sealAsset(deps, target);
+            const output = preparedResult(deps, context, piece, "figure_card", asset, null, {
+                index: card.index,
+                format,
+            });
+            prepared.push({ ...output, slot: `${piece.key}:${format}` });
+        }
+        await publishResult(deps, context, piece, prepared, {
+            index: card.index,
+            kind: card.kind,
+            picture: picture !== undefined,
+        });
+        return "done";
+    }
+    finally {
+        rmSync(workspace, { recursive: true, force: true });
+        discardPreparedAssets(deps, [...pending, ...prepared.map((one) => one.asset)]);
+    }
+}

package/dist/slices/rebuild/runtime-image.js

@@ -0,0 +1,69 @@
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+import { imageBlob } from "../channels/repo.js";
+import { outputPath } from "../storage/layout.js";
+// The provider call an image step makes: its request, the effort when one is chosen and, while
+// the project's Establishing image is on, that image's bytes as the visual reference.
+export function imageCall(deps, projectId, input, previewLabel) {
+    const reference = referenceImage(deps, projectId, input);
+    const cast = castImages(deps, input);
+    return {
+        provider: input.provider,
+        model: input.model,
+        prompt: input.prompt,
+        aspect: input.aspect,
+        ...(input.thinking === undefined ? {} : { thinking: input.thinking }),
+        ...(reference === undefined ? {} : { reference }),
+        ...(cast === undefined ? {} : { cast }),
+        ...(previewLabel === undefined ? {} : { previewLabel }),
+    };
+}
+function referenceImage(deps, projectId, input) {
+    if (input.reference === undefined)
+        return undefined;
+    // The step waits for the establishing image, so a missing one went away since.
+    const missing = "The establishing image this image is drawn from is missing. Use Regenerate on the establishing image in the Images section (or upload it again in Edit project → Images), then use Try again.";
+    if (input.reference.assetId === null)
+        throw new Error(missing);
+    const row = z
+        .object({ path: z.string() })
+        .optional()
+        .parse(deps.db
+        .prepare("SELECT path FROM project_assets WHERE id=? AND project_id=?")
+        .get(input.reference.assetId, projectId));
+    if (row === undefined)
+        throw new Error(missing);
+    let bytes;
+    try {
+        bytes = new Uint8Array(readFileSync(outputPath(deps.paths, projectId, row.path)));
+    }
+    catch {
+        throw new Error(missing);
+    }
+    const mime = imageMime(bytes);
+    if (mime === undefined)
+        throw new Error("The establishing image is not a PNG or JPEG file, so it can't be sent as a reference. Upload a PNG or JPEG in Edit project → Images → Establishing image, then use Try again.");
+    return { bytes, mime };
+}
+// The cast pictures the request names, read by hash from the database. They are never removed
+// while a project may name them, so a missing one came from a backup of another install.
+function castImages(deps, input) {
+    if (input.cast === undefined)
+        return undefined;
+    return input.cast.map((member) => ({
+        name: member.name,
+        description: member.description,
+        images: member.images.map((sha256) => {
+            const blob = imageBlob(deps.db, sha256);
+            if (blob === undefined)
+                throw new Error(`A picture of ${member.name} that this project was started with is not in this Slopify's database, so it can't be sent as a reference. Add the picture again in Channels → Cast, then start the video again from Play.`);
+            return blob;
+        }),
+    }));
+}
+function imageMime(bytes) {
+    const png = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+    if (png.every((value, index) => bytes[index] === value))
+        return "image/png";
+    return bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff ? "image/jpeg" : undefined;
+}

package/dist/slices/rebuild/runtime-local.js

@@ -1,11 +1,18 @@
-import { statSync } from "node:fs";
+import { rmSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { z } from "zod";
+import { referenceKey } from "../admission/model.js";
 import { plainText } from "../article/plain.js";
 import { splitEndMatter } from "../article/split.js";
+import { levelPieces } from "../loudness/level-pieces.js";
 import { joinNarration } from "../narration/concat.js";
+import { applyPauses, planPieces } from "../narration/pauses.js";
 import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
 import { outputPath } from "../storage/layout.js";
+import { probeDurationMs, runFfmpeg } from "../video/ffmpeg.js";
+import { turnJoinArgs } from "../voices/join.js";
+import { levelOperation } from "./recipe-loudness.js";
+import { executeFigureCard } from "./runtime-figure-card.js";
 import { publishNarrationText } from "./runtime-narration-text.js";
 import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
 import { preparedResult, preparedText, preparedTexts, publishResult, } from "./runtime-publication.js";
@@ -19,7 +26,7 @@ export async function executeLocalRecipe(deps, context, piece) {
     const input = piece.input;
     if (input.kind === "provided") {
         if (input.assetId === null)
-            throw new Error("A file you uploaded for this project is missing. Upload it again in Edit project, then Retry stage.");
+            throw new Error("A file you uploaded for this project is missing. Upload it again in Edit project, then Try again.");
         const row = z
             .object({ id: z.string(), project_id: z.string(), path: z.string(), created_at: z.string() })
             .parse(deps.db
@@ -36,19 +43,25 @@ export async function executeLocalRecipe(deps, context, piece) {
             ? "audio_body"
             : piece.key === "thumbnail:image"
                 ? "thumbnail"
-                : piece.key.startsWith("image:")
-                    ? "image"
-                    : undefined;
+                : piece.key === referenceKey
+                    ? "reference"
+                    : piece.key.startsWith("image:")
+                        ? "image"
+                        : undefined;
         await publishResult(deps, context, piece, role === undefined ? [] : [preparedResult(deps, context, piece, role, asset)], {}, asset);
         return "done";
     }
     if (input.kind !== "local")
-        throw new Error("Slopify hit an internal error (a local step was set up wrongly). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (a local step was set up wrongly). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+    if (input.operation === "figure-card-v1")
+        return executeFigureCard(deps, context, piece);
     if (input.operation === "narration-files-v1") {
         await publishNarrationText(deps, context, piece);
         return "done";
     }
-    if (input.operation === "concat-narration") {
+    if (input.operation === "concat-narration" ||
+        input.operation === "concat-turns-v1" ||
+        input.operation === levelOperation) {
         await concatenate(deps, context, piece);
         return "done";
     }
@@ -75,19 +88,19 @@ export async function executeLocalRecipe(deps, context, piece) {
         });
         return "done";
     }
-    throw new Error(`Slopify hit an internal error (no handler for the step "${input.operation}"). Retry stage; if it happens again, use Download diagnostics in Settings and report it.`);
+    throw new Error(`Slopify hit an internal error (no handler for the step "${input.operation}"). Try again; if it happens again, use Download diagnostics in Settings and report it.`);
 }
 async function concatenate(deps, context, piece) {
     const view = executionView(deps, context.work.projectId, context.work.revisionId);
     if (view === undefined)
-        throw new Error("Slopify hit an internal error (the project version being built is missing). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the project version being built is missing). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     const row = deps.db
         .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
         .get(context.work.workId);
     const plan = executionPlan(deps, view, savedCatalogue(row?.recipe_context));
     const recipe = plan.recipes.find((candidate) => candidate.key === piece.key && candidate.fingerprint === piece.fingerprint);
     if (recipe === undefined)
-        throw new Error("Slopify hit an internal error (the narration chunks to join no longer match the project's saved inputs). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the narration chunks to join no longer match the project's saved inputs). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     const files = recipe.dependsOn.map((key) => {
         const input = view.pieces.find((candidate) => candidate.key === key &&
             candidate.selected &&
@@ -95,36 +108,73 @@ async function concatenate(deps, context, piece) {
             candidate.piece.state === "done" &&
             candidate.fingerprint === plan.recipes.find((value) => value.key === key)?.fingerprint);
         if (input?.assetId === null || input === undefined)
-            throw new Error("One narration chunk has no saved audio, so the narration can't be joined together. Regenerate the missing chunk in Edit project → Narration, then Retry stage.");
+            throw new Error("One narration chunk has no saved audio, so the narration can't be joined together. Regenerate the missing chunk in Edit project → Narration, then Try again.");
         const asset = deps.db
             .prepare("SELECT path FROM project_assets WHERE id=? AND project_id=?")
             .get(input.assetId, context.work.projectId);
         return outputPath(deps.paths, context.work.projectId, z.string().parse(asset?.path));
     });
+    // Level the volume repeats the join its recipe names, from the same pieces, each levelled
+    // first (`recipe-loudness.ts`).
+    const level = recipe.input.kind === "local" && recipe.input.operation === levelOperation;
+    const [operation, values] = recipe.input.kind !== "local"
+        ? ["", undefined]
+        : level
+            ? z.tuple([z.string(), z.unknown(), z.unknown()]).parse(recipe.input.values)
+            : [recipe.input.operation, recipe.input.values];
     const pending = allocateAsset(deps, context.work.projectId, "narration.mp3");
+    const piecesDirectory = join(dirname(pending.absolutePath), "levelled");
     try {
-        const durationMs = await joinNarration({ bin: deps.ffmpeg, log: deps.log }, {
-            files,
-            output: pending.absolutePath,
-            listPath: join(dirname(pending.absolutePath), "parts.txt"),
-            signal: context.signal,
-        });
+        const run = { bin: deps.ffmpeg, log: deps.log, signal: context.signal };
+        const levelled = level ? await levelPieces(run, files, piecesDirectory) : undefined;
+        // Pauses between sentences: planned from the pieces as spoken, made in what is joined.
+        const pauses = pausesIn(values);
+        const paced = pauses === undefined
+            ? undefined
+            : await applyPauses(run, levelled?.files ?? files, paceScaled(await planPieces(run, files.map((file, at) => ({
+                file,
+                text: pieceText(plan.recipes.find((one) => one.key === recipe.dependsOn[at])),
+                next: pauses.next[at] ?? "end",
+            })), pauses.settings), operation === "concat-turns-v1" ? values : undefined), join(piecesDirectory, "paced"));
+        const joined = paced?.files ?? levelled?.files ?? files;
+        const durationMs = operation === "concat-turns-v1"
+            ? await joinTurns(run, joined, values, pending.absolutePath)
+            : await joinNarration({ bin: deps.ffmpeg, log: deps.log }, {
+                files: joined,
+                output: pending.absolutePath,
+                listPath: join(dirname(pending.absolutePath), "parts.txt"),
+                signal: context.signal,
+                reencode: level || paced !== undefined,
+            });
+        rmSync(piecesDirectory, { recursive: true, force: true });
         context.signal.throwIfAborted();
         const asset = sealAsset(deps, pending);
-        const role = piece.key === "audio:intro"
-            ? "audio_intro"
-            : piece.key === "audio:outro"
-                ? "audio_outro"
-                : "audio_body";
+        const segment = /^(?:audio|level):(intro|outro)$/.exec(piece.key)?.[1] ?? "body";
+        const role = level
+            ? "audio_levelled"
+            : piece.key === "audio:intro"
+                ? "audio_intro"
+                : piece.key === "audio:outro"
+                    ? "audio_outro"
+                    : "audio_body";
+        const voice = view.revision.config.audio === undefined
+            ? {}
+            : {
+                provider: view.revision.config.audio.provider,
+                model: view.revision.config.audio.model,
+                voice: view.revision.config.audio.voice,
+            };
         await publishResult(deps, context, piece, [
-            preparedResult(deps, context, piece, role, asset, durationMs, view.revision.config.audio === undefined
-                ? {}
+            preparedResult(deps, context, piece, role, asset, durationMs, levelled === undefined
+                ? voice
                 : {
-                    provider: view.revision.config.audio.provider,
-                    model: view.revision.config.audio.model,
-                    voice: view.revision.config.audio.voice,
+                    ...voice,
+                    segment: segment,
+                    loudness: levelled.report,
                 }),
         ], { durationMs }, asset);
+        if (level)
+            return;
         for (const key of recipe.dependsOn) {
             const retained = view.pieces.find((candidate) => candidate.key === key && candidate.selected && candidate.available);
             if (retained?.publicationId === null || retained === undefined)
@@ -137,6 +187,83 @@ async function concatenate(deps, context, piece) {
         }
     }
     finally {
+        rmSync(piecesDirectory, { recursive: true, force: true });
         discardPreparedAssets(deps, [pending]);
     }
 }
+// The pauses a join's values ask for (`recipe-pauses.ts`): its third value, when there is one.
+function pausesIn(values) {
+    const value = Array.isArray(values) ? values[2] : undefined;
+    const parsed = z
+        .tuple([
+        z.literal("pauses-v1"),
+        z.number(),
+        z.number(),
+        z.array(z.enum(["end", "turn", "sentence", "paragraph"])),
+    ])
+        .safeParse(value);
+    if (!parsed.success)
+        return undefined;
+    const [, sentenceSeconds, paragraphSeconds, next] = parsed.data;
+    return { settings: { sentenceSeconds, paragraphSeconds }, next };
+}
+// A speaker's pace plays their turn faster or slower, pauses included, so a turn's added
+// silence is scaled by it to come out at the minimum.
+function paceScaled(plans, turnValues) {
+    const layout = Array.isArray(turnValues) ? turnValues[1] : undefined;
+    if (!Array.isArray(layout))
+        return plans;
+    return plans.map((plan, at) => {
+        const pace = z.tuple([z.number().positive(), z.number()]).safeParse(layout[at]);
+        const factor = pace.success ? pace.data[0] : 1;
+        if (factor === 1)
+            return plan;
+        return {
+            ...plan,
+            padEnd: plan.padEnd * factor,
+            pauses: {
+                ...plan.pauses,
+                inserts: plan.pauses.inserts.map((one) => ({ ...one, seconds: one.seconds * factor })),
+            },
+        };
+    });
+}
+// The words a narration piece speaks, where its sentences end: the clean words of a request, or
+// of a piece supplied as a file.
+function pieceText(recipe) {
+    if (recipe === undefined)
+        return "";
+    const input = recipe.input;
+    // The words as said: a prepared request's delivery tags take no time of their own.
+    if (input.kind === "tts")
+        return (input.spokenText ?? input.text).replace(/\[[^\]]*\]/g, "");
+    if (input.kind === "provided" &&
+        Array.isArray(input.semantic) &&
+        typeof input.semantic[0] === "string")
+        return input.semantic[0];
+    return "";
+}
+// A multi-voice narration: every turn at its speaker's pace with the gap between turns, as the
+// recipe laid it out (`recipe-voices.ts`), measured off the file that was written. `values` is
+// the concat-turns-v1 recipe's own values.
+export async function joinTurns(run, files, values, output) {
+    const layout = z
+        .tuple([z.unknown(), z.array(z.tuple([z.number().positive(), z.number().nonnegative()]))])
+        // The pauses between sentences may follow (`recipe-pauses.ts`); they were made already.
+        .rest(z.unknown())
+        .parse(values)[1];
+    if (layout.length !== files.length || files.length === 0)
+        throw new Error("Slopify hit an internal error (the speaker turns to join don't match their audio). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+    await runFfmpeg({
+        bin: run.bin,
+        args: turnJoinArgs(files.map((path, index) => ({
+            path,
+            pace: layout[index]?.[0] ?? 1,
+            gapAfter: layout[index]?.[1] ?? 0,
+        })), output),
+        signal: run.signal,
+        log: run.log,
+        onProgress: () => { },
+    });
+    return probeDurationMs(run.bin, output, run.signal, run.log);
+}

package/dist/slices/rebuild/runtime-materialize.js

@@ -136,6 +136,10 @@ function futureKey(recipe) {
         return `narration:prepare:${recipe.input.preparation.segment}:future`;
     if (recipe.input.kind === "tts")
         return `audio:${recipe.input.segment}:future`;
+    // The descriptions unfold from the one step that stood in for them while the text was
+    // unwritten.
+    if (recipe.key.startsWith("narration:describe:") || recipe.key.startsWith("figure:card:"))
+        return "narration:describe:future";
     if (recipe.key.startsWith("research:chapter:"))
         return "research:planner";
     if (recipe.key === "article:continuation")
@@ -143,6 +147,10 @@ function futureKey(recipe) {
     // A short's images and render unfold from its image prompts, admitted with them: under the
     // pick on a first run, or on their own when one short is made again and the pick is kept.
     // The prompts unfold from the pick's answer.
+    // A short's review unfolds with the short it reviews.
+    const reviewed = /^review:(shorts:\d+)$/.exec(recipe.key);
+    if (reviewed?.[1] !== undefined)
+        return `${reviewed[1]}:prompts`;
     const clip = /^(shorts:\d+):(?:image:\d+|render)$/.exec(recipe.key);
     if (clip?.[1] !== undefined)
         return `${clip[1]}:prompts`;

package/dist/slices/rebuild/runtime-narration-reuse.js

@@ -3,7 +3,8 @@ import { insertManifestOutput, insertManifestPiece, selectOutputRecord, selectPi
 import { retainedNarrationPieces } from "./narration-history.js";
 import { matchingNarrationPiece } from "./narration-reuse.js";
 export function bindNarrationReuse(deps, view, recipe, ordinal) {
-    if (recipe.input.kind === "local" && recipe.input.operation === "concat-narration") {
+    if (recipe.input.kind === "local" &&
+        (recipe.input.operation === "concat-narration" || recipe.input.operation === "concat-turns-v1")) {
         const completed = view.pieces.find((one) => one.available &&
             one.piece.state === "done" &&
             one.key === recipe.key &&