@flemo/devtools 0.4.0 → 0.5.0

package/README.md

@@ -1,6 +1,8 @@
 # @flemo/devtools
 
-Zero-dependency flight recorder and optional visual panel for [flemo](https://flemo.dev) transitions. It observes existing `data-flemo-*` surfaces, `window.__flemoPlayerGaps`, leftover `flemo:*` keys, `MutationObserver`, `PerformanceObserver("longtask")`, and rAF. It imports neither `@flemo/core` nor `@flemo/react` and does not alter measured motion.
+Zero-dependency flight recorder, on-device readout and visual panel for [flemo](https://flemo.dev) transitions. It observes existing `data-flemo-*` surfaces, leftover `flemo:*` keys, CSS animation events, pointer events, `MutationObserver`, `PerformanceObserver("longtask")`, and rAF. It imports neither `@flemo/core` nor `@flemo/react` and does not alter measured motion.
+
+Everything in it is one probe module per question — pacing, motion, images, shared elements, one-frame events, landing residue — behind a small orchestrator. Adding a measurement means adding a probe.
 
 ## Quickstart
 
@@ -10,16 +12,19 @@ import { attachFlightRecorder } from "@flemo/devtools";
 const recorder = attachFlightRecorder({ log: true });
 // ...navigate...
 const report = recorder.report(); // JSON-serializable FlemoReport
+recorder.mark("A"); // label the flights that follow, for a comparison
 recorder.detach();
 ```
 
+Read `report.verdict` first. It is the recorder's own reading of the session in plain sentences, and it refuses to summarise data from a session that was not allowed to produce evidence.
+
 Unless `installGlobal: false` or the name is already owned, the recorder installs `window.flemo`:
 
 ```js
 copy(JSON.stringify(window.flemo.report(), null, 2));
 ```
 
-Use `/playground?devtools=on` to enable the playground recorder. `flemo:devtools` persists in `sessionStorage`; `?devtools=off` disables it. `attachFlightRecorder()` is idempotent while attached and returns an inert handle during SSR.
+Use `/playground?devtools=on` to enable the playground recorder and its surfaces. `flemo:devtools` persists in `sessionStorage`; `?devtools=off` disables it. Armed, the playground imports `@flemo/devtools/force`, and that is the part worth copying: a plain import of this package resolves to the inert production entry, so an instrument wired the ordinary way exists only in the builds whose numbers the judging protocol below says do not count. `attachFlightRecorder()` is idempotent while attached and returns an inert handle during SSR.
 
 ## Production safety
 
@@ -50,6 +55,24 @@ Install as a devDependency, but do not rely on dependency fields for bundle excl
 
 `@flemo/devtools/force` always loads the recorder. Import it dynamically behind an explicit opt-in only for staging or production-build E2E.
 
+## On-device readout
+
+```ts
+import { attachDevtoolsHud } from "@flemo/devtools";
+const hud = attachDevtoolsHud({ position: "top" });
+// hud.detach();
+```
+
+A phone has no console. The readout is one monospaced line, high contrast and readable in a photograph of the device:
+
+```
+POP 412ms  gap 33.4  drop 1  !2
+```
+
+Tap it for the detail block (frames, motion, holds, shared elements, what drove the navigation, and the flight's anomalies); long-press to cycle the comparison bucket. Options are `recorder`, `position` (`"top"` or `"bottom"`), `initialExpanded` (`false`) and `buckets` (`["A", "B"]`).
+
+It obeys the same rules the panel does: it repaints only between flights, its stylesheet carries no transition and no keyframe, and its host is a zero-sized fixed element that cannot join a flight.
+
 ## Visual panel
 
 ```ts
@@ -60,7 +83,7 @@ const panel = attachDevtoolsPanel();
 
 Consumers must opt in behind a development-only flag; flemo and its playground neither attach nor ship the panel automatically. The floating toggle shows flight count and an anomaly dot. The drawer shows flights, details, active overrides, and blind spots.
 
-Options are `recorder`, `initialOpen` (`false`), and `position` (`"bottom-right"` or `"bottom-left"`). Without `recorder`, the panel reuses this package's `window.flemo` or owns a new recorder. It is idempotent while mounted and inert without a DOM.
+Options are `recorder`, `initialOpen` (`false`), `position` (`"bottom-right"` or `"bottom-left"`) and `buckets` (`["A", "B"]`). Without `recorder`, the panel reuses this package's `window.flemo` or owns a new recorder. It is idempotent while mounted and inert without a DOM. The header leads with the verdict and every failed precondition, and carries an A/B button that arms the comparison buckets.
 
 The framework-free panel uses an open shadow root. Its fixed, zero-sized host has `data-flemo-devtools-panel`, no screen `data-flemo-*` attributes, and cannot join a flight. Drawer height persists as `flemo:devtools-panel-height` in `sessionStorage`.
 
@@ -71,19 +94,29 @@ The panel must not repaint during a flight:
 - Render only the toggle while closed.
 - Add no CSS transitions, keyframes, or live-dashboard behavior.
 
-## Report schema v2
+## Report schema v3
 
 Reports contain:
 
-- `generatedAt`, `version: "2"`, and `environment`: user agent and brands, engine, platform, touch count, DPR, screen and viewport sizes, visual viewport scale, idle `rafCadence`, reduced motion, emulation suspicion, and support for long tasks, element animations, and the player-gap mirror.
+- `generatedAt`, `version: "3"`, and `verdict`: the session read back in sentences, most important first.
+- `preconditions[]`: the observable half of the judging protocol, each `ok`, `violated` or `unknown` with the reasoning and its numbers. The traps a page cannot see stay `unknown` forever rather than being guessed at.
+- `environment`: user agent and brands, engine, platform, touch count, DPR, hardware concurrency, screen and viewport sizes, visual viewport scale, idle `rafCadence`, reduced motion, development-server globals, emulation suspicion, and what the recorder could observe (long tasks, element animations, and whether its own animation channel ever fired).
 - `overrides.active`: all `flemo:*` keys in both storages, unknown keys, keys cleared since attachment, and retired persisted keys marked inert. Since 2026-08-31, flemo reads no `flemo:*` engine key; `overrides.warnings` explains each residue key.
-- `flights[]`: identity, router, navigation kind, timestamps, duration, detected driver, participants, holds, frame and phase statistics, motion, images, player gaps, long tasks, landing checks, and stable anomaly strings.
+- `flights[]`: identity, router, bucket, navigation kind, timestamps, duration, detected driver, participants, holds, frame and phase statistics, motion, images, shared elements, tripwire hits, what drove it, long tasks, landing checks, and stable anomaly strings.
+- `comparison[]`: per-bucket medians, worst gaps, drops, anomalies and stalls; empty until `mark()` arms a label.
+- `previousSession`: flights carried across the last full page load, kept apart from the live ones.
 - Session `anomalies`, constant `blindSpots`, and constant `judgingProtocol`.
 
-`driver` is classified per flight as `compiled`, `player`, `mixed`, or `unknown`; never infer it from platform policy. `holds.releasedAtMs` is the last release relative to `t0`. Held work is intentionally absorbed, so frame gaps and long tasks are separated into held and released phases; held gaps do not raise anomalies.
+`driver` is classified per flight as `compiled`, `inline`, `mixed`, or `unknown`; never infer it from platform policy. flemo compiles every animation, so `inline` means something else is writing frames onto a participant. `holds.releasedAtMs` is the last release relative to `t0`. Held work is intentionally absorbed, so frame gaps and long tasks are separated into held and released phases; held gaps do not raise anomalies.
 
 `motion` measures pose advancement independently of frame arrival. It records sampled and stalled frames, `longestStallMs` with an anomaly threshold of 48 ms, `pausedAfterRelease`, and `holdReassertedAtMs`, using animation clocks or inline poses without a style flush. Stationary closing frames are tails, not mid-flight stalls.
 
+`morphs` answers the question a shared element cannot answer for itself. A morph that does not pair produces no error, no attribute and no animation, so the runtime writes the pairing key onto every registered morph (`data-flemo-morph-id`) and this section groups the ends: `pairable` had everything they needed, `flew` were stamped with a flight role, and `skipped` is the difference. It also reports duplicate keys inside one screen (a consumer mistake, not a runtime one) and the residue a landing left behind: roles, stand-ins, ghosts, elements stranded in a flight layer, and keyframe rules never dropped.
+
+`tripwires` are events the browser REPORTED rather than samples the recorder took: a cancelled flemo animation, an `animationend` carrying `elapsedTime` 0, a hold re-asserted after its release, a ghost cut inside a frame. A sampler cannot see a defect that lasts one frame; a listener cannot miss it.
+
+`input` records the trusted and synthetic pointer events around the flight and the pointer types among them. A session driven only by script never fires the gesture machinery, and a session driven only by a mouse never exercises the touch path.
+
 `images` records loading at start, additions, completions, held images, and `completedUnheld`; count per image so a held loading image cannot cancel an unheld completion. `longTasks` covers visible motion and `holdLongTasks` covers absorbed work. Landing is audited two rAFs after `COMPLETED` for residual inline transforms, off-viewport rest, statuses stuck over 10 seconds, and orphaned holds. Skip orphan auditing when another flight is running.
 
 ## Detected defects
@@ -98,13 +131,16 @@ Stable anomaly signatures include:
 - `screen resting at from-pose while COMPLETED+active`: blank-viewport landing.
 - `long task …ms overlapped the visible-motion start`: swallowed opening.
 - `transitional status stuck >10s`: the navigation queue remains locked.
+- `shared element(s) did not fly`: both ends were registered on two screens and neither took a flight role.
+- `morph element(s) still carry a flight role at rest`: a stranded participant that poisons the next pairing.
+- `tripwire zero-length-animation-end`: something landed on an animation that never ran.
 - `active force pin flemo:motion-driver-force=…`: diagnostic residue pins a driver.
 
 These defects have occurred with clean frame timing.
 
 ## Judging protocol and blind spots
 
-A valid verdict requires DevTools closed, no capture, real input, emulation off, and known display, refresh rate, HiDPI scaling, and Low Power Mode state. The page cannot verify these, so every report includes `judgingProtocol`. Open DevTools caused 2026-08 residual stutter; capture can suppress symptoms; synthetic dispatch bypasses `pointerdown` gesture behavior.
+A valid verdict requires DevTools closed, no capture, real input, emulation off, a production build, an idle machine, and known display, refresh rate, HiDPI scaling and Low Power Mode state. The ones a page CAN check are checked and appear in `preconditions` — emulation, display cadence, foreground, machine contention, build mode, real and touch input, reduced motion. The rest stay `unknown` there and are stated in `judgingProtocol`. Open DevTools caused 2026-08 residual stutter; capture can suppress symptoms; synthetic dispatch bypasses `pointerdown` gesture behavior.
 
 In-page tools cannot observe macOS Chrome present-pipeline pacing on 120 Hz ProMotion (Chromium issues 40062488/345275139), display hardware, compositor-internal present skips, or the post-scale DevTools emulation surface. These remain in `blindSpots`. If a correctly judged report is clean but jank is visible, investigate those layers instead of adding in-page instrumentation.
 
@@ -114,12 +150,14 @@ In-page tools cannot observe macOS Chrome present-pipeline pacing on 120 Hz ProM
 2. Run `copy(JSON.stringify(window.flemo.report(), null, 2))`.
 3. Paste the JSON into the issue or conversation.
 
-Read `overrides.warnings`, `environment.emulationSuspected`, `rafCadence`, each flight's `driver` and `anomalies`, then `blindSpots`.
+Read `verdict`, then `preconditions`, then each flight's `anomalies`, then `blindSpots`. A number from a session with a violated precondition is not evidence.
 
 ## API
 
-- `attachFlightRecorder(options?)` returns `{ report(), detach() }`; options: `maxFlights` (50), `log` (`false`), `installGlobal` (`true`).
-- `attachDevtoolsPanel(options?)` returns `{ detach() }`; options: `recorder`, `initialOpen` (`false`), `position` (`"bottom-right"`).
-- Pure helpers: `deriveFlightAnomalies`, `deriveReportAnomalies`, `deriveOverrideWarnings`, `classifyDriver`, `computeFrameStats`, `computePlayerGapStats`, `parseTranslateX`, `kindFromStatus`.
-- Constants and registries: `BLIND_SPOTS`, `FLAG_REGISTRY`, `LONG_GAP_MS`, `STUCK_STATUS_MS`, `REPORT_SCHEMA_VERSION`.
-- Environment probes: `captureEnvironment`, `detectEngine`, `isEmulationSuspected`, `sampleRafCadence`.
+- `attachFlightRecorder(options?)` returns `{ report(), mark(), detach() }`; options: `maxFlights` (50), `log` (`false`), `installGlobal` (`true`), `persist` (`true`).
+- `attachDevtoolsHud(options?)` returns `{ detach() }`; options: `recorder`, `position` (`"top"`), `initialExpanded` (`false`), `buckets`.
+- `attachDevtoolsPanel(options?)` returns `{ detach() }`; options: `recorder`, `initialOpen` (`false`), `position` (`"bottom-right"`), `buckets`.
+- Pure helpers: `deriveFlightAnomalies`, `deriveReportAnomalies`, `deriveOverrideWarnings`, `derivePreconditions`, `deriveVerdict`, `summariseBuckets`, `classifyDriver`, `computeFrameStats`, `parseTranslateX`, `kindFromStatus`.
+- Constants and registries: `BLIND_SPOTS`, `JUDGING_PROTOCOL`, `FLAG_REGISTRY`, `LONG_GAP_MS`, `STALL_MS`, `STUCK_STATUS_MS`, `REPORT_SCHEMA_VERSION`.
+- Environment probes: `captureEnvironment`, `detectEngine`, `developmentHints`, `isEmulationSuspected`, `sampleRafCadence`.
+- Trace storage: `loadTrace`, `saveTrace`, `clearTrace`, `TRACE_KEY`.

package/dist/__tests__/buckets.test.d.ts

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

package/dist/__tests__/hud.test.d.ts

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

package/dist/__tests__/imageProbe.test.d.ts

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

package/dist/__tests__/morphProbe.test.d.ts

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

package/dist/__tests__/persistence.test.d.ts

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

package/dist/__tests__/preconditions.test.d.ts

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

package/dist/__tests__/recorder.session.test.d.ts

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

package/dist/__tests__/tripwires.test.d.ts

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

package/dist/__tests__/verdict.test.d.ts

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

package/dist/anomalies.d.ts

@@ -1,4 +1,4 @@
-import { FlightDriver, FrameSampleStats, ImageActivity, LandingAudit, LongTaskSpan, MotionProgress, PlayerGapStats } from './types';
+import { FlightDriver, FrameSampleStats, ImageActivity, LandingAudit, LongTaskSpan, MorphActivity, MotionProgress, TripwireHit } from './types';
 /** A gap at/over this is at least one missed 60Hz frame (mirrors core). */
 export declare const LONG_GAP_MS = 30;
 /** A transitional status older than this is a stuck flight. */
@@ -19,7 +19,6 @@ export interface FlightAnomalyInput {
     t1Ms: number;
     driver: FlightDriver;
     frameSamples: FrameSampleStats;
-    playerGaps: PlayerGapStats | null;
     /** Long tasks intersecting the RELEASED (visible-motion) phase. */
     longTasks: LongTaskSpan[];
     /** Long tasks fully absorbed by the hold phase (informational only). */
@@ -29,6 +28,8 @@ export interface FlightAnomalyInput {
     landing: LandingAudit;
     motion: MotionProgress;
     images: ImageActivity;
+    morphs: MorphActivity;
+    tripwires: TripwireHit[];
 }
 export declare const deriveFlightAnomalies: (input: FlightAnomalyInput) => string[];
 export interface ReportAnomalyInput {

package/dist/buckets.d.ts

@@ -0,0 +1,2 @@
+import { BucketSummary, FlightRecord } from './types';
+export declare const summariseBuckets: (flights: readonly FlightRecord[]) => BucketSummary[];

package/dist/domProtocol.d.ts

@@ -10,6 +10,28 @@ export declare const DECORATOR_ATTR = "data-flemo-decorator";
 export declare const BAR_ATTR = "data-flemo-bar";
 export declare const BAR_STATUS_ATTR = "data-flemo-bar-status";
 export declare const BAR_RIDING_ATTR = "data-flemo-bar-riding";
+/** A registered morph. The value is the role while it flies: "enter"/"exit". */
+export declare const MORPH_ATTR = "data-flemo-morph";
+/** The pairing key (the binding's `layoutId`), so the two ends can be grouped. */
+export declare const MORPH_ID_ATTR = "data-flemo-morph-id";
+/** The registered morph-transition name, absent/empty meaning the default preset. */
+export declare const MORPH_NAME_ATTR = "data-flemo-morph-name";
+/** The per-Router flight layer a staged morph is lifted into. */
+export declare const MORPH_LAYER_ATTR = "data-flemo-morph-layer";
+/** The copy left in the layout holding the flying element's place. */
+export declare const MORPH_STAND_IN_ATTR = "data-flemo-morph-stand-in";
+/** The copy of the replaced element carried inside the flight. */
+export declare const MORPH_GHOST_ATTR = "data-flemo-morph-ghost";
+/** A screen being driven as a camera by a morph, stamped with the flight id. */
+export declare const MORPH_CAMERA_ATTR = "data-flemo-morph-camera";
+/** The `<style>` element a morph writes its per-flight keyframes into. */
+export declare const MORPH_SHEET_ATTR = "data-flemo-morph-sheet";
+/** The values MORPH_ATTR takes while an element is in the air. */
+export declare const MORPH_ROLES: readonly ["enter", "exit"];
+/** Every flemo keyframe name starts with this. */
+export declare const FLEMO_ANIMATION_PREFIX = "flemo-";
+/** A morph's per-flight keyframes are namespaced again under this. */
+export declare const MORPH_ANIMATION_PREFIX = "flemo-morph-";
 /** This package's own marker — core reserves the name but never writes it. */
 export declare const DEVTOOLS_PANEL_ATTR = "data-flemo-devtools-panel";
 /** The statuses during which a flight is moving. */

package/dist/environment.d.ts

@@ -25,7 +25,10 @@ export declare const sampleRafCadence: (frames?: number) => Promise<{
     medianGapMs: number | null;
     sampleCount: number;
 }>;
+export declare const developmentHints: () => string[];
 export declare const captureEnvironment: (rafCadence: {
     medianGapMs: number | null;
     sampleCount: number;
-}) => EnvironmentFingerprint;
+}, 
+/** Whether the tripwires have seen a flemo animation event (see types). */
+animationEvents?: boolean) => EnvironmentFingerprint;

package/dist/flight.d.ts

@@ -0,0 +1,40 @@
+import { FrameProbeState } from './frameProbe';
+import { ImageProbeState } from './imageProbe';
+import { MorphProbeState } from './morphProbe';
+import { FlightKind, FlightRecord, TripwireHit } from './types';
+/**
+ * The mutable state of one flight while it is in the air.
+ *
+ * Composed of one field per probe rather than a flat bag: every probe owns its
+ * own state shape, the orchestrator owns only the lifecycle fields, and adding
+ * a measurement means adding a field and a module beside it rather than
+ * growing a closure nobody can hold in their head.
+ */
+export interface ActiveFlight {
+    id: string;
+    kind: FlightKind;
+    routerId?: string;
+    /** The comparison bucket armed when this flight opened, if any. */
+    bucket: string | null;
+    t0Ms: number;
+    t0Iso: string;
+    elements: Element[];
+    participants: FlightRecord["participants"];
+    holdKind: string | null;
+    holdReleasedAtMs: number | null;
+    /**
+     * When the first flemo keyframe actually STARTED, relative to t0.
+     *
+     * The status flip and the first moving frame are not the same moment: a
+     * commit, a style recalculation and a present sit between them, and on a
+     * phone that gap has measured 90-165ms while every other number stayed
+     * clean. It is reported rather than judged, because the gap is React's and
+     * the browser's, not the transition's.
+     */
+    firstAnimationAtMs: number | null;
+    frames: FrameProbeState;
+    images: ImageProbeState;
+    morphs: MorphProbeState;
+    tripwires: TripwireHit[];
+    rafId: number | null;
+}

package/dist/frameProbe.d.ts

@@ -0,0 +1,53 @@
+import { MotionProgress } from './types';
+/** Driver evidence gathered by the rAF sampler during a flight. */
+export interface DriverEvidence {
+    /** A running CSSAnimation named flemo-* was observed on a participant. */
+    compiledAnimation: boolean;
+    /** A participant carried inline `animation` suppression. */
+    inlineSuppression: boolean;
+    /** Inline transform/opacity advanced between sampled frames. */
+    inlineAdvance: boolean;
+}
+/** Everything the frame probe accumulates for one flight. */
+export interface FrameProbeState {
+    /** Frame gaps while any participant still carried an active anim-hold. */
+    heldGaps: number[];
+    /** Frame gaps after every hold released (the visible-motion phase). */
+    releasedGaps: number[];
+    lastFrameAt: number | null;
+    evidence: DriverEvidence;
+    lastPose: Map<Element, string>;
+    /** Cached compiled animations, so the clock read never re-queries per frame. */
+    clocks: Map<Element, Animation>;
+    lastClock: Map<Element, number>;
+    releasedFrames: number;
+    stalledFrames: number;
+    tailFrames: number;
+    stallRunMs: number;
+    longestStallMs: number;
+    pausedAfterRelease: boolean;
+    holdReassertedAtMs: number | null;
+}
+export declare const createFrameProbeState: () => FrameProbeState;
+/**
+ * A hold is active while ANY participating element still carries an active
+ * `data-flemo-anim-hold` value; the flight is "released" once every one of
+ * them reads "false" (or drops the attribute). The engine deliberately absorbs
+ * heavy commits INTO the hold — the screen is posed, not moving — so gaps and
+ * long tasks are segmented on this boundary.
+ */
+export declare const holdActive: (elements: readonly Element[]) => boolean;
+/**
+ * Did this frame MOVE? Read from the cheapest honest source per tier: a
+ * compiled flight's own animation clock (getAnimations, no style flush) and an
+ * inline-driven flight's pose (already in the style attribute). A frame where
+ * neither moved is a stall — the signature that timing metrics miss.
+ */
+export declare const sampleProgress: (state: FrameProbeState, elements: readonly Element[], frameGapMs: number) => void;
+export declare const sampleDriverEvidence: (state: FrameProbeState, elements: readonly Element[]) => void;
+/**
+ * Everything the frame probe knows about the motion. `firstAnimationAtMs` is
+ * deliberately NOT here: it comes from the browser's own `animationstart`
+ * event, which is a tripwire, and the orchestrator joins the two.
+ */
+export declare const motionProgress: (state: FrameProbeState) => Omit<MotionProgress, "firstAnimationAtMs">;

package/dist/hud.d.ts

@@ -0,0 +1,18 @@
+import { FlightRecorderHandle } from './types';
+export interface DevtoolsHudOptions {
+    /** Recorder to read. Defaults to this package's `window.flemo`, else its own. */
+    recorder?: FlightRecorderHandle;
+    /** Where the strip sits. Default "top". */
+    position?: "top" | "bottom";
+    /** Start expanded. Default false (the one-line summary). */
+    initialExpanded?: boolean;
+    /** Labels the long-press cycles through. Default ["A", "B"]. */
+    buckets?: string[];
+}
+export interface DevtoolsHudHandle {
+    detach: () => void;
+}
+/**
+ * Mount the on-device readout. Idempotent while mounted; inert without a DOM.
+ */
+export declare const attachDevtoolsHud: (options?: DevtoolsHudOptions) => DevtoolsHudHandle;

package/dist/imageProbe.d.ts

@@ -0,0 +1,23 @@
+import { ImageActivity } from './types';
+export interface ImageProbeState {
+    /** Images being tracked for this flight: loading at t0, plus arrivals. */
+    tracked: Set<HTMLImageElement>;
+    loadingAtStart: number;
+    addedDuringFlight: number;
+    held: Set<Element>;
+}
+export declare const createImageProbeState: (screens: readonly Element[]) => ImageProbeState;
+/**
+ * Images that arrive DURING the flight — a data commit landing mid-navigation,
+ * which is the case core's image hold watches for with its own observer.
+ * Without this the probe would only ever see the screens as they looked at t0.
+ */
+export declare const trackAddedImages: (state: ImageProbeState, elements: readonly Element[], added: NodeList) => void;
+/** One query per flight, on the first moving frame: which images the engine parked. */
+export declare const snapshotHeldImages: (state: ImageProbeState, elements: readonly Element[]) => void;
+/**
+ * Per-image accounting. Counting completions and holds separately and
+ * subtracting would cancel a held-but-still-loading image against an unheld
+ * completed one, hiding the exact regression this exists to catch.
+ */
+export declare const imageActivity: (state: ImageProbeState) => ImageActivity;

package/dist/index.d.ts

@@ -1,13 +1,22 @@
 export { attachFlightRecorder, REPORT_SCHEMA_VERSION } from './recorder';
 export type { FlemoGlobal } from './recorder';
-export { deriveFlightAnomalies, deriveReportAnomalies, LONG_GAP_MS, STUCK_STATUS_MS, OPENING_WINDOW_LEAD_MS, OPENING_WINDOW_TAIL_MS, MID_FLIGHT_TASK_MS } from './anomalies';
+export { deriveFlightAnomalies, deriveReportAnomalies, LONG_GAP_MS, STALL_MS, STUCK_STATUS_MS, OPENING_WINDOW_LEAD_MS, OPENING_WINDOW_TAIL_MS, MID_FLIGHT_TASK_MS } from './anomalies';
 export type { FlightAnomalyInput, ReportAnomalyInput } from './anomalies';
 export { BLIND_SPOTS } from './blindSpots';
+export { JUDGING_PROTOCOL } from './judging';
+export { summariseBuckets } from './buckets';
 export { attachDevtoolsPanel } from './panel';
 export type { DevtoolsPanelHandle, DevtoolsPanelOptions } from './panel';
-export { captureEnvironment, detectEngine, isEmulationSuspected, sampleRafCadence } from './environment';
+export { attachDevtoolsHud } from './hud';
+export type { DevtoolsHudHandle, DevtoolsHudOptions } from './hud';
+export { captureEnvironment, detectEngine, developmentHints, isEmulationSuspected, sampleRafCadence } from './environment';
+export { derivePreconditions } from './preconditions';
+export type { PreconditionInput } from './preconditions';
+export { deriveVerdict } from './verdict';
+export type { VerdictInput } from './verdict';
+export { clearTrace, loadTrace, saveTrace, TRACE_KEY } from './persistence';
 export { CORE_FLAGS, deriveOverrideWarnings, DEVTOOLS_OWNED_FLAGS, FLAG_REGISTRY, PANEL_HEIGHT_KEY, RETIRED_FLAGS, RETIRED_MARKER, snapshotOverrides } from './overrides';
 export type { FlagClass, FlagDescriptor, RetiredFlag } from './overrides';
-export { classifyDriver, computeFrameStats, computePhaseStats, computePlayerGapStats, kindFromStatus, parseTranslateX } from './sampling';
-export type { DriverEvidence } from './sampling';
-export type { EnvironmentFingerprint, FlemoReport, FlightDriver, FlightHolds, FlightKind, FlightParticipants, FlightRecord, FlightRecorderHandle, FlightRecorderOptions, FlightTimestamp, FramePhaseStats, FrameSampleStats, LandingAudit, LongTaskSpan, ObservationCapabilities, OverridesSection, PlayerGapStats, UaBrand } from './types';
+export { classifyDriver, computeFrameStats, computePhaseStats, kindFromStatus, parseTranslateX } from './sampling';
+export type { DriverEvidence } from './frameProbe';
+export type { BucketSummary, EnvironmentFingerprint, FlemoReport, FlightDriver, FlightHolds, FlightKind, FlightParticipants, FlightRecord, FlightRecorderHandle, FlightRecorderOptions, FlightTimestamp, FramePhaseStats, FrameSampleStats, ImageActivity, InputEvidence, LandingAudit, LongTaskSpan, MorphActivity, MotionProgress, ObservationCapabilities, OverridesSection, Precondition, PreconditionStatus, PreviousSession, TripwireHit, UaBrand } from './types';