@uipath/maestro-builder-sdk 5.2.0

package/dist/decompile.js

@@ -0,0 +1,2482 @@
+/**
+ * decompile — the reverse of `serialize.ts`: turn a real UiPath `.flow` JSON
+ * back into Flow SDK builder source (`.flow.ts`) that, when re-compiled,
+ * serializes to the **same** graph (same node ids, same logical edges).
+ *
+ * Unlike the case decompiler (`case/decompile.ts`), a flow is a directed GRAPH
+ * (`nodes[]` + `edges[]` with `sourcePort`/`targetPort`), not a hierarchy, and
+ * the builder is structured (`.branch()` / `.switch()` / `.loop()` /
+ * `.parallel()` / `.onError()` / `.return()`). Decompiling therefore means
+ * reconstructing structured control flow from the graph — the inverse of
+ * serialize's `emit()` walker. This module is built in layers:
+ *
+ *   - Phase 1 (here): the linear core — header, variables, trigger, and a
+ *     straight-line chain of action steps ending in `.return()` / `.terminate()`.
+ *   - Phase 2: the full node reverse-map (http / transform / connectors / hitl /
+ *     agents / queue / …) and connector reverse-lookup.
+ *   - Phase 3: control-flow reconstruction (branch / switch / loop / parallel /
+ *     onError / stepToRef / subflow) via graph analysis.
+ *
+ * The linchpin is **node-id stability**: serialize derives each node id from the
+ * author's step NAME (`claimId`: `[^A-Za-z0-9_]→_`, then de-dup `base`/`base2`/…),
+ * so if we name every step with its original node id, serialize reproduces
+ * byte-identical ids. A happy consequence: serialize's `renameRefs`
+ * (`$vars.<stepName>`→`$vars.<nodeId>`) becomes the identity, so expression
+ * references need no un-renaming.
+ *
+ * The round-trip is **semantically** lossless, not byte-for-byte: layout,
+ * display labels on plain steps, and formatting are not preserved (layout is
+ * re-attached by `flow-merge`; see `docs/FLOW_PARITY.md`).
+ */
+import { readFileSync } from 'node:fs';
+import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
+import { preserveSchemaVersion } from './schema-version.js';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { inferScriptShape } from './core/script-return.js';
+import { DEFAULT_TRIGGER_ID } from './core/expr.js';
+import { parseIxpProjectType } from './core/actions.js';
+import { readFlowGlobals } from './flow-variables.js';
+import { eventFilterFromTreeLeaf } from './event-filters.js';
+/**
+ * The trigger id of the flow currently being decompiled, so a reference through a
+ * RENAMED trigger is still recognized as `input('x')` rather than falling back to
+ * a raw `js` template. Run-scoped rather than threaded: `decompile()` is
+ * synchronous and single-shot, and `inputNames` is already carried to all 34 call
+ * sites that would otherwise need a second argument.
+ */
+let currentTriggerId = DEFAULT_TRIGGER_ID;
+/**
+ * Version preservation (design §5.3), run-scoped like `currentTriggerId`:
+ * every emitted node method carries an explicit `{ version }` read from the
+ * instance's `typeVersion`, verified against the file's own embedded
+ * `definitions[]`. Strict mode (bestEffort: false) FAILS on a missing or
+ * disagreeing pair rather than normalizing either side; best-effort still
+ * emits the original version so recompilation cannot silently downgrade it.
+ */
+let runDefPairs = new Set();
+/**
+ * The file's `definitions[]`, by `<type>@<version>` and by bare type.
+ *
+ * Several families keep the author's identity on the DEFINITION rather than the
+ * instance — the published-resource families put `name`/`folderPath` in
+ * `model.bindings.values` and the declared `returns` in
+ * `outputDefinition.output.schema` — so recovering them means reading the
+ * definition, not just the node.
+ */
+let runDefs = new Map();
+/**
+ * Manifests hoisted out of the step chain for `rawNode(...)` calls — `[const
+ * name, JSON source]`. A definition can be 18 KB (an IxP extractor's is), and a
+ * blob that size inline in the middle of a builder chain is unreadable for the
+ * agent that has to edit the file next.
+ */
+let runRawManifests = [];
+let runStrict = false;
+/** `DecompileOptions.warn` for the current run, and the messages already sent to it (one line per finding). */
+let runWarn;
+let runWarned = new Set();
+function warnOnce(message) {
+    if (runWarned.has(message))
+        return;
+    runWarned.add(message);
+    runWarn?.(message);
+}
+/**
+ * The `<nodeType>@<version>` pairs this SDK bundles for core nodes — the same
+ * file `serialize` resolves an explicit `{ version }` against (design §2.6:
+ * exact, no floating). Decompile preserves the file's pair (design §5.3), so
+ * when the file pins a version the bundle lacks, `compile` WILL refuse the
+ * emitted source; saying so here is the difference between a loop that fails
+ * at step 2 with a hint and one that fails at step 2 with a puzzle.
+ */
+const CORE_DEFINITION_KEYS = new Set(Object.keys(JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), 'core-definitions.json'), 'utf8'))));
+function verClause(node) {
+    const tv = node.typeVersion;
+    if (!tv) {
+        if (runStrict) {
+            throw new Error(`decompile: node "${node.id}" (${node.type}) carries no typeVersion.`);
+        }
+        return '';
+    }
+    if (runDefPairs.size > 0 && !runDefPairs.has(`${node.type}@${tv}`)) {
+        if (runStrict) {
+            throw new Error(`decompile: no embedded definition matches (${node.type}, ${tv}) for node "${node.id}" — `
+                + `the file's definitions[] disagrees with the instance.`);
+        }
+    }
+    if (node.type.startsWith('core.') && !CORE_DEFINITION_KEYS.has(`${node.type}@${tv}`)) {
+        const shipped = [...CORE_DEFINITION_KEYS]
+            .filter((k) => k.startsWith(`${node.type}@`))
+            .map((k) => k.slice(node.type.length + 1));
+        warnOnce(`node ${str(node.id)} pins ${node.type}@${tv}, but this SDK bundles ${node.type}@${shipped.join(', ') || '<none>'} only; `
+            + `\`compile\` will refuse the emitted { version: ${str(tv)} } (versions resolve exactly, flow-builder-sdk#71). `
+            + `The source keeps the file's pair; to recompile, drop that { version } and the node takes the SDK's pinned version.`);
+    }
+    return `version: ${str(tv)}`;
+}
+function verArg(node) {
+    const clause = verClause(node);
+    return clause ? `, { ${clause} }` : '';
+}
+/**
+ * The full node-options argument for steps that can carry both an exact
+ * `version` and mid-flow `updates` (the format's `variableUpdates[nodeId]`,
+ * for every node that is not an End — an End's updates are `.return()` values).
+ */
+function optsArg(node, ctx) {
+    return optsArgWith(node, ctx, []);
+}
+/** `optsArg` plus construct-specific option clauses (loop/do-while recovery). */
+function optsArgWith(node, ctx, extra) {
+    const parts = [...extra];
+    const ver = verClause(node);
+    if (ver)
+        parts.push(ver);
+    // A canvas label the author chose. Decompile names every step by its node id,
+    // so serialize would re-derive exactly `node.id` — anything else is the
+    // designer's or the author's and has to be carried, or it is lost on the next
+    // compile. Equal-to-default is omitted so ordinary flows stay quiet.
+    const label = node.display?.label;
+    if (typeof label === 'string' && label !== node.id)
+        parts.push(`label: ${str(label)}`);
+    const updates = ctx.flow.variables?.variableUpdates?.[node.id] ?? [];
+    if (updates.length) {
+        const entries = updates.map((u) => `${key(u.variableId)}: ${emitVal(u.expression, ctx.imp, ctx.inputNames)}`);
+        parts.push(`updates: { ${entries.join(', ')} }`);
+    }
+    return parts.length ? `, { ${parts.join(', ')} }` : '';
+}
+// ─── Node type constants (mirror of serialize.ts NODE_TYPE) ───────────────────
+const T = {
+    triggerManual: 'core.trigger.manual',
+    triggerScheduled: 'core.trigger.scheduled',
+    triggerForm: 'core.trigger.form',
+    triggerConversation: 'core.trigger.conversation',
+    hitl: 'uipath.human-in-the-loop',
+    inlineAgent: 'uipath.agent.autonomous',
+    conversationalAgent: 'uipath.agent.conversational',
+    voiceAgent: 'uipath.agent.voice',
+    hitlQuickForm: 'uipath.human-in-the-loop.quick-form',
+    hitlActionApp: 'uipath.human-in-the-loop.coded-action-app',
+    hitlDocValidation: 'uipath.human-in-the-loop.document-validation',
+    queueCreate: 'core.action.queue.create',
+    queueCreateAndWait: 'core.action.queue.create-and-wait',
+    summarize: 'uipath.pattern.deep-rag',
+    batchTransform: 'uipath.pattern.batch-transform',
+    sendMessage: 'uipath.conversational.send-message',
+    waitForMessage: 'uipath.conversational.wait-for-message',
+    conversationContext: 'uipath.conversational.get-conversation-context',
+    triggerVoice: 'core.trigger.voice',
+    createOutgoingCall: 'uipath.conversational.voice.create-outgoing-call',
+    endCall: 'uipath.conversational.voice.end-call',
+    http: 'core.action.http',
+    httpV2: 'core.action.http.v2',
+    script: 'core.action.script',
+    transform: 'core.action.transform',
+    delay: 'core.logic.delay',
+    mock: 'core.logic.mock',
+    decision: 'core.logic.decision',
+    switch: 'core.logic.switch',
+    merge: 'core.logic.merge',
+    loop: 'core.logic.loop',
+    doWhile: 'core.logic.dowhile',
+    dataFabricRead: 'core.datafabric.read',
+    documentClassify: 'uipath.document.classify',
+    dynamicExtract: 'uipath.ixp.extract-document-builder',
+    dataFabricUpdate: 'core.datafabric.update',
+    subflow: 'core.subflow',
+    terminate: 'core.logic.terminate',
+    end: 'core.control.end',
+};
+/** A trigger node's type (its id is always `start`). */
+function isTrigger(type) {
+    return type.startsWith('core.trigger.') || type.startsWith('uipath.connector.event.') || type.startsWith('uipath.connector.trigger.');
+}
+// ─── Injection-safe source emitters (ported verbatim from case/decompile.ts) ──
+/**
+ * A JS/TS string literal (double-quoted, correctly escaped). `JSON.stringify`
+ * escapes quotes, backslashes and control chars — so untrusted `.flow` values
+ * (labels, expressions, code) can never break out of the literal. We also escape
+ * U+2028/U+2029 (legal in JSON, historically illegal in JS string literals).
+ * Non-string input still serializes to inert JSON (never executable).
+ */
+function str(s) {
+    return JSON.stringify(s).replace(/[\u2028\u2029]/g, (c) => '\\u' + c.charCodeAt(0).toString(16));
+}
+/** A boolean literal, coerced so an untrusted non-boolean can never reach source verbatim. */
+function boolLit(v) {
+    return v ? 'true' : 'false';
+}
+/** An object key: a bare identifier when legal, otherwise a quoted string. */
+function key(k) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(k) ? k : str(k);
+}
+/** An arbitrary JSON-serializable value as a TS literal (used for var defaults). */
+function literal(v) {
+    return JSON.stringify(v);
+}
+/** Render an options object from present entries; '' when nothing is present. */
+function opts(entries) {
+    const parts = entries.filter(([, v]) => v !== undefined).map(([k, v]) => `${key(k)}: ${v}`);
+    return parts.length ? `{ ${parts.join(', ')} }` : '';
+}
+/** A collector for indented source lines. */
+class Emit {
+    indentUnit;
+    lines = [];
+    constructor(indentUnit = '  ') {
+        this.indentUnit = indentUnit;
+    }
+    line(depth, text) {
+        this.lines.push(this.indentUnit.repeat(depth) + text);
+    }
+    toString() {
+        return this.lines.join('\n');
+    }
+}
+/** Tracks which SDK identifiers the emitted source uses, so the import is exact. */
+class Imports {
+    used = new Set(['flow']);
+    use(name) {
+        this.used.add(name);
+        return name;
+    }
+    line(specifier) {
+        const names = [...this.used].sort();
+        return `import { ${names.join(', ')} } from ${str(specifier)};`;
+    }
+}
+// ─── Expression inversion ─────────────────────────────────────────────────────
+/**
+ * Unwrap a node input / output `source` value into a raw expression string.
+ * `migrate.ts` wraps dynamic values as `{type:'jsExpression', expression, …}`
+ * (the `=js:` prefix stripped) and literals as `{type:'literal', expression}`;
+ * this is the inverse. A plain string is returned as-is.
+ */
+function unwrapSource(v) {
+    if (typeof v === 'string')
+        return v;
+    if (v && typeof v === 'object' && 'expression' in v) {
+        const o = v;
+        if (o.type === 'jsExpression')
+            return '=js:' + o.expression;
+        return o.expression;
+    }
+    return undefined;
+}
+/** A plain (boolean/number) input value, unwrapping a literal EV envelope if present. */
+function unwrapPlain(v) {
+    if (v && typeof v === 'object' && 'expression' in v && v.type === 'literal') {
+        try {
+            return JSON.parse(v.expression);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return v;
+}
+/** True when any node in the body scope wires the container's break handle. */
+function bodyBreaks(graph, scope, containerId) {
+    return [...scope].some((id) => graph.outEdges(id).some((e) => e.targetNodeId === containerId && e.targetPort === 'break'));
+}
+/** Escape a raw JS expression body for embedding in a `` js`…` `` tagged template. */
+function jsTemplate(body) {
+    const esc = body.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+    return '`' + esc + '`';
+}
+/**
+ * Emit builder source for a dynamic reference or computed expression (the JS
+ * body of an `=js:` value, or a bare decision/switch expression). Recognizes the
+ * common single-reference shapes and lowers them to the readable helpers
+ * (`input` / `v` / `out` / `err` / `ran`); anything composite falls back to a
+ * `` js`…` `` template (which reproduces the same `Expr.js`).
+ */
+function emitRef(jsBody, imp, inputNames) {
+    const body = jsBody.trim();
+    let m;
+    // The path/field grammar of a SINGLE reference: an identifier followed by any
+    // number of `.identifier` or `[index]` selectors — and NOTHING else. Anchoring
+    // to exactly this is what keeps a COMPOSITE expression like
+    // `$vars.p.output.ageDays <= 7` from being mis-read as `out('p','ageDays <= 7')`:
+    // the trailing ` <= 7` is not a path segment, so the whole thing falls through
+    // to the `js\`…\`` template below.
+    const PATH = '[A-Za-z_]\\w*(?:\\.[A-Za-z_]\\w*|\\[\\d+\\])*';
+    // !!$vars.<step>.output  →  ran('step')
+    if ((m = body.match(/^!!\$vars\.([A-Za-z_]\w*)\.output$/)))
+        return `${imp.use('ran')}(${str(m[1])})`;
+    // $vars.<step>.output[.<path>]  →  out('step'[, 'path'])
+    if ((m = body.match(new RegExp(`^\\$vars\\.([A-Za-z_]\\w*)\\.output(?:\\.(${PATH}))?$`)))) {
+        // A flow INPUT is published as the trigger's output, so
+        // `$vars.start.output.<declared input>` is what `input('<name>')` lowers to.
+        // Recover the author's spelling rather than the mechanical `out('start', …)`;
+        // both re-serialize identically, but only one reads like the source.
+        if (m[1] === currentTriggerId && m[2] !== undefined && inputNames.has(m[2])) {
+            return `${imp.use('input')}(${str(m[2])})`;
+        }
+        return m[2] === undefined ? `${imp.use('out')}(${str(m[1])})` : `${imp.use('out')}(${str(m[1])}, ${str(m[2])})`;
+    }
+    // $vars.<step>.error[.<field>]  →  err('step'[, 'field'])
+    if ((m = body.match(new RegExp(`^\\$vars\\.([A-Za-z_]\\w*)\\.error(?:\\.(${PATH}))?$`)))) {
+        return m[2] === undefined ? `${imp.use('err')}(${str(m[1])})` : `${imp.use('err')}(${str(m[1])}, ${str(m[2])})`;
+    }
+    // $vars.<name>  →  input('name') for a declared input, else v('name').
+    // The bare spelling predates flow inputs moving to `<trigger>.output.<name>`;
+    // still read it so an older artifact decompiles.
+    if ((m = body.match(/^\$vars\.([A-Za-z_]\w*)$/))) {
+        const name = m[1];
+        return inputNames.has(name) ? `${imp.use('input')}(${str(name)})` : `${imp.use('v')}(${str(name)})`;
+    }
+    // Composite / unrecognized: a raw JS expression template.
+    return `${imp.use('js')}${jsTemplate(body)}`;
+}
+/**
+ * Emit builder source for ANY input value — a node input, a `.return()` value, a
+ * connector field. Handles the three shapes a serialized value takes: an
+ * expression envelope (`{type,expression,fieldType}`), a plain/`=js:` string, or
+ * a raw JSON literal (number / boolean / null / array / object). A `=js:` value
+ * lowers to a reference helper; everything else is a literal (a plain string, or
+ * `lit(...)` for structured/typed literals). All three are accepted anywhere the
+ * builder takes `Expr | string | unknown` (bare values pass through `toExpr`).
+ */
+function emitVal(v, imp, inputNames) {
+    const raw = unwrapSource(v);
+    if (raw !== undefined && !Array.isArray(v)) {
+        if (raw.startsWith('=js:'))
+            return emitRef(raw.slice(4), imp, inputNames);
+        return str(raw); // a literal string (valid as Expr via toExpr, or as a raw string input)
+    }
+    // A raw JSON literal (number / boolean / null / array / object).
+    return literal(v);
+}
+/** A bare (unprefixed) JS expression, as decision/switch nodes store it. */
+function emitBareExpr(raw, imp, inputNames) {
+    return emitRef(raw, imp, inputNames);
+}
+/** Render an object literal `{ k: <src>, … }` from pre-rendered value sources; '' when empty. */
+function objLit(entries) {
+    if (entries.length === 0)
+        return '';
+    return `{ ${entries.map(([k, v]) => `${key(k)}: ${v}`).join(', ')} }`;
+}
+/** A map of `{name: value}` inputs (headers / query / connector fields) → object-literal source. */
+function emitValMap(m, imp, inputNames) {
+    if (!m || typeof m !== 'object')
+        return '';
+    return objLit(Object.entries(m).map(([k, v]) => [k, emitVal(v, imp, inputNames)]));
+}
+/**
+ * An agent's ARTIFACT handles. Edges leaving these carry no control flow — they
+ * attach a resource (a tool, a grounding index, an escalation, a memory) that
+ * takes no input, produces no output and never reaches End. Treating one as a
+ * successor reads the agent as an unstructured fan-out and drops everything
+ * after it, so they are excluded from the walk and recovered as arguments on
+ * the agent's own spec instead.
+ */
+const ARTIFACT_PORTS = new Set(['tool', 'context', 'escalation', 'memory']);
+// ─── Graph model ──────────────────────────────────────────────────────────────
+class Graph {
+    byId = new Map();
+    out = new Map();
+    inc = new Map();
+    constructor(nodes, edges) {
+        for (const n of nodes)
+            this.byId.set(n.id, n);
+        for (const e of edges) {
+            (this.out.get(e.sourceNodeId) ?? this.out.set(e.sourceNodeId, []).get(e.sourceNodeId)).push(e);
+            (this.inc.get(e.targetNodeId) ?? this.inc.set(e.targetNodeId, []).get(e.targetNodeId)).push(e);
+        }
+    }
+    outEdges(id) {
+        return this.out.get(id) ?? [];
+    }
+    inEdges(id) {
+        return this.inc.get(id) ?? [];
+    }
+    /**
+     * A per-outcome human task's PRIMARY exit — the one serialize continues the
+     * main path from (`outcome-<first outcome's id>`), so it is a successor while
+     * its siblings are side paths. `undefined` for every other node.
+     */
+    primaryOutcomePort(id) {
+        const n = this.byId.get(id);
+        const type = String(n?.type ?? '');
+        if (!type.startsWith('uipath.human-in-the-loop'))
+            return undefined;
+        const outcomes = (n?.inputs?.schema?.outcomes ?? []);
+        const first = outcomes[0]?.id;
+        return typeof first === 'string' && first !== '' ? `outcome-${first}` : undefined;
+    }
+    /**
+     * Out-edges excluding the side paths recovered as port lists: `error`,
+     * `branch-*`, and every `outcome-*` except the primary one.
+     */
+    successorEdges(id) {
+        const primary = this.primaryOutcomePort(id);
+        return this.outEdges(id).filter((e) => e.sourcePort !== 'error'
+            && !ARTIFACT_PORTS.has(e.sourcePort)
+            && !e.sourcePort.startsWith('branch-')
+            && (!e.sourcePort.startsWith('outcome-') || e.sourcePort === primary));
+    }
+}
+// ─── Node → step-spec source ──────────────────────────────────────────────────
+/**
+ * Emit the action-spec argument for a `.step(id, <spec>)` call — e.g.
+ * `script({ code: "…" })`. Returns `undefined` for a node that is not a plain
+ * action (control-flow / trigger / end), which the traversal handles specially.
+ */
+function emitStepSpec(node, imp, inputNames, o, graph) {
+    const inputs = node.inputs ?? {};
+    switch (node.type) {
+        case T.mock:
+            return `${imp.use('mock')}()`;
+        case T.script: {
+            const code = typeof inputs.script === 'string' ? inputs.script : '';
+            // `returns` is emitted only when the node's declared output type is
+            // something re-compiling the body would NOT produce on its own. Serialize
+            // infers from the body first (see `scriptOutputs`), so a script whose type
+            // is already plain in its code round-trips without it — emitting one there
+            // would add an argument the author never wrote to every such step.
+            return `${imp.use('script')}(${opts([['code', str(code)], ...scriptReturnsOpt(node, code)])})`;
+        }
+        case T.delay: {
+            // serialize's `delayInputs` writes `{timerType, timerPreset, timerValue?}`
+            // for a duration and `{timerType:'timeDate', timerDate}` for an absolute
+            // wait. Invert all three spellings.
+            if (inputs.timerType === 'timeDate') {
+                const until = typeof inputs.timerDate === 'string' ? inputs.timerDate : '';
+                return `${imp.use('delay')}(${opts([['until', str(until)]])})`;
+            }
+            const duration = inputs.timerPreset === 'custom'
+                ? (typeof inputs.timerValue === 'string' ? inputs.timerValue : '')
+                : (typeof inputs.timerPreset === 'string' ? inputs.timerPreset : '');
+            return `${imp.use('delay')}(${opts([['duration', str(duration)]])})`;
+        }
+        case T.documentClassify:
+        case T.dynamicExtract: {
+            const fr = unwrapSource(inputs.fileRef) ?? '';
+            const fileSrc = fr.startsWith('=js:') ? emitBareExpr(fr.slice(4), imp, inputNames) : str(fr);
+            const pageRange = typeof inputs.pageRange === 'string' && inputs.pageRange !== '' ? str(inputs.pageRange) : undefined;
+            if (node.type === T.documentClassify) {
+                const split = unwrapPlain(inputs.splitPages);
+                return `${imp.use('documentClassify')}(${opts([
+                    ['fileRef', fileSrc],
+                    ['pageRange', pageRange],
+                    ['splitPages', split === true ? 'true' : undefined],
+                ])})`;
+            }
+            const schema = inputs.schemaDocument !== undefined ? literal(inputs.schemaDocument) : undefined;
+            return `${imp.use('dynamicExtract')}(${opts([
+                ['fileRef', fileSrc],
+                ['schema', schema],
+                ['pageRange', pageRange],
+            ])})`;
+        }
+        case T.dataFabricRead:
+        case T.dataFabricUpdate: {
+            const cfg = (inputs.entityConfig ?? {});
+            const entity = str(String(cfg.entityName ?? ''));
+            const folder = typeof cfg._folderKey === 'string' ? str(cfg._folderKey) : undefined;
+            const val = (v) => {
+                const raw = typeof v === 'string' ? v : String(v ?? '');
+                return raw.startsWith('=js:') ? emitBareExpr(raw.slice(4), imp, inputNames) : str(raw);
+            };
+            if (node.type === T.dataFabricRead) {
+                const rows = Array.isArray(cfg._filters) ? cfg._filters : [];
+                const filterRow = (r) => opts([
+                    ['field', str(String(r.field ?? ''))],
+                    ['operator', r.operator !== '=' ? str(String(r.operator ?? '')) : undefined],
+                    ['value', val(r.value)],
+                    ['or', r['join'] === 'OR' ? 'true' : undefined],
+                ]);
+                const filters = rows.length ? `[${rows.map(filterRow).join(', ')}]` : undefined;
+                return `${imp.use('dataFabricRead')}(${opts([['entity', entity], ['filters', filters], ['folderKey', folder]])})`;
+            }
+            const record = cfg.recordSource === 'fromRead'
+                ? `{ fromRead: ${str(String(cfg.readEntityNodeId ?? ''))} }`
+                : `{ byId: ${val(cfg.recordId)} }`;
+            const updates = Array.isArray(cfg.fieldUpdates) ? cfg.fieldUpdates : [];
+            const set = `{ ${updates.map((u) => `${key(String(u.field ?? ''))}: ${val(u.value)}`).join(', ')} }`;
+            return `${imp.use('dataFabricUpdate')}(${opts([['entity', entity], ['record', record], ['set', set], ['folderKey', folder]])})`;
+        }
+        case T.createOutgoingCall:
+        case T.endCall: {
+            const i = (node.inputs ?? {});
+            const v = (x) => {
+                const raw = typeof x === 'string' ? x : String(x?.expression ?? x ?? '');
+                return raw.startsWith('=js:') ? emitBareExpr(raw.slice(4), imp, inputNames)
+                    : raw.startsWith('$vars.') ? emitBareExpr(raw, imp, inputNames)
+                        : str(raw);
+            };
+            if (node.type === T.createOutgoingCall) {
+                return `${imp.use('createOutgoingCall')}(${opts([['from', v(i.from)], ['to', v(i.to)]])})`;
+            }
+            return `${imp.use('endCall')}(${opts([['callContext', v(i.callContext)]])})`;
+        }
+        case T.inlineAgent:
+        case T.conversationalAgent:
+        case T.voiceAgent:
+            return emitAgentCluster(node, imp, inputNames, graph);
+        case T.hitl:
+        case T.hitlQuickForm:
+        case T.hitlActionApp:
+        case T.hitlDocValidation:
+            return emitHitl(node, imp, inputNames);
+        case T.queueCreate:
+        case T.queueCreateAndWait: {
+            // `itemData` is the node's name for the surface's `item` (the reference
+            // documents the mapping); `queue` carries the three identity fields.
+            const q = (inputs.queue ?? {});
+            const rows = Object.entries((inputs.itemData ?? {}))
+                .map(([k, v]) => [k, emitVal(v, imp, inputNames)]);
+            const optStr = (key) => {
+                const raw = unwrapSource(inputs[key]);
+                // serialize writes '' for an omitted optional — that is not an authored
+                // value, so it must not come back as one.
+                if (raw === undefined || raw === '')
+                    return undefined;
+                return raw.startsWith('=js:') ? emitBareExpr(raw.slice(4), imp, inputNames) : str(raw);
+            };
+            const priority = unwrapPlain(inputs.priority);
+            return `${imp.use('queueItem')}(${opts([
+                ['queue', str(String(q.name ?? ''))],
+                ['folderPath', str(String(q.folderPath ?? ''))],
+                ['key', str(String(q.key ?? ''))],
+                ['item', rows.length ? objLit(rows) : '{}'],
+                // `Normal` is the definition's default — only a departure was authored.
+                ['priority', typeof priority === 'string' && priority !== 'Normal' ? str(priority) : undefined],
+                ['reference', optStr('reference')],
+                ['deferDate', optStr('deferDate')],
+                ['dueDate', optStr('dueDate')],
+                ['wait', node.type === T.queueCreateAndWait ? 'true' : undefined],
+            ])})`;
+        }
+        case T.summarize:
+        case T.batchTransform: {
+            const attachment = emitVal(inputs.attachment, imp, inputNames);
+            const prompt = emitVal(inputs.prompt, imp, inputNames);
+            if (node.type === T.summarize) {
+                return `${imp.use('summarize')}(${opts([
+                    ['attachment', attachment],
+                    ['prompt', prompt],
+                    // Both flags default to false in the emitted node; only `true` was authored.
+                    ['returnCitations', unwrapPlain(inputs.returnCitations) === true ? 'true' : undefined],
+                ])})`;
+            }
+            const cols = Array.isArray(inputs.outputColumns) ? inputs.outputColumns : [];
+            const colSrc = `[${cols.map((c) => opts([
+                ['name', emitVal(c.name, imp, inputNames)],
+                ['description', emitVal(c.description, imp, inputNames)],
+            ])).join(', ')}]`;
+            return `${imp.use('batchTransform')}(${opts([
+                ['attachment', attachment],
+                ['prompt', prompt],
+                ['outputColumns', colSrc],
+                ['enableWebSearchGrounding', unwrapPlain(inputs.enableWebSearchGrounding) === true ? 'true' : undefined],
+            ])})`;
+        }
+        case T.sendMessage:
+        case T.waitForMessage:
+        case T.conversationContext: {
+            // The fixed enum fields (`role`/`mimeType`/`from`) come from the
+            // definition's defaults, so nothing of them is recovered — only what an
+            // author could have written.
+            const i = (node.inputs ?? {});
+            const v = (x) => {
+                const raw = typeof x === 'string' ? x : String(x?.expression ?? x ?? '');
+                return raw.startsWith('=js:') ? emitBareExpr(raw.slice(4), imp, inputNames)
+                    : raw.startsWith('$vars.') ? emitBareExpr(raw, imp, inputNames)
+                        : str(raw);
+            };
+            const num = (x) => {
+                if (x === undefined || x === null)
+                    return undefined;
+                const n = Number(x?.expression ?? x);
+                return Number.isFinite(n) ? String(n) : undefined;
+            };
+            const cid = ['conversationId', v(i.conversationId)];
+            if (node.type === T.sendMessage) {
+                return `${imp.use('sendMessage')}(${opts([
+                    cid,
+                    ['exchangeId', v(i.exchangeId)],
+                    ['content', v(i.content)],
+                    // The definition defaults `endExchange` to false; only a departure
+                    // from the default is something the author wrote.
+                    ['endExchange', i.endExchange === true ? 'true' : undefined],
+                ])})`;
+            }
+            if (node.type === T.waitForMessage) {
+                return `${imp.use('waitForMessage')}(${opts([
+                    cid,
+                    ['numExchanges', num(i.numExchanges) === '20' ? undefined : num(i.numExchanges)],
+                ])})`;
+            }
+            return `${imp.use('conversationContext')}(${opts([
+                cid,
+                ['exchangeLimit', num(i.exchangeLimit) === '20' ? undefined : num(i.exchangeLimit)],
+            ])})`;
+        }
+        case T.http:
+            return emitHttp(node, false, imp, inputNames);
+        case T.httpV2:
+            return emitHttp(node, true, imp, inputNames);
+        default:
+            if (node.type.startsWith('core.action.transform'))
+                return emitTransform(node, imp, inputNames);
+            // A connector action node: `uipath.connector.<key>.<action>` (but NOT the
+            // event nodes `uipath.connector.event.*` / `.trigger.*`, which are triggers).
+            if (node.type.startsWith('uipath.connector.') && !node.type.startsWith('uipath.connector.event.') && !node.type.startsWith('uipath.connector.trigger.')) {
+                return emitConnector(node, imp, inputNames, o);
+            }
+            {
+                const published = emitPublishedResource(node, imp, inputNames);
+                if (published !== undefined)
+                    return published;
+            }
+            // A mid-flow connector EVENT wait (`uipath.connector.event.<key>.<event>`
+            // placed as a step rather than as the start node).
+            if (node.type.startsWith('uipath.connector.event.')) {
+                const sub = emitEventSubscription(node, imp, inputNames);
+                if (sub !== undefined)
+                    return `${imp.use('waitForEvent')}(${sub})`;
+            }
+            // A published IxP extractor: `uipath.ixp.<slug>.<versionId>-<folderKey>`.
+            // The document-processing pair (`uipath.ixp.extract-document-builder`,
+            // `uipath.document.classify`) are their own families, handled above and
+            // excluded here by the parse — their tails are not the GUID pair.
+            if (node.type.startsWith('uipath.ixp.') && parseIxpProjectType(node.type) !== undefined) {
+                const i = (node.inputs ?? {});
+                const plain = (k) => {
+                    const v = unwrapSource(i[k]);
+                    return v === undefined || v === '' ? undefined : v;
+                };
+                const fr = unwrapSource(i.fileRef) ?? '';
+                // The DEPLOYMENT's display name is nested in `inputs.model`, not at the
+                // top of `inputs` — the two are different values (the model block's
+                // `modelDisplayName` is 'InvoiceIXP'; `modelName` is the slug), so
+                // reading the wrong one recovers the slug as the name.
+                const model = (i.model ?? {});
+                const nested = (k) => typeof model[k] === 'string' && model[k] !== '' ? model[k] : undefined;
+                return `${imp.use('ixpExtract')}(${opts([
+                    ['project', str(node.type)],
+                    // `modelName`/`projectName` are one value in two fields; either recovers it.
+                    ['modelName', str(plain('modelName') ?? plain('projectName') ?? nested('modelName') ?? '')],
+                    ['name', str(nested('modelDisplayName') ?? plain('modelName') ?? '')],
+                    ['folderName', str(plain('folderName') ?? nested('folderName') ?? '')],
+                    ['fileRef', fr.startsWith('=js:') ? emitBareExpr(fr.slice(4), imp, inputNames) : str(fr)],
+                    ['pageRange', plain('pageRange') !== undefined ? str(plain('pageRange')) : undefined],
+                    ['versionTag', plain('versionTag') !== undefined ? str(plain('versionTag')) : undefined],
+                    ['description', plain('description') ?? nested('description') !== undefined
+                            ? str((plain('description') ?? nested('description'))) : undefined],
+                ])})`;
+            }
+            // Every family this SDK AUTHORS is recovered above — a guard test asserts
+            // it (`flow-decompile-families.test.ts`). Reaching here means a node type
+            // the SDK cannot author: a hand-written file, a newer platform family, or
+            // a UI-only node (a sticky note). Best effort keeps the node as a
+            // placeholder so the graph shape and `merge` write-back still work.
+            return unsupportedSpec(node, imp, o);
+    }
+}
+/**
+ * The `returns` argument for a script step, or nothing.
+ *
+ * Recovers what the author declared by DIFFERENCE: the node says what its output
+ * is, `inferScriptShape` says what re-compiling the body would declare on its
+ * own, and only a gap between the two needs writing down. Fields are recovered
+ * the same way — a property map the body does not produce is one the author gave
+ * as `returns: {…}`.
+ */
+function scriptReturnsOpt(node, code) {
+    const out = node.outputs?.output;
+    const declared = typeof out?.type === 'string' ? out.type : undefined;
+    if (!declared)
+        return [];
+    const props = out?.properties;
+    // What re-compiling this body with NO `returns` would declare. Mirror
+    // `scriptOutputs` exactly: an inference of a bare `object` (or none at all)
+    // leaves the definition's own `{type:'object'}` standing, untouched.
+    const inferred = inferScriptShape(code);
+    const effective = inferred && !(inferred.type === 'object' && !inferred.properties)
+        ? inferred
+        : { type: 'object', properties: undefined };
+    const same = effective.type === declared
+        && JSON.stringify(sortKeys(effective.properties ?? {})) === JSON.stringify(sortKeys(props ?? {}));
+    if (same)
+        return [];
+    // Not what the body alone would say — so the author declared it, and it has to
+    // be written back or the round-trip loses it. That includes declaring the OPEN
+    // object over a body that looks typed, which is a real thing to want.
+    if (props && Object.keys(props).length > 0) {
+        // A field map is the richer statement, so it wins when there is one.
+        const entries = Object.entries(props)
+            .filter(([, v]) => typeof v?.type === 'string')
+            .map(([k, v]) => [k, str(v.type)]);
+        if (entries.length > 0)
+            return [['returns', opts(entries)]];
+    }
+    return [['returns', str(declared)]];
+}
+/** Key-sorted copy, so a property map compares by content and not by order. */
+function sortKeys(o) {
+    return Object.fromEntries(Object.entries(o).sort(([a], [b]) => a.localeCompare(b)));
+}
+/** A validated numeric literal — never emit a raw JSON value that could carry code. */
+function numLit(v) {
+    const n = Number(v);
+    if (!Number.isFinite(n))
+        throw new Error(`decompile: expected a number, got ${JSON.stringify(v)}.`);
+    return String(n);
+}
+/**
+ * Invert an HTTP node. The plain node (`core.action.http`) keeps its request at
+ * the top level (`url` / `method` / `headers` / `queryParams` / `body` /
+ * `contentType`); the managed node (`core.action.http.v2`) nests the request
+ * inside `detail.bodyParameters` and routes through IS. Request settings
+ * (`timeout` / `retryCount`) sit at the top level on both. Emitted only-when-off
+ * their definition defaults, exactly as serialize writes them, so the round-trip
+ * stays minimal. The response schema (`returns`) is a Phase-2 refinement.
+ */
+function emitHttp(node, managed, imp, inputNames) {
+    const inputs = node.inputs ?? {};
+    const detail = managed
+        ? (inputs.detail ?? {})
+        : {};
+    const req = managed
+        ? detail.bodyParameters ?? {}
+        : inputs;
+    const method = typeof req.method === 'string' ? req.method : 'GET';
+    const headers = managed ? req.headers : inputs.headers;
+    const query = managed ? req.query : inputs.queryParams;
+    const bodySrc = req.body !== undefined && req.body !== '' ? emitVal(req.body, imp, inputNames) : undefined;
+    const headersSrc = emitValMap(headers, imp, inputNames) || undefined;
+    const querySrc = emitValMap(query, imp, inputNames) || undefined;
+    const contentType = !managed && typeof inputs.contentType === 'string' && inputs.contentType !== 'application/json'
+        ? str(inputs.contentType) : undefined;
+    const timeout = typeof inputs.timeout === 'string' && inputs.timeout !== 'PT15M' ? str(inputs.timeout) : undefined;
+    const retry = inputs.retryCount !== undefined && Number(inputs.retryCount) !== 0 ? numLit(inputs.retryCount) : undefined;
+    const branchRows = Array.isArray(inputs.branches) ? inputs.branches : [];
+    const branchesSrc = branchRows.length
+        ? `[${branchRows.map((b) => {
+            const cond = unwrapSource(b.conditionExpression) ?? '';
+            const expr = emitBareExpr(cond.startsWith('=js:') ? cond.slice(4) : cond, imp, inputNames);
+            return `{ name: ${str(String(b.name ?? b.id ?? ''))}, condition: ${expr} }`;
+        }).join(', ')}]`
+        : undefined;
+    const connectionValue = detail.connectionId ?? detail.connectionResourceId ?? req.connection;
+    const connection = managed && typeof connectionValue === 'string' && connectionValue !== 'ImplicitConnection'
+        ? str(connectionValue) : undefined;
+    const folder = managed && typeof detail.connectionFolderKey === 'string' && detail.connectionFolderKey.length > 0
+        ? str(detail.connectionFolderKey) : undefined;
+    const targetConnector = managed && typeof req.targetConnector === 'string'
+        && req.targetConnector !== 'uipath-uipath-http'
+        ? str(req.targetConnector) : undefined;
+    const spec = opts([
+        ['url', emitVal(req.url ?? '', imp, inputNames)],
+        ['method', method !== 'GET' ? str(method) : undefined],
+        ['headers', headersSrc],
+        ['query', querySrc],
+        ['body', bodySrc],
+        ['contentType', contentType],
+        ['managed', boolLit(managed)],
+        ['connection', connection],
+        ['folder', folder],
+        ['targetConnector', targetConnector],
+        ['timeout', timeout],
+        ['retryCount', retry],
+        ['branches', branchesSrc],
+    ]);
+    return `${imp.use('http')}(${spec})`;
+}
+/**
+ * Invert a Transform node (generic `core.action.transform` or a `.map` / `.filter`
+ * / `.group-by` variant). The `collection` is a bare `$vars.…` path; each
+ * operation's serialized `{id,type,config}` becomes a builder operation object.
+ * (The variant node types carry a `groupBy` operation spelled with a hyphen in
+ * the type — `group-by` — but `groupBy` in the operation, the platform's own
+ * mismatch, mirrored here.)
+ */
+function emitTransform(node, imp, inputNames) {
+    const inputs = node.inputs ?? {};
+    const suffix = node.type.slice('core.action.transform'.length).replace(/^\./, '');
+    const variant = suffix || undefined; // 'map' | 'filter' | 'group-by' | undefined
+    const collRaw = unwrapSource(inputs.collection);
+    const collection = collRaw !== undefined
+        ? emitBareExpr(collRaw.startsWith('=js:') ? collRaw.slice(4) : collRaw, imp, inputNames)
+        : `${imp.use('lit')}([])`;
+    const ops = Array.isArray(inputs.operations) ? inputs.operations : [];
+    const opSrcs = ops.map((op) => {
+        const cfg = op?.config ?? {};
+        if (op?.type === 'filter') {
+            const filters = (cfg.filters ?? []).map((f) => objLit([
+                ['field', str(f.field)],
+                ['condition', str(f.condition)],
+                ...(f.value !== undefined ? [['value', literal(f.value)]] : []),
+            ]));
+            return objLit([
+                ['type', str('filter')],
+                ...(cfg.operation !== undefined ? [['operation', str(cfg.operation)]] : []),
+                ['filters', `[${filters.join(', ')}]`],
+            ]);
+        }
+        if (op?.type === 'map') {
+            const mappings = (cfg.mappings ?? []).map((m) => objLit([
+                ['field', str(m.field)],
+                ...(m.transformation && m.transformation !== 'copy' ? [['transformation', str(m.transformation)]] : []),
+                ...(m.renameTo ? [['renameTo', str(m.renameTo)]] : []),
+            ]));
+            return objLit([
+                ['type', str('map')],
+                ...(cfg.keepOriginalFields ? [['keepOriginalFields', boolLit(cfg.keepOriginalFields)]] : []),
+                ['mappings', `[${mappings.join(', ')}]`],
+            ]);
+        }
+        // groupBy
+        const aggs = (cfg.aggregations ?? []).map((a) => objLit([
+            ['operation', str(a.operation)],
+            ['alias', str(a.alias)],
+            ...(a.field ? [['field', str(a.field)]] : []),
+        ]));
+        return objLit([
+            ['type', str('groupBy')],
+            ['groupByField', str(cfg.groupByField)],
+            ['aggregations', `[${aggs.join(', ')}]`],
+        ]);
+    });
+    const spec = opts([
+        ['collection', collection],
+        ['variant', variant ? str(variant) : undefined],
+        ['operations', `[${opSrcs.join(', ')}]`],
+    ]);
+    return `${imp.use('transform')}(${spec})`;
+}
+/**
+ * Split a connector `nodeType` (`uipath.connector.<key>.<action>`) into key +
+ * action. Mirrors `core/connectors.ts`'s `splitConnectorNodeType`.
+ */
+function splitConnector(nodeType) {
+    const rest = nodeType.replace(/^uipath\.connector\./, '');
+    const dot = rest.lastIndexOf('.');
+    if (dot <= 0)
+        return undefined;
+    return { key: rest.slice(0, dot), action: rest.slice(dot + 1) };
+}
+/** Pull `objectName` out of a connector's `=jsonString:` configuration blob, if present. */
+function connectorObjectName(configuration) {
+    if (typeof configuration !== 'string' || !configuration.startsWith('=jsonString:'))
+        return undefined;
+    try {
+        const cfg = JSON.parse(configuration.slice('=jsonString:'.length));
+        const name = cfg?.instanceParameters?.objectName ?? cfg?.objectName;
+        return typeof name === 'string' ? name : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Invert a connector action node into a `connector(key, action, inputs, opts)`
+ * call. serialize routes author inputs into `detail.bodyParameters` /
+ * `queryParameters` / `pathParameters` or the `multipartParameters` list; the
+ * inverse merges values from those slots back into one flat inputs map —
+ * `buildConnectorInputs` re-routes them by field location on recompile. Static
+ * parts of `detail` (endpoint, configuration, telemetry) are regenerated from
+ * the library, so they are not carried through the code.
+ *
+ * NOTE: connector nodes need the connector library to (re)compile, which is not
+ * present in this checkout — it is baked into the e2e image — so this inversion
+ * is validated in-image, not by the local round-trip tests.
+ */
+/**
+ * The PUBLISHED-RESOURCE families: RPA workflow, API workflow, published
+ * function, and the three Agentic Process forms (bpmn / flow / case).
+ *
+ * All five node types are `<prefix><key>`, and all of them keep the author's
+ * identity where the instance cannot: `name` and `folderPath` live in the
+ * definition's `model.bindings.values`, and the declared `returns` in its
+ * `outputDefinition.output.schema`. So this reads the definition and inverts
+ * the one emit path they share (`serialize`'s four-family arm).
+ *
+ * Returns `undefined` when the node is not one of them, so the caller can fall
+ * through to the next arm.
+ */
+/**
+ * An AGENT and its attached resources — the inline autonomous agent, the
+ * conversational agent, and the voice agent.
+ *
+ * The cluster is a node plus artifact nodes on its `tool` / `context` /
+ * `escalation` / `memory` handles, so this walks those edges and recovers each
+ * resource as an argument rather than as a step (see {@link ARTIFACT_PORTS}).
+ *
+ * **The author's input NAMES are not recoverable, and that is by design.** The
+ * platform does not send an agent the names you declared: it keys each argument
+ * by the reference PATH, `__`-joined (`$vars.prep.output` → `prep__output`), and
+ * only those flat names survive in the emitted file. Recovery therefore uses
+ * them for both the `inputs` keys and the `{{input.…}}` placeholders — the same
+ * arguments reach the model, spelled the platform's way. (Node ids are
+ * preserved exactly; only these logical names change.)
+ */
+function emitAgentCluster(node, imp, inputNames, graph) {
+    const i = (node.inputs ?? {});
+    const plain = (v) => {
+        const raw = unwrapSource(v);
+        return raw === undefined || raw === '' ? undefined : raw;
+    };
+    const num = (v) => {
+        const raw = unwrapPlain(v);
+        return typeof raw === 'number' ? String(raw) : undefined;
+    };
+    // Prompts: invert `renderInlineAgentPrompt`. It replaced each
+    // `{{input.<name>}}` with that input's rendered binding, so the bindings in
+    // `agentInputVariables` are exactly what to put back — longest first, so a
+    // shorter binding cannot eat a longer one's prefix.
+    const vars = (Array.isArray(i.agentInputVariables) ? i.agentInputVariables : []);
+    const refs = vars
+        .filter((v) => typeof v.id === 'string' && typeof v.binding === 'string')
+        .map((v) => ({ flatName: v.id, binding: v.binding }))
+        .sort((a, b) => b.binding.length - a.binding.length);
+    const unrender = (text) => {
+        let out = text;
+        for (const r of refs)
+            out = out.split(r.binding).join(`{{input.${r.flatName}}}`);
+        return out;
+    };
+    const promptSrc = (v) => {
+        const raw = plain(v);
+        return raw === undefined ? undefined : str(unrender(raw));
+    };
+    const inputRows = refs
+        // Emit in the file's own order, not the length-sorted one.
+        .slice()
+        .sort((a, b) => vars.findIndex((v) => v.id === a.flatName) - vars.findIndex((v) => v.id === b.flatName))
+        .map((r) => {
+        const js = r.binding.startsWith('=js:') ? r.binding.slice(4) : r.binding;
+        return [r.flatName, emitBareExpr(js, imp, inputNames)];
+    });
+    const outVars = (Array.isArray(i.agentOutputVariables) ? i.agentOutputVariables : []);
+    const returns = outVars.length
+        ? objLit(outVars.map((v) => [String(v.id ?? ''), str(String(v.type ?? 'string'))]))
+        : undefined;
+    // The resources, from the agent's own artifact edges.
+    const resource = (port) => (graph?.outEdges(node.id) ?? [])
+        .filter((e) => e.sourcePort === port)
+        .map((e) => graph.byId.get(e.targetNodeId))
+        .filter((n) => n !== undefined);
+    const rInputs = (n) => (n.inputs ?? {});
+    const rPlain = (n, k) => {
+        const raw = unwrapSource(rInputs(n)[k]);
+        return raw === undefined || raw === '' ? undefined : raw;
+    };
+    const toolSrc = resource('tool').map((t) => {
+        const ti = rInputs(t);
+        const type = t.type;
+        if (type === 'uipath.agent.resource.tool.clientside') {
+            const schemaTypes = (v) => {
+                const props = v?.properties;
+                if (!props || Object.keys(props).length === 0)
+                    return undefined;
+                return objLit(Object.entries(props).map(([k, x]) => [k, str(String(x?.type ?? 'string'))]));
+            };
+            return opts([
+                ['kind', str('clientside')],
+                ['name', str(rPlain(t, 'name') ?? '')],
+                ['description', rPlain(t, 'description') !== undefined ? str(rPlain(t, 'description')) : undefined],
+                ['inputs', schemaTypes(ti.inputSchema)],
+                ['returns', schemaTypes(ti.outputSchema)],
+            ]);
+        }
+        if (type === 'uipath.agent.resource.tool.builtin.httprequest') {
+            // A field is authored only when it left prompt mode (text-builder).
+            const fixed = (k) => {
+                const row = ti[k];
+                if (!row || row.mode !== 'text-builder')
+                    return undefined;
+                const v = row.textValue;
+                return typeof v === 'number' ? String(v) : typeof v === 'string' ? str(v) : JSON.stringify(v);
+            };
+            return opts([
+                ['kind', str('httpRequest')],
+                ['url', fixed('url')], ['method', fixed('method')],
+                ['headers', fixed('headers')], ['params', fixed('params')],
+                ['body', fixed('body')], ['timeout', fixed('timeout')],
+            ]);
+        }
+        if (type.startsWith('uipath.agent.resource.tool.mcp.')) {
+            return opts([
+                ['kind', str('mcp')],
+                ['name', str(rPlain(t, 'name') ?? '')],
+                ['key', str(rPlain(t, 'referenceKey') ?? '')],
+                // The mapper's field name for the canonical server slug.
+                ['slug', rPlain(t, 'serverUrl') !== undefined ? str(rPlain(t, 'serverUrl')) : undefined],
+                ['folderPath', rPlain(t, 'folderPath') !== undefined ? str(rPlain(t, 'folderPath')) : undefined],
+                ['mcpType', rPlain(t, 'mcpType') !== undefined ? str(rPlain(t, 'mcpType')) : undefined],
+            ]);
+        }
+        if (type.startsWith('uipath.agent.resource.tool.a2a.')) {
+            return opts([
+                ['kind', str('a2a')],
+                ['name', str(rPlain(t, 'name') ?? '')],
+                ['key', str(rPlain(t, 'referenceKey') ?? '')],
+                ['slug', str(rPlain(t, 'slug') ?? '')],
+                ['folderPath', rPlain(t, 'folderPath') !== undefined ? str(rPlain(t, 'folderPath')) : undefined],
+            ]);
+        }
+        if (type.startsWith('uipath.agent.resource.tool.builtin.')) {
+            return opts([
+                ['kind', str('builtin')],
+                ['tool', str(type.slice('uipath.agent.resource.tool.builtin.'.length))],
+                ['description', rPlain(t, 'description') !== undefined ? str(rPlain(t, 'description')) : undefined],
+            ]);
+        }
+        if (type.startsWith('uipath.agent.resource.tool.ixp.')) {
+            const tail = type.slice('uipath.agent.resource.tool.ixp.'.length);
+            return opts([
+                ['kind', str('ixp')],
+                ['projectId', str(tail.slice(tail.indexOf('.') + 1))],
+                ['name', str(rPlain(t, 'name') ?? '')],
+            ]);
+        }
+        // The per-instance resource kinds (process / api / flow / maestro / agent /
+        // function): the key is the node type's tail, the rest is a binding pair.
+        const PROCESS_NS = [
+            ['uipath.agent.resource.tool.processorchestration.', 'maestro'],
+            ['uipath.agent.resource.tool.process.', 'process'],
+            ['uipath.agent.resource.tool.function.', 'function'],
+            ['uipath.agent.resource.tool.api.', 'api'],
+            ['uipath.agent.resource.tool.flow.', 'flow'],
+            ['uipath.agent.resource.tool.agent.', 'agent'],
+        ];
+        const ns = PROCESS_NS.find(([prefix]) => type.startsWith(prefix));
+        if (ns) {
+            const def = runDefs.get(`${type}@${t.typeVersion}`) ?? runDefs.get(type);
+            const values = (def?.model?.bindings?.values ?? []);
+            const bound = (n) => {
+                const row = values.find((v) => v.name === n);
+                return typeof row?.default === 'string' ? row.default : undefined;
+            };
+            return opts([
+                ['kind', str(ns[1])],
+                ['key', str(type.slice(ns[0].length))],
+                ['name', str(bound('name') ?? rPlain(t, 'name') ?? '')],
+                ['folderPath', str(bound('folderPath') ?? '')],
+            ]);
+        }
+        return opts([['kind', str('builtin')], ['tool', str('summarize')]]); // unreachable in practice
+    });
+    const contextSrc = resource('context').map((c) => {
+        // `query` is a MODE TRIPLE, not a string: the author's value lands in
+        // `promptValue` (prompt mode) or `textValue` (text-builder). Reading the
+        // field itself finds an object and silently recovers nothing.
+        const q = rInputs(c).query;
+        const queryText = typeof q?.promptValue === 'string' && q.promptValue !== '' ? q.promptValue
+            : typeof q?.textValue === 'string' && q.textValue !== '' ? q.textValue
+                : typeof q === 'string' && q !== '' ? q
+                    : undefined;
+        return opts([
+            ['name', str(rPlain(c, 'indexName') ?? String(c.display?.label ?? ''))],
+            ['id', str(rPlain(c, 'indexId') ?? '')],
+            ['folderPath', rPlain(c, 'folderPath') !== undefined ? str(rPlain(c, 'folderPath')) : undefined],
+            ['folderKey', rPlain(c, 'folderKey') !== undefined ? str(rPlain(c, 'folderKey')) : undefined],
+            ['query', queryText !== undefined ? str(queryText) : undefined],
+        ]);
+    });
+    const escalationSrc = resource('escalation').map((e) => {
+        const ei = rInputs(e);
+        const recipients = Array.isArray(ei.recipients)
+            ? ei.recipients.map((r) => str(String(r.value ?? '')))
+            : [];
+        const outcomeNames = Object.keys((ei.outcomeMapping ?? {}));
+        const isQuickForm = e.type === 'uipath.agent.resource.escalation.quick-form';
+        const rows = isQuickForm
+            ? (ei.schema?.fields ?? [])
+            : [];
+        const app = ei.app;
+        const extra = (ei._additionalProps ?? {});
+        return opts([
+            ['variant', isQuickForm ? str('quick-form') : undefined],
+            ['name', str(rPlain(e, 'name') ?? '')],
+            ['description', rPlain(e, 'description') !== undefined ? str(rPlain(e, 'description')) : undefined],
+            ['fields', rows.length ? `[${rows.map((f) => opts([
+                    ['id', str(String(f.id ?? ''))],
+                    ['type', str(String(f.type ?? 'text'))],
+                    ['direction', str(String(f.direction ?? 'output'))],
+                ])).join(', ')}]` : undefined],
+            ['app', app === undefined ? undefined : opts([
+                    ['key', str(String(app.key ?? ''))],
+                    ['name', str(String(app.name ?? ''))],
+                    ['folderPath', typeof app.folderPath === 'string' && app.folderPath !== '' ? str(app.folderPath) : undefined],
+                ])],
+            ['recipients', recipients.length ? `[${recipients.join(', ')}]` : undefined],
+            ['outcomes', outcomeNames.length ? `[${outcomeNames.map((o) => str(o)).join(', ')}]` : undefined],
+            ['taskTitle', typeof extra.taskTitle === 'string' && extra.taskTitle !== '' ? str(extra.taskTitle) : undefined],
+            // 'medium' is the platform default.
+            ['priority', typeof extra.priority === 'string' && extra.priority !== 'medium' ? str(extra.priority) : undefined],
+        ]);
+    });
+    const mem = resource('memory')[0];
+    const memorySrc = mem === undefined ? undefined : (() => {
+        // The memory's id is the node type's tail; the def carries it too.
+        const tail = mem.type.slice('uipath.agent.resource.memory.'.length);
+        const id = tail.slice(tail.indexOf('.') + 1);
+        const mi = rInputs(mem);
+        return opts([
+            ['name', str(rPlain(mem, 'name') ?? '')],
+            ['id', str(id)],
+            ['description', rPlain(mem, 'description') !== undefined ? str(rPlain(mem, 'description')) : undefined],
+            // The platform defaults: few-shot on, similarity 0, k 3, hybrid search.
+            ['dynamicFewShotLearning', unwrapPlain(mi.dynamicFewShotLearning) === false ? 'false' : undefined],
+            ['semanticSimilarity', num(mi.semanticSimilarity) !== undefined && num(mi.semanticSimilarity) !== '0' ? num(mi.semanticSimilarity) : undefined],
+            ['kValue', num(mi.kValue) !== undefined && num(mi.kValue) !== '3' ? num(mi.kValue) : undefined],
+            ['searchMode', rPlain(mem, 'searchMode') !== undefined && rPlain(mem, 'searchMode') !== 'hybrid'
+                    ? str(rPlain(mem, 'searchMode')) : undefined],
+        ]);
+    })();
+    const guardrails = Array.isArray(i.guardrails) && i.guardrails.length > 0
+        ? JSON.stringify(i.guardrails)
+        : undefined;
+    const list = (items) => (items.length ? `[${items.join(', ')}]` : undefined);
+    if (node.type === T.voiceAgent) {
+        const v = (i.voice ?? {});
+        const voiceSrc = Object.keys(v).length === 0 ? undefined : opts([
+            ['model', typeof v.model === 'string' ? str(v.model) : undefined],
+            ['persona', typeof v.persona === 'string' ? str(v.persona) : undefined],
+            ['temperature', num(v.temperature)],
+            ['maxTokens', num(v.maxTokens)],
+        ]);
+        return `${imp.use('voiceAgent')}(${opts([
+            ['systemPrompt', promptSrc(i.systemPrompt) ?? str('')],
+            ['inputs', inputRows.length ? objLit(inputRows) : undefined],
+            ['callContext', (() => {
+                    const raw = plain(i.callContext) ?? '';
+                    const js = raw.startsWith('=js:') ? raw.slice(4) : raw;
+                    return js.startsWith('$vars.') ? emitBareExpr(js, imp, inputNames) : str(js);
+                })()],
+            ['voice', voiceSrc],
+            ['maxIterations', num(i.maxIterations)],
+            ['source', str(plain(i.source) ?? '')],
+        ])})`;
+    }
+    if (node.type === T.conversationalAgent) {
+        const st = (i.conversationalAgentSettings ?? {});
+        const settingExpr = (k) => {
+            const raw = typeof st[k] === 'string' ? st[k] : undefined;
+            if (raw === undefined || raw === '')
+                return undefined;
+            const js = raw.startsWith('=js:') ? raw.slice(4) : raw;
+            return js.startsWith('$vars.') ? emitBareExpr(js, imp, inputNames) : str(js);
+        };
+        // `'simple'` mode DERIVES the four runtime fields from `context`, so only
+        // the context binding is the author's; recovering the derived ones would
+        // re-emit them as hand-bound custom fields.
+        const mode = typeof st.mode === 'string' ? st.mode : 'simple';
+        const settingsSrc = mode === 'custom'
+            ? opts([
+                ['mode', str('custom')],
+                ['conversationId', settingExpr('conversationId')],
+                ['exchangeId', settingExpr('exchangeId')],
+                ['messages', settingExpr('messages')],
+                ['userSettings', settingExpr('userSettings')],
+            ])
+            : opts([['context', settingExpr('context')]]);
+        return `${imp.use('conversationalAgent')}(${opts([
+            ['model', str(plain(i.model) ?? '')],
+            ['systemPrompt', promptSrc(i.systemPrompt) ?? str('')],
+            ['settings', settingsSrc],
+            ['endExchange', unwrapPlain(i.endExchange) === false ? 'false' : undefined],
+            ['temperature', num(i.temperature)],
+            ['maxTokenPerResponse', num(i.maxTokenPerResponse)],
+            ['modelMaxTokens', num(i.modelMaxTokens)],
+            ['maxIterations', num(i.maxIterations)],
+            ['guardrails', guardrails],
+            ['source', str(plain(i.source) ?? '')],
+        ])})`;
+    }
+    return `${imp.use('inlineAgent')}(${opts([
+        ['model', str(plain(i.model) ?? '')],
+        ['systemPrompt', promptSrc(i.systemPrompt) ?? str('')],
+        ['userPrompt', promptSrc(i.userPrompt) ?? str('')],
+        ['inputs', inputRows.length ? objLit(inputRows) : undefined],
+        ['returns', returns],
+        ['temperature', num(i.temperature)],
+        ['maxTokenPerResponse', num(i.maxTokenPerResponse)],
+        ['modelMaxTokens', num(i.modelMaxTokens)],
+        ['maxIterations', num(i.maxIterations)],
+        ['mode', plain(i.mode) !== undefined ? str(plain(i.mode)) : undefined],
+        ['guardrails', guardrails],
+        ['context', list(contextSrc)],
+        ['tools', list(toolSrc)],
+        ['escalation', list(escalationSrc)],
+        ['memory', memorySrc],
+        // The agent's directory uuid is derived from the flow and step ids, but a
+        // decompiled flow must keep the ORIGINAL — the sidecar lives at
+        // `<source>/agent.json`, so a re-derived one would point at nothing.
+        ['source', str(plain(i.source) ?? '')],
+    ])})`;
+}
+/**
+ * A HUMAN TASK — the base node plus its three sub-typed variants.
+ *
+ * `hitlInputs` is the widest lowering in the serializer, so this inverts it
+ * field by field. Three of its outputs are DERIVED and deliberately not
+ * recovered: `schema.schemaId` (a stable hash of the flow and node ids),
+ * `type: 'quick'` (the base node's discriminator), and the `variable`/`binding`
+ * wiring each field row carries — all of them are re-emitted from what comes
+ * back here.
+ *
+ * A value equal to what serialize would have DEFAULTED is omitted rather than
+ * recovered: the step's own name for `title`, `'Low'` for `priority`, and the
+ * definition's own `inputDefaults.recipient` for delivery. Recovering those
+ * would add arguments the author never wrote to every task.
+ */
+function emitHitl(node, imp, inputNames) {
+    const i = (node.inputs ?? {});
+    const schema = (i.schema ?? {});
+    const plain = (v) => {
+        const raw = unwrapSource(v);
+        return raw === undefined || raw === '' ? undefined : raw;
+    };
+    const variant = node.type === T.hitlQuickForm ? 'quick-form'
+        : node.type === T.hitlActionApp ? 'action-app'
+            : node.type === T.hitlDocValidation ? 'document-validation'
+                : undefined;
+    // A field row's binding is a variable PATH (`vars.x`), not an expression —
+    // serialize rewrote the author's `$vars.x` on the way out, so put it back.
+    const bindingExpr = (v) => {
+        const raw = plain(v);
+        if (raw === undefined)
+            return undefined;
+        const js = raw.startsWith('=js:') ? raw.slice(4) : raw;
+        return emitBareExpr(js.startsWith('vars.') ? `$${js}` : js, imp, inputNames);
+    };
+    const rows = (Array.isArray(schema.fields) ? schema.fields : []);
+    const fields = rows.map((f) => {
+        const id = String(f.id ?? '');
+        const direction = String(f.direction ?? 'output');
+        return opts([
+            ['id', str(id)],
+            // serialize defaults a row's label to its id.
+            ['label', typeof f.label === 'string' && f.label !== id ? str(f.label) : undefined],
+            ['type', str(String(f.type ?? 'text'))],
+            ['direction', str(direction)],
+            ['value', direction === 'input' || direction === 'inOut' ? bindingExpr(f.binding) : undefined],
+            ['required', f.required === true ? 'true' : undefined],
+        ]);
+    });
+    const outcomeRows = (Array.isArray(schema.outcomes) ? schema.outcomes : []);
+    const outcomes = outcomeRows.map((o) => {
+        const name = String(o.name ?? '');
+        // A bare string is the shorthand; only `action: 'End'` needs the object.
+        return o.action === 'End' ? opts([['name', str(name)], ['action', str('End')]]) : str(name);
+    });
+    // Delivery: only an override comes back. The definition's own default is what
+    // serialize emits when the author wrote nothing.
+    const def = runDefs.get(`${node.type}@${node.typeVersion}`) ?? runDefs.get(node.type);
+    const defaultRecipient = JSON.stringify(def?.inputDefaults?.recipient ?? null);
+    const rec = i.recipient;
+    let recipientSrc;
+    if (rec !== undefined && JSON.stringify(rec) !== defaultRecipient) {
+        const assignee = (rec.assignee ?? {});
+        const channels = Array.isArray(rec.channels) ? rec.channels : undefined;
+        recipientSrc = opts([
+            ['channels', channels ? `[${channels.map((c) => str(c)).join(', ')}]` : undefined],
+            ['assignee', opts([
+                    ['type', str(String(assignee.type ?? 'user'))],
+                    ['value', typeof assignee.value === 'string' ? str(assignee.value) : undefined],
+                    ['displayName', typeof assignee.displayName === 'string' ? str(assignee.displayName) : undefined],
+                ])],
+        ]);
+    }
+    // The deployed app that owns the form (action-app, and a custom-render
+    // validation station). `appInputBindings` maps the app's own parameter names
+    // to `=`-prefixed expressions.
+    const app = i.app;
+    // `app.inputs` is a VALUE map — what to send the app, keyed by the app's own
+    // parameter names — and it lowers to a SIBLING key, `appInputBindings`, whose
+    // values are `=vars.…` paths (or literals). Not a type map, and not inside
+    // `app`: both are easy to assume and both round-trip wrong.
+    const bindings = (i.appInputBindings ?? {});
+    const appInputs = Object.keys(bindings).length === 0 ? undefined : objLit(Object.entries(bindings).map(([k, v]) => {
+        const raw = String(v ?? '');
+        return [k, raw.startsWith('=') ? emitBareExpr(`$${raw.slice(1)}`, imp, inputNames) : str(raw)];
+    }));
+    const appSrc = app === undefined ? undefined : opts([
+        // `displayName` is serialize's echo of `name`; only `name` is authored.
+        ['name', str(String(app.name ?? ''))],
+        ['key', str(String(app.key ?? ''))],
+        ['folderPath', typeof app.folderPath === 'string' && app.folderPath !== '' ? str(app.folderPath) : undefined],
+        ['appSystemName', app.appSystemName === null ? 'null'
+                : typeof app.appSystemName === 'string' ? str(app.appSystemName) : undefined],
+        ['inputs', appInputs],
+    ]);
+    // The validation station's own inputs ride as PLAIN `$vars.…` paths.
+    const stationExpr = (v) => {
+        const raw = plain(v);
+        if (raw === undefined)
+            return undefined;
+        const js = raw.startsWith('=js:') ? raw.slice(4) : raw;
+        return js.startsWith('$vars.') ? emitBareExpr(js, imp, inputNames) : str(js);
+    };
+    const render = plain(i.validationRenderType);
+    const documentSrc = node.type !== T.hitlDocValidation ? undefined : opts([
+        ['extractionResult', stationExpr(i.extractionResult) ?? str('')],
+        ['storageBucket', plain(i.storageBucket) !== undefined ? str(plain(i.storageBucket)) : undefined],
+        ['documentId', plain(i.documentId) !== undefined ? str(plain(i.documentId)) : undefined],
+        // 'standard' is the definition's default.
+        ['render', render !== undefined && render !== 'standard' ? str(render) : undefined],
+        ['taxonomy', stationExpr(i.taxonomy)],
+    ]);
+    // Per-outcome exits and the error output are VERSION-selected: 1.1 routes per
+    // outcome, 1.2 adds the error output (and implies the routing).
+    const version = String(node.typeVersion ?? '');
+    const exposeError = version === '1.2';
+    const outcomePorts = version === '1.1';
+    const title = plain(i.title);
+    const priority = plain(i.priority);
+    return `${imp.use('hitl')}(${opts([
+        ['variant', variant !== undefined ? str(variant) : undefined],
+        // serialize defaults the title to the step's own name.
+        ['title', title !== undefined && title !== node.id ? str(title) : undefined],
+        ['priority', priority !== undefined && priority !== 'Low' ? str(priority) : undefined],
+        ['labels', plain(i.labels) !== undefined ? str(plain(i.labels)) : undefined],
+        ['recipient', recipientSrc],
+        ['app', appSrc],
+        ['document', documentSrc],
+        // An app task and a validation station own no inline form; an empty array
+        // there is serialize's own, not the author's.
+        ['fields', fields.length ? `[${fields.join(', ')}]`
+                : (variant === 'action-app' || variant === 'document-validation') ? undefined : '[]'],
+        ['outcomes', `[${outcomes.join(', ')}]`],
+        ['outcomePorts', outcomePorts ? 'true' : undefined],
+        ['exposeError', exposeError ? 'true' : undefined],
+    ])})`;
+}
+/**
+ * A connector EVENT subscription, shared by the trigger (`onEvent`) and the
+ * mid-flow wait (`waitForEvent`) — the same node body in both places, so the
+ * same inversion serves both.
+ *
+ * The `where` scope comes back from `detail.eventParameters`, which carries it
+ * verbatim; the `contains` filters from the filter tree inside
+ * `detail.configuration`. Both are also encoded into the generated
+ * `filterExpression` string, but reading the structured copies avoids parsing a
+ * string this file generated.
+ */
+function emitEventSubscription(node, imp, inputNames) {
+    const prefix = node.type.startsWith('uipath.connector.event.') ? 'uipath.connector.event.'
+        : node.type.startsWith('uipath.connector.trigger.') ? 'uipath.connector.trigger.'
+            : undefined;
+    if (prefix === undefined)
+        return undefined;
+    const rest = node.type.slice(prefix.length);
+    const dot = rest.lastIndexOf('.');
+    if (dot <= 0)
+        return undefined;
+    const connector = rest.slice(0, dot);
+    const event = rest.slice(dot + 1);
+    const detail = (node.inputs ?? {}).detail;
+    const where = (detail?.eventParameters ?? {});
+    const whereRows = Object.entries(where)
+        .filter(([, v]) => v !== undefined && v !== null && String(v) !== '')
+        .map(([k, v]) => [k, emitVal(v, imp, inputNames)]);
+    // The filter tree lives inside the `=jsonString:` configuration blob, and so
+    // does the one fact that says whether `detail.objectName` was the AUTHOR's
+    // choice: a GENERIC event (`activityType: GenericTrigger`) carries the object
+    // the author named, a curated one carries its built-in object.
+    let filterRows = [];
+    let generic = false;
+    const config = detail?.configuration;
+    if (typeof config === 'string' && config.startsWith('=jsonString:')) {
+        try {
+            const parsed = JSON.parse(config.slice('=jsonString:'.length));
+            generic = parsed?.essentialConfiguration?.instanceParameters?.activityType === 'GenericTrigger';
+            const tree = parsed?.essentialConfiguration?.filter;
+            const rows = (tree?.filters ?? []);
+            filterRows = rows
+                .map((f) => eventFilterFromTreeLeaf(f))
+                .filter((f) => f !== undefined)
+                .map((f) => opts([
+                ['field', str(f.field)],
+                [f.operator, typeof f.value === 'string' ? str(f.value) : JSON.stringify(f.value)],
+            ]));
+        }
+        catch {
+            // A hand-edited blob is not ours to guess at — the scope and identity
+            // still recover, and the filters simply do not come back.
+            filterRows = [];
+        }
+    }
+    const object = generic && typeof detail?.objectName === 'string' && detail.objectName !== ''
+        ? detail.objectName
+        : undefined;
+    const conn = typeof detail?.connectionId === 'string' ? detail.connectionId : undefined;
+    const folder = typeof detail?.connectionFolderKey === 'string' ? detail.connectionFolderKey : undefined;
+    return opts([
+        ['connector', str(connector)],
+        ['event', str(event)],
+        ['where', whereRows.length ? objLit(whereRows) : undefined],
+        ['object', object !== undefined ? str(object) : undefined],
+        ['filters', filterRows.length ? `[${filterRows.join(', ')}]` : undefined],
+        ['connection', conn !== undefined ? str(conn) : undefined],
+        ['folder', folder !== undefined ? str(folder) : undefined],
+    ]);
+}
+function emitPublishedResource(node, imp, inputNames) {
+    const FAMILIES = [
+        { prefix: 'uipath.core.rpa-workflow.', factory: 'rpaWorkflow' },
+        { prefix: 'uipath.core.api-workflow.', factory: 'apiWorkflow' },
+        { prefix: 'uipath.core.function.', factory: 'publishedFunction' },
+        // The published AGENT resource — same shape as its siblings (identity in
+        // the definition's binding pair, contract in its output schema).
+        { prefix: 'uipath.core.agent.', factory: 'agent' },
+        // The Agentic Process umbrella: one factory, three wire identities. `bpmn`
+        // is the default form, so only the other two name it.
+        { prefix: 'uipath.core.agentic-process.', factory: 'agenticProcess' },
+        { prefix: 'uipath.core.flow.', factory: 'agenticProcess', form: 'flow' },
+        { prefix: 'uipath.core.case-management.', factory: 'agenticProcess', form: 'case' },
+    ];
+    const family = FAMILIES.find((f) => node.type.startsWith(f.prefix));
+    if (!family)
+        return undefined;
+    const key = node.type.slice(family.prefix.length);
+    const def = runDefs.get(`${node.type}@${node.typeVersion}`) ?? runDefs.get(node.type);
+    const values = (def?.model?.bindings?.values ?? []);
+    const binding = (name) => {
+        const row = values.find((v) => v.name === name);
+        return typeof row?.default === 'string' ? row.default : undefined;
+    };
+    // The binding pair is the identity the runtime resolves by; without a
+    // definition to read there is nothing to recover it from.
+    const name = binding('name');
+    const folderPath = binding('folderPath');
+    const inputs = { ...(node.inputs ?? {}) };
+    // The design-time fire-and-forget switch is an OPTION on the factory, not a
+    // process argument — serialize adds it to `inputs` after rendering the
+    // author's map, so it comes back off here.
+    const fireAndForget = unwrapPlain(inputs.fireAndForget) === true;
+    delete inputs.fireAndForget;
+    const inputRows = Object.entries(inputs)
+        .map(([k, v]) => [k, emitVal(v, imp, inputNames)]);
+    const schema = def?.outputDefinition?.output?.schema?.properties;
+    const returns = schema && Object.keys(schema).length > 0
+        ? objLit(Object.entries(schema).map(([k, v]) => [k, str(String(v?.type ?? 'string'))]))
+        : undefined;
+    return `${imp.use(family.factory)}(${opts([
+        ['key', str(key)],
+        ['name', name !== undefined ? str(name) : undefined],
+        ['folderPath', folderPath !== undefined ? str(folderPath) : undefined],
+        ['inputs', inputRows.length ? objLit(inputRows) : undefined],
+        ['returns', returns],
+        ['form', family.form !== undefined ? str(family.form) : undefined],
+        ['completion', fireAndForget ? str('fire-and-forget') : undefined],
+    ])})`;
+}
+function emitConnector(node, imp, inputNames, o) {
+    const split = splitConnector(node.type);
+    const detail = (node.inputs?.detail ?? {});
+    if (!split)
+        return unsupportedSpec(node, imp, o);
+    const slots = ['bodyParameters', 'queryParameters', 'pathParameters'];
+    const flat = [];
+    for (const s of slots) {
+        const m = detail[s];
+        if (m && typeof m === 'object' && !Array.isArray(m)) {
+            for (const [k, v] of Object.entries(m))
+                flat.push([k, emitVal(v, imp, inputNames)]);
+        }
+    }
+    const multipart = detail.multipartParameters;
+    if (Array.isArray(multipart)) {
+        for (const part of multipart) {
+            if (typeof part?.name === 'string' && Object.prototype.hasOwnProperty.call(part, 'value')) {
+                flat.push([part.name, emitVal(part.value, imp, inputNames)]);
+            }
+        }
+    }
+    const connection = typeof detail.connectionId === 'string' ? detail.connectionId : undefined;
+    const folder = typeof detail.connectionFolderKey === 'string' ? detail.connectionFolderKey : undefined;
+    const object = connectorObjectName(detail.configuration);
+    const optsSrc = opts([
+        ['connection', connection !== undefined ? str(connection) : undefined],
+        ['folder', folder !== undefined ? str(folder) : undefined],
+        ['object', object !== undefined ? str(object) : undefined],
+    ]);
+    const inputsSrc = objLit(flat) || '{}';
+    const args = [str(split.key), str(split.action), inputsSrc, ...(optsSrc ? [optsSrc] : [])];
+    return `${imp.use('connector')}(${args.join(', ')})`;
+}
+/** Best-effort placeholder for a node type the reverse-map does not yet cover. */
+function unsupportedSpec(node, imp, o) {
+    // The file's own definition for this node — the manifest the platform served.
+    const def = runDefs.get(`${node.type}@${node.typeVersion}`) ?? runDefs.get(node.type);
+    if (def !== undefined) {
+        // A node type this SDK has no factory for is still expressible: `rawNode`
+        // carries the definition verbatim, so the node keeps its TYPE, its VERSION
+        // and its inputs through a round trip. `mock()` was the old fallback and it
+        // LOST the type — it compiles to `core.logic.mock`, which only looked
+        // harmless because `merge` restored the original node afterwards. Reserve
+        // `mock()` for a flow that genuinely contains one.
+        const constName = `${camel(node.id)}Definition`;
+        if (!runRawManifests.some(([n]) => n === constName)) {
+            runRawManifests.push([constName, JSON.stringify(def, null, 2)]);
+        }
+        const inputs = node.inputs ?? {};
+        const inputsSrc = Object.keys(inputs).length > 0 ? JSON.stringify(inputs, null, 2) : undefined;
+        return `${imp.use('rawNode')}(${opts([
+            ['nodeType', str(node.type)],
+            ['version', str(String(node.typeVersion ?? ''))],
+            ['manifest', constName],
+            ['inputs', inputsSrc],
+        ])})`;
+    }
+    if (o.bestEffort === false) {
+        throw new Error(`decompile: unsupported node type "${node.type}" (node "${node.id}") and the file carries no `
+            + `definitions[] entry for it, so it cannot be expressed as a rawNode either.`);
+    }
+    // No definition to carry: a mock publishes nothing and takes no inputs, so it
+    // is a safe structural stand-in, and the marker records what it replaced.
+    return `${imp.use('mock')}() /* TODO: unsupported node type ${node.type} */`;
+}
+/** `some-node.id` → `someNodeId`, for a hoisted const name. */
+function camel(id) {
+    const parts = String(id).split(/[^A-Za-z0-9]+/).filter(Boolean);
+    if (parts.length === 0)
+        return 'node';
+    const [first, ...rest] = parts;
+    const head = /^[0-9]/.test(first) ? `n${first}` : first;
+    return head.charAt(0).toLowerCase() + head.slice(1) + rest.map((r) => r.charAt(0).toUpperCase() + r.slice(1)).join('');
+}
+// ─── Variables ────────────────────────────────────────────────────────────────
+const TYPE_NAMES = new Set([
+    'string', 'number', 'boolean', 'object', 'array', 'file', 'any',
+    'integer', 'float', 'double', 'date', 'datetime',
+]);
+/** `types.<name>` when the type is a known descriptor, else a defensive string literal. */
+function typeExpr(type, imp) {
+    if (TYPE_NAMES.has(type))
+        return `${imp.use('types')}.${type}`;
+    return str(type);
+}
+/**
+ * A global carrying metadata decompiles to the rich VarSpec spelling
+ * (`{ type: types.x, description, subType, schema }`); a bare one keeps the
+ * compact `name: types.x` form.
+ */
+function declExpr(g, withDefault, imp) {
+    const meta = [];
+    if (withDefault && g.defaultValue !== undefined)
+        meta.push(`default: ${literal(g.defaultValue)}`);
+    if (g.description !== undefined)
+        meta.push(`description: ${str(g.description)}`);
+    if (g.subType !== undefined)
+        meta.push(`subType: ${str(g.subType)}`);
+    if (g.schema !== undefined)
+        meta.push(`schema: ${literal(g.schema)}`);
+    if (meta.length === 0)
+        return typeExpr(g.type, imp);
+    return `{ type: ${typeExpr(g.type, imp)}, ${meta.join(', ')} }`;
+}
+function emitVariables(e, depth, flow, imp) {
+    const globals = readFlowGlobals(flow.variables, runStrict);
+    const inputs = globals.filter((g) => g.direction === 'in');
+    const outputs = globals.filter((g) => g.direction === 'out');
+    const inouts = globals.filter((g) => g.direction === 'inout');
+    const shape = (list, withDefault) => `{ ${list.map((g) => `${key(g.name ?? g.id)}: ${declExpr(g, withDefault, imp)}`).join(', ')} }`;
+    if (inputs.length)
+        e.line(depth, `.input(${shape(inputs, true)})`);
+    if (outputs.length)
+        e.line(depth, `.output(${shape(outputs, false)})`);
+    for (const g of inouts) {
+        const rich = declExpr(g, false, imp);
+        const def = g.defaultValue !== undefined ? `, ${literal(g.defaultValue)}` : '';
+        e.line(depth, `.var(${str(g.name ?? g.id)}, ${rich}${def})`);
+    }
+}
+// ─── Trigger ──────────────────────────────────────────────────────────────────
+function emitTrigger(e, depth, trigger, imp, o, inputNames = new Set()) {
+    // The trigger's id is addressable — a flow's inputs are published as its
+    // output — so a renamed one has to survive the round trip. `start` is the
+    // default and stays implicit.
+    if (trigger.id && trigger.id !== DEFAULT_TRIGGER_ID)
+        e.line(depth, `.triggerId(${str(trigger.id)})`);
+    if (trigger.type === T.triggerManual) {
+        // The default trigger, spelled out: decompiled source is deliberately more
+        // explicit than hand-authored source so the node's exact definition version
+        // survives recompilation (design §5.3).
+        e.line(depth, `.trigger(${imp.use('manual')}()${verArg(trigger)})`);
+        return;
+    }
+    if (trigger.type === T.triggerScheduled) {
+        e.line(depth, `.trigger(${imp.use('scheduled')}(${opts([['every', str(scheduleEvery(trigger))]])})${verArg(trigger)})`);
+        return;
+    }
+    if (trigger.type === T.triggerForm) {
+        // The schema is DERIVED from the flow's inputs at compile time, so nothing
+        // of it needs recovering — the factory takes no arguments.
+        e.line(depth, `.trigger(${imp.use('formTrigger')}()${verArg(trigger)})`);
+        return;
+    }
+    if (trigger.type === T.triggerConversation) {
+        e.line(depth, `.trigger(${imp.use('conversationTrigger')}()${verArg(trigger)})`);
+        return;
+    }
+    if (trigger.type === T.triggerVoice) {
+        e.line(depth, `.trigger(${imp.use('voiceTrigger')}()${verArg(trigger)})`);
+        return;
+    }
+    // A connector EVENT trigger — the same subscription body as a mid-flow wait.
+    {
+        const sub = emitEventSubscription(trigger, imp, inputNames);
+        if (sub !== undefined) {
+            e.line(depth, `.trigger(${imp.use('onEvent')}(${sub})${verArg(trigger)})`);
+            return;
+        }
+    }
+    if (o.bestEffort === false) {
+        throw new Error(`decompile: unsupported trigger type "${trigger.type}".`);
+    }
+    e.line(depth, `/* TODO: unsupported trigger type ${trigger.type} */`);
+}
+// ─── Control-flow reconstruction (Phase 3) ────────────────────────────────────
+//
+// serialize's `emit()` walker turns a structured builder tree into a graph; this
+// inverts it. A flow is a directed graph, so recovering the tree means finding,
+// for each fork (decision / switch / parallel), the RECONVERGENCE point where its
+// arms meet again — the fork's immediate post-dominator. We compute post-
+// dominators per SCOPE (the root, and each loop body — a `parentId` group), then
+// walk each scope emitting structured constructs, recursing into arm sub-regions
+// and loop bodies. Non-reducible / non-reconverging graphs fall back to a marker
+// rather than a hard failure (a validating flow must still yield usable code).
+const EXIT = '#EXIT#';
+/** The node ids in a scope: the `parentId` group (root scope = no `parentId`). */
+function scopeIds(nodes, parentId) {
+    return new Set(nodes.filter((n) => (n.parentId ?? undefined) === parentId).map((n) => n.id));
+}
+/** In-scope successors of a node (by target id), excluding `error` and `loopBack` edges and out-of-scope targets. */
+function scopeSucc(graph, id, scope) {
+    const out = [];
+    for (const e of graph.successorEdges(id)) {
+        if (e.targetPort === 'loopBack')
+            continue;
+        if (scope.has(e.targetNodeId))
+            out.push(e.targetNodeId);
+    }
+    return out;
+}
+/**
+ * Immediate post-dominators for a scope's CFG (Cooper-Harvey-Kennedy iterative
+ * dominators, run on the REVERSE graph from a virtual EXIT). `ipdom(n)` is the
+ * node where every path out of `n` first reconverges — the reconvergence point of
+ * a fork. Returns a map from node id → its ipdom (`EXIT` when its only join is
+ * the scope exit).
+ */
+function postDominators(entry, scope, graph) {
+    // Forward successors within scope (EXIT for terminals / scope-exits), over the
+    // subgraph reachable from `entry`.
+    const succ = new Map();
+    const fpreds = new Map(); // forward predecessors: fpreds[t] = {n : n→t}
+    const addP = (from, to) => (fpreds.get(to) ?? fpreds.set(to, []).get(to)).push(from);
+    const seen = new Set();
+    const stack = [entry];
+    while (stack.length) {
+        const n = stack.pop();
+        if (seen.has(n) || !scope.has(n))
+            continue;
+        seen.add(n);
+        const s = scopeSucc(graph, n, scope);
+        const ss = s.length ? s : [EXIT];
+        succ.set(n, ss);
+        for (const t of ss) {
+            addP(n, t);
+            if (t !== EXIT && !seen.has(t))
+                stack.push(t);
+        }
+    }
+    // Post-dominators of the forward graph = dominators of the REVERSE graph rooted
+    // at EXIT. In that reverse graph a node's successors are its forward
+    // predecessors (`fpreds`) and its predecessors are its forward successors
+    // (`succ`). Cooper-Harvey-Kennedy over that graph, in reverse-postorder.
+    const post = [];
+    const vis = new Set();
+    const dfs = (n) => {
+        if (vis.has(n))
+            return;
+        vis.add(n);
+        for (const p of fpreds.get(n) ?? [])
+            dfs(p);
+        post.push(n);
+    };
+    dfs(EXIT);
+    const rpo = [...post].reverse(); // EXIT (the root) first
+    const num = new Map(post.map((n, i) => [n, i])); // postorder number: higher = closer to root
+    const ipdom = new Map();
+    ipdom.set(EXIT, EXIT);
+    const intersect = (a, b) => {
+        let x = a;
+        let y = b;
+        while (x !== y) {
+            while ((num.get(x) ?? -1) < (num.get(y) ?? -1))
+                x = ipdom.get(x);
+            while ((num.get(y) ?? -1) < (num.get(x) ?? -1))
+                y = ipdom.get(y);
+        }
+        return x;
+    };
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const b of rpo) {
+            if (b === EXIT)
+                continue;
+            // Predecessors in the reverse graph = forward successors of b.
+            const preds = (succ.get(b) ?? []).filter((p) => ipdom.has(p));
+            if (preds.length === 0)
+                continue;
+            let ni = preds[0];
+            for (const p of preds.slice(1))
+                ni = intersect(p, ni);
+            if (ipdom.get(b) !== ni) {
+                ipdom.set(b, ni);
+                changed = true;
+            }
+        }
+    }
+    return ipdom;
+}
+/** The target of the first out-edge of `id` on port `port` (in the whole graph). */
+function portTarget(graph, id, port) {
+    return graph.outEdges(id).find((e) => e.sourcePort === port)?.targetNodeId;
+}
+/** Re-indent every non-empty line of a (possibly multi-line) segment by `pad`. */
+function reindent(seg, pad) {
+    return seg.split('\n').map((l) => (l === '' ? l : pad + l)).join('\n');
+}
+/** Render a list of chain segments at an indent (each segment may be multi-line). */
+function renderSegs(segs, pad) {
+    return segs.map((s) => reindent(s, pad)).join('\n');
+}
+/** An arm callback `(x) => x <chain>` (or just `(x) => x` for an empty arm). */
+function armCb(param, segs) {
+    if (segs.length === 0)
+        return `(${param}) => ${param}`;
+    return `(${param}) => ${param}\n${renderSegs(segs, '  ')}`;
+}
+/**
+ * The `.return({...})` segment for a `core.control.end` node — its explicit
+ * `variableUpdates` (what `.return()` wrote), NOT the End's full `outputs` map
+ * (which also carries auto fall-through). An End with no updates is the implicit
+ * fall-off End the serializer always appends; it now decompiles to an explicit
+ * `.return({}, { version })` so the End's exact definition version survives the
+ * round trip (design §5.3) — recompiling emits the identical node.
+ */
+function returnSeg(node, ctx) {
+    const updates = ctx.flow.variables?.variableUpdates?.[node.id] ?? [];
+    const opts = returnOptsArg(node);
+    if (updates.length === 0)
+        return `.return({}${opts})`;
+    const entries = updates.map((u) => `${key(u.variableId)}: ${emitVal(u.expression, ctx.imp, ctx.inputNames)}`);
+    return `.return({ ${entries.join(', ')} }${opts})`;
+}
+/**
+ * The options argument for a `.return(...)` — `version`, plus the End's `name`
+ * and `label` when they are not what the serializer would derive on its own.
+ *
+ * `name` is emitted for any id other than `end`, which is what a first End is
+ * always given. That is deliberately not a prediction of the full `end`, `end2`,
+ * `end3` sequence: ids are claimed globally in emission order, decompile walks
+ * the graph in its own order, and a wrong guess would silently move a node. An
+ * id that is already `end` needs no name; every other id gets one and round-trips
+ * exactly. Naming an id the serializer would have chosen anyway is harmless.
+ *
+ * Without this the End's id was lost, and with it the `layout` block that keys on
+ * it — compile then refused its own decompiled source with `layout: "endNiceDay"
+ * names no step or node in this flow`.
+ */
+function returnOptsArg(node) {
+    const parts = [];
+    if (node.id !== 'end')
+        parts.push(`name: ${str(node.id)}`);
+    const ver = verClause(node);
+    if (ver)
+        parts.push(ver);
+    // The serializer labels an unlabelled End `End`, so that needs no carrying.
+    const label = node.display?.label;
+    if (typeof label === 'string' && label !== 'End')
+        parts.push(`label: ${str(label)}`);
+    return parts.length ? `, { ${parts.join(', ')} }` : '';
+}
+/**
+ * `.onError(...)` for whatever node carries an `error` edge — an action step or a
+ * `.loop()` container, which declares the handle too.
+ *
+ * Shared rather than duplicated because the reconstruction is identical: the
+ * handler's rejoin targets are whatever the guarded node's success continuation
+ * reaches, and a handler whose only content is a bare End reconstructs to an
+ * empty region that `.onError()` would refuse — so it becomes an explicit
+ * `.return({})`, the minimal legal handler, which serializes back to the same
+ * "error path ends the run" shape (its End id is derived, so — like all End ids
+ * — it is not preserved exactly).
+ *
+ * @returns The segment, or undefined when the node has no error edge.
+ */
+function errorHandlerSeg(nodeId, succ, scope, ipdom, ctx) {
+    const errEdge = ctx.graph.outEdges(nodeId).find((e) => e.sourcePort === 'error');
+    if (!errEdge)
+        return undefined;
+    const mainReach = forwardReach(succ, scope, ctx.graph);
+    const handlerSegs = region(errEdge.targetNodeId, EXIT, scope, ipdom, ctx, mainReach);
+    if (handlerSegs.length === 0)
+        handlerSegs.push('.return({})');
+    return `.onError(${armCb('h', handlerSegs)})`;
+}
+/**
+ * Emit a region — the chain of steps from `cursor` up to (but not including)
+ * `stop` — as a list of segments. `stop` is the reconvergence node the enclosing
+ * construct continues from (`EXIT`/`undefined` = run to a terminal). `refInto`
+ * (set only inside a port list) names the main-path nodes a `.stepToRef(...)`
+ * hands control back to.
+ */
+function region(cursor, stop, scope, ipdom, ctx, refInto) {
+    const segs = [];
+    while (cursor !== undefined && cursor !== stop && cursor !== EXIT) {
+        // A ref forward: this path re-enters a step the main path reaches later.
+        if (refInto?.has(cursor)) {
+            segs.push(`.stepToRef(${str(cursor)})`);
+            return segs;
+        }
+        const node = ctx.graph.byId.get(cursor);
+        if (!node)
+            break;
+        // A ref backward or sideways: this path has arrived somewhere already emitted.
+        // Before, the walk simply stopped here — which silently dropped the rest of a
+        // cycle, and a backward edge is now something the builder can author. Ends and
+        // terminates are excluded: they are not named steps, so there is nothing a ref
+        // could resolve against, and each path emitting its own is already correct.
+        if (ctx.emitted.has(cursor) && node.type !== T.end && node.type !== T.terminate) {
+            segs.push(`.stepToRef(${str(cursor)})`);
+            return segs;
+        }
+        ctx.emitted.add(cursor);
+        if (node.type === T.end) {
+            segs.push(returnSeg(node, ctx));
+            return segs;
+        }
+        if (node.type === T.terminate) {
+            segs.push(`.terminate(${str(node.id)}, undefined${optsArg(node, ctx)})`);
+            return segs;
+        }
+        if (node.type === T.merge) {
+            // A bare merge reached on the main path (its fork was not detected as a
+            // parallel). Skip it and continue from its output — best effort.
+            cursor = portTarget(ctx.graph, node.id, 'output');
+            continue;
+        }
+        if (node.type === T.decision) {
+            const r = ipdom.get(node.id) ?? stop;
+            const cond = emitBareExpr(String((node.inputs ?? {}).expression ?? ''), ctx.imp, ctx.inputNames);
+            const thenSegs = region(portTarget(ctx.graph, node.id, 'true'), r, scope, ipdom, ctx, refInto);
+            const elseSegs = region(portTarget(ctx.graph, node.id, 'false'), r, scope, ipdom, ctx, refInto);
+            const labels = armLabels(node);
+            if (labels.trueLabel)
+                thenSegs.unshift(`.label(${str(labels.trueLabel)})`);
+            if (labels.falseLabel)
+                elseSegs.unshift(`.label(${str(labels.falseLabel)})`);
+            segs.push(`.branch(${str(node.id)}, ${cond},\n${reindent(armCb('t', thenSegs), '  ')},\n${reindent(armCb('e', elseSegs), '  ')}${verArg(node)})`);
+            cursor = r === EXIT ? undefined : r;
+            continue;
+        }
+        if (node.type === T.switch) {
+            segs.push(emitSwitch(node, ipdom, scope, ctx, stop, refInto));
+            const r = ipdom.get(node.id) ?? stop;
+            cursor = r === EXIT ? undefined : r;
+            continue;
+        }
+        if (node.type === T.loop || node.type === T.doWhile) {
+            const inputs = node.inputs ?? {};
+            const bodyScope = scopeIds(ctx.flow.nodes ?? [], node.id);
+            // v1.0.0 loops start the body from `output`; v2.x loops and do-whiles
+            // from the inner `start` handle. Break edges (body node -> container's
+            // `break` target) decompile to `.break()` inside the body region.
+            const bodyEntry = portTarget(ctx.graph, node.id, 'start') ?? portTarget(ctx.graph, node.id, 'output');
+            const bodyIpdom = bodyEntry ? postDominators(bodyEntry, bodyScope, ctx.graph) : new Map();
+            const prevBreak = ctx.breakInto;
+            ctx.breakInto = node.id;
+            const bodySegs = region(bodyEntry, EXIT, bodyScope, bodyIpdom, ctx);
+            ctx.breakInto = prevBreak;
+            const extra = [];
+            if (node.type === T.loop) {
+                const parallel = unwrapPlain(inputs.parallel);
+                if (parallel === true)
+                    extra.push('parallel: true');
+                const completion = unwrapSource(inputs.completionCondition);
+                if (typeof completion === 'string' && completion.length) {
+                    extra.push(`completionCondition: ${emitBareExpr(completion.startsWith('=js:') ? completion.slice(4) : completion, ctx.imp, ctx.inputNames)}`);
+                }
+            }
+            const limit = node.type === T.doWhile ? unwrapPlain(inputs.limit) : undefined;
+            if (typeof limit === 'number')
+                extra.push(`limit: ${limit}`);
+            if (unwrapPlain(inputs.breakEnabled) === true && !bodyBreaks(ctx.graph, bodyScope, node.id)) {
+                extra.push('breakEnabled: true');
+            }
+            const opts = optsArgWith(node, ctx, extra);
+            if (node.type === T.doWhile) {
+                const condRaw = unwrapSource(inputs.condition);
+                const cond = typeof condRaw === 'string' && condRaw.length
+                    ? emitBareExpr(condRaw.startsWith('=js:') ? condRaw.slice(4) : condRaw, ctx.imp, ctx.inputNames)
+                    : `${ctx.imp.use('lit')}(true)`;
+                segs.push(`.doWhile(${str(node.id)}, ${cond}, ${armCb('b', bodySegs)}${opts})`);
+            }
+            else {
+                const collRaw = unwrapSource(inputs.collection);
+                const collection = collRaw !== undefined
+                    ? emitBareExpr(collRaw.startsWith('=js:') ? collRaw.slice(4) : collRaw, ctx.imp, ctx.inputNames)
+                    : `${ctx.imp.use('lit')}([])`;
+                segs.push(`.loop(${str(node.id)}, ${collection}, ${armCb('b', bodySegs)}${opts})`);
+            }
+            // A container can carry an error handler too — `core.logic.loop` declares
+            // the handle, and `.onError()` after `.loop(...)` authors it. Without this
+            // the edge and its whole handler region were dropped on decompile, which
+            // would delete a handler from any brownfield flow that had one.
+            const containerSucc = scopeSucc(ctx.graph, node.id, scope);
+            const containerHandler = errorHandlerSeg(node.id, containerSucc, scope, ipdom, ctx);
+            if (containerHandler)
+                segs.push(containerHandler);
+            cursor = portTarget(ctx.graph, node.id, 'success');
+            continue;
+        }
+        if (node.type === T.subflow) {
+            segs.push(`.step(${str(node.id)}, ${emitSubflow(node, ctx)}${optsArg(node, ctx)})`);
+            cursor = scopeSucc(ctx.graph, node.id, scope)[0];
+            continue;
+        }
+        // A regular action step (mock / script / http / transform / connector / …).
+        const spec = emitStepSpec(node, ctx.imp, ctx.inputNames, ctx.o, ctx.graph);
+        segs.push(`.step(${str(node.id)}, ${spec}${optsArg(node, ctx)})`);
+        // An error handler on this step (source port `error` + `errorHandlingEnabled`).
+        const succ = scopeSucc(ctx.graph, node.id, scope);
+        const handler = errorHandlerSeg(node.id, succ, scope, ipdom, ctx);
+        if (handler)
+            segs.push(handler);
+        // HTTP response branches: each branch-* edge is its own side path,
+        // recovered as .stepToList('branch-<name>', …) with the same rejoin
+        // machinery an error handler uses.
+        for (const be of ctx.graph.outEdges(node.id).filter((e) => e.sourcePort.startsWith('branch-'))) {
+            const mainReach = forwardReach(succ, scope, ctx.graph);
+            const branchSegs = region(be.targetNodeId, EXIT, scope, ipdom, ctx, mainReach);
+            if (branchSegs.length === 0)
+                branchSegs.push('.return({})');
+            segs.push(`.stepToList(${str(be.sourcePort)}, ${armCb('p', branchSegs)})`);
+        }
+        // A per-outcome human task routes each NON-primary outcome from its own
+        // `outcome-<slug>` exit; the primary one continues the main path, so it is
+        // already a successor (see Graph.primaryOutcomePort).
+        {
+            const primary = ctx.graph.primaryOutcomePort(node.id);
+            for (const oe of ctx.graph.outEdges(node.id)
+                .filter((e) => e.sourcePort.startsWith('outcome-') && e.sourcePort !== primary)) {
+                const mainReach = forwardReach(succ, scope, ctx.graph);
+                const outSegs = region(oe.targetNodeId, EXIT, scope, ipdom, ctx, mainReach);
+                if (outSegs.length === 0)
+                    outSegs.push('.return({})');
+                segs.push(`.stepToList(${str(oe.sourcePort)}, ${armCb('p', outSegs)})`);
+            }
+        }
+        // A body edge into the enclosing container's break handle: the path exits
+        // the loop here. Emit `.break()` and end the region — recompiling recreates
+        // exactly this edge and adds no continue back-edge for the path.
+        if (ctx.breakInto !== undefined
+            && ctx.graph.outEdges(node.id).some((e) => e.targetNodeId === ctx.breakInto && e.targetPort === 'break')) {
+            segs.push('.break()');
+            return segs;
+        }
+        // Continuation: 0 → terminal; 1 → follow; N same-port → parallel fork.
+        if (succ.length === 0)
+            return segs;
+        if (succ.length === 1) {
+            cursor = succ[0];
+            continue;
+        }
+        // Parallel: the fork's ipdom is the merge join; each successor is one arm.
+        const join = ipdom.get(node.id);
+        if (join && join !== EXIT && ctx.graph.byId.get(join)?.type === T.merge) {
+            const arms = succ.map((t, i) => armCb(`a${i}`, region(t, join, scope, ipdom, ctx, refInto)));
+            segs.push(`.parallel(${str(join)}, [\n${arms.map((a) => reindent(a, '  ')).join(',\n')},\n]${verArg(ctx.graph.byId.get(join))})`);
+            cursor = portTarget(ctx.graph, join, 'output');
+            continue;
+        }
+        // Unstructured fan-out we can't fold — best-effort marker.
+        if (ctx.o.bestEffort === false)
+            throw new Error(`decompile: unstructured fan-out at "${node.id}".`);
+        segs.push(`/* TODO: unstructured fan-out at ${node.id} (${succ.length} successors) */`);
+        return segs;
+    }
+    return segs;
+}
+/** A branch/switch node's arm labels (the designer edge text), when non-default. */
+function armLabels(node) {
+    const i = node.inputs ?? {};
+    const out = {};
+    if (typeof i.trueLabel === 'string' && i.trueLabel !== 'True')
+        out.trueLabel = i.trueLabel;
+    if (typeof i.falseLabel === 'string' && i.falseLabel !== 'False')
+        out.falseLabel = i.falseLabel;
+    return out;
+}
+/** Forward-reachable node set from a set of entries, within a scope. */
+function forwardReach(entries, scope, graph) {
+    const seen = new Set();
+    const stack = [...entries];
+    while (stack.length) {
+        const n = stack.pop();
+        if (seen.has(n) || !scope.has(n))
+            continue;
+        seen.add(n);
+        for (const t of scopeSucc(graph, n, scope))
+            stack.push(t);
+    }
+    return seen;
+}
+/**
+ * Emit a `.switch(...)` from a `core.logic.switch` node. Each case's serialized
+ * expression is `<discriminant> === <JSON-literal>`; the discriminant (shared by
+ * all cases) becomes `on`, and each RHS literal a case `value`. The case port is
+ * `case-<caseId>`; the optional default arm is the `default` port.
+ */
+function emitSwitch(node, ipdom, scope, ctx, stop, refInto) {
+    const r = ipdom.get(node.id) ?? stop;
+    const cases = (node.inputs ?? {}).cases ?? [];
+    let disc;
+    let nonUniform = false; // a case whose expr isn't `<disc> === <literal>`, or a differing discriminant
+    const caseSrcs = [];
+    for (const c of cases) {
+        // SDK-emitted switch cases are `<discriminant> === <JSON-literal>` (all cases
+        // share the discriminant). Accept `==` too (hand-authored flows use it).
+        const m = String(c.expression ?? '').match(/^(.*?)\s*===?\s*(.*)$/);
+        const lhs = m ? m[1].trim() : '';
+        if (m && lhs) {
+            if (disc === undefined)
+                disc = lhs;
+            else if (disc !== lhs)
+                nonUniform = true;
+        }
+        else {
+            nonUniform = true;
+        }
+        let value = '0';
+        let valueLiteral = '';
+        if (m) {
+            valueLiteral = m[2].trim();
+            try {
+                value = literal(JSON.parse(valueLiteral));
+            }
+            catch {
+                // A non-JSON literal (e.g. single-quoted) — strip matching quotes if any.
+                const q = valueLiteral.match(/^'(.*)'$/);
+                value = q ? str(q[1]) : str(valueLiteral);
+            }
+        }
+        else {
+            nonUniform = true;
+        }
+        const armSegs = region(portTarget(ctx.graph, node.id, `case-${c.id}`), r, scope, ipdom, ctx, refInto);
+        const defaultLabel = `Case ${valueLiteral}`;
+        const labelPart = c.label && c.label !== defaultLabel ? `, label: ${str(c.label)}` : '';
+        caseSrcs.push(`{ value: ${value}${labelPart}, body: ${armCb('b', armSegs)} }`);
+    }
+    const on = emitBareExpr(disc ?? '', ctx.imp, ctx.inputNames);
+    const hasDefault = (node.inputs ?? {}).hasDefault === true || portTarget(ctx.graph, node.id, 'default') !== undefined;
+    const defArm = hasDefault
+        ? `, ${armCb('d', region(portTarget(ctx.graph, node.id, 'default'), r, scope, ipdom, ctx, refInto))}`
+        : '';
+    const caseList = `[\n${caseSrcs.map((c) => reindent(c, '  ')).join(',\n')},\n]`;
+    // The builder's `.switch(on, [{value}])` models `on === value` only. A flow whose
+    // cases carry arbitrary per-case boolean expressions (or a non-uniform
+    // discriminant) cannot round-trip through it — flag it rather than emit silently
+    // wrong values.
+    const warn = nonUniform
+        ? `\n/* TODO: this switch's case expressions are not a uniform \`<discriminant> === <value>\`; the recovered on/value are best-effort and need review. */`
+        : '';
+    const ver = verArg(node);
+    return `.switch(${str(node.id)}, ${on}, ${caseList}${defArm}${ver && !defArm ? ', undefined' : ''}${ver})${warn}`;
+}
+/** The manifest-less annotation node type — the only annotation `.flow` has. */
+const STICKY_NOTE_TYPE = 'stickyNote';
+/**
+ * Recover `.stickyNotes([...])` from the scope's `stickyNote` nodes.
+ *
+ * They are real nodes in `nodes[]`, so they arrive with the graph rather than
+ * with the layout — but they have no definition, no ports and no edges, so the
+ * control-flow walk never reaches them and they have to be picked up explicitly.
+ * Ids are always emitted, never left to the `stickyNote_<n>` default: an
+ * unnamed note would renumber if a note ahead of it were deleted, and read as
+ * delete-plus-create on the next diff.
+ */
+function stickyNotesSeg(nodes, flow) {
+    const hoisted = (flow.layout?.nodes ?? {});
+    const notes = nodes.filter((n) => n.type === STICKY_NOTE_TYPE);
+    if (!notes.length)
+        return undefined;
+    const entries = notes.map((n) => {
+        const i = (n.inputs ?? {});
+        const ui = { ...(n.ui ?? {}), ...(hoisted[n.id] ?? {}) };
+        const pos = ui.position ?? { x: 0, y: 0 };
+        const fields = [
+            `id: ${str(n.id)}`,
+            `content: ${str(typeof i.content === 'string' ? i.content : '')}`,
+        ];
+        if (typeof i.color === 'string' && i.color !== 'yellow')
+            fields.push(`color: ${str(i.color)}`);
+        fields.push(`x: ${numLit(pos.x)}`, `y: ${numLit(pos.y)}`);
+        if (ui.size && typeof ui.size.width === 'number' && typeof ui.size.height === 'number') {
+            fields.push(`width: ${numLit(ui.size.width)}`, `height: ${numLit(ui.size.height)}`);
+        }
+        return `  { ${fields.join(', ')} },`;
+    });
+    return `.stickyNotes([\n${entries.join('\n')}\n])`;
+}
+/**
+ * Recover the designer `.layout()` for one scope.
+ *
+ * Layout persists in TWO legal shapes, and both must read. The designer's own
+ * write path (`extractLayout` in flow-v1) hoists each node's `ui` into
+ * `layout.nodes[<nodeId>]` and STRIPS `ui` from the node; the SDK's serializer
+ * writes `ui` on the node and leaves `layout.nodes` empty. flow-v1's read path
+ * merges them (`{ ...node.ui, ...layoutEntry }`), so the hoisted entry wins —
+ * this follows the same precedence.
+ *
+ * Keys are AUTHOR-level ids, which for decompiled source are the node ids: the
+ * decompiler names every step with its original id, so the two coincide (see
+ * the node-id stability note at the top of this file).
+ *
+ * A scope is the FLAT `nodes[]` array, not the root-level nodes: BPMN containment
+ * is by `parentId`, so a loop body's steps sit in the same array with their own
+ * positions, and `applyAuthorLayout` resolves them by raw id. Filtering them out
+ * would silently drop the layout of everything inside a loop.
+ *
+ * Edge layout is keyed by EDGE ID in the file and by `"<from>-><to>"` in the
+ * builder. That mapping is only well-defined when exactly ONE edge joins the
+ * pair — `applyAuthorLayout` refuses an ambiguous key rather than guess — so a
+ * pair carrying two edges (a decision whose `true` and `false` ports reach the
+ * same node, say) has its route dropped here. Emitting it would generate source
+ * that fails to compile, which is worse than losing a bend.
+ *
+ * Everything is emitted, including positions the serializer would have assigned
+ * anyway. Decompiled source is deliberately more explicit than hand-written
+ * source (the same rule as explicit node versions): re-deriving "is this the
+ * default?" would mean reimplementing the auto-layout column algorithm here and
+ * silently dropping a hand-placed node that happened to land on the grid.
+ */
+function layoutSeg(flow, nodes, edges) {
+    const hoisted = (flow.layout?.nodes ?? {});
+    const nodeEntries = [];
+    for (const n of nodes) {
+        // A sticky note carries its own geometry in `.stickyNotes()`; a layout entry
+        // for it would be a second, competing source for the same coordinates.
+        if (n.type === STICKY_NOTE_TYPE)
+            continue;
+        const ui = { ...(n.ui ?? {}), ...(hoisted[n.id] ?? {}) };
+        const pos = ui.position;
+        if (!pos || typeof pos.x !== 'number' || typeof pos.y !== 'number')
+            continue;
+        const fields = [`position: { x: ${numLit(pos.x)}, y: ${numLit(pos.y)} }`];
+        if (ui.size && typeof ui.size.width === 'number' && typeof ui.size.height === 'number') {
+            fields.push(`size: { width: ${numLit(ui.size.width)}, height: ${numLit(ui.size.height)} }`);
+        }
+        if (typeof ui.collapsed === 'boolean')
+            fields.push(`collapsed: ${boolLit(ui.collapsed)}`);
+        nodeEntries.push(`${key(n.id)}: { ${fields.join(', ')} }`);
+    }
+    // How many edges join each (source, target) pair — a pair with more than one
+    // has no unambiguous builder key.
+    const pairCount = new Map();
+    for (const e of edges) {
+        const k = `${e.sourceNodeId}->${e.targetNodeId}`;
+        pairCount.set(k, (pairCount.get(k) ?? 0) + 1);
+    }
+    const hoistedEdges = (flow.layout?.edges ?? {});
+    const edgeEntries = [];
+    for (const e of edges) {
+        const ui = { ...(e.ui ?? {}), ...(e.id ? hoistedEdges[e.id] ?? {} : {}) };
+        const parts = [];
+        for (const which of ['waypoints', 'routedWaypoints']) {
+            const pts = ui[which];
+            if (!Array.isArray(pts) || pts.length === 0)
+                continue;
+            const rendered = pts
+                .filter((p) => p && typeof p.x === 'number' && typeof p.y === 'number')
+                .map((p) => `{ x: ${numLit(p.x)}, y: ${numLit(p.y)}${typeof p.id === 'string' ? `, id: ${str(p.id)}` : ''} }`);
+            if (rendered.length)
+                parts.push(`${which}: [${rendered.join(', ')}]`);
+        }
+        if (!parts.length)
+            continue;
+        const pair = `${e.sourceNodeId}->${e.targetNodeId}`;
+        if ((pairCount.get(pair) ?? 0) !== 1)
+            continue; // ambiguous — see the note above
+        edgeEntries.push(`${str(pair)}: { ${parts.join(', ')} }`);
+    }
+    if (!nodeEntries.length && !edgeEntries.length)
+        return undefined;
+    const sections = [];
+    if (nodeEntries.length)
+        sections.push(`  nodes: {\n${nodeEntries.map((s) => `    ${s},`).join('\n')}\n  },`);
+    if (edgeEntries.length)
+        sections.push(`  edges: {\n${edgeEntries.map((s) => `    ${s},`).join('\n')}\n  },`);
+    return `.layout({\n${sections.join('\n')}\n})`;
+}
+/**
+ * Emit `subflow(child, inputs)` for a `core.subflow` node. The child flow body
+ * lives in `flow.subflows[<nodeId>]` (keyed by the CALLING node id — the child's
+ * own `flow(id)` is not preserved and is irrelevant to the output). We render the
+ * child inline as a nested `flow(...)` builder (no `.build()` — `subflow()`
+ * collects the builder) and pass the caller's per-input expressions.
+ */
+function emitSubflow(node, ctx) {
+    const child = ctx.flow.subflows?.[node.id];
+    const inputsSrc = emitValMap(node.inputs, ctx.imp, ctx.inputNames) || '{}';
+    if (!child) {
+        if (ctx.o.bestEffort === false)
+            throw new Error(`decompile: subflow "${node.id}" has no body in subflows[].`);
+        return `${ctx.imp.use('mock')}() /* TODO: subflow ${node.id} body missing */`;
+    }
+    const childName = `${node.id}Child`;
+    const childSrc = emitChildFlow(childName, child, ctx);
+    return `${ctx.imp.use('subflow')}(${childSrc}, ${inputsSrc})`;
+}
+/**
+ * Render a child (sub)flow body as a nested `flow(name)…` builder expression
+ * (parenthesized, no `.build()`). Reuses the same region machinery on the child's
+ * own scope; the child's trigger is its `<caller>Start` node.
+ */
+function emitChildFlow(name, child, ctx) {
+    const globals = readFlowGlobals(child.variables, runStrict);
+    const childCtx = {
+        graph: new Graph(child.nodes ?? [], child.edges ?? []),
+        flow: child,
+        imp: ctx.imp,
+        inputNames: new Set(globals.filter((g) => g.direction === 'in').map((g) => g.name ?? g.id)),
+        emitted: new Set(),
+        o: ctx.o,
+    };
+    const parts = [`${ctx.imp.use('flow')}(${str(name)})`];
+    // Variables.
+    const shape = (dir) => `{ ${globals.filter((g) => g.direction === dir).map((g) => `${key(g.name ?? g.id)}: ${declExpr(g, dir === 'in', ctx.imp)}`).join(', ')} }`;
+    if (globals.some((g) => g.direction === 'in'))
+        parts.push(`.input(${shape('in')})`);
+    if (globals.some((g) => g.direction === 'out'))
+        parts.push(`.output(${shape('out')})`);
+    for (const g of globals.filter((g) => g.direction === 'inout')) {
+        const def = g.defaultValue !== undefined ? `, ${literal(g.defaultValue)}` : '';
+        parts.push(`.var(${str(g.name ?? g.id)}, ${declExpr(g, false, ctx.imp)}${def})`);
+    }
+    // Body: the child's trigger is its own manual Start; walk from its successor.
+    const trigger = (child.nodes ?? []).find((n) => isTrigger(n.type) && !(child.edges ?? []).some((e) => e.targetNodeId === n.id));
+    const scope = scopeIds(child.nodes ?? [], undefined);
+    const entry = trigger ? scopeSucc(childCtx.graph, trigger.id, scope)[0] : undefined;
+    const ipdom = entry ? postDominators(entry, scope, childCtx.graph) : new Map();
+    const bodySegs = entry ? region(entry, EXIT, scope, ipdom, childCtx) : [];
+    parts.push(...bodySegs);
+    // A subflow carries its own scoped layout, resolved against its own node ids.
+    const childNotes = stickyNotesSeg(child.nodes ?? [], child);
+    if (childNotes)
+        parts.push(childNotes);
+    const childLayout = layoutSeg(child, child.nodes ?? [], child.edges ?? []);
+    if (childLayout)
+        parts.push(childLayout);
+    return `(\n${renderSegs(parts.map((p, i) => (i === 0 ? p : p)), '  ')}\n)`;
+}
+// ─── Entry point ──────────────────────────────────────────────────────────────
+/** Slugify the flow name/id into a stable-but-cosmetic `flow(id)` argument. */
+function slugId(flow) {
+    const base = flow.id ?? flow.name ?? 'flow';
+    const slug = base.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+    return slug || 'flow';
+}
+export function decompile(flow, options = {}) {
+    const importSpecifier = options.importSpecifier ?? './flow-sdk.js';
+    runStrict = options.bestEffort === false;
+    runWarn = options.warn;
+    runWarned = new Set();
+    runDefPairs = new Set((flow.definitions ?? [])
+        .filter((d) => typeof d?.nodeType === 'string' && typeof d?.version === 'string')
+        .map((d) => `${d.nodeType}@${d.version}`));
+    runDefs = new Map();
+    runRawManifests = [];
+    for (const d of (flow.definitions ?? [])) {
+        if (typeof d?.nodeType !== 'string')
+            continue;
+        runDefs.set(`${d.nodeType}@${d.version}`, d);
+        if (!runDefs.has(d.nodeType))
+            runDefs.set(d.nodeType, d);
+    }
+    const imp = new Imports();
+    const graph = new Graph(flow.nodes ?? [], flow.edges ?? []);
+    const globals = readFlowGlobals(flow.variables, runStrict);
+    const inputNames = new Set(globals.filter((g) => g.direction === 'in').map((g) => g.name ?? g.id));
+    // Trigger-bound globals name the node they came from; fall back to the graph's
+    // own trigger node, then to the default.
+    currentTriggerId =
+        globals.find((g) => g.direction === 'in' && g.triggerNodeId)?.triggerNodeId ??
+            (flow.nodes ?? []).find((n) => String(n.type ?? '').startsWith('core.trigger.'))?.id ??
+            DEFAULT_TRIGGER_ID;
+    const e = new Emit();
+    e.line(0, `export default ${imp.use('flow')}(${str(slugId(flow))})`);
+    const d = 1;
+    // The file-format version FIRST, mirroring the order the file itself carries
+    // it (`id`, `version`, `name`) — and emitted even when it equals this SDK's
+    // default, because preserving means RE-DECLARING: a later default bump must
+    // not silently upgrade a file a decompile already captured. A version this
+    // build cannot write is reported instead of dropped; emitting the call would
+    // hand `compile` a source it refuses.
+    const schema = preserveSchemaVersion(FLOW_SCHEMA_VERSIONS, flow.version);
+    if (schema.call)
+        e.line(d, schema.call);
+    if (schema.problem) {
+        if (runStrict)
+            throw new Error(`decompile: ${schema.problem}`);
+        warnOnce(schema.problem);
+        e.line(d, `// TODO: ${schema.problem}`);
+    }
+    if (flow.name !== undefined && flow.name !== flow.id)
+        e.line(d, `.name(${str(flow.name)})`);
+    if (typeof flow.description === 'string') {
+        e.line(d, `.description(${str(flow.description)})`);
+    }
+    // Trigger nodes. One root is the default: the isDefaultEntryPoint carrier
+    // when the file marks one (a multi-root flow always does), else `start`.
+    // A node's TYPE is not enough: `uipath.connector.event.<key>.<event>` is a
+    // start trigger when it opens the flow and a mid-flow WAIT step when it has
+    // an incoming edge. Only a root can be a trigger.
+    const triggerNodes = (flow.nodes ?? [])
+        .filter((n) => isTrigger(n.type) && graph.inEdges(n.id).length === 0);
+    const trigger = triggerNodes.find((n) => (n.inputs ?? {}).isDefaultEntryPoint === true)
+        ?? graph.byId.get('start')
+        ?? triggerNodes[0];
+    if (trigger)
+        emitTrigger(e, d, trigger, imp, options, inputNames);
+    // Nodes no trigger reaches. The region walk below starts at the trigger's
+    // successor and follows edges, so a node with no path from any root was
+    // silently absent from the source — it survived only as a `.layout()` key,
+    // which `compile` then refused as naming no step. The builder has no
+    // detached-node construct, so the honest output is: leave it out, say so in
+    // the chain and on stderr, and drop its layout entry so the source compiles.
+    const detached = detachedTopLevelNodes(flow.nodes ?? [], graph, triggerNodes, trigger);
+    const detachedIds = new Set(detached.map((n) => n.id));
+    if (detached.length > 0) {
+        const listing = detached.map((n) => `${str(n.id)} (${n.type})`).join(', ');
+        const message = `${detached.length} node(s) are not reachable from any trigger — no edge leads to them: ${listing}. `
+            + 'The builder has no detached-node construct, so this source omits them and recompiling drops them. '
+            + 'Connect each one with an edge in the .flow first, or edit that node\'s JSON directly.';
+        if (runStrict)
+            throw new Error(`decompile: ${message}`);
+        warnOnce(message);
+        for (const n of detached) {
+            e.line(d, `// TODO: node ${str(n.id)} (${n.type}) is not reachable from any trigger and is NOT in this source; recompiling drops it. Connect it in the .flow or edit its JSON directly.`);
+        }
+    }
+    emitVariables(e, d, flow, imp);
+    // Reconstruct the body: structured control flow recovered from the graph.
+    const ctx = { graph, flow, imp, inputNames, o: options, emitted: new Set() };
+    const scope = scopeIds(flow.nodes ?? [], undefined);
+    const startId = trigger?.id ?? 'start';
+    const first = scopeSucc(graph, startId, scope)[0];
+    const ipdom = first !== undefined ? postDominators(first, scope, graph) : new Map();
+    const bodySegs = first !== undefined ? region(first, EXIT, scope, ipdom, ctx) : [];
+    // Additional roots decompile to .entryPoint(...): scoped inputs from the
+    // globals bound to them, and a prefix region that hands off into the shared
+    // body — the shared nodes are in ctx.emitted by now, so the walk naturally
+    // closes each prefix with a .stepToRef into the join point.
+    const extraEps = [];
+    for (const t of triggerNodes) {
+        if (t === trigger)
+            continue;
+        extraEps.push(entryPointSeg(t, scope, ipdom, ctx));
+    }
+    const header = e.toString();
+    const body = bodySegs.map((s) => reindent(s, '  ')).join('\n');
+    const eps = extraEps.map((s) => reindent(s, '  ')).join('\n');
+    // Designer layout last, so the graph reads first and the coordinates do not
+    // interleave with the steps they position.
+    const notes = stickyNotesSeg(flow.nodes ?? [], flow);
+    const sticky = notes ? reindent(notes, '  ') : '';
+    const lay = layoutSeg(flow, (flow.nodes ?? []).filter((n) => !detachedIds.has(n.id)), (flow.edges ?? []).filter((edge) => !detachedIds.has(edge.sourceNodeId) && !detachedIds.has(edge.targetNodeId)));
+    const layout = lay ? reindent(lay, '  ') : '';
+    const chain = [header, eps, body, sticky, layout, '  .build();'].filter((s) => s.length > 0).join('\n');
+    const hoisted = runRawManifests
+        .map(([name, json]) => `const ${name} = ${json};`)
+        .join('\n\n');
+    return [imp.line(importSpecifier), hoisted, chain].filter((p) => p.length > 0).join('\n\n') + '\n';
+}
+/**
+ * Top-level nodes (no `parentId`) that no root trigger reaches over ANY edge —
+ * error, branch, outcome and artifact ports included, so a node that only an
+ * error path leads to is not reported. Sticky notes carry no graph position and
+ * the roots themselves are excluded. Container children are the container's
+ * business (their own walk emits them) and are never candidates.
+ */
+function detachedTopLevelNodes(nodes, graph, roots, trigger) {
+    const rootIds = new Set(roots.map((n) => n.id));
+    if (trigger)
+        rootIds.add(trigger.id);
+    const seen = new Set();
+    const stack = [...rootIds];
+    while (stack.length) {
+        const id = stack.pop();
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        for (const edge of graph.outEdges(id))
+            if (!seen.has(edge.targetNodeId))
+                stack.push(edge.targetNodeId);
+    }
+    return nodes.filter((n) => (n.parentId ?? undefined) === undefined
+        && n.type !== STICKY_NOTE_TYPE
+        && !rootIds.has(n.id)
+        && !seen.has(n.id));
+}
+/**
+ * The `every` value a scheduled trigger node carries, across both definition
+ * shapes: 1.1 splits preset/custom over `timerPreset`/`timerValue`; 1.2 (the
+ * cron-capable contract) dropped `timerPreset` and rides `timerValue` alone.
+ */
+function scheduleEvery(t) {
+    const i = t.inputs ?? {};
+    if (typeof i.timerPreset !== 'string')
+        return typeof i.timerValue === 'string' ? i.timerValue : '';
+    return i.timerPreset === 'custom'
+        ? (typeof i.timerValue === 'string' ? i.timerValue : '')
+        : i.timerPreset;
+}
+/** One `.entryPoint(id, trigger, { inputs, version }, prefix)` segment for a non-default root. */
+function entryPointSeg(t, scope, ipdom, ctx) {
+    const factory = t.type === T.triggerScheduled
+        ? `${ctx.imp.use('scheduled')}(${opts([['every', str(scheduleEvery(t))]])})`
+        : t.type === T.triggerForm
+            ? `${ctx.imp.use('formTrigger')}()`
+            : t.type === T.triggerConversation
+                ? `${ctx.imp.use('conversationTrigger')}()`
+                : t.type === T.triggerVoice
+                    ? `${ctx.imp.use('voiceTrigger')}()`
+                    : t.type === T.triggerManual
+                        ? `${ctx.imp.use('manual')}()`
+                        : (() => {
+                            if (ctx.o.bestEffort === false)
+                                throw new Error(`decompile: unsupported entry-point trigger type "${t.type}".`);
+                            return `${ctx.imp.use('manual')}() /* TODO: unsupported trigger type ${t.type} */`;
+                        })();
+    const scoped = readFlowGlobals(ctx.flow.variables, runStrict)
+        .filter((g) => g.direction === 'in' && g.triggerNodeId === t.id);
+    const optParts = [];
+    if (scoped.length) {
+        optParts.push(`inputs: { ${scoped.map((g) => `${key(g.name ?? g.id)}: ${declExpr(g, true, ctx.imp)}`).join(', ')} }`);
+    }
+    const ver = verClause(t);
+    if (ver)
+        optParts.push(ver);
+    const first = scopeSucc(ctx.graph, t.id, scope)[0];
+    const prefixSegs = first !== undefined ? region(first, EXIT, scope, ipdom, ctx) : [];
+    const optArgText = optParts.length ? `, { ${optParts.join(', ')} }` : (prefixSegs.length ? ', undefined' : '');
+    const prefix = prefixSegs.length ? `, ${armCb('b', prefixSegs)}` : '';
+    return `.entryPoint(${str(t.id)}, ${factory}${optArgText}${prefix})`;
+}