@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/slices/designs/runner.js

@@ -0,0 +1,239 @@
+import { artworkRequest, castReferences } from "./artwork.js";
+import { createDesignCalls, noProviderMessage } from "./calls.js";
+import { nearestFormat } from "./picture-size.js";
+import { costChanged, costChangedMessage, quoteDesignImage } from "./quote.js";
+import { editPictureSchema, makeArtworkSchema, quoteEditSchema, retryStepSchema, } from "./requests.js";
+import { designView, mutationHash, reusedMessage } from "./service.js";
+import { insertStep, makingSteps, restartStep, settleStep, stepById, stepByMutation, } from "./steps-repo.js";
+const stoppedMessage = "Slopify stopped while this picture was being made. Press Try again.";
+const noProvider = {
+    ok: false,
+    reason: "no-image-provider",
+    message: noProviderMessage,
+};
+const notFound = {
+    ok: false,
+    reason: "not-found",
+    message: "This design no longer exists. Open Library → Designs to choose another.",
+};
+export function createDesignRunner(deps) {
+    const calls = createDesignCalls(deps);
+    const start = calls.start;
+    const view = (designId) => {
+        const value = designView(deps.db, designId);
+        return value === undefined ? notFound : { ok: true, value };
+    };
+    return {
+        quoteEdit: (designId, raw) => {
+            const parsed = quoteEditSchema.safeParse(raw);
+            if (!parsed.success)
+                return { ok: false, reason: "invalid", message: "Choose an image model to quote." };
+            if (designView(deps.db, designId) === undefined)
+                return notFound;
+            return {
+                ok: true,
+                value: quoteDesignImage(deps.catalogue(), {
+                    ...parsed.data,
+                    purpose: "picture-edit",
+                    sendsPictures: true,
+                }),
+            };
+        },
+        quoteArtwork: (designId) => {
+            const design = designView(deps.db, designId);
+            if (design === undefined)
+                return notFound;
+            const request = artworkRequest(design.document, design.values);
+            if (!request.ok)
+                return request;
+            return {
+                ok: true,
+                value: quoteDesignImage(deps.catalogue(), {
+                    ...request.value,
+                    purpose: "design-art",
+                    sendsPictures: request.value.castMemberIds.length > 0,
+                }),
+            };
+        },
+        edit: (designId, raw) => {
+            const parsed = editPictureSchema.safeParse(raw);
+            if (!parsed.success)
+                return {
+                    ok: false,
+                    reason: "invalid",
+                    message: "Write what to change (at most 4,000 characters), then press Edit.",
+                };
+            const input = parsed.data;
+            const { mutationId, acknowledgedHigh: _shown, acknowledgedUnknown: _accepted, ...asked } = input;
+            const replay = stepByMutation(deps.db, mutationId);
+            if (replay !== undefined)
+                return replay.hash === mutationHash(asked) && replay.step.designId === designId
+                    ? view(designId)
+                    : { ok: false, reason: "mutation-reused", message: reusedMessage };
+            if (designView(deps.db, designId) === undefined)
+                return notFound;
+            const from = stepById(deps.db, input.fromStepId);
+            if (from === undefined ||
+                from.designId !== designId ||
+                from.state !== "ready" ||
+                from.width === null ||
+                from.height === null)
+                return {
+                    ok: false,
+                    reason: "not-ready",
+                    message: "The version to edit has no picture yet. Wait for it to finish, or continue from another version.",
+                };
+            if (deps.generate === undefined)
+                return noProvider;
+            const cast = castReferences(deps.db, input.castMemberIds ?? []);
+            if (!cast.ok)
+                return cast;
+            const quote = quoteDesignImage(deps.catalogue(), {
+                ...input,
+                purpose: "picture-edit",
+                sendsPictures: true,
+            });
+            if (costChanged(quote, input.acknowledgedHigh, input.acknowledgedUnknown))
+                return {
+                    ok: false,
+                    reason: "cost-changed",
+                    message: costChangedMessage(quote, "this edit"),
+                    current: quote,
+                };
+            const step = insertStep(deps.db, {
+                id: deps.ids.next(),
+                designId,
+                parentId: from.id,
+                kind: "edit",
+                instruction: input.instruction,
+                provider: input.provider,
+                model: input.model,
+                inputs: {
+                    castMemberIds: input.castMemberIds ?? [],
+                    aspect: nearestFormat({ width: from.width, height: from.height }),
+                    prompt: input.instruction,
+                },
+                state: "making",
+                sha256: null,
+                width: null,
+                height: null,
+                mutationId,
+                mutationHash: mutationHash(asked),
+                at: deps.clock.now().toISOString(),
+            });
+            start(designId, step.id);
+            return view(designId);
+        },
+        artwork: (designId, raw) => {
+            const parsed = makeArtworkSchema.safeParse(raw);
+            if (!parsed.success)
+                return {
+                    ok: false,
+                    reason: "invalid",
+                    message: "Press Make again from the design's page.",
+                };
+            const replay = stepByMutation(deps.db, parsed.data.mutationId);
+            if (replay !== undefined)
+                return replay.step.designId === designId
+                    ? view(designId)
+                    : { ok: false, reason: "mutation-reused", message: reusedMessage };
+            const design = designView(deps.db, designId);
+            if (design === undefined)
+                return notFound;
+            const request = artworkRequest(design.document, design.values);
+            if (!request.ok)
+                return request;
+            if (deps.generate === undefined)
+                return noProvider;
+            const cast = castReferences(deps.db, request.value.castMemberIds);
+            if (!cast.ok)
+                return cast;
+            const quote = quoteDesignImage(deps.catalogue(), {
+                ...request.value,
+                purpose: "design-art",
+                sendsPictures: request.value.castMemberIds.length > 0,
+            });
+            if (costChanged(quote, parsed.data.acknowledgedHigh, parsed.data.acknowledgedUnknown))
+                return {
+                    ok: false,
+                    reason: "cost-changed",
+                    message: costChangedMessage(quote, "the artwork"),
+                    current: quote,
+                };
+            const step = insertStep(deps.db, {
+                id: deps.ids.next(),
+                designId,
+                parentId: null,
+                kind: "generate",
+                instruction: null,
+                provider: request.value.provider,
+                model: request.value.model,
+                inputs: {
+                    castMemberIds: request.value.castMemberIds,
+                    aspect: request.value.aspect,
+                    prompt: request.value.prompt,
+                },
+                state: "making",
+                sha256: null,
+                width: null,
+                height: null,
+                mutationId: parsed.data.mutationId,
+                mutationHash: mutationHash({ artwork: request.value }),
+                at: deps.clock.now().toISOString(),
+            });
+            start(designId, step.id);
+            return view(designId);
+        },
+        retry: (designId, stepId, raw) => {
+            const parsed = retryStepSchema.safeParse(raw);
+            if (!parsed.success)
+                return {
+                    ok: false,
+                    reason: "invalid",
+                    message: "Try again is paid again, and the request didn't say the price you saw. Reload the design and press Try again.",
+                };
+            const step = stepById(deps.db, stepId);
+            if (step === undefined ||
+                step.designId !== designId ||
+                designView(deps.db, designId) === undefined)
+                return {
+                    ok: false,
+                    reason: "not-found",
+                    message: "That version is no longer in this design. Reload the page.",
+                };
+            if (step.state !== "failed")
+                return {
+                    ok: false,
+                    reason: "busy",
+                    message: "This version didn't fail, so there is nothing to try again.",
+                };
+            if (deps.generate === undefined)
+                return noProvider;
+            // A step a restart stopped may have been charged already: asked again, it is paid again.
+            const quote = quoteDesignImage(deps.catalogue(), {
+                provider: step.provider ?? "",
+                model: step.model ?? "",
+                purpose: step.kind === "edit" ? "picture-edit" : "design-art",
+                sendsPictures: step.kind === "edit" || step.inputs.castMemberIds.length > 0,
+            });
+            if (costChanged(quote, parsed.data.acknowledgedHigh, parsed.data.acknowledgedUnknown))
+                return {
+                    ok: false,
+                    reason: "cost-changed",
+                    message: costChangedMessage(quote, "trying this version again"),
+                    current: quote,
+                };
+            restartStep(deps.db, stepId);
+            start(designId, stepId);
+            return view(designId);
+        },
+        recover: () => {
+            let settled = 0;
+            for (const step of makingSteps(deps.db))
+                if (settleStep(deps.db, step.id, { state: "failed", error: stoppedMessage }, deps.clock.now().toISOString()))
+                    settled += 1;
+            return settled;
+        },
+        idle: calls.idle,
+    };
+}

package/dist/slices/designs/sample-repo.js

@@ -0,0 +1,91 @@
+/// <reference lib="esnext.temporal" />
+import { z } from "zod";
+// The one sample job each design template keeps (`design_template_samples`), and what the
+// samples spent today against their daily budget.
+export const sampleStates = ["queued", "making", "done", "failed", "held"];
+const rowSchema = z.object({
+    template_id: z.string(),
+    design_id: z.string().nullable(),
+    version: z.number(),
+    state: z.enum(sampleStates),
+    held_reason: z.string().nullable(),
+    quoted_high: z.number().nullable(),
+    updated_at: z.string(),
+});
+export function sampleRow(db, templateId) {
+    const raw = db
+        .prepare("SELECT * FROM design_template_samples WHERE template_id=?")
+        .get(templateId);
+    if (raw === undefined)
+        return undefined;
+    const row = rowSchema.parse(raw);
+    return {
+        templateId: row.template_id,
+        designId: row.design_id,
+        version: row.version,
+        state: row.state,
+        heldReason: row.held_reason,
+        quotedHigh: row.quoted_high,
+        updatedAt: row.updated_at,
+    };
+}
+export function sampleRowOfDesign(db, designId) {
+    const raw = db
+        .prepare("SELECT template_id FROM design_template_samples WHERE design_id=?")
+        .get(designId);
+    return raw === undefined ? undefined : sampleRow(db, String(raw.template_id));
+}
+export function queuedTemplates(db) {
+    return db
+        .prepare("SELECT template_id FROM design_template_samples WHERE state='queued' ORDER BY updated_at")
+        .all()
+        .map((row) => String(row.template_id));
+}
+export function makingTemplates(db) {
+    return db
+        .prepare("SELECT template_id FROM design_template_samples WHERE state='making'")
+        .all()
+        .map((row) => String(row.template_id));
+}
+export function writeSample(db, row) {
+    db.prepare(`INSERT INTO design_template_samples (template_id,design_id,version,state,held_reason,quoted_high,updated_at)
+     VALUES (?,?,?,?,?,?,?)
+     ON CONFLICT(template_id) DO UPDATE SET design_id=excluded.design_id, version=excluded.version,
+       state=excluded.state, held_reason=excluded.held_reason, quoted_high=excluded.quoted_high,
+       updated_at=excluded.updated_at`).run(row.templateId, row.designId, row.version, row.state, row.heldReason, row.quotedHigh, row.updatedAt);
+}
+// Local midnight of `now` in `timeZone`, as an instant.
+export function startOfDay(now, timeZone) {
+    const day = Temporal.Instant.fromEpochMilliseconds(now.valueOf())
+        .toZonedDateTimeISO(timeZone)
+        .toPlainDate();
+    return new Date(day.toZonedDateTime({ timeZone }).epochMilliseconds).toISOString();
+}
+// What every template's samples cost since local midnight, in dollars. Plan usage costs 0.
+export function sampleSpentToday(db, now, timeZone) {
+    const row = db
+        .prepare(`SELECT COALESCE(SUM(u.cost), 0) AS spent FROM standalone_usage AS u
+       JOIN designs AS d ON d.id = u.owner_id
+       WHERE u.owner_kind='design' AND d.sample_of IS NOT NULL AND u.created_at >= ?`)
+        .get(startOfDay(now, timeZone));
+    return Number(row?.spent ?? 0);
+}
+// What samples queued or being made will cost: each one's quoted price, before any of it is
+// spent. A template's own sample is left out, unless its picture is being made now.
+export function sampleReserved(db, templateId) {
+    const row = db
+        .prepare(`SELECT COALESCE(SUM(quoted_high), 0) AS reserved FROM design_template_samples
+       WHERE (state IN ('queued','making') AND template_id IS NOT ?)
+          OR (state='making' AND template_id=?)`)
+        .get(templateId, templateId);
+    return Number(row?.reserved ?? 0);
+}
+// Earlier samples of a template, kept until the day they were made is over so today's spend
+// still counts them; then removed with their pictures' renders by the caller.
+export function oldSamples(db, templateId, keep, before) {
+    return db
+        .prepare(`SELECT id FROM designs WHERE sample_of=? AND id IS NOT ? AND created_at < ?
+       AND NOT EXISTS (SELECT 1 FROM design_steps WHERE design_id=designs.id AND state='making')`)
+        .all(templateId, keep, before)
+        .map((row) => String(row.id));
+}

package/dist/slices/designs/sample.js

@@ -0,0 +1,222 @@
+import { transact } from "../../kernel/db/tx.js";
+import { budgetSentence } from "./budget.js";
+import { missingValues } from "./fields.js";
+import { costChanged, costChangedMessage } from "./quote.js";
+import { deleteRenders } from "./render.js";
+import { oldSamples, queuedTemplates, sampleReserved, sampleRow, sampleRowOfDesign, sampleSpentToday, startOfDay, writeSample, } from "./sample-repo.js";
+import { designAffectedSections, sampleNeedsPicture } from "./sections.js";
+import { designView } from "./service.js";
+import { makeFromTemplate, quoteDocument } from "./template-make.js";
+import { getTemplate, templateRevision } from "./templates.js";
+const holdSlack = (ack) => ack * 1.25 + 0.05;
+const money = (value) => `$${value.toFixed(2)}`;
+function view(row) {
+    return {
+        state: row.state,
+        version: row.version,
+        designId: row.designId,
+        heldReason: row.heldReason,
+        quotedHigh: row.quotedHigh,
+    };
+}
+export function createDesignSamples(deps) {
+    const db = deps.service.db;
+    const now = () => deps.service.clock.now();
+    const at = () => now().toISOString();
+    const emit = (templateId) => deps.service.emit?.({ type: "design-template.sample", templateId });
+    // A making sample whose picture landed or failed settles; true when it changed.
+    const settle = (row) => {
+        if (row.state !== "making" || row.designId === null)
+            return row;
+        const design = designView(db, row.designId);
+        const last = design?.steps.at(-1);
+        if (last?.state === "making")
+            return row;
+        const next = last === undefined || last.state === "failed" || design === undefined
+            ? {
+                ...row,
+                state: "failed",
+                heldReason: last?.error ?? "The sample's picture was lost. Press Make sample.",
+                updatedAt: at(),
+            }
+            : { ...row, state: "done", heldReason: null, updatedAt: at() };
+        writeSample(db, next);
+        return next;
+    };
+    const sweep = (templateId, keep) => {
+        for (const id of oldSamples(db, templateId, keep, startOfDay(now(), deps.timeZone()))) {
+            db.prepare("DELETE FROM designs WHERE id=?").run(id);
+            deleteRenders(deps.service.paths, id);
+        }
+    };
+    // Why a sample a Save asked for waits instead of starting: a CLI plan samples may not use, a
+    // price nobody knows, more than the person saw, or past today's budget counting what other
+    // samples already queued or making will cost. Undefined when it may start.
+    const holdOf = (templateId, quote, acknowledgedHigh) => {
+        const spent = sampleSpentToday(db, now(), deps.timeZone()) + sampleReserved(db, templateId);
+        const budget = deps.budget();
+        return quote.rows.some((one) => one.onPlan === true) && !deps.plans()
+            ? "Waiting: this sample's picture runs on your CLI plan, and samples may not use CLI plans. Turn on Samples may use my CLI plans in Settings → Template studio, or press Make sample to make it anyway."
+            : quote.unknown > 0
+                ? "Waiting: the price of this sample's picture isn't known, so Slopify didn't make it. Press Make sample to make it anyway."
+                : quote.high > holdSlack(acknowledgedHigh)
+                    ? `Waiting: this sample now costs about ${money(quote.high)}, more than the ${money(acknowledgedHigh)} you saw. Press Make sample (${money(quote.high)}) to make it.`
+                    : spent + quote.high > budget + 0.005
+                        ? budgetSentence(spent + quote.high, budget)
+                        : null;
+    };
+    // The templates whose queued sample the person started with Make sample: it starts on their
+    // say, without the Save's holds. In memory: after a restart it is checked again.
+    const pressed = new Set();
+    // Starts a queued job once the picture before it is done.
+    const start = (templateId) => {
+        const row = sampleRow(db, templateId);
+        if (row === undefined || row.state !== "queued")
+            return;
+        const current = row.designId === null ? undefined : designView(db, row.designId);
+        if (current?.steps.some((step) => step.state === "making") === true)
+            return;
+        const revision = templateRevision(db, templateId, row.version);
+        if (revision === undefined || getTemplate(db, templateId) === undefined)
+            return;
+        const asked = pressed.delete(templateId);
+        // What a Save queued may have waited behind another picture: checked again as it starts.
+        if (!asked) {
+            const held = holdOf(templateId, quoteDocument(deps.catalogue(), revision.document), row.quotedHigh ?? 0);
+            if (held !== null) {
+                writeSample(db, { ...row, state: "held", heldReason: held, updatedAt: at() });
+                emit(templateId);
+                return;
+            }
+        }
+        const made = makeFromTemplate(deps, templateId, {
+            mutationId: `sample-${deps.service.ids.next()}`,
+            values: revision.document.samples,
+            acknowledgedHigh: row.quotedHigh ?? 0,
+            // Checked just above, or accepted on Make sample.
+            acknowledgedUnknown: true,
+            version: row.version,
+        }, { sampleOf: templateId });
+        if (!made.ok) {
+            const held = made.reason === "cost-changed";
+            const missing = missingValues(revision.document, revision.document.samples);
+            writeSample(db, {
+                ...row,
+                state: held ? "held" : "failed",
+                heldReason: made.reason === "missing-values"
+                    ? `The sample wasn't made: ${missing.map((name) => `{{${name}}}`).join(", ")} ${missing.length === 1 ? "has" : "have"} no sample value. Fill ${missing.length === 1 ? "it" : "them"} in under Text layout → Sample values, then press Make sample.`
+                    : made.message,
+                updatedAt: at(),
+            });
+        }
+        else {
+            const making = made.value.steps.some((step) => step.state === "making");
+            writeSample(db, {
+                ...row,
+                designId: made.value.id,
+                state: making ? "making" : "done",
+                heldReason: null,
+                updatedAt: at(),
+            });
+            sweep(templateId, made.value.id);
+        }
+        emit(templateId);
+    };
+    const queue = (templateId, version, quote, held) => {
+        const before = sampleRow(db, templateId);
+        const row = {
+            templateId,
+            designId: before?.designId ?? null,
+            version,
+            state: held === null ? "queued" : "held",
+            heldReason: held,
+            quotedHigh: quote,
+            updatedAt: at(),
+        };
+        // A picture being made keeps its state until it lands; the queued job waits behind it.
+        writeSample(db, before?.state === "making" && held === null ? { ...row, state: "queued" } : row);
+        if (held === null)
+            start(templateId);
+        emit(templateId);
+        return view(sampleRow(db, templateId) ?? row);
+    };
+    // Text-only changes: the sample keeps its artwork and takes the new settings at once.
+    const redraw = (templateId, version, doc) => {
+        const row = sampleRow(db, templateId);
+        if (row === undefined)
+            return null;
+        transact(db, () => {
+            if (row.designId !== null)
+                db.prepare("UPDATE designs SET document_json=?, values_json=?, template_version=?, updated_at=? WHERE id=?").run(JSON.stringify(doc), JSON.stringify(doc.samples), version, at(), row.designId);
+            writeSample(db, { ...row, version, updatedAt: at() });
+        });
+        if (row.designId !== null)
+            deps.service.emit?.({ type: "design.changed", designId: row.designId });
+        emit(templateId);
+        return view(sampleRow(db, templateId) ?? row);
+    };
+    return {
+        afterSave: (input) => {
+            if (input.sample === "skip")
+                return { ok: true, value: current(input.templateId) };
+            const row = sampleRow(db, input.templateId);
+            const affected = designAffectedSections(input.before, input.after);
+            const hasArtwork = row?.designId != null && row.state !== "failed";
+            if (hasArtwork && !sampleNeedsPicture(affected))
+                return { ok: true, value: redraw(input.templateId, input.version, input.after) };
+            const quote = quoteDocument(deps.catalogue(), input.after);
+            const held = holdOf(input.templateId, quote, input.acknowledgedHigh);
+            pressed.delete(input.templateId);
+            return { ok: true, value: queue(input.templateId, input.version, quote.high, held) };
+        },
+        request: (templateId, version, acknowledgedHigh, acknowledgedUnknown = false) => {
+            const revision = templateRevision(db, templateId, version);
+            if (getTemplate(db, templateId) === undefined || revision === undefined)
+                return {
+                    ok: false,
+                    reason: "not-found",
+                    message: "That version of the template doesn't exist. Reload the template.",
+                };
+            const row = sampleRow(db, templateId);
+            if (row?.state === "making" && row.version === version)
+                return { ok: true, value: view(row) };
+            const quote = quoteDocument(deps.catalogue(), revision.document);
+            // The person's own press: the price they saw is the limit, unknown prices included.
+            if (costChanged(quote, acknowledgedHigh, acknowledgedUnknown))
+                return {
+                    ok: false,
+                    reason: "cost-changed",
+                    message: costChangedMessage(quote, "the sample"),
+                    current: quote,
+                };
+            pressed.add(templateId);
+            return { ok: true, value: queue(templateId, version, quote.high, null) };
+        },
+        state: (templateId) => current(templateId),
+        designChanged: (designId) => {
+            const row = sampleRowOfDesign(db, designId);
+            if (row === undefined)
+                return;
+            const settled = settle(row);
+            if (settled !== row)
+                emit(row.templateId);
+            start(row.templateId);
+        },
+        recover: () => {
+            for (const id of db
+                .prepare("SELECT template_id FROM design_template_samples WHERE state='making'")
+                .all()
+                .map((row) => String(row.template_id))) {
+                const row = sampleRow(db, id);
+                if (row !== undefined)
+                    settle(row);
+            }
+            for (const id of queuedTemplates(db))
+                start(id);
+        },
+    };
+    function current(templateId) {
+        const row = sampleRow(db, templateId);
+        return row === undefined ? null : view(settle(row));
+    }
+}

package/dist/slices/designs/schema.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { documentSettingsSchema } from "../document/theme-schema.js";
+import { blockRoles, blocksMax, blockTextMax, castPerDesignMax, daysBeforeMax, designFormats, layoutPresets, promptMax, scrims, } from "./model.js";
+// A designed piece's settings, the same for a one-off design and a design template. Pure and
+// browser-safe, so the web page validates with the server's own schema. Text may hold fields
+// ({{Event}}), filled from the design's values when it is drawn.
+const fontId = z.string().regex(/^(?:default|(?:system|uploaded)-[a-f0-9]{64})$/);
+const hexColor = z.string().regex(/^#[0-9A-Fa-f]{6}$/);
+const unit = z.number().min(0).max(1);
+export const designPictureSchema = z
+    .object({
+    // "generate": the AI draws the artwork from `prompt`. "picture": the design's own picture
+    // (an upload or an edit's result) is the artwork as it is.
+    source: z.enum(["generate", "picture"]),
+    prompt: z.string().max(promptMax),
+    // A template's fixed picture, kept in image_blobs.
+    sha256: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/)
+        .optional(),
+    castMemberIds: z.array(z.string().min(1).max(64)).max(castPerDesignMax),
+    provider: z.string().min(1).max(64),
+    model: z.string().min(1).max(200),
+    // The AI draws the text into the artwork itself; Slopify's text layer is then off.
+    aiText: z.boolean(),
+})
+    .strict();
+export const textBlockSchema = z
+    .object({
+    id: z.string().min(1).max(64),
+    role: z.enum(blockRoles),
+    text: z.string().max(blockTextMax),
+    fontId,
+    color: hexColor,
+})
+    .strict();
+export const designTextSchema = z
+    .object({
+    preset: z.enum(layoutPresets),
+    scrim: z.enum(scrims),
+    blocks: z.array(textBlockSchema).max(blocksMax),
+})
+    .strict()
+    .refine((text) => new Set(text.blocks.map((block) => block.id)).size === text.blocks.length, {
+    message: "Two text blocks share an id.",
+});
+export const designFormatSchema = z
+    .object({ format: z.enum(designFormats), focus: z.object({ x: unit, y: unit }).strict() })
+    .strict();
+export const brochureSchema = z
+    .object({
+    settings: documentSettingsSchema,
+    title: z.string().min(1).max(200),
+    // The inner pages, as markdown with fields. Written by the person, not the AI, in v1.
+    body: z.string().min(1).max(100_000),
+})
+    .strict();
+export const designScheduleSchema = z
+    .object({
+    // The field holding each row's date, typed YYYY-MM-DD.
+    dateField: z.string().min(1).max(100),
+    daysBefore: z.number().int().min(0).max(daysBeforeMax),
+    time: z.string().regex(/^(?:[01]\d|2[0-3]):[0-5]\d$/),
+})
+    .strict();
+export const designDocumentSchema = z
+    .object({
+    version: z.literal(1),
+    picture: designPictureSchema,
+    text: designTextSchema,
+    formats: z
+        .array(designFormatSchema)
+        .min(1)
+        .max(designFormats.length)
+        .refine((formats) => new Set(formats.map((one) => one.format)).size === formats.length, {
+        message: "A format is listed twice.",
+    }),
+    brochure: brochureSchema.optional(),
+    schedule: designScheduleSchema.optional(),
+    // Example values the template editor's sample is drawn with.
+    samples: z.record(z.string().min(1).max(100), z.string().max(2000)),
+})
+    .strict()
+    .refine((doc) => doc.formats.some((one) => one.format === "brochure") === (doc.brochure !== undefined), {
+    message: "A brochure needs its pages: add the brochure's title and text under Formats, or untick Brochure.",
+    path: ["brochure"],
+});

package/dist/slices/designs/sections.js

@@ -0,0 +1,44 @@
+import { detectSlots } from "../admission/substitute.js";
+// The design template editor's sections, and which ones a Save changed. Pure and browser-safe:
+// the page shows the cost on Save only when the Picture changed, because that is the only
+// section whose sample is paid (one artwork); text, formats and the schedule redraw for free.
+export const designSections = [
+    { id: "picture", label: "Picture" },
+    { id: "text", label: "Text layout" },
+    { id: "formats", label: "Formats" },
+    { id: "schedule", label: "Schedule" },
+];
+// Every key of the document belongs to one section; a new key must be added here, which the
+// test that walks the schema's keys enforces.
+export const sectionOfKey = {
+    version: null,
+    picture: "picture",
+    text: "text",
+    samples: "text",
+    formats: "formats",
+    brochure: "formats",
+    schedule: "schedule",
+};
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+export function designAffectedSections(before, after) {
+    const changed = new Set();
+    for (const key of Object.keys(sectionOfKey)) {
+        const section = sectionOfKey[key];
+        if (section !== null && !same(before[key], after[key]))
+            changed.add(section);
+    }
+    // The artwork's prompt is filled from the sample values, so a changed sample that the
+    // prompt uses changes the picture too.
+    if (!same(before.samples, after.samples) && promptUsesChangedSample(before, after))
+        changed.add("picture");
+    return designSections.map((section) => section.id).filter((id) => changed.has(id));
+}
+function promptUsesChangedSample(before, after) {
+    if (after.picture.source !== "generate")
+        return false;
+    return detectSlots(after.picture.prompt).names.some((name) => before.samples[name] !== after.samples[name]);
+}
+// Whether a Save with these changes makes a paid picture for the sample.
+export function sampleNeedsPicture(affected) {
+    return affected.includes("picture");
+}