@uipath/maestro-builder-sdk 6.60.0 → 6.61.0

package/dist/core/refusals.js

@@ -6,7 +6,8 @@
  *     stops `compile` from writing. A serializer warning (`CONNECTION_STUB`) is
  *     `lint` too: it never blocks.
  *   - `lowering`: `compile` cannot write a correct `.flow`. It always stops
- *     `compile`; `check` may report it early.
+ *     `compile`; `check` reports it too, from the serializer it runs in collect
+ *     mode (`SerializeOpts.collect`), so the rule lives in one place.
  *   - `draft`: an unfinished canvas node (no connection yet, a required input
  *     left empty, a generic operation with no object). These are the codes a
  *     draft-tolerant compile collects instead of throwing (`DraftCode` in
@@ -92,6 +93,8 @@ export const REFUSALS = {
     CARRIED_DEFINITION_CONFLICT: 'lowering',
     CARRIED_DEFINITION_INVALID: 'lowering',
     CEQL_UNPARSEABLE: 'lowering',
+    // A throw that is no refusal, which `compile` cannot get past: check reports it on its step.
+    COMPILE_FAILED: 'lowering',
     CONNECTION_CONNECTOR_CONFLICT: 'draft',
     CONNECTION_STUB: 'lint',
     CONNECTOR_IMPORT_NOT_A_FILE: 'lowering',
@@ -246,6 +249,7 @@ export const REFUSALS = {
     HITL_OUTCOME_ACTION: 'lint',
     HITL_OUTCOME_BAD_ID: 'lint',
     HITL_OUTCOME_NO_NAME: 'lint',
+    HITL_OUTCOME_PORTS_NONE: 'lowering',
     HITL_OUTCOME_PORTS_OFF: 'lowering',
     HITL_OUTCOME_PORTS_VARIANT: 'lowering',
     HITL_OUTCOME_PORT_MISPLACED: 'lint',

package/dist/flow-node-type.d.ts

@@ -59,6 +59,17 @@ export interface FlowNodeContribution extends Omit<NodeContribution, 'definition
      * guard that refuses a `completed` edge on such a task (`hitlExitViolation`).
      */
     legacyCompleted?: boolean;
+    /**
+     * The node is a human task with no per-outcome exits (no outcomes, an
+     * app-backed variant, `legacyCompleted: true`): why, as a clause ("it declares
+     * no outcomes"), and what to write instead. An `outcome-<id>` edge out of it
+     * would leave a handle it does not have, so it is refused
+     * (HITL_OUTCOME_PORTS_NONE).
+     */
+    noOutcomePorts?: {
+        readonly why: string;
+        readonly suggestion: string;
+    };
     /**
      * `outputs` REPLACES the definition's `outputDefinition` on the node instead of
      * being merged over it — for an instance whose output slots are its own (a
@@ -195,13 +206,16 @@ export interface FlowSerializeContext {
      * Write a file beside the `.flow` (an agent's `agent.json`), at a path relative
      * to it. The same file twice is not a clash (a subflow body emitted for two
      * callers); two different contents at a path an explicit `source` chose are
-     * refused (`INLINE_AGENT_RESOURCE_SOURCE_DUP`). The `json` object is kept, not
-     * copied, so `typeAgentInputs` can still fill it in.
+     * refused (`INLINE_AGENT_RESOURCE_SOURCE_DUP`). `owner` names whoever chose
+     * that `source`, as the refusal names it (`inline agent step "answer"'s
+     * context index "SOP"`); omit it for a derived one. `true` (the older form)
+     * marks an explicit `source` without naming its owner. The `json` object is
+     * kept, not copied, so `typeAgentInputs` can still fill it in.
      */
     sidecar(file: {
         path: string;
         json: unknown;
-    }, explicitSource?: boolean): void;
+    }, owner?: string | boolean): void;
     /**
      * Type an agent sidecar's `inputSchema` once this scope's variables are known:
      * each ref's `flatName` property gets the JSON Schema of the variable its
@@ -375,10 +389,12 @@ export interface FlowCheckContext {
     readonly options: CheckOpts;
     /**
      * Check a step's symbolic `connection` / `folder` labels against bindings.json,
-     * as a connector step's are, reporting `BINDING_SELF_NAME` / `BINDING_UNDECLARED`.
-     * Those codes are the pipeline's, shared by every family that binds a
-     * connection, so they belong to no family catalog. `use` names the connector
-     * the connection must belong to, for the cross-step connection-owner rule.
+     * reporting `BINDING_SELF_NAME` / `BINDING_UNDECLARED`.
+     *
+     * @deprecated `check` runs the serializer, which refuses a label passed to
+     * `FlowSerializeContext.resolveBinding` under the same codes; a node type that
+     * resolves its labels there needs no call here, and a call here reports the
+     * label twice. Kept so a node-type package written against it still builds.
      */
     bindingLabels(where: string, labels: {
         connection?: unknown;
@@ -393,17 +409,12 @@ export interface FlowCheckContext {
         action?: string;
     }): void;
     /**
-     * The node ids and folders this step's attached resources take, recorded
-     * file-wide — across the root flow and every subflow, as compile claims them.
-     * An explicit id equal to one another node gets is reported once the whole
-     * file is checked (`INLINE_AGENT_RESOURCE_NODE_ID`).
-     */
-    /**
-     * Run the rules every Integration Service operation shares — its lookups, its
-     * schema readiness, its contract against the library facts check was given
-     * (`options`), and BINDING_MISSING — on this step. Their codes are the
-     * pipeline's, shared with an event subscription's, so they belong to no
-     * family catalog; each is reported at its own severity.
+     * Run the rules every Integration Service operation shares that compile does
+     * not: its lookups and its schema readiness, against the library facts check
+     * was given (`options`). The operation, its field contract and its binding
+     * labels are the serializer's refusals, reported from `check`'s serializer
+     * run. Their codes are the pipeline's, shared with an event subscription's, so
+     * they belong to no family catalog; each is reported at its own severity.
      */
     connector(spec: {
         key: string;
@@ -414,15 +425,18 @@ export interface FlowCheckContext {
         folder?: unknown;
         inputs?: unknown;
     }): void;
+    /**
+     * @deprecated Compile claims node ids and folders file-wide and refuses a clash
+     * (INLINE_AGENT_RESOURCE_NODE_ID / INLINE_AGENT_RESOURCE_SOURCE_DUP), which
+     * `check` reports from its serializer run. These record nothing and answer
+     * `undefined`; kept so a node-type package written against them still builds.
+     */
     readonly resources: {
-        /** An id compile derives for one of this step's resources, and what it is, for that report. */
         derivedNodeId(id: string, what: string): void;
-        /** Claim an explicit node id: the earlier claimant when one already has it (and nothing is recorded), else undefined. */
         claimNodeId(id: string, what: string): {
             step: string;
             what: string;
         } | undefined;
-        /** Claim an agent's folder (its `source`, compared lower-cased): the other step that has it, else undefined. */
         claimFolder(source: string): string | undefined;
     };
 }

package/dist/flow-parallel-hitl.d.ts

@@ -0,0 +1,105 @@
+/**
+ * How a `.parallel` arm hands its join its edges, read from the step tree the
+ * way serialize's `emit` wires them, and the two refusals a human task inside
+ * an arm can earn: alternative outcome edges that each enter the join
+ * (HITL_FAN_OUT_INTO_JOIN), and an End outcome beside a continuing one
+ * (HITL_END_OUTCOME_IN_PARALLEL). serialize refuses both on the graph it
+ * builds and words them here, naming the outcomes; `check` reads `armTails` for
+ * its own join rules.
+ */
+import type { Step } from './flow-sdk.js';
+import { type HitlRoutingInputs } from './core/hitl-routing.js';
+/**
+ * Whether a `.parallel` arm hands its join an edge, as serialize wires it: it
+ * has a step, and `armTails` (serialize's `emit` tail for tail) leaves it at
+ * least one tail. So an arm that ends by `.return`, `.terminate`, `.break`,
+ * `.continue` or a `.stepToRef` on the default port does not, and neither does
+ * one that ends in a `.branch` / `.switch` / `.stepSwitch` every arm of which
+ * ends, or in a nested `.parallel` none of whose arms reaches its own join.
+ * When no arm hands on a tail, serialize emits no Merge at all (#1267), so the
+ * join rules (PARALLEL_ARM_RETURNS, REF_INTO_PARALLEL_ARM,
+ * REF_OUT_OF_PARALLEL_ARM) have no join to protect.
+ */
+export declare function armReachesJoin(arm: Step[]): boolean;
+/**
+ * One edge a `.parallel` arm hands its join, as `emit` wires it: the step it
+ * leaves from, and the human-task outcome it leaves on, if it is one.
+ */
+export interface ArmTail {
+    from: string;
+    outcome?: string;
+    /**
+     * The human task whose `.stepSwitch` arm this path runs on, and the outcome
+     * of that arm. Set on every tail a human-task `.stepSwitch` hands on, body
+     * arm or empty arm, so an arm that ends on two of them is seen for what it
+     * is: alternatives, of which only one fires.
+     */
+    humanSwitch?: {
+        step: string;
+        outcome: string;
+    };
+}
+/**
+ * The edges a step list hands on, mirroring serialize's `emit` tail for tail.
+ *
+ * `.branch` / `.switch` / `.stepSwitch` hand on every arm's tails (an empty arm
+ * hands on the port it started from), a `.parallel` its Merge when an arm
+ * reaches it and nothing otherwise, a fan-out human task one per continuing
+ * outcome, a routed one its primary outcome; `.return` / `.terminate` / `.break`
+ * and a `stepToRef('output', …)` hand on none, `.stepToList` leaves the path as
+ * it was, and every other step hands on its own single edge.
+ */
+export declare function armTails(steps: readonly Step[], incoming: ArmTail[]): ArmTail[];
+export declare function actionTails(name: string, spec: {
+    kind?: string;
+    inputs?: HitlRoutingInputs;
+}, version?: string): ArmTail[];
+/**
+ * The tails of a `.parallel` arm when they would starve its join: two or more
+ * alternative edges — only one fires — at least one of which is a human task's
+ * outcome edge, or the end of a human-task `.stepSwitch` arm. The join waits
+ * for a token on every incoming flow.
+ *
+ * However the task got there, it is the same graph: a fan-out task at the arm's
+ * end (its outcomes are the alternatives), a `.stepSwitch` with an empty arm
+ * beside a body arm, a complete `.stepSwitch` with nothing after it (one edge
+ * per arm's last step), a task on one side of a `.branch`. serialize refuses the
+ * same condition, edge for edge. Rejoining arms with NO human task in them are
+ * the older, general case, and not refused here.
+ */
+export declare function hitlFanInto(steps: readonly Step[]): ArmTail[] | undefined;
+/**
+ * The HITL_FAN_OUT_INTO_JOIN refusal for arm `arm` of `.parallel` `join`, whose
+ * `tails` ({@link hitlFanInto}) would each enter the join, and the human task it
+ * is about.
+ */
+export declare function fanInRefusal(join: string, arm: number, steps: readonly Step[], tails: ArmTail[]): {
+    message: string;
+    suggestion: string;
+    task: string;
+};
+/**
+ * A human task inside a `.parallel` arm with an outcome whose path stops at an
+ * End, which would starve the join: an `action: 'End'` outcome of a fan-out
+ * task, or a `.stepSwitch` outcome with no arm or whose arm ends in `.return()`.
+ */
+export interface HitlEndHazard {
+    step: string;
+    outcomes: string[];
+    via: 'action-end' | 'step-switch';
+}
+/**
+ * Human tasks in one `.parallel` arm that continue every outcome while some of
+ * them are `action: 'End'`. The End outcome's path stops at its End node, so the
+ * join waits for the continuing path that did not run.
+ *
+ * Recurses into `.branch` / `.switch` / `.stepSwitch` bodies, which reach the
+ * join too. Not into a loop body (the loop node is what reaches the join) or a
+ * nested `.parallel` (its own join is checked on its own).
+ */
+export declare function hitlEndHazards(steps: readonly Step[]): HitlEndHazard[];
+/** The HITL_END_OUTCOME_IN_PARALLEL refusal for hazard `h` ({@link hitlEndHazards}) inside `.parallel` `join`. */
+export declare function endOutcomeRefusal(join: string, h: HitlEndHazard): {
+    message: string;
+    suggestion?: string;
+};

package/dist/flow-parallel-hitl.js

@@ -0,0 +1,214 @@
+import { commentText } from './core/comment-text.js';
+import { OUTCOME_HANDLE_NODE_TYPES, hitlExitModel } from './core/hitl-routing.js';
+import { FLOW_NODE_TYPES } from './flow-node-registry.js';
+import { hasExits } from './core/step-ports.js';
+import { stopsAtEnd } from './flow-step-tree.js';
+import { stepExits } from './flow-step-exits.js';
+/**
+ * Whether a `.parallel` arm hands its join an edge, as serialize wires it: it
+ * has a step, and `armTails` (serialize's `emit` tail for tail) leaves it at
+ * least one tail. So an arm that ends by `.return`, `.terminate`, `.break`,
+ * `.continue` or a `.stepToRef` on the default port does not, and neither does
+ * one that ends in a `.branch` / `.switch` / `.stepSwitch` every arm of which
+ * ends, or in a nested `.parallel` none of whose arms reaches its own join.
+ * When no arm hands on a tail, serialize emits no Merge at all (#1267), so the
+ * join rules (PARALLEL_ARM_RETURNS, REF_INTO_PARALLEL_ARM,
+ * REF_OUT_OF_PARALLEL_ARM) have no join to protect.
+ */
+export function armReachesJoin(arm) {
+    return arm.length > 0 && armTails(arm, [{ from: '' }]).length > 0;
+}
+/**
+ * The edges a step list hands on, mirroring serialize's `emit` tail for tail.
+ *
+ * `.branch` / `.switch` / `.stepSwitch` hand on every arm's tails (an empty arm
+ * hands on the port it started from), a `.parallel` its Merge when an arm
+ * reaches it and nothing otherwise, a fan-out human task one per continuing
+ * outcome, a routed one its primary outcome; `.return` / `.terminate` / `.break`
+ * and a `stepToRef('output', …)` hand on none, `.stepToList` leaves the path as
+ * it was, and every other step hands on its own single edge.
+ */
+export function armTails(steps, incoming) {
+    let tails = incoming;
+    for (const st of steps) {
+        if (st.kind === 'stepToList')
+            continue;
+        if (st.kind === 'stepToRef') {
+            if (st.port === 'output')
+                tails = [];
+            continue;
+        }
+        if (st.kind === 'return' || st.kind === 'terminate' || st.kind === 'break' || st.kind === 'continue')
+            return [];
+        if (st.kind === 'action') {
+            tails = actionTails(st.name, st.spec, st.options?.version);
+        }
+        else if (st.kind === 'stepSwitch') {
+            const spec = st.spec;
+            const outcomes = outcomeHandleTask(spec);
+            tails = st.cases.flatMap((c) => armTails(c.body, [{ from: st.name, ...(outcomes ? { outcome: String(c.value) } : {}) }])
+                .map((t) => (outcomes && !t.humanSwitch ? { ...t, humanSwitch: { step: st.name, outcome: String(c.value) } } : t)));
+        }
+        else if (st.kind === 'branch') {
+            tails = [...armTails(st.then, [{ from: st.name }]), ...armTails(st.otherwise, [{ from: st.name }])];
+        }
+        else if (st.kind === 'switch') {
+            tails = [
+                ...st.cases.flatMap((c) => armTails(c.body, [{ from: st.name }])),
+                ...(st.default !== undefined ? armTails(st.default, [{ from: st.name }]) : []),
+            ];
+        }
+        else if (st.kind === 'parallel') {
+            // serialize joins a nested `.parallel` at its Merge, the one edge it hands
+            // on, and emits no Merge, so no edge, when no arm hands on a tail (#1267).
+            // An empty arm hands on the path it started from, which the Merge joins.
+            const arms = Array.isArray(st.arms) ? st.arms : [];
+            tails = arms.some((arm) => armTails(arm, tails).length > 0) ? [{ from: st.name }] : [];
+        }
+        else {
+            tails = [{ from: st.name ?? st.kind }];
+        }
+    }
+    return tails;
+}
+/**
+ * Whether `spec` is a human task the product draws one handle per outcome on
+ * (the base node type and quick-form), as its registered node type names it.
+ */
+function outcomeHandleTask(spec) {
+    const kind = spec?.kind;
+    const entry = typeof kind === 'string' ? FLOW_NODE_TYPES.byKind(kind, spec) : undefined;
+    return entry !== undefined && OUTCOME_HANDLE_NODE_TYPES.has(entry.type.typeName);
+}
+export function actionTails(name, spec, version) {
+    if (!outcomeHandleTask(spec))
+        return [{ from: name }];
+    const model = hitlExitModel(spec.inputs, version);
+    if (model.shape === 'placeholder')
+        return [{ from: name }];
+    if (model.shape === 'per-outcome')
+        return model.exits.slice(0, 1).map((e) => ({ from: name, outcome: e.value }));
+    return model.exits.filter((e) => !e.endsProcess).map((e) => ({ from: name, outcome: e.value }));
+}
+/**
+ * The tails of a `.parallel` arm when they would starve its join: two or more
+ * alternative edges — only one fires — at least one of which is a human task's
+ * outcome edge, or the end of a human-task `.stepSwitch` arm. The join waits
+ * for a token on every incoming flow.
+ *
+ * However the task got there, it is the same graph: a fan-out task at the arm's
+ * end (its outcomes are the alternatives), a `.stepSwitch` with an empty arm
+ * beside a body arm, a complete `.stepSwitch` with nothing after it (one edge
+ * per arm's last step), a task on one side of a `.branch`. serialize refuses the
+ * same condition, edge for edge. Rejoining arms with NO human task in them are
+ * the older, general case, and not refused here.
+ */
+export function hitlFanInto(steps) {
+    const tails = armTails(steps, [{ from: '(fork)' }]);
+    return tails.length >= 2 && tails.some((t) => t.outcome !== undefined || t.humanSwitch !== undefined) ? tails : undefined;
+}
+/**
+ * The HITL_FAN_OUT_INTO_JOIN refusal for arm `arm` of `.parallel` `join`, whose
+ * `tails` ({@link hitlFanInto}) would each enter the join, and the human task it
+ * is about.
+ */
+export function fanInRefusal(join, arm, steps, tails) {
+    const tagged = tails.find((t) => t.outcome !== undefined || t.humanSwitch !== undefined);
+    const task = tagged.outcome !== undefined ? tagged.from : tagged.humanSwitch.step;
+    if (tails.every((t) => t.from === task && t.outcome !== undefined)) {
+        return {
+            task,
+            message: `Human task "${task}" ends its path inside parallel "${join}", so its outcomes `
+                + `${tails.map((t) => t.outcome).join(', ')} each get their own edge into the join. Only one outcome ever `
+                + `fires, and the join waits for a token on every incoming edge, so the run never gets past "${join}" — with `
+                + `no incident, and \`flow validate\` answers Valid. Add a step after "${task}" inside the arm, so every `
+                + `outcome continues to that step and only its one edge reaches the join (the decision is `
+                + `out('${task}', 'Action')), or move the task out of the \`.parallel(…)\`.`,
+            suggestion: `a.step('${task}', hitl(…)).step('record', …)`,
+        };
+    }
+    const edges = tails.map((t) => (t.outcome !== undefined ? `outcome ${t.outcome} of "${t.from}"`
+        : t.humanSwitch ? `"${t.from}" (on outcome ${t.humanSwitch.outcome} of "${t.humanSwitch.step}")` : `"${t.from}"`));
+    const last = [...steps].reverse().find((x) => x.kind !== 'stepToList' && x.kind !== 'stepToRef');
+    return {
+        task,
+        message: `Parallel "${join}" arm ${arm + 1} ends on ${tails.length} alternative paths, and each gets its own edge `
+            + `into the join: ${edges.join(', ')}. Only one of them runs, and the join waits for a token on every incoming `
+            + `edge, so the run never gets past "${join}" — with no incident, and \`flow validate\` answers Valid. Add a `
+            + `step at the end of the arm${last?.name ? `, after "${last.name}"` : ''}, so the paths meet on that step and `
+            + `only its one edge reaches the join, or move human task "${task}" out of the \`.parallel(…)\`.`,
+        suggestion: `….step('record', …)  // last step of arm ${commentText(arm + 1)}`,
+    };
+}
+/**
+ * Human tasks in one `.parallel` arm that continue every outcome while some of
+ * them are `action: 'End'`. The End outcome's path stops at its End node, so the
+ * join waits for the continuing path that did not run.
+ *
+ * Recurses into `.branch` / `.switch` / `.stepSwitch` bodies, which reach the
+ * join too. Not into a loop body (the loop node is what reaches the join) or a
+ * nested `.parallel` (its own join is checked on its own).
+ */
+export function hitlEndHazards(steps) {
+    const found = [];
+    for (const st of steps) {
+        if (st.kind === 'action' && outcomeHandleTask(st.spec)) {
+            const model = hitlExitModel(st.spec.inputs, st.options?.version);
+            if (model.shape !== 'every-outcome')
+                continue;
+            const ending = model.exits.filter((e) => e.endsProcess).map((e) => e.value);
+            if (ending.length > 0 && ending.length < model.exits.length)
+                found.push({ step: st.name, outcomes: ending, via: 'action-end' });
+        }
+        else if (st.kind === 'branch') {
+            found.push(...hitlEndHazards(st.then), ...hitlEndHazards(st.otherwise));
+        }
+        else if (st.kind === 'switch') {
+            for (const c of st.cases)
+                found.push(...hitlEndHazards(c.body));
+            if (st.default)
+                found.push(...hitlEndHazards(st.default));
+        }
+        else if (st.kind === 'stepSwitch') {
+            // An outcome with no arm gets an End (serialize's `endExit`), and so does
+            // an arm that ends in `.return()`. Beside an arm that continues, that End
+            // is where this arm's token stops on that outcome.
+            const spec = st.spec;
+            const exits = outcomeHandleTask(spec) ? stepExits(st.spec, st.options?.version) : undefined;
+            if (exits && hasExits(exits)) {
+                const stopped = exits.filter((e) => {
+                    const c = st.cases.find((x) => x.value === e.value);
+                    return !c || (armTails(c.body, [{ from: st.name }]).length === 0 && stopsAtEnd(c.body));
+                }).map((e) => e.value);
+                if (stopped.length > 0 && armTails([st], [{ from: '(fork)' }]).length > 0) {
+                    found.push({ step: st.name, outcomes: stopped, via: 'step-switch' });
+                }
+            }
+            for (const c of st.cases)
+                found.push(...hitlEndHazards(c.body));
+        }
+    }
+    return found;
+}
+/** The HITL_END_OUTCOME_IN_PARALLEL refusal for hazard `h` ({@link hitlEndHazards}) inside `.parallel` `join`. */
+export function endOutcomeRefusal(join, h) {
+    const list = h.outcomes.join(', ');
+    if (h.via === 'step-switch') {
+        return {
+            message: `Human task "${h.step}" is a .stepSwitch inside parallel "${join}", and ${h.outcomes.length === 1
+                ? `outcome ${list} has` : `outcomes ${list} have`} no arm, or an arm that ends in .return(). That path `
+                + `stops at an End node, while the join waits for a token from this arm on the path that continues, so the `
+                + `run never gets past "${join}" — with no incident, and \`flow validate\` answers Valid. Give every outcome `
+                + `an arm that continues (and move a .return() after the \`.parallel(…)\`), or move the task out of the `
+                + `\`.parallel(…)\`.`,
+            suggestion: `{ value: '${h.outcomes[0]}', body: (b) => b.step(…) }`,
+        };
+    }
+    return {
+        message: `Human task "${h.step}" is inside parallel "${join}", and ${h.outcomes.length === 1
+            ? `outcome ${list} is` : `outcomes ${list} are`} action: 'End'. `
+            + `That path stops at its own End node, while the join waits for a token from this arm on its `
+            + `continuing path, so the run never gets past "${join}". Drop action: 'End' there and act on `
+            + `out('${h.step}', 'Action') after the join, or move the task out of the \`.parallel(…)\`.`,
+    };
+}

package/dist/flow-sdk.d.ts

@@ -501,8 +501,8 @@ export interface ReturnOptions extends NodeOptions {
      * for what the canvas shows. Two Ends in one scope asking for `done` with the
      * same values, label, version and updates are one End reached from both paths.
      * Two that differ in any of these, or that sit in different scopes (a loop body
-     * and the main path), are refused (`check`: DUP_END_NAME; `compile --no-check`
-     * throws) rather than renamed `done2`. The name is never renamed to make it
+     * and the main path), are refused (DUP_END_NAME, by `compile` and so by
+     * `check`) rather than renamed `done2`. The name is never renamed to make it
      * unique: a name that gives the node id of a step, the trigger or an entry
      * point is refused too (STEP_ID_COLLISION), as is a second End whose name gives
      * the same id (`a b` and `a_b`, DUP_END_NAME).
@@ -1265,8 +1265,8 @@ declare class StepList {
      * own, from anywhere in the flow, including another port's path. To stop
      * several paths at one Terminate, spell its `.terminate` once and end the
      * other paths with `.stepToRef('<name>')`. Two `.terminate`s asking for the
-     * same name are refused (`check`: DUP_STEP; `compile --no-check` throws)
-     * rather than renamed `<name>2`.
+     * same name are refused (DUP_STEP, by `compile` and so by `check`) rather than
+     * renamed `<name>2`.
      *
      * @example
      * **Abort the sibling arm from inside a parallel**

package/dist/flow-sdk.js

@@ -899,8 +899,8 @@ class StepList {
      * own, from anywhere in the flow, including another port's path. To stop
      * several paths at one Terminate, spell its `.terminate` once and end the
      * other paths with `.stepToRef('<name>')`. Two `.terminate`s asking for the
-     * same name are refused (`check`: DUP_STEP; `compile --no-check` throws)
-     * rather than renamed `<name>2`.
+     * same name are refused (DUP_STEP, by `compile` and so by `check`) rather than
+     * renamed `<name>2`.
      *
      * @example
      * **Abort the sibling arm from inside a parallel**

package/dist/flow-terminate-names.d.ts

@@ -1,7 +1,7 @@
 /**
  * The words for a `.terminate('<name>')` whose name is already taken (#1239).
- * `check` (DUP_STEP) and `serialize` (the `--no-check` backstop) both use them,
- * so one clash gets one explanation whichever reports it.
+ * The serializer refuses the clash with them (DUP_STEP), and `check` reports
+ * that refusal from its serializer run.
  */
 /** Two `.terminate('<name>')` calls: keep one and end the other paths at it. */
 export declare function terminateTwiceMessage(name: string): string;

package/dist/flow-terminate-names.js

@@ -1,7 +1,7 @@
 /**
  * The words for a `.terminate('<name>')` whose name is already taken (#1239).
- * `check` (DUP_STEP) and `serialize` (the `--no-check` backstop) both use them,
- * so one clash gets one explanation whichever reports it.
+ * The serializer refuses the clash with them (DUP_STEP), and `check` reports
+ * that refusal from its serializer run.
  */
 /** Two `.terminate('<name>')` calls: keep one and end the other paths at it. */
 export function terminateTwiceMessage(name) {

package/dist/merge-compile.js

@@ -81,5 +81,6 @@ function baselineDirectory(originalPath) {
  * load-time cycle.
  */
 export function checkEdited(built, editedFlow, opts) {
-    return placeDiagnostics(check(built, opts), editedFlow);
+    // Merge compiles the flow itself (draft-tolerant), so check's serializer pass is skipped.
+    return placeDiagnostics(check(built, { ...opts, serializer: false }), editedFlow);
 }