@osmix/router 0.0.11 → 0.1.0

package/CHANGELOG.md

@@ -1,5 +1,83 @@
 # @osmix/router
 
+## 0.1.0
+
+### Minor Changes
+
+- 66eb7cd: `bidirectional` is now bidirectional Dijkstra: it searches backward over incoming edges, returns an optimal path and respects one-way edges. It was a breadth-first search that could return a longer path. Routing algorithms take an optional `RoutingAlgorithmContext` (`reverseGraph`, `maxSpeedMps`), which `Router` supplies; `RoutingGraph` adds `getIncomingEdges` and `maxSpeedMps`, and A*'s time heuristic uses the graph's maximum speed.
+- 66eb7cd: Add `routingTopologyStats`, which counts a routing network's nodes, edges and components from its ways without building a `RoutingGraph`.
+
+### Patch Changes
+
+- 466adc0: Share one-way normalization between exact reconciliation, fuzzy way matching, and routing. Respect explicit `no`, `false`, and `0` on roundabouts, recognize equivalent supported aliases, and compare reversed geometry consistently. Prevent unsupported values from being treated as direction-equivalent during matching while retaining the router's documented fallback behavior.
+
+  Block fuzzy matches when endpoint geometry cannot establish the orientation needed to compare one-way travel, including closed one-way roundabouts. Bidirectional ways without recognized direction-sensitive tags remain eligible.
+
+- 8be5c80: Allow Osmix to use its ArrayBuffer fallback when SharedArrayBuffer is unavailable, so browser
+  applications no longer need to install a global SharedArrayBuffer shim.
+- cd987f5: Preserve input topology during merges, conservatively reconcile compatible patch entities with the base,
+  validate routing-sensitive references, and insert multiple intersections in way order. Within-file duplicate
+  scans in the Merge app are now diagnostic only; regenerate older merged PBFs from their source inputs. Correct
+  the router priority queue so shortest-path searches visit lower-cost states first, and honor the one-way
+  direction implied by OSM roundabouts plus reverse one-way (`oneway=-1`) tags.
+
+  Restore the original 1-meter matching behavior as explicit, cross-dataset fuzzy conflation for imported data.
+  Callers select transferable properties independently from patch-network attachment; exact merge behavior
+  remains the default. Unique, high-confidence pedestrian and one-to-one-way matches can apply automatically,
+  while routing properties, motor roads, ambiguity, relation involvement, and uncertain geometry require review.
+  Grade conflicts, restrictions, protected tags, dangling references, way collapse, and base-topology rewrites
+  remain blocked. Matching candidates and their evidence are inspectable with `discoverConflationCandidates`;
+  merge plans carry the CAR/WALK topology diagnostics, and the Merge app reviews the plan before applying it.
+
+- Updated dependencies [e4785fe]
+- Updated dependencies [df04f92]
+- Updated dependencies [e4785fe]
+- Updated dependencies [66eb7cd]
+- Updated dependencies [466adc0]
+- Updated dependencies [66eb7cd]
+- Updated dependencies [66eb7cd]
+- Updated dependencies [8be5c80]
+  - @osmix/shared@0.2.0
+  - @osmix/core@0.3.0
+  - @osmix/types@0.2.0
+  - @osmix/geo@0.1.1
+
+## 0.0.14
+
+### Patch Changes
+
+- c7a5a35: Harden parsing, loading, changeset generation, worker orchestration, and package verification across Osmix.
+
+  - `@osmix/pbf`, `@osmix/json`, and `@osmix/load` now validate PBF framing and decompression limits, normalize every supported input form, apply timestamp granularity consistently, translate tags before filtering, remove dangling filtered references, and build every requested spatial index.
+  - `@osmix/core` now returns `null` for unknown node-coordinate lookups, safely handles incomplete geometry, caches relation-to-way membership, and avoids repeated ID lookups and per-entity object allocation during sorted iteration.
+  - `@osmix/change` now preserves relation references during deduplication, escapes OSC XML attributes, applies changesets non-destructively, allocates collision-free IDs for empty or unsorted data, and resolves pending intersection geometry safely. Its intersection runtime is now vendored and strictly typed, removing the upstream test/build dependency graph.
+  - `osmix` now preserves sliced typed-array views during transfer, disposes and terminates owned workers reliably, uses collision-safe worker registries, and supports all documented PBF input forms across local and remote APIs.
+  - `@osmix/geojson`, `@osmix/vt`, and `@osmix/shortbread` now consume nullable or read-only geometry data without aliasing or mutation hazards.
+  - `@osmix/gtfs` and `@osmix/router` documentation now uses the current archive, routing, transfer, and distance APIs.
+  - `@osmix/shared` and `@osmix/test-utils` add executable package smoke coverage for byte streams and checked-in fixtures.
+  - Public package examples are classified as compilable or schematic and are checked against current exports and argument types.
+
+- Updated dependencies [368d103]
+- Updated dependencies [368d103]
+- Updated dependencies [c7a5a35]
+  - @osmix/core@0.2.0
+  - @osmix/geo@0.1.0
+  - @osmix/types@0.1.0
+
+## 0.0.13
+
+### Patch Changes
+
+- Updated dependencies [d67e38d]
+  - @osmix/core@0.1.10
+
+## 0.0.12
+
+### Patch Changes
+
+- Updated dependencies [6144903]
+  - @osmix/core@0.1.9
+
 ## 0.0.11
 
 ### Patch Changes

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Conveyal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -5,8 +5,9 @@
 ## Highlights
 
 - Builds a directed graph from OSM ways and nodes
+- Respects explicit one-way tags and the one-way direction implied by `junction=roundabout`
 - Configurable highway type filtering
-- Multiple routing algorithms (Dijkstra, A*, bidirectional search)
+- Multiple routing algorithms (Dijkstra, A\*, bidirectional search)
 - Support for both distance and time-based routing
 - Returns detailed route information including coordinates, way IDs, and node IDs
 - Serializable graph format for Web Worker support
@@ -14,35 +15,34 @@
 ## Installation
 
 ```sh
-bun install @osmix/router
+pnpm add @osmix/router
 ```
 
 ## Usage
 
-```ts
-import { RoutingGraph, Router, findNearestNodeOnGraph } from "@osmix/router"
-import { Osm } from "@osmix/core"
+```ts check-docs
+import { Osm, Router, RoutingGraph } from "osmix";
 
-const osm = new Osm()
+const osm = new Osm();
 // ... load OSM data into osm ...
 
 // Build routing graph
-const graph = new RoutingGraph(osm)
+const graph = new RoutingGraph(osm);
 
 // Snap coordinates to nearest routable nodes
-const from = findNearestNodeOnGraph(osm, graph, [-73.989, 40.733], 0.5)
-const to = findNearestNodeOnGraph(osm, graph, [-73.988, 40.734], 0.5)
+const from = graph.findNearestRoutableNode(osm, [-73.989, 40.733], 500);
+const to = graph.findNearestRoutableNode(osm, [-73.988, 40.734], 500);
 
 if (from && to) {
-	const router = new Router(osm, graph)
-	const path = router.route(from.nodeIndex, to.nodeIndex)
-
-	if (path) {
-		const result = router.buildResult(path)
-		console.log(result.coordinates) // Array of [lon, lat] coordinates
-		console.log(result.wayIndexes) // Array of way indexes used
-		console.log(result.nodeIndexes) // Array of node indexes for turns
-	}
+  const router = new Router(osm, graph);
+  const path = router.route(from.nodeIndex, to.nodeIndex);
+
+  if (path) {
+    const result = router.buildResult(path);
+    console.log(result.coordinates); // Array of [lon, lat] coordinates
+    console.log(result.wayIndexes); // Array of way indexes used
+    console.log(result.nodeIndexes); // Array of node indexes for turns
+  }
 }
 ```
 
@@ -52,53 +52,101 @@ if (from && to) {
 
 Build and manage a routing graph from OSM data. The graph uses a CSR (Compressed Sparse Row) format for efficient memory usage and cache locality.
 
-```ts
-import { RoutingGraph, defaultHighwayFilter } from "@osmix/router"
+```ts check-docs osm
+import { RoutingGraph, defaultHighwayFilter } from "osmix";
 
 // Build from OSM data
-const graph = new RoutingGraph(osm, defaultHighwayFilter)
+const graph = new RoutingGraph(osm, defaultHighwayFilter);
+const nodeIndex = 0;
 
 // Properties
-graph.size // Number of routable nodes
-graph.edges // Total edge count
-graph.isRouteable(nodeIndex) // Check if node is routable
-graph.isIntersection(nodeIndex) // Check if node is an intersection
-graph.getEdges(nodeIndex) // Get outgoing edges from node
+graph.size; // Number of node slots: every node in the dataset, routable or not
+graph.edges; // Total edge count
+graph.isRoutable(nodeIndex); // Check if node is routable
+graph.isIntersection(nodeIndex); // Check if node is an intersection
+graph.getEdges(nodeIndex); // Get outgoing edges from node
+graph.getIncomingEdges(nodeIndex); // Get incoming edges (targetNodeIndex is the source)
+graph.maxSpeedMps; // Fastest edge speed, used to bound the A* time heuristic
 ```
 
-#### `findNearestRoutableNode(osm, point, maxKm)`
+#### `findNearestRoutableNode(osm, point, maxDistanceM)`
 
-Snap a geographic coordinate to the nearest routable node.
+Snap a geographic coordinate to the nearest routable node. The radius is in meters. It snaps to graph nodes only, not to points along an edge. It needs the all-node spatial index (the Full load profile) and throws `SpatialIndexNotBuiltError` without it.
 
-```ts
-const nearest = graph.findNearestRoutableNode(osm, [-73.989, 40.733], 0.5)
+```ts check-docs router-context
+const nearest = graph.findNearestRoutableNode(osm, [-73.989, 40.733], 500);
 if (nearest) {
-	console.log(nearest.nodeIndex) // Internal node index
-	console.log(nearest.coordinates) // Snapped [lon, lat]
-	console.log(nearest.distance) // Distance from input point (meters)
+  console.log(nearest.nodeIndex); // Internal node index
+  console.log(nearest.coordinates); // Snapped [lon, lat]
+  console.log(nearest.distance); // Distance from input point (meters)
 }
 ```
 
 **Constructor parameters:**
 
 - `osm` - The `@osmix/core` dataset.
-- `filter` - Optional function `(tags?) => boolean` to select routable ways. Default: common vehicle highways.
-- `defaultSpeeds` - Optional speed limits (km/h) by highway type.
+- `filter` - Optional function `(tags?) => boolean` to select routable ways. Default: `defaultHighwayFilter` (motorway to service roads). `defaultPedestrianFilter` selects footways, paths, cycleways, bridleways and steps.
+- `defaultSpeeds` - Optional speed limits (km/h) by highway type. Default: `DEFAULT_SPEEDS`. A way's `maxspeed` tag takes priority (`parseMaxSpeed` reads numbers, `mph`, `walk` and `none`). Unknown types use 50 km/h.
+
+Ways with a ref to a node that is not in the dataset (for example, after a bbox extract) keep their other segments. The segments that touch the missing node are not added.
+
+Way directionality is currently graph-wide: custom filters can select pedestrian ways, but they
+do not disable `oneway` or implicit roundabout direction. A custom filter does not supply a complete pedestrian or turn-restriction policy. The [optional local R5 comparison](../osmix/test/r5/README.md) evaluates declared fixture checks against a specific R5 checkout; coordinate linking and diagnostic observations do not establish complete modal legality.
+
+#### Way direction
+
+Graph construction and exact/fuzzy way matching share `normalizedWayDirection(tags)`, available from
+`osmix` or `@osmix/types/way-direction`. It returns `OsmWayDirection`: `forward`, `reverse`, `both`, or
+`unsupported`. Forward follows the way's ordered node references; reverse travels against that order.
+
+| `oneway` value                              | Normalized direction             |
+| ------------------------------------------- | -------------------------------- |
+| `yes`, `true`, `1`                          | `forward`                        |
+| `reverse`, `-1`                             | `reverse`                        |
+| `no`, `false`, `0`                          | `both`, including on roundabouts |
+| Absent or empty, with `junction=roundabout` | `forward`                        |
+| Absent or empty, on other ways              | `both`                           |
+| Any other nonempty value                    | `unsupported`                    |
+
+One-way aliases are case-insensitive, and numeric values normalize like their string equivalents. Values
+are not trimmed: `" yes "` is unsupported. The roundabout implication requires the literal
+`junction=roundabout` value.
+
+```ts check-docs
+import { normalizedWayDirection } from "osmix";
+
+const direction = normalizedWayDirection({ junction: "roundabout", oneway: "0" });
+console.log(direction); // "both"
+```
+
+Unsupported values such as `reversible` and `alternating` prevent exact or fuzzy way matching from treating
+two ways as direction-equivalent, even when their values are identical. The routing graph retains its existing
+approximation for such values: forward on roundabouts and both directions on other ways. This fallback does
+not model their actual rules. Conditional, time-dependent, lane-specific, and mode-specific one-way rules are
+not evaluated by this normalization.
+
+Fuzzy matching also needs a reliable geometry orientation before comparing one-way travel. It blocks one-way
+candidates whose endpoints fit equally well in either order, including closed one-way loops. This matching
+limit does not change their routing graph: graph edges always follow the stored references and normalized
+tag direction.
 
 #### Serialization (Web Worker support)
 
 `RoutingGraph` can be serialized and transferred between Web Workers:
 
-```ts
+```ts check-docs router-transfer
+import { getTransferableBuffers, RoutingGraph } from "@osmix/router";
+
 // Build graph and get transferables
-const graph = new RoutingGraph(osm)
-const transferables = graph.transferables()
+const transferables = graph.transferables();
+const buffers = getTransferableBuffers(transferables);
 
-// Transfer to worker (zero-copy with SharedArrayBuffer)
-worker.postMessage(transferables)
+// Transfer to worker without cloning ArrayBuffers
+worker.postMessage(transferables, buffers);
 
 // Reconstruct in worker
-const reconstructed = new RoutingGraph(transferables)
+const reconstructed = new RoutingGraph(transferables);
+console.log(reconstructed.size);
 ```
 
 The `transferables()` method returns an object containing:
@@ -112,38 +160,75 @@ The `transferables()` method returns an object containing:
 
 High-level routing interface.
 
-```ts
-const router = new Router(osm, graph, { algorithm: "astar", metric: "time" })
+Schematic construction with route options:
+
+```ts schematic
+const router = new Router(osm, graph, { algorithm: "astar", metric: "time" });
 ```
 
 **Methods:**
 
 - `route(fromNodeIndex, toNodeIndex, options?)` - Find path between nodes. Returns `PathSegment[]` or `null`.
-- `buildResult(path)` - Convert path to `RouteResult` with coordinates and metadata.
+- `buildResult(path, options?)` - Convert path to `RouteResult` with `coordinates`, `wayIndexes` and `nodeIndexes`.
+- `getRouteStatistics(path)` - Total `distance` (meters) and `time` (seconds).
+- `getRoutePathInfo(path)` - `segments` (consecutive ways with the same name merged) and `turnPoints`.
 
 **Options:**
 
 - `algorithm` - `"dijkstra"` | `"astar"` | `"bidirectional"` (default: `"astar"`)
 - `metric` - `"distance"` | `"time"` (default: `"distance"`)
+- `includeStats` - Add `distance` and `time` to the `RouteResult` (default: `false`)
+- `includePathInfo` - Add `segments` and `turnPoints` to the `RouteResult` (default: `false`)
+
+### `routingTopologyStats(source, filter)`
+
+Gives the counts a `RoutingGraph` built with `filter` would have (`nodes`, `routableNodes`, directed `edges` and weakly connected `components`) without building the graph. `source` is anything with a `nodeCount` and a `ways()` iterable of `{ tags, refs }`, so an `Osm` or a view of pending changes both work. Direction follows the graph, including the roundabout fallback.
+
+```ts schematic
+const stats = routingTopologyStats({ nodeCount: osm.nodes.size, ways: () => osm.ways }, filter);
+```
 
 ### Algorithms
 
-| Algorithm       | Optimal? | Speed   | Best For                              |
-| --------------- | -------- | ------- | ------------------------------------- |
-| `dijkstra`      | Yes      | Slower  | When you need guaranteed shortest path |
-| `astar`         | Yes      | Fast    | Point-to-point queries (default)      |
-| `bidirectional` | No       | Fastest | Quick connectivity checks             |
+| Algorithm       | Optimal? | Search                                                            |
+| --------------- | -------- | ----------------------------------------------------------------- |
+| `dijkstra`      | Yes      | Expands in all directions from the start                          |
+| `astar`         | Yes      | Guided toward the end by straight-line distance (default)         |
+| `bidirectional` | Yes      | Dijkstra from both ends; the backward half follows incoming edges |
+
+For the `time` metric, A* divides the straight-line distance by `graph.maxSpeedMps`, so the heuristic stays admissible when a `maxspeed` is above 130 km/h. `bidirectional` builds an index of incoming edges on its first use (4 bytes for each node plus 8 bytes for each edge).
+
+A custom algorithm has the `RoutingAlgorithmFn` signature. Its last argument, `RoutingAlgorithmContext`, carries `reverseGraph` and `maxSpeedMps`.
+
+## Limitations
+
+The router reads only the `highway`, `oneway`, `junction` and `maxspeed` tags. It does not model:
+
+- Turn restrictions (relations)
+- Access tags (`access`, `motor_vehicle`, `foot`, `bicycle` and more)
+- Mode-specific, conditional or lane-specific one-way tags
+- Turn costs or elevation
+- A bicycle profile (`defaultPedestrianFilter` includes cycleways)
+
+Memory and search:
+
+- The graph uses 16 bytes for each directed edge, plus about 4.25 bytes for each node in the dataset, routable or not. The build reads the routable ways twice and writes straight into these arrays, so its peak is the final size plus one 4-byte cursor for each node.
+- Node, edge and way indexes are `Uint32`. Distances and times are `Float32`.
+- A search has no distance or time limit, and you cannot cancel it. If no route exists, the search examines the whole connected network before it returns `null`.
+- The worker keeps one graph (one filter) for each dataset.
+
+See [docs/limits.md](../../docs/limits.md#router-limits) for measured graph sizes.
 
 ## Related Packages
 
 - [`@osmix/core`](../core/README.md) - In-memory OSM index with spatial queries.
+- [`@osmix/load`](../load/README.md) - Load PBF data into `Osm` indexes (`fromPbf`).
 - [`@osmix/shared`](../shared/README.md) - Haversine distance and coordinate utilities.
 - [`osmix`](../osmix/README.md) - High-level API with worker support for routing.
 
 ## Development
 
-- `bun run test packages/router`
-- `bun run lint packages/router`
-- `bun run typecheck packages/router`
+- `pnpm run test packages/router`
+- `pnpm exec oxlint packages/router`
 
-Run `bun run check` at the repo root before publishing to ensure formatting, lint, and type coverage.
+Run `pnpm run verify` at the repo root before publishing.

package/dist/algorithms/bidirectional.d.ts

@@ -1,19 +1,16 @@
 /**
- * Bidirectional breadth-first search algorithm.
+ * Bidirectional Dijkstra.
  *
- * Searches from both start and end simultaneously, terminating when the
- * frontiers meet. Very fast for finding any path, but does not guarantee
- * the shortest path. Use Dijkstra or A* when optimality is required.
+ * Runs Dijkstra forward from the start over outgoing edges and backward from
+ * the end over incoming edges, and stops when neither search can improve the
+ * best meeting point. Returns an optimal path and respects one-way edges.
  *
  * @module
  */
 import type { RoutingAlgorithmFn } from "../types.ts";
 /**
- * Bidirectional BFS - fast path finding from both ends.
- *
- * Uses breadth-first search from both start and end, terminating when
- * the frontiers meet. Very fast for finding any path, though not always
- * the optimal shortest path. Use Dijkstra or A* if optimality is required.
+ * Bidirectional Dijkstra. Requires `context.reverseGraph`, which `Router`
+ * supplies from `RoutingGraph.getIncomingEdges`.
  */
 export declare const bidirectional: RoutingAlgorithmFn;
 //# sourceMappingURL=bidirectional.d.ts.map

package/dist/algorithms/bidirectional.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bidirectional.d.ts","sourceRoot":"","sources":["../../src/algorithms/bidirectional.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAe,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAElE;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,kBA+H3B,CAAA"}
+{"version":3,"file":"bidirectional.d.ts","sourceRoot":"","sources":["../../src/algorithms/bidirectional.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAA0B,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAQ9E;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,kBA+G3B,CAAC"}

package/dist/algorithms/bidirectional.js

@@ -1,128 +1,108 @@
 /**
- * Bidirectional breadth-first search algorithm.
+ * Bidirectional Dijkstra.
  *
- * Searches from both start and end simultaneously, terminating when the
- * frontiers meet. Very fast for finding any path, but does not guarantee
- * the shortest path. Use Dijkstra or A* when optimality is required.
+ * Runs Dijkstra forward from the start over outgoing edges and backward from
+ * the end over incoming edges, and stops when neither search can improve the
+ * best meeting point. Returns an optimal path and respects one-way edges.
  *
  * @module
  */
+import { BinaryHeap } from "../binary-heap.js";
 /**
- * Bidirectional BFS - fast path finding from both ends.
- *
- * Uses breadth-first search from both start and end, terminating when
- * the frontiers meet. Very fast for finding any path, though not always
- * the optimal shortest path. Use Dijkstra or A* if optimality is required.
+ * Bidirectional Dijkstra. Requires `context.reverseGraph`, which `Router`
+ * supplies from `RoutingGraph.getIncomingEdges`.
  */
-export const bidirectional = (graph, start, end, getWeight) => {
+export const bidirectional = (graph, start, end, getWeight, _getCoord, _metric, context) => {
     if (start === end)
         return [{ nodeIndex: start, cost: 0 }];
-    // Forward search state
-    const fDist = new Map();
+    const reverseGraph = context?.reverseGraph;
+    if (!reverseGraph) {
+        throw Error("Bidirectional routing needs context.reverseGraph (incoming edges). " +
+            "Router passes RoutingGraph.getIncomingEdges.");
+    }
+    const fDist = new Map([[start, 0]]);
+    const bDist = new Map([[end, 0]]);
     const fPrev = new Map();
-    const fQueue = [start];
-    // Backward search state
-    const bDist = new Map();
-    const bPrev = new Map();
-    const bQueue = [end];
-    fDist.set(start, 0);
-    bDist.set(end, 0);
-    let meetNode = null;
-    while (fQueue.length > 0 && bQueue.length > 0) {
-        // Expand forward
-        if (fQueue.length > 0) {
-            const current = fQueue.shift();
-            const currentD = fDist.get(current);
-            // Check if backward search reached this node
-            if (bDist.has(current)) {
-                meetNode = current;
-                break;
+    const bNext = new Map();
+    const fHeap = new BinaryHeap();
+    const bHeap = new BinaryHeap();
+    const fClosed = new Set();
+    const bClosed = new Set();
+    fHeap.push(start, 0);
+    bHeap.push(end, 0);
+    let best = Number.POSITIVE_INFINITY;
+    let meet = -1;
+    const relax = (current, edges, dist, otherDist, closed, heap, record) => {
+        const currentD = dist.get(current);
+        for (const edge of edges) {
+            const neighbor = edge.targetNodeIndex;
+            if (closed.has(neighbor))
+                continue;
+            const cost = currentD + getWeight(edge);
+            const existing = dist.get(neighbor);
+            if (existing !== undefined && cost >= existing)
+                continue;
+            dist.set(neighbor, cost);
+            record(neighbor, edge, cost);
+            heap.push(neighbor, cost);
+            const other = otherDist.get(neighbor);
+            if (other !== undefined && cost + other < best) {
+                best = cost + other;
+                meet = neighbor;
             }
-            for (const edge of graph(current)) {
-                const neighbor = edge.targetNodeIndex;
-                if (fDist.has(neighbor))
-                    continue;
-                const newD = currentD + getWeight(edge);
-                fDist.set(neighbor, newD);
+        }
+    };
+    while (fHeap.size > 0 && bHeap.size > 0) {
+        // Stop once no unsettled node can lie on a path shorter than `best`.
+        if (fHeap.peekPriority() + bHeap.peekPriority() >= best)
+            break;
+        if (fHeap.peekPriority() <= bHeap.peekPriority()) {
+            const current = fHeap.pop();
+            if (fClosed.has(current))
+                continue;
+            fClosed.add(current);
+            relax(current, graph(current), fDist, bDist, fClosed, fHeap, (neighbor, edge, cost) => {
                 fPrev.set(neighbor, {
                     nodeIndex: neighbor,
                     wayIndex: edge.wayIndex,
                     previousNodeIndex: current,
-                    cost: newD,
+                    cost,
                 });
-                fQueue.push(neighbor);
-                if (bDist.has(neighbor)) {
-                    meetNode = neighbor;
-                    break;
-                }
-            }
-            if (meetNode !== null)
-                break;
+            });
         }
-        // Expand backward
-        if (bQueue.length > 0) {
-            const current = bQueue.shift();
-            const currentD = bDist.get(current);
-            // Check if forward search reached this node
-            if (fDist.has(current)) {
-                meetNode = current;
-                break;
-            }
-            for (const edge of graph(current)) {
-                const neighbor = edge.targetNodeIndex;
-                if (bDist.has(neighbor))
-                    continue;
-                const newD = currentD + getWeight(edge);
-                bDist.set(neighbor, newD);
-                bPrev.set(neighbor, {
-                    nodeIndex: neighbor,
-                    wayIndex: edge.wayIndex,
-                    previousNodeIndex: current,
-                    cost: newD,
-                });
-                bQueue.push(neighbor);
-                if (fDist.has(neighbor)) {
-                    meetNode = neighbor;
-                    break;
-                }
-            }
-            if (meetNode !== null)
-                break;
+        else {
+            const current = bHeap.pop();
+            if (bClosed.has(current))
+                continue;
+            bClosed.add(current);
+            relax(current, reverseGraph(current), bDist, fDist, bClosed, bHeap, (neighbor, edge) => {
+                bNext.set(neighbor, { nextNodeIndex: current, wayIndex: edge.wayIndex });
+            });
         }
     }
-    if (meetNode === null)
+    if (meet === -1)
         return null;
-    // Build forward path: start -> meet
-    const forward = [];
-    let curr = meetNode;
-    while (curr !== undefined && curr !== start) {
-        const seg = fPrev.get(curr);
-        if (!seg)
-            break;
-        forward.unshift(seg);
-        curr = seg.previousNodeIndex;
+    // Forward half: start → meet.
+    const path = [];
+    let node = meet;
+    while (node !== start) {
+        const segment = fPrev.get(node);
+        path.unshift(segment);
+        node = segment.previousNodeIndex;
     }
-    forward.unshift({ nodeIndex: start, cost: 0 });
-    // Build backward path: meet -> end (reverse direction)
-    // bDist represents distance FROM end TO node, so it decreases as we approach end.
-    // Correct cost = forward cost to meet + (backward dist at meet - backward dist at curr)
-    const meetForwardCost = fDist.get(meetNode);
-    const meetBackwardCost = bDist.get(meetNode);
-    curr = meetNode;
-    while (curr !== undefined && curr !== end) {
-        const seg = bPrev.get(curr);
-        if (!seg)
-            break;
-        curr = seg.previousNodeIndex;
-        if (curr !== undefined) {
-            forward.push({
-                nodeIndex: curr,
-                wayIndex: seg.wayIndex,
-                previousNodeIndex: seg.nodeIndex,
-                cost: meetForwardCost + meetBackwardCost - (bDist.get(curr) ?? 0),
-            });
-        }
+    path.unshift({ nodeIndex: start, cost: 0 });
+    // Backward half: meet → end, with costs measured from the start.
+    node = meet;
+    while (node !== end) {
+        const step = bNext.get(node);
+        path.push({
+            nodeIndex: step.nextNodeIndex,
+            wayIndex: step.wayIndex,
+            previousNodeIndex: node,
+            cost: best - bDist.get(step.nextNodeIndex),
+        });
+        node = step.nextNodeIndex;
     }
-    return forward;
+    return path;
 };
 //# sourceMappingURL=bidirectional.js.map