@uipath/maestro-builder-sdk 6.27.1 → 6.29.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:1224-1247` | Builders | The sub-builder an ARM callback receives — a `StepList` that can also name itself with `.label(...)`. |
+| `ArmBuilder` | class | `dist/flow-sdk.d.ts:1230-1253` | 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:719-731` | Supporting types | One additional flow root, built by `.entryPoint()`. |
-| `BuiltFlow` | interface | `dist/flow-sdk.d.ts:732-773` | Supporting types | 16 field(s) |
+| `BuiltFlow` | interface | `dist/flow-sdk.d.ts:732-779` | Supporting types | 17 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:1572-1587` | Flow construction | Start building a flow with the given id. |
+| `flow` | function | `dist/flow-sdk.d.ts:1618-1633` | 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:1248-1571` | Builders | 14 member(s) |
+| `FlowBuilder` | class | `dist/flow-sdk.d.ts:1254-1617` | Builders | 15 member(s) |
 | `FlowLayout` | interface | `dist/flow-sdk.d.ts:705-718` | 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:508-627` | Supporting types |  |
-| `StepList` | class | `dist/flow-sdk.d.ts:774-1223` | Builders | Collects a sequence of steps. |
+| `StepList` | class | `dist/flow-sdk.d.ts:780-1229` | Builders | Collects a sequence of steps. |
 | `STICKY_NOTE_COLORS` | const | `dist/flow-sdk.d.ts:658-663` | Flow construction | The designer's sticky-note palette. |
 | `StickyNote` | interface | `dist/flow-sdk.d.ts:670-704` | Supporting types | A canvas sticky note — free text pinned to the diagram, for the humans reading it. |
 | `StickyNoteColor` | type | `dist/flow-sdk.d.ts:664-669` | Supporting types | A sticky note's swatch. |
-| `subflow` | function | `dist/flow-sdk.d.ts:1588-1627` | Flow construction | Run another flow as one step, and read back what it returns. |
+| `subflow` | function | `dist/flow-sdk.d.ts:1634-1673` | 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 1116 rows — match one name in it, do not read it.**
+**A lookup table of 1118 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 — 1116 across
+Every field and method of every exported shape — 1118 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 1116 rows here.
+which is why its span is not repeated on all 1118 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:1236` |
+| `armLabel` | property | `ArmBuilder` | `dist/flow-sdk.d.ts:1242` |
 | `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:973-991` |
+| `branch` | method | `StepList` | `dist/flow-sdk.d.ts:979-997` |
 | `branches` | property | `HttpInputsBase` | `dist/nodes/http/flow/spec.d.ts:25-30` |
-| `break` | method | `StepList` | `dist/flow-sdk.d.ts:1108-1117` |
+| `break` | method | `StepList` | `dist/flow-sdk.d.ts:1114-1123` |
 | `breakEnabled` | property | `DoWhileOptions` | `dist/flow-sdk.d.ts:505-506` |
 | `breakEnabled` | property | `LoopOptions` | `dist/flow-sdk.d.ts:492-496` |
 | `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:1564-1570` |
+| `build` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1610-1616` |
 | `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:1118-1132` |
+| `continue` | method | `StepList` | `dist/flow-sdk.d.ts:1124-1138` |
 | `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` |
@@ -208,7 +208,7 @@ not find it either.
 | `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:758-763` |
-| `definitions` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1464-1504` |
+| `definitions` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1471-1511` |
 | `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` |
@@ -225,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:1273-1280` |
+| `description` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1280-1287` |
 | `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` |
@@ -267,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:1083-1107` |
+| `doWhile` | method | `StepList` | `dist/flow-sdk.d.ts:1089-1113` |
 | `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` |
@@ -291,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:1339-1389` |
+| `entryPoint` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1346-1396` |
 | `entryPointId` | property | `ProcessMetadata` | `dist/bpmn/bpmn-sdk.d.ts:534-539` |
 | `entryPoints` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:764-765` |
 | `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:782-807` |
+| `err` | method | `StepList` | `dist/flow-sdk.d.ts:788-813` |
 | `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` |
@@ -461,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:1505-1517` |
+| `input` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1551-1563` |
 | `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` |
@@ -534,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:1237-1246` |
+| `label` | method | `ArmBuilder` | `dist/flow-sdk.d.ts:1243-1252` |
 | `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` |
@@ -548,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:754-755` |
 | `layout` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1139-1159` |
-| `layout` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1281-1291` |
+| `layout` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1288-1298` |
 | `limit` | property | `DataFabricReadInputs` | `dist/nodes/data-fabric/flow/spec.d.ts:95-100` |
 | `limit` | property | `DoWhileOptions` | `dist/flow-sdk.d.ts:503-504` |
 | `literal` | property | `Expr` | `dist/core/expr.d.ts:18` |
@@ -558,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:1071-1082` |
+| `loop` | method | `StepList` | `dist/flow-sdk.d.ts:1077-1088` |
 | `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` |
@@ -647,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:1265-1272` |
+| `name` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1272-1279` |
 | `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` |
@@ -709,11 +709,13 @@ 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:862-922` |
+| `onError` | method | `StepList` | `dist/flow-sdk.d.ts:868-928` |
 | `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` |
 | `onTimer` | method | `ActivityBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3293-3301` |
+| `openTails` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:773-778` |
+| `openTails` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1512-1550` |
 | `operation` | property | `Aggregation` | `dist/nodes/transform/flow/spec.d.ts:37` |
 | `operation` | property | `ConnectorToolRef` | `dist/core/actions.d.ts:1230-1231` |
 | `operation` | property | `WaitConnectorPlaceholderSpec` | `dist/case/case-sdk.d.ts:368-369` |
@@ -727,7 +729,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:1518-1553` |
+| `output` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1564-1599` |
 | `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` |
@@ -763,7 +765,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:485-486` |
-| `parallel` | method | `StepList` | `dist/flow-sdk.d.ts:1035-1070` |
+| `parallel` | method | `StepList` | `dist/flow-sdk.d.ts:1041-1076` |
 | `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` |
@@ -862,7 +864,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:1213-1222` |
+| `return` | method | `StepList` | `dist/flow-sdk.d.ts:1219-1228` |
 | `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` |
@@ -903,7 +905,7 @@ not find it either.
 | `schemaVersion` | method | `BpmnBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3375-3404` |
 | `schemaVersion` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:738-744` |
 | `schemaVersion` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1068-1094` |
-| `schemaVersion` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1424-1463` |
+| `schemaVersion` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1431-1470` |
 | `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` |
@@ -975,16 +977,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:808-818` |
+| `step` | method | `StepList` | `dist/flow-sdk.d.ts:814-824` |
 | `steps` | property | `BuiltEntryPoint` | `dist/flow-sdk.d.ts:729-730` |
 | `steps` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:748` |
-| `steps` | property | `StepList` | `dist/flow-sdk.d.ts:776` |
-| `stepSwitch` | method | `StepList` | `dist/flow-sdk.d.ts:819-861` |
-| `stepToList` | method | `StepList` | `dist/flow-sdk.d.ts:936-964` |
-| `stepToRef` | method | `StepList` | `dist/flow-sdk.d.ts:1164-1192` |
-| `stepToRef` | method | `StepList` | `dist/flow-sdk.d.ts:1193-1212` |
+| `steps` | property | `StepList` | `dist/flow-sdk.d.ts:782` |
+| `stepSwitch` | method | `StepList` | `dist/flow-sdk.d.ts:825-867` |
+| `stepToList` | method | `StepList` | `dist/flow-sdk.d.ts:942-970` |
+| `stepToRef` | method | `StepList` | `dist/flow-sdk.d.ts:1170-1198` |
+| `stepToRef` | method | `StepList` | `dist/flow-sdk.d.ts:1199-1218` |
 | `stickyNotes` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:756-757` |
-| `stickyNotes` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1292-1317` |
+| `stickyNotes` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1299-1324` |
 | `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` |
@@ -997,7 +999,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:992-1034` |
+| `switch` | method | `StepList` | `dist/flow-sdk.d.ts:998-1040` |
 | `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` |
@@ -1022,7 +1024,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:1133-1163` |
+| `terminate` | method | `StepList` | `dist/flow-sdk.d.ts:1139-1169` |
 | `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` |
@@ -1046,11 +1048,11 @@ not find it either.
 | `trigger` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:749-751` |
 | `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:1318-1338` |
+| `trigger` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1325-1345` |
 | `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:766-772` |
-| `triggerId` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1390-1409` |
+| `triggerId` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1397-1416` |
 | `triggerOptions` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:752-753` |
 | `triggers` | property | `BuiltCase` | `dist/case/case-sdk.d.ts:644-645` |
 | `triggers` | property | `CaseLayout` | `dist/case/case-sdk.d.ts:620-621` |
@@ -1106,7 +1108,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:1554-1563` |
+| `var` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1600-1609` |
 | `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` |
@@ -1129,7 +1131,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:1410-1423` |
+| `version` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1417-1430` |
 | `version` | property | `NodeOptions` | `dist/flow-sdk.d.ts:397-404` |
 | `version` | property | `TriggerMeta` | `dist/core/connectors.d.ts:126` |
 | `version` | property | `TriggerOptions` | `dist/core/actions.d.ts:2073-2074` |

package/dist/cli/commands/flow.js

@@ -104,11 +104,14 @@ export function registerFlowCommands(program) {
     });
     flow.command('merge')
         .description('Merge an edited flow with its original artifact.')
-        .argument('<edited>', 'edited .flow path')
+        .argument('<edited>', 'edited .flow path, or the edited .flow.ts source (merge compiles it, tolerating untouched draft nodes)')
         .option('--original <file>', '(required) original .flow path, the artifact to merge into')
         .option('-o, --output <file>', 'merged output path')
         .option('--baseline <file>', 'compiled pristine decompile')
-        .option('--strict', 'refuse when the no-edit round trip (--baseline) differs from the original')
+        .option('--baseline-from <file>', 'build the baseline from this original .flow (decompile + compile, tolerating draft nodes) instead of --baseline')
+        .option('--library <dir>', 'connector library, for compiling with --baseline-from or a .flow.ts edited source')
+        .option('--bindings <file>', 'bindings.json, for the same compiles')
+        .option('--strict', 'refuse when the no-edit round trip (the baseline) differs from the original')
         .allowExcessArguments()
         .action(async (_edited, options, command) => {
         const pair = namedOrLegacySecond(command, {
@@ -121,6 +124,9 @@ export function registerFlowCommands(program) {
         const argv = [original, edited];
         addValue(argv, '-o', options.output);
         addValue(argv, '--baseline', options.baseline);
+        addValue(argv, '--baseline-from', options.baselineFrom);
+        addValue(argv, '--library', options.library);
+        addValue(argv, '--bindings', options.bindings);
         if (options.strict)
             argv.push('--strict');
         await invoke('flow merge', () => import('../../merge-cli.js'), argv);

package/dist/core/connector-inputs.d.ts

@@ -37,6 +37,12 @@ export interface ConnectorInputOpts {
     lookups?: Readonly<Record<string, LookupSpec>>;
     /** `ignore` skips an unresolved lookup instead of refusing it — what `check` wants. */
     unresolvedLookups?: 'error' | 'ignore';
+    /**
+     * Receives a missing REQUIRED input instead of refusing it — the draft
+     * tolerance of a merge-owned compile (#1134). Every other input error still
+     * refuses.
+     */
+    onMissingRequired?: (message: string) => void;
 }
 /** Flow's dialect, re-exported so `serialize.ts` need not reach past this module. */
 export { FLOW_EXPR_DIALECT } from './connector-checks.js';

package/dist/core/connector-inputs.js

@@ -116,8 +116,13 @@ export function buildConnectorInputs(rc, inputs, opts) {
             // not know what to put in it than because they forgot it exists: name the
             // id it sends and the helper that finds one, so "(string)" is not read as
             // "any string" — an e-mail into `fields.reporter.id` is exactly that misreading.
-            if (f.required)
-                errs.push(`missing required input "${f.name}" (${f.type ?? 'value'})${missingLookupHint(f.name, lookups[f.name], rc, dialect.descriptors)}`);
+            if (f.required) {
+                const message = `missing required input "${f.name}" (${f.type ?? 'value'})${missingLookupHint(f.name, lookups[f.name], rc, dialect.descriptors)}`;
+                if (opts.onMissingRequired)
+                    opts.onMissingRequired(message);
+                else
+                    errs.push(message);
+            }
             continue;
         }
         // An unresolved lookup is swapped for its recorded id, or reported. It is

package/dist/decompile.js

@@ -2861,6 +2861,8 @@ function emitChildFlow(name, child, ctx) {
         o: ctx.o,
     };
     const parts = [`${ctx.imp.use('flow')}(${tsLiteral(name)})`];
+    // As for the root flow (emitFlow): every End is explicit, so nothing is implicit.
+    parts.push('.openTails()');
     // Variables.
     const shape = (dir) => `{ ${globals.filter((g) => g.direction === dir).map((g) => `${key(g.name ?? g.id)}: ${declExpr(g, dir !== 'inout', ctx.imp)}`).join(', ')} }`;
     if (globals.some((g) => g.direction === 'in'))
@@ -3050,6 +3052,11 @@ export function decompile(flow, options = {}) {
     }
     if (runCarried.size > 0)
         e.line(d, `.definitions([${[...runCarried.values()].join(', ')}])`);
+    // Every End in the file decompiles to an explicit `.return(...)` or
+    // `.terminate(...)`, so the source needs no implicit End: one would only add
+    // an End to a path the file leaves open (#1142). Always saying so, rather
+    // than detecting open tails, keeps this from drifting from what serialize caps.
+    e.line(d, '.openTails()');
     // 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

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

@@ -288,6 +288,12 @@ export interface FlowNodeType<Spec> extends NodeType<Spec, FlowNodeContribution,
      * envelope is in `<step>.output` (instance 430d43ad-4583-40c0-8f74-b49d2c4904e4).
      */
     readonly errorEnvelope?: string;
+    /**
+     * `true`: a path that ends on this node is capped with an End even under
+     * `.openTails()`. A human task sets it: the product's `hitl-completed`
+     * rule wants an edge after the task.
+     */
+    readonly capsOpenTail?: boolean;
     /**
      * The exits the AUTHOR named on this step — an HTTP call's response branches,
      * and the port each leaves on — or why it has none to route. What

package/dist/flow-sdk.d.ts

@@ -770,6 +770,12 @@ export interface BuiltFlow {
      * follows.
      */
     triggerId?: string;
+    /**
+     * `true` when `.openTails()` was called: a path that runs out of steps
+     * stops on its last node, with no End node added. Absent means the default —
+     * every such path is capped with an End.
+     */
+    openTails?: true;
 }
 /** Collects a sequence of steps. Used for the flow body and each branch/loop arm. */
 declare class StepList {
@@ -1261,6 +1267,7 @@ declare class FlowBuilder extends StepList {
     private _triggerOptions?;
     private _entryPoints;
     private _triggerId?;
+    private _openTails;
     constructor(_id: string);
     /**
      * Set the flow's display name.
@@ -1502,6 +1509,45 @@ declare class FlowBuilder extends StepList {
      * @throws Error when a manifest is not a node manifest, or two differ for one `nodeType@version`.
      */
     definitions(manifests: readonly Record<string, unknown>[]): this;
+    /**
+     * Leave a path that runs out of steps open, instead of ending it on an End node.
+     *
+     * @remarks
+     * By default compile caps every path that falls off the end of its
+     * step list with a `core.control.end` node, and that End maps the flow's
+     * outputs, so the run answers with them. The places this applies are the
+     * flow's own body, a subflow's body, and an `.onError` / `.stepToList` body.
+     *
+     * `.openTails()` leaves such a path open: its last node simply has no outgoing edge.
+     * It is the shape the classic CLI and the canvas write for a flow nobody gave
+     * an End node, and `uip maestro flow validate` accepts it. `flow-decompile`
+     * emits `.openTails()` for every file it decompiles (each End the file
+     * has becomes an explicit `.return(...)`), so a no-edit decompile → compile →
+     * merge does not add an End the author never drew.
+     *
+     * It changes only paths that fall off. `.return(...)`, `.terminate(...)`, a
+     * `.stepSwitch` exit with no arm and a human-task outcome with
+     * `action: 'End'` still emit their End. A human task that ends a path is
+     * still capped with an End (the product's `hitl-completed` rule wants an edge
+     * after it), so a file whose human task has no outgoing edge gains one on a
+     * round trip. A path left open maps no outputs, so a flow that declares
+     * `.output(...)` answers nothing on that path. Use `.return(...)` on the
+     * paths that must answer.
+     *
+     * A subflow's child flow has its own setting; it does not inherit the
+     * caller's.
+     *
+     * @example
+     * **Keep a classic flow's open tail open**
+     * ```ts
+     * flow('notify')
+     *   .openTails()
+     *   .step('send', script({ code: 'return { sent: true };' }))
+     * ```
+     *
+     * @returns This builder, so calls chain.
+     */
+    openTails(): this;
     /**
      * Declare the flow's inputs. Read them with `input('<name>')`.
      *

package/dist/flow-sdk.js

@@ -909,6 +909,7 @@ class FlowBuilder extends StepList {
     _triggerOptions;
     _entryPoints = [];
     _triggerId;
+    _openTails = false;
     constructor(_id) {
         super();
         this._id = _id;
@@ -1211,6 +1212,48 @@ class FlowBuilder extends StepList {
         this._definitions = [...known.values()];
         return this;
     }
+    /**
+     * Leave a path that runs out of steps open, instead of ending it on an End node.
+     *
+     * @remarks
+     * By default compile caps every path that falls off the end of its
+     * step list with a `core.control.end` node, and that End maps the flow's
+     * outputs, so the run answers with them. The places this applies are the
+     * flow's own body, a subflow's body, and an `.onError` / `.stepToList` body.
+     *
+     * `.openTails()` leaves such a path open: its last node simply has no outgoing edge.
+     * It is the shape the classic CLI and the canvas write for a flow nobody gave
+     * an End node, and `uip maestro flow validate` accepts it. `flow-decompile`
+     * emits `.openTails()` for every file it decompiles (each End the file
+     * has becomes an explicit `.return(...)`), so a no-edit decompile → compile →
+     * merge does not add an End the author never drew.
+     *
+     * It changes only paths that fall off. `.return(...)`, `.terminate(...)`, a
+     * `.stepSwitch` exit with no arm and a human-task outcome with
+     * `action: 'End'` still emit their End. A human task that ends a path is
+     * still capped with an End (the product's `hitl-completed` rule wants an edge
+     * after it), so a file whose human task has no outgoing edge gains one on a
+     * round trip. A path left open maps no outputs, so a flow that declares
+     * `.output(...)` answers nothing on that path. Use `.return(...)` on the
+     * paths that must answer.
+     *
+     * A subflow's child flow has its own setting; it does not inherit the
+     * caller's.
+     *
+     * @example
+     * **Keep a classic flow's open tail open**
+     * ```ts
+     * flow('notify')
+     *   .openTails()
+     *   .step('send', script({ code: 'return { sent: true };' }))
+     * ```
+     *
+     * @returns This builder, so calls chain.
+     */
+    openTails() {
+        this._openTails = true;
+        return this;
+    }
     /**
      * Declare the flow's inputs. Read them with `input('<name>')`.
      *
@@ -1310,6 +1353,7 @@ class FlowBuilder extends StepList {
             ...(this._triggerOptions !== undefined ? { triggerOptions: this._triggerOptions } : {}),
             ...(this._entryPoints.length ? { entryPoints: this._entryPoints } : {}),
             ...(this._triggerId !== undefined ? { triggerId: this._triggerId } : {}),
+            ...(this._openTails ? { openTails: true } : {}),
         };
         // First-level validation, intrinsic to running the SDK: catch a definitely-
         // broken expression HERE, before the model is serialized, rather than three

package/dist/merge-cli.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 import { type CliExitCode } from './cli-run.js';
-export declare function run(argv: string[]): CliExitCode;
+export declare function run(argv: string[]): Promise<CliExitCode>;

package/dist/merge-cli.js

@@ -3,7 +3,13 @@
  * merge-cli — merge an edited flow back into the original `.flow` (bin `flow-merge`)
  *
  * Usage:
- *   flow-merge <original.flow> <edited.flow> [-o merged.flow] [--baseline <baseline.flow>] [--strict]
+ *   flow-merge <original.flow> <edited.flow | Edited.flow.ts> [-o merged.flow]
+ *              [--baseline <baseline.flow> | --baseline-from <original.flow>] [--strict]
+ *
+ * `--baseline-from <original.flow>` makes merge build the baseline itself
+ * (decompile + compile, nothing written), and an edited `.flow.ts` makes merge
+ * compile it: both compiles tolerate DRAFT nodes, and merge refuses a draft
+ * only where it would take the node from the edited flow. See merge-compile.ts.
  *
  * `edited.flow` is compile(decompile(original) after your edits). `--baseline`
  * is compile(decompile(original)) BEFORE any edit — supplying it enables the
@@ -19,27 +25,88 @@ import { readFileSync } from 'node:fs';
 import { basename, resolve } from 'node:path';
 import { MergeRefusedError, mergeFlow } from './merge.js';
 import { flagValue, runWhenInvokedDirectly } from './cli-run.js';
-export function run(argv) {
+import { ensureTypeScriptRuntime } from './node-runtime.js';
+import { flowCheckOpts, openCliLibrary } from './cli-library.js';
+import { Bindings } from './bindings.js';
+import { defaultBindingsFile } from './workdir.js';
+import { baselineFromOriginal, checkEdited, classifyDrafts, compileSourceDraftTolerant } from './merge-compile.js';
+const USAGE = 'usage: flow-merge <original.flow> <edited.flow | Edited.flow.ts> [-o merged.flow] '
+    + '[--baseline <baseline.flow> | --baseline-from <original.flow>] [--library <dir>] [--bindings <file>] [--strict]';
+export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
-        console.error('usage: flow-merge <original.flow> <edited.flow> [-o merged.flow] [--baseline <baseline.flow>] [--strict]');
+        console.error(USAGE);
         return 2;
     }
-    const flags = new Set(['-o', '--baseline']);
+    const flags = new Set(['-o', '--baseline', '--baseline-from', '--library', '--bindings', '--connectors-local']);
     const positionals = argv.filter((a, i) => !flags.has(a) && !flags.has(argv[i - 1]) && !a.startsWith('-'));
     const [originalPath, editedPath] = positionals;
     if (!originalPath || !editedPath) {
         console.error('flow-merge: need <original.flow> and <edited.flow>');
         return 2;
     }
-    const original = JSON.parse(readFileSync(originalPath, 'utf8'));
-    const edited = JSON.parse(readFileSync(editedPath, 'utf8'));
     const baselinePath = flagValue(argv, '--baseline');
-    const baseline = baselinePath ? JSON.parse(readFileSync(baselinePath, 'utf8')) : undefined;
+    const baselineFrom = flagValue(argv, '--baseline-from');
+    if (baselinePath && baselineFrom) {
+        console.error('flow-merge: pass --baseline or --baseline-from, not both');
+        return 2;
+    }
+    const editedIsSource = /\.ts$/.test(editedPath);
+    // Merge compiles a side itself only for --baseline-from or a .flow.ts edited
+    // source; both load TypeScript, so both need the type-stripping runtime.
+    if (baselineFrom || editedIsSource)
+        ensureTypeScriptRuntime();
+    const library = baselineFrom || editedIsSource ? openCliLibrary(argv) : undefined;
+    const bindings = baselineFrom || editedIsSource ? new Bindings(flagValue(argv, '--bindings') ?? defaultBindingsFile()) : undefined;
+    const compileOpts = { library, bindings };
+    const original = JSON.parse(readFileSync(originalPath, 'utf8'));
+    let drafts = [];
+    let diagnostics = [];
+    let edited;
+    if (editedIsSource) {
+        // The edited source gets what `compile` gives it: check() with the same
+        // options, and the serializer's warnings (CONNECTION_STUB, ...) printed.
+        const compiled = await compileSourceDraftTolerant(resolve(editedPath), {
+            ...compileOpts,
+            warn: (w) => console.error(`  ⚠ [${w.code}] ${w.message}`),
+        });
+        edited = compiled.flow;
+        drafts = compiled.drafts;
+        diagnostics = checkEdited(compiled.built, edited, flowCheckOpts(library, bindings));
+    }
+    else {
+        edited = JSON.parse(readFileSync(editedPath, 'utf8'));
+    }
+    const baseline = baselineFrom
+        ? (await baselineFromOriginal(baselineFrom, compileOpts, (m) => console.error(`flow-merge: decompile warning: ${m}`))).flow
+        : baselinePath ? JSON.parse(readFileSync(baselinePath, 'utf8')) : undefined;
     const strict = argv.includes('--strict');
     if (strict && !baseline) {
-        console.error('flow-merge: --strict compares the no-edit round trip with the original; pass --baseline <baseline.flow>');
+        console.error('flow-merge: --strict compares the no-edit round trip with the original; pass --baseline <baseline.flow> or --baseline-from <original.flow>');
         return 2;
     }
+    // A draft node (no connection, an empty required input, no object) is
+    // acceptable only where merge restores the ORIGINAL node; one the author
+    // changed or added gets the strict compile's refusal (#1134).
+    // check()'s errors follow the same rule; its warnings are printed as compile prints them.
+    const { kept, refused } = classifyDrafts(original, edited, baseline, drafts);
+    const checked = classifyDrafts(original, edited, baseline, diagnostics.filter((d) => d.level === 'error'));
+    for (const d of diagnostics)
+        if (d.level === 'warning')
+            console.error(`  ⚠ [${d.code}] ${d.message}`);
+    for (const d of [...kept, ...checked.kept]) {
+        console.error(`  ⚠ [DRAFT_NODE_KEPT] "${d.nodeId}" is unfinished in the original (${d.code}); it is untouched, so the original node is kept as is.`);
+    }
+    const errors = [...refused, ...checked.refused];
+    if (errors.length) {
+        for (const d of errors) {
+            const where = d.nodeId === '' ? 'the edited flow'
+                : d.reason === 'subflow' ? `"${d.nodeId}" is inside a subflow, which merge takes whole; finish it`
+                    : `"${d.nodeId}" is changed or new in the edited flow`;
+            console.error(`  ✗ [${d.code}] ${where}: ${d.message}`);
+        }
+        console.error(`flow-merge: ${errors.length} error(s) in nodes merge takes from the edited flow; finish them or revert the edit. Nothing written.`);
+        return 1;
+    }
     let merged;
     try {
         merged = mergeFlow(original, edited, {

package/dist/merge-compile.d.ts

@@ -0,0 +1,55 @@
+import { type DraftFinding, type SerializeOpts } from './serialize.js';
+import { type CheckOpts, type Diagnostic } from './check.js';
+import type { BuiltFlow } from './flow-sdk.js';
+/** A compile's flow and the draft refusals it reported instead of throwing. */
+export interface DraftTolerantCompile {
+    flow: any;
+    drafts: DraftFinding[];
+}
+/** Compile `built` with draft tolerance. Every other refusal still throws. */
+export declare function compileDraftTolerant(built: BuiltFlow, opts?: Omit<SerializeOpts, 'draft'>): DraftTolerantCompile;
+/**
+ * Load a `.flow.ts` source and compile it with draft tolerance.
+ * The caller has already called `ensureTypeScriptRuntime()`.
+ */
+export declare function compileSourceDraftTolerant(file: string, opts?: Omit<SerializeOpts, 'draft'>): Promise<DraftTolerantCompile & {
+    built: BuiltFlow;
+}>;
+/**
+ * The baseline of `originalPath`: decompile it (reading agent sidecars beside
+ * it, as `flow decompile` does), then compile the source with draft tolerance.
+ * The source goes to a temporary directory that is removed afterwards.
+ */
+export declare function baselineFromOriginal(originalPath: string, opts?: Omit<SerializeOpts, 'draft'>, warn?: (message: string) => void): Promise<DraftTolerantCompile>;
+/** Why merge takes a node from the edited flow, so a finding on it is an error. */
+export type TakenReason = 'edited' | 'subflow';
+/** A finding on a node merge takes from the edited flow, with the reason it takes it. */
+export type Refused<T> = T & {
+    reason: TakenReason;
+};
+/**
+ * Sort each finding by what merge does with its node: `refused` when the node
+ * comes from the edited flow (reason `edited`: the author changed or added it;
+ * reason `subflow`: it sits in a subflow, which merge takes from `edited`
+ * whole), `kept` when merge restores the original node.
+ *
+ * For instance a Slack node with no connection that the author did not touch
+ * is `kept`; the same node with a new message text is `refused` as `edited`.
+ */
+export declare function classifyDrafts<T extends {
+    nodeId: string;
+}>(original: any, edited: any, baseline: any, findings: readonly T[]): {
+    kept: T[];
+    refused: Refused<T>[];
+};
+/** A `check()` diagnostic, placed on the root node its step emitted (`''` when it names no root step). */
+export type PlacedDiagnostic = Diagnostic & {
+    nodeId: string;
+};
+/**
+ * Run `check()` on the edited source, as `compile` does, and place each
+ * diagnostic on the node its step emitted in `editedFlow`, so
+ * {@link classifyDrafts} can sort it. A diagnostic with no step, or a step
+ * with no root node, gets nodeId `''`, which is always refused.
+ */
+export declare function checkEdited(built: BuiltFlow, editedFlow: any, opts: CheckOpts): PlacedDiagnostic[];

package/dist/merge-compile.js

@@ -0,0 +1,104 @@
+/**
+ * merge-compile — the compiles `flow merge --baseline-from` runs itself (#1134).
+ *
+ * Both compiles tolerate draft nodes (`SerializeOpts.draft`). A draft on a node
+ * merge keeps from the original is a warning; a draft or `check()` error on a
+ * node merge takes from the edited flow is an error. Nothing draft-tolerant is
+ * written to disk.
+ */
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { decompile } from './decompile.js';
+import { loadBuiltFlow } from './load.js';
+import { serialize } from './serialize.js';
+import { check } from './check.js';
+import { nodesTakenFromEdited } from './merge.js';
+import { PACKAGE_NAME } from './package-name.js';
+/** Compile `built` with draft tolerance. Every other refusal still throws. */
+export function compileDraftTolerant(built, opts = {}) {
+    const drafts = [];
+    const flow = serialize(built, { ...opts, draft: (f) => drafts.push(f) });
+    return { flow, drafts };
+}
+/**
+ * Load a `.flow.ts` source and compile it with draft tolerance.
+ * The caller has already called `ensureTypeScriptRuntime()`.
+ */
+export async function compileSourceDraftTolerant(file, opts = {}) {
+    const built = await loadBuiltFlow(file);
+    return { ...compileDraftTolerant(built, opts), built };
+}
+/**
+ * The baseline of `originalPath`: decompile it (reading agent sidecars beside
+ * it, as `flow decompile` does), then compile the source with draft tolerance.
+ * The source goes to a temporary directory that is removed afterwards.
+ */
+export async function baselineFromOriginal(originalPath, opts = {}, warn) {
+    const original = JSON.parse(readFileSync(originalPath, 'utf8'));
+    const source = decompile(original, {
+        importSpecifier: PACKAGE_NAME,
+        warn,
+        readSidecar: (relativePath) => {
+            try {
+                return readFileSync(join(dirname(resolve(originalPath)), relativePath), 'utf8');
+            }
+            catch {
+                return undefined;
+            }
+        },
+    });
+    const dir = mkdtempSync(join(tmpdir(), 'flow-merge-baseline-'));
+    try {
+        writeFileSync(join(dir, 'package.json'), '{"type":"module"}\n');
+        const file = join(dir, 'Baseline.flow.ts');
+        writeFileSync(file, source);
+        return await compileSourceDraftTolerant(file, opts);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+/**
+ * Sort each finding by what merge does with its node: `refused` when the node
+ * comes from the edited flow (reason `edited`: the author changed or added it;
+ * reason `subflow`: it sits in a subflow, which merge takes from `edited`
+ * whole), `kept` when merge restores the original node.
+ *
+ * For instance a Slack node with no connection that the author did not touch
+ * is `kept`; the same node with a new message text is `refused` as `edited`.
+ */
+export function classifyDrafts(original, edited, baseline, findings) {
+    const fromEdited = new Set(nodesTakenFromEdited(original, edited, baseline));
+    const rootIds = new Set((edited?.nodes ?? []).map((n) => n.id));
+    const kept = [];
+    const refused = [];
+    for (const f of findings) {
+        if (!rootIds.has(f.nodeId))
+            refused.push({ ...f, reason: 'subflow' });
+        else if (fromEdited.has(f.nodeId))
+            refused.push({ ...f, reason: 'edited' });
+        else
+            kept.push(f);
+    }
+    return { kept, refused };
+}
+/**
+ * Run `check()` on the edited source, as `compile` does, and place each
+ * diagnostic on the node its step emitted in `editedFlow`, so
+ * {@link classifyDrafts} can sort it. A diagnostic with no step, or a step
+ * with no root node, gets nodeId `''`, which is always refused.
+ */
+export function checkEdited(built, editedFlow, opts) {
+    const byStep = new Map();
+    for (const n of editedFlow?.nodes ?? []) {
+        const label = n?.display?.label;
+        if (typeof label === 'string' && !byStep.has(label))
+            byStep.set(label, n.id);
+    }
+    const ids = new Set((editedFlow?.nodes ?? []).map((n) => n.id));
+    return check(built, opts).map((d) => ({
+        ...d,
+        nodeId: d.step === undefined ? '' : byStep.get(d.step) ?? (ids.has(d.step) ? d.step : ''),
+    }));
+}

package/dist/merge.d.ts

@@ -152,4 +152,13 @@ export interface MergeOptions {
      */
     strict?: boolean;
 }
+/**
+ * The ids of the root nodes {@link mergeFlow} takes from `edited` rather than
+ * restoring from `original`: every node that is new, or that differs from its
+ * `baseline` counterpart. With no baseline, that is every node.
+ *
+ * For instance, with a baseline equal to `edited` and every node present in
+ * `original`, the answer is `[]` — a no-edit merge keeps them all.
+ */
+export declare function nodesTakenFromEdited(original: AnyFlow, edited: AnyFlow, baseline?: AnyFlow): string[];
 export declare function mergeFlow(original: AnyFlow, edited: AnyFlow, options?: MergeOptions): AnyFlow;

package/dist/merge.js

@@ -97,6 +97,27 @@ function nodeUnchanged(a, b) {
         return false;
     return JSON.stringify(a.inputs ?? {}) === JSON.stringify(b.inputs ?? {});
 }
+/**
+ * The ids of the root nodes {@link mergeFlow} takes from `edited` rather than
+ * restoring from `original`: every node that is new, or that differs from its
+ * `baseline` counterpart. With no baseline, that is every node.
+ *
+ * For instance, with a baseline equal to `edited` and every node present in
+ * `original`, the answer is `[]` — a no-edit merge keeps them all.
+ */
+export function nodesTakenFromEdited(original, edited, baseline) {
+    const origNodes = byId(original.nodes);
+    const baseNodes = byId(baseline?.nodes);
+    return (edited.nodes ?? []).filter((e) => !isKept(e, origNodes, baseNodes, baseline)).map((e) => e.id);
+}
+/**
+ * Whether merge restores `e`'s ORIGINAL node instead of taking `e`: there is a
+ * baseline, the original has the node, and `e` equals its baseline counterpart.
+ * {@link mergeFlow}'s node loop and {@link nodesTakenFromEdited} both ask this.
+ */
+function isKept(e, origNodes, baseNodes, baseline) {
+    return !!baseline && origNodes.has(e.id) && nodeUnchanged(e, baseNodes.get(e.id));
+}
 /**
  * Give an edited node the original's position, by id.
  *
@@ -132,7 +153,7 @@ export function mergeFlow(original, edited, options = {}) {
     const finalNodes = [];
     for (const e of edited.nodes ?? []) {
         const orig = origNodes.get(e.id);
-        if (options.baseline && orig && nodeUnchanged(e, baseNodes.get(e.id))) {
+        if (isKept(e, origNodes, baseNodes, options.baseline) && orig) {
             // Untouched by the user (equal to the faithful baseline) → keep the
             // original node exactly, placeholder-safe.
             finalNodes.push(jsonClone(orig));

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

@@ -518,6 +518,7 @@ function hitlAt(typeName, version, factory) {
     return {
         kind: 'hitl', typeName, version, factory: 'hitl', definition: 'bundled',
         rawNode: { factory },
+        capsOpenTail: true,
         serialize: ({ inputs }, ctx) => {
             // How the task leaves its node — `hitlExitModel` (core/hitl-routing.ts)
             // has the product rule and what `.step()` means after each shape. An

package/dist/serialize.d.ts

@@ -1,6 +1,7 @@
 import type { DefinitionReference } from './core/node-classes.js';
 import type { BuiltFlow } from './flow-sdk.js';
 import type { Library } from './library.js';
+import { type BindingRefusalCode } from './core/binding-messages.js';
 import type { Bindings } from './bindings.js';
 import { connectorInputErrors as coreConnectorInputErrors } from './core/connector-inputs.js';
 /**
@@ -47,6 +48,18 @@ export interface SerializeWarning {
     code: string;
     message: string;
 }
+/** A required connector input left empty — the one draft code with no error class of its own. */
+export declare const CONNECTOR_INPUT_MISSING = "CONNECTOR_INPUT_MISSING";
+/** The refusals a draft-tolerant compile reports instead of throwing. */
+export type DraftCode = BindingRefusalCode | typeof CONNECTOR_INPUT_MISSING | 'CONNECTOR_OBJECT_REQUIRED';
+/** A refusal a draft-tolerant compile reported instead of throwing (see {@link SerializeOpts.draft}). */
+export interface DraftFinding {
+    /** The emitted node's id. */
+    nodeId: string;
+    code: DraftCode;
+    /** The sentence the strict compile refuses with. */
+    message: string;
+}
 export interface SerializeOpts {
     library?: Library;
     bindings?: Bindings;
@@ -56,6 +69,19 @@ export interface SerializeOpts {
      * hears nothing, which keeps `serialize()` silent in tests and libraries.
      */
     warn?: (warning: SerializeWarning) => void;
+    /**
+     * Draft tolerance, for a compile whose output only `merge` reads (#1134).
+     *
+     * A canvas flow often holds DRAFT nodes — a connector with no connection, an
+     * empty required input, a generic operation with no object — which the
+     * canvas saves and compile refuses. In a brownfield merge an untouched node
+     * is restored from the original anyway, so refusing it only blocks the edit.
+     * When this callback is given, those three refusals are reported here, with
+     * the node's id, and the node is emitted with what it has; `merge` then
+     * refuses any such node it would take from the edited flow. Absent (every
+     * ordinary compile), behaviour is unchanged.
+     */
+    draft?: (finding: DraftFinding) => void;
     /**
      * Filled in by `serialize` with the extra files the flow needs beside the
      * `.flow`, relative to it: one `<source>/agent.json` per inline agent, plus a

package/dist/serialize.js

@@ -20,6 +20,7 @@ import { stepExits } from './flow-step-exits.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 { ConnectorResolveError } from './core/library.js';
 import { connectionConnectors } from './bindings-v2.js';
 import { BindingRefusal, GUID_RE, bindingLabelRefusal, bindingMissingMessage, missingBindingLabels } from './core/binding-messages.js';
 import { ByoaRefusal, byoaUnverified } from './core/byoa.js';
@@ -2999,6 +3000,8 @@ function scheduleInputs(inputs, nodeId) {
 function outcomeId(name, index) {
     return outcomeSlug(name, index);
 }
+/** A required connector input left empty — the one draft code with no error class of its own. */
+export const CONNECTOR_INPUT_MISSING = 'CONNECTOR_INPUT_MISSING';
 /**
  * `serialize`, plus the extra files the flow needs on disk beside it.
  *
@@ -3890,6 +3893,7 @@ function newScope(outputs, vars = [], backing = new Map(), backingReads = backin
         agentSchemas: [],
         stepNodeId: new Map(),
         pendingEdges: [],
+        openTails: false,
     };
 }
 /**
@@ -4366,6 +4370,7 @@ export function serialize(built, opts = {}) {
     const subflows = {};
     const rootGlobals = emittableGlobals(built, `flow "${built.id}"`);
     const root = newScope(rootGlobals.outputs, rootGlobals.vars, rootGlobals.backing, rootGlobals.backingReads);
+    root.openTails = built.openTails === true;
     // `input('x')` lowers eagerly to `$vars.start.output.x` — `start` being the
     // trigger node's default id. When the flow renames the trigger, register that
     // rename so the SAME pass that rewrites step-name references rewrites these
@@ -4529,6 +4534,21 @@ export function serialize(built, opts = {}) {
             addEdge(scope, t, id);
         return node;
     }
+    /** Node ids whose type sets `capsOpenTail` (see {@link tailsToCap}). */
+    const capsOpenTail = new Set();
+    /**
+     * The tails of a path that ran out of steps which still need an End node.
+     *
+     * All of them by default. Under `.openTails()` (#1142) only the tails
+     * of a node whose type sets `capsOpenTail` (a human task: the product's
+     * `hitl-completed` rule wants an edge after it). Every other tail is left
+     * open, which is the shape the classic CLI and the canvas write.
+     */
+    function tailsToCap(scope, tails) {
+        if (!scope.openTails)
+            return [...tails];
+        return tails.filter((t) => capsOpenTail.has(t.node));
+    }
     /**
      * Emit a child flow into its own scope and register it under the calling
      * node's id — that key is how the format names a subflow body, and how
@@ -4556,6 +4576,7 @@ export function serialize(built, opts = {}) {
     function emitSubflowBodyIn(child, nodeId) {
         const childGlobals = emittableGlobals(child, `subflow "${nodeId}"`, 'subflow');
         const scope = newScope(childGlobals.outputs, childGlobals.vars, childGlobals.backing, childGlobals.backingReads);
+        scope.openTails = child.openTails === true;
         // Claim this copy's node ids UP FRONT, so the rename map is complete before
         // the first expression renders. A child's step names are free the first
         // time it runs; if any of them is already taken — which is what a second
@@ -4586,8 +4607,9 @@ export function serialize(built, opts = {}) {
         const tails = emit(child.steps, [{ node: startId, port: 'output' }], scope);
         // Same as the root's implicit End — mapped against the SUBFLOW's own
         // outputs, which is the scope the product validates a subflow body in.
-        if (tails.length)
-            emitEnd(scope, uid(scope, 'end'), tails);
+        const capped = tailsToCap(scope, tails);
+        if (capped.length)
+            emitEnd(scope, uid(scope, 'end'), capped);
         const globals = [];
         for (const inp of child.inputs)
             globals.push({ id: inp.name, name: inp.name, direction: 'in', type: inp.type, triggerNodeId: startId, ...varMeta(inp) });
@@ -4835,6 +4857,8 @@ export function serialize(built, opts = {}) {
         const impl = resolved.impl;
         const version = resolved.version;
         const id = stepUid(scope, step.name);
+        if (impl.capsOpenTail)
+            capsOpenTail.add(id);
         // As for every typed family: record the failure-envelope boundary before any
         // expression renders, so a handler reading this step resolves correctly.
         if (impl.errorEnvelope)
@@ -4958,20 +4982,67 @@ export function serialize(built, opts = {}) {
         if (spec.kind === 'connector') {
             if (!opts.library)
                 throw new Error(`connector "${step.name}" needs a library (pass --library / set $FLOW_SDK_LIBRARY_JSON).`);
-            const rc = opts.library.resolve(spec.key, spec.action, spec.version, spec.object);
+            let rc;
+            try {
+                rc = opts.library.resolve(spec.key, spec.action, spec.version, spec.object);
+            }
+            catch (error) {
+                if (!opts.draft || !(error instanceof ConnectorResolveError) || error.code !== 'CONNECTOR_OBJECT_REQUIRED')
+                    throw error;
+                // A generic operation saved before its object was picked has no
+                // definition to emit against. Draft tolerance emits a stable stand-in
+                // under the node's id; merge restores the original when it is untouched
+                // and refuses it otherwise.
+                const id = stepUid(scope, step.name);
+                opts.draft({ nodeId: id, code: error.code, message: error.message });
+                // It leaves on the port every connector action leaves on, so the
+                // no-edit round trip rewires nothing. Its inputs carry what the author
+                // wrote, so an edit to the node (an input, a connection) shows up as a
+                // change and merge refuses it instead of restoring the original.
+                const type = `uipath.connector.${spec.key}.${spec.action}`;
+                scope.nodes.push({
+                    id, type, typeVersion: spec.version ?? '1.0.0',
+                    ...(parentId ? { parentId } : {}), display: { label: step.name },
+                    inputs: {
+                        draft: true,
+                        spec: renderDeep(spec.inputs ?? {}, scope.rename),
+                        ...(spec.connection !== undefined ? { connection: spec.connection } : {}),
+                        ...(spec.folder !== undefined ? { folder: spec.folder } : {}),
+                    },
+                });
+                for (const t of tails)
+                    addEdge(scope, t, id);
+                return [{ node: id, port: successPort(type) }];
+            }
             const id = stepUid(scope, step.name);
             const node = makeNode(rc.nodeType, id, step.name, { parentId, requestedVersion: step.options?.version, def: rc.v1def });
             declareListOutputType(node, rc);
-            requireBindingPair(`connector "${step.name}"`, spec, { key: spec.key, action: spec.action });
+            // A draft that names no connection gets no binding rows either: there
+            // is nothing to bind, and rows with an empty resourceKey would leak into
+            // the merged file through merge's bindings union.
+            let unbound = false;
+            try {
+                requireBindingPair(`connector "${step.name}"`, spec, { key: spec.key, action: spec.action });
+            }
+            catch (error) {
+                if (!opts.draft || !(error instanceof BindingRefusal))
+                    throw error;
+                opts.draft({ nodeId: id, code: error.code, message: error.message });
+                unbound = true;
+            }
             const conn = resolveBinding(opts, spec.connection, 'connection', `connector "${step.name}"`, { key: spec.key, action: spec.action });
             const folder = resolveBinding(opts, spec.folder, 'folder', `connector "${step.name}"`, { key: spec.key, action: spec.action });
             // The platform reaches the connection through the flow's `bindings[]`,
             // never through `inputs.detail` — without this pair the run faults with
             // `[102010]` (board G-19; see connectionResourceBindings).
             const { entries: connBindings } = connectionResourceBindings({ def: rc.v1def, connectorKey: rc.connectorKey, connectionId: conn, folderKey: folder }, resourceBindings);
-            for (const b of connBindings)
-                resourceBindings.set(b.id, b);
+            if (!unbound)
+                for (const b of connBindings)
+                    resourceBindings.set(b.id, b);
             const connectorInputs = buildConnectorInputs(rc, spec.inputs, {
+                ...(opts.draft
+                    ? { onMissingRequired: (m) => opts.draft({ nodeId: id, code: CONNECTOR_INPUT_MISSING, message: `connector ${rc.nodeType}: ${m}` }) }
+                    : {}),
                 dialect: FLOW_EXPR_DIALECT,
                 render: (value) => renderDeep(value, scope.rename),
                 resolutions: opts.library.lookupResolutions ?? {},
@@ -5967,9 +6038,10 @@ export function serialize(built, opts = {}) {
         // A body that runs out of steps ends the run on an End of its own (no
         // merge-back is inferred). That End maps the outputs like any other, so a
         // body that set them with `{ updates }` still answers (#742).
-        if (handlerTails.length) {
+        const capped = tailsToCap(scope, handlerTails);
+        if (capped.length) {
             const endId = uid(scope, `${source}${step.port === 'error' ? 'Error' : step.port.charAt(0).toUpperCase() + step.port.slice(1)}End`);
-            emitEnd(scope, endId, handlerTails, { parentId });
+            emitEnd(scope, endId, capped, { parentId });
         }
         return router !== undefined ? [] : tails;
     }
@@ -6435,8 +6507,10 @@ export function serialize(built, opts = {}) {
     // The implicit End a flow falls off the bottom into still terminates the
     // flow, so it maps the flow's outputs — each to itself, since no `.return`
     // named a value here.
-    if (finalTails.length)
-        emitEnd(root, uid(root, 'end'), finalTails);
+    // `.openTails()` leaves those tails open instead (#1142).
+    const finalCapped = tailsToCap(root, finalTails);
+    if (finalCapped.length)
+        emitEnd(root, uid(root, 'end'), finalCapped);
     // ── Additional entry points (design §5.1) ────────────────────────────────
     // Emitted AFTER the shared body so their prefixes can join it by name. Once a
     // flow has more than one root, every root carries the platform's entry-point

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.27.1",
+  "version": "6.29.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": "c635f8993b10e795715c85109080ec8e2e2f28d2"
+  "gitref": "af71b0c21f732f056d19e802af1c987fd8528336"
 }