@uipath/maestro-builder-sdk 6.15.4 → 6.15.6

package/dist/core/connector-inputs.js

@@ -259,6 +259,57 @@ const SLOT_FOR_LOCATION = {
     query: 'queryParameters',
     path: 'pathParameters',
 };
+/**
+ * Fold a body keyed by the registry's dotted field ids into the nested request
+ * object those ids describe: `{"fields.project.key":"CE"}` → `{"fields":{"project":{"key":"CE"}}}`.
+ *
+ * `buildConnectorInputs` keeps the DOTTED keys on purpose — Flow's `bodyParameters` is a
+ * flat map and Flow's runtime (`convertDotNotationToNested`) nests it before the call.
+ * The Maestro BPMN runtime does not: `IntSvcSendTaskHandler` sends the `body` input as
+ * written, so a dotted key reaches the connector as a literal property name. Measured on
+ * flow-v2-run-12: the SDK's Jira `create-issue` body went out flat and Integration
+ * Service answered 400 `project: Specify a valid project ID or key`; the v1 arm, which
+ * writes the nested form by hand, created the ticket. A BPMN body therefore goes through
+ * this before it is serialised.
+ *
+ * A `[*]` segment names an array. On a leaf (`users[*]`) an array value is kept and a
+ * scalar becomes a one-element list, as the product's own conversion does; on an inner
+ * segment (`attachments[*].url`) each element of an array value becomes one object, and
+ * a scalar one. Later keys win over earlier ones at the same leaf; a nested object the
+ * author already wrote under a plain key is merged into, not replaced.
+ */
+export function nestConnectorBody(flat) {
+    const out = {};
+    for (const [name, value] of Object.entries(flat)) {
+        const parts = connectorPath(name);
+        place(out, parts, 0, value);
+    }
+    return out;
+}
+function place(target, parts, index, value) {
+    const part = parts[index];
+    const last = index === parts.length - 1;
+    if (last) {
+        target[part.key] = part.array && !Array.isArray(value) ? [value] : value;
+        return;
+    }
+    if (part.array) {
+        const elements = Array.isArray(value) ? value : [value];
+        const existing = Array.isArray(target[part.key]) ? target[part.key] : [];
+        target[part.key] = elements.map((element, i) => {
+            const slot = isRecord(existing[i]) ? existing[i] : {};
+            place(slot, parts, index + 1, element);
+            return slot;
+        });
+        return;
+    }
+    const next = isRecord(target[part.key]) ? target[part.key] : {};
+    target[part.key] = next;
+    place(next, parts, index + 1, value);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 function connectorPath(name) {
     return name.split('.').map((raw) => ({
         key: raw.endsWith('[*]') ? raw.slice(0, -3) : raw,

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

@@ -9,12 +9,14 @@
  * `.waitForEvent()` node carries the same facts under its own names, and
  * `bpmn/check.ts` adapts one to the other.
  *
- * What BPMN does NOT carry is `filters` — payload filtering is a Flow surface —
- * so the `EVENT_FILTER_*` family simply does not fire there. The rules that do
- * are the ones about the SUBSCRIPTION: whether it resolves at all, whether a
- * generic event named its object, and whether its scope names parameters the
- * operation actually declares. `skill-bpmn-outlook-waitfor-email` in
- * `flow-v2-run-8` failed on exactly that last question.
+ * BPMN carries `filters` too, since flow-v2-run-12: both families write payload
+ * conditions into the subscription the platform reads (Flow's `filterExpression`,
+ * BPMN's `body.filters.expression`), lowered by the same grammar, so the
+ * `EVENT_FILTER_*` family fires for both. The subscription rules are the rest:
+ * whether it resolves at all, whether a generic event named its object, and whether
+ * its scope names parameters the operation actually declares.
+ * `skill-bpmn-outlook-waitfor-email` in `flow-v2-run-8` failed on exactly that last
+ * question, and in run 12 on having nowhere to put a payload condition.
  */
 import { type LookupResolutions } from './lookups.js';
 import { type ByoaEventFacts, type ByoaLedger } from './byoa.js';

package/dist/core/event-checks.js

@@ -9,12 +9,14 @@
  * `.waitForEvent()` node carries the same facts under its own names, and
  * `bpmn/check.ts` adapts one to the other.
  *
- * What BPMN does NOT carry is `filters` — payload filtering is a Flow surface —
- * so the `EVENT_FILTER_*` family simply does not fire there. The rules that do
- * are the ones about the SUBSCRIPTION: whether it resolves at all, whether a
- * generic event named its object, and whether its scope names parameters the
- * operation actually declares. `skill-bpmn-outlook-waitfor-email` in
- * `flow-v2-run-8` failed on exactly that last question.
+ * BPMN carries `filters` too, since flow-v2-run-12: both families write payload
+ * conditions into the subscription the platform reads (Flow's `filterExpression`,
+ * BPMN's `body.filters.expression`), lowered by the same grammar, so the
+ * `EVENT_FILTER_*` family fires for both. The subscription rules are the rest:
+ * whether it resolves at all, whether a generic event named its object, and whether
+ * its scope names parameters the operation actually declares.
+ * `skill-bpmn-outlook-waitfor-email` in `flow-v2-run-8` failed on exactly that last
+ * question, and in run 12 on having nowhere to put a payload condition.
  */
 import { isLookupToken, resolvedValue, unresolvedLookupMessage, } from './lookups.js';
 import { prepareCommand } from './cli-spelling.js';

package/dist/core/expr.d.ts

@@ -27,9 +27,15 @@ export declare class Expr {
  */
 export declare function lit(value: unknown): Expr;
 /**
- * Reference a flow-level variable or input by name → `$vars.<name>`.
+ * Reference a flow variable or output by name → `$vars.<name>`.
  *
- * @param name - The variable or input as declared with `.var(...)` / `.input(...)`.
+ * @remarks
+ * Not for a flow INPUT: an input is published under the trigger's output, so read
+ * it with {@link input} (`$vars.start.output.<name>`). A bare `$vars.<input>` is
+ * null under any trigger but a manual one, and `check` and `uip maestro flow
+ * validate` both refuse it.
+ *
+ * @param name - The variable or output as declared with `.var(...)` / `.output(...)`.
  * @returns An {@link Expr} reading that variable at run time.
  */
 export declare function v(name: string): Expr;

package/dist/core/expr.js

@@ -33,9 +33,15 @@ export function lit(value) {
     return new Expr(JSON.stringify(value), true, value);
 }
 /**
- * Reference a flow-level variable or input by name → `$vars.<name>`.
+ * Reference a flow variable or output by name → `$vars.<name>`.
  *
- * @param name - The variable or input as declared with `.var(...)` / `.input(...)`.
+ * @remarks
+ * Not for a flow INPUT: an input is published under the trigger's output, so read
+ * it with {@link input} (`$vars.start.output.<name>`). A bare `$vars.<input>` is
+ * null under any trigger but a manual one, and `check` and `uip maestro flow
+ * validate` both refuse it.
+ *
+ * @param name - The variable or output as declared with `.var(...)` / `.output(...)`.
  * @returns An {@link Expr} reading that variable at run time.
  */
 export function v(name) {

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

@@ -13,13 +13,11 @@
  * `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.
+ * One pair is NOT a collision: `.output({ x }) + .var('x')` with the same type is
+ * the loop-accumulator shape ("declare the result, then seed it"), and
+ * `planFlowGlobals` (`flow-variables.ts`) merges it into ONE `out` global that
+ * carries the var's default (flow-builder-sdk#899). Every other repeat of a name
+ * is reported with the sentence below.
  */
 export type GlobalKind = 'input' | 'output' | 'var';
 export interface GlobalNameCollision {

package/dist/core/global-names.js

@@ -13,13 +13,11 @@
  * `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.
+ * One pair is NOT a collision: `.output({ x }) + .var('x')` with the same type is
+ * the loop-accumulator shape ("declare the result, then seed it"), and
+ * `planFlowGlobals` (`flow-variables.ts`) merges it into ONE `out` global that
+ * carries the var's default (flow-builder-sdk#899). Every other repeat of a name
+ * is reported with the sentence below.
  */
 /** The names declared more than once across `.input()`, `.output()` and `.var()`. */
 export function globalNameCollisions(inputs, outputs, vars) {
@@ -49,12 +47,5 @@ export function globalNameCollisionMessage({ name, kinds }) {
     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

@@ -1762,7 +1762,7 @@ function emitVariables(e, depth, flow, imp) {
     if (inputs.length)
         e.line(depth, `.input(${shape(inputs, true)})`);
     if (outputs.length)
-        e.line(depth, `.output(${shape(outputs, false)})`);
+        e.line(depth, `.output(${shape(outputs, true)})`);
     for (const g of inouts) {
         const rich = declExpr(g, false, imp);
         const def = g.defaultValue !== undefined ? `, ${literal(g.defaultValue)}` : '';
@@ -2538,7 +2538,7 @@ function emitChildFlow(name, child, ctx) {
     };
     const parts = [`${ctx.imp.use('flow')}(${str(name)})`];
     // Variables.
-    const shape = (dir) => `{ ${globals.filter((g) => g.direction === dir).map((g) => `${key(g.name ?? g.id)}: ${declExpr(g, dir === 'in', ctx.imp)}`).join(', ')} }`;
+    const shape = (dir) => `{ ${globals.filter((g) => g.direction === dir).map((g) => `${key(g.name ?? g.id)}: ${declExpr(g, dir !== 'inout', ctx.imp)}`).join(', ')} }`;
     if (globals.some((g) => g.direction === 'in'))
         parts.push(`.input(${shape('in')})`);
     if (globals.some((g) => g.direction === 'out'))

package/dist/flow-sdk.d.ts

@@ -71,7 +71,11 @@ export interface VarSpec {
     subType?: string;
     /** JSON schema for complex type validation (object/array shapes). */
     schema?: Record<string, unknown>;
-    /** Default value — inputs and vars only; the format forbids it on outputs. */
+    /**
+     * Default value — the variable's value before anything assigns it. On an
+     * output it is the starting value a `{ updates }` accumulator reads, e.g.
+     * `.output({ product: { type: types.number, default: 1 } })`.
+     */
     default?: unknown;
 }
 /**
@@ -377,7 +381,7 @@ export interface ReturnOptions extends NodeOptions {
      * `done` become `done` and `done2`.
      *
      * ```ts
-     * .branch('checkTemperature', js`$vars.tempF > 60`,
+     * .branch('checkTemperature', js`${input('tempF')} > 60`,
      *   (t) => t.return({}, { name: 'endNiceDay', label: 'Nice Day' }),
      *   (e) => e.return({}, { name: 'endBringJacket', label: 'Bring a Jacket' }))
      * ```
@@ -741,7 +745,7 @@ declare class StepList {
      * ```ts
      * export default flow('draft-review')
      *   .output({ summary: types.string })
-     *   // Not `.var('summary')`: an output and a var share one namespace (VARIABLE_NAME_COLLISION).
+     *   // A working variable the arms assign; the return maps it onto the output.
      *   .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: { result: out('publish') } }) },
@@ -1323,6 +1327,25 @@ declare class FlowBuilder extends StepList {
     /**
      * Declare the flow's outputs — what `.return(...)` binds values to.
      *
+     * @remarks
+     * An output is also a flow variable: `v('<name>')` reads it and a step's
+     * `{ updates }` assigns it, so an accumulator needs no separate `.var()`. Give
+     * it a starting value with the rich spelling, `{ type, default }`. A `.var()`
+     * of the same name and type is merged into the output rather than emitted as a
+     * second variable (its default becomes the output's); a different type is a
+     * `check` error, `OUTPUT_VAR_MISMATCH`.
+     *
+     * @example
+     * **A loop accumulator**
+     * ```ts
+     * flow('multiply')
+     *   .output({ product: { type: types.number, default: 1 } })
+     *   .loop('each', lit([2, 3, 4]), (b) => b
+     *     .step('mul', script({ code: 'return $vars.product * $vars.each.currentItem;', returns: 'number' }),
+     *       { updates: { product: out('mul') } }))
+     *   .return({ product: v('product') })
+     * ```
+     *
      * @param shape - Output names to type descriptors, e.g. `{ total: types.number }`.
      * @returns This builder, so calls chain.
      */
@@ -1384,7 +1407,7 @@ export declare function flow(id: string): FlowBuilder;
  * const reverse = flow('reverse-text')
  *   .input({ text: types.string })
  *   .output({ reversed: types.string })
- *   .step('rev', script({ code: 'return $vars.text.split("").reverse().join("");' }))
+ *   .step('rev', script({ code: 'return $vars.start.output.text.split("").reverse().join("");' }))
  *   .return({ reversed: out('rev') });
  *
  * export default flow('reverse-outer')

package/dist/flow-sdk.js

@@ -63,16 +63,14 @@ function assertShape(method, shape) {
 }
 /**
  * Normalize a `TypeDesc | VarSpec` declaration value into VarDecl fields.
- * Outputs reject `default` — the format only persists defaults on `in`/`inout`.
+ * Every direction takes a `default`: the format's `workflowVariableSchema` allows
+ * `defaultValue` on `in`, `out` and `inout` alike, and the v1 CLI's
+ * `variable add --direction out --default-value` writes one on an output.
  */
 function varDeclOf(method, name, value) {
     if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
         const spec = value;
         assertType(method, name, spec.type);
-        if (method === 'output' && spec.default !== undefined) {
-            throw new TypeError(`.output() declared ${JSON.stringify(name)} with a default, but the .flow format only persists `
-                + `defaults on inputs and vars. Bind the value with .return() instead.`);
-        }
         return {
             type: spec.type,
             ...(spec.default !== undefined ? { default: spec.default } : {}),
@@ -332,7 +330,7 @@ class StepList {
      * ```ts
      * export default flow('draft-review')
      *   .output({ summary: types.string })
-     *   // Not `.var('summary')`: an output and a var share one namespace (VARIABLE_NAME_COLLISION).
+     *   // A working variable the arms assign; the return maps it onto the output.
      *   .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: { result: out('publish') } }) },
@@ -1096,6 +1094,25 @@ class FlowBuilder extends StepList {
     /**
      * Declare the flow's outputs — what `.return(...)` binds values to.
      *
+     * @remarks
+     * An output is also a flow variable: `v('<name>')` reads it and a step's
+     * `{ updates }` assigns it, so an accumulator needs no separate `.var()`. Give
+     * it a starting value with the rich spelling, `{ type, default }`. A `.var()`
+     * of the same name and type is merged into the output rather than emitted as a
+     * second variable (its default becomes the output's); a different type is a
+     * `check` error, `OUTPUT_VAR_MISMATCH`.
+     *
+     * @example
+     * **A loop accumulator**
+     * ```ts
+     * flow('multiply')
+     *   .output({ product: { type: types.number, default: 1 } })
+     *   .loop('each', lit([2, 3, 4]), (b) => b
+     *     .step('mul', script({ code: 'return $vars.product * $vars.each.currentItem;', returns: 'number' }),
+     *       { updates: { product: out('mul') } }))
+     *   .return({ product: v('product') })
+     * ```
+     *
      * @param shape - Output names to type descriptors, e.g. `{ total: types.number }`.
      * @returns This builder, so calls chain.
      */
@@ -1196,7 +1213,7 @@ export function flow(id) {
  * const reverse = flow('reverse-text')
  *   .input({ text: types.string })
  *   .output({ reversed: types.string })
- *   .step('rev', script({ code: 'return $vars.text.split("").reverse().join("");' }))
+ *   .step('rev', script({ code: 'return $vars.start.output.text.split("").reverse().join("");' }))
  *   .return({ reversed: out('rev') });
  *
  * export default flow('reverse-outer')

package/dist/flow-variables.d.ts

@@ -11,3 +11,69 @@ export interface FlowGlobalDeclaration {
 }
 /** Read both supported Flow variable spellings into one declaration table. */
 export declare function readFlowGlobals(variables: unknown, strict?: boolean): FlowGlobalDeclaration[];
+/** The declaration fields `planFlowGlobals` reads (structurally a `VarDecl`). */
+export interface DeclaredVariable {
+    name: string;
+    type: string;
+    default?: unknown;
+    description?: string;
+    subType?: string;
+    schema?: Record<string, unknown>;
+}
+/** One reason the declared names cannot become one global each. */
+export interface FlowGlobalsProblem {
+    code: 'VARIABLE_NAME_COLLISION' | 'OUTPUT_VAR_MISMATCH';
+    name: string;
+    message: string;
+    suggestion?: string;
+}
+/** What `variables.globals` will hold, before directions and trigger ids are stamped. */
+export interface FlowGlobalsPlan<D extends DeclaredVariable = DeclaredVariable> {
+    /** Every `.output()`, in order. One with a same-named `.var()` carries that var's default. */
+    outputs: D[];
+    /** The `.var()` declarations NOT folded into an output, in order. */
+    vars: D[];
+    /** Names declared by both `.output()` and `.var()` and merged into one `out` global. */
+    merged: string[];
+    /** Collisions that would emit two globals with one id. Empty when the plan is emittable. */
+    problems: FlowGlobalsProblem[];
+}
+/**
+ * Turn a flow's `.input()` / `.output()` / `.var()` declarations into the
+ * globals the `.flow` file will carry — one per id, because the product's
+ * `flow validate` rejects a repeated id (`[variables.globals] Duplicate variable
+ * ID`), and the three methods share that one namespace.
+ *
+ * **An output and a var with the same name are one variable** (flow-builder-sdk#899).
+ * The natural loop accumulator is
+ * `.output({ product: types.number }).var('product', types.number, 1)`: declare
+ * the result, then seed it. Both declarations describe the same value, so they
+ * merge into ONE `direction: 'out'` global that carries the var's default.
+ *
+ * Why `out` and not `inout`, measured against `@uipath/flow-converter` 0.69 and
+ * `@uipath/maestro-sdk` (the code that turns a `.flow` into what runs):
+ * - only an `out` global is a flow OUTPUT at the root — `buildNodeOutputMappings`
+ *   drops an End node's mapping for any id that is not `direction: 'out'`;
+ * - `inout` is published as an INPUT too — solution discovery puts it on the
+ *   entry point's input schema — so `inout` would widen the caller's contract;
+ * - `{ updates }` on an `out` global is the same output mapping (`var: <id>`) as
+ *   on an `inout` one, so a loop body can read and rewrite it mid-run;
+ * - the `default` on `<uipath:output>` is serialized (`collectVariablesFromNodes`)
+ *   and a subflow seeds its `out` globals from `defaultValue ?? null`
+ *   (`buildSeedTask`). The v1 CLI's `variable add --direction out
+ *   --default-value` writes the same shape.
+ *
+ * Metadata: the output's `description` / `subType` / `schema` win, falling back
+ * to the var's; the default is whichever side declared one. A disagreement the
+ * merge would have to resolve by picking a side — a different `type`, two
+ * different defaults, two different `subType`s or `schema`s — is
+ * `OUTPUT_VAR_MISMATCH` instead, because silently choosing one changes what the
+ * flow computes. Every other repeated name (two vars, two outputs, an input
+ * reused as an output or var) stays `VARIABLE_NAME_COLLISION`
+ * (`core/global-names.ts`, flow-builder-sdk#890).
+ */
+export declare function planFlowGlobals<D extends DeclaredVariable>(decl: {
+    inputs: readonly D[];
+    outputs: readonly D[];
+    vars: readonly D[];
+}): FlowGlobalsPlan<D>;

package/dist/flow-variables.js

@@ -1,3 +1,4 @@
+import { globalNameCollisionMessage, globalNameCollisions } from './core/global-names.js';
 const CONTAINER_KEYS = new Set(['globals', 'nodes', 'variableUpdates']);
 const DIRECTIONS = new Set(['in', 'out', 'inout']);
 /** Read both supported Flow variable spellings into one declaration table. */
@@ -40,3 +41,86 @@ export function readFlowGlobals(variables, strict = false) {
     }
     return globals;
 }
+const sameJson = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/**
+ * Turn a flow's `.input()` / `.output()` / `.var()` declarations into the
+ * globals the `.flow` file will carry — one per id, because the product's
+ * `flow validate` rejects a repeated id (`[variables.globals] Duplicate variable
+ * ID`), and the three methods share that one namespace.
+ *
+ * **An output and a var with the same name are one variable** (flow-builder-sdk#899).
+ * The natural loop accumulator is
+ * `.output({ product: types.number }).var('product', types.number, 1)`: declare
+ * the result, then seed it. Both declarations describe the same value, so they
+ * merge into ONE `direction: 'out'` global that carries the var's default.
+ *
+ * Why `out` and not `inout`, measured against `@uipath/flow-converter` 0.69 and
+ * `@uipath/maestro-sdk` (the code that turns a `.flow` into what runs):
+ * - only an `out` global is a flow OUTPUT at the root — `buildNodeOutputMappings`
+ *   drops an End node's mapping for any id that is not `direction: 'out'`;
+ * - `inout` is published as an INPUT too — solution discovery puts it on the
+ *   entry point's input schema — so `inout` would widen the caller's contract;
+ * - `{ updates }` on an `out` global is the same output mapping (`var: <id>`) as
+ *   on an `inout` one, so a loop body can read and rewrite it mid-run;
+ * - the `default` on `<uipath:output>` is serialized (`collectVariablesFromNodes`)
+ *   and a subflow seeds its `out` globals from `defaultValue ?? null`
+ *   (`buildSeedTask`). The v1 CLI's `variable add --direction out
+ *   --default-value` writes the same shape.
+ *
+ * Metadata: the output's `description` / `subType` / `schema` win, falling back
+ * to the var's; the default is whichever side declared one. A disagreement the
+ * merge would have to resolve by picking a side — a different `type`, two
+ * different defaults, two different `subType`s or `schema`s — is
+ * `OUTPUT_VAR_MISMATCH` instead, because silently choosing one changes what the
+ * flow computes. Every other repeated name (two vars, two outputs, an input
+ * reused as an output or var) stays `VARIABLE_NAME_COLLISION`
+ * (`core/global-names.ts`, flow-builder-sdk#890).
+ */
+export function planFlowGlobals(decl) {
+    const problems = [];
+    const varsByName = new Map(decl.vars.map((d) => [d.name, d]));
+    const mergeable = new Set();
+    for (const collision of globalNameCollisions(decl.inputs, decl.outputs, decl.vars)) {
+        const pair = collision.kinds.length === 2 && collision.kinds[0] === 'output' && collision.kinds[1] === 'var';
+        if (pair)
+            mergeable.add(collision.name);
+        else
+            problems.push({ code: 'VARIABLE_NAME_COLLISION', name: collision.name, message: globalNameCollisionMessage(collision) });
+    }
+    const merged = [];
+    const outputs = decl.outputs.map((o) => {
+        const vd = varsByName.get(o.name);
+        if (!vd || !mergeable.has(o.name))
+            return o;
+        const clash = [];
+        if (o.type !== vd.type)
+            clash.push(`the output is ${o.type} and the var is ${vd.type}`);
+        if (o.default !== undefined && vd.default !== undefined && !sameJson(o.default, vd.default))
+            clash.push(`the output's default is ${JSON.stringify(o.default)} and the var's is ${JSON.stringify(vd.default)}`);
+        if (o.subType !== undefined && vd.subType !== undefined && o.subType !== vd.subType)
+            clash.push(`the output's subType is ${JSON.stringify(o.subType)} and the var's is ${JSON.stringify(vd.subType)}`);
+        if (o.schema !== undefined && vd.schema !== undefined && !sameJson(o.schema, vd.schema))
+            clash.push(`the output and the var declare different schemas`);
+        if (clash.length) {
+            problems.push({
+                code: 'OUTPUT_VAR_MISMATCH', name: o.name,
+                message: `"${o.name}" is declared by both .output() and .var(), which the SDK merges into one output `
+                    + `variable, but ${clash.join('; ')}. Make the two declarations agree, or drop the .var().`,
+                suggestion: `An output is assignable with { updates } on its own; declare its starting value with `
+                    + `.output({ ${o.name}: { type: types.${o.type}, default: … } }).`,
+            });
+            return o;
+        }
+        merged.push(o.name);
+        return {
+            ...o,
+            ...(o.default === undefined && vd.default !== undefined ? { default: vd.default } : {}),
+            ...(o.description === undefined && vd.description !== undefined ? { description: vd.description } : {}),
+            ...(o.subType === undefined && vd.subType !== undefined ? { subType: vd.subType } : {}),
+            ...(o.schema === undefined && vd.schema !== undefined ? { schema: vd.schema } : {}),
+        };
+    });
+    const mergedSet = new Set(merged);
+    const vars = decl.vars.filter((vd) => !mergedSet.has(vd.name));
+    return { outputs, vars, merged, problems };
+}

package/dist/registry/path-cli.js

@@ -1,4 +1,4 @@
-import { reportResult } from '../cli-result.js';
+import { printResult, reportResult } from '../cli-result.js';
 import { join } from "node:path";
 import { CURRENT_LINK, PULL_COMMAND, currentEntrySha, libraryCacheRoot, resolveCachedLibrary, resolveCachedMarkdown, } from "./cache.js";
 /**
@@ -37,7 +37,7 @@ export async function run(argv) {
             console.error(`No connector library in the cache yet. Run \`${PULL_COMMAND}\`.`);
             return 1;
         }
-        console.log(value);
+        printResult(value);
         return 0;
     };
     if (argv.includes("--library-json"))
@@ -56,7 +56,7 @@ export async function run(argv) {
         libraryMarkdown: libraryMarkdown ?? null,
     };
     reportResult(all);
-    console.log(JSON.stringify(all, null, 2));
+    printResult(JSON.stringify(all, null, 2));
     // Not an error: a caller asking for the whole picture is entitled to be told
     // the cache is empty, rather than getting a non-zero exit for a plain report.
     return 0;

package/dist/registry/search-cli.js

@@ -1,4 +1,4 @@
-import { reportResult } from '../cli-result.js';
+import { printResult, reportResult } from '../cli-result.js';
 import { readFile, stat } from "node:fs/promises";
 import { PULL_COMMAND, resolveLibraryDir } from "./cache.js";
 import { dirname, join } from "node:path";
@@ -155,7 +155,7 @@ export async function run(argv) {
             limit,
         });
         reportResult(result);
-        console.log(JSON.stringify(result, null, 2));
+        printResult(JSON.stringify(result, null, 2));
         return 0;
     }
     catch (error) {