@uipath/maestro-builder-sdk 6.50.0 → 6.50.1

package/dist/case/check-cli.js

@@ -3,7 +3,8 @@
  * check-cli — fast static validation of <Name>.case.ts (no output file).
  *
  * Usage: node --experimental-strip-types check-cli.js <case.ts | BaseName> \
- *     [--library <library-json dir>] [--connectors-local <overlay dir>] [--bindings <bindings.json>]
+ *     [--library <library-json dir>] [--connectors-local <overlay dir>] [--bindings <bindings.json>] \
+ *     [-o <the plan compile writes>]
  * Exits 0 when clean (warnings allowed), 1 on any error.
  *
  * The library is opened exactly as `compile-cli` opens it (`openCliLibrary`), so
@@ -14,19 +15,18 @@ import { resolveCaseFile, loadBuiltCase } from './load.js';
 import { check } from './check.js';
 import { caseCheckOpts } from './cli-library.js';
 import { openCliLibrary } from '../core/cli-library.js';
-import { Bindings } from '../core/bindings.js';
-import { defaultBindingsFile } from '../workdir.js';
-import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';
+import { caseCompileTarget } from './compile-cli.js';
+import { runWhenInvokedDirectly } from '../cli-run.js';
 import { ensureTypeScriptRuntime } from '../node-runtime.js';
 /** Flags that take a value: their argument is never the source positional. */
-const VALUE_FLAGS = new Set(['--library', '--connectors-local', '--bindings']);
-const USAGE = 'usage: check <case.ts | BaseName> [--library <dir>] [--connectors-local <dir>] [--bindings <file>]';
+const VALUE_FLAGS = new Set(['--library', '--connectors-local', '--bindings', '-o']);
+const USAGE = 'usage: check <case.ts | BaseName> [--library <dir>] [--connectors-local <dir>] [--bindings <file>] [-o <plan>]';
 export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
         console.error(USAGE);
         return 2;
     }
-    const input = argv.find((a, i) => !a.startsWith('--') && !VALUE_FLAGS.has(argv[i - 1]));
+    const input = argv.find((a, i) => !a.startsWith('-') && !VALUE_FLAGS.has(argv[i - 1]));
     if (input === undefined) {
         console.error(USAGE);
         return 2;
@@ -34,8 +34,9 @@ export async function run(argv) {
     const file = resolveCaseFile(input);
     ensureTypeScriptRuntime();
     const built = await loadBuiltCase(file);
-    // bindings.json as `case compile` reads it, for the binding-label rules (#1034).
-    const bindings = new Bindings(flagValue(argv, '--bindings') ?? defaultBindingsFile());
+    // The bindings `case compile` reads, plan fallback included, for the
+    // binding-label rules (#1034): `-o` names the plan as it does for compile.
+    const { bindings } = caseCompileTarget(argv);
     const diags = check(built, caseCheckOpts(openCliLibrary(argv), bindings));
     reportDiagnostics(diags);
     for (const d of diags)

package/dist/case/compile-cli.d.ts

@@ -1,6 +1,27 @@
 #!/usr/bin/env node
+import { Bindings } from '../core/bindings.js';
 import { type CliExitCode } from '../cli-run.js';
 export declare function run(argv: string[]): Promise<CliExitCode>;
+/**
+ * The plan file `case compile` writes, and the bindings it resolves connection
+ * and folder labels against. `case check` reads the same pair, so the two agree
+ * on which labels are declared.
+ *
+ * The plan is `-o`, else the plan file the project in the working directory
+ * ships, else `caseplan.json`. The bindings are `--bindings` (default: the
+ * project's bindings.json), with that plan's own root bindings as a fallback
+ * when it exists. Recompiling into an existing plan (the brownfield loop:
+ * decompile, edit, compile back over the same file) then resolves the binding
+ * ids decompile names a connector's connection and folder by
+ * (`connection: "bOC1"`).
+ *
+ * @param argv - The command's arguments.
+ * @returns The output path and the bindings registry.
+ */
+export declare function caseCompileTarget(argv: string[]): {
+    out: string;
+    bindings: Bindings;
+};
 /**
  * Write the entry point's id onto its trigger, as `data.inputs.entryPointId`.
  *

package/dist/case/compile-cli.js

@@ -23,6 +23,7 @@ import { check } from './check.js';
 import { caseCheckOpts } from './cli-library.js';
 import { entryPointIO } from './entry-points.js';
 import { Bindings } from '../core/bindings.js';
+import { offlineBindingLabel } from './ids.js';
 import { openCliLibrary } from '../core/cli-library.js';
 import { defaultBindingsFile } from '../workdir.js';
 import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';
@@ -54,8 +55,7 @@ export async function run(argv) {
     // which is what the three copies of these lines used to each decide for itself.
     // Opened BEFORE the check pass, which reads the same library (#1014).
     const library = openCliLibrary(argv);
-    const bindFile = flagValue(argv, '--bindings') ?? defaultBindingsFile();
-    const bindings = new Bindings(bindFile);
+    const { out, bindings } = caseCompileTarget(argv);
     const diags = check(built, caseCheckOpts(library, bindings));
     for (const d of diags)
         console.error(`  ${d.level === 'error' ? '✗' : '⚠'} [${d.code}] ${d.message}`);
@@ -66,7 +66,6 @@ export async function run(argv) {
         console.error(`compile: ${errors.length} error(s); not emitting.`);
         return 1;
     }
-    const out = flagValue(argv, '-o') ?? shippedCasePlanName('.') ?? 'caseplan.json';
     const shadow = shadowedOutputDiagnostic(out);
     if (shadow) {
         console.error(`  ✗ [${shadow.code}] ${shadow.message} Fix: ${shadow.suggestion}.`);
@@ -94,6 +93,30 @@ export async function run(argv) {
     reportResult({ path: resolve(out), stages, ...(triggers >= 0 ? { triggers } : {}), ...(resources >= 0 ? { resources } : {}) });
     return 0;
 }
+/**
+ * The plan file `case compile` writes, and the bindings it resolves connection
+ * and folder labels against. `case check` reads the same pair, so the two agree
+ * on which labels are declared.
+ *
+ * The plan is `-o`, else the plan file the project in the working directory
+ * ships, else `caseplan.json`. The bindings are `--bindings` (default: the
+ * project's bindings.json), with that plan's own root bindings as a fallback
+ * when it exists. Recompiling into an existing plan (the brownfield loop:
+ * decompile, edit, compile back over the same file) then resolves the binding
+ * ids decompile names a connector's connection and folder by
+ * (`connection: "bOC1"`).
+ *
+ * @param argv - The command's arguments.
+ * @returns The output path and the bindings registry.
+ */
+export function caseCompileTarget(argv) {
+    const out = flagValue(argv, '-o') ?? shippedCasePlanName('.') ?? 'caseplan.json';
+    const bindFile = flagValue(argv, '--bindings') ?? defaultBindingsFile();
+    // A row serialize minted offline (`{ id: 'b…', resourceKey: 'drive' }`) is a
+    // placeholder for the label `drive`, not a binding: it must not answer.
+    const minted = (row) => offlineBindingLabel(row) !== undefined;
+    return { out, bindings: new Bindings(bindFile).withFallback(existsSync(out) ? out : undefined, minted) };
+}
 /**
  * The file names a Case project's plan can have, in the order the packager
  * (`@uipath/packager-tool-case` `CasePlanFileNames`) picks the first one present.

package/dist/core/binding-messages.d.ts

@@ -27,6 +27,8 @@ export interface BindingsView {
     resolve(name?: string): string | undefined;
     declared?(): string[];
     entry?(name?: string): unknown;
+    /** True when only a recompile fallback row (the plan's own bindings) answers `name`. */
+    fromFallback?(name?: string): boolean;
 }
 export declare function bindingSelfNameMessage(where: string, name: string, attribute: 'connection' | 'folder', target?: PrepareTarget): string;
 /**

package/dist/core/binding-messages.js

@@ -81,6 +81,11 @@ export function undeclaredBinding(bindings, name) {
 export function bindingLabelRefusal(bindings, name, attribute, where, target) {
     if (!bindings)
         return undefined;
+    // A label that is exactly a row id of the plan being recompiled (what
+    // decompile emits) reuses that row. Those rows are not an author's
+    // bindings.json, so neither rule applies to them.
+    if (bindings.fromFallback?.(name))
+        return undefined;
     const resolved = bindings.resolve(name);
     if (resolved === name)
         return new BindingRefusal('BINDING_SELF_NAME', bindingSelfNameMessage(where, name, attribute, target));

package/dist/core/bindings.d.ts

@@ -1,11 +1,50 @@
 export declare class Bindings {
     private list;
+    /**
+     * Rows from {@link withFallback}: the root `bindings[]` of the plan being
+     * recompiled. Kept apart from `list` on purpose. They are not an author's
+     * bindings.json, so they never count as declared names and never feed the
+     * self-name / undeclared label rules. An offline plan's own rows are
+     * `{ id: 'slack', resourceKey: 'slack' }`; counted as declared they made the
+     * second offline compile refuse the connector's own label (BINDING_SELF_NAME).
+     */
+    private fallback;
     constructor(file?: string);
-    /** Resolve by binding `name` or `id`; returns its resourceKey (or default). */
+    /**
+     * Add the root bindings of another document (the plan being recompiled) as a
+     * fallback. A fallback row answers only a label that is exactly its `id`
+     * (what decompile emits), whose key is not that same id (a placeholder; see
+     * `fallbackRow`), and that the primary registry does not answer. It
+     * is never part of {@link declared}, and {@link fromFallback} lets the label
+     * rules skip it.
+     *
+     * @param file - A bindings.json, or any document with a root `bindings[]`
+     *   (a caseplan); a missing or unreadable file adds nothing.
+     * @param isPlaceholder - Recognises a row the document's own compiler minted
+     *   offline (a label with no real key behind it, under a minted id). Such a
+     *   row answers nothing, like a row whose key is its own id.
+     * @returns This registry, for chaining.
+     */
+    withFallback(file?: string, isPlaceholder?: (row: Record<string, unknown>) => boolean): this;
+    private primary;
+    /**
+     * The fallback row whose `id` is `name`. A row whose key is its own id
+     * (`{ id: 'drive', resourceKey: 'drive' }`, what an offline compile writes) is
+     * a placeholder, not an answer, so it is skipped: the label rules then judge
+     * `drive` against the author's bindings.json as they would without a fallback.
+     */
+    private fallbackRow;
+    /**
+     * True when only a fallback row answers `name`: the primary registry does not,
+     * and a fallback row's `id` is exactly `name`. The label rules
+     * (`bindingLabelRefusal`) accept such a label as is.
+     */
+    fromFallback(name?: string): boolean;
+    /** Resolve by binding `name` or `id` (fallback rows: `id` only); returns its resourceKey (or default). */
     resolve(name?: string): string | undefined;
-    /** Every symbolic name the file declares — what an author CAN write in `connection:` / `folder:`. */
+    /** Every symbolic name the bindings.json declares — what an author CAN write in `connection:` / `folder:`. Fallback rows are not included. */
     declared(): string[];
-    /** The full binding entry by `name` or `id` — for consumers that emit a binding
+    /** The full binding entry by `name` or `id` (fallback rows: `id` only) — for consumers that emit a binding
      * registry + `=bindings.<id>` refs (the Case caseplan) rather than inlining the
      * resourceKey (the Flow node). */
     entry(name?: string): Record<string, unknown> | undefined;

package/dist/core/bindings.js

@@ -5,21 +5,83 @@
 import { readFileSync, existsSync } from 'node:fs';
 export class Bindings {
     list = [];
+    /**
+     * Rows from {@link withFallback}: the root `bindings[]` of the plan being
+     * recompiled. Kept apart from `list` on purpose. They are not an author's
+     * bindings.json, so they never count as declared names and never feed the
+     * self-name / undeclared label rules. An offline plan's own rows are
+     * `{ id: 'slack', resourceKey: 'slack' }`; counted as declared they made the
+     * second offline compile refuse the connector's own label (BINDING_SELF_NAME).
+     */
+    fallback = [];
     constructor(file) {
         if (file && existsSync(file)) {
             this.list = normalizeBindings(JSON.parse(readFileSync(file, 'utf8')));
         }
     }
-    /** Resolve by binding `name` or `id`; returns its resourceKey (or default). */
+    /**
+     * Add the root bindings of another document (the plan being recompiled) as a
+     * fallback. A fallback row answers only a label that is exactly its `id`
+     * (what decompile emits), whose key is not that same id (a placeholder; see
+     * `fallbackRow`), and that the primary registry does not answer. It
+     * is never part of {@link declared}, and {@link fromFallback} lets the label
+     * rules skip it.
+     *
+     * @param file - A bindings.json, or any document with a root `bindings[]`
+     *   (a caseplan); a missing or unreadable file adds nothing.
+     * @param isPlaceholder - Recognises a row the document's own compiler minted
+     *   offline (a label with no real key behind it, under a minted id). Such a
+     *   row answers nothing, like a row whose key is its own id.
+     * @returns This registry, for chaining.
+     */
+    withFallback(file, isPlaceholder) {
+        if (!file || !existsSync(file))
+            return this;
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(file, 'utf8'));
+        }
+        catch {
+            return this; // a fallback is optional; an unreadable one adds nothing
+        }
+        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))
+                this.fallback.push(entry);
+        return this;
+    }
+    primary(name) {
+        return this.list.find((x) => x.name === name || x.id === name);
+    }
+    /**
+     * The fallback row whose `id` is `name`. A row whose key is its own id
+     * (`{ id: 'drive', resourceKey: 'drive' }`, what an offline compile writes) is
+     * a placeholder, not an answer, so it is skipped: the label rules then judge
+     * `drive` against the author's bindings.json as they would without a fallback.
+     */
+    fallbackRow(name) {
+        return this.fallback.find((x) => x.id === name && (x.resourceKey ?? x.default) !== name);
+    }
+    /**
+     * True when only a fallback row answers `name`: the primary registry does not,
+     * and a fallback row's `id` is exactly `name`. The label rules
+     * (`bindingLabelRefusal`) accept such a label as is.
+     */
+    fromFallback(name) {
+        if (!name)
+            return false;
+        return this.primary(name) === undefined && this.fallbackRow(name) !== undefined;
+    }
+    /** Resolve by binding `name` or `id` (fallback rows: `id` only); returns its resourceKey (or default). */
     resolve(name) {
         if (!name)
             return undefined;
-        const b = this.list.find((x) => x.name === name || x.id === name);
+        const b = this.primary(name) ?? this.fallbackRow(name);
         if (!b)
             return undefined;
         return (b.resourceKey ?? b.default);
     }
-    /** Every symbolic name the file declares — what an author CAN write in `connection:` / `folder:`. */
+    /** Every symbolic name the bindings.json declares — what an author CAN write in `connection:` / `folder:`. Fallback rows are not included. */
     declared() {
         const names = [];
         for (const b of this.list) {
@@ -29,13 +91,13 @@ export class Bindings {
         }
         return names;
     }
-    /** The full binding entry by `name` or `id` — for consumers that emit a binding
+    /** The full binding entry by `name` or `id` (fallback rows: `id` only) — for consumers that emit a binding
      * registry + `=bindings.<id>` refs (the Case caseplan) rather than inlining the
      * resourceKey (the Flow node). */
     entry(name) {
         if (!name)
             return undefined;
-        return this.list.find((x) => x.name === name || x.id === name);
+        return (this.primary(name) ?? this.fallbackRow(name));
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.50.0",
+  "version": "6.50.1",
   "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": "d674fc1a9ed1b8aa61dcc0b30a95a434503eb61b"
+  "gitref": "3b0f8b3f6e84465828936a6242656c563947c74d"
 }