@uipath/maestro-builder-sdk 6.50.0 → 6.50.2

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/case/decompile.js

@@ -914,7 +914,10 @@ function producedVariableNames(plan) {
             continue;
         for (const lane of node.data?.tasks ?? [])
             for (const task of lane) {
-                if (ownEntry(TASK_KIND_METHOD, task.type)) {
+                if (ownEntry(TASK_KIND_METHOD, task.type) || task.type === 'action') {
+                    // An action form output (`{ name, value }`) produces its variable as a
+                    // reference-task output does, so an older plan's root companion for it
+                    // is not re-declared as a `.var()` (the recompile writes none).
                     for (const row of task.data?.outputs ?? [])
                         if (row.var)
                             produced.add(row.var);

package/dist/case/serialize.js

@@ -86,6 +86,7 @@ export function serialize(built, opts = {}) {
         ids,
         offlineBindingIds: new Map(),
         varCompanions: new Map(),
+        ownNameRows: new Map(),
         outputIds: new Set(),
         ownOutputVars: ownOutputVars(built),
         slaId: new Map(),
@@ -230,14 +231,26 @@ export function serialize(built, opts = {}) {
             throw new Error(problem.message);
         metadata.businessEvents = built.businessEvents.map(emitBusinessEvent);
     }
-    // Variables: declared vars + the readable companions that task outputs bound
-    // (collected during stage emission above). A declared var wins on a name clash.
+    // Variables: declared vars + the readable companions that REASSIGNED task
+    // outputs bound (collected during stage emission above). A declared var wins
+    // on a name clash. An own-name output (`id == var`) writes no root entry: like
+    // the Designer, the output row is itself the variable `=vars.<id>` reads.
     const variables = emitVariables(built.vars, ids, triggerNodeByRef);
     const inputOutputs = variables.inputOutputs;
     const declared = new Set(inputOutputs.map((e) => e.id));
     for (const [name, companion] of resolver.varCompanions)
         if (!declared.has(name))
             inputOutputs.push(companion);
+    // An own-name row that writes a variable which DOES have a root entry (a
+    // declared `.var()`, or a companion another, reassigned, writer needed) is the
+    // v1 skill's "controlled alias": `originalVar == id` tells the Designer the row
+    // feeds that existing variable, so it keeps the root entry instead of minting
+    // a second variable under the same name.
+    const rootIds = new Set(inputOutputs.map((e) => e.id));
+    for (const [name, rows] of resolver.ownNameRows)
+        if (rootIds.has(name))
+            for (const row of rows)
+                row.originalVar = row.id;
     const result = {
         id: caseId,
         name: built.name,
@@ -1164,7 +1177,11 @@ function emitActionField(f, outputElementId, resolver) {
         row.source = `=${f.name}`;
         row.target = `=${id}`;
         row.elementId = outputElementId;
-        if (resolver && !resolver.varCompanions.has(f.value)) {
+        // `id == value`: the row is the variable (the Designer writes no root entry
+        // for it). Only a suffixed, reassigned row needs the readable companion.
+        if (resolver && id === f.value)
+            addOwnNameRow(resolver, f.value, row);
+        else if (resolver && !resolver.varCompanions.has(f.value)) {
             resolver.varCompanions.set(f.value, {
                 id: f.value,
                 name: f.value,
@@ -1209,18 +1226,24 @@ const OWN_NAME_OUTPUT_ROWS = new WeakSet();
 function emitTaskOutput(o, elementId, ids, seed, resolver) {
     const path = o.source.replace(/^=/, '');
     const field = path.split('.').pop() || o.source;
-    // Register the readable companion once (declared vars take precedence in the merge).
-    if (!resolver.varCompanions.has(o.var))
-        resolver.varCompanions.set(o.var, { id: o.var, name: o.var, type: o.type, elementId: 'root', custom: true });
+    // A reassigned row registers the readable companion once (declared vars take
+    // precedence in the merge); an own-name row is the variable and registers none.
+    const companion = () => {
+        if (!resolver.varCompanions.has(o.var))
+            resolver.varCompanions.set(o.var, { id: o.var, name: o.var, type: o.type, elementId: 'root', custom: true });
+    };
     if (isOwnNameOutput(o)) {
         const id = claimOutputId(resolver, o.var);
         if (id === o.var) {
             const row = { name: field, type: o.type, id, var: o.var, value: o.var, source: o.source, target: `=${id}`, elementId };
             OWN_NAME_OUTPUT_ROWS.add(row);
+            addOwnNameRow(resolver, o.var, row);
             return row;
         }
+        companion();
         return { name: field, type: o.type, id, var: o.var, originalVar: id, value: o.var, source: o.source, target: `=${id}`, elementId };
     }
+    companion();
     const slot = claimOutputId(resolver, ids.make('o', 8, seed));
     return {
         name: field,
@@ -1600,6 +1623,14 @@ function connectorMetadata(rc, op, executionType) {
 function connectorOutputVar(resolver, base) {
     return claimOutputId(resolver, base);
 }
+/** Record an own-name row (`id == var`), the variable itself; see the variables merge in `serialize`. */
+function addOwnNameRow(resolver, name, row) {
+    const rows = resolver.ownNameRows.get(name);
+    if (rows)
+        rows.push(row);
+    else
+        resolver.ownNameRows.set(name, [row]);
+}
 /**
  * Claim a task-output row id from the document-wide pool, the Designer's
  * uniqueness rule: the first claimant of `base` gets `base`, later ones get

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.2",
   "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": "a0ed06f0dddc98064867948988de27e22e280501"
 }