@v1nvn/readability 0.45.0 → 0.45.1

package/README.md

@@ -10,9 +10,9 @@ User-facing docs: [root README](../../README.md).
 ## Install
 
 ```bash
-npm install @v1nvn/readability@0.45.0
+npm install @v1nvn/readability@0.45.1
 # or run on demand:
-npx @v1nvn/readability@0.45.0
+npx @v1nvn/readability@0.45.1
 ```
 
 Requires Node >= 22.22.2 (jsdom 30's floor). Build from source:
@@ -58,7 +58,7 @@ Add to your MCP client config (Claude Code, Claude Desktop, etc.):
   "mcpServers": {
     "readability": {
       "command": "npx",
-      "args": ["-y", "@v1nvn/readability@0.45.0"],
+      "args": ["-y", "@v1nvn/readability@0.45.1"],
     },
   },
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@v1nvn/readability",
-  "version": "0.45.0",
+  "version": "0.45.1",
   "description": "MCP server that turns rendered (post-JS) HTML into clean Markdown + metadata via Readability, Turndown, and DOMPurify.",
   "type": "module",
-  "main": "./src/index.ts",
-  "bin": "./src/index.ts",
+  "main": "./src/index.js",
+  "bin": "./src/index.js",
   "scripts": {
     "bench": "vite-node test/bench/run.ts",
     "dev": "vite-node src/dev.ts",
@@ -43,7 +43,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@mozilla/readability": "^0.6.0",
-    "@v1nvn/agentic-core": "^0.45.0",
+    "@v1nvn/agentic-core": "^0.45.1",
     "dompurify": "^3.4.12",
     "jsdom": "^30.0.1",
     "remark-gfm": "^4.0.1",

package/src/cli.js

@@ -0,0 +1,99 @@
+import { describeError, HelpRequested, parseCli, runCli, } from '@v1nvn/agentic-core';
+import { extractArticleFromHtml } from "./tools/extract.js";
+import { readHtmlFile } from "./tools/html-source.js";
+const FORMATS = ['html', 'json', 'md'];
+function parseMaxChars(value) {
+    const n = Number(value);
+    if (!Number.isInteger(n)) {
+        throw new Error('must be an integer');
+    }
+    return n;
+}
+const spec = {
+    name: 'readability',
+    usageExit: 2,
+    commands: [
+        {
+            name: 'extract',
+            description: 'extract the readable article from an HTML file',
+            argument: {
+                flags: '[file]',
+                description: 'HTML file; stdin when omitted',
+            },
+            options: [
+                {
+                    flags: '--format <fmt>',
+                    description: 'output format',
+                    choices: FORMATS,
+                    default: 'md',
+                },
+                {
+                    flags: '--max-chars <n>',
+                    description: 'truncate the output',
+                    parse: parseMaxChars,
+                },
+            ],
+            run: async (options, args) => {
+                try {
+                    const html = await readHtml(args.at(0), process.stdin);
+                    // json reuses the markdown pipeline; the structured object is serialized below.
+                    const pipelineFormat = options.format === 'html' ? 'html' : 'markdown';
+                    const result = extractArticleFromHtml({
+                        html,
+                        format: pipelineFormat,
+                        ...(typeof options.maxChars === 'number'
+                            ? { maxChars: options.maxChars }
+                            : {}),
+                    });
+                    if (result.isError) {
+                        process.stderr.write(`${payloadText(result)}\n`);
+                        return 1;
+                    }
+                    if (options.format === 'json') {
+                        process.stdout.write(`${JSON.stringify(result.structuredContent, null, 2)}\n`);
+                    }
+                    else {
+                        process.stdout.write(`${payloadText(result)}\n`);
+                    }
+                    return 0;
+                }
+                catch (err) {
+                    process.stderr.write(`${describeError(err)}\n`);
+                    return 1;
+                }
+            },
+        },
+    ],
+};
+export function parseArgs(argv) {
+    const parsed = parseCli(spec, argv);
+    if (parsed === undefined || parsed instanceof HelpRequested) {
+        return parsed;
+    }
+    const { format, maxChars } = parsed.options;
+    return { file: parsed.args.at(0), format, maxChars };
+}
+// The stream is injected rather than reading process.stdin directly so the
+// path is testable; chunks may be Buffer or string.
+export async function readHtml(file, stream) {
+    if (file !== undefined) {
+        return readHtmlFile(file);
+    }
+    const chunks = [];
+    for await (const chunk of stream) {
+        if (typeof chunk === 'string') {
+            chunks.push(chunk);
+        }
+        else {
+            chunks.push(Buffer.from(chunk).toString('utf8'));
+        }
+    }
+    return chunks.join('');
+}
+function payloadText(result) {
+    const first = result.content.at(0);
+    return first !== undefined && 'text' in first ? first.text : '';
+}
+export function runExtract(argv) {
+    return runCli(spec, argv);
+}

package/src/config.js

@@ -0,0 +1,29 @@
+import pkg from '../package.json' with { type: 'json' };
+const SERVER_TITLE = 'Readability MCP';
+const SERVER_DESCRIPTION = 'Turn already-rendered (post-JavaScript) HTML into clean, LLM-friendly Markdown plus metadata, via Mozilla Readability, Turndown, and DOMPurify. Makes no outbound requests — input is the rendered HTML, read from a file path (localPath) so the page bytes never enter the model context.';
+const SERVER_INSTRUCTIONS = `Every tool reads already-rendered HTML from a file path (\`localPath\`) — e.g. \`document.documentElement.outerHTML\` written to disk by a browser/devtools capture — so the page bytes never enter the model context; \`chunk_text\` alone takes text. The server never fetches URLs: \`baseUrl\` only absolutizes links.
+
+Pick the tool by page shape:
+- extract: the default for article-like pages → Markdown + metadata + diagnostics. \`cache: true\` exposes the result as a \`readability://page/{hash}\` resource; \`chunk\` adds token-bounded chunks.
+- extract_list: feed, index, search, or HN-style pages Readability cannot turn into one article.
+- extract_tables: every \`<table>\` on the page, including ones outside the article body.
+- extract_grid: div-rendered tables in SPAs.
+- extract_section: one section, by CSS selector or heading text.
+- extract_links: anchors from the raw DOM, for crawl and navigation decisions.
+- extract_metadata, outline: cheap pre-checks (bibliographic metadata; h1-h6 heading TOC) before full extraction.
+- html_to_markdown: a fragment already isolated, converted with no Readability scoring.
+- explain: post-mortem when \`extract\` picked the wrong root.
+- chunk_text: split already-extracted text for embedding/RAG.
+
+When the client advertises MCP \`sampling\`, two more tools appear: \`summarize\` (the host's model summarizes text) and \`suggest_preset\` (after \`extract\` reports gating, a fallback, a near-empty result, or debris, the host's model proposes site selectors; the server verifies them and caches a per-site preset).
+
+Failures come back as \`isError: true\` results, never thrown.`;
+export function loadConfig() {
+    return {
+        name: 'readability',
+        version: pkg.version,
+        title: SERVER_TITLE,
+        description: SERVER_DESCRIPTION,
+        instructions: SERVER_INSTRUCTIONS,
+    };
+}

package/src/dev.js

@@ -0,0 +1,55 @@
+// Dev-only hot reload: tool implementations reload on file change without
+// restarting the process; the harness in core owns the vite/runner/watch loop.
+// Never bundled into dist (build entry is src/index.ts). Diagnostics to stderr.
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { describeError } from '@v1nvn/agentic-core';
+import { runDevServer } from '@v1nvn/agentic-core/vite';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { logger } from "./logger.js";
+const here = dirname(fileURLToPath(import.meta.url));
+runDevServer({
+    entry: resolve(here, 'server.ts'),
+    log: logger,
+    start: async (mod) => {
+        const server = mod.createMcpServer();
+        mod.loadPresets();
+        let handles = [
+            ...mod.registerTools(server),
+            ...mod.registerResources(server),
+        ];
+        // Capability-gated tools (sampling) defer to the `initialized`
+        // notification: `connect()` returns before the client advertises
+        // capabilities, so a direct call here would observe
+        // `getClientCapabilities() === undefined`. The hook fires once per
+        // connection, after the initialize handshake but before any `tools/list`.
+        let gatedHandles = [];
+        server.server.oninitialized = () => {
+            gatedHandles = mod.registerCapabilityGatedTools(server);
+        };
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        return {
+            closers: [server],
+            reload: next => {
+                for (const handle of [...handles, ...gatedHandles]) {
+                    handle.remove();
+                }
+                handles = [
+                    ...next.registerTools(server),
+                    ...next.registerResources(server),
+                ];
+                // The re-imported module graph starts with an empty preset store;
+                // refill it alongside the re-registrations. The client is already
+                // past `initialized` by the time a file change fires, so the gate
+                // can re-evaluate directly.
+                next.loadPresets();
+                gatedHandles = next.registerCapabilityGatedTools(server);
+            },
+        };
+    },
+}).catch((error) => {
+    logger.error(`dev failed: ${describeError(error)}`);
+    // eslint-disable-next-line n/no-process-exit
+    process.exit(1);
+});

package/src/errors.js

@@ -0,0 +1,16 @@
+import { describeError } from '@v1nvn/agentic-core';
+export class ExtractionError extends Error {
+    cause;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = 'ExtractionError';
+        this.cause = options.cause;
+    }
+}
+export function toErrorResult(err) {
+    const label = err instanceof ExtractionError ? err.name : 'Error';
+    return {
+        isError: true,
+        content: [{ type: 'text', text: `${label}: ${describeError(err)}` }],
+    };
+}

package/src/handler.js

@@ -0,0 +1,4 @@
+import { toolHandler } from '@v1nvn/agentic-core';
+import { toErrorResult } from "./errors.js";
+import { logger } from "./logger.js";
+export const tool = toolHandler(logger, toErrorResult);

package/src/host-sampling.js

@@ -0,0 +1,57 @@
+// The one seam to the HOST's model via MCP `sampling/createMessage`
+// (server→client request). The server never embeds a model and never calls a
+// provider directly — every LLM call is delegated to the connected client,
+// which picks the model and may prompt the user first. Gating on the
+// capability happens at registration (server.ts), not here.
+// Host models — and the human-in-the-loop approval MCP allows before each
+// call — routinely take longer than the SDK's 60s request default.
+const SAMPLING_TIMEOUT_MS = 300_000;
+export async function sampleText(server, args) {
+    const result = await server.server.createMessage({
+        messages: [
+            {
+                role: 'user',
+                content: { type: 'text', text: args.userText },
+            },
+        ],
+        systemPrompt: args.systemPrompt,
+        maxTokens: args.maxTokens,
+    }, { timeout: SAMPLING_TIMEOUT_MS });
+    if (result.content.type !== 'text') {
+        throw new Error(`host sampling returned non-text content (${result.content.type})`);
+    }
+    return result.content.text;
+}
+// createMessage has no structured-output field, so JSON proposals are
+// negotiated in prose: the prompt demands strict JSON, and the reply is
+// tolerated past code fences before the caller's schema takes over.
+export class SuggestParseError extends Error {
+    rawText;
+    constructor(message, rawText) {
+        super(message);
+        this.rawText = rawText;
+    }
+}
+export function extractJsonReply(text) {
+    const withoutFences = text.replace(/^[\s\S]*?```(?:json)?\s*\n?([\s\S]*?)\n?```[\s\S]*$/, '$1');
+    const trimmed = withoutFences.trim();
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        const start = trimmed.indexOf('{');
+        const end = trimmed.lastIndexOf('}');
+        if (start !== -1 && end > start) {
+            try {
+                return JSON.parse(trimmed.slice(start, end + 1));
+            }
+            catch {
+                // Fall through to the error below.
+            }
+        }
+        throw new SuggestParseError(`host sampling returned text that does not parse as JSON (${trimmed.slice(0, 80)}…)`, trimmed);
+    }
+}
+export async function sampleJson(server, args) {
+    return extractJsonReply(await sampleText(server, args));
+}

package/src/index.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { describeError, shutdownOnSignals } from '@v1nvn/agentic-core';
+import { createServer } from "./server.js";
+if (process.argv[2] === 'extract') {
+    void import("./cli.js")
+        .then(m => m.runExtract(process.argv.slice(2)))
+        .then(code => {
+        // eslint-disable-next-line n/no-process-exit
+        process.exit(code);
+    })
+        .catch((err) => {
+        process.stderr.write(`${describeError(err)}\n`);
+        // eslint-disable-next-line n/no-process-exit
+        process.exit(1);
+    });
+}
+else {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    shutdownOnSignals([server]);
+}

package/src/logger.js

@@ -0,0 +1,2 @@
+import { loggerFromEnv } from '@v1nvn/agentic-core';
+export const logger = loggerFromEnv(process.env, 'READABILITY_LOG_LEVEL');

package/src/output/format.js

@@ -0,0 +1,92 @@
+import { stringify as stringifyYaml } from 'yaml';
+import { headingText, parseBlocks } from "../policy/markdown.js";
+// Readability demotes the article <h1> to <h2> inside `content` and mirrors its
+// text into the title; drop the echoed sub-heading so the title prints once.
+function dropEchoedTitle(body, title) {
+    const blocks = parseBlocks(body);
+    if (blocks.length === 0) {
+        return body;
+    }
+    const first = blocks[0];
+    if (first.kind === 'heading' &&
+        headingText(body.slice(first.start, first.end)) === title.trim()) {
+        return body.slice(first.end).replace(/^\n+/, '');
+    }
+    return body;
+}
+function renderMarkdown(input) {
+    const title = input.metadata.title?.trim();
+    let body = input.markdown;
+    if (title) {
+        body = dropEchoedTitle(body, title);
+        return `# ${title}\n\n${body}`.replace(/\n+$/, '\n');
+    }
+    return body.replace(/\n+$/, '\n');
+}
+// Stable key order for deterministic frontmatter. `structured` is deliberately
+// absent: it is a nested object, not a scalar, and would dump a whole JSON-LD
+// graph into frontmatter. It reaches the host via format=json and
+// structuredContent.metadata, which serialize the full metadata object.
+const METADATA_KEYS = [
+    'title',
+    'byline',
+    'siteName',
+    'lang',
+    'publishedTime',
+    'excerpt',
+    'canonical',
+    'baseUrl',
+    'wordCount',
+    'readingTimeMin',
+    'tokenEstimate',
+    'estimator',
+];
+function pickMetadata(metadata) {
+    const picked = {};
+    for (const key of METADATA_KEYS) {
+        const value = metadata[key];
+        if (value !== undefined) {
+            picked[key] = value;
+        }
+    }
+    return picked;
+}
+// lineWidth: 0 disables folding so each field stays on one line.
+function yamlFrontmatter(metadata) {
+    return `---\n${stringifyYaml(pickMetadata(metadata), { lineWidth: 0 })}---\n`;
+}
+function jsonFrontmatter(metadata) {
+    return ('```json\n' + JSON.stringify(pickMetadata(metadata), null, 2) + '\n```\n');
+}
+function withFrontmatter(payload, mode, metadata) {
+    if (mode === 'yaml') {
+        return `${yamlFrontmatter(metadata)}${payload}`;
+    }
+    if (mode === 'json') {
+        return `${jsonFrontmatter(metadata)}\n${payload}`;
+    }
+    return payload;
+}
+export function formatPayload(input) {
+    let payload;
+    switch (input.format) {
+        case 'html':
+            return input.sanitizedHtml;
+        case 'json': {
+            const body = {
+                metadata: input.metadata,
+                content: input.markdown,
+                diagnostics: input.diagnostics,
+            };
+            return JSON.stringify(body, null, 2);
+        }
+        case 'text':
+            payload = input.textContent;
+            break;
+        case 'markdown':
+        default:
+            payload = renderMarkdown(input);
+            break;
+    }
+    return withFrontmatter(payload, input.metadataMode, input.metadata);
+}

package/src/pipeline/cell-text.js

@@ -0,0 +1,51 @@
+// Resolve a table/grid cell element to the string that represents it in the
+// matrix. Shared by tables.ts (the <table> serializer) and
+// policy/grid-detector.ts (the div-grid detector) so both paths project a
+// cell the same way: whitespace-normalized visible text, with two fallbacks.
+//
+// 1. Tooltip/badge/aria wrappers carry chrome, not data — they are stripped
+//    from a clone so a label cell reads "Market Capitalization" rather than
+//    concatenating every descendant. But stripping must never empty a cell: a
+//    badge/aria element that holds a cell's only text is data, not chrome, so
+//    when stripping would blank the cell the full text is kept.
+// 2. A cell whose only content is an icon link has no visible text at all; its
+//    value lives in the anchor's href, which is surfaced as a last resort.
+const CELL_CHROME_SELECTOR = '[aria-label], [data-tooltip], [data-toggle="tooltip"], .tooltip, .badge';
+function normalize(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+// All non-empty hrefs reachable from the cell, including the cell itself when it
+// is an anchor (a div-grid "cell" can be an <a>). Descendant-only search would
+// miss a link-cell whose element IS the anchor.
+function nonEmptyHrefs(cell) {
+    const anchors = cell.tagName === 'A'
+        ? [cell, ...Array.from(cell.querySelectorAll('a[href]'))]
+        : Array.from(cell.querySelectorAll('a[href]'));
+    const hrefs = [];
+    for (const a of anchors) {
+        const href = (a.getAttribute('href') ?? '').trim();
+        if (href !== '') {
+            hrefs.push(href);
+        }
+    }
+    return hrefs;
+}
+export function resolveCellText(cell) {
+    const full = normalize(cell.textContent);
+    let resolved = full;
+    if (full !== '') {
+        const clone = cell.cloneNode(true);
+        clone.querySelectorAll(CELL_CHROME_SELECTOR).forEach(el => {
+            el.remove();
+        });
+        const stripped = normalize(clone.textContent);
+        resolved = stripped !== '' ? stripped : full;
+    }
+    if (resolved === '') {
+        const hrefs = nonEmptyHrefs(cell);
+        if (hrefs.length > 0) {
+            return hrefs.join(' ');
+        }
+    }
+    return resolved;
+}

package/src/pipeline/context.js

@@ -0,0 +1 @@
+export {};

package/src/pipeline/dom.js

@@ -0,0 +1,16 @@
+import { JSDOM } from 'jsdom';
+// Built only from caller-supplied `html`; `baseUrl` is origin context for
+// absolutization, never fetched. Parse and the downstream Readability walk run
+// synchronously on the event loop — no worker isolation or wall-clock timeout
+// guards them. A worker pool was deferred rather than rejected: the synchronous
+// parse can't be interrupted in-process, and `worker_threads` can't load the dev
+// hot-reload loop's in-memory Vite modules. `maxNodes` is the only input-size
+// bound until a holistic worker strategy lands; a standalone `timeout` option
+// would mislead (it can't interrupt the parse), so it ships with the worker.
+export function buildDocument(html, baseUrl) {
+    const dom = new JSDOM(html, { url: baseUrl });
+    return { document: dom.window.document, window: dom.window };
+}
+export function isElement(node) {
+    return node.nodeType === 1;
+}

package/src/pipeline/footnotes.js

@@ -0,0 +1,148 @@
+import { buildDocument } from "./dom.js";
+// jsdom-parsing every turndown call would dominate hot paths; this pre-check
+// gates on a string scan so footnote-less articles pay nothing.
+const FOOTNOTE_SIGNAL_RE = /cite_note|cite_ref|class="footnotes"|class="references"|data-footnote|role="doc-endnote|<sup\b[^>]*>\s*<a\s[^>]*href="#/i;
+// First match wins per group; an `<ol class="footnotes">` is the common case.
+const DEFINITION_CONTAINER_SELECTORS = [
+    'ol.footnotes',
+    'ol[class*="footnotes"]',
+    'ol.references',
+    'ol[class*="references"]',
+    'section[class*="footnote"]',
+    'div[class*="footnote"]',
+    '[role="doc-endnotes"]',
+    '[role="doc-bibliography"]',
+];
+const STANDALONE_DEF_ID_RE = /^(?:fn|cite_note|footnote|note)[:_-]/i;
+// Some sites prepend a back-to-text caret or "Jump to" label to each definition.
+// Stripping only a leading occurrence keeps accidental mid-text carets intact.
+const BACKREF_LEADING_RE = /^(?:↑\s?|↩\s?|\^\s|Jump to\s*)/;
+function cleanDefText(text) {
+    return text.replace(/\s+/g, ' ').trim().replace(BACKREF_LEADING_RE, '');
+}
+function collectDefinitions(document) {
+    const containers = new Set();
+    const defs = new Map();
+    const standaloneIds = new Set();
+    for (const selector of DEFINITION_CONTAINER_SELECTORS) {
+        let matched;
+        try {
+            matched = document.querySelectorAll(selector);
+        }
+        catch {
+            continue;
+        }
+        for (const container of Array.from(matched)) {
+            if (!containers.has(container)) {
+                containers.add(container);
+            }
+            for (const item of Array.from(container.querySelectorAll('li, [role="doc-endnote"]'))) {
+                const id = item.id;
+                if (!id || defs.has(id)) {
+                    continue;
+                }
+                const text = cleanDefText(item.textContent);
+                if (text) {
+                    defs.set(id, text);
+                }
+            }
+        }
+    }
+    // Some sites scatter `<li id="fn1">` outside any container; collect those too.
+    for (const li of Array.from(document.querySelectorAll('li[id]'))) {
+        const id = li.id;
+        if (!id || defs.has(id) || !STANDALONE_DEF_ID_RE.test(id)) {
+            continue;
+        }
+        const text = cleanDefText(li.textContent);
+        if (text) {
+            defs.set(id, text);
+            standaloneIds.add(id);
+        }
+    }
+    return { containers, defs, standaloneIds };
+}
+export function processFootnotes(html) {
+    if (!html || !FOOTNOTE_SIGNAL_RE.test(html)) {
+        return null;
+    }
+    let document;
+    try {
+        document = buildDocument(html).document;
+    }
+    catch {
+        return null;
+    }
+    const { containers, defs, standaloneIds } = collectDefinitions(document);
+    if (defs.size === 0) {
+        return null;
+    }
+    const refHits = [];
+    const defIdToNumber = new Map();
+    for (const sup of Array.from(document.querySelectorAll('sup'))) {
+        if (!sup.isConnected) {
+            continue;
+        }
+        try {
+            const anchor = sup.querySelector('a[href^="#"]');
+            if (!anchor) {
+                continue;
+            }
+            const frag = (anchor.getAttribute('href') ?? '').slice(1);
+            if (!frag || !defs.has(frag)) {
+                continue;
+            }
+            let n = defIdToNumber.get(frag);
+            if (n === undefined) {
+                n = defIdToNumber.size + 1;
+                defIdToNumber.set(frag, n);
+            }
+            refHits.push({ defId: frag, n, sup });
+        }
+        catch {
+            // Defensive: malformed <sup> must not abort the whole pass.
+        }
+    }
+    if (refHits.length === 0) {
+        return null;
+    }
+    for (const { n, sup } of refHits) {
+        sup.replaceWith(document.createTextNode(`[^${n}]`));
+    }
+    // Drop the rendered references list so it doesn't duplicate the appended
+    // `[^N]:` block. Removing containers also takes care of the standalone <li>
+    // elements that lived inside them; only out-of-container standalones need
+    // individual removal here.
+    for (const container of containers) {
+        if (container.isConnected) {
+            container.remove();
+        }
+    }
+    for (const id of standaloneIds) {
+        const el = document.getElementById(id);
+        if (el?.isConnected) {
+            el.remove();
+        }
+    }
+    const numberToDefId = new Map();
+    for (const [id, n] of defIdToNumber) {
+        numberToDefId.set(n, id);
+    }
+    const footnoteDefs = [];
+    for (let n = 1; n <= numberToDefId.size; n++) {
+        const id = numberToDefId.get(n);
+        if (id === undefined) {
+            break;
+        }
+        const text = defs.get(id);
+        if (text !== undefined) {
+            footnoteDefs.push(text);
+        }
+    }
+    // buildDocument wraps both full documents and bare fragments in a <body>;
+    // serializing its innerHTML returns the equivalent of the input region.
+    return {
+        footnoteDefs,
+        html: document.body.innerHTML,
+    };
+}