@uipath/maestro-builder-sdk 6.16.10 → 6.16.12

package/dist/registry/prepare/connections.js

@@ -279,10 +279,21 @@ export function solutionConnectionIds(cwd, connectorKey) {
  * module's rule intact — ambiguity is never resolved by guessing.
  */
 export async function candidateConnections(client, connectorKey, name) {
+    // Both listings are always needed here, so they run at once: each is a `uip`
+    // process and a tenant round trip (~1 s each, measured in the n8n-vs-flow
+    // adhoc run of 2026-10-06), and neither depends on the other. Started in
+    // own-folder-then-tenant order, merged in that order, and a failure is
+    // reported in that order too — the result is what the sequential loop gave.
+    const settled = await Promise.allSettled([false, true].map((allFolders) => listConnections(client, { allFolders })));
+    const listings = settled.map((outcome) => {
+        if (outcome.status === "rejected")
+            throw outcome.reason;
+        return outcome.value;
+    });
     const ordered = [];
     const seen = new Set();
-    for (const allFolders of [false, true]) {
-        for (const row of enabledConnections(await listConnections(client, { allFolders }), connectorKey, name)) {
+    for (const listing of listings) {
+        for (const row of enabledConnections(listing, connectorKey, name)) {
             const identifier = pyStrAny(pyGet(row, "Id", ""));
             if (identifier && seen.has(identifier))
                 continue;

package/dist/serialize.d.ts

@@ -88,6 +88,17 @@ export declare function serializeWithSidecars(built: BuiltFlow, opts?: Serialize
     }>;
 };
 export declare function serialize(built: BuiltFlow, opts?: SerializeOpts): any;
+/**
+ * Node ids and edge ids are each one namespace over the WHOLE file: the root
+ * and every `subflows` entry. Pack flattens subflows into one BPMN document, so
+ * two scopes sharing an id make it drop one element or crash in layout
+ * (`Cannot read properties of undefined (reading 'get')`), while `check` and
+ * `uip maestro flow validate` both pass. #938 shipped that way for `.stepToRef`
+ * edges; this check stops the next id scheme that forgets the file is shared.
+ *
+ * @throws Error naming each duplicated id and the scopes that carry it.
+ */
+export declare function assertFileWideIdsUnique(flow: any): void;
 /**
  * Every `<bindings.NAME>` placeholder a node's definition carries in its
  * `model.context` must resolve to a `bindings[]` entry for THAT node.

package/dist/serialize.js

@@ -3633,14 +3633,15 @@ const STICKY_NOTE_TYPE_VERSION = '1.0.0';
  * — a note colliding with a step would be silently dropped by the id-keyed
  * layout and merge paths downstream.
  */
-function emitStickyNotes(built, scope) {
+function emitStickyNotes(built, scope, claimNoteId) {
     const notes = built.stickyNotes;
     if (!notes?.length)
         return;
     const taken = new Set(scope.nodes.map((n) => n.id));
     const seen = new Set();
     notes.forEach((note, i) => {
-        const id = note.id ?? `stickyNote_${i + 1}`;
+        const authorId = note.id ?? `stickyNote_${i + 1}`;
+        const id = authorId;
         if (taken.has(id)) {
             throw new Error(`.stickyNotes(): id "${id}" is already a node in this flow. A sticky note is a real node, `
                 + `so its id has to be unique — name it something else.`);
@@ -3657,12 +3658,18 @@ function emitStickyNotes(built, scope) {
         if ((note.width === undefined) !== (note.height === undefined)) {
             throw new Error(`.stickyNotes(): note "${id}" needs both width and height, or neither.`);
         }
+        // Node ids are one namespace over the whole file (#938): pack merges every
+        // subflow into one BPMN document. The author's id is kept unless another
+        // scope already holds it — a child with notes, called from two steps — and
+        // `.layout()` finds a renamed note through `noteNodeId`.
+        const emittedId = claimNoteId(authorId);
+        (scope.noteNodeId ??= new Map()).set(authorId, emittedId);
         // The envelope Studio Web writes for a note (flow-v1 canvas: the add path
         // sets `typeVersion: '1.0.0'` and no display, and `nodeToInstance` persists
         // `display` as `{}`). Both fields are required on every node by
         // `flow validate`, manifest or not (#869).
         scope.nodes.push({
-            id,
+            id: emittedId,
             type: 'stickyNote',
             typeVersion: STICKY_NOTE_TYPE_VERSION,
             ui: {
@@ -3685,7 +3692,9 @@ function applyAuthorLayout(layout, scope, where) {
     if (!layout)
         return undefined;
     const resolveId = (key) => {
-        const id = scope.stepNodeId.get(key) ?? (scope.nodes.some((n) => n.id === key) ? key : undefined);
+        const id = scope.stepNodeId.get(key)
+            ?? scope.noteNodeId?.get(key)
+            ?? (scope.nodes.some((n) => n.id === key) ? key : undefined);
         if (!id) {
             throw new Error(`${where}.layout: "${key}" names no step or node in this flow. Layout keys are the flow's own step names (plus the trigger id and "end").`);
         }
@@ -4366,20 +4375,18 @@ function newScope(outputs, vars = []) {
  * exact class of failure `.onError` used to have (an error path that vanishes in
  * conversion with every rung green). So it throws instead.
  */
-function resolveRejoins(scope) {
+function resolveRejoins(scope, addEdge) {
     for (const { from, target } of scope.pendingEdges) {
         const id = scope.stepNodeId.get(target);
         if (!id) {
             throw new Error(`.stepToRef('${target}') names a step this flow does not have. Known steps: `
                 + `${[...scope.stepNodeId.keys()].join(', ') || '(none)'}.`);
         }
-        scope.edges.push({
-            id: `edge_ref_${scope.edges.length}`,
-            sourceNodeId: from.node,
-            sourcePort: from.port,
-            targetNodeId: id,
-            targetPort: 'input',
-        });
+        // Through the serializer's own `addEdge`, so the id comes from the one
+        // file-wide counter. A per-scope count (`edge_ref_${scope.edges.length}`)
+        // gave two subflow copies of one child the same edge id; pack then dropped
+        // one copy's edge or crashed in layout (flow-builder-sdk#938).
+        addEdge(scope, from, id);
     }
     scope.pendingEdges.length = 0;
 }
@@ -4653,6 +4660,18 @@ export function serialize(built, opts = {}) {
         takenIds.add(id);
         return id;
     }
+    /**
+     * A sticky note's id: the author's id as written when nothing in the file
+     * holds it yet, else `claimId`'s de-duplicated form. Not sanitized first, so
+     * an explicit note id the file does not collide on is emitted unchanged.
+     */
+    function claimNoteId(base) {
+        if (!takenIds.has(base)) {
+            takenIds.add(base);
+            return base;
+        }
+        return claimId(base);
+    }
     /**
      * `uid` for a node that IS an author's step, recording which id that step got.
      *
@@ -4672,8 +4691,9 @@ export function serialize(built, opts = {}) {
      * Base and quick-form human tasks emitted so far, by node id. `addEdge` holds
      * every edge out of one to the product's handle rule (`hitlExitViolation`), so
      * `completed` on a task with outcomes fails at the edge that would write it;
-     * `assertHitlExitInvariant` repeats the check over each finished scope for the
-     * edges that do not come through here (parked `.stepToRef` rejoins).
+     * `assertHitlExitInvariant` repeats the check over each finished scope, as a
+     * guard for any future edge that is pushed without coming through here (parked
+     * `.stepToRef` rejoins now do come through here, #938).
      */
     const hitlNodes = new Map();
     /**
@@ -4796,10 +4816,10 @@ export function serialize(built, opts = {}) {
             globals.push({ id: o.name, name: o.name, direction: 'out', type: o.type, ...varMeta(o) });
         for (const vd of childGlobals.vars)
             globals.push({ id: vd.name, name: vd.name, direction: 'inout', type: vd.type, ...varMeta(vd) });
-        resolveRejoins(scope);
+        resolveRejoins(scope, addEdge);
         assertHitlExitInvariant(scope.nodes, scope.edges);
         typeAgentInputSchemas(scope, globals);
-        emitStickyNotes(child, scope);
+        emitStickyNotes(child, scope, claimNoteId);
         const layoutEdges = applyAuthorLayout(child.layout, scope, `subflow "${nodeId}"`);
         assertNodeEnvelope(scope.nodes, `subflow "${nodeId}"`);
         return {
@@ -6964,10 +6984,10 @@ export function serialize(built, opts = {}) {
             globals.push({ id: inp.name, name: inp.name, direction: 'in', type: inp.type, triggerNodeId: ep.id, ...varMeta(inp) });
         }
     }
-    resolveRejoins(root);
+    resolveRejoins(root, addEdge);
     assertHitlExitInvariant(root.nodes, root.edges);
     typeAgentInputSchemas(root, globals);
-    emitStickyNotes(built, root);
+    emitStickyNotes(built, root, claimNoteId);
     const rootLayoutEdges = applyAuthorLayout(built.layout, root, `flow "${built.id}"`);
     assertNodeEnvelope(root.nodes, `flow "${built.id}"`);
     // The FILE-FORMAT version this document declares: the author's
@@ -7002,9 +7022,44 @@ export function serialize(built, opts = {}) {
     // so every family and every emission order is covered by one rule, not by
     // each call site remembering it (flow-builder-sdk#865/#866).
     assertBindingPlaceholdersResolve(flow);
+    assertFileWideIdsUnique(flow);
     connectionConnectors(flow);
     return flow;
 }
+/**
+ * Node ids and edge ids are each one namespace over the WHOLE file: the root
+ * and every `subflows` entry. Pack flattens subflows into one BPMN document, so
+ * two scopes sharing an id make it drop one element or crash in layout
+ * (`Cannot read properties of undefined (reading 'get')`), while `check` and
+ * `uip maestro flow validate` both pass. #938 shipped that way for `.stepToRef`
+ * edges; this check stops the next id scheme that forgets the file is shared.
+ *
+ * @throws Error naming each duplicated id and the scopes that carry it.
+ */
+export function assertFileWideIdsUnique(flow) {
+    const scopes = [['root', flow]];
+    for (const [name, sub] of Object.entries(flow?.subflows ?? {}))
+        scopes.push([`subflows.${name}`, sub]);
+    const dupes = [];
+    for (const kind of ['nodes', 'edges']) {
+        const seen = new Map();
+        for (const [where, scope] of scopes) {
+            for (const el of Array.isArray(scope?.[kind]) ? scope[kind] : []) {
+                const id = el?.id;
+                if (typeof id !== 'string')
+                    continue;
+                const first = seen.get(id);
+                if (first !== undefined)
+                    dupes.push(`${kind.slice(0, -1)} id "${id}" in ${first} and ${where}`);
+                else
+                    seen.set(id, where);
+            }
+        }
+    }
+    if (dupes.length) {
+        throw new Error(`serialize: ids must be unique across the root and all subflows; duplicated: ${dupes.join('; ')}.`);
+    }
+}
 /**
  * Every `<bindings.NAME>` placeholder a node's definition carries in its
  * `model.context` must resolve to a `bindings[]` entry for THAT node.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.16.10",
+  "version": "6.16.12",
   "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": "2e666ec2dd9e7baa4716a2a0d21ee86484b0de89"
+  "gitref": "a17e4a3af0cefe7881625c5888b282c4ea4a0546"
 }