@uipath/maestro-builder-sdk 6.16.7 → 6.16.8

package/dist/case/compile-cli.js

@@ -12,7 +12,6 @@
 import { reportResult } from '../cli-result.js';
 import { writeFileSync, readFileSync, existsSync } from 'node:fs';
 import { join, dirname, basename, resolve } from 'node:path';
-import { createHash } from 'node:crypto';
 import { resolveCaseFile, loadBuiltCase } from './load.js';
 import { serialize } from './serialize.js';
 import { check } from './check.js';
@@ -23,6 +22,7 @@ import { defaultBindingsFile } from '../workdir.js';
 import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';
 import { ensureTypeScriptRuntime } from '../node-runtime.js';
 import { CASE_FORMAT_PROFILE } from './format-profile.js';
+import { sha256Uuid } from '../core/stable-id.js';
 export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
         console.error('usage: compile <case.ts | BaseName> [-o caseplan.json]');
@@ -128,7 +128,7 @@ function syncEntryPoints(caseplan, outPath) {
         const { input, output } = entryPointIO(caseplan.variables, n.id);
         return {
             filePath: `/content/${base}.bpmn#${n.id}`,
-            uniqueId: prev?.uniqueId ?? stableUuid(`entrypoint:${n.id}`),
+            uniqueId: prev?.uniqueId ?? sha256Uuid(`entrypoint:${n.id}`),
             type: 'CaseManagement',
             input,
             output,
@@ -279,9 +279,4 @@ function isRecord(value) {
 function stringValue(value) {
     return typeof value === 'string' && value.length > 0 ? value : undefined;
 }
-/** A deterministic UUID-shaped id (not a real v4 — the schema only needs a stable string). */
-function stableUuid(seed) {
-    const h = createHash('sha256').update(seed).digest('hex');
-    return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
-}
 runWhenInvokedDirectly(import.meta.url, 'compile', run);

package/dist/core/stable-id.d.ts

@@ -24,5 +24,38 @@
  * cannot read as a uuid. Coercing to unsigned first is the whole repair; the
  * hash itself is unchanged, so a seed that produced a WELL-FORMED id still
  * produces exactly that id.
+ *
+ * ## Three seed → uuid algorithms live here, and they are NOT interchangeable
+ *
+ * `stableId` (connector filter trees, event subscriptions), `fnv1aX4Uuid` (Flow
+ * inline-agent resource ids) and `sha256Uuid` (Case entry-point `uniqueId`) each
+ * produce ids that are already in shipped artifacts. Replacing one with another
+ * renames those resources on the next compile of every existing project. They are
+ * owned here so there is one place to look. The golden table in
+ * `tests/stable-id.test.ts` pins what each function returns, not which one a call
+ * site uses; `tests/cli.test.ts` pins the Case entry point's `uniqueId`. Change one
+ * only deliberately, updating that table and any byte-lock fixture it moves.
  */
+/** A uuid-shaped id derived from `seed`. Every segment is unsigned, including the `>>> 0` fix explained above. */
 export declare function stableId(seed: string): string;
+/**
+ * A deterministic v4-shaped uuid from a string.
+ *
+ * Used for an inline agent's `source` when the author does not pass one. It has to
+ * LOOK like a uuid (the platform treats it as an opaque directory name and the
+ * designer shows it as a folder) and it has to be STABLE, because a random one would
+ * make every recompile a diff of the `.flow` and a rename of a directory. FNV-1a
+ * ×4 with the version/variant nibbles pinned — not a cryptographic hash, and it does
+ * not need to be: the only requirement is that two different (flow, step) pairs do
+ * not collide within one project.
+ *
+ * Consumer: Flow inline-agent resource ids in `serialize.ts`.
+ */
+export declare function fnv1aX4Uuid(seed: string): string;
+/**
+ * A deterministic UUID-shaped id (not a real v4 — the schema only needs a stable string):
+ * the first 128 bits of SHA-256(`seed`), no version or variant bits set.
+ *
+ * Consumer: a Case entry point's `uniqueId` in `entry-points.json` (`case/compile-cli.ts`).
+ */
+export declare function sha256Uuid(seed: string): string;

package/dist/core/stable-id.js

@@ -24,7 +24,20 @@
  * cannot read as a uuid. Coercing to unsigned first is the whole repair; the
  * hash itself is unchanged, so a seed that produced a WELL-FORMED id still
  * produces exactly that id.
+ *
+ * ## Three seed → uuid algorithms live here, and they are NOT interchangeable
+ *
+ * `stableId` (connector filter trees, event subscriptions), `fnv1aX4Uuid` (Flow
+ * inline-agent resource ids) and `sha256Uuid` (Case entry-point `uniqueId`) each
+ * produce ids that are already in shipped artifacts. Replacing one with another
+ * renames those resources on the next compile of every existing project. They are
+ * owned here so there is one place to look. The golden table in
+ * `tests/stable-id.test.ts` pins what each function returns, not which one a call
+ * site uses; `tests/cli.test.ts` pins the Case entry point's `uniqueId`. Change one
+ * only deliberately, updating that table and any byte-lock fixture it moves.
  */
+import { createHash } from 'node:crypto';
+/** A uuid-shaped id derived from `seed`. Every segment is unsigned, including the `>>> 0` fix explained above. */
 export function stableId(seed) {
     let h1 = 0x811c9dc5;
     let h2 = 0x01000193;
@@ -35,3 +48,46 @@ export function stableId(seed) {
     const hex = (n, len) => (n >>> 0).toString(16).padStart(8, '0').slice(0, len);
     return `${hex(h1, 8)}-${hex(h2, 4)}-4${hex(h1 >>> 8, 3)}-8${hex(h2 >>> 8, 3)}-${hex(h1 ^ h2, 8)}${hex(h2, 4)}`;
 }
+/**
+ * A deterministic v4-shaped uuid from a string.
+ *
+ * Used for an inline agent's `source` when the author does not pass one. It has to
+ * LOOK like a uuid (the platform treats it as an opaque directory name and the
+ * designer shows it as a folder) and it has to be STABLE, because a random one would
+ * make every recompile a diff of the `.flow` and a rename of a directory. FNV-1a
+ * ×4 with the version/variant nibbles pinned — not a cryptographic hash, and it does
+ * not need to be: the only requirement is that two different (flow, step) pairs do
+ * not collide within one project.
+ *
+ * Consumer: Flow inline-agent resource ids in `serialize.ts`.
+ */
+export function fnv1aX4Uuid(seed) {
+    const words = [];
+    for (let i = 0; i < 4; i++) {
+        let h = 0x811c9dc5 ^ (i * 0x9e3779b9);
+        const s = `${seed}#${i}`;
+        for (let j = 0; j < s.length; j++) {
+            h ^= s.charCodeAt(j);
+            h = Math.imul(h, 0x01000193) >>> 0;
+        }
+        words.push(h >>> 0);
+    }
+    const hex = words.map((w) => w.toString(16).padStart(8, '0')).join('');
+    return [
+        hex.slice(0, 8),
+        hex.slice(8, 12),
+        `4${hex.slice(13, 16)}`,
+        `${((parseInt(hex.slice(16, 17), 16) & 0x3) | 0x8).toString(16)}${hex.slice(17, 20)}`,
+        hex.slice(20, 32),
+    ].join('-');
+}
+/**
+ * A deterministic UUID-shaped id (not a real v4 — the schema only needs a stable string):
+ * the first 128 bits of SHA-256(`seed`), no version or variant bits set.
+ *
+ * Consumer: a Case entry point's `uniqueId` in `entry-points.json` (`case/compile-cli.ts`).
+ */
+export function sha256Uuid(seed) {
+    const h = createHash('sha256').update(seed).digest('hex');
+    return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
+}

package/dist/serialize.js

@@ -23,7 +23,7 @@ import { declaredExits, hasExits } from './core/step-ports.js';
 import { stopsAtEnd } from './flow-step-tree.js';
 import { assertNodeEnvelope } from './core/node-envelope.js';
 import { buildConfiguration } from './config.js';
-import { stableId } from './core/stable-id.js';
+import { fnv1aX4Uuid, stableId } from './core/stable-id.js';
 import { readEventFilter, eventFilterProblem, eventFilterJmes, eventFilterTreeLeaf } from './core/event-filters.js';
 import { FLOW_EXPR_DIALECT } from './core/connector-checks.js';
 import { buildConnectorInputs, connectorInputErrors as coreConnectorInputErrors, multipartBodyFieldName, transportHttpMethod } from './core/connector-inputs.js';
@@ -3429,37 +3429,6 @@ export function serializeWithSidecars(built, opts = {}) {
     const flow = serialize(built, { ...opts, sidecars });
     return { flow, sidecars };
 }
-/**
- * A deterministic v4-shaped uuid from a string.
- *
- * Used for an inline agent's `source` when the author does not pass one. It has to
- * LOOK like a uuid (the platform treats it as an opaque directory name and the
- * designer shows it as a folder) and it has to be STABLE, because a random one would
- * make every recompile a diff of the `.flow` and a rename of a directory. FNV-1a
- * ×4 with the version/variant nibbles pinned — not a cryptographic hash, and it does
- * not need to be: the only requirement is that two different (flow, step) pairs do
- * not collide within one project.
- */
-function stableUuid(seed) {
-    const words = [];
-    for (let i = 0; i < 4; i++) {
-        let h = 0x811c9dc5 ^ (i * 0x9e3779b9);
-        const s = `${seed}#${i}`;
-        for (let j = 0; j < s.length; j++) {
-            h ^= s.charCodeAt(j);
-            h = Math.imul(h, 0x01000193) >>> 0;
-        }
-        words.push(h >>> 0);
-    }
-    const hex = words.map((w) => w.toString(16).padStart(8, '0')).join('');
-    return [
-        hex.slice(0, 8),
-        hex.slice(8, 12),
-        `4${hex.slice(13, 16)}`,
-        `${((parseInt(hex.slice(16, 17), 16) & 0x3) | 0x8).toString(16)}${hex.slice(17, 20)}`,
-        hex.slice(20, 32),
-    ].join('-');
-}
 /**
  * `variables.nodes` — one entry per node OUTPUT, derived from the nodes we just
  * emitted.
@@ -5081,7 +5050,7 @@ export function serialize(built, opts = {}) {
             // name rather than random so a recompile is byte-identical — a v4-shaped uuid
             // over a stable hash, because the platform treats it as an opaque id and the
             // designer shows it as a folder.
-            const source = s.source ?? stableUuid(`${built.id}/${step.name}`);
+            const source = s.source ?? fnv1aX4Uuid(`${built.id}/${step.name}`);
             const node = makeNode(def.nodeType, id, step.name, { parentId, requestedVersion: step.options?.version, def });
             // Unlike the published families the inline agent KEEPS no node-level model:
             // 29 of 29 deployed instances carry none (the def's `model.source: true` is
@@ -5193,7 +5162,7 @@ export function serialize(built, opts = {}) {
                 // resource's `id` are the same uuid, because that is what joins them. The
                 // platform validator says so in its own refusal text — *"the resource id
                 // from the parent inline agent's `resources[]`"*.
-                const contextResourceId = stableUuid(`${built.id}/${step.name}/context/${cx.id}`);
+                const contextResourceId = fnv1aX4Uuid(`${built.id}/${step.name}/context/${cx.id}`);
                 const contextQuery = renderContextQuery(cx.query, scope.rename);
                 cnode.inputs = {
                     // REQUIRED, and the platform's validator is what says so — measured
@@ -5407,7 +5376,7 @@ export function serialize(built, opts = {}) {
                             : tr.kind === 'clientside' ? `clientside.${tr.name}`
                                 : tr.kind === 'httpRequest' ? `httprequest.${tr.name ?? 'default'}`
                                     : tr.key;
-                const toolResourceId = stableUuid(`${built.id}/${step.name}/tool/${toolSeed}`);
+                const toolResourceId = fnv1aX4Uuid(`${built.id}/${step.name}/tool/${toolSeed}`);
                 tnode.inputs = {
                     source: toolResourceId,
                     ...extraInputs,
@@ -5450,7 +5419,7 @@ export function serialize(built, opts = {}) {
                         type: f.type,
                         direction: f.direction,
                     }));
-                    const qsource = stableUuid(`${built.id}/${step.name}/escalation/${esc.name}`);
+                    const qsource = fnv1aX4Uuid(`${built.id}/${step.name}/escalation/${esc.name}`);
                     qnode.inputs = {
                         source: qsource,
                         name: esc.name,
@@ -5486,7 +5455,7 @@ export function serialize(built, opts = {}) {
                         path: `${source}/resources/${qsource}/resource.json`,
                         json: escalationResourceJson(esc, {
                             id: qsource,
-                            channelId: stableUuid(`${built.id}/${step.name}/escalation/${esc.name}/channel`),
+                            channelId: fnv1aX4Uuid(`${built.id}/${step.name}/escalation/${esc.name}/channel`),
                             quickFormSchema: qnode.inputs.schema,
                         }),
                     });
@@ -5498,7 +5467,7 @@ export function serialize(built, opts = {}) {
                 const enode = makeNode(edef.nodeType, eid, esc.name, { parentId, def: edef });
                 enode.display = { ...enode.display, shape: 'circle' };
                 delete enode.model;
-                const esource = stableUuid(`${built.id}/${step.name}/escalation/${esc.name}`);
+                const esource = fnv1aX4Uuid(`${built.id}/${step.name}/escalation/${esc.name}`);
                 enode.inputs = {
                     source: esource,
                     name: esc.name,
@@ -5535,7 +5504,7 @@ export function serialize(built, opts = {}) {
                     path: `${source}/resources/${esource}/resource.json`,
                     json: escalationResourceJson(esc, {
                         id: esource,
-                        channelId: stableUuid(`${built.id}/${step.name}/escalation/${esc.name}/channel`),
+                        channelId: fnv1aX4Uuid(`${built.id}/${step.name}/escalation/${esc.name}/channel`),
                     }),
                 });
             }
@@ -5549,7 +5518,7 @@ export function serialize(built, opts = {}) {
                 mnode.display = { ...mnode.display, shape: 'circle' };
                 delete mnode.model;
                 mnode.inputs = {
-                    source: stableUuid(`${built.id}/${step.name}/memory/${m.id}`),
+                    source: fnv1aX4Uuid(`${built.id}/${step.name}/memory/${m.id}`),
                     name: m.name,
                     description: m.description ?? '',
                     dynamicFewShotLearning: m.dynamicFewShotLearning ?? true,
@@ -5665,7 +5634,7 @@ export function serialize(built, opts = {}) {
             // lets the platform do that translation.
             const s = spec.inputs;
             const id = stepUid(scope, step.name);
-            const source = s.source ?? stableUuid(`${built.id}/${step.name}`);
+            const source = s.source ?? fnv1aX4Uuid(`${built.id}/${step.name}`);
             const node = makeNode(NODE_TYPE.conversationalAgent, id, step.name, { parentId, requestedVersion: step.options?.version });
             delete node.model;
             const st = s.settings ?? {};
@@ -5758,7 +5727,7 @@ export function serialize(built, opts = {}) {
             // definition declares what comes back.
             const s = spec.inputs;
             const id = stepUid(scope, step.name);
-            const source = s.source ?? stableUuid(`${built.id}/${step.name}`);
+            const source = s.source ?? fnv1aX4Uuid(`${built.id}/${step.name}`);
             const node = makeNode(NODE_TYPE.voiceAgent, id, step.name, { parentId, requestedVersion: step.options?.version });
             // Same rule as the inline agent's: the resource model lives on the
             // definition (its `model.source: true` is what makes `source` an input).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.16.7",
+  "version": "6.16.8",
   "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": "c769835ca295fd52b2f51584b3e21ef9bb226347"
+  "gitref": "77b292a40160cde6e025bbeb534397e5e930bae1"
 }