@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/slices/designs/gate.js

@@ -0,0 +1,128 @@
+import { z } from "zod";
+import { render } from "../admission/substitute.js";
+import { fontAdvances, mappedCodepoints } from "../fonts/sfnt.js";
+import { designFields } from "./fields.js";
+import { frames } from "./frames.js";
+import { layoutText } from "./layout.js";
+import { formatLabels } from "./model.js";
+import { sampleRow } from "./sample-repo.js";
+import { templateRevision } from "./templates.js";
+export function runnableDesignVersion(db, templateId) {
+    const row = db
+        .prepare(`SELECT r.version FROM design_template_revisions AS r
+       JOIN design_templates AS t ON t.id = r.template_id
+       WHERE r.template_id=? AND r.gate='ready' AND t.deleted_at IS NULL
+       ORDER BY r.version DESC LIMIT 1`)
+        .get(templateId);
+    if (row === undefined)
+        return undefined;
+    const version = z.object({ version: z.number() }).parse(row).version;
+    const revision = templateRevision(db, templateId, version);
+    return revision === undefined
+        ? undefined
+        : { version, name: revision.name, document: revision.document };
+}
+export async function contextChecks(doc, templateId, ctx) {
+    const at = (section, label = "Open") => ({
+        label,
+        href: `/library/design-templates/${templateId}#${section}`,
+    });
+    const checks = [];
+    if (doc.picture.source === "generate") {
+        const problem = await ctx.providerProblem(doc.picture.provider);
+        checks.push({
+            id: "provider",
+            ok: problem === null,
+            sentence: problem ?? "The image provider is ready.",
+            fix: problem === null ? null : { label: "Open Providers", href: "/settings?section=providers" },
+        });
+    }
+    else {
+        const kept = doc.picture.sha256 !== undefined;
+        checks.push({
+            id: "provider",
+            ok: kept,
+            sentence: kept
+                ? "The template's own picture is saved with it."
+                : "This template uses its own picture, but none is saved with it. Upload one under Picture.",
+            fix: kept ? null : at("picture"),
+        });
+    }
+    const schedule = doc.schedule;
+    if (schedule !== undefined) {
+        const used = designFields(doc).includes(schedule.dateField);
+        checks.push({
+            id: "date-field",
+            ok: used,
+            sentence: used
+                ? `Each row's date is read from {{${schedule.dateField}}}.`
+                : `The schedule reads each date from {{${schedule.dateField}}}, but the template doesn't use that field. Choose a field it uses under Schedule.`,
+            fix: used ? null : at("schedule"),
+        });
+    }
+    // With the AI drawing the text, Slopify draws none, so there are no fonts to check.
+    if (doc.picture.aiText)
+        return checks;
+    const fonts = new Map();
+    for (const block of doc.text.blocks)
+        if (!fonts.has(block.fontId))
+            fonts.set(block.fontId, await ctx.font(block.fontId));
+    const fontProblems = [];
+    for (const [index, block] of doc.text.blocks.entries()) {
+        const filled = render(block.text, doc.samples);
+        if (filled.trim() === "")
+            continue;
+        const where = `text block ${String(index + 1)}`;
+        const font = fonts.get(block.fontId);
+        if (font === undefined) {
+            fontProblems.push(`The font chosen for ${where} is no longer on this computer. Choose another font for it under Text layout.`);
+            continue;
+        }
+        const letters = [...new Set([...filled].filter((ch) => ch.trim() !== ""))];
+        const found = mappedCodepoints(font.bytes, font.faceIndex, letters.map((ch) => ch.codePointAt(0) ?? 0));
+        const missing = found === undefined ? [] : letters.filter((ch) => !found.has(ch.codePointAt(0) ?? 0));
+        if (missing.length > 0)
+            fontProblems.push(`The font ${font.name} has no ${missing.map((ch) => `“${ch}”`).join(" ")} for the sample of ${where}. Choose another font for it under Text layout, or upload one that has ${missing.length === 1 ? "it" : "them"}.`);
+    }
+    checks.push({
+        id: "fonts",
+        ok: fontProblems.length === 0,
+        sentence: fontProblems[0] ?? "The fonts have every letter of the sample values.",
+        fix: fontProblems.length === 0 ? null : at("text"),
+    });
+    const layoutFonts = {};
+    for (const [id, font] of fonts)
+        if (font !== undefined)
+            layoutFonts[id] = { assName: font.name, advance: fontAdvances(font.bytes, font.faceIndex) };
+    const tooFull = doc.formats
+        .map((entry) => entry.format)
+        .filter((format) => layoutText(frames[format], doc.text, doc.samples, layoutFonts).overflow);
+    checks.push({
+        id: "formats",
+        ok: tooFull.length === 0,
+        sentence: tooFull.length === 0
+            ? "The sample values fit on every format."
+            : `The sample text doesn't fit on ${tooFull.map((format) => formatLabels[format]).join(", ")}, even at the smallest readable size. Shorten it or choose a placement with more room under Text layout.`,
+        fix: tooFull.length === 0 ? null : at("text"),
+    });
+    return checks;
+}
+// Mark ready asks for the version's own sample, made, as a project template's studio does: the
+// person has seen what a schedule will make before it makes it.
+export function sampleCheck(db, templateId, version) {
+    const row = sampleRow(db, templateId);
+    const made = row?.state === "done" && row.version === version;
+    const how = "Make its sample, look it over beside the settings, then press Mark ready.";
+    return {
+        id: "sample",
+        ok: made,
+        sentence: made
+            ? `Version ${String(version)}'s sample is made.`
+            : row?.state === "done" && row.version !== version
+                ? `Version ${String(version)} has no sample yet: the one shown is of version ${String(row.version)}. ${how}`
+                : `Version ${String(version)} has no sample yet. ${how}`,
+        fix: made
+            ? null
+            : { label: "Open Picture", href: `/library/design-templates/${templateId}#picture` },
+    };
+}

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) });
+    }
+});