minotor 11.1.0 → 11.1.2

package/dist/cli.mjs

@@ -17025,7 +17025,6 @@ function isSet(value) {
     return value !== null && value !== undefined;
 }
 
-const TIME_INFINITY = Number.MAX_SAFE_INTEGER;
 const TIME_ORIGIN = 0;
 const DURATION_ZERO = 0;
 /**
@@ -17264,6 +17263,45 @@ let Route$1 = class Route {
         }
         return arrival;
     }
+    /**
+     * Computes the per-trip base offset used by the hot-path scanning methods.
+     *
+     * Cache the result once when boarding a new trip and pass it to
+     * {@link arrivalAtOffset} and {@link dropOffTypeAtOffset} throughout the
+     * scanning loop to avoid recomputing `tripIndex × nbStops` on every stop.
+     *
+     * @param tripIndex - The index of the trip.
+     * @returns `tripIndex × nbStops`.
+     */
+    tripStopOffset(tripIndex) {
+        return tripIndex * this.nbStops;
+    }
+    /**
+     * Hot-path variant of {@link arrivalAt} 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 arrival time at the specified stop.
+     */
+    arrivalAtOffset(stopIndex, offset) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return this.stopTimes[(offset + stopIndex) * 2];
+    }
+    /**
+     * Hot-path variant of {@link dropOffTypeAt} 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 drop-off type at the specified stop.
+     */
+    dropOffTypeAtOffset(stopIndex, offset) {
+        const globalIndex = offset + stopIndex;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const byte = this.pickupDropOffTypes[globalIndex >> 1];
+        // Bit layout per byte (two pairs): [pickup_1(2)][dropOff_1(2)][pickup_0(2)][dropOff_0(2)]
+        // First pair  → drop-off in lower 2 bits; second pair → drop-off in bits 4-5.
+        return (globalIndex & 1 ? (byte >> 4) & 0x03 : byte & 0x03);
+    }
     /**
      * Retrieves the departure time at a specific stop for a given trip.
      *
@@ -17763,6 +17801,12 @@ class Timetable {
     isActive(stopId) {
         return this.activeStops.has(stopId);
     }
+    /**
+     * Returns the total number of stops in the timetable.
+     */
+    nbStops() {
+        return this.stopsAdjacency.length;
+    }
     /**
      * Retrieves the route associated with the given route ID.
      *
@@ -17849,21 +17893,26 @@ class Timetable {
      */
     findReachableRoutes(fromStops, transportModes = ALL_TRANSPORT_MODES) {
         const reachableRoutes = new Map();
-        const fromStopsArray = Array.from(fromStops);
-        for (let i = 0; i < fromStopsArray.length; i++) {
-            const originStop = fromStopsArray[i];
-            const validRoutes = this.routesPassingThrough(originStop).filter((route) => {
-                const serviceRoute = this.getServiceRouteInfo(route);
-                return transportModes.has(serviceRoute.type);
-            });
-            for (let j = 0; j < validRoutes.length; j++) {
-                const route = validRoutes[j];
-                const originStopIndices = route.stopRouteIndices(originStop);
-                const originStopIndex = originStopIndices[0];
+        // Skip the per-route mode check entirely when all modes are allowed,
+        // which is the common case.
+        const filterByMode = transportModes !== ALL_TRANSPORT_MODES;
+        for (const originStop of fromStops) {
+            const stopData = this.stopsAdjacency[originStop];
+            if (!stopData)
+                continue;
+            for (let i = 0; i < stopData.routes.length; i++) {
+                const route = this.routesAdjacency[stopData.routes[i]];
+                if (!route)
+                    continue;
+                if (filterByMode) {
+                    const serviceRoute = this.serviceRoutes[route.serviceRoute()];
+                    if (!serviceRoute || !transportModes.has(serviceRoute.type))
+                        continue;
+                }
+                const originStopIndex = route.stopRouteIndices(originStop)[0];
                 const existingHopOnStopIndex = reachableRoutes.get(route);
                 if (existingHopOnStopIndex !== undefined) {
                     if (originStopIndex < existingHopOnStopIndex) {
-                        // if the current stop is before the existing hop on stop, replace it
                         reachableRoutes.set(route, originStopIndex);
                     }
                 }
@@ -17888,9 +17937,15 @@ class Timetable {
         if (!guaranteedTransfers) {
             return false;
         }
-        return guaranteedTransfers.some((transfer) => transfer.stopIndex === toTripStop.stopIndex &&
-            transfer.routeId === toTripStop.routeId &&
-            transfer.tripIndex === toTripStop.tripIndex);
+        for (let i = 0; i < guaranteedTransfers.length; i++) {
+            const transfer = guaranteedTransfers[i];
+            if (transfer.stopIndex === toTripStop.stopIndex &&
+                transfer.routeId === toTripStop.routeId &&
+                transfer.tripIndex === toTripStop.tripIndex) {
+                return true;
+            }
+        }
+        return false;
     }
     /**
      * Retrieves all guaranteed trip transfer options available at the specified stop for a given trip.
@@ -21224,8 +21279,8 @@ class Plotter {
      * Determines station type (origin/destination) information.
      */
     getStationInfo(stopId) {
-        var _a, _b;
-        const isOrigin = (_b = (_a = this.result.routingState.graph[0]) === null || _a === void 0 ? void 0 : _a.has(stopId)) !== null && _b !== void 0 ? _b : false;
+        var _a;
+        const isOrigin = ((_a = this.result.routingState.graph[0]) === null || _a === void 0 ? void 0 : _a[stopId]) !== undefined;
         const isDestination = this.result.routingState.destinations.includes(stopId);
         return { isOrigin, isDestination };
     }
@@ -21357,8 +21412,11 @@ class Plotter {
     collectStations() {
         const stations = new Set();
         const graph = this.result.routingState.graph;
-        for (const roundMap of graph) {
-            for (const [stopId, edge] of roundMap) {
+        for (const roundEdges of graph) {
+            for (let stopId = 0; stopId < roundEdges.length; stopId++) {
+                const edge = roundEdges[stopId];
+                if (edge === undefined)
+                    continue;
                 stations.add(stopId);
                 if (isVehicleEdge(edge)) {
                     const fromStopId = this.getVehicleEdgeFromStopId(edge);
@@ -21395,14 +21453,17 @@ class Plotter {
         const continuationEdges = [];
         const graph = this.result.routingState.graph;
         for (let round = 0; round < graph.length; round++) {
-            const roundMap = graph[round];
-            if (!roundMap)
+            const roundEdges = graph[round];
+            if (!roundEdges)
                 continue;
             // Skip round 0 as it contains only origin nodes
             if (round === 0) {
                 continue;
             }
-            for (const edge of roundMap.values()) {
+            for (let stopId = 0; stopId < roundEdges.length; stopId++) {
+                const edge = roundEdges[stopId];
+                if (edge === undefined)
+                    continue;
                 if (isVehicleEdge(edge)) {
                     edges.push(...this.createVehicleEdge(edge, round));
                     if (edge.continuationOf) {
@@ -21684,30 +21745,31 @@ class Result {
         const destinationIterable = to instanceof Set ? to : to ? [to] : this.query.to;
         // Find the fastest-reached destination across all equivalent stops.
         let fastestDestination = undefined;
-        let fastestTime = undefined;
+        let fastestArrivalTime = undefined;
+        let fastestLegNumber = undefined;
         for (const sourceDestination of destinationIterable) {
             const equivalentStops = this.stopsIndex.equivalentStops(sourceDestination);
             for (const destination of equivalentStops) {
-                const arrivalTime = this.routingState.earliestArrivals.get(destination.id);
-                if (arrivalTime !== undefined) {
-                    if (fastestTime === undefined ||
-                        arrivalTime.arrival < fastestTime.arrival) {
-                        fastestDestination = destination.id;
-                        fastestTime = arrivalTime;
-                    }
+                const arrivalData = this.routingState.getArrival(destination.id);
+                if (arrivalData !== undefined &&
+                    (fastestArrivalTime === undefined ||
+                        arrivalData.arrival < fastestArrivalTime)) {
+                    fastestDestination = destination.id;
+                    fastestArrivalTime = arrivalData.arrival;
+                    fastestLegNumber = arrivalData.legNumber;
                 }
             }
         }
-        if (!fastestDestination || !fastestTime) {
+        if (fastestDestination === undefined || fastestLegNumber === undefined) {
             return undefined;
         }
         // Reconstruct the path by walking backwards through the routing graph.
         const route = [];
         let currentStop = fastestDestination;
-        let round = fastestTime.legNumber;
+        let round = fastestLegNumber;
         let previousVehicleEdge;
         while (round > 0) {
-            const edge = (_a = this.routingState.graph[round]) === null || _a === void 0 ? void 0 : _a.get(currentStop);
+            const edge = (_a = this.routingState.graph[round]) === null || _a === void 0 ? void 0 : _a[currentStop];
             if (!edge) {
                 throw new Error(`No edge arriving at stop ${currentStop} at round ${round}`);
             }
@@ -21844,19 +21906,21 @@ class Result {
      * @returns The arrival time if the target stop is reachable, otherwise undefined.
      */
     arrivalAt(stop, maxTransfers) {
-        var _a;
+        var _a, _b;
         const equivalentStops = this.stopsIndex.equivalentStops(stop);
         let earliestArrival = undefined;
         for (const equivalentStop of equivalentStops) {
             let arrivalTime;
-            if (maxTransfers === undefined) {
-                arrivalTime = this.routingState.earliestArrivals.get(equivalentStop.id);
+            if (maxTransfers === undefined ||
+                ((_a = this.routingState.getArrival(equivalentStop.id)) === null || _a === void 0 ? void 0 : _a.legNumber) ===
+                    maxTransfers + 1) {
+                arrivalTime = this.routingState.getArrival(equivalentStop.id);
             }
             else {
                 // We have no guarantee that the stop was visited in the last round,
                 // so we need to check all rounds if it's not found in the last one.
                 for (let i = maxTransfers + 1; i >= 0; i--) {
-                    const arrivalEdge = (_a = this.routingState.graph[i]) === null || _a === void 0 ? void 0 : _a.get(equivalentStop.id);
+                    const arrivalEdge = (_b = this.routingState.graph[i]) === null || _b === void 0 ? void 0 : _b[equivalentStop.id];
                     if (arrivalEdge !== undefined) {
                         arrivalTime = {
                             arrival: arrivalEdge.arrival,
@@ -21877,7 +21941,117 @@ class Result {
     }
 }
 
-const UNREACHED = TIME_INFINITY;
+/**
+ * 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.
+ */
+const UNREACHED_TIME = 0xffff;
+/**
+ * Encapsulates all mutable state for a single RAPTOR routing query.
+ */
+class RoutingState {
+    /**
+     * 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).
+     */
+    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 };
+        }
+        this.earliestArrivalTimes = earliestArrivalTimes;
+        this.earliestArrivalLegs = earliestArrivalLegs;
+        this.graph = [graph0];
+    }
+    /** Total number of stops in the timetable */
+    get nbStops() {
+        return this.earliestArrivalTimes.length;
+    }
+    /**
+     * Returns the earliest known arrival time at a stop.
+     * Returns UNREACHED_TIME if the stop has not been reached yet.
+     */
+    arrivalTime(stop) {
+        return this.earliestArrivalTimes[stop];
+    }
+    /**
+     * 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.earliestArrivalTimes[stop] = time;
+        this.earliestArrivalLegs[stop] = leg;
+    }
+    /**
+     * Returns the earliest arrival at a stop as an {@link Arrival} object,
+     * or undefined if the stop has not been reached.
+     */
+    getArrival(stop) {
+        const time = this.earliestArrivalTimes[stop];
+        if (time >= UNREACHED_TIME)
+            return undefined;
+        return { arrival: time, legNumber: this.earliestArrivalLegs[stop] };
+    }
+    /**
+     * Creates a {@link RoutingState} from fully-specified raw data.
+     *
+     * Use this in tests instead of constructing the object through the production
+     * constructor, which is designed for incremental algorithm state.
+     *
+     * @param nbStops  Total number of stops (sets array sizes).
+     * @param origins  Origin stop IDs.
+     * @param destinations  Destination stop IDs.
+     * @param arrivals  Each entry is `[stop, time, leg]` — the earliest arrival
+     *                  time in minutes and the round number for one stop.
+     * @param graph  One element per round. Each round is a sparse list of
+     *               `[stop, edge]` pairs; stops absent from the list are
+     *               left as `undefined` in the dense output array.
+     *
+     * @internal For use in tests only.
+     */
+    static fromTestData({ nbStops, origins = [], destinations = [], arrivals = [], graph = [], }) {
+        const state = new RoutingState(origins, destinations, 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);
+        const earliestArrivalLegs = new Uint8Array(nbStops);
+        for (const [stop, time, leg] of arrivals) {
+            earliestArrivalTimes[stop] = time;
+            earliestArrivalLegs[stop] = leg;
+        }
+        state.earliestArrivalTimes = earliestArrivalTimes;
+        state.earliestArrivalLegs = earliestArrivalLegs;
+        // Convert the sparse per-round representation to dense arrays and replace
+        // the graph in-place.
+        const denseRounds = graph.map((round) => {
+            const arr = new Array(nbStops);
+            for (const [stop, edge] of round) {
+                arr[stop] = edge;
+            }
+            return arr;
+        });
+        state.graph.splice(0, state.graph.length, ...denseRounds);
+        return state;
+    }
+}
+
 /**
  * A public transportation router implementing the RAPTOR algorithm.
  * For more information on the RAPTOR algorithm,
@@ -21897,17 +22071,14 @@ class Router {
      */
     route(query) {
         const routingState = this.initRoutingState(query);
-        const markedStops = new Set();
-        for (const originStop of routingState.graph[0].keys()) {
-            markedStops.add(originStop);
-        }
+        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 Map();
+            const edgesAtCurrentRound = new Array(routingState.nbStops);
             routingState.graph.push(edgesAtCurrentRound);
             const reachableRoutes = this.timetable.findReachableRoutes(markedStops, query.options.transportModes);
             markedStops.clear();
@@ -21920,11 +22091,12 @@ class Router {
             }
             // process in-seat trip continuations
             let continuations = this.findTripContinuations(markedStops, edgesAtCurrentRound);
+            const stopsFromContinuations = new Set();
             while (continuations.length > 0) {
-                const stopsFromContinuations = new Set();
+                stopsFromContinuations.clear();
                 for (const continuation of continuations) {
                     const route = this.timetable.getRoute(continuation.routeId);
-                    const routeScanResults = this.scanRoute(route, continuation.stopIndex, round, routingState, query.options, continuation);
+                    const routeScanResults = this.scanRouteContinuation(route, continuation.stopIndex, round, routingState, continuation);
                     for (const newStop of routeScanResults) {
                         stopsFromContinuations.add(newStop);
                     }
@@ -21946,13 +22118,13 @@ class Router {
     /**
      * Finds trip continuations for the given marked stops and edges at the current round.
      * @param markedStops The set of marked stops.
-     * @param edgesAtCurrentRound The map of edges at the current round.
+     * @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.get(stopId);
+            const arrival = edgesAtCurrentRound[stopId];
             if (!arrival || !('routeId' in arrival))
                 continue;
             const continuousTrips = this.timetable.getContinuousTrips(arrival.hopOffStopIndex, arrival.routeId, arrival.tripIndex);
@@ -21988,106 +22160,116 @@ class Router {
         const destinations = Array.from(to)
             .flatMap((destination) => this.stopsIndex.equivalentStops(destination))
             .map((destination) => destination.id);
-        const earliestArrivals = new Map();
-        const earliestArrivalsWithoutAnyLeg = new Map();
-        const earliestArrivalsPerRound = [earliestArrivalsWithoutAnyLeg];
-        const initialState = {
-            arrival: departureTime,
-            legNumber: 0,
-        };
-        for (const originStop of origins) {
-            earliestArrivals.set(originStop, initialState);
-            earliestArrivalsWithoutAnyLeg.set(originStop, initialState);
-        }
-        return {
-            destinations,
-            earliestArrivals,
-            graph: earliestArrivalsPerRound,
-        };
+        return new RoutingState(origins, destinations, departureTime, this.timetable.nbStops());
     }
     /**
-     * Scans a route to find the earliest possible trips (if not provided) and updates arrival times.
+     * Scans a route for an in-seat trip continuation.
      *
-     * This method implements the core route scanning logic of the RAPTOR algorithm.
-     * It iterates through all stops on a given route starting from the hop-on stop,
-     * maintaining the current best trip and updating arrival times when improvements
-     * are found. The method also handles boarding new trips when earlier departures
-     * are available if no given trip is provided as a parameter.
+     * The boarded trip and entry stop are fixed, so there is no need to probe for
+     * earlier boardings.
      *
-     * @param route The route to scan for possible trips
-     * @param hopOnStopIndex The stop index where passengers can board the route
-     * @param round The current round number in the RAPTOR algorithm
-     * @param routingState The current routing state containing arrival times and marked stops
+     * @param route The route to scan
+     * @param hopOnStopIndex The stop index where the continuation begins
+     * @param round The current RAPTOR round
+     * @param routingState Current routing state
+     * @param tripContinuation The in-seat continuation descriptor
      */
-    scanRoute(route, hopOnStopIndex, round, routingState, options, tripContinuation) {
-        var _a, _b;
+    scanRouteContinuation(route, hopOnStopIndex, round, routingState, tripContinuation) {
         const newlyMarkedStops = new Set();
-        let activeTrip = tripContinuation
-            ? {
-                routeId: route.id,
-                stopIndex: hopOnStopIndex,
-                tripIndex: tripContinuation.tripIndex,
+        const edgesAtCurrentRound = routingState.graph[round];
+        const earliestArrivalAtAnyDestination = this.earliestArrivalAtAnyStop(routingState);
+        const nbStops = route.getNbStops();
+        const routeId = route.id;
+        const tripIndex = tripContinuation.tripIndex;
+        const tripStopOffset = route.tripStopOffset(tripIndex);
+        const previousEdge = tripContinuation.previousEdge;
+        for (let currentStopIndex = hopOnStopIndex; currentStopIndex < nbStops; currentStopIndex++) {
+            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) {
+                edgesAtCurrentRound[currentStop] = {
+                    routeId,
+                    stopIndex: hopOnStopIndex,
+                    tripIndex,
+                    arrival: arrivalTime,
+                    hopOffStopIndex: currentStopIndex,
+                    continuationOf: previousEdge,
+                };
+                routingState.updateArrival(currentStop, arrivalTime, round);
+                newlyMarkedStops.add(currentStop);
             }
-            : undefined;
+        }
+        return newlyMarkedStops;
+    }
+    /**
+     * Scans a route using the standard RAPTOR boarding logic.
+     *
+     * Iterates through all stops from the hop-on point, maintaining the current
+     * best trip and improving arrival times when possible. At each marked stop it
+     * also checks whether an earlier (or first) trip can be boarded, upgrading the
+     * active trip when one is found.
+     *
+     * @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 options Query options (minTransferTime, etc.)
+     */
+    scanRoute(route, hopOnStopIndex, round, routingState, options) {
+        const newlyMarkedStops = new Set();
         const edgesAtCurrentRound = routingState.graph[round];
         const edgesAtPreviousRound = routingState.graph[round - 1];
-        // Compute target pruning criteria only once per route
-        const earliestArrivalAtAnyDestination = this.earliestArrivalAtAnyStop(routingState.earliestArrivals, routingState.destinations);
-        for (let currentStopIndex = hopOnStopIndex; currentStopIndex < route.getNbStops(); currentStopIndex++) {
+        const earliestArrivalAtAnyDestination = this.earliestArrivalAtAnyStop(routingState);
+        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];
-            // If we're currently on a trip,
-            // check if arrival at the stop improves the earliest arrival time
-            if (activeTrip !== undefined) {
-                const arrivalTime = route.arrivalAt(currentStopIndex, activeTrip.tripIndex);
-                const dropOffType = route.dropOffTypeAt(currentStopIndex, activeTrip.tripIndex);
-                const earliestArrivalAtCurrentStop = (_b = (_a = routingState.earliestArrivals.get(currentStop)) === null || _a === void 0 ? void 0 : _a.arrival) !== null && _b !== void 0 ? _b : UNREACHED;
+            // If on a trip, check whether alighting here improves the global best.
+            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) {
-                    const edge = {
-                        routeId: activeTrip.routeId,
-                        stopIndex: activeTrip.stopIndex,
-                        tripIndex: activeTrip.tripIndex,
+                    edgesAtCurrentRound[currentStop] = {
+                        routeId,
+                        stopIndex: activeTripBoardStopIndex,
+                        tripIndex: activeTripIndex,
                         arrival: arrivalTime,
                         hopOffStopIndex: currentStopIndex,
                     };
-                    if (tripContinuation) {
-                        // In case of continuous trip, we set a pointer to the previous edge
-                        edge.continuationOf = tripContinuation.previousEdge;
-                    }
-                    edgesAtCurrentRound.set(currentStop, edge);
-                    routingState.earliestArrivals.set(currentStop, {
-                        arrival: arrivalTime,
-                        legNumber: round,
-                    });
+                    routingState.updateArrival(currentStop, arrivalTime, round);
                     newlyMarkedStops.add(currentStop);
                 }
             }
-            if (tripContinuation) {
-                // If it's a trip continuation, no need to check for earlier trips
-                continue;
-            }
-            // check if we can board an earlier trip at the current stop
-            // if there was no current trip, find the first one reachable
-            const previousEdge = edgesAtPreviousRound.get(currentStop);
+            // Check whether we can board an earlier (or first) trip at this stop.
+            const previousEdge = edgesAtPreviousRound[currentStop];
             const earliestArrivalOnPreviousRound = previousEdge === null || previousEdge === void 0 ? void 0 : previousEdge.arrival;
             if (earliestArrivalOnPreviousRound !== undefined &&
-                (activeTrip === undefined ||
+                (activeTripIndex === undefined ||
                     earliestArrivalOnPreviousRound <=
-                        route.departureFrom(currentStopIndex, activeTrip.tripIndex))) {
-                const earliestTrip = route.findEarliestTrip(currentStopIndex, earliestArrivalOnPreviousRound, activeTrip === null || activeTrip === void 0 ? void 0 : activeTrip.tripIndex);
+                        route.departureFrom(currentStopIndex, activeTripIndex))) {
+                const earliestTrip = route.findEarliestTrip(currentStopIndex, earliestArrivalOnPreviousRound, activeTripIndex);
                 if (earliestTrip === undefined) {
                     continue;
                 }
-                const firstBoardableTrip = this.findFirstBoardableTrip(currentStopIndex, route, earliestTrip, earliestArrivalOnPreviousRound, activeTrip === null || activeTrip === void 0 ? void 0 : activeTrip.tripIndex, 
-                // provide the previous trip if the previous edge was a vehicle
+                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);
                 if (firstBoardableTrip !== undefined) {
-                    activeTrip = {
-                        routeId: route.id,
-                        tripIndex: firstBoardableTrip,
-                        stopIndex: currentStopIndex,
-                    };
+                    activeTripIndex = firstBoardableTrip;
+                    activeTripBoardStopIndex = currentStopIndex;
+                    activeTripStopOffset = route.tripStopOffset(firstBoardableTrip);
                 }
             }
         }
@@ -22146,12 +22328,11 @@ class Router {
      * @param routingState The current routing state containing arrival times and marked stops
      */
     considerTransfers(query, round, markedStops, routingState) {
-        var _a, _b;
         const { options } = query;
         const arrivalsAtCurrentRound = routingState.graph[round];
         const newlyMarkedStops = new Set();
         for (const stop of markedStops) {
-            const currentArrival = arrivalsAtCurrentRound.get(stop);
+            const currentArrival = arrivalsAtCurrentRound[stop];
             // Skip transfers if the last leg was also a transfer
             if (!currentArrival || 'type' in currentArrival)
                 continue;
@@ -22170,19 +22351,16 @@ class Router {
                     transferTime = options.minTransferTime;
                 }
                 const arrivalAfterTransfer = currentArrival.arrival + transferTime;
-                const originalArrival = (_b = (_a = routingState.earliestArrivals.get(transfer.destination)) === null || _a === void 0 ? void 0 : _a.arrival) !== null && _b !== void 0 ? _b : UNREACHED;
+                const originalArrival = routingState.arrivalTime(transfer.destination);
                 if (arrivalAfterTransfer < originalArrival) {
-                    arrivalsAtCurrentRound.set(transfer.destination, {
+                    arrivalsAtCurrentRound[transfer.destination] = {
                         arrival: arrivalAfterTransfer,
                         from: stop,
                         to: transfer.destination,
                         minTransferTime: transfer.minTransferTime,
                         type: transfer.type,
-                    });
-                    routingState.earliestArrivals.set(transfer.destination, {
-                        arrival: arrivalAfterTransfer,
-                        legNumber: round,
-                    });
+                    };
+                    routingState.updateArrival(transfer.destination, arrivalAfterTransfer, round);
                     newlyMarkedStops.add(transfer.destination);
                 }
             }
@@ -22192,17 +22370,16 @@ class Router {
     /**
      * Finds the earliest arrival time at any stop from a given set of destinations.
      *
-     * @param earliestArrivals A map of stops to their earliest reaching times.
-     * @param destinations An array of destination stops to evaluate.
+     * @param routingState The routing state containing arrival times and destinations.
      * @returns The earliest arrival time among the provided destinations.
      */
-    earliestArrivalAtAnyStop(earliestArrivals, destinations) {
-        var _a, _b;
-        let earliestArrivalAtAnyDestination = UNREACHED;
-        for (let i = 0; i < destinations.length; i++) {
-            const destination = destinations[i];
-            const arrival = (_b = (_a = earliestArrivals.get(destination)) === null || _a === void 0 ? void 0 : _a.arrival) !== null && _b !== void 0 ? _b : UNREACHED;
-            earliestArrivalAtAnyDestination = Math.min(earliestArrivalAtAnyDestination, arrival);
+    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;
     }