@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/reactivity/block-list-state.svelte.js

@@ -1,14 +1,14 @@
 /**
- * A container's inner BlockList scope: the keyed-each id source and the component-ref slot
- * array. Structural mutations route through the commit primitives on UndoController, which
- * apply `StructuralChange` descriptors to keep ids/refs aligned with children.
+ * A container's inner block list: where its keyed-each ids come from and where its child
+ * component refs are stored. Structural changes go through the commit calls on
+ * `UndoController`, which apply a `StructuralChange` to keep ids and refs lined up with the
+ * children.
  */
 import { assignIds } from '../block-id';
 import { registerBlockListState } from './state-registry';
 import { refSlotsOver } from './publish-ref.svelte';
-/** `getNode` must be a live getter — by-value freezes on the initial node and misses
- *  undo's deep-clone reassignment. A view suffices: the only writes target `childIds`,
- *  the bytes-view carve-out. */
+/** `getNode` must be a live getter: a node passed by value goes stale when undo swaps in a deep
+ *  clone. A view is enough, since `childIds` is the only field written. */
 export function createBlockListState(getNode) {
     const initialNode = getNode();
     if (!initialNode.childIds) {
@@ -34,9 +34,8 @@ export function createBlockListState(getNode) {
             node.childIds = assignIds(node.children ?? []);
         }
         registerBlockListState(node, state);
-        // A parent-scope replace can reuse this instance with a node prop that has fewer
-        // children than before. Publish cleanup empties departing slots but never shrinks
-        // the array, and refs length must track children exactly, so reconcile it here.
+        // A replacement in the parent list can reuse this instance with fewer children, and ref
+        // cleanup empties entries without shrinking the array; the refs must match the children.
         const childCount = node.children?.length ?? 0;
         if (innerBlockRefs.length > childCount) {
             innerBlockRefs.length = childCount;

package/dist/reactivity/block-window.svelte.d.ts

@@ -1,5 +1,5 @@
 import type { HeightModel } from '../cursor/height-model';
-import type { Scrollport } from '../cursor/scrollport';
+import type { ScrollportReader } from '../cursor/scrollport';
 export interface WindowInputs {
     scrollTop: number;
     viewportHeight: number;
@@ -16,15 +16,22 @@ export interface WindowResult {
     end: number;
     topSpacerPx: number;
     bottomSpacerPx: number;
+    /** The table's height for the whole list, which `useWindowFloor` holds the list's box at while
+     *  the window changes; 0 when not windowing. */
+    floorPx: number;
 }
 export declare function computeWindow(model: HeightModel, input: WindowInputs): WindowResult;
 export interface BlockWindowDeps {
     getModel: () => HeightModel;
-    getPort: () => Scrollport | null;
-    /** Map the port's scrollTop into this list's own coordinate range. Identity for the top level. */
+    getPort: () => ScrollportReader | null;
+    /** Convert the scroll container's `scrollTop` into this list's own range. Unchanged at the
+     *  top level. */
     getLocalScrollTop: () => number;
     getViewportHeight: () => number;
     getPinnedIndex: () => number | null;
+    /** True while a height change's scroll correction is still to come: the range then keeps the
+     *  blocks it has as well, since the scroll doesn't match the table yet. */
+    holdsRange: () => boolean;
     overscan: number;
     pinExtensionCap: number;
     activateAbovePx: number;
@@ -32,9 +39,8 @@ export interface BlockWindowDeps {
 }
 export interface BlockWindow {
     readonly result: WindowResult;
-    /** Push the scroll element's current scrollTop into the window state now. A
-     *  programmatic scrollTop write doesn't fire a `scroll` event, so the passive
-     *  listener wouldn't update the derived in time for a deterministic reveal. */
+    /** A scripted `scrollTop` write fires no `scroll` event, so a scroll into view calls this to
+     *  update the window before reading it. */
     syncScrollTop(): void;
     dispose(): void;
 }

package/dist/reactivity/block-window.svelte.js

@@ -1,28 +1,26 @@
 /**
- * Window math for virtual rendering. `computeWindow` is pure: from a height model and the
- * scroll viewport it returns the slice to mount (extended to keep a pinned caret block
- * contiguous), the spacer heights preserving native scroll geometry, and the next
- * activation state. `createBlockWindow` wires live getters and a scroll listener to it.
+ * Window math for virtual rendering: which blocks to mount, and the spacer heights that keep the
+ * browser's scroll geometry. `computeWindow` is pure; `createBlockWindow` wires live getters and
+ * a scroll listener to it.
  */
 import { untrack } from 'svelte';
 export function computeWindow(model, input) {
     const n = model.size;
     const total = model.total();
-    // The one activation decision in the feature: a scope windows purely on its own modeled
-    // height, so who owns the scroll changes which port is read and nothing else.
+    // The one place windowing turns on or off: a list decides purely on its own estimated
+    // height, so who owns the scroll changes which container is read and nothing else.
     const active = input.active ? total >= input.deactivateBelowPx : total >= input.activateAbovePx;
     if (!active || n === 0) {
-        return { active: false, start: 0, end: n, topSpacerPx: 0, bottomSpacerPx: 0 };
+        return { active: false, start: 0, end: n, topSpacerPx: 0, bottomSpacerPx: 0, floorPx: 0 };
     }
     const firstVisible = model.indexAtOffset(input.scrollTop);
-    // Probe the last on-screen pixel: the viewport is half-open, so a block whose top sits
-    // exactly on the bottom edge isn't visible.
+    // Check the last on-screen pixel: the viewport range is half-open, so a block whose top
+    // sits exactly on the bottom edge isn't visible.
     const lastVisible = model.indexAtOffset(input.scrollTop + input.viewportHeight - 1);
     let start = Math.max(0, firstVisible - input.overscan);
     let end = Math.min(n, lastVisible + 1 + input.overscan);
-    // Extend the CONTIGUOUS range so Svelte preserves the caret block's DOM node and native
-    // focus/IME survive a scroll — bounded, so a caret parked far away before a large scroll
-    // doesn't mount thousands. Beyond the cap it blurs.
+    // Growing the range to the caret block keeps its DOM node, so focus and IME survive a scroll;
+    // capped so a caret left far away doesn't mount thousands of blocks (it loses focus instead).
     const pin = input.pinnedIndex;
     if (pin !== null && pin >= 0 && pin < n) {
         if (pin < start && start - pin <= input.pinExtensionCap)
@@ -35,7 +33,21 @@ export function computeWindow(model, input) {
         start,
         end,
         topSpacerPx: model.offsetOf(start),
-        bottomSpacerPx: total - model.offsetOf(end)
+        bottomSpacerPx: total - model.offsetOf(end),
+        floorPx: total
+    };
+}
+/** `next` widened to keep `shown`'s blocks too, with the spacers the table now gives them. */
+function widened(model, next, shown) {
+    const end = Math.min(Math.max(next.end, shown.end), model.size);
+    const start = Math.min(next.start, shown.start, end);
+    return {
+        active: true,
+        start,
+        end,
+        topSpacerPx: model.offsetOf(start),
+        bottomSpacerPx: model.total() - model.offsetOf(end),
+        floorPx: model.total()
     };
 }
 export function createBlockWindow(deps) {
@@ -56,8 +68,11 @@ export function createBlockWindow(deps) {
             unsubscribe = null;
         };
     });
+    // Plain, not state: the range last shown, and the scroll it was worked out at.
+    let last = null;
     const result = $derived.by(() => {
-        return computeWindow(deps.getModel(), {
+        const model = deps.getModel();
+        const next = computeWindow(model, {
             scrollTop,
             viewportHeight: deps.getViewportHeight(),
             overscan: deps.overscan,
@@ -67,10 +82,22 @@ export function createBlockWindow(deps) {
             activateAbovePx: deps.activateAbovePx,
             deactivateBelowPx: deps.deactivateBelowPx
         });
+        // Unmounting the blocks at the top before the correction lands would remount them fresh; a
+        // range the new one doesn't touch is a jump elsewhere, and goes.
+        const shown = last?.scrollTop === scrollTop ? last.result : null;
+        const kept = shown &&
+            shown.active &&
+            next.active &&
+            next.start <= shown.end &&
+            shown.start <= next.end &&
+            deps.holdsRange()
+            ? widened(model, next, shown)
+            : next;
+        last = { result: kept, scrollTop };
+        return kept;
     });
-    // Hysteresis state. `result` reads `active` and this effect writes it, so the write is
-    // untracked and change-guarded — otherwise the effect depends on its own write. It
-    // converges: once `active` equals `result.active` the guard writes nothing.
+    // Hysteresis: `result` reads `active` and this effect writes it, so the write is untracked
+    // and skipped when unchanged, or the effect would depend on its own write.
     $effect(() => {
         const next = result.active;
         untrack(() => {

package/dist/reactivity/child-list.d.ts

@@ -0,0 +1,34 @@
+/**
+ * One block list's children as a walk down the tree reads them, and the two walks: `descendTo`
+ * scrolls each level's child into the mounted range, `componentAt` reads only what is mounted.
+ * The editor root, every container, the table and each table row publish one.
+ */
+import type { BlockComponent } from '../block-component';
+import { type RefSlots } from './publish-ref.svelte';
+/** One mounted child list, as the descent reads it. Every field is read live. */
+export interface ChildList {
+    count(): number;
+    readonly refs: RefSlots<BlockComponent>;
+    /** Required, so a list that cannot say whether a child is in range cannot exist. */
+    readonly windowing: {
+        /** Scrolls this list so child `index` is inside the mounted range; resolves after a tick. */
+        revealChild(index: number): Promise<void>;
+        /** Whether `index` is inside the mounted range. */
+        isInWindow(index: number): boolean;
+    };
+    /** Scrolls child `index` into this list's own scroller on another axis (a table's columns). */
+    bringChildIntoView?(index: number): void;
+    /** True while only the title row (child 0) is mounted. */
+    isCollapsed?(): boolean;
+    /** Opens a collapsed body as an undoable commit, for a descent asked to open one. */
+    openCollapsed?(): Promise<boolean>;
+}
+/**
+ * Mounts each level of `path` below `root` and returns the component at its end, or null when
+ * a level can't mount. A path into a collapsed body stops there unless `openCollapsed` is set.
+ */
+export declare function descendTo(root: ChildList, path: readonly number[], opts?: {
+    openCollapsed?: boolean;
+}): Promise<BlockComponent | null>;
+/** The mounted component at `path`, or null; never mounts anything. */
+export declare function componentAt(root: ChildList, path: readonly number[]): BlockComponent | null;

package/dist/reactivity/child-list.js

@@ -0,0 +1,48 @@
+import { revealChildOrWait } from './publish-ref.svelte';
+/**
+ * Mounts each level of `path` below `root` and returns the component at its end, or null when
+ * a level can't mount. A path into a collapsed body stops there unless `openCollapsed` is set.
+ */
+export async function descendTo(root, path, opts = {}) {
+    let list = root;
+    for (let depth = 0; depth < path.length; depth++) {
+        const index = path[depth];
+        // Only a body child is hidden; the title row stays mounted while collapsed.
+        if (index >= 1 && list.isCollapsed?.()) {
+            if (!opts.openCollapsed || !list.openCollapsed)
+                return null;
+            await list.openCollapsed();
+        }
+        const { windowing } = list;
+        await revealChildOrWait(index, {
+            slots: list.refs,
+            childCount: list.count(),
+            revealChild: (i) => windowing.revealChild(i),
+            isInWindow: (i) => windowing.isInWindow(i)
+        });
+        const ref = list.refs.get(index);
+        if (!ref)
+            return null;
+        list.bringChildIntoView?.(index);
+        if (depth === path.length - 1)
+            return ref;
+        const next = ref.childList?.();
+        if (!next)
+            return null;
+        list = next;
+    }
+    return null;
+}
+/** The mounted component at `path`, or null; never mounts anything. */
+export function componentAt(root, path) {
+    let list = root;
+    for (let depth = 0; depth < path.length && list; depth++) {
+        const ref = list.refs.get(path[depth]);
+        if (!ref)
+            return null;
+        if (depth === path.length - 1)
+            return ref;
+        list = ref.childList?.();
+    }
+    return null;
+}

package/dist/reactivity/content-version.svelte.d.ts

@@ -1,14 +1,11 @@
 /**
- * A number that changes whenever a byte-writing door announces it, so a whole-document
- * derivation can memoize over a `$state` document that is mutated IN PLACE and never changes
- * identity. Reading it inside a `$derived` subscribes that reader to every edit. The doors are
- * censused (G4.52): the commit ceremony announces every structural write at its publish, and the
- * writers outside it announce their own.
+ * A number bumped whenever the document's bytes change, so a whole-document `$derived` can
+ * memoize over a `$state` document that is mutated in place and never changes identity.
+ * Every place that writes bytes must bump it; a commit does so for each structural write (G4.52).
  */
 export interface ContentVersion {
-    /** The current key, stable until a door bumps it. */
     read(): number;
-    /** Announce that this door moved the document's serialized bytes. */
+    /** Call after changing the document's serialized bytes. */
     bump(): void;
 }
 export declare function createContentVersion(): ContentVersion;

package/dist/reactivity/content-version.svelte.js

@@ -1,9 +1,7 @@
 /**
- * A number that changes whenever a byte-writing door announces it, so a whole-document
- * derivation can memoize over a `$state` document that is mutated IN PLACE and never changes
- * identity. Reading it inside a `$derived` subscribes that reader to every edit. The doors are
- * censused (G4.52): the commit ceremony announces every structural write at its publish, and the
- * writers outside it announce their own.
+ * A number bumped whenever the document's bytes change, so a whole-document `$derived` can
+ * memoize over a `$state` document that is mutated in place and never changes identity.
+ * Every place that writes bytes must bump it; a commit does so for each structural write (G4.52).
  */
 export function createContentVersion() {
     let version = $state(0);

package/dist/reactivity/hold-across.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Which block stays still across a measure round, picked level by level down the document's
+ * block lists before the round, and where it is once the round's changes have landed. See
+ * `docs/design/virtual-rendering.md` § Keeping the page still while heights change.
+ */
+import type { HeightModel } from '../cursor/height-model';
+/** A list's block heights, with the ids they were built from lined up by index. */
+export interface HeightTable {
+    readonly model: HeightModel;
+    /** A snapshot, so a round finds its held block by id in the order from before a change. */
+    readonly ids: readonly string[];
+}
+declare const picked: unique symbol;
+declare const measured: unique symbol;
+/** The block a list keeps still, with its index in the table it was picked from. Only
+ *  `heldBlock` makes one. */
+export type HeldBlock = {
+    readonly id: string;
+    readonly index: number;
+    /** Picked because the caret is in it, which a change that moves it cancels. */
+    readonly focused: boolean;
+    readonly [picked]: true;
+};
+/** How far the held block's top moved across a round. Only `heldDelta` makes one, so a
+ *  correction can't use a distance worked out some other way. */
+export type HeldDelta = number & {
+    readonly [measured]: true;
+};
+/** The focused block's index among the children of the list at `listPath`, or null when the
+ *  focus path doesn't run through that list. */
+export declare function focusedIndexIn(focusPath: readonly number[] | null, listPath: readonly number[]): number | null;
+/** The focused block when it sits at or below `localTop`, else the block at the top, else none. */
+export declare function heldBlock(table: HeightTable, localTop: number, focusedIndex: number | null): HeldBlock | null;
+/** Where `held` sits in `after`, or -1 when the change removed it, or moved the caret's block
+ *  (a reorder moves its block on a still page, so that block isn't held). */
+export declare function heldIndexIn(held: HeldBlock, before: HeightTable, after: HeightTable): number;
+/** The distance a round corrects by: the held block's offset after it minus before. */
+export declare function heldDelta(before: number, after: number): HeldDelta;
+export {};

package/dist/reactivity/hold-across.js

@@ -0,0 +1,57 @@
+import { recordNeighbourPass } from '../perf/instruments';
+/** The focused block's index among the children of the list at `listPath`, or null when the
+ *  focus path doesn't run through that list. */
+export function focusedIndexIn(focusPath, listPath) {
+    if (!focusPath || focusPath.length <= listPath.length)
+        return null;
+    for (let i = 0; i < listPath.length; i++)
+        if (focusPath[i] !== listPath[i])
+            return null;
+    return focusPath[listPath.length];
+}
+/** The focused block when it sits at or below `localTop`, else the block at the top, else none. */
+export function heldBlock(table, localTop, focusedIndex) {
+    // Past the end the viewport's top is below this list, so the pick stays with its container.
+    if (table.model.size === 0 || localTop >= table.model.total())
+        return null;
+    const topIndex = table.model.indexAtOffset(localTop);
+    const focused = focusedIndex ?? -1;
+    if (focused >= topIndex && focused < table.ids.length)
+        return pick(table, focused, true);
+    // At 0 the viewport's top is above this list, in its container's chrome or further up.
+    return localTop === 0 ? null : pick(table, topIndex, false);
+}
+/** Where `held` sits in `after`, or -1 when the change removed it, or moved the caret's block
+ *  (a reorder moves its block on a still page, so that block isn't held). */
+export function heldIndexIn(held, before, after) {
+    if (after === before)
+        return held.index;
+    const index = after.ids.indexOf(held.id);
+    if (index === -1 || !held.focused)
+        return index;
+    return movedAcross(before, after, held.index, index) ? -1 : index;
+}
+/** The distance a round corrects by: the held block's offset after it minus before. */
+export function heldDelta(before, after) {
+    return (after - before);
+}
+function pick(table, index, focused) {
+    return { id: table.ids[index], index, focused };
+}
+// A block whose surviving neighbours changed was moved by the edit.
+function movedAcross(before, after, index, afterIndex) {
+    recordNeighbourPass();
+    const inAfter = new Set(after.ids);
+    const inBefore = new Set(before.ids);
+    return (survivingNeighbour(before.ids, index, -1, inAfter) !==
+        survivingNeighbour(after.ids, afterIndex, -1, inBefore) ||
+        survivingNeighbour(before.ids, index, 1, inAfter) !==
+            survivingNeighbour(after.ids, afterIndex, 1, inBefore));
+}
+function survivingNeighbour(ids, index, step, survivors) {
+    for (let i = index + step; i >= 0 && i < ids.length; i += step) {
+        if (survivors.has(ids[i]))
+            return ids[i];
+    }
+    return undefined;
+}

package/dist/reactivity/layout-state.svelte.d.ts

@@ -0,0 +1,27 @@
+/**
+ * What the editor's heights were measured for: the type scale, the width version the block lists
+ * rebuild their tables off, and the viewport-height version, which only changes how many blocks
+ * fit. Layout state builds the height estimator and hands out its reads alone, so it's the one
+ * place measured heights can be thrown away (G4.98): a route reports what changed.
+ */
+import { type MeasuredHeightOracle } from '../cursor/height-oracle';
+export interface LayoutState {
+    /** The editor's height estimator, without the drop. */
+    heightOracle: Omit<MeasuredHeightOracle, 'dropMeasured'>;
+    /** The host's font scale against `HEIGHT_ESTIMATES`. A plain read, since the height estimates
+     *  read it on the keystroke path and the width version already signals the rebuild. */
+    typeScale(): number;
+    widthVersion(): number;
+    viewportHeightVersion(): number;
+    /** A document swap or a mode switch: the measured heights belong to a view that's gone. The
+     *  width version stays, since a rebuild would lose the block held in place. */
+    forgetMeasuredHeights(): void;
+    /** A width change re-wraps every block: the measured heights go, and every list re-estimates
+     *  its table. */
+    rebuildForNewGeometry(): void;
+    /** A new font scale is a geometry change too. */
+    setTypeScale(next: number): void;
+    /** The scroll container's height changed; that re-wraps nothing, so every height stays. */
+    noteViewportHeight(): void;
+}
+export declare function createLayoutState(): LayoutState;

package/dist/reactivity/layout-state.svelte.js

@@ -0,0 +1,51 @@
+/**
+ * What the editor's heights were measured for: the type scale, the width version the block lists
+ * rebuild their tables off, and the viewport-height version, which only changes how many blocks
+ * fit. Layout state builds the height estimator and hands out its reads alone, so it's the one
+ * place measured heights can be thrown away (G4.98): a route reports what changed.
+ */
+import { createHeightOracle } from '../cursor/height-oracle';
+import { HEIGHT_ESTIMATES } from '../cursor/typography-estimates';
+export function createLayoutState() {
+    let typeScale = 1;
+    let widthVersion = $state(0);
+    let viewportHeightVersion = $state(0);
+    // Only font-relative terms scale; getters, so a scale change needs no new height estimator.
+    const oracle = createHeightOracle({
+        get lineHeight() {
+            return HEIGHT_ESTIMATES.proseLineHeight * typeScale;
+        },
+        get codeLineHeight() {
+            return HEIGHT_ESTIMATES.codeLineHeight * typeScale;
+        },
+        get avgCharWidth() {
+            return HEIGHT_ESTIMATES.avgCharWidth * typeScale;
+        },
+        blockChrome: HEIGHT_ESTIMATES.blockChrome,
+        imageBlockMinHeight: HEIGHT_ESTIMATES.imageBlockMinHeight
+    });
+    function rebuildForNewGeometry() {
+        oracle.dropMeasured();
+        widthVersion++;
+    }
+    return {
+        heightOracle: {
+            estimate: oracle.estimate,
+            measured: oracle.measured,
+            recordMeasured: oracle.recordMeasured,
+            measuredIds: oracle.measuredIds
+        },
+        typeScale: () => typeScale,
+        widthVersion: () => widthVersion,
+        viewportHeightVersion: () => viewportHeightVersion,
+        forgetMeasuredHeights: () => oracle.dropMeasured(),
+        rebuildForNewGeometry,
+        setTypeScale(next) {
+            typeScale = next;
+            rebuildForNewGeometry();
+        },
+        noteViewportHeight: () => {
+            viewportHeightVersion++;
+        }
+    };
+}

package/dist/reactivity/list-tree.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Every mounted block list of one editor, so the scroll owner can read the document through their
+ * height tables: where a block sits, and which one block to keep still across a measure round.
+ * See `docs/design/virtual-rendering.md` § Keeping the page still while heights change.
+ */
+import type { TargetTop } from '../cursor/scroll-owner';
+import { type HeightTable, type HeldDelta } from './hold-across';
+/** One block list as the tree reads it. */
+export interface ListLevel {
+    path(): readonly number[];
+    /** The table as last built, read without building one: what a round opening in the middle of
+     *  a change counts from. */
+    built(): HeightTable;
+    /** The table as it reads now, rebuilt first if the list's blocks changed. */
+    current(): HeightTable;
+    /** The root list's top in the scroll content, a nested list's top below the top of the box its
+     *  parent measures; null before it mounts. */
+    top(): number | null;
+    /** This list's top in the scroll content, off its element; null before it mounts. */
+    contentTop(): number | null;
+    isInWindow(index: number): boolean;
+}
+export interface ListTreeDeps {
+    getScrollTop: () => number | null;
+    getFocusPath: () => readonly number[] | null;
+}
+export interface ListTree {
+    add(level: ListLevel): () => void;
+    /** Where the block at `path` sits in the scroll content, from the tables along its path; null
+     *  when a mounted container has windowed it out. */
+    resolve(path: readonly number[]): TargetTop | null;
+    /** Where to scroll so the list holding `path` mounts that block: the list's top plus its table's
+     *  offset of the block. */
+    mountTop(path: readonly number[]): number | null;
+    /** Picks the block to keep still from the tables and the scroll as they stand; the returned
+     *  read says how far that block has moved since. Null with nothing to hold. */
+    holdForRound(): (() => HeldDelta) | null;
+}
+export declare function createListTree(deps: ListTreeDeps): ListTree;

package/dist/reactivity/list-tree.js

@@ -0,0 +1,132 @@
+import { focusedIndexIn, heldBlock, heldDelta, heldIndexIn } from './hold-across';
+export function createListTree(deps) {
+    const levels = new Set();
+    function levelAt(path) {
+        for (const level of levels) {
+            const at = level.path();
+            if (at.length === path.length && at.every((index, i) => index === path[i]))
+                return level;
+        }
+        return undefined;
+    }
+    /** The one walk down a path: the offset below the root list's top at each level it reaches,
+     *  mounted containers' chrome included; null past a table's end, or a windowed-out block. */
+    function walk(path, read, inWindowOnly) {
+        let level = levelAt([]);
+        if (!level)
+            return null;
+        const offsets = [];
+        let offset = 0;
+        let height = 0;
+        for (let depth = 0; depth < path.length; depth++) {
+            const { model } = read(level);
+            const index = path[depth];
+            if (index >= model.size)
+                return null;
+            offset += model.offsetOf(index);
+            height = model.heightOf(index);
+            offsets.push(offset);
+            if (depth === path.length - 1)
+                break;
+            const inner = levelAt(path.slice(0, depth + 1));
+            const chrome = inner?.top() ?? null;
+            // An unmounted container stands in with its own top.
+            if (!inner || chrome === null)
+                break;
+            // The user scrolled past the target inside a mounted container: decline, not jump.
+            if (inWindowOnly && !inner.isInWindow(path[depth + 1]))
+                return null;
+            offset += chrome;
+            level = inner;
+        }
+        return { offsets, height };
+    }
+    /** The held block at each level, from the viewport's top down, preferring the caret's block. */
+    function descend(localTop, focus) {
+        const steps = [];
+        let level = levelAt([]);
+        let top = localTop;
+        while (level) {
+            const table = level.built();
+            const held = heldBlock(table, top, focusedIndexIn(focus, level.path()));
+            if (!held)
+                break;
+            steps.push({ level, held, table });
+            const inner = levelAt([...level.path(), held.index]);
+            const chrome = inner?.top() ?? null;
+            if (!inner || chrome === null)
+                break;
+            top = Math.max(0, top - table.model.offsetOf(held.index) - chrome);
+            level = inner;
+        }
+        return steps;
+    }
+    /** The held path as indices now, cut at the first level whose block the change removed; empty
+     *  when the caret's block was moved, so the round falls back to the block at the top. */
+    function pathNow(steps) {
+        const path = [];
+        for (const { level, held, table } of steps) {
+            // A list the round's change unmounted stands in with its container, as in `walk`.
+            if (!levels.has(level))
+                return path;
+            const index = heldIndexIn(held, table, level.current());
+            if (index === -1)
+                return held.focused ? [] : path;
+            path.push(index);
+        }
+        return path;
+    }
+    function holdForRound() {
+        const scrollTop = deps.getScrollTop();
+        const rootTop = levelAt([])?.top() ?? null;
+        if (scrollTop === null || rootTop === null)
+            return null;
+        const localTop = Math.max(0, scrollTop - rootTop);
+        const focus = deps.getFocusPath();
+        const candidates = [descend(localTop, focus)];
+        if (candidates[0].some((step) => step.held.focused))
+            candidates.push(descend(localTop, null));
+        const before = candidates.map((steps) => walk(steps.map((step) => step.held.index), (level) => level.built(), false)?.offsets ?? []);
+        if (before.every((offsets) => offsets.length === 0))
+            return null;
+        function movedSince() {
+            let from = 0;
+            let to = 0;
+            for (let i = 0; i < candidates.length; i++) {
+                const path = pathNow(candidates[i]);
+                const after = path.length > 0 ? walk(path, (level) => level.current(), false) : null;
+                if (!after)
+                    continue;
+                from = before[i][path.length - 1];
+                to = after.offsets[path.length - 1];
+                break;
+            }
+            return heldDelta(from, to);
+        }
+        return movedSince;
+    }
+    return {
+        add(level) {
+            levels.add(level);
+            return () => levels.delete(level);
+        },
+        resolve(path) {
+            const rootTop = levelAt([])?.top() ?? null;
+            if (rootTop === null || path.length === 0)
+                return null;
+            const at = walk(path, (level) => level.current(), true);
+            if (!at)
+                return null;
+            return { top: rootTop + at.offsets[at.offsets.length - 1], height: at.height };
+        },
+        mountTop(path) {
+            const level = levelAt(path.slice(0, -1));
+            const top = level?.contentTop() ?? null;
+            const index = path[path.length - 1];
+            if (!level || top === null || index === undefined)
+                return null;
+            return top + level.current().model.offsetOf(index);
+        },
+        holdForRound
+    };
+}