@uipath/maestro-builder-sdk 6.68.2 → 6.68.3

package/dist/case/check.js

@@ -3,7 +3,7 @@ import { ruleShapeProblems } from './rule-options.js';
 import { types } from '../core/expr.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS, authoredCaseVersion, caseVersionMismatch } from './format-profile.js';
 import { schemaVersionRefusal } from '../schema-version.js';
-import { caseJsonPreservation, caseJsonPreservationErrors } from './preserve.js';
+import { caseJsonPreservation, caseJsonPreservationErrors, preservedBindings } from './preserve.js';
 import { EQUALS_EXPR_DIALECT, checkBindingLabels, checkConnectorContract, checkConnectorLookups, checkConnectorSchema, } from '../core/connector-checks.js';
 import { checkEventResolution } from '../core/event-checks.js';
 import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, EXTERNAL_TASK_HYBRID_UNSUPPORTED, externalHybridRefusal, isExternalExecutionMode } from './external.js';
@@ -25,6 +25,11 @@ const ILLEGAL = [];
  */
 export function check(built, opts = {}) {
     const diags = [];
+    // The same registry `serialize` resolves against, so the two agree on which
+    // labels a decompiled source's preserved binding rows answer.
+    const bindings = preservedBindings(opts.bindings, caseJsonPreservation(built));
+    if (bindings !== opts.bindings)
+        opts = { ...opts, bindings };
     for (const message of caseJsonPreservationErrors(caseJsonPreservation(built)))
         diags.push({
             level: 'error',

package/dist/case/decompile.d.ts

@@ -225,6 +225,7 @@ type Preservation = {
         task: string;
     }>;
     identities?: unknown;
+    bindings?: Record<string, unknown>[];
 };
 /**
  * Everything the ORIGINAL document owns and the typed builder does not model —

package/dist/case/decompile.js

@@ -1315,6 +1315,26 @@ function identityPreservation(plan) {
         ])),
     };
 }
+/**
+ * The root connection/folder rows a recompile needs to resolve the labels
+ * decompile names connectors by. `bindingLabel` writes such a label as the
+ * row's `id` (`connection: "bOC1"`), and that id means nothing without the row.
+ * Kept: `resource: "Connection"` rows with a key other than their own id. Not
+ * kept: a row `serialize` minted offline (decompile writes its authored label,
+ * and a recompile mints the same row again) and a row keyed by its own id
+ * (a placeholder, which `Bindings` would ignore anyway).
+ */
+function preservedBindingRows(plan) {
+    return (plan.bindings ?? []).filter((row) => {
+        const r = row;
+        if (typeof r.id !== 'string' || r.resource !== 'Connection')
+            return false;
+        if (offlineBindingLabel(r) !== undefined)
+            return false;
+        const key = r.resourceKey ?? r.default;
+        return typeof key === 'string' && key !== '' && key !== r.id;
+    });
+}
 /**
  * Everything the ORIGINAL document owns and the typed builder does not model —
  * ids, layout, platform metadata, annotation nodes, node order, designer
@@ -1436,6 +1456,9 @@ export function collectPreservation(plan) {
         preservation.omitTaskElementIds = omitTaskElementIds;
     if (omitStagePositions.length)
         preservation.omitStagePositions = omitStagePositions;
+    const bindingRows = preservedBindingRows(plan);
+    if (bindingRows.length)
+        preservation.bindings = bindingRows;
     const variableKnown = new Set(['id', 'name', 'type', 'default', 'body', '_jsonSchema', 'elementId', 'var', 'custom']);
     const variableFields = {};
     const legacyVariableDefaults = {};

package/dist/case/preserve.d.ts

@@ -1,4 +1,6 @@
 import type { BuiltCase } from './case-sdk.js';
+import { Bindings } from '../core/bindings.js';
+import type { BindingsView } from '../core/binding-messages.js';
 export type PreservedVariableLane = 'inputs' | 'outputs' | 'inputOutputs';
 /**
  * A preserved `inputs[]` / `outputs[]` slot id copied verbatim from its name is
@@ -143,11 +145,41 @@ export interface CaseJsonPreservation {
     omitTaskElementIds?: PreservedTaskRef[];
     /** Opaque wire identities aligned to typed constructs by name and position. */
     identities?: CaseIdentityPreservation;
+    /**
+     * The original plan's connection and folder rows from root `bindings[]`: the
+     * map from the binding id decompile names a connector by
+     * (`connection: "bOC1"`) to its resource key. Compile reads them only to
+     * resolve such a label when bindings.json does not answer it (see
+     * {@link preservedBindings}); it emits a row only when a task references it.
+     * Without them, compiling the source anywhere but over the original plan
+     * wrote `resourceKey: "bOC1"`, and nothing refused it (builder-sdk#1242).
+     */
+    bindings?: Record<string, unknown>[];
 }
 /** Attach decompiler-owned, non-authoring wire data to a built case. */
 export declare function preserveCaseJson(built: BuiltCase, payload: CaseJsonPreservation): BuiltCase;
 /** @internal Read the preservation payload attached by `preserveCaseJson`. */
 export declare function caseJsonPreservation(built: BuiltCase): CaseJsonPreservation | undefined;
+/**
+ * The bindings registry `check` and `serialize` resolve a decompiled source's
+ * connection and folder labels against: `bindings` plus the rows the source
+ * preserved ({@link CaseJsonPreservation.bindings}) as fallback rows. A fallback
+ * row answers only a label equal to its id, never counts as declared, and loses
+ * to bindings.json and to the plan `-o` writes over (the same rules as
+ * `Bindings.withFallback`). A row `serialize` minted offline is a placeholder for
+ * its label, not a key, so it answers nothing.
+ *
+ * A `Bindings` comes back as a new `Bindings`. Any other {@link BindingsView}
+ * (an SDK caller's own, or a `Bindings` from a second copy of the package) is
+ * wrapped, so the preserved rows answer there too instead of being dropped.
+ *
+ * @param bindings - The registry the caller loaded, if any.
+ * @param payload - The source's preservation payload, if any.
+ * @returns A registry with the preserved rows, or `bindings` unchanged when
+ *   there are none.
+ */
+export declare function preservedBindings(bindings: Bindings | undefined, payload: CaseJsonPreservation | undefined): Bindings | undefined;
+export declare function preservedBindings(bindings: BindingsView | undefined, payload: CaseJsonPreservation | undefined): BindingsView | undefined;
 /** @internal Validate that preservation cannot impersonate typed authoring. */
 export declare function caseJsonPreservationErrors(payload: CaseJsonPreservation | undefined): string[];
 export {};

package/dist/case/preserve.js

@@ -1,4 +1,6 @@
 import { stableId } from '../core/stable-id.js';
+import { Bindings } from '../core/bindings.js';
+import { offlineBindingLabel } from './ids.js';
 /**
  * A preserved `inputs[]` / `outputs[]` slot id copied verbatim from its name is
  * the STRICT_FORMAL_ARG_ID defect, not an identity to keep; the minted id stands.
@@ -36,6 +38,30 @@ export function preserveCaseJson(built, payload) {
 export function caseJsonPreservation(built) {
     return preserved.get(built);
 }
+export function preservedBindings(bindings, payload) {
+    const rows = payload?.bindings;
+    if (!Array.isArray(rows) || rows.length === 0)
+        return bindings;
+    const minted = (row) => offlineBindingLabel(row) !== undefined;
+    if (bindings === undefined || bindings instanceof Bindings)
+        return (bindings ?? new Bindings()).withFallbackRows(rows, minted);
+    return withPreservedRows(bindings, new Bindings().withFallbackRows(rows, minted));
+}
+/**
+ * `view` with `extra`'s fallback rows behind it: `view` answers first, and a
+ * label only `extra` answers is a fallback label (`fromFallback`), exactly as
+ * `Bindings` treats its own fallback rows.
+ */
+function withPreservedRows(view, extra) {
+    const primary = (name) => view.resolve(name) !== undefined || view.entry?.(name) !== undefined
+        || (name !== undefined && (view.declared?.() ?? []).includes(name));
+    return {
+        resolve: (name) => view.resolve(name) ?? (primary(name) ? undefined : extra.resolve(name)),
+        ...(view.declared ? { declared: () => view.declared() } : {}),
+        entry: (name) => view.entry?.(name) ?? (primary(name) ? undefined : extra.entry(name)),
+        fromFallback: (name) => view.fromFallback?.(name) === true || (!primary(name) && extra.fromFallback(name)),
+    };
+}
 const TOP_LEVEL_KEYS = new Set([
     'id', 'name', 'description', 'version', 'bindings', 'variables', 'metadata', 'nodes', 'edges', 'layout',
 ]);
@@ -123,6 +149,21 @@ export function caseJsonPreservationErrors(payload) {
             else if (TASK_KEYS.has(field))
                 errors.push(`task "${entry.task}" field "${field}" is owned by the typed Case serializer`);
     }
+    if (payload.bindings !== undefined) {
+        if (!Array.isArray(payload.bindings))
+            errors.push('preserved "bindings" must be an array of root binding rows');
+        else
+            payload.bindings.forEach((row, index) => {
+                const r = row;
+                const key = r && typeof r === 'object' ? r.resourceKey ?? r.default : undefined;
+                if (!r || typeof r !== 'object' || typeof r.id !== 'string' || r.id === '')
+                    errors.push(`preserved binding row ${index + 1} has no string id`);
+                else if (r.resource !== 'Connection')
+                    errors.push(`preserved binding row "${r.id}" is not a Connection row (only connection and folder rows are preserved)`);
+                else if (typeof key !== 'string' || key === '' || key === r.id)
+                    errors.push(`preserved binding row "${r.id}" carries no resource key other than its own id`);
+            });
+    }
     for (const [index, fields] of (payload.triggerDataFields ?? []).entries())
         for (const field of Object.keys(fields))
             if (!PRESERVED_TRIGGER_DATA_KEYS.has(field))

package/dist/case/serialize.js

@@ -25,7 +25,7 @@ import { isResourceLabelRefusal, resolveResourceRef, resourceIdentity } from './
 import { ownEntry } from '../core/own-entry.js';
 import { stableId } from '../core/stable-id.js';
 import { resolveSchemaVersion } from '../schema-version.js';
-import { caseJsonPreservation, caseJsonPreservationErrors, } from './preserve.js';
+import { caseJsonPreservation, caseJsonPreservationErrors, preservedBindings, } from './preserve.js';
 import { businessEventProblems } from './business-event-shape.js';
 import { readEventFilterLeaf, eventFilterTreeLeaf } from '../core/event-filters.js';
 import { responseJsonSchema } from '../core/connector-response-schema.js';
@@ -101,7 +101,9 @@ export function serialize(built, opts = {}) {
         stageIdByLabel: new Map(),
         taskIdByKey: new Map(),
         library: opts.library,
-        bindings: opts.bindings,
+        // A decompiled source carries its plan's connection rows: they answer the
+        // binding-id labels decompile wrote (`connection: "bOC1"`).
+        bindings: preservedBindings(opts.bindings, caseJsonPreservation(built)),
         bindingSink: new Map(),
         ids,
         offlineBindingIds: new Map(),
@@ -1875,7 +1877,7 @@ function bindingRef(resolver, name, resource, propertyAttribute, displayName, si
     const refused = bindingLabelRefusal(resolver.bindings, name, site.attribute, site.where, site.target);
     if (refused)
         throw refused;
-    const entry = resolver.bindings?.entry(name);
+    const entry = resolver.bindings?.entry?.(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.
@@ -1912,7 +1914,7 @@ function folderBindingRef(resolver, name, connection, site) {
     const refused = bindingLabelRefusal(resolver.bindings, name, site.attribute, site.where, site.target);
     if (refused)
         throw refused;
-    const entry = resolver.bindings?.entry(name);
+    const entry = resolver.bindings?.entry?.(name);
     const baseId = entry
         ? String(entry.id ?? name)
         : offlineBindingId(resolver, offlineBindingSeed('Connection', 'folderKey', name, connection.resourceKey));

package/dist/core/bindings.d.ts

@@ -26,6 +26,18 @@ export declare class Bindings {
      * @returns This registry, for chaining.
      */
     withFallback(file?: string, isPlaceholder?: (row: Record<string, unknown>) => boolean): this;
+    /**
+     * A NEW registry: this one's entries and fallback rows, plus `rows` as more
+     * fallback rows (same rules as {@link withFallback}; a row whose `id` is
+     * already a fallback row is skipped, so earlier fallbacks win). This registry
+     * is not changed, so a caller's `Bindings` can be shared across compiles.
+     *
+     * @param rows - Root binding rows, e.g. the ones a decompiled Case source carries.
+     * @param isPlaceholder - As for {@link withFallback}.
+     * @returns The new registry.
+     */
+    withFallbackRows(rows: readonly unknown[], isPlaceholder?: (row: Record<string, unknown>) => boolean): Bindings;
+    private addFallbackRows;
     private primary;
     /**
      * The fallback row whose `id` is `name`. A row whose key is its own id

package/dist/core/bindings.js

@@ -44,11 +44,33 @@ export class Bindings {
         catch {
             return this; // a fallback is optional; an unreadable one adds nothing
         }
+        this.addFallbackRows(normalizeBindings(parsed), isPlaceholder);
+        return this;
+    }
+    /**
+     * A NEW registry: this one's entries and fallback rows, plus `rows` as more
+     * fallback rows (same rules as {@link withFallback}; a row whose `id` is
+     * already a fallback row is skipped, so earlier fallbacks win). This registry
+     * is not changed, so a caller's `Bindings` can be shared across compiles.
+     *
+     * @param rows - Root binding rows, e.g. the ones a decompiled Case source carries.
+     * @param isPlaceholder - As for {@link withFallback}.
+     * @returns The new registry.
+     */
+    withFallbackRows(rows, isPlaceholder) {
+        const copy = new Bindings();
+        copy.list = this.list;
+        copy.fallback = [...this.fallback];
+        copy.addFallbackRows(rows, isPlaceholder);
+        return copy;
+    }
+    addFallbackRows(rows, isPlaceholder) {
         const ids = new Set(this.fallback.map((x) => x?.id));
-        for (const entry of normalizeBindings(parsed))
-            if (typeof entry?.id === 'string' && !ids.has(entry.id) && !isPlaceholder?.(entry))
+        for (const entry of rows)
+            if (typeof entry?.id === 'string' && !ids.has(entry.id) && !isPlaceholder?.(entry)) {
                 this.fallback.push(entry);
-        return this;
+                ids.add(entry.id);
+            }
     }
     primary(name) {
         return this.list.find((x) => x.name === name || x.id === name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.68.2",
+  "version": "6.68.3",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -100,5 +100,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "169cc7e0b99153458305df193dd0336b44955b84"
+  "gitref": "7f50084300a8c68552127c4e1ab51a3cb56a5869"
 }