minotor 8.0.0 → 9.0.1

package/src/routing/router.ts

@@ -2,7 +2,12 @@
 import { StopId } from '../stops/stops.js';
 import { StopsIndex } from '../stops/stopsIndex.js';
 import { Duration } from '../timetable/duration.js';
-import { Route, RouteId, TripRouteIndex } from '../timetable/route.js';
+import {
+  Route,
+  RouteId,
+  StopRouteIndex,
+  TripRouteIndex,
+} from '../timetable/route.js';
 import { Time } from '../timetable/time.js';
 import {
   Timetable,
@@ -18,8 +23,8 @@ export type OriginNode = { arrival: Time };
 
 export type VehicleEdge = {
   arrival: Time;
-  from: StopId;
-  to: StopId;
+  from: StopRouteIndex;
+  to: StopRouteIndex;
   routeId: RouteId;
   tripIndex: TripRouteIndex;
   continuationOf?: VehicleEdge;
@@ -96,10 +101,10 @@ export class Router {
       );
       markedStops.clear();
       // for each route that can be reached with at least round - 1 trips
-      for (const [route, hopOnStop] of reachableRoutes) {
+      for (const [route, hopOnStopIndex] of reachableRoutes) {
         const newlyMarkedStops = this.scanRoute(
           route,
-          hopOnStop,
+          hopOnStopIndex,
           round,
           routingState,
         );
@@ -118,7 +123,7 @@ export class Router {
           const route = this.timetable.getRoute(continuation.routeId)!;
           const routeScanResults = this.scanRoute(
             route,
-            continuation.hopOnStop,
+            continuation.hopOnStopIndex,
             round,
             routingState,
             continuation,
@@ -144,6 +149,7 @@ export class Router {
       for (const newStop of newlyMarkedStops) {
         markedStops.add(newStop);
       }
+
       if (markedStops.size === 0) break;
     }
     return new Result(query, routingState, this.stopsIndex, this.timetable);
@@ -165,7 +171,7 @@ export class Router {
       if (!arrival || !('routeId' in arrival)) continue;
 
       const continuousTrips = this.timetable.getContinuousTrips(
-        stopId,
+        arrival.to,
         arrival.routeId,
         arrival.tripIndex,
       );
@@ -173,7 +179,7 @@ export class Router {
         const trip = continuousTrips[i]!;
         continuations.push({
           routeId: trip.routeId,
-          hopOnStop: trip.hopOnStop,
+          hopOnStopIndex: trip.hopOnStopIndex,
           tripIndex: trip.tripIndex,
           previousEdge: arrival,
         });
@@ -232,13 +238,13 @@ export class Router {
    * are available if no given trip is provided as a parameter.
    *
    * @param route The route to scan for possible trips
-   * @param hopOnStop The stop ID where passengers can board the route
+   * @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,
-    hopOnStop: StopId,
+    hopOnStopIndex: StopRouteIndex,
     round: Round,
     routingState: RoutingState,
     tripContinuation?: TripContinuation,
@@ -247,26 +253,32 @@ export class Router {
     let activeTrip: TripBoarding | undefined = tripContinuation
       ? {
           routeId: route.id,
-          hopOnStop,
+          hopOnStopIndex,
           tripIndex: tripContinuation.tripIndex,
         }
       : undefined;
     const edgesAtCurrentRound = routingState.graph[round]!;
     const edgesAtPreviousRound = routingState.graph[round - 1]!;
-    const startIndex = route.stopRouteIndex(hopOnStop);
     // Compute target pruning criteria only once per route
     const earliestArrivalAtAnyDestination = this.earliestArrivalAtAnyStop(
       routingState.earliestArrivals,
       routingState.destinations,
     );
-    for (let j = startIndex; j < route.getNbStops(); j++) {
-      const currentStop = route.stops[j]!;
+    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(currentStop, activeTrip.tripIndex);
+        const arrivalTime = route.arrivalAt(
+          currentStopIndex,
+          activeTrip.tripIndex,
+        );
         const dropOffType = route.dropOffTypeAt(
-          currentStop,
+          currentStopIndex,
           activeTrip.tripIndex,
         );
         const earliestArrivalAtCurrentStop =
@@ -280,8 +292,8 @@ export class Router {
             arrival: arrivalTime,
             routeId: route.id,
             tripIndex: activeTrip.tripIndex,
-            from: activeTrip.hopOnStop,
-            to: currentStop,
+            from: activeTrip.hopOnStopIndex,
+            to: currentStopIndex,
           } as VehicleEdge;
           if (tripContinuation) {
             // In case of continuous trip, we set a pointer to the previous edge
@@ -312,14 +324,14 @@ export class Router {
         earliestArrivalOnPreviousRound !== undefined &&
         (activeTrip === undefined ||
           earliestArrivalOnPreviousRound.isBefore(
-            route.departureFrom(currentStop, activeTrip.tripIndex),
+            route.departureFrom(currentStopIndex, activeTrip.tripIndex),
           ) ||
           earliestArrivalOnPreviousRound.equals(
-            route.departureFrom(currentStop, activeTrip.tripIndex),
+            route.departureFrom(currentStopIndex, activeTrip.tripIndex),
           ))
       ) {
         const earliestTrip = route.findEarliestTrip(
-          currentStop,
+          currentStopIndex,
           earliestArrivalOnPreviousRound,
           activeTrip?.tripIndex,
         );
@@ -327,7 +339,7 @@ export class Router {
           activeTrip = {
             routeId: route.id,
             tripIndex: earliestTrip,
-            hopOnStop: currentStop,
+            hopOnStopIndex: currentStopIndex,
           };
         }
       }

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

@@ -15,6 +15,7 @@ import {
 import { REGULAR, Route } from '../route.js';
 import { Time } from '../time.js';
 import { ServiceRoute, StopAdjacency, TripBoarding } from '../timetable.js';
+import { encode } from '../tripBoardingId.js';
 
 describe('Timetable IO', () => {
   const stopsAdjacency: StopAdjacency[] = [
@@ -63,7 +64,6 @@ describe('Timetable IO', () => {
     {
       transfers: [{ destination: 2, type: 0 }],
       routes: [0],
-      tripContinuations: [],
     },
     {
       transfers: [
@@ -74,7 +74,6 @@ describe('Timetable IO', () => {
         },
       ],
       routes: [1],
-      tripContinuations: [],
     },
   ];
 
@@ -120,12 +119,14 @@ describe('Timetable IO', () => {
   });
 
   it('should serialize and deserialize tripContinuations correctly', () => {
-    const tripContinuations = new Map<number, TripBoarding[]>();
-    tripContinuations.set(0, [
-      { hopOnStop: 1, routeId: 0, tripIndex: 2 },
-      { hopOnStop: 3, routeId: 1, tripIndex: 1 },
+    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 },
     ]);
-    tripContinuations.set(1, [{ hopOnStop: 2, routeId: 0, tripIndex: 0 }]);
 
     const serialized = serializeTripContinuations(tripContinuations);
     const deserialized = deserializeTripContinuations(serialized);

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

@@ -95,34 +95,6 @@ describe('Route', () => {
     });
   });
 
-  describe('isBefore', () => {
-    it('should return true when stopA is before stopB', () => {
-      assert.strictEqual(route.isBefore(1001, 1002), true);
-    });
-
-    it('should return false when stopA is after stopB', () => {
-      assert.strictEqual(route.isBefore(1002, 1001), false);
-    });
-
-    it('should return false when stopA equals stopB', () => {
-      assert.strictEqual(route.isBefore(1001, 1001), false);
-    });
-
-    it('should throw error when stopA is not found', () => {
-      assert.throws(
-        () => route.isBefore(9999, 1002),
-        /Stop index not found for 9999 in route 0/,
-      );
-    });
-
-    it('should throw error when stopB is not found', () => {
-      assert.throws(
-        () => route.isBefore(1001, 9999),
-        /Stop index not found for 9999 in route 0/,
-      );
-    });
-  });
-
   describe('getNbStops', () => {
     it('should return correct number of stops', () => {
       assert.strictEqual(route.getNbStops(), 2);
@@ -136,178 +108,192 @@ describe('Route', () => {
   });
 
   describe('arrivalAt', () => {
-    it('should return correct arrival time for trip 0 at stop 1001', () => {
-      const arrival = route.arrivalAt(1001, 0);
+    it('should return correct arrival time for trip 0 at stop index 0', () => {
+      const arrival = route.arrivalAt(0, 0);
       assert.strictEqual(
         arrival.toMinutes(),
         Time.fromHMS(8, 0, 0).toMinutes(),
       );
     });
 
-    it('should return correct arrival time for trip 1 at stop 1002', () => {
-      const arrival = route.arrivalAt(1002, 1);
+    it('should return correct arrival time for trip 1 at stop index 1', () => {
+      const arrival = route.arrivalAt(1, 1);
       assert.strictEqual(
         arrival.toMinutes(),
         Time.fromHMS(9, 30, 0).toMinutes(),
       );
     });
 
-    it('should throw error for invalid stop ID', () => {
+    it('should throw error for invalid stop index', () => {
       assert.throws(
-        () => route.arrivalAt(9999, 0),
-        /Stop index for 9999 not found in route 0/,
+        () => route.arrivalAt(999, 0),
+        /StopId for stop at index 999 not found/,
       );
     });
 
     it('should throw error for invalid trip index', () => {
-      assert.throws(
-        () => route.arrivalAt(1001, 999),
-        /Arrival time not found for stop 1001 at trip index 999/,
-      );
+      assert.throws(() => route.arrivalAt(0, 999), /Arrival time not found/);
     });
   });
 
   describe('departureFrom', () => {
-    it('should return correct departure time for trip 0 at stop 1001', () => {
-      const departure = route.departureFrom(1001, 0);
+    it('should return correct departure time for trip 0 at stop index 0', () => {
+      const departure = route.departureFrom(0, 0);
       assert.strictEqual(
         departure.toMinutes(),
         Time.fromHMS(8, 1, 0).toMinutes(),
       );
     });
 
-    it('should return correct departure time for trip 2 at stop 1002', () => {
-      const departure = route.departureFrom(1002, 2);
+    it('should return correct departure time for trip 2 at stop index 1', () => {
+      const departure = route.departureFrom(1, 2);
       assert.strictEqual(
         departure.toMinutes(),
         Time.fromHMS(10, 31, 0).toMinutes(),
       );
     });
 
-    it('should throw error for invalid stop ID', () => {
+    it('should throw error for invalid stop index', () => {
       assert.throws(
-        () => route.departureFrom(9999, 0),
-        /Stop index for 9999 not found in route 0/,
+        () => route.departureFrom(999, 0),
+        /StopId for stop at index 999 not found/,
       );
     });
 
     it('should throw error for invalid trip index', () => {
       assert.throws(
-        () => route.departureFrom(1001, 999),
-        /Departure time not found for stop 1001 at trip index 999/,
+        () => route.departureFrom(0, 999),
+        /Departure time not found/,
       );
     });
   });
 
   describe('pickUpTypeFrom', () => {
-    it('should return REGULAR pickup type for trip 0 at stop 1001', () => {
-      const pickUpType = route.pickUpTypeFrom(1001, 0);
+    it('should return REGULAR pickup type for trip 0 at stop index 0', () => {
+      const pickUpType = route.pickUpTypeFrom(0, 0);
       assert.strictEqual(pickUpType, 'REGULAR');
     });
 
-    it('should return NOT_AVAILABLE pickup type for trip 0 at stop 1002', () => {
-      const pickUpType = route.pickUpTypeFrom(1002, 0);
+    it('should return NOT_AVAILABLE pickup type for trip 0 at stop index 1', () => {
+      const pickUpType = route.pickUpTypeFrom(1, 0);
       assert.strictEqual(pickUpType, 'NOT_AVAILABLE');
     });
 
-    it('should return MUST_PHONE_AGENCY pickup type for trip 2 at stop 1001', () => {
-      const pickUpType = route.pickUpTypeFrom(1001, 2);
+    it('should return MUST_PHONE_AGENCY pickup type for trip 2 at stop index 0', () => {
+      const pickUpType = route.pickUpTypeFrom(0, 2);
       assert.strictEqual(pickUpType, 'MUST_PHONE_AGENCY');
     });
 
-    it('should throw error for invalid stop ID', () => {
+    it('should throw error for invalid stop index', () => {
       assert.throws(
-        () => route.pickUpTypeFrom(9999, 0),
-        /Stop index for 9999 not found in route 0/,
+        () => route.pickUpTypeFrom(999, 0),
+        /StopId for stop at index 999 not found/,
       );
     });
 
     it('should throw error for invalid trip index', () => {
       assert.throws(
-        () => route.pickUpTypeFrom(1001, 999),
-        /Pick up type not found for stop 1001 at trip index 999/,
+        () => route.pickUpTypeFrom(0, 999),
+        /Pick up type not found/,
       );
     });
   });
 
   describe('dropOffTypeAt', () => {
-    it('should return REGULAR drop off type for trip 0 at stop 1001', () => {
-      const dropOffType = route.dropOffTypeAt(1001, 0);
+    it('should return REGULAR drop off type for trip 0 at stop index 0', () => {
+      const dropOffType = route.dropOffTypeAt(0, 0);
       assert.strictEqual(dropOffType, 'REGULAR');
     });
 
-    it('should return REGULAR drop off type for trip 1 at stop 1002', () => {
-      const dropOffType = route.dropOffTypeAt(1002, 1);
+    it('should return REGULAR drop off type for trip 1 at stop index 1', () => {
+      const dropOffType = route.dropOffTypeAt(1, 1);
       assert.strictEqual(dropOffType, 'REGULAR');
     });
 
-    it('should throw error for invalid stop ID', () => {
+    it('should throw error for invalid stop index', () => {
       assert.throws(
-        () => route.dropOffTypeAt(9999, 0),
-        /Stop index for 9999 not found in route 0/,
+        () => route.dropOffTypeAt(999, 0),
+        /StopId for stop at index 999 not found/,
       );
     });
 
     it('should throw error for invalid trip index', () => {
       assert.throws(
-        () => route.dropOffTypeAt(1001, 999),
-        /Drop off type not found for stop 1001 at trip index 999/,
+        () => route.dropOffTypeAt(0, 999),
+        /Drop off type not found/,
       );
     });
   });
 
   describe('findEarliestTrip', () => {
     it('should find earliest trip without time constraint', () => {
-      const tripIndex = route.findEarliestTrip(1001);
+      const tripIndex = route.findEarliestTrip(0);
       assert.strictEqual(tripIndex, 0);
     });
 
     it('should find earliest trip after specified time', () => {
       const afterTime = Time.fromHMS(8, 30, 0);
-      const tripIndex = route.findEarliestTrip(1001, afterTime);
+      const tripIndex = route.findEarliestTrip(0, afterTime);
       assert.strictEqual(tripIndex, 1);
     });
 
     it('should find earliest trip with exact match time', () => {
       const afterTime = Time.fromHMS(9, 1, 0);
-      const tripIndex = route.findEarliestTrip(1001, afterTime);
+      const tripIndex = route.findEarliestTrip(0, afterTime);
       assert.strictEqual(tripIndex, 1);
     });
 
     it('should return undefined when no trip is available after specified time', () => {
       const afterTime = Time.fromHMS(23, 0, 0);
-      const tripIndex = route.findEarliestTrip(1001, afterTime);
+      const tripIndex = route.findEarliestTrip(0, afterTime);
       assert.strictEqual(tripIndex, undefined);
     });
 
     it('should skip trips where pickup is not available', () => {
-      const tripIndex = route.findEarliestTrip(1002);
-      // Trip 0 has NOT_AVAILABLE pickup at stop 1002, so should return trip 1
+      const tripIndex = route.findEarliestTrip(1);
+      // Trip 0 has NOT_AVAILABLE pickup at stop index 1, so should return trip 1
       assert.strictEqual(tripIndex, 1);
     });
 
     it('should respect beforeTrip constraint', () => {
-      const tripIndex = route.findEarliestTrip(1001, Time.fromHMS(8, 2, 0), 1);
+      const tripIndex = route.findEarliestTrip(0, Time.fromHMS(8, 2, 0), 1);
       assert.strictEqual(tripIndex, undefined);
     });
 
     it('should return undefined when beforeTrip is 0', () => {
-      const tripIndex = route.findEarliestTrip(1001, Time.origin(), 0);
+      const tripIndex = route.findEarliestTrip(0, Time.origin(), 0);
       assert.strictEqual(tripIndex, undefined);
     });
 
     it('should handle MUST_PHONE_AGENCY pickup type', () => {
       const afterTime = Time.fromHMS(9, 30, 0);
-      const tripIndex = route.findEarliestTrip(1001, afterTime);
+      const tripIndex = route.findEarliestTrip(0, afterTime);
       // Should find trip 2 even though it requires phone agency
       assert.strictEqual(tripIndex, 2);
     });
 
-    it('should throw error for invalid stop ID', () => {
+    it('should throw error for invalid stop index', () => {
       assert.throws(
-        () => route.findEarliestTrip(9999),
-        /Stop index for 9999 not found in route 0/,
+        () => route.findEarliestTrip(999),
+        /StopId for stop at index 999 not found/,
       );
     });
   });
+
+  describe('stopRouteIndices', () => {
+    it('should return correct stop route indices for existing stop', () => {
+      const indices = route.stopRouteIndices(1001);
+      assert.deepStrictEqual(indices, [0]);
+    });
+
+    it('should return correct stop route indices for second stop', () => {
+      const indices = route.stopRouteIndices(1002);
+      assert.deepStrictEqual(indices, [1]);
+    });
+
+    it('should return empty array for non-existent stop', () => {
+      const indices = route.stopRouteIndices(9999);
+      assert.deepStrictEqual(indices, []);
+    });
+  });
 });

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

@@ -11,7 +11,7 @@ import {
   Timetable,
   TripBoarding,
 } from '../timetable.js';
-import { encode } from '../tripId.js';
+import { encode } from '../tripBoardingId.js';
 
 describe('Timetable', () => {
   const stopsAdjacency: StopAdjacency[] = [
@@ -100,6 +100,7 @@ describe('Timetable', () => {
     stopsAdjacency,
     routesAdjacency,
     routes,
+    new Map(),
   );
 
   it('should serialize a timetable to a Uint8Array', () => {
@@ -116,7 +117,7 @@ describe('Timetable', () => {
   it('should find the earliest trip for stop1 on route1', () => {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const route = sampleTimetable.getRoute(0)!;
-    const tripIndex = route.findEarliestTrip(1);
+    const tripIndex = route.findEarliestTrip(0);
     assert.strictEqual(tripIndex, 0);
   });
 
@@ -124,7 +125,7 @@ describe('Timetable', () => {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const route = sampleTimetable.getRoute(0)!;
     const afterTime = Time.fromHMS(17, 0, 0);
-    const tripIndex = route.findEarliestTrip(1, afterTime);
+    const tripIndex = route.findEarliestTrip(0, afterTime);
     assert.strictEqual(tripIndex, 1);
   });
 
@@ -132,13 +133,13 @@ describe('Timetable', () => {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const route = sampleTimetable.getRoute(0)!;
     const afterTime = Time.fromHMS(23, 40, 0);
-    const tripIndex = route.findEarliestTrip(1, afterTime);
+    const tripIndex = route.findEarliestTrip(0, afterTime);
     assert.strictEqual(tripIndex, undefined);
   });
   it('should return undefined if the stop on a trip has pick up not available', () => {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const route = sampleTimetable.getRoute(0)!;
-    const tripIndex = route.findEarliestTrip(2);
+    const tripIndex = route.findEarliestTrip(1);
     assert.strictEqual(tripIndex, 1);
   });
   describe('findReachableRoutes', () => {
@@ -149,7 +150,7 @@ describe('Timetable', () => {
       assert.deepStrictEqual(
         reachableRoutes,
         new Map([
-          [route1, 1],
+          [route1, 0],
           [route2, 1],
         ]),
       );
@@ -163,8 +164,8 @@ describe('Timetable', () => {
       assert.deepStrictEqual(
         reachableRoutes,
         new Map([
-          [route1, 1],
-          [route2, 2],
+          [route1, 0],
+          [route2, 0],
         ]),
       );
     });
@@ -201,7 +202,7 @@ describe('Timetable', () => {
       assert.deepStrictEqual(
         railRoutes,
         new Map([
-          [route1, 1],
+          [route1, 0],
           [route2, 1],
         ]),
       );
@@ -226,33 +227,34 @@ describe('Timetable', () => {
       const fromStops = new Set([1, 2]); // Both stops are on route1
       const reachableRoutes = sampleTimetable.findReachableRoutes(fromStops);
 
-      // route1 should use stop 1 (earlier on the route than stop 2)
-      // route2 should use stop 2 (earlier on route2 which has [2, 1])
+      // route1 should use stop index 0 (stop 1 comes before stop 2 on route1)
+      // route2 should use stop index 0 (stop 2 comes before stop 1 on route2)
       assert.strictEqual(reachableRoutes.size, 2);
       assert.deepStrictEqual(
         reachableRoutes,
         new Map([
-          [route1, 1], // Stop 1 comes before stop 2 on route1
-          [route2, 2], // Stop 2 comes before stop 1 on route2
+          [route1, 0], // Stop index 0 (stop 1) comes before stop index 1 (stop 2) on route1
+          [route2, 0], // Stop index 0 (stop 2) comes before stop index 1 (stop 1) on route2
         ]),
       );
     });
 
     describe('getContinuousTrips', () => {
       it('should return empty array when stop has no trip continuations', () => {
-        const continuousTrips = sampleTimetable.getContinuousTrips(1, 0, 0);
+        const continuousTrips = sampleTimetable.getContinuousTrips(0, 0, 0);
         assert.deepStrictEqual(continuousTrips, []);
       });
 
       it('should return empty array when stop has trip continuations but not for the specified trip', () => {
         // Create a timetable with trip continuations that don't match the query
+        const tripContinuationsMap = new Map([
+          [encode(0, 0, 1), [{ hopOnStopIndex: 0, routeId: 1, tripIndex: 0 }]], // Different trip index
+        ]);
+
         const stopsWithContinuations: StopAdjacency[] = [
           { routes: [] },
           {
             routes: [0, 1],
-            tripContinuations: new Map([
-              [encode(0, 1), [{ hopOnStop: 2, routeId: 1, tripIndex: 0 }]], // Different trip index
-            ]),
           },
           { routes: [1] },
         ];
@@ -261,10 +263,11 @@ describe('Timetable', () => {
           stopsWithContinuations,
           routesAdjacency,
           routes,
+          tripContinuationsMap,
         );
 
         const continuousTrips = timetableWithContinuations.getContinuousTrips(
-          1,
+          0,
           0,
           0,
         ); // Query trip index 0, but continuations are for trip index 1
@@ -273,17 +276,18 @@ describe('Timetable', () => {
 
       it('should return trip continuations when they exist for the specified trip', () => {
         const expectedContinuations: TripBoarding[] = [
-          { hopOnStop: 2, routeId: 1, tripIndex: 0 },
-          { hopOnStop: 2, routeId: 1, tripIndex: 1 },
+          { hopOnStopIndex: 0, routeId: 1, tripIndex: 0 },
+          { hopOnStopIndex: 0, routeId: 1, tripIndex: 1 },
         ];
 
+        const tripContinuationsMap = new Map([
+          [encode(0, 0, 0), expectedContinuations],
+        ]);
+
         const stopsWithContinuations: StopAdjacency[] = [
           { routes: [] },
           {
             routes: [0, 1],
-            tripContinuations: new Map([
-              [encode(0, 0), expectedContinuations], // Trip continuations for route 0, trip 0
-            ]),
           },
           { routes: [1] },
         ];
@@ -292,21 +296,20 @@ describe('Timetable', () => {
           stopsWithContinuations,
           routesAdjacency,
           routes,
+          tripContinuationsMap,
         );
 
         const continuousTrips = timetableWithContinuations.getContinuousTrips(
-          1,
+          0,
           0,
           0,
         );
         assert.deepStrictEqual(continuousTrips, expectedContinuations);
       });
 
-      it('should throw error when querying non-existent stop', () => {
-        assert.throws(
-          () => sampleTimetable.getContinuousTrips(999, 0, 0),
-          /Stop ID 999 not found/,
-        );
+      it('should return empty array when querying with non-matching parameters', () => {
+        const continuousTrips = sampleTimetable.getContinuousTrips(999, 0, 0);
+        assert.deepStrictEqual(continuousTrips, []);
       });
     });
   });