@graph-ir/mcp-server 0.2.0 → 0.2.2

package/dist/tools/layout.js

@@ -1,28 +1,21 @@
-/**
- * Graph-IR Layout Tool
- *
- * Computes graph layout using ELK algorithms.
- */
 import ELKConstructor from 'elkjs/lib/elk.bundled.js';
-// Initialize ELK instance (handle ESM default export)
-const ELKClass = ELKConstructor.default ?? ELKConstructor;
-// @ts-expect-error - ELK ESM/CJS interop
+import { validateIR, } from '@graph-ir/core';
+const ELKClass = ELKConstructor.default ??
+    ELKConstructor;
+// @ts-expect-error elkjs exposes a CJS-shaped constructor to ESM.
 const elk = new ELKClass();
-// ============================================================================
-// Algorithm Mapping
-// ============================================================================
 const ALGORITHM_MAPPING = {
     layered: 'org.eclipse.elk.layered',
     force: 'org.eclipse.elk.force',
+    tree: 'org.eclipse.elk.mrtree',
     mrtree: 'org.eclipse.elk.mrtree',
     box: 'org.eclipse.elk.box',
     stress: 'org.eclipse.elk.stress',
 };
-const DIRECTION_MAPPING = {
-    RIGHT: 'RIGHT',
-    DOWN: 'DOWN',
-    LEFT: 'LEFT',
-    UP: 'UP',
+const EDGE_ROUTING_MAPPING = {
+    orthogonal: 'ORTHOGONAL',
+    polyline: 'POLYLINE',
+    spline: 'SPLINES',
 };
 const DEFAULT_OPTIONS = {
     nodeWidth: 150,
@@ -31,232 +24,643 @@ const DEFAULT_OPTIONS = {
     verticalSpacing: 50,
     direction: 'RIGHT',
 };
-// ============================================================================
-// Main Layout Function
-// ============================================================================
-/**
- * Compute layout for Graph-IR using ELK
- */
-export async function layoutIR(irJson, algorithm = 'layered', options = {}) {
-    // Parse JSON
+const REQUEST_OPTION_KEYS = new Set([
+    'nodeWidth',
+    'nodeHeight',
+    'horizontalSpacing',
+    'verticalSpacing',
+    'direction',
+]);
+const REQUEST_DIRECTIONS = new Set(['RIGHT', 'DOWN', 'LEFT', 'UP']);
+const ELK_ROOT_ID = '__graph_ir_internal_root__';
+export async function layoutIR(irJson, requestedAlgorithm, options = {}) {
     let ir;
     try {
         ir = JSON.parse(irJson);
     }
-    catch (e) {
-        return {
-            success: false,
-            errors: [`Invalid JSON: ${e instanceof Error ? e.message : 'Parse error'}`],
-            algorithm,
-        };
+    catch (error) {
+        return failed(requestedAlgorithm ?? 'layered', [{
+                code: 'INVALID_JSON',
+                path: '',
+                message: `Invalid JSON: ${error instanceof Error ? error.message : 'Parse error'}`,
+            }]);
     }
-    // Validate structure
-    if (!ir.nodes || !Array.isArray(ir.nodes)) {
-        return {
-            success: false,
-            errors: ['Invalid Graph-IR structure: missing nodes array'],
-            algorithm,
-        };
+    const validation = validateIR(ir);
+    if (!validation.valid) {
+        return failed(requestedAlgorithm ?? 'layered', validation.errors.map(({ code, path, message }) => ({ code, path, message })));
     }
-    if (!ir.edges || !Array.isArray(ir.edges)) {
-        return {
-            success: false,
-            errors: ['Invalid Graph-IR structure: missing edges array'],
-            algorithm,
-        };
+    const graph = ir;
+    const requestErrors = validateRequestOptions(options);
+    if (requestErrors.length > 0) {
+        return failed(requestedAlgorithm ?? graph.layoutOptions?.algorithm ?? 'layered', requestErrors);
     }
-    const layoutOptions = {
-        ...DEFAULT_OPTIONS,
-        ...options,
-    };
+    const conflict = optionConflicts(graph, requestedAlgorithm, options);
+    if (conflict.length > 0) {
+        return failed(requestedAlgorithm ?? graph.layoutOptions?.algorithm ?? 'layered', conflict);
+    }
+    const algorithm = requestedAlgorithm ?? graph.layoutOptions?.algorithm ?? 'layered';
+    const capabilityErrors = unsupportedCapabilities(graph, algorithm, options);
+    if (capabilityErrors.length > 0)
+        return failed(algorithm, capabilityErrors);
+    const requestOptions = normalizeOptions(graph, options);
     try {
-        // Convert to ELK format
-        const elkGraph = graphIRToELK(ir, layoutOptions, algorithm);
-        // Run ELK layout
-        const layoutedElk = await elk.layout(elkGraph);
-        // Convert back to Graph-IR
-        const layoutedIR = elkToGraphIR(layoutedElk, ir, algorithm);
+        const elkGraph = graphIRToELK(graph, requestOptions, algorithm);
+        const resolvedElk = await elk.layout(elkGraph);
+        const verification = verifyResolvedLayout(graph, resolvedElk);
+        if (verification.length > 0)
+            return failed(algorithm, verification);
         return {
             success: true,
-            ir: layoutedIR,
+            resolved: elkToResolvedLayout(resolvedElk, graph, algorithm),
             errors: [],
             algorithm,
         };
     }
-    catch (e) {
-        return {
-            success: false,
-            errors: [`Layout failed: ${e instanceof Error ? e.message : 'Unknown error'}`],
-            algorithm,
-        };
+    catch (error) {
+        return failed(algorithm, [{
+                code: 'LAYOUT_FAILED',
+                path: '',
+                message: `Layout failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            }]);
+    }
+}
+export async function layoutIRFromToolArguments(args) {
+    if (!args || typeof args !== 'object' || Array.isArray(args)) {
+        return failed('layered', [{
+                code: 'INVALID_LAYOUT_REQUEST',
+                path: '',
+                message: 'Tool arguments must be an object',
+            }]);
+    }
+    const record = args;
+    const errors = [];
+    for (const key of Object.keys(record)) {
+        if (!['ir', 'algorithm', 'options'].includes(key)) {
+            errors.push({
+                code: 'INVALID_LAYOUT_REQUEST',
+                path: `/${key}`,
+                message: `Unknown layout tool argument "${key}"`,
+            });
+        }
+    }
+    if (typeof record.ir !== 'string') {
+        errors.push({
+            code: 'INVALID_LAYOUT_REQUEST',
+            path: '/ir',
+            message: 'ir must be a JSON string',
+        });
+    }
+    if (record.algorithm !== undefined && typeof record.algorithm !== 'string') {
+        errors.push({
+            code: 'INVALID_LAYOUT_REQUEST',
+            path: '/algorithm',
+            message: 'algorithm must be a string',
+        });
+    }
+    errors.push(...validateRequestOptions(record.options ?? {}));
+    if (errors.length > 0) {
+        return failed(typeof record.algorithm === 'string' ? record.algorithm : 'layered', errors);
+    }
+    return layoutIR(record.ir, record.algorithm, record.options);
+}
+function validateRequestOptions(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return [{
+                code: 'INVALID_LAYOUT_REQUEST',
+                path: '/options',
+                message: 'options must be an object',
+            }];
+    }
+    const options = value;
+    const errors = [];
+    for (const [key, option] of Object.entries(options)) {
+        const path = `/options/${key}`;
+        if (!REQUEST_OPTION_KEYS.has(key)) {
+            errors.push({ code: 'INVALID_LAYOUT_REQUEST', path, message: `Unknown layout option "${key}"` });
+        }
+        else if (key === 'direction') {
+            if (typeof option !== 'string' || !REQUEST_DIRECTIONS.has(option)) {
+                errors.push({ code: 'INVALID_LAYOUT_REQUEST', path, message: 'Invalid layout direction' });
+            }
+        }
+        else if (typeof option !== 'number' || !Number.isFinite(option) || option < 0) {
+            errors.push({ code: 'INVALID_LAYOUT_REQUEST', path, message: 'Layout size and spacing must be finite and nonnegative' });
+        }
     }
+    return errors;
+}
+function optionConflicts(graph, requestedAlgorithm, rawOptions) {
+    const errors = [];
+    if (requestedAlgorithm &&
+        graph.layoutOptions?.algorithm &&
+        requestedAlgorithm !== graph.layoutOptions.algorithm) {
+        errors.push({
+            code: 'LAYOUT_OPTION_CONFLICT',
+            path: '/layoutOptions/algorithm',
+            message: 'Transient algorithm conflicts with authored layout algorithm',
+        });
+    }
+    if (typeof rawOptions.direction === 'string' &&
+        graph.layoutOptions?.direction &&
+        rawOptions.direction !== graph.layoutOptions.direction) {
+        errors.push({
+            code: 'LAYOUT_OPTION_CONFLICT',
+            path: '/layoutOptions/direction',
+            message: 'Transient direction conflicts with authored layout direction',
+        });
+    }
+    const authoredSpacing = graph.layoutOptions?.spacing;
+    const spacingConflicts = [
+        ['horizontalSpacing', 'nodeNode'],
+        ['verticalSpacing', 'layerSpacing'],
+    ];
+    for (const [requestKey, authoredKey] of spacingConflicts) {
+        const requested = rawOptions[requestKey];
+        const authored = authoredSpacing?.[authoredKey];
+        if (typeof requested === 'number' && authored !== undefined && requested !== authored) {
+            errors.push({
+                code: 'LAYOUT_OPTION_CONFLICT',
+                path: `/layoutOptions/spacing/${authoredKey}`,
+                message: `Transient ${requestKey} conflicts with authored ${authoredKey}`,
+            });
+        }
+    }
+    return errors;
+}
+function unsupportedCapabilities(graph, algorithm, rawOptions) {
+    const errors = [];
+    const unsupported = (path, message) => errors.push({
+        code: 'UNSUPPORTED_LAYOUT_CAPABILITY',
+        path,
+        message,
+    });
+    if (!(algorithm in ALGORITHM_MAPPING)) {
+        unsupported('/layoutOptions/algorithm', `Algorithm "${algorithm}" is not supported`);
+    }
+    const layered = algorithm === 'layered';
+    const directional = layered || algorithm === 'tree' || algorithm === 'mrtree';
+    if (!directional && (graph.layoutOptions?.direction || rawOptions.direction !== undefined)) {
+        unsupported(graph.layoutOptions?.direction ? '/layoutOptions/direction' : '/options/direction', `Algorithm "${algorithm}" does not honor direction`);
+    }
+    if (!layered && graph.layoutOptions?.spacing) {
+        unsupported('/layoutOptions/spacing', `Algorithm "${algorithm}" does not honor portable spacing`);
+    }
+    if (!layered && (rawOptions.horizontalSpacing !== undefined || rawOptions.verticalSpacing !== undefined)) {
+        unsupported('/options', `Algorithm "${algorithm}" does not honor transient spacing`);
+    }
+    if (!layered && graph.layoutOptions?.edgeRouting) {
+        unsupported('/layoutOptions/edgeRouting', `Algorithm "${algorithm}" does not honor graph edge routing`);
+    }
+    if (graph.layoutOptions?.edgeRouting === 'spline') {
+        unsupported('/layoutOptions/edgeRouting', 'Spline control-point semantics are not represented by ResolvedLayout');
+    }
+    if (algorithm === 'box' && graph.edges.length > 0) {
+        unsupported('/edges', 'Algorithm "box" does not route authored edges');
+    }
+    if (!layered) {
+        graph.edges.forEach((edge, index) => {
+            if (edge.source === edge.target) {
+                unsupported(`/edges/${index}`, `Algorithm "${algorithm}" does not produce a verified self-loop route`);
+            }
+        });
+    }
+    if (!layered && hasNestedNodes(graph.nodes)) {
+        unsupported('/nodes', `Algorithm "${algorithm}" does not support verified compound layout`);
+    }
+    if (graph.constraints?.length)
+        unsupported('/constraints', 'Spatial constraints require a solver');
+    if (graph.profile)
+        unsupported('/profile', 'Notation profiles require a profile-aware layout adapter');
+    if (graph.interaction)
+        unsupported('/interaction', 'Sequence interactions require a sequence-aware layout adapter');
+    if (graph.layoutOptions?.hierarchyHandling === 'SEPARATE_CHILDREN') {
+        unsupported('/layoutOptions/hierarchyHandling', 'SEPARATE_CHILDREN is not supported');
+    }
+    visitNodes(graph.nodes, '/nodes', (node, path) => {
+        if (node.labelPlacement)
+            unsupported(`${path}/labelPlacement`, 'Node label placement is not supported');
+        if (node.classifier)
+            unsupported(`${path}/classifier`, 'Classifier semantics require a class-aware layout adapter');
+        if (node.position)
+            unsupported(`${path}/position`, 'Exact authored positions are not supported');
+        if (node.pinned)
+            unsupported(`${path}/pinned`, 'Pinned positions are not supported');
+        if (node.children?.length && node.dimensions) {
+            unsupported(`${path}/dimensions`, 'Fixed outer dimensions for containers are not supported');
+        }
+        const layout = node.layoutOptions;
+        if (!layered && node.ports?.length)
+            unsupported(`${path}/ports`, `Algorithm "${algorithm}" does not preserve authored port sides`);
+        if (layout?.portAlignment)
+            unsupported(`${path}/layoutOptions/portAlignment`, 'Port alignment is not supported');
+        if (layout?.minimumSize)
+            unsupported(`${path}/layoutOptions/minimumSize`, 'Minimum size is not supported');
+        if (layout?.sizeConstraints?.length)
+            unsupported(`${path}/layoutOptions/sizeConstraints`, 'Size constraints are not supported');
+        if (node.ports?.length && layout?.portConstraints === 'FREE') {
+            unsupported(`${path}/layoutOptions/portConstraints`, 'FREE would ignore authored port sides');
+        }
+        if (layout?.portConstraints === 'FIXED_ORDER' || layout?.portConstraints === 'FIXED_POS') {
+            unsupported(`${path}/layoutOptions/portConstraints`, `${layout.portConstraints} is not supported`);
+        }
+        node.ports?.forEach((port, index) => {
+            if (port.position !== undefined) {
+                unsupported(`${path}/ports/${index}/position`, 'Exact port position is not supported');
+            }
+        });
+    });
+    graph.edges.forEach((edge, index) => {
+        if (edge.routeIntent)
+            unsupported(`/edges/${index}/routeIntent`, 'Authored route intent is not supported');
+        if (edge.labelPlacement)
+            unsupported(`/edges/${index}/labelPlacement`, 'Edge label placement is not supported');
+        if (edge.style?.routing)
+            unsupported(`/edges/${index}/style/routing`, 'Per-edge routing is not supported');
+        if (edge.sourceEnd)
+            unsupported(`/edges/${index}/sourceEnd`, 'Relationship-end semantics are not supported');
+        if (edge.targetEnd)
+            unsupported(`/edges/${index}/targetEnd`, 'Relationship-end semantics are not supported');
+    });
+    return errors;
+}
+function normalizeOptions(graph, raw) {
+    const authoredSpacing = graph.layoutOptions?.spacing;
+    return {
+        nodeWidth: numberOption(raw.nodeWidth, DEFAULT_OPTIONS.nodeWidth),
+        nodeHeight: numberOption(raw.nodeHeight, DEFAULT_OPTIONS.nodeHeight),
+        horizontalSpacing: numberOption(raw.horizontalSpacing, authoredSpacing?.nodeNode ?? DEFAULT_OPTIONS.horizontalSpacing),
+        verticalSpacing: numberOption(raw.verticalSpacing, authoredSpacing?.layerSpacing ?? DEFAULT_OPTIONS.verticalSpacing),
+        direction: (typeof raw.direction === 'string'
+            ? raw.direction
+            : graph.layoutOptions?.direction ?? DEFAULT_OPTIONS.direction),
+    };
+}
+function numberOption(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
 }
-// ============================================================================
-// Conversion Functions
-// ============================================================================
-/**
- * Convert Graph-IR to ELK graph format
- */
 export function graphIRToELK(ir, options, algorithm = 'layered') {
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    // Build root ELK graph
+    const identifiers = buildElkIdentifiers(ir);
+    const authoredSpacing = ir.layoutOptions?.spacing;
+    const normalized = {
+        ...DEFAULT_OPTIONS,
+        ...options,
+        horizontalSpacing: options.horizontalSpacing ??
+            authoredSpacing?.nodeNode ?? DEFAULT_OPTIONS.horizontalSpacing,
+        verticalSpacing: options.verticalSpacing ??
+            authoredSpacing?.layerSpacing ?? DEFAULT_OPTIONS.verticalSpacing,
+        direction: options.direction ?? ir.layoutOptions?.direction ?? DEFAULT_OPTIONS.direction,
+    };
     const elkLayoutOptions = {
-        'elk.algorithm': ALGORITHM_MAPPING[algorithm] || ALGORITHM_MAPPING.layered,
-        'elk.direction': DIRECTION_MAPPING[opts.direction] || 'RIGHT',
-        'elk.spacing.nodeNode': String(opts.horizontalSpacing),
-        'elk.layered.spacing.nodeNodeBetweenLayers': String(opts.verticalSpacing),
+        'elk.algorithm': ALGORITHM_MAPPING[algorithm] ?? ALGORITHM_MAPPING.layered,
+        'elk.direction': normalized.direction,
+        'elk.spacing.nodeNode': String(normalized.horizontalSpacing),
+        'elk.layered.spacing.nodeNodeBetweenLayers': String(normalized.verticalSpacing),
+        'elk.hierarchyHandling': 'INCLUDE_CHILDREN',
     };
-    const elkGraph = {
-        id: 'root',
+    if (authoredSpacing?.nodeEdge !== undefined) {
+        elkLayoutOptions['elk.spacing.edgeNode'] = String(authoredSpacing.nodeEdge);
+    }
+    if (authoredSpacing?.edgeEdge !== undefined) {
+        elkLayoutOptions['elk.spacing.edgeEdge'] = String(authoredSpacing.edgeEdge);
+    }
+    if (ir.layoutOptions?.edgeRouting) {
+        elkLayoutOptions['elk.edgeRouting'] = EDGE_ROUTING_MAPPING[ir.layoutOptions.edgeRouting];
+    }
+    const root = {
+        id: ELK_ROOT_ID,
         layoutOptions: elkLayoutOptions,
-        children: ir.nodes.map((node) => convertNodeToELK(node, opts)),
-        edges: ir.edges.map((edge) => convertEdgeToELK(edge)),
+        children: ir.nodes.map((node) => nodeToELK(node, normalized, identifiers)),
+        edges: [],
     };
-    return elkGraph;
+    distributeEdges(ir, root, identifiers);
+    return root;
 }
-/**
- * Convert a Graph-IR node to ELK format
- */
-function convertNodeToELK(node, opts) {
-    const elkNode = {
-        id: node.id,
-        width: opts.nodeWidth,
-        height: opts.nodeHeight,
-        labels: node.label ? [{ text: node.label }] : undefined,
+function buildElkIdentifiers(ir) {
+    const identifiers = {
+        nodes: new Map(),
+        ports: new Map(),
+        edges: new Map(),
     };
-    // Convert ports
-    if (node.ports && node.ports.length > 0) {
-        elkNode.ports = node.ports.map((port) => convertPortToELK(port));
+    let nodeIndex = 0;
+    let portIndex = 0;
+    visitNodes(ir.nodes, '/nodes', (node) => {
+        identifiers.nodes.set(node.id, `n${nodeIndex++}`);
+        for (const port of node.ports ?? []) {
+            identifiers.ports.set(portKey(node.id, port.id), `p${portIndex++}`);
+        }
+    });
+    ir.edges.forEach((edge, index) => identifiers.edges.set(edge.id, `e${index}`));
+    return identifiers;
+}
+function distributeEdges(ir, root, identifiers) {
+    const ancestorPaths = new Map();
+    collectAncestorPaths(ir.nodes, ancestorPaths);
+    const elkNodes = new Map();
+    collectElkNodes(root, elkNodes);
+    for (const edge of ir.edges) {
+        const sourceAncestors = ancestorPaths.get(edge.source) ?? [];
+        const targetAncestors = ancestorPaths.get(edge.target) ?? [];
+        let owner = root;
+        for (let index = 0; index < Math.min(sourceAncestors.length, targetAncestors.length); index += 1) {
+            if (sourceAncestors[index] !== targetAncestors[index])
+                break;
+            owner = elkNodes.get(identifiers.nodes.get(sourceAncestors[index])) ?? root;
+        }
+        owner.edges = [...(owner.edges ?? []), edgeToELK(edge, identifiers)];
+    }
+}
+function collectAncestorPaths(nodes, target, ancestors = []) {
+    for (const node of nodes) {
+        target.set(node.id, ancestors);
+        if (node.children) {
+            collectAncestorPaths(node.children, target, [...ancestors, node.id]);
+        }
+    }
+}
+function hasNestedNodes(nodes) {
+    return nodes.some((node) => Boolean(node.children?.length));
+}
+function nodeToELK(node, options, identifiers) {
+    const hasChildren = Boolean(node.children?.length);
+    const elkNode = { id: identifiers.nodes.get(node.id) };
+    if (!hasChildren) {
+        elkNode.width = node.dimensions?.width ?? options.nodeWidth;
+        elkNode.height = node.dimensions?.height ?? options.nodeHeight;
+    }
+    if (node.label)
+        elkNode.labels = [{ text: node.label }];
+    if (node.ports?.length) {
+        elkNode.ports = node.ports.map((port) => portToELK(node.id, port, identifiers));
         elkNode.layoutOptions = {
             ...elkNode.layoutOptions,
             'elk.portConstraints': 'FIXED_SIDE',
         };
     }
-    // Convert children (compound nodes)
-    if (node.children && node.children.length > 0) {
-        elkNode.children = node.children.map((child) => convertNodeToELK(child, opts));
+    if (hasChildren) {
+        elkNode.children = node.children.map((child) => nodeToELK(child, options, identifiers));
+        const padding = node.layoutOptions?.padding ?? {};
         elkNode.layoutOptions = {
             ...elkNode.layoutOptions,
-            'elk.padding': '[top=10,left=10,bottom=10,right=10]',
+            'elk.hierarchyHandling': 'INCLUDE_CHILDREN',
+            'elk.padding': `[top=${padding.top ?? 0},left=${padding.left ?? 0},bottom=${padding.bottom ?? 0},right=${padding.right ?? 0}]`,
         };
     }
     return elkNode;
 }
-/**
- * Convert a Graph-IR port to ELK format
- */
-function convertPortToELK(port) {
-    const sideMapping = {
-        NORTH: 'NORTH',
-        SOUTH: 'SOUTH',
-        EAST: 'EAST',
-        WEST: 'WEST',
-    };
+function portToELK(ownerId, port, identifiers) {
     return {
-        id: port.id,
-        layoutOptions: {
-            'elk.port.side': sideMapping[port.side] || 'EAST',
-        },
-    };
-}
-/**
- * Convert a Graph-IR edge to ELK format
- */
-function convertEdgeToELK(edge) {
-    const elkEdge = {
-        id: edge.id,
-        sources: [edge.sourcePort ? `${edge.source}.${edge.sourcePort}` : edge.source],
-        targets: [edge.targetPort ? `${edge.target}.${edge.targetPort}` : edge.target],
+        id: identifiers.ports.get(portKey(ownerId, port.id)),
+        width: 1,
+        height: 1,
+        layoutOptions: { 'elk.port.side': port.side },
     };
-    return elkEdge;
 }
-/**
- * Convert ELK result back to Graph-IR format
- */
-export function elkToGraphIR(elkResult, originalIR, algorithm) {
-    // Build lookup for ELK nodes
-    const elkNodeMap = new Map();
-    collectElkNodes(elkResult, elkNodeMap);
-    // Build lookup for original edges
-    const originalEdgeMap = new Map(originalIR.edges.map((e) => [e.id, e]));
-    // Convert nodes
-    const layoutedNodes = convertElkNodesToGraphIR(originalIR.nodes, elkNodeMap);
-    // Convert edges
-    const layoutedEdges = convertElkEdgesToGraphIR(elkResult.edges || [], originalEdgeMap);
+function edgeToELK(edge, identifiers) {
     return {
-        ...originalIR,
-        nodes: layoutedNodes,
-        edges: layoutedEdges,
-        layout: {
-            width: elkResult.width || 0,
-            height: elkResult.height || 0,
-            algorithm,
-        },
+        id: identifiers.edges.get(edge.id),
+        sources: [edge.sourcePort
+                ? identifiers.ports.get(portKey(edge.source, edge.sourcePort))
+                : identifiers.nodes.get(edge.source)],
+        targets: [edge.targetPort
+                ? identifiers.ports.get(portKey(edge.target, edge.targetPort))
+                : identifiers.nodes.get(edge.target)],
     };
 }
-/**
- * Collect all ELK nodes into a map for quick lookup
- */
-function collectElkNodes(node, map) {
-    if (node.id !== 'root') {
-        map.set(node.id, node);
-    }
-    if (node.children) {
-        for (const child of node.children) {
-            collectElkNodes(child, map);
-        }
-    }
+function portKey(nodeId, portId) {
+    return JSON.stringify([nodeId, portId]);
 }
-/**
- * Convert ELK nodes back to Graph-IR nodes with layout info
- */
-function convertElkNodesToGraphIR(originalNodes, elkNodeMap) {
-    return originalNodes.map((node) => {
-        const elkNode = elkNodeMap.get(node.id);
-        // Build the layouted node without children first
-        const { children: _, ...nodeWithoutChildren } = node;
-        const layoutedNode = {
-            ...nodeWithoutChildren,
-            layout: {
-                x: elkNode?.x ?? 0,
-                y: elkNode?.y ?? 0,
-                width: elkNode?.width ?? 150,
-                height: elkNode?.height ?? 50,
-            },
-        };
-        // Handle children recursively
-        if (node.children && node.children.length > 0) {
-            layoutedNode.children = convertElkNodesToGraphIR(node.children, elkNodeMap);
+export function verifyResolvedLayout(graph, root) {
+    const errors = [];
+    const identifiers = buildElkIdentifiers(graph);
+    const elkNodes = new Map();
+    const elkParents = new Map();
+    collectElkNodes(root, elkNodes, elkParents);
+    const authoredParents = new Map();
+    collectAuthoredParents(graph.nodes, authoredParents);
+    const elkEdges = new Map();
+    collectElkEdges(root, elkEdges);
+    if (!finiteNonnegative(root.width) || !finiteNonnegative(root.height)) {
+        errors.push({
+            code: 'LAYOUT_VERIFICATION_FAILED',
+            path: '',
+            message: 'Resolved graph bounds must be finite and nonnegative',
+        });
+    }
+    visitNodes(graph.nodes, '/nodes', (node, path) => {
+        const resolved = elkNodes.get(identifiers.nodes.get(node.id));
+        if (!resolved) {
+            errors.push({ code: 'LAYOUT_VERIFICATION_FAILED', path, message: 'Layout omitted node' });
+            return;
         }
-        return layoutedNode;
-    });
-}
-/**
- * Convert ELK edges back to Graph-IR edges with routing info
- */
-function convertElkEdgesToGraphIR(elkEdges, originalEdgeMap) {
-    return elkEdges.map((elkEdge) => {
-        const originalEdge = originalEdgeMap.get(elkEdge.id);
-        // Extract routing points from sections
-        const points = [];
-        if (elkEdge.sections) {
-            for (const section of elkEdge.sections) {
-                points.push(section.startPoint);
-                if (section.bendPoints) {
-                    points.push(...section.bendPoints);
+        if (!finite(resolved.x) || !finite(resolved.y) ||
+            !finiteNonnegative(resolved.width) || !finiteNonnegative(resolved.height)) {
+            errors.push({
+                code: 'LAYOUT_VERIFICATION_FAILED',
+                path,
+                message: 'Resolved node rectangle must be finite with nonnegative size',
+            });
+        }
+        const resolvedParent = elkParents.get(identifiers.nodes.get(node.id));
+        const expectedParent = authoredParents.get(node.id);
+        const expectedElkParent = expectedParent === undefined
+            ? undefined
+            : identifiers.nodes.get(expectedParent);
+        if (resolvedParent !== expectedElkParent) {
+            errors.push({
+                code: 'LAYOUT_VERIFICATION_FAILED',
+                path,
+                message: 'Resolved containment differs from authored children',
+            });
+        }
+        if (!node.children?.length && node.dimensions) {
+            if (resolved.width !== node.dimensions.width || resolved.height !== node.dimensions.height) {
+                errors.push({
+                    code: 'LAYOUT_VERIFICATION_FAILED',
+                    path: `${path}/dimensions`,
+                    message: 'Resolved leaf outer size differs from authored fixed dimensions',
+                });
+            }
+        }
+        if (node.children?.length && node.layoutOptions?.padding) {
+            const padding = node.layoutOptions.padding;
+            for (const child of resolved.children ?? []) {
+                const x = child.x ?? 0;
+                const y = child.y ?? 0;
+                const width = child.width ?? 0;
+                const height = child.height ?? 0;
+                if (x < (padding.left ?? 0) ||
+                    y < (padding.top ?? 0) ||
+                    x + width > (resolved.width ?? 0) - (padding.right ?? 0) ||
+                    y + height > (resolved.height ?? 0) - (padding.bottom ?? 0)) {
+                    errors.push({
+                        code: 'LAYOUT_VERIFICATION_FAILED',
+                        path: `${path}/layoutOptions/padding`,
+                        message: 'Resolved child bounds violate authored container padding',
+                    });
+                    break;
                 }
-                points.push(section.endPoint);
             }
         }
+        node.ports?.forEach((port, portIndex) => {
+            const resolvedPort = resolved.ports?.find((candidate) => candidate.id === identifiers.ports.get(portKey(node.id, port.id)));
+            const portPath = `${path}/ports/${portIndex}`;
+            if (!resolvedPort) {
+                errors.push({
+                    code: 'LAYOUT_VERIFICATION_FAILED',
+                    path: portPath,
+                    message: 'Layout omitted authored port',
+                });
+                return;
+            }
+            if (!finite(resolvedPort.x) || !finite(resolvedPort.y) ||
+                !finiteNonnegative(resolvedPort.width) || !finiteNonnegative(resolvedPort.height)) {
+                errors.push({
+                    code: 'LAYOUT_VERIFICATION_FAILED',
+                    path: portPath,
+                    message: 'Resolved port geometry must be finite with nonnegative size',
+                });
+            }
+            if (!portRemainsOnSide(resolved, resolvedPort, port.side)) {
+                errors.push({
+                    code: 'LAYOUT_VERIFICATION_FAILED',
+                    path: `${portPath}/side`,
+                    message: `Resolved port is not on authored ${port.side} side`,
+                });
+            }
+        });
+    });
+    graph.edges.forEach((edge, index) => {
+        const resolved = elkEdges.get(identifiers.edges.get(edge.id));
+        if (!resolved) {
+            errors.push({
+                code: 'LAYOUT_VERIFICATION_FAILED',
+                path: `/edges/${index}`,
+                message: 'Layout omitted authored edge',
+            });
+            return;
+        }
+        const sections = resolved.edge.sections ?? [];
+        const points = sections.flatMap((section) => [
+            section.startPoint,
+            ...(section.bendPoints ?? []),
+            section.endPoint,
+        ]);
+        if (sections.length === 0 || points.some((point) => !finite(point.x) || !finite(point.y))) {
+            errors.push({
+                code: 'LAYOUT_VERIFICATION_FAILED',
+                path: `/edges/${index}`,
+                message: 'Resolved edge route must contain finite section points',
+            });
+        }
+    });
+    return errors;
+}
+function portRemainsOnSide(node, port, side) {
+    if (node.width === undefined || node.height === undefined ||
+        port.x === undefined || port.y === undefined)
+        return false;
+    const centerX = port.x + (port.width ?? 0) / 2;
+    const centerY = port.y + (port.height ?? 0) / 2;
+    const epsilonX = (port.width ?? 0) / 2 + 1e-6;
+    const epsilonY = (port.height ?? 0) / 2 + 1e-6;
+    const withinHorizontalSpan = centerX >= -1e-6 && centerX <= node.width + 1e-6;
+    const withinVerticalSpan = centerY >= -1e-6 && centerY <= node.height + 1e-6;
+    if (side === 'WEST')
+        return Math.abs(centerX) <= epsilonX && withinVerticalSpan;
+    if (side === 'EAST') {
+        return Math.abs(centerX - node.width) <= epsilonX && withinVerticalSpan;
+    }
+    if (side === 'NORTH')
+        return Math.abs(centerY) <= epsilonY && withinHorizontalSpan;
+    return Math.abs(centerY - node.height) <= epsilonY && withinHorizontalSpan;
+}
+export function elkToResolvedLayout(elkResult, original, algorithm) {
+    const identifiers = buildElkIdentifiers(original);
+    const nodeMap = new Map();
+    collectElkNodes(elkResult, nodeMap);
+    const edgeMap = new Map();
+    collectElkEdges(elkResult, edgeMap);
+    return {
+        graphId: original.id,
+        nodes: resolveNodes(original.nodes, nodeMap, identifiers),
+        edges: original.edges.flatMap((edge) => {
+            const resolved = edgeMap.get(identifiers.edges.get(edge.id)) ?? edgeMap.get(edge.id);
+            return resolved ? [resolveEdge(resolved, edge.id)] : [];
+        }),
+        bounds: { width: elkResult.width ?? 0, height: elkResult.height ?? 0 },
+        algorithm,
+    };
+}
+function resolveNodes(nodes, map, identifiers) {
+    return nodes.map((node) => {
+        const resolved = map.get(identifiers?.nodes.get(node.id) ?? node.id) ?? map.get(node.id);
         return {
-            ...originalEdge,
-            id: elkEdge.id,
-            source: originalEdge?.source ?? '',
-            target: originalEdge?.target ?? '',
-            layout: {
-                points,
+            id: node.id,
+            rectangle: {
+                x: resolved?.x ?? 0,
+                y: resolved?.y ?? 0,
+                width: resolved?.width ?? 0,
+                height: resolved?.height ?? 0,
             },
+            children: node.children ? resolveNodes(node.children, map, identifiers) : undefined,
         };
     });
 }
+function resolveEdge(collected, authoredId) {
+    const { edge, offsetX, offsetY } = collected;
+    const points = [];
+    for (const section of edge.sections ?? []) {
+        points.push(absolutePoint(section.startPoint, offsetX, offsetY));
+        points.push(...(section.bendPoints ?? []).map((point) => absolutePoint(point, offsetX, offsetY)));
+        points.push(absolutePoint(section.endPoint, offsetX, offsetY));
+    }
+    return { id: authoredId, points };
+}
+function absolutePoint(point, offsetX, offsetY) {
+    return { x: point.x + offsetX, y: point.y + offsetY };
+}
+function collectElkNodes(node, target, parents, parentId) {
+    if (node.id !== ELK_ROOT_ID)
+        target.set(node.id, node);
+    if (node.id !== ELK_ROOT_ID)
+        parents?.set(node.id, parentId);
+    const childParent = node.id === ELK_ROOT_ID ? undefined : node.id;
+    for (const child of node.children ?? []) {
+        collectElkNodes(child, target, parents, childParent);
+    }
+}
+function collectElkEdges(node, target, parentX = 0, parentY = 0) {
+    const offsetX = parentX + (node.id === ELK_ROOT_ID ? 0 : node.x ?? 0);
+    const offsetY = parentY + (node.id === ELK_ROOT_ID ? 0 : node.y ?? 0);
+    for (const edge of node.edges ?? []) {
+        target.set(edge.id, { edge, offsetX, offsetY });
+    }
+    for (const child of node.children ?? []) {
+        collectElkEdges(child, target, offsetX, offsetY);
+    }
+}
+function finite(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function finiteNonnegative(value) {
+    return finite(value) && value >= 0;
+}
+function collectAuthoredParents(nodes, target, parentId) {
+    for (const node of nodes) {
+        target.set(node.id, parentId);
+        if (node.children)
+            collectAuthoredParents(node.children, target, node.id);
+    }
+}
+function visitNodes(nodes, base, visit) {
+    nodes.forEach((node, index) => {
+        const path = `${base}/${index}`;
+        visit(node, path);
+        if (node.children)
+            visitNodes(node.children, `${path}/children`, visit);
+    });
+}
+function failed(algorithm, errors) {
+    return { success: false, errors, algorithm };
+}
 //# sourceMappingURL=layout.js.map