@uipath/maestro-builder-sdk 6.43.0 → 6.44.1

package/dist/serialize.js

@@ -8,8 +8,8 @@
  */
 import ixpDefinition from './core/ixp-definition.json' with { type: 'json' };
 import { BUNDLED_DEFINITIONS, bundledVersions } from './flow-definitions.js';
-import { LOOP_DEFAULT_VERSION, bodyUsesBreak, loopHasInnerHandles, loopVersion, loopVersionRefusal } from './loop-version.js';
-import { Expr, toExpr, SCHEDULE_PRESETS, parseIxpProjectType, flatNameSegmentsOf } from './flow-sdk.js';
+import { LOOP_DEFAULT_VERSION, bodyUsesBreak, loopDeclaredInputs, loopHasInnerHandles, loopVersion, loopVersionRefusal } from './loop-version.js';
+import { Expr, toExpr, SCHEDULE_PRESETS, parseIxpProjectType, flatNameSegmentsOf, parallelFork } from './flow-sdk.js';
 import { FlowAction, FlowTrigger } from './core/node-classes.js';
 import { connectorRawNodeRefusal } from './core/connector-raw-node.js';
 import { rawNodeInputProblem, registeredRawType } from './raw-node-advice.js';
@@ -1656,6 +1656,12 @@ function stepNamesOf(steps, out = [], terminates) {
         // End id is claimed as `end`); `stepToRef` has no `name` at all (it is one edge).
         if ('name' in s && s.kind !== 'return')
             out.push(s.name);
+        // A `.parallel` with a fork node claims that node's name too (#1310).
+        if (s.kind === 'parallel') {
+            const fork = parallelFork(s.options);
+            if (fork)
+                out.push(fork.name);
+        }
         // How many `.terminate`s hold each name, so a clash gets the right remedy (#1239).
         if (s.kind === 'terminate' && terminates)
             terminates.set(s.name, (terminates.get(s.name) ?? 0) + 1);
@@ -1705,6 +1711,11 @@ function namedNodesOf(steps, out = { steps: [], ends: [] }, seenEnds = new Set()
         }
         else if ('name' in s)
             out.steps.push(s.name);
+        if (s.kind === 'parallel') {
+            const fork = parallelFork(s.options);
+            if (fork)
+                out.steps.push(fork.name);
+        }
         if (s.kind === 'stepToList')
             namedNodesOf(s.body, out, seenEnds);
         else if (s.kind === 'branch') {
@@ -3227,6 +3238,29 @@ export function serialize(built, opts = {}) {
                 // one, hang the run with no incident. check reports both
                 // (HITL_FAN_OUT_INTO_JOIN, HITL_END_OUTCOME_IN_PARALLEL); this is the
                 // compile-side half, and it fails closed.
+                // The fork, when the author names one (`{ fork }`, #1310): a merge node
+                // with one incoming edge and one edge per arm — the gateway Studio Web
+                // draws for a parallel split. The arms then leave from it instead of
+                // from the step before.
+                const fork = parallelFork(step.options);
+                if (fork) {
+                    // The gateway waits for a token on EVERY incoming edge, so two tails
+                    // that are alternatives — a `.branch()`'s or `.switch()`'s arms, a
+                    // fan-out task's outcomes — must not both enter it: only one fires
+                    // and the arms never start. Fails closed, as the join does.
+                    if (tails.length > 1) {
+                        throw new Error(`.parallel("${step.name}"): its fork "${fork.name}" would receive ${tails.length} alternative edges `
+                            + `(${tails.map((t) => `${t.node}@${t.port}`).join(', ')}), and only one of them fires while the gateway `
+                            + `waits for all of them. Add a step before the .parallel so the paths meet there first, or drop { fork }.`);
+                    }
+                    const forkId = stepUid(scope, fork.name);
+                    const forkNode = makeNode(NODE_TYPE.merge, forkId, fork.label ?? fork.name, { parentId, requestedVersion: fork.version ?? step.options?.version });
+                    forkNode.inputs = {};
+                    scope.nodes.push(forkNode);
+                    for (const t of tails)
+                        addEdge(scope, t, forkId);
+                    tails = [{ node: forkId, port: successPort(NODE_TYPE.merge) }];
+                }
                 const armTails = [];
                 const endsBefore = hitlEndExits.length;
                 for (const arm of step.arms) {
@@ -3292,23 +3326,30 @@ export function serialize(built, opts = {}) {
                 // An option or a .break() the pinned version's definition cannot express
                 // is a contradiction the author must resolve, not a silent drop; `check`
                 // reports the same refusal from the same helper (#1186).
-                const refusal = loopVersionRefusal(step.name, o, usesBreak);
+                const version = loopVersion(o);
+                // The definition the loop compiles against decides its handles AND its
+                // inputs: a carried `core.logic.loop@1.0` (a designer-saved file's own)
+                // keeps its `output`/`loopBack` pair, where the bundled lookup alone
+                // would have written 2.4's `start`/`continue` onto a 1.0 node (#1311),
+                // and an option is written when that definition declares the input
+                // (the carried 1.0 declares `completionCondition`; the bundled 1.0.0
+                // does not) and refused when it does not.
+                const loopDef = definitionFor(NODE_TYPE.loop, version);
+                const refusal = loopVersionRefusal(step.name, o, usesBreak, loopDef);
                 if (refusal)
                     throw new Error(refusal);
-                const version = loopVersion(o);
-                const v24 = loopHasInnerHandles(version);
+                const v24 = loopHasInnerHandles(version, loopDef);
+                const declared = loopDeclaredInputs(loopDef);
                 const id = stepUid(scope, step.name);
                 const node = makeNode(NODE_TYPE.loop, id, step.options?.label ?? step.label ?? step.name, { parentId, requestedVersion: version });
-                node.inputs = v24
-                    ? {
-                        collection: renderValue(step.collection, scope.rename),
-                        parallel: o.parallel ?? false,
-                        ...(o.completionCondition !== undefined
-                            ? { completionCondition: renameRefs(o.completionCondition.js, scope.rename) }
-                            : {}),
-                        breakEnabled: (o.breakEnabled ?? false) || usesBreak,
-                    }
-                    : { collection: renderValue(step.collection, scope.rename), parallel: o.parallel ?? false };
+                node.inputs = {
+                    collection: renderValue(step.collection, scope.rename),
+                    parallel: o.parallel ?? false,
+                    ...(o.completionCondition !== undefined && (v24 || 'completionCondition' in declared)
+                        ? { completionCondition: renameRefs(o.completionCondition.js, scope.rename) }
+                        : {}),
+                    ...(v24 || 'breakEnabled' in declared ? { breakEnabled: (o.breakEnabled ?? false) || usesBreak } : {}),
+                };
                 scope.nodes.push(node);
                 for (const t of tails)
                     addEdge(scope, t, id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.43.0",
+  "version": "6.44.1",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -93,5 +93,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "572ec05cde3b8e5f4e1c102ed2cfa3f0baaa95b0"
+  "gitref": "7e2a9339fd00189290ce2ac453aa52636426d6ce"
 }