callman-core 1.28.0 → 1.29.0

package/dist-cjs/diagram/bpmn/patch.js

@@ -0,0 +1,774 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchBpmnSource = void 0;
+// Apply diagram OPS to BPMN 2.0 XML as minimal text edits. The AI and MCP
+// emit model ops; for a BPMN diagram the same ops land here, on the element
+// they concern, and every other byte (extension elements, annotations, the
+// modeler's formatting) stays exactly as it was.
+//
+// Mapping (structure + geometry — BPMN keeps positions in its DI):
+//   addNode      → a flow node inside its process / subprocess (+ lane
+//                  membership), a participant (+ collaboration) or a lane,
+//                  and its BPMNShape
+//   updateNode   → name, element kind (tag rename), event definition,
+//                  boundary attachment, expanded state, bioc colors
+//   removeNode   → the element, its shape, every flow touching it, boundary
+//                  events attached to it, lane refs and default-flow attrs
+//   addEdge      → a sequenceFlow (or messageFlow across pools) with
+//                  incoming/outgoing refs, condition, default, and its BPMNEdge
+//   updateEdge   → name, ends, condition, default, waypoints, color
+//   removeEdge   → the flow, its BPMNEdge, refs and default attrs
+//   moveNodes / resizeNode → BPMNShape bounds (+ waypoints of touched flows)
+//   reparent     → lane refs, and the element moved between containers
+//   setTitle     → the main process name
+// Ops are applied one at a time against a fresh parse, so an op can refer to
+// what the previous one inserted. Everything else is reported in `unmapped`.
+const geometry_js_1 = require("../geometry.js");
+const derive_js_1 = require("./derive.js");
+const serialize_js_1 = require("./serialize.js");
+const types_js_1 = require("./types.js");
+const xml_js_1 = require("./xml.js");
+const round = (value) => Math.round(value * 100) / 100;
+const tag = (env, local) => (0, xml_js_1.qualify)(env.bp, local);
+const ensureNamespace = (env, prefix, uri) => {
+    if ((0, xml_js_1.prefixForNamespace)(env.root, uri) !== null)
+        return;
+    const edit = (0, xml_js_1.setAttributeEdit)(env.root, `xmlns:${prefix}`, uri, env.text);
+    if (edit)
+        env.edits.push(edit);
+};
+const elementOf = (env, id) => env.parsed.elements.get(id);
+const isProcessLike = (element) => element.local === "process" || element.local === "subProcess";
+const ancestorProcess = (element) => {
+    let current = element.parent;
+    while (current && current.local !== "process")
+        current = current.parent;
+    return current;
+};
+const nearestContainerElement = (element) => {
+    let current = element.parent;
+    while (current && !isProcessLike(current))
+        current = current.parent;
+    return current;
+};
+const mainProcess = (env) => {
+    const referenced = new Set();
+    if (env.parsed.collaboration) {
+        for (const child of (0, xml_js_1.childElements)(env.parsed.collaboration)) {
+            const ref = (0, xml_js_1.attr)(child, "processRef");
+            if (child.local === "participant" && ref)
+                referenced.add(ref);
+        }
+    }
+    return env.parsed.processes.find((process) => !referenced.has((0, xml_js_1.attr)(process, "id") ?? "")) ?? env.parsed.processes[0] ?? null;
+};
+const processForPool = (env, poolId) => {
+    const participant = elementOf(env, poolId);
+    const ref = participant ? (0, xml_js_1.attr)(participant, "processRef") : undefined;
+    return ref ? (elementOf(env, ref) ?? null) : null;
+};
+// The XML element new flow nodes of `node` go into.
+const containerFor = (env, node) => {
+    const parent = node.parentId ? env.afterById.get(node.parentId) : undefined;
+    if (!parent)
+        return mainProcess(env);
+    if (parent.type === "bpmn.pool")
+        return processForPool(env, parent.id);
+    if (parent.type === "bpmn.lane") {
+        const lane = elementOf(env, parent.id);
+        return lane ? ancestorProcess(lane) : null;
+    }
+    if (parent.type === "bpmn.subprocess")
+        return elementOf(env, parent.id) ?? null;
+    return containerFor(env, parent);
+};
+const laneFor = (env, node) => {
+    const parent = node.parentId ? env.afterById.get(node.parentId) : undefined;
+    return parent?.type === "bpmn.lane" ? elementOf(env, parent.id) : undefined;
+};
+const freshId = (env, base) => {
+    let candidate = (0, types_js_1.ncName)(base);
+    while (env.parsed.elements.has(candidate))
+        candidate = `${candidate}_1`;
+    return candidate;
+};
+const rectOf = (env, id) => {
+    const rect = env.afterRects.get(id);
+    if (rect)
+        return rect;
+    const node = env.afterById.get(id);
+    return { x: 0, y: 0, width: node?.size.width ?? 100, height: node?.size.height ?? 80 };
+};
+const shapeXml = (env, id, rect, extra, indent) => {
+    const attrsText = extra.filter((entry) => entry[1] !== undefined).map(([name, value]) => ` ${name}="${(0, xml_js_1.escapeXml)(value)}"`).join("");
+    return [
+        `<${(0, xml_js_1.qualify)(env.di, "BPMNShape")} id="${freshId(env, `${id}_di`)}" bpmnElement="${(0, xml_js_1.escapeXml)(id)}"${attrsText}>`,
+        `${indent}${env.unit}<${(0, xml_js_1.qualify)(env.dc, "Bounds")} x="${round(rect.x)}" y="${round(rect.y)}" width="${round(rect.width)}" height="${round(rect.height)}" />`,
+        `${indent}</${(0, xml_js_1.qualify)(env.di, "BPMNShape")}>`,
+    ].join("\n");
+};
+const edgeXml = (env, id, waypoints, indent) => [
+    `<${(0, xml_js_1.qualify)(env.di, "BPMNEdge")} id="${freshId(env, `${id}_di`)}" bpmnElement="${(0, xml_js_1.escapeXml)(id)}">`,
+    ...waypoints.map((point) => `${indent}${env.unit}<${(0, xml_js_1.qualify)(env.dd, "waypoint")} x="${round(point.x)}" y="${round(point.y)}" />`),
+    `${indent}</${(0, xml_js_1.qualify)(env.di, "BPMNEdge")}>`,
+].join("\n");
+const waypointsFor = (env, edge) => {
+    if (edge.waypoints && edge.waypoints.length >= 2)
+        return edge.waypoints;
+    return (0, serialize_js_1.defaultBpmnWaypoints)(rectOf(env, edge.source), rectOf(env, edge.target));
+};
+const appendToPlane = (env, xml) => {
+    const plane = env.parsed.plane;
+    if (!plane) {
+        env.warnings.push("The BPMN document has no BPMNPlane; the shape was not drawn.");
+        return false;
+    }
+    const indent = (0, xml_js_1.childIndentOf)(plane, env.text, env.unit);
+    env.edits.push((0, xml_js_1.appendChildEdit)(plane, xml(indent), env.text, env.unit));
+    return true;
+};
+// Rewrite a DI edge's waypoints.
+const setWaypoints = (env, edgeId, waypoints) => {
+    const di = env.parsed.diEdges.get(edgeId);
+    if (!di)
+        return;
+    const indent = (0, xml_js_1.indentOf)(env.text, di.element.span.start);
+    const open = env.text.slice(di.element.span.start, di.element.openEnd).replace(/\/>$/, ">");
+    const body = waypoints.map((point) => `${indent}${env.unit}<${(0, xml_js_1.qualify)(env.dd, "waypoint")} x="${round(point.x)}" y="${round(point.y)}" />`).join("\n");
+    // Keep a BPMNLabel child when there is one.
+    const label = (0, xml_js_1.childElements)(di.element).find((child) => child.local === "BPMNLabel");
+    const labelText = label ? `\n${indent}${env.unit}${env.text.slice(label.span.start, label.span.end)}` : "";
+    env.edits.push({ span: di.element.span, replacement: `${open}\n${body}${labelText}\n${indent}</${di.element.name}>` });
+};
+const setBounds = (env, id, rect) => {
+    const shape = env.parsed.shapes.get(id);
+    if (!shape)
+        return;
+    const bounds = (0, xml_js_1.childElements)(shape.element).find((child) => child.local === "Bounds");
+    if (!bounds)
+        return;
+    for (const [name, value] of [
+        ["x", rect.x],
+        ["y", rect.y],
+        ["width", rect.width],
+        ["height", rect.height],
+    ]) {
+        const edit = (0, xml_js_1.setAttributeEdit)(bounds, name, String(round(value)), env.text);
+        if (edit)
+            env.edits.push(edit);
+    }
+};
+const refreshIncidentEdges = (env, nodeIds) => {
+    for (const edge of env.afterById.size ? env.parsed.structure.edges : []) {
+        if (!nodeIds.has(edge.source) && !nodeIds.has(edge.target))
+            continue;
+        const model = ctxEdge(env, edge.id);
+        if (!model)
+            continue;
+        setWaypoints(env, edge.id, waypointsFor(env, model));
+    }
+};
+let afterEdgesRef = new Map();
+const ctxEdge = (_env, id) => afterEdgesRef.get(id);
+const removeElement = (env, element) => {
+    if (env.removed.has(element))
+        return;
+    env.removed.add(element);
+    env.edits.push((0, xml_js_1.removeElementEdit)(element, env.text));
+};
+const removeRefsTo = (env, flowId) => {
+    for (const ref of (0, xml_js_1.findElements)(env.root, (element) => (element.local === "incoming" || element.local === "outgoing") && (0, xml_js_1.textContent)(element).trim() === flowId))
+        removeElement(env, ref);
+    for (const owner of (0, xml_js_1.findElements)(env.root, (element) => (0, xml_js_1.attr)(element, "default") === flowId)) {
+        const edit = (0, xml_js_1.setAttributeEdit)(owner, "default", null, env.text);
+        if (edit)
+            env.edits.push(edit);
+    }
+};
+const removeFlowElement = (env, flowId) => {
+    const element = elementOf(env, flowId);
+    if (element)
+        removeElement(env, element);
+    const di = env.parsed.diEdges.get(flowId);
+    if (di)
+        removeElement(env, di.element);
+    removeRefsTo(env, flowId);
+};
+const removeNodeElement = (env, id) => {
+    const element = elementOf(env, id);
+    if (!element)
+        return;
+    removeElement(env, element);
+    const shape = env.parsed.shapes.get(id);
+    if (shape)
+        removeElement(env, shape.element);
+    // Flows touching it, boundary events on it, lane refs to it.
+    for (const flow of (0, xml_js_1.findElements)(env.root, (candidate) => (candidate.local === "sequenceFlow" || candidate.local === "messageFlow") && ((0, xml_js_1.attr)(candidate, "sourceRef") === id || (0, xml_js_1.attr)(candidate, "targetRef") === id))) {
+        const flowId = (0, xml_js_1.attr)(flow, "id");
+        if (flowId)
+            removeFlowElement(env, flowId);
+        else
+            removeElement(env, flow);
+    }
+    for (const boundary of (0, xml_js_1.findElements)(env.root, (candidate) => candidate.local === "boundaryEvent" && (0, xml_js_1.attr)(candidate, "attachedToRef") === id)) {
+        const boundaryId = (0, xml_js_1.attr)(boundary, "id");
+        if (boundaryId)
+            removeNodeElement(env, boundaryId);
+    }
+    for (const ref of (0, xml_js_1.findElements)(env.root, (candidate) => candidate.local === "flowNodeRef" && (0, xml_js_1.textContent)(candidate).trim() === id))
+        removeElement(env, ref);
+    // Associations to annotations would dangle; the annotation itself stays.
+    for (const association of (0, xml_js_1.findElements)(env.root, (candidate) => candidate.local === "association" && ((0, xml_js_1.attr)(candidate, "sourceRef") === id || (0, xml_js_1.attr)(candidate, "targetRef") === id))) {
+        removeElement(env, association);
+        const associationId = (0, xml_js_1.attr)(association, "id");
+        const di = associationId ? env.parsed.diEdges.get(associationId) : undefined;
+        if (di)
+            removeElement(env, di.element);
+    }
+    if (element.local === "participant") {
+        const process = processForPool(env, id);
+        if (process && env.parsed.collaboration && (0, xml_js_1.childElements)(env.parsed.collaboration).filter((child) => child.local === "participant").length > 1) {
+            // Other pools keep the collaboration; the process of this one goes with it.
+            removeElement(env, process);
+            for (const child of (0, xml_js_1.findElements)(process, (candidate) => Boolean((0, xml_js_1.attr)(candidate, "id")))) {
+                const childId = (0, xml_js_1.attr)(child, "id");
+                const shape = env.parsed.shapes.get(childId);
+                if (shape)
+                    removeElement(env, shape.element);
+                const di = env.parsed.diEdges.get(childId);
+                if (di)
+                    removeElement(env, di.element);
+            }
+        }
+    }
+    if (element.local === "subProcess" && (0, xml_js_1.childElements)(element).some((child) => (0, xml_js_1.attr)(child, "id"))) {
+        env.warnings.push(`Removing subprocess "${id}" removed its contents from the XML as well.`);
+        for (const child of (0, xml_js_1.findElements)(element, (candidate) => Boolean((0, xml_js_1.attr)(candidate, "id")))) {
+            const childId = (0, xml_js_1.attr)(child, "id");
+            const shape = env.parsed.shapes.get(childId);
+            if (shape)
+                removeElement(env, shape.element);
+            const di = env.parsed.diEdges.get(childId);
+            if (di)
+                removeElement(env, di.element);
+        }
+    }
+};
+const nodeElementXml = (env, node, indent) => {
+    const element = (0, types_js_1.bpmnElementForType)(node.type);
+    if (!element || element === "participant" || element === "lane")
+        return null;
+    const data = (0, types_js_1.bpmnNodeData)(node.data);
+    const attrsText = [
+        ["id", node.id],
+        ["name", node.label],
+        ...(element === "boundaryEvent" ? [["attachedToRef", data?.attachedTo], ["cancelActivity", data?.cancelActivity === false ? "false" : undefined]] : []),
+        ...(element === "subProcess" && data?.triggeredByEvent ? [["triggeredByEvent", "true"]] : []),
+    ]
+        .filter((entry) => typeof entry[1] === "string" && entry[1] !== "")
+        .map(([name, value]) => ` ${name}="${(0, xml_js_1.escapeXml)(value)}"`)
+        .join("");
+    const definition = data?.eventDefinition && (0, types_js_1.getBpmnType)(node.type)?.kind === "event" ? data.eventDefinition : undefined;
+    if (!definition)
+        return `<${tag(env, element)}${attrsText} />`;
+    return [`<${tag(env, element)}${attrsText}>`, `${indent}${env.unit}<${tag(env, (0, types_js_1.eventDefinitionElement)(definition))} id="${freshId(env, `${node.id}_def`)}" />`, `${indent}</${tag(env, element)}>`].join("\n");
+};
+const addPool = (env, node) => {
+    const collaboration = env.parsed.collaboration;
+    const rect = rectOf(env, node.id);
+    const name = node.label ? ` name="${(0, xml_js_1.escapeXml)(node.label)}"` : "";
+    if (!collaboration) {
+        // First pool: wrap the main process (or a new one) in a collaboration.
+        const main = mainProcess(env);
+        const processId = main ? ((0, xml_js_1.attr)(main, "id") ?? "Process_1") : freshId(env, `Process_${node.id}`);
+        const indent = (0, xml_js_1.childIndentOf)(env.root, env.text, env.unit);
+        const collaborationId = freshId(env, "Collaboration_1");
+        const xml = [
+            `<${tag(env, "collaboration")} id="${collaborationId}">`,
+            `${indent}${env.unit}<${tag(env, "participant")} id="${(0, xml_js_1.escapeXml)(node.id)}"${name} processRef="${(0, xml_js_1.escapeXml)(processId)}" />`,
+            `${indent}</${tag(env, "collaboration")}>`,
+        ].join("\n");
+        const firstChild = (0, xml_js_1.childElements)(env.root)[0];
+        if (firstChild)
+            env.edits.push({ span: { start: firstChild.span.start, end: firstChild.span.start }, replacement: `${xml}\n${indent}` });
+        else
+            env.edits.push((0, xml_js_1.appendChildEdit)(env.root, xml, env.text, env.unit));
+        if (!main) {
+            const processXml = `<${tag(env, "process")} id="${(0, xml_js_1.escapeXml)(processId)}" isExecutable="false" />`;
+            env.edits.push(firstChild ? { span: { start: firstChild.span.start, end: firstChild.span.start }, replacement: `${processXml}\n${indent}` } : (0, xml_js_1.appendChildEdit)(env.root, processXml, env.text, env.unit));
+        }
+        if (env.parsed.plane) {
+            const edit = (0, xml_js_1.setAttributeEdit)(env.parsed.plane, "bpmnElement", collaborationId, env.text);
+            if (edit)
+                env.edits.push(edit);
+        }
+    }
+    else {
+        const processId = freshId(env, `Process_${node.id}`);
+        env.edits.push((0, xml_js_1.appendChildEdit)(collaboration, `<${tag(env, "participant")} id="${(0, xml_js_1.escapeXml)(node.id)}"${name} processRef="${processId}" />`, env.text, env.unit));
+        const lastProcess = env.parsed.processes[env.parsed.processes.length - 1];
+        const processXml = `<${tag(env, "process")} id="${processId}" isExecutable="false" />`;
+        env.edits.push(lastProcess ? (0, xml_js_1.insertAfterEdit)(lastProcess, processXml, env.text) : (0, xml_js_1.insertAfterEdit)(collaboration, processXml, env.text));
+    }
+    appendToPlane(env, (indent) => shapeXml(env, node.id, rect, [["isHorizontal", "true"]], indent));
+    return true;
+};
+const addLane = (env, node) => {
+    const parent = node.parentId ? env.afterById.get(node.parentId) : undefined;
+    if (!parent) {
+        env.warnings.push(`Lane "${node.id}" needs a pool or a lane as its parent.`);
+        return false;
+    }
+    const name = node.label ? ` name="${(0, xml_js_1.escapeXml)(node.label)}"` : "";
+    const laneXml = `<${tag(env, "lane")} id="${(0, xml_js_1.escapeXml)(node.id)}"${name} />`;
+    if (parent.type === "bpmn.pool") {
+        const process = processForPool(env, parent.id);
+        if (!process)
+            return false;
+        const laneSet = (0, xml_js_1.childElements)(process).find((child) => child.local === "laneSet");
+        if (laneSet)
+            env.edits.push((0, xml_js_1.appendChildEdit)(laneSet, laneXml, env.text, env.unit));
+        else {
+            const indent = (0, xml_js_1.childIndentOf)(process, env.text, env.unit);
+            const xml = [`<${tag(env, "laneSet")} id="${freshId(env, `${(0, xml_js_1.attr)(process, "id") ?? "Process"}_lanes`)}">`, `${indent}${env.unit}${laneXml}`, `${indent}</${tag(env, "laneSet")}>`].join("\n");
+            const first = (0, xml_js_1.childElements)(process)[0];
+            if (first)
+                env.edits.push({ span: { start: first.span.start, end: first.span.start }, replacement: `${xml}\n${indent}` });
+            else
+                env.edits.push((0, xml_js_1.appendChildEdit)(process, xml, env.text, env.unit));
+        }
+    }
+    else if (parent.type === "bpmn.lane") {
+        const parentLane = elementOf(env, parent.id);
+        if (!parentLane)
+            return false;
+        const childSet = (0, xml_js_1.childElements)(parentLane).find((child) => child.local === "childLaneSet");
+        if (childSet)
+            env.edits.push((0, xml_js_1.appendChildEdit)(childSet, laneXml, env.text, env.unit));
+        else {
+            const indent = (0, xml_js_1.childIndentOf)(parentLane, env.text, env.unit);
+            const xml = [`<${tag(env, "childLaneSet")} id="${freshId(env, `${parent.id}_lanes`)}">`, `${indent}${env.unit}${laneXml}`, `${indent}</${tag(env, "childLaneSet")}>`].join("\n");
+            env.edits.push((0, xml_js_1.appendChildEdit)(parentLane, xml, env.text, env.unit));
+        }
+    }
+    else {
+        env.warnings.push(`Lane "${node.id}" needs a pool or a lane as its parent.`);
+        return false;
+    }
+    appendToPlane(env, (indent) => shapeXml(env, node.id, rectOf(env, node.id), [["isHorizontal", "true"]], indent));
+    return true;
+};
+const addNode = (env, id) => {
+    const node = env.afterById.get(id);
+    if (!node)
+        return false;
+    if (elementOf(env, id))
+        return true; // already there (an undo re-adding it, or a duplicate id)
+    if (node.type === "bpmn.pool")
+        return addPool(env, node);
+    if (node.type === "bpmn.lane")
+        return addLane(env, node);
+    const container = containerFor(env, node);
+    if (!container) {
+        env.warnings.push(`No process to add "${id}" to.`);
+        return false;
+    }
+    const indent = (0, xml_js_1.childIndentOf)(container, env.text, env.unit);
+    const xml = nodeElementXml(env, node, indent);
+    if (!xml) {
+        env.warnings.push(`"${node.type}" is not a BPMN element; "${id}" was not written to the XML.`);
+        return false;
+    }
+    // Before the first sequence flow of the container keeps the modeler's usual order.
+    const firstFlow = (0, xml_js_1.childElements)(container).find((child) => child.local === "sequenceFlow");
+    if (firstFlow)
+        env.edits.push({ span: { start: firstFlow.span.start, end: firstFlow.span.start }, replacement: `${xml}\n${indent}` });
+    else
+        env.edits.push((0, xml_js_1.appendChildEdit)(container, xml, env.text, env.unit));
+    const lane = laneFor(env, node);
+    if (lane)
+        env.edits.push((0, xml_js_1.appendChildEdit)(lane, `<${tag(env, "flowNodeRef")}>${(0, xml_js_1.escapeXml)(id)}</${tag(env, "flowNodeRef")}>`, env.text, env.unit));
+    const extra = node.type === "bpmn.subprocess" ? [["isExpanded", node.collapsed ? "false" : "true"]] : [];
+    appendToPlane(env, (planeIndent) => shapeXml(env, id, rectOf(env, id), extra, planeIndent));
+    return true;
+};
+const setColor = (env, id, fill, stroke) => {
+    const shape = env.parsed.shapes.get(id)?.element ?? env.parsed.diEdges.get(id)?.element;
+    if (!shape)
+        return;
+    if (fill !== undefined || stroke !== undefined)
+        ensureNamespace(env, "bioc", derive_js_1.BIOC_NS);
+    for (const [name, value] of [
+        ["bioc:fill", fill],
+        ["bioc:stroke", stroke],
+    ]) {
+        if (value === undefined)
+            continue;
+        const edit = (0, xml_js_1.setAttributeEdit)(shape, name, value, env.text);
+        if (edit)
+            env.edits.push(edit);
+    }
+};
+const rawColor = (value) => {
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return null;
+    if (typeof value === "object" && value && "raw" in value && typeof value.raw === "string")
+        return value.raw;
+    return undefined; // a token color has no XML form
+};
+const updateNode = (env, op) => {
+    const element = elementOf(env, op.id);
+    if (!element)
+        return false;
+    const changes = op.changes;
+    let handled = false;
+    if (changes.label !== undefined) {
+        const edit = (0, xml_js_1.setAttributeEdit)(element, "name", changes.label ?? null, env.text);
+        if (edit)
+            env.edits.push(edit);
+        handled = true;
+    }
+    if (changes.type !== undefined) {
+        const local = (0, types_js_1.bpmnElementForType)(changes.type);
+        if (local && local !== element.local && local !== "participant" && local !== "lane") {
+            env.edits.push(...(0, xml_js_1.renameElementEdits)(element, tag(env, local)));
+            handled = true;
+        }
+    }
+    const data = changes.data && typeof changes.data === "object" ? changes.data.bpmn : undefined;
+    if (data && typeof data === "object") {
+        const wantedDefinition = data.eventDefinition;
+        const current = (0, xml_js_1.childElements)(element).find((child) => (0, types_js_1.eventDefinitionFromElement)(child.local));
+        if ("eventDefinition" in data) {
+            if (!wantedDefinition && current)
+                removeElement(env, current);
+            else if (wantedDefinition && current && (0, types_js_1.eventDefinitionFromElement)(current.local) !== wantedDefinition)
+                env.edits.push(...(0, xml_js_1.renameElementEdits)(current, tag(env, (0, types_js_1.eventDefinitionElement)(wantedDefinition))));
+            else if (wantedDefinition && !current)
+                env.edits.push((0, xml_js_1.appendChildEdit)(element, `<${tag(env, (0, types_js_1.eventDefinitionElement)(wantedDefinition))} id="${freshId(env, `${op.id}_def`)}" />`, env.text, env.unit));
+        }
+        if ("attachedTo" in data) {
+            const edit = (0, xml_js_1.setAttributeEdit)(element, "attachedToRef", typeof data.attachedTo === "string" ? data.attachedTo : null, env.text);
+            if (edit)
+                env.edits.push(edit);
+        }
+        if ("cancelActivity" in data) {
+            const edit = (0, xml_js_1.setAttributeEdit)(element, "cancelActivity", data.cancelActivity === false ? "false" : null, env.text);
+            if (edit)
+                env.edits.push(edit);
+        }
+        if ("isExpanded" in data) {
+            const shape = env.parsed.shapes.get(op.id);
+            const edit = shape ? (0, xml_js_1.setAttributeEdit)(shape.element, "isExpanded", data.isExpanded ? "true" : "false", env.text) : null;
+            if (edit)
+                env.edits.push(edit);
+        }
+        handled = true;
+    }
+    if (changes.collapsed !== undefined && element.local === "subProcess") {
+        const shape = env.parsed.shapes.get(op.id);
+        const edit = shape ? (0, xml_js_1.setAttributeEdit)(shape.element, "isExpanded", changes.collapsed ? "false" : "true", env.text) : null;
+        if (edit)
+            env.edits.push(edit);
+        handled = true;
+    }
+    if (changes.style !== undefined) {
+        if (changes.style === null)
+            setColor(env, op.id, null, null);
+        else
+            setColor(env, op.id, rawColor(changes.style.fill), rawColor(changes.style.stroke));
+        handled = true;
+    }
+    return handled;
+};
+const moveNodes = (env, ids) => {
+    const touched = new Set();
+    for (const id of ids) {
+        touched.add(id);
+        for (const child of (0, geometry_js_1.descendantIds)(id, env.afterById.size ? [...env.afterById.values()] : []))
+            touched.add(child);
+    }
+    let handled = false;
+    for (const id of touched) {
+        if (!env.parsed.shapes.has(id))
+            continue;
+        setBounds(env, id, rectOf(env, id));
+        handled = true;
+    }
+    refreshIncidentEdges(env, touched);
+    return handled;
+};
+const flowElementFor = (env, edge) => {
+    const source = elementOf(env, edge.source);
+    const target = elementOf(env, edge.target);
+    if (!source || !target)
+        return null;
+    const message = (0, types_js_1.bpmnEdgeData)(edge.data)?.flow === "message" || source.local === "participant" || target.local === "participant" || ancestorProcess(source) !== ancestorProcess(target);
+    if (message) {
+        if (!env.parsed.collaboration) {
+            env.warnings.push(`Message flow "${edge.id}" needs pools (a collaboration); it was not written to the XML.`);
+            return null;
+        }
+        return { container: env.parsed.collaboration, kind: "messageFlow" };
+    }
+    // Deepest container both ends share.
+    const chain = (element) => {
+        const out = [];
+        let current = element.parent;
+        while (current) {
+            if (isProcessLike(current))
+                out.push(current);
+            current = current.parent;
+        }
+        return out;
+    };
+    const targetChain = new Set(chain(target));
+    const shared = chain(source).find((candidate) => targetChain.has(candidate));
+    return shared ? { container: shared, kind: "sequenceFlow" } : null;
+};
+const refChild = (env, nodeId, kind, flowId) => {
+    const element = elementOf(env, nodeId);
+    if (!element || element.local === "participant")
+        return;
+    env.edits.push((0, xml_js_1.appendChildEdit)(element, `<${tag(env, kind)}>${(0, xml_js_1.escapeXml)(flowId)}</${tag(env, kind)}>`, env.text, env.unit));
+};
+const addEdge = (env, id) => {
+    const edge = afterEdgesRef.get(id);
+    if (!edge || !edge.source || !edge.target)
+        return false;
+    if (elementOf(env, id))
+        return true;
+    const placement = flowElementFor(env, edge);
+    if (!placement)
+        return false;
+    const data = (0, types_js_1.bpmnEdgeData)(edge.data);
+    const indent = (0, xml_js_1.childIndentOf)(placement.container, env.text, env.unit);
+    const open = `<${tag(env, placement.kind)} id="${(0, xml_js_1.escapeXml)(id)}"${edge.label ? ` name="${(0, xml_js_1.escapeXml)(edge.label)}"` : ""} sourceRef="${(0, xml_js_1.escapeXml)(edge.source)}" targetRef="${(0, xml_js_1.escapeXml)(edge.target)}"`;
+    const xml = data?.conditionExpression
+        ? [`${open}>`, `${indent}${env.unit}<${tag(env, "conditionExpression")} xsi:type="${tag(env, "tFormalExpression")}">${(0, xml_js_1.escapeXml)(data.conditionExpression)}</${tag(env, "conditionExpression")}>`, `${indent}</${tag(env, placement.kind)}>`].join("\n")
+        : `${open} />`;
+    env.edits.push((0, xml_js_1.appendChildEdit)(placement.container, xml, env.text, env.unit));
+    if (placement.kind === "sequenceFlow") {
+        refChild(env, edge.source, "outgoing", id);
+        refChild(env, edge.target, "incoming", id);
+        if (data?.isDefault) {
+            const source = elementOf(env, edge.source);
+            const edit = source ? (0, xml_js_1.setAttributeEdit)(source, "default", id, env.text) : null;
+            if (edit)
+                env.edits.push(edit);
+        }
+    }
+    appendToPlane(env, (planeIndent) => edgeXml(env, id, waypointsFor(env, edge), planeIndent));
+    return true;
+};
+const updateEdge = (env, op) => {
+    const element = elementOf(env, op.id);
+    if (!element)
+        return false;
+    const after = afterEdgesRef.get(op.id);
+    const changes = op.changes;
+    let handled = false;
+    if (changes.label !== undefined) {
+        const edit = (0, xml_js_1.setAttributeEdit)(element, "name", changes.label ?? null, env.text);
+        if (edit)
+            env.edits.push(edit);
+        handled = true;
+    }
+    const previousSource = (0, xml_js_1.attr)(element, "sourceRef");
+    const previousTarget = (0, xml_js_1.attr)(element, "targetRef");
+    if (changes.source !== undefined && changes.source !== previousSource) {
+        const edit = (0, xml_js_1.setAttributeEdit)(element, "sourceRef", changes.source, env.text);
+        if (edit)
+            env.edits.push(edit);
+        for (const ref of (0, xml_js_1.findElements)(env.root, (candidate) => candidate.local === "outgoing" && (0, xml_js_1.textContent)(candidate).trim() === op.id))
+            removeElement(env, ref);
+        if (element.local === "sequenceFlow")
+            refChild(env, changes.source, "outgoing", op.id);
+        handled = true;
+    }
+    if (changes.target !== undefined && changes.target !== previousTarget) {
+        const edit = (0, xml_js_1.setAttributeEdit)(element, "targetRef", changes.target, env.text);
+        if (edit)
+            env.edits.push(edit);
+        for (const ref of (0, xml_js_1.findElements)(env.root, (candidate) => candidate.local === "incoming" && (0, xml_js_1.textContent)(candidate).trim() === op.id))
+            removeElement(env, ref);
+        if (element.local === "sequenceFlow")
+            refChild(env, changes.target, "incoming", op.id);
+        handled = true;
+    }
+    if ((changes.source !== undefined || changes.target !== undefined || changes.waypoints !== undefined) && after) {
+        setWaypoints(env, op.id, waypointsFor(env, after));
+        handled = true;
+    }
+    const data = changes.data && typeof changes.data === "object" ? changes.data.bpmn : undefined;
+    if (data && typeof data === "object") {
+        if ("conditionExpression" in data) {
+            const current = (0, xml_js_1.childElements)(element).find((child) => child.local === "conditionExpression");
+            const expression = typeof data.conditionExpression === "string" && data.conditionExpression.trim() ? data.conditionExpression : null;
+            if (!expression && current)
+                removeElement(env, current);
+            else if (expression && current)
+                env.edits.push({ span: current.span, replacement: `<${current.name} xsi:type="${tag(env, "tFormalExpression")}">${(0, xml_js_1.escapeXml)(expression)}</${current.name}>` });
+            else if (expression)
+                env.edits.push((0, xml_js_1.appendChildEdit)(element, `<${tag(env, "conditionExpression")} xsi:type="${tag(env, "tFormalExpression")}">${(0, xml_js_1.escapeXml)(expression)}</${tag(env, "conditionExpression")}>`, env.text, env.unit));
+        }
+        if ("isDefault" in data) {
+            const sourceId = changes.source ?? previousSource;
+            const source = sourceId ? elementOf(env, sourceId) : undefined;
+            if (source) {
+                const edit = (0, xml_js_1.setAttributeEdit)(source, "default", data.isDefault ? op.id : null, env.text);
+                if (edit)
+                    env.edits.push(edit);
+            }
+        }
+        handled = true;
+    }
+    if (changes.style !== undefined) {
+        setColor(env, op.id, undefined, changes.style === null ? null : rawColor(changes.style.stroke));
+        handled = true;
+    }
+    return handled;
+};
+const reparent = (env, op) => {
+    const element = elementOf(env, op.id);
+    const node = env.afterById.get(op.id);
+    if (!element || !node)
+        return false;
+    if (element.local === "participant")
+        return false;
+    const before = env.beforeById.get(op.id);
+    const previousParent = before?.parentId ? env.beforeById.get(before.parentId) : undefined;
+    // Lane membership.
+    for (const ref of (0, xml_js_1.findElements)(env.root, (candidate) => candidate.local === "flowNodeRef" && (0, xml_js_1.textContent)(candidate).trim() === op.id))
+        removeElement(env, ref);
+    const lane = laneFor(env, node);
+    if (lane)
+        env.edits.push((0, xml_js_1.appendChildEdit)(lane, `<${tag(env, "flowNodeRef")}>${(0, xml_js_1.escapeXml)(op.id)}</${tag(env, "flowNodeRef")}>`, env.text, env.unit));
+    // Container (process / subprocess) change: move the element's text.
+    const target = element.local === "lane" ? null : containerFor(env, node);
+    const current = nearestContainerElement(element);
+    if (target && current && target !== current) {
+        const xml = env.text.slice(element.span.start, element.span.end);
+        removeElement(env, element);
+        const firstFlow = (0, xml_js_1.childElements)(target).find((child) => child.local === "sequenceFlow");
+        const indent = (0, xml_js_1.childIndentOf)(target, env.text, env.unit);
+        const reindented = xml.replace(/\n[ \t]*/g, `\n${indent}`);
+        if (firstFlow)
+            env.edits.push({ span: { start: firstFlow.span.start, end: firstFlow.span.start }, replacement: `${reindented}\n${indent}` });
+        else
+            env.edits.push((0, xml_js_1.appendChildEdit)(target, reindented, env.text, env.unit));
+    }
+    void previousParent;
+    setBounds(env, op.id, rectOf(env, op.id));
+    for (const child of (0, geometry_js_1.descendantIds)(op.id, [...env.afterById.values()]))
+        setBounds(env, child, rectOf(env, child));
+    refreshIncidentEdges(env, new Set([op.id]));
+    return true;
+};
+const setTitle = (env, title) => {
+    const process = env.parsed.processes.length === 1 ? env.parsed.processes[0] : mainProcess(env);
+    if (!process || env.parsed.collaboration)
+        return false;
+    const edit = (0, xml_js_1.setAttributeEdit)(process, "name", title, env.text);
+    if (edit)
+        env.edits.push(edit);
+    return true;
+};
+const applyOne = (env, op) => {
+    switch (op.op) {
+        case "addNode":
+            return addNode(env, op.node.id);
+        case "updateNode":
+            return updateNode(env, op);
+        case "removeNode":
+            if (!elementOf(env, op.id))
+                return false;
+            removeNodeElement(env, op.id);
+            return true;
+        case "moveNodes":
+            return moveNodes(env, op.moves.map((move) => move.id));
+        case "resizeNode":
+            return moveNodes(env, [op.id]);
+        case "reparent":
+            return reparent(env, op);
+        case "addEdge":
+            return addEdge(env, op.edge.id);
+        case "updateEdge":
+            return updateEdge(env, op);
+        case "removeEdge":
+            if (!elementOf(env, op.id))
+                return false;
+            removeFlowElement(env, op.id);
+            return true;
+        case "setTitle":
+            return setTitle(env, op.title);
+        default:
+            return false;
+    }
+};
+const flatten = (ops, out) => {
+    for (const op of ops) {
+        if (op.op === "batch")
+            flatten(op.ops, out);
+        else
+            out.push(op);
+    }
+};
+const patchBpmnSource = (text, ops, context) => {
+    const flat = [];
+    flatten(ops, flat);
+    const unmapped = [];
+    const warnings = [];
+    const afterById = (0, geometry_js_1.indexNodes)(context.after.nodes);
+    const afterRects = (0, geometry_js_1.absoluteRects)(context.after);
+    const beforeById = (0, geometry_js_1.indexNodes)(context.before.nodes);
+    afterEdgesRef = new Map(context.after.edges.map((edge) => [edge.id, edge]));
+    let current = text;
+    let changed = false;
+    for (const op of flat) {
+        const parsed = (0, derive_js_1.parseBpmn)(current);
+        const root = parsed.definitions;
+        if (!parsed.ok || !root) {
+            unmapped.push(op);
+            continue;
+        }
+        const bp = (0, xml_js_1.prefixForNamespace)(root, derive_js_1.BPMN_NS) ?? (root.prefix || null);
+        const env = {
+            parsed,
+            text: current,
+            root,
+            unit: (0, xml_js_1.indentUnit)(root, current),
+            bp,
+            di: (0, xml_js_1.prefixForNamespace)(root, derive_js_1.BPMNDI_NS) ?? "bpmndi",
+            dc: (0, xml_js_1.prefixForNamespace)(root, derive_js_1.DC_NS) ?? "dc",
+            dd: (0, xml_js_1.prefixForNamespace)(root, derive_js_1.DI_NS) ?? "di",
+            bioc: (0, xml_js_1.prefixForNamespace)(root, derive_js_1.BIOC_NS),
+            afterById,
+            afterRects,
+            beforeById,
+            warnings,
+            edits: [],
+            removed: new Set(),
+        };
+        if ((0, xml_js_1.prefixForNamespace)(root, derive_js_1.BPMNDI_NS) === null)
+            ensureNamespace(env, "bpmndi", derive_js_1.BPMNDI_NS);
+        if ((0, xml_js_1.prefixForNamespace)(root, derive_js_1.DC_NS) === null)
+            ensureNamespace(env, "dc", derive_js_1.DC_NS);
+        if ((0, xml_js_1.prefixForNamespace)(root, derive_js_1.DI_NS) === null)
+            ensureNamespace(env, "di", derive_js_1.DI_NS);
+        const handled = applyOne(env, op);
+        if (!handled) {
+            unmapped.push(op);
+            continue;
+        }
+        if (env.edits.length > 0) {
+            current = (0, xml_js_1.applyEdits)(current, env.edits);
+            changed = true;
+        }
+    }
+    return { text: current, unmapped, changed, warnings };
+};
+exports.patchBpmnSource = patchBpmnSource;
+//# sourceMappingURL=patch.js.map