@uipath/maestro-builder-sdk 6.40.1 → 6.41.0

package/dist/serialize.js

@@ -62,8 +62,8 @@ import { outputBackingGlobal, planOutputBacking } from './flow-output-backing.js
 import { mapJsCode } from './core/js-code-spans.js';
 import { contributionPort } from './core/definition-handles.js';
 import { prepareCommand } from './core/cli-spelling.js';
-import { AGENTIC_PROCESS_FORMS } from './core/agentic-process-forms.js';
 import { resourceNodeSortOrder } from './core/process-resource-sort-order.js';
+import { processResourceBindings, processResourceLocation } from './core/process-resource.js';
 import { types } from './core/expr.js';
 import { SUBFLOW_START_LABEL } from './core/subflow-start.js';
 import { ownEntry } from './core/own-entry.js';
@@ -126,491 +126,6 @@ const SUBFLOW_OUTPUT = {
     source: '=result.response',
     var: 'output',
 };
-/** The RPA-workflow node type family. The process's release key is the suffix. */
-const RPA_WORKFLOW_PREFIX = 'uipath.core.rpa-workflow.';
-/**
- * Where a process resource lives, as ONE slot every process-resource definition
- * shares. In the platform model "in this solution" is orthogonal to the
- * resource type: flow-core's single `createModel` (`@uipath/flow-core`
- * `manifest/mappers/node-manifest-builder.ts`, what `uip maestro flow registry
- * get --local` and Studio Web both run) adds `projectId`, `projectName` and
- * `isInSolution: true` to the model of ANY process resource built from a sibling
- * project.
- *
- * The in-solution shape, transcribed from `registry get --local` for a sibling
- * Flow (2026-10-08) and from uipath-cli's `buildInSolutionNodeManifests`:
- *  - `resourceKey` is the bare key (the sibling's `resource.key`), not
- *    `<folderPath>.<name>`; the folder default is `''`;
- *  - no `section: 'Published'`;
- *  - `projectId` on the definition AND on the model, with `projectName` and
- *    `isInSolution: true` (the marker the canvas reads);
- *  - description `(In-solution) <name>`, tags `in-solution` / `local`, and the
- *    `open-workflow` toolbar action.
- */
-function processResourceLocation(spec) {
-    if (spec.location === 'in-solution') {
-        return {
-            inSolution: true,
-            folderPath: '',
-            resourceKey: spec.key,
-            description: `(In-solution) ${spec.name}`,
-            tags: ['in-solution', 'local'],
-            definitionExtras: {
-                toolbarExtensions: {
-                    design: { actions: [{ id: 'open-workflow', icon: 'external-link', label: 'Open' }] },
-                },
-                projectId: spec.projectId,
-            },
-            modelExtras: { projectId: spec.projectId, projectName: spec.name, isInSolution: true },
-        };
-    }
-    const folderPath = spec.folderPath ?? '';
-    return {
-        inSolution: false,
-        folderPath,
-        resourceKey: `${folderPath}.${spec.name}`,
-        description: `(${folderPath})`,
-        tags: [],
-        definitionExtras: {},
-        modelExtras: {},
-    };
-}
-/**
- * Build the definition for one deployed RPA process.
- *
- * This definition CANNOT be bundled, and that is not an oversight: the node type
- * carries the process's release key, and the contract (which arguments it takes,
- * what it returns) belongs to whatever someone published on a tenant. The
- * platform's own answer is per-tenant too — `uip maestro flow registry get
- * uipath.core.rpa-workflow.<key>` synthesizes it from the deployed process.
- *
- * So the static parts below are transcribed from the deployed corpus rather than
- * invented: 45 `uipath.core.rpa-workflow.*` instances across 47 `.flow`
- * artifacts of `skill-flow-rpa` (2026-05-18 → 07-24), cross-checked against
- * `registry get` for the same process. Every constant here is one those agree
- * on — `category: 'rpa-workflow'`, `sortOrder: 530`, `supportsErrorHandling`,
- * `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:
- *
- *  - `inputDefinition` declares exactly the arguments the author passes, typed
- *    from the values passed. That is the PR-10 payload-schema pattern — declare
- *    what is evidenced — but here the evidence is the authored call, not the
- *    deployed process, so it cannot catch an argument the process does not have.
- *    Nothing local can: only the robot knows. A wrong argument name faults the
- *    job on a live run, which is what the `robot` rung is for.
- *  - `outputDefinition.output` carries no schema for the same reason. Its source
- *    expressions follow the tenant-current registry (`=this` / `=Error`). Older
- *    corpus artifacts mostly used `=result.response` / `=result.Error`, but a
- *    2026-08-04 product debug proved that old spelling now completes the RPA
- *    element while publishing a null step output.
- */
-function rpaWorkflowDef(spec) {
-    const loc = processResourceLocation(spec);
-    const { resourceKey } = loc;
-    const properties = {};
-    for (const [k, v] of Object.entries(spec.inputs)) {
-        properties[k] = { type: typeof v === 'number' ? 'number' : typeof v === 'boolean' ? 'boolean' : 'string' };
-    }
-    return {
-        nodeType: `${RPA_WORKFLOW_PREFIX}${spec.key}`,
-        version: '1.0.0',
-        category: 'rpa-workflow',
-        runtimeConstraints: { exclude: ['api-function'] },
-        description: loc.description,
-        tags: loc.tags,
-        sortOrder: resourceNodeSortOrder('rpa-workflow'),
-        supportsErrorHandling: true,
-        display: { label: spec.name, icon: 'rpa' },
-        handleConfiguration: [
-            { position: 'left', handles: [{ id: 'input', type: 'target', handleType: 'input' }] },
-            { position: 'right', handles: [{ id: 'output', type: 'source', handleType: 'output' }] },
-        ],
-        ...loc.definitionExtras,
-        model: {
-            type: 'bpmn:ServiceTask',
-            serviceType: 'Orchestrator.StartJob',
-            version: 'v2',
-            ...(loc.inSolution ? {} : { section: 'Published' }),
-            bindings: {
-                resource: 'process',
-                resourceSubType: 'Process',
-                resourceKey,
-                orchestratorType: 'process',
-                values: [
-                    { name: 'name', propertyAttribute: 'name', default: spec.name },
-                    { name: 'folderPath', propertyAttribute: 'folderPath', default: loc.folderPath },
-                ],
-            },
-            ...loc.modelExtras,
-            context: [
-                { name: 'name', type: 'string', value: '<bindings.name>' },
-                { name: 'folderPath', type: 'string', value: '<bindings.folderPath>' },
-                { name: '_label', type: 'string', value: spec.name },
-            ],
-        },
-        inputDefinition: Object.keys(properties).length ? { type: 'object', properties } : {},
-        inputDefaults: {},
-        outputDefinition: {
-            output: {
-                type: 'object',
-                description: 'The return value of the RPA process',
-                source: '=this',
-                var: 'output',
-                // The process's output arguments, as the author declared them. The
-                // platform's own definition carries this when it can read the deployed
-                // process (`registry get` returns exactly this shape); offline the author
-                // is the only source, and without it a downstream read is unresolvable ("reads
-                // from an undefined object") — rightly, since nothing could tell a real
-                // field from a typo.
-                ...(spec.returns && Object.keys(spec.returns).length
-                    ? {
-                        schema: {
-                            type: 'object',
-                            properties: Object.fromEntries(Object.entries(spec.returns).map(([k, t]) => [k, { type: t }])),
-                        },
-                    }
-                    : {}),
-            },
-            error: {
-                type: 'object',
-                description: 'Error information if the RPA process fails',
-                source: '=Error',
-                var: 'error',
-            },
-        },
-        debug: { runtime: 'bpmnEngine' },
-    };
-}
-/** The API-workflow node type family. The published workflow's key is the suffix. */
-const API_WORKFLOW_PREFIX = 'uipath.core.api-workflow.';
-/**
- * Build the definition for one deployed API workflow.
- *
- * Like rpa's, this definition CANNOT be bundled: the node type carries the
- * workflow's key and the platform synthesizes the contract from whatever someone
- * published on a tenant (`uip maestro flow registry get
- * uipath.core.api-workflow.<key>` answers per-tenant). Unlike rpa's, the
- * platform's copy declares a real OUTPUT SCHEMA as well as an input one — for
- * `Shared.NameToAgeFixed` it is `{EstimatedAge: integer}` — which is still not
- * knowable offline, so `returns` is what supplies it.
- *
- * The constants are transcribed from what the deployed corpus and the registry
- * 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` (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:
- * 'Api'`, `orchestratorType: 'api'`, `debug.runtime: 'bpmnEngine'`, and the
- * `<bindings.name>` / `<bindings.folderPath>` context placeholders.
- *
- * `version` is `1.0.0` in 42 of 42 and the registry agrees: one version, no
- * migrations, so unlike queue's there is no era to be a version behind on. What
- * there IS an era on is the tenant RESOURCE — the corpus splits 31/4 between two
- * different workflows with two different output field names (`estimatedAge` vs
- * `EstimatedAge`) — which is why the author passes the three identifiers rather than
- * anything here defaulting them.
- *
- * (This comment used to say those 31 "name a workflow that no longer exists". That
- * was backwards: re-dated 2026-07-29 with `--all-folders --limit 300`, 36 of the 42
- * still resolve, the 31 among them, and the 6 that do not are early shapes with a
- * blank or stale folder. The claim rested on the 50-row truncation PR 14 found. See
- * `typescript/tests/api-workflow.test.ts`'s header for the recount.)
- *
- * `outputs.output.source` is `=this`, which is what the definition itself
- * declares. The corpus is split (`=result.response` 33/42, `=this` 6/42, and two
- * passing runs a day apart disagree), so the platform accepts either; we emit the
- * one the platform's own definition writes.
- */
-function apiWorkflowDef(spec) {
-    const resourceKey = `${spec.folderPath}.${spec.name}`;
-    const properties = {};
-    for (const [k, v] of Object.entries(spec.inputs)) {
-        properties[k] = { type: typeof v === 'number' ? 'number' : typeof v === 'boolean' ? 'boolean' : 'string' };
-    }
-    return {
-        nodeType: `${API_WORKFLOW_PREFIX}${spec.key}`,
-        version: '1.0.0',
-        category: 'api-workflow',
-        runtimeConstraints: { exclude: ['api-function'] },
-        description: `(${spec.folderPath})`,
-        tags: [],
-        sortOrder: resourceNodeSortOrder('api-workflow'),
-        supportsErrorHandling: true,
-        display: { label: spec.name, icon: 'api' },
-        handleConfiguration: [
-            { position: 'left', handles: [{ id: 'input', type: 'target', handleType: 'input' }] },
-            { position: 'right', handles: [{ id: 'output', type: 'source', handleType: 'output' }] },
-        ],
-        model: {
-            type: 'bpmn:ServiceTask',
-            serviceType: 'Orchestrator.ExecuteApiWorkflowAsync',
-            version: 'v2',
-            section: 'Published',
-            bindings: {
-                resource: 'process',
-                resourceSubType: 'Api',
-                resourceKey,
-                orchestratorType: 'api',
-                values: [
-                    { name: 'name', propertyAttribute: 'name', default: spec.name },
-                    { name: 'folderPath', propertyAttribute: 'folderPath', default: spec.folderPath },
-                ],
-            },
-            context: [
-                { name: 'name', type: 'string', value: '<bindings.name>' },
-                { name: 'folderPath', type: 'string', value: '<bindings.folderPath>' },
-                { name: '_label', type: 'string', value: spec.name },
-            ],
-        },
-        inputDefinition: Object.keys(properties).length ? { type: 'object', properties } : {},
-        inputDefaults: {},
-        outputDefinition: {
-            output: {
-                type: 'object',
-                source: '=this',
-                var: 'output',
-                // The workflow's output arguments, as the author declared them — the same
-                // shape `registry get` returns when it can reach the deployed workflow.
-                // Without it a downstream read is unresolvable, rightly: nothing offline could
-                // tell a real field from a typo.
-                ...(spec.returns && Object.keys(spec.returns).length
-                    ? {
-                        schema: {
-                            type: 'object',
-                            properties: Object.fromEntries(Object.entries(spec.returns).map(([k, t]) => [k, { type: t }])),
-                        },
-                    }
-                    : {}),
-            },
-            error: {
-                type: 'object',
-                description: 'Error information if the node fails',
-                source: '=Error',
-                var: 'error',
-            },
-        },
-        debug: { runtime: 'bpmnEngine' },
-    };
-}
-/** The agentic-process node type family. The published process's key is the suffix. */
-const FUNCTION_PREFIX = 'uipath.core.function.';
-/**
- * The definition for one published Orchestrator FUNCTION, transcribed from the
- * platform's own synthesized manifest (`uip maestro flow registry get
- * uipath.core.function.<key>`, read 2026-08-19): the api-workflow shape with
- * this family's service type (`Orchestrator.ExecuteFunctionAsync`), binding
- * subtype (`Function`), `orchestratorType: 'function'`, and its own
- * `listingVersion` — plus the `error` source handle the registry declares
- * alongside `output` (gated on `errorHandlingEnabled`, as everywhere else).
- */
-function publishedFunctionDef(spec) {
-    const resourceKey = `${spec.folderPath}.${spec.name}`;
-    const properties = {};
-    for (const [k, v] of Object.entries(spec.inputs)) {
-        properties[k] = { type: typeof v === 'number' ? 'number' : typeof v === 'boolean' ? 'boolean' : 'string' };
-    }
-    return {
-        nodeType: `${FUNCTION_PREFIX}${spec.key}`,
-        version: '1.0.0',
-        category: 'function',
-        description: `(${spec.folderPath})`,
-        tags: [],
-        sortOrder: resourceNodeSortOrder('function'),
-        supportsErrorHandling: true,
-        display: { label: spec.name, icon: 'function' },
-        handleConfiguration: [
-            { position: 'left', handles: [{ id: 'input', type: 'target', handleType: 'input' }] },
-            {
-                position: 'right',
-                handles: [
-                    { id: 'output', type: 'source', handleType: 'output' },
-                    {
-                        id: 'error', label: 'Error', type: 'source', handleType: 'output',
-                        visible: '{inputs.errorHandlingEnabled}',
-                        constraints: { maxConnections: 1 },
-                    },
-                ],
-            },
-        ],
-        model: {
-            type: 'bpmn:ServiceTask',
-            serviceType: 'Orchestrator.ExecuteFunctionAsync',
-            version: 'v2',
-            section: 'Published',
-            listingVersion: '1.0.0',
-            bindings: {
-                resource: 'process',
-                resourceSubType: 'Function',
-                resourceKey,
-                orchestratorType: 'function',
-                values: [
-                    { name: 'name', propertyAttribute: 'name', default: spec.name },
-                    { name: 'folderPath', propertyAttribute: 'folderPath', default: spec.folderPath },
-                ],
-            },
-            context: [
-                { name: 'name', type: 'string', value: '<bindings.name>' },
-                { name: 'folderPath', type: 'string', value: '<bindings.folderPath>' },
-                { name: '_label', type: 'string', value: spec.name },
-            ],
-        },
-        inputDefinition: Object.keys(properties).length ? { type: 'object', properties } : {},
-        inputDefaults: {},
-        outputDefinition: {
-            output: {
-                type: 'object',
-                source: '=this',
-                var: 'output',
-                // The function's output arguments as the author declared them — same
-                // rule and same reason as the api-workflow family's.
-                ...(spec.returns && Object.keys(spec.returns).length
-                    ? {
-                        schema: {
-                            type: 'object',
-                            properties: Object.fromEntries(Object.entries(spec.returns).map(([k, t]) => [k, { type: t }])),
-                        },
-                    }
-                    : {}),
-            },
-            error: {
-                type: 'object',
-                description: 'Error information if the node fails',
-                source: '=Error',
-                var: 'error',
-            },
-        },
-        debug: { runtime: 'bpmnEngine' },
-    };
-}
-/**
- * Build the definition for one deployed agentic process (a Maestro process
- * orchestration).
- *
- * Unbundlable for rpa's and api-workflow's reason — the node type carries a
- * tenant's process key and the platform synthesizes the contract from whatever
- * someone published there. So the constants are transcribed from what the
- * platform's own two oracles AGREE on, not invented:
- *
- *  - `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` (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:
- *    'processorchestration'`, `debug.runtime: 'bpmnEngine'`, the
- *    `<bindings.name>` / `<bindings.folderPath>` context placeholders, and
- *    `runtimeConstraints.exclude: ['api-function']`;
- *  - flow-v1's own generator, which is where those come from:
- *    `manifest/mappers/node-manifest-builder.ts::createModel` hard-codes
- *    `bpmn:ServiceTask` for every published-resource node and derives
- *    `orchestratorType` as `resourceType.toLowerCase()`;
- *    `RESOURCE_TYPE_METADATA.ProcessOrchestration` gives the service type.
- *
- * **There is NO deployed corpus for this family** — zero `.flow` artifacts under
- * `runs/` and zero tasks under `uipath-skills/tests/tasks/uipath-maestro-flow/`
- * carry an agentic-process node (checked 2026-07-29). The evidence is the two
- * oracles above plus one live job started from an emitted `.flow`; there is no
- * majority-of-42 to lean on, and `shared/sample-flows/agentic-process.flow` is
- * NOT that corpus: it is an older, fire-and-forget instance whose model type,
- * service type, output sources and `bindings.values` shape all disagree with what
- * `registry get` returns today.
- *
- * `Orchestrator.StartAgenticProcess` is the SYNCHRONOUS spelling — the one that
- * waits and publishes the process's output arguments. The platform's
- * fire-and-forget switch swaps in `…StartAgenticProcessAsync` and then keeps only
- * the `error` output, which is why this surface does not offer it (see
- * `agenticProcess`'s doc comment).
- */
-function agenticProcessDef(spec) {
-    const form = ownEntry(AGENTIC_PROCESS_FORMS, spec.form ?? 'bpmn') ?? AGENTIC_PROCESS_FORMS.bpmn;
-    const loc = processResourceLocation(spec);
-    const { resourceKey } = loc;
-    const properties = {};
-    for (const [k, v] of Object.entries(spec.inputs)) {
-        properties[k] = { type: typeof v === 'number' ? 'number' : typeof v === 'boolean' ? 'boolean' : 'string' };
-    }
-    return {
-        nodeType: `${form.prefix}${spec.key}`,
-        version: '1.0.0',
-        category: form.category,
-        runtimeConstraints: { exclude: ['api-function'] },
-        description: loc.description,
-        tags: loc.tags,
-        sortOrder: resourceNodeSortOrder(form.category),
-        supportsErrorHandling: true,
-        display: { label: spec.name, icon: form.icon },
-        handleConfiguration: [
-            { position: 'left', handles: [{ id: 'input', type: 'target', handleType: 'input' }] },
-            { position: 'right', handles: [{ id: 'output', type: 'source', handleType: 'output' }] },
-        ],
-        ...loc.definitionExtras,
-        model: {
-            type: 'bpmn:ServiceTask',
-            serviceType: form.serviceType,
-            version: 'v2',
-            ...(loc.inSolution ? {} : { section: 'Published' }),
-            bindings: {
-                resource: 'process',
-                resourceSubType: form.resourceSubType,
-                resourceKey,
-                orchestratorType: form.orchestratorType,
-                values: [
-                    { name: 'name', propertyAttribute: 'name', default: spec.name },
-                    { name: 'folderPath', propertyAttribute: 'folderPath', default: loc.folderPath },
-                ],
-            },
-            ...loc.modelExtras,
-            context: [
-                { name: 'name', type: 'string', value: '<bindings.name>' },
-                { name: 'folderPath', type: 'string', value: '<bindings.folderPath>' },
-                { name: '_label', type: 'string', value: spec.name },
-            ],
-        },
-        // The fire-and-forget switch, exactly as flow-v1's withFireAndForgetInput
-        // declares it: a boolean INPUT on the definition (default false). The sync
-        // serviceType stays on the model — the platform's BPMN serializer swaps in
-        // the async sibling when the instance opts in.
-        inputDefinition: { type: 'object', properties: { ...properties, fireAndForget: { type: 'boolean' } } },
-        inputDefaults: { fireAndForget: false },
-        outputDefinition: {
-            output: {
-                type: 'object',
-                source: '=this',
-                var: 'output',
-                // The process's output arguments, as the author declared them — the same
-                // shape `registry get` returns when it can reach the deployed process
-                // (nested under `schema`, which is the spelling gen-tests reads). Without
-                // it a downstream read is unresolvable, rightly: nothing offline could tell a
-                // real field from a typo.
-                ...(spec.returns && Object.keys(spec.returns).length
-                    ? {
-                        schema: {
-                            type: 'object',
-                            properties: Object.fromEntries(Object.entries(spec.returns).map(([k, t]) => [k, { type: t }])),
-                        },
-                    }
-                    : {}),
-            },
-            error: {
-                type: 'object',
-                description: 'Error information if the node fails',
-                source: '=Error',
-                var: 'error',
-            },
-        },
-        debug: { runtime: 'bpmnEngine' },
-    };
-}
 /** The published-agent node type family. The agent's release key is the suffix. */
 const AGENT_PREFIX = 'uipath.core.agent.';
 /** The inline (autonomous) agent's node type — fixed, not per-instance. */
@@ -2726,62 +2241,6 @@ function ixpDeploymentBindings(spec, existing) {
             },
         ] };
 }
-/**
- * The two bindings a process reference always carries — `name` + `folderPath`,
- * both keyed to the SAME `resourceKey`, which is how the node (via its
- * definition's `model.bindings.resourceKey`) finds them. 45 of 45 deployed rpa
- * instances and 42 of 42 deployed api-workflow instances have exactly these two,
- * and no more.
- *
- * ONE PAIR PER PROCESS, not per step. Bindings are addressed by
- * `resource + resourceKey + propertyAttribute` — the key a bindings lookup map is
- * built on — so a second pair for the same process is not a second
- * reference: it is a duplicate that SHADOWS the first, both steps resolve to
- * whichever was inserted last, and the loser sits in the file referenced by
- * nothing. This is the shape PR 12 filed against the rpa family (the queue
- * emitter already avoided it) and the ride-along this card owns; the ids now come
- * from the process rather than from a step name, so two steps starting the same
- * process share one pair.
- */
-function processResourceBindings(spec, existing) {
-    const resourceKey = spec.resourceKey ?? `${spec.folderPath}.${spec.name}`;
-    const found = (attr) => [...existing.values()].find((b) => b.resource === 'process' && b.resourceKey === resourceKey && b.propertyAttribute === attr)?.id;
-    const already = { name: found('name'), folderPath: found('folderPath') };
-    if (already.name && already.folderPath) {
-        return { ids: { name: already.name, folderPath: already.folderPath }, entries: [] };
-    }
-    // A readable, stable id per process. Two processes sharing a NAME across folders
-    // would collide, so the id is suffixed until it is free — the queue emitter's
-    // shape, which this is a port of.
-    const slug = spec.name.replace(/[^A-Za-z0-9]/g, '') || 'Process';
-    let base = `b${slug.charAt(0).toUpperCase()}${slug.slice(1)}`;
-    for (let n = 2; existing.has(`${base}Name`) || existing.has(`${base}FolderPath`); n++) {
-        base = `b${slug.charAt(0).toUpperCase()}${slug.slice(1)}${n}`;
-    }
-    const ids = { name: `${base}Name`, folderPath: `${base}FolderPath` };
-    return { ids, entries: [
-            {
-                id: ids.name,
-                name: 'name',
-                type: 'string',
-                resource: 'process',
-                resourceKey,
-                default: spec.name,
-                propertyAttribute: 'name',
-                resourceSubType: spec.resourceSubType,
-            },
-            {
-                id: ids.folderPath,
-                name: 'folderPath',
-                type: 'string',
-                resource: 'process',
-                resourceKey,
-                default: spec.folderPath,
-                propertyAttribute: 'folderPath',
-                resourceSubType: spec.resourceSubType,
-            },
-        ] };
-}
 /**
  * Declare a LIST operation's output as the ARRAY it is, when the ledger has
  * MEASURED that it is one ([#203](https://github.com/UiPath/flow-builder-sdk/issues/203)).
@@ -3385,20 +2844,6 @@ export function bundledActionNodeType(spec) {
 export function perCallDefinition(spec) {
     const s = spec?.inputs ?? {};
     switch (spec?.kind) {
-        case 'publishedFunction':
-            return publishedFunctionDef({ key: s.key, name: s.name, folderPath: s.folderPath, inputs: s.inputs ?? {}, returns: s.returns });
-        case 'apiWorkflow':
-            return apiWorkflowDef({ key: s.key, name: s.name, folderPath: s.folderPath, inputs: s.inputs ?? {}, returns: s.returns });
-        case 'agenticProcess':
-            return agenticProcessDef({
-                key: s.key, name: s.name, folderPath: s.folderPath, location: s.location, projectId: s.projectId,
-                inputs: s.inputs ?? {}, returns: s.returns, form: s.form,
-            });
-        case 'rpaWorkflow':
-            return rpaWorkflowDef({
-                key: s.key, name: s.name, folderPath: s.folderPath, location: s.location, projectId: s.projectId,
-                inputs: s.inputs ?? {}, returns: s.returns,
-            });
         case 'agent':
             return agentDef({
                 key: s.key, name: s.name, folderPath: s.folderPath, location: s.location, projectId: s.projectId,
@@ -3778,17 +3223,26 @@ function eventDetail(rc, sub, nodeId, opts, site) {
  * or in a custom node's inputs. Recursing into it would put `{"__lookup": …}` on
  * the wire where the connector expects an id.
  */
-function renderDeep(val, rename = NO_RENAME) {
+function renderDeep(val, rename = NO_RENAME, rendered) {
     if (isLookupToken(val))
         throw new Error(misplacedLookupMessage(val));
     if (val instanceof Expr)
         return renderValue(val, rename);
+    // A value `ctx.render` already rendered is the file's: a `lit`'s object is
+    // written as is. Walking it again made `lit(new Date(…))` `{}` and rendered
+    // an `Expr` inside a `lit({ … })`.
+    if (val !== null && typeof val === 'object' && rendered?.has(val))
+        return val;
+    // A value that says how JSON writes it (a `Date`, via `toJSON`) is written
+    // that way: walking its own keys made a bare `new Date(…)` `{}`.
+    if (val !== null && typeof val === 'object' && typeof val.toJSON === 'function')
+        return val;
     if (Array.isArray(val))
-        return val.map((v) => renderDeep(v, rename));
+        return val.map((v) => renderDeep(v, rename, rendered));
     if (val && typeof val === 'object') {
         const o = {};
         for (const [k, v] of Object.entries(val))
-            o[k] = renderDeep(v, rename);
+            o[k] = renderDeep(v, rename, rendered);
         return o;
     }
     return val;
@@ -5017,7 +4471,7 @@ export function serialize(built, opts = {}) {
         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);
+        node.inputs = renderDeep(contribution.inputs ?? {}, scope.rename, o.rendered);
         if (contribution.outputs) {
             // Replaced outputs are the instance's own, written verbatim: a human task's
             // come from its form, where a literal `{nodeId}` in an outcome name or a
@@ -5075,13 +4529,26 @@ export function serialize(built, opts = {}) {
         // expression renders, so a handler reading this step resolves correctly.
         if (impl.errorEnvelope)
             scope.rename.errorEnvelopes.set(step.name, impl.errorEnvelope);
+        const rendered = new WeakSet();
         const ctx = {
             step: step.name,
             nodeId: id,
             flowId: built.id,
             version,
             pinnedVersion: step.options?.version,
-            render: (value) => renderValue(value, scope.rename),
+            render: (value) => {
+                const out = renderValue(value, scope.rename);
+                // Only a `lit` unwraps to a new value. Its JSON copy is the file's: a
+                // copy, so an object the author also passes outside the `lit` is not
+                // mistaken for this one and still has its expressions rendered.
+                if (out !== value && out !== null && typeof out === 'object') {
+                    const copy = JSON.parse(JSON.stringify(out));
+                    if (copy !== null && typeof copy === 'object')
+                        rendered.add(copy);
+                    return copy;
+                }
+                return out;
+            },
             renameRefs: (js) => renameRefs(js, scope.rename),
             stepNodeId: (name) => scope.stepNodeId.get(name) ?? name,
             mint: (seed) => stableId(`${built.id}:${id}:${seed}`),
@@ -5126,6 +4593,16 @@ export function serialize(built, opts = {}) {
         else if (impl.definition === 'per-tenant' && resolved.carried === undefined) {
             throw new Error(`internal SDK error: ${where}: per-tenant node type ${impl.typeName}@${version} returned no definition.`);
         }
+        // A type that owns a family of names (`typeNamePrefix`) is placed under the
+        // name its definition carries — `uipath.core.function.<key>`, not the prefix.
+        // The bare prefix is allowed: an empty `key` builds it, check refuses that
+        // input (`*_NO_KEY`), and serialize alone emits what it always did.
+        const prefix = entry.type.typeNamePrefix;
+        const nodeType = prefix !== undefined ? def?.nodeType : impl.typeName;
+        if (prefix !== undefined && (typeof nodeType !== 'string' || !nodeType.startsWith(prefix))) {
+            throw new Error(`internal SDK error: ${where}: node type ${impl.typeName}@${version} supplied a definition for `
+                + `${JSON.stringify(nodeType)}, which is not a name under "${prefix}".`);
+        }
         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
@@ -5134,7 +4611,7 @@ export function serialize(built, opts = {}) {
                 throw new Error(`internal SDK error: ${where}: node type ${impl.typeName}@${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 });
+            declaredErrorPorts.set(id, { port, typeName: nodeType, version });
         }
         // A forward port is a handle the definition declares, one of the type's
         // author-named exits, or one the product derives (`derivesPort`: a human
@@ -5153,8 +4630,9 @@ export function serialize(built, opts = {}) {
         if (resolved.carried !== undefined)
             bundledNodeDefs.set(id, def ?? resolved.carried);
         return placeStepNode({
-            where, stepName: step.name, id, typeName: impl.typeName, requestedVersion: version, def, contribution, bound, tails, scope, parentId,
+            where, stepName: step.name, id, typeName: nodeType, requestedVersion: version, def, contribution, bound, tails, scope, parentId,
             trackOutcomes: true,
+            rendered,
         });
     }
     function emitAction(step, tails, scope, parentId) {
@@ -5892,55 +5370,6 @@ export function serialize(built, opts = {}) {
                 addEdge(scope, t, id);
             return [{ node: id, port: successPort(def.nodeType) }];
         }
-        if (spec.kind === 'rpaWorkflow' || spec.kind === 'apiWorkflow' || spec.kind === 'agenticProcess'
-            || spec.kind === 'publishedFunction') {
-            // One emit path for the FOUR process-resource families this SDK authors: they
-            // differ in the definition they carry (node type, serviceType, subtype, the
-            // key's field name) and in nothing else — the node body, the binding pair and
-            // the model-stripping are identical, and the DATA paths that differ are all
-            // downstream in the engine.
-            const s = spec.inputs;
-            const nodeInputs = s.inputs ?? {};
-            const fireAndForget = spec.kind === 'agenticProcess' && spec.inputs.completion === 'fire-and-forget';
-            // The same definition `check` asks about the error port.
-            const def = perCallDefinition(spec);
-            // The bindings first: two steps on the same process share ONE pair, and the
-            // definition's `model.context` names ids that have to exist.
-            // Read off the definition: one kind carries several subtypes (agenticProcess by `form`).
-            // The pair's key and folder come off it too: an in-solution step's resourceKey is the
-            // bare sibling key and its folder is `''`.
-            const subType = def.model.bindings.resourceSubType;
-            const pairFolder = def.model.bindings.values.find((v) => v.name === 'folderPath').default;
-            const { entries } = processResourceBindings({ name: s.name, folderPath: pairFolder, resourceSubType: subType, resourceKey: def.model.bindings.resourceKey }, resourceBindings);
-            for (const b of entries)
-                resourceBindings.set(b.id, b);
-            const id = stepUid(scope, step.name);
-            const node = makeNode(def.nodeType, id, step.name, { parentId, requestedVersion: step.options?.version, def });
-            // The deployed shape keeps the resource model on the DEFINITION only —
-            // 42 of 45 rpa instances and 42 of 42 api-workflow instances carry no
-            // node-level `model` at all. makeNode copies a definition's model onto the
-            // node for the connector families, where the platform does the same; here it
-            // would emit a block the platform never writes, so it comes off again.
-            // (agentic-process has no deployed corpus to count, so it follows its two
-            // siblings — and the model resolves from either place since
-            // #94, which is what the step-0 probe walked to a live job.)
-            delete node.model;
-            node.inputs = renderMap(nodeInputs, scope.rename);
-            if (fireAndForget) {
-                // The platform's fire-and-forget switch, persisted the way the canvas
-                // persists it: the design-time flag on the instance. The dispatch
-                // publishes NO normal output — only dispatch failures route — so the
-                // node keeps only its `error` output and the flag never becomes a
-                // process input argument (renderMap above saw only the author's inputs).
-                node.inputs.fireAndForget = true;
-                if (node.outputs?.output)
-                    delete node.outputs.output;
-            }
-            scope.nodes.push(node);
-            for (const t of tails)
-                addEdge(scope, t, id);
-            return [{ node: id, port: successPort(def.nodeType) }];
-        }
         if (spec.kind === 'conversationalAgent') {
             // The text CONVERSATIONAL agent: the inline agent's cluster shape (a
             // minted `source` plus an `agent.json` sidecar) with the family's own