@uipath/maestro-builder-sdk 6.14.0 → 6.14.2

package/dist/check.js

@@ -92,9 +92,9 @@ function checkFlow(built, ancestors, opts = {}) {
      * checkable at all — see ERROR_ENVELOPE_VIA_OUTPUT.
      */
     const exprs = [];
-    // Loop step names, so `$vars.<loop>.<field>` can be checked against the loop
-    // node's actual output fields (see LOOP_FIELDS below).
-    const loopNames = new Set();
+    // Loop step names, each with the output fields its node version exposes, so
+    // `$vars.<loop>.<field>` can be checked against them (see LOOP_FIELDS below).
+    const loopNames = new Map();
     // Switch step names. A switch is pure routing — its definition carries
     // `outputDefinition: null`, so it publishes NOTHING; reading `$vars.<switch>`
     // is always undefined at run time (see SWITCH_HAS_NO_OUTPUT below).
@@ -649,7 +649,7 @@ function checkFlow(built, ancestors, opts = {}) {
                 checkLoopListEnvelope(s, connectorSteps, opts, diags);
                 if (s.options?.completionCondition)
                     addExpr(s.options.completionCondition.js, s.name);
-                loopNames.add(s.name);
+                loopNames.set(s.name, s.options?.version === '1.0.0' ? LOOP_FIELDS_1_0_0 : LOOP_FIELDS);
                 if (s.body.length === 0)
                     diags.push({ level: 'warning', code: 'EMPTY_LOOP', message: `Loop "${s.name}" has an empty body.`, step: s.name });
                 walk(s.body, true);
@@ -660,7 +660,7 @@ function checkFlow(built, ancestors, opts = {}) {
                 // but no error handle.
                 prevPortSource = s;
                 addExpr(s.condition.js, s.name);
-                loopNames.add(s.name);
+                loopNames.set(s.name, LOOP_FIELDS_1_0_0);
                 // The platform's dowhile-limit rule: 1..10000 when set; blank = 10,000.
                 const limit = s.options?.limit;
                 if (limit !== undefined && (!Number.isFinite(limit) || limit < 1 || limit > 10000)) {
@@ -1178,14 +1178,24 @@ function checkFlow(built, ancestors, opts = {}) {
             // A loop step exposes a fixed set of fields, and only those resolve at run
             // time — `$vars.<loop>.item` reads undefined rather than the iteration
             // item. Catch the wrong spelling here, in the fast loop.
-            if (loopNames.has(name) && field && !LOOP_FIELDS.has(field)) {
+            const loopFields = loopNames.get(name);
+            if (loopFields && field && !loopFields.has(field)) {
+                // `currentIndex` (0-based) is the 1.0.0 name; loop 2.x renamed it to
+                // `currentIteration` (1-based). The platform's converter rewrites only
+                // `currentItem` / `currentIteration` / `collection`, so the old name on a
+                // 2.4 loop reads undefined at run time — no error, just a wrong value.
+                const renamed = field === 'currentIndex' && loopFields.has('currentIteration');
                 diags.push({
                     level: 'error',
                     code: 'UNKNOWN_LOOP_FIELD',
                     message: `Loop "${name}" has no output "${field}" (read as "$vars.${name}.${field}" in "${step}"). `
-                        + `A loop exposes: ${[...LOOP_FIELDS].join(', ')}.`,
+                        + `A loop exposes: ${[...loopFields].join(', ')}.`
+                        + (renamed
+                            ? ' `currentIndex` (0-based) is the legacy loop 1.0.0 output; loop 2.4 — the default — names it '
+                                + '`currentIteration` and counts from 1, so a 0-based index is `currentIteration - 1`.'
+                            : ''),
                     step,
-                    suggestion: `$vars.${name}.currentItem`,
+                    suggestion: renamed ? `$vars.${name}.currentIteration - 1` : `$vars.${name}.currentItem`,
                 });
             }
         }
@@ -5330,11 +5340,18 @@ function checkCaseValueTypes(s, typeOf, diags, triggerId) {
     }
 }
 /**
- * The outputs a `core.logic.loop` node exposes. `currentItem`/`currentIndex` are
- * the per-iteration values a body reads; `collection` is what it iterates;
- * `output` is the aggregate (after the loop) and `error` the failure detail.
+ * The outputs a `core.logic.loop@2.4` node — the `.loop()` default — exposes.
+ * `currentItem`/`currentIteration` (1-based) are the per-iteration values a body
+ * reads; `collection` is what it iterates; `output` is the aggregate (after the
+ * loop) and `error` the failure detail.
  */
-const LOOP_FIELDS = new Set(['currentItem', 'currentIndex', 'collection', 'output', 'error']);
+const LOOP_FIELDS = new Set(['currentItem', 'currentIteration', 'collection', 'output', 'error']);
+/**
+ * The same for a loop pinned to `{ version: '1.0.0' }`, whose per-iteration
+ * counter is the 0-based `currentIndex`. `.doWhile()` keeps this set as it had
+ * before the 2.4 default (#868); its own fields are not audited here.
+ */
+const LOOP_FIELDS_1_0_0 = new Set(['currentItem', 'currentIndex', 'collection', 'output', 'error']);
 /**
  * Columns Data Fabric assigns and never accepts a write for.
  *
@@ -5865,12 +5882,12 @@ function checkStepRefs(built, diags) {
         const targetScope = scopeOf.get(target) ?? '';
         if (targetScope !== scope) {
             // INTO a loop body is provably wrong, and not merely for containment: the
-            // body reads `currentItem` / `currentIndex`, which only an ITERATION gives a
+            // body reads `currentItem` / `currentIteration`, which only an ITERATION gives a
             // value. An edge that arrives from outside is not an iteration, so those
             // reads have nothing to resolve to.
             if (targetScope !== '') {
                 say('error', 'REF_INTO_LOOP', `.stepToRef('${target}') ${where} points INTO the body of loop "${targetScope}". A loop body runs per `
-                    + `ITERATION and reads currentItem / currentIndex from it; an edge arriving from outside carries no `
+                    + `ITERATION and reads currentItem / currentIteration from it; an edge arriving from outside carries no `
                     + `iteration, so those have no value. Point at a step after the loop, or do this work inside the body.`);
                 continue;
             }

package/dist/flow-sdk.d.ts

@@ -384,12 +384,11 @@ export interface ReturnOptions extends NodeOptions {
     name?: string;
 }
 /**
- * Loop-specific options. Any of these — or a `b.break()` in the
- * body — selects the loop's v2.4 definition (the current Workbench contract,
- * with inner `start`/`continue`/`break` handles); a plain `.loop()` keeps the
- * SDK's long-pinned 1.0.0 emission unchanged. An explicit `{ version: '1.0.0' }`
- * combined with any of these fails compilation: that definition cannot express
- * them.
+ * Loop-specific options. Every `.loop()` emits the loop's v2.4 definition (the
+ * version the registry serves: inner `start`/`continue`/`break` handles, and a
+ * 1-based `currentIteration` output). The legacy 1.0.0 shape is emitted only for
+ * an explicit `{ version: '1.0.0' }`, and that combined with any of these options
+ * fails compilation: that definition cannot express them.
  */
 export interface LoopOptions extends NodeOptions {
     /** Run iterations in parallel instead of sequentially. */

package/dist/serialize.js

@@ -32,9 +32,10 @@ import { QUEUE_ITEM_RECORD_SCHEMA } from './core/queue-record.js';
 const HERE = dirname(fileURLToPath(import.meta.url));
 // core-definitions.json is an object keyed by "<nodeType>@<version>".
 const DEFS = JSON.parse(readFileSync(join(HERE, 'core-definitions.json'), 'utf8'));
-// FIRST occurrence wins: with multiple bundled versions of one family (loop
-// 1.0.0 + 2.4), the unversioned lookup must stay the pinned default, not
-// whichever entry happens to be last in the JSON.
+// FIRST occurrence wins: with multiple bundled versions of one family (HITL
+// 1.0 / 1.1 / 1.2), the unversioned lookup must stay the pinned default, not
+// whichever entry happens to be last in the JSON. (`.loop()` always passes its
+// version — 2.4 unless `{ version: '1.0.0' }` is pinned — so it never reads this.)
 const defByType = new Map();
 for (const d of Object.values(DEFS))
     if (!defByType.has(d.nodeType))
@@ -5981,13 +5982,14 @@ export function serialize(built, opts = {}) {
             else if (step.kind === 'loop') {
                 const o = step.options ?? {};
                 const usesBreak = bodyUsesBreak(step.body);
-                // Rich loop semantics live in the v2.4 contract (inner start/continue/
-                // break handles). A plain .loop() keeps the long-pinned 1.0.0 emission
-                // byte-for-byte; any rich option — or a break in the body — selects 2.4
-                // as its deterministic pinned default. An explicit 1.0.0 plus a rich
-                // option is a contradiction the author must resolve, not a silent drop.
+                // Every .loop() defaults to 2.4 — the version the registry serves and the
+                // designer authors (inner start/continue/break handles, `currentIteration`
+                // output). 1.0.0 is the legacy shape the canvas shows in its old form; it
+                // is emitted only when { version: '1.0.0' } is pinned explicitly (#868).
+                // An explicit 1.0.0 plus a rich option is a contradiction the author must
+                // resolve, not a silent drop.
                 const rich = o.parallel !== undefined || o.completionCondition !== undefined || o.breakEnabled !== undefined || usesBreak;
-                const version = o.version ?? (rich ? '2.4' : '1.0.0');
+                const version = o.version ?? '2.4';
                 if (rich && version === '1.0.0') {
                     throw new Error(`loop "${step.name}": parallel/completionCondition/breakEnabled/break() need the loop's 2.4 `
                         + `definition, but { version: '1.0.0' } was requested. Drop the version or request 2.4.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.14.0",
+  "version": "6.14.2",
   "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": "84bd49a28ffaae311bcb7b3207a311dfeaf1c08f"
+  "gitref": "cb7a821ea17b6f3022c7b90e2567e91a5495576a"
 }