@gentbajko/slopify 2.0.3 → 2.1.1

package/dist/kernel/db/migrations/0015-description-prompts.sql

@@ -0,0 +1,13 @@
+CREATE TABLE prompts_description_upgrade (
+  id TEXT PRIMARY KEY,
+  kind TEXT NOT NULL CHECK (kind IN ('article','image','thumbnail','narration','description')),
+  name TEXT NOT NULL,
+  body TEXT NOT NULL,
+  slots TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+INSERT INTO prompts_description_upgrade (id,kind,name,body,slots,updated_at)
+  SELECT id,kind,name,body,slots,updated_at FROM prompts;
+DROP TABLE prompts;
+ALTER TABLE prompts_description_upgrade RENAME TO prompts;
+CREATE UNIQUE INDEX prompts_name ON prompts(kind,lower(name));

package/dist/kernel/pipeline.js

@@ -3,7 +3,17 @@
 // runner may not import a slice to learn them.
 // The frame a run is made in, and the aspect an image is asked for: one set, named once.
 export const formats = ["16:9", "9:16"];
-export const stageKinds = ["research", "article", "audio", "images", "thumbnail", "video"];
+// Document is last so every screen that walks this list in order shows the six older
+// stages where they always were.
+export const stageKinds = [
+    "research",
+    "article",
+    "audio",
+    "images",
+    "thumbnail",
+    "video",
+    "document",
+];
 export const stageStates = [
     "pending",
     "running",

package/dist/kernel/ports/host-cli.js

@@ -1,3 +1,4 @@
+import { isAbsolute } from "node:path";
 import { z } from "zod";
 import { messageRoles, thinkingModes } from "./llm.js";
 import { llmDocumentsSchema } from "./llm-documents.js";
@@ -16,6 +17,9 @@ export const bridgeLimits = {
     generation: 5,
     metadata: 8,
 };
+/** A folder the helper refuses to open on purpose; the route answers it with a 403. */
+export class HostFolderRefused extends Error {
+}
 const short = z
     .string()
     .min(1)
@@ -40,6 +44,16 @@ export const hostImageSchema = z
     aspect: z.enum(["16:9", "9:16"]),
 })
     .strict();
+export const hostOpenFolderSchema = z
+    .object({
+    path: z
+        .string()
+        .min(1)
+        .max(4096)
+        .refine((v) => isAbsolute(v) && !/[\p{Cc}]/u.test(v)),
+})
+    .strict();
+export const hostOpenedSchema = z.object({ opened: z.literal(true) }).strict();
 export const hostStatusSchema = z
     .object({
     id: z.enum(hostCliIds),

package/dist/kernel/runner/graph.js

@@ -1,5 +1,7 @@
 // Images use saved prompts and can run immediately. A thumbnail's source and an
-// audio-only export narrow these dependencies through dependenciesOf().
+// audio-only export narrow these dependencies through dependenciesOf(). The document is
+// laid out from the article alone, with the thumbnail as its cover when there is one, so it
+// runs beside narration and images rather than after them.
 export const deps = {
     research: [],
     article: ["research"],
@@ -7,6 +9,7 @@ export const deps = {
     images: [],
     thumbnail: ["article"],
     video: ["article", "audio", "images", "thumbnail"],
+    document: ["article", "thumbnail"],
 };
 // `provided` and `skipped` release a dependency exactly as `done` does.
 export function satisfied(state) {
@@ -37,6 +40,8 @@ export function dependenciesOf(kind, sources) {
         return [];
     if (kind === "video" && sources.video === "off")
         return ["article", "audio"];
+    if (kind === "document" && sources.thumbnail === "off")
+        return ["article"];
     return deps[kind];
 }
 // The thin meter under a running row on Projects, averaging stage progress. Every stage

package/dist/main.js

@@ -27,6 +27,7 @@ import { ulidIds } from "./kernel/ids.js";
 import { acquireInstanceLock } from "./kernel/lock.js";
 import { openLog } from "./kernel/log.js";
 import { ensureDirs, layout, subtitleModelDir } from "./kernel/paths.js";
+import { stageKinds } from "./kernel/pipeline.js";
 import { sqliteAttempts } from "./kernel/runner/attempt-repo.js";
 import { createCheckpointAuthority, } from "./kernel/runner/checkpoint-authority.js";
 import { createRunner } from "./kernel/runner/index.js";
@@ -323,7 +324,10 @@ export async function boot(config, options = {}) {
             schedules: scheduleDeps,
             ...(rebuild.measureAudio === undefined ? {} : { measureAudio: rebuild.measureAudio }),
             openFolder,
-            folderLocation: await dockerFolderConfiguration(process.env, paths.projects),
+            folderLocation: {
+                ...(await dockerFolderConfiguration(process.env, paths.projects)),
+                ...(hostCli === undefined ? {} : { openOnHost: hostCli.openFolder }),
+            },
             ...(dockerState === undefined ? {} : { installationPending: () => updater.locked() }),
             db,
             paths,
@@ -484,7 +488,7 @@ export function wireRunner({ audioPreviews, db, paths, clock, ids, log, hub, tel
                 });
             },
         },
-        runs: Object.fromEntries(["research", "article", "audio", "images", "thumbnail", "video"].map((kind) => [
+        runs: Object.fromEntries(stageKinds.map((kind) => [
             kind,
             (context) => runRevisionInvocation(execution, context, stageProviders(providers, context)),
         ])),

package/dist/slices/admission/model.js

@@ -1,6 +1,12 @@
 // The format is the kernel's: the image port asks for the same two aspects.
 export { formats } from "../../kernel/pipeline.js";
 // Generate, Provide or Off for most stages, plus the thumbnail's two Generate modes.
-// Article stays Generate or Provide; Video can be Generate or Off.
+// Article stays Generate or Provide; Video and Document can be Generate or Off.
 export const stageSources = ["generate", "provide", "off", "from_prompt", "prompt_by_llm"];
+export function sourceOf(sources, kind) {
+    return sources[kind] ?? "off";
+}
+// How each slideshow image moves while it is on screen: Zoom in and out, Pan across, a
+// Mix of both taking turns, or Still. `video/motion.ts` has the rules.
+export const motionStyles = ["zoom", "pan", "mixed", "still"];
 export const entryModes = ["text", "llm"];

package/dist/slices/admission/rules.js

@@ -1,4 +1,5 @@
 import { stageKinds } from "../../kernel/pipeline.js";
+import { sourceOf } from "./model.js";
 export const titleMax = 200;
 export const valueMax = 200;
 export const numberPerPromptMax = 20;
@@ -6,6 +7,41 @@ export const imagesPerRunMax = 60;
 // ceiling: the default gap is 3 s and nothing fixes an upper or lower bound, so the range
 // is this module's. A wider gap is a settings change, not a schema change.
 export const silenceGapSecondsMax = 30;
+// ceiling: the owner's numbers. A still held past ten minutes is a separate kind of video.
+export const imageSecondsMin = 1;
+export const imageSecondsMax = 600;
+export const defaultImageSeconds = 15;
+// ceiling: the same 30 s as the gap; half seconds are enough precision for a pause.
+export const edgeSilenceSecondsMax = 30;
+export const defaultEdgeSilenceSeconds = 2;
+// ceiling: past 50% the crop loses more of the picture than it shows.
+export const zoomPercentMax = 50;
+export const defaultZoomPercent = 22.5;
+export const defaultMotionStyle = "zoom";
+// The words Play, Edit project and the change preview use for each motion style.
+export const motionStyleLabels = {
+    zoom: "Zoom in and out",
+    pan: "Pan across",
+    mixed: "Mix of both",
+    still: "Still",
+};
+// Shared by admission, Play's draft conversion and Edit project, so all three say the same
+// sentence about the same value.
+export function imageSecondsProblem(value) {
+    return Number.isInteger(value) && value >= imageSecondsMin && value <= imageSecondsMax
+        ? undefined
+        : `Enter a whole number of seconds between ${imageSecondsMin} and ${imageSecondsMax}.`;
+}
+export function zoomPercentProblem(value) {
+    return Number.isInteger(value * 2) && value >= 0 && value <= zoomPercentMax
+        ? undefined
+        : `Enter a zoom between 0 and ${zoomPercentMax} percent, in steps of 0.5.`;
+}
+export function edgeSilenceSecondsProblem(value) {
+    return Number.isInteger(value * 2) && value >= 0 && value <= edgeSilenceSecondsMax
+        ? undefined
+        : `Enter a number of seconds between 0 and ${edgeSilenceSecondsMax}, in steps of 0.5.`;
+}
 // The legal source for each stage. Exported because Play's
 // source switches offer exactly these and nothing else, so the segmented control and the
 // refusal below it are the same list and a stage whose legal set changes cannot leave a
@@ -18,6 +54,7 @@ export const allowedSources = {
     images: ["off", "generate", "provide"],
     thumbnail: ["off", "from_prompt", "prompt_by_llm", "provide"],
     video: ["off", "generate"],
+    document: ["off", "generate"],
 };
 export function admit(input) {
     const fields = [];
@@ -30,10 +67,10 @@ export function admit(input) {
         fields.push({ field: "title", message: `Keep the title to ${titleMax} characters or fewer.` });
     }
     for (const kind of stageKinds) {
-        if (!allowedSources[kind].includes(sources[kind])) {
+        if (!allowedSources[kind].includes(sourceOf(sources, kind))) {
             fields.push({
                 field: `sources.${kind}`,
-                message: `"${sources[kind]}" is not an option for ${kind}. Reload the page and choose again.`,
+                message: `"${sourceOf(sources, kind)}" is not an option for ${kind}. Reload the page and choose again.`,
             });
         }
     }
@@ -43,7 +80,8 @@ export function admit(input) {
         sources.thumbnail === "prompt_by_llm" ||
         draft.intro?.mode === "llm" ||
         draft.outro?.mode === "llm" ||
-        usesNarrationPreparation(draft);
+        usesNarrationPreparation(draft) ||
+        usesYoutubeDescription(draft);
     if (needsLlm && !chosen(draft.llm)) {
         fields.push({ field: "llm", message: "Choose a text (LLM) provider and model." });
     }
@@ -79,6 +117,7 @@ export function admit(input) {
             message: "Subtitles need narration. Turn narration on, or turn subtitles off.",
         });
     }
+    fields.push(...youtubeDescriptionFields(draft));
     checkProvided(draft, input.staged, fields);
     checkValues(draft, input.requiredSlots, fields);
     if (!Number.isFinite(draft.silenceGapSeconds) ||
@@ -89,6 +128,16 @@ export function admit(input) {
             message: `Enter a silence gap between 0 and ${silenceGapSecondsMax} seconds.`,
         });
     }
+    // Checked only where they are used: a hidden control cannot hold up a run.
+    const imageProblem = sources.video === "generate" ? imageSecondsProblem(draft.imageSeconds) : undefined;
+    if (imageProblem !== undefined)
+        fields.push({ field: "imageSeconds", message: imageProblem });
+    const zoomProblem = sources.video === "generate" ? zoomPercentProblem(draft.zoomPercent) : undefined;
+    if (zoomProblem !== undefined)
+        fields.push({ field: "zoomPercent", message: zoomProblem });
+    const edgeProblem = sources.audio === "off" ? undefined : edgeSilenceSecondsProblem(draft.edgeSilenceSeconds);
+    if (edgeProblem !== undefined)
+        fields.push({ field: "edgeSilenceSeconds", message: edgeProblem });
     return fields.length === 0 ? { ok: true, draft } : { ok: false, fields };
 }
 // Research only feeds article writing, so a provided article hides it.
@@ -241,6 +290,21 @@ export function narrationPreparationFields(draft) {
         ]
         : [];
 }
+// The YouTube description is written from the narration's word timings, so it needs
+// narration; it runs whether the video renders or only the WAV is exported.
+export function usesYoutubeDescription(draft) {
+    return draft.youtubeDescription === true && draft.sources.audio !== "off";
+}
+export function youtubeDescriptionFields(draft) {
+    return draft.youtubeDescription === true && draft.sources.audio === "off"
+        ? [
+            {
+                field: "youtubeDescription",
+                message: "The YouTube description is timed from the narration. Turn narration on, or turn the YouTube description off.",
+            },
+        ]
+        : [];
+}
 function chosen(choice) {
     return choice !== undefined && choice.provider.trim() !== "" && choice.model.trim() !== "";
 }

package/dist/slices/admission/schema.js

@@ -1,9 +1,11 @@
 import { z } from "zod";
 import { thinkingModes } from "../../kernel/ports/llm.js";
 import { checkpointStageSchema } from "../checkpoints/schema.js";
+import { documentThemes } from "../document/model.js";
 import { chunkModes } from "../narration/chunk.js";
 import { subtitleConfigSchema } from "../subtitles/model.js";
-import { entryModes, formats, stageSources } from "./model.js";
+import { entryModes, formats, motionStyles, stageSources } from "./model.js";
+import { defaultEdgeSilenceSeconds, defaultImageSeconds, defaultMotionStyle, defaultZoomPercent, } from "./rules.js";
 const providerChoice = z.object({
     provider: z.string(),
     model: z.string(),
@@ -21,8 +23,9 @@ export const runDraftSchema = z.object({
         .optional(),
     title: z.string(),
     format: z.enum(formats),
-    // Spelled out rather than built from stageKinds, so the inferred type carries the six
-    // keys and this schema stays assignable to the domain type without a cast.
+    // Spelled out rather than built from stageKinds, so the inferred type carries the
+    // keys and this schema stays assignable to the domain type without a cast. Document is
+    // optional: everything saved before it existed has no such key, and absent means Off.
     sources: z.object({
         research: z.enum(stageSources),
         article: z.enum(stageSources),
@@ -30,6 +33,7 @@ export const runDraftSchema = z.object({
         images: z.enum(stageSources),
         thumbnail: z.enum(stageSources),
         video: z.enum(stageSources),
+        document: z.enum(stageSources).optional(),
     }),
     llm: providerChoice.optional(),
     audio: providerChoice
@@ -60,7 +64,16 @@ export const runDraftSchema = z.object({
     })
         .optional(),
     silenceGapSeconds: z.number(),
+    // Defaulted rather than required, so a config, revision, draft review or backup saved
+    // before these existed still parses. The range is `rules.ts`'s, not the schema's.
+    imageSeconds: z.number().default(defaultImageSeconds),
+    zoomPercent: z.number().default(defaultZoomPercent),
+    motionStyle: z.enum(motionStyles).default(defaultMotionStyle),
+    edgeSilenceSeconds: z.number().default(defaultEdgeSilenceSeconds),
     subtitles: subtitleConfigSchema.optional(),
+    document: z.object({ theme: z.enum(documentThemes) }).optional(),
+    youtubeDescription: z.boolean().optional(),
+    descriptionPrompt: z.string().optional(),
 });
 export const runConfigSchema = runDraftSchema.extend({
     rendered: z.record(z.string(), z.string()),

package/dist/slices/admission/start.js

@@ -5,6 +5,7 @@ import { admitInitialRevision } from "../rebuild/runtime-admission.js";
 import { adoptBaseline } from "../revisions/adopt.js";
 import { attachStagedFile, storeText } from "../storage/staging.js";
 import { releaseStagedFile } from "../storage/staging-refs.js";
+import { sourceOf, } from "./model.js";
 import { insertProject, insertStage } from "./repo.js";
 // Provide → `provided` with its output attached; Off → `skipped`;
 // everything else → `pending`.
@@ -32,10 +33,10 @@ export function startRun(deps, draft, rendered, retainStaged = false, templates)
         id: deps.ids.next(),
         projectId: id,
         kind,
-        source: draft.sources[kind],
+        source: sourceOf(draft.sources, kind),
         state: kind === "video" && draft.sources.video === "off" && draft.sources.audio !== "off"
             ? "pending"
-            : initialState(draft.sources[kind]),
+            : initialState(sourceOf(draft.sources, kind)),
         failureReason: null,
         attemptCount: 0,
         progressCurrent: null,

package/dist/slices/document/blocks.js

@@ -0,0 +1,129 @@
+import { remark } from "remark";
+import remarkGfm from "remark-gfm";
+const plainStyle = { strong: false, emphasis: false, href: null };
+export function markdownBlocks(markdown) {
+    const tree = remark().use(remarkGfm).parse(markdown);
+    return tree.children.flatMap((node) => blocksOf(node, 0));
+}
+export function runsText(runs) {
+    return runs.map((run) => run.text).join("");
+}
+// Every link in the markdown, bare URLs included (remark-gfm makes those links too).
+export function markdownLinks(markdown) {
+    const links = [];
+    const visit = (node) => {
+        if (node.type === "link") {
+            const text = collapse(inlineRuns(node.children, plainStyle)
+                .map((run) => run.text)
+                .join(""));
+            links.push({ text: text === "" ? node.url : text, href: node.url });
+            return;
+        }
+        if ("children" in node)
+            for (const child of node.children)
+                visit(child);
+    };
+    visit(remark().use(remarkGfm).parse(markdown));
+    return links;
+}
+function blocksOf(node, depth) {
+    switch (node.type) {
+        case "heading": {
+            const text = collapse(runsText(inlineRuns(node.children, plainStyle)));
+            return text === ""
+                ? []
+                : [{ kind: "heading", level: node.depth === 1 ? 1 : node.depth === 2 ? 2 : 3, text }];
+        }
+        case "paragraph":
+            return paragraph(inlineRuns(node.children, plainStyle));
+        case "list":
+            return node.children.flatMap((item, index) => {
+                const marker = node.ordered ? `${(node.start ?? 1) + index}.` : "•";
+                let first = true;
+                return item.children.flatMap((child) => {
+                    if (child.type === "list")
+                        return blocksOf(child, depth + 1);
+                    const runs = child.type === "paragraph"
+                        ? inlineRuns(child.children, plainStyle)
+                        : blocksOf(child, depth).flatMap((block) => ("runs" in block ? block.runs : []));
+                    if (tidy(runs).length === 0)
+                        return [];
+                    const block = {
+                        kind: "item",
+                        depth,
+                        marker: first ? marker : "",
+                        runs: tidy(runs),
+                    };
+                    first = false;
+                    return [block];
+                });
+            });
+        case "blockquote":
+            return node.children.flatMap((child) => blocksOf(child, depth).flatMap((block) => "runs" in block ? [{ kind: "quote", runs: block.runs }] : [block]));
+        case "thematicBreak":
+            return [{ kind: "rule" }];
+        case "code":
+            return paragraph([{ ...plainStyle, text: node.value }]);
+        case "table":
+            return node.children.flatMap((row) => paragraph(row.children.flatMap((cell, index) => [
+                ...(index === 0 ? [] : [{ ...plainStyle, text: " | " }]),
+                ...inlineRuns(cell.children, plainStyle),
+            ])));
+        // Raw HTML, footnote definitions, front matter and images have no printed form here.
+        default:
+            return [];
+    }
+}
+function paragraph(runs) {
+    const tidied = tidy(runs);
+    return tidied.length === 0 ? [] : [{ kind: "paragraph", runs: tidied }];
+}
+function inlineRuns(nodes, style) {
+    return nodes.flatMap((node) => {
+        switch (node.type) {
+            case "text":
+            case "inlineCode":
+                return [{ ...style, text: node.value }];
+            case "strong":
+                return inlineRuns(node.children, { ...style, strong: true });
+            case "emphasis":
+                return inlineRuns(node.children, { ...style, emphasis: true });
+            case "delete":
+                return inlineRuns(node.children, style);
+            case "link":
+                return inlineRuns(node.children, { ...style, href: node.url });
+            case "break":
+                return [{ ...style, text: "\n" }];
+            case "footnoteReference":
+                return [{ ...style, text: `[${node.label ?? node.identifier}]` }];
+            case "image":
+                return node.alt ? [{ ...style, text: node.alt }] : [];
+            default:
+                return [];
+        }
+    });
+}
+// Soft line breaks and runs of spaces become one space; a hard break stays a line break.
+function tidy(runs) {
+    const tidied = runs
+        .map((run) => (run.text === "\n" ? run : { ...run, text: run.text.replace(/\s+/g, " ") }))
+        .filter((run) => run.text !== "");
+    const first = tidied[0];
+    const last = tidied.at(-1);
+    if (first === undefined || last === undefined)
+        return [];
+    const trimmed = tidied.map((run, index) => ({
+        ...run,
+        text: index === 0 && index === tidied.length - 1
+            ? run.text.trim()
+            : index === 0
+                ? run.text.trimStart()
+                : index === tidied.length - 1
+                    ? run.text.trimEnd()
+                    : run.text,
+    }));
+    return trimmed.filter((run) => run.text !== "");
+}
+function collapse(text) {
+    return text.replace(/\s+/g, " ").trim();
+}

package/dist/slices/document/flow.js

@@ -0,0 +1,117 @@
+import { faceWidth, useFace } from "./fonts.js";
+// `room(index)` answers where line `index` starts, relative to the paragraph's left edge,
+// and how wide it may be: a drop cap narrows the first few.
+export function wrapRuns(doc, runs, style, room) {
+    const spaceWidth = faceWidth(doc, style.body, style.size, " ");
+    const lines = [];
+    let line = [];
+    let x = 0;
+    const limit = () => room(lines.length);
+    const finish = () => {
+        lines.push(line);
+        line = [];
+        x = 0;
+    };
+    const place = (atom) => {
+        const { indent } = limit();
+        line.push({
+            text: atom.text,
+            face: faceOf(atom.run, style),
+            color: atom.run.href === null ? style.color : style.linkColor,
+            href: atom.run.href,
+            x: indent + x,
+            width: atom.width,
+        });
+        x += atom.width;
+    };
+    for (const token of tokens(doc, runs, style)) {
+        if (token.kind === "break") {
+            finish();
+            continue;
+        }
+        const width = token.atoms.reduce((sum, atom) => sum + atom.width, 0);
+        const gap = line.length > 0 && token.space ? spaceWidth : 0;
+        if (line.length > 0 && x + gap + width > limit().width)
+            finish();
+        else
+            x += gap;
+        if (width <= limit().width) {
+            for (const atom of token.atoms)
+                place(atom);
+            continue;
+        }
+        for (const atom of token.atoms)
+            for (const character of [...atom.text]) {
+                const piece = { ...atom, text: character, width: measure(doc, atom.run, style, character) };
+                if (line.length > 0 && x + piece.width > limit().width)
+                    finish();
+                place(piece);
+            }
+    }
+    if (line.length > 0)
+        finish();
+    return lines;
+}
+export function drawLine(doc, line, left, y, size) {
+    for (const piece of line) {
+        useFace(doc, piece.face, size);
+        doc.setTextColor(piece.color.r, piece.color.g, piece.color.b);
+        doc.text(piece.text, left + piece.x, y);
+    }
+    // One clickable box per run of pieces sharing a link, rather than one per word.
+    let start;
+    let end;
+    const flush = () => {
+        if (start?.href != null && end !== undefined)
+            doc.link(left + start.x, y - size * 0.3528, end.x + end.width - start.x, size * 0.45, {
+                url: start.href,
+            });
+        start = undefined;
+        end = undefined;
+    };
+    for (const piece of line) {
+        if (piece.href !== start?.href)
+            flush();
+        if (piece.href !== null) {
+            start ??= piece;
+            end = piece;
+        }
+    }
+    flush();
+    doc.setCharSpace(0);
+}
+function tokens(doc, runs, style) {
+    const result = [];
+    let space = false;
+    for (const run of runs) {
+        for (const part of run.text.split(/( +|\n)/)) {
+            if (part === "")
+                continue;
+            if (part === "\n") {
+                result.push({ kind: "break" });
+                space = false;
+                continue;
+            }
+            if (/^ +$/.test(part)) {
+                space = true;
+                continue;
+            }
+            const atom = { text: part, run, width: measure(doc, run, style, part) };
+            const last = result.at(-1);
+            // No space before this part: it continues the previous word, as the comma after a
+            // bold word does, and must not be wrapped away from it.
+            if (!space && last?.kind === "word")
+                result[result.length - 1] = { ...last, atoms: [...last.atoms, atom] };
+            else
+                result.push({ kind: "word", atoms: [atom], space });
+            space = false;
+        }
+    }
+    return result;
+}
+function measure(doc, run, style, text) {
+    return faceWidth(doc, faceOf(run, style), style.size, text);
+}
+function faceOf(run, style) {
+    return run.strong ? style.strong : run.emphasis ? style.emphasis : style.body;
+}

package/dist/slices/document/fonts.js

@@ -0,0 +1,54 @@
+import { readFileSync } from "node:fs";
+// The bundled Cinzel weights (SIL OFL 1.1, assets/document/fonts/OFL.txt) and the page
+// texture. Read on every render rather than kept in memory: four fonts and one image are
+// under a megabyte, and a document is made once per article.
+const assets = new URL("../../assets/document/", import.meta.url);
+const cinzelFiles = {
+    normal: "Cinzel-Regular.ttf",
+    medium: "Cinzel-Medium.ttf",
+    bold: "Cinzel-Bold.ttf",
+    black: "Cinzel-Black.ttf",
+};
+export function readDocumentAssets() {
+    try {
+        const cinzel = Object.fromEntries(Object.entries(cinzelFiles).map(([style, file]) => [
+            style,
+            readFileSync(new URL(`fonts/${file}`, assets)).toString("base64"),
+        ]));
+        return { cinzel, parchment: new Uint8Array(readFileSync(new URL("background.jpg", assets))) };
+    }
+    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 Retry stage on Document.`, { cause: error });
+    }
+}
+export function registerFonts(doc, fonts) {
+    for (const [style, file] of Object.entries(cinzelFiles)) {
+        doc.addFileToVFS(file, fonts[style]);
+        doc.addFont(file, "Cinzel", style);
+    }
+}
+// Cinzel exists only in the four bundled weights; the standard fonts only in normal, bold,
+// italic and bold italic. A face asking for anything else gets the nearest one.
+export function useFace(doc, face, size) {
+    doc.setFont(face.family, styleFor(face));
+    doc.setFontSize(size);
+    doc.setCharSpace(face.letterSpacing);
+}
+export function faceWidth(doc, face, size, text) {
+    useFace(doc, face, size);
+    return doc.getTextWidth(text) + face.letterSpacing * [...text].length;
+}
+function styleFor(face) {
+    if (face.family === "Cinzel") {
+        if (face.style === "italic")
+            return "normal";
+        if (face.style === "bolditalic")
+            return "bold";
+        return face.style;
+    }
+    if (face.style === "medium")
+        return "normal";
+    if (face.style === "black")
+        return "bold";
+    return face.style;
+}

package/dist/slices/document/model.js

@@ -0,0 +1,11 @@
+// The built-in looks a project's PDF can take. Browser-safe: Play, Edit project and the
+// server all offer and accept the same names from here.
+export const documentThemes = ["dicemaster", "plain"];
+export const defaultDocumentTheme = "dicemaster";
+export const documentThemeLabels = {
+    dicemaster: "DiceMaster",
+    plain: "Plain",
+};
+export function documentThemeOf(settings) {
+    return settings?.theme ?? defaultDocumentTheme;
+}