@uipath/maestro-builder-sdk 6.38.0 → 6.40.0

package/dist/bpmn/serialize.js

@@ -19,6 +19,7 @@ import { createConnectorTask } from './connector.js';
 import { createConnectorEvent, createExternalTask, intsvcOutputVar } from './intsvc.js';
 import { createExtensionPayload, createTypedNode, rowDeclaration, typedNodeOutputVar, verbatimOutputRows } from './typed-node.js';
 import { connectorOutputVars, typedNodeDeclaredVars } from './declared-vars.js';
+import { defaultEntryPointId } from './entry-point-id.js';
 const require = createRequire(import.meta.url);
 const uipathDescriptor = require('./uipath-moddle.v1.json');
 const NS = {
@@ -138,16 +139,7 @@ export async function serialize(built, opts = {}) {
     const meta = built.metadata;
     if (meta?.migrationVersion !== undefined)
         processExt.push(m.create('uipath:MigrationVersion', { version: meta.migrationVersion }));
-    if (meta?.entryPointId !== undefined) {
-        // The package metadata generator discovers entry points by reading the root start
-        // event. A process-level `uipath:entryPointId` looks plausible and validates as XML,
-        // but is invisible to `update-metadata`, which then writes an empty entry-points.json.
-        const start = flowElements.find((element) => element.$type === 'bpmn:StartEvent');
-        if (start) {
-            const extensions = (start.extensionElements ??= m.create('bpmn:ExtensionElements', { values: [] }));
-            (extensions.values ??= []).unshift(m.create('uipath:EntryPointId', { value: meta.entryPointId }));
-        }
-    }
+    stampEntryPointIds(ctx, built, flowElements, meta?.entryPointId);
     if (meta?.tags !== undefined && meta.tags.length > 0)
         processExt.push(m.create('uipath:Tags', { tags: meta.tags.map((t) => m.create('uipath:Tag', { value: t })) }));
     if (meta?.caseManagement !== undefined)
@@ -218,6 +210,57 @@ export function processId(id) {
     return /^[A-Za-z_][\w.-]*$/.test(id) ? id : 'Process_1';
 }
 // ─── Scope (process root or a sub-process body) ───────────────────────────────
+/**
+ * `uipath:entryPointId` on the process's root start events, triggered or manual.
+ *
+ * The package metadata generator discovers entry points by reading the root start
+ * events — a process-level `uipath:entryPointId` looks plausible and validates as XML,
+ * but is invisible to `update-metadata`, which then writes an empty entry-points.json
+ * — and `uip maestro bpmn refresh` requires exactly one, a GUID, on each root manual
+ * start. The canvas writes one on every ROOT start and strips any inside a
+ * `bpmn:SubProcess` on save, so a nested start gets no derived id here, only one the
+ * author set. A root start takes, in order: the event's own option, else
+ * `.metadata({ entryPointId })` for the first root start in chain order, else the
+ * stable derived id (`entry-point-id.ts`, seeded from the builder's own process id, so
+ * two processes with the same start id derive different ids); `false` writes none.
+ */
+function stampEntryPointIds(ctx, built, flowElements, rootDefault) {
+    const { m } = ctx;
+    const own = new Map();
+    for (const n of allNodes(built.nodes)) {
+        if (n.kind === 'startEvent' || n.kind === 'connectorEvent' || n.kind === 'typed')
+            own.set(n.id, n.entryPointId);
+    }
+    let first = true;
+    const stamp = (el, value) => {
+        if (value === undefined || value === false)
+            return;
+        const extensions = (el.extensionElements ??= m.create('bpmn:ExtensionElements', { values: [] }));
+        const values = (extensions.values ??= []);
+        if (values.some((x) => x.$type === 'uipath:EntryPointId'))
+            return;
+        values.unshift(m.create('uipath:EntryPointId', { value }));
+    };
+    const visit = (elements, root) => {
+        for (const el of elements) {
+            if (el.$type === 'bpmn:SubProcess') {
+                visit(el.flowElements ?? [], false);
+                continue;
+            }
+            if (el.$type !== 'bpmn:StartEvent')
+                continue;
+            const explicit = own.get(el.id);
+            if (!root) {
+                stamp(el, explicit);
+                continue;
+            }
+            const value = explicit !== undefined ? explicit : first && rootDefault !== undefined ? rootDefault : defaultEntryPointId(built.id, el.id);
+            first = false;
+            stamp(el, value);
+        }
+    };
+    visit(flowElements, true);
+}
 /** Build the flowElements array for one scope, wiring all references within it. */
 function buildScope(ctx, nodes, flows) {
     const { m } = ctx;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.38.0",
+  "version": "6.40.0",
   "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": "56a00223262864847db6153351a39d877939abb7"
+  "gitref": "b3dd153cbf30937f6caf22ae3ad103d6ea678cb1"
 }