@uipath/maestro-builder-sdk 6.46.2 → 6.46.4

package/dist/case/serialize.js

@@ -19,6 +19,7 @@ import { resolveCaseSubscription } from './subscription.js';
 import { externalDescriptorRefusal } from './external.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
 import { resourceIdentity } from './resource-identity.js';
+import { ownEntry } from '../core/own-entry.js';
 import { resolveSchemaVersion } from '../schema-version.js';
 import { caseJsonPreservation, caseJsonPreservationErrors, } from './preserve.js';
 import { readEventFilter, eventFilterProblem, eventFilterTreeLeaf } from '../core/event-filters.js';
@@ -81,7 +82,8 @@ export function serialize(built, opts = {}) {
         bindings: opts.bindings,
         bindingSink: new Map(),
         varCompanions: new Map(),
-        connectorOutputCounts: new Map(),
+        outputIds: new Set(),
+        ownOutputVars: ownOutputVars(built),
         slaId: new Map(),
         slaIdByName: new Map(),
         escalationId: new Map(),
@@ -523,6 +525,18 @@ function applyPreservedIdentities(result, preservation) {
     const triggerNodes = nodes.filter((node) => node.type === 'case-management:Trigger' || node.type === 'uipath.case.trigger');
     (identities.triggers ?? []).forEach((trigger, index) => take(triggerNodes[index], trigger.id));
     const stages = nodes.filter((node) => String(node.type).endsWith('Stage'));
+    // Every task-output row id in the plan, kept current as preserved ids are
+    // taken. Output ids are unique plan-wide (`claimOutputId`); a preserved id that
+    // another row already holds would undo that. Example: an older SDK wrote two
+    // action rows both `{ id: 'action', var: 'action' }`; this pass gives the
+    // second `action2`, and taking its preserved `action` would make it a duplicate.
+    const heldOutputIds = new Set();
+    for (const stage of stages)
+        for (const lane of stage.data?.tasks ?? [])
+            for (const task of lane)
+                for (const row of task?.data?.outputs ?? [])
+                    if (typeof row?.id === 'string')
+                        heldOutputIds.add(row.id);
     for (const stageIdentity of identities.stages ?? []) {
         const stage = stages.find((candidate) => candidate.data?.label === stageIdentity.label);
         take(stage, stageIdentity.id);
@@ -547,7 +561,19 @@ function applyPreservedIdentities(result, preservation) {
                     // A positional match never takes a row a name match owns.
                     : named.has(outputRows[index]?.name) ? undefined : outputRows[index];
                 const currentId = target?.id;
+                // An own-name row's id IS its variable's name (`emitTaskOutput`). A
+                // preserved id that differs — an `o<hash>` slot from a plan an older
+                // SDK wrote — would rename the variable out from under every
+                // `=vars.<name>` reader, so the typed rule wins and the row migrates.
+                if (target && OWN_NAME_OUTPUT_ROWS.has(target) && row.id !== target.id)
+                    return;
+                if (target && typeof row.id === 'string' && row.id !== currentId && heldOutputIds.has(row.id))
+                    return;
                 take(target, row.id);
+                if (target && typeof row.id === 'string' && typeof currentId === 'string') {
+                    heldOutputIds.delete(currentId);
+                    heldOutputIds.add(row.id);
+                }
                 if (typeof currentId === 'string' && typeof row.id === 'string' && target?.value === currentId) {
                     target.value = row.id;
                 }
@@ -884,7 +910,12 @@ function taskData(task, resolver, taskId, stageId, ids) {
             // companion so `=vars.<var>` resolves downstream.
             if (!task.ref)
                 return {};
-            const data = { name: task.ref.name, folderPath: task.ref.folderPath };
+            // The resource is named through a name/folderPath pair of root bindings,
+            // never literals: `validate` refuses a literal (CASE_MGMT_RESOURCE_TASK_
+            // LITERAL_BINDING), and deploy re-targets a resource only through its
+            // binding (#1240).
+            const { nameRef, folderRef } = referenceBindings(task.kind, task.ref, resolver, ids);
+            const data = { name: nameRef, folderPath: folderRef };
             const elementId = `${stageId}-${taskId}`;
             if (task.inputs?.length)
                 data.inputs = task.inputs.map((inp, i) => emitTaskInput(inp, elementId, ids, `${elementId}:in:${i}:${inp.name}`));
@@ -906,6 +937,13 @@ function taskData(task, resolver, taskId, stageId, ids) {
             }
             if (a.labels)
                 data.labels = a.labels;
+            // The Action App the task opens, bound like any resource: an `app`
+            // name/folderPath pair keyed `<deployment folder>.<app>` (#1240).
+            if (task.ref) {
+                const { nameRef, folderRef } = referenceBindings('action', task.ref, resolver, ids);
+                data.name = nameRef;
+                data.folderPath = folderRef;
+            }
             if (a.actionCatalogName)
                 data.actionCatalogName = a.actionCatalogName;
             // HITL form fields: inputs are read-only context the assignee sees, outputs
@@ -1104,10 +1142,15 @@ function emitActionField(f, outputElementId, resolver) {
     if (f.value !== undefined)
         row.value = f.value;
     if (outputElementId !== undefined && f.value !== undefined) {
-        row.id = f.value;
+        // `id == var` like the Designer; a second form output into the same case
+        // variable takes a suffixed id and becomes a reassigned row (`originalVar`).
+        const id = resolver ? claimOutputId(resolver, f.value) : f.value;
+        row.id = id;
         row.var = f.value;
+        if (id !== f.value)
+            row.originalVar = id;
         row.source = `=${f.name}`;
-        row.target = `=${f.value}`;
+        row.target = `=${id}`;
         row.elementId = outputElementId;
         if (resolver && !resolver.varCompanions.has(f.value)) {
             resolver.varCompanions.set(f.value, {
@@ -1130,13 +1173,43 @@ function emitTaskInput(inp, elementId, ids, seed) {
     const slot = ids.make('v', 8, seed);
     return { name: inp.name, type: inp.type, id: slot, var: slot, elementId, value: inp.value };
 }
-/** One `data.outputs[]` row (the extract shape): `source` field → the `var` case variable. */
+/** Rows `emitTaskOutput` wrote in the own-name shape (`id == var`); see applyPreservedIdentities. */
+const OWN_NAME_OUTPUT_ROWS = new WeakSet();
+/**
+ * One `data.outputs[]` row: `source` field → the `var` case variable. Two shapes,
+ * as the Case Designer writes them:
+ *
+ * - **own name** — the output keeps its field's name (a top-level `source` whose
+ *   field is the `var`, or the Designer's camelCase of it, either one optionally
+ *   with a numeric suffix: `=APIOutput1` into `APIOutput1`, `aPIOutput1` or
+ *   `aPIOutput12`; see `keepsOwnName`). The row's `id` IS the `var`, with no
+ *   `originalVar`: `{ id: 'APIOutput1', var: 'APIOutput1', target: '=APIOutput1' }`.
+ * - **reassigned** — the output feeds a differently named variable (`=age` into
+ *   `estimatedAge`, or any nested `=Error.Message`). The row keeps its own minted
+ *   slot `id`, points `var` at the case variable, and repeats the slot in
+ *   `originalVar`, which is how the Designer recognises a reassignment.
+ *
+ * Output ids are unique across the plan (`claimOutputId`). When an own-name id
+ * is already taken — a second task writing the same variable — the row takes
+ * the suffixed id (`APIOutput12`) and falls back to the reassigned shape, so its
+ * `var` still names the shared case variable.
+ */
 function emitTaskOutput(o, elementId, ids, seed, resolver) {
-    const slot = ids.make('o', 8, seed);
-    const field = o.source.replace(/^=/, '').split('.').pop() || o.source;
+    const path = o.source.replace(/^=/, '');
+    const field = path.split('.').pop() || o.source;
     // Register the readable companion once (declared vars take precedence in the merge).
     if (!resolver.varCompanions.has(o.var))
         resolver.varCompanions.set(o.var, { id: o.var, name: o.var, type: o.type, elementId: 'root', custom: true });
+    if (isOwnNameOutput(o)) {
+        const id = claimOutputId(resolver, o.var);
+        if (id === o.var) {
+            const row = { name: field, type: o.type, id, var: o.var, value: o.var, source: o.source, target: `=${id}`, elementId };
+            OWN_NAME_OUTPUT_ROWS.add(row);
+            return row;
+        }
+        return { name: field, type: o.type, id, var: o.var, originalVar: id, value: o.var, source: o.source, target: `=${id}`, elementId };
+    }
+    const slot = claimOutputId(resolver, ids.make('o', 8, seed));
     return {
         name: field,
         type: o.type,
@@ -1160,25 +1233,66 @@ const BUSINESS_RULE_TASK_VERSION = 'v3';
  * pattern) is a different namespace, and a binding that uses it is not a
  * BusinessRule resource to the bindings_v2 reader. */
 const BUSINESS_RULE_RESOURCE = 'BusinessRule';
-/** Mint (once per resourceKey + attribute) one root `BusinessRule` binding. */
-function businessRuleBinding(resolver, ids, resourceKey, propertyAttribute, value) {
+/**
+ * The root binding `resource` and `resourceSubType` each published-resource
+ * task kind is bound by — the Studio Web / v1-skill table (`bindings/impl-json.md`
+ * § Per Task Type). Every kind but the business rule binds as a `process`; the
+ * subtype tells the platform which kind of process. An RPA process and a Flow
+ * carry no subtype on the binding.
+ */
+const REFERENCE_BINDING = {
+    process: { resource: 'process', subType: 'ProcessOrchestration' },
+    agent: { resource: 'process', subType: 'Agent' },
+    rpa: { resource: 'process' },
+    'api-workflow': { resource: 'process', subType: 'Api' },
+    'case-management': { resource: 'process', subType: 'CaseManagement' },
+    'flow-process': { resource: 'process' },
+};
+/**
+ * Mint (once per resource + resourceKey + attribute) one root binding row of a
+ * resource task's name/folderPath pair, and return its id. Two tasks on one
+ * resource share the pair: a second pair under the same key is what validate
+ * reads as two resources claiming one binding (CASE_MGMT_BINDING_KEY_SHARED).
+ */
+function resourceBinding(resolver, ids, binding, resourceKey, propertyAttribute, value) {
     for (const entry of resolver.bindingSink.values()) {
-        if (entry.resource === BUSINESS_RULE_RESOURCE && entry.resourceKey === resourceKey
+        if (entry.resource === binding.resource && entry.resourceKey === resourceKey
             && entry.propertyAttribute === propertyAttribute)
             return entry.id;
     }
-    const id = ids.make('b', 8, `binding:${BUSINESS_RULE_RESOURCE}:${resourceKey}:${propertyAttribute}`);
+    const id = ids.make('b', 8, `binding:${binding.resource}:${resourceKey}:${propertyAttribute}`);
+    // All seven fields: Studio Web fails to render a case whose binding lacks
+    // `name` or `type`.
     resolver.bindingSink.set(id, {
         id,
         name: propertyAttribute,
         type: 'string',
-        resource: BUSINESS_RULE_RESOURCE,
+        resource: binding.resource,
+        ...(binding.subType ? { resourceSubType: binding.subType } : {}),
         resourceKey,
         default: value,
         propertyAttribute,
     });
     return id;
 }
+/** The binding `resource` an action task's Action App is bound by (no subtype). */
+const ACTION_APP_RESOURCE = 'app';
+/** The `=bindings.<id>` name/folderPath references of a published-resource task. */
+function referenceBindings(kind, ref, resolver, ids) {
+    const binding = kind === 'business-rule'
+        ? { resource: BUSINESS_RULE_RESOURCE }
+        : kind === 'action'
+            ? { resource: ACTION_APP_RESOURCE }
+            : ownEntry(REFERENCE_BINDING, kind);
+    if (!binding)
+        throw new Error(`task kind "${kind}" is not a published-resource task.`);
+    // An in-solution resource (`folder: 'solution_folder'`) keeps the sentinel
+    // in its key and binds an empty folderPath — see resource-identity.ts.
+    const { resourceKey, folderPath } = resourceIdentity(ref.name, ref.folderPath);
+    const nameId = resourceBinding(resolver, ids, binding, resourceKey, 'name', ref.name);
+    const folderId = resourceBinding(resolver, ids, binding, resourceKey, 'folderPath', folderPath);
+    return { nameRef: `=bindings.${nameId}`, folderRef: `=bindings.${folderId}` };
+}
 /**
  * The `data` of a `business-rule` task, as Studio Web writes it and as the
  * CLI's `tasks describe --type business-rule` + splice produce it:
@@ -1194,12 +1308,7 @@ function businessRuleBinding(resolver, ids, resourceKey, propertyAttribute, valu
  *   (`=<Decision>.<column>`).
  */
 function businessRuleTaskData(task, resolver, elementId, ids) {
-    const ref = task.ref;
-    // An in-solution rule (`folder: 'solution_folder'`) keeps the sentinel in its
-    // key and binds an empty folderPath — see resource-identity.ts.
-    const { resourceKey, folderPath } = resourceIdentity(ref.name, ref.folderPath);
-    const nameId = businessRuleBinding(resolver, ids, resourceKey, 'name', ref.name);
-    const folderId = businessRuleBinding(resolver, ids, resourceKey, 'folderPath', folderPath);
+    const { nameRef, folderRef } = referenceBindings(task.kind, task.ref, resolver, ids);
     const ownRow = (name, source, seed, extra = {}) => {
         const slot = ids.make('v', 8, `${elementId}:${seed}`);
         return { name, type: 'jsonSchema', id: slot, var: slot, value: slot, source, target: `=${slot}`, elementId, ...extra };
@@ -1215,8 +1324,8 @@ function businessRuleTaskData(task, resolver, elementId, ids) {
         ...(task.outputs ?? []).map((o, i) => emitTaskOutput(o, elementId, ids, `${elementId}:out:${i}:${o.var}`, resolver)),
     ];
     return {
-        name: `=bindings.${nameId}`,
-        folderPath: `=bindings.${folderId}`,
+        name: nameRef,
+        folderPath: folderRef,
         version: BUSINESS_RULE_TASK_VERSION,
         inputs: (task.inputs ?? []).map((inp, i) => emitTaskInput(inp, elementId, ids, `${elementId}:in:${i}:${inp.name}`)),
         outputs,
@@ -1477,9 +1586,76 @@ function connectorMetadata(rc, op) {
 /** The `outputs[]`: a `response` json-schema from the op's output schema, plus a
  * standard `Error` schema. */
 function connectorOutputVar(resolver, base) {
-    const occurrence = (resolver.connectorOutputCounts.get(base) ?? 0) + 1;
-    resolver.connectorOutputCounts.set(base, occurrence);
-    return occurrence === 1 ? base : `${base}${occurrence}`;
+    return claimOutputId(resolver, base);
+}
+/**
+ * Claim a task-output row id from the document-wide pool, the Designer's
+ * uniqueness rule: the first claimant of `base` gets `base`, later ones get
+ * `base2`, `base3`, … (the counter starts at 2 — the Designer-saved plan has
+ * `action` / `action2` and `error` / `error2`). Every output emitter (resource,
+ * action and connector tasks) claims through here, so no two task outputs in a
+ * plan share an id.
+ */
+function claimOutputId(resolver, base) {
+    let id = base;
+    // A suffix never lands on a variable another output keeps as its own name
+    // (`ownOutputVars`): with `aPIOutput1`, a second writer of it, and a task that
+    // writes `aPIOutput12` itself, the second writer takes `aPIOutput13` whatever
+    // order the tasks come in.
+    for (let n = 2; resolver.outputIds.has(id) || (id !== base && resolver.ownOutputVars.has(id)); n++)
+        id = `${base}${n}`;
+    resolver.outputIds.add(id);
+    return id;
+}
+/** Whether a task output is written in the own-name shape (see `emitTaskOutput`). */
+function isOwnNameOutput(o) {
+    const path = o.source.replace(/^=/, '');
+    return !path.includes('.') && keepsOwnName(o.var, path);
+}
+/**
+ * Every variable a task in the plan writes under its own name: own-name task
+ * outputs and action form outputs (whose row id is the variable). Collected
+ * before any row is emitted, so `claimOutputId` can keep suffixes off them.
+ */
+function ownOutputVars(built) {
+    const vars = new Set();
+    for (const stage of built.stages)
+        for (const lane of stage.lanes)
+            for (const task of lane) {
+                for (const o of task.outputs ?? [])
+                    if (isOwnNameOutput(o))
+                        vars.add(o.var);
+                for (const f of task.action?.outputs ?? [])
+                    if (f.value !== undefined)
+                        vars.add(f.value);
+            }
+    return vars;
+}
+/**
+ * Whether an output into `name` keeps its field's name: `name` is the field, or
+ * the Designer's camelCase of it, optionally followed by a numeric suffix. The
+ * suffix is how the Designer names the variable a second writer of the same field
+ * gets (`=APIOutput1` → `aPIOutput12`, `=Action` → `action2`): it saves that row
+ * as `{ id: 'aPIOutput12', var: 'aPIOutput12' }` with no `originalVar`, so the
+ * suffixed spelling is an own-name output too, and round-trips as one.
+ */
+function keepsOwnName(name, field) {
+    // Only an identifier field: `camelizeName` drops other characters, so `items[0]`
+    // would otherwise match `items0`. The suffix is the Designer's counter, which
+    // starts at 2 and has no leading zero: for the field `APIOutput1`, `APIOutput12`
+    // matches; `APIOutput11` (suffix 1) and `APIOutput102` (suffix 02) do not.
+    if (!/^[A-Za-z_]\w*$/.test(field))
+        return false;
+    return [field, camelizeName(field)].some((base) => name === base || (name.startsWith(base) && /^(?:[2-9]|[1-9]\d+)$/.test(name.slice(base.length))));
+}
+/**
+ * The Designer's `camelizeDisplayName`: drop non-identifier characters, split on
+ * spaces/underscores, lower the first letter of the first word and upper the
+ * first letter of the rest (`APIOutput1` → `aPIOutput1`).
+ */
+function camelizeName(name) {
+    const words = name.replace(/[^a-zA-Z0-9_ ]/g, '').split(/[\s_]+/).filter(Boolean);
+    return words.map((w, i) => (i === 0 ? w.charAt(0).toLowerCase() : w.charAt(0).toUpperCase()) + w.slice(1)).join('');
 }
 /** The `Error` output's schema: the designer's (and the CLI's) `ERROR_OUTPUT_SCHEMA`. */
 const ERROR_OUTPUT_SCHEMA = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.46.2",
+  "version": "6.46.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": "c3c40cdfae94553b2d63ec072fec2c1b1f45f805"
+  "gitref": "d2cb008a329ef32af20be81f73a2ec726e22a13c"
 }