@uipath/maestro-builder-sdk 6.60.0 → 6.61.1

package/dist/serialize.js

@@ -12,11 +12,13 @@ import { Expr, toExpr, SCHEDULE_PRESETS, flatNameSegmentsOf, parallelFork } from
 import { FlowAction, FlowTrigger } from './core/node-classes.js';
 import { connectorRawNodeRefusal } from './core/connector-raw-node.js';
 import { CompileRefusal } from './core/compile-refusal.js';
+import { nearestName } from './core/edit-distance.js';
 import { rawNodeInputProblem, registeredRawType } from './raw-node-advice.js';
 import { planContributionBindings } from './core/contribution-bindings.js';
 import { declaredErrorPortRefusal, definitionHasErrorPort, errorPortRefusal } from './core/error-port.js';
 import { FLOW_NODE_TYPES } from './flow-node-registry.js';
 import { stepExits } from './flow-step-exits.js';
+import { endOutcomeRefusal, fanInRefusal, hitlEndHazards, hitlFanInto } from './flow-parallel-hitl.js';
 import { resolveVersionCarried } from './core/nodes/versioned.js';
 import { indexCarriedDefinitions } from './core/carried-definitions.js';
 import { connectionConnectors } from './bindings-v2.js';
@@ -30,7 +32,7 @@ import { hasExits } from './core/step-ports.js';
 import { stopsAtEnd } from './flow-step-tree.js';
 import { assertNodeEnvelope } from './core/node-envelope.js';
 import { fnv1aX4Uuid, stableId } from './core/stable-id.js';
-import { readEventFilter, eventFilterProblem, eventFilterJmes, eventFilterTreeLeaf, jmesString, jmesStringProblem } from './core/event-filters.js';
+import { EVENT_FILTER_OPERATORS, readEventFilter, eventFilterProblem, eventFilterJmes, eventFilterTreeLeaf, jmesString, jmesStringProblem } from './core/event-filters.js';
 import { FLOW_EXPR_DIALECT } from './core/connector-checks.js';
 import { connectorInputErrors as coreConnectorInputErrors } from './core/connector-inputs.js';
 /**
@@ -532,8 +534,7 @@ function refuseUnverifiedByoa(opts, where, sub) {
  * INLINE_AGENT_TOOL_CONNECTOR_NO_CONNECTION, and serialize leaves it unbound.)
  * `resolveBinding` returns `undefined` for an absent label, which used to reach
  * the node as `detail.connectionId: null` with no binding — valid to compile,
- * refused by `flow validate` (flow-builder-sdk#890). `check` reports the same
- * sentence first (BINDING_MISSING).
+ * refused by `flow validate` (flow-builder-sdk#890): BINDING_MISSING.
  */
 function requireBindingPair(where, labels, target) {
     const missing = missingBindingLabels(labels);
@@ -709,6 +710,71 @@ export function resolveContributionDefinition(ref, requestedVersion, where) {
     }
     throw new CompileRefusal('CONTRIBUTION_INVALID', `${where}: unknown DefinitionReference source "${ref.source}".`);
 }
+/**
+ * `library.resolveEvent` for one subscription, or EVENT_UNKNOWN: whatever it
+ * throws (a connector or event the library does not carry, a version or object
+ * it does not resolve) is that one condition, an event compile cannot place.
+ * `where` names the site as `check` always has (`trigger`, `waitForEvent "x"`).
+ */
+function resolveEvent(library, kind, sub, where) {
+    try {
+        return library.resolveEvent(kind, sub.connector, sub.event, sub.version, sub.object);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('internal SDK error:'))
+            throw error;
+        throw new CompileRefusal('EVENT_UNKNOWN', `${where}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * LIBRARY_REQUIRED for an event subscription at `site`, after the refusals that
+ * need no library: its binding labels, judged as `eventDetail` judges them, so a
+ * run without a library (`check`'s inner loop) still hears about them.
+ */
+function libraryRequiredForEvent(opts, sub, nodeId, site, call) {
+    if (sub !== null && typeof sub === 'object') {
+        if (Array.isArray(sub.filters))
+            eventFilterReads(sub.filters, nodeId);
+        requireBindingPair(site, sub, eventTarget(sub));
+        resolveBinding(opts, sub.connection, 'connection', `event node "${nodeId}"`, eventTarget(sub));
+        resolveBinding(opts, sub.folder, 'folder', `event node "${nodeId}"`, eventTarget(sub));
+    }
+    return new CompileRefusal('LIBRARY_REQUIRED', `${call} needs a library (pass --library / set $FLOW_SDK_LIBRARY_JSON).`);
+}
+/** The trigger kinds a `.trigger()` or `.entryPoint()` spec may carry. */
+const TRIGGER_KINDS = new Set(['manual', 'scheduled', 'event', 'form', 'conversation', 'voice']);
+/**
+ * Refuse a trigger spec that is not one: types are stripped at run time, so
+ * `.trigger({ every: 'R/PT1H' })` (the spec without its factory) or a typo'd
+ * kind arrives intact. `call` is how the author wrote the site (`.trigger()`,
+ * `.entryPoint("ep")`).
+ */
+function refuseUnknownTrigger(spec, call) {
+    const kind = spec?.kind;
+    if (typeof kind === 'string' && TRIGGER_KINDS.has(kind))
+        return;
+    throw new CompileRefusal('TRIGGER_UNKNOWN_KIND', `${call} was given ${JSON.stringify(kind)}, which is not a trigger. `
+        + `Wrap it in a factory: scheduled({ every: 'R/PT1H' }) for a schedule, `
+        + `onEvent({ connector, event, where, connection, folder }) to start on a connector event, formTrigger() to start from a `
+        + `submitted form, or conversationTrigger() to start on a new conversation. Omit .trigger() entirely `
+        + `for the manual trigger (the default).`, `scheduled({ every: 'R/PT1H' })`);
+}
+/**
+ * A custom node's contribution. A `contribute()` that throws something other
+ * than a refusal (an author's own `Error`) is the node's refusal,
+ * CONTRIBUTION_INVALID, so `check` reports it on the node and `compile` names
+ * the code. An `internal SDK error:` is passed on as it is.
+ */
+function contributionOf(node, requestedVersion, where) {
+    try {
+        return node.contribute(requestedVersion !== undefined ? { requestedVersion } : {});
+    }
+    catch (error) {
+        if (error instanceof CompileRefusal || (error instanceof Error && error.message.startsWith('internal SDK error:')))
+            throw error;
+        throw new CompileRefusal('CONTRIBUTION_INVALID', `compile cannot lower ${where}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
 /**
  * Whether `def` declares `port` as a forward source handle: an exact id, or a
  * templated one (`outcome-{item.id}` declares every `outcome-<slug>`). `error` is
@@ -806,6 +872,43 @@ function flattenWhere(where, declared) {
     walk(where, '');
     return out;
 }
+/**
+ * A subscription's `filters`, each leaf read structurally (`readEventFilter`),
+ * or the refusal of the first leaf compile cannot lower: no field, no operator
+ * or two, a value no operator takes, a backslash JMESPath engines read apart.
+ * Needs no library, so a run without one judges the leaves too
+ * (`libraryRequiredForEvent`).
+ */
+function eventFilterReads(filters, nodeId) {
+    const operators = Object.keys(EVENT_FILTER_OPERATORS).join(', ');
+    const at = `event node "${nodeId}": filters`;
+    return filters.map((f, i) => {
+        const { keys, read } = readEventFilter(f);
+        const field = f?.field;
+        if (typeof field !== 'string' || field === '') {
+            throw new CompileRefusal('EVENT_FILTER_NO_FIELD', `${at}[${i}] has no \`field\` — name a field on the event payload, e.g. 'subject'.`);
+        }
+        if (keys.length === 0) {
+            throw new CompileRefusal('EVENT_FILTER_NO_VALUE', `${at}[${i}] has no operator. Write exactly one of ${operators} with its value — `
+                + `\`contains\` is a case-sensitive substring test, the same one Integration Service applies `
+                + `server-side; \`lessThan\`/\`greaterThan\` order a number or an ISO date.`, `{ field: '${field}', contains: '<text>' }`);
+        }
+        if (keys.length > 1) {
+            throw new CompileRefusal('EVENT_FILTER_MANY_OPERATORS', `${at}[${i}] carries ${keys.length} operators (${keys.join(', ')}); a condition has exactly `
+                + `one. Write two conditions instead — they are ANDed.`);
+        }
+        if (!read) {
+            throw new CompileRefusal('EVENT_FILTER_NO_VALUE', `${at}[${i}] gives \`${keys[0]}\` a value that is not a string, number or boolean.`);
+        }
+        // An ambiguous backslash first: `eventFilterProblem` would report it too.
+        const problem = eventFilterProblem(read);
+        const backslash = typeof read.value === 'string' && jmesStringProblem(read.value) !== undefined;
+        if (problem) {
+            throw new CompileRefusal(backslash ? 'EVENT_FILTER_BACKSLASH' : 'EVENT_FILTER_BAD_VALUE', `${at}[${i}] on \`${read.field}\`: ${problem}`);
+        }
+        return read;
+    });
+}
 function eventDetail(rc, sub, nodeId, opts, site) {
     requireBindingPair(site, sub, eventTarget(sub));
     const conn = resolveBinding(opts, sub.connection, 'connection', `event node "${nodeId}"`, eventTarget(sub));
@@ -817,8 +920,13 @@ function eventDetail(rc, sub, nodeId, opts, site) {
     // would otherwise emit it, with the text every family's compile shares.
     const objectName = String(op.objectName ?? '');
     const noObject = genericEventObjectRefusal(rc, sub, (o) => `onEvent(…, { object: '${o}' })`);
-    if (noObject)
-        throw new CompileRefusal('EVENT_GENERIC_NO_OBJECT', `event node "${nodeId}": ${noObject}`);
+    if (noObject) {
+        // The object an author put in `where` by mistake is the value to move.
+        const scopeObject = sub.where && typeof sub.where === 'object'
+            ? Object.entries(sub.where).find(([k]) => /^(objectName|entityName|object)$/i.test(k))?.[1]
+            : undefined;
+        throw new CompileRefusal('EVENT_GENERIC_NO_OBJECT', `event node "${nodeId}": ${noObject}`, `object: '${scopeObject !== undefined ? String(scopeObject) : '<Object>'}'`);
+    }
     // An unresolved `where` lookup is swapped for its recorded id — the id
     // `prepare --resolve` stored under the EVENT-form node type — or refused.
     // Same rule as connector inputs: emitting a placeholder for a value nobody
@@ -871,27 +979,8 @@ function eventDetail(rc, sub, nodeId, opts, site) {
     });
     // Each authored filter is read structurally (which operator, which value) and
     // lowered with the designer's own grammar — see `event-filters.ts` for the
-    // measured table. `check` has already refused a malformed leaf; a leaf that
-    // still cannot be read here is an author error, not something to drop silently.
-    const conditions = filters.map((f, i) => {
-        const { keys, read } = readEventFilter(f);
-        if (!read) {
-            // The code `check` gives the same leaf (`core/event-checks.ts`).
-            const field = f?.field;
-            throw new CompileRefusal(typeof field !== 'string' || field === '' ? 'EVENT_FILTER_NO_FIELD'
-                : keys.length > 1 ? 'EVENT_FILTER_MANY_OPERATORS' : 'EVENT_FILTER_NO_VALUE', `event node "${nodeId}": filters[${i}] must carry a field and exactly ONE operator `
-                + `(contains, startsWith, endsWith, equals, notEquals, lessThan, lessThanOrEqual, greaterThan, `
-                + `greaterThanOrEqual) — got ${JSON.stringify(f)}.`);
-        }
-        // An ambiguous backslash first, under the code `check` gives it
-        // (`core/event-checks.ts`); `eventFilterProblem` would report it too.
-        const problem = eventFilterProblem(read);
-        const backslash = typeof read.value === 'string' && jmesStringProblem(read.value) !== undefined;
-        if (problem) {
-            throw new CompileRefusal(backslash ? 'EVENT_FILTER_BACKSLASH' : 'EVENT_FILTER_BAD_VALUE', `event node "${nodeId}": filters[${i}] on \`${read.field}\`: ${problem}`);
-        }
-        return read;
-    });
+    // measured table.
+    const conditions = eventFilterReads(filters, nodeId);
     const filterClauses = conditions.map((c) => `(${eventFilterJmes(c)})`);
     const filterExpression = [
         ...scopeClauses,
@@ -1032,10 +1121,10 @@ function misplacedLookupMessage(token) {
 /**
  * The flow's declarations as the globals it will emit: a same-named `.output()`
  * and `.var()` folded into one `out` global (flow-builder-sdk#899), every other
- * repeated name refused. `check()` reports the same problems as
- * VARIABLE_NAME_COLLISION / OUTPUT_VAR_MISMATCH; this throws too, so a path that skips the static pass
- * (`compile --no-check`, `emitFlow`, a direct `serialize()`) cannot write a
- * file `flow validate` rejects for a duplicate variable id.
+ * repeated name refused (VARIABLE_NAME_COLLISION / OUTPUT_VAR_MISMATCH), so no
+ * path (`compile`, `emitFlow`, a direct `serialize()`) can write a file
+ * `flow validate` rejects for a duplicate variable id; `check` reports the
+ * refusal from its serializer run.
  */
 function emittableGlobals(built, where, kind = 'root') {
     // Entry-point inputs are rows of the same globals[], so they share the
@@ -1046,21 +1135,21 @@ function emittableGlobals(built, where, kind = 'root') {
     const shared = sharedInputsOf(built, where, kind);
     const plan = planFlowGlobals({ inputs, outputs: built.outputs, vars: [...built.vars, ...shared.autoVars] });
     if (plan.problems.length) {
-        throw new CompileRefusal(plan.problems[0].code, `${where}: ${plan.problems.map((p) => `[${p.code}] ${p.message}`).join(' ')}`);
+        throw new CompileRefusal(plan.problems[0].code, `${where}: ${plan.problems.map((p) => `[${p.code}] ${p.message}`).join(' ')}`, plan.problems[0].suggestion);
     }
     // An output the flow sets from inside gets an `inout` Variable to hold the
     // value; the End copies it into the Output (#1092, `flow-output-backing.ts`).
     const sharedOutputs = new Set(shared.targets.filter((t) => t.declaredAs === 'output').map((t) => t.name));
     const backing = planOutputBacking(built, plan.outputs, plan.vars, sharedOutputs);
     if (backing.problems.length) {
-        throw new CompileRefusal(backing.problems[0].code, `${where}: ${backing.problems.map((p) => `[${p.code}] ${p.message}`).join(' ')}`);
+        throw new CompileRefusal(backing.problems[0].code, `${where}: ${backing.problems.map((p) => `[${p.code}] ${p.message}`).join(' ')}`, backing.problems[0].suggestion);
     }
     return { ...plan, backing: backing.backing, backingReads: backing.reads };
 }
 /**
- * The flow's `{ shared }` input plan (#924), refused here as `check` refuses it
- * — so `compile --no-check` cannot write what `check` would have stopped.
- * Warnings (a root that feeds nothing) are `check`'s alone.
+ * The flow's `{ shared }` input plan (#924), its errors refused here (and
+ * reported by `check` from its serializer run). Warnings (a root that feeds
+ * nothing) are `check`'s alone.
  */
 function sharedInputsOf(built, where, kind) {
     if (kind === 'subflow') {
@@ -1072,8 +1161,9 @@ function sharedInputsOf(built, where, kind) {
     }
     const plan = planSharedInputs({ roots: sharedInputRoots(built), outputs: built.outputs, vars: built.vars });
     const errors = plan.problems.filter((p) => p.level === 'error');
-    if (errors.length)
-        throw new CompileRefusal(errors[0].code, `${where}: ${errors.map((p) => `[${p.code}] ${p.message}`).join(' ')}`);
+    if (errors.length) {
+        throw new CompileRefusal(errors[0].code, `${where}: ${errors.map((p) => `[${p.code}] ${p.message}`).join(' ')}`, errors[0].suggestion);
+    }
     return plan;
 }
 function newScope(outputs, vars = [], backing = new Map(), backingReads = backing) {
@@ -1147,14 +1237,22 @@ function newScope(outputs, vars = [], backing = new Map(), backingReads = backin
  * exact class of failure `.onError` used to have (an error path that vanishes in
  * conversion with every rung green). So it throws instead.
  */
-function resolveRejoins(scope, addEdge) {
+function resolveRejoins(scope, addEdge, 
+/** Refuse an edge whose target is unknown: throws, or (collect mode) reports it on the step it leaves and returns. */
+refuse = (_from, refusal) => { throw refusal; }) {
     for (const { from, target } of scope.pendingEdges) {
         const id = scope.stepNodeId.get(target) ?? scope.endNodeId.get(target);
         if (!id) {
+            const steps = [...scope.stepNodeId.keys()];
             const ends = [...scope.endNodeId.keys()];
-            throw new CompileRefusal('REF_UNKNOWN_TARGET', `.stepToRef('${target}') names a step this flow does not have. Known steps: `
-                + `${[...scope.stepNodeId.keys()].join(', ') || '(none)'}`
-                + `${ends.length ? `; named Ends: ${ends.join(', ')}` : ''}.`);
+            const near = [...steps, ...ends].find((n) => n.toLowerCase() === target.toLowerCase());
+            const source = [...scope.stepNodeId].find(([, nodeId]) => nodeId === from.node)?.[0];
+            refuse(from, new CompileRefusal('REF_UNKNOWN_TARGET', `.stepToRef('${target}') ${source !== undefined ? `after "${source}" ` : ''}names a step this flow does not have`
+                + `${near ? ` (did you mean "${near}"?)` : ''}. It takes the same name you passed to .step() or `
+                + `.terminate(), or the \`name\` of a \`.return({}, { name })\` End. Known steps: `
+                + `${steps.join(', ') || '(none)'}`
+                + `${ends.length ? `; named Ends: ${ends.join(', ')}` : ''}.`, near ? `.stepToRef('${near}')` : undefined));
+            continue;
         }
         // Through the serializer's own `addEdge`, so the id comes from the one
         // file-wide counter. A per-scope count (`edge_ref_${scope.edges.length}`)
@@ -1425,7 +1523,7 @@ function renameRefs(text, rename) {
  * port paths (`.stepToList`, `.onError`) included: their steps are nodes of
  * this scope too, so they need an id claimed with the rest.
  */
-function stepNamesOf(steps, out = [], terminates) {
+function stepNamesOf(steps, out = [], terminates, forks) {
     for (const s of steps) {
         // `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).
@@ -1434,30 +1532,32 @@ function stepNamesOf(steps, out = [], terminates) {
         // A `.parallel` with a fork node claims that node's name too (#1310).
         if (s.kind === 'parallel') {
             const fork = parallelFork(s.options);
-            if (fork)
+            if (fork) {
                 out.push(fork.name);
+                forks?.set(fork.name, s.name);
+            }
         }
         // How many `.terminate`s hold each name, so a clash gets the right remedy (#1239).
         if (s.kind === 'terminate' && terminates)
             terminates.set(s.name, (terminates.get(s.name) ?? 0) + 1);
         if (s.kind === 'stepToList')
-            stepNamesOf(s.body, out, terminates);
+            stepNamesOf(s.body, out, terminates, forks);
         if (s.kind === 'branch') {
-            stepNamesOf(s.then, out, terminates);
-            stepNamesOf(s.otherwise, out, terminates);
+            stepNamesOf(s.then, out, terminates, forks);
+            stepNamesOf(s.otherwise, out, terminates, forks);
         }
         else if (s.kind === 'switch') {
-            s.cases.forEach((c) => stepNamesOf(c.body, out, terminates));
-            stepNamesOf(s.default ?? [], out, terminates);
+            s.cases.forEach((c) => stepNamesOf(c.body, out, terminates, forks));
+            stepNamesOf(s.default ?? [], out, terminates, forks);
         }
         else if (s.kind === 'stepSwitch')
-            s.cases.forEach((c) => stepNamesOf(c.body, out, terminates));
+            s.cases.forEach((c) => stepNamesOf(c.body, out, terminates, forks));
         else if (s.kind === 'parallel')
-            s.arms.forEach((a) => stepNamesOf(a, out, terminates));
+            s.arms.forEach((a) => stepNamesOf(a, out, terminates, forks));
         else if (s.kind === 'loop')
-            stepNamesOf(s.body, out, terminates);
+            stepNamesOf(s.body, out, terminates, forks);
         else if (s.kind === 'doWhile')
-            stepNamesOf(s.body, out, terminates);
+            stepNamesOf(s.body, out, terminates, forks);
     }
     return out;
 }
@@ -1515,6 +1615,73 @@ function safeNodeId(name) {
     return name.replace(/[^A-Za-z0-9_]/g, '_') || 'node';
 }
 export function serialize(built, opts = {}) {
+    const collect = opts.collect;
+    if (!collect)
+        return serializeFlow(built, opts);
+    try {
+        return serializeFlow(built, opts);
+    }
+    catch (error) {
+        // A step's own refusal was taken by its catch (`emitStep`), so one that gets
+        // here was thrown outside any one step: scope-level, and collection stops.
+        // A throw that is no refusal is compile's COMPILE_FAILED; an internal SDK
+        // error is passed on.
+        if (!(error instanceof Error) || (!(error instanceof CompileRefusal) && error.message.startsWith('internal SDK error:')))
+            throw error;
+        const refusal = error instanceof CompileRefusal ? error : new CompileRefusal('COMPILE_FAILED', error.message);
+        collect({ code: refusal.code, message: refusal.message, ...(refusal.suggestion !== undefined ? { suggestion: refusal.suggestion } : {}) });
+        return undefined;
+    }
+}
+/**
+ * The value an author wrote, as plain JSON: an expression as its `=js:` source,
+ * a class instance as its own fields, a function dropped. Deterministic, so two
+ * compiles of one unchanged spec give equal stand-ins (D5).
+ */
+function authoredValue(value, path = []) {
+    if (value instanceof Expr)
+        return `=js:${value.js}`;
+    if (typeof value === 'function' || typeof value === 'symbol')
+        return undefined;
+    if (typeof value === 'bigint')
+        return String(value);
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (path.includes(value))
+        return '[circular]';
+    const inner = [...path, value];
+    if (Array.isArray(value))
+        return value.map((v) => authoredValue(v, inner) ?? null);
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+        const a = authoredValue(v, inner);
+        if (a !== undefined)
+            out[k] = a;
+    }
+    return out;
+}
+const VERSION_RE = /^\d+\.\d+(\.\d+)?$/;
+/**
+ * The opaque node collect mode emits for a step (or a root's trigger) whose
+ * emission was refused: the node type and the spec as authored, under its node
+ * id, with no definition (docs/CHECK_COMPILE_CONTRACT_DESIGN.md D5). A
+ * comparison of two compiles finds it equal exactly when the spec, version and
+ * name are.
+ */
+function standInNode(name, authored, version, id, parentId) {
+    const spec = (authored ?? {});
+    const kind = typeof spec.kind === 'string' ? spec.kind : undefined;
+    const registered = kind !== undefined ? FLOW_NODE_TYPES.byKind(kind, spec) : undefined;
+    return {
+        id,
+        type: registered?.type.typeName ?? bundledActionNodeType(spec) ?? kind ?? 'action',
+        typeVersion: version !== undefined && VERSION_RE.test(version) ? version : '1.0.0',
+        ...(parentId ? { parentId } : {}),
+        display: { label: name },
+        inputs: { standIn: true, spec: authoredValue(spec) },
+    };
+}
+function serializeFlow(built, opts) {
     /**
      * Definitions the flow carries (`.definitions()`, #1128), by `type@version` —
      * the third source a pinned `{ version }` resolves from, after the bundle and
@@ -1537,8 +1704,9 @@ export function serialize(built, opts = {}) {
      */
     const emittedDefs = new Map();
     /**
-     * The nodes a draft compile emitted unbound (their `BINDING_MISSING` finding):
-     * they write no binding rows by design, so the placeholder check exempts them.
+     * The nodes a draft compile emitted unbound (their `BINDING_MISSING` finding),
+     * and collect mode's stand-ins: they write no binding rows by design, so the
+     * placeholder check exempts them.
      */
     const unboundDrafts = new Set();
     /**
@@ -1572,16 +1740,18 @@ export function serialize(built, opts = {}) {
     /**
      * Refuse an `error` edge from a node whose definition has no error port: a
      * contribution-lowered node (#943) or a typed node with a bundled definition
-     * (#1011). Same predicate as `check`, so `compile --no-check` agrees with it.
+     * (#1011): ONERROR_NO_ERROR_PORT, which `check` reports from its serializer run.
      */
-    function refuseErrorEdgeWithoutPort(nodeId, stepName) {
+    function refuseErrorEdgeWithoutPort(scope, nodeId, stepName) {
         const declared = declaredErrorPorts.get(nodeId);
-        if (declared?.port === false)
-            throw new CompileRefusal('ONERROR_NO_ERROR_PORT', declaredErrorPortRefusal(stepName, declared.typeName, declared.version));
+        if (declared?.port === false) {
+            refuseOn(scope, stepName, new CompileRefusal('ONERROR_NO_ERROR_PORT', declaredErrorPortRefusal(stepName, declared.typeName, declared.version)));
+            return;
+        }
         const contributed = contributionDefs.get(nodeId);
         const def = contributed ?? bundledNodeDefs.get(nodeId);
         if (def !== undefined && !definitionHasErrorPort(def)) {
-            throw new CompileRefusal('ONERROR_NO_ERROR_PORT', errorPortRefusal(stepName, def, { bundled: contributed === undefined }));
+            refuseOn(scope, stepName, new CompileRefusal('ONERROR_NO_ERROR_PORT', errorPortRefusal(stepName, def, { bundled: contributed === undefined })));
         }
     }
     /**
@@ -1645,24 +1815,29 @@ export function serialize(built, opts = {}) {
      * gets them and one that does not is unaffected.
      */
     const sidecars = opts.sidecars ?? [];
-    /** The sidecar paths a resource's explicit `source` chose. */
-    const explicitSidecars = new Set();
+    /** The sidecar paths an explicit `source` chose → who chose it (see `addSidecar`). */
+    const explicitSidecars = new Map();
     /**
-     * Add one sidecar file. A resource whose explicit `source` names a directory
-     * another resource also writes would have the second file silently replace
-     * the first: index A's node would read B's settings. That is refused; `check`
-     * reports it first (INLINE_AGENT_RESOURCE_SOURCE_DUP). The same file twice (a
-     * subflow body emitted for two callers) is not a clash.
+     * Add one sidecar file. An agent or a resource whose explicit `source` names
+     * a directory another one also writes would have the second file silently
+     * replace the first: index A's node would read B's settings, or agent B would
+     * run with A's configuration. That is refused (INLINE_AGENT_RESOURCE_SOURCE_DUP),
+     * naming both; `owner` is the one whose `source` is explicit, as the refusal
+     * names it (`inline agent step "answer"'s context index "SOP"`). The same file
+     * twice (a subflow body emitted for two callers) is not a clash.
      */
-    const addSidecar = (file, explicitSource = false) => {
+    const addSidecar = (file, owner) => {
         const earlier = sidecars.find((f) => f.path === file.path);
+        const earlierOwner = explicitSidecars.get(file.path);
         if (earlier !== undefined && JSON.stringify(earlier.json) !== JSON.stringify(file.json)
-            && (explicitSource || explicitSidecars.has(file.path))) {
-            throw new CompileRefusal('INLINE_AGENT_RESOURCE_SOURCE_DUP', `two resources would both write "${file.path}" with different content, so the second would replace the first. `
-                + 'Give each resource its own `source`, or omit `source` to derive one.');
-        }
-        if (explicitSource)
-            explicitSidecars.add(file.path);
+            && (owner !== undefined || earlierOwner !== undefined)) {
+            const names = [earlierOwner ?? 'another agent or resource', owner ?? 'another agent or resource'];
+            throw new CompileRefusal('INLINE_AGENT_RESOURCE_SOURCE_DUP', `${names[0].charAt(0).toUpperCase()}${names[0].slice(1)} and ${names[1]} would both write "${file.path}" with `
+                + 'different content, so the second file would replace the first. Give each its own `source`, or omit '
+                + '`source` to derive one.');
+        }
+        if (owner !== undefined && earlierOwner === undefined)
+            explicitSidecars.set(file.path, owner);
         sidecars.push(file);
     };
     /**
@@ -1677,6 +1852,10 @@ export function serialize(built, opts = {}) {
         return opts.agentSource ? opts.agentSource(source, stepName) : source;
     };
     const subflows = {};
+    /** The calling steps of the subflow bodies being emitted, outermost first (`CollectedRefusal.subflows`). */
+    const subflowPath = [];
+    /** A refusal that escaped a subflow body in collect mode: scope-level, so no step's catch takes it. */
+    let scopeRefusal;
     const rootGlobals = emittableGlobals(built, `flow "${built.id}"`);
     const root = newScope(rootGlobals.outputs, rootGlobals.vars, rootGlobals.backing, rootGlobals.backingReads);
     root.openTails = built.openTails === true;
@@ -1737,15 +1916,15 @@ export function serialize(built, opts = {}) {
      * End `x2`, and an unnamed `.return()` emitted first turned a named `end`
      * into `end2`. Now:
      *
-     * - two Ends whose names give one id are refused (`check`: DUP_END_NAME);
+     * - two Ends whose names give one id are refused (DUP_END_NAME);
      * - an End whose name gives a step's id, the trigger's or an entry point's
-     *   is refused (`check`: STEP_ID_COLLISION);
+     *   is refused (STEP_ID_COLLISION);
      * - every other id is claimed here, so the ids the SDK makes up (`end`,
      *   `end2`, an agent's context node, ...) are the ones that move.
      *
-     * `check` reports these first; this is the backstop for `compile --no-check`,
-     * the draft-tolerant merge compile and a direct `serialize()`. A subflow COPY
-     * is the one place ids move: `copyPrefix` is set when the copy is prefixed.
+     * These are scope-level refusals: `check` reports the first, with no step.
+     * A subflow COPY is the one place ids move: `copyPrefix` is set when the
+     * copy is prefixed.
      */
     function claimEndIds(scope, nodes, where, reserved, copyPrefix = '') {
         const stepIds = new Map(nodes.steps.map((n) => [safeNodeId(n), n]));
@@ -1786,11 +1965,10 @@ export function serialize(built, opts = {}) {
      * node id. It is never quietly renamed:
      *
      * - Two steps whose names give the same id (`.step('x')` twice, or `a b`
-     *   beside `a_b`) are refused. `check` reports them as DUP_STEP /
-     *   STEP_ID_COLLISION; this is the backstop for every path that skips it
-     *   (`compile --no-check`, the draft-tolerant merge compile, a direct
-     *   `serialize()`). Renaming the second to `x2` left `.stepToRef('x')` and
-     *   `$vars.x` pointing at the first, with no word said.
+     *   beside `a_b`) are refused as DUP_STEP / STEP_ID_COLLISION, on every
+     *   path (`check` reports it from its serializer run, with no step: it is
+     *   thrown before any node is emitted). Renaming the second to `x2` left
+     *   `.stepToRef('x')` and `$vars.x` pointing at the first, with no word said.
      * - In the flow itself, a step named like the trigger is refused the same
      *   way (STEP_ID_COLLISION).
      * - A subflow body whose ids are already taken (a second copy of the same
@@ -1798,7 +1976,9 @@ export function serialize(built, opts = {}) {
      *   place ids move: the whole copy is prefixed with the calling step's name,
      *   and `rename` points its expressions at the prefixed ids.
      */
-    function claimStepIds(scope, names, where, copyPrefix, alsoIds = [], terminates = new Map()) {
+    function claimStepIds(scope, names, where, copyPrefix, alsoIds = [], terminates = new Map(), 
+    /** A `.parallel` fork's name → its parallel, for a fork named like a step. */
+    forks = new Map()) {
         const seen = new Map();
         for (const n of names) {
             const safe = n.replace(/[^A-Za-z0-9_]/g, '_') || 'node';
@@ -1813,9 +1993,12 @@ export function serialize(built, opts = {}) {
                         + 'names that differ in letters, digits or "_".'
                     : t >= 2 ? `${where}: [DUP_STEP] ${terminateTwiceMessage(n)}`
                         : t === 1 ? `${where}: [DUP_STEP] ${terminateStepClashMessage(n)}`
-                            : `${where}: [DUP_STEP] two steps are named "${n}". A step name is its node's id and \`.stepToRef\` / `
-                                + `\`$vars\` name it, so compile will not rename the second one "${n}2". Give each step its own name; to `
-                                + `send several paths to one step, keep one and end the others with .stepToRef('${n}').`);
+                            : forks.has(n) ? `${where}: [DUP_STEP] the fork of parallel "${forks.get(n)}" and another step are both `
+                                + `named "${n}". A step name is its node's id, so compile will not rename either one. Give one of `
+                                + 'them another name.'
+                                : `${where}: [DUP_STEP] two steps are named "${n}". A step name is its node's id and \`.stepToRef\` / `
+                                    + `\`$vars\` name it, so compile will not rename the second one "${n}2". Give each step its own name; to `
+                                    + `send several paths to one step, keep one and end the others with .stepToRef('${n}').`);
             }
             seen.set(safe, n);
         }
@@ -1837,20 +2020,35 @@ export function serialize(built, opts = {}) {
      * The node id of an agent resource: the author's `nodeId` exactly as written
      * (decompile writes the id the original file had, and a changed id is a
      * dropped node plus an added one to merge), else `uid`'s derived one. A
-     * `nodeId` another node already holds is refused rather than renamed, for
-     * the same reason; check reports it first (INLINE_AGENT_RESOURCE_NODE_ID).
+     * `nodeId` another node already holds, or an entry point's id (claimed after
+     * the body), is refused rather than renamed, for the same reason
+     * (INLINE_AGENT_RESOURCE_NODE_ID). So is a derived id an explicit `nodeId`
+     * already took: deriving `<id>2` instead would move a node the author's file
+     * names by that id.
      */
     function resourceNodeId(scope, nodeId, derivedBase, where) {
-        if (nodeId === undefined)
+        if (nodeId === undefined) {
+            const owner = explicitResourceIds.get(derivedBase.replace(/[^A-Za-z0-9_]/g, '_') || 'node');
+            if (owner !== undefined) {
+                throw new CompileRefusal('INLINE_AGENT_RESOURCE_NODE_ID', `${owner} takes the \`nodeId\` ${JSON.stringify(derivedBase)}, which is the id compile derives for ${where}, `
+                    + 'and compile will not rename either one. Give that resource another `nodeId`, or omit it to derive one.');
+            }
             return uid(scope, derivedBase);
-        if (nodeId.trim() === '' || takenIds.has(nodeId)) {
+        }
+        const entryPoint = (built.entryPoints ?? []).some((ep) => ep.id === nodeId);
+        if (nodeId.trim() === '' || takenIds.has(nodeId) || entryPoint) {
             throw new CompileRefusal('INLINE_AGENT_RESOURCE_NODE_ID', `${where}: \`nodeId\` ${JSON.stringify(nodeId)} `
-                + (nodeId.trim() === '' ? 'is blank.' : 'is already the id of another node in this flow.')
+                + (nodeId.trim() === '' ? 'is blank.'
+                    : entryPoint ? `is already the id of entry point "${nodeId}".`
+                        : 'is already the id of another node in this flow.')
                 + ' Give the resource node an id no other node has, or omit `nodeId` to derive one.');
         }
         takenIds.add(nodeId);
+        explicitResourceIds.set(nodeId, where);
         return nodeId;
     }
+    /** Each explicit resource `nodeId` → the resource that took it (see `resourceNodeId`). */
+    const explicitResourceIds = new Map();
     /**
      * The node id of an author's step: the one `claimStepIds` claimed for it,
      * recorded so `.stepToRef('<step>')` can find it.
@@ -1883,6 +2081,10 @@ export function serialize(built, opts = {}) {
      * `.stepToRef` rejoins now do come through here, #938).
      */
     const hitlNodes = new Map();
+    /** Human tasks with no per-outcome exits, and why (`FlowNodeContribution.noOutcomePorts`). */
+    const noOutcomePorts = new Map();
+    /** Per human task in `hitlNodes`, how its main path leaves it (`hitlExitViolation`'s `routing`). */
+    const hitlRouting = new Map();
     /**
      * Human tasks with outcomes that set `legacyCompleted: true`: they leave on
      * `completed` by the author's choice, so the guard exempts that one port
@@ -1903,9 +2105,26 @@ export function serialize(built, opts = {}) {
     const hitlEndExits = [];
     function addEdge(scope, from, toNode, toPort = 'input') {
         const hitlNode = hitlNodes.get(from.node);
-        const refused = hitlNode ? hitlExitViolation(hitlNode, from.port, legacyCompletedNodes.has(from.node)) : undefined;
-        if (refused)
-            throw new CompileRefusal(refused.code, `serialize: ${refused.message}`);
+        const none = from.port.startsWith('outcome-') ? noOutcomePorts.get(from.node) : undefined;
+        const refused = none
+            ? {
+                code: 'HITL_OUTCOME_PORTS_NONE',
+                message: `Port "${from.port}" routes a per-outcome exit, but human task "${stepOfNode(scope, from.node) ?? from.node}" `
+                    + `has none — ${none.why}, so its single exit is 'completed'.`,
+                suggestion: none.suggestion,
+            }
+            : hitlNode
+                ? hitlExitViolation(hitlNode, from.port, legacyCompletedNodes.has(from.node), hitlRouting.get(from.node))
+                : undefined;
+        if (refused) {
+            // On the task the edge leaves, not on the step it enters. In collect mode
+            // the edge is not written, so no later guard trips on it.
+            refuseOn(scope, stepOfNode(scope, from.node), new CompileRefusal(refused.code, `serialize: ${refused.message}`, refused.suggestion));
+            return;
+        }
+        pushEdge(scope, from, toNode, toPort);
+    }
+    function pushEdge(scope, from, toNode, toPort = 'input') {
         scope.edges.push({ id: `edge_${edgeSeq++}`, sourceNodeId: from.node, sourcePort: from.port, targetNodeId: toNode, targetPort: toPort });
     }
     let col = 0;
@@ -2025,13 +2244,22 @@ export function serialize(built, opts = {}) {
      * defect that makes a subflow validate clean and then fault at run time with
      * a null. It is emitted here, always, so it cannot be forgotten.
      */
-    function emitSubflowBody(child, nodeId) {
+    function emitSubflowBody(child, nodeId, stepName) {
         const outer = carriedDefs;
         carriedDefs = indexCarriedDefinitions(child.definitions ?? [], `subflow "${nodeId}" .definitions()`, new Map(outer));
+        subflowPath.push(stepName);
         try {
             return emitSubflowBodyIn(child, nodeId);
         }
+        catch (error) {
+            // Each step of the body had its own catch, so this refusal is the body's
+            // scope-level one: the calling step's catch must not step over it.
+            if (opts.collect && error instanceof CompileRefusal)
+                scopeRefusal = error;
+            throw error;
+        }
         finally {
+            subflowPath.pop();
             carriedDefs = outer;
         }
     }
@@ -2049,7 +2277,8 @@ export function serialize(built, opts = {}) {
         // with its steps and move with it (#1253).
         const childNodes = namedNodesOf(child.steps);
         const childTerminates = new Map();
-        const prefix = claimStepIds(scope, stepNamesOf(child.steps, [], childTerminates), `subflow "${nodeId}"`, `${nodeId}_`, childNodes.ends.map(safeNodeId), childTerminates);
+        const childForks = new Map();
+        const prefix = claimStepIds(scope, stepNamesOf(child.steps, [], childTerminates, childForks), `subflow "${nodeId}"`, `${nodeId}_`, childNodes.ends.map(safeNodeId), childTerminates, childForks);
         claimEndIds(scope, childNodes, `subflow "${nodeId}"`, [], prefix);
         const startId = uid(scope, `${nodeId}Start`);
         // A CHILD's inputs are published as the child's own start node, whose id is
@@ -2083,7 +2312,7 @@ export function serialize(built, opts = {}) {
         }
         for (const vd of childGlobals.vars)
             globals.push({ id: vd.name, name: vd.name, direction: 'inout', type: vd.type, ...varMeta(vd) });
-        resolveRejoins(scope, addEdge);
+        resolveRejoins(scope, addEdge, (from, refusal) => refuseOn(scope, stepOfNode(scope, from.node), refusal));
         assertHitlExitInvariant(scope.nodes, scope.edges, legacyCompletedNodes);
         typeAgentInputSchemas(scope, globals);
         emitStickyNotes(child, scope, claimNoteId);
@@ -2103,101 +2332,108 @@ export function serialize(built, opts = {}) {
     // node — its definition ships there with its `.v1def.json` sidecar — and it
     // replaces the start node's TYPE, exactly as the scheduled trigger does. The
     // node id stays `start`, so edges, `triggerNodeId` on flow inputs and the
-    // `output` success port are untouched.
-    const eventTriggerRc = built.trigger?.kind === 'event'
-        ? (() => {
-            if (!opts.library)
-                throw new CompileRefusal('LIBRARY_REQUIRED', `onEvent() needs a library (pass --library / set $FLOW_SDK_LIBRARY_JSON).`);
-            const sub = built.trigger.subscription;
-            const rc = opts.library.resolveEvent('trigger', sub.connector, sub.event, sub.version, sub.object);
-            refuseUnverifiedByoa(opts, 'trigger', sub);
-            return rc;
-        })()
-        : undefined;
+    // `output` success port are untouched. In collect mode a refused trigger is
+    // stood in (`emitRootNode`), so the steps after it are still judged.
+    //
     // The trigger node's id is `start` unless the flow renamed it. `input('x')`
     // lowered eagerly to `$vars.start.output.x`, so a rename is applied by the
     // same `renameRefs` pass that rewrites step names (see `rename.nodeIds`).
     const triggerId = built.triggerId ?? 'start';
-    // A custom FlowTrigger subclass (no `kind`) compiles through its own
-    // contribution: exact definition, author inputs, definition-owned identity.
-    // When the manifest declares `model.entryPointId: true` (how the platform
-    // marks entry points), the serializer mints the stable entry-point identity
-    // exactly as it does for connector event triggers — an omitted one is the
-    // classic validates-then-faults defect, so it cannot be forgotten here.
-    const builtTrigger = built.trigger;
-    const customTrigger = builtTrigger instanceof FlowTrigger && !('kind' in builtTrigger) ? builtTrigger : undefined;
-    if (customTrigger) {
-        const contribution = customTrigger.contribute(built.triggerOptions?.version !== undefined ? { requestedVersion: built.triggerOptions.version } : {});
-        const def = resolveContributionDefinition(contribution.definition, built.triggerOptions?.version, 'trigger');
-        const node = makeNode(def.nodeType, triggerId, built.triggerOptions?.label ?? def.display?.label ?? 'Start', { def, requestedVersion: built.triggerOptions?.version });
-        const inputs = renderDeep(contribution.inputs ?? {}, NO_RENAME);
-        if (def.model?.entryPointId === true && inputs.entryPointId === undefined) {
-            inputs.entryPointId = stableId(`${built.id}:start:entryPoint`);
-            if (inputs.isDefaultEntryPoint === undefined)
-                inputs.isDefaultEntryPoint = true;
-        }
-        node.inputs = inputs;
-        hoistContributionBindings(def, contribution.bindings, 'trigger');
-        root.nodes.push(node);
-    }
-    // The author's `.trigger(spec, { label })`; makeNode falls back to the definition's label.
-    const rootLabel = built.triggerOptions?.label;
-    const trigger = customTrigger
-        ? root.nodes[root.nodes.length - 1]
-        : eventTriggerRc
-            ? makeNode(eventTriggerRc.nodeType, triggerId, rootLabel, { def: eventTriggerRc.v1def, requestedVersion: built.triggerOptions?.version })
-            : built.trigger?.kind === 'scheduled'
-                ? makeNode(NODE_TYPE.scheduledTrigger, triggerId, rootLabel, {
-                    requestedVersion: scheduledVersion(built.trigger.inputs, built.triggerOptions?.version),
-                })
-                : built.trigger?.kind === 'form'
-                    ? makeNode(NODE_TYPE.formTrigger, triggerId, rootLabel, { requestedVersion: built.triggerOptions?.version })
-                    : built.trigger?.kind === 'conversation'
-                        ? makeNode(NODE_TYPE.conversationTrigger, triggerId, rootLabel, { requestedVersion: built.triggerOptions?.version })
-                        : built.trigger?.kind === 'voice'
-                            ? makeNode(NODE_TYPE.voiceTrigger, triggerId, rootLabel, { requestedVersion: built.triggerOptions?.version })
-                            : makeNode(NODE_TYPE.trigger, triggerId, rootLabel, { requestedVersion: built.triggerOptions?.version });
-    if (!customTrigger) {
-        trigger.inputs = eventTriggerRc && built.trigger?.kind === 'event'
-            ? {
-                // The deployed shape: 38 of 39 archived instances carry `entryPointId`,
-                // 28 carry `isDefaultEntryPoint: true`, and the subscription lives in
-                // `detail` (see eventDetail).
-                entryPointId: stableId(`${built.id}:start:entryPoint`),
-                isDefaultEntryPoint: true,
-                detail: eventDetail(eventTriggerRc, built.trigger.subscription, triggerId, opts, 'event trigger'),
+    const trigger = emitRootNode('trigger', triggerId, built.trigger, built.triggerOptions?.version, () => {
+        const eventTriggerRc = built.trigger?.kind === 'event'
+            ? (() => {
+                const sub = built.trigger.subscription;
+                if (!opts.library)
+                    throw libraryRequiredForEvent(opts, sub, built.triggerId ?? 'start', 'event trigger', 'onEvent()');
+                const rc = resolveEvent(opts.library, 'trigger', sub, 'trigger');
+                refuseUnverifiedByoa(opts, 'trigger', sub);
+                return rc;
+            })()
+            : undefined;
+        // A custom FlowTrigger subclass (no `kind`) compiles through its own
+        // contribution: exact definition, author inputs, definition-owned identity.
+        // When the manifest declares `model.entryPointId: true` (how the platform
+        // marks entry points), the serializer mints the stable entry-point identity
+        // exactly as it does for connector event triggers — an omitted one is the
+        // classic validates-then-faults defect, so it cannot be forgotten here.
+        const builtTrigger = built.trigger;
+        const customTrigger = builtTrigger instanceof FlowTrigger && !('kind' in builtTrigger) ? builtTrigger : undefined;
+        if (built.trigger !== undefined && !customTrigger)
+            refuseUnknownTrigger(built.trigger, '.trigger()');
+        if (customTrigger) {
+            const contribution = contributionOf(customTrigger, built.triggerOptions?.version, 'trigger');
+            const def = resolveContributionDefinition(contribution.definition, built.triggerOptions?.version, 'trigger');
+            const node = makeNode(def.nodeType, triggerId, built.triggerOptions?.label ?? def.display?.label ?? 'Start', { def, requestedVersion: built.triggerOptions?.version });
+            const inputs = renderDeep(contribution.inputs ?? {}, NO_RENAME);
+            if (def.model?.entryPointId === true && inputs.entryPointId === undefined) {
+                inputs.entryPointId = stableId(`${built.id}:start:entryPoint`);
+                if (inputs.isDefaultEntryPoint === undefined)
+                    inputs.isDefaultEntryPoint = true;
             }
-            : built.trigger?.kind === 'scheduled'
-                ? scheduleInputs(built.trigger.inputs, triggerId)
-                : built.trigger?.kind === 'form'
-                    ? {
-                        // A GUID: publish keys the form's FormTrigger binding on it and skips
-                        // the form when it is not one.
-                        entryPointId: stableId(`${built.id}:${triggerId}:entryPoint`),
-                        schema: { fields: formTriggerFields(built.inputs), outcomes: [] },
-                    }
-                    : built.trigger?.kind === 'conversation' || built.trigger?.kind === 'voice'
-                        // Both are entry points (`model.entryPointId: true`) with nothing else
-                        // authored: what the platform started — the conversation, or the live
-                        // call's `callContext` — is the trigger's own declared output.
-                        ? { entryPointId: triggerId }
-                        : {};
-    }
-    if (eventTriggerRc && built.trigger?.kind === 'event') {
-        // An event trigger's def declares the same connection binding names a
-        // mid-flow connector's does — close them (G-19; see connectionResourceBindings).
-        const sub = built.trigger.subscription;
-        const { entries } = connectionResourceBindings({
-            def: eventTriggerRc.v1def,
-            connectorKey: eventTriggerRc.connectorKey,
-            connectionId: resolveBinding(opts, sub.connection, 'connection', 'event trigger', eventTarget(sub)),
-            folderKey: resolveBinding(opts, sub.folder, 'folder', 'event trigger', eventTarget(sub)),
-        }, resourceBindings);
-        for (const b of entries)
-            resourceBindings.set(b.id, b);
-    }
-    if (!customTrigger)
-        root.nodes.push(trigger);
+            node.inputs = inputs;
+            hoistContributionBindings(def, contribution.bindings, 'trigger');
+            root.nodes.push(node);
+        }
+        // The author's `.trigger(spec, { label })`; makeNode falls back to the definition's label.
+        const rootLabel = built.triggerOptions?.label;
+        const trigger = customTrigger
+            ? root.nodes[root.nodes.length - 1]
+            : eventTriggerRc
+                ? makeNode(eventTriggerRc.nodeType, triggerId, rootLabel, { def: eventTriggerRc.v1def, requestedVersion: built.triggerOptions?.version })
+                : built.trigger?.kind === 'scheduled'
+                    ? makeNode(NODE_TYPE.scheduledTrigger, triggerId, rootLabel, {
+                        requestedVersion: scheduledVersion(built.trigger.inputs, built.triggerOptions?.version),
+                    })
+                    : built.trigger?.kind === 'form'
+                        ? makeNode(NODE_TYPE.formTrigger, triggerId, rootLabel, { requestedVersion: built.triggerOptions?.version })
+                        : built.trigger?.kind === 'conversation'
+                            ? makeNode(NODE_TYPE.conversationTrigger, triggerId, rootLabel, { requestedVersion: built.triggerOptions?.version })
+                            : built.trigger?.kind === 'voice'
+                                ? makeNode(NODE_TYPE.voiceTrigger, triggerId, rootLabel, { requestedVersion: built.triggerOptions?.version })
+                                : makeNode(NODE_TYPE.trigger, triggerId, rootLabel, { requestedVersion: built.triggerOptions?.version });
+        if (!customTrigger) {
+            trigger.inputs = eventTriggerRc && built.trigger?.kind === 'event'
+                ? {
+                    // The deployed shape: 38 of 39 archived instances carry `entryPointId`,
+                    // 28 carry `isDefaultEntryPoint: true`, and the subscription lives in
+                    // `detail` (see eventDetail).
+                    entryPointId: stableId(`${built.id}:start:entryPoint`),
+                    isDefaultEntryPoint: true,
+                    detail: eventDetail(eventTriggerRc, built.trigger.subscription, triggerId, opts, 'event trigger'),
+                }
+                : built.trigger?.kind === 'scheduled'
+                    ? scheduleInputs(built.trigger.inputs, triggerId)
+                    : built.trigger?.kind === 'form'
+                        ? {
+                            // A GUID: publish keys the form's FormTrigger binding on it and skips
+                            // the form when it is not one.
+                            entryPointId: stableId(`${built.id}:${triggerId}:entryPoint`),
+                            schema: { fields: formTriggerFields(built.inputs), outcomes: [] },
+                        }
+                        : built.trigger?.kind === 'conversation' || built.trigger?.kind === 'voice'
+                            // Both are entry points (`model.entryPointId: true`) with nothing else
+                            // authored: what the platform started — the conversation, or the live
+                            // call's `callContext` — is the trigger's own declared output.
+                            ? { entryPointId: triggerId }
+                            : {};
+        }
+        if (eventTriggerRc && built.trigger?.kind === 'event') {
+            // An event trigger's def declares the same connection binding names a
+            // mid-flow connector's does — close them (G-19; see connectionResourceBindings).
+            const sub = built.trigger.subscription;
+            const { entries } = connectionResourceBindings({
+                def: eventTriggerRc.v1def,
+                connectorKey: eventTriggerRc.connectorKey,
+                connectionId: resolveBinding(opts, sub.connection, 'connection', 'event trigger', eventTarget(sub)),
+                folderKey: resolveBinding(opts, sub.folder, 'folder', 'event trigger', eventTarget(sub)),
+            }, resourceBindings);
+            for (const b of entries)
+                resourceBindings.set(b.id, b);
+        }
+        if (!customTrigger)
+            root.nodes.push(trigger);
+        return trigger;
+    });
     function successPort(type) {
         if (type === NODE_TYPE.loop)
             return 'success';
@@ -2216,7 +2452,7 @@ export function serialize(built, opts = {}) {
      */
     function emitContribution(spec, stepName, requestedVersion, tails, scope, parentId) {
         const where = `step "${stepName}"`;
-        const contribution = spec.contribute(requestedVersion !== undefined ? { requestedVersion } : {});
+        const contribution = contributionOf(spec, requestedVersion, where);
         const def = resolveContributionDefinition(contribution.definition, requestedVersion, where);
         // A connector definition reached this path only through a raw or hand-written
         // contribution — `connector()` never does — and would be emitted without
@@ -2269,10 +2505,19 @@ export function serialize(built, opts = {}) {
         // 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 (contribution.noOutcomePorts)
+            noOutcomePorts.set(id, contribution.noOutcomePorts);
         if (o.trackOutcomes && contribution.legacyCompleted)
             legacyCompletedNodes.add(id);
-        else if (o.trackOutcomes && OUTCOME_HANDLE_NODE_TYPES.has(o.typeName))
+        else if (o.trackOutcomes && OUTCOME_HANDLE_NODE_TYPES.has(o.typeName)) {
             hitlNodes.set(id, node);
+            // How its main path leaves it: every outcome (a fan-out), or the primary one.
+            const port = contribution.port;
+            if (contribution.fanOut)
+                hitlRouting.set(id, 'every-outcome');
+            else if (port?.startsWith('outcome-'))
+                hitlRouting.set(id, { primary: port });
+        }
         for (const a of contribution.attach ?? []) {
             const def = a.definition;
             const rnode = makeNode(def.nodeType, a.id, a.label, { parentId: o.parentId, def });
@@ -2367,7 +2612,7 @@ export function serialize(built, opts = {}) {
                     resourceBindings.set(b.id, b);
             },
             agentSource: (carried) => agentFolder(carried, step.name),
-            sidecar: (file, explicitSource) => addSidecar(file, explicitSource),
+            sidecar: (file, owner) => addSidecar(file, owner === true ? 'another agent or resource' : owner === false ? undefined : owner),
             typeAgentInputs: (schema, refs) => { scope.agentSchemas.push({ schema: schema, refs: [...refs] }); },
             resourceNodeId: (explicit, seed, at) => resourceNodeId(scope, explicit, seed, at),
             emitted: (typeName, v) => emittedDefs.get(`${typeName}@${v}`),
@@ -2484,6 +2729,169 @@ export function serialize(built, opts = {}) {
             rendered,
         });
     }
+    /**
+     * What a throw out of one node's emission is, in collect mode: a refusal as
+     * it is, and any other throw (a `TypeError` on a spec the serializer has no
+     * refusal for) as COMPILE_FAILED, which is what `compile` reports for it. An
+     * `internal SDK error:`, and a subflow body's scope-level refusal, are passed on.
+     */
+    function stepRefusal(error) {
+        if (error === scopeRefusal)
+            throw error;
+        if (error instanceof CompileRefusal)
+            return error;
+        if (!(error instanceof Error) || error.message.startsWith('internal SDK error:'))
+            throw error;
+        return new CompileRefusal('COMPILE_FAILED', error.message);
+    }
+    /** Report `refusal` to collect mode, on `step` (node `nodeId`) when it has one. */
+    function record(refusal, step, nodeId) {
+        opts.collect?.({
+            code: refusal.code, message: refusal.message,
+            ...(refusal.suggestion !== undefined ? { suggestion: refusal.suggestion } : {}),
+            ...(step !== undefined ? { step, ...(nodeId !== undefined ? { nodeId } : {}) } : {}),
+            ...(step !== undefined && subflowPath.length ? { subflows: [...subflowPath] } : {}),
+        });
+    }
+    /**
+     * Refuse at a site past a step's own emission (an edge out of it, a port list
+     * on it, a join it feeds), on the step the refusal is about. Collect mode
+     * records it there and goes on with the graph as authored, so later steps are
+     * still judged; any other compile throws it. With no owning step it throws in
+     * collect mode too: then it is scope-level.
+     */
+    function refuseOn(scope, stepName, refusal) {
+        if (!opts.collect || stepName === undefined)
+            throw refusal;
+        record(refusal, stepName, scope.stepNodeId.get(stepName) ?? scope.pending.get(stepName));
+    }
+    /** The step whose node `nodeId` is, in `scope`. */
+    function stepOfNode(scope, nodeId) {
+        for (const [name, id] of scope.stepNodeId)
+            if (id === nodeId)
+                return name;
+        return undefined;
+    }
+    /**
+     * Emit one root's trigger node (the flow's trigger, an entry point), standing
+     * it in when its emission is refused in collect mode, as `emitStep` does for a
+     * step: reported on `name`, and the steps after it are still judged.
+     */
+    function emitRootNode(name, id, spec, version, emitNode) {
+        if (!opts.collect)
+            return emitNode();
+        const mark = { nodes: root.nodes.length, resources: new Set(resourceBindings.keys()) };
+        try {
+            return emitNode();
+        }
+        catch (error) {
+            const refusal = stepRefusal(error);
+            record(refusal, name, id);
+            root.nodes.length = mark.nodes;
+            for (const key of [...resourceBindings.keys()])
+                if (!mark.resources.has(key))
+                    resourceBindings.delete(key);
+            unboundDrafts.add(id);
+            const node = standInNode(name, spec, version, id, undefined);
+            root.nodes.push(node);
+            return node;
+        }
+    }
+    /**
+     * Emit one action step and `finish` it (its updates and label). In collect
+     * mode (`SerializeOpts.collect`) this is the per-step catch: a refusal is
+     * reported on the step, everything the step had emitted is undone, and a
+     * stand-in node takes its place, wired to the same tails.
+     */
+    function emitStep(step, tails, scope, parentId, finish) {
+        const collect = opts.collect;
+        if (!collect) {
+            const out = emitAction(step, tails, scope, parentId);
+            finish();
+            return out;
+        }
+        const mark = {
+            nodes: scope.nodes.length, edges: scope.edges.length, pendingEdges: scope.pendingEdges.length,
+            agentSchemas: scope.agentSchemas.length, sidecars: sidecars.length,
+        };
+        try {
+            const out = emitAction(step, tails, scope, parentId);
+            finish();
+            return out;
+        }
+        catch (error) {
+            const refusal = stepRefusal(error);
+            const id = scope.stepNodeId.get(step.name) ?? stepUid(scope, step.name);
+            record(refusal, step.name, id);
+            scope.nodes.length = mark.nodes;
+            scope.edges.length = mark.edges;
+            scope.pendingEdges.length = mark.pendingEdges;
+            scope.agentSchemas.length = mark.agentSchemas;
+            for (const f of sidecars.splice(mark.sidecars)) {
+                if (!sidecars.some((kept) => kept.path === f.path))
+                    explicitSidecars.delete(f.path);
+            }
+            delete scope.variableUpdates[id];
+            delete subflows[id];
+            // An error port recorded before the throw is the type's answer; keep it for the stand-in.
+            const knownPort = declaredErrorPorts.get(id);
+            for (const byId of [contributionDefs, bundledNodeDefs, declaredErrorPorts, hitlNodes, hitlRouting, noOutcomePorts])
+                byId.delete(id);
+            legacyCompletedNodes.delete(id);
+            capsOpenTail.delete(id);
+            routerNodes.delete(step.name);
+            // No binding rows and no definition: the placeholder check passes it, as a draft's.
+            unboundDrafts.add(id);
+            scope.nodes.push(standInNode(step.name, step.spec, step.options?.version, id, parentId));
+            // Its error port is its type's, so an `.onError` after it is still judged.
+            const port = standInErrorPort(step) ?? knownPort;
+            if (port)
+                declaredErrorPorts.set(id, port);
+            // Wired as any node is: an edge a human task does not have is refused on
+            // the task (`addEdge`, collect mode) and not written.
+            for (const t of tails) {
+                try {
+                    addEdge(scope, t, id);
+                }
+                catch (edgeError) {
+                    if (!(edgeError instanceof CompileRefusal))
+                        throw edgeError;
+                    record(edgeError);
+                }
+            }
+            return [{ node: id, port: 'output' }];
+        }
+    }
+    /**
+     * Whether a refused step's node type has an error port, as its emission would
+     * have recorded it: a registered type's declaration or bundled definition.
+     * `undefined` when the type cannot say (a custom node, a pin no version
+     * resolves) and nothing was recorded before the throw: its edge is not judged.
+     */
+    function standInErrorPort(step) {
+        const spec = step.spec;
+        const entry = typeof spec.kind === 'string' ? FLOW_NODE_TYPES.byKind(spec.kind, spec) : undefined;
+        if (!entry)
+            return undefined;
+        try {
+            const resolved = resolveVersionCarried(entry.type, spec, step.options?.version, `step "${step.name}"`, carriedFor);
+            const impl = resolved.impl;
+            if (resolved.carried !== undefined) {
+                return { port: definitionHasErrorPort(resolved.carried), typeName: impl.typeName, version: resolved.version };
+            }
+            if (impl.definition === 'bundled') {
+                const def = bundledDefinition(impl.typeName, resolved.version);
+                return def === undefined ? undefined : { port: definitionHasErrorPort(def), typeName: def.nodeType, version: def.version };
+            }
+            const port = typeof impl.errorPort === 'function' ? impl.errorPort(spec, undefined) : impl.errorPort === true;
+            return { port, typeName: impl.typeName, version: resolved.version };
+        }
+        catch (error) {
+            if (error instanceof CompileRefusal)
+                return undefined;
+            throw error;
+        }
+    }
     function emitAction(step, tails, scope, parentId) {
         const spec = step.spec;
         // A registered node type serializes itself; every other kind falls through to
@@ -2515,17 +2923,24 @@ export function serialize(built, opts = {}) {
                 addEdge(scope, t, id);
             // Emit the body AFTER the node exists, so a child that itself calls a
             // subflow registers its own entry in the same flat map.
-            subflows[id] = emitSubflowBody(spec.child, id);
+            subflows[id] = emitSubflowBody(spec.child, id, step.name);
             return [{ node: id, port: successPort(NODE_TYPE.subflow) }];
         }
         if (spec.kind === 'waitEvent') {
-            if (!opts.library)
-                throw new CompileRefusal('LIBRARY_REQUIRED', `waitForEvent "${step.name}" needs a library (pass --library / set $FLOW_SDK_LIBRARY_JSON).`);
             const sub = spec.subscription;
-            const rc = opts.library.resolveEvent('event', sub.connector, sub.event, sub.version, sub.object);
+            // An event wait resumes or it does not: it has no error port to route.
+            // Recorded before anything can refuse the step, so a stand-in keeps it.
+            declaredErrorPorts.set(scope.pending.get(step.name) ?? step.name, {
+                port: false, typeName: `uipath.connector.event.${sub?.connector}.${sub?.event}`, version: step.options?.version ?? sub?.version ?? '1.0.0',
+            });
+            if (!opts.library) {
+                throw libraryRequiredForEvent(opts, sub, scope.pending.get(step.name) ?? step.name, `waitForEvent "${step.name}"`, `waitForEvent "${step.name}"`);
+            }
+            const rc = resolveEvent(opts.library, 'event', sub, `waitForEvent "${step.name}"`);
             refuseUnverifiedByoa(opts, `waitForEvent "${step.name}"`, sub);
             const id = stepUid(scope, step.name);
             const node = makeNode(rc.nodeType, id, step.name, { parentId, requestedVersion: step.options?.version, def: rc.v1def });
+            declaredErrorPorts.set(id, { port: false, typeName: rc.nodeType, version: String(rc.v1def?.version ?? node.typeVersion) });
             node.inputs = { detail: eventDetail(rc, sub, id, opts, `waitForEvent "${step.name}"`) };
             // Same connection-binding closure as the connector branch (G-19).
             const { entries: waitConnBindings } = connectionResourceBindings({
@@ -2594,12 +3009,11 @@ export function serialize(built, opts = {}) {
     /**
      * Refuse a side exit on a human task's port that the step's tails already
      * continue from: that would put two edges on one port (flow-builder-sdk#741).
-     * After a fan-out task that is EVERY outcome port. `check` reports the same
-     * as HITL_OUTCOME_PORTS_OFF; this is the compile-side half. A
+     * After a fan-out task that is EVERY outcome port (HITL_OUTCOME_PORTS_OFF). A
      * `legacyCompleted` task counts too: its main path leaves on `completed`, so a
      * side route there is the same second edge.
      */
-    function refuseRewire(method, port, source, tails) {
+    function refuseRewire(scope, method, port, source, tails) {
         const node = tails[0]?.node ?? '';
         if (!(hitlNodes.has(node) || legacyCompletedNodes.has(node)) || !tails.some((t) => t.port === port))
             return;
@@ -2607,12 +3021,14 @@ export function serialize(built, opts = {}) {
         // outcome, which is check's HITL_OUTCOME_PORTS_OFF. One tail: that port
         // already continues the main path (a routed task's primary outcome, or a
         // legacyCompleted task's `completed`), and outcomePorts would not help.
-        throw new CompileRefusal(tails.length > 1 ? 'HITL_OUTCOME_PORTS_OFF' : 'HITL_PORT_ALREADY_WIRED', tails.length > 1
+        refuseOn(scope, source, new CompileRefusal(tails.length > 1 ? 'HITL_OUTCOME_PORTS_OFF' : 'HITL_PORT_ALREADY_WIRED', tails.length > 1
             ? `${method}('${port}', …) after human task "${source}": every outcome already continues to the next `
                 + `step, '${port}' included, because this task does not route per outcome. Add outcomePorts: true `
                 + `(the first outcome then continues and the others are routed), or route every outcome with .stepSwitch.`
             : `${method}('${port}', …) after human task "${source}": '${port}' already continues the main path, so `
-                + `routing it here too would put two edges on one port (flow-builder-sdk#741).`);
+                + `routing it here too would put two edges on one port (flow-builder-sdk#741).`, tails.length > 1
+            ? 'outcomePorts: true (then the first outcome continues and the others are routed), or route every outcome with .stepSwitch'
+            : undefined));
     }
     /**
      * A step list hanging off a named PORT of the step just emitted.
@@ -2635,7 +3051,7 @@ export function serialize(built, opts = {}) {
         if (tails.length === 0 || tails.some((t) => t.node !== tails[0].node)) {
             throw new Error(`internal SDK error: .stepToList('${step.port}', …) after step "${source}": expected the step to leave from exactly one node, got ${tails.length} tail(s).`);
         }
-        refuseRewire('.stepToList', step.port, source, tails);
+        refuseRewire(scope, '.stepToList', step.port, source, tails);
         const nodeId = tails[0].node;
         const node = scope.nodes.find((n) => n.id === nodeId);
         if (!node)
@@ -2643,7 +3059,7 @@ export function serialize(built, opts = {}) {
         // 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') {
-            refuseErrorEdgeWithoutPort(nodeId, source);
+            refuseErrorEdgeWithoutPort(scope, nodeId, source);
             node.inputs = { ...(node.inputs ?? {}), errorHandlingEnabled: true };
         }
         const handlerTails = emit(handler, [{ node: nodeId, port: step.port }], scope, parentId, loopExits);
@@ -2709,14 +3125,12 @@ export function serialize(built, opts = {}) {
             // follow: nothing continues from it, so a step here would hang off no edge.
             const router = lastAction !== undefined && tails.length === 0 ? routerNodes.get(lastAction) : undefined;
             if (router !== undefined && step.kind !== 'stepToList' && step.kind !== 'stepToRef') {
-                throw new CompileRefusal('TEMPLATED_EXITS_ONLY', `step "${lastAction}": its definition declares only templated exits (such as case-{item.id}), so no `
+                refuseOn(scope, lastAction, new CompileRefusal('TEMPLATED_EXITS_ONLY', `step "${lastAction}": its definition declares only templated exits (such as case-{item.id}), so no `
                     + `path continues from it and ${'name' in step ? `"${step.name}"` : `.${step.kind}()`} after it would `
-                    + `have no incoming edge. Route each exit with .stepToList('<port>', …), e.g. .stepToList('case-<id>', …).`);
+                    + `have no incoming edge. Route each exit with .stepToList('<port>', …), e.g. .stepToList('case-<id>', …).`));
             }
             if (step.kind === 'action') {
-                tails = emitAction(step, tails, scope, parentId);
-                applyUpdates(step);
-                applyLabel(step);
+                tails = emitStep(step, tails, scope, parentId, () => { applyUpdates(step); applyLabel(step); });
                 lastAction = step.name;
                 // A fan-out human task's `action: 'End'` outcomes end the run here: the
                 // flow runtime never reads `action`, so only an End node can. When the
@@ -2750,11 +3164,13 @@ export function serialize(built, opts = {}) {
                 // no routable fan-out (a human task pinned to 1.0, a variant, an http
                 // with no branches) must refuse rather than emit a node and then
                 // discover it has one port. `stepExits` carries the reason.
-                const exits = stepExits(step.spec, step.options?.version);
-                if (!hasExits(exits)) {
-                    throw new CompileRefusal('STEP_SWITCH_NO_EXITS', `.stepSwitch("${step.name}"): ${exits.reason}, so there are no exits to route.`
-                        + (exits.suggestion ? ` ${exits.suggestion}` : ''));
+                const declaredExits = stepExits(step.spec, step.options?.version);
+                if (!hasExits(declaredExits)) {
+                    refuseOn(scope, step.name, new CompileRefusal('STEP_SWITCH_NO_EXITS', `.stepSwitch("${step.name}"): ${declaredExits.reason}, so there are no exits to route.`, declaredExits.suggestion));
                 }
+                // In collect mode, past a refusal, each arm is still emitted (from the
+                // port its value names), so the steps in it are judged.
+                const exits = hasExits(declaredExits) ? declaredExits : [];
                 const action = {
                     kind: 'action', name: step.name, spec: step.spec,
                     ...(step.options ? { options: step.options } : {}),
@@ -2763,9 +3179,7 @@ export function serialize(built, opts = {}) {
                 // primary outcome, http's `default`. Discarded on purpose: every exit is
                 // an arm here, so that port is wired by the arm that names it (and
                 // wiring both is flow-builder-sdk#741).
-                emitAction(action, tails, scope, parentId);
-                applyUpdates(action);
-                applyLabel(action);
+                emitStep(action, tails, scope, parentId, () => { applyUpdates(action); applyLabel(action); });
                 const nodeId = scope.stepNodeId.get(step.name);
                 if (!nodeId)
                     throw new Error(`internal SDK error: .stepSwitch("${step.name}"): emitted node not found.`);
@@ -2775,11 +3189,13 @@ export function serialize(built, opts = {}) {
                 // in `.return()` here, an outcome with no arm below.
                 const stopped = [];
                 for (const c of step.cases) {
-                    const exit = exits.find((e) => e.value === c.value);
-                    if (!exit) {
-                        throw new CompileRefusal('STEP_SWITCH_EXIT_UNKNOWN', `.stepSwitch("${step.name}"): no exit named ${JSON.stringify(c.value)}. `
-                            + `It declares ${exits.map((e) => JSON.stringify(e.value)).join(', ')}.`);
+                    const found = exits.find((e) => e.value === c.value);
+                    if (!found && hasExits(declaredExits)) {
+                        const nearest = nearestName(c.value, exits.map((e) => e.value));
+                        refuseOn(scope, step.name, new CompileRefusal('STEP_SWITCH_EXIT_UNKNOWN', `.stepSwitch("${step.name}") has an arm for ${JSON.stringify(c.value)}, which is not `
+                            + `an exit it declares — those are ${exits.map((e) => JSON.stringify(e.value)).join(', ')}.`, nearest !== undefined ? `value: '${nearest}'` : undefined));
                     }
+                    const exit = found ?? { value: c.value, port: String(c.value) };
                     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
@@ -2899,9 +3315,9 @@ export function serialize(built, opts = {}) {
                 // The join waits for a token on EVERY incoming edge, and a fan-out human
                 // task's outcome edges are mutually exclusive — only one fires. So two
                 // of them straight into the join, or an End outcome beside a continuing
-                // one, hang the run with no incident. check reports both
-                // (HITL_FAN_OUT_INTO_JOIN, HITL_END_OUTCOME_IN_PARALLEL); this is the
-                // compile-side half, and it fails closed.
+                // one, hang the run with no incident: HITL_FAN_OUT_INTO_JOIN and
+                // HITL_END_OUTCOME_IN_PARALLEL, worded from the step tree
+                // (`flow-parallel-hitl.ts`). It fails closed.
                 // The fork, when the author names one (`{ fork }`, #1310): a merge node
                 // with one incoming edge and one edge per arm — the gateway Studio Web
                 // draws for a parallel split. The arms then leave from it instead of
@@ -2913,9 +3329,9 @@ export function serialize(built, opts = {}) {
                     // fan-out task's outcomes — must not both enter it: only one fires
                     // and the arms never start. Fails closed, as the join does.
                     if (tails.length > 1) {
-                        throw new CompileRefusal('PARALLEL_FORK_ALTERNATIVES', `.parallel("${step.name}"): its fork "${fork.name}" would receive ${tails.length} alternative edges `
+                        refuseOn(scope, step.name, new CompileRefusal('PARALLEL_FORK_ALTERNATIVES', `.parallel("${step.name}"): its fork "${fork.name}" would receive ${tails.length} alternative edges `
                             + `(${tails.map((t) => `${t.node}@${t.port}`).join(', ')}), and only one of them fires while the gateway `
-                            + `waits for all of them. Add a step before the .parallel so the paths meet there first, or drop { fork }.`);
+                            + `waits for all of them. Add a step before the .parallel so the paths meet there first, or drop { fork }.`));
                     }
                     const forkId = stepUid(scope, fork.name);
                     const forkNode = makeNode(NODE_TYPE.merge, forkId, fork.label ?? fork.name, { parentId, requestedVersion: fork.version ?? step.options?.version });
@@ -2927,8 +3343,13 @@ export function serialize(built, opts = {}) {
                 }
                 const armTails = [];
                 const endsBefore = hitlEndExits.length;
-                for (const arm of step.arms) {
+                for (const [armIndex, arm] of step.arms.entries()) {
                     const t = emit(arm, tails, scope, parentId, loopExits);
+                    // Worded from the step tree, which names the outcomes; this graph's tails decide.
+                    const fanIn = () => {
+                        const treeTails = hitlFanInto(arm);
+                        return treeTails && fanInRefusal(step.name, armIndex, arm, treeTails);
+                    };
                     // An arm hands the join ONE edge, or several that are alternatives —
                     // `.branch` / `.switch` / `.stepSwitch` arms, a fan-out task's
                     // outcomes — of which only one fires. Refused when any of them is a
@@ -2941,26 +3362,34 @@ export function serialize(built, opts = {}) {
                     // a complete `.stepSwitch` with nothing after it hands the join one
                     // edge per arm, and still only one arm runs.
                     const switchTail = outcomeTail ? undefined : t.find((x) => x.humanSwitch !== undefined);
+                    // Each is the human task's refusal, so it is reported on the task.
                     if (t.length >= 2 && switchTail) {
-                        throw new CompileRefusal('HITL_FAN_OUT_INTO_JOIN', `.parallel("${step.name}"): an arm sends ${t.length} alternative edges into join "${step.name}" — `
-                            + `among them the end of an arm of human task "${switchTail.humanSwitch}"'s .stepSwitch — and only one `
-                            + `of them fires, while the join waits for all of them. Add a step at the end of the arm, after the `
-                            + `.stepSwitch, so its arms meet there first, or move the task out of the .parallel.`);
+                        const worded = fanIn();
+                        refuseOn(scope, worded?.task ?? switchTail.humanSwitch, new CompileRefusal('HITL_FAN_OUT_INTO_JOIN', worded?.message
+                            ?? `.parallel("${step.name}"): an arm sends ${t.length} alternative edges into join "${step.name}" — `
+                                + `among them the end of an arm of human task "${switchTail.humanSwitch}"'s .stepSwitch — and only one `
+                                + `of them fires, while the join waits for all of them. Add a step at the end of the arm, after the `
+                                + `.stepSwitch, so its arms meet there first, or move the task out of the .parallel.`, worded?.suggestion));
                     }
-                    if (t.length >= 2 && outcomeTail) {
-                        throw new CompileRefusal('HITL_FAN_OUT_INTO_JOIN', `.parallel("${step.name}"): an arm sends ${t.length} alternative edges into join "${step.name}" — `
-                            + `among them outcome edge "${outcomeTail.port}" of human task "${outcomeTail.node}" — and only one `
-                            + `of them fires, while the join waits for all of them. Add a step at the end of the arm so its paths `
-                            + `meet there first, or move the task out of the .parallel.`);
+                    else if (t.length >= 2 && outcomeTail) {
+                        const worded = fanIn();
+                        refuseOn(scope, worded?.task ?? stepOfNode(scope, outcomeTail.node), new CompileRefusal('HITL_FAN_OUT_INTO_JOIN', worded?.message
+                            ?? `.parallel("${step.name}"): an arm sends ${t.length} alternative edges into join "${step.name}" — `
+                                + `among them outcome edge "${outcomeTail.port}" of human task "${outcomeTail.node}" — and only one `
+                                + `of them fires, while the join waits for all of them. Add a step at the end of the arm so its paths `
+                                + `meet there first, or move the task out of the .parallel.`, worded?.suggestion));
                     }
                     armTails.push(...t);
                 }
                 const starved = hitlEndExits.slice(endsBefore).find((x) => x.scope === scope && x.parentId === parentId);
                 if (starved && armTails.length > 0) {
-                    throw new CompileRefusal('HITL_END_OUTCOME_IN_PARALLEL', `.parallel("${step.name}"): human task "${starved.step}" ${starved.why} inside an arm, and join `
-                        + `"${step.name}" would wait forever for the path that continues. Give every outcome a path that `
-                        + `continues to the end of the arm (drop action: 'End', add the missing .stepSwitch arm, move the `
-                        + `.return() after the .parallel), or move the task out of the .parallel.`);
+                    const hazard = step.arms.flatMap((arm) => hitlEndHazards(arm)).find((h) => h.step === starved.step);
+                    const worded = hazard && endOutcomeRefusal(step.name, hazard);
+                    refuseOn(scope, starved.step, new CompileRefusal('HITL_END_OUTCOME_IN_PARALLEL', worded?.message
+                        ?? `.parallel("${step.name}"): human task "${starved.step}" ${starved.why} inside an arm, and join `
+                            + `"${step.name}" would wait forever for the path that continues. Give every outcome a path that `
+                            + `continues to the end of the arm (drop action: 'End', add the missing .stepSwitch arm, move the `
+                            + `.return() after the .parallel), or move the task out of the .parallel.`, worded?.suggestion));
                 }
                 // When EVERY arm is terminal — a terminate, or an End — there is nothing
                 // left to join, and emitting a Merge would add a node with no incoming
@@ -3001,8 +3430,10 @@ export function serialize(built, opts = {}) {
                 const loopDef = definitionFor(NODE_TYPE.loop, version);
                 const refusal = loopVersionRefusal(step.name, o, usesBreak, loopDef);
                 if (refusal)
-                    throw new CompileRefusal('LOOP_VERSION_UNSUPPORTED', refusal);
-                const v24 = loopHasInnerHandles(version, loopDef);
+                    refuseOn(scope, step.name, new CompileRefusal('LOOP_VERSION_UNSUPPORTED', refusal));
+                // Past that refusal (collect mode) the body is emitted with the handles it
+                // asks for, so a `.break()` in it is not refused a second time.
+                const v24 = loopHasInnerHandles(version, loopDef) || refusal !== undefined;
                 const declared = loopDeclaredInputs(loopDef);
                 const id = stepUid(scope, step.name);
                 const node = makeNode(NODE_TYPE.loop, id, step.options?.label ?? step.label ?? step.name, { parentId, requestedVersion: version });
@@ -3073,8 +3504,7 @@ export function serialize(built, opts = {}) {
                 // A Terminate is a `.stepToRef` target (its name is a step name), so a
                 // second `.terminate` asking for a name this scope already holds is
                 // refused, not renamed `<name>2`: that rename turned one Terminate two
-                // paths share into two Terminates with no word said (#1239). `check`
-                // reports it first as DUP_STEP; this is the backstop for `--no-check`.
+                // paths share into two Terminates with no word said (#1239): DUP_STEP.
                 // The remedy depends on what holds the name: another Terminate (end the
                 // other paths at it) or a step of another kind (rename one).
                 if (scope.stepNodeId.has(step.name)) {
@@ -3116,9 +3546,9 @@ export function serialize(built, opts = {}) {
                     const from = tails[0] ?? (router !== undefined ? { node: router, port: step.port } : undefined);
                     if (!from)
                         throw new Error(`internal SDK error: .stepToRef('${step.port}', '${step.target}') has no step to leave from.`);
-                    refuseRewire('.stepToRef', step.port, lastAction ?? '?', tails);
+                    refuseRewire(scope, '.stepToRef', step.port, lastAction ?? '?', tails);
                     if (step.port === 'error') {
-                        refuseErrorEdgeWithoutPort(from.node, lastAction ?? from.node);
+                        refuseErrorEdgeWithoutPort(scope, from.node, lastAction ?? from.node);
                         const node = scope.nodes.find((n) => n.id === from.node);
                         if (node)
                             node.inputs = { ...(node.inputs ?? {}), errorHandlingEnabled: true };
@@ -3166,8 +3596,7 @@ export function serialize(built, opts = {}) {
                 else {
                     // A repeat that DIFFERS is refused, not renamed `<name>2`: the rename
                     // turned one End shared by two paths into two Ends with no word said
-                    // (#1231). `check` reports it first as DUP_END_NAME; this is the
-                    // backstop for `--no-check`.
+                    // (#1231): DUP_END_NAME.
                     if (prior) {
                         throw new CompileRefusal('DUP_END_NAME', `Two .return({}, { name: '${name}' }) calls ask for the same End with different values, label, version, updates or scope. `
                             + `To end several paths at one End, keep one .return and end the others with .stepToRef('${name}'); `
@@ -3198,10 +3627,11 @@ export function serialize(built, opts = {}) {
     // id the SDK makes up is the one that moves (#1253).
     {
         const rootTerminates = new Map();
-        const rootSteps = stepNamesOf(built.steps, [], rootTerminates);
+        const rootForks = new Map();
+        const rootSteps = stepNamesOf(built.steps, [], rootTerminates, rootForks);
         for (const ep of built.entryPoints ?? [])
-            stepNamesOf(ep.steps, rootSteps, rootTerminates);
-        claimStepIds(root, rootSteps, `flow "${built.id}"`, undefined, [], rootTerminates);
+            stepNamesOf(ep.steps, rootSteps, rootTerminates, rootForks);
+        claimStepIds(root, rootSteps, `flow "${built.id}"`, undefined, [], rootTerminates, rootForks);
         const seenEnds = new Set();
         const rootNodes = namedNodesOf(built.steps, undefined, seenEnds);
         for (const ep of built.entryPoints ?? [])
@@ -3235,75 +3665,80 @@ export function serialize(built, opts = {}) {
                 throw new CompileRefusal('ENTRY_POINT_DUP_ID', `.entryPoint("${ep.id}"): the id collides with a step, the trigger, or another entry point.`);
             }
             takenIds.add(ep.id);
-            const spec = ep.trigger;
-            const requestedVersion = ep.options?.version;
-            // The author's label; makeNode falls back to the definition's label.
-            const epLabel = ep.options?.label;
-            const customEp = spec instanceof FlowTrigger && !('kind' in spec) ? spec : undefined;
-            const epSpec = spec;
-            let node;
-            if (customEp) {
-                const contribution = customEp.contribute(requestedVersion !== undefined ? { requestedVersion } : {});
-                const def = resolveContributionDefinition(contribution.definition, requestedVersion, `entryPoint "${ep.id}"`);
-                node = makeNode(def.nodeType, ep.id, ep.options?.label ?? def.display?.label ?? ep.id, { def, requestedVersion });
-                node.inputs = {
-                    entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`),
-                    ...renderDeep(contribution.inputs ?? {}, NO_RENAME),
-                };
-                hoistContributionBindings(def, contribution.bindings, `entryPoint "${ep.id}"`);
-            }
-            else if (epSpec.kind === 'event') {
-                if (!opts.library)
-                    throw new CompileRefusal('LIBRARY_REQUIRED', `onEvent() needs a library (pass --library / set $FLOW_SDK_LIBRARY_JSON).`);
-                const sub = epSpec.subscription;
-                const rc = opts.library.resolveEvent('trigger', sub.connector, sub.event, sub.version, sub.object);
-                refuseUnverifiedByoa(opts, 'trigger', sub);
-                node = makeNode(rc.nodeType, ep.id, epLabel, { def: rc.v1def, requestedVersion });
-                node.inputs = {
-                    entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`),
-                    detail: eventDetail(rc, sub, ep.id, opts, `onEvent() entry point "${ep.id}"`),
-                };
-                const { entries } = connectionResourceBindings({
-                    def: rc.v1def,
-                    connectorKey: rc.connectorKey,
-                    connectionId: resolveBinding(opts, sub.connection, 'connection', 'onEvent() entry point', eventTarget(sub)),
-                    folderKey: resolveBinding(opts, sub.folder, 'folder', 'onEvent() entry point', eventTarget(sub)),
-                }, resourceBindings);
-                for (const b of entries)
-                    resourceBindings.set(b.id, b);
-            }
-            else if (epSpec.kind === 'scheduled') {
-                node = makeNode(NODE_TYPE.scheduledTrigger, ep.id, epLabel, {
-                    requestedVersion: scheduledVersion(epSpec.inputs, requestedVersion),
-                });
-                node.inputs = {
-                    entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`),
-                    ...scheduleInputs(epSpec.inputs, ep.id),
-                };
-            }
-            else if (epSpec.kind === 'form') {
-                node = makeNode(NODE_TYPE.formTrigger, ep.id, epLabel, { requestedVersion });
-                node.inputs = {
-                    entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`),
-                    schema: { fields: formTriggerFields(ep.inputs), outcomes: [] },
-                };
-            }
-            else if (epSpec.kind === 'conversation') {
-                node = makeNode(NODE_TYPE.conversationTrigger, ep.id, epLabel, { requestedVersion });
-                node.inputs = { entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`) };
-            }
-            else if (epSpec.kind === 'voice') {
-                node = makeNode(NODE_TYPE.voiceTrigger, ep.id, epLabel, { requestedVersion });
-                node.inputs = { entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`) };
-            }
-            else if (epSpec.kind === 'manual') {
-                node = makeNode(NODE_TYPE.trigger, ep.id, epLabel, { requestedVersion });
-                node.inputs = { entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`) };
-            }
-            else {
-                throw new CompileRefusal('TRIGGER_UNKNOWN_KIND', `.entryPoint("${ep.id}"): unsupported trigger kind ${JSON.stringify(epSpec.kind)}.`);
-            }
-            root.nodes.push(node);
+            // Stood in when refused in collect mode, so its prefix and the body are still judged.
+            emitRootNode(ep.id, ep.id, ep.trigger, ep.options?.version, () => {
+                const spec = ep.trigger;
+                const requestedVersion = ep.options?.version;
+                // The author's label; makeNode falls back to the definition's label.
+                const epLabel = ep.options?.label;
+                const customEp = spec instanceof FlowTrigger && !('kind' in spec) ? spec : undefined;
+                const epSpec = spec;
+                let node;
+                if (customEp) {
+                    const contribution = contributionOf(customEp, requestedVersion, `entryPoint "${ep.id}"`);
+                    const def = resolveContributionDefinition(contribution.definition, requestedVersion, `entryPoint "${ep.id}"`);
+                    node = makeNode(def.nodeType, ep.id, ep.options?.label ?? def.display?.label ?? ep.id, { def, requestedVersion });
+                    node.inputs = {
+                        entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`),
+                        ...renderDeep(contribution.inputs ?? {}, NO_RENAME),
+                    };
+                    hoistContributionBindings(def, contribution.bindings, `entryPoint "${ep.id}"`);
+                }
+                else if (epSpec.kind === 'event') {
+                    const sub = epSpec.subscription;
+                    if (!opts.library)
+                        throw libraryRequiredForEvent(opts, sub, ep.id, `onEvent() entry point "${ep.id}"`, 'onEvent()');
+                    const rc = resolveEvent(opts.library, 'trigger', sub, 'trigger');
+                    refuseUnverifiedByoa(opts, 'trigger', sub);
+                    node = makeNode(rc.nodeType, ep.id, epLabel, { def: rc.v1def, requestedVersion });
+                    node.inputs = {
+                        entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`),
+                        detail: eventDetail(rc, sub, ep.id, opts, `onEvent() entry point "${ep.id}"`),
+                    };
+                    const { entries } = connectionResourceBindings({
+                        def: rc.v1def,
+                        connectorKey: rc.connectorKey,
+                        connectionId: resolveBinding(opts, sub.connection, 'connection', 'onEvent() entry point', eventTarget(sub)),
+                        folderKey: resolveBinding(opts, sub.folder, 'folder', 'onEvent() entry point', eventTarget(sub)),
+                    }, resourceBindings);
+                    for (const b of entries)
+                        resourceBindings.set(b.id, b);
+                }
+                else if (epSpec.kind === 'scheduled') {
+                    node = makeNode(NODE_TYPE.scheduledTrigger, ep.id, epLabel, {
+                        requestedVersion: scheduledVersion(epSpec.inputs, requestedVersion),
+                    });
+                    node.inputs = {
+                        entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`),
+                        ...scheduleInputs(epSpec.inputs, ep.id),
+                    };
+                }
+                else if (epSpec.kind === 'form') {
+                    node = makeNode(NODE_TYPE.formTrigger, ep.id, epLabel, { requestedVersion });
+                    node.inputs = {
+                        entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`),
+                        schema: { fields: formTriggerFields(ep.inputs), outcomes: [] },
+                    };
+                }
+                else if (epSpec.kind === 'conversation') {
+                    node = makeNode(NODE_TYPE.conversationTrigger, ep.id, epLabel, { requestedVersion });
+                    node.inputs = { entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`) };
+                }
+                else if (epSpec.kind === 'voice') {
+                    node = makeNode(NODE_TYPE.voiceTrigger, ep.id, epLabel, { requestedVersion });
+                    node.inputs = { entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`) };
+                }
+                else if (epSpec.kind === 'manual') {
+                    node = makeNode(NODE_TYPE.trigger, ep.id, epLabel, { requestedVersion });
+                    node.inputs = { entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`) };
+                }
+                else {
+                    refuseUnknownTrigger(epSpec, `.entryPoint("${ep.id}")`);
+                    throw new Error(`internal SDK error: .entryPoint("${ep.id}"): trigger kind ${JSON.stringify(epSpec.kind)} has no emitter.`);
+                }
+                root.nodes.push(node);
+                return node;
+            });
             const prefixTails = emit(ep.steps, [{ node: ep.id, port: 'output' }], root);
             for (const t of prefixTails) {
                 if (!sharedTarget) {
@@ -3356,7 +3791,7 @@ export function serialize(built, opts = {}) {
             globals.push({ id: inp.name, name: inp.name, direction: 'in', type: inp.type, triggerNodeId: ep.id, ...varMeta(inp) });
         }
     }
-    resolveRejoins(root, addEdge);
+    resolveRejoins(root, addEdge, (from, refusal) => refuseOn(root, stepOfNode(root, from.node), refusal));
     assertHitlExitInvariant(root.nodes, root.edges, legacyCompletedNodes);
     typeAgentInputSchemas(root, globals);
     emitStickyNotes(built, root, claimNoteId);
@@ -3364,10 +3799,10 @@ export function serialize(built, opts = {}) {
     assertNodeEnvelope(root.nodes, `flow "${built.id}"`);
     // The FILE-FORMAT version this document declares: the author's
     // `.schemaVersion()` when they set one, else the profile's write floor. It is
-    // resolved HERE rather than in `check()` alone because the serializer must not
-    // stamp a version it cannot back even when the static pass was skipped
-    // (`compile --no-check`, `emitFlow`, a direct `serialize()`); an unwritable
-    // value throws with the same sentence `check()` reports.
+    // resolved HERE because the serializer must not stamp a version it cannot back
+    // on any path (`compile`, `emitFlow`, a direct `serialize()`); an unwritable
+    // value is SCHEMA_VERSION_UNSUPPORTED, which `check` reports from its
+    // serializer run.
     const schemaVersion = resolveSchemaVersion(FLOW_SCHEMA_VERSIONS, built.schemaVersion);
     const flow = {
         id: built.id,