@gentbajko/slopify 2.5.0 → 3.0.0

package/dist/slices/model-upkeep/usage.js

@@ -0,0 +1,183 @@
+import { z } from "zod";
+import { isVideoModel } from "../../catalog/schema.js";
+import { listProjects, stagesOf } from "../admission/repo.js";
+import { draftRows } from "../play-drafts/repo.js";
+import { documentOf } from "../play-drafts/service.js";
+import { templateById } from "../project-templates/repo.js";
+import { currentRevisionId, revisionById } from "../revisions/repo.js";
+import { isLocalCliProvider } from "../settings/model.js";
+import { usageSlots } from "./model.js";
+export { slotLabels, usageKinds, usageSlots } from "./model.js";
+function familyOf(slot) {
+    return slot === "llm" ? "llm" : slot === "audio" ? "tts" : "image";
+}
+// The model choices a Play form (a draft or a template) makes.
+export function formChoices(form) {
+    const edit = form.videoEdit;
+    return {
+        llm: form.llm,
+        audio: form.audio,
+        images: form.images,
+        ...(edit !== undefined && edit.animate !== "off"
+            ? { animate: { provider: form.images.provider, model: edit.animateModel } }
+            : {}),
+    };
+}
+// The same for a project's run configuration.
+export function configChoices(config) {
+    const edit = config.videoEdit;
+    return {
+        ...(config.llm === undefined ? {} : { llm: config.llm }),
+        ...(config.audio === undefined ? {} : { audio: config.audio }),
+        ...(config.images === undefined ? {} : { images: config.images }),
+        ...(edit !== undefined && edit.animate !== "off" && config.images !== undefined
+            ? { animate: { provider: config.images.provider, model: edit.animateModel } }
+            : {}),
+    };
+}
+// Whether a choice names a catalogued model that is no longer offered. Command-line tools
+// list their own models and are checked by the health check instead.
+export function retiredStatus(catalogue, slot, choice) {
+    if (choice.provider === "" || choice.model.trim() === "" || isLocalCliProvider(choice.provider))
+        return null;
+    const row = catalogue[familyOf(slot)].find((model) => model.provider === choice.provider &&
+        model.id === choice.model &&
+        isVideoModel(model) === (slot === "animate"));
+    if (row === undefined)
+        return "unlisted";
+    if (row.deprecated)
+        return "retired";
+    return row.enabled ? null : "unlisted";
+}
+// The closest active model from the same provider and list: the one sharing the longest
+// start of its ID (a newer version of the same line), the catalogue's order breaking ties.
+export function suggestReplacement(catalogue, slot, choice) {
+    let best = null;
+    for (const row of catalogue[familyOf(slot)]) {
+        if (row.provider !== choice.provider ||
+            row.id === choice.model ||
+            !row.enabled ||
+            row.deprecated ||
+            isVideoModel(row) !== (slot === "animate"))
+            continue;
+        const score = sharedStart(row.id.toLowerCase(), choice.model.toLowerCase());
+        if (best === null || score > best.score)
+            best = { id: row.id, name: row.name, score };
+    }
+    return best === null ? null : { id: best.id, name: best.name };
+}
+function sharedStart(a, b) {
+    let index = 0;
+    while (index < a.length && index < b.length && a[index] === b[index])
+        index++;
+    return index;
+}
+function usagesOf(catalogue, base, choices, blocked) {
+    const found = [];
+    for (const slot of usageSlots) {
+        const choice = choices[slot];
+        if (choice === undefined)
+            continue;
+        const why = retiredStatus(catalogue, slot, choice);
+        if (why === null)
+            continue;
+        const replacement = suggestReplacement(catalogue, slot, choice);
+        found.push({
+            ...base,
+            key: `${base.kind}:${base.id}:${slot}`,
+            slot,
+            provider: choice.provider,
+            model: choice.model,
+            why,
+            replacement,
+            blocked: blocked ??
+                (replacement === null
+                    ? "This provider has no other model to switch to. Choose another provider for this step and save."
+                    : null),
+        });
+    }
+    return found;
+}
+const scheduleRow = z.object({
+    id: z.string(),
+    name: z.string(),
+    template_id: z.string(),
+    template_version: z.number(),
+});
+const headRow = z.object({ head_version: z.number() });
+export function choiceSites(db) {
+    const sites = [];
+    const heads = new Map();
+    for (const row of db.prepare("SELECT id FROM project_templates ORDER BY id").all()) {
+        const id = z.object({ id: z.string() }).parse(row).id;
+        const template = templateById(db, id);
+        if (template === undefined)
+            continue;
+        heads.set(id, template.version);
+        sites.push({
+            kind: "template",
+            id,
+            name: template.name,
+            choices: formChoices(template.document.form),
+            blocked: null,
+        });
+    }
+    for (const raw of db
+        .prepare("SELECT id,name,template_id,template_version FROM schedules WHERE deleted_at IS NULL AND status IN ('active','paused') ORDER BY lower(name),id")
+        .all()) {
+        const row = scheduleRow.parse(raw);
+        const template = templateById(db, row.template_id, row.template_version);
+        if (template === undefined)
+            continue;
+        const head = heads.get(row.template_id) ??
+            headRow.parse(db.prepare("SELECT head_version FROM project_templates WHERE id=?").get(row.template_id)).head_version;
+        sites.push({
+            kind: "schedule",
+            id: row.id,
+            name: row.name,
+            choices: formChoices(template.document.form),
+            blocked: head === row.template_version
+                ? null
+                : `This schedule runs an older version of the template "${template.name}". In Library → Schedules, choose Edit, pick the template again so it runs the latest version, then save.`,
+        });
+    }
+    for (const row of draftRows(db)) {
+        if (row.state !== "active")
+            continue;
+        const document = documentOf(row);
+        if (document === null)
+            continue;
+        sites.push({
+            kind: "draft",
+            id: row.id,
+            name: row.title.trim() === "" ? "Untitled draft" : row.title,
+            choices: formChoices(document.form),
+            blocked: null,
+        });
+    }
+    for (const project of listProjects(db)) {
+        const stages = stagesOf(db, project.id);
+        // Only a project with steps still to run will use its models again.
+        if (!stages.some((stage) => ["pending", "running", "failed", "canceled"].includes(stage.state)))
+            continue;
+        const revisionId = currentRevisionId(db, project.id);
+        const config = revisionId === undefined
+            ? project.config
+            : (revisionById(db, project.id, revisionId)?.config ?? project.config);
+        sites.push({
+            kind: "project",
+            id: project.id,
+            name: project.title,
+            choices: configChoices(config),
+            blocked: stages.some((stage) => stage.state === "running")
+                ? "This project is running. Wait for it to finish or pause it, then switch."
+                : null,
+        });
+    }
+    return sites;
+}
+// Every template, schedule, draft and unfinished project that still picks a retired or
+// unlisted model, with the suggested replacement. Nothing is changed here.
+export function retiredModelUsage(db, catalogue) {
+    return choiceSites(db).flatMap((site) => usagesOf(catalogue, { kind: site.kind, id: site.id, name: site.name }, site.choices, site.blocked));
+}

package/dist/slices/narration/aliases-library.js

@@ -0,0 +1,31 @@
+import { transact } from "../../kernel/db/tx.js";
+import { aliasProblems, narrationAliasSchema } from "./aliases-schema.js";
+export function listNarrationAliases(db) {
+    return db
+        .prepare("SELECT written,spoken,whole_word,case_sensitive FROM narration_aliases ORDER BY position,id")
+        .all()
+        .flatMap((row) => {
+        // A row edited by hand into something the editor can't save is left out, not fatal.
+        const parsed = narrationAliasSchema.safeParse({
+            written: row.written,
+            spoken: row.spoken,
+            wholeWord: row.whole_word === 1,
+            caseSensitive: row.case_sensitive === 1,
+        });
+        return parsed.success ? [parsed.data] : [];
+    });
+}
+export function saveNarrationAliases(deps, rows) {
+    const fields = aliasProblems(rows);
+    if (fields.length > 0)
+        return { ok: false, fields };
+    const aliases = rows.map((row) => narrationAliasSchema.parse(row));
+    const now = deps.clock.now().toISOString();
+    transact(deps.db, () => {
+        deps.db.prepare("DELETE FROM narration_aliases").run();
+        const insert = deps.db.prepare("INSERT INTO narration_aliases(id,position,written,spoken,whole_word,case_sensitive,updated_at) VALUES (?,?,?,?,?,?,?)");
+        for (const [position, alias] of aliases.entries())
+            insert.run(deps.ids.next(), position, alias.written, alias.spoken, alias.wholeWord ? 1 : 0, alias.caseSensitive ? 1 : 0, now);
+    });
+    return { ok: true, aliases };
+}

package/dist/slices/narration/aliases-schema.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { aliasCountMax, aliasSpokenMax, aliasWrittenMax, } from "../../kernel/ports/narration-aliases.js";
+// One alias as a project config and Library → Aliases store it.
+export const narrationAliasSchema = z
+    .object({
+    written: z.string().trim().min(1).max(aliasWrittenMax),
+    spoken: z.string().trim().min(1).max(aliasSpokenMax),
+    wholeWord: z.boolean(),
+    caseSensitive: z.boolean(),
+})
+    .strict()
+    .readonly();
+export const narrationAliasesSchema = z.array(narrationAliasSchema).max(aliasCountMax).readonly();
+export function aliasProblems(rows) {
+    const problems = [];
+    if (rows.length > aliasCountMax)
+        problems.push({
+            field: "aliases",
+            message: `Keep at most ${aliasCountMax} aliases; remove some, then Save.`,
+        });
+    const seen = new Map();
+    for (const [index, raw] of rows.entries()) {
+        const row = index + 1;
+        const parsed = narrationAliasSchema.safeParse(raw);
+        if (!parsed.success) {
+            const written = z.object({ written: z.string() }).safeParse(raw);
+            const spoken = z.object({ spoken: z.string() }).safeParse(raw);
+            problems.push({
+                field: `aliases.${index}`,
+                message: !written.success || written.data.written.trim() === ""
+                    ? `Alias ${row}: write the word or phrase as it appears in the article.`
+                    : !spoken.success || spoken.data.spoken.trim() === ""
+                        ? `Alias ${row}: write how the narrator should say it.`
+                        : `Alias ${row}: keep the written form under ${aliasWrittenMax} characters and the spoken form under ${aliasSpokenMax}.`,
+            });
+            continue;
+        }
+        const key = aliasKey(parsed.data);
+        const earlier = seen.get(key);
+        if (earlier !== undefined)
+            problems.push({
+                field: `aliases.${index}`,
+                message: `Alias ${row}: alias ${earlier} already covers the same written form; keep one of them.`,
+            });
+        else
+            seen.set(key, row);
+    }
+    return problems;
+}
+function aliasKey(alias) {
+    const written = alias.written.trim().replace(/\s+/gu, " ");
+    return alias.caseSensitive ? `=${written}` : `~${written.toLocaleLowerCase("en")}`;
+}

package/dist/slices/narration/aliases.js

@@ -0,0 +1,49 @@
+import { aliasMatches, } from "../../kernel/ports/narration-aliases.js";
+// Narration aliases ride the same rails as the Pronunciation Glossary: a span of the clean
+// narration text with what the voice gets instead. The clean text (what the transcript and
+// captions show) is untouched. A span never holds whitespace, so an alias whose written form
+// has several words puts all of the spoken form on its first word and nothing on the rest.
+export function aliasSpans(source, aliases) {
+    const spans = [];
+    for (const match of aliasMatches(source, aliases))
+        for (const [index, word] of Array.from(source.slice(match.start, match.end).matchAll(/\S+/gu)).entries()) {
+            const start = match.start + word.index;
+            spans.push({ start, end: start + word[0].length, text: index === 0 ? match.spoken : "" });
+        }
+    return spans;
+}
+// An alias wins over a glossary pronunciation of the same words: it says what to read, and the
+// glossary only how to read what is written.
+export function withAliasSpans(glossary, aliases) {
+    if (aliases.length === 0)
+        return glossary;
+    const kept = glossary.filter((span) => !aliases.some((alias) => alias.start < span.end && span.start < alias.end));
+    return [...kept, ...aliases].sort((a, b) => a.start - b.start);
+}
+// The sentences Narration Preparation reads, with the aliases already applied, so its
+// delivery cues fit what will actually be said. The sentences are cut from the clean text
+// first, so their numbers stay the ones the cues are checked and placed against.
+export function aliasedSentences(sentences, matches) {
+    if (matches.length === 0)
+        return sentences;
+    let offset = 0;
+    return sentences.map((sentence) => {
+        const start = offset;
+        const end = start + sentence.text.length;
+        offset = end;
+        let text = "";
+        let at = start;
+        for (const match of matches) {
+            if (match.end <= start || match.start >= end)
+                continue;
+            if (match.start >= at)
+                text += sentence.text.slice(at - start, match.start - start);
+            // The spoken form goes with the sentence the written form starts in.
+            if (match.start >= start)
+                text += match.spoken;
+            at = Math.max(at, Math.min(match.end, end));
+        }
+        text += sentence.text.slice(at - start);
+        return { sentence: sentence.sentence, text };
+    });
+}

package/dist/slices/narration/blocks.js

@@ -0,0 +1,352 @@
+import { remark } from "remark";
+import remarkGfm from "remark-gfm";
+// The article as it will be spoken, block by block, for "Describe tables and figures in the
+// narration". Flattening the Markdown (`article/plain.ts`) keeps the words of prose but has
+// nothing to say about a table, a picture, an equation or a program: it drops them or reads
+// their bare cells. Here the document is walked instead, and every block a listener cannot
+// follow read aloud is kept whole for the text model to describe in a sentence or four
+// (`narration/describe.ts`); everything else becomes plain spoken text.
+//
+// Deterministic: the same Markdown always gives the same blocks, so a description is cached by
+// its block and an unchanged article never asks for one again. The article's end matter (the
+// sources and the pronunciation glossary) is cut off before this runs (`article/split.ts`), as
+// it is for the flattened text, so neither is ever narrated.
+export const describedKinds = ["table", "figure", "diagram", "math", "code"];
+// Private-use characters around an equation's number while the document is parsed, so an
+// underscore or asterisk inside an equation is never read as emphasis.
+const open = "\uE000";
+const close = "\uE001";
+const placeholder = /\uE000(\d+)\uE001/g;
+export function narrationBlocks(markdown, options = {}) {
+    const { text: protectedText, math } = protectMath(markdown);
+    const tree = remark().use(remarkGfm).parse(protectedText);
+    const walker = new Walker(protectedText, math, options);
+    walker.blocks(tree.children);
+    return walker.out;
+}
+export function describedBlocks(blocks) {
+    return blocks.filter((block) => block.kind !== "text");
+}
+// The narration: the text blocks as they are and each described block as its spoken passage,
+// one paragraph each, in the flattened text's own shape. Null while any passage is unknown.
+export function spokenNarration(blocks, passage) {
+    const paragraphs = [];
+    for (const block of blocks) {
+        const text = block.kind === "text" ? block.text : passage(block);
+        if (text === null)
+            return null;
+        const clean = text.trim();
+        if (clean !== "")
+            paragraphs.push(clean);
+    }
+    return paragraphs.length === 0 ? "" : `${paragraphs.join("\n\n")}\n`;
+}
+function protectMath(markdown) {
+    // Code keeps its dollars: a shell variable is not an equation.
+    const code = [];
+    const visit = (node) => {
+        if ((node.type === "code" || node.type === "inlineCode") && node.position) {
+            code.push([node.position.start.offset ?? 0, node.position.end.offset ?? 0]);
+            return;
+        }
+        if ("children" in node)
+            for (const child of node.children)
+                visit(child);
+    };
+    visit(remark().use(remarkGfm).parse(markdown));
+    const math = [];
+    const pattern = /\$\$([\s\S]+?)\$\$|\\\[([\s\S]+?)\\\]|\\\(([\s\S]+?)\\\)|(?<![\\$\w])\$(?![\s$])([^$\n]+?)(?<![\s\\])\$(?![\w$])/g;
+    const text = markdown.replace(pattern, (written, a, b, c, d, at) => {
+        if (code.some(([from, to]) => at < to && at + written.length > from))
+            return written;
+        const tex = String(a ?? b ?? c ?? d ?? "").trim();
+        math.push({ tex, written, display: a !== undefined || b !== undefined });
+        return `${open}${String(math.length - 1)}${close}`;
+    });
+    return { text, math };
+}
+class Walker {
+    markdown;
+    math;
+    options;
+    out = [];
+    section = null;
+    described = 0;
+    constructor(markdown, math, options) {
+        this.markdown = markdown;
+        this.math = math;
+        this.options = options;
+    }
+    blocks(nodes) {
+        for (let at = 0; at < nodes.length; at++) {
+            const node = nodes[at];
+            if (node === undefined)
+                continue;
+            switch (node.type) {
+                case "heading": {
+                    const text = this.spoken(node.children).replace(placeholder, (_all, n) => {
+                        const tex = this.math[Number(n)]?.tex ?? "";
+                        return readable(tex) ?? tex;
+                    });
+                    this.section = text.trim() || this.section;
+                    this.text(text);
+                    break;
+                }
+                case "paragraph": {
+                    if (node.children.some((child) => child.type === "image")) {
+                        // A caption or legend written under the picture belongs to it.
+                        const captions = [];
+                        while (captions.length < 2) {
+                            const next = nodes[at + captions.length + 1];
+                            if (next?.type !== "paragraph" || !isCaption(next, this.markdown))
+                                break;
+                            captions.push(next);
+                        }
+                        at += captions.length;
+                        this.figure(node, captions);
+                        break;
+                    }
+                    this.paragraph(node);
+                    break;
+                }
+                case "list":
+                    this.list(node);
+                    break;
+                case "blockquote":
+                    this.quote(node);
+                    break;
+                case "table":
+                    this.describe("table", this.source(node));
+                    break;
+                case "code":
+                    this.code(node);
+                    break;
+                case "html":
+                    this.html(node);
+                    break;
+                // A footnote's text, a link definition, a rule and front matter are never spoken.
+                default:
+                    break;
+            }
+        }
+    }
+    text(text) {
+        const clean = tidy(text);
+        if (clean !== "")
+            this.out.push({ kind: "text", text: clean });
+    }
+    describe(kind, source, extra = {}) {
+        this.described += 1;
+        this.out.push({
+            kind,
+            index: this.described,
+            source: source.trim(),
+            section: this.section,
+            ...(extra.image === undefined ? {} : { image: extra.image }),
+            ...(extra.lang === undefined ? {} : { lang: extra.lang }),
+            ...(extra.inline === undefined ? {} : { inline: extra.inline }),
+        });
+    }
+    paragraph(node) {
+        const raw = this.spoken(node.children);
+        const only = /^\s*\uE000(\d+)\uE001\s*$/.exec(raw);
+        const alone = only === null ? undefined : this.math[Number(only[1])];
+        if (alone !== undefined) {
+            this.describe("math", alone.written);
+            return;
+        }
+        const spans = [...raw.matchAll(placeholder)].map((match) => this.math[Number(match[1])]);
+        if (spans.some((span) => span === undefined || span.display || readable(span.tex) === null)) {
+            // Said in words by the model, the rest of the paragraph with it.
+            this.describe("math", this.source(node), { inline: true });
+            return;
+        }
+        this.text(raw.replace(placeholder, (_all, n) => readable(this.math[Number(n)]?.tex ?? "") ?? ""));
+    }
+    figure(node, captions) {
+        const image = node.children.find((child) => child.type === "image");
+        const lines = [];
+        for (const child of node.children)
+            if (child.type === "image" && child.alt?.trim())
+                lines.push(`Alt text: ${child.alt.trim()}`);
+        const beside = tidy(this.restore(this.spoken(node.children.filter((child) => child.type !== "image"))));
+        if (beside !== "")
+            lines.push(`Caption: ${beside}`);
+        for (const caption of captions) {
+            const text = tidy(this.restore(this.spoken(caption.children)));
+            if (text !== "")
+                lines.push(`Caption: ${text}`);
+        }
+        this.describe("figure", lines.join("\n") || "A picture with no caption.", {
+            ...(image?.url ? { image: image.url } : {}),
+        });
+    }
+    html(node) {
+        // An article pasted from the web may carry its figures as HTML.
+        const img = /<img\b[^>]*>/i.exec(node.value);
+        if (img === null)
+            return;
+        const attribute = (name) => new RegExp(`\\b${name}\\s*=\\s*("([^"]*)"|'([^']*)')`, "i")
+            .exec(img[0])
+            ?.slice(2)
+            .find(Boolean);
+        const caption = /<figcaption[^>]*>([\s\S]*?)<\/figcaption>/i.exec(node.value)?.[1];
+        const lines = [
+            ...(attribute("alt")?.trim() ? [`Alt text: ${attribute("alt")?.trim() ?? ""}`] : []),
+            ...(caption?.trim() ? [`Caption: ${tidy(caption.replace(/<[^>]+>/g, " "))}`] : []),
+        ];
+        const src = attribute("src");
+        this.describe("figure", lines.join("\n") || "A picture with no caption.", {
+            ...(src ? { image: src } : {}),
+        });
+    }
+    code(node) {
+        const lang = node.lang?.trim().toLowerCase() ?? "";
+        const source = this.restore(this.source(node));
+        const named = lang === "" ? {} : { lang };
+        if (lang === "mermaid" ||
+            (["", "text", "txt", "ascii", "plain"].includes(lang) && isDrawing(node.value)))
+            this.describe("diagram", source, named);
+        else if (["math", "latex", "tex", "katex"].includes(lang))
+            this.describe("math", source);
+        else if (this.options.code !== "skip")
+            this.describe("code", source, named);
+    }
+    quote(node) {
+        const start = this.out.length;
+        this.blocks(node.children);
+        // The quoted words are spoken in quotation marks, which a voice reads as a quote.
+        for (let at = start; at < this.out.length; at++) {
+            const block = this.out[at];
+            if (block?.kind === "text")
+                this.out[at] = { kind: "text", text: `“${block.text}”` };
+        }
+    }
+    list(node) {
+        const items = [];
+        const flush = () => {
+            if (items.length > 0)
+                this.text(this.sentences(items.splice(0), node.ordered === true));
+        };
+        for (const item of node.children) {
+            const words = [];
+            for (const child of item.children) {
+                if (child.type === "paragraph" && !child.children.some((one) => one.type === "image")) {
+                    const raw = this.spoken(child.children);
+                    if (!raw.includes(open)) {
+                        words.push(raw);
+                        continue;
+                    }
+                }
+                // A table, a picture or a nested list inside an item is its own block, after the
+                // item's words.
+                if (words.length > 0)
+                    items.push(tidy(words.splice(0).join(" ")));
+                flush();
+                this.blocks([child]);
+            }
+            if (words.length > 0)
+                items.push(tidy(words.join(" ")));
+        }
+        flush();
+    }
+    sentences(items, ordered) {
+        const english = this.options.language === undefined || this.options.language === "en";
+        const kept = items.filter((item) => item !== "");
+        if (!english || kept.length < 2)
+            return kept.map(sentence).join(" ");
+        if (ordered)
+            return kept
+                .map((item, at) => sentence(`${at === 0 ? "First" : at === kept.length - 1 ? "Finally" : "Then"}, ${item}`))
+                .join(" ");
+        // Short items read as one sentence, "a, b and c"; longer ones one sentence each.
+        if (kept.every((item) => item.split(/\s+/).length <= 5 && !/[.!?;:,—–]/.test(item))) {
+            const joined = `${kept.slice(0, -1).join(", ")} and ${kept.at(-1) ?? ""}`;
+            return sentence(joined.charAt(0).toUpperCase() + joined.slice(1));
+        }
+        return kept.map(sentence).join(" ");
+    }
+    // The words of inline Markdown: link text without its address, no footnote markers, no
+    // bare URLs. Equations stay as placeholders for the caller to decide on.
+    spoken(nodes) {
+        return nodes.map((node) => this.inline(node)).join("");
+    }
+    inline(node) {
+        switch (node.type) {
+            case "text":
+            case "inlineCode":
+                return node.value;
+            case "emphasis":
+            case "strong":
+            case "delete":
+                return this.spoken(node.children);
+            case "link": {
+                const text = this.spoken(node.children);
+                return isAddress(text, node.url) ? "" : text;
+            }
+            case "linkReference": {
+                const text = this.spoken(node.children);
+                return /^\s*\^?\d+\s*$/.test(text) ? "" : text;
+            }
+            case "image":
+            case "imageReference":
+                return node.alt ?? "";
+            case "break":
+                return "\n";
+            default:
+                return "";
+        }
+    }
+    source(node) {
+        const from = node.position?.start.offset;
+        const to = node.position?.end.offset;
+        return from === undefined || to === undefined
+            ? ""
+            : this.restore(this.markdown.slice(from, to));
+    }
+    restore(text) {
+        return text.replace(placeholder, (_all, n) => this.math[Number(n)]?.written ?? "");
+    }
+}
+function isCaption(node, markdown) {
+    if (node.children.length === 1 && node.children[0]?.type === "emphasis")
+        return true;
+    const from = node.position?.start.offset ?? 0;
+    const head = markdown.slice(from, from + 40).replace(/^[*_\s]+/, "");
+    return /^(figure|fig\.|chart|graph|diagram|image|legend|caption|source)\b/i.test(head);
+}
+// An ASCII or box-drawing chart in a plain fence: box characters, or lines that are mostly
+// rules and bars.
+function isDrawing(value) {
+    if (/[─│┌┐└┘├┤┬┴┼═║╔╗╚╝▲▼►◄█░▒▓]/.test(value))
+        return true;
+    const lines = value.split("\n").filter((line) => line.trim() !== "");
+    return (lines.filter((line) => /[-+|*]{3,}|[|+].*[|+]/.test(line)).length >=
+        Math.max(3, lines.length / 2));
+}
+// A link whose text is its own address, or any bare URL: nothing a listener can use.
+function isAddress(text, url) {
+    const clean = text.trim();
+    return clean === "" || clean === url || /^(https?:\/\/|www\.|mailto:)/i.test(clean);
+}
+const greek = /\\(alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|Pi|Sigma|Phi|Psi|Omega)\b/g;
+// A short inline symbol read as it is written ("$T$" is "T", "$\alpha$" is "alpha"), or null
+// when it is a formula to be said in words.
+function readable(tex) {
+    const plain = tex.replace(greek, (_all, name) => name.toLowerCase()).trim();
+    return plain.length <= 20 && /^[\p{L}\p{N}\s.,%]*$/u.test(plain) ? plain : null;
+}
+function sentence(text) {
+    const clean = text.trim();
+    return clean === "" || /[.!?…:;]["”’)]?$/.test(clean) ? clean : `${clean}.`;
+}
+// Footnote markers and bare addresses out, then the spacing they leave behind.
+function tidy(text) {
+    return text
+        .replace(/\s?\[(?:\^?[\w-]+)(?:\s*[,–-]\s*\^?\d+)*\](?!\()/g, (marker) => /\[\^|\[\d/.test(marker) ? "" : marker)
+        .replace(/\s?\b(?:https?:\/\/|www\.)[^\s)]+/g, "")
+        .replace(/[ \t]+([.,;:!?])/g, "$1")
+        .replace(/[ \t]{2,}/g, " ")
+        .replace(/\(\s*\)/g, "")
+        .trim();
+}