@uipath/maestro-builder-sdk 6.17.0 → 6.17.2

package/dist/core/connector-checks.js

@@ -321,18 +321,28 @@ export function checkConnectorSchema(where, spec, opts, dialect, report) {
     }
 }
 /**
- * The field contract and the binding names `compile` enforces, reported here first.
+ * The operation, its field contract and the binding names `compile` enforces,
+ * reported here first.
  *
- * Both rules run only with the facts in hand (a library for the fields, a
+ * Each rule runs only with the facts in hand (a library for the operation and its fields, a
  * bindings.json for the names); without them `check` stays a pure function of the
  * built model and says nothing, as before.
  */
 export function checkConnectorContract(where, spec, opts, report, 
 /** The activity's own id, for {@link connectionConnectorConflicts}; omit to record nothing. */
 id) {
-    const inputErr = opts.connectorInputs?.({ key: spec.key, action: spec.action, version: spec.version, object: spec.object }, spec.inputs ?? {});
-    if (inputErr) {
-        report({ level: 'error', code: 'CONNECTOR_INPUT', message: `${where}: ${inputErr}` });
+    const target = { key: spec.key, action: spec.action, version: spec.version, object: spec.object };
+    // The operation itself first: an operation compile cannot resolve has no field
+    // contract to check, and `connectorInputs` answers "unknown" for it.
+    const unresolved = opts.connectorResolveError?.(target);
+    if (unresolved) {
+        report({ level: 'error', code: unresolved.code, message: `${where}: ${unresolved.message}` });
+    }
+    else {
+        const inputErr = opts.connectorInputs?.(target, spec.inputs ?? {});
+        if (inputErr) {
+            report({ level: 'error', code: 'CONNECTOR_INPUT', message: `${where}: ${inputErr}` });
+        }
     }
     checkBindingLabels(where, spec, opts, (code, message) => report({ level: 'error', code, message }), { key: spec.key, action: spec.action }, id === undefined ? undefined : { id, connector: spec.key });
 }

package/dist/core/error-port.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Does a node definition have an `error` port? One answer for `check` and
+ * `serialize` (flow-builder-sdk#943).
+ *
+ * The product's rule, read from @uipath/flow-core and @uipath/flow-tool:
+ *
+ *  - the manifest client injects an `error` source handle into every served
+ *    definition with `supportsErrorHandling: true` that does not declare one
+ *    (`withErrorHandles` / `nodeSupportsErrorHandling`);
+ *  - `uip maestro flow validate` does the same when it checks edge handles
+ *    (`validateEdgeHandlesAgainstCurrentManifests`: `supportsErrorHandling ===
+ *    true` adds `error` to the node's source handles).
+ *
+ * So the flag alone grants the port. For instance, the manifest
+ * `registry get --local` returns for a sibling Flow or RPA project
+ * (`buildNodeManifest`) has `supportsErrorHandling: true` and only `input` +
+ * `output` handles, and an `error` edge from it is valid. A definition that
+ * declares an `error` source handle without the flag counts too.
+ */
+export declare function definitionHasErrorPort(def: any): boolean;
+/**
+ * The ONERROR_NO_ERROR_PORT sentence for a definition-backed node, naming its
+ * node type. Shared with serialize, which throws it for the same node.
+ */
+export declare function errorPortRefusal(stepName: string, def: any): string;

package/dist/core/error-port.js

@@ -0,0 +1,36 @@
+/**
+ * Does a node definition have an `error` port? One answer for `check` and
+ * `serialize` (flow-builder-sdk#943).
+ *
+ * The product's rule, read from @uipath/flow-core and @uipath/flow-tool:
+ *
+ *  - the manifest client injects an `error` source handle into every served
+ *    definition with `supportsErrorHandling: true` that does not declare one
+ *    (`withErrorHandles` / `nodeSupportsErrorHandling`);
+ *  - `uip maestro flow validate` does the same when it checks edge handles
+ *    (`validateEdgeHandlesAgainstCurrentManifests`: `supportsErrorHandling ===
+ *    true` adds `error` to the node's source handles).
+ *
+ * So the flag alone grants the port. For instance, the manifest
+ * `registry get --local` returns for a sibling Flow or RPA project
+ * (`buildNodeManifest`) has `supportsErrorHandling: true` and only `input` +
+ * `output` handles, and an `error` edge from it is valid. A definition that
+ * declares an `error` source handle without the flag counts too.
+ */
+export function definitionHasErrorPort(def) {
+    if (def?.supportsErrorHandling === true)
+        return true;
+    const groups = Array.isArray(def?.handleConfiguration) ? def.handleConfiguration : [];
+    return groups.some((g) => (Array.isArray(g?.handles) ? g.handles : [])
+        .some((h) => h?.id === 'error' && h?.type === 'source'));
+}
+/**
+ * The ONERROR_NO_ERROR_PORT sentence for a definition-backed node, naming its
+ * node type. Shared with serialize, which throws it for the same node.
+ */
+export function errorPortRefusal(stepName, def) {
+    return `Step "${stepName}" is a ${def?.nodeType}@${def?.version} node, and its definition has no error port: `
+        + `it does not set supportsErrorHandling: true and declares no "error" source handle, so the edge would leave a `
+        + `handle the node does not have. Handle the failure downstream instead, or pass the definition exactly as `
+        + `\`uip maestro flow registry get\` returns it.`;
+}

package/dist/core/expr.d.ts

@@ -145,8 +145,8 @@ export declare function ran(step: string): Expr;
  * The first five are what every error-capable node's definition declares
  * (`outputDefinition.error.schema`, `required`, `additionalProperties: false`).
  * `response` and `element` are NOT declared and are present at run time anyway —
- * measured on every family probed (2026-09-10), `element` carrying the id of the
- * step that failed. They are typed here because a field that exists should be
+ * measured on every family probed (2026-09-10), `element` carrying the label of
+ * the step that failed. They are typed here because a field that exists should be
  * readable; the declared five stay first because those are the contract.
  */
 export type ErrorEnvelopeField = 'code' | 'message' | 'detail' | 'category' | 'status' | 'response' | 'element';
@@ -166,15 +166,21 @@ export type ErrorEnvelopeField = 'code' | 'message' | 'detail' | 'category' | 's
  * | `category` | string | `'User'` |
  * | `status` | number | `404` |
  * | `response` | unknown | undeclared; `null` in every probe |
- * | `element` | string | undeclared; the id of the step that failed |
+ * | `element` | string | undeclared; the failing step's label |
  *
  * The last two resolve at run time — measured, a container handler reading
- * `element` came back with the failing body step's id — but they are absent from
- * the declared schema, so `uip maestro flow validate` reports
+ * `element` came back with the failing body step's label — but they are absent
+ * from the declared schema, so `uip maestro flow validate` reports
  * `EXPRESSION_DIAGNOSTIC: Property 'element' does not exist on type
  * '<Step>_Error'` for them. Valid, and noisy: prefer the declared five unless you
  * specifically need one of these.
  *
+ * **`element` is the step's canvas label (`display.label`), not its node id.** The
+ * label defaults to the step name, so it matches the name (not always the node
+ * id) only while no `label` is set: `.step('failA', …, { label: 'Fail A' })`
+ * failing gives `element: 'Fail A'`. Route on `code` / `message`, never on
+ * `element`.
+ *
  * **Which VARIABLE holds it is per node family, and this helper owns that.**
  * Measured on the product (2026-09-10), one debug run per family:
  *

package/dist/core/expr.js

@@ -179,15 +179,21 @@ export function ran(step) {
  * | `category` | string | `'User'` |
  * | `status` | number | `404` |
  * | `response` | unknown | undeclared; `null` in every probe |
- * | `element` | string | undeclared; the id of the step that failed |
+ * | `element` | string | undeclared; the failing step's label |
  *
  * The last two resolve at run time — measured, a container handler reading
- * `element` came back with the failing body step's id — but they are absent from
- * the declared schema, so `uip maestro flow validate` reports
+ * `element` came back with the failing body step's label — but they are absent
+ * from the declared schema, so `uip maestro flow validate` reports
  * `EXPRESSION_DIAGNOSTIC: Property 'element' does not exist on type
  * '<Step>_Error'` for them. Valid, and noisy: prefer the declared five unless you
  * specifically need one of these.
  *
+ * **`element` is the step's canvas label (`display.label`), not its node id.** The
+ * label defaults to the step name, so it matches the name (not always the node
+ * id) only while no `label` is set: `.step('failA', …, { label: 'Fail A' })`
+ * failing gives `element: 'Fail A'`. Route on `code` / `message`, never on
+ * `element`.
+ *
  * **Which VARIABLE holds it is per node family, and this helper owns that.**
  * Measured on the product (2026-09-10), one debug run per family:
  *

package/dist/core/library.d.ts

@@ -218,6 +218,25 @@ export interface LibraryOpts {
      */
     overlayDir?: string;
 }
+/** Why {@link Library.resolve} refused a connector action. */
+export type ConnectorResolveCode = 
+/** The library carries no such operation (or no such connector, or not at that version). */
+'CONNECTOR_NOT_IN_LIBRARY'
+/** A GENERIC operation (one entry per object) named without an `object`. */
+ | 'CONNECTOR_OBJECT_REQUIRED'
+/** An `object` on a single, non-generic operation. */
+ | 'CONNECTOR_OBJECT_NOT_GENERIC';
+/**
+ * The refusal {@link Library.resolve} throws, with a `code` for each reason.
+ *
+ * Typed so a caller can tell a refusal from a bug without matching on message
+ * text: `check` reports it under this code with this message, and a compile
+ * that throws it carries the same code into its `--json` diagnostics (#948).
+ */
+export declare class ConnectorResolveError extends Error {
+    readonly code: ConnectorResolveCode;
+    constructor(code: ConnectorResolveCode, message: string);
+}
 export declare class Library {
     private layers;
     /** The LIST-ENVELOPE LEDGER, overlay first so a prepared entry can add a row. */

package/dist/core/library.js

@@ -9,10 +9,26 @@
 import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { prepareCommand } from './cli-spelling.js';
+import { PULL_COMMAND } from './library-cache.js';
 import { editDistance } from './edit-distance.js';
 import { loadListEnvelopes, lookupListEnvelope } from './list-envelope.js';
 import { lookupSpecOf } from './lookups.js';
 import { loadByoaLedger, loadInvariantCollections, loadLookupResolutions } from './lookup-store.js';
+/**
+ * The refusal {@link Library.resolve} throws, with a `code` for each reason.
+ *
+ * Typed so a caller can tell a refusal from a bug without matching on message
+ * text: `check` reports it under this code with this message, and a compile
+ * that throws it carries the same code into its `--json` diagnostics (#948).
+ */
+export class ConnectorResolveError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'ConnectorResolveError';
+        this.code = code;
+    }
+}
 export class Library {
     layers = [];
     /** The LIST-ENVELOPE LEDGER, overlay first so a prepared entry can add a row. */
@@ -582,7 +598,7 @@ export class Library {
                 + `the library index (\`index.json\`), and remember the two namespaces: `
                 + `\`…connector.trigger.…\` starts a flow, \`…connector.event.…\` waits mid-flow.`
             : '';
-        throw new Error(`connector not in library: ${nodeType}${version ? '@' + version : ''}.${hint}`
+        throw new ConnectorResolveError('CONNECTOR_NOT_IN_LIBRARY', `connector not in library: ${nodeType}${version ? '@' + version : ''}.${hint}`
             + this.describeMiss(nodeType, version, objectName));
     }
     /**
@@ -622,7 +638,7 @@ export class Library {
             + where
             + ' Note the operation slug is the nodeType segment, NOT the tenant\'s `objectName`'
             + ' — `uip maestro case spec` reports the latter, and the two can differ.'
-            + ' If the operation is newer than the library, refresh it with `uip maestro flow registry pull --force`.';
+            + ` If the operation is newer than the library, refresh it with \`${PULL_COMMAND}\`.`;
     }
     /** Every direct operation id under `prefix` (no further dot), across layers, sorted and de-duplicated. */
     opsUnder(prefix) {
@@ -646,7 +662,7 @@ export class Library {
         return ` No connector "${key}" in the library (${keys.length} indexed).`
             + (near && near !== key ? ` Closest: ${near}.` : '')
             + where
-            + ' If the connector is newer than the library, refresh it with `uip maestro flow registry pull --force`.';
+            + ` If the connector is newer than the library, refresh it with \`${PULL_COMMAND}\`.`;
     }
     /**
      * The event half of {@link describeMiss}: which of the connector's EVENTS the
@@ -666,7 +682,7 @@ export class Library {
         const waits = this.opsUnder(`uipath.connector.event.${key}.`);
         // A start trigger resolves from either form; a mid-flow wait needs the `.event.` form itself.
         const usable = kind === 'trigger' ? [...new Set([...starts, ...waits])].sort() : waits;
-        const refresh = ' If the event is newer than the library, refresh it with `uip maestro flow registry pull --force`.';
+        const refresh = ` If the event is newer than the library, refresh it with \`${PULL_COMMAND}\`.`;
         if (usable.length) {
             if (usable.includes(asked)) {
                 // Only a version can make a carried event miss here: every other refusal
@@ -755,7 +771,7 @@ export class Library {
                         + `dispatch. If it is a typo, compile will not catch it.\n`);
                     return this.build(layer.dir, { ...only, objectName }, nodeType, { objectNameUnverified: true });
                 }
-                throw new Error(`connector ${nodeType} does not have an object "${objectName}": it is a single, `
+                throw new ConnectorResolveError('CONNECTOR_OBJECT_NOT_GENERIC', `connector ${nodeType} does not have an object "${objectName}": it is a single, `
                     + `non-generic operation addressing ${only.objectName ? `"${only.objectName}"` : 'no object'}. `
                     + `Drop the \`object\` option (it is only for generic operations, whose node type covers many objects).`);
             }
@@ -769,7 +785,7 @@ export class Library {
             .filter((o) => typeof o === 'string' && o.length > 0)
             .sort();
         if (objectName === undefined) {
-            throw new Error(`connector ${nodeType} is a GENERIC operation covering ${matches.length} objects — `
+            throw new ConnectorResolveError('CONNECTOR_OBJECT_REQUIRED', `connector ${nodeType} is a GENERIC operation covering ${matches.length} objects — `
                 + `say which one with the \`object\` option, e.g. `
                 + `connector('${nodeType.split('.').slice(2, 3)[0]}', '${nodeType.split('.').slice(3).join('.')}', `
                 + `{ … }, { object: '${objects[0] ?? '<object>'}' }). ${describeObjects(objects)}`);

package/dist/flow-sdk.d.ts

@@ -824,7 +824,7 @@ declare class StepList {
      * even a legal call: `out(step, path?)` takes two arguments.
      *
      * **Three ways the handler can end**: `.return(...)` answers the flow,
-     * `.terminate(...)` stops the run, and `h.rejoin('<step>')` compensates and
+     * `.terminate(...)` stops the run, and `h.stepToRef('<step>')` compensates and
      * hands control back to a step the success path also reaches — the shape most
      * deployed flows use. A handler that just runs out of steps still gets its own
      * End: rejoining is something the author SAYS, never something wiring infers.
@@ -838,8 +838,9 @@ declare class StepList {
      *
      * **A `.loop()` container takes one too.** `core.logic.loop` declares the
      * handle, and a body step's failure routes to it: the container's envelope
-     * carries the body's message in `detail` and the failing body step's id in
-     * `element`, and the instance completes rather than faulting. `.doWhile()` does
+     * carries the body's message in `detail` and the failing body step's label
+     * (`display.label`, which defaults to the step name) in `element`, and the
+     * instance completes rather than faulting. `.doWhile()` does
      * NOT — it declares an error variable and no error handle — so that one is
      * refused by name, and its failures belong to the body step that can fail.
      *
@@ -880,6 +881,10 @@ declare class StepList {
      * The body is its own path. It ends by answering (`.return`), stopping the run
      * (`.terminate`), or handing control back with `.stepToRef(...)`; a body that
      * simply runs out of steps gets its own End, exactly as an error handler does.
+     * It does not rejoin the main path. That End maps each flow output from its
+     * variable, as the End a flow falls off the bottom into does, so set the
+     * outputs on the way with `{ updates }` or end the body with `.return({…})`;
+     * `check` warns NO_RETURN when an output is left unset on that path.
      *
      * The main path is untouched — an edge out of a NON-default port is a side exit,
      * so whatever you chain after this call still belongs to the step's normal

package/dist/flow-sdk.js

@@ -402,7 +402,7 @@ class StepList {
      * even a legal call: `out(step, path?)` takes two arguments.
      *
      * **Three ways the handler can end**: `.return(...)` answers the flow,
-     * `.terminate(...)` stops the run, and `h.rejoin('<step>')` compensates and
+     * `.terminate(...)` stops the run, and `h.stepToRef('<step>')` compensates and
      * hands control back to a step the success path also reaches — the shape most
      * deployed flows use. A handler that just runs out of steps still gets its own
      * End: rejoining is something the author SAYS, never something wiring infers.
@@ -416,8 +416,9 @@ class StepList {
      *
      * **A `.loop()` container takes one too.** `core.logic.loop` declares the
      * handle, and a body step's failure routes to it: the container's envelope
-     * carries the body's message in `detail` and the failing body step's id in
-     * `element`, and the instance completes rather than faulting. `.doWhile()` does
+     * carries the body's message in `detail` and the failing body step's label
+     * (`display.label`, which defaults to the step name) in `element`, and the
+     * instance completes rather than faulting. `.doWhile()` does
      * NOT — it declares an error variable and no error handle — so that one is
      * refused by name, and its failures belong to the body step that can fail.
      *
@@ -464,7 +465,7 @@ class StepList {
         // `@2.4`, gated on `errorHandlingEnabled` like every other error handle), and
         // the platform routes it: a body step throwing inside a measured run left the
         // instance Completed with the container's envelope published — `detail` the
-        // body's own message, `element` the id of the body step that failed.
+        // body's own message, `element` the label of the body step that failed.
         //
         // `.doWhile()` is NOT: `core.logic.dowhile@1.0` declares an error VARIABLE
         // and no error HANDLE, so an edge would leave a handle the node does not
@@ -494,6 +495,10 @@ class StepList {
      * The body is its own path. It ends by answering (`.return`), stopping the run
      * (`.terminate`), or handing control back with `.stepToRef(...)`; a body that
      * simply runs out of steps gets its own End, exactly as an error handler does.
+     * It does not rejoin the main path. That End maps each flow output from its
+     * variable, as the End a flow falls off the bottom into does, so set the
+     * outputs on the way with `{ updates }` or end the body with `.return({…})`;
+     * `check` warns NO_RETURN when an output is left unset on that path.
      *
      * The main path is untouched — an edge out of a NON-default port is a side exit,
      * so whatever you chain after this call still belongs to the step's normal

package/dist/serialize.js

@@ -15,6 +15,7 @@ import { FlowAction, FlowTrigger } from './core/node-classes.js';
 import { connectorRawNodeRefusal } from './core/connector-raw-node.js';
 import { dataFabricUnknownInputs } from './core/typed-raw-node.js';
 import { planContributionBindings } from './core/contribution-bindings.js';
+import { definitionHasErrorPort, errorPortRefusal } from './core/error-port.js';
 import { isAnswerField } from './core/hitl-answers.js';
 import { connectionConnectors } from './bindings-v2.js';
 import { BindingRefusal, GUID_RE, bindingMissingMessage, bindingSelfNameMessage, bindingUndeclaredMessage, missingBindingLabels, undeclaredBinding } from './core/binding-messages.js';
@@ -4375,9 +4376,9 @@ function newScope(outputs, vars = []) {
  * note at `uipath.ts:118-123`, MST-9544).
  */
 /**
- * Wire every parked `.rejoin('<step>')` edge, now that the whole scope exists.
+ * Wire every parked `.stepToRef('<step>')` edge, now that the whole scope exists.
  *
- * An unresolved target should be impossible — `check`'s REJOIN_UNKNOWN_TARGET
+ * An unresolved target should be impossible — `check`'s REF_UNKNOWN_TARGET
  * runs first and names the steps that do exist — but a serializer that silently
  * dropped the edge would emit a flow whose handler goes nowhere, which is the
  * exact class of failure `.onError` used to have (an error path that vanishes in
@@ -4577,10 +4578,11 @@ function isTypeDesc(type) {
  *
  * Emitting the full set is not cosmetic. The product's output-mapping rule warns
  * `MISSING_OUTPUT_MAPPING` once per (End node × unmapped output variable), and
- * the SDK used to leave three whole classes unmapped: the implicit End node a
- * flow falls off the bottom into, every `.var(…)` anywhere, and any output a
- * `.return(…)` didn't name. A four-output flow with two End nodes could collect
- * eight warnings for a graph that was completely correct.
+ * an End with no map answers the run with nothing. So every End site goes
+ * through `emitEnd`, which calls this: the implicit End a flow falls off the
+ * bottom into, a `.return(…)`'s End, the End a `.stepToList` / `.onError` body
+ * gets when it runs out of steps, and the End for a `.stepSwitch` exit with no
+ * arm (or a human task's `action: 'End'` outcome).
  */
 function endOutputs(scope, explicit = {}) {
     const outs = {};
@@ -4636,8 +4638,8 @@ function renameRefs(text, rename) {
 /** Every step name a flow declares in its own scope (not its children's). */
 function stepNamesOf(steps, out = []) {
     for (const s of steps) {
-        // `return` and `rejoin` carry a synthetic `name` and create no node named
-        // after it (an End id is claimed as `end`; a rejoin is one edge).
+        // `return` carries a synthetic `name` but creates no node named after it (an
+        // End id is claimed as `end`); `stepToRef` has no `name` at all (it is one edge).
         if ('name' in s && s.kind !== 'return')
             out.push(s.name);
         if (s.kind === 'branch') {
@@ -4679,6 +4681,18 @@ export function serialize(built, opts = {}) {
      * A bindings entry the node does not reference is not a bound resource.
      */
     const resourceBindings = new Map();
+    /**
+     * The resolved definition of every contribution-lowered node, by node id, so an
+     * `error` edge from one can be checked against its definition (#943). Typed
+     * families are not recorded: their definitions are the SDK's own.
+     */
+    const contributionDefs = new Map();
+    /** Refuse an `error` edge from a contribution-lowered node whose definition has no error port. */
+    function refuseErrorEdgeWithoutPort(nodeId, stepName) {
+        const def = contributionDefs.get(nodeId);
+        if (def !== undefined && !definitionHasErrorPort(def))
+            throw new Error(errorPortRefusal(stepName, def));
+    }
     /**
      * Hoist a contribution's own bindings, then close every `<bindings.NAME>` its
      * definition references and it did not supply, from the definition's own
@@ -4785,7 +4799,7 @@ export function serialize(built, opts = {}) {
     /**
      * `uid` for a node that IS an author's step, recording which id that step got.
      *
-     * `.rejoin('<step>')` names a step, and the id it was emitted under is not
+     * `.stepToRef('<step>')` names a step, and the id it was emitted under is not
      * derivable from the name: `uid` sanitizes, de-duplicates against every id in
      * the file, and hands a subflow COPY a prefixed one from the rename map. So
      * the mapping is recorded where it is decided rather than reconstructed later
@@ -4868,6 +4882,32 @@ export function serialize(built, opts = {}) {
             node.parentId = o.parentId;
         return node;
     }
+    /**
+     * Emit an End node, map the flow's outputs on it, and wire `tails` into it.
+     *
+     * Every End goes through here: the `.return()` End, the End a root or
+     * subflow path falls off into, a `.stepToList` / `.onError` body that runs
+     * out of steps, a `.stepSwitch` exit with no arm, and a fan-out human task's
+     * `action: 'End'` outcome. An End finishes the run, and the run's outputs are
+     * whatever its `outputs` map says, so an End built without that map answers
+     * with nothing at all, even on a path that set every output variable
+     * (flow-builder-sdk#742). Building the node and its mappings in one place
+     * makes that impossible to forget.
+     *
+     * `explicit` holds the sources a `.return({…})` named; every other output
+     * maps to its own variable (`endOutputs`).
+     */
+    function emitEnd(scope, id, tails, o = {}) {
+        const node = makeNode(NODE_TYPE.end, id, o.label ?? 'End', { parentId: o.parentId, requestedVersion: o.requestedVersion });
+        node.inputs = {};
+        const outs = endOutputs(scope, o.explicit);
+        if (Object.keys(outs).length)
+            node.outputs = outs;
+        scope.nodes.push(node);
+        for (const t of tails)
+            addEdge(scope, t, id);
+        return node;
+    }
     /**
      * Emit a child flow into its own scope and register it under the calling
      * node's id — that key is how the format names a subflow body, and how
@@ -4908,19 +4948,10 @@ export function serialize(built, opts = {}) {
         start.inputs = {};
         scope.nodes.push(start);
         const tails = emit(child.steps, [{ node: startId, port: 'output' }], scope);
-        if (tails.length) {
-            const endId = uid(scope, 'end');
-            const end = makeNode(NODE_TYPE.end, endId, 'End');
-            end.inputs = {};
-            // Same as the root's implicit End — mapped against the SUBFLOW's own
-            // outputs, which is the scope the product validates a subflow body in.
-            const outs = endOutputs(scope);
-            if (Object.keys(outs).length)
-                end.outputs = outs;
-            scope.nodes.push(end);
-            for (const t of tails)
-                addEdge(scope, t, endId);
-        }
+        // Same as the root's implicit End — mapped against the SUBFLOW's own
+        // outputs, which is the scope the product validates a subflow body in.
+        if (tails.length)
+            emitEnd(scope, uid(scope, 'end'), tails);
         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) });
@@ -5120,6 +5151,7 @@ export function serialize(built, opts = {}) {
             node.outputs = { ...(node.outputs ?? {}), ...subNodeId(clone(contribution.outputs), id) };
         }
         hoistContributionBindings(def, contribution.bindings, where);
+        contributionDefs.set(id, def);
         scope.nodes.push(node);
         for (const t of tails)
             addEdge(scope, t, id);
@@ -6457,7 +6489,7 @@ export function serialize(built, opts = {}) {
      * The handler is its OWN path, and it still is: its leftover tails get their
      * own End rather than rejoining the chain, because `.onError` must not
      * SILENTLY change what runs after the step. What changed is that an author can
-     * now ASK — `h.rejoin('<step>')` emits an edge into a step the success path
+     * now ASK — `h.stepToRef('<step>')` emits an edge into a step the success path
      * also reaches, and returns no tail, so nothing is capped. Never inferred:
      * a handler that just runs out of steps ends exactly as it always did.
      *
@@ -6477,11 +6509,7 @@ export function serialize(built, opts = {}) {
      * outcome.
      */
     function endExit(scope, nodeId, port, stepName, parentId) {
-        const endId = uid(scope, `${stepName}${port.charAt(0).toUpperCase()}${port.slice(1)}End`);
-        const end = makeNode(NODE_TYPE.end, endId, 'End', parentId ? { parentId } : {});
-        end.inputs = {};
-        scope.nodes.push(end);
-        addEdge(scope, { node: nodeId, port }, endId);
+        emitEnd(scope, uid(scope, `${stepName}${port.charAt(0).toUpperCase()}${port.slice(1)}End`), [{ node: nodeId, port }], { parentId });
     }
     /**
      * Refuse a side exit on a human task's port that the step's tails already
@@ -6522,16 +6550,17 @@ export function serialize(built, opts = {}) {
             throw new Error(`.stepToList('${step.port}', …) after step "${source}": emitted node "${nodeId}" not found in scope`);
         // Only the error port carries this: without it the platform routes but Studio
         // Web HIDES the handle, so no human can see the handler.
-        if (step.port === 'error')
+        if (step.port === 'error') {
+            refuseErrorEdgeWithoutPort(nodeId, source);
             node.inputs = { ...(node.inputs ?? {}), errorHandlingEnabled: true };
+        }
         const handlerTails = emit(handler, [{ node: nodeId, port: step.port }], scope, parentId, breakTarget);
+        // A body that runs out of steps ends the run on an End of its own (no
+        // merge-back is inferred). That End maps the outputs like any other, so a
+        // body that set them with `{ updates }` still answers (#742).
         if (handlerTails.length) {
             const endId = uid(scope, `${source}${step.port === 'error' ? 'Error' : step.port.charAt(0).toUpperCase() + step.port.slice(1)}End`);
-            const end = makeNode(NODE_TYPE.end, endId, 'End', parentId ? { parentId } : {});
-            end.inputs = {};
-            scope.nodes.push(end);
-            for (const t of handlerTails)
-                addEdge(scope, t, endId);
+            emitEnd(scope, endId, handlerTails, { parentId });
         }
         return tails;
     }
@@ -6653,8 +6682,8 @@ export function serialize(built, opts = {}) {
                     routed.add(exit.port);
                     // Arms CONVERGE, exactly as `.switch()`'s do: every arm that does not
                     // end in `.return()` contributes its tail, so the next step fans in
-                    // from all of them. (`.stepToList` instead gives each arm a private
-                    // End, which silently drops the flow's outputs on that path —
+                    // from all of them. (`.stepToList` instead gives an arm that runs out
+                    // of steps an End of its own; `emitEnd` maps the outputs on it,
                     // flow-builder-sdk#742.)
                     const caseTails = emit(c.body, [{ node: nodeId, port: exit.port }], scope, parentId, breakTarget);
                     if (caseTails.length === 0 && stopsAtEnd(c.body))
@@ -6924,6 +6953,7 @@ export function serialize(built, opts = {}) {
                         throw new Error(`.stepToRef('${step.port}', '${step.target}') has no step to leave from.`);
                     refuseRewire('.stepToRef', step.port, lastAction ?? '?', tails);
                     if (step.port === 'error') {
+                        refuseErrorEdgeWithoutPort(from.node, lastAction ?? from.node);
                         const node = scope.nodes.find((n) => n.id === from.node);
                         if (node)
                             node.inputs = { ...(node.inputs ?? {}), errorHandlingEnabled: true };
@@ -6936,8 +6966,6 @@ export function serialize(built, opts = {}) {
                 // source must be able to ask for the id the original file had, or the
                 // round trip cannot reproduce its own layout block (ReturnOptions.name).
                 const id = uid(scope, step.options?.name ?? 'end');
-                const node = makeNode(NODE_TYPE.end, id, step.options?.label ?? 'End', { parentId, requestedVersion: step.options?.version });
-                node.inputs = {};
                 const explicit = {};
                 const updates = [];
                 for (const [name, expr] of Object.entries(step.values)) {
@@ -6948,12 +6976,7 @@ export function serialize(built, opts = {}) {
                     // variable; a variableUpdate for one would be a no-op assignment.
                     updates.push({ variableId: name, expression: src });
                 }
-                const outs = endOutputs(scope, explicit);
-                if (Object.keys(outs).length)
-                    node.outputs = outs;
-                scope.nodes.push(node);
-                for (const t of tails)
-                    addEdge(scope, t, id);
+                emitEnd(scope, id, tails, { label: step.options?.label, parentId, requestedVersion: step.options?.version, explicit });
                 const extra = step.options?.updates ?? {};
                 for (const name of Object.keys(extra)) {
                     if (name in step.values) {
@@ -6969,20 +6992,11 @@ export function serialize(built, opts = {}) {
         return tails;
     }
     const finalTails = emit(built.steps, [{ node: built.triggerId ?? 'start', port: 'output' }], root);
-    if (finalTails.length) {
-        const id = uid(root, 'end');
-        const node = makeNode(NODE_TYPE.end, id, 'End');
-        node.inputs = {};
-        // The implicit End a flow falls off the bottom into still terminates the
-        // flow, so it maps the flow's outputs — each to itself, since no `.return`
-        // named a value here.
-        const outs = endOutputs(root);
-        if (Object.keys(outs).length)
-            node.outputs = outs;
-        root.nodes.push(node);
-        for (const t of finalTails)
-            addEdge(root, t, id);
-    }
+    // The implicit End a flow falls off the bottom into still terminates the
+    // flow, so it maps the flow's outputs — each to itself, since no `.return`
+    // named a value here.
+    if (finalTails.length)
+        emitEnd(root, uid(root, 'end'), finalTails);
     // ── Additional entry points (design §5.1) ────────────────────────────────
     // Emitted AFTER the shared body so their prefixes can join it by name. Once a
     // flow has more than one root, every root carries the platform's entry-point

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.17.0",
+  "version": "6.17.2",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -92,5 +92,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "c6e35983af98d4dc81b45aaee8a9bb0419bc1cc2"
+  "gitref": "629eba0e7332894902dec4cd1ef5c7072c02adf6"
 }