@uipath/maestro-builder-sdk 6.11.6 → 6.12.0

package/dist/bpmn/decompile.js

@@ -60,6 +60,12 @@ import { BPMN_SCHEMA_VERSIONS } from './format-profile.js';
 import { preserveSchemaVersion } from '../schema-version.js';
 const require = createRequire(import.meta.url);
 const uipathDescriptor = require('./uipath-moddle.v1.json');
+/**
+ * Set while the nested style writes a sequence-mode root: a sub-process body the
+ * flat renderer writes inherits the mode, and its trailing `.sequenceFlow()`s would
+ * then double every edge, so the body pins `.flowMode('explicit')` for itself.
+ */
+let pinExplicitInBodies = false;
 // ─── Source emitters ──────────────────────────────────────────────────────────
 /**
  * A JS/TS string literal.
@@ -203,6 +209,15 @@ class Chain {
     add(call) {
         this.lines.push(`${this.indent}${call}`);
     }
+    /**
+     * Put a call at the FRONT of the chain.
+     *
+     * For the declarations that belong at the top but are only known once the body has
+     * been walked — `.flowIds()`, which lists the implied edges the walk decided to pin.
+     */
+    addFirst(call) {
+        this.lines.unshift(`${this.indent}${call}`);
+    }
     get all() {
         return this.lines;
     }
@@ -463,14 +478,23 @@ function emitTypedNode(chain, el, payload, type) {
     const ctx = contextOf(payload);
     const inputRows = payload.input ?? [];
     let inputs;
+    let verbatimInputs;
     if (spec.inputPattern === 'separateInputs') {
-        // A row's value is in its BODY or its `value` attribute, and which one is
-        // decided by the field's declared type — see `payloadInput` in typed-node.ts.
-        // Reading only the body silently produced `{}` for every scalar row, so a
-        // string correlation reference round-tripped to `value="[object Object]"`.
-        // Nothing before this authored a separateInputs type with a declared scalar
-        // field, so every row really was a body and the bug had nowhere to appear.
-        inputs = Object.fromEntries(inputRows.map((r) => [r.name, r.body !== undefined ? safeJson(r.body) : r.value]));
+        if (inputRowsNeedSpellingOut(inputRows, spec)) {
+            // A row the record cannot reproduce — a connector parameter whose `target` is
+            // `query` rather than its own name, a type the registry does not declare — is
+            // spelled out as `inputRows`, the way context and output rows are.
+            verbatimInputs = emitInputRows(inputRows);
+        }
+        else {
+            // A row's value is in its BODY or its `value` attribute, and which one is
+            // decided by the field's declared type — see `payloadInput` in typed-node.ts.
+            // Reading only the body silently produced `{}` for every scalar row, so a
+            // string correlation reference round-tripped to `value="[object Object]"`.
+            // Nothing before this authored a separateInputs type with a declared scalar
+            // field, so every row really was a body and the bug had nowhere to appear.
+            inputs = Object.fromEntries(inputRows.map((r) => [r.name, r.body !== undefined ? safeJson(r.body) : r.value]));
+        }
     }
     else if (inputRows.length) {
         inputs = safeJson(inputRows[0].body);
@@ -488,6 +512,7 @@ function emitTypedNode(chain, el, payload, type) {
         ['contextRows', verbatimContext],
         ['inputSchema', payload.context?.inputSchema?.body !== undefined ? jsonLiteral(payload.context.inputSchema.body) : undefined],
         ['inputs', record(inputs)],
+        ['inputRows', verbatimInputs],
         ['outputRows', verbatimRows],
         ['outputVar', verbatimRows === undefined && outputVar !== undefined && outputVar !== defaultVar ? str(outputVar) : undefined],
         ['outputs', verbatimRows === undefined ? record(extras) : undefined],
@@ -499,6 +524,70 @@ function emitTypedNode(chain, el, payload, type) {
         ['loop', emitLoop(el)],
     ]))})`);
 }
+/**
+ * Whether `inputs` — a name→value record — would reproduce these `separateInputs`
+ * rows, or whether they need spelling out as `inputRows`.
+ *
+ * The record derives a row's target and type (the registry's declaration, else the
+ * key and `json`-for-structured / `string`-for-scalar — see `inputRows` in
+ * typed-node.ts), so a row is only reproducible when it carries exactly those. A
+ * connector's flat parameter rows never do: `name="start" … target="query"`.
+ */
+function inputRowsNeedSpellingOut(rows, spec) {
+    const declared = new Map(spec.inputs.map((f) => [f.name, f]));
+    return rows.some((r) => {
+        const field = declared.get(r.name);
+        if (r.value === undefined && r.body === undefined)
+            return true;
+        if (r.target !== (field?.target ?? r.name))
+            return true;
+        const derivedType = field?.type ?? (r.body !== undefined ? 'json' : 'string');
+        return (r.type ?? 'string') !== derivedType;
+    });
+}
+/** The payload rows as `TypedInputRow` option source, in document order. */
+function emitInputRows(rows) {
+    if (!rows.length)
+        return undefined;
+    return `[${rows
+        .map((r) => opts([
+        ['name', str(r.name)],
+        ['type', r.type !== undefined ? str(r.type) : undefined],
+        ['target', r.target !== undefined ? str(r.target) : undefined],
+        ['value', r.value !== undefined ? str(r.value) : undefined],
+        ['body', r.body !== undefined ? (r.type === 'json' ? jsonLiteral(r.body) : str(String(r.body))) : undefined],
+    ]))
+        .join(', ')}]`;
+}
+/**
+ * The serializer's default scope for a public declaration, read off the artifact —
+ * the mirror of `publicDeclarationScope` in serialize.ts, so a declaration the
+ * platform scopes the way the SDK would is emitted without an `elementId`.
+ */
+function publicDeclarationScopeOf(process, processId) {
+    const elements = process.flowElements ?? [];
+    // "Manual" must mean the same thing here as in the emitter, which asks
+    // `n.event === undefined && n.trigger === undefined`. Excluding only a `uipath:Event`
+    // payload did not match it: a trigger start is emitted through its REGISTRY spec, and
+    // `Intsvc.TimerTrigger`'s tag is `uipath:activity`, so a trigger with no timer came
+    // back as a `bpmn:StartEvent` with empty `eventDefinitions` and a `uipath:Activity`
+    // payload — manual to this side, not manual to the emitter. The round trip then moved
+    // a public input's `elementId` from the trigger start to the process. Excluding ANY
+    // typed payload makes the two agree for every shape the SDK can emit.
+    const manualStarts = elements.filter((el) => el.$type === 'bpmn:StartEvent' && !(el.eventDefinitions ?? []).length && payloadOf(el) === undefined);
+    const ends = elements.filter((el) => el.$type === 'bpmn:EndEvent');
+    return (kind, v) => {
+        if (kind === 'input')
+            return manualStarts.length === 1 ? manualStarts[0].id : processId;
+        if (kind === 'output') {
+            const writers = ends.filter((el) => (payloadOf(el)?.output ?? []).some((row) => row.var === v.id));
+            if (writers.length === 1)
+                return writers[0].id;
+            return ends.length === 1 ? ends[0].id : processId;
+        }
+        return processId;
+    };
+}
 /** Mirrors the emitter's own default-variable naming, so a default is not echoed. */
 function identifierize(name) {
     const words = name.split(/[^A-Za-z0-9]+/).filter(Boolean);
@@ -521,6 +610,15 @@ function safeJson(body) {
         return body;
     }
 }
+/**
+ * The `uipath:scriptVersion` a script task carries — `'v1'` when it carries none,
+ * because that is what an absent element means to the runtime (`IsVersionAtLeast`
+ * treats it as the old, spread-result contract).
+ */
+function scriptVersionOf(el) {
+    const sv = (el.extensionElements?.values ?? []).find((x) => x.$type === 'uipath:ScriptVersion');
+    return typeof sv?.value === 'string' && sv.value.trim() !== '' ? sv.value : 'v1';
+}
 /** A `uipath:mapping` script task. */
 function emitScriptTask(chain, el, payload, type) {
     const args = (payload?.input ?? []).find((r) => r.name === 'args');
@@ -537,6 +635,10 @@ function emitScriptTask(chain, el, payload, type) {
         ['name', el.name !== undefined ? str(el.name) : undefined],
         ['script', str(el.script ?? '')],
         ['scriptFormat', el.scriptFormat && el.scriptFormat !== 'JavaScript' ? str(el.scriptFormat) : undefined],
+        // The builder's default is v3; anything else is load-bearing (it selects the
+        // runtime's result shape) and must survive the round trip. An absent element
+        // is spelled `'v1'`, the meaning it has to the runtime.
+        ['scriptVersion', scriptVersionOf(el) !== 'v3' ? str(scriptVersionOf(el)) : undefined],
         // Only when it is neither the contract's value nor the invalid one this SDK
         // used to emit. `BPMN.ScriptTask` is NORMALISED AWAY rather than preserved:
         // the runtime contract has no such type, so reproducing it would propagate a
@@ -594,6 +696,666 @@ function emitScope(chain, container, depth, indent) {
         ]))})`);
     }
 }
+// ─── The lift: flat regions → the nesting constructs (`style: 'nested'`) ───────
+//
+// Every construct the builder offers lowers to plain nodes and flows, so a flat
+// graph can be read back into the construct wherever the pattern holds exactly.
+// The rules below are deliberately conservative — each one names a shape the
+// construct is KNOWN to lower to — and `decompile-cli` still builds both sources
+// and compares the graphs before it writes the nested one. Anything the rules
+// cannot prove stays flat, in the same file, next to what was lifted.
+const LIFT_GATEWAYS = new Set(['exclusiveGateway', 'inclusiveGateway', 'parallelGateway', 'eventBasedGateway']);
+function scopeGraph(container) {
+    const g = { elements: [], byId: new Map(), flows: [], outs: new Map(), ins: new Map() };
+    for (const el of container.flowElements ?? []) {
+        if (el.$type === 'bpmn:SequenceFlow') {
+            g.flows.push(el);
+            const s = el.sourceRef?.id;
+            const t = el.targetRef?.id;
+            if (s !== undefined)
+                g.outs.set(s, [...(g.outs.get(s) ?? []), el]);
+            if (t !== undefined)
+                g.ins.set(t, [...(g.ins.get(t) ?? []), el]);
+            continue;
+        }
+        g.elements.push(el);
+        g.byId.set(el.id, el);
+    }
+    return g;
+}
+/** The id the builder derives for an implied edge between a flow's ends. */
+function derivedFlowId(f) {
+    return `Flow_${f.sourceRef?.id}_${f.targetRef?.id}`;
+}
+/** Whether a flow's id is the one the builder derives, so an implied edge reproduces it. */
+function derivableFlow(f) {
+    return f.id === derivedFlowId(f);
+}
+/**
+ * Consume a flow into a construct: it is no longer written as `.sequenceFlow()`, and
+ * when its id is not the derived one the recompile renames it — recorded on the
+ * summary so the CLI can verify the graphs modulo exactly those ids and report them.
+ */
+function implyFlow(plan, f) {
+    plan.impliedFlows.add(f.id);
+    if (derivableFlow(f))
+        return;
+    // The id is not the one the construct derives. PIN it rather than let the recompile
+    // rename it: `bpmn merge` keys every element by id, flows included, so a renamed flow
+    // reads as a new one and the original — with its diagram edge — is deleted, and any
+    // gateway `default` preserved from the original is left naming an id that is gone.
+    // `.flowIds()` keeps the edge implied and gives it the id it came with.
+    if (plan.relabel)
+        plan.pinned.push({ source: f.sourceRef?.id, target: f.targetRef?.id, id: f.id });
+    else
+        plan.summary.renamedFlows.push({ from: f.id, to: derivedFlowId(f) });
+}
+/**
+ * The first flow of an arm that carries a label the construct cannot keep, or
+ * undefined. An implied edge has no `name`; only a `choose` arm's ENTRY flow keeps its
+ * label (as `label`). An empty `name=""` — designer residue on many imports — counts
+ * as no label, and is dropped on a relabelled edge.
+ */
+function labelledImpliedFlow(flows, entryKeepsLabel, kept = new Set()) {
+    return flows.find((f, i) => typeof f.name === 'string' && f.name !== '' && !(i === 0 && entryKeepsLabel) && !kept.has(f.id));
+}
+/** The flows a lift keeps the label of — every `choose` arm's entry flow, nested constructs' included. */
+function labelKeptFlows(lift, into = new Set()) {
+    for (const a of lift.arms) {
+        if (lift.construct === 'choose')
+            into.add(a.flow.id);
+        for (const item of a.arm.items)
+            if ('lift' in item)
+                labelKeptFlows(item.lift, into);
+    }
+    return into;
+}
+function isEventSubProcess(el) {
+    return el.$type === 'bpmn:SubProcess' && el.triggeredByEvent === true;
+}
+/** An element an arm may contain: something with one way in and one way out, or an end. */
+function isArmNode(el) {
+    const kind = localName(el.$type);
+    return !LIFT_GATEWAYS.has(kind) && kind !== 'boundaryEvent' && kind !== 'startEvent' && !isEventSubProcess(el);
+}
+/**
+ * Follow one path from `entry` as far as an arm can own it.
+ *
+ * The arm owns a chain of elements each with exactly one incoming flow (the
+ * previous one) and exactly one outgoing, and it ends at an end event, at a
+ * `joinOk` gateway, or — when the path reaches something it cannot own (a merge
+ * point, a consumed element, an element that fans out) — by jumping there with
+ * `.goto()`. A gateway the path alone leads into is lifted INSIDE the arm as a
+ * nested construct, and the arm carries on from that construct's exit when it has
+ * one. Every flow it implies must carry the derived id unless the lift may relabel.
+ *
+ * `taken` is shared with the caller and grows as the arm claims elements, so a
+ * nested construct's arms and the arms that follow see what this one owns.
+ */
+function walkArm(plan, entry, taken, joinOk, emitted) {
+    const { g, relabel } = plan;
+    const fail = (reason) => ({ ok: false, reason, elements: [], items: [], flows: [], labelKept: new Set(), end: 'terminal' });
+    const elements = [];
+    const items = [];
+    const flows = [];
+    const labelKept = new Set();
+    const done = (end, extra = {}) => ({ ok: true, elements, items, flows, labelKept, end, ...extra });
+    let f = entry;
+    let tgt;
+    for (let guard = 0; guard < 10_000; guard++) {
+        if (f !== undefined) {
+            if (!relabel && !derivableFlow(f))
+                return fail(`flow "${f.id}" is not named Flow_<source>_<target>, which an implied edge would be`);
+            flows.push(f);
+            tgt = g.byId.get(f.targetRef?.id);
+            if (!tgt)
+                return fail(`flow "${f.id}" leaves the scope`);
+        }
+        if (!tgt)
+            return fail('the path does not end');
+        const incoming = (g.ins.get(tgt.id) ?? []).length;
+        // A join MERGES: a same-kind gateway only this path leads into is not the
+        // construct's join but a decision of its own, lifted inside the arm below.
+        if (joinOk(tgt) && incoming > 1)
+            return done('join', { join: tgt });
+        if (incoming > 1 || taken.has(tgt.id) || emitted.has(tgt.id))
+            return done('goto', { gotoTarget: tgt.id });
+        if (LIFT_GATEWAYS.has(localName(tgt.$type))) {
+            // A decision only this path leads to: lift it here, as the arm's next statement.
+            taken.add(tgt.id);
+            const lift = planBranch(plan, tgt, emitted, false, taken);
+            if (!lift) {
+                taken.delete(tgt.id);
+                return done('goto', { gotoTarget: tgt.id });
+            }
+            for (const a of lift.arms)
+                for (const el of a.arm.elements)
+                    taken.add(el.id);
+            if (lift.join)
+                taken.add(lift.join.id);
+            flows.push(...lift.consumedFlows);
+            labelKeptFlows(lift, labelKept);
+            items.push({ lift });
+            if (!lift.continuation)
+                return done('terminal');
+            // The construct's exit flow is already consumed; carry on AT the continuation.
+            f = undefined;
+            tgt = lift.continuation;
+            continue;
+        }
+        if (!isArmNode(tgt))
+            return done('goto', { gotoTarget: tgt.id });
+        if (localName(tgt.$type) === 'endEvent') {
+            elements.push(tgt);
+            items.push({ el: tgt });
+            taken.add(tgt.id);
+            return done('terminal');
+        }
+        const outs = g.outs.get(tgt.id) ?? [];
+        // An element that fans out (or dead-ends) is not an arm's to own; the arm jumps to
+        // it and the top level writes it with its flows explicit.
+        if (outs.length !== 1)
+            return done('goto', { gotoTarget: tgt.id });
+        elements.push(tgt);
+        items.push({ el: tgt });
+        taken.add(tgt.id);
+        f = outs[0];
+    }
+    return fail('the path does not end');
+}
+/** Whether an event carries exactly one authorable definition, and which. */
+function singleDefinition(el) {
+    const defs = el.eventDefinitions ?? [];
+    if (defs.length !== 1)
+        return undefined;
+    switch (defs[0].$type) {
+        case 'bpmn:ErrorEventDefinition':
+            return 'error';
+        case 'bpmn:TimerEventDefinition':
+            return 'timer';
+        case 'bpmn:MessageEventDefinition':
+            return 'message';
+        default:
+            return undefined;
+    }
+}
+/**
+ * Boundary events, lifted first: an activity's handlers are part of how the
+ * activity is rendered wherever it lands — at the top level or inside an arm.
+ */
+function planHandlers(plan) {
+    const { g } = plan;
+    for (const b of g.elements) {
+        if (localName(b.$type) !== 'boundaryEvent')
+            continue;
+        const host = g.byId.get(b.attachedToRef?.id);
+        const reject = (reason) => {
+            plan.summary.leftFlat.push({ id: b.id, reason });
+        };
+        if (!host || !isArmNode(host) || localName(host.$type) === 'endEvent') {
+            reject('attached to nothing an activity body can own');
+            continue;
+        }
+        if (!singleDefinition(b)) {
+            reject('carries no single error, timer or message definition');
+            continue;
+        }
+        const outs = g.outs.get(b.id) ?? [];
+        if (outs.length !== 1) {
+            reject(`has ${outs.length} outgoing flows; a handler's path leaves once`);
+            continue;
+        }
+        const trial = new Set(plan.taken);
+        const arm = walkArm(plan, outs[0], trial, () => false, new Set());
+        if (!arm.ok) {
+            reject(arm.reason ?? 'path not liftable');
+            continue;
+        }
+        const labelled = labelledImpliedFlow(arm.flows, false, arm.labelKept);
+        if (labelled) {
+            reject(`flow "${labelled.id}" on the handler's path carries the label "${labelled.name}", which an implied edge cannot`);
+            continue;
+        }
+        plan.taken.add(b.id);
+        for (const id of trial)
+            plan.taken.add(id);
+        for (const f of arm.flows)
+            implyFlow(plan, f);
+        plan.handlers.set(host.id, [...(plan.handlers.get(host.id) ?? []), { boundary: b, arm }]);
+        plan.summary.handlers++;
+    }
+}
+/**
+ * A gateway and its arms as one construct, or nothing.
+ *
+ * @param mustTerminate - Inside an event sub-process body the construct is the last
+ * statement, so every arm has to end; a join would need a continuation.
+ */
+function planBranch(plan, gw, emitted, mustTerminate, seedTaken) {
+    const { g } = plan;
+    const kind = localName(gw.$type);
+    const reject = (reason) => {
+        plan.summary.leftFlat.push({ id: gw.id, reason });
+        return undefined;
+    };
+    const outs = g.outs.get(gw.id) ?? [];
+    if (outs.length < 2)
+        return reject('has fewer than two outgoing flows');
+    const construct = kind === 'parallelGateway' ? 'fork' : kind === 'eventBasedGateway' ? 'race' : 'choose';
+    const joinKind = construct === 'fork' ? 'parallelGateway' : construct === 'race' ? 'exclusiveGateway' : kind;
+    const defaultId = gw.default?.id;
+    if (construct === 'choose') {
+        for (const f of outs) {
+            const conditioned = f.conditionExpression?.body !== undefined;
+            if (f.id === defaultId && conditioned)
+                return reject(`default flow "${f.id}" also carries a condition`);
+            if (f.id !== defaultId && !conditioned)
+                return reject(`flow "${f.id}" has neither a condition nor the default`);
+        }
+    }
+    else if (outs.some((f) => f.conditionExpression?.body !== undefined)) {
+        return reject('a fork or race arm cannot carry a condition');
+    }
+    // An arm may own only what nothing has placed yet: an element already written at
+    // the top level (document order put it before its gateway) is reached with `.goto()`,
+    // not written a second time. Before flow ids could be relabelled almost no arm
+    // lifted on a real import, which is how this went unmeasured.
+    // A nested lift (this gateway met inside an arm) walks against the enclosing arm's
+    // ownership too, or its arms could claim what that arm already owns. The set is a
+    // trial copy: a rejected lift leaves nothing claimed.
+    const taken = new Set([...plan.taken, ...emitted, ...(seedTaken ?? [])]);
+    const arms = [];
+    const joinOk = (el) => LIFT_GATEWAYS.has(localName(el.$type)) && localName(el.$type) === joinKind && el.id !== gw.id;
+    for (const f of outs) {
+        const arm = walkArm(plan, f, taken, joinOk, emitted);
+        if (!arm.ok)
+            return reject(`arm from "${f.id}": ${arm.reason}`);
+        const labelled = labelledImpliedFlow(arm.flows, construct === 'choose', arm.labelKept);
+        if (labelled)
+            return reject(`flow "${labelled.id}" inside an arm carries the label "${labelled.name}", which an implied edge cannot`);
+        arms.push({ flow: f, arm, otherwise: f.id === defaultId });
+    }
+    // The join is the one gateway two or more arms reach; an arm that reaches a gateway
+    // alone, or a different one, jumps there instead — the builder writes a join only
+    // for two or more, and `.goto()` is exactly a flow to an element the arm does not own.
+    const reached = new Map();
+    for (const a of arms)
+        if (a.arm.end === 'join')
+            reached.set(a.arm.join.id, (reached.get(a.arm.join.id) ?? 0) + 1);
+    const shared = [...reached.entries()].filter(([, n]) => n >= 2).map(([id]) => id);
+    if (shared.length > 1)
+        return reject('arms rejoin at more than one shared gateway');
+    for (const a of arms) {
+        if (a.arm.end === 'join' && a.arm.join.id !== shared[0]) {
+            a.arm = { ...a.arm, end: 'goto', gotoTarget: a.arm.join.id, join: undefined };
+        }
+    }
+    const joins = arms.filter((a) => a.arm.end === 'join');
+    const joinIds = new Set(joins.map((a) => a.arm.join.id));
+    if (arms.filter((a) => a.arm.end === 'join' && a.arm.elements.length === 0).length > 1)
+        return reject('more than one empty arm');
+    let join;
+    let continuation;
+    const consumedFlows = [];
+    if (joinIds.size === 1) {
+        if (mustTerminate)
+            return reject('rejoins, where the enclosing body needs every arm to end');
+        join = joins[0].arm.join;
+        if ((g.ins.get(join.id) ?? []).length !== joins.length)
+            return reject(`join "${join.id}" has incoming flows from outside the arms`);
+        const jOuts = g.outs.get(join.id) ?? [];
+        if (jOuts.length !== 1)
+            return reject(`join "${join.id}" has ${jOuts.length} outgoing flows`);
+        if (!plan.relabel && !derivableFlow(jOuts[0]))
+            return reject(`flow "${jOuts[0].id}" out of the join is not named Flow_<source>_<target>`);
+        if (labelledImpliedFlow([jOuts[0]], false))
+            return reject(`flow "${jOuts[0].id}" out of the join carries a label, which an implied edge cannot`);
+        continuation = g.byId.get(jOuts[0].targetRef?.id);
+        if (!continuation)
+            return reject('the join leaves the scope');
+        if (emitted.has(continuation.id) || plan.taken.has(continuation.id)) {
+            return reject(`continuation "${continuation.id}" was already placed, so the construct's exit could not reach it`);
+        }
+        consumedFlows.push(jOuts[0]);
+    }
+    for (const a of arms)
+        consumedFlows.push(...a.arm.flows);
+    return { gateway: gw, construct, inclusive: kind === 'inclusiveGateway', arms, join, continuation, consumedFlows };
+}
+/** Every element a lift owns — its arms' elements, nested constructs' included, and its joins. */
+function ownedByLift(lift) {
+    const out = [lift.gateway.id];
+    if (lift.join)
+        out.push(lift.join.id);
+    for (const a of lift.arms) {
+        for (const el of a.arm.elements)
+            out.push(el.id);
+        for (const item of a.arm.items)
+            if ('lift' in item)
+                out.push(...ownedByLift(item.lift));
+    }
+    return out;
+}
+/** Every element a lift's arms jump to, nested constructs' included — the places the top level continues from. */
+function gotoTargetsOf(lift) {
+    const out = [];
+    for (const a of lift.arms) {
+        if (a.arm.end === 'goto' && a.arm.gotoTarget)
+            out.push(a.arm.gotoTarget);
+        for (const item of a.arm.items)
+            if ('lift' in item)
+                out.push(...gotoTargetsOf(item.lift));
+    }
+    return out;
+}
+/** Render one element's call without a leading indent, its lifted handlers written into its body. */
+function renderElementNested(plan, el, depth, indent) {
+    const tmp = new Chain('');
+    emitElement(tmp, el, depth, indent);
+    let call = tmp.all.join('\n');
+    const handlers = plan.handlers.get(el.id);
+    if (handlers?.length) {
+        const pad = indent.repeat(depth + 2);
+        const lines = handlers.map((h) => renderHandler(plan, h, depth + 2, indent));
+        call = `${call.replace(/\)$/, '')}, (t) => {\n${pad}${lines.join(`\n${pad}`)}\n${indent.repeat(depth + 1)}})`;
+    }
+    return call;
+}
+/** The lines of an arm's body after `b`, one per element, or the closing `.goto()`. */
+function renderArmLines(plan, arm, depth, indent) {
+    const lines = arm.items.map((item) => ('el' in item ? renderElementNested(plan, item.el, depth, indent) : renderBranch(plan, item.lift, depth, indent)));
+    if (arm.end === 'goto')
+        lines.push(`.goto(${str(arm.gotoTarget)})`);
+    return lines;
+}
+function renderArmBody(plan, arm, depth, indent) {
+    const lines = renderArmLines(plan, arm, depth, indent);
+    if (!lines.length)
+        return undefined;
+    const pad = indent.repeat(depth + 1);
+    return `(b) => b\n${pad}${lines.join(`\n${pad}`)}`;
+}
+function renderHandler(plan, h, depth, indent) {
+    const b = h.boundary;
+    const host = b.attachedToRef?.id;
+    const def = singleDefinition(b);
+    const method = def === 'error' ? 'onError' : def === 'timer' ? 'onTimer' : 'onMessage';
+    const defExpr = eventOptions(b).find(([k]) => k === def)?.[1] ?? 'true';
+    const payload = payloadOf(b);
+    const type = extensionTypeOf(payload);
+    const optsText = opts([
+        ['id', b.id !== `${host}_${method}` ? str(b.id) : undefined],
+        ['name', b.name !== undefined ? str(b.name) : undefined],
+        ['interrupting', def !== 'error' && b.cancelActivity === false ? 'false' : undefined],
+        ['payload', payload && type ? opts([['type', str(type)], ['outputRows', emitOutputRows(payload) ?? '[]']]) : undefined],
+    ]);
+    const body = renderArmBody(plan, h.arm, depth, indent);
+    const args = [defExpr, ...(optsText !== '' && optsText !== '{}' ? [optsText] : []), ...(body ? [body] : [])];
+    return `t.${method}(${args.join(', ')});`;
+}
+function renderBranch(plan, lift, depth, indent) {
+    plan.summary.branches++;
+    // The chain already indents the statement by one level; arms sit one level inside
+    // it, their bodies one further, and the closing bracket lines up with the statement.
+    const pad = indent.repeat(depth + 2);
+    const gw = lift.gateway;
+    const joinOpt = lift.join !== undefined
+        ? opts([
+            ['id', lift.join.id !== `${gw.id}_join` ? str(lift.join.id) : undefined],
+            ['name', lift.join.name !== undefined ? str(lift.join.name) : undefined],
+        ])
+        : undefined;
+    const optsText = opts([
+        ['name', gw.name !== undefined ? str(gw.name) : undefined],
+        ['inclusive', lift.inclusive ? 'true' : undefined],
+        ['join', joinOpt !== undefined && joinOpt !== '' && joinOpt !== '{}' ? joinOpt : undefined],
+    ]);
+    const armTexts = lift.arms.map(({ flow, arm, otherwise }) => {
+        const body = renderArmBody(plan, arm, depth + 2, indent);
+        if (lift.construct !== 'choose')
+            return body ?? '() => {}';
+        return opts([
+            otherwise ? ['otherwise', 'true'] : ['when', str(flow.conditionExpression?.body)],
+            ['label', flow.name !== undefined ? str(flow.name) : undefined],
+            ['body', body],
+        ]);
+    });
+    const arms = `[\n${pad}${armTexts.join(`,\n${pad}`)},\n${indent.repeat(depth + 1)}]`;
+    return `.${lift.construct}(${str(gw.id)}, ${arms}${optionalArg(optsText)})`;
+}
+/**
+ * An event sub-process as `.eventSubProcess()`, or nothing.
+ *
+ * Its body is a `sequence` scope, so the whole body has to be one path from the
+ * synthesized start — a chain, optionally ending in a construct whose arms all
+ * end — with nothing left over.
+ */
+function renderEventSubProcess(plan, sp, depth, indent) {
+    // A rejected body is written flat under its own flow ids, so the renames its
+    // attempt recorded are withdrawn.
+    const renamesBefore = plan.summary.renamedFlows.length;
+    const reject = (reason) => {
+        plan.summary.leftFlat.push({ id: sp.id, reason });
+        plan.summary.renamedFlows.length = renamesBefore;
+        return undefined;
+    };
+    if (retryOf(sp) || errorMappingOf(sp) || sp.loopCharacteristics)
+        return reject('carries retry, error mapping or a loop');
+    const g = scopeGraph(sp);
+    const starts = g.elements.filter((el) => localName(el.$type) === 'startEvent');
+    if (starts.length !== 1)
+        return reject(`has ${starts.length} start events`);
+    const start = starts[0];
+    const def = singleDefinition(start);
+    if (!def)
+        return reject('its start carries no single error, timer or message definition');
+    if (def === 'error' && start.isInterrupting === false)
+        return reject('a non-interrupting error start is not a thing');
+    const outs = g.outs.get(start.id) ?? [];
+    if (outs.length !== 1)
+        return reject(`its start has ${outs.length} outgoing flows`);
+    // Shares the outer plan's pin list: a flow id is unique across the document, so every
+    // pin can be declared once, in the one `.flowIds()` the top-level chain emits.
+    const inner = {
+        g,
+        taken: new Set([start.id]),
+        impliedFlows: new Set(),
+        handlers: new Map(),
+        summary: plan.summary,
+        relabel: plan.relabel,
+        pinned: plan.pinned,
+    };
+    planHandlers(inner);
+    const arm = walkArm(inner, outs[0], inner.taken, (el) => LIFT_GATEWAYS.has(localName(el.$type)), new Set());
+    if (!arm.ok)
+        return reject(`body: ${arm.reason}`);
+    const labelled = labelledImpliedFlow(arm.flows, false, arm.labelKept);
+    if (labelled)
+        return reject(`body: flow "${labelled.id}" carries the label "${labelled.name}", which an implied edge cannot`);
+    for (const f of arm.flows)
+        implyFlow(inner, f);
+    const lines = renderArmLines(inner, arm, depth + 1, indent);
+    if (arm.end === 'join') {
+        // The chain reached a gateway: it may close the body as a construct whose arms all end.
+        const gw = arm.join;
+        if ((g.ins.get(gw.id) ?? []).length !== 1)
+            return reject(`gateway "${gw.id}" in the body is reached from more than one place`);
+        const lift = planBranch(inner, gw, new Set(), true);
+        if (!lift)
+            return reject(`gateway "${gw.id}" in the body could not be lifted`);
+        for (const id of ownedByLift(lift))
+            inner.taken.add(id);
+        for (const f of lift.consumedFlows)
+            implyFlow(inner, f);
+        lines.push(renderBranch(inner, lift, depth + 1, indent));
+    }
+    else if (arm.end === 'goto') {
+        return reject(`body jumps to "${arm.gotoTarget}", which a sequence body cannot`);
+    }
+    const leftover = g.elements.filter((el) => !inner.taken.has(el.id));
+    if (leftover.length)
+        return reject(`elements outside the one path: ${leftover.map((el) => `"${el.id}"`).join(', ')}`);
+    if (g.flows.some((f) => !inner.impliedFlows.has(f.id)))
+        return reject('flows outside the one path');
+    // The start event's payload: the product's capture row is `errorVar`; anything else is spelled out.
+    const payload = payloadOf(start);
+    const type = extensionTypeOf(payload);
+    const rows = payload?.output ?? [];
+    const capture = def === 'error' && type === 'BPMN.Variables' && rows.length === 1 && rows[0].name === 'Error' && rows[0].source === '=Error' &&
+        rows[0].type === 'jsonSchema' && rows[0].var !== undefined && (payload?.input ?? []).length === 0
+        ? rows[0].var
+        : undefined;
+    const defExpr = eventOptions(start).find(([k]) => k === def)?.[1];
+    const spPayload = payloadOf(sp);
+    const spType = extensionTypeOf(spPayload);
+    const optsText = opts([
+        ['name', sp.name !== undefined ? str(sp.name) : undefined],
+        [def, defExpr],
+        ['interrupting', def !== 'error' && start.isInterrupting === false ? 'false' : undefined],
+        // `` `${id}_Error` `` is compile's default and `false` its opt-out, so neither is
+        // left implicit the wrong way round: an error start with no capture row recompiles
+        // without one, and a capture the designer named something else is spelled out.
+        [
+            'errorVar',
+            capture === `${sp.id}_Error` ? undefined : capture !== undefined ? str(capture) : def === 'error' ? 'false' : undefined,
+        ],
+        ['startId', start.id !== `${sp.id}_start` ? str(start.id) : undefined],
+        ['startName', start.name !== undefined ? str(start.name) : undefined],
+        ['startPayload', payload && type && capture === undefined ? opts([['type', str(type)], ['outputRows', emitOutputRows(payload) ?? '[]']]) : undefined],
+        ['tags', tagsOf(sp)],
+        ['payload', spPayload && spType ? opts([['type', str(spType)], ['outputRows', emitOutputRows(spPayload) ?? '[]']]) : undefined],
+    ]);
+    const vars = new Chain('');
+    emitVariablesInto(vars, sp, sp.id, capture !== undefined && captureDeclLooksDerived(sp, capture, start.id) ? new Set([capture]) : undefined);
+    const bodyLines = [...vars.all, ...lines];
+    const pad = indent.repeat(depth + 2);
+    const body = bodyLines.length ? `(h) => h\n${pad}${bodyLines.join(`\n${pad}`)}` : '(h) => h';
+    plan.summary.nets++;
+    return `.eventSubProcess(${str(sp.id)}, ${optsText}, ${body})`;
+}
+/** `emitScope`, with the liftable regions written as constructs. */
+function emitScopeNested(chain, container, depth, indent, summary, relabel, sequence) {
+    const g = scopeGraph(container);
+    const plan = { g, taken: new Set(), impliedFlows: new Set(), handlers: new Map(), summary, relabel, pinned: [] };
+    planHandlers(plan);
+    const emitted = new Set();
+    const written = new Set();
+    if (sequence)
+        chain.add(".flowMode('sequence')");
+    const renderFlow = (f) => `.sequenceFlow(${str(f.sourceRef?.id)}, ${str(f.targetRef?.id)}${optionalArg(opts([
+        ['id', f.id !== derivedFlowId(f) ? str(f.id) : undefined],
+        ['name', f.name !== undefined ? str(f.name) : undefined],
+        ['condition', f.conditionExpression?.body !== undefined ? str(f.conditionExpression.body) : undefined],
+    ]))})`;
+    /** Write an element's remaining flows now, before the next statement — so "explicit wins" applies. */
+    const writeNow = (flows) => {
+        for (const f of flows) {
+            if (plan.impliedFlows.has(f.id) || written.has(f.id))
+                continue;
+            written.add(f.id);
+            chain.add(renderFlow(f));
+        }
+    };
+    /**
+     * Write one element and say where the path continues: a lifted construct's exit, or
+     * the one element a single outgoing flow leads to. `undefined` ends the chain.
+     */
+    const emitOne = (el) => {
+        emitted.add(el.id);
+        if (LIFT_GATEWAYS.has(localName(el.$type))) {
+            const lift = planBranch(plan, el, emitted, false);
+            if (lift) {
+                for (const id of ownedByLift(lift))
+                    plan.taken.add(id);
+                for (const f of lift.consumedFlows)
+                    implyFlow(plan, f);
+                chain.add(renderBranch(plan, lift, depth, indent));
+                pending.push(...gotoTargetsOf(lift));
+                return lift.continuation;
+            }
+        }
+        if (isEventSubProcess(el)) {
+            const call = renderEventSubProcess(plan, el, depth, indent);
+            if (call) {
+                chain.add(call);
+                return undefined;
+            }
+        }
+        chain.add(renderElementNested(plan, el, depth, indent));
+        for (const h of plan.handlers.get(el.id) ?? [])
+            if (h.arm.end === 'goto' && h.arm.gotoTarget)
+                pending.push(h.arm.gotoTarget);
+        const outs = g.outs.get(el.id) ?? [];
+        if (outs.length === 1) {
+            const f = outs[0];
+            const next = g.byId.get(f.targetRef?.id);
+            const fresh = next !== undefined && !emitted.has(next.id) && !plan.taken.has(next.id);
+            // In sequence mode the edge to the statement written next is implied — when that
+            // statement IS the successor, the edge may be relabelled (or already carries the
+            // derived id), and it carries no label. Otherwise it is written here, before the
+            // next statement, so the builder does not imply a second one beside it.
+            if (sequence && fresh && (relabel || derivableFlow(f)) && !labelledImpliedFlow([f], false))
+                implyFlow(plan, f);
+            else if (sequence)
+                writeNow([f]);
+            return fresh ? next : undefined;
+        }
+        // A fan-out: its edges are explicit, written now, and each target is a place the
+        // process continues from.
+        if (sequence)
+            writeNow(outs);
+        for (const f of outs)
+            pending.push(f.targetRef?.id);
+        return undefined;
+    };
+    // Emit in CONTROL-FLOW order, not document order: from each source, follow the
+    // path while it is a path. An import lists elements in the order they were drawn,
+    // which put a gateway after the elements its arms should own and had the arms jump
+    // to them instead; walking from the start writes the gateway first, the arm owns
+    // its chain, and what remains explicit is a merge or a back edge — the same
+    // ordering an author would type. Manual starts first, then other starts, then
+    // anything nothing flows into, then whatever a cycle left unreached.
+    // The worklist: where the process continues after a construct's arms jumped out or
+    // an element fanned out. Drained before the next source, so the top level follows
+    // the graph's reach rather than the document's order.
+    const pending = [];
+    const emitFrom = (start) => {
+        let el = start;
+        while (el && !emitted.has(el.id) && !plan.taken.has(el.id))
+            el = emitOne(el);
+        while (pending.length) {
+            const next = g.byId.get(pending.shift() ?? '');
+            if (next && !emitted.has(next.id) && !plan.taken.has(next.id))
+                emitFrom(next);
+        }
+    };
+    const rank = (el) => {
+        const kind = localName(el.$type);
+        if (kind === 'startEvent')
+            return (el.eventDefinitions ?? []).length === 0 && payloadOf(el)?.$type !== 'uipath:Event' ? 0 : 1;
+        return (g.ins.get(el.id) ?? []).length === 0 ? 2 : 3;
+    };
+    const sources = [...g.elements].sort((a, b) => rank(a) - rank(b) || g.elements.indexOf(a) - g.elements.indexOf(b));
+    for (const el of sources)
+        emitFrom(el);
+    for (const f of g.flows) {
+        if (plan.impliedFlows.has(f.id) || written.has(f.id))
+            continue;
+        const auto = `Flow_${f.sourceRef?.id}_${f.targetRef?.id}`;
+        chain.add(`.sequenceFlow(${str(f.sourceRef?.id)}, ${str(f.targetRef?.id)}${optionalArg(opts([
+            ['id', f.id !== auto ? str(f.id) : undefined],
+            ['name', f.name !== undefined ? str(f.name) : undefined],
+            ['condition', f.conditionExpression?.body !== undefined ? str(f.conditionExpression.body) : undefined],
+        ]))})`);
+    }
+    // Last, so it is first: the implied edges whose id is not the one the construct
+    // derives. Emitted at the front of the chain because it is a declaration about the
+    // whole scope, and only knowable once the walk has decided what to imply.
+    if (plan.pinned.length) {
+        const rows = plan.pinned.map((e) => `{ source: ${str(e.source)}, target: ${str(e.target)}, id: ${str(e.id)} }`);
+        chain.addFirst(`.flowIds([${rows.join(', ')}])`);
+    }
+}
 /**
  * Whether a start event's event definition carries configuration a registry spec
  * cannot supply — today, a timer's duration/date/cycle.
@@ -715,6 +1477,9 @@ function emitEvent(chain, el, kind, payload, type) {
     chain.add(`.${kind}(${str(el.id)}${optionalArg(opts([
         ['name', el.name !== undefined ? str(el.name) : undefined],
         ...eventOptions(el),
+        // Only a start event can be non-interrupting, and only the exception is
+        // spelled — the builder's default is BPMN's.
+        ['interrupting', kind === 'startEvent' && el.isInterrupting === false ? 'false' : undefined],
         ['payload', eventPayload],
     ]))})`);
 }
@@ -812,8 +1577,10 @@ function emitElement(chain, el, depth, indent) {
             return;
         case 'subProcess': {
             const inner = new Chain(indent.repeat(depth + 2));
+            if (pinExplicitInBodies)
+                inner.add(".flowMode('explicit')");
             emitScope(inner, el, depth + 1, indent);
-            emitVariablesInto(inner, el);
+            emitVariablesInto(inner, el, el.id);
             const body = inner.all.length
                 ? `(sp) => {\n${inner.all.map((l, i) => (i === 0 ? `${l.replace(/^(\s*)\./, '$1sp.')}` : l)).join('\n')};\n${indent.repeat(depth + 1)}}`
                 : '(sp) => {}';
@@ -859,15 +1626,47 @@ function varType(wire) {
             return wire ?? 'string';
     }
 }
-/** Emit `.var()` / `.input()` / `.output()` for one scope's declarations. */
-function emitVariablesInto(chain, container, skip = new Set(), 
+/** How a declaration's `elementId` is spelled in source — see `emitVariablesInto`. */
+function emitElementId(elementId, ownerId, rehome) {
+    if (elementId === undefined)
+        return 'null';
+    const effective = rehome && elementId === rehome.from ? rehome.to : elementId;
+    return effective === ownerId ? undefined : str(effective);
+}
+/**
+ * Whether an error net's capture variable is declared exactly as `errorVar` would
+ * declare it — `jsonSchema`, named `Error`, scoped to the start event, no default — so
+ * the nested form can leave it to the default instead of echoing it.
+ */
+function captureDeclLooksDerived(sp, varId, startId) {
+    const vars = (sp.extensionElements?.values ?? []).find((x) => x.$type === 'uipath:Variables');
+    const v = (vars?.inputOutput ?? []).find((x) => x.id === varId);
+    return v !== undefined && v.name === 'Error' && v.type === 'jsonSchema' && v.elementId === startId && v.default === undefined;
+}
+/**
+ * Emit `.var()` / `.input()` / `.output()` for one scope's declarations.
+ *
+ * `elementId` is written the way `compile` reads it: a declaration belonging to the
+ * scope itself (`ownerId` — the process or sub-process id, which is the compile-time
+ * default) is emitted with no `elementId`; one belonging to another element names it;
+ * and one with NO `elementId` on the wire is emitted as `elementId: null`, because the
+ * default would otherwise add one on recompile and the round trip would not be byte
+ * for byte. Older exports have that shape on every variable.
+ */
+function emitVariablesInto(chain, container, ownerId, skip = new Set(), 
 /**
  * Rewrite one `elementId` as another. Needed when the declarations are read off a
  * COLLABORATION, whose id will not exist after a recompile — see `variablesHost`.
  */
 rehome, 
 /** How each schema body should be written — see {@link planSchemas}. */
-plan) {
+plan, 
+/**
+ * The scope the serializer would give an unscoped declaration of this kind — see
+ * `publicDeclarationScope` in serialize.ts. A declaration already there is emitted
+ * without `elementId`; the owner when absent.
+ */
+defaultScope = () => ownerId) {
     const vars = (container.extensionElements?.values ?? []).find((x) => x.$type === 'uipath:Variables');
     if (!vars)
         return;
@@ -887,12 +1686,7 @@ plan) {
                 ['default', def],
                 ['schema', v.body !== undefined ? (plan?.ref.get(String(v.body)) ?? jsonLiteral(v.body)) : undefined],
                 ['required', v.required !== undefined ? 'true' : undefined],
-                [
-                    'elementId',
-                    v.elementId === undefined
-                        ? undefined
-                        : str(rehome && v.elementId === rehome.from ? rehome.to : v.elementId),
-                ],
+                ['elementId', emitElementId(v.elementId, defaultScope(prop, v), rehome)],
             ]))})`);
         }
     }
@@ -1034,8 +1828,22 @@ export async function decompile(xml, options = {}) {
     ]);
     for (const [id, body] of schemaPlan.declare)
         chain.add(`.schema(${str(id)}, ${body})`);
-    emitVariablesInto(chain, host.container, derived, host.rehome, schemaPlan);
-    emitScope(chain, process, 0, indent);
+    emitVariablesInto(chain, host.container, host.rehome?.to ?? host.container.id, derived, host.rehome, schemaPlan, publicDeclarationScopeOf(process, host.rehome?.to ?? host.container.id));
+    if (options.style === 'nested') {
+        const sequence = options.sequenceMode ?? true;
+        const summary = { handlers: 0, branches: 0, nets: 0, leftFlat: [], renamedFlows: [], sequence };
+        pinExplicitInBodies = sequence;
+        try {
+            emitScopeNested(chain, process, 0, indent, summary, options.relabelFlows ?? true, sequence);
+        }
+        finally {
+            pinExplicitInBodies = false;
+        }
+        options.onLift?.(summary);
+    }
+    else {
+        emitScope(chain, process, 0, indent);
+    }
     const importFrom = options.importSpecifier ?? './bpmn-sdk.js';
     const imported = ['bpmn', ...[...schemaPlan.imports].sort()].join(', ');
     const head = `import { ${imported} } from ${str(importFrom)};\n\nexport default bpmn(${str(process.id)})`;
@@ -1069,17 +1877,21 @@ export async function decompile(xml, options = {}) {
  * `decision` while its declared variable is `o`.
  */
 function derivedVariableIds(process) {
-    const candidates = new Set();
+    // var id -> [owner element id, wire type the derived declaration carries]
+    const candidates = new Map();
     const walk = (container) => {
         for (const el of container.flowElements ?? []) {
             const payload = payloadOf(el);
             const type = extensionTypeOf(payload);
-            // A mapping node's rows write AUTHORED variables (a script task's outputs, a
-            // variable task's assignments), so they are not derived.
-            if (payload && type && type !== 'BPMN.Variables' && type !== 'BPMN.ScriptTask') {
+            // A variable task's rows write AUTHORED variables (its assignments), so they are
+            // not derived. A script task's `outputs` rows ARE — serialize declares each as a
+            // `string` owned by the task, because the validator does not read the row as a
+            // declaration — so they are candidates with the type that shape carries.
+            if (payload && type && type !== 'BPMN.Variables') {
+                const wire = type === 'BPMN.ScriptTask' ? 'string' : 'json';
                 for (const row of payload.output ?? [])
                     if (row.var)
-                        candidates.add(row.var);
+                        candidates.set(row.var, [el.id, wire]);
             }
             if (el.$type === 'bpmn:SubProcess')
                 walk(el);
@@ -1087,20 +1899,22 @@ function derivedVariableIds(process) {
     };
     walk(process);
     // Keep only the candidates whose declaration matches what `implicitNodeVars` would
-    // write: `{ id, name: id, type: 'object', direction: 'inputOutput' }`, i.e. an
-    // `inputOutput` row, `name` equal to `id`, wire type `json`, and no default or
-    // element scope. A declaration that differs in ANY of those cannot have been
-    // derived, so it is the author's and has to be echoed.
+    // write: an `inputOutput` row, `name` equal to `id`, the wire type above, no default,
+    // and `elementId` naming the node whose row fills it. A declaration that differs in
+    // ANY of those cannot have been derived, so it is the author's and has to be echoed
+    // — including the older shape with no `elementId`, which recompiles identically only
+    // because `emitVariablesInto` then writes it as `elementId: null`.
     const out = new Set();
     const vars = (process.extensionElements?.values ?? []).find((x) => x.$type === 'uipath:Variables');
     for (const v of vars?.inputOutput ?? []) {
-        if (!candidates.has(v.id))
+        const c = candidates.get(v.id);
+        if (!c)
             continue;
         if (v.name !== undefined && v.name !== v.id)
             continue;
-        if (v.type !== 'json')
+        if (v.type !== c[1])
             continue;
-        if (v.default !== undefined || v.elementId !== undefined)
+        if (v.default !== undefined || v.elementId !== c[0])
             continue;
         out.add(v.id);
     }