@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/plugins/footnotes/FootnoteDefinition.svelte

@@ -1,7 +1,8 @@
 <script lang="ts">
-	// The marker rides the first child as an ambient prefix (the listItem `- ` model), so the
-	// body edits like ordinary prose while the marker stays read-only chrome. Its `[^label]`
-	// range is the way back, on the same click the reference took to get here.
+	// The `[^label]: ` marker is drawn in front of the first child instead of being part of its
+	// text, the way a list item's `- ` is, so the body edits like ordinary prose and the marker
+	// stays read-only. Clicking the marker, or Enter on it in reading mode, jumps back to the first
+	// reference.
 	import {
 		BlockList,
 		createContainerBlock,
@@ -12,6 +13,7 @@
 		type NodeView
 	} from '../../plugin';
 	import type { FootnoteDefMetadata } from './footnote-definition';
+	import { backToReferenceLabel } from './constants';
 	import { collectFootnoteReferences } from './footnote-numbering';
 
 	let {
@@ -31,10 +33,10 @@
 	let boxEl: HTMLElement | undefined = $state();
 
 	const label = $derived(getPluginMetadata<FootnoteDefMetadata>(node)?.label ?? '');
-	// The clickable half: the colon and its space are syntax nobody aims at.
+	// Only `[^label]` is clickable; the colon and space after it are syntax nobody aims at.
 	const marker = $derived(`[^${label}]`);
 
-	const { blockListProps, containerApi, getPresentationMode } = createContainerBlock({
+	const { blockListProps, containerApi, getPresentationMode, getEditor } = createContainerBlock({
 		getNode: () => node,
 		getIndex: () => index,
 		getPath: () => myPath,
@@ -46,28 +48,39 @@
 					start: 0,
 					end: marker.length,
 					className: 'footnote-def-marker',
-					onClick: jumpToFirstReference
+					role: 'link',
+					label: backToReferenceLabel(label),
+					// A tab stop only where the block holds no caret for it to interrupt.
+					focusable: getPresentationMode() === 'reading',
+					onClick: onMarkerClick,
+					onActivate: jumpToFirstReference
 				}
 			]
 		})
 	});
 
-	// Resolved on the gesture, never derived: the span's listener is bound once at build time,
-	// so a captured path would be the walk's answer from whenever that was.
-	function jumpToFirstReference(e: MouseEvent): void {
+	function onMarkerClick(e: MouseEvent): void {
 		if (!isWidgetActivationClick(e.ctrlKey || e.metaKey, getPresentationMode())) return;
-		// Skips the leaf's caret clamp and the editor's root click handler on purpose: the
-		// jump is the only thing this click does.
+		// Skips the block's caret handling and the editor's root click handler on purpose:
+		// jumping is the only thing this click does.
 		e.preventDefault();
 		e.stopPropagation();
+		jumpToFirstReference();
+	}
+
+	// Looked up on each jump, never derived: the span's listeners are bound once when the span is
+	// built, so a path captured then would be the answer from whenever that was.
+	function jumpToFirstReference(): void {
 		if (!document) return;
 		// GFM numbers by first-reference order, so the first reference is the one this
-		// definition's number was minted from.
-		const first = collectFootnoteReferences(document).find((ref) => ref.label === label);
+		// definition's number comes from.
+		const first = collectFootnoteReferences(document, getEditor()?.computeInlineContent).find(
+			(ref) => ref.label === label
+		);
 		if (first) void rects?.navigateTo(first.path, first.end);
 	}
 
-	// Where a plain click already acts, so the pointer cue matches the gesture.
+	// True where a plain click already jumps, so the pointer shape matches what a click does.
 	const plainClickJumps = $derived(isWidgetActivationClick(false, getPresentationMode()));
 
 	export { containerApi };
@@ -83,7 +96,8 @@
 </div>
 
 <style>
-	/* A gutter rail, not card chrome: the marker itself is the child leaf's prefix span. */
+	/* A line down the left margin, not a card: the marker itself is drawn in front of the
+	   first child. */
 	.footnote-def {
 		position: relative;
 		margin: 0.4em 0;
@@ -92,12 +106,15 @@
 		font-size: 0.95em;
 	}
 
-	/* The marker span is built into the child leaf's DOM, outside this component's scope. */
+	/* The marker span is built into the child block's DOM, outside this component's styles. */
 	.footnote-def :global(.footnote-def-marker:hover) {
 		text-decoration: underline;
 	}
 
+	/* Where the marker is a link, a dotted underline tells it from the note's text without
+	   relying on colour. */
 	.footnote-def[data-plain-click-jumps] :global(.footnote-def-marker) {
 		cursor: pointer;
+		text-decoration: underline dotted;
 	}
 </style>

package/dist/plugins/footnotes/FootnoteReference.svelte

@@ -1,46 +1,66 @@
 <script lang="ts">
 	import { isWidgetActivationClick, type InlineWidgetComponentProps } from '../../plugin';
-	import { assignFootnoteNumbers, footnoteNumbersFor } from './footnote-numbering';
+	import { footnoteNumbersFor } from './footnote-numbering';
 	import { findFootnoteDefinitionLanding } from './footnote-lookup';
+	import { footnoteReferenceLabel } from './constants';
 
 	let {
 		source,
 		getDocument,
 		getContentVersion,
 		getPresentationMode,
-		navigateTo
+		navigateTo,
+		computeInlineContent
 	}: InlineWidgetComponentProps = $props();
 
-	// Frozen: the pool remounts on any source change, so this can never go stale.
+	// Read once: the widget remounts on any source change, so this can never go stale.
 	// svelte-ignore state_referenced_locally
 	const label = source.slice(2, -1);
 
-	// Reactive, not baked: the pool keys on the source, so this instance survives a renumber
-	// driven by a reference added elsewhere. The version is read inside the derived, so the
-	// shared walk stays subscribed rather than snapshotted.
+	// Reactive, since a widget keyed on its source survives a renumber from a reference added
+	// elsewhere; reading the version inside keeps the shared numbering pass subscribed.
 	const display = $derived.by(() => {
-		const doc = getDocument?.();
+		const doc = getDocument();
 		if (!doc) return label;
-		const version = getContentVersion?.();
-		const numbers =
-			version === undefined ? assignFootnoteNumbers(doc) : footnoteNumbersFor(doc, version);
+		const numbers = footnoteNumbersFor(doc, getContentVersion(), computeInlineContent);
 		return String(numbers.get(label) ?? label);
 	});
 
-	// Resolved on the gesture, never derived: a reference that is never clicked costs nothing
-	// beyond the numbering walk it already pays for.
-	function onClick(e: MouseEvent): void {
-		const mode = getPresentationMode?.() ?? 'source';
-		if (!isWidgetActivationClick(e.ctrlKey || e.metaKey, mode)) return;
-		const doc = getDocument?.();
+	// A tab stop only in reading mode: inside an editable block it would interrupt the caret.
+	const isReading = $derived(getPresentationMode() === 'reading');
+
+	// Looked up on each jump, never derived: a reference nobody follows costs nothing beyond the
+	// numbering pass it already pays for.
+	function jumpToDefinition(): void {
+		const doc = getDocument();
 		if (!doc) return;
 		const path = findFootnoteDefinitionLanding(doc, label);
-		if (path) void navigateTo?.(path);
+		if (path) void navigateTo(path);
+	}
+
+	function onClick(e: MouseEvent): void {
+		if (isWidgetActivationClick(e.ctrlKey || e.metaKey, getPresentationMode())) jumpToDefinition();
+	}
+
+	function onKeydown(e: KeyboardEvent): void {
+		if (e.key === 'Enter' || e.key === ' ') {
+			e.preventDefault();
+			e.stopPropagation();
+			jumpToDefinition();
+		}
 	}
 </script>
 
-<!-- svelte-ignore a11y_click_events_have_key_events, a11y_no_noninteractive_element_interactions -->
-<sup class="footnote-ref" onclick={onClick}>{display}</sup>
+<!-- The superscript stays a `<sup>` for its layout; the role says what it does. -->
+<!-- svelte-ignore a11y_no_noninteractive_element_to_interactive_role -->
+<sup
+	class="footnote-ref"
+	role="link"
+	aria-label={footnoteReferenceLabel(display)}
+	tabindex={isReading ? 0 : undefined}
+	onclick={onClick}
+	onkeydown={onKeydown}>{display}</sup
+>
 
 <style>
 	.footnote-ref {

package/dist/plugins/footnotes/constants.d.ts

@@ -1,2 +1,4 @@
 export declare const FOOTNOTE_DEF_KIND = "footnote-def";
 export declare const FOOTNOTE_REF_KIND = "footnote-ref";
+export declare const footnoteReferenceLabel: (number: string) => string;
+export declare const backToReferenceLabel: (label: string) => string;

package/dist/plugins/footnotes/constants.js

@@ -2,3 +2,6 @@
 // importing the registration modules.
 export const FOOTNOTE_DEF_KIND = 'footnote-def';
 export const FOOTNOTE_REF_KIND = 'footnote-ref';
+// Accessible names, kept with the plugin so it carries its own strings.
+export const footnoteReferenceLabel = (number) => `Footnote ${number}`;
+export const backToReferenceLabel = (label) => `Back to reference ${label}`;

package/dist/plugins/footnotes/footnote-definition.d.ts

@@ -1,14 +1,16 @@
 /**
- * The `[^label]: content` definition block as a strip container in the listItem mold.
- * The marker is pure syntax living only in the container's own raw, so
- * `strip(raw) === serialize(children)`. Load is byte-exact off the stored raw; a
- * post-edit rebuild canonicalizes marker spacing and indent, exactly as listItem does.
+ * The `[^label]: content` definition block, a strip container shaped like a list item. The
+ * marker is syntax living only in the container's own raw, so
+ * `strip(raw) === serialize(children)`. Loading is byte-exact off the stored raw; a rebuild
+ * after an edit normalizes marker spacing and indent, exactly as a list item does.
  */
 import { type CstNode } from '../../plugin';
 export interface FootnoteDefMetadata {
     label: string;
 }
-/** Splitting on `\n` keeps a `\r` at each segment's tail, so CRLF rides through; a blank
- *  continuation stays unindented. */
+/**
+ * A separator line stays unindented, as the parser reads it. The blank lines that end the body,
+ * a leaf's own or the body's trailing line, take the indent that keeps them in the definition.
+ */
 export declare function rebuildFootnoteDefRaw(node: CstNode): void;
 export declare function registerFootnoteDefinition(): void;

package/dist/plugins/footnotes/footnote-definition.js

@@ -1,22 +1,33 @@
 /**
- * The `[^label]: content` definition block as a strip container in the listItem mold.
- * The marker is pure syntax living only in the container's own raw, so
- * `strip(raw) === serialize(children)`. Load is byte-exact off the stored raw; a
- * post-edit rebuild canonicalizes marker spacing and indent, exactly as listItem does.
+ * The `[^label]: content` definition block, a strip container shaped like a list item. The
+ * marker is syntax living only in the container's own raw, so
+ * `strip(raw) === serialize(children)`. Loading is byte-exact off the stored raw; a rebuild
+ * after an edit normalizes marker spacing and indent, exactly as a list item does.
  */
-import { OPENER_PRIORITIES, containerClosure, declarePluginKind, declaredPluginKind, defineBlockComponent, getPluginMetadata, isBlankLine, lineStartsOuterBlock, parse, registerBlockComponent, registerBlockKind, registerBlockOpener, serializeChildren, setPluginMetadata } from '../../plugin';
+import { OPENER_PRIORITIES, containerClosure, declarePluginKind, declaredPluginKind, defineBlockComponent, getPluginMetadata, isBlankLine, isBlankText, isWhitespaceChar, lineStartsOuterBlock, parseContainerBody, registerBlockComponent, registerBlockKind, registerBlockOpener, setPluginMetadata, splitLines } from '../../plugin';
 import FootnoteDefinition from './FootnoteDefinition.svelte';
 import { FOOTNOTE_DEF_KIND } from './constants';
-const OPENER = /^ {0,3}\[\^([^\]\s]+)\]:/;
-const MARKER_STRIP = /^ {0,3}\[\^[^\]\s]+\]: ?/;
-const CONTINUATION_INDENT = /^(\t| {4})/;
+const OPENER = /^ {0,3}\[\^([^\]]+)\]:/;
+const MARKER_STRIP = /^ {0,3}\[\^[^\]]+\]: ?/;
+// Four columns, a tab counting to the next multiple of four, so no tab reaches past the body.
+const CONTINUATION_INDENT = /^(?: {0,3}\t| {4})/;
 const CONTINUATION_MARKER = '    ';
+/** The `[^label]:` a line opens with, where the label holds no Markdown whitespace. */
+function matchOpener(text) {
+    const match = OPENER.exec(text);
+    if (!match)
+        return null;
+    for (const ch of match[1])
+        if (isWhitespaceChar(ch))
+            return null;
+    return match;
+}
 /** Per-line approximation of the body's open-paragraph state, as in the core blockquote/list
  *  lazy models: laziness reaches only the body's own top-level paragraph. */
 function keepsParagraphOpen(strippedText, grammar) {
     if (isBlankLine(strippedText))
         return false;
-    if (OPENER.test(strippedText))
+    if (matchOpener(strippedText))
         return false;
     for (const opener of grammar.orderedOpeners()) {
         const interrupts = opener.interruptsParagraph;
@@ -25,28 +36,25 @@ function keepsParagraphOpen(strippedText, grammar) {
     }
     return true;
 }
-/**
- * Blank lines are absorbed only while a later indented line still follows — a trailing blank
- * run belongs to the document. An unindented non-blank line continues the definition only as
- * a lazy continuation of an open body paragraph (CommonMark §5.1, as cmark-gfm applies it).
- */
+/** A line indented to the body continues the definition, bare blank lines only while such a line
+ *  follows; an unindented line continues only lazily, into an open paragraph (CommonMark §5.1). */
 function scanDefinitionEnd(ctx) {
     let lastContent = ctx.index;
     let paragraphOpen = keepsParagraphOpen(ctx.line.text.replace(MARKER_STRIP, ''), ctx.grammar);
     let i = ctx.index + 1;
     while (i < ctx.end) {
         const text = ctx.lines[i].text;
-        if (isBlankLine(text)) {
-            paragraphOpen = false;
-            i++;
-            continue;
-        }
         if (CONTINUATION_INDENT.test(text)) {
             paragraphOpen = keepsParagraphOpen(text.replace(CONTINUATION_INDENT, ''), ctx.grammar);
             lastContent = i;
             i++;
             continue;
         }
+        if (isBlankLine(text)) {
+            paragraphOpen = false;
+            i++;
+            continue;
+        }
         if (paragraphOpen &&
             !lineStartsOuterBlock(ctx.lines[i], { paragraphOpen: true, grammar: ctx.grammar })) {
             lastContent = i;
@@ -58,7 +66,7 @@ function scanDefinitionEnd(ctx) {
     return lastContent + 1;
 }
 function tryOpen(ctx) {
-    const match = OPENER.exec(ctx.line.text);
+    const match = matchOpener(ctx.line.text);
     if (!match)
         return null;
     const next = scanDefinitionEnd(ctx);
@@ -67,8 +75,9 @@ function tryOpen(ctx) {
     const stripped = defLines
         .map((line, i) => line.raw.replace(i === 0 ? MARKER_STRIP : CONTINUATION_INDENT, ''))
         .join('');
-    // A fresh parse entry, so the body's own line 0 must not read as the document top.
-    const body = parse(stripped, { scope: 'fragment' });
+    // A fresh parse entry, so the body's own line 0 must not read as the document top. The body has
+    // no fence lines of its own, so no blank line is set aside from it.
+    const body = parseContainerBody(stripped, {}, { scope: 'fragment', grammar: ctx.grammar });
     const node = {
         kind: declaredPluginKind(FOOTNOTE_DEF_KIND),
         leadingTrivia: ctx.leadingTrivia,
@@ -80,50 +89,65 @@ function tryOpen(ctx) {
     setPluginMetadata(node, { label: match[1] });
     return { node, consumed: next - ctx.index };
 }
-/** Splitting on `\n` keeps a `\r` at each segment's tail, so CRLF rides through; a blank
- *  continuation stays unindented. */
+/**
+ * A separator line stays unindented, as the parser reads it. The blank lines that end the body,
+ * a leaf's own or the body's trailing line, take the indent that keeps them in the definition.
+ */
 export function rebuildFootnoteDefRaw(node) {
     const meta = getPluginMetadata(node);
     const marker = `[^${meta?.label ?? ''}]: `;
-    const inner = (node.innerPrefix ?? '') + serializeChildren(node.children ?? []) + (node.innerSuffix ?? '');
-    const lines = inner.split('\n');
-    node.raw = lines
-        .map((line, i) => {
-        if (i === lines.length - 1 && line === '')
-            return '';
-        if (i === 0)
-            return marker + line;
-        if (line === '' || line === '\r')
-            return line;
-        return CONTINUATION_MARKER + line;
-    })
-        .join('\n');
+    const lines = [];
+    const add = (bytes, separator) => {
+        for (const line of splitLines(bytes))
+            lines.push({ ...line, separator });
+    };
+    add(node.innerPrefix ?? '', true);
+    for (const child of node.children ?? []) {
+        add(child.leadingTrivia, true);
+        // A nested container's rebuild already indented the blank lines it keeps.
+        add(child.raw, child.children !== undefined);
+    }
+    add(node.innerSuffix ?? '', false);
+    let lastContent = lines.length - 1;
+    while (lastContent >= 0 && isBlankText(lines[lastContent].text))
+        lastContent--;
+    let raw = '';
+    lines.forEach(({ text, lineEnding, separator }, i) => {
+        if (raw === '')
+            raw += marker + text + lineEnding;
+        else if (text === '' && (separator || i < lastContent))
+            raw += lineEnding;
+        else
+            raw += CONTINUATION_MARKER + text + lineEnding;
+    });
+    node.raw = raw;
 }
 export function registerFootnoteDefinition() {
     const kind = declarePluginKind(FOOTNOTE_DEF_KIND);
     registerBlockOpener(kind, {
-        // Below linkReferenceDefinition so the footnote form is claimed first, in its own
-        // sub-LRD slot so no two co-installed first-party plugins share it (G1.10).
+        // Below linkReferenceDefinition so the footnote form matches first, at a priority of
+        // its own so no two bundled plugins share one (G1.10).
         priority: OPENER_PRIORITIES.linkReferenceDefinition - 4,
         tryOpen,
         interruptsParagraph: false
     });
     registerBlockKind(kind, {
+        label: 'Footnote',
         gapEdges: 'none',
         mergeRole: 'not-mergeable',
         editable: true,
         supportsInline: false,
-        // Kit fixtures must be rebuildRaw fixed points, so the continuation is indented: the
-        // lazy form canonicalizes.
+        // A conformance fixture has to survive rebuildRaw unchanged, so the continuation line
+        // is indented: the lazy form would be rewritten.
         conformanceFixture: '[^1]: A footnote definition.\n    with an indented continuation.\n',
-        // Unlike a listItem, whose leaf resolves to the item under the list, the body
-        // blocks reorder within; the marker is position-independent, so rebuildRaw re-emits it.
+        // Body blocks reorder inside the definition, unlike a list item, which moves under its
+        // list; the marker does not depend on position, so rebuildRaw re-emits it.
         container: {
             contract: 'strip',
             rebuildRaw: rebuildFootnoteDefRaw,
             reorderChildren: {},
-            // The marker rides metadata rather than the first line, so the remainder of a lift is
-            // still a definition, not the plain quote a quote-shaped lift leaves.
+            // The marker lives in metadata rather than the first line, so lifting the first child
+            // out leaves a definition behind, not the plain blockquote a quote lift leaves.
             unwrapRole: {
                 firstChildBackspace: 'lift-first-child-keep-container',
                 middleChildBackspace: 'default-merge'

package/dist/plugins/footnotes/footnote-lookup.d.ts

@@ -1,9 +1,9 @@
 /**
- * Where a `[^label]` reference jumps to: the caret landing inside that label's definition.
+ * Where a `[^label]` reference jumps to: the block inside that label's definition.
  * Depth-first in document order, so two definitions under one label resolve to the first,
  * which is the one GFM renders.
  */
 import { type DocumentView } from '../../plugin';
-/** The definition's first body block, since the container itself is no caret seat. The
- *  container path stands in when the body holds no block; null when no definition matches. */
+/** The definition's first body block, since the caret cannot sit on the container itself. The
+ *  container's own path is used when the body holds no block; null when no definition matches. */
 export declare function findFootnoteDefinitionLanding(document: DocumentView, label: string): number[] | null;

package/dist/plugins/footnotes/footnote-lookup.js

@@ -1,33 +1,21 @@
 /**
- * Where a `[^label]` reference jumps to: the caret landing inside that label's definition.
+ * Where a `[^label]` reference jumps to: the block inside that label's definition.
  * Depth-first in document order, so two definitions under one label resolve to the first,
  * which is the one GFM renders.
  */
-import { getPluginMetadata } from '../../plugin';
+import { getPluginMetadata, walkBlocks } from '../../plugin';
 import { FOOTNOTE_DEF_KIND } from './constants';
-function findInSubtree(node, path, label) {
-    if (node.kind === FOOTNOTE_DEF_KIND &&
-        getPluginMetadata(node)?.label === label) {
-        return { node, path };
-    }
-    const children = node.children;
-    if (!children)
-        return null;
-    for (let index = 0; index < children.length; index++) {
-        const hit = findInSubtree(children[index], [...path, index], label);
-        if (hit)
-            return hit;
-    }
-    return null;
-}
-/** The definition's first body block, since the container itself is no caret seat. The
- *  container path stands in when the body holds no block; null when no definition matches. */
+/** The definition's first body block, since the caret cannot sit on the container itself. The
+ *  container's own path is used when the body holds no block; null when no definition matches. */
 export function findFootnoteDefinitionLanding(document, label) {
-    const children = document.children;
-    for (let index = 0; index < children.length; index++) {
-        const match = findInSubtree(children[index], [index], label);
-        if (match)
-            return match.node.children?.length ? [...match.path, 0] : match.path;
-    }
-    return null;
+    let landing = null;
+    walkBlocks(document, (node, path) => {
+        if (node.kind !== FOOTNOTE_DEF_KIND)
+            return;
+        if (getPluginMetadata(node)?.label !== label)
+            return;
+        landing = node.children?.length ? [...path, 0] : path;
+        return 'stop';
+    });
+    return landing;
 }

package/dist/plugins/footnotes/footnote-numbering.d.ts

@@ -4,20 +4,20 @@
  * raw bytes excludes two things by construction: a `[^x]` in a code span, and a
  * definition's own marker, which lives in the container's raw rather than a child.
  */
-import { type DocumentView } from '../../plugin';
+import { type DocumentView, type EditorContext } from '../../plugin';
+/** The inline read numbering walks with: an editor's, so a reference inside syntax that editor
+ *  left out still counts. Without one it reads every installed plugin. */
+export type InlineReader = EditorContext['computeInlineContent'];
 export interface FootnoteReference {
     label: string;
-    /** Doc-absolute block path of the prose leaf carrying the reference. */
+    /** Document-absolute block path of the prose block holding the reference. */
     path: number[];
-    /** Raw offset just past the `[^label]` bytes in that leaf — where the way back lands. */
+    /** Raw offset just past the `[^label]` bytes in that block: where a jump back lands. */
     end: number;
 }
-export declare function collectFootnoteReferences(document: DocumentView): FootnoteReference[];
+export declare function collectFootnoteReferences(document: DocumentView, reader?: InlineReader): FootnoteReference[];
 /** Labels only, so the numbering a keystroke rebuilds allocates no rebased paths. */
-export declare function assignFootnoteNumbers(document: DocumentView): Map<string, number>;
-/**
- * One numbering per flush rather than one per widget. `contentVersion` must be in the key:
- * the `$state` document is mutated in place, so an identity-keyed memo would hit forever and
- * return a stale map.
- */
-export declare function footnoteNumbersFor(document: DocumentView, contentVersion: number): Map<string, number>;
+export declare function assignFootnoteNumbers(document: DocumentView, reader?: InlineReader): Map<string, number>;
+/** One numbering per flush, not per widget, keyed on `contentVersion` too: the `$state` document
+ *  changes in place, so an identity key alone would return a stale map. */
+export declare function footnoteNumbersFor(document: DocumentView, contentVersion: number, reader?: InlineReader): Map<string, number>;

package/dist/plugins/footnotes/footnote-numbering.js

@@ -4,8 +4,9 @@
  * raw bytes excludes two things by construction: a `[^x]` in a code span, and a
  * definition's own marker, which lives in the container's raw rather than a child.
  */
-import { computeInlineContent, isProseKind } from '../../plugin';
+import { computeInlineContent, isProseKind, walkBlocks } from '../../plugin';
 import { FOOTNOTE_REF_KIND } from './constants';
+const EVERY_PLUGIN = computeInlineContent;
 function collectRefsInInline(nodes, path, out) {
     for (const node of nodes) {
         if (node.kind === FOOTNOTE_REF_KIND)
@@ -14,31 +15,27 @@ function collectRefsInInline(nodes, path, out) {
             collectRefsInInline(node.children, path, out);
     }
 }
-function collectRefsInSubtree(node, basePath, out) {
-    if (node.children && node.children.length > 0) {
-        node.children.forEach((child, index) => collectRefsInSubtree(child, [...basePath, index], out));
+function collectRefsInLeaf(node, path, out, reader) {
+    if (node.children?.length || !isProseKind(node.kind))
         return;
-    }
-    if (!isProseKind(node.kind))
-        return;
-    collectRefsInInline(computeInlineContent(node), basePath, out);
+    collectRefsInInline(reader(node), path, out);
 }
-export function collectFootnoteReferences(document) {
+export function collectFootnoteReferences(document, reader = EVERY_PLUGIN) {
     const refs = [];
     const children = document.children;
     for (let index = 0; index < children.length; index++) {
-        for (const ref of subtreeRefs(children[index])) {
+        for (const ref of subtreeRefs(children[index], reader)) {
             refs.push({ label: ref.label, path: [index, ...ref.path], end: ref.end });
         }
     }
     return refs;
 }
 /** Labels only, so the numbering a keystroke rebuilds allocates no rebased paths. */
-export function assignFootnoteNumbers(document) {
+export function assignFootnoteNumbers(document, reader = EVERY_PLUGIN) {
     const numbers = new Map();
     const children = document.children;
     for (let index = 0; index < children.length; index++) {
-        for (const ref of subtreeRefs(children[index])) {
+        for (const ref of subtreeRefs(children[index], reader)) {
             if (!numbers.has(ref.label))
                 numbers.set(ref.label, numbers.size + 1);
         }
@@ -46,33 +43,27 @@ export function assignFootnoteNumbers(document) {
     return numbers;
 }
 const refsBySubtree = new WeakMap();
-/**
- * One top-level subtree's references, memoized against the bytes they came from, so a
- * keystroke re-parses that subtree and reuses every other. Sound because the serializer
- * never recurses (`editor.md` § 12): a subtree's `raw` is its whole byte image, kept so by
- * the container-`raw` rebuild up the ancestry.
- */
-function subtreeRefs(node) {
+/** One top-level subtree's references, cached against its `raw` (the subtree's whole byte
+ *  image), so a keystroke re-parses only the subtree it changed. */
+function subtreeRefs(node, reader) {
     const cached = refsBySubtree.get(node);
-    if (cached && cached.raw === node.raw && cached.kind === node.kind)
+    if (cached && cached.raw === node.raw && cached.kind === node.kind && cached.reader === reader)
         return cached.refs;
     const refs = [];
-    collectRefsInSubtree(node, [], refs);
-    refsBySubtree.set(node, { raw: node.raw, kind: node.kind, refs });
+    collectRefsInLeaf(node, [], refs, reader);
+    walkBlocks(node, (child, path) => collectRefsInLeaf(child, path, refs, reader));
+    refsBySubtree.set(node, { raw: node.raw, kind: node.kind, reader, refs });
     return refs;
 }
 // ── Per-version sharing ──────────────────────────────────────────────────────
 const numberingByDocument = new WeakMap();
-/**
- * One numbering per flush rather than one per widget. `contentVersion` must be in the key:
- * the `$state` document is mutated in place, so an identity-keyed memo would hit forever and
- * return a stale map.
- */
-export function footnoteNumbersFor(document, contentVersion) {
+/** One numbering per flush, not per widget, keyed on `contentVersion` too: the `$state` document
+ *  changes in place, so an identity key alone would return a stale map. */
+export function footnoteNumbersFor(document, contentVersion, reader = EVERY_PLUGIN) {
     const cached = numberingByDocument.get(document);
-    if (cached && cached.version === contentVersion)
+    if (cached && cached.version === contentVersion && cached.reader === reader)
         return cached.numbers;
-    const numbers = assignFootnoteNumbers(document);
-    numberingByDocument.set(document, { version: contentVersion, numbers });
+    const numbers = assignFootnoteNumbers(document, reader);
+    numberingByDocument.set(document, { version: contentVersion, reader, numbers });
     return numbers;
 }

package/dist/plugins/footnotes/footnote-reference.d.ts

@@ -1,7 +1,7 @@
 /**
- * The reference implementation of an inline rung: `[^label]` claims the ladder's
- * `[^`-prefix rung, consulted before the built-in `[` handler. The literal bytes stay
- * in the block's raw and the number is derived rather than stored. Recognition is gated
- * on registration: absent the plugin, `[` runs its built-in bracket handling instead.
+ * The worked example of an inline syntax handler: `[^label]` registers on the `[^` prefix, so
+ * it is tried before the built-in `[` handler. The literal bytes stay in the block's raw and
+ * the number is worked out rather than stored. Recognition starts only once the plugin
+ * registers: without it, `[` runs the built-in bracket handling instead.
  */
 export declare function registerFootnoteReference(): void;