minotor 11.2.2 → 11.2.3

package/CHANGELOG.md

@@ -1,6 +1,6 @@
-## [11.2.2](https://github.com/aubryio/minotor/compare/v11.2.1...v11.2.2) (2026-04-27)
+## [11.2.3](https://github.com/aubryio/minotor/compare/v11.2.2...v11.2.3) (2026-05-04)
 
 
-### Bug Fixes
+### Performance Improvements
 
-* 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))
+* max duration query option ([#70](https://github.com/aubryio/minotor/issues/70)) ([4d7fce3](https://github.com/aubryio/minotor/commit/4d7fce31f5af80d97ac095be0b91e8daec10eb68))

package/README.md

@@ -111,6 +111,7 @@ Query options:
 | ----------------------- | --------- | ---------------------------------------------------------------------- |
 | `maxTransfers`          | `5`       | Maximum number of transfers                                            |
 | `minTransferTime`       | `2 min`   | Fallback minimum transfer time                                         |
+| `maxDuration`           | unlimited | Maximum total journey duration from the query departure time           |
 | `maxInitialWaitingTime` | unlimited | Maximum wait for the first vehicle after arriving at the boarding stop |
 | `transportModes`        | all       | Restrict to a subset of GTFS route types                               |
 

package/dist/cli.mjs

@@ -21659,6 +21659,15 @@ Query.Builder = class {
         this.optionsValue.transportModes = transportModes;
         return this;
     }
+    /**
+     * Sets the maximum total journey duration (in minutes) from the query
+     * departure time. The limit includes initial access, waiting time, transit
+     * legs, and transfers.
+     */
+    maxDuration(maxDuration) {
+        this.optionsValue.maxDuration = maxDuration;
+        return this;
+    }
     /**
      * Sets the maximum time (in minutes) the traveler is willing to wait at
      * the first boarding stop before the first transit vehicle departs.
@@ -22231,12 +22240,17 @@ const UNREACHED_TIME = 0xffff;
  * Encapsulates all mutable state for a single RAPTOR routing query.
  */
 class RoutingState {
-    constructor(departureTime, destinations, accessPaths, nbStops, maxRounds = 0) {
+    constructor(departureTime, destinations, accessPaths, nbStops, maxRounds = 0, maxDuration) {
         /**
          * Cached best arrival time at any destination stop, kept up-to-date by
          * {@link updateArrival} so that destination pruning is always O(1).
          */
         this._destinationBest = UNREACHED_TIME;
+        /**
+         * Maximum arrival time allowed for this run. Defaults to UNREACHED_TIME when
+         * the query has no maxDuration limit.
+         */
+        this.maxArrivalTime = UNREACHED_TIME;
         /**
          * Every stop that has received an arrival improvement during the current run,
          * in the order the improvements occurred.  Used by {@link resetFor} to clear
@@ -22244,6 +22258,9 @@ class RoutingState {
          */
         this.reachedStops = [];
         this.destinations = destinations;
+        this.maxDuration = maxDuration;
+        this.maxArrivalTime =
+            maxDuration === undefined ? UNREACHED_TIME : departureTime + maxDuration;
         this.destinationSet = new Set(destinations);
         this.earliestArrivalTimes = new Uint16Array(nbStops).fill(UNREACHED_TIME);
         this.earliestArrivalLegs = new Uint8Array(nbStops);
@@ -22265,6 +22282,8 @@ class RoutingState {
         const seededOrigins = new Set();
         for (const access of accessPaths) {
             const arrival = depTime + access.duration;
+            if (arrival > this.maxArrivalTime)
+                continue;
             const edge = access.duration === 0
                 ? { stopId: access.fromStopId, arrival: depTime }
                 : {
@@ -22356,6 +22375,10 @@ class RoutingState {
         }
         this.reachedStops.length = 0;
         this._destinationBest = UNREACHED_TIME;
+        this.maxArrivalTime =
+            this.maxDuration === undefined
+                ? UNREACHED_TIME
+                : depTime + this.maxDuration;
         this.seedAccessPaths(depTime, accessPaths);
     }
     /**
@@ -22483,7 +22506,7 @@ class PlainRouter {
         const destinations = Array.from(query.to)
             .flatMap((destination) => this.stopsIndex.equivalentStops(destination))
             .map((destination) => destination.id);
-        const routingState = new RoutingState(query.departureTime, destinations, accessLegs, this.timetable.nbStops(), query.options.maxTransfers + 1);
+        const routingState = new RoutingState(query.departureTime, destinations, accessLegs, this.timetable.nbStops(), query.options.maxTransfers + 1, query.options.maxDuration);
         this.raptor.run(query.options, routingState);
         return new Result(new Set(destinations), routingState, this.stopsIndex, this.timetable);
     }
@@ -22812,6 +22835,9 @@ class RangeRaptorState {
     get destinationBest() {
         return this._destinationBest;
     }
+    get maxArrivalTime() {
+        return this.currentRun.maxArrivalTime;
+    }
     isDestination(stop) {
         return this.currentRun.isDestination(stop);
     }
@@ -22899,7 +22925,7 @@ class RangeRouter {
         const trivialDestCovered = new Set();
         let routingState = null;
         if (query.rangeOptions.optimizeBeyondLatestDeparture) {
-            routingState = new RoutingState(latest + 1, destinations, accessLegs, this.timetable.nbStops(), maxRounds);
+            routingState = new RoutingState(latest + 1, destinations, accessLegs, this.timetable.nbStops(), maxRounds, query.options.maxDuration);
             rangeState.setCurrentRun(routingState);
             this.raptor.run(Object.assign(Object.assign({}, query.options), { maxInitialWaitingTime: undefined }), rangeState);
             if (!noDestinations) {
@@ -22915,7 +22941,7 @@ class RangeRouter {
                 break;
             }
             if (routingState === null) {
-                routingState = new RoutingState(depTime, destinations, legs, this.timetable.nbStops(), maxRounds);
+                routingState = new RoutingState(depTime, destinations, legs, this.timetable.nbStops(), maxRounds, query.options.maxDuration);
             }
             else {
                 routingState.resetFor(depTime, legs);
@@ -23044,6 +23070,7 @@ class Raptor {
             const arrivalTime = route.arrivalAtOffset(currentStopIndex, tripStopOffset);
             const dropOffType = route.dropOffTypeAtOffset(currentStopIndex, tripStopOffset);
             if (dropOffType !== NOT_AVAILABLE &&
+                arrivalTime <= state.maxArrivalTime &&
                 arrivalTime < state.improvementBound(round, currentStop) &&
                 arrivalTime < state.destinationBest) {
                 edgesAtCurrentRound[currentStop] = {
@@ -23091,6 +23118,7 @@ class Raptor {
                 const arrivalTime = route.arrivalAtOffset(currentStopIndex, activeTripStopOffset);
                 const dropOffType = route.dropOffTypeAtOffset(currentStopIndex, activeTripStopOffset);
                 if (dropOffType !== NOT_AVAILABLE &&
+                    arrivalTime <= state.maxArrivalTime &&
                     arrivalTime < state.improvementBound(round, currentStop) &&
                     arrivalTime < state.destinationBest) {
                     edgesAtCurrentRound[currentStop] = {
@@ -23124,15 +23152,16 @@ class Raptor {
                     : undefined;
                 const firstBoardableTrip = this.timetable.findFirstBoardableTrip(currentStopIndex, route, earliestTrip, earliestArrivalOnPreviousRound, activeTripIndex, fromTripStop, options.minTransferTime);
                 if (firstBoardableTrip !== undefined) {
+                    const departureTime = route.departureFrom(currentStopIndex, firstBoardableTrip);
                     // At round 1, enforce maxInitialWaitingTime: skip boarding if the
                     // traveler would have to wait longer than the allowed threshold at
                     // the first boarding stop.
                     const exceedsInitialWait = round === 1 &&
                         options.maxInitialWaitingTime !== undefined &&
-                        route.departureFrom(currentStopIndex, firstBoardableTrip) -
-                            earliestArrivalOnPreviousRound >
+                        departureTime - earliestArrivalOnPreviousRound >
                             options.maxInitialWaitingTime;
-                    if (!exceedsInitialWait) {
+                    const exceedsMaxDuration = departureTime > state.maxArrivalTime;
+                    if (!exceedsInitialWait && !exceedsMaxDuration) {
                         activeTripIndex = firstBoardableTrip;
                         activeTripBoardStopIndex = currentStopIndex;
                         activeTripStopOffset = route.tripStopOffset(firstBoardableTrip);
@@ -23174,13 +23203,14 @@ class Raptor {
                     transferTime = options.minTransferTime;
                 }
                 const arrivalAfterTransfer = currentArrival.arrival + transferTime;
-                if (arrivalAfterTransfer <
-                    state.improvementBound(round, transfer.destination) &&
+                if (arrivalAfterTransfer <= state.maxArrivalTime &&
+                    arrivalAfterTransfer <
+                        state.improvementBound(round, transfer.destination) &&
                     arrivalAfterTransfer < state.destinationBest) {
                     arrivalsAtCurrentRound[transfer.destination] = {
                         arrival: arrivalAfterTransfer,
                         from: stop,
-                        to: transfer.destination,
+                        to: transfer.destination, // TODO needed?
                         minTransferTime: transferTime || undefined,
                         type: transfer.type,
                     };
@@ -23294,7 +23324,8 @@ const loadQueriesFromJson = (filePath, stopsIndex) => {
             .from(fromStop.id)
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             .to(new Set(toStops.map((stop) => stop.id)))
-            .departureTime(timeFromString(serializedQuery.departureTime));
+            .departureTime(timeFromString(serializedQuery.departureTime))
+            .maxDuration(6 * 60);
         if (serializedQuery.maxTransfers !== undefined) {
             queryBuilder.maxTransfers(serializedQuery.maxTransfers);
         }
@@ -23333,7 +23364,8 @@ const loadRangeQueriesFromJson = (filePath, stopsIndex) => {
             .to(new Set(toStops.map((stop) => stop.id)))
             .departureTime(timeFromString(serializedQuery.departureTime))
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            .lastDepartureTime(timeFromString(serializedQuery.lastDepartureTime));
+            .lastDepartureTime(timeFromString(serializedQuery.lastDepartureTime))
+            .maxDuration(6 * 60);
         if (serializedQuery.maxTransfers !== undefined) {
             queryBuilder.maxTransfers(serializedQuery.maxTransfers);
         }
@@ -23595,8 +23627,9 @@ const startRepl = (stopsPath, timetablePath) => {
             this.displayPrompt();
         },
     });
+    const routeSyntax = '.route from <stop> to <stop> at <HH:mm> [before <HH:mm>] [with <N> transfers] [wait max <N> minutes]';
     replServer.defineCommand('route', {
-        help: 'Find a route using .route from <stop> to <stop> at <HH:mm> [before <HH:mm>] [with <N> transfers]',
+        help: `Find a route using ${routeSyntax}`,
         action(routeQuery) {
             this.clearBufferedCommand();
             const parts = routeQuery.split(' ').filter(Boolean);
@@ -23605,30 +23638,40 @@ const startRepl = (stopsPath, timetablePath) => {
             const atIndex = parts.indexOf('at');
             const beforeIndex = parts.indexOf('before');
             const withIndex = parts.indexOf('with');
+            const waitIndex = parts.indexOf('wait');
+            const routeClauseIndexes = [beforeIndex, withIndex, waitIndex].filter((index) => index !== -1);
             if (fromIndex === -1 || toIndex === -1 || atIndex === -1) {
-                console.log('Usage: .route from <stop> to <stop> at <HH:mm> [before <HH:mm>] [with <N> transfers]');
+                console.log(`Usage: ${routeSyntax}`);
                 this.displayPrompt();
                 return;
             }
             const fromId = parts.slice(fromIndex + 1, toIndex).join(' ');
             const toId = parts.slice(toIndex + 1, atIndex).join(' ');
-            // atTime ends at 'before', 'with', or the end of the input.
-            const atTimeEnd = beforeIndex !== -1
-                ? beforeIndex
-                : withIndex !== -1
-                    ? withIndex
-                    : parts.length;
+            // atTime ends at 'before', 'with', 'wait', or the end of the input.
+            const atTimeEnd = Math.min(...routeClauseIndexes.filter((index) => index > atIndex), parts.length);
             const atTime = parts.slice(atIndex + 1, atTimeEnd).join(' ');
             // beforeTime is only present when the 'before' keyword appears.
-            const beforeTimeEnd = withIndex !== -1 ? withIndex : parts.length;
+            const beforeTimeEnd = Math.min(...[withIndex, waitIndex].filter((index) => index !== -1 && index > beforeIndex), parts.length);
             const beforeTime = beforeIndex !== -1
                 ? parts.slice(beforeIndex + 1, beforeTimeEnd).join(' ')
                 : undefined;
             const maxTransfers = withIndex !== -1 && parts[withIndex + 1] !== undefined
                 ? parseInt(parts[withIndex + 1])
                 : 4;
-            if (!fromId || !toId || !atTime) {
-                console.log('Usage: .route from <stop> to <stop> at <HH:mm> [before <HH:mm>] [with <N> transfers]');
+            const maxInitialWaitingTime = waitIndex !== -1 &&
+                parts[waitIndex + 1] === 'max' &&
+                parts[waitIndex + 2] !== undefined
+                ? Number(parts[waitIndex + 2])
+                : undefined;
+            const waitUnit = parts[waitIndex + 3];
+            const hasInvalidWaitClause = waitIndex !== -1 &&
+                (parts[waitIndex + 1] !== 'max' ||
+                    maxInitialWaitingTime === undefined ||
+                    !Number.isFinite(maxInitialWaitingTime) ||
+                    maxInitialWaitingTime < 0 ||
+                    (waitUnit !== 'minute' && waitUnit !== 'minutes'));
+            if (!fromId || !toId || !atTime || hasInvalidWaitClause) {
+                console.log(`Usage: ${routeSyntax}`);
                 this.displayPrompt();
                 return;
             }
@@ -23657,13 +23700,16 @@ const startRepl = (stopsPath, timetablePath) => {
                 const router = new Router(timetable, stopsIndex);
                 if (beforeTime !== undefined) {
                     const lastDepartureTime = timeFromString(beforeTime);
-                    const query = new RangeQuery.Builder()
+                    const queryBuilder = new RangeQuery.Builder()
                         .from(fromStop.id)
                         .to(toStop.id)
                         .departureTime(departureTime)
                         .lastDepartureTime(lastDepartureTime)
-                        .maxTransfers(maxTransfers)
-                        .build();
+                        .maxTransfers(maxTransfers);
+                    if (maxInitialWaitingTime !== undefined) {
+                        queryBuilder.maxInitialWaitingTime(maxInitialWaitingTime);
+                    }
+                    const query = queryBuilder.build();
                     const result = router.rangeRoute(query);
                     if (result.size === 0) {
                         console.log(`No journeys found from ${fromStop.name} to ${toStop.name} ` +
@@ -23682,12 +23728,15 @@ const startRepl = (stopsPath, timetablePath) => {
                     }
                 }
                 else {
-                    const query = new Query.Builder()
+                    const queryBuilder = new Query.Builder()
                         .from(fromStop.id)
                         .to(toStop.id)
                         .departureTime(departureTime)
-                        .maxTransfers(maxTransfers)
-                        .build();
+                        .maxTransfers(maxTransfers);
+                    if (maxInitialWaitingTime !== undefined) {
+                        queryBuilder.maxInitialWaitingTime(maxInitialWaitingTime);
+                    }
+                    const query = queryBuilder.build();
                     const result = router.route(query);
                     const arrivalTime = result.arrivalAt(toStop.id);
                     if (arrivalTime === undefined) {