minotor 7.0.2 → 8.0.0

package/dist/cli.mjs

@@ -16606,41 +16606,191 @@ const Transfer = {
         return message;
     },
 };
-function createBaseStopAdjacency() {
-    return { transfers: [], routes: [] };
+function createBaseTripBoarding() {
+    return { hopOnStop: 0, routeId: 0, tripIndex: 0 };
 }
-const StopAdjacency = {
+const TripBoarding = {
     encode(message, writer = new BinaryWriter()) {
-        for (const v of message.transfers) {
-            Transfer.encode(v, writer.uint32(10).fork()).join();
+        if (message.hopOnStop !== 0) {
+            writer.uint32(8).uint32(message.hopOnStop);
         }
-        writer.uint32(18).fork();
-        for (const v of message.routes) {
-            writer.uint32(v);
+        if (message.routeId !== 0) {
+            writer.uint32(16).uint32(message.routeId);
+        }
+        if (message.tripIndex !== 0) {
+            writer.uint32(24).uint32(message.tripIndex);
         }
-        writer.join();
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
         const end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseStopAdjacency();
+        const message = createBaseTripBoarding();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1: {
-                    if (tag !== 10) {
+                    if (tag !== 8) {
                         break;
                     }
-                    message.transfers.push(Transfer.decode(reader, reader.uint32()));
+                    message.hopOnStop = reader.uint32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.routeId = reader.uint32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.tripIndex = reader.uint32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            hopOnStop: isSet(object.hopOnStop) ? globalThis.Number(object.hopOnStop) : 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.routeId !== 0) {
+            obj.routeId = Math.round(message.routeId);
+        }
+        if (message.tripIndex !== 0) {
+            obj.tripIndex = Math.round(message.tripIndex);
+        }
+        return obj;
+    },
+    create(base) {
+        return TripBoarding.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = createBaseTripBoarding();
+        message.hopOnStop = (_a = object.hopOnStop) !== 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: [] };
+}
+const TripContinuationEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.key !== 0) {
+            writer.uint32(8).uint32(message.key);
+        }
+        for (const v of message.value) {
+            TripBoarding.encode(v, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTripContinuationEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.key = reader.uint32();
                     continue;
                 }
                 case 2: {
-                    if (tag === 16) {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value.push(TripBoarding.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    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)) : [],
+        };
+    },
+    toJSON(message) {
+        var _a;
+        const obj = {};
+        if (message.key !== 0) {
+            obj.key = Math.round(message.key);
+        }
+        if ((_a = message.value) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.value = message.value.map((e) => TripBoarding.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return TripContinuationEntry.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        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))) || [];
+        return message;
+    },
+};
+function createBaseStopAdjacency() {
+    return { routes: [], transfers: [], tripContinuations: [] };
+}
+const StopAdjacency = {
+    encode(message, writer = new BinaryWriter()) {
+        writer.uint32(10).fork();
+        for (const v of message.routes) {
+            writer.uint32(v);
+        }
+        writer.join();
+        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) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseStopAdjacency();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag === 8) {
                         message.routes.push(reader.uint32());
                         continue;
                     }
-                    if (tag === 18) {
+                    if (tag === 10) {
                         const end2 = reader.uint32() + reader.pos;
                         while (reader.pos < end2) {
                             message.routes.push(reader.uint32());
@@ -16649,6 +16799,20 @@ const StopAdjacency = {
                     }
                     break;
                 }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    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;
@@ -16659,20 +16823,26 @@ const StopAdjacency = {
     },
     fromJSON(object) {
         return {
+            routes: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.routes) ? object.routes.map((e) => globalThis.Number(e)) : [],
             transfers: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.transfers)
                 ? object.transfers.map((e) => Transfer.fromJSON(e))
                 : [],
-            routes: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.routes) ? object.routes.map((e) => globalThis.Number(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;
+        var _a, _b, _c;
         const obj = {};
-        if ((_a = message.transfers) === null || _a === void 0 ? void 0 : _a.length) {
+        if ((_a = message.routes) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.routes = message.routes.map((e) => Math.round(e));
+        }
+        if ((_b = message.transfers) === null || _b === void 0 ? void 0 : _b.length) {
             obj.transfers = message.transfers.map((e) => Transfer.toJSON(e));
         }
-        if ((_b = message.routes) === null || _b === void 0 ? void 0 : _b.length) {
-            obj.routes = message.routes.map((e) => Math.round(e));
+        if ((_c = message.tripContinuations) === null || _c === void 0 ? void 0 : _c.length) {
+            obj.tripContinuations = message.tripContinuations.map((e) => TripContinuationEntry.toJSON(e));
         }
         return obj;
     },
@@ -16680,10 +16850,11 @@ const StopAdjacency = {
         return StopAdjacency.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b;
+        var _a, _b, _c;
         const message = createBaseStopAdjacency();
-        message.transfers = ((_a = object.transfers) === null || _a === void 0 ? void 0 : _a.map((e) => Transfer.fromPartial(e))) || [];
-        message.routes = ((_b = object.routes) === null || _b === void 0 ? void 0 : _b.map((e) => e)) || [];
+        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;
     },
 };
@@ -17172,7 +17343,8 @@ const toPickupDropOffType = (numericalType) => {
  * A route identifies all trips of a given service route sharing the same list of stops.
  */
 let Route$1 = class Route {
-    constructor(stopTimes, pickUpDropOffTypes, stops, serviceRouteId) {
+    constructor(id, stopTimes, pickUpDropOffTypes, stops, serviceRouteId) {
+        this.id = id;
         this.stopTimes = stopTimes;
         this.pickUpDropOffTypes = pickUpDropOffTypes;
         this.stops = stops;
@@ -17185,6 +17357,78 @@ let Route$1 = class Route {
             this.stopIndices.set(stops[i], i);
         }
     }
+    /**
+     * Creates a new route from multiple trips with their stops.
+     *
+     * @param params The route parameters including ID, service route ID, and trips.
+     * @returns The new route.
+     */
+    static of(params) {
+        var _a, _b;
+        const { id, serviceRouteId, trips } = params;
+        if (trips.length === 0) {
+            throw new Error('At least one trip must be provided');
+        }
+        // All trips must have the same stops in the same order
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const firstTrip = trips[0];
+        const stopIds = new Uint32Array(firstTrip.stops.map((stop) => stop.id));
+        const numStops = stopIds.length;
+        // Validate all trips have the same stops
+        for (let tripIndex = 1; tripIndex < trips.length; tripIndex++) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const trip = trips[tripIndex];
+            if (trip.stops.length !== numStops) {
+                throw new Error(`Trip ${tripIndex} has ${trip.stops.length} stops, expected ${numStops}`);
+            }
+            for (let stopIndex = 0; stopIndex < numStops; stopIndex++) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                if (trip.stops[stopIndex].id !== stopIds[stopIndex]) {
+                    throw new Error(`Trip ${tripIndex} has different stop at index ${stopIndex}`);
+                }
+            }
+        }
+        // Create stopTimes array with arrivals and departures for all trips
+        const stopTimes = new Uint16Array(trips.length * numStops * 2);
+        for (let tripIndex = 0; tripIndex < trips.length; tripIndex++) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const trip = trips[tripIndex];
+            for (let stopIndex = 0; stopIndex < numStops; stopIndex++) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const stop = trip.stops[stopIndex];
+                const baseIndex = (tripIndex * numStops + stopIndex) * 2;
+                stopTimes[baseIndex] = stop.arrivalTime.toMinutes();
+                stopTimes[baseIndex + 1] = stop.departureTime.toMinutes();
+            }
+        }
+        // Create pickUpDropOffTypes array (2-bit encoded) for all trips
+        const totalStopEntries = trips.length * numStops;
+        const pickUpDropOffTypes = new Uint8Array(Math.ceil(totalStopEntries / 2));
+        for (let tripIndex = 0; tripIndex < trips.length; tripIndex++) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const trip = trips[tripIndex];
+            for (let stopIndex = 0; stopIndex < numStops; stopIndex++) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const stop = trip.stops[stopIndex];
+                const globalIndex = tripIndex * numStops + stopIndex;
+                const pickUp = (_a = stop.pickUpType) !== null && _a !== void 0 ? _a : REGULAR;
+                const dropOff = (_b = stop.dropOffType) !== null && _b !== void 0 ? _b : REGULAR;
+                const byteIndex = Math.floor(globalIndex / 2);
+                const isSecondPair = globalIndex % 2 === 1;
+                if (isSecondPair) {
+                    // Second pair: pickup in upper 2 bits, dropOff in bits 4-5
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    pickUpDropOffTypes[byteIndex] |= (pickUp << 6) | (dropOff << 4);
+                }
+                else {
+                    // First pair: pickup in bits 2-3, dropOff in lower 2 bits
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    pickUpDropOffTypes[byteIndex] |= (pickUp << 2) | dropOff;
+                }
+            }
+        }
+        return new Route(id, stopTimes, pickUpDropOffTypes, stopIds, serviceRouteId);
+    }
     /**
      * Serializes the Route into binary arrays.
      *
@@ -17208,11 +17452,11 @@ let Route$1 = class Route {
     isBefore(stopA, stopB) {
         const stopAIndex = this.stopIndices.get(stopA);
         if (stopAIndex === undefined) {
-            throw new Error(`Stop index ${stopAIndex} not found in route ${this.serviceRouteId}`);
+            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 ${stopBIndex} not found in route ${this.serviceRouteId}`);
+            throw new Error(`Stop index not found for ${stopB} in route ${this.serviceRouteId}`);
         }
         return stopAIndex < stopBIndex;
     }
@@ -17224,6 +17468,14 @@ let Route$1 = class Route {
     getNbStops() {
         return this.nbStops;
     }
+    /**
+     * Retrieves the number of trips in the route.
+     *
+     * @returns The total number of trips in the route.
+     */
+    getNbTrips() {
+        return this.nbTrips;
+    }
     /**
      * Finds the ServiceRouteId of the route. It corresponds the identifier
      * of the service shown to the end user as a route.
@@ -17241,7 +17493,7 @@ let Route$1 = class Route {
      * @returns The arrival time at the specified stop and trip as a Time object.
      */
     arrivalAt(stopId, tripIndex) {
-        const arrivalIndex = (tripIndex * this.stops.length + this.stopIndex(stopId)) * 2;
+        const arrivalIndex = (tripIndex * this.stops.length + this.stopRouteIndex(stopId)) * 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}`);
@@ -17256,7 +17508,7 @@ let Route$1 = class Route {
      * @returns The departure time at the specified stop and trip as a Time object.
      */
     departureFrom(stopId, tripIndex) {
-        const departureIndex = (tripIndex * this.stops.length + this.stopIndex(stopId)) * 2 + 1;
+        const departureIndex = (tripIndex * this.stops.length + this.stopRouteIndex(stopId)) * 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}`);
@@ -17271,7 +17523,7 @@ let Route$1 = class Route {
      * @returns The pick-up type at the specified stop and trip.
      */
     pickUpTypeFrom(stopId, tripIndex) {
-        const globalIndex = tripIndex * this.stops.length + this.stopIndex(stopId);
+        const globalIndex = tripIndex * this.stops.length + this.stopRouteIndex(stopId);
         const byteIndex = Math.floor(globalIndex / 2);
         const isSecondPair = globalIndex % 2 === 1;
         const byte = this.pickUpDropOffTypes[byteIndex];
@@ -17291,7 +17543,7 @@ let Route$1 = class Route {
      * @returns The drop-off type at the specified stop and trip.
      */
     dropOffTypeAt(stopId, tripIndex) {
-        const globalIndex = tripIndex * this.stops.length + this.stopIndex(stopId);
+        const globalIndex = tripIndex * this.stops.length + this.stopRouteIndex(stopId);
         const byteIndex = Math.floor(globalIndex / 2);
         const isSecondPair = globalIndex % 2 === 1;
         const byte = this.pickUpDropOffTypes[byteIndex];
@@ -17351,13 +17603,25 @@ let Route$1 = class Route {
      * @param stopId The StopId of the stop to locate in the route.
      * @returns The index of the stop in the route.
      */
-    stopIndex(stopId) {
+    stopRouteIndex(stopId) {
         const stopIndex = this.stopIndices.get(stopId);
         if (stopIndex === undefined) {
             throw new Error(`Stop index for ${stopId} not found in route ${this.serviceRouteId}`);
         }
         return stopIndex;
     }
+    /**
+     * Retrieves the id of a stop at a given index in a route.
+     * @param stopRouteIndex The route index of the stop.
+     * @returns The id of the stop at the given index in the route.
+     */
+    stopId(stopRouteIndex) {
+        const stopId = this.stops[stopRouteIndex];
+        if (stopId === undefined) {
+            throw new Error(`StopId for stop at index ${stopRouteIndex} not found in route ${this.serviceRouteId}`);
+        }
+        return stopId;
+    }
 };
 
 const isLittleEndian = (() => {
@@ -17428,10 +17692,15 @@ const bytesToUint16Array = (bytes) => {
 const serializeStopsAdjacency = (stopsAdjacency) => {
     return stopsAdjacency.map((value) => {
         return {
-            transfers: value.transfers.map((transfer) => (Object.assign({ destination: transfer.destination, type: serializeTransferType(transfer.type) }, (transfer.minTransferTime !== undefined && {
-                minTransferTime: transfer.minTransferTime.toSeconds(),
-            })))),
+            transfers: value.transfers
+                ? value.transfers.map((transfer) => (Object.assign({ destination: transfer.destination, type: serializeTransferType(transfer.type) }, (transfer.minTransferTime !== undefined && {
+                    minTransferTime: transfer.minTransferTime.toSeconds(),
+                }))))
+                : [],
             routes: value.routes,
+            tripContinuations: value.tripContinuations
+                ? serializeTripContinuations(value.tripContinuations)
+                : [],
         };
     });
 };
@@ -17471,10 +17740,17 @@ const deserializeStopsAdjacency = (protoStopsAdjacency) => {
             }));
             transfers.push(newTransfer);
         }
-        result.push({
-            transfers: transfers,
+        const stopAdjacency = {
             routes: value.routes,
-        });
+        };
+        if (transfers.length > 0) {
+            stopAdjacency.transfers = transfers;
+        }
+        const deserializedTripContinuations = deserializeTripContinuations(value.tripContinuations);
+        if (deserializedTripContinuations.size > 0) {
+            stopAdjacency.tripContinuations = deserializedTripContinuations;
+        }
+        result.push(stopAdjacency);
     }
     return result;
 };
@@ -17484,7 +17760,7 @@ const deserializeRoutesAdjacency = (protoRoutesAdjacency) => {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const value = protoRoutesAdjacency[i];
         const stops = bytesToUint32Array(value.stops);
-        routesAdjacency.push(new Route$1(bytesToUint16Array(value.stopTimes), value.pickUpDropOffTypes, stops, value.serviceRouteId));
+        routesAdjacency.push(new Route$1(i, bytesToUint16Array(value.stopTimes), value.pickUpDropOffTypes, stops, value.serviceRouteId));
     }
     return routesAdjacency;
 };
@@ -17578,6 +17854,46 @@ const serializeRouteType = (type) => {
             return RouteType.MONORAIL;
     }
 };
+const serializeTripContinuations = (tripContinuations) => {
+    const result = [];
+    for (const [key, value] of tripContinuations.entries()) {
+        result.push({
+            key: key,
+            value: value.map((tripBoarding) => ({
+                hopOnStop: tripBoarding.hopOnStop,
+                routeId: tripBoarding.routeId,
+                tripIndex: tripBoarding.tripIndex,
+            })),
+        });
+    }
+    return result;
+};
+const deserializeTripContinuations = (protoTripContinuations) => {
+    const result = new Map();
+    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,
+            routeId: protoTripBoarding.routeId,
+            tripIndex: protoTripBoarding.tripIndex,
+        }));
+        result.set(entry.key, 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([
@@ -17592,7 +17908,8 @@ const ALL_TRANSPORT_MODES = new Set([
     'TROLLEYBUS',
     'MONORAIL',
 ]);
-const CURRENT_VERSION = '0.0.7';
+const EMPTY_TRIP_CONTINUATIONS = [];
+const CURRENT_VERSION = '0.0.8';
 /**
  * The internal transit timetable format.
  */
@@ -17603,9 +17920,10 @@ class Timetable {
         this.serviceRoutes = routes;
         this.activeStops = new Set();
         for (let i = 0; i < stopsAdjacency.length; i++) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const stop = stopsAdjacency[i];
-            if (stop.routes.length > 0 || stop.transfers.length > 0) {
+            if (stop.routes.length > 0 ||
+                (stop.transfers && stop.transfers.length > 0) ||
+                (stop.tripContinuations && stop.tripContinuations.size > 0)) {
                 this.activeStops.add(i);
             }
         }
@@ -17668,8 +17986,27 @@ class Timetable {
      * @returns An array of transfer options available at the stop.
      */
     getTransfers(stopId) {
-        var _a, _b;
-        return (_b = (_a = this.stopsAdjacency[stopId]) === null || _a === void 0 ? void 0 : _a.transfers) !== null && _b !== void 0 ? _b : [];
+        const stopAdjacency = this.stopsAdjacency[stopId];
+        if (!stopAdjacency) {
+            throw new Error(`Stop ID ${stopId} not found`);
+        }
+        return stopAdjacency.transfers || [];
+    }
+    /**
+     * 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 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) {
+        var _a;
+        const stopAdjacency = this.stopsAdjacency[stopId];
+        if (!stopAdjacency) {
+            throw new Error(`Stop ID ${stopId} not found`);
+        }
+        return (((_a = stopAdjacency.tripContinuations) === null || _a === void 0 ? void 0 : _a.get(encode(routeId, tripIndex))) ||
+            EMPTY_TRIP_CONTINUATIONS);
     }
     /**
      * Retrieves the service route associated with the given route.
@@ -19955,6 +20292,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();
     try {
         for (var _d = true, _e = __asyncValues(parseCsv(transfersStream, [
             'transfer_type',
@@ -19968,25 +20306,48 @@ const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0,
                 transferEntry.transfer_type === 5) {
                 continue;
             }
-            if (transferEntry.from_trip_id && transferEntry.to_trip_id) {
-                console.warn(`Unsupported transfer between trips ${transferEntry.from_trip_id} and ${transferEntry.to_trip_id}.`);
-                continue;
-            }
-            if (transferEntry.from_route_id && transferEntry.to_route_id) {
-                console.warn(`Unsupported transfer between routes ${transferEntry.from_route_id} and ${transferEntry.to_route_id}.`);
-                continue;
-            }
             if (!transferEntry.from_stop_id || !transferEntry.to_stop_id) {
                 console.warn(`Missing transfer origin or destination stop.`);
                 continue;
             }
-            if (transferEntry.transfer_type === 2 && !transferEntry.min_transfer_time) {
-                console.info(`Missing minimum transfer time between ${transferEntry.from_stop_id} and ${transferEntry.to_stop_id}.`);
-            }
             // 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 (transferEntry.transfer_type === 4) {
+                if (transferEntry.from_trip_id === undefined ||
+                    transferEntry.from_trip_id === '' ||
+                    transferEntry.to_trip_id === undefined ||
+                    transferEntry.to_trip_id === '') {
+                    console.warn(`Unsupported in-seat transfer, missing from_trip_id and/or to_trip_id.`);
+                    continue;
+                }
+                const tripBoardingEntry = {
+                    fromTrip: transferEntry.from_trip_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]);
+                }
+                continue;
+            }
+            if (transferEntry.from_trip_id && transferEntry.to_trip_id) {
+                console.warn(`Unsupported transfer of type ${transferEntry.transfer_type} between trips ${transferEntry.from_trip_id} and ${transferEntry.to_trip_id}.`);
+                continue;
+            }
+            if (transferEntry.from_route_id && transferEntry.to_route_id) {
+                console.warn(`Unsupported transfer of type ${transferEntry.transfer_type} between routes ${transferEntry.from_route_id} and ${transferEntry.to_route_id}.`);
+                continue;
+            }
+            if (transferEntry.transfer_type === 2 &&
+                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 && {
                 minTransferTime: Duration.fromSeconds(transferEntry.min_transfer_time),
             }));
@@ -20002,7 +20363,10 @@ const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0,
         }
         finally { if (e_1) throw e_1.error; }
     }
-    return transfers;
+    return {
+        transfers,
+        tripContinuations,
+    };
 });
 const parseGtfsTransferType = (gtfsTransferType) => {
     switch (gtfsTransferType) {
@@ -20065,11 +20429,13 @@ const finalizeRouteFromBuilder = (builder) => {
     const stopTimesArray = new Uint16Array(stopsCount * tripsCount * 2);
     const allPickUpTypes = [];
     const allDropOffTypes = [];
+    const gtfsTripIds = [];
     for (let tripIndex = 0; tripIndex < tripsCount; tripIndex++) {
         const trip = builder.trips[tripIndex];
         if (!trip) {
             throw new Error(`Missing trip data at index ${tripIndex}`);
         }
+        gtfsTripIds.push(trip.gtfsTripId);
         const baseIndex = tripIndex * stopsCount * 2;
         for (let stopIndex = 0; stopIndex < stopsCount; stopIndex++) {
             const timeIndex = baseIndex + stopIndex * 2;
@@ -20091,12 +20457,15 @@ const finalizeRouteFromBuilder = (builder) => {
     }
     // Use 2-bit encoding for pickup/drop-off types
     const pickUpDropOffTypesArray = encodePickUpDropOffTypes(allPickUpTypes, allDropOffTypes);
-    return {
-        serviceRouteId: builder.serviceRouteId,
-        stops: stopsArray,
-        stopTimes: stopTimesArray,
-        pickUpDropOffTypes: pickUpDropOffTypesArray,
-    };
+    return [
+        {
+            serviceRouteId: builder.serviceRouteId,
+            stops: stopsArray,
+            stopTimes: stopTimesArray,
+            pickUpDropOffTypes: pickUpDropOffTypesArray,
+        },
+        gtfsTripIds,
+    ];
 };
 /**
  * Parses the trips.txt file from a GTFS feed
@@ -20135,11 +20504,12 @@ const parseTrips = (tripsStream, serviceIds, validGtfsRoutes) => __awaiter(void
     }
     return trips;
 });
-const buildStopsAdjacencyStructure = (serviceRoutes, routes, transfersMap, nbStops, activeStops) => {
-    // TODO somehow works when it's a map
+const buildStopsAdjacencyStructure = (tripsMapping, serviceRoutes, routes, transfersMap, tripContinuationsMap, nbStops, activeStops) => {
     const stopsAdjacency = new Array(nbStops);
     for (let i = 0; i < nbStops; i++) {
-        stopsAdjacency[i] = { routes: [], transfers: [] };
+        stopsAdjacency[i] = {
+            routes: [],
+        };
     }
     for (let index = 0; index < routes.length; index++) {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -20164,12 +20534,50 @@ const buildStopsAdjacencyStructure = (serviceRoutes, routes, transfersMap, nbSto
             const transfer = transfers[i];
             if (activeStops.has(stop) || activeStops.has(transfer.destination)) {
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                stopsAdjacency[stop].transfers.push(transfer);
+                const stopAdj = stopsAdjacency[stop];
+                if (!stopAdj.transfers) {
+                    stopAdj.transfers = [];
+                }
+                stopAdj.transfers.push(transfer);
                 activeStops.add(transfer.destination);
                 activeStops.add(stop);
             }
         }
     }
+    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;
 };
 /**
@@ -20228,6 +20636,7 @@ const parseStopTimes = (stopTimesStream, stopsMap, activeTripIds, activeStopIds)
         }
         routeBuilder.trips.push({
             firstDeparture,
+            gtfsTripId: currentTripId,
             arrivalTimes: arrivalTimes,
             departureTimes: departureTimes,
             pickUpTypes: pickUpTypes,
@@ -20265,6 +20674,9 @@ const parseStopTimes = (stopTimesStream, stopsMap, activeTripIds, activeStopIds)
                 continue;
             }
             if (line.pickup_type === '1' && line.drop_off_type === '1') {
+                // Warning: could potentially lead to issues if there is an in-seat transfer
+                // at this stop - it can be not boardable nor alightable but still useful for an in-seat transfer.
+                // This doesn't seem to happen in practice for now so keeping this condition to save memory.
                 continue;
             }
             if (currentTripId && line.trip_id !== currentTripId && stops.length > 0) {
@@ -20301,11 +20713,19 @@ const parseStopTimes = (stopTimesStream, stopsMap, activeTripIds, activeStopIds)
         addTrip(currentTripId);
     }
     const routesAdjacency = [];
+    const tripsMapping = new Map();
     for (const [, routeBuilder] of routeBuilders) {
-        const routeData = finalizeRouteFromBuilder(routeBuilder);
-        routesAdjacency.push(new Route$1(routeData.stopTimes, routeData.pickUpDropOffTypes, routeData.stops, routeData.serviceRouteId));
+        const [routeData, gtfsTripIds] = finalizeRouteFromBuilder(routeBuilder);
+        const routeId = routesAdjacency.length;
+        routesAdjacency.push(new Route$1(routeId, routeData.stopTimes, routeData.pickUpDropOffTypes, routeData.stops, routeData.serviceRouteId));
+        gtfsTripIds.forEach((tripId, index) => {
+            tripsMapping.set(tripId, {
+                routeId,
+                tripRouteIndex: index,
+            });
+        });
     }
-    return { routes: routesAdjacency, serviceRoutesMap };
+    return { routes: routesAdjacency, serviceRoutesMap, tripsMapping };
 });
 const parsePickupDropOffType = (gtfsType) => {
     switch (gtfsType) {
@@ -20384,24 +20804,27 @@ 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();
             if (entries[TRANSFERS_FILE]) {
                 log.info(`Parsing ${TRANSFERS_FILE}`);
                 const transfersStart = performance.now();
                 const transfersStream = yield zip.stream(TRANSFERS_FILE);
-                transfers = yield parseTransfers(transfersStream, parsedStops);
+                const { transfers: parsedTransfers, tripContinuations: parsedTripContinuations, } = yield parseTransfers(transfersStream, parsedStops);
+                transfers = parsedTransfers;
+                tripContinuations = parsedTripContinuations;
                 const transfersEnd = performance.now();
-                log.info(`${transfers.size} valid transfers. (${(transfersEnd - transfersStart).toFixed(2)}ms)`);
+                log.info(`${transfers.size} valid transfers and ${tripContinuations.size} trip continuations. (${(transfersEnd - transfersStart).toFixed(2)}ms)`);
             }
             log.info(`Parsing ${STOP_TIMES_FILE}`);
             const stopTimesStart = performance.now();
             const stopTimesStream = yield zip.stream(STOP_TIMES_FILE);
-            const { routes, serviceRoutesMap } = yield parseStopTimes(stopTimesStream, parsedStops, trips, activeStopIds);
+            const { routes, serviceRoutesMap, tripsMapping } = yield parseStopTimes(stopTimesStream, parsedStops, trips, activeStopIds);
             const serviceRoutes = indexRoutes(validGtfsRoutes, serviceRoutesMap);
             const stopTimesEnd = performance.now();
             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(serviceRoutes, routes, transfers, parsedStops.size, activeStopIds);
+            const stopsAdjacency = buildStopsAdjacencyStructure(tripsMapping, serviceRoutes, routes, transfers, tripContinuations, parsedStops.size, activeStopIds);
             const stopsAdjacencyEnd = performance.now();
             log.info(`${stopsAdjacency.length} valid stops in the structure. (${(stopsAdjacencyEnd - stopsAdjacencyStart).toFixed(2)}ms)`);
             yield zip.close();
@@ -20482,53 +20905,242 @@ const chGtfsProfile = {
 
 class Plotter {
     constructor(result) {
+        this.ROUND_COLORS = [
+            '#60a5fa', // Round 1
+            '#ff9800', // Round 2
+            '#14b8a6', // Round 3
+            '#fb7185', // Round 4
+            '#ffdf00', // Round 5
+            '#b600ff', // Round 6
+            '#ee82ee', // Round 7+
+        ];
         this.result = result;
     }
     /**
-     * Plots the path three as a DOT for debugging purposes.
-     *
-     * @returns A string representing the DOT graph of the path tree.
+     * Gets the color for a round based on the specified palette.
      */
-    plotDotGraph() {
-        const earliestArrivalsPerRound = this.result.earliestArrivalsPerRound;
-        const dotParts = [
-            'digraph PathTree {',
-            '  graph [overlap=false];',
-            '  node [shape=ellipse style=filled fillcolor=lightgrey];',
+    getRoundColor(round) {
+        var _a;
+        if (round === 0)
+            return '#888888';
+        const colorIndex = Math.min(round - 1, this.ROUND_COLORS.length - 1);
+        return (_a = this.ROUND_COLORS[colorIndex]) !== null && _a !== void 0 ? _a : '#ee82ee';
+    }
+    /**
+     * Escapes special characters in DOT strings to prevent syntax errors.
+     */
+    escapeDotString(str) {
+        return str
+            .replace(/\\/g, '\\\\')
+            .replace(/"/g, '\\"')
+            .replace(/\n/g, '\\n')
+            .replace(/\r/g, '\\r')
+            .replace(/\t/g, '\\t');
+    }
+    /**
+     * Determines station type (origin/destination) information.
+     */
+    getStationInfo(stopId) {
+        var _a, _b;
+        const isOrigin = (_b = (_a = this.result.routingState.graph[0]) === null || _a === void 0 ? void 0 : _a.has(stopId)) !== null && _b !== void 0 ? _b : false;
+        const isDestination = this.result.routingState.destinations.includes(stopId);
+        return { isOrigin, isDestination };
+    }
+    /**
+     * Formats a stop name for display, including platform information.
+     */
+    formatStopName(stopId) {
+        const stop = this.result.stopsIndex.findStopById(stopId);
+        if (!stop)
+            return `Unknown Stop (${stopId})`;
+        const escapedName = this.escapeDotString(stop.name);
+        const escapedPlatform = stop.platform
+            ? this.escapeDotString(stop.platform)
+            : '';
+        return escapedPlatform
+            ? `${escapedName}\\nPl. ${escapedPlatform}`
+            : escapedName;
+    }
+    /**
+     * Gets the appropriate fill color for a station based on its type.
+     */
+    getStationFillColor(isOrigin, isDestination) {
+        if (isOrigin)
+            return '#60a5fa';
+        if (isDestination)
+            return '#ee82ee';
+        return 'white';
+    }
+    /**
+     * Creates a DOT node for a station.
+     */
+    createStationNode(stopId) {
+        const stop = this.result.stopsIndex.findStopById(stopId);
+        if (!stop)
+            return '';
+        const displayName = this.formatStopName(stopId);
+        const stopIdStr = this.escapeDotString(String(stopId));
+        const nodeId = `s_${stopId}`;
+        const stationInfo = this.getStationInfo(stopId);
+        const fillColor = this.getStationFillColor(stationInfo.isOrigin, stationInfo.isDestination);
+        return `  "${nodeId}" [label="${displayName}\\n${stopIdStr}" shape=box style=filled fillcolor="${fillColor}"];`;
+    }
+    /**
+     * Creates a vehicle edge with route information oval in the middle.
+     */
+    createVehicleEdge(edge, round) {
+        var _a;
+        const fromNodeId = `s_${edge.from}`;
+        const toNodeId = `s_${edge.to}`;
+        const roundColor = this.getRoundColor(round);
+        const routeOvalId = `e_${edge.from}_${edge.to}_${edge.routeId}_${round}`;
+        const route = this.result.timetable.getRoute(edge.routeId);
+        const serviceRouteInfo = route
+            ? this.result.timetable.getServiceRouteInfo(route)
+            : null;
+        const routeName = (_a = serviceRouteInfo === null || serviceRouteInfo === void 0 ? void 0 : serviceRouteInfo.name) !== null && _a !== void 0 ? _a : `Route ${String(edge.routeId)}`;
+        const routeType = (serviceRouteInfo === null || serviceRouteInfo === void 0 ? void 0 : serviceRouteInfo.type) || 'UNKNOWN';
+        const departureTime = route
+            ? route.departureFrom(edge.from, edge.tripIndex).toString()
+            : 'N/A';
+        const arrivalTime = edge.arrival.toString();
+        const escapedRouteName = this.escapeDotString(routeName);
+        const escapedRouteType = this.escapeDotString(routeType);
+        const routeInfo = `${edge.routeId}:${edge.tripIndex}`;
+        const ovalLabel = `${escapedRouteType} ${escapedRouteName}\\n${routeInfo}\\n${departureTime} → ${arrivalTime}`;
+        return [
+            `  "${routeOvalId}" [label="${ovalLabel}" shape=oval style=filled fillcolor="white" color="${roundColor}"];`,
+            `  "${fromNodeId}" -> "${routeOvalId}" [color="${roundColor}"];`,
+            `  "${routeOvalId}" -> "${toNodeId}" [color="${roundColor}"];`,
         ];
-        earliestArrivalsPerRound.forEach((arrivalsInRound, round) => {
-            arrivalsInRound.forEach((tripLeg) => {
-                const { origin, leg } = tripLeg;
-                if (!leg)
-                    return; // Skip if leg is undefined
-                const fromStop = this.result['stopsIndex'].findStopById(leg.from.id);
-                const toStop = this.result['stopsIndex'].findStopById(leg.to.id);
-                const originStop = this.result['stopsIndex'].findStopById(origin);
-                if (fromStop && toStop && originStop) {
-                    const fromName = fromStop.platform
-                        ? `${fromStop.name} (Pl. ${fromStop.platform})`
-                        : fromStop.name;
-                    const toName = toStop.platform
-                        ? `${toStop.name} (Pl. ${toStop.platform})`
-                        : toStop.name;
-                    const originName = originStop.platform
-                        ? `${originStop.name} (Pl. ${originStop.platform})`
-                        : originStop.name;
-                    const isVehicle = 'route' in leg;
-                    const routeLabelContent = isVehicle
-                        ? `${leg.route.name}\n${leg.departureTime.toString()} - ${leg.arrivalTime.toString()}`
-                        : leg.minTransferTime
-                            ? leg.minTransferTime.toString()
-                            : '';
-                    const intermediateNode = `IntermediateNode${fromStop.id}_${toStop.id}`;
-                    const lineColor = isVehicle ? '' : ', color="red", fontcolor="red"';
-                    const labelColor = isVehicle ? '' : ' fontcolor="red"';
-                    dotParts.push(`  "${fromName} (Origin: ${originName}) [R${round}]\n(${fromStop.id})" -> "${intermediateNode}" [shape=point${lineColor}];`);
-                    dotParts.push(`  "${intermediateNode}" [label="${routeLabelContent}" shape=rect style=filled fillcolor=white${labelColor} border=0];`);
-                    dotParts.push(`  "${intermediateNode}" -> "${toName} (Origin: ${originName}) [R${round}]\n(${toStop.id})" [${lineColor.replace(', ', '')}];`);
+    }
+    /**
+     * Creates a transfer edge with transfer information oval in the middle.
+     */
+    createTransferEdge(edge, round) {
+        var _a;
+        const fromNodeId = `s_${edge.from}`;
+        const toNodeId = `s_${edge.to}`;
+        const roundColor = this.getRoundColor(round);
+        const transferOvalId = `e_${edge.from}_${edge.to}_${round}`;
+        const transferTime = ((_a = edge.minTransferTime) === null || _a === void 0 ? void 0 : _a.toString()) || 'N/A';
+        const escapedTransferTime = this.escapeDotString(transferTime);
+        const ovalLabel = `Transfer\\n${escapedTransferTime}`;
+        return [
+            `  "${transferOvalId}" [label="${ovalLabel}" shape=oval style="dashed,filled" fillcolor="white" color="${roundColor}"];`,
+            `  "${fromNodeId}" -> "${transferOvalId}" [color="${roundColor}" style="dashed"];`,
+            `  "${transferOvalId}" -> "${toNodeId}" [color="${roundColor}" style="dashed"];`,
+        ];
+    }
+    /**
+     * Creates a continuation edge to visually link trip continuations.
+     */
+    createContinuationEdge(fromEdge, toEdge, round) {
+        var _a, _b;
+        const fromStationId = `s_${fromEdge.to}`;
+        const toStationId = `s_${toEdge.from}`;
+        const roundColor = this.getRoundColor(round);
+        const continuationOvalId = `continuation_${fromEdge.to}_${toEdge.from}_${round}`;
+        const fromRoute = this.result.timetable.getRoute(fromEdge.routeId);
+        const toRoute = this.result.timetable.getRoute(toEdge.routeId);
+        const fromServiceRouteInfo = fromRoute
+            ? this.result.timetable.getServiceRouteInfo(fromRoute)
+            : null;
+        const toServiceRouteInfo = toRoute
+            ? this.result.timetable.getServiceRouteInfo(toRoute)
+            : null;
+        const fromRouteName = (_a = fromServiceRouteInfo === null || fromServiceRouteInfo === void 0 ? void 0 : fromServiceRouteInfo.name) !== null && _a !== void 0 ? _a : `Route ${String(fromEdge.routeId)}`;
+        const toRouteName = (_b = toServiceRouteInfo === null || toServiceRouteInfo === void 0 ? void 0 : toServiceRouteInfo.name) !== null && _b !== void 0 ? _b : `Route ${String(toEdge.routeId)}`;
+        const fromRouteType = (fromServiceRouteInfo === null || fromServiceRouteInfo === void 0 ? void 0 : fromServiceRouteInfo.type) || 'UNKNOWN';
+        const toRouteType = (toServiceRouteInfo === null || toServiceRouteInfo === void 0 ? void 0 : toServiceRouteInfo.type) || 'UNKNOWN';
+        const fromArrivalTime = fromEdge.arrival.toString();
+        const toDepartureTime = toRoute
+            ? toRoute.departureFrom(toEdge.from, toEdge.tripIndex).toString()
+            : 'N/A';
+        const escapedFromRouteName = this.escapeDotString(fromRouteName);
+        const escapedToRouteName = this.escapeDotString(toRouteName);
+        const escapedFromRouteType = this.escapeDotString(fromRouteType);
+        const escapedToRouteType = this.escapeDotString(toRouteType);
+        const fromRouteInfo = `${fromEdge.routeId}:${fromEdge.tripIndex}`;
+        const toRouteInfo = `${toEdge.routeId}:${toEdge.tripIndex}`;
+        const ovalLabel = `${escapedFromRouteType} ${escapedFromRouteName} (${fromRouteInfo}) ${fromArrivalTime}\\n↓\\n${escapedToRouteType} ${escapedToRouteName} (${toRouteInfo}) ${toDepartureTime}`;
+        return [
+            `  "${continuationOvalId}" [label="${ovalLabel}" shape=oval style="filled,bold" fillcolor="#ffffcc" color="${roundColor}" penwidth="2"];`,
+            `  "${fromStationId}" -> "${continuationOvalId}" [color="${roundColor}" style="bold" penwidth="3"];`,
+            `  "${continuationOvalId}" -> "${toStationId}" [color="${roundColor}" style="bold" penwidth="3"];`,
+        ];
+    }
+    /**
+     * Collects all stations and edges for the graph.
+     */
+    collectGraphData() {
+        const stations = new Set();
+        const edges = [];
+        const continuationEdges = [];
+        const graph = this.result.routingState.graph;
+        // Collect all stops that appear in the graph
+        graph.forEach((roundMap) => {
+            roundMap.forEach((edge, stopId) => {
+                stations.add(stopId);
+                if ('from' in edge && 'to' in edge) {
+                    stations.add(edge.from);
+                    stations.add(edge.to);
                 }
             });
         });
+        // Create edges for each round
+        graph.forEach((roundMap, round) => {
+            if (round === 0) {
+                // Skip round 0 as it contains only origin nodes
+                return;
+            }
+            roundMap.forEach((edge) => {
+                if ('from' in edge && 'to' in edge) {
+                    if ('routeId' in edge) {
+                        const vehicleEdgeParts = this.createVehicleEdge(edge, round);
+                        edges.push(...vehicleEdgeParts);
+                        if (edge.continuationOf) {
+                            let currentEdge = edge;
+                            let previousEdge = edge.continuationOf;
+                            while (previousEdge) {
+                                const continuationEdgeParts = this.createContinuationEdge(previousEdge, currentEdge, round);
+                                continuationEdges.push(...continuationEdgeParts);
+                                currentEdge = previousEdge;
+                                previousEdge = previousEdge.continuationOf;
+                            }
+                        }
+                    }
+                    else {
+                        const transferEdgeParts = this.createTransferEdge(edge, round);
+                        edges.push(...transferEdgeParts);
+                    }
+                }
+            });
+        });
+        edges.push(...continuationEdges);
+        return { stations, edges };
+    }
+    /**
+     * Plots the routing graph as a DOT graph for visualization.
+     */
+    plotDotGraph() {
+        const { stations, edges } = this.collectGraphData();
+        const dotParts = [
+            'digraph RoutingGraph {',
+            '  graph [overlap=false, splines=true, rankdir=TB, bgcolor=white, nodesep=0.8, ranksep=1.2, concentrate=true];',
+            '  node [fontname="Arial" margin=0.1];',
+            '  edge [fontname="Arial" fontsize=10];',
+            '',
+            '  // Stations',
+        ];
+        stations.forEach((stopId) => {
+            const stationNode = this.createStationNode(stopId);
+            if (stationNode) {
+                dotParts.push(stationNode);
+            }
+        });
+        dotParts.push('', '  // Edges');
+        dotParts.push(...edges);
         dotParts.push('}');
         return dotParts.join('\n');
     }
@@ -20727,11 +21339,11 @@ class Route {
 }
 
 class Result {
-    constructor(query, earliestArrivals, earliestArrivalsPerRound, stopsIndex) {
+    constructor(query, routingState, stopsIndex, timetable) {
         this.query = query;
-        this.earliestArrivals = earliestArrivals;
-        this.earliestArrivalsPerRound = earliestArrivalsPerRound;
+        this.routingState = routingState;
         this.stopsIndex = stopsIndex;
+        this.timetable = timetable;
     }
     /**
      * Reconstructs the best route to a stop.
@@ -20741,17 +21353,18 @@ class Result {
      * @returns a route to the destination stop if it exists.
      */
     bestRoute(to) {
-        var _a, _b, _c;
+        var _a;
         const destinationList = to instanceof Set
             ? Array.from(to)
             : to
                 ? [to]
                 : Array.from(this.query.to);
         const destinations = destinationList.flatMap((destination) => this.stopsIndex.equivalentStops(destination));
+        // find the first reached destination
         let fastestDestination = undefined;
         let fastestTime = undefined;
         for (const destination of destinations) {
-            const arrivalTime = this.earliestArrivals.get(destination.id);
+            const arrivalTime = this.routingState.earliestArrivals.get(destination.id);
             if (arrivalTime !== undefined) {
                 if (fastestTime === undefined ||
                     arrivalTime.arrival.isBefore(fastestTime.arrival)) {
@@ -20766,19 +21379,84 @@ class Result {
         const route = [];
         let currentStop = fastestDestination;
         let round = fastestTime.legNumber;
-        while (fastestTime.origin !== currentStop) {
-            const tripLeg = (_a = this.earliestArrivalsPerRound[round]) === null || _a === void 0 ? void 0 : _a.get(currentStop);
-            if (!(tripLeg === null || tripLeg === void 0 ? void 0 : tripLeg.leg)) {
-                throw new Error(`No leg found for a trip leg: start stop=${(_c = (_b = tripLeg === null || tripLeg === void 0 ? void 0 : tripLeg.leg) === null || _b === void 0 ? void 0 : _b.from.id) !== null && _c !== void 0 ? _c : 'unknown'}, end stop=${currentStop}, round=${round}, origin=${fastestTime.origin}`);
+        while (round > 0) {
+            const edge = (_a = this.routingState.graph[round]) === null || _a === void 0 ? void 0 : _a.get(currentStop);
+            if (!edge) {
+                throw new Error(`No edge arriving at stop ${currentStop} at round ${round}`);
+            }
+            let leg;
+            if ('routeId' in edge) {
+                let vehicleEdge = edge;
+                // Handle leg reconstruction for in-seat trip continuations
+                const chainedEdges = [vehicleEdge];
+                while ('routeId' in vehicleEdge && vehicleEdge.continuationOf) {
+                    chainedEdges.push(vehicleEdge.continuationOf);
+                    vehicleEdge = vehicleEdge.continuationOf;
+                }
+                leg = this.buildVehicleLeg(chainedEdges);
+            }
+            else if ('type' in edge) {
+                leg = this.buildTransferLeg(edge);
+            }
+            else {
+                break;
             }
-            route.unshift(tripLeg.leg);
-            currentStop = tripLeg.leg.from.id;
-            if ('route' in tripLeg.leg) {
+            route.unshift(leg);
+            currentStop = leg.from.id;
+            if ('routeId' in edge) {
                 round -= 1;
             }
         }
         return new Route(route);
     }
+    /**
+     * Builds a vehicle leg from a chain of vehicle edges.
+     *
+     * @param edges Array of vehicle edges representing continuous trips on transit vehicles
+     * @returns A vehicle leg with departure/arrival information and route details
+     * @throws Error if the edges array is empty
+     */
+    buildVehicleLeg(edges) {
+        if (edges.length === 0) {
+            throw new Error('Cannot build vehicle leg from empty edges');
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const firstEdge = edges[edges.length - 1];
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const lastEdge = edges[0];
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const firstRoute = this.timetable.getRoute(firstEdge.routeId);
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const lastRoute = this.timetable.getRoute(lastEdge.routeId);
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            from: this.stopsIndex.findStopById(firstEdge.from),
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            to: this.stopsIndex.findStopById(lastEdge.to),
+            // The route info comes from the first boarded route in case on continuous trips
+            route: this.timetable.getServiceRouteInfo(firstRoute),
+            departureTime: firstRoute.departureFrom(firstEdge.from, firstEdge.tripIndex),
+            arrivalTime: lastEdge.arrival,
+            pickUpType: firstRoute.pickUpTypeFrom(firstEdge.from, firstEdge.tripIndex),
+            dropOffType: lastRoute.dropOffTypeAt(lastEdge.to, lastEdge.tripIndex),
+        };
+    }
+    /**
+     * Builds a transfer leg from a transfer edge.
+     *
+     * @param edge Transfer edge representing a walking connection between stops
+     * @returns A transfer leg with from/to stops and transfer details
+     */
+    buildTransferLeg(edge) {
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            from: this.stopsIndex.findStopById(edge.from),
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            to: this.stopsIndex.findStopById(edge.to),
+            minTransferTime: edge.minTransferTime,
+            type: edge.type,
+        };
+    }
     /**
      * Returns the arrival time at any stop reachable in less time / transfers than the destination(s) of the query)
      *
@@ -20787,14 +21465,28 @@ class Result {
      * @returns The arrival time if the target stop is reachable, otherwise undefined.
      */
     arrivalAt(stop, maxTransfers) {
+        var _a;
         const equivalentStops = this.stopsIndex.equivalentStops(stop);
         let earliestArrival = undefined;
-        const relevantArrivals = maxTransfers !== undefined
-            ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                this.earliestArrivalsPerRound[maxTransfers + 1]
-            : this.earliestArrivals;
         for (const equivalentStop of equivalentStops) {
-            const arrivalTime = relevantArrivals.get(equivalentStop.id);
+            let arrivalTime;
+            if (maxTransfers === undefined) {
+                arrivalTime = this.routingState.earliestArrivals.get(equivalentStop.id);
+            }
+            else {
+                // We have no guarantee that the stop was visited in the last round,
+                // so we need to check all rounds if it's not found in the last one.
+                for (let i = maxTransfers + 1; i >= 0; i--) {
+                    const arrivalEdge = (_a = this.routingState.graph[i]) === null || _a === void 0 ? void 0 : _a.get(equivalentStop.id);
+                    if (arrivalEdge !== undefined) {
+                        arrivalTime = {
+                            arrival: arrivalEdge.arrival,
+                            legNumber: i,
+                        };
+                        break;
+                    }
+                }
+            }
             if (arrivalTime !== undefined) {
                 if (earliestArrival === undefined ||
                     arrivalTime.arrival.isBefore(earliestArrival.arrival)) {
@@ -20808,9 +21500,9 @@ class Result {
 
 const UNREACHED = Time.infinity();
 /**
- * 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
  */
 class Router {
@@ -20819,25 +21511,227 @@ class Router {
         this.stopsIndex = stopsIndex;
     }
     /**
-     * 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) {
+        const routingState = this.initRoutingState(query);
+        const markedStops = new Set();
+        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();
+            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, hopOnStop] of reachableRoutes) {
+                const newlyMarkedStops = this.scanRoute(route, hopOnStop, 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 = new Set();
+                for (const continuation of continuations) {
+                    const route = this.timetable.getRoute(continuation.routeId);
+                    const routeScanResults = this.scanRoute(route, continuation.hopOnStop, 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.
      */
-    considerTransfers(query, markedStops, arrivalsAtCurrentRound, earliestArrivals, round) {
+    findTripContinuations(markedStops, edgesAtCurrentRound) {
+        const continuations = [];
+        for (const stopId of markedStops) {
+            const arrival = edgesAtCurrentRound.get(stopId);
+            if (!arrival || !('routeId' in arrival))
+                continue;
+            const continuousTrips = this.timetable.getContinuousTrips(stopId, arrival.routeId, arrival.tripIndex);
+            for (let i = 0; i < continuousTrips.length; i++) {
+                const trip = continuousTrips[i];
+                continuations.push({
+                    routeId: trip.routeId,
+                    hopOnStop: trip.hopOnStop,
+                    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
+     */
+    initRoutingState(query) {
+        const { from, to, departureTime } = query;
+        // Consider children or siblings of the "from" stop as potential origins
+        const origins = this.stopsIndex
+            .equivalentStops(from)
+            .map((origin) => origin.id);
+        // Consider children or siblings of the "to" stop(s) as potential destinations
+        const destinations = Array.from(to)
+            .flatMap((destination) => this.stopsIndex.equivalentStops(destination))
+            .map((destination) => destination.id);
+        const earliestArrivals = new Map();
+        const earliestArrivalsWithoutAnyLeg = new Map();
+        const earliestArrivalsPerRound = [earliestArrivalsWithoutAnyLeg];
+        const initialState = {
+            arrival: departureTime,
+            legNumber: 0,
+        };
+        for (const originStop of origins) {
+            earliestArrivals.set(originStop, initialState);
+            earliestArrivalsWithoutAnyLeg.set(originStop, initialState);
+        }
+        return {
+            destinations,
+            earliestArrivals,
+            graph: earliestArrivalsPerRound,
+        };
+    }
+    /**
+     * 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 hopOnStop The stop ID 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
+     */
+    scanRoute(route, hopOnStop, round, routingState, tripContinuation) {
+        var _a, _b, _c;
+        const newlyMarkedStops = new Set();
+        let activeTrip = tripContinuation
+            ? {
+                routeId: route.id,
+                hopOnStop,
+                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];
+            // 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 dropOffType = route.dropOffTypeAt(currentStop, activeTrip.tripIndex);
+                const earliestArrivalAtCurrentStop = (_b = (_a = routingState.earliestArrivals.get(currentStop)) === null || _a === void 0 ? void 0 : _a.arrival) !== null && _b !== void 0 ? _b : UNREACHED;
+                if (dropOffType !== 'NOT_AVAILABLE' &&
+                    arrivalTime.isBefore(earliestArrivalAtCurrentStop) &&
+                    arrivalTime.isBefore(earliestArrivalAtAnyDestination)) {
+                    const edge = {
+                        arrival: arrivalTime,
+                        routeId: route.id,
+                        tripIndex: activeTrip.tripIndex,
+                        from: activeTrip.hopOnStop,
+                        to: currentStop,
+                    };
+                    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 = (_c = edgesAtPreviousRound.get(currentStop)) === null || _c === void 0 ? void 0 : _c.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(currentStop, activeTrip.tripIndex)) ||
+                    earliestArrivalOnPreviousRound.equals(route.departureFrom(currentStop, activeTrip.tripIndex)))) {
+                const earliestTrip = route.findEarliestTrip(currentStop, earliestArrivalOnPreviousRound, activeTrip === null || activeTrip === void 0 ? void 0 : activeTrip.tripIndex);
+                if (earliestTrip !== undefined) {
+                    activeTrip = {
+                        routeId: route.id,
+                        tripIndex: earliestTrip,
+                        hopOnStop: currentStop,
+                    };
+                }
+            }
+        }
+        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
+     */
+    considerTransfers(query, round, markedStops, routingState) {
         var _a, _b;
         const { options } = query;
+        const arrivalsAtCurrentRound = routingState.graph[round];
         const newlyMarkedStops = 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)) {
+            if (!currentArrival || 'type' in currentArrival)
                 continue;
-            }
             const transfers = this.timetable.getTransfers(stop);
             for (let j = 0; j < transfers.length; j++) {
                 const transfer = transfers[j];
@@ -20846,6 +21740,7 @@ class Router {
                     transferTime = transfer.minTransferTime;
                 }
                 else if (transfer.type === 'IN_SEAT') {
+                    // TODO not needed anymore now that trip continuations are handled separately
                     transferTime = Duration.zero();
                 }
                 else {
@@ -20854,32 +21749,22 @@ class Router {
                 const arrivalAfterTransfer = currentArrival.arrival.plus(transferTime);
                 const originalArrival = (_b = (_a = arrivalsAtCurrentRound.get(transfer.destination)) === null || _a === void 0 ? void 0 : _a.arrival) !== null && _b !== void 0 ? _b : 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;
     }
     /**
      * Finds the earliest arrival time at any stop from a given set of destinations.
@@ -20893,117 +21778,11 @@ class Router {
         let earliestArrivalAtAnyDestination = UNREACHED;
         for (let i = 0; i < destinations.length; i++) {
             const destination = destinations[i];
-            const arrival = (_b = (_a = earliestArrivals.get(destination.id)) === null || _a === void 0 ? void 0 : _a.arrival) !== null && _b !== void 0 ? _b : UNREACHED;
+            const arrival = (_b = (_a = earliestArrivals.get(destination)) === null || _a === void 0 ? void 0 : _a.arrival) !== null && _b !== void 0 ? _b : UNREACHED;
             earliestArrivalAtAnyDestination = Time.min(earliestArrivalAtAnyDestination, arrival);
         }
         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) {
-        var _a, _b, _c, _d, _e;
-        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();
-        const earliestArrivalsWithoutAnyLeg = new Map();
-        const earliestArrivalsPerRound = [earliestArrivalsWithoutAnyLeg];
-        // Stops that have been improved at round k-1
-        const markedStops = new Set();
-        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();
-            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 = 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 = (_b = (_a = earliestArrivals.get(currentStop)) === null || _a === void 0 ? void 0 : _a.arrival) !== null && _b !== void 0 ? _b : 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 = (_c = arrivalsAtPreviousRound.get(currentStop)) === null || _c === void 0 ? void 0 : _c.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 === null || currentTrip === void 0 ? void 0 : 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: (_e = (_d = arrivalsAtPreviousRound.get(currentStop)) === null || _d === void 0 ? void 0 : _d.origin) !== null && _e !== void 0 ? _e : currentStop,
-                            };
-                        }
-                    }
-                }
-            }
-            this.considerTransfers(query, markedStops, arrivalsAtCurrentRound, earliestArrivals, round);
-            if (markedStops.size === 0)
-                break;
-        }
-        return new Result(query, earliestArrivals, earliestArrivalsPerRound, this.stopsIndex);
-    }
 }
 
 /**
@@ -21140,7 +21919,6 @@ const startRepl = (stopsPath, timetablePath) => {
     replServer.defineCommand('route', {
         help: 'Find a route using .route from <stationIdOrName> to <stationIdOrName> at <HH:mm> [with <N> transfers]',
         action(routeQuery) {
-            var _a;
             this.clearBufferedCommand();
             const parts = routeQuery.split(' ').filter(Boolean);
             const withTransfersIndex = parts.indexOf('with');
@@ -21196,12 +21974,13 @@ const startRepl = (stopsPath, timetablePath) => {
                     console.log(`Destination not reachable`);
                 }
                 else {
-                    console.log(`Arriving to ${toStop.name} at ${arrivalTime.arrival.toString()} with ${arrivalTime.legNumber - 1} transfers from ${(_a = stopsIndex.findStopById(arrivalTime.origin)) === null || _a === void 0 ? void 0 : _a.name}.`);
+                    console.log(`Arriving to ${toStop.name} at ${arrivalTime.arrival.toString()} with ${arrivalTime.legNumber - 1} transfers from ${fromStop.name}.`);
                 }
                 const bestRoute = result.bestRoute(toStop.sourceStopId);
                 if (bestRoute) {
                     console.log(`Found route from ${fromStop.name} to ${toStop.name}:`);
                     console.log(bestRoute.toString());
+                    console.log(bestRoute.asJson());
                 }
                 else {
                     console.log('No route found');
@@ -21277,6 +22056,203 @@ const startRepl = (stopsPath, timetablePath) => {
             this.displayPrompt();
         },
     });
+    const formatPickupDropoffType = (type) => {
+        switch (type) {
+            case 'REGULAR':
+                return 'R';
+            case 'NOT_AVAILABLE':
+                return 'N';
+            case 'MUST_PHONE_AGENCY':
+                return 'A';
+            case 'MUST_COORDINATE_WITH_DRIVER':
+                return 'D';
+            default:
+                return '?';
+        }
+    };
+    replServer.defineCommand('inspect', {
+        help: 'Inspect a route or stop using .inspect route <routeId> or .inspect stop <stopId>',
+        action(inspectQuery) {
+            this.clearBufferedCommand();
+            const parts = inspectQuery.trim().split(' ');
+            if (parts.length !== 2) {
+                console.log('Usage: .inspect route <routeId> or .inspect stop <stopId>');
+                this.displayPrompt();
+                return;
+            }
+            const [type, idStr] = parts;
+            if (type !== 'route' && type !== 'stop') {
+                console.log('Usage: .inspect route <routeId> or .inspect stop <stopId>');
+                this.displayPrompt();
+                return;
+            }
+            const inspectRoute = (routeIdStr) => {
+                var _a, _b, _c;
+                const routeId = parseInt(routeIdStr.trim());
+                if (isNaN(routeId)) {
+                    console.log('Usage: .inspect route <routeId>');
+                    return;
+                }
+                const route = timetable.getRoute(routeId);
+                if (!route) {
+                    console.log(`Route ${routeId} not found`);
+                    return;
+                }
+                const serviceRouteInfo = timetable.getServiceRouteInfo(route);
+                const routeName = serviceRouteInfo.name;
+                const routeType = serviceRouteInfo.type;
+                console.log(`\n=== Route ${routeId} ===`);
+                console.log(`Service Route: ${routeName}`);
+                console.log(`Type: ${routeType}`);
+                console.log(`Number of stops: ${route.getNbStops()}`);
+                console.log(`Number of trips: ${route.getNbTrips()}`);
+                console.log('\n--- Stops ---');
+                for (let i = 0; i < route.stops.length; i++) {
+                    const stopId = route.stopId(i);
+                    const stop = stopsIndex.findStopById(stopId);
+                    const platform = (stop === null || stop === void 0 ? void 0 : stop.platform) ? ` (Pl. ${stop.platform})` : '';
+                    console.log(`${i + 1}. ${(_a = stop === null || stop === void 0 ? void 0 : stop.name) !== null && _a !== void 0 ? _a : 'Unknown'}${platform} (${stopId}, ${(_b = stop === null || stop === void 0 ? void 0 : stop.sourceStopId) !== null && _b !== void 0 ? _b : 'N/A'})`);
+                }
+                console.log('\n--- Trips ---');
+                for (let tripIndex = 0; tripIndex < route.getNbTrips(); tripIndex++) {
+                    console.log(`\nTrip ${tripIndex}:`);
+                    for (let stopIndex = 0; stopIndex < route.stops.length; stopIndex++) {
+                        const stopId = route.stopId(stopIndex);
+                        const stop = stopsIndex.findStopById(stopId);
+                        const departure = route.departureFrom(stopId, tripIndex);
+                        const arrival = route.arrivalAt(stopId, tripIndex);
+                        const pickupType = route.pickUpTypeFrom(stopId, tripIndex);
+                        const dropOffType = route.dropOffTypeAt(stopId, tripIndex);
+                        const pickupStr = formatPickupDropoffType(pickupType);
+                        const dropOffStr = formatPickupDropoffType(dropOffType);
+                        console.log(`  ${stopIndex + 1}. ${(_c = stop === null || stop === void 0 ? void 0 : stop.name) !== null && _c !== void 0 ? _c : 'Unknown'}: arr ${arrival.toString()} (${pickupStr}) → dep ${departure.toString()} (${dropOffStr})`);
+                    }
+                }
+                console.log();
+            };
+            const inspectStop = (stopIdStr) => {
+                var _a, _b, _c;
+                let stop;
+                const stopBySourceId = stopsIndex.findStopBySourceStopId(stopIdStr);
+                if (stopBySourceId !== undefined) {
+                    stop = stopBySourceId;
+                }
+                else if (!isNaN(Number(stopIdStr))) {
+                    const stopById = stopsIndex.findStopById(Number(stopIdStr));
+                    if (stopById !== undefined) {
+                        stop = stopById;
+                    }
+                }
+                else {
+                    const stops = stopsIndex.findStopsByName(stopIdStr);
+                    if (stops.length > 0) {
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                        stop = stops[0];
+                    }
+                }
+                if (!stop) {
+                    console.log(`Stop not found: ${stopIdStr}`);
+                    return;
+                }
+                console.log(`\n=== Stop ${stop.id} ===`);
+                console.log(`Name: ${stop.name}`);
+                if (stop.platform) {
+                    console.log(`Platform: ${stop.platform}`);
+                }
+                console.log(`Source ID: ${stop.sourceStopId}`);
+                const routes = timetable.routesPassingThrough(stop.id);
+                console.log(`Number of routes: ${routes.length}`);
+                const equivalentStops = stopsIndex
+                    .equivalentStops(stop.sourceStopId)
+                    .filter((equivStop) => equivStop.id !== stop.id);
+                console.log(`Number of equivalent stops: ${equivalentStops.length}`);
+                if (equivalentStops.length > 0) {
+                    console.log('\n--- Equivalent Stops ---');
+                    equivalentStops.forEach((equivStop, index) => {
+                        const platform = equivStop.platform
+                            ? ` (Pl. ${equivStop.platform})`
+                            : '';
+                        console.log(`${index + 1}. ${equivStop.name}${platform} (${equivStop.id}, ${equivStop.sourceStopId})`);
+                    });
+                }
+                if (routes.length > 0) {
+                    console.log('\n--- Routes ---');
+                    routes.forEach((route, index) => {
+                        const serviceRouteInfo = timetable.getServiceRouteInfo(route);
+                        console.log(`${index + 1}. Route ${route.id}: ${serviceRouteInfo.name} (${serviceRouteInfo.type})`);
+                    });
+                }
+                const transfers = timetable.getTransfers(stop.id);
+                console.log(`Number of transfers: ${transfers.length}`);
+                if (transfers.length > 0) {
+                    console.log('\n--- Transfers ---');
+                    transfers.forEach((transfer, index) => {
+                        var _a, _b;
+                        const destStop = stopsIndex.findStopById(transfer.destination);
+                        const platform = (destStop === null || destStop === void 0 ? void 0 : destStop.platform)
+                            ? ` (Pl. ${destStop.platform})`
+                            : '';
+                        const minTime = transfer.minTransferTime
+                            ? ` (min: ${Math.floor(transfer.minTransferTime.toSeconds() / 60)}min)`
+                            : '';
+                        console.log(`${index + 1}. ${transfer.type} to ${(_a = destStop === null || destStop === void 0 ? void 0 : destStop.name) !== null && _a !== void 0 ? _a : 'Unknown'}${platform} (${transfer.destination}, ${(_b = destStop === null || destStop === void 0 ? void 0 : destStop.sourceStopId) !== null && _b !== void 0 ? _b : 'N/A'})${minTime}`);
+                    });
+                }
+                let totalContinuations = 0;
+                const continuationsByTrip = new Map();
+                routes.forEach((route) => {
+                    for (let tripIndex = 0; tripIndex < route.getNbTrips(); tripIndex++) {
+                        const continuations = timetable.getContinuousTrips(stop.id, route.id, tripIndex);
+                        if (continuations.length > 0) {
+                            totalContinuations += continuations.length;
+                            const tripKey = `${route.id}-${tripIndex}`;
+                            continuationsByTrip.set(tripKey, {
+                                route,
+                                tripIndex,
+                                continuations,
+                            });
+                        }
+                    }
+                });
+                console.log(`Number of trip continuations: ${totalContinuations}`);
+                if (totalContinuations > 0) {
+                    console.log('\n--- Trip Continuations ---');
+                    let continuationIndex = 1;
+                    for (const [, value] of continuationsByTrip) {
+                        const { route, tripIndex, continuations } = value;
+                        const serviceRouteInfo = timetable.getServiceRouteInfo(route);
+                        for (const continuation of continuations) {
+                            const destStop = stopsIndex.findStopById(continuation.hopOnStop);
+                            const destPlatform = (destStop === null || destStop === void 0 ? void 0 : destStop.platform)
+                                ? ` (Pl. ${destStop.platform})`
+                                : '';
+                            const destRoute = timetable.getRoute(continuation.routeId);
+                            const destServiceRouteInfo = destRoute
+                                ? timetable.getServiceRouteInfo(destRoute)
+                                : null;
+                            const originTime = route.departureFrom(stop.id, tripIndex);
+                            const continuationTime = destRoute === null || destRoute === void 0 ? void 0 : destRoute.departureFrom(continuation.hopOnStop, continuation.tripIndex);
+                            const continuationTimeStr = continuationTime
+                                ? ` at ${continuationTime.toString()}`
+                                : '';
+                            console.log(`${continuationIndex}. From Route ${route.id} (${serviceRouteInfo.name}) Trip ${tripIndex} at ${originTime.toString()} → ` +
+                                `Route ${continuation.routeId} (${(_a = destServiceRouteInfo === null || destServiceRouteInfo === void 0 ? void 0 : destServiceRouteInfo.name) !== null && _a !== void 0 ? _a : 'Unknown'}) Trip ${continuation.tripIndex}${continuationTimeStr} ` +
+                                `at ${(_b = destStop === null || destStop === void 0 ? void 0 : destStop.name) !== null && _b !== void 0 ? _b : 'Unknown'}${destPlatform} (${continuation.hopOnStop}, ${(_c = destStop === null || destStop === void 0 ? void 0 : destStop.sourceStopId) !== null && _c !== void 0 ? _c : 'N/A'})`);
+                            continuationIndex++;
+                        }
+                    }
+                }
+                console.log();
+            };
+            if (type === 'route') {
+                inspectRoute(idStr !== null && idStr !== void 0 ? idStr : '');
+            }
+            else {
+                inspectStop(idStr !== null && idStr !== void 0 ? idStr : '');
+            }
+            this.displayPrompt();
+        },
+    });
 };
 
 const program = new Command();