minotor 11.2.0 → 11.2.2

package/CHANGELOG.md

@@ -1,6 +1,6 @@
-# [11.2.0](https://github.com/aubryio/minotor/compare/v11.1.3...v11.2.0) (2026-04-27)
+## [11.2.2](https://github.com/aubryio/minotor/compare/v11.2.1...v11.2.2) (2026-04-27)
 
 
-### Features
+### Bug Fixes
 
-* range queries support ([#67](https://github.com/aubryio/minotor/issues/67)) ([39d1dd3](https://github.com/aubryio/minotor/commit/39d1dd3ecd17070a1e49bfded3bbb0888594a77b)), closes [#31](https://github.com/aubryio/minotor/issues/31) [#62](https://github.com/aubryio/minotor/issues/62)
+* prevent higher-round rRAPTOR labels from overwriting equal or better aggregate arrivals ([#69](https://github.com/aubryio/minotor/issues/69)) ([a35c4e2](https://github.com/aubryio/minotor/commit/a35c4e23caab026972fbab78e54c0de2a905feda))

package/dist/cli.mjs

@@ -22493,7 +22493,8 @@ class PlainRouter {
  * 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)`
@@ -22503,6 +22504,15 @@ class PlainRouter {
  * 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.
  */
@@ -22528,6 +22538,10 @@ 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() {
         const routes = [];
@@ -22547,6 +22561,8 @@ 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,
@@ -22579,6 +22595,8 @@ 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,
@@ -22603,6 +22621,8 @@ 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
@@ -22795,9 +22815,16 @@ class RangeRaptorState {
     isDestination(stop) {
         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, time, round) {
-        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);
@@ -22853,6 +22880,7 @@ class RangeRouter {
         const destinations = Array.from(query.to)
             .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);
         const departureSlots = this.accessFinder.collectDepartureTimes(accessLegs, earliest, latest);
         if (departureSlots.length === 0) {
@@ -22874,15 +22902,18 @@ class RangeRouter {
             routingState = new RoutingState(latest + 1, destinations, accessLegs, this.timetable.nbStops(), maxRounds);
             rangeState.setCurrentRun(routingState);
             this.raptor.run(Object.assign(Object.assign({}, query.options), { maxInitialWaitingTime: undefined }), rangeState);
-            for (const dest of destinations) {
-                const t = routingState.arrivalTime(dest);
-                if (t < ((_a = paretoDestBest.get(dest)) !== null && _a !== void 0 ? _a : UNREACHED_TIME))
-                    paretoDestBest.set(dest, t);
+            if (!noDestinations) {
+                for (const dest of destinations) {
+                    const t = routingState.arrivalTime(dest);
+                    if (t < ((_a = paretoDestBest.get(dest)) !== null && _a !== void 0 ? _a : UNREACHED_TIME))
+                        paretoDestBest.set(dest, t);
+                }
             }
         }
         for (const { depTime, legs } of departureSlots) {
-            if (trivialDestCovered.size === destinations.length)
+            if (!noDestinations && trivialDestCovered.size === destinations.length) {
                 break;
+            }
             if (routingState === null) {
                 routingState = new RoutingState(depTime, destinations, legs, this.timetable.nbStops(), maxRounds);
             }
@@ -22891,21 +22922,23 @@ class RangeRouter {
             }
             rangeState.setCurrentRun(routingState);
             this.raptor.run(Object.assign(Object.assign({}, query.options), { maxInitialWaitingTime: 0 }), rangeState);
-            let isParetoOptimal = false;
-            for (const dest of destinations) {
-                const arrival = routingState.arrivalTime(dest);
-                if (arrival >= ((_b = paretoDestBest.get(dest)) !== null && _b !== void 0 ? _b : UNREACHED_TIME)) {
-                    continue;
-                }
-                if (trivialDests.has(dest) && trivialDestCovered.has(dest)) {
+            let isParetoOptimal = noDestinations;
+            if (!noDestinations) {
+                for (const dest of destinations) {
+                    const arrival = routingState.arrivalTime(dest);
+                    if (arrival >= ((_b = paretoDestBest.get(dest)) !== null && _b !== void 0 ? _b : UNREACHED_TIME)) {
+                        continue;
+                    }
+                    if (trivialDests.has(dest) && trivialDestCovered.has(dest)) {
+                        paretoDestBest.set(dest, arrival);
+                        continue;
+                    }
                     paretoDestBest.set(dest, arrival);
-                    continue;
-                }
-                paretoDestBest.set(dest, arrival);
-                if (trivialDests.has(dest)) {
-                    trivialDestCovered.add(dest);
+                    if (trivialDests.has(dest)) {
+                        trivialDestCovered.add(dest);
+                    }
+                    isParetoOptimal = true;
                 }
-                isParetoOptimal = true;
             }
             if (isParetoOptimal) {
                 paretoRuns.push({