@voithos-labs/aragonite 0.10.1

package/dist/debug/diagnostics-report.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The attachable field report `getDiagnostics().serializeDiagnostics()` produces:
+ * a fenced-markdown snapshot a consumer pastes into a bug report. Pure over its
+ * inputs so the privacy pin — the document source is EXCLUDED unless the consumer
+ * opts in — is unit-testable without mounting the editor.
+ */
+export interface DiagnosticsReportInput {
+    timestamp: string;
+    /** Tails pre-rendered by the debug engine. */
+    trace: string;
+    opsLog: string;
+    selection: string;
+    /** Raw document Markdown. Emitted ONLY when `includeSource` is true. */
+    source: string;
+    includeSource: boolean;
+}
+export declare function buildDiagnosticsReport(input: DiagnosticsReportInput): string;

package/dist/debug/diagnostics-report.js

@@ -0,0 +1,25 @@
+/**
+ * The attachable field report `getDiagnostics().serializeDiagnostics()` produces:
+ * a fenced-markdown snapshot a consumer pastes into a bug report. Pure over its
+ * inputs so the privacy pin — the document source is EXCLUDED unless the consumer
+ * opts in — is unit-testable without mounting the editor.
+ */
+import { escalatedFenceLength } from '../core/parsers/fence-syntax';
+// A trace tail or a document body routinely holds a fence of its own, which would close the
+// section early and hand the maintainer a malformed report.
+function fenced(title, body) {
+    const text = body || '(empty)';
+    const fence = '`'.repeat(escalatedFenceLength(text, '`', 3));
+    return `## ${title}\n\n${fence}\n${text}\n${fence}`;
+}
+export function buildDiagnosticsReport(input) {
+    const sections = [
+        fenced('Interaction trace', input.trace),
+        fenced('Operations log', input.opsLog),
+        fenced('Selection', input.selection)
+    ];
+    // Default-excluded: a field report must not leak the document unless asked.
+    if (input.includeSource)
+        sections.push(fenced('Source', input.source));
+    return `# aragonite editor diagnostics — ${input.timestamp}\n\n${sections.join('\n\n')}\n`;
+}

package/dist/debug/dump-tree.d.ts

@@ -0,0 +1,6 @@
+import type { DocumentView } from '../core/node-views';
+export interface DumpTreeOptions {
+    maxRawChars?: number;
+    showAllMetadata?: boolean;
+}
+export declare function dumpTree(doc: DocumentView, opts?: DumpTreeOptions): string;

package/dist/debug/dump-tree.js

@@ -0,0 +1,114 @@
+import { isBuiltinBlockNode } from '../core/nodes';
+import { trimTrailingLineEnding } from '../core/lines';
+const DEFAULTS = {
+    maxRawChars: 40,
+    showAllMetadata: false
+};
+export function dumpTree(doc, opts = {}) {
+    const options = { ...DEFAULTS, ...opts };
+    if (!doc.children || doc.children.length === 0)
+        return '';
+    const lines = [];
+    for (let i = 0; i < doc.children.length; i++) {
+        renderNode(doc.children[i], i, 0, lines, options);
+    }
+    return lines.join('\n');
+}
+function renderNode(node, index, depth, lines, opts) {
+    const indent = '  '.repeat(depth);
+    const header = [`${indent}[${index}] ${node.kind}`];
+    const meta = formatMetadata(node, opts);
+    if (meta)
+        header.push(meta);
+    if (node.children && node.children.length > 0) {
+        header.push(`children=${node.children.length}`);
+    }
+    const rawDisplay = truncate(trimTrailingLineEnding(node.raw), opts.maxRawChars);
+    const triviaStr = node.leadingTrivia && node.leadingTrivia.length > 0
+        ? `trivia=${JSON.stringify(node.leadingTrivia)}`
+        : null;
+    if (rawDisplay.includes('\n')) {
+        // Continuation lines take one extra column so they align after the opening quote
+        // instead of reading as child entries, which start with `[` at the same indent.
+        if (triviaStr)
+            header.push(triviaStr);
+        lines.push(header.join(' '));
+        const rawLines = rawDisplay.split('\n');
+        const rawIndent = indent + '  ';
+        const contIndent = rawIndent + ' ';
+        lines.push(`${rawIndent}"${rawLines[0]}`);
+        for (let i = 1; i < rawLines.length - 1; i++) {
+            lines.push(`${contIndent}${rawLines[i]}`);
+        }
+        lines.push(`${contIndent}${rawLines[rawLines.length - 1]}"`);
+    }
+    else {
+        header.push(`"${rawDisplay}"`);
+        if (triviaStr)
+            header.push(triviaStr);
+        lines.push(header.join(' '));
+    }
+    if (node.children && node.children.length > 0) {
+        for (let i = 0; i < node.children.length; i++) {
+            renderNode(node.children[i], i, depth + 1, lines, opts);
+        }
+    }
+}
+function formatMetadata(node, opts) {
+    const m = node.metadata;
+    if (!m)
+        return '';
+    const frags = [];
+    // Narrowing to the built-in union lets each arm read its own metadata directly, with no
+    // `'field' in m` probing.
+    if (isBuiltinBlockNode(node)) {
+        switch (node.kind) {
+            case 'heading':
+            case 'setextHeading':
+                if (node.metadata.level)
+                    frags.push(`level=${node.metadata.level}`);
+                break;
+            case 'fencedCode':
+                if (node.metadata.info)
+                    frags.push(`info=${JSON.stringify(node.metadata.info)}`);
+                if (node.metadata.fenceMarker)
+                    frags.push(`fence=${JSON.stringify(node.metadata.fenceMarker)}`);
+                if (node.metadata.fenceLength)
+                    frags.push(`fenceLength=${node.metadata.fenceLength}`);
+                break;
+            case 'thematicBreak':
+                if (node.metadata.marker)
+                    frags.push(`marker=${JSON.stringify(node.metadata.marker)}`);
+                break;
+            case 'list':
+                frags.push(`kind=${node.metadata.ordered ? 'ordered' : 'bullet'}`);
+                break;
+            case 'listItem':
+                if (node.metadata.marker)
+                    frags.push(`marker=${JSON.stringify(node.metadata.marker)}`);
+                if (node.metadata.taskItem)
+                    frags.push(`task=${node.metadata.taskChecked ? 'x' : ' '}`);
+                break;
+            case 'blockquote':
+                if (node.metadata.quoteDepth)
+                    frags.push(`quoteDepth=${node.metadata.quoteDepth}`);
+                break;
+            case 'linkReferenceDefinition':
+                if (node.metadata.label)
+                    frags.push(`label=${JSON.stringify(node.metadata.label)}`);
+                break;
+            case 'table':
+                if (node.metadata.columnCount)
+                    frags.push(`columnCount=${node.metadata.columnCount}`);
+                break;
+            default:
+                break;
+        }
+    }
+    if (opts.showAllMetadata)
+        frags.push(`metaRaw=${JSON.stringify(m)}`);
+    return frags.join(' ');
+}
+function truncate(s, max) {
+    return s.length <= max ? s : s.slice(0, max) + '…';
+}

package/dist/debug/inspect.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Internal debug engine — never exported from the public barrel (`src/lib/index.ts`).
+ * Output format is disposable: assert on structured accessors (getSource, kinds, paths).
+ */
+import type { InlineNode } from '../core/nodes';
+import type { SelectionState } from '../selection/selection-state.svelte';
+import { type UndoEntry } from '../undo/types';
+import type { OperationsLog } from './operations-log';
+import type { InteractionTraceEntry } from './interaction-trace';
+export { dumpTree } from './dump-tree';
+export declare function dumpSelection(state: SelectionState | null): string;
+export interface UndoStackLike {
+    undo: UndoEntry[];
+    redo: UndoEntry[];
+}
+export declare function dumpUndoStack(stack: UndoStackLike, n?: number): string;
+export declare function dumpInlineTree(nodes: InlineNode[] | undefined): string;
+export declare function dumpOperationsLog(log: OperationsLog, n?: number): string;
+export declare function dumpInteractionTrace(entries: InteractionTraceEntry[], n?: number): string;

package/dist/debug/inspect.js

@@ -0,0 +1,116 @@
+/**
+ * Internal debug engine — never exported from the public barrel (`src/lib/index.ts`).
+ * Output format is disposable: assert on structured accessors (getSource, kinds, paths).
+ */
+import { isGapSelection } from '../undo/types';
+export { dumpTree } from './dump-tree';
+// ── Selection ──────────────────────────────────────────────────────────────
+export function dumpSelection(state) {
+    if (!state || !state.anchor || !state.focus)
+        return '(no selection)';
+    const parts = [
+        `anchor=${formatPoint(state.anchor)}`,
+        `focus=${formatPoint(state.focus)}`,
+        `cross-block=${state.isCrossBlock}`
+    ];
+    if (state.isCrossBlock && state.start && state.end) {
+        parts.push(`start=${formatPoint(state.start)}`);
+        parts.push(`end=${formatPoint(state.end)}`);
+    }
+    return parts.join(' ');
+}
+function formatPoint(p) {
+    return `[${p.path.join(',')}]@${p.offset}`;
+}
+export function dumpUndoStack(stack, n = 10) {
+    const entries = stack.undo.slice(-n).reverse();
+    const lines = entries.map((e, i) => {
+        const selStr = e.selection ? formatUndoSelection(e.selection) : 'selection=null';
+        return `[${i}] ${selStr}`;
+    });
+    lines.push(`undo-depth=${stack.undo.length} redo-depth=${stack.redo.length}`);
+    return lines.join('\n');
+}
+function formatUndoSelection(sel) {
+    if (!sel)
+        return 'selection=null';
+    if (isGapSelection(sel)) {
+        return `selection=gap[${sel.gapCaret.parentPath.join(',')}]#${sel.gapCaret.index}`;
+    }
+    const a = formatPoint(sel.anchor);
+    const f = formatPoint(sel.focus);
+    return `selection=${a}→${f}`;
+}
+// ── Inline tree ────────────────────────────────────────────────────────────
+export function dumpInlineTree(nodes) {
+    if (!nodes || nodes.length === 0)
+        return '';
+    const lines = [];
+    for (const node of nodes)
+        renderInline(node, 0, lines);
+    return lines.join('\n');
+}
+function renderInline(node, depth, lines) {
+    const indent = '  '.repeat(depth);
+    const range = `[${node.start},${node.end}]`;
+    const text = 'text' in node ? ` "${node.text}"` : '';
+    const url = 'url' in node && node.url ? ` url=${JSON.stringify(node.url)}` : '';
+    const decoded = node.kind === 'entityReference' && node.decoded !== undefined
+        ? ` decoded=${JSON.stringify(node.decoded)}`
+        : '';
+    lines.push(`${indent}${node.kind} ${range}${text}${url}${decoded}`);
+    if ('children' in node && node.children) {
+        for (const c of node.children)
+            renderInline(c, depth + 1, lines);
+    }
+}
+// ── Operations log ─────────────────────────────────────────────────────────
+export function dumpOperationsLog(log, n = 20) {
+    const snap = log.snapshot();
+    if (snap.length === 0)
+        return '(no operations recorded)';
+    const tail = snap.slice(-n);
+    const now = Date.now();
+    return tail.map((e) => renderOp(e, now)).join('\n');
+}
+function renderOp(e, now) {
+    const base = `[${now - e.t}ms ago] op=${e.op} path=[${e.path.join(',')}]`;
+    const detail = renderDetail(e);
+    return detail ? `${base} ${detail}` : base;
+}
+// ── Interaction trace ──────────────────────────────────────────────────────
+export function dumpInteractionTrace(entries, n = 50) {
+    if (entries.length === 0)
+        return '(no interactions recorded)';
+    const tail = entries.slice(-n);
+    const now = performance.now();
+    return tail.map((e) => renderTraceEntry(e, now)).join('\n');
+}
+function renderTraceEntry(e, now) {
+    const base = `[${Math.round(now - e.t)}ms ago] ${e.site}/${e.kind}`;
+    if (!e.detail)
+        return base;
+    const detail = Object.entries(e.detail)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(' ');
+    return detail ? `${base} ${detail}` : base;
+}
+/** Detail fields worth printing, per op. An op whose detail carries nothing a reader needs
+ *  is simply absent; a variant missing any listed field prints none of them. */
+const DETAIL_FIELDS = {
+    split: ['at'],
+    merge: ['direction'],
+    updateContent: ['length'],
+    replaceBlock: ['count'],
+    tableInsertRow: ['rowIdx', 'side'],
+    tableDeleteRow: ['rowIdx'],
+    tableInsertColumn: ['colIdx', 'side'],
+    tableDeleteColumn: ['colIdx'],
+    tableCycleAlignment: ['colIdx']
+};
+function renderDetail(e) {
+    const fields = DETAIL_FIELDS[e.op];
+    if (!fields || fields.some((f) => e.detail[f] === undefined))
+        return '';
+    return fields.map((f) => `${f}=${e.detail[f]}`).join(' ');
+}

package/dist/debug/interaction-trace.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Bounded ring buffer of the inline layer's transient state transitions, read through the debug
+ * panel and `getDiagnostics()`. Unlike `perf/instruments.ts` it arms from anywhere, production
+ * included, so a consumer app can attach it to a bug report — which is why entries carry cheap
+ * primitives ONLY, never node references or raw document text. The buffer is module-global, so
+ * two editors on one page interleave.
+ */
+export interface InteractionTraceEntry {
+    /** `performance.now()` at record time — monotonic, no wall clock. */
+    t: number;
+    site: string;
+    kind: string;
+    detail?: Record<string, string | number | boolean>;
+}
+export declare function enableInteractionTrace(): void;
+export declare function disableInteractionTrace(): void;
+export declare function isInteractionTraceEnabled(): boolean;
+/** Empty the buffer without touching the enabled flag — test isolation. */
+export declare function resetInteractionTrace(): void;
+export declare function interactionTraceSnapshot(): InteractionTraceEntry[];
+/** `changed` names the differing render-key segments, comma-joined. */
+export declare function traceRebuild(changed: string, force: boolean): void;
+export declare function traceCursorCapture(walk: number): void;
+export declare function traceCursorRestore(walk: number): void;
+export declare function tracePendingCursorSet(source: string, offset: number | null): void;
+/** `applied` false = the block lost focus before the effect ran, so the caret restore was
+ *  legally skipped. */
+export declare function tracePendingCursorConsume(offset: number, applied: boolean): void;
+/** `construct` carries a `kind:start-end` descriptor; other tiers record the tier alone. */
+export declare function traceRevealOpen(tier: 'inline' | 'leaf' | 'construct', construct?: string): void;
+export type RevealFoldReason = 'commit' | 'cancel' | 'no-edit' | 'selection-escape' | 'blur' | 'caret-exit';
+export declare function traceRevealFold(reason: RevealFoldReason, construct?: string): void;
+/** One record per rebuild bracket, counted inside the pool rather than per widget. */
+export declare function tracePoolPass(adopt: number, build: number, destroyed: number): void;
+export declare function traceCompositionStart(): void;
+export declare function traceCompositionEnd(): void;
+export declare function traceIslandsApplied(count: number): void;
+export declare function traceStickyCapture(x: number): void;
+export declare function traceStickyReset(): void;

package/dist/debug/interaction-trace.js

@@ -0,0 +1,105 @@
+/**
+ * Bounded ring buffer of the inline layer's transient state transitions, read through the debug
+ * panel and `getDiagnostics()`. Unlike `perf/instruments.ts` it arms from anywhere, production
+ * included, so a consumer app can attach it to a bug report — which is why entries carry cheap
+ * primitives ONLY, never node references or raw document text. The buffer is module-global, so
+ * two editors on one page interleave.
+ */
+const CAPACITY = 200;
+let enabled = false;
+let buf = [];
+// ── Switch and readout ──────────────────────────────────────────────────────
+export function enableInteractionTrace() {
+    enabled = true;
+}
+export function disableInteractionTrace() {
+    enabled = false;
+}
+export function isInteractionTraceEnabled() {
+    return enabled;
+}
+/** Empty the buffer without touching the enabled flag — test isolation. */
+export function resetInteractionTrace() {
+    buf = [];
+}
+export function interactionTraceSnapshot() {
+    return buf.slice();
+}
+function record(site, kind, detail) {
+    buf.push({ t: performance.now(), site, kind, detail });
+    if (buf.length > CAPACITY)
+        buf.splice(0, buf.length - CAPACITY);
+}
+// ── Recorders (one per transition family) ────────────────────────────────────
+// Every recorder opens with the disabled gate. Detail assembly that would allocate stays
+// behind an `isInteractionTraceEnabled()` guard at the call site.
+/** `changed` names the differing render-key segments, comma-joined. */
+export function traceRebuild(changed, force) {
+    if (!enabled)
+        return;
+    record('text-render', 'rebuild', { changed, force });
+}
+export function traceCursorCapture(walk) {
+    if (!enabled)
+        return;
+    record('text-render', 'cursor-capture', { walk });
+}
+export function traceCursorRestore(walk) {
+    if (!enabled)
+        return;
+    record('text-render', 'cursor-restore', { walk });
+}
+export function tracePendingCursorSet(source, offset) {
+    if (!enabled)
+        return;
+    record('pending-cursor', 'set', { source, offset: offset ?? -1, cleared: offset === null });
+}
+/** `applied` false = the block lost focus before the effect ran, so the caret restore was
+ *  legally skipped. */
+export function tracePendingCursorConsume(offset, applied) {
+    if (!enabled)
+        return;
+    record('pending-cursor', 'consume', { offset, applied });
+}
+/** `construct` carries a `kind:start-end` descriptor; other tiers record the tier alone. */
+export function traceRevealOpen(tier, construct) {
+    if (!enabled)
+        return;
+    record('reveal', 'open', construct === undefined ? { tier } : { tier, construct });
+}
+export function traceRevealFold(reason, construct) {
+    if (!enabled)
+        return;
+    record('reveal', 'fold', construct === undefined ? { reason } : { reason, construct });
+}
+/** One record per rebuild bracket, counted inside the pool rather than per widget. */
+export function tracePoolPass(adopt, build, destroyed) {
+    if (!enabled)
+        return;
+    record('widget-pool', 'pass', { adopt, build, destroyed });
+}
+export function traceCompositionStart() {
+    if (!enabled)
+        return;
+    record('composition', 'start');
+}
+export function traceCompositionEnd() {
+    if (!enabled)
+        return;
+    record('composition', 'end');
+}
+export function traceIslandsApplied(count) {
+    if (!enabled)
+        return;
+    record('text-render', 'islands', { count });
+}
+export function traceStickyCapture(x) {
+    if (!enabled)
+        return;
+    record('sticky-column', 'capture', { x });
+}
+export function traceStickyReset() {
+    if (!enabled)
+        return;
+    record('sticky-column', 'reset');
+}

package/dist/debug/operations-log.d.ts

@@ -0,0 +1,14 @@
+import type { OperationKind } from '../schema/operations';
+export interface OperationEntry {
+    op: OperationKind;
+    path: number[];
+    detail: Record<string, unknown>;
+    t: number;
+}
+export interface OperationsLog {
+    record(entry: Omit<OperationEntry, 't'>): void;
+    snapshot(): OperationEntry[];
+    subscribe(listener: (entry: OperationEntry) => void): () => void;
+}
+/** Bounded FIFO; oldest entries evicted past `capacity`. */
+export declare function createOperationsLog(capacity?: number): OperationsLog;

package/dist/debug/operations-log.js

@@ -0,0 +1,30 @@
+import { devWarn } from '../dev-warn';
+/** Bounded FIFO; oldest entries evicted past `capacity`. */
+export function createOperationsLog(capacity = 100) {
+    const buf = [];
+    const listeners = new Set();
+    return {
+        record(entry) {
+            const stamped = { ...entry, t: Date.now() };
+            buf.push(stamped);
+            if (buf.length > capacity)
+                buf.splice(0, buf.length - capacity);
+            // Snapshot before iterating so a self-disposing subscriber doesn't abort the loop.
+            for (const l of [...listeners]) {
+                try {
+                    l(stamped);
+                }
+                catch (err) {
+                    devWarn('operations-log', 'subscriber threw while handling entry', err);
+                }
+            }
+        },
+        snapshot() {
+            return buf.slice();
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        }
+    };
+}

package/dist/decorations/buckets.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Per-run indexes of a merged decoration set, built once when the set changes so each
+ * overlay reads only its own bucket instead of scanning every decoration per render.
+ */
+import type { Decoration, MarkDecoration } from './types';
+/** A decoration paired with its flat-list position — the stable key overlays render against. */
+export interface IndexedDecoration<D extends Decoration = Decoration> {
+    dec: D;
+    index: number;
+}
+/** Stable key for a block path; distinct paths never collide, elements being numbers. */
+export declare function pathKey(path: readonly number[]): string;
+/** Bucket `{ path }`-bearing items by block path, preserving flat order. Shared by
+ *  decorations and search. */
+export declare function groupByPathKey<T extends {
+    path: readonly number[];
+}, E>(items: readonly T[], wrap: (item: T, index: number) => E): Map<string, E[]>;
+/** Group decorations by owning leaf path, preserving each one's flat index. */
+export declare function groupDecorationsByPath(decs: readonly Decoration[]): Map<string, IndexedDecoration[]>;
+/**
+ * Group decorations under every strict ancestor prefix of their owning path. Grid
+ * surfaces paint descendant cell decorations themselves, cells having no BlockHost
+ * overlay, so this lets them read one bucket instead of the full list.
+ */
+export declare function groupDecorationsByAncestor(decs: readonly Decoration[]): Map<string, IndexedDecoration[]>;
+/** One whole-cell rect: the union of every mark's class tokens, plus a representative
+ *  decoration for the rect's attrs/interactive. */
+export interface CollapsedCellMark {
+    rowIdx: number;
+    colIdx: number;
+    class: string;
+    dec: MarkDecoration;
+}
+/**
+ * Collapse a grid's descendant cell marks to one entry per `(row, col)`, unioning their
+ * class tokens so two sources in one cell cascade-compose instead of stacking translucent
+ * rects. `containerDepth` is the grid container's path length; the cell coordinates sit at
+ * `path[depth]` and `path[depth + 1]`.
+ */
+export declare function collapseCellMarks(descMarks: readonly IndexedDecoration<MarkDecoration>[], containerDepth: number): CollapsedCellMark[];

package/dist/decorations/buckets.js

@@ -0,0 +1,87 @@
+/**
+ * Per-run indexes of a merged decoration set, built once when the set changes so each
+ * overlay reads only its own bucket instead of scanning every decoration per render.
+ */
+/** Stable key for a block path; distinct paths never collide, elements being numbers. */
+export function pathKey(path) {
+    return path.join(',');
+}
+/** Bucket `{ path }`-bearing items by block path, preserving flat order. Shared by
+ *  decorations and search. */
+export function groupByPathKey(items, wrap) {
+    const buckets = new Map();
+    items.forEach((item, index) => {
+        const key = pathKey(item.path);
+        const bucket = buckets.get(key);
+        if (bucket)
+            bucket.push(wrap(item, index));
+        else
+            buckets.set(key, [wrap(item, index)]);
+    });
+    return buckets;
+}
+/** Group decorations by owning leaf path, preserving each one's flat index. */
+export function groupDecorationsByPath(decs) {
+    return groupByPathKey(decs, (dec, index) => ({ dec, index }));
+}
+/**
+ * Group decorations under every strict ancestor prefix of their owning path. Grid
+ * surfaces paint descendant cell decorations themselves, cells having no BlockHost
+ * overlay, so this lets them read one bucket instead of the full list.
+ */
+export function groupDecorationsByAncestor(decs) {
+    const byAncestor = new Map();
+    decs.forEach((dec, index) => {
+        for (let len = 1; len < dec.path.length; len++) {
+            push(byAncestor, pathKey(dec.path.slice(0, len)), dec, index);
+        }
+    });
+    return byAncestor;
+}
+function push(map, key, dec, index) {
+    const bucket = map.get(key);
+    if (bucket)
+        bucket.push({ dec, index });
+    else
+        map.set(key, [{ dec, index }]);
+}
+/**
+ * Collapse a grid's descendant cell marks to one entry per `(row, col)`, unioning their
+ * class tokens so two sources in one cell cascade-compose instead of stacking translucent
+ * rects. `containerDepth` is the grid container's path length; the cell coordinates sit at
+ * `path[depth]` and `path[depth + 1]`.
+ */
+export function collapseCellMarks(descMarks, containerDepth) {
+    const byCell = new Map();
+    for (const { dec } of descMarks) {
+        const rowIdx = dec.path[containerDepth];
+        const colIdx = dec.path[containerDepth + 1];
+        if (rowIdx == null || colIdx == null)
+            continue;
+        const cell = byCell.get(`${rowIdx},${colIdx}`);
+        if (cell) {
+            addClassTokens(cell.classes, dec.class);
+            cell.dec = dec;
+        }
+        else {
+            byCell.set(`${rowIdx},${colIdx}`, {
+                rowIdx,
+                colIdx,
+                classes: addClassTokens(new Set(), dec.class),
+                dec
+            });
+        }
+    }
+    return [...byCell.values()].map(({ rowIdx, colIdx, classes, dec }) => ({
+        rowIdx,
+        colIdx,
+        class: [...classes].join(' '),
+        dec
+    }));
+}
+function addClassTokens(set, cls) {
+    for (const token of cls.split(/\s+/))
+        if (token)
+            set.add(token);
+    return set;
+}

package/dist/decorations/decoration-state.svelte.d.ts

@@ -0,0 +1,20 @@
+import type { DocumentView } from '../core/node-views';
+import { type IndexedDecoration } from './buckets';
+import type { BlockDecoration, DecorationSource, DecorationSourceHandle, MarkDecoration, ReplaceDecoration, WidgetDecoration } from './types';
+export interface DecorationEngineDeps {
+    getDoc: () => DocumentView;
+    onSourceError?: (sourceName: string, error: unknown) => void;
+}
+export type DecorationEngine = {
+    addSource(source: DecorationSource): DecorationSourceHandle;
+    readonly sourceCount: number;
+    /** Bump the edit epoch, then re-run every provide. `handle.invalidate()` re-runs one
+     *  source WITHOUT the bump, which is what lets a memoized source tell "document
+     *  changed" from "my own state changed". */
+    notifyEdit(): void;
+    marksForPath(path: number[]): IndexedDecoration<MarkDecoration>[];
+    marksForDescendants(path: number[]): IndexedDecoration<MarkDecoration>[];
+    islandsForPath(path: number[]): IndexedDecoration<WidgetDecoration | ReplaceDecoration>[];
+    blockDecorationsForPath(path: number[]): BlockDecoration[];
+};
+export declare function createDecorationEngine(deps: DecorationEngineDeps): DecorationEngine;