@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/reactivity/publish-ref.svelte.d.ts

@@ -1,54 +1,29 @@
-/**
- * A scope's ref-slot array, reached only through the accessors its owner mints. Object
- * identity IS the scope: the mount registry keys on it, so a mount in one scope cannot wake
- * a waiter in another (a nested level, a sibling container, a second editor instance).
- * Neither accessor is reactive: every owner mints the slots over a plain array, so a `get`
- * registers no dependency and a `set` wakes no effect; `whenRefMounted` is how a caller waits.
- */
+/** One block list's child-component refs, reached only through these accessors. Neither is
+ *  reactive; `revealChildOrWait` is how a caller waits for a child to mount. */
 export interface RefSlots<T> {
     set(index: number, ref: T | undefined): void;
     get(index: number): T | undefined;
 }
-/** Mints a scope over its ref array. Takes the array itself, not a getter, so a scope
- *  cannot be re-aimed at a replacement: Svelte pins a teardown's reads to pre-flush values,
- *  so a swapped array takes each cleanup's clear with it and strands the dead ref in the
- *  live one. Publish a new set of contents with `replaceRefs`. */
+/** Takes the array itself, never a getter: a cleanup run against a replaced array would leave a
+ *  dead ref in the live one. Replace contents with `replaceRefs`. */
 export declare function refSlotsOver<T>(refs: (T | undefined)[]): RefSlots<T>;
-/** Publishes a whole slot array in place, the only sanctioned way to replace a scope's
- *  contents wholesale (see `refSlotsOver` for why identity is load-bearing). */
+/** Writes a whole array of refs in place, the only supported way to replace a list's
+ *  contents at once (see `refSlotsOver` for why the array's identity matters). */
 export declare function replaceRefs<T>(target: (T | undefined)[], values: readonly (T | undefined)[]): void;
-/**
- * Replaces `bind:this={refs[i]}` in a keyed each — Svelte 5's `bind:this` doesn't re-target
- * when the iteration index shifts. Cleanup is conditional because effect-cleanup order
- * across siblings isn't guaranteed, and an unconditional clear stomps a neighbor's slot.
- * `el` is the ref's own box, which is what makes `isSlotDetached` answerable.
- */
+/** Replaces `bind:this={refs[i]}` in a keyed each, which doesn't re-target when the index
+ *  shifts. `el` is the ref's own box, which `isSlotDetached` reads. */
 export declare function publishRefSlot<T>(slots: RefSlots<T>, index: number, ref: T | undefined, el?: Element | null): () => void;
 export interface RevealChildOptions<T> {
-    /** This scope's ref slots: the read/drop surface, and the mount-wait's scope key. */
+    /** This list's ref entries: what the wait reads, and clears when a ref left the DOM. */
     readonly slots: RefSlots<T>;
-    /** This scope's child count; an index at or past it can never mount (size lag). */
+    /** This list's child count; an index at or past it can never mount. */
     readonly childCount: number;
-    /** Scroll this scope so child `index` enters its window; resolves after a tick. */
+    /** Scroll this list so child `index` is in the mounted range; resolves after a tick. */
     readonly revealChild: (index: number) => Promise<void>;
-    /** True iff `index` is inside the scope's CURRENT mounted window, read AFTER `revealChild`
-     *  resolved (VR-5's termination guarantee). Optional only for a scope that does not window:
-     *  every production reveal supplies it, so the bounded re-wait below is the harness
-     *  fallback, not a live path. */
-    readonly isInWindow?: (index: number) => boolean;
+    /** True when `index` is in the list's mounted range after `revealChild`, which lets the wait
+     *  give up instead of hanging (VR-5). */
+    readonly isInWindow: (index: number) => boolean;
 }
-/**
- * Bring child `index` into its window before a caller reads its ref: drop a detached ref,
- * scroll it in, and await its mount. Shared by the canonical container reveal and TableBlock's
- * hand-rolled one, so the "is this slot a live mount" gate has one home. Termination (VR-5): only
- * a mount at this index in THIS scope wakes the wait, so a windowing caller proves membership
- * first and a non-windowing one races each wait against a tick, rather than parking forever.
- */
+/** Brings child `index` into the mounted range before a caller reads its ref: drops a ref that
+ *  left the DOM, scrolls the child in, and waits for its mount, giving up when it cannot come. */
 export declare function revealChildOrWait<T>(index: number, opts: RevealChildOptions<T>): Promise<void>;
-/**
- * Resolve when slot `index` of `slots` is (or becomes) populated. Event-driven, woken by
- * `publishRefSlot` on a real mount, never a timer (Design Rule #2 / G4.4). A wake can still
- * be spurious within one scope: a mount that unpublishes in the same flush leaves the slot
- * empty, so the caller re-checks.
- */
-export declare function whenRefMounted<T>(slots: RefSlots<T>, index: number): Promise<void>;

package/dist/reactivity/publish-ref.svelte.js

@@ -1,8 +1,8 @@
+/** A block list's child-component refs, and scrolling a child into the mounted range before
+ *  reading its ref. */
 import { tick, untrack } from 'svelte';
-/** Mints a scope over its ref array. Takes the array itself, not a getter, so a scope
- *  cannot be re-aimed at a replacement: Svelte pins a teardown's reads to pre-flush values,
- *  so a swapped array takes each cleanup's clear with it and strands the dead ref in the
- *  live one. Publish a new set of contents with `replaceRefs`. */
+/** Takes the array itself, never a getter: a cleanup run against a replaced array would leave a
+ *  dead ref in the live one. Replace contents with `replaceRefs`. */
 export function refSlotsOver(refs) {
     return {
         set: (index, ref) => {
@@ -11,28 +11,22 @@ export function refSlotsOver(refs) {
         get: (index) => refs[index]
     };
 }
-/** Publishes a whole slot array in place, the only sanctioned way to replace a scope's
- *  contents wholesale (see `refSlotsOver` for why identity is load-bearing). */
+/** Writes a whole array of refs in place, the only supported way to replace a list's
+ *  contents at once (see `refSlotsOver` for why the array's identity matters). */
 export function replaceRefs(target, values) {
     target.length = values.length;
     for (let i = 0; i < values.length; i++)
         target[i] = values[i];
 }
-/**
- * Replaces `bind:this={refs[i]}` in a keyed each — Svelte 5's `bind:this` doesn't re-target
- * when the iteration index shifts. Cleanup is conditional because effect-cleanup order
- * across siblings isn't guaranteed, and an unconditional clear stomps a neighbor's slot.
- * `el` is the ref's own box, which is what makes `isSlotDetached` answerable.
- */
+/** Replaces `bind:this={refs[i]}` in a keyed each, which doesn't re-target when the index
+ *  shifts. `el` is the ref's own box, which `isSlotDetached` reads. */
 export function publishRefSlot(slots, index, ref, el) {
     slots.set(index, ref);
     if (el && typeof ref === 'object' && ref !== null)
         publishedElements.set(ref, el);
-    // The cleanup's identity check compares against what the slot actually holds, not the raw
-    // ref; untracked, since publishers run inside effects and would self-invalidate.
+    // Sibling cleanups run in no set order, so a cleanup clears the entry only if it still holds
+    // this mount's ref; read untracked, since writers run inside effects.
     const publishedRef = untrack(() => slots.get(index));
-    if (publishedRef !== undefined)
-        resolveMountWaiters(slots, index);
     return () => {
         if (slots.get(index) === publishedRef) {
             slots.set(index, undefined);
@@ -40,17 +34,11 @@ export function publishRefSlot(slots, index, ref, el) {
     };
 }
 // ── Mount attachment ─────────────────────────────────────────────────────────
-// Keyed on ref identity, not on (slots, index): a wholesale `replaceRefs` re-seats a saved
-// ref no publisher will run for again, and only the ref itself still knows its box. Weak,
-// so the entry dies with the ref rather than outliving the scope.
+// Keyed on the ref, not (slots, index): a wholesale `replaceRefs` moves a saved ref that no
+// writer will run for again, and only the ref itself still knows its box.
 const publishedElements = new WeakMap();
-/**
- * True when the slot's ref is a mount that already left the DOM. The one home for the
- * question every reveal asks before trusting a filled slot — and it is an ATTACHMENT
- * question, never a window-membership one: a programmatic scroll moves the slice a flush
- * before the DOM follows, so "off-window" clears refs whose components are still mounted
- * and which nothing re-publishes. A ref with no recorded box degrades to live.
- */
+/** True when the entry's ref is a mount whose element already left the DOM. Asks the DOM, never
+ *  the mounted range, which moves a flush before the DOM follows. A ref with no box is live. */
 function isSlotDetached(slots, index) {
     const ref = slots.get(index);
     if (typeof ref !== 'object' || ref === null)
@@ -58,16 +46,8 @@ function isSlotDetached(slots, index) {
     const el = publishedElements.get(ref);
     return el !== undefined && !el.isConnected;
 }
-/** Each wait races a tick, so a scope with no membership oracle would spin forever on a
- *  child that never publishes. This bounds those turns. */
-const MAX_MOUNT_REWAITS = 64;
-/**
- * Bring child `index` into its window before a caller reads its ref: drop a detached ref,
- * scroll it in, and await its mount. Shared by the canonical container reveal and TableBlock's
- * hand-rolled one, so the "is this slot a live mount" gate has one home. Termination (VR-5): only
- * a mount at this index in THIS scope wakes the wait, so a windowing caller proves membership
- * first and a non-windowing one races each wait against a tick, rather than parking forever.
- */
+/** Brings child `index` into the mounted range before a caller reads its ref: drops a ref that
+ *  left the DOM, scrolls the child in, and waits for its mount, giving up when it cannot come. */
 export async function revealChildOrWait(index, opts) {
     const detached = isSlotDetached(opts.slots, index);
     if (index >= opts.childCount || (!detached && opts.slots.get(index)))
@@ -75,54 +55,10 @@ export async function revealChildOrWait(index, opts) {
     if (detached)
         opts.slots.set(index, undefined);
     await opts.revealChild(index);
-    if (opts.slots.get(index))
+    // Outside the recomputed range the mount cannot fire, so give up now.
+    if (opts.slots.get(index) || !opts.isInWindow(index))
         return;
-    if (opts.isInWindow) {
-        // Provably outside the recomputed window → the mount can't fire; degrade now.
-        if (!opts.isInWindow(index))
-            return;
-        // In-window, the mount flush is at most one tick away; still unpublished after it
-        // means a failed-render boundary left bind:this unset, waking no waiter.
-        await tick();
-        return;
-    }
-    // Membership unknowable: bounded mount-wait, each raced against a tick so a child that
-    // never publishes degrades within the cap instead of parking forever.
-    let rewaits = 0;
-    while (!opts.slots.get(index) && rewaits++ < MAX_MOUNT_REWAITS) {
-        await Promise.race([whenRefMounted(opts.slots, index), tick()]);
-    }
-}
-// ── Mount-await registry ─────────────────────────────────────────────────────
-const mountWaiters = new WeakMap();
-/**
- * Resolve when slot `index` of `slots` is (or becomes) populated. Event-driven, woken by
- * `publishRefSlot` on a real mount, never a timer (Design Rule #2 / G4.4). A wake can still
- * be spurious within one scope: a mount that unpublishes in the same flush leaves the slot
- * empty, so the caller re-checks.
- */
-export function whenRefMounted(slots, index) {
-    if (slots.get(index) !== undefined)
-        return Promise.resolve();
-    return new Promise((resolve) => {
-        let byIndex = mountWaiters.get(slots);
-        if (!byIndex) {
-            byIndex = new Map();
-            mountWaiters.set(slots, byIndex);
-        }
-        const list = byIndex.get(index);
-        if (list)
-            list.push(resolve);
-        else
-            byIndex.set(index, [resolve]);
-    });
-}
-function resolveMountWaiters(slots, index) {
-    const byIndex = mountWaiters.get(slots);
-    const list = byIndex?.get(index);
-    if (!byIndex || !list)
-        return;
-    byIndex.delete(index);
-    for (const resolve of list)
-        resolve();
+    // Inside it the mount flush is at most one tick away; an entry still empty after it means a
+    // failed render left `bind:this` unset.
+    await tick();
 }

package/dist/reactivity/scope-geometry.d.ts

@@ -1,18 +1,11 @@
-/** This scope's own content element, not the scrollport: nested content lays out narrower and
- *  the oracle's line-wrap is monotonic in width, so the port width undercounts at depth. Falls
- *  back to the port, then a constant, when neither is measurable. */
+/** This list's own content element, not the scroll container: nested content lays out narrower,
+ *  and the height estimator wraps more lines the narrower it gets. */
 export declare function estimateWidth(listEl: {
     clientWidth: number;
 } | null, portWidth: number): number;
-/**
- * This scope's list top in the scrollport's CONTENT space — the offset mapping port scrollTop
- * into the scope's local range. The two port terms are distinct and both load-bearing: an editor
- * embedded partway down a page-scrolled shell has a nonzero scroll AND page chrome above it, and
- * conflating them slices the window a band off.
- */
+/** The offset that converts the scroll container's `scrollTop` into this list's range. Viewport
+ *  top and scroll offset are separate terms: an editor partway down a scrolling page has both. */
 export declare function listTopWithinContent(listTop: number, viewportTop: number, scrollTop: number): number;
-/** The intersection of the port's viewport with this scope's own box. Each nested scope
- *  occupies only part of the viewport, so windowing against the full port height would
- *  mount O(viewport × active-scope-count) blocks. The viewport arrives as top + client
- *  height so the intersection excludes the scrollbar/border. */
+/** Each nested list covers only part of the viewport; windowing each against the full height
+ *  would mount O(viewport × lists) blocks. Pass client height, which leaves out the scrollbar. */
 export declare function effectiveViewportHeight(viewportTop: number, viewportHeight: number, scopeTop: number, scopeHeight: number): number;

package/dist/reactivity/scope-geometry.js

@@ -1,27 +1,20 @@
 /**
- * Pure per-scope geometry for windowing, isolated from the reactive wiring in
+ * Pure per-list geometry for windowing, kept apart from the reactive wiring in
  * `list-windowing.svelte.ts` so it can be unit-tested without mounting a component.
  */
 import { FALLBACK_CONTENT_WIDTH } from '../cursor/typography-estimates';
-/** This scope's own content element, not the scrollport: nested content lays out narrower and
- *  the oracle's line-wrap is monotonic in width, so the port width undercounts at depth. Falls
- *  back to the port, then a constant, when neither is measurable. */
+/** This list's own content element, not the scroll container: nested content lays out narrower,
+ *  and the height estimator wraps more lines the narrower it gets. */
 export function estimateWidth(listEl, portWidth) {
     return listEl?.clientWidth || portWidth || FALLBACK_CONTENT_WIDTH;
 }
-/**
- * This scope's list top in the scrollport's CONTENT space — the offset mapping port scrollTop
- * into the scope's local range. The two port terms are distinct and both load-bearing: an editor
- * embedded partway down a page-scrolled shell has a nonzero scroll AND page chrome above it, and
- * conflating them slices the window a band off.
- */
+/** The offset that converts the scroll container's `scrollTop` into this list's range. Viewport
+ *  top and scroll offset are separate terms: an editor partway down a scrolling page has both. */
 export function listTopWithinContent(listTop, viewportTop, scrollTop) {
     return listTop - viewportTop + scrollTop;
 }
-/** The intersection of the port's viewport with this scope's own box. Each nested scope
- *  occupies only part of the viewport, so windowing against the full port height would
- *  mount O(viewport × active-scope-count) blocks. The viewport arrives as top + client
- *  height so the intersection excludes the scrollbar/border. */
+/** Each nested list covers only part of the viewport; windowing each against the full height
+ *  would mount O(viewport × lists) blocks. Pass client height, which leaves out the scrollbar. */
 export function effectiveViewportHeight(viewportTop, viewportHeight, scopeTop, scopeHeight) {
     const top = Math.max(viewportTop, scopeTop);
     const bottom = Math.min(viewportTop + viewportHeight, scopeTop + scopeHeight);

package/dist/reactivity/state-registry.d.ts

@@ -1,10 +1,10 @@
-/** Resolve a container node (by identity; views accepted) to its BlockListState.
- *  WeakMap, so entries collect when the node becomes unreachable. */
+/** Find a container node's `BlockListState` by identity (a view works too). A `WeakMap`,
+ *  so entries are collected once the node is unreachable. */
 import type { NodeView } from '../core/node-views';
 import type { BlockListState } from './block-list-state.svelte';
-/** Overwrites any existing entry — the new state becomes authoritative on re-mount. */
+/** Overwrites any existing entry: on a remount the new state is the one that counts. */
 export declare function registerBlockListState(node: NodeView, state: BlockListState): void;
 export declare function getStateForNode(node: NodeView): BlockListState | undefined;
-/** Strict variant, for a caller holding a live-tree node whose container must be mounted.
- *  `getStateForNode` stays for the ancestor walks where absence is a valid signal. */
+/** The strict lookup, for a live-tree node whose container must be mounted. Ancestor
+ *  traversals, where a missing entry is a valid answer, use `getStateForNode`. */
 export declare function expectStateForNode(node: NodeView): BlockListState;

package/dist/reactivity/state-registry.js

@@ -1,42 +1,38 @@
-/** Resolve a container node (by identity; views accepted) to its BlockListState.
- *  WeakMap, so entries collect when the node becomes unreachable. */
-import { DEV } from 'esm-env';
+/** Find a container node's `BlockListState` by identity (a view works too). A `WeakMap`,
+ *  so entries are collected once the node is unreachable. */
+import { isDevChecks } from '../env';
 import { tick } from 'svelte';
 import { devWarn } from '../dev-warn';
 const stateRegistry = new WeakMap();
-/** Overwrites any existing entry — the new state becomes authoritative on re-mount. */
+/** Overwrites any existing entry: on a remount the new state is the one that counts. */
 export function registerBlockListState(node, state) {
     const existing = stateRegistry.get(node);
     stateRegistry.set(node, state);
-    if (DEV && existing && existing !== state) {
+    if (isDevChecks() && existing && existing !== state) {
         void reportContestedClaim(node, existing, state);
     }
 }
-/**
- * A dev signal, not a guarantee. Svelte creates a structural remount's new mount before
- * tearing the old one down, so a claim contested INSIDE a flush says nothing about
- * ownership; re-ask once it settles, when a loser still holding child refs means either a
- * second live owner or a teardown whose clear never reached the live slots.
- */
+/** Checked a tick later because Svelte mounts a remount's new component before tearing down the
+ *  one it replaces; a replaced state still holding child refs after that has a live rival. */
 async function reportContestedClaim(node, loser, winner) {
     await tick();
     if (stateRegistry.get(node) !== winner)
         return;
     if (loser.innerBlockRefs.every((ref) => ref === undefined))
         return;
-    devWarn('state-registry', `two live components claim the same ${node.kind} — the loser's child refs are orphaned. ` +
+    devWarn('state-registry', `two live components claim the same ${node.kind}: the loser's child refs are orphaned. ` +
         `Either both mounts render this node, or the loser's teardown emptied slots the ` +
         `scope no longer reads.`);
 }
 export function getStateForNode(node) {
     return stateRegistry.get(node);
 }
-/** Strict variant, for a caller holding a live-tree node whose container must be mounted.
- *  `getStateForNode` stays for the ancestor walks where absence is a valid signal. */
+/** The strict lookup, for a live-tree node whose container must be mounted. Ancestor
+ *  traversals, where a missing entry is a valid answer, use `getStateForNode`. */
 export function expectStateForNode(node) {
     const state = stateRegistry.get(node);
     if (!state) {
-        throw new Error(`[state-registry] no BlockListState registered for ${node.kind} — ` +
+        throw new Error(`[state-registry] no BlockListState registered for ${node.kind}: ` +
             `caller assumed a mounted container. If this path can visit non-container ` +
             `nodes, use getStateForNode and guard on undefined.`);
     }

package/dist/reactivity/use-container-windowing.svelte.d.ts

@@ -1,35 +1,22 @@
-import { type BlockElLookup } from '../editor-keys';
 import type { NodeView } from '../core/node-views';
-import type { RevealTarget } from '../cursor/reveal-anchor';
-import { type ListWindowing, type RevealAnchorPlacement } from './list-windowing.svelte';
+import type { RootListScroll } from '../cursor/scroll-owner';
+import { type ListWindowing } from './list-windowing.svelte';
 export interface ContainerWindowingOpts {
-    /** This container's index in its PARENT scope, for the upward subtotal report. A getter, so
-     *  reorders report under the current slot. Ignored at the root (no parent sink). */
-    getIndex: () => number;
-    /** This scope's path; the leaf-channel depth is its length. `[]` at the root. */
+    /** This list's path. */
     getParentPath: () => number[];
     getChildren: () => readonly NodeView[];
     getChildIds: () => string[];
-    /** The content-origin element that scrolls WITH this scope's children. Never the viewport. */
+    /** The element that scrolls with this list's children. Never the viewport. */
     getListEl: () => HTMLElement | null;
-    /** The element the PARENT measures for this scope's height. Omit at the root. */
-    getOwnEl?: () => HTMLElement | null;
-    /** True when this scope's DIRECT children are `BlockHost`s → shadow the leaf channel.
-     *  False for direct-`{#each}` scopes (list / table). */
-    provideLeafChannel: boolean;
-    /** Collapse clamp; see `ListWindowingDeps.isCollapsed`. */
+    /** True while collapsed; see `ListWindowingDeps.isCollapsed`. */
     isCollapsed?: () => boolean;
 }
-/**
- * Resolve the reveal target into the ROOT scope's coordinates. The model addresses
- * top-level children only, so a nested target contributes its ancestor's index plus the
- * measured drop down to itself — without which the pin re-asserts the CONTAINER's top and
- * pushes an already-resolved nested target back out of view.
- */
-export declare function placementOf(target: RevealTarget | null, blockEl: BlockElLookup): RevealAnchorPlacement | null;
-/**
- * One windowing wiring unit per BlockList-bearing or direct-each container scope: reads
- * the windowing contexts, builds `createListWindowing` with the shared constants, and
- * provides the subtotal sink plus the leaf channel. Call synchronously during component init.
- */
+/** One windowing unit per nested container, whether it renders a `BlockList` or its own
+ *  `{#each}`. Call synchronously during component init, since it reads and sets context. */
 export declare function useContainerWindowing(opts: ContainerWindowingOpts): ListWindowing;
+/** The editor root's windowing, and the one height correction the header slot shares, which
+ *  re-places a held target. Null without the editor's services, as in a harness. */
+export declare function useRootWindowing(opts: Pick<ContainerWindowingOpts, 'getChildren' | 'getChildIds' | 'getListEl'>): {
+    windowing: ListWindowing;
+    scroll: RootListScroll | null;
+};

package/dist/reactivity/use-container-windowing.svelte.js

@@ -1,95 +1,85 @@
-import { getContext, setContext } from 'svelte';
-import { EDITOR_DOC_KEY, EDITOR_SERVICES_KEY, PARENT_SCOPE_SINK_KEY, RECORD_BLOCK_HEIGHT_KEY } from '../editor-keys';
+import { getContext, onDestroy, setContext, tick } from 'svelte';
+import { CHILD_MEASURE_KEY, EDITOR_DOC_KEY, EDITOR_SERVICES_KEY } from '../editor-keys';
+import { observeResize } from '../cursor/observe-resize';
+import { assertInvariant } from '../assert';
+import { checkMeasuresInOwnList } from '../invariants/measures-in-own-list';
 import { createListWindowing } from './list-windowing.svelte';
-/**
- * Resolve the reveal target into the ROOT scope's coordinates. The model addresses
- * top-level children only, so a nested target contributes its ancestor's index plus the
- * measured drop down to itself — without which the pin re-asserts the CONTAINER's top and
- * pushes an already-resolved nested target back out of view.
- */
-export function placementOf(target, blockEl) {
-    if (!target || target.path.length === 0)
-        return null;
-    const shallow = { index: target.path[0], block: target.block, innerOffset: 0, height: null };
-    if (target.path.length === 1)
-        return shallow;
-    const ancestorEl = blockEl([shallow.index]);
-    const targetEl = blockEl(target.path);
-    // The ancestor's top is a DIFFERENT block, honest only while the ancestor itself is
-    // windowed out and the model's offset is all that is known. A MOUNTED ancestor missing its
-    // target means the reader scrolled past it inside the container: decline, never teleport.
-    if (!ancestorEl)
-        return shallow;
-    if (!targetEl)
-        return null;
-    const targetRect = targetEl.getBoundingClientRect();
-    return {
-        index: shallow.index,
-        block: target.block,
-        innerOffset: targetRect.top - ancestorEl.getBoundingClientRect().top,
-        height: targetRect.height
-    };
-}
-/**
- * One windowing wiring unit per BlockList-bearing or direct-each container scope: reads
- * the windowing contexts, builds `createListWindowing` with the shared constants, and
- * provides the subtotal sink plus the leaf channel. Call synchronously during component init.
- */
+/** One windowing unit per nested container, whether it renders a `BlockList` or its own
+ *  `{#each}`. Call synchronously during component init, since it reads and sets context. */
 export function useContainerWindowing(opts) {
-    const { heightOracle: oracle, scrollport: getPort, correctsScroll, focusedPath: getFocusPath, widthVersion: getWidthVersion, viewportHeightVersion: getViewportHeightVersion, blockElLookup } = getContext(EDITOR_DOC_KEY);
-    const parentSink = getContext(PARENT_SCOPE_SINK_KEY);
-    const revealAnchor = getContext(EDITOR_SERVICES_KEY)?.revealAnchor;
-    // Single-claimant: nested scopes keep top-of-viewport anchoring, or their deltas would
-    // fight over one scrollTop.
-    const claimsRevealAnchor = opts.getParentPath().length === 0;
+    return windowingUnit(opts);
+}
+/** The editor root's windowing, and the one height correction the header slot shares, which
+ *  re-places a held target. Null without the editor's services, as in a harness. */
+export function useRootWindowing(opts) {
+    const scrollOwner = getContext(EDITOR_SERVICES_KEY)?.scrollOwner;
+    const { listTree } = getContext(EDITOR_DOC_KEY);
+    const windowing = windowingUnit({ ...opts, getParentPath: () => [] });
+    let scroll = null;
+    if (scrollOwner && listTree) {
+        scroll = scrollOwner.resolveTargetsWith({
+            resolve: listTree.resolve,
+            holdForRound: listTree.holdForRound,
+            mountTop: listTree.mountTop,
+            syncScrollTop: () => windowing.syncScrollTop()
+        });
+        onDestroy(scroll.uninstall);
+    }
+    return { windowing, scroll };
+}
+function windowingUnit(opts) {
+    const { heightOracle: oracle, scrollport: getPort, focusedPath: getFocusPath, widthVersion: getWidthVersion, viewportHeightVersion: getViewportHeightVersion, listTree } = getContext(EDITOR_DOC_KEY);
+    const scrollOwner = getContext(EDITOR_SERVICES_KEY)?.scrollOwner;
+    // A bare mount has no owner: its heights land, and nothing holds the page still.
+    const scroll = scrollOwner
+        ? {
+            beginRound: scrollOwner.beginRound,
+            roundOpen: scrollOwner.roundOpen,
+            measureSoon: scrollOwner.measureSoon,
+            scrollToMount: scrollOwner.scrollToMount
+        }
+        : {
+            beginRound: () => { },
+            roundOpen: () => false,
+            measureSoon: (run) => void tick().then(run),
+            scrollToMount: () => { }
+        };
     const windowing = createListWindowing({
         oracle,
         getChildren: opts.getChildren,
         getChildIds: opts.getChildIds,
         getListEl: opts.getListEl,
-        getOwnEl: opts.getOwnEl,
         getPort: () => getPort?.() ?? null,
-        correctsScroll: () => correctsScroll?.() ?? true,
+        scroll,
         getFocusPath: () => getFocusPath?.() ?? null,
-        getRevealAnchorTarget: claimsRevealAnchor
-            ? () => placementOf(revealAnchor?.get() ?? null, blockElLookup)
-            : undefined,
         getWidthVersion: () => getWidthVersion?.() ?? 0,
         getViewportHeightVersion: () => getViewportHeightVersion?.() ?? 0,
         getParentPath: opts.getParentPath,
-        reportSelfHeight: parentSink
-            ? (h) => parentSink.setChildSubtotal(opts.getIndex(), h)
-            : undefined,
         isCollapsed: opts.isCollapsed,
-        // A fling can outrun the deferred window recompute and briefly paint an empty spacer
-        // (VR-8). 6 widens the band without breaching the mounted-set ceiling (the < 60 flat
-        // e2e bound guards that); a skeleton background covers the residual one-frame gap.
+        // Wide enough that a fast scroll rarely outruns the window recompute and paints an empty
+        // spacer (VR-8), narrow enough to keep the count of mounted blocks low.
         overscan: 6,
         pinExtensionCap: 100,
         activateAbovePx: 4000,
         deactivateBelowPx: 3000
     });
-    if (opts.provideLeafChannel) {
-        // Only a DIRECT child measures into this model; a deeper host belongs to its own
-        // scope's channel, so register is a no-op here.
-        setContext(RECORD_BLOCK_HEIGHT_KEY, {
-            register(path, index, id, readHeight) {
-                const depth = opts.getParentPath().length;
-                if (path.length !== depth + 1)
-                    return () => { };
-                return windowing.registerChild(id, {
-                    readHeight,
-                    applyHeight: (h) => windowing.recordMeasuredChild(index, id, h)
-                });
-            },
-            measureNow: windowing.measureChildNow,
-            measureOnResize: windowing.measureChildOnResize
-        });
-    }
-    setContext(PARENT_SCOPE_SINK_KEY, {
-        setChildSubtotal: windowing.setChildSubtotal,
-        registerRow: (id, readHeight, applyHeight) => windowing.registerChild(id, { readHeight, applyHeight }),
-        measureRowNow: windowing.measureChildNow
+    if (listTree)
+        onDestroy(listTree.add(windowing.level));
+    // A child that isn't this list's own would write a slot that indexes something else.
+    setContext(CHILD_MEASURE_KEY, {
+        register(path, id, readHeight) {
+            const foreign = checkMeasuresInOwnList(path, opts.getParentPath());
+            if (foreign) {
+                assertInvariant('measures-in-own-list', () => foreign);
+                return () => { };
+            }
+            return windowing.registerChild(id, { index: path[path.length - 1], readHeight });
+        },
+        measureNow: windowing.measureChildNow,
+        measureOnResize: windowing.measureChildOnResize,
+        watchSize: scrollOwner
+            ? scrollOwner.watchSize
+            : (el, onResize) => observeResize(el, (entries) => entries[0] && onResize(entries[0]))
     });
     return windowing;
 }

package/dist/reactivity/use-measured-child.svelte.d.ts

@@ -0,0 +1,10 @@
+export interface MeasuredChildOpts {
+    getId: () => string;
+    /** The child's own path; its last index is its position in the list. */
+    getPath: () => readonly number[];
+    /** The element whose border box is the child's height. */
+    getEl: () => HTMLElement | null;
+    /** Read reactively: a change re-measures, except at mount, which the batched pass owns. */
+    getRaw: () => string;
+}
+export declare function useMeasuredChild(opts: MeasuredChildOpts): void;

package/dist/reactivity/use-measured-child.svelte.js

@@ -0,0 +1,41 @@
+/**
+ * A windowed child's height reaches its own block list's height table: in the list's batched
+ * pass at mount, again after an edit, and again on a resize. Call during component init, and
+ * before the component provides a block list of its own, since it reads its list's channel.
+ */
+import { getContext, untrack } from 'svelte';
+import { CHILD_MEASURE_KEY } from '../editor-keys';
+export function useMeasuredChild(opts) {
+    const channel = getContext(CHILD_MEASURE_KEY);
+    // Absent only in a bare test mount with no list above.
+    if (!channel)
+        return;
+    const readHeight = () => opts.getEl()?.getBoundingClientRect().height ?? 0;
+    // A primitive, so a fresh path array for the same position doesn't register the child again.
+    const registration = $derived(`${opts.getPath().join()}|${opts.getId()}`);
+    $effect(() => {
+        void registration;
+        return untrack(() => channel.register(opts.getPath(), opts.getId(), readHeight));
+    });
+    let firstRun = true;
+    $effect(() => {
+        void opts.getRaw();
+        if (firstRun) {
+            firstRun = false;
+            return;
+        }
+        untrack(() => channel.measureNow(opts.getId()));
+    });
+    // Growth with no edit (an image decoding, a formula showing its source) would slide the page.
+    $effect(() => {
+        const el = opts.getEl();
+        if (!el)
+            return;
+        return channel.watchSize(el, (entry) => {
+            const box = entry.borderBoxSize?.[0];
+            const height = box ? box.blockSize : entry.contentRect?.height;
+            if (height != null)
+                channel.measureOnResize(opts.getId(), height);
+        });
+    });
+}