@zvk/graphs 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @zvk/graphs Changelog
 
+## [0.1.3](https://github.com/brandon-schabel/zvk/compare/graphs-v0.1.2...graphs-v0.1.3) (2026-06-20)
+
+
+### Features
+
+* improve package release workflow and repo maintainability ([#22](https://github.com/brandon-schabel/zvk/issues/22)) ([a41cb66](https://github.com/brandon-schabel/zvk/commit/a41cb66554496f241c5a8e30b29a76c8b8ca92b3))
+
+## [0.1.2](https://github.com/brandon-schabel/zvk/compare/graphs-v0.1.1...graphs-v0.1.2) (2026-06-19)
+
+
+### Features
+
+* add theme presets and package improvements ([#19](https://github.com/brandon-schabel/zvk/issues/19)) ([867f955](https://github.com/brandon-schabel/zvk/commit/867f9556f7a60144cad4e747f2c032f2d5ede353))
+
 ## [0.1.1](https://github.com/brandon-schabel/zvk/compare/graphs-v0.1.0...graphs-v0.1.1) (2026-06-18)
 
 

package/README.md

@@ -15,13 +15,22 @@ 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/diagnostics`, `@zvk/graphs/algorithms`,
+`@zvk/graphs/serialization`, `@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.
 
+## Package Docs And Examples
+
+Package-local guides live in `packages/graphs/docs/README.md`. They cover
+modeling, algorithms, diagnostics, serialization, deterministic layout, static
+SVG rendering, accessibility, app composition boundaries, and anti-goals.
+Runnable examples live in `packages/graphs/examples/` and must use only public
+`@zvk/graphs` imports.
+
 ## Styles
 
 Import graph styles once from the public stylesheet:
@@ -43,6 +52,11 @@ 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.
 
+Graph typography uses `--zvk-graphs-font-primary`, `--zvk-graphs-font-secondary`,
+and `--zvk-graphs-font-tertiary`. These inherit `--zvk-ui-font-family-primary`,
+`--zvk-ui-font-family-secondary`, and `--zvk-ui-font-family-tertiary` when UI
+styles are present.
+
 ## Accessibility And SSR
 
 - Require a graph title, node labels, and meaningful edge labels or derivable
@@ -57,6 +71,281 @@ component internals for styling.
 - Use deterministic IDs and layout output. Do not use random IDs, timestamps, or
   DOM measurement for default layout.
 
+## Fallback Details
+
+`GraphFigure` renders structured fallback content by default. Node fallback
+details include documented summary fields such as `summary`, `accessibility`,
+`ariaDescription`, `kind`, `groupId`, `status`, `presentation`, structured
+primitive `metadata`, and primitive string/number/boolean `data` values. Edge
+fallback details include source and target labels, route kind, accessibility
+text, status, summary, structured primitive metadata, and primitive edge data.
+Arbitrary object data is not dumped into the DOM by default.
+
+Use `fallbackMode="tree"` when a graph is a one-root tree and should expose a
+nested fallback. Invalid or multi-root trees degrade to the list fallback. Use
+`fallbackMode="none"` only when the host application renders equivalent graph
+details elsewhere.
+
+## Static Metadata And Presentation
+
+Nodes and edges can expose app-owned details through serializable metadata and
+accessibility fields:
+
+```ts
+const graph = {
+  title: "Deploy graph",
+  description: "Release approval flow.",
+  nodes: [
+    {
+      id: "gate",
+      label: "Deploy gate",
+      labelLines: ["Deploy", "gate"],
+      metadata: [
+        { key: "owner", label: "Owner", value: "Platform", visibility: "summary", tone: "info" },
+        { key: "risk", label: "Risk", value: "Medium", visibility: "detail", tone: "warning" }
+      ],
+      accessibility: {
+        label: "Deploy gate decision",
+        description: "Decision node for deployment approval."
+      },
+      presentation: {
+        shape: "diamond",
+        density: "compact",
+        tone: "warning",
+        badge: "Gate",
+        glyph: "?"
+      },
+      status: "warning",
+      position: { x: 0, y: 0 }
+    }
+  ],
+  edges: []
+};
+```
+
+The SVG renderer only displays metadata marked `visibility: "summary"` so
+callers have to opt into compact visible details. Fallback content renders all
+primitive metadata values. Use `renderNode` for advanced custom SVG output, but
+prefer built-in `shape`, `badge`, `glyph`, `labelLines`, and metadata summaries
+for common static graph details.
+
+## Static Groups
+
+Graphs can define static groups and attach nodes through `groupId`:
+
+```ts
+const graph = {
+  title: "Service map",
+  groups: [
+    {
+      id: "backend",
+      label: "Backend services",
+      summary: "Platform-owned services.",
+      tone: "info",
+      status: "active"
+    }
+  ],
+  nodes: [
+    { id: "api", label: "API", groupId: "backend", position: { x: 0, y: 0 } },
+    { id: "worker", label: "Worker", groupId: "backend", position: { x: 140, y: 0 } }
+  ],
+  edges: []
+};
+```
+
+Static groups render as non-interactive SVG containers beneath edges and nodes.
+When a group has explicit `position` and `size`, those bounds are used;
+otherwise `deriveGraphGroupBounds` derives padded bounds from positioned member
+nodes. Group fallback details include summaries, metadata, status, tone, and
+member labels.
+
+Groups are visual and fallback organization only. They do not provide compound
+layout, nested group layout, port constraints, edge routing around group
+boundaries, collapse/expand behavior, or editor workflows.
+
+## Edge Labels And Routes
+
+Static SVG edges include accessible titles and descriptions derived from
+`accessibility.label`, `ariaLabel`, `label`, source label, target label, status,
+`accessibility.description`, and summary where available. Visible edge labels
+render at deterministic label anchors and include a tokenized background
+rectangle for contrast. Use `deriveGraphEdgeLabelAnchor` when applications need
+the same estimated label bounds and anchor metadata before rendering.
+Use `getGraphEdgeLabelOverlapDiagnostics` on positioned graphs, or set
+`warnEdgeLabelOverlaps` on layout helpers, when applications need opt-in
+warnings for estimated label bounds that overlap. This diagnostic is a
+deterministic risk signal; it does not measure rendered text, relocate labels,
+or solve collisions.
+
+The layout helpers expose deterministic straight, curved, elbow, self-loop, and
+parallel-offset route primitives. These are simple SVG path primitives, not
+full orthogonal routing, port routing, obstacle avoidance, edge bundling, or
+Graphviz/ELK-style label placement.
+
+Use `edgeRouteKind` for a layout-wide default route kind and `routeByEdgeId`
+when a specific edge needs a different route:
+
+```ts
+const layout = layoutManualGraph(graph, {
+  edgeRouteKind: "straight",
+  routeByEdgeId: {
+    "audit-edge": "curve",
+    "fallback-edge": "elbow"
+  }
+});
+```
+
+Per-edge route hints take precedence over the layout default. Self-loop edges
+still render with the `self-loop` route kind so loops remain recognizable.
+
+Label anchors are deterministic estimates based on the label text length and
+route label position. They do not use DOM measurement, `getBBox`, label
+collision solving, obstacle avoidance, or route-aware label placement.
+
+## Layout Diagnostics And Bounds
+
+Manual, tree, and narrow DAG layouts return diagnostics rather than throwing for
+expected graph-shape limits. Layout options can warn about large graphs, dense
+graphs, missing explicit node sizes, duplicate manual positions, self-loops, and
+parallel edges. `estimateGraphRenderCost` returns deterministic counts for
+nodes, edges, groups, fallback rows, visible labels, summary metadata, route
+points, complex routes, and a rough SVG element estimate. Use threshold options
+such as `warnFallbackRowsAt`, `warnVisibleLabelsAt`, `warnRoutePointsAt`, and
+`warnMetadataSummariesAt` to surface opt-in performance warnings when a static
+graph should be filtered, collapsed, summarized, or delegated to a specialized
+graph engine.
+
+DAG layout supports `rankStrategy: "longest-path"` and `"source-depth"` for
+small acyclic graphs. Apps can also provide
+`rankByNodeId` and `orderByNodeId` hints when a workflow or dependency view has
+known phases or stable author-defined ordering:
+
+```ts
+import { layoutDagGraph } from "@zvk/graphs";
+
+const layout = layoutDagGraph(workflowGraph, {
+  direction: "left-right",
+  rankByNodeId: {
+    change: 0,
+    preflight: 1,
+    review: 1,
+    release: 2
+  },
+  orderByNodeId: {
+    review: 0,
+    preflight: 1
+  }
+});
+```
+
+Rank hints override computed DAG ranks for matching node IDs. Order hints sort
+nodes within their resolved rank; missing order hints fall back to graph input
+order. Unknown hint keys are ignored. These hints are deterministic layout
+inputs, not a crossing-minimization engine, compound layout system, or
+Graphviz/ELK replacement.
+
+Use `validateGraph(graph, { auditAccessibility: true })` for opt-in
+accessibility audit info entries about missing graph descriptions, node
+descriptions, and edge descriptions. These diagnostics are guidance for complex
+static diagrams; they do not turn ordinary validation failures into throws.
+
+Use `getGraphBounds` as a pure static helper for `viewBox` sizing with padding
+and minimum dimensions. It does not own pan/zoom state, fit-to-screen behavior,
+viewport persistence, or responsive layout state.
+
+## Pure Graph Transforms
+
+Use algorithm transform helpers when an application needs focused graph views
+without moving search, filters, routing, or detail panels into the package:
+
+```ts
+import { getGraphNeighborhood, mapGraphNodes, pickGraphSubgraph } from "@zvk/graphs";
+
+const neighborhood = getGraphNeighborhood(graph, {
+  rootId: "model",
+  direction: "outgoing",
+  maxDepth: 2
+});
+
+const selectedPath = pickGraphSubgraph(graph, {
+  nodeIds: ["model", "diagnostics", "layout"]
+});
+
+const highlighted = mapGraphNodes(neighborhood, (node) => ({
+  ...node,
+  status: node.id === "model" ? "success" : node.status
+}));
+```
+
+`pickGraphSubgraph` preserves node and edge input order while pruning edges to
+selected nodes by default. `includeConnectedEdges: false` returns node-only
+projections, and `includeDanglingEdges: true` keeps edges touching selected
+nodes for app-owned inspection flows. `getGraphNeighborhood` returns a
+depth-limited incoming, outgoing, or bidirectional projection. `mapGraphNodes`
+and `mapGraphEdges` preserve graph metadata while letting applications annotate
+nodes or edges for a derived view.
+
+## Edge And Adjacency Interop
+
+Use edge-list and adjacency-list helpers when an app imports relationship data
+from a database query, config file, or debug fixture and needs a graph model
+without adopting a graph language parser:
+
+```ts
+import { graphFromAdjacencyList, graphFromEdgeList, graphToAdjacencyList } from "@zvk/graphs";
+
+const importedGraph = graphFromEdgeList(
+  [
+    { id: "api-db", source: "api", target: "db", label: "queries" },
+    { source: "api", target: "cache", label: "reads" }
+  ],
+  {
+    title: "Service dependencies",
+    getNodeLabel: (nodeId) => nodeId.toUpperCase()
+  }
+);
+
+const adjacencyList = graphToAdjacencyList(importedGraph);
+const debugGraph = graphFromAdjacencyList(adjacencyList, {
+  title: "Debug dependency graph"
+});
+```
+
+`graphFromEdgeList` preserves explicit edge fields and appends missing nodes in
+first-seen edge order. Missing edge IDs are generated deterministically from the
+source and target IDs, with numeric suffixes for repeated pairs. Provide stable
+edge IDs when IDs are persisted, linked, or shown to users.
+
+`graphToAdjacencyList` returns ordered `{ source, targets }` items in graph node
+order, including isolated nodes. This format is intentionally structural and
+lossy: it preserves source IDs, ordered target IDs, and duplicate targets, but
+not edge labels, metadata, data, kind, status, or IDs.
+
+## Stable JSON Serialization
+
+Use serialization helpers when an app needs deterministic graph JSON for
+storage, debug exports, snapshots, or support bundles:
+
+```ts
+import { normalizeGraphForJson, stringifyGraphForJson } from "@zvk/graphs/serialization";
+
+const portableGraph = normalizeGraphForJson(graph);
+const stableJson = stringifyGraphForJson(graph, {
+  sortItems: true,
+  space: 2
+});
+```
+
+`normalizeGraphForJson` removes unsupported object properties such as
+`undefined`, functions, symbols, and bigints. Object keys are sorted for stable
+diffs. Graph groups, nodes, and edges preserve input order by default; set
+`sortItems: true` to sort those arrays by `id` for persisted output.
+
+`stringifyGraphForJson` serializes the normalized graph. It is not a runtime
+validator and does not parse or emit DOT, Mermaid, Graphviz, or layout-engine
+formats. Use `validateGraph` and `validateGraphLayout` for imported data that
+must be checked before rendering.
+
 ## Package Boundaries
 
 `@zvk/graphs` owns:
@@ -64,8 +353,9 @@ component internals for styling.
 - 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;
+  reachability, component, tree, subgraph, neighborhood, and mapping helpers;
+- deterministic manual, tree, narrow DAG, bounds, and static group-bound
+  utilities;
 - static React/SVG graph rendering;
 - graph CSS and token inheritance contracts.
 
@@ -74,6 +364,75 @@ 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.
 
+App-owned detail panel composition should keep state in the application:
+
+```tsx
+import { GraphFigure, layoutManualGraph } from "@zvk/graphs";
+import "@zvk/graphs/styles.css";
+
+const layout = layoutManualGraph(graph);
+const selectedNode = layout.graph.nodes.find((node) => node.id === selectedNodeId);
+
+return (
+  <>
+    <GraphFigure graph={layout.graph} selectedNodeIds={selectedNodeId ? [selectedNodeId] : []} />
+    <aside>{selectedNode ? selectedNode.label : "No node selected"}</aside>
+  </>
+);
+```
+
+This pattern is application composition. `@zvk/graphs` does not own product
+detail fields, routes, filtering, search, keyboard selection, or client state.
+
+## Client Boundary Decision
+
+There is no `@zvk/graphs/client` public subpath yet. Keep client behavior
+app-owned until the static core needs shared helpers that cannot be expressed
+with public model, layout, SVG, and CSS contracts.
+
+A future client subpath must stay narrow: focusable nodes and edges, roving
+focus or tab-order helpers, controlled selection helpers, keyboard shortcuts,
+persistent inspector helpers, and live-region guidance. Product detail panels,
+filters, search, routing, editing, drag-to-connect, pan/zoom, minimaps, and
+viewport persistence remain application responsibilities.
+
+## CSS Contract
+
+Graph styles use `.zvk-graphs*` classes, `data-zvk-graphs`, `data-node-id`,
+`data-edge-id`, `data-kind`, `data-node-shape`, `data-edge-kind`,
+`data-edge-label-anchor`, `data-edge-label-side`, `data-edge-route-kind`,
+`data-density`, `data-tone`, `data-status`, and `data-selected` hooks. Treat
+these as styling and diagnostics hooks, not a replacement for accessible labels
+or public imports.
+
+Important variables include:
+
+- `--zvk-graphs-canvas-bg`
+- `--zvk-graphs-group-bg`
+- `--zvk-graphs-group-border`
+- `--zvk-graphs-group-label-text`
+- `--zvk-graphs-node-bg`
+- `--zvk-graphs-node-border`
+- `--zvk-graphs-node-text`
+- `--zvk-graphs-node-badge-text`
+- `--zvk-graphs-muted-text`
+- `--zvk-graphs-edge-stroke`
+- `--zvk-graphs-edge-label-bg`
+- `--zvk-graphs-edge-label-border`
+- `--zvk-graphs-selected-bg`
+- `--zvk-graphs-selected-stroke`
+- `--zvk-graphs-success`
+- `--zvk-graphs-warning`
+- `--zvk-graphs-destructive`
+- `--zvk-graphs-info`
+- `--zvk-graphs-font-primary`
+- `--zvk-graphs-font-secondary`
+- `--zvk-graphs-font-tertiary`
+
+The default CSS adds non-color cues for several statuses with dash patterns,
+stroke width changes, and fallback/status text. Host applications should still
+verify contrast and forced-colors behavior in their own theme context.
+
 ## Anti-Goals
 
 - No runtime dependencies.
@@ -84,3 +443,20 @@ pie/donut charts, and other quantitative visualization.
   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.
+
+## Source Policy Validation
+
+`bun run --filter @zvk/graphs validate:source-policy` checks the static package
+boundary. It fails on browser globals or forbidden graph/runtime dependency
+imports in production graph source, nondeterministic time/random APIs, graph CSS
+that escapes the token contract, and private `src` or `dist` graph imports in
+the README, package docs, or examples. The package `preflight` runs this check
+after export validation.
+
+`bun run --filter @zvk/graphs verify:style-contract` checks the positive style
+surface: graph layers, public `.zvk-graphs*` selectors, graph token definitions,
+UI-token inheritance, state selectors, and forced-colors coverage.
+
+## Repo Skill
+
+Use `.codex/skills/use-zvk-graphs/SKILL.md` when maintaining this package.

package/dist/algorithms.d.ts

@@ -1,5 +1,5 @@
 import type { GraphDiagnostic } from "./diagnostics.js";
-import type { GraphEdge, GraphId, GraphModel, GraphNode } from "./model.js";
+import type { GraphDirection, GraphEdge, GraphGroup, GraphId, GraphModel, GraphNode } from "./model.js";
 export interface GraphIndex {
     readonly nodeById: ReadonlyMap<GraphId, GraphNode>;
     readonly edgeById: ReadonlyMap<GraphId, GraphEdge>;
@@ -11,8 +11,71 @@ export interface GraphDegree {
     readonly out: number;
     readonly total: number;
 }
+export type GraphAdjacencyList = readonly GraphAdjacencyListItem[];
+export interface GraphAdjacencyListItem {
+    readonly source: GraphId;
+    readonly targets: readonly GraphId[];
+}
+export interface GraphEdgeListItem<TEdgeData = unknown, TEdgeKind extends string = string> extends Omit<GraphEdge<TEdgeData, TEdgeKind>, "id"> {
+    readonly id?: GraphId;
+}
+export interface GraphNodeLabelContext {
+    readonly nodeId: GraphId;
+    readonly index: number;
+}
+export interface GraphEdgeIdContext<TEdgeData = unknown, TEdgeKind extends string = string> {
+    readonly entry: GraphEdgeListItem<TEdgeData, TEdgeKind>;
+    readonly index: number;
+    readonly proposedId: GraphId;
+}
+export interface GraphFromEdgeListOptions<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 groups?: readonly GraphGroup[];
+    readonly nodes?: readonly GraphNode<TNodeData, TNodeKind>[];
+    readonly getNodeLabel?: (nodeId: GraphId, context: GraphNodeLabelContext) => string;
+    readonly getEdgeId?: (entry: GraphEdgeListItem<TEdgeData, TEdgeKind>, context: GraphEdgeIdContext<TEdgeData, TEdgeKind>) => GraphId;
+}
+export interface GraphFromAdjacencyListOptions<TNodeData = unknown, TNodeKind extends string = string> {
+    readonly id?: GraphId;
+    readonly title: string;
+    readonly description?: string;
+    readonly direction?: GraphDirection;
+    readonly groups?: readonly GraphGroup[];
+    readonly nodes?: readonly GraphNode<TNodeData, TNodeKind>[];
+    readonly getNodeLabel?: (nodeId: GraphId, context: GraphNodeLabelContext) => string;
+}
+export interface GraphSubgraphOptions {
+    readonly nodeIds: readonly GraphId[];
+    readonly includeConnectedEdges?: boolean;
+    readonly includeDanglingEdges?: boolean;
+}
+export type GraphNeighborhoodDirection = "outgoing" | "incoming" | "both";
+export interface GraphNeighborhoodOptions {
+    readonly rootId: GraphId;
+    readonly direction?: GraphNeighborhoodDirection;
+    readonly maxDepth: number;
+}
+export interface GraphNodeMapperContext<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string, TEdgeKind extends string = string> {
+    readonly graph: GraphModel<TNodeData, TEdgeData, TNodeKind, TEdgeKind>;
+    readonly index: number;
+}
+export interface GraphEdgeMapperContext<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string, TEdgeKind extends string = string> {
+    readonly graph: GraphModel<TNodeData, TEdgeData, TNodeKind, TEdgeKind>;
+    readonly index: number;
+}
 export declare function createGraphIndex(graph: GraphModel): GraphIndex;
 export declare function getGraphDegrees(graph: GraphModel): Record<string, GraphDegree>;
+export declare function graphFromEdgeList<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string, TEdgeKind extends string = string>(edgeList: readonly GraphEdgeListItem<TEdgeData, TEdgeKind>[], options: GraphFromEdgeListOptions<TNodeData, TEdgeData, TNodeKind, TEdgeKind>): GraphModel<TNodeData, TEdgeData, TNodeKind, TEdgeKind>;
+export declare function graphToEdgeList<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string, TEdgeKind extends string = string>(graph: GraphModel<TNodeData, TEdgeData, TNodeKind, TEdgeKind>): readonly GraphEdge<TEdgeData, TEdgeKind>[];
+export declare function graphToAdjacencyList(graph: GraphModel): GraphAdjacencyList;
+export declare function graphFromAdjacencyList<TNodeData = unknown, TNodeKind extends string = string>(adjacencyList: GraphAdjacencyList, options: GraphFromAdjacencyListOptions<TNodeData, TNodeKind>): GraphModel<TNodeData, unknown, TNodeKind, string>;
+export declare function pickGraphSubgraph<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string, TEdgeKind extends string = string>(graph: GraphModel<TNodeData, TEdgeData, TNodeKind, TEdgeKind>, options: GraphSubgraphOptions): GraphModel<TNodeData, TEdgeData, TNodeKind, TEdgeKind>;
+export declare function getGraphNeighborhood<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string, TEdgeKind extends string = string>(graph: GraphModel<TNodeData, TEdgeData, TNodeKind, TEdgeKind>, options: GraphNeighborhoodOptions): GraphModel<TNodeData, TEdgeData, TNodeKind, TEdgeKind>;
+export declare function mapGraphNodes<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string, TEdgeKind extends string = string, TNextNodeData = TNodeData, TNextNodeKind extends string = TNodeKind>(graph: GraphModel<TNodeData, TEdgeData, TNodeKind, TEdgeKind>, mapper: (node: GraphNode<TNodeData, TNodeKind>, context: GraphNodeMapperContext<TNodeData, TEdgeData, TNodeKind, TEdgeKind>) => GraphNode<TNextNodeData, TNextNodeKind>): GraphModel<TNextNodeData, TEdgeData, TNextNodeKind, TEdgeKind>;
+export declare function mapGraphEdges<TNodeData = unknown, TEdgeData = unknown, TNodeKind extends string = string, TEdgeKind extends string = string, TNextEdgeData = TEdgeData, TNextEdgeKind extends string = TEdgeKind>(graph: GraphModel<TNodeData, TEdgeData, TNodeKind, TEdgeKind>, mapper: (edge: GraphEdge<TEdgeData, TEdgeKind>, context: GraphEdgeMapperContext<TNodeData, TEdgeData, TNodeKind, TEdgeKind>) => GraphEdge<TNextEdgeData, TNextEdgeKind>): GraphModel<TNodeData, TNextEdgeData, TNodeKind, TNextEdgeKind>;
 export declare function detectGraphCycle(graph: GraphModel): readonly GraphId[] | null;
 export interface TopologicalSortResult {
     readonly nodeIds: readonly GraphId[];
@@ -20,6 +83,15 @@ export interface TopologicalSortResult {
 }
 export declare function topologicalSortGraph(graph: GraphModel): TopologicalSortResult;
 export declare function getReachableNodeIds(graph: GraphModel, startId: GraphId): readonly GraphId[];
+export declare function getUnreachableNodeIds(graph: GraphModel, startId: GraphId): readonly GraphId[];
+export declare function getIsolatedNodeIds(graph: GraphModel): readonly GraphId[];
+export declare function getShortestPath(graph: GraphModel, sourceId: GraphId, targetId: GraphId): readonly GraphId[] | null;
+export declare function getStronglyConnectedComponents(graph: GraphModel): readonly (readonly GraphId[])[];
+export interface TransitiveReductionResult {
+    readonly edges: readonly GraphEdge[];
+    readonly diagnostics: readonly GraphDiagnostic[];
+}
+export declare function getTransitiveReductionEdges(graph: GraphModel): TransitiveReductionResult;
 export declare function getWeaklyConnectedComponents(graph: GraphModel): readonly (readonly GraphId[])[];
 export interface ValidateTreeGraphOptions {
     readonly rootId?: GraphId;