@gentbajko/slopify 2.0.2 → 2.1.0

package/dist/slices/article/provided-entries.js

@@ -11,7 +11,7 @@ export async function prepareProvidedArticleSegments(deps, audioContext, provide
     const { projectId } = audioContext.stage;
     const project = projectById(deps.db, projectId);
     if (!project)
-        throw new Error(`project ${projectId} has no row`);
+        throw new Error("This project no longer exists; it may have been deleted while it was running.");
     const { config } = project;
     if (config.sources.article !== "provide" || config.sources.audio !== "generate")
         return "done";
@@ -20,11 +20,11 @@ export async function prepareProvidedArticleSegments(deps, audioContext, provide
     audioContext.signal.throwIfAborted();
     const article = stagesOf(deps.db, projectId).find((stage) => stage.kind === "article");
     if (!article)
-        throw new Error(`project ${projectId} has no article stage`);
+        throw new Error("Slopify hit an internal error (the project has no article stage). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
     const outputs = outputsOf(deps.db, projectId);
     const plain = outputs.find((output) => output.role === "article_txt");
     if (!plain)
-        throw new Error("the run has no provided article text");
+        throw new Error("The article text you provided is missing, so the intro and outro can't be written from it. Paste the article again in Edit project → Article, then Retry stage.");
     const narration = readFileSync(outputPath(deps.paths, projectId, plain.path), "utf8");
     const saved = outputs.find((output) => output.stageKind === "article" && output.role === "instructions");
     let instructions = saved

package/dist/slices/article/run.js

@@ -13,14 +13,14 @@ export async function runArticle(deps, context, providers) {
     const { projectId } = context.stage;
     const project = projectById(deps.db, projectId);
     if (project === undefined) {
-        throw new Error(`project ${projectId} has no row`);
+        throw new Error("This project no longer exists; it may have been deleted while it was running.");
     }
     const choice = project.config.llm;
     const articlePrompt = project.config.rendered.article;
     if (choice === undefined || articlePrompt === undefined) {
         // Admission refuses a run whose article is Generate without both, so
         // reaching here is a bug in admission rather than something the user did.
-        throw new Error("the run has no LLM provider or no rendered article prompt");
+        throw new Error("No AI model or article prompt is set for writing the article. Choose a model in Edit project → Providers and check Edit project → Prompts, then Retry stage.");
     }
     const notes = researchNotes(deps, projectId);
     const brief = { articlePrompt, ...(notes === undefined ? {} : { notes }) };

package/dist/slices/article/segments.js

@@ -7,12 +7,12 @@ export async function writeSegment(providers, choice, config, category, article,
         return { ok: true, value: undefined };
     const body = config.rendered[category];
     if (body === undefined)
-        throw new Error(`the run has no rendered ${category} text`);
+        throw new Error(`Slopify hit an internal error (the ${category} text was never filled in). Retry stage; if it happens again, use Download diagnostics in Settings and report it.`);
     const common = { category, name: picked.name, mode: picked.mode };
     if (picked.mode === "text")
         return { ok: true, value: { ...common, text: body, tokens: noTokens } };
     if (choice === undefined)
-        throw new Error(`the ${category} has no LLM provider or model`);
+        throw new Error(`No AI model is set for writing the ${category}. Choose one in Edit project → Providers, then Retry stage.`);
     const messages = segmentMessages(body, config, article);
     sent.push({ label: category === "intro" ? "Intro" : "Outro", messages });
     const answer = await providers.llm({
@@ -20,7 +20,9 @@ export async function writeSegment(providers, choice, config, category, article,
         model: choice.model,
         ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
         messages,
-        check: (given) => given.text.trim() === "" ? `the ${category} answered with nothing` : undefined,
+        check: (given) => given.text.trim() === ""
+            ? `The AI model returned an empty ${category}. Retry stage; if it keeps happening, choose a different model in Edit project → Providers.`
+            : undefined,
     });
     if (!answer.ok)
         return answer;

package/dist/slices/control/providers.js

@@ -25,7 +25,7 @@ export const providerChangesSchema = z
         .optional(),
 })
     .strict()
-    .refine((value) => Object.keys(value).length > 0, "Pick at least one provider to update.");
+    .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" };
@@ -35,7 +35,10 @@ export function validateLocalProviderChanges(changes, current) {
             continue;
         const provider = current.providers.find((one) => one.id === picked.provider && one.family === families[key]);
         if (provider === undefined) {
-            fields.push({ field: key, message: "Choose a provider for this kind of generation." });
+            fields.push({
+                field: key,
+                message: "This provider cannot do this kind of work. Choose another provider.",
+            });
             continue;
         }
         const usable = readinessIsUsable(provider.readiness);
@@ -43,14 +46,18 @@ export function validateLocalProviderChanges(changes, current) {
             fields.push({
                 field: key,
                 message: provider.readiness.kind === "cli"
-                    ? (provider.readiness.issue ?? "Install and sign in to this CLI first.")
-                    : "Save this provider's API key in Settings first.",
+                    ? (provider.readiness.issue ??
+                        "Install this command-line tool on your computer and sign in to it, then try again.")
+                    : "Add this provider's API key in Settings → Providers first.",
             });
         }
     }
     if (changes.audio !== undefined &&
         !current.voices.some((voice) => voice.provider === changes.audio?.provider && voice.voiceId === changes.audio.voice)) {
-        fields.push({ field: "audio.voice", message: "Choose a saved voice for this provider." });
+        fields.push({
+            field: "audio.voice",
+            message: "Choose one of your saved voices for this provider. Add voices in Settings → Voices.",
+        });
     }
     return fields;
 }
@@ -67,10 +74,16 @@ export async function validateProviderChanges(changes, current) {
             continue;
         const result = await checkRuntimeModel(current.modelsFor, picked.provider, families[key], picked.model, picked.thinking);
         if (result === "missing") {
-            fields.push({ field: `${key}.model`, message: "Choose a model supported by this provider." });
+            fields.push({
+                field: `${key}.model`,
+                message: "This provider does not offer that model. Choose another model.",
+            });
         }
         else if (result === "thinking") {
-            fields.push({ field: `${key}.thinking`, message: "Choose a supported thinking setting." });
+            fields.push({
+                field: `${key}.thinking`,
+                message: "This model does not support that thinking setting. Choose another.",
+            });
         }
     }
     return fields;

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

package/dist/slices/document/pages.js

@@ -0,0 +1,198 @@
+import { useFace } from "./fonts.js";
+const dateFormat = new Intl.DateTimeFormat("en-US", {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+});
+export function writtenOn(date) {
+    return dateFormat.format(date);
+}
+// Brand, tagline, title, the cover when there is one, then the date, word count and link.
+export function titlePage(w, title, words, date, cover) {
+    const { theme, doc } = w;
+    const { fonts, sizes, titlePage: layout, brand } = theme;
+    const centre = w.width / 2;
+    if (brand.name !== null) {
+        w.write(brand.name, centre, layout.brandY, fonts.dramatic, sizes.brand, "heading", "center");
+        if (brand.url !== null) {
+            const width = doc.getTextWidth(brand.name);
+            doc.link(centre - width / 2, layout.brandY - 8, width, 10, { url: brand.url });
+        }
+    }
+    if (brand.tagline !== null)
+        w.write(brand.tagline, centre, layout.brandY + layout.taglineOffset, fonts.decorative, sizes.body, "heading", "center");
+    useFace(doc, fonts.heading, sizes.title);
+    let y = layout.titleY;
+    for (const line of doc.splitTextToSize(title, w.contentWidth)) {
+        w.write(line, centre, y, fonts.heading, sizes.title, "text", "center");
+        y += layout.titleLine;
+    }
+    // Without a cover the details sit where lore2script2 put them; with one, just under it.
+    let meta = y + layout.metaOffset;
+    if (cover !== null && layout.cover.enabled) {
+        const top = y - layout.titleLine + layout.cover.gap;
+        const below = layout.cover.gap + layout.metaLine * 3;
+        const room = Math.min(layout.cover.maxHeight, w.bottom - below - top);
+        const { width, height } = doc.getImageProperties(cover.data);
+        if (room > 0 && width > 0 && height > 0) {
+            const scale = Math.min(w.contentWidth / width, room / height);
+            doc.addImage(cover.data, cover.format, centre - (width * scale) / 2, top, width * scale, height * scale);
+            meta = top + height * scale + layout.cover.gap + layout.metaLine;
+        }
+    }
+    const line = (text, color, decorative = false) => {
+        w.write(text, centre, meta, decorative ? fonts.decorative : fonts.body, sizes.meta, color, "center");
+        meta += layout.metaLine;
+    };
+    if (layout.showDate)
+        line(`Written on ${writtenOn(date)}`, "muted");
+    if (layout.showWordCount)
+        line(`Word Count: ${words.toLocaleString("en-US")}`, "muted");
+    if (brand.linkLabel !== null) {
+        const at = meta;
+        line(brand.linkLabel, "heading", true);
+        if (brand.url !== null) {
+            const width = doc.getTextWidth(brand.linkLabel);
+            doc.link(centre - width / 2, at - 8, width, 10, { url: brand.url });
+        }
+    }
+}
+// How many pages the contents need for `entries` one-line entries, laid out exactly as
+// fillContents lays them out, so they can be kept free before the body is written.
+export function contentsPages(w, entries) {
+    const { contents } = w.theme;
+    if (!contents.enabled || entries === 0)
+        return 0;
+    let pages = 1;
+    let y = w.left + contents.firstEntryOffset;
+    for (let entry = 0; entry < entries; entry += 1) {
+        if (y + contents.line > w.bottom) {
+            pages += 1;
+            y = w.theme.header.top + contents.titleOffset;
+        }
+        y += contents.line;
+    }
+    return pages;
+}
+export function fillContents(w, first, entries) {
+    const { doc, theme } = w;
+    const { contents, fonts, sizes } = theme;
+    if (!contents.enabled || entries.length === 0)
+        return;
+    let page = first;
+    doc.setPage(page);
+    w.write(contents.title, w.width / 2, w.left + contents.titleOffset, fonts.heading, sizes.section, "heading", "center");
+    const top = Math.min(...entries.map((entry) => entry.level));
+    let y = w.left + contents.firstEntryOffset;
+    for (const entry of entries) {
+        if (y + contents.line > w.bottom) {
+            page += 1;
+            doc.setPage(page);
+            y = theme.header.top + contents.titleOffset;
+        }
+        const indent = (entry.level - top) * contents.indent;
+        const number = String(entry.page);
+        useFace(doc, fonts.body, sizes.body);
+        const numberX = w.width - w.left - doc.getTextWidth(number);
+        const room = numberX - (w.left + indent) - 10;
+        let label = entry.title;
+        if (doc.getTextWidth(label) > room) {
+            while (label.length > 1 && doc.getTextWidth(`${label}...`) > room)
+                label = label.slice(0, -1);
+            label = `${label.trimEnd()}...`;
+        }
+        w.write(label, w.left + indent, y, fonts.body, sizes.body, "text");
+        const labelEnd = w.left + indent + doc.getTextWidth(label) + 3;
+        w.write(number, numberX, y, fonts.body, sizes.body, "text");
+        doc.link(w.left, y - 6, w.contentWidth, 8, { pageNumber: entry.page });
+        const dot = doc.getTextWidth(".") * 1.5;
+        for (let x = labelEnd; x + dot < numberX - 3; x += dot)
+            w.write(".", x, y, fonts.body, sizes.body, "muted");
+        y += contents.line;
+    }
+}
+export function sourcesPage(w, items) {
+    const { doc, theme } = w;
+    const { fonts, sizes, sources } = theme;
+    if (!sources.enabled || items.length === 0)
+        return null;
+    w.addPage();
+    w.write(sources.title, w.left, w.left + sources.titleOffset, fonts.heading, sizes.section, "heading");
+    const entry = { title: sources.title, level: 1, page: w.page() };
+    w.y = w.left + sources.bodyOffset;
+    useFace(doc, fonts.body, sizes.body);
+    const bullet = doc.getTextWidth("• ");
+    for (const item of items) {
+        useFace(doc, fonts.body, sizes.body);
+        const lines = doc.splitTextToSize(item.text, w.contentWidth - bullet - 5);
+        w.ensure(sources.line);
+        w.write("•", w.left, w.y, fonts.body, sizes.body, "muted");
+        for (const line of lines) {
+            w.ensure(sources.line);
+            w.write(line, w.left + bullet, w.y, fonts.body, sizes.body, item.href === null ? "text" : "heading");
+            if (item.href !== null)
+                doc.link(w.left + bullet, w.y - 5, doc.getTextWidth(line), 7, { url: item.href });
+            w.y += sources.line;
+        }
+        w.y += sources.gap;
+    }
+    return entry;
+}
+// The closing page: the theme's lines, then the document's details and the call to action.
+export function endPage(w, words, date) {
+    const { doc, theme } = w;
+    const { fonts, sizes, endPage: end } = theme;
+    if (!end.enabled)
+        return null;
+    w.addPage();
+    w.write(end.title, w.left, w.left + end.titleOffset, fonts.heading, sizes.section, "heading");
+    const entry = { title: end.title, level: 1, page: w.page() };
+    const lines = [...end.lines];
+    if (end.showDocumentDetails) {
+        if (lines.length > 0)
+            lines.push("");
+        lines.push("Document Details:", `• Written On: ${writtenOn(date)}`, `• Total Words: ${words.toLocaleString("en-US")}`, `• Total Pages: ${doc.getNumberOfPages()}`);
+    }
+    const line = theme.spacing.bodyLine;
+    let y = w.left + end.bodyOffset;
+    for (const text of lines) {
+        if (text.startsWith("•"))
+            w.write(text, w.left + 5, y, fonts.body, sizes.body, "muted");
+        else if (text.endsWith(":"))
+            w.write(text, w.left, y, fonts.strong, sizes.body, "text");
+        else if (text !== "")
+            w.write(text, w.left, y, fonts.body, sizes.body, "text");
+        y += line;
+    }
+    const calls = [end.link?.text, end.closing].filter((text) => Boolean(text));
+    if (calls.length > 0)
+        y += line;
+    for (const text of calls) {
+        w.write(text, w.left, y, fonts.decorative, sizes.body, "heading");
+        if (text === end.link?.text && end.link.url !== null)
+            doc.link(w.left, y - 6, doc.getTextWidth(text), 8, { url: end.link.url });
+        y += line;
+    }
+    return entry;
+}
+// The running header ("Brand | Title") and page number on every page after the title page.
+export function headsAndFeet(w, title) {
+    const { doc, theme } = w;
+    const { fonts, sizes, header, footer, brand } = theme;
+    for (let page = 2; page <= doc.getNumberOfPages(); page += 1) {
+        doc.setPage(page);
+        if (header.enabled) {
+            useFace(doc, fonts.body, sizes.footer);
+            const shown = doc.getTextWidth(title) > w.contentWidth - 40
+                ? `${title.slice(0, header.maxTitleCharacters)}...`
+                : title;
+            const text = [brand.name, shown].filter(Boolean).join(" | ");
+            if (text !== "")
+                w.write(text, w.left, header.top, fonts.body, sizes.footer, "faint");
+            if (brand.name !== null && brand.url !== null)
+                doc.link(w.left, header.top - 6, doc.getTextWidth(brand.name), 8, { url: brand.url });
+        }
+        if (footer.enabled)
+            w.write(footer.text.replaceAll("{page}", String(page)), w.width / 2, w.height - footer.bottom, fonts.footer, sizes.footer, "faint", "center");
+    }
+}