@gentbajko/slopify 0.5.0 → 0.6.1

package/dist/slices/fonts/catalog.js

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import { lstat, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { discoverSystemFonts } from "./discovery.js";
+import { readFontFile, unavailable } from "./files.js";
+import { fontSummary } from "./model.js";
+import { readFontMetadata } from "./sfnt.js";
+export const fontIdPattern = /^(?:default|(?:system|uploaded)-[a-f0-9]{64})$/;
+const uploadName = /^(uploaded-[a-f0-9]{64})\.(ttf|otf)$/;
+const bundled = fileURLToPath(new URL("../../assets/fonts/Barlow-Regular.ttf", import.meta.url));
+export async function listFonts(paths) {
+    const [defaultFont, uploaded, system] = await Promise.all([
+        bundledFont(),
+        uploadedFonts(paths),
+        discoverSystemFonts(),
+    ]);
+    return [defaultFont, ...uploaded, ...system].map(fontSummary);
+}
+export async function resolveFont(paths, id) {
+    if (!fontIdPattern.test(id))
+        throw missingFont();
+    if (id === "default")
+        return bundledFont();
+    const fonts = id.startsWith("uploaded-")
+        ? await uploadedFonts(paths, id)
+        : await discoverSystemFonts();
+    const font = fonts.find((font) => font.id === id);
+    if (font === undefined)
+        throw missingFont();
+    return font;
+}
+export function missingFont() {
+    return new Error("The selected font is no longer available. Choose another font.", {
+        cause: "font-not-found",
+    });
+}
+export function isMissingFont(error) {
+    return error instanceof Error && error.cause === "font-not-found";
+}
+async function bundledFont() {
+    const bytes = await readFontFile(bundled);
+    const face = bytes === undefined ? undefined : readFontMetadata(bytes)?.[0];
+    if (face === undefined)
+        throw new Error("Slopify's bundled Barlow font is missing or invalid. Reinstall Slopify.");
+    return {
+        id: "default",
+        name: face.name,
+        family: face.family,
+        source: "bundled",
+        path: bundled,
+        extension: ".ttf",
+        assName: face.assName,
+        faceIndex: 0,
+    };
+}
+async function uploadedFonts(paths, wanted) {
+    const root = join(paths.dataDir, "fonts");
+    let names;
+    try {
+        if (!(await lstat(root)).isDirectory())
+            return [];
+        names = wanted === undefined ? await readdir(root) : [`${wanted}.ttf`, `${wanted}.otf`];
+    }
+    catch (error) {
+        if (unavailable(error))
+            return [];
+        throw error;
+    }
+    const result = [];
+    for (const name of names.toSorted()) {
+        const id = uploadName.exec(name)?.[1];
+        if (id === undefined)
+            continue;
+        const path = join(root, name);
+        const bytes = await readFontFile(path);
+        if (bytes === undefined ||
+            `uploaded-${createHash("sha256").update(bytes).digest("hex")}` !== id)
+            continue;
+        const face = readFontMetadata(bytes)?.[0];
+        if (face === undefined || face.extension === ".ttc")
+            continue;
+        result.push({
+            id,
+            name: face.name,
+            family: face.family,
+            source: "uploaded",
+            path,
+            extension: face.extension,
+            assName: face.assName,
+            faceIndex: 0,
+        });
+    }
+    return result;
+}

package/dist/slices/fonts/discovery.js

@@ -0,0 +1,81 @@
+import { createHash } from "node:crypto";
+import { opendir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { extname, join, posix, win32 } from "node:path";
+import { readFontFile, unavailable } from "./files.js";
+import { readFontMetadata } from "./sfnt.js";
+export function systemFontDirectories(platform, env, home) {
+    if (platform === "win32")
+        return [
+            win32.join(env.WINDIR ?? "C:\\Windows", "Fonts"),
+            ...(env.LOCALAPPDATA ? [win32.join(env.LOCALAPPDATA, "Microsoft", "Windows", "Fonts")] : []),
+        ];
+    if (platform === "darwin")
+        return ["/System/Library/Fonts", "/Library/Fonts", posix.join(home, "Library/Fonts")];
+    return [
+        "/usr/share/fonts",
+        "/usr/local/share/fonts",
+        posix.join(env.XDG_DATA_HOME ?? posix.join(home, ".local/share"), "fonts"),
+        posix.join(home, ".fonts"),
+    ];
+}
+export async function discoverSystemFonts() {
+    return scanFontDirectories(systemFontDirectories(process.platform, process.env, homedir()));
+}
+// Fixed roots only, no symlink traversal. Bounds also cover nested font-manager
+// folders and damaged font files, without making the Settings request unbounded.
+export async function scanFontDirectories(roots) {
+    const pending = [...new Set(roots)].map((path) => ({ path, depth: 0 }));
+    const files = new Set();
+    let entries = 0;
+    for (let at = 0; at < pending.length && entries < 10000 && files.size < 2048; at += 1) {
+        const dir = pending[at];
+        if (dir === undefined)
+            continue;
+        try {
+            for await (const entry of await opendir(dir.path)) {
+                entries += 1;
+                const path = join(dir.path, entry.name);
+                if (entry.isDirectory() && dir.depth < 8)
+                    pending.push({ path, depth: dir.depth + 1 });
+                else if (entry.isFile() &&
+                    [".ttf", ".otf", ".ttc"].includes(extname(entry.name).toLowerCase()))
+                    files.add(path);
+                if (entries >= 10000 || files.size >= 2048)
+                    break;
+            }
+        }
+        catch (error) {
+            if (!unavailable(error))
+                throw error;
+        }
+    }
+    const fonts = [];
+    let bytesRead = 0;
+    for (const path of [...files].sort()) {
+        if (bytesRead >= 256 * 1024 * 1024)
+            break;
+        const bytes = await readFontFile(path);
+        if (bytes === undefined)
+            continue;
+        bytesRead += bytes.length;
+        for (const face of readFontMetadata(bytes) ?? []) {
+            const id = createHash("sha256")
+                .update(path)
+                .update("\0")
+                .update(String(face.index))
+                .digest("hex");
+            fonts.push({
+                id: `system-${id}`,
+                name: face.name,
+                family: face.family,
+                source: "system",
+                path,
+                extension: face.extension,
+                assName: face.assName,
+                faceIndex: face.index,
+            });
+        }
+    }
+    return fonts;
+}

package/dist/slices/fonts/files.js

@@ -0,0 +1,37 @@
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import { fontMaxBytes } from "./model.js";
+export function unavailable(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        ["ENOENT", "ENOTDIR", "EACCES", "EPERM", "ELOOP"].includes(String(error.code)));
+}
+export async function readFontFile(path) {
+    try {
+        if (!(await lstat(path)).isFile())
+            return undefined;
+        const file = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        try {
+            const stat = await file.stat();
+            if (!stat.isFile() || stat.size < 12 || stat.size > fontMaxBytes)
+                return undefined;
+            const bytes = Buffer.alloc(stat.size);
+            let offset = 0;
+            while (offset < bytes.length) {
+                const result = await file.read(bytes, offset, bytes.length - offset, offset);
+                if (result.bytesRead === 0)
+                    return undefined;
+                offset += result.bytesRead;
+            }
+            return bytes;
+        }
+        finally {
+            await file.close();
+        }
+    }
+    catch (error) {
+        if (unavailable(error))
+            return undefined;
+        throw error;
+    }
+}

package/dist/slices/fonts/index.js

@@ -0,0 +1,5 @@
+export { fontIdPattern, isMissingFont, listFonts, resolveFont } from "./catalog.js";
+export { fontMaxBytes } from "./model.js";
+export { previewFont } from "./preview.js";
+export { standaloneFont } from "./sfnt.js";
+export { uploadFont } from "./upload.js";

package/dist/slices/fonts/model.js

@@ -0,0 +1,4 @@
+export const fontMaxBytes = 32 * 1024 * 1024;
+export function fontSummary(font) {
+    return { id: font.id, name: font.name, family: font.family, source: font.source };
+}

package/dist/slices/fonts/preview.js

@@ -0,0 +1,14 @@
+import { missingFont, resolveFont } from "./catalog.js";
+import { readFontFile } from "./files.js";
+import { standaloneFont } from "./sfnt.js";
+export async function previewFont(paths, id) {
+    const font = await resolveFont(paths, id);
+    const bytes = await readFontFile(font.path);
+    const content = bytes === undefined ? undefined : standaloneFont(bytes, font.faceIndex);
+    if (content === undefined)
+        throw missingFont();
+    return {
+        content,
+        contentType: Buffer.from(content).readUInt32BE(0) === 0x4f54544f ? "font/otf" : "font/ttf",
+    };
+}

package/dist/slices/fonts/sfnt.js

@@ -0,0 +1,262 @@
+import { fontMaxBytes } from "./model.js";
+const trueType = 0x00010000;
+const openType = 0x4f54544f;
+const collection = 0x74746366;
+// Metadata only: outlines remain FreeType's responsibility. Every read and allocation
+// is bounded before using file-controlled offsets, lengths or counts.
+export function readFontMetadata(content) {
+    const bytes = Buffer.from(content.buffer, content.byteOffset, content.byteLength);
+    const faces = directories(bytes);
+    if (faces === undefined)
+        return undefined;
+    const result = [];
+    for (const [index, face] of faces.entries()) {
+        const names = fontNames(bytes, face.tables.get("name"));
+        if (names === undefined)
+            return undefined;
+        const family = names.get(1) ?? names.get(16);
+        const name = names.get(4) ?? family;
+        const cff = face.tables.has("CFF ") || face.tables.has("CFF2");
+        const assName = cff ? (names.get(6) ?? family) : (names.get(4) ?? names.get(1));
+        if (!usable(family) || !usable(name) || !usable(assName))
+            return undefined;
+        result.push({
+            family,
+            name,
+            assName,
+            index,
+            extension: bytes.readUInt32BE(0) === collection ? ".ttc" : cff ? ".otf" : ".ttf",
+        });
+    }
+    return result;
+}
+// Browsers do not consistently address individual TTC faces. Repackage just the
+// selected face, retaining its original tables and names, with fresh SFNT checksums.
+export function standaloneFont(content, index) {
+    const bytes = Buffer.from(content.buffer, content.byteOffset, content.byteLength);
+    const face = directories(bytes)?.[index];
+    if (face === undefined || readFontMetadata(content) === undefined)
+        return undefined;
+    if (bytes.readUInt32BE(0) !== collection)
+        return Buffer.from(bytes);
+    const tables = [...face.tables.entries()].filter(([tag]) => tag !== "DSIG");
+    const header = 12 + tables.length * 16;
+    const size = tables.reduce((sum, [, table]) => sum + padded(table.length), header);
+    if (size > fontMaxBytes)
+        return undefined;
+    const result = Buffer.alloc(size);
+    result.writeUInt32BE(bytes.readUInt32BE(face.offset), 0);
+    result.writeUInt16BE(tables.length, 4);
+    const power = Math.floor(Math.log2(tables.length));
+    result.writeUInt16BE(2 ** power * 16, 6);
+    result.writeUInt16BE(power, 8);
+    result.writeUInt16BE(tables.length * 16 - 2 ** power * 16, 10);
+    let offset = header;
+    let head = 0;
+    for (const [index, [tag, table]] of tables.entries()) {
+        const record = 12 + index * 16;
+        result.write(tag, record, 4, "ascii");
+        bytes.copy(result, offset, table.offset, table.offset + table.length);
+        if (tag === "head") {
+            head = offset;
+            result.writeUInt32BE(0, head + 8);
+        }
+        result.writeUInt32BE(checksum(result.subarray(offset, offset + padded(table.length))), record + 4);
+        result.writeUInt32BE(offset, record + 8);
+        result.writeUInt32BE(table.length, record + 12);
+        offset += padded(table.length);
+    }
+    result.writeUInt32BE((0xb1b0afba - checksum(result)) >>> 0, head + 8);
+    return result;
+}
+function directories(bytes) {
+    if (bytes.length < 12 || bytes.length > fontMaxBytes)
+        return undefined;
+    const offsets = [0];
+    if (bytes.readUInt32BE(0) === collection) {
+        const version = bytes.readUInt32BE(4);
+        const count = bytes.readUInt32BE(8);
+        if (![0x00010000, 0x00020000].includes(version) ||
+            count < 1 ||
+            count > 256 ||
+            12 + count * 4 > bytes.length)
+            return undefined;
+        offsets.splice(0);
+        for (let at = 0; at < count; at += 1)
+            offsets.push(bytes.readUInt32BE(12 + at * 4));
+        if (new Set(offsets).size !== offsets.length)
+            return undefined;
+    }
+    const faces = [];
+    for (const offset of offsets) {
+        if (!within(bytes, offset, 12) || ![trueType, openType].includes(bytes.readUInt32BE(offset)))
+            return undefined;
+        const count = bytes.readUInt16BE(offset + 4);
+        if (count < 1 || count > 256 || !within(bytes, offset + 12, count * 16))
+            return undefined;
+        const tables = new Map();
+        for (let at = 0; at < count; at += 1) {
+            const record = offset + 12 + at * 16;
+            const tag = bytes.toString("ascii", record, record + 4);
+            const table = {
+                offset: bytes.readUInt32BE(record + 8),
+                length: bytes.readUInt32BE(record + 12),
+            };
+            if (tables.has(tag) || table.offset % 4 !== 0 || !within(bytes, table.offset, table.length))
+                return undefined;
+            tables.set(tag, table);
+        }
+        const spans = [...tables.values()]
+            .filter((table) => table.length > 0)
+            .toSorted((a, b) => a.offset - b.offset);
+        if (spans.some((table, at) => at > 0 && (spans[at - 1]?.offset ?? 0) + (spans[at - 1]?.length ?? 0) > table.offset))
+            return undefined;
+        const cff = tables.has("CFF ") || tables.has("CFF2");
+        if ((bytes.readUInt32BE(offset) === openType) !== cff || !validTables(bytes, tables))
+            return undefined;
+        faces.push({ offset, tables });
+    }
+    return faces;
+}
+function validTables(bytes, tables) {
+    const minimum = {
+        head: 54,
+        maxp: 6,
+        cmap: 4,
+        hhea: 36,
+        hmtx: 4,
+        name: 6,
+    };
+    for (const [tag, size] of Object.entries(minimum))
+        if ((tables.get(tag)?.length ?? 0) < size)
+            return false;
+    const head = tables.get("head");
+    const maxp = tables.get("maxp");
+    const hhea = tables.get("hhea");
+    const hmtx = tables.get("hmtx");
+    if (!head || !maxp || !hhea || !hmtx)
+        return false;
+    const glyphs = bytes.readUInt16BE(maxp.offset + 4);
+    const metrics = bytes.readUInt16BE(hhea.offset + 34);
+    const units = bytes.readUInt16BE(head.offset + 18);
+    if (bytes.readUInt32BE(head.offset + 12) !== 0x5f0f3cf5 ||
+        units < 16 ||
+        units > 16384 ||
+        glyphs === 0 ||
+        metrics === 0 ||
+        metrics > glyphs ||
+        hmtx.length < metrics * 4 + (glyphs - metrics) * 2)
+        return false;
+    const cff = tables.get("CFF ") ?? tables.get("CFF2");
+    if (!validCmap(bytes, tables.get("cmap")))
+        return false;
+    if (cff)
+        return cff.length >= 4 && [1, 2].includes(bytes[cff.offset] ?? 0);
+    const glyf = tables.get("glyf");
+    const loca = tables.get("loca");
+    const format = bytes.readInt16BE(head.offset + 50);
+    if (!glyf ||
+        !loca ||
+        (format !== 0 && format !== 1) ||
+        loca.length < (glyphs + 1) * (format === 0 ? 2 : 4))
+        return false;
+    let previous = 0;
+    for (let at = 0; at <= glyphs; at += 1) {
+        const next = format === 0
+            ? bytes.readUInt16BE(loca.offset + at * 2) * 2
+            : bytes.readUInt32BE(loca.offset + at * 4);
+        if (next < previous || next > glyf.length)
+            return false;
+        previous = next;
+    }
+    return true;
+}
+function validCmap(bytes, table) {
+    if (!table || table.length < 4 || bytes.readUInt16BE(table.offset) !== 0)
+        return false;
+    const count = bytes.readUInt16BE(table.offset + 2);
+    if (count < 1 || count > 512 || table.length < 4 + count * 8)
+        return false;
+    let supported = false;
+    for (let at = 0; at < count; at += 1) {
+        const offset = bytes.readUInt32BE(table.offset + 4 + at * 8 + 4);
+        if (offset < 4 + count * 8 || offset + 4 > table.length)
+            return false;
+        const format = bytes.readUInt16BE(table.offset + offset);
+        const long = [8, 10, 12, 13].includes(format);
+        if (long && offset + 8 > table.length)
+            return false;
+        const length = format === 14
+            ? offset + 6 <= table.length
+                ? bytes.readUInt32BE(table.offset + offset + 2)
+                : 0
+            : long
+                ? bytes.readUInt32BE(table.offset + offset + 4)
+                : bytes.readUInt16BE(table.offset + offset + 2);
+        if (length < 4 || offset + length > table.length)
+            return false;
+        if ([0, 4, 6, 10, 12, 13].includes(format))
+            supported = true;
+    }
+    return supported;
+}
+function fontNames(bytes, table) {
+    if (!table || table.length < 6)
+        return undefined;
+    const format = bytes.readUInt16BE(table.offset);
+    const count = bytes.readUInt16BE(table.offset + 2);
+    const storage = bytes.readUInt16BE(table.offset + 4);
+    if (format > 1 || count > 4096 || storage < 6 + count * 12 || storage > table.length)
+        return undefined;
+    const names = new Map();
+    for (let at = 0; at < count; at += 1) {
+        const record = table.offset + 6 + at * 12;
+        const platform = bytes.readUInt16BE(record);
+        const encoding = bytes.readUInt16BE(record + 2);
+        const language = bytes.readUInt16BE(record + 4);
+        const id = bytes.readUInt16BE(record + 6);
+        const length = bytes.readUInt16BE(record + 8);
+        const offset = bytes.readUInt16BE(record + 10);
+        if (storage + offset + length > table.length)
+            return undefined;
+        if (![1, 4, 6, 16].includes(id) ||
+            (platform !== 0 && !(platform === 3 && [0, 1, 10].includes(encoding))))
+            continue;
+        if (length === 0 || length > 1024 || length % 2 !== 0)
+            return undefined;
+        const score = (platform === 3 ? 2 : 0) + (language === 0x409 ? 1 : 0);
+        if ((names.get(id)?.score ?? -1) > score)
+            continue;
+        let value;
+        try {
+            value = new TextDecoder("utf-16be", { fatal: true }).decode(bytes.subarray(table.offset + storage + offset, table.offset + storage + offset + length));
+        }
+        catch {
+            return undefined;
+        }
+        names.set(id, { value, score });
+    }
+    return new Map([...names].map(([id, entry]) => [id, entry.value]));
+}
+function usable(value) {
+    return (value !== undefined &&
+        value.length > 0 &&
+        value.length <= 256 &&
+        !value.includes(",") &&
+        ![...value].some((character) => {
+            const point = character.codePointAt(0) ?? 0;
+            return point < 0x20 || (point >= 0x7f && point <= 0x9f);
+        }));
+}
+function within(bytes, offset, length) {
+    return offset >= 0 && length >= 0 && offset <= bytes.length && length <= bytes.length - offset;
+}
+function padded(value) {
+    return Math.ceil(value / 4) * 4;
+}
+function checksum(bytes) {
+    let sum = 0;
+    for (let at = 0; at < bytes.length; at += 4)
+        sum = (sum + bytes.readUInt32BE(at)) >>> 0;
+    return sum;
+}

package/dist/slices/fonts/upload.js

@@ -0,0 +1,40 @@
+import { createHash, randomUUID } from "node:crypto";
+import { lstat, mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { extname, join } from "node:path";
+import { z } from "zod";
+import { fontMaxBytes } from "./model.js";
+import { readFontMetadata } from "./sfnt.js";
+const filename = z
+    .string()
+    .min(1)
+    .max(255)
+    .refine((value) => !value.includes("/") &&
+    !value.includes("\\") &&
+    !value.includes(":") &&
+    ![...value].some((character) => (character.codePointAt(0) ?? 0) < 32));
+export async function uploadFont(paths, input) {
+    if (!filename.safeParse(input.filename).success)
+        return { ok: false, reason: "unsafe-filename" };
+    if (![".ttf", ".otf"].includes(extname(input.filename).toLowerCase()))
+        return { ok: false, reason: "unsupported-format" };
+    if (input.content.byteLength > fontMaxBytes)
+        return { ok: false, reason: "too-large" };
+    const metadata = readFontMetadata(input.content);
+    const face = metadata?.[0];
+    if (face === undefined || metadata?.length !== 1 || face.extension === ".ttc")
+        return { ok: false, reason: "invalid-font" };
+    const id = `uploaded-${createHash("sha256").update(input.content).digest("hex")}`;
+    const root = join(paths.dataDir, "fonts");
+    await mkdir(root, { recursive: true, mode: 0o700 });
+    if (!(await lstat(root)).isDirectory())
+        throw new Error("The font storage directory is unavailable.");
+    const temporary = join(root, `.upload-${randomUUID()}`);
+    try {
+        await writeFile(temporary, input.content, { mode: 0o600, flag: "wx" });
+        await rename(temporary, join(root, `${id}${face.extension}`));
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    return { ok: true, font: { id, name: face.name, family: face.family, source: "uploaded" } };
+}

package/dist/slices/library/slots.js

@@ -2,9 +2,11 @@
 // the picked templates, the slot names they ask for, and the rendered text stored on the
 // project. The bodies are read at the click, not at selection, so an edit made in between
 // is the one that runs.
+import { normaliseDraft } from "../admission/rules.js";
 import { collectFields, render } from "../admission/substitute.js";
 import { entryByName, promptByName } from "./repo.js";
-export function pickTemplates(db, draft) {
+export function pickTemplates(db, input) {
+    const draft = normaliseDraft(input);
     const { sources } = draft;
     const missing = [];
     // Only the prompts of stages set to Generate, plus the picked

package/dist/slices/reruns/cascade.js

@@ -1,5 +1,5 @@
 import { stageKinds } from "../../kernel/pipeline.js";
-import { deps as graph } from "../../kernel/runner/graph.js";
+import { dependenciesOf } from "../../kernel/runner/graph.js";
 // The stages to redo, in pipeline order, each with how much of itself it throws away.
 export function redoPlan(input) {
     const stale = staleStages(input);
@@ -11,7 +11,7 @@ function staleStages(input) {
     const { action } = input;
     switch (action.kind) {
         case "rerun":
-            return withDependents([action.stage]);
+            return withDependents([action.stage], input);
         case "article-edit": {
             // An article edit re-runs audio, LLM-mode intro/outro text, the LLM-written
             // thumbnail and the video, leaving prompt-based images untouched. The video comes
@@ -20,14 +20,14 @@ function staleStages(input) {
             if (input.thumbnailSource === "prompt_by_llm") {
                 roots.push("thumbnail");
             }
-            return withDependents(roots);
+            return withDependents(roots, input);
         }
         case "image-deleted":
             // The image is removed from the set and the video re-renders. The remaining
             // images stand, so the images stage itself is not redone.
-            return withDependents(["video"]);
+            return input.videoSource === "off" ? new Set() : withDependents(["video"], input);
         case "image-regenerated":
-            return withDependents(["images"]);
+            return withDependents(["images"], input);
     }
 }
 // `provided` → `running` and `skipped` → `running` are forbidden, so a stage whose output
@@ -49,11 +49,15 @@ function clearsOf(action, kind) {
 }
 // The transitive closure of the dependents of `roots` over `kernel/runner/graph.ts`. The
 // graph has six nodes, so one pass per node closes it whatever the edges are.
-function withDependents(roots) {
+function withDependents(roots, input) {
     const found = new Set(roots);
     for (let pass = 0; pass < stageKinds.length; pass += 1) {
         for (const kind of stageKinds) {
-            if (graph[kind].some((dependency) => found.has(dependency))) {
+            const dependencies = dependenciesOf(kind, {
+                thumbnail: input.thumbnailSource,
+                video: input.videoSource ?? "generate",
+            });
+            if (dependencies.some((dependency) => found.has(dependency))) {
                 found.add(kind);
             }
         }

package/dist/slices/reruns/index.js

@@ -142,13 +142,19 @@ function load(deps, projectId) {
         stages,
         outputs: outputsOf(deps.db, projectId),
         thumbnailSource: project.config.sources.thumbnail,
+        videoSource: project.config.sources.video,
     };
 }
 // One transaction for every row the action touches, then the filesystem: an unlink cannot
 // be rolled back, so it waits for the commit. A file with no row is what the boot reconcile
 // collects, where a row with no file is a broken download.
 function apply(deps, projectId, action, loaded, own) {
-    const plan = redoPlan({ action, stages: loaded.stages, thumbnailSource: loaded.thumbnailSource });
+    const plan = redoPlan({
+        action,
+        stages: loaded.stages,
+        thumbnailSource: loaded.thumbnailSource,
+        videoSource: loaded.videoSource,
+    });
     // `own` is the action's own change - the new article, the image that goes - and it runs
     // first and inside the same transaction, so it lands or rolls back with the cascade it
     // triggers. The files it writes take the names they already had, replacing in place
@@ -190,6 +196,22 @@ function clearStage(deps, stage, outputs) {
     deletePieces(deps.db, stage.id);
     return files;
 }
+// Switching narrator halfway through a stage must not join two different voices.
+// The caller includes these row changes with the config update's transaction and
+// runs the returned cleanup only after commit. Finished narration is left intact.
+export function clearUnfinishedAudio(deps, projectId) {
+    const stage = stagesOf(deps.db, projectId).find((one) => one.kind === "audio");
+    if (stage === undefined ||
+        stage.state === "done" ||
+        stage.state === "provided" ||
+        stage.state === "skipped")
+        return [];
+    const orphaned = clearStage(deps, stage, outputsOf(deps.db, projectId));
+    deps.db
+        .prepare("UPDATE stages SET progress_current = NULL, progress_total = NULL WHERE id = ?")
+        .run(stage.id);
+    return [() => removeFiles(deps, projectId, orphaned)];
+}
 // A regenerated image is replaced in place at the same index, so the piece keeps the prompt
 // and the index it was planned with and only stops naming a file: `slices/images/run.ts`
 // then sees one image of its plan still to make, and the file it named can be removed.