@uipath/maestro-builder-sdk 6.59.1 → 6.61.0

package/dist/check.js

@@ -2,61 +2,39 @@
  * check — static validation of a BuiltFlow before serialization.
  *
  * Produces structured, actionable diagnostics (the kind an agent can act on):
- * duplicate step names, references to undeclared variables/steps, empty branch
- * arms, and missing terminals.
+ * references to undeclared variables/steps, empty branch arms, missing
+ * terminals, and every refusal `compile` would raise (duplicate step names, an
+ * input a connector does not declare, …), which it gets by running the
+ * serializer in collect mode (`serializerRefusals`), so each of those rules
+ * lives in the serializer alone.
  */
 import { Expr, SCHEDULE_PRESETS, parallelFork } from './flow-sdk.js';
 import { FlowNode } from './core/node-classes.js';
-import { planContributionBindings } from './core/contribution-bindings.js';
-import { definitionHasErrorPort, errorPortRefusal } from './core/error-port.js';
-import { bundledActionNodeType, bundledContainerDefinition, bundledDefinition, resolveContributionDefinition } from './serialize.js';
+import { definitionHasErrorPort } from './core/error-port.js';
+import { bundledDefinition, resolveContributionDefinition, serialize } from './serialize.js';
 import { checkEventResolution, checkEventSubscription, eventParamsFor, } from './core/event-checks.js';
 import { checkCookedEscapes } from './flow-expr-check.js';
-import { FLOW_EXPR_DIALECT, checkBindingLabels, checkBindingPresence, checkConnectorContract as coreCheckConnectorContract, checkConnectorLookups as coreCheckConnectorLookups, checkConnectorSchema as coreCheckConnectorSchema, collectConnectionUses, connectionConnectorConflicts, } from './core/connector-checks.js';
-import { commentText } from './core/comment-text.js';
+import { FLOW_EXPR_DIALECT, checkBindingLabels, checkConnectorLookups as coreCheckConnectorLookups, checkConnectorSchema as coreCheckConnectorSchema, } from './core/connector-checks.js';
 import { nearestName } from './core/edit-distance.js';
 import { hitlDerivesOutcomeHandles, hitlExitModel, hitlRoutesPerOutcome, outcomeIdOf } from './core/hitl-routing.js';
 import { hasExits } from './core/step-ports.js';
-import { stopsAtEnd } from './flow-step-tree.js';
+import { actionTails, armReachesJoin } from './flow-parallel-hitl.js';
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { compareSchemaVersions, schemaVersionRefusal } from './schema-version.js';
-import { planFlowGlobals, planSharedInputs, sharedInputRoots } from './flow-variables.js';
-import { planOutputBacking } from './flow-output-backing.js';
+import { planSharedInputs, sharedInputRoots } from './flow-variables.js';
 import { VARS_READ_RE } from './core/vars-read.js';
-import { terminateStepClashMessage, terminateTwiceMessage } from './flow-terminate-names.js';
 import { endContentKey } from './flow-end-content.js';
 import { FLOW_NODE_TYPES } from './flow-node-registry.js';
 import { stepExits } from './flow-step-exits.js';
 import { stepDeclaredVariables } from './flow-step-variables.js';
 import { plainHttpOnErrorMessage } from './nodes/http/flow/family.js';
 import { resolveVersion, resolveVersionCarried } from './core/nodes/versioned.js';
-import { declaredErrorPortRefusal } from './core/error-port.js';
-import { bodyUsesBreak, loopParallelWarning, loopVersionRefusal, resolveLoopDefinition, loopVersion } from './loop-version.js';
-const newResourceIdLedger = () => ({ explicit: new Map(), taken: new Map(), agentSources: new Map() });
-/** INLINE_AGENT_RESOURCE_NODE_ID for each explicit `nodeId` another node of the file also gets. */
-function resourceNodeIdClashes(ledger) {
-    const out = [];
-    for (const [id, { step, what }] of ledger.explicit) {
-        const other = ledger.taken.get(id);
-        if (other === undefined)
-            continue;
-        out.push({
-            level: 'error', code: 'INLINE_AGENT_RESOURCE_NODE_ID', step,
-            message: `Inline agent step "${step}" gives its ${what} the \`nodeId\` "${id}", which is already `
-                + `${other}. Node ids are unique in a flow, so compile cannot write both. Give the resource another id, `
-                + 'or omit `nodeId` to derive one.',
-        });
-    }
-    return out;
-}
+import { loopParallelWarning, resolveLoopDefinition, loopVersion } from './loop-version.js';
 export function check(built, opts = {}) {
-    let diags = [];
-    const ledger = newResourceIdLedger();
-    const uses = collectConnectionUses(() => { diags = checkFlow(built, [], opts, ledger); });
-    diags.push(...resourceNodeIdClashes(ledger));
-    for (const { id, message } of connectionConnectorConflicts(uses, opts)) {
-        diags.push({ level: 'error', code: 'CONNECTION_CONNECTOR_CONFLICT', step: id, message });
-    }
+    // A connection two connectors use, and an agent resource's `nodeId` another
+    // node of the file has, are the serializer's CONNECTION_CONNECTOR_CONFLICT /
+    // INLINE_AGENT_RESOURCE_NODE_ID: it claims ids and resolves connections file-wide.
+    const diags = checkFlow(built, [], opts);
     // Once, from the top: the walk reaches child flows itself, so running it per
     // `checkFlow` would report a child's escape twice.
     for (const d of checkCookedEscapes(built)) {
@@ -66,37 +44,65 @@ export function check(built, opts = {}) {
             ...(d.suggestion ? { suggestion: d.suggestion } : {}),
         });
     }
+    if (opts.serializer !== false)
+        diags.push(...serializerRefusals(built, { library: opts.library, bindings: opts.bindings }, diags));
     return diags;
 }
+/** The error-level diagnostics a custom node's own `diagnostics()` reported (see `serializerRefusals`). */
+const OWN_NODE_ERRORS = new WeakSet();
 /**
- * A step's node id is its name with every character outside `[A-Za-z0-9_]`
- * made `_`, and `compile` never renames one to make it unique (#1249). So two
- * different names that give one id (`a b` and `a_b`), or a step of the flow
- * itself named like its trigger, are an error here, as the same name twice is
- * DUP_STEP. `serialize` refuses both too, for the paths that skip `check`.
- * A subflow's own start is the SDK's to name, so `trigger` is the flow's only.
+ * Every refusal `compile` would raise for `built`: the serializer, run in
+ * collect mode (docs/CHECK_COMPILE_CONTRACT_DESIGN.md §3.5), so each rule it
+ * enforces is reported from its one implementation. A refusal inside a subflow
+ * is worded and placed as `check` words a child's findings: `In subflow "call": …`
+ * on step `call › x`.
+ *
+ * A throw that is no refusal (a malformed spec the serializer has no refusal
+ * for) comes back as COMPILE_FAILED, on its step, which is what `compile` says;
+ * on a step `check` already refuses it is that refusal's consequence and is not
+ * repeated. An `internal SDK error:` is passed on, unless `check` or the
+ * serializer already found an error: `compile` runs `check` first and stops at
+ * its errors, so it never serializes such a flow, and the author has those
+ * errors to fix first.
  */
-function checkStepIds(stepNames, trigger, diags) {
-    const byId = new Map();
-    for (const name of stepNames) {
-        const id = name.replace(/[^A-Za-z0-9_]/g, '_') || 'node';
-        const first = byId.get(id);
-        if (first !== undefined) {
-            diags.push({
-                level: 'error', code: 'STEP_ID_COLLISION', step: name,
-                message: `Steps "${first}" and "${name}" would both get node id "${id}". Give them names that differ in `
-                    + 'letters, digits or "_".',
-            });
-        }
-        else if (id === trigger) {
-            diags.push({
-                level: 'error', code: 'STEP_ID_COLLISION', step: name,
-                message: `Step "${name}" has the trigger's node id "${id}". Rename the step.`,
-            });
-        }
-        if (first === undefined)
-            byId.set(id, name);
+function serializerRefusals(built, compile, found) {
+    const collected = [];
+    try {
+        serialize(built, { ...compile, collect: (r) => collected.push(r) });
+    }
+    catch (error) {
+        // LIBRARY_REQUIRED is dropped below, so it does not count as something reported.
+        if (!found.some((d) => d.level === 'error') && !collected.some((r) => r.code !== 'LIBRARY_REQUIRED'))
+            throw error;
+    }
+    const out = [];
+    const seen = new Set();
+    for (const r of collected) {
+        // "Compile needs a library" is about compile's inputs, not the flow: a check
+        // run without one fails open, as its library rules do.
+        if (r.code === 'LIBRARY_REQUIRED')
+            continue;
+        const subflows = r.subflows ?? [];
+        const step = r.step !== undefined ? [...subflows, r.step].join(' › ') : undefined;
+        // A custom node whose own diagnostics() reported an error has said why it
+        // cannot be lowered; its contribute() throwing too is not a second finding.
+        if (r.code === 'CONTRIBUTION_INVALID' && found.some((d) => d.step === step && OWN_NODE_ERRORS.has(d)))
+            continue;
+        if (r.code === 'COMPILE_FAILED' && found.some((d) => d.level === 'error' && d.step === step))
+            continue;
+        const message = subflows.reduceRight((m, caller) => `In subflow "${caller}": ${m}`, r.message);
+        // One finding per step path: the same refusal twice there is one rule broken once.
+        const key = `${r.code}\n${step ?? ''}\n${message}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({
+            level: 'error', code: r.code, message,
+            ...(step !== undefined ? { step } : {}),
+            ...(r.suggestion !== undefined ? { suggestion: r.suggestion } : {}),
+        });
     }
+    return out;
 }
 /**
  * `ancestors` is the chain of child flows currently being checked, innermost
@@ -104,7 +110,7 @@ function checkStepIds(stepNames, trigger, diags) {
  * to notice a flow that (transitively) calls itself before the serializer
  * recurses forever.
  */
-function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger()) {
+function checkFlow(built, ancestors, opts = {}) {
     const diags = [];
     if (!built.id)
         diags.push({ level: 'error', code: 'NO_ID', message: 'flow() requires an id.' });
@@ -115,11 +121,9 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
     if (maybeCustomTrigger !== undefined && !('kind' in maybeCustomTrigger) && maybeCustomTrigger instanceof FlowNode) {
         // A custom FlowTrigger subclass reports through its own diagnostics() hook;
         // the built-in trigger rules key on `kind` and don't apply.
-        const own = maybeCustomTrigger.diagnostics();
-        for (const d of own) {
+        for (const d of maybeCustomTrigger.diagnostics()) {
             diags.push({ level: d.severity, code: d.code, message: d.message, step: 'trigger' });
         }
-        checkContribution(maybeCustomTrigger, built.triggerOptions?.version, 'trigger', own.some((d) => d.severity === 'error'), diags);
     }
     else if (built.trigger !== undefined)
         checkTrigger(built.trigger, diags, opts);
@@ -315,27 +319,11 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
                 ? { kind: 'action', name: s0.name, spec: s0.spec, ...(s0.options ? { options: s0.options } : {}) }
                 : s0;
             // `return` carries a synthetic `name` that names no node and is not
-            // referenceable — registering it would report DUP_STEP the second time one
-            // appears. The port-edge kinds carry no name at all.
+            // referenceable, so it is not registered. The port-edge kinds carry no
+            // name at all.
             if ('name' in s && s.kind !== 'return') {
-                if (stepNames.has(s.name)) {
-                    // Two `.terminate('<name>')` calls are two Terminate nodes: the second
-                    // would be renamed `<name>2`, so paths that all stop at ONE Terminate
-                    // come back with an extra node (#1239). Same code as any step clash (a
-                    // Terminate's name is a step name), with the remedy spelled out.
-                    // A step and a Terminate sharing a name (either order) get the same
-                    // words serialize throws for them: rename one.
-                    const twoTerminates = s.kind === 'terminate' && terminateNames.has(s.name);
-                    const oneTerminate = (s.kind === 'terminate') !== terminateNames.has(s.name);
-                    diags.push({
-                        level: 'error', code: 'DUP_STEP', step: s.name,
-                        message: twoTerminates
-                            ? terminateTwiceMessage(s.name)
-                            : oneTerminate
-                                ? terminateStepClashMessage(s.name)
-                                : `Duplicate step name "${s.name}".`,
-                    });
-                }
+                // A name already taken in this scope is the serializer's DUP_STEP, with
+                // the remedy for a step and a Terminate, or two Terminates (#1239).
                 stepNames.add(s.name);
                 declared.add(s.name); // a step's output is referenceable by name
                 // …and so is every variable the step declares by running: a quick
@@ -345,7 +333,7 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
                         declared.add(v);
             }
             if ((s.kind === 'stepToList' || s.kind === 'stepToRef') && s.port === 'error')
-                checkOnError(s, prevPortSource, diags, prevPortSource && checkedSteps.get(prevPortSource.name), opts, carriedLookup([built, ...ancestors]));
+                checkOnError(s, prevPortSource, diags, prevPortSource && checkedSteps.get(prevPortSource.name), opts);
             if ((s.kind === 'stepToList' || s.kind === 'stepToRef') && s.port.startsWith('branch-')) {
                 const want = s.port.slice('branch-'.length);
                 const prevSpec = prevAction?.spec;
@@ -361,38 +349,9 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
                     });
                 }
             }
-            // The mirror of HITL_OUTCOME_PORTS_OFF below: `completed` on a base or
-            // quick-form human task that has outcomes.
-            //
-            // The product draws one `outcome-<id>` handle per outcome on those two node
-            // types, at every definition version, and `completed` only when there are
-            // none (flow-workbench `build-handle-customization.ts`). An edge on it is
-            // stale: Studio Web and the converter remap it to the PRIMARY outcome
-            // (#3512), so every other outcome loses its path — and `flow validate`
-            // accepts it without `handleCustomization`, so nothing later catches it.
-            // `serialize` refuses to emit one; this says why, in the author's terms.
-            if ((s.kind === 'stepToList' || s.kind === 'stepToRef') && s.port === 'completed') {
-                const prevSpec = prevAction?.spec;
-                const isHitl = !!prevSpec && 'kind' in prevSpec && prevSpec.kind === 'hitl';
-                const model = isHitl ? hitlExitModel(prevSpec.inputs, prevAction?.options?.version) : undefined;
-                if (model && model.shape !== 'placeholder') {
-                    const ports = model.exits.map((e) => `"${e.port}"`).join(', ');
-                    const routed = model.shape === 'per-outcome';
-                    diags.push({
-                        level: 'error', code: 'HITL_COMPLETED_PORT_GONE', step: prevAction?.name,
-                        message: `Port "completed" does not exist on human task "${prevAction?.name}". It has outcomes, so `
-                            + `the product draws one handle per outcome (${ports}) and no 'completed' — an edge there is `
-                            + `remapped to the primary outcome and the others lose their path. `
-                            + (routed
-                                ? `The FIRST outcome ("${model.exits[0]?.port}") is what continues the main path.`
-                                : `.step() after this task already continues every outcome to the next step.`),
-                        suggestion: routed
-                            ? `route the outcomes (.stepToList('${model.exits[1]?.port ?? model.exits[0]?.port}', …)), or continue `
-                                + `every outcome to the next step with outcomePorts: false`
-                            : `drop the 'completed' route — .step() continues every outcome — or route each outcome with .stepSwitch`,
-                    });
-                }
-            }
+            // `completed` on a base or quick-form human task that has outcomes is the
+            // serializer's HITL_COMPLETED_PORT_GONE: the product draws one
+            // `outcome-<id>` handle per outcome and no `completed` (#3512).
             if ((s.kind === 'stepToList' || s.kind === 'stepToRef') && s.port.startsWith('outcome-')) {
                 const want = s.port.slice('outcome-'.length);
                 const prevSpec = prevAction?.spec;
@@ -407,41 +366,12 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
                 else {
                     const model = hitlExitModel(prevSpec.inputs, prevAction?.options?.version);
                     const ids = (prevSpec.inputs.outcomes ?? []).map((o, i) => outcomeIdOf(o, i));
-                    if (model.shape === 'placeholder') {
-                        diags.push({
-                            level: 'error', code: 'HITL_OUTCOME_PORTS_OFF', step: prevAction?.name,
-                            message: `Port "${s.port}" routes a per-outcome exit, but human task "${prevAction?.name}" `
-                                + `has none — ${ids.length === 0 ? 'it declares no outcomes'
-                                    : model.legacyCompleted ? 'it sets legacyCompleted: true'
-                                        : `the '${prevSpec.inputs?.variant}' variant reads its outcomes from its app`}, so its single `
-                                + `exit is 'completed'.`,
-                            suggestion: model.legacyCompleted
-                                ? 'drop `legacyCompleted` (and set outcomePorts: true to route each outcome)'
-                                : `route on out('${prevAction?.name}', 'Action') downstream`,
-                        });
-                    }
-                    else if (!ids.includes(want)) {
-                        diags.push({
-                            level: 'error', code: 'HITL_OUTCOME_PORT_UNKNOWN', step: prevAction?.name,
-                            message: `Port "${s.port}" routes the outcome id ${JSON.stringify(want)}, but human task `
-                                + `"${prevAction?.name}" declares ${ids.map((i) => `outcome-${i}`).join(', ')}. Ids are the `
-                                + `outcome names slugified (lowercase, non-alphanumerics to '-').`,
-                        });
-                    }
-                    else if (model.shape === 'every-outcome') {
-                        // The port is real, but it is ALREADY wired: a task that does not
-                        // route per outcome continues every outcome to the next step, so a
-                        // second route would put two edges on one port (#741).
-                        diags.push({
-                            level: 'error', code: 'HITL_OUTCOME_PORTS_OFF', step: prevAction?.name,
-                            message: `Port "${s.port}" is already wired: human task "${prevAction?.name}" does not route per `
-                                + `outcome — ${fanOutWhy(model.why, prevAction?.options?.version)} — so .step() continues every `
-                                + `outcome to the next step, "${s.port}" included. A second route would put two edges on one port.`,
-                            suggestion: `outcomePorts: true (then the first outcome continues and the others are routed), `
-                                + `or route every outcome with .stepSwitch`,
-                        });
-                    }
-                    else if (prevAction) {
+                    // A task with no per-outcome exits, an id the task does not declare,
+                    // and a port a task that does not route per outcome already continues
+                    // on are the serializer's HITL_OUTCOME_PORTS_NONE /
+                    // HITL_OUTCOME_PORT_UNKNOWN / HITL_OUTCOME_PORTS_OFF (#741). A routed
+                    // port is recorded for the unrouted-outcome rule.
+                    if (model.shape === 'per-outcome' && ids.includes(want) && prevAction) {
                         let routed = hitlOutcomeRouted.get(prevAction.name);
                         if (!routed)
                             hitlOutcomeRouted.set(prevAction.name, routed = new Set());
@@ -454,7 +384,7 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
                 prevPortSource = s;
                 const registered = registeredKind(s.spec);
                 if (registered) {
-                    const { placed, checked } = checkRegisteredStep(registered, s, exprs, errorSource, opts, diags, typeOf, triggerId, ledger, carriedLookup([built, ...ancestors]));
+                    const { placed, checked } = checkRegisteredStep(registered, s, exprs, errorSource, opts, diags, typeOf, triggerId, carriedLookup([built, ...ancestors]));
                     checkedSteps.set(s.name, checked);
                     if (placed)
                         registeredSteps.set(s.name, checked);
@@ -468,11 +398,12 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
                 // don't apply, and it reports through its own diagnostics() hook.
                 const maybeCustom = s.spec;
                 if (!('kind' in maybeCustom) && maybeCustom instanceof FlowNode) {
-                    const own = maybeCustom.diagnostics();
-                    for (const d of own) {
-                        diags.push({ level: d.severity, code: d.code, message: d.message, step: s.name });
+                    for (const d of maybeCustom.diagnostics()) {
+                        const diag = { level: d.severity, code: d.code, message: d.message, step: s.name };
+                        if (d.severity === 'error')
+                            OWN_NODE_ERRORS.add(diag);
+                        diags.push(diag);
                     }
-                    checkContribution(maybeCustom, s.options?.version, s.name, own.some((d) => d.severity === 'error'), diags);
                 }
                 // `.stepSwitch` routes its exits as ARMS, so the `.stepToList` bookkeeping
                 // would report every one of them unrouted. STEP_SWITCH_EXIT_UNROUTED is
@@ -527,10 +458,10 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
                         level, code, message, step: stepName,
                         ...(suggestion ? { suggestion } : {}),
                     });
-                    checkEventSubscription(s.spec.subscription, `waitForEvent "${stepName}"`, push('error'), push('warning'), eventParamsFor(s.spec.subscription, opts));
-                    checkEventResolution(s.spec.subscription, `waitForEvent "${stepName}"`, 'event', opts, push('error'), push('warning'), eventParamsFor(s.spec.subscription, opts));
-                    checkBindingLabels(`waitForEvent "${stepName}"`, s.spec.subscription, opts, push('error'), eventTarget(s.spec.subscription), { id: stepName, connector: eventTarget(s.spec.subscription)?.key });
-                    checkBindingPresence(`waitForEvent "${stepName}"`, s.spec.subscription, push('error'), eventTarget(s.spec.subscription));
+                    // What compile refuses (the event itself, its filters, its binding
+                    // labels) is the serializer's, reported from its run.
+                    checkEventSubscription(s.spec.subscription, `waitForEvent "${stepName}"`, push('error'), push('warning'), eventParamsFor(s.spec.subscription, opts), false);
+                    checkEventResolution(s.spec.subscription, `waitForEvent "${stepName}"`, 'event', opts, push('error'), push('warning'), eventParamsFor(s.spec.subscription, opts), false);
                 }
                 if (s.spec.kind === 'subflow') {
                     // Only a real child goes in the map: a missing one is reported by
@@ -689,12 +620,6 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
                 // clashes, and a read of it is a read of a merge — nothing.
                 const fork = parallelFork(s.options);
                 if (fork) {
-                    if (stepNames.has(fork.name)) {
-                        diags.push({
-                            level: 'error', code: 'DUP_STEP', step: s.name,
-                            message: `Duplicate step name "${fork.name}": the fork of parallel "${s.name}" and another step share it.`,
-                        });
-                    }
                     stepNames.add(fork.name);
                     declared.add(fork.name);
                     parallelNames.add(fork.name);
@@ -711,15 +636,11 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
                 checkLoopListEnvelope(s, registeredSteps, opts, diags);
                 if (s.options?.completionCondition)
                     addExpr(s.options.completionCondition.js, s.name);
-                // The same refusal serialize throws, from the same helper: an option or
-                // a `.break()` the pinned version's definition cannot express (#1186).
-                // Against the definition the loop compiles against — bundled, else
-                // carried — as serialize resolves it, so a carried 1.0's `.break()`
-                // and `parallel: true` are judged here and not first at compile (#1311).
+                // An option or a `.break()` the pinned version's definition cannot express
+                // is the serializer's LOOP_VERSION_UNSUPPORTED (#1186). The legacy
+                // `parallel` warning is judged against the same definition — bundled, else
+                // carried — as serialize resolves it (#1311).
                 const loopDef = resolveLoopDefinition(loopVersion(s.options), carriedLookup([built, ...ancestors]));
-                const versionRefusal = loopVersionRefusal(s.name, s.options, bodyUsesBreak(s.body), loopDef);
-                if (versionRefusal)
-                    diags.push({ level: 'error', code: 'LOOP_VERSION_UNSUPPORTED', step: s.name, message: versionRefusal });
                 const parallelWarning = loopParallelWarning(s.name, s.options, loopDef);
                 if (parallelWarning)
                     diags.push({ level: 'warning', code: 'LOOP_PARALLEL_LEGACY', step: s.name, message: parallelWarning });
@@ -753,24 +674,11 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
                     diags.push({ level: 'warning', code: 'EMPTY_LOOP', message: `Do-while "${s.name}" has an empty body.`, step: s.name });
                 walk(s.body, true);
             }
-            else if (s.kind === 'break') {
-                if (!inLoop) {
-                    diags.push({
-                        level: 'error', code: 'BREAK_OUTSIDE_LOOP',
-                        message: '.break() is only valid inside a .loop() or .doWhile() body.',
-                    });
-                }
-            }
             else if (s.kind === 'continue') {
-                if (!inLoop) {
-                    diags.push({
-                        level: 'error', code: 'CONTINUE_OUTSIDE_LOOP',
-                        message: '.continue() is only valid inside a .loop() or .doWhile() body: it goes on to the container\'s next iteration.',
-                    });
-                }
-                else if (inLoop === 'arm') {
+                // Outside any container it is the serializer's CONTINUE_OUTSIDE_LOOP (and
+                // `.break()`'s BREAK_OUTSIDE_LOOP).
+                if (inLoop === 'arm')
                     diags.push(loopExitInArm());
-                }
             }
             else if (s.kind === 'return') {
                 // A named End (`.return({…}, { name })`) is a node merge can place a
@@ -784,16 +692,12 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
             // AFTER the dispatch chain, not inside it: `s` was normalised to an action
             // above, so an `else if` here would be unreachable — which it silently was
             // on the first cut. The action rules have run by now; what is left is the
-            // arms and the three things only this step can get wrong.
+            // arms and the things only this step can get wrong. A step with no exits
+            // to route, and an arm for an exit it does not declare, are the
+            // serializer's STEP_SWITCH_NO_EXITS / STEP_SWITCH_EXIT_UNKNOWN.
             if (s0.kind === 'stepSwitch') {
                 const exits = stepExits(s0.spec, s0.options?.version);
                 if (!hasExits(exits)) {
-                    diags.push({
-                        level: 'error', code: 'STEP_SWITCH_NO_EXITS', step: s0.name,
-                        message: `.stepSwitch("${s0.name}") routes this step's declared exits, but ${exits.reason}, `
-                            + `so there are none to route.`,
-                        ...(exits.suggestion ? { suggestion: exits.suggestion } : {}),
-                    });
                     for (const c of s0.cases)
                         walk(c.body, inLoop);
                 }
@@ -801,23 +705,14 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
                     const seenExit = new Set();
                     for (const c of s0.cases) {
                         const exit = exits.find((e) => e.value === c.value);
-                        if (!exit) {
-                            const nearest = nearestName(c.value, exits.map((e) => e.value));
-                            diags.push({
-                                level: 'error', code: 'STEP_SWITCH_EXIT_UNKNOWN', step: s0.name,
-                                message: `.stepSwitch("${s0.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 ? { suggestion: `value: '${nearest}'` } : {}),
-                            });
-                        }
-                        else if (seenExit.has(exit.port)) {
+                        if (exit !== undefined && seenExit.has(exit.port)) {
                             diags.push({
                                 level: 'error', code: 'STEP_SWITCH_EXIT_DUP', step: s0.name,
                                 message: `.stepSwitch("${s0.name}") has two arms for ${JSON.stringify(c.value)}. A port takes `
                                     + `exactly one outgoing edge, so put everything that exit needs in one arm.`,
                             });
                         }
-                        else {
+                        else if (exit !== undefined) {
                             seenExit.add(exit.port);
                         }
                         if (c.body.length === 0) {
@@ -893,32 +788,14 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
     reportUnreachableHitlOutcomes(hitlChoiceNoPorts, exprs, diags);
     checkRegisteredFamilies(registeredSteps, unresolvedSteps, stepNames, diags);
     checkPackageNodes(registeredSteps, diags);
-    // The ids this scope's other nodes get, for the file-wide nodeId check in `check`.
-    for (const n of stepNames)
-        if (!ledger.taken.has(n))
-            ledger.taken.set(n, `the id of step "${n}"`);
-    if (!ledger.taken.has(triggerId))
-        ledger.taken.set(triggerId, 'the id of the trigger');
-    for (const ep of built.entryPoints ?? [])
-        if (!ledger.taken.has(ep.id))
-            ledger.taken.set(ep.id, `the id of entry point "${ep.id}"`);
-    // Entry points: unique roots with valid triggers, colliding with nothing.
-    const epIds = new Set();
+    // Entry points: valid triggers. An id that collides with a step, the trigger
+    // or another entry point is the serializer's ENTRY_POINT_DUP_ID.
     for (const ep of built.entryPoints ?? []) {
-        if (epIds.has(ep.id) || ep.id === triggerId || ep.id === 'start') {
-            diags.push({
-                level: 'error', code: 'ENTRY_POINT_DUP_ID', step: ep.id,
-                message: `.entryPoint("${ep.id}"): the id collides with the default trigger or another entry point.`,
-            });
-        }
-        epIds.add(ep.id);
         const maybeCustomEp = ep.trigger;
         if (!('kind' in maybeCustomEp) && maybeCustomEp instanceof FlowNode) {
-            const own = maybeCustomEp.diagnostics();
-            for (const d of own) {
+            for (const d of maybeCustomEp.diagnostics()) {
                 diags.push({ level: d.severity, code: d.code, message: d.message, step: ep.id });
             }
-            checkContribution(maybeCustomEp, ep.options?.version, ep.id, own.some((d) => d.severity === 'error'), diags);
         }
         else {
             checkTrigger(ep.trigger, diags, opts, ep.id);
@@ -952,15 +829,9 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
         }
         walk(ep.steps);
     }
-    // After the entry-point loop, so prefix steps are in `stepNames`: serialize
-    // claims body and prefix step ids together (#1249).
-    checkStepIds(stepNames, ancestors.length === 0 ? triggerId : undefined, diags);
-    if (built.entryPoints?.length && !built.steps.some((st) => 'name' in st && st.kind !== 'return')) {
-        diags.push({
-            level: 'error', code: 'ENTRY_POINT_NO_SHARED_BODY',
-            message: 'Entry points join the shared body, but this flow has no shared step. Add one, or end each prefix terminally.',
-        });
-    }
+    // Two steps whose names give one node id, or a step named like the trigger,
+    // are the serializer's STEP_ID_COLLISION (#1249); entry points with no shared
+    // step to join are its ENTRY_POINT_NO_SHARED_BODY.
     const conversationRoots = [
         ...(built.trigger?.kind === 'conversation' ? [triggerId] : []),
         ...(built.entryPoints ?? []).filter((ep) => ep.trigger.kind === 'conversation').map((ep) => ep.id),
@@ -972,9 +843,7 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
                 + `${conversationRoots.map((id) => `"${id}"`).join(', ')}. Keep one and give the others another trigger.`,
         });
     }
-    // The root trigger and entry points hold node ids of their own; a subflow's
-    // start is the SDK's to name, so it reserves nothing.
-    checkStepRefs(built, diags, ancestors.length === 0 ? [triggerId, ...(built.entryPoints ?? []).map((ep) => ep.id)] : []);
+    checkStepRefs(built, diags);
     checkArmScopedReads(built, diags);
     // A fire-and-forget dispatch publishes no output: any read of it would wait
     // on a value the run will never produce. Error reads stay legal — dispatch
@@ -1321,29 +1190,25 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
     for (const [stepName, child] of subflowChildren) {
         if (ancestors.includes(child) || child === built)
             continue;
-        for (const d of checkFlow(child, [...ancestors, built], opts, ledger)) {
-            diags.push({
+        for (const d of checkFlow(child, [...ancestors, built], opts)) {
+            const placed = {
                 ...d,
                 code: d.code,
                 message: `In subflow "${stepName}": ${d.message}`,
                 step: d.step ? `${stepName} › ${d.step}` : stepName,
-            });
+            };
+            if (OWN_NODE_ERRORS.has(d))
+                OWN_NODE_ERRORS.add(placed);
+            diags.push(placed);
         }
     }
     return diags;
 }
-/** What `registry prepare` takes for an event subscription: its connector key and curated event name. */
-function eventTarget(sub) {
-    const { connector, event } = (sub ?? {});
-    return typeof connector === 'string' && connector !== ''
-        ? { key: connector, ...(typeof event === 'string' && event !== '' ? { action: event } : {}) }
-        : undefined;
-}
 /**
  * The connector rules live in `core/connector-checks.ts`, shared with BPMN —
  * they were always a function of the connector corpus and the step's own
  * `{ key, action, version, object, inputs, connection, folder }`, never of
- * anything flow-shaped. These three adapters add what IS flow-shaped: the
+ * anything flow-shaped. These adapters add what IS flow-shaped: the
  * `Connector step "…"` vocabulary, the `step` field on the diagnostic, and the
  * `$vars`/`Expr` dialect its inputs are written in.
  */
@@ -1355,22 +1220,13 @@ function connectorSite(step, diags) {
 }
 function checkConnectorLookups(step, spec, opts, diags) {
     const { where, report } = connectorSite(step, diags);
-    coreCheckConnectorLookups(where, spec, opts, FLOW_EXPR_DIALECT, report);
+    // An unresolved lookup is the serializer's LOOKUP_UNRESOLVED.
+    coreCheckConnectorLookups(where, spec, opts, FLOW_EXPR_DIALECT, report, false);
 }
 function checkConnectorSchema(step, spec, opts, diags) {
     const { where, report } = connectorSite(step, diags);
     coreCheckConnectorSchema(where, spec, opts, FLOW_EXPR_DIALECT, report);
 }
-/**
- * The core contract (fields with a library, names with a bindings.json), plus
- * BINDING_MISSING, which needs neither: an absent label is wrong whatever the
- * file says.
- */
-function checkConnectorContract(step, spec, opts, diags) {
-    const { where, report } = connectorSite(step, diags);
-    coreCheckConnectorContract(where, spec, opts, report, step);
-    checkBindingPresence(`connector "${step}"`, spec, (code, message) => report({ level: 'error', code, message }), { key: spec.key, action: spec.action });
-}
 /**
  * Reject a wrapper hop when the runtime shape of a list has been measured: the
  * step the loop reads says what its list output looks like (`listShape`, a
@@ -1607,14 +1463,8 @@ function checkSubflow(step, child, inputs, parent, ancestors, diags) {
             + `trigger of its own — the schedule would be dropped. Remove the .trigger() from "${child.id}" `
             + `(\`.trigger(manual(), { label })\` is allowed, to name the child's start node).`);
     }
-    // `{ shared }` merges one input across a flow's ROOTS (#924). A subflow has
-    // one root, its caller, so there is nothing to merge; serialize refuses it.
-    for (const inp of child.inputs) {
-        if (inp.shared === undefined)
-            continue;
-        at('SHARED_INPUT_IN_SUBFLOW', `Subflow "${step}" runs "${child.id}", whose input "${inp.name}" has { shared: "${inp.shared}" }. A subflow has `
-            + `one root — its caller — so there is nothing to merge. Read the input with input('${inp.name}') inside the child.`);
-    }
+    // `{ shared }` merges one input across a flow's ROOTS (#924); a subflow has
+    // one root, its caller: the serializer's SHARED_INPUT_IN_SUBFLOW.
     const declared = new Map(child.inputs.map((i) => [i.name, String(i.type)]));
     const given = inputs ?? {};
     for (const key of Object.keys(given)) {
@@ -1849,34 +1699,20 @@ const INTERVAL_WORDS = [
  */
 /**
  * Every declared name must become exactly one global, because `flow validate`
- * rejects a repeated id (`[variables.globals] Duplicate variable ID`;
- * VARIABLE_NAME_COLLISION, flow-builder-sdk#890). The planning — including the one collision that is NOT an error, a same-named
- * `.output()` + `.var()`, which merges into one `out` global carrying the var's
- * default — lives in `planFlowGlobals`, shared with the serializer, so `check`
- * and the emitted file cannot disagree about it (flow-builder-sdk#899: `check`
- * said `Errors: 0`, validate refused the file).
+ * rejects a repeated id (`[variables.globals] Duplicate variable ID`,
+ * flow-builder-sdk#890). The plans that decide it (`planFlowGlobals`,
+ * `planSharedInputs`, `planOutputBacking`) are the serializer's, and so are
+ * their refusals (VARIABLE_NAME_COLLISION, OUTPUT_VAR_MISMATCH, SHARED_INPUT_*,
+ * OUTPUT_BACKING_COLLISION). What is left here is the shared-input plan's
+ * warnings, which compile does not raise.
  */
 function checkGlobalNames(built, diags) {
-    // `{ shared }` inputs (#924) may add `.var()`s; the plan is the serializer's
-    // own (`emittableGlobals`), so check and the emitted file agree on them.
     const shared = planSharedInputs({ roots: sharedInputRoots(built), outputs: built.outputs ?? [], vars: built.vars ?? [] });
     for (const p of shared.problems) {
+        if (p.level !== 'warning')
+            continue;
         diags.push({ level: p.level, code: p.code, message: p.message, ...(p.suggestion ? { suggestion: p.suggestion } : {}) });
     }
-    const vars = [...(built.vars ?? []), ...shared.autoVars];
-    const plan = planFlowGlobals({ inputs: built.inputs ?? [], outputs: built.outputs ?? [], vars });
-    for (const p of plan.problems) {
-        diags.push({ level: 'error', code: p.code, message: p.message, ...(p.suggestion ? { suggestion: p.suggestion } : {}) });
-    }
-    if (plan.problems.length)
-        return;
-    // An output the flow sets from inside is emitted with an `inout` Variable
-    // `<output>Value` behind it (#1092); that id must be free. Same plan as
-    // `emittableGlobals`, so a name check passes is one serialize can emit.
-    const sharedOutputs = new Set(shared.targets.filter((t) => t.declaredAs === 'output').map((t) => t.name));
-    for (const p of planOutputBacking(built, plan.outputs, plan.vars, sharedOutputs).problems) {
-        diags.push({ level: 'error', code: p.code, message: p.message, ...(p.suggestion ? { suggestion: p.suggestion } : {}) });
-    }
 }
 /**
  * `{ updates }` writes a declared flow variable when the node completes. The
@@ -1932,8 +1768,6 @@ function checkNodeUpdates(built, diags) {
     visit(built.steps);
 }
 function checkTrigger(spec, diags, opts = {}, entryPointId) {
-    const where = entryPointId === undefined ? undefined : `onEvent() entry point "${entryPointId}"`;
-    const call = entryPointId === undefined ? '.trigger()' : `.entryPoint("${entryPointId}")`;
     const push = (level) => (code, message, suggestion) => {
         diags.push({ level, code, message, step: entryPointId ?? 'trigger', ...(suggestion ? { suggestion } : {}) });
     };
@@ -1942,10 +1776,9 @@ function checkTrigger(spec, diags, opts = {}, entryPointId) {
     // object without its factory) or a typo'd kind reaches here intact.
     if (spec?.kind === 'event') {
         const sub = spec.subscription;
-        checkEventSubscription(sub, 'trigger', at, push('warning'), eventParamsFor(sub, opts));
-        checkEventResolution(sub, 'trigger', 'trigger', opts, at, push('warning'), eventParamsFor(sub, opts));
-        checkBindingLabels('event trigger', sub, opts, at, eventTarget(sub), { id: 'trigger', connector: eventTarget(sub)?.key });
-        checkBindingPresence(where ?? 'event trigger', sub, at, eventTarget(sub));
+        // As for waitForEvent: what compile refuses is the serializer's.
+        checkEventSubscription(sub, 'trigger', at, push('warning'), eventParamsFor(sub, opts), false);
+        checkEventResolution(sub, 'trigger', 'trigger', opts, at, push('warning'), eventParamsFor(sub, opts), false);
         return;
     }
     // manual() is the explicit spelling of the default — nothing to validate.
@@ -1959,14 +1792,9 @@ function checkTrigger(spec, diags, opts = {}, entryPointId) {
     // platform started is the trigger's own output, declared by the definition.
     if (spec?.kind === 'conversation' || spec?.kind === 'voice')
         return;
-    if (spec?.kind !== 'scheduled') {
-        at('TRIGGER_UNKNOWN_KIND', `${call} was given ${JSON.stringify(spec?.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' })`);
+    // Anything but a schedule here is not a trigger: the serializer's TRIGGER_UNKNOWN_KIND.
+    if (spec?.kind !== 'scheduled')
         return;
-    }
     const inputs = spec.inputs;
     const raw = inputs?.every;
     if (raw === undefined || raw === null || (typeof raw === 'string' && raw.trim() === '')) {
@@ -2262,14 +2090,9 @@ function checkParallel(s, diags) {
                 + `terminate its own arm, or move the earlier step(s) before the \`.parallel(…)\` call.`, `.parallel('${s.name}', [(a) => a.terminate('${term.name}'), …])`);
         }
     });
-    arms.forEach((arm, i) => {
-        const steps = Array.isArray(arm) ? arm : [];
-        const fanIn = hitlFanInto(steps);
-        if (fanIn)
-            diags.push(fanInDiag(s.name, i, steps, fanIn));
-        for (const h of hitlEndHazards(steps))
-            diags.push(endDiag(s.name, h));
-    });
+    // A human task whose alternative outcomes would each enter the join, or whose
+    // End outcome would starve it, is the serializer's HITL_FAN_OUT_INTO_JOIN /
+    // HITL_END_OUTCOME_IN_PARALLEL (worded from `flow-parallel-hitl.ts`).
     // An arm that ends the flow reaches an End node instead of the Merge, so it
     // contributes NO incoming edge. Verified on the emitted graph: with two arms
     // and one returning, the Merge has a single incoming edge and is no longer a
@@ -2293,202 +2116,6 @@ function checkParallel(s, diags) {
         });
     }
 }
-/**
- * Whether a `.parallel` arm hands its join an edge, as serialize wires it: it
- * has a step, and `armTails` (serialize's `emit` tail for tail) leaves it at
- * least one tail. So an arm that ends by `.return`, `.terminate`, `.break`,
- * `.continue` or a `.stepToRef` on the default port does not, and neither does
- * one that ends in a `.branch` / `.switch` / `.stepSwitch` every arm of which
- * ends, or in a nested `.parallel` none of whose arms reaches its own join.
- * When no arm hands on a tail, serialize emits no Merge at all (#1267), so the
- * join rules (PARALLEL_ARM_RETURNS, REF_INTO_PARALLEL_ARM,
- * REF_OUT_OF_PARALLEL_ARM) have no join to protect.
- */
-function armReachesJoin(arm) {
-    return arm.length > 0 && armTails(arm, [{ from: '' }]).length > 0;
-}
-/**
- * The edges a step list hands on, mirroring serialize's `emit` tail for tail.
- *
- * `.branch` / `.switch` / `.stepSwitch` hand on every arm's tails (an empty arm
- * hands on the port it started from), a `.parallel` its Merge when an arm
- * reaches it and nothing otherwise, a fan-out human task one per continuing
- * outcome, a routed one its primary outcome; `.return` / `.terminate` / `.break`
- * and a `stepToRef('output', …)` hand on none, `.stepToList` leaves the path as
- * it was, and every other step hands on its own single edge.
- */
-function armTails(steps, incoming) {
-    let tails = incoming;
-    for (const st of steps) {
-        if (st.kind === 'stepToList')
-            continue;
-        if (st.kind === 'stepToRef') {
-            if (st.port === 'output')
-                tails = [];
-            continue;
-        }
-        if (st.kind === 'return' || st.kind === 'terminate' || st.kind === 'break' || st.kind === 'continue')
-            return [];
-        if (st.kind === 'action') {
-            tails = actionTails(st.name, st.spec, st.options?.version);
-        }
-        else if (st.kind === 'stepSwitch') {
-            const spec = st.spec;
-            const outcomes = spec.kind === 'hitl' && hitlDerivesOutcomeHandles(spec.inputs?.variant);
-            tails = st.cases.flatMap((c) => armTails(c.body, [{ from: st.name, ...(outcomes ? { outcome: String(c.value) } : {}) }])
-                .map((t) => (outcomes && !t.humanSwitch ? { ...t, humanSwitch: { step: st.name, outcome: String(c.value) } } : t)));
-        }
-        else if (st.kind === 'branch') {
-            tails = [...armTails(st.then, [{ from: st.name }]), ...armTails(st.otherwise, [{ from: st.name }])];
-        }
-        else if (st.kind === 'switch') {
-            tails = [
-                ...st.cases.flatMap((c) => armTails(c.body, [{ from: st.name }])),
-                ...(st.default !== undefined ? armTails(st.default, [{ from: st.name }]) : []),
-            ];
-        }
-        else if (st.kind === 'parallel') {
-            // serialize joins a nested `.parallel` at its Merge, the one edge it hands
-            // on, and emits no Merge, so no edge, when no arm hands on a tail (#1267).
-            // An empty arm hands on the path it started from, which the Merge joins.
-            const arms = Array.isArray(st.arms) ? st.arms : [];
-            tails = arms.some((arm) => armTails(arm, tails).length > 0) ? [{ from: st.name }] : [];
-        }
-        else {
-            tails = [{ from: st.name ?? st.kind }];
-        }
-    }
-    return tails;
-}
-function actionTails(name, spec, version) {
-    if (spec.kind !== 'hitl' || !hitlDerivesOutcomeHandles(spec.inputs?.variant))
-        return [{ from: name }];
-    const model = hitlExitModel(spec.inputs, version);
-    if (model.shape === 'placeholder')
-        return [{ from: name }];
-    if (model.shape === 'per-outcome')
-        return model.exits.slice(0, 1).map((e) => ({ from: name, outcome: e.value }));
-    return model.exits.filter((e) => !e.endsProcess).map((e) => ({ from: name, outcome: e.value }));
-}
-/**
- * The tails of a `.parallel` arm when they would starve its join: two or more
- * alternative edges — only one fires — at least one of which is a human task's
- * outcome edge, or the end of a human-task `.stepSwitch` arm. The join waits
- * for a token on every incoming flow.
- *
- * However the task got there, it is the same graph: a fan-out task at the arm's
- * end (its outcomes are the alternatives), a `.stepSwitch` with an empty arm
- * beside a body arm, a complete `.stepSwitch` with nothing after it (one edge
- * per arm's last step), a task on one side of a `.branch`. serialize refuses the
- * same condition, edge for edge. Rejoining arms with NO human task in them are
- * the older, general case, and not refused here.
- */
-function hitlFanInto(steps) {
-    const tails = armTails(steps, [{ from: '(fork)' }]);
-    return tails.length >= 2 && tails.some((t) => t.outcome !== undefined || t.humanSwitch !== undefined) ? tails : undefined;
-}
-function fanInDiag(join, arm, steps, tails) {
-    const tagged = tails.find((t) => t.outcome !== undefined || t.humanSwitch !== undefined);
-    const task = tagged.outcome !== undefined ? tagged.from : tagged.humanSwitch.step;
-    if (tails.every((t) => t.from === task && t.outcome !== undefined)) {
-        return {
-            level: 'error', code: 'HITL_FAN_OUT_INTO_JOIN', step: task,
-            message: `Human task "${task}" ends its path inside parallel "${join}", so its outcomes `
-                + `${tails.map((t) => t.outcome).join(', ')} each get their own edge into the join. Only one outcome ever `
-                + `fires, and the join waits for a token on every incoming edge, so the run never gets past "${join}" — with `
-                + `no incident, and \`flow validate\` answers Valid. Add a step after "${task}" inside the arm, so every `
-                + `outcome continues to that step and only its one edge reaches the join (the decision is `
-                + `out('${task}', 'Action')), or move the task out of the \`.parallel(…)\`.`,
-            suggestion: `a.step('${task}', hitl(…)).step('record', …)`,
-        };
-    }
-    const edges = tails.map((t) => (t.outcome !== undefined ? `outcome ${t.outcome} of "${t.from}"`
-        : t.humanSwitch ? `"${t.from}" (on outcome ${t.humanSwitch.outcome} of "${t.humanSwitch.step}")` : `"${t.from}"`));
-    const last = [...steps].reverse().find((x) => x.kind !== 'stepToList' && x.kind !== 'stepToRef');
-    return {
-        level: 'error', code: 'HITL_FAN_OUT_INTO_JOIN', step: task,
-        message: `Parallel "${join}" arm ${arm + 1} ends on ${tails.length} alternative paths, and each gets its own edge `
-            + `into the join: ${edges.join(', ')}. Only one of them runs, and the join waits for a token on every incoming `
-            + `edge, so the run never gets past "${join}" — with no incident, and \`flow validate\` answers Valid. Add a `
-            + `step at the end of the arm${last?.name ? `, after "${last.name}"` : ''}, so the paths meet on that step and `
-            + `only its one edge reaches the join, or move human task "${task}" out of the \`.parallel(…)\`.`,
-        suggestion: `….step('record', …)  // last step of arm ${commentText(arm + 1)}`,
-    };
-}
-/**
- * Human tasks in one `.parallel` arm that continue every outcome while some of
- * them are `action: 'End'`. The End outcome's path stops at its End node, so the
- * join waits for the continuing path that did not run.
- *
- * Recurses into `.branch` / `.switch` / `.stepSwitch` bodies, which reach the
- * join too. Not into a loop body (the loop node is what reaches the join) or a
- * nested `.parallel` (its own join is checked on its own).
- */
-function hitlEndHazards(steps) {
-    const found = [];
-    for (const st of steps) {
-        if (st.kind === 'action' && st.spec.kind === 'hitl') {
-            const model = hitlExitModel(st.spec.inputs, st.options?.version);
-            if (model.shape !== 'every-outcome')
-                continue;
-            const ending = model.exits.filter((e) => e.endsProcess).map((e) => e.value);
-            if (ending.length > 0 && ending.length < model.exits.length)
-                found.push({ step: st.name, outcomes: ending, via: 'action-end' });
-        }
-        else if (st.kind === 'branch') {
-            found.push(...hitlEndHazards(st.then), ...hitlEndHazards(st.otherwise));
-        }
-        else if (st.kind === 'switch') {
-            for (const c of st.cases)
-                found.push(...hitlEndHazards(c.body));
-            if (st.default)
-                found.push(...hitlEndHazards(st.default));
-        }
-        else if (st.kind === 'stepSwitch') {
-            // An outcome with no arm gets an End (serialize's `endExit`), and so does
-            // an arm that ends in `.return()`. Beside an arm that continues, that End
-            // is where this arm's token stops on that outcome.
-            const spec = st.spec;
-            const exits = spec.kind === 'hitl' && hitlDerivesOutcomeHandles(spec.inputs?.variant)
-                ? stepExits(st.spec, st.options?.version) : undefined;
-            if (exits && hasExits(exits)) {
-                const stopped = exits.filter((e) => {
-                    const c = st.cases.find((x) => x.value === e.value);
-                    return !c || (armTails(c.body, [{ from: st.name }]).length === 0 && stopsAtEnd(c.body));
-                }).map((e) => e.value);
-                if (stopped.length > 0 && armTails([st], [{ from: '(fork)' }]).length > 0) {
-                    found.push({ step: st.name, outcomes: stopped, via: 'step-switch' });
-                }
-            }
-            for (const c of st.cases)
-                found.push(...hitlEndHazards(c.body));
-        }
-    }
-    return found;
-}
-function endDiag(join, h) {
-    const list = h.outcomes.join(', ');
-    if (h.via === 'step-switch') {
-        return {
-            level: 'error', code: 'HITL_END_OUTCOME_IN_PARALLEL', step: h.step,
-            message: `Human task "${h.step}" is a .stepSwitch inside parallel "${join}", and ${h.outcomes.length === 1
-                ? `outcome ${list} has` : `outcomes ${list} have`} no arm, or an arm that ends in .return(). That path `
-                + `stops at an End node, while the join waits for a token from this arm on the path that continues, so the `
-                + `run never gets past "${join}" — with no incident, and \`flow validate\` answers Valid. Give every outcome `
-                + `an arm that continues (and move a .return() after the \`.parallel(…)\`), or move the task out of the `
-                + `\`.parallel(…)\`.`,
-            suggestion: `{ value: '${h.outcomes[0]}', body: (b) => b.step(…) }`,
-        };
-    }
-    return {
-        level: 'error', code: 'HITL_END_OUTCOME_IN_PARALLEL', step: h.step,
-        message: `Human task "${h.step}" is inside parallel "${join}", and ${h.outcomes.length === 1
-            ? `outcome ${list} is` : `outcomes ${list} are`} action: 'End'. `
-            + `That path stops at its own End node, while the join waits for a token from this arm on its `
-            + `continuing path, so the run never gets past "${join}". Drop action: 'End' there and act on `
-            + `out('${h.step}', 'Action') after the join, or move the task out of the \`.parallel(…)\`.`,
-    };
-}
 /**
  * Diagnose a `transform` step.
  *
@@ -2504,19 +2131,6 @@ function endDiag(join, h) {
  * reference to hide — which is what the checks below enforce for the cases
  * where types have been stripped at run time.
  */
-/**
- * Why a base or quick-form task continues every outcome to the next step, as a
- * clause for a diagnostic. `pinned` is the step's `{ version }`.
- */
-function fanOutWhy(why, pinned) {
-    switch (why) {
-        case 'outcomePorts: false': return 'outcomePorts: false says so';
-        case 'quick-form': return 'a quick-form task does not unless it sets outcomePorts: true';
-        case 'pinned': return `{ version: '${pinned}' } pins it without outcomePorts: true`;
-        case 'one outcome': return 'it has a single outcome';
-        case 'every outcome ends': return "every outcome is action: 'End'";
-    }
-}
 /**
  * HITL_OUTCOMES_UNREACHABLE — a human task offers the reviewer a CHOICE that
  * nothing downstream can act on.
@@ -2703,7 +2317,7 @@ function registeredKind(spec) {
  * which serialize enforces (#942) and the type's tests pin; an author cannot
  * cause the gap, so there is no author diagnostic to report.
  */
-function checkRegisteredStep(entry, s, exprs, errorSource, opts, diags, typeOf, triggerId, ledger, carried) {
+function checkRegisteredStep(entry, s, exprs, errorSource, opts, diags, typeOf, triggerId, carried) {
     const spec = s.spec;
     /** The step's node-local rules and expressions, as `impl` defines them. */
     const runRules = (impl, version = impl.version, carriedDef) => {
@@ -2718,30 +2332,14 @@ function checkRegisteredStep(entry, s, exprs, errorSource, opts, diags, typeOf,
                 return name ? { name, type: typeOf.get(name) } : undefined;
             },
             options: opts,
-            bindingLabels: (where, labels, use, target) => checkBindingLabels(where, labels, opts, (code, message) => diags.push({ level: 'error', code, step: s.name, message }), target, use),
+            bindingLabels: (where, labels, _use, target) => checkBindingLabels(where, labels, opts, (code, message) => diags.push({ level: 'error', code, step: s.name, message }), target),
+            resources: { derivedNodeId: () => { }, claimNodeId: () => undefined, claimFolder: () => undefined },
+            // The operation, its field contract and its binding labels are the
+            // serializer's (CONNECTOR_*, BINDING_*), reported from its run.
             connector: (c) => {
                 const spec = c;
                 checkConnectorLookups(s.name, spec, opts, diags);
                 checkConnectorSchema(s.name, spec, opts, diags);
-                checkConnectorContract(s.name, spec, opts, diags);
-            },
-            resources: {
-                derivedNodeId: (id, what) => { if (!ledger.taken.has(id))
-                    ledger.taken.set(id, what); },
-                claimNodeId: (id, what) => {
-                    const other = ledger.explicit.get(id);
-                    if (other === undefined)
-                        ledger.explicit.set(id, { step: s.name, what });
-                    return other;
-                },
-                claimFolder: (source) => {
-                    const key = source.toLowerCase();
-                    const other = ledger.agentSources.get(key);
-                    if (other !== undefined && other !== s.name)
-                        return other;
-                    ledger.agentSources.set(key, s.name);
-                    return undefined;
-                },
             },
         };
         impl.check?.(spec, ctx);
@@ -2771,7 +2369,7 @@ function checkRegisteredStep(entry, s, exprs, errorSource, opts, diags, typeOf,
         // A select() that picks an unregistered version is the node type's bug, not the author's pin.
         if (isInternalSdkError(e))
             throw e;
-        diags.push({ level: 'error', code: 'NODE_VERSION_UNREGISTERED', step: s.name, message: e.message });
+        // The pin itself is the serializer's NODE_VERSION_UNREGISTERED (`serializerRefusals`).
         // Still report the step's other mistakes in this same pass, with the version it
         // would get unpinned (select(), else the default) — as decompile lifts an
         // unregistered version — so fixing the pin is not followed by a second round.
@@ -2899,12 +2497,6 @@ function collectActionExprs(s, out, errorSource) {
  * registered node type — whose node type has no error port. One spelling for
  * both, so porting a family onto the registry changes no message.
  */
-function typedNoErrorPortMessage(stepName, kind, def) {
-    const nodeType = def ? ` (${def.nodeType}@${def.version})` : '';
-    return `Step "${stepName}" is a ${kind} step${nodeType}, and that node type has no error port — its definition does not `
-        + `set supportsErrorHandling, so the edge would leave a handle the node does not have. Handle the failure `
-        + `downstream instead (a delay cannot fail; a wait resumes or does not).`;
-}
 /** The five fields the platform's error envelope declares — no more, no less. */
 // The five the definitions declare, plus the two every probed runtime envelope
 // carried anyway (`response`, `element`) — see ErrorEnvelopeField in core/expr.ts.
@@ -2914,56 +2506,27 @@ const ERROR_ENVELOPE_FIELDS = ['code', 'message', 'detail', 'category', 'status'
  * mistakes at build time (no previous step, two handlers on one node, an empty
  * handler); these are the ones only a checker can see.
  *
- * Whether the step has an error port at all: every family is decided by a
- * definition, never by a list:
- *
- *  - a bundled family by its bundled definition (`bundledActionNodeType` +
- *    `bundledDefinition`, #1011: `documentClassify` was missing from the old
- *    list although `uipath.document.classify@1.0` sets the flag);
- *  - a per-tenant family — every one is registered — through its node type's
- *    `errorPort`, which asks the definition serialize synthesizes (#1040:
- *    `publishedFunction` was refused here although `publishedFunctionDef` sets
- *    the flag), or for a connector the library's definition, which check reads
- *    through `connectorDefinition` and, without a library, assumes grants the
- *    port, as every operation the library serves does.
- *
- * `publishedFunction`'s flag is measured, not assumed: on 2026-10-08 four
- * `flow debug` jobs on alpha/codereval called `acme-echo` with a non-string
- * `message` (null, object, number, array). In each, the function job failed
- * (`Python.FUNCTION_EXECUTION_ERROR`, category User, status 502), the node's
- * error boundary fired, and the handler's `err('message')` read
- * "Failure in the Orchestrator Job".
- *
- * A kind in none of these (`waitEvent`) has no error port: an event wait
- * resumes or does not.
+ * Whether the step has an error port at all is the serializer's
+ * ONERROR_NO_ERROR_PORT: it asks the definition it emits, never a list (a
+ * bundled family's bundled definition, #1011; a per-tenant one's `errorPort`,
+ * #1040; a custom node's own definition, #943). `publishedFunction`'s port is
+ * measured, not assumed: on 2026-10-08 four `flow debug` jobs on
+ * alpha/codereval called `acme-echo` with a non-string `message`, and in each
+ * the node's error boundary fired and the handler read "Failure in the
+ * Orchestrator Job".
  */
 function checkOnError(_handler, step, diags, 
 /** The step's registry record, when its kind is registered and its version resolved. */
-placed, opts, carried) {
+placed, opts) {
     // The builder refuses a handler with no eligible step before it, so a missing
     // source here means a hand-built `BuiltFlow`; there is nothing to say about it.
-    if (!step)
+    // A step whose definition has no error port is the serializer's
+    // ONERROR_NO_ERROR_PORT, asked of the definition it emits (#943, #1011). What
+    // is left here is a node type's own refusal of a handler on a port it has.
+    if (!step || step.kind === 'loop' || step.kind === 'doWhile')
         return;
-    // A container (`.loop()` / `.doWhile()`) is decided by its bundled definition
-    // too. Both set `supportsErrorHandling: true`, and both route a body failure
-    // to the container's port, measured: the container's envelope carries the
-    // body's message in `detail` and the failing body step's canvas label (its id when it has no `label`) in `element`, and
-    // the instance completes. `core.logic.dowhile@1.0` declares no `error` handle,
-    // but the flag alone grants it: flow validate adds the handle from the flag.
-    if (step.kind === 'loop' || step.kind === 'doWhile') {
-        const def = bundledContainerDefinition(step.kind, step.options?.version);
-        if (def === undefined || definitionHasErrorPort(def))
-            return;
-        diags.push({
-            level: 'error',
-            code: 'ONERROR_NO_ERROR_PORT',
-            message: errorPortRefusal(step.name, def),
-            step: step.name,
-        });
-        return;
-    }
-    // A custom FlowAction or rawNode has no `kind`: ask its DEFINITION, with the
-    // product's own rule (definitionHasErrorPort), not the kind list (#943).
+    // A custom node backed by a typed family's bundled definition gets that
+    // family's refusals: the rules are about the node type, not the SDK kind.
     const maybeCustom = step.spec;
     if (!('kind' in maybeCustom) && maybeCustom instanceof FlowNode) {
         let def;
@@ -2972,98 +2535,31 @@ placed, opts, carried) {
             def = resolveContributionDefinition(maybeCustom.contribute(requestedVersion !== undefined ? { requestedVersion } : {}).definition, requestedVersion, `step "${step.name}"`);
         }
         catch {
-            // checkContribution already reports a contribution compile cannot lower.
+            // A contribution compile cannot lower is the serializer's CONTRIBUTION_INVALID.
             return;
         }
-        // A custom node backed by a typed family's bundled definition gets that
-        // family's refusals: the rules are about the node type, not the SDK kind.
-        if (def?.nodeType === 'core.action.http') {
+        if (def?.nodeType === 'core.action.http')
             diags.push(plainHttpOnErrorRefusal(step.name));
-            return;
-        }
-        if (definitionHasErrorPort(def))
-            return;
-        diags.push({
-            level: 'error',
-            code: 'ONERROR_NO_ERROR_PORT',
-            message: errorPortRefusal(step.name, def),
-            step: step.name,
-        });
-        return;
-    }
-    const spec = step.spec;
-    // A registered node type: a bundled one asks its definition at the version it
-    // will be emitted at; a per-tenant one answers for itself (its errorPort).
-    if (registeredKind(spec)) {
-        // An unregistered pin still has a record, with the version it would get
-        // unpinned; NODE_VERSION_UNREGISTERED reports the pin itself.
-        if (!placed)
-            return;
-        const { impl } = placed;
-        if (impl.definition !== 'bundled' && placed.carried !== undefined) {
-            // At a carried version the carried definition answers, as serialize asks
-            // it: the type's declaration covers only the versions it registers.
-            if (!definitionHasErrorPort(placed.carried)) {
-                diags.push({ level: 'error', code: 'ONERROR_NO_ERROR_PORT', message: typedNoErrorPortMessage(step.name, impl.kind, placed.carried), step: step.name });
-                return;
-            }
-        }
-        else if (impl.definition !== 'bundled') {
-            // The definition serialize will be supplied, when check's options can name
-            // it (a connector's, from the library); the type answers without it otherwise.
-            const def = impl.checkDefinition?.(placed.spec, opts);
-            const port = typeof impl.errorPort === 'function' ? impl.errorPort(spec, def) : impl.errorPort === true;
-            if (!port) {
-                const named = def !== undefined && typeof def.nodeType === 'string' && typeof def.version === 'string';
-                diags.push({
-                    level: 'error', code: 'ONERROR_NO_ERROR_PORT', step: step.name,
-                    message: named
-                        ? declaredErrorPortRefusal(step.name, def.nodeType, def.version)
-                        : declaredErrorPortRefusal(step.name, impl.typeName, impl.version),
-                });
-                return;
-            }
-        }
-        else {
-            const def = placed.carried ?? bundledDefinition(impl.typeName, impl.version);
-            if (def !== undefined && !definitionHasErrorPort(def)) {
-                diags.push({ level: 'error', code: 'ONERROR_NO_ERROR_PORT', message: typedNoErrorPortMessage(step.name, impl.kind, def), step: step.name });
-                return;
-            }
-        }
-        // The port exists; the node type may still refuse the handler (plain HTTP's rule, once ported).
-        impl.checkErrorHandler?.(placed.spec, placed.ctx);
         return;
     }
-    // A typed family with a bundled definition: ask the definition serialize will
-    // emit, at the version it will emit (#1011), chosen by the same selector
-    // serialize uses (#1041). For instance `voiceAgent()` defaults to
-    // uipath.agent.voice@1.0 (no error port) and `{ version: '1.1' }` selects @1.1
-    // (which has one); `hitl({ exposeError: true })` selects uipath.human-in-the-loop@1.2
-    // with no `{ version }` at all.
-    // A version the SDK does not bundle (an inline agent's registry version) has
-    // no definition here to ask; version resolution reports that, not this check.
-    const bundledType = bundledActionNodeType(spec);
-    // A version the flow CARRIES (`.definitions()`, #1128) answers the same way
-    // a bundled one does: it is the definition serialize will emit.
-    const pinned = step.options?.version;
-    const bundledDef = bundledType
-        ? bundledDefinition(bundledType, pinned) ?? (pinned !== undefined ? carried?.(bundledType, pinned) : undefined)
-        : undefined;
-    // Every per-tenant family is registered and answers above (its errorPort, or
-    // a carried definition); what is left is bundled, or has no definition here.
-    const noPort = bundledDef !== undefined
-        ? !definitionHasErrorPort(bundledDef)
-        : !bundledType;
-    if (noPort) {
-        diags.push({
-            level: 'error',
-            code: 'ONERROR_NO_ERROR_PORT',
-            message: typedNoErrorPortMessage(step.name, spec.kind, bundledDef),
-            step: step.name,
-        });
+    // A registered node type (an unregistered pin still has a record, with the
+    // version it would get unpinned) may refuse the handler on a port it has
+    // (plain HTTP's rule, once ported).
+    if (!registeredKind(step.spec) || !placed)
         return;
-    }
+    const { impl } = placed;
+    const hasPort = impl.definition !== 'bundled' && placed.carried !== undefined
+        ? definitionHasErrorPort(placed.carried)
+        : impl.definition !== 'bundled'
+            ? (typeof impl.errorPort === 'function'
+                ? impl.errorPort(step.spec, impl.checkDefinition?.(placed.spec, opts))
+                : impl.errorPort === true)
+            : (() => {
+                const def = placed.carried ?? bundledDefinition(impl.typeName, impl.version);
+                return def === undefined || definitionHasErrorPort(def);
+            })();
+    if (hasPort)
+        impl.checkErrorHandler?.(placed.spec, placed.ctx);
 }
 /** `.onError` after a custom node built on the plain `core.action.http` definition (the http family's refusal). */
 function plainHttpOnErrorRefusal(stepName) {
@@ -3225,7 +2721,7 @@ function checkArmScopedReads(built, diags) {
  * Backward targets are ALLOWED. Flow JSON can express a backward edge, so the SDK
  * can author one; refusing it would fence off something the wire format permits.
  */
-function checkStepRefs(built, diags, reservedIds = []) {
+function checkStepRefs(built, diags) {
     const order = new Map();
     /** Step name → the `.stepToList` whose port path it lives in — a path only that port reaches. */
     const portListOf = new Map();
@@ -3337,56 +2833,10 @@ function checkStepRefs(built, diags, reservedIds = []) {
     // End, so its Ends count toward the duplicate-name rule below (#1231).
     for (const ep of built.entryPoints ?? [])
         index(ep.steps, undefined, '', undefined);
-    // Two `.return`s asking for the same End name with different content are two
-    // End nodes, which compile refuses rather than renaming the second `<name>2`
-    // (#1231). One End shared by several paths is spelled once, with every other
-    // path ending at it by `.stepToRef('<name>')`, or repeated identically.
-    for (const [name, count] of endNames) {
-        if (count < 2)
-            continue;
-        diags.push({
-            level: 'error', code: 'DUP_END_NAME', step: name,
-            message: `${count} different \`.return({}, { name: '${name}' })\` calls ask for the same End (their values, label, `
-                + `version or updates differ, or they sit in different scopes), so they would be ${count} End nodes with one id. `
-                + `To end several paths at one End, keep one \`.return({}, { name: '${name}' })\` and end the other paths with `
-                + `\`.stepToRef('${name}')\`; to have separate Ends, give each its own name.`,
-        });
-    }
-    // A named End's node id is its name with every character outside
-    // `[A-Za-z0-9_]` made `_`, as a step's is, and compile never renames it
-    // (#1253): it is an id the author chose, or a decompiled file's own. So an End
-    // whose name gives the id of another End, a step, the trigger or an entry
-    // point is refused here, and `serialize` throws for it under `--no-check`.
-    // Before, it was the End that moved (`.step('x').return({}, { name: 'x' })`
-    // compiled to End `x2`), or, emitted first, the step.
-    const safeId = (n) => n.replace(/[^A-Za-z0-9_]/g, '_') || 'node';
-    const stepById = new Map();
-    for (const n of stepNamesSeen)
-        if (!stepById.has(safeId(n)))
-            stepById.set(safeId(n), n);
-    const endById = new Map();
-    for (const name of endNames.keys()) {
-        const id = safeId(name);
-        const other = endById.get(id);
-        if (other !== undefined) {
-            diags.push({
-                level: 'error', code: 'DUP_END_NAME', step: name,
-                message: `Ends "${other}" and "${name}" would both get node id "${id}". Give them names that differ in `
-                    + 'letters, digits or "_".',
-            });
-            continue;
-        }
-        endById.set(id, name);
-        const step = stepById.get(id);
-        if (step !== undefined || reservedIds.includes(id)) {
-            diags.push({
-                level: 'error', code: 'STEP_ID_COLLISION', step: name,
-                message: `End "${name}" (\`.return({}, { name: '${name}' })\`) would get node id "${id}", which `
-                    + `${step !== undefined ? `step "${step}"` : 'the trigger or an entry point'} has. Compile will not rename `
-                    + 'either one, so give the End a name no step or trigger uses.',
-            });
-        }
-    }
+    // Two `.return`s asking for one End name with different content, and an End
+    // whose name gives the node id of another End, a step, the trigger or an
+    // entry point, are the serializer's DUP_END_NAME / STEP_ID_COLLISION: compile
+    // never renames an End's id (#1231, #1253).
     /** Every ref, with where it sits. */
     const found = [];
     const collect = (steps, from, scope, arm, enclosing = [], paths = []) => {
@@ -3444,13 +2894,9 @@ function checkStepRefs(built, diags, reservedIds = []) {
         const say = (level, code, message, suggestion) => {
             diags.push({ level, code, message, step: from ?? 'stepToRef', ...(suggestion ? { suggestion } : {}) });
         };
-        if (!order.has(target)) {
-            const near = [...order.keys()].find((n) => n.toLowerCase() === target.toLowerCase());
-            say('error', 'REF_UNKNOWN_TARGET', `.stepToRef('${target}') ${where} 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.`, near ? `.stepToRef('${near}')` : undefined);
+        // A name the flow does not have is the serializer's REF_UNKNOWN_TARGET.
+        if (!order.has(target))
             continue;
-        }
         const ends = endNames.get(target) ?? 0;
         // Two Ends sharing the name are DUP_END_NAME above, reported once whether or
         // not a ref names them; this is the step-and-End clash.
@@ -3620,11 +3066,8 @@ function checkSchemaVersion(built, ancestors, diags) {
     const declared = built.schemaVersion;
     if (declared === undefined)
         return;
-    const refusal = schemaVersionRefusal(FLOW_SCHEMA_VERSIONS, declared);
-    if (refusal) {
-        diags.push({ level: 'error', code: 'SCHEMA_VERSION_UNSUPPORTED', message: refusal });
-        return;
-    }
+    // A version this build cannot write is the serializer's SCHEMA_VERSION_UNSUPPORTED
+    // on the root flow. On a subflow it has no effect, whatever it is.
     if (ancestors.length > 0) {
         diags.push({
             level: 'warning',
@@ -3635,6 +3078,8 @@ function checkSchemaVersion(built, ancestors, diags) {
         });
         return;
     }
+    if (schemaVersionRefusal(FLOW_SCHEMA_VERSIONS, declared))
+        return;
     const floor = FLOW_SCHEMA_VERSIONS.default;
     const side = compareSchemaVersions(declared, floor);
     if (side > 0) {
@@ -3658,42 +3103,6 @@ function checkSchemaVersion(built, ancestors, diags) {
         });
     }
 }
-/**
- * Run a custom node's contribution lowering DRY, so `check` reports what
- * `compile` would throw. For instance, a `rawNode` carrying an in-solution
- * sibling's manifest with no `values` row for `<bindings.folderPath>` fails here
- * with the same code compile throws.
- *
- * It calls `contribute()`, resolves the definition the way serialize does, and
- * plans the `bindings[]` entries serialize would build
- * ({@link planContributionBindings}). A name the plan cannot close is
- * `CONTRIBUTION_BINDING_UNRESOLVED` — the same code and sentence serialize
- * throws. A contribution that throws is `CONTRIBUTION_INVALID`, unless
- * `ownError` says the node's own `diagnostics()` already reported an error (a
- * raw connector node throws for the reason `RAW_NODE_CONNECTOR` already gives).
- */
-function checkContribution(node, requestedVersion, step, ownError, diags) {
-    let def;
-    let supplied;
-    try {
-        const contribution = node.contribute(requestedVersion !== undefined ? { requestedVersion } : {});
-        def = resolveContributionDefinition(contribution.definition, requestedVersion, `step "${step}"`);
-        supplied = contribution.bindings;
-    }
-    catch (e) {
-        if (ownError)
-            return;
-        diags.push({
-            level: 'error', code: 'CONTRIBUTION_INVALID', step,
-            message: `compile cannot lower step "${step}": ${e instanceof Error ? e.message : String(e)}`,
-        });
-        return;
-    }
-    const plan = planContributionBindings(def, supplied);
-    if (plan.problems.length === 0)
-        return;
-    diags.push({ level: 'error', code: 'CONTRIBUTION_BINDING_UNRESOLVED', step, message: plan.problems.join(' ') });
-}
 /**
  * The one step every arm of a `.parallel` ends by referring to, when the arms
  * join there instead of on a Merge: each arm ends in `.stepToRef(<that step>)`