@uipath/maestro-builder-sdk 6.46.6 → 6.46.7

package/dist/case/decompile.js

@@ -5,6 +5,7 @@ import { preserveSchemaVersion } from '../schema-version.js';
 import { ownEntry } from '../core/own-entry.js';
 import { isUnrestorableSlotId } from './preserve.js';
 import { isInSolutionKey, SOLUTION_FOLDER } from './resource-identity.js';
+import { offlineBindingLabel } from './ids.js';
 const TASK_KIND_METHOD = {
     process: 'process',
     agent: 'agent',
@@ -342,7 +343,18 @@ function bindingName(value, refs) {
     if (typeof value !== 'string' || !value.startsWith('=bindings.'))
         return undefined;
     const id = value.slice('=bindings.'.length);
-    return refs.bindingById.get(id)?.id ?? id;
+    return bindingLabel(refs, id);
+}
+/**
+ * The name a binding reference decompiles to: the authored label when
+ * `serialize` minted the row offline (so a recompile with no bindings.json
+ * mints the same row, and a later bindings.json entry for that label matches),
+ * else the row id (a bindings.json or Designer row, which the recompile
+ * resolves by id).
+ */
+function bindingLabel(refs, id) {
+    const row = refs.bindingById.get(id);
+    return offlineBindingLabel(row) ?? row?.id ?? id;
 }
 /**
  * The literal a resource task's `data.name` / `data.folderPath` names: the
@@ -567,7 +579,7 @@ function externalCall(task, refs, library) {
         const id = value.slice('=bindings.'.length);
         if (!refs.bindingById.has(id))
             throw new Error(`${owner} context ${name} references missing root binding "${id}".`);
-        return id;
+        return bindingLabel(refs, id);
     };
     const identity = library.identifyAction({
         connectorKey: stringValue('connectorKey'),

package/dist/case/ids.d.ts

@@ -22,3 +22,29 @@ export declare class IdGen {
     conditionId(seed: string): string;
     ruleId(seed: string): string;
 }
+/**
+ * The seed `serialize` mints an offline binding id from (a connection or
+ * folder label no bindings.json declares). One definition for both sides, so
+ * {@link offlineBindingLabel} can recognise exactly the ids `serialize` mints.
+ *
+ * @param resource - The binding's `resource` (`Connection`).
+ * @param propertyAttribute - `ConnectionId` or `folderKey`.
+ * @param name - The authored label.
+ * @param connectionKey - For a folder bound to a connection, that connection's resourceKey.
+ * @returns The seed string.
+ */
+export declare function offlineBindingSeed(resource: string, propertyAttribute: string, name: string, connectionKey?: string): string;
+/**
+ * The authored label behind a root binding row that `serialize` minted offline,
+ * or `undefined` for any other row (a bindings.json entry, a Designer row).
+ *
+ * Offline the label is the row's only real content: a connection row carries
+ * it as `resourceKey`, a folder row on a connection as `default`, a plain
+ * folder row as `resourceKey`. The row is recognised only when its `id` is
+ * exactly the id that label mints, so decompile can name it by the label and
+ * a recompile with no bindings mints the same row again.
+ *
+ * @param row - A root binding entry.
+ * @returns The label, or `undefined`.
+ */
+export declare function offlineBindingLabel(row: Record<string, unknown> | undefined): string | undefined;

package/dist/case/ids.js

@@ -74,3 +74,52 @@ export class IdGen {
         return this.make('Rule_', 6, seed);
     }
 }
+/**
+ * The seed `serialize` mints an offline binding id from (a connection or
+ * folder label no bindings.json declares). One definition for both sides, so
+ * {@link offlineBindingLabel} can recognise exactly the ids `serialize` mints.
+ *
+ * @param resource - The binding's `resource` (`Connection`).
+ * @param propertyAttribute - `ConnectionId` or `folderKey`.
+ * @param name - The authored label.
+ * @param connectionKey - For a folder bound to a connection, that connection's resourceKey.
+ * @returns The seed string.
+ */
+export function offlineBindingSeed(resource, propertyAttribute, name, connectionKey) {
+    return connectionKey === undefined
+        ? `binding:${resource}:${propertyAttribute}:${name}`
+        : `binding:${resource}:${propertyAttribute}:${connectionKey}:${name}`;
+}
+/** The binding id {@link IdGen.make} gives `seed` at salt 0..3 (`b` + 8 base-62). */
+function offlineBindingIds(seed) {
+    return [0, 1, 2, 3].map((salt) => 'b' + base62(salt === 0 ? seed : `${seed}~${salt}`, 8));
+}
+/**
+ * The authored label behind a root binding row that `serialize` minted offline,
+ * or `undefined` for any other row (a bindings.json entry, a Designer row).
+ *
+ * Offline the label is the row's only real content: a connection row carries
+ * it as `resourceKey`, a folder row on a connection as `default`, a plain
+ * folder row as `resourceKey`. The row is recognised only when its `id` is
+ * exactly the id that label mints, so decompile can name it by the label and
+ * a recompile with no bindings mints the same row again.
+ *
+ * @param row - A root binding entry.
+ * @returns The label, or `undefined`.
+ */
+export function offlineBindingLabel(row) {
+    if (!row || typeof row.id !== 'string')
+        return undefined;
+    const { id, resource, propertyAttribute, resourceKey } = row;
+    if (typeof resource !== 'string' || typeof propertyAttribute !== 'string' || typeof resourceKey !== 'string')
+        return undefined;
+    const candidates = [
+        [resourceKey, offlineBindingSeed(resource, propertyAttribute, resourceKey)],
+    ];
+    if (propertyAttribute === 'folderKey' && typeof row.default === 'string')
+        candidates.push([row.default, offlineBindingSeed(resource, propertyAttribute, row.default, resourceKey)]);
+    for (const [label, seed] of candidates)
+        if (offlineBindingIds(seed).includes(id))
+            return label;
+    return undefined;
+}

package/dist/case/serialize.js

@@ -8,7 +8,7 @@
  * `metadata.caseExitRules`. Symbolic references in rules (a stage label, a task
  * name) are resolved here to the generated ids.
  */
-import { IdGen } from './ids.js';
+import { IdGen, offlineBindingSeed } from './ids.js';
 import { isUnrestorableSlotId } from './preserve.js';
 import { v31TaskSets } from './task-sets.js';
 import { buildConnectorInputs, nestConnectorBody, transportHttpMethod } from '../core/connector-inputs.js';
@@ -81,6 +81,8 @@ export function serialize(built, opts = {}) {
         library: opts.library,
         bindings: opts.bindings,
         bindingSink: new Map(),
+        ids,
+        offlineBindingIds: new Map(),
         varCompanions: new Map(),
         outputIds: new Set(),
         ownOutputVars: ownOutputVars(built),
@@ -1469,6 +1471,20 @@ function ioSlot(name, bodyObj, elementId) {
     const v = `v${name}`;
     return { name, type: 'json', target: name, body: bodyObj, var: v, id: v, elementId };
 }
+/**
+ * The binding id for a label no bindings.json declares. The row's
+ * `resourceKey`/`default` stays the label, and the id is minted from it (`b` +
+ * 8, as Studio Web mints one), once per label; `offlineBindingLabel` reverses
+ * it for decompile.
+ */
+function offlineBindingId(resolver, seed) {
+    let id = resolver.offlineBindingIds.get(seed);
+    if (id === undefined) {
+        id = resolver.ids.make('b', 8, seed);
+        resolver.offlineBindingIds.set(seed, id);
+    }
+    return id;
+}
 /** Resolve a symbolic connection/folder to a root binding entry (collected once),
  * returning its id + resourceKey for the `=bindings.<id>` reference. */
 function bindingRef(resolver, name, resource, propertyAttribute, displayName, site) {
@@ -1483,8 +1499,12 @@ function bindingRef(resolver, name, resource, propertyAttribute, displayName, si
     if (refused)
         throw refused;
     const entry = resolver.bindings?.entry(name);
-    const id = entry?.id ?? name;
     const resourceKey = entry?.resourceKey ?? entry?.default ?? name;
+    // Only a label with no bindings.json entry gets a minted id: an entry's
+    // `resourceKey` is the real key, so its id (or its name) cannot clash with it.
+    const id = entry
+        ? String(entry.id ?? name)
+        : offlineBindingId(resolver, offlineBindingSeed(resource, propertyAttribute, name));
     if (!resolver.bindingSink.has(id)) {
         resolver.bindingSink.set(id, {
             id,
@@ -1501,7 +1521,8 @@ function bindingRef(resolver, name, resource, propertyAttribute, displayName, si
 /**
  * A connector's folder is a property of its connection:
  * { resourceKey: <connection key>, default: <folder key>, propertyAttribute: 'folderKey' }.
- * One folder label on two connections gets one row each: `shared`, `shared_2`.
+ * One folder label on two connections gets one row each: `shared`, `shared_2`
+ * (offline, the minted id is seeded on the connection, so the rows differ anyway).
  * One connection with two different folders is refused: a connection lives in
  * one folder, and the syncs group rows by `resourceKey`, so one value would win.
  * Without a connection the folder binds as a plain binding.
@@ -1515,7 +1536,9 @@ function folderBindingRef(resolver, name, connection, site) {
     if (refused)
         throw refused;
     const entry = resolver.bindings?.entry(name);
-    const baseId = entry?.id ?? name;
+    const baseId = entry
+        ? String(entry.id ?? name)
+        : offlineBindingId(resolver, offlineBindingSeed('Connection', 'folderKey', name, connection.resourceKey));
     const folderKey = entry?.default ?? entry?.resourceKey ?? name;
     const matches = (row) => row?.resourceKey === connection.resourceKey && row?.default === folderKey
         && row?.propertyAttribute === 'folderKey';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.46.6",
+  "version": "6.46.7",
   "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": "64e024e591ad47ef3ebcdebe54d8a07ead2aa871"
+  "gitref": "68e27a784a7d9b4fff5177074148d05e0c993a65"
 }