minotor 11.1.2 → 11.2.0

package/dist/cli.mjs

@@ -17287,6 +17287,17 @@ let Route$1 = class Route {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         return this.stopTimes[(offset + stopIndex) * 2];
     }
+    /**
+     * Hot-path variant of {@link departureFrom} that accepts a precomputed base offset.
+     *
+     * @param stopIndex - The index of the stop in the route.
+     * @param offset    - Precomputed value from {@link tripStopOffset}.
+     * @returns The departure time at the specified stop.
+     */
+    departureAtOffset(stopIndex, offset) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return this.stopTimes[(offset + stopIndex) * 2 + 1];
+    }
     /**
      * Hot-path variant of {@link dropOffTypeAt} that accepts a precomputed base offset.
      *
@@ -17326,8 +17337,8 @@ let Route$1 = class Route {
      */
     pickUpTypeFrom(stopIndex, tripIndex) {
         const globalIndex = tripIndex * this.stops.length + stopIndex;
-        const byteIndex = Math.floor(globalIndex / 2);
-        const isSecondPair = globalIndex % 2 === 1;
+        const byteIndex = globalIndex >> 1;
+        const isSecondPair = (globalIndex & 1) === 1;
         const byte = this.pickupDropOffTypes[byteIndex];
         if (byte === undefined) {
             throw new Error(`Pick up type not found for stop ${this.stopId(stopIndex)} (${stopIndex}) at trip index ${tripIndex} in route ${this.serviceRouteId}`);
@@ -17346,8 +17357,8 @@ let Route$1 = class Route {
      */
     dropOffTypeAt(stopIndex, tripIndex) {
         const globalIndex = tripIndex * this.stops.length + stopIndex;
-        const byteIndex = Math.floor(globalIndex / 2);
-        const isSecondPair = globalIndex % 2 === 1;
+        const byteIndex = globalIndex >> 1;
+        const isSecondPair = (globalIndex & 1) === 1;
         const byte = this.pickupDropOffTypes[byteIndex];
         if (byte === undefined) {
             throw new Error(`Drop off type not found for stop ${this.stopId(stopIndex)} (${stopIndex}) at trip index ${tripIndex} in route ${this.serviceRouteId}`);
@@ -17947,6 +17958,47 @@ class Timetable {
         }
         return false;
     }
+    /**
+     * Finds the first trip on `route` at `stopIndex` that can be boarded, starting
+     * from `earliestTrip` and respecting pickup availability, transfer guarantees,
+     * and minimum transfer times.
+     *
+     * @param stopIndex     Stop at which boarding is attempted.
+     * @param route         The route to search.
+     * @param earliestTrip  First trip index to consider.
+     * @param after         Earliest time after which boarding is allowed.
+     * @param beforeTrip    Exclusive upper bound on the trip index (omit to search all).
+     * @param fromTripStop  The alighted trip stop when transferring from another trip;
+     *                      `undefined` when boarding from a walk or origin.
+     * @param transferTime  Minimum transfer time required between trips.
+     * @returns The index of the first boardable trip, or `undefined` if none found.
+     */
+    findFirstBoardableTrip(stopIndex, route, earliestTrip, after = TIME_ORIGIN, beforeTrip, fromTripStop, transferTime = DURATION_ZERO) {
+        const nbTrips = route.getNbTrips();
+        for (let t = earliestTrip; t < (beforeTrip !== null && beforeTrip !== void 0 ? beforeTrip : nbTrips); t++) {
+            const pickup = route.pickUpTypeFrom(stopIndex, t);
+            if (pickup === NOT_AVAILABLE) {
+                continue;
+            }
+            if (fromTripStop === undefined) {
+                return t;
+            }
+            const isGuaranteed = this.isTripTransferGuaranteed(fromTripStop, {
+                stopIndex,
+                routeId: route.id,
+                tripIndex: t,
+            });
+            if (isGuaranteed) {
+                return t;
+            }
+            const departure = route.departureFrom(stopIndex, t);
+            const requiredTime = after + transferTime;
+            if (departure >= requiredTime) {
+                return t;
+            }
+        }
+        return undefined;
+    }
     /**
      * Retrieves all guaranteed trip transfer options available at the specified stop for a given trip.
      *
@@ -21124,6 +21176,12 @@ function isVehicleEdge(edge) {
 function isTransferEdge(edge) {
     return 'from' in edge && 'to' in edge && 'type' in edge;
 }
+/**
+ * Type guard to check if an edge is an AccessEdge (walking access leg).
+ */
+function isAccessEdge(edge) {
+    return 'from' in edge && 'duration' in edge;
+}
 /**
  * Helper class for building DOT graph syntax.
  */
@@ -21219,6 +21277,12 @@ class Plotter {
     transferEdgeNodeId(fromStopId, toStopId, round) {
         return `e_${fromStopId}_${toStopId}_${round}`;
     }
+    /**
+     * Generates a unique node ID for a walking access edge oval.
+     */
+    accessEdgeNodeId(fromStopId, toStopId) {
+        return `access_${fromStopId}_${toStopId}`;
+    }
     /**
      * Generates a unique node ID for a continuation edge oval.
      */
@@ -21342,6 +21406,22 @@ class Plotter {
             `  "${routeOvalId}" -> "${toNodeId}" [color="${roundColor}"];`,
         ];
     }
+    /**
+     * Creates a walking access leg as a dashed oval connecting the query origin
+     * to the initial boarding stop.
+     */
+    createAccessEdge(edge) {
+        const fromNodeId = this.stationNodeId(edge.from);
+        const toNodeId = this.stationNodeId(edge.to);
+        const color = DOT_CONFIG.colors.defaultRound;
+        const ovalId = this.accessEdgeNodeId(edge.from, edge.to);
+        const label = `Walk\\n${durationToString(edge.duration)}`;
+        return [
+            `  "${ovalId}" [label="${label}" shape=oval style="dashed,filled" fillcolor="white" color="${color}"];`,
+            `  "${fromNodeId}" -> "${ovalId}" [color="${color}" style="dashed"];`,
+            `  "${ovalId}" -> "${toNodeId}" [color="${color}" style="dashed"];`,
+        ];
+    }
     /**
      * Creates a transfer edge with transfer information oval in the middle.
      */
@@ -21426,6 +21506,12 @@ class Plotter {
                     if (toStopId)
                         stations.add(toStopId);
                 }
+                else if (isAccessEdge(edge)) {
+                    // Ensure the query origin (edge.from) is always collected even when
+                    // its own OriginNode hasn't been processed yet in this iteration.
+                    stations.add(edge.from);
+                    stations.add(edge.to);
+                }
             }
         }
         return stations;
@@ -21456,14 +21542,18 @@ class Plotter {
             const roundEdges = graph[round];
             if (!roundEdges)
                 continue;
-            // Skip round 0 as it contains only origin nodes
-            if (round === 0) {
-                continue;
-            }
             for (let stopId = 0; stopId < roundEdges.length; stopId++) {
                 const edge = roundEdges[stopId];
                 if (edge === undefined)
                     continue;
+                if (round === 0) {
+                    // Round 0 holds OriginNodes (no edge to draw) and AccessEdges
+                    // (walking legs from the query origin to the first boarding stop).
+                    if (isAccessEdge(edge)) {
+                        edges.push(...this.createAccessEdge(edge));
+                    }
+                    continue;
+                }
                 if (isVehicleEdge(edge)) {
                     edges.push(...this.createVehicleEdge(edge, round));
                     if (edge.continuationOf) {
@@ -21500,6 +21590,13 @@ class Plotter {
     }
 }
 
+/**
+ * A routing query for standard RAPTOR.
+ *
+ * Finds the earliest-arrival journey from `from` to `to` for a single
+ * departure time.  Use {@link RangeQuery} (and `router.rangeRoute()`) when
+ * you want all Pareto-optimal journeys within a departure-time window.
+ */
 class Query {
     constructor(builder) {
         this.from = builder.fromValue;
@@ -21525,16 +21622,16 @@ Query.Builder = class {
         return this;
     }
     /**
-     * Sets the destination stops(s), routing will stop when all the provided stops are reached.
+     * Sets the destination stop(s).
+     * Routing stops as soon as all provided stops have been reached.
      */
     to(to) {
         this.toValue = to instanceof Set ? to : new Set([to]);
         return this;
     }
     /**
-     * Sets the departure time for the query as minutes since midnight.
-     * Note that the router will favor routes that depart shortly after the provided departure time,
-     * even if a later route might arrive at the same time.
+     * Sets the departure time in minutes from midnight.
+     * The router favours trips departing shortly after this time.
      */
     departureTime(departureTime) {
         this.departureTimeValue = departureTime;
@@ -21548,24 +21645,77 @@ Query.Builder = class {
         return this;
     }
     /**
-     * Sets the minimum transfer time (in minutes)
-     * to use when no transfer time is provided in the data.
+     * Sets the fallback minimum transfer time (in minutes) used when the
+     * timetable data does not specify one for a particular transfer.
      */
     minTransferTime(minTransferTime) {
         this.optionsValue.minTransferTime = minTransferTime;
         return this;
     }
     /**
-     * Sets the transport modes to consider.
+     * Restricts routing to the given transport modes.
      */
     transportModes(transportModes) {
         this.optionsValue.transportModes = transportModes;
         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.
+     *
+     * When set, any trip that would require waiting longer than this duration
+     * after arriving at the stop is not considered for the first boarding leg.
+     */
+    maxInitialWaitingTime(maxInitialWaitingTime) {
+        this.optionsValue.maxInitialWaitingTime = maxInitialWaitingTime;
+        return this;
+    }
     build() {
         return new Query(this);
     }
 };
+/**
+ * A routing query for Range RAPTOR.
+ *
+ * Extends {@link Query} with a required `lastDepartureTime` that defines the
+ * upper bound of the departure-time window.  `router.rangeRoute()` returns
+ * all Pareto-optimal journeys departing in
+ * `[departureTime, lastDepartureTime]`.
+ *
+ */
+class RangeQuery extends Query {
+    constructor(builder) {
+        super(builder);
+        this.lastDepartureTime = builder.lastDepartureTimeValue;
+        this.rangeOptions = builder.rangeOptionsValue;
+    }
+}
+RangeQuery.Builder = class extends Query.Builder {
+    constructor() {
+        super(...arguments);
+        this.rangeOptionsValue = {
+            optimizeBeyondLatestDeparture: true,
+        };
+    }
+    /**
+     * Sets the upper bound of the departure-time window.
+     */
+    lastDepartureTime(time) {
+        this.lastDepartureTimeValue = time;
+        return this;
+    }
+    /**
+     * Overrides individual Range RAPTOR options.
+     * Unspecified fields keep their defaults.
+     */
+    rangeOptions(options) {
+        this.rangeOptionsValue = Object.assign(Object.assign({}, this.rangeOptionsValue), options);
+        return this;
+    }
+    build() {
+        return new RangeQuery(this);
+    }
+};
 
 /**
  * Represents a resolved route consisting of multiple legs,
@@ -21582,15 +21732,15 @@ class Route {
      * @throws If no vehicle leg is found in the route.
      */
     departureTime() {
-        let cumulativeTransferTime = DURATION_ZERO;
+        let cumulativeAccessTime = DURATION_ZERO;
         for (let i = 0; i < this.legs.length; i++) {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const leg = this.legs[i];
             if ('departureTime' in leg) {
-                return leg.departureTime - cumulativeTransferTime;
+                return leg.departureTime - cumulativeAccessTime;
             }
-            if ('minTransferTime' in leg && leg.minTransferTime) {
-                cumulativeTransferTime += leg.minTransferTime;
+            if ('duration' in leg && leg.duration) {
+                cumulativeAccessTime += leg.duration;
             }
         }
         throw new Error('No vehicle leg found in route');
@@ -21641,6 +21791,9 @@ class Route {
             const transferDetails = 'type' in leg && !('route' in leg)
                 ? `Transfer: ${leg.type}${leg.minTransferTime ? `, Minimum Transfer Time: ${durationToString(leg.minTransferTime)}` : ''}`
                 : '';
+            const accessDetails = 'duration' in leg
+                ? `Access duration: ${durationToString(leg.duration)}`
+                : '';
             const travelDetails = 'route' in leg && 'departureTime' in leg && 'arrivalTime' in leg
                 ? `Route: ${leg.route.type} ${leg.route.name}, Departure: ${timeToString(leg.departureTime)}, Arrival: ${timeToString(leg.arrivalTime)}`
                 : '';
@@ -21649,6 +21802,7 @@ class Route {
                 `  ${fromStop}`,
                 `  ${toStop}`,
                 transferDetails ? `  ${transferDetails}` : '',
+                accessDetails ? `  ${accessDetails}` : '',
                 travelDetails ? `  ${travelDetails}` : '',
             ]
                 .filter((line) => line.trim() !== '')
@@ -21656,32 +21810,6 @@ class Route {
         })
             .join('\n');
     }
-    /**
-     * Generates a concise JSON representation of the route.
-     * This is particularly useful for generating regression tests
-     * to verify the correctness of route calculations.
-     *
-     * @returns A JSON representation of the route.
-     */
-    asJson() {
-        const jsonLegs = this.legs.map((leg) => {
-            if ('route' in leg) {
-                return {
-                    from: leg.from.id,
-                    to: leg.to.id,
-                    departure: timeToString(leg.departureTime),
-                    arrival: timeToString(leg.arrivalTime),
-                    route: leg.route,
-                };
-            }
-            else {
-                return Object.assign({ from: leg.from.id, to: leg.to.id, type: leg.type }, (leg.minTransferTime !== undefined && {
-                    minTransferTime: leg.minTransferTime,
-                }));
-            }
-        });
-        return jsonLegs;
-    }
 }
 
 const pickUpDropOffTypeMap = [
@@ -21706,15 +21834,35 @@ const toPickupDropOffType = (rawType) => {
     return type;
 };
 class Result {
-    constructor(query, routingState, stopsIndex, timetable) {
-        this.query = query;
+    constructor(destinations, routingState, stopsIndex, timetable) {
+        this.destinations = destinations;
         this.routingState = routingState;
         this.stopsIndex = stopsIndex;
         this.timetable = timetable;
     }
+    /**
+     * Expands a target stop or stop set to all equivalent concrete stop IDs.
+     *
+     * When `to` is omitted, defaults to the resolved destinations stored on this
+     * result.
+     *
+     * Equivalent stops are expanded here so destination handling has a single
+     * source of truth shared by route reconstruction and arrival lookups.
+     */
+    expandDestinations(to) {
+        const targets = to instanceof Set ? to : to !== undefined ? [to] : this.destinations;
+        const expanded = new Set();
+        for (const target of targets) {
+            for (const equivalentStop of this.stopsIndex.equivalentStops(target)) {
+                expanded.add(equivalentStop.id);
+            }
+        }
+        return expanded;
+    }
     /**
      * Reconstructs the best route to a stop by SourceStopId.
-     * (to any stop reachable in less time / transfers than the destination(s) of the query)
+     * (to any stop reachable in less time / transfers than this result's
+     * destination set)
      *
      * @param to The destination stop by SourceStopId.
      * @returns a route to the destination stop if it exists.
@@ -21735,29 +21883,28 @@ class Result {
     }
     /**
      * Reconstructs the best route to a stop.
-     * (to any stop reachable in less time / transfers than the destination(s) of the query)
+     * (to any stop reachable in less time / transfers than this result's
+     * destination set)
      *
-     * @param to The destination stop. Defaults to the destination of the original query.
+     * @param to The destination stop. Defaults to this result's resolved
+     *   destinations.
      * @returns a route to the destination stop if it exists.
      */
     bestRoute(to) {
         var _a;
-        const destinationIterable = to instanceof Set ? to : to ? [to] : this.query.to;
+        const destinationStops = this.expandDestinations(to);
         // Find the fastest-reached destination across all equivalent stops.
         let fastestDestination = undefined;
         let fastestArrivalTime = undefined;
         let fastestLegNumber = undefined;
-        for (const sourceDestination of destinationIterable) {
-            const equivalentStops = this.stopsIndex.equivalentStops(sourceDestination);
-            for (const destination of equivalentStops) {
-                const arrivalData = this.routingState.getArrival(destination.id);
-                if (arrivalData !== undefined &&
-                    (fastestArrivalTime === undefined ||
-                        arrivalData.arrival < fastestArrivalTime)) {
-                    fastestDestination = destination.id;
-                    fastestArrivalTime = arrivalData.arrival;
-                    fastestLegNumber = arrivalData.legNumber;
-                }
+        for (const destination of destinationStops) {
+            const arrivalData = this.routingState.getArrival(destination);
+            if (arrivalData !== undefined &&
+                (fastestArrivalTime === undefined ||
+                    arrivalData.arrival < fastestArrivalTime)) {
+                fastestDestination = destination;
+                fastestArrivalTime = arrivalData.arrival;
+                fastestLegNumber = arrivalData.legNumber;
             }
         }
         if (fastestDestination === undefined || fastestLegNumber === undefined) {
@@ -21768,9 +21915,11 @@ class Result {
         let currentStop = fastestDestination;
         let round = fastestLegNumber;
         let previousVehicleEdge;
-        while (round > 0) {
+        while (round >= 0) {
             const edge = (_a = this.routingState.graph[round]) === null || _a === void 0 ? void 0 : _a[currentStop];
             if (!edge) {
+                if (round === 0)
+                    break;
                 throw new Error(`No edge arriving at stop ${currentStop} at round ${round}`);
             }
             let leg;
@@ -21815,6 +21964,10 @@ class Result {
                 leg = this.buildTransferLeg(edge);
                 previousVehicleEdge = undefined;
             }
+            else if ('duration' in edge) {
+                leg = this.buildAccessLeg(edge);
+                previousVehicleEdge = undefined;
+            }
             else {
                 break;
             }
@@ -21876,6 +22029,21 @@ class Result {
             type: edge.type,
         };
     }
+    /**
+     * Builds a transfer leg from a transfer edge.
+     *
+     * @param edge Transfer edge representing a walking connection between stops
+     * @returns A transfer leg with from/to stops and transfer details
+     */
+    buildAccessLeg(edge) {
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            from: this.stopsIndex.findStopById(edge.from),
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            to: this.stopsIndex.findStopById(edge.to),
+            duration: edge.duration,
+        };
+    }
     /**
      * Builds a guaranteed transfer leg between two consecutive vehicle legs.
      *
@@ -21899,7 +22067,8 @@ class Result {
         };
     }
     /**
-     * Returns the arrival time at any stop reachable in less time / transfers than the destination(s) of the query)
+     * Returns the arrival time at any stop reachable in less time / transfers
+     * than this result's destination set.
      *
      * @param stop The target stop for which to return the arrival time.
      * @param maxTransfers The optional maximum number of transfers allowed.
@@ -21941,6 +22110,118 @@ class Result {
     }
 }
 
+/**
+ * Collects access paths from a query origin and resolves the set of
+ * distinct departure-time slots for Range RAPTOR.
+ */
+class AccessFinder {
+    constructor(timetable, stopsIndex) {
+        this.timetable = timetable;
+        this.stopsIndex = stopsIndex;
+    }
+    /**
+     * Returns every initial access path from the query origin: equivalent stops
+     * (no duration) plus every stop reachable via a single timed walking transfer
+     * (REQUIRES_MINIMAL_TIME), keeping the shortest walk when multiple origins
+     * can reach the same stop.
+     *
+     * @param origin                  Origin stop ID.
+     * @param fallbackMinTransferTime Transfer time used when a walking transfer
+     *                                has no explicit `minTransferTime` in the timetable data.
+     */
+    collectAccessPaths(queryOrigin, fallbackMinTransferTime) {
+        var _a;
+        const equivalentOrigins = this.stopsIndex
+            .equivalentStops(queryOrigin)
+            .map((stop) => stop.id);
+        const accessPaths = new Map();
+        for (const origin of equivalentOrigins) {
+            const existingAccess = accessPaths.get(origin);
+            if (existingAccess === undefined || existingAccess.duration > 0) {
+                accessPaths.set(origin, {
+                    fromStopId: origin,
+                    toStopId: origin,
+                    duration: 0,
+                });
+            }
+            for (const transfer of this.timetable.getTransfers(origin)) {
+                if (transfer.type === 'REQUIRES_MINIMAL_TIME') {
+                    const duration = (_a = transfer.minTransferTime) !== null && _a !== void 0 ? _a : fallbackMinTransferTime;
+                    const existingAccess = accessPaths.get(transfer.destination);
+                    // Keep the shortest walk to maximize the set of reachable trips.
+                    if (existingAccess === undefined ||
+                        (existingAccess.duration && duration < existingAccess.duration)) {
+                        accessPaths.set(transfer.destination, {
+                            fromStopId: origin,
+                            toStopId: transfer.destination,
+                            duration,
+                        });
+                    }
+                }
+            }
+        }
+        return Array.from(accessPaths.values());
+    }
+    /**
+     * Collects all distinct origin departure times within `[from, to]`
+     * (inclusive) and, for each slot, the specific access paths that directly
+     * induce it — i.e. paths whose boarded stop has a boardable trip departing
+     * at exactly `depTime + path.duration`.
+     *
+     * Returned array is sorted **latest-first**. The Range RAPTOR outer loop
+     * seeds only the responsible paths for each slot, avoiding redundant
+     * exploration of access stops whose boarding opportunities belong to a
+     * later slot and whose journeys would therefore be dominated by it.
+     *
+  
+     * @param accessPaths Access paths from the origin to initial boarding stops.
+     * @param from        Earliest origin departure time (inclusive).
+     * @param to          Latest origin departure time (inclusive).
+     */
+    collectDepartureTimes(accessPaths, from, to) {
+        // Map from origin-departure-time → the set of access paths that induce it.
+        const slotMap = new Map();
+        for (const path of accessPaths) {
+            const { toStopId } = path;
+            // Trips from this stop must depart in [from + duration, to + duration]
+            // so that the corresponding origin departure (dep - duration) falls in
+            // [from, to].
+            const searchFrom = from + path.duration;
+            const searchTo = to + path.duration;
+            for (const route of this.timetable.routesPassingThrough(toStopId)) {
+                for (const stopIndex of route.stopRouteIndices(toStopId)) {
+                    let tripIndex = route.findEarliestTrip(stopIndex, searchFrom);
+                    if (tripIndex === undefined)
+                        continue;
+                    const nbTrips = route.getNbTrips();
+                    while (tripIndex < nbTrips) {
+                        const dep = route.departureFrom(stopIndex, tripIndex);
+                        if (dep > searchTo)
+                            break;
+                        if (route.pickUpTypeFrom(stopIndex, tripIndex) !== NOT_AVAILABLE) {
+                            const t = dep - path.duration;
+                            let paths = slotMap.get(t);
+                            if (paths === undefined) {
+                                slotMap.set(t, (paths = new Set()));
+                            }
+                            paths.add(path);
+                        }
+                        tripIndex++;
+                    }
+                }
+            }
+        }
+        if (slotMap.size === 0)
+            return [];
+        // Sort descending so the outer loop processes latest departures first.
+        const sorted = Array.from(slotMap.entries()).sort(([a], [b]) => b - a);
+        return sorted.map(([depTime, paths]) => ({
+            depTime,
+            legs: Array.from(paths),
+        }));
+    }
+}
+
 /**
  * Sentinel value used in the internal arrival-time array to mark stops not yet reached.
  * 0xFFFF = 65 535 minutes ≈ 45.5 days, safely beyond any realistic transit arrival time.
@@ -21950,31 +22231,64 @@ const UNREACHED_TIME = 0xffff;
  * Encapsulates all mutable state for a single RAPTOR routing query.
  */
 class RoutingState {
+    constructor(departureTime, destinations, accessPaths, nbStops, maxRounds = 0) {
+        /**
+         * 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;
+        /**
+         * Every stop that has received an arrival improvement during the current run,
+         * in the order the improvements occurred.  Used by {@link resetFor} to clear
+         * only the touched entries instead of scanning the entire array.
+         */
+        this.reachedStops = [];
+        this.destinations = destinations;
+        this.destinationSet = new Set(destinations);
+        this.earliestArrivalTimes = new Uint16Array(nbStops).fill(UNREACHED_TIME);
+        this.earliestArrivalLegs = new Uint8Array(nbStops);
+        this.origins = []; // overwritten by seedAccessPaths below
+        this.graph = [new Array(nbStops)];
+        for (let r = 1; r <= maxRounds; r++) {
+            this.graph.push(new Array(nbStops));
+        }
+        this.seedAccessPaths(departureTime, accessPaths);
+    }
     /**
-     * Initializes the routing state for a fresh query.
-     *
-     * All stops start as unreached. Each origin is immediately recorded at the
-     * departure time with leg number 0, and a corresponding OriginNode is placed
-     * in round 0 of the graph.
-     *
-     * @param origins      Stop IDs to depart from (may be several equivalent stops).
-     * @param destinations Stop IDs that count as the target of the query.
-     * @param departureTime Earliest departure time in minutes from midnight.
-     * @param nbStops      Total number of stops in the timetable (sets array sizes).
+     * Seeds round-0 arrivals and {@link origins} from a set of access paths.
+     * Called by the constructor and by {@link resetFor}.
+     * Assumes {@link earliestArrivalTimes} and {@link graph}[0] are already
+     * allocated and in their "cleared" state (all entries at UNREACHED_TIME /
+     * undefined) before this method runs.
      */
-    constructor(origins, destinations, departureTime, nbStops) {
-        this.origins = origins;
-        this.destinations = destinations;
-        const earliestArrivalTimes = new Uint16Array(nbStops).fill(UNREACHED_TIME);
-        const earliestArrivalLegs = new Uint8Array(nbStops); // zero-initialized = leg 0
-        const graph0 = new Array(nbStops);
-        for (const stop of origins) {
-            earliestArrivalTimes[stop] = departureTime;
-            graph0[stop] = { arrival: departureTime };
+    seedAccessPaths(depTime, accessPaths) {
+        const seededOrigins = new Set();
+        for (const access of accessPaths) {
+            const arrival = depTime + access.duration;
+            const edge = access.duration === 0
+                ? { stopId: access.fromStopId, arrival: depTime }
+                : {
+                    arrival,
+                    from: access.fromStopId,
+                    to: access.toStopId,
+                    duration: access.duration,
+                };
+            const stop = access.toStopId;
+            if (arrival < this.earliestArrivalTimes[stop]) {
+                this.earliestArrivalTimes[stop] = arrival;
+                this.graph[0][stop] = edge;
+            }
+            seededOrigins.add(stop);
+        }
+        for (const stop of seededOrigins) {
+            this.reachedStops.push(stop);
+        }
+        this.origins = Array.from(seededOrigins);
+        for (let i = 0; i < this.destinations.length; i++) {
+            const t = this.earliestArrivalTimes[this.destinations[i]];
+            if (t < this._destinationBest)
+                this._destinationBest = t;
         }
-        this.earliestArrivalTimes = earliestArrivalTimes;
-        this.earliestArrivalLegs = earliestArrivalLegs;
-        this.graph = [graph0];
     }
     /** Total number of stops in the timetable */
     get nbStops() {
@@ -21987,17 +22301,96 @@ class RoutingState {
     arrivalTime(stop) {
         return this.earliestArrivalTimes[stop];
     }
+    /**
+     * Earliest arrival at any destination stop; {@link UNREACHED_TIME} if none
+     * has been reached yet. Updated automatically by {@link updateArrival}. O(1).
+     */
+    get destinationBest() {
+        return this._destinationBest;
+    }
+    /**
+     * In standard RAPTOR the improvement bound is simply the per-run earliest
+     * arrival; the `round` argument is ignored.
+     */
+    improvementBound(_round, stop) {
+        return this.arrivalTime(stop);
+    }
+    /** No-op in standard RAPTOR — there are no shared cross-run labels to propagate. */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    initRound(_round) { }
     /**
      * Records a new earliest arrival at a stop.
-  
      *
      * @param stop The stop that was reached.
      * @param time The arrival time in minutes from midnight.
      * @param leg  The round number (number of transit legs taken so far).
      */
     updateArrival(stop, time, leg) {
+        this.reachedStops.push(stop);
         this.earliestArrivalTimes[stop] = time;
         this.earliestArrivalLegs[stop] = leg;
+        if (this.destinationSet.has(stop) && time < this._destinationBest) {
+            this._destinationBest = time;
+        }
+    }
+    /**
+     * Resets this state for a new departure-time iteration **without
+     * reallocating** the underlying arrays.
+     *
+     * Only the stops recorded in {@link reachedStops} are touched — all other
+     * entries are already at their initial bound values.
+     *
+     * After this call the state is equivalent to a freshly constructed
+     * {@link RoutingState} for the given `depTime` and `accessPaths`.
+     *
+     * @param depTime     New origin departure time.
+     * @param accessPaths Access legs for this departure-time slot.
+     */
+    resetFor(depTime, accessPaths) {
+        for (const stop of this.reachedStops) {
+            this.earliestArrivalTimes[stop] = UNREACHED_TIME;
+            this.earliestArrivalLegs[stop] = 0;
+            for (let r = 0; r < this.graph.length; r++) {
+                this.graph[r][stop] = undefined;
+            }
+        }
+        this.reachedStops.length = 0;
+        this._destinationBest = UNREACHED_TIME;
+        this.seedAccessPaths(depTime, accessPaths);
+    }
+    /**
+     * Iterates over every stop that has been reached, yielding its stop ID,
+     * earliest arrival time, and the number of legs taken to reach it.
+     *
+     * Unreached stops (those still at UNREACHED_TIME) are skipped entirely.
+     *
+     * @example
+     * ```ts
+     * for (const { stop, arrival, legNumber } of routingState.arrivals()) {
+     *   console.log(`Stop ${stop}: arrived at ${arrival} after ${legNumber} leg(s)`);
+     * }
+     * ```
+     */
+    *arrivals() {
+        for (let stop = 0; stop < this.earliestArrivalTimes.length; stop++) {
+            const time = this.earliestArrivalTimes[stop];
+            if (time < UNREACHED_TIME) {
+                yield {
+                    stop,
+                    arrival: time,
+                    legNumber: this.earliestArrivalLegs[stop],
+                };
+            }
+        }
+    }
+    /**
+     * Finds the earliest arrival time at any stop from a given set of destinations.
+     *
+     * @param routingState The routing state containing arrival times and destinations.
+     * @returns The earliest arrival time among the provided destinations.
+     */
+    earliestArrivalAtAnyDestination() {
+        return this._destinationBest;
     }
     /**
      * Returns the earliest arrival at a stop as an {@link Arrival} object,
@@ -22009,6 +22402,13 @@ class RoutingState {
             return undefined;
         return { arrival: time, legNumber: this.earliestArrivalLegs[stop] };
     }
+    /**
+     * Returns `true` if `stop` is one of the query's destination stops.
+     * O(1) — backed by a `Set` built at construction time.
+     */
+    isDestination(stop) {
+        return this.destinationSet.has(stop);
+    }
     /**
      * Creates a {@link RoutingState} from fully-specified raw data.
      *
@@ -22027,7 +22427,11 @@ class RoutingState {
      * @internal For use in tests only.
      */
     static fromTestData({ nbStops, origins = [], destinations = [], arrivals = [], graph = [], }) {
-        const state = new RoutingState(origins, destinations, 0, nbStops);
+        const state = new RoutingState(0, destinations, origins.map((stop) => ({
+            fromStopId: stop,
+            toStopId: stop,
+            duration: 0,
+        })), nbStops);
         // Replace the arrival arrays with freshly built ones so the constructor's
         // origin-seeding doesn't bleed into the test state.
         const earliestArrivalTimes = new Uint16Array(nbStops).fill(UNREACHED_TIME);
@@ -22038,6 +22442,14 @@ class RoutingState {
         }
         state.earliestArrivalTimes = earliestArrivalTimes;
         state.earliestArrivalLegs = earliestArrivalLegs;
+        // Recompute _destinationBest from the test data since we bypassed updateArrival.
+        // fromTestData is a static method of RoutingState, so private access is allowed.
+        state._destinationBest = UNREACHED_TIME;
+        for (const dest of destinations) {
+            const t = earliestArrivalTimes[dest];
+            if (t !== undefined && t < state._destinationBest)
+                state._destinationBest = t;
+        }
         // Convert the sparse per-round representation to dense arrays and replace
         // the graph in-place.
         const denseRounds = graph.map((round) => {
@@ -22052,115 +22464,526 @@ class RoutingState {
     }
 }
 
-/**
- * A public transportation router implementing the RAPTOR algorithm.
- * For more information on the RAPTOR algorithm,
- * refer to its detailed explanation in the research paper:
- * https://www.microsoft.com/en-us/research/wp-content/uploads/2012/01/raptor_alenex.pdf
- */
-class Router {
-    constructor(timetable, stopsIndex) {
+class PlainRouter {
+    constructor(timetable, stopsIndex, accessFinder, raptor) {
         this.timetable = timetable;
         this.stopsIndex = stopsIndex;
+        this.accessFinder = accessFinder;
+        this.raptor = raptor;
     }
     /**
-     * The main Raptor algorithm implementation.
+     * Standard RAPTOR: finds the earliest-arrival journey from `query.from` to
+     * `query.to` for the given departure time.
      *
-     * @param query The query containing the main parameters for the routing.
-     * @returns A result object containing data structures allowing to reconstruct routes and .
+     * @param query The routing query.
+     * @returns A {@link Result} that can reconstruct the best route and arrival times.
      */
     route(query) {
-        const routingState = this.initRoutingState(query);
-        const markedStops = new Set(routingState.origins);
-        // Initial transfer consideration for origins
-        const newlyMarkedStops = this.considerTransfers(query, 0, markedStops, routingState);
-        for (const newStop of newlyMarkedStops) {
-            markedStops.add(newStop);
-        }
-        for (let round = 1; round <= query.options.maxTransfers + 1; round++) {
-            const edgesAtCurrentRound = new Array(routingState.nbStops);
-            routingState.graph.push(edgesAtCurrentRound);
-            const reachableRoutes = this.timetable.findReachableRoutes(markedStops, query.options.transportModes);
-            markedStops.clear();
-            // for each route that can be reached with at least round - 1 trips
-            for (const [route, hopOnStopIndex] of reachableRoutes) {
-                const newlyMarkedStops = this.scanRoute(route, hopOnStopIndex, round, routingState, query.options);
-                for (const newStop of newlyMarkedStops) {
-                    markedStops.add(newStop);
-                }
-            }
-            // process in-seat trip continuations
-            let continuations = this.findTripContinuations(markedStops, edgesAtCurrentRound);
-            const stopsFromContinuations = new Set();
-            while (continuations.length > 0) {
-                stopsFromContinuations.clear();
-                for (const continuation of continuations) {
-                    const route = this.timetable.getRoute(continuation.routeId);
-                    const routeScanResults = this.scanRouteContinuation(route, continuation.stopIndex, round, routingState, continuation);
-                    for (const newStop of routeScanResults) {
-                        stopsFromContinuations.add(newStop);
-                    }
-                }
-                for (const newStop of stopsFromContinuations) {
-                    markedStops.add(newStop);
-                }
-                continuations = this.findTripContinuations(stopsFromContinuations, edgesAtCurrentRound);
-            }
-            const newlyMarkedStops = this.considerTransfers(query, round, markedStops, routingState);
-            for (const newStop of newlyMarkedStops) {
-                markedStops.add(newStop);
-            }
-            if (markedStops.size === 0)
-                break;
-        }
-        return new Result(query, routingState, this.stopsIndex, this.timetable);
+        const accessLegs = this.accessFinder.collectAccessPaths(query.from, query.options.minTransferTime);
+        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);
+        this.raptor.run(query.options, routingState);
+        return new Result(new Set(destinations), routingState, this.stopsIndex, this.timetable);
+    }
+}
+
+/**
+ * The result of a Range RAPTOR query.
+ *
+ * Contains the complete Pareto-optimal set of journeys for a resolved
+ * destination set.
+ *
+ * **Pareto dominance**: journey J1 dominates J2 iff
+ *   `τdep(J1) ≥ τdep(J2)  AND  τarr(J1) ≤ τarr(J2)`
+ * (with at least one strict inequality).
+ *
+ * Runs are ordered **latest-departure-first**: each successive run departs
+ * strictly earlier *and* arrives strictly earlier than the previous one,
+ * forming the classic staircase Pareto frontier.
+ *
+ * Destination handling is delegated to {@link Result}, which expands
+ * equivalent stops when reconstructing routes or looking up arrivals.
+ */
+class RangeResult {
+    constructor(runs, destinations) {
+        this._runs = runs;
+        this._destinations = destinations;
+    }
+    /** The resolved destination stop IDs for this result. */
+    get destinations() {
+        return this._destinations;
+    }
+    normalizeTargets(to) {
+        if (to instanceof Set)
+            return new Set(to);
+        if (to !== undefined)
+            return new Set([to]);
+        return new Set(this._destinations);
     }
     /**
-     * Finds trip continuations for the given marked stops and edges at the current round.
-     * @param markedStops The set of marked stops.
-     * @param edgesAtCurrentRound The array of edges at the current round, indexed by stop ID.
-     * @returns An array of trip continuations.
+     * Returns all non-dominated routes to this result's default destination set,
+     * ordered from the earliest departure to the latest departure.
+     *
+     * Each route in the list departs strictly earlier *and* arrives strictly
+     * earlier than its predecessor.
      */
-    findTripContinuations(markedStops, edgesAtCurrentRound) {
-        const continuations = [];
-        for (const stopId of markedStops) {
-            const arrival = edgesAtCurrentRound[stopId];
-            if (!arrival || !('routeId' in arrival))
-                continue;
-            const continuousTrips = this.timetable.getContinuousTrips(arrival.hopOffStopIndex, arrival.routeId, arrival.tripIndex);
-            for (let i = 0; i < continuousTrips.length; i++) {
-                const trip = continuousTrips[i];
-                continuations.push({
-                    routeId: trip.routeId,
-                    stopIndex: trip.stopIndex,
-                    tripIndex: trip.tripIndex,
-                    previousEdge: arrival,
-                });
-            }
+    getRoutes() {
+        const routes = [];
+        for (const { result } of this._runs) {
+            const route = result.bestRoute();
+            if (route !== undefined)
+                routes.push(route);
         }
-        return continuations;
+        return routes.reverse();
     }
     /**
-     * Initializes the routing state for the RAPTOR algorithm.
+     * The route that arrives **earliest** at the given stop(s) across all
+     * Pareto-optimal runs.
      *
-     * This method sets up the initial data structures needed for route planning,
-     * including origin and destination stops (considering equivalent stops),
-     * earliest arrival times, and marked stops for processing.
+     * When two runs achieve the same arrival time at the target, the one with
+     * the **later departure** is preferred — you wait at the origin rather than
+     * at a transit stop.
      *
-     * @param query The routing query containing origin, destination, and departure time
-     * @returns The initialized routing state with all necessary data structures
+     * Defaults to this result's own destination stop(s) when `to` is omitted.
+     *
+     * @param to Optional destination stop ID or set of stop IDs.
+     * @returns The reconstructed {@link Route} with the earliest arrival,
+     *          or `undefined` if the target is unreachable in every run.
      */
-    initRoutingState(query) {
-        const { from, to, departureTime } = query;
-        // Consider children or siblings of the "from" stop as potential origins
-        const origins = this.stopsIndex
-            .equivalentStops(from)
-            .map((origin) => origin.id);
-        // Consider children or siblings of the "to" stop(s) as potential destinations
-        const destinations = Array.from(to)
-            .flatMap((destination) => this.stopsIndex.equivalentStops(destination))
+    bestRoute(to) {
+        const targetStops = this.normalizeTargets(to);
+        let bestRun;
+        let bestArrival;
+        for (const run of this._runs) {
+            for (const stopId of targetStops) {
+                const arrival = run.result.arrivalAt(stopId);
+                if (arrival === undefined)
+                    continue;
+                if (bestArrival === undefined || arrival.arrival < bestArrival) {
+                    bestArrival = arrival.arrival;
+                    bestRun = run;
+                }
+            }
+        }
+        return bestRun === null || bestRun === void 0 ? void 0 : bestRun.result.bestRoute(targetStops);
+    }
+    /**
+     * The route with the **latest possible departure** from the origin among all
+     * Pareto-optimal journeys in the window.
+     *
+     * This is the journey that lets you leave the origin as late as possible.
+     * It does **not** necessarily achieve the earliest arrival — for that, use
+     * {@link bestRoute}. For the shortest travel duration, use
+     * {@link fastestRoute}.
+     *
+     * Defaults to this result's own destination stop(s) when `to` is omitted.
+     *
+     * @param to Optional destination stop ID or set of stop IDs.
+     * @returns The reconstructed {@link Route} with the latest departure,
+     *          or `undefined` if the target is unreachable in every run.
+     */
+    latestDepartureRoute(to) {
+        const targetStops = this.normalizeTargets(to);
+        for (const { result } of this._runs) {
+            const route = result.bestRoute(targetStops);
+            if (route !== undefined)
+                return route;
+        }
+        return undefined;
+    }
+    /**
+     * Reconstructs the **fastest** route to the given stop(s) — the journey with
+     * the shortest travel duration (arrival time − origin departure time) across
+     * all Pareto-optimal runs.
+     *
+     * Unlike {@link bestRoute}, which returns the route that departs as late as
+     * possible while still arriving early, this method minimizes total time
+     * spent traveling.
+     *
+     * Defaults to this result's own destination stop(s) when `to` is omitted.
+     *
+     * @param to Optional destination stop ID or set of stop IDs.
+     * @returns The reconstructed fastest {@link Route}, or `undefined` if the
+     *          target is unreachable in every run.
+     */
+    fastestRoute(to) {
+        const targetStops = this.normalizeTargets(to);
+        let fastestRun;
+        let shortestDuration = Infinity;
+        for (const run of this._runs) {
+            for (const stopId of targetStops) {
+                const arrival = run.result.arrivalAt(stopId);
+                if (arrival === undefined)
+                    continue;
+                const duration = arrival.arrival - run.departureTime;
+                if (duration < shortestDuration) {
+                    shortestDuration = duration;
+                    fastestRun = run;
+                }
+            }
+        }
+        return fastestRun === null || fastestRun === void 0 ? void 0 : fastestRun.result.bestRoute(targetStops);
+    }
+    /** Number of Pareto-optimal journeys found. */
+    get size() {
+        return this._runs.length;
+    }
+    /**
+     * Earliest achievable arrival at a stop across all Pareto-optimal runs.
+     *
+     * Useful for isochrone / accessibility analysis: given this result's
+     * departure-time frontier, how early can you reach stop `s` regardless of
+     * which specific trip you take?
+     *
+     * Equivalent stops are handled by {@link Result.arrivalAt}.
+     *
+     * @param stop         The target stop ID.
+     * @param maxTransfers Optional upper bound on the number of transfers.
+     */
+    earliestArrivalAt(stop, maxTransfers) {
+        let best;
+        for (const { result } of this._runs) {
+            const arrival = result.arrivalAt(stop, maxTransfers);
+            if (arrival !== undefined &&
+                (best === undefined || arrival.arrival < best.arrival)) {
+                best = arrival;
+            }
+        }
+        return best;
+    }
+    /**
+     * Shortest travel duration to reach a stop across all Pareto-optimal runs.
+     *
+     * For each run, duration is measured from the run's origin departure time to
+     * the earliest arrival at `stop` within that run. The minimum across all
+     * runs is returned.
+     *
+     * Equivalent stops are handled by {@link Result.arrivalAt}.
+     *
+     * Duration is **not** monotone along the Pareto frontier — a run that
+     * departs later may still travel faster — so every run is checked. In
+     * practice the Pareto frontier is small, so this is O(runs).
+     *
+     * Returns `undefined` if `stop` is unreachable in every run.
+     *
+     * @param stop         The target stop ID.
+     * @param maxTransfers Optional upper bound on the number of transfers.
+     */
+    shortestDurationTo(stop, maxTransfers) {
+        let shortest;
+        for (const { departureTime, result } of this._runs) {
+            const arrival = result.arrivalAt(stop, maxTransfers);
+            if (arrival === undefined)
+                continue;
+            const duration = arrival.arrival - departureTime;
+            if (shortest === undefined || duration < shortest.duration) {
+                shortest = Object.assign(Object.assign({}, arrival), { duration });
+            }
+        }
+        return shortest;
+    }
+    /**
+     * Shortest travel duration to **every reachable stop** across all
+     * Pareto-optimal runs, as a single `Map<StopId, DurationArrival>`.
+     */
+    allShortestDurations() {
+        const durations = new Map();
+        for (const { departureTime, result } of this._runs) {
+            for (const { stop, arrival, legNumber, } of result.routingState.arrivals()) {
+                const duration = arrival - departureTime;
+                const existing = durations.get(stop);
+                if (existing === undefined || duration < existing.duration) {
+                    durations.set(stop, { arrival, legNumber, duration });
+                }
+            }
+        }
+        return durations;
+    }
+    /**
+     * Earliest achievable arrival at **every reachable stop** across all
+     * Pareto-optimal runs, as a single `Map<StopId, Arrival>`.
+     */
+    allEarliestArrivals() {
+        const arrivals = new Map();
+        for (const { result } of this._runs) {
+            for (const { stop, arrival, legNumber, } of result.routingState.arrivals()) {
+                const existing = arrivals.get(stop);
+                if (existing === undefined || arrival < existing.arrival) {
+                    arrivals.set(stop, { arrival, legNumber });
+                }
+            }
+        }
+        return arrivals;
+    }
+    /**
+     * Iterates over all Pareto-optimal `(departureTime, result)` pairs,
+     * ordered from the latest departure to the earliest departure.
+     */
+    [Symbol.iterator]() {
+        return this._runs[Symbol.iterator]();
+    }
+}
+
+/**
+ * RAPTOR state for Range RAPTOR mode, implementing {@link IRaptorState}.
+ *
+ * Holds both the cross-run shared labels (carried over from one departure-time
+ * iteration to the next, latest → earliest) and a reference to the current
+ * per-iteration {@link RoutingState} (swapped via {@link setCurrentRun}).
+ *
+ * Concretely, `roundLabels[k][p]` is the best known arrival at stop `p` using
+ * at most `k` transit legs, across **all departure times tried so far**.
+ *
+ * @see https://www.microsoft.com/en-us/research/wp-content/uploads/2012/01/raptor_alenex.pdf
+ */
+class RangeRaptorState {
+    constructor(maxRounds, nbStops, latestDeparture) {
+        /**
+         * Global best arrival at any destination stop across all runs and rounds.
+         * Used for destination-pruning inside scan methods so that routes that cannot
+         * beat the already-known best are skipped early.
+         */
+        this._destinationBest = UNREACHED_TIME;
+        this.latestDeparture = latestDeparture;
+        // maxRounds + 2: index 0 = origin/walk legs, indices 1…maxRounds+1 = transit rounds
+        this.roundLabels = Array.from({ length: maxRounds + 2 }, () => new Uint16Array(nbStops).fill(UNREACHED_TIME));
+        this.changedInRound = Array.from({ length: maxRounds + 2 }, () => []);
+    }
+    /**
+     * Swaps in a fresh {@link RoutingState} for the next departure-time iteration
+     * and seeds the shared round-0 labels from its access arrivals.
+     *
+     * Must be called before every `runRaptor` invocation.
+     */
+    setCurrentRun(routingState) {
+        this.currentRun = routingState;
+        // Propagate round-0 access arrivals into the shared labels so that
+        // initRound(1) can tighten round-1 pruning bounds correctly.
+        const round0 = routingState.graph[0];
+        for (const stop of routingState.origins) {
+            const edge = round0[stop];
+            if (!edge)
+                continue;
+            this.updateArrival(stop, edge.arrival, 0);
+        }
+    }
+    get origins() {
+        return this.currentRun.origins;
+    }
+    get graph() {
+        return this.currentRun.graph;
+    }
+    arrivalTime(stop) {
+        return this.currentRun.arrivalTime(stop);
+    }
+    /**
+     * Uses the cross-run shared label for `round`, which is always at least as
+     * tight as the per-run arrival and therefore provides stronger pruning.
+     */
+    improvementBound(round, stop) {
+        return this.roundLabels[round][stop];
+    }
+    /**
+     * Global best arrival at any destination across all departure-time iterations.
+     * Always at least as tight as the per-run `destinationBest`.
+     */
+    get destinationBest() {
+        return this._destinationBest;
+    }
+    isDestination(stop) {
+        return this.currentRun.isDestination(stop);
+    }
+    /** Updates both the per-run state and the cross-run shared labels. */
+    updateArrival(stop, time, round) {
+        this.currentRun.updateArrival(stop, time, round);
+        if (time < this.roundLabels[round][stop]) {
+            this.roundLabels[round][stop] = time;
+            this.changedInRound[round].push(stop);
+            if (this.currentRun.isDestination(stop) && time < this._destinationBest) {
+                this._destinationBest = time;
+            }
+        }
+    }
+    /**
+     * initialized round `k` from round `k-1`: τk(p) ← min(τk(p), τk-1(p)).
+     *
+     * Must be called at the very start of each RAPTOR round before routes are
+     * scanned.  After this call, `roundLabels[k][p]` is the minimum arrival at
+     * stop `p` achievable with **at most** k transit legs from any departure time
+     * tried so far — which is exactly the tightest valid pruning bound for round k.
+     */
+    initRound(round) {
+        const changed = this.changedInRound[round - 1];
+        if (changed.length === 0)
+            return;
+        const prev = this.roundLabels[round - 1];
+        const curr = this.roundLabels[round];
+        for (let i = 0; i < changed.length; i++) {
+            const stop = changed[i];
+            if (prev[stop] < curr[stop]) {
+                curr[stop] = prev[stop];
+            }
+        }
+        changed.length = 0;
+    }
+}
+
+class RangeRouter {
+    constructor(timetable, stopsIndex, accessFinder, raptor) {
+        this.timetable = timetable;
+        this.stopsIndex = stopsIndex;
+        this.accessFinder = accessFinder;
+        this.raptor = raptor;
+    }
+    /**
+     * Range RAPTOR: finds all Pareto-optimal journeys within the departure-time
+     * window `[query.departureTime, query.lastDepartureTime]`.
+     *
+     * A journey is Pareto-optimal iff no journey departing no earlier arrives no
+     * later. Runs are ordered latest-departure-first in the returned result.
+     *
+     * @param query A {@link RangeQuery} with both `departureTime` and `lastDepartureTime` set.
+     * @returns A {@link RangeResult} exposing the full Pareto frontier.
+     */
+    rangeRoute(query) {
+        var _a, _b;
+        const { departureTime: earliest, lastDepartureTime: latest } = query;
+        const destinations = Array.from(query.to)
+            .flatMap((destination) => this.stopsIndex.equivalentStops(destination))
             .map((destination) => destination.id);
-        return new RoutingState(origins, destinations, departureTime, this.timetable.nbStops());
+        const accessLegs = this.accessFinder.collectAccessPaths(query.from, query.options.minTransferTime);
+        const departureSlots = this.accessFinder.collectDepartureTimes(accessLegs, earliest, latest);
+        if (departureSlots.length === 0) {
+            return new RangeResult([], new Set(destinations));
+        }
+        const maxRounds = query.options.maxTransfers + 1;
+        const rangeState = new RangeRaptorState(maxRounds, this.timetable.nbStops(), latest);
+        const paretoRuns = [];
+        const paretoDestBest = new Map();
+        for (const dest of destinations) {
+            paretoDestBest.set(dest, UNREACHED_TIME);
+        }
+        const trivialDests = new Set(accessLegs
+            .map((leg) => leg.toStopId)
+            .filter((id) => destinations.includes(id)));
+        const trivialDestCovered = new Set();
+        let routingState = null;
+        if (query.rangeOptions.optimizeBeyondLatestDeparture) {
+            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);
+            }
+        }
+        for (const { depTime, legs } of departureSlots) {
+            if (trivialDestCovered.size === destinations.length)
+                break;
+            if (routingState === null) {
+                routingState = new RoutingState(depTime, destinations, legs, this.timetable.nbStops(), maxRounds);
+            }
+            else {
+                routingState.resetFor(depTime, legs);
+            }
+            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)) {
+                    paretoDestBest.set(dest, arrival);
+                    continue;
+                }
+                paretoDestBest.set(dest, arrival);
+                if (trivialDests.has(dest)) {
+                    trivialDestCovered.add(dest);
+                }
+                isParetoOptimal = true;
+            }
+            if (isParetoOptimal) {
+                paretoRuns.push({
+                    departureTime: depTime,
+                    result: new Result(new Set(destinations), routingState, this.stopsIndex, this.timetable),
+                });
+                routingState = null;
+            }
+        }
+        return new RangeResult(paretoRuns, new Set(destinations));
+    }
+}
+
+/**
+ * Encapsulates the core RAPTOR algorithm, operating on a {@link Timetable} and
+ * an {@link IRaptorState} provided by the caller.
+ *
+ * @see https://www.microsoft.com/en-us/research/wp-content/uploads/2012/01/raptor_alenex.pdf
+ */
+class Raptor {
+    constructor(timetable) {
+        this.timetable = timetable;
+    }
+    run(options, state) {
+        const markedStops = new Set(state.origins);
+        for (let round = 1; round <= options.maxTransfers + 1; round++) {
+            state.initRound(round);
+            const edgesAtCurrentRound = state.graph[round];
+            const reachableRoutes = this.timetable.findReachableRoutes(markedStops, options.transportModes);
+            markedStops.clear();
+            for (const [route, hopOnStopIndex] of reachableRoutes) {
+                for (const stop of this.scanRoute(route, hopOnStopIndex, round, state, options)) {
+                    markedStops.add(stop);
+                }
+            }
+            let continuations = this.findTripContinuations(markedStops, edgesAtCurrentRound);
+            const stopsFromContinuations = new Set();
+            while (continuations.length > 0) {
+                stopsFromContinuations.clear();
+                for (const continuation of continuations) {
+                    const route = this.timetable.getRoute(continuation.routeId);
+                    for (const stop of this.scanRouteContinuation(route, continuation.stopIndex, round, state, continuation)) {
+                        stopsFromContinuations.add(stop);
+                        markedStops.add(stop);
+                    }
+                }
+                continuations = this.findTripContinuations(stopsFromContinuations, edgesAtCurrentRound);
+            }
+            for (const stop of this.considerTransfers(options, round, markedStops, state)) {
+                markedStops.add(stop);
+            }
+            if (markedStops.size === 0)
+                break;
+        }
+    }
+    /**
+     * Finds trip continuations for the given marked stops and edges at the current round.
+     * @param markedStops The set of marked stops.
+     * @param edgesAtCurrentRound The array of edges at the current round, indexed by stop ID.
+     * @returns An array of trip continuations.
+     */
+    findTripContinuations(markedStops, edgesAtCurrentRound) {
+        const continuations = [];
+        for (const stopId of markedStops) {
+            const arrival = edgesAtCurrentRound[stopId];
+            if (!arrival || !('routeId' in arrival))
+                continue;
+            const continuousTrips = this.timetable.getContinuousTrips(arrival.hopOffStopIndex, arrival.routeId, arrival.tripIndex);
+            for (const trip of continuousTrips) {
+                continuations.push({
+                    routeId: trip.routeId,
+                    stopIndex: trip.stopIndex,
+                    tripIndex: trip.tripIndex,
+                    previousEdge: arrival,
+                });
+            }
+        }
+        return continuations;
     }
     /**
      * Scans a route for an in-seat trip continuation.
@@ -22173,11 +22996,11 @@ class Router {
      * @param round The current RAPTOR round
      * @param routingState Current routing state
      * @param tripContinuation The in-seat continuation descriptor
+     * @param shared Optional shared state for Range RAPTOR mode
      */
-    scanRouteContinuation(route, hopOnStopIndex, round, routingState, tripContinuation) {
+    scanRouteContinuation(route, hopOnStopIndex, round, state, tripContinuation) {
         const newlyMarkedStops = new Set();
-        const edgesAtCurrentRound = routingState.graph[round];
-        const earliestArrivalAtAnyDestination = this.earliestArrivalAtAnyStop(routingState);
+        const edgesAtCurrentRound = state.graph[round];
         const nbStops = route.getNbStops();
         const routeId = route.id;
         const tripIndex = tripContinuation.tripIndex;
@@ -22187,10 +23010,9 @@ class Router {
             const currentStop = route.stops[currentStopIndex];
             const arrivalTime = route.arrivalAtOffset(currentStopIndex, tripStopOffset);
             const dropOffType = route.dropOffTypeAtOffset(currentStopIndex, tripStopOffset);
-            const earliestArrivalAtCurrentStop = routingState.arrivalTime(currentStop);
             if (dropOffType !== NOT_AVAILABLE &&
-                arrivalTime < earliestArrivalAtCurrentStop &&
-                arrivalTime < earliestArrivalAtAnyDestination) {
+                arrivalTime < state.improvementBound(round, currentStop) &&
+                arrivalTime < state.destinationBest) {
                 edgesAtCurrentRound[currentStop] = {
                     routeId,
                     stopIndex: hopOnStopIndex,
@@ -22199,7 +23021,7 @@ class Router {
                     hopOffStopIndex: currentStopIndex,
                     continuationOf: previousEdge,
                 };
-                routingState.updateArrival(currentStop, arrivalTime, round);
+                state.updateArrival(currentStop, arrivalTime, round);
                 newlyMarkedStops.add(currentStop);
             }
         }
@@ -22216,20 +23038,18 @@ class Router {
      * @param route The route to scan
      * @param hopOnStopIndex The stop index where passengers can first board
      * @param round The current RAPTOR round
-     * @param routingState Current routing state
+     * @param state Current routing state
      * @param options Query options (minTransferTime, etc.)
      */
-    scanRoute(route, hopOnStopIndex, round, routingState, options) {
+    scanRoute(route, hopOnStopIndex, round, state, options) {
         const newlyMarkedStops = new Set();
-        const edgesAtCurrentRound = routingState.graph[round];
-        const edgesAtPreviousRound = routingState.graph[round - 1];
-        const earliestArrivalAtAnyDestination = this.earliestArrivalAtAnyStop(routingState);
+        const edgesAtCurrentRound = state.graph[round];
+        const edgesAtPreviousRound = state.graph[round - 1];
         const nbStops = route.getNbStops();
         const routeId = route.id;
         let activeTripIndex;
         let activeTripBoardStopIndex = hopOnStopIndex;
         // tripStopOffset = activeTripIndex * nbStops, precomputed when the trip changes.
-        // Only valid while activeTripIndex !== undefined.
         let activeTripStopOffset = 0;
         for (let currentStopIndex = hopOnStopIndex; currentStopIndex < nbStops; currentStopIndex++) {
             const currentStop = route.stops[currentStopIndex];
@@ -22237,10 +23057,9 @@ class Router {
             if (activeTripIndex !== undefined) {
                 const arrivalTime = route.arrivalAtOffset(currentStopIndex, activeTripStopOffset);
                 const dropOffType = route.dropOffTypeAtOffset(currentStopIndex, activeTripStopOffset);
-                const earliestArrivalAtCurrentStop = routingState.arrivalTime(currentStop);
                 if (dropOffType !== NOT_AVAILABLE &&
-                    arrivalTime < earliestArrivalAtCurrentStop &&
-                    arrivalTime < earliestArrivalAtAnyDestination) {
+                    arrivalTime < state.improvementBound(round, currentStop) &&
+                    arrivalTime < state.destinationBest) {
                     edgesAtCurrentRound[currentStop] = {
                         routeId,
                         stopIndex: activeTripBoardStopIndex,
@@ -22248,7 +23067,7 @@ class Router {
                         arrival: arrivalTime,
                         hopOffStopIndex: currentStopIndex,
                     };
-                    routingState.updateArrival(currentStop, arrivalTime, round);
+                    state.updateArrival(currentStop, arrivalTime, round);
                     newlyMarkedStops.add(currentStop);
                 }
             }
@@ -22258,142 +23077,166 @@ class Router {
             if (earliestArrivalOnPreviousRound !== undefined &&
                 (activeTripIndex === undefined ||
                     earliestArrivalOnPreviousRound <=
-                        route.departureFrom(currentStopIndex, activeTripIndex))) {
+                        route.departureAtOffset(currentStopIndex, activeTripStopOffset))) {
                 const earliestTrip = route.findEarliestTrip(currentStopIndex, earliestArrivalOnPreviousRound, activeTripIndex);
                 if (earliestTrip === undefined) {
                     continue;
                 }
-                const firstBoardableTrip = this.findFirstBoardableTrip(currentStopIndex, route, earliestTrip, earliestArrivalOnPreviousRound, activeTripIndex, 
-                // provide the previous edge only if it was a vehicle leg
-                previousEdge && 'routeId' in previousEdge ? previousEdge : undefined, options.minTransferTime);
+                const fromTripStop = previousEdge && 'routeId' in previousEdge
+                    ? {
+                        stopIndex: previousEdge.hopOffStopIndex,
+                        routeId: previousEdge.routeId,
+                        tripIndex: previousEdge.tripIndex,
+                    }
+                    : undefined;
+                const firstBoardableTrip = this.timetable.findFirstBoardableTrip(currentStopIndex, route, earliestTrip, earliestArrivalOnPreviousRound, activeTripIndex, fromTripStop, options.minTransferTime);
                 if (firstBoardableTrip !== undefined) {
-                    activeTripIndex = firstBoardableTrip;
-                    activeTripBoardStopIndex = currentStopIndex;
-                    activeTripStopOffset = route.tripStopOffset(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 >
+                            options.maxInitialWaitingTime;
+                    if (!exceedsInitialWait) {
+                        activeTripIndex = firstBoardableTrip;
+                        activeTripBoardStopIndex = currentStopIndex;
+                        activeTripStopOffset = route.tripStopOffset(firstBoardableTrip);
+                    }
                 }
             }
         }
         return newlyMarkedStops;
     }
-    /**
-     * Finds the first boardable trip on a route at a given stop that meets transfer requirements.
-     *
-     * This method searches through trips on a route starting from the earliest trip index reachable
-     * from the previous edge to find the first trip that can be effectively boarded,
-     * considering pickup availability, transfer guarantees, and minimum transfer times.
-     *
-     * @param stopIndex The index in the route of the stop where boarding is attempted
-     * @param route The route to search for boardable trips
-     * @param earliestTrip The earliest trip index to start searching from
-     * @param after The earliest time after which boarding can occur
-     * @param beforeTrip Optional upper bound trip index to limit search
-     * @param previousTrip The previous trip taken (for transfer guarantee checks)
-     * @param transferTime Minimum time required for transfers between trips
-     * @returns The trip index of the first boardable trip, or undefined if none found
-     */
-    findFirstBoardableTrip(stopIndex, route, earliestTrip, after = TIME_ORIGIN, beforeTrip, previousTrip, transferTime = DURATION_ZERO) {
-        const nbTrips = route.getNbTrips();
-        for (let t = earliestTrip; t < (beforeTrip !== null && beforeTrip !== void 0 ? beforeTrip : nbTrips); t++) {
-            const pickup = route.pickUpTypeFrom(stopIndex, t);
-            if (pickup === NOT_AVAILABLE) {
-                continue;
-            }
-            if (previousTrip === undefined) {
-                return t;
-            }
-            const isGuaranteed = this.timetable.isTripTransferGuaranteed({
-                stopIndex: previousTrip.hopOffStopIndex,
-                routeId: previousTrip.routeId,
-                tripIndex: previousTrip.tripIndex,
-            }, { stopIndex, routeId: route.id, tripIndex: t });
-            if (isGuaranteed) {
-                return t;
-            }
-            const departure = route.departureFrom(stopIndex, t);
-            const requiredTime = after + transferTime;
-            if (departure >= requiredTime) {
-                return t;
-            }
-        }
-        return undefined;
-    }
     /**
      * Processes all currently marked stops to find available transfers
      * and determines if using these transfers would result in earlier arrival times
      * at destination stops. It handles different transfer types including in-seat
      * transfers and walking transfers with appropriate minimum transfer times.
      *
-     * @param query The routing query containing transfer options and constraints
+     * @param options  Query options (minTransferTime, etc.)
      * @param round The current round number in the RAPTOR algorithm
-     * @param routingState The current routing state containing arrival times and marked stops
+     * @param markedStops The set of currently marked stops
+     * @param state Current routing state
      */
-    considerTransfers(query, round, markedStops, routingState) {
-        const { options } = query;
-        const arrivalsAtCurrentRound = routingState.graph[round];
+    considerTransfers(options, round, markedStops, state) {
         const newlyMarkedStops = new Set();
+        const arrivalsAtCurrentRound = state.graph[round];
         for (const stop of markedStops) {
             const currentArrival = arrivalsAtCurrentRound[stop];
             // Skip transfers if the last leg was also a transfer
             if (!currentArrival || 'type' in currentArrival)
                 continue;
             const transfers = this.timetable.getTransfers(stop);
-            for (let j = 0; j < transfers.length; j++) {
-                const transfer = transfers[j];
+            for (const transfer of transfers) {
                 let transferTime;
                 if (transfer.minTransferTime) {
                     transferTime = transfer.minTransferTime;
                 }
                 else if (transfer.type === 'IN_SEAT') {
-                    // TODO not needed anymore now that trip continuations are handled separately
                     transferTime = DURATION_ZERO;
                 }
                 else {
                     transferTime = options.minTransferTime;
                 }
                 const arrivalAfterTransfer = currentArrival.arrival + transferTime;
-                const originalArrival = routingState.arrivalTime(transfer.destination);
-                if (arrivalAfterTransfer < originalArrival) {
+                if (arrivalAfterTransfer <
+                    state.improvementBound(round, transfer.destination) &&
+                    arrivalAfterTransfer < state.destinationBest) {
                     arrivalsAtCurrentRound[transfer.destination] = {
                         arrival: arrivalAfterTransfer,
                         from: stop,
                         to: transfer.destination,
-                        minTransferTime: transfer.minTransferTime,
+                        minTransferTime: transferTime || undefined,
                         type: transfer.type,
                     };
-                    routingState.updateArrival(transfer.destination, arrivalAfterTransfer, round);
+                    state.updateArrival(transfer.destination, arrivalAfterTransfer, round);
                     newlyMarkedStops.add(transfer.destination);
                 }
             }
         }
         return newlyMarkedStops;
     }
+}
+
+/**
+ * A public transportation router implementing the RAPTOR and Range RAPTOR
+ * algorithms.
+ *
+ * Thin facade over {@link PlainRouter} and {@link RangeRouter}: constructs the
+ * shared {@link Raptor} engine and {@link AccessFinder} once and delegates each
+ * query to the appropriate router.
+ *
+ * @see https://www.microsoft.com/en-us/research/wp-content/uploads/2012/01/raptor_alenex.pdf
+ */
+class Router {
+    constructor(timetable, stopsIndex) {
+        const raptor = new Raptor(timetable);
+        const accessFinder = new AccessFinder(timetable, stopsIndex);
+        this.plainRouter = new PlainRouter(timetable, stopsIndex, accessFinder, raptor);
+        this.rangeRouter = new RangeRouter(timetable, stopsIndex, accessFinder, raptor);
+    }
     /**
-     * Finds the earliest arrival time at any stop from a given set of destinations.
-     *
-     * @param routingState The routing state containing arrival times and destinations.
-     * @returns The earliest arrival time among the provided destinations.
+     * Standard RAPTOR: finds the earliest-arrival journey from `query.from` to
+     * `query.to` for the given departure time.
      */
-    earliestArrivalAtAnyStop(routingState) {
-        let earliestArrivalAtAnyDestination = UNREACHED_TIME;
-        for (let i = 0; i < routingState.destinations.length; i++) {
-            const arrival = routingState.arrivalTime(routingState.destinations[i]);
-            if (arrival < earliestArrivalAtAnyDestination) {
-                earliestArrivalAtAnyDestination = arrival;
-            }
-        }
-        return earliestArrivalAtAnyDestination;
+    route(query) {
+        return this.plainRouter.route(query);
+    }
+    /**
+     * Range RAPTOR: finds all Pareto-optimal journeys within the departure-time
+     * window `[query.departureTime, query.lastDepartureTime]`.
+     */
+    rangeRoute(query) {
+        return this.rangeRouter.rangeRoute(query);
     }
 }
 
+const renderTable = (columns, rows, footerRow) => {
+    const bar = (l, m, r) => l + columns.map((c) => '─'.repeat(c.width + 2)).join(m) + r;
+    const renderRow = (cells) => '│' +
+        cells
+            .map((cell, i) => {
+            var _a, _b, _c, _d;
+            const width = (_b = (_a = columns[i]) === null || _a === void 0 ? void 0 : _a.width) !== null && _b !== void 0 ? _b : 0;
+            const align = (_d = (_c = columns[i]) === null || _c === void 0 ? void 0 : _c.align) !== null && _d !== void 0 ? _d : 'left';
+            const padded = align === 'right' ? cell.padStart(width) : cell.padEnd(width);
+            return ` ${padded} `;
+        })
+            .join('│') +
+        '│';
+    return [
+        bar('┌', '┬', '┐'),
+        renderRow(columns.map((c) => c.header)),
+        bar('├', '┼', '┤'),
+        ...rows.map(renderRow),
+        bar('├', '┼', '┤'),
+        renderRow(footerRow),
+        bar('└', '┴', '┘'),
+    ].join('\n');
+};
+// ─── Query label ──────────────────────────────────────────────────────────────
+const buildQueryLabel = (query, stopsIndex) => {
+    var _a, _b;
+    const fromName = (_b = (_a = stopsIndex.findStopById(query.from)) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : String(query.from);
+    const toNames = [...query.to]
+        .map((id) => { var _a, _b; return (_b = (_a = stopsIndex.findStopById(id)) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : String(id); })
+        .join(' / ');
+    const dep = timeToString(query.departureTime);
+    if (query instanceof RangeQuery) {
+        const lastDep = timeToString(query.lastDepartureTime);
+        return `${fromName} → ${toNames}  ${dep}–${lastDep}`;
+    }
+    return `${fromName} → ${toNames}  ${dep}`;
+};
+// ─── Query loaders ────────────────────────────────────────────────────────────
 /**
  * Loads a list of routing queries from a JSON file and resolves the
  * human-readable stop IDs to the internal numeric IDs used by the router.
  *
- * The file must contain a JSON array whose elements each have the shape:
- * ```json
- * { "from": "STOP_A", "to": ["STOP_B", "STOP_C"], "departureTime": "08:30:00" }
- * ```
- * An optional `maxTransfers` integer field is also supported.
+ * Only entries that do **not** carry a `lastDepartureTime` field are loaded —
+ * range-query entries are silently skipped.
  *
  * @param filePath - Path to the JSON file containing the serialized queries.
  * @param stopsIndex - The stops index used to resolve source stop IDs to the
@@ -22406,7 +23249,9 @@ class Router {
 const loadQueriesFromJson = (filePath, stopsIndex) => {
     const fileContent = fs.readFileSync(filePath, 'utf-8');
     const serializedQueries = JSON.parse(fileContent);
-    return serializedQueries.map((serializedQuery) => {
+    return serializedQueries
+        .filter((q) => q.lastDepartureTime === undefined)
+        .map((serializedQuery) => {
         const fromStop = stopsIndex.findStopBySourceStopId(serializedQuery.from);
         const toStops = Array.from(serializedQuery.to).map((stopId) => stopsIndex.findStopBySourceStopId(stopId));
         if (!fromStop || toStops.some((toStop) => !toStop)) {
@@ -22423,6 +23268,46 @@ const loadQueriesFromJson = (filePath, stopsIndex) => {
         return queryBuilder.build();
     });
 };
+/**
+ * Loads a list of range routing queries from a JSON file and resolves the
+ * human-readable stop IDs to the internal numeric IDs used by the router.
+ *
+ * Only entries that carry a `lastDepartureTime` field are loaded — plain
+ * point-query entries are silently skipped.
+ *
+ * @param filePath - Path to the JSON file containing the serialized queries.
+ * @param stopsIndex - The stops index used to resolve source stop IDs to the
+ *   internal numeric IDs expected by the router.
+ * @returns An array of fully constructed {@link RangeQuery} objects ready to
+ *   be passed to {@link Router.rangeRoute}.
+ * @throws If the file cannot be read, the JSON is malformed, or any stop ID
+ *   referenced in the file cannot be found in the stops index.
+ */
+const loadRangeQueriesFromJson = (filePath, stopsIndex) => {
+    const fileContent = fs.readFileSync(filePath, 'utf-8');
+    const serializedQueries = JSON.parse(fileContent);
+    return serializedQueries
+        .filter((q) => q.lastDepartureTime !== undefined)
+        .map((serializedQuery) => {
+        const fromStop = stopsIndex.findStopBySourceStopId(serializedQuery.from);
+        const toStops = Array.from(serializedQuery.to).map((stopId) => stopsIndex.findStopBySourceStopId(stopId));
+        if (!fromStop || toStops.some((toStop) => !toStop)) {
+            throw new Error(`Invalid task: Start or end station not found for task ${JSON.stringify(serializedQuery)}`);
+        }
+        const queryBuilder = new RangeQuery.Builder()
+            .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))
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            .lastDepartureTime(timeFromString(serializedQuery.lastDepartureTime));
+        if (serializedQuery.maxTransfers !== undefined) {
+            queryBuilder.maxTransfers(serializedQuery.maxTransfers);
+        }
+        return queryBuilder.build();
+    });
+};
+// ─── Benchmark runners ────────────────────────────────────────────────────────
 /**
  * Benchmarks {@link Router.route} across a set of queries.
  *
@@ -22431,10 +23316,11 @@ const loadQueriesFromJson = (filePath, stopsIndex) => {
  *   produced per query.
  * @param iterations - Number of times each query is repeated. Higher values
  *   yield a more stable mean at the cost of longer wall-clock time.
+ * @param stopsIndex - Used to resolve stop names for result labels.
  * @returns An array of {@link PerformanceResult} objects, one per query, each
  *   containing the mean wall-clock time (µs) and mean heap delta (MB).
  */
-const testRouterPerformance = (router, tasks, iterations) => {
+const testRouterPerformance = (router, tasks, iterations, stopsIndex) => {
     const results = [];
     for (const task of tasks) {
         let totalTime = 0;
@@ -22454,7 +23340,7 @@ const testRouterPerformance = (router, tasks, iterations) => {
             }
         }
         results.push({
-            task,
+            label: buildQueryLabel(task, stopsIndex),
             meanTimeUs: totalTime / iterations,
             meanMemoryMb: totalMemory / iterations / (1024 * 1024),
         });
@@ -22470,14 +23356,14 @@ const testRouterPerformance = (router, tasks, iterations) => {
  * @param tasks - The list of queries to benchmark. One {@link PerformanceResult}
  *   is produced per query.
  * @param iterations - Number of times `bestRoute` is called per query.
+ * @param stopsIndex - Used to resolve stop names for result labels.
  * @returns An array of {@link PerformanceResult} objects, one per query, each
  *   containing the mean wall-clock time (µs) and mean heap delta (MB) for the
  *   `bestRoute` call alone.
  */
-const testBestRoutePerformance = (router, tasks, iterations) => {
+const testBestRoutePerformance = (router, tasks, iterations, stopsIndex) => {
     const results = [];
     for (const task of tasks) {
-        // Compute the routing result once — this is not part of the benchmark.
         const result = router.route(task);
         let totalTime = 0;
         let totalMemory = 0;
@@ -22496,7 +23382,7 @@ const testBestRoutePerformance = (router, tasks, iterations) => {
             }
         }
         results.push({
-            task,
+            label: buildQueryLabel(task, stopsIndex),
             meanTimeUs: totalTime / iterations,
             meanMemoryMb: totalMemory / iterations / (1024 * 1024),
         });
@@ -22504,38 +23390,131 @@ const testBestRoutePerformance = (router, tasks, iterations) => {
     return results;
 };
 /**
- * Prints a human-readable summary of performance results to stdout.
+ * Benchmarks {@link Router.rangeRoute} across a set of range queries.
  *
- * Displays an overall mean across all tasks followed by a per-task breakdown.
- * An optional {@link label} is printed as a section header so that results
- * from different benchmark phases (e.g. routing vs. reconstruction) can be
- * told apart when several calls appear in the same run.
+ * @param router - The router instance to benchmark.
+ * @param tasks - The list of range queries to run. One {@link PerformanceResult}
+ *   is produced per query.
+ * @param iterations - Number of times each query is repeated.
+ * @param stopsIndex - Used to resolve stop names for result labels.
+ * @returns An array of {@link PerformanceResult} objects, one per query, each
+ *   containing the mean wall-clock time (µs) and mean heap delta (MB).
+ */
+const testRangeRouterPerformance = (router, tasks, iterations, stopsIndex) => {
+    const results = [];
+    for (const task of tasks) {
+        let totalTime = 0;
+        let totalMemory = 0;
+        for (let i = 0; i < iterations; i++) {
+            if (global.gc) {
+                global.gc();
+            }
+            const startMemory = process.memoryUsage().heapUsed;
+            const startTime = performance$1.now();
+            router.rangeRoute(task);
+            const endTime = performance$1.now();
+            const endMemory = process.memoryUsage().heapUsed;
+            totalTime += (endTime - startTime) * 1000;
+            if (endMemory >= startMemory) {
+                totalMemory += endMemory - startMemory;
+            }
+        }
+        results.push({
+            label: buildQueryLabel(task, stopsIndex),
+            meanTimeUs: totalTime / iterations,
+            meanMemoryMb: totalMemory / iterations / (1024 * 1024),
+        });
+    }
+    return results;
+};
+/**
+ * Benchmarks {@link RangeResult.getRoutes} — the full Pareto-frontier
+ * reconstruction phase — independently of the range routing phase.
  *
- * @param results - The performance results to display, as returned by
- *   {@link testRouterPerformance} or {@link testBestRoutePerformance}.
- * @param label - Optional heading printed above the results block.
- *   Defaults to `'Performance Results'`.
+ * @param router - The router instance used to produce the range results that
+ *   are then fed into `getRoutes`.
+ * @param tasks - The list of range queries to benchmark. One
+ *   {@link PerformanceResult} is produced per query.
+ * @param iterations - Number of times `getRoutes` is called per query.
+ * @param stopsIndex - Used to resolve stop names for result labels.
+ * @returns An array of {@link PerformanceResult} objects, one per query, each
+ *   containing the mean wall-clock time (µs) and mean heap delta (MB) for the
+ *   `getRoutes` call alone.
+ */
+const testRangeResultPerformance = (router, tasks, iterations, stopsIndex) => {
+    const results = [];
+    for (const task of tasks) {
+        const rangeResult = router.rangeRoute(task);
+        let totalTime = 0;
+        let totalMemory = 0;
+        for (let i = 0; i < iterations; i++) {
+            if (global.gc) {
+                global.gc();
+            }
+            const startMemory = process.memoryUsage().heapUsed;
+            const startTime = performance$1.now();
+            rangeResult.getRoutes();
+            const endTime = performance$1.now();
+            const endMemory = process.memoryUsage().heapUsed;
+            totalTime += (endTime - startTime) * 1000;
+            if (endMemory >= startMemory) {
+                totalMemory += endMemory - startMemory;
+            }
+        }
+        results.push({
+            label: buildQueryLabel(task, stopsIndex),
+            meanTimeUs: totalTime / iterations,
+            meanMemoryMb: totalMemory / iterations / (1024 * 1024),
+        });
+    }
+    return results;
+};
+// ─── Output ───────────────────────────────────────────────────────────────────
+/**
+ * Prints a table summary of performance results to stdout.
+ *
+ * Each row corresponds to one task, identified by a human-readable query label
+ * (origin → destination + departure time). A footer row shows the mean across
+ * all tasks. An optional `label` is printed as a section header above the table.
+ *
+ * @param results - The performance results to display.
+ * @param label - Heading printed above the table. Defaults to `'Performance Results'`.
  */
 const prettyPrintPerformanceResults = (results, label = 'Performance Results') => {
+    console.log(`\n${label}`);
     if (results.length === 0) {
-        console.log('No performance results to display.');
+        console.log('  (no results)');
         return;
     }
-    const overallMeanTimeNs = results.reduce((sum, result) => sum + result.meanTimeUs, 0) /
-        results.length;
-    const overallMeanMemoryMb = results.reduce((sum, result) => sum + result.meanMemoryMb, 0) /
-        results.length;
-    console.log(`${label}:`);
-    console.log(`  Mean Time (µs): ${overallMeanTimeNs.toFixed(0)}`);
-    console.log(`  Mean Memory (MB): ${overallMeanMemoryMb.toFixed(2)}`);
-    console.log('');
-    console.log('Individual Task Results:');
-    results.forEach((result, index) => {
-        console.log(`Task ${index + 1}:`);
-        console.log(`  Mean Time (µs): ${result.meanTimeUs.toFixed(0)}`);
-        console.log(`  Mean Memory (MB): ${result.meanMemoryMb.toFixed(2)}`);
-        console.log('');
+    const fmtTime = (n) => Math.round(n).toLocaleString('en-US');
+    const fmtMem = (n) => n.toFixed(2);
+    const meanTime = results.reduce((s, r) => s + r.meanTimeUs, 0) / results.length;
+    const meanMem = results.reduce((s, r) => s + r.meanMemoryMb, 0) / results.length;
+    const queryHeader = 'Query';
+    const timeHeader = 'Time (µs)';
+    const memHeader = 'Mem (MB)';
+    const timeVals = results.map((r) => fmtTime(r.meanTimeUs));
+    const memVals = results.map((r) => fmtMem(r.meanMemoryMb));
+    const meanTimeStr = fmtTime(meanTime);
+    const meanMemStr = fmtMem(meanMem);
+    const queryWidth = Math.max(queryHeader.length, 'mean'.length, ...results.map((r) => r.label.length));
+    const timeWidth = Math.max(timeHeader.length, meanTimeStr.length, ...timeVals.map((v) => v.length));
+    const memWidth = Math.max(memHeader.length, meanMemStr.length, ...memVals.map((v) => v.length));
+    const columns = [
+        { header: queryHeader, width: queryWidth, align: 'left' },
+        { header: timeHeader, width: timeWidth, align: 'right' },
+        { header: memHeader, width: memWidth, align: 'right' },
+    ];
+    const rows = results.map((r, i) => {
+        var _a, _b;
+        return [
+            r.label,
+            (_a = timeVals[i]) !== null && _a !== void 0 ? _a : '',
+            (_b = memVals[i]) !== null && _b !== void 0 ? _b : '',
+        ];
     });
+    const footer = ['mean', meanTimeStr, meanMemStr];
+    console.log(renderTable(columns, rows, footer));
 };
 
 /**
@@ -22584,25 +23563,39 @@ const startRepl = (stopsPath, timetablePath) => {
         },
     });
     replServer.defineCommand('route', {
-        help: 'Find a route using .route from <stationIdOrName> to <stationIdOrName> at <HH:mm> [with <N> transfers]',
+        help: 'Find a route using .route from <stop> to <stop> at <HH:mm> [before <HH:mm>] [with <N> transfers]',
         action(routeQuery) {
             this.clearBufferedCommand();
             const parts = routeQuery.split(' ').filter(Boolean);
-            const withTransfersIndex = parts.indexOf('with');
-            const maxTransfers = withTransfersIndex !== -1 && parts[withTransfersIndex + 1] !== undefined
-                ? parseInt(parts[withTransfersIndex + 1])
-                : 4;
-            const atTime = parts
-                .slice(withTransfersIndex === -1
-                ? parts.indexOf('at') + 1
-                : parts.indexOf('at') + 1, withTransfersIndex === -1 ? parts.length : withTransfersIndex)
-                .join(' ');
             const fromIndex = parts.indexOf('from');
             const toIndex = parts.indexOf('to');
+            const atIndex = parts.indexOf('at');
+            const beforeIndex = parts.indexOf('before');
+            const withIndex = parts.indexOf('with');
+            if (fromIndex === -1 || toIndex === -1 || atIndex === -1) {
+                console.log('Usage: .route from <stop> to <stop> at <HH:mm> [before <HH:mm>] [with <N> transfers]');
+                this.displayPrompt();
+                return;
+            }
             const fromId = parts.slice(fromIndex + 1, toIndex).join(' ');
-            const toId = parts.slice(toIndex + 1, parts.indexOf('at')).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;
+            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 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 <stationIdOrName> to <stationIdOrName> at <HH:mm> [with <N> transfers]');
+                console.log('Usage: .route from <stop> to <stop> at <HH:mm> [before <HH:mm>] [with <N> transfers]');
                 this.displayPrompt();
                 return;
             }
@@ -22626,30 +23619,61 @@ const startRepl = (stopsPath, timetablePath) => {
                 this.displayPrompt();
                 return;
             }
-            const departureTime = timeFromString(atTime);
             try {
-                const query = new Query.Builder()
-                    .from(fromStop.id)
-                    .to(toStop.id)
-                    .departureTime(departureTime)
-                    .maxTransfers(maxTransfers)
-                    .build();
+                const departureTime = timeFromString(atTime);
                 const router = new Router(timetable, stopsIndex);
-                const result = router.route(query);
-                const arrivalTime = result.arrivalAt(toStop.id);
-                if (arrivalTime === undefined) {
-                    console.log(`Destination not reachable`);
-                }
-                else {
-                    console.log(`Arriving to ${toStop.name} at ${timeToString(arrivalTime.arrival)} with ${arrivalTime.legNumber - 1} transfers from ${fromStop.name}.`);
-                }
-                const bestRoute = result.bestRoute(toStop.id);
-                if (bestRoute) {
-                    console.log(`Found route from ${fromStop.name} to ${toStop.name}:`);
-                    console.log(bestRoute.toString());
+                if (beforeTime !== undefined) {
+                    const lastDepartureTime = timeFromString(beforeTime);
+                    const query = new RangeQuery.Builder()
+                        .from(fromStop.id)
+                        .to(toStop.id)
+                        .departureTime(departureTime)
+                        .lastDepartureTime(lastDepartureTime)
+                        .maxTransfers(maxTransfers)
+                        .build();
+                    const result = router.rangeRoute(query);
+                    if (result.size === 0) {
+                        console.log(`No journeys found from ${fromStop.name} to ${toStop.name} ` +
+                            `between ${atTime} and ${beforeTime}.`);
+                    }
+                    else {
+                        console.log(`Found ${result.size} Pareto-optimal journey${result.size === 1 ? '' : 's'} ` +
+                            `from ${fromStop.name} to ${toStop.name} ` +
+                            `(window ${atTime}–${beforeTime}):`);
+                        const routes = result.getRoutes();
+                        routes.forEach((route, index) => {
+                            const journeyNumber = index + 1;
+                            console.log(`\nJourney ${journeyNumber}:`);
+                            console.log(route.toString());
+                        });
+                    }
                 }
                 else {
-                    console.log('No route found');
+                    const query = new Query.Builder()
+                        .from(fromStop.id)
+                        .to(toStop.id)
+                        .departureTime(departureTime)
+                        .maxTransfers(maxTransfers)
+                        .build();
+                    const result = router.route(query);
+                    const arrivalTime = result.arrivalAt(toStop.id);
+                    if (arrivalTime === undefined) {
+                        console.log(`Destination not reachable`);
+                    }
+                    else {
+                        const transfers = Math.max(0, arrivalTime.legNumber - 1);
+                        console.log(`Arriving to ${toStop.name} at ${timeToString(arrivalTime.arrival)} ` +
+                            `with ${transfers} transfer${transfers === 1 ? '' : 's'} ` +
+                            `from ${fromStop.name}.`);
+                    }
+                    const bestRoute = result.bestRoute(toStop.id);
+                    if (bestRoute) {
+                        console.log(`Found route from ${fromStop.name} to ${toStop.name}:`);
+                        console.log(bestRoute.toString());
+                    }
+                    else {
+                        console.log('No route found');
+                    }
                 }
             }
             catch (error) {
@@ -23009,10 +24033,15 @@ program
     const router = new Router(timetable, stopsIndex);
     const queries = loadQueriesFromJson(routesPath, stopsIndex);
     const iterations = parseInt(options.iterations, 10);
-    const routerResults = testRouterPerformance(router, queries, iterations);
-    prettyPrintPerformanceResults(routerResults, 'Router Performance');
-    const bestRouteResults = testBestRoutePerformance(router, queries, iterations);
-    prettyPrintPerformanceResults(bestRouteResults, 'bestRoute Performance (reconstruction only)');
+    const routerResults = testRouterPerformance(router, queries, iterations, stopsIndex);
+    prettyPrintPerformanceResults(routerResults, 'Point queries — router.route()');
+    const bestRouteResults = testBestRoutePerformance(router, queries, iterations, stopsIndex);
+    prettyPrintPerformanceResults(bestRouteResults, 'Point queries — result.bestRoute() (reconstruction only)');
+    const rangeQueries = loadRangeQueriesFromJson(routesPath, stopsIndex);
+    const rangeRouterResults = testRangeRouterPerformance(router, rangeQueries, iterations, stopsIndex);
+    prettyPrintPerformanceResults(rangeRouterResults, 'Range queries — router.rangeRoute()');
+    const rangeResultResults = testRangeResultPerformance(router, rangeQueries, iterations, stopsIndex);
+    prettyPrintPerformanceResults(rangeResultResults, 'Range queries — rangeResult.getRoutes() (reconstruction only)');
 });
 program.parse(process.argv);
 //# sourceMappingURL=cli.mjs.map