@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/settings/models.js

@@ -2,7 +2,10 @@ import { isLocalCliProvider } from "./model.js";
 // These marketplaces host models with different input schemas. Discovery alone cannot
 // make an arbitrary endpoint compatible with our image request.
 export function allowsCustomModel(provider) {
-    return provider !== "fal" && provider !== "replicate" && provider !== "codex-image";
+    return (provider !== "fal" &&
+        provider !== "replicate" &&
+        provider !== "codex-image" &&
+        provider !== "system-voice");
 }
 const ttlMs = 5 * 60_000;
 const retryMs = 30_000;
@@ -86,6 +89,7 @@ function catalogNotice(provider) {
         gemini: "Models come from your installed Gemini CLI, not an account access check. Missing a new model? Update Gemini CLI, rerun the Docker launcher if applicable, then refresh this list.",
         "claude-code": "Models come from Claude Code. Missing a new model? Update Claude Code, rerun the Docker launcher if applicable, then refresh this list. You can also enter an exact model ID.",
         inworld: "These are Inworld’s documented TTS models. You can also enter a compatible model ID.",
+        "system-voice": "These are the speech programs found on this computer, best first. Install another (for example espeak-ng) and refresh to see it.",
         cartesia: "Cartesia has no model-list API. These are bundled compatible choices; you can enter a newer model ID.",
         fal: "These models have input formats supported by Slopify's fal adapter.",
         replicate: "These models have input formats supported by Slopify's Replicate adapter.",

package/dist/slices/settings/playback.js

@@ -1,17 +1,25 @@
 import { z } from "zod";
 import { silenceGapSecondsMax } from "../admission/rules.js";
+import { loudnessFields } from "../loudness/model.js";
 import { appearances, defaultSettings } from "./model.js";
 import { readSetting, writeSetting } from "./repo.js";
 // The `settings` table is key/value, so each setting is its own row and a value the app
 // does not understand costs only that one setting.
 const silenceGapKey = "silenceGapSeconds";
 const appearanceKey = "appearance";
+const loudnessKey = "loudness";
 const silenceGapValue = z.number().int().min(0).max(silenceGapSecondsMax);
 const appearanceValue = z.enum(appearances);
+const loudnessValue = z.object({
+    enabled: z.boolean(),
+    videoLufs: z.number(),
+    audioFilesLufs: z.number(),
+});
 export function readSettings(deps) {
     return {
         silenceGapSeconds: parsed(deps, silenceGapKey, silenceGapValue, defaultSettings.silenceGapSeconds),
         appearance: parsed(deps, appearanceKey, appearanceValue, defaultSettings.appearance),
+        loudness: parsed(deps, loudnessKey, loudnessValue, defaultSettings.loudness),
     };
 }
 export function saveSettings(deps, settings) {
@@ -25,11 +33,18 @@ export function saveSettings(deps, settings) {
     if (!appearanceValue.safeParse(settings.appearance).success) {
         fields.push({ field: "appearance", message: "Choose System, Light or Dark." });
     }
+    if (!loudnessValue.safeParse(settings.loudness).success) {
+        fields.push({ field: "loudness", message: "Choose whether new runs level the volume." });
+    }
+    else {
+        fields.push(...loudnessFields(settings.loudness));
+    }
     if (fields.length > 0) {
         return { ok: false, fields };
     }
     writeSetting(deps.db, silenceGapKey, JSON.stringify(settings.silenceGapSeconds));
     writeSetting(deps.db, appearanceKey, JSON.stringify(settings.appearance));
+    writeSetting(deps.db, loudnessKey, JSON.stringify(settings.loudness));
     return { ok: true, settings };
 }
 // A stored value is JSON, and a hand-edited database is the only way it can be anything

package/dist/slices/settings/readiness.js

@@ -1,6 +1,7 @@
+import { detectSpeechCached } from "../../kernel/ports/system-speech.js";
 import { cliPathStatus } from "./cli-paths.js";
 import { cliProbeTimeoutMs, readinessFromProbe } from "./cli-status.js";
-import { isLocalCliProvider, providers } from "./model.js";
+import { isLocalCliProvider, providers, sharedKeyOf } from "./model.js";
 import { keyedProviders } from "./repo.js";
 // Every supported provider is listed, keyed or not, found or not, so Play can grey one out with
 // a reason instead of hiding it. A keyed provider is ready when a key is stored; a CLI provider
@@ -10,6 +11,16 @@ export async function providerStatuses(deps) {
     const probes = new Map();
     return await Promise.all(providers.map(async (provider) => {
         const base = { id: provider.id, family: provider.family, displayName: provider.displayName };
+        if (provider.auth === "local") {
+            const found = await detectSpeechCached(deps.probe, deps.host ?? process);
+            const engine = found.engines[0];
+            return {
+                ...base,
+                readiness: engine === undefined
+                    ? { kind: "local", available: false, ...(found.issue ? { issue: found.issue } : {}) }
+                    : { kind: "local", available: true, engine: engine.name },
+            };
+        }
         if (provider.auth !== "cli")
             return { ...base, readiness: keyedReadiness(keyed, provider.id) };
         if (deps.hostCliStatus && isLocalCliProvider(provider.id)) {
@@ -41,5 +52,6 @@ export async function providerStatuses(deps) {
     }));
 }
 function keyedReadiness(keyed, id) {
-    return { kind: "keyed", hasKey: keyed.has(id) };
+    const shared = sharedKeyOf[id];
+    return { kind: "keyed", hasKey: keyed.has(id) || (shared !== undefined && keyed.has(shared)) };
 }

package/dist/slices/settings/repo.js

@@ -10,7 +10,9 @@ const voiceRow = z.object({
     provider: z.enum(providerIds),
     name: z.string(),
     voice_id: z.string(),
+    languages_json: z.string().nullable(),
 });
+const languagesJson = z.array(z.string());
 const settingRow = z.object({ value: z.string() });
 export function upsertKey(db, provider, key, updatedAt) {
     db.prepare("INSERT INTO provider_keys (provider,key,updated_at,credential_generation) VALUES (?,?,?,?)" +
@@ -37,11 +39,16 @@ export function hasKey(db, provider) {
     return db.prepare("SELECT 1 FROM provider_keys WHERE provider = ?").get(provider) !== undefined;
 }
 export function insertVoice(db, voice) {
-    db.prepare("INSERT INTO voices (id, provider, name, voice_id) VALUES (?, ?, ?, ?)").run(voice.id, voice.provider, voice.name, voice.voiceId);
+    db.prepare("INSERT INTO voices (id, provider, name, voice_id, languages_json) VALUES (?, ?, ?, ?, ?)").run(voice.id, voice.provider, voice.name, voice.voiceId, voice.languages === undefined ? null : JSON.stringify(voice.languages));
+}
+export function updateVoiceLanguages(db, id, languages) {
+    return (Number(db
+        .prepare("UPDATE voices SET languages_json = ? WHERE id = ?")
+        .run(languages === undefined ? null : JSON.stringify(languages), id).changes) > 0);
 }
 export function listVoices(db) {
     return db
-        .prepare("SELECT id, provider, name, voice_id FROM voices ORDER BY provider, name, voice_id")
+        .prepare("SELECT id, provider, name, voice_id, languages_json FROM voices ORDER BY provider, name, voice_id")
         .all()
         .map((row) => toVoice(voiceRow.parse(row)));
 }
@@ -57,5 +64,12 @@ export function writeSetting(db, key, value) {
         " ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
 }
 function toVoice(row) {
-    return { id: row.id, provider: row.provider, name: row.name, voiceId: row.voice_id };
+    const languages = row.languages_json === null ? undefined : languagesJson.parse(JSON.parse(row.languages_json));
+    return {
+        id: row.id,
+        provider: row.provider,
+        name: row.name,
+        voiceId: row.voice_id,
+        ...(languages === undefined ? {} : { languages }),
+    };
 }

package/dist/slices/settings/tutorial-schema.js

@@ -24,6 +24,11 @@ export const tutorialSessionSchema = z
         "play-start",
         "project",
         "download",
+        "run-cost",
+        "studio-prep",
+        "home",
+        "channels",
+        "calendar",
     ]),
     articleId: z.string().optional(),
     imageId: z.string().optional(),

package/dist/slices/settings/voices.js

@@ -1,6 +1,6 @@
 import { isUniqueConstraint } from "../../kernel/db/index.js";
 import { providerById } from "./model.js";
-import { deleteVoice, insertVoice, listVoices } from "./repo.js";
+import { deleteVoice, insertVoice, listVoices, readSetting, updateVoiceLanguages, writeSetting, } from "./repo.js";
 export const voiceNameMax = 200;
 export const voiceIdMax = 200;
 // A non-empty name and a non-empty voice ID, the ID unique within its provider, names free to
@@ -24,7 +24,16 @@ export function addVoice(deps, draft) {
     if (voiceId.length > voiceIdMax) {
         return { ok: false, reason: "voice-id-too-long" };
     }
-    const voice = { id: deps.ids.next(), provider: draft.provider, name, voiceId };
+    const languages = voiceLanguagesOf(draft.languages);
+    if (languages === null)
+        return { ok: false, reason: "unknown-language" };
+    const voice = {
+        id: deps.ids.next(),
+        provider: draft.provider,
+        name,
+        voiceId,
+        ...(languages === undefined ? {} : { languages }),
+    };
     try {
         insertVoice(deps.db, voice);
     }
@@ -39,9 +48,60 @@ export function addVoice(deps, draft) {
     }
     return { ok: true, voice };
 }
+// Lower-case primary codes, each once; an empty list is unknown. Null when one is not a
+// language code at all.
+export function voiceLanguagesOf(raw) {
+    if (raw === undefined)
+        return undefined;
+    const codes = raw.map((one) => one.trim().toLowerCase()).filter((one) => one !== "");
+    if (codes.some((one) => !/^[a-z]{2,3}$/.test(one)))
+        return null;
+    return codes.length === 0 ? undefined : [...new Set(codes)];
+}
+export function setVoiceLanguages(deps, id, raw) {
+    const languages = voiceLanguagesOf(raw);
+    if (languages === null)
+        return { ok: false, reason: "unknown-language" };
+    return updateVoiceLanguages(deps.db, id, languages)
+        ? { ok: true }
+        : { ok: false, reason: "missing" };
+}
 export function removeVoice(deps, id) {
-    return deleteVoice(deps.db, id) ? { ok: true } : { ok: false };
+    if (!deleteVoice(deps.db, id))
+        return { ok: false };
+    writeRealPersonVoices(deps.db, [...realPersonVoiceIds(deps.db)].filter((one) => one !== id));
+    return { ok: true };
 }
 export function voices(deps) {
-    return listVoices(deps.db);
+    const flagged = realPersonVoiceIds(deps.db);
+    return listVoices(deps.db).map((voice) => flagged.has(voice.id) ? { ...voice, imitatesRealPerson: true } : voice);
+}
+// Which saved voices imitate a real person: one row of the key/value `settings` table holding
+// their ids, so the flag needs no column of its own and travels with a backup.
+export const realPersonVoicesKey = "voices.realPerson";
+export function realPersonVoiceIds(db) {
+    const stored = readSetting(db, realPersonVoicesKey);
+    if (stored === undefined)
+        return new Set();
+    try {
+        const value = JSON.parse(stored);
+        return new Set(Array.isArray(value) ? value.filter((one) => typeof one === "string") : []);
+    }
+    catch {
+        return new Set();
+    }
+}
+function writeRealPersonVoices(db, ids) {
+    if (ids.length === 0)
+        db.prepare("DELETE FROM settings WHERE key = ?").run(realPersonVoicesKey);
+    else
+        writeSetting(db, realPersonVoicesKey, JSON.stringify([...new Set(ids)].sort()));
+}
+// Settings → Voices' "Imitates a real person" tick.
+export function setVoiceImitatesRealPerson(deps, id, on) {
+    if (!listVoices(deps.db).some((voice) => voice.id === id))
+        return { ok: false, reason: "missing" };
+    const others = [...realPersonVoiceIds(deps.db)].filter((one) => one !== id);
+    writeRealPersonVoices(deps.db, on ? [...others, id] : others);
+    return { ok: true };
 }

package/dist/slices/settings/whats-new.js

@@ -0,0 +1,64 @@
+import { transact } from "../../kernel/db/tx.js";
+import { machineOf } from "../telemetry/repo.js";
+import { readSetting, writeSetting } from "./repo.js";
+// "What's new" is a short tour shown once per major version, on the first launch after an
+// update. The newest major this install has been shown (or has no need to be shown) lives in
+// one settings key, so it is once per install rather than once per browser.
+export const whatsNewSeenKey = "whats-new.seen-major";
+export function majorOf(version) {
+    const match = /^(\d+)\.\d+\.\d+/.exec(version);
+    return match === null ? undefined : Number(match[1]);
+}
+// The newest major already shown; undefined when none was recorded, null when the stored
+// value is damaged.
+function seenMajor(db) {
+    const raw = readSetting(db, whatsNewSeenKey);
+    if (raw === undefined)
+        return undefined;
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch (error) {
+        if (!(error instanceof SyntaxError))
+            throw error;
+        return null;
+    }
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+// Telling an update from a fresh install: the machine row is written once, when the
+// first-run notice is dismissed, and keeps the version that was running then. A fresh 3.x
+// install either has no machine yet (the notice is still up) or one stamped 3.x, so it is not
+// shown a tour of what changed since 2.x. An install that has been running since 2.x has a
+// machine stamped 2.x. Once the tour is shown and closed, the key above takes over, so a
+// later 4.0 compares against 3 rather than against the machine's first version.
+export function readWhatsNew(db, version) {
+    const major = majorOf(version);
+    if (major === undefined)
+        return { show: false, major: null };
+    const seen = seenMajor(db);
+    // A damaged value is not a reason to show the tour on every launch.
+    if (seen === null)
+        return { show: false, major };
+    if (seen !== undefined)
+        return { show: seen < major, major };
+    const machine = machineOf(db);
+    if (machine === undefined)
+        return { show: false, major };
+    const first = majorOf(machine.appVersion);
+    return { show: first !== undefined && first < major, major };
+}
+// Closing the tour, finishing it or skipping it all record the running major. Idempotent, and
+// never lowers the value, so running an older version for a while and updating again does not
+// bring back a tour already closed.
+export function dismissWhatsNew(db, version) {
+    const major = majorOf(version);
+    if (major === undefined)
+        return { show: false, major: null };
+    transact(db, () => {
+        const seen = seenMajor(db);
+        if (seen === undefined || seen === null || seen < major)
+            writeSetting(db, whatsNewSeenKey, JSON.stringify(major));
+    });
+    return { show: false, major };
+}

package/dist/slices/shorts/captions.js

@@ -173,6 +173,15 @@ export function shortCaptionsAss(words, style) {
             continue;
         const shown = next === undefined ? last.end + holdSeconds : Math.min(last.end + holdSeconds, next.start);
         const lines = lineBreaks(group.map((word) => word.text));
+        if (style.wordByWord === false) {
+            const text = group
+                .map((one, place) => `${assText(one.text)}${lines.has(place) ? "\\N" : place < group.length - 1 ? " " : ""}`)
+                .join("");
+            const from = group[0]?.start ?? last.start;
+            if (shown > from)
+                events.push(`Dialogue: 0,${assStamp(from)},${assStamp(shown)},Short,,0,0,0,,${position}${text}\n`);
+            continue;
+        }
         for (const [index, word] of group.entries()) {
             const from = word.start;
             const to = group[index + 1]?.start ?? Math.max(shown, word.end);

package/dist/slices/shorts/pick.js

@@ -115,7 +115,7 @@ const answerSchema = z.array(z.object({
     hashtags: z.array(z.string()),
     why: z.string().optional(),
 }));
-const fix = "Retry stage, or choose another model in Edit project → Providers.";
+const fix = "Try again, or choose another model in Edit project → Providers.";
 // Timing noise: the length rules are checked to the hundredth of a second.
 const tolerance = 0.01;
 // Reads the model's answer and keeps the clips that follow the rules: in range, the right
@@ -210,8 +210,8 @@ export function checkPicks(text, sentences, limits) {
 export function noPicksMessage(problems, limits) {
     const shortVideo = limits.durationSeconds < limits.minSeconds;
     if (shortVideo)
-        return `The narration is ${String(Math.round(limits.durationSeconds))} seconds long, shorter than the ${String(limits.minSeconds)}-second minimum for a short, so there is nothing to cut. Lower the shortest length in Edit project → Shorts, then Retry stage.`;
-    return `The AI model didn't pick any clip Slopify could use as a short, twice (${problems[0] ?? "no clips were listed"}). Retry stage; if it keeps happening, widen the length range in Edit project → Shorts, or choose another model in Edit project → Providers.`;
+        return `The narration is ${String(Math.round(limits.durationSeconds))} seconds long, shorter than the ${String(limits.minSeconds)}-second minimum for a short, so there is nothing to cut. Lower the shortest length in Edit project → Shorts, then Try again.`;
+    return `The AI model didn't pick any clip Slopify could use as a short, twice (${problems[0] ?? "no clips were listed"}). Try again; if it keeps happening, widen the length range in Edit project → Shorts, or choose another model in Edit project → Providers.`;
 }
 function round(seconds) {
     return Math.round(seconds * 1000) / 1000;

package/dist/slices/shorts/prompts.js

@@ -31,7 +31,7 @@ export function imagePromptMessages(brief) {
         },
     ];
 }
-const fix = "Retry stage, or choose another model in Edit project → Providers.";
+const fix = "Try again, or choose another model in Edit project → Providers.";
 // The reason is the sentence the stage shows; the provider wrapper's `check` asks the model
 // again while attempts remain.
 export function checkImagePrompts(text, count) {

package/dist/slices/shorts/render.js

@@ -1,9 +1,9 @@
 import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { editListVersion } from "../video/edit-list.js";
+import { editListVersion, } from "../video/edit-list.js";
 import { runFfmpeg } from "../video/ffmpeg.js";
 import { motionFor } from "../video/motion.js";
-import { fps } from "../video/plan.js";
+import { figureFrames, fps } from "../video/plan.js";
 import { renderSlideshow } from "../video/slideshow.js";
 import { fasterWords, shortCaptionsAss } from "./captions.js";
 // A short is rendered in three steps. Its sound is cut out of the video's own timeline (the
@@ -46,7 +46,7 @@ export function shortAudioArgs(timeline, start, end, output, options = {}) {
         count += 1;
     }
     if (count === 0 || first === undefined)
-        throw new Error("A short's clip falls outside the narration, so it has no sound to cut. Use Pick different moments in Edit project → Shorts, then Retry stage.");
+        throw new Error("A short's clip falls outside the narration, so it has no sound to cut. Use Pick different moments in Edit project → Shorts, then Try again.");
     const joined = Array.from({ length: count }, (_value, at) => `[a${String(at)}]`).join("");
     chains.push(`${joined}concat=n=${String(count)}:v=0:a=1[joined]`);
     const speed = options.speed ?? 1;
@@ -89,9 +89,46 @@ export function shortAudioArgs(timeline, start, end, output, options = {}) {
 // moving as the video's shots move by their place.
 export function shortEditList(input) {
     if (input.images.length === 0)
-        throw new Error("A short has no images to show. Use Make this short again in Edit project → Shorts, then Retry stage.");
+        throw new Error("A short has no images to show. Use Make this short again in Edit project → Shorts, then Try again.");
     const total = Math.max(1, Math.round(input.seconds * fps));
     const each = Math.max(1, Math.round(input.imageSeconds * fps));
+    const figures = figureFrames(input.figures ?? [], total);
+    if (figures.length > 0) {
+        // The short's images take turns around the cards, in order, starting over if the cards
+        // leave room for more shots than there are images.
+        const shots = [];
+        let cursor = 0;
+        let slot = 0;
+        const stretch = (to) => {
+            for (let from = cursor; from < to; from += each) {
+                const frames = Math.min(each, to - from);
+                shots.push({
+                    source: { kind: "image", path: input.images[slot % input.images.length] ?? "" },
+                    frames,
+                    motion: motionFor(input.motionStyle, slot, input.zoomPercent),
+                });
+                slot += 1;
+            }
+            cursor = Math.max(cursor, to);
+        };
+        for (const figure of figures) {
+            stretch(figure.startFrame);
+            shots.push({
+                source: { kind: "image", path: figure.path },
+                frames: figure.frames,
+                motion: { kind: "still" },
+            });
+            cursor = figure.startFrame + figure.frames;
+        }
+        stretch(total);
+        return {
+            version: editListVersion,
+            ...shortFrame,
+            fps,
+            audio: [{ kind: "body", path: input.audioPath, seconds: input.seconds }],
+            shots,
+        };
+    }
     const images = input.images.slice(0, Math.max(1, Math.ceil(total / each)));
     const shots = images.flatMap((path, at) => {
         const frames = at < images.length - 1 ? each : total - each * (images.length - 1);
@@ -113,6 +150,7 @@ export function shortEditList(input) {
         shots,
     };
 }
+// What the master measured, when the run asked for one.
 export async function renderShort(run) {
     const speed = run.speed ?? 1;
     // The images keep their share of what is said, so at a higher speed each is on screen
@@ -134,20 +172,32 @@ export async function renderShort(run) {
         writeFileSync(join(workspace, "subtitles.ass"), shortCaptionsAss(fasterWords(run.words, speed), {
             ...shortFrame,
             fontName: run.font.assName,
+            ...(run.wordByWord === false ? { wordByWord: false } : {}),
             ...(run.title === undefined ? {} : { title: { text: run.title, seconds } }),
         }), { mode: 0o600 });
         mkdirSync(join(workspace, "fonts"), { mode: 0o700 });
         copyFileSync(run.font.path, join(workspace, "fonts", `selected${run.font.extension}`));
-        await renderSlideshow({
+        const edit = shortEditList({
+            audioPath: audio,
+            seconds,
+            images: run.images,
+            imageSeconds: run.imageSeconds / speed,
+            motionStyle: run.motionStyle,
+            zoomPercent: run.zoomPercent,
+            ...(run.figures === undefined
+                ? {}
+                : {
+                    figures: run.figures.map((figure) => ({
+                        ...figure,
+                        start: figure.start / speed,
+                        end: figure.end / speed,
+                    })),
+                }),
+        });
+        return await renderSlideshow({
             bin: run.bin,
-            edit: shortEditList({
-                audioPath: audio,
-                seconds,
-                images: run.images,
-                imageSeconds: run.imageSeconds / speed,
-                motionStyle: run.motionStyle,
-                zoomPercent: run.zoomPercent,
-            }),
+            master: run.master,
+            edit: run.frame === undefined ? edit : { ...edit, ...run.frame },
             output: run.output,
             burnSubtitles: true,
             cwd: workspace,

package/dist/slices/storage/asset-name.js

@@ -16,6 +16,9 @@ export function assetOf(output) {
         return `${asset}-${String(output.meta.short)}`;
     if (output.role === "short_image" && output.meta.short !== undefined)
         return `${asset}-${String(output.meta.short)}-${String(output.meta.index ?? 1)}`;
+    // A project can hold three thumbnails; the second and third carry their number.
+    if (output.role === "thumbnail" && output.meta.index !== undefined && output.meta.index > 1)
+        return `${asset}-${String(output.meta.index)}`;
     if (output.role === "instructions") {
         return `${output.stageKind}-${asset}`;
     }

package/dist/slices/storage/backup-export.js

@@ -3,7 +3,7 @@ import { constants, lstatSync, readdirSync } from "node:fs";
 import { open } from "node:fs/promises";
 import { join } from "node:path";
 import { transact } from "../../kernel/db/tx.js";
-import { backupFormat, backupSchemaVersion, checksumsMember, fontMember, libraryMember, manifestMember, projectFileMember, projectMember, projectTables, safeRelativePath, stagedMember, usageMember, } from "./backup-format.js";
+import { backupFormat, backupSchemaVersion, checksumsMember, fontMember, imageMember, libraryMember, manifestMember, projectFileMember, projectMember, projectTables, safeRelativePath, stagedMember, usageMember, } from "./backup-format.js";
 import { projectDir, stagingPath } from "./layout.js";
 import { exportableSettings, installedUploadedFontFiles } from "./portable.js";
 import { tarEnd, tarHeader, tarMemberBytes, tarPadding } from "./tar.js";
@@ -25,6 +25,9 @@ export function busySentence(projects) {
     const more = projects.length > 3 ? ` and ${projects.length - 3} more` : "";
     return `Slopify can't export while projects are being made (${named}${more}): their files are still being written. Wait for them to finish, or pause them on their project page, then press Export everything again.`;
 }
+function memberSize(member) {
+    return member.kind === "file" ? member.size : member.content.byteLength;
+}
 export function busyProjects(deps) {
     return deps.db
         .prepare(`SELECT p.id AS id, p.title AS title,
@@ -84,6 +87,8 @@ export function planBackup(deps) {
             path: stagingPath(deps.paths, staged.id),
             size: staged.bytes,
         });
+    for (const image of snapshot.library.images)
+        files.push({ name: imageMember(image.sha256), kind: "data", content: image.content });
     const manifest = {
         format: backupFormat,
         schemaVersion: backupSchemaVersion,
@@ -97,7 +102,7 @@ export function planBackup(deps) {
             bytes: project.part.files.reduce((sum, file) => sum + file.bytes, 0),
         })),
         files: files.length,
-        bytes: files.reduce((sum, file) => sum + (file.kind === "file" ? file.size : 0), 0),
+        bytes: files.reduce((sum, file) => sum + memberSize(file), 0),
     };
     const members = [
         json(manifestMember, manifest),
@@ -106,11 +111,7 @@ export function planBackup(deps) {
         ...snapshot.projects.map((project) => json(projectMember(project.part.id), project.part)),
         ...files,
     ];
-    const archiveBytes = members.reduce((sum, member) => sum +
-        tarMemberBytes({
-            name: member.name,
-            size: member.kind === "bytes" ? member.content.byteLength : member.size,
-        }), 0) +
+    const archiveBytes = members.reduce((sum, member) => sum + tarMemberBytes({ name: member.name, size: memberSize(member) }), 0) +
         tarMemberBytes({
             name: checksumsMember,
             size: checksumsBytes(files, () => "0".repeat(64)).byteLength,
@@ -132,11 +133,16 @@ export async function* streamBackup(plan) {
     const digests = new Map();
     const files = [];
     for (const member of plan.members) {
-        const size = member.kind === "bytes" ? member.content.byteLength : member.size;
+        const size = memberSize(member);
         yield tarHeader({ name: member.name, size });
         if (member.kind === "bytes") {
             yield member.content;
         }
+        else if (member.kind === "data") {
+            files.push(member);
+            digests.set(member.name, createHash("sha256").update(member.content).digest("hex"));
+            yield member.content;
+        }
         else {
             files.push(member);
             const hash = createHash("sha256");
@@ -255,10 +261,27 @@ function librarySnapshot(deps) {
     put("entries", rowsOf(db, "SELECT * FROM entries ORDER BY rowid"));
     put("voices", rowsOf(db, "SELECT * FROM voices ORDER BY rowid"));
     put("document_themes", rowsOf(db, "SELECT * FROM document_themes ORDER BY rowid"));
+    put("narration_aliases", rowsOf(db, "SELECT * FROM narration_aliases ORDER BY position,rowid"));
     put("project_templates", rowsOf(db, "SELECT * FROM project_templates ORDER BY rowid"));
     put("project_template_revisions", rowsOf(db, "SELECT * FROM project_template_revisions ORDER BY template_id,version"));
     put("schedules", rowsOf(db, "SELECT * FROM schedules ORDER BY rowid"));
     put("schedule_runs", rowsOf(db, "SELECT * FROM schedule_runs ORDER BY rowid"));
+    put("schedule_topics", rowsOf(db, "SELECT * FROM schedule_topics ORDER BY rowid"));
+    put("library_versions", rowsOf(db, "SELECT * FROM library_versions ORDER BY item_kind,item_id,version"));
+    put("channels", rowsOf(db, "SELECT * FROM channels ORDER BY rowid"));
+    put("cast_members", rowsOf(db, "SELECT * FROM cast_members ORDER BY rowid"));
+    put("cast_images", rowsOf(db, "SELECT * FROM cast_images ORDER BY rowid"));
+    put("episode_memories", rowsOf(db, "SELECT * FROM episode_memories ORDER BY rowid"));
+    put("channel_videos", rowsOf(db, "SELECT * FROM channel_videos ORDER BY rowid"));
+    put("standalone_usage", rowsOf(db, "SELECT * FROM standalone_usage ORDER BY rowid"));
+    // Every picture, not only the cast's: a project's config names the pictures it was started
+    // with by hash, and a Rebuild reads them from here.
+    const images = db
+        .prepare("SELECT sha256,mime,bytes FROM image_blobs ORDER BY sha256")
+        .all()
+        .flatMap((row) => row.bytes instanceof Uint8Array && row.bytes.byteLength > 0
+        ? [{ sha256: String(row.sha256), mime: String(row.mime), content: row.bytes }]
+        : []);
     // Play drafts are work the user typed and has not started yet, so they travel. A draft
     // that already became projects is not: its projects carry it. Its uploads travel with it
     // when they are complete on disk; one that is not comes back asking to be reattached,
@@ -293,7 +316,23 @@ function librarySnapshot(deps) {
         name: font.name,
         bytes: font.bytes,
     }));
-    return { part: { tables, fonts, staged } };
+    return {
+        part: {
+            tables,
+            fonts,
+            staged,
+            ...(images.length === 0
+                ? {}
+                : {
+                    images: images.map((image) => ({
+                        sha256: image.sha256,
+                        mime: image.mime,
+                        bytes: image.content.byteLength,
+                    })),
+                }),
+        },
+        images,
+    };
 }
 function fileBytes(path) {
     try {