@uipath/maestro-builder-sdk 6.25.1 → 6.26.0

package/dist/api-index.md

@@ -57,13 +57,13 @@ could hand you spans for a version you do not have.
 | `apiWorkflow` | function | `dist/core/actions.d.ts:1658-1692` | Actions | Invoke a deployed API workflow — a coded workflow published to Orchestrator, run as a serverless job rather than by a… |
 | `ApiWorkflowInputs` | interface | `dist/core/actions.d.ts:411-442` | Option shapes | 5 field(s) |
 | `AppRef` | interface | `dist/nodes/hitl/flow/spec.d.ts:140-185` | Supporting types | A deployed Action App that supplies a human task's form — the `'action-app'` variant's subject. |
-| `ArmBuilder` | class | `dist/flow-sdk.d.ts:1187-1210` | Builders | The sub-builder an ARM callback receives — a `StepList` that can also name itself with `.label(...)`. |
+| `ArmBuilder` | class | `dist/flow-sdk.d.ts:1193-1216` | Builders | The sub-builder an ARM callback receives — a `StepList` that can also name itself with `.label(...)`. |
 | `AskedField` | interface | `dist/core/actions.d.ts:79-89` | Supporting types | A value the reviewer FILLS IN: read downstream with `out('<step>', '<id>')`. |
 | `batchTransform` | function | `dist/nodes/ai-patterns/flow/factories.d.ts:49-83` | Actions | Add AI-generated columns to a CSV — the platform's **Batch transform** node, `uipath.pattern.batch-transform` (service… |
 | `BatchTransformInputs` | interface | `dist/nodes/ai-patterns/flow/spec.d.ts:48-63` | Option shapes | 4 field(s) |
 | `BindingContribution` | interface | `dist/core/node-classes.d.ts:80-101` | Supporting types | A resource binding a contribution hoists to the flow's top-level `bindings` array — the shape the `.flow` format… |
 | `BuiltEntryPoint` | interface | `dist/flow-sdk.d.ts:695-707` | Supporting types | One additional flow root, built by `.entryPoint()`. |
-| `BuiltFlow` | interface | `dist/flow-sdk.d.ts:708-743` | Supporting types | 15 field(s) |
+| `BuiltFlow` | interface | `dist/flow-sdk.d.ts:708-749` | Supporting types | 16 field(s) |
 | `BuiltinToolName` | type | `dist/core/actions.d.ts:1066-1067` | Supporting types | The three platform-shipped built-in tools (fixed registry types). |
 | `BuiltinToolRef` | interface | `dist/core/actions.d.ts:1199-1219` | Supporting types | A platform built-in tool. |
 | `BuiltInValidatorGuardrail` | interface | `dist/core/actions.d.ts:762-803` | Supporting types | A platform-shipped validator, configured by parameters. |
@@ -128,11 +128,11 @@ could hand you spans for a version you do not have.
 | `FilterCondition` | type | `dist/nodes/transform/flow/spec.d.ts:10-11` | Supporting types | Comparison a filter rule applies to a field. |
 | `FilterMatch` | type | `dist/nodes/transform/flow/spec.d.ts:8-9` | Supporting types | How a filter combines its rules: every rule must match, or any one. |
 | `FilterRule` | interface | `dist/nodes/transform/flow/spec.d.ts:12-24` | Supporting types | 3 field(s) |
-| `flow` | function | `dist/flow-sdk.d.ts:1493-1508` | Flow construction | Start building a flow with the given id. |
+| `flow` | function | `dist/flow-sdk.d.ts:1541-1556` | Flow construction | Start building a flow with the given id. |
 | `FlowAction` | class | `dist/core/node-classes.d.ts:162-168` | Supporting types | A node placed as a step — pass an instance to `.step(name, …)`. |
 | `FlowActionSpec` | type | `dist/flow-sdk.d.ts:53-54` | Supporting types | What `.step()` accepts here: the shared actions plus this SDK's subflow. |
 | `FlowActionSpecs` | interface | `dist/core/actions.d.ts:1443-1520` | Supporting types | Every action kind, keyed by kind, to the body of its spec — the arm's fields other than `kind`. |
-| `FlowBuilder` | class | `dist/flow-sdk.d.ts:1211-1492` | Builders | 13 member(s) |
+| `FlowBuilder` | class | `dist/flow-sdk.d.ts:1217-1540` | Builders | 14 member(s) |
 | `FlowLayout` | interface | `dist/flow-sdk.d.ts:681-694` | Supporting types | Designer layout for a flow, keyed by AUTHOR-level ids: node entries by step name (plus the trigger id and `end`), edge… |
 | `FlowNode` | class | `dist/core/node-classes.d.ts:126-161` | Supporting types | The abstract root of every definition-backed node the builder can place. |
 | `FlowResource` | class | `dist/core/node-classes.d.ts:176-183` | Supporting types | A node attached to another semantic node — an inline agent's tool, context, memory, or escalation. |
@@ -225,11 +225,11 @@ could hand you spans for a version you do not have.
 | `SendMessageInputs` | interface | `dist/nodes/conversation/flow/spec.d.ts:8-27` | Option shapes | 4 field(s) |
 | `ShownField` | interface | `dist/core/actions.d.ts:63-78` | Supporting types | A value the reviewer READS: shown on the form, filled in from the flow. |
 | `Step` | type | `dist/flow-sdk.d.ts:484-603` | Supporting types |  |
-| `StepList` | class | `dist/flow-sdk.d.ts:744-1186` | Builders | Collects a sequence of steps. |
+| `StepList` | class | `dist/flow-sdk.d.ts:750-1192` | Builders | Collects a sequence of steps. |
 | `STICKY_NOTE_COLORS` | const | `dist/flow-sdk.d.ts:634-639` | Flow construction | The designer's sticky-note palette. |
 | `StickyNote` | interface | `dist/flow-sdk.d.ts:646-680` | Supporting types | A canvas sticky note — free text pinned to the diagram, for the humans reading it. |
 | `StickyNoteColor` | type | `dist/flow-sdk.d.ts:640-645` | Supporting types | A sticky note's swatch. |
-| `subflow` | function | `dist/flow-sdk.d.ts:1509-1548` | Flow construction | Run another flow as one step, and read back what it returns. |
+| `subflow` | function | `dist/flow-sdk.d.ts:1557-1596` | Flow construction | Run another flow as one step, and read back what it returns. |
 | `SubflowSpec` | interface | `dist/flow-sdk.d.ts:45-52` | Supporting types | A step that runs a child flow. |
 | `summarize` | function | `dist/nodes/ai-patterns/flow/factories.d.ts:8-48` | Actions | Summarize a document with citations — the platform's **Summarize** node. |
 | `SummarizeInputs` | interface | `dist/nodes/ai-patterns/flow/spec.d.ts:8-40` | Option shapes | 3 field(s) |

package/dist/api-members.md

@@ -5,12 +5,12 @@
 
 # Maestro Builder SDK — member index
 
-**A lookup table of 1113 rows — match one name in it, do not read it.**
+**A lookup table of 1115 rows — match one name in it, do not read it.**
 Grep or search for the member you have; the row it lands on is the whole
 answer. Reading top to bottom costs ~20x what the one row does and tells you
 nothing you asked for.
 
-Every field and method of every exported shape — 1113 across
+Every field and method of every exported shape — 1115 across
 200 interfaces and classes — keyed by the MEMBER's own name.
 
 **Use this when the name you have is a field or a method**, which is usually
@@ -28,7 +28,7 @@ truncated summary would, for less. Read the span.
 Member names repeat across shapes (`name` is declared on 69 of them), so the
 `Declared on` column is what makes a match actionable. For the whole shape
 rather than the one field, look that name up in [`api-index.md`](api-index.md) —
-which is why its span is not repeated on all 1113 rows here.
+which is why its span is not repeated on all 1115 rows here.
 
 **A name that misses both indexes is probably not part of the API.** The one
 that comes up is a RUNTIME output key — a human task's `Action`, a step's
@@ -66,7 +66,7 @@ not find it either.
 | `app` | property | `HumanTaskOpts` | `dist/bpmn/bpmn-sdk.d.ts:1337-1338` |
 | `appSystemName` | property | `AppRef` | `dist/nodes/hitl/flow/spec.d.ts:170-175` |
 | `appVersion` | property | `HumanTaskOpts` | `dist/bpmn/bpmn-sdk.d.ts:1339-1340` |
-| `armLabel` | property | `ArmBuilder` | `dist/flow-sdk.d.ts:1199` |
+| `armLabel` | property | `ArmBuilder` | `dist/flow-sdk.d.ts:1205` |
 | `assignee` | property | `HitlRecipient` | `dist/nodes/hitl/flow/spec.d.ts:52-63` |
 | `async` | property | `OrchestratorAsyncOpts` | `dist/bpmn/bpmn-sdk.d.ts:1281-1285` |
 | `atRiskPercentage` | property | `EscalationOpts` | `dist/case/case-sdk.d.ts:132-137` |
@@ -97,14 +97,14 @@ not find it either.
 | `body` | property | `TypedContextRow` | `dist/bpmn/typed-node.d.ts:176-181` |
 | `body` | property | `TypedInputRow` | `dist/bpmn/typed-node.d.ts:207-208` |
 | `boundaryEvent` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:2239-2246` |
-| `branch` | method | `StepList` | `dist/flow-sdk.d.ts:943-961` |
+| `branch` | method | `StepList` | `dist/flow-sdk.d.ts:949-967` |
 | `branches` | property | `HttpInputsBase` | `dist/nodes/http/flow/spec.d.ts:25-30` |
-| `break` | method | `StepList` | `dist/flow-sdk.d.ts:1071-1080` |
+| `break` | method | `StepList` | `dist/flow-sdk.d.ts:1077-1086` |
 | `breakEnabled` | property | `DoWhileOptions` | `dist/flow-sdk.d.ts:481-482` |
 | `breakEnabled` | property | `LoopOptions` | `dist/flow-sdk.d.ts:468-472` |
 | `build` | method | `BpmnBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3483-3488` |
 | `build` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1269-1274` |
-| `build` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1485-1491` |
+| `build` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1533-1539` |
 | `businessRule` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:2527-2573` |
 | `by` | property | `LookupResolution` | `dist/core/lookups.d.ts:164` |
 | `by` | property | `LookupSpec` | `dist/core/lookups.d.ts:27-28` |
@@ -172,7 +172,7 @@ not find it either.
 | `context` | property | `RegistryTypeSpec` | `dist/bpmn/typed-node.d.ts:87` |
 | `contextRows` | property | `ActivityNodeOpts` | `dist/bpmn/bpmn-sdk.d.ts:1528-1535` |
 | `contextVerbatim` | property | `ActivityNodeOpts` | `dist/bpmn/bpmn-sdk.d.ts:1600-1605` |
-| `continue` | method | `StepList` | `dist/flow-sdk.d.ts:1081-1095` |
+| `continue` | method | `StepList` | `dist/flow-sdk.d.ts:1087-1101` |
 | `contribute` | method | `FlowNode` | `dist/core/node-classes.d.ts:144-153` |
 | `conversationalAgent` | property | `FlowActionSpecs` | `dist/core/actions.d.ts:1479-1482` |
 | `conversationContext` | property | `FlowActionSpecs` | `dist/nodes/conversation/flow/spec.d.ts:55-58` |
@@ -207,6 +207,8 @@ not find it either.
 | `defaultOf` | property | `PendingExit` | `dist/bpmn/bpmn-sdk.d.ts:1924-1925` |
 | `deferDate` | property | `QueueItemInputs` | `dist/nodes/queue/flow/spec.d.ts:48-49` |
 | `definition` | property | `NodeContribution` | `dist/core/node-classes.d.ts:111-112` |
+| `definitions` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:734-739` |
+| `definitions` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1433-1473` |
 | `delay` | property | `FlowActionSpecs` | `dist/nodes/delay/flow/spec.d.ts:38-41` |
 | `dependsOn` | property | `LookupSpec` | `dist/core/lookups.d.ts:34-35` |
 | `description` | property | `AgentMemoryRef` | `dist/core/actions.d.ts:1187` |
@@ -223,7 +225,7 @@ not find it either.
 | `description` | property | `CustomGuardrail` | `dist/core/actions.d.ts:755` |
 | `description` | property | `EscalationRef` | `dist/core/actions.d.ts:1349-1350` |
 | `description` | property | `EventTriggerOpts` | `dist/case/case-sdk.d.ts:241` |
-| `description` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1235-1242` |
+| `description` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1242-1249` |
 | `description` | property | `HttpRequestToolRef` | `dist/core/actions.d.ts:1154` |
 | `description` | property | `IxpExtractInputs` | `dist/core/actions.d.ts:337-344` |
 | `description` | property | `IxpToolRef` | `dist/core/actions.d.ts:1327-1328` |
@@ -265,7 +267,7 @@ not find it either.
 | `document` | property | `HitlInputs` | `dist/nodes/hitl/flow/spec.d.ts:252-256` |
 | `documentClassify` | property | `FlowActionSpecs` | `dist/nodes/document/flow/spec.d.ts:56-59` |
 | `documentId` | property | `DocValidationInputs` | `dist/nodes/hitl/flow/spec.d.ts:84-85` |
-| `doWhile` | method | `StepList` | `dist/flow-sdk.d.ts:1046-1070` |
+| `doWhile` | method | `StepList` | `dist/flow-sdk.d.ts:1052-1076` |
 | `dueDate` | property | `QueueItemInputs` | `dist/nodes/queue/flow/spec.d.ts:50-51` |
 | `duration` | property | `TimerSpec` | `dist/bpmn/bpmn-sdk.d.ts:33-34` |
 | `dynamicExtract` | property | `FlowActionSpecs` | `dist/nodes/document/flow/spec.d.ts:60-63` |
@@ -289,12 +291,12 @@ not find it either.
 | `entity` | property | `DataServiceOpts` | `dist/bpmn/bpmn-sdk.d.ts:1090-1091` |
 | `entry` | property | `BuiltStage` | `dist/case/case-sdk.d.ts:528` |
 | `entry` | property | `BuiltTask` | `dist/case/case-sdk.d.ts:520` |
-| `entryPoint` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1301-1351` |
+| `entryPoint` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1308-1358` |
 | `entryPointId` | property | `ProcessMetadata` | `dist/bpmn/bpmn-sdk.d.ts:534-539` |
-| `entryPoints` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:734-735` |
+| `entryPoints` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:740-741` |
 | `entryWhen` | method | `StageBuilder` | `dist/case/case-sdk.d.ts:1004-1011` |
 | `entryWhen` | method | `TaskBuilder` | `dist/case/case-sdk.d.ts:947-956` |
-| `err` | method | `StepList` | `dist/flow-sdk.d.ts:752-777` |
+| `err` | method | `StepList` | `dist/flow-sdk.d.ts:758-783` |
 | `error` | property | `BoundaryOpts` | `dist/bpmn/bpmn-sdk.d.ts:750-754` |
 | `error` | property | `EndOpts` | `dist/bpmn/bpmn-sdk.d.ts:696-706` |
 | `error` | property | `EventSubProcessOpts` | `dist/bpmn/bpmn-sdk.d.ts:1842-1847` |
@@ -459,7 +461,7 @@ not find it either.
 | `inclusiveGateway` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:2266-2273` |
 | `inlineAgent` | property | `FlowActionSpecs` | `dist/core/actions.d.ts:1491-1494` |
 | `input` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1160-1185` |
-| `input` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1426-1438` |
+| `input` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1474-1486` |
 | `input` | property | `HumanTaskOpts` | `dist/bpmn/bpmn-sdk.d.ts:1355-1356` |
 | `input` | property | `OrchestratorOpts` | `dist/bpmn/bpmn-sdk.d.ts:1241-1242` |
 | `input` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3068-3076` |
@@ -532,7 +534,7 @@ not find it either.
 | `kind` | property | `SubflowSpec` | `dist/flow-sdk.d.ts:47` |
 | `kind` | property | `WhenExpression` | `dist/case/case-sdk.d.ts:99-100` |
 | `kValue` | property | `AgentMemoryRef` | `dist/core/actions.d.ts:1194-1195` |
-| `label` | method | `ArmBuilder` | `dist/flow-sdk.d.ts:1200-1209` |
+| `label` | method | `ArmBuilder` | `dist/flow-sdk.d.ts:1206-1215` |
 | `label` | property | `AskedField` | `dist/core/actions.d.ts:83-84` |
 | `label` | property | `BuiltStage` | `dist/case/case-sdk.d.ts:523` |
 | `label` | property | `InOutField` | `dist/core/actions.d.ts:99-100` |
@@ -546,7 +548,7 @@ not find it either.
 | `layout` | property | `BuiltCase` | `dist/case/case-sdk.d.ts:646-647` |
 | `layout` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:730-731` |
 | `layout` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1139-1159` |
-| `layout` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1243-1253` |
+| `layout` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1250-1260` |
 | `limit` | property | `DataFabricReadInputs` | `dist/nodes/data-fabric/flow/spec.d.ts:95-100` |
 | `limit` | property | `DoWhileOptions` | `dist/flow-sdk.d.ts:479-480` |
 | `literal` | property | `Expr` | `dist/core/expr.d.ts:18` |
@@ -556,7 +558,7 @@ not find it either.
 | `lookups` | property | `ConnectorMeta` | `dist/core/connectors.d.ts:76-87` |
 | `loop` | property | `ActivityNodeFields` | `dist/bpmn/bpmn-sdk.d.ts:335-336` |
 | `loop` | property | `ActivityOpts` | `dist/bpmn/bpmn-sdk.d.ts:832-833` |
-| `loop` | method | `StepList` | `dist/flow-sdk.d.ts:1034-1045` |
+| `loop` | method | `StepList` | `dist/flow-sdk.d.ts:1040-1051` |
 | `managed` | property | `HttpInputsBase` | `dist/nodes/http/flow/spec.d.ts:37-67` |
 | `marksCaseComplete` | property | `BuiltCaseExitCondition` | `dist/case/case-sdk.d.ts:354` |
 | `marksStageComplete` | property | `BuiltExitCondition` | `dist/case/case-sdk.d.ts:321` |
@@ -645,7 +647,7 @@ not find it either.
 | `name` | property | `EventSubProcessOpts` | `dist/bpmn/bpmn-sdk.d.ts:1840-1841` |
 | `name` | property | `EventTriggerOpts` | `dist/case/case-sdk.d.ts:240` |
 | `name` | property | `ExternalTaskOpts` | `dist/bpmn/bpmn-sdk.d.ts:1499-1500` |
-| `name` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1227-1234` |
+| `name` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1234-1241` |
 | `name` | property | `FlowOpts` | `dist/bpmn/bpmn-sdk.d.ts:1637-1638` |
 | `name` | property | `GatewayOpts` | `dist/bpmn/bpmn-sdk.d.ts:760-761` |
 | `name` | property | `HandlerOpts` | `dist/bpmn/bpmn-sdk.d.ts:1735-1736` |
@@ -707,7 +709,7 @@ not find it either.
 | `onError` | method | `ActivityBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3259-3266` |
 | `onError` | method | `ActivityBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3267-3274` |
 | `onError` | method | `ActivityBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3275-3283` |
-| `onError` | method | `StepList` | `dist/flow-sdk.d.ts:832-892` |
+| `onError` | method | `StepList` | `dist/flow-sdk.d.ts:838-898` |
 | `onMessage` | method | `ActivityBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3302-3310` |
 | `onMessage` | method | `ActivityBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3311-3319` |
 | `onTimer` | method | `ActivityBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3284-3292` |
@@ -725,7 +727,7 @@ not find it either.
 | `outcomes` | property | `EscalationRef` | `dist/core/actions.d.ts:1395-1400` |
 | `outcomes` | property | `HitlInputs` | `dist/nodes/hitl/flow/spec.d.ts:211-225` |
 | `output` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1186-1198` |
-| `output` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1439-1474` |
+| `output` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1487-1522` |
 | `output` | property | `RegistryTypeSpec` | `dist/bpmn/typed-node.d.ts:90` |
 | `output` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3077-3085` |
 | `outputColumns` | property | `BatchTransformInputs` | `dist/nodes/ai-patterns/flow/spec.d.ts:56-60` |
@@ -761,7 +763,7 @@ not find it either.
 | `pageRange` | property | `DynamicExtractInputs` | `dist/nodes/document/flow/spec.d.ts:49-50` |
 | `pageRange` | property | `IxpExtractInputs` | `dist/core/actions.d.ts:326-327` |
 | `parallel` | property | `LoopOptions` | `dist/flow-sdk.d.ts:461-462` |
-| `parallel` | method | `StepList` | `dist/flow-sdk.d.ts:998-1033` |
+| `parallel` | method | `StepList` | `dist/flow-sdk.d.ts:1004-1039` |
 | `parallelGateway` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:2256-2265` |
 | `parameters` | property | `ConnectorEventOpts` | `dist/bpmn/bpmn-sdk.d.ts:1479-1480` |
 | `parameters` | property | `HttpOpts` | `dist/bpmn/bpmn-sdk.d.ts:1140-1145` |
@@ -860,7 +862,7 @@ not find it either.
 | `retry` | property | `ActivityOpts` | `dist/bpmn/bpmn-sdk.d.ts:830-831` |
 | `retryable` | property | `ErrorMappingRow` | `dist/bpmn/bpmn-sdk.d.ts:308-309` |
 | `retryCount` | property | `HttpInputsBase` | `dist/nodes/http/flow/spec.d.ts:109-123` |
-| `return` | method | `StepList` | `dist/flow-sdk.d.ts:1176-1185` |
+| `return` | method | `StepList` | `dist/flow-sdk.d.ts:1182-1191` |
 | `returnCitations` | property | `SummarizeInputs` | `dist/nodes/ai-patterns/flow/spec.d.ts:34-39` |
 | `returns` | property | `AgentInputs` | `dist/core/actions.d.ts:641-660` |
 | `returns` | property | `ApiWorkflowInputs` | `dist/core/actions.d.ts:429-441` |
@@ -901,7 +903,7 @@ not find it either.
 | `schemaVersion` | method | `BpmnBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3375-3404` |
 | `schemaVersion` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:714-720` |
 | `schemaVersion` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1068-1094` |
-| `schemaVersion` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1386-1425` |
+| `schemaVersion` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1393-1432` |
 | `scope` | property | `EscalationRecipient` | `dist/case/case-sdk.d.ts:121` |
 | `scopes` | property | `GuardrailSelector` | `dist/core/actions.d.ts:701` |
 | `script` | property | `FlowActionSpecs` | `dist/nodes/script/flow/spec.d.ts:47-50` |
@@ -973,16 +975,16 @@ not find it either.
 | `startName` | property | `EventSubProcessOpts` | `dist/bpmn/bpmn-sdk.d.ts:1887-1888` |
 | `startPayload` | property | `EventSubProcessOpts` | `dist/bpmn/bpmn-sdk.d.ts:1889-1890` |
 | `startProcess` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:2459-2478` |
-| `step` | method | `StepList` | `dist/flow-sdk.d.ts:778-788` |
+| `step` | method | `StepList` | `dist/flow-sdk.d.ts:784-794` |
 | `steps` | property | `BuiltEntryPoint` | `dist/flow-sdk.d.ts:705-706` |
 | `steps` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:724` |
-| `steps` | property | `StepList` | `dist/flow-sdk.d.ts:746` |
-| `stepSwitch` | method | `StepList` | `dist/flow-sdk.d.ts:789-831` |
-| `stepToList` | method | `StepList` | `dist/flow-sdk.d.ts:906-934` |
-| `stepToRef` | method | `StepList` | `dist/flow-sdk.d.ts:1127-1155` |
-| `stepToRef` | method | `StepList` | `dist/flow-sdk.d.ts:1156-1175` |
+| `steps` | property | `StepList` | `dist/flow-sdk.d.ts:752` |
+| `stepSwitch` | method | `StepList` | `dist/flow-sdk.d.ts:795-837` |
+| `stepToList` | method | `StepList` | `dist/flow-sdk.d.ts:912-940` |
+| `stepToRef` | method | `StepList` | `dist/flow-sdk.d.ts:1133-1161` |
+| `stepToRef` | method | `StepList` | `dist/flow-sdk.d.ts:1162-1181` |
 | `stickyNotes` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:732-733` |
-| `stickyNotes` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1254-1279` |
+| `stickyNotes` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1261-1286` |
 | `storageBucket` | property | `DocValidationInputs` | `dist/nodes/hitl/flow/spec.d.ts:82-83` |
 | `strategy` | property | `LookupSpec` | `dist/core/lookups.d.ts:33` |
 | `style` | property | `CaseNodeLayout` | `dist/case/case-sdk.d.ts:597-598` |
@@ -995,7 +997,7 @@ not find it either.
 | `subType` | property | `VarSpec` | `dist/flow-sdk.d.ts:84-85` |
 | `summarize` | property | `FlowActionSpecs` | `dist/nodes/ai-patterns/flow/spec.d.ts:66-69` |
 | `summary` | property | `CaseAppConfig` | `dist/case/case-sdk.d.ts:585-586` |
-| `switch` | method | `StepList` | `dist/flow-sdk.d.ts:962-997` |
+| `switch` | method | `StepList` | `dist/flow-sdk.d.ts:968-1003` |
 | `systemPrompt` | property | `ConversationalAgentInputs` | `dist/core/actions.d.ts:134-139` |
 | `systemPrompt` | property | `InlineAgentInputs` | `dist/core/actions.d.ts:814-863` |
 | `systemPrompt` | property | `VoiceAgentInputs` | `dist/core/actions.d.ts:221-226` |
@@ -1020,7 +1022,7 @@ not find it either.
 | `temperature` | property | `InlineAgentInputs` | `dist/core/actions.d.ts:924-925` |
 | `temperature` | property | `VoiceSettings` | `dist/core/actions.d.ts:213-214` |
 | `terminate` | property | `EndOpts` | `dist/bpmn/bpmn-sdk.d.ts:692-693` |
-| `terminate` | method | `StepList` | `dist/flow-sdk.d.ts:1096-1126` |
+| `terminate` | method | `StepList` | `dist/flow-sdk.d.ts:1102-1132` |
 | `threshold` | property | `ContextIndexRef` | `dist/core/actions.d.ts:1438-1439` |
 | `timeCycle` | property | `BuiltTrigger` | `dist/case/case-sdk.d.ts:201-202` |
 | `timeout` | property | `HttpInputsBase` | `dist/nodes/http/flow/spec.d.ts:91-108` |
@@ -1044,11 +1046,11 @@ not find it either.
 | `trigger` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:725-727` |
 | `trigger` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1224-1232` |
 | `trigger` | property | `EscalationOpts` | `dist/case/case-sdk.d.ts:128-129` |
-| `trigger` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1280-1300` |
+| `trigger` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1287-1307` |
 | `trigger` | property | `StartOpts` | `dist/bpmn/bpmn-sdk.d.ts:624-671` |
 | `triggeredByEvent` | property | `SubProcessOpts` | `dist/bpmn/bpmn-sdk.d.ts:976-977` |
-| `triggerId` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:736-742` |
-| `triggerId` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1352-1371` |
+| `triggerId` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:742-748` |
+| `triggerId` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1359-1378` |
 | `triggerOptions` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:728-729` |
 | `triggers` | property | `BuiltCase` | `dist/case/case-sdk.d.ts:644-645` |
 | `triggers` | property | `CaseLayout` | `dist/case/case-sdk.d.ts:620-621` |
@@ -1104,7 +1106,7 @@ not find it either.
 | `value` | property | `TypedInputRow` | `dist/bpmn/typed-node.d.ts:205-206` |
 | `values` | property | `DataFabricCreateInputs` | `dist/nodes/data-fabric/flow/spec.d.ts:132-137` |
 | `var` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1199-1223` |
-| `var` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1475-1484` |
+| `var` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1523-1532` |
 | `var` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3059-3067` |
 | `var` | property | `TaskOutputBinding` | `dist/case/case-sdk.d.ts:494-495` |
 | `var` | property | `TypedOutputRow` | `dist/bpmn/typed-node.d.ts:251-252` |
@@ -1127,7 +1129,7 @@ not find it either.
 | `version` | property | `ConnectorToolRef` | `dist/core/actions.d.ts:1232-1233` |
 | `version` | property | `EventSubscription` | `dist/core/actions.d.ts:2116` |
 | `version` | property | `ExternalTaskOpts` | `dist/bpmn/bpmn-sdk.d.ts:1507-1508` |
-| `version` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1372-1385` |
+| `version` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1379-1392` |
 | `version` | property | `NodeOptions` | `dist/flow-sdk.d.ts:373-380` |
 | `version` | property | `TriggerMeta` | `dist/core/connectors.d.ts:126` |
 | `version` | property | `TriggerOptions` | `dist/core/actions.d.ts:2073-2074` |

package/dist/check.js

@@ -29,7 +29,7 @@ import { ownEntry } from './core/own-entry.js';
 import { FLOW_NODE_TYPES } from './flow-node-registry.js';
 import { stepExits } from './flow-step-exits.js';
 import { plainHttpOnErrorMessage } from './nodes/http/flow/family.js';
-import { resolveVersion } from './core/nodes/versioned.js';
+import { resolveVersion, resolveVersionCarried } from './core/nodes/versioned.js';
 import { declaredErrorPortRefusal } from './core/error-port.js';
 export function check(built, opts = {}) {
     let diags = [];
@@ -275,7 +275,7 @@ function checkFlow(built, ancestors, opts = {}) {
                 declared.add(s.name); // a step's output is referenceable by name
             }
             if ((s.kind === 'stepToList' || s.kind === 'stepToRef') && s.port === 'error')
-                checkOnError(s, prevPortSource, diags, prevPortSource && checkedSteps.get(prevPortSource.name));
+                checkOnError(s, prevPortSource, diags, prevPortSource && checkedSteps.get(prevPortSource.name), carriedLookup([built, ...ancestors]));
             if ((s.kind === 'stepToList' || s.kind === 'stepToRef') && s.port.startsWith('branch-')) {
                 const want = s.port.slice('branch-'.length);
                 const prevSpec = prevAction?.spec;
@@ -381,7 +381,7 @@ function checkFlow(built, ancestors, opts = {}) {
                 prevPortSource = s;
                 const registered = registeredKind(s.spec);
                 if (registered) {
-                    const { placed, checked } = checkRegisteredStep(registered, s, exprs, errorSource, opts, diags, typeOf, triggerId);
+                    const { placed, checked } = checkRegisteredStep(registered, s, exprs, errorSource, opts, diags, typeOf, triggerId, carriedLookup([built, ...ancestors]));
                     checkedSteps.set(s.name, checked);
                     if (placed)
                         registeredSteps.set(s.name, checked);
@@ -3977,6 +3977,11 @@ const LOOP_FIELDS = new Set(['currentItem', 'currentIteration', 'collection', 'o
  * before the 2.4 default (#868); its own fields are not audited here.
  */
 const LOOP_FIELDS_1_0_0 = new Set(['currentItem', 'currentIndex', 'collection', 'output', 'error']);
+/** The {@link CarriedLookup} over `scopes` — the flow being checked first, then its ancestors. */
+function carriedLookup(scopes) {
+    const all = scopes.flatMap((b) => b.definitions ?? []);
+    return Object.assign((typeName, version) => all.find((d) => d.nodeType === typeName && d.version === version), { versions: (typeName) => [...new Set(all.filter((d) => d.nodeType === typeName).map((d) => String(d.version)))] });
+}
 /** The registered node type for a spec's kind, or undefined (a custom FlowAction has no kind). */
 function registeredKind(spec) {
     const kind = spec?.kind;
@@ -3994,14 +3999,15 @@ function registeredKind(spec) {
  * which serialize enforces (#942) and the type's tests pin; an author cannot
  * cause the gap, so there is no author diagnostic to report.
  */
-function checkRegisteredStep(entry, s, exprs, errorSource, opts, diags, typeOf, triggerId) {
+function checkRegisteredStep(entry, s, exprs, errorSource, opts, diags, typeOf, triggerId, carried) {
     const spec = s.spec;
     /** The step's node-local rules and expressions, as `impl` defines them. */
-    const runRules = (impl) => {
+    const runRules = (impl, version = impl.version, carriedDef) => {
         const ctx = {
             step: s.name,
-            version: impl.version,
-            definition: () => bundledDefinition(impl.typeName, impl.version),
+            // At a carried version, the version and definition serialize emits.
+            version,
+            definition: () => carriedDef ?? bundledDefinition(impl.typeName, impl.version),
             report: (code, message, suggestion) => diags.push(catalogued(entry, s.name, code, message, suggestion)),
             declaredRef: (js) => {
                 const name = declaredRefName(js, triggerId);
@@ -4024,8 +4030,14 @@ function checkRegisteredStep(entry, s, exprs, errorSource, opts, diags, typeOf,
         return ctx;
     };
     let impl;
+    let version;
+    let carriedDef;
     try {
-        impl = resolveVersion(entry.type, spec, s.options?.version, `step "${s.name}"`);
+        // A pin the registry lacks but the flow carries resolves (#1128), as in serialize.
+        const resolved = resolveVersionCarried(entry.type, spec, s.options?.version, `step "${s.name}"`, carried);
+        impl = resolved.impl;
+        version = resolved.version;
+        carriedDef = resolved.carried;
     }
     catch (e) {
         // A select() that picks an unregistered version is the node type's bug, not the author's pin.
@@ -4043,8 +4055,14 @@ function checkRegisteredStep(entry, s, exprs, errorSource, opts, diags, typeOf,
             checked: { entry, impl: fallback, spec, placement: { step: s.name, kind: fallback.kind, spec, version: fallback.version }, ctx: fallbackCtx },
         };
     }
-    const ctx = runRules(impl);
-    return { placed: true, checked: { entry, impl, spec, placement: { step: s.name, kind: impl.kind, spec, version: impl.version }, ctx } };
+    const ctx = runRules(impl, version, carriedDef);
+    return {
+        placed: true,
+        checked: {
+            entry, impl, spec, placement: { step: s.name, kind: impl.kind, spec, version }, ctx,
+            ...(carriedDef !== undefined ? { carried: carriedDef } : {}),
+        },
+    };
 }
 /** Every non-literal Expr reachable in `value`, as expressions to check. */
 function pushDeepExprs(value, step, errorSource, out) {
@@ -4171,7 +4189,7 @@ const ERROR_ENVELOPE_FIELDS = ['code', 'message', 'detail', 'category', 'status'
  */
 function checkOnError(_handler, step, diags, 
 /** The step's registry record, when its kind is registered and its version resolved. */
-placed) {
+placed, carried) {
     // The builder refuses a handler with no eligible step before it, so a missing
     // source here means a hand-built `BuiltFlow`; there is nothing to say about it.
     if (!step)
@@ -4243,7 +4261,7 @@ placed) {
             }
         }
         else {
-            const def = bundledDefinition(impl.typeName, impl.version);
+            const def = placed.carried ?? bundledDefinition(impl.typeName, impl.version);
             if (def !== undefined && !definitionHasErrorPort(def)) {
                 diags.push({ level: 'error', code: 'ONERROR_NO_ERROR_PORT', message: typedNoErrorPortMessage(step.name, impl.kind, def), step: step.name });
                 return;
@@ -4262,7 +4280,12 @@ placed) {
     // A version the SDK does not bundle (an inline agent's registry version) has
     // no definition here to ask; version resolution reports that, not this check.
     const bundledType = bundledActionNodeType(spec);
-    const bundledDef = bundledType ? bundledDefinition(bundledType, actionVersion(spec, step.options?.version)) : undefined;
+    // A version the flow CARRIES (`.definitions()`, #1128) answers the same way
+    // a bundled one does: it is the definition serialize will emit.
+    const pinned = step.options?.version;
+    const bundledDef = bundledType
+        ? bundledDefinition(bundledType, actionVersion(spec, pinned)) ?? (pinned !== undefined ? carried?.(bundledType, pinned) : undefined)
+        : undefined;
     // A per-tenant family: ask the definition serialize synthesizes for it (#1040).
     let perCallDef;
     if (!bundledType) {

package/dist/core/carried-definitions.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Node definitions a flow CARRIES — the third source a pinned `{ version }`
+ * resolves from, after the SDK's bundle (#1128).
+ *
+ * Every `.flow` file holds the exact definition of every node it uses, in
+ * `definitions[]`. The SDK bundles only the versions it was released with, so
+ * a version the registry served later (`node add` writes
+ * `uipath.human-in-the-loop.quick-form@1.6`; the SDK ships 1.0 and 1.1) used
+ * to be refused, and the source decompile wrote for an untouched product flow
+ * did not compile. A carried definition closes that: decompile copies the
+ * file's own entry into `.definitions([...])`, and compile resolves the pin
+ * against it.
+ *
+ * A carried definition is an exact copy of a real one, never a way to invent a
+ * version. So it is validated the way a `rawNode` snapshot manifest is: it
+ * names its own `nodeType` and `version`, and it has the `display.label` every
+ * node manifest has.
+ */
+/** A carried definition, by its `<nodeType>@<version>` key. */
+export type CarriedDefinitions = ReadonlyMap<string, Record<string, unknown>>;
+/**
+ * Why `manifest` cannot be carried, or `undefined` when it can.
+ *
+ * For instance `{ nodeType: 'x', version: '1.0' }` is refused for lacking
+ * `display.label`.
+ */
+export declare function carriedDefinitionRefusal(manifest: unknown, where: string): string | undefined;
+/**
+ * Index `manifests` by `<nodeType>@<version>`. Throws on an invalid manifest,
+ * or on two different manifests for one pair (which one compiles would be a
+ * guess).
+ */
+export declare function indexCarriedDefinitions(manifests: readonly unknown[], where: string, into?: Map<string, Record<string, unknown>>): Map<string, Record<string, unknown>>;

package/dist/core/carried-definitions.js

@@ -0,0 +1,63 @@
+/**
+ * Node definitions a flow CARRIES — the third source a pinned `{ version }`
+ * resolves from, after the SDK's bundle (#1128).
+ *
+ * Every `.flow` file holds the exact definition of every node it uses, in
+ * `definitions[]`. The SDK bundles only the versions it was released with, so
+ * a version the registry served later (`node add` writes
+ * `uipath.human-in-the-loop.quick-form@1.6`; the SDK ships 1.0 and 1.1) used
+ * to be refused, and the source decompile wrote for an untouched product flow
+ * did not compile. A carried definition closes that: decompile copies the
+ * file's own entry into `.definitions([...])`, and compile resolves the pin
+ * against it.
+ *
+ * A carried definition is an exact copy of a real one, never a way to invent a
+ * version. So it is validated the way a `rawNode` snapshot manifest is: it
+ * names its own `nodeType` and `version`, and it has the `display.label` every
+ * node manifest has.
+ */
+/**
+ * Why `manifest` cannot be carried, or `undefined` when it can.
+ *
+ * For instance `{ nodeType: 'x', version: '1.0' }` is refused for lacking
+ * `display.label`.
+ */
+export function carriedDefinitionRefusal(manifest, where) {
+    if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) {
+        return `${where}: a carried definition must be a node manifest object.`;
+    }
+    const m = manifest;
+    if (typeof m.nodeType !== 'string' || !m.nodeType || typeof m.version !== 'string' || !m.version) {
+        return `${where}: a carried definition must name its exact nodeType and version.`;
+    }
+    if (typeof m.display?.label !== 'string' || !m.display.label) {
+        return `${where}: the carried definition ${m.nodeType}@${m.version} lacks display.label — not a valid node manifest.`;
+    }
+    return undefined;
+}
+/**
+ * Index `manifests` by `<nodeType>@<version>`. Throws on an invalid manifest,
+ * or on two different manifests for one pair (which one compiles would be a
+ * guess).
+ */
+export function indexCarriedDefinitions(manifests, where, into = new Map()) {
+    for (const m of manifests) {
+        const refusal = carriedDefinitionRefusal(m, where);
+        if (refusal)
+            throw new Error(refusal);
+        const def = m;
+        const key = `${def.nodeType}@${def.version}`;
+        const prior = into.get(key);
+        if (prior !== undefined && stableJson(prior) !== stableJson(def)) {
+            throw new Error(`${where}: two different carried definitions for ${key}. Keep the one the file holds.`);
+        }
+        into.set(key, def);
+    }
+    return into;
+}
+/** `JSON.stringify` with object keys sorted, so two copies of one manifest compare equal whatever their key order. */
+function stableJson(value) {
+    return JSON.stringify(value, (_key, v) => (v && typeof v === 'object' && !Array.isArray(v)
+        ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, v[k]]))
+        : v));
+}

package/dist/core/nodes/versioned.d.ts

@@ -48,3 +48,38 @@ export declare function asVersioned<Ctx extends ArtifactContexts>(t: AnyNodeType
  * node type's bug, not the author's, and throws as an internal SDK error.
  */
 export declare function resolveVersion<Spec, Ctx extends ArtifactContexts>(t: VersionedNodeType<Spec, unknown, Ctx>, spec: Spec, requested: string | undefined, where: string): NodeType<Spec, unknown, Ctx>;
+/**
+ * Looks up a definition the flow carries (`.definitions()`) for `typeName@version`.
+ * `versions`, when present, lists every version of `typeName` the flow carries,
+ * so a refusal can name them.
+ */
+export type CarriedDefinitionLookup = ((typeName: string, version: string) => Record<string, unknown> | undefined) & {
+    readonly versions?: (typeName: string) => readonly string[];
+};
+/** What {@link resolveVersionCarried} resolved: the implementation, the version to emit, and a carried definition when one answered. */
+export interface ResolvedNodeVersion<Impl> {
+    readonly impl: Impl;
+    /** The version the node is emitted at — `impl.version`, or the carried version. */
+    readonly version: string;
+    /** The definition the FLOW carries for `typeName@version`, when the registry has no implementation at that version. */
+    readonly carried?: Record<string, unknown>;
+}
+/**
+ * {@link resolveVersion} with the third definition source (#1128): a definition
+ * the flow CARRIES (`.definitions()`, decompile's copy of the file's own
+ * `definitions[]` entry).
+ *
+ * Order: a registered version resolves as before. An explicit version the type
+ * does not register, but the flow carries, is emitted AT that version with the
+ * carried definition, through the implementation the type would use unpinned
+ * (`select(spec)`, else the default) — the registry has no implementation of
+ * its own for it, and the node keeps the version the file pins instead of being
+ * refused. Anything else is refused as {@link resolveVersion} refuses it, except
+ * that an unregistered pin also names the versions the flow carries and the
+ * `.definitions()` remedy.
+ *
+ * For instance a file pinning `core.action.script@1.0` (registered: 1.0.0, 1.1)
+ * and carrying that definition emits the node at 1.0 through the default
+ * implementation.
+ */
+export declare function resolveVersionCarried<Spec, Ctx extends ArtifactContexts>(t: VersionedNodeType<Spec, unknown, Ctx>, spec: Spec, requested: string | undefined, where: string, carried: CarriedDefinitionLookup | undefined): ResolvedNodeVersion<NodeType<Spec, unknown, Ctx>>;

package/dist/core/nodes/versioned.js

@@ -44,3 +44,38 @@ export function resolveVersion(t, spec, requested, where) {
     }
     return impl;
 }
+/**
+ * {@link resolveVersion} with the third definition source (#1128): a definition
+ * the flow CARRIES (`.definitions()`, decompile's copy of the file's own
+ * `definitions[]` entry).
+ *
+ * Order: a registered version resolves as before. An explicit version the type
+ * does not register, but the flow carries, is emitted AT that version with the
+ * carried definition, through the implementation the type would use unpinned
+ * (`select(spec)`, else the default) — the registry has no implementation of
+ * its own for it, and the node keeps the version the file pins instead of being
+ * refused. Anything else is refused as {@link resolveVersion} refuses it, except
+ * that an unregistered pin also names the versions the flow carries and the
+ * `.definitions()` remedy.
+ *
+ * For instance a file pinning `core.action.script@1.0` (registered: 1.0.0, 1.1)
+ * and carrying that definition emits the node at 1.0 through the default
+ * implementation.
+ */
+export function resolveVersionCarried(t, spec, requested, where, carried) {
+    if (requested !== undefined && !ownEntry(t.versions, requested)) {
+        const def = carried?.(t.typeName, requested);
+        if (def !== undefined) {
+            return { impl: resolveVersion(t, spec, undefined, where), version: requested, carried: def };
+        }
+        // Refused: name both sources, and the way to add the second one.
+        const registered = Object.keys(t.versions).sort().join(', ');
+        const carriedVersions = [...(carried?.versions?.(t.typeName) ?? [])].sort();
+        throw new Error(`${where} requests ${t.typeName}@${requested}, but this SDK registers only ${registered}`
+            + (carriedVersions.length > 0 ? ` and the flow carries only ${carriedVersions.join(', ')}` : '')
+            + '. Versions are exact — omit { version } to use the default, request one listed here, or carry '
+            + "that version's definition (the .flow file's definitions[] entry) with .definitions([...]).");
+    }
+    const impl = resolveVersion(t, spec, requested, where);
+    return { impl, version: impl.version };
+}

package/dist/decompile.js

@@ -83,6 +83,13 @@ let runDefs = new Map();
  * agent that has to edit the file next.
  */
 let runRawManifests = [];
+/**
+ * The file's definitions for pinned pairs this SDK cannot resolve, by
+ * `<type>@<version>` → hoisted const name (#1128). Emitted once, in
+ * `.definitions([...])`, so compile resolves the pin against the file's own
+ * definition and the node keeps its version even when the author edits it.
+ */
+let runCarried = new Map();
 let runStrict = false;
 /** `DecompileOptions.warn` for the current run, and the messages already sent to it (one line per finding). */
 let runWarn;
@@ -131,22 +138,21 @@ function verClause(node) {
                 + `the file's definitions[] disagrees with the instance.`);
         }
     }
-    // A pin the SDK cannot resolve: `serialize` resolves an explicit { version }
-    // exactly (design §2.6) — a registered type against its registered versions,
-    // any other type against the bundle. Keeping that pin would emit source
-    // `compile` refuses (#1128: quick-form@1.6 from `node add`, @1.4 from
-    // `migrate`, script@1.0 from a pre-migrate file), so the source omits it: the
-    // node compiles at the SDK's default, and `merge --baseline` keeps the
-    // UNTOUCHED original node, with its own version and definition, verbatim
-    // (`nodeUnchanged` ignores typeVersion). Interim: a node the author EDITS is
-    // re-emitted at the default — the root fix is for compile to accept the
-    // definition the file carries.
+    // A pin the SDK cannot resolve (design §2.6: exact, against the registered
+    // or bundled versions) is kept when the file carries that pair's definition:
+    // `.definitions([...])` hands it to compile (#1128). With no definition to
+    // carry, keeping the pin would emit source `compile` refuses, so the source
+    // omits it: the node compiles at the SDK's default, and `merge --baseline`
+    // keeps the UNTOUCHED original node verbatim (`nodeUnchanged` ignores
+    // typeVersion).
     //
     // A type with no SDK-known version at all (a connector, a published-resource
     // `uipath.core.*` node, a rawNode) resolves its version elsewhere, so its pin
     // is kept.
+    if (runCarried.has(`${node.type}@${tv}`))
+        return `version: ${tsLiteral(tv)}`;
     const registered = FLOW_NODE_TYPES.byTypeName(node.type);
-    const shipped = registered ? Object.keys(registered.type.versions) : bundledVersions(node.type);
+    const shipped = shippedVersions(node.type);
     if (shipped.length > 0 && !shipped.includes(tv)) {
         const known = `${node.type}@${shipped.join(', ')}`;
         if (runStrict) {
@@ -161,6 +167,15 @@ function verClause(node) {
     }
     return `version: ${tsLiteral(tv)}`;
 }
+/**
+ * The versions this SDK resolves a `{ version }` of `type` against: a
+ * registered type's registered versions, any other type's bundled ones; `[]`
+ * for a type it ships at no version (a connector, a published resource).
+ */
+function shippedVersions(type) {
+    const registered = FLOW_NODE_TYPES.byTypeName(type);
+    return registered ? Object.keys(registered.type.versions) : bundledVersions(type);
+}
 function verArg(node) {
     const clause = verClause(node);
     return clause ? `, { ${clause} }` : '';
@@ -1494,6 +1509,92 @@ function unsupportedSpec(node, imp, o) {
     // is a safe structural stand-in, and the marker records what it replaced.
     return `${imp.use('mock')}() /* TODO: unsupported node type ${commentText(node.type)} */`;
 }
+/**
+ * Every pinned `<type>@<version>` in the file (root and subflows) that this SDK
+ * cannot resolve, for a type it ships at some version, and that the file's
+ * `definitions[]` holds — mapped to the const name decompile hoists the
+ * definition under. For instance a quick-form node at 1.6 maps
+ * `uipath.human-in-the-loop.quick-form@1.6` → `quickFormV1_6Definition`.
+ */
+function carriedPairs(flow) {
+    const out = new Map();
+    const taken = new Set();
+    const scopes = [flow.nodes ?? [], ...Object.values(flow.subflows ?? {}).map((sf) => sf?.nodes ?? [])];
+    for (const n of scopes.flat()) {
+        const key = `${n.type}@${n.typeVersion}`;
+        if (!n.typeVersion || out.has(key) || !runDefs.has(key))
+            continue;
+        const shipped = shippedVersions(n.type);
+        if (shipped.length === 0 || shipped.includes(n.typeVersion))
+            continue;
+        const base = `${camel(String(n.type).split('.').pop() ?? 'node')}V${String(n.typeVersion).replace(/[^A-Za-z0-9]+/g, '_')}Definition`;
+        let name = base;
+        for (let i = 2; taken.has(name); i++)
+            name = `${base}${i}`;
+        taken.add(name);
+        out.set(key, name);
+        warnCarriedInputDrift(n, runDefs.get(key));
+    }
+    return out;
+}
+/**
+ * The input names a definition declares: its `inputDefaults` keys and the
+ * top-level `inputs.<name>` its form fields edit. For instance quick-form@1.1
+ * gives `recipient, schema`.
+ */
+function definitionInputNames(def) {
+    const names = new Set(Object.keys(def?.inputDefaults ?? {}));
+    const visit = (v) => {
+        if (Array.isArray(v)) {
+            v.forEach(visit);
+            return;
+        }
+        if (!v || typeof v !== 'object')
+            return;
+        const field = v.name;
+        if (typeof field === 'string' && field.startsWith('inputs.'))
+            names.add(field.slice('inputs.'.length).split(/[.[]/)[0]);
+        for (const child of Object.values(v))
+            visit(child);
+    };
+    visit(def?.form);
+    return [...names].sort();
+}
+/** Compare two dotted versions numerically: `1.10` sorts after `1.9`. */
+function compareVersions(a, b) {
+    const pa = a.split('.').map(Number);
+    const pb = b.split('.').map(Number);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
+/**
+ * Warn when a carried definition's inputs differ from the nearest version the
+ * SDK ships (the highest one below the carried version, else the lowest). An
+ * edited node keeps the file's pin, but its inputs are rebuilt in the SDK's
+ * shape, so a renamed input would be written under the wrong name. For
+ * instance `node "review1" keeps quick-form@1.6 ...; its inputs differ from
+ * 1.1 (assignee)`.
+ */
+function warnCarriedInputDrift(node, carried) {
+    const versions = shippedVersions(node.type).filter((v) => BUNDLED_DEFINITIONS[`${node.type}@${v}`]).sort(compareVersions);
+    const below = versions.filter((v) => compareVersions(v, String(node.typeVersion)) < 0);
+    const nearest = below.length > 0 ? below[below.length - 1] : versions[0];
+    if (nearest === undefined)
+        return;
+    const shipped = BUNDLED_DEFINITIONS[`${node.type}@${nearest}`];
+    const factoryVersion = nearest;
+    const a = definitionInputNames(carried);
+    const b = definitionInputNames(shipped);
+    const differ = [...a.filter((x) => !b.includes(x)), ...b.filter((x) => !a.includes(x))].sort();
+    if (differ.length === 0)
+        return;
+    warnOnce(`node ${tsLiteral(node.id)} keeps ${node.type}@${node.typeVersion} from the file's definitions[]; its inputs differ from `
+        + `${factoryVersion} (${differ.join(', ')}), so an edit to it may need rawNode.`);
+}
 /** `some-node.id` → `someNodeId`, for a hoisted const name. */
 function camel(id) {
     const parts = String(id).split(/[^A-Za-z0-9]+/).filter(Boolean);
@@ -2923,6 +3024,7 @@ export function decompile(flow, options = {}) {
         if (!runDefs.has(d.nodeType))
             runDefs.set(d.nodeType, d);
     }
+    runCarried = carriedPairs(flow);
     const imp = new Imports();
     const graph = new Graph(flow.nodes ?? [], flow.edges ?? []);
     const globals = readFlowGlobals(flow.variables, runStrict);
@@ -2956,6 +3058,8 @@ export function decompile(flow, options = {}) {
     if (typeof flow.description === 'string') {
         e.line(d, `.description(${tsLiteral(flow.description)})`);
     }
+    if (runCarried.size > 0)
+        e.line(d, `.definitions([${[...runCarried.values()].join(', ')}])`);
     // Trigger nodes. One root is the default: the isDefaultEntryPoint carrier
     // when the file marks one (a multi-root flow always does), else `start`.
     // A node's TYPE is not enough: `uipath.connector.event.<key>.<event>` is a
@@ -3042,7 +3146,8 @@ export function decompile(flow, options = {}) {
     const lay = layoutSeg(flow, (flow.nodes ?? []).filter((n) => !detachedIds.has(n.id)), (flow.edges ?? []).filter((edge) => !detachedIds.has(edge.sourceNodeId) && !detachedIds.has(edge.targetNodeId)));
     const layout = lay ? reindent(lay, '  ') : '';
     const chain = [header, eps, body, sticky, layout, '  .build();'].filter((s) => s.length > 0).join('\n');
-    const hoisted = runRawManifests
+    const carriedConsts = [...runCarried].map(([key, name]) => [name, JSON.stringify(runDefs.get(key), null, 2)]);
+    const hoisted = [...carriedConsts, ...runRawManifests]
         .map(([name, json]) => `const ${name} = ${json};`)
         .join('\n\n');
     return [imp.line(importSpecifier), hoisted, chain].filter((p) => p.length > 0).join('\n\n') + '\n';

package/dist/flow-node-type.d.ts

@@ -97,7 +97,12 @@ export interface FlowSerializeContext {
     bind(entry: {
         readonly id: string;
     } & Readonly<Record<string, unknown>>): void;
-    /** The bundled definition `<typeName>@<version>`, or undefined when the SDK does not ship it. */
+    /**
+     * The bundled definition `<typeName>@<version>`, else one the flow carries;
+     * undefined when neither exists. When the node is emitted at a carried
+     * version, asking for its own type answers with that carried definition at
+     * any `version`, so a type's defaults follow the file's definition.
+     */
     definition(typeName: string, version: string): unknown;
     /**
      * The flow's bindings so far, by id — read-only. For a type that SHARES a
@@ -186,8 +191,8 @@ export interface FlowCheckContext {
     /** The version the node will be emitted at. */
     readonly version: string;
     /**
-     * The SDK's bundled definition of this step's node type at `version` (the one
-     * serialize emits from), or undefined when the SDK does not ship it.
+     * The definition serialize emits this step from: the one the flow carries at
+     * a carried version, else the SDK's bundled one; undefined when neither exists.
      */
     definition(): unknown;
     /** Report a diagnostic on this step. Its severity is the family catalog's for `code`. */

package/dist/flow-sdk.d.ts

@@ -731,6 +731,12 @@ export interface BuiltFlow {
     layout?: FlowLayout;
     /** Canvas sticky notes from `.stickyNotes()`. Inert annotations. */
     stickyNotes?: StickyNote[];
+    /**
+     * Node definitions the flow carries, from `.definitions()`: exact manifests a
+     * pinned `{ version }` resolves against when the SDK does not bundle that
+     * version.
+     */
+    definitions?: Record<string, unknown>[];
     /** Additional roots from `.entryPoint()`. The default root stays `.trigger()`/`.input()`. */
     entryPoints?: BuiltEntryPoint[];
     /**
@@ -1216,6 +1222,7 @@ declare class FlowBuilder extends StepList {
     private _stickyNotes?;
     private _version;
     private _schemaVersion?;
+    private _definitions;
     private _inputs;
     private _outputs;
     private _vars;
@@ -1423,6 +1430,47 @@ declare class FlowBuilder extends StepList {
      * @defaultValue `'1.9'` — `FLOW_FORMAT_PROFILE.version`, the fleet write floor.
      */
     schemaVersion(version: string): this;
+    /**
+     * Carry node definitions this SDK does not bundle, so a `{ version }` pin on
+     * one of those versions compiles.
+     *
+     * @remarks
+     * A pinned `{ version }` resolves exactly (design §2.6): first against the
+     * definitions the SDK was released with, then against the ones carried here.
+     * Nothing else changes — an unpinned node still takes the SDK's default, and
+     * a bundled version still compiles from the bundle.
+     *
+     * Its job is BROWNFIELD PRESERVATION. A `.flow` file holds the exact
+     * definition of every node it uses, but the registry moves faster than an SDK
+     * release: `uip maestro flow node add` writes
+     * `uipath.human-in-the-loop.quick-form@1.6` while this SDK bundles 1.0 and
+     * 1.1. `flow-decompile` copies the file's own entry into this call for each
+     * such pair, so the decompiled source compiles unedited and a node you edit
+     * keeps the file's version instead of moving to the SDK's.
+     *
+     * Each manifest must be an exact copy of one the platform served (from the
+     * file's `definitions[]`, or `uip maestro flow registry get`): it names its
+     * `nodeType` and `version`, and has a `display.label`. The SDK still emits
+     * the node's inputs from its own factory, so a version whose inputs differ
+     * from the SDK's shape needs `rawNode` instead.
+     *
+     * @example
+     * **Keep a quick-form task at the version the file pins**
+     * ```ts
+     * // The .flow file's whole definitions[] entry for quick-form@1.6 (or
+     * // `uip maestro flow registry get`), copied verbatim, as flow-decompile hoists it.
+     * // A stub with only nodeType/version/display passes validation but breaks the canvas.
+     * declare const quickFormV1_6Definition: Record<string, unknown>;
+     * flow('review')
+     *   .definitions([quickFormV1_6Definition])
+     *   .step('review', hitl({ variant: 'quick-form', fields: [], outcomes: ['Submit'] }), { version: '1.6' });
+     * ```
+     *
+     * @param manifests - Node manifests, each with its own `nodeType`, `version` and `display.label`.
+     * @returns This builder, so calls chain.
+     * @throws Error when a manifest is not a node manifest, or two differ for one `nodeType@version`.
+     */
+    definitions(manifests: readonly Record<string, unknown>[]): this;
     /**
      * Declare the flow's inputs. Read them with `input('<name>')`.
      *

package/dist/flow-sdk.js

@@ -45,6 +45,7 @@ import { builtinActionSpec, builtinTriggerSpec, subscriptionFrom } from './core/
 import { checkFlowExpressions, FlowBuildError } from './flow-expr-check.js';
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { schemaVersionRefusal } from './schema-version.js';
+import { indexCarriedDefinitions } from './core/carried-definitions.js';
 export { FlowBuildError, checkFlowExpressions } from './flow-expr-check.js';
 const TYPE_NAMES = Object.values(types);
 /**
@@ -881,6 +882,7 @@ class FlowBuilder extends StepList {
     _stickyNotes;
     _version = '1.0.0';
     _schemaVersion;
+    _definitions = [];
     _inputs = [];
     _outputs = [];
     _vars = [];
@@ -1144,6 +1146,52 @@ class FlowBuilder extends StepList {
         this._schemaVersion = version;
         return this;
     }
+    /**
+     * Carry node definitions this SDK does not bundle, so a `{ version }` pin on
+     * one of those versions compiles.
+     *
+     * @remarks
+     * A pinned `{ version }` resolves exactly (design §2.6): first against the
+     * definitions the SDK was released with, then against the ones carried here.
+     * Nothing else changes — an unpinned node still takes the SDK's default, and
+     * a bundled version still compiles from the bundle.
+     *
+     * Its job is BROWNFIELD PRESERVATION. A `.flow` file holds the exact
+     * definition of every node it uses, but the registry moves faster than an SDK
+     * release: `uip maestro flow node add` writes
+     * `uipath.human-in-the-loop.quick-form@1.6` while this SDK bundles 1.0 and
+     * 1.1. `flow-decompile` copies the file's own entry into this call for each
+     * such pair, so the decompiled source compiles unedited and a node you edit
+     * keeps the file's version instead of moving to the SDK's.
+     *
+     * Each manifest must be an exact copy of one the platform served (from the
+     * file's `definitions[]`, or `uip maestro flow registry get`): it names its
+     * `nodeType` and `version`, and has a `display.label`. The SDK still emits
+     * the node's inputs from its own factory, so a version whose inputs differ
+     * from the SDK's shape needs `rawNode` instead.
+     *
+     * @example
+     * **Keep a quick-form task at the version the file pins**
+     * ```ts
+     * // The .flow file's whole definitions[] entry for quick-form@1.6 (or
+     * // `uip maestro flow registry get`), copied verbatim, as flow-decompile hoists it.
+     * // A stub with only nodeType/version/display passes validation but breaks the canvas.
+     * declare const quickFormV1_6Definition: Record<string, unknown>;
+     * flow('review')
+     *   .definitions([quickFormV1_6Definition])
+     *   .step('review', hitl({ variant: 'quick-form', fields: [], outcomes: ['Submit'] }), { version: '1.6' });
+     * ```
+     *
+     * @param manifests - Node manifests, each with its own `nodeType`, `version` and `display.label`.
+     * @returns This builder, so calls chain.
+     * @throws Error when a manifest is not a node manifest, or two differ for one `nodeType@version`.
+     */
+    definitions(manifests) {
+        const known = indexCarriedDefinitions(this._definitions, 'definitions()');
+        indexCarriedDefinitions(manifests, 'definitions()', known);
+        this._definitions = [...known.values()];
+        return this;
+    }
     /**
      * Declare the flow's inputs. Read them with `input('<name>')`.
      *
@@ -1234,6 +1282,7 @@ class FlowBuilder extends StepList {
             ...(this._stickyNotes !== undefined ? { stickyNotes: this._stickyNotes } : {}),
             version: this._version,
             ...(this._schemaVersion !== undefined ? { schemaVersion: this._schemaVersion } : {}),
+            ...(this._definitions.length ? { definitions: this._definitions } : {}),
             inputs: this._inputs,
             outputs: this._outputs,
             vars: this._vars,

package/dist/merge.js

@@ -142,7 +142,8 @@ export function mergeFlow(original, edited, options = {}) {
             finalNodes.push(withOriginalLayout(jsonClone(e), orig, layoutNodesOf(original)));
             if (orig && orig.type === e.type && orig.typeVersion !== e.typeVersion) {
                 options.warn?.(`node ${JSON.stringify(e.id)} moved ${e.type}@${String(orig.typeVersion)} -> ${String(e.typeVersion)} `
-                    + `(the edited node takes the SDK's version; flow-builder-sdk#1167).`);
+                    + `(the edited source does not pin ${String(orig.typeVersion)}; keep the { version } pin, `
+                    + `with .definitions([...]) when the SDK does not bundle that version).`);
             }
         }
     }

package/dist/serialize.js

@@ -19,7 +19,8 @@ import { planContributionBindings } from './core/contribution-bindings.js';
 import { declaredErrorPortRefusal, definitionHasErrorPort, errorPortRefusal } from './core/error-port.js';
 import { FLOW_NODE_TYPES } from './flow-node-registry.js';
 import { stepExits } from './flow-step-exits.js';
-import { resolveVersion } from './core/nodes/versioned.js';
+import { resolveVersionCarried } from './core/nodes/versioned.js';
+import { indexCarriedDefinitions } from './core/carried-definitions.js';
 import { FORM_FIELD_JSON_TYPE } from './core/form-field-type.js';
 import { connectionConnectors } from './bindings-v2.js';
 import { BindingRefusal, GUID_RE, bindingLabelRefusal, bindingMissingMessage, missingBindingLabels } from './core/binding-messages.js';
@@ -2271,8 +2272,8 @@ function declaresMemoryHandle(def) {
  * compiles. The corpus also carries 1.1 and 1.3; `shared/sample-flows/
  * inline-agent.flow` says 1.0, which appears in none of the 29.
  */
-function inlineAgentDef(version, withMemory) {
-    const bundled = DEFS[`${INLINE_AGENT_TYPE}@${version}`];
+function inlineAgentDef(version, withMemory, resolve = (t, v) => DEFS[`${t}@${v}`]) {
+    const bundled = resolve(INLINE_AGENT_TYPE, version);
     if (!bundled)
         return undefined;
     const def = jsonClone(bundled);
@@ -4240,6 +4241,17 @@ function stepNamesOf(steps, out = []) {
     return out;
 }
 export function serialize(built, opts = {}) {
+    /**
+     * Definitions the flow carries (`.definitions()`, #1128), by `type@version` —
+     * the third source a pinned `{ version }` resolves from, after the bundle and
+     * the node-type registry. A flow that carries nothing compiles exactly as
+     * before. A subflow body sees its own carried definitions plus its
+     * ancestors' (as `check` does), only while it is emitted.
+     */
+    let carriedDefs = indexCarriedDefinitions(built.definitions ?? [], `flow "${built.id}" .definitions()`);
+    const carriedFor = Object.assign((type, version) => carriedDefs.get(`${type}@${version}`), { versions: (type) => [...carriedDefs.keys()].filter((k) => k.startsWith(`${type}@`)).map((k) => k.slice(type.length + 1)) });
+    /** The exact definition of `type@version`: bundled, else carried, else `undefined`. */
+    const definitionFor = (type, version) => DEFS[`${type}@${version}`] ?? carriedFor(type, version);
     /**
      * The `definitions[]` a flow carries, keyed by `type@version` — NOT by type.
      * One flow can legitimately hold two versions of the same family (a plain
@@ -4451,19 +4463,22 @@ export function serialize(built, opts = {}) {
     function makeNode(type, id, label, o = {}) {
         let def = o.def ?? defByType.get(type);
         if (o.requestedVersion !== undefined && def?.version !== o.requestedVersion) {
-            const exact = o.def ? undefined : DEFS[`${type}@${o.requestedVersion}`];
+            const exact = o.def ? undefined : definitionFor(type, o.requestedVersion);
             if (!exact) {
-                // Name every version the SDK could have resolved: every bundled
-                // version of the type, else (a type built per resource, a connector)
-                // the definition in hand. Naming only the default sent the reader
-                // looking for a version that was shipped all along (#1128:
+                // Name every version the SDK could have resolved: every bundled or
+                // carried version of the type, else (a type built per resource, a
+                // connector) the definition in hand. Naming only the default sent the
+                // reader looking for a version that was shipped all along (#1128:
                 // quick-form bundles 1.0 AND 1.1, and the message said 1.0).
-                const bundled = bundledVersions(type);
-                const resolvable = bundled.length > 0 ? bundled
+                const prefix = `${type}@`;
+                const carriedVersions = [...carriedDefs.keys()].filter((k) => k.startsWith(prefix)).map((k) => k.slice(prefix.length));
+                const known = o.def ? [] : [...bundledVersions(type), ...carriedVersions];
+                const resolvable = known.length > 0 ? known
                     : [def?.version].filter((v) => typeof v === 'string');
                 throw new Error(`"${label ?? id}" requests ${type}@${o.requestedVersion}, but this SDK resolves only `
                     + `${type}@${resolvable.join(', ') || '<none>'}. Versions are exact — omit { version } to use `
-                    + `the pinned default, or request a version this SDK ships.`);
+                    + `the pinned default, request a version this SDK ships, or carry that version's definition `
+                    + `(the .flow file's definitions[] entry) with .definitions([...]).`);
             }
             def = exact;
         }
@@ -4532,6 +4547,16 @@ export function serialize(built, opts = {}) {
      * a null. It is emitted here, always, so it cannot be forgotten.
      */
     function emitSubflowBody(child, nodeId) {
+        const outer = carriedDefs;
+        carriedDefs = indexCarriedDefinitions(child.definitions ?? [], `subflow "${nodeId}" .definitions()`, new Map(outer));
+        try {
+            return emitSubflowBodyIn(child, nodeId);
+        }
+        finally {
+            carriedDefs = outer;
+        }
+    }
+    function emitSubflowBodyIn(child, nodeId) {
         const childGlobals = emittableGlobals(child, `subflow "${nodeId}"`, 'subflow');
         const scope = newScope(childGlobals.outputs, childGlobals.vars, childGlobals.backing, childGlobals.backingReads);
         // Claim this copy's node ids UP FRONT, so the rename map is complete before
@@ -4807,7 +4832,11 @@ export function serialize(built, opts = {}) {
     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);
+        // A pin the registry has no implementation for, but the flow carries, is
+        // emitted at that version with the carried definition (#1128).
+        const resolved = resolveVersionCarried(entry.type, spec, step.options?.version, where, carriedFor);
+        const impl = resolved.impl;
+        const version = resolved.version;
         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.
@@ -4817,14 +4846,19 @@ export function serialize(built, opts = {}) {
             step: step.name,
             nodeId: id,
             flowId: built.id,
-            version: impl.version,
+            version,
             pinnedVersion: step.options?.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),
+            // At a carried version the node's own definition IS the carried one,
+            // whatever version the implementation asks for (it was written for a
+            // bundled one), so its defaults and outputs come from the file's entry.
+            definition: (typeName, v) => (resolved.carried !== undefined && typeName === impl.typeName
+                ? resolved.carried
+                : bundledDefinition(typeName, v) ?? carriedFor(typeName, v)),
             bindings: resourceBindings,
             resolveBinding: (name, attribute, at) => resolveBinding(opts, name, attribute, at),
             bindConnection: (c) => {
@@ -4843,26 +4877,31 @@ export function serialize(built, opts = {}) {
         // 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;
+        let def = resolved.carried;
         if (impl.definition === 'bundled' && contribution.definition !== undefined) {
-            throw new Error(`internal SDK error: ${where}: bundled node type ${impl.typeName}@${impl.version} returned a definition; `
+            throw new Error(`internal SDK error: ${where}: bundled node type ${impl.typeName}@${version} returned a definition; `
                 + 'the bundle owns it — omit `definition`, or declare the type per-tenant.');
         }
+        // A per-tenant type builds its definition from `ctx.definition(type, version)`,
+        // which answers with the carried definition at a carried version, so the
+        // contribution's own definition wins: it is the carried template plus this
+        // instance's edits (a queue step's own resourceKey, for instance). Only a type
+        // that supplies none at a carried version takes the carried definition as is.
         if (contribution.definition !== undefined) {
-            def = resolveContributionDefinition(contribution.definition, impl.version, where);
+            def = resolveContributionDefinition(contribution.definition, 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.`);
+        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.`);
         }
         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, `
+                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: impl.version });
+            declaredErrorPorts.set(id, { port, typeName: impl.typeName, 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
@@ -4871,13 +4910,17 @@ export function serialize(built, opts = {}) {
         const exitPorts = new Set(exits && hasExits(exits) ? exits.map((e) => e.port) : []);
         for (const p of [...(contribution.port !== undefined ? [contribution.port] : []), ...(contribution.fanOut ?? []).map((f) => f.port)]) {
             if (exitPorts.has(p) || impl.derivesPort?.(spec, p)
-                || declaresForwardPort(def ?? bundledDefinition(impl.typeName, impl.version), p))
+                || declaresForwardPort(def ?? bundledDefinition(impl.typeName, version), p))
                 continue;
-            throw new Error(`internal SDK error: ${where}: node type ${impl.typeName}@${impl.version} leaves by port "${p}", `
+            throw new Error(`internal SDK error: ${where}: node type ${impl.typeName}@${version} leaves by port "${p}", `
                 + 'which its definition declares no source handle for, and the type neither lists as an exit nor derives.');
         }
+        // A carried definition answers the error-edge refusal as a bundled one does
+        // (makeNode records only the definitions it resolved itself).
+        if (resolved.carried !== undefined)
+            bundledNodeDefs.set(id, def ?? resolved.carried);
         return placeStepNode({
-            where, stepName: step.name, id, typeName: impl.typeName, requestedVersion: impl.version, def, contribution, bound, tails, scope, parentId,
+            where, stepName: step.name, id, typeName: impl.typeName, requestedVersion: version, def, contribution, bound, tails, scope, parentId,
             trackOutcomes: true,
         });
     }
@@ -5041,11 +5084,12 @@ export function serialize(built, opts = {}) {
             // agent attaches memory keeps the handle for all of them.
             const withMemory = s.memory !== undefined
                 || declaresMemoryHandle(emittedDefs.get(`${INLINE_AGENT_TYPE}@${version}`));
-            const def = inlineAgentDef(version, withMemory);
+            const def = inlineAgentDef(version, withMemory, definitionFor);
             if (!def) {
                 throw new Error(`"${step.name}" requests ${INLINE_AGENT_TYPE}@${version}, but this SDK resolves only `
                     + `${INLINE_AGENT_VERSIONS.map((v) => `${INLINE_AGENT_TYPE}@${v}`).join(', ')}. Versions are exact — `
-                    + `omit { version } to use the default (${INLINE_AGENT_DEFAULT_VERSION}), or request a version this SDK ships.`);
+                    + `omit { version } to use the default (${INLINE_AGENT_DEFAULT_VERSION}), request a version this SDK ships, `
+                    + `or carry that version's definition with .definitions([...]).`);
             }
             if (s.memory !== undefined && !declaresMemoryHandle(def)) {
                 throw new Error(`"${step.name}" attaches \`memory\`, but ${INLINE_AGENT_TYPE}@${version} declares no \`memory\` handle. `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.25.1",
+  "version": "6.26.0",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -92,5 +92,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "384f76113bc43067b5ec5ea700534e9611e664ff"
+  "gitref": "6f62b8136efeafdce6dde0429c7d98a59a4661d2"
 }