@flemo/core 1.30.0 → 2.1.0

package/dist/morph/__tests__/attachMorph.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/morph/__tests__/morphAnimations.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/morph/__tests__/morphClip.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/morph/__tests__/morphGeometry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/morph/__tests__/morphKeyframes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/morph/__tests__/morphLayer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/morph/__tests__/morphPaint.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/morph/__tests__/morphPose.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/morph/__tests__/morphSheet.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/morph/__tests__/morphSide.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/morph/__tests__/morphSwipe.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/morph/attachMorph.d.ts

@@ -0,0 +1,73 @@
+import { NavigateStatus, NavigateStoreApi } from '../navigate/store';
+import { AnimationOptions } from '../transition/cssTypes';
+import { MorphTransitionName } from '../transition/morphTransition/typing';
+export interface AttachMorphOptions {
+    /** The pairing key. Two elements sharing it across a flight are one thing moving. */
+    layoutId: string | number;
+    /** A registered morph transition. Defaults to the built-in `shared` preset. */
+    name?: MorphTransitionName;
+    /** The navigate store of the Router scope this element belongs to. */
+    navigateStore: NavigateStoreApi;
+}
+interface MorphFlight {
+    finish: () => void;
+    /** The element in the air, so a morph nested inside it can find its clock. */
+    element: HTMLElement;
+    duration: number;
+    start: number;
+    ease: AnimationOptions["ease"];
+    /**
+     * Put the landing's safety net away, and set it again.
+     *
+     * A flight lands on its travel's own `animationend`, and the backstop exists
+     * for the ones that never get one — a screen frozen mid-air, a tab
+     * backgrounded before the compositor reports back. It is armed for the
+     * flight's own length, which is the right guess for a flight on a clock and
+     * the wrong one for a flight on a FINGER: a drag that takes longer than the
+     * animation would have is not stuck, it is being held, and landing it there
+     * puts the element back in its screen mid-gesture. So a gesture puts the net
+     * away while it drives, and sets it again for the release it hands back.
+     */
+    suspendBackstop: () => void;
+    armBackstop: (seconds: number) => void;
+}
+/**
+ * Stage every registered pair as a flight the CALLER drives, and hand back the
+ * elements holding it.
+ *
+ * A programmatic navigation stages its flights when the status flips and lets
+ * the compiled hold clock run them. A DRAG has neither: the navigation does not
+ * exist yet (it is committed on release, if at all) and there is no hold to
+ * mirror. So this takes the same snapshot the status flip would take, stages
+ * the same flights under an explicit direction, and leaves them PAUSED at zero
+ * for the gesture to move by hand.
+ *
+ * Exported for `morphSwipe`, which owns the scrubbing; nothing else should
+ * stage a flight the runtime does not clock.
+ */
+export declare const stageHeldFlights: (store: NavigateStoreApi, status: NavigateStatus) => MorphFlight[];
+/**
+ * Forget any delivery the navigation never came to collect. A NEW gesture
+ * supersedes the last one; only the gesture's own entry point may do this,
+ * because the navigation reaches the scope through `stageHeldFlights` too and
+ * clearing there would erase the mark a moment before reading it.
+ */
+/**
+ * Record that a gesture's release has DELIVERED whatever it is carrying — it
+ * plays those flights out to the arrival itself, so the navigation it commits
+ * must not stage them again. Whatever is in the air at the release is exactly
+ * what the gesture delivers. See `MorphScope.delivered`.
+ */
+export declare const clearGestureDeliveries: (store: NavigateStoreApi) => void;
+export declare const markGestureDelivered: (store: NavigateStoreApi) => void;
+/** The flights a scope currently holds — the nested ones included. */
+export declare const heldFlights: (store: NavigateStoreApi) => MorphFlight[];
+export type { MorphFlight };
+/**
+ * Register one element as a morph, and return the disposer.
+ *
+ * Call it before the paint of the frame the element mounts in, and again
+ * whenever its screen's status changes — re-registering is cheap and is what
+ * lets a screen that was never frozen still take its side of a pop.
+ */
+export default function attachMorph(element: HTMLElement, options: AttachMorphOptions): () => void;

package/dist/morph/morphAnimations.d.ts

@@ -0,0 +1,2 @@
+export declare function preserveDescendantAnimations(root: Element, move: () => void): void;
+export default preserveDescendantAnimations;

package/dist/morph/morphClip.d.ts

@@ -0,0 +1,31 @@
+/** Fraction of the box hidden on each side, as clip-path percentages. */
+export interface MorphClipInset {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/**
+ * How much of the element's box its clipping ancestors cut away, per side, as
+ * percentages of the box — or null when it is fully visible (within half a
+ * pixel) or unmeasurable.
+ *
+ * Everything is read LIVE, from the element's own bounding rect — never from
+ * a rest-space rect computed elsewhere. At staging time the element's screen
+ * may already be mid-pose (a cupertino pop reads its revealed screen at
+ * translate3d(-30%)), and mixing a rest-space element rect with mid-pose
+ * ancestor boxes invents a cut the size of the pose: measured as a
+ * destination cell reported 68.74% hidden on its right, which clipped the
+ * flight to a sliver. Fractions of a box are invariant under the rigid
+ * transforms screens fly by, so live-against-live reads the same answer the
+ * rest layout will.
+ */
+export declare const visibleInset: (element: Element | null) => MorphClipInset | null;
+/**
+ * The clip channel for a flight, or null when neither end was clipped —
+ * inset(0) at every frame is not worth an animated property.
+ */
+export declare const clipTravel: (from: MorphClipInset | null, to: MorphClipInset | null) => {
+    from: MorphClipInset;
+    to: MorphClipInset;
+} | null;

package/dist/morph/morphGeometry.d.ts

@@ -0,0 +1,111 @@
+import { MorphPose, PosePoint } from './morphPose';
+export interface MorphRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface MorphSnapshot {
+    rect: MorphRect;
+    /** The computed `font-size` in px — what makes type grow instead of stretch. */
+    fontSize: number | null;
+    /**
+     * The computed `font-weight`, and the computed `letter-spacing` in px.
+     *
+     * Size is only one of type's dimensions. A list label at 14px/600 handing
+     * over to a heading at 24px/800 that interpolates size alone wears the
+     * heading's WEIGHT from the first frame: the type visibly thickens in a
+     * single step and then merely gets bigger, which reads as a swap wearing a
+     * growth. Tracking is the same story in the other axis.
+     *
+     * Both are null when the two ends cannot be interpolated — `letter-spacing:
+     * normal` is not a length, and an element with no resolved weight has
+     * nothing to interpolate from.
+     */
+    fontWeight: number | null;
+    letterSpacing: number | null;
+    wordSpacing: number | null;
+    lineHeight: number | null;
+    /**
+     * The computed `aspect-ratio`, or null when the element does not declare one.
+     *
+     * It is what lets a nested element change SHAPE on the way rather than
+     * snapping to its destination's proportions on the first frame: a square
+     * thumbnail becoming a 4:3 hero is a ratio interpolating, not a box being
+     * replaced.
+     */
+    aspectRatio: string | null;
+    /**
+     * The element's own box model at capture: the padding it holds its contents
+     * in, and the margin that holds it away from its neighbours.
+     *
+     * Interpolating the outer box is not enough. The element in flight is the
+     * ARRIVAL's tree, so on the first frame it is already wearing the arrival's
+     * spacing — a list card with `p-2` handing over to a panel with `p-3` starts
+     * with its contents 8px narrower than the ones it is replacing, which is a
+     * visible flinch the wrong way at the exact moment of the tap.
+     */
+    padding: string;
+    margin: string;
+    /**
+     * Everything else the two ends can set differently — the corner, the surface
+     * colour, the border, the shadow (see morphPaint's table). Declared as data
+     * rather than as a branch per property, because that list was only ever as
+     * complete as the last thing someone noticed on glass.
+     */
+    paint: Record<string, string>;
+}
+export declare const rectCentre: (rect: MorphRect) => PosePoint;
+export declare const captureMorphSnapshot: (element: HTMLElement) => MorphSnapshot;
+/**
+ * A painted rect mapped back into the space its ancestor's transform is applied
+ * FROM.
+ *
+ * A screen that is mid-flight (or held at its from-pose) carries a transform,
+ * so every rect measured inside it is already displaced. The morph's own
+ * transform composes with that displacement rather than replacing it, so the
+ * travel has to be computed against the element's undisplaced box — otherwise
+ * every push under a sliding transition would start the element a screen-width
+ * away from where the eye last saw it.
+ */
+export declare const untransformRect: (painted: MorphRect, ancestor: MorphPose, ancestorCentre: PosePoint) => MorphRect;
+/**
+ * The transform an element is ACTUALLY wearing right now, read off its computed
+ * matrix rather than inferred from the variant it is supposed to be playing.
+ *
+ * Inferring it was a bug with a name: a held screen usually sits at its
+ * from-pose, but the destination PARK rules put it at its DESTINATION instead
+ * (so the browser rasterises the tiles the animation is about to reveal), and a
+ * measurement corrected for a displacement the screen was not wearing lands a
+ * screen-height away from where anything is. The matrix is true in every one of
+ * those states — parked, held, mid-flight, at rest.
+ *
+ * Rotation and skew are not represented: nothing in the library rotates a
+ * screen, and a rect is not a rotated shape anyway.
+ */
+export declare const readElementPose: (element: HTMLElement) => MorphPose;
+/**
+ * The centre an ancestor's transform is applied about, recovered from its
+ * painted rect. Scale leaves the centre where it is, so the translation is the
+ * whole difference — which is why this needs no scale term.
+ */
+export declare const untransformedCentre: (painted: MorphRect, ancestor: MorphPose) => PosePoint;
+/**
+ * The pose that puts `element` exactly where `target` is — the F of FLIP.
+ *
+ * Both rects live in the same (untransformed) space, and the transform is
+ * applied about the element's own centre, so the translation is centre-to-
+ * centre and the scale is the size ratio. Returns the identity when either box
+ * has no area: an unlaid-out element has no honest travel to compute, and
+ * dividing by its zero would produce an infinity that reaches the compositor.
+ */
+/**
+ * The transform that maps one box onto another, about the element's own centre.
+ *
+ * Only the GHOST uses it. Everything real animates its LAYOUT box so its
+ * contents lay themselves out at every size; a copy that is on its way out must
+ * do the opposite — keep the layout it was captured with and simply follow,
+ * or it re-wraps its own text while the real element re-wraps differently and
+ * the two print over each other.
+ */
+export declare const followPose: (target: MorphRect, element: MorphRect) => MorphPose;

package/dist/morph/morphKeyframes.d.ts

@@ -0,0 +1,190 @@
+import { AnimationOptions, TransitionTarget } from '../transition/cssTypes';
+import { MorphPose } from './morphPose';
+import { MorphClipInset } from './morphClip';
+import { MorphRect } from './morphGeometry';
+/** The non-transform half of an authored target — everything the geometry keyframe must not carry. */
+export declare const contentDecls: (target: TransitionTarget | undefined | null) => import('../transition/compileTransitionStyles').CssDecl[];
+export interface MorphTravel {
+    /** Where the element starts, relative to where it belongs. */
+    from: MorphPose;
+    /**
+     * Where it ends. The identity for anything that belongs at its own layout —
+     * which is everything except a GHOST, whose own box is the departure's and
+     * which therefore has to travel TO the arrival's instead.
+     */
+    to?: MorphPose;
+    /** An author's transform flourish, layered on top of the travel. */
+    authoredFrom: MorphPose;
+    authoredTo: MorphPose;
+    duration: number;
+    /** Seconds from the release, platform head included. */
+    start: number;
+    ease: AnimationOptions["ease"];
+}
+export interface MorphKeyframeSet {
+    /** `@keyframes` blocks to insert, in order. */
+    rules: string[];
+    /** The `animation` shorthand to put on the element. */
+    animation: string;
+    /**
+     * The animation whose end LANDS the flight — the geometry one where there is
+     * one, the corner where the corner is all that changes.
+     */
+    geometryName: string;
+}
+/**
+ * The keyframes and the `animation` shorthand for one side of a morph.
+ *
+ * Three animations, never one: the geometry keyframe carries `transform` and
+ * NOTHING else, because a keyframe listing a property the compositor cannot
+ * animate drops that whole animation to the main thread — and the travel is the
+ * one that must never leave it. The cross-fade and the corner ride alongside on
+ * their own clocks, which is also what lets them have their own windows: the
+ * fade has to be over while the two sides are still on top of each other, the
+ * corner has to track the scale for the whole flight.
+ *
+ * Two endpoints and the authored easing, because the element is staged in the
+ * FLIGHT LAYER: it is not inside a screen any more, so there is no screen
+ * motion left to compose with and nothing to sample.
+ */
+export declare const buildMorphKeyframes: (input: {
+    id: string;
+    travel: MorphTravel;
+    /**
+     * The element's LAYOUT BOX at each end, when it is the thing being animated.
+     *
+     * A box, not a scale. `transform: scale` stretches everything inside — text
+     * becomes a blown-up bitmap and the contents cannot find their own places —
+     * whereas animating the box lets the subtree lay itself out at every size on
+     * the way, which is what "it grows" is supposed to mean. It costs layout per
+     * frame on one subtree, which is the honest price of the thing actually
+     * being laid out.
+     */
+    box?: {
+        from: MorphRect;
+        to: MorphRect;
+    } | null;
+    /** Type morphs by growing, not by being scaled: px at each end. */
+    fontSize?: {
+        from: number;
+        to: number;
+    } | null;
+    /** Type's other two dimensions, so it re-typesets rather than merely re-sizing. */
+    fontWeight?: {
+        from: number;
+        to: number;
+    } | null;
+    letterSpacing?: {
+        from: number;
+        to: number;
+    } | null;
+    wordSpacing?: {
+        from: number;
+        to: number;
+    } | null;
+    lineHeight?: {
+        from: number;
+        to: number;
+    } | null;
+    /** A nested element changes SHAPE by interpolating its ratio, not by snapping to it. */
+    aspectRatio?: {
+        from: string;
+        to: string;
+    } | null;
+    /** The spacing the two ends hold their contents at, and stand apart by. */
+    padding?: {
+        from: string;
+        to: string;
+    } | null;
+    margin?: {
+        from: string;
+        to: string;
+    } | null;
+    /**
+     * A nested element's OWN box, width and height only, for the one geometry
+     * the container cannot carry for it. Riding assumes the container's width
+     * interpolation sizes the child, and it does when the container GROWS in
+     * width; a container that starts at full width (a list row becoming a page)
+     * lays the arrival out at destination width from the first frame, and a
+     * thumbnail inside it lands full-size instantly instead of growing. Measured
+     * on the playground's list: a 48px thumb rendered as a full-width strip on
+     * frame one. From-size to staged-size, exact at both ends.
+     */
+    size?: {
+        from: {
+            width: number;
+            height: number;
+        };
+        to: {
+            width: number;
+            height: number;
+        };
+    } | null;
+    /**
+     * What the scrollport was hiding at each end, as inset percentages — so a
+     * cell clipped at the list's edge slides out from under the chrome covering
+     * it instead of materialising whole over it (see morphClip). Percentages,
+     * because the box is itself animating and the visible FRACTION is the thing
+     * to preserve.
+     */
+    clip?: {
+        from: MorphClipInset;
+        to: MorphClipInset;
+    } | null;
+    fade: {
+        from: TransitionTarget | null;
+        to: TransitionTarget | null;
+        duration: number;
+        /** Seconds to hold the from-pose before the fade runs, on top of `travel.start`. */
+        delay?: number;
+    } | null;
+    /**
+     * Everything the two ends paint differently — corner, surface, border,
+     * shadow. One animation, so the travel keyframe stays on the compositor.
+     */
+    paint: {
+        property: string;
+        from: string;
+        to: string;
+    }[];
+}) => MorphKeyframeSet;
+/**
+ * The CAMERA: the transform that takes a screen from resting to "zoomed onto
+ * this element", for a flight that carries its screen.
+ *
+ * One uniform scale and one translate, both literal — the same discipline the
+ * travel keeps, and for the same reason: a compiled animation whose values come
+ * from custom properties was device-bisected off the compositor on WebKit
+ * (see the literal-timing note in compileTransitionStyles).
+ *
+ * The scale comes from WIDTH alone. The element's own box changes aspect across
+ * the flight, so no single uniform scale can match both axes, and width is the
+ * axis a column grid is built on: at the end of the zoom the tapped cell is
+ * exactly as wide as the screen, which is what puts everything else off the
+ * edges.
+ *
+ * The animation is emitted as LONGHANDS, never the `animation` shorthand: the
+ * shorthand would also write `animation-play-state`, and that longhand belongs
+ * to the compiled hold — the camera has to pause and release with its screen
+ * like everything else in the flight.
+ */
+export declare const buildCameraKeyframes: (input: {
+    id: string;
+    /** The screen's transform-origin, in the same space as the rects. */
+    origin: {
+        x: number;
+        y: number;
+    };
+    /** The element's box on the screen being carried, and at the other end. */
+    small: MorphRect;
+    big: MorphRect;
+    /** True when the screen is arriving (a pop): it starts zoomed and settles. */
+    settling: boolean;
+    duration: number;
+    start: number;
+    ease: AnimationOptions["ease"];
+    selector: string;
+}) => {
+    rules: string[];
+    name: string;
+};

package/dist/morph/morphLayer.d.ts

@@ -0,0 +1,14 @@
+import { NavigateStoreApi } from '../navigate/store';
+/**
+ * Publish the element a scope's flights should be staged in. A binding calls
+ * this from its Router lifecycle — the Router is the only thing that knows
+ * which box bounds its screens.
+ */
+export declare const registerMorphLayer: (store: NavigateStoreApi, element: HTMLElement | null) => void;
+/**
+ * The layer to stage a flight in, creating a document-level fallback for a
+ * binding that publishes none. The fallback is correct for a root Router (its
+ * screens fill the viewport anyway) and wrong only for a CONTAINED one, which
+ * is exactly the case a binding is expected to publish.
+ */
+export declare const resolveMorphLayer: (store: NavigateStoreApi) => HTMLElement | null;

package/dist/morph/morphPaint.d.ts

@@ -0,0 +1,31 @@
+export interface PaintChannel {
+    /** The property as it is written in a keyframe. */
+    property: string;
+    /**
+     * Read as four sides rather than one value. A shorthand's computed value is
+     * empty when the sides disagree, which is exactly the case worth carrying.
+     */
+    sides?: readonly [string, string, string, string];
+    /**
+     * Rewrite a captured value into an interpolable one. A keyword end turns the
+     * whole channel into a discrete swap at the eased midpoint — worse than not
+     * carrying it, because it fires mid-flight where nothing else steps.
+     */
+    normalize?: (value: string) => string;
+}
+export declare const PAINT_CHANNELS: readonly PaintChannel[];
+type Styles = Record<string, string | undefined> | null | undefined;
+/** Both ends' values for every channel, keyed by the property a keyframe wants. */
+export declare const capturePaint: (styles: Styles) => Record<string, string>;
+/**
+ * The channels worth animating: present at both ends and different.
+ *
+ * `exclude` is how a morph transition opts out of one — the built-in `text`
+ * preset turns the corner off, because type has none worth moving.
+ */
+export declare const paintTravel: (from: Record<string, string>, to: Record<string, string>, exclude?: ReadonlySet<string>) => {
+    property: string;
+    from: string;
+    to: string;
+}[];
+export {};

package/dist/morph/morphPose.d.ts

@@ -0,0 +1,44 @@
+import { TransitionTarget } from '../transition/cssTypes';
+export interface MorphPose {
+    /** Translation in px. */
+    x: number;
+    y: number;
+    scaleX: number;
+    scaleY: number;
+    /** Degrees. */
+    rotate: number;
+}
+export interface PoseBox {
+    width: number;
+    height: number;
+}
+export interface PosePoint {
+    x: number;
+    y: number;
+}
+export declare const IDENTITY_POSE: MorphPose;
+export declare const resolveLength: (raw: string | number | undefined, basis: number) => number | null;
+/**
+ * The transform channels of an authored target as numbers, or `null` when one
+ * of them is a length this module cannot resolve (see resolveLength).
+ */
+export declare const resolvePose: (target: TransitionTarget | undefined | null, box: PoseBox) => MorphPose | null;
+/** Whether an authored target moves anything this module represents. */
+export declare const poseIsIdentity: (pose: MorphPose) => boolean;
+/**
+ * One pose as a CSS transform value. `translate3d` rather than translateX/Y for
+ * the same reason the keyframes compiler uses it: Chromium pixel-snaps a
+ * 2D-transform-animated layer on raster-heavy content, and the 3D form keeps
+ * the layer on the texture-filtered path that slides sub-pixel smoothly.
+ */
+export declare const poseToCss: (pose: MorphPose) => string;
+/**
+ * Several poses as ONE transform value, outermost first.
+ *
+ * Concatenation IS composition in CSS — `transform: A B` maps a point through B
+ * and then A — so the runtime never multiplies matrices. That is what lets the
+ * measured travel and an author's flourish stack on one element instead of
+ * needing a wrapper each.
+ */
+export declare const composePosesToCss: (poses: MorphPose[]) => string;
+export declare const interpolatePose: (from: MorphPose, to: MorphPose, progress: number) => MorphPose;

package/dist/morph/morphSheet.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Insert one flight's rules and return the disposer that removes exactly them.
+ *
+ * The rules are tracked by identity, not by index: a concurrent flight (two
+ * morphing elements in one navigation, or a second navigation interrupting the
+ * first) inserts and drops rules in between, and an index captured at insertion
+ * would by then point at someone else's keyframes.
+ */
+export declare const insertMorphRules: (rules: string[]) => (() => void);

package/dist/morph/morphSide.d.ts

@@ -0,0 +1,43 @@
+import { NavigateStatus } from '../navigate/store';
+import { AnimationOptions } from '../transition/cssTypes';
+import { TransitionVariant } from '../transition/typing';
+import { MorphRect } from './morphGeometry';
+export declare const headSeconds: (status: NavigateStatus) => number;
+export interface MorphSide {
+    /**
+     * Where the element's box belongs AT REST, in viewport coordinates.
+     *
+     * Not simply its measured rect: a screen mid-flight (or held at its from-pose)
+     * carries a transform, and every rect measured inside it is displaced by it.
+     * The travel has to be computed against the undisplaced box, or a push under a
+     * sliding transition would aim a screen-width away from where the element ends.
+     */
+    rect: MorphRect;
+    fontSize: number | null;
+    fontWeight: number | null;
+    letterSpacing: number | null;
+    wordSpacing: number | null;
+    lineHeight: number | null;
+    aspectRatio: string | null;
+    padding: string;
+    margin: string;
+    paint: Record<string, string>;
+    /**
+     * Whether this screen's transition MOVES it — read from the DEFINITION, not
+     * from the element: at the moment a flight is staged the arriving screen is
+     * parked at its DESTINATION with no transform on it yet (`park-under`), so
+     * asking the DOM answers no for every screen that is about to slide in.
+     */
+    screenMoves: boolean;
+    /** The screen's own timing, so a morph that authors none lands with its screen. */
+    screenDuration: number;
+    screenEase: AnimationOptions["ease"];
+}
+/**
+ * Where one side of a morph really is, and how long its screen takes.
+ *
+ * The screen is read from the DOM PROTOCOL — its transition name is an
+ * attribute — rather than from a store, so a morph works the same for any
+ * binding and needs nothing threaded through from the consumer's tree.
+ */
+export declare const resolveMorphSide: (element: HTMLElement, screen: HTMLElement, variant: TransitionVariant) => MorphSide;

package/dist/morph/morphSwipe.d.ts

@@ -0,0 +1,24 @@
+import { NavigateStatus, NavigateStoreApi } from '../navigate/store';
+export interface MorphSwipe {
+    /** Move every staged flight to this fraction of its travel (0 → 1). */
+    scrub: (progress: number) => void;
+    /**
+     * Hand the flights back to the browser.
+     *
+     * `commit` plays them out to the arrival — the gesture became a navigation.
+     * Otherwise they run BACKWARDS to where they started and the elements go
+     * home, which is the only way back: a flight that is merely stopped leaves
+     * the element in the layer, outside the tree its consumer wrote.
+     */
+    settle: (commit: boolean, seconds: number) => void;
+    /** Whether anything is actually flying (a screen pair with no shared element is not). */
+    readonly active: boolean;
+}
+/**
+ * Stage the flights for a gesture and return the handle that drives them.
+ *
+ * `status` is the direction the gesture WOULD commit — `"POPPING"` for a
+ * back-swipe — because the pairing reads it to decide which side is arriving.
+ */
+export declare const beginMorphSwipe: (store: NavigateStoreApi, status?: NavigateStatus) => MorphSwipe;
+export default beginMorphSwipe;

package/dist/navigate/createNavigationController.d.ts

@@ -8,7 +8,6 @@ export interface DistanceOptions {
     until?: string;
 }
 export interface NavigateOptions extends DistanceOptions {
-    layoutId?: string | number;
     transitionName?: TransitionName;
 }
 export interface PopOptions extends DistanceOptions {

package/dist/screen/__tests__/publishRideBox.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/screen/publishRideBox.d.ts

@@ -0,0 +1 @@
+export default function publishRideBox(element: HTMLElement): () => void;

package/dist/transition/__tests__/compileTransitionStyles.test.d.ts

@@ -1,5 +1,6 @@
 declare module '../typing' {
     interface RegisterTransition {
+        "custom-snap-percent": "custom-snap-percent";
         "custom-fade-blur": "custom-fade-blur";
         "custom-slide-fade": "custom-slide-fade";
         "custom-rich-css": "custom-rich-css";
@@ -13,6 +14,7 @@ declare module '../decorator/typing' {
     interface RegisterDecorator {
         "rich-deco": "rich-deco";
         "held-deco": "held-deco";
+        "moving-deco": "moving-deco";
         "authored-deco": "authored-deco";
     }
 }

package/dist/transition/__tests__/rideOffset.test.d.ts

@@ -0,0 +1 @@
+export {};