@uipath/maestro-builder-sdk 6.19.0 → 6.20.1

package/dist/decompile.js

@@ -30,17 +30,21 @@
  */
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { preserveSchemaVersion } from './schema-version.js';
-import { BUNDLED_DEFINITIONS, bundledVersions, hasBundledDefinition } from './flow-definitions.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
@@ -79,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) {
@@ -112,19 +127,33 @@ function verClause(node) {
                 + `the file's definitions[] disagrees with the instance.`);
         }
     }
-    // Decompile preserves the file's pair (design §5.3), but `serialize` resolves an
-    // explicit { version } against the bundle exactly (design §2.6), so a pin the
-    // bundle lacks WILL fail `compile`; saying so here is the difference between a
-    // loop that fails at step 2 with a hint and one that fails with a puzzle.
-    // A registered type resolves against its registered versions, which the bundle
-    // may exceed; every other core type against the bundle.
+    // 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)
-        : node.type.startsWith('core.') && !hasBundledDefinition(node.type, tv) ? bundledVersions(node.type) : undefined;
-    if (shipped && !shipped.includes(tv)) {
-        warnOnce(`node ${tsLiteral(node.id)} pins ${node.type}@${tv}, but this SDK ${registered ? 'registers' : '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.`);
+    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)}`;
 }
@@ -393,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) {
@@ -504,9 +545,8 @@ function specValue(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 today — and keeps its own
- * `{ version }` on the step, which compile then refuses; `verClause` warns at
- * decompile time that it will. `undefined` when the type is not registered, or the node type declines
+ * 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) {
@@ -780,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;
@@ -938,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.
@@ -991,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]);
@@ -1113,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],
         ]);
@@ -1139,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([
@@ -1154,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);
@@ -1189,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)],
@@ -1292,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 : []);
@@ -1303,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.
@@ -1344,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.
@@ -1355,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([
@@ -1839,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();
@@ -1853,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);
@@ -1912,9 +2068,241 @@ 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;
+}
+/** Every out-edge of `id` on port `port`, in edge order. */
+function portEdges(graph, id, port) {
+    return graph.outEdges(id).filter((e) => e.sourcePort === port);
+}
+/** `id`'s successor edges whose target is inside `scope` (the edges `scopeSucc` follows). */
+function scopeSuccEdges(graph, id, scope) {
+    return graph.successorEdges(id).filter((e) => e.targetPort !== 'loopBack' && scope.has(e.targetNodeId));
+}
+/**
+ * The nearest node that post-dominates EVERY one of `targets` — where the paths
+ * that start at them all meet again — or `undefined` when they only meet at the
+ * scope exit. Walks each target's `ipdom` chain (the target itself first).
+ */
+function commonPostDominator(targets, ipdom) {
+    const chain = (t) => {
+        const out = [];
+        for (let n = t; n !== undefined && n !== EXIT && !out.includes(n); n = ipdom.get(n))
+            out.push(n);
+        return out;
+    };
+    const [head, ...rest] = targets.map(chain);
+    const others = rest.map((c) => new Set(c));
+    return head?.find((n) => others.every((c) => c.has(n)));
+}
+/**
+ * The region that starts with `edges`, the edges ONE source port (or a
+ * trigger) has.
+ *
+ * One edge is an ordinary region (`edgeRegion`). Two or more are a fork, which
+ * is what serialize emits for a `.parallel(...)` that is the first thing in a
+ * flow, a subflow, an entry point's prefix or a branch / switch arm: the trigger
+ * (or the arm's port) gets one edge per parallel arm, and the arms meet at the
+ * parallel's merge node. When the targets meet at a merge node the fork
+ * decompiles to that `.parallel(...)`, then the region continues from the
+ * merge's output (flow-builder-sdk#1155).
+ *
+ * Every edge in `edges` is accounted (edge accounting, #1125): the fold
+ * recreates each one. A fork whose arms never meet at a merge node has no
+ * builder spelling. Like the same shape mid-flow (`region`), it throws under
+ * `bestEffort: false`, and otherwise keeps the first arm behind a
+ * `TODO: unstructured fan-out` marker, which is what reports the other edges.
+ */
+function forkRegion(edges, stop, scope, ipdom, ctx, refInto) {
+    if (edges.length <= 1)
+        return edgeRegion(edges[0], stop, scope, ipdom, ctx, refInto);
+    const targets = edges.map((e) => e.targetNodeId);
+    const join = commonPostDominator(targets, ipdom);
+    const joinNode = join !== undefined ? ctx.graph.byId.get(join) : undefined;
+    if (join === undefined || join === stop || joinNode?.type !== T.merge) {
+        if (ctx.o.bestEffort === false)
+            throw new Error(`decompile: unstructured fan-out (${edges.length} edges).`);
+        for (const e of edges)
+            ctx.graph.accounted.add(e);
+        return [
+            `/* TODO: unstructured fan-out (${commentText(edges.length)} edges) */`,
+            ...region(targets[0], stop, scope, ipdom, ctx, refInto),
+        ];
+    }
+    for (const e of edges)
+        ctx.graph.accounted.add(e);
+    const fork = parallelSeg(join, joinNode, targets, scope, ipdom, ctx, refInto);
+    if (fork.next.brk || fork.next.cont)
+        return [fork.seg, fork.next.brk ? '.break()' : '.continue()'];
+    return [fork.seg, ...region(fork.next.cursor, stop, scope, ipdom, ctx, refInto)];
+}
+/**
+ * The `.parallel(join, [arms])` segment for a fork whose `targets` (one per
+ * edge; the caller accounts those edges) meet at the merge node `join`. Each
+ * arm is the region up to `join`. `next` is where the walk goes after the
+ * merge: its `output` edge, accounted by `continueOn` (`brk` / `cont` when
+ * that edge leaves through the enclosing loop's `break` / spelled `continue`).
+ */
+function parallelSeg(join, joinNode, targets, scope, ipdom, ctx, refInto) {
+    const arms = targets.map((t, i) => armCb(`a${i}`, region(t, join, scope, ipdom, ctx, refInto)));
+    const seg = `.parallel(${tsLiteral(join)}, [\n${arms.map((a) => reindent(a, '  ')).join(',\n')},\n]${verArg(joinNode)})`;
+    return { seg, next: continueOn(joinNode, 'output', ctx, refInto) };
 }
 /** Re-indent every non-empty line of a (possibly multi-line) segment by `pad`. */
 function reindent(seg, pad) {
@@ -2015,7 +2403,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)})`;
@@ -2050,34 +2438,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 = forkRegion(portEdges(ctx.graph, node.id, 'true'), r, scope, ipdom, ctx, refInto);
+            const elseSegs = forkRegion(portEdges(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;
@@ -2089,7 +2488,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);
@@ -2101,7 +2500,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;
@@ -2114,14 +2513,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})`);
             }
@@ -2133,12 +2532,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 / …).
@@ -2154,11 +2563,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;
         }
@@ -2173,7 +2583,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)})`);
@@ -2183,12 +2593,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)})`);
@@ -2197,30 +2613,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)));
-            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');
+        const joinNode = join !== undefined ? ctx.graph.byId.get(join) : undefined;
+        if (join && join !== EXIT && joinNode?.type === T.merge) {
+            const fork = parallelSeg(join, joinNode, succ.map((t) => follow(ctx.graph, node.id, t)), scope, ipdom, ctx, refInto);
+            segs.push(fork.seg);
+            flagDropped(node, ctx, segs);
+            if (fork.next.brk || fork.next.cont) {
+                segs.push(fork.next.brk ? '.break()' : '.continue()');
+                return segs;
+            }
+            cursor = fork.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;
@@ -2306,6 +2756,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
@@ -2315,62 +2847,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 = forkRegion(portEdges(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', forkRegion(portEdges(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.
  *
@@ -2438,12 +2982,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')
@@ -2480,6 +3033,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
@@ -2542,10 +3097,13 @@ 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 ipdom = entry ? postDominators(entry, scope, childCtx.graph) : new Map();
-    const bodySegs = entry ? region(entry, EXIT, scope, ipdom, childCtx) : [];
+    const entries = trigger ? scopeSuccEdges(childCtx.graph, trigger.id, scope) : [];
+    const ipdom = entries.length
+        ? postDominators(entries.length > 1 ? trigger.id : entries[0].targetNodeId, scope, childCtx.graph)
+        : new Map();
+    const bodySegs = entries.length ? forkRegion(entries, 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)
@@ -2568,11 +3126,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;
@@ -2663,9 +3223,13 @@ 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 ipdom = first !== undefined ? postDominators(first, scope, graph) : new Map();
-    const bodySegs = first !== undefined ? region(first, EXIT, scope, ipdom, ctx) : [];
+    // Walked from the trigger's successors together: a `.parallel` placed first
+    // gives the trigger one edge per arm (#1155).
+    const firsts = scopeSuccEdges(graph, startId, scope);
+    const ipdom = firsts.length
+        ? postDominators(firsts.length > 1 ? startId : firsts[0].targetNodeId, scope, graph)
+        : new Map();
+    const bodySegs = firsts.length ? forkRegion(firsts, 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
@@ -2676,6 +3240,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');
@@ -2746,8 +3319,11 @@ 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 prefixSegs = first !== undefined ? region(first, EXIT, scope, ipdom, ctx) : [];
+    const firsts = scopeSuccEdges(ctx.graph, t.id, scope);
+    // A prefix that forks needs post-dominators over ITS nodes, which the root's
+    // map (computed from the default trigger) does not cover.
+    const epIpdom = firsts.length > 1 ? postDominators(t.id, scope, ctx.graph) : ipdom;
+    const prefixSegs = firsts.length ? forkRegion(firsts, EXIT, scope, epIpdom, ctx) : [];
     const optArgText = optParts.length ? `, { ${optParts.join(', ')} }` : (prefixSegs.length ? ', undefined' : '');
     const prefix = prefixSegs.length ? `, ${armCb('b', prefixSegs)}` : '';
     return `.entryPoint(${tsLiteral(t.id)}, ${factory}${optArgText}${prefix})`;