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

package/dist/navigation/chromeCurves.js

@@ -0,0 +1,255 @@
+// Measured iOS 27 navigation bar chrome curves (what bar items do while a page moves) and the
+// keyframe builders that turn them into Web Animations keyframes. Pure data and math: no DOM.
+/** Incoming bar chrome, measured on the iOS 27.0 Simulator from the presentation layers of stock
+ * SwiftUI (every display frame,
+ * light and dark agree within 0.04): milliseconds since the page starts moving. A push brings the
+ * destination's glass items in faster than a pop brings the revealed screen's back: a push shows
+ * 0.56 at 100 ms (Reminders-style list → list, back circle and trailing "…" together), a pop 0.30
+ * at 100 ms (Chats thread → root, trailing compose Menu). */
+const PUSH_INCOMING = [
+    [0, 0],
+    [17, 0.05],
+    [33, 0.13],
+    [50, 0.23],
+    [67, 0.34],
+    [83, 0.45],
+    [100, 0.56],
+    [117, 0.65],
+    [133, 0.74],
+    [150, 0.81],
+    [167, 0.86],
+    [183, 0.91],
+    [200, 0.95],
+    [217, 0.98],
+    [240, 1],
+];
+const POP_INCOMING = [
+    [0, 0],
+    [34, 0.03],
+    [50, 0.09],
+    [67, 0.19],
+    [84, 0.3],
+    [100, 0.43],
+    [117, 0.52],
+    [134, 0.63],
+    [150, 0.7],
+    [167, 0.79],
+    [184, 0.84],
+    [200, 0.9],
+    [217, 0.93],
+    [234, 0.97],
+    [250, 0.99],
+    [267, 1],
+];
+/* Leaving bar chrome, measured like the arriving curves (reference, presentation-layer measurements presentation layers,
+ * medians of four runs each, light and dark): a pop's leaving items (Reminders-style list → root:
+ * back circle and trailing "…" alike) hold until 33 ms, are 0.72 at 100 ms and gone at 283 ms. A
+ * push's leaving items (Chats root → thread, trailing compose) run the same curve 17 ms earlier
+ * (within 0.012 at every knot), as the push arrivals lead the pop arrivals. */
+const POP_OUTGOING = [
+    [0, 1],
+    [33, 1],
+    [50, 0.99],
+    [67, 0.935],
+    [83, 0.83],
+    [100, 0.72],
+    [117, 0.63],
+    [133, 0.53],
+    [150, 0.42],
+    [167, 0.32],
+    [183, 0.24],
+    [200, 0.18],
+    [217, 0.13],
+    [233, 0.07],
+    [250, 0.04],
+    [267, 0.01],
+    [283, 0],
+];
+const PUSH_OUTGOING = [
+    [0, 1],
+    [17, 1],
+    [33, 0.99],
+    [50, 0.935],
+    [67, 0.83],
+    [83, 0.72],
+    [100, 0.63],
+    [117, 0.53],
+    [133, 0.42],
+    [150, 0.32],
+    [167, 0.24],
+    [183, 0.18],
+    [200, 0.13],
+    [217, 0.07],
+    [233, 0.04],
+    [250, 0.01],
+    [267, 0],
+];
+/** iOS 27 bar chrome curves: [milliseconds since the page starts moving, opacity] knots, linear
+ * between them. They run only when the page is sent to its end (tap push, back-button pop,
+ * completing release). A held back swipe keeps the outgoing items and back control fully shown and
+ * the incoming items hidden at every position, and a cancelled release changes nothing.
+ * Every curve also drives the item's scale and blur (chromeDissolve). Where a back control replaces
+ * a leading item, one glass circle stays put and only the symbols cross-fade (leadingGlassSwap). A
+ * screen's principal item is not faded: it is shown at once on push and moves with its page on
+ * pop (native). */
+export const NAVIGATION_CHROME_CURVES = Object.freeze({
+    /** The back control when the destination has none (popping to a root). */
+    backLeave: POP_OUTGOING,
+    /** The back control arriving with a push from a root. */
+    backAppear: PUSH_INCOMING,
+    /** The outgoing entry's bar items in a push. */
+    pushToolbarLeave: PUSH_OUTGOING,
+    /** The outgoing entry's bar items in a pop. */
+    popToolbarLeave: POP_OUTGOING,
+    /** The destination's bar items in a push. */
+    pushToolbarAppear: PUSH_INCOMING,
+    /** The revealed entry's bar items in a pop. */
+    popToolbarAppear: POP_INCOMING,
+});
+/* Native bar items dissolve as one quantity (reference, presentation-layer measurements presentation layers and their
+ * CAFilters, 16 push/pop transitions): an arriving or leaving glass item at opacity a is scaled
+ * 1 + 0.2 (1 - a) about its centre (residual under 0.003) and blurred 10 (1 - a) pt, platter and
+ * symbol together (every sampled ratio 10.0). */
+export const NAVIGATION_CHROME_DISSOLVE = Object.freeze({ scale: 0.2, blur: 10 });
+/** The keyframe for a chrome item at `opacity`. A shown item carries no scale or filter, so a
+ * finished arrival leaves no stacking context or containing block behind its menus. */
+export function chromeDissolve(opacity) {
+    const hidden = 1 - opacity;
+    if (hidden <= 0.001)
+        return { opacity, scale: 'none', filter: 'none' };
+    return {
+        opacity,
+        scale: String(Number((1 + NAVIGATION_CHROME_DISSOLVE.scale * hidden).toFixed(4))),
+        filter: `blur(${Number((NAVIGATION_CHROME_DISSOLVE.blur * hidden).toFixed(2))}px)`,
+    };
+}
+/* A leading glass swap (a back control replacing a leading glass item, or replaced by one),
+ * measured like the bar curves (reference, presentation-layer measurements presentation layers and CAFilters, Chats root
+ * <-> thread, 6 pushes and 6 pops, light and dark; push milliseconds since the page starts moving).
+ * The one circle at that spot swells to 1.22 wide and 1.20 tall at 150 ms and is back at 1 at
+ * 300 ms (native undershoots to 0.97 and settles at 567 ms; not modelled). Inside it the leaving symbol fades on `leave` and the
+ * arriving one fades in as its complement (within 0.01 from 100 ms). Each symbol is scaled
+ * 1 - 0.8 (1 - a) of the circle (residual 0.0005 over 277 samples) and blurred like any other bar
+ * item. A pop runs all of it 17 ms later (within 0.02 at every knot). */
+export const NAVIGATION_LEADING_SWAP = Object.freeze({
+    leave: [
+        [0, 1],
+        [33, 1],
+        [50, 0.89],
+        [67, 0.79],
+        [83, 0.7],
+        [100, 0.57],
+        [117, 0.485],
+        [133, 0.386],
+        [150, 0.298],
+        [167, 0.223],
+        [183, 0.16],
+        [200, 0.109],
+        [217, 0.061],
+        [233, 0.032],
+        [250, 0.014],
+        [267, 0],
+    ],
+    /* [milliseconds, scale] of the circle: the mean of native's width and height scale. Native's
+     * platter is up to 0.05 wider than tall on the way back; the glass circle stays round. Native
+     * then undershoots to 0.97 and settles at 567 ms; that tail outlived the page transition and
+     * doubled the swap's missed frames in Catalyst (reference perf), so the circle stops at 1 at 300 ms,
+     * where native crosses it. */
+    swell: [
+        [0, 1],
+        [33, 1],
+        [50, 1.037],
+        [67, 1.074],
+        [83, 1.113],
+        [100, 1.15],
+        [117, 1.181],
+        [133, 1.202],
+        [150, 1.21],
+        [167, 1.205],
+        [183, 1.188],
+        [200, 1.162],
+        [217, 1.133],
+        [233, 1.101],
+        [250, 1.071],
+        [267, 1.023],
+        [283, 1.019],
+        [300, 1],
+    ],
+    symbolScale: 0.8,
+    popDelay: 17,
+});
+/** A leading glass swap's keyframes for `part`, one per swell knot. The back control's visual is
+ * the circle (it carries the back glass and the chevron); a symbol inside it takes the swell from
+ * it, the leading slot's symbol carries the swell itself (`swells`). `origin` is an interrupted
+ * symbol's opacity, which the curve then runs from. */
+export function leadingSwapFrames(part, direction, swells = false, origin) {
+    const swap = NAVIGATION_LEADING_SWAP;
+    const delay = direction === 'pop' ? swap.popDelay : 0;
+    const duration = swap.swell.at(-1)[0] + delay;
+    const scale = (value) => Math.abs(value - 1) < 0.0005 ? 'none' : String(Number(value.toFixed(4)));
+    const knots = delay ? [[0, 1], ...swap.swell] : swap.swell;
+    const frames = knots.map(([time, swell], index) => {
+        const at = index === 0 ? 0 : time + delay;
+        const offset = at / duration;
+        if (part === 'circle')
+            return { offset, scale: scale(swell) };
+        const leaving = chromeCurveOpacity(swap.leave, at - delay);
+        const shown = part === 'leaving' ? leaving : 1 - leaving;
+        const initial = part === 'leaving' ? 1 : 0;
+        const endpoint = 1 - initial;
+        const opacity = origin === undefined
+            ? shown
+            : endpoint + (origin - endpoint) * ((shown - endpoint) / (initial - endpoint));
+        const hidden = 1 - opacity;
+        const own = 1 - swap.symbolScale * hidden;
+        const keyframe = { offset, opacity };
+        if (swells)
+            keyframe.scale = scale(own * swell);
+        else
+            keyframe.scale = hidden <= 0.001 ? 'none' : String(Number(own.toFixed(4)));
+        keyframe.filter =
+            hidden <= 0.001
+                ? 'none'
+                : `blur(${Number((NAVIGATION_CHROME_DISSOLVE.blur * hidden).toFixed(2))}px)`;
+        return keyframe;
+    });
+    return { frames, duration };
+}
+/* A root's presented search field (navigation bar drawer) and its close button, when a screen
+ * is pushed over it or popped off it (reference, presentation-layer measurements presentation layers, native reference search-push,
+ * 6 pushes and 6 pops, light and dark): native leaves the field where it is on screen (x within
+ * 0.1 pt) and only fades it, field and close button as one, with no scale or blur. A pop brings it
+ * back on this curve; a push fades it out as its complement (within 0.01 from 50 ms). */
+export const NAVIGATION_SEARCH_FIELD_APPEAR = Object.freeze([
+    [0, 0],
+    [17, 0.3],
+    [33, 0.43],
+    [50, 0.55],
+    [67, 0.65],
+    [83, 0.73],
+    [100, 0.79],
+    [117, 0.84],
+    [133, 0.88],
+    [150, 0.91],
+    [167, 0.93],
+    [183, 0.95],
+    [200, 0.96],
+    [217, 0.97],
+    [233, 0.98],
+    [267, 0.99],
+    [317, 1],
+]);
+/** The curve's opacity at `milliseconds` (clamped to its first and last knots). */
+export function chromeCurveOpacity(curve, milliseconds) {
+    const first = curve[0];
+    if (milliseconds <= first[0])
+        return first[1];
+    for (let index = 1; index < curve.length; index += 1) {
+        const [time, value] = curve[index];
+        const [previousTime, previousValue] = curve[index - 1];
+        if (milliseconds <= time)
+            return (previousValue +
+                ((value - previousValue) * (milliseconds - previousTime)) / (time - previousTime));
+    }
+    return curve.at(-1)[1];
+}

package/dist/navigation/glassTransition.d.ts

@@ -0,0 +1,32 @@
+import type { BoundNavigatorTransition, TransitionScreenElements } from './transitionBindings.js';
+export type NavigationGlassRoute = TransitionScreenElements & {
+    key: string;
+    source: HTMLElement;
+};
+export type NavigationGlassState = {
+    active: boolean;
+    width: number;
+    routes: readonly NavigationGlassRoute[];
+    top: string;
+    zoom?: boolean;
+};
+export declare const navigationGlassState: (host: HTMLElement) => NavigationGlassState | undefined;
+/** Use controller bindings for the real rear of popToRoot/replace. Arbitrary
+ * intermediate exiting routes must not cover that rear in the glass source. */
+export declare function navigationGlassRoutes(keys: readonly string[], elements: ReadonlyMap<string, TransitionScreenElements>, bindings: readonly BoundNavigatorTransition[]): {
+    dim: HTMLElement;
+    motion: HTMLElement;
+    screen: HTMLElement;
+    key: string;
+    source: HTMLElement;
+}[];
+/** Commit-boundary ownership, never a React update for an animation frame. */
+export declare function publishNavigationGlass(host: HTMLElement, state: NavigationGlassState): Promise<void>;
+export declare function observeNavigationGlass(host: HTMLElement, listener: (state: NavigationGlassState) => void | Promise<void>): () => void;
+/** Read compositor-owned transforms, including overlapping pop parents. No
+ * bounding-box/layout reads or independent spring clock in the frame loop. */
+export declare function sampleNavigationGlass(state: NavigationGlassState): {
+    key: string;
+    x: number;
+    dim: number;
+}[];

package/dist/navigation/glassTransition.js

@@ -0,0 +1,55 @@
+const states = new WeakMap();
+export const navigationGlassState = (host) => states.get(host);
+const listeners = new WeakMap();
+/** Use controller bindings for the real rear of popToRoot/replace. Arbitrary
+ * intermediate exiting routes must not cover that rear in the glass source. */
+export function navigationGlassRoutes(keys, elements, bindings) {
+    const needed = new Set();
+    for (const { binding } of bindings) {
+        needed.add(binding.primary);
+        if (binding.secondary)
+            needed.add(binding.secondary);
+    }
+    return keys.flatMap((key, index) => {
+        const route = elements.get(key);
+        if (!route ||
+            !(needed.has(route.motion) ||
+                needed.has(route.screen) ||
+                (!bindings.length && index >= keys.length - 2)))
+            return [];
+        const source = route.screen.querySelector('[data-satin-scroll][data-satin-primary="true"]') ??
+            route.motion;
+        return [{ ...route, key, source }];
+    });
+}
+/** Commit-boundary ownership, never a React update for an animation frame. */
+export function publishNavigationGlass(host, state) {
+    states.set(host, state);
+    const ready = Promise.all([...(listeners.get(host) ?? [])].map(listener => listener(state))).then(() => { });
+    // Publication also occurs without an automatic push consumer. The runtime reports failures.
+    void ready.catch(() => { });
+    return ready;
+}
+export function observeNavigationGlass(host, listener) {
+    const set = listeners.get(host) ?? new Set();
+    listeners.set(host, set);
+    set.add(listener);
+    const state = states.get(host);
+    if (state)
+        void Promise.resolve(listener(state)).catch(() => { });
+    return () => {
+        set.delete(listener);
+    };
+}
+/** Read compositor-owned transforms, including overlapping pop parents. No
+ * bounding-box/layout reads or independent spring clock in the frame loop. */
+export function sampleNavigationGlass(state) {
+    return state.routes.map(route => {
+        const outer = getComputedStyle(route.screen).transform;
+        const inner = getComputedStyle(route.motion).transform;
+        const x = (outer === 'none' ? 0 : new DOMMatrixReadOnly(outer).m41) +
+            (inner === 'none' ? 0 : new DOMMatrixReadOnly(inner).m41);
+        const dim = Number(getComputedStyle(route.dim).opacity);
+        return { key: route.key, x, dim: Number.isFinite(dim) ? dim : 0 };
+    });
+}

package/dist/navigation/horizontalDrag.d.ts

@@ -0,0 +1,6 @@
+/** Row actions reserve interior contacts; the first 20 points of the navigation
+ * pane remain Back's edge-start region. This is an input policy, not a spring. */
+export declare const ROW_BACK_EDGE_WIDTH = 20;
+/** Controls declare their available drag directions before contact. Row actions
+ * additionally share their edge-start exception with both navigation input paths. */
+export declare function horizontalDragBlocksBack(target: Element, clientX?: number): boolean;

package/dist/navigation/horizontalDrag.js

@@ -0,0 +1,15 @@
+/** Row actions reserve interior contacts; the first 20 points of the navigation
+ * pane remain Back's edge-start region. This is an input policy, not a spring. */
+export const ROW_BACK_EDGE_WIDTH = 20;
+/** Controls declare their available drag directions before contact. Row actions
+ * additionally share their edge-start exception with both navigation input paths. */
+export function horizontalDragBlocksBack(target, clientX) {
+    const owner = target.closest('[data-satin-horizontal-drag]');
+    if (clientX !== undefined && owner?.matches('[data-satin-row-swipe="true"]')) {
+        const pane = owner.closest('[data-satin-pane], [data-satin-navigator-host]');
+        const left = pane?.getBoundingClientRect().left;
+        return left === undefined || clientX < left || clientX >= left + ROW_BACK_EDGE_WIDTH;
+    }
+    const direction = owner?.getAttribute('data-satin-horizontal-drag');
+    return direction === 'both' || direction === 'right';
+}

package/dist/navigation/interactivePop.d.ts

@@ -0,0 +1,45 @@
+import { type ReleaseVelocityTracker } from './releaseVelocity.js';
+export type InteractivePopDirectionLock = 'claim-horizontal' | 'reject-leftward' | 'reject-vertical' | 'tracking';
+export declare function resolveInteractivePopDirectionLock(deltaX: number, deltaY: number): InteractivePopDirectionLock;
+export type InteractivePopGesture = Readonly<{
+    currentX: number;
+    currentY: number;
+    pointerId: number;
+    progress: number;
+    releaseVelocity: ReleaseVelocityTracker;
+    startX: number;
+    startY: number;
+    state: 'recognized' | 'tracking';
+    velocityPointsPerSecond: number;
+    width: number;
+}>;
+export type InteractivePopMove = Readonly<{
+    gesture?: InteractivePopGesture;
+    recognized: boolean;
+    resolution: 'foreign-pointer' | 'leftward-rejected' | 'recognized' | 'tracking' | 'vertical-rejected';
+}>;
+export declare function beginInteractivePopGesture(existing: InteractivePopGesture | undefined, input: Readonly<{
+    isPrimary: boolean;
+    pointerId: number;
+    time: number;
+    width: number;
+    x: number;
+    y: number;
+}>): Readonly<{
+    currentX: number;
+    currentY: number;
+    pointerId: number;
+    progress: number;
+    releaseVelocity: ReleaseVelocityTracker;
+    startX: number;
+    startY: number;
+    state: 'recognized' | 'tracking';
+    velocityPointsPerSecond: number;
+    width: number;
+}> | undefined;
+export declare function moveInteractivePopGesture(gesture: InteractivePopGesture, input: Readonly<{
+    pointerId: number;
+    time: number;
+    x: number;
+    y: number;
+}>): InteractivePopMove;

package/dist/navigation/interactivePop.js

@@ -0,0 +1,86 @@
+import { NAVIGATION_DIRECTION_LOCK_PX, NAVIGATION_HORIZONTAL_INTENT_PX } from './motionTokens.js';
+import { createReleaseVelocityTracker } from './releaseVelocity.js';
+export function resolveInteractivePopDirectionLock(deltaX, deltaY) {
+    const absoluteX = Math.abs(deltaX);
+    const absoluteY = Math.abs(deltaY);
+    if (Math.max(absoluteX, absoluteY) < NAVIGATION_DIRECTION_LOCK_PX) {
+        return 'tracking';
+    }
+    if (deltaX > 0 && absoluteX > absoluteY)
+        return 'claim-horizontal';
+    if (absoluteY >= absoluteX)
+        return 'reject-vertical';
+    return 'reject-leftward';
+}
+function clampProgress(progress) {
+    return Math.min(1, Math.max(0, progress));
+}
+export function beginInteractivePopGesture(existing, input) {
+    if (existing || !input.isPrimary || input.width <= 0)
+        return existing;
+    const releaseVelocity = createReleaseVelocityTracker();
+    releaseVelocity.record(input.x, input.time);
+    return {
+        currentX: input.x,
+        currentY: input.y,
+        pointerId: input.pointerId,
+        progress: 0,
+        releaseVelocity,
+        startX: input.x,
+        startY: input.y,
+        state: 'tracking',
+        velocityPointsPerSecond: 0,
+        width: input.width,
+    };
+}
+export function moveInteractivePopGesture(gesture, input) {
+    if (gesture.pointerId !== input.pointerId) {
+        return { gesture, recognized: false, resolution: 'foreign-pointer' };
+    }
+    const velocityPointsPerSecond = gesture.releaseVelocity.record(input.x, input.time);
+    const deltaX = input.x - gesture.startX;
+    const deltaY = input.y - gesture.startY;
+    if (gesture.state === 'tracking' &&
+        Math.abs(deltaY) >= NAVIGATION_HORIZONTAL_INTENT_PX &&
+        Math.abs(deltaY) >= Math.abs(deltaX)) {
+        return {
+            gesture: undefined,
+            recognized: false,
+            resolution: 'vertical-rejected',
+        };
+    }
+    if (gesture.state === 'tracking' && deltaX <= -NAVIGATION_HORIZONTAL_INTENT_PX) {
+        return {
+            gesture: undefined,
+            recognized: false,
+            resolution: 'leftward-rejected',
+        };
+    }
+    const recognized = gesture.state === 'recognized' ||
+        (deltaX >= NAVIGATION_HORIZONTAL_INTENT_PX && deltaX > Math.abs(deltaY));
+    if (!recognized) {
+        return {
+            gesture: {
+                ...gesture,
+                currentX: input.x,
+                currentY: input.y,
+                velocityPointsPerSecond,
+            },
+            recognized: false,
+            resolution: 'tracking',
+        };
+    }
+    const nextGesture = {
+        ...gesture,
+        currentX: input.x,
+        currentY: input.y,
+        progress: clampProgress(deltaX / gesture.width),
+        state: 'recognized',
+        velocityPointsPerSecond,
+    };
+    return {
+        gesture: nextGesture,
+        recognized: gesture.state !== 'recognized',
+        resolution: 'recognized',
+    };
+}

package/dist/navigation/interactivePopTypes.d.ts

@@ -0,0 +1,85 @@
+import type { InteractivePopMove } from './interactivePop.js';
+import type { createNavigationReleaseStatistics } from './releaseDecision.js';
+import type { ReleaseVelocityTracker } from './releaseVelocity.js';
+import type { ScrubFrameMetrics } from './scrubFrameLoop.js';
+import type { TransitionController } from './types.js';
+export type InteractivePopDiagnostic = Readonly<{
+    averageEventsPerFrame?: number;
+    claimDeltaX?: number;
+    claimDeltaY?: number;
+    deltaX: number;
+    deltaY: number;
+    eventsThisFrame?: number;
+    event: 'lostpointercapture' | 'pointercancel' | 'pointerdown' | 'pointermove' | 'pointerup' | 'scrubframe' | 'touchclaim' | 'touchcancel' | 'touchend' | 'touchmove' | 'touchreject';
+    pointerId: number;
+    progress: number;
+    input?: 'pointer' | 'touch';
+    inputCount?: number;
+    inputHz?: number;
+    rafCount?: number;
+    rafHz?: number;
+    reason?: InteractivePopMove['resolution'] | 'early-horizontal-claim' | 'early-leftward-release' | 'early-vertical-release' | 'no-pop-target' | 'release-cancel' | 'release-complete' | 'release-pending';
+    startX: number;
+    startY: number;
+    state: 'cancelled' | 'claimed' | 'completed' | 'ignored' | 'recognized' | 'tracking' | 'released';
+    velocityPointsPerSecond: number;
+    x: number;
+    y: number;
+}>;
+export type EarlyTouchArbitration = {
+    previousX: number;
+    recognitionOffset?: number;
+    minimumProgress?: number;
+    pendingPushKey?: string;
+    claimDeltaX?: number;
+    claimDeltaY?: number;
+    currentX: number;
+    currentY: number;
+    identifier: number;
+    /** The private scroll source could be bound to this contact at touch-down. */
+    nativeSource?: HTMLElement;
+    nativeSourceLive: boolean;
+    rowBlocksNativeSource: boolean;
+    progress: number;
+    /** Chosen at recognition. Installed pops scrub from the private source's
+     * ScrollTimeline; 'frame-loop' drives the pose from touch input instead,
+     * one write per display frame. */
+    scrubOwner?: 'frame-loop' | 'scroll-timeline';
+    /** The scroll-timeline scrub attached (it attaches one frame after recognition). */
+    scrubAttached?: boolean;
+    releaseStatistics: ReturnType<typeof createNavigationReleaseStatistics>;
+    releaseVelocity: ReleaseVelocityTracker;
+    startX: number;
+    startY: number;
+    state: 'claimed' | 'recognized' | 'rejected' | 'tracking';
+    velocityPointsPerSecond: number;
+    width: number;
+};
+export type NavigatorHostGeometry = Readonly<{
+    left: number;
+    top: number;
+    width: number;
+}>;
+export type ScrubDiagnosticState = {
+    claimDeltaX?: number;
+    claimDeltaY?: number;
+    currentX: number;
+    currentY: number;
+    input: 'pointer' | 'touch';
+    pointerId: number;
+    progress: number;
+    startX: number;
+    startY: number;
+    velocityPointsPerSecond: number;
+};
+/** Copies a contact's latest sample into the frame loop's diagnostic state, when that state was
+ * started by the same kind of input. */
+export declare function updateScrubDiagnostic(state: ScrubDiagnosticState | undefined, input: ScrubDiagnosticState['input'], sample: Readonly<{
+    currentX: number;
+    currentY: number;
+    progress: number;
+    velocityPointsPerSecond: number;
+}>): void;
+/** The diagnostic a recognized scrub reports once per display frame. */
+export declare function scrubFrameDiagnostic(state: ScrubDiagnosticState, metrics: ScrubFrameMetrics): InteractivePopDiagnostic;
+export type InteractiveTransitionController = TransitionController & Required<Pick<TransitionController, 'cancelInteractive' | 'completeInteractive' | 'setProgress'>>;

package/dist/navigation/interactivePopTypes.js

@@ -0,0 +1,36 @@
+/** Copies a contact's latest sample into the frame loop's diagnostic state, when that state was
+ * started by the same kind of input. */
+export function updateScrubDiagnostic(state, input, sample) {
+    if (state?.input !== input)
+        return;
+    state.currentX = sample.currentX;
+    state.currentY = sample.currentY;
+    state.progress = sample.progress;
+    state.velocityPointsPerSecond = sample.velocityPointsPerSecond;
+}
+/** The diagnostic a recognized scrub reports once per display frame. */
+export function scrubFrameDiagnostic(state, metrics) {
+    return {
+        averageEventsPerFrame: metrics.averageEventsPerFrame,
+        claimDeltaX: state.claimDeltaX,
+        claimDeltaY: state.claimDeltaY,
+        deltaX: state.currentX - state.startX,
+        deltaY: state.currentY - state.startY,
+        event: 'scrubframe',
+        eventsThisFrame: metrics.eventsThisFrame,
+        input: state.input,
+        inputCount: metrics.inputCount,
+        inputHz: metrics.inputHz,
+        pointerId: state.pointerId,
+        progress: state.progress,
+        rafCount: metrics.frameCount,
+        rafHz: metrics.rafHz,
+        reason: 'recognized',
+        startX: state.startX,
+        startY: state.startY,
+        state: 'recognized',
+        velocityPointsPerSecond: state.velocityPointsPerSecond,
+        x: state.currentX,
+        y: state.currentY,
+    };
+}

package/dist/navigation/keyboard.d.ts

@@ -0,0 +1,9 @@
+/** One document listener arbitrates retained/nested navigators before popping. */
+type Target = {
+    host: HTMLElement;
+    enabled: () => boolean;
+    canPop: () => boolean;
+    pop: () => void;
+};
+export declare function registerNavigationKeyboard(target: Target): () => void;
+export {};