@multiplatform.one/node-graph 7.7.2

package/types/bench/frameSampler.d.ts

@@ -0,0 +1,235 @@
+/**
+ * The frame sampler, design §13.2 and plan task 5.1.
+ *
+ * It samples `requestAnimationFrame` deltas from INSIDE the canvas, because
+ * that is the clock that measures the frames a user sees. The host RN view's
+ * FPS is a different and less useful quantity: it keeps ticking while the
+ * WebView is stalled.
+ *
+ * Three things it refuses to do, each one a way a perf number lies:
+ *
+ *  - **Report an idle page.** `didMove` compares a transform signature taken at
+ *    the first sample against one taken at the last, and `reportRun` REJECTS a
+ *    run where they match rather than handing back plausible-looking numbers.
+ *    The reactflow spike lost a whole round of measurements to exactly this
+ *    when touch emulation silently reset, which is why design §13.2 makes it
+ *    mandatory rather than advisory.
+ *  - **Report an empty run.** Zero frames is not a fast run.
+ *  - **Guess a window.** `relayoutGate` throws on a mark that was never set
+ *    instead of measuring from t = 0 and calling it a pre-window.
+ *
+ * No React, no `@xyflow`, no DOM in the core: everything the sampler needs from
+ * the page arrives as the `probeTransform` and `countNodes` callbacks, so the
+ * whole module runs in vitest under a fake clock. `createDomTransformProbe`
+ * builds the real probe from SELECTORS the caller passes, which keeps the one
+ * `@xyflow` import site in `react-flow/xy.ts` where the lint rule wants it.
+ */
+import type { Result } from "../model/index";
+/** 60 Hz. A frame longer than this dropped one. */
+export declare const frameBudgetMs = 16.7;
+/** Two frames. Design §13.2's "no frame over 33 ms" gate reads this. */
+export declare const doubleFrameBudgetMs = 33.3;
+export interface FrameStats {
+    readonly samples: number;
+    readonly mean: number;
+    readonly p50: number;
+    readonly p95: number;
+    readonly worst: number;
+    /** Frames STRICTLY over 16.7 ms. A frame exactly on budget did not drop one. */
+    readonly over16_7: number;
+    readonly over33_3: number;
+    /** Derived from the mean, so it is the average frame rate and not a peak. */
+    readonly fps: number;
+}
+export declare function summarizeFrames(deltas: readonly number[]): FrameStats;
+export interface FrameSample {
+    /** The rAF timestamp this frame ENDED at. */
+    readonly t: number;
+    readonly d: number;
+}
+export interface FrameMark {
+    readonly t: number;
+    /** The transform signature at the instant of the mark, so a post-window `didMove` is checkable. */
+    readonly signature: string;
+    /** Which mark this is. Carried on the ordered list, where the key is gone. */
+    readonly label: string;
+}
+export interface FrameRun {
+    readonly deltas: readonly number[];
+    readonly samples: readonly FrameSample[];
+    readonly stats: FrameStats;
+    readonly didMove: boolean;
+    readonly nodeCount: number;
+    readonly marks: Readonly<Record<string, FrameMark>>;
+    /**
+     * Every mark IN ORDER, including repeats of the same label.
+     *
+     * `marks` is keyed, so `mark("start")` six times keeps the sixth and loses
+     * five — which is fine for `relayoutGate`, whose whole subject is a single
+     * relayout, and useless for six scripted pans. Both are kept rather than one
+     * derived from the other: the keyed record is a different question ("when did
+     * the relayout fire") from the ordered list ("which windows were gestures").
+     */
+    readonly markList: readonly FrameMark[];
+    readonly startedAt: number;
+    readonly stoppedAt: number;
+    readonly startSignature: string;
+    readonly stopSignature: string;
+    /**
+     * `start()` had been called and this `stop()` is the one closing it.
+     *
+     * The device instrument. On a phone there is no console, so "the Stop never
+     * reached the canvas" and "the Stop arrived with no run in flight" are the
+     * same picture: a readout stuck on `sampling…`. They are different bugs — the
+     * first is a dead bridge, the second is a lost Start — and only the canvas
+     * knows which. `reportRun` turns this into a named rejection so a screenshot
+     * can say.
+     */
+    readonly started: boolean;
+}
+export interface FrameSamplerOptions {
+    readonly now?: () => number;
+    readonly requestFrame?: (cb: (t: number) => void) => number;
+    readonly cancelFrame?: (handle: number) => void;
+    /**
+     * A short string that changes when anything on the canvas moved. Design
+     * §13.2's `didMove` is exactly "this changed between the first and last
+     * sample"; nothing is compared per frame, so the probe can afford to walk
+     * every node.
+     */
+    readonly probeTransform?: () => string;
+    readonly countNodes?: () => number;
+    /** Ring buffer bound. 3600 frames is a minute at 60 Hz. */
+    readonly maxSamples?: number;
+}
+export interface FrameSampler {
+    start: () => void;
+    stop: () => FrameRun;
+    /** Stamps an instant AND the transform signature at it. Returns the timestamp. */
+    mark: (label: string) => number;
+    readonly running: boolean;
+}
+export declare function createFrameSampler(options?: FrameSamplerOptions): FrameSampler;
+/**
+ * The real probe, built from selectors the caller supplies.
+ *
+ * React Flow places both the viewport and every node with a CSS TRANSFORM and
+ * never with a layout offset, so `offsetLeft` / `offsetTop` are 0 at every
+ * arrangement — milestone 4 shipped a position stamp built on them that was a
+ * constant, and caught it in Chrome rather than in a spec. This reads
+ * `style.transform`, which is the thing that actually moves.
+ *
+ * A pan moves the viewport; a node drag moves one node while the viewport
+ * stands still. Both are in the signature, because both are runs design §13.2
+ * asks for.
+ */
+export declare function createDomTransformProbe(selectors: {
+    readonly viewport: string;
+    readonly node: string;
+    readonly root?: ParentNode;
+}): () => string;
+/** The default bracket labels. A pair, so a story cannot spell one of them. */
+export declare const gestureStartMark = "start";
+export declare const gestureEndMark = "end";
+export interface GestureWindow {
+    /** Frames inside a `start` → `end` pair, and only those. */
+    readonly stats: FrameStats;
+    /** How many pairs the run recorded. Design §13.2's six scripted pans is six. */
+    readonly segments: number;
+    /** Frames that fell in no segment: the harness sitting still between pans. */
+    readonly idleFrames: number;
+    /**
+     * A `start` still open when the Stop came, closed at the Stop.
+     *
+     * Reported rather than silently dropped or silently included. Dropping loses
+     * a whole gesture; including it without saying so folds the idle tail into a
+     * number that claims to be gesture-only. 0 or 1, since the marks are read in
+     * order.
+     */
+    readonly unclosed: number;
+}
+/**
+ * Design §13.2's cell, bounded to the GESTURES instead of to the session.
+ *
+ * The m6 iOS number — `952 frames · p95 18.8 · mean 16.7` over six scripted
+ * pans — was reported with its own caveat attached: the window ran from Start
+ * to Stop, so it held every idle frame between one pan and the next. Idle
+ * frames are cheap and plentiful, so they drag the mean down and leave the p95
+ * roughly alone: the cell was pessimistic about the tail and optimistic about
+ * the average, and there was no way to say by how much.
+ *
+ * A `start` mark opens a segment and the next `end` closes it. Repeats are read
+ * in ORDER off `markList`, because the keyed `marks` record keeps only the last
+ * of each label — six pans marked `start`/`end` are one entry there.
+ *
+ * `null` when nothing was marked at all. "No gesture was bracketed" and "a
+ * bracketed gesture produced no frames" are different findings, and a zeroed
+ * `FrameStats` cannot tell them apart.
+ */
+export declare function gestureWindow(run: FrameRun, labels?: {
+    readonly start: string;
+    readonly end: string;
+}): GestureWindow | null;
+export interface FrameRunContext {
+    readonly label: string;
+    readonly host: string;
+    readonly nodeCount: number;
+    readonly culling: boolean;
+    readonly layoutRunner?: string;
+    readonly note?: string;
+}
+export interface FrameReport extends FrameRunContext {
+    readonly didMove: true;
+    readonly stats: FrameStats;
+    /** The gesture-only cell, or `null` when the run bracketed nothing. */
+    readonly gesture: GestureWindow | null;
+    readonly deltas: readonly number[];
+    readonly durationMs: number;
+    readonly marks: Readonly<Record<string, FrameMark>>;
+}
+export interface FrameReportRejection {
+    readonly reason: "empty" | "didMove" | "notStarted";
+    readonly message: string;
+}
+/**
+ * The gate on the way OUT of a run.
+ *
+ * A `didMove: false` run is discarded, not reported — design §13.2, verbatim.
+ * Returning a `Result` rather than throwing is the package's house shape
+ * (`parseDocument`), and it means a five-run cell can drop a bad run and say
+ * how many it dropped instead of dying halfway through a session.
+ */
+export declare function reportRun(run: FrameRun, context: FrameRunContext): Result<FrameReport, FrameReportRejection>;
+/**
+ * Frames whose timestamp falls in `(from, to]`.
+ *
+ * Half-open on the NEAR edge on purpose: the frame that ended exactly at the
+ * mark is a frame that happened before the relayout fired, so it belongs to
+ * the pre-window.
+ */
+export declare function sliceWindow(run: FrameRun, from: number, to: number): number[];
+export interface RelayoutGateVerdict {
+    readonly pass: boolean;
+    readonly pre: FrameStats;
+    readonly post: FrameStats;
+    readonly p95Ratio: number;
+    readonly postDidMove: boolean;
+    readonly windowMs: number;
+    readonly markT: number;
+    /** `p95` | `newHeavyFrames` | `didMove`. Empty on a pass. */
+    readonly reasons: readonly string[];
+}
+/**
+ * Design §13.2's first absolute gate, as a function rather than a paragraph.
+ *
+ * PASS is all three of:
+ *
+ *  - the post window's p95 is within 20% of the pre window's,
+ *  - the post window holds no more frames over 33.3 ms than the pre window did
+ *    (the design's "no frame over 33 ms appears in the post window that is
+ *    absent from the pre window", read as a count so it is falsifiable),
+ *  - `didMove` holds across the post window ALONE — a relayout that froze the
+ *    canvas produces a beautiful histogram.
+ */
+export declare function relayoutGate(run: FrameRun, markLabel: string, windowMs?: number): RelayoutGateVerdict;
+//# sourceMappingURL=frameSampler.d.ts.map

package/types/bench/frameSampler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frameSampler.d.ts","sourceRoot":"","sources":["../../src/bench/frameSampler.ts"],"names":[],"mappings":"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"}

package/types/bench/generateGraph.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The bench graph: 200 nodes, ~400 edges, and the same document every time.
+ *
+ * Determinism is the point. Design §13.2 asks for five runs per cell and the
+ * median of the per-run p95, which only means anything if the five runs are
+ * looking at the same graph — and a `Math.random` scatter makes a regression
+ * indistinguishable from a luckier layout. `mulberry32` is named in plan task
+ * 5.1 for that reason: 32 bits of state, one multiply and two shifts, no
+ * dependency, and identical output on Hermes and in V8.
+ *
+ * Edges only ever run FORWARD (`target index > source index`), so the graph is
+ * acyclic by construction. That is not decoration: dagre ranks a cyclic graph
+ * by breaking edges it picks itself, which would make the layout bench's
+ * numbers depend on which edge it happened to break.
+ *
+ * No React and no `@xyflow` here — the model half of the package has to stay
+ * importable from a CLI and from the CI bench (design §3.1), and this module is
+ * imported by both the bench script and the story.
+ */
+import type { BuiltinEdgeData } from "../edges/edgeKinds";
+import type { GraphDocument } from "../model/index";
+import type { DemoNodeData } from "../react-flow/fixtures";
+/** Mulberry32. Named in plan task 5.1; 32-bit state, seeded, repeatable. */
+export declare function mulberry32(seed: number): () => number;
+export interface BenchGraphOptions {
+    readonly count: number;
+    readonly seed?: number;
+    /** Extra forward edges attempted per node that HAS an out port. 3 gives ~400 at 200. */
+    readonly fanOut?: number;
+    /** Flow units between grid columns and rows. Wide on purpose: culling is the thing under test. */
+    readonly columns?: number;
+    readonly columnGap?: number;
+    readonly rowGap?: number;
+}
+type Doc = GraphDocument<DemoNodeData, BuiltinEdgeData>;
+/**
+ * A graph big enough that culling matters and laid out so it does NOT all fit
+ * on one screen — design §13.2's runs are taken "not at `fitView`", which only
+ * has meaning if the graph overflows the viewport.
+ */
+export declare function generateBenchGraph(options: BenchGraphOptions): Doc;
+export {};
+//# sourceMappingURL=generateGraph.d.ts.map

package/types/bench/generateGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateGraph.d.ts","sourceRoot":"","sources":["../../src/bench/generateGraph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,4EAA4E;AAC5E,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,MAAM,CASrD;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,wFAAwF;IACxF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,kGAAkG;IAClG,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,KAAK,GAAG,GAAG,aAAa,CAAC,YAAY,EAAE,eAAe,CAAC,CAAC;AAgBxD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,iBAAiB,GAAG,GAAG,CAqElE"}

package/types/diagnostics/GraphDiagnostics.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Design §9.5's record, rendered so a screenshot is a diagnosis.
+ *
+ * On a device there is no console to open, so this panel is the whole of the
+ * evidence. It leads with the failure when there is one — **which stage boot
+ * reached and which phase threw** — because that pair is what tells a reader
+ * which of design §9.4's five layers let the failure through, and everything
+ * else is context behind it.
+ *
+ * Dev-only by default, per §9.5. `show` overrides that, which is what the
+ * device runs at 2.7/2.8 use to read the panel out of a release build.
+ */
+import type { ReactNode } from "react";
+import type { GraphDiagnostics as GraphDiagnosticsRecord } from "./types";
+export interface GraphDiagnosticsProps {
+    readonly diagnostics: GraphDiagnosticsRecord;
+    /** Defaults to dev-only. Pass `true` to read the panel in a release build. */
+    readonly show?: boolean;
+}
+/**
+ * The failure banner.
+ *
+ * Named separately because it is the part that has to survive a screenshot at
+ * phone resolution: a reader must get the stage and the phase without zooming.
+ */
+export declare function GraphBootFailure({ diagnostics, }: {
+    diagnostics: GraphDiagnosticsRecord;
+}): ReactNode;
+export declare function GraphDiagnostics({ diagnostics, show }: GraphDiagnosticsProps): ReactNode;
+//# sourceMappingURL=GraphDiagnostics.d.ts.map

package/types/diagnostics/GraphDiagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphDiagnostics.d.ts","sourceRoot":"","sources":["../../src/diagnostics/GraphDiagnostics.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,gBAAgB,IAAI,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAE1E,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,WAAW,EAAE,sBAAsB,CAAC;IAC7C,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;CACzB;AAiBD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,WAAW,GACZ,EAAE;IACD,WAAW,EAAE,sBAAsB,CAAC;CACrC,GAAG,SAAS,CAgBZ;AAED,wBAAgB,gBAAgB,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,EAAE,qBAAqB,GAAG,SAAS,CAwExF"}

package/types/diagnostics/LiveGraphDiagnostics.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A REAL canvas with design §9.5's panel under it — the web half.
+ *
+ * WHY IT EXISTS (MPO-211). `NodeGraph/Diagnostics` was a harness: it walked the
+ * boot stages by hand and fed the panel synthetic input, including
+ * `nodesMounted: loaded ? 12 : 0` — a literal, in the one story whose job was
+ * to prove that number. A harness that hardcodes the thing it exists to prove
+ * is worse than no harness, so the harness keeps the half it is genuinely good
+ * at (breaking the bundle on purpose) and this component owns the measured
+ * half.
+ *
+ * Every number below comes from the canvas mounted beside it:
+ *
+ *  - `nodesMounted` from `nodeCensus`, which counts `GraphNodeHost` instances
+ *    and therefore counts node bodies React Flow actually rendered;
+ *  - `nodesInDocument` from the document handed to the canvas;
+ *  - `faces` from design §6.3's corrupted-first-family probe, run against a
+ *    node title the canvas rendered;
+ *  - `faceDelivery` from `GraphFaces`, which is how the panel says whether the
+ *    asset URL answered or the base64 carried it.
+ *
+ * The native twin is `LiveGraphDiagnostics.native.tsx`, and it reads the same
+ * record out of the WebView's `ready` event instead. Only a `.native.tsx`
+ * twin, never a `.web.*` one (MPO-192).
+ */
+export declare function LiveGraphDiagnostics(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=LiveGraphDiagnostics.d.ts.map

package/types/diagnostics/LiveGraphDiagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LiveGraphDiagnostics.d.ts","sourceRoot":"","sources":["../../src/diagnostics/LiveGraphDiagnostics.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAqCH,wBAAgB,oBAAoB,4CA2DnC"}

package/types/diagnostics/LiveGraphDiagnostics.native.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A REAL canvas with design §9.5's panel under it — the NATIVE half, and the
+ * only place AC-3's DOM half can be read (MPO-211).
+ *
+ * The problem this solves. On device the canvas renders inside a WebView, so
+ * every number worth having is measured in a JS realm the Hermes side cannot
+ * reach: how many node bodies actually mounted, and whether §6.3's
+ * corrupted-first-family control says the `$body` face painted. A story on the
+ * Hermes side can measure neither — `NodeGraph/GraphNode` → `FontProof` tries,
+ * and its probe measures the Hermes-side stack, which is not the thing AC-3
+ * asks about. The canvas already computes all of it and sends it over the
+ * `ready` event; until now nothing on a device DISPLAYED it.
+ *
+ * So this mounts the same `<NodeGraph>` the Kitchen Sink's `Main` story mounts,
+ * takes the `ready` payload, and renders it straight into `GraphDiagnostics`.
+ * Nothing is synthesised here. If the canvas never reports, the panel says so
+ * rather than showing zeroes that look like measurements.
+ *
+ * `../NodeGraph.native` is imported by its explicit filename, the same way
+ * `index.native.ts` does it: `onReady` is native-only by construction, so the
+ * shared specifier would resolve to the web twin under `tsgo` and the prop
+ * would not typecheck.
+ */
+export declare function LiveGraphDiagnostics(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=LiveGraphDiagnostics.native.d.ts.map

package/types/diagnostics/LiveGraphDiagnostics.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LiveGraphDiagnostics.native.d.ts","sourceRoot":"","sources":["../../src/diagnostics/LiveGraphDiagnostics.native.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAgBH,wBAAgB,oBAAoB,4CAsBnC"}

package/types/diagnostics/deliberateBreak.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A module that throws when it is evaluated. That is its whole job.
+ *
+ * Design §9.5 asks for a story toggle that "deliberately breaks the bundle so
+ * the fallback path is a story rather than a hope". A toggle that only sets a
+ * flag would exercise a branch, not the failure — the real failure is a module
+ * whose EVALUATION throws inside `await import(...)`, which is what the boot
+ * heartbeat of §9.4 layer 3 is built to catch and what the diagnostics panel
+ * has to be able to name.
+ *
+ * SAFE TO SHIP, and `GraphDiagnostics.stories.tsx` is the only importer:
+ *
+ *  - It is reached exclusively through a dynamic `import()` behind a story
+ *    control, so nothing evaluates it unless a human flips the switch.
+ *  - The package build EXCLUDES THIS FILE BY NAME, so no compiled copy exists.
+ *    Excluding only `*.stories.*` was not enough and the first build proved
+ *    it: `tamagui-build` compiles every source file it finds, reachable or
+ *    not, and emitted `dist/esm/diagnostics/deliberateBreak.mjs`. The exclude
+ *    pattern is the same mechanism that keeps the DOM entry out of `dist`.
+ *  - `GraphDiagnostics.spec.tsx` asserts no non-story module under `src/`
+ *    imports it, so it cannot quietly acquire a second caller.
+ *
+ * The message is written to look like the failure it stands in for: the
+ * `import.meta` parse error that blanks a WebView with no reachable error
+ * boundary (design §9.4).
+ */
+export {};
+//# sourceMappingURL=deliberateBreak.d.ts.map

package/types/diagnostics/deliberateBreak.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deliberateBreak.d.ts","sourceRoot":"","sources":["../../src/diagnostics/deliberateBreak.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AASH,OAAO,EAAE,CAAC"}

package/types/diagnostics/fromWire.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The `ready` event's payload, as design §9.5's record.
+ *
+ * The two shapes are the same fields with one deliberate difference:
+ * `GraphDiagnosticsWire.layoutRunner` is a plain string, so adding a layout
+ * runner in milestone 4 is not a bridge change. This is the one place that
+ * difference is reconciled, and an unknown runner narrows to `"none"` rather
+ * than being cast — a value the panel invented would read as a runner that ran.
+ *
+ * Everything else crosses unchanged. `FaceProbeWire` and `FaceProbe` are the
+ * same five fields, and `graphDiagnosticsWireFields` in `wire.spec.ts` is what
+ * holds them to that.
+ */
+import type { GraphDiagnosticsWire } from "../dom/wire";
+import type { GraphDiagnostics } from "./types";
+export declare function graphDiagnosticsFromWire(wire: GraphDiagnosticsWire): GraphDiagnostics;
+//# sourceMappingURL=fromWire.d.ts.map

package/types/diagnostics/fromWire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fromWire.d.ts","sourceRoot":"","sources":["../../src/diagnostics/fromWire.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAoB,MAAM,SAAS,CAAC;AAgBlE,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,oBAAoB,GAAG,gBAAgB,CAgBrF"}

package/types/diagnostics/lastError.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The one error worth reporting, kept where both halves of boot can reach it.
+ *
+ * Same shape and same reason as `dom/boot.ts`: `NodeGraphDom.ts` must carry no
+ * top-level import of ours that could itself throw (design §9.4 layer 3), so it
+ * writes this slot INLINE from its own catch block. A module-scoped variable
+ * would give the entry and the diagnostics panel two separate records, and the
+ * panel would report the empty one.
+ *
+ * Everything here treats the global as untrusted. A record another library
+ * clobbered, or a phase outside the wire's four, reads back as `null` rather
+ * than throwing inside the error path — which is the one path where a second
+ * throw costs you the diagnosis.
+ *
+ * Design: docs/design/node-graph-editor.md §9.5.
+ */
+import type { GraphErrorPhase } from "../dom/wire";
+/**
+ * The key `NodeGraphDom.ts` writes inline.
+ *
+ * Exported so `useGraphDiagnostics.spec.tsx` can assert the entry's literal and
+ * this module's reader still name the same slot — the one place the two halves
+ * could silently drift.
+ */
+export declare const graphErrorGlobalKey = "__mp_graph_error";
+export interface GraphErrorRecord {
+    readonly phase: GraphErrorPhase;
+    readonly message: string;
+    readonly stack?: string;
+    /** `Date.now()` at the record, so a panel can say how long ago it happened. */
+    readonly at: number;
+}
+/** The record as written, normalised. Anything unrecognisable reads as `null`. */
+export declare function readGraphError(): GraphErrorRecord | null;
+/**
+ * Record an error, keeping the FIRST one.
+ *
+ * A module-eval throw usually produces a train of render errors behind it, and
+ * last-write-wins would report the consequence while the cause scrolled off.
+ * `resetGraphError` is what Retry calls before remounting, so a genuinely new
+ * boot is not judged on the previous one's failure.
+ */
+export declare function recordGraphError(error: {
+    readonly phase: GraphErrorPhase;
+    readonly message: string;
+    readonly stack?: string;
+}): GraphErrorRecord | null;
+/** Test seam, and what Retry calls before remounting. */
+export declare function resetGraphError(): void;
+//# sourceMappingURL=lastError.d.ts.map

package/types/diagnostics/lastError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lastError.d.ts","sourceRoot":"","sources":["../../src/diagnostics/lastError.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,qBAAqB,CAAC;AAEtD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAYD,kFAAkF;AAClF,wBAAgB,cAAc,IAAI,gBAAgB,GAAG,IAAI,CAYxD;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE;IACtC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,gBAAgB,GAAG,IAAI,CAY1B;AAED,yDAAyD;AACzD,wBAAgB,eAAe,IAAI,IAAI,CAEtC"}

package/types/diagnostics/types.d.ts

@@ -0,0 +1,101 @@
+/**
+ * What a WebView that came up wrong is able to tell you (design §9.5).
+ *
+ * Every field here answers a question an agent reading a device screenshot has
+ * to be able to answer without a console: how far did boot get, which renderer
+ * drew this, which layout runner resolved, did the face actually paint, how
+ * many nodes mounted, and what threw first.
+ */
+import type { BootStage } from "../dom/boot";
+import type { LayoutRunnerKind as LayoutEngineRunnerKind } from "../layout/types";
+import type { GraphErrorPhase } from "../dom/wire";
+import type { FaceProbe } from "../theme/faces";
+/**
+ * Design §8's four, plus `none`.
+ *
+ * `none` is not in the design's union and is not a fifth strategy — it is the
+ * honest state before a canvas has resolved a runner. The alternative was
+ * reporting `inline`, which is a real runner and would read as "the worker
+ * fallback fired" to exactly the person the field exists for.
+ *
+ * The four are IMPORTED rather than restated. Milestone 4 made
+ * `layout/types.ts` the definition, and two hand-kept copies of a union is how
+ * a fifth runner ends up reportable in one file and not the other.
+ */
+export type LayoutRunnerKind = LayoutEngineRunnerKind | "none";
+export type GraphRenderer = "react-flow-web" | "react-flow-dom";
+/**
+ * Which of design 6.3's two mechanisms actually delivered a face.
+ *
+ * On device this is the whole answer to "did the asset URL work, or did the
+ * 211 KB of base64 carry it" — a question nothing on screen could answer
+ * before MPO-211, because `GraphFaces` reported it to a callback the panel
+ * never saw. `pending` means the probe has not answered yet, and is reported
+ * rather than guessed.
+ */
+export interface GraphFaceDelivery {
+    readonly id: string;
+    readonly family: string;
+    readonly weight: number;
+    readonly source: "asset" | "inline" | "pending" | "failed";
+}
+export interface GraphDiagnostics {
+    readonly stage: BootStage | null;
+    /**
+     * Milliseconds from the entry's `script` stamp to this record, or `null`
+     * where no boot record exists.
+     *
+     * The number the native watchdog's budget is set FROM (MPO-211). Design
+     * 9.4's 4000 ms was never measured; on emulator-5590 rebooted fresh it
+     * fired on a canvas that then rendered on the first Retry.
+     */
+    readonly bootMs: number | null;
+    readonly renderer: GraphRenderer;
+    readonly xyflowVersion: string;
+    readonly layoutRunner: LayoutRunnerKind;
+    readonly faces: readonly FaceProbe[];
+    /** Which mechanism delivered each declared face. Empty where none was mounted. */
+    readonly faceDelivery: readonly GraphFaceDelivery[];
+    /**
+     * Node bodies React Flow has MOUNTED, from `nodeCensus` — not the document's
+     * node count, which is the field below.
+     *
+     * The two differ whenever `culling` is true: the demo document has 12 nodes
+     * and mounts 10 at the default viewport. Reporting one number for both is
+     * what made "renders 12 nodes" unreadable off a device screenshot.
+     */
+    readonly nodesMounted: number;
+    /** Nodes in the document the canvas parsed. */
+    readonly nodesInDocument: number;
+    readonly culling: boolean;
+    readonly renderMode: "detail" | "overview";
+    readonly scheme: "light" | "dark";
+    readonly lastError: {
+        readonly phase: GraphErrorPhase;
+        readonly message: string;
+    } | null;
+}
+/**
+ * What the caller knows, as against what this module derives.
+ *
+ * The split is deliberate. `stage`, `xyflowVersion` and `lastError` are read
+ * from module state and cannot be faked by a caller; the rest are live values
+ * only the canvas holds. Making the canvas hand them in beats reaching into
+ * React Flow's store from a second place — `renderMode` in particular is
+ * already computed once, in `GraphNodeHost`, from the live zoom.
+ */
+export interface GraphDiagnosticsInput {
+    readonly renderer: GraphRenderer;
+    readonly nodesMounted: number;
+    readonly nodesInDocument: number;
+    readonly culling: boolean;
+    readonly renderMode: "detail" | "overview";
+    readonly scheme: "light" | "dark";
+    /** Omitted until `resolveRunner()` has answered. Reported as `none`. */
+    readonly layoutRunner?: LayoutRunnerKind;
+    /** From `probeRenderedFamily`. Omitted reports as an empty list, never absent. */
+    readonly faces?: readonly FaceProbe[];
+    /** From `GraphFaces`' `onStatus`. Omitted reports as an empty list, never absent. */
+    readonly faceDelivery?: readonly GraphFaceDelivery[];
+}
+//# sourceMappingURL=types.d.ts.map

package/types/diagnostics/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/diagnostics/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,IAAI,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAClF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,gBAAgB,GAAG,sBAAsB,GAAG,MAAM,CAAC;AAE/D,MAAM,MAAM,aAAa,GAAG,gBAAgB,GAAG,gBAAgB,CAAC;AAEhE;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;CAC5D;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACjC;;;;;;;OAOG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;IACrC,kFAAkF;IAClF,QAAQ,CAAC,YAAY,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACpD;;;;;;;OAOG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,+CAA+C;IAC/C,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC3C,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CAC1F;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC3C,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC;IAClC,wEAAwE;IACxE,QAAQ,CAAC,YAAY,CAAC,EAAE,gBAAgB,CAAC;IACzC,kFAAkF;IAClF,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,qFAAqF;IACrF,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACtD"}

package/types/diagnostics/useGraphDiagnostics.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Reads design §9.5's record out of the state that already exists.
+ *
+ * Nothing here is stored twice. The boot stage comes from the heartbeat's
+ * global, the version from the one `@xyflow` import site, the first error from
+ * the slot the DOM entry writes inline. What a caller passes in is only what
+ * lives in the canvas and nowhere else.
+ *
+ * THE GLOBALS ARE READ ON EVERY RENDER, and that is not an oversight to be
+ * memoized away. Both are written from EFFECTS — `stampBootStage` from the
+ * boot sequence, the error slot from the DOM entry's catch — so both land
+ * after the first render has already happened. A `useMemo` keyed on the input
+ * alone captures them at mount and never looks again, and the panel then
+ * reports `stage: none` on a boot that reached `faces`. Measured on the
+ * Storybook at task 2.6, before the spec existed to catch it.
+ *
+ * Two cheap property reads per render is the correct price. The memo below
+ * exists only to keep the RESULT's identity stable when nothing actually
+ * moved, so a consumer memoizing on it does not re-run every frame.
+ */
+import type { GraphDiagnostics, GraphDiagnosticsInput } from "./types";
+export declare function useGraphDiagnostics(input: GraphDiagnosticsInput): GraphDiagnostics;
+//# sourceMappingURL=useGraphDiagnostics.d.ts.map

package/types/diagnostics/useGraphDiagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGraphDiagnostics.d.ts","sourceRoot":"","sources":["../../src/diagnostics/useGraphDiagnostics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAMH,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAKvE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,qBAAqB,GAAG,gBAAgB,CAsDlF"}