@flemo/core 1.29.0 → 1.30.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__/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

@@ -30,6 +30,17 @@ export interface SwipeController {
     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,5 @@
-export declare const readLandingSnapFlag: () => boolean;
 export declare const readImageHoldFlag: () => "on" | "off" | null;
 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 +8,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,70 @@
+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;
+}
+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/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;

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/attributes.d.ts

@@ -0,0 +1,115 @@
+/** Shared prefix. Every attribute below starts with it. */
+export declare const FLEMO_ATTR_PREFIX = "data-flemo-";
+/** Marks a screen scope. Presence only — the value carries nothing. */
+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";
+/**
+ * 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";
+/**
+ * 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-part-name", "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"];

package/dist/index.d.ts

@@ -36,15 +36,19 @@ export { default as registerTransitionDefinitions } from './transition/registerT
 export { default as enteringInitialStyle, type EnteringInitialStyleInput } from './transition/enteringInitialStyle';
 export { default as animateInline, clearInlineAnimation } from './transition/animateInline';
 export { default as createTransitionEngine } from './core/engine/createTransitionEngine';
-export { governedCompiledActive } from './core/engine/governedCompiled';
-export { readSettleGateFlag, readDeferReleaseCommitFlag, readDesktopReleaseFlipFlag, readPrerasterFlag, readRestLayerPromotionFlag, readImageOffloadOverride } from './core/engine/diagnosticFlags';
+export { governedCompiledActive } from './platform/governedCompiled';
+export { startFlemoRuntime } from './runtime/flemoRuntime';
+export { resolvePlatformProfile, restLayerPromotionEnabled, type PlatformProfile, type PlatformProfileInput } from './platform/profile';
+export { FLEMO_ATTR_PREFIX, FLEMO_ATTRIBUTES, attrSelector, attrValueSelector, ANIM_HOLD, ANIM_HOLD_ATTR, ANIM_HOLD_PAUSED_VALUES, ACTIVE_ATTR, BAR_ACTIVE_ATTR, BAR_ATTR, BAR_ID_ATTR, BAR_ID_TYPE_ATTR, BAR_RIDING_ATTR, BAR_SPACER_ATTR, BAR_STATUS_ATTR, BAR_TRANSITION_ATTR, CREEP_ATTR, DECORATOR_ATTR, DECORATOR_NAME_ATTR, DESK_HEAD_ATTR, DEVTOOLS_PANEL_ATTR, GOVERNED_ATTR, GPU_PREWARM_ATTR, HELD_ARRIVAL_ATTR, IMAGE_HOLD_ATTR, PART_NAME_ATTR, ROUTER_ATTR, SCREEN_ATTR, STATUS_ATTR, TRANSITION_ATTR, WARM_ATTR, WARM_VIDEO_ATTR } from './dom/attributes';
+export { DIAGNOSTIC_FLAGS, RETIRED_DIAGNOSTIC_FLAGS, type DiagnosticFlag, type DiagnosticFlagKind, type RetiredDiagnosticFlag } from './core/engine/diagnosticRegistry';
+export { TRANSITIONAL_STATUS_VALUES } from './navigate/store';
 export { SKIP_ANIMATION_ATTR, type TransitionEngine, type TransitionEngineDeps, type ScreenLifecycleInput } from './core/engine/types';
 export { default as createSwipeController } from './core/engine/createSwipeController';
 export { type SwipeController, type SwipeControllerConfig, type SwipeControllerElements, type SharedBarPresenceLike } from './core/engine/createSwipeController';
 export { default as computeBarRiding, sharedBarsMatch, type BarRidingInput } from './screen/computeBarRiding';
 export { animHoldKey, scheduleAnimHoldRelease, createAnimHoldCoordinator, eagerlyDecodeImages, ANIM_HOLD_RELEASE_BACKSTOP_MS, type AnimHoldInput, type AnimHoldCoordinator } from './screen/animStartAnchor';
-export { detectBlinkEngine, isDesktopBlink, isLegacyAndroidBlink } from './core/engine/driverPolicy';
-export { steadySixtyPlayerEligible } from './core/engine/steadySixtyCadence';
+export { detectBlinkEngine, isDesktopBlink, isLegacyAndroidBlink } from './platform/engineProbes';
+export { steadySixtyDesktopProfile } from './platform/steadySixtyCadence';
 export { swipeSettleSeconds, MIN_SETTLE_SECONDS, type SwipeSettleInput } from './transition/swipeSettle';
 export { default as observeBarHeight } from './screen/observeBarHeight';
 export { default as observeViewportScrollHeight } from './screen/observeViewportScrollHeight';