@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/slices/video/encoding.js

@@ -0,0 +1,160 @@
+import { constants, setPriority } from "node:os";
+import { errorText } from "../../kernel/errors.js";
+import { lookEncoding } from "./look.js";
+// Settings → Production defaults → Rendering: how this computer encodes a video's picture.
+// They change how a video is made, never what it is, so no recipe fingerprint carries them and
+// a render reads them once as it starts (`renderMachine`).
+export const videoEncoders = ["cpu", "nvidia"];
+export const clipEncodeSpeeds = ["thorough", "fast"];
+export const renderPriorities = ["normal", "background"];
+// Today's render: x264 at its default preset, at normal priority.
+export const defaultEncode = { kind: "x264", clipSpeed: "thorough" };
+// Clips that are joined by copying get the final encode's settings. Clips that will be decoded
+// again under burned-in captions are kept closer to the source, so the second encode is not a
+// visible second generation.
+const intermediateCrf = "16";
+// measured on two minutes of a real project (changelog.d/2026-10-13-render-settings.md): 20
+// matches CRF 16's quality for the clips under captions; 28.5 makes the finished video about the
+// size CRF 23 does, where NVENC scores about 2.5 VMAF below x264 (no NVENC setting tried closed
+// that gap at that size).
+export const nvencQuality = { intermediate: 20, final: 28.5 };
+// `final` is a picture someone watches (a clip joined by copying, a burned-in part, the join);
+// `intermediate` is a clip decoded again under burned-in captions.
+export function codecArgs(encode, role, look) {
+    if (encode.kind === "nvenc")
+        return [
+            "-c:v",
+            "h264_nvenc",
+            // The slowest, best preset, constant quality with no bitrate cap. No `-multipass`: measured,
+            // a second full-resolution pass gave no better picture for its size on these videos.
+            "-preset",
+            "p7",
+            "-tune",
+            "hq",
+            "-rc",
+            "vbr",
+            "-cq",
+            String(nvencQuality[role]),
+            "-b:v",
+            "0",
+            // x264's own keyframe interval, so a clip opens on its one keyframe as x264's do and the
+            // clips still join by copying.
+            "-g",
+            "250",
+            "-pix_fmt",
+            "yuv420p",
+        ];
+    return [
+        "-c:v",
+        "libx264",
+        "-pix_fmt",
+        "yuv420p",
+        ...lookEncoding(look),
+        ...(role === "intermediate"
+            ? [...(encode.clipSpeed === "fast" ? ["-preset", "veryfast"] : []), "-crf", intermediateCrf]
+            : []),
+    ];
+}
+export const noNvenc = "No NVIDIA encoder found on this computer.";
+// The renders' own settings on a tiny picture: a driver or card that refuses any of them fails
+// here rather than in a render. NVENC refuses anything under about 145 pixels across.
+const testArgs = [
+    "-hide_banner",
+    "-nostdin",
+    "-loglevel",
+    "error",
+    "-f",
+    "lavfi",
+    "-i",
+    "color=c=black:s=256x256:r=30:d=0.1",
+    "-frames:v",
+    "1",
+    ...codecArgs({ kind: "nvenc", bin: "", clipSpeed: "thorough" }, "final", undefined),
+    "-f",
+    "null",
+    "-",
+];
+// The filters a render runs in the NVENC ffmpeg besides the encoder.
+const neededFilters = ["zoompan", "xfade", "ass"];
+// Which ffmpeg can encode on an NVIDIA card, asked once and remembered until Slopify restarts.
+// The bundled ffmpeg first, then the computer's own: unlike everything else, NVENC is the
+// computer's (its driver and its ffmpeg), and only used when chosen in Settings.
+export function createNvencProbe(deps) {
+    let answer;
+    return () => {
+        answer ??= probe(deps).catch((error) => ({
+            available: false,
+            reason: `${noNvenc} (${errorText(error)})`,
+        }));
+        return answer;
+    };
+}
+async function probe(deps) {
+    let failed;
+    for (const bin of new Set(deps.candidates)) {
+        const encoders = await deps.exec(bin, ["-hide_banner", "-encoders"]).catch(() => "");
+        if (!/^\s*V\S*\s+h264_nvenc\s/m.test(encoders))
+            continue;
+        const filters = await deps.exec(bin, ["-hide_banner", "-filters"]).catch(() => "");
+        const missing = neededFilters.filter((name) => !new RegExp(`^\\s*\\S+\\s+${name}\\s`, "m").test(filters));
+        if (missing.length > 0) {
+            failed = `the ffmpeg at ${bin} has NVENC but not the ${missing.join(", ")} filter a video needs`;
+            continue;
+        }
+        try {
+            await deps.exec(bin, testArgs);
+            deps.log.write("info", "video.encoder", { detail: `NVENC works through ${bin}` });
+            return { available: true, bin };
+        }
+        catch (error) {
+            failed = `the ffmpeg at ${bin} lists NVENC but its test encode failed: ${errorText(error)}`;
+        }
+    }
+    if (failed !== undefined) {
+        deps.log.write("info", "video.encoder", { detail: failed });
+        return { available: false, reason: `${noNvenc} (${failed})` };
+    }
+    return { available: false, reason: noNvenc };
+}
+// The render's machine settings, read as it starts. A card chosen but not working is a notice,
+// never a failed render: the processor encodes it instead.
+export async function renderMachine(deps) {
+    const { settings } = deps;
+    const cpu = { kind: "x264", clipSpeed: settings.clipEncodeSpeed };
+    if (settings.videoEncoder !== "nvidia")
+        return { machine: { encode: cpu, priority: settings.renderPriority } };
+    const status = await deps.nvenc();
+    if (status.available)
+        return {
+            machine: {
+                encode: { kind: "nvenc", bin: status.bin, clipSpeed: settings.clipEncodeSpeed },
+                priority: settings.renderPriority,
+            },
+        };
+    deps.log.write("warn", "video.encoder", {
+        projectId: deps.projectId,
+        detail: `NVIDIA encoder chosen but unavailable; encoding on the processor. ${status.reason}`,
+    });
+    return {
+        machine: { encode: cpu, priority: settings.renderPriority },
+        notice: nvencFallbackNotice(status.reason),
+    };
+}
+export function nvencFallbackNotice(reason) {
+    return `This video was encoded on the processor because the NVIDIA graphics card encoder didn't work (${reason.replace(/\.$/, "")}). Check the NVIDIA driver, or choose Processor (x264) in Settings → Production defaults → Video encoder.`;
+}
+// Background renders run below normal priority: nice 10 on Linux and macOS, the below-normal
+// class on Windows. Threads ffmpeg starts afterwards inherit it. Advisory: a system that
+// refuses is logged and the render carries on.
+export function setRenderPriority(pid, priority, log, set = setPriority) {
+    if (priority !== "background")
+        return;
+    try {
+        set(pid, constants.priority.PRIORITY_BELOW_NORMAL);
+    }
+    catch (error) {
+        log.write("warn", "video.priority", {
+            detail: `could not lower the render's priority: ${errorText(error)}`,
+        });
+    }
+}

package/dist/slices/video/ffmpeg.js

@@ -1,7 +1,9 @@
 import { spawn } from "node:child_process";
 import { isAbsolute, resolve as resolvePath } from "node:path";
+import { errorText, internalError } from "../../kernel/errors.js";
 import { bedChains, bedInputs } from "./ambient-mix.js";
-import { gradeFilter, lookChain, lookEncoding, placed } from "./look.js";
+import { codecArgs, defaultEncode, setRenderPriority, } from "./encoding.js";
+import { gradeFilter, lookChain, placed } from "./look.js";
 import { decimal, zoomRange } from "./plan.js";
 import { segments, transitionHalves } from "./transitions.js";
 // Hand-rolled per the standards: the filtergraph is the load-bearing part of this slice
@@ -44,7 +46,7 @@ export function slideshowClips(edit) {
             named.set(key, name);
             const shot = edit.shots[segment.kind === "shot" ? segment.shot : segment.to];
             if (shot === undefined)
-                throw new Error("Slopify hit an internal error (the video's edit list lost a shot). Use More → Render the video again in the Video section; if it happens again, use Download diagnostics in Settings and report it.");
+                throw new Error(internalError("the video's edit list lost a shot", "Use More → Render the video again in the Video section"));
             clips.push({ name, segment, shot, frames: segment.count });
         }
         return name;
@@ -77,10 +79,6 @@ function clipKey(edit, segment) {
         ? [shot?.source, shot?.motion, shot?.frames]
         : [shot?.source, shot?.motion, shot?.frames, segment.from, segment.count, at]);
 }
-// Clips that are joined by copying get the final encode's settings. Clips that will be
-// decoded again under burned-in captions are kept closer to the source, so the second
-// encode is not a visible second generation.
-const intermediateCrf = "16";
 // A whole shot as one clip.
 export function clipArgs(frame, shot, output, intermediate = false) {
     return segmentArgs({ ...frame, shots: [shot] }, { kind: "shot", shot: 0, from: 0, count: shot.frames, start: 0 }, output, intermediate);
@@ -88,12 +86,14 @@ export function clipArgs(frame, shot, output, intermediate = false) {
 // One clip of the slideshow: part of a shot, or a transition between two, with the Look.
 export function segmentArgs(edit, segment, output, intermediate = false, 
 // The clip's own chapter-card script, beside it in the working folder (`cards.ts`).
-cardsFile = "cards.ass") {
+cardsFile = "cards.ass", 
+// Settings → Production defaults → Rendering (`encoding.ts`).
+encode = defaultEncode) {
     const inputs = [];
     const chains = [];
     const picture = (shot, from, label) => {
         if (shot === undefined)
-            throw new Error("Slopify hit an internal error (the video's edit list lost a shot). Use More → Render the video again in the Video section; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error(internalError("the video's edit list lost a shot", "Use More → Render the video again in the Video section"));
         const at = inputs.filter((one) => one === "-i").length;
         const built = pictureChain(edit, shot, from, segment.count, at, label, gradeFilter(edit.look));
         inputs.push(...built.inputs);
@@ -125,9 +125,7 @@ cardsFile = "cards.ass") {
         ...(segment.kind === "shot" && segment.from === 0 && look === undefined
             ? []
             : ["-frames:v", String(segment.count)]),
-        ...videoCodec,
-        ...lookEncoding(edit.look),
-        ...(intermediate ? ["-crf", intermediateCrf] : []),
+        ...codecArgs(encode, intermediate ? "intermediate" : "final", edit.look),
         "-an",
         output,
     ];
@@ -257,7 +255,7 @@ export function audioMixArgs(edit, output, codec = "wav") {
 }
 // `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) {
+export function joinArgs(edit, output, list, burnSubtitles = false, portraits = [], sound, encode = defaultEncode) {
     const mix = sound === undefined ? audioMix(edit, 1) : { inputs: ["-i", sound], chains: [] };
     const inputs = ["-f", "concat", "-i", list, ...mix.inputs];
     const chains = burnSubtitles ? burnIn(inputs, portraits) : [];
@@ -270,7 +268,7 @@ export function joinArgs(edit, output, list, burnSubtitles = false, portraits =
         "-map",
         burnSubtitles ? "[v]" : "0:v",
         ...(audio ? ["-map", sound === undefined ? "[a]" : "1:a"] : []),
-        ...(burnSubtitles ? [...videoCodec, ...lookEncoding(edit.look)] : ["-c:v", "copy"]),
+        ...(burnSubtitles ? codecArgs(encode, "final", edit.look) : ["-c:v", "copy"]),
         ...(audio ? ["-c:a", sound === undefined ? "aac" : "copy"] : ["-an"]),
         "-movflags",
         "+faststart",
@@ -280,7 +278,7 @@ export function joinArgs(edit, output, list, burnSubtitles = false, portraits =
 // 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 = []) {
+export function burnPartArgs(edit, list, output, start, portraits = [], encode = defaultEncode) {
     const inputs = ["-f", "concat", "-i", list];
     const shifted = start === 0
         ? { before: "", after: "" }
@@ -298,8 +296,7 @@ export function burnPartArgs(edit, list, output, start, portraits = []) {
         chains.join(";"),
         "-map",
         "[v]",
-        ...videoCodec,
-        ...lookEncoding(edit.look),
+        ...codecArgs(encode, "final", edit.look),
         "-an",
         output,
     ];
@@ -333,7 +330,6 @@ const progressArgs = [
     "-nostats",
     "-y",
 ];
-const videoCodec = ["-c:v", "libx264", "-pix_fmt", "yuv420p"];
 const centredX = "iw/2-(iw/zoom/2)";
 const centredY = "ih/2-(ih/zoom/2)";
 // zoompan's expressions for a motion, or undefined for one that does not move. `on` is
@@ -403,6 +399,9 @@ export function runFfmpeg(run) {
             windowsHide: true,
             ...(run.cwd === undefined ? {} : { cwd: run.cwd }),
         });
+        // Before ffmpeg starts its threads, which inherit the priority.
+        if (child.pid !== undefined && run.priority !== undefined)
+            setRenderPriority(child.pid, run.priority, run.log);
         const errors = [];
         let pending = "";
         // A throw out of a stream listener is an uncaughtException, not a rejection: it would
@@ -413,7 +412,7 @@ export function runFfmpeg(run) {
                 work();
             }
             catch (error) {
-                run.log.write("warn", what, { detail: messageOf(error) });
+                run.log.write("warn", what, { detail: errorText(error) });
             }
         };
         const report = (line) => {
@@ -508,9 +507,6 @@ export async function probeDurationMs(bin, file, signal, log) {
     });
     return last;
 }
-function messageOf(error) {
-    return error instanceof Error ? error.message : String(error);
-}
 function failure(code, signal, errors) {
     const ended = code === null ? `killed by ${signal ?? "a signal"}` : `exited with code ${code}`;
     const said = errors.length === 0
@@ -518,3 +514,9 @@ function failure(code, signal, errors) {
         : `ffmpeg ${ended}: ${errors.join(" / ")}`;
     return `The audio/video export failed (${said}). Try again; if it fails again, make sure your disk has free space (see Settings → Backup & storage), then use Download diagnostics in Settings and report it.`;
 }
+// `runFfmpeg` at Settings → Production defaults → Render priority, read as each call starts: for
+// the work outside a video's render that still runs ffmpeg on this computer (a design's drawing,
+// a post's picture, Template Studio's free samples). A priority the caller set itself is kept.
+export function runFfmpegAt(priority, run = runFfmpeg) {
+    return (call) => run({ ...call, priority: call.priority ?? priority() });
+}

package/dist/slices/video/figure-card.js

@@ -1,5 +1,6 @@
 import { remark } from "remark";
 import remarkGfm from "remark-gfm";
+import { assText, assColour as colour } from "./ass-text.js";
 import { runFfmpeg } from "./ffmpeg.js";
 // The 3.0 design tokens (`packages/web/src/styles/index.css`): the surface graphite, ink,
 // the second ink, Slopify lime and the line colour, in the bundled Barlow.
@@ -449,21 +450,6 @@ function wrap(textValue, width, most) {
 function clip(value, room) {
     return value.length <= room ? value : `${value.slice(0, Math.max(1, room - 1))}…`;
 }
-// Text as libass draws it literally: braces and backslashes escaped rather than read as
-// override tags; code keeps its spaces, prose has them collapsed.
-function assText(value, keepSpaces = false) {
-    const escaped = value.replace(/\\/g, "\\\\").replace(/\{/g, "\\{").replace(/\}/g, "\\}");
-    return keepSpaces
-        ? escaped.replace(/ {2,}/g, (run) => "\\h".repeat(run.length))
-        : escaped.replace(/\s+/g, " ");
-}
-function colour(hex) {
-    const match = /^#([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/.exec(hex);
-    if (match === null)
-        return "&HFFFFFF&";
-    const [, r, g, b] = match;
-    return `&H${(b ?? "").toUpperCase()}${(g ?? "").toUpperCase()}${(r ?? "").toUpperCase()}&`;
-}
 function text(x, y, align, body) {
     return `Dialogue: 0,0:00:00.00,0:00:10.00,Card,,0,0,0,,{\\an${String(align)}\\pos(${String(Math.round(x))},${String(Math.round(y))})}${body}`;
 }

package/dist/slices/video/slideshow.js

@@ -1,8 +1,10 @@
 import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { extname, join } from "node:path";
+import { errorText, internalError } from "../../kernel/errors.js";
 import { masterFile, masterReport } from "../loudness/loudnorm.js";
 import { cardsAss } from "./cards.js";
 import { cacheKey, fileIdentity, keepClip, pruneClips, reuseClip } from "./clip-cache.js";
+import { defaultEncode, nvencFallbackNotice, } from "./encoding.js";
 import { audioMixArgs, burnPartArgs, concatList, joinArgs, runFfmpeg, segmentArgs, slideshowClips, } from "./ffmpeg.js";
 import { cardsIn } from "./look.js";
 import { inPool, renderJobs } from "./pool.js";
@@ -14,9 +16,31 @@ const copyWeight = 0.05;
 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.
+// What the master measured, when the run asked for one. A render on the NVIDIA card that fails
+// for any reason but a cancel is made again on the processor: the card never fails a render.
 export async function renderSlideshow(run) {
+    const encode = run.machine?.encode ?? defaultEncode;
+    if (encode.kind !== "nvenc")
+        return renderWith(run, encode);
+    try {
+        return await renderWith(run, encode);
+    }
+    catch (error) {
+        if (run.signal.aborted)
+            throw error;
+        const detail = errorText(error);
+        run.log.write("warn", "video.encoder", {
+            detail: `the NVENC render failed; rendering again on the processor: ${detail}`,
+        });
+        run.notice?.(nvencFallbackNotice(`it stopped the render: ${detail}`));
+        return renderWith(run, { kind: "x264", clipSpeed: encode.clipSpeed });
+    }
+}
+async function renderWith(run, encode) {
     const { edit } = run;
+    const priority = run.machine?.priority;
+    // The ffmpeg that encodes the picture; copying, sound and probing stay with the bundled one.
+    const encoder = encode.kind === "nvenc" ? encode.bin : run.bin;
     const { clips, order } = slideshowClips(edit);
     const msOf = (frames) => (frames / edit.fps) * 1000;
     const joinMs = msOf(edit.shots.reduce((sum, shot) => sum + shot.frames, 0));
@@ -38,7 +62,7 @@ export async function renderSlideshow(run) {
         const font = edit.cardFont;
         if (cards.length > 0) {
             if (font === undefined)
-                throw new Error("Slopify hit an internal error (the chapter cards have no font). Use More → Render the video again in the Video section; if it happens again, use Download diagnostics in Settings and report it.");
+                throw new Error(internalError("the chapter cards have no font", "Use More → Render the video again in the Video section"));
             mkdirSync(join(workspace, "fonts"), { mode: 0o700 });
             copyFileSync(font.path, join(workspace, "fonts", `card${extname(font.path)}`));
         }
@@ -81,7 +105,7 @@ export async function renderSlideshow(run) {
                 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 args = segmentArgs(edit, clip.segment, output, run.burnSubtitles, script, encode);
                 const weight = msOf(clip.frames) * clipWeight;
                 const cache = run.cache;
                 let key;
@@ -89,7 +113,7 @@ export async function renderSlideshow(run) {
                 // 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)]);
+                        key = cacheKey(encoder, 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;
@@ -99,15 +123,16 @@ export async function renderSlideshow(run) {
                     }
                 }
                 catch (error) {
-                    run.log.write("warn", "video.cache", { detail: messageOf(error) });
+                    run.log.write("warn", "video.cache", { detail: errorText(error) });
                     rmSync(output, { force: true });
                 }
                 await runFfmpeg({
-                    bin: run.bin,
+                    bin: encoder,
                     ...(cards.length > 0 ? { cwd: workspace } : {}),
                     args,
                     signal,
                     log: run.log,
+                    priority,
                     onProgress: (elapsedMs) => {
                         running.set(clip.name, Math.min(elapsedMs * clipWeight, weight));
                         tell();
@@ -120,7 +145,7 @@ export async function renderSlideshow(run) {
                         keepClip(cache, key, output);
                     }
                     catch (error) {
-                        run.log.write("warn", "video.cache", { detail: messageOf(error) });
+                        run.log.write("warn", "video.cache", { detail: errorText(error) });
                     }
                 }
             });
@@ -138,11 +163,12 @@ export async function renderSlideshow(run) {
                 const partList = join(workspace, `${part.name}.ffconcat`);
                 writeFileSync(partList, concatList(part.names), { mode: 0o600 });
                 await runFfmpeg({
-                    bin: run.bin,
+                    bin: encoder,
                     cwd: run.cwd,
-                    args: burnPartArgs(edit, partList, join(workspace, `${part.name}.mp4`), part.start, run.portraits),
+                    args: burnPartArgs(edit, partList, join(workspace, `${part.name}.mp4`), part.start, run.portraits, encode),
                     signal,
                     log: run.log,
+                    priority,
                     onProgress: (elapsedMs) => {
                         done.set(part.name, Math.min(elapsedMs, msOf(part.frames)));
                         burned();
@@ -167,11 +193,12 @@ export async function renderSlideshow(run) {
             throw new Error("the render was canceled");
         const burnsHere = run.burnSubtitles && parts.length <= 1;
         await runFfmpeg({
-            bin: run.bin,
+            bin: burnsHere ? encoder : run.bin,
             cwd: run.cwd,
-            args: joinArgs(edit, run.output, played, burnsHere, run.portraits, sound),
+            args: joinArgs(edit, run.output, played, burnsHere, run.portraits, sound, encode),
             signal: run.signal,
             log: run.log,
+            priority,
             onProgress: (elapsedMs) => report(rendered + elapsedMs * (burnsHere ? 1 : copyWeight)),
         });
         if (run.cache !== undefined) {
@@ -179,12 +206,12 @@ export async function renderSlideshow(run) {
                 pruneClips(run.cache, keys);
             }
             catch (error) {
-                run.log.write("warn", "video.cache", { detail: messageOf(error) });
+                run.log.write("warn", "video.cache", { detail: errorText(error) });
             }
         }
         // What the finished video measures, after its AAC encode.
         return run.master !== undefined && edit.audio.length > 0
-            ? await masterReport(run, run.output, run.master)
+            ? await masterReport({ ...run, priority }, run.output, run.master)
             : undefined;
     }
     finally {
@@ -194,13 +221,14 @@ export async function renderSlideshow(run) {
 // 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: () => { } };
+    const priority = run.machine?.priority;
+    const quiet = { bin: run.bin, signal, log: run.log, priority, 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);
+        await masterFile({ ...run, signal, priority }, mixed, mastered, run.master, masterFormat);
         played = {
             ...edit,
             audio: [
@@ -249,6 +277,3 @@ export function burnParts(order, clips, jobs) {
         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/slices/voices/palette.js

@@ -14,9 +14,6 @@ export function speakerColour(index) {
 }
 // ASS writes colours blue first: &HAABBGGRR in a style (alpha 00 is opaque) and &HBBGGRR& in
 // an inline override.
-export function assColour(hex, alpha = 0) {
-    return `&H${alpha.toString(16).padStart(2, "0")}${bgr(hex)}`.toUpperCase();
-}
 export function assInlineColour(hex) {
     return `&H${bgr(hex)}&`.toUpperCase();
 }

package/dist/slices/youtube/answer.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { jsonBetween } from "../../kernel/json-answer.js";
 import { alternativeTitles, descriptionMaxCharacters, hashtagsMax, minChapterSeconds, minChapters, pinnedCommentMaxCharacters, tagMaxCharacters, tagsMaxCharacters, titleMaxCharacters, } from "./model.js";
 import { parseTimestamp, youtubeTimestamp } from "./timestamps.js";
 import { keepsShape, titleShapeRule } from "./titles.js";
@@ -60,7 +61,7 @@ export function checkDescriptionAnswer(text, durationSeconds,
 title = "", 
 // Its pattern, whose fixed wording the other titles keep.
 shape) {
-    const parsed = answerSchema.safeParse(jsonOf(text));
+    const parsed = answerSchema.safeParse(jsonBetween(text, "{", "}"));
     if (!parsed.success)
         return {
             ok: false,
@@ -239,17 +240,3 @@ function checkTags(raw) {
         return broke(`the tags come to ${String(length)} characters, over YouTube's ${String(tagsMaxCharacters)}`);
     return { ok: true, value: tags };
 }
-// The object in the answer, wherever the model put it: bare, in a ```json fence, or after a
-// sentence of its own.
-function jsonOf(text) {
-    const start = text.indexOf("{");
-    const end = text.lastIndexOf("}");
-    if (start === -1 || end <= start)
-        return undefined;
-    try {
-        return JSON.parse(text.slice(start, end + 1));
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/slices/youtube/edits-repo.js

@@ -4,7 +4,7 @@
 import { z } from "zod";
 import { defaultChannelId } from "../channels/model.js";
 import { channelById, projectChannelId } from "../channels/repo.js";
-import { readSetting, writeSetting } from "../settings/repo.js";
+import { readJsonSetting, writeSetting } from "../settings/repo.js";
 import { chapterNotice, fitChapters } from "./chapters.js";
 import { composeDescription, descriptionFields, resolveFields, shownFields, splitDescription, } from "./edits.js";
 import { fillPlaceholders, mergeLinks } from "./placeholders.js";
@@ -36,18 +36,9 @@ export function writeDescriptionEdits(db, projectId, edits, updatedAt) {
      ON CONFLICT(project_id) DO UPDATE SET fields_json=excluded.fields_json,links_json=excluded.links_json,updated_at=excluded.updated_at`).run(projectId, JSON.stringify(edits.fields), JSON.stringify(edits.links), updatedAt);
 }
 export function readChannelLinks(db) {
-    const value = readSetting(db, channelLinksKey);
-    if (value === undefined)
-        return [];
     // A hand-edited row that no longer parses reads as no links rather than breaking the page;
     // saving the list in Settings writes a good one again.
-    try {
-        const parsed = linksSchema.safeParse(JSON.parse(value));
-        return parsed.success ? parsed.data : [];
-    }
-    catch {
-        return [];
-    }
+    return readJsonSetting(db, channelLinksKey, linksSchema, []);
 }
 export function writeChannelLinks(db, links) {
     writeSetting(db, channelLinksKey, JSON.stringify(links.map((link) => ({ name: link.name.trim(), url: link.url.trim() }))));

package/dist/tutorials/Agents-MCP.md

@@ -144,7 +144,8 @@ Slopify cannot wake an agent; the agent looks. Its work list is the `needs_atten
 | A paused run, or a run a restart **Stopped** | Continues it once nothing on the project still needs fixing. |
 | Topics a schedule holds for approval | Approves the ones that fit and turns down the rest. |
 | A video marked **Late · upload now** | Reports it. It cannot upload. |
-| A finishing touch the Studio extension failed (captions, end screen, pinned comment) | Reports it. Fixing it is the extension's or yours. |
+| A finishing touch the Studio extension failed (captions, end screen, pinned comment), or a post it couldn't fill on another site | Reports it. Fixing it is the extension's or yours. |
+| A post filled in another site's form, waiting for your **Post** (`post-due`) | Reports it. Posting is yours. |
 
 Projects that are **Kept as is** are not listed. Each entry says whether Slopify is already retrying or redoing it by itself (the agent leaves those alone and looks again later) and whether the agent can act on it at all.
 

package/dist/tutorials/Assistant.md

@@ -0,0 +1,42 @@
+# Assistant
+
+The assistant is a chat inside Slopify. Ask it how something works, or ask it to do something on the screen you have open: "Which templates do I have?", "Why did this run stop?", "Remake the thumbnail of this project". It runs on your own **Claude Code** or **Codex** sign-in, so it uses your plan's allowance and is not added to a project's run cost.
+
+**Where to find it:** **Assistant** in the left rail, under the search field. On a phone it is the sparkle button in the top bar. It opens beside the page without moving it.
+
+## What it can and can't do
+
+- It uses only Slopify's own tools, the same ones an [agent](Agents-MCP) uses, with the same checks and refusals as the buttons in the page. It reads this guide to answer questions about Slopify.
+- It has no web search, can't run commands and can't open files on your computer. None of your Claude Code or Codex settings, hooks, plugins, skills, memory or other MCP servers are loaded for it. If the CLI ever offers it a tool from outside Slopify, Slopify stops the answer at once and says so.
+- It never answers an external review, exports or imports the Library, uploads a file from disk, empties the Trash or deletes old versions. Uploading to YouTube, backups, provider keys and updates stay yours.
+- What it changes shows as **by assistant** in a project's history, in notifications and in **Settings → Connections → Agents (MCP)**.
+
+## It asks first
+
+Anything that costs money (starting a run or a remake, retrying a step, generating topics, a cast picture or a voice sample), anything a button would confirm, anything that removes something, and anything that sends to or changes an address outside Slopify (where notifications go, a test notification) waits for you. The chat shows a card with what it wants to do, for which project, and what it costs: the estimate the remake preview or Play's review showed, or "Slopify can't price it here" when there is none.
+
+| Press | What happens |
+| --- | --- |
+| **Allow** | The assistant does that one thing, with exactly what it asked for, and tells you what happened. An Allow is used once and only in that chat. |
+| **Don't** | Nothing runs. The assistant sees your answer the next time you write. |
+
+An ask you don't answer within 15 minutes expires: ask again, so it can check the cost again. The assistant can't press Allow for you; only a press in the page counts.
+
+## Using the chat
+
+- **Send** (or Enter) sends your message; Shift+Enter starts a new line. The answer streams in as it is written, with a line for each tool it used.
+- **Stop** ends the answer at once. Whatever it already did stays done. An answer that takes longer than 10 minutes is stopped for you.
+- **New chat** starts over. Each chat keeps its last 200 messages; the assistant remembers the last 20 of them (up to about 24,000 characters) when it answers.
+- **Runs on** picks the CLI: **Auto** takes Claude Code when it is installed and signed in, otherwise Codex.
+- It knows the page you have open: the project, schedule, channel or template on it, the section, and the rows you selected in a list.
+
+## When it can't start
+
+The panel says why and links to the fix:
+
+| Message | Fix |
+| --- | --- |
+| Neither Claude Code nor Codex is ready | Install one and sign in, then check it in **Settings → Providers** ([AI CLIs](AI-CLIs)). |
+| Claude Code (or Codex) is signed out | Run `claude auth login` (or `codex login`) in a terminal, then send your message again. |
+| Codex is too old | Update Codex CLI to the version the message names. |
+| The Docker version | The assistant isn't available in Docker: there the CLIs run on your computer through the host helper, which can't hand them Slopify's tools safely. Install Slopify with npm ([Install](Install)) to use it. |

package/dist/tutorials/Channels.md

@@ -47,6 +47,8 @@ A channel page has six tabs: **Brand**, **Cast**, **Templates**, **Schedules**,
 
 Mark voices in **Settings → Voices** and Image prompts in **Library → Prompts**. See [Publishing to YouTube](Publishing-to-YouTube).
 
+**Posting.** The channel's accounts on other sites, used only for [posting](Posting-to-Social-Sites). **X subscription** (Free, Premium or Premium+) only changes which warnings a post gets: Free warns about text over 280 characters and videos over 2 min 20 s. **Account names** (such as `@yourname` on X, `in/your-name` on LinkedIn, `yourname.bsky.social` on Bluesky, `u/yourname` on Reddit) let the extension find a published post's link on your profile. They are never a sign-in. Saved with **Save channel**.
+
 **Series brief.** What the channel covers, its style and what makes a topic worth a video. Topic generation reads it for every schedule of this channel that has no brief of its own. It doesn't change how videos are written. Up to 10,000 characters. See [Schedules](Schedules#topics-that-find-themselves).
 
 **Language of new projects.** The language this channel's new projects are written and narrated in when Play or the template picks none. It applies even with the brand kit off, since it is not styling. Pick voices that speak it. Not set means English. Projects already made keep their language. See [Other languages](Other-Languages).