minotor 3.0.2 → 4.0.0

package/dist/timetable/proto/timetable.d.ts

@@ -37,7 +37,8 @@ export interface Route {
      *   1: NOT_AVAILABLE
      *   2: MUST_PHONE_AGENCY
      *   3: MUST_COORDINATE_WITH_DRIVER
-     * Format: [pickupTypeStop1, dropOffTypeStop1, pickupTypeStop2, dropOffTypeStop2, etc.]
+     * Format: [drop_off_1][pickup_1][drop_off_0][pickup_0]
+     * 2 bits per value
      */
     pickUpDropOffTypes: Uint8Array;
     /**

package/dist/timetable/route.d.ts

@@ -28,14 +28,16 @@ export declare class Route {
      */
     private readonly stopTimes;
     /**
-     * PickUp and DropOff types represented as a binary Uint8Array.
-     * Values:
+     * PickUp and DropOff types represented as a 2-bit encoded Uint8Array.
+     * Values (2 bits each):
      *   0: REGULAR
      *   1: NOT_AVAILABLE
      *   2: MUST_PHONE_AGENCY
      *   3: MUST_COORDINATE_WITH_DRIVER
-     * Format: [pickupTypeStop1, dropOffTypeStop1, pickupTypeStop2, dropOffTypeStop2, etc.]
-     * TODO: Encode 4 values instead of 1 in 8 bits.
+     *
+     * Encoding format: Each byte contains 2 pickup/drop-off pairs (4 bits each)
+     * Bit layout per byte: [pickup_1 (2 bits)][drop_off_1 (2 bits)][pickup_0 (2 bits)][drop_off_0 (2 bits)]
+     * Example: For stops 0 and 1 in a trip, one byte encodes all 4 values
      */
     private readonly pickUpDropOffTypes;
     /**

package/dist/timetable/timetable.d.ts

@@ -20,7 +20,7 @@ export type ServiceRoute = {
 };
 export type ServiceRoutesMap = Map<ServiceRouteId, ServiceRoute>;
 export declare const ALL_TRANSPORT_MODES: Set<RouteType>;
-export declare const CURRENT_VERSION = "0.0.3";
+export declare const CURRENT_VERSION = "0.0.4";
 /**
  * The internal transit timetable format.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minotor",
-  "version": "3.0.2",
+  "version": "4.0.0",
   "description": "A lightweight client-side transit routing library.",
   "keywords": [
     "minotor",

package/src/__e2e__/timetable/timetable.bin

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6725771bfd0e287d515b3ddd74202eab8023b39808818e422bd57b564013b37c
-size 29833126
+oid sha256:a88ef7ca621f3c18af125d01518732475e649398d50d28981af134aeee17fa6c
+size 24889916

package/src/cli/repl.ts

@@ -121,7 +121,6 @@ export const startRepl = (stopsPath: string, timetablePath: string) => {
         if (bestRoute) {
           console.log(`Found route from ${fromStop.name} to ${toStop.name}:`);
           console.log(bestRoute.toString());
-          console.log(JSON.stringify(bestRoute.asJson(), null, 2));
         } else {
           console.log('No route found');
         }

package/src/gtfs/__tests__/trips.test.ts

@@ -14,6 +14,7 @@ import { ParsedStopsMap } from '../stops.js';
 import { TransfersMap } from '../transfers.js';
 import {
   buildStopsAdjacencyStructure,
+  encodePickUpDropOffTypes,
   parseStopTimes,
   parseTrips,
   TripIdsMap,
@@ -27,7 +28,7 @@ describe('buildStopsAdjacencyStructure', () => {
         'routeA',
         new Route(
           new Uint16Array(),
-          new Uint8Array(),
+          encodePickUpDropOffTypes([], []),
           new Uint32Array([0, 1]),
           'service1',
         ),
@@ -61,7 +62,7 @@ describe('buildStopsAdjacencyStructure', () => {
         'routeA',
         new Route(
           new Uint16Array(),
-          new Uint8Array(),
+          encodePickUpDropOffTypes([], []),
           new Uint32Array([0, 1]),
           'service1',
         ),
@@ -222,7 +223,7 @@ describe('GTFS stop times parser', () => {
               Time.fromHMS(8, 10, 0).toMinutes(),
               Time.fromHMS(8, 15, 0).toMinutes(),
             ]),
-            new Uint8Array([REGULAR, REGULAR, REGULAR, REGULAR]),
+            encodePickUpDropOffTypes([REGULAR, REGULAR], [REGULAR, REGULAR]),
             new Uint32Array([0, 1]),
             'routeA',
           ),
@@ -292,16 +293,10 @@ describe('GTFS stop times parser', () => {
               Time.fromHMS(9, 10, 0).toMinutes(),
               Time.fromHMS(9, 15, 0).toMinutes(),
             ]),
-            new Uint8Array([
-              REGULAR,
-              REGULAR,
-              REGULAR,
-              REGULAR,
-              REGULAR,
-              REGULAR,
-              REGULAR,
-              REGULAR,
-            ]),
+            encodePickUpDropOffTypes(
+              [REGULAR, REGULAR, REGULAR, REGULAR],
+              [REGULAR, REGULAR, REGULAR, REGULAR],
+            ),
             new Uint32Array([0, 1]),
             'routeA',
           ),
@@ -371,16 +366,10 @@ describe('GTFS stop times parser', () => {
               Time.fromHMS(9, 10, 0).toMinutes(),
               Time.fromHMS(9, 15, 0).toMinutes(),
             ]),
-            new Uint8Array([
-              REGULAR,
-              REGULAR,
-              REGULAR,
-              REGULAR,
-              REGULAR,
-              REGULAR,
-              REGULAR,
-              REGULAR,
-            ]),
+            encodePickUpDropOffTypes(
+              [REGULAR, REGULAR, REGULAR, REGULAR],
+              [REGULAR, REGULAR, REGULAR, REGULAR],
+            ),
             new Uint32Array([0, 1]),
             'routeA',
           ),
@@ -445,7 +434,7 @@ describe('GTFS stop times parser', () => {
               Time.fromHMS(8, 10, 0).toMinutes(),
               Time.fromHMS(8, 15, 0).toMinutes(),
             ]),
-            new Uint8Array([REGULAR, REGULAR, REGULAR, REGULAR]),
+            encodePickUpDropOffTypes([REGULAR, REGULAR], [REGULAR, REGULAR]),
             new Uint32Array([0, 1]),
             'routeA',
           ),
@@ -457,7 +446,7 @@ describe('GTFS stop times parser', () => {
               Time.fromHMS(9, 0, 0).toMinutes(),
               Time.fromHMS(9, 15, 0).toMinutes(),
             ]),
-            new Uint8Array([REGULAR, REGULAR]),
+            encodePickUpDropOffTypes([REGULAR], [REGULAR]),
             new Uint32Array([0]),
             'routeA',
           ),
@@ -516,7 +505,7 @@ describe('GTFS stop times parser', () => {
               Time.fromHMS(8, 0, 0).toMinutes(),
               Time.fromHMS(8, 5, 0).toMinutes(),
             ]),
-            new Uint8Array([REGULAR, REGULAR]),
+            encodePickUpDropOffTypes([REGULAR], [REGULAR]),
             new Uint32Array([0]),
             'routeA',
           ),

package/src/gtfs/parser.ts

@@ -51,6 +51,7 @@ export class GtfsParser {
   async parse(
     date: Date,
   ): Promise<{ timetable: Timetable; stopsIndex: StopsIndex }> {
+    log.setLevel('INFO');
     const zip = new StreamZip.async({ file: this.path });
     const entries = await zip.entries();
     const datetime = DateTime.fromJSDate(date);
@@ -59,50 +60,75 @@ export class GtfsParser {
     const validStopIds = new Set<StopId>();
 
     log.info(`Parsing ${STOPS_FILE}`);
+    const stopsStart = performance.now();
     const stopsStream = await zip.stream(STOPS_FILE);
     const parsedStops = await parseStops(
       stopsStream,
       this.profile.platformParser,
     );
-    log.info(`${parsedStops.size} parsed stops.`);
+    const stopsEnd = performance.now();
+    log.info(
+      `${parsedStops.size} parsed stops. (${(stopsEnd - stopsStart).toFixed(2)}ms)`,
+    );
 
     if (entries[CALENDAR_FILE]) {
       log.info(`Parsing ${CALENDAR_FILE}`);
+      const calendarStart = performance.now();
       const calendarStream = await zip.stream(CALENDAR_FILE);
       await parseCalendar(calendarStream, validServiceIds, datetime);
-      log.info(`${validServiceIds.size} valid services.`);
+      const calendarEnd = performance.now();
+      log.info(
+        `${validServiceIds.size} valid services. (${(calendarEnd - calendarStart).toFixed(2)}ms)`,
+      );
     }
 
     if (entries[CALENDAR_DATES_FILE]) {
       log.info(`Parsing ${CALENDAR_DATES_FILE}`);
+      const calendarDatesStart = performance.now();
       const calendarDatesStream = await zip.stream(CALENDAR_DATES_FILE);
       await parseCalendarDates(calendarDatesStream, validServiceIds, datetime);
-      log.info(`${validServiceIds.size} valid services.`);
+      const calendarDatesEnd = performance.now();
+      log.info(
+        `${validServiceIds.size} valid services. (${(calendarDatesEnd - calendarDatesStart).toFixed(2)}ms)`,
+      );
     }
 
     log.info(`Parsing ${ROUTES_FILE}`);
+    const routesStart = performance.now();
     const routesStream = await zip.stream(ROUTES_FILE);
     const validGtfsRoutes = await parseRoutes(routesStream, this.profile);
-    log.info(`${validGtfsRoutes.size} valid GTFS routes.`);
+    const routesEnd = performance.now();
+    log.info(
+      `${validGtfsRoutes.size} valid GTFS routes. (${(routesEnd - routesStart).toFixed(2)}ms)`,
+    );
 
     log.info(`Parsing ${TRIPS_FILE}`);
+    const tripsStart = performance.now();
     const tripsStream = await zip.stream(TRIPS_FILE);
     const trips = await parseTrips(
       tripsStream,
       validServiceIds,
       validGtfsRoutes,
     );
-    log.info(`${trips.size} valid trips.`);
+    const tripsEnd = performance.now();
+    log.info(
+      `${trips.size} valid trips. (${(tripsEnd - tripsStart).toFixed(2)}ms)`,
+    );
 
     let transfers = new Map() as TransfersMap;
     if (entries[TRANSFERS_FILE]) {
       log.info(`Parsing ${TRANSFERS_FILE}`);
+      const transfersStart = performance.now();
       const transfersStream = await zip.stream(TRANSFERS_FILE);
       transfers = await parseTransfers(transfersStream, parsedStops);
-      log.info(`${transfers.size} valid transfers.`);
+      const transfersEnd = performance.now();
+      log.info(
+        `${transfers.size} valid transfers. (${(transfersEnd - transfersStart).toFixed(2)}ms)`,
+      );
     }
 
     log.info(`Parsing ${STOP_TIMES_FILE}`);
+    const stopTimesStart = performance.now();
     const stopTimesStream = await zip.stream(STOP_TIMES_FILE);
     const routesAdjacency = await parseStopTimes(
       stopTimesStream,
@@ -115,12 +141,17 @@ export class GtfsParser {
       routesAdjacency,
       transfers,
     );
-    log.info(`${routesAdjacency.size} valid unique routes.`);
+    const stopTimesEnd = performance.now();
+    log.info(
+      `${routesAdjacency.size} valid unique routes. (${(stopTimesEnd - stopTimesStart).toFixed(2)}ms)`,
+    );
 
     log.info(`Removing unused stops.`);
+    const indexStopsStart = performance.now();
     const stops = indexStops(parsedStops, validStopIds);
+    const indexStopsEnd = performance.now();
     log.info(
-      `${stops.size} used stop stops, ${parsedStops.size - stops.size} unused.`,
+      `${stops.size} used stop stops, ${parsedStops.size - stops.size} unused. (${(indexStopsEnd - indexStopsStart).toFixed(2)}ms)`,
     );
 
     await zip.close();
@@ -132,7 +163,12 @@ export class GtfsParser {
     );
 
     log.info(`Building stops index.`);
+    const stopsIndexStart = performance.now();
     const stopsIndex = new StopsIndex(stops);
+    const stopsIndexEnd = performance.now();
+    log.info(
+      `Stops index built. (${(stopsIndexEnd - stopsIndexStart).toFixed(2)}ms)`,
+    );
 
     log.info('Parsing complete.');
     return { timetable, stopsIndex };
@@ -149,12 +185,16 @@ export class GtfsParser {
     const zip = new StreamZip.async({ file: this.path });
 
     log.info(`Parsing ${STOPS_FILE}`);
+    const stopsStart = performance.now();
     const stopsStream = await zip.stream(STOPS_FILE);
     const stops = indexStops(
       await parseStops(stopsStream, this.profile.platformParser),
     );
+    const stopsEnd = performance.now();
 
-    log.info(`${stops.size} parsed stops.`);
+    log.info(
+      `${stops.size} parsed stops. (${(stopsEnd - stopsStart).toFixed(2)}ms)`,
+    );
 
     await zip.close();
 

package/src/gtfs/trips.ts

@@ -32,10 +32,10 @@ type TripEntry = {
 
 export type GtfsPickupDropOffType =
   | '' // Not specified
-  | 0 // Regularly scheduled
-  | 1 // Not available
-  | 2 // Must phone agency
-  | 3; // Must coordinate with driver
+  | '0' // Regularly scheduled
+  | '1' // Not available
+  | '2' // Must phone agency
+  | '3'; // Must coordinate with driver
 
 type StopTimeEntry = {
   trip_id: TripId;
@@ -49,6 +49,121 @@ type StopTimeEntry = {
 
 export type SerializedPickUpDropOffType = 0 | 1 | 2 | 3;
 
+/**
+ * Intermediate data structure for building routes during parsing
+ */
+type RouteBuilder = {
+  serviceRouteId: ServiceRouteId;
+  stops: StopId[];
+  trips: Array<{
+    firstDeparture: number;
+    arrivalTimes: number[];
+    departureTimes: number[];
+    pickUpTypes: SerializedPickUpDropOffType[];
+    dropOffTypes: SerializedPickUpDropOffType[];
+  }>;
+};
+
+/**
+ * Encodes pickup/drop-off types into a Uint8Array using 2 bits per value.
+ * Layout per byte: [drop_off_1][pickup_1][drop_off_0][pickup_0] for stops 0 and 1
+ */
+export const encodePickUpDropOffTypes = (
+  pickUpTypes: SerializedPickUpDropOffType[],
+  dropOffTypes: SerializedPickUpDropOffType[],
+): Uint8Array => {
+  const stopsCount = pickUpTypes.length;
+  // Each byte stores 2 pickup/drop-off pairs (4 bits each)
+  const arraySize = Math.ceil(stopsCount / 2);
+  const encoded = new Uint8Array(arraySize);
+
+  for (let i = 0; i < stopsCount; i++) {
+    const byteIndex = Math.floor(i / 2);
+    const isSecondPair = i % 2 === 1;
+    const dropOffType = dropOffTypes[i];
+    const pickUpType = pickUpTypes[i];
+
+    if (
+      dropOffType !== undefined &&
+      pickUpType !== undefined &&
+      byteIndex < encoded.length
+    ) {
+      if (isSecondPair) {
+        // Second pair: upper 4 bits
+        const currentByte = encoded[byteIndex];
+        if (currentByte !== undefined) {
+          encoded[byteIndex] =
+            currentByte | (dropOffType << 4) | (pickUpType << 6);
+        }
+      } else {
+        // First pair: lower 4 bits
+        const currentByte = encoded[byteIndex];
+        if (currentByte !== undefined) {
+          encoded[byteIndex] = currentByte | dropOffType | (pickUpType << 2);
+        }
+      }
+    }
+  }
+  return encoded;
+};
+
+/**
+ * Sorts trips by departure time and creates optimized typed arrays
+ */
+const finalizeRouteFromBuilder = (builder: RouteBuilder): SerializedRoute => {
+  builder.trips.sort((a, b) => a.firstDeparture - b.firstDeparture);
+
+  const stopsCount = builder.stops.length;
+  const tripsCount = builder.trips.length;
+  const stopsArray = new Uint32Array(builder.stops);
+  const stopTimesArray = new Uint16Array(stopsCount * tripsCount * 2);
+  const allPickUpTypes: SerializedPickUpDropOffType[] = [];
+  const allDropOffTypes: SerializedPickUpDropOffType[] = [];
+
+  for (let tripIndex = 0; tripIndex < tripsCount; tripIndex++) {
+    const trip = builder.trips[tripIndex];
+    if (!trip) {
+      throw new Error(`Missing trip data at index ${tripIndex}`);
+    }
+    const baseIndex = tripIndex * stopsCount * 2;
+
+    for (let stopIndex = 0; stopIndex < stopsCount; stopIndex++) {
+      const timeIndex = baseIndex + stopIndex * 2;
+      const arrivalTime = trip.arrivalTimes[stopIndex];
+      const departureTime = trip.departureTimes[stopIndex];
+      const pickUpType = trip.pickUpTypes[stopIndex];
+      const dropOffType = trip.dropOffTypes[stopIndex];
+
+      if (
+        arrivalTime === undefined ||
+        departureTime === undefined ||
+        pickUpType === undefined ||
+        dropOffType === undefined
+      ) {
+        throw new Error(
+          `Missing trip data for trip ${tripIndex} at stop ${stopIndex}`,
+        );
+      }
+
+      stopTimesArray[timeIndex] = arrivalTime;
+      stopTimesArray[timeIndex + 1] = departureTime;
+      allDropOffTypes.push(dropOffType);
+      allPickUpTypes.push(pickUpType);
+    }
+  }
+  // Use 2-bit encoding for pickup/drop-off types
+  const pickUpDropOffTypesArray = encodePickUpDropOffTypes(
+    allPickUpTypes,
+    allDropOffTypes,
+  );
+  return {
+    serviceRouteId: builder.serviceRouteId,
+    stops: stopsArray,
+    stopTimes: stopTimesArray,
+    pickUpDropOffTypes: pickUpDropOffTypesArray,
+  };
+};
+
 /**
  * Parses the trips.txt file from a GTFS feed
  *
@@ -126,11 +241,12 @@ export const parseStopTimes = async (
   validStopIds: Set<StopId>,
 ): Promise<RoutesAdjacency> => {
   /**
-   * Inserts a trip at the right place in the routes adjacency structure.
+   * Adds a trip to the appropriate route builder
    */
   const addTrip = (currentTripId: TripId) => {
     const gtfsRouteId = validTripIds.get(currentTripId);
-    if (!gtfsRouteId) {
+
+    if (!gtfsRouteId || stops.length === 0) {
       stops = [];
       arrivalTimes = [];
       departureTimes = [];
@@ -138,90 +254,41 @@ export const parseStopTimes = async (
       dropOffTypes = [];
       return;
     }
+
     const routeId = `${gtfsRouteId}_${hashIds(stops)}`;
 
-    let route = routes.get(routeId);
-    if (!route) {
-      const stopsCount = stops.length;
-      const stopsArray = new Uint32Array(stops);
-      const stopTimesArray = new Uint16Array(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 = {
+    const firstDeparture = departureTimes[0];
+    if (firstDeparture === undefined) {
+      console.warn(`Empty trip ${currentTripId}`);
+      stops = [];
+      arrivalTimes = [];
+      departureTimes = [];
+      pickUpTypes = [];
+      dropOffTypes = [];
+      return;
+    }
+
+    let routeBuilder = routeBuilders.get(routeId);
+    if (!routeBuilder) {
+      routeBuilder = {
         serviceRouteId: gtfsRouteId,
-        stops: stopsArray,
-        stopTimes: stopTimesArray,
-        pickUpDropOffTypes: pickUpDropOffTypesArray,
+        stops: [...stops],
+        trips: [],
       };
-      routes.set(routeId, route);
+      routeBuilders.set(routeId, routeBuilder);
       for (const stop of stops) {
         validStopIds.add(stop);
       }
-    } else {
-      const tripFirstStopDeparture = departureTimes[0];
-      if (tripFirstStopDeparture === undefined) {
-        throw new Error(`Empty trip ${currentTripId}`);
-      }
-
-      // 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;
-        }
-      }
-
-      // insert data for the new trip at the right place
-      const newStopTimesLength = route.stopTimes.length + stopsCount * 2;
-      const newStopTimes = new Uint16Array(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,
-      );
+    routeBuilder.trips.push({
+      firstDeparture,
+      arrivalTimes: [...arrivalTimes],
+      departureTimes: [...departureTimes],
+      pickUpTypes: [...pickUpTypes],
+      dropOffTypes: [...dropOffTypes],
+    });
 
-      route.stopTimes = newStopTimes;
-      route.pickUpDropOffTypes = newPickUpDropOffTypes;
-    }
     stops = [];
     arrivalTimes = [];
     departureTimes = [];
@@ -229,7 +296,7 @@ export const parseStopTimes = async (
     dropOffTypes = [];
   };
 
-  const routes: Map<RouteId, SerializedRoute> = new Map();
+  const routeBuilders: Map<RouteId, RouteBuilder> = new Map();
 
   let previousSeq = 0;
   let stops: StopId[] = [];
@@ -242,7 +309,9 @@ export const parseStopTimes = async (
   for await (const rawLine of parseCsv(stopTimesStream, ['stop_sequence'])) {
     const line = rawLine as StopTimeEntry;
     if (line.trip_id === currentTripId && line.stop_sequence <= previousSeq) {
-      console.warn(`Stop sequences not increasing for trip ${line.trip_id}.`);
+      console.warn(
+        `Stop sequences not increasing for trip ${line.trip_id}: ${line.stop_sequence} > ${previousSeq}.`,
+      );
       continue;
     }
     if (!line.arrival_time && !line.departure_time) {
@@ -251,21 +320,32 @@ export const parseStopTimes = async (
       );
       continue;
     }
-    if (line.pickup_type === 1 && line.drop_off_type === 1) {
+    if (line.pickup_type === '1' && line.drop_off_type === '1') {
       continue;
     }
     if (currentTripId && line.trip_id !== currentTripId && stops.length > 0) {
       addTrip(currentTripId);
     }
     currentTripId = line.trip_id;
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    stops.push(stopsMap.get(line.stop_id)!.id);
+
+    const stopData = stopsMap.get(line.stop_id);
+    if (!stopData) {
+      console.warn(`Unknown stop ID: ${line.stop_id}`);
+      continue;
+    }
+    stops.push(stopData.id);
+
     const departure = line.departure_time ?? line.arrival_time;
     const arrival = line.arrival_time ?? line.departure_time;
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    arrivalTimes.push(toTime(arrival!).toMinutes());
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    departureTimes.push(toTime(departure!).toMinutes());
+
+    if (!arrival || !departure) {
+      console.warn(
+        `Missing time data for ${line.trip_id} at stop ${line.stop_id}`,
+      );
+      continue;
+    }
+    arrivalTimes.push(toTime(arrival).toMinutes());
+    departureTimes.push(toTime(departure).toMinutes());
     pickUpTypes.push(parsePickupDropOffType(line.pickup_type));
     dropOffTypes.push(parsePickupDropOffType(line.drop_off_type));
 
@@ -276,7 +356,8 @@ export const parseStopTimes = async (
   }
 
   const routesAdjacency: RoutesAdjacency = new Map<RouteId, Route>();
-  for (const [routeId, routeData] of routes) {
+  for (const [routeId, routeBuilder] of routeBuilders) {
+    const routeData = finalizeRouteFromBuilder(routeBuilder);
     routesAdjacency.set(
       routeId,
       new Route(
@@ -296,13 +377,13 @@ const parsePickupDropOffType = (
   switch (gtfsType) {
     default:
       return REGULAR;
-    case 0:
+    case '0':
       return REGULAR;
-    case 1:
+    case '1':
       return NOT_AVAILABLE;
-    case 2:
+    case '2':
       return MUST_PHONE_AGENCY;
-    case 3:
+    case '3':
       return MUST_COORDINATE_WITH_DRIVER;
   }
 };