@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/cursor/edge-affinity.d.ts

@@ -1,44 +1,16 @@
 /**
  * Edge affinity: which of the two raw offsets a caret means when it sits beside a hidden
- * marker run, whose interior paints nothing so both offsets land on one pixel. CAPTURE: the
- * arrival that put the caret there, via `note` on the shared keydown door. CONSUME: the
- * typing seat, which reads `get()` and keeps its own default when it answers null.
+ * marker run, whose interior paints nothing so both offsets land on one pixel. The caret memory
+ * (`cursor/caret-memory.ts`) holds the answer; this module decides it from the key.
  */
 /**
- * Which raw offset a hidden run's one pixel names. Two answers are positional — the run's
- * `near` (earlier) or `far` (later) walk-order side — and one is construct-relative:
- * `outside` means past the construct's delimiters whichever side that lands on, so it reads
- * as the run's start at an opener and its end at a closer.
+ * Which raw offset a hidden run's one pixel names. Two answers are positional, the run's `near`
+ * (earlier) or `far` (later) side in walk order, and one is relative to the construct: `outside`
+ * means past the construct's delimiters whichever side that is, so it reads as the run's start
+ * at an opener and its end at a closer.
  */
 export type EdgeAffinity = 'near' | 'far' | 'outside';
-export interface EdgeAffinityState {
-    get(): EdgeAffinity | null;
-    /**
-     * The only door a keydown handler may use; `reset()` stays public for the lifecycle,
-     * commit, undo and pointer callers, whose unconditional clear has no key to classify.
-     */
-    note(e: Pick<KeyboardEvent, 'key' | 'altKey'> & Partial<Pick<KeyboardEvent, 'metaKey'>>): void;
-    /** A committed keystroke belongs to the content whatever arrival preceded it. */
-    noteTyping(): void;
-    /**
-     * A caret seated at an EXTREME rather than stepped there — a range collapsing onto its own
-     * edge. The key that triggered it is directional, but the caret took no step, so the side it
-     * means is construct-relative, the same answer a line extreme gives.
-     */
-    noteExtreme(): void;
-    reset(): void;
-}
-export interface EdgeAffinityDeps {
-    /**
-     * Ephemeral caret state with this same lifetime rides the invalidation (pending marks,
-     * `cursor/pending-marks.ts`). Composed rather than copied at each seam: every seat below
-     * already reaches exactly one of these three doors.
-     */
-    onInvalidate?: () => void;
-}
-export declare function createEdgeAffinityState(deps?: EdgeAffinityDeps): EdgeAffinityState;
 /** What a keydown does to the affinity. */
 export type EdgeAffinityAction = EdgeAffinity | 'preserve' | 'reset';
-/** The decision {@link EdgeAffinityState.note} enacts. Pure on the key, so the matrix is
- *  testable without a DOM or a state instance. */
+/** Pure on the key, so the matrix is testable without a DOM or a memory instance. */
 export declare function classifyArrivalKey(key: string, metaKey?: boolean): EdgeAffinityAction;

package/dist/cursor/edge-affinity.js

@@ -1,61 +1,30 @@
 /**
  * Edge affinity: which of the two raw offsets a caret means when it sits beside a hidden
- * marker run, whose interior paints nothing so both offsets land on one pixel. CAPTURE: the
- * arrival that put the caret there, via `note` on the shared keydown door. CONSUME: the
- * typing seat, which reads `get()` and keeps its own default when it answers null.
+ * marker run, whose interior paints nothing so both offsets land on one pixel. The caret memory
+ * (`cursor/caret-memory.ts`) holds the answer; this module decides it from the key.
  */
 import { BARE_MODIFIER_KEYS, isCharacterKey } from '../schema/keybindings';
-export function createEdgeAffinityState(deps = {}) {
-    let affinity = null;
-    /** Sets the side AND settles everything riding on it — the two are one act, so no caller
-     *  can do the first without the second. */
-    function settle(next) {
-        affinity = next;
-        deps.onInvalidate?.();
-    }
-    return {
-        get: () => affinity,
-        noteTyping: () => settle('near'),
-        noteExtreme: () => settle('outside'),
-        reset: () => settle(null),
-        note: (e) => {
-            // Alt+Arrow is the block-reorder chord, not caret nav.
-            if (e.altKey && (e.key === 'ArrowUp' || e.key === 'ArrowDown'))
-                return;
-            const action = classifyArrivalKey(e.key, e.metaKey);
-            // A preserved key left the caret where it was — the chord that pends a mark and the
-            // byte that spends it are both preserved, so neither may invalidate.
-            if (action === 'preserve')
-                return;
-            settle(action === 'reset' ? null : action);
-        }
-    };
-}
-/** The decision {@link EdgeAffinityState.note} enacts. Pure on the key, so the matrix is
- *  testable without a DOM or a state instance. */
+/** Pure on the key, so the matrix is testable without a DOM or a memory instance. */
 export function classifyArrivalKey(key, metaKey = false) {
-    // macOS Cmd+Arrow is the line extreme — a seat, not a step, so it takes Home/End's
-    // construct-relative answer. Windows/Linux never deliver meta+arrow to the page.
+    // macOS Cmd+Arrow jumps to the line's end, a placement rather than a step, so it takes
+    // Home/End's answer. Windows and Linux never deliver meta+arrow to the page.
     if (metaKey && (key === 'ArrowLeft' || key === 'ArrowRight'))
         return 'outside';
-    // A step stops on the side of the run it approached from, so one press never changes which
-    // construct the caret is in (live-mode.md § 4.2); leaving a construct is a typed closer's job
-    // (delimiter-autopair.ts) or a toggle's, not the arrow's.
+    // A step stops on the side of the run it came from, so one keypress never changes which construct
+    // the caret is in (`docs/design/live-mode.md` § 4.2 Typing at a hidden edge).
     if (key === 'ArrowRight' || key === 'ArrowDown' || key === 'PageDown')
         return 'near';
     if (key === 'ArrowLeft' || key === 'ArrowUp' || key === 'PageUp')
         return 'far';
-    // A line extreme is construct-relative, not directional: `Home` before a line-leading
-    // construct means before its opener, which is the run's EARLIER side — the opposite
-    // walk-order answer from `End` after a line-trailing one.
+    // Home and End are relative to the construct: `Home` before a construct starting the line means
+    // before its opener, the run's earlier side, the opposite of `End` after one ending the line.
     if (key === 'Home' || key === 'End')
         return 'outside';
-    // Bare modifiers are read from the chord parser rather than re-listed — a local copy
-    // missing AltGraph is how a modifier tap mid-arrow-run drops the side. A printable key
-    // preserves because its write seat reads the side later in this same keydown.
+    // Bare modifiers come from the key-combination parser, which knows AltGraph. A printable key
+    // preserves because the typing path reads the side later in this same keydown.
     if (BARE_MODIFIER_KEYS.includes(key) || isCharacterKey(key))
         return 'preserve';
-    // Anything left lands by a mutation or a command, not by an arrival; the commit seams
-    // re-arm through `noteTyping`.
+    // Anything left moves the caret by a mutation or a command, not by a key; the commit path
+    // sets the side again through `noteTyping`.
     return 'reset';
 }

package/dist/cursor/focused-caret.d.ts

@@ -1,10 +1,8 @@
 /**
- * Carry a focused caret across an imperative DOM rebuild. A decoration-driven rebuild
- * mints fresh spans with no edit-path pending offset, so the render path captures the
- * caret in walk space before the rebuild and restores it after — through the single-home
- * offset walk (`widget-offset.ts`), shared by the prose and table-cell render paths.
+ * Keep a focused caret across an imperative DOM rebuild: a decoration-driven rebuild creates
+ * fresh spans with no pending offset from an edit, so the render path reads the caret as a raw
+ * offset before the rebuild and writes it back after (`placeCaretAtRaw`, exact).
  */
-import type { DomTextOffset } from './coordinate-spaces';
-/** The live caret as a walk-space offset, or null when `el` does not own focus. */
-export declare function captureFocusedCaretWalkOffset(el: HTMLElement): DomTextOffset | null;
-export declare function restoreCaretAtWalkOffset(el: HTMLElement, walkOffset: DomTextOffset): void;
+import type { RawOffset } from './coordinate-spaces';
+/** The live caret as a raw offset, or null when `el` does not own focus. */
+export declare function captureFocusedCaret(el: HTMLElement): RawOffset | null;

package/dist/cursor/focused-caret.js

@@ -1,24 +1,15 @@
 /**
- * Carry a focused caret across an imperative DOM rebuild. A decoration-driven rebuild
- * mints fresh spans with no edit-path pending offset, so the render path captures the
- * caret in walk space before the rebuild and restores it after — through the single-home
- * offset walk (`widget-offset.ts`), shared by the prose and table-cell render paths.
+ * Keep a focused caret across an imperative DOM rebuild: a decoration-driven rebuild creates
+ * fresh spans with no pending offset from an edit, so the render path reads the caret as a raw
+ * offset before the rebuild and writes it back after (`placeCaretAtRaw`, exact).
  */
-import { createRangeAtDomTextOffsets, domTextOffsetAtNode } from './widget-offset';
-/** The live caret as a walk-space offset, or null when `el` does not own focus. */
-export function captureFocusedCaretWalkOffset(el) {
+import { rawOffsetAt } from './widget-offset';
+/** The live caret as a raw offset, or null when `el` does not own focus. */
+export function captureFocusedCaret(el) {
     if (!document.activeElement || !el.contains(document.activeElement))
         return null;
     const sel = window.getSelection();
     if (!sel?.focusNode || !el.contains(sel.focusNode))
         return null;
-    return domTextOffsetAtNode(el, sel.focusNode, sel.focusOffset);
-}
-export function restoreCaretAtWalkOffset(el, walkOffset) {
-    const range = createRangeAtDomTextOffsets(el, walkOffset, walkOffset);
-    if (!range)
-        return;
-    const sel = window.getSelection();
-    sel?.removeAllRanges();
-    sel?.addRange(range);
+    return rawOffsetAt(el, sel.focusNode, sel.focusOffset);
 }

package/dist/cursor/height-model.d.ts

@@ -1,7 +1,7 @@
 /**
- * Cumulative block-height model for one BlockList: a Fenwick tree giving O(log n)
- * prefix-sum, offset→index lookup, and per-index update. Virtual rendering maps scrollTop
- * to a window range through it without laying off-screen blocks out.
+ * The table of block heights for one BlockList: a Fenwick tree giving O(log n) prefix sums,
+ * offset-to-index lookup, and per-index update. Virtual rendering maps scrollTop to a mounted
+ * range through it without laying out off-screen blocks.
  */
 export declare class HeightModel {
     private tree;

package/dist/cursor/height-model.js

@@ -1,7 +1,7 @@
 /**
- * Cumulative block-height model for one BlockList: a Fenwick tree giving O(log n)
- * prefix-sum, offset→index lookup, and per-index update. Virtual rendering maps scrollTop
- * to a window range through it without laying off-screen blocks out.
+ * The table of block heights for one BlockList: a Fenwick tree giving O(log n) prefix sums,
+ * offset-to-index lookup, and per-index update. Virtual rendering maps scrollTop to a mounted
+ * range through it without laying out off-screen blocks.
  */
 export class HeightModel {
     tree; // 1-indexed Fenwick sums
@@ -23,7 +23,7 @@ export class HeightModel {
     }
     /** Pixel offset of the top of index `i` (sum of heights[0..i)); `offsetOf(count)` == total. */
     offsetOf(i) {
-        // prefix(i) past `count` reads off the Fenwick array → NaN into every spacer.
+        // prefix(i) past `count` reads off the end of the Fenwick array and puts NaN into every spacer.
         return this.prefix(Math.max(0, Math.min(i, this.count)));
     }
     /** Current height stored for index `i`. */
@@ -32,7 +32,7 @@ export class HeightModel {
     }
     /** Set index `i` to `height` in O(log n). No-op when unchanged or out of range. */
     setHeight(i, height) {
-        // Out of range corrupts the model: i >= count poisons heights[] with no tree update,
+        // Out of range corrupts the table: i >= count poisons heights[] with no tree update,
         // and i < 0 makes bump's `p += p & -p` stall at p=0 forever.
         if (i < 0 || i >= this.count)
             return;

package/dist/cursor/height-oracle.d.ts

@@ -1,7 +1,7 @@
 /**
- * Per-kind block-height estimator plus a measured-height cache for virtual rendering.
- * `estimate` is O(1) from `node.raw` length even for containers (their raw is
- * materialized, so no subtree walk). Measured heights supersede estimates and are keyed by
+ * Per-block height estimates plus a measured-height cache for virtual rendering. Each kind's
+ * descriptor makes the estimate (`schema/height-estimates.ts`), O(1) from `node.raw` even for
+ * containers, whose raw is materialized. Measured heights supersede estimates and are keyed by
  * stable block id, so structural index shifts and undo don't invalidate them.
  */
 import type { NodeView } from '../core/node-views';
@@ -16,8 +16,12 @@ export interface HeightOracle {
     estimate(node: NodeView, width: number): number;
     measured(id: string): number | undefined;
     recordMeasured(id: string, height: number): void;
-    /** Drop every measured height. A live scope carries its own across a rebuild (VR-15), so
-     *  estimates seed only a scope built after the drop, and any block with a fresh id. */
+}
+/** The editor's own estimator, which can also drop and list what it has measured. */
+export interface MeasuredHeightOracle extends HeightOracle {
+    /** Drop every measured height; only layout state calls it (G4.98). A mounted list keeps its
+     *  table's heights across a structural rebuild, so only a later list or a fresh id starts from estimates. */
     dropMeasured(): void;
+    measuredIds(): string[];
 }
-export declare function createHeightOracle(opts: HeightOracleOptions): HeightOracle;
+export declare function createHeightOracle(opts: HeightOracleOptions): MeasuredHeightOracle;

package/dist/cursor/height-oracle.js

@@ -1,86 +1,37 @@
 import { isCollapsedByDescriptor } from '../schema/reserved-chrome';
 import { tryGetBlockKindDescriptor } from '../schema/block-kind-descriptor';
-// Any image form, capturing the alt segment for its `|WxH` size hint. The char-based prose
-// estimate badly undercounts a rendered image, so an image-bearing block sizes off this.
-const IMAGE_ALT = /!\[([^\]]*)\]/g;
-// Size hint inside the alt, e.g. `Square|200x200` or `photo|400` (width only).
-const SIZE_HINT = /\|(\d+)(?:x(\d+))?/;
-const NEWLINE = 10;
+import { containerEstimate, proseEstimate } from '../schema/height-estimates';
 export function createHeightOracle(opts) {
     const measuredById = new Map();
-    function wrappedLines(visibleLen, width) {
-        const perLine = Math.max(1, Math.floor(width / opts.avgCharWidth));
-        return Math.max(1, Math.ceil(visibleLen / perLine));
-    }
-    function sourceLines(raw) {
-        let n = 1;
-        // Code units, not `raw[i]`: the indexed read mints a one-character string per byte.
-        for (let i = 0; i < raw.length; i++)
-            if (raw.charCodeAt(i) === NEWLINE)
-                n++;
-        if (raw.endsWith('\n'))
-            n--; // trailing newline shouldn't add a phantom line
-        return Math.max(1, n);
-    }
-    // Each image contributes its `|WxH` hint height, else the min-height floor — an unsized
-    // image isn't knowable until decode, which the ResizeObserver corrects post-mount.
-    function imageHeights(raw) {
-        let total = 0;
-        IMAGE_ALT.lastIndex = 0;
-        let m;
-        while ((m = IMAGE_ALT.exec(raw)) !== null) {
-            const hint = SIZE_HINT.exec(m[1]);
-            total += hint && hint[2] ? Number(hint[2]) : opts.imageBlockMinHeight;
+    // One object for every call, since the height table estimates each block of the document: the
+    // metrics read through to `opts`, whose getters follow the editor's type scale.
+    const env = {
+        width: 0,
+        get lineHeight() {
+            return opts.lineHeight;
+        },
+        get codeLineHeight() {
+            return opts.codeLineHeight;
+        },
+        get avgCharWidth() {
+            return opts.avgCharWidth;
+        },
+        get blockChrome() {
+            return opts.blockChrome;
+        },
+        get imageBlockMinHeight() {
+            return opts.imageBlockMinHeight;
         }
-        return total;
-    }
+    };
     function estimate(node, width) {
-        // One registry lookup, read twice: the model seeds this once per block of the document.
         const descriptor = tryGetBlockKindDescriptor(node.kind);
         // A collapsed container's body lives in `raw` but never renders, so estimating from
-        // full `raw` over-counts it several-fold; only the chrome row paints.
+        // full `raw` over-counts it several-fold; only the title row paints.
         if (isCollapsedByDescriptor(descriptor, node))
             return opts.lineHeight + opts.blockChrome;
-        // A descriptor's own O(1) estimate supersedes the built-in arms (a rendered artifact
-        // is far taller than its source text); the oracle still adds chrome.
-        const custom = descriptor?.estimateHeight;
-        if (custom)
-            return custom(node, { width }) + opts.blockChrome;
-        const kind = node.kind;
-        const raw = node.raw;
-        switch (kind) {
-            case 'thematicBreak':
-                return opts.lineHeight + opts.blockChrome;
-            case 'fencedCode':
-            case 'indentedCode':
-            case 'htmlBlock':
-                return sourceLines(raw) * opts.codeLineHeight + opts.blockChrome;
-            case 'table':
-            case 'tableRow':
-                // Source lines model a normal table; a wide one wraps its cells far beyond its
-                // row count, which the blob-wrap of the whole raw catches.
-                return (Math.max(sourceLines(raw), wrappedLines(raw.length, width)) * opts.lineHeight +
-                    opts.blockChrome);
-            case 'blockquote':
-            case 'list':
-            case 'listItem': {
-                // Max of two terms, each alone wrong: the blob term ignores newlines and
-                // per-child chrome, the child-count term ignores wrap. Still O(1), no walk.
-                const childCount = Math.max(1, node.children?.length ?? 1);
-                const byChildren = childCount * (opts.lineHeight + opts.blockChrome);
-                const byText = wrappedLines(raw.length, width) * opts.lineHeight + opts.blockChrome;
-                return Math.max(byChildren, byText);
-            }
-            default: {
-                const prose = wrappedLines(raw.length, width) * opts.lineHeight + opts.blockChrome;
-                // Substring test first: the alt-capturing scan otherwise runs over every prose
-                // block in the document, and all but a handful carry no image at all.
-                if (!raw.includes('!['))
-                    return prose;
-                const images = imageHeights(raw);
-                return images > 0 ? Math.max(prose, images) : prose;
-            }
-        }
+        const content = descriptor?.estimateHeight ?? (descriptor?.isContainer ? containerEstimate : proseEstimate);
+        env.width = width;
+        return content(node, env) + opts.blockChrome;
     }
     return {
         estimate,
@@ -88,6 +39,7 @@ export function createHeightOracle(opts) {
         recordMeasured: (id, height) => {
             measuredById.set(id, height);
         },
-        dropMeasured: () => measuredById.clear()
+        dropMeasured: () => measuredById.clear(),
+        measuredIds: () => [...measuredById.keys()]
     };
 }

package/dist/cursor/observe-resize.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Watches one element's size for a component that can mount while the browser delivers resize
+ * notifications. An element first observed during that delivery is skipped at its depth and
+ * reported as a ResizeObserver loop error, so observation starts at the next frame; the first
+ * notification then still carries the element's size as of that frame. Returns the disposer.
+ */
+export declare function observeResize(el: Element, onResize: ResizeObserverCallback): () => void;
+export interface SharedResizeWatch {
+    /** Watches `el` from the next frame on; returns the disposer. */
+    watch(el: Element, onResize: (entry: ResizeObserverEntry) => void): () => void;
+}
+/** One observer for many elements, each watched from the next frame, made after the width watcher. */
+export declare function createSharedResizeWatch(): SharedResizeWatch;

package/dist/cursor/observe-resize.js

@@ -0,0 +1,43 @@
+/**
+ * Watches one element's size for a component that can mount while the browser delivers resize
+ * notifications. An element first observed during that delivery is skipped at its depth and
+ * reported as a ResizeObserver loop error, so observation starts at the next frame; the first
+ * notification then still carries the element's size as of that frame. Returns the disposer.
+ */
+export function observeResize(el, onResize) {
+    // jsdom has no ResizeObserver; callers keep their other measuring paths there.
+    if (typeof ResizeObserver !== 'function')
+        return () => { };
+    const observer = new ResizeObserver(onResize);
+    const frame = requestAnimationFrame(() => observer.observe(el));
+    return () => {
+        cancelAnimationFrame(frame);
+        observer.disconnect();
+    };
+}
+/** One observer for many elements, each watched from the next frame, made after the width watcher. */
+export function createSharedResizeWatch() {
+    const listeners = new Map();
+    let observer = null;
+    const deliver = (entries) => {
+        for (const entry of entries)
+            listeners.get(entry.target)?.(entry);
+    };
+    return {
+        watch(el, onResize) {
+            if (typeof ResizeObserver !== 'function')
+                return () => { };
+            listeners.set(el, onResize);
+            const frame = requestAnimationFrame(() => {
+                observer ??= new ResizeObserver(deliver);
+                observer.observe(el);
+            });
+            return () => {
+                cancelAnimationFrame(frame);
+                observer?.unobserve(el);
+                if (listeners.get(el) === onResize)
+                    listeners.delete(el);
+            };
+        }
+    };
+}

package/dist/cursor/overlay-rects.d.ts

@@ -1,8 +1,5 @@
 /** The client rects a block contributes when it is an endpoint of a cross-block selection. */
 import type { DomTextOffset } from './coordinate-spaces';
-/**
- * Client rects covering the walk-space range [startOffset, endOffset) within `el` (see
- * `cursor/widget-offset.ts`). The `getClientRects` guard keeps jsdom unit tests from
- * crashing; real pixel geometry is covered by e2e.
- */
+/** Client rects covering the DOM-walk range [startOffset, endOffset) within `el`. The
+ *  `getClientRects` check keeps jsdom unit tests from crashing. */
 export declare function measurePartialRectsInContentEditable(el: HTMLElement, startOffset: DomTextOffset, endOffset: DomTextOffset): DOMRect[];

package/dist/cursor/overlay-rects.js

@@ -1,10 +1,7 @@
 /** The client rects a block contributes when it is an endpoint of a cross-block selection. */
 import { createRangeAtDomTextOffsets, widgetsIntersectingRange } from './widget-offset';
-/**
- * Client rects covering the walk-space range [startOffset, endOffset) within `el` (see
- * `cursor/widget-offset.ts`). The `getClientRects` guard keeps jsdom unit tests from
- * crashing; real pixel geometry is covered by e2e.
- */
+/** Client rects covering the DOM-walk range [startOffset, endOffset) within `el`. The
+ *  `getClientRects` check keeps jsdom unit tests from crashing. */
 export function measurePartialRectsInContentEditable(el, startOffset, endOffset) {
     if (startOffset === endOffset)
         return [];

package/dist/cursor/overlay-remeasure.d.ts

@@ -1,8 +1,8 @@
 /**
- * Shared scroll-listener wiring for DecorationOverlay and SelectionOverlay: measure on
- * mount, on scroll, and on the table's row-window `$derived` moving. That third trigger is
- * load-bearing for windowed tables — a raw 'scroll' fires BEFORE the windowed `{#each}`
- * mounts the new rows, so only the dep-based re-run measures post-commit.
+ * Shared scroll-listener wiring for DecorationOverlay and SelectionOverlay: measure on mount, on
+ * scroll, and when the table's row-window `$derived` moves. Windowed tables need that third
+ * trigger: a raw 'scroll' fires before the windowed `{#each}` mounts the new rows, so only the
+ * dependency-driven re-run measures after the commit.
  */
 import type { BlockComponent } from '../block-component';
 export declare function wireOverlayRemeasure(opts: {
@@ -10,8 +10,7 @@ export declare function wireOverlayRemeasure(opts: {
     editorRoot: HTMLElement | null;
     blockRef: BlockComponent | undefined;
     measure: () => void;
-    /** Run the SETUP measure untracked, for a caller whose `measure` reads the document: tracking
-     *  it would tear down and re-wire these listeners on every keystroke. Scoped to that one call,
-     *  never the whole wiring — the row-window read below must stay tracked either way. */
+    /** Run the setup measure untracked, so a `measure` that reads the document doesn't re-wire these
+     *  listeners on every keystroke. Only that call: the row-window read below must stay tracked. */
     untrackSetupMeasure?: boolean;
 }): () => void;

package/dist/cursor/overlay-remeasure.js

@@ -1,15 +1,16 @@
 /**
- * Shared scroll-listener wiring for DecorationOverlay and SelectionOverlay: measure on
- * mount, on scroll, and on the table's row-window `$derived` moving. That third trigger is
- * load-bearing for windowed tables — a raw 'scroll' fires BEFORE the windowed `{#each}`
- * mounts the new rows, so only the dep-based re-run measures post-commit.
+ * Shared scroll-listener wiring for DecorationOverlay and SelectionOverlay: measure on mount, on
+ * scroll, and when the table's row-window `$derived` moves. Windowed tables need that third
+ * trigger: a raw 'scroll' fires before the windowed `{#each}` mounts the new rows, so only the
+ * dependency-driven re-run measures after the commit.
  */
 import { untrack } from 'svelte';
 import { firstScrollableDescendant, nearestScrollContainer } from './scroll-ancestors';
+import { observeResize } from './observe-resize';
 export function wireOverlayRemeasure(opts) {
     const { el, editorRoot, blockRef, measure } = opts;
-    // Plain synchronous read so the enclosing $effect registers as a dep of the table's win
-    // $derived. Must NOT be inside untrack().
+    // Plain synchronous read so the enclosing $effect depends on the table's row-window
+    // $derived; it must not be inside untrack().
     blockRef?.mountedRowWindow?.();
     if (opts.untrackSetupMeasure)
         untrack(measure);
@@ -27,13 +28,8 @@ export function wireOverlayRemeasure(opts) {
         editorRoot.addEventListener('scroll', measure, { passive: true });
         disposers.push(() => editorRoot.removeEventListener('scroll', measure));
     }
-    // The block's own box changing under a live range — a paragraph set to a heading, a font
-    // load, a resize — moves the text the rects were measured against. Layout-driven, so it
-    // fires after the change has painted; absent (jsdom) the scroll paths above still hold.
-    if (typeof ResizeObserver === 'function') {
-        const observer = new ResizeObserver(() => measure());
-        observer.observe(el);
-        disposers.push(() => observer.disconnect());
-    }
+    // The block's own box changing under a live range (a paragraph set to a heading, a font
+    // load) moves the text the rects were measured against.
+    disposers.push(observeResize(el, () => measure()));
     return () => disposers.forEach((dispose) => dispose());
 }

package/dist/cursor/pending-marks.d.ts

@@ -1,12 +1,12 @@
 /**
- * Pending marks: the inline constructs a collapsed-caret toggle promises the NEXT insertion,
- * relative to the caret's construct chain — a kind already in the chain is a removal, one absent
- * is an application. Live mode paints no delimiter, so materializing an empty pair in the bytes
- * would leave invisible `****` behind on an abandoned toggle. SET by the toggle command, CONSUMED
- * by the typing and composition seats, INVALIDATED by the edge affinity (live-mode.md § 4.3).
+ * Pending marks: the inline formats a toggle at a collapsed caret promises the next insertion,
+ * relative to the constructs around the caret (a kind already active is a removal, one absent is
+ * an application). Live mode paints no delimiter, so writing an empty pair into the bytes would
+ * leave an invisible `****` behind on an abandoned toggle. The toggle command sets them, the typing
+ * and composition paths consume them, and the caret memory drops them (live-mode.md § 4.3).
  */
 import type { InlineMarkKind } from '../schema/inline-construct-policy';
-export interface PendingMarksState {
+export interface PendingMarks {
     /** Null when nothing is pending; never an empty set, so a read is the whole question. */
     get(): ReadonlySet<InlineMarkKind> | null;
     /** A toggle chord at a collapsed caret. The same chord twice pends nothing again. */
@@ -16,9 +16,7 @@ export interface PendingMarksState {
     /** Hand back a set taken for an insertion that never happened (an IME cancel). Declines once
      *  anything else is pending: that is a newer instruction about the same caret. */
     restore(marks: ReadonlySet<InlineMarkKind>): void;
-    reset(): void;
 }
-export declare function createPendingMarksState(): PendingMarksState;
-/** The set a chord press produces, or null once it empties. Pure, so the toggle matrix is
+/** The set one toggle chord produces, or null once it empties. Pure, so the toggle matrix is
  *  testable without an instance. */
 export declare function flipMark(marks: ReadonlySet<InlineMarkKind> | null, kind: InlineMarkKind): ReadonlySet<InlineMarkKind> | null;

package/dist/cursor/pending-marks.js

@@ -1,32 +1,11 @@
 /**
- * Pending marks: the inline constructs a collapsed-caret toggle promises the NEXT insertion,
- * relative to the caret's construct chain — a kind already in the chain is a removal, one absent
- * is an application. Live mode paints no delimiter, so materializing an empty pair in the bytes
- * would leave invisible `****` behind on an abandoned toggle. SET by the toggle command, CONSUMED
- * by the typing and composition seats, INVALIDATED by the edge affinity (live-mode.md § 4.3).
+ * Pending marks: the inline formats a toggle at a collapsed caret promises the next insertion,
+ * relative to the constructs around the caret (a kind already active is a removal, one absent is
+ * an application). Live mode paints no delimiter, so writing an empty pair into the bytes would
+ * leave an invisible `****` behind on an abandoned toggle. The toggle command sets them, the typing
+ * and composition paths consume them, and the caret memory drops them (live-mode.md § 4.3).
  */
-export function createPendingMarksState() {
-    let marks = null;
-    return {
-        get: () => marks,
-        toggle: (kind) => {
-            marks = flipMark(marks, kind);
-        },
-        consume: () => {
-            const spent = marks;
-            marks = null;
-            return spent;
-        },
-        restore: (unspent) => {
-            if (marks === null)
-                marks = unspent;
-        },
-        reset: () => {
-            marks = null;
-        }
-    };
-}
-/** The set a chord press produces, or null once it empties. Pure, so the toggle matrix is
+/** The set one toggle chord produces, or null once it empties. Pure, so the toggle matrix is
  *  testable without an instance. */
 export function flipMark(marks, kind) {
     const next = new Set(marks ?? []);