minotor 8.0.0 → 9.0.1

package/dist/parser.cjs.js

@@ -12297,12 +12297,12 @@ const Transfer = {
     },
 };
 function createBaseTripBoarding() {
-    return { hopOnStop: 0, routeId: 0, tripIndex: 0 };
+    return { hopOnStopIndex: 0, routeId: 0, tripIndex: 0 };
 }
 const TripBoarding = {
     encode(message, writer = new BinaryWriter()) {
-        if (message.hopOnStop !== 0) {
-            writer.uint32(8).uint32(message.hopOnStop);
+        if (message.hopOnStopIndex !== 0) {
+            writer.uint32(8).uint32(message.hopOnStopIndex);
         }
         if (message.routeId !== 0) {
             writer.uint32(16).uint32(message.routeId);
@@ -12323,7 +12323,7 @@ const TripBoarding = {
                     if (tag !== 8) {
                         break;
                     }
-                    message.hopOnStop = reader.uint32();
+                    message.hopOnStopIndex = reader.uint32();
                     continue;
                 }
                 case 2: {
@@ -12350,15 +12350,15 @@ const TripBoarding = {
     },
     fromJSON(object) {
         return {
-            hopOnStop: isSet(object.hopOnStop) ? globalThis.Number(object.hopOnStop) : 0,
+            hopOnStopIndex: isSet(object.hopOnStopIndex) ? globalThis.Number(object.hopOnStopIndex) : 0,
             routeId: isSet(object.routeId) ? globalThis.Number(object.routeId) : 0,
             tripIndex: isSet(object.tripIndex) ? globalThis.Number(object.tripIndex) : 0,
         };
     },
     toJSON(message) {
         const obj = {};
-        if (message.hopOnStop !== 0) {
-            obj.hopOnStop = Math.round(message.hopOnStop);
+        if (message.hopOnStopIndex !== 0) {
+            obj.hopOnStopIndex = Math.round(message.hopOnStopIndex);
         }
         if (message.routeId !== 0) {
             obj.routeId = Math.round(message.routeId);
@@ -12374,22 +12374,28 @@ const TripBoarding = {
     fromPartial(object) {
         var _a, _b, _c;
         const message = createBaseTripBoarding();
-        message.hopOnStop = (_a = object.hopOnStop) !== null && _a !== void 0 ? _a : 0;
+        message.hopOnStopIndex = (_a = object.hopOnStopIndex) !== null && _a !== void 0 ? _a : 0;
         message.routeId = (_b = object.routeId) !== null && _b !== void 0 ? _b : 0;
         message.tripIndex = (_c = object.tripIndex) !== null && _c !== void 0 ? _c : 0;
         return message;
     },
 };
 function createBaseTripContinuationEntry() {
-    return { key: 0, value: [] };
+    return { originStopIndex: 0, originRouteId: 0, originTripIndex: 0, continuations: [] };
 }
 const TripContinuationEntry = {
     encode(message, writer = new BinaryWriter()) {
-        if (message.key !== 0) {
-            writer.uint32(8).uint32(message.key);
+        if (message.originStopIndex !== 0) {
+            writer.uint32(8).uint32(message.originStopIndex);
         }
-        for (const v of message.value) {
-            TripBoarding.encode(v, writer.uint32(18).fork()).join();
+        if (message.originRouteId !== 0) {
+            writer.uint32(16).uint32(message.originRouteId);
+        }
+        if (message.originTripIndex !== 0) {
+            writer.uint32(24).uint32(message.originTripIndex);
+        }
+        for (const v of message.continuations) {
+            TripBoarding.encode(v, writer.uint32(34).fork()).join();
         }
         return writer;
     },
@@ -12404,14 +12410,28 @@ const TripContinuationEntry = {
                     if (tag !== 8) {
                         break;
                     }
-                    message.key = reader.uint32();
+                    message.originStopIndex = reader.uint32();
                     continue;
                 }
                 case 2: {
-                    if (tag !== 18) {
+                    if (tag !== 16) {
                         break;
                     }
-                    message.value.push(TripBoarding.decode(reader, reader.uint32()));
+                    message.originRouteId = reader.uint32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.originTripIndex = reader.uint32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.continuations.push(TripBoarding.decode(reader, reader.uint32()));
                     continue;
                 }
             }
@@ -12424,18 +12444,28 @@ const TripContinuationEntry = {
     },
     fromJSON(object) {
         return {
-            key: isSet(object.key) ? globalThis.Number(object.key) : 0,
-            value: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.value) ? object.value.map((e) => TripBoarding.fromJSON(e)) : [],
+            originStopIndex: isSet(object.originStopIndex) ? globalThis.Number(object.originStopIndex) : 0,
+            originRouteId: isSet(object.originRouteId) ? globalThis.Number(object.originRouteId) : 0,
+            originTripIndex: isSet(object.originTripIndex) ? globalThis.Number(object.originTripIndex) : 0,
+            continuations: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.continuations)
+                ? object.continuations.map((e) => TripBoarding.fromJSON(e))
+                : [],
         };
     },
     toJSON(message) {
         var _a;
         const obj = {};
-        if (message.key !== 0) {
-            obj.key = Math.round(message.key);
+        if (message.originStopIndex !== 0) {
+            obj.originStopIndex = Math.round(message.originStopIndex);
         }
-        if ((_a = message.value) === null || _a === void 0 ? void 0 : _a.length) {
-            obj.value = message.value.map((e) => TripBoarding.toJSON(e));
+        if (message.originRouteId !== 0) {
+            obj.originRouteId = Math.round(message.originRouteId);
+        }
+        if (message.originTripIndex !== 0) {
+            obj.originTripIndex = Math.round(message.originTripIndex);
+        }
+        if ((_a = message.continuations) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.continuations = message.continuations.map((e) => TripBoarding.toJSON(e));
         }
         return obj;
     },
@@ -12443,15 +12473,17 @@ const TripContinuationEntry = {
         return TripContinuationEntry.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const message = createBaseTripContinuationEntry();
-        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : 0;
-        message.value = ((_b = object.value) === null || _b === void 0 ? void 0 : _b.map((e) => TripBoarding.fromPartial(e))) || [];
+        message.originStopIndex = (_a = object.originStopIndex) !== null && _a !== void 0 ? _a : 0;
+        message.originRouteId = (_b = object.originRouteId) !== null && _b !== void 0 ? _b : 0;
+        message.originTripIndex = (_c = object.originTripIndex) !== null && _c !== void 0 ? _c : 0;
+        message.continuations = ((_d = object.continuations) === null || _d === void 0 ? void 0 : _d.map((e) => TripBoarding.fromPartial(e))) || [];
         return message;
     },
 };
 function createBaseStopAdjacency() {
-    return { routes: [], transfers: [], tripContinuations: [] };
+    return { routes: [], transfers: [] };
 }
 const StopAdjacency = {
     encode(message, writer = new BinaryWriter()) {
@@ -12463,9 +12495,6 @@ const StopAdjacency = {
         for (const v of message.transfers) {
             Transfer.encode(v, writer.uint32(18).fork()).join();
         }
-        for (const v of message.tripContinuations) {
-            TripContinuationEntry.encode(v, writer.uint32(26).fork()).join();
-        }
         return writer;
     },
     decode(input, length) {
@@ -12496,13 +12525,6 @@ const StopAdjacency = {
                     message.transfers.push(Transfer.decode(reader, reader.uint32()));
                     continue;
                 }
-                case 3: {
-                    if (tag !== 26) {
-                        break;
-                    }
-                    message.tripContinuations.push(TripContinuationEntry.decode(reader, reader.uint32()));
-                    continue;
-                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -12517,13 +12539,10 @@ const StopAdjacency = {
             transfers: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.transfers)
                 ? object.transfers.map((e) => Transfer.fromJSON(e))
                 : [],
-            tripContinuations: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.tripContinuations)
-                ? object.tripContinuations.map((e) => TripContinuationEntry.fromJSON(e))
-                : [],
         };
     },
     toJSON(message) {
-        var _a, _b, _c;
+        var _a, _b;
         const obj = {};
         if ((_a = message.routes) === null || _a === void 0 ? void 0 : _a.length) {
             obj.routes = message.routes.map((e) => Math.round(e));
@@ -12531,20 +12550,16 @@ const StopAdjacency = {
         if ((_b = message.transfers) === null || _b === void 0 ? void 0 : _b.length) {
             obj.transfers = message.transfers.map((e) => Transfer.toJSON(e));
         }
-        if ((_c = message.tripContinuations) === null || _c === void 0 ? void 0 : _c.length) {
-            obj.tripContinuations = message.tripContinuations.map((e) => TripContinuationEntry.toJSON(e));
-        }
         return obj;
     },
     create(base) {
         return StopAdjacency.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b, _c;
+        var _a, _b;
         const message = createBaseStopAdjacency();
         message.routes = ((_a = object.routes) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
         message.transfers = ((_b = object.transfers) === null || _b === void 0 ? void 0 : _b.map((e) => Transfer.fromPartial(e))) || [];
-        message.tripContinuations = ((_c = object.tripContinuations) === null || _c === void 0 ? void 0 : _c.map((e) => TripContinuationEntry.fromPartial(e))) || [];
         return message;
     },
 };
@@ -12643,7 +12658,7 @@ const ServiceRoute = {
     },
 };
 function createBaseTimetable() {
-    return { version: "", stopsAdjacency: [], routesAdjacency: [], serviceRoutes: [] };
+    return { version: "", stopsAdjacency: [], routesAdjacency: [], serviceRoutes: [], tripContinuations: [] };
 }
 const Timetable$1 = {
     encode(message, writer = new BinaryWriter()) {
@@ -12659,6 +12674,9 @@ const Timetable$1 = {
         for (const v of message.serviceRoutes) {
             ServiceRoute.encode(v, writer.uint32(34).fork()).join();
         }
+        for (const v of message.tripContinuations) {
+            TripContinuationEntry.encode(v, writer.uint32(42).fork()).join();
+        }
         return writer;
     },
     decode(input, length) {
@@ -12696,6 +12714,13 @@ const Timetable$1 = {
                     message.serviceRoutes.push(ServiceRoute.decode(reader, reader.uint32()));
                     continue;
                 }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.tripContinuations.push(TripContinuationEntry.decode(reader, reader.uint32()));
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -12716,10 +12741,13 @@ const Timetable$1 = {
             serviceRoutes: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.serviceRoutes)
                 ? object.serviceRoutes.map((e) => ServiceRoute.fromJSON(e))
                 : [],
+            tripContinuations: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.tripContinuations)
+                ? object.tripContinuations.map((e) => TripContinuationEntry.fromJSON(e))
+                : [],
         };
     },
     toJSON(message) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const obj = {};
         if (message.version !== "") {
             obj.version = message.version;
@@ -12733,18 +12761,22 @@ const Timetable$1 = {
         if ((_c = message.serviceRoutes) === null || _c === void 0 ? void 0 : _c.length) {
             obj.serviceRoutes = message.serviceRoutes.map((e) => ServiceRoute.toJSON(e));
         }
+        if ((_d = message.tripContinuations) === null || _d === void 0 ? void 0 : _d.length) {
+            obj.tripContinuations = message.tripContinuations.map((e) => TripContinuationEntry.toJSON(e));
+        }
         return obj;
     },
     create(base) {
         return Timetable$1.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         const message = createBaseTimetable();
         message.version = (_a = object.version) !== null && _a !== void 0 ? _a : "";
         message.stopsAdjacency = ((_b = object.stopsAdjacency) === null || _b === void 0 ? void 0 : _b.map((e) => StopAdjacency.fromPartial(e))) || [];
         message.routesAdjacency = ((_c = object.routesAdjacency) === null || _c === void 0 ? void 0 : _c.map((e) => Route$1.fromPartial(e))) || [];
         message.serviceRoutes = ((_d = object.serviceRoutes) === null || _d === void 0 ? void 0 : _d.map((e) => ServiceRoute.fromPartial(e))) || [];
+        message.tripContinuations = ((_e = object.tripContinuations) === null || _e === void 0 ? void 0 : _e.map((e) => TripContinuationEntry.fromPartial(e))) || [];
         return message;
     },
 };
@@ -13044,7 +13076,14 @@ class Route {
         this.stopIndices = new Map();
         for (let i = 0; i < stops.length; i++) {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            this.stopIndices.set(stops[i], i);
+            const stopId = stops[i];
+            const existingIndices = this.stopIndices.get(stopId);
+            if (existingIndices) {
+                existingIndices.push(i);
+            }
+            else {
+                this.stopIndices.set(stopId, [i]);
+            }
         }
     }
     /**
@@ -13132,24 +13171,6 @@ class Route {
             serviceRouteId: this.serviceRouteId,
         };
     }
-    /**
-     * Checks if stop A is before stop B in the route.
-     *
-     * @param stopA - The StopId of the first stop.
-     * @param stopB - The StopId of the second stop.
-     * @returns True if stop A is before stop B, false otherwise.
-     */
-    isBefore(stopA, stopB) {
-        const stopAIndex = this.stopIndices.get(stopA);
-        if (stopAIndex === undefined) {
-            throw new Error(`Stop index not found for ${stopA} in route ${this.serviceRouteId}`);
-        }
-        const stopBIndex = this.stopIndices.get(stopB);
-        if (stopBIndex === undefined) {
-            throw new Error(`Stop index not found for ${stopB} in route ${this.serviceRouteId}`);
-        }
-        return stopAIndex < stopBIndex;
-    }
     /**
      * Retrieves the number of stops in the route.
      *
@@ -13178,47 +13199,47 @@ class Route {
     /**
      * Retrieves the arrival time at a specific stop for a given trip.
      *
-     * @param stopId - The identifier of the stop.
+     * @param stopIndex - The index of the stop in the route.
      * @param tripIndex - The index of the trip.
      * @returns The arrival time at the specified stop and trip as a Time object.
      */
-    arrivalAt(stopId, tripIndex) {
-        const arrivalIndex = (tripIndex * this.stops.length + this.stopRouteIndex(stopId)) * 2;
+    arrivalAt(stopIndex, tripIndex) {
+        const arrivalIndex = (tripIndex * this.stops.length + stopIndex) * 2;
         const arrival = this.stopTimes[arrivalIndex];
         if (arrival === undefined) {
-            throw new Error(`Arrival time not found for stop ${stopId} at trip index ${tripIndex} in route ${this.serviceRouteId}`);
+            throw new Error(`Arrival time not found for stop ${this.stopId(stopIndex)} (${stopIndex}) at trip index ${tripIndex} in route ${this.serviceRouteId}`);
         }
         return Time.fromMinutes(arrival);
     }
     /**
      * Retrieves the departure time at a specific stop for a given trip.
      *
-     * @param stopId - The identifier of the stop.
+     * @param stopIndex - The index of the stop in the route.
      * @param tripIndex - The index of the trip.
      * @returns The departure time at the specified stop and trip as a Time object.
      */
-    departureFrom(stopId, tripIndex) {
-        const departureIndex = (tripIndex * this.stops.length + this.stopRouteIndex(stopId)) * 2 + 1;
+    departureFrom(stopIndex, tripIndex) {
+        const departureIndex = (tripIndex * this.stops.length + stopIndex) * 2 + 1;
         const departure = this.stopTimes[departureIndex];
         if (departure === undefined) {
-            throw new Error(`Departure time not found for stop ${stopId} at trip index ${tripIndex} in route ${this.serviceRouteId}`);
+            throw new Error(`Departure time not found for stop ${this.stopId(stopIndex)} (${stopIndex}) at trip index ${tripIndex} in route ${this.serviceRouteId}`);
         }
         return Time.fromMinutes(departure);
     }
     /**
      * Retrieves the pick-up type for a specific stop and trip.
      *
-     * @param stopId - The identifier of the stop.
+     * @param stopIndex - The index of the stop in the route.
      * @param tripIndex - The index of the trip.
      * @returns The pick-up type at the specified stop and trip.
      */
-    pickUpTypeFrom(stopId, tripIndex) {
-        const globalIndex = tripIndex * this.stops.length + this.stopRouteIndex(stopId);
+    pickUpTypeFrom(stopIndex, tripIndex) {
+        const globalIndex = tripIndex * this.stops.length + stopIndex;
         const byteIndex = Math.floor(globalIndex / 2);
         const isSecondPair = globalIndex % 2 === 1;
         const byte = this.pickUpDropOffTypes[byteIndex];
         if (byte === undefined) {
-            throw new Error(`Pick up type not found for stop ${stopId} at trip index ${tripIndex} in route ${this.serviceRouteId}`);
+            throw new Error(`Pick up type not found for stop ${this.stopId(stopIndex)} (${stopIndex}) at trip index ${tripIndex} in route ${this.serviceRouteId}`);
         }
         const pickUpValue = isSecondPair
             ? (byte >> 6) & 0x03 // Upper 2 bits for second pair
@@ -13228,17 +13249,17 @@ class Route {
     /**
      * Retrieves the drop-off type for a specific stop and trip.
      *
-     * @param stopId - The identifier of the stop.
+     * @param stopIndex - The index of the stop in the route.
      * @param tripIndex - The index of the trip.
      * @returns The drop-off type at the specified stop and trip.
      */
-    dropOffTypeAt(stopId, tripIndex) {
-        const globalIndex = tripIndex * this.stops.length + this.stopRouteIndex(stopId);
+    dropOffTypeAt(stopIndex, tripIndex) {
+        const globalIndex = tripIndex * this.stops.length + stopIndex;
         const byteIndex = Math.floor(globalIndex / 2);
         const isSecondPair = globalIndex % 2 === 1;
         const byte = this.pickUpDropOffTypes[byteIndex];
         if (byte === undefined) {
-            throw new Error(`Drop off type not found for stop ${stopId} at trip index ${tripIndex} in route ${this.serviceRouteId}`);
+            throw new Error(`Drop off type not found for stop ${this.stopId(stopIndex)} (${stopIndex}) at trip index ${tripIndex} in route ${this.serviceRouteId}`);
         }
         const dropOffValue = isSecondPair
             ? (byte >> 4) & 0x03 // Bits 4-5 for second pair
@@ -13250,14 +13271,14 @@ class Route {
      * optionally constrained by a latest trip index and a time before which the trip
      * should not depart.
      * *
-     * @param stopId - The StopId of the stop where the trip should be found.
+     * @param stopIndex - The route index of the stop where the trip should be found.
      * @param [after=Time.origin()] - The earliest time after which the trip should depart.
      *                                    If not provided, searches all available trips.
      * @param [beforeTrip] - (Optional) The index of the trip before which the search should be constrained.
      *                                   If not provided, searches all available trips.
      * @returns The index of the earliest trip meeting the criteria, or undefined if no such trip is found.
      */
-    findEarliestTrip(stopId, after = Time.origin(), beforeTrip) {
+    findEarliestTrip(stopIndex, after = Time.origin(), beforeTrip) {
         if (this.nbTrips <= 0)
             return undefined;
         let hi = this.nbTrips - 1;
@@ -13269,7 +13290,7 @@ class Route {
         let lb = -1;
         while (lo <= hi) {
             const mid = (lo + hi) >>> 1;
-            const depMid = this.departureFrom(stopId, mid);
+            const depMid = this.departureFrom(stopIndex, mid);
             if (depMid.isBefore(after)) {
                 lo = mid + 1;
             }
@@ -13281,7 +13302,7 @@ class Route {
         if (lb === -1)
             return undefined;
         for (let t = lb; t < (beforeTrip !== null && beforeTrip !== void 0 ? beforeTrip : this.nbTrips); t++) {
-            const pickup = this.pickUpTypeFrom(stopId, t);
+            const pickup = this.pickUpTypeFrom(stopIndex, t);
             if (pickup !== 'NOT_AVAILABLE') {
                 return t;
             }
@@ -13289,14 +13310,14 @@ class Route {
         return undefined;
     }
     /**
-     * Retrieves the index of a stop within the route.
+     * Retrieves the indices of a stop within the route.
      * @param stopId The StopId of the stop to locate in the route.
-     * @returns The index of the stop in the route.
+     * @returns An array of indices where the stop appears in the route, or an empty array if the stop is not found.
      */
-    stopRouteIndex(stopId) {
+    stopRouteIndices(stopId) {
         const stopIndex = this.stopIndices.get(stopId);
         if (stopIndex === undefined) {
-            throw new Error(`Stop index for ${stopId} not found in route ${this.serviceRouteId}`);
+            return [];
         }
         return stopIndex;
     }
@@ -13314,6 +13335,51 @@ class Route {
     }
 }
 
+// Each value uses 20 bits, allowing values from 0 to 1,048,575 (2^20 - 1)
+const VALUE_MASK = (BigInt(1) << BigInt(20)) - BigInt(1); // 0xFFFFF
+const MAX_VALUE = 1048575; // 2^20 - 1
+// Bit positions for each value in the 60-bit bigint
+const TRIP_INDEX_SHIFT = BigInt(0);
+const ROUTE_ID_SHIFT = BigInt(20);
+const STOP_INDEX_SHIFT = BigInt(40);
+/**
+ * Validates that a value fits within 20 bits (0 to 1,048,575)
+ * @param value - The value to validate
+ * @param name - The name of the value for error reporting
+ * @throws Error if the value is out of range
+ */
+const validateValue = (value, name) => {
+    if (value < 0 || value > MAX_VALUE) {
+        throw new Error(`${name} must be between 0 and ${MAX_VALUE}, got ${value}`);
+    }
+};
+/**
+ * Encodes a stop index, route ID, and trip index into a single trip boarding ID.
+ * @param stopIndex - The index of the stop within the route (0 to 1,048,575)
+ * @param routeId - The route identifier (0 to 1,048,575)
+ * @param tripIndex - The index of the trip within the route (0 to 1,048,575)
+ * @returns The encoded trip ID as a bigint
+ */
+const encode = (stopIndex, routeId, tripIndex) => {
+    validateValue(stopIndex, 'stopIndex');
+    validateValue(routeId, 'routeId');
+    validateValue(tripIndex, 'tripIndex');
+    return ((BigInt(stopIndex) << STOP_INDEX_SHIFT) |
+        (BigInt(routeId) << ROUTE_ID_SHIFT) |
+        (BigInt(tripIndex) << TRIP_INDEX_SHIFT));
+};
+/**
+ * Decodes a trip boarding ID back into its constituent stop index, route ID, and trip index.
+ * @param tripBoardingId - The encoded trip ID
+ * @returns A tuple containing [stopIndex, routeId, tripIndex]
+ */
+const decode = (tripBoardingId) => {
+    const stopIndex = Number((tripBoardingId >> STOP_INDEX_SHIFT) & VALUE_MASK);
+    const routeId = Number((tripBoardingId >> ROUTE_ID_SHIFT) & VALUE_MASK);
+    const tripIndex = Number((tripBoardingId >> TRIP_INDEX_SHIFT) & VALUE_MASK);
+    return [stopIndex, routeId, tripIndex];
+};
+
 const isLittleEndian = (() => {
     const buffer = new ArrayBuffer(4);
     const view = new DataView(buffer);
@@ -13388,9 +13454,6 @@ const serializeStopsAdjacency = (stopsAdjacency) => {
                 }))))
                 : [],
             routes: value.routes,
-            tripContinuations: value.tripContinuations
-                ? serializeTripContinuations(value.tripContinuations)
-                : [],
         };
     });
 };
@@ -13436,10 +13499,6 @@ const deserializeStopsAdjacency = (protoStopsAdjacency) => {
         if (transfers.length > 0) {
             stopAdjacency.transfers = transfers;
         }
-        const deserializedTripContinuations = deserializeTripContinuations(value.tripContinuations);
-        if (deserializedTripContinuations.size > 0) {
-            stopAdjacency.tripContinuations = deserializedTripContinuations;
-        }
         result.push(stopAdjacency);
     }
     return result;
@@ -13546,11 +13605,14 @@ const serializeRouteType = (type) => {
 };
 const serializeTripContinuations = (tripContinuations) => {
     const result = [];
-    for (const [key, value] of tripContinuations.entries()) {
+    for (const [tripBoardingId, boardings] of tripContinuations.entries()) {
+        const [originStopIndex, originRouteId, originTripIndex] = decode(tripBoardingId);
         result.push({
-            key: key,
-            value: value.map((tripBoarding) => ({
-                hopOnStop: tripBoarding.hopOnStop,
+            originStopIndex,
+            originRouteId,
+            originTripIndex,
+            continuations: boardings.map((tripBoarding) => ({
+                hopOnStopIndex: tripBoarding.hopOnStopIndex,
                 routeId: tripBoarding.routeId,
                 tripIndex: tripBoarding.tripIndex,
             })),
@@ -13563,28 +13625,17 @@ const deserializeTripContinuations = (protoTripContinuations) => {
     for (let i = 0; i < protoTripContinuations.length; i++) {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const entry = protoTripContinuations[i];
-        const tripBoardings = entry.value.map((protoTripBoarding) => ({
-            hopOnStop: protoTripBoarding.hopOnStop,
+        const tripBoardingId = encode(entry.originStopIndex, entry.originRouteId, entry.originTripIndex);
+        const tripBoardings = entry.continuations.map((protoTripBoarding) => ({
+            hopOnStopIndex: protoTripBoarding.hopOnStopIndex,
             routeId: protoTripBoarding.routeId,
             tripIndex: protoTripBoarding.tripIndex,
         }));
-        result.set(entry.key, tripBoardings);
+        result.set(tripBoardingId, tripBoardings);
     }
     return result;
 };
 
-// const ROUTE_ID_BITS = 17;
-const TRIP_INDEX_BITS = 15;
-/**
- * Encodes a route ID and trip index into a single trip ID.
- * @param routeId - The route identifier, needs to fit on 17 bits
- * @param tripIndex - The index of the trip within the route, needs to fit on 15 bits
- * @returns The encoded trip ID
- */
-const encode = (routeId, tripIndex) => {
-    return (routeId << TRIP_INDEX_BITS) | tripIndex;
-};
-
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 const ALL_TRANSPORT_MODES = new Set([
     'TRAM',
@@ -13599,21 +13650,21 @@ const ALL_TRANSPORT_MODES = new Set([
     'MONORAIL',
 ]);
 const EMPTY_TRIP_CONTINUATIONS = [];
-const CURRENT_VERSION = '0.0.8';
+const CURRENT_VERSION = '0.0.9';
 /**
  * The internal transit timetable format.
  */
 class Timetable {
-    constructor(stopsAdjacency, routesAdjacency, routes) {
+    constructor(stopsAdjacency, routesAdjacency, routes, tripContinuations) {
         this.stopsAdjacency = stopsAdjacency;
         this.routesAdjacency = routesAdjacency;
         this.serviceRoutes = routes;
+        this.tripContinuations = tripContinuations;
         this.activeStops = new Set();
         for (let i = 0; i < stopsAdjacency.length; i++) {
             const stop = stopsAdjacency[i];
             if (stop.routes.length > 0 ||
-                (stop.transfers && stop.transfers.length > 0) ||
-                (stop.tripContinuations && stop.tripContinuations.size > 0)) {
+                (stop.transfers && stop.transfers.length > 0)) {
                 this.activeStops.add(i);
             }
         }
@@ -13629,6 +13680,7 @@ class Timetable {
             stopsAdjacency: serializeStopsAdjacency(this.stopsAdjacency),
             routesAdjacency: serializeRoutesAdjacency(this.routesAdjacency),
             serviceRoutes: serializeServiceRoutesMap(this.serviceRoutes),
+            tripContinuations: serializeTripContinuations(this.tripContinuations || new Map()),
         };
         const writer = new BinaryWriter();
         Timetable$1.encode(protoTimetable, writer);
@@ -13646,7 +13698,7 @@ class Timetable {
         if (protoTimetable.version !== CURRENT_VERSION) {
             throw new Error(`Unsupported timetable version ${protoTimetable.version}`);
         }
-        return new Timetable(deserializeStopsAdjacency(protoTimetable.stopsAdjacency), deserializeRoutesAdjacency(protoTimetable.routesAdjacency), deserializeServiceRoutesMap(protoTimetable.serviceRoutes));
+        return new Timetable(deserializeStopsAdjacency(protoTimetable.stopsAdjacency), deserializeRoutesAdjacency(protoTimetable.routesAdjacency), deserializeServiceRoutesMap(protoTimetable.serviceRoutes), deserializeTripContinuations(protoTimetable.tripContinuations));
     }
     /**
      * Checks if the given stop is active on the timetable.
@@ -13685,18 +13737,18 @@ class Timetable {
     /**
      * Retrieves all trip continuation options available at the specified stop for a given trip.
      *
-     * @param stopId - The ID of the stop to get trip continuations for.
+     * @param stopIndex - The index in the route of the stop to get trip continuations for.
+     * @param routeId - The ID of the route to get continuations for.
      * @param tripIndex - The index of the trip to get continuations for.
      * @returns An array of trip continuation options available at the stop for the specified trip.
      */
-    getContinuousTrips(stopId, routeId, tripIndex) {
+    getContinuousTrips(stopIndex, routeId, tripIndex) {
         var _a;
-        const stopAdjacency = this.stopsAdjacency[stopId];
-        if (!stopAdjacency) {
-            throw new Error(`Stop ID ${stopId} not found`);
+        const tripContinuations = (_a = this.tripContinuations) === null || _a === void 0 ? void 0 : _a.get(encode(stopIndex, routeId, tripIndex));
+        if (!tripContinuations) {
+            return EMPTY_TRIP_CONTINUATIONS;
         }
-        return (((_a = stopAdjacency.tripContinuations) === null || _a === void 0 ? void 0 : _a.get(encode(routeId, tripIndex))) ||
-            EMPTY_TRIP_CONTINUATIONS);
+        return tripContinuations;
     }
     /**
      * Retrieves the service route associated with the given route.
@@ -13736,12 +13788,12 @@ class Timetable {
     }
     /**
      * Finds routes that are reachable from a set of stop IDs.
-     * Also identifies the first stop available to hop on each route among
+     * Also identifies the first stop index available to hop on each route among
      * the input stops.
      *
      * @param fromStops - The set of stop IDs to find reachable routes from.
      * @param transportModes - The set of transport modes to consider for reachable routes.
-     * @returns A map of reachable routes to the first stop available to hop on each route.
+     * @returns A map of reachable routes to the first stop index available to hop on each route.
      */
     findReachableRoutes(fromStops, transportModes = ALL_TRANSPORT_MODES) {
         const reachableRoutes = new Map();
@@ -13754,15 +13806,17 @@ class Timetable {
             });
             for (let j = 0; j < validRoutes.length; j++) {
                 const route = validRoutes[j];
-                const hopOnStop = reachableRoutes.get(route);
-                if (hopOnStop) {
-                    if (route.isBefore(originStop, hopOnStop)) {
+                const originStopIndices = route.stopRouteIndices(originStop);
+                const originStopIndex = originStopIndices[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, originStop);
+                        reachableRoutes.set(route, originStopIndex);
                     }
                 }
                 else {
-                    reachableRoutes.set(route, originStop);
+                    reachableRoutes.set(route, originStopIndex);
                 }
             }
         }
@@ -15982,7 +16036,7 @@ const parseGtfsLocationType = (gtfsLocationType) => {
 const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, e_1, _b, _c;
     const transfers = new Map();
-    const tripContinuations = new Map();
+    const tripContinuations = [];
     try {
         for (var _d = true, _e = __asyncValues(parseCsv(transfersStream, [
             'transfer_type',
@@ -16000,10 +16054,12 @@ const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0,
                 console.warn(`Missing transfer origin or destination stop.`);
                 continue;
             }
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const fromStop = stopsMap.get(transferEntry.from_stop_id);
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const toStop = stopsMap.get(transferEntry.to_stop_id);
+            if (!fromStop || !toStop) {
+                console.warn(`Transfer references non-existent stop(s): from_stop_id=${transferEntry.from_stop_id}, to_stop_id=${transferEntry.to_stop_id}`);
+                continue;
+            }
             if (transferEntry.transfer_type === 4) {
                 if (transferEntry.from_trip_id === undefined ||
                     transferEntry.from_trip_id === '' ||
@@ -16013,17 +16069,12 @@ const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0,
                     continue;
                 }
                 const tripBoardingEntry = {
+                    fromStop: fromStop.id,
                     fromTrip: transferEntry.from_trip_id,
+                    toStop: toStop.id,
                     toTrip: transferEntry.to_trip_id,
-                    hopOnStop: toStop.id,
                 };
-                const existingBoardings = tripContinuations.get(fromStop.id);
-                if (existingBoardings) {
-                    existingBoardings.push(tripBoardingEntry);
-                }
-                else {
-                    tripContinuations.set(fromStop.id, [tripBoardingEntry]);
-                }
+                tripContinuations.push(tripBoardingEntry);
                 continue;
             }
             if (transferEntry.from_trip_id && transferEntry.to_trip_id) {
@@ -16038,7 +16089,7 @@ const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0,
                 transferEntry.min_transfer_time === undefined) {
                 console.info(`Missing minimum transfer time between ${transferEntry.from_stop_id} and ${transferEntry.to_stop_id}.`);
             }
-            const transfer = Object.assign({ destination: toStop.id, type: parseGtfsTransferType(transferEntry.transfer_type) }, (transferEntry.min_transfer_time && {
+            const transfer = Object.assign({ destination: toStop.id, type: parseGtfsTransferType(transferEntry.transfer_type) }, (transferEntry.min_transfer_time !== undefined && {
                 minTransferTime: Duration.fromSeconds(transferEntry.min_transfer_time),
             }));
             const fromStopTransfers = transfers.get(fromStop.id) || [];
@@ -16058,6 +16109,91 @@ const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0,
         tripContinuations,
     };
 });
+/**
+ * Disambiguates stops involved in a transfer.
+ *
+ * The GTFS specification only refers to a stopId in the trip-to-trip transfers and not the
+ * specific stop index in the route. For routes that have multiple stops with the same stopId,
+ * we need to determine which are the from / to stop indices in respective routes.
+ * We do so by picking the stop indices leading to the most coherent transfer.
+ * (we pick the closest from stop index happening after the to stop index).
+ */
+const disambiguateTransferStopsIndices = (fromStop, fromRoute, fromTripIndex, toStop, toRoute, toTripIndex) => {
+    const fromStopIndices = fromRoute.stopRouteIndices(fromStop);
+    const toStopIndices = toRoute.stopRouteIndices(toStop);
+    let bestFromStopIndex;
+    let bestToStopIndex;
+    let bestTimeDifference = Infinity;
+    for (const originStopIndex of fromStopIndices) {
+        const fromArrivalTime = fromRoute.arrivalAt(originStopIndex, fromTripIndex);
+        for (const toStopIndex of toStopIndices) {
+            const toDepartureTime = toRoute.departureFrom(toStopIndex, toTripIndex);
+            if (toDepartureTime.isAfter(fromArrivalTime)) {
+                const timeDifference = toDepartureTime.toMinutes() - fromArrivalTime.toMinutes();
+                if (timeDifference < bestTimeDifference) {
+                    bestTimeDifference = timeDifference;
+                    bestFromStopIndex = originStopIndex;
+                    bestToStopIndex = toStopIndex;
+                }
+            }
+        }
+    }
+    if (bestFromStopIndex !== undefined && bestToStopIndex !== undefined) {
+        return {
+            fromStopIndex: bestFromStopIndex,
+            toStopIndex: bestToStopIndex,
+        };
+    }
+    return undefined;
+};
+/**
+ * Builds trip continuations map from GTFS trip continuation data.
+ *
+ * This function processes GTFS in-seat transfer data and creates a mapping
+ * from trip boarding IDs to continuation boarding information. It disambiguates
+ * stop indices when routes have multiple stops with the same ID by finding
+ * the most coherent transfer timing.
+ *
+ * @param tripsMapping Mapping from GTFS trip IDs to internal trip representations
+ * @param tripContinuations Array of GTFS trip continuation data from transfers.txt
+ * @param timetable The timetable containing route and timing information
+ * @param activeStopIds Set of stop IDs that are active/enabled in the system
+ * @returns A map from trip boarding IDs to arrays of continuation boarding options
+ */
+const buildTripContinuations = (tripsMapping, tripContinuations, timetable, activeStopIds) => {
+    const continuations = new Map();
+    for (const gtfsContinuation of tripContinuations) {
+        if (!activeStopIds.has(gtfsContinuation.fromStop) ||
+            !activeStopIds.has(gtfsContinuation.toStop)) {
+            continue;
+        }
+        const fromTripMapping = tripsMapping.get(gtfsContinuation.fromTrip);
+        const toTripMapping = tripsMapping.get(gtfsContinuation.toTrip);
+        if (!fromTripMapping || !toTripMapping) {
+            continue;
+        }
+        const fromRoute = timetable.getRoute(fromTripMapping.routeId);
+        const toRoute = timetable.getRoute(toTripMapping.routeId);
+        if (!fromRoute || !toRoute) {
+            continue;
+        }
+        const bestStopIndices = disambiguateTransferStopsIndices(gtfsContinuation.fromStop, fromRoute, fromTripMapping.tripRouteIndex, gtfsContinuation.toStop, toRoute, toTripMapping.tripRouteIndex);
+        if (!bestStopIndices) {
+            // No valid continuation found
+            continue;
+        }
+        const tripBoardingId = encode(bestStopIndices.fromStopIndex, fromTripMapping.routeId, fromTripMapping.tripRouteIndex);
+        const continuationBoarding = {
+            hopOnStopIndex: bestStopIndices.toStopIndex,
+            routeId: toTripMapping.routeId,
+            tripIndex: toTripMapping.tripRouteIndex,
+        };
+        const existingContinuations = continuations.get(tripBoardingId) || [];
+        existingContinuations.push(continuationBoarding);
+        continuations.set(tripBoardingId, existingContinuations);
+    }
+    return continuations;
+};
 const parseGtfsTransferType = (gtfsTransferType) => {
     switch (gtfsTransferType) {
         case 0:
@@ -16194,7 +16330,7 @@ const parseTrips = (tripsStream, serviceIds, validGtfsRoutes) => __awaiter(void
     }
     return trips;
 });
-const buildStopsAdjacencyStructure = (tripsMapping, serviceRoutes, routes, transfersMap, tripContinuationsMap, nbStops, activeStops) => {
+const buildStopsAdjacencyStructure = (serviceRoutes, routes, transfersMap, nbStops, activeStops) => {
     const stopsAdjacency = new Array(nbStops);
     for (let i = 0; i < nbStops; i++) {
         stopsAdjacency[i] = {
@@ -16234,40 +16370,6 @@ const buildStopsAdjacencyStructure = (tripsMapping, serviceRoutes, routes, trans
             }
         }
     }
-    for (const [stop, tripContinuations] of tripContinuationsMap) {
-        for (let i = 0; i < tripContinuations.length; i++) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const tripContinuation = tripContinuations[i];
-            if (activeStops.has(stop) ||
-                activeStops.has(tripContinuation.hopOnStop)) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                const stopAdj = stopsAdjacency[stop];
-                if (!stopAdj.tripContinuations) {
-                    stopAdj.tripContinuations = new Map();
-                }
-                const originTrip = tripsMapping.get(tripContinuation.fromTrip);
-                const destinationTrip = tripsMapping.get(tripContinuation.toTrip);
-                if (destinationTrip === undefined || originTrip === undefined) {
-                    continue;
-                }
-                const tripBoarding = {
-                    hopOnStop: tripContinuation.hopOnStop,
-                    routeId: destinationTrip.routeId,
-                    tripIndex: destinationTrip.tripRouteIndex,
-                };
-                const tripId = encode(originTrip.routeId, originTrip.tripRouteIndex);
-                const existingContinuations = stopAdj.tripContinuations.get(tripId);
-                if (existingContinuations) {
-                    existingContinuations.push(tripBoarding);
-                }
-                else {
-                    stopAdj.tripContinuations.set(tripId, [tripBoarding]);
-                }
-                activeStops.add(tripContinuation.hopOnStop);
-                activeStops.add(stop);
-            }
-        }
-    }
     return stopsAdjacency;
 };
 /**
@@ -16494,16 +16596,16 @@ class GtfsParser {
             const tripsEnd = performance.now();
             log.info(`${trips.size} valid trips. (${(tripsEnd - tripsStart).toFixed(2)}ms)`);
             let transfers = new Map();
-            let tripContinuations = new Map();
+            let tripContinuationsMap = [];
             if (entries[TRANSFERS_FILE]) {
                 log.info(`Parsing ${TRANSFERS_FILE}`);
                 const transfersStart = performance.now();
                 const transfersStream = yield zip.stream(TRANSFERS_FILE);
                 const { transfers: parsedTransfers, tripContinuations: parsedTripContinuations, } = yield parseTransfers(transfersStream, parsedStops);
                 transfers = parsedTransfers;
-                tripContinuations = parsedTripContinuations;
+                tripContinuationsMap = parsedTripContinuations;
                 const transfersEnd = performance.now();
-                log.info(`${transfers.size} valid transfers and ${tripContinuations.size} trip continuations. (${(transfersEnd - transfersStart).toFixed(2)}ms)`);
+                log.info(`${transfers.size} valid transfers and ${tripContinuationsMap.length} trip continuations. (${(transfersEnd - transfersStart).toFixed(2)}ms)`);
             }
             log.info(`Parsing ${STOP_TIMES_FILE}`);
             const stopTimesStart = performance.now();
@@ -16514,13 +16616,19 @@ class GtfsParser {
             log.info(`${routes.length} valid unique routes. (${(stopTimesEnd - stopTimesStart).toFixed(2)}ms)`);
             log.info('Building stops adjacency structure');
             const stopsAdjacencyStart = performance.now();
-            const stopsAdjacency = buildStopsAdjacencyStructure(tripsMapping, serviceRoutes, routes, transfers, tripContinuations, parsedStops.size, activeStopIds);
+            const stopsAdjacency = buildStopsAdjacencyStructure(serviceRoutes, routes, transfers, parsedStops.size, activeStopIds);
             const stopsAdjacencyEnd = performance.now();
             log.info(`${stopsAdjacency.length} valid stops in the structure. (${(stopsAdjacencyEnd - stopsAdjacencyStart).toFixed(2)}ms)`);
             yield zip.close();
+            // temporary timetable for building continuations
             const timetable = new Timetable(stopsAdjacency, routes, serviceRoutes);
+            log.info('Building in-seat trip continuations');
+            const tripContinuationsStart = performance.now();
+            const tripContinuations = buildTripContinuations(tripsMapping, tripContinuationsMap, timetable, activeStopIds);
+            const tripContinuationsEnd = performance.now();
+            log.info(`${tripContinuations.size} in-seat trip continuations origins created. (${(tripContinuationsEnd - tripContinuationsStart).toFixed(2)}ms)`);
             log.info('Parsing complete.');
-            return timetable;
+            return new Timetable(stopsAdjacency, routes, serviceRoutes, tripContinuations);
         });
     }
     /**