@uipath/maestro-builder-sdk 6.41.0 → 6.41.2

package/dist/core/step-ports.d.ts

@@ -55,7 +55,7 @@ type SpecLike = {
  * The author-declared exits of `spec`, or a `NoExits` explaining why there are
  * none to route.
  */
-export declare function declaredExits(spec: SpecLike | undefined, _pinnedVersion?: string): DeclaredExit[] | NoExits;
+export declare function declaredExits(spec: SpecLike | undefined): DeclaredExit[] | NoExits;
 /** Narrowing helper — `declaredExits` returns one or the other. */
 export declare function hasExits(r: DeclaredExit[] | NoExits): r is DeclaredExit[];
 export {};

package/dist/core/step-ports.js

@@ -26,7 +26,7 @@
  * The author-declared exits of `spec`, or a `NoExits` explaining why there are
  * none to route.
  */
-export function declaredExits(spec, _pinnedVersion) {
+export function declaredExits(spec) {
     const kind = spec && 'kind' in spec ? spec.kind : undefined;
     return {
         reason: `a ${kind ?? 'custom'} step declares no author-named exits`,

package/dist/flow-step-exits.js

@@ -23,7 +23,7 @@ export function stepExits(spec, pinnedVersion) {
         return raw;
     const entry = typeof spec?.kind === 'string' ? FLOW_NODE_TYPES.byKind(spec.kind, spec) : undefined;
     if (!entry)
-        return declaredExits(spec, pinnedVersion);
+        return declaredExits(spec);
     let impl;
     try {
         impl = resolveVersion(entry.type, spec, pinnedVersion, 'exits');
@@ -31,5 +31,5 @@ export function stepExits(spec, pinnedVersion) {
     catch {
         impl = resolveVersion(entry.type, spec, undefined, 'exits');
     }
-    return impl.exits?.(spec, pinnedVersion) ?? declaredExits(spec, pinnedVersion);
+    return impl.exits?.(spec, pinnedVersion) ?? declaredExits(spec);
 }

package/dist/merge-variables.d.ts

@@ -1,4 +1,5 @@
 type Json = unknown;
+type Obj = Record<string, Json>;
 /** JSON with object keys sorted, so key order is not a difference. */
 export declare function stableJson(v: Json): string;
 /**
@@ -16,4 +17,10 @@ export declare function isDeltaSpelling(variables: Json): boolean;
 export declare function mergeVariables(original: Json, edited: Json, baseline: {
     variables?: Json;
 } | undefined, goneNodeIds: Set<string>): Json;
+/**
+ * `o` with the author's changes in `e` applied key by key under the delta rule,
+ * keys in the original's order; `inner` merges a value all three have and the
+ * author changed. Built from entries, so an own `__proto__` key stays a key.
+ */
+export declare function mergeObject(o: Obj, b: Obj, e: Obj, inner: (o: Json, b: Json, e: Json) => Json): Obj;
 export {};

package/dist/merge-variables.js

@@ -75,7 +75,7 @@ export function mergeVariables(original, edited, baseline, goneNodeIds) {
         return copy(edited);
     const orig = isObj(original) ? original : {};
     const baseObj = isObj(base) ? base : {};
-    const out = {};
+    const entries = [];
     for (const key of keysInOrder(orig, edited)) {
         const updates = key === 'variableUpdates';
         const inner = updates
@@ -83,16 +83,16 @@ export function mergeVariables(original, edited, baseline, goneNodeIds) {
             : (o, b, e) => mergeList(o, b, e, goneNodeIds);
         // A section the original lacks but the round trip writes is merged as an
         // empty one, so its minted entries stay out and only the author's land.
-        const absent = !(key in orig) && key in baseObj && key in edited && !same(edited[key], baseObj[key]);
+        const absent = !has(orig, key) && has(baseObj, key) && has(edited, key) && !same(edited[key], baseObj[key]);
         const value = absent
             ? nonEmpty(inner(updates ? {} : [], baseObj[key], edited[key]))
-            : mergeKey(orig[key], baseObj[key], edited[key], key in orig, key in baseObj, key in edited, inner);
+            : mergeKey(own(orig, key), own(baseObj, key), own(edited, key), has(orig, key), has(baseObj, key), has(edited, key), inner);
         if (value !== undefined)
-            out[key] = value;
+            entries.push([key, value]);
     }
-    if (original === undefined && Object.keys(out).length === 0)
+    if (original === undefined && entries.length === 0)
         return undefined;
-    return withoutGoneUpdates(out, goneNodeIds);
+    return withoutGoneUpdates(Object.fromEntries(entries), goneNodeIds);
 }
 /** `undefined` for an empty list or map, so an absent section stays absent. */
 function nonEmpty(v) {
@@ -113,9 +113,29 @@ function withoutGoneUpdates(variables, goneNodeIds) {
         return variables;
     return { ...variables, variableUpdates: Object.fromEntries(Object.entries(updates).filter(([k]) => !goneNodeIds.has(k))) };
 }
+/**
+ * Own keys only, so a key named like an `Object.prototype` member
+ * (`constructor`, `toString`) is not taken as present everywhere.
+ */
+const has = (v, k) => Object.hasOwn(v, k);
+const own = (v, k) => (has(v, k) ? v[k] : undefined);
 /** Original's keys in its order, then the edited file's new ones. */
 function keysInOrder(original, edited) {
-    return [...Object.keys(original), ...Object.keys(edited).filter((k) => !(k in original))];
+    return [...Object.keys(original), ...Object.keys(edited).filter((k) => !has(original, k))];
+}
+/**
+ * `o` with the author's changes in `e` applied key by key under the delta rule,
+ * keys in the original's order; `inner` merges a value all three have and the
+ * author changed. Built from entries, so an own `__proto__` key stays a key.
+ */
+export function mergeObject(o, b, e, inner) {
+    const entries = [];
+    for (const key of keysInOrder(o, e)) {
+        const v = mergeKey(own(o, key), own(b, key), own(e, key), has(o, key), has(b, key), has(e, key), inner);
+        if (v !== undefined)
+            entries.push([key, v]);
+    }
+    return Object.fromEntries(entries);
 }
 /**
  * One key's value under the delta rule; `undefined` = leave the key out.
@@ -173,14 +193,7 @@ function insertAt(out, edited, i) {
  * keys in the original's order.
  */
 function mergeFields(o, b, e) {
-    const base = b ?? {};
-    const out = {};
-    for (const key of keysInOrder(o, e)) {
-        const v = mergeKey(o[key], base[key], e[key], key in o, key in base, key in e, (_o, _b, ev) => copy(ev));
-        if (v !== undefined)
-            out[key] = v;
-    }
-    return out;
+    return mergeObject(o, b ?? {}, e, (_o, _b, ev) => copy(ev));
 }
 function idList(v) {
     return Array.isArray(v) && v.every((x) => isObj(x) && typeof x.id === 'string');

package/dist/merge.d.ts

@@ -19,7 +19,8 @@
  *     `edited` is byte-equal to its `baseline` counterpart, the user did NOT
  *     touch it, so the merge keeps the ORIGINAL node verbatim (its real type,
  *     inputs, layout — even for a placeholder). Only nodes the user actually
- *     changed (or added) are taken from `edited`.
+ *     changed (or added) are taken from `edited`, and a changed node takes only
+ *     the fields that differ from the baseline (see withEdits).
  *   - Without a `baseline`, the merge is two-way: it takes `edited`'s graph and
  *     re-attaches the original layout by node-id match. This is correct as long
  *     as decompile was faithful for every node (the common case).

package/dist/merge.js

@@ -19,7 +19,8 @@
  *     `edited` is byte-equal to its `baseline` counterpart, the user did NOT
  *     touch it, so the merge keeps the ORIGINAL node verbatim (its real type,
  *     inputs, layout — even for a placeholder). Only nodes the user actually
- *     changed (or added) are taken from `edited`.
+ *     changed (or added) are taken from `edited`, and a changed node takes only
+ *     the fields that differ from the baseline (see withEdits).
  *   - Without a `baseline`, the merge is two-way: it takes `edited`'s graph and
  *     re-attaches the original layout by node-id match. This is correct as long
  *     as decompile was faithful for every node (the common case).
@@ -85,12 +86,13 @@
  */
 import { bindingIdentity } from './core/binding-identity.js';
 import { jsonClone } from './core/json-clone.js';
+import { isRecord } from './core/node-envelope.js';
 import { DEFINITIONLESS_NODE_TYPES } from './core/definitionless-node-types.js';
 import { MergeRefusedError, mergedFileFindings, roundTripFindings } from './merge-roundtrip.js';
 import { placeAddedNodes } from './node-placement.js';
 import { mergeAgentSidecars } from './merge-sidecars.js';
 import { embeddedAgentFindings, isEmbeddedAgent, mergeEmbeddedAgentNode } from './merge-embedded-agent.js';
-import { mergeVariables } from './merge-variables.js';
+import { mergeObject, mergeVariables, stableJson } from './merge-variables.js';
 export { MergeRefusedError } from './merge-roundtrip.js';
 function byId(nodes) {
     return new Map((nodes ?? []).map((n) => [n.id, n]));
@@ -163,6 +165,65 @@ function withOriginalLayout(edited, orig, originalLayout) {
     }
     return edited;
 }
+/**
+ * Give `node` the original's `display` with the author's display edits applied,
+ * key by key: a key whose edited value differs from the baseline's is the
+ * author's (a relabel); every other key stays as the original has it. Compile
+ * writes only a label and the type's default icon, so the edited display taken
+ * whole drops a canvas file's `subLabel`, `iconBackground` and custom icon, and
+ * the original's taken whole drops the relabel.
+ */
+function withDisplayEdits(node, orig, e, base) {
+    const o = isRecord(orig.display) ? orig.display : {};
+    const ed = isRecord(e.display) ? e.display : {};
+    const b = isRecord(base.display) ? base.display : {};
+    const display = {};
+    for (const k of new Set([...Object.keys(o), ...Object.keys(ed)])) {
+        const v = sortedJson(ed[k]) === sortedJson(b[k]) ? o[k] : ed[k];
+        if (v !== undefined)
+            display[k] = jsonClone(v);
+    }
+    const next = sortedJson(display) === sortedJson(orig.display ?? {}) ? orig.display : display;
+    if (JSON.stringify(next) === JSON.stringify(node.display))
+        return node;
+    // In place, so the node keeps its key order.
+    const out = { ...node, display: undefined };
+    if (next === undefined)
+        delete out.display;
+    else
+        out.display = jsonClone(next);
+    return out;
+}
+/**
+ * The original with the author's edits applied, by the delta rule of
+ * merge-variables.ts: where `e` equals the baseline `b` the original's value
+ * stays (absent stays absent), and inside objects all three have, the rule
+ * recurses key by key. Lists are taken whole, and so is a changed expression
+ * value, whose `type` says how to read its `expression`: decompile turns a
+ * legacy `{ type: 'literal', expression: '{{ $vars.x }}' }` agent input into a
+ * `jsExpression`, so an edited reference merged key by key would keep
+ * `literal` and hand the agent the text. Applied to an edited node, a
+ * one-input edit to a connector keeps the rest of its `detail` as written, and
+ * compile's `model`, derived `outputs` and other spellings stay out of it.
+ */
+function withEdits(o, b, e) {
+    if (stableJson(e) === stableJson(b))
+        return o === undefined ? o : jsonClone(o);
+    if (!isRecord(o) || !isRecord(b) || !isRecord(e) || isExpressionValue(o) || isExpressionValue(e)) {
+        return e === undefined ? e : jsonClone(e);
+    }
+    return mergeObject(o, b, e, withEdits);
+}
+const isExpressionValue = (v) => typeof v.type === 'string' && Object.hasOwn(v, 'expression');
+/**
+ * Whether an edited node can merge field by field onto its original: all three
+ * have one type and one `typeVersion`. A node whose version the edit or the
+ * round trip moved is taken from `edited` whole, so it never mixes two
+ * versions' inputs.
+ */
+function mergesByField(orig, base, e) {
+    return orig.type === e.type && base.type === e.type && orig.typeVersion === e.typeVersion && base.typeVersion === e.typeVersion;
+}
 /**
  * Give an edited node the original's `inputs.source` when only the round trip
  * changed it (the baseline's equals the edited one's).
@@ -243,18 +304,23 @@ function mergeFlowFindings(original, edited, options) {
     const editedIds = new Set();
     for (const e of edited.nodes ?? []) {
         const orig = origNodes.get(e.id);
+        const base = baseNodes.get(e.id);
         if (isKept(e, origNodes, baseNodes, options.baseline) && orig) {
             // Untouched by the user (equal to the faithful baseline) → keep the
-            // original node exactly, placeholder-safe.
-            finalNodes.push(jsonClone(orig));
+            // original node exactly, placeholder-safe, plus any relabel.
+            finalNodes.push(base ? withDisplayEdits(jsonClone(orig), orig, e, base) : jsonClone(orig));
             keptFromOriginal.add(e.id);
         }
         else {
-            // Added or edited → take the edited node, re-attaching original layout.
+            // Added or edited → the original plus the author's changes, field by
+            // field (withEdits), else the edited node; then re-attach original layout.
             // An EMBEDDED agent stays embedded: the original plus the author's change
             // to the node, never the edited shell whole (#1220, merge-embedded-agent.ts).
-            const node = keepsEmbeddedAgent(orig, e) ? mergeEmbeddedAgentNode(orig, e, baseNodes.get(e.id)) : jsonClone(e);
-            const placed = withOriginalSource(withOriginalLayout(node, orig, layoutNodesOf(original)), orig, baseNodes.get(e.id));
+            const taken = keepsEmbeddedAgent(orig, e) ? mergeEmbeddedAgentNode(orig, e, base)
+                : orig && base && mergesByField(orig, base, e) ? withEdits(orig, base, e)
+                    : jsonClone(e);
+            const node = orig && base ? withDisplayEdits(taken, orig, e, base) : taken;
+            const placed = withOriginalSource(withOriginalLayout(node, orig, layoutNodesOf(original)), orig, base);
             finalNodes.push(placed);
             // Without a baseline every node lands here; count one as edited only
             // when the merged node differs from the original.
@@ -289,6 +355,10 @@ function mergeFlowFindings(original, edited, options) {
         ...(original.nodes ?? []),
         ...Object.values(original.subflows ?? {}).flatMap((sf) => sf?.nodes ?? []),
     ].map((n) => n.id).filter((id) => !mergedNodeIds.has(id)));
+    const layoutNodes = layoutNodesOf(result);
+    if (layoutNodes)
+        for (const id of goneNodeIds)
+            delete layoutNodes[id];
     const variables = mergeVariables(original.variables, edited.variables, options.baseline, goneNodeIds);
     if (variables === undefined)
         delete result.variables;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.41.0",
+  "version": "6.41.2",
   "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": "98a669a3825cc478f61ec1f337f5efb835236c3e"
+  "gitref": "cac59a549d2de4ef1ed882e7d21c7ed68598cd52"
 }