@osmix/router 0.0.11 → 0.1.0

package/test/algorithms.test.ts

@@ -1,6 +1,7 @@
-import { describe, expect, it } from "bun:test"
-import { astar, bidirectional, dijkstra } from "../src/algorithms"
-import type { GraphEdge } from "../src/types"
+import { describe, expect, it } from "vitest";
+
+import { astar, bidirectional, dijkstra } from "../src/algorithms";
+import type { GraphEdge } from "../src/types";
 
 /**
  * Test suite for individual routing algorithms.
@@ -18,33 +19,56 @@ import type { GraphEdge } from "../src/types"
  * Creates a simple graph function from an adjacency list.
  * The adjacency list maps node IDs to their outgoing edges.
  */
-function createGraph(
-	adjacencyList: Map<number, GraphEdge[]>,
-): (nodeId: number) => GraphEdge[] {
-	return (nodeId: number) => adjacencyList.get(nodeId) ?? []
+function createGraph(adjacencyList: Map<number, GraphEdge[]>): (nodeId: number) => GraphEdge[] {
+  return (nodeId: number) => adjacencyList.get(nodeId) ?? [];
+}
+
+/**
+ * Creates the incoming-edge function for an adjacency list, as bidirectional needs.
+ * In each returned edge, `targetNodeIndex` is the source node.
+ */
+function createReverseContext(adjacencyList: Map<number, GraphEdge[]>) {
+  const incoming = new Map<number, GraphEdge[]>();
+  for (const [source, edges] of adjacencyList) {
+    for (const edge of edges) {
+      const list = incoming.get(edge.targetNodeIndex) ?? [];
+      list.push({ ...edge, targetNodeIndex: source });
+      incoming.set(edge.targetNodeIndex, list);
+    }
+  }
+  return { reverseGraph: (nodeId: number) => incoming.get(nodeId) ?? [] };
+}
+
+/** Run bidirectional search over an adjacency list. */
+function runBidirectional(adjacencyList: Map<number, GraphEdge[]>, start: number, end: number) {
+  return bidirectional(
+    createGraph(adjacencyList),
+    start,
+    end,
+    distanceWeight,
+    undefined,
+    undefined,
+    createReverseContext(adjacencyList),
+  );
 }
 
 /**
  * Simple edge weight function that uses distance.
  */
 function distanceWeight(edge: GraphEdge): number {
-	return edge.distance
+  return edge.distance;
 }
 
 /**
  * Creates a mock edge with default values.
  */
-function mockEdge(
-	targetNodeIndex: number,
-	wayIndex: number,
-	distance: number,
-): GraphEdge {
-	return {
-		targetNodeIndex: targetNodeIndex,
-		wayIndex,
-		distance,
-		time: distance / 10, // 10 m/s default speed
-	}
+function mockEdge(targetNodeIndex: number, wayIndex: number, distance: number): GraphEdge {
+  return {
+    targetNodeIndex: targetNodeIndex,
+    wayIndex,
+    distance,
+    time: distance / 10, // 10 m/s default speed
+  };
 }
 
 /**
@@ -52,12 +76,12 @@ function mockEdge(
  * Bidirectional edges for proper routing.
  */
 function createLinearGraph(): Map<number, GraphEdge[]> {
-	return new Map([
-		[1, [mockEdge(2, 100, 10)]],
-		[2, [mockEdge(1, 100, 10), mockEdge(3, 101, 10)]],
-		[3, [mockEdge(2, 101, 10), mockEdge(4, 102, 10)]],
-		[4, [mockEdge(3, 102, 10)]],
-	])
+  return new Map([
+    [1, [mockEdge(2, 100, 10)]],
+    [2, [mockEdge(1, 100, 10), mockEdge(3, 101, 10)]],
+    [3, [mockEdge(2, 101, 10), mockEdge(4, 102, 10)]],
+    [4, [mockEdge(3, 102, 10)]],
+  ]);
 }
 
 /**
@@ -73,12 +97,12 @@ function createLinearGraph(): Map<number, GraphEdge[]> {
  * Path 1->3->4 has distance 15
  */
 function createSquareGraph(): Map<number, GraphEdge[]> {
-	return new Map([
-		[1, [mockEdge(2, 100, 10), mockEdge(3, 101, 5)]],
-		[2, [mockEdge(1, 100, 10), mockEdge(4, 102, 5)]],
-		[3, [mockEdge(1, 101, 5), mockEdge(4, 103, 10)]],
-		[4, [mockEdge(2, 102, 5), mockEdge(3, 103, 10)]],
-	])
+  return new Map([
+    [1, [mockEdge(2, 100, 10), mockEdge(3, 101, 5)]],
+    [2, [mockEdge(1, 100, 10), mockEdge(4, 102, 5)]],
+    [3, [mockEdge(1, 101, 5), mockEdge(4, 103, 10)]],
+    [4, [mockEdge(2, 102, 5), mockEdge(3, 103, 10)]],
+  ]);
 }
 
 /**
@@ -94,18 +118,18 @@ function createSquareGraph(): Map<number, GraphEdge[]> {
  * Indirect path: 30 (should be chosen)
  */
 function createIndirectShorterGraph(): Map<number, GraphEdge[]> {
-	return new Map([
-		[
-			1,
-			[
-				mockEdge(4, 100, 100), // Direct but long
-				mockEdge(2, 101, 10), // Indirect start
-			],
-		],
-		[2, [mockEdge(1, 101, 10), mockEdge(3, 102, 10)]],
-		[3, [mockEdge(2, 102, 10), mockEdge(4, 103, 10)]],
-		[4, [mockEdge(1, 100, 100), mockEdge(3, 103, 10)]],
-	])
+  return new Map([
+    [
+      1,
+      [
+        mockEdge(4, 100, 100), // Direct but long
+        mockEdge(2, 101, 10), // Indirect start
+      ],
+    ],
+    [2, [mockEdge(1, 101, 10), mockEdge(3, 102, 10)]],
+    [3, [mockEdge(2, 102, 10), mockEdge(4, 103, 10)]],
+    [4, [mockEdge(1, 100, 100), mockEdge(3, 103, 10)]],
+  ]);
 }
 
 /**
@@ -113,12 +137,12 @@ function createIndirectShorterGraph(): Map<number, GraphEdge[]> {
  * Nodes 1-3 are connected bidirectionally, but 4 has no edges.
  */
 function createDisconnectedGraph(): Map<number, GraphEdge[]> {
-	return new Map([
-		[1, [mockEdge(2, 100, 10)]],
-		[2, [mockEdge(1, 100, 10), mockEdge(3, 101, 10)]],
-		[3, [mockEdge(2, 101, 10)]],
-		[4, []], // Unreachable - no edges to/from this node
-	])
+  return new Map([
+    [1, [mockEdge(2, 100, 10)]],
+    [2, [mockEdge(1, 100, 10), mockEdge(3, 101, 10)]],
+    [3, [mockEdge(2, 101, 10)]],
+    [4, []], // Unreachable - no edges to/from this node
+  ]);
 }
 
 /**
@@ -135,13 +159,13 @@ function createDisconnectedGraph(): Map<number, GraphEdge[]> {
  * Edge weights are 10+ units, so heuristic <= actual cost (admissible).
  */
 function createCoordFn(): (nodeId: number) => [number, number] | undefined {
-	const coords = new Map<number, [number, number]>([
-		[1, [0, 0]],
-		[2, [0.00005, 0]], // ~5m east
-		[3, [0.0001, 0]], // ~10m east
-		[4, [0.00015, 0]], // ~15m east
-	])
-	return (nodeId: number) => coords.get(nodeId)
+  const coords = new Map<number, [number, number]>([
+    [1, [0, 0]],
+    [2, [0.00005, 0]], // ~5m east
+    [3, [0.0001, 0]], // ~10m east
+    [4, [0.00015, 0]], // ~15m east
+  ]);
+  return (nodeId: number) => coords.get(nodeId);
 }
 
 // ---------------------------------------------------------------------------
@@ -149,318 +173,337 @@ function createCoordFn(): (nodeId: number) => [number, number] | undefined {
 // ---------------------------------------------------------------------------
 
 describe("dijkstra", () => {
-	it("should find direct path between adjacent nodes", () => {
-		const graph = createGraph(createLinearGraph())
-		const path = dijkstra(graph, 1, 2, distanceWeight)
-
-		expect(path).not.toBeNull()
-		expect(path?.length).toBe(2)
-		expect(path?.[0]?.nodeIndex).toBe(1)
-		expect(path?.[1]?.nodeIndex).toBe(2)
-		expect(path?.[1]?.wayIndex).toBe(100)
-	})
-
-	it("should find path through multiple nodes", () => {
-		const graph = createGraph(createLinearGraph())
-		const path = dijkstra(graph, 1, 4, distanceWeight)
-
-		expect(path).not.toBeNull()
-		expect(path?.length).toBe(4)
-
-		// Verify node order
-		const nodeIds = path?.map((p) => p.nodeIndex)
-		expect(nodeIds).toEqual([1, 2, 3, 4])
-
-		// Verify way indexes are tracked
-		expect(path?.[1]?.wayIndex).toBe(100)
-		expect(path?.[2]?.wayIndex).toBe(101)
-		expect(path?.[3]?.wayIndex).toBe(102)
-	})
-
-	it("should return null when no path exists", () => {
-		const graph = createGraph(createDisconnectedGraph())
-		const path = dijkstra(graph, 1, 4, distanceWeight)
-
-		expect(path).toBeNull()
-	})
-
-	it("should handle same start and end node", () => {
-		const graph = createGraph(createLinearGraph())
-		const path = dijkstra(graph, 1, 1, distanceWeight)
-
-		expect(path).not.toBeNull()
-		expect(path?.length).toBe(1)
-		expect(path?.[0]?.nodeIndex).toBe(1)
-	})
-
-	it("should find shortest path when indirect is shorter", () => {
-		const graph = createGraph(createIndirectShorterGraph())
-		const path = dijkstra(graph, 1, 4, distanceWeight)
-
-		expect(path).not.toBeNull()
-
-		// Should take indirect route 1->2->3->4 (cost 30) not 1->4 (cost 100)
-		const nodeIds = path?.map((p) => p.nodeIndex)
-		expect(nodeIds).toEqual([1, 2, 3, 4])
-
-		// Verify total cost
-		const lastSegment = path?.[path.length - 1]
-		expect(lastSegment?.cost).toBe(30)
-	})
-
-	it("should calculate correct costs", () => {
-		const graph = createGraph(createLinearGraph())
-		const path = dijkstra(graph, 1, 4, distanceWeight)
-
-		expect(path).not.toBeNull()
-
-		// Each edge has distance 10
-		expect(path?.[0]?.cost).toBe(0) // Start node
-		expect(path?.[1]?.cost).toBe(10)
-		expect(path?.[2]?.cost).toBe(20)
-		expect(path?.[3]?.cost).toBe(30)
-	})
-
-	it("should track correct way indexes in path", () => {
-		const graph = createGraph(createSquareGraph())
-		const path = dijkstra(graph, 1, 4, distanceWeight)
-
-		expect(path).not.toBeNull()
-
-		// Verify way indexes are present for traversed edges
-		const wayIndexes = path?.slice(1).map((p) => p.wayIndex)
-		expect(wayIndexes?.every((idx) => idx !== undefined)).toBe(true)
-	})
-})
+  it("should find direct path between adjacent nodes", () => {
+    const graph = createGraph(createLinearGraph());
+    const path = dijkstra(graph, 1, 2, distanceWeight);
+
+    expect(path).not.toBeNull();
+    expect(path?.length).toBe(2);
+    expect(path?.[0]?.nodeIndex).toBe(1);
+    expect(path?.[1]?.nodeIndex).toBe(2);
+    expect(path?.[1]?.wayIndex).toBe(100);
+  });
+
+  it("should find path through multiple nodes", () => {
+    const graph = createGraph(createLinearGraph());
+    const path = dijkstra(graph, 1, 4, distanceWeight);
+
+    expect(path).not.toBeNull();
+    expect(path?.length).toBe(4);
+
+    // Verify node order
+    const nodeIds = path?.map((p) => p.nodeIndex);
+    expect(nodeIds).toEqual([1, 2, 3, 4]);
+
+    // Verify way indexes are tracked
+    expect(path?.[1]?.wayIndex).toBe(100);
+    expect(path?.[2]?.wayIndex).toBe(101);
+    expect(path?.[3]?.wayIndex).toBe(102);
+  });
+
+  it("should return null when no path exists", () => {
+    const graph = createGraph(createDisconnectedGraph());
+    const path = dijkstra(graph, 1, 4, distanceWeight);
+
+    expect(path).toBeNull();
+  });
+
+  it("should handle same start and end node", () => {
+    const graph = createGraph(createLinearGraph());
+    const path = dijkstra(graph, 1, 1, distanceWeight);
+
+    expect(path).not.toBeNull();
+    expect(path?.length).toBe(1);
+    expect(path?.[0]?.nodeIndex).toBe(1);
+  });
+
+  it("should find shortest path when indirect is shorter", () => {
+    const graph = createGraph(createIndirectShorterGraph());
+    const path = dijkstra(graph, 1, 4, distanceWeight);
+
+    expect(path).not.toBeNull();
+
+    // Should take indirect route 1->2->3->4 (cost 30) not 1->4 (cost 100)
+    const nodeIds = path?.map((p) => p.nodeIndex);
+    expect(nodeIds).toEqual([1, 2, 3, 4]);
+
+    // Verify total cost
+    const lastSegment = path?.[path.length - 1];
+    expect(lastSegment?.cost).toBe(30);
+  });
+
+  it("should calculate correct costs", () => {
+    const graph = createGraph(createLinearGraph());
+    const path = dijkstra(graph, 1, 4, distanceWeight);
+
+    expect(path).not.toBeNull();
+
+    // Each edge has distance 10
+    expect(path?.[0]?.cost).toBe(0); // Start node
+    expect(path?.[1]?.cost).toBe(10);
+    expect(path?.[2]?.cost).toBe(20);
+    expect(path?.[3]?.cost).toBe(30);
+  });
+
+  it("should track correct way indexes in path", () => {
+    const graph = createGraph(createSquareGraph());
+    const path = dijkstra(graph, 1, 4, distanceWeight);
+
+    expect(path).not.toBeNull();
+
+    // Verify way indexes are present for traversed edges
+    const wayIndexes = path?.slice(1).map((p) => p.wayIndex);
+    expect(wayIndexes?.every((idx) => idx !== undefined)).toBe(true);
+  });
+});
 
 // ---------------------------------------------------------------------------
 // A* Tests
 // ---------------------------------------------------------------------------
 
 describe("astar", () => {
-	it("should find direct path between adjacent nodes", () => {
-		const graph = createGraph(createLinearGraph())
-		const path = astar(graph, 1, 2, distanceWeight, createCoordFn())
-
-		expect(path).not.toBeNull()
-		expect(path?.length).toBe(2)
-		expect(path?.[0]?.nodeIndex).toBe(1)
-		expect(path?.[1]?.nodeIndex).toBe(2)
-	})
-
-	it("should find path through multiple nodes", () => {
-		const graph = createGraph(createLinearGraph())
-		const path = astar(graph, 1, 4, distanceWeight, createCoordFn())
-
-		expect(path).not.toBeNull()
-		const nodeIds = path?.map((p) => p.nodeIndex)
-		expect(nodeIds).toEqual([1, 2, 3, 4])
-	})
-
-	it("should return null when no path exists", () => {
-		const graph = createGraph(createDisconnectedGraph())
-		const path = astar(graph, 1, 4, distanceWeight, createCoordFn())
-
-		expect(path).toBeNull()
-	})
-
-	it("should handle same start and end node", () => {
-		const graph = createGraph(createLinearGraph())
-		const path = astar(graph, 1, 1, distanceWeight, createCoordFn())
-
-		expect(path).not.toBeNull()
-		expect(path?.length).toBe(1)
-		expect(path?.[0]?.nodeIndex).toBe(1)
-	})
-
-	it("should find shortest path when indirect is shorter", () => {
-		const graph = createGraph(createIndirectShorterGraph())
-		const path = astar(graph, 1, 4, distanceWeight, createCoordFn())
-
-		expect(path).not.toBeNull()
-		const nodeIds = path?.map((p) => p.nodeIndex)
-		expect(nodeIds).toEqual([1, 2, 3, 4])
-	})
-
-	it("should use heuristic to guide search", () => {
-		// With heuristic, A* should explore fewer nodes than Dijkstra
-		// We can verify it finds the correct path
-		const graph = createGraph(createIndirectShorterGraph())
-		const path = astar(graph, 1, 4, distanceWeight, createCoordFn())
-
-		expect(path).not.toBeNull()
-		expect(path?.[path.length - 1]?.cost).toBe(30)
-	})
-
-	it("should return null when coordinate function is missing", () => {
-		const graph = createGraph(createLinearGraph())
-		const path = astar(graph, 1, 4, distanceWeight, undefined)
-
-		expect(path).toBeNull()
-	})
-
-	it("should handle missing coordinate for node gracefully", () => {
-		const graph = createGraph(createLinearGraph())
-		// Coordinate function that only knows about nodes 1 and 4
-		const partialCoordFn = (nodeId: number) => {
-			if (nodeId === 1) return [0, 0] as [number, number]
-			if (nodeId === 4) return [0.001, 0.001] as [number, number]
-			return undefined
-		}
-		const path = astar(graph, 1, 4, distanceWeight, partialCoordFn)
-
-		// A* should still find a path, using 0 heuristic for unknown nodes
-		expect(path).not.toBeNull()
-		const nodeIds = path?.map((p) => p.nodeIndex)
-		expect(nodeIds).toEqual([1, 2, 3, 4])
-	})
-
-	it("should track correct way indexes in path", () => {
-		const graph = createGraph(createSquareGraph())
-		const path = astar(graph, 1, 4, distanceWeight, createCoordFn())
-
-		expect(path).not.toBeNull()
-		const wayIndexes = path?.slice(1).map((p) => p.wayIndex)
-		expect(wayIndexes?.every((idx) => idx !== undefined)).toBe(true)
-	})
-})
+  it("should find direct path between adjacent nodes", () => {
+    const graph = createGraph(createLinearGraph());
+    const path = astar(graph, 1, 2, distanceWeight, createCoordFn());
+
+    expect(path).not.toBeNull();
+    expect(path?.length).toBe(2);
+    expect(path?.[0]?.nodeIndex).toBe(1);
+    expect(path?.[1]?.nodeIndex).toBe(2);
+  });
+
+  it("should find path through multiple nodes", () => {
+    const graph = createGraph(createLinearGraph());
+    const path = astar(graph, 1, 4, distanceWeight, createCoordFn());
+
+    expect(path).not.toBeNull();
+    const nodeIds = path?.map((p) => p.nodeIndex);
+    expect(nodeIds).toEqual([1, 2, 3, 4]);
+  });
+
+  it("should return null when no path exists", () => {
+    const graph = createGraph(createDisconnectedGraph());
+    const path = astar(graph, 1, 4, distanceWeight, createCoordFn());
+
+    expect(path).toBeNull();
+  });
+
+  it("should handle same start and end node", () => {
+    const graph = createGraph(createLinearGraph());
+    const path = astar(graph, 1, 1, distanceWeight, createCoordFn());
+
+    expect(path).not.toBeNull();
+    expect(path?.length).toBe(1);
+    expect(path?.[0]?.nodeIndex).toBe(1);
+  });
+
+  it("should find shortest path when indirect is shorter", () => {
+    const graph = createGraph(createIndirectShorterGraph());
+    const path = astar(graph, 1, 4, distanceWeight, createCoordFn());
+
+    expect(path).not.toBeNull();
+    const nodeIds = path?.map((p) => p.nodeIndex);
+    expect(nodeIds).toEqual([1, 2, 3, 4]);
+  });
+
+  it("should use heuristic to guide search", () => {
+    // With heuristic, A* should explore fewer nodes than Dijkstra
+    // We can verify it finds the correct path
+    const graph = createGraph(createIndirectShorterGraph());
+    const path = astar(graph, 1, 4, distanceWeight, createCoordFn());
+
+    expect(path).not.toBeNull();
+    expect(path?.[path.length - 1]?.cost).toBe(30);
+  });
+
+  it("should return null when coordinate function is missing", () => {
+    const graph = createGraph(createLinearGraph());
+    const path = astar(graph, 1, 4, distanceWeight, undefined);
+
+    expect(path).toBeNull();
+  });
+
+  it("should handle missing coordinate for node gracefully", () => {
+    const graph = createGraph(createLinearGraph());
+    // Coordinate function that only knows about nodes 1 and 4
+    const partialCoordFn = (nodeId: number) => {
+      if (nodeId === 1) return [0, 0] as [number, number];
+      if (nodeId === 4) return [0.001, 0.001] as [number, number];
+      return undefined;
+    };
+    const path = astar(graph, 1, 4, distanceWeight, partialCoordFn);
+
+    // A* should still find a path, using 0 heuristic for unknown nodes
+    expect(path).not.toBeNull();
+    const nodeIds = path?.map((p) => p.nodeIndex);
+    expect(nodeIds).toEqual([1, 2, 3, 4]);
+  });
+
+  it("should track correct way indexes in path", () => {
+    const graph = createGraph(createSquareGraph());
+    const path = astar(graph, 1, 4, distanceWeight, createCoordFn());
+
+    expect(path).not.toBeNull();
+    const wayIndexes = path?.slice(1).map((p) => p.wayIndex);
+    expect(wayIndexes?.every((idx) => idx !== undefined)).toBe(true);
+  });
+});
 
 // ---------------------------------------------------------------------------
 // Bidirectional Tests
 // ---------------------------------------------------------------------------
 
 describe("bidirectional", () => {
-	it("should find direct path between adjacent nodes", () => {
-		const graph = createGraph(createLinearGraph())
-		const path = bidirectional(graph, 1, 2, distanceWeight)
-
-		expect(path).not.toBeNull()
-		// Bidirectional may have different path structure but same nodes
-		const nodeIds = path?.map((p) => p.nodeIndex)
-		expect(nodeIds).toContain(1)
-		expect(nodeIds).toContain(2)
-	})
-
-	it("should find path through multiple nodes", () => {
-		const graph = createGraph(createLinearGraph())
-		const path = bidirectional(graph, 1, 4, distanceWeight)
-
-		expect(path).not.toBeNull()
-		const nodeIds = path?.map((p) => p.nodeIndex)
-		// Should contain all nodes in the path
-		expect(nodeIds).toContain(1)
-		expect(nodeIds).toContain(4)
-	})
-
-	it("should return null when no path exists", () => {
-		const graph = createGraph(createDisconnectedGraph())
-		const path = bidirectional(graph, 1, 4, distanceWeight)
-
-		expect(path).toBeNull()
-	})
-
-	it("should handle same start and end node", () => {
-		const graph = createGraph(createLinearGraph())
-		const path = bidirectional(graph, 1, 1, distanceWeight)
-
-		expect(path).not.toBeNull()
-		expect(path?.some((p) => p.nodeIndex === 1)).toBe(true)
-	})
-
-	it("should meet in the middle correctly", () => {
-		// Create a symmetric graph where meeting in middle is clear
-		// 1 <-> 2 <-> 3 <-> 4 <-> 5
-		const symmetricGraph = new Map([
-			[1, [mockEdge(2, 100, 10)]],
-			[2, [mockEdge(1, 100, 10), mockEdge(3, 101, 10)]],
-			[3, [mockEdge(2, 101, 10), mockEdge(4, 102, 10)]],
-			[4, [mockEdge(3, 102, 10), mockEdge(5, 103, 10)]],
-			[5, [mockEdge(4, 103, 10)]],
-		])
-
-		const graph = createGraph(symmetricGraph)
-		const path = bidirectional(graph, 1, 5, distanceWeight)
-
-		expect(path).not.toBeNull()
-		// Should include start and end
-		const nodeIds = path?.map((p) => p.nodeIndex)
-		expect(nodeIds).toContain(1)
-		expect(nodeIds).toContain(5)
-	})
-
-	it("should combine forward and backward paths properly", () => {
-		const graph = createGraph(createSquareGraph())
-		const path = bidirectional(graph, 1, 4, distanceWeight)
-
-		expect(path).not.toBeNull()
-
-		// Path should go from 1 to 4
-		const nodeIds = path?.map((p) => p.nodeIndex)
-		expect(nodeIds?.[0]).toBe(1)
-		// Last node should be 4 or path should include 4
-		expect(nodeIds).toContain(4)
-	})
-
-	it("should track way indexes in combined path", () => {
-		const graph = createGraph(createSquareGraph())
-		const path = bidirectional(graph, 1, 4, distanceWeight)
-
-		expect(path).not.toBeNull()
-
-		// Way indexes should be present (except possibly for start node)
-		const wayIndexes = path
-			?.filter((p) => p.wayIndex !== undefined)
-			.map((p) => p.wayIndex)
-		expect(wayIndexes?.length).toBeGreaterThan(0)
-	})
-})
+  it("follows one-way edges backward from the end", () => {
+    // 1 -> 2 -> 3 is one-way; 1 <-> 4 <-> 3 is a longer two-way detour.
+    // Going 3 to 1 must take the detour: the old search followed 3's outgoing
+    // edges from the end and could return 3 -> 2 -> 1 against the one-way.
+    const oneWay = new Map([
+      [1, [mockEdge(2, 100, 1), mockEdge(4, 101, 10)]],
+      [2, [mockEdge(3, 100, 1)]],
+      [3, [mockEdge(4, 102, 10)]],
+      [4, [mockEdge(1, 101, 10), mockEdge(3, 102, 10)]],
+    ]);
+    expect(runBidirectional(oneWay, 3, 1)?.map((p) => p.nodeIndex)).toEqual([3, 4, 1]);
+    expect(runBidirectional(oneWay, 1, 3)?.map((p) => p.nodeIndex)).toEqual([1, 2, 3]);
+  });
+
+  it("reports costs from the start on both halves of the path", () => {
+    const path = runBidirectional(createIndirectShorterGraph(), 1, 4);
+    expect(path?.map((p) => p.cost)).toEqual([0, 10, 20, 30]);
+  });
+
+  it("throws without a reverse graph", () => {
+    expect(() => bidirectional(createGraph(createLinearGraph()), 1, 4, distanceWeight)).toThrow(
+      /reverseGraph/,
+    );
+  });
+
+  it("should find direct path between adjacent nodes", () => {
+    const path = runBidirectional(createLinearGraph(), 1, 2);
+
+    expect(path).not.toBeNull();
+    // Bidirectional may have different path structure but same nodes
+    const nodeIds = path?.map((p) => p.nodeIndex);
+    expect(nodeIds).toContain(1);
+    expect(nodeIds).toContain(2);
+  });
+
+  it("should find path through multiple nodes", () => {
+    const path = runBidirectional(createLinearGraph(), 1, 4);
+
+    expect(path).not.toBeNull();
+    const nodeIds = path?.map((p) => p.nodeIndex);
+    // Should contain all nodes in the path
+    expect(nodeIds).toContain(1);
+    expect(nodeIds).toContain(4);
+  });
+
+  it("should return null when no path exists", () => {
+    const path = runBidirectional(createDisconnectedGraph(), 1, 4);
+
+    expect(path).toBeNull();
+  });
+
+  it("should handle same start and end node", () => {
+    const path = runBidirectional(createLinearGraph(), 1, 1);
+
+    expect(path).not.toBeNull();
+    expect(path?.some((p) => p.nodeIndex === 1)).toBe(true);
+  });
+
+  it("should meet in the middle correctly", () => {
+    // Create a symmetric graph where meeting in middle is clear
+    // 1 <-> 2 <-> 3 <-> 4 <-> 5
+    const symmetricGraph = new Map([
+      [1, [mockEdge(2, 100, 10)]],
+      [2, [mockEdge(1, 100, 10), mockEdge(3, 101, 10)]],
+      [3, [mockEdge(2, 101, 10), mockEdge(4, 102, 10)]],
+      [4, [mockEdge(3, 102, 10), mockEdge(5, 103, 10)]],
+      [5, [mockEdge(4, 103, 10)]],
+    ]);
+
+    const path = runBidirectional(symmetricGraph, 1, 5);
+
+    expect(path).not.toBeNull();
+    // Should include start and end
+    const nodeIds = path?.map((p) => p.nodeIndex);
+    expect(nodeIds).toContain(1);
+    expect(nodeIds).toContain(5);
+  });
+
+  it("should combine forward and backward paths properly", () => {
+    const path = runBidirectional(createSquareGraph(), 1, 4);
+
+    expect(path).not.toBeNull();
+
+    // Path should go from 1 to 4
+    const nodeIds = path?.map((p) => p.nodeIndex);
+    expect(nodeIds?.[0]).toBe(1);
+    // Last node should be 4 or path should include 4
+    expect(nodeIds).toContain(4);
+  });
+
+  it("should track way indexes in combined path", () => {
+    const path = runBidirectional(createSquareGraph(), 1, 4);
+
+    expect(path).not.toBeNull();
+
+    // Way indexes should be present (except possibly for start node)
+    const wayIndexes = path?.filter((p) => p.wayIndex !== undefined).map((p) => p.wayIndex);
+    expect(wayIndexes?.length).toBeGreaterThan(0);
+  });
+});
 
 // ---------------------------------------------------------------------------
 // Cross-Algorithm Comparison Tests
 // ---------------------------------------------------------------------------
 
 describe("algorithm consistency", () => {
-	it("should find same path length with all algorithms", () => {
-		const graph = createGraph(createIndirectShorterGraph())
-
-		const dijkstraPath = dijkstra(graph, 1, 4, distanceWeight)
-		const astarPath = astar(graph, 1, 4, distanceWeight, createCoordFn())
-		const biPath = bidirectional(graph, 1, 4, distanceWeight)
-
-		// All should find a path
-		expect(dijkstraPath).not.toBeNull()
-		expect(astarPath).not.toBeNull()
-		expect(biPath).not.toBeNull()
-
-		// Dijkstra and A* should have same final cost
-		const dijkstraCost = dijkstraPath?.[dijkstraPath.length - 1]?.cost
-		const astarCost = astarPath?.[astarPath.length - 1]?.cost
-
-		expect(dijkstraCost).toBe(astarCost)
-	})
-
-	it("all algorithms should return null for unreachable nodes", () => {
-		const graph = createGraph(createDisconnectedGraph())
-
-		expect(dijkstra(graph, 1, 4, distanceWeight)).toBeNull()
-		expect(astar(graph, 1, 4, distanceWeight, createCoordFn())).toBeNull()
-		expect(bidirectional(graph, 1, 4, distanceWeight)).toBeNull()
-	})
-
-	it("all algorithms should handle trivial single-node path", () => {
-		const graph = createGraph(createLinearGraph())
-
-		const dijkstraPath = dijkstra(graph, 1, 1, distanceWeight)
-		const astarPath = astar(graph, 1, 1, distanceWeight, createCoordFn())
-		const biPath = bidirectional(graph, 1, 1, distanceWeight)
-
-		expect(dijkstraPath).not.toBeNull()
-		expect(astarPath).not.toBeNull()
-		expect(biPath).not.toBeNull()
-
-		// All should include node 1
-		expect(dijkstraPath?.some((p) => p.nodeIndex === 1)).toBe(true)
-		expect(astarPath?.some((p) => p.nodeIndex === 1)).toBe(true)
-		expect(biPath?.some((p) => p.nodeIndex === 1)).toBe(true)
-	})
-})
+  it("should find same path length with all algorithms", () => {
+    const graph = createGraph(createIndirectShorterGraph());
+
+    const dijkstraPath = dijkstra(graph, 1, 4, distanceWeight);
+    const astarPath = astar(graph, 1, 4, distanceWeight, createCoordFn());
+    const biPath = runBidirectional(createIndirectShorterGraph(), 1, 4);
+
+    // All should find a path
+    expect(dijkstraPath).not.toBeNull();
+    expect(astarPath).not.toBeNull();
+    expect(biPath).not.toBeNull();
+
+    // All three are optimal, so they share the final cost
+    const dijkstraCost = dijkstraPath?.[dijkstraPath.length - 1]?.cost;
+    const astarCost = astarPath?.[astarPath.length - 1]?.cost;
+    const biCost = biPath?.[biPath.length - 1]?.cost;
+
+    expect(dijkstraCost).toBe(astarCost);
+    expect(biCost).toBe(dijkstraCost);
+    expect(biPath?.map((p) => p.nodeIndex)).toEqual([1, 2, 3, 4]);
+  });
+
+  it("all algorithms should return null for unreachable nodes", () => {
+    const graph = createGraph(createDisconnectedGraph());
+
+    expect(dijkstra(graph, 1, 4, distanceWeight)).toBeNull();
+    expect(astar(graph, 1, 4, distanceWeight, createCoordFn())).toBeNull();
+    expect(runBidirectional(createDisconnectedGraph(), 1, 4)).toBeNull();
+  });
+
+  it("all algorithms should handle trivial single-node path", () => {
+    const graph = createGraph(createLinearGraph());
+
+    const dijkstraPath = dijkstra(graph, 1, 1, distanceWeight);
+    const astarPath = astar(graph, 1, 1, distanceWeight, createCoordFn());
+    const biPath = runBidirectional(createLinearGraph(), 1, 1);
+
+    expect(dijkstraPath).not.toBeNull();
+    expect(astarPath).not.toBeNull();
+    expect(biPath).not.toBeNull();
+
+    // All should include node 1
+    expect(dijkstraPath?.some((p) => p.nodeIndex === 1)).toBe(true);
+    expect(astarPath?.some((p) => p.nodeIndex === 1)).toBe(true);
+    expect(biPath?.some((p) => p.nodeIndex === 1)).toBe(true);
+  });
+});