rapier-html 1.2.45 → 1.2.48

package/BUILD.json

@@ -1,10 +1,10 @@
 {
   "package": "rapier-html",
-  "version": "1.2.45",
+  "version": "1.2.48",
   "path": "dist/rapier.html",
-  "bytes": 5843562,
-  "sha256": "4377466b87c89fcfbd71dd6c8de0f73fc72de2f7e2529c89b0004828ce6855c4",
-  "builtAt": "2026-10-25T17:51:41.653Z",
+  "bytes": 5967960,
+  "sha256": "be629bc50b6a201e8889ce4c2768ee350015e8dfbafe7cfe880a6a6113865595",
+  "builtAt": "2026-10-28T02:28:38.799Z",
   "node": "v22.23.4",
   "canonical": true,
   "packing": "zopfli",
@@ -31,15 +31,15 @@
       "delivery": "built-in",
       "kind": "files",
       "element": "rapier-plugin-mermaid",
-      "bytes": 720263,
-      "packedBytes": 240280,
+      "bytes": 722820,
+      "packedBytes": 241155,
       "files": [
         {
           "id": "rapier-mermaid-core",
-          "name": "pele-1.9.0-native-1.js",
-          "version": "1.9.0-native-1",
-          "bytes": 720263,
-          "sri": "zPE63bYrlp1ZqlwxePk6pclPq6VoxZ7o769Lz109vEo8OEPtvOl1GPrMDj0OhtVB"
+          "name": "pele-1.9.0-native-2.js",
+          "version": "1.9.0-native-2",
+          "bytes": 722820,
+          "sri": "vPm/+HAI9fOqGc1GFl8wFvzMcZjXMhIUXWSdd2qAAVW6fBqjmK6Np6MVprxE8DFK"
         }
       ]
     },
@@ -48,15 +48,15 @@
       "delivery": "built-in",
       "kind": "files",
       "element": "rapier-plugin-mermaid-zenuml",
-      "bytes": 420431,
-      "packedBytes": 110835,
+      "bytes": 421169,
+      "packedBytes": 111122,
       "files": [
         {
           "id": "rapier-mermaid-zenuml",
-          "name": "rapier-zenuml-svg-4.5.0-1.js",
-          "version": "4.5.0-svg-1",
-          "bytes": 420431,
-          "sri": "Dma7QZLWfZx3gWM0ie8JpjR4KwOXqndKcIJywkdxJ2shsdw/gDRFByjGlUv+eNoQ"
+          "name": "rapier-zenuml-svg-4.5.0-2.js",
+          "version": "4.5.0-svg-2",
+          "bytes": 421169,
+          "sri": "g5vdITVAGyvxD4BJdaFJjNZKvlTUXxXlJkqeFyfXREsJVsopr/iH4DC8gPhuEjDK"
         }
       ]
     },

package/README.md

@@ -7,8 +7,8 @@ Turn Markdown into one offline HTML file that contains the full Rapier editor.
   <img src="https://raw.githubusercontent.com/jackskip22/rapier-plugins/main/assets/write-390-light.png" alt="The Rapier editor on a phone: a launch plan with an agent's change marked" width="320">
 </picture>
 
-Try it: `npx rapier-html@1.2.45 notes.md`, then open `notes.rapier.html` in any browser.
-Install: `npm install rapier-html@1.2.45`.
+Try it: `npx rapier-html@1.2.48 notes.md`, then open `notes.rapier.html` in any browser.
+Install: `npm install rapier-html@1.2.48`.
 
 It opens on a phone or computer, with no account. People read, edit, draw and paint; agents hand over documents, show
 what changed and get the edited copy back.
@@ -21,19 +21,20 @@ The file needs no hosted workspace.
 - Where scripts don't run (a mail preview, a strict viewer), the file shows the document's words.
 - `--return` adds a one-use Send back address from the agent door.
 - `--view draw` opens on Draw. `--compare original.md` opens the edit with its diff; `--by <name>` attributes it.
+- `--editor page.html` uses another Rapier page as the editor, such as one the agent door exported.
 - `writePage(text, name)` makes the page in one call; `unwrap` gives the document back, exactly.
 
 Needs Node 22 or newer.
 
 ```sh
-npx -- rapier-html@1.2.45 notes.md                          # the editor, notes.md inside it, written beside the file
-npx -- rapier-html@1.2.45 notes.md --view draw              # opens on Draw: sketch and paint, the document behind it
-npx -- rapier-html@1.2.45 notes.md --include draw,math     # carries Draw and Math (default: what the document needs)
-npx -- rapier-html@1.2.45 notes.md --drawing sketch.svg     # carries a drawing, opened on Draw over the document
-npx -- rapier-html@1.2.45 revised.md --compare original.md # opens showing what changed
-npx -- rapier-html@1.2.45 notes.md --return "$RETURN_URL" --return-expires-at "$RETURN_EXPIRES_AT" # Send back
-npx -- rapier-html@1.2.45 notes.md out.html                 # a named output
-npm install rapier-html@1.2.45                              # as a library: writePage, unwrap
+npx -- rapier-html@1.2.48 notes.md                          # the editor, notes.md inside it, written beside the file
+npx -- rapier-html@1.2.48 notes.md --view draw              # opens on Draw: sketch and paint, the document behind it
+npx -- rapier-html@1.2.48 notes.md --include draw,math     # carries Draw and Math (default: what the document needs)
+npx -- rapier-html@1.2.48 notes.md --drawing sketch.svg     # carries a drawing, opened on Draw over the document
+npx -- rapier-html@1.2.48 revised.md --compare original.md # opens showing what changed
+npx -- rapier-html@1.2.48 notes.md --return <return_url> --return-expires-at <return_expires_at> # Send back
+npx -- rapier-html@1.2.48 notes.md out.html                 # a named output
+npm install rapier-html@1.2.48                              # as a library: writePage, unwrap
 ```
 
 The first `--` is for npm, so `--help` reaches the command. It never overwrites a file.
@@ -52,7 +53,7 @@ Will markers in the Markdown (`keep`, `append`, `edit`) control what agents may
 ## Send an edited document back
 
 1. Call `show {target:"return"}` on the Rapier agent door for the document's workspace.
-2. Pass its `return_url` and `return_expires_at` as `--return "$RETURN_URL" --return-expires-at "$RETURN_EXPIRES_AT"`,
+2. Pass its `return_url` and `return_expires_at` as `--return <return_url> --return-expires-at <return_expires_at>`,
    or `wrap(..., {return: return_url, return_expires_at})`. Only `https://mcp.rapier.website/return/…` is accepted.
    Share then shows Send back; a page without an address doesn't.
 3. The person edits offline and taps Send back. The source and filename go once; the page shows acceptance or
@@ -117,7 +118,7 @@ objects, and `unwrap(page)` returns the checked parts beside the text. Both are
   history.
 - Markdown saved with the kit's `ledger/carried.writeDocument` is read automatically when wrapping. Rewrapping a page
   without parts drops the old parts.
-- The published package carries its own MIT validator; no source checkout is needed.
+- The published package carries the portable MIT validator and canonical Markdown parser support, with the parser vendors' original MIT, ISC and BSD-2-Clause notices. Accepted comment history reopens without a source checkout or a parser supplied by the caller.
 
 ## License
 

package/dist/ledger/LICENSE

@@ -21,14 +21,18 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
 Files under this license carry `SPDX-License-Identifier: MIT` in their first lines: the standard's
-grammar, marks and reference style (`spec/md-layout.mjs`, `spec/md-marks.mjs`, `spec/md-source.mjs`, `spec/flowchart.mjs`, `spec/markdown-style.css`), ink geometry
-(`spec/ink.mjs`),
+grammar, marks and reference style (`spec/md-layout.mjs`, `spec/md-marks.mjs`, `spec/md-source.mjs`, `spec/flowchart.mjs`, `spec/markdown-style.css`),
+the reusable diagram source, layout and raising helpers (`draw/flowchart-mermaid.mjs`, `draw/flowchart-layout.mjs`,
+`draw/flowchart-raise.mjs`) and diagram-core export facade (`shell/mermaid/api.mjs`),
+ink geometry (`spec/ink.mjs`),
 the layout model and line planner (`layout/model.mjs`, `layout/line-plan.mjs`, `layout/typography.mjs`, `layout/preparation.mjs`,
 `layout/prepared-paragraph.mjs`, `layout/hyphenation.mjs`, `layout/paragraph-fit.mjs`), the animated-picture reader and playback
 the HTML blocks use (`images/gif.mjs`, `images/playback.mjs`),
 the portable HTML and document metadata helpers (`spec/html-blocks.mjs`, `spec/frontmatter.mjs`,
 `spec/document-settings.mjs`, `spec/document-fonts.mjs`), the Will grammar (`agent/will.mjs`), the picture appendix reader and writer
-(`spec/md-assets.mjs`), the two shared-page reference readers (`tools/read-shared-page.mjs`,
+(`spec/md-assets.mjs`), the portable comment and canonical parser support owners
+(`spec/md-comments.mjs`, `spec/md-parser-config.mjs`, `spec/md-parser-runtime.mjs`),
+the neutral math boundary and parser adapters (`math/delimiters.mjs`, `math/markdown-rules.mjs`), the two shared-page reference readers (`tools/read-shared-page.mjs`,
 `tools/read-shared-page.py`), and the host helper `packages/rapier-embed/embed.mjs` with its
 contract owner `packages/rapier-embed/contract.mjs`. The vendored Pretext (`agent/vendor/pretext`) and micromark carry their
 own MIT notices. The edit-ledger module (`kit/rapier-ledger.mjs`, `kit/ledger/*.mjs`) and
@@ -39,11 +43,14 @@ AGPL-3.0-only. The page wrapper (`skills/rapier-html/wrap.mjs`, `skills/rapier-h
 `skills/rapier-html/return-address.mjs`) and its carrier-staging helper
 (`skills/rapier-html/package-files.mjs`) are MIT. The kit's MIT-marked facades,
 `kit/render-entry.mjs`, `kit/render*.mjs`, `kit/export-fonts.mjs`, `kit/print-capitals.mjs`,
-`kit/pdf-vectors.mjs`, `kit/pdf-glyphs.mjs`, `kit/stage.mjs` and MIT-marked conformance
+`kit/pdf-vectors.mjs`, `kit/pdf-glyphs.mjs`, `kit/stage.mjs`, `kit/markdown-vendor.mjs` and MIT-marked conformance
 modules are covered too. These names describe the Rapier-owned files carrying the
 MIT notice, not a grant over the editor or third-party code. Other Rapier-owned
 files retain their stated license; the editor is AGPL-3.0-only (see `LICENSE`).
-Third-party components retain their own copyright and license notices.
+Third-party components retain their own copyright and license notices. The published Markdown parser,
+its plugins and their dependencies retain their original MIT, ISC and BSD-2-Clause notices in `agent/vendor/NOTICE.txt` and
+`agent/vendor/markdown-licenses/`; this inventory does not replace them. The Feather callout paths
+in the canonical configuration retain the Feather copyright and MIT notice there.
 
 The portable font helpers read document definitions and accept explicit host validation and
 subsetting functions. The application binding (`editor/export-fonts.mjs`), captured-font

package/dist/ledger/authored-origin.mjs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
-import {_rapierTransformSplices, _rapierValidAuthored} from './journal-records.mjs';
-import {sha256} from './hash.mjs';
+import {_rapierTransformSplices, _rapierValidAuthored} from "./journal-records.mjs";
+import {sha256} from "./hash.mjs";
 
 function authoredFrontier(records, visit = null) {
   const dependencies = new Map(), frontier = new Set();

package/dist/ledger/authorship.mjs

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: MIT
-import {readLedger, exportLedger, textRoot, rootAfter} from './format.mjs';
-import {_rapierTransformSplices, _rapierHistoryEffects} from './journal-records.mjs';
-import {projectInverseSource} from './inverse-source.mjs';
-import {sha256} from './hash.mjs';
-import {plainData, documentText, nonnegative, exactKeys, fault} from './data.mjs';
+import {readLedger, exportLedger, textRoot, rootAfter} from "./format.mjs";
+import {_rapierTransformSplices, _rapierHistoryEffects} from "./journal-records.mjs";
+import {projectInverseSource} from "./inverse-source.mjs";
+import {sha256} from "./hash.mjs";
+import {plainData, documentText, nonnegative, exactKeys, fault} from "./data.mjs";
 function coalesce(runs) {
   const out = [];
   for (const run of runs) {

package/dist/ledger/carried.mjs

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MIT
-import {readLedger} from './format.mjs';
-import {sha256} from './hash.mjs';
-import {authorship as projectAuthorship, readAuthorship} from './authorship.mjs';
-import {canonicalJSON, fault} from './data.mjs';
+import {readLedger} from "./format.mjs";
+import {sha256} from "./hash.mjs";
+import {authorship as projectAuthorship, readAuthorship} from "./authorship.mjs";
+import {canonicalJSON, fault} from "./data.mjs";
 export function encodeCarried(text) {
   return String(text).replace(/[\\\r\0]|<[/!]/g, m => m === '\\' ? '\\\\' : m === '\r' ? '\\r' : m === '\0' ? '\\0' : m === '</' ? '\\/' : '\\!');
 }
@@ -56,11 +56,19 @@ export function documentTrailer(text, options) {
 export function writeDocument(text, options) {
   return text + documentTrailer(text, options);
 }
+function trailerOpening(source) {
+  const marker = '<!-- rapier-carried/1', at = source.lastIndexOf(marker);
+  if (at < 0) return null;
+  if (source.slice(at - 2, at + marker.length + 1) === OPEN) return {start: at - 2, body: at + marker.length + 1};
+  const before = /(?:\r\n|\r|\n){2}$/.exec(source.slice(Math.max(0, at - 4), at));
+  const after = /^(?:\r\n|\r|\n)/.exec(source.slice(at + marker.length, at + marker.length + 2));
+  return before && after ? {start: at - before[0].length, body: at + marker.length + after[0].length} : null;
+}
 function unfinishedTrailer(source) {
-  const at = source.lastIndexOf(OPEN);
-  if (at < 0) return false;
+  const opening = trailerOpening(source);
+  if (!opening) return false;
   let fence = null;
-  for (const line of source.slice(0, at).split('\n')) {
+  for (const line of source.slice(0, opening.start).split(/\r\n?|\n/)) {
     const found = /^ {0,3}(`{3,}|~{3,})/.exec(line);
     if (!found) continue;
     if (!fence) fence = found[1];
@@ -69,17 +77,18 @@ function unfinishedTrailer(source) {
   return !fence;
 }
 export function readDocument(source) {
-  if (!source.endsWith(CLOSE)) {
+  const closing = /(?:\r\n|\r|\n)-->(?:\r\n|\r|\n)$/.exec(source.slice(-7));
+  if (!closing) {
     if (unfinishedTrailer(source)) throw fault('unfinished document metadata');
     return {text: source, ledger: null, authorship: null};
   }
-  const at = source.lastIndexOf(OPEN);
-  if (at < 0) return {text: source, ledger: null, authorship: null};
+  const opening = trailerOpening(source);
+  if (!opening) return {text: source, ledger: null, authorship: null};
   let parts;
-  try { parts = JSON.parse(source.slice(at + OPEN.length, -CLOSE.length)); }
+  try { parts = JSON.parse(source.slice(opening.body, -closing[0].length)); }
   catch (_) { throw fault('invalid document metadata'); }
   if (!parts || Object.keys(parts).length !== 2 || !Object.hasOwn(parts, 'ledger') || !Object.hasOwn(parts, 'authorship')) throw fault('invalid document parts');
-  const text = source.slice(0, at);
+  const text = source.slice(0, opening.start);
   return {text, ...validateParts(text, parts)};
 }
 

package/dist/ledger/diff/concerns.mjs

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: MIT
-import {letter, within, prev, next} from './tokens.mjs';
+import {letter, within, prev, next} from "./tokens.mjs";
 
 export function separate(c, endA = c.before.length, endB = c.after.length) {
   const {before, after, safe, raw, spend} = c;
   if (!raw) for (let i = c.result.length - 1; i > 0; i--) {
     const p = c.result[i - 1], q = c.result[i], side = p[0][0] === p[0][1] ? 1 : p[1][0] === p[1][1] ? 0 : -1, text = side ? after : before;
-    if (side >= 0 && !/\S/.test(text.slice(...p[side]))) {
+    if (!c.evidence && side >= 0 && !/\S/.test(text.slice(...p[side]))) {
       let n = 0;
       while (p[0][1] + n < q[0][0] && text[p[side][0] + n] === text[p[side][1] + n] && spend()) n++;
       if (p[0][1] + n === q[0][0] && p.slice(0, 2).every((span, k) => safe(k ? after : before, span[0] + n) && safe(k ? after : before, span[1] + n)))
@@ -20,7 +20,7 @@ export function separate(c, endA = c.before.length, endB = c.after.length) {
     keep[3][0] = x[0] === x[1] ? 2 : y[0] === y[1] ? 0 : 1;
     c.result.splice(i - 1, 2, [x, y, false, keep[3]]);
   }
-  if (!raw) for (let i = 0; i < c.result.length; i++) {
+  if (!raw && !c.evidence) for (let i = 0; i < c.result.length; i++) {
     const p = c.result[i], q = c.result[i + 1], side = p[0][0] === p[0][1] ? 1 : p[1][0] === p[1][1] ? 0 : -1;
     if (side < 0 || p[2]) continue;
     const text = side ? after : before;

package/dist/ledger/diff/diff.mjs

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: MIT
-import {observe} from './structure.mjs';
-import {boundaries, tokenizer, wordSegmenter} from './tokens.mjs';
-import {matcher} from './matching.mjs';
-import {walker} from './walk.mjs';
-import {moves} from './moves.mjs';
-import {separate, concerns} from './concerns.mjs';
+import {observe} from "./structure.mjs";
+import {boundaries, tokenizer, wordSegmenter} from "./tokens.mjs";
+import {matcher} from "./matching.mjs";
+import {walker} from "./walk.mjs";
+import {moves} from "./moves.mjs";
+import {separate, concerns} from "./concerns.mjs";
 
 export function diff(before, after, options = {}) {
   if (before === after) return {edits: [], changes: []};

package/dist/ledger/diff/index.mjs

@@ -1,4 +1,4 @@
 // SPDX-License-Identifier: MIT
-import {diff} from './diff.mjs';
-import {merge} from './merge.mjs';
+import {diff} from "./diff.mjs";
+import {merge} from "./merge.mjs";
 export {diff, merge};

package/dist/ledger/diff/merge.mjs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
-import {diff} from './diff.mjs';
-import {observe} from './structure.mjs';
-import {boundaries, words, wordSegmenter} from './tokens.mjs';
+import {diff} from "./diff.mjs";
+import {observe} from "./structure.mjs";
+import {boundaries, words, wordSegmenter} from "./tokens.mjs";
 
 export function merge(base, mine, theirs, options = {}) {
   if (mine === theirs || base === theirs || base === mine) return {text: base === mine ? theirs : mine, conflicts: []};

package/dist/ledger/diff/moves.mjs

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-import {separate, phrases} from './concerns.mjs';
+import {separate, phrases} from "./concerns.mjs";
 
 export function moves(c) {
   const {before, after, spend, safe, budget, raw, code, tokens, matches, walk, structures, pa, pb, la, aliases} = c;

package/dist/ledger/diff/walk.mjs

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-import {words, letter, within, prev, next} from './tokens.mjs';
+import {words, letter, within, prev, next} from "./tokens.mjs";
 
 export function walker(c) {
   const {before, after, spend, safe, budget, raw, chars, code, segmenter, tokens, matches} = c;

package/dist/ledger/document-fonts.mjs

@@ -0,0 +1,296 @@
+// SPDX-License-Identifier: MIT
+import {markdownParser, installMarkdownImages, normalizeLabel} from "./md-assets.mjs";
+import {splitOpeningFrontmatter} from "./frontmatter.mjs";
+import {readDocumentSettings, documentFont} from "./document-settings.mjs";
+import {normalizeFontFamily, fontFamilyCss, FONT_STACKS, typography, fontDataUrl} from "./md-marks.mjs";
+export {fontDataUrl};
+
+export const CSS_GENERIC_FONT_FAMILIES = Object.freeze(['serif', 'sans-serif', 'monospace', 'cursive', 'fantasy', 'system-ui',
+  'ui-serif', 'ui-sans-serif', 'ui-monospace', 'ui-rounded', 'emoji', 'math', 'fangsong', 'initial', 'revert', 'revert-layer']);
+
+function parserFor(parser) {
+	const md = installMarkdownImages(markdownParser(parser));
+	if (!md.__rapierFontsInstalled) {
+		const validate = md.validateLink;
+		md.validateLink = url => !!fontDataUrl(url) || validate(url);
+		md.__rapierFontsInstalled = true;
+	}
+	return md;
+}
+
+const sourceMetadataFields = ['license', 'origin'];
+function sourceMetadata(value) {
+	return Object.fromEntries(sourceMetadataFields.filter(field => value[field] != null).map(field => [field, value[field]]));
+}
+
+function faceOf(value) {
+	const family = normalizeFontFamily(value?.family), style = value?.style || 'normal';
+	const weight = value?.weight ?? 400, stretch = value?.stretch ?? 100;
+	if (!family || !['normal', 'italic', 'oblique'].includes(style) || !Number.isFinite(weight) || weight < 1 || weight > 1000 ||
+		!Number.isFinite(stretch) || stretch <= 0 || stretch > 1000) return null;
+	const result = {family, style, weight, stretch};
+	if (value.subsetted != null && typeof value.subsetted !== 'boolean') return null;
+	if (value.subsetted === true || value.subset?.subset === true) result.subsetted = true;
+	if (value.weightRange != null) {
+		const range = value.weightRange;
+		if (!Array.isArray(range) || range.length !== 2 || range.some(number => !Number.isFinite(number) || number < 1 || number > 1000) || range[0] > range[1]) return null;
+		result.weightRange = range.slice();
+	}
+	if (value.axes != null) {
+		if (!Array.isArray(value.axes) || value.axes.length > 64) return null;
+		const seen = new Set(), axes = [];
+		for (const axis of value.axes) {
+			if (!axis || !/^[ -~]{4}$/.test(axis.tag) || seen.has(axis.tag) ||
+				![axis.min, axis.default, axis.max].every(Number.isFinite) || axis.min > axis.default || axis.default > axis.max) return null;
+			seen.add(axis.tag);
+			axes.push({tag: axis.tag, min: axis.min, default: axis.default, max: axis.max, ...(typeof axis.name === 'string' ? {name: axis.name} : {})});
+		}
+		if (axes.length) result.axes = axes;
+	}
+	if (value.sourceId != null) {
+		if (!/^f[0-9a-f]{24}$/.test(value.sourceId)) return null;
+		result.sourceId = value.sourceId;
+	}
+	if (value.license != null) {
+		const license = value.license;
+		if (!license || !['OFL-1.0', 'OFL-1.1', 'Apache-2.0', 'Ubuntu-font-1.0'].includes(license.id) ||
+			typeof license.text !== 'string' || !license.text.trim() || new TextEncoder().encode(license.text).length > 128 * 1024 ||
+			typeof license.url !== 'string' || typeof license.sri !== 'string' || !/^sha384-[A-Za-z0-9+/]{64}$/.test(license.sri)) return null;
+		let url;
+		try { url = new URL(license.url); } catch (_) { return null; }
+		if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash) return null;
+		result.license = {id: license.id, text: license.text, url: license.url, sri: license.sri};
+	}
+	if (value.origin != null) {
+		const origin = value.origin;
+		if (!result.license || result.subsetted || !origin || origin.catalog !== 'google-fonts' ||
+			typeof origin.family !== 'string' || !/^[a-z0-9][a-z0-9-]{0,95}$/.test(origin.family) ||
+			typeof origin.version !== 'string' || !origin.version || origin.version.length > 128 || /[\u0000-\u001f\u007f]/u.test(origin.version) ||
+			typeof origin.file !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}\.woff2$/.test(origin.file) ||
+			typeof origin.sri !== 'string' || !/^sha384-[A-Za-z0-9+/]{64}$/.test(origin.sri)) return null;
+		result.origin = {catalog: origin.catalog, family: origin.family, version: origin.version, file: origin.file, sri: origin.sri};
+	}
+	return result;
+}
+
+export function fontAssetKey(font) {
+	const face = faceOf(font);
+	if (!face) return '';
+	return [face.family.toLowerCase(), face.style, face.weight, face.stretch,
+		(face.axes || []).map(axis => [axis.tag, axis.min, axis.max].join(':')).sort().join(',')].join('/');
+}
+
+export function readFontAssets(markdown, parser) {
+	const source = String(markdown ?? ''), assets = [], blocks = [], refused = [];
+	if (!/\[font:/i.test(source)) return {assets, blocks, refused, references: Object.create(null)};
+	const md = parserFor(parser), frame = splitOpeningFrontmatter(source), env = {}, tokens = [], starts = [frame.bodyOffset];
+	for (let at = frame.bodyOffset; at < source.length; at++) {
+		if (source[at] === '\r') { if (source[at + 1] === '\n') at++; starts.push(at + 1); }
+		else if (source[at] === '\n') starts.push(at + 1);
+	}
+	md.block.parse(frame.body.replace(/\r\n?/g, '\n').replace(/\0/g, '\ufffd'), md, env, tokens);
+	const labels = new Set(), faces = new Set(), metadata = new Map(), faceMetadata = new Map(), subsetUrls = new Set();
+	for (const token of tokens) {
+		if (token.type !== 'reference_definition' || !token.map) continue;
+		const id = token.meta.label, first = !labels.has(id);
+		labels.add(id);
+		const definition = token.meta.mdImageDefinition || env.references?.[id];
+		const url = definition?.href, data = fontDataUrl(url);
+		if (!/^FONT:/i.test(id)) continue;
+		const start = starts[token.map[0]], next = starts[token.map[1]] ?? source.length;
+		let end = next;
+		if (source[end - 1] === '\n') end--;
+		if (source[end - 1] === '\r') end--;
+		const raw = source.slice(start, end), match = /^[ \t]{0,3}\[((?:\\.|[^\]\\\r\n])+)\]:/.exec(raw);
+		if (!match) continue;
+		const label = md.utils.unescapeAll(match[1]);
+		if (!data) { refused.push({name: label, reason: 'The font reference must contain an embedded font.'}); continue; }
+		let definitionMetadata = {family: label.slice(5)};
+		if (definition.title) {
+			try { definitionMetadata = JSON.parse(definition.title); }
+			catch (_) { refused.push({name: label, reason: 'The font reference has invalid metadata.'}); continue; }
+		}
+		const face = faceOf(definitionMetadata);
+		if (!face) { refused.push({name: label, reason: 'The font reference has invalid metadata.'}); continue; }
+		const key = fontAssetKey(face), active = first && !faces.has(key);
+		const conflict = sourceMetadataFields.find(field => face[field] && [metadata.get(url)?.[field], faceMetadata.get(key)?.[field]]
+			.some(prior => prior && JSON.stringify(prior) !== JSON.stringify(face[field])));
+		if (conflict) { refused.push({name: label, reason: 'The font references have conflicting ' + conflict + ' metadata.'}); continue; }
+		if (face.subsetted && metadata.get(url)?.origin || face.origin && subsetUrls.has(url)) {
+			refused.push({name: label, reason: 'A font subset cannot claim an original catalog file.'}); continue;
+		}
+		metadata.set(url, {...metadata.get(url), ...sourceMetadata(face)});
+		faceMetadata.set(key, {...faceMetadata.get(key), ...sourceMetadata(face)});
+		if (face.subsetted) subsetUrls.add(url);
+		const row = {...face, ...data, url, label, id, key, source: raw, start, end, next, active, topLevel: token.level === 0};
+		blocks.push(row);
+		if (active) { assets.push(row); faces.add(key); }
+	}
+	for (let index = 0; index < assets.length; index++) {
+		const asset = assets[index], declared = metadata.get(asset.url);
+		for (const field of sourceMetadataFields) if (!asset[field] && declared?.[field])
+			assets[index] = {...assets[index], [field]: declared[field]};
+		if (subsetUrls.has(asset.url) && !asset.subsetted) assets[index] = {...assets[index], subsetted: true};
+	}
+	return {assets, blocks, refused, references: env.references || Object.create(null)};
+}
+
+function fontLabel(face) {
+	const variants = face.style !== 'normal' || face.weight !== 400 || face.stretch !== 100 || face.axes?.length;
+	return 'font:' + face.family + (variants ? '/' + face.style + '/' + face.weight + (face.stretch !== 100 ? '/' + face.stretch : '')
+		+ (face.axes?.length ? '/' + face.axes.map(axis => axis.tag + '=' + axis.min + ':' + axis.max).join(',') : '') : '');
+}
+
+export function serializeFontAsset(asset, label = null) {
+	const face = faceOf(asset), data = fontDataUrl(asset?.url);
+	if (!face || !data) throw new TypeError('font: use an embedded font with valid family metadata');
+	const escaped = escapeFontLabel(label || fontLabel(face));
+	const title = JSON.stringify(face).replace(/&/g, '&amp;').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+	return '[' + escaped + ']: ' + asset.url + ' "' + title + '"';
+}
+
+function escapeFontLabel(label) {
+	return String(label).replace(/[\\[\]]/g, '\\$&').replace(/&/g, '&amp;');
+}
+
+export function writeFontAssets(markdown, assets, parser) {
+	const source = String(markdown ?? ''), md = parserFor(parser), index = readFontAssets(source, md), wanted = new Map(), metadata = new Map(), subsetUrls = new Set();
+	for (const asset of assets || []) {
+		const key = fontAssetKey(asset), face = faceOf(asset);
+		if (!key || !fontDataUrl(asset?.url)) throw new TypeError('font: invalid embedded asset');
+		if (wanted.has(key) && wanted.get(key).url !== asset.url) throw new TypeError('font: one file owns each family face');
+		const conflict = sourceMetadataFields.find(field => face[field] && metadata.get(asset.url)?.[field] &&
+			JSON.stringify(metadata.get(asset.url)[field]) !== JSON.stringify(face[field]));
+		if (conflict) throw new TypeError('font: conflicting ' + conflict + ' metadata');
+		if (face.subsetted && metadata.get(asset.url)?.origin || face.origin && subsetUrls.has(asset.url))
+			throw new TypeError('font: a subset cannot claim an original catalog file');
+		metadata.set(asset.url, {...metadata.get(asset.url), ...sourceMetadata(face)});
+		if (face.subsetted) subsetUrls.add(asset.url);
+		wanted.set(key, asset);
+	}
+	for (const [key, asset] of wanted) {
+		const declared = metadata.get(asset.url);
+		for (const field of sourceMetadataFields) if (!asset[field] && declared?.[field])
+			wanted.set(key, {...wanted.get(key), [field]: declared[field]});
+		if (subsetUrls.has(asset.url) && !asset.subsetted) wanted.set(key, {...wanted.get(key), subsetted: true});
+	}
+	const edits = [], consumed = new Set(), labels = new Set(Object.keys(index.references));
+	const retired = index.assets.filter(row => !wanted.has(row.key));
+	for (const row of index.blocks) {
+		if (!row.active) {
+			if (retired.some(active => active.key === row.key || active.id === row.id)) edits.push({start: row.start, end: row.next, text: ''});
+			continue;
+		}
+		const asset = wanted.get(row.key);
+		if (!asset) { edits.push({start: row.start, end: row.next, text: ''}); continue; }
+		consumed.add(row.key);
+		if (asset.url === row.url && JSON.stringify(faceOf(asset)) === JSON.stringify(faceOf(row))) continue;
+		edits.push({start: row.start, end: row.end, text: serializeFontAsset(asset, row.label)});
+	}
+	let result = source;
+	for (const edit of edits.sort((a, b) => b.start - a.start)) result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+	const pending = [];
+	for (const [key, asset] of wanted) {
+		if (consumed.has(key)) continue;
+		const base = fontLabel(faceOf(asset));
+		let label = base, suffix = 2;
+		while (labels.has(normalizeLabel(escapeFontLabel(label)))) label = base + '/' + suffix++;
+		labels.add(normalizeLabel(escapeFontLabel(label)));
+		pending.push(serializeFontAsset(asset, label));
+	}
+	if (pending.length) {
+		const eol = /\r\n|\r|\n/.exec(source)?.[0] || '\n';
+		result += (result ? (/(?:\r\n|\r(?!\n)|\n)[ \t]*(?:\r\n|\r(?!\n)|\n)$/.test(result) ? '' : /[\r\n]$/.test(result) ? eol : eol + eol) : '') + pending.join(eol) + eol;
+		const written = readFontAssets(result, md).assets;
+		for (const [key, asset] of wanted) if (!written.some(row => row.key === key && row.url === asset.url)) throw new Error('font: close the code or HTML block before embedding a font');
+	}
+	return result;
+}
+
+export function documentFontsCss(assets) {
+	const rules = [];
+	for (const asset of assets || []) {
+		const face = faceOf(asset);
+		if (!face || !fontDataUrl(asset?.url)) continue;
+		const weight = face.axes?.find(axis => axis.tag === 'wght');
+		const width = face.axes?.find(axis => axis.tag === 'wdth');
+		const range = weight ? [weight.min, weight.max] : face.weightRange || [face.weight, face.weight];
+		const weightCss = range[0] === range[1] ? String(range[0]) : range.join(' ');
+		const stretchCss = width ? width.min + '% ' + width.max + '%' : face.stretch + '%';
+		rules.push('@font-face{font-family:' + fontFamilyCss(face.family) + ';font-style:' + face.style + ';font-weight:' + weightCss +
+			';font-stretch:' + stretchCss + ';src:url("' + asset.url + '");font-display:swap}');
+	}
+	return rules.join('');
+}
+
+function htmlFontFamilies(html, md) {
+	const families = new Set();
+	const decode = value => md.utils.unescapeAll(value.replace(/\\/g, '\\\\'));
+	for (const tag of html.matchAll(/<[A-Za-z][A-Za-z0-9:-]*(?:"[^"]*"|'[^']*'|[^'">])*>/g)) {
+		for (const attr of tag[0].matchAll(/\s(data-md-font|style)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/gi)) {
+			const value = decode(attr[2] ?? attr[3] ?? attr[4]), names = [];
+			if (/^<span(?=[\s>])/i.test(tag[0])) {
+				const family = attr[1].toLowerCase() === 'style' ? typography.parseStyle(value).family : null;
+				if (family?.custom) families.add(family.name);
+				continue;
+			}
+			if (attr[1].toLowerCase() === 'data-md-font') names.push(value);
+			else for (const declared of value.matchAll(/(?:^|;)\s*font-family\s*:\s*((?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^;])*)/gi)) {
+				const match = /^\s*(?:"((?:\\.|[^"])*)"|'((?:\\.|[^'])*)'|([^,!]+))/.exec(declared[1]);
+				if (!match) continue;
+				const name = (match[1] ?? match[2] ?? match[3]).replace(/\\(?:([0-9a-f]{1,6})\s?|([^\r\n\f]))/gi, (_whole, hex, escaped) => {
+					const code = hex ? parseInt(hex, 16) : 0;
+					return hex ? code > 0 && code <= 0x10ffff ? String.fromCodePoint(code) : '\ufffd' : escaped;
+				});
+				if (match[3] != null && CSS_GENERIC_FONT_FAMILIES.includes(name.trim().toLowerCase())) continue;
+				names.push(name);
+			}
+			for (const name of names) { const family = normalizeFontFamily(name); if (family) families.add(family); }
+		}
+	}
+	return families;
+}
+
+export function documentFontUsage(markdown, parser, defaultFont) {
+	const source = String(markdown ?? ''), md = parserFor(parser), settings = readDocumentSettings(source), use = new Map();
+	const family = setting => setting?.stack === 'named' ? setting.family : null;
+	const inherited = defaultFont === undefined ? settings.defaultfont : documentFont(defaultFont);
+	const main = family(settings.mainfont || inherited || settings.sansfont), sans = family(settings.sansfont || settings.mainfont || inherited), mono = family(settings.monofont);
+	const add = (name, text) => { if (name && !Object.hasOwn(FONT_STACKS, name.toLowerCase()) && text) use.set(name, (use.get(name) || '') + text + '\n'); };
+	if (!main && !sans && !mono && !source.includes('<')) return use;
+	const plain = html => md.utils.unescapeAll(String(html).replace(/<!--[^]*?-->/g, '').replace(/<(script|style)\b[^>]*>[^]*?<\/\1\s*>/gi, '').replace(/<[^>]*>/g, '').replace(/\\/g, '\\\\'));
+	let blockFamily = main;
+	for (const token of md.parse(splitOpeningFrontmatter(source).body, {})) {
+		if (token.type === 'heading_open') blockFamily = sans;
+		else if (token.type === 'heading_close' || token.type === 'paragraph_open') blockFamily = main;
+		else if (token.type === 'fence' && /^html(?:\s+\{[^{}]*\})?\s*$/i.test(token.info)) {
+			const text = plain(token.content);
+			add(blockFamily, text);
+			for (const name of htmlFontFamilies(token.content, md)) add(name, text);
+		}
+		else if (token.type === 'fence' || token.type === 'code_block') add(mono, token.content);
+		else if (token.type === 'html_block') {
+			const text = plain(token.content);
+			add(blockFamily, text);
+			for (const name of htmlFontFamilies(token.content, md)) add(name, text);
+		}
+		else if (token.type === 'inline') {
+			const stack = [blockFamily];
+			let html = '', text = '';
+			for (const child of token.children || []) {
+				if (child.type === 'html_inline') html += child.content;
+				if (['text', 'text_special', 'emoji', 'image', 'code_inline'].includes(child.type)) text += child.content;
+				const typed = child.meta?.typography;
+				if (typed && child.nesting === 1) {
+					stack.push(typed.style.family ? typed.style.family.custom ? typed.style.family.name : null : stack.at(-1)); continue;
+				}
+				if (typed && child.nesting === -1) { if (stack.length > 1) stack.pop(); continue; }
+				if (child.type === 'code_inline') add(mono, child.content);
+				else if (['text', 'text_special', 'emoji', 'image'].includes(child.type)) add(stack.at(-1), child.content);
+			}
+			for (const name of htmlFontFamilies(html, md)) add(name, text);
+		}
+	}
+	add(main, settings.title); add(main, settings.subtitle);
+	return use;
+}

package/dist/ledger/document-settings.mjs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
-import {frontMatterFrame, frontMatterLine} from './frontmatter.mjs';
-import {normalizeFontFamily, fontFamilyCss, FONT_STACKS} from './md-marks.mjs';
+import {frontMatterFrame, frontMatterLine} from "./frontmatter.mjs";
+import {normalizeFontFamily, fontFamilyCss, FONT_STACKS} from "./md-marks.mjs";
 
 const NUMBER = /^(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
 export const DOCUMENT_LEADING = 1.75 / 1.1;