@multiplatform.one/node-graph 7.7.2

package/types/react-flow/fixtures.d.ts

@@ -0,0 +1,107 @@
+/**
+ * One schema and one document, shared by the two task-1.11 specs and the story.
+ *
+ * A fixture module rather than a copy in each file: the story is the thing a
+ * reviewer looks at, and a story that drifts from what the specs assert is a
+ * story that proves nothing about the code under test.
+ *
+ * `.ts`, no JSX, and no component values — `NodeKindSpec.render` is filled in
+ * by whoever mounts these, because the model half of the package must stay
+ * importable without React (design §3.1).
+ */
+import type { GraphDocument, GraphSchema, PortSpec } from "../model/index";
+import type { BuiltinEdgeData } from "../edges/edgeKinds";
+export type DemoNodeData = {
+    readonly source: {
+        readonly table: string;
+    };
+    readonly transform: {
+        readonly expression: string;
+    };
+    readonly sink: {
+        readonly target: string;
+    };
+};
+/**
+ * The schema WITHOUT its `render` components.
+ *
+ * Split out so `demoNodeBody.tsx` can supply real bodies over the same
+ * measures, ports and intents the model-only specs use. A second copy of the
+ * kind table is a second thing to keep in step.
+ */
+/**
+ * The id the package's OWN demo schema registers under.
+ *
+ * A named constant rather than a literal in two places, because it is the one
+ * string that crosses the bridge: `NodeGraphDomInner` matches on it to register
+ * this schema inside the DOM bundle, where a story cannot reach. See the note
+ * there — a schema's `render` is a component and cannot be JSON, so the only
+ * way a canvas gets one is a module the DOM bundle itself imports.
+ */
+export declare const demoGraphSchemaId = "node-graph-demo";
+/**
+ * The id the plain-div CONTROL schema registers under.
+ *
+ * Design §13.2 asks for a control condition in every measurement session so the
+ * Tamagui cost is measured rather than carried over from the web's ~10%. The
+ * control lived in `bench/Perf200.stories.tsx` until the m6 device pass, and a
+ * story runs on the Hermes side: only `schemaId` crosses the bridge, so on
+ * device the canvas looked the id up, missed, and reported
+ * `render: no graph schema registered as "node-graph-demo-control"`. The
+ * control condition was therefore unmeasurable on every device.
+ *
+ * It is a constant here, beside the schema it names, for the same reason the
+ * demo id is: it is a string two realms have to agree on.
+ */
+export declare const demoControlSchemaId = "node-graph-demo-control";
+export declare function demoSchemaShape(): {
+    id: string;
+    nodes: {
+        source: {
+            kind: "source";
+            ports: PortSpec[];
+            defaultData: {
+                table: string;
+            };
+            measure: {
+                width: number;
+                minHeight: number;
+            };
+        };
+        transform: {
+            kind: "transform";
+            ports: PortSpec[];
+            defaultData: {
+                expression: string;
+            };
+            measure: {
+                width: number;
+                minHeight: number;
+            };
+            intent: string;
+        };
+        sink: {
+            kind: "sink";
+            ports: PortSpec[];
+            defaultData: {
+                target: string;
+            };
+            measure: {
+                width: number;
+                minHeight: number;
+            };
+            intent: string;
+        };
+    };
+};
+export declare function demoSchema(): GraphSchema<DemoNodeData, BuiltinEdgeData>;
+type Doc = GraphDocument<DemoNodeData, BuiltinEdgeData>;
+/** Three nodes, one edge. Small enough that a failing assertion names a node. */
+export declare function demoDocument(): Doc;
+/**
+ * Twelve nodes and all four edge kinds — the `Main` story's graph, per design
+ * §12.1 ("the default editor, 12 nodes, all four edge kinds").
+ */
+export declare function demoDocumentLarge(count?: number): Doc;
+export {};
+//# sourceMappingURL=fixtures.d.ts.map

package/types/react-flow/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/react-flow/fixtures.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAG1D,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5C,QAAQ,CAAC,SAAS,EAAE;QAAE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;IACpD,QAAQ,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5C,CAAC;AAkBF;;;;;;GAMG;AACH;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,oBAAoB,CAAC;AAEnD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,4BAAiC,CAAC;AAElE,wBAAgB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6B9B;AAED,wBAAgB,UAAU,IAAI,WAAW,CAAC,YAAY,EAAE,eAAe,CAAC,CAYvE;AAED,KAAK,GAAG,GAAG,aAAa,CAAC,YAAY,EAAE,eAAe,CAAC,CAAC;AAExD,iFAAiF;AACjF,wBAAgB,YAAY,IAAI,GAAG,CAuBlC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,SAAK,GAAG,GAAG,CAkCjD"}

package/types/react-flow/flowAdapter.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Document → React Flow arrays. Pure, so the mapping can be asserted without
+ * mounting anything.
+ *
+ * Two things happen here that cannot happen later:
+ *
+ *  - **Size seeding (design §5).** Every node carries `width` / `height` from
+ *    `graphNodeMeasure` BEFORE first paint, so React Flow's per-node
+ *    `ResizeObserver` CORRECTS a measurement rather than discovering one. On a
+ *    200-node knob flip that is the difference between 200 observer callbacks
+ *    resizing the world and 200 confirming it.
+ *  - **The edge marker.** `markerEnd` on the edge OBJECT, because React Flow
+ *    builds its `<marker>` defs from the edges array. Choosing it inside the
+ *    edge component is too late — measured in task 1.10, where the arrowheads
+ *    painted and the lines did not.
+ */
+import type { EdgeKindDefs, GraphDocument, GraphSchema, NodeKindDefs, PortSpec } from "../model/index";
+import type { GraphNodeSizeKnob } from "../nodes/nodeMeasure";
+import type { Edge, Node } from "./xy";
+/**
+ * What the registered node component receives as `props.data`.
+ *
+ * A type ALIAS, not an interface. React Flow constrains node data to
+ * `Record<string, unknown>`, and TypeScript gives an alias an implicit index
+ * signature while an interface has none — so `interface GraphFlowNodeData`
+ * does not satisfy `Node<T>` and every call site needs a cast. Same rule that
+ * governs the kind maps in `edges/edgeKinds.ts`, and it bites the same way.
+ */
+export type GraphFlowNodeData = {
+    readonly kind: string;
+    /** The consumer's own node payload. */
+    readonly data: unknown;
+    readonly ports: readonly PortSpec[];
+    /** `NodeKindSpec.intent`, so a kind can carry a semantic colour. */
+    readonly intent?: string;
+    readonly locked?: boolean;
+};
+export interface FlowMappingOptions {
+    /** The resolved `size` knob; picks the per-kind measure row. */
+    readonly size: GraphNodeSizeKnob;
+    /** `portSpacing({ coarsePointer })`, so the height floor matches the paint. */
+    readonly portSpacingPx: number;
+    /** One React Flow node type name, registered by `NodeGraphWeb`. */
+    readonly nodeType: string;
+}
+export declare function toFlowNodes<N extends NodeKindDefs, E extends EdgeKindDefs>(document: GraphDocument<N, E>, schema: GraphSchema<N, E>, options: FlowMappingOptions): Node<GraphFlowNodeData>[];
+export declare function toFlowEdges<N extends NodeKindDefs, E extends EdgeKindDefs>(document: GraphDocument<N, E>, schema: GraphSchema<N, E>): Edge[];
+/**
+ * Carry React Flow's own transient node flags across a re-derive.
+ *
+ * `selected` and `dragging` live in React Flow's array, not in the document —
+ * selecting a node is not an edit. Re-deriving from the document would drop
+ * them, so a click would deselect itself the moment anything committed.
+ */
+export declare function preserveFlowState(next: Node<GraphFlowNodeData>[], previous: readonly Node<GraphFlowNodeData>[]): Node<GraphFlowNodeData>[];
+//# sourceMappingURL=flowAdapter.d.ts.map

package/types/react-flow/flowAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowAdapter.d.ts","sourceRoot":"","sources":["../../src/react-flow/flowAdapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EAGb,WAAW,EACX,YAAY,EACZ,QAAQ,EACT,MAAM,gBAAgB,CAAC;AAIxB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAEvC;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;IACpC,oEAAoE;IACpE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,MAAM,WAAW,kBAAkB;IACjC,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,+EAA+E;IAC/E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,mEAAmE;IACnE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,YAAY,EACxE,QAAQ,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC7B,MAAM,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EACzB,OAAO,EAAE,kBAAkB,GAC1B,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAE3B;AAgDD,wBAAgB,WAAW,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,YAAY,EACxE,QAAQ,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC7B,MAAM,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GACxB,IAAI,EAAE,CAER;AAqBD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,IAAI,CAAC,iBAAiB,CAAC,EAAE,EAC/B,QAAQ,EAAE,SAAS,IAAI,CAAC,iBAAiB,CAAC,EAAE,GAC3C,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAkB3B"}

package/types/react-flow/graphHandle.d.ts

@@ -0,0 +1,90 @@
+/**
+ * The imperative command surface, in a module NEITHER realm owns.
+ *
+ * Milestone 6's rule (design §9.1): a native consumer cannot put React children
+ * inside the canvas, so every control is either a native SIBLING driving the
+ * canvas through this handle, or it is rendered INSIDE the DOM bundle from
+ * serializable options. That makes the handle the load-bearing surface on both
+ * platforms, and it therefore may not live in `dom/`: `NodeGraphDomShell.ts`
+ * imports `expo/dom` at its top, and `NodeGraphWeb` — which now publishes the
+ * same handle through `graphRef` — must not carry that import into a web build
+ * even as an erased type edge.
+ *
+ * Every method returns void and takes JSON. That is not a style choice:
+ * `DOMImperativeFactory` is `{ [key: string]: (...args: JSONValue[]) => void }`,
+ * so an answer can only come back as an EVENT. `exportViewport`, `perfStop` and
+ * `relayout` each answer on the wire rather than by returning.
+ */
+/**
+ * Design §9.1's six, plus milestone 6's five.
+ *
+ * The five are here rather than on a second handle because a consumer holds one
+ * ref: a `perfStart` that lived somewhere else would be a second bridge, and
+ * the whole reason the wire is one channel is that a second one is a change to
+ * the bridge rather than to a type.
+ */
+export interface NodeGraphHandle {
+    fitView(): void;
+    /**
+     * Tidy. It emits `{ t: "layoutResult" }` when the engine answers.
+     *
+     * It was a documented NO-OP until milestone 6 — the comment said auto-layout
+     * was milestone 4 and the method was named early so the bridge surface would
+     * not have to change later. Milestone 4 then built the layout engine and
+     * never came back here, so `layoutRunner` read `none` on every device: not
+     * because the runner failed to resolve, but because nothing on a phone could
+     * ask it to run.
+     */
+    relayout(): void;
+    zoomTo(zoom: number): void;
+    centerOn(nodeId: string): void;
+    setSelection(ids: string[]): void;
+    exportViewport(): void;
+    undo(): void;
+    redo(): void;
+    /** Starts the frame sampler in the realm the canvas paints in. */
+    perfStart(label: string): void;
+    /** Stops it and emits `{ t: "perfReport" }`. */
+    perfStop(label: string): void;
+    /** Stamps an instant inside the run, so `relayoutGate` has a window to read. */
+    perfMark(label: string): void;
+    /**
+     * Puts the canvas at an exact viewport, with no animation.
+     *
+     * Five runs have to start from the same place or the median of five is the
+     * median of five experiments. `duration` is deliberately absent: an animated
+     * move is still moving when the sampler starts, and the first frames of every
+     * run would then measure the seek rather than the gesture.
+     */
+    setViewport(x: number, y: number, zoom: number): void;
+    /**
+     * A synthesised two-finger pinch, dispatched on the PANE — which is the
+     * element d3-zoom's touch listener is attached to, and which exists only in
+     * the realm the canvas paints in.
+     *
+     * It is here because the `mobile` MCP has no pinch verb at all (design
+     * §13.2), so on a device a pinch can only be produced from inside the
+     * WebView. That is also the technique that made the native spike's node-drag
+     * measurement unprovable, which is why a pinch row taken this way is reported
+     * SEPARATELY and flagged synthetic. On web the same row is taken with
+     * Chrome's own `Input.synthesizePinchGesture`, which is a browser-level
+     * gesture and a different thing.
+     */
+    synthPinch(scale: number, steps: number): void;
+}
+/** What the bridge component registers once the canvas is reachable. */
+export type GraphCommands = NodeGraphHandle;
+export interface GraphCommandSlot {
+    current: GraphCommands | null;
+}
+/**
+ * The command NAMES, as data.
+ *
+ * The two conditional types below are the compile-time half — a method added to
+ * `NodeGraphHandle` and not to this tuple, or a name here that is not a method,
+ * is a build error. It exists for the same reason `graphEventKinds` does: the
+ * shell has to forward every command by hand across `useDOMImperativeHandle`,
+ * and a forgotten one is a button that silently does nothing on a phone.
+ */
+export declare const graphCommandNames: readonly ["fitView", "relayout", "zoomTo", "centerOn", "setSelection", "exportViewport", "undo", "redo", "perfStart", "perfStop", "perfMark", "setViewport", "synthPinch"];
+//# sourceMappingURL=graphHandle.d.ts.map

package/types/react-flow/graphHandle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphHandle.d.ts","sourceRoot":"","sources":["../../src/react-flow/graphHandle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,OAAO,IAAI,IAAI,CAAC;IAChB;;;;;;;;;OASG;IACH,QAAQ,IAAI,IAAI,CAAC;IACjB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAClC,cAAc,IAAI,IAAI,CAAC;IACvB,IAAI,IAAI,IAAI,CAAC;IACb,IAAI,IAAI,IAAI,CAAC;IACb,kEAAkE;IAClE,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,gDAAgD;IAChD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B;;;;;;;OAOG;IACH,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACtD;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAChD;AAED,wEAAwE;AACxE,MAAM,MAAM,aAAa,GAAG,eAAe,CAAC;AAE5C,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,aAAa,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,4KAcpB,CAAC"}

package/types/react-flow/nodeCensus.d.ts

@@ -0,0 +1,42 @@
+/**
+ * How many node bodies React Flow actually has mounted, right now.
+ *
+ * WHY THIS EXISTS. Design §9.5's record calls the field `nodesMounted`, and
+ * until MPO-211 the DOM entry filled it with `document.nodes.length` — the
+ * number of nodes in the DOCUMENT, which is a different number whenever
+ * culling is on. On the demo document that is 12 against 10, and the gap is
+ * the whole reason AC 2.7's "renders 12 nodes" could not be read off a device
+ * screenshot: a panel reporting 12 while ten bodies are painted proves nothing
+ * about either number.
+ *
+ * So the two are reported separately now, and this module owns the harder one.
+ * `GraphNodeHost` is the ONE registered React Flow node type, so it mounts once
+ * per node React Flow decides to render and unmounts when culling drops one.
+ * Counting its instances counts exactly what is on screen, whatever body a
+ * consumer's schema renders — a DOM query for the package's own
+ * `data-graph-node` would miss a custom body, and a `.react-flow__node`
+ * selector is banned outside the token bridge (lint-conventions' GRAPH VARS
+ * COVERAGE).
+ *
+ * The register is a module global rather than React state because two
+ * different trees read it: the canvas's own diagnostics, and a story rendering
+ * `GraphDiagnostics` beside the canvas. It is per JS REALM, which is the right
+ * grain here — inside a WebView there is exactly one canvas, and that is the
+ * realm whose number crosses the bridge.
+ *
+ * `useSyncExternalStore` is the intended reader; `subscribeNodeCensus` and
+ * `mountedNodeCount` are its two halves.
+ */
+/**
+ * Count a mounted node body. Returns the release, so a caller's effect cleanup
+ * is the whole of the unregistration.
+ *
+ * Keyed by node id rather than counted, so React's mount → unmount → mount in
+ * StrictMode, and a double-invoked effect, cannot inflate the number.
+ */
+export declare function registerMountedNode(id: string): () => void;
+export declare function mountedNodeCount(): number;
+export declare function subscribeNodeCensus(listener: () => void): () => void;
+/** Test seam. Never called by the canvas — an unmount releases its own id. */
+export declare function resetNodeCensus(): void;
+//# sourceMappingURL=nodeCensus.d.ts.map

package/types/react-flow/nodeCensus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeCensus.d.ts","sourceRoot":"","sources":["../../src/react-flow/nodeCensus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AASH;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,IAAI,CAO1D;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAKpE;AAED,8EAA8E;AAC9E,wBAAgB,eAAe,IAAI,IAAI,CAGtC"}

package/types/react-flow/useGraphController.d.ts

@@ -0,0 +1,93 @@
+/**
+ * The controller: one document, one undo journal, and the four React Flow
+ * callbacks that keep them honest.
+ *
+ * The rule that shapes everything here: **mid-drag is not a document state.**
+ * React Flow emits a `position` change per animation frame, so a two-second
+ * drag is ~120 of them. Committing each one would fire `onDocumentChange` 120
+ * times, hand a consumer 120 autosaves, and bury the undo stack. So the live
+ * React Flow array moves on every frame (the drag has to look right) while the
+ * DOCUMENT moves once, when React Flow marks the last change `dragging: false`.
+ * `useGraphController.spec.tsx` pins that at 30 changes → 1 commit → 1 undo.
+ *
+ * Controlled and uncontrolled are the same code path with a different source of
+ * truth: `commit` always computes the next document and always calls
+ * `onDocumentChange`; it only WRITES to local state when uncontrolled. A
+ * controlled parent that ignores the callback simply sees nothing move, which
+ * is the behaviour every controlled React input has.
+ *
+ * Design: docs/design/node-graph-editor.md §4.5, §5.
+ */
+import type { ConnectionVerdict, EdgeKindDefs, GraphCommand, GraphDocument, GraphSchema, HistoryOptions, NodeKindDefs } from "../model/index";
+import type { NodeId, Size } from "../model/document";
+import type { LayoutRunnerKind } from "../diagnostics/types";
+import type { GraphLayoutOptions } from "../layout/layout";
+import type { LayoutResult } from "../layout/types";
+import type { GraphNodeSizeKnob } from "../nodes/nodeMeasure";
+import type { GraphFlowNodeData } from "./flowAdapter";
+import type { Connection, Edge, EdgeChange, Node, NodeChange } from "./xy";
+/** Test seam. A module-level dedupe set outlives a test file otherwise. */
+export declare function resetControllerWarnings(): void;
+export interface UseGraphControllerOptions<N extends NodeKindDefs, E extends EdgeKindDefs> {
+    readonly schema: GraphSchema<N, E>;
+    /** Controlled. Wins over `defaultDocument`, with a warning, when both are passed. */
+    readonly document?: GraphDocument<N, E>;
+    /** Uncontrolled seed. Read once, at mount. */
+    readonly defaultDocument?: GraphDocument<N, E>;
+    readonly onDocumentChange?: (document: GraphDocument<N, E>, command: GraphCommand<N, E>) => void;
+    /** Called when a DROP is refused, with the verdict `validateDrop` returned. */
+    readonly onConnectionRefused?: (verdict: ConnectionVerdict) => void;
+    /** Selection still works; nothing else commits. */
+    readonly readOnly?: boolean;
+    readonly history?: HistoryOptions;
+    /** The resolved `size` knob, for the node measure seed. */
+    readonly size?: GraphNodeSizeKnob;
+    /** Touch surface: widens the port pitch, which raises the node height floor. */
+    readonly coarsePointer?: boolean;
+    /** The React Flow node type name `NodeGraphWeb` registers. */
+    readonly nodeType?: string;
+    /**
+     * Reads the boxes React Flow has MEASURED, at the moment a relayout starts.
+     *
+     * A getter rather than a prop: measured sizes change on every observer
+     * callback, and holding 200 of them in state would re-render the canvas for
+     * a value only `relayout()` ever reads.
+     */
+    readonly readMeasuredSizes?: () => Readonly<Record<NodeId, Size>> | undefined;
+}
+export interface GraphController<N extends NodeKindDefs, E extends EdgeKindDefs> {
+    readonly document: GraphDocument<N, E>;
+    readonly nodes: Node<GraphFlowNodeData>[];
+    readonly edges: Edge[];
+    readonly onNodesChange: (changes: NodeChange[]) => void;
+    readonly onEdgesChange: (changes: EdgeChange[]) => void;
+    readonly onConnect: (connection: Connection) => void;
+    readonly isValidConnection: (connection: Connection | Edge) => boolean;
+    readonly commit: (command: GraphCommand<N, E>) => void;
+    readonly undo: () => void;
+    readonly redo: () => void;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    /**
+     * Tidy the graph. ONE `setPositions` command, one undo, design §8.
+     *
+     * Resolves with the engine's result even when nothing was committed (an
+     * empty document, `readOnly`, or a superseded generation), so a caller can
+     * report the runner and the ms without inferring them from a side effect.
+     * `null` means there was nothing to lay out.
+     */
+    readonly relayout: (options?: GraphRelayoutOptions) => Promise<LayoutResult | null>;
+    /** `none` until the first relayout has resolved a runner. */
+    readonly layoutRunner: LayoutRunnerKind;
+    /** Engine milliseconds of the last relayout. `null` before the first. */
+    readonly lastLayoutMs: number | null;
+    /** True from the call until its result has been applied. */
+    readonly layoutPending: boolean;
+}
+/** Everything `layout()` takes except the measure knobs, which the canvas owns. */
+export type GraphRelayoutOptions = Omit<GraphLayoutOptions, "size" | "coarsePointer">;
+export declare const defaultGraphNodeType = "mpGraphNode";
+export declare function useGraphController<N extends NodeKindDefs, E extends EdgeKindDefs>(options: UseGraphControllerOptions<N, E>): GraphController<N, E>;
+/** Applying a command without a controller — the model half, for a consumer. */
+export declare function applyGraphCommand<N extends NodeKindDefs, E extends EdgeKindDefs>(document: GraphDocument<N, E>, command: GraphCommand<N, E>): GraphDocument<N, E>;
+//# sourceMappingURL=useGraphController.d.ts.map

package/types/react-flow/useGraphController.d.ts.map

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

package/types/react-flow/xy.d.ts

@@ -0,0 +1,84 @@
+/**
+ * THE ONLY `@xyflow` import site in this package.
+ *
+ * `no-restricted-imports` in the repo's `oxlintrc.json` refuses `@xyflow/*`
+ * everywhere else under `public/node-graph/src`, so a React Flow major bump has
+ * exactly one reconciliation site instead of thirty. `xy.spec.ts` asserts every
+ * name below still resolves and that the installed version is inside the range
+ * `package.json` declares, so an upgrade fails CI rather than a user.
+ *
+ * The list is deliberately narrow. It is what the editor uses, not a mirror of
+ * upstream — a name nobody imports is a name nobody reconciles. Add one here
+ * (and to the spec's list) when a task actually needs it.
+ *
+ * Upgrade runbook: README.md.
+ *
+ * ONE name comes from `@xyflow/system` rather than `@xyflow/react`:
+ * `getHandlePosition`. React Flow does not re-export it (its own index re-lists
+ * `getBezierPath` and friends and stops there), and it is the function that
+ * turns a handle's measured BOX into the point an edge is drawn to — which is
+ * the whole reason the 44pt hit region is a pseudo-element and not element
+ * growth (design 7.1 H2). Asserting that law against our own reimplementation
+ * would prove nothing, so the spec calls the real one. `package.json` pins
+ * `@xyflow/system` to the exact version `@xyflow/react` pins, and `xy.spec.ts`
+ * fails if the two ever split.
+ */
+export { getHandlePosition } from "@xyflow/system";
+export type { Handle as HandleBounds, InternalNodeBase } from "@xyflow/system";
+export { applyEdgeChanges, applyNodeChanges, Background, BaseEdge, Controls, EdgeLabelRenderer, getBezierPath, getSmoothStepPath, getStraightPath, Handle, MarkerType, MiniMap, Position, ReactFlow, ReactFlowProvider, SelectionMode, useEdgesState, useNodesState, useReactFlow, useStore, useStoreApi, useUpdateNodeInternals, 
+/**
+ * The guide layer has to live INSIDE `.react-flow__viewport` so the pan and
+ * zoom transform applies to it for free (design §7.2 S10). This portal is the
+ * only supported way in; rendering a sibling and re-deriving the transform is
+ * how a guide ends up one frame behind the node it points at.
+ */
+ViewportPortal, } from "@xyflow/react";
+export type { ColorMode, Connection, Edge, EdgeChange, EdgeMarkerType, EdgeProps, EdgeTypes, HandleType, IsValidConnection, Node, NodeChange, NodeProps, NodeTypes, OnConnect, ReactFlowInstance, Viewport, XYPosition, } from "@xyflow/react";
+/**
+ * The installed React Flow version, as a plain string.
+ *
+ * Diagnostics has to report it (design §9.5) and only THIS file may reach
+ * `@xyflow`, so it is declared here rather than read at the use site. A literal
+ * rather than an import of `@xyflow/react/package.json`: that path is not in
+ * the package's exports map on every condition, and a bundler that cannot
+ * resolve it would take the whole canvas down to report a version string.
+ *
+ * `xy.spec.ts` asserts this equals the installed version, so it cannot drift
+ * from reality — an upgrade that forgets it fails CI rather than a user.
+ */
+export declare const xyflowVersion = "12.11.5";
+/**
+ * The class React Flow puts on its pane element.
+ *
+ * A class name is part of @xyflow's DOM contract exactly as its exported
+ * symbols are, so it belongs at the same boundary they do. The long press has
+ * to FIND the pane to listen on it (`useLassoSelect.ts`) — that is a DOM
+ * lookup, not a paint rule, and a paint rule is what `checkGraphVarsCoverage`
+ * exists to keep out of `src`. Hardcoding the string at the call site would
+ * have been the wrong kind of coupling either way: when an upgrade renames the
+ * class, a `querySelector` returns null and the long press dies in silence, so
+ * the rename should have exactly one place to land.
+ */
+export declare const reactFlowPaneSelector = ".react-flow__pane";
+/**
+ * The class React Flow puts on a node element. Same boundary rule as
+ * `reactFlowPaneSelector`, and for the same reason: it is a DOM lookup, not a
+ * paint rule, and a rename should have exactly one place to land.
+ *
+ * The lookup this exists for is `NodeGraph/AutoLayout`'s position stamp, which
+ * reads each node's CSS `transform` — React Flow places a node with a
+ * transform and never with a layout offset, so `offsetLeft` / `offsetTop` are
+ * 0 at every arrangement and a stamp built on them is a constant.
+ */
+export declare const reactFlowNodeSelector = ".react-flow__node";
+/**
+ * The class React Flow puts on the pan/zoom viewport — the ONE element whose
+ * transform carries the whole canvas.
+ *
+ * Same boundary rule as the pane and node selectors. The frame sampler's
+ * `didMove` probe (design §13.2) reads this transform to tell a real pan from
+ * an idle page, and a rename that silently returned `null` there would turn
+ * every perf run into a discarded one with no explanation.
+ */
+export declare const reactFlowViewportSelector = ".react-flow__viewport";
+//# sourceMappingURL=xy.d.ts.map

package/types/react-flow/xy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xy.d.ts","sourceRoot":"","sources":["../../src/react-flow/xy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EAAE,MAAM,IAAI,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAE/E,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,MAAM,EACN,UAAU,EACV,OAAO,EACP,QAAQ,EACR,SAAS,EACT,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,aAAa,EACb,YAAY,EACZ,QAAQ,EACR,WAAW,EACX,sBAAsB;AACtB;;;;;GAKG;AACH,cAAc,GACf,MAAM,eAAe,CAAC;AAEvB,YAAY,EACV,SAAS,EACT,UAAU,EACV,IAAI,EACJ,UAAU,EACV,cAAc,EACd,SAAS,EACT,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,IAAI,EACJ,UAAU,EACV,SAAS,EACT,SAAS,EACT,SAAS,EACT,iBAAiB,EACjB,QAAQ,EACR,UAAU,GACX,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,YAAY,CAAC;AAEvC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,sBAAsB,CAAC;AAEzD;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,sBAAsB,CAAC;AAEzD;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,0BAA0B,CAAC"}

package/types/theme/GraphFaces.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Gets the `$body` face into the WebView, asset URL first, bytes second.
+ *
+ * Design §6.3's two mechanisms, in the order it names them:
+ *
+ *  1. **Asset URL.** A consumer hands in the URL Expo produced from a
+ *     `require()` of the face. Nothing rides in the bundle for that face.
+ *  2. **Inline base64.** Whatever the first path did not deliver, this does.
+ *     Proven, and the reason `faces.generated.ts` exists.
+ *
+ * The switch between them is not a guess. `document.fonts.load` is awaited and
+ * `document.fonts.check` is read back, so a URL that 404s inside the WebView —
+ * the exact failure that makes the primary path unverified on device — demotes
+ * that face to its bytes instead of leaving the canvas in a fallback family
+ * nobody notices.
+ *
+ * IMPORTING THIS PULLS THE PAYLOAD. `faces.generated.ts` is ~200 KB of base64
+ * and this module's default argument references it, so a consumer that already
+ * registers Inter (every web app in this repo does, through Tamagui) should not
+ * mount `GraphFaces` at all. The DOM bundle is who it is for.
+ *
+ * Design: docs/design/node-graph-editor.md §6.3.
+ */
+import { type ReactNode } from "react";
+import { type GraphFaceAsset } from "./faces";
+/** Which of the two mechanisms actually delivered a face. */
+export type GraphFaceSource = "asset" | "inline" | "pending" | "failed";
+/** Per-face outcome, for the diagnostics panel and the `FontProof` story. */
+export interface GraphFaceStatus {
+    readonly id: string;
+    readonly family: string;
+    readonly weight: number;
+    readonly source: GraphFaceSource;
+}
+export interface GraphFacesProps {
+    /** Defaults to the generated payload. */
+    readonly faces?: readonly GraphFaceAsset[];
+    /**
+     * `require()`d asset URLs by face id. A face named here is tried from its URL
+     * first; a face absent here goes straight to its bytes.
+     */
+    readonly assetUris?: Readonly<Record<string, string>>;
+    /**
+     * How long to wait for the asset URL before falling back, in ms.
+     *
+     * 1500, well inside the native watchdog's 4000 ms (design §9.4 layer 4), so a
+     * slow face degrades to base64 rather than letting the whole WebView be
+     * declared dead.
+     */
+    readonly timeoutMs?: number;
+    readonly onStatus?: (statuses: readonly GraphFaceStatus[]) => void;
+}
+/**
+ * Resolves each face to the mechanism that actually delivered it.
+ *
+ * Returns the URIs still worth honouring, so the sheet re-renders with base64
+ * for the ones that did not answer.
+ */
+export declare function useGraphFaces(faces: readonly GraphFaceAsset[], assetUris: Readonly<Record<string, string>> | undefined, timeoutMs: number): {
+    readonly uris: Readonly<Record<string, string>>;
+    readonly statuses: readonly GraphFaceStatus[];
+};
+/**
+ * The `@font-face` sheet, plus the asset-URL-first resolution behind it.
+ *
+ * Renders NOTHING where there is no DOM, and that is not defensive coding — it
+ * is the component being honest about what it is. This is a `<style>` element
+ * and nothing else; `<style>` is a browser intrinsic, and React Native answers a
+ * lowercase intrinsic it does not know with
+ * `View config getter callback for component "style" must be a function`, which
+ * takes the whole tree down. Measured on the iPhone 16e at task 2.7: the
+ * `NodeGraph/GraphNode` → `FontProof` story mounts this directly and died
+ * exactly there, on a device where the story's own error boundary was the only
+ * thing between it and a blank screen.
+ *
+ * The hooks run either way, so the rules of hooks hold and the status callback
+ * still fires; only the element is withheld. A caller on native gets `null` and
+ * should read `GraphDiagnostics`, where the probe that ran INSIDE the WebView
+ * arrives over the `ready` event.
+ */
+export declare function GraphFaces({ faces, assetUris, timeoutMs, onStatus, }: GraphFacesProps): ReactNode;
+//# sourceMappingURL=GraphFaces.d.ts.map

package/types/theme/GraphFaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphFaces.d.ts","sourceRoot":"","sources":["../../src/theme/GraphFaces.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,KAAK,SAAS,EAAgC,MAAM,OAAO,CAAC;AACrE,OAAO,EAAE,KAAK,cAAc,EAAgB,MAAM,SAAS,CAAC;AAG5D,6DAA6D;AAC7D,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;AAExE,6EAA6E;AAC7E,MAAM,WAAW,eAAe;IAC9B,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,eAAe,CAAC;CAClC;AAED,MAAM,WAAW,eAAe;IAC9B,yCAAyC;IACzC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtD;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,KAAK,IAAI,CAAC;CACpE;AAuBD;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,SAAS,cAAc,EAAE,EAChC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,EACvD,SAAS,EAAE,MAAM,GAChB;IACD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAChD,QAAQ,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAC;CAC/C,CAqFA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,EACzB,KAA2B,EAC3B,SAAS,EACT,SAAgB,EAChB,QAAQ,GACT,EAAE,eAAe,GAAG,SAAS,CAe7B"}

package/types/theme/GraphVarsStyle.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The var layer as one `<style>` tag, plus the adapter that reads a live
+ * Tamagui theme into `GraphThemeAccess`.
+ *
+ * Design 6.2 names this file `GraphVars.tsx`, next to `graphVars.ts`. Those two
+ * are the SAME module specifier on a case-insensitive filesystem, and the
+ * resolver's extension order (.ts before .tsx) means `import … from
+ * "./GraphVars"` silently returns `graphVars.ts` — measured on macOS, where
+ * `head ./GraphVars.ts` prints the pure module. The COMPONENT keeps its design
+ * name; only the file gains a suffix, so `graphVars.ts` and the lint check's
+ * exemption path are unchanged.
+ *
+ * Design: docs/design/node-graph-editor.md 6.2.
+ */
+import { type ReactNode } from "react";
+import type { ResolvedKnobs } from "@multiplatform.one/theme";
+import { type GraphCssVarsOptions, type GraphThemeAccess } from "./graphVars";
+/**
+ * The class the graph root carries; every rule in `css/graph.css` is scoped to it.
+ *
+ * `mp-graph`, not `mp-graph-root`: design 7.1 and 7.5 write the selectors as
+ * `.mp-graph .react-flow__handle` and `.mp-graph .react-flow__pane`, and the
+ * port rules landed by task 1.9 use that prefix. One name, and it is the
+ * design's. Nothing outside this constant may spell it.
+ */
+export declare const graphRootClassName = "mp-graph";
+export interface GraphVarsProps {
+    /** The `--xy-*` / `--mpo-graph-*` layer, from `graphCssVars` or straight off the envelope. */
+    readonly vars: Readonly<Record<string, string>>;
+    readonly scheme: "light" | "dark";
+    /**
+     * The envelope's revision. The sheet is rebuilt on THIS and nothing else:
+     * `vars` is derived from the envelope, so its revision is the authority on
+     * whether anything moved, and a fresh `vars` object identity on every render
+     * would otherwise re-serialize the whole sheet at 60 Hz during a drag.
+     * `graphCss.spec.ts` pins that behaviour rather than leaving it as a comment.
+     */
+    readonly revision: number;
+    /** Scope selector. Defaults to the graph root class. */
+    readonly selector?: string;
+}
+/** A CSS custom-property block, deterministic in key order so a diff is readable. */
+export declare function graphVarsSheet(vars: Readonly<Record<string, string>>, scheme: "light" | "dark", selector: string): string;
+export declare function GraphVars({ vars, scheme, revision, selector }: GraphVarsProps): ReactNode;
+/**
+ * Read a live Tamagui theme into the two forms `graphCssVars` needs.
+ *
+ * The CSS form comes from the Variable itself (`var(--…)` on web) rather than
+ * from a reconstructed prefix, so nothing here has to know how Tamagui names
+ * its custom properties. The raw form is the literal value, and is used only by
+ * the two blended entries.
+ */
+export declare function useGraphThemeAccess(): GraphThemeAccess;
+/** `graphCssVars` against the live theme. */
+export declare function useGraphCssVars(resolved: ResolvedKnobs, options?: GraphCssVarsOptions): Record<string, string>;
+//# sourceMappingURL=GraphVarsStyle.d.ts.map