@nodegx/export 0.0.0-stage → 0.2.5

package/dist/analyze/plan.d.ts

@@ -0,0 +1,3757 @@
+/**
+ * Component analysis — EXP-002 step 4's decision stage, extended by step 5. Parsing recorded
+ * what the project says; this walks each component's visual tree and decides what the generator
+ * will do about it: which nodes render (and as what), which collapse, which become stubs, and
+ * which defer to EXP-003. Dispositions are analysis output about the graph, never facts of it
+ * (IR design).
+ *
+ * Step 5 adds the app-state constructs (EXP-002-STEP5-TARGET-OUTPUT.md): Variables become the
+ * stores module, Send/Receive Event pairs become channels, and signal wires compile into
+ * handler *actions* — a navigate, a store `.set`, a channel `.emit` — attached to whichever
+ * handler owns the triggering signal (a rendered element's DOM event, or a receiver's
+ * `useSignal`). Value wires resolve by sink context: the same `Variable2.value` read is a
+ * `useValue` hook in rendered content and a `.get()` snapshot inside a handler.
+ *
+ * Step 6 adds statically-knowable logic (EXP-002-LOGIC-TARGET-OUTPUT.md): String Format and
+ * Condition resolve into *expression trees* over the same source vocabulary, rendered inline
+ * wherever their output lands — the `derived()` row of EXP-001's table compiled away, because
+ * the hooks a component already earns are the reactivity a Derived would provide. A Condition
+ * in a handler chain (`trigger → eval`, `ontrue → sink`) becomes a branch action — an `if`
+ * statement in the trigger's handler — and only when the author unticked Run On Value Change,
+ * because Evaluate is additive and an onClick cannot carry on-change firing.
+ *
+ * Everything here is pure decision-making over the IR; no text is generated. The emit layer
+ * (emit/component.ts) turns a ComponentPlan into TSX/CSS.
+ */
+import { CatalogIndex } from '../catalog';
+import { ComponentIR, Disposition, ExportIR, KitNodeIR, ModuleIR, RefusedNode } from '../ir/types';
+import { Reachability } from './reach';
+import { ScaffoldPage } from '../emit/scaffold';
+import { DateHelper } from '../emit/dateLib';
+import { UtilHelper } from '../emit/utilLib';
+import { IdHelper } from '../emit/idLib';
+import { StyleRole } from '../emit/style';
+import { AnimateEaseName } from '../emit/animateLib';
+import { StatesValueType } from '../emit/statesLib';
+import { ScriptUsePlan } from './scriptUses';
+import { QueryParamsPlan } from './querySettings';
+import { ChannelPlan, CollectionPlan, StorePlan, VariablePlan } from './appState';
+export type { ChannelPlan, CollectionKeyPlan, CollectionPlan, StoreKeyPlan, StorePlan, VariablePlan } from './appState';
+/**
+ * How a node participates in the render, or null for pure logic nodes.
+ *
+ * `'custom'` is EXP-010's: a visual node from a `noodl_modules` kit. It is its own role rather
+ * than a `StyleRole` because a kit node has no Noodl style ports at all — every parameter on one
+ * is a port the kit itself declared (measured across every project on this machine: not one custom
+ * node carries a `width`, a `margin` or a `backgroundColor`), so the style tables have nothing to
+ * say about it and `computeNodeStyle` must not be asked.
+ */
+export type RenderRole = StyleRole | 'instance' | 'repeater' | 'custom' | 'slot';
+/**
+ * EXP-011 §51. The marker the runtime reads structurally rather than as a node: `nodescope.ts:217`
+ * creates nothing for it and, when it has a parent, makes that parent the instance's child root
+ * (`componentinstance.ts` `setChildRoot`). The placed children of an instance are inserted into
+ * that parent at the marker's index, in order, contiguously — React's `children`, rendered where
+ * the marker sits.
+ */
+export declare const CHILD_SLOT_TYPE = "Component Children";
+/** Parent of every node, read from both `parent` fields and `children` arrays (two corpus files carry only the latter). */
+export declare function parentMapOf(component: ComponentIR): Map<string, string>;
+/**
+ * Which `Component Children` receives an instance's children, by the runtime's own two rules:
+ * `createNodeFromModel` runs per node in file order and every marker with a parent calls
+ * `setChildRoot(parent)`, so the LAST marker's parent wins; then `getChildRootIndex` inserts at the
+ * FIRST marker among that parent's children. A parentless marker sets nothing. Null when no marker
+ * has a parent — an instance's children are then never drawn.
+ */
+export declare function chooseChildSlot(component: ComponentIR): {
+    nodeId: string;
+    parentId: string;
+} | null;
+/** `Hash` (EXP-011 §59). A SHA-2 digest of a UTF-8 string through `crypto.subtle.digest` — asynchronous. */
+export declare const HASH_TYPE = "net.noodl.Hash";
+/** `Random Bytes` (EXP-011 §59). `crypto.getRandomValues` rendered as text — synchronous, never `Math.random()`. */
+export declare const RANDOM_BYTES_TYPE = "net.noodl.RandomBytes";
+/**
+ * `Pattern Extractor` (EXP-011 §76). A regular expression over a text — `Hash`'s shape (an action port, an
+ * outcome pair, a raise on failure) with SEVEN value outputs where Hash has one, and a third signal pair
+ * (`Found` / `Not Found`) the runtime fires BEFORE `Done` off the same Extract: two RESULTS, one outcome.
+ */
+export declare const PATTERN_EXTRACTOR_TYPE = "net.noodl.PatternExtractor";
+/** The crypto family's members — `node` on {@link CRYPTO_NODES}, on `crypto-out` and on `crypto-call`. */
+export type CryptoNodeKind = 'hash' | 'random-bytes' | 'pattern';
+/**
+ * `Pattern Extractor`'s value outputs (EXP-011 §76), each a row of its own when read outside the chain —
+ * and, unlike the two crypto rows, each SEEDED: `initialize` writes every internal (`match: null`, `[]`,
+ * `{}`, `''`) and the getters answer them, so nothing here is ever undefined. `tsType` is what the getter
+ * publishes; `boot` / `bootCode` is what `initialize` leaves for the getter to read.
+ */
+export declare const PATTERN_VALUE_OUTPUTS: Record<string, {
+    label: string;
+    tsType: string;
+    boot: string | number;
+    bootCode?: string;
+}>;
+/**
+ * The two crypto verbs (EXP-011 §59), which are `UUID`'s shape (§37) and not a request's: read the
+ * inputs the setters stored, answer a value or a failure in the one call (`_run` / `_generate`),
+ * write the value row or leave it as it was, clear or write the Error, report the outcome. Two
+ * things differ from `UUID` and the export keeps both: **the value row boots empty** (neither node
+ * has an `initialize` that seeds it — `Digest` / `Value` read undefined until the first Do) and
+ * **a failure raises on the error channel** (`reportOutcome(…, 'failure', { code })` raises
+ * `hash/failed` / `random-bytes/failed` before the Failure pulse — `node.ts`). `Hash` awaits.
+ *
+ * `inputs` is the port order the emitted verb takes its arguments in; `numeric` names the one
+ * port whose setter is `Number(value)`, applied at the delivery site (a wire) and not in the lib.
+ */
+export declare const CRYPTO_NODES: Record<string, {
+    node: CryptoNodeKind;
+    /** The value output port — the ONE for the two verbs, the first of {@link PATTERN_VALUE_OUTPUTS} for the extractor. */
+    output: string;
+    /**
+     * EXP-011 §76. Every value output where a node has more than one, each typed and seeded; a read of any of
+     * them is a `crypto-out` carrying the port as `field`. Absent for the two verbs (their one output is `output`).
+     */
+    values?: Record<string, {
+        label: string;
+        tsType: string;
+        boot: string | number;
+        bootCode?: string;
+    }>;
+    /**
+     * EXP-011 §76. The RESULT pulses the node fires before `Done` — `Found` when the pattern matched at least
+     * once, `Not Found` when it ran and matched nothing (ERG-001 §4: a result, not an `Unchanged`). Two more
+     * chains compiled off one Extract, printed inside the Done arm ahead of the Done chain.
+     */
+    results?: readonly ['found', 'notFound'];
+    /** The action port, and what the editor shows it as. */
+    trigger: string;
+    triggerLabel: string;
+    /** The value output's display name, for the sentence about a read nothing ever writes. */
+    outputLabel: string;
+    /** The lib verb, the raised code, whether the call is awaited. */
+    fn: 'tryHash' | 'tryRandomBytes' | 'tryExtract';
+    code: string;
+    async: boolean;
+    inputs: readonly string[];
+    numeric?: string;
+    /** What the node is called in a deferral sentence. */
+    label: string;
+    /** The sentence for a read while nothing fires the trigger. */
+    neverFired: string;
+}>;
+/** `Screen Resolution` (EXP-011 §59). The type id IS the display name. Three numbers off one `resize` listener. */
+export declare const SCREEN_RESOLUTION_TYPE = "Screen Resolution";
+export declare const SCREEN_RESOLUTION_OUTPUTS: readonly ["width", "height", "aspectRatio"];
+/**
+ * `Drag` (EXP-011 §63). The type id IS the display name. A visual node that renders no element of its own — `Drag.tsx`
+ * wraps its FIRST child in `react-draggable` — so the export drags a wrapper `<div>` bound to a `useDrag` handle.
+ */
+export declare const DRAG_TYPE = "Drag";
+/** The option ports in the order the hook prints them: the port, the `useDrag` option key, and the panel's label. */
+export declare const DRAG_OPTION_PORTS: ReadonlyArray<{
+    port: string;
+    key: string;
+    label: string;
+}>;
+/** The four value outputs → the handle's live getters. */
+export declare const DRAG_VALUE_OUTPUTS: Readonly<Record<string, 'x' | 'y' | 'deltaX' | 'deltaY'>>;
+/** The three pulses → the hook's listeners, and the outcome trio the two snaps share (`outcomeOutputs`). */
+export declare const DRAG_PULSE_OUTPUTS: Readonly<Record<string, {
+    listener: 'onStart' | 'onMove' | 'onEnd' | 'done' | 'failure' | 'completed';
+    label: string;
+}>>;
+/** The two action ports — `Do|Snap To Position X` and `Do|Snap To Position Y` — and the axis each snaps. */
+export declare const DRAG_SNAP_TRIGGERS: Readonly<Record<string, 'x' | 'y'>>;
+declare const TIMER_TRIGGERS: readonly ["start", "restart", "stop"];
+type TimerTrigger = (typeof TIMER_TRIGGERS)[number];
+/** `log.ts`'s `LEVELS`, in its order — an authored level outside it falls back to `info` as the setter does. */
+declare const LOG_LEVELS: readonly ["debug", "info", "warn", "error"];
+export type LogLevel = (typeof LOG_LEVELS)[number];
+/**
+ * EXP-011 §61. The component-stack trio: the visual container (display name "Component Stack"), the pusher
+ * ("Push Component To Stack") and the popper ("Pop Component Stack"). A push is a call and a pop is its
+ * return — the pusher grows a `backResult-<k>` output per result and a `backAction-<a>` signal per way of
+ * closing that any Pop in the target declares (`navigate.ts` setup), and the Pop's `result-<k>` values and
+ * `backAction-<a>` signals are the other end of the same wire (`navigate-back.ts`).
+ */
+export declare const PAGE_STACK_TYPE = "Page Stack";
+export declare const STACK_PUSH_TYPE = "PageStackNavigate";
+export declare const STACK_POP_TYPE = "PageStackNavigateBack";
+export declare const PAGE_STACK_OUTPUTS: readonly ["topPageName", "stackDepth"];
+/** The reserved prop the stack row passes to the component it shows — the Pop's way back (§61.0). */
+export declare const PAGE_STACK_ENTRY_PROP = "pageStackEntry";
+/**
+ * EXP-011 §40. The outputs each node's **own compile** consumes when the node attaches — its
+ * Done/Failure chains and the sibling pulses it drops with a reason of its own.
+ *
+ * 🔴 **The attach pass must skip a wire off any of these, whatever order the file lists it in.**
+ * It walks connections in file order, and a chain wire listed *before* the wire that fires its
+ * node used to fall to *"the trigger is not a rendered element event or a receiver"* — reported
+ * dropped, marked consumed, and then emitted anyway when the node attached (`doneChainOf` filters
+ * by port, not by `consumed`). §39.3 found it on `Log`, `Delay` and `Value Changed` and measured
+ * the rest as unowned; §40.1 measured every family here order-dependent, and a node fired only
+ * from a reactive Condition or a Value Changed reported the same false note in *every* order,
+ * because that trigger wire is never the attach pass's to take.
+ *
+ * ⚠️ A port here must be one the node's compile answers for — consumed, deferred by name, or
+ * dropped with a reason — or the skip turns a false note into a silent one. Every entry below was
+ * read off the compile it names.
+ */
+/**
+ * EXP-011 §53 — `Run Tasks` (type id `RunTasks`; `Run Tasks` is its display name, and a match on the
+ * display name never fires — §5.7's `runtasks` branch was unreachable until this row spelled it right).
+ * The five signal outputs are the node's whole output set (`outcomeOutputs` + `aborted`); the four
+ * contract names are `runtasks-template-contract.ts`'s defaults, applied when the parameter is absent
+ * or empty (`resolveTemplateContract`: "an empty name falls back rather than being honoured").
+ */
+/** `On App Error` (EXP-011 §54) — the app-wide error boundary. The type id IS the display name. */
+export declare const ON_APP_ERROR_TYPE = "On App Error";
+/** The boundary's six value outputs — read off the `useAppError` handle's `last` (onapperror.ts's getters). */
+export declare const ON_APP_ERROR_VALUE_OUTPUTS: readonly ["message", "code", "nodeId", "componentName", "nodeType", "errorObject"];
+/** The Error Object's type, structurally — `src/lib/errors.ts`'s AppError, spelled so a store row needs no import. */
+export declare const APP_ERROR_TS_TYPE = "{ code: string; message: string; nodeId: string; componentName: string; nodeType: string; detail?: unknown }";
+/**
+ * EXP-011 §58 — the streaming trio (`agent/json-stream-parser.ts`, `stream-buffer.ts`, `text-accumulator.ts`).
+ * The type ids carry the `net.noodl.` prefix; the display names do not. Each is one hook over one `_internal`
+ * (`src/lib/streaming.ts`): the data port is read at the pulse, the config ports live off an options object, the
+ * signal outputs are listeners, the value outputs are live getters on the handle. The table is the catalog's
+ * port set, read off the node files — every port of the three translates, so what is refused is only the graph
+ * shapes every hook refuses (two wires, no static source, a pulse read as a value, an uncompilable chain).
+ */
+export declare const STREAM_PARSER_TYPE = "net.noodl.JSONStreamParser";
+export declare const STREAM_BUFFER_TYPE = "net.noodl.StreamBuffer";
+export declare const TEXT_ACCUMULATOR_TYPE = "net.noodl.TextAccumulator";
+export type StreamKind = 'parser' | 'buffer' | 'accumulator' | 'sse' | 'websocket' | 'subscription' | 'repeat' | 'dispatcher' | 'handler' | 'history' | 'undo' | 'snapshot' | 'optimistic' | 'signin';
+/** EXP-011 §64. `Server-Sent Events` — the fourth member of the table: no data port, two Actions, its own module. */
+export declare const SSE_TYPE = "net.noodl.SSE";
+/** EXP-011 §65. `WebSocket` — the fifth member: a data port (Message) that only the Send verb carries, three Actions, its own module. */
+export declare const WEBSOCKET_TYPE = "net.noodl.WebSocket";
+/**
+ * EXP-011 §66. `Subscribe To Changes` — the sixth member, and the last scheduled node: no data port, no Actions, two config
+ * ports (the Class — a runtime-discovered `collectionName` parameter, hence `param` — and Enabled), five signals, seven values;
+ * its own module, riding EXP-009's client. The Backend picker, the Filter and its `qp-` ports are refused by name (streamPlanOf).
+ */
+export declare const SUBSCRIBE_TO_CHANGES_TYPE = "SubscribeToChanges";
+/**
+ * GAM-013 (P88). `Repeat` — the seventh member: no data port, one config port (Interval), two Actions (Start, Stop), Tick
+ * and the outcome trio as listeners, Count a live getter; its own module, `src/lib/repeat.ts`. The table fits it exactly,
+ * where Delay's per-verb callbacks (§39) could not carry a node whose Tick belongs to the node and whose Count is a value.
+ */
+export declare const REPEAT_TYPE = "Repeat";
+/**
+ * EXP-011 §77. `Action Dispatcher` and `Action Handler` — the eighth and ninth members, one module (`src/lib/actions.ts`)
+ * holding the app's one registry, so the two meet across components by channel name alone, as in the runtime.
+ */
+export declare const ACTION_DISPATCHER_TYPE = "net.noodl.ActionDispatcher";
+export declare const ACTION_HANDLER_TYPE = "net.noodl.ActionHandler";
+/** The four built-in store actions (action-dispatcher.ts BUILT_IN_ACTIONS) — a dispatcher that enables one is refused in this slice. */
+export declare const ACTION_BUILT_INS: readonly ["SET_STORE", "MERGE_STORE", "DELETE_STORE_KEY", "CLEAR_STORE"];
+/**
+ * EXP-011 §78. `State History`, `Undo / Redo` and `State Snapshot` — the tenth, eleventh and twelfth members, one module
+ * (`src/lib/history.ts`) holding the app's one history manager and its named checkpoints over the exported Global Store.
+ * Each names its store by a literal Store Name, printed as the store module itself (`store: app`), so the history reads
+ * and writes the same `store()` the app's Set and Subscribe nodes do.
+ */
+export declare const STATE_HISTORY_TYPE = "net.noodl.StateHistory";
+export declare const UNDO_REDO_TYPE = "net.noodl.StateHistory.Undo";
+export declare const STATE_SNAPSHOT_TYPE = "net.noodl.StateSnapshot";
+/**
+ * EXP-011 §78 part 2. `Optimistic Update` — the thirteenth member, in the same module: a patch on the exported Global Store
+ * (apply now, commit or roll back later, overlapping patches handing values to each other) is one write through the
+ * history's store seam, so the history records it and every Subscribe sees it.
+ */
+export declare const OPTIMISTIC_UPDATE_TYPE = "net.noodl.OptimisticUpdate";
+/**
+ * EXP-011 §79. `Sign In With` — the fourteenth member, its own module (`src/lib/signIn.ts`): a launcher (Do hands the browser
+ * over to the backend's `/oauth/<provider>/start`) and a receiver (at mount it hears the sign-in coming back, which the
+ * client consumes when the app starts). Rides EXP-009's client, so it is kept only where the project declares a backend.
+ */
+export declare const SIGN_IN_WITH_TYPE = "net.noodl.user.SignInWith";
+/** EXP-011 §66. The structural RealtimeError — `src/lib/realtime.ts`'s, spelled so a store row needs no import. */
+export declare const REALTIME_ERROR_TS_TYPE = "{ message: string; code: string; kind: string } | null";
+export interface StreamValueField {
+    tsType: string;
+    /** How the value casts at a sink: the port's declared type, which is what NDA-014's typecast keys on. */
+    cast: 'string' | 'number' | 'boolean' | 'array' | 'unknown';
+    /** Undefined before anything happened (must agree with component.ts). */
+    maybeUndefined: boolean;
+}
+export interface StreamNodeSpec {
+    kind: StreamKind;
+    displayName: string;
+    hook: string;
+    localStem: string;
+    /** The module the hook lives in (component.ts maps it to a path; emitApp.ts ships it). */
+    lib: 'streaming' | 'sse' | 'websocket' | 'realtime' | 'repeat' | 'actions' | 'history' | 'signIn';
+    /** The runtime file the hook transcribes, for the emitted comment. */
+    sourceFile: string;
+    /** The data port, delivered with the pulse — absent on a node whose actions carry nothing (§64's SSE). */
+    data?: {
+        port: string;
+        displayName: string;
+    };
+    /** EXP-011 §78. The input naming the store module the hook is handed (StreamPlan.store) — never an option. */
+    store?: {
+        port: string;
+        displayName: string;
+    };
+    /** The config ports, read live off the options object. `param` names the on-disk parameter / wire port where it differs from the option (§66's Class is `collectionName` on disk). */
+    config: Array<{
+        port: string;
+        displayName: string;
+        param?: string;
+    }>;
+    /** The action ports: the verb on the handle, and whether the call carries the data port's value. */
+    actions: Record<string, {
+        verb: string;
+        takesData: boolean;
+    }>;
+    /** The signal outputs, as the listeners the hook takes, in the runtime's declaration order. */
+    signals: readonly string[];
+    values: Record<string, StreamValueField>;
+}
+export declare const STREAM_NODES: Record<string, StreamNodeSpec>;
+/** EXP-011 §64. The type id behind a `stream-out`'s kind — the one ladder component.ts and the maybe-undefined answer share. */
+export declare function streamTypeOfKind(kind: StreamKind): string;
+export declare const RUN_TASKS_TYPE = "RunTasks";
+/** EXP-011 §57. `Repeater Item` — the type id is the runtime's `name`, not the display name. */
+export declare const REPEATER_ITEM_TYPE = "For Each Actions";
+/** EXP-011 §60. The component-object trio — the Set, and the parent pair that read/write an ancestor's record. */
+export declare const SET_COMPONENT_OBJECT_TYPE = "net.noodl.SetComponentObjectProperties";
+export declare const PARENT_COMPONENT_OBJECT_TYPE = "net.noodl.ParentComponentObject";
+export declare const SET_PARENT_COMPONENT_OBJECT_TYPE = "net.noodl.SetParentComponentObjectProperties";
+/** EXP-011 §60. The message setparentcomponentobjectproperties.ts raises on a miss — verbatim (the lib exports the same constant). */
+export declare const NO_ANCESTOR_WRITE_MESSAGE = "No ancestor component has a Component Object node \u2014 nothing was written";
+export declare const RUN_TASKS_OUTPUTS: readonly string[];
+export declare const RUN_TASKS_CONTRACT_TEMPLATE_PARAM = "taskTemplate";
+export declare const RUN_TASKS_CONTRACT: {
+    readonly start: {
+        readonly parameter: "taskStartInput";
+        readonly default: "Do";
+    };
+    readonly success: {
+        readonly parameter: "taskSuccessOutput";
+        readonly default: "Success";
+    };
+    readonly failure: {
+        readonly parameter: "taskFailureOutput";
+        readonly default: "Failure";
+    };
+    readonly error: {
+        readonly parameter: "taskErrorOutput";
+        readonly default: "Error";
+    };
+};
+/** EXP-011 §62. The api-call / MutationPlan verb the pair compiles to. */
+export type RelationVerb = 'add-relation' | 'remove-relation';
+export type UserVerb = 'login' | 'logout' | 'signup' | 'update-user' | 'magic-link';
+/** One refused wire, as EXP-004's marker needs to talk about it. */
+export interface DroppedWire {
+    key: string;
+    fromId: string;
+    fromProperty: string;
+    toId: string;
+    toProperty: string;
+    /** The author's own label on the wire — irrecoverable once the wire is gone, so it travels. */
+    label?: string;
+    /** The exporter's own reason, in the words the note carries. */
+    reason: string;
+}
+export type BindingSource = {
+    kind: 'prop';
+    name: string;
+}
+/**
+ * A Variable read. `untyped` marks one whose writers this analysis could not type — the
+ * emitted `value<unknown>` (EXP-011 §10). It is not a defect and not a deferral: the render
+ * sinks coerce it, exactly as the runtime's own sinks coerce whatever the variable holds.
+ */
+ | {
+    kind: 'store';
+    variableName: string;
+    untyped?: true;
+}
+/**
+ * A single-key Global Store read. `untyped` is the Variable rule above, one construct over
+ * (EXP-011 §10.5): a key whose value this analysis could not type as `string`/`number` — a
+ * `boolean`, or an `unknown` written from an HTTP body or a Function output — binds and is
+ * coerced at the sink, rather than dropping the read the way it did before.
+ *
+ * 🔴 The gate is widened **here only**. `resolveExpr` still refuses the same key, because an
+ * expression position is arithmetic, a date argument or a url segment, and none of those has
+ * a sink that can state what it holds. §10.5 named that as the reason not to lift the gate
+ * wholesale, and it is still the reason.
+ */
+ | {
+    kind: 'store-key';
+    storeName: string;
+    key: string;
+    untyped?: true;
+} | {
+    kind: 'computed';
+    expr: ValueExpr;
+} | {
+    kind: 'unresolved';
+    fromId: string;
+    fromProperty: string;
+};
+/**
+ * A value read inside a handler or binding, resolved to what the generated code can actually
+ * say. `input-text` and `payload` are context-bound: they only exist inside the owning input's
+ * onChange and the owning receiver's handler respectively — attachment validates that.
+ *
+ * Step 6's additions compose: `format` is a String Format resolved to alternating static text
+ * and sub-expressions (a template literal at emit), and `store-key-get` is a single-key
+ * Subscribe read usable in either context (the selector hook local in render, `.get().<key>`
+ * in a handler).
+ *
+ * The boolean kinds (`logical`, `not`, `truthy` — LOGIC-TARGET §6) are truthiness devices:
+ * their short forms (`a && b`, `!x`, the bare operand) are truthiness-equal to the runtime's
+ * strict-boolean outputs, not value-equal, so analysis admits them into truthiness sinks only
+ * (a Condition's test, another logical's operand, the `enabled` render sink). `truthy` marks a
+ * Condition's `result` — provenance the value-sink gates need, emitted as the bare condition.
+ *
+ * `undefined` is a Component Object property's boot value (COMPONENT-OBJECT-TARGET §3): the
+ * record boots empty and no wire writes the key, so the read is the constant the runtime
+ * would deliver. It is maybe-undefined by definition and folds at its sinks the way the
+ * runtime folds it — format parts to '', truthiness to false, render children/attrs to the
+ * empty/omitted form.
+ */
+/**
+ * EXP-011 §56. The neutral operators a `Filter Records` condition may carry and still translate — the ones
+ * `queryutils.ts`'s local matcher answers from a loaded record alone, after `toParseWhere`'s lowering. Everything
+ * schema-bound (`pointsTo`, `relatedTo`, `textSearch`, the id and geo operators) is refused by name in
+ * `recordFilterReadOf`, because the runtime resolves those through the backend or not at all.
+ */
+export type RecordFilterOp = 'equalTo' | 'notEqualTo' | 'lessThan' | 'greaterThan' | 'lessThanOrEqualTo' | 'greaterThanOrEqualTo' | 'containedIn' | 'notContainedIn' | 'exists' | 'matchesRegex' | 'contains' | 'notContains' | 'containsIgnoreCase' | 'startsWith' | 'notStartsWith' | 'startsWithIgnoreCase' | 'endsWith' | 'notEndsWith' | 'endsWithIgnoreCase' | 'between' | 'notBetween' | 'isEmpty' | 'isNotEmpty';
+/**
+ * EXP-011 §56. A `Filter Records` filter tree as the emitted app evaluates it — the builder's saved shape (either
+ * generation) read the way `savedFilterToNeutral` / `visualQueryToNeutral` read it, with every value either a
+ * static JSON value or the expression wired into the condition's `fp-<name>` port. `connected` carries the runtime's
+ * `dropUnresolvedConnected` rule to the client: a connected condition whose value is `undefined` does not narrow.
+ */
+export type RecordWhere = {
+    and: RecordWhere[];
+} | {
+    or: RecordWhere[];
+} | {
+    field: string;
+    op: RecordFilterOp;
+    value: {
+        kind: 'json';
+        value: unknown;
+    } | {
+        kind: 'expr';
+        expr: ValueExpr;
+    };
+    connected: boolean;
+};
+export type ValueExpr = {
+    kind: 'prop';
+    name: string;
+} | {
+    kind: 'input-text';
+    inputId: string;
+} | {
+    kind: 'store-get';
+    variableName: string;
+} | {
+    kind: 'store-key-get';
+    storeName: string;
+    key: string;
+} | {
+    kind: 'payload';
+    key: string;
+    receiverId: string;
+}
+/**
+ * A `Page Inputs` parameter (EXP-011 Tier 2.5) — one `pm-*` output, read from the url.
+ *
+ * 🔴 **One expression for both stringlists, because the runtime has one namespace.** The node
+ * declares `pathParams` and `queryParams` separately and the editor draws a port per name, but
+ * the Router hands the node a single flat map built as
+ * `Object.assign({}, match.params, urlQuery)` (`router.tsx:456`) — so a name in both lists is
+ * one port, and **every** query parameter in the url overrides the path segment of the same
+ * name, whether or not the author listed it. `?id=99` on `/product/42` reads `99`.
+ *
+ * That is why this carries no `from: 'path' | 'query'` discriminator: a read that consulted
+ * only the list the name was declared in would be a different function from the one the
+ * running app computes, and would differ exactly on the urls a user can type by hand.
+ *
+ * Maybe-undefined by definition — an unmatched segment or an absent query key — and it folds
+ * at its sinks the way the runtime's own Text node folds it ("an empty value renders nothing
+ * rather than the words null or undefined", text.ts).
+ */
+ | {
+    kind: 'page-param';
+    name: string;
+} | {
+    kind: 'literal';
+    value: string | number | boolean;
+} | {
+    kind: 'format';
+    parts: Array<string | ValueExpr>;
+} | {
+    kind: 'logical';
+    op: 'and' | 'or';
+    operands: ValueExpr[];
+} | {
+    kind: 'not';
+    operand: ValueExpr;
+} | {
+    kind: 'truthy';
+    operand: ValueExpr;
+} | {
+    kind: 'undefined';
+}
+/**
+ * A re-hosted Function/Expression output (EXP-003 §4): in render it reads the node's render
+ * local (`formatShoutOut.text`); in a handler it inlines the call over `.get()` snapshots —
+ * legal because the gate admits only pure bodies, so recomputation is unobservable. `fold`
+ * carries Expression's typed getters (`asString` → `String(x ?? '')`, `asNumber` →
+ * `Number(x) || 0`, `asBoolean` → `!!x` — expression.ts, verbatim semantics). `viaState` is
+ * the 4f landing zone (CONTROLLED-STATE-TARGET): an *invoked* node whose outputs feed render
+ * sinks materializes its output record as a state var, and render reads go through it
+ * (`stockCheckOut?.warning`) — maybe-undefined until the first invocation, the runtime's own
+ * pre-first-run contract.
+ */
+ | {
+    kind: 'jsfun-out';
+    nodeId: string;
+    output: string;
+    fold?: 'string' | 'number' | 'boolean';
+    viaState?: string;
+}
+/**
+ * A state var read (CONTROLLED-STATE-TARGET §3.2): the render closure's value in both render
+ * and handler positions. Inside a handler chain the attachment pass applies the chain-local
+ * snapshot rule — a read after a `state-set` in the same chain is rewritten to the written
+ * expression, because the runtime updates state synchronously mid-chain and React closures
+ * do not.
+ */
+ | {
+    kind: 'state-get';
+    name: string;
+    maybeUndefined?: boolean;
+}
+/**
+ * EXP-011 §100. A repeater's relayed row value (`itemOutput-<output>`) read inside a chain one of its rows' relayed
+ * signals runs: the firing row's own value, which the runtime copies onto the repeater before it sends the signal
+ * (`foreach.tsx` `itemOutputSignalTriggered`). Minted only while such a chain is compiled (`rowChainScopes`), valid only
+ * in that repeater's row callbacks, and printed there as what the row is handed for `input` (the row's input the output
+ * passes straight through). `tsType` is the row template's declared output type.
+ */
+ | {
+    kind: 'row-relay';
+    repeaterId: string;
+    output: string;
+    input: string;
+    tsType: string;
+}
+/**
+ * The user-path value inside a control's own onChange (CONTROLLED-STATE-TARGET §4c) — the
+ * `input-text` context rule generalized per control role: `event.target.checked` for a
+ * checkbox, `Number(event.target.value)` for a range, `event.target.value` for a dropdown.
+ */
+ | {
+    kind: 'control-event';
+    controlId: string;
+    form: 'string' | 'checked' | 'number';
+}
+/**
+ * A read of the signed-in user (USER-FAMILY-TARGET §4c) — the `User` node's outputs, which are
+ * getters over the session rather than stored values. `authenticated` is
+ * `model !== undefined` in the runtime, so it is a real boolean and lands at value sinks as
+ * well as truthiness ones; the other three are `model.get(…)` and read undefined while nobody
+ * is signed in, which is exactly the state the stub reports.
+ */
+ | {
+    kind: 'session-get';
+    nodeId: string;
+    field: 'authenticated' | 'id' | 'username' | 'email';
+}
+/**
+ * A named client-side array, read as a list (EXP-011 Tier 1.1).
+ *
+ * The collections slice could reach a named array only as a repeater's feed, through
+ * {@link RepeaterPlan.itemsCollectionName} — a dedicated field, not an expression. That was
+ * enough while `For Each` was the only consumer; `Array Filter` and `Array Map` are a second
+ * and third, and they compose (`notes → filter → map → For Each`), which a per-consumer field
+ * cannot express. So the array becomes an ordinary value expression and the transforms are
+ * ordinary functions of it.
+ *
+ * In render it is the `useCollection` local, so the component re-renders when the array
+ * changes; in a handler it is `.peek()` — a read that deliberately creates no dependency edge,
+ * which is what a handler wants and what `Collection.get()` would get wrong.
+ */
+ | {
+    kind: 'collection-get';
+    collectionName: string;
+}
+/**
+ * FLD-015. A `Static Data` node's `items`, read as a value rather than fed to a repeater —
+ * the hoisted module constant by name.
+ *
+ * 🔴 **Before this existed, `items` had exactly one destination: a `For Each`.** The wire was
+ * matched by target (`toNode.type === 'For Each'`), so an array going anywhere else — a chart
+ * kit's `series`, any custom node with an `array` port — reached no branch at all and left as
+ * *"has no deterministic translation"*. The rows were already hoisted, already typed and
+ * already sitting in the emitted file; nothing could say their name.
+ *
+ * The constant is module scope and frozen at build time, so this reads in every context and is
+ * never undefined — `collection-get`'s answer, for a stronger reason: there is no hook and no
+ * boot value, the array IS the literal.
+ */
+ | {
+    kind: 'static-rows';
+    nodeId: string;
+    constName: string;
+    rowType: string;
+}
+/**
+ * EXP-011 §55. A `Create New Array`'s array, read through an `Array` node bound to it **by wire** — the
+ * handle in the minting component's state row. In render it is the `useCollection` hook local over
+ * `<row> ?? noArray`; in a handler `(<row>?.peek() ?? [])`; inside the mint's own Done chain the
+ * chain-local (`viaLocal`) — `setX` does not change `x` in that closure, and the chain must see the array
+ * it just made (the id nodes' Done-arm rule, §37). Type `any[]`, exactly as `collection-get` answers.
+ */
+ | {
+    kind: 'minted-array-get';
+    nodeId: string;
+    viaLocal?: string;
+}
+/**
+ * `Array Map` over a list (EXP-011 Tier 1.1) — `mapcollectionnode.ts`'s `map({…})` with every
+ * mapping a **property name**, which is `m.set(key, model.get(mapping))` in the runtime and
+ * `{ key: row.mapping }` here.
+ *
+ * ⚠️ A mapping whose value is a *function* is arbitrary JavaScript over a live `Model` and
+ * defers to EXP-003 — {@link parseIdentityMapping} answers null for it, which is the same
+ * gate `For Each`'s own mapping script goes through.
+ */
+ | {
+    kind: 'list-map';
+    source: ValueExpr;
+    entries: Array<{
+        key: string;
+        field: string;
+    }>;
+}
+/**
+ * `Array Filter` over a list (EXP-011 Tier 1.1) — the panel-authored filter, sort and
+ * skip/limit, which are `filterSettings` and not a script (`filtercollectionnode.ts`).
+ *
+ * Each piece is optional and they compose in the runtime's own order: filter, then sort, then
+ * skip, then limit (`scheduleFilter`). Emitting them in any other order would silently change
+ * which rows survive a limit.
+ */
+ | {
+    kind: 'list-filter';
+    source: ValueExpr;
+    tests: Array<{
+        field: string;
+        op: 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte';
+        value: string | number | boolean;
+    }>;
+    sort: Array<{
+        field: string;
+        direction: 'ascending' | 'descending';
+    }>;
+    skip?: number;
+    limit?: number;
+}
+/**
+ * EXP-011 §56. A `Query Records`' result, read as a list: the state row its fetch effect fills (`QueryPlan`),
+ * typed `<TypeName>[]` off the project's declared collection — the same row the repeater branch reads directly.
+ */
+ | {
+    kind: 'query-get';
+    nodeId: string;
+    stateName: string;
+    typeName: string;
+    collectionName: string;
+}
+/**
+ * EXP-011 §56. `Filter Records` over a list — the saved filter tree, the visual sorting and skip/limit, applied
+ * in `scheduleFilter`'s order by `src/lib/filterRecords.ts` (the runtime's local matcher, transcribed). Unlike
+ * `list-filter` the rows keep their static type: a filter selects, it does not reshape.
+ */
+ | {
+    kind: 'record-filter';
+    source: ValueExpr;
+    where: RecordWhere | null;
+    sort: Array<{
+        field: string;
+        direction: 'ascending' | 'descending';
+    }>;
+    skip?: number;
+    limit?: number;
+}
+/** EXP-011 §56. A list transform's `Count` — the derived list's length, always current. */
+ | {
+    kind: 'list-count';
+    source: ValueExpr;
+}
+/**
+ * An `HTTP Request` output (EXP-011 Tier 1.2) — the answer the last request produced.
+ *
+ * Two forms, and which one a read takes is decided by **where the read is**, not by the port:
+ *
+ * - Inside the node's own outcome chain, `viaState` is absent and the read is the chain's
+ *   local (`quoteAnswer.response`, `quoteMessage`). It has to be: the setter has been called
+ *   but React state does not change inside the closure that called it, so a state read here
+ *   would deliver the *previous* request's answer — the chain-local snapshot rule
+ *   (CONTROLLED-STATE-TARGET §3.2) reaching a construct that cannot recompute itself.
+ * - Anywhere else — render, another handler — `viaState` names the state row the call writes,
+ *   maybe-undefined until the first request, which is the runtime's own pre-first-fetch state.
+ *
+ * `output` is a runtime port name: `response`, `statusCode`, `responseHeaders`, `error`, or
+ * an author's Response Mapping as `out-<name>` (`registerOutputIfNeeded` prefixes every one of
+ * them, so a mapping an author calls "response" is `out-response` and cannot collide).
+ */
+ | {
+    kind: 'http-out';
+    nodeId: string;
+    output: string;
+    viaState?: string;
+}
+/** EXP-011 §41 — a `Cloud Function`'s `Error` or an `out-<result>`, the HTTP shape one node over. */
+ | {
+    kind: 'cloud-out';
+    nodeId: string;
+    output: string;
+    viaState?: string;
+}
+/**
+ * EXP-011 §43 — a `Record`'s `Error` or a `prop-<column>`. `tsType` is the column's declared
+ * type off the project's schema snapshot (`tsColumnType`), `unknown` for a column the snapshot
+ * does not carry — the sink decides what an `unknown` needs, as it does for an untyped Variable.
+ */
+ | {
+    kind: 'record-out';
+    nodeId: string;
+    output: string;
+    tsType: string;
+    viaState?: string;
+}
+/**
+ * EXP-011 §45 — a files node's answer, the Record shape with three families behind one kind:
+ * `pick` reads the chosen `File` (`file` is the object itself; `name`/`size`/`type` its
+ * members), `upload` reads the stored file (`cloudFile` the object; `url`/`name`/`contentType`
+ * /`size` its members — and `name` is `cloudFileName(...)`, the prefix stripped as the Cloud
+ * File node strips it), `sign` reads the minted link (`url`/`kind`/`isShareable`/`expiresAt`/
+ * `ttlSeconds`). `error` is the message in every family. A `Cloud File` node resolves to the
+ * `upload` family of the Upload File that feeds it — it holds nothing of its own.
+ */
+ | {
+    kind: 'file-out';
+    family: 'pick' | 'upload' | 'sign';
+    nodeId: string;
+    output: string;
+    tsType: string;
+    viaState?: string;
+}
+/**
+ * EXP-011 §46 — a member of a stored file that is *not* a files node's own answer: a `Cloud
+ * File` fed from a `Record`'s File-typed column reads `source.url` / `cloudFileName(source)` /
+ * `source.contentType` / `source.size`, where `source` is the record's column read (a
+ * `record-out` typed `CloudFile`, in either of its forms). `name` goes through `cloudFileName()`
+ * as the upload family's does; the two optional members are optional here too.
+ */
+ | {
+    kind: 'file-field';
+    source: ValueExpr;
+    field: 'url' | 'name' | 'contentType' | 'size';
+    tsType: string;
+}
+/**
+ * A `Now` output (EXP-011 Tier 1.3) — the instant of the last Read.
+ *
+ * 🔴 **`Now` is not a live clock, and reading it as one is the trap this kind exists to avoid.**
+ * The node's own port description says the outputs "hold the instant of the last Read, not a
+ * live value", and `initialize` seeds `_internal.now` so they are never empty before the first
+ * one. That is a `useState` with a **lazy initializer** — `useState(() => new Date())`, read
+ * once per mount exactly as `initialize` runs once per node. A bare `new Date()` in render
+ * would recompute on every pass and re-render forever; the runtime's own `runOnChange`
+ * vocabulary answered this rather than the export choosing.
+ *
+ * Two forms, and which one a read takes is decided by **where the read is** — the `http-out`
+ * rule (§8.2) reaching the second construct that needs it. `setNow(...)` does not change `now`
+ * inside the closure that called it, so a state read inside the Read chain would deliver the
+ * *previous* instant; the chain binds the instant to a local and reads that. Two bare
+ * `new Date()` calls in one chain could also straddle a millisecond boundary, which is the
+ * same bug wearing a different hat.
+ *
+ * ⚠️ Never maybe-undefined, alone in this family: the row is seeded at mount and every write
+ * is a fresh `Date`, so `now.getTime()` needs no guard.
+ */
+ | {
+    kind: 'now-out';
+    nodeId: string;
+    output: 'date' | 'timestamp' | 'iso';
+    viaState?: string;
+}
+/**
+ * A `Unique Id`'s or `UUID`'s `Id` output (EXP-011 §37) — the row anywhere, the chain's own
+ * local inside the `New` chain, on `now-out`'s rule and for `now-out`'s reason.
+ *
+ * `fn` rides on the expression rather than being looked up from the node, because the one
+ * question every consumer asks about this kind — can the read be empty — is answered by which
+ * generator it is: `randomId` cannot fail, so its row is seeded; `randomUuid` can, so its row
+ * boots `undefined` on a host with no CSPRNG.
+ */
+ | {
+    kind: 'id-out';
+    nodeId: string;
+    fn: 'randomId' | 'randomUuid';
+    viaState?: string;
+}
+/**
+ * `Hash`'s Digest or `Random Bytes`' Value (EXP-011 §59) — `id-out`'s two forms: the row anywhere,
+ * the chain-local (`<local>.digest` / `<local>.value`) inside the node's own Done arm. The row is
+ * always maybe-undefined: neither node seeds it, so it reads nothing until the first Do.
+ */
+ | {
+    kind: 'crypto-out';
+    nodeId: string;
+    node: CryptoNodeKind;
+    viaState?: string;
+    field?: string;
+}
+/**
+ * EXP-011 §76. A `Pattern Extractor`'s value output carries its port as `field` (`match`, `matches`,
+ * `groups`, `firstGroup`, `namedGroups`, `matchCount`); the row is one per field, seeded, never
+ * undefined; inside ANY of the node's four arms the read is the local's field — the Failure arm too,
+ * because a failed pattern clears the values and the render closure's row is the stale one.
+ */
+/**
+ * A `Screen Resolution`'s width, height or aspect ratio (EXP-011 §59) — a number off the
+ * `useScreenResolution` handle, never undefined (the hook seeds from the window at mount).
+ */
+ | {
+    kind: 'screen-out';
+    nodeId: string;
+    local: string;
+    field: (typeof SCREEN_RESOLUTION_OUTPUTS)[number];
+}
+/** EXP-011 §61. A Component Stack's two outputs off its `usePageStack` handle — a string and a number, never undefined. */
+ | {
+    kind: 'stack-out';
+    nodeId: string;
+    local: string;
+    field: (typeof PAGE_STACK_OUTPUTS)[number];
+}
+/**
+ * EXP-011 §61. A pusher's `backResult-<k>`: inside one of its `backAction-*` chains the callback's own
+ * `results` argument (the runtime flags the outputs dirty BEFORE sending the signal, and a state read
+ * there would be the stale closure); anywhere else the row `viaState`, typed `unknown` — the port is `*`.
+ */
+ | {
+    kind: 'stack-back-result';
+    nodeId: string;
+    key: string;
+    viaState?: string;
+    local?: string;
+}
+/**
+ * EXP-011 §60. A key of a component-object record: `<local>.value.<key>` in render, `<local>.get().<key>` in a
+ * handler (live, as `model.get` is). `parent` reads the nearest ancestor's record through the context hook, whose
+ * handle is `undefined` at the root — the read prints `?.` and answers undefined, as the unbound node's output does.
+ * `tsType` is the key's own type (`unknown` for a parent read, or a key with no statically-known own writer).
+ */
+ | {
+    kind: 'component-object-out';
+    nodeId: string;
+    local: string;
+    key: string;
+    parent: boolean;
+    tsType: string;
+}
+/**
+ * A `Drag`'s Drag X / Drag Y / Delta X / Delta Y (EXP-011 §63) — a number off the `useDrag` handle's live getters,
+ * never undefined (the hook seeds all four at mount from Start Drag X/Y).
+ */
+ | {
+    kind: 'drag-out';
+    nodeId: string;
+    local: string;
+    field: 'x' | 'y' | 'deltaX' | 'deltaY';
+}
+/**
+ * The `Error` output of `External Link` or `Navigate To Path` (EXP-011 §24) — the message the
+ * node wrote just before it fired `Failure`.
+ *
+ * One kind for two nodes, because the two ports are the same port: a short string out of
+ * `_internal.lastError`, written immediately before the Failure fork and **never cleared**.
+ * `http-out`'s two forms (§8.2) reaching the third and fourth construct that needs them, and
+ * which form a read takes is decided by **where the read is**:
+ *
+ * - Inside the node's own **Failure** chain, `viaState` is absent and the read is `local` — the
+ *   `const` the failure arm binds the message to. It has to be: the setter has been called but
+ *   React state does not change inside the closure that called it, so a state read there would
+ *   deliver the *previous* failure's message.
+ * - Everywhere else — render, another handler, and **the node's own Done chain** — `viaState`
+ *   names the row the failure arm writes. In the Done chain that is not a concession: the
+ *   interpreter never clears `lastError` either, so a read there is the previous failure's
+ *   message in both, and the stale row is the faithful answer rather than the tolerable one.
+ *
+ * ⚠️ **`Navigate To Path`'s Completed chain gets neither form, and that is the asymmetry this
+ * kind is easiest to get wrong at.** `Completed` is printed as a join *beneath* both arms, so
+ * the failure arm's `const` is out of scope there, while the row is still the pre-render value
+ * — and unlike the Done chain that is now *wrong*, because Completed runs after the failure
+ * that just wrote the message. Neither form is faithful, so the read stays refused.
+ *
+ * `local` is carried on the expression rather than looked up from the node, so the emitter
+ * needs no second table to agree with about a name.
+ */
+ | {
+    kind: 'outcome-error';
+    nodeId: string;
+    local: string;
+    viaState?: string;
+    seeded?: true;
+}
+/**
+ * EXP-011 §76. `seeded` marks an Error row that `initialize` wrote `''` into and every run rewrites — the
+ * extractor's — so the row form is never undefined either. Absent for every other node, whose row reads
+ * undefined until the first failure.
+ */
+/**
+ * One of the five **pure** date nodes (EXP-011 Tier 1.3) — `Date Add`, `Date Compare`,
+ * `Date Difference`, `Date Parts`, `Date To String`.
+ *
+ * They are value-driven: each recomputes whenever any input changes and holds nothing else, so
+ * a node becomes **an ordinary function call** the way Tier 1.1's arrays became ordinary value
+ * expressions. `fn` names a helper in the emitted `src/lib/date.ts`, and `args` are its
+ * arguments in position order — a wired input is the expression that feeds it, an authored one
+ * a literal. They compose, which is the whole point: `Now → Date Add → Date To String` is one
+ * nested expression and needs no per-consumer field to carry it.
+ *
+ * Every input may be wired, `Unit` and `Granularity` included since P109-S21-EXPORTDATEUNITWIRED:
+ * the emitted helpers coerce both as the setters do (`unitOrDays`; an unknown Granularity
+ * truncates nothing), and none of them has a throwing branch.
+ */
+ | {
+    kind: 'date-call';
+    fn: DateHelper;
+    args: ValueExpr[];
+}
+/**
+ * One of the three small **pure** utilities (EXP-011 Tier 2.7) — `Substring`,
+ * `Number Remapper`, `String Mapper`.
+ *
+ * Structurally `date-call`'s twin: a node that is a function of its inputs and holds nothing
+ * else becomes one call into an emitted library, `args` in the helper's parameter order, and
+ * the calls compose. Every clause in this package that walks a `date-call`'s arguments walks
+ * this one's for the same reason, which is why the two are handled together at each of them
+ * rather than by a second copy of each walker.
+ *
+ * They are a separate kind rather than a widened `DateHelper` because the two libraries are
+ * separate modules in the emitted app: a project that formats a date should not ship the
+ * string utilities, and the import lines are earned per helper.
+ *
+ * ⚠️ **`cases` is `mapString`'s table and prints between `args[0]` and `args[1]`.** The two
+ * numbered-input families are index-aligned lists in the interpreter — `inputs[n]` matched by
+ * `indexOf`, `mappings[n]` read off the index it found — and an object literal reproduces that
+ * exactly once two things are true of how it is built: **first-wins on a repeated Input**,
+ * because `indexOf` finds the first and an object literal keeps the last; and a **present key
+ * with an `undefined` value** for an Input whose Mapping was never filled in, because that
+ * publishes empty rather than falling through to Default. Both are done where the table is
+ * built, and the helper's `hasOwnProperty` is the second half of the second one.
+ */
+ | {
+    kind: 'util-call';
+    fn: UtilHelper;
+    args: ValueExpr[];
+    cases?: Array<{
+        from: string;
+        to: string | undefined;
+    }>;
+    /**
+     * P109-S21-EXPORTBLENDNAN — `blendColorKept`'s first argument: the `useRef` local holding the blend this
+     * Color Blend last received and the colour it last showed, declared once per node at the top of the component. 🔴 Both expression walkers
+     * (`collectExprUse` and `hookExprSources`) record it; missing one prints a call naming a local nobody declared.
+     */
+    kept?: string;
+}
+/**
+ * A `States` node's value outputs (EXP-011 §49) — a read off the `useStates` handle the
+ * component declares: `state` is the State output (`<local>.state`), `value` one of the
+ * authored values (`<local>.values.<name>`, typed by its `type-<name>`), `at` an `At <state>`
+ * (`<local>.state === '<state>'`, a real boolean, so it lands at value sinks too), `error` the
+ * last Error (`<local>.error`, undefined until a failure). No `viaState`: the handle *is* the
+ * render-scope value, read the same way in a handler — the hook re-renders the component on
+ * every frame of a tween, and a handler closes over the latest render, which is what the
+ * interpreter's getter answers too.
+ */
+ | {
+    kind: 'states-out';
+    nodeId: string;
+    local: string;
+    field: 'state' | 'value' | 'at' | 'error';
+    name?: string;
+    tsType: string;
+}
+/**
+ * An `Animate To Value`'s `Current Value` (EXP-011 §49) — the number `useAnimatedValue` returns,
+ * never undefined (it boots 0 and only ever holds a number).
+ */
+/**
+ * A `Script` node's value output (EXP-011 §52) — read off the `useScript` handle's `outputs`, which
+ * reads the live record in both modes: render re-renders on every write, and a handler that fires a
+ * signal reads what the code has written so far, exactly as the runtime getter answers. Always
+ * maybe-undefined — an output the code has not written yet reads undefined.
+ */
+ | {
+    kind: 'script-out';
+    nodeId: string;
+    local: string;
+    output: string;
+    tsType: string;
+}
+/**
+ * An `On App Error` boundary's value output (EXP-011 §54) — read off the `useAppError` handle's `last`, the
+ * latest error it accepted, in both modes: the hook re-renders on every accepted error, and a chain fired
+ * by its Error signal reads the error that fired it (the values are updated before the signal, as
+ * onapperror.ts flags them dirty before `sendSignalOnOutput('error')`). Always maybe-undefined — before
+ * the first error there is nothing to read.
+ */
+ | {
+    kind: 'app-error-out';
+    nodeId: string;
+    local: string;
+    field: (typeof ON_APP_ERROR_VALUE_OUTPUTS)[number];
+    tsType: string;
+}
+/**
+ * A streaming node's value output (EXP-011 §58) — a live getter on the hook's handle, read the same way in
+ * both contexts: the host re-renders once per invocation, and a chain fired by one of the node's signals
+ * reads the state the runtime's getter would answer at that moment. `maybeUndefined` is the table's.
+ */
+ | {
+    kind: 'stream-out';
+    nodeId: string;
+    local: string;
+    node: StreamKind;
+    field: string;
+    tsType: string;
+} | {
+    kind: 'animate-out';
+    nodeId: string;
+    local: string;
+};
+/**
+ * A `Script` node's signal input pulsed (EXP-011 §52) — `<local>.signals.<port>()`, one call on the
+ * handle. The code's function for that signal runs after the handler that asked (a microtask), which is
+ * where `scheduleSignal` puts it in the runtime; nothing rides on the action, and the node's signal
+ * outputs are its listeners ({@link ScriptPlan.listeners}), passed once to the hook.
+ */
+/**
+ * A `Run Tasks` node's two action ports (EXP-011 §53) — `Do` is `<local>.run(<items>)`, the list read at
+ * the pulse (the runtime reads `internal.items`, the last value delivered, at `run()`); `Abort` is
+ * `<local>.abort()`. Neither awaits: `run()` schedules its work through the node's own serial queue and
+ * answers through the listeners ({@link RunTasksPlan.listeners}), passed once to the hook.
+ */
+export type RunTasksAction = {
+    kind: 'runtasks-run';
+    nodeId: string;
+    local: string;
+    items: ValueExpr;
+} | {
+    kind: 'runtasks-abort';
+    nodeId: string;
+    local: string;
+};
+/**
+ * P18-S116-QUERYFETCH. A `Query Records`' Fetch (`storageFetch` → `scheduleFetch`): the query asks again, its wired
+ * filter values read at the pulse, and the list is replaced by the answer. `void fetch<Plural>(…).then(set<Plural>)`:
+ * the runtime's fetch is scheduled, so the chain does not wait for it. `values` are {@link QueryPlan.wiredValues}, carried
+ * so every walker sees what the action reads. A query the export does not keep prints nothing (`expandActions`).
+ */
+export type QueryFetchAction = {
+    kind: 'query-fetch';
+    nodeId: string;
+    values: Array<{
+        name: string;
+        expr: ValueExpr;
+    }>;
+};
+export type ScriptSignalAction = {
+    kind: 'script-signal';
+    nodeId: string;
+    /** The `useScript` local. */
+    local: string;
+    port: string;
+};
+export type HandlerAction = 
+/**
+ * A Router navigation (EXP-011 Tier 2.5). `to` is the target page's **authored** url path,
+ * braces and all, and `pathParams` names the expression each braced segment is filled from —
+ * the emitter builds the concrete url, because it is the only place the values exist.
+ *
+ * ⚠️ `query` is the runtime's *leftover* rule, not a second authored list: `getRelativeURL`
+ * substitutes every `pm-` value whose name appears in the path and appends **whatever is
+ * left** as a query string (`router.tsx:625-633`). So a `pm-sort` on a Navigate whose target
+ * path has no `{sort}` is `?sort=…`, and that is a feature authors use rather than an
+ * accident — it is how a page takes an optional parameter without putting it in the route.
+ */
+{
+    kind: 'navigate';
+    to: string;
+    pathParams: Array<{
+        name: string;
+        expr: ValueExpr;
+    }>;
+    query: Array<{
+        name: string;
+        expr: ValueExpr;
+    }>;
+    /**
+     * P18-S110-NEWTAB. `Open In New Tab` ticked: router.tsx `navigateAsync` builds the page's
+     * url and calls `window.open(url, '_blank')` — no features string, no blocked test, `Done`
+     * either way. The exported url is the BrowserRouter path the in-place arm would push.
+     */
+    newTab?: true;
+}
+/**
+ * `Navigate To Path` (EXP-011 §15, session 44) — a navigation to an **authored path string**
+ * rather than to a page component, and four things about it differ from {@link HandlerAction}'s
+ * `navigate` even though the two nodes look like a pair:
+ *
+ * | | `getRelativeURL` (RouterNavigate) | `navigate()` (this node) |
+ * |---|---|---|
+ * | an unset placeholder | left as the literal `{id}`, **and** `?id=undefined` appended | substituted with `''` |
+ * | encoding | `encodeURIComponent` on every value | none — `String(v)` and `q + '=' + v` |
+ * | the query set | whatever is **left over** after substitution | the authored `Query` list |
+ * | an unset query value | n/a | **omitted from the url** |
+ *
+ * 🔴 **So §11.6's rules do not carry across, and copying them would have been wrong in all
+ * four places.** The unset placeholder is the sharpest: it is deferred one node over precisely
+ * because the Router's three readings of it disagree, and it is *translated* here because this
+ * node's own function is coherent about it.
+ *
+ * {@link to} is normalised to exactly one leading slash. The runtime compares trimmed paths
+ * (`_trimUrlPart`, `router.tsx:39`) so `note/42` and `/note/42` are one route there; in
+ * react-router the first is **relative to the current route** and the second is absolute.
+ *
+ * `then` is the `Done` chain and `completedThen` the `Completed` one, in that order, because
+ * `reportOutcome` sends the outcome and then `Completed` (`node.ts:958-995`).
+ *
+ * 🔴 **`newTab` decides which of two different actions this is** (EXP-011 §17, session 46).
+ * Off, the node is `history.pushState` and cannot fail, so `failThen` is empty and
+ * `completedThen` follows the one outcome there is. On, it is `window.open` — which *can* be
+ * refused — so `Failure` becomes live, `Error` becomes writable, and `Completed` stops being
+ * a continuation of `Done` and becomes a **join beneath both arms**. §15.4 earned `Completed`
+ * on "the gates leave exactly one outcome reachable", and opening this arm is exactly the
+ * change that retires that argument rather than inheriting it.
+ */
+ | {
+    kind: 'navigate-path';
+    /** Needed by every registry keyed on the node — the Error row, and the attachment sweep. */
+    nodeId: string;
+    to: string;
+    pathParams: Array<{
+        name: string;
+        expr: ValueExpr;
+    }>;
+    /** `omittable` values print inside the `if` the runtime's `v !== undefined && v !== null` test describes (P107-D21). */
+    query: Array<{
+        name: string;
+        expr: ValueExpr;
+        omittable: boolean;
+    }>;
+    /** The `const` the omittable form collects into; unused when every value is present. */
+    queryLocal: string;
+    /**
+     * 🔴 **This field means “the new-tab arm is reachable”, not “the port is on”** (EXP-011 §18,
+     * session 47). Every consumer already asks it that question — is `Failure` live, is `Error`
+     * writable, is `Completed` a join, is there an outcome to bind — and a wired port answers
+     * all four the same way an authored `true` does, because the tab can still be refused.
+     * What a wire adds is that the *other* arm is reachable too, and that is {@link newTabExpr}
+     * rather than a second reading of this one.
+     *
+     * ⚠️ **`default: false` here and `default: true` on `External Link`** — the two nodes look
+     * like a pair and their unset state lands on opposite sides.
+     */
+    newTab: boolean;
+    /**
+     * The wired `Open In New Tab`, as the expression the emitted handler branches on — set
+     * **only** where the port carries a wire, which is the only way both of this node's two
+     * actions become reachable in one handler (EXP-011 §18).
+     *
+     * 🔴 **The port is answerable because the runtime reads it exactly once, as `!!value`**
+     * (`navigate-to-path.ts:89`, an input `set` that stores a boolean), and `navigate` then
+     * reads that stored boolean (`:204`). ⚠️ `External Link`'s identically-named port is read
+     * **two different ways in two adjacent lines** — truthiness for the features string and
+     * strict equality for the target — which is why a wire defers there and translates here.
+     * The two nodes are not a pair on this port either.
+     *
+     * It is a truthiness sink, so a logic truth value lands here rather than deferring on the
+     * standing rule: the emitted read is the `if` test itself, which coerces exactly as `!!`
+     * does. Read **once**, at the top of the handler, so there is no local to bind it to.
+     */
+    newTabExpr?: ValueExpr;
+    /**
+     * The `const` the `window.open` result binds to. Emitted only where something branches on
+     * it: a new tab with no chains and no Error row is the bare call the graph asked for.
+     */
+    openedLocal: string;
+    /**
+     * The `Error` output as a state row, allocated **by the read** (§14.2's rule, fifth
+     * instance). Only ever set for `newTab`: in-tab, neither of the node's two failures can
+     * fire, so there is no read to earn it.
+     */
+    errorState?: string;
+    /**
+     * The `const` the failure arm binds the message to, set only where something inside that
+     * arm reads `Error` (EXP-011 §24). Minted by the read, like the row above it — the
+     * commonest node here reads neither and emits neither.
+     */
+    errorLocal?: string;
+    then: HandlerAction[];
+    /** The `Failure` chain — reachable only for `newTab`, where the browser can refuse. */
+    failThen: HandlerAction[];
+    completedThen: HandlerAction[];
+}
+/**
+ * `External Link` (EXP-011 Tier 2.5) — `window.open`, plus the two outcome chains the
+ * runtime's own fork owes (`externallink.ts`).
+ *
+ * The emitted shape is the interpreter's, guard for guard:
+ *
+ * ```
+ * const link = donateUrl;                       // bound once — the guard and the open must
+ * if (link === undefined || link === null || link === '') { …failThen }   //   read one value
+ * else if (!window.open(link, '_blank', 'noopener,noreferrer')) { …failThen }
+ * else { …then }
+ * ```
+ *
+ * 🔴 **`Open In New Tab` unset is `true`, not `undefined`.** The port declares `default: true`
+ * and `registerInput` writes a declared default straight into `_inputValues` (`node.ts:138`),
+ * so `getInputValue` never sees the `undefined` its own target expression tests for — which is
+ * what makes {@link newTab} a plain boolean here rather than a third state.
+ *
+ * That question is worth asking because the runtime reads this one input **two different ways
+ * in two adjacent lines**: `params` is truthiness (`openInNewTab ? … : ''`) and `target` is
+ * strict equality (`=== true || === undefined`). They agree for `true`, for `false` and for
+ * the unset port — every value the *editor* can put there — and disagree for every other
+ * truthy value, which only a wire can deliver. So a wired `Open In New Tab` defers, and the
+ * three cases that remain are the three an author can actually author.
+ *
+ * ⚠️ **There is no `unchanged` arm and its absence is a decision.** The runtime reports
+ * `unchanged` when `typeof window === 'undefined'` — a server-side render. The scaffold
+ * mounts with `createRoot` (`scaffold.ts:249`) and has no server pass at all, so that chain
+ * is unreachable in the exported app exactly as it is in the app running in a browser. The
+ * wire is dropped with a note rather than deferring the node, on `Clear Array`'s rule: a wire
+ * already dead in the interpreter must not cost a translation.
+ */
+ | {
+    kind: 'external-link';
+    /** The node, so the attachment pass and the late row sweep can find it (§14). */
+    nodeId: string;
+    link: ValueExpr;
+    /** `Open In New Tab` — resolved here, because only an unwired port reaches this action. */
+    newTab: boolean;
+    /**
+     * The chain-local the link binds to, emitted only where the empty-link guard needs it —
+     * the guard and the `window.open` must read one value, not two evaluations of one
+     * expression (a link read from a Variable can change between them).
+     */
+    local: string;
+    /**
+     * The local the blocked-tab test binds to, emitted only for a new tab whose outcome is
+     * read (EXP-011 §14).
+     *
+     * 🔴 **The binding is the correctness, and it is not a tidiness choice.** `window.open`
+     * **consumes** the transient activation — measured in Chrome 151, one control arm varying
+     * only whether the call sits between two reads of `navigator.userActivation.isActive`:
+     * without it both reads are `true`, with it the second is `false` while a tab opens. So
+     * the emitted test had to move *before* the call, exactly where the runtime reads it
+     * (`externallink.ts:96`). Read after, it is `false` on every tab successfully opened —
+     * which is DEF-016's own symptom, reintroduced on the export side by DEF-016's fix.
+     */
+    blockedLocal: string;
+    /**
+     * False only where the link is provably non-empty — a non-empty literal. The runtime
+     * refuses before touching the browser on `undefined`, `null` and `''`, and `window.open('')`
+     * opens a blank tab, so this guard is observable even with no Failure chain wired.
+     */
+    guardLink: boolean;
+    /**
+     * The `Error` output as a state row (EXP-011 §14), filled by the late sweep and undefined
+     * where nothing reads it — which is the ordinary case, and why a button opening a literal
+     * url still emits one expression and no `useState`.
+     *
+     * 🔴 **This is the field that makes the two failures tell themselves apart.** Everywhere
+     * else in this action they are one arm, because "no link" and "the browser blocked the
+     * tab" both run the Failure chain and nothing else. `Error` is the one port that
+     * distinguishes them — two static strings, `externallink.ts:62` and `:101` — so the
+     * emitted failure arm re-tests the link to pick the message. Both strings are the node's
+     * own `_internal.lastError`, which is the SHORT one; the longer sentence beside it goes to
+     * the outcome channel, not to this port.
+     */
+    errorState?: string;
+    /**
+     * The `const` the failure arm binds the message to (EXP-011 §24), set only where something
+     * inside that arm reads `Error`.
+     *
+     * 🔴 **It is what stops the message being computed twice.** The write above picks between
+     * two strings by re-testing the link; a chain reading `Error` would otherwise have to print
+     * that same ternary again at every sink, and the two copies would be free to disagree.
+     */
+    errorLocal?: string;
+    then: HandlerAction[];
+    failThen: HandlerAction[];
+} | {
+    kind: 'emit';
+    channelName: string;
+    payload: Array<{
+        key: string;
+        expr: ValueExpr;
+    }>;
+}
+/**
+ * EXP-011 §74. `fallback`: the value typed into the Set's own port UNDER the wire `expr` came from, kept only when
+ * `expr` may read `undefined` — the runtime writes the wire's last defined delivery, else the typed-in value
+ * (measured: `exp-011-s96-a-literal-under-a-wire.test.ts`), so the handler prints `expr ?? fallback`. Absent when
+ * nothing is typed in, or when the wire's source always carries a value (the typed-in value is then never written,
+ * in the runtime or here — a note says so).
+ *
+ * P18-S127-SETDONE (EXP-011 §95). `then`: the Set's Done chain, then its Completed chain, as following statements
+ * (`expandActions`), present only when something hangs off them. The runtime writes, notifies every Variable reading
+ * the name, then sends Done and Completed (`setvariablenode.ts` `scheduleStore`), and a Done's target is updated before
+ * the click's next wire (it is flagged dirty with its sender and pulls it first): depth first, as printed.
+ */
+ | {
+    kind: 'store-set';
+    variableName: string;
+    expr: ValueExpr;
+    fallback?: string | number | boolean;
+    then?: HandlerAction[];
+} | {
+    kind: 'globalstore-set';
+    storeName: string;
+    key: string;
+    expr: ValueExpr;
+    fallback?: string | number | boolean;
+}
+/**
+ * `Set Object Properties` on a named Object (EXP-011 §47): one patch over every wired property
+ * the node's list admits — `profile.set({ name: …, city: … })` — then its Done chain as
+ * following statements. No failure arm: with a literal Id the runtime's only failure (no
+ * object bound) is unreachable, because `Model.get` creates the object on read.
+ */
+ | {
+    kind: 'object-set';
+    storeName: string;
+    entries: Array<{
+        key: string;
+        expr: ValueExpr;
+        fallback?: string | number | boolean;
+    }>;
+    then: HandlerAction[];
+}
+/**
+ * EXP-011 §60. `Set Component Object Properties` (`parent: false`) — `<local>.set({ … })`, then Done, then Completed, as
+ * following statements (one arm, always taken: the self variant cannot miss its own record). `Set Parent Component
+ * Object Properties` (`parent: true`) — the block form: `if (<local> === undefined) { raise no-ancestor; failThen }
+ * else { <local>.set({ … }); then }` — the runtime's `resolution.id === undefined` fork in base.ts, verbatim.
+ */
+ | {
+    kind: 'component-object-set';
+    nodeId: string;
+    local: string;
+    parent: boolean;
+    entries: Array<{
+        key: string;
+        expr: ValueExpr;
+    }>;
+    then: HandlerAction[];
+    completedThen: HandlerAction[];
+    failThen: HandlerAction[];
+} | {
+    kind: 'collection-add';
+    collectionName: string;
+    entries: Array<{
+        key: string;
+        expr: ValueExpr;
+    }>;
+    minted?: MintedTarget;
+}
+/**
+ * `Clear Array` (EXP-011 Tier 1.1) — `notes.clear()`, plus the two chains the runtime's own
+ * outcome fork owes.
+ *
+ * `collectionnode-clear.ts` measures `wasEmpty` **before** `set([])` and reports `unchanged`
+ * for an array that was already empty, `done` otherwise (ERG-001: "the post-condition already
+ * held"). So a `done` chain emitted unconditionally would fire where the interpreter stays
+ * silent. The emitted form tests the length instead of keeping a local, which is exact rather
+ * than merely close: `Collection.clear()` is itself `if (length === 0) return`, so skipping
+ * the call on the empty arm is the same no-op the guard would have made.
+ */
+ | {
+    kind: 'collection-clear';
+    collectionName: string;
+    then: HandlerAction[];
+    unchangedThen: HandlerAction[];
+    minted?: MintedTarget;
+}
+/**
+ * `Remove Object From Array` (EXP-011 §30) — `notes.remove(item)`, inside the row callback of
+ * the repeater named by {@link repeaterId}.
+ *
+ * 🔴 **This action is only meaningful in one place, and the type says so.** The node's Object
+ * Id is a `For Each`'s `itemActionItemId`, which the runtime sets to `model.getId()` of the
+ * row that fired *immediately before* pulsing `itemOutputSignal-<name>` (`foreach.tsx`). Read
+ * anywhere else it is "whichever row fired last", which the emitted list holds no state for —
+ * so `actionsValidIn` refuses this action outside that repeater's own row signal, and the row
+ * the interpreter names becomes the `item` the callback already closes over.
+ *
+ * There is no `unchangedThen` and no failure arm because in this shape neither can fire, and
+ * the compile proves it rather than assuming it: see `compileCollectionRemove`.
+ */
+ | {
+    kind: 'collection-remove';
+    collectionName: string;
+    repeaterId: string;
+    then: HandlerAction[];
+    minted?: MintedTarget;
+}
+/**
+ * A Condition in a handler chain: `if (cond) whenTrue; else whenFalse;` (LOGIC-TARGET §3). `flat` (EXP-011 §87): a
+ * Condition whose answer is a literal and which writes its sinks' cells has one side; its `cond` is `true`, its
+ * `whenFalse` empty, and `whenTrue` prints as following statements.
+ */
+ | {
+    kind: 'branch';
+    cond: ValueExpr;
+    whenTrue: HandlerAction[];
+    whenFalse: HandlerAction[];
+    flat?: true;
+}
+/** Fires the component's own signal output: `onWaved?.()` (COMPONENT-OUTPUTS-TARGET §4). */
+ | {
+    kind: 'output-signal';
+    prop: string;
+}
+/**
+ * Opens a popup slot: `setOpenPopup('AboutDialog')`, then the Show Popup's `done`-chain as
+ * following statements in the same handler (POPUPS-TARGET §3).
+ */
+ | {
+    kind: 'popup-show';
+    slotKey: string;
+    then: HandlerAction[];
+}
+/**
+ * Closes the enclosing popup through the reserved prop (POPUPS-TARGET §4): with a
+ * `done`-chain, `if (onClose) { onClose('ok'); …then }`; without one, `onClose?.('ok')`.
+ * `action` undefined is the plain `Close` (the runtime's `Closed` outcome).
+ */
+ | {
+    kind: 'popup-close';
+    action?: string;
+    then: HandlerAction[];
+}
+/**
+ * A pure Function/Expression fired from a handler chain (EXP-003 §4 A2h): the actions its
+ * `done` wires described, in wire order. The node's own compute needs no statement — output
+ * reads inside the chain inline the call at their sinks, and a pure body run without reading
+ * its outputs is unobservable. `done` is invocation-only in both runtimes, so this is exact.
+ * `materialize` (CONTROLLED-STATE-TARGET §4f) names the state var the run writes when the
+ * node's outputs also feed render sinks: `setStockCheckOut(stockCheck({ … }))` precedes the
+ * chain, and render reads go through the var.
+ * `ticked` (P18-S119-TICKEDRUN) marks the run a ticked input's new value starts (`TickedRunPlan`): it has no Done, and
+ * its effect has already recorded the values it read.
+ */
+ | {
+    kind: 'jsfun-run';
+    nodeId: string;
+    then: HandlerAction[];
+    materialize?: string;
+    ticked?: true;
+    /**
+     * EXP-019 slice 1b (session 134). The body awaits at its top level: where in `then` the chain the runtime sends after
+     * the run's promise settles begins (Success, then Done), after the chains of the signals the body sent before its
+     * first `await`. Printed whole (`runFunction`, the pulses, `await <run>.settled`, the rest) and awaited like a request,
+     * so §90's `detached` lets the click's later wires run before it settles.
+     */
+    awaitsAt?: number;
+    /** EXP-011 §90, as an api call's. */
+    detached?: true;
+}
+/**
+ * EXP-011 §86. The chains of a Function's own signals (`Outputs.go()`), first in its run's `then`: one loop over the
+ * pulses the run sent, in the order it sent them, each arm (`jsfun-pulse`) the chain of one signal. Inside an arm the
+ * Function's outputs read as that pulse's targets read them (C7 lockstep, `src/lib/functionRun.ts`).
+ */
+ | {
+    kind: 'jsfun-pulses';
+    nodeId: string;
+    then: HandlerAction[];
+}
+/** EXP-011 §86. One signal's chain inside `jsfun-pulses`: the actions its wires describe, in wire order. */
+ | {
+    kind: 'jsfun-pulse';
+    nodeId: string;
+    signal: string;
+    then: HandlerAction[];
+}
+/**
+ * A state var write (CONTROLLED-STATE-TARGET §3.3). `op` is a functional update
+ * (`setX(v => !v)`) — immune to closure staleness, which is why Switch's `flip` and
+ * Counter's arithmetic use it, never `expr`.
+ */
+ | {
+    kind: 'state-set';
+    name: string;
+    expr?: ValueExpr;
+    op?: 'toggle' | 'inc' | 'dec';
+    field?: FieldWrite;
+}
+/**
+ * P18-S128-FIELDSET (EXP-011 §97). A text field's Focus or Blur: `focus()` / `blur()` on the exported `<input>` through a
+ * ref, as the runtime's focus tracker calls them on the viewer's own (`_focus`, `_blur`). A field that is not on the page
+ * takes nothing, and the Focus is not held (GAM-012 R13): the ref is `null` then.
+ */
+ | {
+    kind: 'field-focus';
+    inputId: string;
+    focus: boolean;
+}
+/**
+ * An awaited call into an api stub (RECORD-VERBS-TARGET §4, USER-FAMILY-TARGET §4e): the
+ * vocabulary's asynchronous action. The emitted handler becomes `async`, the call is awaited,
+ * `then` is the `done` chain — which is where `reportOutcomes(…, 'done')` sits in the runtime,
+ * after the service answers — and the catch writes `errorState`, the node's `Error` output,
+ * which the runtime never clears once set.
+ *
+ * ⚠️ **One kind, two families.** The record verbs and the user family emit the *same* action;
+ * they differ only in `fnName` and in the shape of `args`. USER-FAMILY §4e records why this is
+ * a rename of `record-op` rather than a sibling case beside it: a new discriminant recruits
+ * every switch site silently and the wrong ones fail without throwing (s19's dispatcher trap),
+ * whereas a rename is a compile error at each site until it is handled.
+ */
+ | {
+    kind: 'api-call';
+    /**
+     * EXP-011 §90. Set by the planner's last pass where a later action of the same list follows it: printed as
+     * `void (async () => { … })();`, so the click's later wires run before the answer arrives, as the runtime's do
+     * (each node acts after the update; the request answers later). A failure before the first await (the
+     * `Missing Record Id` guard) still runs its chain first, as the runtime's synchronous `setError` does.
+     */
+    detached?: true;
+    nodeId: string;
+    /** What produced the call — for notes and the stub's provenance line. EXP-011 §62: the relation pair rides the same action. */
+    verb: 'create' | 'update' | 'delete' | RelationVerb | UserVerb;
+    /** The api module's exported function: `createPuppy` / `updatePuppy` / `logIn` / `logOut`. */
+    fnName: string;
+    /**
+     * The call's arguments, in position order. `updatePuppy(id, {…})` is `[expr, data]`,
+     * `logIn(u, p)` is `[expr, expr]`, `logOut()` is `[]`.
+     */
+    args: ApiCallArg[];
+    /**
+     * Refuse before calling when the leading id argument is absent or empty, the way the
+     * runtime does (RECORD-VERBS-TARGET §1): `setModelID` reads `undefined`/`null`/`''` as
+     * *clear the binding*, after which every verb answers `setError('Missing Record Id')` and
+     * never reaches the backend. Gate 9 already defers an id that is **statically** absent;
+     * this is its dynamic twin, and the corpus reaches it because every emitted component prop
+     * is optional, so an id wired from one is `string | undefined` at the call.
+     *
+     * False only where the guard is provably dead — a non-empty literal id, and every `create`,
+     * which takes no id at all.
+     */
+    guardId: boolean;
+    /**
+     * EXP-011 §72. The id argument is read from a source typed `unknown` — a Variable nothing
+     * statically writes, or one written by a Function or an HTTP body — and the client's
+     * parameter is `string`: the emitter prints `String(x ?? '')` around the read. The runtime
+     * keys `Model.get(id)` by the value and the client `encodeURIComponent`s it, so the
+     * coercion transcribes both; an empty read still meets `guardId`'s `Missing Record Id`.
+     * Absent for a `string` source — a `string | undefined` narrows on its own.
+     */
+    coerceId?: 'string';
+    /**
+     * EXP-011 §62. The relation verbs' dynamic pre-flight, in the runtime's own order and its own
+     * words (`validateInputs`): a positional argument that is empty at the click throws that
+     * sentence into the catch — *No target record Id (the record to add a relation to) specified*
+     * before *No record Id specified (the record that should get the relation)*, because the
+     * runtime asks about the target first. Printed after `guardId`'s line; emitted only for an
+     * argument that is not a literal (a literal is never empty — the planner refused that).
+     */
+    guards?: Array<{
+        index: number;
+        local: string;
+        message: string;
+        coerce?: 'string';
+    }>;
+    errorState: string;
+    /**
+     * EXP-011 §44 — write `undefined` to the Error row the moment the call answers, before the
+     * done chain: `Request Magic Link` is the one verb whose success clears its Error. Every
+     * other `api-call` keeps the runtime's "never cleared" (RECORD-VERBS-TARGET §1).
+     */
+    clearErrorOnDone?: true;
+    then: HandlerAction[];
+    /**
+     * EXP-011 §90. The `failure` chain, printed in the catch after the Error row and the raise: the runtime's
+     * `setError` writes the row, raises, then pulses Failure (`node.ts` `reportOutcome`). A read of this node's Error
+     * inside it is the catch's `<errorState>Message` local (`outcome-error`), never the row.
+     */
+    failThen: HandlerAction[];
+}
+/**
+ * An `HTTP Request`'s `Fetch` (EXP-011 Tier 1.2) — the vocabulary's second asynchronous action,
+ * and the first whose *failure* is a chain rather than only a value.
+ *
+ * The emitted shape is the runtime's own three outcomes, not two:
+ *
+ * ```
+ * try {
+ *   const answer = await fetchQuote({ … });   // throws only where no answer arrived
+ *   setQuoteOut(answer);                      //   response/statusCode/headers/fields — set for ANY answer
+ *   if (answer.ok) { …then }
+ *   else { const message = answer.error; setQuoteError(message); …failThen }
+ * } catch (error) {
+ *   const message = error instanceof Error ? error.message : String(error);
+ *   setQuoteError(message); …failThen
+ * }
+ * ```
+ *
+ * 🔴 **A non-2xx still writes the value outputs, and a network error still does not.**
+ * `processResponse` runs before `doFetch` reports `failure`, so a 404's body and status are on
+ * the node's outputs while `Failure` fires; a request that never reached the server leaves
+ * `Response` and `Status Code` holding exactly what they held. Splitting the answer from the
+ * throw is what reproduces both — the record verbs' single try/catch could not, because for
+ * them a refused write has nothing to publish.
+ *
+ * `failThen` is therefore emitted **twice**, once per arm, and the two arms are identical by
+ * construction because both bind `message` first. A join would need a `finally` that can tell
+ * which arm it is in, which is a variable the arms already are.
+ */
+ | {
+    kind: 'http-call';
+    /** EXP-011 §90, as `api-call`'s. */
+    detached?: true;
+    nodeId: string;
+    /** `src/api/http.ts`'s exported function for this node. */
+    fnName: string;
+    /** Wired inputs, in the emitted parameter order — `{ tag: tagText }` at the call. */
+    args: Array<{
+        param: string;
+        expr: ValueExpr;
+    }>;
+    /** The state row the answer is written to, when anything outside the chain reads a value. */
+    materialize?: string;
+    /** The `Error` output's row — written on every failure, never cleared (the runtime's own). */
+    errorState: string;
+    then: HandlerAction[];
+    failThen: HandlerAction[];
+}
+/**
+ * A `Cloud Function`'s `Call` (EXP-011 §41) — the request's shape one hop in: the function
+ * throws where the interpreter reports Failure (an answered error or an unreachable backend),
+ * so the two outcome chains are a try/catch's two arms.
+ *
+ * ```
+ * try {
+ *   const answer = await callPublishPage({ pageId });   // throws on any failure
+ *   setPublishOut(answer);                               // only where something outside the chain reads a result
+ *   …then
+ * } catch (error) {
+ *   const message = error instanceof Error ? error.message : String(error);
+ *   setPublishError(message); …failThen
+ * }
+ * ```
+ */
+ | {
+    kind: 'cloud-call';
+    /** EXP-011 §90, as `api-call`'s. */
+    detached?: true;
+    nodeId: string;
+    /** `src/api/functions.ts`'s exported function for this node. */
+    fnName: string;
+    /** Wired parameters, in the emitted parameter order — `{ pageId: pageIdValue }` at the call. */
+    args: Array<{
+        param: string;
+        expr: ValueExpr;
+    }>;
+    /** The results row, when anything outside the chain reads a result. */
+    materialize?: string;
+    /** The `Error` output's row — written on every failure, never cleared (the runtime's own). */
+    errorState: string;
+    then: HandlerAction[];
+    failThen: HandlerAction[];
+}
+/**
+ * A `Record`'s `Fetch` (EXP-011 §43) — the Cloud Function shape with one argument, the Id:
+ *
+ * ```
+ * try {
+ *   const pageRecord = await fetchPageById(pageId.get());
+ *   setPageRow(pageRecord);          // only where something outside the chain reads a column
+ *   …then
+ * } catch (error) {
+ *   const message = error instanceof Error ? error.message : String(error);
+ *   setPageError(message); …failThen
+ * }
+ * ```
+ * An empty Id throws `Missing Id.` inside the try — the runtime's own sentence, reported as
+ * Failure before any request (`scheduleFetch`) — so it lands in the catch like every other failure.
+ */
+ | {
+    kind: 'record-fetch';
+    /** EXP-011 §90, as `api-call`'s. */
+    detached?: true;
+    nodeId: string;
+    /** The collection module's exported `fetch<Type>ById`. */
+    fnName: string;
+    id: ValueExpr;
+    /** EXP-011 §72. `id` is typed `unknown` — printed `String(id ?? '')`, as `api-call`'s `coerceId`. */
+    coerceId?: 'string';
+    /** The record row, when anything outside the chain reads a column. */
+    materialize?: string;
+    /** The `Error` output's row — written on every failure, never cleared (the runtime's own). */
+    errorState: string;
+    then: HandlerAction[];
+    failThen: HandlerAction[];
+}
+/**
+ * `Open File Picker`'s `Open` (EXP-011 §45) — `pickFile()` from `src/lib/util.ts`, which is the
+ * node's `<input type=file>` and its two listeners as one promise: a `File` on `change` with a
+ * file, `undefined` on `change` with none or on `cancel`, a rejection where `click()` threw.
+ *
+ * ```
+ * try {
+ *   const picked = await pickFile({ accept: 'image/*' });
+ *   if (picked === undefined) { …unchangedThen }
+ *   else { setPickedFile(picked); …then }
+ * } catch (error) {
+ *   const message = error instanceof Error ? error.message : String(error);
+ *   setPickError(message); …failThen
+ * }
+ * ```
+ * The row is written only on Done — Unchanged leaves every output exactly as it was, which is
+ * the port's definition, and Failure writes only the Error (openfilepicker.ts).
+ */
+ | {
+    kind: 'file-pick';
+    /** EXP-011 §90, as `api-call`'s. */
+    detached?: true;
+    nodeId: string;
+    accept?: ValueExpr;
+    capture?: ValueExpr;
+    /** The chosen-file row, when anything outside the Done chain reads the file or its metadata. */
+    materialize?: string;
+    errorState: string;
+    then: HandlerAction[];
+    unchangedThen: HandlerAction[];
+    failThen: HandlerAction[];
+}
+/**
+ * `Upload File`'s `Upload` (EXP-011 §45) — the Cloud Function shape with the file as the one
+ * argument: `uploadFile(file, { private })` from `src/api/files.ts`, which is the client's
+ * `POST /files/<name>` with the bytes as the body and `X-NodeGX-File-Private` where asked.
+ * `No file specified` is thrown inside the try where the file is unset — the node's own
+ * sentence, reported as Failure before any request (uploadfile.ts).
+ */
+ | {
+    kind: 'file-upload';
+    /** EXP-011 §90, as `api-call`'s. */
+    detached?: true;
+    nodeId: string;
+    file: ValueExpr;
+    /** `Private` — absent where unset or authored false; a literal `true` or the wired expression otherwise. */
+    isPrivate?: ValueExpr;
+    materialize?: string;
+    errorState: string;
+    then: HandlerAction[];
+    failThen: HandlerAction[];
+}
+/**
+ * `Sign File URL`'s `Sign` (EXP-011 §45) — `signFileUrl(file)` from `src/api/files.ts`, the
+ * client's `GET /files/<name>/sign`; `No file specified` thrown for an unset file, as above.
+ */
+ | {
+    kind: 'file-sign';
+    /** EXP-011 §90, as `api-call`'s. */
+    detached?: true;
+    nodeId: string;
+    file: ValueExpr;
+    materialize?: string;
+    errorState: string;
+    then: HandlerAction[];
+    failThen: HandlerAction[];
+}
+/**
+ * `Now`'s `Read` (EXP-011 Tier 1.3) — re-read the clock, then run the `done` chain.
+ *
+ * ```
+ * const nowRead = new Date();   // bound, so every read in the chain is the SAME instant
+ * setNow(nowRead);              // only where something outside the chain reads it
+ * …then
+ * ```
+ *
+ * Synchronous, so `done` is the statements that follow rather than an arm: `_read` flags the
+ * three outputs dirty and reports `done` in the same call, with no branch where it declines.
+ * There is deliberately no failure arm — the node's own comment says reading the clock cannot
+ * fail, and two Reads in the same millisecond still re-read.
+ *
+ * `materialize` is filled in the verdict sweep, never at compile time: a render read of
+ * `Timestamp` resolves passes later, so asking "does anything read this" here answers *no* for
+ * every render read there is (§8.3's allocation-order rule, third instance).
+ */
+ | {
+    kind: 'date-now-read';
+    nodeId: string;
+    /** The chain-local the instant binds to — what a read inside `then` says. */
+    local: string;
+    /** The state row the instant is written to, where anything outside the chain reads it. */
+    materialize?: string;
+    then: HandlerAction[];
+} | IdNewAction | CryptoCallAction | StackPushAction | StackPopAction | StackResetAction | ArrayNewAction | LogAction | DelayAction | StatesGoAction | DragSnapAction | ScriptSignalAction | RunTasksAction | QueryFetchAction | StreamAction;
+/**
+ * A streaming node's action port pulsed (EXP-011 §58) — `<local>.<verb>(<data>)`. `value` is the data port's
+ * expression, read AT THE PULSE (the runtime appends the last delivered Chunk / Data when the pulse lands, and
+ * the chain that pulses may have written it a statement earlier — `runtasks-run`'s rule); absent when the port
+ * has no source, in which case the call takes no argument and the setter never ran. The node's signal outputs
+ * are its listeners ({@link StreamPlan.listeners}), passed once to the hook.
+ */
+export type StreamAction = {
+    kind: 'stream-action';
+    nodeId: string;
+    local: string;
+    verb: string;
+    value?: ValueExpr;
+};
+/**
+ * A `States` node's `Toggle` or `To <state>` (EXP-011 §49) — one call on the `useStates` handle:
+ * `<local>.toggle()` or `<local>.goTo('<state>')`.
+ *
+ * ⚠️ **No chains ride on the action, and that is the node's own shape, not a shortcut.** Done,
+ * Unchanged and Failure are *ports of the node*, pulsed by `reportOutcome` whichever trigger asked
+ * — a chain wired off `done` fires for a Toggle and for every `To <state>` alike — so they are
+ * listeners on the node ({@link StatesPlan.listeners}), compiled once, not arms printed at each
+ * call site. The interpreter drains requests after the pass, so the outcome arrives from a
+ * microtask; the handler that asked has already finished, exactly as it has there.
+ */
+export type StatesGoAction = {
+    kind: 'states-go';
+    nodeId: string;
+    /** The `useStates` local. */
+    local: string;
+    verb: 'toggle' | 'to';
+    /** The state a `To <state>` names; absent for Toggle. */
+    state?: string;
+};
+/**
+ * A `Drag`'s Snap To Position X / Y — Do (EXP-011 §63): one call on the handle, always an expression. Its Done is the
+ * node's listener — `outcomeOnInnerComponent` reports `done` for every snap call whichever port asked — so it is passed
+ * once to the hook, not printed as an arm here; Failure cannot fire in the emitted app and is dropped with a note.
+ */
+export type DragSnapAction = {
+    kind: 'drag-snap';
+    nodeId: string;
+    /** The `useDrag` local. */
+    local: string;
+    axis: 'x' | 'y';
+};
+/**
+ * A `Log`'s `Log` (EXP-011 §39) — `log(level, message, data)` into `src/lib/util.ts`, then the
+ * Done chain as following statements (`popup-show`'s treatment: the write is synchronous and has
+ * one outcome, so the chain is not an arm).
+ *
+ * `message` is `undefined` where nothing is authored or wired — the helper prints `''` for it,
+ * as `_write` does. `data` is absent (not `undefined`) where the port is unset, because the
+ * runtime writes the data argument only when one arrived, and `console.info('x', undefined)`
+ * prints a trailing `undefined` the interpreter never prints.
+ */
+export type LogAction = {
+    kind: 'log';
+    nodeId: string;
+    level: LogLevel;
+    message: ValueExpr;
+    data?: ValueExpr;
+    then: HandlerAction[];
+};
+/**
+ * One of a `Delay`'s three actions (EXP-011 §39) — `startDelay`/`restartDelay`/`stopDelay` from
+ * `src/lib/timer.ts` over a `useRef` the component declares per node.
+ *
+ * Four chains, and which ones an arm prints depends on the verb:
+ *
+ * | verb | `then` (Done) | `unchangedThen` | `startedThen` / `finishedThen` |
+ * |---|---|---|---|
+ * | `start` | began a countdown | one was already running | passed as the two callbacks |
+ * | `restart` | always | never — Restart cannot no-op (timer.ts) | passed as the two callbacks |
+ * | `stop` | abandoned a running countdown | nothing was running | not this verb's — a stopped countdown never fires them |
+ *
+ * `startDelay` and `duration` are read where the handler is, so a `Set Variable` earlier in the
+ * chain reaches them (the snapshot rule). The two callback chains run *later*, in a timeout, and
+ * close over the same handler scope — the shape `http-call`'s continuations already have.
+ */
+export type DelayAction = {
+    kind: 'delay';
+    nodeId: string;
+    verb: TimerTrigger;
+    /** The `useRef` local this node's timer handle lives in — one per node, shared by its verbs. */
+    ref: string;
+    startDelay: ValueExpr;
+    duration: ValueExpr;
+    then: HandlerAction[];
+    unchangedThen: HandlerAction[];
+    startedThen: HandlerAction[];
+    finishedThen: HandlerAction[];
+};
+/**
+ * A `Unique Id`'s or `UUID`'s `New` (EXP-011 §37) — `date-now-read`'s shape, with a failure arm
+ * on one of the two nodes and none on the other.
+ *
+ * 🔴 **One kind for both nodes, discriminated by `fn`.** §9.4 counted eleven sites that enumerate
+ * this union and named the five the compiler does not hold; a second action kind would have paid
+ * that toll twice for two nodes whose only structural difference is whether `failThen` can be
+ * non-empty. `ID_NODES.canFail` is the fact, and it is stated once.
+ *
+ * Like `date-now-read`, `materialize` and `errorMaterialize` are filled in the verdict sweep and
+ * never at compile time — a render read of `Id` resolves passes later, so asking "does anything
+ * read this" here answers *no* for every render read there is (§8.3's allocation-order rule).
+ */
+/**
+ * EXP-011 §55. A mutator's Array Id fed by a `Create New Array`'s `id` — the handle, never a string.
+ *
+ * `stateName` is the minting component's row; `viaLocal` is set when the mutator sits inside the mint's own
+ * Done chain (the chain-local is the array just made). Outside that chain the handle can be `null` — no Do
+ * has fired — which is the runtime's `<prefix>/no-array` Failure: the emitter prints the guard, the raise on
+ * the error channel (§54) with the node's own message, and `failThen`. `Remove` never guards: its row exists
+ * only because the handle did (§30's gate 3, restated over the handle).
+ */
+export type MintedTarget = {
+    /** The `Create New Array` node. */
+    nodeId: string;
+    stateName: string;
+    viaLocal?: string;
+    /** The mutator node — the raise's provenance. */
+    sinkId: string;
+    action: 'insert' | 'clear' | 'remove';
+    failThen: HandlerAction[];
+};
+/**
+ * EXP-011 §55. `Create New Array`'s Do: `const <local> = collection<T>([...<source>]); set<Row>(<local>);`
+ * then the Done chain. `source` absent is the empty literal (`items` never received). Every Do mints another
+ * array, exactly as `Collection.get()` with no name does.
+ */
+export type ArrayNewAction = {
+    kind: 'array-new';
+    nodeId: string;
+    local: string;
+    stateName: string;
+    rowType: string;
+    source?: ValueExpr;
+    /** Whether `source` is statically a list; an untyped source is copied when it is an array and empty otherwise. */
+    sourceIsList?: boolean;
+    then: HandlerAction[];
+};
+/** EXP-011 §55. One `Create New Array`'s handle row, and the row type the emitter spells it with. */
+export interface MintedArrayPlan {
+    nodeId: string;
+    stateName: string;
+    /** `any`, or a named array's interface when the snapshot source is that array (or a filter over it) and nothing inserts. */
+    rowType: string;
+    /** The named array whose interface `rowType` names, for the import. */
+    rowCollection?: string;
+}
+/**
+ * A `Hash`'s Do or a `Random Bytes`' New (EXP-011 §59) — {@link IdNewAction}'s two-arm shape with a
+ * value row that boots empty, a raise in the Failure arm, and (Hash) an `await`.
+ */
+export type CryptoCallAction = {
+    kind: 'crypto-call';
+    /** EXP-011 §90, as `api-call`'s. */
+    detached?: true;
+    nodeId: string;
+    node: CryptoNodeKind;
+    fn: 'tryHash' | 'tryRandomBytes' | 'tryExtract';
+    /** The raised code — `hash/failed` / `random-bytes/failed` (the node files). */
+    code: string;
+    /** Whether the call is awaited (`crypto.subtle.digest` is a promise; `getRandomValues` is not). */
+    async: boolean;
+    /**
+     * The verb's arguments in port order. A wire is the expression the handler closes over, a literal
+     * is the literal, and an input nobody set is absent — the lib applies the node's own fallback
+     * there, as `_run` / `_generate` do. `numeric` marks the one argument printed inside `Number(…)`
+     * (Length's setter), and only where a wire delivers it.
+     */
+    inputs: Array<{
+        port: string;
+        expr?: ValueExpr;
+        numeric?: true;
+    }>;
+    /** The chain-local the call binds — the whole result; the Done arm reads `.digest` / `.value`, the Failure arm `.error`. */
+    local: string;
+    /** The value row, where anything outside the chain reads it. Allocated by a read (§14.2's rule). */
+    materialize?: string;
+    /** The Error row, allocated by a read. */
+    errorMaterialize?: string;
+    /**
+     * EXP-011 §76. A `Pattern Extractor`'s rows, one per value output something reads outside the chain —
+     * written from the local's field of the same name BEFORE the arms, on every run, as `doExtract` writes them.
+     */
+    materializeByPort?: Array<{
+        port: string;
+        state: string;
+    }>;
+    then: HandlerAction[];
+    failThen: HandlerAction[];
+    /** EXP-011 §76. The `Found` / `Not Found` chains — printed inside the Done arm, ahead of `then`. Empty for the two verbs. */
+    foundThen: HandlerAction[];
+    notFoundThen: HandlerAction[];
+};
+/**
+ * A `Push Component To Stack`'s Navigate (EXP-011 §61) — `navigate.ts` `navigate()`, printed as the runtime's own call:
+ * `pushComponent(name, { target, params, backCallback, hasNavigated, hasUnchanged })` (or `replaceComponent`, which
+ * installs no callback — `replaceAsync` never does). The three failures are excluded statically (a literal Target inside
+ * the stack's Components list, no transitions), so `hasFailed` is never printed and a Failure wire is dropped with a note.
+ */
+export type StackPushAction = {
+    kind: 'stack-push';
+    nodeId: string;
+    /** The stack's authored name (`'Main'` by default) — the registry key. */
+    stack: string;
+    mode: 'push' | 'replace';
+    /** The target page id, resolved statically against the stack's Components list. */
+    target: string;
+    /** The component the target page shows — the emit resolves each param's prop identifier off its plan. */
+    targetLegacy: string;
+    /** The target's Component Inputs the pusher sets, by port; the prop identifier is the target's own, read at emit. */
+    params: Array<{
+        port: string;
+        expr: ValueExpr;
+        coerce?: 'string';
+    }>;
+    /** The pusher's local stem — the callback's `results` argument is `<local>Results`. */
+    local: string;
+    /** The back-results row, where anything outside the back chains reads a `backResult-<k>`. Allocated by a read. */
+    backResults?: string;
+    /** The `backAction-<a>` chains, by action, in wire order. */
+    backActions: Array<{
+        action: string;
+        then: HandlerAction[];
+    }>;
+    then: HandlerAction[];
+    unchangedThen: HandlerAction[];
+};
+/**
+ * A `Pop Component Stack`'s Navigate or one of its `backAction-<a>` inputs (EXP-011 §61) — `navigate-back.ts`
+ * `navigate()`: `const <local> = popComponent(pageStackEntry, { backAction, results })`, the Done arm, and the
+ * Failure arm, which raises `pop-component-stack/no-stack-in-scope` on the channel (the one failure the export can
+ * reach — `transition-in-progress` needs a transition). Always the block form, on the crypto verbs' reason.
+ */
+export type StackPopAction = {
+    kind: 'stack-pop';
+    nodeId: string;
+    /** The back action this pop was asked under, or none for the plain Navigate. */
+    backAction?: string;
+    /** The `result-<k>` values, read where the setters stored them — the render expression the handler closes over. */
+    results: Array<{
+        key: string;
+        expr: ValueExpr;
+    }>;
+    local: string;
+    then: HandlerAction[];
+    failThen: HandlerAction[];
+};
+/** A `Component Stack`'s Reset (EXP-011 §61): `<local>.reset()` then the Done chain — `resetAsync` reports done last. */
+export type StackResetAction = {
+    kind: 'stack-reset';
+    nodeId: string;
+    local: string;
+    then: HandlerAction[];
+};
+export type IdNewAction = {
+    kind: 'id-new';
+    nodeId: string;
+    fn: 'randomId' | 'randomUuid';
+    /**
+     * The chain-local the `New` binds to.
+     *
+     * ⚠️ **It is not the id in both cases.** For `randomId` the local *is* the string; for
+     * `randomUuid` it is the `UuidResult`, and a read of `Id` inside the Done chain is
+     * `<local>.uuid` — which narrows to `string` there and only there. `idLocalReadOf` is the one
+     * place that spelling lives, so the expression side and the action side cannot disagree.
+     */
+    local: string;
+    /** The id row, where anything outside the chain reads it. */
+    materialize?: string;
+    /**
+     * `UUID` only — the `Error` row, allocated by a *read* rather than by the node (§14.2's rule).
+     * A UUID whose Error nobody reads emits no row and no clearing setter.
+     */
+    errorMaterialize?: string;
+    then: HandlerAction[];
+    /** `UUID` only. Always empty for `Unique Id`, which has no Failure port to wire. */
+    failThen: HandlerAction[];
+};
+/**
+ * One argument of an {@link HandlerAction} `api-call`: either a plain value, or the object
+ * literal a record verb's `prop-*` set (and a Sign Up's credentials) collapses into.
+ */
+export type ApiCallArg = {
+    kind: 'expr';
+    expr: ValueExpr;
+} | {
+    kind: 'data';
+    props: Array<{
+        key: string;
+        expr: ValueExpr;
+    }>;
+};
+/**
+ * One re-hosted Function/Expression node (EXP-003-JS-TARGET-OUTPUT §4): the verbatim body plus
+ * everything the wrapper reproduces of the runtime's contract — inputs arriving as a record,
+ * assignments to `Outputs` publishing, script-declared signal outputs callable (as no-ops when
+ * nothing consumes them, exactly as an unwired pulse lands nowhere).
+ */
+/**
+ * A node whose authored JavaScript did not reach the emitted code, preserved so the repo carries
+ * a record of it. Not a `JsFunctionPlan`: these nodes have no wrapper and no ports mined from the
+ * body — the script is a *parameter* of a node that does something else (a Map Collection's
+ * mapping, a Repeater's template, a Script node's code).
+ */
+export interface RefusedScriptPlan {
+    nodeId: string;
+    /** The graph type, for the comment's noun — "Map Collection", "Javascript2". */
+    typeName: string;
+    /** The author's label for the node, when it has one. */
+    label?: string;
+    /** Verbatim, from `NodeIR.sourceText`. Never trimmed, never reformatted. */
+    source: string;
+}
+export interface JsFunctionPlan {
+    nodeId: string;
+    kind: 'function' | 'expression' | 'visual';
+    /** Module-scope wrapper name — the sanitized node label, deduped per component file. */
+    fnName: string;
+    /** The verbatim body (Function), expression text (Expression) or generated code (Visual). */
+    body: string;
+    /**
+     * The wrapper's input record, in script order: wire-fed inputs carry the resolved source,
+     * literal `in-*` parameters fold, mined-but-unfed inputs stay fields so the body's reads
+     * typecheck (they read `undefined`, exactly as a never-delivered runtime input does).
+     */
+    inputs: Array<{
+        name: string;
+        tsType: string;
+        expr?: ValueExpr;
+    }>;
+    /** Function only: the Outputs record's value fields (mined + declared + consumed). */
+    outputs: Array<{
+        name: string;
+        tsType: string;
+    }>;
+    /** Function only: signal outputs (mined call syntax / `outtype-*: signal`), seeded no-op. */
+    signals: string[];
+    /** Expression only: preamble Math aliases the expression references (`pi` → `Math.PI`). */
+    mathAliases: string[];
+    /**
+     * Visual only: app-wide Variables the block program reads or writes, from the workspace's
+     * `noodl_get_variable`/`noodl_set_variable` fields — never mined from the generated text.
+     *
+     * These become the `Noodl.Variables` facade the wrapper binds (LOGIC-BUILDER-TARGET §3.4):
+     * the body keeps its verbatim `Noodl.Variables["x"]` reads and writes, and they land on the
+     * export's own variables store. Every name here is registered in `ProjectPlan.variables`,
+     * minted by the block program where no `Variable` node declares it.
+     */
+    variables?: string[];
+    /**
+     * P109 ISL-005. Function only, present when its `uses` lists script files: each file the body
+     * reaches as `Scripts.<alias>`, in the order listed. The wrapper binds `Scripts` from the one
+     * shared registry (`src/lib/projectScriptFiles.ts`); the files are emitted once, never pasted here.
+     */
+    scripts?: ScriptUsePlan[];
+    /**
+     * reactive — no `run` wire: one render local per instance, recomputed per render (grade Q).
+     * invoked — `run` wired: calls inline inside its own handler chain only (grade I).
+     */
+    mode: 'reactive' | 'invoked';
+    /**
+     * EXP-019. Function only: the host traits the body carries ("reads the clock (Date)", "keeps state on `this`", …,
+     * `jsHostTraitsOf`). Present ⇒ the run is `pulsed` (a kept node, one run per trigger, outputs read from the node's
+     * record), because a body with a trait must never run at a read site. A `this` trait binds the body to the node's
+     * `self`. In `reactive` mode (no Run wire, slice 2) the trigger is its inputs' arrival and the load (`TickedRunPlan.atLoad`).
+     */
+    host?: string[];
+    /**
+     * EXP-019 (session 133). Function only: the body may write an output or send a signal after its run has returned, from a
+     * timer or a listener it sets up (`jsCallsBackOf`). Its kept node then hands those to the component (`FunctionNode.late`),
+     * which writes the row and runs the signal's chain, as the runtime's node delivers them when they happen.
+     */
+    late?: true;
+    /**
+     * EXP-019 slice 1b (session 134). Function only: the body awaits at its top level (`jsAwaitsAtTopLevel`). Its wrapper is
+     * `async`, its run hands back the promise (`FunctionRun.settled`), and Success and Done run after it settles, as the
+     * runtime's `runScript` awaits the body before sending them. What it writes after its first `await` arrives `late`.
+     */
+    awaits?: true;
+    /**
+     * EXP-020 (session 134). Function only: the Noodl API members the body reads (`jsNoodlUseOf`), and the Variables it
+     * reads or writes by name. The wrapper binds `Noodl` to `src/lib/noodl.ts`'s object, with a facade over each Variable.
+     */
+    noodl?: {
+        members: string[];
+        variables: string[];
+    };
+    /**
+     * EXP-020 slice 2 (session 135). Function only: the body reads `Component.Object`, its component instance's record. The
+     * component keeps one scope per mount (`src/lib/componentScope.ts`), its kept nodes carry it, and `runFunction` hands it
+     * to the body as the runtime hands it the fourth parameter. Always `pulsed` (it is a host trait).
+     */
+    component?: true;
+    /**
+     * EXP-011 §86. Function only, invoked only: a run of it sends a signal of its own that a chain consumes, or (P18-S121-
+     * FRESHOUTPUTS) it materializes a row a reader reads between runs. The wrapper then takes its `Outputs` record as a
+     * parameter, so `runFunction` can hand it the recording one, and the component keeps the node's last values across
+     * runs (`functionNode`), as the runtime's node does.
+     */
+    pulsed?: true;
+    /**
+     * P18-S110-EVALATLOAD. Expression only, reactive only: present when nothing is sure to arrive at
+     * load — no input has a literal (a parameter is set at load, so it always arrives) and the body
+     * reads at least one port. `unset` names the wire-fed inputs; while every one reads `undefined`
+     * nothing has arrived, because the runtime never delivers `undefined` over a wire.
+     *
+     * That is the state GAM-001's load evaluation runs in (`expression.ts` `_scheduleEvaluateExpression`):
+     * ticked (`evaluate`, the default) it evaluates over the unset inputs but publishes no answer for
+     * a throw or a NaN — Result stays `null`, where an arrival's evaluation answers `0` and `NaN`;
+     * unticked (`wait`) it publishes nothing until an input arrives.
+     */
+    loadGate?: {
+        unset: string[];
+        atLoad: 'evaluate' | 'wait';
+    };
+}
+/**
+ * P18-S126-INSIGNAL (EXP-011 §94). A signal input's chain: the actions the Component Inputs port's wires describe, in wire
+ * order, run from an effect keyed on the pulse count the parent passes (`InstancePulsePlan`).
+ */
+export interface InputPulsePlan {
+    port: string;
+    actions: HandlerAction[];
+}
+/**
+ * P18-S126-INSIGNAL. A placed component's signal input the parent pulses: the count (`stateName`, a state row) and the
+ * count the child has acted on (`takenLocal`, a ref the parent keeps, so it outlives the child's unmount). Passed as one
+ * prop, `{ sent, taken }`: the child runs its chain when `sent` passes `taken`, at a mount too (the runtime's instance exists
+ * while it is not drawn and takes the pulse then), and never twice for one pulse (StrictMode's second mount included).
+ */
+export interface InstancePulsePlan {
+    nodeId: string;
+    port: string;
+    stateName: string;
+    takenLocal: string;
+    /**
+     * P18-S127-SIBLINGVALUE (EXP-011 §96). Set when the placed component also reads an input the parent lifts from another
+     * placed component: the count it is handed (`sent`) is a second row that follows the count from the parent's own
+     * effect, one commit later. A lifted value reaches the parent from the child's push effect, which runs in the commit the
+     * pulse lands in; the parent's effects run after its children's, so the delivered count and the lifted value arrive in
+     * the same render, and the chain inside reads the value sent with the pulse, as the runtime's does.
+     */
+    delivered?: {
+        name: string;
+        setterName: string;
+    };
+}
+/** P18-S126-INSIGNAL. The TypeScript type of a signal input's prop, the pair the parent passes. */
+export declare const INPUT_PULSE_TS_TYPE = "{ sent: number; taken: { current: number } }";
+export interface ReceiverPlan {
+    nodeId: string;
+    channelName: string;
+    /** Actions in trigger-wire source order — statement order in the useSignal handler. */
+    actions: HandlerAction[];
+}
+/**
+ * One `useState` row in the component (CONTROLLED-STATE-TARGET §3.1) — the first construct
+ * that materializes state in the emitted component rather than compiling it away. Names live
+ * in the component's one identifier space (props, hooks, wrappers — the stores rule).
+ */
+export interface StateVarPlan {
+    name: string;
+    setterName: string;
+    /** The useState type parameter, `' | undefined'` included where the boot is undefined. */
+    tsType: string;
+    /** Boot value; null is the `undefined` boot (`useState<T | undefined>()`). */
+    boot: string | number | boolean | null;
+    /**
+     * An initializer expression emitted verbatim, used **instead of** `boot` (EXP-011 Tier 1.3).
+     *
+     * 🔴 The one row that needs it is `Now`'s, and it needs it to be a *lazy* initializer:
+     * `useState(() => new Date())` constructs once per mount, which is what `initialize` does,
+     * where `useState(new Date())` would construct on every render. No other origin has a boot
+     * value that is not a literal, which is why this is an exception rather than the field's
+     * general form.
+     */
+    bootCode?: string;
+    /**
+     * The emitted-library helper {@link bootCode} calls, where it calls one (EXP-011 §37).
+     *
+     * 🔴 **The import is earned from this field and never by reading `bootCode`.** `bootCode` is a
+     * string emitted verbatim, and the two id rows are the first whose initializer calls into
+     * `src/lib/id.ts` — every other earn site in `component.ts` walks *expressions*, and a row's
+     * boot is not an expression it can see. A `Unique Id` with nothing on `New` has a row and no
+     * action at all, so there is nothing else left to derive the import from.
+     */
+    bootHelper?: IdHelper;
+    originNodeId: string;
+    origin: 'switch' | 'counter' | 'control' | 'lifted' | 'jsfun' | 'record-error' | 'variable' | 'http' | 'http-error'
+    /** EXP-011 §41 — a `Cloud Function`'s results row and its Error row. */
+     | 'cloud' | 'cloud-error'
+    /** EXP-011 §43 — a `Record`'s row and its Error row. */
+     | 'record-row' | 'record-row-error'
+    /** EXP-011 §45 — a files node's answer row (a `File`, a `CloudFile`, a `SignedFileUrl`) and its Error row. */
+     | 'file' | 'file-error' | 'external-link-error' | 'navigate-path-error' | 'now'
+    /** EXP-011 §37 — the id a `Unique Id` or a `UUID` holds. */
+     | 'id' | 'array'
+    /** EXP-011 §37 — a `UUID`'s Error. `Unique Id` has no Failure port and never allocates one. */
+     | 'id-error'
+    /** EXP-011 §59 — a `Hash`'s Digest / a `Random Bytes`' Value row, and its Error row. Both allocated by a read. */
+     | 'crypto' | 'crypto-error'
+    /** EXP-011 §61 — a pusher's back-results row (`Record<string, unknown>`, boots `{}`). */
+     | 'stack-back'
+    /** EXP-011 §87 — a Mounted or Visible written by the Evaluate of the unticked Conditions wired into it. */
+     | 'condition'
+    /** EXP-011 §99 — a repeater's relayed row value, written in the rows' relayed-signal callbacks. */
+     | 'relay';
+    /** The provenance comment above the row. */
+    comment: string;
+}
+/**
+ * The graph path of a wired control-state input (CONTROLLED-STATE-TARGET §3.4): a useEffect
+ * running the *input setter's* semantics — coercion, abstain guards, clamping, per §1's table —
+ * and never the `Changed` chain (the runtime's own asymmetry).
+ */
+export interface SyncEffectPlan {
+    stateName: string;
+    source: ValueExpr;
+    /**
+     * The `variable-*` forms are the value Variables (EXP-011 Tier 1.4) reaching the same
+     * construct from the other direction: their `value` input under Run On Value Change is a
+     * graph path that stores without firing `Changed`, exactly as a control's is, so
+     * `variablebase.setValueTo`'s table — abstain on `undefined`, `Treat empty as` on `null`,
+     * `args.cast` otherwise, `NaN` banned — is written here as one more coercion. `variable-none`
+     * is Color's identity cast.
+     */
+    coerce: 'checkbox' | 'slider' | 'dropdown' | 'textinput' | 'variable-string' | 'variable-number' | 'variable-boolean' | 'variable-none';
+    /** Slider only: the literal clamp bounds (a wired min/max defers the node before this). */
+    min?: number;
+    max?: number;
+    /** `variable-*` only: what a `null` arrival stores — the selected `Treat empty as` coercion. */
+    empty?: string | number | boolean | null;
+}
+/**
+ * The lifted value output's child side (CONTROLLED-STATE-TARGET §3.5, CO §6 built): a push
+ * effect firing the optional callback prop on change and once at mount — the boot delivery a
+ * parent wire gets from the interpreter, so the mount fire is the faithful part.
+ */
+export interface PushEffectPlan {
+    prop: string;
+    expr: ValueExpr;
+    /**
+     * P18-S122-TPLBUILD (TS2345). The port's declared type, when the pushed value's static type is not it (an untyped
+     * Variable is `unknown`, an Expression's answer keeps `null` for a NaN at load): the push says the port's type, as a
+     * cast. The runtime's Component Outputs hands the value on as it is, and so does the cast; it changes no value.
+     */
+    castTo?: string;
+}
+/**
+ * A reactive Condition (LOGIC-TARGET §10): the box is ticked, so the node re-tests on every
+ * arrival on `condition` and fires exactly one arm — a re-run keyed on the condition, which is
+ * a `useEffect`, not a handler. The Evaluate-only Condition is the other half and compiles to a
+ * `branch` action inside whatever handler drives it (§3).
+ *
+ * `action` is always a `branch`, so every emit-side sweep that already walks branch arms — the
+ * import, navigate and state-reference collectors — reaches these arms for free.
+ */
+export interface BranchEffectPlan {
+    nodeId: string;
+    action: HandlerAction;
+    /** The provenance comment above the effect — the node's authored label when it has one. */
+    comment: string;
+}
+/**
+ * A `Value Changed` (EXP-011 §39): the node fires whenever its Input becomes a different value,
+ * the first arrival included, and compares by identity — `useEffect` over the value, with the
+ * last value seen in a `useRef` so a re-render that delivers the same value fires nothing.
+ *
+ * ⚠️ React's dependency compare is `Object.is` and the node's is `===`; they differ only on
+ * `NaN` (the node fires on every `NaN` arrival, the effect never re-runs for one). Recorded in
+ * the ledger rather than reproduced — a value that is `NaN` on every arrival is not a change
+ * an author is watching for.
+ */
+export interface ValueChangedEffectPlan {
+    nodeId: string;
+    /** The Input, as the render-mode expression the effect watches. */
+    watch: ValueExpr;
+    /** The `useRef` local holding the last value the effect saw. */
+    lastLocal: string;
+    actions: HandlerAction[];
+    comment: string;
+}
+/**
+ * P18-S119-TICKEDRUN. A Function or Expression whose Run is wired also runs when one of its value inputs whose Run On Value
+ * Change box is ticked (or unset, which is ticked) gets a new value (NDA-017 §2, `setScriptInputValue`). A wired value
+ * arrives when its source first has one and whenever it changes after; a literal arrives once, at load. Such a run sends
+ * the Function's own signals and writes its outputs, but never Done (no Run sent it). Two arrivals, or an arrival and a
+ * Run, in one update make one run.
+ *
+ * Printed as a `useEffect` keyed on the watched values' sources, beside the Run chains: it asks `tickedArrival` whether
+ * a value arrived (not `undefined`, not the one held), and runs `action` if so. A Run records what it read the same way,
+ * so a click that sets a watched value and sends Run makes one run, the Run's, with its Done (measured, s121 drive S4).
+ * Measured in the viewer (s121 drive S0): at load the arrival's run comes first, then a Did Mount's Run, two runs.
+ */
+export interface TickedRunPlan {
+    nodeId: string;
+    /** The ticked inputs the runtime delivers, in input order: a wired one as the value it reads, a literal as itself. */
+    watch: ValueExpr[];
+    /** The run without its Done: the body, its signals' chains, its §4f write. `ticked: true`. */
+    action: Extract<HandlerAction, {
+        kind: 'jsfun-run';
+    }>;
+    /**
+     * EXP-019 slice 2. A Function with a host trait and no Run wire: the runtime's script setter also runs it once at load
+     * (`simplejavascript.ts`, `if (!this.isInputConnected('run')) this.scheduleRun()`), whatever has arrived, inputs or none.
+     * The effect then runs on its first pass even when no watched value arrived (a ref, so StrictMode's second mount does
+     * not run it twice).
+     */
+    atLoad?: true;
+    comment: string;
+}
+/**
+ * A `CSS Definition`'s stylesheet (EXP-011 §48): a module constant holding the authored CSS
+ * verbatim, and a mount effect that appends it to `document.head` in a `<style>` and removes it
+ * on unmount — the node's own `updateStyle`/`removeStyleDeclaration`, per instance.
+ *
+ * ⚠️ One difference, invisible on the page: the runtime keys the element by *node id* and
+ * ref-counts it, so N mounted instances of one component share one `<style>`; the export appends
+ * one per instance. Identical text N times has the same cascade as once.
+ */
+export interface StyleSheetPlan {
+    nodeId: string;
+    /** `DESK_STYLES` — SCREAMING_SNAKE of the authored label, deduped like a Static Data constant. */
+    constName: string;
+    /** The authored CSS, verbatim — never trimmed, never reformatted. */
+    css: string;
+    comment: string;
+}
+/** One `transitiondef-<state>` / `transition-<state>-<value>` — the node's `curve` port shape. */
+export interface StatesCurve {
+    curve: number[];
+    dur: number;
+    delay: number;
+}
+/** One authored value of a States node — its `type-<name>` and its `value-<state>-<name>` per state. */
+export interface StatesValueDef {
+    name: string;
+    type: StatesValueType;
+    /** The declared TypeScript type of the read: `number`, `string`, `boolean`; a colour is a `string`. */
+    tsType: string;
+    byState: Record<string, string | number | boolean>;
+    transitions: Record<string, StatesCurve>;
+}
+/**
+ * A `States` node (EXP-011 §49): a definition constant above the component (`defineStates({…})`),
+ * a `useStates` handle inside it, the listeners its signal outputs compiled into, and the wired
+ * State input as an effect.
+ *
+ * The values are held by the emitted hook, not by state rows: every frame of a tween publishes a
+ * new snapshot, and a row per value would be five setters per frame for the same re-render.
+ */
+export interface StatesPlan {
+    nodeId: string;
+    /** The `useStates` local — `panel`. */
+    local: string;
+    /** The definition constant — `PANEL_STATES`. */
+    constName: string;
+    states: string[];
+    values: StatesValueDef[];
+    /** `transitiondef-<state>`, by state, where authored. */
+    transitions: Record<string, StatesCurve>;
+    useTransitions: boolean;
+    /** The authored State, when it names a state; the node starts in the first state otherwise. */
+    start: string | undefined;
+    /** The wired State input — `useEffect(() => { local.follow(expr) }, [deps])`. */
+    follow?: ValueExpr;
+    /** The signal outputs, as the chains wired off them. `reached` is by state. */
+    listeners: {
+        stateChanged?: HandlerAction[];
+        reached: Record<string, HandlerAction[]>;
+        done?: HandlerAction[];
+        unchanged?: HandlerAction[];
+        failure?: HandlerAction[];
+    };
+    comment: string;
+}
+/**
+ * A `Script` node (EXP-011 §52): `const <local> = useScript(<defName>, { <inputs> }, { <listeners> })`,
+ * with the node's code in its own file under `src/scripts/`, verbatim and unchecked, exported as
+ * `<defName>`. The port set is the one on disk (`scriptPortsOf`); the input record carries only the
+ * inputs the graph feeds, typed by what is delivered.
+ */
+export interface ScriptPlan {
+    nodeId: string;
+    /** The authored label, or `Script`. */
+    label: string;
+    /** The `useScript` local — `ticker`. */
+    local: string;
+    /** The exported definition constant and the file's base name — `tickerScript`. */
+    defName: string;
+    /** `src/scripts/<dir>/<fileBase>/<defName>.ts` — the file the code lives in. */
+    file: string;
+    /** The author's code, verbatim (`sourceText`'s contract: never trimmed, never reformatted). */
+    code: string;
+    /** Value inputs, in port order: wire-fed carry the resolved source, literals fold, unfed are absent from the record. */
+    inputs: Array<{
+        name: string;
+        tsType: string;
+        expr?: ValueExpr;
+    }>;
+    signalInputs: string[];
+    /** Value outputs, in port order, typed by the declared port type. */
+    outputs: Array<{
+        name: string;
+        tsType: string;
+    }>;
+    signalOutputs: string[];
+    /** The ports as `defineScript` registers them — every port on disk, typed as the editor spelled it. */
+    ports: {
+        inputs: Record<string, string>;
+        outputs: Record<string, string>;
+    };
+    /** The signal outputs, as the chains wired off them. */
+    listeners: Record<string, HandlerAction[]>;
+    comment: string;
+}
+/**
+ * A `Run Tasks` node (EXP-011 §53): `const <local> = useRunTasks(<label>, { maxRunningTasks, stopOnFailure },
+ * { <listeners> })` in the host, and the active task instances rendered as the last child of the host's
+ * root container — `{<local>.tasks.map((task) => <Template key={task.key} <inputs from task.item>
+ * onSuccess={task.succeed} onFailure={task.fail} />)}`. The template is a project component with no
+ * visual root, emitted as a null-rendering component whose start-input chain runs on mount
+ * ({@link TaskPlan}). The contract between the two is by NAME, as the runtime's is (`runtasks.ts`
+ * matches the template's outputs by string; there is no wire between host and template).
+ */
+export interface RunTasksPlan {
+    nodeId: string;
+    /** The authored label, or `Run Tasks`. */
+    label: string;
+    /** The `useRunTasks` local — `sendAll`. */
+    local: string;
+    /** The template's legacy path — `/Notify`. The symbol and file are read off its plan at emit. */
+    templateLegacy: string;
+    /** The resolved contract names (defaults applied). */
+    contract: {
+        start: string;
+        success: string;
+        failure: string;
+        error: string;
+    };
+    /** The list, read at the pulse. */
+    items: ValueExpr;
+    /** Literal or wired (a render read); the hook reads both live, as the runtime reads `_internal`. */
+    maxRunningTasks: ValueExpr;
+    stopOnFailure: ValueExpr;
+    /**
+     * The template's value inputs the host binds from the item, by identity (`runtasks.ts`:
+     * `for (const inputKey in itemNode._inputs) if (model.data[inputKey] !== undefined) setInputValue`).
+     * `prop` is the template's prop identifier for the port; `field` the item key (the port name).
+     */
+    inputs: Array<{
+        port: string;
+        field: string;
+    }>;
+    /** The template's `Id` / `id` inputs, fed the task's model id (`item.id`, else a generated one). */
+    idInputs: string[];
+    /** The template's callback props for the contract's success and failure outputs. */
+    onSuccess?: string;
+    onFailure?: string;
+    /** The signal outputs, as the chains wired off them. */
+    listeners: Partial<Record<'done' | 'failure' | 'unchanged' | 'completed' | 'aborted', HandlerAction[]>>;
+    comment: string;
+}
+/**
+ * A component that a `Run Tasks` names as its template (EXP-011 §53) — logic-only, emitted anyway,
+ * rendering `null`; the chain wired off its start input runs once in a mount effect, which is exactly
+ * when `startTask` pulses it (right after `createNode`). Every other signal input stays as before
+ * (declared, unconsumed — COMPONENT-OUTPUTS-TARGET §6). Set only when every host names the same
+ * start input and the chain compiled; otherwise the component keeps no file and
+ * {@link ComponentPlan.taskRefusal} says why, for the hosts to repeat.
+ */
+export interface TaskPlan {
+    startPort: string;
+    actions: HandlerAction[];
+    /** The Run Tasks nodes that name this component, for the doc comment. */
+    hosts: Array<{
+        componentPath: string;
+        nodeId: string;
+    }>;
+    comment: string;
+}
+/**
+ * A `Repeater Item` (EXP-011 §57) whose `Added` drives a chain: once, on mount, guarded against StrictMode's
+ * second mount — `signalAdded` is called synchronously inside `addItem` after `createNode`, once per row
+ * (`foreach.tsx`). Its Item Id, when read, is a row prop ({@link ComponentPlan.rowProps}) rather than anything
+ * here — the parent binds it from `item.id`.
+ */
+export interface RepeaterItemPlan {
+    nodeId: string;
+    /** The authored label, or `Repeater Item`. */
+    label: string;
+    /** The Added chain, snapped for render context. */
+    actions: HandlerAction[];
+    comment: string;
+}
+/**
+ * An `On App Error` node (EXP-011 §54): `const <local> = useAppError({ filter }, () => { …the Error chain… })`.
+ * The boundary subscribes to the app's error channel (`src/lib/errors.ts`) for the life of the component
+ * that hosts it — a page's boundary hears errors while the page is mounted, the root component's for the
+ * app's life (the router shell keeps a file for it, {@link ComponentPlan.shell}) — and every instance
+ * fires (onapperror.ts: no claiming, no consumption). Its value outputs read off the handle's `last`.
+ */
+export interface AppErrorPlan {
+    nodeId: string;
+    /** The authored label, or `On App Error`. */
+    label: string;
+    /** The `useAppError` local — `catchAll`. */
+    local: string;
+    /** The Filter — a literal, or a render read where wired; absent means every error. Read live by the hook. */
+    filter?: ValueExpr;
+    /** The chain wired off `Error`, when any. */
+    listener?: HandlerAction[];
+    comment: string;
+}
+/**
+ * A streaming node (EXP-011 §58): `const <local> = use<Hook>({ label, nodeId, componentName }, { <config> },
+ * { <listeners> })`. The data port's expression rides every action that takes it; the config is the options
+ * object the hook re-reads every render (a literal, or a render read where wired); the signal outputs are the
+ * chains wired off them.
+ */
+export interface StreamPlan {
+    nodeId: string;
+    type: string;
+    kind: StreamKind;
+    /** The authored label, or the display name. */
+    label: string;
+    /** The hook local — `parser`. */
+    local: string;
+    /** The data port's source — a wire's expression or an authored literal; absent when the port has none. */
+    data?: ValueExpr;
+    /** The config ports that are authored or wired, by port name; an absent port keeps the runtime's initialize() value. */
+    config: Array<{
+        port: string;
+        expr: ValueExpr;
+    }>;
+    /** The signal outputs, as the chains wired off them. */
+    listeners: Record<string, HandlerAction[]>;
+    /** EXP-011 §78. The store a history-family node names — printed as its store module (`store: app`) and imported. */
+    store?: string;
+    comment: string;
+}
+/**
+ * A `Screen Resolution` node (EXP-011 §59): `const <local> = useScreenResolution()`. Registered on first
+ * read, the boundary's shape without a listener; its three outputs read off the handle. A node nobody
+ * reads is never registered — the hook would be a listener nothing observes.
+ */
+export interface ScreenResolutionPlan {
+    nodeId: string;
+    label: string;
+    local: string;
+    comment: string;
+}
+/**
+ * EXP-011 §60. A `Component Object` node in **record** mode — its component hosts a `Set Component Object Properties`,
+ * or a descendant reaches the record through the parent pair: `const <local> = useComponentObject<<typeName>>()`,
+ * one mirror effect per wired `value-*` input (`useEffect(() => { <local>.set({ key: src }); }, [deps])`), and the
+ * component's root wrapped in `ParentComponentObjectContext.Provider` — the transcription of "this component owns a
+ * Component Object", which is what `findAncestorWithComponentObject` tests. Alias mode (no writer, no descendant
+ * reach) is COMPONENT-OBJECT-TARGET §3 unchanged and registers nothing here.
+ */
+export interface ComponentObjectRecordPlan {
+    nodeId: string;
+    label: string;
+    local: string;
+    /** The record's type alias, printed at module level: `type <typeName> = { key?: tsType; … }`. */
+    typeName: string;
+    keys: Array<{
+        key: string;
+        tsType: string;
+    }>;
+    mirrors: Array<{
+        key: string;
+        source: ValueExpr;
+        wireKey: string;
+    }>;
+    comment: string;
+}
+/**
+ * A `Component Stack` that renders (EXP-011 §61): `const <local> = usePageStack({ name, pages, startPage })`, and a
+ * visual row that renders the TOP entry only — one `&&` line per page, the entry's params spread as the page
+ * component's props, the reserved `pageStackEntry` prop where the page keeps a Pop.
+ */
+export interface PageStackPlan {
+    nodeId: string;
+    label: string;
+    local: string;
+    /** The registry key — the authored Name, `Main` by default. */
+    name: string;
+    /** The Components list in authored order, each resolved to the component it shows. */
+    pages: Array<{
+        id: string;
+        label: string;
+        componentLegacy: string;
+    }>;
+    /** The authored Start Page, or the first page's id. */
+    startPage: string;
+    comment: string;
+}
+/**
+ * EXP-011 §60. The nearest ancestor's record, read from below — one hook per component, shared by every
+ * `Parent Component Object` and `Set Parent Component Object Properties` in it (each resolves the same nearest
+ * owner): `const <local> = useParentComponentObject<<typeName>>([readers])`. `readers` are the reader nodes that
+ * collapsed — each raises `parent-component-object/no-ancestor` once at mount when the hook answers undefined.
+ */
+export interface ParentComponentObjectPlan {
+    local: string;
+    typeName: string;
+    keys: Array<{
+        key: string;
+        tsType: string;
+    }>;
+    readers: Array<{
+        nodeId: string;
+        label: string;
+    }>;
+    /** Whether a parent Set prints — the hook prints when a reader collapsed or a writer attached. */
+    comment: string;
+}
+/**
+ * A `Drag` node (EXP-011 §63): `const <local> = useDrag({ label, nodeId, componentName }, { …options }, { …listeners })`,
+ * and a wrapper `<div ref style {...handlers}>` where the node sits. Registered for every rendered Drag — the wrapper
+ * needs the hook whether or not anything reads the node.
+ */
+export interface DragPlan {
+    nodeId: string;
+    label: string;
+    local: string;
+    comment: string;
+    /**
+     * The options that print, in `DRAG_OPTION_PORTS` order — a wire is the render expression the hook reads on arrival,
+     * an authored value a literal, a port nothing set absent (the lib applies the declared default there).
+     */
+    options: Array<{
+        key: string;
+        expr: ValueExpr;
+    }>;
+    /** The listener chains that translated. `done` fires after every snap call; Failure never (dropped with a note). */
+    listeners: {
+        onStart?: HandlerAction[];
+        onMove?: HandlerAction[];
+        onEnd?: HandlerAction[];
+        done?: HandlerAction[];
+    };
+    /** Wires dropped by name — printed as in-code markers on the wrapper, counted by the pre-flight. */
+    drops: Array<{
+        subject: string;
+        reason: string;
+    }>;
+}
+/**
+ * An `Animate To Value` node (EXP-011 §49): `const <local> = useAnimatedValue(target, { duration,
+ * delay, ease }, onArrive)`. `duration` and `delay` are read where the hook is — a wired one is
+ * the render expression, an authored one a literal — and `ease` is the authored enum, which a
+ * wire cannot deliver (the node indexes `EaseCurves` by it and an unknown name throws).
+ */
+export interface AnimationPlan {
+    nodeId: string;
+    local: string;
+    target: ValueExpr;
+    duration: ValueExpr;
+    delay: ValueExpr;
+    /**
+     * P18-S122-TPLBUILD (TS2322). The inputs whose wired value is not statically a number (an untyped Variable is `unknown`):
+     * the runtime's Duration setter stores the value as it is, and the hook's option says `number`, so the option is a cast.
+     */
+    castToNumber?: Array<'duration' | 'delay'>;
+    ease: AnimateEaseName;
+    /** The At Target Value chain, when wired. */
+    arrive?: HandlerAction[];
+    comment: string;
+}
+export interface PropPlan {
+    name: string;
+    tsType: string;
+}
+export interface QueryPlan {
+    nodeId: string;
+    collectionName: string;
+    /** `puppies` / `setPuppies` / `puppy` / `fetchPuppies` / `Puppy` / api module base `puppies`. */
+    stateName: string;
+    setterName: string;
+    itemName: string;
+    fetchName: string;
+    typeName: string;
+    moduleBase: string;
+    /**
+     * P18-S115-QUERYFILTER (EXP-011 §82). The `where` / `order` / `limit` / `skip` the runtime sends for this node, its
+     * filter translated by the runtime's own translator (`querySettings.ts`). Absent when it sends none of them, so an
+     * unfiltered query's call is the bare `fetch<Plural>()` it always was.
+     */
+    params?: QueryParamsPlan;
+    /**
+     * P18-S115-QUERYPARAMS. With `params.wired`: each wired filter value as the render read its wire resolves to, in
+     * `params.wired.params` order. The query re-runs whenever one changes (`setQueryParameter`, its box ticked).
+     */
+    wiredValues?: Array<{
+        name: string;
+        expr: ValueExpr;
+    }>;
+    /** The project declares a backend, so `src/api/client.ts` exists to put each value on the wire (`filterValue`). */
+    wiredClient?: boolean;
+    /**
+     * P18-S116-QUERYFETCH. Its Fetch is wired, so the query asks when Fetch is sent (`query-fetch` in the sender's
+     * chain). `mount`: it also asks as the node is made, its Class box ticked or its Query settings box ticked with a
+     * setting authored (a wired Fetch settles both unticked, NDA-017; an author can tick them again). `onValues`: the
+     * wired filter values' boxes are ticked, so a new value asks too (the effect, mount included).
+     */
+    fetchWired?: {
+        mount: boolean;
+        onValues: boolean;
+    };
+}
+/**
+ * One translated record verb (RECORD-VERBS-TARGET §4d): what the api stub module has to export
+ * for it. The naming is a pure function of the class name, identical to {@link QueryPlan}'s, so a
+ * project that both reads and writes one collection gets a single module.
+ */
+export interface MutationPlan {
+    nodeId: string;
+    /** EXP-011 §62: `add-relation` / `remove-relation` join the class's module beside the three record verbs. */
+    verb: 'create' | 'update' | 'delete' | RelationVerb;
+    collectionName: string;
+    /** `createPuppy` / `updatePuppy` / `deletePuppy`. */
+    fnName: string;
+    typeName: string;
+    moduleBase: string;
+    /**
+     * The columns this verb actually writes, with the type its argument resolves to — the graph's
+     * own evidence of the record's shape (RECORD-VERBS-TARGET §4d).
+     *
+     * The interface is minted from the project's collection **schema snapshot**, and 32 of the 39
+     * corpus projects carry none at all: `metadata.dbCollections` is absent, so every collection
+     * types as `{ id: string }` and *any* `create`/`update` that writes a property emits a call
+     * that does not compile. The schema is the authority where it exists and silent where it does
+     * not; a `prop-` the graph writes is direct evidence of a column, so the two union. Empty for
+     * `delete`, which writes nothing.
+     */
+    writes: Array<{
+        name: string;
+        tsType: string;
+    }>;
+}
+/**
+ * One translated user-family node (USER-FAMILY-TARGET §4d): what `src/api/session.ts` has to
+ * export for it. Unlike {@link MutationPlan} there is nothing to key on — a project has one
+ * session — so the three writes and the read all land in a single module.
+ */
+export interface SessionCallPlan {
+    nodeId: string;
+    verb: UserVerb | 'read';
+    /** `logIn` / `logOut` / `signUp` / `useSession` / `setUserProperties` / `requestMagicLink`. */
+    fnName: string;
+    /**
+     * EXP-011 §44 — the `_User` columns a `Set User Properties` writes (its `prop-*` inputs, the
+     * prefix stripped), typed the record verbs' way: the wire's type where it is one of the three
+     * JSON scalars, else `unknown`. The session module's `UserProperties` interface is the union
+     * over every site — a project has one `_User` class, as it has one session.
+     */
+    writes?: Array<{
+        name: string;
+        tsType: string;
+    }>;
+}
+/**
+ * One value an `HTTP Request` sends (EXP-011 Tier 1.2): a path segment, a query parameter, a
+ * header, a body field or a credential.
+ *
+ * `from` is the whole difference between configuration and data. An authored parameter is folded
+ * into the emitted module as a literal — it is what the interpreter would have read out of
+ * `inputValues` on every fetch, and nothing can change it. A wired one becomes a function
+ * parameter the call site fills. An input that is *neither* never appears: the runtime reads
+ * `undefined` for it, and `undefined` omits the header, the query parameter and the body field
+ * alike, so emitting the guard would be emitting a branch that cannot be taken.
+ */
+export interface HttpValuePlan {
+    /** The wire name — the header, query parameter, path placeholder or field, verbatim. */
+    name: string;
+    from: {
+        kind: 'literal';
+        value: string | number | boolean;
+    } | {
+        kind: 'param';
+        param: string;
+        tsType: string;
+    };
+}
+/**
+ * One translated `HTTP Request` (EXP-011 Tier 1.2) — everything `src/api/http.ts` needs to
+ * rebuild the request the node would have sent.
+ *
+ * The node's configuration is `allowEditOnly` almost throughout (method, body type, the four
+ * string lists, the auth preset), which is why this is a plan and not a solver: what the request
+ * *is* was decided in the editor and cannot change at runtime. What can change is the values, and
+ * those are {@link HttpValuePlan}s.
+ */
+export interface HttpCallPlan {
+    nodeId: string;
+    /** `fetchQuote` — from the node's authored label, deduped across the project's HTTP nodes. */
+    fnName: string;
+    /** `QuoteAnswer` — the exported result type the component's state row is typed by. */
+    typeName: string;
+    /**
+     * The `const answer = await …` local, and the `const message = …` both failure arms bind.
+     *
+     * They live here rather than on the action because the *expression* side needs them too — a
+     * chain-local read is emitted from a `http-out` that knows only its node — and two places
+     * deriving the same name independently is the divergence FINDINGS B-iv is about.
+     */
+    answerLocal: string;
+    messageLocal: string;
+    /** The authored URL, `{placeholders}` included. */
+    url: string;
+    method: string;
+    /** Milliseconds; `timeout || 30000`, the runtime's own defaulting, already applied. */
+    timeout: number;
+    /**
+     * P18-S104-RESPONSETYPE — how the body is read (FED-001 §3.2). `setResponseType` stores `value || 'auto'` and the
+     * fetch tests for `'text'` and `'json'` only, so any other value reads as Auto; that defaulting is applied here.
+     */
+    responseType: 'auto' | 'text' | 'json';
+    pathParams: HttpValuePlan[];
+    queryParams: HttpValuePlan[];
+    headers: HttpValuePlan[];
+    /** Null for GET/HEAD/OPTIONS, which send none — `buildBody` returns undefined for them. */
+    body: {
+        type: 'json' | 'form' | 'urlencoded';
+        fields: HttpValuePlan[];
+    } | {
+        type: 'raw';
+        raw: HttpValuePlan;
+    } | null;
+    auth: {
+        kind: 'bearer';
+        token: HttpValuePlan;
+    } | {
+        kind: 'basic';
+        username: HttpValuePlan;
+        password: HttpValuePlan;
+    } | {
+        kind: 'apiKey';
+        name: HttpValuePlan;
+        value: HttpValuePlan;
+        location: 'header' | 'query';
+    } | null;
+    /**
+     * The Response Mapping, compiled (`$.data.items[0].name` → `?.data?.items?.[0]?.name`).
+     *
+     * `steps` is empty for the default path `$`, which is the whole body — and `null` for a path
+     * `extractByPath` can never resolve (one that does not start with `$`), where the runtime
+     * publishes `undefined` on every answer and so does the emitted module.
+     */
+    fields: Array<{
+        name: string;
+        steps: Array<string | number> | null;
+    }>;
+}
+/** One `Cloud Function` node's call (EXP-011 §41) — what `src/api/functions.ts` emits for it. */
+export interface CloudCallPlan {
+    nodeId: string;
+    /** The backend function's name, verbatim — the `function` parameter. */
+    functionName: string;
+    /** `callPublishPage` — from the node's authored label, else the function name. */
+    fnName: string;
+    /** `PublishPageResults` — the exported result type the component's state row is typed by. */
+    typeName: string;
+    answerLocal: string;
+    messageLocal: string;
+    /** The `in-*` parameters — a folded literal, or the parameter the call site fills. */
+    params: HttpValuePlan[];
+    /** The `out-*` result names the node declares, in port order. */
+    results: string[];
+}
+/** One `Record` node's read (EXP-011 §43) — what its collection module has to export for it. */
+export interface RecordReadPlan {
+    nodeId: string;
+    collectionName: string;
+    /** `Page` — the collection module's interface, the row's type. */
+    typeName: string;
+    moduleBase: string;
+    /** `fetchPageById`. */
+    fnName: string;
+    answerLocal: string;
+    messageLocal: string;
+    /** The Id, bound before the guard so the emitted `Missing Id.` test and the call read one value. */
+    idLocal: string;
+    /** Columns the graph reads off this node that the schema snapshot does not carry — `unknown` in the interface. */
+    reads: Array<{
+        name: string;
+        tsType: string;
+    }>;
+    /**
+     * P18-S111-RECORDLIVE. "Record properties" ticked under Run On Value Change, the default: the node shows the app's one
+     * copy of its record, so a write anywhere in the app reaches its outputs (dbmodelnode2.ts `onModelChangedCallback`).
+     * Unticked, the callback returns early and the outputs move only on the node's own read, which is the row as it was.
+     * False where the project declares no backend: the read is a stub that throws and no client is emitted.
+     */
+    live: boolean;
+    /**
+     * P18-S113-IDBINDREAD. Fetch unwired: the node never reads, its Id only binds the row to the client's copy of the
+     * record (`RecordEffectPlan`). Its class's module carries no `fetch<Type>ById` for it, and the client holds records.
+     */
+    binds?: true;
+}
+/**
+ * One files node that translated (EXP-011 §45) — what `src/api/files.ts` must export (`upload` and
+ * `sign`; a `pick` needs only `pickFile` from the util library) and the chain-locals its two arms
+ * bind, read off the plan so the expression side and the action side cannot disagree about a name.
+ */
+export interface FileOpPlan {
+    nodeId: string;
+    family: 'pick' | 'upload' | 'sign';
+    answerLocal: string;
+    messageLocal: string;
+}
+/**
+ * A `Variable` node carrying an authored `Value` (EXP-011 §67). The runtime's `value` input setter
+ * runs at node creation with the parameter and schedules a store (variablenode2.ts), so the node
+ * rewrites the variable on EVERY mount of the component that holds it — navigating back to the
+ * page resets the variable there. The translation is therefore a mount effect in the host — never
+ * a module-level seed, which would boot once, never reset, and run for a component nothing mounted.
+ */
+export interface VariableSeedPlan {
+    nodeId: string;
+    variableName: string;
+    value: string | number | boolean;
+    comment: string;
+}
+/** The seed as the action it prints — read off the plan so the import sweep and the emitter cannot disagree. */
+export declare function variableSeedAction(seed: VariableSeedPlan): HandlerAction;
+/**
+ * EXP-011 §71. An `Object` node whose OWN `prop-<key>` inputs carry typed-in values. The runtime
+ * registers any `prop-*` input on demand and queues every authored parameter at node creation
+ * (nodescope.ts); `userInputSetter` marks the key dirty and `scheduleStore` writes it into the
+ * record in the same pass (modelnode2.ts) — so the node rewrites those keys on EVERY mount of the
+ * component that holds it, and a Set's Do lands over them afterwards (measured, session 94). §67's
+ * shape one construct over: a mount effect in the host, one patch per node, never a module-level
+ * seed (which would boot once, never reset, and run for a component nothing mounted).
+ */
+export interface ObjectSeedPlan {
+    nodeId: string;
+    storeName: string;
+    /** Parameter order — the order the runtime writes `dirtyValues` in. */
+    entries: Array<{
+        key: string;
+        value: string | number | boolean;
+    }>;
+    comment: string;
+}
+/**
+ * P18-S116-FIELDMOUNT. A rendered text input whose Value reaches a chain the export translated (its `onChange`). The
+ * runtime's field announces its Value as it mounts: `componentDidMount` calls `setText(startValue)`, which sends
+ * `onTextChanged` with `outwardValueForFieldType(type, text)` and, through the output's `onChange`, Value Changed
+ * (TextInput.tsx, text-input.ts). So every sink of the Value, and every chain on Value Changed, runs once as the field
+ * appears, with the start value or `""`. The export runs the field's own change chain once from a mount effect, with
+ * the announced value where the chain reads the field.
+ */
+export interface FieldMountPlan {
+    inputId: string;
+    /** The text the field starts from with nothing wired, as the control's boot computes it (`String(startValue ?? '')`). */
+    start: string;
+    /**
+     * The wired Value's source, where a sync effect carries it. The runtime delivers it at node creation, before the
+     * mount, so the field announces it: `undefined` is never delivered (the start value stands), `null` clears.
+     */
+    source?: ValueExpr;
+    /**
+     * P18 session 126 (EXP-011 §93). The field and the elements above it whose Mounted a value decides: the field is not there
+     * as the component mounts, so it announces the first time those values all say mounted (its later mounts announce only a
+     * real change, GAM-009 R10, and the field keeps what it holds). Absent or empty, it announces as the component mounts.
+     */
+    gates?: string[];
+    comment: string;
+}
+/**
+ * P18-S128-FIELDSET and P18-S127-CLEAROUT (EXP-011 §97). A text field's Set or Clear, carried on the `state-set` of the
+ * field's own row, so every walker that reads a state write reads this one; the emitter prints the rest.
+ *
+ * The runtime (`text-input.ts`, `TextInput.tsx`): **Set** writes `_internal.text`, the Value as last delivered (`undefined`
+ * is never delivered, `null` is `''`) or `''` once a Clear has run, and **nothing while the field has focus**; **Clear**
+ * writes `''`, focused or not. Both then call the field's own `setText`, which sends the text to every sink of the Value and
+ * fires Value Changed, changed or not. So the exported write is followed by the field's own change chain, with the text
+ * written where the chain reads the field, as the mount announcement prints it (P18-S116-FIELDMOUNT).
+ *
+ * On a Set, `expr` is the Value's source as a handler reads it (a literal where nothing is wired), and `start` the text a
+ * Value never delivered leaves (the typed-in Value, or `''`); the emitter writes `start` for `undefined`, `''` for `null`,
+ * else `String(value)`. On a Clear, `expr` is the literal `''`.
+ */
+export interface FieldWrite {
+    inputId: string;
+    port: 'set' | 'clear';
+    start?: string;
+}
+/** The seed as the action it prints — one patch, read off the plan so the import sweep and the emitter cannot disagree. */
+export declare function objectSeedAction(seed: ObjectSeedPlan): HandlerAction;
+/**
+ * A `Record` whose `Fetch` is unwired (EXP-011 §43, P18-S113-IDBINDREAD): the Id binds the row to the client's copy of
+ * that record, from an effect keyed on the Id. `action` is the node's `record-fetch` with empty chains (a Done or a
+ * Failure wired is refused, as neither fires without a Fetch); it carries the Id and the row the planner fills, and
+ * the emitter prints the bind from it, never the read.
+ */
+export interface RecordEffectPlan {
+    nodeId: string;
+    action: HandlerAction;
+    comment: string;
+    /** The project declares a backend, so the client holds records; with none, nothing is held and the row stays unset. */
+    held: boolean;
+    /**
+     * "Record properties" ticked (the default): the row follows every later write to the copy (`onModelChangedCallback`).
+     * Unticked, the bind flags the outputs once, so the row is the copy as it was at the bind.
+     */
+    follows: boolean;
+}
+export interface RepeaterPlan {
+    nodeId: string;
+    /** Legacy component path of the template ("/Components/PuppyCard"), or null when unset. */
+    templatePath: string | null;
+    /** The DbCollection2 node wired into `items`, or null when nothing statically known feeds it. */
+    itemsQueryId: string | null;
+    /** The named client-side array wired into `items` (Collection2.items), or null. */
+    itemsCollectionName: string | null;
+    /**
+     * The identity mapping parsed from the effective mapping script (authored parameter, else the
+     * declared port's default — the fixture's trap). **No script at all is 'template-inputs'**:
+     * the runtime then identity-maps item properties onto same-named component inputs by itself
+     * (foreach.tsx), so the mapping is the template's input names, resolved at emit. Null when
+     * the script is anything beyond a static string→string `map({...})` literal; that repeater
+     * defers to EXP-003.
+     */
+    mapping: Array<{
+        input: string;
+        field: string;
+    }> | 'template-inputs' | null;
+    /**
+     * A list-typed vocabulary source wired into `items` (CONTROLLED-STATE-TARGET §4e) — a
+     * prop-fed or state-fed plain list. Emitted `(expr ?? []).map(…)`: `?? []` is foreach.tsx's
+     * own "empty arrival clears the list", rows key by index (no identity column, and the
+     * runtime re-renders on array identity change anyway — grade Q).
+     */
+    itemsExpr?: ValueExpr;
+    /**
+     * A Static Data node whose parsed rows are hoisted to a module constant (STATIC-DATA §3).
+     * Deliberately not `itemsExpr`: that path's contract is "no statically-known item shape, so
+     * fields read as `any` and every mapped input is kept". Static Data's shape *is* known, so it
+     * takes the `collection` treatment instead — derived type, `allowedFields`, a real key.
+     */
+    itemsStaticId?: string;
+}
+/** EXP-011 §99. One relayed row value: the repeater, the row's output, the row's input it passes through, its state row. */
+export interface RowRelayPlan {
+    repeaterId: string;
+    output: string;
+    input: string;
+    stateName: string;
+}
+/**
+ * One Static Data node hoisted to a frozen module constant (STATIC-DATA-TARGET §3).
+ *
+ * The node's three inputs are all `allowEditOnly` (staticdata.ts), so no wire can feed them and
+ * the rows are knowable by construction rather than by a solver that happened to succeed. Only
+ * nodes that pass every §4 gate get a plan; the rest defer with their reason named.
+ */
+export interface StaticDataPlan {
+    nodeId: string;
+    /** `PRODUCTS_DATA` — SCREAMING_SNAKE of the authored label, deduped against reserved names. */
+    constName: string;
+    /** `FeaturedProduct` — the row type alias. */
+    typeName: string;
+    /** Nested object/array aliases this row type references, declaration order (§3.1). */
+    nestedTypes: Array<{
+        name: string;
+        decl: string;
+    }>;
+    /** The row type's own field list, source order. */
+    fields: Array<{
+        name: string;
+        tsType: string;
+        optional: boolean;
+    }>;
+    /** The parsed rows, verbatim — emitted as a frozen literal. */
+    rows: Array<Record<string, unknown>>;
+    /**
+     * `id` when every row carries a unique, primitive, non-null one — which mirrors the runtime's
+     * own identity notion, since `Collection.set` mints each row into a Model and treats `id` as
+     * the record's identity rather than ordinary data (collection.ts:542). Null ⇒ key by index.
+     */
+    keyField: string | null;
+}
+/**
+ * One conditional popup render in the hosting component (POPUPS-TARGET §2, §5). Show Popup
+ * nodes opening the same target with identical literal params share a slot — safe because a
+ * node with any consumed close outcome defers, so shared keys never conflate observable
+ * behaviour.
+ */
+export interface PopupSlotPlan {
+    /** The slot's string literal (`'AboutDialog'`), from the target path's last segment. */
+    slotKey: string;
+    /** Legacy component path of the popup component ("/Components/AboutDialog"). */
+    targetLegacy: string;
+    /** Literal `popupParam-*` values, keyed by the target's input port name — props at emit. */
+    params: Array<{
+        input: string;
+        value: string | number | boolean;
+    }>;
+    /**
+     * HLT-014 — Show Popup's `Close On Escape`. The emitted `PopupDialog` closes on Escape unless this is
+     * `false`, matching the runtime's default-on.
+     */
+    closeOnEscape: boolean;
+    /** HLT-014 — Show Popup's `Accessible Name`; absent means "named by the popup's first heading". */
+    label?: string;
+    /** HLT-014 — Show Popup's `Modal`. `false` renders the plain overlay: not a dialog (a toast). */
+    modal: boolean;
+}
+export interface ComponentFilePlan {
+    dir: 'pages' | 'components';
+    /** "ThankYou" — file base name, deduplicated per directory. */
+    fileBase: string;
+    /** "ThankYouPage" for pages, "PuppyCard" for components. */
+    symbol: string;
+}
+export interface ComponentPlan {
+    path: string;
+    legacyPath: string;
+    role: 'page' | 'component';
+    /** Null when nothing is emitted for this component (no visual root, or the router shell). */
+    file: ComponentFilePlan | null;
+    /** Why file is null, for the report. */
+    skipReason?: string;
+    /**
+     * Which *kind* of skip {@link skipReason} describes — EXP-004's report leads with what worked,
+     * and these two do not belong on the same side of that line.
+     *
+     * 🔴 **A discriminator rather than a read of the sentence.** There are exactly two skips: the
+     * router shell, which the scaffold emits as `src/App.tsx` and is therefore *done*, and a
+     * logic-only component, which is *not*. Both arrive as one `notes` string prefixed with the
+     * component path, and a report that grouped them by matching the prose would call a working
+     * export broken the first time either sentence was reworded. Set at the two sites that know.
+     */
+    skipKind?: 'scaffolded' | 'deferred';
+    /** The node the JSX root renders (the Page node for pages). */
+    rootId: string | null;
+    /** A page's sole Group child merged into the page div (TARGET-OUTPUT §2's shape). */
+    collapsedGroupId?: string;
+    head?: {
+        title?: string;
+        description?: string;
+    };
+    /** Root node's authored label — the component's doc comment. */
+    docComment?: string;
+    props: PropPlan[];
+    /**
+     * Props that carry the enclosing repeater's row (EXP-011 Tier 1.1) — an `Object` node in
+     * "From repeater" mode, compiled away into the component's interface
+     * (EXP-002-MODEL2-TARGET-OUTPUT §4). Minting order.
+     *
+     * 🔴 `field` is carried separately from `prop` and is **not** decoration. The prop name is
+     * deduplicated against everything else the component declares, so an `Object` reading `mood`
+     * in a component that already has a `mood` input becomes the prop `mood2` — and the parent
+     * must still bind it from `item.mood`. Deriving the field from the prop name would silently
+     * read a field no row has, exactly where the collision made it hardest to notice.
+     */
+    rowProps: Array<{
+        prop: string;
+        field: string;
+        /**
+         * EXP-011 §57. Set when the row prop is a `Repeater Item`'s Item Id (field `id`, typed `string` on this
+         * side): the parent then names the node and the port when a feed cannot supply it, rather than the
+         * generic "no row carries this field".
+         */
+        repeaterItem?: string;
+    }>;
+    /**
+     * Declared signal outputs as callback props (`onWaved?: () => void`), declaration order —
+     * the parent side reads the same list off the target's plan (COMPONENT-OUTPUTS-TARGET §2).
+     */
+    outputProps: Array<{
+        port: string;
+        prop: string;
+    }>;
+    /** Render children per node, collapse applied, logic nodes filtered out. */
+    childrenOf: Record<string, string[]>;
+    roleOf: Record<string, RenderRole>;
+    /**
+     * EXP-011 §51. The `Component Children` the runtime honours (chooseChildSlot), when one exists —
+     * the component then declares a `children` prop, and every instance passes its placed children.
+     * Decided by the pure rule on BOTH sides so they cannot disagree; whether the marker also
+     * RENDERS (`roleOf[childSlot] === 'slot'`) is the walk's answer — a marker below a node that did
+     * not draw declares the prop and renders nothing, which is what the running app does.
+     */
+    childSlot?: string;
+    /**
+     * EXP-010. The kit node definition behind each rendered `'custom'` node, plus the module it came
+     * from. Carried on the plan rather than looked up again at emit time so there is one answer to
+     * "which kit owns this node" — the emitted wrapper's import path is derived from it.
+     */
+    customNodes: Record<string, {
+        moduleDir: string;
+        def: KitNodeIR;
+    }>;
+    /**
+     * EXP-010. A custom node's value outputs that something in this component reads, as local state:
+     * the wrapper calls `onXChanged`, the setter writes the row, and the sink binds to it.
+     *
+     * ⚠️ Local, unlike {@link instanceLifted}, and that is not an oversight. A component instance's
+     * value output has to wait for `planProject`'s second phase because whether the *child* lifted
+     * the port is a fact about another plan. A kit node publishes its own outputs from its own
+     * definition, which this component already has — there is nothing to wait for.
+     */
+    customLifted: Record<string, Array<{
+        port: string;
+        setterName: string;
+    }>>;
+    /**
+     * EXP-010 AC3. Visual children of a rendered node that the export could not identify at all,
+     * per parent id, in child order — the emitter prints a comment where each one sat.
+     *
+     * 🔴 **Unidentifiable, not merely undrawn**, and the difference is the whole criterion. A
+     * `Masonry` that defers is a built-in with a reason the report can state and a slice that will
+     * one day handle it. A node whose type is in no catalog and no loaded kit is *the author's own
+     * node*, and before EXP-010 it left the emitted JSX with a gap and nothing in the file to say a
+     * node had ever been there. That silence is the defect this task exists to end, and it is not
+     * ended by a kit that loads — it is ended by the case where the kit does **not**.
+     */
+    droppedChildren: Record<string, Array<{
+        nodeId: string;
+        type: string;
+        reason: string;
+    }>>;
+    /**
+     * Every wire this plan refused, with the endpoints kept as *values* (EXP-004's in-code markers).
+     *
+     * 🔴 **The emitter cannot re-derive this, and must not try.** "A wire whose sink has no binding"
+     * looks like the same population and is not: a signal folded into a handler chain, a control's
+     * state merged into its `onChange`, a `mounted` wire riding the render wrapper and a wire into a
+     * collapsed group all leave no binding behind while having translated perfectly. Guessing from
+     * absence would put `TODO(export)` markers on working code — a worse failure than the missing
+     * marker this closes, in the one file whose job is not misleading its reader.
+     *
+     * So each refusal records itself here, beside the note it files, and `wireNote` is what keeps
+     * the two from drifting: it writes the row and returns the sentence.
+     */
+    droppedWires: DroppedWire[];
+    /** nodeId → toProperty → source, for value wires landing on rendered nodes. */
+    bindings: Record<string, Record<string, BindingSource>>;
+    /** nodeId → source signal port → actions, for signal wires resolved to handler statements. */
+    handlers: Record<string, Record<string, HandlerAction[]>>;
+    /** Rendered text input id → actions its onChange performs (the wired-onTextChanged rule). */
+    changeHandlers: Record<string, HandlerAction[]>;
+    /** Event Receivers this component hosts as useSignal subscriptions. */
+    receivers: ReceiverPlan[];
+    /** P18-S126-INSIGNAL. One effect per signal input whose wires run a chain. */
+    inputPulses: InputPulsePlan[];
+    /** P18-S126-INSIGNAL. One count per placed component's signal input a sender here attached to. */
+    instancePulses: InstancePulsePlan[];
+    /** Popup slots this component renders, registration order — earned by attachment (§2). */
+    popups: PopupSlotPlan[];
+    /** True when a translated Close Popup attached — the component declares `onClose` (§4). */
+    closesPopup: boolean;
+    queries: QueryPlan[];
+    /** Record verbs translated in this component (RECORD-VERBS-TARGET §4), compile order. */
+    mutations: MutationPlan[];
+    /** The user-family nodes that translated — what `src/api/session.ts` must export. */
+    sessionCalls: SessionCallPlan[];
+    /**
+     * HTTP Requests translated in this component (EXP-011 Tier 1.2), compile order — what
+     * `src/api/http.ts` must export. Earned by attachment, exactly as the record verbs are.
+     */
+    httpCalls: HttpCallPlan[];
+    /** EXP-011 §41. */
+    cloudCalls: CloudCallPlan[];
+    /** EXP-011 §43. */
+    recordReads: RecordReadPlan[];
+    /** EXP-011 §45. The files nodes that translated, compile order — earned by attachment. */
+    fileOps: FileOpPlan[];
+    repeaters: Record<string, RepeaterPlan>;
+    /** Static Data nodes hoisted to module constants (STATIC-DATA-TARGET §3), resolution order. */
+    staticData: StaticDataPlan[];
+    /**
+     * Re-host wrapper definitions by node id (EXP-003 §4), registered the moment a read of the
+     * node resolves — the emit layer prints exactly the wrappers that surviving expressions
+     * reference, so a definition nothing kept costs nothing. Insertion order is resolution order
+     * and therefore deterministic.
+     */
+    jsFunctions: Record<string, JsFunctionPlan>;
+    /**
+     * Nodes carrying author-written JavaScript that this component did **not** translate, and that
+     * are not Function/Expression/Visual Function — those three are `jsFunctions`, and the emit
+     * layer already preserves a refused one's body as a comment.
+     *
+     * 🔴 This is the same loss one node-family over, and it was silent. A `Map Collection` whose
+     * Script does more than name properties is deferred with a reason and an in-code marker naming
+     * the node — and its script text appeared **nowhere in the exported repo**, which is exactly
+     * the case where that text is the only statement of what the developer now has to write
+     * (EXP-004, and §20's argument for the Function case verbatim).
+     *
+     * Node order, so the output is deterministic.
+     */
+    refusedScripts: RefusedScriptPlan[];
+    /**
+     * State rows (CONTROLLED-STATE-TARGET §3), registered the moment a use resolves — the emit
+     * layer prints exactly the vars that surviving actions/expressions/effects reference.
+     */
+    stateVars: StateVarPlan[];
+    /** Sync effects (§3.4), registration order — one per translated wired control-state input. */
+    syncEffects: SyncEffectPlan[];
+    /** Push effects (§3.5), registration order — the lifted value outputs' child side. */
+    pushEffects: PushEffectPlan[];
+    /**
+     * EXP-011 §99. A repeater's relayed row values (`itemOutput-<output>`) this component lifts: a state row per value,
+     * written in every row's relayed-signal callback from what the parent hands that row for its input `input`, before
+     * the signal's chain, as the runtime's `itemOutputSignalTriggered` copies the row's outputs and then sends the signal.
+     */
+    rowRelays: RowRelayPlan[];
+    /** Reactive Conditions (LOGIC-TARGET §10), compile order — one useEffect each. */
+    branchEffects: BranchEffectPlan[];
+    /** Value Changed effects (EXP-011 §39), compile order — one useEffect + one useRef each. */
+    valueChangedEffects: ValueChangedEffectPlan[];
+    /** P18-S119-TICKEDRUN. Run-wired Functions a ticked input also runs, node order — one useEffect + one useRef each. */
+    tickedRuns: TickedRunPlan[];
+    /** EXP-011 §43. Records whose Fetch is unwired, compile order — one useEffect keyed on the Id each. */
+    recordEffects: RecordEffectPlan[];
+    /** EXP-011 §67. Variables with an authored Value, node order — one mount effect each. */
+    variableSeeds: VariableSeedPlan[];
+    /** EXP-011 §71. Object nodes with values typed into their own property inputs, node order — one mount effect each. */
+    objectSeeds: ObjectSeedPlan[];
+    /** P18-S116-FIELDMOUNT. Text inputs that announce their Value as they mount, node order — one mount effect each. */
+    fieldMounts: FieldMountPlan[];
+    /** EXP-011 §48. CSS Definitions, node order — one module constant + one mount effect each. */
+    styleSheets: StyleSheetPlan[];
+    /** EXP-011 §49. The States nodes that translated, registration order. */
+    statesMachines: StatesPlan[];
+    /** EXP-011 §49. The Animate To Value nodes that translated, registration order. */
+    animations: AnimationPlan[];
+    /** EXP-011 §52. The Script nodes that translated, registration order. */
+    scripts: ScriptPlan[];
+    /** EXP-011 §53. The Run Tasks nodes hosted here, registration order. */
+    runTasks: RunTasksPlan[];
+    /** EXP-011 §53. Set when this component is a Run Tasks template whose start chain translated. */
+    task?: TaskPlan;
+    /** EXP-011 §57. Repeater Items whose Added chain translated — a once-on-mount effect each. */
+    repeaterItems: RepeaterItemPlan[];
+    /** EXP-011 §53. Why a component named as a template is not one — repeated by every host that names it. */
+    taskRefusal?: string;
+    /** EXP-011 §54. The On App Error boundaries hosted here, registration order. */
+    appErrors: AppErrorPlan[];
+    /** EXP-011 §58. */
+    streams: StreamPlan[];
+    /** EXP-011 §59. The Screen Resolution hooks this component reads, registration order. */
+    screenResolutions: ScreenResolutionPlan[];
+    /** EXP-011 §60. The Component Object record this component materializes (record mode), if any. */
+    componentObject?: ComponentObjectRecordPlan;
+    /** EXP-011 §60. The nearest ancestor's record this component reads or writes through the parent pair, if any. */
+    parentObject?: ParentComponentObjectPlan;
+    /** EXP-011 §63. The Drag nodes rendered here, registration order. */
+    drags: DragPlan[];
+    /** EXP-011 §61. The Component Stacks this component renders, registration order — one hook line each. */
+    pageStacks: PageStackPlan[];
+    /**
+     * EXP-011 §61. Set when a Pop Component Stack attached here: the interface then declares the reserved prop
+     * `pageStackEntry?: PageStackEntryHandle`, and every stack row that shows this component passes it.
+     */
+    popsStack: boolean;
+    /** EXP-011 §55. The `Create New Array` handles this component holds, allocation order. */
+    mintedArrays: MintedArrayPlan[];
+    /**
+     * EXP-011 §54. Set when this is the router shell kept as a file for the logic beside its Router — a
+     * null-rendering component the scaffold's `App.tsx` renders inside the router, for the app's life. The
+     * Router itself is still `collapsed into src/App.tsx`.
+     */
+    shell?: true;
+    /**
+     * EXP-021 slice 1 (P18 session 136). Set when this is a logic component — no node in it draws, and a component places
+     * it — exported as a hook, `use<Name>(props)`, with the props interface a visual component has: the placement's inputs,
+     * its signal inputs' pulses, its signal outputs' callbacks, its lifted value outputs. Its placements are called, not drawn
+     * (`hookCalls`). The runtime keeps a component instance whether or not anything draws it, as a hook call does.
+     */
+    hook?: true;
+    /** EXP-021 slice 1. The placements of logic components in this component, in source order: one hook call each. */
+    hookCalls: string[];
+    /**
+     * Value output ports this component lifts (§4d child side) — the parent side consults this
+     * list off the target's plan, so parent and child agree by construction (the s10 rule).
+     */
+    liftedOutputProps: Array<{
+        port: string;
+        prop: string;
+        tsType: string;
+    }>;
+    /** Instance id → lifted callbacks the parent passes (`onXChanged={setX}`) (§4d parent side). */
+    instanceLifted: Record<string, Array<{
+        prop: string;
+        setterName: string;
+    }>>;
+    /**
+     * Parent-side lifted wires awaiting the target's plan (planProject's second phase): a
+     * consumed instance value output binds only when the child actually lifted the port —
+     * otherwise the parent would pass a prop the child's emitted interface does not declare.
+     */
+    pendingLifted: Array<{
+        connectionKey: string;
+        instanceId: string;
+        targetLegacy: string;
+        port: string;
+        toNodeId: string;
+        toProperty: string;
+        /** P18-S127-SIBLINGVALUE. The sink is another placed component's input: a lift that fails is named on its marker. */
+        intoInstance?: true;
+    }>;
+    dispositions: Record<string, Disposition>;
+    /** Dropped wires, unhandled constructs — EXP-004's report feed. Nothing silently dropped. */
+    notes: string[];
+    /**
+     * EXP-013. Every node `dispositions` refused, as a row with the refused node that starves it.
+     * Built from `dispositions` at each exit, after the sweeps — see {@link RefusedNode}.
+     */
+    refusals: RefusedNode[];
+}
+export interface ProjectPlan {
+    plans: ComponentPlan[];
+    byLegacyPath: Map<string, ComponentPlan>;
+    /**
+     * Legacy component path → the scaffold's route-table row for it.
+     *
+     * 🔴 **The whole row, not the url string it used to hold.** A parameterised page has three
+     * paths — the authored `/product/{id}`, the react-router pattern `/product/:id` and the
+     * concrete url a Navigate builds — and a `Map<string, string>` can only carry one of them.
+     * Carrying the row means the route table and the navigations into it cannot disagree.
+     */
+    pageByLegacy: Map<string, ScaffoldPage>;
+    /** Collections needing an api stub module, in first-use order. */
+    stubCollections: string[];
+    /** App-wide Variables, discovery order — src/stores/variables.ts when non-empty. */
+    variables: VariablePlan[];
+    /** Event channels, discovery order — src/events.ts when non-empty. */
+    channels: ChannelPlan[];
+    /** Named Global Stores, discovery order — one src/stores/<exportName>.ts each. */
+    stores: StorePlan[];
+    /** Named client-side arrays, discovery order — one src/collections/<exportName>.ts each. */
+    collections: CollectionPlan[];
+    /**
+     * Which components a route can reach (reach.ts). Not a disposition and never a reason to emit
+     * less — every component is still emitted. It is what lets the report say whether a deferral is
+     * work the app is missing or a node in a component nothing renders, which over this corpus is
+     * the difference between 85.00% and 93.38%.
+     */
+    reachability: Reachability;
+    /**
+     * EXP-010. Node types more than one kit registers, as `type (kit that lost)`.
+     *
+     * 🔴 A collision, not a warning about one: `registerModule` refuses the second registration, so
+     * the running app shows the *first* kit's node. The export follows that rule and says which kit
+     * it therefore ignored — silently taking either one would emit an app that does not match the
+     * one the author is looking at.
+     */
+    kitDuplicates: string[];
+}
+export declare function planProject(ir: ExportIR, catalog: CatalogIndex): ProjectPlan;
+/**
+ * P18-S122-DEADROW, P18-S123-UNDRAWNTRIGGER. What a component's next plan refuses before it attaches anything: chains on
+ * an element the export never draws (`owners`), Did Mount chains on an element a value mounts (`mounts`, which the
+ * emitter does not run), and the render reads of a Function's row that nothing the export runs ever writes (`rows`, by
+ * the Function's id). Each maps a node id to the sentence the refusal says.
+ *
+ * 🔴 **A row's other readers are kept, and said.** A Function input or a Set Variable that reads a dead row reads what
+ * HEAD's export read (nothing yet); refusing the reader would take a chain that works for every other input with it
+ * (the older Site Builder copies' "The slug to show" reads the URL's slug, and the never-written home slug only as a
+ * fallback). They are named in a note instead.
+ */
+/** P18 session 126 (EXP-011 §93). The words a refusal under a page's own wired Group starts with; the emitter says the same. */
+export declare const UNCARRIED_PAGE_GROUP = "the page's own Group,";
+export interface PlanExclusions {
+    owners: Map<string, string>;
+    mounts: Map<string, string>;
+    rows: Map<string, string>;
+}
+/**
+ * Why an element of a planned component is never drawn, or `null` when it may be. The emitter's own rule (`render` in
+ * `component.ts`): an element, or an element above it, whose Mounted is bound to a statically false value, or not bound
+ * and authored false, is removed from the tree. A Mounted bound to anything else draws it when that value says.
+ */
+export declare function undrawnReasonOf(plan: ComponentPlan, component: ComponentIR, id: string): string | null;
+/**
+ * EXP-011 §99, P18-S131-ROWLESSTRIGGER. Why a repeater draws no rows in the export, or null when it draws them: its items
+ * have no feed the export reads (a query, a named array, an expression, Static Data), or its rows are mapped by a script
+ * (the emitter's `renderRepeater` draws a TODO marker for both). Decided after the list passes.
+ */
+export declare function rowlessReasonOf(plan: ComponentPlan, repeaterId: string): string | null;
+/**
+ * The triggers of one planned component that the emitted app never runs (see {@link PlanExclusions}). Read off the
+ * finished plan: its handlers, its bindings after the lift phase, and every action list it carries.
+ */
+export declare function unreachedTriggersOf(plan: ComponentPlan, component: ComponentIR): PlanExclusions;
+/**
+ * A component's output interface, from its Component Outputs nodes' declarations — the union
+ * across nodes, first declaration of a name winning (the runtime merges the port sets the same
+ * way). Signal ports become callback props (COMPONENT-OUTPUTS-TARGET §2): a name that is
+ * already an `onX` identifier is kept verbatim, anything else becomes `on` + PascalCase. A
+ * port that cannot become a prop — no identifier material, or a collision with an input prop
+ * or another output — fails with a reason rather than being silently renamed. Deterministic
+ * over the ComponentIR alone, so the child's plan and every parent's plan agree.
+ */
+export interface OutputInterface {
+    props: Array<{
+        port: string;
+        prop: string;
+    }>;
+    failed: Array<{
+        port: string;
+        reason: string;
+    }>;
+    /** Declared value-kind output ports — the lifted-state candidates (CONTROLLED-STATE §4d). */
+    valuePorts: string[];
+    /**
+     * Value ports named as lifted callback props (`on` + PascalCase + `Changed` — the s10 name
+     * source; collisions fail the port, never silently rename). Whether a port actually lifts is
+     * the owning component's plan's to decide (its feed must resolve); the name is decided here,
+     * off the ComponentIR alone, so the child's plan and every parent's plan agree.
+     */
+    valueProps: Array<{
+        port: string;
+        prop: string;
+        tsType: string;
+    }>;
+}
+export declare function signalInputPortsOf(component: ComponentIR | undefined): Set<string>;
+export declare function componentOutputInterface(component: ComponentIR): OutputInterface;
+/** node type → the kit node that registers it, and which module folder that kit is. */
+export type KitIndex = Map<string, {
+    moduleDir: string;
+    def: KitNodeIR;
+}>;
+/**
+ * Every node type the project's kits register (EXP-010).
+ *
+ * ⚠️ **First registration wins, and a duplicate is not silently discarded** — the running app has
+ * the same collision (`registerModule` refuses the second) so the export must agree with it rather
+ * than pick the later one and render a different node than the app does. The caller reports it.
+ */
+export declare function indexKitNodes(modules: ModuleIR[]): {
+    index: KitIndex;
+    duplicates: string[];
+};
+/**
+ * EXP-013 AC4 — is losing this node losing a **pathway** rather than a feature?
+ *
+ * Three families, from Richard's ruling (EXP-011 §50): a backend verb (the record verbs, the
+ * relation verbs, `Record`, `Query Records`, the user verbs, `Cloud Function`, `HTTP Request`,
+ * the files), a navigation (`Navigate`, `Navigate To Path`, `External Link`), and `On App Error`,
+ * whose refusal removes the app's whole error pathway. A `Set Variable` behind a refused trigger
+ * is a missing feature; a `Cloud Function` behind one is the app no longer talking to its backend
+ * — the verdict in the pre-flight turns on this distinction, so it lives beside the tables that
+ * define the families rather than in a second list the report would keep.
+ */
+/** EXP-011 §58. Which of a streaming node's value outputs read undefined before anything happened — the table's answer, shared with component.ts. */
+export declare function streamFieldMaybeUndefined(node: StreamKind, field: string): boolean;
+export declare function isPathwayType(type: string): boolean;
+/** EXP-011 §56. Every wired expression a filter tree reads, for the walkers that follow an expression's reads. */
+export declare function whereExprs(where: RecordWhere | null): ValueExpr[];
+/**
+ * Parses a For Each mapping script as far as "is this a static object literal of
+ * string→string" (TARGET-OUTPUT §2). Anything cleverer returns null and defers to EXP-003.
+ */
+export declare function parseIdentityMapping(script: string): Array<{
+    input: string;
+    field: string;
+}> | null;
+/**
+ * §15 — a component prop's type is what the port *declares*, and `any` when it declares nothing.
+ *
+ * A port type is **free text** (`AiAssistant/authoring/plan.ts`: *"names are what bind"*), so
+ * there is no closed vocabulary to fall through to a default with. The editor's own PortEditor
+ * panel opens a new Component Inputs port as `type: { name: '*' }` (`componentinputs.ts`), and
+ * `*` is normatively the untyped wildcard — the Port Type Contract describes "an untyped Function
+ * output defaulted to `*` and connected anywhere". It is two thirds of the corpus's component
+ * ports (471 of 714).
+ *
+ * Mapping that to `string` was the emitter claiming a type the graph refused to make, and it is
+ * the same disagreement §12 refused in the other direction: the declared type is a claim about
+ * the port, not a check on what reaches it. Nothing coerces on delivery — `componentinputs.ts`
+ * registers each output as a bare getter over `_internal.inputValues`, and the one cast on a
+ * connection (`node.ts` `_setValueFromConnection`) is `object`/`array` → `string` only.
+ *
+ * `any` rather than `unknown` for the reason the `array` case already gives, and the reason the
+ * two sibling mappers in this file — `jsOutputTsType` and `valueTsTypeOf` — both already default
+ * to `any`: strict tsc rejects an `unknown` read at the sites that consume these values.
+ *
+ * ⚠️ `string` must stay an explicit case. It is 224 ports, and it reached its type through the
+ * old default — folding it into this one would widen every genuinely-typed prop in the corpus.
+ */
+/** One row of a Component Stack's Components list, resolved (EXP-011 §61). */
+interface StackPageInfo {
+    id: string;
+    label: string;
+    /** The `pageComp-<id>` parameter — undefined when unset (the stack then refuses). */
+    componentLegacy: string | undefined;
+}
+/** A `Page Stack` anywhere in the project, read off the IR once (EXP-011 §61). */
+export interface StackInfo {
+    nodeId: string;
+    componentPath: string;
+    label: string;
+    /** The authored Name, `Main` by default — `navigation-handler.ts` keys its registry on `name || 'Main'`. */
+    name: string;
+    pages: StackPageInfo[];
+    /** The authored Start Page, or the first page's id (`resetAsync`). */
+    startPage: string;
+    /** Why the stack does not translate, or null. Decided from the IR alone, so a pusher in any component can ask. */
+    refusal: string | null;
+}
+export interface StackIndex {
+    byNode: Map<string, StackInfo>;
+    byName: Map<string, StackInfo[]>;
+    /** The stacks listing a component (by legacy path) among their pages — the Pop's gate. */
+    hostsOf: Map<string, StackInfo[]>;
+}
+/** The stringlist parameters of a Pop (`results`, `backActions`) — split as the runtime splits them, no trimming. */
+export declare function stackStringList(value: unknown): string[];
+/**
+ * EXP-011 §61. Every `Page Stack` in the project with its refusal, computed once per IR — `popupTargetLegacies`'
+ * shape, because a pusher is planned in one component and its stack sits in another, and the plan runs
+ * component by component. Every check here is a fact the IR states outright (an authored value, a wire into
+ * the stack, a page's existence and root), never a plan-time one.
+ */
+export declare function indexPageStacks(ir: ExportIR, catalog: CatalogIndex, kits: KitIndex): StackIndex;
+/**
+ * The api module's names for one class, a pure function of the class name (RECORD-VERBS-TARGET
+ * §4d). Queries and mutations both derive from this, so a project that reads *and* writes one
+ * collection lands both in a single module rather than two that disagree about the type name.
+ */
+/**
+ * A schema column's declared type as TS (EXP-002 §10a) — the one mapping, read by the collection
+ * module's interface and by a `Record`'s column reads (EXP-011 §43), so the two cannot disagree.
+ */
+export declare function tsColumnType(columnType: string): string;
+export declare function collectionModuleNames(collectionName: string): {
+    typeName: string;
+    plural: string;
+    moduleBase: string;
+    fetchName: string;
+};