@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/slices/designs/picture-size.js

@@ -0,0 +1,79 @@
+// The width and height a PNG's IHDR or a JPEG's start-of-frame states; undefined for anything
+// truncated or not one of the two.
+export function pictureSize(bytes) {
+    const size = bytes[0] === 0x89 && bytes[1] === 0x50
+        ? pngSize(bytes)
+        : bytes[0] === 0xff
+            ? jpegSize(bytes)
+            : undefined;
+    return size !== undefined && size.width > 0 && size.height > 0 ? size : undefined;
+}
+function pngSize(bytes) {
+    if (bytes.length < 24)
+        return undefined;
+    const ihdr = String.fromCharCode(...bytes.subarray(12, 16));
+    if (ihdr !== "IHDR")
+        return undefined;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return { width: view.getUint32(16), height: view.getUint32(20) };
+}
+// Markers that carry no length: start of image, TEM and the restart markers.
+const standalone = (marker) => marker === 0xd8 || marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7);
+// Every SOFn except DHT (C4), JPG (C8) and DAC (CC), which share the range.
+const startOfFrame = (marker) => marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc;
+function jpegSize(bytes) {
+    if (bytes[1] !== 0xd8)
+        return undefined;
+    let at = 2;
+    while (at + 1 < bytes.length) {
+        if (bytes[at] !== 0xff)
+            return undefined;
+        let marker = bytes[at + 1] ?? 0;
+        while (marker === 0xff && at + 2 < bytes.length) {
+            at += 1;
+            marker = bytes[at + 1] ?? 0;
+        }
+        if (standalone(marker)) {
+            at += 2;
+            continue;
+        }
+        // End of image or start of scan before any frame: no size to read.
+        if (marker === 0xd9 || marker === 0xda)
+            return undefined;
+        if (at + 3 >= bytes.length)
+            return undefined;
+        const length = ((bytes[at + 2] ?? 0) << 8) | (bytes[at + 3] ?? 0);
+        if (length < 2)
+            return undefined;
+        if (startOfFrame(marker)) {
+            if (at + 8 >= bytes.length || length < 7)
+                return undefined;
+            return {
+                height: ((bytes[at + 5] ?? 0) << 8) | (bytes[at + 6] ?? 0),
+                width: ((bytes[at + 7] ?? 0) << 8) | (bytes[at + 8] ?? 0),
+            };
+        }
+        at += 2 + length;
+    }
+    return undefined;
+}
+const shapes = [
+    { format: "16:9", ratio: 16 / 9 },
+    { format: "1:1", ratio: 1 },
+    { format: "9:16", ratio: 9 / 16 },
+];
+// The provider shape closest to the picture's, measured on a log scale so 2:1 and 1:2 are
+// equally far from square.
+export function nearestFormat(size) {
+    const ratio = Math.log(size.width / size.height);
+    let best = { format: "1:1", ratio: 1 };
+    let distance = Number.POSITIVE_INFINITY;
+    for (const shape of shapes) {
+        const d = Math.abs(Math.log(shape.ratio) - ratio);
+        if (d < distance) {
+            best = shape;
+            distance = d;
+        }
+    }
+    return best.format;
+}

package/dist/slices/designs/pictures.js

@@ -0,0 +1,55 @@
+import { readFileSync } from "node:fs";
+import { castImageMaxBytes, sniffImage } from "../channels/images.js";
+import { imageBlob } from "../channels/repo.js";
+import { stagingPath } from "../storage/layout.js";
+import { stagedFileById } from "../storage/repo.js";
+import { pictureSize } from "./picture-size.js";
+export function readPicture(bytes) {
+    if (bytes.byteLength > castImageMaxBytes)
+        return {
+            ok: false,
+            reason: "not-an-image",
+            message: `This picture is larger than ${String(castImageMaxBytes / 1024 / 1024)} MB. Save it smaller (for example as a JPEG) and upload it again.`,
+        };
+    const mime = sniffImage(bytes);
+    const size = mime === undefined ? undefined : pictureSize(bytes);
+    if (mime === undefined || size === undefined)
+        return {
+            ok: false,
+            reason: "not-an-image",
+            message: "This file is not a PNG or JPEG picture Slopify can read. Upload a PNG or JPEG file.",
+        };
+    return { ok: true, value: { bytes, mime, ...size } };
+}
+export function startingPicture(deps, input) {
+    if (input.stagedFileId !== undefined) {
+        const staged = stagedFileById(deps.db, input.stagedFileId);
+        if (staged === undefined)
+            return {
+                ok: false,
+                reason: "upload-gone",
+                message: "The uploaded picture is gone. Upload it again.",
+            };
+        if (staged.state !== "staged")
+            return {
+                ok: false,
+                reason: "still-uploading",
+                message: "The picture is still uploading. Wait for it to finish, then try again.",
+            };
+        if (staged.bytes > castImageMaxBytes)
+            return readPicture(new Uint8Array(castImageMaxBytes + 1));
+        const read = readPicture(new Uint8Array(readFileSync(stagingPath(deps.paths, staged.path))));
+        return read.ok ? { ok: true, value: { ...read.value, stagedId: staged.id } } : read;
+    }
+    if (input.fromStepSha !== undefined) {
+        const blob = imageBlob(deps.db, input.fromStepSha);
+        if (blob === undefined)
+            return {
+                ok: false,
+                reason: "not-found",
+                message: "That picture is no longer kept. Choose another version, or upload the picture again.",
+            };
+        return readPicture(blob.bytes);
+    }
+    return { ok: true, value: undefined };
+}

package/dist/slices/designs/quote.js

@@ -0,0 +1,24 @@
+import { estimateRequests } from "../estimate/requests.js";
+// What one paid picture of a design costs: an edit (which sends pictures, so its price is a
+// range) or the artwork. Quoting records nothing.
+export function quoteDesignImage(catalogue, request) {
+    return estimateRequests([
+        {
+            kind: "image",
+            provider: request.provider,
+            model: request.model,
+            stage: request.purpose === "picture-edit" ? "Picture edit" : "Artwork",
+            variable: request.sendsPictures,
+        },
+    ], catalogue);
+}
+// A paid step starts only when what it costs now is no more than what the person was shown,
+// give or take half a cent of rounding, and a price nobody knows only once they accepted that.
+export function costChanged(quote, acknowledgedHigh, acknowledgedUnknown = false) {
+    return quote.high > acknowledgedHigh + 0.005 || (quote.unknown > 0 && !acknowledgedUnknown);
+}
+export function costChangedMessage(quote, what) {
+    if (quote.unknown > 0)
+        return `The price changed since you looked: ${what} has no known price now, so nothing was started. Check the button, which says the price is unknown, and press it again to make it anyway.`;
+    return `The price changed since you looked: ${what} now costs up to $${quote.high.toFixed(2)}. Check the new price on the button and press it again.`;
+}

package/dist/slices/designs/render-args.js

@@ -0,0 +1,36 @@
+// The ffmpeg arguments that draw a piece and shrink a picture.
+export function renderArgs(input) {
+    const { crop, frame } = input;
+    const chain = [
+        `scale=${String(crop.scaleWidth)}:${String(crop.scaleHeight)}:flags=lanczos`,
+        `crop=${String(frame.width)}:${String(frame.height)}:${String(crop.x)}:${String(crop.y)}`,
+        ...(input.text ? ["ass=filename=design.ass:fontsdir=fonts"] : []),
+        "format=rgb24",
+    ];
+    return [
+        ...["-hide_banner", "-nostdin", "-loglevel", "error", "-y", "-i", input.art],
+        ...[
+            "-filter_complex",
+            `[0:v]${chain.join(",")}[v]`,
+            "-map",
+            "[v]",
+            "-frames:v",
+            "1",
+            input.output,
+        ],
+    ];
+}
+// What a picture is shrunk to before it is sent to a provider again: at most 4096 pixels on
+// its long side, as a JPEG.
+export function shrinkArgs(input, output) {
+    return [
+        ...["-hide_banner", "-nostdin", "-loglevel", "error", "-y", "-i", input],
+        ...[
+            "-vf",
+            "scale=w='min(iw,4096)':h='min(ih,4096)':force_original_aspect_ratio=decrease",
+            "-q:v",
+            "3",
+            output,
+        ],
+    ];
+}

package/dist/slices/designs/render-input.js

@@ -0,0 +1,59 @@
+import { imageBlob } from "../channels/repo.js";
+import { fillDocument, missingSentence, missingValues } from "./fields.js";
+import { formatLabels } from "./model.js";
+import { designDocumentSchema } from "./schema.js";
+import { designView } from "./service.js";
+export function prepare(db, designId, format) {
+    const design = designView(db, designId);
+    if (design === undefined)
+        return {
+            ok: false,
+            reason: "not-found",
+            message: "This design no longer exists. Open Library → Designs to choose another.",
+        };
+    const parsed = designDocumentSchema.safeParse(design.document);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid",
+            message: "This picture has no formats yet. Press Turn into a designed piece to add text and formats, or download the picture itself.",
+        };
+    if (!parsed.data.formats.some((one) => one.format === format))
+        return {
+            ok: false,
+            reason: "invalid",
+            message: `${formatLabels[format]} isn't ticked for this design. Tick it under Formats, then download again.`,
+        };
+    const head = design.steps.find((step) => step.id === design.headStepId);
+    const blob = head === undefined || head.sha256 === null ? undefined : imageBlob(db, head.sha256);
+    if (head === undefined ||
+        blob === undefined ||
+        head.width === null ||
+        head.height === null ||
+        head.sha256 === null)
+        return {
+            ok: false,
+            reason: "not-ready",
+            message: "This design has no artwork yet. Press Make to draw it, then download again.",
+        };
+    const missing = missingValues({ ...parsed.data, picture: { ...parsed.data.picture, prompt: "" } }, design.values);
+    if (missing.length > 0)
+        return { ok: false, reason: "missing-values", message: missingSentence(missing) };
+    return {
+        ok: true,
+        value: {
+            doc: parsed.data,
+            values: design.values,
+            art: { ...blob, width: head.width, height: head.height, sha256: head.sha256 },
+        },
+    };
+}
+export function fileName(doc, values, format) {
+    const headline = fillDocument(doc, values).text.blocks.find((block) => block.text.trim() !== "")?.text ??
+        "design";
+    const safe = headline
+        .replace(/[^\p{L}\p{N}]+/gu, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 60) || "design";
+    return `${safe}-${format}`;
+}

package/dist/slices/designs/render.js

@@ -0,0 +1,215 @@
+import { createHash } from "node:crypto";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { errorText } from "../../kernel/errors.js";
+import { fontAdvances } from "../fonts/sfnt.js";
+import { checkText } from "./check-text.js";
+import { fillDocument } from "./fields.js";
+import { coverCrop, frames } from "./frames.js";
+import { layoutText } from "./layout.js";
+import { formatLabels } from "./model.js";
+import { renderArgs, shrinkArgs } from "./render-args.js";
+import { fileName, prepare } from "./render-input.js";
+// A finished piece, drawn on demand: the artwork cover-cropped to the format's frame and the
+// text layer set over it by libass, in a child ffmpeg (never this thread); print formats then
+// go to the PDF worker. One render at a time. Files are a cache under the data dir, named by
+// the design and a hash of everything drawn, so the same piece is drawn once; they are never
+// backed up and are deleted with the design.
+// 2: text measured with the font's own widths.
+export const rendererVersion = 2;
+export const rendersDir = (paths) => join(paths.dataDir, "design-renders");
+export function createDesignRenderer(deps) {
+    let queue = Promise.resolve();
+    const oneAtATime = (work) => {
+        const next = queue.then(work, work);
+        queue = next.catch(() => undefined);
+        return next;
+    };
+    const png = async (prepared, designId, format, signal) => {
+        const { doc, art, values } = prepared;
+        const frame = frames[format];
+        const entry = doc.formats.find((one) => one.format === format);
+        const focus = entry?.focus ?? { x: 0.5, y: 0.5 };
+        const textLayer = !doc.picture.aiText;
+        const fontIds = textLayer ? [...new Set(doc.text.blocks.map((block) => block.fontId))] : [];
+        const fonts = new Map();
+        for (const id of fontIds) {
+            try {
+                fonts.set(id, await deps.font(id));
+            }
+            catch (error) {
+                deps.log.write("warn", "designs.render.font", {
+                    detail: `${designId}: ${errorText(error)}`,
+                });
+            }
+        }
+        const filled = fillDocument(doc, values);
+        const key = createHash("sha256")
+            .update(JSON.stringify({
+            rendererVersion,
+            art: art.sha256,
+            format,
+            focus,
+            text: textLayer ? filled.text : null,
+            fonts: [...fonts].map(([id, font]) => [id, font.path, font.faceIndex]),
+        }))
+            .digest("hex")
+            .slice(0, 32);
+        const dir = join(rendersDir(deps.paths), designId);
+        const target = join(dir, `${format}-${key}.png`);
+        // Drawn before from the very same text, fonts and artwork, so it passed the checks then.
+        if (existsSync(target))
+            return { ok: true, value: target };
+        const checkFonts = {};
+        for (const [id, font] of fonts)
+            checkFonts[id] = {
+                name: font.name,
+                bytes: new Uint8Array(await readFile(font.path)),
+                faceIndex: font.faceIndex,
+            };
+        // Measured with the font's own widths; a font that can't be read is estimated.
+        const layoutFonts = Object.fromEntries([...fonts].map(([id, font]) => {
+            const bytes = checkFonts[id]?.bytes;
+            const advance = bytes === undefined ? undefined : fontAdvances(bytes, font.faceIndex);
+            return [id, { assName: font.assName, advance }];
+        }));
+        const layout = layoutText(frame, doc.text, values, layoutFonts);
+        if (textLayer) {
+            const problem = checkText({
+                text: doc.text,
+                values,
+                layout,
+                fonts: checkFonts,
+                formatLabel: formatLabels[format],
+            })[0];
+            if (problem !== undefined)
+                return { ok: false, reason: "invalid", message: problem.sentence };
+        }
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const work = mkdtempSync(join(dir, ".work-"));
+        try {
+            const artName = art.mime === "image/jpeg" ? "art.jpg" : "art.png";
+            writeFileSync(join(work, artName), art.bytes, { mode: 0o600 });
+            if (textLayer) {
+                mkdirSync(join(work, "fonts"), { mode: 0o700 });
+                for (const [index, font] of [...fonts.values()].entries())
+                    copyFileSync(font.path, join(work, "fonts", `font-${String(index)}${font.extension}`));
+                writeFileSync(join(work, "design.ass"), layout.ass, { mode: 0o600 });
+            }
+            await deps.runFfmpeg({
+                bin: deps.ffmpeg,
+                cwd: work,
+                args: renderArgs({
+                    art: artName,
+                    crop: coverCrop(art, frame, focus),
+                    frame,
+                    text: textLayer,
+                    output: "out.png",
+                }),
+                signal,
+                log: deps.log,
+                onProgress: () => undefined,
+            });
+            renameSync(join(work, "out.png"), target);
+            dropOlderDrawings(dir, format, target);
+            return { ok: true, value: target };
+        }
+        finally {
+            rmSync(work, { recursive: true, force: true });
+        }
+    };
+    return {
+        shrink: (bytes, signal) => oneAtATime(async () => {
+            const dir = rendersDir(deps.paths);
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+            const work = mkdtempSync(join(dir, ".work-"));
+            try {
+                writeFileSync(join(work, "in"), bytes, { mode: 0o600 });
+                await deps.runFfmpeg({
+                    bin: deps.ffmpeg,
+                    cwd: work,
+                    args: shrinkArgs("in", "out.jpg"),
+                    signal,
+                    log: deps.log,
+                    onProgress: () => undefined,
+                });
+                return new Uint8Array(readFileSync(join(work, "out.jpg")));
+            }
+            finally {
+                rmSync(work, { recursive: true, force: true });
+            }
+        }),
+        render: (designId, format, type, signal) => oneAtATime(async () => {
+            const prepared = prepare(deps.db, designId, format);
+            if (!prepared.ok)
+                return prepared;
+            const frame = frames[format];
+            if (type === "pdf" && frame.pdf === undefined)
+                return {
+                    ok: false,
+                    reason: "invalid",
+                    message: `${formatLabels[format]} is a screen size, so it downloads as a PNG. Press Download PNG.`,
+                };
+            if (type === "png" && format === "brochure")
+                return {
+                    ok: false,
+                    reason: "invalid",
+                    message: "A brochure downloads as a PDF. Press Download PDF.",
+                };
+            const drawn = await png(prepared.value, designId, format, signal);
+            if (!drawn.ok)
+                return drawn;
+            const name = fileName(prepared.value.doc, prepared.value.values, format);
+            if (type === "png")
+                return { ok: true, value: { path: drawn.value, mime: "image/png", name: `${name}.png` } };
+            const pdfPath = drawn.value.replace(/\.png$/, ".pdf");
+            if (!existsSync(pdfPath)) {
+                if (deps.pdf === undefined)
+                    throw new Error("design PDFs need the PDF worker");
+                const page = frame.pdf;
+                const filled = fillDocument(prepared.value.doc, prepared.value.values);
+                const bytes = await deps.pdf(format === "brochure" && filled.brochure !== undefined
+                    ? {
+                        kind: "brochure",
+                        cover: new Uint8Array(readFileSync(drawn.value)),
+                        title: filled.brochure.title,
+                        markdown: filled.brochure.body,
+                        settings: filled.brochure.settings,
+                        writtenOn: deps.clock.now().toISOString(),
+                    }
+                    : {
+                        kind: "poster",
+                        png: new Uint8Array(readFileSync(drawn.value)),
+                        widthMm: page?.widthMm ?? 210,
+                        heightMm: page?.heightMm ?? 297,
+                    }, signal);
+                const partial = `${pdfPath}.part`;
+                writeFileSync(partial, bytes, { mode: 0o600 });
+                renameSync(partial, pdfPath);
+            }
+            return { ok: true, value: { path: pdfPath, mime: "application/pdf", name: `${name}.pdf` } };
+        }),
+    };
+}
+// What this format looked like before its newest drawing (PNG and PDF): nothing asks for those
+// again, so the cache holds one drawing per format.
+function dropOlderDrawings(dir, format, target) {
+    const keep = basename(target, ".png");
+    const drawing = new RegExp(`^(${format}-[a-f0-9]{32})\\.(png|pdf)$`);
+    for (const name of readdirSync(dir)) {
+        const stem = drawing.exec(name)?.[1];
+        if (stem !== undefined && stem !== keep)
+            rmSync(join(dir, name), { force: true });
+    }
+}
+// Every drawn file of a design, removed when it is purged. Design ids are letters, digits,
+// dashes and underscores (`requests.ts`), so one is always a single folder name.
+export function deleteRenders(paths, designId) {
+    const dir = join(rendersDir(paths), designId);
+    if (!/^[A-Za-z0-9_-]+$/.test(designId) || !existsSync(dir))
+        return 0;
+    const count = readdirSync(dir).length;
+    rmSync(dir, { recursive: true, force: true });
+    return count;
+}

package/dist/slices/designs/repo.js

@@ -0,0 +1,101 @@
+import { z } from "zod";
+import { designKinds } from "./model.js";
+// Rows of `designs` (migration 0070). Every list leaves out deleted designs
+// and the hidden samples a design template's editor redraws (`sample_of`).
+const designRow = z.object({
+    id: z.string(),
+    kind: z.enum(designKinds),
+    name: z.string(),
+    channel_id: z.string(),
+    project_id: z.string().nullable(),
+    template_id: z.string().nullable(),
+    template_version: z.number().nullable(),
+    schedule_id: z.string().nullable(),
+    schedule_run_id: z.string().nullable(),
+    document_json: z.string().nullable(),
+    values_json: z.string(),
+    head_step_id: z.string().nullable(),
+    sample_of: z.string().nullable(),
+    created_at: z.string(),
+    updated_at: z.string(),
+    deleted_at: z.string().nullable(),
+});
+const valuesSchema = z.record(z.string(), z.string());
+export const notDesignSample = "sample_of IS NULL";
+function toDesign(raw) {
+    const row = designRow.parse(raw);
+    return {
+        id: row.id,
+        kind: row.kind,
+        name: row.name,
+        channelId: row.channel_id,
+        projectId: row.project_id,
+        templateId: row.template_id,
+        templateVersion: row.template_version,
+        scheduleId: row.schedule_id,
+        scheduleRunId: row.schedule_run_id,
+        document: row.document_json === null ? null : JSON.parse(row.document_json),
+        values: valuesSchema.catch({}).parse(JSON.parse(row.values_json)),
+        headStepId: row.head_step_id,
+        sampleOf: row.sample_of,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        deletedAt: row.deleted_at,
+    };
+}
+export function insertDesign(db, row) {
+    db.prepare(`INSERT INTO designs (id,kind,name,channel_id,project_id,template_id,template_version,schedule_id,schedule_run_id,document_json,values_json,sample_of,mutation_id,mutation_hash,created_at,updated_at)
+     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(row.id, row.kind, row.name, row.channelId, row.projectId, row.templateId ?? null, row.templateVersion ?? null, row.scheduleId ?? null, row.scheduleRunId ?? null, row.document === null || row.document === undefined ? null : JSON.stringify(row.document), JSON.stringify(row.values), row.sampleOf ?? null, row.mutationId, row.mutationHash, row.at, row.at);
+}
+// Deleted designs included: the trash and a mutation replay read them too.
+export function designById(db, id) {
+    const row = db.prepare("SELECT * FROM designs WHERE id=?").get(id);
+    return row === undefined ? undefined : toDesign(row);
+}
+export function designByMutation(db, mutationId) {
+    const row = db.prepare("SELECT * FROM designs WHERE mutation_id=?").get(mutationId);
+    return row === undefined
+        ? undefined
+        : {
+            design: toDesign(row),
+            hash: row.mutation_hash === null ? null : String(row.mutation_hash),
+        };
+}
+export function listDesigns(db, filter = {}) {
+    const where = [`deleted_at IS NULL`, notDesignSample];
+    const params = [];
+    if (filter.projectId !== undefined) {
+        where.push("project_id=?");
+        params.push(filter.projectId);
+    }
+    return db
+        .prepare(`SELECT * FROM designs WHERE ${where.join(" AND ")} ORDER BY updated_at DESC, id`)
+        .all(...params)
+        .map(toDesign);
+}
+// Only when the row still has `baseUpdatedAt`; false when someone changed it meanwhile.
+export function updateDesign(db, id, baseUpdatedAt, changes, at) {
+    const sets = ["updated_at=?"];
+    const params = [at];
+    const set = (column, value) => {
+        sets.push(`${column}=?`);
+        params.push(value);
+    };
+    if (changes.name !== undefined)
+        set("name", changes.name);
+    if (changes.kind !== undefined)
+        set("kind", changes.kind);
+    if (changes.projectId !== undefined)
+        set("project_id", changes.projectId);
+    if (changes.document !== undefined)
+        set("document_json", JSON.stringify(changes.document));
+    if (changes.values !== undefined)
+        set("values_json", JSON.stringify(changes.values));
+    if (changes.headStepId !== undefined)
+        set("head_step_id", changes.headStepId);
+    const guard = baseUpdatedAt === undefined ? "" : " AND updated_at=?";
+    const result = db
+        .prepare(`UPDATE designs SET ${sets.join(",")} WHERE id=? AND deleted_at IS NULL${guard}`)
+        .run(...params, id, ...(baseUpdatedAt === undefined ? [] : [baseUpdatedAt]));
+    return Number(result.changes) > 0;
+}

package/dist/slices/designs/requests.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { castPerDesignMax, designKinds, designNameMax, instructionMax } from "./model.js";
+import { designDocumentSchema } from "./schema.js";
+// What the design routes and tools take. Browser-safe, like schema.ts.
+// Letters, digits, dashes and underscores: a design id names its folder of drawn files.
+const id = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[A-Za-z0-9_-]+$/);
+const mutationId = z.string().min(8).max(128);
+const sha256 = z.string().regex(/^[a-f0-9]{64}$/);
+export const designValuesSchema = z
+    .record(z.string().min(1).max(100), z.string().max(2000))
+    .refine((values) => Object.keys(values).length <= 100, {
+    message: "A design has at most 100 fields.",
+});
+export const createDesignSchema = z
+    .object({
+    id,
+    mutationId,
+    kind: z.enum(designKinds),
+    name: z.string().trim().min(1).max(designNameMax),
+    channelId: id.optional(),
+    projectId: id.optional(),
+    // The picture to start from: an upload, or a version another design already has.
+    stagedFileId: id.optional(),
+    fromStepSha: sha256.optional(),
+    document: designDocumentSchema.optional(),
+    values: designValuesSchema.optional(),
+})
+    .strict()
+    .refine((input) => input.stagedFileId === undefined || input.fromStepSha === undefined, {
+    message: "Start from an upload or from an earlier version, not both.",
+});
+export const updateDesignSchema = z
+    .object({
+    baseUpdatedAt: z.string().min(1).max(64),
+    name: z.string().trim().min(1).max(designNameMax).optional(),
+    projectId: id.nullable().optional(),
+    document: designDocumentSchema.optional(),
+    values: designValuesSchema.optional(),
+})
+    .strict();
+export const quoteEditSchema = z
+    .object({
+    provider: z.string().min(1).max(64),
+    model: z.string().min(1).max(200),
+    castMemberIds: z.array(id).max(castPerDesignMax).optional(),
+})
+    .strict();
+export const editPictureSchema = z
+    .object({
+    mutationId,
+    fromStepId: id,
+    instruction: z.string().trim().min(1).max(instructionMax),
+    provider: z.string().min(1).max(64),
+    model: z.string().min(1).max(200),
+    castMemberIds: z.array(id).max(castPerDesignMax).optional(),
+    // The highest cost the person saw on the button, in dollars; 0 for plan usage.
+    acknowledgedHigh: z.number().min(0).max(1000),
+    // That the button said the price is unknown, and the person pressed it anyway.
+    acknowledgedUnknown: z.boolean().optional(),
+})
+    .strict();
+export const makeArtworkSchema = z
+    .object({
+    mutationId,
+    acknowledgedHigh: z.number().min(0).max(1000),
+    acknowledgedUnknown: z.boolean().optional(),
+})
+    .strict();
+// Try again asks the provider again, which is paid again: at the price the button showed.
+export const retryStepSchema = z
+    .object({
+    acknowledgedHigh: z.number().min(0).max(1000),
+    acknowledgedUnknown: z.boolean().optional(),
+})
+    .strict();
+export const setHeadSchema = z.object({ stepId: id }).strict();