@gentbajko/slopify 2.3.1 → 2.5.0

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

@@ -2,7 +2,8 @@
 // the project page builds the same URL for every image, player and download link it
 // draws, and `downloads.ts` reads the disk: importing it into the SPA would drag
 // `node:fs` and the zip encoder into the browser bundle. Nothing here touches IO.
-// An output's role is its asset name; images add their place in the slideshow, and the
+// An output's role is its asset name; images (and animated images) add their place in the
+// slideshow, and the
 // instructions add their stage, those being the two roles a project holds more than one of -
 // research and the article each store what they sent.
 export function assetOf(output) {
@@ -10,10 +11,16 @@ export function assetOf(output) {
     if ((output.role === "narration_txt" || output.role === "tts_script") &&
         output.meta.segment !== undefined)
         return `${asset}-${output.meta.segment}`;
+    // A project holds one video per short and several images per short.
+    if (output.role === "short_video" && output.meta.short !== undefined)
+        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)}`;
     if (output.role === "instructions") {
         return `${output.stageKind}-${asset}`;
     }
-    return output.role === "image" && output.meta.index !== undefined
+    return (output.role === "image" || output.role === "animated_image") &&
+        output.meta.index !== undefined
         ? `${asset}-${String(output.meta.index)}`
         : asset;
 }

package/dist/slices/storage/layout.js

@@ -5,6 +5,14 @@ export function projectDir(paths, projectId) {
 export function outputPath(paths, projectId, relativePath) {
     return contained(projectDir(paths, projectId), relativePath);
 }
+// Scheduled backups (slices/backups) land here unless the user picks another folder. It sits
+// inside the projects root because that is the one folder a Docker install shares with the
+// host, so the archives end up on the user's disk and not only in the container's volume.
+// Project folders are ULIDs, so the name never collides with one; reconcile leaves it alone.
+export const backupsFolderName = "Backups";
+export function defaultBackupsDir(paths) {
+    return contained(paths.projects, backupsFolderName);
+}
 export function stagingPath(paths, stagedFileId) {
     return contained(paths.staging, stagedFileId);
 }
@@ -60,6 +68,14 @@ export function outputFileName(role, index, extension, stageKind) {
             return "description.txt";
         case "youtube_tags":
             return "tags.txt";
+        case "shorts":
+            return "shorts.json";
+        case "short_image":
+            return `shorts/image-${String(index).padStart(3, "0")}${extension}`;
+        case "short_video":
+            return `shorts/short-${String(index).padStart(2, "0")}${extension}`;
+        case "animated_image":
+            return `animated/image-${String(index).padStart(3, "0")}${extension}`;
         case "audio_body":
             return `audio-body${extension}`;
         case "audio_export":
@@ -70,6 +86,8 @@ export function outputFileName(role, index, extension, stageKind) {
             return `audio-outro${extension}`;
         case "thumbnail":
             return `thumbnail${extension}`;
+        case "reference":
+            return `reference${extension}`;
         case "image":
             return `images/${String(index).padStart(3, "0")}${extension}`;
     }

package/dist/slices/storage/model.js

@@ -27,5 +27,14 @@ export const outputRoles = [
     "document_pdf",
     "youtube_description",
     "youtube_tags",
+    // The Shorts step: the picked clips (JSON), each clip's vertical images, and each clip.
+    "shorts",
+    "short_image",
+    "short_video",
+    // An image of the slideshow brought to life by an image-to-video model (Animate images).
+    "animated_image",
+    // The Images stage's establishing image: made or uploaded first, drawn from by the other
+    // images, never shown in the video.
+    "reference",
 ];
 export const stagedFileStates = ["copying", "staged"];

package/dist/slices/storage/portable.js

@@ -12,12 +12,13 @@ import { readFontMetadata } from "../fonts/sfnt.js";
 import { lintEntry, lintPrompt } from "../library/lint.js";
 import { entryCategories, entryModes, promptKinds } from "../library/model.js";
 import { listEntries, listPrompts } from "../library/repo.js";
+import { notificationUrlKey } from "../notifications/settings.js";
 import { projectTemplateSchema } from "../project-templates/schema.js";
 import { cliPathMaxLength } from "../settings/cli-paths.js";
 import { appearances, providerById, providerIds } from "../settings/model.js";
 import { listVoices } from "../settings/repo.js";
 import { voiceIdMax, voiceNameMax } from "../settings/voices.js";
-import { projectDir, stagingPath } from "./layout.js";
+import { defaultBackupsDir, projectDir, stagingPath } from "./layout.js";
 import { stageKinds } from "./model.js";
 import { insertStagedFile, stagedFiles } from "./repo.js";
 const record = z.record(z.string(), z.string());
@@ -326,7 +327,8 @@ const storedAppearance = z.enum(appearances);
 function portableSettings(settings) {
     const portable = {};
     for (const [key, value] of Object.entries(settings)) {
-        if (key === "tutorial.session")
+        // The Notification URL stays on this machine: an ntfy topic in it is as good as a password.
+        if (key === "tutorial.session" || key === notificationUrlKey)
             continue;
         const parsed = storedJson(value);
         if (key === "silenceGapSeconds")
@@ -862,7 +864,8 @@ function planStagedImport(deps, archive, files) {
     });
 }
 export function storageBytes(paths) {
-    const projects = directoryBytes(paths.projects);
+    // Scheduled backups default to a folder inside the projects root; they are not project files.
+    const projects = directoryBytes(paths.projects) - directoryBytes(defaultBackupsDir(paths));
     const staging = directoryBytes(paths.staging);
     return { data: directoryBytes(paths.dataDir), projects, staging };
 }

package/dist/slices/storage/reconcile.js

@@ -1,6 +1,6 @@
 import { readdirSync, rmSync, statSync, unlinkSync } from "node:fs";
 import { join, relative, sep } from "node:path";
-import { outputPath, stagingPath } from "./layout.js";
+import { backupsFolderName, outputPath, stagingPath } from "./layout.js";
 import { stagedFiles as stagedRows } from "./repo.js";
 import { stagedFileReferenced } from "./staging-refs.js";
 export function reconcileStorage(db, paths) {
@@ -33,6 +33,10 @@ export function reconcileStorage(db, paths) {
     let orphanFiles = 0;
     for (const entry of readdirSync(paths.projects, { withFileTypes: true })) {
         const path = join(paths.projects, entry.name);
+        // The scheduled backups' default folder: its archives belong to slices/backups, which
+        // prunes them by its own rules.
+        if (entry.name === backupsFolderName && entry.isDirectory())
+            continue;
         if (!entry.isDirectory()) {
             unlinkSync(path);
             orphanFiles += 1;

package/dist/slices/storage/schema.js

@@ -9,6 +9,9 @@ export const metaSchema = z.object({
     promptName: z.string().optional(),
     prompt: z.string().optional(),
     index: z.number().optional(),
+    short: z.number().optional(),
+    sentences: z.tuple([z.number(), z.number()]).optional(),
+    warnings: z.array(z.string()).optional(),
     provider: z.string().optional(),
     model: z.string().optional(),
     voice: z.string().optional(),

package/dist/slices/telemetry/model.js

@@ -37,4 +37,7 @@ export const payloadSchema = z.strictObject({
     // A written YouTube description. Its event names no stage: it is made inside the Video
     // stage, and a collector counting stage "video" as a finished video must not count it.
     descriptions: z.number().int().nonnegative().optional(),
+    // A rendered short. Like a description it names no stage: the Shorts step runs inside
+    // the Video stage, and a short is not a finished video.
+    shorts: z.number().int().nonnegative().optional(),
 });

package/dist/slices/video/cards.js

@@ -0,0 +1,72 @@
+// 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
+// in and out. Every clip a card shows in gets its own script with the times counted from the
+// 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) {
+    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.
+    const size = Math.round(Math.min(width, height) * 0.11);
+    // A wide, blurred, half-clear dark outline: a soft shadow all round that keeps the title
+    // readable on a bright picture without a box behind it.
+    const outline = Math.max(2, Math.round(size / 10));
+    const header = [
+        "[Script Info]",
+        "ScriptType: v4.00+",
+        `PlayResX: ${String(width)}`,
+        `PlayResY: ${String(height)}`,
+        "WrapStyle: 0",
+        "ScaledBorderAndShadow: yes",
+        "",
+        "[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`,
+        "",
+        "[Events]",
+        "Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text",
+    ];
+    const events = cards.flatMap((card) => {
+        const from = card.startFrame - offset;
+        const to = from + card.frames;
+        if (to <= 0)
+            return [];
+        // A card that began before this clip starts with the clip, part way through its fade in
+        // (or past it), so it runs on from the clip before without a second fade.
+        const before = Math.max(0, (-from / fps) * 1000);
+        const length = Math.round((to / fps) * 1000);
+        const fade = before === 0
+            ? `\\fad(${String(fadeMs)},${String(fadeMs)})`
+            : `\\fade(${String(Math.round(255 * Math.max(0, 1 - before / fadeMs)))},0,255,0,${String(Math.max(0, Math.round(fadeMs - before)))},${String(length - fadeMs)},${String(length)})`;
+        return [
+            `Dialogue: 0,${assTime(Math.max(0, from) / fps)},${assTime(to / fps)},Card,,0,0,0,,{\\blur${String(outline)}${fade}${settle(before)}}${assText(card.title)}`,
+        ];
+    });
+    return `${[...header, ...events].join("\n")}\n`;
+}
+// The title settles from 96% to full size while it fades in, a small movement that reads as
+// a title arriving rather than text appearing. A card carried on from the clip before is
+// already settled.
+function settle(before) {
+    if (before >= fadeMs)
+        return "";
+    const from = Math.round(96 + (4 * before) / fadeMs);
+    return `\\fscx${String(from)}\\fscy${String(from)}\\t(0,${String(Math.round(fadeMs - before))},\\fscx100\\fscy100)`;
+}
+// h:mm:ss.cc, the centiseconds ASS counts in.
+function assTime(seconds) {
+    const centis = Math.max(0, Math.round(seconds * 100));
+    const h = Math.floor(centis / 360000);
+    const m = Math.floor((centis % 360000) / 6000);
+    const s = Math.floor((centis % 6000) / 100);
+    const c = centis % 100;
+    return `${String(h)}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}.${String(c).padStart(2, "0")}`;
+}
+// A title is plain text: braces would start an override block and a backslash an escape, so
+// both are replaced, and a line break is a space.
+function assText(text) {
+    return text.replace(/[{}]/g, "").replace(/\\/g, "/").replace(/\s+/g, " ").trim();
+}

package/dist/slices/video/chapters.js

@@ -0,0 +1,89 @@
+import { splitEndMatter } from "../article/split.js";
+// ceiling: a heading is looked for within 200 words either side of where its share of the
+// article puts it; past that, a rewritten narration has drifted too far to trust a match.
+const searchWords = 200;
+// The heading's first words that have to match, in order.
+const matchWords = 4;
+export function headingChapters(markdown, words) {
+    if (words.length === 0)
+        return [];
+    const headings = topHeadings(splitEndMatter(markdown).body);
+    const articleWords = tokens(splitEndMatter(markdown).body).length;
+    if (headings.length === 0 || articleWords === 0)
+        return [];
+    const spoken = words.map((word) => normalise(word.text));
+    const chapters = [];
+    let after = -1;
+    for (const heading of headings) {
+        const estimate = Math.round((heading.at / articleWords) * words.length);
+        const wanted = tokens(heading.title).slice(0, matchWords);
+        const found = findNear(spoken, wanted, estimate, after + 1);
+        const index = found ?? Math.max(after + 1, Math.min(estimate, words.length - 1));
+        const word = words[index];
+        if (word === undefined || index <= after)
+            continue;
+        chapters.push({ title: heading.title, start: word.start });
+        after = index;
+    }
+    return chapters;
+}
+// The article's chapter headings: the highest level used, except a lone title heading at the
+// very top, which names the article rather than a part of it.
+export function topHeadings(markdown) {
+    const found = [];
+    let fenced = false;
+    let before = 0;
+    for (const line of markdown.split(/\r?\n/)) {
+        if (/^\s*(```|~~~)/.test(line))
+            fenced = !fenced;
+        const matched = fenced ? null : /^\s{0,3}(#{1,6})\s+(.+?)\s*#*\s*$/.exec(line);
+        if (matched?.[1] !== undefined && matched[2] !== undefined) {
+            const title = plainHeading(matched[2]);
+            if (title !== "")
+                found.push({ level: matched[1].length, title, at: before });
+        }
+        before += tokens(line).length;
+    }
+    if (found.length === 0)
+        return [];
+    const top = Math.min(...found.map((heading) => heading.level));
+    const atTop = found.filter((heading) => heading.level === top);
+    const first = found[0];
+    if (atTop.length === 1 && first !== undefined && first.level === top && found.length > 1) {
+        const rest = found.slice(1);
+        const next = Math.min(...rest.map((heading) => heading.level));
+        return rest.filter((heading) => heading.level === next);
+    }
+    return atTop;
+}
+function plainHeading(text) {
+    return text
+        .replace(/!?\[([^\]]*)\]\([^)]*\)/g, "$1")
+        .replace(/[*_`~]/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function tokens(text) {
+    return text
+        .split(/\s+/)
+        .map(normalise)
+        .filter((token) => token !== "");
+}
+function normalise(word) {
+    return word.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "");
+}
+// The start of the run of `wanted` in `spoken` nearest to `estimate`, at or after `from`.
+function findNear(spoken, wanted, estimate, from) {
+    if (wanted.length === 0)
+        return undefined;
+    const low = Math.max(from, estimate - searchWords);
+    const high = Math.min(spoken.length - wanted.length, estimate + searchWords);
+    let best;
+    for (let at = low; at <= high; at += 1) {
+        if (!wanted.every((token, offset) => spoken[at + offset] === token))
+            continue;
+        if (best === undefined || Math.abs(at - estimate) < Math.abs(best - estimate))
+            best = at;
+    }
+    return best;
+}

package/dist/slices/video/cuts.js

@@ -0,0 +1,141 @@
+import { transcriptSentences } from "../youtube/transcript.js";
+import { cutFloorShare } from "./edit-settings.js";
+// "Follow the narration": every cut lands in the pause after a sentence, as near to Seconds
+// per image as the sentences allow, and a chapter always starts on a new shot. Pure, so the
+// same timing plans the same cuts every time and a re-render is identical.
+//
+// The images carry no link to a passage of the article: each one is rendered from an image
+// prompt template filled with the run's keyword values, never from a paragraph. So they are
+// spread over the narration in slideshow order, taking turns as they do with Every N
+// seconds; only where the cuts fall changes.
+// A cut sits in the pause between two sentences: halfway through it, but never more than this
+// long after the last word, so a long breath does not hold the old picture over the new
+// sentence's first word.
+const pauseCutSeconds = 0.25;
+// A chapter start is moved onto the nearest sentence pause within this many seconds; a
+// chapter the model or a heading places mid-sentence would otherwise cut mid-word.
+const chapterSnapSeconds = 3;
+// Where the narration pauses between sentences, in seconds into the video. The word times
+// already count the silence at the start, the intro and the gaps (`runtime-subtitles.ts`).
+export function sentenceCutPoints(words) {
+    const sentences = transcriptSentences(words);
+    const points = [];
+    for (const [index, sentence] of sentences.entries()) {
+        const next = sentences[index + 1];
+        if (next === undefined)
+            break;
+        const pause = Math.max(0, next.start - sentence.end);
+        points.push(sentence.end + Math.min(pause / 2, pauseCutSeconds));
+    }
+    return points;
+}
+// The frames of each shot, in timeline order, adding up to `totalFrames`. Between two
+// chapter starts the shots are laid greedily: each next cut is the sentence pause nearest to
+// Seconds per image after the last one, no nearer than the floor (40% of it) and no further
+// than twice it; with no pause in that window the cut falls at Seconds per image, as it does
+// with Every N seconds. What is left before a chapter start that could not hold a full shot
+// and a floor-length one after it becomes the last shot, so no shot runs past 1.4 times
+// Seconds per image unless the sentences leave no pause.
+export function narrationShotFrames(input) {
+    const total = input.totalFrames / input.fps;
+    if (!(total > 0) || !(input.imageSeconds > 0))
+        return [Math.max(1, input.totalFrames)];
+    const floor = input.imageSeconds * (input.floorShare ?? cutFloorShare);
+    const points = [...input.cutPoints]
+        .filter((point) => Number.isFinite(point) && point > 0 && point < total)
+        .toSorted((left, right) => left - right);
+    // A chapter that opens with the narration's first words would cut the silence before them
+    // into a shot of its own; the first shot opens that chapter anyway.
+    const bounds = chapterCuts(input.chapterStarts, points, total).filter((cut) => cut >= floor);
+    const cuts = [];
+    let start = 0;
+    for (const end of [...bounds, total]) {
+        let position = start;
+        while (end - position > input.imageSeconds + floor) {
+            const target = position + input.imageSeconds;
+            const low = position + floor;
+            const high = Math.min(position + 2 * input.imageSeconds, end - floor);
+            const cut = nearest(points.filter((point) => point >= low && point <= high), target);
+            position = cut ?? target;
+            cuts.push(position);
+        }
+        if (end < total)
+            cuts.push(end);
+        start = end;
+    }
+    return framesBetween(cuts, input.totalFrames, input.fps);
+}
+// The chapter starts as cuts: inside the video, each moved to the nearest pause within 3 s,
+// and at least one frame from the start, the end and each other.
+export function chapterCuts(starts, points, total) {
+    const snapped = starts
+        .filter((start) => Number.isFinite(start))
+        .map((start) => {
+        const near = nearest(points.filter((point) => Math.abs(point - start) <= chapterSnapSeconds), start);
+        return near ?? start;
+    })
+        .filter((start) => start > 0 && start < total)
+        .toSorted((left, right) => left - right);
+    return snapped.filter((start, index) => index === 0 || start > (snapped[index - 1] ?? 0));
+}
+function nearest(values, target) {
+    let best;
+    for (const value of values)
+        if (best === undefined || Math.abs(value - target) < Math.abs(best - target))
+            best = value;
+    return best;
+}
+// Cut times to whole frames. Two cuts that round to the same frame are one cut, so every shot
+// is at least one frame, and the last shot runs to the end.
+function framesBetween(cuts, totalFrames, fps) {
+    const marks = [];
+    for (const cut of cuts) {
+        const frame = Math.round(cut * fps);
+        if (frame > (marks.at(-1) ?? 0) && frame < totalFrames)
+            marks.push(frame);
+    }
+    const shots = [];
+    let from = 0;
+    for (const mark of [...marks, totalFrames]) {
+        shots.push(mark - from);
+        from = mark;
+    }
+    return shots.filter((frames) => frames > 0);
+}
+// The shots (0-based) the video and each chapter open on, as the render will cut them: what
+// "Chapter openers" animates. The cuts before a chapter do not depend on how long the video
+// runs after it, so the timeline is taken to end just past the last chapter.
+export function chapterOpeningShots(input) {
+    const { fps, imageSeconds } = input;
+    const last = Math.max(0, ...input.chapterStarts.filter((start) => Number.isFinite(start)));
+    const totalFrames = Math.round((last + 1) * fps);
+    if (!input.narration) {
+        // Every N seconds does not move a chapter: the image on screen when it starts opens it.
+        const each = Math.max(1, Math.round(imageSeconds * fps));
+        return [
+            ...new Set([
+                0,
+                ...input.chapterStarts
+                    .filter((start) => Number.isFinite(start) && start > 0)
+                    .map((start) => Math.floor(Math.round(start * fps) / each)),
+            ]),
+        ];
+    }
+    const starts = chapterStartFrames(input.chapterStarts, input.cutPoints, totalFrames, fps);
+    const shots = narrationShotFrames({ ...input, totalFrames });
+    const opening = [0];
+    let frame = 0;
+    for (const [index, frames] of shots.entries()) {
+        if (starts.includes(frame) && index > 0)
+            opening.push(index);
+        frame += frames;
+    }
+    return opening;
+}
+// The frame each chapter's shot starts on, for the chapter cards and the chapter openers:
+// the same snapping the cuts use, so a card appears with its shot.
+export function chapterStartFrames(starts, points, totalFrames, fps) {
+    return chapterCuts(starts, points, totalFrames / fps)
+        .map((start) => Math.round(start * fps))
+        .filter((frame) => frame > 0 && frame < totalFrames);
+}

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

@@ -1,4 +1,5 @@
 import { z } from "zod";
+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`,
 // `slideshow.ts`) reads nothing else, so a new kind of shot or movement is a new case
@@ -6,11 +7,10 @@ import { z } from "zod";
 // It is plain JSON, recorded in render.json, and carries a version so a later Slopify can
 // tell an older list from its own.
 //
-// Extension points, none of them built yet: `Shot.source` gains a `video` kind for clips,
-// `Shot.transition` says how a shot enters from the one before, and effects (a colour
-// grade, a text card) become a list on the shot. Each is a new optional field or union
-// case, so a version-1 list stays readable; a change that alters what an existing field
-// means bumps the version instead.
+// Each extension is a new optional field or union case, so a version-1 list stays readable:
+// `Shot.source` has a `video` kind for clips, `Shot.transition` says how a shot enters from
+// the one before, and the list's `look` and `cards` are the effects every shot is rendered
+// with. A change that alters what an existing field means bumps the version instead.
 export const editListVersion = 1;
 // The same list with every file path passed through `map`: render.json records paths
 // relative to the project folder.
@@ -25,6 +25,9 @@ export function withPaths(edit, map) {
             ...shot,
             source: { ...shot.source, path: map(shot.source.path) },
         })),
+        ...(edit.cardFont === undefined
+            ? {}
+            : { cardFont: { ...edit.cardFont, path: map(edit.cardFont.path) } }),
     };
 }
 const share = z.number().min(0).max(1);
@@ -36,6 +39,26 @@ const motionSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("still") }).strict(),
 ]);
 const count = z.number().int().positive();
+const sourceSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("image"), path: z.string().min(1) }).strict(),
+    z
+        .object({ kind: z.literal("video"), path: z.string().min(1), seconds: z.number().positive() })
+        .strict(),
+]);
+const transitionSchema = z
+    .object({ kind: z.enum(["crossfade", "fadeblack", "slide", "wipe"]), frames: count })
+    .strict();
+const lookSchema = z
+    .object({
+    vignette: z.enum(lookLevels),
+    grain: z.enum(lookLevels),
+    grade: z.enum(colorGrades),
+    atmosphere: z.enum(atmospheres),
+})
+    .strict();
+const cardSchema = z
+    .object({ title: z.string().min(1), startFrame: z.number().int().nonnegative(), frames: count })
+    .strict();
 const editListSchema = z
     .object({
     version: z.literal(editListVersion),
@@ -52,12 +75,19 @@ const editListSchema = z
     shots: z
         .array(z
         .object({
-        source: z.object({ kind: z.literal("image"), path: z.string().min(1) }).strict(),
+        source: sourceSchema,
         frames: count,
         motion: motionSchema,
+        transition: transitionSchema.optional(),
     })
         .strict())
         .min(1),
+    look: lookSchema.optional(),
+    cards: z.array(cardSchema).optional(),
+    cardFont: z
+        .object({ path: z.string().min(1), name: z.string().min(1) })
+        .strict()
+        .optional(),
 })
     .strict();
 // Reads a recorded edit list back. Strict, so a list written by a newer Slopify, with a