@gentbajko/slopify 3.1.0 → 3.2.0

package/dist/patch-notes/3.1.1.md

@@ -0,0 +1,18 @@
+# Slopify 3.1.1
+
+Released 30 September 2026.
+
+3.1.1 lets the shorts draw figures the way the video does.
+
+## Shorts
+
+- The shorts' image prompt (**Shorts → Image prompt**) takes `{{Appearance}}`, like the video's image and thumbnail prompts. Each short gets the subject's researched look and those of the figures its clip names, so a figure looks the same in the shorts as in the video.
+- A `{{Scene}}` line in the shorts' image prompt is left out: each short's images already show what is said at that moment.
+
+## Help
+
+- The **Prompts** page of the wiki explains the two keywords Slopify fills itself, `{{Scene}}` and `{{Appearance}}`: what each becomes, where it works, and an example.
+
+## Upgrading from 3.1.0
+
+- **Nothing becomes outdated.** Only a shorts image prompt that names `{{Appearance}}` changes, the next time its shorts are made.

package/dist/patch-notes/3.2.0.md

@@ -0,0 +1,24 @@
+# Slopify 3.2.0
+
+Released 30 September 2026.
+
+3.2.0 renders videos several times faster, with the same picture and sound.
+
+## Highlights
+
+- **Faster renders.** A 2 h 22 min video with transitions and burned-in captions took about 2 hours to render. It now takes 36 minutes on the same computer.
+- **Faster re-renders.** Rendering again after an edit makes only the clips that changed; making the clips was 20 of those 36 minutes.
+
+## Video
+
+- The picture's clips are made several at a time instead of one after another: up to eight at once, depending on your computer's cores and memory.
+- With burned-in captions, a video of two minutes or more is encoded in parts side by side and then joined, instead of in one long pass.
+- The sound is levelled and encoded while the picture renders, instead of after it.
+- The clips of each project's last render are kept, so a render after an edit (captions, a few images, chapter cards) reuses every clip that did not change. A render that is canceled keeps the clips it finished, so the next one picks up where it stopped.
+- The kept clips live in a hidden `.render-cache` folder in your Projects folder. All projects together keep at most 30 GB. Older projects' clips are removed first, and all of them are removed if your disk gets short on space. Deleting a project removes its clips, and backups and moving your files leave them out.
+- Zooms and pans look exactly as before.
+
+## Upgrading from 3.1.1
+
+- **Nothing becomes outdated.** Videos you already rendered stay as they are. The first render of each project after upgrading makes all its clips; later renders reuse them.
+- A render uses more of your processor and memory while it runs (up to eight runs of about 1.5 GB each on a large computer). Two videos rendering at the same time share it.

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.2.0",
+    "title": "Slopify 3.2.0",
+    "version": "3.2.0",
+    "date": "2026-09-30"
+  },
+  {
+    "id": "3.1.1",
+    "title": "Slopify 3.1.1",
+    "version": "3.1.1",
+    "date": "2026-09-30"
+  },
   {
     "id": "3.1.0",
     "title": "Slopify 3.1.0",

package/dist/slices/rebuild/recipe-appearance.js

@@ -4,7 +4,7 @@ import { recipe, selectedReference, } from "./recipe-model.js";
 import { llmInput, llmInputFingerprint } from "./recipe-text.js";
 export const imageAppearanceKey = "images:appearance";
 // The prompt bodies a run draws pictures from: the generated images', the thumbnail's when it
-// is drawn from a Library prompt, and the establishing image's.
+// is drawn from a Library prompt, the establishing image's and the shorts' image prompt.
 function pictureBodies(context) {
     const { config, content } = context;
     const images = config.sources.images === "generate"
@@ -27,6 +27,9 @@ function pictureBodies(context) {
         ...(config.sources.images === "generate" && config.reference?.source === "prompt"
             ? [content.promptTemplates.referencePrompt ?? config.rendered.referencePrompt]
             : []),
+        ...(config.shorts?.enabled === true && config.shorts.imagePrompt?.trim()
+            ? [content.promptTemplates.shortsImage ?? config.rendered.shortsImage]
+            : []),
     ];
 }
 export function imageAppearance(context, text) {

package/dist/slices/rebuild/recipe-build.js

@@ -43,7 +43,7 @@ export function buildRecipes(context) {
         ...exports,
         ...youtube,
         ...(reference === undefined ? [] : [reference]),
-        ...shortsRecipes(context, exports, drawnFrom, audio.cards ?? [], masterPlan(context, audio.levels, "video")),
+        ...shortsRecipes(context, exports, drawnFrom, audio.cards ?? [], masterPlan(context, audio.levels, "video"), appearance),
         ...thumbnail,
         ...documentRecipes(context, text, thumbnail),
         ...visualAssets(context, visualRecipes(context.config, context.content, audio.mediaFingerprint, captions?.fingerprint ?? null, (images) => editPlan(context, exports, youtube, images, audio.cards ?? []), drawnFrom, timing === undefined ? null : resourceIdentity(context, timing), withLines(masterPlan(context, audio.levels, "video"), linePlan(context, timing)), scenes, appearance)),

package/dist/slices/rebuild/recipe-shorts.js

@@ -1,9 +1,11 @@
 import { z } from "zod";
 import { fingerprint } from "../../kernel/runner/work.js";
 import { usesShorts } from "../admission/rules.js";
+import { withoutScene } from "../images/scenes.js";
 import { effectiveClips, pickedShortsOf } from "../shorts/clips.js";
 import { defaultShortsImagePrompt, musicVolumeOf, shortImageCount, shortsSpeedOf, } from "../shorts/model.js";
 import { imagePromptMessages } from "../shorts/prompts.js";
+import { lookWait, withLooks } from "./recipe-appearance.js";
 import { castFor } from "./recipe-cast.js";
 import { noMaster } from "./recipe-loudness.js";
 import { recipe, resourceIdentity, selectedReference, } from "./recipe-model.js";
@@ -28,7 +30,9 @@ reference,
 // "Show tables and figures on screen": the cards a short shows where it describes one.
 cards = [], 
 // Level the volume: the levelled narration and the master (`recipe-loudness.ts`).
-master = noMaster) {
+master = noMaster, 
+// How the figures look, for a shorts image prompt with `{{Appearance}}` (`recipe-appearance.ts`).
+appearance) {
     const { config } = context;
     const shorts = config.shorts;
     const timing = exports.find((value) => value.key === "subtitles:timing");
@@ -58,8 +62,10 @@ master = noMaster) {
     { kind: "provider" });
     const picked = savedPicked(context, pick);
     const images = config.images ?? { provider: "", model: "" };
+    // A shorts image prompt may name `{{Scene}}` like the video's: the prompts call already writes
+    // each image's moment from what the clip says, so that line is left out here.
     const style = shorts.imagePrompt?.trim()
-        ? renderedPrompt(context, "shortsImage")
+        ? withoutScene(renderedPrompt(context, "shortsImage"))
         : defaultShortsImagePrompt;
     if (picked === undefined)
         return [
@@ -91,9 +97,22 @@ master = noMaster) {
         const prefix = `shorts:${String(clip.number)}`;
         const token = clipToken(context, clip);
         const count = shortImageCount(clip.end - clip.start, config.imageSeconds);
+        // The looks of the figures the clip names, and always the subject's: a short stands for
+        // the video. Until they are looked up the clip's prompts wait for them.
+        const looked = withLooks(style, appearance, clip.text, { subjectAlways: true });
+        if (looked === null) {
+            const wait = lookWait(style, appearance);
+            recipes.push(recipe(context, `${prefix}:prompts`, "video", {
+                kind: "deferred",
+                version: 1,
+                operation: "shorts",
+                template: [...wait.template, style, clip.text, count],
+            }, [pick.key, ...wait.dependsOn], { token }));
+            continue;
+        }
         const prompts = {
             ...recipe(context, `${prefix}:prompts`, "video", llmInput(context, imagePromptMessages({
-                style,
+                style: looked,
                 videoTitle: config.title,
                 shortTitle: clip.title,
                 text: clip.text,

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

@@ -4,7 +4,7 @@ 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 { outputPath, projectDir, renderCacheDir } from "../storage/layout.js";
 import { audioExportArgs } from "../video/audio-export.js";
 import { withPaths } from "../video/edit-list.js";
 import { runFfmpeg } from "../video/ffmpeg.js";
@@ -188,6 +188,7 @@ export async function executeExportRecipe(deps, context, piece) {
                 cwd: directory,
                 ...(portraits === undefined ? {} : { portraits: portraits.overlays }),
                 scratch: projectDirectory,
+                cache: renderCacheDir(deps.paths, context.work.projectId),
                 signal: context.signal,
                 log: deps.log,
                 onProgress,

package/dist/slices/storage/delete-project.js

@@ -1,7 +1,7 @@
 import { rmSync } from "node:fs";
 import { derive } from "../../kernel/runner/graph.js";
 import { stagesOf } from "../admission/repo.js";
-import { projectDir } from "./layout.js";
+import { projectDir, renderCacheDir } from "./layout.js";
 // A run in flight: a call the runner holds, or a stage running or waiting out a retry.
 export function projectBusy(deps, projectId) {
     return (deps.hasInflight?.(projectId) === true || derive(stagesOf(deps.db, projectId)) === "running");
@@ -18,6 +18,7 @@ export function deleteProject(deps, projectId) {
     const dir = projectDir(deps.paths, projectId);
     try {
         rmSync(dir, { recursive: true, force: true });
+        rmSync(renderCacheDir(deps.paths, projectId), { recursive: true, force: true });
     }
     catch (error) {
         deps.log.write("warn", "project.delete", {

package/dist/slices/storage/files-location.js

@@ -5,7 +5,7 @@ import { dirname, isAbsolute, join, parse, relative, resolve, sep } from "node:p
 import { z } from "zod";
 import { repoint } from "../../kernel/paths.js";
 import { readSetting, writeSetting } from "../settings/repo.js";
-import { backupsFolderName } from "./layout.js";
+import { backupsFolderName, renderCacheFolder } from "./layout.js";
 // Where the files a user looks at live: project folders, scheduled backups and anything else
 // Slopify saves for them. New installs keep them in <Documents>/Slopify; installs from before
 // 3.0 keep them where they were, inside the data dir, until the user moves them from Settings →
@@ -300,7 +300,7 @@ function sourceFiles(pair) {
         }
         for (const entry of entries) {
             const full = join(dir, entry.name);
-            if (dir === pair.from && entry.name === pair.skip)
+            if (dir === pair.from && (entry.name === pair.skip || entry.name === renderCacheFolder))
                 continue;
             if (entry.isDirectory())
                 walk(full);

package/dist/slices/storage/layout.js

@@ -2,6 +2,13 @@ import { extname, isAbsolute, relative, resolve } from "node:path";
 export function projectDir(paths, projectId) {
     return contained(paths.projects, projectId);
 }
+// The clips of each project's last render (`slices/video/clip-cache.ts`). Hidden, so
+// reconcile, backups and the user's file browser leave it alone; disposable, so moving the
+// files leaves it behind and a render simply encodes its clips again.
+export const renderCacheFolder = ".render-cache";
+export function renderCacheDir(paths, projectId) {
+    return contained(paths.projects, `${renderCacheFolder}/${projectId}`);
+}
 export function outputPath(paths, projectId, relativePath) {
     return contained(projectDir(paths, projectId), relativePath);
 }

package/dist/slices/video/clip-cache.js

@@ -0,0 +1,118 @@
+import { createHash } from "node:crypto";
+import { constants, copyFileSync, linkSync, mkdirSync, readdirSync, renameSync, rmSync, statfsSync, statSync, utimesSync, } from "node:fs";
+import { dirname, join } from "node:path";
+// The clips of a project's last render, kept so the next render encodes only the clips that
+// changed. A clip is named by what went into its ffmpeg run: the binary, the arguments with
+// its own output left out, every input file as it is on disk, and its chapter-card script and
+// font. Any change to those is another name, so a clip is never reused for a picture it
+// would not have drawn.
+//
+// The folder is one per project under a hidden folder of Projects, the same disk as the
+// render's working folder so a clip is linked, not copied; storage reconcile and backups
+// leave hidden folders alone, and deleting the project removes it.
+const version = "clip-cache-v1";
+const outputMark = "\u0000output";
+// ceiling: the caches of every project together. A 2.5-hour video with transitions keeps
+// about 10 GB of clips, so this holds the last few projects rendered.
+const mostBytes = 30 * 1024 ** 3;
+// floor: the free space a disk keeps before the caches give way; a tenth of a small disk.
+const leastFree = 20 * 1024 ** 3;
+const leastFreeShare = 0.1;
+export function cacheKey(bin, args, output, extra = []) {
+    const inputs = [];
+    args.forEach((value, at) => {
+        if (args[at - 1] === "-i")
+            inputs.push(fileIdentity(value));
+    });
+    const named = args.map((value) => (value === output ? outputMark : value));
+    return createHash("sha256")
+        .update(JSON.stringify([version, bin, named, inputs, extra]))
+        .digest("hex");
+}
+// A file as a key part: its path, size and last change. lavfi sources and other inputs that
+// are not files are keyed by their text alone.
+export function fileIdentity(path) {
+    const stat = statSync(path, { throwIfNoEntry: false });
+    return stat === undefined ? path : `${path}|${String(stat.size)}|${String(stat.mtimeMs)}`;
+}
+// Puts the cached clip at `target`; false when there is none.
+export function reuseClip(dir, key, target) {
+    const cached = join(dir, `${key}.mp4`);
+    if (statSync(cached, { throwIfNoEntry: false })?.isFile() !== true)
+        return false;
+    place(cached, target);
+    return true;
+}
+// Keeps a finished clip under its key, whole or not at all.
+export function keepClip(dir, key, source) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const pending = join(dir, `${key}.${String(process.pid)}.part`);
+    rmSync(pending, { force: true });
+    place(source, pending);
+    renameSync(pending, join(dir, `${key}.mp4`));
+}
+// After a finished render: the project keeps only that render's clips, and the other
+// projects' caches give way, least recently rendered first, until all of them fit under the
+// ceiling and the disk keeps its floor.
+export function pruneClips(dir, used, limits = { mostBytes }) {
+    for (const name of list(dir)) {
+        if (!used.has(name.replace(/\.mp4$/, "")))
+            rmSync(join(dir, name), { force: true });
+    }
+    const root = dirname(dir);
+    const now = new Date();
+    if (list(dir).length > 0)
+        utimesSync(dir, now, now);
+    const others = list(root)
+        .map((name) => join(root, name))
+        .filter((path) => path !== dir && statSync(path, { throwIfNoEntry: false })?.isDirectory())
+        .map((path) => ({ path, at: statSync(path).mtimeMs, bytes: bytesOf(path) }))
+        .toSorted((a, b) => a.at - b.at);
+    const floor = limits.leastFree ?? Math.min(leastFree, diskBytes(root) * leastFreeShare);
+    let total = bytesOf(dir) + others.reduce((sum, one) => sum + one.bytes, 0);
+    for (const other of others) {
+        if (total <= limits.mostBytes && freeBytes(root) >= floor)
+            break;
+        rmSync(other.path, { recursive: true, force: true });
+        total -= other.bytes;
+    }
+    if (freeBytes(root) < floor)
+        rmSync(dir, { recursive: true, force: true });
+}
+function place(from, to) {
+    try {
+        linkSync(from, to);
+    }
+    catch {
+        copyFileSync(from, to, constants.COPYFILE_FICLONE);
+    }
+}
+function list(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}
+function bytesOf(dir) {
+    return list(dir).reduce((sum, name) => sum + (statSync(join(dir, name), { throwIfNoEntry: false })?.size ?? 0), 0);
+}
+function diskBytes(path) {
+    try {
+        const stats = statfsSync(path);
+        return stats.blocks * stats.bsize;
+    }
+    catch {
+        return Number.POSITIVE_INFINITY;
+    }
+}
+function freeBytes(path) {
+    try {
+        const stats = statfsSync(path);
+        return stats.bavail * stats.bsize;
+    }
+    catch {
+        return Number.POSITIVE_INFINITY;
+    }
+}

package/dist/slices/video/ffmpeg.js

@@ -240,9 +240,9 @@ function audioMix(edit, first) {
     }
     return { inputs, chains };
 }
-// The video's sound alone, as a WAV: what Level the volume masters before the join plays it
-// (`slideshow.ts`).
-export function audioMixArgs(edit, output) {
+// The video's sound alone: as a WAV, what Level the volume masters, or as AAC, the finished
+// sound the join copies in (`slideshow.ts`, which makes it while the picture renders).
+export function audioMixArgs(edit, output, codec = "wav") {
     const mix = audioMix(edit, 0);
     return [
         ...progressArgs,
@@ -251,51 +251,77 @@ export function audioMixArgs(edit, output) {
         mix.chains.join(";"),
         "-map",
         "[a]",
-        "-c:a",
-        "pcm_s16le",
-        "-f",
-        "wav",
+        ...(codec === "wav" ? ["-c:a", "pcm_s16le", "-f", "wav"] : ["-c:a", "aac", "-f", "mp4"]),
         output,
     ];
 }
-export function joinArgs(edit, output, list, burnSubtitles = false, portraits = []) {
-    const mix = audioMix(edit, 1);
+// `sound`, when given, is the finished AAC (`audioMixArgs`), copied in; without it the join
+// mixes and encodes the edit list's audio itself.
+export function joinArgs(edit, output, list, burnSubtitles = false, portraits = [], sound) {
+    const mix = sound === undefined ? audioMix(edit, 1) : { inputs: ["-i", sound], chains: [] };
     const inputs = ["-f", "concat", "-i", list, ...mix.inputs];
-    const chains = [];
-    const overlaid = burnSubtitles && portraits.length > 0;
-    if (burnSubtitles && !overlaid)
-        chains.push("[0:v]ass=filename=subtitles.ass:fontsdir=fonts[v]");
+    const chains = burnSubtitles ? burnIn(inputs, portraits) : [];
     chains.push(...mix.chains);
-    // The portraits go in after every other input and under the captions, so the panel's lit
-    // outline is drawn over them; a video without any is joined exactly as before. A still
-    // image is one frame, which overlay holds to the end (`eof_action=repeat`).
-    if (overlaid) {
-        let first = inputs.filter((value) => value === "-i").length;
-        let source = "[0:v]";
-        const video = [];
-        portraits.forEach((portrait, at) => {
-            inputs.push("-i", portrait.path);
-            const size = String(portrait.size);
-            video.push(`[${String(first)}:v]scale=${size}:${size}:force_original_aspect_ratio=increase,crop=${size}:${size},setsar=1[pic${String(at)}]`, `${source}[pic${String(at)}]overlay=x=${String(portrait.x)}:y=${String(portrait.y)}:eof_action=repeat[panel${String(at)}]`);
-            source = `[panel${String(at)}]`;
-            first += 1;
-        });
-        chains.unshift(...video, `${source}ass=filename=subtitles.ass:fontsdir=fonts[v]`);
-    }
+    const audio = sound !== undefined || edit.audio.length > 0;
     return [
         ...progressArgs,
         ...inputs,
         ...(chains.length > 0 ? ["-filter_complex", chains.join(";")] : []),
         "-map",
         burnSubtitles ? "[v]" : "0:v",
-        ...(edit.audio.length > 0 ? ["-map", "[a]"] : []),
+        ...(audio ? ["-map", sound === undefined ? "[a]" : "1:a"] : []),
         ...(burnSubtitles ? [...videoCodec, ...lookEncoding(edit.look)] : ["-c:v", "copy"]),
-        ...(edit.audio.length > 0 ? ["-c:a", "aac"] : ["-an"]),
+        ...(audio ? ["-c:a", sound === undefined ? "aac" : "copy"] : ["-an"]),
         "-movflags",
         "+faststart",
         output,
     ];
 }
+// One part of a long video's picture with its captions burned in, from frame `start` of the
+// video (`slideshow.ts` encodes the parts side by side, then joins them by copying). The part's
+// frames are moved to their place in the video for the captions and back to zero after them.
+export function burnPartArgs(edit, list, output, start, portraits = []) {
+    const inputs = ["-f", "concat", "-i", list];
+    const shifted = start === 0
+        ? { before: "", after: "" }
+        : {
+            before: `setpts=PTS+${String(start)}/(${String(edit.fps)}*TB),`,
+            // Moving the timestamps drops the declared rate, and without one the output falls
+            // back to 25 fps and drops frames.
+            after: `,setpts=PTS-STARTPTS,fps=${String(edit.fps)}`,
+        };
+    const chains = burnIn(inputs, portraits, shifted.before, shifted.after);
+    return [
+        ...progressArgs,
+        ...inputs,
+        "-filter_complex",
+        chains.join(";"),
+        "-map",
+        "[v]",
+        ...videoCodec,
+        ...lookEncoding(edit.look),
+        "-an",
+        output,
+    ];
+}
+// The captions over the picture in input 0, into `[v]`. The portraits go in after every other
+// input and under the captions, so the panel's lit outline is drawn over them; a video without
+// any is burned exactly as before. A still image is one frame, which overlay holds to the end
+// (`eof_action=repeat`).
+function burnIn(inputs, portraits, before = "", after = "") {
+    let first = inputs.filter((value) => value === "-i").length;
+    let source = "[0:v]";
+    const video = [];
+    portraits.forEach((portrait, at) => {
+        inputs.push("-i", portrait.path);
+        const size = String(portrait.size);
+        video.push(`[${String(first)}:v]scale=${size}:${size}:force_original_aspect_ratio=increase,crop=${size}:${size},setsar=1[pic${String(at)}]`, `${source}[pic${String(at)}]overlay=x=${String(portrait.x)}:y=${String(portrait.y)}:eof_action=repeat[panel${String(at)}]`);
+        source = `[panel${String(at)}]`;
+        first += 1;
+    });
+    video.push(`${source}${before}ass=filename=subtitles.ass:fontsdir=fonts${after}[v]`);
+    return video;
+}
 const progressArgs = [
     "-hide_banner",
     "-nostdin",

package/dist/slices/video/pool.js

@@ -0,0 +1,56 @@
+import { availableParallelism, totalmem } from "node:os";
+// zoompan runs on one core, so a render of one clip at a time leaves most of the machine
+// idle. Measured on 32 cores with ffmpeg 7 and 15-second clips from a 4x still: one at a time
+// 8.1 s a clip, four at once 2.9 s, eight 1.9 s, sixteen 1.6 s. Eight is where the gain
+// flattens, and each run holds about 1.4 GB (a transition, two stills, twice that), so the
+// memory the process may use caps it as well.
+const mostJobs = 8;
+const coresPerJob = 4;
+const bytesPerJob = 3 * 1024 ** 3;
+export function renderJobs(cores = availableParallelism(), memory = usableMemory()) {
+    return Math.max(1, Math.min(mostJobs, Math.floor(cores / coresPerJob), Math.floor(memory / 2 / bytesPerJob)));
+}
+// A container's memory limit, when it has one below the machine's.
+function usableMemory() {
+    const limit = process.constrainedMemory();
+    const total = totalmem();
+    return limit > 0 && limit < total ? limit : total;
+}
+// Runs `work` over every item, at most `limit` at once, in the items' order. The first failure
+// stops the rest: nothing new starts, the runs already going are aborted through the signal
+// each was given, and once they have all ended the first failure is the one thrown, not the
+// cancellations it caused.
+export async function inPool(items, limit, signal, work) {
+    if (signal.aborted)
+        throw new Error("the render was canceled before it started");
+    const stop = new AbortController();
+    const follow = () => {
+        stop.abort();
+    };
+    signal.addEventListener("abort", follow, { once: true });
+    let next = 0;
+    let failed;
+    const runner = async () => {
+        while (failed === undefined && !stop.signal.aborted && next < items.length) {
+            const at = next;
+            next += 1;
+            try {
+                await work(items[at], stop.signal);
+            }
+            catch (error) {
+                failed ??= { error };
+                stop.abort();
+            }
+        }
+    };
+    try {
+        await Promise.all(Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, runner));
+    }
+    finally {
+        signal.removeEventListener("abort", follow);
+    }
+    if (failed !== undefined)
+        throw failed.error;
+    if (signal.aborted)
+        throw new Error("the render was canceled");
+}

package/dist/slices/video/slideshow.js

@@ -2,12 +2,16 @@ import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "nod
 import { extname, join } from "node:path";
 import { masterFile, masterReport } from "../loudness/loudnorm.js";
 import { cardsAss } from "./cards.js";
-import { audioMixArgs, concatList, joinArgs, runFfmpeg, segmentArgs, slideshowClips, } from "./ffmpeg.js";
+import { cacheKey, fileIdentity, keepClip, pruneClips, reuseClip } from "./clip-cache.js";
+import { audioMixArgs, burnPartArgs, concatList, joinArgs, runFfmpeg, segmentArgs, slideshowClips, } from "./ffmpeg.js";
 import { cardsIn } from "./look.js";
+import { inPool, renderJobs } from "./pool.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;
+// floor: a burned-in part shorter than a minute is not worth its own run.
+const leastPartFrames = 60 * 30;
 // 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.
@@ -19,7 +23,11 @@ export async function renderSlideshow(run) {
     // Progress is reported against the video's length, the longer of picture and sound.
     const totalMs = Math.max(joinMs, edit.audio.reduce((sum, segment) => sum + segment.seconds * 1000, 0));
     const clipMs = clips.reduce((sum, clip) => sum + msOf(clip.frames), 0);
-    const work = clipMs * clipWeight + joinMs * (run.burnSubtitles ? 1 : copyWeight);
+    const jobs = run.jobs ?? renderJobs();
+    const parts = run.burnSubtitles ? burnParts(order, clips, jobs) : [];
+    const work = clipMs * clipWeight +
+        joinMs * (run.burnSubtitles ? 1 : copyWeight) +
+        (parts.length > 1 ? joinMs * copyWeight : 0);
     const report = (done) => {
         run.onProgress(work > 0 ? Math.round((Math.min(done, work) / work) * totalMs) : 0);
     };
@@ -34,66 +42,213 @@ export async function renderSlideshow(run) {
             mkdirSync(join(workspace, "fonts"), { mode: 0o700 });
             copyFileSync(font.path, join(workspace, "fonts", `card${extname(font.path)}`));
         }
+        // The sound is mixed, levelled and encoded while the picture renders, on its own run; the
+        // join then only copies it in. Either failing stops the other, and the first failure is
+        // the one reported.
+        const stop = new AbortController();
+        const follow = () => {
+            stop.abort();
+        };
+        if (run.signal.aborted)
+            stop.abort();
+        else
+            run.signal.addEventListener("abort", follow, { once: true });
+        let failed;
+        const watched = (work) => work.catch((error) => {
+            failed ??= { error };
+            stop.abort();
+            throw error;
+        });
+        const sounding = edit.audio.length > 0
+            ? watched(renderSound(run, edit, workspace, stop.signal))
+            : Promise.resolve(undefined);
+        // Handled now, since the picture is awaited first and the sound may fail meanwhile.
+        sounding.catch(() => { });
         let rendered = 0;
-        for (const clip of clips) {
-            const before = rendered;
-            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, edit.cardColor), { mode: 0o600 });
-            await runFfmpeg({
-                bin: run.bin,
-                ...(cards.length > 0 ? { cwd: workspace } : {}),
-                args: segmentArgs(edit, clip.segment, join(workspace, clip.name), run.burnSubtitles, script),
-                signal: run.signal,
-                log: run.log,
-                onProgress: (elapsedMs) => report(before + elapsedMs * clipWeight),
-            });
-            rendered += msOf(clip.frames) * clipWeight;
-        }
-        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),
+        const keys = new Set();
+        const picture = async (halt) => {
+            // Each run's own progress, summed: runs side by side each report their own elapsed time.
+            const running = new Map();
+            const tell = () => {
+                report(rendered + [...running.values()].reduce((sum, one) => sum + one, 0));
+            };
+            await inPool(clips, jobs, halt, async (clip, signal) => {
+                const script = clip.name.replace(/\.mp4$/, ".ass");
+                const shown = cardsIn(cards, clip.segment.start, clip.segment.count);
+                const drawn = shown.length > 0 && font !== undefined
+                    ? cardsAss(edit, shown, font.name, clip.segment.start, edit.cardColor)
+                    : undefined;
+                if (drawn !== undefined)
+                    writeFileSync(join(workspace, script), drawn, { mode: 0o600 });
+                const output = join(workspace, clip.name);
+                const args = segmentArgs(edit, clip.segment, output, run.burnSubtitles, script);
+                const weight = msOf(clip.frames) * clipWeight;
+                const cache = run.cache;
+                let key;
+                // The cache only saves time: a clip it cannot name or give back (another project's render
+                // let it go a moment ago) is encoded as if there were none.
+                try {
+                    if (cache !== undefined) {
+                        key = cacheKey(run.bin, args.map((value) => drawn === undefined ? value : value.replaceAll(script, "\u0000cards")), output, drawn === undefined || font === undefined ? [] : [drawn, fileIdentity(font.path)]);
+                        keys.add(key);
+                        if (reuseClip(cache, key, output)) {
+                            rendered += weight;
+                            tell();
+                            return;
+                        }
+                    }
+                }
+                catch (error) {
+                    run.log.write("warn", "video.cache", { detail: messageOf(error) });
+                    rmSync(output, { force: true });
+                }
+                await runFfmpeg({
+                    bin: run.bin,
+                    ...(cards.length > 0 ? { cwd: workspace } : {}),
+                    args,
+                    signal,
+                    log: run.log,
+                    onProgress: (elapsedMs) => {
+                        running.set(clip.name, Math.min(elapsedMs * clipWeight, weight));
+                        tell();
                     },
-                ],
-                bed: undefined,
+                });
+                running.delete(clip.name);
+                rendered += weight;
+                if (cache !== undefined && key !== undefined) {
+                    try {
+                        keepClip(cache, key, output);
+                    }
+                    catch (error) {
+                        run.log.write("warn", "video.cache", { detail: messageOf(error) });
+                    }
+                }
+            });
+            const list = join(workspace, "slides.ffconcat");
+            writeFileSync(list, concatList(order), { mode: 0o600 });
+            if (parts.length <= 1)
+                return list;
+            // A long video's captions are burned in parts side by side, and the parts joined by
+            // copying, as the clips are without captions.
+            const done = new Map();
+            const burned = () => {
+                report(rendered + [...done.values()].reduce((sum, one) => sum + one, 0));
             };
-        }
+            await inPool(parts, jobs, halt, async (part, signal) => {
+                const partList = join(workspace, `${part.name}.ffconcat`);
+                writeFileSync(partList, concatList(part.names), { mode: 0o600 });
+                await runFfmpeg({
+                    bin: run.bin,
+                    cwd: run.cwd,
+                    args: burnPartArgs(edit, partList, join(workspace, `${part.name}.mp4`), part.start, run.portraits),
+                    signal,
+                    log: run.log,
+                    onProgress: (elapsedMs) => {
+                        done.set(part.name, Math.min(elapsedMs, msOf(part.frames)));
+                        burned();
+                    },
+                });
+                done.set(part.name, msOf(part.frames));
+                burned();
+            });
+            rendered += joinMs;
+            const joinedList = join(workspace, "parts.ffconcat");
+            writeFileSync(joinedList, concatList(parts.map((part) => `${part.name}.mp4`)), {
+                mode: 0o600,
+            });
+            return joinedList;
+        };
+        const played = await watched(picture(stop.signal)).catch(() => undefined);
+        const sound = await sounding.catch(() => undefined);
+        run.signal.removeEventListener("abort", follow);
+        if (failed !== undefined)
+            throw failed.error;
+        if (played === undefined)
+            throw new Error("the render was canceled");
+        const burnsHere = run.burnSubtitles && parts.length <= 1;
         await runFfmpeg({
             bin: run.bin,
             cwd: run.cwd,
-            args: joinArgs(joined, run.output, list, run.burnSubtitles, run.portraits),
+            args: joinArgs(edit, run.output, played, burnsHere, run.portraits, sound),
             signal: run.signal,
             log: run.log,
-            onProgress: (elapsedMs) => report(rendered + elapsedMs * (run.burnSubtitles ? 1 : copyWeight)),
+            onProgress: (elapsedMs) => report(rendered + elapsedMs * (burnsHere ? 1 : copyWeight)),
         });
+        if (run.cache !== undefined) {
+            try {
+                pruneClips(run.cache, keys);
+            }
+            catch (error) {
+                run.log.write("warn", "video.cache", { detail: messageOf(error) });
+            }
+        }
         // 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;
+        return run.master !== undefined && edit.audio.length > 0
+            ? await masterReport(run, run.output, run.master)
+            : undefined;
     }
     finally {
         rmSync(workspace, { recursive: true, force: true });
     }
 }
+// The video's finished sound as AAC in the working folder: the narration, silences and bed
+// mixed, and with Level the volume mastered first, alone and then as one file.
+async function renderSound(run, edit, workspace, signal) {
+    const quiet = { bin: run.bin, signal, log: run.log, onProgress: () => { } };
+    let played = edit;
+    if (run.master !== undefined) {
+        const mixed = join(workspace, "mix.wav");
+        await runFfmpeg({ ...quiet, args: audioMixArgs(edit, mixed) });
+        const mastered = join(workspace, "master.wav");
+        await masterFile({ ...run, signal }, mixed, mastered, run.master, masterFormat);
+        played = {
+            ...edit,
+            audio: [
+                {
+                    kind: "body",
+                    path: mastered,
+                    seconds: edit.audio.reduce((sum, segment) => sum + segment.seconds, 0),
+                },
+            ],
+            bed: undefined,
+        };
+    }
+    const sound = join(workspace, "sound.m4a");
+    await runFfmpeg({ ...quiet, args: audioMixArgs(played, sound, "aac") });
+    return sound;
+}
+// The timeline cut at clip boundaries into at most `jobs` parts of about equal length, a
+// minute or more each; one part means the captions are burned in the join as before.
+export function burnParts(order, clips, jobs) {
+    const framesOf = new Map(clips.map((clip) => [clip.name, clip.frames]));
+    const total = order.reduce((sum, name) => sum + (framesOf.get(name) ?? 0), 0);
+    const count = Math.max(1, Math.min(jobs, Math.floor(total / leastPartFrames)));
+    const parts = [];
+    let names = [];
+    let start = 0;
+    let at = 0;
+    for (const name of order) {
+        const frames = framesOf.get(name) ?? 0;
+        const target = (total * (parts.length + 1)) / count;
+        const last = parts.length === count - 1;
+        // A part ends at the clip boundary nearest its share of the timeline.
+        if (!last && names.length > 0 && at + frames >= target && target - at < at + frames - target) {
+            parts.push({ name: `p${String(parts.length + 1)}`, names, start, frames: at - start });
+            names = [];
+            start = at;
+        }
+        names.push(name);
+        at += frames;
+        if (parts.length < count - 1 && at >= (total * (parts.length + 1)) / count) {
+            parts.push({ name: `p${String(parts.length + 1)}`, names, start, frames: at - start });
+            names = [];
+            start = at;
+        }
+    }
+    if (names.length > 0)
+        parts.push({ name: `p${String(parts.length + 1)}`, names, start, frames: at - start });
+    return parts;
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/tutorials/Play-Images.md

@@ -124,7 +124,7 @@ The style, composition and everything else in the prompt stay as written; only t
 
 ## Looks looked up: {{Appearance}}
 
-An image model draws a named figure from whatever it half remembers, so the same character can look different in every image. Put `{{Appearance}}` in an image, thumbnail or establishing prompt, for example a line `Looks: {{Appearance}}`, and Slopify looks the looks up instead.
+An image model draws a named figure from whatever it half remembers, so the same character can look different in every image. Put `{{Appearance}}` in an image, thumbnail, establishing or shorts image prompt, for example a line `Looks: {{Appearance}}`, and Slopify looks the looks up instead.
 
 - Once the article exists, one call to the project's AI model **searches the web** for how the video's subject and every named character in the article look: build, face, clothing, colours and the marks that make them recognisable. Where depictions disagree, it describes the most iconic one.
 - With **Scenes from the article** on, each picture gets the looks of the figures its scene names (up to three besides the subject), so a scene of a place or of someone else isn't redrawn with the subject in it; a scene that names no one leaves the looks line out. A thumbnail always gets the subject's look. Without scenes, every picture gets the subject's look.

package/dist/tutorials/Prompts.md

@@ -50,7 +50,7 @@ When the body already has text, Slopify asks "Replace this prompt body?" first.
 
 ## Keywords (slots)
 
-Every `{{keyword}}` in the body becomes one field on Play.
+Every `{{keyword}}` in the body becomes one field on Play, except the two Slopify fills itself (below).
 
 - You type a keyword's value once per video, and it is filled into every prompt, intro and outro that names it.
 - Names are case-sensitive: `{{Topic}}` and `{{topic}}` are two fields.
@@ -63,6 +63,30 @@ Mistakes the editor refuses, with the line and column:
 - a keyword with no name,
 - a keyword placed inside another keyword.
 
+### Keywords Slopify fills: {{Scene}} and {{Appearance}}
+
+Two keywords never become fields. The project's AI model writes them during the run, once the article exists, and the picture waits for them:
+
+| Keyword | Filled with | Works in | Needs |
+| --- | --- | --- | --- |
+| `{{Scene}}` | This picture's moment from the article: for images, in order from the article's opening to its ending; for thumbnails, its most striking moment, a different one for each of three. | Image and thumbnail prompts | Images → **Scenes from the article** on |
+| `{{Appearance}}` | How the figures look, looked up on the web (most iconic depiction): the ones the picture's scene names, or the video's subject; a thumbnail or a short always gets the subject. | Image, thumbnail, establishing and shorts image prompts | Nothing: the keyword turns it on |
+
+Put each on a line of its own with a label, for example:
+
+```
+Scene: {{Scene}}
+
+Looks: {{Appearance}}
+```
+
+- An image prompt without `{{Scene}}` still gets its scene, after its first paragraph, while Scenes from the article is on. A thumbnail prompt without it gets none.
+- With Scenes from the article off, a line holding `{{Scene}}` is left out. A `{{Appearance}}` line whose scene names no one is left out too.
+- Each costs one more AI call per video (the looks call searches the web).
+- In the shorts' image prompt (**Shorts → Image prompt**), `{{Appearance}}` gives each short the subject's look and those of the figures its clip names. A `{{Scene}}` line is left out there: each short's images already show what is said at that moment.
+
+See [Play Images](Play-Images#scenes-from-the-article) for how the scenes and looks are chosen.
+
 ## Mark an image prompt as photorealistic
 
 YouTube asks whether a video contains realistic-looking AI scenes. Slopify answers for you from your marks.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gentbajko/slopify",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Turn a prompt into a finished video, locally, with your own provider keys",
   "license": "Apache-2.0",
   "author": "Gent Bajko",