@joewinke/jatui 0.26.0 → 0.27.1

package/dist/utils/pollBackoff.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Poll backoff — coordinated exponential backoff for independent pollers.
+ * Upstreamed from the JAT IDE `utils/pollBackoff.ts` (adoption audit U12,
+ * jatui-rl7w6.5; jat-gtdiz upstream).
+ *
+ * ## The problem
+ *
+ * A dozen independent pollers (agents, tasks, sessions, …) each retrying on
+ * a fixed `setInterval` cadence no matter what multiply into a refetch storm
+ * when their endpoint goes down — every poller keeps firing at full rate and
+ * the browser's ~6-socket HTTP/1.1 pool saturates.
+ *
+ * ## The fix
+ *
+ * A single self-scheduling poll loop that:
+ *  - fires `tick()` every `intervalMs` while healthy,
+ *  - on failure (tick throws, rejects, or resolves `false`) backs off
+ *    exponentially with jitter, capped at `maxIntervalMs`,
+ *  - resets to the base interval on the first success,
+ *  - skips the fetch entirely while `document.visibilityState === 'hidden'`
+ *    (re-checking on the current cadence so it resumes the moment the tab is
+ *    visible again),
+ *  - never overlaps ticks: the next tick is scheduled only after the previous
+ *    one settles, so failures cannot pile up concurrent loops.
+ *
+ * Framework-free (no runes) — each store constructs its own instance and owns
+ * its lifecycle (start on subscribe/poll-start, stop on
+ * unsubscribe/poll-stop). It complements `pollOperation` (one-shot operation
+ * polling) and pairs with `useElapsedEstimate`; see also the shared `quota`
+ * helpers — this covers the *recurring* case those do not.
+ *
+ * `createPollLoop` is a tiny factory wrapper so hosts can construct the loop
+ * without `new` (and future implementations can swap underneath it).
+ *
+ * Usage:
+ * ```ts
+ * const poller = createPollLoop({
+ *   name: 'agents',
+ *   intervalMs: 3000,
+ *   maxIntervalMs: 60_000,
+ *   tick: () => store.fetch()   // return false (or throw) on failure
+ * });
+ * poller.start();
+ * poller.stop();                 // on teardown
+ * ```
+ */
+export interface PollBackoffOptions {
+    /** Stable name for logs — e.g. the store or endpoint being polled. */
+    name: string;
+    /** Healthy poll interval (also the minimum delay and the backoff base). */
+    intervalMs: number;
+    /** Backoff cap. Defaults to 60_000 (1 minute). */
+    maxIntervalMs?: number;
+    /** Jitter as a fraction of the delay (±). Defaults to 0.25. */
+    jitterRatio?: number;
+    /**
+     * The poll body. Resolve `true`/`void` for success or a benign skip
+     * (e.g. a duplicate in-flight request). Resolve `false` or throw to
+     * signal failure and trigger backoff.
+     */
+    tick: () => Promise<boolean | void>;
+}
+/**
+ * Pure backoff-delay calculation (extracted for unit testability).
+ * `failures` is the number of consecutive failures so far (1 = first failure).
+ */
+export declare function computeBackoffDelayMs(failures: number, intervalMs: number, maxIntervalMs?: number, jitterRatio?: number): number;
+export declare class PollBackoff {
+    #private;
+    constructor(opts: PollBackoffOptions);
+    /** Begin (or resume) the poll loop. Idempotent while already running. */
+    start(): void;
+    /** Stop the loop and clear any pending tick. Safe to call repeatedly. */
+    stop(): void;
+    /** Forget accumulated failures so the next tick runs at the base interval. */
+    reset(): void;
+    get isActive(): boolean;
+}
+/**
+ * Factory form of `PollBackoff` — the `createPollLoop` name the adoption
+ * audit (U12) lands this under. Same options, same instance API.
+ */
+export declare function createPollLoop(opts: PollBackoffOptions): PollBackoff;

package/dist/utils/pollBackoff.js

@@ -0,0 +1,151 @@
+/**
+ * Poll backoff — coordinated exponential backoff for independent pollers.
+ * Upstreamed from the JAT IDE `utils/pollBackoff.ts` (adoption audit U12,
+ * jatui-rl7w6.5; jat-gtdiz upstream).
+ *
+ * ## The problem
+ *
+ * A dozen independent pollers (agents, tasks, sessions, …) each retrying on
+ * a fixed `setInterval` cadence no matter what multiply into a refetch storm
+ * when their endpoint goes down — every poller keeps firing at full rate and
+ * the browser's ~6-socket HTTP/1.1 pool saturates.
+ *
+ * ## The fix
+ *
+ * A single self-scheduling poll loop that:
+ *  - fires `tick()` every `intervalMs` while healthy,
+ *  - on failure (tick throws, rejects, or resolves `false`) backs off
+ *    exponentially with jitter, capped at `maxIntervalMs`,
+ *  - resets to the base interval on the first success,
+ *  - skips the fetch entirely while `document.visibilityState === 'hidden'`
+ *    (re-checking on the current cadence so it resumes the moment the tab is
+ *    visible again),
+ *  - never overlaps ticks: the next tick is scheduled only after the previous
+ *    one settles, so failures cannot pile up concurrent loops.
+ *
+ * Framework-free (no runes) — each store constructs its own instance and owns
+ * its lifecycle (start on subscribe/poll-start, stop on
+ * unsubscribe/poll-stop). It complements `pollOperation` (one-shot operation
+ * polling) and pairs with `useElapsedEstimate`; see also the shared `quota`
+ * helpers — this covers the *recurring* case those do not.
+ *
+ * `createPollLoop` is a tiny factory wrapper so hosts can construct the loop
+ * without `new` (and future implementations can swap underneath it).
+ *
+ * Usage:
+ * ```ts
+ * const poller = createPollLoop({
+ *   name: 'agents',
+ *   intervalMs: 3000,
+ *   maxIntervalMs: 60_000,
+ *   tick: () => store.fetch()   // return false (or throw) on failure
+ * });
+ * poller.start();
+ * poller.stop();                 // on teardown
+ * ```
+ */
+/** Default backoff cap: 1 minute. */
+const DEFAULT_MAX_INTERVAL_MS = 60_000;
+/** Default jitter: ±25%. */
+const DEFAULT_JITTER_RATIO = 0.25;
+/** Doubling stops growing past 2^6 = 64× the base interval. */
+const MAX_EXPONENT = 6;
+/**
+ * Pure backoff-delay calculation (extracted for unit testability).
+ * `failures` is the number of consecutive failures so far (1 = first failure).
+ */
+export function computeBackoffDelayMs(failures, intervalMs, maxIntervalMs = DEFAULT_MAX_INTERVAL_MS, jitterRatio = DEFAULT_JITTER_RATIO) {
+    const exponent = Math.min(Math.max(failures, 1), MAX_EXPONENT);
+    const base = Math.min(intervalMs * Math.pow(2, exponent), maxIntervalMs);
+    const jitter = base * jitterRatio * (Math.random() * 2 - 1);
+    // Never schedule faster than the healthy interval, even with negative jitter.
+    return Math.max(intervalMs, Math.round(base + jitter));
+}
+export class PollBackoff {
+    #opts;
+    #maxIntervalMs;
+    #jitterRatio;
+    #timer = null;
+    #failures = 0;
+    #stopped = true;
+    constructor(opts) {
+        this.#opts = opts;
+        this.#maxIntervalMs = opts.maxIntervalMs ?? DEFAULT_MAX_INTERVAL_MS;
+        this.#jitterRatio = opts.jitterRatio ?? DEFAULT_JITTER_RATIO;
+        if (this.#jitterRatio < 0 || this.#jitterRatio >= 1) {
+            throw new Error(`PollBackoff(${opts.name}): jitterRatio must be in [0, 1)`);
+        }
+    }
+    /** Begin (or resume) the poll loop. Idempotent while already running. */
+    start() {
+        if (!this.#stopped)
+            return;
+        this.#stopped = false;
+        this.#failures = 0;
+        this.#schedule(this.#opts.intervalMs);
+    }
+    /** Stop the loop and clear any pending tick. Safe to call repeatedly. */
+    stop() {
+        this.#stopped = true;
+        if (this.#timer !== null) {
+            clearTimeout(this.#timer);
+            this.#timer = null;
+        }
+    }
+    /** Forget accumulated failures so the next tick runs at the base interval. */
+    reset() {
+        this.#failures = 0;
+    }
+    get isActive() {
+        return !this.#stopped;
+    }
+    #schedule(delayMs) {
+        if (this.#stopped)
+            return;
+        if (this.#timer !== null)
+            clearTimeout(this.#timer);
+        this.#timer = setTimeout(() => {
+            this.#timer = null;
+            void this.#runTick();
+        }, delayMs);
+    }
+    /** Current inter-tick delay given consecutive failures (0 = healthy). */
+    #nextDelayMs() {
+        if (this.#failures === 0)
+            return this.#opts.intervalMs;
+        return computeBackoffDelayMs(this.#failures, this.#opts.intervalMs, this.#maxIntervalMs, this.#jitterRatio);
+    }
+    async #runTick() {
+        if (this.#stopped)
+            return;
+        // Never fetch while the tab is hidden — but keep the loop alive on the
+        // current cadence so polling resumes the instant the tab is visible.
+        if (typeof document !== 'undefined' && document.visibilityState === 'hidden') {
+            this.#schedule(this.#nextDelayMs());
+            return;
+        }
+        try {
+            const result = await this.#opts.tick();
+            if (result === false) {
+                throw new Error(`PollBackoff(${this.#opts.name}): tick reported failure`);
+            }
+            this.#failures = 0;
+        }
+        catch (err) {
+            this.#failures += 1;
+            const delayMs = computeBackoffDelayMs(this.#failures, this.#opts.intervalMs, this.#maxIntervalMs, this.#jitterRatio);
+            // First failure logs at warn so a storm is visible; do not spam per retry.
+            if (this.#failures === 1 || this.#failures % 5 === 0) {
+                console.warn(`PollBackoff(${this.#opts.name}): poll failed ×${this.#failures}, backing off ${delayMs}ms`, err);
+            }
+        }
+        this.#schedule(this.#nextDelayMs());
+    }
+}
+/**
+ * Factory form of `PollBackoff` — the `createPollLoop` name the adoption
+ * audit (U12) lands this under. Same options, same instance API.
+ */
+export function createPollLoop(opts) {
+    return new PollBackoff(opts);
+}

package/dist/utils/snapFlick.d.ts

@@ -0,0 +1,59 @@
+/**
+ * snapFlick.ts — pure snap-point + flick-momentum math for the bottom-sheet
+ * inspector pattern (docs/reviews/wayflow-ide-adoption-eval.md §6b).
+ *
+ * The BottomSheet drag gesture feeds pointer deltas and a measured release
+ * velocity into `resolveSnapTarget`, which decides where the sheet settles:
+ *
+ *   • flick-momentum release — a fast flick (≥ FLICK_VELOCITY_PX_MS) wins over
+ *     position: flick up → next (taller) snap, flick down → previous (shorter)
+ *     snap, or dismissal when already at the peek snap.
+ *   • otherwise the snap closest to the post-drag height wins (position release).
+ *
+ * Pure and DOM-free so it is unit-testable; BottomSheet.svelte applies the
+ * result to its own drag state.
+ */
+/** Velocity (px/ms) at or above which a release counts as a flick. */
+export declare const FLICK_VELOCITY_PX_MS = 0.5;
+export type SnapName = 'peek' | 'expanded';
+export interface SnapHeight {
+    name: SnapName;
+    /** Height of the snap point in px (already resolved against the viewport). */
+    heightPx: number;
+}
+export interface SnapInput {
+    /** Net pointer travel since drag start: positive = dragged down. */
+    dragDeltaY: number;
+    /** Measured release velocity: positive = moving down, px/ms. */
+    velocity: number;
+    /** Snap points ordered peek → expanded (ascending height). */
+    snapPoints: SnapHeight[];
+    /** Index of the snap the sheet was resting at when the drag began. */
+    currentIndex: number;
+}
+export interface SnapResult {
+    /** Snap index to settle at (bounded to snapPoints). */
+    index: number;
+    /**
+     * True when a downward flick from the shortest snap requests dismissal
+     * (the classic flick-the-sheet-away gesture). The caller closes the sheet.
+     */
+    dismiss: boolean;
+}
+export declare function resolveSnapTarget(input: SnapInput): SnapResult;
+/**
+ * Keyboard avoidance (wayflow §6b): the visible viewport shrinks when the soft
+ * keyboard opens. The inset the sheet must clear is what `window.innerHeight`
+ * counts but the `visualViewport` no longer covers, plus whatever the visual
+ * viewport itself is pushed up by.
+ */
+export declare function keyboardInsetPx(visualViewport: {
+    height: number;
+    offsetTop: number;
+}, windowInnerHeight: number): number;
+/**
+ * Height of the sheet at a snap point, clamped to what is actually visible —
+ * under keyboard avoidance the usable height is the visual viewport's, so an
+ * expanded snap can never extend behind the keyboard.
+ */
+export declare function clampSnapHeight(snapHeightPx: number, availableHeightPx: number): number;

package/dist/utils/snapFlick.js

@@ -0,0 +1,66 @@
+/**
+ * snapFlick.ts — pure snap-point + flick-momentum math for the bottom-sheet
+ * inspector pattern (docs/reviews/wayflow-ide-adoption-eval.md §6b).
+ *
+ * The BottomSheet drag gesture feeds pointer deltas and a measured release
+ * velocity into `resolveSnapTarget`, which decides where the sheet settles:
+ *
+ *   • flick-momentum release — a fast flick (≥ FLICK_VELOCITY_PX_MS) wins over
+ *     position: flick up → next (taller) snap, flick down → previous (shorter)
+ *     snap, or dismissal when already at the peek snap.
+ *   • otherwise the snap closest to the post-drag height wins (position release).
+ *
+ * Pure and DOM-free so it is unit-testable; BottomSheet.svelte applies the
+ * result to its own drag state.
+ */
+/** Velocity (px/ms) at or above which a release counts as a flick. */
+export const FLICK_VELOCITY_PX_MS = 0.5;
+export function resolveSnapTarget(input) {
+    const { dragDeltaY, velocity, snapPoints, currentIndex } = input;
+    if (snapPoints.length === 0) {
+        return { index: 0, dismiss: false };
+    }
+    const at = Math.max(0, Math.min(snapPoints.length - 1, currentIndex));
+    // Flick-momentum release: a fast flick overrides position entirely.
+    if (Math.abs(velocity) >= FLICK_VELOCITY_PX_MS) {
+        if (velocity < 0) {
+            // Upward flick → grow toward the tallest snap.
+            return { index: Math.min(snapPoints.length - 1, at + 1), dismiss: false };
+        }
+        // Downward flick → shrink one snap; from the shortest snap, dismiss.
+        if (at === 0)
+            return { index: 0, dismiss: true };
+        return { index: at - 1, dismiss: false };
+    }
+    // Position release: the height the sheet would rest at after the drag
+    // (dragging down shrinks the sheet) settles on the nearest snap point.
+    const currentHeight = snapPoints[at].heightPx;
+    const restHeight = Math.max(0, currentHeight - dragDeltaY);
+    let best = at;
+    let bestDist = Infinity;
+    snapPoints.forEach((p, i) => {
+        const dist = Math.abs(p.heightPx - restHeight);
+        if (dist < bestDist) {
+            bestDist = dist;
+            best = i;
+        }
+    });
+    return { index: best, dismiss: false };
+}
+/**
+ * Keyboard avoidance (wayflow §6b): the visible viewport shrinks when the soft
+ * keyboard opens. The inset the sheet must clear is what `window.innerHeight`
+ * counts but the `visualViewport` no longer covers, plus whatever the visual
+ * viewport itself is pushed up by.
+ */
+export function keyboardInsetPx(visualViewport, windowInnerHeight) {
+    return Math.max(0, windowInnerHeight - (visualViewport.height + visualViewport.offsetTop));
+}
+/**
+ * Height of the sheet at a snap point, clamped to what is actually visible —
+ * under keyboard avoidance the usable height is the visual viewport's, so an
+ * expanded snap can never extend behind the keyboard.
+ */
+export function clampSnapHeight(snapHeightPx, availableHeightPx) {
+    return Math.max(0, Math.min(snapHeightPx, availableHeightPx));
+}

package/dist/video/advisors/qr.d.ts

@@ -50,7 +50,7 @@ declare function rsEncode(data: Uint8Array, ecLen: number): Uint8Array;
 declare function rsSyndromes(block: number[], ecLen: number): Uint8Array;
 declare function formatBits(ecc: string, mask: number): number;
 declare function versionBits(version: number): number;
-declare const charCountBits: (version: number) => 8 | 16;
+declare const charCountBits: (version: number) => 16 | 8;
 declare const dataCodewords: (version: number, ecc: EccLevel) => number;
 declare const maxBytes: (version: number, ecc: EccLevel) => number;
 declare function toBytes(text: unknown): Uint8Array;

package/dist/virtual/createRowWindow.d.ts

@@ -0,0 +1,75 @@
+import { type RowWindowAlign, type RowWindowItem } from './rowWindowCore';
+export type { RowWindowAlign, RowWindowItem, RowWindowSnapshot } from './rowWindowCore';
+export interface RowWindowOptions<K = string> {
+    /** Number of items in the render list (rows + group headers). Reactive getter. */
+    count: () => number;
+    /** Stable, unique key for item i (task id, or `group:<key>` for a header). */
+    getKey: (index: number) => K;
+    /** First-paint height guess per item, px. Measured heights replace it. */
+    estimateSize: (index: number) => number;
+    /**
+     * The element that scrolls. `'auto'` (default) = the nearest ancestor that
+     * really scrolls (overflow auto/scroll AND content taller than it), else the
+     * window. An `overflow-auto` wrapper that grows with its content is skipped,
+     * which fixes the dash case. Re-resolved when the anchor or root resizes.
+     */
+    scrollRoot?: HTMLElement | Window | 'auto';
+    /** Extra items rendered above and below the viewport. Default 6. */
+    overscan?: number;
+    /**
+     * Keys that stay rendered even when out of view: an exiting row, the focused
+     * row, an open inline editor or popover. Reactive getter.
+     */
+    pinned?: () => Iterable<K>;
+    /**
+     * Below this count, render everything. That keeps FLIP and enter animations
+     * intact on small lists. Default 0 = always window. Reactive when passed as
+     * a getter (`get threshold() { return t }`).
+     */
+    threshold?: number;
+    /**
+     * Indices of sticky items (group headers). The active one for the current
+     * scroll offset is always rendered. For nested groups, pass one array per
+     * level, outermost first (`[projectHeaders, epicHeaders]`), and each level
+     * keeps its own active header rendered. Reactive getter.
+     */
+    stickyIndices?: () => readonly number[] | readonly (readonly number[])[];
+    /** Height a sticky header covers at the top, px. `scrollTo*` keeps targets below it. */
+    scrollPaddingStart?: number;
+    /** Height of a sticky footer at the bottom, px. */
+    scrollPaddingEnd?: number;
+    /** Viewport height assumed on the server and before mount, px. Default 800. */
+    initialViewportSize?: number;
+}
+export interface RowWindow<K = string> {
+    /** Reactive: the items to render, in order, with their offsets. */
+    readonly items: ReadonlyArray<RowWindowItem<K>>;
+    /** Spacer above the rendered slice, px. */
+    readonly paddingTop: number;
+    /** Spacer below the rendered slice, px. */
+    readonly paddingBottom: number;
+    /** Height of the whole list, px. */
+    readonly totalSize: number;
+    /** False while `count < threshold` (everything is rendered). */
+    readonly windowed: boolean;
+    /** Svelte action for each rendered item: `use:win.measure={item.key}`. */
+    measure: (node: HTMLElement, key: K) => {
+        update(key: K): void;
+        destroy(): void;
+    };
+    /** Svelte action for the anchor element (a `<tbody>` or list container). */
+    anchor: (node: HTMLElement) => {
+        destroy(): void;
+    };
+    scrollToIndex(index: number, opts?: {
+        align?: RowWindowAlign;
+    }): void;
+    scrollToKey(key: K, opts?: {
+        align?: RowWindowAlign;
+    }): void;
+    /** Index of `key` in the render list, or -1. */
+    indexOf(key: K): number;
+    /** Drop cached heights and re-measure, e.g. after a column-width change. */
+    remeasure(): void;
+}
+export declare function createRowWindow<K = string>(opts: RowWindowOptions<K>): RowWindow<K>;

package/dist/virtual/createRowWindow.js

@@ -0,0 +1,129 @@
+/* createRowWindow.svelte.js generated by Svelte v5.53.11 */
+import * as $ from 'svelte/internal/client';
+import { untrack } from 'svelte';
+import { EMPTY_SNAPSHOT, RowWindowEngine } from './rowWindowCore';
+
+export function createRowWindow(opts) {
+	let snap = $.state(EMPTY_SNAPSHOT);
+
+	const engine = new RowWindowEngine({
+		overscan: opts.overscan ?? 6,
+		threshold: opts.threshold ?? 0,
+		scrollRoot: opts.scrollRoot ?? 'auto',
+		initialViewportSize: opts.initialViewportSize ?? 800,
+		scrollPaddingStart: opts.scrollPaddingStart ?? 0,
+		scrollPaddingEnd: opts.scrollPaddingEnd ?? 0,
+		onChange: (s) => {
+			$.set(snap, s);
+		}
+	});
+
+	const readItems = () => {
+		const n = Math.max(0, Math.floor(opts.count()));
+		const keys = new Array(n);
+		const estimates = new Array(n);
+
+		for (let i = 0; i < n; i++) {
+			keys[i] = opts.getKey(i);
+			estimates[i] = opts.estimateSize(i);
+		}
+
+		engine.setItems(keys, estimates);
+	};
+
+	// Eager first pass, so SSR (where effects never run) and the first client
+	// render already have a slice to draw.
+	untrack(() => {
+		if (opts.stickyIndices) engine.setSticky(opts.stickyIndices());
+		if (opts.pinned) engine.setPinned(opts.pinned());
+
+		readItems();
+	});
+
+	// dist is compiled with `generate: 'client'` (scripts/compile-rune-modules.mjs),
+	// so an effect created during SSR throws `effect_orphan`. The server render
+	// has everything it needs from the eager pass above.
+	if (typeof window !== 'undefined') {
+		$.user_pre_effect(() => {
+			engine.setThreshold(opts.threshold ?? 0);
+		});
+
+		$.user_pre_effect(() => {
+			readItems();
+		});
+
+		if (opts.pinned) {
+			const pinned = opts.pinned;
+
+			$.user_pre_effect(() => {
+				engine.setPinned(pinned());
+			});
+		}
+
+		if (opts.stickyIndices) {
+			const sticky = opts.stickyIndices;
+
+			$.user_pre_effect(() => {
+				engine.setSticky(sticky());
+			});
+		}
+
+		$.user_effect(() => () => engine.destroy());
+	}
+
+	return {
+		get items() {
+			return $.get(snap).items;
+		},
+
+		get paddingTop() {
+			return $.get(snap).paddingTop;
+		},
+
+		get paddingBottom() {
+			return $.get(snap).paddingBottom;
+		},
+
+		get totalSize() {
+			return $.get(snap).totalSize;
+		},
+
+		get windowed() {
+			return $.get(snap).windowed;
+		},
+
+		measure(node, key) {
+			let current = key;
+
+			engine.measure(node, current);
+
+			return {
+				update(next) {
+					if (next === current) return;
+
+					engine.unmeasure(node, current);
+					current = next;
+					engine.measure(node, current);
+				},
+
+				destroy() {
+					engine.unmeasure(node, current);
+				}
+			};
+		},
+
+		anchor(node) {
+			engine.attach(node);
+
+			return {
+				destroy() {
+					engine.detach();
+				}
+			};
+		},
+		scrollToIndex: (index, o) => engine.scrollToIndex(index, o),
+		scrollToKey: (key, o) => engine.scrollToKey(key, o),
+		indexOf: (key) => engine.indexOf(key),
+		remeasure: () => engine.remeasure()
+	};
+}

package/dist/virtual/index.d.ts

@@ -0,0 +1,4 @@
+export { createRowWindow } from './createRowWindow';
+export type { RowWindow, RowWindowOptions } from './createRowWindow';
+export { RowWindowEngine, activeStickyIndices, extractWindowIndices, findScrollRoot, layoutWindow, normalizeStickyLevels } from './rowWindowCore';
+export type { RowWindowAlign, RowWindowEngineOptions, RowWindowItem, RowWindowSnapshot, WindowPolicy } from './rowWindowCore';

package/dist/virtual/index.js

@@ -0,0 +1,5 @@
+// Subpath entry: @joewinke/jatui/virtual — requires peer @tanstack/virtual-core.
+// Kept out of the root barrel so consumers that never window a list need not
+// install the optional peer (the dnd lesson, 6c9b104).
+export { createRowWindow } from './createRowWindow';
+export { RowWindowEngine, activeStickyIndices, extractWindowIndices, findScrollRoot, layoutWindow, normalizeStickyLevels } from './rowWindowCore';