@gentbajko/slopify 2.4.0 → 3.0.0

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,12 +172,14 @@ 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({
+        return await renderSlideshow({
             bin: run.bin,
+            master: run.master,
             edit: shortEditList({
                 audioPath: audio,
                 seconds,
@@ -147,6 +187,15 @@ export async function renderShort(run) {
                 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,
+                        })),
+                    }),
             }),
             output: run.output,
             burnSubtitles: true,

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 {

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

@@ -7,7 +7,8 @@ import { fontMaxBytes } from "../fonts/model.js";
 //   data/library.json            settings, library, templates, schedules, drafts
 //   data/usage.json              the Usage screen's event log
 //   data/projects/<id>.json      one per project: every row it needs to open and keep going
-//   files/...                    the bytes: project folders, uploaded fonts, draft uploads
+//   files/...                    the bytes: project folders, uploaded fonts, draft uploads and
+//                                the pictures kept in the database (cast, end screen)
 //   checksums.json               a SHA-256 per file, written as the files streamed out
 //
 // Rows travel as the database holds them, table by table, with the schema version they fit;
@@ -24,6 +25,9 @@ export const projectMember = (id) => `data/projects/${id}.json`;
 export const projectFileMember = (id, path) => `files/projects/${id}/${path}`;
 export const fontMember = (name) => `files/fonts/${name}`;
 export const stagedMember = (id) => `files/staging/${id}`;
+// A picture from image_blobs, named by its SHA-256: the database keeps the bytes (cast
+// pictures, the end screen image), so they travel as files rather than inside a JSON row.
+export const imageMember = (sha256) => `files/images/${sha256}`;
 // Every table a project's rows live in, parents before children. The queue is left out on
 // purpose: a backup never carries a project that is waiting to run.
 export const projectTables = [
@@ -49,6 +53,15 @@ export const projectTables = [
     "review_checkpoints",
     "review_checkpoint_approvals",
     "project_recovery_requests",
+    "youtube_description_edits",
+    "project_uploads",
+    // Since 2.5.0. Left out on purpose: plan_limit_waits and plan_limit_waiters (an account's
+    // current wait, a lease of this install) and prompt_softening (a pending one-off request).
+    "review_verdicts",
+    "provider_usage",
+    "plan_limit_readings",
+    "project_channels",
+    "project_trash",
 ];
 export const libraryTables = [
     "settings",
@@ -56,14 +69,27 @@ export const libraryTables = [
     "entries",
     "voices",
     "document_themes",
+    "narration_aliases",
     "project_templates",
     "project_template_revisions",
     "schedules",
     "schedule_runs",
+    "schedule_topics",
     "staged_files",
     "play_drafts",
     "play_draft_attachments",
     "project_template_instantiations",
+    // Since 2.5.0: prompt history, channels with their cast, episode memories and existing
+    // videos. image_blobs travel as files (`imageMember`), listed in the library part's `images`.
+    "library_versions",
+    "channels",
+    "cast_members",
+    "cast_images",
+    "episode_memories",
+    "channel_videos",
+    // Since 3.0.0: what topic generation, episode summaries and cast pictures cost, which
+    // belongs to a schedule or channel rather than a project.
+    "standalone_usage",
 ];
 export const usageTables = ["telemetry_events"];
 // Ceilings a well-formed backup of a real install stays far below. They bound what a hostile
@@ -118,6 +144,15 @@ export const manifestSchema = z
     bytes: z.number().int().min(0),
 })
     .strict();
+// A picture in image_blobs is at most this large (cast uploads are capped well below it).
+export const backupMaxImageBytes = 64 * 1024 * 1024;
+export const backupImage = z
+    .object({
+    sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    mime: z.enum(["image/png", "image/jpeg"]),
+    bytes: z.number().int().min(1).max(backupMaxImageBytes),
+})
+    .strict();
 const fileEntry = z.object({ path: relativePath, bytes: z.number().int().min(0) }).strict();
 export const libraryPartSchema = z
     .object({
@@ -133,6 +168,8 @@ export const libraryPartSchema = z
     staged: z
         .array(z.object({ id: backupId, bytes: z.number().int().positive() }).strict())
         .max(10_000),
+    // Absent in backups made before channels.
+    images: z.array(backupImage).max(100_000).optional(),
 })
     .strict();
 export const usagePartSchema = z.object({ tables: tablesOf(usageTables) }).strict();