@multiplatform.one/node-graph 7.7.2

package/types/interaction/useLassoSelect.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Select mode: the free half of the lasso (design §7.3, task 3.6).
+ *
+ * There are two ways into a marquee on touch and this is the one that costs
+ * nothing, because it is upstream's own path rather than a mechanism we own.
+ * The toolbar flips a mode; the canvas re-renders with
+ * `panOnDrag={false} selectionOnDrag selectionMode={SelectionMode.Partial}`;
+ * the next `pointerdown` then passes React Flow's touch guard.
+ *
+ * That guard, verbatim from the installed 12.11.5 (`Pane/index.tsx:143-148`,
+ * shipped at `dist/esm/index.js:1481`):
+ *
+ *   if (event.pointerType === 'touch' && panOnDrag !== false && !selectionKeyPressed) return;
+ *
+ * `panOnDrag !== false` is an IDENTITY check, so `false` is the only value in
+ * the language that opens it. `0`, `[]`, `null` and `undefined` are every bit
+ * as truthy to that line as `true` is, and each of them yields a select mode
+ * that looks right in a props table and does nothing under a finger. Hence
+ * `panOnDrag: false as const` below rather than anything computed, and hence
+ * the spec asserting it with `toBe(false)`.
+ *
+ * `SelectionMode.Partial` is the touch default on purpose: `Full` asks the user
+ * to enclose a node completely, and on a phone the marquee is drawn with the
+ * thing you are aiming at hidden under your hand.
+ *
+ * The long press (design §7.3 L1-L7) is the OTHER entry point, added in task
+ * 3.7 below. It drives this same mode and it is opt-in, so that if the
+ * interceptor turns out not to work on a real WebView, toolbar mode is
+ * untouched and there is still a lasso.
+ */
+import type { RefObject } from "react";
+import type { MarqueeMode, NodeId, NodeRect, Rect, Viewport } from "../model/index";
+import { SelectionMode } from "../react-flow/xy";
+/**
+ * `pan` is React Flow's ordinary canvas — one finger pans, and that is what
+ * every graph does today. `select` swaps that one finger for a marquee.
+ *
+ * Two values, not three: a "connect" mode was considered and dropped, because
+ * connecting already starts from a port rather than from the pane and a mode
+ * for it would be a mode the user has to remember to leave.
+ */
+export type GraphInteractionMode = "pan" | "select";
+/** Exactly the React Flow props the mode decides, and no others. */
+export interface LassoFlowProps {
+    readonly panOnDrag: boolean;
+    readonly selectionOnDrag: boolean;
+    readonly selectionMode: SelectionMode;
+}
+/**
+ * Frozen module constants rather than a fresh object per call: these are spread
+ * onto `ReactFlow` on every render of the canvas, and a new `selectionMode`
+ * identity each time is a prop change React Flow has to reconcile for nothing.
+ */
+export declare function lassoFlowProps(mode: GraphInteractionMode): LassoFlowProps;
+/** Design §7.3 L1. Long enough not to fire on a flick, short enough to feel deliberate. */
+export declare const lassoHoldMs = 350;
+/** Design §7.3 L2. Past this before the timer fires, it was a pan and it stays one. */
+export declare const lassoSlopPx = 10;
+/**
+ * The viewport, as a port rather than as `useReactFlow()`.
+ *
+ * Arming has to UNDO the sub-slop drift d3 already applied during the hold
+ * (L3), which means reading the viewport at `touchstart` and writing it back
+ * 350 ms later. Taking that as two functions rather than reaching for the
+ * instance keeps this hook mountable outside `ReactFlowProvider` — and, more
+ * usefully, keeps the screen/flow arithmetic below honest: it is the same
+ * `(screen - paneOrigin - pan) / zoom` React Flow uses, written out, rather
+ * than a helper whose behaviour a spec would have to take on trust.
+ *
+ * Whether d3 HONOURS a `setViewport` mid-gesture is not something a unit test
+ * can answer. That is the device video's job, and until it exists the long
+ * press is a hypothesis (design §7.3).
+ */
+export interface LassoViewportPort {
+    readonly get: () => Viewport;
+    readonly set: (viewport: Viewport) => void;
+}
+export interface LassoLongPressOptions {
+    /**
+     * The canvas root. The pane is found under it by class, so a consumer
+     * threads one ref instead of reaching into React Flow's tree.
+     */
+    readonly rootRef: RefObject<HTMLElement | null>;
+    readonly viewport: LassoViewportPort;
+    /** Every node's rect in FLOW units. Same shape `model/select.ts` takes. */
+    readonly getNodeRects: () => readonly NodeRect[];
+    readonly onSelect?: (ids: readonly NodeId[]) => void;
+    /**
+     * Design §7.3 L3. A WebView cannot buzz, so the canvas asks and the native
+     * shell does it — this is what becomes `{ t: "haptic", kind: "selection" }`.
+     */
+    readonly onHaptic?: () => void;
+    /**
+     * Every way OUT of an armed gesture that is not a selection: past the slop, a
+     * second finger, an unmount. Milestone 6 added it because a native shell has
+     * a readout to clear and a marquee to stop drawing, and without this it could
+     * only learn that a lasso had ended by inferring it from a `select` that
+     * never came.
+     *
+     * Fires ONCE per armed gesture and never for a press that never armed — a tap
+     * is not a cancelled lasso.
+     */
+    readonly onCancel?: () => void;
+    readonly holdMs?: number;
+    readonly slopPx?: number;
+    readonly marqueeMode?: MarqueeMode;
+    /**
+     * Design §7.3 L7: on fine pointers NOTHING changes. Default false, so the
+     * long press is something a touch canvas opts into and a mouse canvas never
+     * sees — React Flow's own `selectionKeyCode` lasso stays the desktop answer.
+     */
+    readonly enabled?: boolean;
+}
+export interface UseLassoSelectOptions {
+    /** Controlled. When set, the hook never changes the mode itself. */
+    readonly mode?: GraphInteractionMode;
+    /** Uncontrolled seed. Defaults to `pan`, so a canvas with no toolbar is unchanged. */
+    readonly defaultMode?: GraphInteractionMode;
+    readonly onModeChange?: (mode: GraphInteractionMode) => void;
+    readonly longPress?: LassoLongPressOptions;
+}
+export interface LassoSelect {
+    /** What the TOOLBAR says. Arming does not change it, so the button does not flicker. */
+    readonly mode: GraphInteractionMode;
+    readonly setMode: (mode: GraphInteractionMode) => void;
+    readonly toggleMode: () => void;
+    /**
+     * What the CANVAS should be given — `select` while armed, whatever the
+     * toolbar says otherwise. Pass this to `NodeGraphWeb`'s `interactionMode`,
+     * not `mode`.
+     *
+     * Measured in Chrome before this existed: the story passed `mode`, the pane
+     * kept its `draggable` class through the whole armed gesture, and L3's
+     * "set `panOnDrag={false}` so nothing new starts" was true of `flowProps`
+     * and of nothing else. The interceptor stops the gesture already running;
+     * this is what stops the next one.
+     */
+    readonly effectiveMode: GraphInteractionMode;
+    readonly flowProps: LassoFlowProps;
+    /** True between the hold firing and the finger lifting. */
+    readonly armed: boolean;
+    /** The marquee in pane-relative SCREEN px, or null. `LassoOverlay` paints it. */
+    readonly marquee: Rect | null;
+}
+/**
+ * Controlled and uncontrolled, the same way `useGraphController` does it: the
+ * prop wins when present, and `onModeChange` fires either way so a native shell
+ * can mirror the mode into its own toolbar without owning it.
+ */
+export declare function useLassoSelect(options?: UseLassoSelectOptions): LassoSelect;
+//# sourceMappingURL=useLassoSelect.d.ts.map

package/types/interaction/useLassoSelect.d.ts.map

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

package/types/knobs/KnobEnvelopeProvider.d.ts

@@ -0,0 +1,45 @@
+/**
+ * DOM side of the knob envelope: rebuild the real stack from the inputs.
+ *
+ * It uses the theme package's OWN components — `<Preset>`, `<Surface>`,
+ * `IntentContext.Provider` — and never raw `PresetContext.Provider`, so a later
+ * change to Preset's merge order or Surface's LC-68 clamp cannot desync the two
+ * sides. Design: docs/design/node-graph-editor.md 6.1.
+ */
+import { type ReactNode } from "react";
+import { type TamaguiInternalConfig } from "tamagui";
+import { type KnobEnvelope } from "./envelope";
+export interface KnobEnvelopeProviderProps {
+    readonly envelope: KnobEnvelope;
+    /**
+     * Only the DOM/WebView host passes a config: it is a fresh React root with no
+     * provider above it. On web the graph renders inside the app's existing
+     * `TamaguiProvider`, and mounting a second one there would give the subtree a
+     * different token table from the page around it.
+     */
+    readonly config?: TamaguiInternalConfig;
+    readonly children?: ReactNode;
+}
+/**
+ * The theme name this side can actually resolve.
+ *
+ * `envelope.themeName` is the HOST's, and across the bridge the two realms are
+ * different Tamagui builds with different theme tables: the app's config knows
+ * `light_blue`, the DOM bundle's knows whatever `@multiplatform.one/theme`
+ * created. Tamagui does not degrade on a name it cannot find — it THROWS
+ * `Missing theme.` — so an unportable name took the whole canvas down.
+ *
+ * Measured on the iPhone 16e simulator at task 2.7: `render: Missing theme.`,
+ * caught by the entry's error boundary. Design 6.1 assumed the name crossed;
+ * it does not, and the envelope already carries `scheme` for exactly the part
+ * that must survive.
+ *
+ * On WEB there is no `config`, because the graph renders inside the app's own
+ * provider and that provider owns the table — so the name is passed through
+ * untouched and nothing changes for the platform that was already working.
+ *
+ * @returns the name to mount, or undefined to inherit.
+ */
+export declare function resolveEnvelopeThemeName(envelope: Pick<KnobEnvelope, "scheme" | "themeName">, themes?: Readonly<Record<string, unknown>>): string | undefined;
+export declare function KnobEnvelopeProvider({ envelope, config, children }: KnobEnvelopeProviderProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=KnobEnvelopeProvider.d.ts.map

package/types/knobs/KnobEnvelopeProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KnobEnvelopeProvider.d.ts","sourceRoot":"","sources":["../../src/knobs/KnobEnvelopeProvider.tsx"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,KAAK,SAAS,EAAW,MAAM,OAAO,CAAC;AAChD,OAAO,EAAE,KAAK,qBAAqB,EAA0B,MAAM,SAAS,CAAC;AAS7E,OAAO,EAAE,KAAK,YAAY,EAAoB,MAAM,YAAY,CAAC;AAEjE,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,qBAAqB,CAAC;IACxC,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,IAAI,CAAC,YAAY,EAAE,QAAQ,GAAG,WAAW,CAAC,EACpD,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACzC,MAAM,GAAG,SAAS,CAMpB;AAED,wBAAgB,oBAAoB,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,yBAAyB,2CA6C7F"}

package/types/knobs/envelope.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The knob ENVELOPE: the inputs to the knob stack, serialized.
+ *
+ * MPO-191 AC-3 asks for the real `useResolvedKnobs` with its Preset / Surface /
+ * Intent context stack, not the pure `resolveKnobs` function. React context does
+ * not cross a WebView, so what crosses is the INPUTS to that stack, never the
+ * resolved outputs — the DOM side rebuilds the stack out of the theme package's
+ * own components and resolves for itself. One code path: the web host is the
+ * degenerate case where the envelope never leaves the process.
+ *
+ * Design: docs/design/node-graph-editor.md section 6.1.
+ */
+import type { Knobs, SurfaceDensity, SurfaceSize } from "@multiplatform.one/theme";
+/**
+ * `unset` is part of the surface vocabulary, and dropping it changes what
+ * resolves.
+ *
+ * Design 6.1 types the envelope's surface as `{ size: SurfaceSize; density:
+ * SurfaceDensity }`, but `SurfaceContext`'s default is `{ size: "unset",
+ * density: "unset" }` (Surface.tsx:23-26) and `applySurfaceToKnobs`
+ * (useResolvedKnobs.ts:44-70) SKIPS an `unset` axis entirely. Coercing a host
+ * that sits under no `<Surface>` to "medium" would then step `knobs.size` down
+ * from `large`, and the rehydrated tree would resolve differently from the host
+ * it copied. So the envelope carries the third value.
+ */
+export type GraphSurfaceSize = SurfaceSize | "unset";
+export type GraphSurfaceDensity = SurfaceDensity | "unset";
+/** A face the DOM side has to register itself, because WKWebView cannot see an expo-font registration. */
+export interface GraphFontRef {
+    readonly family: string;
+    /** Asset URL or `data:` URI the WebView can fetch. */
+    readonly src: string;
+    readonly weight?: number;
+    readonly style?: "normal" | "italic";
+}
+/** Bumped when the envelope's shape changes in a way the DOM side must refuse. */
+export declare const knobEnvelopeSchemaVersion = 1;
+export interface KnobEnvelope {
+    readonly schemaVersion: typeof knobEnvelopeSchemaVersion;
+    /** Fully merged host knobs: preset.knobs + every Preset override in the chain + props.knobs. */
+    readonly knobs: Knobs;
+    /**
+     * REQUIRED when the host is under a NAMED preset. Without it the DOM side
+     * loses that preset's `intents` map: `useResolvedKnobs.ts:139` reads
+     * `presetCtx?.preset.intents[intent] ?? defaultIntents[intent]`, so a
+     * rehydrated tree with no name falls back to the defaults and a
+     * preset-specific intent override vanishes inside the WebView.
+     *
+     * It is a PROP, not a context read, because `PresetContextValue`
+     * (PresetContext.ts:7-10) carries `{ preset, overrides }` and no name — the
+     * name genuinely cannot be recovered from the context. The host passes the
+     * name it mounted `<Preset preset=…>` with, or `useTheme()`'s active preset.
+     */
+    readonly presetName?: string;
+    readonly intent: string | null;
+    readonly surface: {
+        readonly size: GraphSurfaceSize;
+        readonly density: GraphSurfaceDensity;
+    };
+    readonly scheme: "light" | "dark";
+    readonly themeName: string;
+    /**
+     * Resolved HOST-side. `usePrefersReducedMotion` (useResolvedKnobs.ts:22-41)
+     * reads `window.matchMedia`, which inside a WKWebView does not see the iOS
+     * setting.
+     */
+    readonly prefersReducedMotion: boolean;
+    /** The `--xy-*` / `--mpo-graph-*` layer, built host-side by `graphCssVars`. */
+    readonly vars: Readonly<Record<string, string>>;
+    readonly fonts: readonly GraphFontRef[];
+    readonly pixelRatio: number;
+    /** Bumped on any change above, so the DOM side memoises cheaply. */
+    readonly revision: number;
+}
+/** Everything except `revision` — two envelopes with the same identity are the same envelope. */
+export type KnobEnvelopeBody = Omit<KnobEnvelope, "revision">;
+/**
+ * Deterministic JSON. `JSON.stringify` preserves INSERTION order, and the host
+ * knobs are built by spreading, so `{...defaults, ...overrides}` and
+ * `{...overrides, ...defaults}` stringify differently while being the same
+ * object. A revision that bumps on key order alone would re-emit the whole var
+ * sheet on every unrelated render.
+ */
+export declare function stableStringify(value: unknown): string;
+/** Stable identity of an envelope's inputs, ignoring `revision`. */
+export declare function knobEnvelopeIdentity(body: KnobEnvelopeBody): string;
+export declare function serializeKnobEnvelope(envelope: KnobEnvelope): string;
+/**
+ * Parse an envelope that crossed the bridge.
+ *
+ * A version mismatch throws rather than rendering: a DOM bundle older than its
+ * host would otherwise resolve against a knob set it does not understand and
+ * paint something plausible but wrong, which is the failure that takes longest
+ * to find.
+ */
+export declare function parseKnobEnvelope(text: string): KnobEnvelope;
+/** `animation: "none"` forced in, idempotent against the resolver's own reduced-motion branch. */
+export declare function knobsForEnvelope(envelope: KnobEnvelope): Knobs;
+//# sourceMappingURL=envelope.d.ts.map

package/types/knobs/envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../../src/knobs/envelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAa,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAE9F;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,gBAAgB,GAAG,WAAW,GAAG,OAAO,CAAC;AACrD,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG,OAAO,CAAC;AAE3D,0GAA0G;AAC1G,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sDAAsD;IACtD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CACtC;AAED,kFAAkF;AAClF,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,aAAa,EAAE,OAAO,yBAAyB,CAAC;IACzD,gGAAgG;IAChG,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAA;KAAE,CAAC;IAC7F,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;IACvC,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAChD,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,iGAAiG;AACjG,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;AAE9D;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAQtD;AAED,oEAAoE;AACpE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,CAEnE;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAEpE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAS5D;AAED,kGAAkG;AAClG,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,YAAY,GAAG,KAAK,CAG9D"}

package/types/knobs/graphKnobs.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The ONE place a graph node reads knobs.
+ *
+ * Nodes read knobs the way every other catalog component does — the real
+ * `useResolvedKnobs` with its Preset / Surface / Intent stack — and the
+ * GraphNode-specific laws in design section 11 (the width ladder, the
+ * CONTAINER-CAP radius, the port-spacing floor) land on top of the resolver's
+ * fragments in task 1.8. This module exists from task 1.6 so there is exactly
+ * one call site to add them to, rather than a hook per node kind.
+ *
+ * Consumers spread whole `knobProps.*` fragments (AGENTS.md "Knobs system") and
+ * never cherry-pick a resolved token.
+ */
+import { type ResolvedKnobs } from "@multiplatform.one/theme";
+export interface UseGraphNodeKnobsOptions {
+    /** A registered intent name — "accent" | "error" | "warning" | "success". */
+    readonly intent?: string;
+    readonly selected?: boolean;
+    readonly dragging?: boolean;
+}
+export interface GraphNodeKnobs extends ResolvedKnobs {
+    readonly selected: boolean;
+    readonly dragging: boolean;
+}
+export declare function useGraphNodeKnobs(options?: UseGraphNodeKnobsOptions): GraphNodeKnobs;
+//# sourceMappingURL=graphKnobs.d.ts.map

package/types/knobs/graphKnobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphKnobs.d.ts","sourceRoot":"","sources":["../../src/knobs/graphKnobs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,KAAK,aAAa,EAAoB,MAAM,0BAA0B,CAAC;AAEhF,MAAM,WAAW,wBAAwB;IACvC,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,cAAe,SAAQ,aAAa;IACnD,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,wBAAwB,GAAG,cAAc,CAOpF"}

package/types/knobs/useKnobEnvelope.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Host side of the knob envelope: read the real knob stack, hand back the
+ * inputs that reproduce it. Design: docs/design/node-graph-editor.md 6.1.
+ */
+import { type Knobs } from "@multiplatform.one/theme";
+import type { GraphCssVarsOptions } from "../theme/graphVars";
+import { type GraphFontRef, type KnobEnvelope } from "./envelope";
+export interface UseKnobEnvelopeOptions {
+    /** `props.knobs` — merged last, on top of the whole Preset chain. */
+    readonly knobs?: Partial<Knobs>;
+    /**
+     * The name the host mounted `<Preset preset=…>` with. Not readable from
+     * context (see `KnobEnvelope.presetName`), so a host under a named preset
+     * has to say so or the DOM side loses that preset's `intents` map.
+     */
+    readonly presetName?: string;
+    /** Overrides the ambient `IntentContext` when the graph itself carries an intent. */
+    readonly intent?: string | null;
+    readonly fonts?: readonly GraphFontRef[];
+    /**
+     * Pointer class the graph is painted for, threaded into the var layer so the
+     * handle HIT region gets the 44 px floor on touch.
+     */
+    readonly pointer?: GraphCssVarsOptions["pointer"];
+    /**
+     * The `--xy-*` / `--mpo-graph-*` layer. Built from `graphCssVars` against the
+     * live theme by default; pass your own only to override the whole layer.
+     */
+    readonly vars?: Readonly<Record<string, string>>;
+}
+/**
+ * Build the envelope from the live knob stack.
+ *
+ * The knob merge is deliberately the SAME expression `useResolvedKnobs` uses
+ * for its base (`{...presetCtx.preset.knobs, ...presetCtx.overrides}`,
+ * useResolvedKnobs.ts:131-133) — anything cleverer is a second resolver to keep
+ * in step. It is then completed against `defaultKnobs`, because `JSON.stringify`
+ * DROPS a key whose value is `undefined`: without the completion an optional
+ * knob (`cornerSmoothing`, `pageTitleScale`) would arrive absent on the far
+ * side and the rehydrating `<Preset>`'s own base would show through the gap.
+ */
+export declare function useKnobEnvelope(options?: UseKnobEnvelopeOptions): KnobEnvelope;
+//# sourceMappingURL=useKnobEnvelope.d.ts.map

package/types/knobs/useKnobEnvelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKnobEnvelope.d.ts","sourceRoot":"","sources":["../../src/knobs/useKnobEnvelope.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EACL,KAAK,KAAK,EAMX,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,YAAY,EAIlB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,sBAAsB;IACrC,qEAAqE;IACrE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IAChC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,qFAAqF;IACrF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IACzC;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,mBAAmB,CAAC,SAAS,CAAC,CAAC;IAClD;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAClD;AA2CD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,sBAAsB,GAAG,YAAY,CAkD9E"}

package/types/layout/dagre.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The dagre adapter: pure, headless, and the only engine in the package.
+ *
+ * Pure so it can run in three realms that share nothing — the main thread, a
+ * classic Worker built from `worker.generated.ts`, and the Hermes JS thread on
+ * native. Headless is not a claim, it is asserted: `layout.spec.ts` stubs
+ * `document` and `window` to `undefined` for every case, because a stray DOM
+ * reach here would surface as a runtime error inside a Worker, which is the
+ * least debuggable place in this package.
+ *
+ * Three things this file is responsible for that dagre is not:
+ *
+ *  - **Centres to top-left.** dagre reports a node's CENTRE. Documents and
+ *    React Flow both hold top-left. Converting at the boundary is why nothing
+ *    downstream has to know dagre's convention.
+ *  - **Determinism.** dagre's own result depends on insertion order, so nodes
+ *    and edges are sorted by id before they go in. Without that, two
+ *    structurally equal documents that were BUILT differently lay out
+ *    differently, and the "same input twice" assertion would pass while the
+ *    real property failed.
+ *  - **The anchor.** A tidy that teleports the graph to the origin looks like
+ *    a crash. The laid-out bounding box's top-left is translated back onto the
+ *    top-left the moved set already occupied, so the arrangement changes and
+ *    the location does not.
+ *
+ * Design §8. Licence: dagre is MIT, compatible with this repo's Apache-2.0 —
+ * unlike elkjs, whose `EPL-2.0 OR GPL-3.0-or-later` is decision D2 and is
+ * still unruled, which is why there is no second engine here.
+ */
+import type { LayoutRequest, LayoutResult } from "./types";
+/** dagre's own defaults are 50 / 50; these are tuned for the node measures. */
+export declare const defaultLayoutSpacing: {
+    readonly direction: "TB";
+    readonly nodeSpacing: 60;
+    readonly rankSpacing: 90;
+    readonly edgeSpacing: 20;
+};
+export declare function layoutWithDagre(request: LayoutRequest): LayoutResult;
+//# sourceMappingURL=dagre.d.ts.map

package/types/layout/dagre.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dagre.d.ts","sourceRoot":"","sources":["../../src/layout/dagre.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAKH,OAAO,KAAK,EAAmB,aAAa,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5E,+EAA+E;AAC/E,eAAO,MAAM,oBAAoB;;;;;CAKvB,CAAC;AAkCX,wBAAgB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,YAAY,CAyEpE"}

package/types/layout/layout.d.ts

@@ -0,0 +1,58 @@
+/**
+ * `layout()` — a document in, positions out, off the main thread where the
+ * platform allows one. Design §8.
+ *
+ * Three things live here rather than in `runner.ts`, because they are about
+ * the DOCUMENT and the runner deliberately knows nothing about one:
+ *
+ *  - `buildLayoutRequest` turns a document plus a schema into boxes. The
+ *    width and height it uses are the SEEDED measure (design §5) — the same
+ *    numbers `toFlowNodes` gives React Flow before first paint. dagre runs on
+ *    another thread and could not read the DOM even if it wanted to, so the
+ *    seed is not an approximation here, it is the only measurement available,
+ *    and using the same function is what stops the tidy and the paint
+ *    disagreeing about how big a node is.
+ *  - `reconcilePositions` is the generation guard. A result that arrives after
+ *    the user has dragged something applies to every node EXCEPT the ones
+ *    touched since the request went out. Dropping the whole result instead
+ *    would make a relayout feel like it silently failed, which design §8 calls
+ *    out by name.
+ *  - `layout()` itself, which is a Promise on every runner.
+ */
+import type { EdgeKindDefs, GraphDocument, GraphSchema, NodeKindDefs } from "../model/index";
+import type { NodeId, Size, XY } from "../model/document";
+import type { GraphNodeSizeKnob } from "../nodes/nodeMeasure";
+import type { LayoutRunnerOptions } from "./runner";
+import type { LayoutOptions, LayoutRequest, LayoutResult } from "./types";
+export interface GraphLayoutOptions extends LayoutOptions {
+    /** The resolved `size` knob, so the boxes match the painted nodes. */
+    readonly size?: GraphNodeSizeKnob;
+    /** Touch surface: a wider port pitch, and so a taller height floor. */
+    readonly coarsePointer?: boolean;
+    /**
+     * Live boxes React Flow's ResizeObserver has already reported.
+     *
+     * They BEAT the seed, and the difference is visible rather than academic.
+     * Measured in Chrome on `NodeGraph/AutoLayout → Main`: the demo kinds seed a
+     * 72 px `minHeight` and paint 144-192 px, so a tidy on the seed put ranks
+     * 18 flow units apart where `rankSpacing` asked for 90 — a correct layout of
+     * boxes that are not the boxes on screen. Design §5 says the observer
+     * CORRECTS the seed; this is the layout half of taking that correction.
+     *
+     * Absent for a node React Flow has not measured yet, which is why the seed
+     * stays the fallback rather than being replaced.
+     */
+    readonly measured?: Readonly<Record<NodeId, Size>>;
+    readonly runner?: LayoutRunnerOptions;
+}
+export declare function buildLayoutRequest<N extends NodeKindDefs, E extends EdgeKindDefs>(document: GraphDocument<N, E>, schema: GraphSchema<N, E>, options?: GraphLayoutOptions): LayoutRequest;
+/**
+ * The result minus everything the user has touched since it was requested.
+ *
+ * Not "discard the result if anything moved". A 200-node tidy that silently
+ * does nothing because one node was nudged mid-flight is indistinguishable
+ * from a broken button.
+ */
+export declare function reconcilePositions(result: LayoutResult, touched: ReadonlySet<NodeId>): Readonly<Record<NodeId, XY>>;
+export declare function layout<N extends NodeKindDefs, E extends EdgeKindDefs>(document: GraphDocument<N, E>, schema: GraphSchema<N, E>, options?: GraphLayoutOptions): Promise<LayoutResult>;
+//# sourceMappingURL=layout.d.ts.map

package/types/layout/layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../src/layout/layout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE7F,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAG9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE1E,MAAM,WAAW,kBAAmB,SAAQ,aAAa;IACvD,sEAAsE;IACtE,QAAQ,CAAC,IAAI,CAAC,EAAE,iBAAiB,CAAC;IAClC,uEAAuE;IACvE,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;IACnD,QAAQ,CAAC,MAAM,CAAC,EAAE,mBAAmB,CAAC;CACvC;AAED,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,YAAY,EAC/E,QAAQ,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC7B,MAAM,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EACzB,OAAO,GAAE,kBAAuB,GAC/B,aAAa,CAkCf;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAC3B,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAQ9B;AAED,wBAAsB,MAAM,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,YAAY,EACzE,QAAQ,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC7B,MAAM,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EACzB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,YAAY,CAAC,CAGvB"}

package/types/layout/runner.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The layout runner, design §8. Probed, never assumed.
+ *
+ * `layout()` is a Promise on every path, so the API does not move when the
+ * runner does. Which runner answers is a RUNTIME question with three honest
+ * answers and one dishonest one:
+ *
+ *  - `worker-blob` — the good case on web and, if the platform allows it,
+ *    inside a WebView. Built from the committed string in
+ *    `worker.generated.ts` through `URL.createObjectURL`, so it needs no
+ *    module support, no origin and no bundler cooperation.
+ *  - `hermes-inline` — the good case on native, and a FIRST-CLASS runner, not
+ *    a fallback. On native the RN runtime is a different engine on a different
+ *    thread from the WebView's, so a 300 ms dagre run costs the canvas zero
+ *    frames with no worker involved. Nothing is warned about here.
+ *  - `inline` on a platform with no `Worker` and no Hermes — a plain web page
+ *    in a very old browser, or a spec run. Honest, and rare.
+ *  - `inline` on a platform that HAS `Worker` — the dishonest one, and the
+ *    reason this module reports rather than shrugs. That case produces
+ *    perfectly plausible frame numbers that mean nothing, so it warns once,
+ *    records a reason `readLayoutRunnerFallback()` returns, and surfaces as
+ *    `layoutRunner` in diagnostics. Design §13.2 makes a device perf run that
+ *    resolved this way fail BY DEFINITION.
+ *
+ * `worker-url` is in the union because design §8 names it. This module never
+ * returns it: a URL worker needs `new URL(..., import.meta.url)`, which is a
+ * parse-time SyntaxError in the classic script a DOM component's WebView
+ * runs. The member stays so a consumer switching on the kind is exhaustive
+ * against the design's vocabulary rather than ours.
+ */
+import type { LayoutRequest, LayoutResult, LayoutRunnerKind } from "./types";
+/** Design §8's number. A worker that has not answered in half a second is not going to. */
+export declare const defaultProbeTimeoutMs = 500;
+export interface LayoutRunner {
+    readonly kind: LayoutRunnerKind;
+    readonly run: (request: LayoutRequest) => Promise<LayoutResult>;
+    readonly dispose: () => void;
+}
+export interface LayoutRunnerOptions {
+    /** Overridable so a spec can drive the timeout without a five-second wait. */
+    readonly probeTimeoutMs?: number;
+}
+export interface LayoutRunnerFallback {
+    readonly reason: string;
+    /** The kind we settled for. */
+    readonly kind: LayoutRunnerKind;
+}
+/** Null when the resolved runner is the right one for the platform. */
+export declare function readLayoutRunnerFallback(): LayoutRunnerFallback | null;
+/** Test seam, and the hook a host uses to re-probe after a realm change. */
+export declare function resetLayoutRunner(): void;
+export declare function createLayoutRunner(options?: LayoutRunnerOptions): Promise<LayoutRunner>;
+/**
+ * The process-wide runner. Probing costs a worker spawn and a round trip, and
+ * doing it per relayout would put that on the interaction it is meant to make
+ * cheap.
+ */
+export declare function getLayoutRunner(options?: LayoutRunnerOptions): Promise<LayoutRunner>;
+export declare function resolveRunner(options?: LayoutRunnerOptions): Promise<LayoutRunnerKind>;
+//# sourceMappingURL=runner.d.ts.map

package/types/layout/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/layout/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,gBAAgB,EAAwB,MAAM,SAAS,CAAC;AAGnG,2FAA2F;AAC3F,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IAChE,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,mBAAmB;IAClC,8EAA8E;IAC9E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,+BAA+B;IAC/B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;CACjC;AAmBD,uEAAuE;AACvE,wBAAgB,wBAAwB,IAAI,oBAAoB,GAAG,IAAI,CAEtE;AAED,4EAA4E;AAC5E,wBAAgB,iBAAiB,IAAI,IAAI,CAMxC;AAmID,wBAAsB,kBAAkB,CAAC,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,YAAY,CAAC,CA0BjG;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC,CAGpF;AAED,wBAAsB,aAAa,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAE5F"}

package/types/layout/structuredCloneShim.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A guarded `structuredClone`, because dagre needs one and two of this
+ * package's three layout realms do not have it.
+ *
+ * FOUND BY RUNNING THE ARTEFACT, not by reading a changelog.
+ * `worker.generated.spec.ts` evaluates the bundled worker in a synthetic
+ * worker scope and drives a real layout through it; the first run came back
+ * `{"t":"error","message":"structuredClone is not defined"}`. dagre 3.1.1 calls
+ * it twice — once in `graphlib`'s JSON writer, and once on the POSITIONING hot
+ * path (`positionX`'s balance step), which every `layout()` call reaches.
+ *
+ * Where it is missing:
+ *
+ *  - **Hermes.** React Native 0.83.2 ships an implementation at
+ *    `src/private/webapis/structuredClone/structuredClone.js` and installs it
+ *    as a global from nowhere — nothing in `Libraries/Core` imports it. So the
+ *    `hermes-inline` runner, which design §8 makes a first-class runner and
+ *    not a fallback, would throw on the first tidy on device. That is the
+ *    failure this file exists to prevent, and it is exactly the kind that a
+ *    green web suite hides.
+ *  - **Older WebViews.** `structuredClone` is Safari 15.4 / iOS 15.4 and
+ *    Chrome 98. A WKWebView below that parses the worker fine and dies on the
+ *    first layout, which is the worst shape of failure this package has.
+ *
+ * WHAT IT CLONES. Only what dagre asks of it: plain objects, arrays, `Map`,
+ * `Set`, `Date`, `RegExp` and primitives, with cycles preserved. Not transfer
+ * lists, not `ArrayBuffer`, not `Blob`, not `Error`. A value outside that set
+ * throws, the way the real algorithm throws `DataCloneError` — inventing a
+ * silent shallow copy for a case dagre never produces would be a worse lie
+ * than a loud refusal.
+ *
+ * It installs on `globalThis` ONLY when the global is absent, so a real engine
+ * implementation always wins and nothing here shadows the platform.
+ */
+/** The shim itself, exported so a spec can drive it without touching a global. */
+export declare function cloneStructured<T>(value: T): T;
+/**
+ * Idempotent and cheap: one `typeof` on the happy path, which is every browser
+ * and every worker made this decade. Called at the top of `layoutWithDagre`
+ * rather than as a module side effect so nothing depends on import ORDER —
+ * a formatter that reorders two imports must not be able to break a runtime.
+ */
+export declare function ensureStructuredClone(): void;
+//# sourceMappingURL=structuredCloneShim.d.ts.map

package/types/layout/structuredCloneShim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structuredCloneShim.d.ts","sourceRoot":"","sources":["../../src/layout/structuredCloneShim.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAuDH,kFAAkF;AAClF,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAE9C;AAID;;;;;GAKG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAI5C"}