@uipath/maestro-builder-sdk 6.46.2 → 6.46.3

package/dist/case/case-sdk.d.ts

@@ -765,7 +765,7 @@ declare class TaskBuilder {
      * Reference a published Maestro process.
      *
      * @param name - The published process's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     process(name: string, opts?: {
@@ -788,7 +788,7 @@ declare class TaskBuilder {
      * Reference a published agent.
      *
      * @param name - The published agent's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     agent(name: string, opts?: {
@@ -798,7 +798,7 @@ declare class TaskBuilder {
      * Reference a published RPA process.
      *
      * @param name - The published RPA process's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     rpa(name: string, opts?: {
@@ -808,7 +808,7 @@ declare class TaskBuilder {
      * Reference a published API workflow.
      *
      * @param name - The published API workflow's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     apiWorkflow(name: string, opts?: {
@@ -820,7 +820,7 @@ declare class TaskBuilder {
      * io-binding as reference-mode tasks.
      *
      * @param name - The published child case's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     caseManagement(name: string, opts?: {
@@ -830,7 +830,7 @@ declare class TaskBuilder {
      * Reference a published Maestro Flow.
      *
      * @param name - The published Flow's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     flowProcess(name: string, opts?: {

package/dist/case/case-sdk.js

@@ -190,7 +190,7 @@ class TaskBuilder {
      * Reference a published Maestro process.
      *
      * @param name - The published process's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     process(name, opts) {
@@ -216,7 +216,7 @@ class TaskBuilder {
      * Reference a published agent.
      *
      * @param name - The published agent's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     agent(name, opts) {
@@ -226,7 +226,7 @@ class TaskBuilder {
      * Reference a published RPA process.
      *
      * @param name - The published RPA process's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     rpa(name, opts) {
@@ -236,7 +236,7 @@ class TaskBuilder {
      * Reference a published API workflow.
      *
      * @param name - The published API workflow's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     apiWorkflow(name, opts) {
@@ -248,7 +248,7 @@ class TaskBuilder {
      * io-binding as reference-mode tasks.
      *
      * @param name - The published child case's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     caseManagement(name, opts) {
@@ -258,7 +258,7 @@ class TaskBuilder {
      * Reference a published Maestro Flow.
      *
      * @param name - The published Flow's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     flowProcess(name, opts) {

package/dist/case/check.js

@@ -483,6 +483,17 @@ function checkStage(stage, diags, refStage, refPlacement) {
                 message: `Task "${t.name}" binding "${'var' in invalidBinding ? invalidBinding.var : invalidBinding.name}" has unsupported type ${JSON.stringify(invalidBinding.type)}. Use a type name such as "string" or "jsonSchema"; jsonSchema(...) is only for declaring a structured case variable.`,
                 where: t.name,
             });
+        // The builder binds a resource task itself: it mints the name/folderPath
+        // binding pair from the literal name and folder. A `=bindings.<id>` string
+        // passed as either becomes part of the binding key, which then names no
+        // resource (`=bindings.f.=bindings.n`) and dangles at deploy.
+        if (t.ref && [t.ref.name, t.ref.folderPath].some((v) => v.trim().startsWith('=bindings.')))
+            diags.push({
+                level: 'error',
+                code: 'RESOURCE_REF_IS_BINDING',
+                message: `Task "${t.name}" passes a "=bindings.<id>" reference as its resource name or folder. Pass the resource's own name and its folder, e.g. .agent('Contract Analysis', { folder: 'Shared/Legal' }); compile writes the name/folderPath binding pair keyed '<folder>.<name>' and points the task at it.`,
+                where: t.name,
+            });
         if (t.kind === 'business-rule') {
             if (!t.ref || !t.ref.name.trim() || !t.ref.folderPath.trim())
                 diags.push({

package/dist/case/compile-cli.js

@@ -292,7 +292,8 @@ function syncEntryPoints(caseplan, outPath) {
  * artifact. `resources refresh` reads bindings_v2.json, not caseplan.json, and
  * succeeds with zero warnings when the sidecar is stale or empty.
  *
- * Non-connector resources come from root binding pairs and referenced tasks.
+ * Non-connector resources come from the root binding rows only, as in
+ * `uip maestro case bindings sync`.
  * A connector's connection and folder relationship comes from the context[]
  * that references both binding ids.
  * No-op when compiling outside a scaffolded project.
@@ -308,65 +309,29 @@ function syncBindingsV2(caseplan, outPath) {
         .filter((binding) => typeof binding.id === 'string')
         .map((binding) => [binding.id, binding]));
     const resources = [];
-    const grouped = new Map();
+    // One entry per (resource, resourceKey) group of root binding rows, in the
+    // shape `uip maestro case bindings sync` derives (`deriveCaseBindingsV2` in
+    // cli case-bindings-service.ts). `validate --strict` compares the two
+    // entry by entry as serialized JSON, so field order matters as well as
+    // field values.
+    const groups = new Map();
     for (const binding of bindings) {
         const resource = stringValue(binding.resource);
         const key = stringValue(binding.resourceKey);
-        if (!resource || !key || resource.toLowerCase() === 'connection')
+        if (!resource || !key || typeof binding.propertyAttribute !== 'string')
+            continue;
+        if (resource.toLowerCase() === 'connection')
             continue;
         const groupKey = `${resource}\0${key}`;
-        let group = grouped.get(groupKey);
-        if (!group) {
-            group = { resource, key, value: {} };
-            grouped.set(groupKey, group);
-        }
-        const property = stringValue(binding.propertyAttribute) ?? stringValue(binding.name);
-        // An in-solution resource binds an empty folderPath in the caseplan, while
-        // the sidecar names its folder by the sentinel the key carries — the split
-        // `uip maestro case bindings sync` writes (resource-identity.ts).
-        const defaultValue = property === 'folderPath' && isInSolutionKey(key)
-            ? SOLUTION_FOLDER
-            : binding.default ?? key;
-        if (property)
-            group.value[property] = { defaultValue };
-        const subType = stringValue(binding.resourceSubType);
-        if (subType)
-            group.subType = subType;
+        const group = groups.get(groupKey);
+        if (group)
+            group.push(binding);
+        else
+            groups.set(groupKey, [binding]);
     }
-    const referenceTaskSubTypes = new Map([
-        ['process', 'ProcessOrchestration'],
-        ['agent', 'Agent'],
-        ['rpa', undefined],
-        ['api-workflow', 'Api'],
-        ['case-management', 'CaseManagement'],
-        ['flow-process', 'ProcessOrchestration'],
-    ]);
     const seenConnections = new Set();
     const connectionResources = [];
     visitRecords(caseplan, (record) => {
-        const type = stringValue(record.type);
-        const data = isRecord(record.data) ? record.data : undefined;
-        if (type && data && referenceTaskSubTypes.has(type)) {
-            const name = referencedBindingValue(data.name, byId);
-            const folderPath = referencedBindingValue(data.folderPath, byId);
-            if (name && folderPath) {
-                const key = referencedBindingResourceKey(data.name, byId)
-                    ?? referencedBindingResourceKey(data.folderPath, byId)
-                    ?? `${folderPath}.${name}`;
-                const groupKey = `process\0${key}`;
-                if (!grouped.has(groupKey)) {
-                    grouped.set(groupKey, {
-                        resource: 'process',
-                        key,
-                        value: {
-                            name: { defaultValue: name },
-                            folderPath: { defaultValue: folderPath },
-                        },
-                        subType: referenceTaskSubTypes.get(type),
-                    });
-                }
-            }
-        }
         if (!Array.isArray(record.context))
             return;
         const context = new Map(record.context
@@ -389,23 +354,126 @@ function syncBindingsV2(caseplan, outPath) {
             metadata: { connector },
         });
     });
-    for (const group of grouped.values()) {
-        resources.push({
-            resource: group.resource,
-            key: group.key,
-            value: group.value,
-            // A BusinessRule entry carries the bindings version deploy needs to
-            // override its folder — the metadata `uip maestro case bindings sync`
-            // writes for it (no subType).
-            metadata: group.subType
-                ? { subType: group.subType }
-                : group.resource === 'BusinessRule' ? { BindingsVersion: '2.2' } : {},
-        });
-    }
+    const labels = bindingLabels(caseplan.nodes);
+    for (const group of groups.values())
+        resources.push(sidecarResourceEntry(group, labels));
     resources.push(...connectionResources);
     writeJsonFile(sidecarPath, { version: '2.0', resources });
     return resources.length;
 }
+/**
+ * The Case Designer's label for each value slot of an app or process entry.
+ * These resources get the Designer shape (cli#5003, MST-16424): an `id`, each
+ * slot flagged and labelled, and the `BindingsVersion` / `SolutionsSupport`
+ * metadata without which deploy cannot override the entry.
+ */
+const DESIGNER_SLOT_NAMES = new Map([
+    ['app', { name: 'App name', folderPath: 'Folder path', solutionsSupport: true }],
+    ['process', { name: 'Process name', folderPath: 'Folder path', solutionsSupport: true }],
+    ['ixpDeployment', { name: 'name', folderPath: 'Folder path', solutionsSupport: false }],
+]);
+/** The bindings version deploy needs to override an entry. */
+const RESOURCE_BINDINGS_VERSION = '2.2';
+/**
+ * One sidecar entry for a group of root binding rows that share a resource and
+ * a resource key. The subtype comes from the rows only: a Flow's rows carry
+ * none, so its entry has none either, as the Designer saves it.
+ *
+ * `metadata.ActivityName` labels a Designer-shaped entry with the first task
+ * that references one of its rows ({@link bindingLabels}).
+ */
+function sidecarResourceEntry(group, labels) {
+    const resource = group[0].resource;
+    const key = group[0].resourceKey;
+    const attributeDefault = (attribute) => {
+        const found = group.find((binding) => binding.propertyAttribute === attribute)?.default;
+        return typeof found === 'string' ? found : undefined;
+    };
+    // An in-solution resource binds an empty folderPath in the caseplan, while
+    // the sidecar names its folder by the sentinel the key carries.
+    const folderPath = isInSolutionKey(key) ? SOLUTION_FOLDER : attributeDefault('folderPath');
+    const name = attributeDefault('name');
+    const subType = group.map((binding) => binding.resourceSubType).find((found) => found !== undefined);
+    const designer = DESIGNER_SLOT_NAMES.get(resource);
+    if (designer) {
+        const value = {};
+        if (folderPath !== undefined) {
+            value.folderPath = { defaultValue: folderPath, isExpression: false, displayName: designer.folderPath };
+        }
+        if (name !== undefined) {
+            value.name = { defaultValue: name, isExpression: false, displayName: designer.name };
+        }
+        const activityName = group
+            .map((binding) => (typeof binding.id === 'string' ? labels.get(binding.id) : undefined))
+            .find((found) => found !== undefined);
+        return {
+            resource,
+            key,
+            id: `${resource}${key}`,
+            value,
+            metadata: {
+                ...(activityName !== undefined && { ActivityName: activityName }),
+                BindingsVersion: RESOURCE_BINDINGS_VERSION,
+                DisplayLabel: 'name',
+                ...(designer.solutionsSupport && { SolutionsSupport: 'true' }),
+                ...(subType !== undefined && { subType }),
+            },
+        };
+    }
+    const value = {};
+    if (name !== undefined)
+        value.name = { defaultValue: name };
+    if (folderPath !== undefined)
+        value.folderPath = { defaultValue: folderPath };
+    // A solution-resource picker (such as a Data Fabric entity) carries its folder key as a slot of its own.
+    const folderKey = attributeDefault('folderKey');
+    if (folderKey !== undefined)
+        value.folderKey = { defaultValue: folderKey };
+    return {
+        resource,
+        key,
+        value,
+        metadata: {
+            BindingsVersion: RESOURCE_BINDINGS_VERSION,
+            ...(subType !== undefined && { subType }),
+        },
+    };
+}
+/**
+ * The label of the first object that references each binding id
+ * (`=bindings.<id>`), in document order: the nearest enclosing `displayName`,
+ * `display.label` or `label`. The same walk as the CLI's
+ * `collectBindingLabels`, so both name an entry after the same task.
+ */
+function bindingLabels(nodes) {
+    const found = new Map();
+    const ownLabel = (node) => {
+        const display = isRecord(node.display) ? node.display.label : undefined;
+        return [node.displayName, display, node.label].map(stringValue).find((label) => label !== undefined);
+    };
+    const walk = (node, label) => {
+        if (typeof node === 'string') {
+            if (label !== undefined && node.startsWith('=bindings.')) {
+                const id = node.slice('=bindings.'.length);
+                if (!found.has(id))
+                    found.set(id, label);
+            }
+            return;
+        }
+        if (Array.isArray(node)) {
+            for (const item of node)
+                walk(item, label);
+            return;
+        }
+        if (!isRecord(node))
+            return;
+        const scoped = ownLabel(node) ?? label;
+        for (const value of Object.values(node))
+            walk(value, scoped);
+    };
+    walk(nodes ?? [], undefined);
+    return found;
+}
 function referencedBindingValue(value, bindings) {
     const ref = stringValue(value);
     if (!ref)
@@ -415,12 +483,6 @@ function referencedBindingValue(value, bindings) {
     const binding = bindings.get(ref.slice('=bindings.'.length));
     return binding && (stringValue(binding.default) ?? stringValue(binding.resourceKey));
 }
-function referencedBindingResourceKey(value, bindings) {
-    const ref = stringValue(value);
-    if (!ref?.startsWith('=bindings.'))
-        return undefined;
-    return stringValue(bindings.get(ref.slice('=bindings.'.length))?.resourceKey);
-}
 function visitRecords(value, visit) {
     if (Array.isArray(value)) {
         for (const item of value)

package/dist/case/decompile.js

@@ -344,11 +344,24 @@ function bindingName(value, refs) {
     const id = value.slice('=bindings.'.length);
     return refs.bindingById.get(id)?.id ?? id;
 }
-function bindingDefault(value, refs) {
+/**
+ * The literal a resource task's `data.name` / `data.folderPath` names: the
+ * value itself, or the `default` of the root binding row a `=bindings.<id>`
+ * reference points at. A reference the plan's root `bindings[]` cannot answer
+ * (no such row, or a row with no `default`) is refused: the plan names no
+ * resource there, and emitting the reference as the name would only fail
+ * again at compile.
+ */
+function bindingDefault(value, refs, owner, field) {
     if (typeof value !== 'string' || !value.startsWith('=bindings.'))
         return value;
     const id = value.slice('=bindings.'.length);
-    return refs.bindingById.get(id)?.default ?? value;
+    const row = refs.bindingById.get(id);
+    if (typeof row?.default !== 'string')
+        throw new Error(`${owner} data.${field} is "${value}", but the plan's root bindings ${row ? `row "${id}" has no default` : `declare no row "${id}"`}, `
+            + `so decompile cannot recover the resource ${field === 'name' ? 'name' : 'folder'}. `
+            + `Give the task a name/folderPath binding pair whose rows carry the resource's name and folder as their defaults (what Studio Web writes), then decompile again.`);
+    return row.default;
 }
 /**
  * The folder a resource task's `folderPath` reference names, as the author
@@ -357,13 +370,13 @@ function bindingDefault(value, refs) {
  * (resource-identity.ts), so lift the sentinel back rather than the empty
  * default, which would recompile to the key `.<name>`.
  */
-function bindingFolder(value, refs) {
+function bindingFolder(value, refs, owner) {
     if (typeof value === 'string' && value.startsWith('=bindings.')) {
         const row = refs.bindingById.get(value.slice('=bindings.'.length));
         if (typeof row?.resourceKey === 'string' && isInSolutionKey(row.resourceKey))
             return SOLUTION_FOLDER;
     }
-    return bindingDefault(value, refs);
+    return bindingDefault(value, refs, owner, 'folderPath');
 }
 function selectNextStageByExit(plan, refs) {
     const raw = plan.metadata?.waitForHumanSelectNextStageDFConnector;
@@ -606,9 +619,12 @@ function emitTaskKind(task, refs, library) {
                 throw new Error(`unresolved ${kind} task "${task.displayName ?? task.id ?? '?'}" cannot carry input or output bindings.`);
             return `.unresolved(${tsLiteral(kind)})`;
         }
-        const name = bindingDefault(data.name, refs);
-        const folderPath = bindingDefault(data.folderPath, refs);
-        const folder = folderPath ? `, ${opts([['folder', tsLiteral(folderPath)]])}` : '';
+        const owner = `${kind} task "${task.displayName ?? task.id ?? '?'}"`;
+        const name = bindingDefault(data.name, refs, owner, 'name');
+        const folderPath = bindingFolder(data.folderPath, refs, owner);
+        // No folder already means the case's own solution folder
+        // (resource-identity.ts), so an in-solution resource decompiles to none.
+        const folder = folderPath && folderPath !== SOLUTION_FOLDER ? `, ${opts([['folder', tsLiteral(folderPath)]])}` : '';
         return `.${method}(${tsLiteral(name ?? '')}${folder})`;
     }
     if (isAuthorableBusinessRule(task))
@@ -674,8 +690,8 @@ function isBusinessRuleOwnOutput(row) {
 function businessRuleCall(task, refs) {
     const data = task.data ?? {};
     const owner = `business-rule task "${task.displayName ?? task.id ?? '?'}"`;
-    const name = bindingDefault(data.name, refs);
-    const folderPath = bindingFolder(data.folderPath, refs);
+    const name = bindingDefault(data.name, refs, owner, 'name');
+    const folderPath = bindingFolder(data.folderPath, refs, owner);
     if (typeof name !== 'string' || !name || typeof folderPath !== 'string')
         throw new Error(`${owner} must name its rule and folder (data.name / data.folderPath).`);
     const outputRow = (Array.isArray(data.outputs) ? data.outputs : [])

package/dist/case/resource-identity.d.ts

@@ -30,7 +30,15 @@ export interface ResourceIdentity {
     /** The `default` of the `folderPath` binding row. */
     folderPath: string;
 }
-/** The binding identity of resource `name` authored in `folder`. */
+/**
+ * The binding identity of resource `name` authored in `folder`. No folder
+ * means the case's own solution folder, the same as `solution_folder`:
+ *
+ *   .process('notify') -> resourceKey 'solution_folder.notify', folderPath ''
+ *
+ * (A literal `.notify` key would name no folder, and deploy and `resources
+ * refresh` could not match it.)
+ */
 export declare function resourceIdentity(name: string, folder: string): ResourceIdentity;
 /** True for the key of a resource built inside the same solution. */
 export declare function isInSolutionKey(resourceKey: string): boolean;

package/dist/case/resource-identity.js

@@ -25,9 +25,17 @@
  */
 export const SOLUTION_FOLDER = 'solution_folder';
 const SOLUTION_FOLDER_KEY_PREFIX = `${SOLUTION_FOLDER}.`;
-/** The binding identity of resource `name` authored in `folder`. */
+/**
+ * The binding identity of resource `name` authored in `folder`. No folder
+ * means the case's own solution folder, the same as `solution_folder`:
+ *
+ *   .process('notify') -> resourceKey 'solution_folder.notify', folderPath ''
+ *
+ * (A literal `.notify` key would name no folder, and deploy and `resources
+ * refresh` could not match it.)
+ */
 export function resourceIdentity(name, folder) {
-    if (folder === SOLUTION_FOLDER)
+    if (folder === SOLUTION_FOLDER || !folder.trim())
         return { resourceKey: `${SOLUTION_FOLDER_KEY_PREFIX}${name}`, folderPath: '' };
     return { resourceKey: `${folder}.${name}`, folderPath: folder };
 }

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}`));
@@ -1104,10 +1135,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 +1166,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 +1226,62 @@ 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 `=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 }
+        : 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 +1297,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 +1313,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 +1575,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.3",
   "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": "b763fc50a8d6430ce9a6e3e3e6b79b7c8645a4b1"
 }