@uipath/maestro-builder-sdk 6.18.10 → 6.20.0

package/dist/decompile.js

@@ -28,21 +28,23 @@
  * 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 { BUNDLED_DEFINITIONS, bundledVersions } from './flow-definitions.js';
+import { DEFAULT_TRIGGER_ID, Expr } from './core/expr.js';
+import { FLOW_NODE_TYPES } from './flow-node-registry.js';
 import { commentText } from './core/comment-text.js';
 import { tsLiteral, tsNumber, tsText } from './core/ts-literal.js';
+import { contextIndexSlug, parseContextIndexType } from './core/context-index.js';
+import { wireExprBody } from './core/wire-expr.js';
 import { parseIxpProjectType } from './core/actions.js';
 import { readFlowGlobals } from './flow-variables.js';
 import { missingBindingLabels } from './core/binding-messages.js';
 import { prepareCommand } from './core/cli-spelling.js';
-import { OUTCOME_HANDLE_NODE_TYPES } from './core/hitl-routing.js';
+import { OUTCOME_HANDLE_NODE_TYPES, outcomeSlug } from './core/hitl-routing.js';
+import { STICKY_NOTE_TYPE } from './core/definitionless-node-types.js';
 import { eventFilterFromTreeLeaf } from './core/event-filters.js';
+import { sdkFormFieldType } from './core/form-field-type.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
@@ -81,6 +83,17 @@ 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();
+/**
+ * The agent RESOURCE nodes the agent-cluster inverter folded into an agent's
+ * spec (`inlineAgent({ tools, context, escalation, memory })`), mapped to the
+ * node id compile will mint for each (`<agent>Context`, `<agent>Tool2`, ...), or
+ * to `undefined` when compile will not re-emit the node at all.
+ *
+ * A folded resource is not a step, so its id is not the author's to choose:
+ * compile names it. Anything decompile writes that names the node, such as a
+ * `.layout()` key, must use the id compile will produce, not the file's.
+ */
+let runAbsorbed = new Map();
 /** `DecompileOptions.readSidecar` for the current run. */
 let runReadSidecar;
 function warnOnce(message) {
@@ -89,16 +102,6 @@ function warnOnce(message) {
     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_DEFINITIONS = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), 'core-definitions.json'), 'utf8'));
-const CORE_DEFINITION_KEYS = new Set(Object.keys(CORE_DEFINITIONS));
 /**
  * The label the canvas gives a freshly dropped `node`: its definition's
  * `display.label`, from the file's own `definitions[]`, else the bundled core
@@ -106,7 +109,7 @@ const CORE_DEFINITION_KEYS = new Set(Object.keys(CORE_DEFINITIONS));
  */
 function definitionLabel(node) {
     const key = `${node.type}@${node.typeVersion}`;
-    const def = runDefs.get(key) ?? CORE_DEFINITIONS[key] ?? runDefs.get(node.type);
+    const def = runDefs.get(key) ?? BUNDLED_DEFINITIONS[key] ?? runDefs.get(node.type);
     const label = def?.display?.label;
     return typeof label === 'string' ? label : undefined;
 }
@@ -124,13 +127,33 @@ function verClause(node) {
                 + `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 ${tsLiteral(node.id)} pins ${node.type}@${tv}, but this SDK bundles ${node.type}@${shipped.join(', ') || '<none>'} only; `
-            + `\`compile\` will refuse the emitted { version: ${tsLiteral(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.`);
+    // A pin the SDK cannot resolve: `serialize` resolves an explicit { version }
+    // exactly (design §2.6) — a registered type against its registered versions,
+    // any other type against the bundle. Keeping that pin would emit source
+    // `compile` refuses (#1128: quick-form@1.6 from `node add`, @1.4 from
+    // `migrate`, script@1.0 from a pre-migrate file), so the source omits it: the
+    // node compiles at the SDK's default, and `merge --baseline` keeps the
+    // UNTOUCHED original node, with its own version and definition, verbatim
+    // (`nodeUnchanged` ignores typeVersion). Interim: a node the author EDITS is
+    // re-emitted at the default — the root fix is for compile to accept the
+    // definition the file carries.
+    //
+    // A type with no SDK-known version at all (a connector, a published-resource
+    // `uipath.core.*` node, a rawNode) resolves its version elsewhere, so its pin
+    // is kept.
+    const registered = FLOW_NODE_TYPES.byTypeName(node.type);
+    const shipped = registered ? Object.keys(registered.type.versions) : bundledVersions(node.type);
+    if (shipped.length > 0 && !shipped.includes(tv)) {
+        const known = `${node.type}@${shipped.join(', ')}`;
+        if (runStrict) {
+            // Strict never changes a node's version behind the author's back.
+            throw new Error(`decompile: node "${node.id}" pins ${node.type}@${tv}, which this SDK cannot resolve (it ${registered ? 'registers' : 'bundles'} `
+                + `${known}); compile would refuse the pin, and omitting it changes the node's version.`);
+        }
+        warnOnce(`node ${tsLiteral(node.id)} pins ${node.type}@${tv}, but this SDK ${registered ? 'registers' : 'bundles'} ${known} only, `
+            + `so the source omits that { version } and \`compile\` emits the SDK's default (versions resolve exactly, flow-builder-sdk#71). `
+            + `\`merge --baseline\` keeps the node at ${tv} if you leave it untouched; if you edit it, the merged node moves to the SDK's version.`);
+        return '';
     }
     return `version: ${tsLiteral(tv)}`;
 }
@@ -210,21 +233,11 @@ const T = {
     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',
-    dataFabricCreate: 'core.datafabric.create',
-    dataFabricDelete: 'core.datafabric.delete',
-    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',
@@ -409,7 +422,19 @@ class Graph {
     byId = new Map();
     out = new Map();
     inc = new Map();
+    /**
+     * Edge accounting (#1125): every edge the source carries — walked into by a
+     * construct, or one serialize recreates on its own — is added here as the walk
+     * emits it. What is left at the end has no spelling in the emitted source, so
+     * recompiling would drop it; `droppedEdgesSeg` (at the site) and
+     * `sweepDroppedEdges` (edges no walk reached) say so instead of letting the
+     * round trip lose it silently. The edge counterpart of the node check
+     * (`detachedTopLevelNodes`).
+     */
+    accounted = new Set();
+    edges;
     constructor(nodes, edges) {
+        this.edges = edges;
         for (const n of nodes)
             this.byId.set(n.id, n);
         for (const e of edges) {
@@ -503,147 +528,90 @@ class Graph {
     }
 }
 // ─── Node → step-spec source ──────────────────────────────────────────────────
+/**
+ * A serialized value back as a spec holds it: `=js:` text (bare, or in a
+ * `{ type: 'jsExpression', expression }` object) becomes an `Expr`; anything else
+ * is a literal and stays itself.
+ */
+function specValue(raw) {
+    if (typeof raw === 'string')
+        return raw.startsWith('=js:') ? new Expr(raw.slice(4)) : raw;
+    const o = raw;
+    if (o && typeof o === 'object' && o.type === 'jsExpression' && typeof o.expression === 'string')
+        return new Expr(o.expression);
+    return raw;
+}
+/**
+ * Print a node whose type is registered (flow-node-registry.ts): the node type
+ * deserializes it to its spec and prints the factory call. A node at a version
+ * the type does not register is lifted by its default version's implementation —
+ * as every built-in family lifts any version — and `verClause` omits a
+ * `{ version }` the type does not register, with a warning. `undefined` when the type is not registered, or the node type declines
+ * the node; the caller's branches take it from there.
+ */
+function emitRegisteredSpec(node, imp, inputNames) {
+    const entry = typeof node.type === 'string' ? FLOW_NODE_TYPES.byTypeName(node.type) : undefined;
+    if (!entry)
+        return undefined;
+    const version = String(node.typeVersion ?? '');
+    const impl = (Object.hasOwn(entry.type.versions, version)
+        ? entry.type.versions[version]
+        : entry.type.versions[entry.type.defaultVersion]);
+    const ctx = {
+        nodeId: node.id,
+        expr: specValue,
+        sourceText: unwrapSource,
+        plainValue: unwrapPlain,
+        stepName: (nodeId) => nodeId,
+        definition: () => runDefs.get(`${node.type}@${version}`) ?? runDefs.get(node.type),
+        warn: warnOnce,
+    };
+    const spec = impl.deserialize(node, ctx);
+    if (spec === undefined)
+        return undefined;
+    // A spec value as source, recursing into arrays and plain objects so an Expr
+    // nested in one (a filter row's value) prints as the helper an author writes —
+    // in the `{ k: v }` / `[a, b]` spelling the hand-written printers use.
+    const printValue = (v) => {
+        if (v instanceof Expr)
+            return v.literal ? tsLiteral(v.value) : emitRef(v.js, imp, inputNames);
+        if (Array.isArray(v))
+            return `[${v.map(printValue).join(', ')}]`;
+        if (v && typeof v === 'object') {
+            const parts = Object.entries(v).filter(([, x]) => x !== undefined).map(([k, x]) => `${key(k)}: ${printValue(x)}`);
+            return parts.length ? `{ ${parts.join(', ')} }` : '{}';
+        }
+        return tsLiteral(v);
+    };
+    const print = {
+        value: printValue,
+        string: (t) => tsLiteral(t),
+        json: (v) => tsLiteral(v),
+        key: (k) => key(k),
+        helper: (name) => imp.use(name),
+    };
+    const call = impl.print?.(spec, print) ?? {
+        factory: impl.factory,
+        options: Object.entries(spec.inputs ?? {})
+            .map(([k, v]) => [k, v === undefined ? undefined : print.value(v)]),
+    };
+    const options = opts((call.options ?? []).map(([k, v]) => [k, v]));
+    const args = [...(call.positional ?? []), ...(options ? [options] : [])];
+    return `${imp.use(call.factory)}(${args.join(', ')})`;
+}
 /**
  * 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) {
+    // A registered node type lifts itself; every other type falls through to the
+    // branches below until its family is ported (FB014's pins are the list).
+    const lifted = emitRegisteredSpec(node, imp, inputNames);
+    if (lifted !== undefined)
+        return lifted;
     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', tsLiteral(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', tsLiteral(until)]])})`;
-            }
-            const duration = inputs.timerPreset === 'custom'
-                ? (typeof inputs.timerValue === 'string' ? inputs.timerValue : '')
-                : (typeof inputs.timerPreset === 'string' ? inputs.timerPreset : '');
-            return `${imp.use('delay')}(${opts([['duration', tsLiteral(duration)]])})`;
-        }
-        case T.documentClassify:
-        case T.dynamicExtract: {
-            const fr = unwrapSource(inputs.fileRef) ?? '';
-            const fileSrc = fr.startsWith('=js:') ? emitBareExpr(fr.slice(4), imp, inputNames) : tsLiteral(fr);
-            const pageRange = typeof inputs.pageRange === 'string' && inputs.pageRange !== '' ? tsLiteral(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 ? tsLiteral(inputs.schemaDocument) : undefined;
-            return `${imp.use('dynamicExtract')}(${opts([
-                ['fileRef', fileSrc],
-                ['schema', schema],
-                ['pageRange', pageRange],
-            ])})`;
-        }
-        case T.dataFabricRead:
-        case T.dataFabricCreate:
-        case T.dataFabricUpdate:
-        case T.dataFabricDelete: {
-            const cfg = (inputs.entityConfig ?? {});
-            const entity = tsText(cfg.entityName);
-            const folder = typeof cfg._folderKey === 'string' ? tsLiteral(cfg._folderKey) : undefined;
-            const resourceKey = typeof cfg._resourceKey === 'string' ? tsLiteral(cfg._resourceKey) : undefined;
-            const val = (v) => {
-                // 1.3 let `recordId` and a create's field value be a `{ type:
-                // 'jsExpression', expression }` object as well as a `=js:` string. A
-                // product-authored node can carry either; both recover as an expression.
-                const obj = v;
-                if (obj && typeof obj === 'object' && obj.type === 'jsExpression') {
-                    return emitBareExpr(String(obj.expression ?? ''), imp, inputNames);
-                }
-                const raw = typeof v === 'string' ? v : String(v ?? '');
-                return raw.startsWith('=js:') ? emitBareExpr(raw.slice(4), imp, inputNames) : tsLiteral(raw);
-            };
-            const fieldObject = (rows) => {
-                const list = Array.isArray(rows) ? rows : [];
-                return `{ ${list.map((r) => `${key(String(r.field ?? ''))}: ${val(r.value)}`).join(', ')} }`;
-            };
-            const record = cfg.recordSource === 'fromRead'
-                ? `{ fromRead: ${tsText(cfg.readEntityNodeId)} }`
-                : `{ byId: ${val(cfg.recordId)} }`;
-            if (node.type === T.dataFabricRead) {
-                // The array is what the platform serializer reads and what compile
-                // writes; the grouped object is the newer authoring shape, tolerated
-                // here so a canvas-authored file still decompiles. Both flatten to the
-                // builder's row list, where `or: true` marks each new OR alternative.
-                const filterRow = (r, or = false) => opts([
-                    ['field', tsText(r.field)],
-                    ['operator', r.operator !== undefined && r.operator !== '=' ? tsLiteral(String(r.operator)) : undefined],
-                    ['value', val(r.value)],
-                    ['or', or ? 'true' : undefined],
-                ]);
-                const q = cfg._filters;
-                let rows = [];
-                if (Array.isArray(q)) {
-                    rows = q.map((r, i) => filterRow(r, i > 0 && r['join'] === 'OR'));
-                }
-                else if (q && typeof q === 'object') {
-                    // Grouped: each root row and each group is one alternative, so every
-                    // one but the first opens with `or: true`.
-                    const alts = [
-                        ...(Array.isArray(q.rows) ? q.rows.map((r) => [r]) : []),
-                        ...(Array.isArray(q.groups) ? q.groups : [])
-                            .map((g) => (Array.isArray(g.rows) ? g.rows : [])),
-                    ].filter((a) => a.length);
-                    rows = alts.flatMap((alt, ai) => alt.map((r, ri) => filterRow(r, ai > 0 && ri === 0)));
-                }
-                const filters = rows.length ? `[${rows.join(', ')}]` : undefined;
-                // `resultMode` only exists from 1.4, and recovering it re-selects 1.4 on
-                // the way back out — so a 1.0 node stays a 1.0 node through the round trip.
-                const mode = cfg.resultMode === 'single' || cfg.resultMode === 'multiple'
-                    ? tsLiteral(cfg.resultMode) : undefined;
-                const sort = cfg._sort && typeof cfg._sort === 'object'
-                    ? opts([
-                        ['field', tsText(cfg._sort.field)],
-                        ['direction', cfg._sort.direction === 'desc' ? tsLiteral('desc') : undefined],
-                    ])
-                    : undefined;
-                const fields = Array.isArray(cfg._selectedFieldNames) && cfg._selectedFieldNames.length
-                    ? `[${cfg._selectedFieldNames.map((f) => tsLiteral(String(f))).join(', ')}]`
-                    : undefined;
-                return `${imp.use('dataFabricRead')}(${opts([
-                    ['entity', entity], ['filters', filters], ['resultMode', mode],
-                    ['limit', typeof cfg._recordLimit === 'number' ? String(cfg._recordLimit) : undefined],
-                    ['skip', typeof cfg._skip === 'number' ? String(cfg._skip) : undefined],
-                    ['sort', sort], ['fields', fields],
-                    ['folderKey', folder], ['resourceKey', resourceKey],
-                ])})`;
-            }
-            if (node.type === T.dataFabricCreate) {
-                return `${imp.use('dataFabricCreate')}(${opts([
-                    ['entity', entity], ['values', fieldObject(cfg.fieldValues)], ['folderKey', folder], ['resourceKey', resourceKey],
-                ])})`;
-            }
-            if (node.type === T.dataFabricDelete) {
-                return `${imp.use('dataFabricDelete')}(${opts([
-                    ['entity', entity], ['record', record], ['folderKey', folder], ['resourceKey', resourceKey],
-                ])})`;
-            }
-            return `${imp.use('dataFabricUpdate')}(${opts([
-                ['entity', entity], ['record', record], ['set', fieldObject(cfg.fieldUpdates)],
-                ['folderKey', folder], ['resourceKey', resourceKey],
-            ])})`;
-        }
         case T.createOutgoingCall:
         case T.endCall: {
             const i = (node.inputs ?? {});
@@ -766,8 +734,6 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
         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.')) {
@@ -823,49 +789,6 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
             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, tsLiteral(v.type)]);
-        if (entries.length > 0)
-            return [['returns', opts(entries)]];
-    }
-    return [['returns', tsLiteral(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)));
-}
 /**
  * Invert an HTTP node. The plain node (`core.action.http`) keeps its request at
  * the top level (`url` / `method` / `headers` / `queryParams` / `body` /
@@ -897,7 +820,7 @@ function emitHttp(node, managed, imp, inputNames) {
     const branchesSrc = branchRows.length
         ? `[${branchRows.map((b) => {
             const cond = unwrapSource(b.conditionExpression) ?? '';
-            const expr = emitBareExpr(cond.startsWith('=js:') ? cond.slice(4) : cond, imp, inputNames);
+            const expr = emitBareExpr(wireExprBody(cond), imp, inputNames);
             return `{ name: ${tsText(b.name ?? b.id)}, condition: ${expr} }`;
         }).join(', ')}]`
         : undefined;
@@ -926,68 +849,6 @@ function emitHttp(node, managed, imp, inputNames) {
     ]);
     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', tsLiteral(f.field)],
-                ['condition', tsLiteral(f.condition)],
-                ...(f.value !== undefined ? [['value', tsLiteral(f.value)]] : []),
-            ]));
-            return objLit([
-                ['type', tsLiteral('filter')],
-                ...(cfg.operation !== undefined ? [['operation', tsLiteral(cfg.operation)]] : []),
-                ['filters', `[${filters.join(', ')}]`],
-            ]);
-        }
-        if (op?.type === 'map') {
-            const mappings = (cfg.mappings ?? []).map((m) => objLit([
-                ['field', tsLiteral(m.field)],
-                ...(m.transformation && m.transformation !== 'copy' ? [['transformation', tsLiteral(m.transformation)]] : []),
-                ...(m.renameTo ? [['renameTo', tsLiteral(m.renameTo)]] : []),
-            ]));
-            return objLit([
-                ['type', tsLiteral('map')],
-                ...(cfg.keepOriginalFields ? [['keepOriginalFields', boolLit(cfg.keepOriginalFields)]] : []),
-                ['mappings', `[${mappings.join(', ')}]`],
-            ]);
-        }
-        // groupBy
-        const aggs = (cfg.aggregations ?? []).map((a) => objLit([
-            ['operation', tsLiteral(a.operation)],
-            ['alias', tsLiteral(a.alias)],
-            ...(a.field ? [['field', tsLiteral(a.field)]] : []),
-        ]));
-        return objLit([
-            ['type', tsLiteral('groupBy')],
-            ['groupByField', tsLiteral(cfg.groupByField)],
-            ['aggregations', `[${aggs.join(', ')}]`],
-        ]);
-    });
-    const spec = opts([
-        ['collection', collection],
-        ['variant', variant ? tsLiteral(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`.
@@ -1117,6 +978,72 @@ function sidecarAgentInputs(node) {
         ...(isVoice && settings.voice && typeof settings.voice === 'object' ? { voice: settings.voice } : {}),
     };
 }
+/**
+ * Where a context-index resource node keeps its identity, read in the order
+ * that holds for every writer.
+ *
+ * SDK compile writes `indexId` / `indexName` / `folderPath` onto the node. The
+ * canvas and the CLI do not: their node carries only `inputs.source`, and the
+ * identity lives in two other places.
+ *
+ *  - The node TYPE, `…context.index.<slug>.<uuid>`: the uuid is the index id
+ *    (the `ContextIndexRef.id` JSDoc says to read it there).
+ *  - The resource sidecar `<agent source>/resources/<inputs.source>/resource.json`,
+ *    whose `name` is the index's real name (the one the slug is made from) and
+ *    whose `folderPath` is its folder. `display.label` is only what the canvas
+ *    shows, and a canvas rename changes it.
+ *
+ * So the id comes from the type (then `inputs.indexId`). The name is the first
+ * of `inputs.indexName`, sidecar `name`, sidecar `indexName`, label that slugs to
+ * the type's slug, else the first one present in that order. Compile derives
+ * the type from `slug(name)` + id, so when the chosen name does not slug back to
+ * the type's slug the recompiled node gets a different type, and that is warned.
+ */
+function contextIndexIdentity(agent, c, rPlain) {
+    const fromType = parseContextIndexType(c.type);
+    const sidecar = contextResourceSidecar(agent, c);
+    const sidecarText = (k) => typeof sidecar?.[k] === 'string' && sidecar[k] !== '' ? sidecar[k] : undefined;
+    const label = typeof c.display?.label === 'string' && c.display.label !== '' ? c.display.label : undefined;
+    // The canvas can set both sidecar `name` and `indexName`, and they can differ.
+    // The one that slugs to the type's slug is the one the type was built from, so
+    // it wins; the fixed order is the fallback when none matches.
+    const candidates = [rPlain(c, 'indexName'), sidecarText('name'), sidecarText('indexName'), label]
+        .filter((n) => n !== undefined);
+    const name = (fromType?.slug ? candidates.find((n) => contextIndexSlug(n) === fromType.slug) : undefined)
+        ?? candidates[0] ?? '';
+    const id = (fromType?.id || undefined) ?? rPlain(c, 'indexId') ?? '';
+    if (fromType !== undefined && fromType.slug !== '' && contextIndexSlug(name) !== fromType.slug) {
+        warnOnce(`context index "${c.id}" on agent "${agent.id}": its node type names the index "${fromType.slug}", `
+            + `but the name decompile recovered, ${JSON.stringify(name)}, slugs to "${contextIndexSlug(name)}", so compile `
+            + `will write a different node type. Set \`name\` to the index's real name`
+            + (sidecar === undefined ? ', or keep the resources/ folder beside the .flow so decompile can read it.' : '.'));
+    }
+    return { name, id, folderPath: rPlain(c, 'folderPath') ?? sidecarText('folderPath') };
+}
+/**
+ * A context resource's `resource.json` sidecar, parsed; `undefined` when it is
+ * not beside the `.flow`, or (with a warning) when it is not a JSON object.
+ */
+function contextResourceSidecar(agent, c) {
+    const agentSource = unwrapSource(agent.inputs?.source);
+    const resourceSource = unwrapSource(c.inputs?.source);
+    if (!agentSource || !resourceSource)
+        return undefined;
+    const path = `${agentSource}/resources/${resourceSource}/resource.json`;
+    const raw = runReadSidecar?.(path);
+    if (raw === undefined)
+        return undefined;
+    try {
+        const json = JSON.parse(raw);
+        if (json && typeof json === 'object' && !Array.isArray(json))
+            return json;
+    }
+    catch {
+        // Reported below with the non-object case.
+    }
+    warnOnce(`context index "${c.id}": ${path} is not valid JSON, so its name and folder decompile from the node.`);
+    return undefined;
+}
 /**
  * An AGENT and its attached resources — the inline autonomous agent, the
  * conversational agent, and the voice agent.
@@ -1170,18 +1097,47 @@ function emitAgentCluster(node, imp, inputNames, graph) {
         .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)];
+        return [r.flatName, emitBareExpr(wireExprBody(r.binding), imp, inputNames)];
     });
     const outVars = (Array.isArray(i.agentOutputVariables) ? i.agentOutputVariables : []);
     const returns = outVars.length
         ? objLit(outVars.map((v) => [String(v.id ?? ''), tsLiteral(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);
+    // The resources, from the agent's own artifact edges. Each edge read here is
+    // carried by the agent spec (edge accounting, #1125); `limit` is for a port
+    // the spec carries only one resource on.
+    const resource = (port, limit = Infinity) => {
+        const found = [];
+        for (const e of graph?.outEdges(node.id) ?? []) {
+            if (e.sourcePort !== port || found.length >= limit)
+                continue;
+            const n = graph.byId.get(e.targetNodeId);
+            if (n === undefined)
+                continue;
+            graph.accounted.add(e);
+            found.push(n);
+        }
+        return found;
+    };
+    // Record what compile will call each folded resource node. Serialize mints
+    // `uid(scope, \`${step.name}<Kind>\`)` per resource, in spec order, and the
+    // spec order is this edge order: the first is `<agent><Kind>`, the n-th
+    // `<agent><Kind><n>` (claimId's dedupe). Only the first memory is recovered,
+    // so every further memory maps to `undefined`.
+    // This reads the edges directly, not through `resource()`: it must see EVERY
+    // artifact edge, including ones the spec does not carry, and it must not
+    // account for any edge.
+    for (const [port, kind, emittedCount] of [
+        ['context', 'Context', Infinity], ['tool', 'Tool', Infinity],
+        ['escalation', 'Escalation', Infinity], ['memory', 'Memory', 1],
+    ]) {
+        const base = `${node.id}${kind}`.replace(/[^A-Za-z0-9_]/g, '_');
+        (graph?.outEdges(node.id) ?? [])
+            .filter((e) => e.sourcePort === port && graph.byId.has(e.targetNodeId))
+            .forEach((e, k) => {
+            runAbsorbed.set(e.targetNodeId, k >= emittedCount ? undefined : k === 0 ? base : `${base}${k + 1}`);
+        });
+    }
     const rInputs = (n) => (n.inputs ?? {});
     const rPlain = (n, k) => {
         const raw = unwrapSource(rInputs(n)[k]);
@@ -1292,10 +1248,11 @@ function emitAgentCluster(node, imp, inputNames, graph) {
             : typeof q?.textValue === 'string' && q.textValue !== '' ? q.textValue
                 : typeof q === 'string' && q !== '' ? q
                     : undefined;
+        const { name, id, folderPath } = contextIndexIdentity(node, c, rPlain);
         return opts([
-            ['name', tsLiteral(rPlain(c, 'indexName') ?? String(c.display?.label ?? ''))],
-            ['id', tsLiteral(rPlain(c, 'indexId') ?? '')],
-            ['folderPath', rPlain(c, 'folderPath') !== undefined ? tsLiteral(rPlain(c, 'folderPath')) : undefined],
+            ['name', tsLiteral(name)],
+            ['id', tsLiteral(id)],
+            ['folderPath', folderPath !== undefined ? tsLiteral(folderPath) : undefined],
             ['folderKey', rPlain(c, 'folderKey') !== undefined ? tsLiteral(rPlain(c, 'folderKey')) : undefined],
             ['query', queryText !== undefined ? tsLiteral(queryText) : undefined],
         ]);
@@ -1318,7 +1275,7 @@ function emitAgentCluster(node, imp, inputNames, graph) {
             ['description', rPlain(e, 'description') !== undefined ? tsLiteral(rPlain(e, 'description')) : undefined],
             ['fields', rows.length ? `[${rows.map((f) => opts([
                     ['id', tsText(f.id)],
-                    ['type', tsLiteral(String(f.type ?? 'text'))],
+                    ['type', tsLiteral(sdkFormFieldType(f.type ?? 'text') ?? String(f.type))],
                     ['direction', tsLiteral(String(f.direction ?? 'output'))],
                 ])).join(', ')}]` : undefined],
             ['app', app === undefined ? undefined : opts([
@@ -1333,7 +1290,7 @@ function emitAgentCluster(node, imp, inputNames, graph) {
             ['priority', typeof extra.priority === 'string' && extra.priority !== 'medium' ? tsLiteral(extra.priority) : undefined],
         ]);
     });
-    const mem = resource('memory')[0];
+    const mem = resource('memory', 1)[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);
@@ -1368,8 +1325,9 @@ function emitAgentCluster(node, imp, inputNames, graph) {
             ['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) : tsLiteral(js);
+                    const js = wireExprBody(raw);
+                    // Anything but a `$vars.` reference stays the wire text verbatim.
+                    return js.startsWith('$vars.') ? emitBareExpr(js, imp, inputNames) : tsLiteral(raw);
                 })()],
             ['voice', voiceSrc],
             ['maxIterations', num(i.maxIterations)],
@@ -1471,7 +1429,7 @@ function emitHitl(node, imp, inputNames, graph) {
         const raw = plain(v);
         if (raw === undefined)
             return undefined;
-        const js = raw.startsWith('=js:') ? raw.slice(4) : raw;
+        const js = wireExprBody(raw);
         return emitBareExpr(js.startsWith('vars.') ? `$${js}` : js, imp, inputNames);
     };
     const rows = (Array.isArray(schema.fields) ? schema.fields : []);
@@ -1482,17 +1440,29 @@ function emitHitl(node, imp, inputNames, graph) {
             ['id', tsLiteral(id)],
             // serialize defaults a row's label to its id.
             ['label', typeof f.label === 'string' && f.label !== id ? tsLiteral(f.label) : undefined],
-            ['type', tsLiteral(String(f.type ?? 'text'))],
+            // The product's own spelling (`"string"`, `"datetime"`, …) → the SDK's (#1143).
+            ['type', tsLiteral(sdkFormFieldType(f.type ?? 'text') ?? String(f.type))],
             ['direction', tsLiteral(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 outcomes = outcomeRows.map((o, idx) => {
         const name = String(o.name ?? '');
-        // A bare string is the shorthand; only `action: 'End'` needs the object.
-        return o.action === 'End' ? opts([['name', tsLiteral(name)], ['action', tsLiteral('End')]]) : tsLiteral(name);
+        // The file's id comes back only when serialize would not derive it from the
+        // name: a designer-drawn task's ids (`outcome-1778015958049`) are not slugs,
+        // and merge keeps the ORIGINAL node, so recompiled edges must use its ids
+        // (#1130). An SDK-written task's ids are slugs and stay implicit.
+        const id = typeof o.id === 'string' && o.id !== '' && o.id !== outcomeSlug(name, idx) ? o.id : undefined;
+        // A bare string is the shorthand; `action: 'End'` or a kept id needs the object.
+        return o.action === 'End' || id !== undefined
+            ? opts([
+                ['name', tsLiteral(name)],
+                ['action', o.action === 'End' ? tsLiteral('End') : undefined],
+                ['id', id !== undefined ? tsLiteral(id) : undefined],
+            ])
+            : tsLiteral(name);
     });
     // Delivery: only an override comes back. The definition's own default is what
     // serialize emits when the author wrote nothing.
@@ -1523,7 +1493,7 @@ function emitHitl(node, imp, inputNames, graph) {
     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) : tsLiteral(raw)];
+        return [k, raw.startsWith('=') ? emitBareExpr(wireExprBody(raw), imp, inputNames) : tsLiteral(raw)];
     }));
     const appSrc = app === undefined ? undefined : opts([
         // `displayName` is serialize's echo of `name`; only `name` is authored.
@@ -1534,13 +1504,14 @@ function emitHitl(node, imp, inputNames, graph) {
                 : typeof app.appSystemName === 'string' ? tsLiteral(app.appSystemName) : undefined],
         ['inputs', appInputs],
     ]);
-    // The validation station's own inputs ride as PLAIN `$vars.…` paths.
+    // The validation station's own inputs ride as PLAIN `$vars.…` paths. Anything
+    // but a `$vars.` reference stays the wire text verbatim.
     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) : tsLiteral(js);
+        const js = wireExprBody(raw);
+        return js.startsWith('$vars.') ? emitBareExpr(js, imp, inputNames) : tsLiteral(raw);
     };
     const render = plain(i.validationRenderType);
     const documentSrc = node.type !== T.hitlDocValidation ? undefined : opts([
@@ -2018,7 +1989,7 @@ function scopeSucc(graph, id, scope) {
  * a fork. Returns a map from node id → its ipdom (`EXIT` when its only join is
  * the scope exit).
  */
-function postDominators(entry, scope, graph) {
+function postDominators(entry, scope, graph, container) {
     // Forward successors within scope (EXIT for terminals / scope-exits), over the
     // subgraph reachable from `entry`.
     const succ = new Map();
@@ -2032,7 +2003,13 @@ function postDominators(entry, scope, graph) {
             continue;
         seen.add(n);
         const s = scopeSucc(graph, n, scope);
-        const ss = s.length ? s : [EXIT];
+        // An edge back into the enclosing container (`continue` / `break` /
+        // `loopBack`) leaves the body: it is a path to EXIT like a terminal is, so
+        // a branch with one empty arm does not "reconverge" at the other arm's
+        // first step.
+        const leaves = container !== undefined
+            && graph.successorEdges(n).some((e) => e.targetNodeId === container);
+        const ss = s.length === 0 ? [EXIT] : leaves ? [...s, EXIT] : s;
         succ.set(n, ss);
         for (const t of ss) {
             addP(n, t);
@@ -2091,9 +2068,164 @@ function postDominators(entry, scope, graph) {
     }
     return ipdom;
 }
-/** The target of the first out-edge of `id` on port `port` (in the whole graph). */
+/**
+ * The target of `id`'s first edge on `port`. Every caller walks into what it
+ * returns, so the edge counts as emitted (edge accounting, #1125). A second edge
+ * on the same port is not carried and stays unaccounted.
+ */
 function portTarget(graph, id, port) {
-    return graph.outEdges(id).find((e) => e.sourcePort === port)?.targetNodeId;
+    const edge = graph.outEdges(id).find((e) => e.sourcePort === port);
+    if (edge)
+        graph.accounted.add(edge);
+    return edge?.targetNodeId;
+}
+/** `id`'s first edge on `port`, for a caller that walks it with `edgeRegion`. */
+function portEdge(graph, id, port) {
+    return graph.outEdges(id).find((e) => e.sourcePort === port);
+}
+/**
+ * The region an arm, handler or port list starts with `edge` — accounting for
+ * the edge (#1125). An edge straight back into the enclosing container (an empty
+ * arm inside a loop body, wired to the container's `continue`) is no region at all,
+ * not `.stepToRef(<container>)`, which compiles to the container's `input` port
+ * and re-enters the loop. On the body's main path that edge is one serialize
+ * recreates for an empty arm; on a side path (`refInto` set: a handler, a port
+ * list, an arm inside one) it is `.continue()`. An edge straight to the
+ * container's `break` handle is `.break()`.
+ */
+function edgeRegion(edge, stop, scope, ipdom, ctx, refInto) {
+    if (edge === undefined)
+        return [];
+    if (ctx.breakInto !== undefined && edge.targetNodeId === ctx.breakInto) {
+        // An arm that breaks straight away: `.break()` on its own recreates the edge.
+        if (edge.targetPort === 'break') {
+            ctx.graph.accounted.add(edge);
+            return ['.break()'];
+        }
+        if (edge.targetPort === 'continue' || edge.targetPort === 'loopBack') {
+            ctx.graph.accounted.add(edge);
+            return refInto === undefined ? [] : ['.continue()'];
+        }
+        return [];
+    }
+    ctx.graph.accounted.add(edge);
+    return region(edge.targetNodeId, stop, scope, ipdom, ctx, refInto);
+}
+/** Account for the successor edges of `from` that a walk followed to `to` (#1125). */
+function follow(graph, from, to) {
+    if (to === undefined)
+        return undefined;
+    for (const e of graph.successorEdges(from)) {
+        if (e.targetNodeId === to && e.targetPort !== 'loopBack')
+            graph.accounted.add(e);
+    }
+    return to;
+}
+/**
+ * Account for the edges serialize recreates on its own when `node` ends a path:
+ * a loop or do-while body tail on the MAIN path of the body goes back to the
+ * container's `continue` handle (`loopBack` on a 1.0 loop) without any source
+ * spelling it. A tail on a side path — an `.onError` handler, an HTTP branch,
+ * a non-primary outcome (`refInto` set) — does NOT: serialize caps it with an
+ * End of its own, so its edge into the container is left unaccounted.
+ */
+function accountImplicitTail(node, ctx, refInto) {
+    if (ctx.breakInto === undefined || refInto !== undefined)
+        return;
+    for (const e of ctx.graph.outEdges(node.id)) {
+        if (e.targetNodeId === ctx.breakInto && (e.targetPort === 'continue' || e.targetPort === 'loopBack')) {
+            ctx.graph.accounted.add(e);
+        }
+    }
+}
+/**
+ * Where the walk goes after `from` leaves on `port` — a container's `success`,
+ * a join's `output`. That edge can lead straight back into the ENCLOSING
+ * container (the body's tail: `inner@success -> outer@continue`). Walking into
+ * the container would emit `.stepToRef(<container>)`, which compiles to its
+ * `input` port and re-enters the loop, so it ends the path instead:
+ *
+ *  - into `<container>@break`: `{ brk: true }`, the caller emits `.break()`;
+ *  - into `<container>@continue` / `@loopBack`: on the main path no cursor,
+ *    and the edge is one serialize recreates (`accountImplicitTail`); on a
+ *    side path `{ cont: true }`, the caller emits `.continue()`;
+ *  - anything else: the target, with the edge accounted (as `portTarget`).
+ */
+function continueOn(from, port, ctx, refInto) {
+    const edge = portEdge(ctx.graph, from.id, port);
+    if (edge !== undefined && ctx.breakInto !== undefined && edge.targetNodeId === ctx.breakInto) {
+        if (edge.targetPort === 'break') {
+            ctx.graph.accounted.add(edge);
+            return { brk: true };
+        }
+        if (edge.targetPort === 'continue' || edge.targetPort === 'loopBack') {
+            if (refInto !== undefined) {
+                // A side path has no implicit tail: it goes on with `.continue()`.
+                ctx.graph.accounted.add(edge);
+                return { cont: true };
+            }
+            accountImplicitTail(from, ctx, refInto);
+            return {};
+        }
+    }
+    if (edge === undefined) {
+        accountImplicitTail(from, ctx, refInto);
+        return {};
+    }
+    ctx.graph.accounted.add(edge);
+    return { cursor: edge.targetNodeId };
+}
+/** `<source>@<port> -> <target>@<port>` — how an edge is named in a message. */
+function edgeName(e) {
+    return `${e.sourceNodeId ?? '?'}@${e.sourcePort ?? '?'} -> ${e.targetNodeId ?? '?'}@${e.targetPort ?? '?'}`;
+}
+/** The edges this run could not carry into the source, for the strict-mode refusal. */
+let runDropped = [];
+/** The warning for an edge with no spelling in the emitted source. */
+function droppedEdgeMessage(e) {
+    return `edge ${edgeName(e)} has no spelling in the decompiled source, so recompiling drops it `
+        + '(and merge writes that loss into the original). If this edge matters to your edit, '
+        + 'change the .flow JSON directly instead of round-tripping it through the source.';
+}
+/**
+ * The out-edges of `node` that nothing emitted for it accounts for — called
+ * once the walk has finished with the node, so every construct it heads has had
+ * its chance to claim them. Each is warned once, remembered for strict mode,
+ * and returned as a `/* TODO *\/` segment for the site.
+ */
+function droppedEdgesSeg(node, ctx) {
+    const dropped = ctx.graph.outEdges(node.id).filter((e) => !ctx.graph.accounted.has(e));
+    if (dropped.length === 0)
+        return undefined;
+    for (const e of dropped) {
+        ctx.graph.accounted.add(e);
+        runDropped.push(e);
+        warnOnce(droppedEdgeMessage(e));
+    }
+    return `/* TODO: ${commentText(`edge(s) ${dropped.map(edgeName).join(', ')} are NOT in this source; recompiling drops them.`)} */`;
+}
+/** Push `node`'s dropped-edge marker (if any) onto `segs`. */
+function flagDropped(node, ctx, segs) {
+    const seg = droppedEdgesSeg(node, ctx);
+    if (seg !== undefined)
+        segs.push(seg);
+}
+/**
+ * The edges no walk reached at all (their source was never emitted, typically
+ * because the only path to it was itself dropped), as `// TODO` lines. Edges on
+ * a detached node are left out: node accounting already reported that node.
+ */
+function sweepDroppedEdges(graph, skip) {
+    const lines = [];
+    for (const e of graph.edges) {
+        if (graph.accounted.has(e) || skip.has(e.sourceNodeId) || skip.has(e.targetNodeId))
+            continue;
+        graph.accounted.add(e);
+        runDropped.push(e);
+        warnOnce(droppedEdgeMessage(e));
+        lines.push(`// TODO: ${commentText(`edge ${edgeName(e)} is NOT in this source; recompiling drops it.`)}`);
+    }
+    return lines;
 }
 /** Re-indent every non-empty line of a (possibly multi-line) segment by `pad`. */
 function reindent(seg, pad) {
@@ -2194,7 +2326,7 @@ function errorHandlerSeg(nodeId, succ, scope, ipdom, ctx) {
     if (!errEdge)
         return undefined;
     const mainReach = forwardReach(succ, scope, ctx.graph);
-    const handlerSegs = region(errEdge.targetNodeId, EXIT, scope, ipdom, ctx, mainReach);
+    const handlerSegs = edgeRegion(errEdge, EXIT, scope, ipdom, ctx, mainReach);
     if (handlerSegs.length === 0)
         handlerSegs.push('.return({})');
     return `.onError(${armCb('h', handlerSegs)})`;
@@ -2229,34 +2361,45 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
         ctx.emitted.add(cursor);
         if (node.type === T.end) {
             segs.push(returnSeg(node, ctx));
+            flagDropped(node, ctx, segs);
             return segs;
         }
         if (node.type === T.terminate) {
             segs.push(`.terminate(${tsLiteral(node.id)}, undefined${optsArg(node, ctx)})`);
+            flagDropped(node, ctx, segs);
             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');
+            const next = continueOn(node, 'output', ctx, refInto);
+            if (next.brk || next.cont) {
+                segs.push(next.brk ? '.break()' : '.continue()');
+                flagDropped(node, ctx, segs);
+                return segs;
+            }
+            cursor = next.cursor;
+            flagDropped(node, ctx, segs);
             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 thenSegs = edgeRegion(portEdge(ctx.graph, node.id, 'true'), r, scope, ipdom, ctx, refInto);
+            const elseSegs = edgeRegion(portEdge(ctx.graph, node.id, 'false'), r, scope, ipdom, ctx, refInto);
             const labels = armLabels(node);
             if (labels.trueLabel)
                 thenSegs.unshift(`.label(${tsLiteral(labels.trueLabel)})`);
             if (labels.falseLabel)
                 elseSegs.unshift(`.label(${tsLiteral(labels.falseLabel)})`);
             segs.push(`.branch(${tsLiteral(node.id)}, ${cond},\n${reindent(armCb('t', thenSegs), '  ')},\n${reindent(armCb('e', elseSegs), '  ')}${verArg(node)})`);
+            flagDropped(node, ctx, segs);
             cursor = r === EXIT ? undefined : r;
             continue;
         }
         if (node.type === T.switch) {
             segs.push(emitSwitch(node, ipdom, scope, ctx, stop, refInto));
+            flagDropped(node, ctx, segs);
             const r = ipdom.get(node.id) ?? stop;
             cursor = r === EXIT ? undefined : r;
             continue;
@@ -2268,7 +2411,7 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
             // 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 bodyIpdom = bodyEntry ? postDominators(bodyEntry, bodyScope, ctx.graph, node.id) : new Map();
             const prevBreak = ctx.breakInto;
             ctx.breakInto = node.id;
             const bodySegs = region(bodyEntry, EXIT, bodyScope, bodyIpdom, ctx);
@@ -2280,7 +2423,7 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
                     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)}`);
+                    extra.push(`completionCondition: ${emitBareExpr(wireExprBody(completion), ctx.imp, ctx.inputNames)}`);
                 }
             }
             const limit = node.type === T.doWhile ? unwrapPlain(inputs.limit) : undefined;
@@ -2293,14 +2436,14 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
             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)
+                    ? emitBareExpr(wireExprBody(condRaw), ctx.imp, ctx.inputNames)
                     : `${ctx.imp.use('lit')}(true)`;
                 segs.push(`.doWhile(${tsLiteral(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)
+                    ? emitBareExpr(wireExprBody(collRaw), ctx.imp, ctx.inputNames)
                     : `${ctx.imp.use('lit')}([])`;
                 segs.push(`.loop(${tsLiteral(node.id)}, ${collection}, ${armCb('b', bodySegs)}${opts})`);
             }
@@ -2312,12 +2455,22 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
             const containerHandler = errorHandlerSeg(node.id, containerSucc, scope, ipdom, ctx);
             if (containerHandler)
                 segs.push(containerHandler);
-            cursor = portTarget(ctx.graph, node.id, 'success');
+            const next = continueOn(node, 'success', ctx, refInto);
+            if (next.brk || next.cont) {
+                segs.push(next.brk ? '.break()' : '.continue()');
+                flagDropped(node, ctx, segs);
+                return segs;
+            }
+            cursor = next.cursor;
+            flagDropped(node, ctx, segs);
             continue;
         }
         if (node.type === T.subflow) {
             segs.push(`.step(${tsLiteral(node.id)}, ${emitSubflow(node, ctx)}${optsArg(node, ctx)})`);
-            cursor = scopeSucc(ctx.graph, node.id, scope)[0];
+            cursor = follow(ctx.graph, node.id, scopeSucc(ctx.graph, node.id, scope)[0]);
+            if (cursor === undefined)
+                accountImplicitTail(node, ctx, refInto);
+            flagDropped(node, ctx, segs);
             continue;
         }
         // A regular action step (mock / script / http / transform / connector / …).
@@ -2333,11 +2486,12 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
         if (exitPorts && exitPorts.length > 1) {
             const r = ipdom.get(node.id) ?? stop;
             const armSrcs = exitPorts.map(({ value, port }) => {
-                const armSegs = region(portTarget(ctx.graph, node.id, port), r, scope, ipdom, ctx, refInto);
+                const armSegs = edgeRegion(portEdge(ctx.graph, node.id, port), r, scope, ipdom, ctx, refInto);
                 return `{ value: ${tsLiteral(value)}, body: ${armCb('b', armSegs)} }`;
             });
             const armList = `[\n${armSrcs.map((a) => reindent(a, '  ')).join(',\n')},\n]`;
             segs.push(`.stepSwitch(${tsLiteral(node.id)}, ${spec}, ${armList}${optsArg(node, ctx)})`);
+            flagDropped(node, ctx, segs);
             cursor = r === EXIT ? undefined : r;
             continue;
         }
@@ -2352,7 +2506,7 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
         // 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);
+            const branchSegs = edgeRegion(be, EXIT, scope, ipdom, ctx, mainReach);
             if (branchSegs.length === 0)
                 branchSegs.push('.return({})');
             segs.push(`.stepToList(${tsLiteral(be.sourcePort)}, ${armCb('p', branchSegs)})`);
@@ -2362,12 +2516,18 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
         // already a successor (see Graph.primaryOutcomePort).
         // A converged fan-out has none: every outcome continues to the one
         // successor, which is what `.step()` recompiles to.
-        if (!ctx.graph.convergedFanOut(node.id)) {
+        if (ctx.graph.convergedFanOut(node.id)) {
+            // `.step()` with `outcomePorts: false` recompiles every one of these edges.
+            for (const oe of ctx.graph.outEdges(node.id))
+                if (oe.sourcePort.startsWith('outcome-'))
+                    ctx.graph.accounted.add(oe);
+        }
+        else {
             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);
+                const outSegs = edgeRegion(oe, EXIT, scope, ipdom, ctx, mainReach);
                 if (outSegs.length === 0)
                     outSegs.push('.return({})');
                 segs.push(`.stepToList(${tsLiteral(oe.sourcePort)}, ${armCb('p', outSegs)})`);
@@ -2376,30 +2536,64 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
         // 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')) {
+        const breakEdges = ctx.breakInto === undefined
+            ? []
+            : ctx.graph.outEdges(node.id).filter((e) => e.targetNodeId === ctx.breakInto && e.targetPort === 'break');
+        if (breakEdges.length > 0) {
+            for (const be of breakEdges)
+                ctx.graph.accounted.add(be);
             segs.push('.break()');
+            flagDropped(node, ctx, segs);
+            return segs;
+        }
+        // A SIDE-path edge into the container's continue handle (an `.onError`
+        // handler, an HTTP branch or outcome list that goes on to the next item):
+        // `.continue()`. On the body's main path the same edge is the one every body
+        // tail gets, so it stays implicit there.
+        const continueEdges = ctx.breakInto === undefined || refInto === undefined
+            ? []
+            : ctx.graph.outEdges(node.id).filter((e) => e.targetNodeId === ctx.breakInto
+                && (e.targetPort === 'continue' || e.targetPort === 'loopBack'));
+        if (continueEdges.length > 0) {
+            for (const ce of continueEdges)
+                ctx.graph.accounted.add(ce);
+            segs.push('.continue()');
+            flagDropped(node, ctx, segs);
             return segs;
         }
         // Continuation: 0 → terminal; 1 → follow; N same-port → parallel fork.
-        if (succ.length === 0)
+        if (succ.length === 0) {
+            accountImplicitTail(node, ctx, refInto);
+            flagDropped(node, ctx, segs);
             return segs;
+        }
         if (succ.length === 1) {
-            cursor = succ[0];
+            cursor = follow(ctx.graph, node.id, succ[0]);
+            flagDropped(node, ctx, segs);
             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)));
+            const arms = succ.map((t, i) => armCb(`a${i}`, region(follow(ctx.graph, node.id, t), join, scope, ipdom, ctx, refInto)));
             segs.push(`.parallel(${tsLiteral(join)}, [\n${arms.map((a) => reindent(a, '  ')).join(',\n')},\n]${verArg(ctx.graph.byId.get(join))})`);
-            cursor = portTarget(ctx.graph, join, 'output');
+            flagDropped(node, ctx, segs);
+            const next = continueOn(ctx.graph.byId.get(join), 'output', ctx, refInto);
+            if (next.brk || next.cont) {
+                segs.push(next.brk ? '.break()' : '.continue()');
+                return segs;
+            }
+            cursor = next.cursor;
             continue;
         }
-        // Unstructured fan-out we can't fold — best-effort marker.
+        // Unstructured fan-out we can't fold — best-effort marker. Its successor
+        // edges are what the marker reports, so they are not reported twice.
         if (ctx.o.bestEffort === false)
             throw new Error(`decompile: unstructured fan-out at "${node.id}".`);
         segs.push(`/* TODO: unstructured fan-out at ${commentText(node.id)} (${commentText(succ.length)} successors) */`);
+        for (const t of succ)
+            follow(ctx.graph, node.id, t);
+        flagDropped(node, ctx, segs);
         return segs;
     }
     return segs;
@@ -2485,6 +2679,88 @@ function declaredExitsOfNode(node) {
     }
     return undefined;
 }
+/**
+ * Split a switch case expression into `<discriminant> === <literal>`, the only
+ * form `.switch(on, [{ value }])` models. Returns `undefined` for any other
+ * condition, so the caller can refuse it rather than emit a different one:
+ *
+ *  - the split is at the LAST top-level `===` (equality is left-associative,
+ *    so that `===` is the outermost one); `==`, `!==` and `!=` never match;
+ *  - the right side must be one literal: JSON, or a single-quoted string;
+ *  - the left side must hold no top-level operator that binds looser than
+ *    `===` (`&&`, `||`, `??`, `?:`, `&`, `|`, `^`, `,`, `=`, `=>`), since
+ *    `a && b === 1` means `a && (b === 1)`, not `(a && b) === 1`.
+ *
+ * Strings, template literals and bracketed groups are skipped when scanning.
+ */
+function parseSwitchCase(expr) {
+    let depth = 0;
+    let lastEq = -1;
+    const loose = [];
+    for (let i = 0; i < expr.length; i++) {
+        const ch = expr[i];
+        if (ch === '"' || ch === "'" || ch === '`') {
+            for (i++; i < expr.length && expr[i] !== ch; i++)
+                if (expr[i] === '\\')
+                    i++;
+            continue;
+        }
+        if (ch === '(' || ch === '[' || ch === '{') {
+            depth++;
+            continue;
+        }
+        if (ch === ')' || ch === ']' || ch === '}') {
+            depth--;
+            continue;
+        }
+        if (depth !== 0)
+            continue;
+        const two = expr.slice(i, i + 2);
+        if (expr.startsWith('===', i)) {
+            lastEq = i;
+            i += 2;
+        }
+        else if (expr.startsWith('!==', i)) {
+            i += 2;
+        }
+        else if (two === '?.' && !/[0-9]/.test(expr[i + 2] ?? '')) {
+            i += 1; // optional chaining, not a conditional
+        }
+        else if (two === '==' || two === '!=' || two === '<=' || two === '>=') {
+            i += 1;
+        }
+        else if (two === '&&' || two === '||' || two === '??' || two === '=>') {
+            loose.push(i);
+            i += 1;
+        }
+        else if ('?&|^,='.includes(ch)) {
+            loose.push(i);
+        }
+    }
+    if (lastEq < 0)
+        return undefined;
+    const lhs = expr.slice(0, lastEq).trim();
+    const literal = expr.slice(lastEq + 3).trim();
+    if (!lhs || loose.some((at) => at < lastEq))
+        return undefined;
+    try {
+        return { lhs, literal, value: tsLiteral(JSON.parse(literal)) };
+    }
+    catch {
+        const q = literal.match(/^'((?:[^'\\]|\\.)*)'$/);
+        if (!q)
+            return undefined;
+        // The string's value, escapes resolved (`'it\'s'` is `it's`): rewrite it as
+        // a JSON string, which shares JS's escapes except `\'`.
+        const json = `"${q[1].replace(/\\(.)|"/g, (m, c) => (c === undefined ? '\\"' : c === "'" ? "'" : m))}"`;
+        try {
+            return { lhs, literal, value: tsLiteral(JSON.parse(json)) };
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
 /**
  * Emit a `.switch(...)` from a `core.logic.switch` node. Each case's serialized
  * expression is `<discriminant> === <JSON-literal>`; the discriminant (shared by
@@ -2494,62 +2770,74 @@ function declaredExitsOfNode(node) {
 function emitSwitch(node, ipdom, scope, ctx, stop, refInto) {
     const r = ipdom.get(node.id) ?? stop;
     const cases = (node.inputs ?? {}).cases ?? [];
+    let caseIndex = 0;
     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) {
+        const parsed = parseSwitchCase(String(c.expression ?? ''));
+        let value = '0';
+        let valueLiteral = '';
+        if (parsed) {
             if (disc === undefined)
-                disc = lhs;
-            else if (disc !== lhs)
+                disc = parsed.lhs;
+            else if (disc !== parsed.lhs)
                 nonUniform = true;
+            valueLiteral = parsed.literal;
+            value = parsed.value;
         }
         else {
             nonUniform = true;
-        }
-        let value = '0';
-        let valueLiteral = '';
-        if (m) {
-            valueLiteral = m[2].trim();
-            try {
-                value = tsLiteral(JSON.parse(valueLiteral));
-            }
-            catch {
-                // A non-JSON literal (e.g. single-quoted) — strip matching quotes if any.
-                const q = valueLiteral.match(/^'(.*)'$/);
-                value = q ? tsLiteral(q[1]) : tsLiteral(valueLiteral);
+            // Keep the best-effort output the TODO comment points at.
+            const m = String(c.expression ?? '').match(/^(.*?)\s*===?\s*(.*)$/);
+            if (m && m[1].trim() && disc === undefined)
+                disc = m[1].trim();
+            if (m) {
+                valueLiteral = m[2].trim();
+                try {
+                    value = tsLiteral(JSON.parse(valueLiteral));
+                }
+                catch {
+                    const q = valueLiteral.match(/^'(.*)'$/);
+                    value = q ? tsLiteral(q[1]) : tsLiteral(valueLiteral);
+                }
             }
         }
-        else {
-            nonUniform = true;
-        }
-        const armSegs = region(portTarget(ctx.graph, node.id, `case-${c.id}`), r, scope, ipdom, ctx, refInto);
+        const armSegs = edgeRegion(portEdge(ctx.graph, node.id, `case-${c.id}`), r, scope, ipdom, ctx, refInto);
         const defaultLabel = `Case ${valueLiteral}`;
         const labelPart = c.label && c.label !== defaultLabel ? `, label: ${tsLiteral(c.label)}` : '';
-        caseSrcs.push(`{ value: ${value}${labelPart}, body: ${armCb('b', armSegs)} }`);
+        // The file's case id comes back when it is not the positional one serialize
+        // derives (a designer-drawn switch uses `default-1`, …), so the recompiled
+        // edges leave from the ORIGINAL node's handles, which merge keeps (#1130).
+        caseIndex += 1;
+        const idPart = typeof c.id === 'string' && c.id !== '' && c.id !== `case_${caseIndex}` ? `, id: ${tsLiteral(c.id)}` : '';
+        caseSrcs.push(`{ value: ${value}${labelPart}${idPart}, 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 hasDefault = (node.inputs ?? {}).hasDefault === true || portEdge(ctx.graph, node.id, 'default') !== undefined;
     const defArm = hasDefault
-        ? `, ${armCb('d', region(portTarget(ctx.graph, node.id, 'default'), r, scope, ipdom, ctx, refInto))}`
+        ? `, ${armCb('d', edgeRegion(portEdge(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.
+    if (nonUniform) {
+        const listing = cases.map((c) => `${tsLiteral(c.label ?? c.id)}: ${tsLiteral(String(c.expression ?? ''))}`).join(', ');
+        const message = `switch ${tsLiteral(node.id)} has per-case conditions that are not one shared \`<discriminant> === <value>\` `
+            + `(${listing}). \`.switch()\` models only that form, so the decompiled \`on\`/\`value\` are placeholders: `
+            + 'recompiling either fails or changes which case runs. Edit this switch in the .flow JSON directly.';
+        if (runStrict)
+            throw new Error(`decompile: ${message}`);
+        warnOnce(message);
+    }
     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(${tsLiteral(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.
  *
@@ -2617,12 +2905,21 @@ function stickyNotesSeg(nodes, flow) {
  */
 function layoutSeg(flow, nodes, edges) {
     const hoisted = (flow.layout?.nodes ?? {});
+    // A layout key must name a node the recompiled flow will HAVE. A resource
+    // folded into its agent comes back under the id compile mints for it; when
+    // that is not the file's id (a canvas- or CLI-placed resource is named after
+    // its index or tool, not `<agent>Context`), the file's id names nothing and
+    // compile refuses the whole `.layout()`. So its entry, and any edge route that
+    // ends at it, is left out and compile places the node itself.
+    const renamed = (id) => runAbsorbed.has(id) && runAbsorbed.get(id) !== id;
     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;
+        if (renamed(n.id))
+            continue;
         const ui = { ...(n.ui ?? {}), ...(hoisted[n.id] ?? {}) };
         const pos = ui.position;
         if (!pos || typeof pos.x !== 'number' || typeof pos.y !== 'number')
@@ -2659,6 +2956,8 @@ function layoutSeg(flow, nodes, edges) {
         }
         if (!parts.length)
             continue;
+        if (renamed(e.sourceNodeId) || renamed(e.targetNodeId))
+            continue;
         const pair = `${e.sourceNodeId}->${e.targetNodeId}`;
         if ((pairCount.get(pair) ?? 0) !== 1)
             continue; // ambiguous — see the note above
@@ -2721,10 +3020,11 @@ function emitChildFlow(name, child, ctx) {
     // 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 entry = trigger ? follow(childCtx.graph, trigger.id, 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);
+    parts.push(...sweepDroppedEdges(childCtx.graph, new Set()));
     // A subflow carries its own scoped layout, resolved against its own node ids.
     const childNotes = stickyNotesSeg(child.nodes ?? [], child);
     if (childNotes)
@@ -2747,11 +3047,13 @@ export function decompile(flow, options = {}) {
     runWarn = options.warn;
     runReadSidecar = options.readSidecar;
     runWarned = new Set();
+    runDropped = [];
     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 = [];
+    runAbsorbed = new Map();
     for (const d of (flow.definitions ?? [])) {
         if (typeof d?.nodeType !== 'string')
             continue;
@@ -2842,7 +3144,7 @@ export function decompile(flow, options = {}) {
     const ctx = { graph, flow, imp, inputNames, o: options, emitted: new Set(), shared };
     const scope = scopeIds(flow.nodes ?? [], undefined);
     const startId = trigger?.id ?? 'start';
-    const first = scopeSucc(graph, startId, scope)[0];
+    const first = follow(graph, startId, 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
@@ -2855,6 +3157,15 @@ export function decompile(flow, options = {}) {
             continue;
         extraEps.push(entryPointSeg(t, scope, ipdom, ctx));
     }
+    // Edge accounting (#1125): the walk above has claimed every edge it emitted
+    // or that serialize recreates on its own. The rest are not in the source.
+    const unreached = sweepDroppedEdges(graph, detachedIds);
+    for (const line of unreached)
+        e.line(d, line);
+    if (runStrict && runDropped.length > 0) {
+        throw new Error(`decompile: ${runDropped.length} edge(s) have no spelling in the decompiled source, so recompiling would drop them: `
+            + `${runDropped.map(edgeName).join(', ')}.`);
+    }
     const header = e.toString();
     const body = bodySegs.map((s) => reindent(s, '  ')).join('\n');
     const eps = extraEps.map((s) => reindent(s, '  ')).join('\n');
@@ -2925,7 +3236,7 @@ function entryPointSeg(t, scope, ipdom, ctx) {
         optParts.push(`inputs: { ${scoped.map((g) => `${key(g.name ?? g.id)}: ${declExpr(g, true, ctx.imp, sharedOf(g))}`).join(', ')} }`);
     }
     optParts.push(...triggerOptParts(t));
-    const first = scopeSucc(ctx.graph, t.id, scope)[0];
+    const first = follow(ctx.graph, t.id, 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)}` : '';