@uipath/maestro-builder-sdk 6.29.1 → 6.29.2

package/dist/core/definition-handles.d.ts

@@ -35,4 +35,17 @@ export declare function expandSourceHandles(def: Def, inputs: unknown): string[]
  * whose handles cannot be known: such a node has no fan-out to route.
  */
 export declare function forwardFanOut(def: Def, inputs: unknown): string[] | undefined;
+/**
+ * The port a node's main path leaves on — the edge a plain `.step()` writes
+ * and a following step continues from: the first concrete forward source
+ * handle (`isDefaultForType` wins), else `output`. `undefined` when every
+ * forward source handle is templated (`case-{item.id}`), so no main path leaves
+ * the node.
+ *
+ * `serialize` writes the main-path edge on this port, and `decompile` reads the
+ * main path back off it, so the two must agree: a `core.logic.agentic-switch`
+ * (`case-{item.id}` + `default`) continues on `default`, and each other wired
+ * exit is a `.stepToList('case-<id>', …)` (#1214).
+ */
+export declare function contributionPort(def: Def): string | undefined;
 export {};

package/dist/core/definition-handles.js

@@ -72,3 +72,24 @@ export function forwardFanOut(def, inputs) {
     const handles = expandSourceHandles(def, inputs)?.filter((h) => !NOT_FORWARD.has(h));
     return handles !== undefined && handles.length > 1 ? handles : undefined;
 }
+/**
+ * The port a node's main path leaves on — the edge a plain `.step()` writes
+ * and a following step continues from: the first concrete forward source
+ * handle (`isDefaultForType` wins), else `output`. `undefined` when every
+ * forward source handle is templated (`case-{item.id}`), so no main path leaves
+ * the node.
+ *
+ * `serialize` writes the main-path edge on this port, and `decompile` reads the
+ * main path back off it, so the two must agree: a `core.logic.agentic-switch`
+ * (`case-{item.id}` + `default`) continues on `default`, and each other wired
+ * exit is a `.stepToList('case-<id>', …)` (#1214).
+ */
+export function contributionPort(def) {
+    const groups = Array.isArray(def?.handleConfiguration) ? def.handleConfiguration : [];
+    const handles = groups.flatMap((g) => (g?.handles ?? []));
+    const sources = handles.filter((h) => h?.type === 'source' && h?.id !== 'error');
+    const concrete = sources.filter((h) => typeof h?.id === 'string' && !h.id.includes('{'));
+    if (concrete.length === 0 && sources.length > 0)
+        return undefined;
+    return concrete.find((h) => h?.isDefaultForType)?.id ?? concrete[0]?.id ?? 'output';
+}

package/dist/decompile.js

@@ -46,7 +46,7 @@ import { mapJsCode } from './core/js-code-spans.js';
 import { missingBindingLabels } from './core/binding-messages.js';
 import { prepareCommand } from './core/cli-spelling.js';
 import { OUTCOME_HANDLE_NODE_TYPES } from './core/hitl-routing.js';
-import { forwardFanOut } from './core/definition-handles.js';
+import { contributionPort, forwardFanOut } from './core/definition-handles.js';
 import { STICKY_NOTE_TYPE } from './core/definitionless-node-types.js';
 import { eventFilterFromTreeLeaf } from './core/event-filters.js';
 import { sdkFormFieldType } from './core/form-field-type.js';
@@ -532,11 +532,34 @@ class Graph {
     successorEdges(id) {
         const primary = this.primaryOutcomePort(id);
         const forked = this.fullyWiredExits(id);
+        const side = forked ? undefined : this.rawSidePorts(id);
         return this.outEdges(id).filter((e) => e.sourcePort !== 'error'
             && !ARTIFACT_PORTS.has(e.sourcePort)
             && (forked?.has(e.sourcePort)
                 || (!e.sourcePort.startsWith('branch-')
-                    && (!e.sourcePort.startsWith('outcome-') || e.sourcePort === primary))));
+                    && (!e.sourcePort.startsWith('outcome-') || e.sourcePort === primary)
+                    && !side?.has(e.sourcePort))));
+    }
+    /**
+     * 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`,
+     * the port serialize writes a plain `.step()`'s edge on — `default` for a
+     * `core.logic.agentic-switch`). Each is recovered as a
+     * `.stepToList('<port>', …)` after the `.step`, as `branch-*` and non-primary
+     * `outcome-*` exits are. `undefined` for every other node, and for a raw node
+     * whose exits are all wired (that one is a `.stepSwitch`).
+     *
+     * Without this, a partially wired agentic switch had two successors and no
+     * merge join, so the walk emitted an unstructured-fan-out TODO and dropped
+     * every arm (#1214).
+     */
+    rawSidePorts(id) {
+        const node = this.byId.get(id);
+        const exits = node ? rawNodeExits(node) : undefined;
+        if (!node || exits === undefined || this.fullyWiredExits(id) !== undefined)
+            return undefined;
+        const main = contributionPort(rawNodeDefinition(node));
+        return new Set(exits.map((e) => e.port).filter((p) => p !== main));
     }
 }
 // ─── Node → step-spec source ──────────────────────────────────────────────────
@@ -2397,6 +2420,17 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
                 segs.push(`.stepToList(${tsLiteral(oe.sourcePort)}, ${armCb('p', outSegs)})`);
             }
         }
+        // A partially wired multi-exit raw node (an agentic switch with one choice
+        // unwired): every wired exit but the main path's is its own port list, and
+        // an unwired one stays unwired (#1214).
+        const rawSide = ctx.graph.rawSidePorts(node.id);
+        for (const re of rawSide ? ctx.graph.outEdges(node.id).filter((e) => rawSide.has(e.sourcePort)) : []) {
+            const mainReach = forwardReach(succ, scope, ctx.graph);
+            const sideSegs = edgeRegion(re, EXIT, scope, ipdom, ctx, mainReach);
+            if (sideSegs.length === 0)
+                sideSegs.push('.return({})');
+            segs.push(`.stepToList(${tsLiteral(re.sourcePort)}, ${armCb('p', sideSegs)})`);
+        }
         // A body edge into the enclosing container's break handle: the path exits
         // the loop here. Emit `.break()` and end the region — recompiling recreates
         // exactly this edge and adds no continue back-edge for the path.
@@ -2565,13 +2599,20 @@ function declaredExitsOfNode(node) {
  */
 function rawNodeExits(node) {
     const type = String(node.type);
+    // A registered type (an HTTP call, say) answers from its own `exits`.
+    if (registeredImpl(node) !== undefined)
+        return undefined;
     if (Object.values(T).includes(type) || isTrigger(type))
         return undefined;
     if (['uipath.connector.', 'uipath.core.', 'uipath.ixp.', 'uipath.agent.', 'uipath.conversational.']
         .some((p) => type.startsWith(p)))
         return undefined;
-    const def = runDefs.get(`${type}@${node.typeVersion}`) ?? runDefs.get(type);
-    return forwardFanOut(def, node.inputs)?.map((port) => ({ value: port, port }));
+    return forwardFanOut(rawNodeDefinition(node), node.inputs)?.map((port) => ({ value: port, port }));
+}
+/** The definition the file carries for `node`'s type (its version's, else the type's). */
+function rawNodeDefinition(node) {
+    const type = String(node.type);
+    return runDefs.get(`${type}@${node.typeVersion}`) ?? runDefs.get(type);
 }
 /**
  * Split a switch case expression into `<discriminant> === <literal>`, the only

package/dist/serialize.js

@@ -57,6 +57,7 @@ import { resolveSchemaVersion } from './schema-version.js';
 import { planFlowGlobals, planSharedInputs, sharedInputRoots } from './flow-variables.js';
 import { outputBackingGlobal, planOutputBacking } from './flow-output-backing.js';
 import { mapJsCode } from './core/js-code-spans.js';
+import { contributionPort } from './core/definition-handles.js';
 import { prepareCommand } from './core/cli-spelling.js';
 import { AGENTIC_PROCESS_FORMS } from './core/agentic-process-forms.js';
 import { resourceNodeSortOrder } from './core/process-resource-sort-order.js';
@@ -3531,18 +3532,6 @@ function declaresForwardPort(def, port) {
         return port.length > head.length + tail.length && port.startsWith(head) && port.endsWith(tail);
     });
 }
-/**
- * Forward port: the first concrete source handle (`isDefaultForType` wins), else `output`;
- * `undefined` when every forward source handle is templated (`case-{item.id}`).
- */
-function contributionPort(def) {
-    const handles = (def?.handleConfiguration ?? []).flatMap((g) => g?.handles ?? []);
-    const sources = handles.filter((h) => h?.type === 'source' && h?.id !== 'error');
-    const concrete = sources.filter((h) => typeof h?.id === 'string' && !h.id.includes('{'));
-    if (concrete.length === 0 && sources.length > 0)
-        return undefined;
-    return concrete.find((h) => h?.isDefaultForType)?.id ?? concrete[0]?.id ?? 'output';
-}
 /**
  * Render a switch case value as a JS literal for the case expression.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.29.1",
+  "version": "6.29.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": "5dee9e0ebdef1bca6c586f4802285a0f429ae432"
+  "gitref": "b0d822e147a21ef1051b36c474b303839e980b13"
 }