minotor 1.0.7 → 2.0.1

package/dist/cli.mjs

@@ -13430,7 +13430,6 @@ var StreamZip = /*@__PURE__*/getDefaultExportFromCjs(node_stream_zipExports);
 // of the input file used when generating it.  This code is not
 // standalone and requires a support library to be linked with it.  This
 // support library is itself covered by the above license.
-/* eslint-disable prefer-const,@typescript-eslint/restrict-plus-operands */
 /**
  * Read a 64 bit varint as two JS numbers.
  *
@@ -13713,7 +13712,7 @@ function varint32read() {
     return result >>> 0;
 }
 
-// Copyright 2021-2024 Buf Technologies, Inc.
+// Copyright 2021-2025 Buf Technologies, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -13742,7 +13741,10 @@ function makeInt64Support() {
             typeof process.env != "object" ||
             process.env.BUF_BIGINT_DISABLE !== "1");
     if (ok) {
-        const MIN = BigInt("-9223372036854775808"), MAX = BigInt("9223372036854775807"), UMIN = BigInt("0"), UMAX = BigInt("18446744073709551615");
+        const MIN = BigInt("-9223372036854775808");
+        const MAX = BigInt("9223372036854775807");
+        const UMIN = BigInt("0");
+        const UMAX = BigInt("18446744073709551615");
         return {
             zero: BigInt(0),
             supported: true,
@@ -13836,7 +13838,7 @@ function assertUInt64String(value) {
     }
 }
 
-// Copyright 2021-2024 Buf Technologies, Inc.
+// Copyright 2021-2025 Buf Technologies, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -13866,7 +13868,7 @@ function getTextEncoding() {
                     encodeURIComponent(text);
                     return true;
                 }
-                catch (e) {
+                catch (_) {
                     return false;
                 }
             },
@@ -13875,7 +13877,7 @@ function getTextEncoding() {
     return globalThis[symbol];
 }
 
-// Copyright 2021-2024 Buf Technologies, Inc.
+// Copyright 2021-2025 Buf Technologies, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -13888,7 +13890,6 @@ function getTextEncoding() {
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-/* eslint-disable prefer-const,no-case-declarations,@typescript-eslint/restrict-plus-operands */
 /**
  * Protobuf binary format wire types.
  *
@@ -14149,7 +14150,7 @@ class BinaryWriter {
      * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
      */
     sint64(value) {
-        let tc = protoInt64.enc(value), 
+        const tc = protoInt64.enc(value), 
         // zigzag encode
         sign = tc.hi >> 31, lo = (tc.lo << 1) ^ sign, hi = ((tc.hi << 1) | (tc.lo >>> 31)) ^ sign;
         varint64write(lo, hi, this.buf);
@@ -14159,7 +14160,7 @@ class BinaryWriter {
      * Write a `uint64` value, an unsigned 64-bit varint.
      */
     uint64(value) {
-        let tc = protoInt64.uEnc(value);
+        const tc = protoInt64.uEnc(value);
         varint64write(tc.lo, tc.hi, this.buf);
         return this;
     }
@@ -14200,11 +14201,9 @@ class BinaryReader {
                     // ignore
                 }
                 break;
-            // eslint-disable-next-line
             // @ts-expect-error TS7029: Fallthrough case in switch
             case WireType.Bit64:
                 this.pos += 4;
-            // eslint-disable-next-line no-fallthrough
             case WireType.Bit32:
                 this.pos += 4;
                 break;
@@ -14285,12 +14284,14 @@ class BinaryReader {
      * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
      */
     fixed32() {
+        // biome-ignore lint/suspicious/noAssignInExpressions: no
         return this.view.getUint32((this.pos += 4) - 4, true);
     }
     /**
      * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
      */
     sfixed32() {
+        // biome-ignore lint/suspicious/noAssignInExpressions: no
         return this.view.getInt32((this.pos += 4) - 4, true);
     }
     /**
@@ -14309,12 +14310,14 @@ class BinaryReader {
      * Read a `float` field, 32-bit floating point number.
      */
     float() {
+        // biome-ignore lint/suspicious/noAssignInExpressions: no
         return this.view.getFloat32((this.pos += 4) - 4, true);
     }
     /**
      * Read a `double` field, a 64-bit floating point number.
      */
     double() {
+        // biome-ignore lint/suspicious/noAssignInExpressions: no
         return this.view.getFloat64((this.pos += 8) - 8, true);
     }
     /**
@@ -14370,7 +14373,7 @@ function assertFloat32(arg) {
     if (typeof arg == "string") {
         const o = arg;
         arg = Number(arg);
-        if (isNaN(arg) && o !== "NaN") {
+        if (Number.isNaN(arg) && o !== "NaN") {
             throw new Error("invalid float32: " + o);
         }
     }
@@ -15045,6 +15048,7 @@ function locationTypeToJSON(object) {
 function createBaseStop() {
     return {
         name: "",
+        sourceStopId: "",
         lat: undefined,
         lon: undefined,
         children: [],
@@ -15058,23 +15062,28 @@ const Stop = {
         if (message.name !== "") {
             writer.uint32(10).string(message.name);
         }
+        if (message.sourceStopId !== "") {
+            writer.uint32(18).string(message.sourceStopId);
+        }
         if (message.lat !== undefined) {
-            writer.uint32(17).double(message.lat);
+            writer.uint32(25).double(message.lat);
         }
         if (message.lon !== undefined) {
-            writer.uint32(25).double(message.lon);
+            writer.uint32(33).double(message.lon);
         }
+        writer.uint32(42).fork();
         for (const v of message.children) {
-            writer.uint32(34).string(v);
+            writer.uint32(v);
         }
+        writer.join();
         if (message.parent !== undefined) {
-            writer.uint32(42).string(message.parent);
+            writer.uint32(48).uint32(message.parent);
         }
         if (message.locationType !== 0) {
-            writer.uint32(48).int32(message.locationType);
+            writer.uint32(56).int32(message.locationType);
         }
         if (message.platform !== undefined) {
-            writer.uint32(58).string(message.platform);
+            writer.uint32(66).string(message.platform);
         }
         return writer;
     },
@@ -15093,42 +15102,56 @@ const Stop = {
                     continue;
                 }
                 case 2: {
-                    if (tag !== 17) {
+                    if (tag !== 18) {
                         break;
                     }
-                    message.lat = reader.double();
+                    message.sourceStopId = reader.string();
                     continue;
                 }
                 case 3: {
                     if (tag !== 25) {
                         break;
                     }
-                    message.lon = reader.double();
+                    message.lat = reader.double();
                     continue;
                 }
                 case 4: {
-                    if (tag !== 34) {
+                    if (tag !== 33) {
                         break;
                     }
-                    message.children.push(reader.string());
+                    message.lon = reader.double();
                     continue;
                 }
                 case 5: {
-                    if (tag !== 42) {
-                        break;
+                    if (tag === 40) {
+                        message.children.push(reader.uint32());
+                        continue;
                     }
-                    message.parent = reader.string();
-                    continue;
+                    if (tag === 42) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.children.push(reader.uint32());
+                        }
+                        continue;
+                    }
+                    break;
                 }
                 case 6: {
                     if (tag !== 48) {
                         break;
                     }
-                    message.locationType = reader.int32();
+                    message.parent = reader.uint32();
                     continue;
                 }
                 case 7: {
-                    if (tag !== 58) {
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.locationType = reader.int32();
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 66) {
                         break;
                     }
                     message.platform = reader.string();
@@ -15145,10 +15168,11 @@ const Stop = {
     fromJSON(object) {
         return {
             name: isSet$1(object.name) ? globalThis.String(object.name) : "",
+            sourceStopId: isSet$1(object.sourceStopId) ? globalThis.String(object.sourceStopId) : "",
             lat: isSet$1(object.lat) ? globalThis.Number(object.lat) : undefined,
             lon: isSet$1(object.lon) ? globalThis.Number(object.lon) : undefined,
-            children: globalThis.Array.isArray(object === null || object === undefined ? undefined : object.children) ? object.children.map((e) => globalThis.String(e)) : [],
-            parent: isSet$1(object.parent) ? globalThis.String(object.parent) : undefined,
+            children: globalThis.Array.isArray(object === null || object === undefined ? undefined : object.children) ? object.children.map((e) => globalThis.Number(e)) : [],
+            parent: isSet$1(object.parent) ? globalThis.Number(object.parent) : undefined,
             locationType: isSet$1(object.locationType) ? locationTypeFromJSON(object.locationType) : 0,
             platform: isSet$1(object.platform) ? globalThis.String(object.platform) : undefined,
         };
@@ -15159,6 +15183,9 @@ const Stop = {
         if (message.name !== "") {
             obj.name = message.name;
         }
+        if (message.sourceStopId !== "") {
+            obj.sourceStopId = message.sourceStopId;
+        }
         if (message.lat !== undefined) {
             obj.lat = message.lat;
         }
@@ -15166,10 +15193,10 @@ const Stop = {
             obj.lon = message.lon;
         }
         if ((_a = message.children) === null || _a === undefined ? undefined : _a.length) {
-            obj.children = message.children;
+            obj.children = message.children.map((e) => Math.round(e));
         }
         if (message.parent !== undefined) {
-            obj.parent = message.parent;
+            obj.parent = Math.round(message.parent);
         }
         if (message.locationType !== 0) {
             obj.locationType = locationTypeToJSON(message.locationType);
@@ -15183,15 +15210,16 @@ const Stop = {
         return Stop.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         const message = createBaseStop();
         message.name = (_a = object.name) !== null && _a !== undefined ? _a : "";
-        message.lat = (_b = object.lat) !== null && _b !== undefined ? _b : undefined;
-        message.lon = (_c = object.lon) !== null && _c !== undefined ? _c : undefined;
-        message.children = ((_d = object.children) === null || _d === undefined ? undefined : _d.map((e) => e)) || [];
-        message.parent = (_e = object.parent) !== null && _e !== undefined ? _e : undefined;
-        message.locationType = (_f = object.locationType) !== null && _f !== undefined ? _f : 0;
-        message.platform = (_g = object.platform) !== null && _g !== undefined ? _g : undefined;
+        message.sourceStopId = (_b = object.sourceStopId) !== null && _b !== undefined ? _b : "";
+        message.lat = (_c = object.lat) !== null && _c !== undefined ? _c : undefined;
+        message.lon = (_d = object.lon) !== null && _d !== undefined ? _d : undefined;
+        message.children = ((_e = object.children) === null || _e === undefined ? undefined : _e.map((e) => e)) || [];
+        message.parent = (_f = object.parent) !== null && _f !== undefined ? _f : undefined;
+        message.locationType = (_g = object.locationType) !== null && _g !== undefined ? _g : 0;
+        message.platform = (_h = object.platform) !== null && _h !== undefined ? _h : undefined;
         return message;
     },
 };
@@ -15245,7 +15273,7 @@ const StopsMap = {
             version: isSet$1(object.version) ? globalThis.String(object.version) : "",
             stops: isObject$1(object.stops)
                 ? Object.entries(object.stops).reduce((acc, [key, value]) => {
-                    acc[key] = Stop.fromJSON(value);
+                    acc[globalThis.Number(key)] = Stop.fromJSON(value);
                     return acc;
                 }, {})
                 : {},
@@ -15276,7 +15304,7 @@ const StopsMap = {
         message.version = (_a = object.version) !== null && _a !== undefined ? _a : "";
         message.stops = Object.entries((_b = object.stops) !== null && _b !== undefined ? _b : {}).reduce((acc, [key, value]) => {
             if (value !== undefined) {
-                acc[key] = Stop.fromPartial(value);
+                acc[globalThis.Number(key)] = Stop.fromPartial(value);
             }
             return acc;
         }, {});
@@ -15284,12 +15312,12 @@ const StopsMap = {
     },
 };
 function createBaseStopsMap_StopsEntry() {
-    return { key: "", value: undefined };
+    return { key: 0, value: undefined };
 }
 const StopsMap_StopsEntry = {
     encode(message, writer = new BinaryWriter()) {
-        if (message.key !== "") {
-            writer.uint32(10).string(message.key);
+        if (message.key !== 0) {
+            writer.uint32(8).uint32(message.key);
         }
         if (message.value !== undefined) {
             Stop.encode(message.value, writer.uint32(18).fork()).join();
@@ -15304,10 +15332,10 @@ const StopsMap_StopsEntry = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1: {
-                    if (tag !== 10) {
+                    if (tag !== 8) {
                         break;
                     }
-                    message.key = reader.string();
+                    message.key = reader.uint32();
                     continue;
                 }
                 case 2: {
@@ -15327,14 +15355,14 @@ const StopsMap_StopsEntry = {
     },
     fromJSON(object) {
         return {
-            key: isSet$1(object.key) ? globalThis.String(object.key) : "",
+            key: isSet$1(object.key) ? globalThis.Number(object.key) : 0,
             value: isSet$1(object.value) ? Stop.fromJSON(object.value) : undefined,
         };
     },
     toJSON(message) {
         const obj = {};
-        if (message.key !== "") {
-            obj.key = message.key;
+        if (message.key !== 0) {
+            obj.key = Math.round(message.key);
         }
         if (message.value !== undefined) {
             obj.value = Stop.toJSON(message.value);
@@ -15347,7 +15375,7 @@ const StopsMap_StopsEntry = {
     fromPartial(object) {
         var _a;
         const message = createBaseStopsMap_StopsEntry();
-        message.key = (_a = object.key) !== null && _a !== undefined ? _a : "";
+        message.key = (_a = object.key) !== null && _a !== undefined ? _a : 0;
         message.value = (object.value !== undefined && object.value !== null) ? Stop.fromPartial(object.value) : undefined;
         return message;
     },
@@ -15359,10 +15387,11 @@ function isSet$1(value) {
     return value !== null && value !== undefined;
 }
 
-const CURRENT_VERSION$1 = '0.0.1';
+const CURRENT_VERSION$1 = '0.0.2';
 const serializeStop = (stop) => {
     return {
         name: stop.name,
+        sourceStopId: stop.sourceStopId,
         lat: stop.lat,
         lon: stop.lon,
         children: stop.children,
@@ -15384,6 +15413,7 @@ const serializeStopsMap = (stopsMap) => {
 const deserializeStop = (stopId, protoStop) => {
     return {
         id: stopId,
+        sourceStopId: protoStop.sourceStopId,
         name: protoStop.name,
         lat: protoStop.lat,
         lon: protoStop.lon,
@@ -15399,7 +15429,8 @@ const deserializeStopsMap = (protoStopsMap) => {
     }
     const stopsMap = new Map();
     Object.entries(protoStopsMap.stops).forEach(([key, value]) => {
-        stopsMap.set(key, deserializeStop(key, value));
+        const intKey = parseInt(key, 10);
+        stopsMap.set(intKey, deserializeStop(intKey, value));
     });
     return stopsMap;
 };
@@ -15443,6 +15474,10 @@ class StopsIndex {
     constructor(stopsMap) {
         var _a;
         this.stopsMap = stopsMap;
+        this.sourceStopsMap = new Map();
+        for (const [id, stop] of stopsMap.entries()) {
+            this.sourceStopsMap.set(stop.sourceStopId, id);
+        }
         this.textIndex = lt({
             fields: ['name'],
             storeFields: ['id'],
@@ -15501,6 +15536,14 @@ class StopsIndex {
         StopsMap.encode(protoStopsMap, writer);
         return writer.finish();
     }
+    /**
+     * Returns the number of stops in the index.
+     *
+     * @returns The total number of stops.
+     */
+    size() {
+        return this.stopsMap.size;
+    }
     /**
      * Finds stops by their name using a text search.
      *
@@ -15529,16 +15572,36 @@ class StopsIndex {
         return nearestStops;
     }
     /**
-     * Finds a stop by its ID.
+     * Finds a stop by its internal ID.
      *
-     * @param id - The ID of the stop to search for.
+     * @param id - The internal ID of the stop to search for.
      * @returns The Stop object that matches the specified ID, or undefined if not found.
      */
     findStopById(id) {
         return this.stopsMap.get(id);
     }
-    equivalentStops(id) {
+    /**
+     * Finds a stop by its ID in the transit data source (e.g. GTFS).
+     *
+     * @param id - The source ID of the stop to search for.
+     * @returns The Stop object that matches the specified ID, or undefined if not found.
+     */
+    findStopBySourceStopId(sourceStopId) {
+        const stopId = this.sourceStopsMap.get(sourceStopId);
+        if (stopId === undefined) {
+            return;
+        }
+        return this.findStopById(stopId);
+    }
+    /**
+     * Find ids of all sibling stops.
+     */
+    equivalentStops(sourceId) {
         var _a, _b;
+        const id = this.sourceStopsMap.get(sourceId);
+        if (id === undefined) {
+            return [];
+        }
         const stop = this.stopsMap.get(id);
         if (!stop) {
             return [];
@@ -15546,7 +15609,7 @@ class StopsIndex {
         const equivalentStops = stop.parent
             ? ((_b = (_a = this.stopsMap.get(stop.parent)) === null || _a === undefined ? undefined : _a.children) !== null && _b !== undefined ? _b : [])
             : stop.children;
-        return Array.from(new Set([id, ...equivalentStops]));
+        return Array.from(new Set([id, ...equivalentStops])).map((stopId) => this.stopsMap.get(stopId));
     }
 }
 
@@ -15637,43 +15700,6 @@ class Duration {
 //   protoc               v4.23.4
 // source: src/timetable/proto/timetable.proto
 /* eslint-disable */
-var PickUpDropOffType;
-(function (PickUpDropOffType) {
-    PickUpDropOffType[PickUpDropOffType["NOT_AVAILABLE"] = 0] = "NOT_AVAILABLE";
-    PickUpDropOffType[PickUpDropOffType["MUST_PHONE_AGENCY"] = 1] = "MUST_PHONE_AGENCY";
-    PickUpDropOffType[PickUpDropOffType["MUST_COORDINATE_WITH_DRIVER"] = 2] = "MUST_COORDINATE_WITH_DRIVER";
-    PickUpDropOffType[PickUpDropOffType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
-})(PickUpDropOffType || (PickUpDropOffType = {}));
-function pickUpDropOffTypeFromJSON(object) {
-    switch (object) {
-        case 0:
-        case "NOT_AVAILABLE":
-            return PickUpDropOffType.NOT_AVAILABLE;
-        case 1:
-        case "MUST_PHONE_AGENCY":
-            return PickUpDropOffType.MUST_PHONE_AGENCY;
-        case 2:
-        case "MUST_COORDINATE_WITH_DRIVER":
-            return PickUpDropOffType.MUST_COORDINATE_WITH_DRIVER;
-        case -1:
-        case "UNRECOGNIZED":
-        default:
-            return PickUpDropOffType.UNRECOGNIZED;
-    }
-}
-function pickUpDropOffTypeToJSON(object) {
-    switch (object) {
-        case PickUpDropOffType.NOT_AVAILABLE:
-            return "NOT_AVAILABLE";
-        case PickUpDropOffType.MUST_PHONE_AGENCY:
-            return "MUST_PHONE_AGENCY";
-        case PickUpDropOffType.MUST_COORDINATE_WITH_DRIVER:
-            return "MUST_COORDINATE_WITH_DRIVER";
-        case PickUpDropOffType.UNRECOGNIZED:
-        default:
-            return "UNRECOGNIZED";
-    }
-}
 var TransferType;
 (function (TransferType) {
     TransferType[TransferType["RECOMMENDED_TRANSFER_POINT"] = 0] = "RECOMMENDED_TRANSFER_POINT";
@@ -15796,118 +15822,27 @@ function routeTypeToJSON(object) {
             return "UNRECOGNIZED";
     }
 }
-function createBaseStopTimes() {
-    return { arrival: 0, departure: 0, pickUpType: undefined, dropOffType: undefined };
-}
-const StopTimes = {
-    encode(message, writer = new BinaryWriter()) {
-        if (message.arrival !== 0) {
-            writer.uint32(8).int32(message.arrival);
-        }
-        if (message.departure !== 0) {
-            writer.uint32(16).int32(message.departure);
-        }
-        if (message.pickUpType !== undefined) {
-            writer.uint32(24).int32(message.pickUpType);
-        }
-        if (message.dropOffType !== undefined) {
-            writer.uint32(32).int32(message.dropOffType);
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseStopTimes();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1: {
-                    if (tag !== 8) {
-                        break;
-                    }
-                    message.arrival = reader.int32();
-                    continue;
-                }
-                case 2: {
-                    if (tag !== 16) {
-                        break;
-                    }
-                    message.departure = reader.int32();
-                    continue;
-                }
-                case 3: {
-                    if (tag !== 24) {
-                        break;
-                    }
-                    message.pickUpType = reader.int32();
-                    continue;
-                }
-                case 4: {
-                    if (tag !== 32) {
-                        break;
-                    }
-                    message.dropOffType = reader.int32();
-                    continue;
-                }
-            }
-            if ((tag & 7) === 4 || tag === 0) {
-                break;
-            }
-            reader.skip(tag & 7);
-        }
-        return message;
-    },
-    fromJSON(object) {
-        return {
-            arrival: isSet(object.arrival) ? globalThis.Number(object.arrival) : 0,
-            departure: isSet(object.departure) ? globalThis.Number(object.departure) : 0,
-            pickUpType: isSet(object.pickUpType) ? pickUpDropOffTypeFromJSON(object.pickUpType) : undefined,
-            dropOffType: isSet(object.dropOffType) ? pickUpDropOffTypeFromJSON(object.dropOffType) : undefined,
-        };
-    },
-    toJSON(message) {
-        const obj = {};
-        if (message.arrival !== 0) {
-            obj.arrival = Math.round(message.arrival);
-        }
-        if (message.departure !== 0) {
-            obj.departure = Math.round(message.departure);
-        }
-        if (message.pickUpType !== undefined) {
-            obj.pickUpType = pickUpDropOffTypeToJSON(message.pickUpType);
-        }
-        if (message.dropOffType !== undefined) {
-            obj.dropOffType = pickUpDropOffTypeToJSON(message.dropOffType);
-        }
-        return obj;
-    },
-    create(base) {
-        return StopTimes.fromPartial(base !== null && base !== undefined ? base : {});
-    },
-    fromPartial(object) {
-        var _a, _b, _c, _d;
-        const message = createBaseStopTimes();
-        message.arrival = (_a = object.arrival) !== null && _a !== undefined ? _a : 0;
-        message.departure = (_b = object.departure) !== null && _b !== undefined ? _b : 0;
-        message.pickUpType = (_c = object.pickUpType) !== null && _c !== undefined ? _c : undefined;
-        message.dropOffType = (_d = object.dropOffType) !== null && _d !== undefined ? _d : undefined;
-        return message;
-    },
-};
 function createBaseRoute() {
-    return { stopTimes: [], stops: [], serviceRouteId: "" };
+    return {
+        stopTimes: new Uint8Array(0),
+        pickUpDropOffTypes: new Uint8Array(0),
+        stops: new Uint8Array(0),
+        serviceRouteId: "",
+    };
 }
 const Route$1 = {
     encode(message, writer = new BinaryWriter()) {
-        for (const v of message.stopTimes) {
-            StopTimes.encode(v, writer.uint32(10).fork()).join();
+        if (message.stopTimes.length !== 0) {
+            writer.uint32(10).bytes(message.stopTimes);
         }
-        for (const v of message.stops) {
-            writer.uint32(18).string(v);
+        if (message.pickUpDropOffTypes.length !== 0) {
+            writer.uint32(18).bytes(message.pickUpDropOffTypes);
+        }
+        if (message.stops.length !== 0) {
+            writer.uint32(26).bytes(message.stops);
         }
         if (message.serviceRouteId !== "") {
-            writer.uint32(26).string(message.serviceRouteId);
+            writer.uint32(34).string(message.serviceRouteId);
         }
         return writer;
     },
@@ -15922,20 +15857,27 @@ const Route$1 = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.stopTimes.push(StopTimes.decode(reader, reader.uint32()));
+                    message.stopTimes = reader.bytes();
                     continue;
                 }
                 case 2: {
                     if (tag !== 18) {
                         break;
                     }
-                    message.stops.push(reader.string());
+                    message.pickUpDropOffTypes = reader.bytes();
                     continue;
                 }
                 case 3: {
                     if (tag !== 26) {
                         break;
                     }
+                    message.stops = reader.bytes();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
                     message.serviceRouteId = reader.string();
                     continue;
                 }
@@ -15949,21 +15891,24 @@ const Route$1 = {
     },
     fromJSON(object) {
         return {
-            stopTimes: globalThis.Array.isArray(object === null || object === undefined ? undefined : object.stopTimes)
-                ? object.stopTimes.map((e) => StopTimes.fromJSON(e))
-                : [],
-            stops: globalThis.Array.isArray(object === null || object === undefined ? undefined : object.stops) ? object.stops.map((e) => globalThis.String(e)) : [],
+            stopTimes: isSet(object.stopTimes) ? bytesFromBase64(object.stopTimes) : new Uint8Array(0),
+            pickUpDropOffTypes: isSet(object.pickUpDropOffTypes)
+                ? bytesFromBase64(object.pickUpDropOffTypes)
+                : new Uint8Array(0),
+            stops: isSet(object.stops) ? bytesFromBase64(object.stops) : new Uint8Array(0),
             serviceRouteId: isSet(object.serviceRouteId) ? globalThis.String(object.serviceRouteId) : "",
         };
     },
     toJSON(message) {
-        var _a, _b;
         const obj = {};
-        if ((_a = message.stopTimes) === null || _a === undefined ? undefined : _a.length) {
-            obj.stopTimes = message.stopTimes.map((e) => StopTimes.toJSON(e));
+        if (message.stopTimes.length !== 0) {
+            obj.stopTimes = base64FromBytes(message.stopTimes);
+        }
+        if (message.pickUpDropOffTypes.length !== 0) {
+            obj.pickUpDropOffTypes = base64FromBytes(message.pickUpDropOffTypes);
         }
-        if ((_b = message.stops) === null || _b === undefined ? undefined : _b.length) {
-            obj.stops = message.stops;
+        if (message.stops.length !== 0) {
+            obj.stops = base64FromBytes(message.stops);
         }
         if (message.serviceRouteId !== "") {
             obj.serviceRouteId = message.serviceRouteId;
@@ -15974,11 +15919,12 @@ const Route$1 = {
         return Route$1.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const message = createBaseRoute();
-        message.stopTimes = ((_a = object.stopTimes) === null || _a === undefined ? undefined : _a.map((e) => StopTimes.fromPartial(e))) || [];
-        message.stops = ((_b = object.stops) === null || _b === undefined ? undefined : _b.map((e) => e)) || [];
-        message.serviceRouteId = (_c = object.serviceRouteId) !== null && _c !== undefined ? _c : "";
+        message.stopTimes = (_a = object.stopTimes) !== null && _a !== undefined ? _a : new Uint8Array(0);
+        message.pickUpDropOffTypes = (_b = object.pickUpDropOffTypes) !== null && _b !== undefined ? _b : new Uint8Array(0);
+        message.stops = (_c = object.stops) !== null && _c !== undefined ? _c : new Uint8Array(0);
+        message.serviceRouteId = (_d = object.serviceRouteId) !== null && _d !== undefined ? _d : "";
         return message;
     },
 };
@@ -16125,12 +16071,12 @@ const RoutesAdjacency_RoutesEntry = {
     },
 };
 function createBaseTransfer() {
-    return { destination: "", type: 0, minTransferTime: undefined };
+    return { destination: 0, type: 0, minTransferTime: undefined };
 }
 const Transfer = {
     encode(message, writer = new BinaryWriter()) {
-        if (message.destination !== "") {
-            writer.uint32(10).string(message.destination);
+        if (message.destination !== 0) {
+            writer.uint32(8).uint32(message.destination);
         }
         if (message.type !== 0) {
             writer.uint32(16).int32(message.type);
@@ -16148,10 +16094,10 @@ const Transfer = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1: {
-                    if (tag !== 10) {
+                    if (tag !== 8) {
                         break;
                     }
-                    message.destination = reader.string();
+                    message.destination = reader.uint32();
                     continue;
                 }
                 case 2: {
@@ -16178,15 +16124,15 @@ const Transfer = {
     },
     fromJSON(object) {
         return {
-            destination: isSet(object.destination) ? globalThis.String(object.destination) : "",
+            destination: isSet(object.destination) ? globalThis.Number(object.destination) : 0,
             type: isSet(object.type) ? transferTypeFromJSON(object.type) : 0,
             minTransferTime: isSet(object.minTransferTime) ? globalThis.Number(object.minTransferTime) : undefined,
         };
     },
     toJSON(message) {
         const obj = {};
-        if (message.destination !== "") {
-            obj.destination = message.destination;
+        if (message.destination !== 0) {
+            obj.destination = Math.round(message.destination);
         }
         if (message.type !== 0) {
             obj.type = transferTypeToJSON(message.type);
@@ -16202,7 +16148,7 @@ const Transfer = {
     fromPartial(object) {
         var _a, _b, _c;
         const message = createBaseTransfer();
-        message.destination = (_a = object.destination) !== null && _a !== undefined ? _a : "";
+        message.destination = (_a = object.destination) !== null && _a !== undefined ? _a : 0;
         message.type = (_b = object.type) !== null && _b !== undefined ? _b : 0;
         message.minTransferTime = (_c = object.minTransferTime) !== null && _c !== undefined ? _c : undefined;
         return message;
@@ -16742,6 +16688,31 @@ const Timetable$1 = {
         return message;
     },
 };
+function bytesFromBase64(b64) {
+    if (globalThis.Buffer) {
+        return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+    }
+    else {
+        const bin = globalThis.atob(b64);
+        const arr = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; ++i) {
+            arr[i] = bin.charCodeAt(i);
+        }
+        return arr;
+    }
+}
+function base64FromBytes(arr) {
+    if (globalThis.Buffer) {
+        return globalThis.Buffer.from(arr).toString("base64");
+    }
+    else {
+        const bin = [];
+        arr.forEach((byte) => {
+            bin.push(globalThis.String.fromCharCode(byte));
+        });
+        return globalThis.btoa(bin.join(""));
+    }
+}
 function isObject(value) {
     return typeof value === "object" && value !== null;
 }
@@ -16749,6 +16720,202 @@ function isSet(value) {
     return value !== null && value !== undefined;
 }
 
+const isLittleEndian = (() => {
+    const buffer = new ArrayBuffer(4);
+    const view = new DataView(buffer);
+    view.setUint32(0, 0x12345678);
+    return new Uint8Array(buffer)[0] === 0x78;
+})();
+const STANDARD_ENDIANNESS = true; // true = little-endian
+function uint32ArrayToBytes(array) {
+    if (isLittleEndian === STANDARD_ENDIANNESS) {
+        return new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+    }
+    // If endianness doesn't match, we need to swap byte order
+    const result = new Uint8Array(array.length * 4);
+    const view = new DataView(result.buffer);
+    for (let i = 0; i < array.length; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        view.setUint32(i * 4, array[i], STANDARD_ENDIANNESS);
+    }
+    return result;
+}
+function bytesToUint32Array(bytes) {
+    if (bytes.byteLength % 4 !== 0) {
+        throw new Error('Byte array length must be a multiple of 4 to convert to Uint32Array');
+    }
+    // If system endianness matches our standard, we can create a view directly
+    if (isLittleEndian === STANDARD_ENDIANNESS) {
+        return new Uint32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
+    }
+    // If endianness doesn't match, we need to swap byte order
+    const result = new Uint32Array(bytes.byteLength / 4);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    for (let i = 0; i < result.length; i++) {
+        result[i] = view.getUint32(i * 4, STANDARD_ENDIANNESS);
+    }
+    return result;
+}
+const serializeStopsAdjacency = (stopsAdjacency) => {
+    const protoStopsAdjacency = {
+        stops: {},
+    };
+    stopsAdjacency.forEach((value, key) => {
+        protoStopsAdjacency.stops[key] = {
+            transfers: value.transfers.map((transfer) => (Object.assign({ destination: transfer.destination, type: serializeTransferType(transfer.type) }, (transfer.minTransferTime !== undefined && {
+                minTransferTime: transfer.minTransferTime.toSeconds(),
+            })))),
+            routes: value.routes,
+        };
+    });
+    return protoStopsAdjacency;
+};
+const serializeRoutesAdjacency = (routesAdjacency) => {
+    const protoRoutesAdjacency = {
+        routes: {},
+    };
+    routesAdjacency.forEach((value, key) => {
+        protoRoutesAdjacency.routes[key] = {
+            stopTimes: uint32ArrayToBytes(value.stopTimes),
+            pickUpDropOffTypes: value.pickUpDropOffTypes,
+            stops: uint32ArrayToBytes(value.stops),
+            serviceRouteId: value.serviceRouteId,
+        };
+    });
+    return protoRoutesAdjacency;
+};
+const serializeServiceRoutesMap = (serviceRoutesMap) => {
+    const protoServiceRoutesMap = {
+        routes: {},
+    };
+    serviceRoutesMap.forEach((value, key) => {
+        protoServiceRoutesMap.routes[key] = {
+            type: serializeRouteType(value.type),
+            name: value.name,
+        };
+    });
+    return protoServiceRoutesMap;
+};
+const deserializeStopsAdjacency = (protoStopsAdjacency) => {
+    const stopsAdjacency = new Map();
+    Object.entries(protoStopsAdjacency.stops).forEach(([keyStr, value]) => {
+        const key = parseInt(keyStr, 10);
+        stopsAdjacency.set(key, {
+            transfers: value.transfers.map((transfer) => (Object.assign({ destination: transfer.destination, type: parseTransferType(transfer.type) }, (transfer.minTransferTime !== undefined && {
+                minTransferTime: Duration.fromSeconds(transfer.minTransferTime),
+            })))),
+            routes: value.routes,
+        });
+    });
+    return stopsAdjacency;
+};
+const deserializeRoutesAdjacency = (protoRoutesAdjacency) => {
+    const routesAdjacency = new Map();
+    Object.entries(protoRoutesAdjacency.routes).forEach(([key, value]) => {
+        const stops = bytesToUint32Array(value.stops);
+        const indices = new Map();
+        for (let i = 0; i < stops.length; i++) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            indices.set(stops[i], i);
+        }
+        routesAdjacency.set(key, {
+            stopTimes: bytesToUint32Array(value.stopTimes),
+            pickUpDropOffTypes: value.pickUpDropOffTypes,
+            stops: stops,
+            stopIndices: indices,
+            serviceRouteId: value.serviceRouteId,
+        });
+    });
+    return routesAdjacency;
+};
+const deserializeServiceRoutesMap = (protoServiceRoutesMap) => {
+    const serviceRoutesMap = new Map();
+    Object.entries(protoServiceRoutesMap.routes).forEach(([key, value]) => {
+        serviceRoutesMap.set(key, {
+            type: parseRouteType(value.type),
+            name: value.name,
+        });
+    });
+    return serviceRoutesMap;
+};
+const parseTransferType = (type) => {
+    switch (type) {
+        case TransferType.RECOMMENDED_TRANSFER_POINT:
+            return 'RECOMMENDED';
+        case TransferType.TIMED_TRANSFER:
+            return 'GUARANTEED';
+        case TransferType.REQUIRES_MINIMAL_TIME:
+            return 'REQUIRES_MINIMAL_TIME';
+        case TransferType.IN_SEAT_TRANSFER:
+            return 'IN_SEAT';
+        case TransferType.UNRECOGNIZED:
+            throw new Error('Unrecognized protobuf transfer type.');
+    }
+};
+const serializeTransferType = (type) => {
+    switch (type) {
+        case 'RECOMMENDED':
+            return TransferType.RECOMMENDED_TRANSFER_POINT;
+        case 'GUARANTEED':
+            return TransferType.TIMED_TRANSFER;
+        case 'REQUIRES_MINIMAL_TIME':
+            return TransferType.REQUIRES_MINIMAL_TIME;
+        case 'IN_SEAT':
+            return TransferType.IN_SEAT_TRANSFER;
+    }
+};
+const parseRouteType = (type) => {
+    switch (type) {
+        case RouteType.TRAM:
+            return 'TRAM';
+        case RouteType.SUBWAY:
+            return 'SUBWAY';
+        case RouteType.RAIL:
+            return 'RAIL';
+        case RouteType.BUS:
+            return 'BUS';
+        case RouteType.FERRY:
+            return 'FERRY';
+        case RouteType.CABLE_TRAM:
+            return 'CABLE_TRAM';
+        case RouteType.AERIAL_LIFT:
+            return 'AERIAL_LIFT';
+        case RouteType.FUNICULAR:
+            return 'FUNICULAR';
+        case RouteType.TROLLEYBUS:
+            return 'TROLLEYBUS';
+        case RouteType.MONORAIL:
+            return 'MONORAIL';
+        case RouteType.UNRECOGNIZED:
+        default:
+            throw new Error('Unrecognized protobuf route type.');
+    }
+};
+const serializeRouteType = (type) => {
+    switch (type) {
+        case 'TRAM':
+            return RouteType.TRAM;
+        case 'SUBWAY':
+            return RouteType.SUBWAY;
+        case 'RAIL':
+            return RouteType.RAIL;
+        case 'BUS':
+            return RouteType.BUS;
+        case 'FERRY':
+            return RouteType.FERRY;
+        case 'CABLE_TRAM':
+            return RouteType.CABLE_TRAM;
+        case 'AERIAL_LIFT':
+            return RouteType.AERIAL_LIFT;
+        case 'FUNICULAR':
+            return RouteType.FUNICULAR;
+        case 'TROLLEYBUS':
+            return RouteType.TROLLEYBUS;
+        case 'MONORAIL':
+            return RouteType.MONORAIL;
+    }
+};
+
 /**
  * A class representing a time in hours, minutes, and seconds.
  */
@@ -16920,195 +17087,10 @@ class Time {
     }
 }
 
-const serializeStopsAdjacency = (stopsAdjacency) => {
-    const protoStopsAdjacency = {
-        stops: {},
-    };
-    stopsAdjacency.forEach((value, key) => {
-        protoStopsAdjacency.stops[key] = {
-            transfers: value.transfers.map((transfer) => (Object.assign({ destination: transfer.destination, type: serializeTransferType(transfer.type) }, (transfer.minTransferTime !== undefined && {
-                minTransferTime: transfer.minTransferTime.toSeconds(),
-            })))),
-            routes: value.routes,
-        };
-    });
-    return protoStopsAdjacency;
-};
-const serializeRoutesAdjacency = (routesAdjacency) => {
-    const protoRoutesAdjacency = {
-        routes: {},
-    };
-    routesAdjacency.forEach((value, key) => {
-        protoRoutesAdjacency.routes[key] = {
-            stopTimes: value.stopTimes.map((stopTimes) => ({
-                arrival: stopTimes.arrival.toSeconds(),
-                departure: stopTimes.departure.toSeconds(),
-                pickUpType: serializePickUpDropOffType(stopTimes.pickUpType),
-                dropOffType: serializePickUpDropOffType(stopTimes.dropOffType),
-            })),
-            stops: value.stops,
-            serviceRouteId: value.serviceRouteId,
-        };
-    });
-    return protoRoutesAdjacency;
-};
-const serializeServiceRoutesMap = (serviceRoutesMap) => {
-    const protoServiceRoutesMap = {
-        routes: {},
-    };
-    serviceRoutesMap.forEach((value, key) => {
-        protoServiceRoutesMap.routes[key] = {
-            type: serializeRouteType(value.type),
-            name: value.name,
-        };
-    });
-    return protoServiceRoutesMap;
-};
-const deserializeStopsAdjacency = (protoStopsAdjacency) => {
-    const stopsAdjacency = new Map();
-    Object.entries(protoStopsAdjacency.stops).forEach(([key, value]) => {
-        stopsAdjacency.set(key, {
-            transfers: value.transfers.map((transfer) => (Object.assign({ destination: transfer.destination, type: parseTransferType(transfer.type) }, (transfer.minTransferTime !== undefined && {
-                minTransferTime: Duration.fromSeconds(transfer.minTransferTime),
-            })))),
-            routes: value.routes,
-        });
-    });
-    return stopsAdjacency;
-};
-const deserializeRoutesAdjacency = (protoRoutesAdjacency) => {
-    const routesAdjacency = new Map();
-    Object.entries(protoRoutesAdjacency.routes).forEach(([key, value]) => {
-        routesAdjacency.set(key, {
-            stopTimes: value.stopTimes.map((stopTimes) => ({
-                arrival: Time.fromSeconds(stopTimes.arrival),
-                departure: Time.fromSeconds(stopTimes.departure),
-                pickUpType: stopTimes.pickUpType !== undefined
-                    ? parsePickUpDropOffType(stopTimes.pickUpType)
-                    : 'REGULAR',
-                dropOffType: stopTimes.dropOffType !== undefined
-                    ? parsePickUpDropOffType(stopTimes.dropOffType)
-                    : 'REGULAR',
-            })),
-            stops: value.stops,
-            stopIndices: new Map(value.stops.map((stop, index) => [stop, index])),
-            serviceRouteId: value.serviceRouteId,
-        });
-    });
-    return routesAdjacency;
-};
-const deserializeServiceRoutesMap = (protoServiceRoutesMap) => {
-    const serviceRoutesMap = new Map();
-    Object.entries(protoServiceRoutesMap.routes).forEach(([key, value]) => {
-        serviceRoutesMap.set(key, {
-            type: parseRouteType(value.type),
-            name: value.name,
-        });
-    });
-    return serviceRoutesMap;
-};
-const parseTransferType = (type) => {
-    switch (type) {
-        case TransferType.RECOMMENDED_TRANSFER_POINT:
-            return 'RECOMMENDED';
-        case TransferType.TIMED_TRANSFER:
-            return 'GUARANTEED';
-        case TransferType.REQUIRES_MINIMAL_TIME:
-            return 'REQUIRES_MINIMAL_TIME';
-        case TransferType.IN_SEAT_TRANSFER:
-            return 'IN_SEAT';
-        case TransferType.UNRECOGNIZED:
-            throw new Error('Unrecognized protobuf transfer type.');
-    }
-};
-const serializeTransferType = (type) => {
-    switch (type) {
-        case 'RECOMMENDED':
-            return TransferType.RECOMMENDED_TRANSFER_POINT;
-        case 'GUARANTEED':
-            return TransferType.TIMED_TRANSFER;
-        case 'REQUIRES_MINIMAL_TIME':
-            return TransferType.REQUIRES_MINIMAL_TIME;
-        case 'IN_SEAT':
-            return TransferType.IN_SEAT_TRANSFER;
-    }
-};
-const parseRouteType = (type) => {
-    switch (type) {
-        case RouteType.TRAM:
-            return 'TRAM';
-        case RouteType.SUBWAY:
-            return 'SUBWAY';
-        case RouteType.RAIL:
-            return 'RAIL';
-        case RouteType.BUS:
-            return 'BUS';
-        case RouteType.FERRY:
-            return 'FERRY';
-        case RouteType.CABLE_TRAM:
-            return 'CABLE_TRAM';
-        case RouteType.AERIAL_LIFT:
-            return 'AERIAL_LIFT';
-        case RouteType.FUNICULAR:
-            return 'FUNICULAR';
-        case RouteType.TROLLEYBUS:
-            return 'TROLLEYBUS';
-        case RouteType.MONORAIL:
-            return 'MONORAIL';
-        case RouteType.UNRECOGNIZED:
-        default:
-            throw new Error('Unrecognized protobuf route type.');
-    }
-};
-const serializeRouteType = (type) => {
-    switch (type) {
-        case 'TRAM':
-            return RouteType.TRAM;
-        case 'SUBWAY':
-            return RouteType.SUBWAY;
-        case 'RAIL':
-            return RouteType.RAIL;
-        case 'BUS':
-            return RouteType.BUS;
-        case 'FERRY':
-            return RouteType.FERRY;
-        case 'CABLE_TRAM':
-            return RouteType.CABLE_TRAM;
-        case 'AERIAL_LIFT':
-            return RouteType.AERIAL_LIFT;
-        case 'FUNICULAR':
-            return RouteType.FUNICULAR;
-        case 'TROLLEYBUS':
-            return RouteType.TROLLEYBUS;
-        case 'MONORAIL':
-            return RouteType.MONORAIL;
-    }
-};
-const parsePickUpDropOffType = (type) => {
-    switch (type) {
-        case PickUpDropOffType.MUST_PHONE_AGENCY:
-            return 'MUST_PHONE_AGENCY';
-        case PickUpDropOffType.MUST_COORDINATE_WITH_DRIVER:
-            return 'MUST_COORDINATE_WITH_DRIVER';
-        case PickUpDropOffType.NOT_AVAILABLE:
-            return 'NOT_AVAILABLE';
-        default:
-            return 'REGULAR';
-    }
-};
-const serializePickUpDropOffType = (type) => {
-    switch (type) {
-        case 'REGULAR':
-            return undefined;
-        case 'NOT_AVAILABLE':
-            return PickUpDropOffType.NOT_AVAILABLE;
-        case 'MUST_COORDINATE_WITH_DRIVER':
-            return PickUpDropOffType.MUST_COORDINATE_WITH_DRIVER;
-        case 'MUST_PHONE_AGENCY':
-            return PickUpDropOffType.MUST_PHONE_AGENCY;
-    }
-};
-
+const REGULAR = 0;
+const NOT_AVAILABLE = 1;
+const MUST_PHONE_AGENCY = 2;
+const MUST_COORDINATE_WITH_DRIVER = 3;
 const ALL_TRANSPORT_MODES = [
     'TRAM',
     'SUBWAY',
@@ -17121,7 +17103,7 @@ const ALL_TRANSPORT_MODES = [
     'TROLLEYBUS',
     'MONORAIL',
 ];
-const CURRENT_VERSION = '0.0.1';
+const CURRENT_VERSION = '0.0.2';
 /**
  * The internal transit timetable format
  * reuses some GTFS concepts for the sake of simplicity for now.
@@ -17168,6 +17150,13 @@ class Timetable {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         deserializeServiceRoutesMap(protoTimetable.routes));
     }
+    getRoutesThroughStop(stopId) {
+        const stopAdjacency = this.stopsAdjacency.get(stopId);
+        if (!stopAdjacency) {
+            return [];
+        }
+        return stopAdjacency.routes;
+    }
     getRoute(routeId) {
         return this.routesAdjacency.get(routeId);
     }
@@ -17234,9 +17223,9 @@ class Timetable {
         if (beforeTrip === undefined) {
             for (let tripIndex = 0; tripIndex < route.stopTimes.length / stopsNumber; tripIndex++) {
                 const stopTimeIndex = tripIndex * stopsNumber + stopIndex;
-                const stopTime = route.stopTimes[stopTimeIndex];
-                if (stopTime.departure >= after &&
-                    stopTime.pickUpType !== 'NOT_AVAILABLE') {
+                const departure = route.stopTimes[stopTimeIndex * 2 + 1];
+                const pickUpType = route.pickUpDropOffTypes[stopTimeIndex * 2];
+                if (departure >= after.toSeconds() && pickUpType !== NOT_AVAILABLE) {
                     return tripIndex;
                 }
             }
@@ -17248,15 +17237,16 @@ class Timetable {
             for (let tripIndex = beforeTrip; // ?? route.stopTimes.length / stopsNumber - 1;
              tripIndex >= 0; tripIndex--) {
                 const stopTimeIndex = tripIndex * stopsNumber + stopIndex;
-                const stopTime = route.stopTimes[stopTimeIndex];
-                if (stopTime.departure < after) {
+                const departure = route.stopTimes[stopTimeIndex * 2 + 1];
+                const pickUpType = route.pickUpDropOffTypes[stopTimeIndex * 2];
+                if (departure < after.toSeconds()) {
                     break;
                 }
-                if (stopTime.pickUpType !== 'NOT_AVAILABLE' &&
+                if (pickUpType !== NOT_AVAILABLE &&
                     (earliestDeparture === undefined ||
-                        stopTime.departure < earliestDeparture)) {
+                        departure < earliestDeparture.toSeconds())) {
                     earliestTripIndex = tripIndex;
-                    earliestDeparture = stopTime.departure;
+                    earliestDeparture = Time.fromSeconds(departure);
                 }
             }
             return earliestTripIndex;
@@ -19182,23 +19172,23 @@ const parse = function () {
 };
 
 /**
- * Generates a simple hash from a string.
+ * Generates a simple hash from an array of numeric IDs.
  *
- * This function computes a hash for a given string by iterating over each
- * character and applying bitwise operations to accumulate a hash value.
- * The final hash is then converted to a base-36 string and padded to
- * ensure a minimum length of 6 characters.
+ * This function computes a hash for a given array of numbers by iterating over each
+ * ID and applying bitwise operations to accumulate a hash value.
+ * The final hash is then converted to a base-36 string.
  *
- * @param str - The input string to hash.
- * @returns A hashed string representation of the input.
+ * @param ids - The array of numeric IDs to hash.
+ * @returns A hashed string representation of the input array.
  */
-const hash = (str) => {
+const hashIds = (ids) => {
     let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-        hash = (hash << 5) - hash + str.charCodeAt(i);
+    for (let i = 0; i < ids.length; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        hash = (hash << 5) - hash + ids[i];
         hash &= hash;
     }
-    return (hash >>> 0).toString(36).padStart(6, '0');
+    return (hash >>> 0).toString(36);
 };
 /**
  * Parses a CSV stream with a sensible configuration for GTFS feeds.
@@ -19366,18 +19356,19 @@ const parseCalendarDates = (calendarDatesStream, serviceIds, date) => __awaiter(
  * @param stopsStream The readable stream containing the stops data.
  * @return A mapping of stop IDs to corresponding stop details.
  */
-const parseStops = (stopsStream, platformParser, validStops) => __awaiter(undefined, undefined, undefined, function* () {
+const parseStops = (stopsStream, platformParser) => __awaiter(undefined, undefined, undefined, function* () {
     var _a, e_1, _b, _c;
-    const stops = new Map();
+    const parsedStops = new Map();
+    let i = 0;
     try {
         for (var _d = true, _e = __asyncValues(parseCsv(stopsStream)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
             _c = _f.value;
             _d = false;
             const rawLine = _c;
             const line = rawLine;
-            const stop = Object.assign({ id: line.stop_id, name: line.stop_name, lat: line.stop_lat, lon: line.stop_lon, locationType: line.location_type
+            const stop = Object.assign({ id: i, sourceStopId: line.stop_id + '', name: line.stop_name, lat: line.stop_lat, lon: line.stop_lon, locationType: line.location_type
                     ? parseGtfsLocationType(line.location_type)
-                    : 'SIMPLE_STOP_OR_PLATFORM', children: [] }, (line.parent_station && { parent: line.parent_station }));
+                    : 'SIMPLE_STOP_OR_PLATFORM', children: [] }, (line.parent_station && { parentSourceId: line.parent_station }));
             if (platformParser) {
                 try {
                     const platform = platformParser(line);
@@ -19389,7 +19380,8 @@ const parseStops = (stopsStream, platformParser, validStops) => __awaiter(undefi
                     console.info(`Could not parse platform for stop ${line.stop_id}.`);
                 }
             }
-            stops.set(line.stop_id, stop);
+            parsedStops.set(line.stop_id + '', stop);
+            i = i + 1;
         }
     }
     catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -19399,29 +19391,50 @@ const parseStops = (stopsStream, platformParser, validStops) => __awaiter(undefi
         }
         finally { if (e_1) throw e_1.error; }
     }
-    for (const [stopId, stop] of stops) {
-        if (stop.parent) {
-            const parentStop = stops.get(stop.parent);
+    for (const [sourceStopId, stop] of parsedStops) {
+        if (stop.parentSourceId) {
+            const parentStop = parsedStops.get(stop.parentSourceId);
             if (!parentStop) {
-                console.warn(`Cannot find parent stop ${stop.parent} of ${stopId}`);
+                console.warn(`Cannot find parent stop ${stop.parentSourceId} of ${sourceStopId}`);
                 continue;
             }
-            parentStop.children.push(stopId);
+            stop.parent = parentStop.id;
+            parentStop.children.push(stop.id);
         }
     }
-    if (validStops) {
-        // Remove all stops which don't have at least one valid stopId as a child,
-        // a parent or as its own.
-        for (const [stopId, stop] of stops) {
-            if (!validStops.has(stopId) &&
-                (!stop.parent || !validStops.has(stop.parent)) &&
-                !stop.children.some((childId) => validStops.has(childId))) {
-                stops.delete(stopId);
-            }
+    return parsedStops;
+});
+/**
+ * Builds the final stop map indexed by internal IDs.
+ * Excludes all stops that do not have at least one valid stopId
+ * as a child, a parent, or being valid itself.
+ *
+ * @param parsedStops - The map of parsed stops.
+ * @param validStops - A set of valid stop IDs.
+ * @returns A map of stops indexed by internal IDs.
+ */
+const indexStops = (parsedStops, validStops) => {
+    const stops = new Map();
+    for (const [, stop] of parsedStops) {
+        if (!validStops ||
+            validStops.has(stop.id) ||
+            (stop.parent && validStops.has(stop.parent)) ||
+            stop.children.some((childId) => validStops.has(childId))) {
+            stops.set(stop.id, {
+                id: stop.id,
+                sourceStopId: stop.sourceStopId,
+                name: stop.name,
+                lat: stop.lat,
+                lon: stop.lon,
+                locationType: stop.locationType,
+                platform: stop.platform,
+                children: stop.children.filter((childId) => !validStops || validStops.has(childId)),
+                parent: stop.parent,
+            });
         }
     }
     return stops;
-});
+};
 const parseGtfsLocationType = (gtfsLocationType) => {
     switch (gtfsLocationType) {
         case 0:
@@ -19444,7 +19457,7 @@ const parseGtfsLocationType = (gtfsLocationType) => {
  * @param stopsStream The readable stream containing the stops data.
  * @return A mapping of stop IDs to corresponding stop details.
  */
-const parseTransfers = (transfersStream) => __awaiter(undefined, undefined, undefined, function* () {
+const parseTransfers = (transfersStream, stopsMap) => __awaiter(undefined, undefined, undefined, function* () {
     var _a, e_1, _b, _c;
     const transfers = new Map();
     try {
@@ -19472,12 +19485,16 @@ const parseTransfers = (transfersStream) => __awaiter(undefined, undefined, unde
             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}.`);
             }
-            const transfer = Object.assign({ destination: transferEntry.to_stop_id, type: parseGtfsTransferType(transferEntry.transfer_type) }, (transferEntry.min_transfer_time && {
+            // 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 + '');
+            const transfer = Object.assign({ destination: toStop.id, type: parseGtfsTransferType(transferEntry.transfer_type) }, (transferEntry.min_transfer_time && {
                 minTransferTime: Duration.fromSeconds(transferEntry.min_transfer_time),
             }));
-            const fromStopTransfers = transfers.get(transferEntry.from_stop_id) || [];
+            const fromStopTransfers = transfers.get(fromStop.id) || [];
             fromStopTransfers.push(transfer);
-            transfers.set(transferEntry.from_stop_id, fromStopTransfers);
+            transfers.set(fromStop.id, fromStopTransfers);
         }
     }
     catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -19568,28 +19585,52 @@ const buildStopsAdjacencyStructure = (validStops, routes, transfersMap) => {
  * Parses the stop_times.txt data from a GTFS feed.
  *
  * @param stopTimesStream The readable stream containing the stop times data.
+ * @param stopsMap A map of parsed stops from the GTFS feed.
  * @param validTripIds A map of valid trip IDs to corresponding route IDs.
- * @param validStopIds A map of valid stop IDs.
- * @returns A mapping of route IDs to route details. The routes return corresponds to the set of trips from GTFS that share the same stop list.
+ * @param validStopIds A set of valid stop IDs.
+ * @returns A mapping of route IDs to route details. The routes returned correspond to the set of trips from GTFS that share the same stop list.
  */
-const parseStopTimes = (stopTimesStream, validTripIds, validStopIds) => __awaiter(undefined, undefined, undefined, function* () {
+const parseStopTimes = (stopTimesStream, stopsMap, validTripIds, validStopIds) => __awaiter(undefined, undefined, undefined, function* () {
     var _a, e_2, _b, _c;
     var _d, _e;
+    /**
+     * Inserts a trip at the right place in the routes adjacency structure.
+     */
     const addTrip = (currentTripId) => {
         const gtfsRouteId = validTripIds.get(currentTripId);
         if (!gtfsRouteId) {
             stops = [];
-            stopTimes = [];
+            arrivalTimes = [];
+            departureTimes = [];
+            pickUpTypes = [];
+            dropOffTypes = [];
             return;
         }
-        const routeId = `${gtfsRouteId}_${hash(stops.join('$'))}`;
+        const routeId = `${gtfsRouteId}_${hashIds(stops)}`;
         let route = routes.get(routeId);
         if (!route) {
+            const stopsCount = stops.length;
+            const stopsArray = new Uint32Array(stops);
+            const stopTimesArray = new Uint32Array(stopsCount * 2);
+            for (let i = 0; i < stopsCount; i++) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                stopTimesArray[i * 2] = arrivalTimes[i];
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                stopTimesArray[i * 2 + 1] = departureTimes[i];
+            }
+            const pickUpDropOffTypesArray = new Uint8Array(stopsCount * 2);
+            for (let i = 0; i < stopsCount; i++) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                pickUpDropOffTypesArray[i * 2] = pickUpTypes[i];
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                pickUpDropOffTypesArray[i * 2 + 1] = dropOffTypes[i];
+            }
             route = {
                 serviceRouteId: gtfsRouteId,
-                stops: [...stops],
+                stops: stopsArray,
                 stopIndices: new Map(stops.map((stop, i) => [stop, i])),
-                stopTimes: [...stopTimes],
+                stopTimes: stopTimesArray,
+                pickUpDropOffTypes: pickUpDropOffTypesArray,
             };
             routes.set(routeId, route);
             for (const stop of stops) {
@@ -19597,31 +19638,59 @@ const parseStopTimes = (stopTimesStream, validTripIds, validStopIds) => __awaite
             }
         }
         else {
-            const tripFirstStop = stopTimes[0];
-            if (!tripFirstStop) {
+            const tripFirstStopDeparture = departureTimes[0];
+            if (tripFirstStopDeparture === undefined) {
                 throw new Error(`Empty trip ${currentTripId}`);
             }
-            // insert the stopTimes at the right position
-            let stopTimesIndex = 0;
-            for (let i = 0; i < route.stopTimes.length; i += stops.length) {
-                const currentDeparture = route.stopTimes[i];
-                if (currentDeparture &&
-                    tripFirstStop.departure > currentDeparture.departure) {
-                    stopTimesIndex = i + stops.length;
+            // Find the correct position to insert the new trip
+            const stopsCount = stops.length;
+            let insertPosition = 0;
+            const existingTripsCount = route.stopTimes.length / (stopsCount * 2);
+            for (let tripIndex = 0; tripIndex < existingTripsCount; tripIndex++) {
+                const currentDeparture = route.stopTimes[tripIndex * stopsCount * 2 + 1];
+                if (currentDeparture && tripFirstStopDeparture > currentDeparture) {
+                    insertPosition = (tripIndex + 1) * stopsCount;
                 }
                 else {
                     break;
                 }
             }
-            route.stopTimes.splice(stopTimesIndex, 0, ...stopTimes);
+            // insert data for the new trip at the right place
+            const newStopTimesLength = route.stopTimes.length + stopsCount * 2;
+            const newStopTimes = new Uint32Array(newStopTimesLength);
+            const newPickUpDropOffTypes = new Uint8Array(newStopTimesLength);
+            newStopTimes.set(route.stopTimes.slice(0, insertPosition * 2), 0);
+            newPickUpDropOffTypes.set(route.pickUpDropOffTypes.slice(0, insertPosition * 2), 0);
+            for (let i = 0; i < stopsCount; i++) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                newStopTimes[(insertPosition + i) * 2] = arrivalTimes[i];
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                newStopTimes[(insertPosition + i) * 2 + 1] = departureTimes[i];
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                newPickUpDropOffTypes[(insertPosition + i) * 2] = pickUpTypes[i];
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                newPickUpDropOffTypes[(insertPosition + i) * 2 + 1] = dropOffTypes[i];
+            }
+            const afterInsertionSlice = route.stopTimes.slice(insertPosition * 2);
+            newStopTimes.set(afterInsertionSlice, (insertPosition + stopsCount) * 2);
+            const afterInsertionTypesSlice = route.pickUpDropOffTypes.slice(insertPosition * 2);
+            newPickUpDropOffTypes.set(afterInsertionTypesSlice, (insertPosition + stopsCount) * 2);
+            route.stopTimes = newStopTimes;
+            route.pickUpDropOffTypes = newPickUpDropOffTypes;
         }
         stops = [];
-        stopTimes = [];
+        arrivalTimes = [];
+        departureTimes = [];
+        pickUpTypes = [];
+        dropOffTypes = [];
     };
     const routes = new Map();
     let previousSeq = 0;
     let stops = [];
-    let stopTimes = [];
+    let arrivalTimes = [];
+    let departureTimes = [];
+    let pickUpTypes = [];
+    let dropOffTypes = [];
     let currentTripId = undefined;
     try {
         for (var _f = true, _g = __asyncValues(parseCsv(stopTimesStream)), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
@@ -19640,24 +19709,20 @@ const parseStopTimes = (stopTimesStream, validTripIds, validStopIds) => __awaite
             if (line.pickup_type === 1 && line.drop_off_type === 1) {
                 continue;
             }
-            if (currentTripId &&
-                line.trip_id !== currentTripId &&
-                stops.length > 0 &&
-                stopTimes.length > 0) {
+            if (currentTripId && line.trip_id !== currentTripId && stops.length > 0) {
                 addTrip(currentTripId);
             }
             currentTripId = line.trip_id;
-            stops.push(line.stop_id);
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            stops.push(stopsMap.get(line.stop_id + '').id);
             const departure = (_d = line.departure_time) !== null && _d !== void 0 ? _d : line.arrival_time;
             const arrival = (_e = line.arrival_time) !== null && _e !== void 0 ? _e : line.departure_time;
-            stopTimes.push({
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                departure: toTime(departure),
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                arrival: toTime(arrival),
-                pickUpType: parsePickupDropOffType(line.pickup_type),
-                dropOffType: parsePickupDropOffType(line.drop_off_type),
-            });
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            arrivalTimes.push(toTime(arrival).toSeconds());
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            departureTimes.push(toTime(departure).toSeconds());
+            pickUpTypes.push(parsePickupDropOffType(line.pickup_type));
+            dropOffTypes.push(parsePickupDropOffType(line.drop_off_type));
             previousSeq = line.stop_sequence;
         }
     }
@@ -19677,15 +19742,15 @@ const parsePickupDropOffType = (gtfsType) => {
     switch (gtfsType) {
         default:
             console.warn(`Unknown pickup/drop-off type ${gtfsType}`);
-            return 'REGULAR';
+            return REGULAR;
         case 0:
-            return 'REGULAR';
+            return REGULAR;
         case 1:
-            return 'NOT_AVAILABLE';
+            return NOT_AVAILABLE;
         case 2:
-            return 'MUST_PHONE_AGENCY';
+            return MUST_PHONE_AGENCY;
         case 3:
-            return 'MUST_COORDINATE_WITH_DRIVER';
+            return MUST_COORDINATE_WITH_DRIVER;
     }
 };
 
@@ -19717,6 +19782,10 @@ class GtfsParser {
             const datetime = DateTime.fromJSDate(date);
             const validServiceIds = new Set();
             const validStopIds = new Set();
+            log.info(`Parsing ${STOPS_FILE}`);
+            const stopsStream = yield zip.stream(STOPS_FILE);
+            const parsedStops = yield parseStops(stopsStream, this.profile.platformParser);
+            log.info(`${parsedStops.size} parsed stops.`);
             if (entries[CALENDAR_FILE]) {
                 log.info(`Parsing ${CALENDAR_FILE}`);
                 const calendarStream = yield zip.stream(CALENDAR_FILE);
@@ -19741,18 +19810,17 @@ class GtfsParser {
             if (entries[TRANSFERS_FILE]) {
                 log.info(`Parsing ${TRANSFERS_FILE}`);
                 const transfersStream = yield zip.stream(TRANSFERS_FILE);
-                transfers = yield parseTransfers(transfersStream);
+                transfers = yield parseTransfers(transfersStream, parsedStops);
                 log.info(`${transfers.size} valid transfers.`);
             }
             log.info(`Parsing ${STOP_TIMES_FILE}`);
             const stopTimesStream = yield zip.stream(STOP_TIMES_FILE);
-            const routesAdjacency = yield parseStopTimes(stopTimesStream, trips, validStopIds);
+            const routesAdjacency = yield parseStopTimes(stopTimesStream, parsedStops, trips, validStopIds);
             const stopsAdjacency = buildStopsAdjacencyStructure(validStopIds, routesAdjacency, transfers);
             log.info(`${routesAdjacency.size} valid unique routes.`);
-            log.info(`Parsing ${STOPS_FILE}`);
-            const stopsStream = yield zip.stream(STOPS_FILE);
-            const stops = yield parseStops(stopsStream, this.profile.platformParser, validStopIds);
-            log.info(`${stops.size} valid stops.`);
+            log.info(`Removing unused stops.`);
+            const stops = indexStops(parsedStops, validStopIds);
+            log.info(`${stops.size} used stop stops, ${parsedStops.size - stops.size} unused.`);
             yield zip.close();
             const timetable = new Timetable(stopsAdjacency, routesAdjacency, validGtfsRoutes);
             log.info(`Building stops index.`);
@@ -19773,8 +19841,8 @@ class GtfsParser {
             const zip = new StreamZip.async({ file: this.path });
             log.info(`Parsing ${STOPS_FILE}`);
             const stopsStream = yield zip.stream(STOPS_FILE);
-            const stops = yield parseStops(stopsStream, this.profile.platformParser);
-            log.info(`${stops.size} valid stops.`);
+            const stops = indexStops(yield parseStops(stopsStream, this.profile.platformParser));
+            log.info(`${stops.size} parsed stops.`);
             yield zip.close();
             return new StopsIndex(stops);
         });
@@ -20028,11 +20096,11 @@ class Result {
         let fastestDestination = undefined;
         let fastestTime = undefined;
         for (const destination of destinations) {
-            const arrivalTime = this.earliestArrivals.get(destination);
+            const arrivalTime = this.earliestArrivals.get(destination.id);
             if (arrivalTime !== undefined) {
                 if (fastestTime === undefined ||
                     arrivalTime.time.toSeconds() < fastestTime.time.toSeconds()) {
-                    fastestDestination = destination;
+                    fastestDestination = destination.id;
                     fastestTime = arrivalTime;
                 }
             }
@@ -20071,7 +20139,7 @@ class Result {
                 this.earliestArrivalsPerRound[maxTransfers - 1]
             : this.earliestArrivals;
         for (const equivalentStop of equivalentStops) {
-            const arrivalTime = relevantArrivals.get(equivalentStop);
+            const arrivalTime = relevantArrivals.get(equivalentStop.id);
             if (arrivalTime !== undefined) {
                 if (earliestArrival === undefined ||
                     arrivalTime.time.toSeconds() < earliestArrival.time.toSeconds()) {
@@ -20159,16 +20227,16 @@ class Router {
         // Stops that have been improved at round k-1
         const markedStops = new Set();
         for (const originStop of origins) {
-            markedStops.add(originStop);
-            earliestArrivals.set(originStop, {
+            markedStops.add(originStop.id);
+            earliestArrivals.set(originStop.id, {
                 time: departureTime,
                 legNumber: 0,
-                origin: originStop,
+                origin: originStop.id,
             });
-            earliestArrivalsWithoutAnyLeg.set(originStop, {
+            earliestArrivalsWithoutAnyLeg.set(originStop.id, {
                 time: departureTime,
                 legNumber: 0,
-                origin: originStop,
+                origin: originStop.id,
             });
         }
         // on the first round we need to first consider transfers to discover all possible route origins
@@ -20186,12 +20254,14 @@ class Router {
                 const route = this.timetable.getRoute(routeId);
                 let currentTrip = undefined;
                 const hopOnIndex = route.stopIndices.get(hopOnStop);
-                // for each stops in the route starting with the hop-on one
+                // for each stop in the route starting with the hop-on one
                 for (let i = hopOnIndex; i < route.stops.length; i++) {
                     const currentStop = route.stops[i];
                     const stopNumbers = route.stops.length;
                     if (currentTrip !== undefined) {
-                        const currentStopTimes = route.stopTimes[currentTrip.trip * stopNumbers + i];
+                        const currentArrivalIndex = (currentTrip.trip * stopNumbers + i) * 2;
+                        const currentArrivalTime = Time.fromSeconds(route.stopTimes[currentArrivalIndex]);
+                        const currentDropOffType = route.pickUpDropOffTypes[i * 2 + 1];
                         const earliestArrivalAtCurrentStop = (_b = (_a = earliestArrivals.get(currentStop)) === null || _a === undefined ? undefined : _a.time) !== null && _b !== undefined ? _b : UNREACHED;
                         let arrivalToImprove = earliestArrivalAtCurrentStop;
                         if (destinations.length > 0) {
@@ -20199,31 +20269,31 @@ class Router {
                             // if multiple destinations are specified, the target pruning
                             // should compare to the earliest arrival at any of them
                             for (const destinationStop of destinations) {
-                                const earliestArrivalAtDestination = (_d = (_c = earliestArrivals.get(destinationStop)) === null || _c === undefined ? undefined : _c.time) !== null && _d !== undefined ? _d : UNREACHED;
+                                const earliestArrivalAtDestination = (_d = (_c = earliestArrivals.get(destinationStop.id)) === null || _c === undefined ? undefined : _c.time) !== null && _d !== undefined ? _d : UNREACHED;
                                 earliestArrivalsAtDestinations.push(earliestArrivalAtDestination);
                             }
                             const earliestArrivalAtDestination = Time.min(...earliestArrivalsAtDestinations);
                             arrivalToImprove = Time.min(earliestArrivalAtCurrentStop, earliestArrivalAtDestination);
                         }
-                        if (currentStopTimes.dropOffType !== 'NOT_AVAILABLE' &&
-                            currentStopTimes.arrival.toSeconds() <
-                                arrivalToImprove.toSeconds()) {
+                        if (currentDropOffType !== NOT_AVAILABLE &&
+                            currentArrivalTime.toSeconds() < arrivalToImprove.toSeconds()) {
                             const bestHopOnStopIndex = route.stopIndices.get(currentTrip.bestHopOnStop);
-                            const bestHopOnStopTimes = route.stopTimes[currentTrip.trip * stopNumbers + bestHopOnStopIndex];
+                            const bestHopOnStopDepartureIndex = currentTrip.trip * stopNumbers * 2 + bestHopOnStopIndex * 2 + 1;
+                            const bestHopOnDepartureTime = Time.fromSeconds(route.stopTimes[bestHopOnStopDepartureIndex]);
                             arrivalsAtCurrentRound.set(currentStop, {
-                                time: currentStopTimes.arrival,
+                                time: currentArrivalTime,
                                 legNumber: round,
                                 origin: currentTrip.origin,
                                 leg: {
                                     from: this.stopsIndex.findStopById(currentTrip.bestHopOnStop),
                                     to: this.stopsIndex.findStopById(currentStop),
-                                    departureTime: bestHopOnStopTimes.departure,
-                                    arrivalTime: currentStopTimes.arrival,
+                                    departureTime: bestHopOnDepartureTime,
+                                    arrivalTime: currentArrivalTime,
                                     route: this.timetable.getServiceRoute(route.serviceRouteId),
                                 },
                             });
                             earliestArrivals.set(currentStop, {
-                                time: currentStopTimes.arrival,
+                                time: currentArrivalTime,
                                 legNumber: round,
                                 origin: currentTrip.origin,
                             });
@@ -20236,7 +20306,7 @@ class Router {
                     if (earliestArrivalOnPreviousRound !== undefined &&
                         (currentTrip === undefined ||
                             earliestArrivalOnPreviousRound.toSeconds() <=
-                                route.stopTimes[currentTrip.trip * stopNumbers + i].departure.toSeconds())) {
+                                route.stopTimes[(currentTrip.trip * stopNumbers + i) * 2])) {
                         const earliestTrip = this.timetable.findEarliestTrip(route, currentStop, currentTrip === null || currentTrip === undefined ? undefined : currentTrip.trip, earliestArrivalOnPreviousRound);
                         if (earliestTrip !== undefined) {
                             currentTrip = {
@@ -20291,6 +20361,7 @@ const plotGraphToDotFile = (result, filePath) => {
 const startRepl = (stopsPath, timetablePath) => {
     const stopsIndex = StopsIndex.fromData(fs.readFileSync(stopsPath));
     const timetable = Timetable.fromData(fs.readFileSync(timetablePath));
+    console.log(`Minotor Transit Router CLI`);
     console.log('Enter your stop (.find) or routing (.route) queries. Type ".exit" to quit.');
     const replServer = repl.start({
         prompt: 'minotor> ',
@@ -20334,9 +20405,10 @@ const startRepl = (stopsPath, timetablePath) => {
                 this.displayPrompt();
                 return;
             }
-            const fromStop = stopsIndex.findStopById(fromId) ||
+            const fromStop = stopsIndex.findStopBySourceStopId(fromId) ||
                 stopsIndex.findStopsByName(fromId)[0];
-            const toStop = stopsIndex.findStopById(toId) || stopsIndex.findStopsByName(toId)[0];
+            const toStop = stopsIndex.findStopBySourceStopId(toId) ||
+                stopsIndex.findStopsByName(toId)[0];
             if (!fromStop) {
                 console.log(`No stop found for 'from' ID or name: ${fromId}`);
                 this.displayPrompt();
@@ -20350,21 +20422,21 @@ const startRepl = (stopsPath, timetablePath) => {
             const departureTime = Time.fromString(atTime);
             try {
                 const query = new Query.Builder()
-                    .from(fromStop.id)
-                    .to([toStop.id])
+                    .from(fromStop.sourceStopId)
+                    .to([toStop.sourceStopId])
                     .departureTime(departureTime)
                     .maxTransfers(maxTransfers)
                     .build();
                 const router = new Router(timetable, stopsIndex);
                 const result = router.route(query);
-                const arrivalTime = result.arrivalAt(toStop.id);
+                const arrivalTime = result.arrivalAt(toStop.sourceStopId);
                 if (arrivalTime === undefined) {
                     console.log(`Destination not reachable`);
                 }
                 else {
                     console.log(`Arriving to ${toStop.name} at ${arrivalTime.time.toString()} with ${arrivalTime.legNumber - 1} transfers from ${(_a = stopsIndex.findStopById(arrivalTime.origin)) === null || _a === void 0 ? void 0 : _a.name}.`);
                 }
-                const bestRoute = result.bestRoute(toStop.id);
+                const bestRoute = result.bestRoute(toStop.sourceStopId);
                 if (bestRoute) {
                     console.log(`Found route from ${fromStop.name} to ${toStop.name}:`);
                     prettyPrintRoute(bestRoute);
@@ -20411,9 +20483,10 @@ const startRepl = (stopsPath, timetablePath) => {
                 this.displayPrompt();
                 return;
             }
-            const fromStop = stopsIndex.findStopById(fromId) ||
+            const fromStop = stopsIndex.findStopBySourceStopId(fromId) ||
                 stopsIndex.findStopsByName(fromId)[0];
-            const toStop = stopsIndex.findStopById(toId) || stopsIndex.findStopsByName(toId)[0];
+            const toStop = stopsIndex.findStopBySourceStopId(toId) ||
+                stopsIndex.findStopsByName(toId)[0];
             if (!fromStop) {
                 console.log(`No stop found for 'from' ID or name: ${fromId}`);
                 this.displayPrompt();
@@ -20427,8 +20500,8 @@ const startRepl = (stopsPath, timetablePath) => {
             const departureTime = Time.fromString(atTime);
             try {
                 const query = new Query.Builder()
-                    .from(fromStop.id)
-                    .to([toStop.id])
+                    .from(fromStop.sourceStopId)
+                    .to([toStop.sourceStopId])
                     .departureTime(departureTime)
                     .maxTransfers(maxTransfers)
                     .build();