@gentbajko/slopify 2.3.1 → 2.5.0

package/dist/slices/library/slots.js

@@ -2,7 +2,7 @@
 // the picked templates, the slot names they ask for, and the rendered text stored on the
 // project. The bodies are read at the click, not at selection, so an edit made in between
 // is the one that runs.
-import { normaliseDraft, usesNarrationPreparation, usesYoutubeDescription, } from "../admission/rules.js";
+import { normaliseDraft, usesNarrationPreparation, usesReference, usesShorts, usesYoutubeDescription, } from "../admission/rules.js";
 import { collectFields, render } from "../admission/substitute.js";
 import { snapshotEntry, snapshotPrompt } from "./snapshot.js";
 export function pickTemplates(db, input, snapshot) {
@@ -25,6 +25,15 @@ export function pickTemplates(db, input, snapshot) {
     // None picked is the built-in prompt, which asks for no keyword.
     if (usesYoutubeDescription(draft))
         body(db, "description", draft.descriptionPrompt, "descriptionPrompt", missing, text, "description", snapshot);
+    // The Shorts step's two prompts; none picked is the built-in one, which asks for no keyword.
+    if (usesShorts(draft)) {
+        body(db, "shorts", draft.shorts?.prompt, "shorts.prompt", missing, text, "shorts", snapshot);
+        body(db, "image", draft.shorts?.imagePrompt, "shorts.imagePrompt", missing, image, "shortsImage", snapshot);
+    }
+    // The establishing image's prompt: an image prompt like the others, its keywords filled the
+    // same way.
+    if (usesReference(draft) && draft.reference?.source === "prompt")
+        body(db, "image", draft.reference.prompt, "reference.prompt", missing, image, "referencePrompt", snapshot);
     if (sources.images === "generate") {
         for (const [index, picked] of draft.imagePrompts.entries()) {
             const field = `imagePrompts.${String(index)}.name`;
@@ -36,7 +45,9 @@ export function pickTemplates(db, input, snapshot) {
     if (sources.thumbnail === "from_prompt" || sources.thumbnail === "prompt_by_llm") {
         body(db, "thumbnail", draft.thumbnailPrompt, "thumbnailPrompt", missing, image, "thumbnailPrompt", snapshot);
     }
-    const fields = collectFields(text.map((picked) => picked.body), image.map((picked) => picked.body));
+    const fields = collectFields(
+    // The title's keywords are asked for like a prompt's: it is filled when the run starts.
+    [draft.title, ...text.map((picked) => picked.body)], image.map((picked) => picked.body));
     return {
         draft: withSavedModes(draft, intro, outro),
         requiredSlots: fields.map((field) => field.name),

package/dist/slices/library/snapshot.js

@@ -25,9 +25,15 @@ export const librarySnapshotSchema = z
 })
     .strict()
     .readonly();
+// A template names its prompts and intros/outros; the Library's current one of that name is
+// what a run from it uses, so editing a prompt reaches every template and schedule that names
+// it. The copy the template saved is only the fallback for one since deleted or renamed, so a
+// template never stops working because its Library changed.
 export function snapshotPrompt(db, snapshot, kind, name) {
-    return (snapshot?.prompts.find((row) => row.kind === kind && row.name.toLowerCase() === name.toLowerCase()) ?? promptByName(db, kind, name));
+    return (promptByName(db, kind, name) ??
+        snapshot?.prompts.find((row) => row.kind === kind && row.name.toLowerCase() === name.toLowerCase()));
 }
 export function snapshotEntry(db, snapshot, category, name) {
-    return (snapshot?.entries.find((row) => row.category === category && row.name.toLowerCase() === name.toLowerCase()) ?? entryByName(db, category, name));
+    return (entryByName(db, category, name) ??
+        snapshot?.entries.find((row) => row.category === category && row.name.toLowerCase() === name.toLowerCase()));
 }

package/dist/slices/notifications/notifier.js

@@ -0,0 +1,76 @@
+import { redact } from "../../kernel/log.js";
+import { noticeOf, noticeText, webhookBody } from "./rules.js";
+import { sendFailureText } from "./send.js";
+export function createRunNotifier(deps) {
+    // ceiling: one entry per project seen since boot, a few dozen bytes each.
+    const states = new Map();
+    const reasons = new Map();
+    const inflight = new Set();
+    let closed = false;
+    const notify = (projectId, kind) => {
+        const url = deps.url();
+        if (url === null)
+            return;
+        const subject = deps.subject(projectId);
+        if (subject === undefined)
+            return;
+        const text = noticeText(kind, { ...subject, reason: reasons.get(projectId) });
+        const body = redact(webhookBody(text));
+        const sending = deps
+            .send(url, body)
+            .then((result) => {
+            if (!result.ok)
+                deps.log.write("warn", "notification.failed", {
+                    projectId,
+                    detail: `${kind} notification not delivered: ${sendFailureText(result)}`,
+                });
+        })
+            .catch((error) => {
+            deps.log.write("warn", "notification.failed", {
+                projectId,
+                detail: `${kind} notification not delivered: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        })
+            .finally(() => {
+            inflight.delete(sending);
+        });
+        inflight.add(sending);
+    };
+    return {
+        observe: (event) => {
+            if (closed)
+                return;
+            try {
+                if (event.type === "stage.state") {
+                    if (event.state === "failed" && event.failureReason !== undefined)
+                        reasons.set(event.projectId, event.failureReason);
+                    else if (event.state === "running")
+                        reasons.delete(event.projectId);
+                    return;
+                }
+                if (event.type !== "project.state")
+                    return;
+                const previous = states.get(event.projectId);
+                if (previous === event.state)
+                    return;
+                states.set(event.projectId, event.state);
+                const kind = noticeOf(previous, event.state);
+                if (kind !== undefined)
+                    notify(event.projectId, kind);
+            }
+            catch (error) {
+                deps.log.write("warn", "notification.failed", {
+                    projectId: event.projectId,
+                    detail: `notification skipped: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        },
+        close: () => {
+            closed = true;
+        },
+        settled: async () => {
+            while (inflight.size > 0)
+                await Promise.all([...inflight]);
+        },
+    };
+}

package/dist/slices/notifications/rules.js

@@ -0,0 +1,81 @@
+// Only a run seen running can finish, fail or stop to wait: a project first seen already done
+// was done before anyone was watching. Paused and canceled are what the user just pressed, so
+// they say nothing. `pending` after `running` is the runner finding nothing it may start: a
+// review checkpoint holding the next step, or held work waiting for Resume.
+export function noticeOf(previous, next) {
+    if (previous !== "running")
+        return undefined;
+    switch (next) {
+        case "done":
+            return "ready";
+        case "failed":
+            return "failed";
+        case "pending":
+            return "waiting";
+        default:
+            return undefined;
+    }
+}
+const reasonMax = 140;
+// A provider's failure can run to paragraphs; a notification has a line.
+export function shortReason(reason) {
+    const line = reason
+        ?.split(/\r?\n/)
+        .map((part) => part.trim())
+        .find((part) => part !== "");
+    if (line === undefined)
+        return undefined;
+    return line.length <= reasonMax ? line : `${line.slice(0, reasonMax - 1).trimEnd()}…`;
+}
+export function noticeText(kind, subject) {
+    const title = subject.title.trim() === "" ? "Untitled project" : subject.title.trim();
+    switch (kind) {
+        case "ready":
+            return subject.makesVideo
+                ? { headline: `Video ready: ${title}`, detail: "Open the project to watch it." }
+                : { headline: `Run finished: ${title}`, detail: "Open the project to see its files." };
+        case "failed": {
+            const reason = shortReason(subject.reason);
+            return {
+                headline: reason === undefined ? `Run failed: ${title}` : `Run failed: ${title} — ${reason}`,
+                detail: "Open the project to see what stopped it and press Retry.",
+            };
+        }
+        case "waiting":
+            return {
+                headline: `Waiting for you: ${title}`,
+                detail: "Open the project to review the held step or press Resume.",
+            };
+    }
+}
+export const testNotice = {
+    headline: "Slopify test notification",
+    detail: "Notifications work. You'll get one when a run finishes, fails or waits for you.",
+};
+// The body a Notification URL receives: plain text, which ntfy shows as the message. Nothing
+// but the project's title, what happened and the provider's own short reason goes in it.
+export function webhookBody(text) {
+    return `${text.headline}\n${text.detail}\n`;
+}
+export const notificationUrlMax = 2048;
+// Empty clears the setting. Otherwise one absolute http(s) URL with no user name or password:
+// fetch refuses those, and a password in a URL would sit in the database in plain sight.
+export function notificationUrlProblem(value) {
+    const trimmed = value.trim();
+    if (trimmed === "")
+        return undefined;
+    if (trimmed.length > notificationUrlMax)
+        return `Keep the Notification URL to ${String(notificationUrlMax)} characters or fewer.`;
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        return "Enter a full address starting with https:// or http://, for example https://ntfy.sh/your-topic.";
+    }
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:")
+        return "The Notification URL must start with https:// or http://.";
+    if (parsed.username !== "" || parsed.password !== "")
+        return "Remove the user name and password from the Notification URL; Slopify can't send them.";
+    return undefined;
+}

package/dist/slices/notifications/send.js

@@ -0,0 +1,40 @@
+// One POST to the user's Notification URL. Short, single-shot and never retried: a
+// notification that did not arrive is logged, and a run never waits on one.
+export const notificationTimeoutMs = 5_000;
+export function createNotificationSender(fetchImpl, timeoutMs = notificationTimeoutMs) {
+    return async (url, body) => {
+        try {
+            const response = await fetchImpl(url, {
+                method: "POST",
+                headers: { "content-type": "text/plain; charset=utf-8" },
+                body,
+                redirect: "manual",
+                signal: AbortSignal.timeout(timeoutMs),
+            });
+            // The answer's body is never read; cancelling it frees the socket.
+            await response.body?.cancel().catch(() => { });
+            return response.ok ? { ok: true } : { ok: false, reason: "refused", status: response.status };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                reason: error instanceof DOMException &&
+                    (error.name === "TimeoutError" || error.name === "AbortError")
+                    ? "timeout"
+                    : "unreachable",
+            };
+        }
+    };
+}
+// What went wrong, in words fit for both the log and the Settings screen. The URL itself is
+// never repeated: an ntfy topic in it is as good as a password.
+export function sendFailureText(result) {
+    switch (result.reason) {
+        case "timeout":
+            return `the Notification URL didn't answer within ${String(notificationTimeoutMs / 1000)} seconds`;
+        case "unreachable":
+            return "the Notification URL couldn't be reached (wrong address, no network, or the server is down)";
+        case "refused":
+            return `the Notification URL answered HTTP ${String(result.status)}`;
+    }
+}

package/dist/slices/notifications/settings.js

@@ -0,0 +1,34 @@
+import { readSetting, writeSetting } from "../settings/repo.js";
+import { notificationUrlProblem } from "./rules.js";
+// Its own row in the key/value `settings` table. Backups leave it out
+// (`slices/storage/portable.ts`): an ntfy topic in the URL is as good as a password.
+export const notificationUrlKey = "notificationUrl";
+export function readNotificationUrl(db) {
+    const stored = readSetting(db, notificationUrlKey);
+    if (stored === undefined)
+        return null;
+    let value;
+    try {
+        value = JSON.parse(stored);
+    }
+    catch {
+        return null;
+    }
+    // A hand-edited row that no longer passes the rules is treated as not set rather than
+    // POSTed to.
+    return typeof value === "string" && value !== "" && notificationUrlProblem(value) === undefined
+        ? value
+        : null;
+}
+export function saveNotificationUrl(db, raw) {
+    const problem = notificationUrlProblem(raw);
+    if (problem !== undefined)
+        return { ok: false, message: problem };
+    const url = raw.trim();
+    if (url === "") {
+        db.prepare("DELETE FROM settings WHERE key = ?").run(notificationUrlKey);
+        return { ok: true, url: null };
+    }
+    writeSetting(db, notificationUrlKey, JSON.stringify(url));
+    return { ok: true, url };
+}

package/dist/slices/play-drafts/convert.js

@@ -2,7 +2,16 @@ import { z } from "zod";
 import { defaultEdgeSilenceSeconds, defaultImageSeconds, defaultZoomPercent, edgeSilenceSecondsProblem, imageSecondsProblem, numberPerPromptMax, zoomPercentProblem, } from "../admission/rules.js";
 import { runDraftSchema } from "../admission/schema.js";
 import { draftDocumentThemeOf } from "../document/model.js";
+import { defaultShorts, shortsExtrasOf, shortsSettingsProblems, } from "../shorts/model.js";
 import { defaultSubtitles } from "../subtitles/model.js";
+// Said where the control is, since the music sits in a closed disclosure on the Export rail.
+const musicMessages = {
+    uploading: "The shorts' background music is still uploading, so the run can't start yet. Wait for it to finish, or remove it under Outputs → Export → More shorts options → Background music.",
+    missing: "The shorts' background music file is no longer available (it was not uploaded again after the draft was copied, or the upload failed). Choose the file again under Outputs → Export → More shorts options → Background music, or remove it.",
+};
+function pickMusic(id) {
+    return id === undefined ? {} : { shortsMusic: id };
+}
 export function toAdmissionDraft(input) {
     const { form } = input.document;
     const fields = [];
@@ -48,15 +57,18 @@ export function toAdmissionDraft(input) {
         });
         return undefined;
     };
-    const file = (ref, kind, field) => {
+    const file = (ref, kind, field, messages = {
+        uploading: "This file is still uploading. Wait for it to finish.",
+        missing: "That upload is no longer available. Choose the file again.",
+    }) => {
         const attachment = input.attachments.find((item) => item.id === ref?.attachmentId && item.kind === kind && item.name === ref.name);
         if (attachment?.state === "ready" && attachment.stagedFileId !== null)
             return attachment.stagedFileId;
         fields.push({
             field,
             message: attachment?.state === "copying" || attachment?.state === "pending"
-                ? "This file is still uploading. Wait for it to finish."
-                : "That upload is no longer available. Choose the file again.",
+                ? messages.uploading
+                : messages.missing,
         });
         return undefined;
     };
@@ -66,6 +78,36 @@ export function toAdmissionDraft(input) {
             ? "files"
             : form.subtitles.mode;
     const chunkMode = sources.audio === "generate" ? form.chunking.mode : "whole";
+    const shortsOn = sources.audio !== "off" && form.shorts?.enabled === true;
+    // Refused in admission's words, so Play and the run say the same sentence.
+    const shortsOf = (raw) => {
+        const whole = (value) => (value.trim() === "" ? Number.NaN : Number(value));
+        const settings = {
+            enabled: true,
+            count: whole(raw.count),
+            minSeconds: whole(raw.minSeconds),
+            maxSeconds: whole(raw.maxSeconds),
+            ...(raw.prompt.trim() ? { prompt: raw.prompt } : {}),
+            ...(raw.imagePrompt.trim() ? { imagePrompt: raw.imagePrompt } : {}),
+            ...shortsExtrasOf(raw),
+        };
+        for (const problem of shortsSettingsProblems(settings))
+            fields.push({ field: `shorts.${problem.field}`, message: problem.message });
+        const { musicVolume, speed, ...rest } = settings;
+        return {
+            ...rest,
+            // A number already refused above is left out rather than saved as NaN.
+            ...(musicVolume !== undefined && Number.isFinite(musicVolume) ? { musicVolume } : {}),
+            ...(speed !== undefined && Number.isFinite(speed) ? { speed } : {}),
+            count: Number.isFinite(settings.count) ? settings.count : defaultShorts.count,
+            minSeconds: Number.isFinite(settings.minSeconds)
+                ? settings.minSeconds
+                : defaultShorts.minSeconds,
+            maxSeconds: Number.isFinite(settings.maxSeconds)
+                ? settings.maxSeconds
+                : defaultShorts.maxSeconds,
+        };
+    };
     const draft = {
         ...(form.checkpoints === undefined ? {} : { checkpoints: form.checkpoints }),
         title: form.title,
@@ -88,6 +130,19 @@ export function toAdmissionDraft(input) {
                     : form.audio
             : undefined,
         images: form.images,
+        // The establishing image belongs to generated images; Off, or images not generated,
+        // leaves it out, which is what every draft saved before it was.
+        ...(sources.images === "generate" &&
+            form.reference !== undefined &&
+            form.reference.source !== "off"
+            ? {
+                reference: {
+                    source: form.reference.source,
+                    ...(form.reference.source === "prompt" ? { prompt: form.reference.prompt } : {}),
+                    thumbnail: form.reference.thumbnail,
+                },
+            }
+            : {}),
         articlePrompt: sources.article === "generate" ? form.articlePrompt : undefined,
         ...(sources.audio === "generate" && form.narrationPrompt?.trim()
             ? { narrationPrompt: form.narrationPrompt }
@@ -99,6 +154,9 @@ export function toAdmissionDraft(input) {
                 ...(form.descriptionPrompt?.trim() ? { descriptionPrompt: form.descriptionPrompt } : {}),
             }
             : {}),
+        // Cut from the narration too, so the same rule: a switch left on with narration Off asks
+        // for nothing.
+        ...(shortsOn && form.shorts !== undefined ? { shorts: shortsOf(form.shorts) } : {}),
         imagePrompts: sources.images === "generate"
             ? form.imagePrompts.map((prompt, index) => ({
                 name: prompt.name,
@@ -120,12 +178,20 @@ export function toAdmissionDraft(input) {
             thumbnail: sources.thumbnail === "provide"
                 ? file(form.provided.thumbnail, "thumbnail", "provided.thumbnail")
                 : undefined,
+            reference: sources.images === "generate" && form.reference?.source === "provide"
+                ? file(form.provided.reference ?? null, "reference", "provided.reference")
+                : undefined,
             images: sources.images === "provide"
                 ? form.provided.images.flatMap((ref, index) => {
                     const id = file(ref, "images", `provided.images.${index}`);
                     return id === undefined ? [] : [id];
                 })
                 : [],
+            // Optional, so only a file that was attached is checked; with Shorts off it is kept on
+            // the draft for when Shorts is turned back on, and never reaches the run.
+            ...(shortsOn && form.provided.shortsMusic
+                ? pickMusic(file(form.provided.shortsMusic, "audio", "shorts.music", musicMessages))
+                : {}),
         },
         chunking: {
             mode: chunkMode,
@@ -144,11 +210,13 @@ export function toAdmissionDraft(input) {
                 fontSize: number(form.subtitles.fontSize, "subtitles.fontSize", 120, 16),
             },
         silenceGapSeconds: input.silenceGapSeconds,
-        imageSeconds: measure("imageSeconds", sources.video === "generate", defaultImageSeconds, imageSecondsProblem),
+        imageSeconds: measure("imageSeconds", sources.video === "generate" || shortsOn, defaultImageSeconds, imageSecondsProblem),
         zoomPercent: measure("zoomPercent", sources.video === "generate", defaultZoomPercent, zoomPercentProblem),
         // A choice from a list, so there is nothing to refuse; a run without a video keeps it
         // for when the video is turned back on.
         motionStyle: form.motionStyle,
+        // Kept the same way; admission checks it only while the video renders.
+        ...(form.videoEdit === undefined ? {} : { videoEdit: form.videoEdit }),
         edgeSilenceSeconds: measure("edgeSilenceSeconds", sources.audio !== "off", defaultEdgeSilenceSeconds, edgeSilenceSecondsProblem),
     };
     const parsed = runDraftSchema.safeParse(draft);

package/dist/slices/play-drafts/readiness.js

@@ -1,9 +1,10 @@
 import { checkRuntimeModel } from "../../catalog/runtime-models.js";
 import { modelFields } from "../../catalog/validate.js";
 import { readinessIsUsable } from "../../kernel/ports/model.js";
-import { usesNarrationPreparation, usesYoutubeDescription, } from "../admission/rules.js";
+import { usesNarrationPreparation, usesShorts, usesYoutubeDescription, } from "../admission/rules.js";
 import { cliPathChanged } from "../settings/cli-paths.js";
 import { hasKey, listVoices } from "../settings/repo.js";
+import { usesAnimation } from "../video/edit-settings.js";
 export function choices(runs) {
     const selected = runs
         .flatMap(({ draft: d }) => [
@@ -17,7 +18,8 @@ export function choices(runs) {
                 d.intro?.mode === "llm" ||
                 d.outro?.mode === "llm" ||
                 usesNarrationPreparation(d) ||
-                usesYoutubeDescription(d),
+                usesYoutubeDescription(d) ||
+                usesShorts(d),
         },
         {
             field: "audio",
@@ -30,7 +32,9 @@ export function choices(runs) {
             family: "image",
             choice: d.images,
             needed: d.sources.images === "generate" ||
-                ["from_prompt", "prompt_by_llm"].includes(d.sources.thumbnail),
+                ["from_prompt", "prompt_by_llm"].includes(d.sources.thumbnail) ||
+                usesShorts(d) ||
+                usesAnimation(d),
         },
     ])
         .flatMap((c) => (c.needed && c.choice ? [{ ...c, ...c.choice }] : []));

package/dist/slices/play-drafts/repo.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { fingerprint } from "../../kernel/runner/work.js";
+import { draftAttachmentKinds } from "./schema.js";
 const rowSchema = z.object({
     id: z.string(),
     schema_version: z.number(),
@@ -21,7 +22,7 @@ const attachmentSchema = z.object({
     id: z.string(),
     draft_id: z.string(),
     staged_file_id: z.string().nullable(),
-    kind: z.enum(["audio", "images", "thumbnail"]),
+    kind: z.enum(draftAttachmentKinds),
     original_filename: z.string(),
     status: z.enum(["pending", "ready", "reattach"]),
     error: z.string().nullable(),
@@ -52,6 +53,11 @@ export function attachmentRefs(document) {
         ...(p.audio === null ? [] : [{ ...p.audio, kind: "audio" }]),
         ...p.images.map((file) => ({ ...file, kind: "images" })),
         ...(p.thumbnail === null ? [] : [{ ...p.thumbnail, kind: "thumbnail" }]),
+        ...(p.reference === undefined || p.reference === null
+            ? []
+            : [{ ...p.reference, kind: "reference" }]),
+        // The shorts' music is staged like narration audio, so it is an audio attachment.
+        ...(p.shortsMusic == null ? [] : [{ ...p.shortsMusic, kind: "audio" }]),
     ];
 }
 export function requestHash(value) {

package/dist/slices/play-drafts/review-inputs.js

@@ -110,7 +110,9 @@ export function resolveReviewInputs(deps, view, font) {
     const activeIds = new Set(runs.flatMap((run) => [
         run.draft.provided.audio,
         run.draft.provided.thumbnail,
+        run.draft.provided.reference,
         ...(run.draft.provided.images ?? []),
+        run.draft.provided.shortsMusic,
     ]));
     const attachmentIdentity = fresh.value.attachments.flatMap((file) => file.stagedFileId !== null && activeIds.has(file.stagedFileId)
         ? [{ id: file.id, stagedFileId: file.stagedFileId, bytes: file.bytes }]

package/dist/slices/play-drafts/schema.js

@@ -1,9 +1,9 @@
 import { z } from "zod";
 import { formats, stageKinds } from "../../kernel/pipeline.js";
 import { thinkingModes } from "../../kernel/ports/llm.js";
-import { motionStyles, stageSources } from "../admission/model.js";
+import { motionStyles, referenceSources, stageSources } from "../admission/model.js";
 import { defaultEdgeSilenceSeconds, defaultImageSeconds, defaultMotionStyle, defaultZoomPercent, } from "../admission/rules.js";
-import { runDraftSchema } from "../admission/schema.js";
+import { runDraftSchema, videoEditSchema } from "../admission/schema.js";
 import { checkpointRowSchema, checkpointStageSchema } from "../checkpoints/schema.js";
 import { documentSettingsSchema } from "../document/theme-schema.js";
 import { librarySnapshotSchema } from "../library/snapshot.js";
@@ -15,6 +15,8 @@ const values = z.record(text, text).readonly();
 const provider = z
     .object({ provider: text, model: text, thinking: z.enum(thinkingModes).optional() })
     .strict();
+// What a draft's uploads are for: a stage's files, or the Images stage's establishing image.
+export const draftAttachmentKinds = ["audio", "images", "thumbnail", "reference"];
 const file = z.object({ attachmentId: id, name: text }).strict().readonly();
 export const playDraftFormSchema = z
     .object({
@@ -45,11 +47,42 @@ export const playDraftFormSchema = z
     })
         .readonly(),
     images: provider.readonly(),
+    // Absent on drafts and templates saved before the establishing image: Off. The prompt is
+    // an image prompt's name, "" when none is picked.
+    reference: z
+        .object({
+        source: z.enum(["off", ...referenceSources]),
+        prompt: text,
+        thumbnail: z.boolean(),
+    })
+        .strict()
+        .readonly()
+        .optional(),
     articlePrompt: text,
     narrationPrompt: text.optional(),
     // Absent on drafts and templates saved before the YouTube description: off, built-in prompt.
     youtubeDescription: z.boolean().optional(),
     descriptionPrompt: text.optional(),
+    // Absent on drafts and templates saved before Shorts: off. The numbers are raw text, like
+    // every other number on Play; the prompts are names, "" being the built-in ones.
+    shorts: z
+        .object({
+        enabled: z.boolean(),
+        count: text,
+        minSeconds: text,
+        maxSeconds: text,
+        prompt: text,
+        imagePrompt: text,
+        // Absent on drafts saved before these: the title off, no link, the music at its
+        // default level, normal speed. The two numbers are raw text too.
+        titleOnScreen: z.boolean().optional(),
+        fullVideoLink: text.optional(),
+        musicVolume: text.optional(),
+        speed: text.optional(),
+    })
+        .strict()
+        .readonly()
+        .optional(),
     imagePrompts: z.array(z.object({ name: text, number: text }).strict().readonly()).readonly(),
     thumbnailPrompt: text,
     intro: text,
@@ -74,6 +107,9 @@ export const playDraftFormSchema = z
     edgeSilenceSeconds: text.default(String(defaultEdgeSilenceSeconds)),
     zoomPercent: text.default(String(defaultZoomPercent)),
     motionStyle: z.enum(motionStyles).default(defaultMotionStyle),
+    // Absent on drafts and templates saved before the edit settings: today's slideshow. Every
+    // field is a pick from a list, so it is kept as the settings themselves.
+    videoEdit: videoEditSchema.strict().readonly().optional(),
     values,
     provided: z
         .object({
@@ -82,6 +118,11 @@ export const playDraftFormSchema = z
         audio: file.nullable(),
         thumbnail: file.nullable(),
         images: z.array(file).readonly(),
+        // The uploaded establishing image; absent on drafts saved before it.
+        reference: file.nullable().optional(),
+        // The Shorts step's background music, uploaded as an audio attachment. Absent on
+        // drafts and templates saved before Play offered it: no music.
+        shortsMusic: file.nullable().optional(),
     })
         .strict()
         .readonly(),
@@ -127,7 +168,7 @@ export const discardDraftInputSchema = z
 export const draftAttachmentSchema = z
     .object({
     id,
-    kind: z.enum(["audio", "images", "thumbnail"]),
+    kind: z.enum(draftAttachmentKinds),
     name: text,
     state: z.enum(["pending", "copying", "ready", "reattach"]),
     stagedFileId: text.nullable(),

package/dist/slices/play-drafts/service.js

@@ -208,6 +208,12 @@ export function forkDraft(deps, input) {
                     audio: p.audio === null ? null : rewrite(p.audio),
                     thumbnail: p.thumbnail === null ? null : rewrite(p.thumbnail),
                     images: p.images.map(rewrite),
+                    ...(p.reference === undefined
+                        ? {}
+                        : { reference: p.reference === null ? null : rewrite(p.reference) }),
+                    ...(p.shortsMusic === undefined
+                        ? {}
+                        : { shortsMusic: p.shortsMusic === null ? null : rewrite(p.shortsMusic) }),
                 },
             },
         };

package/dist/slices/play-drafts/uploads.js

@@ -29,7 +29,8 @@ export async function uploadDraftAttachment(deps, input) {
         return refuse("conflict");
     const storage = { ...deps, emit: () => undefined };
     const result = await stageUpload(storage, {
-        stageKind: attachment.kind,
+        // The establishing image is the Images stage's upload.
+        stageKind: attachment.kind === "reference" ? "images" : attachment.kind,
         originalFilename: attachment.original_filename,
         content: input.content,
         onAllocated(file) {