@uipath/maestro-builder-sdk 6.32.3 → 6.32.4

package/dist/check.js

@@ -51,6 +51,36 @@ export function check(built, opts = {}) {
     }
     return diags;
 }
+/**
+ * A step's node id is its name with every character outside `[A-Za-z0-9_]`
+ * made `_`, and `compile` never renames one to make it unique (#1249). So two
+ * different names that give one id (`a b` and `a_b`), or a step of the flow
+ * itself named like its trigger, are an error here, as the same name twice is
+ * DUP_STEP. `serialize` refuses both too, for the paths that skip `check`.
+ * A subflow's own start is the SDK's to name, so `trigger` is the flow's only.
+ */
+function checkStepIds(stepNames, trigger, diags) {
+    const byId = new Map();
+    for (const name of stepNames) {
+        const id = name.replace(/[^A-Za-z0-9_]/g, '_') || 'node';
+        const first = byId.get(id);
+        if (first !== undefined) {
+            diags.push({
+                level: 'error', code: 'STEP_ID_COLLISION', step: name,
+                message: `Steps "${first}" and "${name}" would both get node id "${id}". Give them names that differ in `
+                    + 'letters, digits or "_".',
+            });
+        }
+        else if (id === trigger) {
+            diags.push({
+                level: 'error', code: 'STEP_ID_COLLISION', step: name,
+                message: `Step "${name}" has the trigger's node id "${id}". Rename the step.`,
+            });
+        }
+        if (first === undefined)
+            byId.set(id, name);
+    }
+}
 /**
  * `ancestors` is the chain of child flows currently being checked, innermost
  * last — used to prefix a child's diagnostics with the step that runs it, and
@@ -898,6 +928,9 @@ function checkFlow(built, ancestors, opts = {}) {
         }
         walk(ep.steps);
     }
+    // After the entry-point loop, so prefix steps are in `stepNames`: serialize
+    // claims body and prefix step ids together (#1249).
+    checkStepIds(stepNames, ancestors.length === 0 ? triggerId : undefined, diags);
     if (built.entryPoints?.length && !built.steps.some((st) => 'name' in st && st.kind !== 'return')) {
         diags.push({
             level: 'error', code: 'ENTRY_POINT_NO_SHARED_BODY',

package/dist/serialize.js

@@ -4166,9 +4166,9 @@ function terminateOutputs(scope) {
 /**
  * Rewrite `$vars.<step>` references through a scope's rename map.
  *
- * A name maps to the ids claimed for it in order; a reference resolves to the
- * first, which is the only sensible reading when a scope has two steps of the
- * same name (an error in its own right — DUP_STEP).
+ * A name maps to the id claimed for it (a list only for the type's sake: a
+ * scope with two steps of one name is refused before anything renders, #1249);
+ * a reference resolves to the first.
  */
 function renameRefs(text, rename) {
     if (rename.nodeIds.size === 0 && rename.errorEnvelopes.size === 0 && !rename.vars?.size)
@@ -4189,29 +4189,38 @@ function renameRefs(text, rename) {
         return `$vars.${nodeId}.${envelope}`;
     }));
 }
-/** Every step name a flow declares in its own scope (not its children's). */
-function stepNamesOf(steps, out = []) {
+/**
+ * Every step name a flow declares in its own scope (not its children's),
+ * port paths (`.stepToList`, `.onError`) included: their steps are nodes of
+ * this scope too, so they need an id claimed with the rest.
+ */
+function stepNamesOf(steps, out = [], terminates) {
     for (const s of steps) {
         // `return` carries a synthetic `name` but creates no node named after it (an
         // 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);
+        // 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);
+        if (s.kind === 'stepToList')
+            stepNamesOf(s.body, out, terminates);
         if (s.kind === 'branch') {
-            stepNamesOf(s.then, out);
-            stepNamesOf(s.otherwise, out);
+            stepNamesOf(s.then, out, terminates);
+            stepNamesOf(s.otherwise, out, terminates);
         }
         else if (s.kind === 'switch') {
-            s.cases.forEach((c) => stepNamesOf(c.body, out));
-            stepNamesOf(s.default ?? [], out);
+            s.cases.forEach((c) => stepNamesOf(c.body, out, terminates));
+            stepNamesOf(s.default ?? [], out, terminates);
         }
         else if (s.kind === 'stepSwitch')
-            s.cases.forEach((c) => stepNamesOf(c.body, out));
+            s.cases.forEach((c) => stepNamesOf(c.body, out, terminates));
         else if (s.kind === 'parallel')
-            s.arms.forEach((a) => stepNamesOf(a, out));
+            s.arms.forEach((a) => stepNamesOf(a, out, terminates));
         else if (s.kind === 'loop')
-            stepNamesOf(s.body, out);
+            stepNamesOf(s.body, out, terminates);
         else if (s.kind === 'doWhile')
-            stepNamesOf(s.body, out);
+            stepNamesOf(s.body, out, terminates);
     }
     return out;
 }
@@ -4412,19 +4421,22 @@ export function serialize(built, opts = {}) {
         root.rename.nodeIds.set('start', [built.triggerId]);
     }
     // Every node id emitted anywhere in the file. `start` is taken before
-    // anything else: the root trigger's id is fixed, so a step named `start` must
-    // be renamed rather than silently collide with it.
+    // anything else: the root trigger's id is fixed, so a step named like the
+    // trigger is refused (claimStepIds).
     const takenIds = new Set([built.triggerId ?? 'start']);
     /** Per scope, each named `.return` End emitted so far and its content. */
     const namedEnds = new Map();
     /** Per scope, the names a `.terminate` claimed: which remedy a later clash gets (#1239). */
     const terminateNames = new Map();
     let edgeSeq = 0;
-    /** Claim a globally unique node id, honouring the scope's rename map. */
-    function uid(scope, base) {
-        const pre = scope.pending.get(base);
-        if (pre && pre.length > 0)
-            return pre.shift();
+    /**
+     * Claim a globally unique node id for a node the SDK names itself: an End,
+     * a subflow's Start, an agent's context or tool node, an error-port End.
+     * Those ids are the SDK's to choose, so a clash is settled by `claimId`'s
+     * numeric suffix (`end`, `end2`, …). A step's id never comes from here; see
+     * `stepUid`.
+     */
+    function uid(_scope, base) {
         return claimId(base);
     }
     function claimId(base) {
@@ -4499,18 +4511,82 @@ export function serialize(built, opts = {}) {
         }
     }
     /**
-     * `uid` for a node that IS an author's step, recording which id that step got.
+     * Claim the node ids for every step of one scope, BEFORE any node of the
+     * scope (or of a subflow it calls) is emitted, so an author's step name
+     * always gets its id ahead of the ids the SDK makes up (#1249).
+     *
+     * A step's id is its name: the author's name, or a decompiled file's own
+     * node id. It is never quietly renamed:
+     *
+     * - Two steps whose names give the same id (`.step('x')` twice, or `a b`
+     *   beside `a_b`) are refused. `check` reports them as DUP_STEP /
+     *   STEP_ID_COLLISION; this is the backstop for every path that skips it
+     *   (`compile --no-check`, the draft-tolerant merge compile, a direct
+     *   `serialize()`). Renaming the second to `x2` left `.stepToRef('x')` and
+     *   `$vars.x` pointing at the first, with no word said.
+     * - In the flow itself, a step named like the trigger is refused the same
+     *   way (STEP_ID_COLLISION).
+     * - A subflow body whose ids are already taken (a second copy of the same
+     *   child, or a child step sharing a name with a caller's step) is the one
+     *   place ids move: the whole copy is prefixed with the calling step's name,
+     *   and `rename` points its expressions at the prefixed ids.
+     */
+    function claimStepIds(scope, names, where, copyPrefix, alsoIds = [], terminates = new Map()) {
+        const seen = new Map();
+        for (const n of names) {
+            const safe = n.replace(/[^A-Za-z0-9_]/g, '_') || 'node';
+            const first = seen.get(safe);
+            if (first !== undefined) {
+                // A name a `.terminate` holds gets the same words `check` gives (#1239):
+                // two Terminates -> end the other paths at one; a step and a Terminate
+                // -> rename one.
+                const t = first === n ? (terminates.get(n) ?? 0) : 0;
+                throw new Error(first !== n
+                    ? `${where}: [STEP_ID_COLLISION] steps "${first}" and "${n}" would both get node id "${safe}". Give them `
+                        + 'names that differ in letters, digits or "_".'
+                    : t >= 2 ? `${where}: [DUP_STEP] ${terminateTwiceMessage(n)}`
+                        : t === 1 ? `${where}: [DUP_STEP] ${terminateStepClashMessage(n)}`
+                            : `${where}: [DUP_STEP] two steps are named "${n}". A step name is its node's id and \`.stepToRef\` / `
+                                + `\`$vars\` name it, so compile will not rename the second one "${n}2". Give each step its own name; to `
+                                + `send several paths to one step, keep one and end the others with .stepToRef('${n}').`);
+            }
+            seen.set(safe, n);
+        }
+        // A subflow copy's named Ends (`alsoIds`) decide the prefix with its steps (#1253).
+        const prefix = copyPrefix !== undefined && [...seen.keys(), ...alsoIds].some((id) => takenIds.has(id)) ? copyPrefix : '';
+        for (const [safe, n] of seen) {
+            if (!prefix && takenIds.has(safe)) {
+                throw new Error(`${where}: [STEP_ID_COLLISION] step "${n}" has the trigger's node id "${safe}", and compile will not `
+                    + `rename it "${safe}2". Rename the step.`);
+            }
+            const id = claimId(prefix + safe);
+            if (copyPrefix !== undefined)
+                (scope.rename.nodeIds.get(n) ?? scope.rename.nodeIds.set(n, []).get(n)).push(id);
+            scope.pending.set(n, id);
+        }
+        return prefix;
+    }
+    /**
+     * The node id of an author's step: the one `claimStepIds` claimed for it,
+     * recorded so `.stepToRef('<step>')` can find it.
      *
      * `.stepToRef('<step>')` names a step, and the id it was emitted under is not
-     * derivable from the name: `uid` sanitizes, de-duplicates against every id in
-     * the file, and hands a subflow COPY a prefixed one from the rename map. So
-     * the mapping is recorded where it is decided rather than reconstructed later
-     * — the derived-names lesson (G-20), one layer in.
+     * always the name: a subflow COPY's steps are prefixed. So the mapping is
+     * recorded where it is decided rather than reconstructed later — the
+     * derived-names lesson (G-20), one layer in.
      */
     function stepUid(scope, stepName) {
-        const id = uid(scope, stepName);
-        if (!scope.stepNodeId.has(stepName))
-            scope.stepNodeId.set(stepName, id);
+        // Unreachable after `claimStepIds`, which refuses a repeated name first;
+        // kept so no future emission path can bring back the silent `<name>2`.
+        if (scope.stepNodeId.has(stepName)) {
+            throw new Error(`step "${stepName}" is emitted twice in one scope (internal: DUP_STEP reached stepUid).`);
+        }
+        const id = scope.pending.get(stepName);
+        if (id === undefined) {
+            throw new Error(`step "${stepName}" has no claimed node id (internal: stepNamesOf missed a step kind).`);
+        }
+        scope.pending.delete(stepName);
+        scope.stepNodeId.set(stepName, id);
         return id;
     }
     /**
@@ -4680,14 +4756,9 @@ export function serialize(built, opts = {}) {
         // namespace the `subflows` map keeps.
         // A child's named Ends belong to the copy too, so they decide the prefix
         // with its steps and move with it (#1253).
-        const names = stepNamesOf(child.steps);
         const childNodes = namedNodesOf(child.steps);
-        const prefix = [...names, ...childNodes.ends.map(safeNodeId)].some((n) => takenIds.has(n)) ? `${nodeId}_` : '';
-        for (const n of names) {
-            const id = claimId(prefix + n);
-            (scope.rename.nodeIds.get(n) ?? scope.rename.nodeIds.set(n, []).get(n)).push(id);
-            (scope.pending.get(n) ?? scope.pending.set(n, []).get(n)).push(id);
-        }
+        const childTerminates = new Map();
+        const prefix = claimStepIds(scope, stepNamesOf(child.steps, [], childTerminates), `subflow "${nodeId}"`, `${nodeId}_`, childNodes.ends.map(safeNodeId), childTerminates);
         claimEndIds(scope, childNodes, `subflow "${nodeId}"`, [], prefix);
         const startId = uid(scope, `${nodeId}Start`);
         // A CHILD's inputs are published as the child's own start node, whose id is
@@ -6653,10 +6724,17 @@ export function serialize(built, opts = {}) {
         }
         return tails;
     }
-    // The flow's named Ends (entry-point prefixes included: they emit into the
-    // root scope) are claimed before anything is emitted, so an id the SDK makes
-    // up is the one that moves (#1253).
+    // The flow's own step ids (entry-point prefixes included: they emit into the
+    // root scope) are claimed before anything else but the trigger, so a subflow
+    // body or an SDK-made node that shares a step's name is the one that moves.
+    // Its named Ends are claimed right after, before anything is emitted, so an
+    // id the SDK makes up is the one that moves (#1253).
     {
+        const rootTerminates = new Map();
+        const rootSteps = stepNamesOf(built.steps, [], rootTerminates);
+        for (const ep of built.entryPoints ?? [])
+            stepNamesOf(ep.steps, rootSteps, rootTerminates);
+        claimStepIds(root, rootSteps, `flow "${built.id}"`, undefined, [], rootTerminates);
         const seenEnds = new Set();
         const rootNodes = namedNodesOf(built.steps, undefined, seenEnds);
         for (const ep of built.entryPoints ?? [])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.32.3",
+  "version": "6.32.4",
   "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": "ae1239906aef3bdd220cbea1ba2a09845f9fd4c7"
+  "gitref": "9a7e5f98ca054b05f74ac655b8725bf4e3b50e89"
 }