@uipath/maestro-builder-sdk 6.18.9 → 6.19.0

package/dist/serialize.js

@@ -10,12 +10,15 @@ 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 } 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 { 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';
@@ -45,7 +48,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';
@@ -58,7 +60,7 @@ 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 +93,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 +103,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',
@@ -3048,32 +3040,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 +3081,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 +3125,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' },
@@ -3936,22 +3779,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':
@@ -4021,6 +3854,25 @@ export function resolveContributionDefinition(ref, requestedVersion, where) {
  * 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);
+    });
+}
 function contributionPort(def) {
     const handles = (def?.handleConfiguration ?? []).flatMap((g) => g?.handles ?? []);
     const sources = handles.filter((h) => h?.type === 'source' && h?.id !== 'error');
@@ -4726,12 +4578,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)) {
@@ -4914,14 +4775,11 @@ export function serialize(built, opts = {}) {
             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 +4982,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 +5014,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 +5040,112 @@ 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) }];
+        return [{ node: id, port: contribution.port ?? contributionPort(def) }];
+    }
+    /**
+     * 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
@@ -6310,154 +6250,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 +6261,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 +6274,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 +6294,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);
@@ -7364,88 +7151,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 +7174,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 +7356,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;
-}