minotor 3.0.1 → 3.0.2

package/dist/routing/__tests__/result.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/routing/query.d.ts

@@ -4,31 +4,52 @@ import { Time } from '../timetable/time.js';
 import { RouteType } from '../timetable/timetable.js';
 export declare class Query {
     from: SourceStopId;
-    to: SourceStopId[];
+    to: Set<SourceStopId>;
     departureTime: Time;
     lastDepartureTime?: Time;
     options: {
         maxTransfers: number;
         minTransferTime: Duration;
-        transportModes: RouteType[];
+        transportModes: Set<RouteType>;
     };
     constructor(builder: typeof Query.Builder.prototype);
     static Builder: {
         new (): {
             fromValue: SourceStopId;
-            toValue: SourceStopId[];
+            toValue: Set<SourceStopId>;
             departureTimeValue: Time;
             optionsValue: {
                 maxTransfers: number;
                 minTransferTime: Duration;
-                transportModes: RouteType[];
+                transportModes: Set<RouteType>;
             };
+            /**
+             * Sets the starting stop.
+             */
             from(from: SourceStopId): /*elided*/ any;
-            to(to: SourceStopId | SourceStopId[]): /*elided*/ any;
+            /**
+             * Sets the destination stops(s), routing will stop when all the provided stops are reached.
+             */
+            to(to: SourceStopId | Set<SourceStopId>): /*elided*/ any;
+            /**
+             * Sets the departure time for the query.
+             * Note that the router will favor routes that depart shortly after the provided departure time,
+             * even if a later route might arrive at the same time.
+             * Range queries will allow to specify a range of departure times in the future.
+             */
             departureTime(departureTime: Time): /*elided*/ any;
+            /**
+             * Sets the maximum number of transfers allowed.
+             */
             maxTransfers(maxTransfers: number): /*elided*/ any;
+            /**
+             * Sets the minimum transfer time to use when no transfer time is provided in the data.
+             */
             minTransferTime(minTransferTime: Duration): /*elided*/ any;
-            transportModes(transportModes: RouteType[]): /*elided*/ any;
+            /**
+             * Sets the transport modes to consider.
+             */
+            transportModes(transportModes: Set<RouteType>): /*elided*/ any;
             build(): Query;
         };
     };

package/dist/routing/result.d.ts

@@ -16,7 +16,7 @@ export declare class Result {
      * @param to The destination stop. Defaults to the destination of the original query.
      * @returns a route to the destination stop if it exists.
      */
-    bestRoute(to?: SourceStopId | SourceStopId[]): Route | undefined;
+    bestRoute(to?: SourceStopId | Set<SourceStopId>): Route | undefined;
     /**
      * Returns the arrival time at any stop reachable in less time / transfers than the destination(s) of the query)
      *

package/dist/routing/route.d.ts

@@ -1,7 +1,18 @@
-import { Stop } from '../stops/stops.js';
+import { SourceStopId, Stop } from '../stops/stops.js';
 import { Duration } from '../timetable/duration.js';
 import { Time } from '../timetable/time.js';
 import { ServiceRoute, TransferType } from '../timetable/timetable.js';
+export type JsonLeg = {
+    from: SourceStopId;
+    to: SourceStopId;
+} & ({
+    departure: string;
+    arrival: string;
+    route: ServiceRoute;
+} | {
+    type: TransferType;
+    minTransferTime?: string;
+});
 export type PickUpDropOffType = 'REGULAR' | 'NOT_AVAILABLE' | 'MUST_PHONE_AGENCY' | 'MUST_COORDINATE_WITH_DRIVER';
 export type BaseLeg = {
     from: Stop;
@@ -17,11 +28,45 @@ export type VehicleLeg = BaseLeg & {
     arrivalTime: Time;
 };
 export type Leg = Transfer | VehicleLeg;
+/**
+ * Represents a resolved route consisting of multiple legs,
+ * which can be either vehicle legs or transfer legs.
+ */
 export declare class Route {
     legs: Leg[];
     constructor(legs: Leg[]);
+    /**
+     * Calculates the departure time of the route.
+     *
+     * @returns The departure time of the route.
+     * @throws If no vehicle leg is found in the route.
+     */
     departureTime(): Time;
+    /**
+     * Calculates the arrival time of the route.
+     *
+     * @returns The arrival time of the route.
+     * @throws If no vehicle leg is found in the route.
+     */
     arrivalTime(): Time;
+    /**
+     * Calculates the total duration of the route.
+     *
+     * @returns The total duration of the route.
+     */
     totalDuration(): Duration;
-    print(): string;
+    /**
+     * Generates a human-readable string representation of the route.
+     *
+     * @returns A formatted string describing each leg of the route.
+     */
+    toString(): string;
+    /**
+     * Generates a concise JSON representation of the route.
+     * This is particularly useful for generating regression tests
+     * to verify the correctness of route calculations.
+     *
+     * @returns A JSON representation of the route.
+     */
+    asJson(): JsonLeg[];
 }

package/dist/routing/router.d.ts

@@ -9,10 +9,16 @@ export type TripLeg = ReachingTime & {
     leg?: Leg;
 };
 export type ReachingTime = {
-    time: Time;
+    arrival: Time;
     legNumber: number;
     origin: StopId;
 };
+/**
+ * A public transportation network router utilizing the RAPTOR algorithm for
+ * efficient journey planning and routing. For more information on the RAPTOR
+ * algorithm, refer to its detailed explanation in the research paper:
+ * https://www.microsoft.com/en-us/research/wp-content/uploads/2012/01/raptor_alenex.pdf
+ */
 export declare class Router {
     private readonly timetable;
     private readonly stopsIndex;
@@ -23,6 +29,14 @@ export declare class Router {
      * stops that can be reached through these transfers.
      */
     private considerTransfers;
+    /**
+     * Finds the earliest arrival time at any stop from a given set of destinations.
+     *
+     * @param earliestArrivals A map of stops to their earliest reaching times.
+     * @param destinations An array of destination stops to evaluate.
+     * @returns The earliest arrival time among the provided destinations.
+     */
+    private earliestArrivalAtAnyStop;
     /**
      * The main Raptor algorithm implementation.
      *

package/dist/stops/stopsIndex.d.ts

@@ -14,14 +14,14 @@ export declare class StopsIndex {
     /**
      * Deserializes a binary representation of the stops.
      *
-     * @param {Uint8Array} data - The binary data to deserialize.
-     * @returns {StopsMap} - The deserialized StopFinder.
+     * @param data - The binary data to deserialize.
+     * @returns The deserialized StopFinder.
      */
     static fromData(data: Uint8Array): StopsIndex;
     /**
      * Serializes the stops into a binary protobuf.
      *
-     * @returns {Uint8Array} - The serialized binary data.
+     * @returns The serialized binary data.
      */
     serialize(): Uint8Array;
     /**

package/dist/timetable/__tests__/route.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/timetable/__tests__/time.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/timetable/io.d.ts

@@ -1,5 +1,11 @@
 import { RoutesAdjacency as ProtoRoutesAdjacency, ServiceRoutesMap as ProtoServiceRoutesMap, StopsAdjacency as ProtoStopsAdjacency } from './proto/timetable.js';
-import { RoutesAdjacency, ServiceRoutesMap, StopsAdjacency } from './timetable.js';
+import { RoutesAdjacency, ServiceRouteId, ServiceRoutesMap, StopsAdjacency } from './timetable.js';
+export type SerializedRoute = {
+    stopTimes: Uint16Array;
+    pickUpDropOffTypes: Uint8Array;
+    stops: Uint32Array;
+    serviceRouteId: ServiceRouteId;
+};
 export declare const serializeStopsAdjacency: (stopsAdjacency: StopsAdjacency) => ProtoStopsAdjacency;
 export declare const serializeRoutesAdjacency: (routesAdjacency: RoutesAdjacency) => ProtoRoutesAdjacency;
 export declare const serializeServiceRoutesMap: (serviceRoutesMap: ServiceRoutesMap) => ProtoServiceRoutesMap;

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

@@ -26,7 +26,7 @@ export declare function routeTypeFromJSON(object: any): RouteType;
 export declare function routeTypeToJSON(object: RouteType): string;
 export interface Route {
     /**
-     * Arrivals and departures encoded as a 32 bit uint array.
+     * Arrivals and departures encoded as a 16 bit uint array.
      * Format: [arrival1, departure1, arrival2, departure2, etc.]
      */
     stopTimes: Uint8Array;

package/dist/timetable/route.d.ts

@@ -0,0 +1,155 @@
+import { StopId } from '../stops/stops.js';
+import { SerializedRoute } from './io.js';
+import { Time } from './time.js';
+import { ServiceRouteId } from './timetable.js';
+/**
+ * An internal identifier for routes.
+ * Not to mix with the ServiceRouteId which corresponds to the GTFS RouteId.
+ * This one is used for identifying groups of trips
+ * from a service route sharing the same list of stops.
+ */
+export type RouteId = string;
+/**
+ * Details about the pickup and drop-off modalities at each stop in each trip of a route.
+ */
+export type PickUpDropOffType = 'REGULAR' | 'NOT_AVAILABLE' | 'MUST_PHONE_AGENCY' | 'MUST_COORDINATE_WITH_DRIVER';
+export declare const REGULAR = 0;
+export declare const NOT_AVAILABLE = 1;
+export declare const MUST_PHONE_AGENCY = 2;
+export declare const MUST_COORDINATE_WITH_DRIVER = 3;
+export type TripIndex = number;
+/**
+ * A route identifies all trips of a given service route sharing the same list of stops.
+ */
+export declare class Route {
+    /**
+     * Arrivals and departures encoded as minutes from midnight.
+     * Format: [arrival1, departure1, arrival2, departure2, etc.]
+     */
+    private readonly stopTimes;
+    /**
+     * PickUp and DropOff types represented as a binary Uint8Array.
+     * Values:
+     *   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.
+     */
+    private readonly pickUpDropOffTypes;
+    /**
+     * A binary array of stopIds in the route.
+     * [stop1, stop2, stop3,...]
+     */
+    private readonly stops;
+    /**
+     * A reverse mapping of each stop with their index in the route:
+     * {
+     *   4: 0,
+     *   5: 1,
+     *   ...
+     * }
+     */
+    private readonly stopIndices;
+    /**
+     * The identifier of the route as a service shown to users.
+     */
+    private readonly serviceRouteId;
+    /**
+     * The total number of stops in the route.
+     */
+    private readonly nbStops;
+    /**
+     * The total number of trips in the route.
+     */
+    private readonly nbTrips;
+    constructor(stopTimes: Uint16Array, pickUpDropOffTypes: Uint8Array, stops: Uint32Array, serviceRouteId: ServiceRouteId);
+    /**
+     * Serializes the Route into binary arrays.
+     *
+     * @returns The serialized binary data.
+     */
+    serialize(): SerializedRoute;
+    /**
+     * Checks if stop A is before stop B in the route.
+     *
+     * @param stopA - The StopId of the first stop.
+     * @param stopB - The StopId of the second stop.
+     * @returns True if stop A is before stop B, false otherwise.
+     */
+    isBefore(stopA: StopId, stopB: StopId): boolean;
+    /**
+     * Retrieves the number of stops in the route.
+     *
+     * @returns The total number of stops in the route.
+     */
+    getNbStops(): number;
+    /**
+     * Finds the ServiceRouteId of the route. It corresponds the identifier
+     * of the service shown to the end user as a route.
+     *
+     * @returns The ServiceRouteId of the route.
+     */
+    serviceRoute(): ServiceRouteId;
+    /**
+     * Retrieves the arrival time at a specific stop for a given trip.
+     *
+     * @param stopId - The identifier of the stop.
+     * @param tripIndex - The index of the trip.
+     * @returns The arrival time at the specified stop and trip as a Time object.
+     */
+    arrivalAt(stopId: StopId, tripIndex: TripIndex): Time;
+    /**
+     * Retrieves the departure time at a specific stop for a given trip.
+     *
+     * @param stopId - The identifier of the stop.
+     * @param tripIndex - The index of the trip.
+     * @returns The departure time at the specified stop and trip as a Time object.
+     */
+    departureFrom(stopId: StopId, tripIndex: TripIndex): Time;
+    /**
+     * Retrieves the pick-up type for a specific stop and trip.
+     *
+     * @param stopId - The identifier of the stop.
+     * @param tripIndex - The index of the trip.
+     * @returns The pick-up type at the specified stop and trip.
+     */
+    pickUpTypeFrom(stopId: StopId, tripIndex: TripIndex): PickUpDropOffType;
+    /**
+     * Retrieves the drop-off type for a specific stop and trip.
+     *
+     * @param stopId - The identifier of the stop.
+     * @param tripIndex - The index of the trip.
+     * @returns The drop-off type at the specified stop and trip.
+     */
+    dropOffTypeAt(stopId: StopId, tripIndex: TripIndex): PickUpDropOffType;
+    /**
+     * Iterates over the stops in the route, starting from an optional specified stop.
+     * If no start stop is provided, the iteration begins from the first stop in the route.
+     *
+     * @param [startStopId] - (Optional) The StopId of the stop to start the iteration from.
+     * @returns An IterableIterator of StopIds, starting from the specified stop or the first stop.
+     * @throws An error if the specified start stop is not found in the route.
+     */
+    stopsIterator(startStopId?: StopId): IterableIterator<StopId>;
+    /**
+     * Finds the earliest trip that can be taken from a specific stop on a given route,
+     * optionally constrained by a latest trip index and a time before which the trip
+     * should not depart.
+     * *
+     * @param stopId - The StopId of the stop where the trip should be found.
+     * @param [after=Time.origin()] - The earliest time after which the trip should depart.
+     *                                    If not provided, searches all available trips.
+     * @param [beforeTrip] - (Optional) The index of the trip before which the search should be constrained.
+     *                                   If not provided, searches all available trips.
+     * @returns The index of the earliest trip meeting the criteria, or undefined if no such trip is found.
+     */
+    findEarliestTrip(stopId: StopId, after?: Time, beforeTrip?: TripIndex): TripIndex | undefined;
+    /**
+     * Retrieves the index of a stop within the route.
+     * @param stopId The StopId of the stop to locate in the route.
+     * @returns The index of the stop in the route.
+     */
+    private stopIndex;
+}

package/dist/timetable/time.d.ts

@@ -104,4 +104,25 @@ export declare class Time {
      * @returns A Time instance representing the minimum time.
      */
     static min(...times: Time[]): Time;
+    /**
+     * Determines if the current Time instance is after another Time instance.
+     *
+     * @param otherTime - A Time instance to compare against.
+     * @returns True if the current Time instance is after the other Time instance, otherwise false.
+     */
+    isAfter(otherTime: Time): boolean;
+    /**
+     * Determines if the current Time instance is before another Time instance.
+     *
+     * @param otherTime - A Time instance to compare against.
+     * @returns True if the current Time instance is before the other Time instance, otherwise false.
+     */
+    isBefore(otherTime: Time): boolean;
+    /**
+     * Determines if the current Time instance is equal to another Time instance.
+     *
+     * @param otherTime - A Time instance to compare against.
+     * @returns True if the current Time instance is equal to the other Time instance, otherwise false.
+     */
+    equals(otherTime: Time): boolean;
 }

package/dist/timetable/timetable.d.ts

@@ -1,47 +1,6 @@
 import { StopId } from '../stops/stops.js';
 import { Duration } from './duration.js';
-import { Time } from './time.js';
-export type RouteId = string;
-export declare const REGULAR = 0;
-export declare const NOT_AVAILABLE = 1;
-export declare const MUST_PHONE_AGENCY = 2;
-export declare const MUST_COORDINATE_WITH_DRIVER = 3;
-export type PickUpDropOffType = 0 | 1 | 2 | 3;
-export type Route = {
-    /**
-     * Arrivals and departures encoded as minutes from midnight.
-     * Format: [arrival1, departure1, arrival2, departure2, etc.]
-     */
-    stopTimes: Uint16Array;
-    /**
-     * PickUp and DropOff types represented as a binary Uint8Array.
-     * Values:
-     *   0: REGULAR
-     *   1: NOT_AVAILABLE
-     *   2: MUST_PHONE_AGENCY
-     *   3: MUST_COORDINATE_WITH_DRIVER
-     * Format: [pickupTypeStop1, dropOffTypeStop1, pickupTypeStop2, dropOffTypeStop2, etc.]
-     */
-    pickUpDropOffTypes: Uint8Array;
-    /**
-     * A binary array of stopIds in the route.
-     * [stop1, stop2, stop3,...]
-     */
-    stops: Uint32Array;
-    /**
-     * A reverse mapping of each stop with their index in the route:
-     * {
-     *   4: 0,
-     *   5: 1,
-     *   ...
-     * }
-     */
-    stopIndices: Map<StopId, number>;
-    /**
-     * The identifier of the route as a service shown to users.
-     */
-    serviceRouteId: ServiceRouteId;
-};
+import { Route, RouteId } from './route.js';
 export type RoutesAdjacency = Map<RouteId, Route>;
 export type TransferType = 'RECOMMENDED' | 'GUARANTEED' | 'REQUIRES_MINIMAL_TIME' | 'IN_SEAT';
 export type Transfer = {
@@ -60,12 +19,10 @@ export type ServiceRoute = {
     name: string;
 };
 export type ServiceRoutesMap = Map<ServiceRouteId, ServiceRoute>;
-type TripIndex = number;
-export declare const ALL_TRANSPORT_MODES: RouteType[];
+export declare const ALL_TRANSPORT_MODES: Set<RouteType>;
 export declare const CURRENT_VERSION = "0.0.3";
 /**
- * The internal transit timetable format
- * reuses some GTFS concepts for the sake of simplicity for now.
+ * The internal transit timetable format.
  */
 export declare class Timetable {
     private readonly stopsAdjacency;
@@ -73,34 +30,57 @@ export declare class Timetable {
     private readonly routes;
     constructor(stopsAdjacency: StopsAdjacency, routesAdjacency: RoutesAdjacency, routes: ServiceRoutesMap);
     /**
-     * Serializes the Timetable into a binary protobuf.
+     * Serializes the Timetable into a binary array.
      *
-     * @returns {Uint8Array} - The serialized binary data.
+     * @returns The serialized binary data.
      */
     serialize(): Uint8Array;
     /**
      * Deserializes a binary protobuf into a Timetable object.
      *
-     * @param {Uint8Array} data - The binary data to deserialize.
-     * @returns {Timetable} - The deserialized Timetable object.
+     * @param data - The binary data to deserialize.
+     * @returns The deserialized Timetable object.
      */
     static fromData(data: Uint8Array): Timetable;
-    getRoutesThroughStop(stopId: StopId): RouteId[];
+    /**
+     * Retrieves the route associated with the given route ID.
+     *
+     * @param routeId - The ID of the route to be retrieved.
+     * @returns The route corresponding to the provided ID,
+     * or undefined if no such route exists.
+     */
     getRoute(routeId: RouteId): Route | undefined;
+    /**
+     * Retrieves all transfer options available at the specified stop.
+     *
+     * @param stopId - The ID of the stop to get transfers for.
+     * @returns An array of transfer options available at the stop.
+     */
     getTransfers(stopId: StopId): Transfer[];
+    /**
+     * Retrieves the service route associated with the given route.
+     * A service route refers to a collection of trips that are displayed
+     * to riders as a single service.
+     *
+     * @param route - The route for which the service route is to be retrieved.
+     * @returns The service route corresponding to the provided route.
+     */
+    getServiceRoute(route: Route): ServiceRoute;
+    /**
+     * Finds all routes passing through a stop.
+     *
+     * @param stopId - The ID of the stop to find routes for.
+     * @returns An array of routes passing through the specified stop.
+     */
+    routesPassingThrough(stopId: StopId): Route[];
     /**
      * Finds routes that are reachable from a set of stop IDs.
      * Also identifies the first stop available to hop on each route among
      * the input stops.
+     *
+     * @param fromStops - The set of stop IDs to find reachable routes from.
+     * @param transportModes - The set of transport modes to consider for reachable routes.
+     * @returns A map of reachable routes to the first stop available to hop on each route.
      */
-    findReachableRoutes(fromStops: Set<StopId>, transportModes?: RouteType[]): Map<RouteId, StopId>;
-    getServiceRouteFromRouteId(routeId: RouteId): ServiceRoute | undefined;
-    getServiceRoute(serviceRouteId: ServiceRouteId): ServiceRoute | undefined;
-    /**
-     * Finds the earliest trip that can be taken from a specific stop on a given route,
-     * optionally constrained by a latest trip index and a time before which the trip
-     * should not depart.
-     */
-    findEarliestTrip(route: Route, stopId: StopId, beforeTrip?: TripIndex, after?: Time): TripIndex | undefined;
+    findReachableRoutes(fromStops: Set<StopId>, transportModes?: Set<RouteType>): Map<Route, StopId>;
 }
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minotor",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "A lightweight client-side transit routing library.",
   "keywords": [
     "minotor",
@@ -42,12 +42,12 @@
     }
   },
   "engines": {
-    "node": ">=21.1.0",
-    "npm": ">=10.9.1"
+    "node": ">=22.18.0",
+    "npm": ">=11.5.2"
   },
   "volta": {
-    "node": "21.1.0",
-    "npm": "10.9.1"
+    "node": "22.18.0",
+    "npm": "11.5.2"
   },
   "publishConfig": {
     "access": "public"
@@ -63,53 +63,55 @@
     "lint:check": "eslint src",
     "format:check": "prettier . --check",
     "format": "prettier --write .",
-    "test": "tsx --test src/**/*.test.ts",
+    "test": "tsx --test src/**/__tests__/*.test.ts",
+    "e2e": "tsx --test src/__e2e__/*.test.ts",
+    "perf": "tsx src/cli/minotor perf -s src/__e2e__/timetable/stops.bin -t src/__e2e__/timetable/timetable.bin src/__e2e__/benchmark.json",
+    "repl": "tsx src/cli/minotor repl -s src/__e2e__/timetable/stops.bin -t src/__e2e__/timetable/timetable.bin",
     "test:watch": "tsx --watch --test src/**/*.test.ts",
-    "test:coverage": "c8 -x 'src/**/proto/*.ts' -x 'src/**/__tests__/*.ts' --check-coverage --lines=85 tsx --test src/**/*.test.ts",
+    "test:coverage": "c8 -x 'src/**/proto/*.ts' -x 'src/**/__tests__/*.ts' --check-coverage --lines=85 tsx --test src/**/__tests__/*.test.ts",
     "spell:check": "cspell \"{README.md,.github/*.md,src/**/*.ts}\" -u",
     "cz": "cz",
     "semantic-release": "semantic-release"
   },
   "devDependencies": {
-    "@eslint/js": "^9.0.0",
-    "@rollup/plugin-commonjs": "^28.0.1",
-    "@rollup/plugin-node-resolve": "^15.3.0",
+    "@eslint/js": "^9.34.0",
+    "@rollup/plugin-commonjs": "^28.0.6",
+    "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-terser": "^0.4.4",
-    "@rollup/plugin-typescript": "^12.1.1",
+    "@rollup/plugin-typescript": "^12.1.4",
     "@ryansonshine/commitizen": "^4.2.8",
     "@ryansonshine/cz-conventional-changelog": "^3.3.4",
     "@semantic-release/changelog": "^6.0.3",
-    "@semantic-release/commit-analyzer": "^13.0.0",
-    "@semantic-release/github": "^11.0.1",
-    "@semantic-release/npm": "^12.0.1",
-    "@semantic-release/release-notes-generator": "^14.0.1",
-    "@types/eslint__js": "^8.42.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/github": "^11.0.4",
+    "@semantic-release/npm": "^12.0.2",
+    "@semantic-release/release-notes-generator": "^14.0.3",
     "@types/geokdbush": "^1.1.5",
-    "@types/luxon": "^3.4.2",
-    "@types/node": "^22.9.0",
-    "c8": "^10.1.2",
-    "cspell": "^8.16.0",
-    "eslint": "^9.15.0",
-    "eslint-config-prettier": "^9.1.0",
+    "@types/luxon": "^3.7.1",
+    "@types/node": "^24.3.0",
+    "c8": "^10.1.3",
+    "cspell": "^9.2.0",
+    "eslint": "^9.34.0",
+    "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-simple-import-sort": "^12.1.1",
-    "prettier": "^3.3.3",
+    "prettier": "^3.6.2",
     "rimraf": "^6.0.1",
-    "rollup": "^4.27.2",
-    "semantic-release": "^24.2.0",
-    "ts-proto": "^2.2.7",
-    "tsx": "^4.19.2",
-    "typescript": "^5.6.3",
-    "typescript-eslint": "^8.14.0"
+    "rollup": "^4.49.0",
+    "semantic-release": "^24.2.7",
+    "ts-proto": "^2.7.7",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.41.0"
   },
   "dependencies": {
-    "@bufbuild/protobuf": "^2.5.0",
-    "commander": "^12.1.0",
-    "csv-parse": "^5.5.6",
+    "@bufbuild/protobuf": "^2.7.0",
+    "commander": "^14.0.0",
+    "csv-parse": "^6.1.0",
     "geokdbush": "^2.0.1",
     "kdbush": "^4.0.2",
     "loglevel": "^1.9.2",
-    "luxon": "^3.5.0",
+    "luxon": "^3.7.1",
     "node-stream-zip": "^1.15.0",
-    "slimsearch": "^2.2.1"
+    "slimsearch": "^2.2.2"
   }
 }