@zvk/graphs 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @zvk/graphs Changelog
+
+## 0.1.0
+
+- Initial package scaffold for accessible SVG-first graph model, diagnostics,
+  algorithms, deterministic layout, static SVG rendering, and graph stylesheet
+  contracts.
+- Documented zero-runtime-dependency, SSR-safe, accessibility-first package
+  boundaries and repo-local `use-zvk-graphs` maintenance guidance.

package/LICENSE.md

@@ -0,0 +1 @@
+See the repository license for usage terms.

package/README.md

@@ -0,0 +1,86 @@
+# @zvk/graphs
+
+Accessible SVG-first node and edge graph primitives for ZVK applications.
+
+`@zvk/graphs` is for relationship visualizations: dependency graphs, workflows,
+state machines, lineage views, and topology maps. It is not a charting package
+and should stay deterministic, SSR-safe, and zero-runtime-dependency.
+
+## Public Imports
+
+Use the package root and documented subpaths only:
+
+```ts
+import "@zvk/graphs/styles.css";
+```
+
+Public subpaths are `@zvk/graphs`, `@zvk/graphs/model`,
+`@zvk/graphs/diagnostics`, `@zvk/graphs/algorithms`, `@zvk/graphs/layout`,
+`@zvk/graphs/svg`, `@zvk/graphs/styles.css`, and
+`@zvk/graphs/package.json`.
+
+Do not import from `src`, `dist`, package internals, or private relative paths.
+Treat `packages/graphs/package.json` `exports` as the public API contract.
+
+## Styles
+
+Import graph styles once from the public stylesheet:
+
+```ts
+import "@zvk/graphs/styles.css";
+```
+
+When an app also uses `@zvk/ui`, import UI styles first so graph CSS variables
+can inherit UI tokens:
+
+```ts
+import "@zvk/ui/styles.css";
+import "@zvk/graphs/styles.css";
+```
+
+The graph package should own `--zvk-graphs-*` variables, `.zvk-graphs*` classes,
+and graph-specific `data-*` attributes. It may fall back to `--zvk-ui-*` tokens
+when present, but package source must not import `@zvk/ui` JavaScript or
+component internals for styling.
+
+## Accessibility And SSR
+
+- Require a graph title, node labels, and meaningful edge labels or derivable
+  edge descriptions.
+- Render SVG as a complex image by default: stable title/description IDs,
+  `aria-labelledby`/`aria-describedby`, and structured fallback content.
+- Do not rely on color alone for status, selection, errors, or direction.
+- Keep focus, selection, and keyboard behavior opt-in and fully documented.
+- Keep root imports and static SVG rendering SSR-safe. Do not read `window`,
+  `document`, `ResizeObserver`, SVG measurements, or browser layout at module
+  initialization.
+- Use deterministic IDs and layout output. Do not use random IDs, timestamps, or
+  DOM measurement for default layout.
+
+## Package Boundaries
+
+`@zvk/graphs` owns:
+
+- serializable graph model types;
+- graph diagnostics and validation reports;
+- pure graph algorithms such as adjacency, degree, cycle, topological,
+  reachability, component, and tree helpers;
+- deterministic manual, tree, and narrow DAG layout utilities;
+- static React/SVG graph rendering;
+- graph CSS and token inheritance contracts.
+
+Applications own product data, filtering, search, detail panels, routing to
+domain entities, and any editor or viewport state. Use `@zvk/charts` for axes,
+scales, numeric series, legends, bars, lines, areas, scatterplots, sparklines,
+pie/donut charts, and other quantitative visualization.
+
+## Anti-Goals
+
+- No runtime dependencies.
+- No D3, Dagre, ELK, Cytoscape, React Flow, Mermaid, Graphviz, Pixi, canvas,
+  WebGL, CSS-in-JS, Tailwind-only assumptions, or runtime class helpers.
+- No graph editor, drag editing, pan/zoom, minimap, force simulation,
+  orthogonal routing, edge bundling, compound-node layout, or `foreignObject`
+  node rendering in the core package.
+- No unlabeled graph nodes, inaccessible edge relationships, color-only states,
+  or browser-only behavior leaking into SSR-safe imports.

package/dist/algorithms.d.ts

@@ -0,0 +1,27 @@
+import type { GraphDiagnostic } from "./diagnostics.js";
+import type { GraphEdge, GraphId, GraphModel, GraphNode } from "./model.js";
+export interface GraphIndex {
+    readonly nodeById: ReadonlyMap<GraphId, GraphNode>;
+    readonly edgeById: ReadonlyMap<GraphId, GraphEdge>;
+    readonly outgoingByNodeId: ReadonlyMap<GraphId, readonly GraphEdge[]>;
+    readonly incomingByNodeId: ReadonlyMap<GraphId, readonly GraphEdge[]>;
+}
+export interface GraphDegree {
+    readonly in: number;
+    readonly out: number;
+    readonly total: number;
+}
+export declare function createGraphIndex(graph: GraphModel): GraphIndex;
+export declare function getGraphDegrees(graph: GraphModel): Record<string, GraphDegree>;
+export declare function detectGraphCycle(graph: GraphModel): readonly GraphId[] | null;
+export interface TopologicalSortResult {
+    readonly nodeIds: readonly GraphId[];
+    readonly diagnostics: readonly GraphDiagnostic[];
+}
+export declare function topologicalSortGraph(graph: GraphModel): TopologicalSortResult;
+export declare function getReachableNodeIds(graph: GraphModel, startId: GraphId): readonly GraphId[];
+export declare function getWeaklyConnectedComponents(graph: GraphModel): readonly (readonly GraphId[])[];
+export interface ValidateTreeGraphOptions {
+    readonly rootId?: GraphId;
+}
+export declare function validateTreeGraph(graph: GraphModel, options?: ValidateTreeGraphOptions): GraphDiagnostic[];

package/dist/algorithms.js

@@ -0,0 +1,232 @@
+export function createGraphIndex(graph) {
+    const nodeById = new Map();
+    const edgeById = new Map();
+    const outgoingByNodeId = new Map();
+    const incomingByNodeId = new Map();
+    for (const node of graph.nodes) {
+        if (!nodeById.has(node.id)) {
+            nodeById.set(node.id, node);
+            outgoingByNodeId.set(node.id, []);
+            incomingByNodeId.set(node.id, []);
+        }
+    }
+    for (const edge of graph.edges) {
+        if (!edgeById.has(edge.id)) {
+            edgeById.set(edge.id, edge);
+        }
+        outgoingByNodeId.get(edge.source)?.push(edge);
+        incomingByNodeId.get(edge.target)?.push(edge);
+    }
+    return {
+        nodeById,
+        edgeById,
+        outgoingByNodeId,
+        incomingByNodeId
+    };
+}
+export function getGraphDegrees(graph) {
+    const index = createGraphIndex(graph);
+    const degrees = {};
+    for (const node of graph.nodes) {
+        const incoming = index.incomingByNodeId.get(node.id)?.length ?? 0;
+        const outgoing = index.outgoingByNodeId.get(node.id)?.length ?? 0;
+        degrees[node.id] = {
+            in: incoming,
+            out: outgoing,
+            total: incoming + outgoing
+        };
+    }
+    return degrees;
+}
+export function detectGraphCycle(graph) {
+    const index = createGraphIndex(graph);
+    const visiting = new Set();
+    const visited = new Set();
+    const stack = [];
+    function visit(nodeId) {
+        if (visiting.has(nodeId)) {
+            const startIndex = stack.indexOf(nodeId);
+            return [...stack.slice(startIndex), nodeId];
+        }
+        if (visited.has(nodeId)) {
+            return null;
+        }
+        visiting.add(nodeId);
+        stack.push(nodeId);
+        for (const edge of index.outgoingByNodeId.get(nodeId) ?? []) {
+            if (!index.nodeById.has(edge.target)) {
+                continue;
+            }
+            const cycle = visit(edge.target);
+            if (cycle) {
+                return cycle;
+            }
+        }
+        stack.pop();
+        visiting.delete(nodeId);
+        visited.add(nodeId);
+        return null;
+    }
+    for (const node of graph.nodes) {
+        const cycle = visit(node.id);
+        if (cycle) {
+            return cycle;
+        }
+    }
+    return null;
+}
+export function topologicalSortGraph(graph) {
+    const index = createGraphIndex(graph);
+    const indegrees = new Map();
+    for (const node of graph.nodes) {
+        indegrees.set(node.id, 0);
+    }
+    for (const edge of graph.edges) {
+        if (!index.nodeById.has(edge.source) || !index.nodeById.has(edge.target)) {
+            continue;
+        }
+        indegrees.set(edge.target, (indegrees.get(edge.target) ?? 0) + 1);
+    }
+    const queue = graph.nodes.filter((node) => indegrees.get(node.id) === 0).map((node) => node.id);
+    const ordered = [];
+    for (let cursor = 0; cursor < queue.length; cursor += 1) {
+        const nodeId = queue[cursor];
+        if (!nodeId) {
+            continue;
+        }
+        ordered.push(nodeId);
+        for (const edge of index.outgoingByNodeId.get(nodeId) ?? []) {
+            if (!indegrees.has(edge.target)) {
+                continue;
+            }
+            const nextDegree = (indegrees.get(edge.target) ?? 0) - 1;
+            indegrees.set(edge.target, nextDegree);
+            if (nextDegree === 0) {
+                queue.push(edge.target);
+            }
+        }
+    }
+    if (ordered.length !== graph.nodes.length) {
+        const cycle = detectGraphCycle(graph);
+        return {
+            nodeIds: ordered,
+            diagnostics: [
+                {
+                    code: "cycle-detected",
+                    severity: "error",
+                    message: cycle ? `Graph contains a cycle: ${cycle.join(" -> ")}.` : "Graph contains a cycle."
+                }
+            ]
+        };
+    }
+    return { nodeIds: ordered, diagnostics: [] };
+}
+export function getReachableNodeIds(graph, startId) {
+    const index = createGraphIndex(graph);
+    const visited = new Set([startId]);
+    const reachable = [];
+    const queue = [startId];
+    for (let cursor = 0; cursor < queue.length; cursor += 1) {
+        const nodeId = queue[cursor];
+        if (!nodeId) {
+            continue;
+        }
+        for (const edge of index.outgoingByNodeId.get(nodeId) ?? []) {
+            if (visited.has(edge.target) || !index.nodeById.has(edge.target)) {
+                continue;
+            }
+            visited.add(edge.target);
+            reachable.push(edge.target);
+            queue.push(edge.target);
+        }
+    }
+    return reachable;
+}
+export function getWeaklyConnectedComponents(graph) {
+    const index = createGraphIndex(graph);
+    const visited = new Set();
+    const components = [];
+    for (const node of graph.nodes) {
+        if (visited.has(node.id)) {
+            continue;
+        }
+        const component = [];
+        const queue = [node.id];
+        visited.add(node.id);
+        for (let cursor = 0; cursor < queue.length; cursor += 1) {
+            const nodeId = queue[cursor];
+            if (!nodeId) {
+                continue;
+            }
+            component.push(nodeId);
+            const adjacent = [
+                ...(index.outgoingByNodeId.get(nodeId) ?? []).map((edge) => edge.target),
+                ...(index.incomingByNodeId.get(nodeId) ?? []).map((edge) => edge.source)
+            ];
+            for (const adjacentId of adjacent) {
+                if (visited.has(adjacentId) || !index.nodeById.has(adjacentId)) {
+                    continue;
+                }
+                visited.add(adjacentId);
+                queue.push(adjacentId);
+            }
+        }
+        components.push(component);
+    }
+    return components;
+}
+export function validateTreeGraph(graph, options = {}) {
+    const index = createGraphIndex(graph);
+    const diagnostics = [];
+    const parentCount = new Map();
+    for (const node of graph.nodes) {
+        parentCount.set(node.id, 0);
+    }
+    for (const edge of graph.edges) {
+        if (parentCount.has(edge.target)) {
+            parentCount.set(edge.target, (parentCount.get(edge.target) ?? 0) + 1);
+        }
+    }
+    const roots = graph.nodes.filter((node) => parentCount.get(node.id) === 0).map((node) => node.id);
+    const expectedRoots = options.rootId ? [options.rootId] : roots;
+    if (roots.length !== 1 || (options.rootId && roots[0] !== options.rootId)) {
+        const rootNodeId = expectedRoots[0];
+        diagnostics.push({
+            code: "tree-multiple-roots",
+            severity: "error",
+            message: `Tree graphs must have exactly one root; found ${roots.length}.`,
+            ...(rootNodeId ? { nodeId: rootNodeId } : {})
+        });
+    }
+    for (const [nodeId, count] of parentCount) {
+        if (count > 1) {
+            diagnostics.push({
+                code: "tree-multiple-parents",
+                severity: "error",
+                message: `Node "${nodeId}" has ${count} parents.`,
+                nodeId
+            });
+        }
+    }
+    const cycle = detectGraphCycle(graph);
+    if (cycle) {
+        diagnostics.push({
+            code: "cycle-detected",
+            severity: "error",
+            message: `Tree graph contains a cycle: ${cycle.join(" -> ")}.`
+        });
+    }
+    if (roots.length === 1 && !cycle) {
+        const reachable = new Set([roots[0], ...getReachableNodeIds(graph, roots[0] ?? "")]);
+        const disconnected = graph.nodes.find((node) => !reachable.has(node.id));
+        if (disconnected && index.nodeById.has(disconnected.id)) {
+            diagnostics.push({
+                code: "tree-disconnected",
+                severity: "error",
+                message: `Node "${disconnected.id}" is not reachable from the tree root.`,
+                nodeId: disconnected.id
+            });
+        }
+    }
+    return diagnostics;
+}

package/dist/diagnostics.d.ts

@@ -0,0 +1,19 @@
+import type { GraphEdge, GraphId, GraphModel, GraphNode } from "./model.js";
+export type GraphDiagnosticCode = "missing-graph-title" | "duplicate-node-id" | "duplicate-edge-id" | "dangling-edge-source" | "dangling-edge-target" | "self-loop" | "cycle-detected" | "missing-node-label" | "missing-edge-label" | "missing-node-position" | "tree-multiple-roots" | "tree-multiple-parents" | "tree-disconnected";
+export type GraphDiagnosticSeverity = "error" | "warning";
+export interface GraphDiagnostic {
+    readonly code: GraphDiagnosticCode;
+    readonly severity: GraphDiagnosticSeverity;
+    readonly message: string;
+    readonly nodeId?: GraphId;
+    readonly edgeId?: GraphId;
+}
+export interface ValidateGraphOptions {
+    readonly allowSelfLoops?: boolean;
+    readonly requireEdgeLabels?: boolean;
+}
+export declare function validateGraph(graph: GraphModel, options?: ValidateGraphOptions): GraphDiagnostic[];
+export declare function hasGraphErrors(diagnostics: readonly GraphDiagnostic[]): boolean;
+export declare function formatGraphDiagnostic(diagnosticEntry: GraphDiagnostic): string;
+export declare function getNodeLabel(node: GraphNode): string;
+export declare function getEdgeAccessibleLabel(edge: GraphEdge, graph: GraphModel): string;

package/dist/diagnostics.js

@@ -0,0 +1,109 @@
+function isBlank(value) {
+    return value === undefined || value.trim().length === 0;
+}
+function diagnostic(input) {
+    return input;
+}
+export function validateGraph(graph, options = {}) {
+    const requireEdgeLabels = options.requireEdgeLabels ?? true;
+    const diagnostics = [];
+    const nodeIds = new Set();
+    const edgeIds = new Set();
+    if (isBlank(graph.title)) {
+        diagnostics.push(diagnostic({
+            code: "missing-graph-title",
+            severity: "error",
+            message: "Graph title is required for accessible graph output."
+        }));
+    }
+    for (const node of graph.nodes) {
+        if (nodeIds.has(node.id)) {
+            diagnostics.push(diagnostic({
+                code: "duplicate-node-id",
+                severity: "error",
+                message: `Node ID "${node.id}" is used more than once.`,
+                nodeId: node.id
+            }));
+        }
+        nodeIds.add(node.id);
+        if (isBlank(node.label)) {
+            diagnostics.push(diagnostic({
+                code: "missing-node-label",
+                severity: "error",
+                message: `Node "${node.id}" is missing a label.`,
+                nodeId: node.id
+            }));
+        }
+    }
+    for (const edge of graph.edges) {
+        if (edgeIds.has(edge.id)) {
+            diagnostics.push(diagnostic({
+                code: "duplicate-edge-id",
+                severity: "error",
+                message: `Edge ID "${edge.id}" is used more than once.`,
+                edgeId: edge.id
+            }));
+        }
+        edgeIds.add(edge.id);
+        if (!nodeIds.has(edge.source)) {
+            diagnostics.push(diagnostic({
+                code: "dangling-edge-source",
+                severity: "error",
+                message: `Edge "${edge.id}" references missing source node "${edge.source}".`,
+                nodeId: edge.source,
+                edgeId: edge.id
+            }));
+        }
+        if (!nodeIds.has(edge.target)) {
+            diagnostics.push(diagnostic({
+                code: "dangling-edge-target",
+                severity: "error",
+                message: `Edge "${edge.id}" references missing target node "${edge.target}".`,
+                nodeId: edge.target,
+                edgeId: edge.id
+            }));
+        }
+        if (requireEdgeLabels && isBlank(edge.label) && isBlank(edge.ariaLabel)) {
+            diagnostics.push(diagnostic({
+                code: "missing-edge-label",
+                severity: "error",
+                message: `Edge "${edge.id}" needs a label or ariaLabel.`,
+                edgeId: edge.id
+            }));
+        }
+        if (edge.source === edge.target && options.allowSelfLoops !== true) {
+            diagnostics.push(diagnostic({
+                code: "self-loop",
+                severity: "warning",
+                message: `Edge "${edge.id}" points from node "${edge.source}" back to itself.`,
+                nodeId: edge.source,
+                edgeId: edge.id
+            }));
+        }
+    }
+    return diagnostics;
+}
+export function hasGraphErrors(diagnostics) {
+    return diagnostics.some((entry) => entry.severity === "error");
+}
+export function formatGraphDiagnostic(diagnosticEntry) {
+    const edge = diagnosticEntry.edgeId ? ` edge=${diagnosticEntry.edgeId}` : "";
+    const node = diagnosticEntry.nodeId ? ` node=${diagnosticEntry.nodeId}` : "";
+    return `${diagnosticEntry.severity} ${diagnosticEntry.code}${edge}${node}: ${diagnosticEntry.message}`;
+}
+export function getNodeLabel(node) {
+    return node.label.trim();
+}
+export function getEdgeAccessibleLabel(edge, graph) {
+    const ariaLabel = edge.ariaLabel;
+    if (ariaLabel !== undefined && ariaLabel.trim().length > 0) {
+        return ariaLabel;
+    }
+    const label = edge.label;
+    if (label !== undefined && label.trim().length > 0) {
+        return label;
+    }
+    const source = graph.nodes.find((node) => node.id === edge.source)?.label ?? edge.source;
+    const target = graph.nodes.find((node) => node.id === edge.target)?.label ?? edge.target;
+    return `${source} connects to ${target}`;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./algorithms.js";
+export * from "./diagnostics.js";
+export * from "./layout/index.js";
+export * from "./model.js";
+export * from "./svg.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./algorithms.js";
+export * from "./diagnostics.js";
+export * from "./layout/index.js";
+export * from "./model.js";
+export * from "./svg.js";

package/dist/layout/dag.d.ts

@@ -0,0 +1,10 @@
+import type { GraphModel, GraphSize } from "../model.js";
+import { type GraphLayoutResult } from "./types.js";
+export interface DagLayeredLayoutOptions {
+    readonly direction?: "top-bottom" | "left-right";
+    readonly nodeSize?: GraphSize;
+    readonly nodeGap?: number;
+    readonly rankGap?: number;
+    readonly rankStrategy?: "longest-path" | "source-depth";
+}
+export declare function layoutDagGraph<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string, TEdgeKind extends string = string>(graph: GraphModel<TNodeData, TEdgeData, TNodeKind, TEdgeKind>, options?: DagLayeredLayoutOptions): GraphLayoutResult<TNodeData, TEdgeData, TNodeKind, TEdgeKind>;

package/dist/layout/dag.js

@@ -0,0 +1,69 @@
+import { createGraphIndex, detectGraphCycle, topologicalSortGraph } from "../algorithms.js";
+import { defaultGraphNodeSize, edgeWithPoints } from "./types.js";
+function rankedPoint(rank, indexInRank, size, nodeGap, rankGap, direction) {
+    if (direction === "left-right") {
+        return {
+            x: rank * (size.width + rankGap),
+            y: indexInRank * (size.height + nodeGap)
+        };
+    }
+    return {
+        x: indexInRank * (size.width + nodeGap),
+        y: rank * (size.height + rankGap)
+    };
+}
+export function layoutDagGraph(graph, options = {}) {
+    const cycle = detectGraphCycle(graph);
+    if (cycle) {
+        const diagnostic = {
+            code: "cycle-detected",
+            severity: "error",
+            message: `DAG layout requires an acyclic graph; found ${cycle.join(" -> ")}.`
+        };
+        return {
+            graph: {
+                ...graph,
+                nodes: [],
+                edges: []
+            },
+            diagnostics: [diagnostic]
+        };
+    }
+    const size = options.nodeSize ?? defaultGraphNodeSize;
+    const nodeGap = options.nodeGap ?? 32;
+    const rankGap = options.rankGap ?? 96;
+    const direction = options.direction ?? "top-bottom";
+    const index = createGraphIndex(graph);
+    const sorted = topologicalSortGraph(graph);
+    const ranks = new Map();
+    for (const nodeId of sorted.nodeIds) {
+        const incoming = index.incomingByNodeId.get(nodeId) ?? [];
+        const rank = incoming.reduce((nextRank, edge) => {
+            return Math.max(nextRank, (ranks.get(edge.source) ?? 0) + 1);
+        }, 0);
+        ranks.set(nodeId, rank);
+    }
+    const rankBuckets = new Map();
+    for (const node of graph.nodes) {
+        const rank = ranks.get(node.id) ?? 0;
+        rankBuckets.set(rank, [...(rankBuckets.get(rank) ?? []), node.id]);
+    }
+    const nodes = graph.nodes.map((node) => {
+        const rank = ranks.get(node.id) ?? 0;
+        const indexInRank = rankBuckets.get(rank)?.indexOf(node.id) ?? 0;
+        return {
+            ...node,
+            position: rankedPoint(rank, indexInRank, size, nodeGap, rankGap, direction),
+            size: node.size ?? size
+        };
+    });
+    const nodeById = new Map(nodes.map((node) => [node.id, node]));
+    return {
+        graph: {
+            ...graph,
+            nodes,
+            edges: graph.edges.map((edge) => edgeWithPoints(edge, nodeById))
+        },
+        diagnostics: sorted.diagnostics
+    };
+}

package/dist/layout/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./dag.js";
+export * from "./manual.js";
+export * from "./tree.js";
+export * from "./types.js";

package/dist/layout/index.js

@@ -0,0 +1,4 @@
+export * from "./dag.js";
+export * from "./manual.js";
+export * from "./tree.js";
+export * from "./types.js";

package/dist/layout/manual.d.ts

@@ -0,0 +1,7 @@
+import type { GraphModel, GraphSize } from "../model.js";
+import { type GraphLayoutResult } from "./types.js";
+export interface ManualLayoutOptions {
+    readonly defaultNodeSize?: GraphSize;
+    readonly missingPosition?: "error" | "grid" | "zero";
+}
+export declare function layoutManualGraph<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string, TEdgeKind extends string = string>(graph: GraphModel<TNodeData, TEdgeData, TNodeKind, TEdgeKind>, options?: ManualLayoutOptions): GraphLayoutResult<TNodeData, TEdgeData, TNodeKind, TEdgeKind>;

package/dist/layout/manual.js

@@ -0,0 +1,39 @@
+import { defaultGraphNodeSize, edgeWithPoints } from "./types.js";
+function gridPosition(index, size) {
+    const columns = 4;
+    return {
+        x: (index % columns) * (size.width + 48),
+        y: Math.floor(index / columns) * (size.height + 48)
+    };
+}
+export function layoutManualGraph(graph, options = {}) {
+    const defaultNodeSize = options.defaultNodeSize ?? defaultGraphNodeSize;
+    const missingPosition = options.missingPosition ?? "grid";
+    const diagnostics = [];
+    const nodes = graph.nodes.map((node, index) => {
+        if (!node.position && missingPosition === "error") {
+            diagnostics.push({
+                code: "missing-node-position",
+                severity: "error",
+                message: `Node "${node.id}" is missing a manual position.`,
+                nodeId: node.id
+            });
+        }
+        const fallbackPosition = missingPosition === "zero" ? { x: 0, y: 0 } : gridPosition(index, defaultNodeSize);
+        return {
+            ...node,
+            position: node.position ?? fallbackPosition,
+            size: node.size ?? defaultNodeSize
+        };
+    });
+    const nodeById = new Map(nodes.map((node) => [node.id, node]));
+    const edges = graph.edges.map((edge) => edgeWithPoints(edge, nodeById));
+    return {
+        graph: {
+            ...graph,
+            nodes,
+            edges
+        },
+        diagnostics
+    };
+}

package/dist/layout/tree.d.ts

@@ -0,0 +1,10 @@
+import type { GraphModel, GraphSize } from "../model.js";
+import { type GraphLayoutResult } from "./types.js";
+export interface TreeLayoutOptions {
+    readonly direction?: "top-bottom" | "left-right";
+    readonly nodeSize?: GraphSize;
+    readonly siblingGap?: number;
+    readonly levelGap?: number;
+    readonly rootId?: string;
+}
+export declare function layoutTreeGraph<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string, TEdgeKind extends string = string>(graph: GraphModel<TNodeData, TEdgeData, TNodeKind, TEdgeKind>, options?: TreeLayoutOptions): GraphLayoutResult<TNodeData, TEdgeData, TNodeKind, TEdgeKind>;

package/dist/layout/tree.js

@@ -0,0 +1,68 @@
+import { createGraphIndex, validateTreeGraph } from "../algorithms.js";
+import { defaultGraphNodeSize, edgeWithPoints } from "./types.js";
+function orientPoint(depth, breadth, size, levelGap, direction) {
+    if (direction === "left-right") {
+        return {
+            x: depth * (size.width + levelGap),
+            y: breadth
+        };
+    }
+    return {
+        x: breadth,
+        y: depth * (size.height + levelGap)
+    };
+}
+export function layoutTreeGraph(graph, options = {}) {
+    const diagnostics = validateTreeGraph(graph, options.rootId ? { rootId: options.rootId } : {});
+    const size = options.nodeSize ?? defaultGraphNodeSize;
+    const siblingGap = options.siblingGap ?? 32;
+    const levelGap = options.levelGap ?? 96;
+    const direction = options.direction ?? "top-bottom";
+    const index = createGraphIndex(graph);
+    const hasBlockingDiagnostics = diagnostics.some((entry) => {
+        return entry.code === "cycle-detected" || entry.code === "tree-multiple-parents";
+    });
+    const parentCounts = new Map(graph.nodes.map((node) => [node.id, 0]));
+    for (const edge of graph.edges) {
+        if (parentCounts.has(edge.target)) {
+            parentCounts.set(edge.target, (parentCounts.get(edge.target) ?? 0) + 1);
+        }
+    }
+    const rootId = options.rootId ?? graph.nodes.find((node) => parentCounts.get(node.id) === 0)?.id;
+    const positions = new Map();
+    let leafCursor = 0;
+    function place(nodeId, depth) {
+        const children = (index.outgoingByNodeId.get(nodeId) ?? [])
+            .map((edge) => edge.target)
+            .filter((targetId) => index.nodeById.has(targetId));
+        if (children.length === 0) {
+            const breadth = leafCursor * (size.width + siblingGap);
+            leafCursor += 1;
+            positions.set(nodeId, orientPoint(depth, breadth, size, levelGap, direction));
+            return breadth;
+        }
+        const childBreadths = children.map((childId) => place(childId, depth + 1));
+        const breadth = (childBreadths[0] ?? 0) + ((childBreadths.at(-1) ?? 0) - (childBreadths[0] ?? 0)) / 2;
+        positions.set(nodeId, orientPoint(depth, breadth, size, levelGap, direction));
+        return breadth;
+    }
+    if (rootId && !hasBlockingDiagnostics) {
+        place(rootId, 0);
+    }
+    const nodes = graph.nodes.map((node, index) => {
+        return {
+            ...node,
+            position: positions.get(node.id) ?? orientPoint(0, index * (size.width + siblingGap), size, levelGap, direction),
+            size: node.size ?? size
+        };
+    });
+    const nodeById = new Map(nodes.map((node) => [node.id, node]));
+    return {
+        graph: {
+            ...graph,
+            nodes,
+            edges: graph.edges.map((edge) => edgeWithPoints(edge, nodeById))
+        },
+        diagnostics
+    };
+}

package/dist/layout/types.d.ts

@@ -0,0 +1,21 @@
+import type { GraphDiagnostic } from "../diagnostics.js";
+import type { GraphEdge, GraphModel, GraphNode, GraphPoint, GraphSize } from "../model.js";
+export interface PositionedGraphNode<TData = unknown, TKind extends string = string> extends GraphNode<TData, TKind> {
+    readonly position: GraphPoint;
+    readonly size: GraphSize;
+}
+export interface PositionedGraphEdge<TData = unknown, TKind extends string = string> extends GraphEdge<TData, TKind> {
+    readonly points: readonly GraphPoint[];
+    readonly labelPosition?: GraphPoint;
+}
+export interface PositionedGraph<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string, TEdgeKind extends string = string> extends Omit<GraphModel<TNodeData, TEdgeData, TNodeKind, TEdgeKind>, "nodes" | "edges"> {
+    readonly nodes: readonly PositionedGraphNode<TNodeData, TNodeKind>[];
+    readonly edges: readonly PositionedGraphEdge<TEdgeData, TEdgeKind>[];
+}
+export interface GraphLayoutResult<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string, TEdgeKind extends string = string> {
+    readonly graph: PositionedGraph<TNodeData, TEdgeData, TNodeKind, TEdgeKind>;
+    readonly diagnostics: readonly GraphDiagnostic[];
+}
+export declare const defaultGraphNodeSize: GraphSize;
+export declare function nodeCenter(node: PositionedGraphNode): GraphPoint;
+export declare function edgeWithPoints<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string, TEdgeKind extends string = string>(edge: GraphEdge<TEdgeData, TEdgeKind>, nodes: ReadonlyMap<string, PositionedGraphNode<TNodeData, TNodeKind>>): PositionedGraphEdge<TEdgeData, TEdgeKind>;

package/dist/layout/types.js

@@ -0,0 +1,19 @@
+export const defaultGraphNodeSize = { width: 100, height: 48 };
+export function nodeCenter(node) {
+    return {
+        x: node.position.x + node.size.width / 2,
+        y: node.position.y + node.size.height / 2
+    };
+}
+export function edgeWithPoints(edge, nodes) {
+    const source = nodes.get(edge.source);
+    const target = nodes.get(edge.target);
+    const points = source && target ? [nodeCenter(source), nodeCenter(target)] : [];
+    const labelPosition = points.length === 2 && points[0] && points[1]
+        ? {
+            x: (points[0].x + points[1].x) / 2,
+            y: (points[0].y + points[1].y) / 2
+        }
+        : undefined;
+    return labelPosition ? { ...edge, points, labelPosition } : { ...edge, points };
+}

package/dist/model.d.ts

@@ -0,0 +1,41 @@
+export type GraphId = string;
+export type GraphDirection = "directed" | "undirected";
+export interface GraphPoint {
+    readonly x: number;
+    readonly y: number;
+}
+export interface GraphSize {
+    readonly width: number;
+    readonly height: number;
+}
+export interface GraphNode<TData = unknown, TKind extends string = string> {
+    readonly id: GraphId;
+    readonly label: string;
+    readonly kind?: TKind;
+    readonly data?: TData;
+    readonly position?: GraphPoint;
+    readonly size?: GraphSize;
+    readonly status?: string;
+    readonly groupId?: GraphId;
+    readonly ariaDescription?: string;
+}
+export interface GraphEdge<TData = unknown, TKind extends string = string> {
+    readonly id: GraphId;
+    readonly source: GraphId;
+    readonly target: GraphId;
+    readonly label?: string;
+    readonly ariaLabel?: string;
+    readonly kind?: TKind;
+    readonly data?: TData;
+    readonly directed?: boolean;
+    readonly status?: string;
+}
+export interface GraphModel<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string, TEdgeKind extends string = string> {
+    readonly id?: GraphId;
+    readonly title: string;
+    readonly description?: string;
+    readonly direction?: GraphDirection;
+    readonly nodes: readonly GraphNode<TNodeData, TNodeKind>[];
+    readonly edges: readonly GraphEdge<TEdgeData, TEdgeKind>[];
+}
+export declare function defineGraph<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string, TEdgeKind extends string = string>(graph: GraphModel<TNodeData, TEdgeData, TNodeKind, TEdgeKind>): GraphModel<TNodeData, TEdgeData, TNodeKind, TEdgeKind>;

package/dist/model.js

@@ -0,0 +1,3 @@
+export function defineGraph(graph) {
+    return graph;
+}

package/dist/styles.css

@@ -0,0 +1,116 @@
+/* src/styles.css */
+@layer zvk-graphs-tokens, zvk-graphs-components;
+
+/* src/styles/graph.css */
+@layer zvk-graphs-tokens {
+  :root {
+    --zvk-graphs-canvas-bg: var(--zvk-ui-color-background, Canvas);
+    --zvk-graphs-node-bg: var(--zvk-ui-color-surface, Canvas);
+    --zvk-graphs-node-border: var(--zvk-ui-card-border, GrayText);
+    --zvk-graphs-node-text: var(--zvk-ui-color-foreground, CanvasText);
+    --zvk-graphs-muted-text: var(--zvk-ui-color-muted-foreground, GrayText);
+    --zvk-graphs-edge-stroke: var(--zvk-ui-color-border-strong, CanvasText);
+    --zvk-graphs-edge-muted-stroke: var(--zvk-ui-color-border, GrayText);
+    --zvk-graphs-selected-bg: var(--zvk-ui-color-primary-soft, color-mix(in srgb, Highlight 12%, Canvas));
+    --zvk-graphs-selected-stroke: var(--zvk-ui-color-primary, Highlight);
+    --zvk-graphs-focus-outline: var(--zvk-ui-focus-ring, 0 0 0 3px Highlight);
+    --zvk-graphs-focus-stroke: var(--zvk-ui-color-ring, Highlight);
+    --zvk-graphs-success: var(--zvk-ui-color-success, #0a6b3a);
+    --zvk-graphs-warning: var(--zvk-ui-color-warning, #8a5a00);
+    --zvk-graphs-destructive: var(--zvk-ui-color-destructive, #b00020);
+    --zvk-graphs-info: var(--zvk-ui-color-info, #087ea4);
+    --zvk-graphs-node-radius: var(--zvk-ui-radius-md, 0.5rem);
+    --zvk-graphs-node-shadow: var(--zvk-ui-shadow-xs, none);
+    --zvk-graphs-edge-width: 1.5px;
+    --zvk-graphs-selected-edge-width: 2.5px;
+  }
+}
+
+@layer zvk-graphs-components {
+  :where(.zvk-graphs) {
+    color: var(--zvk-graphs-node-text);
+    background: var(--zvk-graphs-canvas-bg);
+  }
+
+  :where(.zvk-graphs__svg) {
+    display: block;
+    max-width: 100%;
+    height: auto;
+    overflow: visible;
+  }
+
+  :where(.zvk-graphs__edge) {
+    fill: none;
+    stroke: var(--zvk-graphs-edge-stroke);
+    stroke-width: var(--zvk-graphs-edge-width);
+  }
+
+  :where(.zvk-graphs__edge-group[data-selected="true"] .zvk-graphs__edge) {
+    stroke: var(--zvk-graphs-selected-stroke);
+    stroke-width: var(--zvk-graphs-selected-edge-width);
+  }
+
+  :where(.zvk-graphs__marker) {
+    fill: var(--zvk-graphs-edge-stroke);
+  }
+
+  :where(.zvk-graphs__edge-label) {
+    fill: var(--zvk-graphs-muted-text);
+    font: 12px system-ui, sans-serif;
+    paint-order: stroke;
+    stroke: var(--zvk-graphs-canvas-bg);
+    stroke-width: 3px;
+    text-anchor: middle;
+  }
+
+  :where(.zvk-graphs__node-shape) {
+    fill: var(--zvk-graphs-node-bg);
+    stroke: var(--zvk-graphs-node-border);
+    stroke-width: 1px;
+    filter: var(--zvk-graphs-node-shadow);
+  }
+
+  :where(.zvk-graphs__node-label) {
+    fill: var(--zvk-graphs-node-text);
+    font: 13px system-ui, sans-serif;
+    dominant-baseline: middle;
+    pointer-events: none;
+    text-anchor: middle;
+  }
+
+  :where(.zvk-graphs__node-selection) {
+    fill: var(--zvk-graphs-selected-bg);
+    stroke: var(--zvk-graphs-selected-stroke);
+    stroke-width: 2px;
+  }
+
+  :where(.zvk-graphs__node[data-status="success"] .zvk-graphs__node-shape) {
+    stroke: var(--zvk-graphs-success);
+  }
+
+  :where(.zvk-graphs__node[data-status="warning"] .zvk-graphs__node-shape) {
+    stroke: var(--zvk-graphs-warning);
+    stroke-dasharray: 4 3;
+  }
+
+  :where(.zvk-graphs__node[data-status="destructive"] .zvk-graphs__node-shape) {
+    stroke: var(--zvk-graphs-destructive);
+  }
+
+  :where(.zvk-graphs__fallback) {
+    margin-top: 0.75rem;
+  }
+
+  :where(.zvk-graphs__fallback h3) {
+    margin: 0.75rem 0 0.25rem;
+    font: 600 0.875rem system-ui, sans-serif;
+  }
+
+  :where(.zvk-graphs__fallback ul) {
+    margin: 0;
+    padding-inline-start: 1.25rem;
+  }
+}
+
+
+

package/dist/svg.d.ts

@@ -0,0 +1,32 @@
+import { type ReactNode, type SVGProps } from "react";
+import type { GraphId } from "./model.js";
+import { type PositionedGraph, type PositionedGraphNode } from "./layout/index.js";
+export type RenderGraphNode<TData = unknown, TKind extends string = string> = (input: {
+    readonly node: PositionedGraphNode<TData, TKind>;
+    readonly selected: boolean;
+    readonly focused: boolean;
+}) => ReactNode;
+export interface GraphSvgProps<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string> {
+    readonly graph: PositionedGraph<TNodeData, TEdgeData, TNodeKind>;
+    readonly titleId: string;
+    readonly descriptionId: string;
+    readonly selectedNodeIds?: readonly GraphId[];
+    readonly selectedEdgeIds?: readonly GraphId[];
+    readonly renderNode?: RenderGraphNode<TNodeData, TNodeKind>;
+    readonly svgProps?: Omit<SVGProps<SVGSVGElement>, "children">;
+}
+export interface GraphFigureProps<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string> {
+    readonly graph: PositionedGraph<TNodeData, TEdgeData, TNodeKind>;
+    readonly selectedNodeIds?: readonly GraphId[];
+    readonly selectedEdgeIds?: readonly GraphId[];
+    readonly renderNode?: RenderGraphNode<TNodeData, TNodeKind>;
+    readonly fallbackMode?: "list" | "tree" | "none";
+}
+export declare function GraphSvg<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string>({ graph, titleId, descriptionId, selectedNodeIds, selectedEdgeIds, renderNode, svgProps }: GraphSvgProps<TNodeData, TEdgeData, TNodeKind>): ReactNode;
+export declare function GraphFallbackList({ graph }: {
+    readonly graph: PositionedGraph;
+}): ReactNode;
+export declare function GraphFallbackTree({ graph }: {
+    readonly graph: PositionedGraph;
+}): ReactNode;
+export declare function GraphFigure<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string>({ graph, selectedNodeIds, selectedEdgeIds, renderNode, fallbackMode }: GraphFigureProps<TNodeData, TEdgeData, TNodeKind>): ReactNode;

package/dist/svg.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useId } from "react";
+import { getEdgeAccessibleLabel } from "./diagnostics.js";
+import { nodeCenter } from "./layout/index.js";
+function pathForPoints(points) {
+    if (points.length === 0 || !points[0]) {
+        return "";
+    }
+    return points.slice(1).reduce((path, point) => `${path} L ${point.x} ${point.y}`, `M ${points[0].x} ${points[0].y}`);
+}
+function graphBounds(graph) {
+    const padding = 24;
+    const maxX = graph.nodes.reduce((value, node) => Math.max(value, node.position.x + node.size.width), 0);
+    const maxY = graph.nodes.reduce((value, node) => Math.max(value, node.position.y + node.size.height), 0);
+    const width = Math.max(1, maxX + padding * 2);
+    const height = Math.max(1, maxY + padding * 2);
+    return {
+        width,
+        height,
+        viewBox: `${-padding} ${-padding} ${width} ${height}`
+    };
+}
+function nodeSelected(selectedNodeIds, nodeId) {
+    return selectedNodeIds?.includes(nodeId) ?? false;
+}
+function edgeSelected(selectedEdgeIds, edgeId) {
+    return selectedEdgeIds?.includes(edgeId) ?? false;
+}
+export function GraphSvg({ graph, titleId, descriptionId, selectedNodeIds, selectedEdgeIds, renderNode, svgProps }) {
+    const bounds = graphBounds(graph);
+    const markerId = `${titleId}-arrow`;
+    const hasDirectedEdges = graph.edges.some((edge) => edge.directed !== false);
+    return (_jsxs("svg", { ...svgProps, className: ["zvk-graphs__svg", svgProps?.className].filter(Boolean).join(" "), role: "img", "aria-labelledby": titleId, "aria-describedby": descriptionId, viewBox: bounds.viewBox, width: svgProps?.width ?? bounds.width, height: svgProps?.height ?? bounds.height, children: [_jsx("title", { id: titleId, children: graph.title }), _jsx("desc", { id: descriptionId, children: graph.description ?? `${graph.nodes.length} nodes and ${graph.edges.length} edges.` }), hasDirectedEdges ? (_jsx("defs", { children: _jsx("marker", { id: markerId, viewBox: "0 0 10 10", refX: "9", refY: "5", markerWidth: "7", markerHeight: "7", orient: "auto", children: _jsx("path", { className: "zvk-graphs__marker", d: "M 0 0 L 10 5 L 0 10 z" }) }) })) : null, _jsx("g", { className: "zvk-graphs__edges", children: graph.edges.map((edge) => {
+                    const selected = edgeSelected(selectedEdgeIds, edge.id);
+                    const d = pathForPoints(edge.points);
+                    return (_jsxs("g", { className: "zvk-graphs__edge-group", "data-edge-id": edge.id, "data-status": edge.status, "data-selected": selected ? "true" : undefined, children: [_jsx("path", { className: "zvk-graphs__edge", d: d, markerEnd: edge.directed === false ? undefined : `url(#${markerId})` }), edge.label && edge.labelPosition ? (_jsx("text", { className: "zvk-graphs__edge-label", x: edge.labelPosition.x, y: edge.labelPosition.y - 6, children: edge.label })) : null] }, edge.id));
+                }) }), _jsx("g", { className: "zvk-graphs__nodes", children: graph.nodes.map((node) => {
+                    const selected = nodeSelected(selectedNodeIds, node.id);
+                    const center = nodeCenter(node);
+                    return (_jsxs("g", { className: "zvk-graphs__node", "data-node-id": node.id, "data-kind": node.kind, "data-status": node.status, "data-selected": selected ? "true" : undefined, transform: `translate(${node.position.x} ${node.position.y})`, children: [renderNode ? (renderNode({ node, selected, focused: false })) : (_jsxs(_Fragment, { children: [_jsx("rect", { className: "zvk-graphs__node-shape", width: node.size.width, height: node.size.height, rx: "8" }), _jsx("text", { className: "zvk-graphs__node-label", x: node.size.width / 2, y: node.size.height / 2, children: node.label }), _jsx("title", { children: node.ariaDescription ?? node.label })] })), selected ? (_jsx("rect", { className: "zvk-graphs__node-selection", x: "-4", y: "-4", width: node.size.width + 8, height: node.size.height + 8, rx: "10", "aria-hidden": "true" })) : null, _jsx("circle", { className: "zvk-graphs__node-anchor", cx: center.x - node.position.x, cy: center.y - node.position.y, r: "0" })] }, node.id));
+                }) })] }));
+}
+export function GraphFallbackList({ graph }) {
+    return (_jsxs("div", { className: "zvk-graphs__fallback", children: [_jsx("h3", { children: "Nodes" }), _jsx("ul", { children: graph.nodes.map((node) => (_jsxs("li", { children: [node.label, node.status ? ` (${node.status})` : ""] }, node.id))) }), _jsx("h3", { children: "Edges" }), _jsx("ul", { children: graph.edges.map((edge) => (_jsx("li", { children: getEdgeAccessibleLabel(edge, graph) }, edge.id))) })] }));
+}
+export function GraphFallbackTree({ graph }) {
+    return _jsx(GraphFallbackList, { graph: graph });
+}
+export function GraphFigure({ graph, selectedNodeIds, selectedEdgeIds, renderNode, fallbackMode = "list" }) {
+    const id = useId();
+    const titleId = `${id}-title`;
+    const descriptionId = `${id}-description`;
+    return (_jsxs("figure", { className: "zvk-graphs", "data-zvk-graphs": true, children: [_jsx(GraphSvg, { graph: graph, titleId: titleId, descriptionId: descriptionId, ...(selectedNodeIds ? { selectedNodeIds } : {}), ...(selectedEdgeIds ? { selectedEdgeIds } : {}), ...(renderNode ? { renderNode } : {}) }), fallbackMode === "none" ? null : fallbackMode === "tree" ? (_jsx(GraphFallbackTree, { graph: graph })) : (_jsx(GraphFallbackList, { graph: graph }))] }));
+}

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@zvk/graphs",
+  "version": "0.1.0",
+  "description": "Accessible SVG-first node and edge graph utilities, deterministic layouts, and static React renderers for ZVK applications.",
+  "private": false,
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/brandon-schabel/zvk.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "files": [
+    "dist",
+    "CHANGELOG.md",
+    "LICENSE.md",
+    "README.md"
+  ],
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./model": {
+      "types": "./dist/model.d.ts",
+      "import": "./dist/model.js"
+    },
+    "./diagnostics": {
+      "types": "./dist/diagnostics.d.ts",
+      "import": "./dist/diagnostics.js"
+    },
+    "./algorithms": {
+      "types": "./dist/algorithms.d.ts",
+      "import": "./dist/algorithms.js"
+    },
+    "./layout": {
+      "types": "./dist/layout/index.d.ts",
+      "import": "./dist/layout/index.js"
+    },
+    "./svg": {
+      "types": "./dist/svg.d.ts",
+      "import": "./dist/svg.js"
+    },
+    "./styles.css": "./dist/styles.css",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "clean": "bun run scripts/clean.mjs",
+    "build:types": "tsc -p tsconfig.build.json",
+    "build:css": "bun run scripts/build-css.mjs",
+    "build": "bun run clean && bun run build:types && bun run build:css",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:ssr": "vitest run tests/ssr --environment node",
+    "test:exports": "vitest run tests/exports --environment node",
+    "test:types": "tsd",
+    "validate:exports": "bun run scripts/validate-exports.mjs",
+    "tarball:inspect": "bun run scripts/check-tarball.mjs",
+    "pack:dry": "bun pm pack --dry-run",
+    "preflight": "bun run typecheck && bun run build && bun run test && bun run test:ssr && bun run test:types && bun run test:exports && bun run validate:exports && bun run tarball:inspect && bun run pack:dry"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "tsd": {
+    "directory": "tests/types"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "@types/react": "^19.2.16",
+    "@types/react-dom": "^19.2.3",
+    "tsd": "^0.33.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
+  }
+}