@multiplatform.one/node-graph 7.7.2

package/types/model/schema.d.ts

@@ -0,0 +1,136 @@
+/**
+ * The schema, design §4.3.
+ *
+ * The union of node and edge kinds is generic over consumer-supplied kind maps.
+ * No declaration merging, no global mutable registry of TYPES — `edge.kind ===
+ * "error"` narrows `edge.data` because `E` says so, not because a `.d.ts`
+ * somewhere was merged into.
+ *
+ * `react` appears here as a TYPE-ONLY import. It is erased, so the model still
+ * carries no React at runtime, which is what `dom/importGraph.spec.ts` checks
+ * and what lets a server or the CI bench import `@multiplatform.one/node-graph/model`.
+ */
+import type { ComponentType } from "react";
+import type { DocumentSchema, EdgeKindDefs, GraphNodeOf, NodeId, NodeKindDefs, PortId } from "./document";
+import type { ConnectionRule, DropOnlyRule } from "./connect";
+export interface PortSpec {
+    readonly id: PortId;
+    readonly side: "left" | "right" | "top" | "bottom";
+    readonly direction: "in" | "out";
+    readonly index?: number;
+    readonly label?: string;
+    /** Consumer-defined payload type name; connection rules read it. */
+    readonly dataType?: string;
+    /** Default: "many" on out, "one" on in. */
+    readonly arity?: "one" | "many";
+}
+/** Default arity, spelled once so the rules and the docs cannot drift apart. */
+export declare function portArity(port: PortSpec): "one" | "many";
+export interface GraphNodeRenderProps<TData> {
+    readonly id: NodeId;
+    readonly data: TData;
+    readonly selected: boolean;
+    readonly dragging: boolean;
+    /**
+     * "overview" below `overviewZoom`. On the prop type from v1 on purpose: it is
+     * what stops the merged single-path edge layer being a breaking change for
+     * every custom node in v1.1 (design §5).
+     */
+    readonly renderMode: "detail" | "overview";
+    /** true on a touch surface: fields are display-only, taps route to the sheet. */
+    readonly readOnlyFields: boolean;
+    readonly ports: readonly PortSpec[];
+    /**
+     * The kind's own `NodeKindSpec.measure`.
+     *
+     * On the render props because the canvas seeds React Flow from it before
+     * first paint (design §5) and the BODY has to paint the same number. Without
+     * it a kind declaring a non-default width was seeded at one width and painted
+     * at the per-size default — measured in the MPO-191 knob fuzz, where a 240px
+     * kind painted 172 / 190 / 216.
+     */
+    readonly measure: {
+        readonly width: number;
+        readonly minHeight: number;
+    };
+    readonly setData: (patch: Partial<TData>) => void;
+}
+/**
+ * A field the native inspector edits. The widget set is milestone 2's to settle
+ * — this is the minimum `NodeKindSpec.fields` needs to exist.
+ */
+export interface GraphNodeField {
+    readonly key: string;
+    readonly label?: string;
+    readonly type: "text" | "number" | "boolean" | "select";
+    readonly options?: readonly {
+        readonly value: string;
+        readonly label: string;
+    }[];
+}
+export interface NodeKindSpec<TData> {
+    readonly kind: string;
+    readonly render: ComponentType<GraphNodeRenderProps<TData>>;
+    /** May be a function of data, so a switch node grows outputs without a new kind. */
+    readonly ports: readonly PortSpec[] | ((data: TData) => readonly PortSpec[]);
+    readonly defaultData: TData;
+    /** Width is fixed per kind; height is knob-driven and re-measured. */
+    readonly measure: {
+        readonly width: number;
+        readonly minHeight: number;
+    };
+    readonly intent?: string;
+    /** Fields the native inspector edits. Absent means no inspector. */
+    readonly fields?: readonly GraphNodeField[];
+}
+export interface EdgeKindSpec<TData> {
+    readonly kind: string;
+    readonly defaultData: TData;
+    /**
+     * Which painted appearance this kind draws as — one of the four in
+     * `src/edges/edgeKinds.ts`. A NAME, not a style: the model stays free of
+     * rendering, and one registered React Flow edge type switches on it.
+     * Absent falls back to the kind's own name.
+     */
+    readonly appearance?: string;
+}
+export interface GraphSchema<N extends NodeKindDefs, E extends EdgeKindDefs> extends DocumentSchema<N, E> {
+    readonly id: string;
+    readonly nodes: {
+        readonly [K in keyof N & string]: NodeKindSpec<N[K]>;
+    };
+    readonly edges: {
+        readonly [K in keyof E & string]: EdgeKindSpec<E[K]>;
+    };
+    /** The pointer-tick rules. `refuseCycle` cannot go here; that is a type. */
+    readonly rules: readonly ConnectionRule<N, E>[];
+    /** Rules that run once, on drop. */
+    readonly dropRules: readonly DropOnlyRule<N, E>[];
+}
+export interface GraphSchemaSpec<N extends NodeKindDefs, E extends EdgeKindDefs> {
+    readonly id: string;
+    readonly nodes: {
+        readonly [K in keyof N & string]: NodeKindSpec<N[K]>;
+    };
+    readonly edges: {
+        readonly [K in keyof E & string]: EdgeKindSpec<E[K]>;
+    };
+    readonly rules?: readonly ConnectionRule<N, E>[];
+    readonly dropRules?: readonly DropOnlyRule<N, E>[];
+}
+export declare function createGraphSchema<N extends NodeKindDefs, E extends EdgeKindDefs>(spec: GraphSchemaSpec<N, E>): GraphSchema<N, E>;
+/**
+ * `schema.id` is what crosses the bridge. A `render` is a `ComponentType` and
+ * cannot be JSON, so schemas register by id in a module BOTH the native screen
+ * and the DOM entry import. That constraint is what keeps nodes Tamagui: the
+ * body is written once, in the consumer's package, and renders inside the
+ * WebView against the real config, theme and hook.
+ */
+export declare function registerGraphSchema<N extends NodeKindDefs, E extends EdgeKindDefs>(schema: GraphSchema<N, E>): void;
+export declare function getGraphSchema(id: string): GraphSchema<never, never> | undefined;
+/** Test seam. Registering the same id twice is legal; leaking between specs is not. */
+export declare function clearGraphSchemas(): void;
+export declare function nodeKindSpec<N extends NodeKindDefs, E extends EdgeKindDefs>(schema: GraphSchema<N, E>, kind: string): NodeKindSpec<unknown> | undefined;
+/** Resolves a node's ports, calling the `ports` function when the kind uses one. */
+export declare function resolvePorts<N extends NodeKindDefs, E extends EdgeKindDefs>(schema: GraphSchema<N, E>, node: GraphNodeOf<N>): readonly PortSpec[];
+//# sourceMappingURL=schema.d.ts.map

package/types/model/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/model/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,WAAW,EACX,MAAM,EACN,YAAY,EACZ,MAAM,EACP,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9D,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,CAAC;IACnD,QAAQ,CAAC,SAAS,EAAE,IAAI,GAAG,KAAK,CAAC;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,2CAA2C;IAC3C,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;CACjC;AAED,gFAAgF;AAChF,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,GAAG,KAAK,GAAG,MAAM,CAExD;AAED,MAAM,WAAW,oBAAoB,CAAC,KAAK;IACzC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC3C,iFAAiF;IACjF,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;IACpC;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IACzE,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;CACnD;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;IACxD,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAClF;AAED,MAAM,WAAW,YAAY,CAAC,KAAK;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAC;IAC5D,oFAAoF;IACpF,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,KAAK,SAAS,QAAQ,EAAE,CAAC,CAAC;IAC7E,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;IAC5B,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IACzE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,oEAAoE;IACpE,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CAC7C;AAED,MAAM,WAAW,YAAY,CAAC,KAAK;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,WAAW,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,YAAY,CAAE,SAAQ,cAAc,CACjG,CAAC,EACD,CAAC,CACF;IACC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KAAE,CAAC;IACzE,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KAAE,CAAC;IACzE,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;IAChD,oCAAoC;IACpC,QAAQ,CAAC,SAAS,EAAE,SAAS,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;CACnD;AAED,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,YAAY;IAC7E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KAAE,CAAC;IACzE,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KAAE,CAAC;IACzE,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;IACjD,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;CACpD;AAED,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,YAAY,EAC9E,IAAI,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,GAC1B,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAQnB;AAID;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,YAAY,EAChF,MAAM,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GACxB,IAAI,CAEN;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,SAAS,CAEhF;AAED,uFAAuF;AACvF,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAED,wBAAgB,YAAY,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,YAAY,EACzE,MAAM,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EACzB,IAAI,EAAE,MAAM,GACX,YAAY,CAAC,OAAO,CAAC,GAAG,SAAS,CAEnC;AAED,oFAAoF;AACpF,wBAAgB,YAAY,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,YAAY,EACzE,MAAM,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EACzB,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,GACnB,SAAS,QAAQ,EAAE,CAIrB"}

package/types/model/select.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Marquee selection and union bounds, design §12.2.
+ *
+ * Rects come in, ids come out. No document, no schema, no sizes guessed —
+ * `nodeRects` is the one place that turns a document into rects, and it takes
+ * the measurer as an argument, because a node's height is knob-driven and only
+ * the renderer knows it.
+ */
+import type { EdgeKindDefs, GraphDocument, NodeId, NodeKindDefs, Rect, Size } from "./document";
+/**
+ * "partial" selects anything the marquee overlaps; "full" only what it fully
+ * contains. React Flow calls these `SelectionMode.Partial` / `.Full`.
+ */
+export type MarqueeMode = "partial" | "full";
+export interface NodeRect {
+    readonly id: NodeId;
+    readonly rect: Rect;
+}
+/**
+ * Touching edges do not overlap. A marquee whose left edge sits exactly on a
+ * node's right edge has covered zero of it, and a brush that swept it up would
+ * select a node the user can see it never touched.
+ */
+export declare function rectsOverlap(a: Rect, b: Rect): boolean;
+/** Inclusive: a rect contains itself. */
+export declare function rectContains(outer: Rect, inner: Rect): boolean;
+/** Input order is preserved, so a selection is stable between two identical drags. */
+export declare function selectInMarquee(nodes: readonly NodeRect[], marquee: Rect, mode: MarqueeMode): readonly NodeId[];
+/**
+ * `undefined` for an empty selection, not a zero rect at the origin — 0,0 is a
+ * real position, and a toolbar centring on it would jump the viewport every
+ * time the selection emptied.
+ */
+export declare function unionBounds(rects: readonly Rect[]): Rect | undefined;
+/**
+ * A node's `size` is seeded from `NodeKindSpec.measure` plus resolved knobs
+ * before first paint (design §5), but a document loaded from JSON may carry no
+ * size at all, so `measure` is the fallback rather than a guess baked in here.
+ */
+export declare function nodeRects<N extends NodeKindDefs, E extends EdgeKindDefs>(doc: GraphDocument<N, E>, measure: (kind: string) => Size): readonly NodeRect[];
+//# sourceMappingURL=select.d.ts.map

package/types/model/select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../src/model/select.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEhG;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,MAAM,CAAC;AAE7C,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAEtD;AAED,yCAAyC;AACzC,wBAAgB,YAAY,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,GAAG,OAAO,CAO9D;AAED,sFAAsF;AACtF,wBAAgB,eAAe,CAC7B,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,OAAO,EAAE,IAAI,EACb,IAAI,EAAE,WAAW,GAChB,SAAS,MAAM,EAAE,CAGnB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,GAAG,SAAS,CAapE;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,YAAY,EACtE,GAAG,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EACxB,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAC9B,SAAS,QAAQ,EAAE,CAQrB"}

package/types/model/serialize.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Serialization, design §4.6.
+ *
+ * Two properties carry the weight. `parseDocument` NEVER throws: a corrupt
+ * document renders an `EmptyState`, never a blank WebView, and on native there
+ * is no console to find the exception in. And the output is canonical —
+ * geometry rounded to 2 dp, document keys in a declared order, consumer payload
+ * keys sorted — so the same graph saved twice produces the same bytes and a
+ * change is a readable diff rather than a whole-file rewrite.
+ */
+import type { DocumentProblem, DocumentSchema, EdgeKindDefs, GraphDocument, NodeKindDefs, Result } from "./document";
+export interface ParseOptions {
+    /**
+     * Drop nodes and edges whose kind the schema does not know, instead of
+     * refusing the document. For a read-only viewer that would rather show most
+     * of the graph than nothing. Edges left dangling by a dropped node are
+     * dropped with it — a graph with an edge pointing at nothing is not a
+     * partial render, it is a broken one.
+     */
+    readonly dropUnknownKinds?: boolean;
+}
+/**
+ * Emits the document's own keys in a declared order and everything below them
+ * canonically. `JSON.stringify` walks insertion order, so the order below IS
+ * the format.
+ */
+export declare function serializeDocument<N extends NodeKindDefs, E extends EdgeKindDefs>(doc: GraphDocument<N, E>): string;
+/**
+ * Never throws. Every path out of this function is a `Result`, including the
+ * one where something below it does throw.
+ */
+export declare function parseDocument<N extends NodeKindDefs, E extends EdgeKindDefs>(raw: string | unknown, schema: DocumentSchema<N, E>, options?: ParseOptions): Result<GraphDocument<N, E>, readonly DocumentProblem[]>;
+//# sourceMappingURL=serialize.d.ts.map

package/types/model/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/model/serialize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,YAAY,EACZ,aAAa,EAIb,YAAY,EACZ,MAAM,EAIP,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,YAAY;IAC3B;;;;;;OAMG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CACrC;AAkCD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,YAAY,EAC9E,GAAG,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,GACvB,MAAM,CAoCR;AAoFD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,YAAY,EAC1E,GAAG,EAAE,MAAM,GAAG,OAAO,EACrB,MAAM,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,EAC5B,OAAO,GAAE,YAAiB,GACzB,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC,CAiBzD"}

package/types/native/DomOnlyStory.d.ts

@@ -0,0 +1,49 @@
+/**
+ * What a DOM-only story draws on Hermes (milestone 6, task 6.8).
+ *
+ * Some stories in this package are about the DOM and nothing else: a `<span>`
+ * with a corrupted font stack, a `<style>` element, a React Flow `Handle` — a
+ * `div` — mounted OUTSIDE a canvas so the port can be seen off it. React Native
+ * answers a lowercase intrinsic it does not know with `View config getter
+ * callback for component "div" must be a function` and takes the whole tree
+ * down, so on the Kitchen Sink those stories were a red box. Measured on the
+ * iPhone 16e at MPO-211 and again on MPO-212's device pass.
+ *
+ * A red box is the worst of the three possible outcomes. It looks like a defect
+ * in the thing being demonstrated, it hides which stories actually work, and it
+ * teaches a reader nothing about where the answer IS. `FontProof` had already
+ * solved this by hand — it draws a sentence naming `NodeGraph → Diagnostics →
+ * Live`, where the probe that ran inside the WebView is rendered. This is that
+ * guard, extracted, so the next DOM-only story costs one decorator instead of
+ * twenty lines.
+ *
+ * `hasDomRealm` is a `document` check and not a `Platform.OS` check on purpose:
+ * `react-native` is an OPTIONAL peer of this package, and a story file must not
+ * be the thing that makes it required. It is also the more honest question —
+ * what these stories need is a DOM, and a DOM is exactly what is being tested
+ * for.
+ */
+/** True in a browser and inside the canvas's WebView; false on Hermes. */
+export declare const hasDomRealm: boolean;
+export interface DomOnlyStoryProps {
+    /** What this story needs a DOM for, in a clause. */
+    readonly needs: string;
+    /** Where the same thing CAN be read on device. A story title, not a URL. */
+    readonly readInstead?: string;
+}
+/**
+ * One line, not an error.
+ *
+ * Every style is a whole `knobProps.*` fragment spread (AGENTS.md); nothing here
+ * cherry-picks a resolved token and nothing here is a literal.
+ */
+export declare function DomOnlyStory({ needs, readInstead }: DomOnlyStoryProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * A Storybook decorator, so guarding a whole file is one line in its `meta`.
+ *
+ * It replaces the story rather than wrapping it: the point is that the tree
+ * below must never be constructed, and a wrapper that rendered its child and
+ * then apologised would still have thrown on the way.
+ */
+export declare function domOnlyStoryDecorator(props: DomOnlyStoryProps): (Story: () => React.ReactElement) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DomOnlyStory.d.ts.map

package/types/native/DomOnlyStory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomOnlyStory.d.ts","sourceRoot":"","sources":["../../src/native/DomOnlyStory.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAKH,0EAA0E;AAC1E,eAAO,MAAM,WAAW,SAA6C,CAAC;AAEtE,MAAM,WAAW,iBAAiB;IAChC,oDAAoD;IACpD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,4EAA4E;IAC5E,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE,iBAAiB,2CAcrE;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,iBAAiB,IACpD,OAAO,MAAM,KAAK,CAAC,YAAY,6CAExC"}

package/types/native/GraphFallback.native.d.ts

@@ -0,0 +1,41 @@
+/**
+ * What the user sees instead of a blank rectangle.
+ *
+ * Design 9.4 layer 4. The WebView failed, and the one thing worth knowing is
+ * HOW FAR it got: `script` means the bundle parsed and nothing else ran,
+ * `module` means the tree failed to evaluate, `flow` means React Flow mounted
+ * and never painted. Each sends a reader to a different layer, and a spinner
+ * that never resolves sends them nowhere.
+ *
+ * Built from `tamagui` and the real `useResolvedKnobs`, deliberately NOT from
+ * `@multiplatform.one/components`' `EmptyState`: components is an OPTIONAL
+ * peer, and a fallback that cannot render because its own dependency is absent
+ * is not a fallback. The rest of the native shell — toolbar, sheet, inspector —
+ * may use components freely.
+ *
+ * Every style comes from a whole `knobProps.*` fragment spread (AGENTS.md);
+ * nothing here cherry-picks a resolved token and nothing here is a literal.
+ */
+import type { BootStage } from "../dom/boot";
+export type GraphFallbackReason = "no-ready" | "no-dom-entry" | "module" | "render" | "runtime";
+export interface GraphFallbackProps {
+    /** Whether ANY event arrived from the canvas. A stage-less failure reads differently either way. */
+    readonly started?: boolean;
+    readonly reason: GraphFallbackReason;
+    /** The last stage the WebView stamped, or `null` if it never stamped one. */
+    readonly stage?: BootStage | null;
+    readonly message?: string;
+    /** The watchdog budget that ran out, so the reader knows what "did not finish" cost. */
+    readonly waitedMs?: number;
+    readonly onRetry?: () => void;
+}
+/**
+ * `stage: null` gets its own sentence rather than the word "null".
+ *
+ * Nothing stamped at all means the script never executed, which is what a
+ * parse error looks like from out here — a different problem from stopping AT
+ * `script`, and the two must not read the same.
+ */
+export declare function graphFallbackDetail(stage: BootStage | null | undefined, started?: boolean, reason?: GraphFallbackReason, waitedMs?: number): string;
+export declare function GraphFallback({ message, onRetry, reason, stage, started, waitedMs, }: GraphFallbackProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=GraphFallback.native.d.ts.map

package/types/native/GraphFallback.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphFallback.native.d.ts","sourceRoot":"","sources":["../../src/native/GraphFallback.native.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,cAAc,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEhG,MAAM,WAAW,kBAAkB;IACjC,oGAAoG;IACpG,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;IACrC,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,wFAAwF;IACxF,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CAC/B;AAYD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,EACnC,OAAO,CAAC,EAAE,OAAO,EACjB,MAAM,CAAC,EAAE,mBAAmB,EAC5B,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,CA4BR;AAED,wBAAgB,aAAa,CAAC,EAC5B,OAAO,EACP,OAAO,EACP,MAAM,EACN,KAAK,EACL,OAAO,EACP,QAAQ,GACT,EAAE,kBAAkB,2CA0BpB"}

package/types/native/GraphToolbar.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The toolbar that owns the interaction mode (design §7.3, §7.5; task 3.6).
+ *
+ * It lives under `src/native/` because the shell it belongs to is the native
+ * one — a WebView cannot draw chrome the OS will treat as chrome, and design
+ * §7.6 already puts every control outside the canvas. It is NOT a `.native.tsx`
+ * twin: it is plain Tamagui and it renders identically on the web canvas, which
+ * is what makes the web story a real rehearsal of the phone rather than a
+ * different component that happens to look similar.
+ *
+ * MILESTONE 6 GAVE IT THE REST OF THE CONTROLS. Tidy, Undo and Redo used to
+ * live inside `NodeGraph/AutoLayout` as `children` of the canvas, which native
+ * drops — so on device the story painted 12 nodes with no way to lay them out,
+ * `layoutRunner` read `none` on every host, and MPO-213's device criterion had
+ * no way to be attempted. They are here now because here is a SIBLING, and a
+ * sibling is one of the two legal places a control can go (design §9.1). Each
+ * is rendered only when its handler is given, so a canvas with no auto-layout
+ * does not grow three dead buttons.
+ *
+ * Two decisions worth stating:
+ *
+ *  - `fitView` is a BUTTON and not a double-tap. Design §7.5: a hidden gesture
+ *    that fights the platform's own double-tap zoom is worse than a visible
+ *    control. It renders only when a handler is given, so a read-only canvas
+ *    does not grow a dead button.
+ *  - selection is shown by DROPPING `chromeless` on the active button and
+ *    spreading the `textWeight` fragment onto it, never by a colour. Both are
+ *    Tamagui's own, so the active stop follows whatever theme the envelope
+ *    resolved and there is no literal here to drift from it. (`themeInverse`
+ *    would have been the obvious choice and is not a prop in Tamagui 2.7.6;
+ *    `ThemeProps` carries no `inverse` either, so the pressed state is
+ *    fill-and-weight rather than a theme flip.)
+ *
+ * Every style comes from a whole `knobProps.*` fragment spread (AGENTS.md).
+ * Built from `tamagui` rather than `@multiplatform.one/components`, which is an
+ * optional peer of this package.
+ *
+ * A11y is expressed with `role` / `aria-*` and not with the React Native
+ * `accessibility*` names, matching the house count (113 `aria-label` against 15
+ * `accessibilityLabel` under public/components, and `role="toolbar"` in
+ * `layouts/toolbar.tsx`). Measured in Chrome: Tamagui's `Button` forwards
+ * `accessibilityLabel`, `accessibilityRole` and `accessibilityState` straight to
+ * the DOM node, and React logs an error per prop per button. React Native
+ * >= 0.71 understands `aria-*` and `role`, so this is the spelling that is
+ * correct on both platforms rather than a web-only concession.
+ */
+import type { GraphInteractionMode } from "../interaction/useLassoSelect";
+export interface GraphToolbarProps {
+    readonly mode: GraphInteractionMode;
+    readonly onModeChange: (mode: GraphInteractionMode) => void;
+    /** Design §7.5. Omitted, the button is not rendered. */
+    readonly onFitView?: () => void;
+    /** Auto-layout, design §8. Omitted, the button is not rendered. */
+    readonly onTidy?: () => void;
+    readonly onUndo?: () => void;
+    readonly onRedo?: () => void;
+    /**
+     * Undo and Redo are disabled from the HOST's knowledge of the history, not
+     * from the canvas's.
+     *
+     * On native the journal lives on the far side of the bridge and nothing
+     * reports `canUndo` across it, so a native shell that has applied commits
+     * knows this and the canvas does not. Both default to enabled: a disabled
+     * button that should have worked is a worse failure than a press that turns
+     * out to be a no-op, and `history.undo` returns the same document when there
+     * is nothing to undo.
+     */
+    readonly canUndo?: boolean;
+    readonly canRedo?: boolean;
+    /** True while a relayout is in flight, so Tidy cannot be double-pressed. */
+    readonly busy?: boolean;
+    readonly disabled?: boolean;
+}
+export declare function GraphToolbar({ busy, canRedo, canUndo, disabled, mode, onFitView, onModeChange, onRedo, onTidy, onUndo, }: GraphToolbarProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=GraphToolbar.d.ts.map

package/types/native/GraphToolbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphToolbar.d.ts","sourceRoot":"","sources":["../../src/native/GraphToolbar.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAIH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAE1E,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,YAAY,EAAE,CAAC,IAAI,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAC5D,wDAAwD;IACxD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IAChC,mEAAmE;IACnE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AASD,wBAAgB,YAAY,CAAC,EAC3B,IAAY,EACZ,OAAc,EACd,OAAc,EACd,QAAQ,EACR,IAAI,EACJ,SAAS,EACT,YAAY,EACZ,MAAM,EACN,MAAM,EACN,MAAM,GACP,EAAE,iBAAiB,2CA0EnB"}

package/types/native/NodeGraph.native.d.ts

@@ -0,0 +1,128 @@
+/**
+ * The native host: the WebView, the watchdog, and the fallback.
+ *
+ * Design 9.4 layer 4. A DOM component that never comes up is, by default, a
+ * blank rectangle — the parse error that caused it happened before any error
+ * boundary existed, and there is no console on a phone to find it in. So this
+ * file starts a timer at mount and, if no `{ t: "ready" }` arrives inside
+ * `readyTimeoutMs`, draws `GraphFallback` naming the last boot stage the
+ * WebView managed to stamp.
+ *
+ * The retry is a REMOUNT under a new key, not a reload: the boot record is a
+ * global inside the WebView, and a new key gives boot a fresh one rather than
+ * a second attempt reading the first one's stages.
+ *
+ * The host owns `rev`. Every commit the canvas emits proposes `rev + 1`; this
+ * file applies the commands, stamps the new rev and hands the document back.
+ * The canvas's own echo gate then refuses the document it caused, so a drag
+ * does not fight itself. `wire.ts` holds the gate and the reasoning.
+ *
+ * WHAT IT NO LONGER OWNS (design §9.3, MPO-211): the `'use dom'` entry. It used
+ * to render the package's own, and the package's own can never see a consumer's
+ * Tamagui config or schema — both are live objects, so both can only arrive
+ * from a module the DOM BUNDLE imports, and a DOM bundle is rooted at the file
+ * carrying the directive. Measured on the iPhone 16e simulator and on
+ * emulator-5592: `render: Missing theme.`, identically on both platforms,
+ * because `getConfig()` threw inside the WebView. So the entry is a PROP now,
+ * and a host given none draws `GraphFallback` naming that rather than booting a
+ * WebView that is guaranteed to fail four seconds later.
+ */
+import type { Ref } from "react";
+import type { NodeGraphDomOptions, NodeGraphDomProps } from "../dom/NodeGraphDomShell";
+import type { GraphDiagnosticsWire, GraphEventWire, PerfReportWire } from "../dom/wire";
+import type { NodeGraphHandle } from "../react-flow/graphHandle";
+import type { KnobEnvelope } from "../knobs/envelope";
+import type { NodeId, Viewport } from "../model/index";
+import type { NodeGraphDomEntry } from "./domEntryRegistry";
+/**
+ * The watchdog budget. Design 9.4 said 4000; this is the measured replacement.
+ *
+ * 4000 was never measured — the design's own words were that "a cold WKWebView
+ * start with a first-run font fetch is comfortably under it". On emulator-5590,
+ * rebooted fresh, it was not: the watchdog fired, the fallback blamed a parse
+ * error, and Retry rendered the canvas immediately. Nothing had failed. A
+ * watchdog cannot tell a dead canvas from a slow one, so the only safe budget
+ * is one set from a real cold start with headroom over it.
+ *
+ * Two things go into the number now:
+ *
+ *  - the cold WebView start itself, which the canvas MEASURES and reports as
+ *    `bootMs` in design 9.5's panel, so this constant can be re-set from a
+ *    device instead of from a guess;
+ *  - `graphReadySettleMs` (1800), which the canvas deliberately waits before
+ *    stamping `ready` so its own diagnostics are filled in rather than
+ *    reporting `nodesMounted: 0` and every face `pending`.
+ *
+ * This MUST stay comfortably above their sum. A watchdog that undercut the
+ * settle grace would declare a healthy canvas dead while it was filling in its
+ * own panel, which is a worse version of exactly the bug this replaces.
+ */
+export declare const readyTimeoutMs = 12000;
+export interface NodeGraphNativeProps {
+    readonly documentJson: string;
+    readonly rev: number;
+    readonly envelope: KnobEnvelope;
+    readonly schemaId: string;
+    readonly options?: NodeGraphDomOptions;
+    /** Commands the canvas proposes, already JSON. The host applies and re-stamps `rev`. */
+    readonly onCommit?: (rev: number, commandsJson: string) => void;
+    readonly onSelection?: (ids: readonly NodeId[]) => void;
+    readonly onViewport?: (viewport: Viewport) => void;
+    readonly onNodeActivate?: (id: NodeId) => void;
+    readonly onConnectionRefused?: (code: string, message: string) => void;
+    readonly onHaptic?: (kind: "selection" | "impact" | "warning") => void;
+    readonly onReady?: (diagnostics: GraphDiagnosticsWire) => void;
+    readonly onError?: (event: Extract<GraphEventWire, {
+        t: "error";
+    }>) => void;
+    /**
+     * The canvas painted. Milestone 6: this, and not `ready`, is what the
+     * watchdog is measured against — see the effect below.
+     */
+    readonly onPaint?: (bootMs: number | null) => void;
+    readonly onLayoutResult?: (result: {
+        runner: string;
+        ms: number;
+        nodeCount: number;
+        /** Present when the engine REJECTED. `runner` is `none` and `ms` is 0 there. */
+        error?: string;
+    }) => void;
+    readonly onPerfReport?: (report: PerfReportWire) => void;
+    readonly onLasso?: (event: Extract<GraphEventWire, {
+        t: "lasso";
+    }>) => void;
+    /**
+     * EVERY decoded event, before the typed callbacks fire. One name that means
+     * the same thing on both platforms, so one story file can serve both.
+     */
+    readonly onGraphEvent?: (event: GraphEventWire) => void;
+    /**
+     * The imperative handle, forwarded to the DOM component. It is the ONLY way a
+     * native sibling can drive this canvas, so it is a prop and not an internal
+     * ref — which is what it was, and which is why nothing on a device could ever
+     * press Tidy.
+     */
+    readonly graphRef?: Ref<NodeGraphHandle>;
+    /** Overridable so a test can make the watchdog fire without waiting four seconds. */
+    readonly readyTimeoutMs?: number;
+    /**
+     * D1 is unruled. The gate that passed used Expo's OWN DOM WebView, and
+     * `@expo/dom-webview` is what this repo carries — `react-native-webview` is in
+     * no package.json here. So the default is `useExpoDOMWebView: true`, which is
+     * exactly what was proven, and a consumer who adds `react-native-webview` can
+     * override the whole `dom` prop.
+     */
+    readonly dom?: NonNullable<NodeGraphDomProps["dom"]>;
+    /**
+     * The app's `'use dom'` entry. Design §9.3: it imports the app's tamagui
+     * config and its schema registration and renders `NodeGraphDomShell`, and
+     * nothing inside this package can stand in for it.
+     *
+     * Falls back to `getNodeGraphDomEntry()` so a story that lives in this
+     * package — which cannot import an app's config — still gets a canvas once
+     * the app has registered one.
+     */
+    readonly domEntry?: NodeGraphDomEntry;
+}
+export declare function NodeGraphNative(props: NodeGraphNativeProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=NodeGraph.native.d.ts.map

package/types/native/NodeGraph.native.d.ts.map

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

package/types/native/domEntryRegistry.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Where an app parks its `'use dom'` entry so the PACKAGE's own stories can
+ * reach it (design §9.3).
+ *
+ * Same move as `registerGraphSchema`, one realm out. A schema registers by id
+ * because a `render` is a component and cannot be JSON; a DOM entry registers
+ * here because it is a component too — but this side of the bridge, so nothing
+ * is serialized and nothing is looked up by string. `NodeGraphNative` takes the
+ * entry as a prop first and reads this only when it was given none.
+ *
+ * It exists for exactly one shape of consumer: a story that lives inside this
+ * package and therefore cannot import the app's config. `public/*` may not
+ * depend on `@package/themes`, so `NodeGraph/NodeGraph` on device had no way to
+ * get a Tamagui config into the WebView at all — which is what it died of.
+ * `apps/storybook-expo` calls `setNodeGraphDomEntry` from its Storybook preview,
+ * and every story in the gallery then renders against the app's real config.
+ *
+ * An app with its own screens never needs this: it passes `domEntry` to
+ * `<NodeGraph />` and skips the global entirely.
+ */
+import type { ComponentType } from "react";
+import type { NodeGraphDomProps } from "../dom/NodeGraphDomShell";
+/** What a `'use dom'` module's default export looks like from the Hermes side. */
+export type NodeGraphDomEntry = ComponentType<NodeGraphDomProps>;
+/**
+ * Last writer wins, deliberately. An app has one entry; a second call is a hot
+ * reload replacing the first, not two apps competing.
+ */
+export declare function setNodeGraphDomEntry(entry: NodeGraphDomEntry | null): void;
+export declare function getNodeGraphDomEntry(): NodeGraphDomEntry | null;
+/** Test seam, matching `clearGraphSchemas`. */
+export declare function clearNodeGraphDomEntry(): void;
+//# sourceMappingURL=domEntryRegistry.d.ts.map

package/types/native/domEntryRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domEntryRegistry.d.ts","sourceRoot":"","sources":["../../src/native/domEntryRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,kFAAkF;AAClF,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,iBAAiB,CAAC,CAAC;AAIjE;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,GAAG,IAAI,CAE1E;AAED,wBAAgB,oBAAoB,IAAI,iBAAiB,GAAG,IAAI,CAE/D;AAED,+CAA+C;AAC/C,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C"}

package/types/native/graphChildren.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The rule, as a warning a story author trips over once (milestone 6, task 6.1).
+ *
+ * `NodeGraph` on native accepts `children` and IGNORES them. That has been the
+ * written contract since milestone 2 and it is still right: React Flow's
+ * `<Background />` and `<Controls />` are components, a component cannot cross a
+ * JSON bridge, and accepting them is what lets ONE story file serve both
+ * platforms.
+ *
+ * What was wrong is that nothing said so at the moment it mattered. Measured
+ * across MPO-212, MPO-213 and MPO-214: every device-facing control and readout
+ * milestones 3-5 built was written as a child of `<NodeGraph>` — AutoLayout's
+ * Tidy button, the Perf200 sampler and its `window.__mpoPerf200`, the Lasso
+ * story's interceptor — and on device all of them silently vanished. Five
+ * pending acceptance criteria, one cause, and no error anywhere: the canvas
+ * painted, so nothing looked broken.
+ *
+ * So the contract now announces itself, ONCE per process, in dev only. Once
+ * because the alternative is a warning per canvas per render, which is how a
+ * console becomes something people stop reading. Dev only because in production
+ * the author is not there and the message is for the author.
+ *
+ * It names both legal places rather than only the ban. A rule that says what
+ * not to do teaches nothing at 2 a.m.
+ */
+/** Test seam. Nothing in the package calls it. */
+export declare function resetGraphChildrenWarning(): void;
+export declare const graphChildrenWarning: string;
+/**
+ * True when it warned. `children` is checked for a value rather than for a
+ * count: `null`, `false` and `undefined` are all what a conditional child
+ * collapses to, and warning about `{cond && <X/>}` when `cond` is false would
+ * be a warning about code that is doing the right thing.
+ */
+export declare function warnOnGraphChildren(children: unknown): boolean;
+//# sourceMappingURL=graphChildren.d.ts.map

package/types/native/graphChildren.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphChildren.d.ts","sourceRoot":"","sources":["../../src/native/graphChildren.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,kDAAkD;AAClD,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD;AAED,eAAO,MAAM,oBAAoB,QAMwD,CAAC;AAE1F;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAc9D"}