callman-core 1.28.0 → 1.29.0

package/dist/diagram/patchInput.js

@@ -0,0 +1,621 @@
+// 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 { 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 === "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 === "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 === "bpmn" ? undefined : getDiagramComponent(type);
+    const bpmn = kind === "bpmn" ? getBpmnType(type) : undefined;
+    const label = input.label !== undefined || !known ? (input.label ?? input.type) : def?.defaultLabel;
+    // A BPMN node always knows which element it stands for.
+    const data = kind === "bpmn"
+        ? { ...(input.data ?? {}), bpmn: { ...(input.data?.bpmn ?? {}), element: bpmnElementForType(type) ?? "task" } }
+        : input.data;
+    const node = {
+        id,
+        type,
+        position: input.position ?? { x: 0, y: 0 },
+        size: input.size ?? bpmn?.size ?? 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.
+    const data = kind === "bpmn"
+        ? { ...(input.data ?? {}), bpmn: { flow: "sequence", ...(input.data?.bpmn ?? {}) } }
+        : input.data;
+    const style = edgeStyleFor(semantic, input.color);
+    return {
+        id,
+        source: input.source,
+        target: input.target,
+        ...(input.label ? { label: input.label } : {}),
+        ...(input.routing ? { routing: input.routing } : {}),
+        markerEnd: input.markerEnd ?? "classicThin",
+        ...(input.markerStart && input.markerStart !== "none" ? { markerStart: input.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" : "canvas");
+    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;
+            default:
+                throw new DiagramOpError("DIAGRAM_INVALID_OP", `Unknown op "${op.op}"`, index);
+        }
+    });
+    return { ops, warnings, 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" : "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