@uipath/maestro-builder-sdk 5.2.0

package/dist/bpmn/decompile.js

@@ -0,0 +1,1108 @@
+/**
+ * bpmn/decompile — the reverse of `serialize.ts`: turn a real UiPath `.bpmn` back
+ * into `.bpmn.ts` builder source whose default export re-serializes to the **same**
+ * XML.
+ *
+ * Phase 4 of `docs/BPMN_COVERAGE_DESIGN.md`. A BPMN process is a flat graph of
+ * elements plus edges, and every builder method is 1-1 with an element — so this
+ * is a straight structural walk of the moddle tree, with no control-flow inference
+ * and no AST parsing. Expressions are opaque strings on both sides, so they emit
+ * as string literals; no expression parser is needed.
+ *
+ * **The round-trip target is byte-identical XML**, not merely structural
+ * equivalence — `serialize` is deterministic, so anything less means something was
+ * lost. `bpmn-decompile.test.ts` asserts exactly that over the whole corpus, which
+ * is what keeps the claims below honest.
+ *
+ * What does NOT survive, and why:
+ *
+ * - **`bpmndi` diagram layout.** The SDK emits none and `tidy` regenerates it, so
+ *   there is nothing to preserve. A decompiled file recompiles to semantic-only
+ *   XML; re-run `tidy` for a canvas.
+ * - **Comments, method order, and formatting.** Regenerated, not preserved.
+ *
+ * Everything else round-trips: events and their definitions, all four gateways,
+ * script/variable tasks, sub-processes (recursively), boundary events, flows and
+ * conditions, variables, bindings, retry, loops, skip conditions, and every
+ * registry-typed node — connector tasks included.
+ *
+ * ## Connector tasks, and why they used to be refused
+ *
+ * `Intsvc.ActivityExecution` was refused on the grounds that it carries three things
+ * no builder surface modelled. One of the three was never really a blocker, and the
+ * other two were emitter gaps rather than facts about connectors:
+ *
+ * 1. **The library's ACTION id** — the XML has `objectName="send_message_to_user_v2"`
+ *    and `operation="Create"`, never the library's `send-message-to-user`. True, and
+ *    it only matters if the output has to be a `.connector(key, action, …)` call.
+ *    It does not: the generic `.activity()` with `contextVerbatim` reproduces the
+ *    context rows exactly as written, and no library is consulted. Refusing over this
+ *    treated "cannot recover the prettiest source form" as "cannot decompile".
+ * 2. **PER-INPUT targets** — `pathParameters` / `queryParameters` / `body` each carry
+ *    their own `target`. This was a real bug, and not in this file: `separateInputs`
+ *    applied the spec's single `inputTarget` to every sibling row, collapsing all
+ *    three onto `target="body"`. `bpmn/connector.ts` never hit it because it writes
+ *    its own rows with the targets hardcoded.
+ * 3. **Output rows carrying a JSON RESPONSE SCHEMA in their body** — a real surface
+ *    gap. `outputs` is a variable→expression map with nowhere to put a type or a
+ *    body, so the schema had nowhere to live. `TypedOutputRow` is that surface.
+ *
+ * With 2 and 3 closed, a connector round-trips byte-identically and needs NO library
+ * on the way back, because everything it needs is already in the artifact. Measured
+ * on real Slack and Customer.io operations, the second of which exercises the
+ * path/query split.
+ */
+import BpmnModdle from 'bpmn-moddle';
+import { createRequire } from 'node:module';
+import { registryType } from './typed-node.js';
+import { errorSchema, errorSchemaWithResponse } from './bpmn-sdk.js';
+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');
+// ─── Source emitters ──────────────────────────────────────────────────────────
+/**
+ * A JS/TS string literal.
+ *
+ * `JSON.stringify` escapes quotes, backslashes and control characters, so a value
+ * out of an untrusted `.bpmn` — a label, an expression, a URL — can never break
+ * out of the literal and become code in the emitted source. U+2028/U+2029 are
+ * escaped too: legal in JSON, historically illegal in JS string literals.
+ */
+function str(s) {
+    return JSON.stringify(String(s ?? '')).replace(/[\u2028\u2029]/g, (c) => `\\u${c.charCodeAt(0).toString(16)}`);
+}
+/** An arbitrary JSON value as an inert TS literal. Never executable. */
+function literal(v) {
+    return JSON.stringify(v ?? null);
+}
+/**
+ * Schema bodies that need no declaration, because the platform defines them.
+ *
+ * `V2EndEventBody.BuildErrorCoreResult` in PO.BpmnEngine builds the `Error` entry
+ * with "the six expected fields", and separately mentions "the generic failure
+ * mapping shape, which includes a `response` key". Those are the two forms below —
+ * 243 and 42 byte-identical copies across five unrelated customer exports.
+ *
+ * Matched on exact bytes, so a contract that changes simply stops matching and the
+ * body is declared like any other. Nothing is coerced into the constant.
+ */
+const WELL_KNOWN_SCHEMAS = [
+    ['errorSchema', JSON.stringify(errorSchema)],
+    ['errorSchemaWithResponse', JSON.stringify(errorSchemaWithResponse)],
+];
+/** The SDK export that reproduces this body exactly, if one does. */
+function wellKnownSchema(body) {
+    const text = String(body);
+    return WELL_KNOWN_SCHEMAS.find(([, json]) => json === text)?.[0];
+}
+/** An identifier for a shared schema, from the variable name that carries it. */
+function schemaIdFrom(name, taken) {
+    const base = `${identifierize(name ?? 'shared')}Schema`;
+    let id = base;
+    for (let n = 2; taken.has(id); n++)
+        id = `${base}${n}`;
+    taken.add(id);
+    return id;
+}
+/** Decide the plan by counting how often each body appears across the document. */
+function planSchemas(rows) {
+    const plan = { ref: new Map(), declare: [], imports: new Set() };
+    const counts = new Map();
+    const firstName = new Map();
+    for (const row of rows) {
+        if (row.body === undefined)
+            continue;
+        const text = String(row.body);
+        counts.set(text, (counts.get(text) ?? 0) + 1);
+        if (!firstName.has(text))
+            firstName.set(text, row.name);
+    }
+    const taken = new Set();
+    for (const [text, count] of counts) {
+        const known = wellKnownSchema(text);
+        if (known) {
+            plan.ref.set(text, known);
+            plan.imports.add(known);
+        }
+        else if (count > 1) {
+            const id = schemaIdFrom(firstName.get(text), taken);
+            plan.ref.set(text, str(id));
+            plan.declare.push([id, jsonLiteral(text)]);
+        }
+    }
+    return plan;
+}
+/**
+ * A schema body as a JSON LITERAL rather than an escaped string.
+ *
+ * `schema: { type: "object", … }` reads; `schema: "{\"type\":\"object\",…}"` does
+ * not, and a real artifact carries thousands of characters of it. The emitters have
+ * always accepted either — `typeof x === 'string' ? x : JSON.stringify(x)` — so this
+ * only changes which one an IMPORT produces.
+ *
+ * Only when re-stringifying reproduces the source byte for byte. A body with
+ * whitespace, an unusual key order, or anything JSON.parse would not give back
+ * unchanged keeps its string form, because the round trip is held to byte identity
+ * and a prettier source is not worth breaking that.
+ */
+function jsonLiteral(body) {
+    const value = jsonValue(body);
+    return typeof value === 'string' ? str(value) : literal(value);
+}
+/**
+ * The same decision, as a VALUE rather than as source text — for a body that lands
+ * inside a record the emitter renders for itself, such as a node's `context`.
+ *
+ * The round-trip guard is the whole rule: a body is parsed only when
+ * re-stringifying it reproduces the source byte for byte, so anything with
+ * whitespace, an unusual key order, or a number JSON would not spell back the same
+ * way stays the string it was and the recompile still matches.
+ */
+function jsonValue(body) {
+    const text = String(body);
+    try {
+        const parsed = JSON.parse(text);
+        // A body of `null` stays the STRING it was. `null` and `undefined` are how a
+        // context record says "field not supplied" — `contextRows` skips both — so
+        // handing back a real null would delete the row on recompile rather than write
+        // it. `Intsvc.UnifiedHttpRequest` makes this concrete: its `body` field's
+        // registry default is the text `null`, and every HTTP node carries it.
+        if (parsed === null)
+            return text;
+        return JSON.stringify(parsed) === text ? parsed : text;
+    }
+    catch {
+        return text;
+    }
+}
+/** An object key: a bare identifier when legal, otherwise a quoted string. */
+function key(k) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(k) ? k : str(k);
+}
+/** Render `{ a: 1, b: 2 }` from the entries that are present; `''` when none are. */
+function opts(entries) {
+    const parts = entries.filter(([, v]) => v !== undefined).map(([k, v]) => `${key(k)}: ${v}`);
+    return parts.length ? `{ ${parts.join(', ')} }` : '';
+}
+/** A record literal, or `undefined` when the record is empty. */
+function record(r) {
+    if (!r || Object.keys(r).length === 0)
+        return undefined;
+    return `{ ${Object.entries(r)
+        .map(([k, v]) => `${key(k)}: ${typeof v === 'string' ? str(v) : literal(v)}`)
+        .join(', ')} }`;
+}
+/** A collector for the fluent chain's lines. */
+class Chain {
+    indent;
+    lines = [];
+    constructor(indent) {
+        this.indent = indent;
+    }
+    add(call) {
+        this.lines.push(`${this.indent}${call}`);
+    }
+    get all() {
+        return this.lines;
+    }
+}
+// ─── Reading the moddle tree ──────────────────────────────────────────────────
+/** `bpmn:SendTask` → `sendTask`; the instance-tag spelling the builder speaks. */
+function localName(type) {
+    const local = type.split(':')[1] ?? type;
+    return local.charAt(0).toLowerCase() + local.slice(1);
+}
+/** The `uipath:*` payload element on an element, if it has one. */
+function payloadOf(el) {
+    for (const ext of el.extensionElements?.values ?? []) {
+        if (ext.$type === 'uipath:Activity' || ext.$type === 'uipath:Event' || ext.$type === 'uipath:Mapping')
+            return ext;
+    }
+    return undefined;
+}
+/** `uipath:tags` on an element as a plain record, or undefined when it has none. */
+function tagsOf(el) {
+    const tags = (el.extensionElements?.values ?? []).find((x) => x.$type === 'uipath:Tags');
+    const rows = tags?.tags ?? [];
+    // A row with no `key` is the PROCESS-level shape (a plain value), which
+    // `.metadata({ tags })` owns; only the keyed per-node form belongs here.
+    const keyed = rows.filter((t) => t.key !== undefined);
+    if (!keyed.length)
+        return undefined;
+    return record(Object.fromEntries(keyed.map((t) => [t.key, String(t.value ?? '')])));
+}
+/** The `uipath:Retry` element on an element, if it has one. */
+function retryOf(el) {
+    return (el.extensionElements?.values ?? []).find((x) => x.$type === 'uipath:Retry');
+}
+/**
+ * Whether the context rows carry detail the `context` record cannot hold: a type
+ * the registry does not declare for that field, or an absent `value` attribute
+ * (which is not the same as `value=""`).
+ */
+function contextRowsNeedSpellingOut(payload, type) {
+    const rows = payload?.context?.input ?? [];
+    if (!rows.length || !type)
+        return false;
+    let declared;
+    try {
+        declared = new Map(registryType(type).context.map((f) => [f.name, f.type]));
+    }
+    catch {
+        return true;
+    }
+    return rows.some((r) => (r.value === undefined && r.body === undefined) ||
+        r.required !== undefined ||
+        r.target !== undefined ||
+        (r.type ?? 'string') !== (declared.get(r.name) ?? 'string'));
+}
+/** The context rows as `TypedContextRow` option source, in document order. */
+function emitContextRows(payload) {
+    const rows = payload?.context?.input ?? [];
+    if (!rows.length)
+        return undefined;
+    return `[${rows
+        .map((r) => opts([
+        ['name', str(r.name)],
+        ['type', r.type !== undefined ? str(r.type) : undefined],
+        ['required', r.required !== undefined ? 'true' : 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(', ')}]`;
+}
+/** `uipath:context` inputs as a plain record, json fields read from the body. */
+function contextOf(payload) {
+    const out = {};
+    for (const input of payload?.context?.input ?? []) {
+        out[input.name] = input.type === 'json' ? jsonValue(input.body ?? '') : (input.value ?? '');
+    }
+    return out;
+}
+/** The extension type value, e.g. `Intsvc.UnifiedHttpRequest`. */
+function extensionTypeOf(payload) {
+    return payload?.type?.value;
+}
+/** A retry policy back into `RetrySpec` option source. */
+function emitRetry(retry) {
+    if (!retry)
+        return undefined;
+    const count = Number(retry.maxRetryCount ?? 0);
+    if (!Number.isFinite(count) || count < 1)
+        return undefined;
+    return opts([
+        ['maxRetries', String(count)],
+        ['backoff', retry.retryBackoff ? str(retry.retryBackoff) : undefined],
+        ['backoffType', retry.retryBackoffType === 'Exponential' ? str('exponential') : undefined],
+        ['exponentialBase', retry.exponentialBase !== undefined ? String(Number(retry.exponentialBase)) : undefined],
+        ['allErrors', retry.retryAllErrors === 'true' || retry.retryAllErrors === true ? 'true' : undefined],
+        ['maxDuration', retry.maxDuration ? str(retry.maxDuration) : undefined],
+    ]);
+}
+/** The `uipath:ErrorMapping` element on an element, if it has one. */
+function errorMappingOf(el) {
+    return (el.extensionElements?.values ?? []).find((x) => x.$type === 'uipath:ErrorMapping');
+}
+/**
+ * `uipath:errorMapping` back into `ErrorMappingRow[]` option source.
+ *
+ * Every attribute the descriptor declares is carried, including `priority` and
+ * `detail`, which neither this SDK nor the local engine interprets — an imported
+ * artifact may hold them and dropping them would break the byte-identity round trip.
+ *
+ * `retryable` is tri-state on the wire and stays that way here: present-and-`"true"`,
+ * present-and-`"false"`, or ABSENT. Reading absent as `false` would emit an attribute
+ * the original did not have.
+ */
+function emitErrorMapping(em) {
+    const rows = em?.error ?? [];
+    if (!rows.length)
+        return undefined;
+    const parts = rows.map((r) => opts([
+        ['code', str(r.errorRef ?? '')],
+        ['retryable', r.retryable === undefined ? undefined : r.retryable === 'true' || r.retryable === true ? 'true' : 'false'],
+        ['id', r.id !== undefined ? str(r.id) : undefined],
+        // A numeric-looking priority round-trips as a number; anything else stays a
+        // string, since the wire is a string either way and the author's form is unknown.
+        ['priority', r.priority === undefined ? undefined : /^-?\d+$/.test(String(r.priority)) ? String(Number(r.priority)) : str(r.priority)],
+        ['condition', r.condition !== undefined ? str(r.condition) : undefined],
+        ['detail', r.detail !== undefined ? str(r.detail) : undefined],
+    ]));
+    return `[${parts.join(', ')}]`;
+}
+/** Multi-instance loop characteristics back into `LoopSpec` option source. */
+function emitLoop(el) {
+    const loop = el.loopCharacteristics;
+    if (!loop)
+        return undefined;
+    const uip = (loop.extensionElements?.values ?? []).find((x) => x.$type === 'uipath:LoopCharacteristics');
+    if (!uip)
+        return undefined;
+    return opts([
+        ['collection', str(uip.inputCollection ?? '')],
+        ['itemVar', str(uip.inputElement ?? 'item')],
+        ['sequential', loop.isSequential ? 'true' : undefined],
+        ['completion', loop.completionCondition?.body ? str(loop.completionCondition.body) : undefined],
+    ]);
+}
+/** An event definition back into the `{ message | timer | error | terminate }` option. */
+function eventOptions(el) {
+    const def = (el.eventDefinitions ?? [])[0];
+    if (!def)
+        return [];
+    switch (def.$type) {
+        case 'bpmn:MessageEventDefinition':
+            return [['message', str(def.messageRef?.name ?? '')]];
+        case 'bpmn:TerminateEventDefinition':
+            return [['terminate', 'true']];
+        case 'bpmn:ErrorEventDefinition': {
+            const ref = def.errorRef;
+            // No `errorRef` is CATCH-ANY, not "no definition". Returning nothing here
+            // dropped the definition entirely, and the builder then refused the result —
+            // which is what made all 71 error boundaries in five real exports unimportable.
+            if (!ref)
+                return [['error', 'true']];
+            // The builder defaults an error's code to its name, so re-emitting the pair
+            // only matters when they differ — otherwise the shorter form round-trips.
+            return [
+                ['error', ref.errorCode && ref.errorCode !== ref.name ? opts([['name', str(ref.name)], ['code', str(ref.errorCode)]]) : str(ref.name)],
+            ];
+        }
+        case 'bpmn:TimerEventDefinition': {
+            const d = def.timeDuration?.body;
+            const date = def.timeDate?.body;
+            const cycle = def.timeCycle?.body;
+            // A bare duration is the shorthand the builder accepts directly.
+            if (d !== undefined && date === undefined && cycle === undefined)
+                return [['timer', str(d)]];
+            return [['timer', opts([['duration', d !== undefined ? str(d) : undefined], ['date', date !== undefined ? str(date) : undefined], ['cycle', cycle !== undefined ? str(cycle) : undefined]])]];
+        }
+        default:
+            return [];
+    }
+}
+/** `uipath:output` rows split into the type's own row and the author-mapped extras. */
+function outputsOf(payload, id, type) {
+    const rows = payload?.output ?? [];
+    const extras = {};
+    let outputVar;
+    const specName = type ? registryType(type).output?.name : undefined;
+    for (const row of rows) {
+        if (specName !== undefined && row.name === specName) {
+            // Only worth emitting when it differs from the default the builder derives.
+            outputVar = row.var;
+            continue;
+        }
+        if (row.source !== undefined)
+            extras[row.var ?? row.name] = row.source;
+    }
+    return { outputVar, extras };
+}
+/**
+ * Whether these rows can be reproduced by the compact `outputVar` + `outputs` pair,
+ * or need spelling out.
+ *
+ * A row with a BODY cannot: `outputs` is a variable→expression map, so the body — a
+ * connector's response schema, the biggest thing in the element — has nowhere to go.
+ * A row whose NAME differs from the variable it writes cannot either, for the same
+ * reason `add_output` needed the merge: `outputs` is keyed by the variable, so it
+ * always writes `name` and `var` the same.
+ *
+ * Deciding per artifact rather than per type is what keeps this honest. The compact
+ * form stays in use wherever it is exact, so the 30 other extension types decompile
+ * to exactly the source they did before, and only a row that genuinely needs the
+ * long form gets it.
+ */
+function outputRowsNeedSpellingOut(payload) {
+    const rows = payload?.output ?? [];
+    return rows.some((row) => row.body !== undefined ||
+        row.custom !== undefined ||
+        row.description !== undefined ||
+        row.target !== undefined ||
+        (row.var !== undefined && row.var !== row.name));
+}
+/** The output rows as `TypedOutputRow` option source, in document order. */
+function emitOutputRows(payload) {
+    const rows = payload?.output ?? [];
+    if (!rows.length)
+        return undefined;
+    const rendered = rows.map((row) => opts([
+        ['name', str(row.name)],
+        ['type', row.type !== undefined ? str(row.type) : undefined],
+        ['var', row.var !== undefined ? str(row.var) : undefined],
+        ['source', row.source !== undefined ? str(row.source) : undefined],
+        ['custom', row.custom ? 'true' : undefined],
+        ['description', row.description !== undefined ? str(row.description) : undefined],
+        ['target', row.target !== undefined ? str(row.target) : undefined],
+        // The body goes back as the STRING it was, not as a re-serialized object: a
+        // schema is carried, never interpreted, so nothing here can reorder its keys
+        // or drop a field this SDK does not know about.
+        ['schema', row.body !== undefined ? jsonLiteral(row.body) : undefined],
+    ]));
+    return `[${rendered.join(', ')}]`;
+}
+// ─── Element emitters ─────────────────────────────────────────────────────────
+/**
+ * A registry-typed node.
+ *
+ * Emitted through the GENERIC `.activity()` rather than a typed method, and
+ * deliberately: `context` is reproduced verbatim, so the round-trip is exact for
+ * all 30 extension types without a per-type reverse mapping to keep in step with
+ * the registry. Typed methods are for authoring; fidelity is what an importer
+ * owes you.
+ */
+function emitTypedNode(chain, el, payload, type) {
+    const spec = registryType(type);
+    const id = el.id;
+    // Verbatim: reproduce every context field, in document order, and let the
+    // emitter inject nothing. Stripping the ones that match a registry default
+    // would be smaller source but a lossy round-trip — the artifact's own emitter
+    // may not have written the same set the registry would default.
+    const ctx = contextOf(payload);
+    const inputRows = payload.input ?? [];
+    let inputs;
+    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]));
+    }
+    else if (inputRows.length) {
+        inputs = safeJson(inputRows[0].body);
+    }
+    const verbatimContext = contextRowsNeedSpellingOut(payload, type) ? emitContextRows(payload) : undefined;
+    const { outputVar, extras } = outputsOf(payload, id, type);
+    const defaultVar = spec.output ? `${id}_${identifierize(spec.output.name)}` : undefined;
+    const verbatimRows = outputRowsNeedSpellingOut(payload) ? emitOutputRows(payload) : undefined;
+    chain.add(`.activity(${str(id)}, ${str(type)}${optionalArg(opts([
+        ['name', el.name !== undefined ? str(el.name) : undefined],
+        // Only when it differs from the registry's own template, so an
+        // SDK-authored node keeps the shorter source it had.
+        ['typeVersion', payload.type?.version && payload.type.version !== 'v1' ? str(payload.type.version) : undefined],
+        ['context', verbatimContext ? undefined : record(ctx)],
+        ['contextRows', verbatimContext],
+        ['inputSchema', payload.context?.inputSchema?.body !== undefined ? jsonLiteral(payload.context.inputSchema.body) : undefined],
+        ['inputs', record(inputs)],
+        ['outputRows', verbatimRows],
+        ['outputVar', verbatimRows === undefined && outputVar !== undefined && outputVar !== defaultVar ? str(outputVar) : undefined],
+        ['outputs', verbatimRows === undefined ? record(extras) : undefined],
+        ['skipCondition', payload.skipCondition !== undefined ? str(payload.skipCondition) : undefined],
+        ['contextVerbatim', Object.keys(ctx).length ? 'true' : undefined],
+        ['tags', tagsOf(el)],
+        ['retry', emitRetry(retryOf(el))],
+        ['errorMapping', emitErrorMapping(errorMappingOf(el))],
+        ['loop', emitLoop(el)],
+    ]))})`);
+}
+/** 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);
+    if (words.length === 0)
+        return 'response';
+    return words.map((w, i) => (i === 0 ? w.charAt(0).toLowerCase() + w.slice(1) : w.charAt(0).toUpperCase() + w.slice(1))).join('');
+}
+/** `, { … }` when there are options, `''` when there are none. */
+function optionalArg(rendered) {
+    return rendered ? `, ${rendered}` : '';
+}
+/** Parse a CDATA body as JSON, falling back to the raw string. */
+function safeJson(body) {
+    if (typeof body !== 'string')
+        return {};
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        return body;
+    }
+}
+/** A `uipath:mapping` script task. */
+function emitScriptTask(chain, el, payload, type) {
+    const args = (payload?.input ?? []).find((r) => r.name === 'args');
+    const inputs = args ? safeJson(args.body) : undefined;
+    const outputs = {};
+    for (const row of payload?.output ?? [])
+        outputs[row.var ?? row.name] = row.source;
+    // The rows go back verbatim whenever `outputs` could not reproduce them —
+    // the product names a row after what the script RETURNS (`scriptResponse`,
+    // `Error`) while binding a differently-named variable, and the derived form
+    // names it after the variable.
+    const verbatim = outputRowsNeedSpellingOut(payload) ? emitOutputRows(payload) : undefined;
+    chain.add(`.scriptTask(${str(el.id)}, ${opts([
+        ['name', el.name !== undefined ? str(el.name) : undefined],
+        ['script', str(el.script ?? '')],
+        ['scriptFormat', el.scriptFormat && el.scriptFormat !== 'JavaScript' ? str(el.scriptFormat) : 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
+        // defect `uip maestro bpmn validate` does not catch. Same call the round trip
+        // already makes for a bare `<uipath:input name="args">`.
+        [
+            'type',
+            type !== undefined && type !== 'BPMN.Variables' && type !== 'BPMN.ScriptTask' ? str(type) : undefined,
+        ],
+        ['inputSchema', payload?.context?.inputSchema?.body !== undefined ? jsonLiteral(payload.context.inputSchema.body) : undefined],
+        ['inputs', record(inputs)],
+        ['outputs', verbatim ? undefined : record(outputs)],
+        ['outputRows', verbatim],
+        ['tags', tagsOf(el)],
+        ['retry', emitRetry(retryOf(el))],
+        ['errorMapping', emitErrorMapping(errorMappingOf(el))],
+        ['loop', emitLoop(el)],
+    ])})`);
+}
+/** A `uipath:mapping` variable task. */
+function emitVariableTask(chain, el, payload) {
+    const set = {};
+    for (const row of payload.output ?? []) {
+        const source = String(row.source ?? '');
+        // The serializer wraps a literal as `=js:"…"`; unwrap it so the source reads
+        // the way it was authored rather than the way it was encoded.
+        const asLiteral = /^=js:(".*")$/.exec(source);
+        set[row.var ?? row.name] = asLiteral ? JSON.parse(asLiteral[1]) : source;
+    }
+    chain.add(`.task(${str(el.id)}, ${opts([
+        ['name', el.name !== undefined ? str(el.name) : undefined],
+        ['set', record(set)],
+        ['tags', tagsOf(el)],
+        ['retry', emitRetry(retryOf(el))],
+        ['errorMapping', emitErrorMapping(errorMappingOf(el))],
+        ['loop', emitLoop(el)],
+    ])})`);
+}
+/** Every element of one scope, in document order, then its flows. */
+function emitScope(chain, container, depth, indent) {
+    const flows = [];
+    for (const el of container.flowElements ?? []) {
+        if (el.$type === 'bpmn:SequenceFlow') {
+            flows.push(el);
+            continue;
+        }
+        emitElement(chain, el, depth, indent);
+    }
+    for (const f of flows) {
+        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],
+        ]))})`);
+    }
+}
+/**
+ * Whether a start event's event definition carries configuration a registry spec
+ * cannot supply — today, a timer's duration/date/cycle.
+ *
+ * A definition with no children is reproduced exactly by the spec-driven emitter
+ * (it emits the same bare element), so the generic `.activity()` path is lossless
+ * for it. One with a body is not.
+ */
+function startEventDefinitionCarriesConfig(el) {
+    for (const def of el.eventDefinitions ?? []) {
+        if (def.$type === 'bpmn:TimerEventDefinition')
+            return true;
+    }
+    return false;
+}
+/**
+ * A start event carrying a registry-backed trigger — `.startEvent({ timer, trigger })`.
+ *
+ * The schedule comes from the element's own event definition and the payload
+ * variable from the extension's output row, which is exactly the split the builder
+ * models: the definition schedules, the extension names the type and the variable.
+ *
+ * Only `Intsvc.TimerTrigger` has an authoring surface today. Another start-event
+ * type reaching here (`Intsvc.EventTrigger`, phase 3d) has no `trigger` spelling to
+ * emit, so it is refused rather than quietly written as an `.activity()` that would
+ * lose its event definition.
+ */
+function emitTriggerStartEvent(chain, el, payload, type) {
+    if (type !== 'Intsvc.TimerTrigger') {
+        throw new Error(`start event "${el.id}" carries extension type "${type}", whose event definition the generic ` +
+            `.activity() path cannot reproduce, so it is refused rather than silently emitted without it.`);
+    }
+    const spec = registryType(type);
+    const row = (payload.output ?? [])[0];
+    const defaultVar = spec.output ? `${el.id}_${identifierize(spec.output.name)}` : undefined;
+    const outputVar = row?.var;
+    const trigger = outputVar !== undefined && outputVar !== defaultVar ? opts([['outputVar', str(outputVar)]]) : 'true';
+    chain.add(`.startEvent(${str(el.id)}, ${opts([
+        ['name', el.name !== undefined ? str(el.name) : undefined],
+        ...eventOptions(el),
+        ['trigger', trigger],
+    ])})`);
+}
+/**
+ * Kinds whose builder method OWNS the element it emits, so a payload that does not
+ * describe that element is a decoration rather than the node itself.
+ *
+ * An activity is deliberately absent: for a service task the extension type really
+ * is what the node is, and the generic `.activity()` reproduces it faithfully.
+ */
+const ELEMENT_OWNS = new Set([
+    'startEvent',
+    'endEvent',
+    'intermediateCatchEvent',
+    'intermediateThrowEvent',
+    'boundaryEvent',
+    'scriptTask',
+    'subProcess',
+]);
+/** The five element kinds the builder spells with an event method. */
+const EVENT_KINDS = new Set([
+    'startEvent',
+    'endEvent',
+    'intermediateCatchEvent',
+    'intermediateThrowEvent',
+    'boundaryEvent',
+]);
+/**
+ * Whether an element is the kind its extension type says it is.
+ *
+ * The registry gives each type the element it serializes to. When the two agree,
+ * the type describes the whole element and the typed emitter reproduces it. When
+ * they disagree the payload is a DECORATION on an element the type knows nothing
+ * about — `BPMN.Variables` says `bpmn:Task`, but the product writes it on start
+ * events, end events and sub-processes too — and the element has to win.
+ *
+ * An unknown type answers `false` rather than throwing: the caller is choosing an
+ * emitter, and the typed path is the one that reports the unknown type properly.
+ */
+function typeDescribesElement(kind, type) {
+    if (!type)
+        return false;
+    let element;
+    try {
+        element = registryType(type).element;
+    }
+    catch {
+        return false;
+    }
+    return !!element && localName(element).toLowerCase() === kind.toLowerCase();
+}
+/**
+ * An event element, with whatever payload it carries as an option on it.
+ *
+ * One emitter for all five kinds because they differ only in which options are
+ * legal, and the boundary's extra two are additive.
+ */
+function emitEvent(chain, el, kind, payload, type) {
+    // `outputRows` is the only payload shape an event carries in the corpus. A
+    // `context` or `input` row on one would mean the registry describes the element
+    // after all, which is the branch this function is not on.
+    const eventPayload = payload && type
+        ? opts([
+            ['type', str(type)],
+            ['outputRows', emitOutputRows(payload) ?? '[]'],
+        ])
+        : undefined;
+    if (kind === 'boundaryEvent') {
+        chain.add(`.boundaryEvent(${str(el.id)}, ${opts([
+            ['name', el.name !== undefined ? str(el.name) : undefined],
+            ['attachedTo', str(el.attachedToRef?.id)],
+            // The builder defaults to interrupting; only the exception is worth saying.
+            ['cancelActivity', el.cancelActivity === false ? 'false' : undefined],
+            ...eventOptions(el),
+            ['payload', eventPayload],
+        ])})`);
+        return;
+    }
+    chain.add(`.${kind}(${str(el.id)}${optionalArg(opts([
+        ['name', el.name !== undefined ? str(el.name) : undefined],
+        ...eventOptions(el),
+        ['payload', eventPayload],
+    ]))})`);
+}
+function emitElement(chain, el, depth, indent) {
+    const kind = localName(el.$type);
+    const payload = payloadOf(el);
+    const type = extensionTypeOf(payload);
+    // THE ELEMENT DECIDES, whenever the payload does not describe it.
+    //
+    // The product decorates elements with payloads that say nothing about what the
+    // element is: `BPMN.Variables` on a start event (mapping process inputs onto
+    // variables), on an end event (variables onto process outputs), on a script task,
+    // on a sub-process — and `uipath:Activity` on an error boundary, to capture the
+    // error payload. `BPMN.Variables`' registry element is `bpmn:Task`, so dispatching
+    // on the extension type turned every one of them into a task. Measured over five
+    // real exports, that cost a process its only start event (recompile then failed
+    // `NO_START`), freed ten error boundaries into the main flow as service tasks,
+    // dropped 19 445 lines of script body, and flattened a sub-process holding 22
+    // elements into a single `.task()`. All of it validates.
+    //
+    // `typeDescribesElement` separates decoration from description, rather than a list
+    // of decorating types: `Intsvc.EventTrigger` and `Intsvc.TimerTrigger` genuinely
+    // ARE start events in the registry, so they keep the typed path and their context.
+    const elementWins = ELEMENT_OWNS.has(kind) && !typeDescribesElement(kind, type);
+    if (elementWins) {
+        if (EVENT_KINDS.has(kind))
+            return emitEvent(chain, el, kind, payload, type);
+        if (kind === 'scriptTask')
+            return emitScriptTask(chain, el, payload, type);
+        // `subProcess` falls through to the switch below, whose emitter already
+        // recurses into the nested scope — it was simply never reached.
+    }
+    // Registry-typed nodes: the extension type, not the element, decides.
+    if (payload && type && !elementWins) {
+        if (type === 'BPMN.ScriptTask')
+            return emitScriptTask(chain, el, payload, type);
+        if (type === 'BPMN.Variables')
+            return emitVariableTask(chain, el, payload);
+        // …except a start-event type whose event definition carries CONFIGURATION the
+        // generic `.activity()` path would drop.
+        //
+        // The distinction is the definition's CONTENT, not the element. A timer's
+        // definition holds the schedule, which the typed emitter takes from the spec —
+        // and the spec declares it empty, so a timer trigger came back as
+        // `<bpmn:timerEventDefinition />` with no schedule at all: the fires-never
+        // artifact the builder refuses to author, reachable by IMPORT instead. Both
+        // validators call that Valid, so only the byte-identity gate sees it.
+        //
+        // `Intsvc.EventTrigger` (phase 3d) is the opposite case: its
+        // `<bpmn:messageEventDefinition />` is BARE, and the spec emits exactly that, so
+        // the generic path reproduces it byte-for-byte and needs no special handling.
+        if (kind === 'startEvent' && startEventDefinitionCarriesConfig(el)) {
+            return emitTriggerStartEvent(chain, el, payload, type);
+        }
+        return emitTypedNode(chain, el, payload, type);
+    }
+    switch (kind) {
+        case 'exclusiveGateway':
+        case 'inclusiveGateway':
+            chain.add(`.${kind}(${str(el.id)}${optionalArg(opts([
+                ['name', el.name !== undefined ? str(el.name) : undefined],
+                ['default', el.default?.id !== undefined ? str(el.default.id) : undefined],
+            ]))})`);
+            return;
+        case 'parallelGateway':
+        case 'eventBasedGateway':
+            chain.add(`.${kind}(${str(el.id)}${optionalArg(opts([['name', el.name !== undefined ? str(el.name) : undefined]]))})`);
+            return;
+        // A task element with no `uipath:*` payload — an abstract task. All seven kinds are
+        // legal bare and `validate` accepts every one, so they decompile through
+        // `.plainTask()`, which is the only surface that emits a payload-free element.
+        //
+        // `bpmn:task` used to come through `.task()` here, with a comment claiming it
+        // "round-trips as an empty one". It did not: `.task()` always emits a
+        // `BPMN.Variables` mapping, so the recompiled element GAINED a payload the original
+        // never had — a silent change, in a file whose header promises the opposite. The
+        // other six threw "has no builder equivalent", which was at least honest.
+        case 'task':
+        case 'userTask':
+        case 'serviceTask':
+        case 'sendTask':
+        case 'manualTask':
+        case 'businessRuleTask':
+        case 'receiveTask':
+            chain.add(`.plainTask(${str(el.id)}${optionalArg(opts([
+                ['name', el.name !== undefined ? str(el.name) : undefined],
+                // Only when it is not the default, so the common case stays terse. Spelled
+                // the way the XML is, not the way moddle types it.
+                ['element', kind === 'task' ? undefined : str(`bpmn:${kind}`)],
+                ['tags', tagsOf(el)],
+                ['retry', emitRetry(retryOf(el))],
+                ['errorMapping', emitErrorMapping(errorMappingOf(el))],
+                ['loop', emitLoop(el)],
+            ]))})`);
+            return;
+        case 'subProcess': {
+            const inner = new Chain(indent.repeat(depth + 2));
+            emitScope(inner, el, depth + 1, indent);
+            emitVariablesInto(inner, el);
+            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) => {}';
+            // The mapping a sub-process carries maps its results back out to the
+            // enclosing scope — distinct from the variables it DECLARES, which
+            // `emitVariablesInto` has already written into the body above.
+            const spPayload = payloadOf(el);
+            const spType = extensionTypeOf(spPayload);
+            chain.add(`.subProcess(${str(el.id)}, ${body}${optionalArg(opts([
+                ['name', el.name !== undefined ? str(el.name) : undefined],
+                [
+                    'payload',
+                    spPayload && spType
+                        ? opts([
+                            ['type', str(spType)],
+                            ['outputRows', emitOutputRows(spPayload) ?? '[]'],
+                        ])
+                        : undefined,
+                ],
+                ['triggeredByEvent', el.triggeredByEvent ? 'true' : undefined],
+                ['loop', emitLoop(el)],
+                ['tags', tagsOf(el)],
+                ['retry', emitRetry(retryOf(el))],
+                ['errorMapping', emitErrorMapping(errorMappingOf(el))],
+            ]))})`);
+            return;
+        }
+        default:
+            throw new Error(`decompile: element <${el.$type}> (id "${el.id}") has no builder equivalent. ` +
+                'A registry-typed node needs its `uipath:activity`/`uipath:event`/`uipath:mapping` payload to be decompiled.');
+    }
+}
+/** The core `types` spellings the builder's `.var()` takes, from a wire value. */
+function varType(wire) {
+    switch (wire) {
+        case 'json':
+            // `object` and `array` both serialize to `json`; `object` is the safe reading
+            // since the builder maps both the same way.
+            return 'object';
+        case 'bool':
+            return 'boolean';
+        default:
+            return wire ?? 'string';
+    }
+}
+/** Emit `.var()` / `.input()` / `.output()` for one scope's declarations. */
+function emitVariablesInto(chain, container, 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) {
+    const vars = (container.extensionElements?.values ?? []).find((x) => x.$type === 'uipath:Variables');
+    if (!vars)
+        return;
+    const groups = [
+        ['input', 'input'],
+        ['inputOutput', 'var'],
+        ['output', 'output'],
+    ];
+    for (const [prop, method] of groups) {
+        for (const v of vars[prop] ?? []) {
+            if (skip.has(v.id))
+                continue;
+            const type = varType(v.type);
+            const def = v.default === undefined ? undefined : decodeDefault(v.default, v.type);
+            chain.add(`.${method}(${str(v.id)}, ${str(type)}${optionalArg(opts([
+                ['name', v.name !== undefined && v.name !== v.id ? str(v.name) : undefined],
+                ['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),
+                ],
+            ]))})`);
+        }
+    }
+}
+/** A variable `default` attribute back into the TS literal it came from. */
+function decodeDefault(raw, wire) {
+    if (wire === 'json')
+        return raw; // already JSON — emit it verbatim
+    if (wire === 'number')
+        return Number.isFinite(Number(raw)) ? String(Number(raw)) : str(raw);
+    if (wire === 'boolean' || wire === 'bool')
+        return raw === 'true' ? 'true' : 'false';
+    return str(raw);
+}
+// ─── Entry point ──────────────────────────────────────────────────────────────
+/**
+ * Turn `.bpmn` XML into `.bpmn.ts` builder source.
+ *
+ * @param xml - The `.bpmn` document.
+ * @param options - The import specifier for the emitted source.
+ * @returns TypeScript source whose default export re-serializes to the same XML.
+ */
+/**
+ * Where a document's `uipath:variables` and `uipath:bindings` actually live, and
+ * what it costs to read them from there.
+ *
+ * A pool-shaped export hangs both off the `bpmn:collaboration` rather than the
+ * `bpmn:process` — the process is reached through a `bpmn:participant` — and the
+ * SDK models a bare process. Reading only the process found nothing at all: one
+ * real customer file declares **all 112** of its variables at collaboration level,
+ * so the import produced a source whose every expression referenced something
+ * undeclared.
+ *
+ * Flattening is the honest trade — the variables are the process's, and the pool
+ * is presentation — but it is not free, so it is announced rather than performed
+ * silently: the emitted source carries a header saying what was dropped. Twenty-seven
+ * of those variables are scoped to the collaboration's own id, which will not exist
+ * after a recompile, so they are rehomed onto the process, which is a legal scope.
+ */
+function variablesHost(defs, process) {
+    const hasOwn = (process.extensionElements?.values ?? []).some((x) => x.$type === 'uipath:Variables' || x.$type === 'uipath:Bindings');
+    const collab = (defs.rootElements ?? []).find((r) => r.$type === 'bpmn:Collaboration');
+    if (hasOwn || !collab)
+        return { container: process, note: '' };
+    const lanes = (process.laneSets ?? []).flatMap((ls) => ls.lanes ?? []);
+    const dropped = [
+        `bpmn:collaboration ${collab.id}`,
+        ...(collab.participants ?? []).map((p) => `bpmn:participant ${p.id}${p.name ? ` (${p.name})` : ''}`),
+        ...lanes.map((l) => `bpmn:lane ${l.id}${l.name ? ` (${l.name})` : ''}`),
+    ];
+    const note = `// FLATTENED FROM A POOL. The source document wrapped this process in a\n` +
+        `// collaboration, and the SDK models a bare bpmn:process — so recompiling this\n` +
+        `// file will NOT reproduce the pool or its lanes, and the canvas will look\n` +
+        `// different. Dropped:\n` +
+        dropped.map((d) => `//   - ${d}\n`).join('') +
+        `// The variables below were declared on the collaboration and are carried over;\n` +
+        `// those scoped to it are rehomed onto the process, which is a legal scope.\n\n`;
+    return { container: collab, rehome: { from: collab.id, to: process.id }, note };
+}
+export async function decompile(xml, options = {}) {
+    const moddle = new BpmnModdle({ uipath: uipathDescriptor });
+    const { rootElement } = await moddle.fromXML(xml, { lax: true });
+    const defs = rootElement;
+    const process = (defs.rootElements ?? []).find((r) => r.$type === 'bpmn:Process');
+    if (!process)
+        throw new Error('decompile: no bpmn:Process in the document');
+    const indent = '  ';
+    const chain = new Chain(indent);
+    const host = variablesHost(defs, process);
+    // Process metadata, before anything else — it describes the document, and reading it
+    // first mirrors the order `serialize` writes it.
+    //
+    // Dropping it silently is a round-trip hole with teeth: every real artifact carries
+    // `uipath:migrationVersion` (the skills `edit/*` fixtures all have version="11.5"), and a
+    // grader that requires it fails a decompiled-then-recompiled process even though the
+    // author changed nothing. `.metadata()` only became expressible in #474, which is why
+    // this was not wired up when the importer landed.
+    const processExt = process.extensionElements?.values ?? [];
+    const findExt = (type) => processExt.find((x) => x.$type === type);
+    const migration = findExt('uipath:MigrationVersion');
+    const rootStart = (process.flowElements ?? []).find((x) => x.$type === 'bpmn:StartEvent');
+    const entryPoint = (rootStart?.extensionElements?.values ?? []).find((x) => x.$type === 'uipath:EntryPointId') ?? findExt('uipath:EntryPointId');
+    const tagsExt = findExt('uipath:Tags');
+    const caseMgmt = findExt('uipath:CaseManagement');
+    const tagValues = (tagsExt?.tags ?? []).map((t) => t.value).filter((v) => typeof v === 'string');
+    // `isExecutable` is an ATTRIBUTE rather than an extension, and only worth emitting when
+    // it is false: the serializer defaults to true, and a document that omits the attribute
+    // is executable by BPMN's own default. Carrying it matters because the serializer used
+    // to hardcode true, so a non-executable process came back executable — a draft promoted
+    // to runnable, silently.
+    const nonExecutable = process.isExecutable === false;
+    // The schema generation gets its OWN call, under the name all three families
+    // use for a document's schema version — and it comes first, mirroring the
+    // order `serialize` writes the process's extension children. `.metadata({
+    // migrationVersion })` still sets the same field; this is the spelling the
+    // round-trip emits.
+    const schema = preserveSchemaVersion(BPMN_SCHEMA_VERSIONS, migration?.version);
+    if (schema.call)
+        chain.add(schema.call);
+    if (entryPoint !== undefined ||
+        tagValues.length > 0 ||
+        caseMgmt !== undefined ||
+        nonExecutable) {
+        chain.add(`.metadata(${opts([
+            ['executable', nonExecutable ? 'false' : undefined],
+            ['entryPointId', entryPoint?.value !== undefined ? str(entryPoint.value) : undefined],
+            ['tags', tagValues.length > 0 ? `[${tagValues.map((t) => str(t)).join(', ')}]` : undefined],
+            [
+                'caseManagement',
+                caseMgmt?.version !== undefined
+                    ? `{ version: ${str(caseMgmt.version)}${caseMgmt.value !== undefined ? `, value: ${str(caseMgmt.value)}` : ''} }`
+                    : undefined,
+            ],
+        ])})`);
+    }
+    // Bindings next: a typed node may reference one, and reading the declarations
+    // before the nodes keeps the emitted source in dependency order.
+    const bindings = (host.container.extensionElements?.values ?? []).find((x) => x.$type === 'uipath:Bindings');
+    for (const b of bindings?.binding ?? []) {
+        chain.add(`.binding(${str(b.id)}, ${opts([
+            ['name', b.name !== undefined && b.name !== b.id ? str(b.name) : undefined],
+            ['value', b.default !== undefined ? str(b.default) : undefined],
+            ['resource', b.resource !== undefined && b.resource !== 'custom' ? str(b.resource) : undefined],
+            ['resourceKey', b.resourceKey !== undefined && b.resourceKey !== b.default ? str(b.resourceKey) : undefined],
+            ['propertyAttribute', b.propertyAttribute !== undefined && b.propertyAttribute !== 'value' ? str(b.propertyAttribute) : undefined],
+            ['resourceSubType', b.resourceSubType !== undefined ? str(b.resourceSubType) : undefined],
+        ])})`);
+    }
+    // Variables the serializer DERIVES from a node's output are re-derived on
+    // recompile, so echoing them would double-declare. Skip exactly those.
+    const derived = derivedVariableIds(process);
+    // Count the bodies first: whether one is written inline or shared depends on how
+    // many variables carry it, which is only knowable across the whole document.
+    const varsExt = (host.container.extensionElements?.values ?? []).find((x) => x.$type === 'uipath:Variables');
+    const schemaPlan = planSchemas([
+        ...(varsExt?.input ?? []),
+        ...(varsExt?.inputOutput ?? []),
+        ...(varsExt?.output ?? []),
+    ]);
+    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);
+    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)})`;
+    const name = process.name !== undefined ? `\n${indent}.name(${str(process.name)})` : '';
+    return `${host.note}${head}${name}\n${chain.all.join('\n')}\n${indent}.build();\n`;
+}
+/**
+ * Variable ids the serializer creates on its own from a node's output rows.
+ *
+ * These are not author declarations — `implicitNodeVars` adds them at serialize
+ * time — so a decompiled file must NOT re-declare them, or the recompiled process
+ * declares them twice and the XML stops matching.
+ *
+ * **This set has to equal serialize's derive set exactly.** Drift either way is a
+ * silent round-trip bug: too narrow and a variable is declared twice (measured —
+ * an author-mapped HITL output was re-declared, which reordered the block); too
+ * wide and a genuinely authored variable disappears. So it mirrors
+ * `implicitNodeVars`: EVERY output row of a typed node, its own and the
+ * author-mapped extras alike, plus a connector's response/error pair — but only
+ * where the declaration on disk actually LOOKS derived, per below.
+ *
+ * The second half of that comment was not hypothetical. `implicitNodeVars` claims a
+ * row's variable only when the author has not declared it (`taken.has(id)` — "author-
+ * declared names win"), so a row whose `var` is also an explicit `.var()` is NOT
+ * derived, and echoing the row's id into the skip set deleted a real declaration.
+ * Measured on a business rule mapping into a declared variable:
+ * `.var('t', 'string', { default: 'none' })` vanished and came back as the implicit
+ * `type="json"` with no default — a silently RETYPED variable, D1's hazard arriving by
+ * a different road. Any `outputs: { <a declared var>: … }` on any typed node hit it;
+ * the HITL case in the round-trip table missed it only because its mapped row writes
+ * `decision` while its declared variable is `o`.
+ */
+function derivedVariableIds(process) {
+    const candidates = new Set();
+    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') {
+                for (const row of payload.output ?? [])
+                    if (row.var)
+                        candidates.add(row.var);
+            }
+            if (el.$type === 'bpmn:SubProcess')
+                walk(el);
+        }
+    };
+    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.
+    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))
+            continue;
+        if (v.name !== undefined && v.name !== v.id)
+            continue;
+        if (v.type !== 'json')
+            continue;
+        if (v.default !== undefined || v.elementId !== undefined)
+            continue;
+        out.add(v.id);
+    }
+    return out;
+}