@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/slices/estimate/requests.js

@@ -38,8 +38,8 @@ export function estimateRequests(requests, catalogue) {
         catalogueDate: catalogue.updatedAt,
         assumptions: [
             "Planning estimate, not a spending limit. Generated lengths use a ±50% range; actual output can exceed it.",
-            "Assumes roughly 6 characters per word, 4 characters per token, and 150 spoken words per minute.",
-            "Retries, extra reasoning tokens, web tools, taxes, discounts and included credits are excluded. Unknown charges are not counted as zero.",
+            "Assumes about 6 letters per word and 150 spoken words a minute.",
+            "Retries, extra thinking, web search, taxes, discounts and included credits are not counted. A charge with no listed price is not counted as zero.",
         ],
     };
 }
@@ -99,8 +99,8 @@ function onPlan(request, catalogue) {
         high: 0,
         detail: request.detail ??
             (amount === null
-                ? "Runs on your CLI plan, so it adds no charge; no API price is listed for this model."
-                : `Runs on your CLI plan, so it adds no charge; priced as ${api?.name ?? "the API model"} through the API.`),
+                ? "Runs on your subscription at no extra charge; no API price is listed for this model."
+                : `Runs on your subscription at no extra charge; through the API it would cost what ${api?.name ?? "the API model"} costs.`),
         onPlan: true,
         apiLow: amount === null ? null : amount * 0.5,
         apiHigh: amount === null ? null : amount * 1.5,

package/dist/slices/fixes/rules.js

@@ -35,7 +35,9 @@ export function fixFor(step) {
         const name = nameOf(step.provider);
         return {
             kind: "provider-settings",
-            label: name === undefined ? "Open Settings → Providers" : `Open Settings → Providers → ${name}`,
+            label: name === undefined
+                ? "Open Settings → Keys & services"
+                : `Open Settings → Keys & services → ${name}`,
             provider: step.provider ?? "",
         };
     }

package/dist/slices/fonts/catalog.js

@@ -2,8 +2,10 @@ 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 { editSettings } from "../../kernel/ports/settings-places.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})$/;
@@ -54,7 +56,7 @@ export async function resolveBoldFont(paths, id) {
     };
 }
 export function missingFont() {
-    return new Error("The chosen caption font is no longer available; it may have been uninstalled or deleted. Choose another font in Edit project → Subtitles, then try again.", {
+    return new Error(`The chosen caption font is no longer available; it may have been uninstalled or deleted. Choose another font in ${editSettings.captions}, then try again.`, {
         cause: "font-not-found",
     });
 }
@@ -86,7 +88,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/coverage.js

@@ -1,5 +1,6 @@
 import { fileURLToPath } from "node:url";
 import { languageInfo, languageLetters } from "../../kernel/ports/languages.js";
+import { editSettings } from "../../kernel/ports/settings-places.js";
 import { resolveBoldFont, resolveFont } from "./catalog.js";
 import { discoverSystemFonts } from "./discovery.js";
 import { readFontFile } from "./files.js";
@@ -45,7 +46,7 @@ export async function captionFont(deps, fontId, language) {
     for (const font of await deps.system())
         if (await covers(font, letters))
             return font;
-    throw new Error(`The caption font ${chosen.name} has no ${info.name} letters, and Slopify doesn't ship a font for ${info.name} (they are 10-20 MB). In Edit project → Subtitles, use Upload font in the caption font picker to add a font that has them (for example Noto Sans ${info.code === "ja" ? "JP" : info.code === "ko" ? "KR" : "SC"} from fonts.google.com), choose it there, then Try again.`);
+    throw new Error(`The caption font ${chosen.name} has no ${info.name} letters, and Slopify doesn't ship a font for ${info.name} (they are 10-20 MB). In ${editSettings.captions}, use Upload font in the caption font picker to add a font that has them (for example Noto Sans ${info.code === "ja" ? "JP" : info.code === "ko" ? "KR" : "SC"} from fonts.google.com), choose it there, then Try again.`);
 }
 // The same for text drawn bold (the shorts' captions): the chosen font's bold face when it has
 // the letters, else the fallback, which the renderer emboldens.

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,16 @@
 import { z } from "zod";
+import { jsonBetween } from "../../kernel/json-answer.js";
+import { editSettings } from "../../kernel/ports/settings-places.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(),
@@ -41,8 +45,8 @@ 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 fix = `Use Try again; if it keeps happening, choose another model in ${editSettings.writer}.`;
+    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 +85,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 +97,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;
-    }
-}

package/dist/slices/images/scenes.js

@@ -1,30 +1,80 @@
 import { z } from "zod";
+import { jsonBetween } from "../../kernel/json-answer.js";
+import { editSettings } from "../../kernel/ports/settings-places.js";
 import { detectSlots, render, sceneKeyword } from "../admission/substitute.js";
 // Scenes from the article (Images → Scenes from the article): each image is drawn from its
 // own scene instead of the same text every time. One call to the project's AI model reads the
 // article and writes every scene, following the article from its opening to its end in the
 // order the images are shown.
+// The keywords Slopify fills per picture from the scenes call (`keywords/specs.ts`): any of them
+// turns scenes on for that picture, whatever the Images switch says.
+export const slopifySceneKeywords = ["Slopify_Scene", "Slopify_Setting", "Slopify_Mood"];
+const sceneNames = [sceneKeyword, "Slopify_Scene"];
+const detailNames = ["Slopify_Setting", "Slopify_Mood"];
+// `{{Scene}}` or `{{Slopify_Scene}}`: where the scene goes.
 export function usesScene(body) {
+    return body != null && detectSlots(body).names.some((name) => sceneNames.includes(name));
+}
+// The old name, which follows Images → Scenes from the article as it always did.
+export function usesLegacyScene(body) {
     return body != null && detectSlots(body).names.includes(sceneKeyword);
 }
-// The prompt with its scene: where the prompt has `{{Scene}}`, there; otherwise as a line of
-// its own after the prompt's first paragraph, so any prompt takes a scene without editing.
-export function withScene(body, scene) {
-    if (usesScene(body))
-        return render(body, { [sceneKeyword]: scene });
-    const at = body.indexOf("\n\n");
+// `{{Slopify_Scene}}`, `{{Slopify_Setting}}` or `{{Slopify_Mood}}`: the picture gets its scene.
+export function usesSlopifyScene(body) {
+    return (body != null &&
+        detectSlots(body).names.some((name) => slopifySceneKeywords.includes(name)));
+}
+// `{{Slopify_Setting}}` or `{{Slopify_Mood}}`: the scenes call writes them too.
+export function wantsSceneDetails(body) {
+    return body != null && detectSlots(body).names.some((name) => detailNames.includes(name));
+}
+// The prompt with its scene: where the prompt has `{{Scene}}` or `{{Slopify_Scene}}`, there;
+// otherwise, while the Images switch is on (`legacy`), as a line of its own after the prompt's
+// first paragraph, so any prompt takes a scene without editing. With the switch off a picture is
+// here only for its `Slopify_` keywords, and a `{{Scene}}` line is left out as it always was.
+// The setting and mood go where the prompt asks; a line asking for one not written is left out.
+export function withScene(body, scene, options = {}) {
+    const legacy = options.legacy !== false;
+    const text = legacy ? body : withoutLines(body, [sceneKeyword]);
+    const detailed = withDetails(text, options);
+    if (usesScene(detailed))
+        return render(detailed, { [sceneKeyword]: scene, Slopify_Scene: scene });
+    if (!legacy)
+        return detailed;
+    const at = detailed.indexOf("\n\n");
     return at === -1
-        ? `${body}\n\nScene: ${scene}`
-        : `${body.slice(0, at)}\n\nScene: ${scene}${body.slice(at)}`;
+        ? `${detailed}\n\nScene: ${scene}`
+        : `${detailed.slice(0, at)}\n\nScene: ${scene}${detailed.slice(at)}`;
 }
-// The prompt with the switch off: a line that holds `{{Scene}}` is left out, so the image is
-// drawn from the rest of the prompt as it always was.
+// A picture that is drawn without scenes (the establishing image): a line holding a `Slopify_`
+// scene keyword is left out, and `{{Scene}}` stays as it always did.
+export function withoutSlopifyScene(body) {
+    return withoutLines(body, slopifySceneKeywords);
+}
+// The prompt with no scene: a line that holds a scene keyword is left out, so the image is drawn
+// from the rest of the prompt as it always was.
 export function withoutScene(body) {
-    if (!usesScene(body))
+    return withoutLines(body, [...sceneNames, ...detailNames]);
+}
+function withDetails(body, details) {
+    if (!wantsSceneDetails(body))
+        return body;
+    const missing = [
+        ...(details.setting?.trim() ? [] : ["Slopify_Setting"]),
+        ...(details.mood?.trim() ? [] : ["Slopify_Mood"]),
+    ];
+    return render(withoutLines(body, missing), {
+        ...(details.setting?.trim() ? { Slopify_Setting: details.setting.trim() } : {}),
+        ...(details.mood?.trim() ? { Slopify_Mood: details.mood.trim() } : {}),
+    });
+}
+function withoutLines(body, names) {
+    const holds = (line) => detectSlots(line).names.some((name) => names.includes(name));
+    if (!body.split("\n").some(holds))
         return body;
     return body
         .split("\n")
-        .filter((line) => !usesScene(line))
+        .filter((line) => !holds(line))
         .join("\n")
         .replace(/\n{3,}/g, "\n\n")
         .trim();
@@ -42,7 +92,25 @@ const countLine = /^Pictures: (\d+)$/m;
 // prompt asks for one with `{{Scene}}`. They are not tied to a stretch of the article: each is
 // the moment that would make someone click, a different one for each thumbnail.
 const thumbnailLine = /^Thumbnails: (\d+)$/m;
+// With `details`, each scene comes with its setting and mood for `{{Slopify_Setting}}` and
+// `{{Slopify_Mood}}`; without, the request is the one it always was.
 export function sceneMessages(brief) {
+    const plain = plainSceneMessages(brief);
+    return brief.details === true ? plain.map(askingDetails) : plain;
+}
+const answerLine = /^Answer with a JSON array of exactly (\d+) strings, (.*), and nothing else\.$/m;
+function askingDetails(message) {
+    if (message.role !== "system")
+        return message;
+    return {
+        ...message,
+        content: message.content.replace(answerLine, (_whole, total, order) => [
+            "For each scene also write its setting: the era and place of that moment in a few words (period, region, season), so the picture stays true to its time; and its mood: the feeling of that moment in one to three words (calm, tense, sad), for the picture's light and colour.",
+            `Answer with a JSON array of exactly ${total} objects, ${order}, each {"scene": "…", "setting": "…", "mood": "…"}, and nothing else.`,
+        ].join("\n\n")),
+    };
+}
+function plainSceneMessages(brief) {
     const count = brief.pictures.length;
     const thumbnails = brief.thumbnails ?? 0;
     if (thumbnails > 0)
@@ -120,15 +188,33 @@ function withThumbnails(brief, count, thumbnails) {
         },
     ];
 }
+const sceneAnswer = z.array(z.union([
+    z.string(),
+    z.object({
+        scene: z.string(),
+        setting: z.string().optional(),
+        mood: z.string().optional(),
+    }),
+]));
+// A list of scenes, or of scenes with their setting and mood (`details`, only then present).
 export function checkScenes(text, count) {
-    const fix = "Use Try again; if it keeps happening, choose another model in the Providers section of Edit project.";
-    const parsed = z.array(z.string()).safeParse(jsonArrayOf(text));
+    const fix = `Use Try again; if it keeps happening, choose another model in ${editSettings.writer}.`;
+    const parsed = sceneAnswer.safeParse(jsonBetween(text, "[", "]"));
     if (!parsed.success)
         return {
             ok: false,
             reason: `The AI model didn't answer with a list of image scenes. ${fix}`,
         };
-    const scenes = parsed.data.map((scene) => scene.replace(/\s+/g, " ").trim());
+    const tidy = (value) => value.replace(/\s+/g, " ").trim();
+    const scenes = parsed.data.map((one) => tidy(typeof one === "string" ? one : one.scene));
+    const details = parsed.data.some((one) => typeof one !== "string")
+        ? parsed.data.map((one) => typeof one === "string"
+            ? {}
+            : {
+                ...(one.setting === undefined ? {} : { setting: tidy(one.setting) }),
+                ...(one.mood === undefined ? {} : { mood: tidy(one.mood) }),
+            })
+        : undefined;
     if (scenes.length !== count)
         return {
             ok: false,
@@ -136,17 +222,5 @@ export function checkScenes(text, count) {
         };
     if (scenes.some((scene) => scene === ""))
         return { ok: false, reason: `One of the AI model's image scenes is empty. ${fix}` };
-    return { ok: true, scenes };
-}
-function jsonArrayOf(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;
-    }
+    return { ok: true, scenes, ...(details === undefined ? {} : { details }) };
 }

package/dist/slices/keywords/digest.js

@@ -0,0 +1,85 @@
+import { z } from "zod";
+import { editSettings } from "../../kernel/ports/settings-places.js";
+import { keywordSpecs } from "./specs.js";
+// The keyword digest: one call to the project's AI model reads the article once and writes every
+// digest keyword (`{{Slopify_Summary}}`, `{{Slopify_Hook}}`…), so a run that uses several pays for
+// one call. It asks for all six every time, so adding one more digest keyword to a prompt later
+// reuses the same answer.
+export const digestNames = keywordSpecs
+    .filter((spec) => spec.filler === "digest")
+    .map((spec) => spec.name);
+export function digestMessages(brief) {
+    return [
+        {
+            role: "system",
+            content: [
+                "You write short texts about a narrated video from its article, for its pictures, thumbnail, description, shorts and reviews.",
+                "summary: two or three sentences on what the video covers.",
+                "hook: the single most click-worthy idea of the video, in one sentence.",
+                "thumbnailText: two to four words to put on the thumbnail, in the video's language.",
+                "keyFacts: three to five striking facts the article states, each one sentence.",
+                "quote: one quotable line from the article, as it is written there.",
+                "tags: five to fifteen search terms someone would type to find this video.",
+                "Use only what the article says. Write in the article's language.",
+                'Answer with JSON and nothing else: {"summary": "…", "hook": "…", "thumbnailText": "…", "keyFacts": ["…"], "quote": "…", "tags": ["…"]}.',
+            ].join("\n\n"),
+        },
+        {
+            role: "user",
+            content: [`Video: ${brief.title}`, `Article:\n\n${brief.article}`].join("\n\n"),
+        },
+    ];
+}
+const listOrText = z.union([z.array(z.string()), z.string()]);
+const digestSchema = z.object({
+    summary: z.string(),
+    hook: z.string(),
+    thumbnailText: z.string(),
+    keyFacts: listOrText,
+    quote: z.string(),
+    tags: listOrText,
+});
+export function checkDigest(text) {
+    const fix = `Use Try again; if it keeps happening, choose another model in ${editSettings.writer}.`;
+    const parsed = digestSchema.safeParse(jsonObjectOf(text));
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: `The AI model didn't answer with the keyword digest (summary, hook, thumbnail text, key facts, quote and tags). ${fix}`,
+        };
+    const tidy = (value) => value.replace(/\s+/g, " ").trim();
+    const list = (value) => (typeof value === "string" ? value.split("\n") : value)
+        .map((one) => tidy(one).replace(/^[-•*]\s*/, ""))
+        .filter((one) => one !== "");
+    const { summary, hook, thumbnailText, keyFacts, quote, tags } = parsed.data;
+    const digest = {
+        Slopify_Summary: tidy(summary),
+        Slopify_Hook: tidy(hook),
+        Slopify_Thumbnail_Text: tidy(thumbnailText),
+        Slopify_Key_Facts: list(keyFacts).join("\n"),
+        Slopify_Quote: tidy(quote),
+        Slopify_Tags: (typeof tags === "string" ? tags.split(",") : tags)
+            .map(tidy)
+            .filter((one) => one !== "")
+            .join(", "),
+    };
+    const empty = digestNames.filter((name) => (digest[name] ?? "") === "");
+    if (empty.length > 0)
+        return {
+            ok: false,
+            reason: `The AI model left part of the keyword digest empty (${empty.map((name) => `{{${name}}}`).join(", ")}). ${fix}`,
+        };
+    return { ok: true, digest };
+}
+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;
+    }
+}

package/dist/slices/keywords/facts.js

@@ -0,0 +1,92 @@
+// The facts a run copies when it starts, for the keywords Slopify fills from them: what the
+// channel, its links, its cast, its brand kit and its other projects are now. Later edits there
+// never change a project already made; Edit project's Refresh keyword facts copies them again.
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { listProjects } from "../admission/repo.js";
+import { castOfChannel, channelById, projectChannels, resolveChannelId } from "../channels/repo.js";
+import { readFontMetadata } from "../fonts/sfnt.js";
+import { seriesOf } from "../studio/plan-model.js";
+import { allReleases } from "../studio/releases.js";
+import { videoOf } from "../studio/videos.js";
+import { readChannelLinksFor } from "../youtube/edits-repo.js";
+// ceiling: the titles a prompt is told about. A channel with hundreds of videos would fill the
+// prompt with titles; the newest are the ones it is likeliest to repeat.
+export const coveredBeforeMax = 50;
+// `projectId` is the project the facts are for, when it exists already (a refresh): it is
+// neither its own previous video nor one it covered before.
+export function keywordFactsFor(deps, draft, now, projectId) {
+    const { db } = deps;
+    const channelId = resolveChannelId(db, draft.channelId);
+    const channel = channelById(db, channelId);
+    const channels = projectChannels(db);
+    const projects = listProjects(db);
+    // A refresh sees the channel as it was before this project, never the episodes made after it.
+    const made = projects.find((project) => project.id === projectId)?.createdAt;
+    const own = projects.filter((project) => project.id !== projectId &&
+        (made === undefined || project.createdAt < made) &&
+        (channels.get(project.id) ?? channelId) === channelId);
+    const series = seriesOf(draft);
+    const sameSeries = own.filter((project) => seriesOf(project.config) === series);
+    const later = projects.filter((project) => project.id !== projectId &&
+        seriesOf(project.config) === series &&
+        (channels.get(project.id) ?? channelId) === channelId);
+    const previous = sameSeries[0];
+    const previousVideo = previous === undefined ? undefined : videoOf(db, previous.id, null)?.videoId;
+    const upcoming = allReleases(db).find((release) => release.short === 0 &&
+        Date.parse(release.at) > now.getTime() &&
+        later.some((project) => project.id === release.projectId));
+    const next = upcoming === undefined ? undefined : later.find((one) => one.id === upcoming.projectId);
+    const links = readChannelLinksFor(db, channelId);
+    const cast = castOfChannel(db, channelId);
+    const brand = draft.useBrandKit === false ? undefined : channel?.brand;
+    const colours = unique([brand?.captionColor, brand?.captionOutlineColor, brand?.titleColor]);
+    const fonts = unique([brand?.captionFontId, brand?.titleFontId].map((id) => id === undefined ? undefined : fontName(deps.paths, id)));
+    return {
+        ...(channel === undefined ? {} : { channel: channel.name }),
+        ...(channel?.seriesBrief.trim() ? { series: channel.seriesBrief.trim() } : {}),
+        ...(links.length === 0 ? {} : { links: links.map(({ name, url }) => ({ name, url })) }),
+        ...(previous === undefined
+            ? {}
+            : {
+                previousVideo: {
+                    title: previous.title,
+                    ...(previousVideo === undefined ? {} : { url: `https://youtu.be/${previousVideo}` }),
+                },
+            }),
+        ...(next === undefined ? {} : { nextVideo: { title: next.title } }),
+        ...(cast.length === 0
+            ? {}
+            : { cast: cast.map(({ name, description }) => ({ name, description })) }),
+        ...(own.length === 0
+            ? {}
+            : { coveredBefore: own.slice(0, coveredBeforeMax).map((project) => project.title) }),
+        episode: sameSeries.length + 1,
+        ...(colours.length === 0 && fonts.length === 0 ? {} : { brand: { colours, fonts } }),
+    };
+}
+// A brand-kit font's name: the bundled one's, or an uploaded font's own. A system font is
+// found only by scanning the computer's font folders, which a run's start never waits for, so
+// it is left out.
+function fontName(paths, id) {
+    if (id === "default")
+        return "Barlow";
+    if (!/^uploaded-[a-f0-9]{64}$/.test(id))
+        return undefined;
+    for (const extension of [".ttf", ".otf"]) {
+        let bytes;
+        try {
+            bytes = readFileSync(join(paths.dataDir, "fonts", `${id}${extension}`));
+        }
+        catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT")
+                continue;
+            throw error;
+        }
+        return readFontMetadata(bytes)?.[0]?.family;
+    }
+    return undefined;
+}
+function unique(values) {
+    return [...new Set(values.filter((value) => value !== undefined))];
+}