@voithos-labs/aragonite 0.10.1

package/dist/plugins/emoji/index.d.ts

@@ -0,0 +1,3 @@
+export { emojiPlugin } from './emoji-plugin';
+export { EMOJI_KIND } from './emoji-recognizer';
+export { EMOJI_TABLE } from './emoji-table';

package/dist/plugins/emoji/index.js

@@ -0,0 +1,4 @@
+// GitHub `:shortcode:` emoji as atomic glyph widgets on the bare `:` trigger.
+export { emojiPlugin } from './emoji-plugin';
+export { EMOJI_KIND } from './emoji-recognizer';
+export { EMOJI_TABLE } from './emoji-table';

package/dist/plugins/footnotes/FootnoteDefinition.svelte

@@ -0,0 +1,103 @@
+<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.
+	import {
+		BlockList,
+		createContainerBlock,
+		getPluginMetadata,
+		isWidgetActivationClick,
+		type DocumentView,
+		type EditorRects,
+		type NodeView
+	} from '../../plugin';
+	import type { FootnoteDefMetadata } from './footnote-definition';
+	import { collectFootnoteReferences } from './footnote-numbering';
+
+	let {
+		node,
+		index,
+		myPath = [],
+		document,
+		rects
+	}: {
+		node: NodeView;
+		index: number;
+		myPath?: number[];
+		document?: DocumentView;
+		rects?: EditorRects;
+	} = $props();
+
+	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.
+	const marker = $derived(`[^${label}]`);
+
+	const { blockListProps, containerApi, getPresentationMode } = createContainerBlock({
+		getNode: () => node,
+		getIndex: () => index,
+		getPath: () => myPath,
+		getBoxEl: () => boxEl,
+		getAmbientPrefix: () => ({
+			text: `${marker}: `,
+			interactive: [
+				{
+					start: 0,
+					end: marker.length,
+					className: 'footnote-def-marker',
+					onClick: 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 {
+		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.
+		e.preventDefault();
+		e.stopPropagation();
+		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);
+		if (first) void rects?.navigateTo(first.path, first.end);
+	}
+
+	// Where a plain click already acts, so the pointer cue matches the gesture.
+	const plainClickJumps = $derived(isWidgetActivationClick(false, getPresentationMode()));
+
+	export { containerApi };
+</script>
+
+<div
+	class="footnote-def"
+	data-footnote-label={label}
+	data-plain-click-jumps={plainClickJumps ? '' : undefined}
+	bind:this={boxEl}
+>
+	<BlockList {...blockListProps} />
+</div>
+
+<style>
+	/* A gutter rail, not card chrome: the marker itself is the child leaf's prefix span. */
+	.footnote-def {
+		position: relative;
+		margin: 0.4em 0;
+		padding-left: 0.9em;
+		border-left: 2px solid var(--color-border, #3d4047);
+		font-size: 0.95em;
+	}
+
+	/* The marker span is built into the child leaf's DOM, outside this component's scope. */
+	.footnote-def :global(.footnote-def-marker:hover) {
+		text-decoration: underline;
+	}
+
+	.footnote-def[data-plain-click-jumps] :global(.footnote-def-marker) {
+		cursor: pointer;
+	}
+</style>

package/dist/plugins/footnotes/FootnoteDefinition.svelte.d.ts

@@ -0,0 +1,13 @@
+import { type DocumentView, type EditorRects, type NodeView } from '../../plugin';
+type $$ComponentProps = {
+    node: NodeView;
+    index: number;
+    myPath?: number[];
+    document?: DocumentView;
+    rects?: EditorRects;
+};
+declare const FootnoteDefinition: import("svelte").Component<$$ComponentProps, {
+    containerApi: import("../../plugin").ContainerBlockComponent;
+}, "">;
+type FootnoteDefinition = ReturnType<typeof FootnoteDefinition>;
+export default FootnoteDefinition;

package/dist/plugins/footnotes/FootnoteReference.svelte

@@ -0,0 +1,50 @@
+<script lang="ts">
+	import { isWidgetActivationClick, type InlineWidgetComponentProps } from '../../plugin';
+	import { assignFootnoteNumbers, footnoteNumbersFor } from './footnote-numbering';
+	import { findFootnoteDefinitionLanding } from './footnote-lookup';
+
+	let {
+		source,
+		getDocument,
+		getContentVersion,
+		getPresentationMode,
+		navigateTo
+	}: InlineWidgetComponentProps = $props();
+
+	// Frozen: the pool 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.
+	const display = $derived.by(() => {
+		const doc = getDocument?.();
+		if (!doc) return label;
+		const version = getContentVersion?.();
+		const numbers =
+			version === undefined ? assignFootnoteNumbers(doc) : footnoteNumbersFor(doc, version);
+		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?.();
+		if (!doc) return;
+		const path = findFootnoteDefinitionLanding(doc, label);
+		if (path) void navigateTo?.(path);
+	}
+</script>
+
+<!-- svelte-ignore a11y_click_events_have_key_events, a11y_no_noninteractive_element_interactions -->
+<sup class="footnote-ref" onclick={onClick}>{display}</sup>
+
+<style>
+	.footnote-ref {
+		color: var(--color-accent, #567b67);
+		cursor: pointer;
+	}
+</style>

package/dist/plugins/footnotes/FootnoteReference.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type InlineWidgetComponentProps } from '../../plugin';
+declare const FootnoteReference: import("svelte").Component<InlineWidgetComponentProps, {}, "">;
+type FootnoteReference = ReturnType<typeof FootnoteReference>;
+export default FootnoteReference;

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

@@ -0,0 +1,2 @@
+export declare const FOOTNOTE_DEF_KIND = "footnote-def";
+export declare const FOOTNOTE_REF_KIND = "footnote-ref";

package/dist/plugins/footnotes/constants.js

@@ -0,0 +1,4 @@
+// Plain strings, not branded declarations, so a consumer can filter on kind without
+// importing the registration modules.
+export const FOOTNOTE_DEF_KIND = 'footnote-def';
+export const FOOTNOTE_REF_KIND = 'footnote-ref';

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

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+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. */
+export declare function rebuildFootnoteDefRaw(node: CstNode): void;
+export declare function registerFootnoteDefinition(): void;

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

@@ -0,0 +1,147 @@
+/**
+ * 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.
+ */
+import { OPENER_PRIORITIES, containerClosure, declarePluginKind, declaredPluginKind, defineBlockComponent, getPluginMetadata, isBlankLine, lineStartsOuterBlock, parse, registerBlockComponent, registerBlockKind, registerBlockOpener, serializeChildren, setPluginMetadata } 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 CONTINUATION_MARKER = '    ';
+/** 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))
+        return false;
+    for (const opener of grammar.orderedOpeners()) {
+        const interrupts = opener.interruptsParagraph;
+        if (interrupts !== false && interrupts(strippedText))
+            return false;
+    }
+    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).
+ */
+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 (paragraphOpen &&
+            !lineStartsOuterBlock(ctx.lines[i], { paragraphOpen: true, grammar: ctx.grammar })) {
+            lastContent = i;
+            i++;
+            continue;
+        }
+        break;
+    }
+    return lastContent + 1;
+}
+function tryOpen(ctx) {
+    const match = OPENER.exec(ctx.line.text);
+    if (!match)
+        return null;
+    const next = scanDefinitionEnd(ctx);
+    const defLines = ctx.lines.slice(ctx.index, next);
+    const raw = defLines.map((line) => line.raw).join('');
+    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' });
+    const node = {
+        kind: declaredPluginKind(FOOTNOTE_DEF_KIND),
+        leadingTrivia: ctx.leadingTrivia,
+        raw,
+        innerPrefix: body.prefix,
+        children: body.children,
+        innerSuffix: body.suffix
+    };
+    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. */
+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');
+}
+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).
+        priority: OPENER_PRIORITIES.linkReferenceDefinition - 4,
+        tryOpen,
+        interruptsParagraph: false
+    });
+    registerBlockKind(kind, {
+        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.
+        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.
+        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.
+            unwrapRole: {
+                firstChildBackspace: 'lift-first-child-keep-container',
+                middleChildBackspace: 'default-merge'
+            }
+        },
+        closure: containerClosure({
+            roundTripVia: 'container contract=strip — rebuildFootnoteDefRaw re-emits the [^label]: marker + four-space continuation indent',
+            focus: {
+                mode: 'implemented',
+                via: 'focus walks into the first child block via createContainerBlock'
+            },
+            mergeBackspace: {
+                mode: 'implemented',
+                via: 'not-mergeable outward, so nothing below concatenates into the note; within the body, unwrapRole lifts the first block out (lift-first-child-keep-container) and later blocks default-merge'
+            },
+            undo: { mode: 'inherit-default' },
+            simOracle: { mode: 'inherit-default' }
+        })
+    });
+    registerBlockComponent(kind, defineBlockComponent(FootnoteDefinition));
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Where a `[^label]` reference jumps to: the caret landing 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. */
+export declare function findFootnoteDefinitionLanding(document: DocumentView, label: string): number[] | null;

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

@@ -0,0 +1,33 @@
+/**
+ * Where a `[^label]` reference jumps to: the caret landing 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 { 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. */
+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;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Numbering derived as a pure function over the read-only document: GFM numbers by
+ * first-reference order, not definition order. Walking parsed inline nodes rather than
+ * 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';
+export interface FootnoteReference {
+    label: string;
+    /** Doc-absolute block path of the prose leaf carrying the reference. */
+    path: number[];
+    /** Raw offset just past the `[^label]` bytes in that leaf — where the way back lands. */
+    end: number;
+}
+export declare function collectFootnoteReferences(document: DocumentView): 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>;

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

@@ -0,0 +1,78 @@
+/**
+ * Numbering derived as a pure function over the read-only document: GFM numbers by
+ * first-reference order, not definition order. Walking parsed inline nodes rather than
+ * 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 { FOOTNOTE_REF_KIND } from './constants';
+function collectRefsInInline(nodes, path, out) {
+    for (const node of nodes) {
+        if (node.kind === FOOTNOTE_REF_KIND)
+            out.push({ label: node.label ?? '', path, end: node.end });
+        else if (node.children)
+            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));
+        return;
+    }
+    if (!isProseKind(node.kind))
+        return;
+    collectRefsInInline(computeInlineContent(node), basePath, out);
+}
+export function collectFootnoteReferences(document) {
+    const refs = [];
+    const children = document.children;
+    for (let index = 0; index < children.length; index++) {
+        for (const ref of subtreeRefs(children[index])) {
+            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) {
+    const numbers = new Map();
+    const children = document.children;
+    for (let index = 0; index < children.length; index++) {
+        for (const ref of subtreeRefs(children[index])) {
+            if (!numbers.has(ref.label))
+                numbers.set(ref.label, numbers.size + 1);
+        }
+    }
+    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) {
+    const cached = refsBySubtree.get(node);
+    if (cached && cached.raw === node.raw && cached.kind === node.kind)
+        return cached.refs;
+    const refs = [];
+    collectRefsInSubtree(node, [], refs);
+    refsBySubtree.set(node, { raw: node.raw, kind: node.kind, 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) {
+    const cached = numberingByDocument.get(document);
+    if (cached && cached.version === contentVersion)
+        return cached.numbers;
+    const numbers = assignFootnoteNumbers(document);
+    numberingByDocument.set(document, { version: contentVersion, numbers });
+    return numbers;
+}

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

@@ -0,0 +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.
+ */
+export declare function registerFootnoteReference(): void;

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

@@ -0,0 +1,54 @@
+/**
+ * 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.
+ */
+import { INLINE_PRIORITIES, createScanIndex, declarePluginInlineKind, isInlineKindDeclared, registerInlineSyntax, registerInlineWidgetKind } from '../../plugin';
+import FootnoteReference from './FootnoteReference.svelte';
+import { FOOTNOTE_REF_KIND } from './constants';
+const isWhitespace = (ch) => /\s/.test(ch);
+function indexLabelTerminators(raw) {
+    const positions = [];
+    for (let i = 0; i < raw.length; i++) {
+        if (raw[i] === ']' || isWhitespace(raw[i]))
+            positions.push(i);
+    }
+    return Int32Array.from(positions);
+}
+// Indexed once per block, not searched per consultation: an unterminated `[^` declines
+// only by reaching the end, so a paragraph full of them would cost a block scan each.
+const firstTerminatorFrom = createScanIndex(indexLabelTerminators);
+/**
+ * Every decline falls through to the built-in bracket handler byte-identically. The reference
+ * is atomic, so a trailing `(...)` rescans as ordinary inline content, never a destination.
+ */
+function recognizeFootnoteReference(raw, pos, end, kind) {
+    if (raw[pos] !== '[' || raw[pos + 1] !== '^')
+        return null;
+    const labelStart = pos + 2;
+    // The index spans the whole block, so `end` decides the claim: a `]` past the scan
+    // range leaves the reference unterminated.
+    const close = firstTerminatorFrom(raw, labelStart);
+    if (close === -1 || close >= end)
+        return null;
+    if (raw[close] !== ']' || close === labelStart)
+        return null;
+    return { kind, start: pos, end: close + 1, label: raw.slice(labelStart, close) };
+}
+export function registerFootnoteReference() {
+    // Keyed on the kind registry, not a module latch, so the platform reset that clears
+    // the inline registries also clears this guard.
+    if (isInlineKindDeclared(FOOTNOTE_REF_KIND))
+        return;
+    const kind = declarePluginInlineKind(FOOTNOTE_REF_KIND);
+    registerInlineSyntax('[', (raw, pos, end) => recognizeFootnoteReference(raw, pos, end, kind), {
+        prefix: '[^',
+        priority: INLINE_PRIORITIES.prefixOverride
+    });
+    registerInlineWidgetKind(kind, {
+        isWidget: () => true,
+        component: FootnoteReference,
+        editing: { revealSource: true, claimsActivationClick: true }
+    });
+}

package/dist/plugins/footnotes/footnotes-plugin.d.ts

@@ -0,0 +1,7 @@
+/**
+ * GFM footnotes: a strip-container definition plus an inline-widget reference, which jump to
+ * each other off their own markers. Numbering is derived off the live document, so no counter
+ * is stored anywhere.
+ */
+import { type EditorPlugin } from '../../plugin';
+export declare function footnotesPlugin(): EditorPlugin;

package/dist/plugins/footnotes/footnotes-plugin.js

@@ -0,0 +1,17 @@
+/**
+ * GFM footnotes: a strip-container definition plus an inline-widget reference, which jump to
+ * each other off their own markers. Numbering is derived off the live document, so no counter
+ * is stored anywhere.
+ */
+import { definePlugin } from '../../plugin';
+import { registerFootnoteDefinition } from './footnote-definition';
+import { registerFootnoteReference } from './footnote-reference';
+export function footnotesPlugin() {
+    return definePlugin({
+        name: 'footnotes',
+        setup() {
+            registerFootnoteDefinition();
+            registerFootnoteReference();
+        }
+    });
+}

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

@@ -0,0 +1,5 @@
+export { footnotesPlugin } from './footnotes-plugin';
+export { FOOTNOTE_DEF_KIND, FOOTNOTE_REF_KIND } from './constants';
+export { assignFootnoteNumbers, collectFootnoteReferences } from './footnote-numbering';
+export type { FootnoteReference } from './footnote-numbering';
+export type { FootnoteDefMetadata } from './footnote-definition';

package/dist/plugins/footnotes/index.js

@@ -0,0 +1,6 @@
+export { footnotesPlugin } from './footnotes-plugin';
+export { FOOTNOTE_DEF_KIND, FOOTNOTE_REF_KIND } from './constants';
+// `footnoteNumbersFor` is deliberately absent: only a mounted widget can supply its
+// content-version argument, and `InlineWidgetComponentProps.getContentVersion` is the
+// reusable half of that recipe.
+export { assignFootnoteNumbers, collectFootnoteReferences } from './footnote-numbering';

package/dist/plugins/highlight-occurrences/highlight-occurrences-plugin.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The decoration-source shape on public doors only: onEditor wires a mark source to the
+ * selection and edit channels, and the scan, its memo and the typing gate stay pure in
+ * the sibling modules.
+ */
+import { type EditorPlugin } from '../../plugin';
+export interface HighlightOccurrencesOptions {
+    /**
+     * Called when the word index is rebuilt: on a document change, not on a caret move,
+     * carrying how many leaves that rebuild had to tokenize. Public so a harness asserts
+     * the memo against this wiring rather than a copy of it.
+     */
+    onScan?: (stats: {
+        tokenizedLeaves: number;
+    }) => void;
+}
+export declare function highlightOccurrencesPlugin(options?: HighlightOccurrencesOptions): EditorPlugin;

package/dist/plugins/highlight-occurrences/highlight-occurrences-plugin.js

@@ -0,0 +1,31 @@
+/**
+ * The decoration-source shape on public doors only: onEditor wires a mark source to the
+ * selection and edit channels, and the scan, its memo and the typing gate stay pure in
+ * the sibling modules.
+ */
+import { definePlugin } from '../../plugin';
+import { createOccurrenceSource } from './occurrence-source';
+export function highlightOccurrencesPlugin(options = {}) {
+    return definePlugin({
+        name: 'highlight-occurrences',
+        setup(ctx) {
+            ctx.onEditor((editor) => {
+                const occurrences = createOccurrenceSource({ onScan: options.onScan });
+                const handle = editor.decorations.addSource(occurrences.source);
+                const offSelection = editor.events.on('selectionChange', (selection) => {
+                    occurrences.setSelection(selection);
+                    handle.invalidate();
+                });
+                const offEdit = editor.events.on('edit', ({ op }) => {
+                    if (occurrences.noteEdit(op))
+                        handle.invalidate();
+                });
+                return () => {
+                    offSelection();
+                    offEdit();
+                    handle.dispose();
+                };
+            });
+        }
+    });
+}