@uipath/maestro-builder-sdk 6.20.0 → 6.20.1

package/dist/decompile.js

@@ -2227,6 +2227,83 @@ function sweepDroppedEdges(graph, skip) {
     }
     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) {
     return seg.split('\n').map((l) => (l === '' ? l : pad + l)).join('\n');
@@ -2385,8 +2462,8 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
         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 = 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 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)})`);
@@ -2574,16 +2651,16 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
         }
         // 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(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))})`);
+        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);
-            const next = continueOn(ctx.graph.byId.get(join), 'output', ctx, refInto);
-            if (next.brk || next.cont) {
-                segs.push(next.brk ? '.break()' : '.continue()');
+            if (fork.next.brk || fork.next.cont) {
+                segs.push(fork.next.brk ? '.break()' : '.continue()');
                 return segs;
             }
-            cursor = next.cursor;
+            cursor = fork.next.cursor;
             continue;
         }
         // Unstructured fan-out we can't fold — best-effort marker. Its successor
@@ -2803,7 +2880,7 @@ function emitSwitch(node, ipdom, scope, ctx, stop, refInto) {
                 }
             }
         }
-        const armSegs = edgeRegion(portEdge(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)}` : '';
         // The file's case id comes back when it is not the positional one serialize
@@ -2816,7 +2893,7 @@ function emitSwitch(node, ipdom, scope, ctx, stop, refInto) {
     const on = emitBareExpr(disc ?? '', ctx.imp, ctx.inputNames);
     const hasDefault = (node.inputs ?? {}).hasDefault === true || portEdge(ctx.graph, node.id, 'default') !== undefined;
     const defArm = hasDefault
-        ? `, ${armCb('d', edgeRegion(portEdge(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
@@ -3020,9 +3097,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 ? 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) : [];
+    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.
@@ -3144,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 = 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) : [];
+    // 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
@@ -3236,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 = follow(ctx.graph, t.id, 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})`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.20.0",
+  "version": "6.20.1",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -92,5 +92,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "30b9615751de65281973caeec9d688ad105fc925"
+  "gitref": "5440c25e8e833aced459eb5a0ae9109ac3c973ae"
 }