@flemo/devtools 0.1.0

package/dist/judging.d.ts

@@ -0,0 +1 @@
+export declare const JUDGING_PROTOCOL: readonly string[];

package/dist/overrides.d.ts

@@ -0,0 +1,22 @@
+export type FlagClass = "production-state" | "production-default-with-override" | "opt-in-diagnostic";
+export interface FlagDescriptor {
+    key: string;
+    storage: "session" | "local";
+    kind: FlagClass;
+    description: string;
+}
+export declare const FLAG_REGISTRY: readonly FlagDescriptor[];
+/** Marker suffix for the legacy-location residue of the force pin. */
+export declare const LEGACY_LOCAL_PIN_KEY = "flemo:motion-driver-force (localStorage \u2014 legacy location)";
+/**
+ * Snapshot every `flemo:*` key currently set, from both storages: the
+ * registry keys from their native storage, the legacy localStorage location
+ * of the force pin, and any UNKNOWN `flemo:`-prefixed key either storage
+ * holds (a future flag, or hand-set residue).
+ */
+export declare const snapshotOverrides: () => Record<string, string>;
+/**
+ * Derive prominent warnings from an override snapshot. Pure — testable with
+ * a plain record and reusable on merged attach+report snapshots.
+ */
+export declare const deriveOverrideWarnings: (active: Record<string, string>) => string[];

package/dist/panel/dom.d.ts

@@ -0,0 +1,7 @@
+export declare const el: <K extends keyof HTMLElementTagNameMap>(tag: K, className?: string, text?: string) => HTMLElementTagNameMap[K];
+export declare const svgEl: (tag: string, attributes: Record<string, string>) => SVGElement;
+/** Empty a container without innerHTML (which would re-parse markup). */
+export declare const clear: (node: Element) => void;
+/** Set textContent only when it actually changed — the panel's whole job is
+ *  to not churn the DOM more than necessary. */
+export declare const setText: (node: Element, value: string) => void;

package/dist/panel/format.d.ts

@@ -0,0 +1,29 @@
+import { FlemoReport, FlightRecord, FrameSampleStats } from '../types';
+/** What a missing/unreadable value renders as. Never blank — an empty cell
+ *  reads as "zero", a dash reads as "the recorder did not see this". */
+export declare const DASH = "\u2014";
+export declare const formatText: (value: string | number | null | undefined) => string;
+/** Whole milliseconds — flight durations, long-task spans. */
+export declare const formatMs: (value: number | null | undefined) => string;
+/** One decimal — frame gaps and rAF cadence, where 16.7 vs 17 matters. */
+export declare const formatGapMs: (value: number | null | undefined) => string;
+export declare const formatCount: (value: number | null | undefined) => string;
+export declare const formatBool: (value: boolean | null | undefined) => string;
+/** Header line: the four facts that decide whether the rest is trustworthy —
+ *  which engine, at what density, in what viewport, at what display cadence. */
+export declare const environmentSummary: (report: FlemoReport | null) => string;
+/** Cheap change key for the flight LIST. Rebuilding rows costs nothing when
+ *  it is actually needed and everything when it is not, so the list is only
+ *  rebuilt when one of these visible values moved. */
+export declare const flightListSignature: (flights: readonly FlightRecord[], selectedId: string | null) => string;
+/**
+ * Per-frame gap series for the released phase, when the record carries one.
+ *
+ * The shipped FramePhaseStats is aggregate-only (count / median / max /
+ * over30Count), so there is usually nothing to draw and the sparkline is
+ * omitted silently. If a future recorder field supplies a numeric series this
+ * picks it up without a panel change — but the panel never INVENTS a series
+ * it cannot see (a fabricated trace is exactly the kind of artifact that
+ * sends an investigation down a blind alley).
+ */
+export declare const releasedGapSeries: (frameSamples: FrameSampleStats | undefined) => number[] | null;

package/dist/panel/index.d.ts

@@ -0,0 +1,25 @@
+import { FlightRecorderHandle } from '../types';
+export interface DevtoolsPanelOptions {
+    /**
+     * Recorder to read. Defaults to this package's `window.flemo` when one is
+     * installed, otherwise the panel attaches its own and detaches it with
+     * itself.
+     */
+    recorder?: FlightRecorderHandle;
+    /** Start with the panel expanded. Default false (toggle button only). */
+    initialOpen?: boolean;
+    /** Corner for the toggle button. Default "bottom-right". */
+    position?: "bottom-right" | "bottom-left";
+}
+export interface DevtoolsPanelHandle {
+    detach: () => void;
+}
+/**
+ * Mount the devtools panel: a floating toggle plus a bottom drawer with the
+ * flight list and per-flight detail, rendered into a shadow root so no
+ * consumer CSS reaches in and none of ours reaches out.
+ *
+ * Idempotent — while a panel is mounted, further calls return the same
+ * handle. In a non-DOM environment it returns an inert handle.
+ */
+export declare const attachDevtoolsPanel: (options?: DevtoolsPanelOptions) => DevtoolsPanelHandle;

package/dist/panel/styles.d.ts

@@ -0,0 +1 @@
+export declare const PANEL_CSS = "\n:host {\n  all: initial;\n  color-scheme: dark;\n}\n* { box-sizing: border-box; }\n.root {\n  --bg: #14161a;\n  --bg-soft: #1b1e24;\n  --line: #2b3038;\n  --fg: #e6e9ef;\n  --fg-dim: #99a1b0;\n  --accent: #7cc4ff;\n  --warn: #ffb454;\n  --bad: #ff6b6b;\n  font: 12px/1.45 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;\n  color: var(--fg);\n}\n@media (prefers-color-scheme: light) {\n  .root {\n    --bg: #ffffff;\n    --bg-soft: #f4f6f9;\n    --line: #dde1e8;\n    --fg: #1a1d22;\n    --fg-dim: #5c6472;\n    --accent: #0b6bcb;\n    --warn: #a35a00;\n    --bad: #c2261f;\n  }\n}\n.toggle {\n  position: fixed;\n  bottom: 12px;\n  z-index: 2147483000;\n  display: flex;\n  align-items: center;\n  gap: 6px;\n  margin: 0;\n  padding: 6px 10px;\n  border: 1px solid var(--line);\n  border-radius: 999px;\n  background: var(--bg);\n  color: var(--fg);\n  font: inherit;\n  cursor: pointer;\n}\n.toggle:hover { background: var(--bg-soft); }\n.toggle[data-corner=\"bottom-right\"] { right: 12px; }\n.toggle[data-corner=\"bottom-left\"] { left: 12px; }\n.mark { font-weight: 700; letter-spacing: 0.04em; }\n.count {\n  padding: 0 6px;\n  border-radius: 999px;\n  background: var(--bg-soft);\n  color: var(--fg-dim);\n}\n.dot {\n  width: 7px;\n  height: 7px;\n  border-radius: 50%;\n  background: var(--bad);\n}\n.dot[hidden] { display: none; }\n.panel {\n  position: fixed;\n  left: 0;\n  right: 0;\n  bottom: 0;\n  z-index: 2147482999;\n  display: flex;\n  flex-direction: column;\n  max-width: 100%;\n  border-top: 1px solid var(--line);\n  background: var(--bg);\n  overflow: hidden;\n}\n.panel[hidden] { display: none; }\n.grip {\n  flex: 0 0 6px;\n  height: 6px;\n  background: var(--line);\n  cursor: ns-resize;\n  touch-action: none;\n}\n.head {\n  display: flex;\n  flex-wrap: wrap;\n  align-items: center;\n  gap: 8px;\n  padding: 8px 10px;\n  border-bottom: 1px solid var(--line);\n}\n.env { color: var(--fg-dim); }\n.spacer { flex: 1 1 auto; }\n.act {\n  padding: 4px 8px;\n  border: 1px solid var(--line);\n  border-radius: 4px;\n  background: var(--bg-soft);\n  color: var(--fg);\n  font: inherit;\n  cursor: pointer;\n}\n.chips {\n  display: flex;\n  flex-wrap: wrap;\n  gap: 6px;\n  flex: 1 1 100%;\n}\n.chips:empty { display: none; }\n.chip {\n  padding: 2px 8px;\n  border: 1px solid var(--line);\n  border-radius: 999px;\n  background: var(--bg-soft);\n  color: var(--fg-dim);\n  max-width: 100%;\n  overflow-wrap: anywhere;\n}\n.chip.warn { border-color: var(--warn); color: var(--warn); }\n.chip.bad { border-color: var(--bad); color: var(--bad); }\n.body {\n  display: flex;\n  flex: 1 1 auto;\n  min-height: 0;\n}\n.list {\n  flex: 0 0 40%;\n  max-width: 340px;\n  min-width: 180px;\n  overflow: auto;\n  border-right: 1px solid var(--line);\n}\n.row {\n  display: flex;\n  align-items: center;\n  gap: 8px;\n  width: 100%;\n  padding: 6px 10px;\n  border: 0;\n  border-bottom: 1px solid var(--line);\n  background: none;\n  color: var(--fg);\n  font: inherit;\n  text-align: left;\n  cursor: pointer;\n}\n.row[aria-selected=\"true\"] { background: var(--bg-soft); }\n.row .kind { font-weight: 700; }\n.row .driver { color: var(--accent); }\n.row .dur, .row .screens { color: var(--fg-dim); }\n.row .n {\n  margin-left: auto;\n  padding: 0 6px;\n  border-radius: 999px;\n  background: var(--bg-soft);\n  color: var(--fg-dim);\n}\n.row .n.bad { background: var(--bad); color: #fff; }\n.detail { flex: 1 1 auto; overflow: auto; padding: 8px 10px; }\n.section { margin: 0 0 10px; }\n.section > h2 {\n  margin: 0 0 4px;\n  font: inherit;\n  font-weight: 700;\n  color: var(--fg-dim);\n  text-transform: uppercase;\n  letter-spacing: 0.06em;\n}\n.kv { display: flex; gap: 8px; }\n.kv > .k { flex: 0 0 34%; max-width: 180px; color: var(--fg-dim); }\n.kv > .v { flex: 1 1 auto; overflow-wrap: anywhere; }\n/* A value that IS the finding \u2014 a stall, a re-asserted hold, an orphan. */\n.kv > .v.bad { color: var(--bad); }\n.li { overflow-wrap: anywhere; }\n.li.bad { color: var(--bad); }\n.dim { color: var(--fg-dim); }\n.spark { display: block; width: 100%; height: 28px; }\n.foot { border-top: 1px solid var(--line); padding: 6px 10px; color: var(--fg-dim); }\n.foot summary { cursor: pointer; }\n.foot .li { margin-top: 4px; }\n";

package/dist/panel/view.d.ts

@@ -0,0 +1,12 @@
+import { FlemoReport, FlightRecord } from '../types';
+/**
+ * Header chips: override warnings and session-level anomalies first (they
+ * decide whether the rest of the report describes stock behavior at all),
+ * then the raw active overrides. Values come from storage the user can edit,
+ * so they land via textContent like everything else.
+ */
+export declare const renderChips: (node: Element, report: FlemoReport | null) => void;
+/** Newest first — the flight you just ran is the one you came to look at. */
+export declare const renderFlightList: (node: Element, flights: readonly FlightRecord[], selectedId: string | null, onSelect: (id: string) => void) => void;
+export declare const renderFlightDetail: (node: Element, flight: FlightRecord | null) => void;
+export declare const renderBlindSpots: (node: Element, blindSpots: readonly string[] | undefined) => void;

package/dist/recorder.d.ts

@@ -0,0 +1,17 @@
+import { FlemoReport, FlightRecord, FlightRecorderHandle, FlightRecorderOptions } from './types';
+export declare const REPORT_SCHEMA_VERSION = "2";
+/** The API installed at window.flemo (guarded — see attachFlightRecorder). */
+export interface FlemoGlobal {
+    /** Marker distinguishing this recorder's global from foreign occupants. */
+    __flemoDevtools: true;
+    report: () => FlemoReport;
+    flights: () => FlightRecord[];
+    detach: () => void;
+}
+/**
+ * Attach the flight recorder. Idempotent: while a recorder is attached,
+ * further calls return the SAME handle (their options are ignored). In a
+ * non-DOM environment it returns an inert handle whose report carries only
+ * the schema constants.
+ */
+export declare const attachFlightRecorder: (options?: FlightRecorderOptions) => FlightRecorderHandle;

package/dist/sampling.d.ts

@@ -0,0 +1,26 @@
+import { FlightDriver, FlightKind, FramePhaseStats, FrameSampleStats, PlayerGapStats } from './types';
+export declare const computePhaseStats: (gaps: readonly number[]) => FramePhaseStats;
+/**
+ * Combined frame stats: `heldGaps` are frames sampled while any transitional
+ * screen still carried an active anim-hold; `releasedGaps` are frames after
+ * every hold released. The hold phase precedes release, so the overall
+ * ordered gap list is their concatenation.
+ */
+export declare const computeFrameStats: (heldGaps: readonly number[], releasedGaps?: readonly number[]) => FrameSampleStats;
+export declare const computePlayerGapStats: (gaps: readonly number[]) => PlayerGapStats | null;
+/** 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 (player stake). */
+    playerSuppression: boolean;
+    /** Inline transform/opacity advanced between sampled frames. */
+    playerAdvance: boolean;
+}
+export declare const classifyDriver: (evidence: DriverEvidence) => FlightDriver;
+export declare const kindFromStatus: (status: string) => FlightKind | null;
+/**
+ * Horizontal translation of a computed `transform` matrix, in px. Returns
+ * null for "none"/"" or unparseable values.
+ */
+export declare const parseTranslateX: (transform: string) => number | null;

package/dist/types.d.ts

@@ -0,0 +1,280 @@
+/** How a flight's motion was driven, judged from DOM signatures alone. */
+export type FlightDriver = "player" | "compiled" | "mixed" | "unknown";
+/** Navigation kind, from the transitional `data-flemo-status` value. */
+export type FlightKind = "PUSH" | "POP" | "REPLACE";
+/** A single moment on both clocks: monotonic performance.now + wall clock. */
+export interface FlightTimestamp {
+    /** performance.now() milliseconds (same clock as longTasks/frame gaps). */
+    ms: number;
+    /** ISO-8601 wall-clock time, for correlating with external logs. */
+    iso: string;
+}
+/** Elements that carried transitional flemo attributes during the flight. */
+export interface FlightParticipants {
+    screens: number;
+    bars: number;
+    decorators: number;
+    parts: number;
+}
+/** The animation-hold observed on the flight (data-flemo-anim-hold). */
+export interface FlightHolds {
+    /** "park-under" | "park-over" | "park" | "true", or null if no hold ran. */
+    kind: string | null;
+    /**
+     * Milliseconds after t0 at which the LAST hold released (every
+     * transitional screen's data-flemo-anim-hold at "false"). Null when no
+     * hold ran — or when a hold never released (then the whole flight is the
+     * held phase).
+     */
+    releasedAtMs: number | null;
+}
+/** Frame-gap stats for one phase of a flight (held vs released). */
+export interface FramePhaseStats {
+    count: number;
+    medianGapMs: number;
+    maxGapMs: number;
+    over30Count: number;
+}
+/**
+ * Stats over the recorder's own rAF-observed frame gaps during the flight,
+ * segmented by the anim-hold phase. The engine deliberately absorbs heavy
+ * commits INTO the hold (the screen is posed, not moving), so a gap during
+ * `held` is the engine working as designed — only `released` gaps are
+ * user-visible jank, and only they drive anomaly rules.
+ */
+export interface FrameSampleStats {
+    count: number;
+    medianGapMs: number;
+    maxGapMs: number;
+    /** Every observed gap >= 30ms (a missed 60Hz frame), in order. */
+    longGaps: number[];
+    /** Frames while any transitional screen still carried an active hold. */
+    held: FramePhaseStats;
+    /** Frames after every hold released — the phase the eye watches. */
+    released: FramePhaseStats;
+}
+/** Stats over the transition player's own gap mirror (__flemoPlayerGaps). */
+export interface PlayerGapStats {
+    maxMs: number;
+    over30Count: number;
+}
+/** A PerformanceObserver("longtask") entry overlapping the flight window. */
+export interface LongTaskSpan {
+    startMs: number;
+    durationMs: number;
+}
+/**
+ * Whether the motion actually MOVED, as opposed to whether frames arrived.
+ *
+ * Frame timing and pose progress are different questions, and the 2026-08
+ * campaign turned on the difference: a hold attribute re-asserted over a
+ * running flight paused the animation for ~250ms while rAF kept ticking at a
+ * perfect 16.7ms — every timing metric clean, the screen frozen. The decisive
+ * instrument was a pose encoder, so the recorder carries one: for a compiled
+ * flight it reads the animation's own clock, for a player flight the inline
+ * pose it writes. Neither forces a style flush.
+ */
+export interface MotionProgress {
+    /** Frames sampled during the RELEASED (visible-motion) phase. */
+    sampledFrames: number;
+    /** Released frames where neither the clock nor the pose moved. */
+    stalledFrames: number;
+    /** Longest unbroken run of stalled released frames, in ms. */
+    longestStallMs: number;
+    /** A compiled animation reported playState "paused" after its release. */
+    pausedAfterRelease: boolean;
+    /** Offset from t0 at which a hold was re-asserted AFTER the release. */
+    holdReassertedAtMs: number | null;
+}
+/**
+ * Images inside the flight's participants. A still-loading <img> that
+ * finishes DURING the flight decodes and first-rasters on the moving layer —
+ * glass-measured at one skipped present per decode (2026-08-18). The engine
+ * holds those images for the flight span; an unheld one completing mid-flight
+ * is that regression coming back.
+ */
+export interface ImageActivity {
+    /** Participant images not yet complete when the flight opened. */
+    loadingAtStart: number;
+    /**
+     * Images that appeared INSIDE a participant after the flight opened and
+     * were still loading — a data commit landing mid-navigation. The engine's
+     * own image hold watches for exactly these, so the recorder must too.
+     */
+    addedDuringFlight: number;
+    /** Of the tracked images, how many completed before the flight ended. */
+    completedDuringFlight: number;
+    /** Tracked images seen carrying the engine's hold marker. */
+    heldDuringFlight: number;
+    /**
+     * The number that actually matters: images that completed during the
+     * flight WITHOUT a hold, counted per image. Subtracting the two counts
+     * above would cancel out a held-but-still-loading image against an
+     * unheld completed one and report nothing.
+     */
+    completedUnheld: number;
+}
+/** Post-landing residue audit, taken 2 rAF after the flight completed. */
+export interface LandingAudit {
+    /**
+     * Inline transform/opacity left on participating [data-flemo-screen]
+     * elements at rest. The landed scope belongs to the compiled rest rules —
+     * any inline pose here is a cleanup failure (the flemo PR #259 class).
+     */
+    residualInlineTransforms: string[];
+    /**
+     * A COMPLETED+active screen whose computed transform translates it >= 50%
+     * of the viewport width off screen: the blank-viewport signature.
+     */
+    offViewportAtRest: boolean;
+    /** Transitional statuses still present ~10s after the flight began. */
+    stuckStatuses: string[];
+    /**
+     * Engine hold markers still on the page at rest. Every hold is supposed to
+     * be released when the flight lands; a leftover marker means something is
+     * still hidden with no owner left to reveal it — the class that produced
+     * ~130 permanently blank avatars before the single-owner guard landed.
+     */
+    orphanedHolds: string[];
+}
+/** One recorded navigation flight. */
+export interface FlightRecord {
+    /** Sequential id, "flight-1"… in recording order. */
+    id: string;
+    /** data-flemo-router of the first participating screen, if stamped. */
+    routerId?: string;
+    kind: FlightKind;
+    t0: FlightTimestamp;
+    t1: FlightTimestamp;
+    durationMs: number;
+    driver: FlightDriver;
+    participants: FlightParticipants;
+    holds: FlightHolds;
+    frameSamples: FrameSampleStats;
+    /** Did the motion advance, frame by frame — not just: did frames arrive. */
+    motion: MotionProgress;
+    /** Image load/hold activity inside the participants during the flight. */
+    images: ImageActivity;
+    /** Present only when the player's gap mirror grew during the flight. */
+    playerGaps?: PlayerGapStats;
+    /**
+     * Long tasks intersecting the RELEASED phase (visible motion) — these
+     * drive the anomaly rules.
+     */
+    longTasks: LongTaskSpan[];
+    /**
+     * Long tasks fully absorbed by the hold phase: the screen was posed, not
+     * moving, so these are the engine's commit-absorption working as designed,
+     * not user-visible jank.
+     */
+    holdLongTasks: LongTaskSpan[];
+    landing: LandingAudit;
+    /** Human/agent-readable findings derived from the data above. */
+    anomalies: string[];
+}
+export interface UaBrand {
+    brand: string;
+    version: string;
+}
+/** What this recorder could actually observe in this browser. */
+export interface ObservationCapabilities {
+    /** PerformanceObserver("longtask") supported — longTasks are meaningful. */
+    longTasks: boolean;
+    /** Element.getAnimations available — compiled-tier detection is direct. */
+    elementAnimations: boolean;
+    /** window.__flemoPlayerGaps present (the player has driven >= 1 flight). */
+    playerGapMirror: boolean;
+}
+export interface EnvironmentFingerprint {
+    userAgent: string;
+    /** navigator.userAgentData.brands, when the browser ships UA-CH. */
+    uaBrands: UaBrand[] | null;
+    engine: "blink" | "webkit" | "gecko" | "unknown";
+    platform: string;
+    maxTouchPoints: number;
+    devicePixelRatio: number;
+    screen: {
+        width: number;
+        height: number;
+    };
+    viewport: {
+        width: number;
+        height: number;
+    };
+    visualViewportScale: number | null;
+    /** Idle rAF cadence sampled at attach (median gap over ~20 frames). */
+    rafCadence: {
+        medianGapMs: number | null;
+        sampleCount: number;
+    };
+    reducedMotion: boolean;
+    /**
+     * DevTools device-emulation signature: Blink + desktop platform + touch
+     * points. Emulation composites the page to a scaled surface, so VISUAL
+     * reports from such a session are untrustworthy (instruments read the
+     * pre-scale surface and say "clean" while the eye watches the post-scale
+     * one). Mirrors packages/core/src/core/engine/emulationNotice.ts.
+     */
+    emulationSuspected: boolean;
+    observation: ObservationCapabilities;
+}
+export interface OverridesSection {
+    /**
+     * Every `flemo:*` storage key found (sessionStorage + localStorage),
+     * including unknown ones and keys that were present at attach but cleared
+     * since (marked in the key name). A non-empty map means this session does
+     * NOT run stock behavior.
+     */
+    active: Record<string, string>;
+    /** Derived, prominent warnings — read these before trusting anything. */
+    warnings: string[];
+}
+export interface DriverPolicySection {
+    /**
+     * localStorage `flemo:motion-driver` — the learned ledger. "css" means the
+     * device earned a persisted player demotion; "raf" means a clean probe.
+     */
+    demotion: string | null;
+    /**
+     * sessionStorage `flemo:motion-driver-force` raw value. NON-NULL MEANS A
+     * PIN IS ACTIVE: every transition is forced onto one driver. Almost always
+     * A/B residue when found unexpectedly.
+     */
+    forcePin: string | null;
+}
+export interface FlemoReport {
+    generatedAt: string;
+    /** Report schema version (not the package version). */
+    version: string;
+    environment: EnvironmentFingerprint;
+    overrides: OverridesSection;
+    driverPolicy: DriverPolicySection;
+    flights: FlightRecord[];
+    /** Session-level findings (observation traps, active pins, stuck flights). */
+    anomalies: string[];
+    /**
+     * Constant list of layers NO in-page instrument can see. If every field in
+     * this report is clean and the user still sees jank, the cause lives in one
+     * of these — do not chase them with in-page tooling.
+     */
+    blindSpots: string[];
+    /**
+     * Constant list of preconditions a motion verdict is only valid under (see
+     * judging.ts). The report cannot verify them from inside the page — an
+     * agent must confirm them with the user before trusting any judgement,
+     * including a clean one.
+     */
+    judgingProtocol: string[];
+}
+export interface FlightRecorderOptions {
+    /** Ring-buffer size for recorded flights. Default 50. */
+    maxFlights?: number;
+    /** console.info a one-line summary per completed flight. Default false. */
+    log?: boolean;
+    /** Install window.flemo = { report, flights, detach }. Default true. */
+    installGlobal?: boolean;
+}
+export interface FlightRecorderHandle {
+    detach: () => void;
+    report: () => FlemoReport;
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@flemo/devtools",
+  "version": "0.1.0",
+  "description": "Zero-config flight recorder for flemo screen transitions: captures per-flight driver routing, frame pacing, long tasks, landing residues, active debug overrides, and environment/observation-trap fingerprints into one JSON report readable by humans and coding agents.",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "flemo",
+    "devtools",
+    "diagnostics",
+    "flight-recorder",
+    "transition",
+    "performance"
+  ],
+  "author": {
+    "name": "kimjh96",
+    "email": "kimjhs@kakao.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kimjh96/flemo.git",
+    "directory": "packages/devtools"
+  },
+  "bugs": {
+    "url": "https://github.com/kimjh96/flemo/issues",
+    "email": "kimjhs@kakao.com"
+  },
+  "homepage": "https://flemo.dev",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^24.13.1",
+    "@vitest/coverage-v8": "^4.1.10",
+    "eslint": "^9.39.5",
+    "jsdom": "^29.1.1",
+    "typescript": "^6.0.3",
+    "vite": "^8.2.1",
+    "vite-plugin-dts": "^5.0.3",
+    "vitest": "^4.1.10",
+    "@flemo/eslint-config": "0.0.0",
+    "@flemo/tsconfig": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vite build",
+    "watch": "vite build --watch",
+    "dev": "vite build --watch",
+    "lint": "eslint \"**/*.{js,mjs,ts,jsx,tsx,mts}\"",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist .turbo"
+  }
+}