@uipath/maestro-builder-sdk 6.24.0 → 6.25.0

package/dist/serialize.js

@@ -7,7 +7,6 @@
  * the platform emits, so the result passes `uip maestro flow validate`.
  */
 import { readFileSync } from 'node:fs';
-import { createHash } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { BUNDLED_DEFINITIONS, bundledVersions } from './flow-definitions.js';
@@ -21,19 +20,19 @@ import { declaredErrorPortRefusal, definitionHasErrorPort, errorPortRefusal } fr
 import { FLOW_NODE_TYPES } from './flow-node-registry.js';
 import { stepExits } from './flow-step-exits.js';
 import { resolveVersion } from './core/nodes/versioned.js';
-import { isAnswerField } from './core/hitl-answers.js';
+import { FORM_FIELD_JSON_TYPE } from './core/form-field-type.js';
 import { connectionConnectors } from './bindings-v2.js';
 import { BindingRefusal, GUID_RE, bindingLabelRefusal, bindingMissingMessage, missingBindingLabels } from './core/binding-messages.js';
 import { ByoaRefusal, byoaUnverified } from './core/byoa.js';
 import { genericEventObjectRefusal } from './core/event-checks.js';
-import { OUTCOME_HANDLE_NODE_TYPES, assertHitlExitInvariant, hitlExitModel, hitlExitViolation, outcomeIdOf, outcomeSlug } from './core/hitl-routing.js';
+import { OUTCOME_HANDLE_NODE_TYPES, assertHitlExitInvariant, hitlExitViolation, outcomeSlug } from './core/hitl-routing.js';
 import { STICKY_NOTE_TYPE, STICKY_NOTE_TYPE_VERSION } from './core/definitionless-node-types.js';
 import { placeholderPosition } from './node-placement.js';
 import { hasExits } from './core/step-ports.js';
 import { stopsAtEnd } from './flow-step-tree.js';
 import { assertNodeEnvelope } from './core/node-envelope.js';
 import { buildConfiguration } from './config.js';
-import { fnv1aX4Uuid, stableId } from './core/stable-id.js';
+import { fnv1aX4Uuid, schemaId, stableId } from './core/stable-id.js';
 import { readEventFilter, eventFilterProblem, eventFilterJmes, eventFilterTreeLeaf, jmesString, jmesStringProblem } from './core/event-filters.js';
 import { FLOW_EXPR_DIALECT } from './core/connector-checks.js';
 import { buildConnectorInputs, connectorInputErrors as coreConnectorInputErrors, multipartBodyFieldName, transportHttpMethod } from './core/connector-inputs.js';
@@ -95,16 +94,12 @@ const NODE_TYPE = {
     conversationalAgent: 'uipath.agent.conversational',
     createOutgoingCall: 'uipath.conversational.voice.create-outgoing-call',
     endCall: 'uipath.conversational.voice.end-call',
-    hitl: 'uipath.human-in-the-loop',
     // The two other spellings of the SAME human task, both resolvable on this
     // tenant. `hitl()` emits the base type unless `variant` names one of these;
     // all three share the model (`bpmn:UserTask` / `Actions.HITL`), the single
     // `completed` handle and the `output`/`status` output pair, so only the type
     // string and the form's OWNER differ. (A third, `…​.document-validation`, is
     // `AvailableOnTenant: false` — no definition resolves, so it is not here.)
-    hitlQuickForm: 'uipath.human-in-the-loop.quick-form',
-    hitlActionApp: 'uipath.human-in-the-loop.coded-action-app',
-    hitlDocValidation: 'uipath.human-in-the-loop.document-validation',
     // The PLATFORM's placeholder — "a real node goes here later". Not the engine's
     // fixture-returning `kind: 'mock'` test construct, which shares only the name
     // (#125). The definition declares no `inputDefinition` and one output whose
@@ -2998,245 +2993,6 @@ function scheduleInputs(inputs, nodeId) {
         ...(isPreset ? {} : { timerValue: every }),
     };
 }
-/** JSON-Schema type per form-field type, as flow-v1's form serializer maps them (quick-form escalations and human tasks). */
-const FORM_FIELD_JSON_TYPE = {
-    text: { type: 'string' },
-    number: { type: 'number' },
-    boolean: { type: 'boolean' },
-    'date-time': { type: 'string', format: 'date-time' },
-};
-/**
- * A human task's inputs, and the outputs its form implies.
- *
- * Three things the author does not state and the platform needs:
- *
- * 1. **`type: 'quick'`** — the node type carries both an inline quick form and an
- *    App-backed task, selected by this field. flow-v1's serializer defaults an
- *    absent value to `quick`, but a reader cannot rely on that default, so the
- *    serializer writes it (the same "the encoding is the serializer's job" call as
- *    the scheduled trigger's `timerPreset`/`timerValue` split). **Only on the base
- *    node type**: on either suffixed variant the node TYPE is the choice, so no
- *    `inputs.type` is written — 165 of the 175 deployed `.quick-form` instances
- *    omit it, neither variant's definition declares it, and flow-v1's serializer
- *    DERIVES its `hitlType` from the node type rather than reading the field
- *    (`hitl-serialization.ts:140-146`).
- * 2. **`recipient`** — who gets the task. Emitted from the definition's own
- *    `inputDefaults`: Email + Action Center, assigned to a group. That is what
- *    203 of 233 deployed, debug-green v1 human tasks carry, unchanged.
- * 3. **`schema.schemaId`** — the stable id the backend caches the form under
- *    (229 of those 233 flows have one). Derived from the flow and node ids so the
- *    emitted `.flow` is byte-stable across builds.
- *
- * And the outputs, which the DEFINITION cannot declare: a quick form's result keys
- * are its own answer fields, so `uipath.human-in-the-loop@1.0` says only
- * `output: { type: 'object' }` and the instance carries the shape — `properties`
- * per answer field plus `Action` enumerated over the outcome names, and `status`
- * (the platform's `=result.Action` projection) enumerated the same way. This is
- * exactly what deployed v1 flows carry, and it is what lets `gen-tests` synthesize
- * a replay fixture a downstream read can actually use.
- */
-function hitlInputs(inputs, nodeId, flowId, label, rename) {
-    const nodeType = hitlNodeType(inputs);
-    const isApp = nodeType === NODE_TYPE.hitlActionApp;
-    const fields = (inputs?.fields ?? []).map((f) => {
-        const base = {
-            id: f.id,
-            label: f.label ?? f.id,
-            type: f.type,
-            direction: f.direction,
-        };
-        if (f.direction === 'input') {
-            // The platform reads a field's `binding` as a variable PATH (`vars.…`),
-            // not as an expression — so the Expr's `$vars.x` form is rewritten here
-            // rather than asked of the author.
-            base.binding = bindingPath(f.value, rename);
-        }
-        else if (f.direction === 'inOut') {
-            // Pre-filled AND editable: `binding` is the canonical pre-fill (the data
-            // contract flow-v1's serializer reads), and the WRITE target is the field
-            // id itself — deliberately decoupled from the binding, so no `variable`.
-            base.binding = bindingPath(f.value, rename);
-            if (f.required)
-                base.required = true;
-        }
-        else {
-            // The answer's landing variable. The platform falls back to the field id
-            // when this is absent; naming it keeps the emitted flow explicit and
-            // matches what the designer writes.
-            base.variable = `vars.${f.id}`;
-            if (f.required)
-                base.required = true;
-        }
-        return base;
-    });
-    const outcomes = (inputs?.outcomes ?? []).map((o, i) => {
-        const name = typeof o === 'string' ? o : o?.name;
-        const action = typeof o === 'string' ? 'Continue' : (o?.action ?? 'Continue');
-        return { id: outcomeIdOf(o, i), name, type: 'string', isPrimary: i === 0, action };
-    });
-    const properties = {};
-    for (const f of inputs?.fields ?? []) {
-        // inOut fields land in the answers too — their reviewed value flows back.
-        if (!isAnswerField(f))
-            continue;
-        properties[f.id] = { ...ownEntry(FORM_FIELD_JSON_TYPE, String(f.type)) };
-    }
-    const names = outcomes.map((o) => o.name).filter((n) => typeof n === 'string');
-    if (names.length > 0) {
-        properties.Action = { type: 'string', enum: names, default: names[0] };
-    }
-    // The app reference and its input map, for the `action-app` variant only. The
-    // keys are flow-v1's own app-picker names (`name`/`key`/`folderPath`, plus the
-    // `appSystemName` that stays null until an app's first deployment); the
-    // bindings map the app's OWN parameter names to `=`-prefixed expressions,
-    // which is the form v1's serializer turns into `HitlTaskArguments`.
-    const app = inputs?.app;
-    const appInputBindings = {};
-    for (const [name, value] of Object.entries(app?.inputs ?? {})) {
-        appInputBindings[name] = appBindingExpr(value, rename);
-    }
-    // The author's recipient when given; the definition's own default otherwise
-    // (unchanged — that default is what 203 of 233 deployed v1 tasks carry).
-    const defaultRecipient = jsonClone(defByType.get(nodeType)?.inputDefaults?.recipient ?? {});
-    const r = inputs?.recipient;
-    const recipient = r
-        ? {
-            channels: r.channels ?? (defaultRecipient.channels ?? []),
-            // Preserve the default's shape: quick-form's default carries an empty
-            // `connections` map, the others none — keep whichever, unless the
-            // author supplies their own.
-            ...(r.connections !== undefined
-                ? { connections: r.connections }
-                : 'connections' in defaultRecipient ? { connections: defaultRecipient.connections } : {}),
-            assignee: {
-                type: r.assignee.type,
-                ...(r.assignee.value !== undefined ? { value: r.assignee.value } : {}),
-                ...(r.assignee.displayName !== undefined ? { displayName: r.assignee.displayName } : {}),
-            },
-        }
-        : defaultRecipient;
-    // Document Validation carries the station's own inputs instead of a form; the
-    // expressions ride as `=js:` strings, EV-wrapped by the profile migration like
-    // any other input (the family is not in UNWRAPPED_INPUTS).
-    // The station's expression fields ride as PLAIN `$vars.…` strings — the
-    // property panel's own placeholder shape, and what the platform validator
-    // reads (it string-checks them directly; an ExpressionValue envelope fails
-    // with "extractionResult?.trim is not a function").
-    const docPath = (v) => {
-        const e = toExpr(v);
-        return e.literal ? String(e.value) : renameRefs(e.js, rename);
-    };
-    const doc = inputs?.document;
-    const docvalInputs = nodeType === NODE_TYPE.hitlDocValidation && doc
-        ? {
-            validationRenderType: doc.render ?? 'standard',
-            extractionResult: docPath(doc.extractionResult),
-            ...(doc.storageBucket !== undefined ? { storageBucket: doc.storageBucket } : {}),
-            ...(doc.documentId !== undefined ? { documentId: doc.documentId } : {}),
-            ...(doc.taxonomy !== undefined ? { taxonomy: docPath(doc.taxonomy) } : {}),
-        }
-        : {};
-    // 1.2's error output, verbatim from the bundled definition — the instance
-    // outputs replace the definition's (see the caller), so the slot is re-added
-    // here when the author asked for it.
-    const errorOutput = inputs?.exposeError
-        ? DEFS['uipath.human-in-the-loop@1.2']?.outputDefinition?.error
-        : undefined;
-    return {
-        inputs: {
-            // The base node type alone needs the discriminator — see the doc block.
-            ...(nodeType === NODE_TYPE.hitl ? { type: 'quick' } : {}),
-            title: inputs?.title ?? label,
-            priority: inputs?.priority ?? 'Low',
-            ...(inputs?.labels !== undefined ? { labels: inputs.labels } : {}),
-            recipient,
-            ...docvalInputs,
-            ...((isApp || (nodeType === NODE_TYPE.hitlDocValidation && doc?.render === 'custom')) && app
-                ? {
-                    app: {
-                        displayName: app.name,
-                        name: app.name,
-                        key: app.key,
-                        folderPath: app.folderPath,
-                        ...(app.appSystemName !== undefined ? { appSystemName: app.appSystemName } : {}),
-                    },
-                    ...(Object.keys(appInputBindings).length > 0 ? { appInputBindings } : {}),
-                }
-                : {}),
-            // The app variant still carries a `schema` — with NO fields (the app owns
-            // the form) but WITH the outcomes, because the flow's own routing and its
-            // `Action`/`status` outputs are derived from them. Both of flow-v1's
-            // app-task node references write exactly this shape.
-            schema: { schemaId: schemaId(flowId, nodeId), fields, outcomes },
-        },
-        outputs: {
-            output: {
-                type: 'object',
-                description: 'Task result data',
-                source: '=result',
-                var: 'output',
-                ...(Object.keys(properties).length > 0 ? { properties } : {}),
-            },
-            status: {
-                type: 'string',
-                description: 'Task completion status',
-                source: '=result.Action',
-                var: 'status',
-                ...(names.length > 0 ? { enum: names, default: names[0] } : {}),
-            },
-            ...(errorOutput !== undefined ? { error: jsonClone(errorOutput) } : {}),
-        },
-    };
-}
-/**
- * Which of the three human-task node types this step emits.
- *
- * `undefined` is deliberately the base type and not an alias for `.quick-form`:
- * the default emission must not change, so a flow authored before `variant`
- * existed compiles to the same bytes it always did.
- */
-function hitlNodeType(inputs) {
-    if (inputs?.variant === 'quick-form')
-        return NODE_TYPE.hitlQuickForm;
-    if (inputs?.variant === 'action-app')
-        return NODE_TYPE.hitlActionApp;
-    if (inputs?.variant === 'document-validation')
-        return NODE_TYPE.hitlDocValidation;
-    return NODE_TYPE.hitl;
-}
-/**
- * One `appInputBindings` value: the expression sent to a deployed app's input.
- *
- * flow-v1 writes these `=`-prefixed and WITHOUT `js:` (`"=vars.<node>.output.<f>"`
- * — `hitl-node-apptask.md`), and its serializer normalizes each to `=js:<body>`
- * when it builds `HitlTaskArguments`. So the flow-level form is the bare
- * `=`-prefixed path, which is what our own `$vars.` expressions become once the
- * prefix is dropped. A plain string passes through as written.
- */
-function appBindingExpr(value, rename) {
-    if (!(value instanceof Expr))
-        return String(value ?? '');
-    const js = renameRefs(value.js, rename).trim();
-    const path = js.startsWith('$vars.') ? js.slice('$vars.'.length) : js;
-    return path.startsWith('=') ? path : `=${path.startsWith('vars.') ? path : `vars.${path}`}`;
-}
-/**
- * A shown field's `binding`: the platform resolves it as a path against the
- * workflow's variables (`vars.<flowInput>`, `vars.<node>.output.<field>`), so the
- * `$vars.` prefix our expressions carry is dropped. A computed expression cannot
- * be a path — `check` rejects one (HITL_FIELD_VALUE_NOT_PATH) before we get here.
- */
-function bindingPath(value, rename) {
-    if (!(value instanceof Expr))
-        return String(value ?? '');
-    const js = renameRefs(value.js, rename).trim();
-    const path = js.startsWith('$vars.') ? js.slice('$vars.'.length) : js;
-    // `vars.`-prefixed, which is what 526 of 528 bound fields in deployed v1 flows
-    // carry. flow-v1's serializer does prefix a bare identifier itself
-    // (`hitl-serialization.ts`), but only for `HitlTaskArguments` — the
-    // `__hitlInputBindings` the designer reads back stores the binding verbatim.
-    return path.startsWith('vars.') ? path : `vars.${path}`;
-}
 /**
  * `Approve` → `approve`; a name that slugifies to nothing falls back to its index.
  * The same rule that names the `outcome-<id>` ports (`outcomeSlug`), so an id
@@ -3245,22 +3001,6 @@ function bindingPath(value, rename) {
 function outcomeId(name, index) {
     return outcomeSlug(name, index);
 }
-/**
- * A deterministic UUID for the form schema, derived from the flow and node ids.
- *
- * The platform uses `schemaId` to identify and cache a form, so it has to be
- * stable across builds of the same flow — a random one would make every rebuild a
- * different form and every emitted `.flow` a different file. Shaped as a v5 UUID
- * (SHA-1 based, version + variant bits set) because that is what the field holds.
- */
-function schemaId(flowId, nodeId) {
-    const h = createHash('sha1').update(`uipath.human-in-the-loop:${flowId}:${nodeId}`).digest();
-    const b = Buffer.from(h.subarray(0, 16));
-    b[6] = (b[6] & 0x0f) | 0x50;
-    b[8] = (b[8] & 0x3f) | 0x80;
-    const hex = b.toString('hex');
-    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
 /**
  * `serialize`, plus the extra files the flow needs on disk beside it.
  *
@@ -3629,7 +3369,6 @@ function describeDeclared(bindings) {
  */
 export function bundledActionNodeType(spec) {
     switch (spec?.kind) {
-        case 'hitl': return hitlNodeType(spec.inputs);
         case 'inlineAgent': return INLINE_AGENT_TYPE;
         case 'subflow':
         case 'createOutgoingCall':
@@ -3686,10 +3425,8 @@ export function perCallDefinition(spec) {
  * The definition version serialize emits for a typed action step that is not
  * yet on the node-type registry: the author's `{ version }` when given,
  * otherwise the version the step's inputs select, otherwise `undefined` (the
- * pinned default). Two such families pick a version themselves:
- *
- *  - `hitl`: `exposeError` selects `@1.2`, per-outcome routing selects `@1.1`;
- *  - `inlineAgent`: the newest bundled version, not the first bundled entry.
+ * pinned default). One such family picks a version itself: `inlineAgent`
+ * takes the newest bundled version, not the first bundled entry.
  *
  * The emit paths read their version here, and `check` resolves the definition
  * it asks about with this same version (#1041), so the two cannot pick
@@ -3704,23 +3441,10 @@ export function actionVersion(spec, explicit) {
     // Keyed by the node type `bundledActionNodeType` already picks, so the
     // version rule adds no second dispatch on the step's kind.
     const type = bundledActionNodeType(spec);
-    if (type === NODE_TYPE.hitl)
-        return hitlNeededVersion(spec?.inputs);
     if (type === INLINE_AGENT_TYPE)
         return INLINE_AGENT_DEFAULT_VERSION;
     return undefined;
 }
-/**
- * The base human task version a task's inputs need when nothing is pinned:
- * `exposeError` needs 1.2 (it adds the `error` output), and a task that
- * routes per outcome needs 1.1. Only the base task reaches here: a variant
- * (quick-form, app task) has its own node type and one definition.
- */
-function hitlNeededVersion(inputs) {
-    if (inputs?.exposeError)
-        return '1.2';
-    return hitlExitModel(inputs, undefined).shape === 'per-outcome' ? '1.1' : undefined;
-}
 /**
  * The bundled definition of `nodeType` that `makeNode` resolves: the author's
  * exact `{ version }` when given, otherwise the pinned default (the first
@@ -4972,14 +4696,6 @@ export function serialize(built, opts = {}) {
     function successPort(type) {
         if (type === NODE_TYPE.loop)
             return 'success';
-        // Every human-task definition declares one static source handle, `completed`.
-        // It is the real exit only where the product draws it: action-app,
-        // document-validation, and a task with no outcomes. A base or quick-form task
-        // with outcomes leaves on `outcome-<id>` instead (`hitlExitModel`), and never
-        // reaches this function for its tail.
-        if (type === NODE_TYPE.hitl || type === NODE_TYPE.hitlQuickForm || type === NODE_TYPE.hitlActionApp
-            || type === NODE_TYPE.hitlDocValidation)
-            return 'completed';
         // The inline agent's forward handle is `success`, not `output` — its definition
         // declares `success` (with `isDefaultForType`) + `error` on the right, and 29 of
         // 29 deployed instances wire the outgoing edge to `success`. The PUBLISHED agent
@@ -5049,7 +4765,12 @@ export function serialize(built, opts = {}) {
             delete node.model;
         node.inputs = renderDeep(contribution.inputs ?? {}, scope.rename);
         if (contribution.outputs) {
-            node.outputs = { ...(node.outputs ?? {}), ...subNodeId(jsonClone(contribution.outputs), id) };
+            // Replaced outputs are the instance's own, written verbatim: a human task's
+            // come from its form, where a literal `{nodeId}` in an outcome name or a
+            // field id is the author's text, not a template.
+            node.outputs = contribution.replaceOutputs
+                ? jsonClone(contribution.outputs)
+                : { ...(node.outputs ?? {}), ...subNodeId(jsonClone(contribution.outputs), id) };
         }
         // A bundled registered type returns no definition; its bindings still close
         // against the bundled one (#942), counting what it bound through the context
@@ -5057,8 +4778,17 @@ export function serialize(built, opts = {}) {
         const def = o.def ?? bundledDefinition(o.typeName, o.requestedVersion);
         hoistContributionBindings(def, [...(o.bound ?? []), ...(contribution.bindings ?? [])], o.where);
         scope.nodes.push(node);
+        // A typed human task whose exits the product derives from its outcomes: every
+        // edge out of it is held to that rule (`hitlExitViolation`, in addEdge), and
+        // the step list treats its tails as outcome edges. A rawNode of the type is
+        // not one: it routes by the port lists its author wrote.
+        if (o.trackOutcomes && OUTCOME_HANDLE_NODE_TYPES.has(o.typeName))
+            hitlNodes.set(id, node);
         for (const t of o.tails)
             addEdge(scope, t, id);
+        if (contribution.fanOut) {
+            return contribution.fanOut.map((f) => ({ node: id, port: f.port, ...(f.endsRun ? { endsRun: true } : {}) }));
+        }
         const port = contribution.port ?? contributionPort(def);
         if (port === undefined) {
             // Only templated exits: no main path leaves this node. Remember it so a
@@ -5085,7 +4815,10 @@ export function serialize(built, opts = {}) {
             scope.rename.errorEnvelopes.set(step.name, impl.errorEnvelope);
         const ctx = {
             step: step.name,
+            nodeId: id,
+            flowId: built.id,
             version: impl.version,
+            pinnedVersion: step.options?.version,
             render: (value) => renderValue(value, scope.rename),
             renameRefs: (js) => renameRefs(js, scope.rename),
             stepNodeId: (name) => scope.stepNodeId.get(name) ?? name,
@@ -5131,12 +4864,21 @@ export function serialize(built, opts = {}) {
             }
             declaredErrorPorts.set(id, { port, typeName: impl.typeName, version: impl.version });
         }
-        if (contribution.port !== undefined && !declaresForwardPort(def ?? bundledDefinition(impl.typeName, impl.version), contribution.port)) {
-            throw new Error(`internal SDK error: ${where}: node type ${impl.typeName}@${impl.version} leaves by port "${contribution.port}", `
-                + 'which its definition declares no source handle for.');
+        // A forward port is a handle the definition declares, one of the type's
+        // author-named exits, or one the product derives (`derivesPort`: a human
+        // task's `outcome-<id>` handles, where the definition lists only `completed`).
+        const exits = impl.exits?.(spec, step.options?.version);
+        const exitPorts = new Set(exits && hasExits(exits) ? exits.map((e) => e.port) : []);
+        for (const p of [...(contribution.port !== undefined ? [contribution.port] : []), ...(contribution.fanOut ?? []).map((f) => f.port)]) {
+            if (exitPorts.has(p) || impl.derivesPort?.(spec, p)
+                || declaresForwardPort(def ?? bundledDefinition(impl.typeName, impl.version), p))
+                continue;
+            throw new Error(`internal SDK error: ${where}: node type ${impl.typeName}@${impl.version} leaves by port "${p}", `
+                + 'which its definition declares no source handle for, and the type neither lists as an exit nor derives.');
         }
         return placeStepNode({
             where, stepName: step.name, id, typeName: impl.typeName, requestedVersion: impl.version, def, contribution, bound, tails, scope, parentId,
+            trackOutcomes: true,
         });
     }
     function emitAction(step, tails, scope, parentId) {
@@ -6082,57 +5824,6 @@ export function serialize(built, opts = {}) {
                 addEdge(scope, t, id);
             return [{ node: id, port: successPort(rc.nodeType) }];
         }
-        if (spec.kind === 'hitl') {
-            const id = stepUid(scope, step.name);
-            const hitlType = hitlNodeType(spec.inputs);
-            // How the task leaves its node — `hitlExitModel` (core/hitl-routing.ts)
-            // has the product rule and what `.step()` means after each shape.
-            //
-            // Only the BASE node has definition versions to select: routing per
-            // outcome picks 1.1 and `exposeError` picks 1.2 (which adds the `error`
-            // output). quick-form draws the same per-outcome handles on the one
-            // definition it has, so it routes per outcome without moving. An explicit
-            // pin wins over the inferred 1.1 — `flow validate` accepts `outcome-<id>`
-            // edges on base@1.0 — but not over `exposeError`, whose output only 1.2
-            // declares. A zero- or one-outcome task stays on the pinned default.
-            const pinned = step.options?.version;
-            const exitModel = hitlExitModel(spec.inputs, pinned);
-            if (hitlType !== NODE_TYPE.hitl && spec.inputs?.exposeError === true) {
-                throw new Error(`"${step.name}": exposeError needs the base human task's 1.2 definition, which adds the `
-                    + `error output — the '${spec.inputs?.variant}' variant has no such version. Drop the variant or exposeError.`);
-            }
-            if (spec.inputs?.outcomePorts === true && !OUTCOME_HANDLE_NODE_TYPES.has(hitlType)) {
-                throw new Error(`"${step.name}": outcomePorts: true, but the '${spec.inputs?.variant}' variant reads its outcomes `
-                    + `from its app and leaves on its single 'completed' exit. Route on out('${step.name}', 'Action') downstream.`);
-            }
-            if (spec.inputs?.exposeError === true && pinned !== undefined && pinned !== '1.2') {
-                throw new Error(`"${step.name}": exposeError needs the task's 1.2 definition, but { version: '${pinned}' } pins it. `
-                    + `Drop the pin or match it.`);
-            }
-            // The same version `check` resolves the definition at (#1041).
-            const node = makeNode(hitlType, id, step.name, { parentId, requestedVersion: actionVersion(spec, pinned) });
-            const { inputs, outputs } = hitlInputs(spec.inputs, id, built.id, step.name, scope.rename);
-            node.inputs = inputs;
-            // The definition's `outputDefinition` gives the two output SLOTS; the form
-            // gives their shape (see hitlInputs), so the instance's version wins.
-            node.outputs = outputs;
-            scope.nodes.push(node);
-            if (OUTCOME_HANDLE_NODE_TYPES.has(hitlType))
-                hitlNodes.set(id, node);
-            for (const t of tails)
-                addEdge(scope, t, id);
-            if (exitModel.shape === 'per-outcome') {
-                // The PRIMARY (first) outcome continues the main path; the author routes
-                // the rest with .stepToList('outcome-<id>', …) or as .stepSwitch arms.
-                return [{ node: id, port: exitModel.exits[0]?.port ?? `outcome-${outcomeSlug(undefined, 0)}` }];
-            }
-            if (exitModel.shape === 'every-outcome') {
-                // Fan-out: every outcome continues to the next step, each on its own
-                // handle. End outcomes are marked, and `emit` ends them.
-                return exitModel.exits.map((e) => ({ node: id, port: e.port, ...(e.endsProcess ? { endsRun: true } : {}) }));
-            }
-            return [{ node: id, port: successPort(hitlType) }];
-        }
         // A custom FlowAction subclass carries no `kind`; it compiles through its
         // own contribution (design §4). Anything else without a recognized kind is
         // an authoring error — it must NOT fall through into the script branch

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.24.0",
+  "version": "6.25.0",
   "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": "a3e8314b01bff6cf76316765840e31bd2e3860e5"
+  "gitref": "119258f247ce3ff7e3b3b3faf21ab2e2b13eca5a"
 }