@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/slices/channels/repo.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { channelSocialOf } from "../social/channel.js";
 import { aiDisclosureSettings } from "../studio/disclosure.js";
 import { channelAmbientBedSchema } from "../video/ambient-bed-schema.js";
 import { castKinds, defaultChannelId, } from "./model.js";
@@ -25,6 +26,8 @@ const channelRow = z.object({
     brand_json: z.string(),
     series_brief: z.string(),
     ai_disclosure: z.enum(aiDisclosureSettings),
+    x_tier: z.string().optional(),
+    social_accounts: z.string().optional(),
     version: z.number(),
     created_at: z.string(),
     updated_at: z.string(),
@@ -69,6 +72,7 @@ function channelOf(row) {
         brand: brandSchema.parse(JSON.parse(value.brand_json)),
         seriesBrief: value.series_brief,
         aiDisclosure: value.ai_disclosure,
+        ...((social) => ({ xTier: social.xTier, socialAccounts: social.accounts }))(channelSocialOf(value.x_tier, value.social_accounts)),
         version: value.version,
         createdAt: value.created_at,
         updatedAt: value.updated_at,

package/dist/slices/channels/schema.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { languageSchema } from "../../kernel/ports/languages.js";
+import { socialPlatforms, xTiers } from "../social/model.js";
 import { aiDisclosureSettings } from "../studio/disclosure.js";
 import { ambientBedProblems } from "../video/ambient-bed.js";
 import { channelAmbientBedSchema } from "../video/ambient-bed-schema.js";
@@ -75,6 +76,11 @@ export const channelUpdateSchema = z
     name,
     brand: brandKitSchema,
     seriesBrief: z.string().max(10000, "Keep the series brief to 10,000 characters or fewer."),
+    // Brand → Posting (`slices/social`): left out, they stay as they are.
+    xTier: z.enum(xTiers, "Choose Free, Premium or Premium+.").optional(),
+    socialAccounts: z
+        .partialRecord(z.enum(socialPlatforms), z.string().max(260, "Keep each account name to 260 characters or fewer."))
+        .optional(),
     baseVersion: z.number().int().positive(),
 })
     .strict()

package/dist/slices/channels/service.js

@@ -1,4 +1,5 @@
 import { transact } from "../../kernel/db/tx.js";
+import { accountsProblem, writeChannelSocial } from "../social/channel.js";
 import { defaultChannelId } from "./model.js";
 import { castMemberById, castOfChannel, channelById, channelSummaries } from "./repo.js";
 import { castMemberCreateSchema, castMemberUpdateSchema, castMoveSchema, channelAiDisclosureSchema, channelCreateSchema, channelUpdateSchema, templateChannelSchema, } from "./schema.js";
@@ -50,9 +51,18 @@ export function updateChannel(deps, id, input) {
         if (previous.version !== parsed.data.baseVersion)
             return { ok: false, reason: "conflict" };
         const brand = parsed.data.brand;
+        const accountsWrong = parsed.data.socialAccounts === undefined
+            ? undefined
+            : accountsProblem(parsed.data.socialAccounts);
+        if (accountsWrong !== undefined)
+            return { ok: false, reason: "invalid-input", message: accountsWrong };
         deps.db
             .prepare("UPDATE channels SET name=?,brand_json=?,series_brief=?,version=version+1,updated_at=? WHERE id=? AND version=?")
             .run(parsed.data.name, JSON.stringify(brand), parsed.data.seriesBrief, deps.clock.now().toISOString(), id, parsed.data.baseVersion);
+        writeChannelSocial(deps.db, id, {
+            xTier: parsed.data.xTier,
+            accounts: parsed.data.socialAccounts,
+        });
         const saved = channelById(deps.db, id);
         if (saved === undefined)
             throw new Error("The saved channel could not be read back");

package/dist/slices/channels/videos.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
-import { readSetting, writeSetting } from "../settings/repo.js";
+import { readJsonSetting, writeSetting } from "../settings/repo.js";
 import { channelById } from "./repo.js";
 import { titlesFromCsv, titlesFromLines } from "./studio-csv.js";
 export const videoTitleMax = 500;
@@ -47,7 +47,7 @@ export function previewChannelVideos(deps, channelId, input) {
     const read = importOf(input);
     if (!read.ok)
         return read;
-    const filter = storedFilter(readSetting(deps.db, filterKey(channelId)));
+    const filter = readJsonSetting(deps.db, filterKey(channelId), z.string(), "");
     return { ok: true, value: { titles: read.value.titles, filter } };
 }
 // Titles already on the channel (any case) and repeats within the import are skipped.
@@ -69,18 +69,6 @@ export function importChannelVideos(deps, channelId, input) {
         return { ok: true, value: { added, skipped: titles.length - added } };
     });
 }
-// Stored as JSON, like every row of the `settings` table a backup carries.
-function storedFilter(stored) {
-    if (stored === undefined)
-        return "";
-    try {
-        const value = JSON.parse(stored);
-        return typeof value === "string" ? value : "";
-    }
-    catch {
-        return "";
-    }
-}
 function importOf(input) {
     const parsed = importSchema.safeParse(input);
     if (!parsed.success)

package/dist/slices/checkpoints/index.js

@@ -1,2 +1 @@
 export { approveCheckpoint, checkpointForWork, listCheckpoints, saveCheckpointSet, settleCheckpointClosures, } from "./repo.js";
-export { checkpointApprovalSchema, checkpointRowSchema, checkpointSetSchema, checkpointStageSchema, checkpointStateSchema, } from "./schema.js";

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" };

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 → Template studio 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 provider is set up. Add one in Settings → Providers, 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 → Providers, 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 provider: ${errorText(error)} Open Settings → Providers, then press Mark ready again.`;
+            }
+            const status = statuses.find((one) => one.id === provider);
+            if (status === undefined)
+                return `The image provider “${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 → Providers, then press Mark ready 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 → Providers, then press Mark ready 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 {{field}}",
+};
+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 field 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 field 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 Fields, 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),
+    };
+}