@uipath/maestro-builder-sdk 6.21.2 → 6.22.0

package/dist/check.js

@@ -20,7 +20,7 @@ import { commentText } from './core/comment-text.js';
 import { nearestName } from './core/edit-distance.js';
 import { isAnswerField } from './core/hitl-answers.js';
 import { hitlDerivesOutcomeHandles, hitlExitModel, hitlRoutesPerOutcome, outcomeIdOf } from './core/hitl-routing.js';
-import { declaredExits, hasExits } from './core/step-ports.js';
+import { hasExits } from './core/step-ports.js';
 import { stopsAtEnd } from './flow-step-tree.js';
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { compareSchemaVersions, schemaVersionRefusal } from './schema-version.js';
@@ -28,6 +28,8 @@ import { planFlowGlobals, planSharedInputs, sharedInputRoots } from './flow-vari
 import { planOutputBacking } from './flow-output-backing.js';
 import { ownEntry } from './core/own-entry.js';
 import { FLOW_NODE_TYPES } from './flow-node-registry.js';
+import { stepExits } from './flow-step-exits.js';
+import { plainHttpOnErrorMessage } from './nodes/http/flow/family.js';
 import { resolveVersion } from './core/nodes/versioned.js';
 import { declaredErrorPortRefusal } from './core/error-port.js';
 export function check(built, opts = {}) {
@@ -125,6 +127,14 @@ function checkFlow(built, ancestors, opts = {}) {
     const registeredSteps = new Map();
     /** Steps of a registered kind whose version did not resolve (NODE_VERSION_UNREGISTERED), so a family rule can stay silent about them. */
     const unresolvedSteps = new Set();
+    /**
+     * Every step of a registered kind, placed or not, with the implementation its
+     * node-local rules ran with: an unregistered pin falls back to the version it
+     * would get unpinned. The step-level rules that follow a step (its output
+     * reads, its `.onError`) ask this one, so a wrong pin is not followed by a
+     * second round of mistakes. Family rules use `registeredSteps` only.
+     */
+    const checkedSteps = new Map();
     /**
      * Every expression the flow carries, with the step that failed when the
      * expression sits inside that step's error handler. The failed step's own
@@ -270,13 +280,14 @@ function checkFlow(built, ancestors, opts = {}) {
                 declared.add(s.name); // a step's output is referenceable by name
             }
             if ((s.kind === 'stepToList' || s.kind === 'stepToRef') && s.port === 'error')
-                checkOnError(s, prevPortSource, diags, prevPortSource && registeredSteps.get(prevPortSource.name));
+                checkOnError(s, prevPortSource, diags, prevPortSource && checkedSteps.get(prevPortSource.name));
             if ((s.kind === 'stepToList' || s.kind === 'stepToRef') && s.port.startsWith('branch-')) {
                 const want = s.port.slice('branch-'.length);
                 const prevSpec = prevAction?.spec;
-                const declared = prevSpec && 'kind' in prevSpec && prevSpec.kind === 'http'
-                    ? (prevSpec.inputs.branches ?? []).some((b) => b.name === want)
-                    : false;
+                // Whichever type the preceding step is, its declared exits say whether it
+                // has this port: only an HTTP step names `branch-<name>` exits.
+                const exits = prevSpec && 'kind' in prevSpec ? stepExits(prevSpec, prevAction?.options?.version) : undefined;
+                const declared = exits !== undefined && hasExits(exits) && exits.some((e) => e.port === s.port);
                 if (!declared) {
                     diags.push({
                         level: 'error', code: 'HTTP_BRANCH_UNKNOWN', step: prevAction?.name,
@@ -375,9 +386,10 @@ function checkFlow(built, ancestors, opts = {}) {
                 prevPortSource = s;
                 const registered = registeredKind(s.spec);
                 if (registered) {
-                    const placed = checkRegisteredStep(registered, s, exprs, errorSource, opts, diags, typeOf, triggerId);
+                    const { placed, checked } = checkRegisteredStep(registered, s, exprs, errorSource, opts, diags, typeOf, triggerId);
+                    checkedSteps.set(s.name, checked);
                     if (placed)
-                        registeredSteps.set(s.name, placed);
+                        registeredSteps.set(s.name, checked);
                     else
                         unresolvedSteps.add(s.name);
                 }
@@ -400,43 +412,6 @@ function checkFlow(built, ancestors, opts = {}) {
                     }
                     checkContribution(maybeCustom, s.options?.version, s.name, own.some((d) => d.severity === 'error'), diags);
                 }
-                if (s.spec.kind === 'http') {
-                    checkHttp(s.name, s.spec.inputs, diags);
-                    // Only a complete pair: an empty half is HTTP_MANAGED_BINDING_INCOMPLETE, which
-                    // serialize refuses before it resolves either name.
-                    const pair = s.spec.inputs;
-                    const filled = (v) => typeof v === 'string' && v.trim() !== '';
-                    if (pair?.managed && filled(pair.connection) && filled(pair.folder)) {
-                        const httpStep = s.name;
-                        const target = pair.targetConnector;
-                        checkBindingLabels(`managed http "${httpStep}"`, pair, opts, (code, message) => diags.push({ level: 'error', code, step: httpStep, message }), undefined, 
-                        // The connector its CONNECTION belongs to: the target, not the wrapper.
-                        { id: httpStep, connector: typeof target === 'string' && target !== '' ? target : 'uipath-uipath-http' });
-                    }
-                    const seen = new Set();
-                    for (const b of s.spec.inputs.branches ?? []) {
-                        addExpr(b.condition.js, s.name);
-                        if (!/^[A-Za-z0-9_-]+$/.test(b.name)) {
-                            diags.push({
-                                level: 'error', code: 'HTTP_BRANCH_NAME', step: s.name,
-                                message: `HTTP branch ${JSON.stringify(b.name)} on "${s.name}" is not port-safe — use letters, digits, _ or - (it becomes the branch-<name> port).`,
-                            });
-                        }
-                        if (seen.has(b.name)) {
-                            diags.push({
-                                level: 'error', code: 'HTTP_BRANCH_DUP', step: s.name,
-                                message: `HTTP branch ${JSON.stringify(b.name)} on "${s.name}" is declared twice.`,
-                            });
-                        }
-                        seen.add(b.name);
-                        if (b.condition.literal) {
-                            diags.push({
-                                level: 'error', code: 'HTTP_BRANCH_CONST', step: s.name,
-                                message: `HTTP branch ${JSON.stringify(b.name)} on "${s.name}" tests a constant — it would fire always or never. Reference the response, e.g. $vars.${s.name}.output.statusCode.`,
-                            });
-                        }
-                    }
-                }
                 // `.stepSwitch` routes its exits as ARMS, so the `.stepToList` bookkeeping
                 // would report every one of them unrouted. STEP_SWITCH_EXIT_UNROUTED is
                 // that step's version of the same question.
@@ -706,7 +681,7 @@ function checkFlow(built, ancestors, opts = {}) {
             // 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.
             if (s0.kind === 'stepSwitch') {
-                const exits = declaredExits(s0.spec, s0.options?.version);
+                const exits = stepExits(s0.spec, s0.options?.version);
                 if (!hasExits(exits)) {
                     diags.push({
                         level: 'error', code: 'STEP_SWITCH_NO_EXITS', step: s0.name,
@@ -1044,7 +1019,7 @@ function checkFlow(built, ancestors, opts = {}) {
             // per-family rules below, because the envelope carries the same fields
             // whatever the node publishes on its success path; which VARIABLE holds it
             // is a per-family runtime boundary `serialize` rewrites, not something the
-            // author writes (`ERROR_ENVELOPE_VAR`).
+            // author writes (a node type's `errorEnvelope`).
             if (field === 'error') {
                 const tail = rest ? rest.slice(1).split('.')[0] : undefined;
                 if (tail !== undefined)
@@ -1095,13 +1070,17 @@ function checkFlow(built, ancestors, opts = {}) {
             }
             // A registered node type declares what its output is; `none` reports here,
             // at the same point as the per-family no-output rules below.
-            const placed = registeredSteps.get(name);
+            const placed = checkedSteps.get(name);
             if (placed) {
                 const contract = placed.impl.output(placed.spec);
                 if (contract.kind === 'none') {
                     diags.push(catalogued(placed.entry, step, contract.code, contract.message({ node: name, ref: `$vars.${name}${field ? '.' + field : ''}`, reader: step })));
                     continue;
                 }
+                if (contract.kind === 'reader') {
+                    contract.read({ node: name, ref: `$vars.${name}${field ? '.' + field : ''}${rest}`, reader: step, field, rest }, (code, message, suggestion) => diags.push(catalogued(placed.entry, step, code, message, suggestion)));
+                    continue;
+                }
             }
             // A switch only routes; it has no output of its own, so any read of it is
             // undefined at run time. Point the author at the arm's step instead.
@@ -1176,7 +1155,7 @@ function checkFlow(built, ancestors, opts = {}) {
             }
             // A registered node type that states its output's fields: the same read
             // rule, worded by its contract and reported through its family's catalog.
-            const fieldsPlaced = registeredSteps.get(name);
+            const fieldsPlaced = checkedSteps.get(name);
             const fieldsContract = fieldsPlaced?.impl.output(fieldsPlaced.spec);
             if (fieldsPlaced && fieldsContract?.kind === 'fields') {
                 const found = [];
@@ -2434,79 +2413,6 @@ function checkPublishedFunctionRead(name, field, rest, spec, step, diags) {
         suggestion: `returns: { ${wanted}: 'string' }`,
     });
 }
-/**
- * The fields every HTTP response carries at the top of `output`, whatever the
- * API answered. `core.action.http`'s definition declares all three; the author's
- * `returns` describes what is INSIDE `body`, never beside it.
- */
-const HTTP_ENVELOPE_FIELDS = ['body', 'statusCode', 'headers'];
-/**
- * A read of an `http()` step's result.
- *
- * The response is an envelope — `{ body, statusCode, headers }` — and `returns`
- * declares the parsed JSON body's top-level fields, so a declared field is read
- * at `output.body.<field>` (`out('<step>', 'body.<field>')`). That nesting is the
- * one thing this family does not share with the process families, and it is
- * exactly where flow-builder-sdk#850's run went wrong: a branch kept reading
- * `output.currentDayForecast…` (the Azure Maps connector's path) after the step
- * became an Open-Meteo `http()`, passed `check` and `validate`, and faulted at
- * `flow debug` as `[400302]`.
- */
-function checkHttpRead(name, field, rest, spec, step, diags) {
-    if (field === undefined)
-        return; // `out('fetch')` — the whole response.
-    if (field === 'error')
-        return; // the failure envelope (managed http's error port).
-    if (field !== 'output') {
-        diags.push({
-            level: 'error', code: 'HTTP_READ_NOT_OUTPUT', step,
-            message: `HTTP step "${name}" publishes its response under "output", but "$vars.${name}.${field}" `
-                + `(read in "${step}") asks for "${field}", which is undefined at run time.`,
-            suggestion: `out('${name}', 'body.<field>')`,
-        });
-        return;
-    }
-    const [top, inner] = (rest ?? '').replace(/^\./, '').split('.');
-    if (!top)
-        return; // `$vars.<name>.output` — the whole envelope.
-    const declared = Object.keys(spec?.returns ?? {});
-    if (!HTTP_ENVELOPE_FIELDS.includes(top)) {
-        // The commonest form: a declared body field read one level too high.
-        const hoisted = declared.includes(top) ? top : undefined;
-        const nearest = hoisted ?? nearestName(top, declared);
-        diags.push({
-            level: 'error', code: 'HTTP_READ_UNKNOWN_FIELD', step,
-            message: `"$vars.${name}.output.${top}" (read in "${step}") is not a field of HTTP step "${name}"'s `
-                + `response. An HTTP response publishes ${HTTP_ENVELOPE_FIELDS.map((f) => `"${f}"`).join(', ')}; `
-                + `the fields \`returns\` declares live under "body"`
-                + (hoisted ? `, so "${top}" is read as "$vars.${name}.output.body.${top}".` : '.')
-                + ` A read outside that shape resolves to undefined and faults a gateway at run time.`,
-            ...(nearest !== undefined ? { suggestion: `out('${name}', 'body.${nearest}')` } : {}),
-        });
-        return;
-    }
-    if (top !== 'body' || !inner)
-        return; // `statusCode`, `headers`, or the whole body.
-    if (declared.length === 0) {
-        diags.push({
-            level: 'error', code: 'HTTP_READ_WITHOUT_RETURNS', step,
-            message: `"$vars.${name}.output.body.${inner}" (read in "${step}") reads a field of HTTP step "${name}"'s `
-                + `response body, but the step declares no \`returns\` — so the node carries no body schema and nothing `
-                + `can tell a real field from a typo. Only the API being called knows its body; declare the fields you read.`,
-            suggestion: `returns: { ${inner}: 'string' }`,
-        });
-        return;
-    }
-    if (declared.includes(inner))
-        return;
-    const nearest = nearestName(inner, declared);
-    diags.push({
-        level: 'error', code: 'HTTP_READ_UNKNOWN_FIELD', step,
-        message: `HTTP step "${name}" declares no body field "${inner}" (read as "$vars.${name}.output.body.${inner}" `
-            + `in "${step}"). Its \`returns\` names: ${declared.join(', ')}. A read outside that set resolves to undefined.`,
-        ...(nearest !== undefined ? { suggestion: `out('${name}', 'body.${nearest}')` } : {}),
-    });
-}
 /**
  * The read rule the process-shaped families share: the result is published
  * under `output`, keyed by a known field list — the author's `returns`, or a
@@ -2572,7 +2478,7 @@ function checkRpaWorkflowRead(name, field, rest, spec, step, diags) {
  * build until it lands here.
  */
 const OUTPUT_READ_RULES = {
-    http: checkHttpRead,
+    http: { exempt: 'Registered: the http node types read their own output (nodes/http/flow, a `reader` contract).' },
     rpaWorkflow: checkRpaWorkflowRead,
     apiWorkflow: checkApiWorkflowRead,
     publishedFunction: checkPublishedFunctionRead,
@@ -3912,7 +3818,7 @@ function hitlEndHazards(steps) {
             // is where this arm's token stops on that outcome.
             const spec = st.spec;
             const exits = spec.kind === 'hitl' && hitlDerivesOutcomeHandles(spec.inputs?.variant)
-                ? declaredExits(st.spec, st.options?.version) : undefined;
+                ? 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);
@@ -3966,170 +3872,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.
  */
-/**
- * An ISO-8601 DURATION, which is what both http definitions declare `timeout` to
- * be (`PT15M` by default) and what all 808 deployed http nodes carry.
- *
- * Deliberately the whole grammar rather than the `PT<n>[HMS]` subset the corpus
- * happens to use: a too-narrow fence would refuse `P1D` or `PT1H30M`, which the
- * platform parses perfectly well. What it does refuse is the family of things
- * that are NOT durations at all and would reach the platform as an unparseable
- * string — `'30s'`, `'30'`, `'PT'`, `'15 minutes'`.
- */
-const ISO8601_DURATION = /^P(?!$)(\d+(?:\.\d+)?Y)?(\d+(?:\.\d+)?M)?(\d+(?:\.\d+)?W)?(\d+(?:\.\d+)?D)?(T(?!$)(\d+(?:\.\d+)?H)?(\d+(?:\.\d+)?M)?(\d+(?:\.\d+)?S)?)?$/;
-/**
- * Where `check` stops treating a retry count as plainly reasonable. The
- * platform's own ceiling is NOT measured, and the deployed corpus's largest
- * author-set value is 3 — so above this we WARN. A too-narrow fence is fatal
- * (it refuses something that works); a too-wide one costs nothing.
- */
-const RETRY_COUNT_SOFT_MAX = 5;
-/**
- * The two http settings every deployed request node carries.
- *
- * Both definitions declare the defaults (`timeout: 'PT15M'`, `retryCount: 0`), so
- * omitting them is safe and is what ~99% of deployed nodes do. What is NOT safe
- * is writing them in a form the platform cannot read: an unparseable duration is
- * not a shorter timeout, it is a value the request node fails to configure with,
- * and nothing downstream of `check` would say so in the author's own vocabulary.
- */
-function checkHttp(step, inputs, diags) {
-    // `core.action.http` is retired on the platform side: after `registry pull
-    // --force` the tenant serves only `core.action.http.v2` (2.3), and a
-    // `registry get core.action.http` — bare or at the `@1.3` that `flow migrate`
-    // upgrades it to — answers "Node not found". It still compiles, validates and
-    // runs, which is why this is a warning and not an error: existing flows are
-    // not broken and `decompile` must keep round-tripping them.
-    //
-    // Moving to the managed node is not a rename. A plain step keeps a non-2xx on
-    // the SUCCESS path (`out(step,'statusCode')`); the managed one fails on it, so
-    // a status branch becomes an error handler reading the envelope's `status`.
-    //
-    // It is not a free upgrade either, and for a connection-less URL it is usually
-    // the wrong move (flow-builder-sdk#898). With no `connection` the managed node
-    // still goes through Integration Service: serialize emits the `uipath-uipath-http`
-    // connector on `ImplicitConnection`, so the request leaves from IS's SHARED
-    // egress. Measured on slack-weather-pipeline (3/3 runs): agents took the old
-    // `managed: true` hint, and Open-Meteo answered that egress 429 "Daily API
-    // request limit exceeded" while direct calls from the same box got 200. The
-    // plain node goes direct. So the hint only steers toward `managed: true` when
-    // the step was given connection settings; the two other real reasons to move
-    // (a binding, an `.onError()`) already fire as errors with that suggestion
-    // (HTTP_BINDING_REQUIRES_MANAGED, HTTP_ONERROR_V1).
-    if (inputs && !inputs.managed) {
-        const asked = inputs;
-        const wantsConnection = asked.connection !== undefined || asked.folder !== undefined
-            || asked.targetConnector !== undefined;
-        diags.push(wantsConnection
-            ? {
-                level: 'warning',
-                code: 'HTTP_V1_RETIRED',
-                message: `Step "${step}" emits core.action.http, which the tenant registry no longer serves (only `
-                    + `core.action.http.v2). It sets Integration Service connection settings, which only the managed node `
-                    + `can use. Moving to managed: true changes behaviour rather than just the node type: a non-2xx stops `
-                    + `arriving on the success path with statusCode and fails the step instead, so a status branch becomes `
-                    + `an .onError() handler reading err('${step}', 'status').`,
-                step,
-                suggestion: `http({ url: …, managed: true, connection, folder })`,
-            }
-            : {
-                level: 'warning',
-                code: 'HTTP_V1_RETIRED',
-                message: `Step "${step}" emits core.action.http, which the tenant registry no longer serves (only `
-                    + `core.action.http.v2). It still compiles, validates and runs, and it calls the URL directly. For a URL `
-                    + `that needs no Integration Service connection, keep managed: false. managed: true is not a drop-in `
-                    + `replacement: even without a connection it sends the request through Integration Service's shared `
-                    + `egress (rate limits there are shared, and public APIs can answer 429 where a direct call succeeds), `
-                    + `and a non-2xx fails the step instead of arriving with statusCode. Switch only if the call needs an `
-                    + `Integration Service connection or an .onError() handler.`,
-                step,
-            });
-    }
-    const connection = inputs?.connection;
-    const folder = inputs?.folder;
-    const targetConnector = inputs?.targetConnector;
-    const bindingConfigured = connection !== undefined || folder !== undefined;
-    const targetConfigured = targetConnector !== undefined;
-    const nonEmpty = (value) => typeof value === 'string' && value.trim().length > 0;
-    if (!inputs?.managed && (bindingConfigured || targetConfigured)) {
-        diags.push({
-            level: 'error',
-            code: 'HTTP_BINDING_REQUIRES_MANAGED',
-            message: `Step "${step}" supplies Integration Service connection settings to the standalone HTTP node. `
-                + `Only the managed node can use connection, folder, or targetConnector.`,
-            step,
-            suggestion: `managed: true`,
-        });
-    }
-    else if (inputs?.managed && bindingConfigured && (!nonEmpty(connection) || !nonEmpty(folder))) {
-        diags.push({
-            level: 'error',
-            code: 'HTTP_MANAGED_BINDING_INCOMPLETE',
-            message: `Managed HTTP step "${step}" must name both a non-empty \`connection\` and \`folder\`. The platform `
-                + `needs the pair to resolve the Integration Service connection at runtime.`,
-            step,
-            suggestion: `connection: 'http', folder: 'shared'`,
-        });
-    }
-    if (inputs?.managed && targetConfigured && !nonEmpty(targetConnector)) {
-        diags.push({
-            level: 'error',
-            code: 'HTTP_TARGET_CONNECTOR_EMPTY',
-            message: `Managed HTTP step "${step}" sets an empty \`targetConnector\`; name its Integration Service connector key.`,
-            step,
-            suggestion: `targetConnector: 'uipath-salesforce-slack'`,
-        });
-    }
-    else if (inputs?.managed && targetConfigured && !bindingConfigured) {
-        diags.push({
-            level: 'error',
-            code: 'HTTP_TARGET_CONNECTOR_REQUIRES_BINDING',
-            message: `Managed HTTP step "${step}" sets \`targetConnector\` without a connection and folder. `
-                + `A connector-specific fallback needs the binding pair whose authentication it reuses.`,
-            step,
-            suggestion: `connection: 'slack', folder: 'shared'`,
-        });
-    }
-    const timeout = inputs?.timeout;
-    if (timeout !== undefined) {
-        if (typeof timeout !== 'string' || !ISO8601_DURATION.test(timeout.trim())) {
-            diags.push({
-                level: 'error',
-                code: 'HTTP_TIMEOUT_NOT_DURATION',
-                message: `Step "${step}" sets timeout to ${JSON.stringify(timeout)}, which is not an ISO-8601 duration. The `
-                    + `platform reads this field as a duration string (both http definitions default it to "PT15M"), so a `
-                    + `value it cannot parse configures no timeout at all.`,
-                step,
-                suggestion: `timeout: 'PT30S'  // 30 seconds — also 'PT1M', 'PT15M', 'PT1H'`,
-            });
-        }
-    }
-    const retryCount = inputs?.retryCount;
-    if (retryCount !== undefined) {
-        if (typeof retryCount !== 'number' || !Number.isInteger(retryCount) || retryCount < 0) {
-            diags.push({
-                level: 'error',
-                code: 'HTTP_RETRY_COUNT_INVALID',
-                message: `Step "${step}" sets retryCount to ${JSON.stringify(retryCount)}. It is a count of RETRIES after the `
-                    + `first attempt, so it must be a non-negative whole number — 0 (the definitions' default) means "try `
-                    + `once", 2 means up to three attempts.`,
-                step,
-                suggestion: `retryCount: 2`,
-            });
-        }
-        else if (retryCount > RETRY_COUNT_SOFT_MAX) {
-            diags.push({
-                level: 'warning',
-                code: 'HTTP_RETRY_COUNT_HIGH',
-                message: `Step "${step}" asks for ${retryCount} retries. The local runtime clamps at ${RETRY_COUNT_SOFT_MAX} and `
-                    + `the largest value in the deployed corpus is 3, so a local replay will not exercise what you wrote. `
-                    + `The platform's own ceiling is not measured — this is a warning, not a refusal.`,
-                step,
-                suggestion: `retryCount: ${RETRY_COUNT_SOFT_MAX}`,
-            });
-        }
-    }
-}
 /**
  * Why a form-field type is refused: a product spelling of a type the SDK
  * models (`"string"` is the platform's own name for text), or a type
@@ -4699,6 +4441,7 @@ function checkRegisteredStep(entry, s, exprs, errorSource, opts, diags, typeOf,
                 return name ? { name, type: typeOf.get(name) } : undefined;
             },
             options: opts,
+            bindingLabels: (where, labels, use) => checkBindingLabels(where, labels, opts, (code, message) => diags.push({ level: 'error', code, step: s.name, message }), undefined, use),
         };
         impl.check?.(spec, ctx);
         for (const site of impl.expressions(spec)) {
@@ -4726,11 +4469,15 @@ function checkRegisteredStep(entry, s, exprs, errorSource, opts, diags, typeOf,
         // would get unpinned (select(), else the default) — as decompile lifts an
         // unregistered version — so fixing the pin is not followed by a second round.
         // It stays unplaced: the pin is wrong, so no family rule may rely on it.
-        runRules(resolveVersion(entry.type, spec, undefined, `step "${s.name}"`));
-        return undefined;
+        const fallback = resolveVersion(entry.type, spec, undefined, `step "${s.name}"`);
+        const fallbackCtx = runRules(fallback);
+        return {
+            placed: false,
+            checked: { entry, impl: fallback, spec, placement: { step: s.name, kind: fallback.kind, spec, version: fallback.version }, ctx: fallbackCtx },
+        };
     }
     const ctx = runRules(impl);
-    return { entry, impl, spec, placement: { step: s.name, kind: impl.kind, spec, version: impl.version }, ctx };
+    return { placed: true, checked: { entry, impl, spec, placement: { step: s.name, kind: impl.kind, spec, version: impl.version }, ctx } };
 }
 /** Every non-literal Expr reachable in `value`, as expressions to check. */
 function pushDeepExprs(value, step, errorSource, out) {
@@ -4795,16 +4542,6 @@ function collectActionExprs(s, out, errorSource) {
         if (val && typeof val === 'object')
             return Object.values(val).forEach(pushDeep);
     };
-    if (s.spec.kind === 'http') {
-        const i = s.spec.inputs;
-        push(i.url);
-        push(i.body);
-        for (const val of Object.values(i.headers ?? {}))
-            push(val);
-        for (const val of Object.values(i.query ?? {}))
-            push(val);
-        return;
-    }
     if (s.spec.kind === 'hitl') {
         // A human task's only expressions are the values its shown fields display.
         // Without this a typo'd reference inside a form field would reach the
@@ -4933,8 +4670,8 @@ placed) {
     // 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)) {
-        // No record: the version did not resolve, which NODE_VERSION_UNREGISTERED
-        // already reports where the step is checked.
+        // 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;
@@ -5002,36 +4739,11 @@ placed) {
         });
         return;
     }
-    // Two separate facts about a PLAIN http step, both measured, both fatal to a
-    // handler there:
-    //
-    //  1. a 4xx/5xx does not FAIL the node — it completes carrying `statusCode`,
-    //     so the handler only ever runs on a transport failure (DNS, refused,
-    //     timeout);
-    //  2. when it does run there is nothing to read. `core.action.http@1.0.0` and
-    //     the `@1.3` that `uip maestro flow migrate` upgrades it to both publish
-    //     `<step>.error = true` and leave `<step>.output` null — no envelope
-    //     anywhere, unlike every other family. `validate` still says Valid.
-    //
-    // So this stays an error, and says the second part too: an author who reads
-    // the old message ("use the managed node if statuses must route") could
-    // reasonably conclude a transport-failure handler is fine as it is.
-    if (spec.kind === 'http' && !spec.inputs?.managed)
-        diags.push(plainHttpOnErrorRefusal(step.name));
 }
-/** `.onError` after a plain `core.action.http` node (see the two measured facts in {@link checkOnError}). */
+/** `.onError` after a custom node built on the plain `core.action.http` definition (the http family's refusal). */
 function plainHttpOnErrorRefusal(stepName) {
-    return {
-        level: 'error',
-        code: 'HTTP_ONERROR_V1',
-        message: `Step "${stepName}" handles errors on a plain http() request. A 4xx/5xx does NOT fail that node — it `
-            + `completes with out('${stepName}', 'statusCode') set — so the handler runs only on a transport failure, `
-            + `and when it does the node publishes no failure envelope at all (measured: "<step>.error" is the boolean `
-            + `true and "<step>.output" is null, in 1.0.0 and in the 1.3 flow migrate produces), so err() has nothing `
-            + `to read. The managed node is the one whose failures route AND carry the envelope.`,
-        step: stepName,
-        suggestion: `http({ url: …, managed: true })`,
-    };
+    const { message, suggestion } = plainHttpOnErrorMessage(stepName);
+    return { level: 'error', code: 'HTTP_ONERROR_V1', message, step: stepName, suggestion };
 }
 /**
  * Reading a value that only ONE arm produces (flow-builder-sdk#200).
@@ -5356,7 +5068,7 @@ function loopExitInArm() {
  * checks and what it does not. It checks the FIELD NAME against the envelope's
  * own fields, which are the same on every family. It does NOT police the prefix:
  * `.error` vs `.output` is a per-family runtime boundary, measured per family and
- * rewritten by `serialize` (`ERROR_ENVELOPE_VAR`), so an author writing `.error`
+ * rewritten by `serialize` (a node type's `errorEnvelope`), so an author writing `.error`
  * is right by construction and an author hand-writing `.output` is caught by
  * ERROR_ENVELOPE_VIA_OUTPUT instead.
  *