@gentbajko/slopify 2.0.2 → 2.1.0

package/dist/slices/document/render.js

@@ -0,0 +1,242 @@
+import { jsPDF } from "jspdf";
+import { runsText } from "./blocks.js";
+import { drawLine, wrapRuns } from "./flow.js";
+import { faceWidth, registerFonts, useFace } from "./fonts.js";
+import { contentsPages, endPage, fillContents, headsAndFeet, sourcesPage, titlePage, } from "./pages.js";
+import { documentText } from "./sources.js";
+import { createWriter } from "./writer.js";
+export function renderDocument(input) {
+    const { theme } = input;
+    const text = documentText(input.articleMarkdown, input.researchNotes);
+    const blocks = withoutTitle(text.blocks, input.title);
+    if (blocks.length === 0)
+        throw new Error("The article has no text to put in the document. Write or regenerate the article (Edit project → Article), then use Retry stage on Document.");
+    const words = blocks
+        .map((block) => block.kind === "heading" ? block.text : "runs" in block ? runsText(block.runs) : "")
+        .join(" ")
+        .split(/\s+/)
+        .filter((word) => word !== "").length;
+    const doc = new jsPDF({
+        orientation: "portrait",
+        unit: "mm",
+        format: theme.page.format,
+        compress: true,
+    });
+    registerFonts(doc, input.assets.cinzel);
+    const fill = (template) => template.replaceAll("{title}", input.title).trim();
+    doc.setProperties({
+        title: input.title,
+        author: fill(theme.metadata.author),
+        subject: fill(theme.metadata.subject),
+        keywords: fill(theme.metadata.keywords),
+        creator: fill(theme.metadata.creator),
+    });
+    const w = createWriter(doc, theme, input.assets);
+    const cover = coverImage(input.cover);
+    titlePage(w, input.title, words, input.writtenOn, cover === "unsupported" ? null : cover);
+    const listed = blocks.filter((block) => block.kind === "heading" && block.level <= theme.contents.depth).length;
+    const extra = (theme.sources.enabled && text.sources.length > 0 ? 1 : 0) + (theme.endPage.enabled ? 1 : 0);
+    const reserved = contentsPages(w, listed + extra);
+    for (let page = 0; page < reserved; page += 1)
+        w.addPage();
+    w.addPage();
+    const contents = [];
+    writeBody(w, blocks, contents);
+    // The sources and closing pages line up with the article's outermost headings.
+    const level = Math.min(3, ...contents.map((entry) => entry.level));
+    for (const page of [sourcesPage(w, text.sources), endPage(w, words, input.writtenOn)])
+        if (page !== null)
+            contents.push({ ...page, level });
+    if (reserved > 0)
+        fillContents(w, 2, contents);
+    headsAndFeet(w, input.title);
+    return {
+        bytes: new Uint8Array(doc.output("arraybuffer")),
+        pages: doc.getNumberOfPages(),
+        words,
+        contents,
+        sources: text.sources.length,
+        cover: cover === null ? "none" : cover === "unsupported" ? "unsupported" : "placed",
+    };
+}
+// The title page already carries the title, so an article that opens by repeating it
+// starts with its first real section instead.
+function withoutTitle(blocks, title) {
+    const at = blocks
+        .slice(0, 3)
+        .findIndex((block) => block.kind === "heading" && block.text.trim().toLowerCase() === title.trim().toLowerCase());
+    return at === -1 ? blocks : blocks.filter((_, index) => index !== at);
+}
+function coverImage(data) {
+    if (data === null)
+        return null;
+    const bytes = (...values) => values.every((value, index) => data[index] === value);
+    if (bytes(0x89, 0x50, 0x4e, 0x47))
+        return { data, format: "PNG" };
+    if (bytes(0xff, 0xd8, 0xff))
+        return { data, format: "JPEG" };
+    if (bytes(0x52, 0x49, 0x46, 0x46) && String.fromCharCode(...data.subarray(8, 12)) === "WEBP")
+        return { data, format: "WEBP" };
+    return "unsupported";
+}
+function writeBody(w, blocks, contents) {
+    const { theme } = w;
+    const line = theme.spacing.bodyLine;
+    const style = {
+        size: theme.sizes.body,
+        body: theme.fonts.body,
+        strong: theme.fonts.strong,
+        emphasis: theme.fonts.emphasis,
+        color: w.colors.text,
+        linkColor: w.colors.heading,
+    };
+    let afterHeading = false;
+    for (const [index, block] of blocks.entries()) {
+        if (block.kind === "heading") {
+            // A heading keeps the start of what follows it on its page: two lines, or all the
+            // room a drop-capped paragraph asks for, so the heading is never left at the foot.
+            const next = blocks[index + 1];
+            const keep = next?.kind === "paragraph" && dropCapLetter(theme, next.runs) !== null
+                ? dropCapRoom(w)
+                : theme.spacing.bodyLine * 2;
+            const entry = writeHeading(w, block, keep);
+            if (block.level <= theme.contents.depth)
+                contents.push(entry);
+            afterHeading = true;
+            continue;
+        }
+        if (block.kind === "rule") {
+            w.ensure(line);
+            const rgb = w.colors.muted;
+            w.doc.setDrawColor(rgb.r, rgb.g, rgb.b);
+            w.doc.setLineWidth(0.3);
+            const half = theme.spacing.ruleWidth / 2;
+            w.doc.line(w.width / 2 - half, w.y - line / 3, w.width / 2 + half, w.y - line / 3);
+            w.y += line;
+            continue;
+        }
+        if (block.kind === "paragraph") {
+            const cap = afterHeading ? dropCapLetter(theme, block.runs) : null;
+            if (cap === null)
+                writeLines(w, block.runs, style, 0, w.contentWidth);
+            else
+                writeDropCap(w, block.runs, style, cap);
+            w.y += line * theme.spacing.paragraphGap;
+        }
+        else if (block.kind === "item") {
+            const indent = block.depth * theme.spacing.listIndent;
+            w.ensure(line);
+            if (block.marker !== "")
+                w.write(block.marker, w.left + indent, w.y, theme.fonts.body, theme.sizes.body, "muted");
+            const text = indent + theme.spacing.listIndent;
+            writeLines(w, block.runs, style, text, w.contentWidth - text);
+            w.y += line * theme.spacing.itemGap;
+        }
+        else {
+            const indent = theme.spacing.quoteIndent;
+            const quote = { ...style, color: w.colors.muted };
+            const start = { page: w.page(), y: w.y };
+            writeLines(w, block.runs, quote, indent, w.contentWidth - indent * 2);
+            if (w.page() === start.page) {
+                const rgb = w.colors.heading;
+                w.doc.setDrawColor(rgb.r, rgb.g, rgb.b);
+                w.doc.setLineWidth(0.6);
+                const x = w.left + indent / 2;
+                w.doc.line(x, start.y - line * 0.6, x, w.y - line * 0.8);
+            }
+            w.y += line * theme.spacing.paragraphGap;
+        }
+        afterHeading = false;
+    }
+}
+function writeLines(w, runs, style, indent, width) {
+    const lines = wrapRuns(w.doc, runs, style, () => ({ indent, width }));
+    for (const one of lines) {
+        w.ensure(w.theme.spacing.bodyLine);
+        drawLine(w.doc, one, w.left, w.y, style.size);
+        w.y += w.theme.spacing.bodyLine;
+    }
+}
+const chapterHeading = /^(Chapter|Section|Part)\s+(\d+):?\s*([\s\S]*)$/i;
+// Level 1 and 2 are centred in the heading face at the section and heading sizes; a
+// "Chapter 3: Title – Subtitle" heading shows its number large with each part of the title
+// under it. Level 3 sits on the left, smaller.
+function writeHeading(w, block, keep) {
+    const { theme, doc } = w;
+    const { fonts, sizes, spacing } = theme;
+    if (w.y > theme.page.contentTop)
+        w.y += spacing.bodyLine * spacing.headingGap;
+    const sub = block.level === 3;
+    const size = block.level === 1 ? sizes.section : sub ? sizes.subheading : sizes.heading;
+    const lineHeight = sub ? spacing.subheadingLine : spacing.headingLine;
+    const chapter = sub ? null : chapterHeading.exec(block.text);
+    const parts = chapter === null
+        ? [block.text]
+        : (chapter[3] ?? "")
+            .split(/\s+[–—]\s+/)
+            .map((part) => part.trim())
+            .filter((part) => part !== "");
+    useFace(doc, fonts.heading, size);
+    const lines = parts.flatMap((part) => doc.splitTextToSize(part, w.contentWidth - (chapter === null ? 0 : 20)));
+    // The heading and the first lines under it stay on one page.
+    const height = lines.length * lineHeight + (chapter === null ? 0 : lineHeight * 1.5);
+    w.ensure(height + spacing.bodyLine * spacing.paragraphGap + keep);
+    const entry = { title: block.text, level: block.level, page: w.page() };
+    if (chapter !== null) {
+        w.write(chapter[2] ?? "", w.width / 2, w.y, fonts.dramatic, sizes.section, "heading", "center");
+        w.y += lineHeight * 1.5;
+    }
+    for (const text of lines) {
+        if (sub)
+            w.write(text, w.left, w.y, fonts.heading, size, "heading");
+        else
+            w.write(text, w.width / 2, w.y, fonts.heading, size, "heading", "center");
+        w.y += lineHeight;
+    }
+    w.y += spacing.bodyLine * spacing.paragraphGap;
+    return entry;
+}
+function dropCapLetter(theme, runs) {
+    const first = runs[0];
+    if (!theme.dropCap.enabled || first === undefined || first.href !== null)
+        return null;
+    if (runsText(runs).length < theme.dropCap.minLength)
+        return null;
+    const letter = [...first.text][0] ?? "";
+    return /\p{L}/u.test(letter) ? letter : null;
+}
+// The first letter set large across `lines` body lines, the text beside it narrowed, then
+// full width below it.
+function writeDropCap(w, runs, style, letter) {
+    const { theme, doc } = w;
+    const { dropCap } = theme;
+    const line = theme.spacing.bodyLine;
+    w.ensure(dropCapRoom(w));
+    const size = line * dropCap.lines * dropCap.scale;
+    const capital = letter.toUpperCase();
+    const capWidth = faceWidth(doc, theme.fonts.dropCap, size, capital) + dropCap.gap;
+    w.write(capital, w.left, w.y + line * (dropCap.lines - 1), theme.fonts.dropCap, size, "heading");
+    const [first, ...rest] = runs;
+    const remaining = first === undefined ? [] : [{ ...first, text: [...first.text].slice(1).join("") }, ...rest];
+    const top = w.y;
+    const lines = wrapRuns(doc, remaining, style, (index) => index < dropCap.lines
+        ? { indent: capWidth, width: w.contentWidth - capWidth }
+        : { indent: 0, width: w.contentWidth });
+    for (const [index, one] of lines.entries()) {
+        if (index >= dropCap.lines)
+            w.ensure(line);
+        drawLine(doc, one, w.left, w.y, style.size);
+        w.y += line;
+    }
+    // Text shorter than the initial still leaves its full height free.
+    w.y = Math.max(w.y, top + line * dropCap.lines);
+}
+// The room a drop-capped paragraph needs left on the page: the theme's share of it, and at
+// least the initial itself, which reaches about `lines * scale` body lines below its first
+// baseline.
+function dropCapRoom(w) {
+    const { theme } = w;
+    const { dropCap } = theme;
+    const usable = w.height - theme.page.margin - theme.header.top - theme.footer.bottom - theme.footer.reserve;
+    return Math.max(usable * dropCap.minRoom, theme.spacing.bodyLine * dropCap.lines * dropCap.scale);
+}

package/dist/slices/document/sources.js

@@ -0,0 +1,35 @@
+import { splitEndMatter } from "../article/split.js";
+import { markdownBlocks, markdownLinks, runsText } from "./blocks.js";
+// The pronunciation glossary is narration's business and is left out; the sources section
+// becomes the Sources page instead of being printed as body text.
+export function documentText(articleMarkdown, researchNotes) {
+    const parts = splitEndMatter(articleMarkdown);
+    const listed = sourceItems(parts.sources);
+    const seen = new Set(listed.flatMap((item) => (item.href === null ? [] : [item.href])));
+    const cited = [];
+    for (const link of researchNotes === null ? [] : markdownLinks(researchNotes)) {
+        if (seen.has(link.href) || !/^https?:\/\//i.test(link.href))
+            continue;
+        seen.add(link.href);
+        cited.push(link.text === link.href ? { text: link.href, href: link.href } : link);
+    }
+    return { blocks: markdownBlocks(parts.body), sources: [...listed, ...cited] };
+}
+function sourceItems(section) {
+    if (section.trim() === "")
+        return [];
+    // The section's own heading, whether a `#` line or a bold paragraph, is its first block.
+    return markdownBlocks(section)
+        .slice(1)
+        .flatMap((block) => {
+        if (block.kind !== "item" && block.kind !== "paragraph" && block.kind !== "quote")
+            return [];
+        const text = runsText(block.runs).trim();
+        if (text === "")
+            return [];
+        const href = block.runs.find((run) => run.href !== null)?.href ??
+            /https?:\/\/[^\s)>\]]+/.exec(text)?.[0] ??
+            null;
+        return [{ text, href }];
+    });
+}

package/dist/slices/document/theme.js

@@ -0,0 +1,158 @@
+import { defaultDocumentTheme } from "./model.js";
+// "Cinzel" is bundled (assets/document/fonts) in the styles below; the other three are the
+// PDF standard fonts every reader has.
+export const fontFamilies = ["Cinzel", "times", "helvetica", "courier"];
+export const fontStyles = ["normal", "medium", "bold", "black", "italic", "bolditalic"];
+const cinzel = (style, letterSpacing) => ({
+    family: "Cinzel",
+    style,
+    letterSpacing,
+});
+const dicemaster = {
+    page: { format: "a4", margin: 22, contentTop: 32 },
+    background: { image: "parchment", color: "#f5ebd7" },
+    colors: { heading: "#8c1e14", text: "#000000", muted: "#50463c", faint: "#786e5f" },
+    fonts: {
+        body: cinzel("normal", 0.01),
+        strong: cinzel("bold", 0.02),
+        // Cinzel has no italic, so emphasis borrows the standard serif's.
+        emphasis: { family: "times", style: "italic", letterSpacing: 0 },
+        heading: cinzel("bold", 0.02),
+        dramatic: cinzel("black", 0.03),
+        decorative: cinzel("medium", 0.015),
+        dropCap: cinzel("black", 0),
+        footer: { family: "times", style: "normal", letterSpacing: 0 },
+    },
+    // lore2script2 scaled its Cinzel sizes and line heights (by 1.1, 1.05 and 1.2) and
+    // rounded; these are the results.
+    sizes: {
+        brand: 31,
+        title: 22,
+        section: 19,
+        heading: 17,
+        subheading: 13,
+        body: 10.5,
+        footer: 9,
+        meta: 10,
+    },
+    spacing: {
+        bodyLine: 8,
+        headingLine: 11,
+        subheadingLine: 9,
+        paragraphGap: 0.5,
+        headingGap: 1,
+        itemGap: 0.2,
+        listIndent: 6,
+        quoteIndent: 8,
+        ruleWidth: 30,
+    },
+    dropCap: { enabled: true, lines: 3, scale: 3, gap: 4, minLength: 50, minRoom: 0.25 },
+    titlePage: {
+        brandY: 60,
+        taglineOffset: 10,
+        titleY: 80,
+        titleLine: 10,
+        metaOffset: 20,
+        metaLine: 10,
+        showDate: true,
+        showWordCount: true,
+        cover: { enabled: true, gap: 6, maxHeight: 110 },
+    },
+    contents: {
+        enabled: true,
+        title: "Table of Contents",
+        depth: 2,
+        titleOffset: 20,
+        firstEntryOffset: 40,
+        line: 8,
+        indent: 5,
+    },
+    header: { enabled: true, top: 15, maxTitleCharacters: 35 },
+    footer: { enabled: true, bottom: 10, reserve: 15, text: "Page {page}" },
+    brand: {
+        name: "DiceMaster.io",
+        url: "https://dicemaster.io/",
+        tagline: "Let us Handle the Crunch, You Focus on the Story",
+        linkLabel: "Visit DiceMaster.io",
+    },
+    metadata: {
+        author: "Created with DiceMaster.io",
+        subject: "{title} - Powered by DiceMaster.io",
+        keywords: "D&D, DnD, Dungeons and Dragons, lore, script, tabletop, RPG, TTRPG, DiceMaster.io",
+        creator: "DiceMaster.io - The AI-Powered Virtual Tabletop",
+    },
+    sources: {
+        enabled: true,
+        title: "Sources Consulted",
+        titleOffset: 20,
+        bodyOffset: 40,
+        line: 8,
+        gap: 2,
+    },
+    endPage: {
+        enabled: true,
+        title: "About DiceMaster.io",
+        titleOffset: 20,
+        bodyOffset: 40,
+        lines: [
+            "About DiceMaster.io:",
+            "• Character Engine - Form-driven creation with automatic leveling",
+            "• Automated Rules Engine - D&D mechanics and spells run automatically",
+            "• AI-Generated NPCs - Instant personalities with full stat blocks",
+            "• Granular Inventory Tracking - Live gear & condition management",
+            "• Real-Time Rule Guidance - Context-aware clarifications",
+            "• Dynamic Storytelling AI - On-the-fly narration & dialogue",
+            "• True-Physics Dice - RNG-driven rolls with animated suspense",
+            "• Cinematic Combat Module - Positional tracking & narrative summaries",
+            "• Voice Commands - Seamless STT/TTS multimodal interaction",
+            "• AI Dungeon Master Layer - Rules adjudication & encounter balancing",
+        ],
+        showDocumentDetails: true,
+        link: { text: "Visit DiceMaster.io", url: "https://dicemaster.io/" },
+        closing: "Experience the future of tabletop RPGs!",
+    },
+};
+const plain = {
+    background: { image: null, color: "#fdfaf3" },
+    colors: { heading: "#1f3a5f", text: "#1a1a1a", muted: "#555555", faint: "#888888" },
+    brand: { name: null, url: null, tagline: null, linkLabel: null },
+    metadata: { author: "", subject: "{title}", keywords: "D&D, lore", creator: "" },
+    endPage: { enabled: false },
+};
+export function builtInTheme(name) {
+    return name === "plain" ? resolveTheme(plain) : resolveTheme();
+}
+export function defaultTheme() {
+    return builtInTheme(defaultDocumentTheme);
+}
+// Unknown sections and keys throw, so a typo in a saved theme can't pass silently.
+export function resolveTheme(overrides = {}, base = dicemaster) {
+    const theme = structuredClone(base);
+    for (const [section, values] of Object.entries(overrides)) {
+        const target = theme[section];
+        if (target === undefined)
+            throw new Error(`Unknown document theme section "${section}" (expected one of: ${Object.keys(theme).join(", ")})`);
+        for (const [key, value] of Object.entries(values ?? {})) {
+            if (!(key in target))
+                throw new Error(`Unknown document theme setting "${section}.${key}" (expected one of: ${Object.keys(target).join(", ")})`);
+            target[key] = value;
+        }
+    }
+    const resolved = theme;
+    for (const [key, value] of Object.entries(resolved.colors))
+        parseHexColor(value, `colors.${key}`);
+    parseHexColor(resolved.background.color, "background.color");
+    return resolved;
+}
+export function parseHexColor(hex, label = "color") {
+    const match = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(hex.trim());
+    const digits = match?.[1];
+    if (digits === undefined)
+        throw new Error(`Invalid document theme ${label} "${hex}": expected a hex color like "#8c1e14"`);
+    const full = digits.length === 3 ? [...digits].map((digit) => digit + digit).join("") : digits;
+    return {
+        r: Number.parseInt(full.slice(0, 2), 16),
+        g: Number.parseInt(full.slice(2, 4), 16),
+        b: Number.parseInt(full.slice(4, 6), 16),
+    };
+}

package/dist/slices/document/writer.js

@@ -0,0 +1,66 @@
+import { useFace } from "./fonts.js";
+import { parseHexColor } from "./theme.js";
+export function createWriter(doc, theme, assets) {
+    const width = doc.internal.pageSize.getWidth();
+    const height = doc.internal.pageSize.getHeight();
+    const colors = {
+        heading: parseHexColor(theme.colors.heading),
+        text: parseHexColor(theme.colors.text),
+        muted: parseHexColor(theme.colors.muted),
+        faint: parseHexColor(theme.colors.faint),
+    };
+    const writer = {
+        doc,
+        theme,
+        colors,
+        width,
+        height,
+        left: theme.page.margin,
+        contentWidth: width - theme.page.margin * 2,
+        bottom: height - theme.footer.bottom - theme.footer.reserve,
+        y: theme.page.contentTop,
+        addPage() {
+            doc.addPage();
+            paintBackground(doc, theme, assets, width, height);
+            writer.y = theme.page.contentTop;
+        },
+        ensure(needed) {
+            if (writer.y + needed > writer.bottom)
+                writer.addPage();
+        },
+        page() {
+            return doc.getCurrentPageInfo().pageNumber;
+        },
+        write(text, x, y, face, size, color, align = "left") {
+            useFace(doc, face, size);
+            const rgb = colors[color];
+            doc.setTextColor(rgb.r, rgb.g, rgb.b);
+            doc.text(text, x, y, align === "left" ? {} : { align });
+            doc.setCharSpace(0);
+        },
+    };
+    paintBackground(doc, theme, assets, width, height);
+    return writer;
+}
+// The texture when the theme has one, otherwise the flat colour with slightly darker edges.
+function paintBackground(doc, theme, assets, width, height) {
+    if (theme.background.image === "parchment") {
+        // The alias embeds the image once and points every page at it.
+        doc.addImage(assets.parchment, "JPEG", 0, 0, width, height, "parchment");
+        return;
+    }
+    const base = parseHexColor(theme.background.color);
+    doc.setFillColor(base.r, base.g, base.b);
+    doc.rect(0, 0, width, height, "F");
+    const steps = 4;
+    const thickness = 2;
+    for (let step = 0; step < steps; step += 1) {
+        const inset = step * 2;
+        const shade = (channel) => Math.max(0, Math.round(channel - 15 * (1 - step / steps)));
+        doc.setFillColor(shade(base.r), shade(base.g), shade(base.b));
+        doc.rect(inset, inset, width - 2 * inset, thickness, "F");
+        doc.rect(inset, height - inset - thickness, width - 2 * inset, thickness, "F");
+        doc.rect(inset, inset, thickness, height - 2 * inset, "F");
+        doc.rect(width - inset - thickness, inset, thickness, height - 2 * inset, "F");
+    }
+}

package/dist/slices/estimate/index.js

@@ -1,10 +1,12 @@
 import { z } from "zod";
-import { usesNarrationPreparation } from "../admission/rules.js";
+import { sourceOf } from "../admission/model.js";
+import { usesNarrationPreparation, usesYoutubeDescription } from "../admission/rules.js";
 import { plainText } from "../article/plain.js";
 import { splitEndMatter } from "../article/split.js";
 import { chunkNarration, defaultChunking } from "../narration/chunk.js";
 import { normalizeNarrationText } from "../narration/plan.js";
 import { preparationMessages } from "../narration/preparation.js";
+import { defaultDescriptionPrompt } from "../youtube/model.js";
 import { estimateRequests, groupEstimateRows } from "./requests.js";
 export { estimateRequests } from "./requests.js";
 export function estimateRun(draft, rendered, expectedWords, catalogue) {
@@ -32,7 +34,7 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
         !model.deprecated)?.pricing.note ?? "Model or account pricing is unknown.";
     const generatedArticle = draft.sources.article === "generate";
     const articleChars = generatedArticle ? expectedWords * 6 : (draft.provided.article?.length ?? 0);
-    const promptChars = Object.entries(rendered).reduce((sum, [key, value]) => sum + (key === "narration" ? 0 : value.length), 0);
+    const promptChars = Object.entries(rendered).reduce((sum, [key, value]) => sum + (key === "narration" || key === "description" ? 0 : value.length), 0);
     const local = (stage, detail) => {
         requests.push({ kind: "local", stage, detail });
     };
@@ -122,6 +124,16 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
     if (draft.sources.thumbnail === "prompt_by_llm")
         text("Thumbnail prompt", promptChars + articleChars, 1200);
     local("Export / subtitles", "Local processing; no API fee.");
+    // The timed transcript is the narration with a time before every passage of about 20 s,
+    // plus the fixed rules of the answer.
+    if (usesYoutubeDescription(draft))
+        text("YouTube description", (rendered.description?.trim()
+            ? rendered.description.length
+            : defaultDescriptionPrompt.length) +
+            Math.round(articleChars * 1.05) +
+            1500, 2400, "One LLM call on the timed transcript.");
+    if (sourceOf(draft.sources, "document") === "generate")
+        local("Document", "Laid out locally from the article; no API fee.");
     return {
         ...groupEstimateRows(estimateRequests(requests, data)),
         expectedWords,

package/dist/slices/fonts/catalog.js

@@ -31,7 +31,7 @@ export async function resolveFont(paths, id) {
     return font;
 }
 export function missingFont() {
-    return new Error("The selected font is no longer available. Choose another font.", {
+    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.", {
         cause: "font-not-found",
     });
 }

package/dist/slices/fonts/upload.js

@@ -27,7 +27,7 @@ export async function uploadFont(paths, input) {
     const root = join(paths.dataDir, "fonts");
     await mkdir(root, { recursive: true, mode: 0o700 });
     if (!(await lstat(root)).isDirectory())
-        throw new Error("The font storage directory is unavailable.");
+        throw new Error(`Slopify can't save uploaded fonts because ${root} is not a folder. Move or rename that file, then upload the font again.`);
     const temporary = join(root, `.upload-${randomUUID()}`);
     try {
         await writeFile(temporary, input.content, { mode: 0o600, flag: "wx" });

package/dist/slices/images/run.js

@@ -22,19 +22,19 @@ export async function runImages(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.images;
     if (choice === undefined) {
         // Admission refuses a run whose images are Generate without a provider and a model, so
         // reaching here is a bug in admission rather than the user's.
-        throw new Error("the run has no image provider or model");
+        throw new Error("No image model is set for this project. Choose one in Edit project → Providers, then Retry stage.");
     }
     const pieces = plan(deps, context, project.config);
     if (pieces.length === 0) {
         // Admission makes an image source mandatory and puts the Number at one or more, so an
         // empty plan is a bug upstream rather than a run with no pictures.
-        throw new Error("the run ticked no image prompt");
+        throw new Error("Slopify hit an internal error (no image prompt was selected). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
     }
     // The run's own frame. The adapter turns it into whatever its provider spells the
     // closest supported size, and the render crops whatever is left over.
@@ -78,7 +78,7 @@ function plan(deps, context, config) {
         // it, so the run carries the substituted text under this key.
         const prompt = config.rendered[`imagePrompts.${String(at)}`];
         if (prompt === undefined) {
-            throw new Error(`the run has no rendered text for the image prompt ${picked.name}`);
+            throw new Error(`Slopify hit an internal error (the image prompt ${picked.name} was never filled in). Retry stage; if it happens again, use Download diagnostics in Settings and report it.`);
         }
         for (let send = 1; send <= picked.number; send += 1) {
             planned.push({
@@ -224,7 +224,7 @@ function report(deps, context, done, total) {
 }
 function payloadOf(piece) {
     if (piece.payload === null) {
-        throw new Error(`image ${piece.id} has no payload`);
+        throw new Error("Slopify hit an internal error (a saved image step is empty). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
     }
     return imagePayload.parse(JSON.parse(piece.payload));
 }

package/dist/slices/library/lint.js

@@ -13,17 +13,23 @@ function lint(name, body) {
     const fields = [];
     const trimmed = name.trim();
     if (trimmed === "") {
-        fields.push({ field: "name", message: "A name is required." });
+        fields.push({ field: "name", message: "Enter a name." });
     }
     else if (trimmed.length > nameMax) {
-        fields.push({ field: "name", message: `A name is at most ${String(nameMax)} characters.` });
+        fields.push({
+            field: "name",
+            message: `Keep the name to ${String(nameMax)} characters or fewer.`,
+        });
     }
     if (body.trim() === "") {
-        fields.push({ field: "body", message: "A body is required." });
+        fields.push({ field: "body", message: "Enter the text." });
         return fields;
     }
     if (body.length > bodyMax) {
-        fields.push({ field: "body", message: `A body is at most ${String(bodyMax)} characters.` });
+        fields.push({
+            field: "body",
+            message: `The text is too long. Keep it to ${String(bodyMax)} characters or fewer.`,
+        });
         return fields;
     }
     for (const error of detectSlots(body).errors) {
@@ -37,11 +43,11 @@ function describe(error, body) {
     const where = positionOf(body, error.at);
     switch (error.kind) {
         case "unclosed":
-            return `The \`{{\` at ${where} is never closed.`;
+            return `The \`{{\` at ${where} is never closed. Add \`}}\` after the keyword name.`;
         case "empty":
-            return `The slot at ${where} has no name.`;
+            return `The keyword at ${where} has no name. Write a name between \`{{\` and \`}}\`.`;
         case "nested":
-            return `The slot at ${where} holds a brace; slots do not nest.`;
+            return `The keyword at ${where} contains a brace. Keywords cannot be placed inside other keywords.`;
     }
 }
 function positionOf(body, at) {

package/dist/slices/library/model.js

@@ -2,7 +2,7 @@
 // set covers both, which is why the drafts, the lint and the save path below are shared
 // rather than mirrored.
 export { entryModes } from "../admission/model.js";
-export const promptKinds = ["article", "image", "thumbnail", "narration"];
+export const promptKinds = ["article", "image", "thumbnail", "narration", "description"];
 export const entryCategories = ["intro", "outro"];
 // The name is what the Play pickers show, so it shares admission's title bound.
 export const nameMax = 200;