@uipath/maestro-builder-sdk 6.66.2 → 6.66.4

package/dist/case/decompile.js

@@ -4,7 +4,7 @@ import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
 import { EXTERNAL_TASK_CONTEXT, externalDescriptorRefusal, externalHybridRefusal, externalServiceType, isExternalExecutionMode } from './external.js';
 import { preserveSchemaVersion } from '../schema-version.js';
 import { ownEntry } from '../core/own-entry.js';
-import { isUnrestorableSlotId } from './preserve.js';
+import { isUnrestorableSlotId, taskFingerprint } from './preserve.js';
 import { isInSolutionKey, SOLUTION_FOLDER } from './resource-identity.js';
 import { offlineBindingLabel } from './ids.js';
 const TASK_KIND_METHOD = {
@@ -1172,7 +1172,14 @@ function refuseUnsupportedAuthoring(plan) {
 function conditionIdentity(condition) {
     return {
         ...(condition.id ? { id: condition.id } : {}),
-        rules: (condition.rules ?? []).map((group) => group.map((rule) => ({ ...(rule.id ? { id: rule.id } : {}) }))),
+        rules: (condition.rules ?? []).map((group) => group.map((rule) => ({
+            ...(rule.id ? { id: rule.id } : {}),
+            // A wait-for-connector rule's rows take their ids from the plan-wide pool,
+            // so deleting an earlier output would renumber them.
+            ...(rule.uipath?.outputs?.length
+                ? { outputs: rule.uipath.outputs.map((row) => ({ name: row.name ?? '', ...(row.id ? { id: row.id } : {}) })) }
+                : {}),
+        }))),
     };
 }
 function slaIdentity(sla) {
@@ -1231,20 +1238,25 @@ function identityPreservation(plan) {
     return {
         ...(plan.id ? { id: plan.id } : {}),
         triggers: (plan.nodes ?? []).filter(isTrigger).map((node) => ({ ...(node.id ? { id: node.id } : {}) })),
-        stages: (plan.nodes ?? []).filter(isStage).map((stage) => ({
-            label: stage.data?.label ?? '',
-            ...(stage.id ? { id: stage.id } : {}),
-            tasks: (stage.data?.tasks ?? []).map((lane) => lane.map((task) => ({
-                name: task.displayName ?? '',
-                ...(task.id ? { id: task.id } : {}),
-                entryConditions: (task.entryConditions ?? []).map(conditionIdentity),
-                inputs: (task.data?.inputs ?? []).map((row) => ({ name: row.name ?? '', ...(row.id ? { id: row.id } : {}) })),
-                outputs: (task.data?.outputs ?? []).map((row) => ({ name: row.name ?? '', ...(row.id ? { id: row.id } : {}) })),
-            }))),
-            entryConditions: (stage.data?.entryConditions ?? []).map(conditionIdentity),
-            exitConditions: (stage.data?.exitConditions ?? []).map(conditionIdentity),
-            slaRules: (stage.data?.slaRules ?? []).map(slaIdentity),
-        })),
+        stages: (plan.nodes ?? []).filter(isStage).map((stage) => {
+            const shape = (task) => JSON.stringify([task.data?.inputs, task.data?.outputs].map((rows) => (rows ?? []).map((row) => row.name ?? '')));
+            const shapes = (stage.data?.tasks ?? []).flat().map(shape);
+            return {
+                label: stage.data?.label ?? '',
+                ...(stage.id ? { id: stage.id } : {}),
+                tasks: (stage.data?.tasks ?? []).map((lane) => lane.map((task) => ({
+                    name: task.displayName ?? '',
+                    ...(task.id ? { id: task.id } : {}),
+                    entryConditions: (task.entryConditions ?? []).map(conditionIdentity),
+                    inputs: (task.data?.inputs ?? []).map((row) => ({ name: row.name ?? '', ...(row.id ? { id: row.id } : {}) })),
+                    outputs: (task.data?.outputs ?? []).map((row) => ({ name: row.name ?? '', ...(row.id ? { id: row.id } : {}) })),
+                    ...(shapes.filter((other) => other === shape(task)).length > 1 ? { fingerprint: taskFingerprint(task) } : {}),
+                }))),
+                entryConditions: (stage.data?.entryConditions ?? []).map(conditionIdentity),
+                exitConditions: (stage.data?.exitConditions ?? []).map(conditionIdentity),
+                slaRules: (stage.data?.slaRules ?? []).map(slaIdentity),
+            };
+        }),
         caseExitRules: (plan.metadata?.caseExitRules ?? []).map(conditionIdentity),
         slaRules: (plan.metadata?.slaRules ?? []).map(slaIdentity),
         variables: Object.fromEntries(['inputs', 'outputs', 'inputOutputs'].map((lane) => [
@@ -1374,7 +1386,6 @@ export function collectPreservation(plan) {
         preservation.omitTaskElementIds = omitTaskElementIds;
     if (omitStagePositions.length)
         preservation.omitStagePositions = omitStagePositions;
-    const produced = producedVariableNames(plan);
     const variableKnown = new Set(['id', 'name', 'type', 'default', 'body', '_jsonSchema', 'elementId', 'var', 'custom']);
     const variableFields = {};
     const legacyVariableDefaults = {};
@@ -1390,7 +1401,9 @@ export function collectPreservation(plan) {
             for (const field of Object.keys(fields))
                 if (!['subType', 'canonicalId', 'camelizedId', 'variableType', 'internal'].includes(field))
                     throw new Error(`variable "${row.name}" has unsupported field "${field}", which is not allowed in the collision-refusing preservation channel.`);
-            if (lane === 'inputOutputs' && row.custom && !produced.has(row.name))
+            // Carried even while an output writes the variable, so deleting its last
+            // writer keeps the flag; `applyPreservation` reads an equal value as agreement.
+            if (lane === 'inputOutputs' && row.custom)
                 fields.custom = true;
             const formalOutput = (plan.variables?.outputs ?? []).find((candidate) => candidate.name === row.name);
             if (lane === 'inputOutputs' && formalOutput && row.default !== undefined && formalOutput.default !== row.default)

package/dist/case/merge.d.ts

@@ -3,9 +3,9 @@ export type CaseDocument = Record<string, unknown>;
 export interface CaseMergeOptions {
     /**
      * Called once per finding. Today the only finding is a construct the original
-     * carried an identity for that the edited document no longer has — a rename or
-     * a delete, which are indistinguishable here and which silently drop the
-     * original's ids for that construct.
+     * carried an identity for that the edited document no longer has — a delete, or
+     * a rename `followRenames` could not pair — which silently drops the original's
+     * ids for that construct.
      */
     warn?: (message: string) => void;
 }

package/dist/case/merge.js

@@ -22,9 +22,11 @@
  * merge cannot use.
  *
  * What it uses instead is what the preservation channel already uses: stage
- * LABEL, task displayName, lane and position. That is not a second mechanism —
- * it is the same one, read from the original file at merge time rather than
- * from a `preserveCaseJson(...)` payload baked into the source.
+ * LABEL, task displayName, lane and position, with `followRenames` first
+ * re-pointing a stage or task the edit renamed or moved (see its doc) so it keeps
+ * its ids. That is not a second mechanism — it is the same one, read from the
+ * original file at merge time rather than from a `preserveCaseJson(...)` payload
+ * baked into the source.
  *
  * ## What each side decides
  *
@@ -47,7 +49,7 @@
  * cannot drift from it.
  */
 import { collectPreservation } from './decompile.js';
-import { applyPreservation } from './serialize.js';
+import { applyPreservation, followRenames } from './serialize.js';
 import { jsonClone } from '../core/json-clone.js';
 /** Stage labels in a document, in order. */
 function stageLabels(document) {
@@ -79,8 +81,9 @@ function warnOrphanedIdentities(preservation, edited, warn) {
     for (const stage of preservation.identities?.stages ?? []) {
         if (!labels.has(stage.label)) {
             warn(`stage "${stage.label}" is in the original but not in the edited case, so its ids are dropped. `
-                + `If this was a RENAME rather than a delete, the renamed stage gets a new id and every reference `
-                + `to the old one goes with it — rename in the original first, or keep the label.`);
+                + `A renamed stage keeps its ids while it still holds one of its tasks by name, or when the edit `
+                + `leaves as many new stages as it removed. Neither holds here, so if this was a RENAME, the renamed `
+                + `stage gets a new id and every reference to the old one goes with it: keep a task's name, or keep the label.`);
             continue;
         }
         const present = tasks.get(stage.label) ?? new Set();
@@ -88,7 +91,8 @@ function warnOrphanedIdentities(preservation, edited, warn) {
             for (const task of lane)
                 if (!present.has(task.name))
                     warn(`task "${task.name}" in stage "${stage.label}" is in the original but not in the edited case, `
-                        + `so its ids are dropped. A rename reads the same as a delete here.`);
+                        + `so its ids are dropped. A renamed or moved task keeps its ids only when its input and output `
+                        + `rows keep their names; with those changed too, a rename reads the same as a delete.`);
     }
 }
 /**
@@ -102,7 +106,7 @@ export function mergeCase(original, edited, options = {}) {
     if (!preservation)
         return jsonClone(edited);
     if (options.warn)
-        warnOrphanedIdentities(preservation, edited, options.warn);
+        warnOrphanedIdentities(followRenames(edited, preservation), edited, options.warn);
     // `applyPreservation` is what `compile` runs with the payload a source
     // carries. Handing it the ORIGINAL's payload and the EDITED graph is the whole
     // merge: same operation, different provenance.

package/dist/case/preserve.d.ts

@@ -33,6 +33,10 @@ interface ConditionIdentity {
     id?: string;
     rules?: Array<Array<{
         id?: string;
+        outputs?: Array<{
+            name: string;
+            id?: string;
+        }>;
     }>>;
 }
 interface SlaIdentity {
@@ -56,11 +60,19 @@ interface StageIdentity {
             name: string;
             id?: string;
         }>;
+        /** `taskFingerprint`, for a task a sibling shares its row names with. */
+        fingerprint?: string;
     }>>;
     entryConditions?: ConditionIdentity[];
     exitConditions?: ConditionIdentity[];
     slaRules?: SlaIdentity[];
 }
+/**
+ * A task less its rows, its ids and every display name (a condition's defaults
+ * to its task's): what renaming it leaves alone, so a rename beside a deleted
+ * sibling of the same shape can be told from the delete.
+ */
+export declare function taskFingerprint(task: object): string;
 interface CaseIdentityPreservation {
     id?: string;
     triggers?: Array<{

package/dist/case/preserve.js

@@ -1,3 +1,4 @@
+import { stableId } from '../core/stable-id.js';
 /**
  * A preserved `inputs[]` / `outputs[]` slot id copied verbatim from its name is
  * the STRICT_FORMAL_ARG_ID defect, not an identity to keep; the minted id stands.
@@ -5,6 +6,26 @@
 export function isUnrestorableSlotId(lane, row) {
     return lane !== 'inputOutputs' && typeof row.id === 'string' && row.id === row.name;
 }
+/**
+ * A task less its rows, its ids and every display name (a condition's defaults
+ * to its task's): what renaming it leaves alone, so a rename beside a deleted
+ * sibling of the same shape can be told from the delete.
+ */
+export function taskFingerprint(task) {
+    const canonical = (value) => {
+        if (Array.isArray(value))
+            return value.map(canonical);
+        if (!value || typeof value !== 'object')
+            return value;
+        return Object.fromEntries(Object.entries(value)
+            .filter(([key]) => key !== 'id' && key !== 'elementId' && key !== 'displayName')
+            .sort(([a], [b]) => (a < b ? -1 : 1))
+            .map(([key, inner]) => [key, canonical(inner)]));
+    };
+    const { data, ...rest } = task;
+    const { inputs: _inputs, outputs: _outputs, ...fields } = data ?? {};
+    return stableId(JSON.stringify(canonical({ ...rest, data: fields })));
+}
 const preserved = new WeakMap();
 /** Attach decompiler-owned, non-authoring wire data to a built case. */
 export function preserveCaseJson(built, payload) {

package/dist/case/serialize.d.ts

@@ -31,3 +31,19 @@ export interface ApplyPreservationOptions {
  * same operation compile performs with the payload the source carries.
  */
 export declare function applyPreservation(result: Record<string, unknown>, preservation: CaseJsonPreservation | undefined, options?: ApplyPreservationOptions): Record<string, unknown>;
+/**
+ * The payload with each stage label and task name an edit renamed rewritten to
+ * the one compiled, so a renamed stage or task keeps its ids and wire fields
+ * instead of reading as a delete plus an add. Stages left over on both sides
+ * pair by the most task names shared, then the fewest not shared, then in order
+ * when as many are left on each side; a task left over pairs with one in the
+ * same stage whose input and output rows have the same names, and a task gone
+ * from its stage that another stage now holds under the same name and rows
+ * moved there.
+ *
+ * `wanted` is the payload's side (identities read from the original plan),
+ * `compiled` this compile's. Per stage, `missing` tasks are the payload's that
+ * the compiled stage no longer names, `extra` tasks the compiled stage's that
+ * the payload does not.
+ */
+export declare function followRenames(result: Record<string, unknown>, preservation: CaseJsonPreservation): CaseJsonPreservation;

package/dist/case/serialize.js

@@ -9,7 +9,7 @@
  * name) are resolved here to the generated ids.
  */
 import { IdGen, offlineBindingSeed } from './ids.js';
-import { isUnrestorableSlotId } from './preserve.js';
+import { isUnrestorableSlotId, taskFingerprint } from './preserve.js';
 import { v31TaskSets } from './task-sets.js';
 import { camelizeName, defaultActionOutputVar } from './action-output-var.js';
 import { buildConnectorInputs, nestConnectorBody, replayInputsOf, transportHttpMethod } from '../core/connector-inputs.js';
@@ -23,6 +23,7 @@ import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, EXTERNAL_TASK_HYBRID_UNSUPPORTED, ex
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
 import { isResourceLabelRefusal, resolveResourceRef, resourceIdentity } from './resource-identity.js';
 import { ownEntry } from '../core/own-entry.js';
+import { stableId } from '../core/stable-id.js';
 import { resolveSchemaVersion } from '../schema-version.js';
 import { caseJsonPreservation, caseJsonPreservationErrors, } from './preserve.js';
 import { businessEventProblems } from './business-event-shape.js';
@@ -30,6 +31,13 @@ import { readEventFilterLeaf, eventFilterTreeLeaf } from '../core/event-filters.
 import { responseJsonSchema } from '../core/connector-response-schema.js';
 import { ruleShapeProblems } from './rule-options.js';
 import { CompileRefusal } from '../core/compile-refusal.js';
+/** The ids a serialize pass hashed from element ids, by the document it returned. */
+const ELEMENT_SEEDED_IDS = new WeakMap();
+function elementSeededId(resolver, elementId, suffix) {
+    const id = stableId(`${elementId}${suffix}`);
+    resolver.elementSeededIds.push({ elementId, suffix, id });
+    return id;
+}
 /**
  * Condition `displayName` allocator.
  *
@@ -102,6 +110,7 @@ export function serialize(built, opts = {}) {
         escalationIdByName: new Map(),
         businessEvents: new Set((built.businessEvents ?? []).map((event) => event.name)),
         conditionName: conditionNamer(built),
+        elementSeededIds: [],
     };
     // Preallocate SLA + escalation ids (before any rule is emitted) so a
     // `sla-status-change` rule can resolve the `slaId`/`escalationId` it points at.
@@ -282,6 +291,7 @@ export function serialize(built, opts = {}) {
             }
             : {}),
     };
+    ELEMENT_SEEDED_IDS.set(result, resolver.elementSeededIds);
     const plan = stampConnectorConfigVersion(applyAuthorLayout(applyPreservation(result, caseJsonPreservation(built)), built.layout));
     // Last, over the finished document: V32 requires case-unique condition names,
     // and an author (or a decompiled pre-V32 plan) can repeat one. Rename the
@@ -396,6 +406,7 @@ export function applyPreservation(result, preservation, options = {}) {
     const errors = caseJsonPreservationErrors(preservation);
     if (errors.length)
         throw new CompileRefusal('PRESERVATION_COLLISION', `invalid Case JSON preservation payload: ${errors.join('; ')}`);
+    preservation = followRenames(result, preservation);
     applyPreservedIdentities(result, preservation);
     Object.assign(result, preservation.topLevel ?? {});
     Object.assign(result.metadata, preservation.metadata ?? {});
@@ -431,9 +442,15 @@ export function applyPreservation(result, preservation, options = {}) {
             const row = rows.find((candidate) => candidate.name === name);
             if (!row && options.overwrite)
                 continue;
+            // `custom` alone has nothing to mark when no row is written: an older SDK's
+            // companion for a variable an output writes, which this one migrates away.
+            if (!row && Object.keys(fields).every((field) => field === 'custom'))
+                continue;
             if (!row)
                 throw new CompileRefusal('PRESERVATION_TARGET_MISSING', `preserved variable "${name}" was not regenerated in variables.${lane}.`);
             for (const [field, value] of Object.entries(fields)) {
+                if (row[field] === value)
+                    continue;
                 if (!options.overwrite && Object.prototype.hasOwnProperty.call(row, field))
                     throw new CompileRefusal('PRESERVATION_FIELD_COLLISION', `preserved variable "${name}" field "${field}" collides with serializer-owned output.`);
                 row[field] = value;
@@ -524,14 +541,171 @@ export function applyPreservation(result, preservation, options = {}) {
         nodes.sort((left, right) => (order.get(String(left.id ?? '')) ?? Number.MAX_SAFE_INTEGER)
             - (order.get(String(right.id ?? '')) ?? Number.MAX_SAFE_INTEGER));
     }
+    // A stage the payload names that was not regenerated was deleted by the edit:
+    // its edges and canvas position go with it.
+    const nodeIds = new Set(result.nodes.map((node) => node.id));
+    const gone = new Set((preservation.identities?.stages ?? []).flatMap((stage) => (stage.id && !nodeIds.has(stage.id) ? [stage.id] : [])));
     if (preservation.edges !== undefined)
-        result.edges = preservation.edges;
+        result.edges = preservation.edges.filter((edge) => !gone.has(edge?.source) && !gone.has(edge?.target));
     if (preservation.layout !== undefined)
-        result.layout = preservation.layout;
+        result.layout = withoutLayoutNodes(preservation.layout, gone);
     else if (preservation.omitLayout)
         delete result.layout;
     return result;
 }
+function withoutLayoutNodes(layout, gone) {
+    const nodes = layout?.nodes;
+    if (!gone.size || !nodes || typeof nodes !== 'object' || !Object.keys(nodes).some((id) => gone.has(id)))
+        return layout;
+    return { ...layout, nodes: Object.fromEntries(Object.entries(nodes).filter(([id]) => !gone.has(id))) };
+}
+/**
+ * The payload with each stage label and task name an edit renamed rewritten to
+ * the one compiled, so a renamed stage or task keeps its ids and wire fields
+ * instead of reading as a delete plus an add. Stages left over on both sides
+ * pair by the most task names shared, then the fewest not shared, then in order
+ * when as many are left on each side; a task left over pairs with one in the
+ * same stage whose input and output rows have the same names, and a task gone
+ * from its stage that another stage now holds under the same name and rows
+ * moved there.
+ *
+ * `wanted` is the payload's side (identities read from the original plan),
+ * `compiled` this compile's. Per stage, `missing` tasks are the payload's that
+ * the compiled stage no longer names, `extra` tasks the compiled stage's that
+ * the payload does not.
+ */
+export function followRenames(result, preservation) {
+    const wanted = preservation.identities?.stages ?? [];
+    if (!wanted.length)
+        return preservation;
+    const compiled = (result.nodes ?? []).filter((node) => String(node.type ?? '').endsWith('Stage'));
+    const labelOf = (stage) => String(stage.data?.label ?? '');
+    const tasksOf = (stage) => (stage.data?.tasks ?? []).flat().filter((task) => task && typeof task === 'object');
+    const compiledLabels = new Set(compiled.map(labelOf));
+    const wantedLabels = new Set(wanted.map((stage) => stage.label));
+    const unmatchedCompiled = compiled.filter((stage) => !wantedLabels.has(labelOf(stage)));
+    const stageLabels = new Map();
+    const paired = new Set();
+    const unmatchedWanted = wanted.filter((stage) => !compiledLabels.has(stage.label));
+    // Ranked across every pair, so a deleted stage that shares one task name with
+    // a renamed stage cannot take it from the stage that shares more.
+    const stagePairs = unmatchedWanted.flatMap((stage, from) => {
+        const names = new Set((stage.tasks ?? []).flat().map((task) => task.name));
+        return unmatchedCompiled.flatMap((candidate, to) => {
+            const tasks = tasksOf(candidate);
+            const shared = tasks.filter((task) => names.has(String(task.displayName ?? ''))).length;
+            return shared ? [{ from, to, shared, unshared: names.size + tasks.length - 2 * shared }] : [];
+        });
+    });
+    stagePairs.sort((a, b) => b.shared - a.shared || a.unshared - b.unshared || a.from - b.from || a.to - b.to);
+    for (const { from, to } of stagePairs) {
+        if (stageLabels.has(unmatchedWanted[from].label) || paired.has(unmatchedCompiled[to]))
+            continue;
+        paired.add(unmatchedCompiled[to]);
+        stageLabels.set(unmatchedWanted[from].label, labelOf(unmatchedCompiled[to]));
+    }
+    const unpairedWanted = unmatchedWanted.filter((stage) => !stageLabels.has(stage.label));
+    const unpairedCompiled = unmatchedCompiled.filter((stage) => !paired.has(stage));
+    if (unpairedWanted.length === unpairedCompiled.length)
+        unpairedWanted.forEach((stage, index) => stageLabels.set(stage.label, labelOf(unpairedCompiled[index])));
+    const rowNames = (inputs, outputs) => JSON.stringify([inputs, outputs].map((rows) => (Array.isArray(rows) ? rows : []).map((row) => String(row?.name ?? ''))));
+    const nameOf = (task) => String(task.displayName ?? '');
+    const stageSides = wanted.map((stage) => {
+        const target = compiled.find((candidate) => labelOf(candidate) === (stageLabels.get(stage.label) ?? stage.label));
+        const tasks = (stage.tasks ?? []).flat();
+        const current = target ? tasksOf(target) : [];
+        const currentNames = new Set(current.map(nameOf));
+        const names = new Set(tasks.map((task) => task.name));
+        return { stage, target, missing: tasks.filter((task) => !currentNames.has(task.name)), extra: current.filter((task) => !names.has(nameOf(task))) };
+    });
+    const targeted = new Set(stageSides.map((side) => side.target));
+    const extraTasks = [
+        ...stageSides.flatMap(({ target, extra }) => (target ? extra.map((task) => ({ stage: labelOf(target), task })) : [])),
+        ...compiled.filter((stage) => !targeted.has(stage)).flatMap((stage) => tasksOf(stage).map((task) => ({ stage: labelOf(stage), task }))),
+    ];
+    const missingTasks = stageSides.flatMap(({ stage, missing }) => missing.map((task) => ({ stage: stage.label, task })));
+    const moves = new Map();
+    const claimed = new Set();
+    for (const { stage, task } of missingTasks) {
+        const rows = rowNames(task.inputs, task.outputs);
+        const to = extraTasks.filter((extra) => nameOf(extra.task) === task.name && rowNames(extra.task.data?.inputs, extra.task.data?.outputs) === rows);
+        if (to.length !== 1 || missingTasks.filter((other) => other.task.name === task.name).length !== 1)
+            continue;
+        if (!moves.has(stage))
+            moves.set(stage, new Map());
+        moves.get(stage).set(task.name, to[0].stage);
+        claimed.add(to[0].task);
+    }
+    const movedTo = (label, name) => moves.get(label)?.get(name);
+    const taskNames = new Map();
+    for (const side of stageSides) {
+        if (!side.target)
+            continue;
+        const missing = side.missing.filter((task) => !movedTo(side.stage.label, task.name));
+        const extra = side.extra
+            .filter((task) => !claimed.has(task))
+            .map((task) => ({ name: nameOf(task), rows: rowNames(task.data?.inputs, task.data?.outputs), task }));
+        // A deleted sibling can share a renamed task's rows, so the one whose content
+        // the renamed task still has wins, then the old name closest to the new one,
+        // then the earlier task.
+        const candidates = missing.flatMap((task, from) => extra.flatMap((candidate, to) => candidate.rows === rowNames(task.inputs, task.outputs)
+            ? [{ from, to, same: Number(task.fingerprint !== undefined && task.fingerprint === taskFingerprint(candidate.task)), score: nameAffinity(task.name, candidate.name) }]
+            : []));
+        candidates.sort((a, b) => b.same - a.same || b.score - a.score || a.from - b.from || a.to - b.to);
+        const renames = new Map();
+        const taken = new Set();
+        for (const { from, to } of candidates) {
+            if (renames.has(missing[from].name) || taken.has(to))
+                continue;
+            renames.set(missing[from].name, extra[to].name);
+            taken.add(to);
+        }
+        if (renames.size)
+            taskNames.set(side.stage.label, renames);
+    }
+    if (!stageLabels.size && !taskNames.size && !moves.size)
+        return preservation;
+    const stageName = (label) => stageLabels.get(label) ?? label;
+    const taskName = (label, name) => taskNames.get(label)?.get(name) ?? name;
+    const ref = (entry) => ({ ...entry, stage: movedTo(entry.stage, entry.task) ?? stageName(entry.stage), task: taskName(entry.stage, entry.task) });
+    const stages = wanted.map((stage) => ({
+        ...stage,
+        label: stageName(stage.label),
+        ...(stage.tasks
+            ? { tasks: stage.tasks.map((lane) => lane.filter((task) => !movedTo(stage.label, task.name)).map((task) => ({ ...task, name: taskName(stage.label, task.name) }))) }
+            : {}),
+    }));
+    for (const { stage: from, task } of missingTasks) {
+        const to = movedTo(from, task.name);
+        if (!to)
+            continue;
+        const target = stages.find((stage) => stage.label === to);
+        if (target)
+            target.tasks = [...(target.tasks ?? []), [task]];
+        else
+            stages.push({ label: to, tasks: [[task]] });
+    }
+    return {
+        ...preservation,
+        identities: {
+            ...preservation.identities,
+            stages,
+        },
+        ...(preservation.taskFields ? { taskFields: preservation.taskFields.map(ref) } : {}),
+        ...(preservation.omitTaskElementIds ? { omitTaskElementIds: preservation.omitTaskElementIds.map(ref) } : {}),
+        ...(preservation.omitStagePositions ? { omitStagePositions: preservation.omitStagePositions.map(stageName) } : {}),
+    };
+}
+/** How much of a renamed name survives: the longer of the shared prefix and the shared suffix. */
+function nameAffinity(before, after) {
+    let prefix = 0;
+    while (prefix < before.length && before[prefix] === after[prefix])
+        prefix++;
+    let suffix = 0;
+    while (suffix < before.length && suffix < after.length && before.at(-1 - suffix) === after.at(-1 - suffix))
+        suffix++;
+    return Math.max(prefix, suffix);
+}
 function applyPreservedIdentities(result, preservation) {
     const identities = preservation.identities;
     if (!identities)
@@ -543,11 +717,70 @@ function applyPreservedIdentities(result, preservation) {
         replacements.set(current.id, wanted);
         current.id = wanted;
     };
+    const nodes = result.nodes;
+    const stages = nodes.filter((node) => String(node.type).endsWith('Stage'));
+    const bagField = CASE_FORMAT_PROFILE.waitConnectorRuleBagField;
+    const ruleOutputRows = (conditions) => (conditions ?? []).flatMap((condition) => (condition?.rules ?? []).flat().flatMap((rule) => rule?.[bagField]?.outputs ?? []));
+    // Every output row id in the plan, task and rule rows alike, 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) {
+        const rows = [
+            ...ruleOutputRows(stage.data?.entryConditions),
+            ...ruleOutputRows(stage.data?.exitConditions),
+            ...(stage.data?.tasks ?? []).flat().flatMap((task) => [...(task?.data?.outputs ?? []), ...ruleOutputRows(task?.entryConditions)]),
+        ];
+        for (const row of rows)
+            if (typeof row?.id === 'string')
+                heldOutputIds.add(row.id);
+    }
+    for (const row of ruleOutputRows(result.metadata?.caseExitRules))
+        if (typeof row?.id === 'string')
+            heldOutputIds.add(row.id);
+    const takeOutputRows = (outputRows, wantedRows) => {
+        // Match by name when unique on both sides, else by position.
+        const unique = (names, name) => names.filter((n) => n === name).length === 1;
+        const currentNames = outputRows.map((r) => r?.name);
+        const wantedNames = wantedRows.map((r) => r.name);
+        const named = new Set(wantedRows.filter((r) => unique(wantedNames, r.name) && unique(currentNames, r.name)).map((r) => r.name));
+        wantedRows.forEach((row, index) => {
+            const target = named.has(row.name)
+                ? outputRows.find((r) => r?.name === row.name)
+                // 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;
+            }
+        });
+    };
     const takeConditions = (current, wanted) => {
         (wanted ?? []).forEach((condition, index) => {
             const target = current?.[index];
             take(target, condition.id);
-            (condition.rules ?? []).forEach((group, groupIndex) => group.forEach((rule, ruleIndex) => take(target?.rules?.[groupIndex]?.[ruleIndex], rule.id)));
+            (condition.rules ?? []).forEach((group, groupIndex) => group.forEach((rule, ruleIndex) => {
+                const ruleTarget = target?.rules?.[groupIndex]?.[ruleIndex];
+                take(ruleTarget, rule.id);
+                if (rule.outputs)
+                    takeOutputRows(ruleTarget?.[bagField]?.outputs ?? [], rule.outputs);
+            }));
         });
     };
     const takeSlas = (current, wanted) => {
@@ -558,22 +791,8 @@ function applyPreservedIdentities(result, preservation) {
         });
     };
     take(result, identities.id);
-    const nodes = result.nodes;
     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);
@@ -585,36 +804,7 @@ function applyPreservedIdentities(result, preservation) {
             take(task, taskIdentity.id);
             takeConditions(task?.entryConditions, taskIdentity.entryConditions);
             (taskIdentity.inputs ?? []).forEach((row, index) => take(task?.data?.inputs?.[index], row.id));
-            const outputRows = task?.data?.outputs ?? [];
-            const wantedRows = taskIdentity.outputs ?? [];
-            // Match by name when unique on both sides, else by position.
-            const unique = (names, name) => names.filter((n) => n === name).length === 1;
-            const currentNames = outputRows.map((r) => r?.name);
-            const wantedNames = wantedRows.map((r) => r.name);
-            const named = new Set(wantedRows.filter((r) => unique(wantedNames, r.name) && unique(currentNames, r.name)).map((r) => r.name));
-            wantedRows.forEach((row, index) => {
-                const target = named.has(row.name)
-                    ? outputRows.find((r) => r?.name === row.name)
-                    // 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;
-                }
-            });
+            takeOutputRows(task?.data?.outputs ?? [], taskIdentity.outputs ?? []);
         }));
     }
     const metadata = result.metadata;
@@ -627,11 +817,12 @@ function applyPreservedIdentities(result, preservation) {
                 return;
             take(variables[lane]?.find((candidate) => candidate.name === row.name), row.id);
         });
+    const longestFirst = [...replacements].sort((a, b) => b[0].length - a[0].length);
     const replace = (value) => {
         if (replacements.has(value))
             return replacements.get(value);
         let replaced = value;
-        for (const [current, wanted] of [...replacements].sort((a, b) => b[0].length - a[0].length))
+        for (const [current, wanted] of longestFirst)
             replaced = replaced.replaceAll(current, wanted);
         return replaced;
     };
@@ -696,6 +887,33 @@ function applyPreservedIdentities(result, preservation) {
     rewrite(result);
     for (const { row, source } of preservedOutputSources)
         row.source = source;
+    // An id hashed from a generated element id is re-minted from the preserved one,
+    // wherever it is spelled, including inside a `=jsonString:` configuration.
+    const reseeded = new Map();
+    for (const entry of ELEMENT_SEEDED_IDS.get(result) ?? []) {
+        const elementId = replace(entry.elementId);
+        if (elementId !== entry.elementId)
+            reseeded.set(entry.id, stableId(`${elementId}${entry.suffix}`));
+    }
+    if (reseeded.size)
+        reseed(result, reseeded);
+}
+function reseed(value, ids) {
+    if (!value || typeof value !== 'object')
+        return;
+    const entries = Array.isArray(value) ? value.map((entry, index) => [index, entry]) : Object.entries(value);
+    for (const [key, entry] of entries) {
+        if (typeof entry !== 'string') {
+            reseed(entry, ids);
+            continue;
+        }
+        let next = entry;
+        for (const [from, to] of ids)
+            if (next.includes(from))
+                next = next.replaceAll(from, to);
+        if (next !== entry)
+            value[key] = next;
+    }
 }
 function emitVariables(vars, ids, triggerNodeByRef) {
     const inputs = [];
@@ -1091,7 +1309,7 @@ function resolvedSubscriptionBag(kind, spec, resolver, elementId, where) {
     const folder = folderBindingRef(resolver, spec.folder, connection, { attribute: 'folder', where, target });
     if (folder)
         context.push(io('folderKey', 'string', { value: `=bindings.${folder.id}` }));
-    context.push(io('method', 'string', {}), io('path', 'string', {}), io('objectName', 'string', { value: op.objectName ?? spec.event }), io('operation', 'string', { value: op.eventOperation ?? spec.event }), io('metadata', 'json', { body: subscriptionMetadata(rc, op, spec.filters ?? [], elementId) }));
+    context.push(io('method', 'string', {}), io('path', 'string', {}), io('objectName', 'string', { value: op.objectName ?? spec.event }), io('operation', 'string', { value: op.eventOperation ?? spec.event }), io('metadata', 'json', { body: subscriptionMetadata(rc, op, spec.filters ?? [], elementId, resolver) }));
     return {
         serviceType: kind === 'trigger' ? CASE_FORMAT_PROFILE.eventServiceType : CASE_FORMAT_PROFILE.waitConnectorServiceType,
         context,
@@ -1106,7 +1324,7 @@ function eventInput(where, elementId) {
         ? { name: 'body', type: 'json', target: 'body', body: { queryParams: where }, var: 'vbody', id: 'vbody', elementId }
         : { name: 'body', type: 'json', target: 'body', value: '', var: 'vbody', id: 'vbody', elementId };
 }
-function subscriptionMetadata(rc, op, filters, elementId) {
+function subscriptionMetadata(rc, op, filters, elementId, resolver) {
     const instanceParameters = {
         connectorKey: rc.connectorKey,
         objectName: op.objectName ?? rc.nodeType.split('.').pop(),
@@ -1131,7 +1349,7 @@ function subscriptionMetadata(rc, op, filters, elementId) {
             const { read } = judged;
             return {
                 ...eventFilterTreeLeaf(read),
-                uiId: stableUuid(`${elementId}:${read.field}:${String(read.value)}:${index}`),
+                uiId: elementSeededId(resolver, elementId, `:${read.field}:${String(read.value)}:${index}`),
             };
         }).map((leaf) => ({
             id: leaf.id,
@@ -1140,7 +1358,7 @@ function subscriptionMetadata(rc, op, filters, elementId) {
             uiId: leaf.uiId,
         })),
         groups: [],
-        uuId: stableUuid(`${elementId}:filters`),
+        uuId: elementSeededId(resolver, elementId, ':filters'),
     } : null;
     const configuration = {
         essentialConfiguration: {
@@ -1182,16 +1400,6 @@ function subscriptionMetadata(rc, op, filters, elementId) {
         },
     };
 }
-function stableUuid(seed) {
-    let h1 = 0x811c9dc5;
-    let h2 = 0x01000193;
-    for (let index = 0; index < seed.length; index++) {
-        h1 = (h1 ^ seed.charCodeAt(index)) * 0x01000193 >>> 0;
-        h2 = (h2 + seed.charCodeAt(index) * (index + 7)) >>> 0;
-    }
-    const hex = (value, length) => value.toString(16).padStart(8, '0').slice(0, length);
-    return `${hex(h1, 8)}-${hex(h2, 4)}-4${hex(h1 >>> 8, 3)}-8${hex(h2 >>> 8, 3)}-${hex(h1 ^ h2, 8)}${hex(h2, 4)}`;
-}
 // ─── Reference-mode task io-binding (data.inputs[] / data.outputs[]) ───────────
 //
 // Wire shape verified against a real `uip maestro case` caseplan (the io-binding

package/dist/decompile.js

@@ -48,6 +48,7 @@ import { OUTCOME_HANDLE_NODE_TYPES } from './core/hitl-routing.js';
 import { contributionPort, forwardFanOut } from './core/definition-handles.js';
 import { STICKY_NOTE_TYPE } from './core/definitionless-node-types.js';
 import { eventFilterFromTreeLeaf } from './core/event-filters.js';
+import { referencedBindingNames } from './core/contribution-bindings.js';
 /**
  * The trigger id of the flow currently being decompiled, so a reference through a
  * RENAMED trigger is still recognized as `input('x')` rather than falling back to
@@ -89,6 +90,8 @@ let runRawManifests = [];
  * definition and the node keeps its version even when the author edits it.
  */
 let runCarried = new Map();
+/** The file's top-level `bindings[]` rows, by id, for {@link resolveTemplateBindings}. */
+let runBindings = new Map();
 let runStrict = false;
 /** `DecompileOptions.warn` for the current run, and the messages already sent to it (one line per finding). */
 let runWarn;
@@ -1040,6 +1043,81 @@ function emitEventSubscription(node, imp, inputNames) {
         ['folder', folder !== undefined ? tsLiteral(folder) : undefined],
     ]) + unboundMarker(node, { connection: conn, folder }, connector, event);
 }
+/**
+ * The definition a `rawNode` carries for `node`. A per-tenant template
+ * (`<bindings.NAME>` placeholders, empty `resourceKey`) comes back as a copy
+ * resolved with the node's own key and defaults (#1512); any other `def` comes
+ * back unchanged.
+ *
+ * For instance, a template context row `queueName: "<bindings.name>"`, on a node
+ * whose `queueName` row is `=bindings.bQueueName`, takes `bQueueName`'s
+ * `resourceKey` and `default`. The placeholders stay, for compile to close.
+ *
+ * `reason` says why a template was left unresolved, when the node is bound but
+ * not fully: compile's refusal names only the empty key, not what the node lacks.
+ */
+function resolveTemplateBindings(def, node) {
+    const model = def?.model;
+    const names = referencedBindingNames(model);
+    const resource = model?.bindings?.resource;
+    if (names.length === 0 || typeof resource !== 'string' || !resource || resource === 'connection')
+        return { def };
+    if (typeof model.bindings.resourceKey === 'string' && model.bindings.resourceKey)
+        return { def };
+    const nodeModel = node.model;
+    const nodeContext = Array.isArray(nodeModel?.context) ? nodeModel.context : [];
+    const nodeValues = Array.isArray(nodeModel?.bindings?.values) ? nodeModel.bindings.values : [];
+    const keys = new Map();
+    const defaults = new Map();
+    const missing = [];
+    for (const name of names) {
+        // Matched by the context row's own `name` (`queueName`): the canvas rewrites its value.
+        const fields = model.context.filter((c) => c?.value === `<bindings.${name}>`).map((c) => c?.name);
+        const ref = nodeContext.find((c) => fields.includes(c?.name) && typeof c?.value === 'string');
+        const id = typeof ref?.value === 'string' ? /^=bindings\.(.+)$/.exec(ref.value)?.[1] : undefined;
+        const row = id !== undefined ? runBindings.get(id) : undefined;
+        let key = row?.resource === resource ? row.resourceKey : undefined;
+        let value = row?.resource === resource ? row.default : undefined;
+        if (typeof key !== 'string' || !key)
+            key = nodeModel?.bindings?.resource === resource ? nodeModel.bindings.resourceKey : undefined;
+        if (typeof value !== 'string')
+            value = nodeValues.find((v) => v?.name === name)?.default;
+        if (typeof key === 'string' && key)
+            keys.set(name, key);
+        else
+            missing.push(`no resourceKey for "${name}"`);
+        if (typeof value === 'string')
+            defaults.set(name, value);
+        else
+            missing.push(`no default for "${name}"`);
+    }
+    const label = `node "${node.id}" (${def?.nodeType}@${def?.version})`;
+    // Nothing bound at all: compile's own refusal already says what to do.
+    if (keys.size === 0 && defaults.size === 0)
+        return { def };
+    if (missing.length > 0) {
+        return { def, reason: `${label} is bound to a ${resource}, but its binding has ${missing.join(', ')}, so its definition stays the template.` };
+    }
+    const distinct = [...new Set(keys.values())];
+    if (distinct.length !== 1) {
+        const each = [...keys].map(([n, k]) => `"${n}" → ${k}`).join(', ');
+        return { def, reason: `${label} names more than one ${resource} (${each}), so its definition stays the template.` };
+    }
+    const values = Array.isArray(model.bindings.values) ? model.bindings.values : [];
+    return {
+        def: {
+            ...def,
+            model: {
+                ...model,
+                bindings: {
+                    ...model.bindings,
+                    resourceKey: distinct[0],
+                    values: values.map((v) => (defaults.has(v?.name) ? { ...v, default: defaults.get(v.name) } : v)),
+                },
+            },
+        },
+    };
+}
 /** Best-effort placeholder for a node type the reverse-map does not yet cover. */
 function unsupportedSpec(node, imp, o) {
     // The file's own definition for this node — the manifest the platform served.
@@ -1053,7 +1131,10 @@ function unsupportedSpec(node, imp, o) {
         // `mock()` for a flow that genuinely contains one.
         const constName = `${camel(node.id)}Definition`;
         if (!runRawManifests.some(([n]) => n === constName)) {
-            runRawManifests.push([constName, JSON.stringify(def, null, 2)]);
+            const resolved = resolveTemplateBindings(def, node);
+            if (resolved.reason !== undefined)
+                warnOnce(resolved.reason);
+            runRawManifests.push([constName, JSON.stringify(resolved.def, null, 2)]);
         }
         const inputs = node.inputs ?? {};
         const inputsSrc = Object.keys(inputs).length > 0 ? JSON.stringify(inputs, null, 2) : undefined;
@@ -2937,6 +3018,11 @@ export function decompile(flow, options = {}) {
             runDefs.set(d.nodeType, d);
     }
     runCarried = carriedPairs(flow);
+    // Best effort: a malformed `bindings` section (not an array) indexes nothing.
+    const rows = flow.bindings;
+    runBindings = new Map((Array.isArray(rows) ? rows : [])
+        .filter((b) => typeof b?.id === 'string')
+        .map((b) => [b.id, b]));
     const imp = new Imports();
     const graph = new Graph(flow.nodes ?? [], flow.edges ?? [], flow.variables);
     const globals = readFlowGlobals(flow.variables, runStrict);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.66.2",
+  "version": "6.66.4",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -100,5 +100,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "f698c1379d7c348671e6bf0df5b211be77e8f1c6"
+  "gitref": "af11f232febf9ed683dec9f44b4ae7fe3c2426fe"
 }