@flemo/core 1.29.0 → 2.0.0

package/dist/core/TaskManger.d.ts

@@ -50,6 +50,19 @@ declare class TaskManager {
     emitSignal(signalName: string): void;
     private processPendingTasks;
     private pendingWaiters;
+    /**
+     * Wake the queue on the next frame, so the terminal flip's commit and the
+     * queued flight's opening commit land in different ones.
+     *
+     * Falls straight through where there is no frame clock (SSR, a non-browser
+     * embedder): there is no commit to separate from.
+     *
+     * Reaching this at all takes a task genuinely PENDING ahead of the queued one
+     * — a waiter added to an empty queue resolves on the spot and never goes
+     * through the notify path, so a test that merely drives two tasks exercises
+     * nothing here. The suite holds a manual task open and queues behind it.
+     */
+    private wakeQueueNextFrame;
     private notifyPendingWaiters;
     private waitForPendingTasks;
     private onTaskStatusChange;

package/dist/core/engine/__tests__/architectureDoc.test.d.ts

@@ -0,0 +1,10 @@
+declare global {
+    interface ImportMeta {
+        glob(pattern: string, options: {
+            query: string;
+            import: string;
+            eager: true;
+        }): Record<string, string>;
+    }
+}
+export {};

package/dist/core/engine/__tests__/diagnosticRegistry.test.d.ts

@@ -0,0 +1,10 @@
+declare global {
+    interface ImportMeta {
+        glob(pattern: string, options: {
+            query: string;
+            import: string;
+            eager: true;
+        }): Record<string, string>;
+    }
+}
+export {};

package/dist/core/engine/__tests__/flightRouting.test.d.ts

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

package/dist/core/engine/__tests__/landingGovernor.test.d.ts

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

package/dist/core/engine/__tests__/layerRiders.test.d.ts

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

package/dist/core/engine/__tests__/participantLayers.test.d.ts

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

package/dist/core/engine/__tests__/singleResolution.test.d.ts

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

package/dist/core/engine/arrivalHold.d.ts

@@ -1,2 +1,2 @@
-export declare const HELD_ARRIVAL_ATTR = "data-flemo-held-arrival";
+export { HELD_ARRIVAL_ATTR } from '../../dom/attributes';
 export default function createArrivalHold(scope: HTMLElement): () => void;

package/dist/core/engine/cancelResume.d.ts

@@ -0,0 +1,17 @@
+import { VariantMotion } from '../../transition/variantMotion';
+export declare const RESUME_BUDGET = 4;
+export interface CancelResumeConfig {
+    element: HTMLElement;
+    expectedName: string;
+    motion: VariantMotion;
+    isLive: () => boolean;
+    budgetUsed: () => number;
+    spendBudget: () => void;
+    onTerminal: () => void;
+    writer?: symbol;
+}
+export declare const wireCancelResume: (config: CancelResumeConfig) => {
+    attach: () => void;
+    detach: () => void;
+    fullRestart: () => void;
+};

package/dist/core/engine/compositorWarmUp.d.ts

@@ -1,3 +1,3 @@
-export declare const WARM_ATTR = "data-flemo-warm";
+export { WARM_ATTR } from '../../dom/attributes';
 export declare const resetCompositorWarmForTesting: () => void;
 export default function holdCompositorWarm(): () => void;

package/dist/core/engine/createSwipeController.d.ts

@@ -24,12 +24,28 @@ export interface SwipeControllerConfig {
     getPartnerBarMetadata?: () => SharedBarsMetadata | undefined;
     setDragStatus: (status: "IDLE" | "PENDING") => void;
     back: () => void;
+    onDragStart?: () => void;
+    /** 0 at rest, 1 at the point the gesture would commit. */
+    onDragProgress?: (progress: number) => void;
+    /** The release: whether it committed, and the seconds the screens settle in. */
+    onDragSettle?: (committed: boolean, seconds: number) => void;
 }
 export interface SwipeController {
     pointerDown: (event: PointerEvent) => void;
     pointerMove: (event: PointerEvent) => void;
     pointerUp: (event: PointerEvent) => void;
     pointerCancel: (event: PointerEvent) => void;
+    lostPointerCapture: (event: PointerEvent) => void;
+    /**
+     * Abandon whatever gesture is in flight, with no pointer to close it.
+     *
+     * The binding calls this when the SCREEN goes away underneath one: an unmount,
+     * or a freeze (which detaches the listeners but keeps this controller, since
+     * it outlives the effects). Without it the gesture state has exactly one way
+     * out — a pointerup carrying the id that armed it — and if the browser never
+     * delivers that event, nothing ever does. See the note on `abandon` below.
+     */
+    abandon: () => void;
     shouldPreventTouch: () => boolean;
 }
 export default function createSwipeController(config: SwipeControllerConfig): SwipeController;

package/dist/core/engine/createTransitionEngine.d.ts

@@ -1,3 +1,4 @@
 import { TransitionEngine, TransitionEngineDeps } from './types';
-export declare const resetDisplayProbeForTests: () => void;
+import { resetDisplayProbeForTests } from '../../platform/displayProbe';
+export { resetDisplayProbeForTests };
 export default function createTransitionEngine(deps: TransitionEngineDeps): TransitionEngine;

package/dist/core/engine/diagnosticFlags.d.ts

@@ -1,7 +1,6 @@
-export declare const readLandingSnapFlag: () => boolean;
 export declare const readImageHoldFlag: () => "on" | "off" | null;
+export declare const morphTraceArmed: () => boolean;
 export declare const readSettleGateFlag: () => boolean;
-export declare const readHandoffFlag: () => boolean;
 export declare const readArrivalHoldFlag: () => boolean;
 export declare const readDesktopReleaseFlipFlag: () => boolean;
 export declare const readCreepHeadFlag: () => boolean;
@@ -10,14 +9,7 @@ export declare const readDesktopHeadFlag: () => boolean;
 export declare const readPrerasterFlag: () => boolean;
 export declare const readRestLayerPromotionFlag: () => boolean;
 export declare const readImageOffloadOverride: () => "on" | "off" | null;
-export declare const HANDOFF_MS_DEFAULT: number;
-export declare const JITTER_BAND_MAX_DEVICE_PX = 4;
-export declare const snapshotApplyOverride: () => "scrub" | null;
-export declare const handoffOverride: () => "on" | null;
-export declare const snapOverride: () => "always" | "off" | "gate" | "hybrid" | null;
-export declare const jitterBandMaxDevicePx: () => number;
-export declare const handoffMs: () => number;
-export declare const resetSessionOverrideCachesForTests: () => void;
+export declare const readBlinkGovernedOverride: () => "on" | "off" | null;
 export declare const residentScreenLayers: () => boolean;
 export declare const resetResidentLayersForTesting: () => void;
 export declare const shallowFreeze: () => boolean;

package/dist/core/engine/diagnosticRegistry.d.ts

@@ -0,0 +1,38 @@
+/**
+ * What kind of thing a flag is — which decides how a report should read it.
+ *
+ * - `production-state`: written by the library itself (a learned ledger). Never
+ *   set by hand; the KEY STRINGS are frozen, since users' devices carry
+ *   persisted values.
+ * - `production-default-with-override`: the library computes a default and the
+ *   key overrides it both ways, for field debugging.
+ * - `opt-in-diagnostic`: default OFF. A measurement instrument that ships so a
+ *   device session can be probed without a custom build.
+ */
+export type DiagnosticFlagKind = "production-state" | "production-default-with-override" | "opt-in-diagnostic";
+export interface DiagnosticFlag {
+    readonly key: string;
+    readonly storage: "session" | "local";
+    readonly kind: DiagnosticFlagKind;
+    /** Accepted values, for a report or a panel to offer. */
+    readonly values: string;
+    /** The default when the key is unset. */
+    readonly fallback: string;
+    readonly effect: string;
+}
+/** Every `flemo:*` key the library reads today. */
+export declare const DIAGNOSTIC_FLAGS: readonly DiagnosticFlag[];
+export interface RetiredDiagnosticFlag {
+    readonly key: string;
+    readonly storage: "session" | "local";
+    /** What it used to do, and when it stopped doing it. */
+    readonly retiredWith: string;
+}
+/**
+ * Keys the library once read and no longer does. Declared so a report can say
+ * "this is set, and it does nothing" — residue that is merely unknown reads as
+ * a lead worth chasing, and one such key once burned a multi-day investigation.
+ *
+ * Values persisted on users' devices are never read again.
+ */
+export declare const RETIRED_DIAGNOSTIC_FLAGS: readonly RetiredDiagnosticFlag[];

package/dist/core/engine/flightHolds.d.ts

@@ -0,0 +1,22 @@
+import { TransitionName } from '../../transition/typing';
+export interface FlightHoldsDeps {
+    /**
+     * Land any pending deferred landing NOW. A navigation starting inside a
+     * still-pending window must not let that window's reveal punch into it.
+     */
+    readonly landNow: () => void;
+    /** Defer a release to the frames past the COMPLETED flip. */
+    readonly scheduleLanding: (land: () => void) => void;
+}
+export interface FlightHoldsInput {
+    readonly isTransitional: boolean;
+    readonly isActive: boolean;
+    readonly status: string;
+    readonly transitionName: TransitionName;
+    readonly getScope: () => HTMLElement | null | undefined;
+}
+export interface FlightHolds {
+    /** Reconcile every hold with what this drive run says the screen is doing. */
+    readonly sync: (input: FlightHoldsInput) => void;
+}
+export declare const createFlightHolds: (deps: FlightHoldsDeps) => FlightHolds;

package/dist/core/engine/flightParticipants.d.ts

@@ -0,0 +1,8 @@
+import { default as resolveTransition } from '../../transition/resolveTransition';
+import { TransitionVariant } from '../../transition/typing';
+export declare const collectScreenParts: (scope: HTMLElement) => HTMLElement[];
+export declare const collectVariantParts: (scope: HTMLElement, variant: TransitionVariant) => HTMLElement[];
+export declare const collectFlightParts: (scope: HTMLElement, status: string) => HTMLElement[];
+export declare const collectUnheldOuterParts: (scope: HTMLElement, status: string) => HTMLElement[];
+export declare const collectStampedOuterParts: (scope: HTMLElement) => HTMLElement[];
+export declare const statusChoreographySpanMs: (scope: HTMLElement, transition: ReturnType<typeof resolveTransition>, status: string) => number;

package/dist/core/engine/flightRouting.d.ts

@@ -0,0 +1,91 @@
+import { Transition } from '../../transition/typing';
+export interface FlightRouting {
+    /** This flight has motion to drive at all (not skipped, and it resolves). */
+    readonly hasDrivableMotion: boolean;
+    /**
+     * The engine may perform CLOCK SURGERY on this flight — the first-frame
+     * hold, the flight-start anchor, stall re-anchoring. Authored
+     * `driver: "native"` pins only, and never on Blink.
+     *
+     * Every one of those mutates a running animation's timing (WAAPI pause/play,
+     * startTime shifts), and the 2026-08 iPhone falsification series established
+     * that on WebKit any such touch costs the accelerated out-of-process path or
+     * desyncs its re-sync. The default therefore runs the compiled animation
+     * UNTOUCHED and protects the opening by release scheduling instead. An author
+     * who pins "native" takes the main-thread-presentation trade knowingly.
+     */
+    readonly nativeSurgeryAllowed: boolean;
+    /** Touch WebKit on the governed compiled tier. */
+    readonly touchGoverned: boolean;
+    /**
+     * Touch WebKit whose STATUS also takes the flat head: POP always, PUSH once
+     * the settle gate has moved the mount weight out of the release.
+     */
+    readonly forceCompiled: boolean;
+    /**
+     * This flight gets the GOVERNED HEAD KIT — a flat opening segment baked into
+     * the keyframes, so a commit that ages the wall clock eats the head instead
+     * of the curve's start.
+     */
+    readonly governedHead: boolean;
+    /**
+     * Desktop macOS Safari's own flat head: the same compiled clock presented
+     * from the main thread, with its own lengths and its own gate attribute.
+     * Arming it retires the birth anchor — two interventions on one clock is the
+     * pairing the touch tier was built to avoid.
+     */
+    readonly desktopHead: boolean;
+    /** The head's length for this status, in milliseconds. 0 when there is none. */
+    readonly birthHoldMs: number;
+    /**
+     * A SLIDE on the governed touch tier. It stands the wall-clock accelerators
+     * down for the same reason `forceCompiled` does, and covers one case that
+     * predicate does not: a touch-WebKit PUSH with the settle gate turned off.
+     *
+     * Named `governedSoftenActive` until 2026-08, after the front-softening
+     * treatment it shipped beside. That treatment is gone; this outlived it
+     * because what it guards is the clock, not the curve.
+     */
+    readonly governedSlide: boolean;
+    /**
+     * Keep a frame source alive for the flight. Compiled Blink only: a
+     * compositor-driven flight leaves the main thread idle, and Chrome then
+     * paces its macOS ProMotion presentation unevenly — video-measured as
+     * drops and double-steps the eye reads as trembling.
+     */
+    readonly framePacingKeepalive: boolean;
+    /** Arm the creep head beside the governed one (`flemo:creep`). */
+    readonly creepHead: boolean;
+}
+export interface FlightRoutingInput {
+    readonly status: string;
+    readonly transition: Transition;
+    /** The scope carries the skip marker for this flight. */
+    readonly skipAnimation: boolean;
+    /** The active variant resolves a motion. */
+    readonly hasActiveMotion: boolean;
+    /** The active variant has an authored animation at all. */
+    readonly hasAnimation: boolean;
+}
+/**
+ * WHICH HEAD KIT this session plays, and how long its flat head is.
+ *
+ * Extracted so it has exactly one definition. It is a pure function of the
+ * platform, the diagnostic flags and the status — nothing about the flight —
+ * and the MORPH runtime needs the same answer at a moment when it cannot get
+ * it from the DOM: the head is announced by an attribute on the root, and the
+ * engine writes that attribute from the SAME commit the morph is staged in.
+ * React runs a descendant's layout effect first, so a morph reading the
+ * attribute reads the PREVIOUS flight's answer — right by luck from the second
+ * navigation on, and wrong on the first, which is what made a first push run
+ * its element 33ms ahead of the screen carrying it while every push after it
+ * was aligned.
+ */
+export declare const resolveHeadKit: (status: string) => {
+    touchGoverned: boolean;
+    forceCompiled: boolean;
+    governedHead: boolean;
+    desktopHead: boolean;
+    headMs: number;
+};
+export declare const resolveFlightRouting: (input: FlightRoutingInput) => FlightRouting;

package/dist/core/engine/gpuPipelinePrewarm.d.ts

@@ -1,4 +1,4 @@
-export declare const GPU_PREWARM_ATTR = "data-flemo-gpu-prewarm";
+export { GPU_PREWARM_ATTR } from '../../dom/attributes';
 export declare const PREWARM_SPAN_MS = 450;
 export declare const resetGpuPipelinePrewarmForTesting: () => void;
 export default function ensureGpuPipelinePrewarm(): () => void;

package/dist/core/engine/imageDecodeOffloader.d.ts

@@ -1,5 +1,5 @@
 export declare const OVERSIZE_AREA_RATIO = 8;
-export declare const OFFLOADED_SRC_ATTR = "data-flemo-image-src";
+export { OFFLOADED_SRC_ATTR } from '../../dom/attributes';
 export interface OversizeInput {
     naturalWidth: number;
     naturalHeight: number;

package/dist/core/engine/landingGovernor.d.ts

@@ -0,0 +1,3 @@
+import { VariantMotion } from '../../transition/variantMotion';
+import { PerceptualBox } from './perceptualSpan';
+export declare const governedEasingForMotion: (motion: VariantMotion, box: PerceptualBox, devicePixelRatio: number, frameIntervalMs: number) => string | null;

package/dist/core/engine/layerRiders.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The `<Layer>` overlays that move with the screen in this container.
+ *
+ * Two shapes, because a host is inherited. A screen that renders its OWN host
+ * moves everything portaled into it by moving that one box. A screen NESTED
+ * inside such a host has its overlays in a container that is not its own, and
+ * no walk of its subtree can find them — so they are matched by the owner id
+ * they carry.
+ *
+ * Never both: driving a host and the slots inside it would compose the two
+ * writes and send the overlay twice as far as its screen.
+ */
+export declare const collectLayerRiders: (container: HTMLElement | null) => HTMLElement[];
+/**
+ * Whether an element beside a scope is riding this flight.
+ *
+ * A bar rides only when its partner screen does not own it, so it says so with
+ * an attribute the binding flips per flight. An overlay has exactly one screen
+ * and always leaves with it, so being a host or a slot is the whole answer.
+ */
+export declare const isRider: (element: HTMLElement | null | undefined) => element is HTMLElement;

package/dist/core/engine/participantLayers.d.ts

@@ -0,0 +1,12 @@
+import { default as resolveTransition } from '../../transition/resolveTransition';
+import { TransitionVariant } from '../../transition/typing';
+export declare const holdParticipantLayers: (elements: {
+    scope: HTMLElement;
+    decorator?: HTMLElement | null;
+    bars?: (HTMLElement | null | undefined)[];
+}, transition: ReturnType<typeof resolveTransition>, variant: TransitionVariant, owner: symbol) => void;
+export declare const releaseParticipantLayers: (elements: {
+    scope?: HTMLElement | null;
+    decorator?: HTMLElement | null;
+    bars?: (HTMLElement | null | undefined)[];
+}, owner: symbol) => void;

package/dist/core/engine/types.d.ts

@@ -1,6 +1,6 @@
 import { NavigateStatus } from '../../navigate/store';
 import { TransitionName } from '../../transition/typing';
-export declare const SKIP_ANIMATION_ATTR = "data-flemo-skip-animation";
+export { SKIP_ANIMATION_ATTR } from '../../dom/attributes';
 export interface TransitionEngineDeps {
     getTransitionTaskId: () => string | null;
     setDragStatus: (status: "IDLE" | "PENDING") => void;
@@ -11,6 +11,7 @@ export interface ScreenLifecycleInput {
         scope: HTMLElement | null;
         decorator?: HTMLElement | null;
         bars?: (HTMLElement | null | undefined)[];
+        screenContainer?: HTMLElement | null;
     };
     transitionName: TransitionName;
     prevTransitionName: TransitionName;

package/dist/dom/__tests__/attributes.test.d.ts

@@ -0,0 +1,10 @@
+declare global {
+    interface ImportMeta {
+        glob(pattern: string, options: {
+            query: string;
+            import: string;
+            eager: true;
+        }): Record<string, string>;
+    }
+}
+export {};

package/dist/dom/__tests__/stacking.test.d.ts

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

package/dist/dom/attributes.d.ts

@@ -0,0 +1,239 @@
+/** Shared prefix. Every attribute below starts with it. */
+export declare const FLEMO_ATTR_PREFIX = "data-flemo-";
+/**
+ * Marks a screen scope, and carries that screen's id.
+ *
+ * The value was empty until a `<Layer>` slot needed to name the screen it
+ * belongs to from the DOM alone. Presence selectors are unaffected, which is
+ * what every existing reader uses; nothing may start requiring the value.
+ */
+export declare const SCREEN_ATTR = "data-flemo-screen";
+/** The navigation status this screen is rendering: a `NavigateStatus` value. */
+export declare const STATUS_ATTR = "data-flemo-status";
+/** `"true"` on the screen the navigation is moving TO, `"false"` on its partner. */
+export declare const ACTIVE_ATTR = "data-flemo-active";
+/** The resolved transition name, so the compiled rules select the right keyframes. */
+export declare const TRANSITION_ATTR = "data-flemo-transition";
+/**
+ * The owning Router's identity. The engine scopes a flight's choreography
+ * participants by this marker rather than by DOM structure: each screen sits in
+ * its own wrapper, a root Router renders no container, and two independent
+ * Routers may share a DOM parent — so structure cannot draw the line.
+ */
+export declare const ROUTER_ATTR = "data-flemo-router";
+/**
+ * `"true"` suppresses this screen's motion for one flight (an interrupted or
+ * restored navigation that must land without animating).
+ */
+export declare const SKIP_ANIMATION_ATTR = "data-flemo-skip-animation";
+/** Marks a shared bar element. */
+export declare const BAR_ATTR = "data-flemo-bar";
+/** The bar's own active flag (see ACTIVE_ATTR). */
+export declare const BAR_ACTIVE_ATTR = "data-flemo-bar-active";
+/** The bar's own status (see STATUS_ATTR). */
+export declare const BAR_STATUS_ATTR = "data-flemo-bar-status";
+/**
+ * `"true"` while the bar RIDES its screen's keyframes — the compiled rule pairs
+ * the bar selector with the screen rule, so the pair moves in lockstep.
+ */
+export declare const BAR_RIDING_ATTR = "data-flemo-bar-riding";
+/** The consumer-supplied shared-bar id, used to match a bar across screens. */
+export declare const BAR_ID_ATTR = "data-flemo-bar-id";
+/** The id's `typeof`, so `1` and `"1"` never match as the same bar. */
+export declare const BAR_ID_TYPE_ATTR = "data-flemo-bar-id-type";
+/** The transition name driving this bar. */
+export declare const BAR_TRANSITION_ATTR = "data-flemo-bar-transition";
+/** The layout spacer that reserves a shared bar's height in the screen flow. */
+export declare const BAR_SPACER_ATTR = "data-flemo-bar-spacer";
+/** Marks the decorator element (the dim/overlay layer between screens). */
+export declare const DECORATOR_ATTR = "data-flemo-decorator";
+/** The decorator definition's name, for its own compiled rules. */
+export declare const DECORATOR_NAME_ATTR = "data-flemo-decorator-name";
+/**
+ * The HOST: one childless box per screen chain, rendered by the OUTERMOST
+ * screen's container and inherited by every screen nested inside it. Outermost
+ * because an overlay has to clear the chrome of every screen above its own,
+ * and chrome declared by an ancestor sits outside that ancestor's scope.
+ *
+ * It is `position: absolute` and full-size so a consumer's absolutely
+ * positioned overlay has the region to anchor to, and it never takes a pointer
+ * itself — a host with nothing in it must not swallow taps meant for the
+ * screen underneath.
+ */
+export declare const LAYER_HOST_ATTR = "data-flemo-layer-host";
+/**
+ * A SLOT: one per `<Layer>`, portaled into the host, carrying its owning
+ * screen's identity. This is what keeps the escape from becoming an orphan —
+ * the slot leaves the screen's box for PAINT ORDER only, and takes the rest of
+ * being that screen with it:
+ *
+ * - it stacks by its owner's position, so two screens' overlays order the way
+ *   their screens do rather than by portal mount order
+ * - it carries its owner's status/active/transition, so the compiled screen
+ *   rule animates it in lockstep and it leaves WITH its screen (the same
+ *   pairing a riding shared bar uses)
+ * - it mirrors its owner's paint-hidden state, which `visibility: hidden` on
+ *   the screen container cannot reach across a portal
+ *
+ * Unmounting is React's: the slot is rendered from inside its screen's
+ * subtree, so it dies with the screen without anything having to notice.
+ */
+export declare const LAYER_SLOT_ATTR = "data-flemo-layer-slot";
+/**
+ * The id (see SCREEN_ATTR) of the screen a slot belongs to.
+ *
+ * A slot sits in an ancestor's host, so nothing about where it IS says whose
+ * it is. The gesture driver needs to: a drag moves a screen by writing inline
+ * styles frame by frame rather than through the compiled rules, so it has to
+ * enumerate everything that rides along, and it finds those by walking the
+ * moving screen's container. A slot is not in that container. This is how it
+ * is found anyway — the same problem a shared bar does not have, because a bar
+ * never leaves the container it belongs to.
+ */
+export declare const LAYER_OWNER_ATTR = "data-flemo-layer-owner";
+/**
+ * A `<Part>`'s registered part-transition name. Parts self-carry their screen's
+ * status/active (STATUS_ATTR/ACTIVE_ATTR) so the compiled part selectors and
+ * the engine's participant scan can both find them.
+ */
+export declare const PART_NAME_ATTR = "data-flemo-part-name";
+/**
+ * Marks a registered morph element. Presence only — the value is the ROLE
+ * (see MORPH_ROLE). Written by the binding, read by the morph runtime (to find
+ * the pair), by the compiled hold rule (so a morph pauses with its screen),
+ * and by devtools.
+ */
+export declare const MORPH_ATTR = "data-flemo-morph";
+/** The morph's side of the flight, stamped by the runtime for its duration. */
+export declare const MORPH_ROLE: {
+    /** The arriving element: it travels from its partner's rect to its own. */
+    readonly ENTER: "enter";
+    /** The element left behind: it stays put and trades places with the arrival. */
+    readonly EXIT: "exit";
+};
+/**
+ * The registered morph-transition name for this element, so a consumer can run
+ * different morph choreography per element. Absent means the default preset.
+ */
+export declare const MORPH_NAME_ATTR = "data-flemo-morph-name";
+/**
+ * The per-Router FLIGHT LAYER: the box a shared element is staged in while it
+ * travels. Rendered by the binding (a Router knows which box bounds its
+ * screens); the morph runtime moves the element in at the start of a flight and
+ * back on landing. A morph inside a screen would be clipped by it, covered by
+ * it and dragged along with it — all three are properties of being a
+ * descendant, so for the flight it stops being one.
+ */
+export declare const MORPH_LAYER_ATTR = "data-flemo-morph-layer";
+/**
+ * The morph's placeholder: the box that stays behind in the layout, at the
+ * element's own size, while the element itself is up in the flight layer. It is
+ * what keeps the arriving screen laid out exactly as it will be at rest, so the
+ * landing has somewhere true to land.
+ */
+export declare const MORPH_SLOT_ATTR = "data-flemo-morph-slot";
+/**
+ * The STAND-IN: a copy of the element that is flying, left in its slot to hold
+ * its place in the layout.
+ *
+ * A placeholder measured in pixels is a placeholder that can be wrong, and
+ * "wrong" here is a layout shift lasting exactly as long as the flight. A copy
+ * of the element cannot be: the layout has no way to tell it apart from what
+ * was there — same box, same margins, same baseline. It paints nothing and
+ * takes no input, and it is replaced by the real element on landing. Owned
+ * entirely by the morph runtime.
+ */
+export declare const MORPH_STAND_IN_ATTR = "data-flemo-morph-stand-in";
+/**
+ * The GHOST: a copy of the element being replaced, carried inside the flight so
+ * the travelling box shows what was actually there at the start instead of the
+ * arrival's content squeezed into the departure's size. It cross-fades into the
+ * real element and is removed on landing. Owned entirely by the morph runtime.
+ */
+export declare const MORPH_GHOST_ATTR = "data-flemo-morph-ghost";
+/**
+ * The SCREEN a flight is driving as a camera, stamped with the flight's id.
+ *
+ * A morph with `carry: "screen"` does not just move its element: it moves the
+ * whole screen the element is small on, by exactly the zoom that takes the
+ * element from one end of the flight to the other. Everything else on that
+ * screen is then dragged along and pushed out of frame, which is what makes a
+ * container transform read as one camera move rather than as one card
+ * escaping a grid that stayed behind.
+ *
+ * The id is in the value because two flights can overlap: the rule that
+ * matches is the one whose keyframes are still in the sheet.
+ */
+export declare const MORPH_CAMERA_ATTR = "data-flemo-morph-camera";
+/**
+ * The `<style>` tag the morph runtime writes its per-flight keyframes into. A
+ * morph's geometry only exists once two rects do, so unlike every other
+ * animation in the library its keyframes cannot be compiled at registration —
+ * they are inserted when a flight starts and dropped when it lands. Kept out of
+ * the compiled sheet so that sheet stays a pure function of the definitions.
+ */
+export declare const MORPH_SHEET_ATTR = "data-flemo-morph-sheet";
+/**
+ * The animation hold. `"true"` pauses this element's compiled animation (and
+ * its descendant parts) at the from-pose; `"park"` parks it at its
+ * destination instead; `"false"` releases. The release flip is the moment a
+ * flight's clock starts.
+ */
+export declare const ANIM_HOLD_ATTR = "data-flemo-anim-hold";
+/**
+ * The values ANIM_HOLD_ATTR takes. These are as much of the contract as the
+ * attribute name: the binding writes them, the compiled stylesheet generates
+ * one rule per parked form, and the engine's release watch compares against
+ * RELEASED. All four "held" forms pause the animation; they differ in where
+ * the held element sits while it waits.
+ */
+export declare const ANIM_HOLD: {
+    /** Paused at the keyframe's from-pose. */
+    readonly HELD: "true";
+    /** Released — the flight's clock starts on this write. */
+    readonly RELEASED: "false";
+    /** Pre-positioned at its DESTINATION, under an opaque cover. */
+    readonly PARK: "park";
+    /** The push-side mirror: the entering screen parked BELOW its cover. */
+    readonly PARK_UNDER: "park-under";
+    /** The promoted variant of PARK_UNDER, kept above so its raster survives. */
+    readonly PARK_OVER: "park-over";
+};
+/** The values the compiled hold rule must pause on. */
+export declare const ANIM_HOLD_PAUSED_VALUES: readonly ["true", "park", "park-under", "park-over"];
+/** Marks content parked by the in-flight arrival hold, pending its landing. */
+export declare const HELD_ARRIVAL_ATTR = "data-flemo-held-arrival";
+/** Marks an `<img>` whose reveal is held to the flight's rest. */
+export declare const IMAGE_HOLD_ATTR = "data-flemo-img-hold";
+/** The governed (touch WebKit) head kit. */
+export declare const GOVERNED_ATTR = "data-flemo-governed";
+/** The creep head: the head's end keyframe carries a hair of motion. */
+export declare const CREEP_ATTR = "data-flemo-creep";
+/** The desktop macOS Safari flat head, with its own lengths. */
+export declare const DESK_HEAD_ATTR = "data-flemo-desk-head";
+/** The compositor warm-up element. */
+export declare const WARM_ATTR = "data-flemo-warm";
+/** The warm-up's cadence video, when the desktop profile uses one. */
+export declare const WARM_VIDEO_ATTR = "data-flemo-warm-video";
+/** The one-shot GPU pipeline prewarm element. */
+export declare const GPU_PREWARM_ATTR = "data-flemo-gpu-prewarm";
+/**
+ * An offloaded `<img>`'s AUTHORED source, kept while `src` points at the
+ * decoded-to-scale replacement.
+ */
+export declare const OFFLOADED_SRC_ATTR = "data-flemo-image-src";
+/**
+ * The devtools panel's shadow host. Owned by @flemo/devtools, reserved here so
+ * the name cannot be reused and so the engine's own scans can skip it.
+ */
+export declare const DEVTOOLS_PANEL_ATTR = "data-flemo-devtools-panel";
+/** `[data-flemo-screen]` — presence selector for one attribute. */
+export declare const attrSelector: (attribute: string) => string;
+/** `[data-flemo-status="PUSHING"]` — value selector for one attribute. */
+export declare const attrValueSelector: (attribute: string, value: string) => string;
+/**
+ * Every attribute this library writes. Exported so a consumer, an e2e suite or
+ * a devtools build can assert against the shipped set instead of a hand-kept
+ * copy — the drift this module exists to end.
+ */
+export declare const FLEMO_ATTRIBUTES: readonly ["data-flemo-screen", "data-flemo-status", "data-flemo-active", "data-flemo-transition", "data-flemo-router", "data-flemo-skip-animation", "data-flemo-bar", "data-flemo-bar-active", "data-flemo-bar-status", "data-flemo-bar-riding", "data-flemo-bar-id", "data-flemo-bar-id-type", "data-flemo-bar-transition", "data-flemo-bar-spacer", "data-flemo-decorator", "data-flemo-decorator-name", "data-flemo-layer-host", "data-flemo-layer-owner", "data-flemo-layer-slot", "data-flemo-part-name", "data-flemo-morph", "data-flemo-morph-camera", "data-flemo-morph-ghost", "data-flemo-morph-layer", "data-flemo-morph-name", "data-flemo-morph-slot", "data-flemo-morph-stand-in", "data-flemo-morph-sheet", "data-flemo-anim-hold", "data-flemo-held-arrival", "data-flemo-img-hold", "data-flemo-governed", "data-flemo-creep", "data-flemo-desk-head", "data-flemo-warm", "data-flemo-warm-video", "data-flemo-gpu-prewarm", "data-flemo-image-src", "data-flemo-devtools-panel"];