@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/slices/designs/templates.js

@@ -0,0 +1,218 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { defaultChannelId } from "../channels/model.js";
+import { designDocumentSchema } from "./schema.js";
+import { mutationHash, reusedMessage } from "./service.js";
+import { documentChecks } from "./template-checks.js";
+// Design templates: a designed piece saved with fields to make again by hand or from a
+// schedule. Every Save is a new version; a version is marked ready only when its checks pass,
+// and only a ready version is what a schedule makes (`runnableDesignVersion`).
+const id = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[A-Za-z0-9_-]+$/);
+const name = z.string().trim().min(1).max(200);
+export const createTemplateSchema = z
+    .object({
+    id,
+    mutationId: z.string().min(8).max(128),
+    name,
+    document: designDocumentSchema,
+    channelId: id.optional(),
+})
+    .strict();
+export const saveTemplateSchema = z
+    .object({
+    baseVersion: z.number().int().min(1),
+    name,
+    document: designDocumentSchema,
+    // Whether this Save redraws the editor's sample (`sample.ts`); "skip" saves only.
+    sample: z.enum(["make", "skip"]).optional(),
+    acknowledgedHigh: z.number().min(0).max(1000).optional(),
+})
+    .strict();
+export const markReadySchema = z.object({ version: z.number().int().min(1) }).strict();
+const revisionRow = z.object({
+    version: z.number(),
+    name: z.string(),
+    document_json: z.string(),
+    gate: z.enum(["unchecked", "ready"]),
+    checks_json: z.string().nullable(),
+    marked_at: z.string().nullable(),
+    created_at: z.string(),
+});
+const checksSchema = z
+    .array(z.object({
+    id: z.string(),
+    ok: z.boolean(),
+    sentence: z.string(),
+    fix: z.object({ label: z.string(), href: z.string() }).nullable(),
+}))
+    .catch([]);
+export function templateRevision(db, templateId, version) {
+    const raw = db
+        .prepare("SELECT * FROM design_template_revisions WHERE template_id=? AND version=?")
+        .get(templateId, version);
+    if (raw === undefined)
+        return undefined;
+    const row = revisionRow.parse(raw);
+    return {
+        version: row.version,
+        name: row.name,
+        gate: row.gate,
+        markedAt: row.marked_at,
+        createdAt: row.created_at,
+        document: designDocumentSchema.parse(JSON.parse(row.document_json)),
+    };
+}
+export function getTemplate(db, templateId) {
+    const head = db
+        .prepare("SELECT id, channel_id, head_version, created_at FROM design_templates WHERE id=? AND deleted_at IS NULL")
+        .get(templateId);
+    if (head === undefined)
+        return undefined;
+    const revisions = db
+        .prepare("SELECT * FROM design_template_revisions WHERE template_id=? ORDER BY version")
+        .all(templateId)
+        .map((raw) => revisionRow.parse(raw));
+    const current = revisions.find((row) => row.version === head.head_version);
+    if (current === undefined)
+        return undefined;
+    const ready = revisions.filter((row) => row.gate === "ready").at(-1);
+    return {
+        id: String(head.id),
+        channelId: head.channel_id === null ? defaultChannelId : String(head.channel_id),
+        headVersion: current.version,
+        name: current.name,
+        document: designDocumentSchema.parse(JSON.parse(current.document_json)),
+        gate: current.gate,
+        checks: current.checks_json === null ? [] : checksSchema.parse(JSON.parse(current.checks_json)),
+        readyVersion: ready?.version ?? null,
+        versions: revisions.map((row) => ({
+            version: row.version,
+            name: row.name,
+            gate: row.gate,
+            markedAt: row.marked_at,
+            createdAt: row.created_at,
+        })),
+        createdAt: String(head.created_at),
+        updatedAt: current.created_at,
+    };
+}
+export function listTemplates(db) {
+    return db
+        .prepare("SELECT id FROM design_templates WHERE deleted_at IS NULL ORDER BY created_at DESC, id")
+        .all()
+        .flatMap((row) => getTemplate(db, String(row.id)) ?? []);
+}
+const notFound = {
+    ok: false,
+    reason: "not-found",
+    message: "This design template no longer exists. Open Library → Designs → Templates to choose another.",
+};
+function invalid(error) {
+    return {
+        ok: false,
+        reason: "invalid",
+        message: `The template can't be saved: ${error.issues[0]?.message ?? "a field is missing"}.`,
+    };
+}
+export function createTemplate(deps, raw) {
+    const parsed = createTemplateSchema.safeParse(raw);
+    if (!parsed.success)
+        return invalid(parsed.error);
+    const { mutationId, ...input } = parsed.data;
+    const hash = mutationHash(input);
+    const replay = deps.db
+        .prepare("SELECT id, mutation_hash FROM design_templates WHERE mutation_id=?")
+        .get(mutationId);
+    if (replay !== undefined) {
+        if (replay.mutation_hash !== hash)
+            return { ok: false, reason: "mutation-reused", message: reusedMessage };
+        const template = getTemplate(deps.db, String(replay.id));
+        return template === undefined ? notFound : { ok: true, value: template };
+    }
+    if (deps.db.prepare("SELECT 1 FROM design_templates WHERE id=?").get(input.id) !== undefined)
+        return { ok: false, reason: "mutation-reused", message: reusedMessage };
+    const at = deps.clock.now().toISOString();
+    transact(deps.db, () => {
+        deps.db
+            .prepare("INSERT INTO design_templates (id,channel_id,head_version,created_at,mutation_id,mutation_hash) VALUES (?,?,1,?,?,?)")
+            .run(input.id, input.channelId ?? null, at, mutationId, hash);
+        deps.db
+            .prepare("INSERT INTO design_template_revisions (template_id,version,name,document_json,created_at) VALUES (?,1,?,?,?)")
+            .run(input.id, input.name, JSON.stringify(input.document), at);
+    });
+    const template = getTemplate(deps.db, input.id);
+    return template === undefined ? notFound : { ok: true, value: template };
+}
+// A Save on the version it was made on becomes the next version; one made on an older version
+// is refused with the current template. Saving exactly what the head already holds is a no-op.
+export function saveTemplate(deps, templateId, raw) {
+    const parsed = saveTemplateSchema.safeParse(raw);
+    if (!parsed.success)
+        return invalid(parsed.error);
+    const current = getTemplate(deps.db, templateId);
+    if (current === undefined)
+        return notFound;
+    const input = parsed.data;
+    const same = input.name === current.name &&
+        JSON.stringify(input.document) === JSON.stringify(current.document);
+    if (same)
+        return { ok: true, value: { template: current, saved: false, before: current.document } };
+    if (input.baseVersion !== current.headVersion)
+        return {
+            ok: false,
+            reason: "changed",
+            message: "This template was saved in another tab or by an agent. Reload it to see that version, then make your change again.",
+            current,
+        };
+    const version = current.headVersion + 1;
+    transact(deps.db, () => {
+        deps.db
+            .prepare("INSERT INTO design_template_revisions (template_id,version,name,document_json,created_at) VALUES (?,?,?,?,?)")
+            .run(templateId, version, input.name, JSON.stringify(input.document), deps.clock.now().toISOString());
+        deps.db
+            .prepare("UPDATE design_templates SET head_version=? WHERE id=?")
+            .run(version, templateId);
+    });
+    const template = getTemplate(deps.db, templateId);
+    return template === undefined
+        ? notFound
+        : { ok: true, value: { template, saved: true, before: current.document } };
+}
+// Mark ready: the version's checks are run and kept; it is marked only when every one passes,
+// and otherwise refused with the list.
+export async function markTemplateReady(deps, templateId, raw, more = async () => []) {
+    const parsed = markReadySchema.safeParse(raw);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid", message: "Say which version to mark ready." };
+    if (getTemplate(deps.db, templateId) === undefined)
+        return notFound;
+    const revision = templateRevision(deps.db, templateId, parsed.data.version);
+    if (revision === undefined)
+        return {
+            ok: false,
+            reason: "not-found",
+            message: "That version of the template doesn't exist. Reload the template.",
+        };
+    const checks = [
+        ...documentChecks(revision.document, templateId),
+        ...(await more(revision.document, parsed.data.version)),
+    ];
+    const passed = checks.every((check) => check.ok);
+    deps.db
+        .prepare("UPDATE design_template_revisions SET checks_json=?, gate=?, marked_at=? WHERE template_id=? AND version=?")
+        .run(JSON.stringify(checks), passed ? "ready" : revision.gate, passed ? deps.clock.now().toISOString() : revision.markedAt, templateId, parsed.data.version);
+    const failed = checks.filter((check) => !check.ok);
+    if (failed.length > 0)
+        return {
+            ok: false,
+            reason: "not-ready",
+            message: `Version ${String(parsed.data.version)} can't be marked ready yet: ${failed.map((check) => check.sentence).join(" ")}`,
+            current: failed,
+        };
+    const template = getTemplate(deps.db, templateId);
+    return template === undefined ? notFound : { ok: true, value: template };
+}

package/dist/slices/document/fonts.js

@@ -1,4 +1,5 @@
 import { readFileSync } from "node:fs";
+import { errorText } from "../../kernel/errors.js";
 // The bundled Cinzel weights and Literata styles (SIL OFL 1.1, assets/document/fonts) and the
 // page texture. Read on every render rather than kept in memory: eight fonts and one image
 // are about a megabyte and a half, and a document is made once per article.
@@ -32,7 +33,7 @@ export function readDocumentAssets() {
         };
     }
     catch (error) {
-        throw new Error(`Slopify couldn't read the fonts and page texture it makes documents with (${error instanceof Error ? error.message : String(error)}). Its installation is incomplete: reinstall or update Slopify, then use Try again on Document.`, { cause: error });
+        throw new Error(`Slopify couldn't read the fonts and page texture it makes documents with (${errorText(error)}). Its installation is incomplete: reinstall or update Slopify, then use Try again on Document.`, { cause: error });
     }
 }
 export function registerFonts(doc, fonts) {

package/dist/slices/episodes/summarize.js

@@ -1,11 +1,13 @@
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
+import { errorText } from "../../kernel/errors.js";
 import { projectById } from "../admission/repo.js";
 import { castMentions } from "../channels/cast-match.js";
 import { castOfChannel, projectChannelId } from "../channels/repo.js";
 import { reviewedByAgent } from "../reviews/model.js";
 import { outputPath } from "../storage/layout.js";
 import { outputsOf } from "../storage/repo.js";
+import { isTemplateSample } from "../template-studio/repo.js";
 import { episodeMemoryOn, memoryOfProject, saveGeneratedMemory } from "./repo.js";
 // When a project finishes, a small LLM call writes what the episode covered (at most
 // `summaryWordsMax` words) for its channel's episode memory. It never fails the project: every
@@ -51,7 +53,7 @@ export async function summarizeEpisode(deps, projectId, signal) {
             return "failed";
         deps.log.write("warn", "episode.memory", {
             projectId,
-            detail: `The episode summary wasn't saved: ${error instanceof Error ? error.message : String(error)}. The project is unaffected; only later episodes won't be reminded of this one. Check the project's text model in Settings → Providers.`,
+            detail: `The episode summary wasn't saved: ${errorText(error)}. The project is unaffected; only later episodes won't be reminded of this one. Check the project's text model in Settings → Providers.`,
         });
         return "failed";
     }
@@ -60,6 +62,8 @@ async function summarize(deps, projectId, signal) {
     const project = projectById(deps.db, projectId);
     if (project === undefined)
         return "gone";
+    if (isTemplateSample(deps.db, projectId))
+        return "sample";
     const channelId = projectChannelId(deps.db, projectId);
     if (!episodeMemoryOn(deps.db, channelId))
         return "off";

package/dist/slices/estimate/index.js

@@ -3,7 +3,10 @@ import { sourceOf, thumbnailCountOf } from "../admission/model.js";
 import { imageSecondsProblem, usesDescribedNarration, usesNarrationPreparation, usesReference, usesShorts, usesYoutubeDescription, } from "../admission/rules.js";
 import { plainText } from "../article/plain.js";
 import { splitEndMatter } from "../article/split.js";
+import { usesAppearance } from "../images/appearance.js";
 import { narrationMinutes, plannedImageCount, scalesImages } from "../images/scale.js";
+import { usesSlopifyScene } from "../images/scenes.js";
+import { keywordUsesOf, placeOfKey } from "../keywords/rules.js";
 import { describedBlocks, narrationBlocks } from "../narration/blocks.js";
 import { chunkNarration, defaultChunking } from "../narration/chunk.js";
 import { describeMessages } from "../narration/describe.js";
@@ -13,12 +16,15 @@ import { defaultReviewPrompts, reviewedByAgent, reviewPromptKey, reviewRetriesOf
 import { activeReviewStages } from "../reviews/rules.js";
 import { isLocalCliProvider } from "../settings/model.js";
 import { defaultShortsImagePrompt, defaultShortsPrompt, shortsImageUpperBound, shortsSettingsProblems, } from "../shorts/model.js";
+import { socialPlatforms } from "../social/model.js";
+import { defaultPostPrompt } from "../social/post-prompt.js";
 import { animatedClipSeconds, animatedImageIndexes, usesAnimation, videoEditProblems, } from "../video/edit-settings.js";
-import { usesVoices } from "../voices/model.js";
+import { usesScriptPrompt, usesVoices } from "../voices/model.js";
 import { defaultDescriptionPrompt } from "../youtube/model.js";
 // ceiling: the most chapters "Chapter openers" is charged for before the article exists, the
 // top of the 5-12 chapters the built-in YouTube description prompt asks for.
 const chapterOpenersMax = 12;
+import { sampleSpokenWords } from "../template-studio/scope.js";
 import { estimateRequests, groupEstimateRows } from "./requests.js";
 export { estimateRequests } from "./requests.js";
 export function estimateRun(draft, rendered, expectedWords, catalogue) {
@@ -55,7 +61,8 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
             key === "description" ||
             key === "shorts" ||
             key === "shortsImage" ||
-            key.startsWith("review.")
+            key.startsWith("review.") ||
+            key.startsWith("social.")
             ? 0
             : value.length), 0);
     const local = (stage, detail) => {
@@ -127,6 +134,8 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
                 detail: "TTS character charges include delivery tags; their length is known after preparation.",
             });
         }
+        // A template studio sample says only the narration's opening (`template-studio/scope.ts`).
+        const spokenChars = draft.sample === undefined ? articleChars : Math.min(articleChars, sampleSpokenWords * 6);
         const extras = ["intro", "outro"].reduce((n, key) => n + (rendered[key]?.length ?? 0), 0);
         const llmExtras = (draft.intro?.mode === "llm" ? 1200 : 0) + (draft.outro?.mode === "llm" ? 1200 : 0);
         const choice = { stage: "Narration", provider: tts.provider, model: tts.model };
@@ -140,7 +149,7 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
                     stage: "Narration",
                     provider: speaker.voice.provider,
                     model: speaker.voice.model,
-                    characters: Math.round(articleChars / speakers.length),
+                    characters: Math.round(spokenChars / speakers.length),
                     detail: `${speaker.name.trim() || "A speaker"}: assumes every speaker says about the same.`,
                 });
             if (extras + llmExtras > 0)
@@ -152,7 +161,7 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
         }
         else
             requests.push(generatedArticle || llmExtras > 0
-                ? { ...choice, kind: "tts-estimate", characters: articleChars + extras + llmExtras }
+                ? { ...choice, kind: "tts-estimate", characters: spokenChars + extras + llmExtras }
                 : {
                     ...choice,
                     kind: "tts",
@@ -178,9 +187,29 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
         });
     if (images === 0)
         local("Images", "Provided or off.");
-    // Scenes from the article: one call reads the article and writes every image's scene.
-    if (images > 0 && draft.imageScenes === true)
+    // Scenes from the article: one call reads the article and writes every image's scene. A
+    // `Slopify_` scene keyword turns it on for the pictures that use it, switch or no switch.
+    const pictureKeys = Object.keys(rendered).filter((key) => /^imagePrompts\.\d+$/.test(key));
+    if (images > 0 &&
+        (draft.imageScenes === true || pictureKeys.some((key) => usesSlopifyScene(rendered[key]))))
         text("Image scenes", articleChars + 1500, 120 * images);
+    if (draft.sources.thumbnail === "from_prompt" && usesSlopifyScene(rendered.thumbnailPrompt))
+        text("Thumbnail scenes", articleChars + 1500, 120 * thumbnailCountOf(draft));
+    // The keyword digest: one call reads the article and writes every digest keyword.
+    const placed = Object.entries(rendered).flatMap(([key, body]) => {
+        const place = placeOfKey(key, { script: usesScriptPrompt(draft) });
+        return place === undefined ? [] : [{ field: key, place, body }];
+    });
+    if (keywordUsesOf(placed).digest !== undefined)
+        text("Keyword digest", articleChars + 1500, 600, "One call reads the article and writes every digest keyword the run uses.");
+    // `{{Appearance}}` (or `{{Slopify_Appearance}}`): one call with web search looks up the looks.
+    if ([
+        ...(images > 0 ? pictureKeys : []),
+        ...(draft.sources.thumbnail === "from_prompt" ? ["thumbnailPrompt"] : []),
+        "referencePrompt",
+        "shortsImage",
+    ].some((key) => usesAppearance(rendered[key])))
+        text("Appearance lookup", articleChars + 1500, 1500, "One call with web search looks up how the subject and characters look.");
     // The establishing image is one more image when it is made from a prompt.
     if (usesReference(draft) && draft.reference?.source === "prompt")
         requests.push({
@@ -210,6 +239,13 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
             : defaultDescriptionPrompt.length) +
             Math.round(articleChars * 1.05) +
             1500, 2400, "One LLM call on the timed transcript.");
+    // Each site whose post is written by a post prompt: one call that reads the article.
+    for (const platform of socialPlatforms) {
+        if (draft.social?.[platform]?.text !== "prompt")
+            continue;
+        const own = rendered[`social.${platform}`]?.trim() ?? "";
+        text("Posts", (own === "" ? defaultPostPrompt.length : own.length) + articleChars + 400, 600, "One LLM call per site whose post a post prompt writes, reading the article.");
+    }
     // Shorts: one call picks the clips from the numbered transcript, one per clip writes its
     // image prompts, and the images are charged at the most the step can ask for, every clip
     // at the longest length allowed.
@@ -273,7 +309,9 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
                 ? articleChars + promptChars
                 : stage === "narration"
                     ? Math.round(articleChars * 2.1)
-                    : 1500;
+                    : stage === "promise"
+                        ? articleChars + 1500
+                        : 1500;
             for (let index = 0; index < items; index++)
                 requests.push({
                     kind: "llm",

package/dist/slices/fonts/catalog.js

@@ -2,8 +2,9 @@ import { createHash } from "node:crypto";
 import { lstat, readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { isUnreachablePath } from "../../kernel/errors.js";
 import { discoverSystemFonts } from "./discovery.js";
-import { readFontFile, unavailable } from "./files.js";
+import { readFontFile } from "./files.js";
 import { fontSummary } from "./model.js";
 import { readFontMetadata } from "./sfnt.js";
 export const fontIdPattern = /^(?:default|(?:system|uploaded)-[a-f0-9]{64})$/;
@@ -86,7 +87,7 @@ async function uploadedFonts(paths, wanted) {
         names = wanted === undefined ? await readdir(root) : [`${wanted}.ttf`, `${wanted}.otf`];
     }
     catch (error) {
-        if (unavailable(error))
+        if (isUnreachablePath(error))
             return [];
         throw error;
     }

package/dist/slices/fonts/discovery.js

@@ -2,7 +2,8 @@ import { createHash } from "node:crypto";
 import { opendir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { extname, join, posix, win32 } from "node:path";
-import { readFontFile, unavailable } from "./files.js";
+import { isUnreachablePath } from "../../kernel/errors.js";
+import { readFontFile } from "./files.js";
 import { readFontMetadata } from "./sfnt.js";
 export function systemFontDirectories(platform, env, home) {
     if (platform === "win32")
@@ -46,7 +47,7 @@ export async function scanFontDirectories(roots) {
             }
         }
         catch (error) {
-            if (!unavailable(error))
+            if (!isUnreachablePath(error))
                 throw error;
         }
     }

package/dist/slices/fonts/files.js

@@ -1,11 +1,7 @@
 import { constants } from "node:fs";
 import { lstat, open } from "node:fs/promises";
+import { isUnreachablePath } from "../../kernel/errors.js";
 import { fontMaxBytes } from "./model.js";
-export function unavailable(error) {
-    return (error instanceof Error &&
-        "code" in error &&
-        ["ENOENT", "ENOTDIR", "EACCES", "EPERM", "ELOOP"].includes(String(error.code)));
-}
 export async function readFontFile(path) {
     try {
         if (!(await lstat(path)).isFile())
@@ -30,7 +26,7 @@ export async function readFontFile(path) {
         }
     }
     catch (error) {
-        if (unavailable(error))
+        if (isUnreachablePath(error))
             return undefined;
         throw error;
     }

package/dist/slices/fonts/index.js

@@ -1,5 +1,4 @@
 export { fontIdPattern, isMissingFont, listFonts, resolveBoldFont, resolveFont, } from "./catalog.js";
 export { fontMaxBytes } from "./model.js";
 export { previewFont } from "./preview.js";
-export { standaloneFont } from "./sfnt.js";
 export { uploadFont } from "./upload.js";

package/dist/slices/fonts/sfnt.js

@@ -266,8 +266,50 @@ function checksum(bytes) {
 export function mappedCodepoints(content, index, codepoints) {
     const bytes = Buffer.from(content.buffer, content.byteOffset, content.byteLength);
     const face = directories(bytes)?.[index];
-    const table = face?.tables.get("cmap");
-    if (face === undefined || table === undefined || !validCmap(bytes, table))
+    const cmap = face === undefined ? undefined : unicodeCmap(bytes, face);
+    if (cmap === undefined)
+        return undefined;
+    const found = new Set();
+    for (const codepoint of codepoints)
+        if (glyphOf(bytes, cmap.at, cmap.format, codepoint, cmap.end) !== 0)
+            found.add(codepoint);
+    return found;
+}
+// How wide each character is drawn, as a share of the ASS font size: the glyph's advance
+// (hmtx) over the height libass sizes a font by (OS/2 winAscent + winDescent, else the em).
+// Undefined for a character the font has no glyph for, and the whole answer undefined when
+// the font's tables can't be read; the caller then estimates.
+export function fontAdvances(content, index) {
+    const bytes = Buffer.from(content.buffer, content.byteOffset, content.byteLength);
+    const face = directories(bytes)?.[index];
+    const cmap = face === undefined ? undefined : unicodeCmap(bytes, face);
+    const head = face?.tables.get("head");
+    const hhea = face?.tables.get("hhea");
+    const hmtx = face?.tables.get("hmtx");
+    if (cmap === undefined || head === undefined || hhea === undefined || hmtx === undefined)
+        return undefined;
+    const units = bytes.readUInt16BE(head.offset + 18);
+    const metrics = bytes.readUInt16BE(hhea.offset + 34);
+    const os2 = face?.tables.get("OS/2");
+    const win = os2 !== undefined && os2.length >= 78
+        ? bytes.readUInt16BE(os2.offset + 74) + bytes.readUInt16BE(os2.offset + 76)
+        : 0;
+    const height = win >= units / 2 && win <= units * 4 ? win : units;
+    const cache = new Map();
+    return (codepoint) => {
+        if (cache.has(codepoint))
+            return cache.get(codepoint);
+        const glyph = glyphOf(bytes, cmap.at, cmap.format, codepoint, cmap.end);
+        // Glyphs past the last full metric share its advance (validated in `validTables`).
+        const advance = glyph === 0 ? undefined : bytes.readUInt16BE(hmtx.offset + Math.min(glyph, metrics - 1) * 4);
+        const share = advance === undefined ? undefined : advance / height;
+        cache.set(codepoint, share);
+        return share;
+    };
+}
+function unicodeCmap(bytes, face) {
+    const table = face.tables.get("cmap");
+    if (table === undefined || !validCmap(bytes, table))
         return undefined;
     const count = bytes.readUInt16BE(table.offset + 2);
     let best;
@@ -283,14 +325,7 @@ export function mappedCodepoints(content, index, codepoints) {
         if (best === undefined || format > best.format)
             best = { at, format };
     }
-    if (best === undefined)
-        return undefined;
-    const end = table.offset + table.length;
-    const found = new Set();
-    for (const codepoint of codepoints)
-        if (glyphOf(bytes, best.at, best.format, codepoint, end) !== 0)
-            found.add(codepoint);
-    return found;
+    return best === undefined ? undefined : { ...best, end: table.offset + table.length };
 }
 function glyphOf(bytes, at, format, codepoint, end) {
     if (format === 12) {

package/dist/slices/images/appearance.js

@@ -1,12 +1,15 @@
 import { z } from "zod";
+import { jsonBetween } from "../../kernel/json-answer.js";
 import { appearanceKeyword, detectSlots, render } from "../admission/substitute.js";
 // How things look, looked up rather than guessed: when an image or thumbnail prompt has
 // `{{Appearance}}`, one call to the project's AI model searches the web for how the video's
 // subject and every named character in the article look in their best-known depiction. Each
 // picture then gets the subject's look and the looks of the characters its scene names, so a
 // figure looks the same from image to image and like the one people know.
+// `{{Appearance}}` is the old name of `{{Slopify_Appearance}}`; both mean the same.
+const appearanceNames = [appearanceKeyword, "Slopify_Appearance"];
 export function usesAppearance(body) {
-    return body != null && detectSlots(body).names.includes(appearanceKeyword);
+    return body != null && detectSlots(body).names.some((name) => appearanceNames.includes(name));
 }
 const figureSchema = z.object({
     name: z.string(),
@@ -42,7 +45,7 @@ export function appearanceMessages(brief) {
 }
 export function checkAppearance(text) {
     const fix = "Use Try again; if it keeps happening, choose another model in the Providers section of Edit project.";
-    const parsed = appearanceSchema.safeParse(jsonObjectOf(text));
+    const parsed = appearanceSchema.safeParse(jsonBetween(text, "{", "}"));
     if (!parsed.success)
         return { ok: false, reason: `The AI model didn't answer with the looks it looked up. ${fix}` };
     const tidy = (figure) => ({
@@ -81,7 +84,7 @@ export function appearanceFor(appearance, scene, options = {}) {
 // The prompt with its looks; a line asking for looks nobody in the picture has is left out.
 export function withAppearance(body, text) {
     if (text !== "")
-        return render(body, { [appearanceKeyword]: text });
+        return render(body, { [appearanceKeyword]: text, Slopify_Appearance: text });
     return body
         .split("\n")
         .filter((line) => !usesAppearance(line))
@@ -93,15 +96,3 @@ function names(text, name) {
     const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     return new RegExp(`(^|[^\\p{L}\\p{N}])${escaped}($|[^\\p{L}\\p{N}])`, "iu").test(text);
 }
-function jsonObjectOf(text) {
-    const start = text.indexOf("{");
-    const end = text.lastIndexOf("}");
-    if (start === -1 || end <= start)
-        return undefined;
-    try {
-        return JSON.parse(text.slice(start, end + 1));
-    }
-    catch {
-        return undefined;
-    }
-}