@uipath/maestro-builder-sdk 6.45.0 → 6.45.1

package/dist/api-index.md

@@ -133,11 +133,11 @@ could hand you spans for a version you do not have.
 | `FilterCondition` | type | `dist/nodes/transform/flow/spec.d.ts:10-11` | Supporting types | Comparison a filter rule applies to a field. |
 | `FilterMatch` | type | `dist/nodes/transform/flow/spec.d.ts:8-9` | Supporting types | How a filter combines its rules: every rule must match, or any one. |
 | `FilterRule` | interface | `dist/nodes/transform/flow/spec.d.ts:12-24` | Supporting types | 3 field(s) |
-| `flow` | function | `dist/flow-sdk.d.ts:1762-1777` | Flow construction | Start building a flow with the given id. |
+| `flow` | function | `dist/flow-sdk.d.ts:1763-1778` | Flow construction | Start building a flow with the given id. |
 | `FlowAction` | class | `dist/core/node-classes.d.ts:162-168` | Supporting types | A node placed as a step — pass an instance to `.step(name, …)`. |
 | `FlowActionSpec` | type | `dist/flow-sdk.d.ts:55-56` | Supporting types | What `.step()` accepts here: the shared actions plus this SDK's subflow. |
 | `FlowActionSpecs` | interface | `dist/core/actions.d.ts:905-942` | Supporting types | Every action kind, keyed by kind, to the body of its spec — the arm's fields other than `kind`. |
-| `FlowBuilder` | class | `dist/flow-sdk.d.ts:1382-1761` | Builders | 15 member(s) |
+| `FlowBuilder` | class | `dist/flow-sdk.d.ts:1382-1762` | Builders | 15 member(s) |
 | `FlowLayout` | interface | `dist/flow-sdk.d.ts:807-820` | Supporting types | Designer layout for a flow, keyed by AUTHOR-level ids: node entries by step name (plus the trigger id and `end`), edge… |
 | `FlowNode` | class | `dist/core/node-classes.d.ts:126-161` | Supporting types | The abstract root of every definition-backed node the builder can place. |
 | `FlowResource` | class | `dist/core/node-classes.d.ts:176-183` | Supporting types | A node attached to another semantic node — an inline agent's tool, context, memory, or escalation. |
@@ -241,7 +241,7 @@ could hand you spans for a version you do not have.
 | `STICKY_NOTE_COLORS` | const | `dist/flow-sdk.d.ts:760-765` | Flow construction | The designer's sticky-note palette. |
 | `StickyNote` | interface | `dist/flow-sdk.d.ts:772-806` | Supporting types | A canvas sticky note — free text pinned to the diagram, for the humans reading it. |
 | `StickyNoteColor` | type | `dist/flow-sdk.d.ts:766-771` | Supporting types | A sticky note's swatch. |
-| `subflow` | function | `dist/flow-sdk.d.ts:1778-1817` | Flow construction | Run another flow as one step, and read back what it returns. |
+| `subflow` | function | `dist/flow-sdk.d.ts:1779-1818` | Flow construction | Run another flow as one step, and read back what it returns. |
 | `SubflowSpec` | interface | `dist/flow-sdk.d.ts:47-54` | Supporting types | A step that runs a child flow. |
 | `summarize` | function | `dist/nodes/ai-patterns/flow/factories.d.ts:8-48` | Actions | Summarize a document with citations — the platform's **Summarize** node. |
 | `SummarizeInputs` | interface | `dist/nodes/ai-patterns/flow/spec.d.ts:8-40` | Option shapes | 3 field(s) |

package/dist/api-members.md

@@ -105,7 +105,7 @@ not find it either.
 | `breakEnabled` | property | `LoopOptions` | `dist/flow-sdk.d.ts:541-545` |
 | `build` | method | `BpmnBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3581-3586` |
 | `build` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1344-1349` |
-| `build` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1754-1760` |
+| `build` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1755-1761` |
 | `businessRule` | property | `BuiltTask` | `dist/case/case-sdk.d.ts:542-543` |
 | `businessRule` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:2577-2641` |
 | `businessRule` | method | `TaskBuilder` | `dist/case/case-sdk.d.ts:833-861` |
@@ -481,7 +481,7 @@ not find it either.
 | `inclusiveGateway` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:2305-2312` |
 | `inlineAgent` | property | `FlowActionSpecs` | `dist/nodes/agent/flow/spec.d.ts:443-446` |
 | `input` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1235-1260` |
-| `input` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1695-1707` |
+| `input` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1696-1708` |
 | `input` | property | `HumanTaskOpts` | `dist/bpmn/bpmn-sdk.d.ts:1381-1382` |
 | `input` | property | `OrchestratorOpts` | `dist/bpmn/bpmn-sdk.d.ts:1267-1268` |
 | `input` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3137-3145` |
@@ -746,7 +746,7 @@ not find it either.
 | `onTimer` | method | `ActivityBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3382-3390` |
 | `onTimer` | method | `ActivityBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3391-3399` |
 | `openTails` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:875-880` |
-| `openTails` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1656-1694` |
+| `openTails` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1656-1695` |
 | `operation` | property | `Aggregation` | `dist/nodes/transform/flow/spec.d.ts:37` |
 | `operation` | property | `ConnectorToolRef` | `dist/core/actions.d.ts:686-687` |
 | `operation` | property | `WaitConnectorPlaceholderSpec` | `dist/case/case-sdk.d.ts:386-387` |
@@ -762,7 +762,7 @@ not find it either.
 | `outcomes` | property | `EscalationRef` | `dist/core/actions.d.ts:851-856` |
 | `outcomes` | property | `HitlInputs` | `dist/nodes/hitl/flow/spec.d.ts:211-225` |
 | `output` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1261-1273` |
-| `output` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1708-1743` |
+| `output` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1709-1744` |
 | `output` | property | `RegistryTypeSpec` | `dist/bpmn/typed-node.d.ts:97` |
 | `output` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3146-3154` |
 | `outputColumns` | property | `BatchTransformInputs` | `dist/nodes/ai-patterns/flow/spec.d.ts:56-60` |
@@ -1151,7 +1151,7 @@ not find it either.
 | `value` | property | `TypedInputRow` | `dist/bpmn/typed-node.d.ts:250-251` |
 | `values` | property | `DataFabricCreateInputs` | `dist/nodes/data-fabric/flow/spec.d.ts:132-137` |
 | `var` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1274-1298` |
-| `var` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1744-1753` |
+| `var` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1745-1754` |
 | `var` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3128-3136` |
 | `var` | property | `TaskOutputBinding` | `dist/case/case-sdk.d.ts:531-532` |
 | `var` | property | `TypedOutputRow` | `dist/bpmn/typed-node.d.ts:296-297` |

package/dist/check.js

@@ -3267,8 +3267,8 @@ function checkArmScopedReads(built, diags) {
  */
 function checkStepRefs(built, diags, reservedIds = []) {
     const order = new Map();
-    /** Steps that live inside a port list — a path only that port reaches. */
-    const inPortList = new Set();
+    /** Step name → the `.stepToList` whose port path it lives in — a path only that port reaches. */
+    const portListOf = new Map();
     /** Step name → the id of the scope it lives in (a loop body is its own). */
     const scopeOf = new Map();
     /** Step name → the parallel arm it lives in, as `<parallel>#<index>`. */
@@ -3321,7 +3321,7 @@ function checkStepRefs(built, diags, reservedIds = []) {
                     if (!order.has(name))
                         order.set(name, seq);
                     if (portList)
-                        inPortList.add(name);
+                        portListOf.set(name, portList);
                     scopeOf.set(name, scope);
                     if (arm)
                         armOf.set(name, arm);
@@ -3329,7 +3329,7 @@ function checkStepRefs(built, diags, reservedIds = []) {
             }
             seq++;
             if (s.kind === 'stepToList')
-                index(s.body, true, scope, arm);
+                index(s.body, s, scope, arm);
             // A `.stepSwitch` routes EVERY declared exit, as `.switch` routes every
             // case, so its arms are not side paths: they inherit `portList`, as a
             // `.switch` case does. So a ref into a step of an arm is legal from another
@@ -3356,7 +3356,7 @@ function checkStepRefs(built, diags, reservedIds = []) {
                     if (!order.has(fork.name))
                         order.set(fork.name, seq);
                     if (portList)
-                        inPortList.add(fork.name);
+                        portListOf.set(fork.name, portList);
                     scopeOf.set(fork.name, scope);
                     if (arm)
                         armOf.set(fork.name, arm);
@@ -3368,11 +3368,11 @@ function checkStepRefs(built, diags, reservedIds = []) {
                 index(s.body, portList, s.name, arm);
         }
     };
-    index(built.steps, false, '', undefined);
+    index(built.steps, undefined, '', undefined);
     // An entry-point prefix is a path of its own that may end at the shared body's
     // End, so its Ends count toward the duplicate-name rule below (#1231).
     for (const ep of built.entryPoints ?? [])
-        index(ep.steps, false, '', undefined);
+        index(ep.steps, undefined, '', undefined);
     // Two `.return`s asking for the same End name with different content are two
     // End nodes, which compile refuses rather than renaming the second `<name>2`
     // (#1231). One End shared by several paths is spelled once, with every other
@@ -3425,14 +3425,14 @@ function checkStepRefs(built, diags, reservedIds = []) {
     }
     /** Every ref, with where it sits. */
     const found = [];
-    const collect = (steps, from, scope, arm, enclosing = []) => {
+    const collect = (steps, from, scope, arm, enclosing = [], paths = []) => {
         let source = from;
         for (const [i, s] of steps.entries()) {
             if (s.kind === 'action' || s.kind === 'stepSwitch')
                 source = s.name;
             if (s.kind === 'stepToRef') {
                 found.push({
-                    target: s.target, port: s.port, from: source, scope, arm, enclosing,
+                    target: s.target, port: s.port, from: source, scope, arm, enclosing, paths,
                     // Only a default-port ref hands the path off, so only it can strand
                     // what follows; a side exit leaves the chain running.
                     after: s.port === 'output' ? steps.length - i - 1 : 0,
@@ -3440,16 +3440,16 @@ function checkStepRefs(built, diags, reservedIds = []) {
                 continue;
             }
             if (s.kind === 'stepToList')
-                collect(s.body, source, scope, arm, enclosing);
+                collect(s.body, source, scope, arm, enclosing, [...paths, s]);
             else if (s.kind === 'stepSwitch')
-                s.cases.forEach((c) => collect(c.body, s.name, scope, arm, enclosing));
+                s.cases.forEach((c) => collect(c.body, s.name, scope, arm, enclosing, paths));
             else if (s.kind === 'branch') {
-                collect(s.then, source, scope, arm, enclosing);
-                collect(s.otherwise, source, scope, arm, enclosing);
+                collect(s.then, source, scope, arm, enclosing, paths);
+                collect(s.otherwise, source, scope, arm, enclosing, paths);
             }
             else if (s.kind === 'switch') {
-                s.cases.forEach((c) => collect(c.body, source, scope, arm, enclosing));
-                collect(s.default ?? [], source, scope, arm, enclosing);
+                s.cases.forEach((c) => collect(c.body, source, scope, arm, enclosing, paths));
+                collect(s.default ?? [], source, scope, arm, enclosing, paths);
             }
             else if (s.kind === 'parallel') {
                 // Arms that all end in `.stepToRef(<one step>)` (or stop) have no Merge:
@@ -3461,11 +3461,11 @@ function checkStepRefs(built, diags, reservedIds = []) {
                     const key = `${s.name}#${i}`;
                     if (refJoinTarget !== undefined)
                         refJoin.set(key, refJoinTarget);
-                    collect(a, source, scope, key, enclosing);
+                    collect(a, source, scope, key, enclosing, paths);
                 });
             }
             else if (s.kind === 'loop' || s.kind === 'doWhile')
-                collect(s.body, source, s.name, arm, [...enclosing, s.name]);
+                collect(s.body, source, s.name, arm, [...enclosing, s.name], paths);
         }
     };
     /** The step every arm of a parallel refs instead of a Merge, by `<parallel>#<arm>`. */
@@ -3475,7 +3475,7 @@ function checkStepRefs(built, diags, reservedIds = []) {
     collect(built.steps, undefined, '', undefined);
     for (const ep of built.entryPoints ?? [])
         collect(ep.steps, ep.id, '', undefined);
-    for (const { target, from, after, scope, arm, enclosing } of found) {
+    for (const { target, from, after, scope, arm, enclosing, paths } of found) {
         const where = from ? `after "${from}"` : 'at the start of the flow';
         const say = (level, code, message, suggestion) => {
             diags.push({ level, code, message, step: from ?? 'stepToRef', ...(suggestion ? { suggestion } : {}) });
@@ -3517,7 +3517,10 @@ function checkStepRefs(built, diags, reservedIds = []) {
                 + `next iteration, or .break() to leave the loop.`, '.continue()');
             continue;
         }
-        if (inPortList.has(target) && !terminal) {
+        // A ref inside the port path its target is on (a step's own `.onError`
+        // rejoining the error path it sits on) runs only when that port fired too.
+        const targetPath = portListOf.get(target);
+        if (targetPath && !paths.includes(targetPath) && !terminal) {
             say('error', 'REF_INTO_PORT_LIST', `.stepToRef('${target}') ${where} targets a step inside another port's path. That path runs only when ITS `
                 + `port fired — it is not somewhere another edge can jump into. Point at a step on the main path, or end `
                 + `this one with .return() / .terminate(). (A named End or a Terminate is the exception: any path may end `

package/dist/decompile.js

@@ -602,6 +602,36 @@ class Graph {
                     && (!e.sourcePort.startsWith('outcome-') || e.sourcePort === primary)
                     && !side?.has(e.sourcePort))));
     }
+    /**
+     * `true` when a decision or switch has an arm with no edge at all: a
+     * decision's `true` or `false`, a switch's `case-<id>`, or its `default` when
+     * the switch has one. Such an arm is a dead end — the flow stops there — so in
+     * the post-dominator walk it is a path to the scope's EXIT, exactly like a
+     * step with no successor (#1228). Without that, the arms "reconverged" at the
+     * wired arm's first step: `dec@true -> a`, `dec@false` unwired decompiled to
+     * `.branch("dec", …, (t) => t, (e) => e).step("a", …)`, and compiling it wired
+     * `dec@false -> a`, an edge the file never had.
+     *
+     * Only the two structured forks need this. Every other exit that may be
+     * unwired (`branch-*`, a non-primary `outcome-*`, a raw node's side exit) is
+     * a side path, not a successor, so it never takes part in a join; and a node
+     * whose declared exits are all wired (`fullyWiredExits`) has none unwired.
+     */
+    hasUnwiredArm(id) {
+        const node = this.byId.get(id);
+        if (!node)
+            return false;
+        const wired = new Set(this.outEdges(id).map((e) => e.sourcePort));
+        if (node.type === T.decision)
+            return !wired.has('true') || !wired.has('false');
+        if (node.type !== T.switch)
+            return false;
+        const inputs = (node.inputs ?? {});
+        const arms = (inputs.cases ?? []).map((c) => `case-${String(c?.id ?? '')}`);
+        if (inputs.hasDefault === true)
+            arms.push('default');
+        return arms.some((p) => !wired.has(p));
+    }
     /**
      * A multi-exit `rawNode`'s SIDE exits when not every exit is wired: each
      * declared exit except the one its main path leaves on (`contributionPort`,
@@ -1307,7 +1337,10 @@ function postDominators(entry, scope, graph, container) {
         // first step.
         const leaves = container !== undefined
             && graph.successorEdges(n).some((e) => e.targetNodeId === container);
-        const ss = s.length === 0 ? [EXIT] : leaves ? [...s, EXIT] : s;
+        // A decision or switch arm with no edge is a dead end: a path to EXIT too,
+        // or the fork "reconverges" at the wired arm's first step and compiling
+        // wires the empty arm there (#1228).
+        const ss = s.length === 0 ? [EXIT] : leaves || graph.hasUnwiredArm(n) ? [...s, EXIT] : s;
         succ.set(n, ss);
         for (const t of ss) {
             addP(n, t);
@@ -1848,15 +1881,15 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
                 cursor = fork.next.cursor;
                 continue;
             }
-            // A merge node with one edge in and one out is a pass-through the
-            // designer left in place (a join whose arms were later removed). The
-            // layout names it, so it is kept: it falls through to the regular step
-            // path below and comes back as the raw node of its own definition
-            // (#1310). Skipping it dropped the node, and compile then refused the
-            // `.layout()` key. A bare merge with several edges in (a join whose fork
-            // was not detected) is still skipped — best effort.
+            // A merge node with one edge in and at most one out is a pass-through
+            // (or a dead end) the designer left in place (a join whose arms were
+            // later removed). The layout names it, so it is kept: it falls through
+            // to the regular step path below and comes back as the raw node of its
+            // own definition (#1310). Skipping it dropped the node, and compile then
+            // refused the `.layout()` key. A bare merge with several edges in (a
+            // join whose fork was not detected) is still skipped — best effort.
             const ins = ctx.graph.inEdges(node.id).filter((e) => scope.has(e.sourceNodeId));
-            if (outs.length !== 1 || ins.length !== 1) {
+            if (outs.length > 1 || ins.length !== 1) {
                 const next = continueOn(node, 'output', ctx, refInto);
                 if (next.brk || next.cont) {
                     segs.push(next.brk ? '.break()' : '.continue()');

package/dist/flow-node-type.d.ts

@@ -428,8 +428,9 @@ export interface FlowNodeType<Spec> extends NodeType<Spec, FlowNodeContribution,
     readonly errorEnvelope?: string;
     /**
      * `true`: a path that ends on this node is capped with an End even under
-     * `.openTails()`. A human task sets it: the product's `hitl-completed`
-     * rule wants an edge after the task.
+     * `.openTails()`, unless the node already has a `completed` or `outcome-*`
+     * edge. A human task sets it: the product's `hitl-completed` rule wants an
+     * edge after the task.
      */
     readonly capsOpenTail?: boolean;
     /**

package/dist/flow-sdk.d.ts

@@ -1671,12 +1671,13 @@ declare class FlowBuilder extends StepList {
      *
      * It changes only paths that fall off. `.return(...)`, `.terminate(...)`, a
      * `.stepSwitch` exit with no arm and a human-task outcome with
-     * `action: 'End'` still emit their End. A human task that ends a path is
-     * still capped with an End (the product's `hitl-completed` rule wants an edge
-     * after it), so a file whose human task has no outgoing edge gains one on a
-     * round trip. A path left open maps no outputs, so a flow that declares
-     * `.output(...)` answers nothing on that path. Use `.return(...)` on the
-     * paths that must answer.
+     * `action: 'End'` still emit their End. A human task that ends a path with
+     * no outcome wired is still capped with an End (the product's
+     * `hitl-completed` rule wants an edge after it), so a file whose human task
+     * has no outgoing edge gains one on a round trip; one whose other outcome is
+     * wired keeps the open one open. A path left open maps no outputs, so a flow
+     * that declares `.output(...)` answers nothing on that path. Use
+     * `.return(...)` on the paths that must answer.
      *
      * A subflow's child flow has its own setting; it does not inherit the
      * caller's.

package/dist/flow-sdk.js

@@ -1325,12 +1325,13 @@ class FlowBuilder extends StepList {
      *
      * It changes only paths that fall off. `.return(...)`, `.terminate(...)`, a
      * `.stepSwitch` exit with no arm and a human-task outcome with
-     * `action: 'End'` still emit their End. A human task that ends a path is
-     * still capped with an End (the product's `hitl-completed` rule wants an edge
-     * after it), so a file whose human task has no outgoing edge gains one on a
-     * round trip. A path left open maps no outputs, so a flow that declares
-     * `.output(...)` answers nothing on that path. Use `.return(...)` on the
-     * paths that must answer.
+     * `action: 'End'` still emit their End. A human task that ends a path with
+     * no outcome wired is still capped with an End (the product's
+     * `hitl-completed` rule wants an edge after it), so a file whose human task
+     * has no outgoing edge gains one on a round trip; one whose other outcome is
+     * wired keeps the open one open. A path left open maps no outputs, so a flow
+     * that declares `.output(...)` answers nothing on that path. Use
+     * `.return(...)` on the paths that must answer.
      *
      * A subflow's child flow has its own setting; it does not inherit the
      * caller's.

package/dist/merge.js

@@ -262,23 +262,83 @@ function withDisplayEdits(node, orig, e, base) {
  * 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
+ * recurses key by key. A list whose entries have ids goes entry by entry
+ * ({@link withListEdits}), so relabelling one form field does not rewrite the
+ * others in compile's spelling, and an edited condition keeps the original's
+ * spelling ({@link inOriginalSpelling}). Any other list is 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);
+    const respelled = inOriginalSpelling(o, b, e);
+    if (respelled !== undefined)
+        return respelled;
+    if (Array.isArray(o) && Array.isArray(b) && Array.isArray(e))
+        return withListEdits(o, b, e) ?? jsonClone(e);
     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');
+/**
+ * An edited condition `e` in the original's spelling, where compile writes it
+ * bare: Studio Web writes a decision or switch condition as `=js: <x>` or a
+ * `{ type: 'jsExpression', expression: <x> }` envelope, compile as `<x>` (#1308).
+ * `undefined` when `o` is not one of those spellings of `b`.
+ */
+function inOriginalSpelling(o, b, e) {
+    if (typeof b !== 'string' || typeof e !== 'string' || e.startsWith('='))
+        return undefined;
+    if (typeof o === 'string') {
+        const prefix = /^=js:\s*/.exec(o)?.[0];
+        return prefix && o.slice(prefix.length) === b ? prefix + e : undefined;
+    }
+    return isRecord(o) && o.type === 'jsExpression' && o.expression === b ? { ...jsonClone(o), expression: e } : undefined;
+}
+/** What `after` changed from `before`, key by key; `undefined` when nothing. */
+function changedFrom(before, after) {
+    if (stableJson(after) === stableJson(before))
+        return undefined;
+    if (!isRecord(before) || !isRecord(after) || isExpressionValue(before) || isExpressionValue(after))
+        return after;
+    const out = {};
+    for (const k of Object.keys(after)) {
+        const d = changedFrom(before[k], after[k]);
+        if (d !== undefined)
+            out[k] = d;
+    }
+    return out;
+}
+/** The `id` of every entry, when every entry is an object with its own string `id`. */
+function entryIds(list) {
+    const ids = list.map((x) => (isRecord(x) && typeof x.id === 'string' ? x.id : undefined));
+    return ids.every((id) => id !== undefined) && new Set(ids).size === ids.length ? ids : undefined;
+}
+/**
+ * {@link withEdits} over a list whose entries all have their own `id` (a human
+ * task's form fields, a switch's cases), entry by entry: an entry the author
+ * did not change stays as the original wrote it. `undefined` when the lists
+ * cannot be lined up that way (no ids, or the round trip changed which entries
+ * there are), and the caller takes the edited list whole.
+ */
+function withListEdits(o, b, e) {
+    const [oi, bi, ei] = [entryIds(o), entryIds(b), entryIds(e)];
+    if (!oi || !bi || !ei || oi.length !== bi.length || !oi.every((id) => bi.includes(id)))
+        return undefined;
+    const at = (list, ids, id) => list[ids.indexOf(id)];
+    // The author kept the entries and their order: keep the original's order too.
+    const order = ei.join('\0') === bi.join('\0') ? oi : ei;
+    return order.map((id) => (bi.includes(id)
+        ? withEdits(at(o, oi, id), at(b, bi, id), at(e, ei, id))
+        : jsonClone(at(e, ei, id))));
+}
 /**
  * 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
@@ -369,6 +429,9 @@ function mergeFlowFindings(original, edited, options) {
     // references are the original's now, not the recompile's
     // (see withoutRowsMintedForKeptNodes).
     const keptFromOriginal = new Set();
+    // The edited nodes merged field by field, with what the merge took from the
+    // edit: their other fields are the original's, and so are the bindings those need.
+    const fieldwise = new Map();
     /** Root node ids taken from `edited` that the original also has (the author edited them). */
     const editedIds = new Set();
     for (const e of edited.nodes ?? []) {
@@ -385,9 +448,14 @@ function mergeFlowFindings(original, edited, options) {
             // 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 byField = !keepsEmbeddedAgent(orig, e) && !!orig && !!base && mergesByField(orig, base, e);
             const taken = keepsEmbeddedAgent(orig, e) ? mergeEmbeddedAgentNode(orig, e, base)
-                : orig && base && mergesByField(orig, base, e) ? withEdits(orig, base, e)
+                : byField ? withEdits(orig, base, e)
                     : jsonClone(e);
+            // Against the merged node, not the edit: a key the original lacks comes
+            // from the edit whole, unchanged children and their bindings included.
+            if (byField)
+                fieldwise.set(e.id, changedFrom(orig, taken));
             const node = orig && base ? withDisplayEdits(taken, orig, e, base) : taken;
             const placed = withOriginalSource(withOriginalLayout(node, orig, layoutNodesOf(original)), orig, base);
             finalNodes.push(placed);
@@ -493,9 +561,10 @@ function mergeFlowFindings(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.
     //    A row the no-edit recompile minted only for nodes the merge kept from the
-    //    original is not carried (#1133). ──
+    //    original, or for fields of an edited node the edit did not change, is
+    //    not carried (#1133). ──
     result.bindings = mergeBindings(original.bindings, edited.bindings);
-    result.bindings = withoutRowsMintedForKeptNodes(result.bindings, original, edited, options.baseline, keptFromOriginal);
+    result.bindings = withoutRowsMintedForKeptNodes(result.bindings, original, edited, options.baseline, keptFromOriginal, fieldwise);
     // metadata / solutionId / projectId / layout / runtime were carried by the
     // initial clone of `original` and are intentionally left untouched, apart
     // from the `layout.nodes` entries of removed nodes (dropped above) and added
@@ -733,11 +802,16 @@ function mergeBindings(orig, edited) {
  * 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.
  *
+ * An edited node merged field by field (`fieldwise`, with what the merge took
+ * from the edit) is the original's in every other field, so it needs such a row
+ * only when what it took references it. A classic-CLI IxP extract
+ * whose `fileRef` the author edits still carries its model inline.
+ *
  * 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 withoutRowsMintedForKeptNodes(rows, original, edited, baseline, keptFromOriginal) {
-    if (!baseline || !rows || keptFromOriginal.size === 0)
+function withoutRowsMintedForKeptNodes(rows, original, edited, baseline, keptFromOriginal, fieldwise) {
+    if (!baseline || !rows || (keptFromOriginal.size === 0 && fieldwise.size === 0))
         return rows;
     const contextByType = new Map();
     for (const d of (edited.definitions ?? [])) {
@@ -745,9 +819,9 @@ function withoutRowsMintedForKeptNodes(rows, original, edited, baseline, keptFro
             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 describe = (n, kept, changed) => ({ kept, changed, text: JSON.stringify(n) + (contextByType.get(n.type) ?? '') });
     const nodes = [
-        ...(edited.nodes ?? []).map((n) => describe(n, keptFromOriginal.has(n.id))),
+        ...(edited.nodes ?? []).map((n) => describe(n, keptFromOriginal.has(n.id), fieldwise.has(n.id) ? JSON.stringify(fieldwise.get(n.id) ?? {}) : undefined)),
         ...Object.values(edited.subflows ?? {}).flatMap((sf) => (sf?.nodes ?? []).map((n) => describe(n, false))),
     ];
     const spelled = (s) => JSON.stringify(s).slice(1, -1);
@@ -774,6 +848,7 @@ function withoutRowsMintedForKeptNodes(rows, original, edited, baseline, keptFro
                 : others.length === 0;
         };
         const referencers = nodes.filter((n) => references(n.text));
-        return !(referencers.length > 0 && referencers.every((n) => n.kept));
+        const needs = (n) => !n.kept && (n.changed === undefined || references(n.changed));
+        return !(referencers.length > 0 && !referencers.some(needs));
     });
 }

package/dist/serialize.js

@@ -2217,13 +2217,19 @@ export function serialize(built, opts = {}) {
      *
      * All of them by default. Under `.openTails()` (#1142) only the tails
      * of a node whose type sets `capsOpenTail` (a human task: the product's
-     * `hitl-completed` rule wants an edge after it). Every other tail is left
-     * open, which is the shape the classic CLI and the canvas write.
+     * `hitl-completed` rule wants an edge after it) and that has no outcome
+     * edge yet: the rule is met by any `completed` or `outcome-*` edge, so a
+     * task whose Reject is wired keeps its Approve open. Every other tail is
+     * left open, which is the shape the classic CLI and the canvas write.
      */
     function tailsToCap(scope, tails) {
         if (!scope.openTails)
             return [...tails];
-        return tails.filter((t) => capsOpenTail.has(t.node));
+        const isOutcome = (port) => port === 'completed' || String(port).startsWith('outcome-');
+        // A `.stepToRef` edge is still pending here: resolveRejoins runs after.
+        const hasOutcomeEdge = (node) => scope.edges.some((e) => e.sourceNodeId === node && isOutcome(e.sourcePort))
+            || scope.pendingEdges.some((p) => p.from.node === node && isOutcome(p.from.port));
+        return tails.filter((t) => capsOpenTail.has(t.node) && !hasOutcomeEdge(t.node));
     }
     /**
      * Emit a child flow into its own scope and register it under the calling
@@ -3178,7 +3184,7 @@ export function serialize(built, opts = {}) {
                 // DYNAMIC, one per case, so they are synthesized here instead of copied
                 // from the definition. The emitted shape mirrors the platform's
                 // `walkSwitchStatement` (the canonical emitter) exactly:
-                //   inputs.cases[] = { id, label, expression }, inputs.hasDefault,
+                //   inputs.cases[] = { id, label, expression }, inputs.hasDefault (1.0.0),
                 //   source ports `case-<id>` per case + `default` for the default arm.
                 // Each case `expression` is a full boolean condition (the node evaluates
                 // them in order and takes the first truthy one), auto-evaluated as JS by
@@ -3197,7 +3203,9 @@ export function serialize(built, opts = {}) {
                         ? renameRefs(c.when.js, scope.rename)
                         : `${renameRefs(step.on?.js ?? 'undefined', scope.rename)} === ${caseLiteral(c.value)}`,
                 }));
-                node.inputs = { cases, hasDefault: step.default !== undefined };
+                // Switch 1.1 dropped `hasDefault`: its `default` handle is always there.
+                const declared = bundledNodeDefs.get(id)?.inputDefinition?.properties;
+                node.inputs = { cases, ...(!declared || Object.hasOwn(declared, 'hasDefault') ? { hasDefault: step.default !== undefined } : {}) };
                 scope.nodes.push(node);
                 for (const t of tails)
                     addEdge(scope, t, id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.45.0",
+  "version": "6.45.1",
   "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": "618bc7abd8705bcc85c85d6414dd29be5e9c3ec0"
+  "gitref": "f8fe049e27996a1862ea9ce5c48507b15b6178d0"
 }