@osmix/router 0.0.11 → 0.1.0

package/test/binary-heap.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest";
+
+import { BinaryHeap } from "../src/binary-heap.ts";
+
+describe("BinaryHeap", () => {
+  it("preserves priority order when a replacement must move down multiple levels", () => {
+    const heap = new BinaryHeap();
+    for (let priority = 1; priority <= 7; priority++) {
+      heap.push(priority, priority);
+    }
+
+    const popped: number[] = [];
+    while (heap.size > 0) popped.push(heap.pop()!);
+
+    expect(popped).toEqual([1, 2, 3, 4, 5, 6, 7]);
+  });
+
+  it("preserves ordering after decreasing an existing item's priority", () => {
+    const heap = new BinaryHeap();
+    heap.push(1, 10);
+    heap.push(2, 20);
+    heap.push(3, 30);
+    heap.push(3, 5);
+
+    expect([heap.pop(), heap.pop(), heap.pop()]).toEqual([3, 1, 2]);
+  });
+});

package/test/limits.test.ts

@@ -0,0 +1,82 @@
+import { Osm } from "@osmix/core";
+import { describe, expect, it } from "vitest";
+
+import { buildGraph, Router } from "../src/index.ts";
+
+function finish(osm: Osm): Osm {
+  osm.buildIndexes();
+  osm.buildSpatialIndexes();
+  return osm;
+}
+
+describe("graph build with missing nodes", () => {
+  it("skips segments that touch a node outside the dataset", () => {
+    const osm = new Osm({ id: "dangling" });
+    osm.nodes.addNode({ id: 1, lon: 0, lat: 0 });
+    osm.nodes.addNode({ id: 2, lon: 0.001, lat: 0 });
+    osm.nodes.addNode({ id: 3, lon: 0.002, lat: 0 });
+    // Node 99 is not in the dataset, as after a bbox extract.
+    osm.ways.addWay({ id: 10, refs: [99, 1, 2, 3], tags: { highway: "residential" } });
+    finish(osm);
+
+    const graph = buildGraph(osm);
+    // Two two-way segments remain: 1-2 and 2-3.
+    expect(graph.edges).toBe(4);
+    const targets = new Uint32Array(graph.transferables().edgeTargets);
+    for (const target of targets) expect(target).toBeLessThan(graph.size);
+
+    const router = new Router(osm, graph);
+    const path = router.route(0, 2);
+    expect(path?.map((p) => p.nodeIndex)).toEqual([0, 1, 2]);
+  });
+});
+
+describe("bidirectional routing on one-way streets", () => {
+  it("never travels against a one-way", () => {
+    const osm = new Osm({ id: "one-way" });
+    osm.nodes.addNode({ id: 1, lon: 0, lat: 0 });
+    osm.nodes.addNode({ id: 2, lon: 0.001, lat: 0 });
+    osm.nodes.addNode({ id: 3, lon: 0.002, lat: 0 });
+    osm.nodes.addNode({ id: 4, lon: 0.001, lat: 0.01 });
+    osm.ways.addWay({ id: 10, refs: [1, 2, 3], tags: { highway: "residential", oneway: "yes" } });
+    osm.ways.addWay({ id: 11, refs: [3, 4, 1], tags: { highway: "residential" } });
+    finish(osm);
+
+    const graph = buildGraph(osm);
+    const router = new Router(osm, graph, { algorithm: "bidirectional" });
+    const node = (id: number) => osm.nodes.ids.getIndexFromId(id);
+
+    const back = router.route(node(3), node(1));
+    expect(back?.map((p) => osm.nodes.ids.at(p.nodeIndex))).toEqual([3, 4, 1]);
+    const dijkstra = router.route(node(3), node(1), { algorithm: "dijkstra" });
+    expect(back?.at(-1)?.cost).toBeCloseTo(dijkstra!.at(-1)!.cost);
+
+    const incoming = graph
+      .getIncomingEdges(node(2))
+      .map((e) => osm.nodes.ids.at(e.targetNodeIndex));
+    expect(incoming).toEqual([1]);
+  });
+});
+
+describe("A* time heuristic", () => {
+  it("stays optimal when a maxspeed is above 130 km/h", () => {
+    // A slow direct road (100 km/h, ~11 km) and a much longer detour at 1,000 km/h.
+    // The detour is faster. A heuristic fixed at 130 km/h overestimates on it.
+    const osm = new Osm({ id: "fast-road" });
+    osm.nodes.addNode({ id: 1, lon: 0, lat: 0 });
+    osm.nodes.addNode({ id: 2, lon: 0.1, lat: 0 });
+    osm.nodes.addNode({ id: 3, lon: 0.05, lat: 0.3 });
+    osm.ways.addWay({ id: 10, refs: [1, 2], tags: { highway: "primary", maxspeed: "100" } });
+    osm.ways.addWay({ id: 11, refs: [1, 3, 2], tags: { highway: "motorway", maxspeed: "1000" } });
+    finish(osm);
+
+    const graph = buildGraph(osm);
+    expect(graph.maxSpeedMps).toBeCloseTo(1000 / 3.6, 2);
+
+    const router = new Router(osm, graph, { metric: "time" });
+    const astar = router.route(0, 1, { algorithm: "astar" });
+    const dijkstra = router.route(0, 1, { algorithm: "dijkstra" });
+    expect(astar?.map((p) => p.nodeIndex)).toEqual([0, 2, 1]);
+    expect(astar?.at(-1)?.cost).toBeCloseTo(dijkstra!.at(-1)!.cost);
+  });
+});

package/test/no-shared-array-buffer.test.ts

@@ -0,0 +1,37 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+describe("router transfers without SharedArrayBuffer", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.resetModules();
+  });
+
+  it("returns every ArrayBuffer in the transfer list", async () => {
+    vi.stubGlobal("SharedArrayBuffer", undefined);
+    vi.resetModules();
+
+    const { getTransferableBuffers } = await import("../src/graph.ts");
+    const createBuffer = () => new ArrayBuffer(4);
+    const transferables = {
+      nodeCount: 0,
+      edgeCount: 0,
+      edgeOffsets: createBuffer(),
+      edgeTargets: createBuffer(),
+      edgeWayIndexes: createBuffer(),
+      edgeDistances: createBuffer(),
+      edgeTimes: createBuffer(),
+      routableBits: createBuffer(),
+      intersectionBits: createBuffer(),
+    };
+
+    expect(getTransferableBuffers(transferables)).toEqual([
+      transferables.edgeOffsets,
+      transferables.edgeTargets,
+      transferables.edgeWayIndexes,
+      transferables.edgeDistances,
+      transferables.edgeTimes,
+      transferables.routableBits,
+      transferables.intersectionBits,
+    ]);
+  });
+});

package/test/router.bench.ts

@@ -1,14 +1,15 @@
-import { Osm } from "@osmix/core"
-import { getFixtureFile, PBFs } from "@osmix/shared/fixtures"
-import { bench, group, run } from "mitata"
-import { fromPbf } from "osmix"
-import { buildGraph } from "../src"
-import { Router } from "../src/router"
+import { Osm } from "@osmix/core";
+import { fromPbf } from "@osmix/load";
+import { getFixtureFile, PBFs } from "@osmix/test-utils/fixtures";
+import { bench, group, run } from "mitata";
+
+import { buildGraph } from "../src/index.ts";
+import { Router } from "../src/router.ts";
 
 /**
  * Router Benchmark Suite using mitata
  *
- * Run with: bun test/router.bench.ts
+ * Run with: pnpm --filter @osmix/router run bench
  *
  * These benchmarks compare the performance of different routing algorithms
  * using both real-world OSM data (Monaco) and synthetic grid networks.
@@ -28,230 +29,212 @@ import { Router } from "../src/router"
  * @param spacing - Spacing between nodes in degrees (~100m per 0.001)
  */
 function createSyntheticGrid(size: number, spacing: number): Osm {
-	const osm = new Osm({ id: "synthetic-grid" })
-
-	// Create nodes in a grid pattern
-	for (let row = 0; row < size; row++) {
-		for (let col = 0; col < size; col++) {
-			const nodeId = row * size + col + 1
-			osm.nodes.addNode({
-				id: nodeId,
-				lat: row * spacing,
-				lon: col * spacing,
-			})
-		}
-	}
-
-	osm.nodes.buildIndex()
-	osm.nodes.buildSpatialIndex()
-
-	// Create horizontal ways (connecting nodes in each row)
-	let wayId = 1
-	for (let row = 0; row < size; row++) {
-		const refs: number[] = []
-		for (let col = 0; col < size; col++) {
-			refs.push(row * size + col + 1)
-		}
-		osm.ways.addWay({
-			id: wayId++,
-			refs,
-			tags: { highway: "residential" },
-		})
-	}
-
-	// Create vertical ways (connecting nodes in each column)
-	for (let col = 0; col < size; col++) {
-		const refs: number[] = []
-		for (let row = 0; row < size; row++) {
-			refs.push(row * size + col + 1)
-		}
-		osm.ways.addWay({
-			id: wayId++,
-			refs,
-			tags: { highway: "residential" },
-		})
-	}
-
-	osm.ways.buildIndex()
-	osm.ways.buildSpatialIndex()
-	osm.buildIndexes()
-
-	return osm
+  const osm = new Osm({ id: "synthetic-grid" });
+
+  // Create nodes in a grid pattern
+  for (let row = 0; row < size; row++) {
+    for (let col = 0; col < size; col++) {
+      const nodeId = row * size + col + 1;
+      osm.nodes.addNode({
+        id: nodeId,
+        lat: row * spacing,
+        lon: col * spacing,
+      });
+    }
+  }
+
+  osm.nodes.buildIndex();
+  osm.nodes.buildSpatialIndex();
+
+  // Create horizontal ways (connecting nodes in each row)
+  let wayId = 1;
+  for (let row = 0; row < size; row++) {
+    const refs: number[] = [];
+    for (let col = 0; col < size; col++) {
+      refs.push(row * size + col + 1);
+    }
+    osm.ways.addWay({
+      id: wayId++,
+      refs,
+      tags: { highway: "residential" },
+    });
+  }
+
+  // Create vertical ways (connecting nodes in each column)
+  for (let col = 0; col < size; col++) {
+    const refs: number[] = [];
+    for (let row = 0; row < size; row++) {
+      refs.push(row * size + col + 1);
+    }
+    osm.ways.addWay({
+      id: wayId++,
+      refs,
+      tags: { highway: "residential" },
+    });
+  }
+
+  osm.ways.buildIndex();
+  osm.ways.buildSpatialIndex();
+  osm.buildIndexes();
+
+  return osm;
 }
 
 // ---------------------------------------------------------------------------
 // Setup
 // ---------------------------------------------------------------------------
 
-console.log("Setting up benchmark data...")
+console.log("Setting up benchmark data...");
 
 // Load Monaco PBF
-const monacoPbf = PBFs["monaco"]!
-const pbfData = await getFixtureFile(monacoPbf.url)
-const monacoOsm = await fromPbf(pbfData, {
-	buildSpatialIndexes: ["node", "way"],
-})
-const monacoGraph = buildGraph(monacoOsm)
-const monacoRouter = new Router(monacoOsm, monacoGraph)
+const monacoPbf = PBFs["monaco"]!;
+const pbfData = await getFixtureFile(monacoPbf.url);
+const monacoOsm = await fromPbf(pbfData, { loadProfile: "full" });
+const monacoGraph = buildGraph(monacoOsm);
+const monacoRouter = new Router(monacoOsm, monacoGraph);
 
 // Create synthetic grid
-const GRID_SIZE = 50
-const GRID_SPACING = 0.001
-const gridOsm = createSyntheticGrid(GRID_SIZE, GRID_SPACING)
-const gridGraph = buildGraph(gridOsm)
-const gridRouter = new Router(gridOsm, gridGraph)
+const GRID_SIZE = 50;
+const GRID_SPACING = 0.001;
+const gridOsm = createSyntheticGrid(GRID_SIZE, GRID_SPACING);
+const gridGraph = buildGraph(gridOsm);
+const gridRouter = new Router(gridOsm, gridGraph);
 
 // Pre-snap coordinates to node indexes for benchmarking
 const monacoShortFrom = monacoGraph.findNearestRoutableNode(
-	monacoOsm,
-	[7.42, 43.735],
-	500,
-)!.nodeIndex
+  monacoOsm,
+  [7.42, 43.735],
+  500,
+)!.nodeIndex;
 const monacoShortTo = monacoGraph.findNearestRoutableNode(
-	monacoOsm,
-	[7.425, 43.738],
-	500,
-)!.nodeIndex
+  monacoOsm,
+  [7.425, 43.738],
+  500,
+)!.nodeIndex;
 const monacoLongFrom = monacoGraph.findNearestRoutableNode(
-	monacoOsm,
-	[7.41, 43.725],
-	500,
-)!.nodeIndex
-const monacoLongTo = monacoGraph.findNearestRoutableNode(
-	monacoOsm,
-	[7.44, 43.745],
-	500,
-)!.nodeIndex
-
-const gridShortFrom = gridGraph.findNearestRoutableNode(
-	gridOsm,
-	[0.01, 0.01],
-	200,
-)!.nodeIndex
-const gridShortTo = gridGraph.findNearestRoutableNode(
-	gridOsm,
-	[0.015, 0.015],
-	200,
-)!.nodeIndex
-const gridLongFrom = gridGraph.findNearestRoutableNode(
-	gridOsm,
-	[0, 0],
-	200,
-)!.nodeIndex
+  monacoOsm,
+  [7.41, 43.725],
+  500,
+)!.nodeIndex;
+const monacoLongTo = monacoGraph.findNearestRoutableNode(monacoOsm, [7.44, 43.745], 500)!.nodeIndex;
+
+const gridShortFrom = gridGraph.findNearestRoutableNode(gridOsm, [0.01, 0.01], 200)!.nodeIndex;
+const gridShortTo = gridGraph.findNearestRoutableNode(gridOsm, [0.015, 0.015], 200)!.nodeIndex;
+const gridLongFrom = gridGraph.findNearestRoutableNode(gridOsm, [0, 0], 200)!.nodeIndex;
 const gridLongTo = gridGraph.findNearestRoutableNode(
-	gridOsm,
-	[(GRID_SIZE - 1) * GRID_SPACING, (GRID_SIZE - 1) * GRID_SPACING],
-	200,
-)!.nodeIndex
+  gridOsm,
+  [(GRID_SIZE - 1) * GRID_SPACING, (GRID_SIZE - 1) * GRID_SPACING],
+  200,
+)!.nodeIndex;
 
-console.log("Setup complete. Running benchmarks...\n")
+console.log("Setup complete. Running benchmarks...\n");
 
 // ---------------------------------------------------------------------------
 // Monaco PBF Benchmarks
 // ---------------------------------------------------------------------------
 
 group("Monaco - Short Distance (~500m)", () => {
-	bench("Dijkstra", () => {
-		monacoRouter.route(monacoShortFrom, monacoShortTo, {
-			algorithm: "dijkstra",
-		})
-	})
-
-	bench("A*", () => {
-		monacoRouter.route(monacoShortFrom, monacoShortTo, {
-			algorithm: "astar",
-		})
-	})
-
-	bench("Bidirectional", () => {
-		monacoRouter.route(monacoShortFrom, monacoShortTo, {
-			algorithm: "bidirectional",
-		})
-	})
-})
+  bench("Dijkstra", () => {
+    monacoRouter.route(monacoShortFrom, monacoShortTo, {
+      algorithm: "dijkstra",
+    });
+  });
+
+  bench("A*", () => {
+    monacoRouter.route(monacoShortFrom, monacoShortTo, {
+      algorithm: "astar",
+    });
+  });
+
+  bench("Bidirectional", () => {
+    monacoRouter.route(monacoShortFrom, monacoShortTo, {
+      algorithm: "bidirectional",
+    });
+  });
+});
 
 group("Monaco - Long Distance (~2km)", () => {
-	bench("Dijkstra", () => {
-		monacoRouter.route(monacoLongFrom, monacoLongTo, {
-			algorithm: "dijkstra",
-		})
-	})
-
-	bench("A*", () => {
-		monacoRouter.route(monacoLongFrom, monacoLongTo, {
-			algorithm: "astar",
-		})
-	})
-
-	bench("Bidirectional", () => {
-		monacoRouter.route(monacoLongFrom, monacoLongTo, {
-			algorithm: "bidirectional",
-		})
-	})
-})
+  bench("Dijkstra", () => {
+    monacoRouter.route(monacoLongFrom, monacoLongTo, {
+      algorithm: "dijkstra",
+    });
+  });
+
+  bench("A*", () => {
+    monacoRouter.route(monacoLongFrom, monacoLongTo, {
+      algorithm: "astar",
+    });
+  });
+
+  bench("Bidirectional", () => {
+    monacoRouter.route(monacoLongFrom, monacoLongTo, {
+      algorithm: "bidirectional",
+    });
+  });
+});
 
 // ---------------------------------------------------------------------------
 // Synthetic Grid Benchmarks
 // ---------------------------------------------------------------------------
 
 group("Grid 50x50 - Short Path", () => {
-	bench("Dijkstra", () => {
-		gridRouter.route(gridShortFrom, gridShortTo, {
-			algorithm: "dijkstra",
-		})
-	})
-
-	bench("A*", () => {
-		gridRouter.route(gridShortFrom, gridShortTo, {
-			algorithm: "astar",
-		})
-	})
-
-	bench("Bidirectional", () => {
-		gridRouter.route(gridShortFrom, gridShortTo, {
-			algorithm: "bidirectional",
-		})
-	})
-})
+  bench("Dijkstra", () => {
+    gridRouter.route(gridShortFrom, gridShortTo, {
+      algorithm: "dijkstra",
+    });
+  });
+
+  bench("A*", () => {
+    gridRouter.route(gridShortFrom, gridShortTo, {
+      algorithm: "astar",
+    });
+  });
+
+  bench("Bidirectional", () => {
+    gridRouter.route(gridShortFrom, gridShortTo, {
+      algorithm: "bidirectional",
+    });
+  });
+});
 
 group("Grid 50x50 - Long Path (corner to corner)", () => {
-	bench("Dijkstra", () => {
-		gridRouter.route(gridLongFrom, gridLongTo, {
-			algorithm: "dijkstra",
-		})
-	})
-
-	bench("A*", () => {
-		gridRouter.route(gridLongFrom, gridLongTo, {
-			algorithm: "astar",
-		})
-	})
-
-	bench("Bidirectional", () => {
-		gridRouter.route(gridLongFrom, gridLongTo, {
-			algorithm: "bidirectional",
-		})
-	})
-})
+  bench("Dijkstra", () => {
+    gridRouter.route(gridLongFrom, gridLongTo, {
+      algorithm: "dijkstra",
+    });
+  });
+
+  bench("A*", () => {
+    gridRouter.route(gridLongFrom, gridLongTo, {
+      algorithm: "astar",
+    });
+  });
+
+  bench("Bidirectional", () => {
+    gridRouter.route(gridLongFrom, gridLongTo, {
+      algorithm: "bidirectional",
+    });
+  });
+});
 
 // ---------------------------------------------------------------------------
 // Router Initialization Benchmarks
 // ---------------------------------------------------------------------------
 
 group("Router Initialization", () => {
-	bench("Monaco OSM (14k nodes, 3k ways)", () => {
-		new Router(monacoOsm, buildGraph(monacoOsm))
-	})
+  bench("Monaco OSM (14k nodes, 3k ways)", () => {
+    new Router(monacoOsm, buildGraph(monacoOsm));
+  });
 
-	bench("Grid 50x50 (2.5k nodes)", () => {
-		new Router(gridOsm, buildGraph(gridOsm))
-	})
-})
+  bench("Grid 50x50 (2.5k nodes)", () => {
+    new Router(gridOsm, buildGraph(gridOsm));
+  });
+});
 
 // ---------------------------------------------------------------------------
 // Run benchmarks
 // ---------------------------------------------------------------------------
 
 await run({
-	colors: true,
-})
+  colors: true,
+});