minotor 11.2.0 → 11.2.2

package/dist/routing/rangeResult.d.ts

@@ -28,7 +28,8 @@ export type ArrivalWithDuration = Arrival & {
  * The result of a Range RAPTOR query.
  *
  * Contains the complete Pareto-optimal set of journeys for a resolved
- * destination set.
+ * destination set, **or** the full per-departure-time routing state when no
+ * destinations were provided (full-network / isochrone mode).
  *
  * **Pareto dominance**: journey J1 dominates J2 iff
  *   `τdep(J1) ≥ τdep(J2)  AND  τarr(J1) ≤ τarr(J2)`
@@ -38,6 +39,15 @@ export type ArrivalWithDuration = Arrival & {
  * strictly earlier *and* arrives strictly earlier than the previous one,
  * forming the classic staircase Pareto frontier.
  *
+ * **Full-network mode** (empty `destinations`): when no destinations are
+ * supplied to the range query every departure slot in the window becomes its
+ * own run, because destination-based Pareto pruning cannot be applied.
+ * In this mode the destination-specific helpers ({@link getRoutes},
+ * {@link bestRoute}, {@link latestDepartureRoute}, {@link fastestRoute})
+ * return empty results; use {@link allEarliestArrivals},
+ * {@link allShortestDurations}, {@link earliestArrivalAt}, or
+ * {@link shortestDurationTo} instead.
+ *
  * Destination handling is delegated to {@link Result}, which expands
  * equivalent stops when reconstructing routes or looking up arrivals.
  */
@@ -54,6 +64,10 @@ export declare class RangeResult {
      *
      * Each route in the list departs strictly earlier *and* arrives strictly
      * earlier than its predecessor.
+     *
+     * Returns an empty array when no destinations were provided (full-network
+     * mode). Use {@link allEarliestArrivals} or {@link allShortestDurations}
+     * to query individual stops in that case.
      */
     getRoutes(): Route[];
     /**
@@ -65,6 +79,8 @@ export declare class RangeResult {
      * at a transit stop.
      *
      * Defaults to this result's own destination stop(s) when `to` is omitted.
+     * Always pass an explicit `to` stop when operating in full-network mode
+     * (no destinations), otherwise `undefined` is returned.
      *
      * @param to Optional destination stop ID or set of stop IDs.
      * @returns The reconstructed {@link Route} with the earliest arrival,
@@ -81,6 +97,8 @@ export declare class RangeResult {
      * {@link fastestRoute}.
      *
      * Defaults to this result's own destination stop(s) when `to` is omitted.
+     * Always pass an explicit `to` stop when operating in full-network mode
+     * (no destinations), otherwise `undefined` is returned.
      *
      * @param to Optional destination stop ID or set of stop IDs.
      * @returns The reconstructed {@link Route} with the latest departure,
@@ -97,6 +115,8 @@ export declare class RangeResult {
      * spent traveling.
      *
      * Defaults to this result's own destination stop(s) when `to` is omitted.
+     * Always pass an explicit `to` stop when operating in full-network mode
+     * (no destinations), otherwise `undefined` is returned.
      *
      * @param to Optional destination stop ID or set of stop IDs.
      * @returns The reconstructed fastest {@link Route}, or `undefined` if the

package/dist/routing/rangeState.d.ts

@@ -69,7 +69,7 @@ export declare class RangeRaptorState implements IRaptorState {
      */
     get destinationBest(): Time;
     isDestination(stop: StopId): boolean;
-    /** Updates both the per-run state and the cross-run shared labels. */
+    /** Updates the per-run aggregate best when improved, and always considers the cross-run shared label. */
     updateArrival(stop: StopId, time: Time, round: number): void;
     /**
      * initialized round `k` from round `k-1`: τk(p) ← min(τk(p), τk-1(p)).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minotor",
-  "version": "11.2.0",
+  "version": "11.2.2",
   "description": "A lightweight client-side transit routing library.",
   "keywords": [
     "minotor",

package/src/routing/__tests__/rangeResult.test.ts

@@ -2,7 +2,7 @@ import assert from 'node:assert';
 import { describe, it } from 'node:test';
 
 import { Timetable } from '../../router.js';
-import { Stop } from '../../stops/stops.js';
+import { Stop, StopId } from '../../stops/stops.js';
 import { StopsIndex } from '../../stops/stopsIndex.js';
 import { Route } from '../../timetable/route.js';
 import { timeFromHM } from '../../timetable/time.js';
@@ -270,4 +270,89 @@ describe('RangeResult', () => {
       assert.deepStrictEqual(empty.allEarliestArrivals(), new Map());
     });
   });
+
+  describe('no destinations (full-network / isochrone mode)', () => {
+    // Same routing data as runA/runB but Result is built with empty destinations,
+    // reflecting how RangeRouter constructs results in full-network mode.
+    const emptyDests = new Set<StopId>();
+
+    const runAFull: ParetoRun = {
+      departureTime: timeFromHM(9, 0),
+      result: new Result(
+        emptyDests,
+        RoutingState.fromTestData({
+          nbStops: 2,
+          origins: [0],
+          destinations: [],
+          arrivals: [
+            [0, timeFromHM(9, 0), 0],
+            [DEST, timeFromHM(9, 30), 1],
+          ],
+          graph: [
+            [[0, { stopId: 0, arrival: timeFromHM(9, 0) }]],
+            [[DEST, edgeA]],
+          ],
+        }),
+        stopsIndex,
+        timetable,
+      ),
+    };
+
+    const runBFull: ParetoRun = {
+      departureTime: timeFromHM(8, 30),
+      result: new Result(
+        emptyDests,
+        RoutingState.fromTestData({
+          nbStops: 2,
+          origins: [0],
+          destinations: [],
+          arrivals: [
+            [0, timeFromHM(8, 30), 0],
+            [DEST, timeFromHM(9, 10), 1],
+          ],
+          graph: [
+            [[0, { stopId: 0, arrival: timeFromHM(8, 30) }]],
+            [[DEST, edgeB]],
+          ],
+        }),
+        stopsIndex,
+        timetable,
+      ),
+    };
+
+    const fullNetworkResult = new RangeResult([runAFull, runBFull], emptyDests);
+
+    it('destinations is empty', () => {
+      assert.strictEqual(fullNetworkResult.destinations.size, 0);
+    });
+
+    it('getRoutes returns an empty array', () => {
+      // Result was built with empty destinations, so bestRoute() on each inner
+      // Result finds no target and getRoutes() collapses to [].
+      assert.deepStrictEqual(fullNetworkResult.getRoutes(), []);
+    });
+
+    it('bestRoute without an explicit stop returns undefined', () => {
+      assert.strictEqual(fullNetworkResult.bestRoute(), undefined);
+    });
+
+    it('bestRoute with an explicit stop returns the correct route', () => {
+      const route = fullNetworkResult.bestRoute(DEST);
+      assert(route);
+      // Best route to DEST is via runB (earlier arrival at 09:10).
+      assert.strictEqual(route.arrivalTime(), timeFromHM(9, 10));
+    });
+
+    it('allEarliestArrivals covers all reachable stops', () => {
+      const arrivals = fullNetworkResult.allEarliestArrivals();
+      // DEST earliest arrival is 09:10 (from runB).
+      assert.strictEqual(arrivals.get(DEST)?.arrival, timeFromHM(9, 10));
+    });
+
+    it('allShortestDurations covers all reachable stops', () => {
+      const durations = fullNetworkResult.allShortestDurations();
+      // runA: 30 min, runB: 40 min → shortest duration to DEST is 30 min.
+      assert.strictEqual(durations.get(DEST)?.duration, 30);
+    });
+  });
 });

package/src/routing/__tests__/rangeRouter.test.ts

@@ -12,6 +12,7 @@ import {
 } from '../../timetable/timetable.js';
 import { AccessFinder } from '../access.js';
 import { RangeQuery } from '../query.js';
+import { RangeResult } from '../rangeResult.js';
 import { RangeRouter } from '../rangeRouter.js';
 import { Raptor } from '../raptor.js';
 
@@ -469,4 +470,132 @@ describe('RangeRouter', () => {
       assert.strictEqual(run.departureTime, timeFromHM(8, 30));
     });
   });
+
+  describe('with no destinations (full-network / isochrone mode)', () => {
+    // Two-stop network, two trips:
+    //   trip 0: stop 0 departs 08:00 → stop 1 arrives 08:30  (30-min journey)
+    //   trip 1: stop 0 departs 08:30 → stop 1 arrives 09:00  (30-min journey)
+    // The query window covers both departure slots; no destination is specified.
+    let result: RangeResult;
+
+    beforeEach(() => {
+      const stopsAdjacency: StopAdjacency[] = [
+        { routes: [0] },
+        { routes: [0] },
+      ];
+
+      const routesAdjacency = [
+        Route.of({
+          id: 0,
+          serviceRouteId: 0,
+          trips: [
+            {
+              stops: [
+                {
+                  id: 0,
+                  arrivalTime: timeFromHM(8, 0),
+                  departureTime: timeFromHM(8, 0),
+                },
+                {
+                  id: 1,
+                  arrivalTime: timeFromHM(8, 30),
+                  departureTime: timeFromHM(8, 30),
+                },
+              ],
+            },
+            {
+              stops: [
+                {
+                  id: 0,
+                  arrivalTime: timeFromHM(8, 30),
+                  departureTime: timeFromHM(8, 30),
+                },
+                {
+                  id: 1,
+                  arrivalTime: timeFromHM(9, 0),
+                  departureTime: timeFromHM(9, 0),
+                },
+              ],
+            },
+          ],
+        }),
+      ];
+
+      const serviceRoutes: ServiceRoute[] = [
+        { type: 'BUS', name: 'Line 1', routes: [0] },
+      ];
+
+      const timetable = new Timetable(
+        stopsAdjacency,
+        routesAdjacency,
+        serviceRoutes,
+      );
+
+      const stops: Stop[] = [
+        {
+          id: 0,
+          sourceStopId: 'origin',
+          name: 'Origin',
+          lat: 0,
+          lon: 0,
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+        {
+          id: 1,
+          sourceStopId: 'dest',
+          name: 'Destination',
+          lat: 0,
+          lon: 0,
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ];
+
+      const stopsIndex = new StopsIndex(stops);
+      const accessFinder = new AccessFinder(timetable, stopsIndex);
+      const raptor = new Raptor(timetable);
+      const router = new RangeRouter(
+        timetable,
+        stopsIndex,
+        accessFinder,
+        raptor,
+      );
+
+      // Omitting .to() leaves toValue as its default empty Set.
+      const query = new RangeQuery.Builder()
+        .from(0)
+        .departureTime(timeFromHM(8, 0))
+        .lastDepartureTime(timeFromHM(8, 30))
+        .build();
+
+      result = router.rangeRoute(query);
+    });
+
+    it('returns a run for every departure slot in the window', () => {
+      // Without destinations the trivialDestCovered guard (0 === 0) previously
+      // aborted the loop before any run was processed; now both slots are kept.
+      assert.strictEqual(result.size, 2);
+    });
+
+    it('allEarliestArrivals covers all reachable stops', () => {
+      const arrivals = result.allEarliestArrivals();
+      // Stop 1 is first reached by trip 0 (depart 08:00, arrive 08:30).
+      assert.strictEqual(arrivals.get(1)?.arrival, timeFromHM(8, 30));
+    });
+
+    it('allShortestDurations covers all reachable stops', () => {
+      const durations = result.allShortestDurations();
+      // Both trips take 30 min; shortest duration to stop 1 is 30 min.
+      assert.strictEqual(durations.get(1)?.duration, 30);
+    });
+
+    it('bestRoute without an explicit stop returns undefined', () => {
+      assert.strictEqual(result.bestRoute(), undefined);
+    });
+
+    it('getRoutes returns an empty array', () => {
+      assert.deepStrictEqual(result.getRoutes(), []);
+    });
+  });
 });

package/src/routing/__tests__/rangeState.test.ts

@@ -229,6 +229,94 @@ describe('RangeRaptorState', () => {
     });
   });
 
+  describe('updateArrival aggregate overwrite behavior', () => {
+    it('does not overwrite the current run aggregate with a later arrival from a higher round', () => {
+      const state = new RangeRaptorState(
+        MAX_ROUNDS,
+        NB_STOPS,
+        timeFromHM(12, 0),
+      );
+      const run = RoutingState.fromTestData({
+        nbStops: NB_STOPS,
+        destinations: [2],
+        arrivals: [[2, timeFromHM(8, 30), 1]],
+      });
+      state.setCurrentRun(run);
+
+      state.updateArrival(2, timeFromHM(8, 45), 2);
+
+      assert.deepStrictEqual(run.getArrival(2), {
+        arrival: timeFromHM(8, 30),
+        legNumber: 1,
+      });
+      assert.strictEqual(state.roundLabels[2]![2], timeFromHM(8, 45));
+    });
+
+    it('does not overwrite the current run aggregate with an equal-time arrival using more legs', () => {
+      const state = new RangeRaptorState(
+        MAX_ROUNDS,
+        NB_STOPS,
+        timeFromHM(12, 0),
+      );
+      const run = RoutingState.fromTestData({
+        nbStops: NB_STOPS,
+        destinations: [2],
+        arrivals: [[2, timeFromHM(8, 30), 2]],
+      });
+      state.setCurrentRun(run);
+
+      state.updateArrival(2, timeFromHM(8, 30), 3);
+
+      assert.deepStrictEqual(run.getArrival(2), {
+        arrival: timeFromHM(8, 30),
+        legNumber: 2,
+      });
+      assert.strictEqual(state.roundLabels[3]![2], timeFromHM(8, 30));
+    });
+
+    it('prefers fewer legs for the current run aggregate when arrival time is equal', () => {
+      const state = new RangeRaptorState(
+        MAX_ROUNDS,
+        NB_STOPS,
+        timeFromHM(12, 0),
+      );
+      const run = RoutingState.fromTestData({
+        nbStops: NB_STOPS,
+        destinations: [2],
+        arrivals: [[2, timeFromHM(8, 30), 3]],
+      });
+      state.setCurrentRun(run);
+
+      state.updateArrival(2, timeFromHM(8, 30), 2);
+
+      assert.deepStrictEqual(run.getArrival(2), {
+        arrival: timeFromHM(8, 30),
+        legNumber: 2,
+      });
+    });
+
+    it('still updates the current run aggregate when the new arrival is earlier', () => {
+      const state = new RangeRaptorState(
+        MAX_ROUNDS,
+        NB_STOPS,
+        timeFromHM(12, 0),
+      );
+      const run = RoutingState.fromTestData({
+        nbStops: NB_STOPS,
+        destinations: [2],
+        arrivals: [[2, timeFromHM(8, 45), 1]],
+      });
+      state.setCurrentRun(run);
+
+      state.updateArrival(2, timeFromHM(8, 30), 3);
+
+      assert.deepStrictEqual(run.getArrival(2), {
+        arrival: timeFromHM(8, 30),
+        legNumber: 3,
+      });
+    });
+  });
+
   describe('isDestination', () => {
     it('delegates to the current run', () => {
       const state = new RangeRaptorState(

package/src/routing/rangeResult.ts

@@ -31,7 +31,8 @@ export type ArrivalWithDuration = Arrival & {
  * The result of a Range RAPTOR query.
  *
  * Contains the complete Pareto-optimal set of journeys for a resolved
- * destination set.
+ * destination set, **or** the full per-departure-time routing state when no
+ * destinations were provided (full-network / isochrone mode).
  *
  * **Pareto dominance**: journey J1 dominates J2 iff
  *   `τdep(J1) ≥ τdep(J2)  AND  τarr(J1) ≤ τarr(J2)`
@@ -41,6 +42,15 @@ export type ArrivalWithDuration = Arrival & {
  * strictly earlier *and* arrives strictly earlier than the previous one,
  * forming the classic staircase Pareto frontier.
  *
+ * **Full-network mode** (empty `destinations`): when no destinations are
+ * supplied to the range query every departure slot in the window becomes its
+ * own run, because destination-based Pareto pruning cannot be applied.
+ * In this mode the destination-specific helpers ({@link getRoutes},
+ * {@link bestRoute}, {@link latestDepartureRoute}, {@link fastestRoute})
+ * return empty results; use {@link allEarliestArrivals},
+ * {@link allShortestDurations}, {@link earliestArrivalAt}, or
+ * {@link shortestDurationTo} instead.
+ *
  * Destination handling is delegated to {@link Result}, which expands
  * equivalent stops when reconstructing routes or looking up arrivals.
  */
@@ -70,6 +80,10 @@ export class RangeResult {
    *
    * Each route in the list departs strictly earlier *and* arrives strictly
    * earlier than its predecessor.
+   *
+   * Returns an empty array when no destinations were provided (full-network
+   * mode). Use {@link allEarliestArrivals} or {@link allShortestDurations}
+   * to query individual stops in that case.
    */
   getRoutes(): Route[] {
     const routes: Route[] = [];
@@ -89,6 +103,8 @@ export class RangeResult {
    * at a transit stop.
    *
    * Defaults to this result's own destination stop(s) when `to` is omitted.
+   * Always pass an explicit `to` stop when operating in full-network mode
+   * (no destinations), otherwise `undefined` is returned.
    *
    * @param to Optional destination stop ID or set of stop IDs.
    * @returns The reconstructed {@link Route} with the earliest arrival,
@@ -124,6 +140,8 @@ export class RangeResult {
    * {@link fastestRoute}.
    *
    * Defaults to this result's own destination stop(s) when `to` is omitted.
+   * Always pass an explicit `to` stop when operating in full-network mode
+   * (no destinations), otherwise `undefined` is returned.
    *
    * @param to Optional destination stop ID or set of stop IDs.
    * @returns The reconstructed {@link Route} with the latest departure,
@@ -148,6 +166,8 @@ export class RangeResult {
    * spent traveling.
    *
    * Defaults to this result's own destination stop(s) when `to` is omitted.
+   * Always pass an explicit `to` stop when operating in full-network mode
+   * (no destinations), otherwise `undefined` is returned.
    *
    * @param to Optional destination stop ID or set of stop IDs.
    * @returns The reconstructed fastest {@link Route}, or `undefined` if the

package/src/routing/rangeRouter.ts

@@ -45,6 +45,8 @@ export class RangeRouter {
       .flatMap((destination) => this.stopsIndex.equivalentStops(destination))
       .map((destination) => destination.id);
 
+    const noDestinations = destinations.length === 0;
+
     const accessLegs = this.accessFinder.collectAccessPaths(
       query.from,
       query.options.minTransferTime,
@@ -99,15 +101,19 @@ export class RangeRouter {
         },
         rangeState,
       );
-      for (const dest of destinations) {
-        const t = routingState.arrivalTime(dest);
-        if (t < (paretoDestBest.get(dest) ?? UNREACHED_TIME))
-          paretoDestBest.set(dest, t);
+      if (!noDestinations) {
+        for (const dest of destinations) {
+          const t = routingState.arrivalTime(dest);
+          if (t < (paretoDestBest.get(dest) ?? UNREACHED_TIME))
+            paretoDestBest.set(dest, t);
+        }
       }
     }
 
     for (const { depTime, legs } of departureSlots) {
-      if (trivialDestCovered.size === destinations.length) break;
+      if (!noDestinations && trivialDestCovered.size === destinations.length) {
+        break;
+      }
 
       if (routingState === null) {
         routingState = new RoutingState(
@@ -129,23 +135,25 @@ export class RangeRouter {
         rangeState,
       );
 
-      let isParetoOptimal = false;
-      for (const dest of destinations) {
-        const arrival = routingState.arrivalTime(dest);
-        if (arrival >= (paretoDestBest.get(dest) ?? UNREACHED_TIME)) {
-          continue;
-        }
+      let isParetoOptimal = noDestinations;
+      if (!noDestinations) {
+        for (const dest of destinations) {
+          const arrival = routingState.arrivalTime(dest);
+          if (arrival >= (paretoDestBest.get(dest) ?? UNREACHED_TIME)) {
+            continue;
+          }
 
-        if (trivialDests.has(dest) && trivialDestCovered.has(dest)) {
-          paretoDestBest.set(dest, arrival);
-          continue;
-        }
+          if (trivialDests.has(dest) && trivialDestCovered.has(dest)) {
+            paretoDestBest.set(dest, arrival);
+            continue;
+          }
 
-        paretoDestBest.set(dest, arrival);
-        if (trivialDests.has(dest)) {
-          trivialDestCovered.add(dest);
+          paretoDestBest.set(dest, arrival);
+          if (trivialDests.has(dest)) {
+            trivialDestCovered.add(dest);
+          }
+          isParetoOptimal = true;
         }
-        isParetoOptimal = true;
       }
 
       if (isParetoOptimal) {

package/src/routing/rangeState.ts

@@ -113,9 +113,19 @@ export class RangeRaptorState implements IRaptorState {
     return this.currentRun.isDestination(stop);
   }
 
-  /** Updates both the per-run state and the cross-run shared labels. */
+  /** Updates the per-run aggregate best when improved, and always considers the cross-run shared label. */
   updateArrival(stop: StopId, time: Time, round: number): void {
-    this.currentRun.updateArrival(stop, time, round);
+    const currentRunArrival = this.currentRun.getArrival(stop);
+    const improvesCurrentRunAggregate =
+      currentRunArrival === undefined ||
+      time < currentRunArrival.arrival ||
+      (time === currentRunArrival.arrival &&
+        round < currentRunArrival.legNumber);
+
+    if (improvesCurrentRunAggregate) {
+      this.currentRun.updateArrival(stop, time, round);
+    }
+
     if (time < this.roundLabels[round]![stop]!) {
       this.roundLabels[round]![stop] = time;
       this.changedInRound[round]!.push(stop);