@uipath/maestro-builder-sdk 6.65.0 → 6.66.1

package/dist/bpmn/merge.js

@@ -21,36 +21,53 @@
  * the merge emits the element from the ORIGINAL. The original XML is the carrier for the
  * wire detail the builder does not model, so the builder never has to model it.
  *
+ * The same rule holds one level down, all the way: inside an element the author did
+ * touch, each attribute, child element and text that `edited` has as `baseline` has it
+ * stays the original's, and only what differs comes from `edited`. So editing a script
+ * changes the script, not the task's mapping rows, event definition ids or the other
+ * children of its sub-process. The document root is merged the same way, so a
+ * definition the edit needs (a new `bpmn:error`) lands beside the process.
+ *
  * Without a `baseline` the merge is two-way: take the edited process, re-attach the
  * original diagram by element id. Correct whenever decompile was faithful for every
  * element, and still much better than a bare recompile, which drops layout entirely.
  *
+ * ## Reading the code
+ *
+ * Every function of the three-way merge names the three documents the same way:
+ * `original` (the file on disk), `baseline` (the round trip of the original) and `edited`
+ * (the compiled edit). Each is passed as a `Located`, one element with the text of the
+ * document it was read from, since a range means nothing without its text. A map between
+ * two sibling lists is named for its direction: `originalToBaseline` takes an original
+ * child to its baseline counterpart.
+ *
  * ## Two things that differ from the flow merge
  *
  * 1. **Wiring lives inside the element.** A flow node's edges are separate objects, so
  *    `mergeFlow` can swap a whole node. A BPMN element carries `bpmn:incoming` /
  *    `bpmn:outgoing` as children, so a reorder changes an element whose payload is
- *    untouched. The comparison here therefore ignores wiring, and a preserved element
- *    adopts the EDITED wiring while keeping its ORIGINAL payload. Without that,
- *    reordering two tasks either loses their payloads or restores the old order.
+ *    untouched. The comparison here therefore ignores wiring, and wiring merges on its
+ *    own, entry by entry (`mergedWiring`): the original's entries, less those the edit
+ *    dropped from the baseline's, plus those it added. An element whose payload the edit
+ *    left alone keeps its original text, with that wiring.
  *
- * 2. **`bpmn:extensionElements` has no id**, so the process-level block is merged by
- *    role rather than by key: the author's `uipath:variables` wins (they may have
- *    declared one), and every other child — `migrationVersion`, `caseManagement`, and
- *    anything else a future platform version puts there — comes from the original
- *    untouched. Nothing in this file needs to know what those payloads mean.
+ * 2. **`bpmn:extensionElements` and its rows mostly have no id**, so children are paired
+ *    by id, then by a unique `name`, then by position among siblings of the same kind.
+ *    A child of the original the round trip does not carry (`caseManagement`, anything
+ *    a future platform version adds) has no baseline counterpart, so nothing can have
+ *    removed it and it stays. Nothing in this file needs to know what those payloads
+ *    mean.
  *
- * ## What it deliberately does NOT preserve
+ * ## What it does not repair
  *
- * A bare `<uipath:input name="args">`. `uip maestro bpmn validate` rejects it — the row
- * must declare `type="json"` and target `"bodyField"` — so an original missing them is
- * invalid, and the recompiled form is the correct one. Preserving that faithfully would
- * mean preserving invalid markup. It is not a special case in the code: such a row only
- * ever appears inside an element the author edited, which is taken from `edited` anyway.
- * Recorded here because it is the one difference a reader will expect to see handled.
+ * A bare `<uipath:input name="args">`, which `uip maestro bpmn validate` rejects (the row
+ * must declare `type="json"` and target `"bodyField"`), stays bare unless the author
+ * edits that row: the merge changes what the edit changed and nothing else.
  */
+import { ownEntry } from '../core/own-entry.js';
 import { findByLocal, parseXmlRanges } from './xml-ranges.js';
 const WIRING = new Set(['incoming', 'outgoing']);
+const isWiring = (range) => WIRING.has(range.local);
 function processOf(xml, label) {
     const process = findByLocal(parseXmlRanges(xml), 'process');
     if (!process)
@@ -61,6 +78,32 @@ function processOf(xml, label) {
 function textOf(xml, range) {
     return xml.slice(range.start, range.end);
 }
+/** Where the run of whitespace that ends at `at` starts. */
+function whitespaceStart(xml, at) {
+    let from = at;
+    while (from > 0 && /\s/.test(xml[from - 1]))
+        from--;
+    return from;
+}
+/** The spaces and tabs between the start of the line `at` is on and `at`. */
+function lineIndent(xml, at) {
+    let from = at;
+    while (from > 0 && (xml[from - 1] === ' ' || xml[from - 1] === '\t'))
+        from--;
+    return xml.slice(from, at);
+}
+/** `xml` with each range replaced by its text; a range replaced by nothing takes the whitespace before it too. */
+function replaceRanges(xml, edits) {
+    let text = '';
+    let at = 0;
+    for (const edit of [...edits].sort((x, y) => x.range.start - y.range.start)) {
+        const from = edit.text === '' ? whitespaceStart(xml, edit.range.start) : edit.range.start;
+        text += xml.slice(at, Math.max(at, from)) + edit.text;
+        at = edit.range.end;
+    }
+    return text + xml.slice(at);
+}
+const locate = (document, range) => ({ xml: document.xml, range });
 /**
  * The element's text with its wiring children removed and whitespace flattened — the
  * form two documents are compared in to answer "did the author touch this element?".
@@ -70,83 +113,52 @@ function textOf(xml, range) {
  * produces identical bytes. Structural canonicalisation would be strictly more code for
  * the same answer.
  */
-function withoutWiring(xml, range) {
-    const cuts = range.children.filter((c) => WIRING.has(c.local));
+function withoutWiring(element) {
     let text = '';
-    let at = range.start;
-    for (const cut of cuts) {
-        text += xml.slice(at, cut.start);
-        at = cut.end;
+    let at = element.range.start;
+    for (const child of element.range.children.filter(isWiring)) {
+        text += element.xml.slice(at, child.start);
+        at = child.end;
     }
-    text += xml.slice(at, range.end);
+    text += element.xml.slice(at, element.range.end);
     return text.replace(/\s+/g, ' ').trim();
 }
 /**
- * Graft the edited element's wiring onto the original element's text.
- *
- * The edited wiring is written where the original's first wiring child sat, so the
- * children stay in schema order (`extensionElements` before `incoming`/`outgoing`). An
- * element with no wiring in either document is returned untouched.
+ * The wiring an element ends with, three ways by entry: the original's, less what the
+ * edit dropped from the baseline's, plus what it added. The round trip lists every flow
+ * an element is an end of, which an original may not, so a whole-list comparison would
+ * rewire elements nobody touched. Undefined when the answer is the original's own list.
+ * The schema wants every `incoming` before any `outgoing`, so an added entry goes with its kind.
  */
-function withWiringFrom(originalXml, original, editedXml, edited) {
-    const originalWiring = original.children.filter((c) => WIRING.has(c.local));
-    const editedWiring = edited.children.filter((c) => WIRING.has(c.local));
-    // When the wiring is the same, the element is returned untouched — no reflowing. This
-    // is not an optimisation: splicing identical content back in still rewrites the
-    // element's whitespace, and an original that put `<bpmn:incoming/>` and
-    // `<bpmn:outgoing/>` on one line would come back on two. That is a diff on an element
-    // nobody edited, which is the one thing this function exists to avoid.
-    const wiringOf = (xml, w) => w.map((c) => `${c.local}=${xml.slice(c.innerStart, c.innerEnd).trim()}`).join(',');
-    if (wiringOf(originalXml, originalWiring) === wiringOf(editedXml, editedWiring)) {
-        return textOf(originalXml, original);
-    }
-    const replacement = editedWiring.map((w) => editedXml.slice(w.start, w.end));
-    // Indentation of the first wiring child, so the grafted lines sit where the old ones did.
-    const anchor = originalWiring[0];
-    const indent = anchor
-        ? (/([ \t]*)$/.exec(originalXml.slice(original.innerStart, anchor.start))?.[1] ?? '')
-        : '';
-    if (originalWiring.length === 0) {
-        // Nothing to replace: insert before the close tag.
-        const head = originalXml.slice(original.start, original.innerEnd);
-        const tail = originalXml.slice(original.innerEnd, original.end);
-        const block = replacement.map((w) => `${indent}  ${w}\n`).join('');
-        return `${head}${block}${indent}${tail}`;
-    }
-    let text = '';
-    let at = original.start;
-    let first = true;
-    for (const w of originalWiring) {
-        text += originalXml.slice(at, w.start);
-        if (first) {
-            text += replacement.join(`\n${indent}`);
-            first = false;
-        }
-        else {
-            // A second or later wiring child: its own text is dropped, and so is the
-            // separator that preceded it, which the slice above already added.
-            text = text.replace(/\s+$/, '');
-        }
-        at = w.end;
-    }
-    text += originalXml.slice(at, original.end);
-    return text;
+function mergedWiring(original, baseline, edited) {
+    const entriesOf = (element) => element.range.children.filter(isWiring).map((child) => ({
+        key: `${child.local}=${element.xml.slice(child.innerStart, child.innerEnd).trim()}`,
+        text: textOf(element.xml, child),
+    }));
+    const keys = (entries) => entries.map((entry) => entry.key).join(',');
+    const originalEntries = entriesOf(original);
+    const editedEntries = entriesOf(edited);
+    if (keys(originalEntries) === keys(editedEntries))
+        return undefined;
+    const inEdited = new Set(editedEntries.map((entry) => entry.key));
+    const inBaseline = new Set(entriesOf(baseline).map((entry) => entry.key));
+    const kept = originalEntries.filter((entry) => inEdited.has(entry.key) || !inBaseline.has(entry.key));
+    const keptKeys = new Set(kept.map((entry) => entry.key));
+    const merged = [...kept, ...editedEntries.filter((entry) => !inBaseline.has(entry.key) && !keptKeys.has(entry.key))];
+    if (keys(merged) === keys(originalEntries))
+        return undefined;
+    const isOutgoing = (entry) => Number(entry.key.startsWith('outgoing='));
+    return merged.sort((x, y) => isOutgoing(x) - isOutgoing(y)).map((entry) => entry.text);
 }
 /**
- * Children of the process-level `bpmn:extensionElements` that the BUILDER can author, and
- * which therefore come from the EDITED document.
- *
- * This is the whole rule for that block, which has no id and so cannot be merged by key:
- * anything the builder models is the author's to change, and anything it does not model is
- * preserve-only and comes from the original untouched. Nothing here needs to know what
- * these payloads mean — only who owns them.
+ * Children of the process-level `bpmn:extensionElements` the builder can author. Used only
+ * by the two-way merge: with no baseline there is no telling whether the author changed
+ * one, so ownership decides. An authored child comes from the edited document, and
+ * anything the builder does not model comes from the original.
  *
- * It started as `variables` alone, which was too narrow and wrong in a way worth
- * recording: a task that sanitized a `uipath:binding` default — replacing a real
- * connection id with a placeholder — produced a merged file with the private value still
- * in it, because bindings were treated as preserve-only. The author had changed them and
- * the merge quietly put them back. Metadata is on the list for the same reason: `.metadata()`
- * has been authorable since #474, so a changed `migrationVersion` must land too.
+ * `bindings` is on the list for a reason worth recording: a task that sanitized a
+ * `uipath:binding` default, replacing a real connection id with a placeholder, produced a
+ * merged file with the private value still in it while bindings were preserve-only.
  */
 const AUTHORED_EXTENSIONS = new Set([
     'variables',
@@ -156,138 +168,494 @@ const AUTHORED_EXTENSIONS = new Set([
     'tags',
     'caseManagement',
 ]);
-/**
- * Merge the process-level `bpmn:extensionElements`.
- *
- * Same delta logic as the elements: an authorable child is taken from the edited document
- * only when the author actually CHANGED it, judged against the baseline. Ownership alone
- * is not enough — taking every authorable child from the edited document rewrote ones
- * nobody touched, and `caseManagement`'s `<![CDATA[…]]>` came back as plain text. Same
- * value, but a diff on a block the author never opened, which is the thing this file
- * exists to avoid.
- *
- * With no baseline there is nothing to compare against, so an authorable child comes from
- * the edited document — the same fallback the two-way element merge makes.
- */
-function mergeExtensionElements(originalXml, original, editedXml, edited, baselineXml, baseline) {
+function twoWayExtensionElements(originalXml, original, editedXml, edited) {
     if (!original)
         return edited ? textOf(editedXml, edited) : undefined;
     if (!edited)
         return textOf(originalXml, original);
-    const baselineByLocal = new Map((baseline?.children ?? []).map((c) => [c.local, c]));
-    const flat = (xml, r) => xml.slice(r.start, r.end).replace(/\s+/g, ' ').trim();
-    /** Did the author change this child, relative to a faithful round trip of the original? */
-    const changed = (child) => {
-        if (!baselineXml)
-            return true;
-        const base = baselineByLocal.get(child.local);
-        if (!base)
-            return true;
-        return flat(editedXml, child) !== flat(baselineXml, base);
-    };
-    const editedByLocal = new Map(edited.children.filter((c) => changed(c)).map((c) => [c.local, c]));
-    const seen = new Set();
-    // Walk the ORIGINAL's children so its order and formatting lead, substituting each
-    // authored child with the edited document's version of it.
+    const editedByLocal = new Map(edited.children.map((c) => [c.local, c]));
     let body = '';
     let at = original.innerStart;
     for (const child of original.children) {
         body += originalXml.slice(at, child.start);
-        const replacement = AUTHORED_EXTENSIONS.has(child.local)
-            ? editedByLocal.get(child.local)
-            : undefined;
-        if (replacement) {
-            body += editedXml.slice(replacement.start, replacement.end);
-            seen.add(child.local);
+        const replacement = AUTHORED_EXTENSIONS.has(child.local) ? editedByLocal.get(child.local) : undefined;
+        body += replacement ? textOf(editedXml, replacement) : textOf(originalXml, child);
+        at = child.end;
+    }
+    body += originalXml.slice(at, original.innerEnd);
+    const indent = lineIndent(originalXml, original.children[0]?.start ?? original.innerEnd);
+    for (const child of edited.children) {
+        if (AUTHORED_EXTENSIONS.has(child.local) && !original.children.some((c) => c.local === child.local)) {
+            body += `${indent}${textOf(editedXml, child)}\n`;
+        }
+    }
+    return originalXml.slice(original.start, original.innerStart) + body + originalXml.slice(original.innerEnd, original.end);
+}
+/** How many of `ranges` carry each `name`. */
+function nameCounts(ranges) {
+    const counts = new Map();
+    for (const range of ranges) {
+        const name = range.attributes.name;
+        if (name !== undefined)
+            counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+    return counts;
+}
+/**
+ * Pair two sibling lists: by id, then by a `name` unique on both sides, then by position
+ * among siblings of the same kind. The last two never pair two elements that both have an
+ * id, since those are different elements; they exist for what compile writes with no id
+ * or a different one (event definitions, `uipath:input` rows, `extensionElements`).
+ */
+function pair(left, right) {
+    const pairs = new Map();
+    const taken = new Set();
+    const take = (x, y) => {
+        pairs.set(x, y);
+        taken.add(y);
+    };
+    const rightById = new Map();
+    for (const y of right)
+        if (y.id !== undefined)
+            rightById.set(y.id, [...(rightById.get(y.id) ?? []), y]);
+    for (const x of left) {
+        if (x.id === undefined)
+            continue;
+        const candidates = (rightById.get(x.id) ?? []).filter((y) => !taken.has(y));
+        if (candidates.length === 1)
+            take(x, candidates[0]);
+    }
+    const free = (x, y) => !pairs.has(x) && !taken.has(y) && y.local === x.local && (x.id === undefined || y.id === undefined);
+    const leftNames = nameCounts(left);
+    const rightNames = nameCounts(right);
+    const rightByName = new Map();
+    for (const y of right)
+        if (y.attributes.name !== undefined && !rightByName.has(y.attributes.name))
+            rightByName.set(y.attributes.name, y);
+    for (const x of left) {
+        const name = x.attributes.name;
+        if (name === undefined || leftNames.get(name) !== 1 || rightNames.get(name) !== 1)
+            continue;
+        const y = rightByName.get(name);
+        if (free(x, y))
+            take(x, y);
+    }
+    for (const x of left) {
+        if (pairs.has(x))
+            continue;
+        const y = right.find((candidate) => free(x, candidate));
+        if (y)
+            take(x, y);
+    }
+    return pairs;
+}
+const invert = (m) => new Map([...m].map(([k, v]) => [v, k]));
+const ATTRIBUTE_AT = /(\s+)([^\s=/>]+)\s*=\s*("[^"]*"|'[^']*')/g;
+/** Three-way merge of one element's attributes, in the original's order with additions last. */
+function mergeAttributes(original, baseline, edited) {
+    const merged = new Map();
+    const chosen = (name) => (edited[name] === baseline[name] ? original[name] : edited[name]);
+    for (const name of Object.keys(original)) {
+        const value = chosen(name);
+        if (value !== undefined)
+            merged.set(name, value);
+    }
+    for (const name of Object.keys(edited))
+        if (!Object.hasOwn(original, name) && edited[name] !== baseline[name])
+            merged.set(name, edited[name]);
+    return merged;
+}
+/** The original open tag, patched to carry `attributes`: same spelling for every attribute it keeps. */
+function openTag(original, attributes, selfClosing) {
+    const { xml, range } = original;
+    const tag = xml.slice(range.start, range.innerStart);
+    const wasSelfClosing = range.innerStart === range.end;
+    const own = Object.entries(range.attributes);
+    if (selfClosing === wasSelfClosing && own.length === attributes.size && own.every(([k, v]) => attributes.get(k) === v))
+        return tag;
+    const quoted = (v) => `"${v.replace(/"/g, '&quot;')}"`;
+    const text = tag.replace(ATTRIBUTE_AT, (all, space, k) => {
+        if (!attributes.has(k))
+            return '';
+        const v = attributes.get(k);
+        return v === range.attributes[k] ? all : `${space}${k}=${quoted(v)}`;
+    });
+    const end = /\s*\/?>$/.exec(text)[0];
+    const adds = [...attributes].filter(([k]) => !Object.hasOwn(range.attributes, k)).map(([k, v]) => ` ${k}=${quoted(v)}`).join('');
+    const close = selfClosing === wasSelfClosing ? end : selfClosing ? ' />' : '>';
+    return `${text.slice(0, text.length - end.length)}${adds}${close}`;
+}
+const ENTITIES = { lt: '<', gt: '>', amp: '&', quot: '"', apos: "'" };
+/** Edited text in the original's spelling: a CDATA body stays CDATA. */
+function asWritten(original, edited) {
+    const cdata = /^(\s*)<!\[CDATA\[[\s\S]*\]\]>(\s*)$/.exec(original);
+    if (!cdata || edited.includes('<![CDATA['))
+        return edited;
+    const text = edited.replace(/&(#x[0-9a-f]+|#\d+|\w+);/gi, (all, name) => {
+        if (name[0] === '#')
+            return String.fromCodePoint(Number(name[1]?.toLowerCase() === 'x' ? `0${name.slice(1)}` : name.slice(1)));
+        return ownEntry(ENTITIES, name) ?? all;
+    });
+    return text.includes(']]>') ? edited : `${cdata[1]}<![CDATA[${text}]]>${cdata[2]}`;
+}
+/** The element's text with some children cut (each with the whitespace before it) or replaced. */
+function spliceChildren(element, edits) {
+    const { xml, range } = element;
+    let text = '';
+    let at = range.start;
+    for (const child of range.children) {
+        if (!edits.has(child))
+            continue;
+        const replacement = edits.get(child);
+        const from = replacement === '' ? whitespaceStart(xml, child.start) : child.start;
+        text += xml.slice(at, Math.max(at, from)) + replacement;
+        at = child.end;
+    }
+    return text + xml.slice(at, range.end);
+}
+/**
+ * What is left of an original child whose baseline counterpart the edit no longer writes.
+ * An element with an id, or a row the baseline also has, was deleted. A container is
+ * not, as such: compile writes none when it has nothing to put in it. What goes is what
+ * the baseline had in it; the children the round trip does not carry stay, and so does
+ * a shell the original wrote empty. A container the edit emptied goes, as compile's does.
+ */
+function remnant(original, baseline) {
+    if (original.range.id !== undefined)
+        return '';
+    if (original.range.children.length === 0)
+        return baseline.range.children.length === 0 ? '' : textOf(original.xml, original.range);
+    const originalToBaseline = pair(original.range.children, baseline.range.children);
+    const edits = new Map();
+    let kept = 0;
+    for (const child of original.range.children) {
+        const counterpart = originalToBaseline.get(child);
+        const rest = counterpart ? remnant(locate(original, child), locate(baseline, counterpart)) : textOf(original.xml, child);
+        if (counterpart)
+            edits.set(child, rest);
+        if (rest)
+            kept += 1;
+    }
+    return kept ? spliceChildren(original, edits) : '';
+}
+/**
+ * The part of a child the original lacks that the edit changed: nothing when the edit
+ * left the round trip's version alone, else the edited element with every child it
+ * shares unchanged with the baseline cut.
+ */
+function changedPart(baseline, edited) {
+    if (withoutWiring(edited) === withoutWiring(baseline))
+        return '';
+    if (edited.range.children.length === 0 || baseline.range.children.length === 0)
+        return textOf(edited.xml, edited.range);
+    const editedToBaseline = invert(pair(baseline.range.children, edited.range.children));
+    const edits = new Map();
+    for (const child of edited.range.children) {
+        const counterpart = editedToBaseline.get(child);
+        if (counterpart)
+            edits.set(child, changedPart(locate(baseline, counterpart), locate(edited, child)));
+    }
+    if ([...edits.values()].every((t) => t === '') && edits.size === edited.range.children.length) {
+        // Every edited child is the baseline's: what changed is the element's own attributes,
+        // or the edit only removed something, which takes nothing from an original without it.
+        const own = (element) => JSON.stringify(Object.entries(element.range.attributes).sort());
+        return own(edited) === own(baseline) ? '' : textOf(edited.xml, edited.range);
+    }
+    return spliceChildren(edited, edits);
+}
+/**
+ * One element, three ways. Untouched (the edit equals the baseline, wiring aside) with
+ * its wiring unchanged, it is the original's text. Otherwise it is rebuilt from the
+ * original one level down: each attribute, child and text the edit left as the baseline
+ * has it stays the original's, the wiring is merged by entry, and only what the edit
+ * changed comes from the edited document.
+ */
+function mergeNode(original, baseline, edited, ctx) {
+    if (!baseline)
+        return textOf(edited.xml, edited.range);
+    const wiring = mergedWiring(original, baseline, edited);
+    if (!wiring && withoutWiring(edited) === withoutWiring(baseline)) {
+        const processes = original.range.local === 'process' ? [original.range] : original.range.children.filter((child) => child.local === 'process');
+        for (const process of processes)
+            for (const child of process.children)
+                if (child.id !== undefined && !isWiring(child))
+                    ctx.preserved.push(child.id);
+        return textOf(original.xml, original.range);
+    }
+    const attributes = mergeAttributes(original.range.attributes, baseline.range.attributes, edited.range.attributes);
+    const leaf = (element) => element.range.children.length === 0;
+    const inner = (element) => element.xml.slice(element.range.innerStart, element.range.innerEnd);
+    const body = leaf(original) && leaf(baseline) && leaf(edited)
+        ? (inner(edited) === inner(baseline) ? inner(original) : asWritten(inner(original), inner(edited)))
+        : mergeChildren(original, baseline, edited, wiring, ctx);
+    if (body === '')
+        return openTag(original, attributes, true);
+    const { range } = original;
+    const close = range.innerStart === range.end ? `</${range.name}>` : original.xml.slice(range.innerEnd, range.end);
+    return `${openTag(original, attributes, false)}${body}${close}`;
+}
+/**
+ * The children of an element the merge rebuilds, from the original's: in the original's
+ * order and spacing, each child the edit kept merged three ways, `wiring` where the
+ * original's wiring sat, and what the edit added placed among its neighbours the way the
+ * edited document orders them.
+ */
+function mergeChildren(original, baseline, edited, wiring, ctx) {
+    const originalChildren = original.range.children;
+    const editedChildren = edited.range.children;
+    const originalPayload = originalChildren.filter((child) => !isWiring(child));
+    const baselinePayload = baseline.range.children.filter((child) => !isWiring(child));
+    const editedPayload = editedChildren.filter((child) => !isWiring(child));
+    const originalToBaseline = pair(originalPayload, baselinePayload);
+    const baselineToOriginal = invert(originalToBaseline);
+    const editedToBaseline = invert(pair(baselinePayload, editedPayload));
+    // Neither side has a baseline counterpart: the round trip drops the original's, and the edit wrote one.
+    const editedToOriginalDirect = invert(pair(originalPayload.filter((child) => !originalToBaseline.has(child)), editedPayload.filter((child) => !editedToBaseline.has(child))));
+    const editedToOriginal = new Map();
+    for (const child of editedPayload) {
+        const base = editedToBaseline.get(child);
+        const counterpart = base ? baselineToOriginal.get(base) : editedToOriginalDirect.get(child);
+        if (counterpart)
+            editedToOriginal.set(child, counterpart);
+    }
+    const originalToEdited = invert(editedToOriginal);
+    const editedIndex = new Map(editedChildren.map((child, index) => [child, index]));
+    const reportsIds = original.range.local === 'process';
+    // Each piece is a child's text and the whitespace before it, with the edited child's
+    // position when it has one, which is where an added sibling is placed against it.
+    const firstEditedWiring = editedChildren.findIndex(isWiring);
+    const pieces = [];
+    let wiringPlaced = !wiring;
+    let at = original.range.innerStart;
+    for (const child of originalChildren) {
+        const lead = original.xml.slice(at, child.start);
+        at = child.end;
+        if (isWiring(child)) {
+            if (!wiring)
+                pieces.push({ lead, text: textOf(original.xml, child) });
+            else if (!wiringPlaced) {
+                // The merged wiring replaces all of the original's, written where its first entry sat.
+                wiringPlaced = true;
+                const next = `\n${lineIndent(original.xml, child.start)}`;
+                wiring.forEach((text, k) => pieces.push({ lead: k ? next : lead, text, editedAt: firstEditedWiring }));
+            }
+            continue;
         }
-        else if (AUTHORED_EXTENSIONS.has(child.local) &&
-            baselineByLocal.has(child.local) &&
-            !edited.children.some((c) => c.local === child.local)) {
-            // The author DELETED it (e.g. dropped every binding): the baseline had it and the
-            // edit does not. Skip it, and the whitespace that preceded it, so no blank line is
-            // left behind. Requires a baseline — without one, absence is indistinguishable from
-            // a child the round trip never carried.
-            body = body.replace(/\s+$/, '');
-            seen.add(child.local);
+        const counterpart = originalToEdited.get(child);
+        if (counterpart) {
+            const base = editedToBaseline.get(counterpart);
+            if (reportsIds && child.id !== undefined) {
+                const untouched = base !== undefined && withoutWiring(locate(edited, counterpart)) === withoutWiring(locate(baseline, base));
+                (untouched ? ctx.preserved : ctx.authored).push(child.id);
+            }
+            const text = mergeNode(locate(original, child), base && locate(baseline, base), locate(edited, counterpart), ctx);
+            pieces.push({ lead, text, editedAt: editedIndex.get(counterpart) });
+        }
+        else if (!originalToBaseline.has(child)) {
+            // The round trip does not carry it, so the edit could not have removed it. Except a
+            // binding row: decompile drops one nothing reads, and a bindings block the edit
+            // changed is where that cleanup reaches the file (RULE:bpmn.brownfield.unused-bindings).
+            if (original.range.local !== 'bindings')
+                pieces.push({ lead, text: textOf(original.xml, child) });
         }
         else {
-            body += originalXml.slice(child.start, child.end);
+            const rest = remnant(locate(original, child), locate(baseline, originalToBaseline.get(child)));
+            if (rest)
+                pieces.push({ lead, text: rest });
         }
-        at = child.end;
     }
-    body += originalXml.slice(at, original.innerEnd);
-    // Authored children the original did not have at all — the author ADDED a block.
-    const indent = /([ \t]*)$/.exec(originalXml.slice(original.innerStart, original.children[0]?.start ?? original.innerEnd))?.[1] ?? '';
-    for (const child of edited.children) {
-        if (AUTHORED_EXTENSIONS.has(child.local) && !seen.has(child.local) && !original.children.some((c) => c.local === child.local)) {
-            body += `${indent}${editedXml.slice(child.start, child.end)}\n`;
+    let tail = original.xml.slice(at, original.range.innerEnd);
+    // What the round trip writes and the edit left alone is not the author's; only a changed part of it is.
+    const added = editedChildren.flatMap((child, index) => {
+        if (isWiring(child) || editedToOriginal.has(child))
+            return [];
+        const base = editedToBaseline.get(child);
+        const text = base ? changedPart(locate(baseline, base), locate(edited, child)) : textOf(edited.xml, child);
+        return text ? [{ child, index, text }] : [];
+    });
+    if (wiring && !wiringPlaced)
+        added.push(...wiring.map((text) => ({ child: editedChildren[firstEditedWiring], index: firstEditedWiring, text })));
+    added.sort((x, y) => x.index - y.index);
+    if (!added.length)
+        return pieces.map((piece) => piece.lead + piece.text).join('') + tail;
+    const parentIndent = lineIndent(original.xml, original.range.start);
+    const indent = originalChildren.length ? lineIndent(original.xml, originalChildren[0].start) : `${parentIndent}  `;
+    if (!originalChildren.length)
+        tail = `\n${parentIndent}`;
+    // An added child goes after the last piece the edited document puts before it, else
+    // before the first it puts after it, else last; children added to one slot keep the
+    // edited order. `anchors` are the pieces by edited position, so one pass places them all.
+    const anchors = pieces.flatMap((piece, k) => (piece.editedAt === undefined ? [] : [{ editedAt: piece.editedAt, k }]))
+        .sort((x, y) => x.editedAt - y.editedAt);
+    const firstAnchorFrom = anchors.map((anchor) => anchor.k);
+    for (let j = firstAnchorFrom.length - 2; j >= 0; j--)
+        firstAnchorFrom[j] = Math.min(firstAnchorFrom[j], firstAnchorFrom[j + 1]);
+    const slots = new Map();
+    let passed = 0;
+    let lastBefore = -1;
+    for (const { child, index, text } of added) {
+        if (reportsIds && child.id !== undefined)
+            ctx.authored.push(child.id);
+        while (passed < anchors.length && anchors[passed].editedAt < index)
+            lastBefore = Math.max(lastBefore, anchors[passed++].k);
+        const slot = lastBefore >= 0 ? lastBefore + 1 : passed < anchors.length ? firstAnchorFrom[passed] : pieces.length;
+        slots.set(slot, [...(slots.get(slot) ?? []), `\n${indent}${text}`]);
+    }
+    const placed = (slot) => (slots.get(slot) ?? []).join('');
+    return pieces.map((piece, k) => placed(k) + piece.lead + piece.text).join('') + placed(pieces.length) + tail;
+}
+/** `xmlns:` declarations the edited root makes and the merged root lacks, for prefixes the merged text uses. */
+function withDeclarations(merged, editedXml) {
+    const root = parseXmlRanges(merged)[0];
+    const editedRoot = parseXmlRanges(editedXml)[0];
+    if (!root || !editedRoot)
+        return merged;
+    const missing = Object.entries(editedRoot.attributes).filter(([k]) => {
+        if (!k.startsWith('xmlns:') || Object.hasOwn(root.attributes, k))
+            return false;
+        return new RegExp(`[<\\s"]${k.slice(6).replace(/[.-]/g, '\\$&')}:`).test(merged.slice(root.innerStart));
+    });
+    if (!missing.length)
+        return merged;
+    const tag = merged.slice(root.start, root.innerStart);
+    const end = /\s*\/?>$/.exec(tag)[0];
+    const decl = missing.map(([k, v]) => ` ${k}="${v}"`).join('');
+    return merged.slice(0, root.start) + tag.slice(0, tag.length - end.length) + decl + end + merged.slice(root.innerStart);
+}
+/** Every id under the document's processes and their siblings, outside the diagram. */
+function modelIds(xml) {
+    const out = new Set();
+    const visit = (r) => {
+        if (r.local === 'BPMNDiagram')
+            return;
+        if (r.id !== undefined)
+            out.add(r.id);
+        r.children.forEach(visit);
+    };
+    for (const root of parseXmlRanges(xml))
+        root.children.forEach(visit);
+    return out;
+}
+/** Every element under `nodes` with the given local name. */
+function allByLocal(nodes, local) {
+    return nodes.flatMap((n) => [...(n.local === local ? [n] : []), ...allByLocal(n.children, local)]);
+}
+/**
+ * Drop the diagram elements, in every diagram, that draw something the merge removed,
+ * and the edges that start or end at one of them.
+ */
+function withoutDiagramFor(merged, kept, originalIds) {
+    const planes = allByLocal(parseXmlRanges(merged), 'BPMNPlane');
+    const all = planes.flatMap((p) => p.children);
+    const gone = new Set(all.filter((di) => {
+        const ref = di.attributes.bpmnElement;
+        return ref !== undefined && originalIds.has(ref) && !kept.has(ref);
+    }));
+    const goneIds = new Set([...gone].map((di) => di.id).filter((id) => id !== undefined));
+    for (const di of all) {
+        if ([di.attributes.sourceElement, di.attributes.targetElement].some((ref) => ref !== undefined && goneIds.has(ref)))
+            gone.add(di);
+    }
+    return replaceRanges(merged, [...gone].map((range) => ({ range, text: '' })));
+}
+/**
+ * A designer-saved file can keep the process's `uipath:variables` and `uipath:bindings` on
+ * its collaboration, where compile writes them on the process. Such a child is merged where
+ * the original keeps it, three ways against the copy the baseline and the edited document
+ * write on the process, and that copy is then cut from both, so the process merge neither
+ * adds it a second time nor reads its absence from the original's process as a delete.
+ */
+function mergeCollaborationExtensions(documents, ctx) {
+    const [originalRoot] = parseXmlRanges(documents.original);
+    const [baselineRoot] = parseXmlRanges(documents.baseline);
+    const [editedRoot] = parseXmlRanges(documents.edited);
+    if (!originalRoot || !baselineRoot || !editedRoot)
+        return documents;
+    const extensionsOf = (range) => range?.children.find((c) => c.local === 'extensionElements');
+    const processIn = (root, id) => root.children.find((c) => c.local === 'process' && c.id === id);
+    const merges = [];
+    const baselineCuts = [];
+    const editedCuts = [];
+    for (const collaboration of originalRoot.children.filter((c) => c.local === 'collaboration')) {
+        const carrier = extensionsOf(collaboration);
+        if (!carrier)
+            continue;
+        for (const participant of collaboration.children.filter((c) => c.local === 'participant')) {
+            const processRef = participant.attributes.processRef;
+            const originalProcess = processIn(originalRoot, processRef);
+            const baselineExtensions = extensionsOf(processIn(baselineRoot, processRef));
+            if (!originalProcess || !baselineExtensions)
+                continue;
+            const own = extensionsOf(originalProcess);
+            const editedExtensions = extensionsOf(processIn(editedRoot, processRef));
+            const held = carrier.children.filter((child) => baselineExtensions.children.some((b) => b.local === child.local) && !own?.children.some((o) => o.local === child.local));
+            if (!held.length)
+                continue;
+            for (const child of held) {
+                const original = { xml: documents.original, range: child };
+                const baseline = { xml: documents.baseline, range: baselineExtensions.children.find((b) => b.local === child.local) };
+                const editedCopy = editedExtensions?.children.find((e) => e.local === child.local);
+                const text = editedCopy ? mergeNode(original, baseline, { xml: documents.edited, range: editedCopy }, ctx) : remnant(original, baseline);
+                merges.push({ range: child, text });
+                baselineCuts.push({ range: baseline.range, text: '' });
+                if (editedCopy)
+                    editedCuts.push({ range: editedCopy, text: '' });
+            }
+            break;
         }
     }
-    return (originalXml.slice(original.start, original.innerStart) +
-        body +
-        originalXml.slice(original.innerEnd, original.end));
+    if (!merges.length)
+        return documents;
+    return {
+        original: replaceRanges(documents.original, merges),
+        baseline: replaceRanges(documents.baseline, baselineCuts),
+        edited: replaceRanges(documents.edited, editedCuts),
+    };
 }
-export function mergeBpmn(originalXml, editedXml, options = {}) {
+function twoWay(originalXml, editedXml) {
     const originalProcess = processOf(originalXml, 'original');
     const editedProcess = processOf(editedXml, 'edited');
-    const baselineProcess = options.baseline ? processOf(options.baseline, 'baseline') : undefined;
-    const byId = (p) => new Map(p.children.filter((c) => c.id !== undefined).map((c) => [c.id, c]));
-    const originalById = byId(originalProcess);
-    const baselineById = baselineProcess ? byId(baselineProcess) : new Map();
-    const preserved = [];
+    const originalById = new Map(originalProcess.children.filter((c) => c.id !== undefined).map((c) => [c.id, c]));
     const authored = [];
     const kept = new Set();
     const pieces = [];
-    const extension = mergeExtensionElements(originalXml, originalProcess.children.find((c) => c.local === 'extensionElements'), editedXml, editedProcess.children.find((c) => c.local === 'extensionElements'), options.baseline, baselineProcess?.children.find((c) => c.local === 'extensionElements'));
+    const extension = twoWayExtensionElements(originalXml, originalProcess.children.find((c) => c.local === 'extensionElements'), editedXml, editedProcess.children.find((c) => c.local === 'extensionElements'));
     if (extension)
         pieces.push(extension);
-    // The EDITED process decides which elements exist and in what order; the ORIGINAL
-    // decides the content of every element the author did not touch.
     for (const element of editedProcess.children) {
         if (element.local === 'extensionElements')
             continue;
-        const id = element.id;
-        const original = id !== undefined ? originalById.get(id) : undefined;
-        const baseline = id !== undefined ? baselineById.get(id) : undefined;
-        const untouched = original !== undefined &&
-            baseline !== undefined &&
-            withoutWiring(editedXml, element) === withoutWiring(options.baseline, baseline);
-        if (untouched) {
-            pieces.push(withWiringFrom(originalXml, original, editedXml, element));
-            preserved.push(id);
-        }
-        else {
-            pieces.push(textOf(editedXml, element));
-            if (id !== undefined)
-                authored.push(id);
+        pieces.push(textOf(editedXml, element));
+        if (element.id !== undefined) {
+            authored.push(element.id);
+            kept.add(element.id);
         }
-        if (id !== undefined)
-            kept.add(id);
     }
     const removed = [...originalById.keys()].filter((id) => !kept.has(id));
-    // Splice the rebuilt process body into the ORIGINAL document, so the prolog,
-    // `bpmn:definitions` attributes and namespace declarations are the original's.
-    const indent = /([ \t]*)$/.exec(originalXml.slice(originalProcess.innerStart, originalProcess.children[0]?.start ?? originalProcess.innerEnd))?.[1] ?? '    ';
+    const indent = lineIndent(originalXml, originalProcess.children[0]?.start ?? originalProcess.innerEnd) || '    ';
     const body = `\n${indent}${pieces.join(`\n${indent}`)}\n${indent.slice(0, -2)}`;
-    let merged = originalXml.slice(0, originalProcess.innerStart) +
-        body +
-        originalXml.slice(originalProcess.innerEnd);
-    // The diagram: the original's layout survives, which is strictly better than the
-    // re-layout a bare recompile forces. Shapes and edges for deleted elements go with
-    // them; anything newly added has no DI yet, which is what `format` is for.
-    if (removed.length > 0) {
-        const plane = findByLocal(parseXmlRanges(merged), 'BPMNPlane');
-        if (plane) {
-            const gone = plane.children.filter((di) => {
-                const ref = di.attributes.bpmnElement;
-                return ref !== undefined && !kept.has(ref);
-            });
-            for (const di of [...gone].reverse()) {
-                // Take the whitespace before it too, so no blank line is left behind.
-                const from = /\s*$/.exec(merged.slice(0, di.start))?.index ?? di.start;
-                merged = merged.slice(0, from) + merged.slice(di.end);
-            }
-        }
-    }
-    return { xml: merged, preserved, authored, removed };
+    let merged = originalXml.slice(0, originalProcess.innerStart) + body + originalXml.slice(originalProcess.innerEnd);
+    if (removed.length > 0)
+        merged = withoutDiagramFor(merged, kept, new Set(removed));
+    return { xml: withDeclarations(merged, editedXml), preserved: [], authored, removed };
+}
+export function mergeBpmn(originalXml, editedXml, options = {}) {
+    processOf(originalXml, 'original');
+    processOf(editedXml, 'edited');
+    if (options.baseline === undefined)
+        return twoWay(originalXml, editedXml);
+    processOf(options.baseline, 'baseline');
+    const ctx = { preserved: [], authored: [] };
+    const documents = mergeCollaborationExtensions({ original: originalXml, baseline: options.baseline, edited: editedXml }, ctx);
+    const [original] = parseXmlRanges(documents.original);
+    const [baseline] = parseXmlRanges(documents.baseline);
+    const [edited] = parseXmlRanges(documents.edited);
+    const root = mergeNode({ xml: documents.original, range: original }, { xml: documents.baseline, range: baseline }, { xml: documents.edited, range: edited }, ctx);
+    let merged = documents.original.slice(0, original.start) + root + documents.original.slice(original.end);
+    const originalIds = modelIds(originalXml);
+    const kept = modelIds(merged);
+    const removed = [...originalIds].filter((id) => !kept.has(id));
+    if (removed.length > 0)
+        merged = withoutDiagramFor(merged, kept, originalIds);
+    return { xml: withDeclarations(merged, editedXml), preserved: ctx.preserved, authored: ctx.authored, removed };
 }