@uipath/maestro-builder-sdk 6.40.1 → 6.41.1

package/dist/nodes/process/flow/node-type.js

@@ -0,0 +1,652 @@
+/**
+ * The process family's node types — one per published-resource kind this SDK
+ * starts as a job: an RPA process, an API workflow, a published function, and an
+ * agentic process in each of its three forms. Each type's name carries the
+ * resource's key (`uipath.core.function.<key>`), so the type owns every name under
+ * its prefix (`typeNamePrefix`) and supplies the definition it built, transcribed
+ * from the platform's own synthesized one (per-tenant). Moved from serialize.ts /
+ * check.ts / decompile.ts in Phase 4 of docs/NODE_TYPE_ARCHITECTURE_DESIGN.md;
+ * serialized output, printed source, codes and messages unchanged.
+ */
+import { AGENTIC_PROCESS_FORMS } from '../../../core/agentic-process-forms.js';
+import { definitionHasErrorPort } from '../../../core/error-port.js';
+import { Expr } from '../../../core/expr.js';
+import { ownEntry } from '../../../core/own-entry.js';
+import { resourceNodeSortOrder } from '../../../core/process-resource-sort-order.js';
+import { processResourceBindings, processResourceLocation } from '../../../core/process-resource.js';
+import { checkAgenticProcess, checkAgenticProcessRead, checkApiWorkflow, checkApiWorkflowRead, checkPublishedFunction, checkPublishedFunctionRead, checkRpaWorkflow, rpaWorkflowRead, } from './check.js';
+/** The RPA-workflow node type family. The process's release key is the suffix. */
+const RPA_WORKFLOW_PREFIX = 'uipath.core.rpa-workflow.';
+/**
+ * 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 definition a process step's node is emitted against — what serialize
+ * supplies and what `errorPort` asks, so the two cannot disagree (#1040).
+ */
+export function processDefinition(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,
+            });
+    }
+}
+/**
+ * One emit path for the four process-resource kinds: 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.
+ */
+function serializeProcess(spec, ctx) {
+    const s = spec.inputs;
+    const fireAndForget = spec.kind === 'agenticProcess' && s.completion === 'fire-and-forget';
+    const def = processDefinition(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`), and
+    // an in-solution step's resourceKey is the bare sibling key with folder `''`.
+    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 }, ctx.bindings);
+    for (const b of entries)
+        ctx.bind(b);
+    const inputs = Object.fromEntries(Object.entries(s.inputs ?? {}).map(([k, v]) => [k, ctx.render(v)]));
+    let outputs;
+    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.
+        inputs.fireAndForget = true;
+        const { output: _drop, ...rest } = (def.outputDefinition ?? {});
+        outputs = JSON.parse(JSON.stringify(rest));
+    }
+    return {
+        definition: { source: 'snapshot', nodeType: def.nodeType, version: def.version, manifest: 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. (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.)
+        model: 'omit',
+        inputs,
+        ...(outputs !== undefined ? { outputs, replaceOutputs: true } : {}),
+    };
+}
+/** A value as the author wrote it: an expression back to an Expr, a literal string as itself, any other JSON as is. */
+function lifted(raw, ctx) {
+    const text = Array.isArray(raw) ? undefined : ctx.sourceText(raw);
+    if (text === undefined)
+        return raw;
+    return text.startsWith('=js:') ? ctx.expr(text) : text;
+}
+/**
+ * Invert a process node. The identity the runtime resolves by is the
+ * definition's binding pair, and the contract is its output schema, so both come
+ * back off the file's definition — without one there is nothing to recover them
+ * from.
+ */
+function liftProcess(node, ctx, prefix, kind, form) {
+    const n = node;
+    const key = n.type.slice(prefix.length);
+    const def = ctx.definition();
+    const values = (def?.model?.bindings?.values ?? []);
+    const binding = (name) => {
+        const row = values.find((v) => v.name === name);
+        return typeof row?.default === 'string' ? row.default : undefined;
+    };
+    const name = binding('name');
+    const folderPath = binding('folderPath');
+    // A sibling project of the same solution (#951): the model names its project
+    // instead of a folder. `isInSolution` is flow-core's marker. Read back as
+    // `location: 'in-solution'` so the recompile takes the in-solution path
+    // instead of a published one with an empty folder.
+    const projectId = typeof def?.model?.projectId === 'string' ? def.model.projectId : undefined;
+    const inSolution = def?.model?.isInSolution === true || projectId !== undefined;
+    const inputs = { ...(n.inputs ?? {}) };
+    // The design-time fire-and-forget switch is an OPTION on the factory, not a
+    // process argument — serialize adds it to `inputs` after rendering the
+    // author's map, so it comes back off here.
+    const fireAndForget = ctx.plainValue(inputs.fireAndForget) === true;
+    delete inputs.fireAndForget;
+    const schema = def?.outputDefinition?.output?.schema?.properties;
+    const spec = {
+        key,
+        ...(name !== undefined ? { name } : {}),
+        ...(inSolution ? { location: 'in-solution' } : {}),
+        ...(!inSolution && folderPath !== undefined ? { folderPath } : {}),
+        ...(inSolution && projectId !== undefined ? { projectId } : {}),
+        ...(Object.keys(inputs).length ? { inputs: Object.fromEntries(Object.entries(inputs).map(([k, v]) => [k, lifted(v, ctx)])) } : {}),
+        ...(schema && Object.keys(schema).length > 0
+            ? { returns: Object.fromEntries(Object.entries(schema).map(([k, v]) => [k, String(v?.type ?? 'string')])) } : {}),
+        ...(form !== undefined ? { form } : {}),
+        ...(fireAndForget ? { completion: 'fire-and-forget' } : {}),
+    };
+    return { kind, inputs: spec };
+}
+function printProcess(spec, ctx, factory) {
+    const p = spec.inputs;
+    const val = (v) => (v === undefined ? 'undefined' : v instanceof Expr ? ctx.value(v) : ctx.json(v));
+    const obj = (entries) => `{ ${entries.map(([k, v]) => `${ctx.key(k)}: ${v}`).join(', ')} }`;
+    return {
+        factory,
+        options: [
+            ['key', ctx.string(p.key)],
+            ['name', p.name !== undefined ? ctx.string(p.name) : undefined],
+            ['location', p.location !== undefined ? ctx.string(p.location) : undefined],
+            ['folderPath', p.folderPath !== undefined ? ctx.string(p.folderPath) : undefined],
+            ['projectId', p.projectId !== undefined ? ctx.string(p.projectId) : undefined],
+            ['inputs', p.inputs !== undefined ? obj(Object.entries(p.inputs).map(([k, v]) => [k, val(v)])) : undefined],
+            ['returns', p.returns !== undefined ? obj(Object.entries(p.returns).map(([k, t]) => [k, ctx.string(t)])) : undefined],
+            ['form', p.form !== undefined ? ctx.string(p.form) : undefined],
+            ['completion', p.completion !== undefined ? ctx.string(p.completion) : undefined],
+        ],
+    };
+}
+/** What reading a process step's result yields: its `returns`, each kind's read rule. */
+function processOutput(spec) {
+    switch (spec.kind) {
+        case 'rpaWorkflow': {
+            const declared = Object.keys(spec.inputs?.returns ?? {});
+            return {
+                kind: 'fields',
+                fields: declared.length ? Object.fromEntries(declared.map((k) => [k, 'any'])) : undefined,
+                read: rpaWorkflowRead(spec.inputs),
+            };
+        }
+        case 'apiWorkflow':
+            return { kind: 'reader', read: (read, report) => checkApiWorkflowRead(read, spec.inputs, report) };
+        case 'publishedFunction':
+            return { kind: 'reader', read: (read, report) => checkPublishedFunctionRead(read, spec.inputs, report) };
+        case 'agenticProcess':
+            return { kind: 'reader', read: (read, report) => checkAgenticProcessRead(read, spec.inputs, report) };
+    }
+}
+function processCheck(spec, ctx) {
+    switch (spec.kind) {
+        case 'rpaWorkflow': return checkRpaWorkflow(spec.inputs, ctx);
+        case 'apiWorkflow': return checkApiWorkflow(spec.inputs, ctx);
+        case 'publishedFunction': return checkPublishedFunction(spec.inputs, ctx);
+        case 'agenticProcess': return checkAgenticProcess(spec.inputs, ctx);
+    }
+}
+function processType(kind, prefix, factory, form) {
+    const impl = {
+        kind, typeName: `${prefix}*`, version: '1.0.0', factory, definition: 'per-tenant',
+        // The definition this SDK synthesizes is the one serialize emits, and every
+        // one of the four sets supportsErrorHandling; asking it keeps the two in step (#1040).
+        errorPort: (spec) => definitionHasErrorPort(processDefinition(spec)),
+        serialize: (spec, ctx) => serializeProcess(spec, ctx),
+        deserialize: (node, ctx) => liftProcess(node, ctx, prefix, kind, form),
+        print: (spec, ctx) => printProcess(spec, ctx, factory),
+        check: (spec, ctx) => processCheck(spec, ctx),
+        // check collected no expressions for a process step before the port; unchanged by it.
+        expressions: () => [],
+        output: processOutput,
+    };
+    return {
+        kind, typeName: `${prefix}*`, typeNamePrefix: prefix, factory, defaultVersion: '1.0.0',
+        versions: { '1.0.0': impl },
+        // The agentic process's three forms share its kind; an absent or unknown form
+        // is the default `bpmn` one, as the definition builder reads it.
+        ...(kind === 'agenticProcess' ? {
+            matches: ({ inputs }) => {
+                const f = inputs?.form;
+                return form === undefined ? f !== 'flow' && f !== 'case' : f === form;
+            },
+        } : {}),
+    };
+}
+export const processNodeTypes = [
+    processType('rpaWorkflow', RPA_WORKFLOW_PREFIX, 'rpaWorkflow'),
+    processType('apiWorkflow', API_WORKFLOW_PREFIX, 'apiWorkflow'),
+    processType('publishedFunction', FUNCTION_PREFIX, 'publishedFunction'),
+    processType('agenticProcess', AGENTIC_PROCESS_FORMS.bpmn.prefix, 'agenticProcess'),
+    processType('agenticProcess', AGENTIC_PROCESS_FORMS.flow.prefix, 'agenticProcess', 'flow'),
+    processType('agenticProcess', AGENTIC_PROCESS_FORMS.case.prefix, 'agenticProcess', 'case'),
+];