@uipath/maestro-builder-sdk 6.15.1 → 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)
@@ -894,20 +901,17 @@ function checkFlow(built, ancestors, opts = {}) {
     // Both forms resolve at run time — measured, `$vars.call["output"].x` and
     // `$vars["call"].output.x` both returned the value — so this is not a broken
     // read. It is an unrewritable one. Every reference the SDK emits goes through
-    // `renameRefs`, whose regex matches the DOTTED form only, and three separate
+    // `renameRefs`, whose regex matches the DOTTED form only, and two separate
     // rewrites ride on it:
     //
     //   * a subflow copy renames node ids (`rename.nodeIds`), so a bracketed read
     //     keeps pointing at the uncopied name;
-    //   * the queue family publishes its result as `<step>.response`, not
-    //     `<step>.output` (`rename.runtimeOutputs`), so the two spellings read
-    //     DIFFERENT variables;
     //   * a failure envelope resolves per node family (`rename.errorEnvelopes`).
     //
-    // So the bracketed spelling is correct only for as long as none of those
+    // So the bracketed spelling is correct only for as long as neither of those
     // applies to the step — and it fails silently when one starts to. This is the
     // shape an eval agent actually wrote (`$vars.enqueue["output"].Key` on a queue
-    // step, where the emitted read had to be `.response.Key`).
+    // step, at a time when the SDK still aliased queue reads to `.response`, #891).
     //
     // Deeper brackets are untouched: `$vars.rows.output["odd key"]` is ordinary
     // data access, it is the only way to spell a key that is not an identifier,
@@ -916,16 +920,15 @@ function checkFlow(built, ancestors, opts = {}) {
         const flag = (name, read, key) => {
             const suggestion = key === 'error'
                 ? `err('${name}', 'message')`
-                : key && key !== 'output' && key !== 'response'
+                : key && key !== 'output'
                     ? `out('${name}', '${key}')`
                     : `out('${name}')`;
             diags.push({
                 level: 'error',
                 code: 'VARS_BRACKET_READ',
                 message: `"${read}" in "${step}" reaches step "${name}" through a bracket. It resolves today, but only the `
-                    + `DOTTED form is rewritten on the way out: a subflow copy renames node ids, the queue family publishes `
-                    + `its result as "${name}.response" rather than "${name}.output", and a failure envelope resolves per node `
-                    + `family. A bracketed read opts out of all three and goes silently stale when one applies.`,
+                    + `DOTTED form is rewritten on the way out: a subflow copy renames node ids, and a failure envelope `
+                    + `resolves per node family. A bracketed read opts out of both and goes silently stale when one applies.`,
                 step,
                 suggestion,
             });
@@ -1261,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) {
@@ -1651,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 } : {}) });
     };
@@ -1663,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.
@@ -1679,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/expr.d.ts

@@ -72,10 +72,9 @@ export declare function entryInput(entryPointId: string, name: string): Expr;
  * Write the reference this way, or dotted by hand — never through a bracket
  * (`$vars.fetchRate["output"]`, `$vars["fetchRate"].output`). Both of those
  * resolve at run time, so the mistake is invisible, but only the DOTTED form is
- * rewritten on the way out: a subflow copy renames node ids, the queue family
- * publishes its result as `<step>.response`, and a failure envelope resolves per
- * node family. A bracketed read opts out of all three and goes stale the moment
- * one applies. `path` may still bracket INTO the value — `out('rows', 'items')`
+ * rewritten on the way out: a subflow copy renames node ids, and a failure
+ * envelope resolves per node family. A bracketed read opts out of both and goes
+ * stale the moment one applies. `path` may still bracket INTO the value — `out('rows', 'items')`
  * then `["odd key"]` — because nothing rewrites past the runtime variable.
  *
  * @param step - The step whose result to read, named as it was in `.step(...)`.

package/dist/core/expr.js

@@ -92,10 +92,9 @@ export function entryInput(entryPointId, name) {
  * Write the reference this way, or dotted by hand — never through a bracket
  * (`$vars.fetchRate["output"]`, `$vars["fetchRate"].output`). Both of those
  * resolve at run time, so the mistake is invisible, but only the DOTTED form is
- * rewritten on the way out: a subflow copy renames node ids, the queue family
- * publishes its result as `<step>.response`, and a failure envelope resolves per
- * node family. A bracketed read opts out of all three and goes stale the moment
- * one applies. `path` may still bracket INTO the value — `out('rows', 'items')`
+ * rewritten on the way out: a subflow copy renames node ids, and a failure
+ * envelope resolves per node family. A bracketed read opts out of both and goes
+ * stale the moment one applies. `path` may still bracket INTO the value — `out('rows', 'items')`
  * then `["odd key"]` — because nothing rewrites past the runtime variable.
  *
  * @param step - The step whose result to read, named as it was in `.step(...)`.

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();
      * ```
      */