@zvk/graphs 0.1.1 → 0.1.2

package/dist/diagnostics.js

@@ -1,14 +1,196 @@
+import { getGraphEdgeLabelOverlapDiagnostics } from "./layout/types.js";
 function isBlank(value) {
     return value === undefined || value.trim().length === 0;
 }
+const graphDiagnosticCategoryByCode = {
+    "missing-graph-title": "accessibility",
+    "duplicate-node-id": "structure",
+    "duplicate-edge-id": "structure",
+    "duplicate-group-id": "structure",
+    "dangling-edge-source": "structure",
+    "dangling-edge-target": "structure",
+    "unknown-node-group": "structure",
+    "self-loop": "structure",
+    "cycle-detected": "structure",
+    "missing-group-label": "accessibility",
+    "missing-node-label": "accessibility",
+    "missing-edge-label": "accessibility",
+    "missing-node-description": "accessibility",
+    "missing-edge-description": "accessibility",
+    "missing-graph-description": "accessibility",
+    "duplicate-node-label": "accessibility",
+    "duplicate-edge-label": "accessibility",
+    "fallback-disabled": "fallback",
+    "missing-node-position": "layout",
+    "missing-node-size": "layout",
+    "duplicate-node-position": "layout",
+    "large-graph": "performance",
+    "dense-graph": "performance",
+    "large-fallback-content": "performance",
+    "large-visible-label-count": "performance",
+    "high-route-complexity": "performance",
+    "large-metadata-summary": "performance",
+    "parallel-edge": "layout",
+    "edge-label-overlap-risk": "layout",
+    "empty-group": "structure",
+    "tree-multiple-roots": "tree",
+    "tree-multiple-parents": "tree",
+    "tree-disconnected": "tree"
+};
+const graphDiagnosticFixByCode = {
+    "missing-graph-title": {
+        target: "graph",
+        title: "Add a graph title",
+        description: "Provide a non-empty graph title so static SVG output has an accessible name."
+    },
+    "missing-graph-description": {
+        target: "graph",
+        title: "Add a graph description",
+        description: "Describe the graph purpose or structure for complex static graph output."
+    },
+    "missing-node-label": {
+        target: "node",
+        title: "Add a node label",
+        description: "Give each node a visible label that identifies the represented entity."
+    },
+    "missing-edge-label": {
+        target: "edge",
+        title: "Add an edge label",
+        description: "Provide an edge label or accessibility label that explains the relationship."
+    },
+    "dangling-edge-source": {
+        target: "edge",
+        title: "Use an existing source node",
+        description: "Update the edge source to reference a node that exists in this graph."
+    },
+    "dangling-edge-target": {
+        target: "edge",
+        title: "Use an existing target node",
+        description: "Update the edge target to reference a node that exists in this graph."
+    },
+    "duplicate-node-id": {
+        target: "node",
+        title: "Use unique node IDs",
+        description: "Every node ID must be unique so graph helpers can build deterministic indexes."
+    },
+    "duplicate-edge-id": {
+        target: "edge",
+        title: "Use unique edge IDs",
+        description: "Every edge ID must be unique so diagnostics, routes, and selections can address it."
+    },
+    "duplicate-group-id": {
+        target: "group",
+        title: "Use unique group IDs",
+        description: "Every group ID must be unique so static group bounds can be addressed deterministically."
+    },
+    "missing-group-label": {
+        target: "group",
+        title: "Add a group label",
+        description: "Provide a visible group label for static group containers and fallback details."
+    },
+    "unknown-node-group": {
+        target: "node",
+        title: "Reference an existing group",
+        description: "Update the node groupId to reference a group defined on this graph."
+    },
+    "empty-group": {
+        target: "group",
+        title: "Assign nodes to the group",
+        description: "A static group should either contain at least one node or provide explicit bounds."
+    },
+    "fallback-disabled": {
+        target: "graph",
+        title: "Provide equivalent fallback content",
+        description: "Render equivalent graph details elsewhere when disabling built-in fallback content."
+    },
+    "missing-node-position": {
+        target: "layout",
+        title: "Add a manual node position",
+        description: "Provide a node position or choose a layout fallback that can position missing nodes."
+    },
+    "missing-node-size": {
+        target: "layout",
+        title: "Add an explicit node size",
+        description: "Provide a node size when precise static layout and bounds are important."
+    },
+    "large-fallback-content": {
+        target: "graph",
+        title: "Simplify fallback content",
+        description: "Filter, collapse, or summarize the graph before rendering large static fallback content."
+    },
+    "large-visible-label-count": {
+        target: "graph",
+        title: "Reduce visible labels",
+        description: "Filter, collapse, or shorten visible labels before rendering dense static graph output."
+    },
+    "high-route-complexity": {
+        target: "layout",
+        title: "Simplify edge routes",
+        description: "Reduce routed edge complexity or split the graph into smaller focused views."
+    },
+    "large-metadata-summary": {
+        target: "graph",
+        title: "Reduce summary metadata",
+        description: "Keep only the most important summary metadata visible in static graph nodes."
+    },
+    "edge-label-overlap-risk": {
+        target: "layout",
+        title: "Separate edge labels",
+        description: "Adjust route hints, spacing, or label copy so estimated edge-label bounds do not overlap."
+    },
+    "tree-multiple-roots": {
+        target: "layout",
+        title: "Choose one tree root",
+        description: "Tree layout expects exactly one root or an explicit valid root ID."
+    },
+    "tree-multiple-parents": {
+        target: "layout",
+        title: "Use one parent per tree node",
+        description: "Tree layout requires each non-root node to have exactly one parent."
+    },
+    "tree-disconnected": {
+        target: "layout",
+        title: "Connect every tree node",
+        description: "Tree fallback and layout need every node reachable from the tree root."
+    }
+};
+function diagnosticCategory(code) {
+    return graphDiagnosticCategoryByCode[code];
+}
+function diagnosticFix(code) {
+    return graphDiagnosticFixByCode[code];
+}
 function diagnostic(input) {
-    return input;
+    const details = { ...(input.details ?? {}) };
+    if (input.nodeId !== undefined) {
+        details.nodeId = input.nodeId;
+    }
+    if (input.edgeId !== undefined) {
+        details.edgeId = input.edgeId;
+    }
+    const hasDetails = Object.keys(details).length > 0;
+    const fix = input.fix ?? diagnosticFix(input.code);
+    return {
+        code: input.code,
+        severity: input.severity,
+        message: input.message,
+        ...(input.nodeId !== undefined ? { nodeId: input.nodeId } : {}),
+        ...(input.edgeId !== undefined ? { edgeId: input.edgeId } : {}),
+        category: input.category ?? diagnosticCategory(input.code),
+        ...(hasDetails ? { details } : {}),
+        ...(fix !== undefined ? { fix } : {})
+    };
 }
 export function validateGraph(graph, options = {}) {
     const requireEdgeLabels = options.requireEdgeLabels ?? true;
+    const auditAccessibility = options.auditAccessibility ?? false;
     const diagnostics = [];
+    const groupIds = new Set();
+    const groupMemberCounts = new Map();
     const nodeIds = new Set();
     const edgeIds = new Set();
+    const nodeLabelByValue = new Map();
+    const edgeLabelByValue = new Map();
     if (isBlank(graph.title)) {
         diagnostics.push(diagnostic({
             code: "missing-graph-title",
@@ -16,6 +198,40 @@ export function validateGraph(graph, options = {}) {
             message: "Graph title is required for accessible graph output."
         }));
     }
+    if ((options.requireGraphDescription === true || auditAccessibility) && isBlank(graph.description)) {
+        diagnostics.push(diagnostic({
+            code: "missing-graph-description",
+            severity: options.requireGraphDescription === true ? "warning" : "info",
+            message: "Graph description is recommended for complex graph output."
+        }));
+    }
+    if (options.fallbackMode === "none") {
+        diagnostics.push(diagnostic({
+            code: "fallback-disabled",
+            severity: "warning",
+            message: "Fallback content is disabled; make sure equivalent graph details are available elsewhere."
+        }));
+    }
+    for (const group of graph.groups ?? []) {
+        if (groupIds.has(group.id)) {
+            diagnostics.push(diagnostic({
+                code: "duplicate-group-id",
+                severity: "error",
+                message: `Group ID "${group.id}" is used more than once.`,
+                details: { groupId: group.id }
+            }));
+        }
+        groupIds.add(group.id);
+        groupMemberCounts.set(group.id, 0);
+        if (isBlank(group.label)) {
+            diagnostics.push(diagnostic({
+                code: "missing-group-label",
+                severity: "error",
+                message: `Group "${group.id}" is missing a label.`,
+                details: { groupId: group.id }
+            }));
+        }
+    }
     for (const node of graph.nodes) {
         if (nodeIds.has(node.id)) {
             diagnostics.push(diagnostic({
@@ -26,6 +242,20 @@ export function validateGraph(graph, options = {}) {
             }));
         }
         nodeIds.add(node.id);
+        if (node.groupId && groupIds.size > 0) {
+            if (groupIds.has(node.groupId)) {
+                groupMemberCounts.set(node.groupId, (groupMemberCounts.get(node.groupId) ?? 0) + 1);
+            }
+            else {
+                diagnostics.push(diagnostic({
+                    code: "unknown-node-group",
+                    severity: "error",
+                    message: `Node "${node.id}" references unknown group "${node.groupId}".`,
+                    nodeId: node.id,
+                    details: { groupId: node.groupId }
+                }));
+            }
+        }
         if (isBlank(node.label)) {
             diagnostics.push(diagnostic({
                 code: "missing-node-label",
@@ -34,6 +264,43 @@ export function validateGraph(graph, options = {}) {
                 nodeId: node.id
             }));
         }
+        if (auditAccessibility &&
+            isBlank(node.summary) &&
+            isBlank(node.ariaDescription) &&
+            isBlank(node.accessibility?.description)) {
+            diagnostics.push(diagnostic({
+                code: "missing-node-description",
+                severity: "info",
+                message: `Node "${node.id}" has no summary or accessibility description.`,
+                nodeId: node.id
+            }));
+        }
+        const nodeLabel = node.label.trim();
+        if (options.warnDuplicateLabels === true && nodeLabel.length > 0) {
+            const existingNodeId = nodeLabelByValue.get(nodeLabel);
+            if (existingNodeId && existingNodeId !== node.id) {
+                diagnostics.push(diagnostic({
+                    code: "duplicate-node-label",
+                    severity: "warning",
+                    message: `Node label "${nodeLabel}" is used by more than one node.`,
+                    nodeId: node.id
+                }));
+            }
+            else {
+                nodeLabelByValue.set(nodeLabel, node.id);
+            }
+        }
+    }
+    for (const group of graph.groups ?? []) {
+        if ((groupMemberCounts.get(group.id) ?? 0) > 0 || (group.position && group.size)) {
+            continue;
+        }
+        diagnostics.push(diagnostic({
+            code: "empty-group",
+            severity: "warning",
+            message: `Group "${group.id}" has no member nodes or explicit bounds.`,
+            details: { groupId: group.id }
+        }));
     }
     for (const edge of graph.edges) {
         if (edgeIds.has(edge.id)) {
@@ -71,6 +338,29 @@ export function validateGraph(graph, options = {}) {
                 edgeId: edge.id
             }));
         }
+        if (auditAccessibility && isBlank(edge.summary) && isBlank(edge.accessibility?.description)) {
+            diagnostics.push(diagnostic({
+                code: "missing-edge-description",
+                severity: "info",
+                message: `Edge "${edge.id}" has no summary or accessibility description.`,
+                edgeId: edge.id
+            }));
+        }
+        const edgeLabel = (edge.label ?? edge.ariaLabel ?? "").trim();
+        if (options.warnDuplicateLabels === true && edgeLabel.length > 0) {
+            const existingEdgeId = edgeLabelByValue.get(edgeLabel);
+            if (existingEdgeId && existingEdgeId !== edge.id) {
+                diagnostics.push(diagnostic({
+                    code: "duplicate-edge-label",
+                    severity: "warning",
+                    message: `Edge label "${edgeLabel}" is used by more than one edge.`,
+                    edgeId: edge.id
+                }));
+            }
+            else {
+                edgeLabelByValue.set(edgeLabel, edge.id);
+            }
+        }
         if (edge.source === edge.target && options.allowSelfLoops !== true) {
             diagnostics.push(diagnostic({
                 code: "self-loop",
@@ -86,6 +376,65 @@ export function validateGraph(graph, options = {}) {
 export function hasGraphErrors(diagnostics) {
     return diagnostics.some((entry) => entry.severity === "error");
 }
+function diagnosticGroupValue(diagnosticEntry, groupBy) {
+    if (groupBy === "category") {
+        return diagnosticEntry.category ?? diagnosticCategory(diagnosticEntry.code);
+    }
+    return diagnosticEntry[groupBy];
+}
+export function countGraphDiagnostics(diagnostics, groupBy) {
+    const counts = {};
+    for (const diagnosticEntry of diagnostics) {
+        const key = diagnosticGroupValue(diagnosticEntry, groupBy);
+        counts[key] = (counts[key] ?? 0) + 1;
+    }
+    return counts;
+}
+export function groupGraphDiagnostics(diagnostics, groupBy) {
+    const groups = {};
+    for (const diagnosticEntry of diagnostics) {
+        const key = diagnosticGroupValue(diagnosticEntry, groupBy);
+        groups[key] = [...(groups[key] ?? []), diagnosticEntry];
+    }
+    return groups;
+}
+export function filterGraphDiagnostics(diagnostics, filter) {
+    return diagnostics.filter((diagnosticEntry) => {
+        if (filter.severity !== undefined && diagnosticEntry.severity !== filter.severity) {
+            return false;
+        }
+        if (filter.code !== undefined && diagnosticEntry.code !== filter.code) {
+            return false;
+        }
+        if (filter.category !== undefined && diagnosticGroupValue(diagnosticEntry, "category") !== filter.category) {
+            return false;
+        }
+        if (filter.nodeId !== undefined && diagnosticEntry.nodeId !== filter.nodeId) {
+            return false;
+        }
+        if (filter.edgeId !== undefined && diagnosticEntry.edgeId !== filter.edgeId) {
+            return false;
+        }
+        return true;
+    });
+}
+export function getGraphDiagnosticFixes(diagnostics) {
+    const fixes = [];
+    const seen = new Set();
+    for (const diagnosticEntry of diagnostics) {
+        const fix = diagnosticEntry.fix ?? diagnosticFix(diagnosticEntry.code);
+        if (!fix) {
+            continue;
+        }
+        const key = `${fix.target ?? ""}:${fix.title}:${fix.description ?? ""}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        fixes.push(fix);
+    }
+    return fixes;
+}
 export function formatGraphDiagnostic(diagnosticEntry) {
     const edge = diagnosticEntry.edgeId ? ` edge=${diagnosticEntry.edgeId}` : "";
     const node = diagnosticEntry.nodeId ? ` node=${diagnosticEntry.nodeId}` : "";
@@ -95,6 +444,10 @@ export function getNodeLabel(node) {
     return node.label.trim();
 }
 export function getEdgeAccessibleLabel(edge, graph) {
+    const accessibilityLabel = edge.accessibility?.label;
+    if (accessibilityLabel !== undefined && accessibilityLabel.trim().length > 0) {
+        return accessibilityLabel;
+    }
     const ariaLabel = edge.ariaLabel;
     if (ariaLabel !== undefined && ariaLabel.trim().length > 0) {
         return ariaLabel;
@@ -107,3 +460,226 @@ export function getEdgeAccessibleLabel(edge, graph) {
     const target = graph.nodes.find((node) => node.id === edge.target)?.label ?? edge.target;
     return `${source} connects to ${target}`;
 }
+function graphDensity(graph) {
+    const nodeCount = graph.nodes.length;
+    if (nodeCount <= 1) {
+        return 0;
+    }
+    return graph.edges.length / (nodeCount * (nodeCount - 1));
+}
+function hasVisibleMetadataValue(item) {
+    if (item.value === null) {
+        return true;
+    }
+    if (typeof item.value === "string") {
+        return item.value.trim().length > 0;
+    }
+    return true;
+}
+function countSummaryMetadata(metadata) {
+    return (metadata ?? []).filter((item) => item.visibility === "summary" && hasVisibleMetadataValue(item)).length;
+}
+function countNodeLabels(node) {
+    const labelLines = node.labelLines?.filter((line) => line.trim().length > 0);
+    if (labelLines && labelLines.length > 0) {
+        return labelLines.length;
+    }
+    return isBlank(node.label) ? 0 : 1;
+}
+function edgePoints(edge) {
+    const points = edge.points;
+    return Array.isArray(points) ? points : [];
+}
+function edgeRouteKind(edge) {
+    const routeKind = edge.routeKind;
+    return typeof routeKind === "string" ? routeKind : undefined;
+}
+export function estimateGraphRenderCost(graph) {
+    const groupCount = graph.groups?.length ?? 0;
+    const nodeCount = graph.nodes.length;
+    const edgeCount = graph.edges.length;
+    const fallbackRowCount = groupCount + nodeCount + edgeCount;
+    const visibleLabelCount = (graph.groups ?? []).filter((group) => !isBlank(group.label)).length +
+        graph.nodes.reduce((count, node) => count + countNodeLabels(node), 0) +
+        graph.edges.filter((edge) => !isBlank(edge.label)).length;
+    const metadataSummaryCount = (graph.groups ?? []).reduce((count, group) => count + countSummaryMetadata(group.metadata), 0) +
+        graph.nodes.reduce((count, node) => count + countSummaryMetadata(node.metadata), 0) +
+        graph.edges.reduce((count, edge) => count + countSummaryMetadata(edge.metadata), 0);
+    const routePointCount = graph.edges.reduce((count, edge) => count + edgePoints(edge).length, 0);
+    const routedEdgeCount = graph.edges.filter((edge) => edgePoints(edge).length > 0).length;
+    const complexRouteCount = graph.edges.filter((edge) => {
+        const points = edgePoints(edge);
+        const routeKind = edgeRouteKind(edge);
+        return points.length > 2 || (routeKind !== undefined && routeKind !== "straight");
+    }).length;
+    const roughSvgElementCount = 1 +
+        groupCount * 2 +
+        nodeCount * 3 +
+        edgeCount * 3 +
+        visibleLabelCount +
+        metadataSummaryCount +
+        routePointCount;
+    return {
+        complexRouteCount,
+        edgeCount,
+        fallbackRowCount,
+        groupCount,
+        metadataSummaryCount,
+        nodeCount,
+        roughSvgElementCount,
+        routedEdgeCount,
+        routePointCount,
+        visibleLabelCount
+    };
+}
+function renderCostThresholdDiagnostic(input) {
+    if (input.threshold === undefined || input.count < input.threshold) {
+        return undefined;
+    }
+    return diagnostic({
+        code: input.code,
+        severity: "warning",
+        message: input.message,
+        details: {
+            [input.detailKey]: input.count,
+            roughSvgElementCount: input.roughSvgElementCount,
+            threshold: input.threshold
+        }
+    });
+}
+export function validateGraphLayout(graph, options = {}) {
+    const diagnostics = [];
+    const warnLargeGraphAt = options.warnLargeGraphAt;
+    const warnDenseGraphAt = options.warnDenseGraphAt;
+    const renderCost = estimateGraphRenderCost(graph);
+    if (warnLargeGraphAt !== undefined && graph.nodes.length >= warnLargeGraphAt) {
+        diagnostics.push(diagnostic({
+            code: "large-graph",
+            severity: "warning",
+            message: `Graph has ${graph.nodes.length} nodes; consider simplifying static SVG output for large graphs.`
+        }));
+    }
+    const density = graphDensity(graph);
+    if (warnDenseGraphAt !== undefined && density >= warnDenseGraphAt) {
+        diagnostics.push(diagnostic({
+            code: "dense-graph",
+            severity: "warning",
+            message: `Graph edge density ${density.toFixed(2)} may produce cluttered static layouts.`
+        }));
+    }
+    diagnostics.push(...[
+        renderCostThresholdDiagnostic({
+            code: "large-fallback-content",
+            count: renderCost.fallbackRowCount,
+            detailKey: "fallbackRowCount",
+            message: `Graph fallback content has ${renderCost.fallbackRowCount} rows; consider filtering, collapsing, or summarizing static output.`,
+            roughSvgElementCount: renderCost.roughSvgElementCount,
+            threshold: options.warnFallbackRowsAt
+        }),
+        renderCostThresholdDiagnostic({
+            code: "large-visible-label-count",
+            count: renderCost.visibleLabelCount,
+            detailKey: "visibleLabelCount",
+            message: `Graph has ${renderCost.visibleLabelCount} visible labels; consider focused views or shorter labels for static output.`,
+            roughSvgElementCount: renderCost.roughSvgElementCount,
+            threshold: options.warnVisibleLabelsAt
+        }),
+        renderCostThresholdDiagnostic({
+            code: "high-route-complexity",
+            count: renderCost.routePointCount,
+            detailKey: "routePointCount",
+            message: `Graph routes use ${renderCost.routePointCount} route points across ${renderCost.routedEdgeCount} routed edges.`,
+            roughSvgElementCount: renderCost.roughSvgElementCount,
+            threshold: options.warnRoutePointsAt
+        }),
+        renderCostThresholdDiagnostic({
+            code: "large-metadata-summary",
+            count: renderCost.metadataSummaryCount,
+            detailKey: "metadataSummaryCount",
+            message: `Graph has ${renderCost.metadataSummaryCount} visible summary metadata entries; keep static summaries focused.`,
+            roughSvgElementCount: renderCost.roughSvgElementCount,
+            threshold: options.warnMetadataSummariesAt
+        })
+    ].filter((entry) => entry !== undefined));
+    if (options.warnDuplicatePositions === true) {
+        const seenPositions = new Map();
+        for (const node of graph.nodes) {
+            if (!node.position) {
+                continue;
+            }
+            const key = `${node.position.x}:${node.position.y}`;
+            const existingNodeId = seenPositions.get(key);
+            if (existingNodeId && existingNodeId !== node.id) {
+                diagnostics.push(diagnostic({
+                    code: "duplicate-node-position",
+                    severity: "warning",
+                    message: `Node "${node.id}" shares position (${node.position.x}, ${node.position.y}) with node "${existingNodeId}".`,
+                    nodeId: node.id
+                }));
+            }
+            else {
+                seenPositions.set(key, node.id);
+            }
+        }
+    }
+    if (options.warnMissingSizes === true) {
+        for (const node of graph.nodes) {
+            if (!node.size) {
+                diagnostics.push(diagnostic({
+                    code: "missing-node-size",
+                    severity: "warning",
+                    message: `Node "${node.id}" is missing an explicit size; layout will use the default node size.`,
+                    nodeId: node.id
+                }));
+            }
+        }
+    }
+    if (options.warnParallelEdges === true) {
+        const seenEdges = new Map();
+        for (const edge of graph.edges) {
+            const key = `${edge.source}->${edge.target}`;
+            const existingEdgeId = seenEdges.get(key);
+            if (existingEdgeId && existingEdgeId !== edge.id) {
+                diagnostics.push(diagnostic({
+                    code: "parallel-edge",
+                    severity: "warning",
+                    message: `Edge "${edge.id}" is parallel to edge "${existingEdgeId}".`,
+                    edgeId: edge.id
+                }));
+            }
+            else {
+                seenEdges.set(key, edge.id);
+            }
+        }
+    }
+    if (options.warnSelfLoops === true) {
+        for (const edge of graph.edges) {
+            if (edge.source === edge.target) {
+                diagnostics.push(diagnostic({
+                    code: "self-loop",
+                    severity: "warning",
+                    message: `Edge "${edge.id}" is a self-loop; static layouts render it with a simple loop route.`,
+                    nodeId: edge.source,
+                    edgeId: edge.id
+                }));
+            }
+        }
+    }
+    if (options.warnEdgeLabelOverlaps === true) {
+        diagnostics.push(...getGraphEdgeLabelOverlapDiagnostics(graph));
+    }
+    return diagnostics;
+}
+export function createGraphHealthReport(graph, options = {}) {
+    const diagnostics = [...validateGraph(graph, options), ...validateGraphLayout(graph, options)];
+    return {
+        diagnostics,
+        errors: filterGraphDiagnostics(diagnostics, { severity: "error" }),
+        warnings: filterGraphDiagnostics(diagnostics, { severity: "warning" }),
+        info: filterGraphDiagnostics(diagnostics, { severity: "info" }),
+        countsByCode: countGraphDiagnostics(diagnostics, "code"),
+        countsByCategory: countGraphDiagnostics(diagnostics, "category"),
+        canRenderStaticSvg: !hasGraphErrors(diagnostics),
+        shouldRenderFallback: options.fallbackMode !== "none"
+    };
+}

package/dist/index.d.ts

@@ -2,4 +2,5 @@ export * from "./algorithms.js";
 export * from "./diagnostics.js";
 export * from "./layout/index.js";
 export * from "./model.js";
+export * from "./serialization.js";
 export * from "./svg.js";

package/dist/index.js

@@ -2,4 +2,5 @@ export * from "./algorithms.js";
 export * from "./diagnostics.js";
 export * from "./layout/index.js";
 export * from "./model.js";
+export * from "./serialization.js";
 export * from "./svg.js";

package/dist/layout/dag.d.ts

@@ -1,9 +1,12 @@
+import { type ValidateGraphLayoutOptions } from "../diagnostics.js";
 import type { GraphModel, GraphSize } from "../model.js";
-import { type GraphLayoutResult } from "./types.js";
-export interface DagLayeredLayoutOptions {
+import { type GraphEdgesWithPointsOptions, type GraphLayoutResult } from "./types.js";
+export interface DagLayeredLayoutOptions extends ValidateGraphLayoutOptions, GraphEdgesWithPointsOptions {
     readonly direction?: "top-bottom" | "left-right";
     readonly nodeSize?: GraphSize;
     readonly nodeGap?: number;
+    readonly orderByNodeId?: Readonly<Record<string, number>>;
+    readonly rankByNodeId?: Readonly<Record<string, number>>;
     readonly rankGap?: number;
     readonly rankStrategy?: "longest-path" | "source-depth";
 }