@gentbajko/slopify 3.1.1 → 3.2.1

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/3.2.1.md

@@ -0,0 +1,13 @@
+# Slopify 3.2.1
+
+Released 30 September 2026.
+
+3.2.1 lets one narration chunk be re-tagged without re-recording the whole narration.
+
+## Narration
+
+- A chunk whose text is edited in Edit project → Narration can carry its own delivery note. The note is added to the narration prep prompt for that chunk only, so its delivery cues can change (a calmer opening, say) while every other chunk keeps its recording.
+
+## Upgrading from 3.2.0
+
+- **Nothing becomes outdated.**

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.2.1",
+    "title": "Slopify 3.2.1",
+    "version": "3.2.1",
+    "date": "2026-09-30"
+  },
+  {
+    "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",

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

@@ -26,8 +26,12 @@ export function preparationFuture(context, segment, dependency, additionalDepend
     }, [...new Set([dependency.key, ...additionalDependencies.map((row) => row.key)])]);
 }
 export function preparationForGroup(context, logicalKey, source, segment, dependsOn, maxCharacters, spans = [], aliases = [], speaker) {
+    // A delivery note for this chunk alone (Edit project → Narration), after the project's prompt.
+    const override = context.content.narrationOverrides[logicalKey];
+    const note = override?.kind === "text" ? override.direction : undefined;
+    const prompt = renderedPrompt(context, "narration");
     const preparation = recipe(context, `narration:prepare:${segment}:${logicalKey}`, "audio", {
-        ...llmInput(context, preparationMessages(renderedPrompt(context, "narration"), source, aliases, context.config.language, speaker)),
+        ...llmInput(context, preparationMessages(note === undefined ? prompt : `${prompt}\n\n${note}`, source, aliases, context.config.language, speaker)),
         preparation: { format: "inworld-tts-2", version: 1, source, logicalKey, segment },
     }, dependsOn, { unresolved: source.trim() === "" });
     if (source.trim() === "")

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/revisions/schema.js

@@ -55,7 +55,13 @@ export const revisionContentSchema = z
         .strict()),
     narrationOverrides: z.record(workKey, z.discriminatedUnion("kind", [
         z.object({ kind: z.literal("asset"), assetId: id }).strict(),
-        z.object({ kind: z.literal("text"), text: z.string().trim().min(1).max(500000) }).strict(),
+        z
+            .object({
+            kind: z.literal("text"),
+            text: z.string().trim().min(1).max(500000),
+            direction: z.string().trim().min(1).max(20000).optional(),
+        })
+            .strict(),
     ])),
     narrationSources: z
         .record(workKey, z

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");
+}