@multiplatform.one/node-graph 7.7.2

package/types/dom/GraphDomLayout.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The four CSS rules without which the canvas is laid out and invisible.
+ *
+ * `NodeGraphWeb` sizes its root `width: 100%; height: 100%`, and React Flow's
+ * own `.react-flow` does the same. A percentage height resolves against the
+ * parent's height, and in an Expo DOM component the chain above it —
+ * `html > body > #root` — is a plain auto-height document. So `height: 100%`
+ * computes to `auto`, `.react-flow` collapses, and `@xyflow/react`'s
+ * `overflow: hidden` on the pane clips every node away.
+ *
+ * MEASURED ON BOTH PLATFORMS at tasks 2.7 and 2.8, and it is the failure that
+ * looks most like nothing being wrong. The iPhone 16e's accessibility tree
+ * carried all ten mounted node bodies with correct titles, correct three-column
+ * geometry, and heights that MOVED when the space knob was flipped — every
+ * signal a reader would take as proof — while the screen showed white. There
+ * was no fallback, because there was no error: boot ran through to `ready`, the
+ * canvas was fine, and it had nowhere to paint. emulator-5592 looked identical.
+ *
+ * The gate spike carried these rules and passed with them
+ * (`components/GraphCanvas.tsx`'s `LAYOUT_CSS`); the package never ported them,
+ * so this is the one part of the gate that was proven and then lost.
+ *
+ * It is a `<style>` element and nothing else, so it costs no layout and cannot
+ * move a node. Mounted by `NodeGraphDomInner` for the same reason `GraphFaces`
+ * is: inside the WebView is the only place either can do anything.
+ */
+import type { ReactNode } from "react";
+/**
+ * `#root` is Expo's own mount point for a DOM component, and `#root > div` is
+ * whatever React renders first inside it — neither is ours to name in markup,
+ * so they are named here.
+ *
+ * `margin: 0` on `body` matters as much as the heights: a UA's default 8px
+ * margin makes the canvas 16px wider than its WebView, and React Flow's pane
+ * then reports a viewport that does not match the box the user is touching.
+ */
+export declare const graphDomLayoutCss: string;
+/** The sheet, and nothing else. Renders nothing where there is no DOM. */
+export declare function GraphDomLayout(): ReactNode;
+//# sourceMappingURL=GraphDomLayout.d.ts.map

package/types/dom/GraphDomLayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphDomLayout.d.ts","sourceRoot":"","sources":["../../src/dom/GraphDomLayout.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,QAIlB,CAAC;AAEb,0EAA0E;AAC1E,wBAAgB,cAAc,IAAI,SAAS,CAG1C"}

package/types/dom/NodeGraphDom.d.ts

@@ -0,0 +1,4 @@
+import type { NodeGraphDomProps } from "./NodeGraphDomShell";
+export type { GraphDomCommandSlot, GraphDomCommands, NodeGraphDomHandle, NodeGraphDomInnerProps, NodeGraphDomOptions, NodeGraphDomProps, NodeGraphDomRealmProps, NodeGraphDomShellProps, } from "./NodeGraphDomShell";
+export default function NodeGraphDom(props: NodeGraphDomProps): import("react").FunctionComponentElement<import("./NodeGraphDomShell").NodeGraphDomShellProps<import("../model").NodeKindDefs, import("../model").EdgeKindDefs>>;
+//# sourceMappingURL=NodeGraphDom.d.ts.map

package/types/dom/NodeGraphDom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeGraphDom.d.ts","sourceRoot":"","sources":["../../src/dom/NodeGraphDom.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,YAAY,EACV,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,sBAAsB,EACtB,mBAAmB,EACnB,iBAAiB,EACjB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,KAAK,EAAE,iBAAiB,oKAE5D"}

package/types/dom/NodeGraphDomInner.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The real tree, behind the dynamic import.
+ *
+ * Everything that can throw at module-eval time lives here rather than in the
+ * entry, so a throw is a caught `{ t: "error", phase: "module" }` instead of a
+ * blank WebView. That is the whole reason this file is separate from
+ * `NodeGraphDom.ts`.
+ *
+ * It renders exactly one code path: `KnobEnvelopeProvider` rebuilds the real
+ * Preset / Surface / Intent stack out of the envelope the host serialized, and
+ * `NodeGraphWeb` — the same component the web Storybook mounts — resolves its
+ * own knobs from that rebuilt stack. There is no DOM-specific canvas. Design
+ * 6.1's claim is that the rehydrated `ResolvedKnobs` deep-equals the host's,
+ * and `envelope.spec.tsx` is what holds it to that.
+ *
+ * A fresh React root has no `TamaguiProvider` above it, so this file supplies
+ * the config. It takes it as a PROP from the app's `'use dom'` entry and falls
+ * back to whatever `createTamagui` already installed: the config is not JSON
+ * and cannot cross the bridge, so it has to come from a module the consumer's
+ * DOM entry imports — the same constraint that makes schemas register by id,
+ * and the one that had this canvas dying of `Missing theme.` on both platforms
+ * until design §9.3 was amended to say who owns the entry.
+ */
+import type { NodeGraphDomInnerProps } from "./NodeGraphDomShell";
+export declare function NodeGraphDomInner(props: NodeGraphDomInnerProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=NodeGraphDomInner.d.ts.map

package/types/dom/NodeGraphDomInner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeGraphDomInner.d.ts","sourceRoot":"","sources":["../../src/dom/NodeGraphDomInner.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAyBH,OAAO,KAAK,EAAE,sBAAsB,EAAuB,MAAM,qBAAqB,CAAC;AA0BvF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,kDAkc9D"}

package/types/dom/NodeGraphDomShell.d.ts

@@ -0,0 +1,221 @@
+/**
+ * The DOM SHELL — everything a `'use dom'` entry needs except the directive.
+ *
+ * Exported at `@multiplatform.one/node-graph/dom-inner`, source-resolved on
+ * every condition, because the entry itself is APP-OWNED (design §9.3). A
+ * schema's `render` is a component and a Tamagui config is a live object, so
+ * neither can be JSON and neither can cross the bridge: both have to come from
+ * a module the DOM BUNDLE imports, and a DOM bundle is rooted at the file
+ * carrying `'use dom'`. The package cannot own that file any more than it can
+ * own the schema registry, so it owns everything else and the app writes three
+ * lines around it.
+ *
+ * This file exists to be BORING. Design 9.4's third layer: a blank WebView is
+ * what a parse error looks like from the outside, and a parse error in a
+ * top-level dependency happens before any error boundary exists. So the shell
+ * imports nothing of ours at the top, stamps how far boot got on a global as
+ * early as the module body allows, and only then reaches for the real tree
+ * through a dynamic `import()` inside a try/catch. Under Metro that becomes a
+ * `require`, so a module-eval throw is catchable and reportable instead of
+ * fatal.
+ *
+ * Two consequences worth naming, because both look like mistakes:
+ *
+ *  - It is a `.ts` with `createElement`, not a `.tsx`. The automatic JSX
+ *    runtime injects a top-level `import { jsx } from "react/jsx-runtime"`, so
+ *    "no top-level import" is not literally achievable in a `.tsx`, and the
+ *    honest version of the invariant is "no top-level import of anything that
+ *    can throw".
+ *  - The boot stamp is written INLINE rather than through `boot.ts`, which
+ *    already has a function for it. Importing that function would be a
+ *    top-level import of ours. `boot.ts` exports `bootGlobalKey` and
+ *    `domEntry.spec.ts` asserts this file names the same slot, so the
+ *    duplication cannot drift.
+ *
+ * The imperative handle lives HERE rather than in the inner tree, so
+ * `ref.current.fitView()` after a failed boot is a no-op that reports, not a
+ * `TypeError` on a canvas that never mounted. The inner tree registers the
+ * real implementations into `commands` when it mounts.
+ *
+ * WHAT THE APP'S ENTRY ADDS, and why it cannot be here (measured on the
+ * iPhone 16e simulator and on emulator-5592 at task 2.7/2.8): `getConfig()`
+ * threw inside the DOM bundle because `createThemeConfig` is a FACTORY the app
+ * calls and nothing in `public/node-graph`'s import graph calls it, so the
+ * canvas mounted with no `TamaguiProvider` and the first Tamagui component
+ * threw `Missing theme.` on both platforms. `config` is now a prop, and the
+ * one place it can come from is a static import in the app's own entry.
+ */
+import { Component } from "react";
+import type { ErrorInfo, ReactNode, Ref } from "react";
+import type { DOMProps } from "expo/dom";
+import type { TamaguiInternalConfig } from "@tamagui/web";
+import type { EdgeKindDefs, GraphSchema, NodeKindDefs } from "../model/index";
+import type { GraphCommandSlot, GraphCommands, NodeGraphHandle } from "../react-flow/graphHandle";
+import type { FontFaceWire, GraphEventWire } from "./wire";
+/**
+ * The canvas options that are not knobs. JSON because they cross the bridge;
+ * every field optional because a host that sets none should still get the
+ * package's measured defaults, which live in `NodeGraphDomInner`.
+ */
+export interface NodeGraphDomOptions {
+    readonly readOnly?: boolean;
+    /** Touch surface: widens the port pitch and makes fields display-only. */
+    readonly coarsePointer?: boolean;
+    readonly onlyRenderVisibleElements?: boolean;
+    readonly fitView?: boolean;
+    readonly overviewZoom?: number;
+    /** Drop nodes and edges the schema does not know instead of refusing the document. */
+    readonly dropUnknownKinds?: boolean;
+    /**
+     * Arms design §7.3's long press INSIDE the WebView (milestone 6).
+     *
+     * A boolean and not a hook, because it has to cross the bridge. The gesture
+     * needs `.react-flow__pane`, which exists only in the DOM realm — the story
+     * that wired the interceptor to a HOST-tree ref could not mount on native at
+     * all (`View config getter callback for component 'div'`), and would not have
+     * reached the right element if it had.
+     *
+     * Arm / select / cancel come back as `{ t: "lasso" }` on the wire, with a
+     * haptic HINT on `arm`: a WebView cannot buzz and whether a buzz is right is
+     * the shell's call.
+     */
+    readonly longPressLasso?: boolean;
+    /**
+     * `pan` or `select`, design §7.3 — the toolbar's mode, crossing the bridge.
+     *
+     * It is a prop on `NodeGraphWeb` and was never in this options object, so on
+     * native the toolbar flipped its own label and the canvas never heard. MPO-212
+     * recorded the mode flip as proven on device from the READOUT; what a 190 pt
+     * drag then failed to do in select mode was therefore unexplained. It is
+     * explained: `panOnDrag` inside the WebView stayed `true`.
+     */
+    readonly interactionMode?: "pan" | "select";
+}
+export interface NodeGraphDomProps {
+    /**
+     * The serialized document. A STRING on purpose: one `JSON.parse` inside
+     * beats structured prop walking across the marshaller, and an identity check
+     * becomes a string compare.
+     */
+    readonly documentJson: string;
+    /** Monotonic, stamped by the host. See the echo gate in `wire.ts`. */
+    readonly rev: number;
+    readonly envelopeJson: string;
+    /** The schema is looked up by id: a `render` is a component and cannot be JSON. */
+    readonly schemaId: string;
+    readonly optionsJson: string;
+    readonly extraFaces?: readonly FontFaceWire[];
+    /** ONE channel. Adding an event never changes the bridge surface. */
+    readonly onEvent: (eventJson: string) => Promise<void>;
+    readonly dom?: DOMProps;
+    readonly ref?: Ref<NodeGraphDomHandle>;
+}
+/**
+ * Design §9.1's handle, DEFINED in `react-flow/graphHandle.ts` and re-exported
+ * here under its bridge name.
+ *
+ * It moved in milestone 6 because `NodeGraphWeb` now publishes the SAME handle
+ * through `graphRef` — one command surface on both platforms, so a story writes
+ * one toolbar — and a web build must not take an edge, even an erased one, to a
+ * module whose first import is `expo/dom`. The names here are unchanged, so
+ * `@multiplatform.one/node-graph/dom-inner` still exports exactly what it did.
+ */
+export type { GraphCommandSlot, GraphCommands, NodeGraphHandle } from "../react-flow/graphHandle";
+export type NodeGraphDomHandle = NodeGraphHandle;
+/** What the inner tree registers once React Flow is mounted and reachable. */
+export type GraphDomCommands = GraphCommands;
+export type GraphDomCommandSlot = GraphCommandSlot;
+/**
+ * What the APP's `'use dom'` entry supplies on top of the bridge props: the two
+ * things that are live objects rather than JSON, so the two things that can
+ * only arrive from a module the DOM bundle itself imports.
+ */
+export interface NodeGraphDomRealmProps<N extends NodeKindDefs = NodeKindDefs, E extends EdgeKindDefs = EdgeKindDefs> {
+    /**
+     * The app's `createTamagui` result. Without it `getConfig()` throws inside
+     * the WebView and the first Tamagui component dies with `Missing theme.` —
+     * which is exactly what milestone 2 died of before this prop existed.
+     */
+    readonly config?: TamaguiInternalConfig;
+    /**
+     * The schema BY VALUE, for the common app that has ONE.
+     *
+     * Kept beside `schemas` rather than folded into it: one schema is the common
+     * case, and making every consumer write a single-element array to say so
+     * would be ceremony charged to the majority.
+     */
+    readonly schema?: GraphSchema<N, E>;
+    /**
+     * Every schema this entry can render, looked up BY ID (milestone 6 device
+     * pass).
+     *
+     * A `render` is a `ComponentType`: it cannot be JSON, so it cannot cross the
+     * bridge, and the only string that does is `schemaId`. An entry that could
+     * supply exactly one schema was therefore an app that could show exactly one
+     * kind of canvas on device — measured on the iPhone 16e, where
+     * `NodeGraph/Perf200` → `Control` reported
+     * `render: no graph schema registered as "node-graph-demo-control"` and
+     * painted nothing, which left design §13.2's mandated plain-div control
+     * condition unmeasurable on every device.
+     *
+     * The inner tree builds an id-keyed registry out of this list and looks the
+     * inbound `schemaId` up in it. A schema whose id does not match is NEVER
+     * substituted: a silent substitution renders the wrong nodes instead of
+     * reporting anything, which is worse than a fallback that says what is
+     * missing. An app that would rather not thread a prop calls
+     * `registerGraphSchema` in a module its entry imports; the inner tree prefers
+     * that registry, so the two mechanisms compose rather than compete.
+     */
+    readonly schemas?: readonly GraphSchema<N, E>[];
+}
+export interface NodeGraphDomShellProps<N extends NodeKindDefs = NodeKindDefs, E extends EdgeKindDefs = EdgeKindDefs> extends NodeGraphDomProps, NodeGraphDomRealmProps<N, E> {
+}
+export interface NodeGraphDomInnerProps extends NodeGraphDomProps {
+    readonly commands: GraphDomCommandSlot;
+    readonly config?: TamaguiInternalConfig;
+    /** Erased at this boundary exactly as `registerGraphSchema` erases it. */
+    readonly schema?: GraphSchema<never, never>;
+    /** The same erasure, for the id-keyed list. */
+    readonly schemas?: readonly GraphSchema<never, never>[];
+}
+interface BoundaryProps {
+    readonly report: (event: GraphEventWire) => void;
+    readonly children?: ReactNode;
+}
+/**
+ * Design 9.4 layer 5's error boundary, and it is the only layer that can say
+ * WHAT went wrong.
+ *
+ * Measured on the iPhone 16e simulator: a render throw inside the canvas
+ * reached `window.onerror`, which reported the message `"Script error."` and
+ * nothing else. That is not a bug in the handler — a browser sanitises
+ * `onerror` to exactly that string when the throw came from a script loaded
+ * from a different origin than the document, and an Expo DOM component's
+ * `<script src>` is precisely that. So the host saw `phase: "runtime"`, kept
+ * the canvas (correctly, a runtime error is not fatal), the watchdog fired
+ * four seconds later, and the failure had no description anywhere.
+ *
+ * React hands the boundary the real Error object, so this one does. It lives
+ * in the ENTRY rather than the inner tree because the throw it exists to catch
+ * is the inner tree's own render, and a boundary inside the thing that throws
+ * catches nothing. A class component and `createElement`, importing only
+ * `react`, so the entry's "no top-level import of anything that can throw"
+ * invariant still holds.
+ */
+declare class GraphRenderBoundary extends Component<BoundaryProps, {
+    message: string | null;
+}> {
+    state: {
+        message: string | null;
+    };
+    static getDerivedStateFromError(error: unknown): {
+        message: string | null;
+    };
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    render(): ReactNode;
+}
+export declare function NodeGraphDomShell<N extends NodeKindDefs = NodeKindDefs, E extends EdgeKindDefs = EdgeKindDefs>(props: NodeGraphDomShellProps<N, E>): import("react").DetailedReactHTMLElement<{
+    "data-graph-boot-error": string;
+    role: "alert";
+}, HTMLElement> | import("react").CElement<BoundaryProps, GraphRenderBoundary> | null;
+//# sourceMappingURL=NodeGraphDomShell.d.ts.map

package/types/dom/NodeGraphDomShell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeGraphDomShell.d.ts","sourceRoot":"","sources":["../../src/dom/NodeGraphDomShell.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,OAAO,EAAE,SAAS,EAAuD,MAAM,OAAO,CAAC;AAEvF,OAAO,KAAK,EAAiB,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AACtE,OAAO,KAAK,EAAwB,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9E,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAClG,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAmB3D;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,yBAAyB,CAAC,EAAE,OAAO,CAAC;IAC7C,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,sFAAsF;IACtF,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC;;;;;;;;OAQG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC;CAC7C;AAED,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,sEAAsE;IACtE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,mFAAmF;IACnF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAC9C,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,kBAAkB,CAAC,CAAC;CACxC;AAED;;;;;;;;;GASG;AACH,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAClG,MAAM,MAAM,kBAAkB,GAAG,eAAe,CAAC;AACjD,8EAA8E;AAC9E,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAC7C,MAAM,MAAM,mBAAmB,GAAG,gBAAgB,CAAC;AAEnD;;;;GAIG;AACH,MAAM,WAAW,sBAAsB,CACrC,CAAC,SAAS,YAAY,GAAG,YAAY,EACrC,CAAC,SAAS,YAAY,GAAG,YAAY;IAErC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,qBAAqB,CAAC;IACxC;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACpC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;CACjD;AAED,MAAM,WAAW,sBAAsB,CACrC,CAAC,SAAS,YAAY,GAAG,YAAY,EACrC,CAAC,SAAS,YAAY,GAAG,YAAY,CAErC,SAAQ,iBAAiB,EAAE,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC;CAAG;AAE5D,MAAM,WAAW,sBAAuB,SAAQ,iBAAiB;IAC/D,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,MAAM,CAAC,EAAE,qBAAqB,CAAC;IACxC,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC5C,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC;CACzD;AAQD,UAAU,aAAa;IACrB,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;IACjD,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,cAAM,mBAAoB,SAAQ,SAAS,CAAC,aAAa,EAAE;IAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;IACpF,KAAK,EAAE;QAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAqB;IAEtD,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG;QAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;IAI3E,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS;IASjD,MAAM;CAUP;AAED,wBAAgB,iBAAiB,CAC/B,CAAC,SAAS,YAAY,GAAG,YAAY,EACrC,CAAC,SAAS,YAAY,GAAG,YAAY,EACrC,KAAK,EAAE,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC;;;sFA+HpC"}

package/types/dom/boot.d.ts

@@ -0,0 +1,90 @@
+/**
+ * The boot heartbeat, design 9.4 layer 3.
+ *
+ * `import.meta` in a dependency is a PARSE error in a classic script, so the
+ * script never executes, so no error boundary is reachable, so the WebView is a
+ * blank rectangle with no console the user can see. Layers 1 and 2 stop that
+ * one at build time. This layer answers the next question: when a WebView does
+ * come up empty, HOW FAR did it get?
+ *
+ * The record lives on `globalThis` rather than in a module-scoped variable
+ * because two different pieces of code write it. `NodeGraphDom.ts` stamps
+ * `script` INLINE — it cannot import this module, since the entry must carry no
+ * top-level import of ours that could itself throw — and the tree it then
+ * dynamic-imports stamps the rest through `stampBootStage`. A module variable
+ * would give those two separate records, and the fallback would report the
+ * emptier one.
+ *
+ * Everything here therefore treats the global as untrusted: a record another
+ * library clobbered, or the bare `{ stage: "script" }` the entry wrote with no
+ * history, both read back cleanly instead of throwing inside the error path.
+ */
+/** Design 9.4: `script -> module -> faces -> provider -> flow -> ready`. */
+export declare const bootStages: readonly ["script", "module", "faces", "provider", "flow", "ready"];
+/**
+ * How long the canvas waits for its own diagnostics to settle before stamping
+ * `ready` anyway (MPO-211).
+ *
+ * `ready` carries design 9.5's record, and two of its fields are unknowable at
+ * the instant the document parses: React Flow has not measured the pane, so
+ * with culling on no node body has mounted, and `GraphFaces` has not heard back
+ * from `document.fonts`. Emitting immediately reported `nodesMounted: 0` and
+ * every face `pending` on a canvas that was about to paint correctly.
+ *
+ * 1800 is `GraphFaces`' own 1500 ms asset-URL timeout plus a margin, so a face
+ * that falls back to base64 reports the fallback rather than being caught mid
+ * probe. It lives HERE rather than beside the canvas because the native
+ * watchdog has to be larger than it, and a watchdog that undercut this would
+ * declare a healthy canvas dead while it was still filling in its own panel.
+ */
+export declare const graphReadySettleMs = 1800;
+export type BootStage = (typeof bootStages)[number];
+export interface BootRecord {
+    readonly stage: BootStage;
+    /** `Date.now()` at the stamp, so diagnostics can show where boot spent its time. */
+    readonly at: number;
+    /**
+     * `Date.now()` when the record was CREATED — the first stamp of this attempt.
+     *
+     * `at - startedAt` is how long boot has taken, which is the number the native
+     * watchdog's budget has to be set from. Without it the 4000 ms of design
+     * 9.4 was a guess, and on emulator-5590 rebooted fresh it was the wrong one:
+     * the watchdog fired, the fallback blamed a parse error, and Retry rendered
+     * the canvas immediately (MPO-211).
+     */
+    readonly startedAt: number;
+    readonly history: readonly BootStage[];
+}
+/**
+ * The key `NodeGraphDom.ts` writes inline. Exported so `domEntry.spec.ts` can
+ * assert the entry's literal and this module's reader still name the same slot
+ * — the one place the two halves of the heartbeat could silently drift.
+ */
+export declare const bootGlobalKey = "__mp_graph_boot";
+export declare function bootStageIndex(stage: BootStage): number;
+/**
+ * The record as written, normalised. A raw `{ stage: "script" }` from the entry
+ * gains the history it never had; anything unrecognisable reads as `null`.
+ */
+export declare function readBootRecord(): BootRecord | null;
+/**
+ * Milliseconds since this attempt's first stamp, or `null` with no record.
+ *
+ * This is the measurement the native watchdog's budget is set from, and it is
+ * reported in design 9.5's panel so the budget can be re-set from a device
+ * rather than from a guess.
+ */
+export declare function readBootElapsedMs(now?: number): number | null;
+export declare function readBootStage(): BootStage | null;
+/**
+ * Record that boot reached `stage`, and return the stage the record now holds.
+ *
+ * Forward only. The watchdog's fallback names the last stage reached, so a
+ * stamp that could move the record backwards would understate how far boot got
+ * and point whoever reads it at the wrong layer. `script` is the one exception:
+ * Retry remounts the WebView under a new key, and boot genuinely starts over.
+ */
+export declare function stampBootStage(stage: BootStage): BootStage;
+/** Test seam, and what Retry calls before remounting. */
+export declare function resetBoot(): void;
+//# sourceMappingURL=boot.d.ts.map

package/types/dom/boot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot.d.ts","sourceRoot":"","sources":["../../src/dom/boot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,4EAA4E;AAC5E,eAAO,MAAM,UAAU,qEAAsE,CAAC;AAE9F;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAEvC,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAEpD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,oFAAoF;IACpF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;;;;;;;OAQG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,CAAC;CACxC;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,oBAAoB,CAAC;AAM/C,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAEvD;AAMD;;;GAGG;AACH,wBAAgB,cAAc,IAAI,UAAU,GAAG,IAAI,CAgBlD;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,MAAmB,GAAG,MAAM,GAAG,IAAI,CAIzE;AAED,wBAAgB,aAAa,IAAI,SAAS,GAAG,IAAI,CAEhD;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,CAmB1D;AAED,yDAAyD;AACzD,wBAAgB,SAAS,IAAI,IAAI,CAEhC"}