@uipath/maestro-builder-sdk 6.18.10 → 6.20.0

package/dist/serialize.js

@@ -10,18 +10,24 @@ import { readFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
-import { Expr, toExpr, SCHEDULE_PRESETS, DELAY_PRESETS, parseIxpProjectType, flatNameOf, flatNameSegmentsOf } from './flow-sdk.js';
+import { BUNDLED_DEFINITIONS, bundledVersions } from './flow-definitions.js';
+import { Expr, toExpr, SCHEDULE_PRESETS, parseIxpProjectType, flatNameOf, flatNameSegmentsOf } from './flow-sdk.js';
 import { FlowAction, FlowTrigger } from './core/node-classes.js';
+import { contextIndexType } from './core/context-index.js';
 import { connectorRawNodeRefusal } from './core/connector-raw-node.js';
-import { dataFabricUnknownInputs } from './core/typed-raw-node.js';
+import { rawNodeInputProblem, registeredRawType } from './raw-node-advice.js';
 import { planContributionBindings } from './core/contribution-bindings.js';
-import { definitionHasErrorPort, errorPortRefusal } from './core/error-port.js';
+import { declaredErrorPortRefusal, definitionHasErrorPort, errorPortRefusal } from './core/error-port.js';
+import { FLOW_NODE_TYPES } from './flow-node-registry.js';
+import { resolveVersion } from './core/nodes/versioned.js';
 import { isAnswerField } from './core/hitl-answers.js';
 import { connectionConnectors } from './bindings-v2.js';
 import { BindingRefusal, GUID_RE, bindingLabelRefusal, bindingMissingMessage, missingBindingLabels } from './core/binding-messages.js';
 import { ByoaRefusal, byoaUnverified } from './core/byoa.js';
 import { genericEventObjectRefusal } from './core/event-checks.js';
-import { OUTCOME_HANDLE_NODE_TYPES, assertHitlExitInvariant, hitlExitModel, hitlExitViolation, outcomeSlug } from './core/hitl-routing.js';
+import { OUTCOME_HANDLE_NODE_TYPES, assertHitlExitInvariant, hitlExitModel, hitlExitViolation, outcomeIdOf, outcomeSlug } from './core/hitl-routing.js';
+import { STICKY_NOTE_TYPE, STICKY_NOTE_TYPE_VERSION } from './core/definitionless-node-types.js';
+import { placeholderPosition } from './node-placement.js';
 import { declaredExits, hasExits } from './core/step-ports.js';
 import { stopsAtEnd } from './flow-step-tree.js';
 import { assertNodeEnvelope } from './core/node-envelope.js';
@@ -45,7 +51,6 @@ export function connectorInputErrors(rc, inputs, resolutions = {}, lookups = {})
     });
 }
 import { isLookupToken, resolveEventWhere, } from './core/lookups.js';
-import { declaredScriptShape, inferScriptShape } from './core/script-return.js';
 import { migrateToSchemaVersion } from './migrate.js';
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { resolveSchemaVersion } from './schema-version.js';
@@ -53,12 +58,13 @@ import { planFlowGlobals, planSharedInputs, sharedInputRoots } from './flow-vari
 import { prepareCommand } from './core/cli-spelling.js';
 import { QUEUE_ITEM_RECORD_SCHEMA } from './core/queue-record.js';
 import { AGENTIC_PROCESS_FORMS } from './core/agentic-process-forms.js';
+import { resourceNodeSortOrder } from './core/process-resource-sort-order.js';
 import { types } from './core/expr.js';
 import { ownEntry } from './core/own-entry.js';
 import { jsonClone } from './core/json-file.js';
 const HERE = dirname(fileURLToPath(import.meta.url));
 // core-definitions.json is an object keyed by "<nodeType>@<version>".
-const DEFS = JSON.parse(readFileSync(join(HERE, 'core-definitions.json'), 'utf8'));
+const DEFS = BUNDLED_DEFINITIONS;
 // FIRST occurrence wins: with multiple bundled versions of one family (HITL
 // 1.0 / 1.1 / 1.2), the unversioned lookup must stay the pinned default, not
 // whichever entry happens to be last in the JSON. (`.loop()` always passes its
@@ -91,8 +97,6 @@ const NODE_TYPE = {
     endCall: 'uipath.conversational.voice.end-call',
     http: 'core.action.http',
     httpV2: 'core.action.http.v2',
-    script: 'core.action.script',
-    transform: 'core.action.transform',
     hitl: 'uipath.human-in-the-loop',
     // The two other spellings of the SAME human task, both resolvable on this
     // tenant. `hitl()` emits the base type unless `variant` names one of these;
@@ -103,23 +107,15 @@ const NODE_TYPE = {
     hitlQuickForm: 'uipath.human-in-the-loop.quick-form',
     hitlActionApp: 'uipath.human-in-the-loop.coded-action-app',
     hitlDocValidation: 'uipath.human-in-the-loop.document-validation',
-    delay: 'core.logic.delay',
     // The PLATFORM's placeholder — "a real node goes here later". Not the engine's
     // fixture-returning `kind: 'mock'` test construct, which shares only the name
     // (#125). The definition declares no `inputDefinition` and one output whose
     // `source` is the literal `"null"`.
-    mock: 'core.logic.mock',
     decision: 'core.logic.decision',
     switch: 'core.logic.switch',
     merge: 'core.logic.merge',
     loop: 'core.logic.loop',
     doWhile: 'core.logic.dowhile',
-    dataFabricRead: 'core.datafabric.read',
-    dataFabricCreate: 'core.datafabric.create',
-    dataFabricUpdate: 'core.datafabric.update',
-    dataFabricDelete: 'core.datafabric.delete',
-    documentClassify: 'uipath.document.classify',
-    dynamicExtract: 'uipath.ixp.extract-document-builder',
     subflow: 'core.subflow',
     terminate: 'core.logic.terminate',
     queueCreate: 'core.action.queue.create',
@@ -214,6 +210,9 @@ function processResourceLocation(spec) {
  * `icon: 'rpa'`, the `bpmn:ServiceTask` / `Orchestrator.StartJob` / `v2` model,
  * `section: 'Published'` (42/45), `debug.runtime: 'bpmnEngine'`, and the
  * `<bindings.name>` / `<bindings.folderPath>` context placeholders.
+ * `sortOrder` is not one of those constants any more: flow-core derives it from
+ * the category, and renumbered after 07-29, so it comes from
+ * `resourceNodeSortOrder` (#1045).
  *
  * Two fields are derived from the author's call rather than from the tenant, and
  * that limit is real:
@@ -244,7 +243,7 @@ function rpaWorkflowDef(spec) {
         runtimeConstraints: { exclude: ['api-function'] },
         description: loc.description,
         tags: loc.tags,
-        sortOrder: 530,
+        sortOrder: resourceNodeSortOrder('rpa-workflow'),
         supportsErrorHandling: true,
         display: { label: spec.name, icon: 'rpa' },
         handleConfiguration: [
@@ -324,7 +323,7 @@ const API_WORKFLOW_PREFIX = 'uipath.core.api-workflow.';
  * AGREE on, not invented: 42 `uipath.core.api-workflow.*` instances across 42
  * dated `skill-flow-api-workflow` artifacts (2026-05-18 → 07-29), cross-checked
  * against `registry get` for today's workflow. Every one is unanimous —
- * `category: 'api-workflow'`, `sortOrder: 510`, `supportsErrorHandling`,
+ * `category: 'api-workflow'`, `sortOrder: 510` (now 640, see `resourceNodeSortOrder`, #1045), `supportsErrorHandling`,
  * `icon: 'api'`, the `bpmn:ServiceTask` / `Orchestrator.ExecuteApiWorkflowAsync` /
  * `v2` model, `section: 'Published'` (37/42; the 5 without are the in-solution
  * shape, a bare-GUID resourceKey — rpa's 3/45 split again), `resourceSubType:
@@ -362,7 +361,7 @@ function apiWorkflowDef(spec) {
         runtimeConstraints: { exclude: ['api-function'] },
         description: `(${spec.folderPath})`,
         tags: [],
-        sortOrder: 510,
+        sortOrder: resourceNodeSortOrder('api-workflow'),
         supportsErrorHandling: true,
         display: { label: spec.name, icon: 'api' },
         handleConfiguration: [
@@ -443,7 +442,7 @@ function publishedFunctionDef(spec) {
         category: 'function',
         description: `(${spec.folderPath})`,
         tags: [],
-        sortOrder: 512,
+        sortOrder: resourceNodeSortOrder('function'),
         supportsErrorHandling: true,
         display: { label: spec.name, icon: 'function' },
         handleConfiguration: [
@@ -521,7 +520,8 @@ function publishedFunctionDef(spec) {
  *
  *  - `uip maestro flow registry get uipath.core.agentic-process.<key>` for ALL
  *    THREE agentic processes on the tenant (2026-07-29): `category:
- *    'agentic-process'`, `sortOrder: 507`, `supportsErrorHandling`, `icon:
+ *    'agentic-process'`, `sortOrder: 507` (now 610 for bpmn, 600 flow, 620 case:
+ *    `resourceNodeSortOrder`, #1045), `supportsErrorHandling`, `icon:
  *    'agentic-process'`, `version: '1.0.0'`, the `bpmn:ServiceTask` /
  *    `Orchestrator.StartAgenticProcess` / `v2` model, `section: 'Published'`,
  *    `resourceSubType: 'ProcessOrchestration'`, `orchestratorType:
@@ -564,7 +564,7 @@ function agenticProcessDef(spec) {
         runtimeConstraints: { exclude: ['api-function'] },
         description: loc.description,
         tags: loc.tags,
-        sortOrder: 507,
+        sortOrder: resourceNodeSortOrder(form.category),
         supportsErrorHandling: true,
         display: { label: spec.name, icon: form.icon },
         handleConfiguration: [
@@ -645,7 +645,8 @@ const INLINE_AGENT_TYPE = 'uipath.agent.autonomous';
  * checkable rather than asserted:
  *
  *  - `uip maestro flow registry get uipath.core.agent.<key>` for ALL NINE agents on
- *    the tenant (2026-07-29): `category: 'agent'`, `sortOrder: 505`,
+ *    the tenant (2026-07-29): `category: 'agent'`, `sortOrder: 505` (510 since flow-core's
+ *    renumber: the 54 runs from 09-01 below carry 510; `resourceNodeSortOrder`, #1045),
  *    `supportsErrorHandling: true`, `version: '1.0.0'`, the `bpmn:ServiceTask` /
  *    `Orchestrator.StartAgentJob` / `v2` model, `section: 'Published'`,
  *    `resourceSubType: 'Agent'`, `orchestratorType: 'agent'`,
@@ -699,7 +700,7 @@ function agentDef(spec) {
         runtimeConstraints: { exclude: ['api-function'] },
         description: loc.description,
         tags: loc.tags,
-        sortOrder: 505,
+        sortOrder: resourceNodeSortOrder('agent'),
         supportsErrorHandling: true,
         display: {
             label: spec.name,
@@ -844,21 +845,6 @@ function contextIndexDef(spec) {
         },
     };
 }
-/**
- * The node type for a context index: `…context.index.<slug>.<uuid>`.
- *
- * The slug is the index's display name lower-cased with every run of
- * non-alphanumerics collapsed to a single `-`. Measured against the platform's own
- * type for "Billing Dispute SOP Index" → `billing-dispute-sop-index`, and pinned
- * by a test — because a derived identifier that disagrees with the registry's is a
- * node type the tenant has never heard of.
- */
-function contextIndexSlug(name) {
-    return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
-}
-function contextIndexType(spec) {
-    return `uipath.agent.resource.context.index.${contextIndexSlug(spec.name)}.${spec.id}`;
-}
 /**
  * Render an index's retrieval query into the platform's MODE-TAGGED object.
  *
@@ -2966,9 +2952,14 @@ function connectionResourceBindings(spec, existing) {
  *    create, or the author's `returns` for a create-and-wait. Without a schema a
  *    downstream read is unresolvable.
  */
-function queueItemDef(spec, stepName, ids) {
+function queueItemDef(spec, stepName, ids, version) {
     const nodeType = spec.wait ? NODE_TYPE.queueCreateAndWait : NODE_TYPE.queueCreate;
-    const base = defByType.get(nodeType);
+    // The template at the AUTHOR'S version, when the bundle has it. Starting from
+    // the default and handing it to makeNode with the pin refused every other
+    // bundled version — the bug #988 fixed for inline agents (#1128). An
+    // unbundled pin falls back to the default, and makeNode's exact-version
+    // refusal names what is bundled.
+    const base = (version !== undefined ? DEFS[`${nodeType}@${version}`] : undefined) ?? defByType.get(nodeType);
     if (!base)
         throw new Error(`no bundled definition for "${nodeType}"`);
     const def = jsonClone(base);
@@ -3048,32 +3039,6 @@ function queueItemBindings(spec, existing) {
         ],
     };
 }
-/**
- * The three single-purpose Transform node types. Same runtime as the generic
- * (the platform dispatches on the OPERATION's type, not the node's) — the node
- * type only says what the node is for, and picks its editor in the designer.
- */
-const TRANSFORM_VARIANT_TYPE = {
-    map: 'core.action.transform.map',
-    filter: 'core.action.transform.filter',
-    'group-by': 'core.action.transform.group-by',
-};
-/**
- * Pick the node type for a transform step: the generic unless a variant is named.
- *
- * An unrecognized variant is rejected by `check` (TRANSFORM_VARIANT_UNKNOWN)
- * before serialization, and compile-cli refuses to emit on errors. Reaching
- * here with one means compile ran without a check — so emit the type the author
- * asked for, keeping the failure loud downstream rather than quietly falling
- * back to the generic (which would produce a flow that runs and is the wrong
- * node) — the same principle as `collectionPath`.
- */
-function transformNodeType(inputs) {
-    const variant = inputs?.variant;
-    if (!variant)
-        return NODE_TYPE.transform;
-    return ownEntry(TRANSFORM_VARIANT_TYPE, variant) ?? `core.action.transform.${String(variant)}`;
-}
 /**
  * Encode a scheduled trigger's single `every` interval into the three inputs the
  * platform's node carries.
@@ -3115,93 +3080,6 @@ function scheduledVersion(inputs, explicit) {
     }
     return cron ? '1.2' : undefined;
 }
-/**
- * Lower filter rows the way the platform's own serializer reads them.
- *
- * `_filters` is an ARRAY, and the join is a `join: 'OR'` key on the row that
- * STARTS a new alternative — `entity-vdo.ts`'s `buildQesFromEntityConfig`
- * splits the array into runs on that key, ANDs within a run, and ORs the runs
- * together. So the query model is disjunctive: `alt1 OR alt2 OR …`, each `alt`
- * an AND of its rows, which is why `[A, B(or), C]` is `A OR (B AND C)` and not
- * `(A OR B) AND C`.
- *
- * The grouped `{ logicalOperator, rows, groups }` object the authoring guide
- * shows is a NEWER shape: the vendored converter the local engine runs throws
- * `(filters ?? []).filter is not a function` on it, so emitting it would trade
- * a working offline rung for a shape only the current platform can read. The
- * array is the form both accept.
- */
-function dataFabricFilterRows(filters, render) {
-    return filters.map((f, i) => ({
-        field: f.field,
-        operator: f.operator ?? '=',
-        value: render(f.value),
-        // Never on the first row: a leading `join` starts an empty run, which the
-        // platform's own loop guards against, and which means nothing anyway.
-        ...(i > 0 && f.or ? { join: 'OR' } : {}),
-    }));
-}
-/**
- * The two `bindings[]` rows a FOLDER-SCOPED entity needs to survive export to
- * another org, and the `_resourceKey` that ties them to the node.
- *
- * Nothing else in this file emits `resource: 'Entity'`: the kind is matched by
- * `(resourceKey, propertyAttribute)` rather than by name, carries no
- * `resourceSubType`, spells the folder attribute `folderKey` (never
- * `folderPath` — a folderPath row receives the Orchestrator FQN, which the
- * Data Fabric query rejects even in the source org), and puts a DISPLAY label
- * in `name`. The capital `E` is load-bearing: packaging ignores a lowercase
- * row, so deploy emits no override at all.
- *
- * A tenant-scoped entity needs none of this — it serializes as a dotted
- * literal — which is why the pair is emitted only when the author supplied
- * both `folderKey` and `resourceKey`. `check` refuses the half-authored case,
- * because `_folderKey` with no binding falls back to a source-org literal that
- * looks portable and breaks on deploy.
- */
-function entityBindings(entity, folderKey, resourceKey) {
-    const base = `b${entity.replace(/[^A-Za-z0-9]/g, '')}Entity`;
-    return [
-        {
-            id: `${base}Name`,
-            name: entity,
-            type: 'string',
-            resource: 'Entity',
-            resourceKey,
-            default: entity,
-            propertyAttribute: 'name',
-        },
-        {
-            id: `${base}Folder`,
-            name: `${entity}Folder`,
-            type: 'string',
-            resource: 'Entity',
-            resourceKey,
-            default: folderKey,
-            propertyAttribute: 'folderKey',
-        },
-    ];
-}
-/**
- * Which `core.datafabric.read` definition a step needs.
- *
- * The family's read node grew from "Read entity" into "Query entity records" at
- * 1.4, and `entityConfig.resultMode` is the input that expresses the difference.
- * The SDK keeps 1.0 pinned as the default, the same way every other family here
- * keeps its older default — a flow that reads one record must not change
- * version because the platform moved. So `resultMode` SELECTS 1.4, exactly as a
- * Quartz `every` selects the scheduled trigger's 1.2 (see `scheduledVersion`).
- */
-function dataFabricReadVersion(inputs, explicit) {
-    if (explicit !== undefined) {
-        if (inputs?.resultMode !== undefined && explicit === '1.0') {
-            throw new Error("dataFabricRead(): { resultMode } needs the node's 1.4 definition, but { version: '1.0' } was "
-                + 'requested. Drop the version, request 1.4, or drop resultMode.');
-        }
-        return explicit;
-    }
-    return inputs?.resultMode !== undefined ? '1.4' : undefined;
-}
 /**
  * The form-trigger schema: one field per flow input, the same derivation the
  * designer's form editor applies to a flow's arguments (`argument-fields.ts` /
@@ -3246,42 +3124,6 @@ function scheduleInputs(inputs, nodeId) {
         ...(isPreset ? {} : { timerValue: every }),
     };
 }
-/**
- * Encode a delay's single `duration` into the two inputs the platform's node
- * carries — the SAME split as the scheduled trigger above, on the same field
- * names, because it is the same designer control: `timerPreset` holds the
- * duration when it is one of the dropdown's twelve, and otherwise holds the
- * literal `"custom"` with the real duration in `timerValue`. flow-v1's timer
- * serializer collapses them straight back (`event-definition.ts:31`), so the
- * two encodings are the same wait.
- *
- * Both are shapes the platform actually deploys — 26 of 26 archived
- * `skill-flow-delay` flows carry the preset form, 35 of 38 archived
- * `skill-flow-terminate` flows the custom form — so this is a choice of
- * encoding, not of correctness. Emitting the preset when one fits keeps the
- * node's Duration dropdown showing a value instead of "Custom".
- *
- * `timerType` is `timeDuration` for a `duration` and `timeDate` for `until`,
- * because the platform's timer serializer resolves a body as
- * "preset, else timerValue" for EVERY kind and so never reads `timerDate` while
- * a duration is present (flow-builder-sdk#70).
- */
-function delayInputs(inputs) {
-    // An absolute-date wait (`until`) is the definition's timeDate arm: it
-    // requires timerDate, while the top-level required timerPreset is satisfied
-    // with the literal 'custom' (the timeDuration-only allOf never fires).
-    const until = String(inputs?.until ?? '').trim();
-    if (until) {
-        return { timerType: 'timeDate', timerPreset: 'custom', timerDate: until };
-    }
-    const duration = String(inputs?.duration ?? '').trim();
-    const isPreset = DELAY_PRESETS.includes(duration);
-    return {
-        timerType: 'timeDuration',
-        timerPreset: isPreset ? duration : 'custom',
-        ...(isPreset ? {} : { timerValue: duration }),
-    };
-}
 /** JSON-Schema type per form-field type, as flow-v1's form serializer maps them (quick-form escalations and human tasks). */
 const FORM_FIELD_JSON_TYPE = {
     text: { type: 'string' },
@@ -3356,7 +3198,7 @@ function hitlInputs(inputs, nodeId, flowId, label, rename) {
     const outcomes = (inputs?.outcomes ?? []).map((o, i) => {
         const name = typeof o === 'string' ? o : o?.name;
         const action = typeof o === 'string' ? 'Continue' : (o?.action ?? 'Continue');
-        return { id: outcomeId(name, i), name, type: 'string', isPrimary: i === 0, action };
+        return { id: outcomeIdOf(o, i), name, type: 'string', isPrimary: i === 0, action };
     });
     const properties = {};
     for (const f of inputs?.fields ?? []) {
@@ -3632,8 +3474,6 @@ const NO_RENAME = { nodeIds: new Map(), errorEnvelopes: new Map() };
 const ERROR_ENVELOPE_VAR = {
     [NODE_TYPE.httpV2]: 'output',
 };
-/** The `typeVersion` Studio Web stamps on a sticky note. The type has no manifest to take it from. */
-const STICKY_NOTE_TYPE_VERSION = '1.0.0';
 /**
  * Append the flow's `.stickyNotes()` as real `stickyNote` nodes.
  *
@@ -3684,7 +3524,7 @@ function emitStickyNotes(built, scope, claimNoteId) {
         // `flow validate`, manifest or not (#869).
         scope.nodes.push({
             id: emittedId,
-            type: 'stickyNote',
+            type: STICKY_NOTE_TYPE,
             typeVersion: STICKY_NOTE_TYPE_VERSION,
             ui: {
                 position: { x: note.x, y: note.y },
@@ -3936,22 +3776,12 @@ function describeDeclared(bindings) {
 export function bundledActionNodeType(spec) {
     switch (spec?.kind) {
         case 'http': return spec.inputs?.managed ? NODE_TYPE.httpV2 : NODE_TYPE.http;
-        case 'transform': return transformNodeType(spec.inputs);
         case 'hitl': return hitlNodeType(spec.inputs);
         case 'queueItem': return spec.inputs?.wait ? NODE_TYPE.queueCreateAndWait : NODE_TYPE.queueCreate;
         case 'inlineAgent': return INLINE_AGENT_TYPE;
-        case 'delay':
-        case 'script':
-        case 'mock':
         case 'subflow':
         case 'summarize':
         case 'batchTransform':
-        case 'documentClassify':
-        case 'dynamicExtract':
-        case 'dataFabricRead':
-        case 'dataFabricCreate':
-        case 'dataFabricUpdate':
-        case 'dataFabricDelete':
         case 'sendMessage':
         case 'waitForMessage':
         case 'conversationContext':
@@ -4017,14 +3847,35 @@ export function resolveContributionDefinition(ref, requestedVersion, where) {
     throw new Error(`${where}: unknown DefinitionReference source "${ref.source}".`);
 }
 /**
- * The forward port of a contribution-lowered node, derived from its
- * definition's handles: the source handle marked `isDefaultForType`, else the
- * first non-error source handle, else the conventional `output`.
+ * Whether `def` declares `port` as a forward source handle: an exact id, or a
+ * templated one (`outcome-{item.id}` declares every `outcome-<slug>`). `error` is
+ * not a forward port. A definition that declares no handles cannot say, so it
+ * accepts any port.
+ */
+function declaresForwardPort(def, port) {
+    const handles = (def?.handleConfiguration ?? []).flatMap((g) => g?.handles ?? []);
+    if (handles.length === 0)
+        return true;
+    return handles.some((h) => {
+        if (h?.type !== 'source' || typeof h.id !== 'string' || h.id === 'error')
+            return false;
+        if (!h.id.includes('{'))
+            return h.id === port;
+        const [head, tail] = [h.id.slice(0, h.id.indexOf('{')), h.id.slice(h.id.lastIndexOf('}') + 1)];
+        return port.length > head.length + tail.length && port.startsWith(head) && port.endsWith(tail);
+    });
+}
+/**
+ * Forward port: the first concrete source handle (`isDefaultForType` wins), else `output`;
+ * `undefined` when every forward source handle is templated (`case-{item.id}`).
  */
 function contributionPort(def) {
     const handles = (def?.handleConfiguration ?? []).flatMap((g) => g?.handles ?? []);
     const sources = handles.filter((h) => h?.type === 'source' && h?.id !== 'error');
-    return sources.find((h) => h?.isDefaultForType)?.id ?? sources[0]?.id ?? 'output';
+    const concrete = sources.filter((h) => typeof h?.id === 'string' && !h.id.includes('{'));
+    if (concrete.length === 0 && sources.length > 0)
+        return undefined;
+    return concrete.find((h) => h?.isDefaultForType)?.id ?? concrete[0]?.id ?? 'output';
 }
 /**
  * Render a switch case value as a JS literal for the case expression.
@@ -4726,12 +4577,21 @@ export function serialize(built, opts = {}) {
      * recorded: `check` answers for those from its per-tenant kind list.
      */
     const bundledNodeDefs = new Map();
+    /**
+     * Node id → whether a registered PER-TENANT node type has an error port, as it
+     * declares (its definition is built per call, so there is nothing else to ask).
+     * A registered bundled type is in `bundledNodeDefs` like any typed family.
+     */
+    const declaredErrorPorts = new Map();
     /**
      * Refuse an `error` edge from a node whose definition has no error port: a
      * contribution-lowered node (#943) or a typed node with a bundled definition
      * (#1011). Same predicate as `check`, so `compile --no-check` agrees with it.
      */
     function refuseErrorEdgeWithoutPort(nodeId, stepName) {
+        const declared = declaredErrorPorts.get(nodeId);
+        if (declared?.port === false)
+            throw new Error(declaredErrorPortRefusal(stepName, declared.typeName, declared.version));
         const contributed = contributionDefs.get(nodeId);
         const def = contributed ?? bundledNodeDefs.get(nodeId);
         if (def !== undefined && !definitionHasErrorPort(def)) {
@@ -4865,6 +4725,8 @@ export function serialize(built, opts = {}) {
      * `.stepToRef` rejoins now do come through here, #938).
      */
     const hitlNodes = new Map();
+    /** Step name → node id of a step whose every forward exit is templated (see `contributionPort`). */
+    const routerNodes = new Map();
     /**
      * Human tasks with an outcome whose path stops at an End while another
      * outcome continues — read by `.parallel`, whose join would wait forever for
@@ -4896,8 +4758,16 @@ export function serialize(built, opts = {}) {
         if (o.requestedVersion !== undefined && def?.version !== o.requestedVersion) {
             const exact = o.def ? undefined : DEFS[`${type}@${o.requestedVersion}`];
             if (!exact) {
+                // Name every version the SDK could have resolved: every bundled
+                // version of the type, else (a type built per resource, a connector)
+                // the definition in hand. Naming only the default sent the reader
+                // looking for a version that was shipped all along (#1128:
+                // quick-form bundles 1.0 AND 1.1, and the message said 1.0).
+                const bundled = bundledVersions(type);
+                const resolvable = bundled.length > 0 ? bundled
+                    : [def?.version].filter((v) => typeof v === 'string');
                 throw new Error(`"${label ?? id}" requests ${type}@${o.requestedVersion}, but this SDK resolves only `
-                    + `${type}@${def?.version ?? '<none>'}. Versions are exact — omit { version } to use `
+                    + `${type}@${resolvable.join(', ') || '<none>'}. Versions are exact — omit { version } to use `
                     + `the pinned default, or request a version this SDK ships.`);
             }
             def = exact;
@@ -4910,18 +4780,15 @@ export function serialize(built, opts = {}) {
             id,
             type,
             typeVersion: def?.version ?? '1.0.0',
-            ui: { position: { x: 256 + col * 288, y: 144 + (o.parentId ? 160 : 0) }, size: { width: 96, height: 96 }, collapsed: false },
+            ui: { position: placeholderPosition(col, Boolean(o.parentId)), size: { width: 96, height: 96 }, collapsed: false },
             display: { label: label ?? def?.display?.label ?? id, ...(def?.display?.icon ? { icon: def.display.icon } : {}) },
         };
         col++;
-        // A Data Fabric node gets no node-level `model`, whichever path emits it
-        // (the typed verbs, or a rawNode through emitContribution). Studio Web
-        // never writes one (flow-core node.ts: "`node.model` is never written";
-        // canvas `nodeToInstance` omits it), and export seeds it from the
-        // definition (services bpmn-to-xml.ts), so a copy here can only go stale.
-        // `outputs` stay: the canvas persists them (`source: '=response'`), and
-        // `variables.nodes[]` is derived from them.
-        if (def?.model && !type.startsWith('core.datafabric.'))
+        // A registered node type may carry no node-level `model`, whichever path
+        // emits it (its own serialize, or a rawNode through emitContribution) — the
+        // Data Fabric verbs, whose reasons are in their family (`nodeModel`).
+        const omitModel = registeredRawType(type, String(def?.version ?? ''))?.impl.nodeModel === 'omit';
+        if (def?.model && !omitModel)
             node.model = subNodeId(jsonClone(def.model), id);
         if (def?.outputDefinition)
             node.outputs = subNodeId(jsonClone(def.outputDefinition), id);
@@ -5124,7 +4991,7 @@ export function serialize(built, opts = {}) {
     function successPort(type) {
         if (type === NODE_TYPE.http || type === NODE_TYPE.httpV2)
             return 'default';
-        if (type === NODE_TYPE.script || type === NODE_TYPE.loop)
+        if (type === NODE_TYPE.loop)
             return 'success';
         // Both queue definitions declare exactly one source handle, `success` — and
         // the shipped `sample-flows/queue-operations.flow` wires its edges to it.
@@ -5156,9 +5023,6 @@ export function serialize(built, opts = {}) {
         // as it is in all 151 deployed IxP instances.
         if (type.startsWith('uipath.ixp.'))
             return 'success';
-        // Classify declares the same single `success` source handle as the extractors.
-        if (type === NODE_TYPE.documentClassify)
-            return 'success';
         // connectors, the trigger, the merge join and the mock placeholder all expose
         // their forward edge on `output` (merge's definition declares exactly one
         // source handle, `output`; so does `core.logic.mock`, and all 74 archived
@@ -5185,27 +5049,119 @@ export function serialize(built, opts = {}) {
         const connectorRefusal = connectorRawNodeRefusal(def.nodeType);
         if (connectorRefusal)
             throw new Error(`${where}: ${connectorRefusal}`);
-        // A Data Fabric key the product never reads (`_sortOptions`) is refused for
-        // every contribution, whichever class or SDK copy made it: `validate`
-        // cannot see it, and the node would ignore it at run time.
-        const unknownInput = dataFabricUnknownInputs(def.nodeType, def.version, contribution.inputs);
+        // An input a registered node type never reads (a Data Fabric `_sortOptions`)
+        // is refused for every contribution, whichever class or SDK copy made it:
+        // `validate` cannot see it, and the node would ignore it at run time.
+        const unknownInput = rawNodeInputProblem(def.nodeType, def.version, contribution.inputs);
         if (unknownInput?.severity === 'error')
             throw new Error(`${where}: ${unknownInput.message}`);
         const id = stepUid(scope, stepName);
-        const node = makeNode(def.nodeType, id, stepName, { parentId, def, requestedVersion });
+        contributionDefs.set(id, def);
+        return placeStepNode({ where, stepName, id, typeName: def.nodeType, requestedVersion, def, contribution, tails, scope, parentId });
+    }
+    /**
+     * Place one step node from a contribution — the one path a custom FlowAction
+     * (emitContribution) and a registered node type (emitRegistered) share
+     * (docs/NODE_TYPE_ARCHITECTURE_DESIGN.md, Phase 3). The serializer owns the
+     * rest: the node envelope from the definition, rendering, bindings, edges, and
+     * the forward port. `def` is undefined only for a registered bundled type,
+     * whose definition is `<typeName>@<version>` from the bundle.
+     */
+    function placeStepNode(o) {
+        const { id, contribution, scope } = o;
+        const node = makeNode(o.typeName, id, o.stepName, { parentId: o.parentId, def: o.def, requestedVersion: o.requestedVersion });
+        if (contribution.model === 'omit')
+            delete node.model;
         node.inputs = renderDeep(contribution.inputs ?? {}, scope.rename);
         if (contribution.outputs) {
             node.outputs = { ...(node.outputs ?? {}), ...subNodeId(jsonClone(contribution.outputs), id) };
         }
-        hoistContributionBindings(def, contribution.bindings, where);
-        contributionDefs.set(id, def);
+        // A bundled registered type returns no definition; its bindings still close
+        // against the bundled one (#942), counting what it bound through the context
+        // as supplied (first, in the order it bound them, as when `bind` hoisted directly).
+        const def = o.def ?? bundledDefinition(o.typeName, o.requestedVersion);
+        hoistContributionBindings(def, [...(o.bound ?? []), ...(contribution.bindings ?? [])], o.where);
         scope.nodes.push(node);
-        for (const t of tails)
+        for (const t of o.tails)
             addEdge(scope, t, id);
-        return [{ node: id, port: contributionPort(def) }];
+        const port = contribution.port ?? contributionPort(def);
+        if (port === undefined) {
+            // Only templated exits: no main path leaves this node. Remember it so a
+            // following `.stepToList` / side-exit `.stepToRef` can still attach.
+            routerNodes.set(o.stepName, id);
+            return [];
+        }
+        return [{ node: id, port }];
+    }
+    /**
+     * Lower a step whose kind is a registered node type (flow-node-registry.ts):
+     * the node type serializes its spec through a context, and this owns the rest —
+     * id, label, `typeVersion`, definition, rendering, bindings, edges — exactly as
+     * for a custom contribution. docs/NODE_TYPE_ARCHITECTURE_DESIGN.md §4.
+     */
+    function emitRegistered(entry, step, tails, scope, parentId) {
+        const where = `step "${step.name}"`;
+        const spec = step.spec;
+        const impl = resolveVersion(entry.type, spec, step.options?.version, where);
+        const id = stepUid(scope, step.name);
+        // As for every typed family: record the failure-envelope boundary before any
+        // expression renders, so a handler reading this step resolves correctly.
+        const envelope = ownEntry(ERROR_ENVELOPE_VAR, impl.typeName);
+        if (envelope)
+            scope.rename.errorEnvelopes.set(step.name, envelope);
+        const ctx = {
+            step: step.name,
+            version: impl.version,
+            render: (value) => renderValue(value, scope.rename),
+            renameRefs: (js) => renameRefs(js, scope.rename),
+            stepNodeId: (name) => scope.stepNodeId.get(name) ?? name,
+            mint: (seed) => stableId(`${built.id}:${id}:${seed}`),
+            bind: (b) => { bound.push(b); },
+            definition: (typeName, version) => bundledDefinition(typeName, version),
+        };
+        const bound = [];
+        const contribution = impl.serialize(spec, ctx);
+        // The definition contract, both halves: a per-tenant type supplies its
+        // definition, and a bundled type does not (its definition is the bundle's, and
+        // makeNode records it, so the error-edge refusal and check ask the same one).
+        let def;
+        if (impl.definition === 'bundled' && contribution.definition !== undefined) {
+            throw new Error(`internal SDK error: ${where}: bundled node type ${impl.typeName}@${impl.version} returned a definition; `
+                + 'the bundle owns it — omit `definition`, or declare the type per-tenant.');
+        }
+        if (contribution.definition !== undefined) {
+            def = resolveContributionDefinition(contribution.definition, impl.version, where);
+        }
+        else if (impl.definition === 'per-tenant') {
+            throw new Error(`internal SDK error: ${where}: per-tenant node type ${impl.typeName}@${impl.version} returned no definition.`);
+        }
+        if (impl.definition === 'per-tenant') {
+            const port = typeof impl.errorPort === 'function' ? impl.errorPort(spec) : impl.errorPort === true;
+            // The declaration answers for check, which has no definition; here the
+            // definition is in hand, and the two must agree (#1011).
+            if (port && def !== undefined && !definitionHasErrorPort(def)) {
+                throw new Error(`internal SDK error: ${where}: node type ${impl.typeName}@${impl.version} declares an error port, `
+                    + 'but the definition it supplied has no error handle and no supportsErrorHandling.');
+            }
+            declaredErrorPorts.set(id, { port, typeName: impl.typeName, version: impl.version });
+        }
+        if (contribution.port !== undefined && !declaresForwardPort(def ?? bundledDefinition(impl.typeName, impl.version), contribution.port)) {
+            throw new Error(`internal SDK error: ${where}: node type ${impl.typeName}@${impl.version} leaves by port "${contribution.port}", `
+                + 'which its definition declares no source handle for.');
+        }
+        return placeStepNode({
+            where, stepName: step.name, id, typeName: impl.typeName, requestedVersion: impl.version, def, contribution, bound, tails, scope, parentId,
+        });
     }
     function emitAction(step, tails, scope, parentId) {
         const spec = step.spec;
+        // A registered node type serializes itself; every other kind falls through to
+        // the branches below until its family is ported (FB014's pins are the list).
+        const registered = typeof spec.kind === 'string'
+            ? FLOW_NODE_TYPES.byKind(spec.kind, spec)
+            : undefined;
+        if (registered)
+            return emitRegistered(registered, step, tails, scope, parentId);
         if (spec.kind === 'subflow') {
             const id = stepUid(scope, step.name);
             // `subflows` is ONE flat map for the whole file, keyed by the calling
@@ -5473,6 +5429,13 @@ export function serialize(built, opts = {}) {
             const contexts = s.context === undefined ? []
                 : Array.isArray(s.context) ? s.context : [s.context];
             for (const cx of contexts) {
+                // `check`'s AGENT_CONTEXT_NO_ID, again for `--no-check`: a blank id builds
+                // the type `…context.index.<slug>.`, which no tenant serves, and nothing
+                // after this point would say so.
+                if (typeof cx?.id !== 'string' || !GUID_RE.test(cx.id)) {
+                    throw Object.assign(new Error(`inline agent "${step.name}": context index "${cx?.name ?? ''}" needs its index id (a GUID) as \`id\`; `
+                        + `got ${JSON.stringify(cx?.id)}. \`uip solution resources list --kind Index --source remote --search "<name>"\` returns it as \`Key\`.`), { code: 'AGENT_CONTEXT_NO_ID' });
+                }
                 const cdef = contextIndexDef({ name: cx.name, id: cx.id });
                 // `<step>Context`, deduped by `uid` for a second index on the same agent.
                 // Not slugged from the index NAME: an id is the author's handle on the node
@@ -5936,7 +5899,7 @@ export function serialize(built, opts = {}) {
             const { ids, entries } = queueItemBindings(s, resourceBindings);
             for (const b of entries)
                 resourceBindings.set(b.id, b);
-            const def = queueItemDef(s, step.name, ids);
+            const def = queueItemDef(s, step.name, ids, step.options?.version);
             const id = stepUid(scope, step.name);
             // The result is read as `$vars.<step>.output`, like every other family: the
             // node's own output block maps the runtime `response` onto the variable
@@ -6310,154 +6273,6 @@ export function serialize(built, opts = {}) {
             }
             return [{ node: id, port: successPort(hitlType) }];
         }
-        if (spec.kind === 'mock') {
-            // A placeholder is a pure `makeNode` node: the definition supplies `model`
-            // and the single `output` (`source: "null"`), and there is nothing else to
-            // write. `inputs: {}` rather than an omitted key because that is what the
-            // vendored Studio-Web golden writes (`shared/sample-flows/new.flow`, all
-            // three of its mock nodes) and what 36 of the 74 archived instances carry.
-            //
-            // Nothing here can open a fixture channel: a runner that honours one looks
-            // for `fixture`/`output`/`value` in the node's `inputs`, and the factory
-            // takes no arguments, so `inputs` is always the empty object. That
-            // is the #125 fence, made unrepresentable rather than documented.
-            const id = stepUid(scope, step.name);
-            const node = makeNode(NODE_TYPE.mock, id, step.name, { parentId, requestedVersion: step.options?.version });
-            node.inputs = {};
-            scope.nodes.push(node);
-            for (const t of tails)
-                addEdge(scope, t, id);
-            return [{ node: id, port: successPort(NODE_TYPE.mock) }];
-        }
-        if (spec.kind === 'documentClassify' || spec.kind === 'dynamicExtract') {
-            const type = spec.kind === 'documentClassify' ? NODE_TYPE.documentClassify : NODE_TYPE.dynamicExtract;
-            const id = stepUid(scope, step.name);
-            const node = makeNode(type, id, step.name, { parentId, requestedVersion: step.options?.version });
-            const def = defByType.get(type);
-            const defaults = jsonClone(def?.inputDefaults ?? {});
-            // A `uipath.ixp.*` fileRef must stay a PLAIN `=js:` string — the platform
-            // reads it unwrapped (see migrate's UNWRAPPED_INPUTS); classify follows
-            // the default envelope rules.
-            const fileRef = renderValue(toExpr(spec.inputs.fileRef), scope.rename);
-            if (spec.kind === 'documentClassify') {
-                node.inputs = {
-                    ...defaults,
-                    fileRef,
-                    ...(spec.inputs.pageRange !== undefined ? { pageRange: spec.inputs.pageRange } : {}),
-                    ...(spec.inputs.splitPages !== undefined ? { splitPages: spec.inputs.splitPages } : {}),
-                    ...(spec.inputs.modelConfig !== undefined
-                        ? { modelConfig: { ...(defaults.modelConfig ?? {}), ...spec.inputs.modelConfig } }
-                        : {}),
-                };
-            }
-            else {
-                const m = spec.inputs.model;
-                node.inputs = {
-                    ...defaults,
-                    // The deployment identity Studio Web's panel destructures — both the
-                    // nested `model` object and the flat mirrors the definition declares.
-                    model: { modelName: m.modelName, folderKey: m.folderKey },
-                    modelName: m.modelName,
-                    folderKey: m.folderKey,
-                    ...(m.projectId !== undefined ? { projectId: m.projectId } : {}),
-                    ...(m.projectName !== undefined ? { projectName: m.projectName } : {}),
-                    ...(m.folderName !== undefined ? { folderName: m.folderName } : {}),
-                    ...(m.versionTag !== undefined ? { versionTag: m.versionTag } : {}),
-                    fileRef,
-                    ...(spec.inputs.pageRange !== undefined ? { pageRange: spec.inputs.pageRange } : {}),
-                    ...(spec.inputs.modelConfig !== undefined
-                        ? { modelConfig: { ...(defaults.modelConfig ?? {}), ...spec.inputs.modelConfig } }
-                        : {}),
-                    ...(spec.inputs.schema !== undefined ? { schemaDocument: spec.inputs.schema } : {}),
-                };
-                // The definition's model declares `source: true`: the platform mints a
-                // stable storage slot per instance; omit it and the node validates then
-                // faults. Deterministic, like every other minted identity here.
-                node.inputs.source = stableId(`${built.id}:${id}:source`);
-                // IxP instances must NOT carry the manifest's model block — the slim
-                // { type, serviceType } lives only in definitions[] (product validate
-                // rejects a node-level copy).
-                delete node.model;
-            }
-            scope.nodes.push(node);
-            for (const t of tails)
-                addEdge(scope, t, id);
-            return [{ node: id, port: successPort(type) }];
-        }
-        if (spec.kind === 'dataFabricRead' || spec.kind === 'dataFabricCreate'
-            || spec.kind === 'dataFabricUpdate' || spec.kind === 'dataFabricDelete') {
-            const type = NODE_TYPE[spec.kind];
-            const id = stepUid(scope, step.name);
-            const node = makeNode(type, id, step.name, {
-                parentId,
-                requestedVersion: spec.kind === 'dataFabricRead'
-                    ? dataFabricReadVersion(spec.inputs, step.options?.version)
-                    : step.options?.version,
-            });
-            const cfg = { entityName: spec.inputs.entity };
-            // `recordSource` is how update and delete both name their target; the
-            // read step's emitted node id is rename-aware, for subflow copies.
-            const targetRecord = (record) => {
-                if (typeof record.fromRead === 'string') {
-                    cfg.recordSource = 'fromRead';
-                    cfg.readEntityNodeId = scope.stepNodeId.get(record.fromRead) ?? record.fromRead;
-                }
-                else {
-                    cfg.recordSource = 'byId';
-                    cfg.recordId = String(renderValue(record.byId, scope.rename));
-                }
-            };
-            const fieldRows = (values) => Object.entries(values ?? {}).map(([field, value]) => ({
-                field,
-                value: String(renderValue(value, scope.rename)),
-            }));
-            if (spec.kind === 'dataFabricRead') {
-                // Only 1.4 declares it, and only 1.4 is emitted when it is set (see
-                // dataFabricReadVersion) — so writing it can never land on a 1.0 node,
-                // where it would be an input the definition does not know.
-                if (spec.inputs.resultMode !== undefined)
-                    cfg.resultMode = spec.inputs.resultMode;
-                if (spec.inputs.limit !== undefined)
-                    cfg._recordLimit = spec.inputs.limit;
-                if (spec.inputs.skip !== undefined)
-                    cfg._skip = spec.inputs.skip;
-                if (spec.inputs.sort !== undefined) {
-                    cfg._sort = { field: spec.inputs.sort.field, direction: spec.inputs.sort.direction ?? 'asc' };
-                }
-                if (spec.inputs.fields?.length)
-                    cfg._selectedFieldNames = [...spec.inputs.fields];
-                if (spec.inputs.filters?.length) {
-                    cfg._filters = dataFabricFilterRows(spec.inputs.filters, (value) => String(renderValue(value, scope.rename)));
-                }
-            }
-            else if (spec.kind === 'dataFabricCreate') {
-                cfg.fieldValues = fieldRows(spec.inputs.values);
-            }
-            else if (spec.kind === 'dataFabricUpdate') {
-                targetRecord(spec.inputs.record);
-                cfg.fieldUpdates = fieldRows(spec.inputs.set);
-            }
-            else {
-                targetRecord(spec.inputs.record);
-            }
-            if (spec.inputs.folderKey !== undefined)
-                cfg._folderKey = spec.inputs.folderKey;
-            // A folder-scoped entity is portable only with its `Entity` bindings; the
-            // half-authored form is refused by check(), so reaching here with both
-            // means emit both. Same id for the same (entity, resourceKey), so two
-            // steps on one entity share one pair rather than duplicating it.
-            if (spec.inputs.folderKey !== undefined && spec.inputs.resourceKey !== undefined) {
-                cfg._resourceKey = spec.inputs.resourceKey;
-                for (const entry of entityBindings(spec.inputs.entity, spec.inputs.folderKey, spec.inputs.resourceKey)) {
-                    resourceBindings.set(entry.id, entry);
-                }
-            }
-            node.inputs = { entityConfig: cfg };
-            scope.nodes.push(node);
-            for (const t of tails)
-                addEdge(scope, t, id);
-            return [{ node: id, port: successPort(type) }];
-        }
         // A custom FlowAction subclass carries no `kind`; it compiles through its
         // own contribution (design §4). Anything else without a recognized kind is
         // an authoring error — it must NOT fall through into the script branch
@@ -6469,7 +6284,7 @@ export function serialize(built, opts = {}) {
             }
             throw new Error(`step "${step.name}": not an action spec — pass a factory result, subflow(), or a FlowAction subclass instance.`);
         }
-        if (!['http', 'transform', 'delay', 'script'].includes(spec.kind)) {
+        if (spec.kind !== 'http') {
             throw new Error(`step "${step.name}": unknown action kind "${spec.kind}".`);
         }
         const type = bundledActionNodeType(spec);
@@ -6482,6 +6297,7 @@ export function serialize(built, opts = {}) {
         const envelope = ownEntry(ERROR_ENVELOPE_VAR, type);
         if (envelope)
             scope.rename.errorEnvelopes.set(step.name, envelope);
+        // The guard above leaves http; registered kinds returned at the top.
         node.inputs = actionInputs(spec, scope.rename, opts, step.name);
         if (spec.kind === 'http') {
             node.outputs = httpOutputs(node.outputs, spec.inputs.returns, spec.inputs.managed);
@@ -6501,12 +6317,6 @@ export function serialize(built, opts = {}) {
                     resourceBindings.set(entry.id, entry);
             }
         }
-        if (spec.kind === 'script') {
-            node.outputs = scriptOutputs(node.outputs, spec.inputs.returns, spec.inputs.code);
-        }
-        if (spec.kind === 'transform') {
-            node.outputs = transformOutputs(node.outputs);
-        }
         scope.nodes.push(node);
         for (const t of tails)
             addEdge(scope, t, id);
@@ -6572,8 +6382,13 @@ export function serialize(built, opts = {}) {
      * from a non-default port is a side exit. Only the seed differs from an ordinary
      * list — the same node, a different port.
      */
-    function emitPortList(step, source, tails, scope, parentId, breakTarget) {
+    function emitPortList(step, source, tails, scope, parentId, loopExits) {
         const handler = step.body;
+        // A node whose exits are all templated hands on no tail; its port lists
+        // leave from the node itself.
+        const router = tails.length === 0 ? routerNodes.get(source) : undefined;
+        if (router !== undefined)
+            tails = [{ node: router, port: step.port }];
         // `emitAction` returns one tail for every action kind — the node's own
         // success port — except a fan-out human task, which returns one per outcome
         // from the SAME node. Tails from two nodes mean a new action shape reached
@@ -6592,7 +6407,7 @@ export function serialize(built, opts = {}) {
             refuseErrorEdgeWithoutPort(nodeId, source);
             node.inputs = { ...(node.inputs ?? {}), errorHandlingEnabled: true };
         }
-        const handlerTails = emit(handler, [{ node: nodeId, port: step.port }], scope, parentId, breakTarget);
+        const handlerTails = emit(handler, [{ node: nodeId, port: step.port }], scope, parentId, loopExits);
         // A body that runs out of steps ends the run on an End of its own (no
         // merge-back is inferred). That End maps the outputs like any other, so a
         // body that set them with `{ updates }` still answers (#742).
@@ -6600,13 +6415,13 @@ export function serialize(built, opts = {}) {
             const endId = uid(scope, `${source}${step.port === 'error' ? 'Error' : step.port.charAt(0).toUpperCase() + step.port.slice(1)}End`);
             emitEnd(scope, endId, handlerTails, { parentId });
         }
-        return tails;
+        return router !== undefined ? [] : tails;
     }
     function emit(steps, incoming, scope, parentId, 
-    // The enclosing container's break handle, when inside a loop/do-while body.
-    // Branch/switch/parallel arms and error handlers INHERIT it; a nested
-    // container replaces it for its own body.
-    breakTarget) {
+    // The enclosing container's break and continue handles, when inside a
+    // loop/do-while body. Branch/switch/parallel arms and error handlers INHERIT
+    // them; a nested container replaces them for its own body.
+    loopExits) {
         let tails = incoming;
         // The action a port-scoped edge leaves. `.stepToList('error', …)` and
         // `.stepToRef('error', …)` are list MEMBERS that follow the step they attach
@@ -6650,6 +6465,14 @@ export function serialize(built, opts = {}) {
             node.display = { ...(node.display ?? {}), label };
         };
         for (const [stepIndex, step] of steps.entries()) {
+            // After a node whose exits are all templated, only its port lists may
+            // follow: nothing continues from it, so a step here would hang off no edge.
+            const router = lastAction !== undefined && tails.length === 0 ? routerNodes.get(lastAction) : undefined;
+            if (router !== undefined && step.kind !== 'stepToList' && step.kind !== 'stepToRef') {
+                throw new Error(`step "${lastAction}": its definition declares only templated exits (such as case-{item.id}), so no `
+                    + `path continues from it and ${'name' in step ? `"${step.name}"` : `.${step.kind}()`} after it would `
+                    + `have no incoming edge. Route each exit with .stepToList('<port>', …), e.g. .stepToList('case-<id>', …).`);
+            }
             if (step.kind === 'action') {
                 tails = emitAction(step, tails, scope, parentId);
                 applyUpdates(step);
@@ -6678,7 +6501,7 @@ export function serialize(built, opts = {}) {
                 }
             }
             else if (step.kind === 'stepToList') {
-                tails = emitPortList(step, lastAction ?? '?', tails, scope, parentId, breakTarget);
+                tails = emitPortList(step, lastAction ?? '?', tails, scope, parentId, loopExits);
             }
             else if (step.kind === 'stepSwitch') {
                 // The action, then EVERY exit it declares as an arm — no tacit tail.
@@ -6723,7 +6546,7 @@ export function serialize(built, opts = {}) {
                     // from all of them. (`.stepToList` instead gives an arm that runs out
                     // of steps an End of its own; `emitEnd` maps the outputs on it,
                     // flow-builder-sdk#742.)
-                    const caseTails = emit(c.body, [{ node: nodeId, port: exit.port }], scope, parentId, breakTarget);
+                    const caseTails = emit(c.body, [{ node: nodeId, port: exit.port }], scope, parentId, loopExits);
                     if (caseTails.length === 0 && stopsAtEnd(c.body))
                         stopped.push(String(c.value));
                     armTails.push(...(hitlNodes.has(nodeId)
@@ -6768,8 +6591,8 @@ export function serialize(built, opts = {}) {
                 scope.nodes.push(node);
                 for (const t of tails)
                     addEdge(scope, t, id);
-                const thenTails = emit(step.then, [{ node: id, port: 'true' }], scope, parentId, breakTarget);
-                const elseTails = emit(step.otherwise, [{ node: id, port: 'false' }], scope, parentId, breakTarget);
+                const thenTails = emit(step.then, [{ node: id, port: 'true' }], scope, parentId, loopExits);
+                const elseTails = emit(step.otherwise, [{ node: id, port: 'false' }], scope, parentId, loopExits);
                 tails = [...thenTails, ...elseTails];
             }
             else if (step.kind === 'switch') {
@@ -6784,8 +6607,11 @@ export function serialize(built, opts = {}) {
                 // the runtime — so no `=js:` prefix, same as a decision's `expression`.
                 const id = stepUid(scope, step.name);
                 const node = makeNode(NODE_TYPE.switch, id, step.options?.label ?? step.label ?? step.name, { parentId, requestedVersion: step.options?.version });
+                // `id` is the author's when given (a decompiled switch keeps the
+                // canvas's `default-1`, …: merge keeps the original node, so the edges
+                // must leave from ITS handles), else positional (#1130).
                 const cases = step.cases.map((c, i) => ({
-                    id: `case_${i + 1}`,
+                    id: c.id ?? `case_${i + 1}`,
                     label: c.label ?? `Case ${caseLiteral(c.value)}`,
                     expression: `${renameRefs(step.on.js, scope.rename)} === ${caseLiteral(c.value)}`,
                 }));
@@ -6798,9 +6624,9 @@ export function serialize(built, opts = {}) {
                 // merge node; the convergence point is found by graph search).
                 const armTails = [];
                 for (const [i, c] of step.cases.entries())
-                    armTails.push(...emit(c.body, [{ node: id, port: `case-${cases[i].id}` }], scope, parentId, breakTarget));
+                    armTails.push(...emit(c.body, [{ node: id, port: `case-${cases[i].id}` }], scope, parentId, loopExits));
                 if (step.default !== undefined)
-                    armTails.push(...emit(step.default, [{ node: id, port: 'default' }], scope, parentId));
+                    armTails.push(...emit(step.default, [{ node: id, port: 'default' }], scope, parentId, loopExits));
                 tails = armTails;
             }
             else if (step.kind === 'parallel') {
@@ -6833,7 +6659,7 @@ export function serialize(built, opts = {}) {
                 const armTails = [];
                 const endsBefore = hitlEndExits.length;
                 for (const arm of step.arms) {
-                    const t = emit(arm, tails, scope, parentId, breakTarget);
+                    const t = emit(arm, tails, scope, parentId, loopExits);
                     // An arm hands the join ONE edge, or several that are alternatives —
                     // `.branch` / `.switch` / `.stepSwitch` arms, a fan-out task's
                     // outcomes — of which only one fires. Refused when any of them is a
@@ -6918,7 +6744,7 @@ export function serialize(built, opts = {}) {
                     addEdge(scope, t, id);
                 const bodyPort = v24 ? 'start' : 'output';
                 const backPort = v24 ? 'continue' : 'loopBack';
-                const bodyTails = emit(step.body, [{ node: id, port: bodyPort }], scope, id, v24 ? { node: id, port: 'break' } : undefined);
+                const bodyTails = emit(step.body, [{ node: id, port: bodyPort }], scope, id, v24 ? { node: id, break: 'break', continue: backPort } : { node: id, continue: backPort });
                 for (const bt of bodyTails)
                     addEdge(scope, bt, id, backPort);
                 applyUpdates(step);
@@ -6937,18 +6763,29 @@ export function serialize(built, opts = {}) {
                 scope.nodes.push(node);
                 for (const t of tails)
                     addEdge(scope, t, id);
-                const bodyTails = emit(step.body, [{ node: id, port: 'start' }], scope, id, { node: id, port: 'break' });
+                const bodyTails = emit(step.body, [{ node: id, port: 'start' }], scope, id, { node: id, break: 'break', continue: 'continue' });
                 for (const bt of bodyTails)
                     addEdge(scope, bt, id, 'continue');
                 applyUpdates(step);
                 tails = [{ node: id, port: 'success' }];
             }
             else if (step.kind === 'break') {
-                if (!breakTarget) {
+                if (!loopExits?.break) {
                     throw new Error('.break() has no enclosing .loop()/.doWhile() body to exit — it is only valid inside a container.');
                 }
                 for (const t of tails)
-                    addEdge(scope, t, breakTarget.node, breakTarget.port);
+                    addEdge(scope, t, loopExits.node, loopExits.break);
+                tails = [];
+            }
+            else if (step.kind === 'continue') {
+                // The same edge a body's last step gets, from wherever this path has got
+                // to — so a handler or an arm can go on to the next iteration instead of
+                // ending the run on an End of its own (#1129).
+                if (!loopExits) {
+                    throw new Error('.continue() has no enclosing .loop()/.doWhile() body to go back to — it is only valid inside a container.');
+                }
+                for (const t of tails)
+                    addEdge(scope, t, loopExits.node, loopExits.continue);
                 tails = [];
             }
             else if (step.kind === 'terminate') {
@@ -6986,7 +6823,8 @@ export function serialize(built, opts = {}) {
                 else {
                     // Any other port is a SIDE EXIT from the step just emitted. The main
                     // path is untouched, so `tails` survives and chaining continues.
-                    const from = tails[0];
+                    const router = tails.length === 0 && lastAction !== undefined ? routerNodes.get(lastAction) : undefined;
+                    const from = tails[0] ?? (router !== undefined ? { node: router, port: step.port } : undefined);
                     if (!from)
                         throw new Error(`.stepToRef('${step.port}', '${step.target}') has no step to leave from.`);
                     refuseRewire('.stepToRef', step.port, lastAction ?? '?', tails);
@@ -7364,88 +7202,7 @@ export function assertBindingPlaceholdersResolve(flow) {
         + `"invalid GUID <bindings.…>") and refuses to publish. This is a serializer defect, not an authoring `
         + `error; report it with the flow source.`);
 }
-/**
- * Emit a transform's `inputs` in the canonical shape the node's runtime reads:
- * `collection` as a BARE variable path (not `=js:`-prefixed — it is a path
- * field, and the runtime turns the string into a lookup), and `operations` as
- * the array of `{ id, type, config }` descriptors the designer writes.
- *
- * Ids are synthesized here rather than asked of the author, the same way switch
- * case ids are: they identify a row in the designer's editor and carry no
- * meaning for the author. Defaults are made explicit for the same reason the
- * HTTP case spells out `method`/`contentType` — the emitted file should say
- * what it does rather than rely on the runtime's fallbacks.
- */
-function transformInputs(inputs, rename = NO_RENAME) {
-    const operations = (inputs.operations ?? []).map((op, i) => {
-        const id = `op${i + 1}`;
-        if (op.type === 'filter') {
-            return {
-                id,
-                type: 'filter',
-                config: {
-                    operation: op.operation ?? 'and',
-                    filters: (op.filters ?? []).map((f, j) => ({
-                        id: `f${j + 1}`,
-                        field: f.field,
-                        condition: f.condition,
-                        // Value-free conditions (is_null, is_empty, …) legitimately omit it.
-                        ...(f.value !== undefined ? { value: f.value } : {}),
-                    })),
-                },
-            };
-        }
-        if (op.type === 'map') {
-            return {
-                id,
-                type: 'map',
-                config: {
-                    keepOriginalFields: op.keepOriginalFields ?? false,
-                    mappings: (op.mappings ?? []).map((m, j) => ({
-                        id: `m${j + 1}`,
-                        field: m.field,
-                        transformation: m.transformation ?? 'copy',
-                        // '' is the runtime's "keep the original name" sentinel.
-                        renameTo: m.renameTo ?? '',
-                    })),
-                },
-            };
-        }
-        return {
-            id,
-            type: 'groupBy',
-            config: {
-                groupByField: op.groupByField,
-                aggregations: (op.aggregations ?? []).map((a, j) => ({
-                    id: `a${j + 1}`,
-                    // `count` needs no field; the runtime expects the key present anyway.
-                    field: a.field ?? '',
-                    operation: a.operation,
-                    alias: a.alias,
-                })),
-            },
-        };
-    });
-    return { collection: renameRefs(collectionPath(inputs.collection), rename), operations };
-}
-/**
- * The `collection` string. A bare reference (`v('x')` / `out('s','p')`) is
- * already the path the runtime wants, so it is emitted verbatim. Anything else
- * cannot be expressed as a path — `check` rejects it (TRANSFORM_COLLECTION_*)
- * before serialization, so reaching here with one means `compile` was called
- * without a check; emit the raw text so the failure stays visible downstream
- * rather than becoming a silently empty collection.
- */
-function collectionPath(collection) {
-    if (collection instanceof Expr)
-        return collection.literal ? JSON.stringify(collection.value) : collection.js;
-    return String(collection);
-}
 function actionInputs(spec, rename = NO_RENAME, opts = {}, stepName = '') {
-    if (spec.kind === 'transform')
-        return transformInputs(spec.inputs, rename);
-    if (spec.kind === 'delay')
-        return delayInputs(spec.inputs);
     if (spec.kind === 'http') {
         const i = spec.inputs;
         if (i.managed)
@@ -7468,10 +7225,7 @@ function actionInputs(spec, rename = NO_RENAME, opts = {}, stepName = '') {
             ...httpBranchRows(i, rename),
         };
     }
-    // A script BODY is a plain string, not an Expr, and it reads step outputs the
-    // same way everything else does — so it needs the rename too, or a reused
-    // child's script would read the first copy's node.
-    return { script: renameRefs(spec.inputs.code, rename) };
+    throw new Error(`internal SDK error: no inputs for action kind "${spec.kind}".`);
 }
 /**
  * `timeout` / `retryCount` — the two request settings BOTH http node types carry.
@@ -7653,60 +7407,3 @@ function httpOutputs(base, returns, managed) {
     };
     return out;
 }
-/**
- * A transform node publishes a COLLECTION — always.
- *
- * All four transform definitions declare `output: {type: 'object', description:
- * 'The transformed data result'}`, which makes the designer type
- * `out('<step>')` as `Record<string, any>` and reject mapping it into an
- * `array` flow output — the same defect as the script node's, one node type
- * over, and it hits five of the shipped examples.
- *
- * Unlike a script this needs no inference and no author declaration, because it
- * is not a property of the particular node: `filter` and `map` are array→array,
- * and `group-by` is too — the engine's own implementation says so in as many
- * words (`transform-operations.ts`: "Always return an array", returning
- * `Array.from(groups.entries()).map(…)` rather than an object keyed by group).
- * So the type is knowable from the node TYPE alone, and is simply written down.
- */
-function transformOutputs(base) {
-    // An unrecognized `variant` resolves to no definition at all, so there are no
-    // outputs to refine — and `jsonClone(undefined)` throws ("undefined" is not valid
-    // JSON) rather than passing the node through.
-    if (!base || typeof base !== 'object')
-        return base;
-    const out = jsonClone(base);
-    if (out.output)
-        out.output.type = 'array';
-    return out;
-}
-/**
- * Declare what a `core.action.script` node actually publishes.
- *
- * Same instance-vs-definition split as `httpOutputs` above, for the same reason
- * one level over: the platform's definition says `output: {type: 'object'}`
- * because a node TYPE cannot know what a particular body returns, so the
- * designer types every script read as `Record<string, any>` and rejects mapping
- * one into a `string` flow output — on a flow that runs. What the body returns
- * is knowable here, at author time, and this is where it gets written down.
- *
- * `returns` wins; otherwise the body is read (see `inferScriptShape`, which
- * answers only when every `return` agrees). When neither says anything the
- * definition's open object stands, byte-identical to what this emitted before.
- */
-function scriptOutputs(base, returns, code) {
-    const shape = returns !== undefined ? declaredScriptShape(returns) : inferScriptShape(code);
-    // Nothing knowable, or knowably the open object the definition already
-    // declares — leave the node exactly as it was.
-    if (!shape || (shape.type === 'object' && !shape.properties))
-        return base;
-    if (!base || typeof base !== 'object')
-        return base;
-    const out = jsonClone(base);
-    if (!out.output)
-        return out;
-    out.output.type = shape.type;
-    if (shape.properties)
-        out.output.properties = shape.properties;
-    return out;
-}