@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/slices/template-studio/checks.js

@@ -0,0 +1,322 @@
+import { detectSlots, filledKeywords } from "../admission/substitute.js";
+import { isReserved } from "../keywords/model.js";
+import { topicKeywords } from "../project-templates/one-off.js";
+import { withProviderDefaults, } from "../project-templates/provider-defaults.js";
+import { usesPostPrompt } from "../social/rules.js";
+import { sectionLabel } from "./model.js";
+export const freeCheckIds = [
+    "keywords",
+    "providers",
+    "voice",
+    "release-slots",
+    "monthly-cost",
+    "answerers",
+];
+const nameOf = (schedule) => schedule.paused === true ? `${schedule.name} (paused)` : schedule.name;
+export const studioHref = (templateId, section) => `/templates/${encodeURIComponent(templateId)}?section=${section}`;
+const scheduleHref = (id) => `/calendar?tab=schedules&schedule=${encodeURIComponent(id)}`;
+const weekdays = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+const agentWindowMs = 7 * 24 * 60 * 60 * 1000;
+// The checks in order. Providers is one line per missing thing, each with its own fix, so the
+// count of lines to fix is the count of things to fix. A run that can't start can't be priced
+// either: while a line above says why, the monthly cost's line would only say it again, so it
+// waits until they are fixed.
+export function freeChecks(input) {
+    const start = [keywordsCheck(input), ...providersChecks(input), voiceCheck(input)];
+    const blocked = start.some((check) => !check.ok);
+    const cost = monthlyCostCheck(input);
+    return [
+        ...start,
+        releaseSlotsCheck(input),
+        ...(blocked && !cost.ok ? [] : [cost]),
+        answerersCheck(input),
+    ];
+}
+function list(names) {
+    if (names.length <= 1)
+        return names.join("");
+    return `${names.slice(0, -1).join(", ")} and ${names.at(-1) ?? ""}`;
+}
+// A keyword is filled when it has a value, is the topic a schedule fills each run, or is one
+// Slopify fills itself ({{Scene}}, {{Appearance}} and every {{Slopify_…}} name).
+function keywordsCheck(input) {
+    const { form } = input.document;
+    const topics = new Set([
+        ...topicKeywords(form.title),
+        ...input.schedules.flatMap((schedule) => schedule.topicKeyword === null ? [] : [schedule.topicKeyword]),
+    ]);
+    const names = new Set([form.title, ...input.bodies].flatMap((body) => detectSlots(body).names));
+    const empty = [...names].filter((name) => !topics.has(name) &&
+        !filledKeywords.includes(name) &&
+        // The keywords registry's: an unknown Slopify_ name is refused when the prompt is saved.
+        !isReserved(name) &&
+        (form.values[name] ?? "").trim() === "");
+    if (empty.length === 0)
+        return {
+            id: "keywords",
+            ok: true,
+            sentence: "Every keyword has a value or is filled per video.",
+        };
+    return {
+        id: "keywords",
+        ok: false,
+        sentence: `${empty.length === 1 ? "A keyword is" : "Keywords are"} empty: ${list(empty.map((name) => `{{${name}}}`))}. A run would send the prompt with nothing in ${empty.length === 1 ? "its place" : "their place"}.`,
+        fix: {
+            label: `Fill them in ${sectionLabel.subject}`,
+            href: studioHref(input.templateId, "subject"),
+        },
+    };
+}
+function usedProviders(document) {
+    const { form } = document;
+    const generates = (source) => source !== undefined && source !== "off" && source !== "provide";
+    const text = generates(form.sources.research) ||
+        generates(form.sources.article) ||
+        form.sources.thumbnail === "prompt_by_llm" ||
+        form.youtubeDescription === true ||
+        usesPostPrompt(form) ||
+        form.shorts?.enabled === true;
+    const reviews = form.reviews !== undefined &&
+        (form.reviews.reviewer ?? "model") === "model" &&
+        Object.values(form.reviews.stages).some((stage) => stage.mode !== "off");
+    return [
+        ...(text
+            ? [
+                {
+                    family: "llm",
+                    provider: form.llm.provider,
+                    model: form.llm.model,
+                    section: "script",
+                    what: "writing service",
+                },
+            ]
+            : []),
+        ...(generates(form.sources.audio)
+            ? [
+                {
+                    family: "tts",
+                    provider: form.audio.provider,
+                    model: form.audio.model,
+                    section: "voice",
+                    what: "voice service",
+                },
+            ]
+            : []),
+        ...(generates(form.sources.images) || generates(form.sources.thumbnail)
+            ? [
+                {
+                    family: "image",
+                    provider: form.images.provider,
+                    model: form.images.model,
+                    section: "pictures",
+                    what: "image service",
+                },
+            ]
+            : []),
+        ...(reviews && form.reviews !== undefined
+            ? [
+                {
+                    family: "llm",
+                    provider: form.reviews.provider,
+                    model: form.reviews.model,
+                    section: "reviews",
+                    what: "service for the AI checks",
+                },
+            ]
+            : []),
+    ];
+}
+function providersChecks(input) {
+    const used = usedProviders(withProviderDefaults(input.document, input.defaults ?? {}));
+    const unchosen = used.filter((one, index) => one.provider === "" && used.findIndex((other) => other.what === one.what) === index);
+    // A service picked without its model is refused by every run, as the sample says.
+    const modelless = used.filter((one, index) => one.provider !== "" &&
+        one.model.trim() === "" &&
+        used.findIndex((other) => other.what === one.what) === index);
+    const missing = used.filter((one, index) => one.provider !== "" &&
+        input.providers.get(one.provider)?.ready !== true &&
+        used.findIndex((other) => other.provider === one.provider) === index);
+    const lines = [
+        ...unchosen.map((one) => ({
+            id: "providers",
+            ok: false,
+            sentence: `No ${one.what} is chosen, so a run can't start.`,
+            fix: {
+                label: `Choose one in ${sectionLabel[one.section]}`,
+                href: studioHref(input.templateId, one.section),
+            },
+        })),
+        ...modelless.map((one) => {
+            const name = input.providers.get(one.provider)?.name ?? one.provider;
+            return {
+                id: "providers",
+                ok: false,
+                sentence: `No model is chosen for ${name}, the ${one.what}, so a run can't start.`,
+                fix: {
+                    label: `Choose one in ${sectionLabel[one.section]}`,
+                    href: studioHref(input.templateId, one.section),
+                },
+            };
+        }),
+        ...missing.map((one) => {
+            const name = input.providers.get(one.provider)?.name ?? one.provider;
+            return {
+                id: "providers",
+                ok: false,
+                sentence: `${name}, the ${one.what}, isn't set up on this computer: no key is stored or its program wasn't found.`,
+                fix: {
+                    label: "Set it up in Settings → Keys & services",
+                    href: "/settings?section=providers",
+                },
+            };
+        }),
+    ];
+    return lines.length > 0
+        ? lines
+        : [{ id: "providers", ok: true, sentence: "Every service this template uses is set up." }];
+}
+// The narration's voice (and each speaker's) is chosen and is one of the voices this computer
+// keeps in Settings → Voices: an imported pack's voice may be someone else's.
+function voiceCheck(input) {
+    const { form } = input.document;
+    const voiced = form.sources.audio === "generate";
+    const fix = {
+        label: `Choose a voice in ${sectionLabel.voice}`,
+        href: studioHref(input.templateId, "voice"),
+    };
+    if (!voiced)
+        return { id: "voice", ok: true, sentence: "The narration isn't voiced by Slopify." };
+    const picks = [
+        { who: "The narration's", provider: form.audio.provider, voice: form.audio.voice },
+        ...(form.voices?.speakers ?? []).map((speaker) => ({
+            who: `${speaker.name.trim() === "" ? "A speaker" : speaker.name}'s`,
+            provider: speaker.voice.provider,
+            voice: speaker.voice.voice,
+        })),
+    ];
+    if (form.audio.voice.trim() === "" && form.voices === undefined)
+        return {
+            id: "voice",
+            ok: false,
+            sentence: "No voice is chosen for the narration, so a run can't start.",
+            fix,
+        };
+    const known = input.voices;
+    const unknown = known === undefined
+        ? undefined
+        : picks.find((pick) => pick.voice.trim() !== "" &&
+            !known.some((one) => one.provider === pick.provider && one.voiceId === pick.voice));
+    if (unknown !== undefined)
+        return {
+            id: "voice",
+            ok: false,
+            sentence: `${unknown.who} voice (ID ${unknown.voice}) isn't one of your voices in Settings → Voices. Add it there under that ID, or choose one of yours.`,
+            fix,
+        };
+    return { id: "voice", ok: true, sentence: "The narration's voice is one of your voices." };
+}
+function releaseSlotsCheck(input) {
+    const shorts = input.document.form.shorts;
+    const wanted = shorts?.enabled === true ? Math.max(0, Number.parseInt(shorts.count, 10) || 0) : 0;
+    for (const schedule of input.schedules) {
+        if (schedule.releases.length === 0)
+            continue;
+        const missing = schedule.runDays.filter((day) => !schedule.releases.some((release) => release.day === day));
+        if (missing.length > 0)
+            return {
+                id: "release-slots",
+                ok: false,
+                sentence: `${nameOf(schedule)} runs on ${list(missing.map((day) => weekdays[day] ?? String(day)))} but has no release time for ${missing.length === 1 ? "that day" : "those days"}.`,
+                fix: {
+                    label: `Add the release times in ${schedule.name}`,
+                    href: scheduleHref(schedule.id),
+                },
+            };
+        const short = schedule.releases.find((release) => release.shorts < wanted);
+        if (short !== undefined)
+            return {
+                id: "release-slots",
+                ok: false,
+                sentence: `This template makes ${String(wanted)} shorts a video, but ${nameOf(schedule)} gives ${weekdays[short.day] ?? ""}'s run release times for ${String(short.shorts)}.`,
+                fix: {
+                    label: `Add short release times in ${schedule.name}`,
+                    href: scheduleHref(schedule.id),
+                },
+            };
+    }
+    return {
+        id: "release-slots",
+        ok: true,
+        sentence: input.schedules.length === 0
+            ? "No schedule runs this template yet."
+            : "Every run has a release time for the video and its shorts.",
+    };
+}
+// A run that can't be priced at all fails: it can't start either, and the sentence says why.
+// Steps with no price (how many tables a written article describes is known only once it is
+// written) never fail it, since nothing fixes them: they are named as not counted, here and in
+// Schedule, so the dollar figure reads as the least it costs.
+function monthlyCostCheck(input) {
+    const cost = input.monthlyCost;
+    if (cost === null)
+        return {
+            id: "monthly-cost",
+            ok: true,
+            sentence: "No schedule runs this template, so it costs nothing a month.",
+        };
+    if (cost.problem !== undefined && cost.problem !== null)
+        return {
+            id: "monthly-cost",
+            ok: false,
+            sentence: cost.problem,
+            fix: { label: "See its runs in Schedule", href: studioHref(input.templateId, "schedule") },
+        };
+    const paused = cost.paused?.schedules ?? 0;
+    const resumed = `up to about $${(cost.paused?.high ?? 0).toFixed(2)} a month when resumed`;
+    const many = (n) => `${String(n)} paused ${n === 1 ? "schedule" : "schedules"}`;
+    const activeCost = `Its schedules cost ${cost.unknown === 0 ? "up to about" : "at least"} $${cost.high.toFixed(2)} a month`;
+    const sentence = paused === 0
+        ? `${activeCost}.`
+        : cost.high === 0 && (cost.runs ?? 0) === 0
+            ? `${many(paused)} ${paused === 1 ? "uses" : "use"} this template: ${paused === 1 ? "it costs" : "they cost"} nothing while paused, and ${resumed}.`
+            : `${activeCost}; ${many(paused)} would add ${resumed}.`;
+    return {
+        id: "monthly-cost",
+        ok: true,
+        sentence: cost.unknown === 0 ? sentence : `${sentence} ${unpricedSentence(cost)}`,
+    };
+}
+// "Not counted, with no known price: Narration descriptions and Delivery cue overhead."
+function unpricedSentence(cost) {
+    const names = cost.unpriced ?? [];
+    return names.length === 0
+        ? `${String(cost.unknown)} ${cost.unknown === 1 ? "step has" : "steps have"} no known price and ${cost.unknown === 1 ? "isn't" : "aren't"} counted.`
+        : `Not counted, with no known price: ${list(names)}.`;
+}
+function answerersCheck(input) {
+    const { form } = input.document;
+    const asks = (form.checkpoints?.length ?? 0) > 0 ||
+        (form.reviews?.reviewer === "agent" &&
+            Object.values(form.reviews.stages).some((stage) => stage.mode !== "off"));
+    if (!asks)
+        return { id: "answerers", ok: true, sentence: "Nothing in a run waits for an answer." };
+    const agent = input.agentSeenAt !== null &&
+        input.now.getTime() - new Date(input.agentSeenAt).getTime() <= agentWindowMs;
+    if (input.notificationUrl || agent)
+        return {
+            id: "answerers",
+            ok: true,
+            sentence: agent
+                ? "An agent connected this week answers when a run pauses."
+                : "You're notified when a run pauses for you.",
+        };
+    return {
+        id: "answerers",
+        ok: false,
+        sentence: "A run pauses for your approval and nobody would know: no notification address is set and no agent connected in the last 7 days.",
+        fix: {
+            label: "Set a notification address in Settings → Notifications",
+            href: "/settings?section=notifications",
+        },
+    };
+}

package/dist/slices/template-studio/document-sample.js

@@ -0,0 +1,56 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { draftDocumentThemeOf } from "../document/model.js";
+import { renderSampleDocument } from "../document/sample.js";
+import { resolvedDocumentTheme } from "../document/theme.js";
+import { stableJson } from "../style-preview/settings.js";
+// The Document (PDF) sample: the Library theme editor's sample article laid out in the
+// template's theme. Local and free.
+export function documentThemeOfTemplate(document) {
+    const settings = document.form.document;
+    return resolvedDocumentTheme({
+        theme: draftDocumentThemeOf(settings),
+        ...(settings?.custom === undefined ? {} : { custom: settings.custom }),
+    });
+}
+export function documentHash(theme) {
+    return createHash("sha256")
+        .update(stableJson({ version: 1, theme }))
+        .digest("hex");
+}
+const hashPattern = /^[a-f0-9]{64}$/;
+export function createDocumentSamples(deps) {
+    const render = deps.render ?? ((theme) => renderSampleDocument(theme).bytes);
+    const pathOf = (hash) => join(deps.dir, `${hash}.pdf`);
+    const file = (hash) => {
+        if (!hashPattern.test(hash))
+            return undefined;
+        try {
+            const stats = statSync(pathOf(hash));
+            return stats.isFile() && stats.size > 0
+                ? { path: pathOf(hash), bytes: stats.size }
+                : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    return {
+        file,
+        make: (theme) => {
+            const hash = documentHash(theme);
+            if (file(hash) !== undefined)
+                return;
+            mkdirSync(deps.dir, { recursive: true, mode: 0o700 });
+            const part = join(deps.dir, `${hash}.${randomUUID()}.part`);
+            try {
+                writeFileSync(part, render(theme), { mode: 0o600 });
+                renameSync(part, pathOf(hash));
+            }
+            finally {
+                rmSync(part, { force: true });
+            }
+        },
+    };
+}

package/dist/slices/template-studio/edit.js

@@ -0,0 +1,15 @@
+import { configOf } from "../admission/start.js";
+// The sample project's next revision for a template's newer setup: the config a fresh run of it
+// would start with (`configOf`, so aliases and rules are copied as they are now) and the
+// current content with each prompt's template body replaced, so a changed prompt is sent as
+// written now. Saving it outdates exactly what the change touches; the rebuild makes only that.
+export function sampleEdit(deps, base, run) {
+    const config = configOf(deps, run.draft, run.rendered, deps.clock.now(), run.templates, base.revision.projectId);
+    return {
+        config,
+        content: {
+            ...base.revision.content,
+            promptTemplates: Object.fromEntries(Object.keys(config.rendered).map((key) => [key, run.templates[key] ?? null])),
+        },
+    };
+}

package/dist/slices/template-studio/for-all.js

@@ -0,0 +1,161 @@
+import { setImmediate as yieldTurn } from "node:timers/promises";
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { templateById, templateSummaries } from "../project-templates/repo.js";
+import { budgetRoom, budgetWords, fitsBudget, plansSwitch } from "./budget.js";
+import { enqueueJob } from "./jobs.js";
+import { quoteSample } from "./quote.js";
+import { sampleVersions, setSampleVersion } from "./repo.js";
+import { exceedsAcknowledged } from "./save.js";
+import { affectedSections } from "./sections.js";
+import { paidSections } from "./status.js";
+const money = (value) => `$${value.toFixed(2)}`;
+// The sections a template's newest version has no sample of: every one before its first
+// sample, the ones changed since the last one made, none when it is made or on its way.
+function wanted(deps, templateId) {
+    const head = templateById(deps.db, templateId);
+    if (head === undefined)
+        return "none";
+    const versions = sampleVersions(deps.db, templateId);
+    const row = versions.find((one) => one.templateVersion === head.version);
+    if (row !== undefined && ["done", "queued", "making"].includes(row.state))
+        return "none";
+    const done = versions.find((one) => one.state === "done" && one.templateVersion <= head.version);
+    const from = done === undefined ? undefined : templateById(deps.db, templateId, done.templateVersion);
+    if (from === undefined)
+        return "all";
+    const paid = new Set(paidSections);
+    const changed = affectedSections(from.document, head.document).filter((one) => paid.has(one));
+    return changed.length === 0 ? "none" : changed;
+}
+export async function quoteSamplesForAll(deps) {
+    const room = budgetRoom(deps.db, deps.clock.now(), deps.timeZone);
+    const items = [];
+    let used = 0;
+    for (const template of templateSummaries(deps.db)) {
+        const sections = wanted(deps, template.id);
+        if (sections === "none")
+            continue;
+        // Each price resolves a draft through Play's review: the server stays answering between them.
+        await yieldTurn();
+        const quoted = await quoteSample(deps, template.id, { sections });
+        if (!quoted.ok)
+            continue;
+        const { high, unknown, problem, usesPlan } = quoted.value;
+        const fits = problem === null && fitsBudget(room, used + high, usesPlan);
+        if (fits)
+            used += high;
+        items.push({
+            templateId: template.id,
+            name: template.name,
+            version: quoted.value.version,
+            high: problem === null ? high : 0,
+            unknown: problem === null ? unknown : 0,
+            usesPlan: problem === null && usesPlan,
+            fits,
+            problem,
+        });
+    }
+    const makeable = items.filter((item) => item.problem === null);
+    const total = makeable.reduce((sum, item) => sum + item.high, 0);
+    const fitting = makeable.filter((item) => item.fits).length;
+    return {
+        items,
+        total,
+        fitting,
+        budget: room,
+        sentence: sentenceOf(makeable, room),
+    };
+}
+function sentenceOf(makeable, room) {
+    const count = makeable.length;
+    if (count === 0)
+        return "Every template's sample is made for its newest version. Nothing to make.";
+    const total = makeable.reduce((sum, item) => sum + item.high, 0);
+    const fitting = makeable.filter((item) => item.fits).length;
+    const head = `${String(count)} ${count === 1 ? "template needs" : "templates need"} a sample: about ${money(total)} in all.`;
+    if (fitting === count)
+        return head;
+    const waiting = count - fitting;
+    const onPlan = makeable.filter((item) => !item.fits && item.usesPlan && !room.plans).length;
+    const why = onPlan === waiting
+        ? `: they run on your Claude Code or Codex plan, which samples may not use (turn on ${plansSwitch} in Settings → Production defaults)`
+        : onPlan > 0
+            ? `: ${String(onPlan)} run on your Claude Code or Codex plan, which samples may not use (turn on ${plansSwitch} in Settings → Production defaults), and the rest wait for tomorrow or a higher budget`
+            : " for tomorrow or a higher budget in Settings → Production defaults";
+    return `${head} ${String(fitting)} of them ${fitting === 1 ? "fits" : "fit"} today's budget; the other ${String(waiting)} wait${why}.`;
+}
+export const samplesForAllSchema = z
+    .object({
+    // The total the button showed.
+    acknowledgedTotal: z.number().finite().min(0).max(100_000),
+    // That some steps have no price, and the person accepts it.
+    acknowledgedUnknown: z.boolean().optional(),
+})
+    .strict()
+    .readonly();
+const budgetHeld = "Waiting: today's sample budget is used by the other templates' samples. Press Make sample tomorrow, or raise the budget in Settings → Production defaults.";
+export async function makeSamplesForAll(deps, raw) {
+    const parsed = samplesForAllSchema.safeParse(raw);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid-input",
+            message: "Settings sent a request Slopify couldn't read. Reload the page and press Make samples for all again.",
+        };
+    const quote = await quoteSamplesForAll(deps);
+    if (exceedsAcknowledged(quote.total, parsed.data.acknowledgedTotal))
+        return {
+            ok: false,
+            reason: "cost-changed",
+            message: `Making them now costs about ${money(quote.total)}, more than the ${money(parsed.data.acknowledgedTotal)} you saw. Press Make samples for all again to accept the new price.`,
+            quote,
+        };
+    const at = deps.clock.now().toISOString();
+    // Each sample's share of the total the person saw: its leeway is applied once, at make time.
+    const seenShare = quote.total > 0 ? Math.min(1, parsed.data.acknowledgedTotal / quote.total) : 1;
+    const queued = [];
+    const held = [];
+    transact(deps.db, () => {
+        for (const item of quote.items) {
+            if (item.problem !== null)
+                continue;
+            const head = templateById(deps.db, item.templateId);
+            // Saved again meanwhile: its own Save made (or skipped) that version's sample.
+            if (head === undefined || head.version !== item.version)
+                continue;
+            const unpriced = item.unknown > 0 && parsed.data.acknowledgedUnknown !== true;
+            if (!item.fits || unpriced) {
+                setSampleVersion(deps.db, item.templateId, item.version, {
+                    state: "held",
+                    at,
+                    quotedHigh: item.high,
+                    heldReason: unpriced
+                        ? `Waiting: ${String(item.unknown)} ${item.unknown === 1 ? "step of this sample has" : "steps of this sample have"} no known price. Press Make sample to accept that and make it.`
+                        : item.usesPlan && !quote.budget.plans
+                            ? `Waiting: ${budgetWords(quote.budget, item, "this sample")}, then press Make sample.`
+                            : budgetHeld,
+                });
+                held.push(item.templateId);
+                continue;
+            }
+            // Its unknown prices were accepted above, or its quote priced every step.
+            deps.acks.accept(item.templateId, item.version);
+            setSampleVersion(deps.db, item.templateId, item.version, {
+                state: "queued",
+                at,
+                quotedHigh: item.high,
+                heldReason: null,
+            });
+            enqueueJob(deps.db, {
+                templateId: item.templateId,
+                templateVersion: item.version,
+                ackHigh: item.high * seenShare,
+                kind: "save",
+                requestedAt: at,
+            });
+            queued.push(item.templateId);
+        }
+    });
+    return { ok: true, value: { queued, held, quote } };
+}

package/dist/slices/template-studio/free-video.js

@@ -0,0 +1,31 @@
+import { defaultImageSeconds, defaultMotionStyle, defaultZoomPercent } from "../admission/rules.js";
+// The Video and style sample: 30 seconds made by the style preview's renderer from the
+// template's frame, captions, Look and picture timing, on the bundled sample's pictures and
+// narration. Local and free; no provider is called.
+export const videoSampleSeconds = 30;
+function number(raw, fallback, min, max) {
+    const value = Number(raw);
+    return raw === undefined || raw.trim() === "" || !Number.isFinite(value)
+        ? fallback
+        : Math.min(max, Math.max(min, value));
+}
+export function videoSampleRequest(document) {
+    const { form } = document;
+    return {
+        format: form.format,
+        subtitles: {
+            mode: form.subtitles.mode,
+            fontId: /^[A-Za-z0-9_-]+$/.test(form.subtitles.fontId) ? form.subtitles.fontId : "default",
+            fontSize: number(form.subtitles.fontSize, 48, 16, 120),
+            position: form.subtitles.position,
+        },
+        ...(form.videoEdit === undefined ? {} : { videoEdit: form.videoEdit }),
+        previewText: document.previewText.slice(0, 200),
+        seconds: videoSampleSeconds,
+        timing: {
+            imageSeconds: number(form.imageSeconds, defaultImageSeconds, 1, 120),
+            zoomPercent: number(form.zoomPercent, defaultZoomPercent, 0, 100),
+            motionStyle: form.motionStyle ?? defaultMotionStyle,
+        },
+    };
+}