@uipath/maestro-builder-sdk 6.31.4 → 6.31.5

package/dist/merge.d.ts

@@ -28,7 +28,9 @@
  * preserved from the original; `subflows` and edges (with their ids) come from
  * `edited`; `definitions` and `bindings` are unioned
  * (original wins on conflict, since the original's are the tenant-resolved
- * authority). A binding row's identity is what it binds, not its row id. Node ids are stable by construction (decompile names every step by
+ * authority). A binding row's identity is what it binds, not its row id, and a
+ * row the no-edit recompile minted only for nodes merge kept from the original
+ * is not carried (see withoutRowsMintedForKeptNodes). Node ids are stable by construction (decompile names every step by
  * its node id), which is what lets every re-attach key on id.
  *
  * ## Definitions are keyed by `nodeType@version`, not by `nodeType`

package/dist/merge.js

@@ -28,7 +28,9 @@
  * preserved from the original; `subflows` and edges (with their ids) come from
  * `edited`; `definitions` and `bindings` are unioned
  * (original wins on conflict, since the original's are the tenant-resolved
- * authority). A binding row's identity is what it binds, not its row id. Node ids are stable by construction (decompile names every step by
+ * authority). A binding row's identity is what it binds, not its row id, and a
+ * row the no-edit recompile minted only for nodes merge kept from the original
+ * is not carried (see withoutRowsMintedForKeptNodes). Node ids are stable by construction (decompile names every step by
  * its node id), which is what lets every re-attach key on id.
  *
  * ## Definitions are keyed by `nodeType@version`, not by `nodeType`
@@ -212,12 +214,17 @@ function mergeFlowFindings(original, edited, options) {
     // ── Nodes: the edited graph decides which nodes exist and in what order; the
     //    original decides their look (and, for untouched nodes, their content). ──
     const finalNodes = [];
+    // The edited nodes the merge replaced with the original's: their bindings
+    // references are the original's now, not the recompile's
+    // (see withoutRowsMintedForKeptNodes).
+    const keptFromOriginal = new Set();
     for (const e of edited.nodes ?? []) {
         const orig = origNodes.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));
+            keptFromOriginal.add(e.id);
         }
         else {
             // Added or edited → take the edited node, re-attaching original layout.
@@ -266,9 +273,11 @@ function mergeFlowFindings(original, edited, options) {
     ];
     result.definitions = mergeDefinitions(original.definitions, edited.definitions, allNodes, originalNodes, options.warn);
     // ── Bindings: union by what each row binds (original wins), so resources for
-    //    newly-added nodes come from `edited` while the original's stay intact. ──
+    //    newly-added nodes come from `edited` while the original's stay intact.
+    //    A row the no-edit recompile minted only for nodes the merge kept from the
+    //    original is not carried (#1133). ──
     result.bindings = mergeBindings(original.bindings, edited.bindings);
-    result.bindings = withoutRowsKeyedOnlyByKeptNodes(result.bindings, original, edited, options.baseline);
+    result.bindings = withoutRowsMintedForKeptNodes(result.bindings, original, edited, options.baseline, keptFromOriginal);
     // metadata / solutionId / projectId / layout / runtime were carried by the
     // initial clone of `original` and are intentionally left untouched.
     //
@@ -379,12 +388,14 @@ function mergeDefinitions(orig, edited, nodes, originalNodes, warn) {
  * holds it, in which case it gets a fresh one — ids are unreferenced labels, but
  * two rows with one id are not a valid file.
  *
- * Rows no surviving node uses are NOT pruned. The file has no uniform
+ * Rows of the ORIGINAL are never pruned. The canvas file has no uniform
  * node-to-row reference to decide "unused" by: an in-solution Flow is named by
  * the node TYPE's suffix, a connection by an id in the node's inputs, a published
  * process by a folder-qualified key that no node field spells. A wrong prune
  * drops a row a kept node needs, and the run fails to resolve its resource; an
- * orphan row is accepted by `validate` and ignored at run time.
+ * orphan row is accepted by `validate` and ignored at run time. Added rows the
+ * round trip minted only for kept nodes are dropped afterwards, by
+ * {@link withoutRowsMintedForKeptNodes}.
  */
 function mergeBindings(orig, edited) {
     const out = (orig ?? []).map((b) => jsonClone(b));
@@ -409,41 +420,70 @@ function mergeBindings(orig, edited) {
     return out;
 }
 /**
- * Drop each added row that the no-edit recompile minted for a resource only
- * nodes kept from the original spell. A row qualifies when the original lacks
- * it, the baseline has it, and its `resourceKey` appears in at least one edited
- * root node, every one of which the merge replaced with the original's: the kept
- * node is the original's, and it reaches the resource without that row.
+ * Drop each added row that the no-edit recompile minted only for nodes the merge
+ * kept from the original (#1133). A row qualifies when the original lacks it, the
+ * baseline has it, and at least one edited node references it, every one of
+ * which is in `keptFromOriginal`: the kept node is the original's, which reaches
+ * its resource without that row.
  *
- * Example: a classic-CLI IxP extract carries its model inline and has no
- * binding rows. It decompiles to `ixpExtract(...)`, whose compile mints
- * `ixpDeployment` `name` / `folderPath` rows keyed by the model id, and an
- * untouched node would carry them into the merged file.
+ * Examples:
+ * - A classic-CLI IxP extract carries its model inline and has no rows. It
+ *   decompiles to `ixpExtract(...)`, whose compile mints `ixpDeployment` rows
+ *   keyed by the model id.
+ * - A classic-CLI `core.action.http.v2` with no connection decompiles to
+ *   `http({ managed: true })`, whose compile mints `""`-keyed rows for
+ *   `<bindings.uipath-uipath-http connection>` and `<bindings.FolderKey>`.
  *
- * A row whose key no edited node spells is kept, as are rows a subflow node or
- * an edited node spells.
+ * "References" is read off the EDITED file, which the SDK wrote. A node
+ * references a row when it spells the row's `resourceKey`, or when it spells the
+ * row's `<bindings.NAME>` placeholder (in the node, or in its type's definition)
+ * and points at that row's resource. Names are not unique: a Slack step on
+ * connection X and a connection-less http step both use `<bindings.FolderKey>`,
+ * each with its own `FolderKey` row. So a placeholder counts for a keyed row
+ * only when no other row has that name, and for a `""`-keyed row only when the
+ * node spells none of the other same-named rows' keys.
+ *
+ * Kept: a row no edited node references (one a sidecar file uses, say), a row
+ * a subflow node or an edited node references, and every row without a baseline.
  */
-function withoutRowsKeyedOnlyByKeptNodes(rows, original, edited, baseline) {
-    if (!baseline || !rows)
+function withoutRowsMintedForKeptNodes(rows, original, edited, baseline, keptFromOriginal) {
+    if (!baseline || !rows || keptFromOriginal.size === 0)
         return rows;
-    const origNodes = byId(original.nodes);
-    const baseNodes = byId(baseline.nodes);
+    const contextByType = new Map();
+    for (const d of (edited.definitions ?? [])) {
+        if (typeof d?.nodeType !== 'string' || d.model?.context === undefined)
+            continue;
+        contextByType.set(d.nodeType, (contextByType.get(d.nodeType) ?? '') + JSON.stringify(d.model.context));
+    }
+    const describe = (n, kept) => ({ kept, text: JSON.stringify(n) + (contextByType.get(n.type) ?? '') });
     const nodes = [
-        ...(edited.nodes ?? []).map((n) => ({ kept: origNodes.has(n.id) && nodeUnchanged(n, baseNodes.get(n.id)), text: JSON.stringify(n) })),
-        ...Object.values(edited.subflows ?? {}).flatMap((sf) => (sf?.nodes ?? []).map((n) => ({ kept: false, text: JSON.stringify(n) }))),
+        ...(edited.nodes ?? []).map((n) => describe(n, keptFromOriginal.has(n.id))),
+        ...Object.values(edited.subflows ?? {}).flatMap((sf) => (sf?.nodes ?? []).map((n) => describe(n, false))),
     ];
-    if (!nodes.some((n) => n.kept))
-        return rows;
+    const spelled = (s) => JSON.stringify(s).slice(1, -1);
+    const keyOf = (b) => (typeof b.resourceKey === 'string' ? b.resourceKey : '');
+    const all = (edited.bindings ?? []);
     const fromOriginal = new Set((original.bindings ?? []).map(bindingIdentity));
     const inBaseline = new Set((baseline.bindings ?? []).map(bindingIdentity));
     return rows.filter((b) => {
         const identity = bindingIdentity(b);
         if (fromOriginal.has(identity) || !inBaseline.has(identity))
             return true;
-        if (typeof b.resourceKey !== 'string' || b.resourceKey === '')
-            return true;
-        const spelled = JSON.stringify(b.resourceKey).slice(1, -1);
-        const spellers = nodes.filter((n) => n.text.includes(spelled));
-        return !(spellers.length > 0 && spellers.every((n) => n.kept));
+        const key = keyOf(b);
+        const others = typeof b.name === 'string'
+            ? all.filter((o) => o.name === b.name && keyOf(o) !== key)
+            : [];
+        const placeholder = typeof b.name === 'string' ? spelled(`<bindings.${b.name}>`) : undefined;
+        const references = (text) => {
+            if (key !== '' && text.includes(spelled(key)))
+                return true;
+            if (placeholder === undefined || !text.includes(placeholder))
+                return false;
+            return key === ''
+                ? !others.some((o) => text.includes(spelled(keyOf(o))))
+                : others.length === 0;
+        };
+        const referencers = nodes.filter((n) => references(n.text));
+        return !(referencers.length > 0 && referencers.every((n) => n.kept));
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.31.4",
+  "version": "6.31.5",
   "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": "db2cd4696c73eec6402fdb616e678841a5ac3b06"
+  "gitref": "19700f105da9eae840ec05cd3796c28a96f1a4ed"
 }