callman-core 1.28.1 → 1.29.0

package/dist/diagram/ops.js

@@ -0,0 +1,823 @@
+// Diagram OPERATIONS — the one way a document changes.
+//
+// Every edit, whether it comes from the canvas, an AI reply, an MCP tool, a
+// Mermaid text edit or an import, is expressed as a list of `DiagramOp`s and
+// applied by `applyDiagramOps`. The function is pure and deterministic (ids
+// are supplied by the caller, no clock unless `now` is passed), atomic (an
+// error leaves the input untouched) and returns the INVERSE ops, so undo/redo
+// is a property of the model rather than of any editor. Untouched node/edge
+// objects keep their identity (structural sharing) so renderers can memoise.
+//
+// Vocabulary (16 ops). Canonical, stored-shape ops — the compact authoring
+// vocabulary models write (`parent`, `semantic`, CSS colors…) is lowered onto
+// these by patchInput.ts.
+import { absolutePosition, descendantIds, indexNodes, isDescendantOf, toParentRelative, } from "./geometry.js";
+import { mermaidSourceHash } from "./mermaid/index.js";
+import { parseMermaid, syncOpsFromStructure } from "./mermaid/derive.js";
+import { patchMermaidSource } from "./mermaid/patch.js";
+import { parseBpmn, syncOpsFromBpmn } from "./bpmn/derive.js";
+import { patchBpmnSource } from "./bpmn/patch.js";
+import { sortPreOrder } from "./normalize.js";
+export class DiagramOpError extends Error {
+    code;
+    data;
+    opIndex;
+    constructor(code, message, opIndex = -1, data) {
+        super(message);
+        this.name = "DiagramOpError";
+        this.code = code;
+        this.opIndex = opIndex;
+        this.data = data;
+    }
+}
+const MISSING_CODES = new Set([
+    "DIAGRAM_NODE_NOT_FOUND",
+    "DIAGRAM_EDGE_NOT_FOUND",
+    "DIAGRAM_PARENT_NOT_FOUND",
+    "DIAGRAM_EDGE_ENDPOINT_NOT_FOUND",
+    "DIAGRAM_NODE_LOCKED",
+]);
+// --- helpers ------------------------------------------------------------------
+const compact = (value) => {
+    const out = {};
+    for (const [key, entry] of Object.entries(value))
+        if (entry !== undefined)
+            out[key] = entry;
+    return out;
+};
+const isLegacyPinned = (edge) => Boolean(edge.sourceAnchor || edge.targetAnchor) && edge.routing === "straight";
+const sameStyleValue = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+// Apply a StyleChanges merge and return [next, inverse].
+const mergeStyle = (base, changes) => {
+    if (changes === null) {
+        return { next: undefined, inverse: base ? { ...base } : null };
+    }
+    const next = { ...(base ?? {}) };
+    const inverse = {};
+    for (const [key, value] of Object.entries(changes)) {
+        if (value === undefined)
+            continue;
+        const prior = base?.[key];
+        inverse[key] = prior === undefined ? null : prior;
+        if (value === null)
+            delete next[key];
+        else
+            next[key] = value;
+    }
+    return {
+        next: Object.keys(next).length > 0 ? next : undefined,
+        inverse: inverse,
+    };
+};
+const mergeData = (base, changes) => {
+    if (changes === null) {
+        return { next: undefined, inverse: base ? { ...base } : null };
+    }
+    const next = { ...(base ?? {}) };
+    const inverse = {};
+    for (const [key, value] of Object.entries(changes)) {
+        if (value === undefined)
+            continue;
+        const prior = base?.[key];
+        inverse[key] = prior === undefined ? null : prior;
+        if (value === null)
+            delete next[key];
+        else
+            next[key] = value;
+    }
+    return { next: Object.keys(next).length > 0 ? next : undefined, inverse };
+};
+// Set-or-delete an optional field; returns the prior value for the inverse
+// (`null` when it was absent).
+const assign = (target, key, value) => {
+    const prior = target[key];
+    if (value === undefined)
+        return prior === undefined ? null : prior;
+    if (value === null)
+        delete target[key];
+    else
+        target[key] = value;
+    return prior === undefined ? null : prior;
+};
+// --- working state --------------------------------------------------------------
+class WorkingDoc {
+    nodes;
+    edges;
+    title;
+    canvas;
+    source;
+    changedNodes = new Set();
+    changedEdges = new Set();
+    addedNodes = [];
+    addedEdges = [];
+    removedNodes = [];
+    removedEdges = [];
+    rerouted = new Set();
+    warnings = [];
+    index = null;
+    edgeIndex = null;
+    constructor(doc) {
+        this.nodes = doc.nodes.slice();
+        this.edges = doc.edges.slice();
+        this.title = doc.meta.title;
+        this.canvas = doc.canvas;
+        this.source = doc.source;
+    }
+    byId() {
+        this.index ??= indexNodes(this.nodes);
+        return this.index;
+    }
+    edgesById() {
+        this.edgeIndex ??= new Map(this.edges.map((edge) => [edge.id, edge]));
+        return this.edgeIndex;
+    }
+    node(id) {
+        return this.byId().get(id);
+    }
+    edge(id) {
+        return this.edgesById().get(id);
+    }
+    invalidate() {
+        this.index = null;
+        this.edgeIndex = null;
+    }
+    setNode(next) {
+        const at = this.nodes.findIndex((node) => node.id === next.id);
+        if (at < 0)
+            throw new Error(`setNode: ${next.id} missing`);
+        this.nodes[at] = next;
+        this.changedNodes.add(next.id);
+        this.invalidate();
+    }
+    setEdge(next) {
+        const at = this.edges.findIndex((edge) => edge.id === next.id);
+        if (at < 0)
+            throw new Error(`setEdge: ${next.id} missing`);
+        this.edges[at] = next;
+        this.changedEdges.add(next.id);
+        this.invalidate();
+    }
+    siblings(parentId) {
+        return this.nodes.filter((node) => (node.parentId ?? undefined) === parentId);
+    }
+    siblingIndex(id) {
+        const node = this.node(id);
+        if (!node)
+            return -1;
+        return this.siblings(node.parentId).findIndex((sibling) => sibling.id === id);
+    }
+    // Insert `node` so that it sits at `index` among its siblings (array
+    // position = right after the previous sibling's subtree, or after the parent
+    // for index 0, or at the end for the root level).
+    insertNode(node, index) {
+        const siblings = this.siblings(node.parentId);
+        const at = index === undefined ? siblings.length : Math.max(0, Math.min(index, siblings.length));
+        let arrayPos;
+        if (at === 0) {
+            if (node.parentId) {
+                arrayPos = this.nodes.findIndex((candidate) => candidate.id === node.parentId) + 1;
+            }
+            else {
+                arrayPos = 0;
+            }
+        }
+        else {
+            const previous = siblings[at - 1];
+            const subtree = descendantIds(previous.id, this.nodes);
+            const lastId = subtree.length > 0 ? subtree[subtree.length - 1] : previous.id;
+            arrayPos = this.nodes.findIndex((candidate) => candidate.id === lastId) + 1;
+        }
+        this.nodes.splice(arrayPos, 0, node);
+        this.invalidate();
+    }
+    // Remove a node (and only that node) from the array.
+    detachNode(id) {
+        const at = this.nodes.findIndex((node) => node.id === id);
+        if (at < 0)
+            return undefined;
+        const [removed] = this.nodes.splice(at, 1);
+        this.invalidate();
+        return removed;
+    }
+    // Move a subtree so its root sits at `index` among the siblings of `parentId`.
+    placeSubtree(id, parentId, index) {
+        const subtreeIds = [id, ...descendantIds(id, this.nodes)];
+        const subtree = subtreeIds.map((subtreeId) => this.node(subtreeId));
+        this.nodes = this.nodes.filter((node) => !subtreeIds.includes(node.id));
+        this.invalidate();
+        const root = { ...subtree[0], ...(parentId ? { parentId } : {}) };
+        if (!parentId)
+            delete root.parentId;
+        this.insertNode(root, index);
+        const rootPos = this.nodes.findIndex((node) => node.id === id);
+        this.nodes.splice(rootPos + 1, 0, ...subtree.slice(1));
+        this.invalidate();
+    }
+}
+// --- the apply --------------------------------------------------------------------
+export const applyDiagramOps = (doc, ops, options = {}) => {
+    const onMissing = options.onMissing ?? "error";
+    const work = new WorkingDoc(doc);
+    const inverse = [];
+    const skipped = [];
+    let replaced = null;
+    const fail = (code, message, index, data) => {
+        throw new DiagramOpError(code, message, index, data);
+    };
+    // Clears a legacy pinned route / manual bends and records the inverse.
+    const clearRoute = (edge, mode) => {
+        const pinned = isLegacyPinned(edge);
+        const clearWaypoints = mode === "all" || pinned;
+        if (!pinned && !(clearWaypoints && edge.waypoints))
+            return edge;
+        const next = { ...edge };
+        const restore = {};
+        if (pinned) {
+            restore.sourceAnchor = edge.sourceAnchor ?? null;
+            restore.targetAnchor = edge.targetAnchor ?? null;
+            restore.routing = edge.routing ?? null;
+            delete next.sourceAnchor;
+            delete next.targetAnchor;
+            delete next.routing;
+        }
+        if (clearWaypoints && edge.waypoints) {
+            restore.waypoints = edge.waypoints;
+            delete next.waypoints;
+        }
+        inverse.push({ op: "updateEdge", id: edge.id, changes: restore });
+        work.rerouted.add(edge.id);
+        return next;
+    };
+    // After a subtree moved by `delta` (absolute), fix the edges: bends inside
+    // travel, pinned routes touching it are cleared, bends leaving it are kept
+    // or cleared per option.
+    const settleEdgesAfterMove = (subtree, delta) => {
+        for (const edge of work.edges) {
+            const sourceIn = Boolean(edge.source && subtree.has(edge.source));
+            const targetIn = Boolean(edge.target && subtree.has(edge.target));
+            if (!sourceIn && !targetIn)
+                continue;
+            let next = edge;
+            if (sourceIn && targetIn) {
+                if (edge.waypoints && (delta.x !== 0 || delta.y !== 0)) {
+                    inverse.push({ op: "updateEdge", id: edge.id, changes: { waypoints: edge.waypoints } });
+                    next = { ...edge, waypoints: edge.waypoints.map((p) => ({ x: p.x + delta.x, y: p.y + delta.y })) };
+                }
+            }
+            else {
+                next = clearRoute(edge, options.moveClearsWaypoints ? "all" : "pinned");
+            }
+            if (next !== edge)
+                work.setEdge(next);
+        }
+    };
+    const applyNodeChanges = (index, id, changes) => {
+        const node = work.node(id);
+        if (!node)
+            return fail("DIAGRAM_NODE_NOT_FOUND", `Node "${id}" does not exist.`, index);
+        const next = { ...node };
+        const restore = {};
+        if (changes.type !== undefined) {
+            restore.type = node.type;
+            next.type = changes.type;
+        }
+        if (changes.label !== undefined)
+            restore.label = assign(next, "label", changes.label === "" ? null : changes.label);
+        if (changes.rotation !== undefined)
+            restore.rotation = assign(next, "rotation", changes.rotation === 0 ? null : changes.rotation);
+        if (changes.locked !== undefined)
+            restore.locked = assign(next, "locked", changes.locked ? true : null);
+        if (changes.hidden !== undefined)
+            restore.hidden = assign(next, "hidden", changes.hidden ? true : null);
+        if (changes.collapsed !== undefined)
+            restore.collapsed = assign(next, "collapsed", changes.collapsed ? true : null);
+        if (changes.collapsedSize !== undefined)
+            restore.collapsedSize = assign(next, "collapsedSize", changes.collapsedSize);
+        if (changes.style !== undefined) {
+            const merged = mergeStyle(node.style, changes.style);
+            restore.style = merged.inverse;
+            if (merged.next)
+                next.style = merged.next;
+            else
+                delete next.style;
+        }
+        if (changes.data !== undefined) {
+            const merged = mergeData(node.data, changes.data);
+            restore.data = merged.inverse;
+            if (merged.next)
+                next.data = merged.next;
+            else
+                delete next.data;
+        }
+        if (Object.keys(restore).length === 0)
+            return;
+        inverse.push({ op: "updateNode", id, changes: restore });
+        work.setNode(compact(next));
+    };
+    const applyEdgeChanges = (index, id, changes) => {
+        const edge = work.edge(id);
+        if (!edge)
+            return fail("DIAGRAM_EDGE_NOT_FOUND", `Edge "${id}" does not exist.`, index);
+        let next = { ...edge };
+        const restore = {};
+        let endpointChanged = false;
+        for (const end of ["source", "target"]) {
+            const value = changes[end];
+            if (value === undefined)
+                continue;
+            if (!work.node(value))
+                return fail("DIAGRAM_EDGE_ENDPOINT_NOT_FOUND", `Edge endpoint "${value}" does not exist.`, index);
+            if (value !== edge[end]) {
+                restore[end] = edge[end];
+                next[end] = value;
+                endpointChanged = true;
+            }
+        }
+        if (changes.sourcePoint !== undefined)
+            restore.sourcePoint = assign(next, "sourcePoint", changes.sourcePoint);
+        if (changes.targetPoint !== undefined)
+            restore.targetPoint = assign(next, "targetPoint", changes.targetPoint);
+        if (changes.sourceHandle !== undefined)
+            restore.sourceHandle = assign(next, "sourceHandle", changes.sourceHandle);
+        if (changes.targetHandle !== undefined)
+            restore.targetHandle = assign(next, "targetHandle", changes.targetHandle);
+        if (changes.label !== undefined)
+            restore.label = assign(next, "label", changes.label === "" ? null : changes.label);
+        if (changes.labelPosition !== undefined)
+            restore.labelPosition = assign(next, "labelPosition", changes.labelPosition);
+        if (changes.labelOffset !== undefined)
+            restore.labelOffset = assign(next, "labelOffset", changes.labelOffset);
+        if (changes.routing !== undefined)
+            restore.routing = assign(next, "routing", changes.routing);
+        if (changes.waypoints !== undefined)
+            restore.waypoints = assign(next, "waypoints", changes.waypoints && changes.waypoints.length > 0 ? changes.waypoints : null);
+        if (changes.markerStart !== undefined)
+            restore.markerStart = assign(next, "markerStart", changes.markerStart === "none" ? null : changes.markerStart);
+        if (changes.markerEnd !== undefined)
+            restore.markerEnd = assign(next, "markerEnd", changes.markerEnd);
+        if (changes.sourceAnchor !== undefined)
+            restore.sourceAnchor = assign(next, "sourceAnchor", changes.sourceAnchor);
+        if (changes.targetAnchor !== undefined)
+            restore.targetAnchor = assign(next, "targetAnchor", changes.targetAnchor);
+        if (changes.data !== undefined) {
+            const merged = mergeData(edge.data, changes.data);
+            restore.data = merged.inverse;
+            if (merged.next)
+                next.data = merged.next;
+            else
+                delete next.data;
+        }
+        if (changes.style !== undefined) {
+            const merged = mergeStyle(edge.style, changes.style);
+            restore.style = merged.inverse;
+            if (merged.next)
+                next.style = merged.next;
+            else
+                delete next.style;
+        }
+        if (Object.keys(restore).length === 0)
+            return;
+        if (endpointChanged) {
+            // Re-pointing an end invalidates the saved route. Its restore is pushed
+            // BEFORE the field restore so that, reversed for undo, the endpoints go
+            // back first (a no-op clear on an already-clear edge) and the route last.
+            const cleared = clearRoute(edge, "all");
+            next = { ...next };
+            for (const key of ["sourceAnchor", "targetAnchor", "routing", "waypoints"]) {
+                // Keep whatever the caller set explicitly in the same op.
+                if (!(key in cleared) && changes[key] === undefined)
+                    delete next[key];
+            }
+        }
+        inverse.push({ op: "updateEdge", id, changes: restore });
+        work.setEdge(compact(next));
+    };
+    const removeEdgeAt = (id) => {
+        const at = work.edges.findIndex((edge) => edge.id === id);
+        if (at < 0)
+            return;
+        const [edge] = work.edges.splice(at, 1);
+        work.invalidate();
+        work.removedEdges.push(id);
+        inverse.push({ op: "addEdge", edge, index: at });
+    };
+    const run = (op, index) => {
+        switch (op.op) {
+            case "setTitle": {
+                const title = op.title.trim();
+                if (!title)
+                    return fail("DIAGRAM_INVALID_OP", "setTitle: title must not be empty", index);
+                if (title === work.title)
+                    return;
+                inverse.push({ op: "setTitle", title: work.title });
+                work.title = title;
+                return;
+            }
+            case "addNode": {
+                const node = compact({ ...op.node });
+                if (!node.id)
+                    return fail("DIAGRAM_INVALID_OP", "addNode: node.id is required", index);
+                if (work.node(node.id) || work.edge(node.id))
+                    return fail("DIAGRAM_DUPLICATE_NODE_ID", `A node with id "${node.id}" already exists.`, index);
+                if (node.parentId && !work.node(node.parentId))
+                    return fail("DIAGRAM_PARENT_NOT_FOUND", `Parent "${node.parentId}" does not exist.`, index);
+                work.insertNode(node, op.index);
+                work.addedNodes.push(node.id);
+                inverse.push({ op: "removeNode", id: node.id, children: "delete" });
+                return;
+            }
+            case "updateNode":
+                return applyNodeChanges(index, op.id, op.changes);
+            case "removeNode": {
+                const node = work.node(op.id);
+                if (!node)
+                    return fail("DIAGRAM_NODE_NOT_FOUND", `Node "${op.id}" does not exist.`, index);
+                const mode = op.children ?? "lift";
+                const byId = work.byId();
+                const subtree = new Set([op.id, ...(mode === "delete" ? descendantIds(op.id, work.nodes) : [])]);
+                // Edges touching anything removed go first (their inverses run last).
+                for (const edge of work.edges.slice()) {
+                    if ((edge.source && subtree.has(edge.source)) || (edge.target && subtree.has(edge.target)))
+                        removeEdgeAt(edge.id);
+                }
+                // Lift direct children to the removed node's parent, keeping their
+                // absolute position.
+                if (mode === "lift") {
+                    for (const child of work.siblings(op.id)) {
+                        const childIndex = work.siblingIndex(child.id);
+                        const childAbs = absolutePosition(child, byId);
+                        const lifted = { ...child, position: toParentRelative(childAbs, node.parentId, byId) };
+                        if (node.parentId)
+                            lifted.parentId = node.parentId;
+                        else
+                            delete lifted.parentId;
+                        inverse.push({ op: "reparent", id: child.id, parentId: op.id, position: child.position, index: childIndex });
+                        work.setNode(lifted);
+                    }
+                }
+                const removedInOrder = work.nodes.filter((candidate) => subtree.has(candidate.id));
+                for (const candidate of removedInOrder.slice().reverse()) {
+                    const siblingIndex = work.siblingIndex(candidate.id);
+                    work.detachNode(candidate.id);
+                    work.removedNodes.push(candidate.id);
+                    // Re-added in forward order: parents before children.
+                    inverse.push({ op: "addNode", node: candidate, index: siblingIndex });
+                }
+                return;
+            }
+            case "addEdge": {
+                const edge = compact({ ...op.edge });
+                if (!edge.id)
+                    return fail("DIAGRAM_INVALID_OP", "addEdge: edge.id is required", index);
+                if (work.edge(edge.id) || work.node(edge.id))
+                    return fail("DIAGRAM_DUPLICATE_EDGE_ID", `An edge with id "${edge.id}" already exists.`, index);
+                for (const end of ["source", "target"]) {
+                    const value = edge[end];
+                    if (value === undefined) {
+                        if (!edge[end === "source" ? "sourcePoint" : "targetPoint"])
+                            return fail("DIAGRAM_INVALID_OP", `addEdge: ${end} is required`, index);
+                        continue;
+                    }
+                    if (!work.node(value))
+                        return fail("DIAGRAM_EDGE_ENDPOINT_NOT_FOUND", `Edge endpoint "${value}" does not exist.`, index);
+                }
+                const at = op.index === undefined ? work.edges.length : Math.max(0, Math.min(op.index, work.edges.length));
+                work.edges.splice(at, 0, edge);
+                work.invalidate();
+                work.addedEdges.push(edge.id);
+                inverse.push({ op: "removeEdge", id: edge.id });
+                return;
+            }
+            case "updateEdge":
+                return applyEdgeChanges(index, op.id, op.changes);
+            case "removeEdge": {
+                if (!work.edge(op.id))
+                    return fail("DIAGRAM_EDGE_NOT_FOUND", `Edge "${op.id}" does not exist.`, index);
+                removeEdgeAt(op.id);
+                return;
+            }
+            case "moveNodes": {
+                const restore = [];
+                for (const move of op.moves) {
+                    const node = work.node(move.id);
+                    if (!node)
+                        return fail("DIAGRAM_NODE_NOT_FOUND", `Node "${move.id}" does not exist.`, index);
+                    if (node.locked)
+                        return fail("DIAGRAM_NODE_LOCKED", `Node "${move.id}" is locked.`, index);
+                    if (node.position.x === move.position.x && node.position.y === move.position.y)
+                        continue;
+                    const delta = { x: move.position.x - node.position.x, y: move.position.y - node.position.y };
+                    restore.push({ id: move.id, position: node.position });
+                    work.setNode({ ...node, position: move.position });
+                    settleEdgesAfterMove(new Set([move.id, ...descendantIds(move.id, work.nodes)]), delta);
+                }
+                if (restore.length > 0)
+                    inverse.push({ op: "moveNodes", moves: restore });
+                return;
+            }
+            case "resizeNode": {
+                const node = work.node(op.id);
+                if (!node)
+                    return fail("DIAGRAM_NODE_NOT_FOUND", `Node "${op.id}" does not exist.`, index);
+                if (node.locked)
+                    return fail("DIAGRAM_NODE_LOCKED", `Node "${op.id}" is locked.`, index);
+                if (!(op.size.width > 0 && op.size.height > 0))
+                    return fail("DIAGRAM_INVALID_OP", "resizeNode: size must be positive", index);
+                const sameSize = node.size.width === op.size.width && node.size.height === op.size.height;
+                const samePos = !op.position || (op.position.x === node.position.x && op.position.y === node.position.y);
+                if (sameSize && samePos)
+                    return;
+                const next = { ...node, size: op.size, ...(op.position ? { position: op.position } : {}) };
+                if (node.collapsed && node.collapsedSize) {
+                    // Resizing a folded container sets its FOLDED size.
+                    next.size = node.size;
+                    next.collapsedSize = op.size;
+                }
+                work.setNode(next);
+                if (op.position) {
+                    // Children stay put on the canvas: shift them by the opposite delta.
+                    const delta = { x: op.position.x - node.position.x, y: op.position.y - node.position.y };
+                    for (const child of work.siblings(op.id)) {
+                        inverse.push({ op: "moveNodes", moves: [{ id: child.id, position: child.position }] });
+                        work.setNode({ ...child, position: { x: child.position.x - delta.x, y: child.position.y - delta.y } });
+                    }
+                }
+                // Edges into a resized node: pinned routes are stale.
+                for (const edge of work.edges) {
+                    if (edge.source === op.id || edge.target === op.id) {
+                        const next2 = clearRoute(edge, "pinned");
+                        if (next2 !== edge)
+                            work.setEdge(next2);
+                    }
+                }
+                // Primary inverse LAST: reversed for undo it runs first, when the edges
+                // are still clear (no double-clearing), and the route restores follow.
+                if (node.collapsed && node.collapsedSize) {
+                    inverse.push({ op: "updateNode", id: op.id, changes: { collapsedSize: node.collapsedSize } });
+                    if (op.position)
+                        inverse.push({ op: "moveNodes", moves: [{ id: op.id, position: node.position }] });
+                }
+                else {
+                    inverse.push({ op: "resizeNode", id: op.id, size: node.size, position: op.position ? node.position : undefined });
+                }
+                return;
+            }
+            case "reparent": {
+                const node = work.node(op.id);
+                if (!node)
+                    return fail("DIAGRAM_NODE_NOT_FOUND", `Node "${op.id}" does not exist.`, index);
+                if (node.locked)
+                    return fail("DIAGRAM_NODE_LOCKED", `Node "${op.id}" is locked.`, index);
+                const parentId = op.parentId ?? undefined;
+                if (parentId) {
+                    if (parentId === op.id)
+                        return fail("DIAGRAM_PARENT_CYCLE", `Node "${op.id}" cannot contain itself.`, index);
+                    if (!work.node(parentId))
+                        return fail("DIAGRAM_PARENT_NOT_FOUND", `Parent "${parentId}" does not exist.`, index);
+                    if (isDescendantOf(parentId, op.id, work.byId()))
+                        return fail("DIAGRAM_PARENT_CYCLE", `Node "${op.id}" cannot be moved into its own descendant "${parentId}".`, index);
+                }
+                const before = absolutePosition(node, work.byId());
+                const priorIndex = work.siblingIndex(op.id);
+                work.placeSubtree(op.id, parentId, op.index);
+                const placed = work.node(op.id);
+                work.setNode({ ...placed, position: op.position });
+                const after = absolutePosition(work.node(op.id), work.byId());
+                settleEdgesAfterMove(new Set([op.id, ...descendantIds(op.id, work.nodes)]), { x: after.x - before.x, y: after.y - before.y });
+                // Primary inverse last (see resizeNode).
+                inverse.push({ op: "reparent", id: op.id, parentId: node.parentId ?? null, position: node.position, index: priorIndex });
+                return;
+            }
+            case "reorder": {
+                if (op.kind === "edge") {
+                    const at = work.edges.findIndex((edge) => edge.id === op.id);
+                    if (at < 0)
+                        return fail("DIAGRAM_EDGE_NOT_FOUND", `Edge "${op.id}" does not exist.`, index);
+                    const target = Math.max(0, Math.min(op.index, work.edges.length - 1));
+                    if (target === at)
+                        return;
+                    const [edge] = work.edges.splice(at, 1);
+                    work.edges.splice(target, 0, edge);
+                    work.invalidate();
+                    work.changedEdges.add(op.id);
+                    inverse.push({ op: "reorder", kind: "edge", id: op.id, index: at });
+                    return;
+                }
+                const node = work.node(op.id);
+                if (!node)
+                    return fail("DIAGRAM_NODE_NOT_FOUND", `Node "${op.id}" does not exist.`, index);
+                const priorIndex = work.siblingIndex(op.id);
+                const siblingCount = work.siblings(node.parentId).length;
+                const target = Math.max(0, Math.min(op.index, siblingCount - 1));
+                if (target === priorIndex)
+                    return;
+                // placeSubtree removes the subtree first, so `target` is already the
+                // index among the remaining siblings.
+                work.placeSubtree(op.id, node.parentId, target);
+                work.changedNodes.add(op.id);
+                inverse.push({ op: "reorder", kind: "node", id: op.id, index: priorIndex });
+                return;
+            }
+            case "setCanvas": {
+                const next = { ...(work.canvas ?? {}) };
+                const restore = {};
+                for (const [key, value] of Object.entries(op.changes)) {
+                    if (value === undefined)
+                        continue;
+                    const prior = next[key];
+                    if (sameStyleValue(prior, value === null ? undefined : value))
+                        continue;
+                    restore[key] = prior === undefined ? null : prior;
+                    if (value === null)
+                        delete next[key];
+                    else
+                        next[key] = value;
+                }
+                if (Object.keys(restore).length === 0)
+                    return;
+                inverse.push({ op: "setCanvas", changes: restore });
+                work.canvas = next;
+                return;
+            }
+            case "setViewport": {
+                const prior = work.canvas?.viewport;
+                if (prior && prior.x === op.viewport.x && prior.y === op.viewport.y && prior.zoom === op.viewport.zoom)
+                    return;
+                inverse.push(prior ? { op: "setViewport", viewport: prior } : { op: "setCanvas", changes: { viewport: null } });
+                work.canvas = { ...(work.canvas ?? {}), viewport: op.viewport };
+                return;
+            }
+            case "replaceDocument": {
+                // Restore point = the working state right before the replacement.
+                inverse.push({
+                    op: "replaceDocument",
+                    document: compact({
+                        ...(replaced ?? doc),
+                        meta: { ...(replaced ?? doc).meta, title: work.title },
+                        canvas: work.canvas,
+                        nodes: sortPreOrder(work.nodes),
+                        edges: work.edges.slice(),
+                        source: work.source,
+                    }),
+                });
+                replaced = op.document;
+                const fresh = new WorkingDoc(op.document);
+                work.nodes = fresh.nodes;
+                work.edges = fresh.edges;
+                work.title = fresh.title;
+                work.canvas = fresh.canvas;
+                work.source = fresh.source;
+                work.invalidate();
+                for (const node of work.nodes)
+                    work.changedNodes.add(node.id);
+                for (const edge of work.edges)
+                    work.changedEdges.add(edge.id);
+                return;
+            }
+            case "setSource": {
+                const prior = work.source;
+                if (sameStyleValue(prior, op.source ?? undefined))
+                    return;
+                const next = op.source ? { ...op.source } : undefined;
+                if (next && next.format === "bpmn" && op.resync !== false && next.text !== prior?.text) {
+                    // The XML is the structure AND geometry truth: derive the model from it.
+                    const parsed = parseBpmn(next.text);
+                    next.hash = mermaidSourceHash(next.text);
+                    next.diagramType = "bpmn";
+                    next.valid = parsed.ok;
+                    if (parsed.ok) {
+                        const sync = syncOpsFromBpmn(snapshotDoc(), parsed.structure);
+                        for (const syncOp of sync.ops)
+                            run(syncOp, index);
+                    }
+                }
+                if (next && next.format === "mermaid" && op.resync !== false && next.text !== prior?.text) {
+                    // The text is the structure truth: parse it and bring the nodes/edges
+                    // in line. A text that does not parse is kept (the user is mid-edit)
+                    // and flagged; the structure stays what it was.
+                    const parsed = parseMermaid(next.text);
+                    next.hash = mermaidSourceHash(next.text);
+                    if (parsed.ok) {
+                        next.valid = true;
+                        next.diagramType = parsed.cst.diagramType ?? next.diagramType;
+                        const snapshot = snapshotDoc();
+                        const sync = syncOpsFromStructure(snapshot, parsed.structure);
+                        for (const syncOp of sync.ops)
+                            run(syncOp, index);
+                    }
+                    else {
+                        next.valid = false;
+                        if (parsed.cst.diagramType && parsed.cst.diagramType !== "flowchart")
+                            next.diagramType = parsed.cst.diagramType;
+                    }
+                }
+                work.source = next;
+                // Primary inverse last: reversed for undo it runs first and restores
+                // the text verbatim (no resync), then the structural inverses follow.
+                inverse.push({ op: "setSource", source: prior ?? null, resync: false });
+                return;
+            }
+            case "batch": {
+                const mark = inverse.length;
+                for (const inner of op.ops)
+                    run(inner, index);
+                const innerInverse = inverse.splice(mark).reverse();
+                inverse.push({ op: "batch", ops: innerInverse, label: op.label });
+                return;
+            }
+            default:
+                return fail("DIAGRAM_INVALID_OP", `Unknown op "${op.op}"`, index);
+        }
+    };
+    const snapshotDoc = () => compact({
+        ...(replaced ?? doc),
+        meta: { ...(replaced ?? doc).meta, title: work.title },
+        canvas: work.canvas,
+        nodes: sortPreOrder(work.nodes),
+        edges: work.edges.slice(),
+        source: work.source,
+    });
+    ops.forEach((op, index) => {
+        try {
+            run(op, index);
+        }
+        catch (error) {
+            if (onMissing === "skip" && error instanceof DiagramOpError && MISSING_CODES.has(error.code)) {
+                skipped.push({ index, code: error.code, message: error.message });
+                return;
+            }
+            throw error;
+        }
+    });
+    // Source-backed document: mirror the structural changes onto the text as
+    // minimal edits. Skipped when this batch itself set the source (a text edit
+    // or an undo restoring one) — the text is then already the truth.
+    let sourceUnmapped = [];
+    const touchesSource = (list) => list.some((op) => op.op === "setSource" || op.op === "replaceDocument" || (op.op === "batch" && touchesSource(op.ops)));
+    if (work.source?.format === "mermaid" && !touchesSource(ops) && skipped.length < ops.length) {
+        const prior = work.source;
+        const patched = patchMermaidSource(prior.text, ops, { before: doc, after: snapshotDoc() });
+        sourceUnmapped = patched.unmapped;
+        if (patched.changed) {
+            work.source = { ...prior, text: patched.text, hash: mermaidSourceHash(patched.text), valid: true };
+            // Pushed last → first on undo: the text goes back verbatim before the
+            // structural inverses run (which then skip patching, see above).
+            inverse.push({ op: "setSource", source: prior, resync: false });
+        }
+    }
+    if (work.source?.format === "bpmn" && !touchesSource(ops) && skipped.length < ops.length) {
+        const prior = work.source;
+        const patched = patchBpmnSource(prior.text, ops, { before: doc, after: snapshotDoc() });
+        sourceUnmapped = patched.unmapped;
+        for (const warning of patched.warnings)
+            work.warnings.push(warning);
+        if (patched.changed) {
+            work.source = { ...prior, text: patched.text, hash: mermaidSourceHash(patched.text), valid: true };
+            // The XML is the truth, so the model follows it back: what the patch
+            // decided (placement, waypoints, cascades) is derived into the model
+            // as ordinary ops whose inverses sit before the text's own inverse.
+            const parsed = parseBpmn(patched.text);
+            if (parsed.ok) {
+                const sync = syncOpsFromBpmn(snapshotDoc(), parsed.structure);
+                for (const syncOp of sync.ops) {
+                    try {
+                        run(syncOp, -1);
+                    }
+                    catch {
+                        // A sync op that cannot apply leaves the model as the ops made it.
+                    }
+                }
+            }
+            inverse.push({ op: "setSource", source: prior, resync: false });
+        }
+    }
+    const nodes = sortPreOrder(work.nodes);
+    const meta = {
+        ...(replaced ?? doc).meta,
+        title: work.title,
+        ...(options.now ? { updatedAt: options.now } : {}),
+    };
+    const base = replaced ?? doc;
+    const next = compact({
+        ...base,
+        meta,
+        canvas: work.canvas,
+        nodes,
+        edges: work.edges,
+        source: work.source,
+    });
+    return {
+        doc: next,
+        inverse: inverse.slice().reverse(),
+        changed: { nodes: [...work.changedNodes], edges: [...work.changedEdges] },
+        added: { nodes: work.addedNodes, edges: work.addedEdges },
+        removed: { nodes: work.removedNodes, edges: work.removedEdges },
+        rerouted: [...work.rerouted],
+        warnings: work.warnings,
+        skipped,
+        sourceUnmapped,
+    };
+};
+// Convenience for hosts that only need the document.
+export const applyOps = (doc, ops, options) => applyDiagramOps(doc, ops, options).doc;
+//# sourceMappingURL=ops.js.map