@graphty/algorithms 1.3.1 → 1.4.2

package/src/algorithms/components/connected.ts

@@ -1,6 +1,6 @@
-import type {Graph} from "../../core/graph.js";
-import {UnionFind} from "../../data-structures/union-find.js";
-import type {NodeId} from "../../types/index.js";
+import type { Graph } from "../../core/graph.js";
+import { UnionFind } from "../../data-structures/union-find.js";
+import type { NodeId } from "../../types/index.js";
 
 /**
  * Connected components algorithms
@@ -11,10 +11,14 @@ import type {NodeId} from "../../types/index.js";
 
 /**
  * Find connected components in an undirected graph using Union-Find
+ * @param graph - The input graph (must be undirected)
+ * @returns Array of connected components, each containing an array of node IDs
  */
 export function connectedComponents(graph: Graph): NodeId[][] {
     if (graph.isDirected) {
-        throw new Error("Connected components algorithm requires an undirected graph. Use stronglyConnectedComponents for directed graphs.");
+        throw new Error(
+            "Connected components algorithm requires an undirected graph. Use stronglyConnectedComponents for directed graphs.",
+        );
     }
 
     const nodes = Array.from(graph.nodes()).map((node) => node.id);
@@ -35,6 +39,8 @@ export function connectedComponents(graph: Graph): NodeId[][] {
 
 /**
  * Find connected components using DFS (alternative implementation)
+ * @param graph - The input graph (must be undirected)
+ * @returns Array of connected components, each containing an array of node IDs
  */
 export function connectedComponentsDFS(graph: Graph): NodeId[][] {
     if (graph.isDirected) {
@@ -57,13 +63,12 @@ export function connectedComponentsDFS(graph: Graph): NodeId[][] {
 
 /**
  * DFS helper for connected components
+ * @param graph - The input graph
+ * @param nodeId - The starting node ID
+ * @param visited - Set of already visited node IDs
+ * @param component - Array to accumulate component members
  */
-function dfsComponent(
-    graph: Graph,
-    nodeId: NodeId,
-    visited: Set<NodeId>,
-    component: NodeId[],
-): void {
+function dfsComponent(graph: Graph, nodeId: NodeId, visited: Set<NodeId>, component: NodeId[]): void {
     visited.add(nodeId);
     component.push(nodeId);
 
@@ -76,6 +81,8 @@ function dfsComponent(
 
 /**
  * Find the number of connected components
+ * @param graph - The input graph (must be undirected)
+ * @returns The number of connected components in the graph
  */
 export function numberOfConnectedComponents(graph: Graph): number {
     return connectedComponents(graph).length;
@@ -83,6 +90,8 @@ export function numberOfConnectedComponents(graph: Graph): number {
 
 /**
  * Check if the graph is connected (has exactly one connected component)
+ * @param graph - The input graph (must be undirected)
+ * @returns True if the graph is connected, false otherwise
  */
 export function isConnected(graph: Graph): boolean {
     return numberOfConnectedComponents(graph) <= 1;
@@ -90,6 +99,8 @@ export function isConnected(graph: Graph): boolean {
 
 /**
  * Find the largest connected component
+ * @param graph - The input graph (must be undirected)
+ * @returns Array of node IDs in the largest connected component
  */
 export function largestConnectedComponent(graph: Graph): NodeId[] {
     const components = connectedComponents(graph);
@@ -98,13 +109,14 @@ export function largestConnectedComponent(graph: Graph): NodeId[] {
         return [];
     }
 
-    return components.reduce((largest, current) =>
-        current.length > largest.length ? current : largest,
-    );
+    return components.reduce((largest, current) => (current.length > largest.length ? current : largest));
 }
 
 /**
  * Get the connected component containing a specific node
+ * @param graph - The input graph (must be undirected)
+ * @param nodeId - The node ID to find the component for
+ * @returns Array of node IDs in the same component as the specified node
  */
 export function getConnectedComponent(graph: Graph, nodeId: NodeId): NodeId[] {
     if (!graph.hasNode(nodeId)) {
@@ -125,6 +137,8 @@ export function getConnectedComponent(graph: Graph, nodeId: NodeId): NodeId[] {
 
 /**
  * Find strongly connected components using Tarjan's algorithm
+ * @param graph - The input graph (must be directed)
+ * @returns Array of strongly connected components, each containing an array of node IDs
  */
 export function stronglyConnectedComponents(graph: Graph): NodeId[][] {
     if (!graph.isDirected) {
@@ -198,6 +212,8 @@ export function stronglyConnectedComponents(graph: Graph): NodeId[][] {
 
 /**
  * Check if a directed graph is strongly connected
+ * @param graph - The input graph (must be directed)
+ * @returns True if the graph is strongly connected, false otherwise
  */
 export function isStronglyConnected(graph: Graph): boolean {
     if (!graph.isDirected) {
@@ -211,10 +227,14 @@ export function isStronglyConnected(graph: Graph): boolean {
 /**
  * Find weakly connected components in a directed graph
  * (treat the graph as undirected for connectivity)
+ * @param graph - The input graph (must be directed)
+ * @returns Array of weakly connected components, each containing an array of node IDs
  */
 export function weaklyConnectedComponents(graph: Graph): NodeId[][] {
     if (!graph.isDirected) {
-        throw new Error("Weakly connected components are for directed graphs. Use connectedComponents for undirected graphs.");
+        throw new Error(
+            "Weakly connected components are for directed graphs. Use connectedComponents for undirected graphs.",
+        );
     }
 
     const nodes = Array.from(graph.nodes()).map((node) => node.id);
@@ -235,6 +255,8 @@ export function weaklyConnectedComponents(graph: Graph): NodeId[][] {
 
 /**
  * Check if a directed graph is weakly connected
+ * @param graph - The input graph (must be directed)
+ * @returns True if the graph is weakly connected, false otherwise
  */
 export function isWeaklyConnected(graph: Graph): boolean {
     if (!graph.isDirected) {
@@ -246,6 +268,8 @@ export function isWeaklyConnected(graph: Graph): boolean {
 
 /**
  * Find condensation graph (quotient graph of strongly connected components)
+ * @param graph - The input graph (must be directed)
+ * @returns Object containing the condensed graph, component map, and component arrays
  */
 export function condensationGraph(graph: Graph): {
     condensedGraph: Graph;
@@ -258,7 +282,7 @@ export function condensationGraph(graph: Graph): {
 
     const components = stronglyConnectedComponents(graph);
     const componentMap = new Map<NodeId, number>();
-    const condensedGraph = new (graph.constructor as new (config: {directed: boolean}) => Graph)({directed: true});
+    const condensedGraph = new (graph.constructor as new (config: { directed: boolean }) => Graph)({ directed: true });
 
     // Map each node to its component index
     for (let i = 0; i < components.length; i++) {
@@ -279,8 +303,7 @@ export function condensationGraph(graph: Graph): {
         const sourceComponent = componentMap.get(edge.source);
         const targetComponent = componentMap.get(edge.target);
 
-        if (sourceComponent !== undefined && targetComponent !== undefined &&
-            sourceComponent !== targetComponent) {
+        if (sourceComponent !== undefined && targetComponent !== undefined && sourceComponent !== targetComponent) {
             const edgeKey = `${String(sourceComponent)}-${String(targetComponent)}`;
 
             if (!addedEdges.has(edgeKey)) {

package/src/algorithms/matching/bipartite.ts

@@ -1,6 +1,6 @@
-import type {Graph} from "../../core/graph.js";
-import type {NodeId} from "../../types/index.js";
-import {bfsColoringWithPartitions} from "../traversal/bfs-variants.js";
+import type { Graph } from "../../core/graph.js";
+import type { NodeId } from "../../types/index.js";
+import { bfsColoringWithPartitions } from "../traversal/bfs-variants.js";
 
 /**
  * Maximum Bipartite Matching implementation using Hopcroft-Karp algorithm
@@ -25,13 +25,17 @@ export interface BipartiteMatchingOptions {
 /**
  * Find maximum matching in a bipartite graph using augmenting path algorithm
  * (simplified implementation that's more reliable than Hopcroft-Karp for this context)
+ * @param graph - The bipartite graph to find maximum matching for
+ * @param options - Optional configuration including left and right node partitions
+ * @returns The maximum matching as a map from left nodes to right nodes and the matching size
+ * @throws Error if the graph is not bipartite
  */
 export function maximumBipartiteMatching(
     graph: Graph,
     options: BipartiteMatchingOptions = {},
 ): BipartiteMatchingResult {
     // If partitions not provided, try to infer them
-    let {leftNodes, rightNodes} = options;
+    let { leftNodes, rightNodes } = options;
 
     if (!leftNodes || !rightNodes) {
         const partition = bipartitePartition(graph);
@@ -87,8 +91,10 @@ export function maximumBipartiteMatching(
 
 /**
  * Check if graph is bipartite and return the partition
+ * @param graph - The graph to check for bipartiteness
+ * @returns An object with left and right node sets if bipartite, or null if not bipartite
  */
-export function bipartitePartition(graph: Graph): {left: Set<NodeId>, right: Set<NodeId>} | null {
+export function bipartitePartition(graph: Graph): { left: Set<NodeId>; right: Set<NodeId> } | null {
     const result = bfsColoringWithPartitions(graph);
 
     if (!result.isBipartite || !result.partitions) {
@@ -104,12 +110,13 @@ export function bipartitePartition(graph: Graph): {left: Set<NodeId>, right: Set
 /**
  * Simple greedy bipartite matching algorithm
  * Useful for comparison or when Hopcroft-Karp is overkill
+ * @param graph - The bipartite graph to find matching for
+ * @param options - Optional configuration including left and right node partitions
+ * @returns The matching as a map from left nodes to right nodes and the matching size
+ * @throws Error if the graph is not bipartite
  */
-export function greedyBipartiteMatching(
-    graph: Graph,
-    options: BipartiteMatchingOptions = {},
-): BipartiteMatchingResult {
-    let {leftNodes, rightNodes} = options;
+export function greedyBipartiteMatching(graph: Graph, options: BipartiteMatchingOptions = {}): BipartiteMatchingResult {
+    let { leftNodes, rightNodes } = options;
 
     if (!leftNodes || !rightNodes) {
         const partition = bipartitePartition(graph);

package/src/algorithms/matching/index.ts

@@ -2,7 +2,7 @@
  * Graph matching algorithms
  */
 
-export type {BipartiteMatchingOptions, BipartiteMatchingResult} from "./bipartite.js";
-export {bipartitePartition, greedyBipartiteMatching, maximumBipartiteMatching} from "./bipartite.js";
-export type {IsomorphismOptions, IsomorphismResult} from "./isomorphism.js";
-export {findAllIsomorphisms, isGraphIsomorphic} from "./isomorphism.js";
+export type { BipartiteMatchingOptions, BipartiteMatchingResult } from "./bipartite.js";
+export { bipartitePartition, greedyBipartiteMatching, maximumBipartiteMatching } from "./bipartite.js";
+export type { IsomorphismOptions, IsomorphismResult } from "./isomorphism.js";
+export { findAllIsomorphisms, isGraphIsomorphic } from "./isomorphism.js";

package/src/algorithms/matching/isomorphism.ts

@@ -1,5 +1,5 @@
-import type {Graph} from "../../core/graph.js";
-import type {NodeId} from "../../types/index.js";
+import type { Graph } from "../../core/graph.js";
+import type { NodeId } from "../../types/index.js";
 
 /**
  * Graph Isomorphism (VF2) algorithm implementation
@@ -37,19 +37,19 @@ interface VF2State {
 
 /**
  * Check if two graphs are isomorphic using VF2 algorithm
+ * @param graph1 - The first graph to compare
+ * @param graph2 - The second graph to compare
+ * @param options - Optional configuration for node and edge matching predicates
+ * @returns An object indicating if the graphs are isomorphic and an optional mapping between nodes
  */
-export function isGraphIsomorphic(
-    graph1: Graph,
-    graph2: Graph,
-    options: IsomorphismOptions = {},
-): IsomorphismResult {
+export function isGraphIsomorphic(graph1: Graph, graph2: Graph, options: IsomorphismOptions = {}): IsomorphismResult {
     // Quick checks
     if (graph1.nodeCount !== graph2.nodeCount || graph1.totalEdgeCount !== graph2.totalEdgeCount) {
-        return {isIsomorphic: false};
+        return { isIsomorphic: false };
     }
 
     if (graph1.isDirected !== graph2.isDirected) {
-        return {isIsomorphic: false};
+        return { isIsomorphic: false };
     }
 
     const nodes1 = Array.from(graph1.nodes()).map((n) => n.id);
@@ -61,7 +61,7 @@ export function isGraphIsomorphic(
 
     for (let i = 0; i < degrees1.length; i++) {
         if (degrees1[i] !== degrees2[i]) {
-            return {isIsomorphic: false};
+            return { isIsomorphic: false };
         }
     }
 
@@ -87,11 +87,19 @@ export function isGraphIsomorphic(
         };
     }
 
-    return {isIsomorphic: false};
+    return { isIsomorphic: false };
 }
 
 /**
  * VF2 recursive search
+ * @param g1 - The first graph being compared
+ * @param g2 - The second graph being compared
+ * @param state - The current VF2 algorithm state containing mappings and terminal sets
+ * @param nodes1 - Array of node IDs from the first graph
+ * @param nodes2 - Array of node IDs from the second graph
+ * @param options - Configuration options for matching predicates
+ * @param mappings - Array to collect found isomorphism mappings
+ * @returns True if an isomorphism was found and search should stop, false otherwise
  */
 function vf2Recurse(
     g1: Graph,
@@ -127,6 +135,12 @@ function vf2Recurse(
 
 /**
  * Get candidate pairs for the next mapping
+ * @param g1 - The first graph being compared
+ * @param g2 - The second graph being compared
+ * @param state - The current VF2 algorithm state containing mappings and terminal sets
+ * @param nodes1 - Array of node IDs from the first graph
+ * @param nodes2 - Array of node IDs from the second graph
+ * @returns Array of candidate node pairs to try matching
  */
 function getCandidatePairs(
     g1: Graph,
@@ -187,6 +201,13 @@ function getCandidatePairs(
 
 /**
  * Check if a pair is feasible
+ * @param g1 - The first graph being compared
+ * @param g2 - The second graph being compared
+ * @param state - The current VF2 algorithm state containing mappings and terminal sets
+ * @param node1 - The candidate node from the first graph
+ * @param node2 - The candidate node from the second graph
+ * @param options - Configuration options for matching predicates
+ * @returns True if the node pair can be feasibly matched, false otherwise
  */
 function isFeasible(
     g1: Graph,
@@ -222,8 +243,14 @@ function isFeasible(
     }
 
     // Check terminal set sizes
-    let new1In = 0; let new1Out = 0; let term1In = 0; let term1Out = 0;
-    let new2In = 0; let new2Out = 0; let term2In = 0; let term2Out = 0;
+    let new1In = 0;
+    let new1Out = 0;
+    let term1In = 0;
+    let term1Out = 0;
+    let new2In = 0;
+    let new2Out = 0;
+    let term2In = 0;
+    let term2Out = 0;
 
     for (const neighbor of neighbors1) {
         if (state.core1.has(neighbor)) {
@@ -271,20 +298,19 @@ function isFeasible(
         }
     }
 
-    return term1In === term2In && term1Out === term2Out &&
-           new1In === new2In && new1Out === new2Out;
+    return term1In === term2In && term1Out === term2Out && new1In === new2In && new1Out === new2Out;
 }
 
 /**
  * Add a pair to the mapping and update terminal sets
+ * @param g1 - The first graph being compared
+ * @param g2 - The second graph being compared
+ * @param state - The current VF2 algorithm state containing mappings and terminal sets
+ * @param node1 - The node from the first graph to add to the mapping
+ * @param node2 - The node from the second graph to add to the mapping
+ * @returns A new VF2 state with the pair added and terminal sets updated
  */
-function addPair(
-    g1: Graph,
-    g2: Graph,
-    state: VF2State,
-    node1: NodeId,
-    node2: NodeId,
-): VF2State {
+function addPair(g1: Graph, g2: Graph, state: VF2State, node1: NodeId, node2: NodeId): VF2State {
     const newState: VF2State = {
         core1: new Map(state.core1),
         core2: new Map(state.core2),
@@ -340,6 +366,10 @@ function addPair(
 
 /**
  * Find all isomorphisms between two graphs
+ * @param graph1 - The first graph to compare
+ * @param graph2 - The second graph to compare
+ * @param options - Optional configuration for node and edge matching predicates
+ * @returns An array of all possible node mappings between the graphs
  */
 export function findAllIsomorphisms(
     graph1: Graph,
@@ -386,7 +416,7 @@ export function findAllIsomorphisms(
 
     // Find all isomorphisms
     const mappings: Map<NodeId, NodeId>[] = [];
-    vf2Recurse(graph1, graph2, state, nodes1, nodes2, {... options, findAllMappings: true}, mappings);
+    vf2Recurse(graph1, graph2, state, nodes1, nodes2, { ...options, findAllMappings: true }, mappings);
 
     return mappings;
 }

package/src/algorithms/mst/index.ts

@@ -1,4 +1,3 @@
-export type {MSTResult} from "./kruskal.js";
-export {kruskalMST, minimumSpanningTree} from "./kruskal.js";
-export {primMST} from "./prim.js";
-
+export type { MSTResult } from "./kruskal.js";
+export { kruskalMST, minimumSpanningTree } from "./kruskal.js";
+export { primMST } from "./prim.js";

package/src/algorithms/mst/kruskal.ts

@@ -1,12 +1,20 @@
-import {Graph} from "../../core/graph.js";
-import {UnionFind} from "../../data-structures/union-find.js";
-import type {Edge} from "../../types/index.js";
+import { Graph } from "../../core/graph.js";
+import { UnionFind } from "../../data-structures/union-find.js";
+import type { Edge } from "../../types/index.js";
 
 export interface MSTResult {
     edges: Edge[];
     totalWeight: number;
 }
 
+/**
+ * Computes the minimum spanning tree of an undirected graph using Kruskal's algorithm.
+ * The algorithm sorts edges by weight and greedily adds edges that don't create cycles,
+ * using a union-find data structure to efficiently detect cycles.
+ * @param graph - The undirected graph to compute the MST for
+ * @returns The minimum spanning tree as a set of edges and the total weight
+ * @throws Error if the graph is directed or not connected
+ */
 export function kruskalMST(graph: Graph): MSTResult {
     if (graph.isDirected) {
         throw new Error("Kruskal's algorithm requires an undirected graph");
@@ -16,9 +24,10 @@ export function kruskalMST(graph: Graph): MSTResult {
     const visitedEdges = new Set<string>();
 
     for (const edge of Array.from(graph.edges())) {
-        const edgeKey = edge.source < edge.target ?
-            `${String(edge.source)}-${String(edge.target)}` :
-            `${String(edge.target)}-${String(edge.source)}`;
+        const edgeKey =
+            edge.source < edge.target
+                ? `${String(edge.source)}-${String(edge.target)}`
+                : `${String(edge.target)}-${String(edge.source)}`;
 
         if (!visitedEdges.has(edgeKey)) {
             visitedEdges.add(edgeKey);
@@ -56,6 +65,12 @@ export function kruskalMST(graph: Graph): MSTResult {
     };
 }
 
+/**
+ * Alias for kruskalMST. Computes the minimum spanning tree of an undirected graph.
+ * @param graph - The undirected graph to compute the MST for
+ * @returns The minimum spanning tree as a set of edges and the total weight
+ * @throws Error if the graph is directed or not connected
+ */
 export function minimumSpanningTree(graph: Graph): MSTResult {
     return kruskalMST(graph);
 }

package/src/algorithms/mst/prim.ts

@@ -1,8 +1,17 @@
-import {Graph} from "../../core/graph.js";
-import {PriorityQueue} from "../../data-structures/priority-queue.js";
-import type {Edge, NodeId} from "../../types/index.js";
-import type {MSTResult} from "./kruskal.js";
+import { Graph } from "../../core/graph.js";
+import { PriorityQueue } from "../../data-structures/priority-queue.js";
+import type { Edge, NodeId } from "../../types/index.js";
+import type { MSTResult } from "./kruskal.js";
 
+/**
+ * Computes the minimum spanning tree of an undirected graph using Prim's algorithm.
+ * The algorithm grows the MST from a starting node by repeatedly adding the minimum
+ * weight edge that connects a node in the tree to a node outside the tree.
+ * @param graph - The undirected graph to compute the MST for
+ * @param startNode - Optional starting node; if not provided, uses the first node in the graph
+ * @returns The minimum spanning tree as a set of edges and the total weight
+ * @throws Error if the graph is directed, the start node is not found, or the graph is not connected
+ */
 export function primMST(graph: Graph, startNode?: NodeId): MSTResult {
     if (graph.isDirected) {
         throw new Error("Prim's algorithm requires an undirected graph");

package/src/algorithms/shortest-path/bellman-ford.ts

@@ -1,6 +1,6 @@
-import type {Graph} from "../../core/graph.js";
-import type {NodeId, ShortestPathResult} from "../../types/index.js";
-import {reconstructPath} from "../../utils/graph-utilities.js";
+import type { Graph } from "../../core/graph.js";
+import type { NodeId, ShortestPathResult } from "../../types/index.js";
+import { reconstructPath } from "../../utils/graph-utilities.js";
 
 /**
  * Bellman-Ford algorithm implementation for single-source shortest paths
@@ -44,12 +44,12 @@ export interface BellmanFordResult {
 
 /**
  * Find shortest paths from source using Bellman-Ford algorithm
+ * @param graph - The graph to search
+ * @param source - The starting node for the search
+ * @param options - Algorithm options including optional target for early termination
+ * @returns The distances, predecessors, and negative cycle information
  */
-export function bellmanFord(
-    graph: Graph,
-    source: NodeId,
-    options: BellmanFordOptions = {},
-): BellmanFordResult {
+export function bellmanFord(graph: Graph, source: NodeId, options: BellmanFordOptions = {}): BellmanFordResult {
     if (!graph.hasNode(source)) {
         throw new Error(`Source node ${String(source)} not found in graph`);
     }
@@ -130,12 +130,12 @@ export function bellmanFord(
 
 /**
  * Find shortest path between two specific nodes using Bellman-Ford
+ * @param graph - The graph to search
+ * @param source - The starting node for the path
+ * @param target - The destination node for the path
+ * @returns The shortest path result or null if no path exists
  */
-export function bellmanFordPath(
-    graph: Graph,
-    source: NodeId,
-    target: NodeId,
-): ShortestPathResult | null {
+export function bellmanFordPath(graph: Graph, source: NodeId, target: NodeId): ShortestPathResult | null {
     if (!graph.hasNode(source)) {
         throw new Error(`Source node ${String(source)} not found in graph`);
     }
@@ -144,7 +144,7 @@ export function bellmanFordPath(
         throw new Error(`Target node ${String(target)} not found in graph`);
     }
 
-    const result = bellmanFord(graph, source, {target});
+    const result = bellmanFord(graph, source, { target });
 
     if (result.hasNegativeCycle) {
         throw new Error("Graph contains a negative cycle");
@@ -168,6 +168,8 @@ export function bellmanFordPath(
 
 /**
  * Check if graph has negative cycles using Bellman-Ford
+ * @param graph - The graph to check for negative cycles
+ * @returns True if the graph contains a negative cycle
  */
 export function hasNegativeCycle(graph: Graph): boolean {
     const nodes = Array.from(graph.nodes());
@@ -198,4 +200,3 @@ export function hasNegativeCycle(graph: Graph): boolean {
 
     return false;
 }
-

package/src/algorithms/shortest-path/bidirectional-dijkstra.ts

@@ -1,6 +1,6 @@
-import type {Graph} from "../../core/graph.js";
-import {PriorityQueue} from "../../data-structures/priority-queue.js";
-import type {NodeId, ShortestPathResult} from "../../types/index.js";
+import type { Graph } from "../../core/graph.js";
+import { PriorityQueue } from "../../data-structures/priority-queue.js";
+import type { NodeId, ShortestPathResult } from "../../types/index.js";
 
 interface SearchState {
     distances: Map<NodeId, number>;
@@ -30,6 +30,10 @@ export class BidirectionalDijkstra {
     private meetingNode: NodeId | null = null;
     private shortestDistance = Infinity;
 
+    /**
+     * Creates a new BidirectionalDijkstra instance
+     * @param graph - The graph to search for shortest paths
+     */
     constructor(graph: Graph) {
         this.graph = graph;
         this.forwardSearch = this.initSearchState();
@@ -46,10 +50,13 @@ export class BidirectionalDijkstra {
     }
 
     /**
-   * Find shortest path between source and target nodes
-   */
+     * Find shortest path between source and target nodes
+     * @param source - The starting node for the path
+     * @param target - The destination node for the path
+     * @returns The shortest path result or null if no path exists
+     */
     public findShortestPath(source: NodeId, target: NodeId): ShortestPathResult | null {
-    // Reset state for new search
+        // Reset state for new search
         this.reset();
         if (!this.graph.hasNode(source)) {
             throw new Error(`Source node ${String(source)} not found in graph`);
@@ -79,15 +86,16 @@ export class BidirectionalDijkstra {
         this.backwardSearch.frontier.enqueue(target, 0);
 
         // Main search loop
-        while (!this.forwardSearch.frontier.isEmpty() ||
-           !this.backwardSearch.frontier.isEmpty()) {
+        while (!this.forwardSearch.frontier.isEmpty() || !this.backwardSearch.frontier.isEmpty()) {
             // Alternate between forward and backward search
             // Choose the search with smaller frontier for better performance
             let searchExpanded = false;
 
-            if (!this.forwardSearch.frontier.isEmpty() &&
-          (this.backwardSearch.frontier.isEmpty() ||
-           this.forwardSearch.frontier.size() <= this.backwardSearch.frontier.size())) {
+            if (
+                !this.forwardSearch.frontier.isEmpty() &&
+                (this.backwardSearch.frontier.isEmpty() ||
+                    this.forwardSearch.frontier.size() <= this.backwardSearch.frontier.size())
+            ) {
                 if (this.expandSearch(this.forwardSearch, this.backwardSearch, true)) {
                     break;
                 }
@@ -102,8 +110,7 @@ export class BidirectionalDijkstra {
             }
 
             // Continue until both frontiers are empty or we've found an optimal path
-            if (this.forwardSearch.frontier.isEmpty() &&
-          this.backwardSearch.frontier.isEmpty()) {
+            if (this.forwardSearch.frontier.isEmpty() && this.backwardSearch.frontier.isEmpty()) {
                 break;
             }
         }
@@ -119,11 +126,7 @@ export class BidirectionalDijkstra {
         };
     }
 
-    private expandSearch(
-        search: SearchState,
-        oppositeSearch: SearchState,
-        isForward: boolean,
-    ): boolean {
+    private expandSearch(search: SearchState, oppositeSearch: SearchState, isForward: boolean): boolean {
         const current = search.frontier.dequeue();
         if (current === undefined) {
             return false;
@@ -150,18 +153,16 @@ export class BidirectionalDijkstra {
         }
 
         // Explore neighbors
-        const neighbors = isForward ?
-            Array.from(this.graph.neighbors(current)) :
-            Array.from(this.graph.inNeighbors(current));
+        const neighbors = isForward
+            ? Array.from(this.graph.neighbors(current))
+            : Array.from(this.graph.inNeighbors(current));
 
         for (const neighbor of neighbors) {
             if (search.visited.has(neighbor)) {
                 continue;
             }
 
-            const edge = isForward ?
-                this.graph.getEdge(current, neighbor) :
-                this.graph.getEdge(neighbor, current);
+            const edge = isForward ? this.graph.getEdge(current, neighbor) : this.graph.getEdge(neighbor, current);
 
             if (!edge) {
                 continue;
@@ -175,8 +176,7 @@ export class BidirectionalDijkstra {
             const newDistance = distance + edgeWeight;
             const currentNeighborDistance = search.distances.get(neighbor);
 
-            if (!search.distances.has(neighbor) ||
-          newDistance < (currentNeighborDistance ?? Infinity)) {
+            if (!search.distances.has(neighbor) || newDistance < (currentNeighborDistance ?? Infinity)) {
                 search.distances.set(neighbor, newDistance);
                 search.previous.set(neighbor, current);
                 search.frontier.enqueue(neighbor, newDistance);
@@ -237,8 +237,8 @@ export class BidirectionalDijkstra {
     }
 
     /**
-   * Reset the search state for reuse
-   */
+     * Reset the search state for reuse
+     */
     public reset(): void {
         this.forwardSearch = this.initSearchState();
         this.backwardSearch = this.initSearchState();