minotor 7.0.2 → 9.0.0

package/src/routing/router.ts

@@ -1,36 +1,64 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { Stop, StopId } from '../stops/stops.js';
+import { StopId } from '../stops/stops.js';
 import { StopsIndex } from '../stops/stopsIndex.js';
 import { Duration } from '../timetable/duration.js';
-import { TripIndex } from '../timetable/route.js';
+import {
+  Route,
+  RouteId,
+  StopRouteIndex,
+  TripRouteIndex,
+} from '../timetable/route.js';
 import { Time } from '../timetable/time.js';
-import { Timetable } from '../timetable/timetable.js';
+import {
+  Timetable,
+  TransferType,
+  TripBoarding,
+} from '../timetable/timetable.js';
 import { Query } from './query.js';
 import { Result } from './result.js';
-import { Leg } from './route.js';
 
 const UNREACHED = Time.infinity();
 
-export type TripLeg = ReachingTime & {
-  leg?: Leg; // leg is not set for the very first segment
+export type OriginNode = { arrival: Time };
+
+export type VehicleEdge = {
+  arrival: Time;
+  from: StopRouteIndex;
+  to: StopRouteIndex;
+  routeId: RouteId;
+  tripIndex: TripRouteIndex;
+  continuationOf?: VehicleEdge;
 };
+export type TransferEdge = {
+  arrival: Time;
+  from: StopId;
+  to: StopId;
+  type: TransferType;
+  minTransferTime?: Duration;
+};
+export type RoutingEdge = OriginNode | VehicleEdge | TransferEdge;
 
-export type ReachingTime = {
+type TripContinuation = TripBoarding & {
+  previousEdge: VehicleEdge;
+};
+
+export type Arrival = {
   arrival: Time;
   legNumber: number;
-  origin: StopId;
 };
 
-type CurrentTrip = {
-  tripIndex: TripIndex;
-  origin: StopId;
-  bestHopOnStop: StopId;
+type Round = number;
+
+export type RoutingState = {
+  earliestArrivals: Map<StopId, Arrival>;
+  graph: Map<StopId, RoutingEdge>[];
+  destinations: StopId[];
 };
 
 /**
- * A public transportation network router implementing the RAPTOR algorithm for
- * efficient journey planning and routing. For more information on the RAPTOR
- * algorithm, refer to its detailed explanation in the research paper:
+ * 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
  */
 export class Router {
@@ -43,30 +71,305 @@ export class Router {
   }
 
   /**
-   * Evaluates possible transfers for a given query on a transport
-   * network, updating the earliest arrivals at various stops and marking new
-   * stops that can be reached through these transfers.
+   * The main Raptor algorithm implementation.
+   *
+   * @param query The query containing the main parameters for the routing.
+   * @returns A result object containing data structures allowing to reconstruct routes and .
+   */
+  route(query: Query): Result {
+    const routingState = this.initRoutingState(query);
+    const markedStops = new Set<StopId>();
+    for (const originStop of routingState.graph[0]!.keys()) {
+      markedStops.add(originStop);
+    }
+    // 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<StopId, RoutingEdge>();
+      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,
+        );
+        for (const newStop of newlyMarkedStops) {
+          markedStops.add(newStop);
+        }
+      }
+      // process in-seat trip continuations
+      let continuations = this.findTripContinuations(
+        markedStops,
+        edgesAtCurrentRound,
+      );
+      while (continuations.length > 0) {
+        const stopsFromContinuations: Set<StopId> = new Set();
+        for (const continuation of continuations) {
+          const route = this.timetable.getRoute(continuation.routeId)!;
+          const routeScanResults = this.scanRoute(
+            route,
+            continuation.hopOnStopIndex,
+            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);
+  }
+
+  /**
+   * 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.
+   * @returns An array of trip continuations.
+   */
+  private findTripContinuations(
+    markedStops: Set<StopId>,
+    edgesAtCurrentRound: Map<StopId, RoutingEdge>,
+  ): TripContinuation[] {
+    const continuations: TripContinuation[] = [];
+    for (const stopId of markedStops) {
+      const arrival = edgesAtCurrentRound.get(stopId);
+      if (!arrival || !('routeId' in arrival)) continue;
+
+      const continuousTrips = this.timetable.getContinuousTrips(
+        arrival.to,
+        arrival.routeId,
+        arrival.tripIndex,
+      );
+      for (let i = 0; i < continuousTrips.length; i++) {
+        const trip = continuousTrips[i]!;
+        continuations.push({
+          routeId: trip.routeId,
+          hopOnStopIndex: trip.hopOnStopIndex,
+          tripIndex: trip.tripIndex,
+          previousEdge: arrival,
+        });
+      }
+    }
+    return continuations;
+  }
+
+  /**
+   * Initializes the routing state for the RAPTOR algorithm.
+   *
+   * 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.
+   *
+   * @param query The routing query containing origin, destination, and departure time
+   * @returns The initialized routing state with all necessary data structures
+   */
+  private initRoutingState(query: Query): RoutingState {
+    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))
+      .map((destination) => destination.id);
+
+    const earliestArrivals = new Map<StopId, Arrival>();
+    const earliestArrivalsWithoutAnyLeg = new Map<StopId, RoutingEdge>();
+    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,
+    };
+  }
+
+  /**
+   * Scans a route to find the earliest possible trips (if not provided) and updates arrival times.
+   *
+   * 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.
+   *
+   * @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
+   */
+  private scanRoute(
+    route: Route,
+    hopOnStopIndex: StopRouteIndex,
+    round: Round,
+    routingState: RoutingState,
+    tripContinuation?: TripContinuation,
+  ): Set<StopId> {
+    const newlyMarkedStops = new Set<StopId>();
+    let activeTrip: TripBoarding | undefined = tripContinuation
+      ? {
+          routeId: route.id,
+          hopOnStopIndex,
+          tripIndex: tripContinuation.tripIndex,
+        }
+      : undefined;
+    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 currentStop: StopId = 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 =
+          routingState.earliestArrivals.get(currentStop)?.arrival ?? UNREACHED;
+        if (
+          dropOffType !== 'NOT_AVAILABLE' &&
+          arrivalTime.isBefore(earliestArrivalAtCurrentStop) &&
+          arrivalTime.isBefore(earliestArrivalAtAnyDestination)
+        ) {
+          const edge = {
+            arrival: arrivalTime,
+            routeId: route.id,
+            tripIndex: activeTrip.tripIndex,
+            from: activeTrip.hopOnStopIndex,
+            to: currentStopIndex,
+          } as VehicleEdge;
+          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,
+          });
+          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 earliestArrivalOnPreviousRound =
+        edgesAtPreviousRound.get(currentStop)?.arrival;
+      // TODO if the last edge is not a transfer, and if there is no trip continuation of type 1 (guaranteed)
+      // Add the minTransferTime to make sure there's at least 2 minutes to transfer.
+      // If platforms are collapsed, make sure to apply the station level transfer time
+      // (or later at route reconstruction time)
+      if (
+        earliestArrivalOnPreviousRound !== undefined &&
+        (activeTrip === undefined ||
+          earliestArrivalOnPreviousRound.isBefore(
+            route.departureFrom(currentStopIndex, activeTrip.tripIndex),
+          ) ||
+          earliestArrivalOnPreviousRound.equals(
+            route.departureFrom(currentStopIndex, activeTrip.tripIndex),
+          ))
+      ) {
+        const earliestTrip = route.findEarliestTrip(
+          currentStopIndex,
+          earliestArrivalOnPreviousRound,
+          activeTrip?.tripIndex,
+        );
+        if (earliestTrip !== undefined) {
+          activeTrip = {
+            routeId: route.id,
+            tripIndex: earliestTrip,
+            hopOnStopIndex: currentStopIndex,
+          };
+        }
+      }
+    }
+    return newlyMarkedStops;
+  }
+
+  /**
+   * 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 round The current round number in the RAPTOR algorithm
+   * @param routingState The current routing state containing arrival times and marked stops
    */
   private considerTransfers(
     query: Query,
-    markedStops: Set<StopId>,
-    arrivalsAtCurrentRound: Map<StopId, TripLeg>,
-    earliestArrivals: Map<StopId, ReachingTime>,
     round: number,
-  ): void {
+    markedStops: Set<StopId>,
+    routingState: RoutingState,
+  ): Set<StopId> {
     const { options } = query;
+    const arrivalsAtCurrentRound = routingState.graph[round]!;
     const newlyMarkedStops: Set<StopId> = new Set();
-    const markedStopsArray = Array.from(markedStops);
-    for (let i = 0; i < markedStopsArray.length; i++) {
-      const stop = markedStopsArray[i]!;
+    for (const stop of markedStops) {
       const currentArrival = arrivalsAtCurrentRound.get(stop);
-      if (!currentArrival) continue;
       // Skip transfers if the last leg was also a transfer
-      const previousLeg = currentArrival.leg;
-      if (previousLeg && !('route' in previousLeg)) {
-        continue;
-      }
-
+      if (!currentArrival || 'type' in currentArrival) continue;
       const transfers = this.timetable.getTransfers(stop);
       for (let j = 0; j < transfers.length; j++) {
         const transfer = transfers[j]!;
@@ -74,6 +377,7 @@ export class Router {
         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;
@@ -83,32 +387,22 @@ export class Router {
           arrivalsAtCurrentRound.get(transfer.destination)?.arrival ??
           UNREACHED;
         if (arrivalAfterTransfer.isBefore(originalArrival)) {
-          const origin = currentArrival.origin;
           arrivalsAtCurrentRound.set(transfer.destination, {
             arrival: arrivalAfterTransfer,
-            legNumber: round,
-            origin: origin,
-            leg: {
-              from: this.stopsIndex.findStopById(stop)!,
-              to: this.stopsIndex.findStopById(transfer.destination)!,
-              minTransferTime: transfer.minTransferTime,
-              type: transfer.type,
-            },
+            from: stop,
+            to: transfer.destination,
+            minTransferTime: transfer.minTransferTime,
+            type: transfer.type,
           });
-          earliestArrivals.set(transfer.destination, {
+          routingState.earliestArrivals.set(transfer.destination, {
             arrival: arrivalAfterTransfer,
             legNumber: round,
-            origin: origin,
           });
           newlyMarkedStops.add(transfer.destination);
         }
       }
     }
-    const newlyMarkedStopsArray = Array.from(newlyMarkedStops);
-    for (let i = 0; i < newlyMarkedStopsArray.length; i++) {
-      const newStop = newlyMarkedStopsArray[i]!;
-      markedStops.add(newStop);
-    }
+    return newlyMarkedStops;
   }
 
   /**
@@ -119,14 +413,13 @@ export class Router {
    * @returns The earliest arrival time among the provided destinations.
    */
   private earliestArrivalAtAnyStop(
-    earliestArrivals: Map<StopId, ReachingTime>,
-    destinations: Stop[],
+    earliestArrivals: Map<StopId, Arrival>,
+    destinations: StopId[],
   ): Time {
     let earliestArrivalAtAnyDestination = UNREACHED;
     for (let i = 0; i < destinations.length; i++) {
       const destination = destinations[i]!;
-      const arrival =
-        earliestArrivals.get(destination.id)?.arrival ?? UNREACHED;
+      const arrival = earliestArrivals.get(destination)?.arrival ?? UNREACHED;
       earliestArrivalAtAnyDestination = Time.min(
         earliestArrivalAtAnyDestination,
         arrival,
@@ -134,164 +427,4 @@ export class Router {
     }
     return earliestArrivalAtAnyDestination;
   }
-
-  /**
-   * The main Raptor algorithm implementation.
-   *
-   * @param query The query containing the main parameters for the routing.
-   * @returns A result object containing data structures allowing to reconstruct routes and .
-   */
-  route(query: Query): Result {
-    const { from, to, departureTime, options } = query;
-    // Consider children or siblings of the "from" stop as potential origins
-    const origins = this.stopsIndex.equivalentStops(from);
-    // Consider children or siblings of the "to" stop(s) as potential destinations
-    const destinations = Array.from(to).flatMap((destination) =>
-      this.stopsIndex.equivalentStops(destination),
-    );
-    const earliestArrivals = new Map<StopId, ReachingTime>();
-
-    const earliestArrivalsWithoutAnyLeg = new Map<StopId, TripLeg>();
-    const earliestArrivalsPerRound = [earliestArrivalsWithoutAnyLeg];
-    // Stops that have been improved at round k-1
-    const markedStops = new Set<StopId>();
-
-    for (let i = 0; i < origins.length; i++) {
-      const originStop = origins[i]!;
-      markedStops.add(originStop.id);
-      earliestArrivals.set(originStop.id, {
-        arrival: departureTime,
-        legNumber: 0,
-        origin: originStop.id,
-      });
-      earliestArrivalsWithoutAnyLeg.set(originStop.id, {
-        arrival: departureTime,
-        legNumber: 0,
-        origin: originStop.id,
-      });
-    }
-    // on the first round we need to first consider transfers to discover all possible route origins
-    this.considerTransfers(
-      query,
-      markedStops,
-      earliestArrivalsWithoutAnyLeg,
-      earliestArrivals,
-      0,
-    );
-
-    for (let round = 1; round <= options.maxTransfers + 1; round++) {
-      const arrivalsAtCurrentRound = new Map<StopId, TripLeg>();
-      earliestArrivalsPerRound.push(arrivalsAtCurrentRound);
-      const arrivalsAtPreviousRound = earliestArrivalsPerRound[round - 1]!;
-      // Routes that contain at least one stop reached with at least round - 1 legs
-      // together with corresponding hop on stop index (earliest marked stop)
-      const reachableRoutes = this.timetable.findReachableRoutes(
-        markedStops,
-        options.transportModes,
-      );
-      markedStops.clear();
-      const earliestArrivalAtAnyDestination = this.earliestArrivalAtAnyStop(
-        earliestArrivals,
-        destinations,
-      );
-      // for each route that can be reached with at least round - 1 trips
-      const reachableRoutesArray = Array.from(reachableRoutes.entries());
-      for (let i = 0; i < reachableRoutesArray.length; i++) {
-        const [route, hopOnStop] = reachableRoutesArray[i]!;
-        let currentTrip: CurrentTrip | undefined = undefined;
-        const startIndex = route.stopIndex(hopOnStop);
-        for (let j = startIndex; j < route.getNbStops(); j++) {
-          const currentStop = route.stops[j]!;
-          // If we're currently on a trip,
-          // check if arrival at the stop improves the earliest arrival time
-          if (currentTrip !== undefined) {
-            const currentArrivalTime = route.arrivalAt(
-              currentStop,
-              currentTrip.tripIndex,
-            );
-            const currentDropOffType = route.dropOffTypeAt(
-              currentStop,
-              currentTrip.tripIndex,
-            );
-            const earliestArrivalAtCurrentStop =
-              earliestArrivals.get(currentStop)?.arrival ?? UNREACHED;
-            if (
-              currentDropOffType !== 'NOT_AVAILABLE' &&
-              currentArrivalTime.isBefore(earliestArrivalAtCurrentStop) &&
-              currentArrivalTime.isBefore(earliestArrivalAtAnyDestination)
-            ) {
-              const bestHopOnDepartureTime = route.departureFrom(
-                currentTrip.bestHopOnStop,
-                currentTrip.tripIndex,
-              );
-              arrivalsAtCurrentRound.set(currentStop, {
-                arrival: currentArrivalTime,
-                legNumber: round,
-                origin: currentTrip.origin,
-                leg: {
-                  from: this.stopsIndex.findStopById(
-                    currentTrip.bestHopOnStop,
-                  )!,
-                  to: this.stopsIndex.findStopById(currentStop)!,
-                  departureTime: bestHopOnDepartureTime,
-                  arrivalTime: currentArrivalTime,
-                  route: this.timetable.getServiceRouteInfo(route),
-                },
-              });
-              earliestArrivals.set(currentStop, {
-                arrival: currentArrivalTime,
-                legNumber: round,
-                origin: currentTrip.origin,
-              });
-              markedStops.add(currentStop);
-            }
-          }
-          // check if we can board an earlier trip at the current stop
-          // if there was no current trip, find the first one reachable
-          const earliestArrivalOnPreviousRound =
-            arrivalsAtPreviousRound.get(currentStop)?.arrival;
-          if (
-            earliestArrivalOnPreviousRound !== undefined &&
-            (currentTrip === undefined ||
-              earliestArrivalOnPreviousRound.isBefore(
-                route.departureFrom(currentStop, currentTrip.tripIndex),
-              ) ||
-              earliestArrivalOnPreviousRound.equals(
-                route.departureFrom(currentStop, currentTrip.tripIndex),
-              ))
-          ) {
-            const earliestTrip = route.findEarliestTrip(
-              currentStop,
-              earliestArrivalOnPreviousRound,
-              currentTrip?.tripIndex,
-            );
-            if (earliestTrip !== undefined) {
-              currentTrip = {
-                tripIndex: earliestTrip,
-                // we need to keep track of the best hop-on stop to reconstruct the route at the end
-                bestHopOnStop: currentStop,
-                origin:
-                  arrivalsAtPreviousRound.get(currentStop)?.origin ??
-                  currentStop,
-              };
-            }
-          }
-        }
-      }
-      this.considerTransfers(
-        query,
-        markedStops,
-        arrivalsAtCurrentRound,
-        earliestArrivals,
-        round,
-      );
-      if (markedStops.size === 0) break;
-    }
-    return new Result(
-      query,
-      earliestArrivals,
-      earliestArrivalsPerRound,
-      this.stopsIndex,
-    );
-  }
 }

package/src/timetable/__tests__/io.test.ts

@@ -6,13 +6,16 @@ import {
   deserializeRoutesAdjacency,
   deserializeServiceRoutesMap,
   deserializeStopsAdjacency,
+  deserializeTripContinuations,
   serializeRoutesAdjacency,
   serializeServiceRoutesMap,
   serializeStopsAdjacency,
+  serializeTripContinuations,
 } from '../io.js';
 import { REGULAR, Route } from '../route.js';
 import { Time } from '../time.js';
-import { ServiceRoute, StopAdjacency } from '../timetable.js';
+import { ServiceRoute, StopAdjacency, TripBoarding } from '../timetable.js';
+import { encode } from '../tripBoardingId.js';
 
 describe('Timetable IO', () => {
   const stopsAdjacency: StopAdjacency[] = [
@@ -33,6 +36,7 @@ describe('Timetable IO', () => {
   ];
   const routesAdjacency = [
     new Route(
+      0,
       new Uint16Array([
         Time.fromHMS(16, 40, 0).toMinutes(),
         Time.fromHMS(16, 50, 0).toMinutes(),
@@ -42,6 +46,7 @@ describe('Timetable IO', () => {
       0,
     ),
     new Route(
+      1,
       new Uint16Array([
         Time.fromHMS(15, 20, 0).toMinutes(),
         Time.fromHMS(15, 30, 0).toMinutes(),
@@ -113,6 +118,34 @@ describe('Timetable IO', () => {
     assert.deepStrictEqual(deserializedData, stopsAdjacency);
   });
 
+  it('should serialize and deserialize tripContinuations correctly', () => {
+    const tripContinuations = new Map<bigint, TripBoarding[]>();
+    tripContinuations.set(encode(1, 0, 2), [
+      { hopOnStopIndex: 1, routeId: 0, tripIndex: 2 },
+      { hopOnStopIndex: 3, routeId: 1, tripIndex: 1 },
+    ]);
+    tripContinuations.set(encode(2, 0, 0), [
+      { hopOnStopIndex: 2, routeId: 0, tripIndex: 0 },
+    ]);
+
+    const serialized = serializeTripContinuations(tripContinuations);
+    const deserialized = deserializeTripContinuations(serialized);
+
+    assert.deepStrictEqual(deserialized, tripContinuations);
+  });
+
+  it('should handle empty StopAdjacency without transfers or tripContinuations', () => {
+    const emptyStopsAdjacency: StopAdjacency[] = [
+      { routes: [0] },
+      { routes: [1] },
+    ];
+
+    const serialized = serializeStopsAdjacency(emptyStopsAdjacency);
+    const deserialized = deserializeStopsAdjacency(serialized);
+
+    assert.deepStrictEqual(deserialized, emptyStopsAdjacency);
+  });
+
   it('should serialize a routes adjacency matrix to a Uint8Array', () => {
     const serializedData = serializeRoutesAdjacency(routesAdjacency);
     assert.deepStrictEqual(serializedData, routesAdjacencyProto);