@uipath/maestro-builder-sdk 6.15.3 → 6.15.5

package/dist/flow-variables.js

@@ -1,3 +1,4 @@
+import { globalNameCollisionMessage, globalNameCollisions } from './core/global-names.js';
 const CONTAINER_KEYS = new Set(['globals', 'nodes', 'variableUpdates']);
 const DIRECTIONS = new Set(['in', 'out', 'inout']);
 /** Read both supported Flow variable spellings into one declaration table. */
@@ -40,3 +41,86 @@ export function readFlowGlobals(variables, strict = false) {
     }
     return globals;
 }
+const sameJson = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/**
+ * Turn a flow's `.input()` / `.output()` / `.var()` declarations into the
+ * globals the `.flow` file will carry — one per id, because the product's
+ * `flow validate` rejects a repeated id (`[variables.globals] Duplicate variable
+ * ID`), and the three methods share that one namespace.
+ *
+ * **An output and a var with the same name are one variable** (flow-builder-sdk#899).
+ * The natural loop accumulator is
+ * `.output({ product: types.number }).var('product', types.number, 1)`: declare
+ * the result, then seed it. Both declarations describe the same value, so they
+ * merge into ONE `direction: 'out'` global that carries the var's default.
+ *
+ * Why `out` and not `inout`, measured against `@uipath/flow-converter` 0.69 and
+ * `@uipath/maestro-sdk` (the code that turns a `.flow` into what runs):
+ * - only an `out` global is a flow OUTPUT at the root — `buildNodeOutputMappings`
+ *   drops an End node's mapping for any id that is not `direction: 'out'`;
+ * - `inout` is published as an INPUT too — solution discovery puts it on the
+ *   entry point's input schema — so `inout` would widen the caller's contract;
+ * - `{ updates }` on an `out` global is the same output mapping (`var: <id>`) as
+ *   on an `inout` one, so a loop body can read and rewrite it mid-run;
+ * - the `default` on `<uipath:output>` is serialized (`collectVariablesFromNodes`)
+ *   and a subflow seeds its `out` globals from `defaultValue ?? null`
+ *   (`buildSeedTask`). The v1 CLI's `variable add --direction out
+ *   --default-value` writes the same shape.
+ *
+ * Metadata: the output's `description` / `subType` / `schema` win, falling back
+ * to the var's; the default is whichever side declared one. A disagreement the
+ * merge would have to resolve by picking a side — a different `type`, two
+ * different defaults, two different `subType`s or `schema`s — is
+ * `OUTPUT_VAR_MISMATCH` instead, because silently choosing one changes what the
+ * flow computes. Every other repeated name (two vars, two outputs, an input
+ * reused as an output or var) stays `VARIABLE_NAME_COLLISION`
+ * (`core/global-names.ts`, flow-builder-sdk#890).
+ */
+export function planFlowGlobals(decl) {
+    const problems = [];
+    const varsByName = new Map(decl.vars.map((d) => [d.name, d]));
+    const mergeable = new Set();
+    for (const collision of globalNameCollisions(decl.inputs, decl.outputs, decl.vars)) {
+        const pair = collision.kinds.length === 2 && collision.kinds[0] === 'output' && collision.kinds[1] === 'var';
+        if (pair)
+            mergeable.add(collision.name);
+        else
+            problems.push({ code: 'VARIABLE_NAME_COLLISION', name: collision.name, message: globalNameCollisionMessage(collision) });
+    }
+    const merged = [];
+    const outputs = decl.outputs.map((o) => {
+        const vd = varsByName.get(o.name);
+        if (!vd || !mergeable.has(o.name))
+            return o;
+        const clash = [];
+        if (o.type !== vd.type)
+            clash.push(`the output is ${o.type} and the var is ${vd.type}`);
+        if (o.default !== undefined && vd.default !== undefined && !sameJson(o.default, vd.default))
+            clash.push(`the output's default is ${JSON.stringify(o.default)} and the var's is ${JSON.stringify(vd.default)}`);
+        if (o.subType !== undefined && vd.subType !== undefined && o.subType !== vd.subType)
+            clash.push(`the output's subType is ${JSON.stringify(o.subType)} and the var's is ${JSON.stringify(vd.subType)}`);
+        if (o.schema !== undefined && vd.schema !== undefined && !sameJson(o.schema, vd.schema))
+            clash.push(`the output and the var declare different schemas`);
+        if (clash.length) {
+            problems.push({
+                code: 'OUTPUT_VAR_MISMATCH', name: o.name,
+                message: `"${o.name}" is declared by both .output() and .var(), which the SDK merges into one output `
+                    + `variable, but ${clash.join('; ')}. Make the two declarations agree, or drop the .var().`,
+                suggestion: `An output is assignable with { updates } on its own; declare its starting value with `
+                    + `.output({ ${o.name}: { type: types.${o.type}, default: … } }).`,
+            });
+            return o;
+        }
+        merged.push(o.name);
+        return {
+            ...o,
+            ...(o.default === undefined && vd.default !== undefined ? { default: vd.default } : {}),
+            ...(o.description === undefined && vd.description !== undefined ? { description: vd.description } : {}),
+            ...(o.subType === undefined && vd.subType !== undefined ? { subType: vd.subType } : {}),
+            ...(o.schema === undefined && vd.schema !== undefined ? { schema: vd.schema } : {}),
+        };
+    });
+    const mergedSet = new Set(merged);
+    const vars = decl.vars.filter((vd) => !mergedSet.has(vd.name));
+    return { outputs, vars, merged, problems };
+}

package/dist/registry/path-cli.js

@@ -1,4 +1,4 @@
-import { reportResult } from '../cli-result.js';
+import { printResult, reportResult } from '../cli-result.js';
 import { join } from "node:path";
 import { CURRENT_LINK, PULL_COMMAND, currentEntrySha, libraryCacheRoot, resolveCachedLibrary, resolveCachedMarkdown, } from "./cache.js";
 /**
@@ -37,7 +37,7 @@ export async function run(argv) {
             console.error(`No connector library in the cache yet. Run \`${PULL_COMMAND}\`.`);
             return 1;
         }
-        console.log(value);
+        printResult(value);
         return 0;
     };
     if (argv.includes("--library-json"))
@@ -56,7 +56,7 @@ export async function run(argv) {
         libraryMarkdown: libraryMarkdown ?? null,
     };
     reportResult(all);
-    console.log(JSON.stringify(all, null, 2));
+    printResult(JSON.stringify(all, null, 2));
     // Not an error: a caller asking for the whole picture is entitled to be told
     // the cache is empty, rather than getting a non-zero exit for a plain report.
     return 0;

package/dist/registry/search-cli.js

@@ -1,4 +1,4 @@
-import { reportResult } from '../cli-result.js';
+import { printResult, reportResult } from '../cli-result.js';
 import { readFile, stat } from "node:fs/promises";
 import { PULL_COMMAND, resolveLibraryDir } from "./cache.js";
 import { dirname, join } from "node:path";
@@ -155,7 +155,7 @@ export async function run(argv) {
             limit,
         });
         reportResult(result);
-        console.log(JSON.stringify(result, null, 2));
+        printResult(JSON.stringify(result, null, 2));
         return 0;
     }
     catch (error) {

package/dist/serialize.js

@@ -16,7 +16,6 @@ import { connectorRawNodeRefusal } from './core/connector-raw-node.js';
 import { dataFabricUnknownInputs } from './core/typed-raw-node.js';
 import { isAnswerField } from './core/hitl-answers.js';
 import { connectionConnectors } from './bindings-v2.js';
-import { globalNameCollisionMessage, globalNameCollisions } from './core/global-names.js';
 import { BindingRefusal, GUID_RE, bindingMissingMessage, bindingSelfNameMessage, bindingUndeclaredMessage, missingBindingLabels, undeclaredBinding } from './core/binding-messages.js';
 import { ByoaRefusal, byoaUnverified } from './core/byoa.js';
 import { OUTCOME_HANDLE_NODE_TYPES, assertHitlExitInvariant, hitlExitModel, hitlExitViolation, outcomeSlug } from './core/hitl-routing.js';
@@ -46,6 +45,7 @@ import { declaredScriptShape, inferScriptShape } from './core/script-return.js';
 import { migrateToSchemaVersion } from './migrate.js';
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { resolveSchemaVersion } from './schema-version.js';
+import { planFlowGlobals } from './flow-variables.js';
 import { prepareCommand } from './core/cli-spelling.js';
 import { QUEUE_ITEM_RECORD_SCHEMA } from './core/queue-record.js';
 const HERE = dirname(fileURLToPath(import.meta.url));
@@ -3485,12 +3485,6 @@ function refuseUnverifiedByoa(opts, where, sub) {
     if (message)
         throw new ByoaRefusal(message);
 }
-/** Refuse a name declared twice across `.input()` / `.output()` / `.var()` — one `variables.globals[]` id each. */
-function refuseGlobalNameCollisions(inputs, outputs, vars) {
-    const [first] = globalNameCollisions(inputs, outputs, vars);
-    if (first)
-        throw new Error(globalNameCollisionMessage(first));
-}
 /**
  * Refuse a connector-bound node (connector step, event trigger, `.entryPoint`
  * onEvent, `waitForEvent`) that names no `connection` or no `folder` label.
@@ -3957,6 +3951,24 @@ function misplacedLookupMessage(token) {
         `a lookup() must be the whole value of a connector input, or an element of an array input. ` +
         `Emitting it here would send a raw {"__lookup": …} object where the connector expects an id.`);
 }
+/**
+ * The flow's declarations as the globals it will emit: a same-named `.output()`
+ * and `.var()` folded into one `out` global (flow-builder-sdk#899), every other
+ * repeated name refused. `check()` reports the same problems as
+ * VARIABLE_NAME_COLLISION / OUTPUT_VAR_MISMATCH; this throws too, so a path that skips the static pass
+ * (`compile --no-check`, `emitFlow`, a direct `serialize()`) cannot write a
+ * file `flow validate` rejects for a duplicate variable id.
+ */
+function emittableGlobals(built, where) {
+    // Entry-point inputs are rows of the same globals[], so they share the
+    // namespace; `check` reports those as ENTRY_POINT_INPUT_COLLISION.
+    const inputs = [...built.inputs, ...(built.entryPoints ?? []).flatMap((ep) => ep.inputs)];
+    const plan = planFlowGlobals({ inputs, outputs: built.outputs, vars: built.vars });
+    if (plan.problems.length) {
+        throw new Error(`${where}: ${plan.problems.map((p) => `[${p.code}] ${p.message}`).join(' ')}`);
+    }
+    return plan;
+}
 function newScope(outputs, vars = []) {
     return {
         nodes: [],
@@ -4280,7 +4292,8 @@ export function serialize(built, opts = {}) {
      */
     const sidecars = opts.sidecars ?? [];
     const subflows = {};
-    const root = newScope(built.outputs, built.vars);
+    const rootGlobals = emittableGlobals(built, `flow "${built.id}"`);
+    const root = newScope(rootGlobals.outputs, rootGlobals.vars);
     // `input('x')` lowers eagerly to `$vars.start.output.x` — `start` being the
     // trigger node's default id. When the flow renames the trigger, register that
     // rename so the SAME pass that rewrites step-name references rewrites these
@@ -4404,7 +4417,8 @@ export function serialize(built, opts = {}) {
      * a null. It is emitted here, always, so it cannot be forgotten.
      */
     function emitSubflowBody(child, nodeId) {
-        const scope = newScope(child.outputs, child.vars);
+        const childGlobals = emittableGlobals(child, `subflow "${nodeId}"`);
+        const scope = newScope(childGlobals.outputs, childGlobals.vars);
         // Claim this copy's node ids UP FRONT, so the rename map is complete before
         // the first expression renders. A child's step names are free the first
         // time it runs; if any of them is already taken — which is what a second
@@ -4443,13 +4457,12 @@ export function serialize(built, opts = {}) {
             for (const t of tails)
                 addEdge(scope, t, endId);
         }
-        refuseGlobalNameCollisions(child.inputs, child.outputs, child.vars);
         const globals = [];
         for (const inp of child.inputs)
             globals.push({ id: inp.name, name: inp.name, direction: 'in', type: inp.type, triggerNodeId: startId, ...varMeta(inp) });
-        for (const o of child.outputs)
+        for (const o of childGlobals.outputs)
             globals.push({ id: o.name, name: o.name, direction: 'out', type: o.type, ...varMeta(o) });
-        for (const vd of child.vars)
+        for (const vd of childGlobals.vars)
             globals.push({ id: vd.name, name: vd.name, direction: 'inout', type: vd.type, ...varMeta(vd) });
         resolveRejoins(scope);
         assertHitlExitInvariant(scope.nodes, scope.edges);
@@ -6531,16 +6544,13 @@ export function serialize(built, opts = {}) {
             }
         }
     }
-    // Entry-point inputs are rows of the same globals[] (pushed below), so they
-    // share the namespace; `check` reports these as ENTRY_POINT_INPUT_COLLISION.
-    refuseGlobalNameCollisions([...built.inputs, ...entryPoints.flatMap((ep) => ep.inputs)], built.outputs, built.vars);
     const globals = [];
     const triggerNodeId = built.triggerId ?? 'start';
     for (const inp of built.inputs)
         globals.push({ id: inp.name, name: inp.name, direction: 'in', type: inp.type, triggerNodeId, ...varMeta(inp) });
-    for (const o of built.outputs)
+    for (const o of rootGlobals.outputs)
         globals.push({ id: o.name, name: o.name, direction: 'out', type: o.type, ...varMeta(o) });
-    for (const vd of built.vars)
+    for (const vd of rootGlobals.vars)
         globals.push({ id: vd.name, name: vd.name, direction: 'inout', type: vd.type, ...varMeta(vd) });
     for (const ep of entryPoints) {
         for (const inp of ep.inputs) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.15.3",
+  "version": "6.15.5",
   "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": "a85d11af254f270d645ec46d57994ccb800ebc1f"
+  "gitref": "7c0103ce6f6d970156e15bbc3bae0a3f88ca4195"
 }