@uipath/maestro-builder-sdk 6.44.0 → 6.44.2

package/dist/merge.d.ts

@@ -26,9 +26,11 @@
  *     as decompile was faithful for every node (the common case).
  *
  * Layout, `metadata`, `solutionId`, `projectId`, `runtime` and `layout` are
- * preserved from the original; `subflows` and edges (with their ids) come from
- * `edited`; root `variables` merge as a delta per entry, like nodes
- * (merge-variables.ts); `definitions` and `bindings` are unioned
+ * preserved from the original, apart from the `layout.nodes` entries of
+ * removed nodes (dropped) and added nodes (node-placement.ts); `subflows` and
+ * edges (with their ids) come from `edited`; root `variables` merge as a
+ * delta per entry, like nodes (merge-variables.ts); `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, and a
  * row the no-edit recompile minted only for nodes merge kept from the original

package/dist/merge.js

@@ -26,9 +26,11 @@
  *     as decompile was faithful for every node (the common case).
  *
  * Layout, `metadata`, `solutionId`, `projectId`, `runtime` and `layout` are
- * preserved from the original; `subflows` and edges (with their ids) come from
- * `edited`; root `variables` merge as a delta per entry, like nodes
- * (merge-variables.ts); `definitions` and `bindings` are unioned
+ * preserved from the original, apart from the `layout.nodes` entries of
+ * removed nodes (dropped) and added nodes (node-placement.ts); `subflows` and
+ * edges (with their ids) come from `edited`; root `variables` merge as a
+ * delta per entry, like nodes (merge-variables.ts); `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, and a
  * row the no-edit recompile minted only for nodes merge kept from the original
@@ -261,6 +263,11 @@ function layoutNodesOf(f) {
     const nodes = f.layout?.nodes;
     return nodes && typeof nodes === 'object' && !Array.isArray(nodes) ? nodes : undefined;
 }
+/** The original's `layout.nodes` when it holds positions. An SDK compile writes `{}` there and keeps them on `node.ui`. */
+function positionStoreOf(f) {
+    const nodes = layoutNodesOf(f);
+    return nodes && Object.keys(nodes).length > 0 ? nodes : undefined;
+}
 export function mergeFlow(original, edited, options = {}) {
     const { result, findings } = mergeFlowFindings(original, edited, options);
     reportOrRefuse(findings, options);
@@ -374,12 +381,13 @@ function mergeFlowFindings(original, edited, options) {
     //    one already taken elsewhere in the file, gets a fresh id, from ids unused
     //    anywhere in the file. ──
     result.edges = withFileUniqueEdgeIds(edited.edges ?? [], subflowScopes);
-    // ── Placement: a node the edit ADDED has only compile's placeholder, an
-    //    emission-index slot that can land on an original node. Put it next to
-    //    its predecessor, collision-free, in the store the
-    //    original uses — see node-placement.ts. Root scope only: a subflow is
-    //    taken from `edited` whole, layout included. ──
-    placeAddedNodes(finalNodes, result.edges, layoutNodesOf(result), (id) => !origNodes.has(id));
+    // ── Placement: a node the edit ADDED has no original position. Unless the
+    //    author set one, it has compile's placeholder, an emission-index slot
+    //    that can land on an original node. Put it next to its predecessor,
+    //    collision-free, and store every added node's position where the
+    //    original stores positions — see node-placement.ts. Root scope only: a
+    //    subflow is taken from `edited` whole, layout included. ──
+    placeAddedNodes(finalNodes, result.edges, positionStoreOf(original) && layoutNodesOf(result), (id) => !origNodes.has(id));
     // ── Definitions: the (type, version) pairs used by EVERY node in the file —
     //    root and subflows — original winning on conflict (its defs are the
     //    tenant-resolved authority). Selecting by root nodes only dropped the
@@ -398,7 +406,9 @@ function mergeFlowFindings(original, edited, options) {
     result.bindings = mergeBindings(original.bindings, edited.bindings);
     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.
+    // initial clone of `original` and are intentionally left untouched, apart
+    // from the `layout.nodes` entries of removed nodes (dropped above) and added
+    // nodes (placement).
     //
     // The declared file-format `version` follows the same delta rule the nodes
     // do. The original's wins by default, because a compile of an edited source

package/dist/node-placement.d.ts

@@ -19,7 +19,7 @@
  * A child's position is relative to its container, as on the canvas.
  *
  * The position goes where the original stores positions: `layout.nodes[id]`
- * when it has a `layout.nodes` map, otherwise `node.ui`. Positions are read the
+ * when its `layout.nodes` has entries, otherwise `node.ui`. Positions are read the
  * way the designer reads them (flow-workbench `flow-schema`
  * `workflow-format-conversion.ts` `mergeLayout`): a `layout.nodes[id]` entry
  * wins over `node.ui`, field by field.
@@ -77,13 +77,14 @@ interface PlacedNode {
  * its placeholder, and placed nodes avoid it.
  *
  * Where the result is written follows the file: when the original stores
- * positions in `layout.nodes` (every canvas-saved file does), the position goes
- * there and the placeholder `node.ui` is dropped, so the file has one store;
- * otherwise `node.ui.position` is updated.
+ * positions in `layout.nodes` (every canvas-saved file does), every added
+ * node's `node.ui`, placed or not, sticky notes included, replaces its
+ * `layout.nodes` entry, so the node has one position; otherwise
+ * `node.ui.position` is updated.
  *
  * @param nodes - The merged root nodes (mutated).
  * @param edges - The merged root edges.
- * @param layoutNodes - The merged file's `layout.nodes`, or undefined when the original has none (mutated).
+ * @param layoutNodes - The merged file's `layout.nodes`, or undefined when the original keeps positions on `node.ui` (mutated).
  * @param isAdded - Whether a node id is new in this merge.
  */
 export declare function placeAddedNodes(nodes: PlacedNode[], edges: ReadonlyArray<{

package/dist/node-placement.js

@@ -19,7 +19,7 @@
  * A child's position is relative to its container, as on the canvas.
  *
  * The position goes where the original stores positions: `layout.nodes[id]`
- * when it has a `layout.nodes` map, otherwise `node.ui`. Positions are read the
+ * when its `layout.nodes` has entries, otherwise `node.ui`. Positions are read the
  * way the designer reads them (flow-workbench `flow-schema`
  * `workflow-format-conversion.ts` `mergeLayout`): a `layout.nodes[id]` entry
  * wins over `node.ui`, field by field.
@@ -83,6 +83,21 @@ function findFreePosition(candidate, size, others) {
     }
     return candidate;
 }
+/**
+ * Move each added node's `ui` into `layoutNodes`, replacing any entry under its
+ * id: the original can hold an entry for an id it has no node for.
+ */
+function moveAddedUi(nodes, layoutNodes, isAdded) {
+    for (const n of nodes) {
+        if (!isAdded(n.id))
+            continue;
+        if (n.ui === undefined)
+            delete layoutNodes[n.id];
+        else
+            layoutNodes[n.id] = n.ui;
+        delete n.ui;
+    }
+}
 /**
  * Give each node the edit added a position next to its predecessor, in place.
  *
@@ -95,16 +110,19 @@ function findFreePosition(candidate, size, others) {
  * its placeholder, and placed nodes avoid it.
  *
  * Where the result is written follows the file: when the original stores
- * positions in `layout.nodes` (every canvas-saved file does), the position goes
- * there and the placeholder `node.ui` is dropped, so the file has one store;
- * otherwise `node.ui.position` is updated.
+ * positions in `layout.nodes` (every canvas-saved file does), every added
+ * node's `node.ui`, placed or not, sticky notes included, replaces its
+ * `layout.nodes` entry, so the node has one position; otherwise
+ * `node.ui.position` is updated.
  *
  * @param nodes - The merged root nodes (mutated).
  * @param edges - The merged root edges.
- * @param layoutNodes - The merged file's `layout.nodes`, or undefined when the original has none (mutated).
+ * @param layoutNodes - The merged file's `layout.nodes`, or undefined when the original keeps positions on `node.ui` (mutated).
  * @param isAdded - Whether a node id is new in this merge.
  */
 export function placeAddedNodes(nodes, edges, layoutNodes, isAdded) {
+    if (layoutNodes)
+        moveAddedUi(nodes, layoutNodes, isAdded);
     const byId = new Map(nodes.map((n) => [n.id, n]));
     const uiOf = (n) => {
         const entry = layoutNodes?.[n.id];
@@ -149,13 +167,10 @@ export function placeAddedNodes(nodes, edges, layoutNodes, isAdded) {
                 .map((o) => ({ ...uiOf(o).position, ...sizeOf(o) }));
             const position = findFreePosition(candidate, sizeOf(n), others);
             const ui = { ...uiOf(n), position };
-            if (layoutNodes) {
+            if (layoutNodes)
                 layoutNodes[id] = ui;
-                delete n.ui;
-            }
-            else {
+            else
                 n.ui = ui;
-            }
             pending.delete(id);
             progress = true;
         }

package/dist/nodes/process/flow/node-type.js

@@ -698,10 +698,13 @@ function liftProcess(node, ctx, prefix, kind, form) {
     const n = node;
     const key = n.type.slice(prefix.length);
     const def = ctx.definition();
-    const values = (def?.model?.bindings?.values ?? []);
+    // Descriptor rows (`[{ name, default }]`), or the early `{ name, folderPath }` object.
+    const values = def?.model?.bindings?.values;
     const binding = (name) => {
-        const row = values.find((v) => v.name === name);
-        return typeof row?.default === 'string' ? row.default : undefined;
+        const v = Array.isArray(values)
+            ? values.find((r) => r?.name === name)?.default
+            : values !== null && typeof values === 'object' ? values[name] : undefined;
+        return typeof v === 'string' ? v : undefined;
     };
     const name = binding('name');
     const folderPath = binding('folderPath');
@@ -712,11 +715,13 @@ function liftProcess(node, ctx, prefix, kind, form) {
     const projectId = typeof def?.model?.projectId === 'string' ? def.model.projectId : undefined;
     const inSolution = def?.model?.isInSolution === true || projectId !== undefined;
     const inputs = { ...(n.inputs ?? {}) };
-    // The design-time fire-and-forget switch is an OPTION on the factory, not a
-    // process argument — serialize adds it to `inputs` after rendering the
-    // author's map, so it comes back off here.
-    const fireAndForget = ctx.plainValue(inputs.fireAndForget) === true;
-    delete inputs.fireAndForget;
+    // The design-time fire-and-forget switch is an OPTION on agenticProcess(),
+    // not a process argument — serialize adds it to `inputs` after rendering the
+    // author's map, so it comes back off here. No other factory has the option, so
+    // on another kind the key stays an ordinary input and round-trips as one.
+    const fireAndForget = kind === 'agenticProcess' && ctx.plainValue(inputs.fireAndForget) === true;
+    if (kind === 'agenticProcess')
+        delete inputs.fireAndForget;
     if (kind === 'agent' && (def?.model?.isInSolution === true || def?.model?.projectId !== undefined)) {
         for (const [k, v] of Object.entries(inputs))
             inputs[k] = legacyAgentTemplateInput(v);
@@ -748,6 +753,9 @@ function liftProcess(node, ctx, prefix, kind, form) {
         ...(returns !== undefined && !fireAndForget ? { returns } : {}),
         ...(form !== undefined ? { form } : {}),
         ...(fireAndForget ? { completion: 'fire-and-forget' } : {}),
+        // The only field a coded agent's definition differs in (see agentDef);
+        // 'lowcode' is the default, so only 'coded' is written.
+        ...(kind === 'agent' && def?.display?.icon === 'coded-agent' ? { flavour: 'coded' } : {}),
     };
     return { kind, inputs: spec };
 }
@@ -767,6 +775,7 @@ function printProcess(spec, ctx, factory) {
             ['returns', p.returns !== undefined ? obj(Object.entries(p.returns).map(([k, t]) => [k, ctx.string(t)])) : undefined],
             ['form', p.form !== undefined ? ctx.string(p.form) : undefined],
             ['completion', p.completion !== undefined ? ctx.string(p.completion) : undefined],
+            ['flavour', p.flavour !== undefined ? ctx.string(p.flavour) : undefined],
         ],
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.44.0",
+  "version": "6.44.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": "7075376040d8eb546745a5457c894dbc168448c8"
+  "gitref": "7afed05cfe5a6856deb6fe7984a5cf2b31a2dd20"
 }