callman-core 1.28.1 → 1.30.0

package/dist/diagram/patchInput.js

@@ -0,0 +1,1024 @@
+// The AUTHORING vocabulary — the compact shape AI models and MCP clients
+// write (`parent` not `parentId`, a `semantic` instead of a dash tuple, CSS
+// colors, optional positions) — lowered onto the canonical ops of ops.ts.
+// One implementation of the merge rules, type checks and suggestions, shared
+// by the MCP server (behind its zod schemas), the AI EDIT mode and imports.
+// Moved from the MCP server's build.ts / patch.ts.
+import { BPMN_CONTAINER_TYPES, bpmnElementForType, getBpmnType, isBpmnContainerType, suggestBpmnTypes } from "./bpmn/types.js";
+import { applyDatabaseEdits, DATABASE_GRAMMAR_VERSION, DatabaseEditError, databaseEntitySize, DB_NODE_TYPES, emptyDatabaseModel, findEntity, isValidCardinality, kindForDatabaseType, markersForCardinality, parseDatabaseModel, serializeDatabaseModel, suggestDatabaseTypes, } from "./database/index.js";
+import { DIAGRAM_COMPONENT_CATALOG, getDiagramComponent, searchDiagramComponents } from "./componentCatalog.js";
+import { isBusComponentType, isDefaultEdgeStyle, semanticStyle } from "./edgeSemantics.js";
+import { absolutePosition, absoluteRect, boundingBox, indexNodes, toParentRelative } from "./geometry.js";
+import { sequentialIdFactory, slugIdFactory } from "./ids.js";
+import { normalizeDiagramStyles } from "./normalize.js";
+import { DiagramOpError } from "./ops.js";
+import { nowIso, safeParseDiagramDocument, SCHEMA_VERSION, } from "./schema.js";
+import { applyStyleInput, styleInputToChanges, toTokenRef } from "./styleInput.js";
+// --- catalog helpers ---------------------------------------------------------------
+export const suggestComponentTypes = (type, limit = 5) => {
+    const seen = new Set();
+    const out = [];
+    const push = (candidate) => {
+        if (!seen.has(candidate) && out.length < limit) {
+            seen.add(candidate);
+            out.push(candidate);
+        }
+    };
+    for (const entry of searchDiagramComponents(type))
+        push(entry.type);
+    // A typo usually sits at the END of the last segment ("db.postgresqlx"):
+    // shrink it until something in the catalog contains it.
+    const tail = (type.split(".").pop() ?? type).toLowerCase();
+    for (let length = tail.length; length >= 3 && out.length < limit; length -= 1) {
+        const needle = tail.slice(0, length);
+        for (const entry of DIAGRAM_COMPONENT_CATALOG) {
+            const haystack = [entry.type, entry.label, ...(entry.aliases ?? [])].join(" ").toLowerCase();
+            if (haystack.includes(needle))
+                push(entry.type);
+        }
+    }
+    // Still nothing: offer the same namespace ("db.*", "aws.*").
+    const namespace = type.includes(".") ? `${type.split(".")[0].toLowerCase()}.` : null;
+    if (namespace) {
+        for (const entry of DIAGRAM_COMPONENT_CATALOG)
+            if (entry.type.toLowerCase().startsWith(namespace))
+                push(entry.type);
+    }
+    return out;
+};
+// Containers hold children through `parent`: frames and swimlane pools.
+export const isContainerType = (type) => {
+    const def = type ? getDiagramComponent(type) : undefined;
+    return Boolean(def?.container || def?.swimlane);
+};
+export const containerTypes = () => DIAGRAM_COMPONENT_CATALOG.filter((entry) => entry.container || entry.swimlane).map((entry) => entry.type);
+export const parentWarning = (id, parentId, parentType, kind = "canvas") => {
+    if (kind === "database")
+        return `Node ${id} sits inside "${parentId}" — database diagrams have no containers; the parent is ignored.`;
+    if (kind === "bpmn") {
+        return isBpmnContainerType(parentType)
+            ? null
+            : `Node ${id} sits inside "${parentId}" (${parentType ?? "unknown"}), which is not a BPMN container — use ${BPMN_CONTAINER_TYPES.join(", ")}.`;
+    }
+    return isContainerType(parentType)
+        ? null
+        : `Node ${id} sits inside "${parentId}" (${parentType ?? "unknown"}), which is not a container — use ${containerTypes().join(", ")} to group nodes.`;
+};
+// line / arrow / line.dashed are palette connectors (0-height), not nodes.
+export const assertNotConnector = (type, id, opIndex = -1) => {
+    if (getDiagramComponent(type)?.variant === "line") {
+        throw new DiagramOpError("DIAGRAM_CONNECTOR_NOT_NODE", `"${type}" on ${id} is a connector, not a node — draw it as an edge between two nodes.`, opIndex);
+    }
+};
+// Edge input → the stored edge's visual fields: the semantic's line tuple
+// plus an optional color.
+export const edgeStyleFor = (semantic, color) => {
+    const base = semantic ? semanticStyle(semantic) : undefined;
+    if (!color)
+        return base;
+    return { ...(base ?? {}), stroke: toTokenRef(color) };
+};
+const resolveType = (type, id, strict, warnings, opIndex, kind = "canvas") => {
+    const trimmed = type.trim();
+    if (kind === "database") {
+        if (DB_NODE_TYPES.includes(trimmed))
+            return { type: trimmed, known: true };
+        const suggestions = suggestDatabaseTypes(trimmed);
+        if (strict) {
+            throw new DiagramOpError("DIAGRAM_UNKNOWN_COMPONENT_TYPE", `Unknown database type "${trimmed}" on ${id}. A database diagram has db.table, db.view and db.collection (prefer the DATABASE OPS: addTable, addColumn, addRelationship …), or pass strictTypes:false to draw it as a table.`, opIndex, { unknownTypes: [{ type: trimmed, suggestions }] });
+        }
+        warnings.push(`Unknown database type "${trimmed}" on ${id} → drawn as a table`);
+        return { type: "db.table", known: false };
+    }
+    if (kind === "bpmn") {
+        if (getBpmnType(trimmed))
+            return { type: trimmed, known: true };
+        const suggestions = suggestBpmnTypes(trimmed);
+        if (strict) {
+            throw new DiagramOpError("DIAGRAM_UNKNOWN_COMPONENT_TYPE", `Unknown BPMN type "${trimmed}" on ${id}. Use one of the bpmn.* types (e.g. ${suggestions.join(", ") || "bpmn.user-task, bpmn.exclusive-gateway"}), or pass strictTypes:false to draw it as a task.`, opIndex, { unknownTypes: [{ type: trimmed, suggestions }] });
+        }
+        warnings.push(`Unknown BPMN type "${trimmed}" on ${id} → drawn as a task (suggestions: ${suggestions.join(", ") || "none"})`);
+        return { type: "bpmn.task", known: false };
+    }
+    if (getDiagramComponent(trimmed)) {
+        assertNotConnector(trimmed, id, opIndex);
+        return { type: trimmed, known: true };
+    }
+    const suggestions = suggestComponentTypes(trimmed);
+    if (strict) {
+        throw new DiagramOpError("DIAGRAM_UNKNOWN_COMPONENT_TYPE", `Unknown component type "${trimmed}" on ${id}. Read callman://diagram/components for the catalog, or pass strictTypes:false to draw it as a rectangle.`, opIndex, { unknownTypes: [{ type: trimmed, suggestions }] });
+    }
+    warnings.push(`Unknown component type "${trimmed}" on ${id} → drawn as a rectangle (suggestions: ${suggestions.join(", ") || "none"})`);
+    return { type: "rect", known: false };
+};
+const nodeFromInput = (input, id, strict, warnings, opIndex, kind = "canvas") => {
+    const { type, known } = resolveType(input.type, id, strict, warnings, opIndex, kind);
+    const def = kind === "canvas" ? getDiagramComponent(type) : undefined;
+    const bpmn = kind === "bpmn" ? getBpmnType(type) : undefined;
+    const dbRaw = kind === "database" ? (input.data?.db ?? {}) : undefined;
+    const label = kind === "database"
+        ? (typeof dbRaw?.name === "string" && dbRaw.name.trim()) || input.label || id
+        : input.label !== undefined || !known
+            ? (input.label ?? input.type)
+            : def?.defaultLabel;
+    // A BPMN node always knows which element it stands for; a database node its
+    // table name and kind (its `columns` stay the authoring input until the
+    // model absorbs them).
+    const data = kind === "bpmn"
+        ? { ...(input.data ?? {}), bpmn: { ...(input.data?.bpmn ?? {}), element: bpmnElementForType(type) ?? "task" } }
+        : kind === "database"
+            ? { ...(input.data ?? {}), db: { ...dbRaw, name: label, kind: kindForDatabaseType(type) } }
+            : input.data;
+    const dbColumns = Array.isArray(dbRaw?.columns) ? dbRaw.columns : [];
+    const dbSize = kind === "database"
+        ? databaseEntitySize({
+            name: String(label),
+            ...(typeof dbRaw?.schema === "string" ? { schema: dbRaw.schema } : {}),
+            columns: dbColumns.map((column) => {
+                const raw = (column ?? {});
+                return { name: typeof raw.name === "string" ? raw.name : "", dataType: typeof raw.dataType === "string" ? raw.dataType : typeof raw.type === "string" ? raw.type : "" };
+            }),
+        })
+        : undefined;
+    const node = {
+        id,
+        type,
+        position: input.position ?? { x: 0, y: 0 },
+        size: input.size ?? bpmn?.size ?? dbSize ?? def?.defaultSize ?? { width: 140, height: 60 },
+        ...(label !== undefined ? { label } : {}),
+        ...(input.parent ? { parentId: input.parent } : {}),
+        ...(input.style ? { style: applyStyleInput(undefined, input.style) } : {}),
+        ...(input.rotation ? { rotation: input.rotation } : {}),
+        ...(input.locked ? { locked: true } : {}),
+        ...(input.hidden ? { hidden: true } : {}),
+        ...(input.collapsed ? { collapsed: true } : {}),
+        ...(data ? { data } : {}),
+    };
+    if (node.style === undefined)
+        delete node.style;
+    return node;
+};
+const edgeFromInput = (input, id, typeOf, kind = "canvas") => {
+    let semantic = input.semantic;
+    // A fresh edge into a broker reads as a bus line — the studio's own rule.
+    if (kind === "canvas" && !semantic && (isBusComponentType(typeOf(input.source)) || isBusComponentType(typeOf(input.target))))
+        semantic = "bus";
+    // A BPMN flow is a sequence flow unless said otherwise; a database edge is
+    // a relationship (manual, N:1 unless said otherwise) with crow's-foot ends.
+    const dbRaw = kind === "database" ? (input.data?.db ?? {}) : undefined;
+    const cardinality = isValidCardinality(dbRaw?.cardinality) ? dbRaw.cardinality : "N:1";
+    const data = kind === "bpmn"
+        ? { ...(input.data ?? {}), bpmn: { flow: "sequence", ...(input.data?.bpmn ?? {}) } }
+        : kind === "database"
+            ? { ...(input.data ?? {}), db: { kind: "manual", sourceColumns: [], targetColumns: [], ...dbRaw, cardinality } }
+            : input.data;
+    const dbMarkers = kind === "database" ? markersForCardinality(cardinality) : undefined;
+    const style = edgeStyleFor(semantic, input.color);
+    const markerStart = input.markerStart ?? dbMarkers?.markerStart;
+    return {
+        id,
+        source: input.source,
+        target: input.target,
+        ...(input.label ? { label: input.label } : {}),
+        ...(input.routing ? { routing: input.routing } : {}),
+        markerEnd: input.markerEnd ?? dbMarkers?.markerEnd ?? "classicThin",
+        ...(markerStart && markerStart !== "none" ? { markerStart } : {}),
+        ...(input.sourceSide ? { sourceHandle: input.sourceSide } : {}),
+        ...(input.targetSide ? { targetHandle: input.targetSide } : {}),
+        ...(style && (!isDefaultEdgeStyle(style) || semantic === "sync" || input.color) ? { style } : {}),
+        ...(data ? { data } : {}),
+    };
+};
+// --- lowering -----------------------------------------------------------------------
+export const lowerPatchOps = (doc, input, options = {}) => {
+    const strict = options.strictTypes !== false;
+    const kind = options.kind ?? (doc.source?.format === "bpmn" ? "bpmn" : doc.source?.format === "database" ? "database" : "canvas");
+    if (kind === "database")
+        return lowerDatabasePatchOps(doc, input, { ...options, strict });
+    const warnings = [];
+    const unpositionedNodeIds = [];
+    const idMap = {};
+    const ops = [];
+    let relayout;
+    // A working view of ids/types/parents so later ops in the same batch can
+    // reference nodes added earlier — the ops themselves stay canonical.
+    const nodes = new Map(doc.nodes.map((node) => [node.id, { ...node }]));
+    const edges = new Map(doc.edges.map((edge) => [edge.id, { ...edge }]));
+    const takenIds = () => [...nodes.keys(), ...edges.keys()];
+    const genNodeId = options.genNodeId ?? slugIdFactory(takenIds(), "n");
+    const genEdgeId = options.genEdgeId ?? sequentialIdFactory("e", takenIds());
+    const typeOf = (id) => nodes.get(id)?.type;
+    const mapId = (id) => idMap[id] ?? id;
+    const requireNode = (id, index) => {
+        const node = nodes.get(mapId(id));
+        if (!node)
+            throw new DiagramOpError("DIAGRAM_NODE_NOT_FOUND", `Node "${id}" does not exist.`, index);
+        return node;
+    };
+    input.forEach((op, index) => {
+        switch (op.op) {
+            case "setTitle":
+                ops.push({ op: "setTitle", title: op.title });
+                return;
+            case "addNode": {
+                const requested = op.node.id?.trim();
+                let id = requested || genNodeId(op.node.label ?? op.node.type);
+                if (requested && (nodes.has(requested) || edges.has(requested))) {
+                    throw new DiagramOpError("DIAGRAM_DUPLICATE_NODE_ID", `A node with id "${requested}" already exists.`, index);
+                }
+                if (!requested && (nodes.has(id) || edges.has(id)))
+                    id = genNodeId();
+                const parent = op.node.parent ? mapId(op.node.parent) : undefined;
+                if (parent && !nodes.has(parent))
+                    throw new DiagramOpError("DIAGRAM_PARENT_NOT_FOUND", `Parent "${op.node.parent}" does not exist.`, index);
+                const node = nodeFromInput({ ...op.node, parent }, id, strict, warnings, index, kind);
+                if (parent) {
+                    const warning = parentWarning(id, parent, typeOf(parent), kind);
+                    if (warning)
+                        warnings.push(warning);
+                }
+                nodes.set(id, node);
+                if (requested && requested !== id)
+                    idMap[requested] = id;
+                if (!op.node.position)
+                    unpositionedNodeIds.push(id);
+                ops.push({ op: "addNode", node });
+                return;
+            }
+            case "updateNode": {
+                const id = mapId(op.id);
+                const node = requireNode(id, index);
+                const changes = op.changes;
+                const nodeChanges = {};
+                if (changes.type !== undefined)
+                    nodeChanges.type = resolveType(changes.type, id, strict, warnings, index, kind).type;
+                if (changes.label !== undefined)
+                    nodeChanges.label = changes.label;
+                if (changes.rotation !== undefined)
+                    nodeChanges.rotation = changes.rotation;
+                if (changes.locked !== undefined)
+                    nodeChanges.locked = changes.locked;
+                if (changes.hidden !== undefined)
+                    nodeChanges.hidden = changes.hidden;
+                if (changes.collapsed !== undefined)
+                    nodeChanges.collapsed = changes.collapsed;
+                if (changes.style !== undefined)
+                    nodeChanges.style = changes.style === null ? null : styleInputToChanges(node.style, changes.style);
+                if (changes.data !== undefined)
+                    nodeChanges.data = changes.data;
+                if (Object.keys(nodeChanges).length > 0) {
+                    ops.push({ op: "updateNode", id, changes: nodeChanges });
+                    const next = { ...node };
+                    if (nodeChanges.type)
+                        next.type = nodeChanges.type;
+                    nodes.set(id, next);
+                }
+                if (changes.size !== undefined) {
+                    ops.push({ op: "resizeNode", id, size: changes.size });
+                    nodes.set(id, { ...nodes.get(id), size: changes.size });
+                }
+                if (changes.parent !== undefined) {
+                    const parent = changes.parent ? mapId(changes.parent) : null;
+                    if (parent && !nodes.has(parent))
+                        throw new DiagramOpError("DIAGRAM_PARENT_NOT_FOUND", `Parent "${changes.parent}" does not exist.`, index);
+                    if (parent === id)
+                        throw new DiagramOpError("DIAGRAM_PARENT_CYCLE", `Node "${id}" cannot contain itself.`, index);
+                    const byId = indexNodes([...nodes.values()]);
+                    const position = changes.position ?? toParentRelative(absolutePosition(nodes.get(id), byId), parent, byId);
+                    ops.push({ op: "reparent", id, parentId: parent, position });
+                    if (parent) {
+                        const warning = parentWarning(id, parent, typeOf(parent), kind);
+                        if (warning)
+                            warnings.push(warning);
+                    }
+                    const next = { ...nodes.get(id), position };
+                    if (parent)
+                        next.parentId = parent;
+                    else
+                        delete next.parentId;
+                    nodes.set(id, next);
+                }
+                else if (changes.position !== undefined) {
+                    ops.push({ op: "moveNodes", moves: [{ id, position: changes.position }] });
+                    nodes.set(id, { ...nodes.get(id), position: changes.position });
+                }
+                return;
+            }
+            case "removeNode": {
+                const id = mapId(op.id);
+                requireNode(id, index);
+                ops.push({ op: "removeNode", id, children: "lift" });
+                nodes.delete(id);
+                for (const [edgeId, edge] of [...edges])
+                    if (edge.source === id || edge.target === id)
+                        edges.delete(edgeId);
+                for (const node of nodes.values())
+                    if (node.parentId === id)
+                        delete node.parentId;
+                return;
+            }
+            case "addEdge": {
+                const requested = op.edge.id?.trim();
+                let id = requested || genEdgeId();
+                if (requested && (edges.has(requested) || nodes.has(requested))) {
+                    throw new DiagramOpError("DIAGRAM_DUPLICATE_EDGE_ID", `An edge with id "${requested}" already exists.`, index);
+                }
+                if (!requested && (edges.has(id) || nodes.has(id)))
+                    id = genEdgeId();
+                const source = mapId(op.edge.source);
+                const target = mapId(op.edge.target);
+                for (const endpoint of [source, target]) {
+                    if (!nodes.has(endpoint))
+                        throw new DiagramOpError("DIAGRAM_EDGE_ENDPOINT_NOT_FOUND", `Edge endpoint "${endpoint}" does not exist.`, index);
+                }
+                const edge = edgeFromInput({ ...op.edge, source, target }, id, typeOf, kind);
+                edges.set(id, edge);
+                ops.push({ op: "addEdge", edge });
+                return;
+            }
+            case "updateEdge": {
+                const id = mapId(op.id);
+                const edge = edges.get(id);
+                if (!edge)
+                    throw new DiagramOpError("DIAGRAM_EDGE_NOT_FOUND", `Edge "${op.id}" does not exist.`, index);
+                const changes = op.changes;
+                const edgeChanges = {};
+                if (changes.source !== undefined)
+                    edgeChanges.source = mapId(changes.source);
+                if (changes.target !== undefined)
+                    edgeChanges.target = mapId(changes.target);
+                if (changes.label !== undefined)
+                    edgeChanges.label = changes.label === "" ? null : changes.label;
+                if (changes.routing !== undefined)
+                    edgeChanges.routing = changes.routing;
+                if (changes.markerEnd !== undefined)
+                    edgeChanges.markerEnd = changes.markerEnd;
+                if (changes.markerStart !== undefined)
+                    edgeChanges.markerStart = changes.markerStart === "none" ? null : changes.markerStart;
+                if (changes.sourceSide !== undefined)
+                    edgeChanges.sourceHandle = changes.sourceSide;
+                if (changes.targetSide !== undefined)
+                    edgeChanges.targetHandle = changes.targetSide;
+                if (changes.data !== undefined)
+                    edgeChanges.data = changes.data;
+                // The semantic owns the line tuple (dash + width); the color is kept
+                // unless it is changed explicitly.
+                if (changes.semantic !== undefined || changes.color !== undefined) {
+                    const style = {};
+                    if (changes.semantic !== undefined) {
+                        const line = semanticStyle(changes.semantic);
+                        style.dashed = line.dashed ?? null;
+                        style.dashPattern = line.dashPattern ?? null;
+                        style.strokeWidth = line.strokeWidth ?? null;
+                    }
+                    if (changes.color !== undefined)
+                        style.stroke = changes.color === null ? null : toTokenRef(changes.color);
+                    edgeChanges.style = style;
+                }
+                for (const endpoint of [edgeChanges.source, edgeChanges.target]) {
+                    if (endpoint !== undefined && !nodes.has(endpoint)) {
+                        throw new DiagramOpError("DIAGRAM_EDGE_ENDPOINT_NOT_FOUND", `Edge endpoint "${endpoint}" does not exist.`, index);
+                    }
+                }
+                if (Object.keys(edgeChanges).length > 0) {
+                    ops.push({ op: "updateEdge", id, changes: edgeChanges });
+                    edges.set(id, { ...edge, ...(edgeChanges.source ? { source: edgeChanges.source } : {}), ...(edgeChanges.target ? { target: edgeChanges.target } : {}) });
+                }
+                return;
+            }
+            case "removeEdge": {
+                const id = mapId(op.id);
+                if (!edges.has(id))
+                    throw new DiagramOpError("DIAGRAM_EDGE_NOT_FOUND", `Edge "${op.id}" does not exist.`, index);
+                edges.delete(id);
+                ops.push({ op: "removeEdge", id });
+                return;
+            }
+            case "moveNode": {
+                const id = mapId(op.id);
+                requireNode(id, index);
+                ops.push({ op: "moveNodes", moves: [{ id, position: op.position }] });
+                nodes.set(id, { ...nodes.get(id), position: op.position });
+                return;
+            }
+            case "reparent": {
+                const id = mapId(op.id);
+                const node = requireNode(id, index);
+                const parent = op.parent ? mapId(op.parent) : null;
+                if (parent && !nodes.has(parent))
+                    throw new DiagramOpError("DIAGRAM_PARENT_NOT_FOUND", `Parent "${op.parent}" does not exist.`, index);
+                const byId = indexNodes([...nodes.values()]);
+                const position = op.position ?? toParentRelative(absolutePosition(node, byId), parent, byId);
+                ops.push({ op: "reparent", id, parentId: parent, position });
+                const next = { ...node, position };
+                if (parent)
+                    next.parentId = parent;
+                else
+                    delete next.parentId;
+                nodes.set(id, next);
+                return;
+            }
+            case "setEdgeRoute": {
+                const id = mapId(op.id);
+                if (!edges.has(id))
+                    throw new DiagramOpError("DIAGRAM_EDGE_NOT_FOUND", `Edge "${op.id}" does not exist.`, index);
+                const changes = {};
+                if (op.routing !== undefined)
+                    changes.routing = op.routing;
+                if (op.sourceSide !== undefined)
+                    changes.sourceHandle = op.sourceSide;
+                if (op.targetSide !== undefined)
+                    changes.targetHandle = op.targetSide;
+                if (op.waypoints !== undefined)
+                    changes.waypoints = op.waypoints;
+                // "Reset routing" when nothing else is asked.
+                if (Object.keys(changes).length === 0) {
+                    changes.waypoints = null;
+                    changes.sourceAnchor = null;
+                    changes.targetAnchor = null;
+                }
+                ops.push({ op: "updateEdge", id, changes });
+                return;
+            }
+            case "reorder": {
+                const id = mapId(op.id);
+                const node = requireNode(id, index);
+                const siblings = [...nodes.values()].filter((candidate) => (candidate.parentId ?? undefined) === (node.parentId ?? undefined));
+                const target = op.index === "front" ? siblings.length - 1 : op.index === "back" ? 0 : op.index;
+                ops.push({ op: "reorder", kind: "node", id, index: target });
+                return;
+            }
+            case "setCanvas":
+                ops.push({ op: "setCanvas", changes: op.canvas });
+                return;
+            case "group": {
+                const memberIds = op.ids.map(mapId);
+                for (const memberId of memberIds)
+                    requireNode(memberId, index);
+                const type = op.type ?? "frame";
+                if (!isContainerType(type)) {
+                    throw new DiagramOpError("DIAGRAM_INVALID_OP", `"${type}" is not a container type — use ${containerTypes().join(", ")}.`, index);
+                }
+                const requested = op.id?.trim();
+                const groupId = requested || genNodeId(op.label ?? "group");
+                if (nodes.has(groupId) || edges.has(groupId))
+                    throw new DiagramOpError("DIAGRAM_DUPLICATE_NODE_ID", `A node with id "${groupId}" already exists.`, index);
+                const grouped = groupNodesOps({ ...doc, nodes: [...nodes.values()], edges: [...edges.values()] }, memberIds, { id: groupId, type, label: op.label });
+                ops.push(...grouped.ops);
+                nodes.set(groupId, grouped.container);
+                for (const [memberId, position] of Object.entries(grouped.memberPositions)) {
+                    nodes.set(memberId, { ...nodes.get(memberId), parentId: groupId, position });
+                }
+                return;
+            }
+            case "ungroup": {
+                const id = mapId(op.id);
+                requireNode(id, index);
+                ops.push({ op: "removeNode", id, children: "lift" });
+                nodes.delete(id);
+                for (const node of nodes.values())
+                    if (node.parentId === id)
+                        delete node.parentId;
+                return;
+            }
+            case "relayout":
+                relayout = { scope: op.scope, ...(op.direction ? { direction: op.direction } : {}) };
+                return;
+            case "addTable":
+            case "renameTable":
+            case "removeTable":
+            case "setTableComment":
+            case "addColumn":
+            case "alterColumn":
+            case "removeColumn":
+            case "setPrimaryKey":
+            case "addRelationship":
+            case "updateRelationship":
+            case "removeRelationship":
+            case "hideTable":
+            case "showTable":
+                throw new DiagramOpError("DIAGRAM_INVALID_OP", `"${op.op}" is a database-diagram op; this diagram is a ${kind} diagram.`, index);
+            default:
+                throw new DiagramOpError("DIAGRAM_INVALID_OP", `Unknown op "${op.op}"`, index);
+        }
+    });
+    return { ops, warnings, unpositionedNodeIds, ...(relayout ? { relayout } : {}), idMap };
+};
+// --- database diagrams -------------------------------------------------------------
+//
+// Every structural op (semantic or generic) becomes an edit of the database
+// model; the batch then yields ONE setSource op (the model re-derives the
+// nodes/edges) followed by the presentation ops (positions, visibility,
+// routing) that address nodes by their entity ids.
+const DATABASE_ERROR_CODES = {
+    DIAGRAM_TABLE_NOT_FOUND: "DIAGRAM_TABLE_NOT_FOUND",
+    DIAGRAM_COLUMN_NOT_FOUND: "DIAGRAM_COLUMN_NOT_FOUND",
+    DIAGRAM_RELATIONSHIP_NOT_FOUND: "DIAGRAM_RELATIONSHIP_NOT_FOUND",
+    DIAGRAM_DUPLICATE_TABLE: "DIAGRAM_DUPLICATE_TABLE",
+    DIAGRAM_DUPLICATE_COLUMN: "DIAGRAM_DUPLICATE_COLUMN",
+    DIAGRAM_INVALID_OP: "DIAGRAM_INVALID_OP",
+};
+const columnInputsOf = (value) => {
+    if (!Array.isArray(value))
+        return undefined;
+    return value
+        .filter((item) => Boolean(item) && typeof item === "object" && typeof item.name === "string")
+        .map((item) => ({
+        ...(typeof item.id === "string" ? { id: item.id } : {}),
+        name: String(item.name),
+        dataType: typeof item.dataType === "string" ? item.dataType : typeof item.type === "string" ? item.type : "",
+        ...(typeof item.nullable === "boolean" ? { nullable: item.nullable } : {}),
+        ...(typeof item.primaryKey === "boolean" ? { primaryKey: item.primaryKey } : {}),
+        ...(typeof item.unique === "boolean" ? { unique: item.unique } : {}),
+        ...(item.defaultValue !== undefined && item.defaultValue !== null ? { defaultValue: String(item.defaultValue) } : {}),
+        ...(typeof item.autoIncrement === "boolean" ? { autoIncrement: item.autoIncrement } : {}),
+        ...(typeof item.comment === "string" ? { comment: item.comment } : {}),
+    }));
+};
+const lowerDatabasePatchOps = (doc, input, options) => {
+    const warnings = [];
+    const idMap = {};
+    const presentation = [];
+    const positioned = new Map();
+    const unpositionedNodeIds = [];
+    let relayout;
+    const parsed = doc.source?.format === "database" ? parseDatabaseModel(doc.source.text) : null;
+    if (parsed && !parsed.ok)
+        throw new DiagramOpError("DIAGRAM_DOCUMENT_INVALID", `The database model cannot be read: ${parsed.errors.join("; ")}`);
+    let model = parsed?.model ?? emptyDatabaseModel();
+    let changed = false;
+    const mapId = (id) => idMap[id] ?? id;
+    const run = (edits, index) => {
+        try {
+            const result = applyDatabaseEdits(model, edits);
+            model = result.model;
+            changed = changed || result.changed;
+            warnings.push(...result.warnings);
+            Object.assign(idMap, result.idMap);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof DatabaseEditError)
+                throw new DiagramOpError(DATABASE_ERROR_CODES[error.code], error.message, index);
+            throw error;
+        }
+    };
+    const entityIdOf = (ref, index) => {
+        const entity = findEntity(model, mapId(ref));
+        if (!entity)
+            throw new DiagramOpError("DIAGRAM_TABLE_NOT_FOUND", `Table "${ref}" does not exist.`, index);
+        return entity.id;
+    };
+    const relationshipIdOf = (ref) => mapId(ref);
+    const noContainers = (index) => {
+        throw new DiagramOpError("DIAGRAM_INVALID_OP", "Database diagrams have no containers (group / ungroup / reparent do not apply).", index);
+    };
+    const endInput = (value) => (typeof value === "string" ? value : { ...value, table: mapId(value.table) });
+    input.forEach((op, index) => {
+        switch (op.op) {
+            case "setTitle":
+                presentation.push({ op: "setTitle", title: op.title });
+                return;
+            case "addTable": {
+                const result = run([{ kind: "addTable", table: op.table }], index);
+                const id = result.addedEntityIds[0];
+                if (op.position)
+                    positioned.set(id, op.position);
+                else
+                    unpositionedNodeIds.push(id);
+                return;
+            }
+            case "renameTable":
+                run([{ kind: "renameTable", table: mapId(op.table), name: op.name, ...(op.schema !== undefined ? { schema: op.schema } : {}) }], index);
+                return;
+            case "removeTable":
+                run([{ kind: "removeTable", table: mapId(op.table) }], index);
+                return;
+            case "setTableComment":
+                run([{ kind: "setTableComment", table: mapId(op.table), comment: op.comment }], index);
+                return;
+            case "addColumn":
+                run([{ kind: "addColumn", table: mapId(op.table), column: op.column, ...(op.after !== undefined ? { after: op.after } : {}) }], index);
+                return;
+            case "alterColumn":
+                run([{ kind: "alterColumn", table: mapId(op.table), column: op.column, changes: op.changes }], index);
+                return;
+            case "removeColumn":
+                run([{ kind: "removeColumn", table: mapId(op.table), column: op.column }], index);
+                return;
+            case "setPrimaryKey":
+                run([{ kind: "setPrimaryKey", table: mapId(op.table), columns: op.columns }], index);
+                return;
+            case "addRelationship":
+                run([
+                    {
+                        kind: "addRelationship",
+                        ...(op.id ? { id: op.id } : {}),
+                        source: endInput(op.source),
+                        target: endInput(op.target),
+                        ...(op.cardinality ? { cardinality: op.cardinality } : {}),
+                        ...(op.kind ? { relationshipKind: op.kind } : {}),
+                        ...(op.name ? { name: op.name } : {}),
+                        ...(op.label ? { label: op.label } : {}),
+                    },
+                ], index);
+                return;
+            case "updateRelationship": {
+                const { kind: relationshipKind, source, target, ...rest } = op.changes;
+                run([
+                    {
+                        kind: "updateRelationship",
+                        relationship: relationshipIdOf(op.relationship),
+                        changes: { ...rest, ...(source !== undefined ? { source: endInput(source) } : {}), ...(target !== undefined ? { target: endInput(target) } : {}), ...(relationshipKind ? { relationshipKind } : {}) },
+                    },
+                ], index);
+                return;
+            }
+            case "removeRelationship":
+                run([{ kind: "removeRelationship", relationship: relationshipIdOf(op.relationship) }], index);
+                return;
+            case "hideTable":
+                presentation.push({ op: "updateNode", id: entityIdOf(op.table, index), changes: { hidden: true } });
+                return;
+            case "showTable":
+                presentation.push({ op: "updateNode", id: entityIdOf(op.table, index), changes: { hidden: false } });
+                return;
+            case "addNode": {
+                const { type } = resolveType(op.node.type, op.node.id ?? op.node.label ?? "node", options.strict, warnings, index, "database");
+                if (op.node.parent)
+                    warnings.push(parentWarning(op.node.id ?? "node", op.node.parent, undefined, "database") ?? "");
+                const raw = op.node.data?.db ?? {};
+                const name = (typeof raw.name === "string" && raw.name.trim()) || (op.node.label ?? "").trim() || op.node.id?.trim() || "table";
+                const result = run([
+                    {
+                        kind: "addTable",
+                        table: {
+                            ...(op.node.id?.trim() ? { id: op.node.id.trim() } : {}),
+                            name,
+                            ...(typeof raw.schema === "string" && raw.schema.trim() ? { schema: raw.schema.trim() } : {}),
+                            kind: kindForDatabaseType(type),
+                            ...(columnInputsOf(raw.columns ?? raw.columnInputs) ? { columns: columnInputsOf(raw.columns ?? raw.columnInputs) } : {}),
+                            ...(typeof raw.comment === "string" && raw.comment.trim() ? { comment: raw.comment.trim() } : {}),
+                        },
+                    },
+                ], index);
+                const id = result.addedEntityIds[0];
+                if (op.node.position)
+                    positioned.set(id, op.node.position);
+                else
+                    unpositionedNodeIds.push(id);
+                if (op.node.hidden)
+                    presentation.push({ op: "updateNode", id, changes: { hidden: true } });
+                if (op.node.collapsed)
+                    presentation.push({ op: "updateNode", id, changes: { collapsed: true } });
+                if (op.node.locked)
+                    presentation.push({ op: "updateNode", id, changes: { locked: true } });
+                if (op.node.style)
+                    presentation.push({ op: "updateNode", id, changes: { style: styleInputToChanges(undefined, op.node.style) } });
+                if (op.node.size)
+                    presentation.push({ op: "resizeNode", id, size: op.node.size });
+                return;
+            }
+            case "updateNode": {
+                const id = entityIdOf(op.id, index);
+                const changes = op.changes;
+                if (changes.parent)
+                    noContainers(index);
+                const edits = [];
+                if (changes.type !== undefined) {
+                    const { type } = resolveType(changes.type, id, options.strict, warnings, index, "database");
+                    edits.push({ kind: "setTableKind", table: id, entityKind: kindForDatabaseType(type) });
+                }
+                const raw = changes.data && typeof changes.data.db === "object" && changes.data.db ? changes.data.db : undefined;
+                const requestedName = typeof raw?.name === "string" ? raw.name : typeof changes.label === "string" ? changes.label : undefined;
+                if (requestedName !== undefined) {
+                    const dot = requestedName.lastIndexOf(".");
+                    const schema = typeof raw?.schema === "string" ? raw.schema : dot > 0 ? requestedName.slice(0, dot) : undefined;
+                    edits.push({ kind: "renameTable", table: id, name: dot > 0 && typeof raw?.name !== "string" ? requestedName.slice(dot + 1) : requestedName, ...(schema !== undefined ? { schema } : {}) });
+                }
+                else if (typeof raw?.schema === "string") {
+                    const entity = findEntity(model, id);
+                    if (entity)
+                        edits.push({ kind: "renameTable", table: id, name: entity.name, schema: raw.schema || null });
+                }
+                if (raw && "comment" in raw)
+                    edits.push({ kind: "setTableComment", table: id, comment: typeof raw.comment === "string" ? raw.comment : null });
+                const columns = raw ? columnInputsOf(raw.columns ?? raw.columnInputs) : undefined;
+                if (columns)
+                    edits.push({ kind: "setColumns", table: id, columns });
+                if (edits.length > 0)
+                    run(edits, index);
+                const nodeChanges = {};
+                if (changes.rotation !== undefined)
+                    nodeChanges.rotation = changes.rotation;
+                if (changes.locked !== undefined)
+                    nodeChanges.locked = changes.locked;
+                if (changes.hidden !== undefined)
+                    nodeChanges.hidden = changes.hidden;
+                if (changes.collapsed !== undefined)
+                    nodeChanges.collapsed = changes.collapsed;
+                if (changes.style !== undefined)
+                    nodeChanges.style = changes.style === null ? null : styleInputToChanges(doc.nodes.find((node) => node.id === id)?.style, changes.style);
+                if (Object.keys(nodeChanges).length > 0)
+                    presentation.push({ op: "updateNode", id, changes: nodeChanges });
+                if (changes.size !== undefined)
+                    presentation.push({ op: "resizeNode", id, size: changes.size });
+                if (changes.position !== undefined)
+                    presentation.push({ op: "moveNodes", moves: [{ id, position: changes.position }] });
+                return;
+            }
+            case "removeNode":
+                run([{ kind: "removeTable", table: entityIdOf(op.id, index) }], index);
+                return;
+            case "addEdge": {
+                const raw = op.edge.data?.db ?? {};
+                const refs = (value) => (Array.isArray(value) ? value.filter((item) => typeof item === "string") : []);
+                const result = run([
+                    {
+                        kind: "addRelationship",
+                        ...(op.edge.id?.trim() ? { id: op.edge.id.trim() } : {}),
+                        source: { table: entityIdOf(op.edge.source, index), columns: refs(raw.sourceColumns) },
+                        target: { table: entityIdOf(op.edge.target, index), columns: refs(raw.targetColumns) },
+                        ...(isValidCardinality(raw.cardinality) ? { cardinality: raw.cardinality } : {}),
+                        relationshipKind: raw.kind === "foreignKey" ? "foreignKey" : "manual",
+                        ...(typeof raw.name === "string" ? { name: raw.name } : {}),
+                        ...(op.edge.label ? { label: op.edge.label } : {}),
+                    },
+                ], index);
+                const id = result.addedRelationshipIds[0];
+                if (id && (op.edge.routing || op.edge.sourceSide || op.edge.targetSide || op.edge.color)) {
+                    const edgeChanges = {};
+                    if (op.edge.routing)
+                        edgeChanges.routing = op.edge.routing;
+                    if (op.edge.sourceSide)
+                        edgeChanges.sourceHandle = op.edge.sourceSide;
+                    if (op.edge.targetSide)
+                        edgeChanges.targetHandle = op.edge.targetSide;
+                    if (op.edge.color)
+                        edgeChanges.style = { stroke: toTokenRef(op.edge.color) };
+                    presentation.push({ op: "updateEdge", id, changes: edgeChanges });
+                }
+                return;
+            }
+            case "updateEdge": {
+                const id = relationshipIdOf(op.id);
+                const changes = op.changes;
+                const raw = changes.data && typeof changes.data.db === "object" && changes.data.db ? changes.data.db : undefined;
+                const refs = (value) => (Array.isArray(value) ? value.filter((item) => typeof item === "string") : undefined);
+                const relationshipChanges = {};
+                if (changes.source !== undefined || refs(raw?.sourceColumns))
+                    relationshipChanges.source = { table: changes.source !== undefined ? entityIdOf(changes.source, index) : (findEntity(model, id) ? model.relationships.find((r) => r.id === id)?.source.entityId ?? "" : ""), columns: refs(raw?.sourceColumns) ?? (changes.source !== undefined ? [] : undefined) };
+                if (changes.target !== undefined || refs(raw?.targetColumns))
+                    relationshipChanges.target = { table: changes.target !== undefined ? entityIdOf(changes.target, index) : model.relationships.find((r) => r.id === id)?.target.entityId ?? "", columns: refs(raw?.targetColumns) ?? (changes.target !== undefined ? [] : undefined) };
+                if (isValidCardinality(raw?.cardinality))
+                    relationshipChanges.cardinality = raw.cardinality;
+                if (raw && (raw.kind === "manual" || raw.kind === "foreignKey"))
+                    relationshipChanges.relationshipKind = raw.kind;
+                if (raw && "name" in raw)
+                    relationshipChanges.name = typeof raw.name === "string" ? raw.name : null;
+                if (changes.label !== undefined)
+                    relationshipChanges.label = changes.label === "" ? null : changes.label;
+                if (Object.keys(relationshipChanges).length > 0)
+                    run([{ kind: "updateRelationship", relationship: id, changes: relationshipChanges }], index);
+                const edgeChanges = {};
+                if (changes.routing !== undefined)
+                    edgeChanges.routing = changes.routing;
+                if (changes.sourceSide !== undefined)
+                    edgeChanges.sourceHandle = changes.sourceSide;
+                if (changes.targetSide !== undefined)
+                    edgeChanges.targetHandle = changes.targetSide;
+                if (changes.color !== undefined)
+                    edgeChanges.style = { stroke: changes.color === null ? null : toTokenRef(changes.color) };
+                if (Object.keys(edgeChanges).length > 0)
+                    presentation.push({ op: "updateEdge", id, changes: edgeChanges });
+                return;
+            }
+            case "removeEdge":
+                run([{ kind: "removeRelationship", relationship: relationshipIdOf(op.id) }], index);
+                return;
+            case "moveNode":
+                presentation.push({ op: "moveNodes", moves: [{ id: entityIdOf(op.id, index), position: op.position }] });
+                return;
+            case "setEdgeRoute": {
+                const changes = {};
+                if (op.routing !== undefined)
+                    changes.routing = op.routing;
+                if (op.sourceSide !== undefined)
+                    changes.sourceHandle = op.sourceSide;
+                if (op.targetSide !== undefined)
+                    changes.targetHandle = op.targetSide;
+                if (op.waypoints !== undefined)
+                    changes.waypoints = op.waypoints;
+                if (Object.keys(changes).length === 0) {
+                    changes.waypoints = null;
+                    changes.sourceAnchor = null;
+                    changes.targetAnchor = null;
+                }
+                presentation.push({ op: "updateEdge", id: relationshipIdOf(op.id), changes });
+                return;
+            }
+            case "reorder": {
+                const id = entityIdOf(op.id, index);
+                const count = doc.nodes.filter((node) => !node.parentId).length;
+                presentation.push({ op: "reorder", kind: "node", id, index: op.index === "front" ? Math.max(0, count - 1) : op.index === "back" ? 0 : op.index });
+                return;
+            }
+            case "setCanvas":
+                presentation.push({ op: "setCanvas", changes: op.canvas });
+                return;
+            case "relayout":
+                relayout = { scope: op.scope, ...(op.direction ? { direction: op.direction } : {}) };
+                return;
+            case "reparent":
+            case "group":
+            case "ungroup":
+                noContainers(index);
+                return;
+            default:
+                throw new DiagramOpError("DIAGRAM_INVALID_OP", `Unknown op "${op.op}"`, index);
+        }
+    });
+    const ops = [];
+    if (changed) {
+        ops.push({
+            op: "setSource",
+            source: { format: "database", text: serializeDatabaseModel(model), diagramType: "database", grammar: DATABASE_GRAMMAR_VERSION, valid: true },
+            resync: true,
+        });
+    }
+    for (const [id, position] of positioned)
+        ops.push({ op: "moveNodes", moves: [{ id, position }] });
+    ops.push(...presentation);
+    return { ops, warnings: warnings.filter(Boolean), unpositionedNodeIds, ...(relayout ? { relayout } : {}), idMap };
+};
+export const buildDiagramFromInput = (input, options = {}) => {
+    const kind = options.kind ?? "canvas";
+    const strict = options.strictTypes !== false;
+    const warnings = [];
+    const explicitIds = input.nodes.map((node) => node.id?.trim()).filter((id) => Boolean(id));
+    const duplicates = explicitIds.filter((id, index) => explicitIds.indexOf(id) !== index);
+    if (duplicates.length > 0) {
+        throw new DiagramOpError("DIAGRAM_DUPLICATE_NODE_ID", `Duplicate node ids: ${[...new Set(duplicates)].join(", ")}`);
+    }
+    const genNodeId = options.idStrategy === "sequential" ? sequentialIdFactory("n", explicitIds) : slugIdFactory(explicitIds, "n");
+    const genEdgeId = sequentialIdFactory("e", (input.edges ?? []).map((edge) => edge.id).filter((id) => Boolean(id)));
+    // Ids first so parents/edges can reference nodes declared later.
+    const ids = input.nodes.map((node) => node.id?.trim() || genNodeId(node.label ?? node.type));
+    const idSet = new Set(ids);
+    const unknown = [];
+    const nodes = input.nodes.map((node, index) => {
+        const id = ids[index];
+        if (node.parent && !idSet.has(node.parent)) {
+            throw new DiagramOpError("DIAGRAM_PARENT_NOT_FOUND", `Node ${id} references parent "${node.parent}" which is not in nodes.`, index);
+        }
+        try {
+            return nodeFromInput(node, id, strict, warnings, index, kind);
+        }
+        catch (error) {
+            if (error instanceof DiagramOpError && error.code === "DIAGRAM_UNKNOWN_COMPONENT_TYPE") {
+                const entry = error.data?.unknownTypes?.[0];
+                if (entry)
+                    unknown.push(entry);
+                return nodeFromInput({ ...node, type: kind === "bpmn" ? "bpmn.task" : kind === "database" ? "db.table" : "rect", label: node.label ?? node.type }, id, false, [], index, kind);
+            }
+            throw error;
+        }
+    });
+    if (unknown.length > 0) {
+        throw new DiagramOpError("DIAGRAM_UNKNOWN_COMPONENT_TYPE", `Unknown component type(s): ${unknown.map((entry) => entry.type).join(", ")}. Read callman://diagram/components for the catalog, or pass strictTypes:false to draw them as rectangles.`, -1, { unknownTypes: unknown });
+    }
+    const typeOf = (id) => nodes.find((node) => node.id === id)?.type;
+    for (const node of nodes) {
+        const warning = node.parentId ? parentWarning(node.id, node.parentId, typeOf(node.parentId), kind) : null;
+        if (warning)
+            warnings.push(warning);
+    }
+    const edgeIds = new Set();
+    const edges = (input.edges ?? []).map((edge, index) => {
+        const id = edge.id?.trim() || genEdgeId();
+        if (edgeIds.has(id) || idSet.has(id))
+            throw new DiagramOpError("DIAGRAM_DUPLICATE_EDGE_ID", `Duplicate edge id: ${id}`, index);
+        edgeIds.add(id);
+        for (const endpoint of [edge.source, edge.target]) {
+            if (!idSet.has(endpoint)) {
+                throw new DiagramOpError("DIAGRAM_EDGE_ENDPOINT_NOT_FOUND", `Edge ${id} references "${endpoint}" which is not a node id.`, index);
+            }
+        }
+        return edgeFromInput(edge, id, typeOf, kind);
+    });
+    const timestamp = options.createdAt ?? nowIso();
+    const document = normalizeDiagramStyles({
+        schemaVersion: SCHEMA_VERSION,
+        id: options.existingId ?? `doc_${Math.random().toString(36).slice(2, 10)}`,
+        meta: { title: input.title.trim(), createdAt: timestamp, updatedAt: options.now ?? nowIso() },
+        canvas: {
+            background: input.canvas?.background ?? "dots",
+            gridSize: input.canvas?.gridSize ?? 16,
+            ...(input.canvas?.defaultRouting ? { defaultRouting: input.canvas.defaultRouting } : {}),
+        },
+        nodes,
+        edges,
+    });
+    const parsed = safeParseDiagramDocument(document);
+    if (!parsed.ok) {
+        throw new DiagramOpError("DIAGRAM_DOCUMENT_INVALID", `The diagram document is invalid: ${parsed.errors.join("; ")}`, -1, { errors: parsed.errors });
+    }
+    return {
+        document: parsed.document,
+        warnings,
+        unpositionedNodeIds: input.nodes.filter((node) => !node.position).map((_node, index) => ids[index]),
+    };
+};
+// A container around the members' bounding box, members re-parented into it
+// with their positions converted so nothing moves on the canvas.
+export const groupNodesOps = (doc, memberIds, options) => {
+    const byId = indexNodes(doc.nodes);
+    const members = memberIds.map((id) => byId.get(id)).filter((node) => Boolean(node));
+    const padding = options.padding ?? 24;
+    const titleHeight = options.titleHeight ?? 32;
+    const rects = members.map((node) => absoluteRect(node, byId));
+    const box = boundingBox(rects) ?? { x: 0, y: 0, width: 200, height: 120 };
+    // The container joins the first member's parent so nested groups stay nested.
+    const parentId = members[0]?.parentId;
+    const type = options.type ?? "frame";
+    const def = getDiagramComponent(type);
+    const containerAbs = { x: box.x - padding, y: box.y - padding - titleHeight };
+    const container = {
+        id: options.id,
+        type,
+        position: toParentRelative(containerAbs, parentId, byId),
+        size: { width: box.width + padding * 2, height: box.height + padding * 2 + titleHeight },
+        label: options.label ?? def?.defaultLabel ?? "Group",
+        ...(parentId ? { parentId } : {}),
+    };
+    const ops = [{ op: "addNode", node: container }];
+    const memberPositions = {};
+    members.forEach((member, index) => {
+        const abs = rects[index];
+        const position = { x: abs.x - containerAbs.x, y: abs.y - containerAbs.y };
+        memberPositions[member.id] = position;
+        ops.push({ op: "reparent", id: member.id, parentId: options.id, position });
+    });
+    return { ops, container, memberPositions };
+};
+export const ungroupOps = (containerId) => [{ op: "removeNode", id: containerId, children: "lift" }];
+// Place ONLY the given nodes (new ones from a patch) below the current
+// bounding box, in rows — nothing that already has a position moves. Nodes
+// inside a container are placed inside it, below its current content.
+export const placeNewNodesOps = (doc, nodeIds, gap = 40) => {
+    const wanted = new Set(nodeIds);
+    if (wanted.size === 0)
+        return [];
+    const byParent = new Map();
+    for (const node of doc.nodes) {
+        if (!wanted.has(node.id))
+            continue;
+        const list = byParent.get(node.parentId) ?? [];
+        list.push(node);
+        byParent.set(node.parentId, list);
+    }
+    const moves = [];
+    for (const [parentId, newcomers] of byParent) {
+        const placed = doc.nodes.filter((node) => !wanted.has(node.id) && (node.parentId ?? undefined) === parentId);
+        const maxY = placed.reduce((max, node) => Math.max(max, node.position.y + node.size.height), parentId ? 48 : 0);
+        const minX = placed.reduce((min, node) => Math.min(min, node.position.x), placed.length > 0 ? Infinity : parentId ? 24 : 0);
+        const startX = Number.isFinite(minX) ? minX : 0;
+        let cursorX = startX;
+        let cursorY = placed.length > 0 ? maxY + gap * 2 : maxY;
+        let rowHeight = 0;
+        const rowLimit = 1200;
+        for (const node of newcomers) {
+            if (cursorX + node.size.width > rowLimit && cursorX > startX) {
+                cursorX = startX;
+                cursorY += rowHeight + gap;
+                rowHeight = 0;
+            }
+            moves.push({ id: node.id, position: { x: cursorX, y: cursorY } });
+            cursorX += node.size.width + gap;
+            rowHeight = Math.max(rowHeight, node.size.height);
+        }
+    }
+    return moves.length > 0 ? [{ op: "moveNodes", moves }] : [];
+};
+// Whether an ops batch (typically from a model) deletes a large part of the
+// diagram — hosts confirm with the user before applying such a batch.
+export const assessOpsRisk = (doc, ops, threshold = 0.3, minimum = 3) => {
+    const removes = new Set();
+    const collect = (list) => {
+        for (const op of list) {
+            if (op.op === "removeNode")
+                removes.add(op.id);
+            else if (op.op === "batch")
+                collect(op.ops);
+            else if (op.op === "replaceDocument")
+                for (const node of doc.nodes)
+                    if (!op.document.nodes.some((n) => n.id === node.id))
+                        removes.add(node.id);
+        }
+    };
+    collect(ops);
+    const totalNodes = doc.nodes.length;
+    const ratio = totalNodes === 0 ? 0 : removes.size / totalNodes;
+    return { removesNodes: removes.size, totalNodes, ratio, destructive: removes.size >= minimum && ratio > threshold };
+};
+//# sourceMappingURL=patchInput.js.map