@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/slices/video/encoding.js

@@ -0,0 +1,169 @@
+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]
+            : []),
+    ];
+}
+// Said to a person who may have no NVIDIA card at all: stock ffmpeg builds list the NVIDIA
+// encoder everywhere, so a failed test usually means there is no card, not a broken one. What
+// the test printed goes under Details (`detail`), never into these sentences.
+export const noNvenc = "No NVIDIA graphics card was found on this computer.";
+export const failedNvenc = "No working NVIDIA graphics card was found on this computer.";
+// The reason with the test's output, for the log and a run's notice.
+export function nvencWhy(status) {
+    return status.detail === undefined ? status.reason : `${status.reason} (${status.detail})`;
+}
+// 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,
+            detail: 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: failedNvenc, detail: 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. ${nvencWhy(status)}`,
+    });
+    return {
+        machine: { encode: cpu, priority: settings.renderPriority },
+        notice: nvencFallbackNotice(nvencWhy(status)),
+    };
+}
+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", "Press Make the video again in the project's 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", "Press Make the video again in the project's 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/plan.js

@@ -1,3 +1,4 @@
+import { editSettings } from "../../kernel/ports/settings-places.js";
 import { chapterCuts, narrationShotFrames } from "./cuts.js";
 import { editListVersion, } from "./edit-list.js";
 import { chapterCardSeconds, endScreenSeconds } from "./edit-settings.js";
@@ -41,7 +42,7 @@ const figureGapSeconds = 1;
 export function planRender(input) {
     if (input.images.length === 0) {
         // Admission permits Video only with an image source, so an empty set is a bug upstream.
-        throw new Error("The video needs at least one image, but there are none. Check the Images section in Edit project, then Try again.");
+        throw new Error(`The video needs at least one image, but there are none. Check ${editSettings.images}, then Try again.`);
     }
     const frame = frames[input.format];
     const bed = input.body === undefined ? undefined : input.bed;

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", "Press Make the video again in the project's 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/attribution.js

@@ -1,3 +1,4 @@
+import { editSettings } from "../../kernel/ports/settings-places.js";
 import { parseScript } from "./script.js";
 // Audiobooks from an existing text: the text model hands each passage to a speaker - the
 // narrator's prose to the narrator, each quoted line to the character who says it - and
@@ -35,12 +36,12 @@ export function parseAttribution(answer, source, speakers) {
     if (expected.length > 0 && kept / expected.length < 0.9)
         return {
             ok: false,
-            reason: `The speaker split left out ${String(expected.length - kept)} of the text's ${String(expected.length)} words. The text model must hand every word to a speaker; Try again, or choose another model in Edit project → Providers.`,
+            reason: `The speaker split left out ${String(expected.length - kept)} of the text's ${String(expected.length)} words. The AI model must hand every word to a speaker; Try again, or choose another model in ${editSettings.writer}.`,
         };
     if (got.length - kept > Math.max(3, expected.length * 0.1))
         return {
             ok: false,
-            reason: `The speaker split added ${String(got.length - kept)} words that are not in the text. The text model must not write anything of its own; Try again, or choose another model in Edit project → Providers.`,
+            reason: `The speaker split added ${String(got.length - kept)} words that are not in the text. The AI model must not write anything of its own; Try again, or choose another model in ${editSettings.writer}.`,
         };
     return parsed;
 }

package/dist/slices/voices/model.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { createRows, editSettings } from "../../kernel/ports/settings-places.js";
 // Multiple voices: a run whose narration is a script of speaker turns rather than one voice
 // reading an article. Absent on a run is the Narration format, which is every project saved
 // before this existed, and nothing about such a run reads anything in this slice.
@@ -136,23 +137,23 @@ export function voicesProblems(settings) {
     if (speakers.length === 0)
         problems.push({
             field: "voices.speakers",
-            message: "Add at least one speaker under Speakers (Play → Narration, or Edit project → Providers).",
+            message: `Add at least one speaker under Speakers (${createRows.narration}, or ${editSettings.narration}).`,
         });
     if (settings.source === "attribute" && settings.format !== "audiobook")
         problems.push({
             field: "voices.source",
-            message: "Only audiobooks can hand an existing text's dialogue to speakers. Choose Write a script under Speakers (Play → Narration, or Edit project → Providers).",
+            message: `Only audiobooks can hand an existing text's dialogue to speakers. Choose Write a script under Speakers (${createRows.narration}, or ${editSettings.narration}).`,
         });
     if ((settings.format === "podcast" || settings.format === "interview") && speakers.length < 2)
         problems.push({
             field: "voices.speakers",
-            message: `A ${voiceFormatLabels[settings.format].toLowerCase()} needs at least two speakers. Add one under Speakers (Play → Narration, or Edit project → Providers).`,
+            message: `A ${voiceFormatLabels[settings.format].toLowerCase()} needs at least two speakers. Add one under Speakers (${createRows.narration}, or ${editSettings.narration}).`,
         });
     if ((settings.format === "audiobook" || settings.format === "drama") &&
         !speakers.some((speaker) => speaker.role === "narrator"))
         problems.push({
             field: "voices.speakers",
-            message: `An ${settings.format === "drama" ? "radio drama" : "audiobook"} needs a narrator. Set one speaker's role to Narrator under Speakers (Play → Narration, or Edit project → Providers).`,
+            message: `An ${settings.format === "drama" ? "radio drama" : "audiobook"} needs a narrator. Set one speaker's role to Narrator under Speakers (${createRows.narration}, or ${editSettings.narration}).`,
         });
     const names = new Set();
     const ids = new Set();
@@ -181,7 +182,7 @@ export function voicesProblems(settings) {
         if (speaker.voice.provider.trim() === "" || speaker.voice.model.trim() === "")
             problems.push({
                 field: `${field}.voice`,
-                message: `Choose a voice provider and model for ${name || "this speaker"}.`,
+                message: `Choose a voice service and model for ${name || "this speaker"}.`,
             });
         else if (speaker.voice.voice.trim() === "")
             problems.push({
@@ -198,20 +199,20 @@ export function voicesProblems(settings) {
         if (settings.book.title.trim() === "")
             problems.push({
                 field: "voices.book.title",
-                message: "Enter the book's title under Speakers (Play → Narration), or remove the book to make a project on its own.",
+                message: `Enter the book's title under Speakers (${createRows.narration}, or ${editSettings.narration}), or remove the book to make a project on its own.`,
             });
         if (!Number.isInteger(settings.book.chapter) ||
             settings.book.chapter < 1 ||
             settings.book.chapter > bookChapterMax)
             problems.push({
                 field: "voices.book.chapter",
-                message: `Enter a chapter number from 1 to ${String(bookChapterMax)} under Speakers (Play → Narration).`,
+                message: `Enter a chapter number from 1 to ${String(bookChapterMax)} under Speakers (${createRows.narration}, or ${editSettings.narration}).`,
             });
     }
     if (!turnGapSteps.includes(settings.turnGapSeconds))
         problems.push({
             field: "voices.turnGapSeconds",
-            message: "Pick a gap between turns from the list under Speakers (Play → Narration, or Edit project → Providers).",
+            message: `Pick a gap between turns from the list under Speakers (${createRows.narration}, or ${editSettings.narration}).`,
         });
     return problems;
 }

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/voices/script.js

@@ -1,3 +1,4 @@
+import { createRows, editSettings } from "../../kernel/ports/settings-places.js";
 import { voiceFormatLabels } from "./model.js";
 const heading = /^#{1,6}\s+(.+?)\s*#*\s*$/;
 const turnLine = /^\*{0,2}([^:*\n]{1,60}?)\*{0,2}\s*:\s*\*{0,2}\s*(.*)$/;
@@ -42,7 +43,7 @@ export function parseScript(markdown, speakers, keepMarkdown = false) {
             ok: false,
             reason: turn === null
                 ? `Line ${String(number)} of the script is not a turn. Start every turn with a speaker's name and a colon (${names}), one turn per paragraph.`
-                : `Line ${String(number)} of the script is spoken by "${(turn[1] ?? "").trim()}", who is not one of the speakers (${names}). Use only these names, or add the speaker under Speakers (Play → Narration, or Edit project → Providers).`,
+                : `Line ${String(number)} of the script is spoken by "${(turn[1] ?? "").trim()}", who is not one of the speakers (${names}). Use only these names, or add the speaker under Speakers (${createRows.narration}, or ${editSettings.narration}).`,
         };
     }
     const spoken = [];