@uipath/maestro-builder-sdk 6.15.2 → 6.15.3

package/dist/check.js

@@ -9,9 +9,10 @@ import { Expr, SCHEDULE_PRESETS, DELAY_PRESETS, VARIANT_OPERATION, parseIxpProje
 import { FlowNode } from './core/node-classes.js';
 import { QUEUE_ITEM_RECORD_SCHEMA } from './core/queue-record.js';
 import { checkEventResolution, checkEventSubscription, eventParamsFor, } from './core/event-checks.js';
-import { FLOW_EXPR_DIALECT, checkBindingLabels, checkConnectorContract as coreCheckConnectorContract, checkConnectorLookups as coreCheckConnectorLookups, checkConnectorSchema as coreCheckConnectorSchema, collectConnectionUses, connectionConnectorConflicts, } from './core/connector-checks.js';
+import { FLOW_EXPR_DIALECT, checkBindingLabels, checkBindingPresence, checkConnectorContract as coreCheckConnectorContract, checkConnectorLookups as coreCheckConnectorLookups, checkConnectorSchema as coreCheckConnectorSchema, collectConnectionUses, connectionConnectorConflicts, } from './core/connector-checks.js';
 import { prepareCommand } from './core/cli-spelling.js';
 import { isAnswerField } from './core/hitl-answers.js';
+import { globalNameCollisionMessage, globalNameCollisions } from './core/global-names.js';
 import { hitlDerivesOutcomeHandles, hitlExitModel, hitlRoutesPerOutcome } from './core/hitl-routing.js';
 import { childStepLists, declaredExits, hasExits, stopsAtEnd } from './core/step-ports.js';
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
@@ -36,6 +37,11 @@ function checkFlow(built, ancestors, opts = {}) {
         diags.push({ level: 'error', code: 'NO_ID', message: 'flow() requires an id.' });
     checkSchemaVersion(built, ancestors, diags);
     checkNodeUpdates(built, diags);
+    // Inputs, outputs and vars are one namespace in the .flow (variables.globals[]);
+    // `serialize` throws the same sentence (flow-builder-sdk#890).
+    for (const collision of globalNameCollisions(built.inputs ?? [], built.outputs ?? [], built.vars ?? [])) {
+        diags.push({ level: 'error', code: 'VARIABLE_NAME_COLLISION', message: globalNameCollisionMessage(collision) });
+    }
     const maybeCustomTrigger = built.trigger;
     if (maybeCustomTrigger !== undefined && !('kind' in maybeCustomTrigger) && maybeCustomTrigger instanceof FlowNode) {
         // A custom FlowTrigger subclass reports through its own diagnostics() hook;
@@ -543,6 +549,7 @@ function checkFlow(built, ancestors, opts = {}) {
                     checkEventSubscription(s.spec.subscription, `waitForEvent "${stepName}"`, push('error'), push('warning'), eventParamsFor(s.spec.subscription, opts));
                     checkEventResolution(s.spec.subscription, `waitForEvent "${stepName}"`, 'event', opts, push('error'), push('warning'), eventParamsFor(s.spec.subscription, opts));
                     checkBindingLabels(`waitForEvent "${stepName}"`, s.spec.subscription, opts, push('error'), eventTarget(s.spec.subscription), { id: stepName, connector: eventTarget(s.spec.subscription)?.key });
+                    checkBindingPresence(`waitForEvent "${stepName}"`, s.spec.subscription, push('error'), eventTarget(s.spec.subscription));
                 }
                 if (s.spec.kind === 'subflow') {
                     // Only a real child goes in the map: a missing one is reported by
@@ -848,7 +855,7 @@ function checkFlow(built, ancestors, opts = {}) {
             }
         }
         else {
-            checkTrigger(ep.trigger, diags, opts);
+            checkTrigger(ep.trigger, diags, opts, `onEvent() entry point "${ep.id}"`);
         }
         for (const inp of ep.inputs) {
             const collides = built.inputs.some((g) => g.name === inp.name)
@@ -1257,9 +1264,15 @@ function checkConnectorSchema(step, spec, opts, diags) {
     const { where, report } = connectorSite(step, diags);
     coreCheckConnectorSchema(where, spec, opts, FLOW_EXPR_DIALECT, report);
 }
+/**
+ * The core contract (fields with a library, names with a bindings.json), plus
+ * BINDING_MISSING, which needs neither: an absent label is wrong whatever the
+ * file says.
+ */
 function checkConnectorContract(step, spec, opts, diags) {
     const { where, report } = connectorSite(step, diags);
     coreCheckConnectorContract(where, spec, opts, report, step);
+    checkBindingPresence(`connector "${step}"`, spec, (code, message) => report({ level: 'error', code, message }), { key: spec.key, action: spec.action });
 }
 /** Reject a wrapper hop when the runtime shape of a list has been measured. */
 function checkLoopListEnvelope(loop, connectors, opts, diags) {
@@ -1647,7 +1660,7 @@ function checkNodeUpdates(built, diags) {
     };
     visit(built.steps);
 }
-function checkTrigger(spec, diags, opts = {}) {
+function checkTrigger(spec, diags, opts = {}, where) {
     const push = (level) => (code, message, suggestion) => {
         diags.push({ level, code, message, step: 'trigger', ...(suggestion ? { suggestion } : {}) });
     };
@@ -1659,6 +1672,7 @@ function checkTrigger(spec, diags, opts = {}) {
         checkEventSubscription(sub, 'trigger', at, push('warning'), eventParamsFor(sub, opts));
         checkEventResolution(sub, 'trigger', 'trigger', opts, at, push('warning'), eventParamsFor(sub, opts));
         checkBindingLabels('event trigger', sub, opts, at, eventTarget(sub), { id: 'trigger', connector: eventTarget(sub)?.key });
+        checkBindingPresence(where ?? 'event trigger', sub, at, eventTarget(sub));
         return;
     }
     // manual() is the explicit spelling of the default — nothing to validate.
@@ -1675,7 +1689,7 @@ function checkTrigger(spec, diags, opts = {}) {
     if (spec?.kind !== 'scheduled') {
         at('TRIGGER_UNKNOWN_KIND', `.trigger() was given ${JSON.stringify(spec?.kind)}, which is not a trigger. `
             + `Wrap it in a factory: scheduled({ every: 'R/PT1H' }) for a schedule, `
-            + `onEvent({ connector, event, where }) to start on a connector event, formTrigger() to start from a `
+            + `onEvent({ connector, event, where, connection, folder }) to start on a connector event, formTrigger() to start from a `
             + `submitted form, or conversationTrigger() to start on a new conversation. Omit .trigger() entirely `
             + `for the manual trigger (the default).`, `scheduled({ every: 'R/PT1H' })`);
         return;

package/dist/core/actions.d.ts

@@ -187,9 +187,12 @@ export interface ScriptInputs {
 export interface ConnectorOpts {
     /** Connector action version (defaults to the library's newest match). */
     version?: string;
-    /** Symbolic connection name declared in bindings.json (→ ConnectionId). */
+    /**
+     * Symbolic connection name declared in bindings.json (→ ConnectionId). Required with
+     * `folder`: `check` refuses a connector step without both (BINDING_MISSING).
+     */
     connection?: string;
-    /** Symbolic folder name declared in bindings.json (→ connectionFolderKey). */
+    /** Symbolic folder name declared in bindings.json (→ connectionFolderKey). Required with `connection`. */
     folder?: string;
     /**
      * Which OBJECT a **generic** operation addresses — e.g. ServiceNow's "List All
@@ -1593,7 +1596,8 @@ export interface InlineAgentInputs {
      * ```ts
      * tools: [
      *   { kind: 'builtin', tool: 'summarize' },
-     *   { kind: 'connector', connector: 'uipath-atlassian-jira', operation: 'create-issue' },
+     *   { kind: 'connector', connector: 'uipath-atlassian-jira', operation: 'create-issue',
+     *     connection: 'jira', folder: 'shared' },   // bindings.json labels, both required
      *   { kind: 'process', key: '6235d64e-b190-4b7a-8918-723df964c068',
      *     name: 'Create TestCase', folderPath: 'Shared',
      *     inputs: { title: 'string' }, returns: { id: 'string' } },
@@ -3420,9 +3424,12 @@ export interface TriggerOptions<W = Record<string, string>> {
     object?: string;
     /** Optional filters on the payload. Omit to take every event in scope. */
     filters?: EventFilter[];
-    /** bindings.json id for the connection (defaults to the flow's single binding). */
+    /**
+     * bindings.json id for the connection. Required with `folder`: `check` refuses an event
+     * node without both (BINDING_MISSING) — it would compile to `connectionId: null`.
+     */
     connection?: string;
-    /** bindings.json id for the folder key. */
+    /** bindings.json id for the folder key. Required with `connection` (BINDING_MISSING). */
     folder?: string;
     /** Override the descriptor's version. */
     version?: string;
@@ -3460,9 +3467,12 @@ export interface EventSubscription {
     object?: string;
     /** Optional filters on the payload. Omit to take every event in scope. */
     filters?: EventFilter[];
-    /** bindings.json id for the connection (defaults to the flow's single binding). */
+    /**
+     * bindings.json id for the connection. Required with `folder`: `check` refuses an event
+     * node without both (BINDING_MISSING) — it would compile to `connectionId: null`.
+     */
     connection?: string;
-    /** bindings.json id for the folder key. */
+    /** bindings.json id for the folder key. Required with `connection` (BINDING_MISSING). */
     folder?: string;
     version?: string;
 }
@@ -3493,6 +3503,7 @@ export declare function subscriptionFrom<W>(a: EventSubscription | TriggerDescri
  *   event: 'email-received',
  *   where: { parentFolderId: inboxId },
  *   filters: [{ field: 'subject', contains: 'TestWaitFor' }],
+ *   connection: 'outlook', folder: 'shared',   // bindings.json labels, both required
  * }))
  * ```
  *

package/dist/core/actions.js

@@ -1090,8 +1090,9 @@ export function connector(a, b, c, d) {
 export function subscriptionFrom(a, opts) {
     if (!isTriggerDescriptor(a))
         return a;
-    // No options at all is legal: an operation with no event parameters (HTTP
-    // Webhook) has nothing to put in them, and the descriptor carries the version.
+    // No `where` is legal: an operation with no event parameters (HTTP Webhook)
+    // has nothing to put in it, and the descriptor carries the version. The
+    // `connection` / `folder` labels are still required (BINDING_MISSING).
     return {
         connector: a.connector,
         event: a.event,

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

@@ -5,7 +5,9 @@ export type BindingRefusalCode = 'BINDING_SELF_NAME' | 'BINDING_UNDECLARED'
 /** An emitted definition's `<bindings.NAME>` placeholder has no `bindings[]` entry named NAME (#865). */
  | 'BINDING_PLACEHOLDER_UNRESOLVED'
 /** Two steps on one connection disagree on which connector it belongs to (#866). */
- | 'CONNECTION_CONNECTOR_CONFLICT';
+ | 'CONNECTION_CONNECTOR_CONFLICT'
+/** A connector-bound node names no `connection` or no `folder` label (#890). */
+ | 'BINDING_MISSING';
 /**
  * What `serialize` throws for a label it refuses. It is an ordinary `Error` whose
  * message is the sentence `check` prints; the `code` lets `compile --no-check`
@@ -73,3 +75,22 @@ export declare function bindingUndeclaredMessage(where: string, name: string, at
  * (flow-builder-sdk#866).
  */
 export declare function connectionConnectorConflictMessage(connection: string, users: ReadonlyMap<string, readonly string[]>): string;
+/**
+ * Which of a connector-bound node's two labels the author left out.
+ *
+ * A connector step, an event trigger, an `.entryPoint` onEvent and a
+ * `waitForEvent` all call Integration Service on a tenant connection, so the
+ * node needs BOTH halves: `connection` (→ `detail.connectionId`) and `folder`
+ * (→ `detail.folderKey`). Omitting a label used to compile the node with
+ * `connectionId: null` and no binding at all — `check` and `compile` were
+ * silent, and only `uip maestro flow validate` refused it ("A connection is
+ * required to run this activity." / "FolderKey is required for the connection
+ * binding.", flow-builder-sdk#890). Managed HTTP is NOT one of these sites: its
+ * pair is optional by design (absent = an unmanaged request).
+ */
+export declare function missingBindingLabels(labels: {
+    connection?: unknown;
+    folder?: unknown;
+} | undefined): ('connection' | 'folder')[];
+/** Why compile refuses a connector-bound node with no `connection` / `folder` label, and how to bind it. */
+export declare function bindingMissingMessage(where: string, missing: readonly ('connection' | 'folder')[], target?: PrepareTarget): string;

package/dist/core/binding-messages.js

@@ -110,3 +110,30 @@ export function connectionConnectorConflictMessage(connection, users) {
         + `\`http({ managed: true, … })\` step on another connector's connection must name that connector in `
         + `\`targetConnector\`.`;
 }
+/**
+ * Which of a connector-bound node's two labels the author left out.
+ *
+ * A connector step, an event trigger, an `.entryPoint` onEvent and a
+ * `waitForEvent` all call Integration Service on a tenant connection, so the
+ * node needs BOTH halves: `connection` (→ `detail.connectionId`) and `folder`
+ * (→ `detail.folderKey`). Omitting a label used to compile the node with
+ * `connectionId: null` and no binding at all — `check` and `compile` were
+ * silent, and only `uip maestro flow validate` refused it ("A connection is
+ * required to run this activity." / "FolderKey is required for the connection
+ * binding.", flow-builder-sdk#890). Managed HTTP is NOT one of these sites: its
+ * pair is optional by design (absent = an unmanaged request).
+ */
+export function missingBindingLabels(labels) {
+    const blank = (v) => typeof v !== 'string' || v.trim() === '';
+    return ['connection', 'folder'].filter((k) => blank(labels?.[k]));
+}
+/** Why compile refuses a connector-bound node with no `connection` / `folder` label, and how to bind it. */
+export function bindingMissingMessage(where, missing, target) {
+    return `${where} has no ${missing.map((m) => `\`${m}\``).join(' or ')}. It calls Integration Service on a tenant `
+        + `connection, so the node needs both labels — \`connection\` (the connection id) and \`folder\` (its folder key), `
+        + `each naming a bindings.json entry. Without them the .flow carries \`connectionId: null\` and `
+        + `\`uip maestro flow validate\` refuses it ("A connection is required to run this activity." / "FolderKey is `
+        + `required for the connection binding."). \`${prepareFor(target)}\` finds the connection and writes both entries; `
+        + `with nothing real to bind yet, declare both labels in bindings.json with a placeholder resourceKey (a `
+        + `CONNECTION_STUB warning, never an invented GUID).`;
+}

package/dist/core/connector-checks.d.ts

@@ -185,6 +185,17 @@ use?: {
     id: string;
     connector: string | undefined;
 }): void;
+/**
+ * BINDING_MISSING: a connector-bound node with no `connection` or no `folder`
+ * label — the sentence compile throws (see `requireBindingPair` in serialize).
+ * Unlike {@link checkBindingLabels} this needs no bindings.json: an ABSENT label
+ * is wrong whatever the file says, because the node then compiles with
+ * `connectionId: null` and `flow validate` refuses it (flow-builder-sdk#890).
+ */
+export declare function checkBindingPresence(where: string, labels: {
+    connection?: unknown;
+    folder?: unknown;
+} | undefined, report: (code: 'BINDING_MISSING', message: string) => void, target?: PrepareTarget): void;
 /**
  * The two phrases every lookup diagnostic needs: what the field sends, and how
  * to resolve it.

package/dist/core/connector-checks.js

@@ -26,7 +26,7 @@ import { isLookupToken, resolvedValue, } from './lookups.js';
 import { Expr } from './expr.js';
 import { extractRefs } from './expr-check.js';
 import { prepareCommand, resolveFlagArg } from './cli-spelling.js';
-import { bindingSelfNameMessage, bindingUndeclaredMessage, connectionConnectorConflictMessage, undeclaredBinding, } from './binding-messages.js';
+import { bindingMissingMessage, bindingSelfNameMessage, bindingUndeclaredMessage, connectionConnectorConflictMessage, missingBindingLabels, undeclaredBinding, } from './binding-messages.js';
 /**
  * Flow: an input is an {@link Expr} object. A non-literal one is runtime; a
  * literal one (`lit(…)`) carries the constant it was built from.
@@ -372,6 +372,18 @@ use) {
         }
     }
 }
+/**
+ * BINDING_MISSING: a connector-bound node with no `connection` or no `folder`
+ * label — the sentence compile throws (see `requireBindingPair` in serialize).
+ * Unlike {@link checkBindingLabels} this needs no bindings.json: an ABSENT label
+ * is wrong whatever the file says, because the node then compiles with
+ * `connectionId: null` and `flow validate` refuses it (flow-builder-sdk#890).
+ */
+export function checkBindingPresence(where, labels, report, target) {
+    const missing = missingBindingLabels(labels);
+    if (missing.length > 0)
+        report('BINDING_MISSING', bindingMissingMessage(where, missing, target));
+}
 /**
  * The two phrases every lookup diagnostic needs: what the field sends, and how
  * to resolve it.

package/dist/core/global-names.d.ts

@@ -0,0 +1,39 @@
+/**
+ * One namespace for a flow's declared variables.
+ *
+ * `.input()`, `.output()` and `.var()` each look like their own namespace in the
+ * builder, but the `.flow` stores all three as rows of ONE list,
+ * `variables.globals[]`, keyed by `id`:
+ *
+ *   .input({ x })  → { id: 'x', direction: 'in' }
+ *   .output({ x }) → { id: 'x', direction: 'out' }
+ *   .var('x')      → { id: 'x', direction: 'inout' }
+ *
+ * The product refuses two rows with one id (`uip maestro flow validate`:
+ * `Duplicate variable ID: "x" (appears 2 times)`). Before flow-builder-sdk#890,
+ * `check` and `compile` were silent and wrote both rows.
+ *
+ * The common shape is `.output({ summary }) + .var('summary')` — "the output
+ * the arms assign". The remedy keeps the output and renames the var:
+ * `.var('draftSummary')` + `.return({ summary: v('draftSummary') })`. The output
+ * then stays a declared `out` global — the direction the Flow docs and the eval
+ * checkers (`direction == "out"`) treat as the flow's output contract. Dropping the name from `.output()` also
+ * validates — a `.var()` is an `inout` global, which the product counts as an
+ * output too — but the flow then has no declared `out` for it.
+ */
+export type GlobalKind = 'input' | 'output' | 'var';
+export interface GlobalNameCollision {
+    name: string;
+    /** Every declaration of the name, in declaration order (`input`, then `output`, then `var`). */
+    kinds: GlobalKind[];
+}
+/** The names declared more than once across `.input()`, `.output()` and `.var()`. */
+export declare function globalNameCollisions(inputs: readonly {
+    name: string;
+}[], outputs: readonly {
+    name: string;
+}[], vars: readonly {
+    name: string;
+}[]): GlobalNameCollision[];
+/** The sentence `check` (VARIABLE_NAME_COLLISION) prints and `serialize` throws for one collision. */
+export declare function globalNameCollisionMessage({ name, kinds }: GlobalNameCollision): string;

package/dist/core/global-names.js

@@ -0,0 +1,60 @@
+/**
+ * One namespace for a flow's declared variables.
+ *
+ * `.input()`, `.output()` and `.var()` each look like their own namespace in the
+ * builder, but the `.flow` stores all three as rows of ONE list,
+ * `variables.globals[]`, keyed by `id`:
+ *
+ *   .input({ x })  → { id: 'x', direction: 'in' }
+ *   .output({ x }) → { id: 'x', direction: 'out' }
+ *   .var('x')      → { id: 'x', direction: 'inout' }
+ *
+ * The product refuses two rows with one id (`uip maestro flow validate`:
+ * `Duplicate variable ID: "x" (appears 2 times)`). Before flow-builder-sdk#890,
+ * `check` and `compile` were silent and wrote both rows.
+ *
+ * The common shape is `.output({ summary }) + .var('summary')` — "the output
+ * the arms assign". The remedy keeps the output and renames the var:
+ * `.var('draftSummary')` + `.return({ summary: v('draftSummary') })`. The output
+ * then stays a declared `out` global — the direction the Flow docs and the eval
+ * checkers (`direction == "out"`) treat as the flow's output contract. Dropping the name from `.output()` also
+ * validates — a `.var()` is an `inout` global, which the product counts as an
+ * output too — but the flow then has no declared `out` for it.
+ */
+/** The names declared more than once across `.input()`, `.output()` and `.var()`. */
+export function globalNameCollisions(inputs, outputs, vars) {
+    const seen = new Map();
+    const add = (kind, list) => {
+        for (const { name } of list) {
+            const kinds = seen.get(name);
+            if (kinds)
+                kinds.push(kind);
+            else
+                seen.set(name, [kind]);
+        }
+    };
+    add('input', inputs);
+    add('output', outputs);
+    add('var', vars);
+    return [...seen].filter(([, kinds]) => kinds.length > 1).map(([name, kinds]) => ({ name, kinds }));
+}
+const SPELLING = {
+    input: (name) => `.input({ ${name} })`,
+    output: (name) => `.output({ ${name} })`,
+    var: (name) => `.var('${name}')`,
+};
+/** The sentence `check` (VARIABLE_NAME_COLLISION) prints and `serialize` throws for one collision. */
+export function globalNameCollisionMessage({ name, kinds }) {
+    const declared = kinds.map((k) => SPELLING[k](name)).join(' and ');
+    const head = `"${name}" is declared ${kinds.length} times (${declared}). The .flow keeps inputs, outputs and `
+        + `variables in one list, variables.globals[], so this compiles to ${kinds.length} globals with the id "${name}" `
+        + `and \`uip maestro flow validate\` refuses it: Duplicate variable ID: "${name}".`;
+    const distinct = new Set(kinds);
+    if (distinct.size === 2 && distinct.has('output') && distinct.has('var')) {
+        return `${head} Keep the output and give the variable its own name: `
+            + `.var('${name}Value', …) with { updates: { ${name}Value: … } }, then .return({ ${name}: v('${name}Value') }). `
+            + `(Dropping "${name}" from .output() also validates — a .var() compiles to an \`inout\` global, which the `
+            + `product counts as an output — but then the flow declares no \`out\` variable for it.)`;
+    }
+    return `${head} Rename one of them.`;
+}

package/dist/decompile.js

@@ -37,6 +37,8 @@ import { inferScriptShape } from './core/script-return.js';
 import { DEFAULT_TRIGGER_ID } from './core/expr.js';
 import { parseIxpProjectType } from './core/actions.js';
 import { readFlowGlobals } from './flow-variables.js';
+import { missingBindingLabels } from './core/binding-messages.js';
+import { prepareCommand } from './core/cli-spelling.js';
 import { OUTCOME_HANDLE_NODE_TYPES } from './core/hitl-routing.js';
 import { eventFilterFromTreeLeaf } from './core/event-filters.js';
 /**
@@ -1517,6 +1519,25 @@ function emitHitl(node, imp, inputNames, graph) {
  * `filterExpression` string, but reading the structured copies avoids parsing a
  * string this file generated.
  */
+/**
+ * A connector-bound node the file carries UNBOUND: Studio Web saves a draft whose
+ * connection was never picked as `connectionId: null`. The source cannot invent
+ * labels for it, and `compile` refuses a node without both (BINDING_MISSING, the
+ * rule `flow validate` applies too: flow-builder-sdk#890). So the source says so
+ * at the node and the run warns once, instead of handing back a file whose first
+ * compile fails with no context. Returns the inline marker, or '' when bound.
+ */
+function unboundMarker(node, labels, key, action) {
+    const missing = missingBindingLabels(labels);
+    if (missing.length === 0)
+        return '';
+    const names = missing.join(' and ');
+    warnOnce(`node ${str(node.id)} (${node.type}) has no ${missing.join(' or ')} in the .flow (an unbound draft). `
+        + `The source leaves ${missing.length > 1 ? 'them' : 'it'} out, and compile refuses the node (BINDING_MISSING) `
+        + `until it names both labels: run \`${prepareCommand(key, action ?? '<action>')}\`, then pass `
+        + `\`connection\` and \`folder\`.`);
+    return ` /* TODO: bind ${names}; compile refuses this node until it has both labels (BINDING_MISSING) */`;
+}
 function emitEventSubscription(node, imp, inputNames) {
     const prefix = node.type.startsWith('uipath.connector.event.') ? 'uipath.connector.event.'
         : node.type.startsWith('uipath.connector.trigger.') ? 'uipath.connector.trigger.'
@@ -1574,7 +1595,7 @@ function emitEventSubscription(node, imp, inputNames) {
         ['filters', filterRows.length ? `[${filterRows.join(', ')}]` : undefined],
         ['connection', conn !== undefined ? str(conn) : undefined],
         ['folder', folder !== undefined ? str(folder) : undefined],
-    ]);
+    ]) + unboundMarker(node, { connection: conn, folder }, connector, event);
 }
 function emitPublishedResource(node, imp, inputNames) {
     const FAMILIES = [
@@ -1658,7 +1679,8 @@ function emitConnector(node, imp, inputNames, o) {
     ]);
     const inputsSrc = objLit(flat) || '{}';
     const args = [str(split.key), str(split.action), inputsSrc, ...(optsSrc ? [optsSrc] : [])];
-    return `${imp.use('connector')}(${args.join(', ')})`;
+    return `${imp.use('connector')}(${args.join(', ')})`
+        + unboundMarker(node, { connection, folder }, split.key, split.action);
 }
 /** Best-effort placeholder for a node type the reverse-map does not yet cover. */
 function unsupportedSpec(node, imp, o) {

package/dist/flow-sdk.d.ts

@@ -148,6 +148,7 @@ export declare function manual(): TriggerSpec;
  *     connector: 'uipath-microsoft-outlook365',
  *     event: 'email-received',
  *     where: { parentFolderId: inboxId },
+ *     connection: 'outlook', folder: 'shared',   // bindings.json labels, both required
  *   }))
  *   .step('extract', script({ code: 'return { subject: $vars.start.output.subject };' }))
  *   .build();
@@ -740,12 +741,13 @@ declare class StepList {
      * ```ts
      * export default flow('draft-review')
      *   .output({ summary: types.string })
-     *   .var('summary', types.string)
+     *   // Not `.var('summary')`: an output and a var share one namespace (VARIABLE_NAME_COLLISION).
+     *   .var('result', types.string)
      *   .stepSwitch('review', hitl({ fields: [], outcomes: ['Publish', 'Revise'] }), [
-     *     { value: 'Publish', body: (b) => b.step('publish', script({ code: 'return "published";', returns: 'string' }), { updates: { summary: out('publish') } }) },
-     *     { value: 'Revise', body: (b) => b.step('sendBack', script({ code: 'return "revise";', returns: 'string' }), { updates: { summary: out('sendBack') } }) },
+     *     { value: 'Publish', body: (b) => b.step('publish', script({ code: 'return "published";', returns: 'string' }), { updates: { result: out('publish') } }) },
+     *     { value: 'Revise', body: (b) => b.step('sendBack', script({ code: 'return "revise";', returns: 'string' }), { updates: { result: out('sendBack') } }) },
      *   ])
-     *   .return({ summary: v('summary') })
+     *   .return({ summary: v('result') })
      *   .build();
      * ```
      */

package/dist/flow-sdk.js

@@ -332,12 +332,13 @@ class StepList {
      * ```ts
      * export default flow('draft-review')
      *   .output({ summary: types.string })
-     *   .var('summary', types.string)
+     *   // Not `.var('summary')`: an output and a var share one namespace (VARIABLE_NAME_COLLISION).
+     *   .var('result', types.string)
      *   .stepSwitch('review', hitl({ fields: [], outcomes: ['Publish', 'Revise'] }), [
-     *     { value: 'Publish', body: (b) => b.step('publish', script({ code: 'return "published";', returns: 'string' }), { updates: { summary: out('publish') } }) },
-     *     { value: 'Revise', body: (b) => b.step('sendBack', script({ code: 'return "revise";', returns: 'string' }), { updates: { summary: out('sendBack') } }) },
+     *     { value: 'Publish', body: (b) => b.step('publish', script({ code: 'return "published";', returns: 'string' }), { updates: { result: out('publish') } }) },
+     *     { value: 'Revise', body: (b) => b.step('sendBack', script({ code: 'return "revise";', returns: 'string' }), { updates: { result: out('sendBack') } }) },
      *   ])
-     *   .return({ summary: v('summary') })
+     *   .return({ summary: v('result') })
      *   .build();
      * ```
      */

package/dist/serialize.js

@@ -16,7 +16,8 @@ import { connectorRawNodeRefusal } from './core/connector-raw-node.js';
 import { dataFabricUnknownInputs } from './core/typed-raw-node.js';
 import { isAnswerField } from './core/hitl-answers.js';
 import { connectionConnectors } from './bindings-v2.js';
-import { BindingRefusal, GUID_RE, bindingSelfNameMessage, bindingUndeclaredMessage, undeclaredBinding } from './core/binding-messages.js';
+import { globalNameCollisionMessage, globalNameCollisions } from './core/global-names.js';
+import { BindingRefusal, GUID_RE, bindingMissingMessage, bindingSelfNameMessage, bindingUndeclaredMessage, missingBindingLabels, undeclaredBinding } from './core/binding-messages.js';
 import { ByoaRefusal, byoaUnverified } from './core/byoa.js';
 import { OUTCOME_HANDLE_NODE_TYPES, assertHitlExitInvariant, hitlExitModel, hitlExitViolation, outcomeSlug } from './core/hitl-routing.js';
 import { declaredExits, hasExits, stopsAtEnd } from './core/step-ports.js';
@@ -3484,6 +3485,27 @@ function refuseUnverifiedByoa(opts, where, sub) {
     if (message)
         throw new ByoaRefusal(message);
 }
+/** Refuse a name declared twice across `.input()` / `.output()` / `.var()` — one `variables.globals[]` id each. */
+function refuseGlobalNameCollisions(inputs, outputs, vars) {
+    const [first] = globalNameCollisions(inputs, outputs, vars);
+    if (first)
+        throw new Error(globalNameCollisionMessage(first));
+}
+/**
+ * Refuse a connector-bound node (connector step, event trigger, `.entryPoint`
+ * onEvent, `waitForEvent`) that names no `connection` or no `folder` label.
+ * (An inline agent's connector tool is #875's: `check` refuses it as
+ * INLINE_AGENT_TOOL_CONNECTOR_NO_CONNECTION, and serialize leaves it unbound.)
+ * `resolveBinding` returns `undefined` for an absent label, which used to reach
+ * the node as `detail.connectionId: null` with no binding — valid to compile,
+ * refused by `flow validate` (flow-builder-sdk#890). `check` reports the same
+ * sentence first (BINDING_MISSING).
+ */
+function requireBindingPair(where, labels, target) {
+    const missing = missingBindingLabels(labels);
+    if (missing.length > 0)
+        throw new BindingRefusal('BINDING_MISSING', bindingMissingMessage(where, missing, target));
+}
 /**
  * Resolve a symbolic connection/folder name to the resource key that is inlined
  * as `connectionId` / `connectionFolderKey`.
@@ -3709,7 +3731,8 @@ function flattenWhere(where, declared) {
     walk(where, '');
     return out;
 }
-function eventDetail(rc, sub, nodeId, opts) {
+function eventDetail(rc, sub, nodeId, opts, site) {
+    requireBindingPair(site, sub, eventTarget(sub));
     const conn = resolveBinding(opts, sub.connection, 'connection', `event node "${nodeId}"`, eventTarget(sub));
     const folder = resolveBinding(opts, sub.folder, 'folder', `event node "${nodeId}"`, eventTarget(sub));
     const op = (rc.entry?.operation ?? {});
@@ -4420,6 +4443,7 @@ export function serialize(built, opts = {}) {
             for (const t of tails)
                 addEdge(scope, t, endId);
         }
+        refuseGlobalNameCollisions(child.inputs, child.outputs, child.vars);
         const globals = [];
         for (const inp of child.inputs)
             globals.push({ id: inp.name, name: inp.name, direction: 'in', type: inp.type, triggerNodeId: startId, ...varMeta(inp) });
@@ -4508,7 +4532,7 @@ export function serialize(built, opts = {}) {
                 // `detail` (see eventDetail).
                 entryPointId: stableId(`${built.id}:start:entryPoint`),
                 isDefaultEntryPoint: true,
-                detail: eventDetail(eventTriggerRc, built.trigger.subscription, triggerId, opts),
+                detail: eventDetail(eventTriggerRc, built.trigger.subscription, triggerId, opts, 'event trigger'),
             }
             : built.trigger?.kind === 'scheduled'
                 ? scheduleInputs(built.trigger.inputs, triggerId)
@@ -4658,6 +4682,7 @@ export function serialize(built, opts = {}) {
             const id = stepUid(scope, step.name);
             const node = makeNode(rc.nodeType, id, step.name, { parentId, requestedVersion: step.options?.version, def: rc.v1def });
             declareListOutputType(node, rc);
+            requireBindingPair(`connector "${step.name}"`, spec, { key: spec.key, action: spec.action });
             const conn = resolveBinding(opts, spec.connection, 'connection', `connector "${step.name}"`, { key: spec.key, action: spec.action });
             const folder = resolveBinding(opts, spec.folder, 'folder', `connector "${step.name}"`, { key: spec.key, action: spec.action });
             // The platform reaches the connection through the flow's `bindings[]`,
@@ -5614,7 +5639,7 @@ export function serialize(built, opts = {}) {
             refuseUnverifiedByoa(opts, `waitForEvent "${step.name}"`, sub);
             const id = stepUid(scope, step.name);
             const node = makeNode(rc.nodeType, id, step.name, { parentId, requestedVersion: step.options?.version, def: rc.v1def });
-            node.inputs = { detail: eventDetail(rc, sub, id, opts) };
+            node.inputs = { detail: eventDetail(rc, sub, id, opts, `waitForEvent "${step.name}"`) };
             // Same connection-binding closure as the connector branch (G-19).
             const { entries: waitConnBindings } = connectionResourceBindings({
                 def: rc.v1def,
@@ -6471,7 +6496,7 @@ export function serialize(built, opts = {}) {
                 node = makeNode(rc.nodeType, ep.id, 'Event trigger', { def: rc.v1def, requestedVersion });
                 node.inputs = {
                     entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`),
-                    detail: eventDetail(rc, sub, ep.id, opts),
+                    detail: eventDetail(rc, sub, ep.id, opts, `onEvent() entry point "${ep.id}"`),
                 };
                 const { entries } = connectionResourceBindings({
                     def: rc.v1def,
@@ -6506,6 +6531,9 @@ export function serialize(built, opts = {}) {
             }
         }
     }
+    // Entry-point inputs are rows of the same globals[] (pushed below), so they
+    // share the namespace; `check` reports these as ENTRY_POINT_INPUT_COLLISION.
+    refuseGlobalNameCollisions([...built.inputs, ...entryPoints.flatMap((ep) => ep.inputs)], built.outputs, built.vars);
     const globals = [];
     const triggerNodeId = built.triggerId ?? 'start';
     for (const inp of built.inputs)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.15.2",
+  "version": "6.15.3",
   "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": "0b7e3bb5985faa13fef763c45e3d69ef07a4d346"
+  "gitref": "a85d11af254f270d645ec46d57994ccb800ebc1f"
 }