@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/slices/designs/layout.js

@@ -0,0 +1,293 @@
+import { render } from "../admission/substitute.js";
+import { assColour, assText } from "../video/ass-text.js";
+export const minTextShare = 0.024;
+const roleShare = {
+    headline: 0.11,
+    subhead: 0.06,
+    details: 0.045,
+    small: 0.03,
+};
+const lineSpacing = 1.2;
+const maxFilled = 10_000;
+const blockGap = 0.45;
+// Average advance per em: about half for mixed case, more for capitals.
+export function advanceOf(text) {
+    const letters = [...text].filter((ch) => /\p{L}/u.test(ch));
+    const upper = letters.filter((ch) => ch !== ch.toLowerCase()).length;
+    return letters.length > 0 && upper / letters.length > 0.6 ? 0.68 : 0.56;
+}
+export function estimatedWidth(text, size) {
+    return [...text].length * size * advanceOf(text);
+}
+// What a line takes on the frame: the font's advances when known, plus room for the outline.
+export function measuredWidth(text, size, font) {
+    const advance = font?.advance;
+    if (advance === undefined)
+        return estimatedWidth(text, size);
+    const guess = advanceOf(text);
+    let em = 0;
+    for (const ch of text)
+        em += advance(ch.codePointAt(0) ?? 0) ?? guess;
+    return em * size * 1.02 + size * 0.08;
+}
+export function safeArea(frame, preset) {
+    const { width, height } = frame;
+    const margin = Math.round(Math.min(width, height) * 0.06);
+    switch (preset) {
+        case "top-title":
+            return {
+                x: margin,
+                y: margin,
+                width: width - margin * 2,
+                height: Math.round(height * 0.45) - margin,
+            };
+        case "bottom-band": {
+            const top = Math.round(height * 0.62);
+            return { x: margin, y: top, width: width - margin * 2, height: height - top - margin };
+        }
+        case "centered":
+            return { x: margin, y: margin, width: width - margin * 2, height: height - margin * 2 };
+        case "left-column":
+            return {
+                x: margin,
+                y: margin,
+                width: Math.round(width * 0.5) - margin,
+                height: height - margin * 2,
+            };
+    }
+}
+// A word this short is never cut: it moves to its own line, and the text shrinks if even that
+// is too wide.
+const shortWord = 8;
+const numeric = /\p{N}/u;
+// A currency or code written before the number ("CHF 15", "€ 12"), and a unit after it
+// ("20:00 Uhr", "15 €", "5 km").
+const unitBefore = /^(?:\p{Sc}{1,3}|\p{Lu}{2,4}\.?)$/u;
+const unitAfter = /^[\p{L}\p{Sc}%°]{1,4}[.,;:!?]?$/u;
+// The words that must stay on one line: a number with the unit or currency beside it.
+export function wrapUnits(text) {
+    const words = text.split(/\s+/).filter((part) => part !== "");
+    const units = [];
+    for (const word of words) {
+        const last = units.at(-1);
+        const previous = last?.at(-1);
+        const open = last !== undefined && last.length === 1 && previous !== undefined;
+        const joins = open &&
+            ((numeric.test(previous) && !numeric.test(word) && unitAfter.test(word)) ||
+                (numeric.test(word) && !numeric.test(previous) && unitBefore.test(previous)));
+        if (joins)
+            last.push(word);
+        else
+            units.push([word]);
+    }
+    return units.map((unit) => unit.join(" "));
+}
+// Greedy wrap by width. A long word wider than the line is broken, so nothing leaves the area
+// sideways; a short word or a number with its unit is kept whole (the caller shrinks the text),
+// and only `split` (at the smallest size) lets a unit go across two lines.
+export function wrapText(text, size, room, font, split = false) {
+    const lines = [];
+    let line = "";
+    const fits = (candidate) => measuredWidth(candidate, size, font) <= room;
+    const pieces = wrapUnits(text).flatMap((unit) => split && !fits(unit) ? unit.split(" ") : [unit]);
+    for (const word of pieces) {
+        const candidate = line === "" ? word : `${line} ${word}`;
+        if (fits(candidate)) {
+            line = candidate;
+            continue;
+        }
+        if (line !== "")
+            lines.push(line);
+        line = "";
+        if ([...word].length <= shortWord || word.includes(" ")) {
+            line = word;
+            continue;
+        }
+        const cuts = cutWord([...word], size, room, font);
+        lines.push(...cuts.slice(0, -1));
+        line = cuts.at(-1) ?? "";
+    }
+    if (line !== "")
+        lines.push(line);
+    return lines;
+}
+// A word too wide for the line, cut into pieces that each take the longest run of characters
+// that fits (at least one). Each character's advance has a lowest and highest share (an
+// unknown one is guessed between `advanceOf`'s two figures), so running sums rule most cut
+// points in or out at once and only the few in between are measured exactly: the result is
+// what measuring every cut point would give, without the time that takes on a long URL.
+function cutWord(chars, size, room, font) {
+    const advance = font?.advance;
+    const low = [0];
+    const high = [0];
+    for (const ch of chars) {
+        const known = advance?.(ch.codePointAt(0) ?? 0);
+        if (known !== undefined && !(known >= 0))
+            return cutWordSlowly(chars, size, room, font);
+        low.push((low.at(-1) ?? 0) + (known ?? 0.56));
+        high.push((high.at(-1) ?? 0) + (known ?? 0.68));
+    }
+    const width = (em) => advance === undefined ? em * size : em * size * 1.02 + size * 0.08;
+    const slack = 1e-6 * (Math.abs(room) + size);
+    const lowAt = (from, to) => width((low[to] ?? 0) - (low[from] ?? 0));
+    const fitsRun = (from, to) => {
+        if (lowAt(from, to) > room + slack)
+            return false;
+        if (width((high[to] ?? 0) - (high[from] ?? 0)) < room - slack)
+            return true;
+        return measuredWidth(chars.slice(from, to).join(""), size, font) <= room;
+    };
+    const pieces = [];
+    let start = 0;
+    while (!fitsRun(start, chars.length)) {
+        const top = Math.max(1, chars.length - start - 1);
+        let below = 0;
+        let above = top + 1;
+        while (above - below > 1) {
+            const middle = Math.floor((below + above) / 2);
+            if (lowAt(start, start + middle) <= room + slack)
+                below = middle;
+            else
+                above = middle;
+        }
+        let cut = Math.max(1, below);
+        while (cut > 1 && !fitsRun(start, start + cut))
+            cut -= 1;
+        pieces.push(chars.slice(start, start + cut).join(""));
+        start += cut;
+    }
+    pieces.push(chars.slice(start).join(""));
+    return pieces;
+}
+function cutWordSlowly(chars, size, room, font) {
+    const fits = (candidate) => measuredWidth(candidate, size, font) <= room;
+    const pieces = [];
+    let rest = [...chars];
+    while (!fits(rest.join(""))) {
+        let cut = Math.max(1, rest.length - 1);
+        while (cut > 1 && !fits(rest.slice(0, cut).join("")))
+            cut -= 1;
+        pieces.push(rest.slice(0, cut).join(""));
+        rest = rest.slice(cut);
+    }
+    pieces.push(rest.join(""));
+    return pieces;
+}
+export function layoutText(frame, text, values, fonts) {
+    const short = Math.min(frame.width, frame.height);
+    const floor = Math.round(short * minTextShare);
+    const area = safeArea(frame, text.preset);
+    let cutShort = false;
+    const blocks = text.blocks
+        .map((block) => {
+        const filled = render(block.text, values).replace(/\s+/g, " ").trim();
+        // More than any format holds even at the smallest size: the rest is never laid out, and
+        // the piece says it doesn't fit.
+        const chars = filled.length > maxFilled ? [...filled] : [];
+        if (chars.length <= maxFilled)
+            return { ...block, filled };
+        cutShort = true;
+        return { ...block, filled: chars.slice(0, maxFilled).join("") };
+    })
+        .filter((block) => block.filled !== "");
+    const size = (role, scale) => Math.max(floor, Math.round(short * roleShare[role] * scale));
+    const sized = (scale, split = false) => blocks.map((block) => {
+        const at = size(block.role, scale);
+        return {
+            id: block.id,
+            lines: wrapText(block.filled, at, area.width, fonts[block.fontId], split),
+            size: at,
+            font: fonts[block.fontId],
+            fontName: fonts[block.fontId]?.assName ?? "Barlow",
+            color: block.color,
+        };
+    });
+    const heightOf = (set) => set.reduce((sum, block, index) => sum +
+        block.lines.length * block.size * lineSpacing +
+        (index === 0 ? 0 : block.size * blockGap), 0);
+    const widest = (set) => Math.max(0, ...set.flatMap((block) => block.lines.map((line) => measuredWidth(line, block.size, block.font))));
+    const tooBig = (set) => heightOf(set) > area.height || widest(set) > area.width;
+    let scale = 1;
+    let set = sized(scale);
+    while (tooBig(set) && set.some((block) => block.size > floor)) {
+        scale *= 0.92;
+        set = sized(scale);
+    }
+    if (widest(set) > area.width)
+        set = sized(scale, true);
+    const total = heightOf(set);
+    const overflow = cutShort || total > area.height || widest(set) > area.width + 1;
+    const vertical = text.preset === "top-title" ? 0 : (area.height - Math.min(total, area.height)) / 2;
+    const left = text.preset === "left-column";
+    const lines = [];
+    let y = area.y + vertical;
+    for (const [index, block] of set.entries()) {
+        if (index > 0)
+            y += block.size * blockGap;
+        for (const line of block.lines) {
+            lines.push({
+                blockId: block.id,
+                text: line,
+                x: Math.round(left ? area.x : area.x + area.width / 2),
+                y: Math.round(y),
+                size: block.size,
+                width: Math.round(measuredWidth(line, block.size, block.font)),
+            });
+            y += block.size * lineSpacing;
+        }
+    }
+    const events = [
+        ...scrimEvents(text, frame, area, lines),
+        ...lines.map((line) => {
+            const block = set.find((one) => one.id === line.blockId);
+            const outline = text.scrim === "none" ? Math.max(1, Math.round(line.size * 0.035)) : 0;
+            return dialogue(1, `{\\an${left ? "7" : "8"}\\pos(${String(line.x)},${String(line.y)})\\fn${(block?.fontName ?? "Barlow").replace(/[\\{}]/g, "")}\\fs${String(line.size)}\\c${assColour(block?.color ?? "#FFFFFF")}\\bord${String(outline)}\\3c&H000000&\\shad0}${assText(line.text)}`);
+        }),
+    ];
+    return { ass: script(frame, events), area, lines, overflow };
+}
+function scrimEvents({ scrim, preset }, frame, area, lines) {
+    if (scrim === "none" || lines.length === 0)
+        return [];
+    const first = lines[0];
+    const last = lines.at(-1);
+    if (first === undefined || last === undefined)
+        return [];
+    const pad = Math.round(Math.min(frame.width, frame.height) * 0.03);
+    // A band under a bottom or top title runs to that edge of the frame.
+    const band = scrim === "band";
+    const top = band && preset === "top-title" ? 0 : Math.max(0, first.y - pad);
+    const bottom = band && preset === "bottom-band"
+        ? frame.height
+        : Math.min(frame.height, last.y + last.size * lineSpacing + pad);
+    // A band runs the frame's full width; a soft scrim sits behind the text area only.
+    const [x0, x1, alpha] = band
+        ? [0, frame.width, "&H40&"]
+        : [Math.max(0, area.x - pad), Math.min(frame.width, area.x + area.width + pad), "&H80&"];
+    const corners = [x0, top, x1, bottom].map((n) => String(Math.round(n)));
+    const [a, b, c, d] = corners;
+    return [
+        dialogue(0, `{\\an7\\pos(0,0)\\p1\\bord0\\shad0\\c&H000000&\\1a${alpha}}m ${a ?? "0"} ${b ?? "0"} l ${c ?? "0"} ${b ?? "0"} l ${c ?? "0"} ${d ?? "0"} l ${a ?? "0"} ${d ?? "0"}{\\p0}`),
+    ];
+}
+function dialogue(layer, body) {
+    return `Dialogue: ${String(layer)},0:00:00.00,0:00:10.00,Design,,0,0,0,,${body}`;
+}
+function script(frame, events) {
+    return `${[
+        "[Script Info]",
+        "ScriptType: v4.00+",
+        `PlayResX: ${String(frame.width)}`,
+        `PlayResY: ${String(frame.height)}`,
+        "WrapStyle: 2",
+        "ScaledBorderAndShadow: yes",
+        "",
+        "[V4+ Styles]",
+        "Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding",
+        `Style: Design,Barlow,${String(Math.round(Math.min(frame.width, frame.height) * 0.04))},&H00FFFFFF,&H00FFFFFF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,0,0,7,0,0,0,1`,
+        "",
+        "[Events]",
+        "Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text",
+        ...events,
+    ].join("\n")}\n`;
+}

package/dist/slices/designs/model.js

@@ -0,0 +1,35 @@
+// A design is a picture edited step by step ("edit") or a designed piece whose text Slopify
+// lays out on the AI's artwork ("design"). Every step is one version of the picture.
+export const designKinds = ["edit", "design"];
+export const stepKinds = ["upload", "edit", "generate"];
+export const stepStates = ["making", "ready", "failed"];
+export const designFormats = [
+    "a4",
+    "a3",
+    "flyer",
+    "square",
+    "portrait",
+    "story",
+    "wide",
+    "brochure",
+];
+export const formatLabels = {
+    a4: "Poster A4",
+    a3: "Poster A3",
+    flyer: "Flyer A5",
+    square: "Square 1:1",
+    portrait: "Portrait 4:5",
+    story: "Story 9:16",
+    wide: "Wide 16:9",
+    brochure: "Brochure A4",
+};
+export const layoutPresets = ["top-title", "bottom-band", "centered", "left-column"];
+export const scrims = ["none", "soft", "band"];
+export const blockRoles = ["headline", "subhead", "details", "small"];
+export const designNameMax = 200;
+export const instructionMax = 4000;
+export const promptMax = 4000;
+export const blocksMax = 8;
+export const blockTextMax = 500;
+export const castPerDesignMax = 3;
+export const daysBeforeMax = 90;

package/dist/slices/designs/pdf-job.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { documentSettingsSchema } from "../document/theme-schema.js";
+const bytes = z.custom((value) => value instanceof Uint8Array);
+const millimetres = z.number().positive().max(2000);
+export const pdfJobSchema = z.discriminatedUnion("kind", [
+    z
+        .object({ kind: z.literal("poster"), png: bytes, widthMm: millimetres, heightMm: millimetres })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("brochure"),
+        cover: bytes,
+        title: z.string().min(1).max(200),
+        markdown: z.string().min(1).max(100_000),
+        settings: documentSettingsSchema,
+        writtenOn: z.string(),
+    })
+        .strict(),
+]);
+export const pdfWorkerMessage = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("done"), bytes }).strict(),
+    z.object({ type: z.literal("error"), message: z.string().max(4000) }).strict(),
+]);

package/dist/slices/designs/pdf-pages.js

@@ -0,0 +1,30 @@
+import { jsPDF } from "jspdf";
+import { renderDocument } from "../document/render.js";
+import { resolvedDocumentTheme } from "../document/theme.js";
+// The PDFs themselves, drawn by jsPDF. Called only inside the PDF worker (`pdf-worker.ts`):
+// jsPDF is synchronous and a print page is large, so the server never runs it in its thread.
+// One page of the given size, the drawn piece filling it edge to edge. No bleed or crop
+// marks: the PNG is already 300 dpi of the page.
+export function posterPdf(job) {
+    const doc = new jsPDF({
+        orientation: job.widthMm > job.heightMm ? "landscape" : "portrait",
+        unit: "mm",
+        format: [job.widthMm, job.heightMm],
+        compress: true,
+    });
+    doc.addImage(job.png, "PNG", 0, 0, job.widthMm, job.heightMm, undefined, "FAST");
+    return new Uint8Array(doc.output("arraybuffer"));
+}
+// The theme's document: the designed cover on its title page, then the brochure's pages.
+export function brochurePdf(job, assets) {
+    const rendered = renderDocument({
+        title: job.title,
+        articleMarkdown: job.markdown,
+        researchNotes: null,
+        cover: job.cover,
+        theme: resolvedDocumentTheme(job.settings),
+        writtenOn: new Date(job.writtenOn),
+        assets,
+    });
+    return { bytes: rendered.bytes, pages: rendered.pages, cover: rendered.cover };
+}

package/dist/slices/designs/pdf-runner.js

@@ -0,0 +1,68 @@
+import { fork } from "node:child_process";
+import { pdfWorkerMessage } from "./pdf-job.js";
+// Draws one design PDF in a forked worker, so jsPDF's synchronous work never holds up the
+// server. Bytes travel both ways over IPC with structured-clone serialization; a cancel kills
+// the worker outright. The worker's address is injectable for tests.
+export const pdfWorkerTimeoutMs = 5 * 60_000;
+export function runPdfWorker(job, signal, worker = new URL("./pdf-worker.js", import.meta.url), timeoutMs = pdfWorkerTimeoutMs) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const options = {
+            stdio: ["ignore", "ignore", "pipe", "ipc"],
+            windowsHide: true,
+            execArgv: [],
+            serialization: "advanced",
+        };
+        const child = fork(worker, [], options);
+        let finishing = false;
+        let failure;
+        let output = new Uint8Array();
+        let stderr = "";
+        const timer = setTimeout(() => finish(new Error("Making the PDF took longer than 5 minutes, so it was stopped. Press Download PDF again.")), timeoutMs);
+        const finish = (error, bytes) => {
+            if (finishing)
+                return;
+            finishing = true;
+            failure = error;
+            output = bytes ?? new Uint8Array();
+            clearTimeout(timer);
+            signal.removeEventListener("abort", abort);
+            child.kill("SIGKILL");
+        };
+        const abort = () => finish(new Error("Making the PDF was canceled."));
+        signal.addEventListener("abort", abort, { once: true });
+        child.stderr?.on("data", (data) => {
+            stderr = (stderr + data.toString("utf8")).slice(-2000);
+        });
+        child.on("error", (error) => finish(error));
+        child.on("close", (code) => {
+            if (!finishing)
+                finish(new Error(`Slopify's PDF maker stopped (exit ${String(code)}). ${stderr}`.trim()));
+            if (failure !== undefined)
+                reject(failure);
+            else
+                resolve(output);
+        });
+        child.on("message", (raw) => {
+            if (finishing)
+                return;
+            const parsed = pdfWorkerMessage.safeParse(raw);
+            if (!parsed.success) {
+                finish(new Error("Slopify's PDF maker answered with something it can't read. Press Download PDF again."));
+                return;
+            }
+            if (parsed.data.type === "error")
+                finish(new Error(`The PDF couldn't be made: ${parsed.data.message}`));
+            else
+                finish(undefined, parsed.data.bytes);
+        });
+        if (signal.aborted) {
+            abort();
+            return;
+        }
+        child.send(job, (error) => {
+            if (error !== null)
+                finish(error);
+        });
+    });
+}

package/dist/slices/designs/pdf-worker.js

@@ -0,0 +1,24 @@
+import { errorText } from "../../kernel/errors.js";
+import { readDocumentAssets } from "../document/fonts.js";
+import { pdfJobSchema } from "./pdf-job.js";
+import { brochurePdf, posterPdf } from "./pdf-pages.js";
+// The forked process a design's PDF is drawn in (`pdf-runner.ts`): one job in, its bytes or
+// what went wrong out, then it exits.
+function answer(message) {
+    process.send?.(message, () => process.exit(0));
+}
+process.once("message", (raw) => {
+    const parsed = pdfJobSchema.safeParse(raw);
+    if (!parsed.success) {
+        answer({ type: "error", message: "The PDF worker was sent a job it can't read." });
+        return;
+    }
+    try {
+        const job = parsed.data;
+        const bytes = job.kind === "poster" ? posterPdf(job) : brochurePdf(job, readDocumentAssets()).bytes;
+        answer({ type: "done", bytes });
+    }
+    catch (error) {
+        answer({ type: "error", message: errorText(error).slice(0, 4000) });
+    }
+});

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,
+        ],
+    ];
+}