@satinhq/kit 0.0.0-stage → 0.1.0-beta.0

package/dist/navigation/routeCodec.js

@@ -0,0 +1,123 @@
+import { isSerializableState } from '../restoration/scene.js';
+/** Each route is independently versioned so updates keep the deepest valid ancestor. */
+export function createRouteCodec(registry) {
+    const decode = (input) => {
+        try {
+            if (!input || typeof input !== 'object')
+                return null;
+            const route = input;
+            if (typeof route.screen !== 'string' ||
+                !Number.isInteger(route.version) ||
+                (route.params !== undefined && !isSerializableState(route.params)))
+                return null;
+            const definition = registry.resolve(route.screen), schema = definition?.restoration;
+            if (!schema || route.version !== schema.version || !schema.validate(route.params))
+                return null;
+            return {
+                screen: route.screen,
+                version: schema.version,
+                ...(route.params === undefined ? {} : { params: route.params }),
+            };
+        }
+        catch {
+            return null;
+        }
+    };
+    const decodePath = (input) => {
+        if (!Array.isArray(input))
+            return [];
+        const path = [];
+        for (const item of input.slice(0, 64)) {
+            const route = decode(item);
+            if (!route)
+                break;
+            path.push(route);
+        }
+        return path;
+    };
+    return {
+        decode,
+        decodePath,
+        pushRules(tabs) {
+            return Object.fromEntries(registry.definitions
+                .filter(screen => screen.restoration?.pushParams)
+                .map(screen => [
+                screen.id,
+                {
+                    params: screen.restoration.pushParams,
+                    version: screen.restoration.version,
+                    validate: screen.restoration.validate,
+                    schemaOwned: screen.restoration.schemaOwned,
+                    ...(tabs ? { tabs } : {}),
+                },
+            ]));
+        },
+        encode(route) {
+            const result = decode({
+                ...route,
+                version: registry.resolve(route.screen)?.restoration?.version,
+            });
+            if (!result)
+                throw new Error('Invalid or non-restorable route');
+            // Roundtrip rejects values that cannot survive storage.
+            const roundtrip = decode(JSON.parse(JSON.stringify(result)));
+            if (!roundtrip)
+                throw new Error('Route params must be serializable');
+            return roundtrip;
+        },
+        encodeURL(base, path, tab) {
+            const url = new URL(base);
+            if (!['http:', 'https:'].includes(url.protocol) ||
+                url.username ||
+                url.password ||
+                !url.pathname.endsWith('/') ||
+                url.search ||
+                url.hash)
+                throw new Error('Use an app scope URL');
+            if (tab)
+                url.searchParams.set('satin-tab', tab);
+            url.searchParams.set('satin-route', JSON.stringify(path.map(route => this.encode(route))));
+            return url.href;
+        },
+        decodeURL(input, base) {
+            try {
+                const url = new URL(input, base), scope = new URL(base);
+                if (url.origin !== scope.origin ||
+                    url.pathname !== scope.pathname ||
+                    url.username ||
+                    url.password)
+                    return null;
+                const raw = url.searchParams.get('satin-route');
+                if (raw === null)
+                    return null;
+                try {
+                    return decodePath(JSON.parse(raw));
+                }
+                catch {
+                    return [];
+                }
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}
+/** Object key order is not route identity. Never throw for an app-owned value. */
+export function sameRouteParams(left, right) {
+    const canonical = (value) => {
+        if (Array.isArray(value))
+            return value.map(canonical);
+        if (value && typeof value === 'object')
+            return Object.fromEntries(Object.entries(value)
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([key, item]) => [key, canonical(item)]));
+        return value;
+    };
+    try {
+        return JSON.stringify(canonical(left)) === JSON.stringify(canonical(right));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/navigation/scrollEdge.d.ts

@@ -0,0 +1,18 @@
+/** Scroll distance over which the edge material reaches full strength once
+ * content first meets its lower boundary. Unmeasured against native motion. */
+export declare const SCROLL_EDGE_RAMP_PX = 8;
+/** 0 while nothing sits under the edge; 1 once content is RAMP px underneath. */
+export declare function scrollEdgeStrength(edgeBottom: number, contentTop: number | undefined): number;
+export declare function firstContentTop(scroller: HTMLElement, scrollTop?: number, rect?: (element: Element) => DOMRect): number | undefined;
+/** A pinned search drawer joins the navigation treatment 4 pt above its field.
+ * Keep the high chrome layer above that boundary; extending it across the field
+ * would blur the field's foreground. The adjacent search layer owns the tail. */
+export declare function searchHeaderEdge(scroller: HTMLElement, scrollTop?: number, rect?: (element: Element) => DOMRect): {
+    marker: HTMLElement;
+    top: number;
+    strength: number;
+} | undefined;
+export declare function pinnedSectionHeader(scroller: HTMLElement, rect?: (element: Element) => DOMRect): {
+    header: HTMLElement;
+    reach: number;
+} | undefined;

package/dist/navigation/scrollEdge.js

@@ -0,0 +1,66 @@
+/** Scroll distance over which the edge material reaches full strength once
+ * content first meets its lower boundary. Unmeasured against native motion. */
+export const SCROLL_EDGE_RAMP_PX = 8;
+/** 0 while nothing sits under the edge; 1 once content is RAMP px underneath. */
+export function scrollEdgeStrength(edgeBottom, contentTop) {
+    if (contentTop === undefined)
+        return 0;
+    return Math.min(1, Math.max(0, (edgeBottom - contentTop) / SCROLL_EDGE_RAMP_PX));
+}
+export function firstContentTop(scroller, scrollTop = scroller.scrollTop, rect = (element) => element.getBoundingClientRect()) {
+    // Floating iPad tabs overlap the resting title's geometry. That overlap is
+    // not scrolling and must not turn on the edge blur at the initial offset.
+    if (scrollTop <= 0)
+        return undefined;
+    for (const child of scroller.children) {
+        // The pinned drawer and its edge marker are chrome, not scrolling content.
+        if (child.matches('[data-satin-search], [data-satin-search-edge]'))
+            continue;
+        const box = rect(child);
+        if (box.height > 0 || box.width > 0)
+            return box.top;
+    }
+    return undefined;
+}
+/** A pinned search drawer joins the navigation treatment 4 pt above its field.
+ * Keep the high chrome layer above that boundary; extending it across the field
+ * would blur the field's foreground. The adjacent search layer owns the tail. */
+export function searchHeaderEdge(scroller, scrollTop = scroller.scrollTop, rect = (element) => element.getBoundingClientRect()) {
+    if (scrollTop <= 0 || scroller.hasAttribute('data-satin-search-presented'))
+        return;
+    const drawer = scroller.querySelector(':scope > [data-satin-search]');
+    const marker = drawer?.nextElementSibling;
+    if (!drawer || !(marker instanceof HTMLElement) || !marker.hasAttribute('data-satin-search-edge'))
+        return;
+    for (let content = marker.nextElementSibling; content; content = content.nextElementSibling) {
+        const box = rect(content);
+        if (box.height <= 0 || box.width <= 0)
+            continue;
+        const drawerBox = rect(drawer);
+        const strength = scrollEdgeStrength(drawerBox.bottom, box.top);
+        if (strength === 0)
+            return;
+        return { marker, top: drawerBox.top - 4, strength };
+    }
+}
+/* The section header of a plain List that is pinned at the top of its scroll view, and its
+ * distance below the scroll view's top edge. Native grows the bar's edge effect over a pinned
+ * header as one hard-edged material (iOS 27 native reference rough-edges, pinned 116-156 pt), so the header
+ * then owns the whole material. A header is pinned when its section's top has scrolled above it.
+ * Searchable lists are excluded: their drawer draws the edge material under its pinned headers. */
+export function pinnedSectionHeader(scroller, rect = (element) => element.getBoundingClientRect()) {
+    if (!scroller.matches("[data-satin-list='plain']:not([data-satin-searchable])"))
+        return;
+    const scrollerTop = rect(scroller).top;
+    for (const header of scroller.querySelectorAll("[data-satin-list-section] > [data-satin-section-header='true']")) {
+        const box = rect(header);
+        if (box.bottom <= scrollerTop)
+            continue;
+        const sectionTop = rect(header.parentElement).top;
+        if (box.top - sectionTop > 0.5)
+            return { header, reach: box.top - scrollerTop };
+        // Headers below an unpinned one sit lower still.
+        return;
+    }
+    return;
+}

package/dist/navigation/scrubFrameLoop.d.ts

@@ -0,0 +1,44 @@
+export type ScrubFrameMetrics = Readonly<{
+    averageEventsPerFrame: number;
+    eventsThisFrame: number;
+    frameCount: number;
+    inputCount: number;
+    inputHz?: number;
+    rafHz?: number;
+}>;
+export type ScrubResolution = 'cancel' | 'complete';
+export type InteractiveScrubFrameLoop = Readonly<{
+    dispose(): void;
+    record(progress: number, inputTime: number): void;
+    resolve(target: ScrubResolution, progress: number, velocityPointsPerSecond: number, inputTime: number): void;
+}>;
+type InteractiveScrubFrameLoopOptions = Readonly<{
+    applyProgress(progress: number): void;
+    cancelFrame(frame: number): void;
+    onFrame?(metrics: ScrubFrameMetrics): void;
+    requestFrame(callback: FrameRequestCallback): number;
+    resolve(target: ScrubResolution, velocityPointsPerSecond: number): void;
+}>;
+/**
+ * Buffers the newest direct-manipulation sample and gives the transition one
+ * coordinated visual commit per display frame. Release thresholds and
+ * velocity stay on the unfiltered input stream; resolution begins only after
+ * the final raw position has been painted.
+ */
+export declare function createInteractiveScrubFrameLoop(options: InteractiveScrubFrameLoopOptions): InteractiveScrubFrameLoop;
+export type FilteredScrubSample = Readonly<{
+    progress: number;
+    /** Raw release velocity is deliberately never smoothed. */
+    velocityPointsPerSecond: number;
+}>;
+type CriticallyDampedScrubFilter = Readonly<{
+    reset(): void;
+    sample(progress: number, time: number, velocityPointsPerSecond: number): FilteredScrubSample;
+}>;
+/**
+ * A dormant, testable filter candidate for a future measured input-rate gap.
+ * It is intentionally not wired into NavigatorHost until native latency gives
+ * us a defensible time constant and the physical phone still needs it.
+ */
+export declare function createCriticallyDampedScrubFilter(timeConstantMs: number): CriticallyDampedScrubFilter;
+export {};

package/dist/navigation/scrubFrameLoop.js

@@ -0,0 +1,129 @@
+function observedHz(count, firstTime, lastTime) {
+    if (count < 2)
+        return undefined;
+    const elapsed = lastTime - firstTime;
+    return elapsed > 0 ? ((count - 1) * 1_000) / elapsed : undefined;
+}
+/**
+ * Buffers the newest direct-manipulation sample and gives the transition one
+ * coordinated visual commit per display frame. Release thresholds and
+ * velocity stay on the unfiltered input stream; resolution begins only after
+ * the final raw position has been painted.
+ */
+export function createInteractiveScrubFrameLoop(options) {
+    let disposed = false;
+    let eventsSinceFrame = 0;
+    let firstFrameTime = 0;
+    let firstInputTime = 0;
+    let frameCount = 0;
+    let frameRequest;
+    let inputCount = 0;
+    let lastFrameTime = 0;
+    let lastInputTime = 0;
+    let latestProgress = 0;
+    let pendingResolution;
+    const renderFrame = frameTime => {
+        frameRequest = undefined;
+        if (disposed || inputCount === 0)
+            return;
+        const eventsThisFrame = eventsSinceFrame;
+        eventsSinceFrame = 0;
+        frameCount += 1;
+        if (frameCount === 1)
+            firstFrameTime = frameTime;
+        lastFrameTime = frameTime;
+        if (eventsThisFrame > 0)
+            options.applyProgress(latestProgress);
+        options.onFrame?.({
+            averageEventsPerFrame: inputCount / frameCount,
+            eventsThisFrame,
+            frameCount,
+            inputCount,
+            inputHz: observedHz(inputCount, firstInputTime, lastInputTime),
+            rafHz: observedHz(frameCount, firstFrameTime, lastFrameTime),
+        });
+        const resolution = pendingResolution;
+        pendingResolution = undefined;
+        if (resolution) {
+            options.resolve(resolution.target, resolution.velocityPointsPerSecond);
+            return;
+        }
+        scheduleFrame();
+    };
+    const scheduleFrame = () => {
+        if (disposed || frameRequest !== undefined)
+            return;
+        frameRequest = options.requestFrame(renderFrame);
+    };
+    const record = (progress, inputTime) => {
+        if (disposed || pendingResolution)
+            return;
+        latestProgress = progress;
+        inputCount += 1;
+        eventsSinceFrame += 1;
+        if (inputCount === 1)
+            firstInputTime = inputTime;
+        lastInputTime = inputTime;
+        scheduleFrame();
+    };
+    return Object.freeze({
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            if (frameRequest !== undefined)
+                options.cancelFrame(frameRequest);
+            frameRequest = undefined;
+            pendingResolution = undefined;
+        },
+        record,
+        resolve(target, progress, velocityPointsPerSecond, inputTime) {
+            if (disposed || pendingResolution)
+                return;
+            record(progress, inputTime);
+            pendingResolution = { target, velocityPointsPerSecond };
+            scheduleFrame();
+        },
+    });
+}
+/**
+ * A dormant, testable filter candidate for a future measured input-rate gap.
+ * It is intentionally not wired into NavigatorHost until native latency gives
+ * us a defensible time constant and the physical phone still needs it.
+ */
+export function createCriticallyDampedScrubFilter(timeConstantMs) {
+    if (!(timeConstantMs > 0)) {
+        throw new Error('Satin scrub filter timeConstantMs must be greater than zero.');
+    }
+    let current = 0;
+    let currentVelocity = 0;
+    let initialized = false;
+    let previousTime = 0;
+    const angularFrequency = 1_000 / timeConstantMs;
+    return Object.freeze({
+        reset() {
+            current = 0;
+            currentVelocity = 0;
+            initialized = false;
+            previousTime = 0;
+        },
+        sample(progress, time, velocityPointsPerSecond) {
+            if (!initialized || time <= previousTime) {
+                current = progress;
+                currentVelocity = 0;
+                initialized = true;
+                previousTime = time;
+                return { progress: current, velocityPointsPerSecond };
+            }
+            const elapsedSeconds = Math.min(0.05, (time - previousTime) / 1_000);
+            const displacement = current - progress;
+            const coupledVelocity = currentVelocity + angularFrequency * displacement;
+            const decay = Math.exp(-angularFrequency * elapsedSeconds);
+            current = progress + (displacement + coupledVelocity * elapsedSeconds) * decay;
+            currentVelocity =
+                (currentVelocity - angularFrequency * coupledVelocity * elapsedSeconds) * decay;
+            previousTime = time;
+            return { progress: current, velocityPointsPerSecond };
+        },
+    });
+}

package/dist/navigation/sidebarSelection.d.ts

@@ -0,0 +1,5 @@
+/** Ordered destinations, not registry order, define a fresh sidebar's initial detail. */
+export declare function chooseSidebarInitialEntry<Entry extends {
+    id: string;
+    disabled?: boolean;
+}>(entries: readonly Entry[], initial?: 'first' | false | string): Entry | undefined;

package/dist/navigation/sidebarSelection.js

@@ -0,0 +1,8 @@
+/** Ordered destinations, not registry order, define a fresh sidebar's initial detail. */
+export function chooseSidebarInitialEntry(entries, initial = 'first') {
+    if (initial === false)
+        return undefined;
+    return initial === 'first'
+        ? entries.find(entry => !entry.disabled)
+        : entries.find(entry => entry.id === initial && !entry.disabled);
+}

package/dist/navigation/splitContext.d.ts

@@ -0,0 +1,17 @@
+import type { ScreenEntry } from './types.js';
+export type SplitSelection = Readonly<{
+    mode: 'stack' | 'split';
+    /** Internal one-shot launch ownership, consumed by Sidebar. */
+    claimInitialSelection?: () => boolean;
+    entry: ScreenEntry | undefined;
+    identity: string | undefined;
+}>;
+export declare const SplitContext: import("react").Context<Readonly<{
+    mode: 'stack' | 'split';
+    /** Internal one-shot launch ownership, consumed by Sidebar. */
+    claimInitialSelection?: () => boolean;
+    entry: ScreenEntry | undefined;
+    identity: string | undefined;
+}> | undefined>;
+/** Entry identity owns navigation/scroll; identity is the registry's semantic row key. */
+export declare function useSplitSelection(): SplitSelection;

package/dist/navigation/splitContext.js

@@ -0,0 +1,9 @@
+import { createContext, useContext } from 'react';
+export const SplitContext = createContext(undefined);
+/** Entry identity owns navigation/scroll; identity is the registry's semantic row key. */
+export function useSplitSelection() {
+    const selection = useContext(SplitContext);
+    if (!selection)
+        throw new Error('useSplitSelection must be called inside NavigatorHost.');
+    return selection;
+}

package/dist/navigation/splitState.d.ts

@@ -0,0 +1,46 @@
+import type { AxisLayoutClass } from '../layout/layoutClass.js';
+import type { NavigatorState, ScreenEntry, TransitionController, TransitionOperation } from './types.js';
+export type SplitNavigationTransition = Readonly<{
+    controller: TransitionController;
+    interactive: boolean;
+    operation: TransitionOperation;
+}>;
+export type CompactNavigationProjection<Entry extends ScreenEntry> = Readonly<{
+    entries: readonly Entry[];
+    mode: 'stack';
+    selectionEntryKey?: string;
+}>;
+export type RegularNavigationProjection<Entry extends ScreenEntry> = Readonly<{
+    detailEntries: readonly Entry[];
+    mode: 'split';
+    selectionEntryKey?: string;
+    sidebarEntry: Entry;
+}>;
+export type SplitNavigationProjection<Entry extends ScreenEntry> = CompactNavigationProjection<Entry> | RegularNavigationProjection<Entry>;
+export type SplitNavigationState<Entry extends ScreenEntry> = Readonly<{
+    appliedHorizontalClass: AxisLayoutClass;
+    navigator: NavigatorState<Entry>;
+    pendingHorizontalClass?: AxisLayoutClass;
+    projection: SplitNavigationProjection<Entry>;
+    requestedControllers: readonly TransitionController[];
+    transitions: readonly SplitNavigationTransition[];
+}>;
+export type SplitNavigationCommand = Readonly<{
+    controller: TransitionController;
+    operation: TransitionOperation;
+    type: 'cancel-interactive-transition' | 'finish-transition';
+}>;
+export type SplitNavigationEvent<Entry extends ScreenEntry> = Readonly<{
+    horizontal: AxisLayoutClass;
+    type: 'horizontal-class-changed';
+}> | Readonly<{
+    navigator: NavigatorState<Entry>;
+    transitions: readonly SplitNavigationTransition[];
+    type: 'navigator-synchronized';
+}>;
+export type SplitNavigationReduction<Entry extends ScreenEntry> = Readonly<{
+    commands: readonly SplitNavigationCommand[];
+    state: SplitNavigationState<Entry>;
+}>;
+export declare function createSplitNavigationState<Entry extends ScreenEntry>(horizontal: AxisLayoutClass, navigator: NavigatorState<Entry>, transitions?: readonly SplitNavigationTransition[]): SplitNavigationState<Entry>;
+export declare function reduceSplitNavigation<Entry extends ScreenEntry>(state: SplitNavigationState<Entry>, event: SplitNavigationEvent<Entry>): SplitNavigationReduction<Entry>;

package/dist/navigation/splitState.js

@@ -0,0 +1,130 @@
+const EMPTY_COMMANDS = Object.freeze([]);
+function activeControllers(navigator) {
+    const controllers = [];
+    for (const entry of navigator.entries) {
+        const { controller, phase } = entry.transition;
+        if (phase === 'settled' || controllers.includes(controller))
+            continue;
+        controllers.push(controller);
+    }
+    return controllers;
+}
+function normalizeTransitions(navigator, transitions) {
+    if (navigator.entries.length === 0) {
+        throw new Error('Split navigation requires the Navigator root entry.');
+    }
+    const active = activeControllers(navigator);
+    for (const controller of active) {
+        const matches = transitions.filter(transition => transition.controller === controller);
+        if (matches.length !== 1) {
+            throw new Error('Every in-flight Navigator controller needs exactly one transition descriptor.');
+        }
+        if (matches[0]?.interactive && matches[0].operation !== 'pop') {
+            throw new Error('Only a pop transition can own an interactive back gesture.');
+        }
+    }
+    for (const transition of transitions) {
+        if (!active.includes(transition.controller)) {
+            throw new Error('A transition descriptor does not belong to the active Navigator stack.');
+        }
+    }
+    return active.map(controller => transitions.find(transition => transition.controller === controller));
+}
+function project(horizontal, navigator) {
+    const sidebarEntry = navigator.entries[0];
+    if (!sidebarEntry) {
+        throw new Error('Split navigation requires the Navigator root entry.');
+    }
+    const selectionEntryKey = navigator.entries[1]?.key;
+    if (horizontal === 'compact') {
+        return {
+            entries: navigator.entries,
+            mode: 'stack',
+            ...(selectionEntryKey ? { selectionEntryKey } : {}),
+        };
+    }
+    return {
+        detailEntries: navigator.entries.slice(1),
+        mode: 'split',
+        ...(selectionEntryKey ? { selectionEntryKey } : {}),
+        sidebarEntry,
+    };
+}
+function requestedForActiveControllers(requested, transitions) {
+    return requested.filter(controller => transitions.some(transition => transition.controller === controller));
+}
+function settlementCommands(transitions, requestedControllers) {
+    return transitions
+        .filter(transition => !requestedControllers.includes(transition.controller))
+        .map(transition => ({
+        controller: transition.controller,
+        operation: transition.operation,
+        type: transition.interactive
+            ? 'cancel-interactive-transition'
+            : 'finish-transition',
+    }));
+}
+function settlePendingClass(state) {
+    if (!state.pendingHorizontalClass) {
+        return { commands: EMPTY_COMMANDS, state };
+    }
+    if (state.transitions.length === 0) {
+        const appliedHorizontalClass = state.pendingHorizontalClass;
+        return {
+            commands: EMPTY_COMMANDS,
+            state: {
+                ...state,
+                appliedHorizontalClass,
+                pendingHorizontalClass: undefined,
+                projection: project(appliedHorizontalClass, state.navigator),
+                requestedControllers: [],
+            },
+        };
+    }
+    const commands = settlementCommands(state.transitions, state.requestedControllers);
+    if (commands.length === 0)
+        return { commands: EMPTY_COMMANDS, state };
+    return {
+        commands,
+        state: {
+            ...state,
+            requestedControllers: [
+                ...state.requestedControllers,
+                ...commands.map(command => command.controller),
+            ],
+        },
+    };
+}
+export function createSplitNavigationState(horizontal, navigator, transitions = []) {
+    const normalizedTransitions = normalizeTransitions(navigator, transitions);
+    return {
+        appliedHorizontalClass: horizontal,
+        navigator,
+        projection: project(horizontal, navigator),
+        requestedControllers: [],
+        transitions: normalizedTransitions,
+    };
+}
+export function reduceSplitNavigation(state, event) {
+    if (event.type === 'horizontal-class-changed') {
+        const pendingHorizontalClass = event.horizontal === state.appliedHorizontalClass ? undefined : event.horizontal;
+        const nextState = {
+            ...state,
+            pendingHorizontalClass,
+            requestedControllers: pendingHorizontalClass ? state.requestedControllers : [],
+        };
+        return settlePendingClass(nextState);
+    }
+    const transitions = normalizeTransitions(event.navigator, event.transitions);
+    const requestedControllers = state.pendingHorizontalClass
+        ? requestedForActiveControllers(state.requestedControllers, transitions)
+        : [];
+    const synchronized = {
+        ...state,
+        navigator: event.navigator,
+        projection: project(state.appliedHorizontalClass, event.navigator),
+        requestedControllers,
+        transitions,
+    };
+    return settlePendingClass(synchronized);
+}

package/dist/navigation/stack.d.ts

@@ -0,0 +1,25 @@
+import type { NavigatorState, ScreenEntry, TransitionController } from './types.js';
+import type { ScrollSnapshot } from '../scroll/types.js';
+export declare function isEntryCovered(entries: readonly ScreenEntry[], entryIndex: number): boolean;
+/**
+ * A multi-screen pop (popToRoot) animates only its topmost outgoing screen over
+ * the destination. Outgoing screens beneath it on the same controller must not
+ * paint, or the animation reveals them instead of the destination and then cuts
+ * to it (owner phone, 2026-09-24: page 6 → page 5 → cut to root). Concurrent
+ * single pops each own their controller and keep painting.
+ */
+export declare function hiddenByMultiPop(entries: readonly {
+    transition: {
+        phase: string;
+        controller?: unknown;
+    };
+}[], index: number): boolean;
+export declare function shouldRestoreOnUncover(wasCovered: boolean | undefined, isCovered: boolean): boolean;
+export declare function scrollSnapshotsEqual(left: ScrollSnapshot | undefined, right: ScrollSnapshot | undefined): boolean;
+export declare function setEntryScrollSnapshot<Entry extends ScreenEntry>(state: NavigatorState<Entry>, entryKey: string, scrollSnapshot: ScrollSnapshot): NavigatorState<Entry>;
+export declare function pushStack<Entry extends ScreenEntry>(state: NavigatorState<Entry>, entry: Entry): NavigatorState<Entry>;
+export declare function popStack<Entry extends ScreenEntry>(state: NavigatorState<Entry>, controller: TransitionController): NavigatorState<Entry>;
+export declare function popToRootStack<Entry extends ScreenEntry>(state: NavigatorState<Entry>, controller: TransitionController): NavigatorState<Entry>;
+export declare function replaceStack<Entry extends ScreenEntry>(state: NavigatorState<Entry>, entry: Entry, controller: TransitionController): NavigatorState<Entry>;
+export declare function finishStackTransition<Entry extends ScreenEntry>(state: NavigatorState<Entry>, controller: TransitionController): NavigatorState<Entry>;
+export declare function cancelStackTransition<Entry extends ScreenEntry>(state: NavigatorState<Entry>, controller: TransitionController): NavigatorState<Entry>;