@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/slices/control/providers.js

@@ -1,31 +1,5 @@
-import { z } from "zod";
 import { checkRuntimeModel } from "../../catalog/runtime-models.js";
-import { thinkingModes } from "../../kernel/ports/llm.js";
 import { readinessIsUsable, } from "../../kernel/ports/model.js";
-import { chunkModes } from "../narration/chunk.js";
-const choice = z
-    .object({
-    provider: z.string().trim().min(1).max(200),
-    model: z.string().trim().min(1).max(200),
-    thinking: z.enum(thinkingModes).optional(),
-})
-    .strict();
-export const providerChangesSchema = z
-    .object({
-    llm: choice.optional(),
-    audio: choice.extend({ voice: z.string().trim().min(1).max(200) }).optional(),
-    images: choice.optional(),
-    chunking: z
-        .object({
-        mode: z.enum(chunkModes),
-        words: z.number().int().min(1).max(10000).optional(),
-        characters: z.number().int().min(1).max(1000000).optional(),
-    })
-        .strict()
-        .optional(),
-})
-    .strict()
-    .refine((value) => Object.keys(value).length > 0, "Change at least one provider before saving.");
 export function validateLocalProviderChanges(changes, current) {
     const fields = [];
     const families = { llm: "llm", audio: "tts", images: "image" };
@@ -50,8 +24,8 @@ export function validateLocalProviderChanges(changes, current) {
                         "Install this command-line tool on your computer and sign in to it, then try again.")
                     : provider.readiness.kind === "local"
                         ? (provider.readiness.issue ??
-                            "No speech program was found on this computer. Install espeak-ng, or choose a voice provider with a key in Settings → Providers.")
-                        : "Add this provider's API key in Settings → Providers first.",
+                            "No speech program was found on this computer. Install the free program eSpeak NG, or choose a voice service with a key in Settings → Keys & services.")
+                        : "Add this provider's API key in Settings → Keys & services first.",
             });
         }
     }

package/dist/slices/designs/artwork.js

@@ -0,0 +1,66 @@
+import { castMemberById, imageBlob } from "../channels/repo.js";
+import { designFields, fieldProblems, fillDocument, missingSentence, missingValues, } from "./fields.js";
+import { artworkAspect } from "./frames.js";
+import { designDocumentSchema } from "./schema.js";
+export function artworkRequest(document, values) {
+    const parsed = designDocumentSchema.safeParse(document);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid",
+            message: "This design has no settings to make artwork from. Choose its picture, text and formats first.",
+        };
+    const doc = parsed.data;
+    if (doc.picture.source !== "generate")
+        return {
+            ok: false,
+            reason: "invalid",
+            message: "This design uses its own picture as the artwork, so there is nothing to make. Edit the picture instead, or switch Picture to Made by the AI.",
+        };
+    const problem = fieldProblems(doc)[0];
+    if (problem !== undefined)
+        return { ok: false, reason: "invalid", message: problem.sentence };
+    const missing = missingValues(doc, values).filter((name) => detectedInPicture(doc, name));
+    if (missing.length > 0)
+        return { ok: false, reason: "missing-values", message: missingSentence(missing) };
+    const filled = fillDocument(doc, values);
+    const words = filled.text.blocks.map((block) => block.text.trim()).filter((text) => text !== "");
+    const prompt = doc.picture.aiText && words.length > 0
+        ? `${filled.picture.prompt}\n\nDraw this text into the picture as part of the design, spelled exactly as written, each line on its own:\n${words.map((line) => `"${line}"`).join("\n")}`
+        : `${filled.picture.prompt}\n\nLeave room for a title and details to be set over the picture; draw no text, letters or logos.`;
+    return {
+        ok: true,
+        value: {
+            prompt,
+            aspect: artworkAspect(doc.formats.map((one) => one.format)),
+            castMemberIds: doc.picture.castMemberIds,
+            provider: doc.picture.provider,
+            model: doc.picture.model,
+        },
+    };
+}
+// The text fields only matter to the artwork when the AI draws the text.
+function detectedInPicture(doc, name) {
+    if (doc.picture.aiText)
+        return designFields({ ...doc, brochure: undefined }).includes(name);
+    return designFields({ ...doc, text: { ...doc.text, blocks: [] }, brochure: undefined }).includes(name);
+}
+// Each chosen cast member with the pictures they have, in the order chosen.
+export function castReferences(db, ids) {
+    const references = [];
+    for (const id of ids) {
+        const member = castMemberById(db, id);
+        if (member === undefined)
+            return {
+                ok: false,
+                reason: "invalid",
+                message: "A cast member you chose was deleted. Choose the cast again, then press the button again.",
+            };
+        const images = member.images.flatMap((image) => {
+            const blob = image.state === "ready" && image.sha256 !== null ? imageBlob(db, image.sha256) : undefined;
+            return blob === undefined ? [] : [blob];
+        });
+        references.push({ name: member.name, description: member.description, images });
+    }
+    return { ok: true, value: references };
+}

package/dist/slices/designs/budget.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { readJsonSetting } from "../settings/repo.js";
+import { sampleSpentToday } from "./sample-repo.js";
+// What a design template's samples may spend per day, in dollars, before the editor holds a
+// sample for a person to start.
+// No row is seeded: an absent row reads as the default, and only a changed budget travels in
+// backups.
+export const dailySampleBudgetKey = "designs.dailySampleBudget";
+export const dailySampleBudgetSchema = z.number().min(0).max(1000);
+export const defaultDailySampleBudget = 1;
+export function dailySampleBudget(db, log) {
+    return readJsonSetting(db, dailySampleBudgetKey, dailySampleBudgetSchema, defaultDailySampleBudget, log);
+}
+export function budgetSentence(total, budget) {
+    return `Waiting: this sample would take today's sample spending to $${total.toFixed(2)}, over the $${budget.toFixed(2)} a day samples may spend. Press Make sample to make it anyway; the limit starts again at midnight.`;
+}
+// Settings → Production defaults shows it beside the budget: what design samples spent since local
+// midnight and what is left of today's budget.
+export function designBudgetRoom(db, now, timeZone) {
+    const budget = dailySampleBudget(db);
+    const spent = sampleSpentToday(db, now, timeZone);
+    return { budget, spent, left: Math.max(0, budget - spent) };
+}

package/dist/slices/designs/calls.js

@@ -0,0 +1,124 @@
+import { transact } from "../../kernel/db/tx.js";
+import { errorText } from "../../kernel/errors.js";
+import { isProviderError } from "../../kernel/ports/model.js";
+import { castImageMaxBytes, storeImageBlob } from "../channels/images.js";
+import { imageBlob } from "../channels/repo.js";
+import { backupMaxImageBytes } from "../storage/backup-format.js";
+import { castReferences } from "./artwork.js";
+import { pictureSize } from "./picture-size.js";
+import { updateDesign } from "./repo.js";
+import { settleStep, stepById } from "./steps-repo.js";
+// The background half of the runner: each "making" step's provider call, at most two at once,
+// settled into its step (and made the design's current version when it lands).
+export const maxConcurrentDesignCalls = 2;
+export const noProviderMessage = "No image service is set up. Add one in Settings → Keys & services, then press the button again.";
+export function createDesignCalls(deps) {
+    let running = 0;
+    const waiting = [];
+    const inFlight = new Set();
+    const slot = async () => {
+        if (running < maxConcurrentDesignCalls) {
+            running += 1;
+            return;
+        }
+        await new Promise((resolve) => waiting.push(resolve));
+    };
+    const release = () => {
+        const next = waiting.shift();
+        if (next === undefined)
+            running -= 1;
+        else
+            next();
+    };
+    const finish = (designId, stepId, outcome) => {
+        const at = deps.clock.now().toISOString();
+        transact(deps.db, () => {
+            if (settleStep(deps.db, stepId, outcome, at) && outcome.state === "ready")
+                updateDesign(deps.db, designId, undefined, { headStepId: stepId }, at);
+        });
+        try {
+            deps.emit?.({ type: "design.changed", designId });
+        }
+        catch (error) {
+            deps.log.write("warn", "designs.emit", { detail: errorText(error) });
+        }
+    };
+    const call = async (designId, stepId) => {
+        await slot();
+        try {
+            const step = stepById(deps.db, stepId);
+            const generate = deps.generate;
+            if (step === undefined ||
+                step.state !== "making" ||
+                step.provider === null ||
+                step.model === null)
+                return;
+            if (generate === undefined)
+                throw new Error(noProviderMessage);
+            const cast = castReferences(deps.db, step.inputs.castMemberIds);
+            if (!cast.ok)
+                throw new Error(cast.message);
+            const parent = step.parentId === null ? undefined : stepById(deps.db, step.parentId);
+            const source = parent === undefined || parent.sha256 === null
+                ? undefined
+                : imageBlob(deps.db, parent.sha256);
+            if (step.kind === "edit" && source === undefined)
+                throw new Error("The version this edit starts from is no longer kept. Continue from another version, then press Edit.");
+            const sent = source === undefined || source.bytes.byteLength <= castImageMaxBytes
+                ? source
+                : await shrunk(source.bytes);
+            const image = await generate({
+                designId,
+                purpose: step.kind === "edit" ? "picture-edit" : "design-art",
+                provider: step.provider,
+                model: step.model,
+                prompt: step.inputs.prompt ?? step.instruction ?? "",
+                aspect: step.inputs.aspect ?? "1:1",
+                ...(sent === undefined || step.kind !== "edit" ? {} : { edit: { source: sent } }),
+                ...(cast.value.length === 0 ? {} : { cast: cast.value }),
+            });
+            const size = pictureSize(image.bytes);
+            if (size === undefined || image.bytes.byteLength > backupMaxImageBytes)
+                throw new Error("The provider answered with something that is not a usable PNG or JPEG picture.");
+            const sha256 = storeImageBlob(deps.db, image.bytes, image.mime, deps.clock.now().toISOString());
+            finish(designId, stepId, { state: "ready", sha256, ...size });
+        }
+        catch (error) {
+            const reason = errorText(error).slice(0, 500);
+            deps.log.write("warn", "designs.picture.failed", {
+                detail: `${designId}/${stepId}: ${reason}`,
+            });
+            finish(designId, stepId, { state: "failed", error: failedSentence(error, reason) });
+        }
+        finally {
+            release();
+        }
+    };
+    const shrunk = async (bytes) => {
+        if (deps.shrink === undefined)
+            throw new Error("The picture is too large to send to the provider.");
+        return { bytes: await deps.shrink(bytes), mime: "image/jpeg" };
+    };
+    const start = (designId, stepId) => {
+        const job = call(designId, stepId);
+        inFlight.add(job);
+        void job.finally(() => inFlight.delete(job));
+    };
+    return {
+        start,
+        idle: async () => {
+            while (inFlight.size > 0)
+                await Promise.allSettled([...inFlight]);
+        },
+    };
+}
+// Try again is offered only when asking again can help: a model that can't do this, or a key
+// the provider refuses, fails the same way every time, so the sentence says the fix instead.
+function failedSentence(error, reason) {
+    const kind = isProviderError(error) ? error.fault.kind : undefined;
+    if (kind === "unsupported")
+        return `The picture couldn't be made: ${reason}${reason.includes("Made with") ? "" : " Choose another image model under Made with … · change."}`;
+    if (kind === "auth" || kind === "missing_key")
+        return `The picture couldn't be made: ${reason}${/Settings/.test(reason) ? "" : " Check the provider's key in Settings → Keys & services, then press Try again."}`;
+    return `The picture couldn't be made: ${reason} Press Try again, or choose another image model under Made with … · change.`;
+}

package/dist/slices/designs/check-context.js

@@ -0,0 +1,38 @@
+import { errorText } from "../../kernel/errors.js";
+import { readFontFile } from "../fonts/files.js";
+// The fonts and providers Mark ready looks at, read from this computer. `main.ts` passes the
+// real font catalogue and provider statuses; tests pass their own.
+export function designCheckContext(deps) {
+    return {
+        font: async (fontId) => {
+            try {
+                const font = await deps.resolveFont(fontId);
+                const bytes = await readFontFile(font.path);
+                return bytes === undefined
+                    ? undefined
+                    : { name: font.name, bytes: new Uint8Array(bytes), faceIndex: font.faceIndex };
+            }
+            catch {
+                return undefined;
+            }
+        },
+        providerProblem: async (provider) => {
+            let statuses;
+            try {
+                statuses = await deps.providers();
+            }
+            catch (error) {
+                return `Slopify couldn't check the image service: ${errorText(error)} Open Settings → Keys & services, then press Approve for schedules again.`;
+            }
+            const status = statuses.find((one) => one.id === provider);
+            if (status === undefined)
+                return `The image service “${provider}” isn't one this Slopify knows. Choose another image model under Picture.`;
+            const readiness = status.readiness;
+            if (readiness.kind === "keyed" && !readiness.hasKey)
+                return `${status.displayName} has no API key, so the picture can't be made. Add the key in Settings → Keys & services, then press Approve for schedules again.`;
+            if (readiness.kind === "cli" && (!readiness.installed || readiness.issue !== undefined))
+                return `${status.displayName} can't be used yet: ${readiness.issue ?? "it isn't installed on this computer."} Fix it in Settings → Keys & services, then press Approve for schedules again.`;
+            return null;
+        },
+    };
+}

package/dist/slices/designs/check-text.js

@@ -0,0 +1,43 @@
+import { render } from "../admission/substitute.js";
+import { mappedCodepoints } from "../fonts/sfnt.js";
+const squash = (value) => value.replace(/\s+/g, "");
+export function checkText(input) {
+    const problems = [];
+    for (const [index, block] of input.text.blocks.entries()) {
+        const filled = render(block.text, input.values);
+        if (filled.trim() === "")
+            continue;
+        const where = `text block ${String(index + 1)}`;
+        const font = input.fonts[block.fontId];
+        if (font === undefined) {
+            problems.push({
+                blockId: block.id,
+                sentence: `The font chosen for ${where} is no longer on this computer. Choose another font for it under Text.`,
+            });
+            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)
+            problems.push({
+                blockId: block.id,
+                sentence: `The font ${font.name} has no ${missing.map((ch) => `“${ch}”`).join(" ")} for ${where}. Choose another font for it under Text, or upload one that has ${missing.length === 1 ? "it" : "them"}.`,
+            });
+        const drawn = input.layout.lines
+            .filter((line) => line.blockId === block.id)
+            .map((line) => line.text)
+            .join("");
+        if (squash(drawn) !== squash(filled))
+            problems.push({
+                blockId: block.id,
+                sentence: `Slopify couldn't place ${where} exactly as typed on ${input.formatLabel}. Shorten it under Text, then press Make again.`,
+            });
+    }
+    if (input.layout.overflow)
+        problems.push({
+            blockId: "",
+            sentence: `The text doesn't fit on ${input.formatLabel}, even at the smallest readable size. Shorten it or choose a placement with more room under Text.`,
+        });
+    return problems;
+}

package/dist/slices/designs/fields.js

@@ -0,0 +1,88 @@
+import { detectSlots, filledKeywords, render } from "../admission/substitute.js";
+import { isReserved, reservedPrefix } from "../keywords/model.js";
+function bodies(doc) {
+    return [
+        { where: "the picture prompt", text: doc.picture.prompt },
+        ...doc.text.blocks.map((block, index) => ({
+            where: `text block ${String(index + 1)}`,
+            text: block.text,
+        })),
+        ...(doc.brochure === undefined
+            ? []
+            : [
+                { where: "the brochure title", text: doc.brochure.title },
+                { where: "the brochure text", text: doc.brochure.body },
+            ]),
+    ];
+}
+export function designFields(doc) {
+    const names = [];
+    for (const body of bodies(doc))
+        for (const name of detectSlots(body.text).names)
+            if (!names.includes(name))
+                names.push(name);
+    return names;
+}
+const slotSentences = {
+    unclosed: "has a {{ without its }}",
+    empty: "has an empty {{}}",
+    nested: "has a { or } inside a {{keyword}}",
+};
+export function fieldProblems(doc) {
+    const problems = [];
+    for (const body of bodies(doc))
+        for (const error of detectSlots(body.text).errors)
+            problems.push({
+                kind: "slot",
+                where: body.where,
+                error: error.kind,
+                sentence: `The ${body.where.replace(/^the /, "")} ${slotSentences[error.kind]}. Fix it so every keyword reads {{Name}}.`,
+            });
+    const names = designFields(doc);
+    for (const name of names)
+        if (isReserved(name) || filledKeywords.includes(name))
+            problems.push({
+                kind: "reserved",
+                name,
+                sentence: `{{${name}}} is a name Slopify keeps for videos, so a design can't use it. Rename it (for example {{${isReserved(name) ? name.slice(reservedPrefix.length) : name}Text}}).`,
+            });
+    const dateField = doc.schedule?.dateField;
+    if (dateField !== undefined && !names.includes(dateField))
+        problems.push({
+            kind: "date-field",
+            name: dateField,
+            sentence: `The schedule reads each row's date from {{${dateField}}}, but no text uses it. Put {{${dateField}}} in a text block, or choose another date keyword under Schedule.`,
+        });
+    return problems;
+}
+// A field counts as filled only with something other than spaces.
+export function missingValues(doc, values) {
+    return designFields(doc).filter((name) => (Object.hasOwn(values, name) ? (values[name] ?? "") : "").trim() === "");
+}
+export function missingSentence(missing) {
+    const list = missing.map((name) => `{{${name}}}`);
+    const named = list.length === 1
+        ? `${list[0] ?? ""} has`
+        : `${list.slice(0, -1).join(", ")} and ${list.at(-1) ?? ""} have`;
+    return `${named} no value. Fill ${list.length === 1 ? "it" : "them"} in under Keywords, then press Make.`;
+}
+// Every text with its fields filled. Values are inserted verbatim, never read as fields.
+export function fillDocument(doc, values) {
+    return {
+        ...doc,
+        picture: { ...doc.picture, prompt: render(doc.picture.prompt, values) },
+        text: {
+            ...doc.text,
+            blocks: doc.text.blocks.map((block) => ({ ...block, text: render(block.text, values) })),
+        },
+        ...(doc.brochure === undefined
+            ? {}
+            : {
+                brochure: {
+                    ...doc.brochure,
+                    title: render(doc.brochure.title, values),
+                    body: render(doc.brochure.body, values),
+                },
+            }),
+    };
+}

package/dist/slices/designs/frames.js

@@ -0,0 +1,34 @@
+import { nearestFormat } from "./picture-size.js";
+export const frames = {
+    a4: { width: 2480, height: 3508, pdf: { widthMm: 210, heightMm: 297 } },
+    a3: { width: 3508, height: 4961, pdf: { widthMm: 297, heightMm: 420 } },
+    flyer: { width: 1748, height: 2480, pdf: { widthMm: 148, heightMm: 210 } },
+    square: { width: 1080, height: 1080 },
+    portrait: { width: 1080, height: 1350 },
+    story: { width: 1080, height: 1920 },
+    wide: { width: 1920, height: 1080 },
+    // The brochure's cover is an A4 page; its inner pages are the document theme's own.
+    brochure: { width: 2480, height: 3508, pdf: { widthMm: 210, heightMm: 297 } },
+};
+// One artwork serves every format: the provider shape every chosen format is closest to, or
+// square when they pull different ways, so each crop loses as little as it can.
+export function artworkAspect(formats) {
+    const shapes = new Set(formats.map((format) => nearestFormat(frames[format])));
+    const [only] = shapes;
+    return shapes.size === 1 && only !== undefined ? only : "1:1";
+}
+// Cover-fit: the picture fills the frame, and what is cut off is cut around the focus point
+// (0..1 on each axis of the picture), never past the picture's edge.
+export function coverCrop(picture, frame, focus) {
+    const scale = Math.max(frame.width / picture.width, frame.height / picture.height);
+    const scaleWidth = Math.max(frame.width, Math.round(picture.width * scale));
+    const scaleHeight = Math.max(frame.height, Math.round(picture.height * scale));
+    // The frame is centred on the focus point, then slid back inside the picture.
+    const place = (size, window, at) => Math.min(size - window, Math.max(0, Math.round(at * size - window / 2)));
+    return {
+        scaleWidth,
+        scaleHeight,
+        x: place(scaleWidth, frame.width, focus.x),
+        y: place(scaleHeight, frame.height, focus.y),
+    };
+}

package/dist/slices/designs/gate.js

@@ -0,0 +1,130 @@
+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 service is ready.",
+            fix: problem === null
+                ? null
+                : { label: "Open Keys & services", 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 keyword. Choose a keyword 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;
+}
+// Approve for schedules asks for the version's own sample, made, as Edit template 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 Approve for schedules.";
+    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` },
+    };
+}