@uipath/maestro-builder-sdk 6.18.9 → 6.19.0

package/dist/check.js

@@ -5,7 +5,7 @@
  * duplicate step names, references to undeclared variables/steps, empty branch
  * arms, and missing terminals.
  */
-import { Expr, SCHEDULE_PRESETS, DELAY_PRESETS, VARIANT_OPERATION, parseIxpProjectType, flatNameOf, flatNameSegmentsOf, FLAT_SEP } from './flow-sdk.js';
+import { Expr, SCHEDULE_PRESETS, parseIxpProjectType, flatNameOf, flatNameSegmentsOf, FLAT_SEP } 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';
@@ -26,6 +26,9 @@ import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { compareSchemaVersions, schemaVersionRefusal } from './schema-version.js';
 import { planFlowGlobals, planSharedInputs, sharedInputRoots } from './flow-variables.js';
 import { ownEntry } from './core/own-entry.js';
+import { FLOW_NODE_TYPES } from './flow-node-registry.js';
+import { resolveVersion } from './core/nodes/versioned.js';
+import { declaredErrorPortRefusal } from './core/error-port.js';
 export function check(built, opts = {}) {
     let diags = [];
     const uses = collectConnectionUses(() => { diags = checkFlow(built, [], opts); });
@@ -115,6 +118,12 @@ function checkFlow(built, ancestors, opts = {}) {
     ]);
     const outputType = new Map(built.outputs.map((x) => [x.name, String(x.type)]));
     const stepNames = new Set();
+    // Steps whose kind is a registered node type (flow-node-registry.ts), by name:
+    // their node-local rules, expressions and output contract come from the node
+    // type, and their family's rules run over all of them after the walk.
+    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 expression the flow carries, with the step that failed when the
      * expression sits inside that step's error handler. The failed step's own
@@ -133,8 +142,6 @@ function checkFlow(built, ancestors, opts = {}) {
     // `core.logic.merge` definition declares no outputs at all (see
     // PARALLEL_HAS_NO_OUTPUT below).
     const parallelNames = new Set();
-    const delayNames = new Set();
-    const dataFabricReads = new Set();
     // Per-outcome routing bookkeeping: which hitl steps opted into outcome ports
     // (and their declared outcome ids), and which ids actually got a route.
     const hitlOutcomeSteps = new Map();
@@ -151,22 +158,6 @@ function checkFlow(built, ancestors, opts = {}) {
     // waits until the expressions are collected (see HITL_OUTCOMES_UNREACHABLE
     // below).
     const hitlChoiceNoPorts = new Map();
-    // Data Fabric writes that target a record `{ fromRead: '<step>' }` — update and
-    // delete share the selector, so they share the check.
-    const dataFabricRefs = [];
-    // Delete step names. `core.datafabric.delete` is the one verb of the family
-    // whose definition declares NO outputDefinition, so `$vars.<delete>.output` is
-    // undefined at run time (see DATAFABRIC_DELETE_HAS_NO_OUTPUT below).
-    const dataFabricDeletes = new Set();
-    // Reads that return a LIST. A multi-record read is refused as a write target
-    // (see DATAFABRIC_FROMREAD_MULTIPLE below) — the serializer emits a plain
-    // no-op task for the write, and nothing at any rung reports it.
-    const dataFabricMultiReads = new Set();
-    // Placeholder (`mock()`) step names. The platform's `core.logic.mock` declares
-    // one output whose `source` is the literal `"null"` — it publishes nothing —
-    // so `$vars.<mock>.output` is null at run time, always (see
-    // MOCK_HAS_NO_OUTPUT below).
-    const mockNames = new Set();
     // Terminate step names. A terminate declares no action output in any registry
     // version, so `$vars.<terminate>` is undefined at run time. The terminal
     // flow-output mappings the serializer emits are validation metadata, not a
@@ -260,7 +251,7 @@ 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);
+                checkOnError(s, prevPortSource, diags, prevPortSource && registeredSteps.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;
@@ -363,7 +354,17 @@ function checkFlow(built, ancestors, opts = {}) {
             if (s.kind === 'action') {
                 prevAction = s;
                 prevPortSource = s;
-                collectActionExprs(s, exprs, errorSource);
+                const registered = registeredKind(s.spec);
+                if (registered) {
+                    const placed = checkRegisteredStep(registered, s, exprs, errorSource, opts, diags, typeOf, triggerId);
+                    if (placed)
+                        registeredSteps.set(s.name, placed);
+                    else
+                        unresolvedSteps.add(s.name);
+                }
+                else {
+                    collectActionExprs(s, exprs, errorSource);
+                }
                 if (s.spec.kind === 'connector') {
                     connectorSteps.set(s.name, s.spec);
                     checkConnectorLookups(s.name, s.spec, opts, diags);
@@ -380,8 +381,6 @@ function checkFlow(built, ancestors, opts = {}) {
                     }
                     checkContribution(maybeCustom, s.options?.version, s.name, own.some((d) => d.severity === 'error'), diags);
                 }
-                if (s.spec.kind === 'transform')
-                    checkTransform(s.name, s.spec.inputs, diags, typeOf, triggerId);
                 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
@@ -419,14 +418,6 @@ function checkFlow(built, ancestors, opts = {}) {
                         }
                     }
                 }
-                if (s.spec.kind === 'script')
-                    checkScript(s.name, s.spec.inputs, diags);
-                if (s.spec.kind === 'delay') {
-                    checkDelay(s.name, s.spec.inputs, diags);
-                    delayNames.add(s.name);
-                }
-                if (s.spec.kind === 'mock')
-                    mockNames.add(s.name);
                 // `.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.
@@ -497,71 +488,6 @@ function checkFlow(built, ancestors, opts = {}) {
                         outputReaders.set(stepName, (field, rest, at, d) => rule(stepName, field, rest, inputs, at, d));
                     }
                 }
-                if (s.spec.kind === 'documentClassify' || s.spec.kind === 'dynamicExtract') {
-                    const fr = s.spec.inputs.fileRef;
-                    const empty = fr === undefined || fr === null || (typeof fr === 'string' && fr.trim() === '');
-                    if (empty) {
-                        diags.push({
-                            level: 'error', code: 'DOC_NO_FILEREF', step: s.name,
-                            message: `"${s.name}" has no fileRef — nothing to ${s.spec.kind === 'documentClassify' ? 'classify' : 'extract from'}. Reference a file input or an upstream attachment.`,
-                        });
-                    }
-                    if (s.spec.kind === 'dynamicExtract' && s.spec.inputs.schema !== undefined
-                        && (typeof s.spec.inputs.schema !== 'object' || Array.isArray(s.spec.inputs.schema))) {
-                        diags.push({
-                            level: 'error', code: 'EXTRACT_SCHEMA_SHAPE', step: s.name,
-                            message: `"${s.name}"'s schema must be an object (the inline extraction schema document).`,
-                        });
-                    }
-                }
-                if (s.spec.kind === 'dataFabricRead' || s.spec.kind === 'dataFabricCreate'
-                    || s.spec.kind === 'dataFabricUpdate' || s.spec.kind === 'dataFabricDelete') {
-                    if (!String(s.spec.inputs.entity ?? '').trim()) {
-                        diags.push({
-                            level: 'error', code: 'DATAFABRIC_NO_ENTITY', step: s.name,
-                            message: `"${s.name}" names no Data Fabric entity. Set { entity: '<entity name>' }.`,
-                        });
-                    }
-                    if (s.spec.kind === 'dataFabricRead') {
-                        dataFabricReads.add(s.name);
-                        if (s.spec.inputs.resultMode === 'multiple')
-                            dataFabricMultiReads.add(s.name);
-                        checkDataFabricQuery(s.name, s.spec.inputs, diags);
-                    }
-                    if (s.spec.kind === 'dataFabricCreate') {
-                        // Not the same failure as an empty update: a BLANK value is omitted
-                        // from the insert so the column default applies, so an all-blank
-                        // `fieldValues` serializes to an empty body and runs green having
-                        // inserted nothing. The node's schema rejects that — and the fix is
-                        // a real value, never a placeholder to satisfy the rule.
-                        const written = Object.values(s.spec.inputs.values ?? {})
-                            .filter((v) => (v instanceof Expr ? true : String(v ?? '').trim() !== ''));
-                        if (written.length === 0) {
-                            diags.push({
-                                level: 'error', code: 'DATAFABRIC_EMPTY_VALUES', step: s.name,
-                                message: `"${s.name}" sets no column to a non-blank value, so it would insert nothing and run green. `
-                                    + 'The node\'s schema rejects that — give a real column a real value rather than a placeholder.',
-                            });
-                        }
-                        checkDataFabricColumns(s.name, Object.keys(s.spec.inputs.values ?? {}), 'values', diags);
-                    }
-                    if (s.spec.kind === 'dataFabricUpdate') {
-                        if (Object.keys(s.spec.inputs.set ?? {}).length === 0) {
-                            diags.push({
-                                level: 'error', code: 'DATAFABRIC_EMPTY_SET', step: s.name,
-                                message: `"${s.name}" writes no columns — { set } is empty, so the update would no-op green.`,
-                            });
-                        }
-                        checkDataFabricColumns(s.name, Object.keys(s.spec.inputs.set ?? {}), 'set', diags);
-                    }
-                    checkDataFabricScope(s.name, s.spec.inputs, diags);
-                    if (s.spec.kind === 'dataFabricUpdate' || s.spec.kind === 'dataFabricDelete') {
-                        const factory = s.spec.kind === 'dataFabricUpdate' ? 'dataFabricUpdate' : 'dataFabricDelete';
-                        dataFabricRefs.push({ step: s.name, factory, record: s.spec.inputs.record });
-                        if (s.spec.kind === 'dataFabricDelete')
-                            dataFabricDeletes.add(s.name);
-                    }
-                }
                 if (s.spec.kind === 'ixpExtract')
                     checkIxpExtract(s.name, s.spec.inputs, diags);
                 if (s.spec.kind === 'waitEvent') {
@@ -839,30 +765,7 @@ function checkFlow(built, ancestors, opts = {}) {
         }
     }
     reportUnreachableHitlOutcomes(hitlChoiceNoPorts, exprs, diags);
-    for (const { step, factory, record } of dataFabricRefs) {
-        const fromRead = record?.fromRead;
-        if (typeof fromRead !== 'string')
-            continue;
-        if (!dataFabricReads.has(fromRead)) {
-            diags.push({
-                level: 'error', code: 'DATAFABRIC_FROMREAD_UNKNOWN', step,
-                message: `"${step}" targets record: { fromRead: ${JSON.stringify(fromRead)} }, but no dataFabricRead step has that name.`,
-                suggestion: `${factory}({ …, record: { byId: '<record id>' } })`,
-            });
-            continue;
-        }
-        // A LIST is not a write target: the serializer refuses it and emits a plain
-        // no-op task, so the flow validates, runs green, and writes nothing.
-        if (dataFabricMultiReads.has(fromRead)) {
-            diags.push({
-                level: 'error', code: 'DATAFABRIC_FROMREAD_MULTIPLE', step,
-                message: `"${step}" targets record: { fromRead: ${JSON.stringify(fromRead)} }, but "${fromRead}" is a `
-                    + "resultMode: 'multiple' query. A multi-record read is refused as a write target — the step compiles to "
-                    + 'a no-op and the run goes green having written nothing.',
-                suggestion: `loop the results and target each record with ${factory}({ …, record: { byId: … } })`,
-            });
-        }
-    }
+    checkRegisteredFamilies(registeredSteps, unresolvedSteps, stepNames, diags);
     // Entry points: unique roots with valid triggers, colliding with nothing.
     const epIds = new Set();
     for (const ep of built.entryPoints ?? []) {
@@ -1144,6 +1047,16 @@ function checkFlow(built, ancestors, opts = {}) {
                 });
                 continue;
             }
+            // 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);
+            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;
+                }
+            }
             // 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.
             if (switchNames.has(name)) {
@@ -1186,62 +1099,6 @@ function checkFlow(built, ancestors, opts = {}) {
                 });
                 continue;
             }
-            // A Data Fabric delete is the one verb of that family whose definition
-            // declares no outputDefinition at all — the record is gone, so there is
-            // nothing to publish. Read the record on the step that FOUND it instead,
-            // which on the `{ fromRead }` form is already in the flow.
-            if (dataFabricDeletes.has(name)) {
-                diags.push({
-                    level: 'error',
-                    code: 'DATAFABRIC_DELETE_HAS_NO_OUTPUT',
-                    message: `Delete "${name}" produces no output, but "$vars.${name}${field ? '.' + field : ''}" reads one in "${step}". `
-                        + 'A Data Fabric delete declares no outputs — take the value off the dataFabricRead step that found the record, before the delete.',
-                    step,
-                });
-                continue;
-            }
-            if (delayNames.has(name)) {
-                diags.push({
-                    level: 'error',
-                    code: 'DELAY_HAS_NO_OUTPUT',
-                    message: `Delay "${name}" produces no output, but "$vars.${name}${field ? '.' + field : ''}" reads one in "${step}". `
-                        + 'A delay only waits — read the step that computed the value instead.',
-                    step,
-                });
-                continue;
-            }
-            // A `mock()` is a PLACEHOLDER: `core.logic.mock`'s definition declares one
-            // output whose `source` is the literal `"null"`, so the value is null at run
-            // time whatever the flow does. Unlike the four rules above, the node DOES
-            // declare an output slot — which is exactly why the read is silent: it
-            // resolves in the designer, it resolves in `variables.nodes`, and it hands
-            // the downstream step a null.
-            //
-            // WHY THIS RULE LIVES HERE, in the authoring checker rather than in a
-            // pass over the compiled artifact (the measurement,
-            // convention #191). Reading a placeholder's output is the ARCHIVE's
-            // dominant idiom, not a rarity: 55 of the 62 archived mock-carrying
-            // artifacts do it — 110 read sites, 87 of them inside a script's body and
-            // 19 in a decision's expression — and **39 of those 55 come from runs that
-            // scored 1.0**. That is an author writing the downstream code for the real
-            // node the placeholder stands in for, and a `.flow`-level rule refusing it
-            // would refuse the deployed corpus (lesson 47). An SDK author is in the
-            // other position: they wrote `mock()` here, in this file, and the SDK can
-            // say at compile time that the read is dead.
-            //   Measured 2026-08-02 over 4,033 distinct archived artifacts —
-            //   runs/flow-sdk-cleanup-2026-08-02/step0/mock-output-read-sites.txt.
-            if (mockNames.has(name)) {
-                diags.push({
-                    level: 'error',
-                    code: 'MOCK_HAS_NO_OUTPUT',
-                    message: `Placeholder "${name}" publishes nothing, but "$vars.${name}${field ? '.' + field : ''}" reads it in "${step}". `
-                        + 'A mock() is a marker for a node that does not exist yet — its output is null at run time, always. '
-                        + 'Keep the placeholder while the real node does not exist, and have the reader use a value you supply instead (a flow input, as example/ClaimScaffold.flow.ts does). '
-                        + 'Replace the placeholder only with the real node, once `registry search` finds it; a script returning fixed values is not the real node.',
-                    step,
-                });
-                continue;
-            }
             // A subflow hands back an OBJECT keyed by the child flow's declared
             // outputs — even when the child declares exactly one. So the reference
             // needs the output's NAME (`out('call', 'reversed')`), and the name has to
@@ -1985,26 +1842,6 @@ function checkTrigger(spec, diags, opts = {}, entryPointId) {
             + `comes round. Use a non-zero interval.`, `every: 'R/PT1H'`);
     }
 }
-/**
- * An EXACT ISO-8601 duration: weeks/days plus a time part, at least one
- * component. Copied in shape from the delay definition's own
- * `timerValue.pattern`, minus the years and months — see DELAY_CALENDAR below.
- */
-const DURATION_RE = /^P(?!$)(\d+W)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?$/;
-/** Grammatical ISO-8601 duration, including the calendar-relative parts. */
-const ANY_DURATION_RE = /^P(?!$)(\d+Y)?(\d+M)?(\d+W)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?$/;
-/** Natural-language guesses an author might reach for, mapped to a duration. */
-const DURATION_WORDS = [
-    ['second', 'PT30S'], ['minute', 'PT15M'], ['hour', 'PT1H'],
-    ['day', 'P1D'], ['daily', 'P1D'], ['week', 'P1W'], ['weekly', 'P1W'],
-];
-/**
- * Diagnose a `delay` step's wait.
- *
- * Rung 1 is the only place an author hears about a bad duration in time to fix
- * it cheaply. Anything downstream speaks in terms of `timerPreset`/`timerValue`,
- * the two fields the serializer writes, rather than the one field the author typed.
- */
 /** A release key is a GUID — the shape 45/45 deployed rpa node types carry. */
 /**
  * The DECLARED name a single reference resolves to, or undefined.
@@ -3870,64 +3707,6 @@ function checkQueueItem(step, inputs, diags) {
 }
 /** The three priorities `core.action.queue.create[-and-wait]`'s form offers. */
 const QUEUE_PRIORITIES = ['Low', 'Normal', 'High'];
-function checkDelay(step, inputs, diags) {
-    const at = (code, message, suggestion) => {
-        diags.push({ level: 'error', code, message, step, ...(suggestion ? { suggestion } : {}) });
-    };
-    const untilRaw = inputs?.until;
-    if (typeof untilRaw === 'string' && untilRaw.trim() !== '') {
-        // The absolute-date arm: an ISO-8601 date-time, e.g. 2026-09-01T09:00:00Z.
-        const until = untilRaw.trim();
-        if (!/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2})?)?$/.test(until)) {
-            at('DELAY_UNTIL_NOT_ISO', `Delay "${step}"'s until ${JSON.stringify(untilRaw)} is not an ISO-8601 date-time. `
-                + `Use e.g. '2026-09-01T09:00:00Z' (a timezone-less value is read in the tenant's zone).`, `until: '2026-09-01T09:00:00Z'`);
-        }
-        return;
-    }
-    const raw = inputs?.duration;
-    if (raw === undefined || raw === null || (typeof raw === 'string' && raw.trim() === '')) {
-        at('DELAY_NO_DURATION', `Delay "${step}" has no \`duration\`, so it carries no wait at all and the flow runs straight `
-            + `past it. Give it an ISO-8601 duration — ${DELAY_PRESETS.slice(0, 8).join(', ')} … are the `
-            + `designer's presets, and any other exact duration works too.`, `duration: 'PT15M'`);
-        return;
-    }
-    const d = String(raw).trim();
-    if (!ANY_DURATION_RE.test(d)) {
-        at('DELAY_NOT_ISO', `Delay "${step}"'s duration ${JSON.stringify(raw)} is not an ISO-8601 duration. The format is `
-            + `"P" plus a date part and/or "T" plus a time part — PT30S, PT15M, PT2H, P1D, P1W. Note the `
-            + `"T": P1M is a MONTH, PT1M is a minute.`, nearestDuration(d));
-        return;
-    }
-    if (!/[1-9]/.test(d)) {
-        at('DELAY_ZERO', `Delay "${step}"'s duration ${JSON.stringify(d)} is zero-length, so the step waits for no time `
-            + `at all. Use a non-zero duration, or drop the step.`, `duration: 'PT15M'`);
-        return;
-    }
-    // Grammatical, and the platform runs it — but a month is not a fixed number
-    // of milliseconds, so NO local rung can run the flow at all.
-    // Rejected here rather than approximated: guessing 30 days would
-    // put a silent disagreement with the deployed engine back into the pipeline.
-    if (!DURATION_RE.test(d)) {
-        at('DELAY_CALENDAR', `Delay "${step}"'s duration ${JSON.stringify(d)} is calendar-relative: how long a month or a `
-            + `year is depends on when it starts. The platform resolves that at run time, but the local `
-            + `timer takes a fixed millisecond count, so this flow could not be replayed or run offline.`, `duration: 'P30D'`);
-    }
-}
-/** Best guess at what the author meant, for a `DELAY_NOT_ISO` suggestion. */
-function nearestDuration(d) {
-    // The likeliest slip: a time-part duration written without its "T".
-    if (/^P\d+[HMS]$/.test(d) && ANY_DURATION_RE.test(`PT${d.slice(1)}`))
-        return `duration: 'PT${d.slice(1)}'`;
-    const lower = d.toLowerCase();
-    const n = /(\d+)/.exec(lower)?.[1];
-    const word = DURATION_WORDS.find(([w]) => lower.includes(w));
-    if (!word)
-        return undefined;
-    if (!n)
-        return `duration: '${word[1]}'`;
-    const unit = word[1].replace(/\d+/, '');
-    return `duration: '${unit.startsWith('PT') ? `PT${n}${unit.slice(2)}` : `P${n}${unit.slice(1)}`}'`;
-}
 /** Best guess at what the author meant, for a `SCHEDULE_NOT_ISO` suggestion. */
 function nearestInterval(every) {
     // By far the likeliest slip: a correct duration missing the "R/" repeat marker.
@@ -4249,70 +4028,6 @@ const RETRY_COUNT_SOFT_MAX = 5;
  * 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.
  */
-/** The type vocabulary a script's `returns` may name — what the wire format accepts. */
-const SCRIPT_RETURN_TYPES = new Set(['string', 'number', 'boolean', 'object', 'array']);
-/**
- * A script step's `returns` — the author overriding what the body looks like.
- *
- * TypeScript already refuses a bad value at the call site, so this is the fence
- * for everything that does NOT go through the type checker: a `.flow.ts` loaded
- * as plain JS, a generated flow, a value read from config. Both mistakes below
- * reach the emitted file silently and are then the designer's problem instead of
- * the author's, which is precisely the failure this whole feature exists to undo.
- */
-function checkScript(step, inputs, diags) {
-    const returns = inputs?.returns;
-    if (returns === undefined)
-        return;
-    if (typeof returns === 'string') {
-        if (!SCRIPT_RETURN_TYPES.has(returns)) {
-            diags.push({
-                level: 'error',
-                code: 'SCRIPT_RETURNS_UNKNOWN_TYPE',
-                message: `Script step "${step}" declares \`returns: ${JSON.stringify(returns)}\`, which is not a type the `
-                    + `wire format knows. Use one of ${[...SCRIPT_RETURN_TYPES].map((t) => `"${t}"`).join(', ')}, or a `
-                    + `field map like \`{ total: "number" }\` to name an object's fields.`,
-                step,
-            });
-        }
-        return;
-    }
-    if (typeof returns !== 'object' || returns === null || Array.isArray(returns)) {
-        diags.push({
-            level: 'error',
-            code: 'SCRIPT_RETURNS_UNKNOWN_TYPE',
-            message: `Script step "${step}"'s \`returns\` is ${JSON.stringify(returns)}. It takes either a type name or a `
-                + `map of field names to types (\`{ total: "number" }\`).`,
-            step,
-        });
-        return;
-    }
-    const fields = returns;
-    // Same call as `APIWF_EMPTY_RETURNS` one surface over: an empty map declares
-    // nothing, emits nothing, and reads exactly like omitting the key — so it is
-    // almost always a half-finished edit rather than a statement.
-    if (Object.keys(fields).length === 0) {
-        diags.push({
-            level: 'warning',
-            code: 'SCRIPT_EMPTY_RETURNS',
-            message: `Script step "${step}" declares \`returns: {}\`, which names no fields and emits nothing — the same `
-                + `as omitting it. Name the fields, or drop the key and let the body speak for itself.`,
-            step,
-        });
-        return;
-    }
-    for (const [name, type] of Object.entries(fields)) {
-        if (typeof type !== 'string' || !SCRIPT_RETURN_TYPES.has(type)) {
-            diags.push({
-                level: 'error',
-                code: 'SCRIPT_RETURNS_UNKNOWN_TYPE',
-                message: `Script step "${step}" declares field "${name}" as ${JSON.stringify(type)}, which is not a type the `
-                    + `wire format knows. Use one of ${[...SCRIPT_RETURN_TYPES].map((t) => `"${t}"`).join(', ')}.`,
-                step,
-            });
-        }
-    }
-}
 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
@@ -4907,211 +4622,6 @@ function checkHitlRead(name, field, rest, form, step, diags) {
         ...(nearest !== undefined ? { suggestion: `out('${name}', '${nearest}')` } : {}),
     });
 }
-function checkTransform(step, inputs, diags, typeOf = new Map(), triggerId = 'start') {
-    const at = (code, message, suggestion) => {
-        diags.push({ level: 'error', code, message, step, ...(suggestion ? { suggestion } : {}) });
-    };
-    // ── collection must be a bare variable path ──
-    const collection = inputs?.collection;
-    if (collection === undefined || collection === null) {
-        at('TRANSFORM_NO_COLLECTION', `Transform "${step}" has no collection. Point it at the variable or step output holding the array.`, `collection: v('catalog')`);
-    }
-    else if (!(collection instanceof Expr)) {
-        // Types are stripped at run time, so `collection: [{…}]` or
-        // `collection: 'catalog'` reaches here as a raw value.
-        at('TRANSFORM_COLLECTION_NOT_REF', `Transform "${step}" was given a ${Array.isArray(collection) ? 'raw array' : `raw ${typeof collection}`} as its `
-            + `collection. That field is a variable PATH — the runtime turns the string into a lookup, so a value there `
-            + `resolves to nothing and the transform silently sees an empty collection.`, typeof collection === 'string' ? `collection: v('${collection}')` : `collection: v('<varName>')`);
-    }
-    else if (collection.literal) {
-        at('TRANSFORM_COLLECTION_LITERAL', `Transform "${step}" has a literal collection. Inline data cannot be a path — keep the array in a variable `
-            + `default (\`.var('items', types.array, [...])\`) and reference it, or read an upstream step's output.`, `collection: v('items')`);
-    }
-    else if (!/^\$vars\.[A-Za-z0-9_]+(\.[A-Za-z0-9_]+)*$/.test(collection.js.trim())) {
-        // A computed expression (js`…`, tmpl`…`, `.concat(…)`) is the trap that
-        // survives every local rung: a local run resolves it to a value, so
-        // it runs correctly there and resolves to NOTHING once deployed, where the
-        // string is used as a lookup path.
-        at('TRANSFORM_COLLECTION_NOT_PATH', `Transform "${step}"'s collection must be a plain reference, but it is the expression `
-            + `"${collection.js.trim().slice(0, 60)}". The deployed runtime uses that string as a lookup PATH, so a `
-            + `computed expression resolves to nothing there even though it runs locally. Compute it in a script step `
-            + `first, then point the transform at that step's output.`, `collection: out('<scriptStep>')`);
-    }
-    else {
-        // A collection that is not an array is PASSED THROUGH untouched — no error,
-        // no operations applied (faithful to v1). The result is a transform that
-        // looks like it ran and changed nothing.
-        // Only a DECLARED scalar can be judged here: a step output's type is not
-        // known offline, so this stays quiet about those rather than guessing.
-        const refName = declaredRefName(collection.js, triggerId);
-        const declaredType = refName ? typeOf.get(refName) : undefined;
-        if (declaredType && ['string', 'number', 'boolean'].includes(declaredType)) {
-            at('TRANSFORM_COLLECTION_SCALAR', `Transform "${step}"'s collection is "${refName}", declared as ${declaredType}. A transform runs its `
-                + `operations over an ARRAY; anything else is passed through untouched — no error, nothing applied — so `
-                + `the step would look like it ran and change nothing.`, `Declare it as types.array, or point the collection at the array field: collection: out('<step>', '<field>')`);
-        }
-    }
-    // ── the operation chain ──
-    const ops = inputs?.operations;
-    if (!Array.isArray(ops) || ops.length === 0) {
-        at('TRANSFORM_NO_OPERATIONS', `Transform "${step}" has no operations, so it passes its collection straight through. Add at least one `
-            + `filter / map / groupBy operation, or drop the node.`, `operations: [{ type: 'filter', filters: [{ field: 'status', condition: 'equals', value: 'open' }] }]`);
-        return;
-    }
-    checkVariant(step, inputs, ops, at);
-    ops.forEach((op, i) => {
-        const where = `operations[${i}]`;
-        // Read the discriminant before the narrowing below exhausts the union — at
-        // run time it can be anything (an author typo survives type erasure).
-        const kind = op?.type;
-        if (op?.type === 'filter') {
-            if (!Array.isArray(op.filters) || op.filters.length === 0) {
-                at('TRANSFORM_EMPTY_FILTER', `Transform "${step}" ${where} is a filter with no rules — the runtime passes every item through it.`);
-                return;
-            }
-            for (const [j, f] of op.filters.entries()) {
-                if (!f?.field && f?.field !== '')
-                    at('TRANSFORM_FILTER_NO_FIELD', `Transform "${step}" ${where}.filters[${j}] has no field, so the rule is dropped and the filter `
-                        + `matches everything.`);
-                checkVocab(step, `${where}.filters[${j}].condition`, f?.condition, FILTER_CONDITIONS, 'filter condition', 'passes every item through the rule', diags);
-                if (typeof f?.value === 'string' && LOOKS_LIKE_EXPRESSION.test(f.value.trim()))
-                    at('TRANSFORM_FILTER_VALUE_EXPR', `Transform "${step}" ${where}.filters[${j}] compares against ${JSON.stringify(f.value)}. Filter values `
-                        + `are LITERAL only — the runtime evaluates nothing here, so every item would be compared against that `
-                        + `text and the filter would return nothing. Use a literal, or do the comparison in a script step.`, `value: 500`);
-                // `contains` is TWO operators wearing one name — the runtime does
-                // `Array.includes` when the FIELD holds an array and `String.includes`
-                // otherwise, faithful to v1. Which
-                // one runs is decided by the data, so nothing static can pick for you —
-                // but an ARRAY on the compare side is wrong under both readings
-                // (`['a','b']` is stringified to `a,b` for the substring test, and
-                // `includes` looks for the array itself as one element), and it is the
-                // shape an author reaches for when they mean "any of these".
-                if ((f?.condition === 'contains' || f?.condition === 'not_contains') && Array.isArray(f?.value))
-                    at('TRANSFORM_CONTAINS_ARRAY_VALUE', `Transform "${step}" ${where}.filters[${j}] uses "${f.condition}" against an ARRAY. "contains" compares `
-                        + `ONE value: if the item's field holds an array it tests membership of that value, otherwise it tests `
-                        + `for that value as a substring — either way an array on the right matches nothing, silently. For `
-                        + `"any of these", use one rule per value with the filter's "or" operation.`, `condition: 'contains', value: ${JSON.stringify(f.value[0] ?? 'x')}`);
-            }
-            return;
-        }
-        if (op?.type === 'map') {
-            if (!Array.isArray(op.mappings) || op.mappings.length === 0) {
-                at('TRANSFORM_EMPTY_MAP', `Transform "${step}" ${where} is a map with no mappings — with keepOriginalFields off that turns every `
-                    + `item into {}.`);
-                return;
-            }
-            for (const [j, m] of op.mappings.entries()) {
-                if (!m?.field)
-                    at('TRANSFORM_MAP_NO_FIELD', `Transform "${step}" ${where}.mappings[${j}] has no field, so nothing is carried into the output.`);
-                // Omitted is fine — it defaults to `copy`.
-                if (m?.transformation !== undefined)
-                    checkVocab(step, `${where}.mappings[${j}].transformation`, m.transformation, TRANSFORMATIONS, 'transformation', 'copies the value unchanged', diags);
-            }
-            return;
-        }
-        if (op?.type === 'groupBy') {
-            if (!op.groupByField)
-                at('TRANSFORM_NO_GROUP_FIELD', `Transform "${step}" ${where} is a groupBy with no groupByField, so every item lands in one anonymous `
-                    + `group.`);
-            for (const [j, a] of (op.aggregations ?? []).entries()) {
-                if (!a?.alias?.trim())
-                    at('TRANSFORM_AGG_NO_ALIAS', `Transform "${step}" ${where}.aggregations[${j}] has no alias. The runtime drops an unaliased `
-                        + `aggregation, so its result would simply be absent from the output.`);
-                if (a?.operation !== 'count' && !a?.field?.trim())
-                    at('TRANSFORM_AGG_NO_FIELD', `Transform "${step}" ${where}.aggregations[${j}] is "${a?.operation}" with no field. Only "count" `
-                        + `works without one; the runtime drops the rest, so the aggregate would be missing from the output.`);
-                checkVocab(step, `${where}.aggregations[${j}].operation`, a?.operation, AGGREGATION_OPERATIONS, 'aggregation operation', 'yields null for that aggregate', diags);
-            }
-            return;
-        }
-        at('TRANSFORM_UNKNOWN_OP', `Transform "${step}" ${where} has type ${JSON.stringify(kind)}. The runtime skips an operation it does `
-            + `not recognize, so the collection would pass through unchanged. Use 'filter', 'map', or 'groupBy'.`);
-    });
-}
-/**
- * Diagnose the `variant` discriminator on a transform step.
- *
- * A variant emits a single-purpose node type (`core.action.transform.filter`,
- * `.map`, `.group-by`) instead of the generic one. The platform runs all four
- * node types through the SAME script generators and dispatches on the
- * OPERATION's type, never the node's — so a mismatch here does not fault and
- * does not change the answer. It produces a node that lies: a `.filter` node
- * that actually maps, whose operation the designer's filter editor cannot even
- * show. That is exactly the class this SDK catches at rung 1, because no rung
- * below it ever will.
- */
-function checkVariant(step, inputs, ops, at) {
-    const variant = inputs?.variant;
-    if (variant === undefined || variant === null)
-        return; // generic — chains freely
-    const variants = Object.keys(VARIANT_OPERATION);
-    if (typeof variant !== 'string' || !variants.includes(variant)) {
-        at('TRANSFORM_VARIANT_UNKNOWN', `Transform "${step}" has variant ${JSON.stringify(variant)}, which is not a Transform node type. `
-            + `The emitted node would be "core.action.transform.${String(variant)}", which no runtime resolves. `
-            + `Valid: ${variants.join(', ')} — or omit \`variant\` for the generic chaining Transform.`, nearestIn(variant, variants));
-        return;
-    }
-    const expected = VARIANT_OPERATION[variant];
-    if (ops.length !== 1) {
-        at('TRANSFORM_VARIANT_ONE_OP', `Transform "${step}" is the "${variant}" variant but carries ${ops.length} operations. A variant node runs `
-            + `exactly one — the designer's ${variant} editor shows a single ${expected} operation and nothing else. `
-            + `Drop \`variant\` to chain them in one generic Transform, or split them across one node per step.`);
-        return;
-    }
-    const got = ops[0]?.type;
-    if (got !== expected) {
-        at('TRANSFORM_VARIANT_OP_MISMATCH', `Transform "${step}" is the "${variant}" variant but its operation is ${JSON.stringify(got)}, not `
-            + `"${expected}". The node type does not drive the runtime — the OPERATION does — so this would emit a `
-            + `node labelled "${variant}" that actually does ${JSON.stringify(got)}, and the designer's ${variant} `
-            + `editor could not show it. Match them, or drop \`variant\` for the generic Transform.`, typeof got === 'string' && Object.values(VARIANT_OPERATION).includes(got)
-            ? `variant: '${variants.find((v) => VARIANT_OPERATION[v] === got)}'`
-            : `type: '${expected}'`);
-    }
-}
-/** Nearest member of a closed vocabulary, for a "did you mean" suggestion. */
-function nearestIn(value, vocab) {
-    const v = typeof value === 'string' ? value.toLowerCase() : '';
-    return vocab.find((c) => c.replace(/[-_]/g, '') === v.replace(/[^a-z]/g, ''))
-        ?? vocab.find((c) => c.startsWith(v) || (v !== '' && v.startsWith(c)));
-}
-/** A string that is an expression the transform runtime will NOT evaluate. */
-const LOOKS_LIKE_EXPRESSION = /^(=js:|\$vars\.|\{\s*\$vars\.)/;
-// The three closed vocabularies a transform operation carries. TypeScript types
-// them, but an authored `.flow.ts` runs with types ERASED — so `condition:
-// 'greater'` reaches the runtime, whose generated script falls through on a name
-// it does not know and is silent about it:
-//   condition      → the rule passes every item
-//   transformation → the value is copied unchanged
-//   aggregation    → the aggregate is null
-// Green at every rung, wrong answer. Checked here so the author hears it at
-// rung 1 — a flow that never went through this SDK gets no such warning.
-const FILTER_CONDITIONS = [
-    'equals', 'not_equals',
-    'greater_than', 'less_than', 'greater_equal', 'less_equal',
-    'contains', 'not_contains',
-    'starts_with', 'not_starts_with',
-    'ends_with', 'not_ends_with',
-    'matches_regex',
-    'in', 'not_in',
-    'is_null', 'is_not_null',
-    'is_empty', 'is_not_empty',
-];
-const TRANSFORMATIONS = ['copy', 'uppercase', 'lowercase', 'trim'];
-const AGGREGATION_OPERATIONS = ['count', 'sum', 'average', 'min', 'max', 'first', 'last', 'collect'];
-/** Flag a value that is not a member of a closed vocabulary, suggesting the nearest. */
-function checkVocab(step, at, value, vocab, what, effect, diags) {
-    if (typeof value === 'string' && vocab.includes(value))
-        return;
-    const near = nearestIn(value, vocab);
-    diags.push({
-        level: 'error',
-        code: 'TRANSFORM_BAD_VOCAB',
-        message: `Transform "${step}" ${at} is ${JSON.stringify(value)}, which is not a valid ${what}. The runtime does not `
-            + `recognize it and ${effect}, so the result would be silently wrong. Valid: ${vocab.join(', ')}.`,
-        step,
-        ...(near ? { suggestion: near } : {}),
-    });
-}
 /**
  * Flag a case value whose type cannot match the discriminant's declared type.
  *
@@ -5174,100 +4684,116 @@ const LOOP_FIELDS = new Set(['currentItem', 'currentIteration', 'collection', 'o
  * before the 2.4 default (#868); its own fields are not audited here.
  */
 const LOOP_FIELDS_1_0_0 = new Set(['currentItem', 'currentIndex', 'collection', 'output', 'error']);
-/**
- * Columns Data Fabric assigns and never accepts a write for.
- *
- * The canvas hides them from both write editors, but the serializer has no
- * guard: a hand-authored `Id` row satisfies the node's own "at least one field"
- * rule, ships in the body, and is rejected — and the rejection is only logged,
- * so the row comes back unchanged and the run goes green.
- */
-const DATAFABRIC_SYSTEM_COLUMNS = new Set(['Id', 'CreateTime', 'CreatedBy', 'UpdateTime', 'UpdatedBy']);
-function checkDataFabricColumns(step, columns, option, diags) {
-    const system = columns.filter((c) => DATAFABRIC_SYSTEM_COLUMNS.has(c));
-    if (system.length) {
-        diags.push({
-            level: 'error', code: 'DATAFABRIC_SYSTEM_COLUMN', step,
-            message: `"${step}" writes ${system.map((c) => JSON.stringify(c)).join(', ')} in { ${option} }. `
-                + 'Data Fabric assigns its system columns (Id, CreateTime, CreatedBy, UpdateTime, UpdatedBy) and rejects a '
-                + 'write to them — and it only LOGS the rejection, so the row comes back unchanged and the run goes green.',
-        });
-    }
+/** The registered node type for a spec's kind, or undefined (a custom FlowAction has no kind). */
+function registeredKind(spec) {
+    const kind = spec?.kind;
+    return typeof kind === 'string' ? FLOW_NODE_TYPES.byKind(kind, spec) : undefined;
 }
 /**
- * A folder-scoped entity is portable only with its `Entity` bindings.
+ * Check one step whose kind is registered: its version, its node-local rules
+ * (reported through the family's catalog), and the expressions it carries.
+ * Returns its placement, or undefined when the version cannot be resolved — the
+ * step is then reported and not checked further.
  *
- * `_folderKey` on its own still serializes — it falls back to a source-org
- * literal and logs a warning — so the flow looks fine until it is deployed to
- * another org. Refusing the half-authored pair here is the whole point: the
- * alternative is a defect that only appears at deploy time, in a different org,
- * to somebody else.
+ * Its bindings are not checked here: unlike a contribution (`checkContribution`),
+ * a registered type's bindings exist only once it serializes. Closing every
+ * `<bindings.NAME>` its definition references is the node type's own contract,
+ * 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 checkDataFabricScope(step, inputs, diags) {
-    if (inputs.folderKey !== undefined && inputs.resourceKey === undefined) {
-        diags.push({
-            level: 'error', code: 'DATAFABRIC_FOLDER_NO_RESOURCE_KEY', step,
-            message: `"${step}" sets { folderKey } without { resourceKey }. A folder-scoped entity needs both — with only `
-                + 'the folder key the entity serializes as a source-org literal, which validates, runs in this org, and '
-                + 'breaks on deploy to another one.',
-            suggestion: 'resolve the key with `uip solution resources list --kind Entity`, or drop { folderKey } and keep '
-                + 'the entity tenant-scoped',
-        });
+function checkRegisteredStep(entry, s, exprs, errorSource, opts, diags, typeOf, triggerId) {
+    const spec = s.spec;
+    /** The step's node-local rules and expressions, as `impl` defines them. */
+    const runRules = (impl) => {
+        const ctx = {
+            step: s.name,
+            version: impl.version,
+            report: (code, message, suggestion) => diags.push(catalogued(entry, s.name, code, message, suggestion)),
+            declaredRef: (js) => {
+                const name = declaredRefName(js, triggerId);
+                return name ? { name, type: typeOf.get(name) } : undefined;
+            },
+            options: opts,
+        };
+        impl.check?.(spec, ctx);
+        for (const site of impl.expressions(spec)) {
+            if ('code' in site) {
+                // A script body: checked for its `$vars.` refs although it is a string. No
+                // errorSource, as for `script()` (collectActionExprs).
+                exprs.push({ js: site.code, step: s.name });
+            }
+            else {
+                pushDeepExprs(site.value, s.name, errorSource, exprs);
+            }
+        }
+        return ctx;
+    };
+    let impl;
+    try {
+        impl = resolveVersion(entry.type, spec, s.options?.version, `step "${s.name}"`);
     }
-    if (inputs.resourceKey !== undefined && inputs.folderKey === undefined) {
-        diags.push({
-            level: 'error', code: 'DATAFABRIC_RESOURCE_KEY_NO_FOLDER', step,
-            message: `"${step}" sets { resourceKey } without { folderKey }. The pair exists to scope a FOLDER entity; a `
-                + 'tenant-scoped entity needs neither and serializes as a dotted literal.',
-        });
+    catch (e) {
+        // 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 });
+        // 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.
+        // 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 ctx = runRules(impl);
+    return { entry, impl, spec, placement: { step: s.name, kind: impl.kind, spec, version: impl.version }, ctx };
 }
-/**
- * The query options, none of which the node's `inputDefinition` declares — they
- * are `_`-prefixed extras, so `uip maestro flow validate` checks none of them
- * and every mistake here is silent at run time.
- */
-function checkDataFabricQuery(step, inputs, diags) {
-    const listOnly = ['limit', 'skip', 'sort', 'fields'].filter((k) => inputs[k] !== undefined);
-    if (listOnly.length && inputs.resultMode !== 'multiple') {
-        diags.push({
-            level: 'error', code: 'DATAFABRIC_QUERY_OPTS_WITHOUT_MULTIPLE', step,
-            message: `"${step}" sets { ${listOnly.join(', ')} }, which only a list query uses, but its resultMode is `
-                + `${inputs.resultMode ? JSON.stringify(inputs.resultMode) : 'unset (a single-record read)'}.`,
-            suggestion: "resultMode: 'multiple'",
-        });
+/** Every non-literal Expr reachable in `value`, as expressions to check. */
+function pushDeepExprs(value, step, errorSource, out) {
+    if (value instanceof Expr) {
+        if (!value.literal)
+            out.push({ js: value.js, step, errorSource });
     }
-    // The emitted query ALWAYS carries a limit — omitted it resolves to 100 — and
-    // 1000 is a hard ceiling that TRUNCATES rather than erroring above it.
-    if (inputs.limit !== undefined && (!Number.isInteger(inputs.limit) || inputs.limit < 1 || inputs.limit > 1000)) {
-        diags.push({
-            level: 'error', code: 'DATAFABRIC_LIMIT_RANGE', step,
-            message: `"${step}": limit must be a whole number between 1 and 1000 (got ${inputs.limit}). 1000 is a hard `
-                + 'ceiling — a larger value truncates silently, so page with { skip } instead.',
-        });
+    else if (Array.isArray(value)) {
+        for (const v of value)
+            pushDeepExprs(v, step, errorSource, out);
     }
-    // `in` is honoured only on a list query; on a single read the row compiles
-    // away, and a read whose filters compiled away returns EVERY record.
-    if (inputs.resultMode !== 'multiple' && (inputs.filters ?? []).some((f) => f.operator === 'in')) {
-        diags.push({
-            level: 'error', code: 'DATAFABRIC_IN_REQUIRES_MULTIPLE', step,
-            message: `"${step}" filters with the 'in' operator, which is honoured only when resultMode is 'multiple'. `
-                + 'On a single-record read that row compiles away — and a read whose filters compiled away matches every record.',
-        });
+    else if (value && typeof value === 'object') {
+        for (const v of Object.values(value))
+            pushDeepExprs(v, step, errorSource, out);
     }
-    // A filter expression switched on and left blank is refused by the serializer,
-    // and it refuses the WHOLE query rather than dropping the row, which strands
-    // every downstream reference to this step.
-    for (const f of inputs.filters ?? []) {
-        const blank = f.value instanceof Expr ? f.value.js.trim() === '' : String(f.value ?? '').trim() === '';
-        if (blank) {
-            diags.push({
-                level: 'error', code: 'DATAFABRIC_FILTER_BLANK_VALUE', step,
-                message: `"${step}" has a filter on ${JSON.stringify(f.field)} with a blank value. The serializer refuses the `
-                    + 'ENTIRE query rather than dropping the row, so the step emits nothing and every downstream $vars read of '
-                    + 'it breaks.',
-            });
-        }
+}
+/** Whether `e` is one of the SDK's own `internal SDK error:` throws, which `check` never turns into a diagnostic. */
+function isInternalSdkError(e) {
+    return e instanceof Error && e.message.startsWith('internal SDK error:');
+}
+/** A diagnostic a registered node type reports, at its family catalog's severity. */
+function catalogued(entry, step, code, message, suggestion) {
+    const known = Object.hasOwn(entry.family.diagnostics, code) ? entry.family.diagnostics[code] : undefined;
+    if (!known) {
+        throw new Error(`internal SDK error: node family "${entry.family.id}" reports ${code}, which its diagnostics catalog does not list.`);
+    }
+    // Key order as the per-family rules always wrote it — `check --json` prints it.
+    return { level: known.severity, code, step, message, ...(suggestion !== undefined ? { suggestion } : {}) };
+}
+/** Run each registered family's own rules over all of its placements in this flow. */
+function checkRegisteredFamilies(steps, unresolved, stepNames, diags) {
+    const byFamily = new Map();
+    for (const placed of steps.values()) {
+        const list = byFamily.get(placed.entry.family.id) ?? [];
+        list.push(placed);
+        byFamily.set(placed.entry.family.id, list);
+    }
+    for (const placed of byFamily.values()) {
+        const family = placed[0].entry.family;
+        if (!family.check)
+            continue;
+        const ctx = {
+            report: (step, code, message, suggestion) => diags.push(catalogued(placed[0].entry, step, code, message, suggestion)),
+            hasStep: (step) => stepNames.has(step),
+            placementOf: (step) => steps.get(step)?.placement,
+            versionUnresolved: (step) => unresolved.has(step),
+        };
+        family.check(placed.map((p) => p.placement), ctx);
     }
 }
 function collectActionExprs(s, out, errorSource) {
@@ -5294,20 +4820,6 @@ function collectActionExprs(s, out, errorSource) {
             push(val);
         return;
     }
-    if (s.spec.kind === 'script') {
-        // A script body is a plain STRING, not an Expr — so it never went through
-        // this check, and a bad `$vars.…` ref inside one used to surface only rungs
-        // later, as a type error about generated code (flow-builder-sdk#20). The body
-        // isn't parsed; the `$vars.<name>` refs it contains are checked like any other.
-        out.push({ js: s.spec.inputs.code, step: s.name });
-        return;
-    }
-    if (s.spec.kind === 'transform') {
-        // The only expression a transform carries is its collection; everything
-        // else is a literal or a field name (see checkTransform).
-        push(s.spec.inputs.collection);
-        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
@@ -5326,30 +4838,6 @@ function collectActionExprs(s, out, errorSource) {
             push(val);
         return;
     }
-    if (s.spec.kind === 'dataFabricRead' || s.spec.kind === 'dataFabricCreate'
-        || s.spec.kind === 'dataFabricUpdate' || s.spec.kind === 'dataFabricDelete') {
-        // Every value a Data Fabric step carries is authored against flow scope: a
-        // filter's comparison value, the record id, the columns written. The family
-        // was missing here entirely, so a `$vars.` typo in any of them travelled to
-        // the platform unchecked — and the delete verb's no-output rule below has
-        // nothing to fire on until these are collected.
-        if (s.spec.kind === 'dataFabricRead') {
-            for (const f of s.spec.inputs.filters ?? [])
-                push(f.value);
-            return;
-        }
-        if (s.spec.kind === 'dataFabricCreate') {
-            for (const val of Object.values(s.spec.inputs.values ?? {}))
-                push(val);
-            return;
-        }
-        push(s.spec.inputs.record?.byId);
-        if (s.spec.kind === 'dataFabricUpdate') {
-            for (const val of Object.values(s.spec.inputs.set ?? {}))
-                push(val);
-        }
-        return;
-    }
     if (s.spec.kind === 'connector') {
         // Same gap on the connector surface: `messageToSend: tmpl`…${v('typo')}``
         // reached the runtime unchecked.
@@ -5376,6 +4864,17 @@ function collectActionExprs(s, out, errorSource) {
 const PER_TENANT_ERROR_PORT_KINDS = new Set([
     'connector', 'rpaWorkflow', 'apiWorkflow', 'agenticProcess', 'agent', 'ixpExtract',
 ]);
+/**
+ * The ONERROR_NO_ERROR_PORT sentence for a typed step — a built-in family or a
+ * 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.
@@ -5385,7 +4884,9 @@ 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.
  */
-function checkOnError(_handler, step, diags) {
+function checkOnError(_handler, step, diags, 
+/** The step's registry record, when its kind is registered and its version resolved. */
+placed) {
     // 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)
@@ -5439,6 +4940,35 @@ function checkOnError(_handler, step, diags) {
         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)) {
+        // No record: the version did not resolve, which NODE_VERSION_UNREGISTERED
+        // already reports where the step is checked.
+        if (!placed)
+            return;
+        const { impl } = placed;
+        if (impl.definition === 'per-tenant') {
+            const port = typeof impl.errorPort === 'function' ? impl.errorPort(spec) : impl.errorPort === true;
+            if (!port) {
+                diags.push({
+                    level: 'error', code: 'ONERROR_NO_ERROR_PORT', step: step.name,
+                    message: declaredErrorPortRefusal(step.name, impl.typeName, impl.version),
+                });
+                return;
+            }
+        }
+        else {
+            const def = 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). For instance `voiceAgent()`
     // defaults to uipath.agent.voice@1.0 (no error port) and `{ version: '1.1' }`
@@ -5451,13 +4981,10 @@ function checkOnError(_handler, step, diags) {
         ? bundledDef !== undefined && !definitionHasErrorPort(bundledDef)
         : !PER_TENANT_ERROR_PORT_KINDS.has(spec.kind);
     if (noPort) {
-        const nodeType = bundledDef ? ` (${bundledDef.nodeType}@${bundledDef.version})` : '';
         diags.push({
             level: 'error',
             code: 'ONERROR_NO_ERROR_PORT',
-            message: `Step "${step.name}" is a ${spec.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).`,
+            message: typedNoErrorPortMessage(step.name, spec.kind, bundledDef),
             step: step.name,
         });
         return;