minotor 8.0.0 → 9.0.1

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

@@ -3,8 +3,17 @@ import { Readable } from 'node:stream';
 import { describe, it } from 'node:test';
 
 import { Duration } from '../../timetable/duration.js';
+import { Route } from '../../timetable/route.js';
+import { Time } from '../../timetable/time.js';
+import { Timetable } from '../../timetable/timetable.js';
+import { encode } from '../../timetable/tripBoardingId.js';
 import { GtfsStopsMap } from '../stops.js';
-import { parseTransfers } from '../transfers.js';
+import {
+  buildTripContinuations,
+  GtfsTripContinuation,
+  parseTransfers,
+} from '../transfers.js';
+import { TripsMapping } from '../trips.js';
 
 describe('GTFS transfers parser', () => {
   it('should correctly parse valid transfers', async () => {
@@ -13,7 +22,7 @@ describe('GTFS transfers parser', () => {
       'from_stop_id,to_stop_id,transfer_type,min_transfer_time\n',
     );
     mockedStream.push('"1100084","8014440:0:1","2","180"\n');
-    mockedStream.push('"1100097","8014447","2","240"\n');
+    mockedStream.push('"1100097","8014447","0","240"\n');
     mockedStream.push(null);
 
     const stopsMap: GtfsStopsMap = new Map([
@@ -60,6 +69,7 @@ describe('GTFS transfers parser', () => {
     ]);
 
     const result = await parseTransfers(mockedStream, stopsMap);
+
     const expectedTransfers = new Map([
       [
         0, // Internal ID for stop '1100084'
@@ -76,7 +86,7 @@ describe('GTFS transfers parser', () => {
         [
           {
             destination: 3, // Internal ID for stop '8014447'
-            type: 'REQUIRES_MINIMAL_TIME',
+            type: 'RECOMMENDED',
             minTransferTime: Duration.fromSeconds(240),
           },
         ],
@@ -84,10 +94,10 @@ describe('GTFS transfers parser', () => {
     ]);
 
     assert.deepEqual(result.transfers, expectedTransfers);
-    assert.deepEqual(result.tripContinuations, new Map());
+    assert.deepEqual(result.tripContinuations, []);
   });
 
-  it('should ignore impossible transfer types', async () => {
+  it('should ignore impossible transfer types (3 and 5)', async () => {
     const mockedStream = new Readable();
     mockedStream.push(
       'from_stop_id,to_stop_id,transfer_type,min_transfer_time\n',
@@ -140,35 +150,37 @@ describe('GTFS transfers parser', () => {
     ]);
 
     const result = await parseTransfers(mockedStream, stopsMap);
+
     assert.deepEqual(result.transfers, new Map());
-    assert.deepEqual(result.tripContinuations, new Map());
+    assert.deepEqual(result.tripContinuations, []);
   });
 
-  it('should ignore unsupported transfer types between routes', async () => {
+  it('should ignore transfers with missing stop IDs', async () => {
     const mockedStream = new Readable();
     mockedStream.push(
-      'from_route_id,to_route_id,transfer_type,min_transfer_time\n',
+      'from_stop_id,to_stop_id,transfer_type,min_transfer_time\n',
     );
-    mockedStream.push('"1100084","8014440","2","180"\n');
+    mockedStream.push(',"8014440:0:1","2","180"\n');
+    mockedStream.push('"1100097",,"0","240"\n');
     mockedStream.push(null);
 
     const stopsMap: GtfsStopsMap = new Map([
       [
-        '1100084',
+        '8014440:0:1',
         {
-          id: 0,
-          sourceStopId: '1100084',
-          name: 'Test Stop 1',
+          id: 1,
+          sourceStopId: '8014440:0:1',
+          name: 'Test Stop 2',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
       [
-        '8014440',
+        '1100097',
         {
-          id: 1,
-          sourceStopId: '8014440',
-          name: 'Test Stop 2',
+          id: 2,
+          sourceStopId: '1100097',
+          name: 'Test Stop 3',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
@@ -176,16 +188,18 @@ describe('GTFS transfers parser', () => {
     ]);
 
     const result = await parseTransfers(mockedStream, stopsMap);
+
     assert.deepEqual(result.transfers, new Map());
-    assert.deepEqual(result.tripContinuations, new Map());
+    assert.deepEqual(result.tripContinuations, []);
   });
 
-  it('should ignore unsupported transfer types between trips', async () => {
+  it('should correctly parse in-seat transfers (type 4)', async () => {
     const mockedStream = new Readable();
     mockedStream.push(
-      'from_trip_id,to_trip_id,transfer_type,min_transfer_time\n',
+      'from_stop_id,to_stop_id,from_trip_id,to_trip_id,transfer_type,min_transfer_time\n',
     );
-    mockedStream.push('"1100084","8014440","2","180"\n');
+    mockedStream.push('"1100084","8014440:0:1","trip1","trip2","4","0"\n');
+    mockedStream.push('"1100097","8014447","trip3","trip4","4","0"\n');
     mockedStream.push(null);
 
     const stopsMap: GtfsStopsMap = new Map([
@@ -200,130 +214,106 @@ describe('GTFS transfers parser', () => {
         },
       ],
       [
-        '8014440',
+        '8014440:0:1',
         {
           id: 1,
-          sourceStopId: '8014440',
+          sourceStopId: '8014440:0:1',
           name: 'Test Stop 2',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
-    ]);
-
-    const result = await parseTransfers(mockedStream, stopsMap);
-    assert.deepEqual(result.transfers, new Map());
-    assert.deepEqual(result.tripContinuations, new Map());
-  });
-
-  it('should allow missing minimum transfer time', async () => {
-    const mockedStream = new Readable();
-    mockedStream.push(
-      'from_stop_id,to_stop_id,transfer_type,min_transfer_time\n',
-    );
-    mockedStream.push('"1100084","8014440:0:1","2"\n');
-    mockedStream.push(null);
-
-    const stopsMap: GtfsStopsMap = new Map([
       [
-        '1100084',
+        '1100097',
         {
-          id: 0,
-          sourceStopId: '1100084',
-          name: 'Test Stop 1',
+          id: 2,
+          sourceStopId: '1100097',
+          name: 'Test Stop 3',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
       [
-        '8014440:0:1',
+        '8014447',
         {
-          id: 1,
-          sourceStopId: '8014440:0:1',
-          name: 'Test Stop 2',
+          id: 3,
+          sourceStopId: '8014447',
+          name: 'Test Stop 4',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
     ]);
+
     const result = await parseTransfers(mockedStream, stopsMap);
-    assert.deepEqual(
-      result.transfers,
-      new Map([
-        [
-          0, // Internal ID for stop '1100084'
-          [
-            {
-              destination: 1, // Internal ID for stop '8014440:0:1'
-              type: 'REQUIRES_MINIMAL_TIME',
-            },
-          ],
-        ],
-      ]),
-    );
-    assert.deepEqual(result.tripContinuations, new Map());
-  });
 
-  it('should handle empty transfers', async () => {
-    const mockedStream = new Readable();
-    mockedStream.push(
-      'from_stop_id,to_stop_id,transfer_type,min_transfer_time\n',
-    );
-    mockedStream.push(null);
+    const expectedTripContinuations = [
+      {
+        fromStop: 0,
+        fromTrip: 'trip1',
+        toStop: 1,
+        toTrip: 'trip2',
+      },
+      {
+        fromStop: 2,
+        fromTrip: 'trip3',
+        toStop: 3,
+        toTrip: 'trip4',
+      },
+    ];
 
-    const stopsMap: GtfsStopsMap = new Map();
-
-    const result = await parseTransfers(mockedStream, stopsMap);
     assert.deepEqual(result.transfers, new Map());
-    assert.deepEqual(result.tripContinuations, new Map());
+    assert.deepEqual(result.tripContinuations, expectedTripContinuations);
   });
 
-  it('should correctly parse valid trip continuations (in-seat transfers)', async () => {
+  it('should ignore in-seat transfers with missing trip IDs', async () => {
     const mockedStream = new Readable();
     mockedStream.push(
-      'from_stop_id,to_stop_id,from_trip_id,to_trip_id,transfer_type\n',
+      'from_stop_id,to_stop_id,from_trip_id,to_trip_id,transfer_type,min_transfer_time\n',
     );
-    mockedStream.push('"stop1","stop2","trip1","trip2","4"\n');
-    mockedStream.push('"stop3","stop4","trip3","trip4","4"\n');
+    mockedStream.push('"1100084","8014440:0:1",,"trip2","4","0"\n');
+    mockedStream.push('"1100097","8014447","trip3",,"4","0"\n');
+    mockedStream.push('"1100098","8014448","","trip5","4","0"\n');
+    mockedStream.push('"1100099","8014449","trip6","","4","0"\n');
     mockedStream.push(null);
 
     const stopsMap: GtfsStopsMap = new Map([
       [
-        'stop1',
+        '1100084',
         {
           id: 0,
-          sourceStopId: 'stop1',
-          name: 'Stop 1',
+          sourceStopId: '1100084',
+          name: 'Test Stop 1',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
       [
-        'stop2',
+        '8014440:0:1',
         {
           id: 1,
-          sourceStopId: 'stop2',
-          name: 'Stop 2',
+          sourceStopId: '8014440:0:1',
+          name: 'Test Stop 2',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
       [
-        'stop3',
+        '1100097',
         {
           id: 2,
-          sourceStopId: 'stop3',
-          name: 'Stop 3',
+          sourceStopId: '1100097',
+          name: 'Test Stop 3',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
       [
-        'stop4',
+        '8014447',
         {
           id: 3,
-          sourceStopId: 'stop4',
-          name: 'Stop 4',
+          sourceStopId: '8014447',
+          name: 'Test Stop 4',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
@@ -332,136 +322,130 @@ describe('GTFS transfers parser', () => {
 
     const result = await parseTransfers(mockedStream, stopsMap);
 
-    const expectedTripContinuations = new Map([
-      [
-        0, // from_stop_id 'stop1' -> internal ID 0
-        [
-          {
-            fromTrip: 'trip1',
-            toTrip: 'trip2',
-            hopOnStop: 1, // to_stop_id 'stop2' -> internal ID 1
-          },
-        ],
-      ],
-      [
-        2, // from_stop_id 'stop3' -> internal ID 2
-        [
-          {
-            fromTrip: 'trip3',
-            toTrip: 'trip4',
-            hopOnStop: 3, // to_stop_id 'stop4' -> internal ID 3
-          },
-        ],
-      ],
-    ]);
-
     assert.deepEqual(result.transfers, new Map());
-    assert.deepEqual(result.tripContinuations, expectedTripContinuations);
+    assert.deepEqual(result.tripContinuations, []);
   });
 
-  it('should handle multiple trip continuations from the same stop', async () => {
+  it('should ignore unsupported transfer types between trips', async () => {
     const mockedStream = new Readable();
     mockedStream.push(
-      'from_stop_id,to_stop_id,from_trip_id,to_trip_id,transfer_type\n',
+      'from_stop_id,to_stop_id,from_trip_id,to_trip_id,transfer_type,min_transfer_time\n',
     );
-    mockedStream.push('"stop1","stop2","trip1","trip2","4"\n');
-    mockedStream.push('"stop1","stop3","trip1","trip3","4"\n');
+    mockedStream.push('"1100084","8014440:0:1","trip1","trip2","1","0"\n');
     mockedStream.push(null);
 
     const stopsMap: GtfsStopsMap = new Map([
       [
-        'stop1',
+        '1100084',
         {
           id: 0,
-          sourceStopId: 'stop1',
-          name: 'Stop 1',
+          sourceStopId: '1100084',
+          name: 'Test Stop 1',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
       [
-        'stop2',
+        '8014440:0:1',
         {
           id: 1,
-          sourceStopId: 'stop2',
-          name: 'Stop 2',
+          sourceStopId: '8014440:0:1',
+          name: 'Test Stop 2',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
+    ]);
+
+    const result = await parseTransfers(mockedStream, stopsMap);
+
+    assert.deepEqual(result.transfers, new Map());
+    assert.deepEqual(result.tripContinuations, []);
+  });
+
+  it('should ignore unsupported transfer types between routes', async () => {
+    const mockedStream = new Readable();
+    mockedStream.push(
+      'from_stop_id,to_stop_id,from_route_id,to_route_id,transfer_type,min_transfer_time\n',
+    );
+    mockedStream.push('"1100084","8014440:0:1","route1","route2","1","0"\n');
+    mockedStream.push(null);
+
+    const stopsMap: GtfsStopsMap = new Map([
       [
-        'stop3',
+        '1100084',
         {
-          id: 2,
-          sourceStopId: 'stop3',
-          name: 'Stop 3',
+          id: 0,
+          sourceStopId: '1100084',
+          name: 'Test Stop 1',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
-    ]);
-
-    const result = await parseTransfers(mockedStream, stopsMap);
-
-    const expectedTripContinuations = new Map([
       [
-        0, // from_stop_id 'stop1' -> internal ID 0
-        [
-          {
-            fromTrip: 'trip1',
-            toTrip: 'trip2',
-            hopOnStop: 1, // to_stop_id 'stop2' -> internal ID 1
-          },
-          {
-            fromTrip: 'trip1',
-            toTrip: 'trip3',
-            hopOnStop: 2, // to_stop_id 'stop3' -> internal ID 2
-          },
-        ],
+        '8014440:0:1',
+        {
+          id: 1,
+          sourceStopId: '8014440:0:1',
+          name: 'Test Stop 2',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
       ],
     ]);
 
+    const result = await parseTransfers(mockedStream, stopsMap);
+
     assert.deepEqual(result.transfers, new Map());
-    assert.deepEqual(result.tripContinuations, expectedTripContinuations);
+    assert.deepEqual(result.tripContinuations, []);
   });
 
-  it('should mix regular transfers and trip continuations correctly', async () => {
+  it('should handle transfers without minimum transfer time', async () => {
     const mockedStream = new Readable();
     mockedStream.push(
-      'from_stop_id,to_stop_id,from_trip_id,to_trip_id,transfer_type,min_transfer_time\n',
+      'from_stop_id,to_stop_id,transfer_type,min_transfer_time\n',
     );
-    mockedStream.push('"stop1","stop2","","","2","120"\n'); // Regular transfer
-    mockedStream.push('"stop1","stop3","trip1","trip2","4",""\n'); // Trip continuation
-    mockedStream.push('"stop2","stop3","","","0",""\n'); // Regular transfer
+    mockedStream.push('"1100084","8014440:0:1","2"\n');
+    mockedStream.push('"1100097","8014447","1","0"\n');
     mockedStream.push(null);
 
     const stopsMap: GtfsStopsMap = new Map([
       [
-        'stop1',
+        '1100084',
         {
           id: 0,
-          sourceStopId: 'stop1',
-          name: 'Stop 1',
+          sourceStopId: '1100084',
+          name: 'Test Stop 1',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
       [
-        'stop2',
+        '8014440:0:1',
         {
           id: 1,
-          sourceStopId: 'stop2',
-          name: 'Stop 2',
+          sourceStopId: '8014440:0:1',
+          name: 'Test Stop 2',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
       [
-        'stop3',
+        '1100097',
         {
           id: 2,
-          sourceStopId: 'stop3',
-          name: 'Stop 3',
+          sourceStopId: '1100097',
+          name: 'Test Stop 3',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+      [
+        '8014447',
+        {
+          id: 3,
+          sourceStopId: '8014447',
+          name: 'Test Stop 4',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
@@ -472,215 +456,152 @@ describe('GTFS transfers parser', () => {
 
     const expectedTransfers = new Map([
       [
-        0, // from_stop_id 'stop1' -> internal ID 0
+        0,
         [
           {
-            destination: 1, // to_stop_id 'stop2' -> internal ID 1
+            destination: 1,
             type: 'REQUIRES_MINIMAL_TIME',
-            minTransferTime: Duration.fromSeconds(120),
-          },
-        ],
-      ],
-      [
-        1, // from_stop_id 'stop2' -> internal ID 1
-        [
-          {
-            destination: 2, // to_stop_id 'stop3' -> internal ID 2
-            type: 'RECOMMENDED',
           },
         ],
       ],
-    ]);
-
-    const expectedTripContinuations = new Map([
       [
-        0, // from_stop_id 'stop1' -> internal ID 0
+        2,
         [
           {
-            fromTrip: 'trip1',
-            toTrip: 'trip2',
-            hopOnStop: 2, // to_stop_id 'stop3' -> internal ID 2
+            destination: 3,
+            type: 'GUARANTEED',
+            minTransferTime: Duration.fromSeconds(0),
           },
         ],
       ],
     ]);
 
     assert.deepEqual(result.transfers, expectedTransfers);
-    assert.deepEqual(result.tripContinuations, expectedTripContinuations);
-  });
-
-  it('should ignore trip continuations with undefined trip IDs', async () => {
-    const mockedStream = new Readable();
-    mockedStream.push('from_stop_id,to_stop_id,transfer_type\n');
-    mockedStream.push('"stop1","stop2","4"\n');
-    mockedStream.push(null);
-
-    const stopsMap: GtfsStopsMap = new Map([
-      [
-        'stop1',
-        {
-          id: 0,
-          sourceStopId: 'stop1',
-          name: 'Stop 1',
-          children: [],
-          locationType: 'SIMPLE_STOP_OR_PLATFORM',
-        },
-      ],
-      [
-        'stop2',
-        {
-          id: 1,
-          sourceStopId: 'stop2',
-          name: 'Stop 2',
-          children: [],
-          locationType: 'SIMPLE_STOP_OR_PLATFORM',
-        },
-      ],
-    ]);
-
-    const result = await parseTransfers(mockedStream, stopsMap);
-
-    assert.deepEqual(result.transfers, new Map());
-    assert.deepEqual(result.tripContinuations, new Map());
+    assert.deepEqual(result.tripContinuations, []);
   });
 
-  it('should ignore trip continuations with empty string trip IDs', async () => {
+  it('should handle mixed transfers and trip continuations', async () => {
     const mockedStream = new Readable();
     mockedStream.push(
-      'from_stop_id,to_stop_id,from_trip_id,to_trip_id,transfer_type\n',
+      'from_stop_id,to_stop_id,from_trip_id,to_trip_id,transfer_type,min_transfer_time\n',
     );
-    mockedStream.push('"stop1","stop2","trip1","","4"\n');
-    mockedStream.push('"stop3","stop4","","trip4","4"\n');
-    mockedStream.push('"stop5","stop6","","","4"\n');
+    mockedStream.push('"1100084","8014440:0:1","","","1","120"\n');
+    mockedStream.push('"1100097","8014447","trip1","trip2","4","0"\n');
     mockedStream.push(null);
 
     const stopsMap: GtfsStopsMap = new Map([
       [
-        'stop1',
+        '1100084',
         {
           id: 0,
-          sourceStopId: 'stop1',
-          name: 'Stop 1',
+          sourceStopId: '1100084',
+          name: 'Test Stop 1',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
       [
-        'stop2',
+        '8014440:0:1',
         {
           id: 1,
-          sourceStopId: 'stop2',
-          name: 'Stop 2',
+          sourceStopId: '8014440:0:1',
+          name: 'Test Stop 2',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
       [
-        'stop3',
+        '1100097',
         {
           id: 2,
-          sourceStopId: 'stop3',
-          name: 'Stop 3',
+          sourceStopId: '1100097',
+          name: 'Test Stop 3',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
       [
-        'stop4',
+        '8014447',
         {
           id: 3,
-          sourceStopId: 'stop4',
-          name: 'Stop 4',
-          children: [],
-          locationType: 'SIMPLE_STOP_OR_PLATFORM',
-        },
-      ],
-      [
-        'stop5',
-        {
-          id: 4,
-          sourceStopId: 'stop5',
-          name: 'Stop 5',
+          sourceStopId: '8014447',
+          name: 'Test Stop 4',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
+    ]);
+
+    const result = await parseTransfers(mockedStream, stopsMap);
+
+    const expectedTransfers = new Map([
       [
-        'stop6',
-        {
-          id: 5,
-          sourceStopId: 'stop6',
-          name: 'Stop 6',
-          children: [],
-          locationType: 'SIMPLE_STOP_OR_PLATFORM',
-        },
+        0,
+        [
+          {
+            destination: 1,
+            type: 'GUARANTEED',
+            minTransferTime: Duration.fromSeconds(120),
+          },
+        ],
       ],
     ]);
 
+    const expectedTripContinuations = [
+      {
+        fromStop: 2,
+        fromTrip: 'trip1',
+        toStop: 3,
+        toTrip: 'trip2',
+      },
+    ];
+
+    assert.deepEqual(result.transfers, expectedTransfers);
+    assert.deepEqual(result.tripContinuations, expectedTripContinuations);
+  });
+
+  it('should handle empty transfers file', async () => {
+    const mockedStream = new Readable();
+    mockedStream.push(
+      'from_stop_id,to_stop_id,transfer_type,min_transfer_time\n',
+    );
+    mockedStream.push(null);
+
+    const stopsMap: GtfsStopsMap = new Map();
+
     const result = await parseTransfers(mockedStream, stopsMap);
 
     assert.deepEqual(result.transfers, new Map());
-    assert.deepEqual(result.tripContinuations, new Map());
+    assert.deepEqual(result.tripContinuations, []);
   });
 
-  it('should handle complex scenario with multiple transfer types from same stop', async () => {
+  it('should ignore transfers with non-existent stops', async () => {
     const mockedStream = new Readable();
     mockedStream.push(
-      'from_stop_id,to_stop_id,from_trip_id,to_trip_id,transfer_type,min_transfer_time\n',
+      'from_stop_id,to_stop_id,transfer_type,min_transfer_time\n',
     );
-    mockedStream.push('"stop1","stop2","","","2","120"\n'); // Regular transfer to stop2
-    mockedStream.push('"stop1","stop3","trip1","trip2","4",""\n'); // Trip continuation to stop3
-    mockedStream.push('"stop1","stop4","","","0",""\n'); // Another regular transfer to stop4
-    mockedStream.push('"stop1","stop5","trip3","trip4","4",""\n'); // Another trip continuation to stop5
+    mockedStream.push('"unknown_stop","8014440:0:1","0","120"\n');
+    mockedStream.push('"1100084","unknown_stop","1","60"\n');
+    mockedStream.push('"1100084","8014440:0:1","2","180"\n');
     mockedStream.push(null);
 
     const stopsMap: GtfsStopsMap = new Map([
       [
-        'stop1',
+        '1100084',
         {
           id: 0,
-          sourceStopId: 'stop1',
-          name: 'Stop 1',
+          sourceStopId: '1100084',
+          name: 'Test Stop 1',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
       ],
       [
-        'stop2',
+        '8014440:0:1',
         {
           id: 1,
-          sourceStopId: 'stop2',
-          name: 'Stop 2',
-          children: [],
-          locationType: 'SIMPLE_STOP_OR_PLATFORM',
-        },
-      ],
-      [
-        'stop3',
-        {
-          id: 2,
-          sourceStopId: 'stop3',
-          name: 'Stop 3',
-          children: [],
-          locationType: 'SIMPLE_STOP_OR_PLATFORM',
-        },
-      ],
-      [
-        'stop4',
-        {
-          id: 3,
-          sourceStopId: 'stop4',
-          name: 'Stop 4',
-          children: [],
-          locationType: 'SIMPLE_STOP_OR_PLATFORM',
-        },
-      ],
-      [
-        'stop5',
-        {
-          id: 4,
-          sourceStopId: 'stop5',
-          name: 'Stop 5',
+          sourceStopId: '8014440:0:1',
+          name: 'Test Stop 2',
           children: [],
           locationType: 'SIMPLE_STOP_OR_PLATFORM',
         },
@@ -691,40 +612,399 @@ describe('GTFS transfers parser', () => {
 
     const expectedTransfers = new Map([
       [
-        0, // from_stop_id 'stop1' -> internal ID 0
+        0,
         [
           {
-            destination: 1, // to_stop_id 'stop2' -> internal ID 1
+            destination: 1,
             type: 'REQUIRES_MINIMAL_TIME',
-            minTransferTime: Duration.fromSeconds(120),
-          },
-          {
-            destination: 3, // to_stop_id 'stop4' -> internal ID 3
-            type: 'RECOMMENDED',
+            minTransferTime: Duration.fromSeconds(180),
           },
         ],
       ],
     ]);
 
-    const expectedTripContinuations = new Map([
-      [
-        0, // from_stop_id 'stop1' -> internal ID 0
-        [
-          {
-            fromTrip: 'trip1',
-            toTrip: 'trip2',
-            hopOnStop: 2, // to_stop_id 'stop3' -> internal ID 2
-          },
-          {
-            fromTrip: 'trip3',
-            toTrip: 'trip4',
-            hopOnStop: 4, // to_stop_id 'stop5' -> internal ID 4
-          },
-        ],
-      ],
+    assert.deepEqual(result.transfers, expectedTransfers);
+    assert.deepEqual(result.tripContinuations, []);
+  });
+});
+
+describe('buildTripContinuations', () => {
+  it('should build trip continuations for valid data', () => {
+    const tripsMapping: TripsMapping = new Map([
+      ['trip1', { routeId: 0, tripRouteIndex: 0 }],
+      ['trip2', { routeId: 1, tripRouteIndex: 0 }],
     ]);
 
-    assert.deepEqual(result.transfers, expectedTransfers);
-    assert.deepEqual(result.tripContinuations, expectedTripContinuations);
+    const tripContinuations = [
+      {
+        fromStop: 100,
+        fromTrip: 'trip1',
+        toStop: 200,
+        toTrip: 'trip2',
+      },
+    ];
+
+    // Mock route with simple stops and timing
+    const mockFromRoute = {
+      stopRouteIndices: () => [0],
+      arrivalAt: () => Time.fromMinutes(60), // 1:00
+    } as unknown as Route;
+
+    const mockToRoute = {
+      stopRouteIndices: () => [1],
+      departureFrom: () => Time.fromMinutes(75), // 1:15
+    } as unknown as Route;
+
+    const mockTimetable = {
+      getRoute: (routeId: number) =>
+        routeId === 0 ? mockFromRoute : mockToRoute,
+    } as unknown as Timetable;
+
+    const activeStopIds = new Set([100, 200]);
+
+    const result = buildTripContinuations(
+      tripsMapping,
+      tripContinuations,
+      mockTimetable,
+      activeStopIds,
+    );
+
+    const expectedTripBoardingId = encode(0, 0, 0);
+    const continuations = result.get(expectedTripBoardingId);
+
+    assert(continuations);
+    assert.strictEqual(continuations.length, 1);
+    assert.deepEqual(continuations[0], {
+      hopOnStopIndex: 1,
+      routeId: 1,
+      tripIndex: 0,
+    });
+  });
+
+  it('should ignore trip continuations with inactive stops', () => {
+    const tripsMapping: TripsMapping = new Map([
+      ['trip1', { routeId: 0, tripRouteIndex: 0 }],
+      ['trip2', { routeId: 1, tripRouteIndex: 0 }],
+    ]);
+
+    const tripContinuations = [
+      {
+        fromStop: 100, // inactive stop
+        fromTrip: 'trip1',
+        toStop: 200,
+        toTrip: 'trip2',
+      },
+    ];
+
+    const mockTimetable = {} as unknown as Timetable;
+    const activeStopIds = new Set([200]); // only toStop is active
+
+    const result = buildTripContinuations(
+      tripsMapping,
+      tripContinuations,
+      mockTimetable,
+      activeStopIds,
+    );
+
+    assert.strictEqual(result.size, 0);
+  });
+
+  it('should ignore trip continuations with unknown trip IDs', () => {
+    const tripsMapping: TripsMapping = new Map([
+      ['trip1', { routeId: 0, tripRouteIndex: 0 }],
+    ]);
+
+    const tripContinuations = [
+      {
+        fromStop: 100,
+        fromTrip: 'unknown_trip', // not in tripsMapping
+        toStop: 200,
+        toTrip: 'trip1',
+      },
+    ];
+
+    const mockTimetable = {} as unknown as Timetable;
+    const activeStopIds = new Set([100, 200]);
+
+    const result = buildTripContinuations(
+      tripsMapping,
+      tripContinuations,
+      mockTimetable,
+      activeStopIds,
+    );
+
+    assert.strictEqual(result.size, 0);
+  });
+
+  it('should ignore trip continuations with unknown routes', () => {
+    const tripsMapping: TripsMapping = new Map([
+      ['trip1', { routeId: 0, tripRouteIndex: 0 }],
+      ['trip2', { routeId: 1, tripRouteIndex: 0 }],
+    ]);
+
+    const tripContinuations = [
+      {
+        fromStop: 100,
+        fromTrip: 'trip1',
+        toStop: 200,
+        toTrip: 'trip2',
+      },
+    ];
+
+    const mockTimetable = {
+      getRoute: () => undefined, // no routes found
+    } as unknown as Timetable;
+
+    const activeStopIds = new Set([100, 200]);
+
+    const result = buildTripContinuations(
+      tripsMapping,
+      tripContinuations,
+      mockTimetable,
+      activeStopIds,
+    );
+
+    assert.strictEqual(result.size, 0);
+  });
+
+  it('should ignore trip continuations with no valid timing', () => {
+    const tripsMapping: TripsMapping = new Map([
+      ['trip1', { routeId: 0, tripRouteIndex: 0 }],
+      ['trip2', { routeId: 1, tripRouteIndex: 0 }],
+    ]);
+
+    const tripContinuations = [
+      {
+        fromStop: 100,
+        fromTrip: 'trip1',
+        toStop: 200,
+        toTrip: 'trip2',
+      },
+    ];
+
+    const mockFromRoute = {
+      stopRouteIndices: () => [0],
+      arrivalAt: () => Time.fromMinutes(75), // 1:15 - arrives AFTER departure
+    } as unknown as Route;
+
+    const mockToRoute = {
+      stopRouteIndices: () => [1],
+      departureFrom: () => Time.fromMinutes(60), // 1:00 - departs BEFORE arrival
+    } as unknown as Route;
+
+    const mockTimetable = {
+      getRoute: (routeId: number) =>
+        routeId === 0 ? mockFromRoute : mockToRoute,
+    } as unknown as Timetable;
+
+    const activeStopIds = new Set([100, 200]);
+
+    const result = buildTripContinuations(
+      tripsMapping,
+      tripContinuations,
+      mockTimetable,
+      activeStopIds,
+    );
+
+    assert.strictEqual(result.size, 0);
+  });
+
+  it('should handle multiple continuations from same trip boarding', () => {
+    const tripsMapping: TripsMapping = new Map([
+      ['trip1', { routeId: 0, tripRouteIndex: 0 }],
+      ['trip2', { routeId: 1, tripRouteIndex: 0 }],
+      ['trip3', { routeId: 2, tripRouteIndex: 0 }],
+    ]);
+
+    const tripContinuations = [
+      {
+        fromStop: 100,
+        fromTrip: 'trip1',
+        toStop: 200,
+        toTrip: 'trip2',
+      },
+      {
+        fromStop: 100,
+        fromTrip: 'trip1',
+        toStop: 300,
+        toTrip: 'trip3',
+      },
+    ];
+
+    const mockFromRoute = {
+      stopRouteIndices: () => [0],
+      arrivalAt: () => Time.fromMinutes(60),
+    } as unknown as Route;
+
+    const mockToRoute1 = {
+      stopRouteIndices: () => [1],
+      departureFrom: () => Time.fromMinutes(70),
+    } as unknown as Route;
+
+    const mockToRoute2 = {
+      stopRouteIndices: () => [2],
+      departureFrom: () => Time.fromMinutes(80),
+    } as unknown as Route;
+
+    const mockTimetable = {
+      getRoute: (routeId: number) => {
+        if (routeId === 0) return mockFromRoute;
+        if (routeId === 1) return mockToRoute1;
+        if (routeId === 2) return mockToRoute2;
+        return undefined;
+      },
+    } as unknown as Timetable;
+
+    const activeStopIds = new Set([100, 200, 300]);
+
+    const result = buildTripContinuations(
+      tripsMapping,
+      tripContinuations,
+      mockTimetable,
+      activeStopIds,
+    );
+
+    const expectedTripBoardingId = encode(0, 0, 0);
+    const continuations = result.get(expectedTripBoardingId);
+
+    assert(continuations);
+    assert.strictEqual(continuations.length, 2);
+    assert.deepEqual(continuations[0], {
+      hopOnStopIndex: 1,
+      routeId: 1,
+      tripIndex: 0,
+    });
+    assert.deepEqual(continuations[1], {
+      hopOnStopIndex: 2,
+      routeId: 2,
+      tripIndex: 0,
+    });
+  });
+
+  it('should handle empty input gracefully', () => {
+    const tripsMapping: TripsMapping = new Map();
+    const tripContinuations: GtfsTripContinuation[] = [];
+    const mockTimetable = {} as unknown as Timetable;
+    const activeStopIds = new Set<number>();
+
+    const result = buildTripContinuations(
+      tripsMapping,
+      tripContinuations,
+      mockTimetable,
+      activeStopIds,
+    );
+
+    assert.strictEqual(result.size, 0);
+  });
+
+  it('should disambiguate transfers when routes visit same stop multiple times', () => {
+    const tripsMapping: TripsMapping = new Map([
+      ['trip1', { routeId: 0, tripRouteIndex: 0 }],
+      ['trip2', { routeId: 1, tripRouteIndex: 0 }],
+    ]);
+
+    const tripContinuations = [
+      {
+        fromStop: 100, // This stop appears multiple times in the route
+        fromTrip: 'trip1',
+        toStop: 200, // This stop also appears multiple times
+        toTrip: 'trip2',
+      },
+    ];
+
+    // Mock route that visits stop 100 at indices 0 and 3 (circular route)
+    const mockFromRoute = {
+      stopRouteIndices: () => [0, 3], // Stop 100 appears twice
+      arrivalAt: (stopIndex: number) => {
+        // First visit at 1:00, second visit at 2:00
+        return stopIndex === 0 ? Time.fromMinutes(60) : Time.fromMinutes(120);
+      },
+    } as unknown as Route;
+
+    // Mock route that visits stop 200 at indices 1 and 4
+    const mockToRoute = {
+      stopRouteIndices: () => [1, 4], // Stop 200 appears twice
+      departureFrom: (stopIndex: number) => {
+        // First departure at 1:10, second departure at 2:30
+        return stopIndex === 1 ? Time.fromMinutes(70) : Time.fromMinutes(150);
+      },
+    } as unknown as Route;
+
+    const mockTimetable = {
+      getRoute: (routeId: number) =>
+        routeId === 0 ? mockFromRoute : mockToRoute,
+    } as unknown as Timetable;
+
+    const activeStopIds = new Set([100, 200]);
+
+    const result = buildTripContinuations(
+      tripsMapping,
+      tripContinuations,
+      mockTimetable,
+      activeStopIds,
+    );
+
+    // Should pick the best timing: arrive at stop 0 (1:00) -> depart from stop 1 (1:10)
+    // This is better than arrive at stop 3 (2:00) -> depart from stop 4 (2:30)
+    const expectedTripBoardingId = encode(0, 0, 0); // stopIndex=0, routeId=0, tripIndex=0
+    const continuations = result.get(expectedTripBoardingId);
+
+    assert(continuations);
+    assert.strictEqual(continuations.length, 1);
+    assert.deepEqual(continuations[0], {
+      hopOnStopIndex: 1, // Best to-stop index
+      routeId: 1,
+      tripIndex: 0,
+    });
+  });
+
+  it('should handle case where no valid transfer timing exists between duplicate stops', () => {
+    const tripsMapping: TripsMapping = new Map([
+      ['trip1', { routeId: 0, tripRouteIndex: 0 }],
+      ['trip2', { routeId: 1, tripRouteIndex: 0 }],
+    ]);
+
+    const tripContinuations = [
+      {
+        fromStop: 100,
+        fromTrip: 'trip1',
+        toStop: 200,
+        toTrip: 'trip2',
+      },
+    ];
+
+    // Mock route where all arrivals are AFTER all departures (impossible transfer)
+    const mockFromRoute = {
+      stopRouteIndices: () => [0, 3], // Stop 100 appears twice
+      arrivalAt: (stopIndex: number) => {
+        // Both arrivals are late: 2:00 and 3:00
+        return stopIndex === 0 ? Time.fromMinutes(120) : Time.fromMinutes(180);
+      },
+    } as unknown as Route;
+
+    const mockToRoute = {
+      stopRouteIndices: () => [1, 4], // Stop 200 appears twice
+      departureFrom: (stopIndex: number) => {
+        // Both departures are early: 1:00 and 1:30
+        return stopIndex === 1 ? Time.fromMinutes(60) : Time.fromMinutes(90);
+      },
+    } as unknown as Route;
+
+    const mockTimetable = {
+      getRoute: (routeId: number) =>
+        routeId === 0 ? mockFromRoute : mockToRoute,
+    } as unknown as Timetable;
+
+    const activeStopIds = new Set([100, 200]);
+
+    const result = buildTripContinuations(
+      tripsMapping,
+      tripContinuations,
+      mockTimetable,
+      activeStopIds,
+    );
+
+    // Should find no valid continuations since all departures are before arrivals
+    assert.strictEqual(result.size, 0);
   });
 });