@uipath/maestro-builder-sdk 6.33.0 → 6.33.2

package/dist/api-index.md

@@ -287,10 +287,10 @@ could hand you spans for a version you do not have.
 | `CaseAppConfig` | interface | `dist/case/case-sdk.d.ts:601-607` | Supporting types | Typed configuration for the generated Case App. |
 | `CaseAppDetailValue` | type | `dist/case/case-sdk.d.ts:590-591` | Supporting types | A value displayed in one Case App section. |
 | `CaseAppSection` | interface | `dist/case/case-sdk.d.ts:592-600` | Supporting types | One summary section in the generated Case App. |
-| `CaseBuilder` | class | `dist/case/case-sdk.d.ts:1050-1293` | Builders | 17 member(s) |
+| `CaseBuilder` | class | `dist/case/case-sdk.d.ts:1056-1299` | Builders | 17 member(s) |
 | `CaseLayout` | interface | `dist/case/case-sdk.d.ts:629-640` | Supporting types | Optional Case designer layout, keyed by author-level stage and trigger names. |
 | `CaseNodeLayout` | interface | `dist/case/case-sdk.d.ts:608-628` | Supporting types | Designer-only fields the shipped Case transformer moves into `layout.nodes[id]`. |
-| `casePlan` | function | `dist/case/case-sdk.d.ts:1294-1300` | Case authoring | Start building a case plan with the given id. |
+| `casePlan` | function | `dist/case/case-sdk.d.ts:1300-1306` | Case authoring | Start building a case plan with the given id. |
 | `CaseRule` | interface | `dist/case/case-sdk.d.ts:78-81` | Supporting types | A single DNF rule. |
 | `CaseRuleGrid` | type | `dist/case/case-sdk.d.ts:113-114` | Supporting types | One rule, one AND-group, or a complete OR-of-AND condition grid. |
 | `CaseRuleInput` | type | `dist/case/case-sdk.d.ts:111-112` | Supporting types | A concrete rule or a pure expression gate resolved by its receiving slot. |
@@ -329,7 +329,7 @@ could hand you spans for a version you do not have.
 | `SelectNextStageSpec` | interface | `dist/case/case-sdk.d.ts:318-336` | Supporting types | Data Fabric entity used by the Case runtime to deliver a person's next-stage selection. |
 | `SlaOpts` | interface | `dist/case/case-sdk.d.ts:166-185` | Option shapes | 5 field(s) |
 | `SlaUnit` | type | `dist/case/case-sdk.d.ts:115-116` | Supporting types | SLA deadline unit. |
-| `StageBuilder` | class | `dist/case/case-sdk.d.ts:978-1049` | Builders | 6 member(s) |
+| `StageBuilder` | class | `dist/case/case-sdk.d.ts:978-1055` | Builders | 6 member(s) |
 | `StageExitType` | type | `dist/case/case-sdk.d.ts:317` | Supporting types |  |
 | `TaskBuilder` | class | `dist/case/case-sdk.d.ts:717-977` | Builders | 23 member(s) |
 | `TaskInputBinding` | interface | `dist/case/case-sdk.d.ts:499-506` | Supporting types | A task input binding: a resource input parameter set to a literal or a `=`-expression. |

package/dist/api-members.md

@@ -58,7 +58,7 @@ not find it either.
 | `aliases` | property | `LookupSpec` | `dist/core/lookups.d.ts:31-32` |
 | `allErrors` | property | `RetrySpec` | `dist/bpmn/bpmn-sdk.d.ts:803-804` |
 | `allowAdhocOptionalStageTasks` | property | `BuiltCase` | `dist/case/case-sdk.d.ts:656-657` |
-| `allowAdhocTasks` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1149-1156` |
+| `allowAdhocTasks` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1155-1162` |
 | `apiWorkflow` | property | `FlowActionSpecs` | `dist/core/actions.d.ts:1558-1561` |
 | `apiWorkflow` | method | `TaskBuilder` | `dist/case/case-sdk.d.ts:779-788` |
 | `app` | property | `EscalationRef` | `dist/core/actions.d.ts:1458-1485` |
@@ -103,7 +103,7 @@ not find it either.
 | `breakEnabled` | property | `DoWhileOptions` | `dist/flow-sdk.d.ts:519-520` |
 | `breakEnabled` | property | `LoopOptions` | `dist/flow-sdk.d.ts:506-510` |
 | `build` | method | `BpmnBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3483-3488` |
-| `build` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1287-1292` |
+| `build` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1293-1298` |
 | `build` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1649-1655` |
 | `businessRule` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:2527-2573` |
 | `by` | property | `LookupResolution` | `dist/core/lookups.d.ts:164` |
@@ -112,7 +112,7 @@ not find it either.
 | `callContext` | property | `EndCallInputs` | `dist/core/actions.d.ts:247-252` |
 | `callContext` | property | `VoiceAgentInputs` | `dist/core/actions.d.ts:290-295` |
 | `cancelActivity` | property | `BoundaryOpts` | `dist/bpmn/bpmn-sdk.d.ts:744-745` |
-| `caseApp` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1128-1148` |
+| `caseApp` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1134-1154` |
 | `caseAppConfig` | property | `BuiltCase` | `dist/case/case-sdk.d.ts:655` |
 | `caseAppEnabled` | property | `BuiltCase` | `dist/case/case-sdk.d.ts:654` |
 | `caseExit` | property | `BuiltCase` | `dist/case/case-sdk.d.ts:660` |
@@ -130,7 +130,7 @@ not find it either.
 | `collection` | property | `LoopSpec` | `dist/bpmn/bpmn-sdk.d.ts:79-80` |
 | `collection` | property | `TransformInputs` | `dist/nodes/transform/flow/spec.d.ts:85-95` |
 | `color` | property | `StickyNote` | `dist/flow-sdk.d.ts:708-709` |
-| `completeWhen` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1267-1277` |
+| `completeWhen` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1273-1283` |
 | `completion` | property | `LoopSpec` | `dist/bpmn/bpmn-sdk.d.ts:85-86` |
 | `completionCondition` | property | `LoopOptions` | `dist/flow-sdk.d.ts:501-505` |
 | `condition` | property | `BpmnFlow` | `dist/bpmn/bpmn-sdk.d.ts:350-351` |
@@ -219,7 +219,7 @@ not find it either.
 | `description` | property | `BuiltStage` | `dist/case/case-sdk.d.ts:543` |
 | `description` | property | `BuiltTask` | `dist/case/case-sdk.d.ts:532` |
 | `description` | property | `BuiltTrigger` | `dist/case/case-sdk.d.ts:200` |
-| `description` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1113-1119` |
+| `description` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1119-1125` |
 | `description` | property | `ClientSideToolRef` | `dist/core/actions.d.ts:1230-1231` |
 | `description` | property | `ConnectorToolRef` | `dist/core/actions.d.ts:1331-1335` |
 | `description` | property | `CustomGuardrail` | `dist/core/actions.d.ts:812` |
@@ -294,7 +294,7 @@ not find it either.
 | `entryPoint` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1385-1435` |
 | `entryPointId` | property | `ProcessMetadata` | `dist/bpmn/bpmn-sdk.d.ts:534-539` |
 | `entryPoints` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:778-779` |
-| `entryWhen` | method | `StageBuilder` | `dist/case/case-sdk.d.ts:1022-1029` |
+| `entryWhen` | method | `StageBuilder` | `dist/case/case-sdk.d.ts:1028-1035` |
 | `entryWhen` | method | `TaskBuilder` | `dist/case/case-sdk.d.ts:965-974` |
 | `err` | method | `StepList` | `dist/flow-sdk.d.ts:802-827` |
 | `error` | property | `BoundaryOpts` | `dist/bpmn/bpmn-sdk.d.ts:750-754` |
@@ -324,7 +324,7 @@ not find it either.
 | `every` | property | `ScheduledInputs` | `dist/flow-sdk.d.ts:150-160` |
 | `every` | property | `TimerTriggerOpts` | `dist/case/case-sdk.d.ts:215-223` |
 | `exception` | property | `BuiltStage` | `dist/case/case-sdk.d.ts:542` |
-| `exceptionStage` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1259-1266` |
+| `exceptionStage` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1265-1272` |
 | `exchangeId` | property | `ConversationalAgentSettings` | `dist/core/actions.d.ts:183-184` |
 | `exchangeId` | property | `SendMessageInputs` | `dist/nodes/conversation/flow/spec.d.ts:14-19` |
 | `exchangeLimit` | property | `ConversationContextInputs` | `dist/nodes/conversation/flow/spec.d.ts:40-43` |
@@ -334,7 +334,7 @@ not find it either.
 | `exit` | property | `BuiltStage` | `dist/case/case-sdk.d.ts:547` |
 | `exitToStage` | property | `BuiltExitCondition` | `dist/case/case-sdk.d.ts:347-361` |
 | `exitToStage` | property | `ExitOpts` | `dist/case/case-sdk.d.ts:696-710` |
-| `exitWhen` | method | `StageBuilder` | `dist/case/case-sdk.d.ts:1030-1037` |
+| `exitWhen` | method | `StageBuilder` | `dist/case/case-sdk.d.ts:1036-1043` |
 | `exponentialBase` | property | `RetrySpec` | `dist/bpmn/bpmn-sdk.d.ts:801-802` |
 | `exposeError` | property | `HitlInputs` | `dist/nodes/hitl/flow/spec.d.ts:245-251` |
 | `expression` | property | `BuiltSla` | `dist/case/case-sdk.d.ts:191-192` |
@@ -455,14 +455,14 @@ not find it either.
 | `id` | property | `SwitchArm` | `dist/flow-sdk.d.ts:369-375` |
 | `id` | property | `VarEntry` | `dist/bpmn/bpmn-sdk.d.ts:992-993` |
 | `identifier` | property | `BuiltCase` | `dist/case/case-sdk.d.ts:652` |
-| `identifier` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1120-1127` |
+| `identifier` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1126-1133` |
 | `identifierType` | property | `BuiltCase` | `dist/case/case-sdk.d.ts:653` |
 | `implied` | property | `BpmnFlow` | `dist/bpmn/bpmn-sdk.d.ts:352-359` |
 | `impliedFlowIds` | property | `SugarRegistry` | `dist/bpmn/bpmn-sdk.d.ts:1949-1950` |
 | `inclusive` | property | `ChooseOpts` | `dist/bpmn/bpmn-sdk.d.ts:1820-1824` |
 | `inclusiveGateway` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:2266-2273` |
 | `inlineAgent` | property | `FlowActionSpecs` | `dist/core/actions.d.ts:1590-1593` |
-| `input` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1178-1203` |
+| `input` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1184-1209` |
 | `input` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1590-1602` |
 | `input` | property | `HumanTaskOpts` | `dist/bpmn/bpmn-sdk.d.ts:1355-1356` |
 | `input` | property | `OrchestratorOpts` | `dist/bpmn/bpmn-sdk.d.ts:1241-1242` |
@@ -551,7 +551,7 @@ not find it either.
 | `lanes` | property | `BuiltStage` | `dist/case/case-sdk.d.ts:545` |
 | `layout` | property | `BuiltCase` | `dist/case/case-sdk.d.ts:664-665` |
 | `layout` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:768-769` |
-| `layout` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1157-1177` |
+| `layout` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1163-1183` |
 | `layout` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1327-1337` |
 | `legacyCompleted` | property | `HitlInputs` | `dist/nodes/hitl/flow/spec.d.ts:252-284` |
 | `limit` | property | `DataFabricReadInputs` | `dist/nodes/data-fabric/flow/spec.d.ts:95-100` |
@@ -636,7 +636,7 @@ not find it either.
 | `name` | property | `BuiltInValidatorGuardrail` | `dist/core/actions.d.ts:824` |
 | `name` | property | `BuiltTask` | `dist/case/case-sdk.d.ts:519-520` |
 | `name` | property | `BuiltTrigger` | `dist/case/case-sdk.d.ts:198-199` |
-| `name` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1068-1074` |
+| `name` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1074-1080` |
 | `name` | property | `CaseVarDecl` | `dist/case/case-sdk.d.ts:576` |
 | `name` | property | `CatchOpts` | `dist/bpmn/bpmn-sdk.d.ts:715-716` |
 | `name` | property | `ChooseOpts` | `dist/bpmn/bpmn-sdk.d.ts:1818-1819` |
@@ -738,7 +738,7 @@ not find it either.
 | `outcomePorts` | property | `HitlInputs` | `dist/nodes/hitl/flow/spec.d.ts:230-244` |
 | `outcomes` | property | `EscalationRef` | `dist/core/actions.d.ts:1488-1493` |
 | `outcomes` | property | `HitlInputs` | `dist/nodes/hitl/flow/spec.d.ts:211-225` |
-| `output` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1204-1216` |
+| `output` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1210-1222` |
 | `output` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1603-1638` |
 | `output` | property | `RegistryTypeSpec` | `dist/bpmn/typed-node.d.ts:90` |
 | `output` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3077-3085` |
@@ -914,7 +914,7 @@ not find it either.
 | `schemas` | property | `BuiltBpmn` | `dist/bpmn/bpmn-sdk.d.ts:509-510` |
 | `schemaVersion` | method | `BpmnBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3375-3404` |
 | `schemaVersion` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:752-758` |
-| `schemaVersion` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1086-1112` |
+| `schemaVersion` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1092-1118` |
 | `schemaVersion` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1470-1509` |
 | `scope` | property | `EscalationRecipient` | `dist/case/case-sdk.d.ts:121` |
 | `scopes` | property | `GuardrailSelector` | `dist/core/actions.d.ts:758` |
@@ -954,9 +954,9 @@ not find it either.
 | `skipCondition` | property | `QueueItemOpts` | `dist/bpmn/bpmn-sdk.d.ts:1323-1324` |
 | `skipCondition` | property | `ReceiveMessageOpts` | `dist/bpmn/bpmn-sdk.d.ts:1398-1399` |
 | `skipWhen` | method | `TaskBuilder` | `dist/case/case-sdk.d.ts:931-937` |
-| `sla` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1278-1286` |
+| `sla` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1284-1292` |
 | `sla` | property | `RuleOpts` | `dist/case/case-sdk.d.ts:63-68` |
-| `sla` | method | `StageBuilder` | `dist/case/case-sdk.d.ts:1038-1046` |
+| `sla` | method | `StageBuilder` | `dist/case/case-sdk.d.ts:1044-1052` |
 | `slaRules` | property | `BuiltCase` | `dist/case/case-sdk.d.ts:661` |
 | `slaRules` | property | `BuiltStage` | `dist/case/case-sdk.d.ts:548` |
 | `slug` | property | `McpToolRef` | `dist/core/actions.d.ts:1191-1192` |
@@ -976,7 +976,7 @@ not find it either.
 | `sourceTrigger` | property | `CaseVarDecl` | `dist/case/case-sdk.d.ts:582-588` |
 | `spec` | property | `ActivityNodeOpts` | `dist/bpmn/bpmn-sdk.d.ts:1547-1561` |
 | `splitPages` | property | `DocumentClassifyInputs` | `dist/nodes/document/flow/spec.d.ts:14-15` |
-| `stage` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1251-1258` |
+| `stage` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1257-1264` |
 | `stage` | property | `RuleOpts` | `dist/case/case-sdk.d.ts:29-39` |
 | `stages` | property | `BuiltCase` | `dist/case/case-sdk.d.ts:659` |
 | `stages` | property | `CaseLayout` | `dist/case/case-sdk.d.ts:636-637` |
@@ -1027,7 +1027,7 @@ not find it either.
 | `target` | property | `TypedInputRow` | `dist/bpmn/typed-node.d.ts:203-204` |
 | `target` | property | `TypedOutputRow` | `dist/bpmn/typed-node.d.ts:279-284` |
 | `task` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:2293-2301` |
-| `task` | method | `StageBuilder` | `dist/case/case-sdk.d.ts:1002-1021` |
+| `task` | method | `StageBuilder` | `dist/case/case-sdk.d.ts:1002-1027` |
 | `tasks` | property | `RuleOpts` | `dist/case/case-sdk.d.ts:40-55` |
 | `taskTitle` | property | `EscalationRef` | `dist/core/actions.d.ts:1494-1495` |
 | `taxonomy` | property | `DocValidationInputs` | `dist/nodes/hitl/flow/spec.d.ts:91-92` |
@@ -1057,7 +1057,7 @@ not find it either.
 | `transformation` | property | `FieldMapping` | `dist/nodes/transform/flow/spec.d.ts:30-31` |
 | `trigger` | property | `BuiltEntryPoint` | `dist/flow-sdk.d.ts:737-738` |
 | `trigger` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:763-765` |
-| `trigger` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1242-1250` |
+| `trigger` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1248-1256` |
 | `trigger` | property | `EscalationOpts` | `dist/case/case-sdk.d.ts:128-129` |
 | `trigger` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1364-1384` |
 | `trigger` | property | `StartOpts` | `dist/bpmn/bpmn-sdk.d.ts:624-671` |
@@ -1119,7 +1119,7 @@ not find it either.
 | `value` | property | `TypedContextRow` | `dist/bpmn/typed-node.d.ts:174-175` |
 | `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:1217-1241` |
+| `var` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1223-1247` |
 | `var` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1639-1648` |
 | `var` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:3059-3067` |
 | `var` | property | `TaskOutputBinding` | `dist/case/case-sdk.d.ts:512-513` |
@@ -1136,7 +1136,7 @@ not find it either.
 | `varSchema` | property | `TypedOutputRow` | `dist/bpmn/typed-node.d.ts:257-271` |
 | `version` | property | `BuiltCase` | `dist/case/case-sdk.d.ts:644-650` |
 | `version` | property | `BuiltFlow` | `dist/flow-sdk.d.ts:751` |
-| `version` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1075-1085` |
+| `version` | method | `CaseBuilder` | `dist/case/case-sdk.d.ts:1081-1091` |
 | `version` | property | `ConnectorEventOpts` | `dist/bpmn/bpmn-sdk.d.ts:1435-1436` |
 | `version` | property | `ConnectorMeta` | `dist/core/connectors.d.ts:63` |
 | `version` | property | `ConnectorOpts` | `dist/core/actions.d.ts:14-15` |

package/dist/case/case-sdk.d.ts

@@ -1010,10 +1010,16 @@ declare class StageBuilder {
      * scheduler rules whether they share a set or not, and the designer writes
      * one task per set even for a stage its own SDD calls parallel.
      *
+     * A task without a `runs-sequentially` rule is always written to a set of its
+     * own, placed right after the set `lane` names; `lane` only groups sequential
+     * tasks. Case schema V31 made set membership behavioural: its V30→V31
+     * migration rewrites the entry conditions of any non-sequential task that
+     * shares a set (builder-sdk#1248).
+     *
      * @param displayName - The task's display name.
      * @param fn - Receives a sub-builder for what the task does.
-     * @param opts - `lane` is the task's set index in `data.tasks[][]` (default 0);
-     *   it orders `runs-sequentially` sets and is inert for every other task.
+     * @param opts - `lane` is the index of the set a `runs-sequentially` task joins
+     *   in `data.tasks[][]` (default 0). Any other task gets its own set after it.
      * @returns This builder, so calls chain.
      */
     task(displayName: string, fn: (t: TaskBuilder) => void, opts?: {

package/dist/case/case-sdk.js

@@ -516,10 +516,16 @@ class StageBuilder {
      * scheduler rules whether they share a set or not, and the designer writes
      * one task per set even for a stage its own SDD calls parallel.
      *
+     * A task without a `runs-sequentially` rule is always written to a set of its
+     * own, placed right after the set `lane` names; `lane` only groups sequential
+     * tasks. Case schema V31 made set membership behavioural: its V30→V31
+     * migration rewrites the entry conditions of any non-sequential task that
+     * shares a set (builder-sdk#1248).
+     *
      * @param displayName - The task's display name.
      * @param fn - Receives a sub-builder for what the task does.
-     * @param opts - `lane` is the task's set index in `data.tasks[][]` (default 0);
-     *   it orders `runs-sequentially` sets and is inert for every other task.
+     * @param opts - `lane` is the index of the set a `runs-sequentially` task joins
+     *   in `data.tasks[][]` (default 0). Any other task gets its own set after it.
      * @returns This builder, so calls chain.
      */
     task(displayName, fn, opts = {}) {

package/dist/case/serialize.js

@@ -10,6 +10,7 @@
  */
 import { IdGen } from './ids.js';
 import { isUnrestorableSlotId } from './preserve.js';
+import { v31TaskSets } from './task-sets.js';
 import { buildConnectorInputs, nestConnectorBody, transportHttpMethod } from '../core/connector-inputs.js';
 import { EQUALS_EXPR_DIALECT } from '../core/connector-checks.js';
 import { bindingLabelRefusal } from '../core/binding-messages.js';
@@ -109,6 +110,8 @@ export function serialize(built, opts = {}) {
     built.stages.forEach((stage) => prealloc(stage.slaRules, stage.label));
     const stageIds = [];
     const taskIds = []; // [stageIndex][lane][taskIndex]
+    // The task sets as written: one set per parallel task (see `laneSets`).
+    const stageLanes = built.stages.map((stage) => laneSets(stage.lanes));
     // Task displayNames must be unique across the whole case: the platform rejects
     // duplicates (CASE_MGMT_STAGE_TASK_NAME_DUPLICATE, CRITICAL), and a bare
     // `selected-tasks-completed` reference resolves against a single name→id map, so
@@ -121,7 +124,7 @@ export function serialize(built, opts = {}) {
         resolver.stageIdByLabel.set(stage.label, sid);
         stageIds.push(sid);
         taskIds.push([]);
-        stage.lanes.forEach((lane, li) => {
+        stageLanes[si].forEach((lane, li) => {
             taskIds[si].push([]);
             lane.forEach((task) => {
                 if (seenTaskNames.has(task.name))
@@ -144,7 +147,7 @@ export function serialize(built, opts = {}) {
     const triggerNodeByRef = new Map();
     built.triggers.forEach((t, i) => triggerNodeByRef.set(t, triggerNodes[i]));
     built.stages.forEach((stage, si) => {
-        nodes.push(emitStage(stage, si, stageIds[si], taskIds[si], ids, resolver));
+        nodes.push(emitStage(stage, stageLanes[si], si, stageIds[si], taskIds[si], ids, resolver));
     });
     // ── Metadata (case-level) ──
     const metadata = {
@@ -382,7 +385,7 @@ export function applyPreservation(result, preservation, options = {}) {
         .filter((node) => String(node.type ?? '').endsWith('Stage'));
     for (const entry of preservation.taskFields ?? []) {
         const stage = stageNodes.find((candidate) => candidate.data?.label === entry.stage);
-        const task = stage?.data?.tasks?.[entry.lane]?.find((candidate) => candidate.displayName === entry.task);
+        const task = stageTask(stage, entry.task);
         // A brownfield edit may deliberately delete a typed task or its stage. Its
         // attached designer-only fields leave with that construct; surviving tasks
         // still collide-refuse below instead of letting preservation overwrite
@@ -408,7 +411,7 @@ export function applyPreservation(result, preservation, options = {}) {
     }
     for (const entry of preservation.omitTaskElementIds ?? []) {
         const stage = stageNodes.find((candidate) => candidate.data?.label === entry.stage);
-        const task = stage?.data?.tasks?.[entry.lane]?.find((candidate) => candidate.displayName === entry.task);
+        const task = stageTask(stage, entry.task);
         if (task)
             delete task.elementId;
     }
@@ -483,8 +486,8 @@ function applyPreservedIdentities(result, preservation) {
         takeConditions(stage?.data?.entryConditions, stageIdentity.entryConditions);
         takeConditions(stage?.data?.exitConditions, stageIdentity.exitConditions);
         takeSlas(stage?.data?.slaRules, stageIdentity.slaRules);
-        (stageIdentity.tasks ?? []).forEach((lane, laneIndex) => lane.forEach((taskIdentity) => {
-            const task = stage?.data?.tasks?.[laneIndex]?.find((candidate) => candidate.displayName === taskIdentity.name);
+        (stageIdentity.tasks ?? []).forEach((lane) => lane.forEach((taskIdentity) => {
+            const task = stageTask(stage, taskIdentity.name);
             take(task, taskIdentity.id);
             takeConditions(task?.entryConditions, taskIdentity.entryConditions);
             (taskIdentity.inputs ?? []).forEach((row, index) => take(task?.data?.inputs?.[index], row.id));
@@ -729,13 +732,25 @@ function emitTriggers(triggers, ids, resolver) {
         };
     });
 }
-function emitStage(stage, si, stageId, laneTaskIds, ids, resolver) {
+/** A stage's task sets as the serializer writes them — one set per parallel task (`v31TaskSets`). */
+function laneSets(lanes) {
+    return v31TaskSets(lanes, (task) => task.entry.some((condition) => condition.rules.some((group) => group.some((r) => r.rule === 'runs-sequentially'))));
+}
+/** One emitted task of a stage node, by its (case-unique) display name, in any set. */
+function stageTask(stage, name) {
+    for (const lane of stage?.data?.tasks ?? [])
+        for (const candidate of lane)
+            if (candidate.displayName === name)
+                return candidate;
+    return undefined;
+}
+function emitStage(stage, lanes, si, stageId, laneTaskIds, ids, resolver) {
     const data = {
         [CASE_FORMAT_PROFILE.stageLabelField]: stage.label,
         parentElement: { id: 'root', type: 'case-management:root' },
         isInvalidDropTarget: false,
         isPendingParent: false,
-        tasks: stage.lanes.map((lane, li) => lane.map((task, ti) => emitTask(task, stage.label, laneTaskIds[li][ti], ids, resolver))),
+        tasks: lanes.map((lane, li) => lane.map((task, ti) => emitTask(task, stage.label, laneTaskIds[li][ti], ids, resolver))),
     };
     if (stage.description)
         data.description = stage.description;

package/dist/case/task-sets.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Task sets (`data.tasks[i]`) in the shape Case schema V31+ keeps unchanged.
+ *
+ * V31 made a set a sequential chain. Its V30→V31 migration — which the product
+ * runs on every V30 document it reads — keeps a set unchanged only when it holds
+ * one task, or when every task in it declares a `runs-sequentially` rule. Every
+ * other task in a shared set has its entry conditions REPLACED by a generated
+ * `runs-sequentially` condition, so two parallel `current-stage-entered` tasks
+ * written into one set ran one after the other, under conditions the author
+ * never wrote, and nothing reported it (builder-sdk#1248).
+ *
+ * At V30 the regrouping is free: the converter reads a set's position only for
+ * tasks whose every rule is `runs-sequentially`; every other task runs on its
+ * own entry condition wherever it sits. A task the migration would rewrite
+ * therefore moves to a set of its own right after the set it was written in, so
+ * the stage's flattened task order — the order the converter writes its rules
+ * in — is unchanged too. Tasks the migration treats as sequential keep their
+ * set. The only case that reorders is a set that mixed both kinds: its
+ * sequential tasks stay together and the others follow.
+ *
+ * Generic over the task shape so the serializer (built tasks) and the tests
+ * (emitted JSON) apply the one rule.
+ */
+export declare function v31TaskSets<T>(sets: readonly (readonly T[])[], runsSequentially: (task: T) => boolean): T[][];
+/** The V30→V31 migration's own test, on emitted task JSON: any rule of any entry condition is `runs-sequentially`. */
+export declare function taskJsonRunsSequentially(task: {
+    entryConditions?: Array<{
+        rules?: Array<Array<{
+            rule?: string;
+        }>>;
+    }>;
+}): boolean;

package/dist/case/task-sets.js

@@ -0,0 +1,43 @@
+/**
+ * Task sets (`data.tasks[i]`) in the shape Case schema V31+ keeps unchanged.
+ *
+ * V31 made a set a sequential chain. Its V30→V31 migration — which the product
+ * runs on every V30 document it reads — keeps a set unchanged only when it holds
+ * one task, or when every task in it declares a `runs-sequentially` rule. Every
+ * other task in a shared set has its entry conditions REPLACED by a generated
+ * `runs-sequentially` condition, so two parallel `current-stage-entered` tasks
+ * written into one set ran one after the other, under conditions the author
+ * never wrote, and nothing reported it (builder-sdk#1248).
+ *
+ * At V30 the regrouping is free: the converter reads a set's position only for
+ * tasks whose every rule is `runs-sequentially`; every other task runs on its
+ * own entry condition wherever it sits. A task the migration would rewrite
+ * therefore moves to a set of its own right after the set it was written in, so
+ * the stage's flattened task order — the order the converter writes its rules
+ * in — is unchanged too. Tasks the migration treats as sequential keep their
+ * set. The only case that reorders is a set that mixed both kinds: its
+ * sequential tasks stay together and the others follow.
+ *
+ * Generic over the task shape so the serializer (built tasks) and the tests
+ * (emitted JSON) apply the one rule.
+ */
+export function v31TaskSets(sets, runsSequentially) {
+    const out = [];
+    for (const set of sets) {
+        if (set.length <= 1 || set.every(runsSequentially)) {
+            out.push([...set]);
+            continue;
+        }
+        const sequential = set.filter(runsSequentially);
+        if (sequential.length)
+            out.push(sequential);
+        for (const task of set)
+            if (!runsSequentially(task))
+                out.push([task]);
+    }
+    return out;
+}
+/** The V30→V31 migration's own test, on emitted task JSON: any rule of any entry condition is `runs-sequentially`. */
+export function taskJsonRunsSequentially(task) {
+    return (task.entryConditions ?? []).some((condition) => (condition.rules ?? []).some((group) => group.some((r) => r?.rule === 'runs-sequentially')));
+}

package/dist/flow-variables.d.ts

@@ -9,6 +9,8 @@ export interface FlowGlobalDeclaration {
     subType?: string;
     schema?: Record<string, unknown>;
 }
+/** The keys of `variables` that hold declarations rather than name one (the map spelling). */
+export declare const CONTAINER_KEYS: ReadonlySet<string>;
 /** Read both supported Flow variable spellings into one declaration table. */
 export declare function readFlowGlobals(variables: unknown, strict?: boolean): FlowGlobalDeclaration[];
 /** The declaration fields `planFlowGlobals` reads (structurally a `VarDecl`). */

package/dist/flow-variables.js

@@ -1,5 +1,6 @@
 import { globalNameCollisionMessage, globalNameCollisions } from './core/global-names.js';
-const CONTAINER_KEYS = new Set(['globals', 'nodes', 'variableUpdates']);
+/** The keys of `variables` that hold declarations rather than name one (the map spelling). */
+export const CONTAINER_KEYS = new Set(['globals', 'nodes', 'variableUpdates']);
 const DIRECTIONS = new Set(['in', 'out', 'inout']);
 /** Read both supported Flow variable spellings into one declaration table. */
 export function readFlowGlobals(variables, strict = false) {

package/dist/merge-roundtrip.d.ts

@@ -33,7 +33,7 @@ interface RtFlow {
 /** One difference, or one inconsistency in the merged file. */
 export interface MergeFinding {
     /** Which comparison found it. */
-    kind: 'node-removed' | 'node-added' | 'node-type' | 'implicit-end' | 'edge-handle-renamed' | 'edge-rewired' | 'edge-removed' | 'edge-added' | 'handle-ids' | 'binding-removed' | 'binding-added' | 'undeclared-handle' | 'duplicate-binding' | 'agent-sidecar' | 'agent-storage' | 'agent-prompt-input' | 'agent-embedded-edit';
+    kind: 'node-removed' | 'node-added' | 'node-type' | 'implicit-end' | 'edge-handle-renamed' | 'edge-rewired' | 'edge-removed' | 'edge-added' | 'handle-ids' | 'binding-removed' | 'binding-added' | 'variable-added' | 'variable-changed' | 'undeclared-handle' | 'duplicate-binding' | 'agent-sidecar' | 'agent-storage' | 'agent-prompt-input' | 'agent-embedded-edit';
     /** The finding, phrased for the author, naming the node, edge or row. */
     message: string;
     /**

package/dist/merge-roundtrip.js

@@ -27,7 +27,10 @@
  * - switch case ids and human-task outcome ids, which name the handles the
  *   edges leave from;
  * - binding rows by what they bind (`core/binding-identity.ts`), never by the
- *   row `id`.
+ *   row `id`;
+ * - root `variables` entries (`globals`, `nodes`) by id. Merge restores an
+ *   entry the author did not touch (merge-variables.ts), so this reports only
+ *   what slipped past that rule, such as a section taken whole.
  *
  * Two checks run on the MERGED file whatever the baseline says, because merge
  * mixes sources (untouched nodes from the original, edges from the edited file):
@@ -52,6 +55,7 @@
 import { bindingIdentity } from './core/binding-identity.js';
 import { expandSourceHandles } from './core/definition-handles.js';
 import { OUTCOME_HANDLE_NODE_TYPES } from './core/hitl-routing.js';
+import { isDeltaSpelling, stableJson } from './merge-variables.js';
 /** A file's definitions, keyed `nodeType@version`. */
 function defsOf(f) {
     const out = new Map();
@@ -276,6 +280,33 @@ export function roundTripFindings(original, baseline, merged) {
             out.push({ kind: 'binding-added', refuses: true, message: `the round trip adds a binding row for ${bindingText(r)}; merge will write it.` });
         }
     }
+    // ── Root variables, by section and id ──
+    // A map-spelled original is taken whole on any edit (merge-variables.ts), so
+    // what that carries is reported but never refused: the author cannot avoid it.
+    const refuses = isDeltaSpelling(original.variables);
+    const tail = refuses ? '' : ' (the original uses the map spelling, so merge takes the edited section whole; not refused under --strict)';
+    for (const section of ['globals', 'nodes']) {
+        const entries = (f) => {
+            const list = f.variables?.[section];
+            return new Map((Array.isArray(list) ? list : [])
+                .filter((v) => typeof v?.id === 'string').map((v) => [v.id, v]));
+        };
+        const o = entries(original);
+        const b = entries(baseline);
+        const m = entries(merged);
+        for (const [id, bv] of b) {
+            const mv = m.get(id);
+            const ov = o.get(id);
+            if (mv === undefined || stableJson(mv) !== stableJson(bv) || (ov !== undefined && stableJson(ov) === stableJson(bv)))
+                continue;
+            if (ov === undefined) {
+                out.push({ kind: 'variable-added', refuses, message: `the round trip adds variables.${section} "${id}"; merge will write it${tail}.` });
+                continue;
+            }
+            const fields = [...new Set([...Object.keys(ov), ...Object.keys(bv)])].filter((k) => stableJson(ov[k]) !== stableJson(bv[k]));
+            out.push({ kind: 'variable-changed', refuses, message: `the round trip rewrites ${fields.join(', ')} of variables.${section} "${id}"; merge will write it${tail}.` });
+        }
+    }
     return out;
 }
 /** The source handles a node's definition declares, or `undefined` when they cannot be known. */

package/dist/merge-variables.d.ts

@@ -0,0 +1,19 @@
+type Json = unknown;
+/** JSON with object keys sorted, so key order is not a difference. */
+export declare function stableJson(v: Json): string;
+/**
+ * Whether `variables` is spelled the way the delta reads it: absent, or an
+ * object whose keys are only the container keys (`globals`, `nodes`,
+ * `variableUpdates`). A map-spelled original is not, and is taken whole.
+ */
+export declare function isDeltaSpelling(variables: Json): boolean;
+/**
+ * The merged root `variables`. `goneNodeIds` are the original's nodes (root and
+ * subflows) the merged file no longer has: a node variable, or a
+ * `variableUpdates` key, kept from the original for one of them is dropped
+ * with the node.
+ */
+export declare function mergeVariables(original: Json, edited: Json, baseline: {
+    variables?: Json;
+} | undefined, goneNodeIds: Set<string>): Json;
+export {};

package/dist/merge-variables.js

@@ -0,0 +1,191 @@
+/**
+ * merge-variables — the delta rule for a flow's root `variables` (#1261).
+ *
+ * Nodes merge as a delta: one the author did not touch (edited equals
+ * baseline) is restored from the original. `variables` follow the same rule.
+ *
+ * The same rule, applied at three levels:
+ *
+ *   - the whole section: edited equals baseline → the original's, verbatim;
+ *   - a top-level key (`globals`, `nodes`, `variableUpdates`): edited equals
+ *     baseline → the original's (absent stays absent);
+ *   - an entry of an id-keyed list (`globals`, `nodes`) or a key of a map
+ *     (`variableUpdates`): the same, and inside an entry each field the same,
+ *     so an edited global's new `type` lands without the `name` compile adds.
+ *
+ * Presence follows the same logic. An entry the edited file lacks was removed
+ * by the author when the baseline has it, and lost by the round trip when it
+ * does not (kept). An entry the original lacks is the author's when the
+ * baseline lacks it or differs, and the round trip's when the baseline has it
+ * unchanged (dropped).
+ *
+ * Example, after the author changes `creditAmount`'s type and nothing else:
+ *
+ *     original  { id: 'creditAmount', direction: 'out', type: 'string' }
+ *     baseline  { id: 'creditAmount', name: 'creditAmount', direction: 'out', type: 'string' }
+ *     edited    { id: 'creditAmount', name: 'creditAmount', direction: 'out', type: 'number' }
+ *     merged    { id: 'creditAmount', direction: 'out', type: 'number' }
+ *
+ * An original with no `variables` section, or with no `globals` / `nodes` /
+ * `variableUpdates` key, is treated as empty there: what compile minted for
+ * the untouched part is still the round trip's, and only the author's
+ * additions land.
+ *
+ * Without a baseline there is nothing to tell an edit from the round trip, so
+ * the edited section is taken whole. So is a section whose original uses a key
+ * this file does not know (the older map spelling, `variables.city = {...}`)
+ * once the author changed anything: mixing two spellings in one section is
+ * worse than taking the compile's. The round-trip report still lists what that
+ * carries, but does not refuse it under `--strict`, because the author cannot
+ * avoid it short of making no edit ({@link isDeltaSpelling}).
+ */
+import { jsonClone } from './core/json-clone.js';
+import { CONTAINER_KEYS } from './flow-variables.js';
+/** `jsonClone`, which also passes `undefined` (an absent section or key) through. */
+const copy = (v) => (v === undefined ? v : jsonClone(v));
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+/** JSON with object keys sorted, so key order is not a difference. */
+export function stableJson(v) {
+    return JSON.stringify(v, (_k, val) => (isObj(val)
+        ? Object.fromEntries(Object.keys(val).sort().map((k) => [k, val[k]]))
+        : val));
+}
+const same = (a, b) => stableJson(a) === stableJson(b);
+/**
+ * Whether `variables` is spelled the way the delta reads it: absent, or an
+ * object whose keys are only the container keys (`globals`, `nodes`,
+ * `variableUpdates`). A map-spelled original is not, and is taken whole.
+ */
+export function isDeltaSpelling(variables) {
+    return variables === undefined || (isObj(variables) && Object.keys(variables).every((k) => CONTAINER_KEYS.has(k)));
+}
+/**
+ * The merged root `variables`. `goneNodeIds` are the original's nodes (root and
+ * subflows) the merged file no longer has: a node variable, or a
+ * `variableUpdates` key, kept from the original for one of them is dropped
+ * with the node.
+ */
+export function mergeVariables(original, edited, baseline, goneNodeIds) {
+    if (!baseline)
+        return copy(edited);
+    const base = baseline.variables;
+    if (same(edited, base))
+        return withoutGoneUpdates(copy(original), goneNodeIds);
+    if (!isDeltaSpelling(original) || !isObj(edited))
+        return copy(edited);
+    const orig = isObj(original) ? original : {};
+    const baseObj = isObj(base) ? base : {};
+    const out = {};
+    for (const key of keysInOrder(orig, edited)) {
+        const updates = key === 'variableUpdates';
+        const inner = updates
+            ? (o, b, e) => (isObj(o) && isObj(e) ? mergeFields(o, isObj(b) ? b : undefined, e) : copy(e))
+            : (o, b, e) => mergeList(o, b, e, goneNodeIds);
+        // A section the original lacks but the round trip writes is merged as an
+        // empty one, so its minted entries stay out and only the author's land.
+        const absent = !(key in orig) && key in baseObj && key in edited && !same(edited[key], baseObj[key]);
+        const value = absent
+            ? nonEmpty(inner(updates ? {} : [], baseObj[key], edited[key]))
+            : mergeKey(orig[key], baseObj[key], edited[key], key in orig, key in baseObj, key in edited, inner);
+        if (value !== undefined)
+            out[key] = value;
+    }
+    if (original === undefined && Object.keys(out).length === 0)
+        return undefined;
+    return withoutGoneUpdates(out, goneNodeIds);
+}
+/** `undefined` for an empty list or map, so an absent section stays absent. */
+function nonEmpty(v) {
+    if (Array.isArray(v))
+        return v.length ? v : undefined;
+    if (isObj(v))
+        return Object.keys(v).length ? v : undefined;
+    return v;
+}
+/**
+ * `variables` without the `variableUpdates` keys (node ids) of nodes the merge
+ * dropped. A key the round trip lost is kept from the original, so without
+ * this it would outlive its node.
+ */
+function withoutGoneUpdates(variables, goneNodeIds) {
+    const updates = isObj(variables) ? variables.variableUpdates : undefined;
+    if (!isObj(updates) || !Object.keys(updates).some((k) => goneNodeIds.has(k)))
+        return variables;
+    return { ...variables, variableUpdates: Object.fromEntries(Object.entries(updates).filter(([k]) => !goneNodeIds.has(k))) };
+}
+/** Original's keys in its order, then the edited file's new ones. */
+function keysInOrder(original, edited) {
+    return [...Object.keys(original), ...Object.keys(edited).filter((k) => !(k in original))];
+}
+/**
+ * One key's value under the delta rule; `undefined` = leave the key out.
+ * `inner` merges a value both sides have and the author changed.
+ */
+function mergeKey(o, b, e, inOriginal, inBaseline, inEdited, inner) {
+    if (!inEdited)
+        return inBaseline || !inOriginal ? undefined : copy(o); // removed by the author / lost by the round trip
+    if (inBaseline && same(e, b))
+        return inOriginal ? copy(o) : undefined; // untouched
+    if (!inOriginal)
+        return copy(e); // the author's addition
+    return inner(o, b, e);
+}
+/** An id-keyed list (`globals`, `nodes`): per entry, then per field. */
+function mergeList(o, b, e, goneNodeIds) {
+    if (!idList(o) || !idList(e))
+        return copy(e);
+    const base = new Map((idList(b) ? b : []).map((x) => [x.id, x]));
+    const edits = new Map(e.map((x) => [x.id, x]));
+    const out = [];
+    for (const entry of o) {
+        const id = entry.id;
+        if (!edits.has(id)) {
+            // The author removed it (baseline has it), or the round trip lost it; a
+            // lost node variable whose node is gone goes with the node.
+            if (!base.has(id) && !boundToGoneNode(entry, goneNodeIds))
+                out.push(copy(entry));
+            continue;
+        }
+        const ed = edits.get(id);
+        out.push(base.has(id) && same(ed, base.get(id)) ? copy(entry) : mergeFields(entry, base.get(id), ed));
+    }
+    const originalIds = new Set(o.map((x) => x.id));
+    for (const [i, ed] of e.entries()) {
+        const id = ed.id;
+        if (originalIds.has(id) || (base.has(id) && same(ed, base.get(id))))
+            continue; // kept above / minted by the round trip
+        out.splice(insertAt(out, e, i), 0, copy(ed));
+    }
+    return out;
+}
+/** After the nearest earlier edited entry already in `out`, else first. */
+function insertAt(out, edited, i) {
+    for (let j = i - 1; j >= 0; j--) {
+        const at = out.findIndex((x) => x.id === edited[j].id);
+        if (at >= 0)
+            return at + 1;
+    }
+    return 0;
+}
+/**
+ * An object the author changed — a list entry, or the `variableUpdates` map
+ * (keyed by node id): each key under the delta rule, each value taken whole,
+ * keys in the original's order.
+ */
+function mergeFields(o, b, e) {
+    const base = b ?? {};
+    const out = {};
+    for (const key of keysInOrder(o, e)) {
+        const v = mergeKey(o[key], base[key], e[key], key in o, key in base, key in e, (_o, _b, ev) => copy(ev));
+        if (v !== undefined)
+            out[key] = v;
+    }
+    return out;
+}
+function idList(v) {
+    return Array.isArray(v) && v.every((x) => isObj(x) && typeof x.id === 'string');
+}
+function boundToGoneNode(entry, goneNodeIds) {
+    const nodeId = isObj(entry.binding) ? entry.binding.nodeId : undefined;
+    return typeof nodeId === 'string' && goneNodeIds.has(nodeId);
+}

package/dist/merge.d.ts

@@ -26,7 +26,8 @@
  *
  * Layout, `metadata`, `solutionId`, `projectId`, `runtime` and `layout` are
  * preserved from the original; `subflows` and edges (with their ids) come from
- * `edited`; `definitions` and `bindings` are unioned
+ * `edited`; root `variables` merge as a delta per entry, like nodes
+ * (merge-variables.ts); `definitions` and `bindings` are unioned
  * (original wins on conflict, since the original's are the tenant-resolved
  * authority). A binding row's identity is what it binds, not its row id, and a
  * row the no-edit recompile minted only for nodes merge kept from the original
@@ -143,8 +144,8 @@ export interface MergeOptions {
      * - with a `baseline`, each wire-identity difference between the baseline
      *   (the no-edit round trip) and the original — a node or edge added, dropped
      *   or rewired, a switch case id or human-task outcome id renamed, a binding
-     *   row added or dropped — that the merged file still carries, i.e. the
-     *   author's edit did not undo it;
+     *   row added or dropped, a root `variables` entry added or rewritten — that
+     *   the merged file still carries, i.e. the author's edit did not undo it;
      * - an edited node whose `typeVersion` differs from the original node with
      *   the same id, because the edit took the SDK's version;
      * - a merged edge whose `sourcePort` is not a handle its source node declares,

package/dist/merge.js

@@ -26,7 +26,8 @@
  *
  * Layout, `metadata`, `solutionId`, `projectId`, `runtime` and `layout` are
  * preserved from the original; `subflows` and edges (with their ids) come from
- * `edited`; `definitions` and `bindings` are unioned
+ * `edited`; root `variables` merge as a delta per entry, like nodes
+ * (merge-variables.ts); `definitions` and `bindings` are unioned
  * (original wins on conflict, since the original's are the tenant-resolved
  * authority). A binding row's identity is what it binds, not its row id, and a
  * row the no-edit recompile minted only for nodes merge kept from the original
@@ -89,6 +90,7 @@ import { MergeRefusedError, mergedFileFindings, roundTripFindings } from './merg
 import { placeAddedNodes } from './node-placement.js';
 import { mergeAgentSidecars } from './merge-sidecars.js';
 import { embeddedAgentFindings, isEmbeddedAgent, mergeEmbeddedAgentNode } from './merge-embedded-agent.js';
+import { mergeVariables } from './merge-variables.js';
 export { MergeRefusedError } from './merge-roundtrip.js';
 function byId(nodes) {
     return new Map((nodes ?? []).map((n) => [n.id, n]));
@@ -256,8 +258,7 @@ function mergeFlowFindings(original, edited, options) {
     result.nodes = finalNodes;
     // Nodes present in the original but absent from `edited` were deleted by the
     // user; they are simply not carried over.
-    // ── Variables & subflows: the edited flow is authoritative (the user's graph). ──
-    result.variables = jsonClone(edited.variables);
+    // ── Subflows: the edited flow is authoritative (the user's graph). ──
     result.subflows = jsonClone(edited.subflows ?? {});
     // A subflow is taken from `edited` whole, so an embedded agent inside one
     // would flip to the edited shell even with no edit. Keep it embedded too.
@@ -267,6 +268,20 @@ function mergeFlowFindings(original, edited, options) {
     if (options.baseline)
         keepOriginalSourcesInSubflows(original, result.subflows, options.baseline);
     const subflowScopes = Object.values(result.subflows);
+    // ── Variables: the same delta as nodes, per entry — what the author did not
+    //    change stays the original's, so compile's own spellings (an added
+    //    `name`, a re-derived End output type) do not reach the file (#1261).
+    //    See merge-variables.ts. ──
+    const mergedNodeIds = new Set([...finalNodes, ...subflowScopes.flatMap((sf) => sf?.nodes ?? [])].map((n) => n.id));
+    const goneNodeIds = new Set([
+        ...(original.nodes ?? []),
+        ...Object.values(original.subflows ?? {}).flatMap((sf) => sf?.nodes ?? []),
+    ].map((n) => n.id).filter((id) => !mergedNodeIds.has(id)));
+    const variables = mergeVariables(original.variables, edited.variables, options.baseline, goneNodeIds);
+    if (variables === undefined)
+        delete result.variables;
+    else
+        result.variables = variables;
     // ── Edges: the edited graph's edges define the wiring, under the edited
     //    file's own ids. compile draws every edge id — root AND subflows — from
     //    one file-wide counter, so they are already unique. Renumbering the root

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.33.0",
+  "version": "6.33.2",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -93,5 +93,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "8875d03ffd74e131e88778405d2eb401dd13d0e9"
+  "gitref": "04124f15f4e70827cb18bbd0f52c0bf676ceedd1"
 }