@squawk/flightplan 0.5.7 → 0.6.0

package/README.md

@@ -95,8 +95,8 @@ Creates a resolver from optional lookup providers.
 **Parameters:**
 
 - `options.airports` - airport lookup (must provide `byFaaId` and `byIcao`)
-- `options.navaids` - navaid lookup (must provide `byIdent`)
-- `options.fixes` - fix lookup (must provide `byIdent`)
+- `options.navaids` - navaid lookup (must provide `byIdent`; may also provide `byIdentAtPosition` for proximity disambiguation)
+- `options.fixes` - fix lookup (must provide `byIdent`; may also provide `byIdentAtPosition` for proximity disambiguation)
 - `options.airways` - airway lookup (must provide `byDesignation` and `expand`)
 - `options.procedures` - procedure lookup (must provide `byIdentifier` and `expand`)
 
@@ -159,3 +159,119 @@ both an airport and a navaid), the resolver uses this priority order:
 3. Procedure (SID/STAR)
 4. Fix
 5. Navaid
+
+The same fix or navaid identifier is sometimes published in more than one
+region. When the `fixes` or `navaids` provider exposes `byIdentAtPosition`, the
+resolver disambiguates such a token by proximity to the most recently resolved
+positional element (a preceding airport, coordinate, waypoint, airway exit fix,
+or procedure terminus). The first token in a route has no such anchor, and a
+provider that exposes only `byIdent` cannot disambiguate; both cases fall back
+to the first `byIdent` match.
+
+### `computeRouteDistance(route, groundSpeedKt?)`
+
+Computes the total great-circle route distance and optional estimated time
+enroute from a parsed route. Walks the same ordered point sequence as the
+geometry helpers below, so distance and geometry stay in agreement. Airway
+segments use FAA-published per-segment distances when available, falling back
+to great-circle computation.
+
+```typescript
+import { computeRouteDistance } from '@squawk/flightplan';
+
+const route = resolver.parse('KJFK DCT MERIT J60 MARTN DCT KLAX');
+const result = computeRouteDistance(route, 450);
+console.log(result.totalDistanceNm, result.estimatedTimeEnrouteHrs);
+```
+
+**Parameters:**
+
+- `route` - a `ParsedRoute` from `resolver.parse`
+- `groundSpeedKt` - optional ground speed in knots; omit to skip ETE
+
+**Returns:** `RouteDistanceResult` with:
+
+- `legs` - ordered `RouteLeg` values, each with `from`/`to` point labels, their `fromLat`/`fromLon`/`toLat`/`toLon` coordinates in decimal degrees, `distanceNm`, and `cumulativeDistanceNm`
+- `totalDistanceNm` - total great-circle distance in nautical miles
+- `estimatedTimeEnrouteHrs` - ETE in hours, or `undefined` when no ground speed was given
+- `unresolvedElements` - route elements that could not contribute coordinates
+
+### `computeRouteTiming(route, options)`
+
+Layers per-leg, wind-corrected timing over the same legs as
+`computeRouteDistance`. For each leg it derives the initial great-circle true
+course, samples the wind at the leg midpoint, and solves the wind triangle for
+true heading, wind correction angle, and ground speed. Estimated time enroute
+follows from leg distance and ground speed, and fuel burn follows from the same
+ground speed.
+
+Winds are supplied through an optional `windProvider` callback, keeping this
+function independent of any weather source. The provider takes only a position;
+bake the sampling altitude into the closure. A `@squawk/weather` winds-aloft
+forecast read at a chosen cruise altitude is one way to satisfy it. When the
+provider is omitted, or returns `undefined` for a leg (no data, or light and
+variable), that leg is timed as calm: ground speed equals true airspeed and the
+wind correction angle is zero.
+
+```typescript
+import { computeRouteTiming } from '@squawk/flightplan';
+
+const route = resolver.parse('KJFK DCT MERIT J60 MARTN DCT KLAX');
+const result = computeRouteTiming(route, {
+  trueAirspeedKt: 450,
+  windProvider: (lat, lon) => ({ directionDeg: 270, speedKt: 80 }),
+  fuelBurnPerHr: 600,
+  fuelAvailable: 2400,
+});
+console.log(result.totalEteHrs, result.totalFuelRequired, result.fuelSufficient);
+```
+
+**Parameters:**
+
+- `route` - a `ParsedRoute` from `resolver.parse`
+- `options.trueAirspeedKt` - true airspeed in knots flown on every leg
+- `options.windProvider` - optional `(lat, lon) => WindVector | undefined` callback sampling the wind at each leg midpoint
+- `options.fuelBurnPerHr` - optional fuel burn rate per hour (any consistent unit); enables per-leg and total fuel
+- `options.fuelAvailable` - optional fuel on board (same unit as `fuelBurnPerHr`); with the burn rate, enables endurance and sufficiency
+
+**Returns:** `RouteTimingResult` with:
+
+- `legs` - ordered `RouteTimingLeg` values, each carrying the distance fields above plus `trueCourseDeg`, `trueHeadingDeg`, `windCorrectionAngleDeg`, `groundSpeedKt`, the applied `wind` (or `undefined` when calm), `eteHrs`, `cumulativeEteHrs`, and `fuelRequired`
+- `totalDistanceNm` - total great-circle distance in nautical miles
+- `totalEteHrs` - total estimated time enroute in hours, or `undefined` if any leg could not be timed
+- `totalFuelRequired` - total fuel across all legs, or `undefined` without a burn rate or when any leg could not be timed
+- `enduranceHrs` - endurance in hours from `fuelAvailable` and `fuelBurnPerHr`, or `undefined`
+- `fuelSufficient` - whether endurance covers the total ETE, or `undefined`
+- `unresolvedElements` - route elements that could not contribute coordinates
+
+Ground speed comes from the wind triangle as a magnitude, so a leg is left
+untimed (`eteHrs` is `undefined`) only when ground speed is not positive, which
+occurs where a pure headwind equals true airspeed. A headwind exceeding true
+airspeed still yields a positive magnitude and is not separately flagged.
+
+### `extractRoutePoints(route)`
+
+Extracts the ordered sequence of drawable geographic points from a parsed
+route. Expands airway and SID/STAR segments into their constituent fixes and
+suppresses consecutive duplicate points (e.g. an airway entry fix that matches
+the preceding waypoint). Elements without coordinates (DCT, speed/altitude
+groups, unresolved tokens) contribute no points.
+
+**Returns:** `RoutePoint[]`, each with `label`, `lat`, and `lon`.
+
+### `routeToLineString(route)`
+
+Builds a GeoJSON `LineString` from a parsed route, ready to render as a
+polyline on a map (e.g. MapLibre, Leaflet). Coordinates follow the GeoJSON
+`[lon, lat]` ordering. Returns `undefined` when the route yields fewer than
+two drawable points, since a `LineString` requires at least two positions.
+
+```typescript
+import { routeToLineString } from '@squawk/flightplan';
+
+const route = resolver.parse('KJFK DCT MERIT J60 MARTN DCT KLAX');
+const line = routeToLineString(route);
+if (line) {
+  map.addSource('route', { type: 'geojson', data: line });
+}
+```

package/dist/index.d.ts

@@ -8,4 +8,9 @@ export { createFlightplanResolver } from './resolver.js';
 export type { FlightplanResolver, FlightplanResolverOptions, FlightplanAirportLookup, FlightplanNavaidLookup, FlightplanFixLookup, FlightplanAirwayLookup, FlightplanProcedureLookup, ParsedRoute, RouteElement, AirportRouteElement, SidRouteElement, StarRouteElement, AirwayRouteElement, DirectRouteElement, WaypointRouteElement, CoordinateRouteElement, SpeedAltitudeRouteElement, UnresolvedRouteElement, } from './resolver.js';
 export { computeRouteDistance } from './route-distance.js';
 export type { RouteLeg, RouteDistanceResult } from './route-distance.js';
+export { computeRouteTiming } from './route-timing.js';
+export type { WindProvider, RouteTimingOptions, RouteTimingLeg, RouteTimingResult, } from './route-timing.js';
+export type { WindVector } from '@squawk/flight-math';
+export { extractRoutePoints, routeToLineString } from './route-geometry.js';
+export type { RoutePoint } from './route-geometry.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AACzD,YAAY,EACV,kBAAkB,EAClB,yBAAyB,EACzB,uBAAuB,EACvB,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EACtB,yBAAyB,EACzB,WAAW,EACX,YAAY,EACZ,mBAAmB,EACnB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,sBAAsB,EACtB,yBAAyB,EACzB,sBAAsB,GACvB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,YAAY,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AACzD,YAAY,EACV,kBAAkB,EAClB,yBAAyB,EACzB,uBAAuB,EACvB,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EACtB,yBAAyB,EACzB,WAAW,EACX,YAAY,EACZ,mBAAmB,EACnB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,sBAAsB,EACtB,yBAAyB,EACzB,sBAAsB,GACvB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,YAAY,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,YAAY,EACV,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACd,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC5E,YAAY,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -6,3 +6,5 @@
  */
 export { createFlightplanResolver } from './resolver.js';
 export { computeRouteDistance } from './route-distance.js';
+export { computeRouteTiming } from './route-timing.js';
+export { extractRoutePoints, routeToLineString } from './route-geometry.js';

package/dist/resolver.d.ts

@@ -16,6 +16,13 @@ export interface FlightplanAirportLookup {
 export interface FlightplanNavaidLookup {
     /** Looks up navaids by identifier. Returns an empty array if none found. */
     byIdent(ident: string): Navaid[];
+    /**
+     * Optionally looks up the single navaid sharing the identifier that lies
+     * nearest a reference position, disambiguating same-identifier collisions by
+     * proximity to the previously resolved route waypoint. When omitted, the
+     * resolver falls back to the first `byIdent` match.
+     */
+    byIdentAtPosition?(ident: string, lat: number, lon: number, toleranceNm?: number): Navaid | undefined;
 }
 /**
  * Minimal fix lookup interface consumed by the flightplan resolver.
@@ -24,6 +31,13 @@ export interface FlightplanNavaidLookup {
 export interface FlightplanFixLookup {
     /** Looks up fixes by identifier. Returns an empty array if none found. */
     byIdent(ident: string): Fix[];
+    /**
+     * Optionally looks up the single fix sharing the identifier that lies nearest
+     * a reference position, disambiguating same-identifier collisions by proximity
+     * to the previously resolved route waypoint. When omitted, the resolver falls
+     * back to the first `byIdent` match.
+     */
+    byIdentAtPosition?(ident: string, lat: number, lon: number, toleranceNm?: number): Fix | undefined;
 }
 /**
  * Minimal airway lookup interface consumed by the flightplan resolver.

package/dist/resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../src/resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,MAAM,EACN,cAAc,EACd,GAAG,EACH,MAAM,EACN,SAAS,EACT,YAAY,EACb,MAAM,eAAe,CAAC;AAMvB;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,mEAAmE;IACnE,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;IAC5C,sDAAsD;IACtD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;CAC3C;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC,4EAA4E;IAC5E,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAClC;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,0EAA0E;IAC1E,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,EAAE,CAAC;CAC/B;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC,iGAAiG;IACjG,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC7C,mFAAmF;IACnF,MAAM,CACJ,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,cAAc,EAAE,CAAA;KAAE,GAAG,SAAS,CAAC;CAChE;AAED;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,yFAAyF;IACzF,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,CAAC;IAC9C,wDAAwD;IACxD,MAAM,CACJ,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,MAAM,GACtB;QAAE,SAAS,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,YAAY,EAAE,CAAA;KAAE,GAAG,SAAS,CAAC;CAC/D;AAMD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,yCAAyC;IACzC,IAAI,EAAE,SAAS,CAAC;IAChB,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,+BAA+B;IAC/B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,qCAAqC;IACrC,IAAI,EAAE,KAAK,CAAC;IACZ,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,iCAAiC;IACjC,SAAS,EAAE,SAAS,CAAC;IACrB,gDAAgD;IAChD,IAAI,EAAE,YAAY,EAAE,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,iCAAiC;IACjC,SAAS,EAAE,SAAS,CAAC;IACrB,gDAAgD;IAChD,IAAI,EAAE,YAAY,EAAE,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,wCAAwC;IACxC,IAAI,EAAE,QAAQ,CAAC;IACf,4DAA4D;IAC5D,GAAG,EAAE,MAAM,CAAC;IACZ,8BAA8B;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,4DAA4D;IAC5D,SAAS,EAAE,cAAc,EAAE,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,wCAAwC;IACxC,IAAI,EAAE,QAAQ,CAAC;IACf,+CAA+C;IAC/C,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,0CAA0C;IAC1C,IAAI,EAAE,UAAU,CAAC;IACjB,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,0DAA0D;IAC1D,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,gEAAgE;IAChE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,GAAG,EAAE,MAAM,CAAC;IACZ,mDAAmD;IACnD,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,4CAA4C;IAC5C,IAAI,EAAE,YAAY,CAAC;IACnB,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,mDAAmD;IACnD,GAAG,EAAE,MAAM,CAAC;IACZ,mDAAmD;IACnD,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,gDAAgD;IAChD,IAAI,EAAE,eAAe,CAAC;IACtB,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2DAA2D;IAC3D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oDAAoD;IACpD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,4CAA4C;IAC5C,IAAI,EAAE,YAAY,CAAC;IACnB,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,GACpB,mBAAmB,GACnB,eAAe,GACf,gBAAgB,GAChB,kBAAkB,GAClB,kBAAkB,GAClB,oBAAoB,GACpB,sBAAsB,GACtB,yBAAyB,GACzB,sBAAsB,CAAC;AAE3B;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,iDAAiD;IACjD,GAAG,EAAE,MAAM,CAAC;IACZ,mDAAmD;IACnD,QAAQ,EAAE,YAAY,EAAE,CAAC;CAC1B;AAMD;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,uBAAuB,CAAC;IACnC,8BAA8B;IAC9B,OAAO,CAAC,EAAE,sBAAsB,CAAC;IACjC,2BAA2B;IAC3B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,8BAA8B;IAC9B,OAAO,CAAC,EAAE,sBAAsB,CAAC;IACjC,iCAAiC;IACjC,UAAU,CAAC,EAAE,yBAAyB,CAAC;CACxC;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;OAQG;IACH,KAAK,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,CAAC;CACzC;AA6ND;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,kBAAkB,CA6I/F"}
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../src/resolver.ts"],"names":[],"mappings":"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"}

package/dist/resolver.js

@@ -84,9 +84,6 @@ function parseSpeedAltitude(token) {
     }
     return result;
 }
-// ---------------------------------------------------------------------------
-// Token resolution helpers
-// ---------------------------------------------------------------------------
 /**
  * Attempts to resolve a token as an airport (ICAO or FAA ID).
  */
@@ -147,29 +144,35 @@ function tryProcedure(token, procedures, airportContext) {
     return { type: 'star', raw: token, procedure: proc, legs };
 }
 /**
- * Attempts to resolve a token as a fix waypoint.
+ * Attempts to resolve a token as a fix waypoint. When an anchor is supplied and
+ * the lookup provides `byIdentAtPosition`, the identifier is disambiguated by
+ * proximity to the anchor; otherwise the first `byIdent` match is used.
  */
-function tryFix(token, fixes) {
+function tryFix(token, fixes, anchor) {
     if (!fixes) {
         return undefined;
     }
-    const results = fixes.byIdent(token);
-    if (results.length > 0) {
-        const fix = results[0];
+    const fix = anchor && fixes.byIdentAtPosition
+        ? fixes.byIdentAtPosition(token, anchor.lat, anchor.lon)
+        : fixes.byIdent(token)[0];
+    if (fix) {
         return { type: 'waypoint', raw: token, fix, lat: fix.lat, lon: fix.lon };
     }
     return undefined;
 }
 /**
- * Attempts to resolve a token as a navaid waypoint.
+ * Attempts to resolve a token as a navaid waypoint. When an anchor is supplied
+ * and the lookup provides `byIdentAtPosition`, the identifier is disambiguated
+ * by proximity to the anchor; otherwise the first `byIdent` match is used.
  */
-function tryNavaid(token, navaids) {
+function tryNavaid(token, navaids, anchor) {
     if (!navaids) {
         return undefined;
     }
-    const results = navaids.byIdent(token);
-    if (results.length > 0) {
-        const navaid = results[0];
+    const navaid = anchor && navaids.byIdentAtPosition
+        ? navaids.byIdentAtPosition(token, anchor.lat, anchor.lon)
+        : navaids.byIdent(token)[0];
+    if (navaid) {
         return { type: 'waypoint', raw: token, navaid, lat: navaid.lat, lon: navaid.lon };
     }
     return undefined;
@@ -226,6 +229,7 @@ export function createFlightplanResolver(options) {
             const elements = [];
             let lastWaypointIdent;
             let lastAirportIdent;
+            let lastPosition;
             let i = 0;
             while (i < tokens.length) {
                 const token = tokens[i].toUpperCase();
@@ -240,6 +244,7 @@ export function createFlightplanResolver(options) {
                 if (coord) {
                     elements.push({ type: 'coordinate', raw: token, lat: coord.lat, lon: coord.lon });
                     lastWaypointIdent = undefined;
+                    lastPosition = { lat: coord.lat, lon: coord.lon };
                     i++;
                     continue;
                 }
@@ -267,6 +272,10 @@ export function createFlightplanResolver(options) {
                             });
                             // The exit fix is consumed as part of the airway; update last waypoint
                             lastWaypointIdent = exitFix;
+                            const exitWaypoint = expansion.waypoints[expansion.waypoints.length - 1];
+                            if (exitWaypoint) {
+                                lastPosition = { lat: exitWaypoint.lat, lon: exitWaypoint.lon };
+                            }
                             i += 2;
                             continue;
                         }
@@ -298,6 +307,7 @@ export function createFlightplanResolver(options) {
                     // airport and a navaid on V16).
                     lastWaypointIdent = token;
                     lastAirportIdent = airportElement.airport.icao ?? airportElement.airport.faaId;
+                    lastPosition = { lat: airportElement.airport.lat, lon: airportElement.airport.lon };
                     i++;
                     continue;
                 }
@@ -308,9 +318,12 @@ export function createFlightplanResolver(options) {
                     // Update last waypoint to the last fix in the procedure expansion
                     // that actually terminates at a fix (some leg types have no fix).
                     for (let j = procElement.legs.length - 1; j >= 0; j--) {
-                        const fixIdent = procElement.legs[j]?.fixIdentifier;
-                        if (fixIdent !== undefined) {
-                            lastWaypointIdent = fixIdent;
+                        const leg = procElement.legs[j];
+                        if (leg?.fixIdentifier !== undefined) {
+                            lastWaypointIdent = leg.fixIdentifier;
+                            if (leg.lat !== undefined && leg.lon !== undefined) {
+                                lastPosition = { lat: leg.lat, lon: leg.lon };
+                            }
                             break;
                         }
                     }
@@ -318,18 +331,20 @@ export function createFlightplanResolver(options) {
                     continue;
                 }
                 // Try fix
-                const fixElement = tryFix(token, fixes);
+                const fixElement = tryFix(token, fixes, lastPosition);
                 if (fixElement) {
                     elements.push(fixElement);
                     lastWaypointIdent = token;
+                    lastPosition = { lat: fixElement.lat, lon: fixElement.lon };
                     i++;
                     continue;
                 }
                 // Try navaid
-                const navaidElement = tryNavaid(token, navaids);
+                const navaidElement = tryNavaid(token, navaids, lastPosition);
                 if (navaidElement) {
                     elements.push(navaidElement);
                     lastWaypointIdent = token;
+                    lastPosition = { lat: navaidElement.lat, lon: navaidElement.lon };
                     i++;
                     continue;
                 }

package/dist/route-distance.d.ts

@@ -1,7 +1,7 @@
 /**
  * Route distance and estimated time enroute computation for parsed flight
- * plan routes. Extracts the ordered geographic point sequence from a
- * {@link ParsedRoute} and sums great-circle leg distances.
+ * plan routes. Sums great-circle leg distances over the ordered geographic
+ * point sequence produced by the `route-geometry` module.
  */
 import type { ParsedRoute, RouteElement } from './resolver.js';
 /**
@@ -12,6 +12,14 @@ export interface RouteLeg {
     from: string;
     /** Identifier or raw token of the ending point. */
     to: string;
+    /** Latitude of the starting point in decimal degrees, positive north. */
+    fromLat: number;
+    /** Longitude of the starting point in decimal degrees, positive east. */
+    fromLon: number;
+    /** Latitude of the ending point in decimal degrees, positive north. */
+    toLat: number;
+    /** Longitude of the ending point in decimal degrees, positive east. */
+    toLon: number;
     /** Great-circle distance of this leg in nautical miles. */
     distanceNm: number;
     /** Cumulative distance from the route start through the end of this leg in nautical miles. */

package/dist/route-distance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route-distance.d.ts","sourceRoot":"","sources":["../src/route-distance.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAM/D;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,qDAAqD;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,EAAE,EAAE,MAAM,CAAC;IACX,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,8FAA8F;IAC9F,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,0DAA0D;IAC1D,IAAI,EAAE,QAAQ,EAAE,CAAC;IACjB,2DAA2D;IAC3D,eAAe,EAAE,MAAM,CAAC;IACxB,uFAAuF;IACvF,uBAAuB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C;;;;OAIG;IACH,kBAAkB,EAAE,YAAY,EAAE,CAAC;CACpC;AAgID;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,WAAW,EAClB,aAAa,CAAC,EAAE,MAAM,GACrB,mBAAmB,CAkCrB"}
+{"version":3,"file":"route-distance.d.ts","sourceRoot":"","sources":["../src/route-distance.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAO/D;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,qDAAqD;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,EAAE,EAAE,MAAM,CAAC;IACX,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,8FAA8F;IAC9F,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,0DAA0D;IAC1D,IAAI,EAAE,QAAQ,EAAE,CAAC;IACjB,2DAA2D;IAC3D,eAAe,EAAE,MAAM,CAAC;IACxB,uFAAuF;IACvF,uBAAuB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C;;;;OAIG;IACH,kBAAkB,EAAE,YAAY,EAAE,CAAC;CACpC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,WAAW,EAClB,aAAa,CAAC,EAAE,MAAM,GACrB,mBAAmB,CAsCrB"}

package/dist/route-distance.js

@@ -1,94 +1,10 @@
 /**
  * Route distance and estimated time enroute computation for parsed flight
- * plan routes. Extracts the ordered geographic point sequence from a
- * {@link ParsedRoute} and sums great-circle leg distances.
+ * plan routes. Sums great-circle leg distances over the ordered geographic
+ * point sequence produced by the `route-geometry` module.
  */
 import { greatCircle } from '@squawk/geo';
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-/** Epsilon for comparing coordinates to detect duplicate points. */
-const COORD_EPSILON = 1e-9;
-/**
- * Returns true if two points share the same coordinates (within epsilon).
- */
-function samePosition(a, b) {
-    return Math.abs(a.lat - b.lat) < COORD_EPSILON && Math.abs(a.lon - b.lon) < COORD_EPSILON;
-}
-/**
- * Walks the route elements and extracts an ordered array of geographic
- * points. Duplicate consecutive points (e.g. an airway entry fix that
- * matches the preceding waypoint) are suppressed.
- *
- * Also collects all `unresolved` elements encountered during the walk.
- */
-function extractGeoPoints(elements) {
-    const points = [];
-    const unresolvedElements = [];
-    function emit(point) {
-        if (points.length > 0 && samePosition(points[points.length - 1], point)) {
-            // When the duplicate carries a precomputed distance that the existing
-            // point lacks, adopt it. This happens when an airway's entry fix
-            // overlaps the preceding waypoint -- the airway waypoint has the
-            // published segment distance that would otherwise be lost.
-            const last = points[points.length - 1];
-            if (point.precomputedDistanceToNextNm !== undefined &&
-                last.precomputedDistanceToNextNm === undefined) {
-                last.precomputedDistanceToNextNm = point.precomputedDistanceToNextNm;
-            }
-            return;
-        }
-        points.push(point);
-    }
-    for (const el of elements) {
-        switch (el.type) {
-            case 'airport':
-                emit({ label: el.raw, lat: el.airport.lat, lon: el.airport.lon });
-                break;
-            case 'waypoint':
-                emit({ label: el.raw, lat: el.lat, lon: el.lon });
-                break;
-            case 'coordinate':
-                emit({ label: el.raw, lat: el.lat, lon: el.lon });
-                break;
-            case 'airway':
-                for (let i = 0; i < el.waypoints.length; i++) {
-                    const wp = el.waypoints[i];
-                    const isLast = i === el.waypoints.length - 1;
-                    const point = {
-                        label: wp.identifier ?? wp.name,
-                        lat: wp.lat,
-                        lon: wp.lon,
-                    };
-                    // Only carry precomputed distance for non-last waypoints (the
-                    // last waypoint's distanceToNextNm points beyond this segment).
-                    if (!isLast && wp.distanceToNextNm !== undefined) {
-                        point.precomputedDistanceToNextNm = wp.distanceToNextNm;
-                    }
-                    emit(point);
-                }
-                break;
-            case 'sid':
-            case 'star':
-                for (const leg of el.legs) {
-                    if (leg.fixIdentifier === undefined || leg.lat === undefined || leg.lon === undefined) {
-                        continue;
-                    }
-                    emit({ label: leg.fixIdentifier, lat: leg.lat, lon: leg.lon });
-                }
-                break;
-            case 'unresolved':
-                unresolvedElements.push(el);
-                break;
-            // 'direct' and 'speedAltitude' are expected non-geographic markers
-            // and are silently skipped.
-            case 'direct':
-            case 'speedAltitude':
-                break;
-        }
-    }
-    return { points, unresolvedElements };
-}
+import { extractGeoPoints } from './route-geometry.js';
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -135,6 +51,10 @@ export function computeRouteDistance(route, groundSpeedKt) {
         legs.push({
             from: from.label,
             to: to.label,
+            fromLat: from.lat,
+            fromLon: from.lon,
+            toLat: to.lat,
+            toLon: to.lon,
             distanceNm: legDistanceNm,
             cumulativeDistanceNm: totalDistanceNm,
         });

package/dist/route-geometry.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Drawable geometry extraction for parsed flight plan routes. Walks the
+ * {@link ParsedRoute} elements into an ordered point sequence - expanding
+ * airway waypoints, flattening SID/STAR legs, and suppressing consecutive
+ * duplicate points - and exposes that sequence both as plain
+ * {@link RoutePoint} values and as a GeoJSON `LineString` for map rendering.
+ *
+ * The same walk feeds `computeRouteDistance` in the `route-distance` module,
+ * so distance and geometry stay in agreement.
+ */
+import type { LineString } from 'geojson';
+import type { ParsedRoute, RouteElement } from './resolver.js';
+/**
+ * A single drawable geographic point along a parsed route, in route order.
+ */
+export interface RoutePoint {
+    /** Display label (identifier or raw token) for the point. */
+    label: string;
+    /** Latitude in decimal degrees, positive north. */
+    lat: number;
+    /** Longitude in decimal degrees, positive east. */
+    lon: number;
+}
+/**
+ * A geographic point extracted from a route element. Internal to the package;
+ * carries the precomputed airway segment distance that `computeRouteDistance`
+ * needs but that is not part of the public {@link RoutePoint} shape.
+ *
+ * @internal
+ */
+export interface GeoPoint {
+    /** Display label (identifier or raw token). */
+    label: string;
+    /** Latitude in decimal degrees, positive north. */
+    lat: number;
+    /** Longitude in decimal degrees, positive east. */
+    lon: number;
+    /**
+     * Pre-computed distance to the next point along an airway segment in
+     * nautical miles, if available from the source data.
+     */
+    precomputedDistanceToNextNm?: number;
+}
+/**
+ * Walks the route elements and extracts an ordered array of geographic
+ * points. Duplicate consecutive points (e.g. an airway entry fix that
+ * matches the preceding waypoint) are suppressed.
+ *
+ * Also collects all `unresolved` elements encountered during the walk.
+ *
+ * Internal to the package: `extractRoutePoints` and `routeToLineString`
+ * project this into public shapes, and `computeRouteDistance` consumes the
+ * precomputed segment distances directly.
+ *
+ * @internal
+ */
+export declare function extractGeoPoints(elements: RouteElement[]): {
+    points: GeoPoint[];
+    unresolvedElements: RouteElement[];
+};
+/**
+ * Extracts the ordered sequence of drawable geographic points from a parsed
+ * flight plan route.
+ *
+ * Expands airway and SID/STAR segments into their constituent fixes and
+ * suppresses consecutive duplicate points (e.g. an airway entry fix that
+ * matches the preceding waypoint). Elements without coordinates (DCT,
+ * speed/altitude groups, unresolved tokens) contribute no points.
+ *
+ * This is the same walk that backs `computeRouteDistance`, so the point
+ * sequence here lines up with that result's legs.
+ *
+ * ```typescript
+ * import { createFlightplanResolver, extractRoutePoints } from '@squawk/flightplan';
+ *
+ * const resolver = createFlightplanResolver({ airports, navaids, fixes, airways });
+ * const route = resolver.parse('KJFK DCT MERIT J60 MARTN DCT KLAX');
+ * const points = extractRoutePoints(route);
+ * ```
+ *
+ * @param route - A parsed route from {@link FlightplanResolver.parse}.
+ * @returns Ordered drawable points along the route.
+ */
+export declare function extractRoutePoints(route: ParsedRoute): RoutePoint[];
+/**
+ * Builds a GeoJSON `LineString` from a parsed flight plan route, ready to
+ * render as a polyline on a map (e.g. MapLibre, Leaflet).
+ *
+ * Coordinates follow the GeoJSON `[lon, lat]` ordering. Returns `undefined`
+ * when the route yields fewer than two drawable points, since a `LineString`
+ * requires at least two positions to be valid.
+ *
+ * ```typescript
+ * import { createFlightplanResolver, routeToLineString } from '@squawk/flightplan';
+ *
+ * const resolver = createFlightplanResolver({ airports, navaids, fixes, airways });
+ * const route = resolver.parse('KJFK DCT MERIT J60 MARTN DCT KLAX');
+ * const line = routeToLineString(route);
+ * if (line) {
+ *   map.addSource('route', { type: 'geojson', data: line });
+ * }
+ * ```
+ *
+ * @param route - A parsed route from {@link FlightplanResolver.parse}.
+ * @returns A GeoJSON `LineString`, or `undefined` if fewer than two points.
+ */
+export declare function routeToLineString(route: ParsedRoute): LineString | undefined;
+//# sourceMappingURL=route-geometry.d.ts.map

package/dist/route-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-geometry.d.ts","sourceRoot":"","sources":["../src/route-geometry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAM/D;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,GAAG,EAAE,MAAM,CAAC;IACZ,mDAAmD;IACnD,GAAG,EAAE,MAAM,CAAC;CACb;AAMD;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,GAAG,EAAE,MAAM,CAAC;IACZ,mDAAmD;IACnD,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,2BAA2B,CAAC,EAAE,MAAM,CAAC;CACtC;AAgBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG;IAC1D,MAAM,EAAE,QAAQ,EAAE,CAAC;IACnB,kBAAkB,EAAE,YAAY,EAAE,CAAC;CACpC,CA6EA;AAMD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,UAAU,EAAE,CAGnE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,UAAU,GAAG,SAAS,CAS5E"}

package/dist/route-geometry.js

@@ -0,0 +1,163 @@
+/**
+ * Drawable geometry extraction for parsed flight plan routes. Walks the
+ * {@link ParsedRoute} elements into an ordered point sequence - expanding
+ * airway waypoints, flattening SID/STAR legs, and suppressing consecutive
+ * duplicate points - and exposes that sequence both as plain
+ * {@link RoutePoint} values and as a GeoJSON `LineString` for map rendering.
+ *
+ * The same walk feeds `computeRouteDistance` in the `route-distance` module,
+ * so distance and geometry stay in agreement.
+ */
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/** Epsilon for comparing coordinates to detect duplicate points. */
+const COORD_EPSILON = 1e-9;
+/**
+ * Returns true if two points share the same coordinates (within epsilon).
+ */
+function samePosition(a, b) {
+    return Math.abs(a.lat - b.lat) < COORD_EPSILON && Math.abs(a.lon - b.lon) < COORD_EPSILON;
+}
+/**
+ * Walks the route elements and extracts an ordered array of geographic
+ * points. Duplicate consecutive points (e.g. an airway entry fix that
+ * matches the preceding waypoint) are suppressed.
+ *
+ * Also collects all `unresolved` elements encountered during the walk.
+ *
+ * Internal to the package: `extractRoutePoints` and `routeToLineString`
+ * project this into public shapes, and `computeRouteDistance` consumes the
+ * precomputed segment distances directly.
+ *
+ * @internal
+ */
+export function extractGeoPoints(elements) {
+    const points = [];
+    const unresolvedElements = [];
+    function emit(point) {
+        if (points.length > 0 && samePosition(points[points.length - 1], point)) {
+            // When the duplicate carries a precomputed distance that the existing
+            // point lacks, adopt it. This happens when an airway's entry fix
+            // overlaps the preceding waypoint -- the airway waypoint has the
+            // published segment distance that would otherwise be lost.
+            const last = points[points.length - 1];
+            if (point.precomputedDistanceToNextNm !== undefined &&
+                last.precomputedDistanceToNextNm === undefined) {
+                last.precomputedDistanceToNextNm = point.precomputedDistanceToNextNm;
+            }
+            return;
+        }
+        points.push(point);
+    }
+    for (const el of elements) {
+        switch (el.type) {
+            case 'airport':
+                emit({ label: el.raw, lat: el.airport.lat, lon: el.airport.lon });
+                break;
+            case 'waypoint':
+                emit({ label: el.raw, lat: el.lat, lon: el.lon });
+                break;
+            case 'coordinate':
+                emit({ label: el.raw, lat: el.lat, lon: el.lon });
+                break;
+            case 'airway':
+                for (let i = 0; i < el.waypoints.length; i++) {
+                    const wp = el.waypoints[i];
+                    const isLast = i === el.waypoints.length - 1;
+                    const point = {
+                        label: wp.identifier ?? wp.name,
+                        lat: wp.lat,
+                        lon: wp.lon,
+                    };
+                    // Only carry precomputed distance for non-last waypoints (the
+                    // last waypoint's distanceToNextNm points beyond this segment).
+                    if (!isLast && wp.distanceToNextNm !== undefined) {
+                        point.precomputedDistanceToNextNm = wp.distanceToNextNm;
+                    }
+                    emit(point);
+                }
+                break;
+            case 'sid':
+            case 'star':
+                for (const leg of el.legs) {
+                    if (leg.fixIdentifier === undefined || leg.lat === undefined || leg.lon === undefined) {
+                        continue;
+                    }
+                    emit({ label: leg.fixIdentifier, lat: leg.lat, lon: leg.lon });
+                }
+                break;
+            case 'unresolved':
+                unresolvedElements.push(el);
+                break;
+            // 'direct' and 'speedAltitude' are expected non-geographic markers
+            // and are silently skipped.
+            case 'direct':
+            case 'speedAltitude':
+                break;
+        }
+    }
+    return { points, unresolvedElements };
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Extracts the ordered sequence of drawable geographic points from a parsed
+ * flight plan route.
+ *
+ * Expands airway and SID/STAR segments into their constituent fixes and
+ * suppresses consecutive duplicate points (e.g. an airway entry fix that
+ * matches the preceding waypoint). Elements without coordinates (DCT,
+ * speed/altitude groups, unresolved tokens) contribute no points.
+ *
+ * This is the same walk that backs `computeRouteDistance`, so the point
+ * sequence here lines up with that result's legs.
+ *
+ * ```typescript
+ * import { createFlightplanResolver, extractRoutePoints } from '@squawk/flightplan';
+ *
+ * const resolver = createFlightplanResolver({ airports, navaids, fixes, airways });
+ * const route = resolver.parse('KJFK DCT MERIT J60 MARTN DCT KLAX');
+ * const points = extractRoutePoints(route);
+ * ```
+ *
+ * @param route - A parsed route from {@link FlightplanResolver.parse}.
+ * @returns Ordered drawable points along the route.
+ */
+export function extractRoutePoints(route) {
+    const { points } = extractGeoPoints(route.elements);
+    return points.map((p) => ({ label: p.label, lat: p.lat, lon: p.lon }));
+}
+/**
+ * Builds a GeoJSON `LineString` from a parsed flight plan route, ready to
+ * render as a polyline on a map (e.g. MapLibre, Leaflet).
+ *
+ * Coordinates follow the GeoJSON `[lon, lat]` ordering. Returns `undefined`
+ * when the route yields fewer than two drawable points, since a `LineString`
+ * requires at least two positions to be valid.
+ *
+ * ```typescript
+ * import { createFlightplanResolver, routeToLineString } from '@squawk/flightplan';
+ *
+ * const resolver = createFlightplanResolver({ airports, navaids, fixes, airways });
+ * const route = resolver.parse('KJFK DCT MERIT J60 MARTN DCT KLAX');
+ * const line = routeToLineString(route);
+ * if (line) {
+ *   map.addSource('route', { type: 'geojson', data: line });
+ * }
+ * ```
+ *
+ * @param route - A parsed route from {@link FlightplanResolver.parse}.
+ * @returns A GeoJSON `LineString`, or `undefined` if fewer than two points.
+ */
+export function routeToLineString(route) {
+    const points = extractRoutePoints(route);
+    if (points.length < 2) {
+        return undefined;
+    }
+    return {
+        type: 'LineString',
+        coordinates: points.map((p) => [p.lon, p.lat]),
+    };
+}

package/dist/route-timing.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Wind-corrected route timing for parsed flight plan routes. Layers per-leg
+ * wind triangle solutions over the great-circle legs produced by the
+ * `route-distance` module: each leg's true course drives a heading, wind
+ * correction angle, and ground speed, which in turn yield estimated time
+ * enroute and optional fuel burn.
+ *
+ * Winds are supplied by the caller through a {@link WindProvider}, keeping this
+ * module independent of any particular weather source. A `@squawk/weather`
+ * winds-aloft forecast sampled at a chosen cruise altitude is one way to
+ * satisfy the provider.
+ */
+import type { WindVector } from '@squawk/flight-math';
+import type { ParsedRoute, RouteElement } from './resolver.js';
+/**
+ * Resolves the wind at a geographic point for route timing. Returns the wind
+ * vector to apply, or `undefined` when no wind data is available (or the wind
+ * is light and variable), in which case the leg is timed as if calm.
+ *
+ * The provider takes only a position; bake the sampling altitude into the
+ * closure so this module stays altitude-agnostic.
+ *
+ * @param lat - Latitude of the sample point in decimal degrees, positive north.
+ * @param lon - Longitude of the sample point in decimal degrees, positive east.
+ * @returns The wind vector to apply at the point, or `undefined` for calm.
+ */
+export type WindProvider = (lat: number, lon: number) => WindVector | undefined;
+/**
+ * Options controlling a {@link computeRouteTiming} computation.
+ */
+export interface RouteTimingOptions {
+    /** True airspeed in knots flown on every leg. */
+    trueAirspeedKt: number;
+    /**
+     * Supplies the wind at each leg's midpoint. Omit to time every leg as calm
+     * (ground speed equals true airspeed).
+     */
+    windProvider?: WindProvider;
+    /**
+     * Fuel burn rate per hour (any consistent unit). When provided, per-leg and
+     * total fuel are computed; the result fuel fields stay `undefined` otherwise.
+     */
+    fuelBurnPerHr?: number;
+    /**
+     * Fuel on board (same unit as `fuelBurnPerHr`). When provided together with
+     * `fuelBurnPerHr`, the result reports endurance and whether fuel is
+     * sufficient for the total estimated time enroute.
+     */
+    fuelAvailable?: number;
+}
+/**
+ * A single route leg with its wind-corrected timing solution.
+ */
+export interface RouteTimingLeg {
+    /** Identifier or raw token of the starting point. */
+    from: string;
+    /** Identifier or raw token of the ending point. */
+    to: string;
+    /** Latitude of the starting point in decimal degrees, positive north. */
+    fromLat: number;
+    /** Longitude of the starting point in decimal degrees, positive east. */
+    fromLon: number;
+    /** Latitude of the ending point in decimal degrees, positive north. */
+    toLat: number;
+    /** Longitude of the ending point in decimal degrees, positive east. */
+    toLon: number;
+    /** Great-circle distance of this leg in nautical miles. */
+    distanceNm: number;
+    /** Cumulative distance from the route start through the end of this leg in nautical miles. */
+    cumulativeDistanceNm: number;
+    /** Initial great-circle true course for the leg in degrees (0-360). */
+    trueCourseDeg: number;
+    /** True heading to fly to hold the course given the wind, in degrees (0-360). */
+    trueHeadingDeg: number;
+    /** Wind correction angle in degrees. Positive means crab right, negative means crab left. */
+    windCorrectionAngleDeg: number;
+    /** Ground speed in knots after wind correction. */
+    groundSpeedKt: number;
+    /** Wind applied to the leg, or `undefined` when the leg was timed as calm. */
+    wind: WindVector | undefined;
+    /** Estimated time enroute for the leg in hours, or `undefined` if ground speed is not positive. */
+    eteHrs: number | undefined;
+    /**
+     * Cumulative estimated time enroute from the route start through this leg in
+     * hours. `undefined` once any preceding leg could not be timed.
+     */
+    cumulativeEteHrs: number | undefined;
+    /**
+     * Fuel required for the leg (same unit as `fuelBurnPerHr`), or `undefined`
+     * when no burn rate was given or the leg could not be timed.
+     */
+    fuelRequired: number | undefined;
+}
+/**
+ * Result of computing wind-corrected timing across a parsed flight plan route.
+ */
+export interface RouteTimingResult {
+    /** Ordered legs with their wind-corrected timing. */
+    legs: RouteTimingLeg[];
+    /** Total great-circle route distance in nautical miles. */
+    totalDistanceNm: number;
+    /**
+     * Total estimated time enroute in hours, or `undefined` if any leg could not
+     * be timed (ground speed not positive).
+     */
+    totalEteHrs: number | undefined;
+    /**
+     * Total fuel required across all legs (same unit as `fuelBurnPerHr`), or
+     * `undefined` when no burn rate was given or any leg could not be timed.
+     */
+    totalFuelRequired: number | undefined;
+    /**
+     * Endurance in hours from `fuelAvailable` and `fuelBurnPerHr`, or `undefined`
+     * when either input was omitted.
+     */
+    enduranceHrs: number | undefined;
+    /**
+     * Whether endurance covers the total estimated time enroute, or `undefined`
+     * when endurance or total ETE could not be computed.
+     */
+    fuelSufficient: boolean | undefined;
+    /**
+     * Route elements of type `unresolved` that could not contribute coordinates,
+     * passed through from the distance computation.
+     */
+    unresolvedElements: RouteElement[];
+}
+/**
+ * Computes wind-corrected per-leg timing for a parsed flight plan route.
+ *
+ * Reuses {@link computeRouteDistance} for the leg geometry, then for each leg
+ * derives the initial true course, samples the wind at the leg midpoint via the
+ * optional {@link WindProvider}, and solves the wind triangle for heading, wind
+ * correction angle, and ground speed. Estimated time enroute is leg distance
+ * divided by ground speed, and fuel (when a burn rate is given) follows from
+ * the same ground speed.
+ *
+ * When the provider returns `undefined` for a leg, that leg is timed as calm:
+ * heading equals course, wind correction angle is zero, and ground speed equals
+ * true airspeed.
+ *
+ * Ground speed comes from {@link solveWindTriangle} as a magnitude, so it is
+ * never negative. A leg is left untimed (`eteHrs` `undefined`) only when ground
+ * speed is not positive, which occurs at the boundary where a pure headwind
+ * equals true airspeed. A headwind exceeding true airspeed still yields a
+ * positive magnitude and inherits the clamping behavior documented on
+ * {@link solveWindTriangle}; such legs are not separately flagged here. A single
+ * untimed leg makes `totalEteHrs` (and `totalFuelRequired`, when fuel is
+ * requested) `undefined`.
+ *
+ * ```typescript
+ * import { createFlightplanResolver, computeRouteTiming } from '@squawk/flightplan';
+ *
+ * const resolver = createFlightplanResolver({ airports, navaids, fixes, airways });
+ * const route = resolver.parse('KJFK DCT MERIT J60 MARTN DCT KLAX');
+ * const result = computeRouteTiming(route, {
+ *   trueAirspeedKt: 450,
+ *   windProvider: (lat, lon) => ({ directionDeg: 270, speedKt: 80 }),
+ *   fuelBurnPerHr: 600,
+ * });
+ * console.log(result.totalEteHrs, result.totalFuelRequired);
+ * ```
+ *
+ * @param route - A parsed route from {@link FlightplanResolver.parse}.
+ * @param options - True airspeed, optional wind provider, and optional fuel inputs.
+ * @returns Per-leg wind-corrected timing with route totals.
+ */
+export declare function computeRouteTiming(route: ParsedRoute, options: RouteTimingOptions): RouteTimingResult;
+//# sourceMappingURL=route-timing.d.ts.map

package/dist/route-timing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-timing.d.ts","sourceRoot":"","sources":["../src/route-timing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGtD,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAO/D;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,UAAU,GAAG,SAAS,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,iDAAiD;IACjD,cAAc,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,qDAAqD;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,EAAE,EAAE,MAAM,CAAC;IACX,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,8FAA8F;IAC9F,oBAAoB,EAAE,MAAM,CAAC;IAC7B,uEAAuE;IACvE,aAAa,EAAE,MAAM,CAAC;IACtB,iFAAiF;IACjF,cAAc,EAAE,MAAM,CAAC;IACvB,6FAA6F;IAC7F,sBAAsB,EAAE,MAAM,CAAC;IAC/B,mDAAmD;IACnD,aAAa,EAAE,MAAM,CAAC;IACtB,8EAA8E;IAC9E,IAAI,EAAE,UAAU,GAAG,SAAS,CAAC;IAC7B,mGAAmG;IACnG,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B;;;OAGG;IACH,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC;;;OAGG;IACH,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,qDAAqD;IACrD,IAAI,EAAE,cAAc,EAAE,CAAC;IACvB,2DAA2D;IAC3D,eAAe,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC;;;OAGG;IACH,iBAAiB,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC;;;OAGG;IACH,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC;;;OAGG;IACH,cAAc,EAAE,OAAO,GAAG,SAAS,CAAC;IACpC;;;OAGG;IACH,kBAAkB,EAAE,YAAY,EAAE,CAAC;CACpC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,kBAAkB,GAC1B,iBAAiB,CAwFnB"}

package/dist/route-timing.js

@@ -0,0 +1,129 @@
+/**
+ * Wind-corrected route timing for parsed flight plan routes. Layers per-leg
+ * wind triangle solutions over the great-circle legs produced by the
+ * `route-distance` module: each leg's true course drives a heading, wind
+ * correction angle, and ground speed, which in turn yield estimated time
+ * enroute and optional fuel burn.
+ *
+ * Winds are supplied by the caller through a {@link WindProvider}, keeping this
+ * module independent of any particular weather source. A `@squawk/weather`
+ * winds-aloft forecast sampled at a chosen cruise altitude is one way to
+ * satisfy the provider.
+ */
+import { planning, wind } from '@squawk/flight-math';
+import { greatCircle } from '@squawk/geo';
+import { computeRouteDistance } from './route-distance.js';
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Computes wind-corrected per-leg timing for a parsed flight plan route.
+ *
+ * Reuses {@link computeRouteDistance} for the leg geometry, then for each leg
+ * derives the initial true course, samples the wind at the leg midpoint via the
+ * optional {@link WindProvider}, and solves the wind triangle for heading, wind
+ * correction angle, and ground speed. Estimated time enroute is leg distance
+ * divided by ground speed, and fuel (when a burn rate is given) follows from
+ * the same ground speed.
+ *
+ * When the provider returns `undefined` for a leg, that leg is timed as calm:
+ * heading equals course, wind correction angle is zero, and ground speed equals
+ * true airspeed.
+ *
+ * Ground speed comes from {@link solveWindTriangle} as a magnitude, so it is
+ * never negative. A leg is left untimed (`eteHrs` `undefined`) only when ground
+ * speed is not positive, which occurs at the boundary where a pure headwind
+ * equals true airspeed. A headwind exceeding true airspeed still yields a
+ * positive magnitude and inherits the clamping behavior documented on
+ * {@link solveWindTriangle}; such legs are not separately flagged here. A single
+ * untimed leg makes `totalEteHrs` (and `totalFuelRequired`, when fuel is
+ * requested) `undefined`.
+ *
+ * ```typescript
+ * import { createFlightplanResolver, computeRouteTiming } from '@squawk/flightplan';
+ *
+ * const resolver = createFlightplanResolver({ airports, navaids, fixes, airways });
+ * const route = resolver.parse('KJFK DCT MERIT J60 MARTN DCT KLAX');
+ * const result = computeRouteTiming(route, {
+ *   trueAirspeedKt: 450,
+ *   windProvider: (lat, lon) => ({ directionDeg: 270, speedKt: 80 }),
+ *   fuelBurnPerHr: 600,
+ * });
+ * console.log(result.totalEteHrs, result.totalFuelRequired);
+ * ```
+ *
+ * @param route - A parsed route from {@link FlightplanResolver.parse}.
+ * @param options - True airspeed, optional wind provider, and optional fuel inputs.
+ * @returns Per-leg wind-corrected timing with route totals.
+ */
+export function computeRouteTiming(route, options) {
+    const { trueAirspeedKt, windProvider, fuelBurnPerHr, fuelAvailable } = options;
+    const { legs: distanceLegs, totalDistanceNm, unresolvedElements } = computeRouteDistance(route);
+    const legs = [];
+    let cumulativeEteHrs = 0;
+    let totalFuelRequired = fuelBurnPerHr !== undefined ? 0 : undefined;
+    for (const leg of distanceLegs) {
+        const trueCourseDeg = greatCircle.bearing(leg.fromLat, leg.fromLon, leg.toLat, leg.toLon);
+        const mid = greatCircle.midpoint(leg.fromLat, leg.fromLon, leg.toLat, leg.toLon);
+        const legWind = windProvider?.(mid.lat, mid.lon);
+        const triangle = legWind !== undefined
+            ? wind.solveWindTriangle(trueAirspeedKt, trueCourseDeg, legWind.directionDeg, legWind.speedKt)
+            : {
+                trueHeadingDeg: trueCourseDeg,
+                windCorrectionAngleDeg: 0,
+                groundSpeedKt: trueAirspeedKt,
+            };
+        const eteHrs = triangle.groundSpeedKt > 0 ? leg.distanceNm / triangle.groundSpeedKt : undefined;
+        if (eteHrs === undefined || cumulativeEteHrs === undefined) {
+            cumulativeEteHrs = undefined;
+        }
+        else {
+            cumulativeEteHrs += eteHrs;
+        }
+        const fuelRequired = fuelBurnPerHr !== undefined && eteHrs !== undefined
+            ? planning.fuelRequired(leg.distanceNm, triangle.groundSpeedKt, fuelBurnPerHr)
+            : undefined;
+        if (fuelBurnPerHr !== undefined) {
+            if (fuelRequired === undefined || totalFuelRequired === undefined) {
+                totalFuelRequired = undefined;
+            }
+            else {
+                totalFuelRequired += fuelRequired;
+            }
+        }
+        legs.push({
+            from: leg.from,
+            to: leg.to,
+            fromLat: leg.fromLat,
+            fromLon: leg.fromLon,
+            toLat: leg.toLat,
+            toLon: leg.toLon,
+            distanceNm: leg.distanceNm,
+            cumulativeDistanceNm: leg.cumulativeDistanceNm,
+            trueCourseDeg,
+            trueHeadingDeg: triangle.trueHeadingDeg,
+            windCorrectionAngleDeg: triangle.windCorrectionAngleDeg,
+            groundSpeedKt: triangle.groundSpeedKt,
+            wind: legWind,
+            eteHrs,
+            cumulativeEteHrs,
+            fuelRequired,
+        });
+    }
+    const totalEteHrs = legs.length > 0 ? legs[legs.length - 1].cumulativeEteHrs : 0;
+    const enduranceHrs = fuelAvailable !== undefined && fuelBurnPerHr !== undefined
+        ? planning.endurance(fuelAvailable, fuelBurnPerHr)
+        : undefined;
+    const fuelSufficient = enduranceHrs !== undefined && totalEteHrs !== undefined
+        ? enduranceHrs >= totalEteHrs
+        : undefined;
+    return {
+        legs,
+        totalDistanceNm,
+        totalEteHrs,
+        totalFuelRequired,
+        enduranceHrs,
+        fuelSufficient,
+        unresolvedElements,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squawk/flightplan",
-  "version": "0.5.7",
+  "version": "0.6.0",
   "type": "module",
   "description": "Flight plan route string parsing and resolution using composed navigation resolvers",
   "author": "Neil Cochran",
@@ -29,7 +29,8 @@
   },
   "files": [
     "dist",
-    "!dist/**/*.spec.*"
+    "!dist/**/*.spec.*",
+    "!dist/test-utils.*"
   ],
   "scripts": {
     "build": "tsc",
@@ -41,20 +42,22 @@
     "api:report": "api-extractor run --local --verbose"
   },
   "dependencies": {
+    "@squawk/flight-math": "^0.5.9",
     "@squawk/geo": "^0.4.3",
-    "@squawk/types": "^0.8.0"
+    "@squawk/types": "^0.8.0",
+    "@types/geojson": "^7946.0.16"
   },
   "devDependencies": {
     "@squawk/airport-data": "^0.7.3",
-    "@squawk/airports": "^0.6.1",
+    "@squawk/airports": "^0.7.0",
     "@squawk/airway-data": "^0.5.3",
-    "@squawk/airways": "^0.4.1",
+    "@squawk/airways": "^0.5.0",
     "@squawk/fix-data": "^0.6.3",
-    "@squawk/fixes": "^0.3.1",
+    "@squawk/fixes": "^0.5.0",
     "@squawk/navaid-data": "^0.6.3",
-    "@squawk/navaids": "^0.4.1",
+    "@squawk/navaids": "^0.6.0",
     "@squawk/procedure-data": "^0.7.2",
-    "@squawk/procedures": "^0.5.1",
+    "@squawk/procedures": "^0.7.0",
     "@types/node": "^25.9.3"
   },
   "keywords": [