@uipath/maestro-builder-sdk 6.30.0 → 6.30.2

package/dist/merge.js

@@ -79,6 +79,7 @@ import { jsonClone } from './core/json-file.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';
 export { MergeRefusedError } from './merge-roundtrip.js';
 function byId(nodes) {
     return new Map((nodes ?? []).map((n) => [n.id, n]));
@@ -145,6 +146,34 @@ function layoutNodesOf(f) {
     return nodes && typeof nodes === 'object' && !Array.isArray(nodes) ? nodes : undefined;
 }
 export function mergeFlow(original, edited, options = {}) {
+    const { result, findings } = mergeFlowFindings(original, edited, options);
+    reportOrRefuse(findings, options);
+    return result;
+}
+/**
+ * `mergeFlow`, plus the agent sidecar files the merged flow needs written beside
+ * it (#1207). An inline agent's prompts and settings live only in
+ * `<source>/agent.json`, so an edit to them changes no node; this carries the
+ * author's change to that file onto the original's copy. What it cannot carry
+ * becomes a finding: warned, and refused under `strict`, with the flow's own
+ * findings. See merge-sidecars.ts.
+ */
+export function mergeFlowWithSidecars(original, edited, sidecars, options = {}) {
+    const { result, findings } = mergeFlowFindings(original, edited, options);
+    const carried = mergeAgentSidecars(result, sidecars);
+    reportOrRefuse([...findings, ...carried.findings], options);
+    return { flow: result, sidecars: carried.writes };
+}
+/** Warn every finding; under `strict`, throw over the refusing ones (and still warn the rest). */
+function reportOrRefuse(findings, options) {
+    const refusing = options.strict ? findings.filter((f) => f.refuses) : [];
+    for (const f of findings)
+        if (!refusing.includes(f))
+            options.warn?.(f.message);
+    if (refusing.length > 0)
+        throw new MergeRefusedError(refusing);
+}
+function mergeFlowFindings(original, edited, options) {
     const result = jsonClone(original);
     const origNodes = byId(original.nodes);
     const baseNodes = byId(options.baseline?.nodes);
@@ -205,6 +234,7 @@ export function mergeFlow(original, edited, options = {}) {
     // ── Bindings: union by what each row binds (original wins), so resources for
     //    newly-added nodes come from `edited` while the original's stay intact. ──
     result.bindings = mergeBindings(original.bindings, edited.bindings);
+    result.bindings = withoutRowsKeyedOnlyByKeptNodes(result.bindings, original, edited, options.baseline);
     // metadata / solutionId / projectId / layout / runtime were carried by the
     // initial clone of `original` and are intentionally left untouched.
     //
@@ -219,19 +249,12 @@ export function mergeFlow(original, edited, options = {}) {
         result.version = edited.version;
     }
     // ── What the no-edit round trip changed, and what mixing sources broke. ──
-    // Under strict, the findings that do not refuse are still warned, so a
-    // refused run shows them too.
+    // The caller warns them, or refuses under strict (`reportOrRefuse`).
     const findings = [
         ...(options.baseline ? roundTripFindings(original, options.baseline, result) : []),
         ...mergedFileFindings(result, original),
     ];
-    const refusing = options.strict ? findings.filter((f) => f.refuses) : [];
-    for (const f of findings)
-        if (!refusing.includes(f))
-            options.warn?.(f.message);
-    if (refusing.length > 0)
-        throw new MergeRefusedError(refusing);
-    return result;
+    return { result, findings };
 }
 /**
  * The root edges with their edited ids, except that an edge with no id, or with
@@ -351,3 +374,42 @@ 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.
+ *
+ * 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.
+ *
+ * A row whose key no edited node spells is kept, as are rows a subflow node or
+ * an edited node spells.
+ */
+function withoutRowsKeyedOnlyByKeptNodes(rows, original, edited, baseline) {
+    if (!baseline || !rows)
+        return rows;
+    const origNodes = byId(original.nodes);
+    const baseNodes = byId(baseline.nodes);
+    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) }))),
+    ];
+    if (!nodes.some((n) => n.kept))
+        return rows;
+    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));
+    });
+}

package/dist/serialize.js

@@ -4371,6 +4371,8 @@ export function serialize(built, opts = {}) {
     // anything else: the root trigger's id is fixed, so a step named `start` must
     // be renamed rather than silently collide with it.
     const takenIds = new Set([built.triggerId ?? 'start']);
+    /** Per scope, each named `.return` End emitted so far and its content. */
+    const namedEnds = new Map();
     let edgeSeq = 0;
     /** Claim a globally unique node id, honouring the scope's rename map. */
     function uid(scope, base) {
@@ -6474,7 +6476,7 @@ export function serialize(built, opts = {}) {
                 // `name` is the End's identity — `layout` keys on it and a decompiled
                 // source must be able to ask for the id the original file had, or the
                 // round trip cannot reproduce its own layout block (ReturnOptions.name).
-                const id = uid(scope, step.options?.name ?? 'end');
+                const name = step.options?.name;
                 const explicit = {};
                 const updates = [];
                 for (const [name, expr] of Object.entries(step.values)) {
@@ -6489,7 +6491,6 @@ export function serialize(built, opts = {}) {
                     if (!scope.outputType.has(name))
                         updates.push({ variableId: name, expression: src });
                 }
-                emitEnd(scope, id, tails, { label: step.options?.label, parentId, requestedVersion: step.options?.version, explicit });
                 const extra = step.options?.updates ?? {};
                 for (const name of Object.keys(extra)) {
                     if (name in step.values) {
@@ -6497,8 +6498,24 @@ export function serialize(built, opts = {}) {
                     }
                 }
                 updates.push(...renderUpdates(extra, scope.rename));
-                if (updates.length)
-                    scope.variableUpdates[id] = updates;
+                // Decompile writes one `.return` per path into an End that several paths
+                // share, so a repeat of an earlier named End in this scope, with the same
+                // content, is that End reached again rather than a second one.
+                const sig = JSON.stringify([parentId ?? null, step.options?.label ?? null, step.options?.version ?? null, explicit, updates]);
+                const prior = name === undefined ? undefined : namedEnds.get(scope)?.get(name);
+                if (prior?.sig === sig) {
+                    for (const t of tails)
+                        addEdge(scope, t, prior.id);
+                }
+                else {
+                    const id = uid(scope, name ?? 'end');
+                    emitEnd(scope, id, tails, { label: step.options?.label, parentId, requestedVersion: step.options?.version, explicit });
+                    if (updates.length)
+                        scope.variableUpdates[id] = updates;
+                    if (name !== undefined && !prior) {
+                        (namedEnds.get(scope) ?? namedEnds.set(scope, new Map()).get(scope)).set(name, { id, sig });
+                    }
+                }
                 tails = [];
             }
         }

package/package.json

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