@gentbajko/slopify 2.5.0 → 3.0.0

package/dist/slices/trash/service.js

@@ -0,0 +1,273 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { deleteVersions, recordVersion } from "../library/history.js";
+import { nameMax } from "../library/model.js";
+import { entryById, promptById } from "../library/repo.js";
+import { deleteProject, projectBusy } from "../storage/delete-project.js";
+import { trashKinds, trashMs, } from "./model.js";
+// Settings → Trash: what was deleted in the last 30 days, put back or removed for good.
+//
+// Each kind keeps its stamp where it lives: a project in `project_trash` (the projects table is
+// read positionally in many places), a prompt, entry or template in its own `deleted_at`, and a
+// schedule in the `deleted_at` it always had as the tombstone that keeps its run history. A
+// schedule leaves the trash by getting `purged_at`; its row and history stay, as before.
+const dayMs = 24 * 60 * 60_000;
+// A template's name column allows this much (0008's CHECK on project_template_revisions).
+const templateNameMax = 200;
+const row = z.object({
+    id: z.string(),
+    name: z.string(),
+    detail: z.string().nullable(),
+    deleted_at: z.string(),
+});
+// Every kind in one statement, newest deletion first.
+const trashedRows = `
+  SELECT 'project' AS kind, p.id, p.title AS name, NULL AS detail, t.deleted_at
+    FROM project_trash t JOIN projects p ON p.id = t.project_id
+  UNION ALL SELECT 'prompt', id, name, kind, deleted_at FROM prompts WHERE deleted_at IS NOT NULL
+  UNION ALL SELECT 'entry', id, name, category, deleted_at FROM entries WHERE deleted_at IS NOT NULL
+  UNION ALL SELECT 'template', t.id, r.name, NULL, t.deleted_at
+    FROM project_templates t
+    JOIN project_template_revisions r ON r.template_id = t.id AND r.version = t.head_version
+    WHERE t.deleted_at IS NOT NULL
+  UNION ALL SELECT 'schedule', id, name, NULL, deleted_at FROM schedules
+    WHERE deleted_at IS NOT NULL AND purged_at IS NULL`;
+export function listTrash(deps) {
+    const now = deps.clock.now().valueOf();
+    return deps.db
+        .prepare(`SELECT * FROM (${trashedRows}) ORDER BY deleted_at DESC, kind, id`)
+        .all()
+        .map((raw) => {
+        const parsed = row.extend({ kind: z.enum(trashKinds) }).parse(raw);
+        const purgeAt = Date.parse(parsed.deleted_at) + trashMs;
+        return {
+            kind: parsed.kind,
+            id: parsed.id,
+            name: parsed.name,
+            detail: parsed.detail,
+            deletedAt: parsed.deleted_at,
+            purgeAt: new Date(purgeAt).toISOString(),
+            daysLeft: Math.max(0, Math.ceil((purgeAt - now) / dayMs)),
+        };
+    });
+}
+// 07 Projects' Delete. Refused while the run is going, as removing it always was: the work
+// has to be stopped by the user first. A project waiting its turn (a queued batch item, a
+// checkpoint, work left over from a restart) simply stops being picked up: the runner holds a
+// project in the trash like a paused one and the batch queue moves on past it.
+export function trashProject(deps, projectId) {
+    return transact(deps.db, () => {
+        const found = deps.db
+            .prepare("SELECT (SELECT 1 FROM project_trash t WHERE t.project_id = p.id) AS trashed FROM projects p WHERE p.id = ?")
+            .get(projectId);
+        if (found === undefined || found.trashed === 1)
+            return { ok: false, reason: "not-found" };
+        if (projectBusy(deps, projectId))
+            return { ok: false, reason: "running" };
+        deps.db
+            .prepare("INSERT INTO project_trash (project_id, deleted_at) VALUES (?, ?)")
+            .run(projectId, deps.clock.now().toISOString());
+        return { ok: true, value: null };
+    });
+}
+// Puts the item back where it was. A prompt, entry or template whose name a live one has
+// taken meanwhile comes back as "Name (restored)", then "Name (restored 2)"…
+//
+// A schedule comes back paused with no next run, whatever it was when deleted (only a
+// canceled or completed one can be deleted): nothing runs until Resume is pressed on
+// Schedules, which picks the next occurrence from then. Its template must be live: one in the
+// trash is restored first, and one removed for good leaves the schedule nothing to run.
+export function restoreItem(deps, kind, id) {
+    return transact(deps.db, () => {
+        switch (kind) {
+            case "project":
+                return restoreProject(deps.db, id);
+            case "prompt":
+                return restoreLibrary(deps, "prompt", id);
+            case "entry":
+                return restoreLibrary(deps, "entry", id);
+            case "template":
+                return restoreTemplate(deps, id);
+            case "schedule":
+                return restoreSchedule(deps, id);
+        }
+    });
+}
+function restoreProject(db, id) {
+    const found = db
+        .prepare("SELECT p.title FROM project_trash t JOIN projects p ON p.id = t.project_id WHERE t.project_id = ?")
+        .get(id);
+    if (typeof found?.title !== "string")
+        return { ok: false, reason: "not-found" };
+    db.prepare("DELETE FROM project_trash WHERE project_id = ?").run(id);
+    return { ok: true, value: { kind: "project", id, name: found.title, renamedFrom: null } };
+}
+function restoreLibrary(deps, itemKind, id) {
+    const table = itemKind === "prompt" ? "prompts" : "entries";
+    const group = itemKind === "prompt" ? "kind" : "category";
+    const found = deps.db
+        .prepare(`SELECT name, ${group} AS grp FROM ${table} WHERE id = ? AND deleted_at IS NOT NULL`)
+        .get(id);
+    if (typeof found?.name !== "string" || typeof found.grp !== "string")
+        return { ok: false, reason: "not-found" };
+    const taken = deps.db.prepare(`SELECT 1 FROM ${table} WHERE ${group} = ? AND lower(name) = lower(?) AND deleted_at IS NULL`);
+    const grp = found.grp;
+    const name = freeName(found.name, nameMax, (candidate) => taken.get(grp, candidate) !== undefined);
+    const renamed = name !== found.name;
+    deps.db
+        .prepare(`UPDATE ${table} SET deleted_at = NULL, name = ?, updated_at = ${renamed ? "?" : "updated_at"} WHERE id = ?`)
+        .run(...(renamed ? [name, deps.clock.now().toISOString(), id] : [name, id]));
+    // A rename shows in History as a version of its own.
+    if (renamed) {
+        const item = itemKind === "prompt" ? promptById(deps.db, id) : entryById(deps.db, id);
+        if (item !== undefined)
+            recordVersion(deps.db, itemKind, item);
+    }
+    return {
+        ok: true,
+        value: { kind: itemKind, id, name, renamedFrom: renamed ? found.name : null },
+    };
+}
+function restoreTemplate(deps, id) {
+    const found = deps.db
+        .prepare(`SELECT r.name, r.version, r.document_json FROM project_templates t
+       JOIN project_template_revisions r ON r.template_id = t.id AND r.version = t.head_version
+       WHERE t.id = ? AND t.deleted_at IS NOT NULL`)
+        .get(id);
+    if (typeof found?.name !== "string" ||
+        typeof found.version !== "number" ||
+        typeof found.document_json !== "string")
+        return { ok: false, reason: "not-found" };
+    const taken = deps.db.prepare(`SELECT 1 FROM project_templates t
+     JOIN project_template_revisions r ON r.template_id = t.id AND r.version = t.head_version
+     WHERE t.deleted_at IS NULL AND lower(r.name) = lower(?)`);
+    const name = freeName(found.name, templateNameMax, (candidate) => taken.get(candidate) !== undefined);
+    deps.db.prepare("UPDATE project_templates SET deleted_at = NULL WHERE id = ?").run(id);
+    // A rename is a new version, as a rename in the template editor is; the versions a schedule
+    // or a draft names stay as they were.
+    if (name !== found.name) {
+        const version = found.version + 1;
+        deps.db
+            .prepare("INSERT INTO project_template_revisions(template_id,version,name,document_json,created_at) VALUES (?,?,?,?,?)")
+            .run(id, version, name, found.document_json, deps.clock.now().toISOString());
+        deps.db.prepare("UPDATE project_templates SET head_version = ? WHERE id = ?").run(version, id);
+    }
+    return {
+        ok: true,
+        value: {
+            kind: "template",
+            id,
+            name,
+            renamedFrom: name === found.name ? null : found.name,
+        },
+    };
+}
+function restoreSchedule(deps, id) {
+    const found = deps.db
+        .prepare(`SELECT s.name, s.template_id,
+        (SELECT t.deleted_at IS NOT NULL FROM project_templates t WHERE t.id = s.template_id) AS trashed
+       FROM schedules s WHERE s.id = ? AND s.deleted_at IS NOT NULL AND s.purged_at IS NULL`)
+        .get(id);
+    if (typeof found?.name !== "string")
+        return { ok: false, reason: "not-found" };
+    if (found.trashed === null)
+        return { ok: false, reason: "template-gone" };
+    if (found.trashed === 1)
+        return { ok: false, reason: "template-in-trash" };
+    const at = deps.clock.now().toISOString();
+    deps.db
+        .prepare(`UPDATE schedules SET deleted_at = NULL, status = 'paused', next_run_at = NULL,
+       version = version + 1, updated_at = ? WHERE id = ?`)
+        .run(at, id);
+    return { ok: true, value: { kind: "schedule", id, name: found.name, renamedFrom: null } };
+}
+// "Delete now": removes one item for good. A project's folder goes first, then its rows
+// (`slices/storage/delete-project.ts`); a folder that will not go leaves it in the trash.
+export function deleteNow(deps, kind, id) {
+    switch (kind) {
+        case "project": {
+            if (deps.db.prepare("SELECT 1 FROM project_trash WHERE project_id = ?").get(id) === undefined)
+                return { ok: false, reason: "not-found" };
+            const removed = deleteProject(deps, id);
+            if (removed.ok)
+                return { ok: true, value: null };
+            return {
+                ok: false,
+                reason: removed.reason === "no-project" ? "not-found" : removed.reason,
+                ...(removed.detail === undefined ? {} : { detail: removed.detail }),
+            };
+        }
+        case "prompt":
+        case "entry":
+            return transact(deps.db, () => {
+                const table = kind === "prompt" ? "prompts" : "entries";
+                const changed = deps.db
+                    .prepare(`DELETE FROM ${table} WHERE id = ? AND deleted_at IS NOT NULL`)
+                    .run(id).changes;
+                if (Number(changed) === 0)
+                    return { ok: false, reason: "not-found" };
+                deleteVersions(deps.db, kind, id);
+                return { ok: true, value: null };
+            });
+        case "template": {
+            // Revisions cascade. A schedule in the trash may still name it: that schedule can then
+            // no longer be restored (`restoreSchedule`), only removed.
+            const changed = deps.db
+                .prepare("DELETE FROM project_templates WHERE id = ? AND deleted_at IS NOT NULL")
+                .run(id).changes;
+            return Number(changed) === 0 ? { ok: false, reason: "not-found" } : { ok: true, value: null };
+        }
+        case "schedule": {
+            // Gone from the trash; the row stays as the history Schedules lists under Deleted.
+            const changed = deps.db
+                .prepare("UPDATE schedules SET purged_at = ? WHERE id = ? AND deleted_at IS NOT NULL AND purged_at IS NULL")
+                .run(deps.clock.now().toISOString(), id).changes;
+            return Number(changed) === 0 ? { ok: false, reason: "not-found" } : { ok: true, value: null };
+        }
+    }
+}
+// The daily purge: everything deleted more than 30 days ago goes for good. A failure on one
+// item is logged and leaves it for the next pass; the rest still go.
+export function purgeExpired(deps) {
+    const cutoff = new Date(deps.clock.now().valueOf() - trashMs).toISOString();
+    let removed = 0;
+    let kept = 0;
+    for (const item of listTrash(deps)) {
+        if (item.deletedAt > cutoff)
+            continue;
+        const result = deleteNow(deps, item.kind, item.id);
+        if (result.ok)
+            removed++;
+        else {
+            kept++;
+            deps.log.write("warn", "trash.purge", {
+                ...(item.kind === "project" ? { projectId: item.id } : {}),
+                detail: `${item.kind} ${item.id}: ${result.detail ?? result.reason}`,
+            });
+        }
+    }
+    return { removed, kept };
+}
+export function createTrashPurge(deps) {
+    let last;
+    return {
+        tick: () => {
+            const now = deps.clock.now().valueOf();
+            if (last !== undefined && now - last < dayMs)
+                return undefined;
+            last = now;
+            return purgeExpired(deps);
+        },
+    };
+}
+// The name itself when free, else "Name (restored)", "Name (restored 2)"… cut to fit `max`.
+export function freeName(name, max, taken) {
+    if (!taken(name))
+        return name;
+    for (let n = 1;; n++) {
+        const suffix = n === 1 ? " (restored)" : ` (restored ${String(n)})`;
+        const candidate = `${name.slice(0, Math.max(1, max - suffix.length)).trimEnd()}${suffix}`;
+        if (!taken(candidate))
+            return candidate;
+    }
+}

package/dist/slices/uploads/repo.js

@@ -0,0 +1,20 @@
+export function markUploaded(db, projectId, uploaded, at) {
+    if (db.prepare("SELECT 1 FROM projects WHERE id=?").get(projectId) === undefined)
+        return { ok: false, reason: "not-found" };
+    if (!uploaded) {
+        db.prepare("DELETE FROM project_uploads WHERE project_id=?").run(projectId);
+        return { ok: true, uploadedAt: null };
+    }
+    // Marking twice keeps the first time: it is when the video went up.
+    db.prepare("INSERT INTO project_uploads(project_id,uploaded_at) VALUES (?,?) ON CONFLICT(project_id) DO NOTHING").run(projectId, at);
+    const row = db
+        .prepare("SELECT uploaded_at FROM project_uploads WHERE project_id=?")
+        .get(projectId);
+    return { ok: true, uploadedAt: typeof row?.uploaded_at === "string" ? row.uploaded_at : at };
+}
+export function uploadedProjects(db) {
+    return new Map(db
+        .prepare("SELECT project_id, uploaded_at FROM project_uploads")
+        .all()
+        .map((row) => [String(row.project_id), String(row.uploaded_at)]));
+}

package/dist/slices/video/ambient-bed-schema.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { ambientBedSources, builtInBeds } from "./ambient-bed.js";
+// The ambient bed as a run's config and a channel's brand kit hold it. The ranges are
+// `ambient-bed.ts`'s, checked by admission and the channel page, not the schema's.
+const numbers = {
+    levelDb: z.number(),
+    fadeInSeconds: z.number(),
+    tailSeconds: z.number(),
+};
+export const ambientBedSchema = z
+    .object({ source: z.enum(ambientBedSources), ...numbers })
+    .strict();
+export const channelAmbientBedSchema = z
+    .object({ source: z.enum(builtInBeds), ...numbers })
+    .strict();

package/dist/slices/video/ambient-bed.js

@@ -0,0 +1,95 @@
+// An ambient sound bed under the long video: rain, fire or wind that ffmpeg makes itself from
+// noise (no downloads, no bundled recordings), or the user's own audio file. It plays under the
+// whole narration, ducked whenever the voice speaks, fades in at the start, and keeps playing
+// for a fade-out tail after the narration ends, which lengthens the video when the tail is
+// longer than the silence already there (`plan.ts`). Only the long video gets it: the shorts
+// have their own background music, and the audio-only WAV export stays the narration alone.
+// Browser-safe: Play, the channel page and the review summary read these names and limits too.
+//
+// A run without one has no `ambientBed` at all, and the render recipe leaves it out of the
+// fingerprint then, so no video made before it existed turns outdated.
+export const builtInBeds = ["rain", "fire", "wind"];
+export const ambientBedSources = [...builtInBeds, "upload"];
+export const ambientBedLabels = {
+    rain: "Rain",
+    fire: "Fireplace",
+    wind: "Wind",
+    upload: "My own file",
+};
+// ceiling: below -40 dB the bed is inaudible under a voice; above -6 dB it competes with it.
+export const ambientLevelMin = -40;
+export const ambientLevelMax = -6;
+export const ambientFadeMax = 30;
+export const ambientTailMax = 30;
+export const defaultAmbientBed = {
+    levelDb: -18,
+    fadeInSeconds: 3,
+    tailSeconds: 6,
+};
+// Whether the run's long video gets the bed: it is set, the video renders and there is a
+// narration to lie under. A short-only run (`admission/short-mode.ts`) renders through the
+// Shorts renderer and has no bed.
+export function usesAmbientBed(config) {
+    return (config.ambientBed !== undefined &&
+        config.mode !== "short" &&
+        config.sources.video === "generate" &&
+        config.sources.audio !== "off");
+}
+// The words a problem with one of the settings is said in; shared by admission, Play's draft
+// conversion and the channel page.
+export function ambientBedProblems(bed) {
+    const problems = [];
+    if (!ambientBedSources.includes(bed.source))
+        problems.push({
+            field: "source",
+            message: "Choose Rain, Fireplace, Wind or My own file for the ambient sound.",
+        });
+    if (!(Number.isInteger(bed.levelDb) &&
+        bed.levelDb >= ambientLevelMin &&
+        bed.levelDb <= ambientLevelMax))
+        problems.push({
+            field: "level",
+            message: `Enter an ambient sound level between ${String(ambientLevelMin)} and ${String(ambientLevelMax)} dB, in whole dB.`,
+        });
+    if (!halfSteps(bed.fadeInSeconds, ambientFadeMax))
+        problems.push({
+            field: "fadeIn",
+            message: `Enter a fade-in between 0 and ${String(ambientFadeMax)} seconds, in steps of 0.5.`,
+        });
+    if (!halfSteps(bed.tailSeconds, ambientTailMax))
+        problems.push({
+            field: "tail",
+            message: `Enter a tail between 0 and ${String(ambientTailMax)} seconds, in steps of 0.5.`,
+        });
+    return problems;
+}
+function halfSteps(value, max) {
+    return Number.isInteger(value * 2) && value >= 0 && value <= max;
+}
+// How much longer the video runs with the bed: the tail plays over the silence already after
+// the narration (`edgeSilenceSeconds`) and only the rest is added.
+export function ambientTailExtension(config, edgeSilenceSeconds) {
+    if (!usesAmbientBed(config) || config.ambientBed === undefined)
+        return 0;
+    return Math.max(0, config.ambientBed.tailSeconds - edgeSilenceSeconds);
+}
+export function ambientBedFormOf(bed) {
+    return {
+        source: bed.source,
+        level: String(bed.levelDb),
+        fadeIn: String(bed.fadeInSeconds),
+        tail: String(bed.tailSeconds),
+    };
+}
+// The settings a form asks for, numbers as typed (NaN for a blank one), or undefined for none.
+export function ambientBedOfForm(form) {
+    if (form === undefined || form.source === "none")
+        return undefined;
+    const number = (raw) => (raw.trim() === "" ? Number.NaN : Number(raw));
+    return {
+        source: form.source,
+        levelDb: number(form.level),
+        fadeInSeconds: number(form.fadeIn),
+        tailSeconds: number(form.tail),
+    };
+}

package/dist/slices/video/ambient-mix.js

@@ -0,0 +1,72 @@
+// How the join mixes the ambient bed under the narration (`ffmpeg.ts`). Every value goes into
+// an argument array, never a shell string.
+//
+// The built-in beds are shaped noise, made by ffmpeg's own anoisesrc with a fixed seed, so the
+// same settings always render the same sound and nothing is downloaded or shipped:
+// - rain: pink noise with the rumble and the fizz filtered off, a steady patter;
+// - wind: brown noise kept low, swelling and dropping in slow gusts;
+// - fire: a low brown-noise roar that flickers, with sparse velvet-noise crackle over it.
+// Each is levelled to about -20 dBFS RMS before the bed's own level, so 0 dB is roughly as loud
+// as a narration and the three sit alike at the same setting.
+//
+// The ducking is a sidechain compressor keyed by the narration itself, the Shorts' music does
+// the same (`shorts/render.ts`): it follows the voice as it is, needs no word timing (which a
+// run without captions, chapters or shorts never makes), and dips under an intro or outro too.
+// ceiling: it dips once the voice passes about -34 dBFS, by up to 8:1, over 40 ms, and comes
+// back over 900 ms after the voice stops: slower than the shorts' music, so a bed under a long
+// narration settles rather than swelling in every pause between sentences.
+const duck = "threshold=0.02:ratio=8:attack=40:release=900:makeup=1";
+const presets = {
+    rain: [{ source: "anoisesrc=c=pink:a=1:seed=17", filters: "highpass=f=600,lowpass=f=9000" }],
+    wind: [
+        {
+            source: "anoisesrc=c=brown:a=1:seed=29",
+            filters: "highpass=f=60,lowpass=f=500,tremolo=f=0.15:d=0.6,volume=-1dB",
+        },
+    ],
+    fire: [
+        {
+            source: "anoisesrc=c=brown:a=1:seed=41",
+            filters: "highpass=f=80,lowpass=f=800,tremolo=f=6:d=0.25,volume=-3dB",
+        },
+        {
+            source: "anoisesrc=c=velvet:a=1:seed=43",
+            filters: "highpass=f=1500,lowpass=f=6000,volume=-22dB",
+        },
+    ],
+};
+// The inputs the bed adds after the join's own, for `seconds` of video.
+export function bedInputs(bed, seconds, sampleRate) {
+    if (bed.source.kind === "file")
+        // Looped endlessly and cut to the video, so a file shorter than the video plays again.
+        return ["-stream_loop", "-1", "-i", bed.source.path];
+    return presets[bed.source.preset].flatMap((layer) => [
+        "-f",
+        "lavfi",
+        "-t",
+        seconds.toFixed(6),
+        "-i",
+        `${layer.source}:r=${String(sampleRate)}`,
+    ]);
+}
+// The chains that turn the join's narration `voice` into `out` with the bed under it; `first`
+// is the index of the bed's first input.
+export function bedChains(bed, first, seconds, format, voice, out) {
+    const chains = [];
+    const layers = bed.source.kind === "file" ? [{ filters: "" }] : presets[bed.source.preset];
+    layers.forEach((layer, at) => {
+        chains.push(`[${String(first + at)}:a]${layer.filters === "" ? "" : `${layer.filters},`}${format},atrim=end=${seconds.toFixed(6)},asetpts=PTS-STARTPTS[bed${String(at)}]`);
+    });
+    const joined = layers.length === 1
+        ? "[bed0]anull"
+        : `${layers.map((_layer, at) => `[bed${String(at)}]`).join("")}amix=inputs=${String(layers.length)}:duration=first:normalize=0`;
+    const fadeIn = bed.fadeInSeconds > 0 ? `,afade=t=in:st=0:d=${bed.fadeInSeconds.toFixed(3)}` : "";
+    // A tail of 0 still fades, over a moment, rather than cutting off mid-sound.
+    const fadeOut = `,afade=t=out:st=${bed.fadeOutAt.toFixed(6)}:d=${Math.max(0.25, bed.fadeOutSeconds).toFixed(3)}`;
+    chains.push(`${joined},volume=${String(bed.levelDb)}dB${fadeIn}${fadeOut}[bed]`);
+    chains.push(`${voice}asplit=2[voice][key]`);
+    chains.push(`[bed][key]sidechaincompress=${duck}[ducked]`);
+    // The narration keeps its level; `normalize=0` stops amix halving both.
+    chains.push(`[voice][ducked]amix=inputs=2:duration=first:dropout_transition=0:normalize=0${out}`);
+    return chains;
+}

package/dist/slices/video/audio-inputs.js

@@ -5,9 +5,9 @@ export async function audioInputs(deps, projectId, outputs, signal) {
     const dir = projectDir(deps.paths, projectId);
     const body = await audio(deps, outputs, "audio_body", dir, signal);
     if (!body)
-        throw new Error("The video has no narration audio to play. Let the Narration stage finish, then Retry stage.");
+        throw new Error("The video has no narration audio to play. Let the Narration stage finish, then Try again.");
     if (body.seconds <= 0)
-        throw new Error("The narration audio contains no sound; the file may be damaged or empty. Regenerate the narration (or upload a different audio file in Edit project → Narration), then Retry stage.");
+        throw new Error("The narration audio contains no sound; the file may be damaged or empty. Regenerate the narration (or upload a different audio file in Edit project → Narration), then Try again.");
     const intro = await audio(deps, outputs, "audio_intro", dir, signal);
     const outro = await audio(deps, outputs, "audio_outro", dir, signal);
     return { body, intro, outro };

package/dist/slices/video/cards.js

@@ -1,3 +1,4 @@
+import { assColour } from "../subtitles/captions.js";
 // Chapter cards as an ASS script the clips draw with libass, the renderer the captions use,
 // so a card is set in the subtitle font without a font-rendering filter of its own (this
 // ffmpeg has none). Each card is centred, well above where captions sit by default, and fades
@@ -5,7 +6,9 @@
 // clip's first frame (`offset`), since a clip's frames count from zero.
 // ceiling: the owner's eye. The fades take 0.4 s each of the card's 2.5 s.
 const fadeMs = 400;
-export function cardsAss(edit, cards, fontName, offset = 0) {
+export function cardsAss(edit, cards, fontName, offset = 0, 
+// #RRGGBB from the brand kit; absent is white.
+color) {
     const { width, height, fps } = edit;
     // The title is sized from the frame's short side, so a vertical video's card fits too. At
     // 8% it read as a caption rather than a chapter title; 11% and bold gives it presence.
@@ -24,7 +27,7 @@ export function cardsAss(edit, cards, fontName, offset = 0) {
         "[V4+ Styles]",
         "Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding",
         // White bold text, the soft outline, no offset shadow, centred (alignment 5), letter-spaced.
-        `Style: Card,${fontName.replace(/,/g, " ")},${String(size)},&H00FFFFFF,&H00FFFFFF,&H60000000,&H00000000,-1,0,0,0,100,100,${String(Math.round(size / 12))},0,1,${String(outline)},0,5,${String(Math.round(width * 0.1))},${String(Math.round(width * 0.1))},0,1`,
+        `Style: Card,${fontName.replace(/,/g, " ")},${String(size)},${assColour(color, "&H00FFFFFF")},${assColour(color, "&H00FFFFFF")},&H60000000,&H00000000,-1,0,0,0,100,100,${String(Math.round(size / 12))},0,1,${String(outline)},0,5,${String(Math.round(width * 0.1))},${String(Math.round(width * 0.1))},0,1`,
         "",
         "[Events]",
         "Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text",

package/dist/slices/video/edit-list.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { builtInBeds } from "./ambient-bed.js";
 import { atmospheres, colorGrades, lookLevels, } from "./edit-settings.js";
 // The edit list is the whole video as data: what plays, for how many frames, how it moves,
 // and the audio under it. Planning (`plan.ts`) writes one and the renderer (`ffmpeg.ts`,
@@ -28,6 +29,9 @@ export function withPaths(edit, map) {
         ...(edit.cardFont === undefined
             ? {}
             : { cardFont: { ...edit.cardFont, path: map(edit.cardFont.path) } }),
+        ...(edit.bed?.source.kind === "file"
+            ? { bed: { ...edit.bed, source: { kind: "file", path: map(edit.bed.source.path) } } }
+            : {}),
     };
 }
 const share = z.number().min(0).max(1);
@@ -88,6 +92,23 @@ const editListSchema = z
         .object({ path: z.string().min(1), name: z.string().min(1) })
         .strict()
         .optional(),
+    cardColor: z
+        .string()
+        .regex(/^#[0-9A-Fa-f]{6}$/)
+        .optional(),
+    bed: z
+        .object({
+        source: z.discriminatedUnion("kind", [
+            z.object({ kind: z.literal("noise"), preset: z.enum(builtInBeds) }).strict(),
+            z.object({ kind: z.literal("file"), path: z.string().min(1) }).strict(),
+        ]),
+        levelDb: z.number(),
+        fadeInSeconds: z.number().nonnegative(),
+        fadeOutAt: z.number().nonnegative(),
+        fadeOutSeconds: z.number().nonnegative(),
+    })
+        .strict()
+        .optional(),
 })
     .strict();
 // Reads a recorded edit list back. Strict, so a list written by a newer Slopify, with a
@@ -95,9 +116,9 @@ const editListSchema = z
 export function readEditList(value) {
     const version = typeof value === "object" && value !== null && "version" in value ? value.version : undefined;
     if (version !== editListVersion)
-        throw new Error(`This video's edit list is version ${String(version)}, and this Slopify reads version ${editListVersion}. Update Slopify, or use Re-run section on Video to plan it again.`);
+        throw new Error(`This video's edit list is version ${String(version)}, and this Slopify reads version ${editListVersion}. Update Slopify, or use More → Render the video again in the Video section to plan it again.`);
     const parsed = editListSchema.safeParse(value);
     if (!parsed.success)
-        throw new Error(`This video's edit list is damaged (${parsed.error.issues[0]?.path.join(".") || "the list"}: ${parsed.error.issues[0]?.message ?? "not readable"}). Use Re-run section on Video to plan it again.`);
+        throw new Error(`This video's edit list is damaged (${parsed.error.issues[0]?.path.join(".") || "the list"}: ${parsed.error.issues[0]?.message ?? "not readable"}). Use More → Render the video again in the Video section to plan it again.`);
     return parsed.data;
 }

package/dist/slices/video/edit-settings.js

@@ -1,3 +1,4 @@
+import { wordTimingUnavailable } from "../../kernel/ports/languages.js";
 // How the Video stage edits the slideshow beyond seconds per image, zoom and motion: where the
 // cuts fall, how one shot hands over to the next, the Look (vignette, grain, colour, an
 // atmosphere overlay and chapter cards), and which images come to life as short clips.
@@ -49,6 +50,8 @@ export const animatePrompt = "Subtle cinematic motion: a slow, steady camera pus
 export const cutFloorShare = 0.4;
 // How long a chapter card stays on screen, fades included.
 export const chapterCardSeconds = 2.5;
+// How long the brand kit's end screen card stays on screen at the end of the video.
+export const endScreenSeconds = 5;
 export const cutModeLabels = {
     interval: "Every N seconds",
     narration: "Follow the narration",
@@ -87,12 +90,14 @@ export const animateModeLabels = {
 export function videoEditOf(config) {
     return config.videoEdit ?? legacyVideoEdit;
 }
-// Following the narration needs narration to follow and a video to cut; otherwise the video
-// falls back to Every N seconds, which is also what its fingerprint says.
+// Following the narration needs narration to follow, a video to cut and word timing in the
+// project language (`wordTimingUnavailable`); otherwise the video falls back to Every N
+// seconds, which is also what its fingerprint says.
 export function usesNarrationCuts(config) {
     return (videoEditOf(config).cuts === "narration" &&
         config.sources.audio !== "off" &&
-        config.sources.video === "generate");
+        config.sources.video === "generate" &&
+        wordTimingUnavailable(config.language) === undefined);
 }
 // Chapter cards are placed from the narration's word timing, so they need narration too.
 export function usesChapterCards(config) {
@@ -111,6 +116,11 @@ export function usesAnimation(config) {
 // know which images open a chapter.
 export function editNeedsTiming(config) {
     return (usesNarrationCuts(config) ||
+        // "Show tables and figures on screen" places each card where its description is spoken.
+        (config.showFigures === true &&
+            config.audio?.describeFigures === true &&
+            config.sources.audio === "generate" &&
+            config.sources.video === "generate") ||
         usesChapterCards(config) ||
         (usesAnimation(config) && videoEditOf(config).animate === "chapters"));
 }