@squawk/mcp 0.9.6 → 0.11.0

package/README.md

@@ -98,7 +98,7 @@ version explicitly in the client config:
   "mcpServers": {
     "squawk": {
       "command": "npx",
-      "args": ["-y", "@squawk/mcp@0.9.6"]
+      "args": ["-y", "@squawk/mcp@0.11.0"]
     }
   }
 }
@@ -164,7 +164,7 @@ Pinning works the same way:
   "mcpServers": {
     "squawk": {
       "command": "npx",
-      "args": ["-y", "-p", "@squawk/icao-registry-data@0.8.10", "@squawk/mcp@0.9.6"]
+      "args": ["-y", "-p", "@squawk/icao-registry-data@0.8.10", "@squawk/mcp@0.11.0"]
     }
   }
 }
@@ -249,7 +249,7 @@ directly.
 | `get_airport_by_faa_id` | Look up an airport by FAA identifier                                                   |
 | `get_airport_by_icao`   | Look up an airport by ICAO code                                                        |
 | `find_nearest_airports` | Find airports nearest a position with optional facility-type and runway-length filters |
-| `search_airports`       | Substring search by airport name or city                                               |
+| `search_airports`       | Fuzzy search by FAA identifier, name, or city                                          |
 
 ### Airspace (`@squawk/airspace` + `@squawk/airspace-data`)
 
@@ -259,23 +259,26 @@ directly.
 | `get_airspace_for_airport`   | Class B/C/D/E2 surface-area sectors associated with an airport, with full polygon boundaries                                                    |
 | `find_artcc_for_position`    | US ARTCC features containing a given position and altitude (typically one feature; multiple for oceanic CTA+FIR overlaps or stratum boundaries) |
 | `find_artcc_by_identifier`   | All ARTCC features for a 3-letter center code (e.g. "ZNY"), optionally narrowed to a single stratum, with full polygon boundaries               |
+| `search_airspace`            | Fuzzy search by identifier or name (boundary summarized as a vertex count)                                                                      |
 
 ### Navaids (`@squawk/navaids` + `@squawk/navaid-data`)
 
-| Tool                        | Purpose                                         |
-| --------------------------- | ----------------------------------------------- |
-| `get_navaid_by_ident`       | Look up navaids by identifier                   |
-| `find_navaids_by_frequency` | Find navaids tuned to a given MHz/kHz frequency |
-| `find_nearest_navaids`      | Find navaids nearest a position                 |
-| `search_navaids`            | Substring search by name or identifier          |
+| Tool                              | Purpose                                                  |
+| --------------------------------- | -------------------------------------------------------- |
+| `get_navaid_by_ident`             | Look up navaids by identifier                            |
+| `get_navaid_by_ident_at_position` | Look up the navaid sharing an identifier nearest a point |
+| `find_navaids_by_frequency`       | Find navaids tuned to a given MHz/kHz frequency          |
+| `find_nearest_navaids`            | Find navaids nearest a position                          |
+| `search_navaids`                  | Fuzzy search by name or identifier                       |
 
 ### Fixes (`@squawk/fixes` + `@squawk/fix-data`)
 
-| Tool                 | Purpose                        |
-| -------------------- | ------------------------------ |
-| `get_fix_by_ident`   | Look up fixes by identifier    |
-| `find_nearest_fixes` | Find fixes nearest a position  |
-| `search_fixes`       | Substring search by identifier |
+| Tool                           | Purpose                                               |
+| ------------------------------ | ----------------------------------------------------- |
+| `get_fix_by_ident`             | Look up fixes by identifier                           |
+| `get_fix_by_ident_at_position` | Look up the fix sharing an identifier nearest a point |
+| `find_nearest_fixes`           | Find fixes nearest a position                         |
+| `search_fixes`                 | Fuzzy search by identifier                            |
 
 ### Airways (`@squawk/airways` + `@squawk/airway-data`)
 
@@ -284,7 +287,7 @@ directly.
 | `get_airway_by_designation` | Look up airways by designation                        |
 | `expand_airway_segment`     | Expand an airway between an entry fix and an exit fix |
 | `find_airways_by_fix`       | Reverse lookup: airways that pass through a given fix |
-| `search_airways`            | Substring search by designation                       |
+| `search_airways`            | Fuzzy search by designation                           |
 
 ### Procedures (`@squawk/procedures` + `@squawk/procedure-data`)
 
@@ -298,7 +301,8 @@ Covers SIDs, STARs, and Instrument Approach Procedures (IAPs) from FAA CIFP.
 | `find_procedures_by_airport_and_runway`   | Procedures at an airport serving a specific runway (IAP runway match or RW\* transition)    |
 | `find_approaches_by_type`                 | Every IAP of a given approach classification (ILS, RNAV, VOR, etc.)                         |
 | `expand_procedure`                        | Expand a procedure into its leg sequence (with optional transition merge)                   |
-| `search_procedures`                       | Substring search by name or identifier, optionally filtered by procedure or approach type   |
+| `get_procedure_geometry`                  | Ordered drawable fix points and a GeoJSON LineString for a procedure                        |
+| `search_procedures`                       | Fuzzy search by name or identifier, optionally filtered by procedure or approach type       |
 
 ### ICAO aircraft registry (`@squawk/icao-registry` + `@squawk/icao-registry-data`)
 
@@ -342,6 +346,8 @@ lookup so sessions that never need it do not pay the cost.
 | ------------------------ | ---------------------------------------------------------- |
 | `parse_flightplan_route` | Parse an ICAO Item 15 route into structured route elements |
 | `compute_route_distance` | Total great-circle route distance with optional ETE        |
+| `get_route_geometry`     | Ordered drawable points and a GeoJSON LineString           |
+| `get_route_timing`       | Per-leg wind-corrected timing, ETE, and fuel/endurance     |
 
 ### Flight computer (`@squawk/flight-math`)
 

package/dist/tools/airports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"airports.d.ts","sourceRoot":"","sources":["../../src/tools/airports.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAkBzE;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA6I5D"}
+{"version":3,"file":"airports.d.ts","sourceRoot":"","sources":["../../src/tools/airports.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAkBzE;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA2J5D"}

package/dist/tools/airports.js

@@ -111,9 +111,12 @@ export function registerAirportTools(server) {
     });
     server.registerTool('search_airports', {
         title: 'Search airports by name or city',
-        description: 'Searches US airports using case-insensitive substring matching on airport name and city. Returns airports in alphabetical order by name. Use this when the user knows a partial name but not the identifier.',
+        description: 'Fuzzy-searches US airports across FAA identifier, name, and city. Matching is case-insensitive and tolerant of prefixes, substrings, subsequences, and small typos. Each result carries a match score in [0, 1] (1 is an exact match) and the matched field; results are returned best-match first. Use this when the user knows a partial name but not the identifier.',
         inputSchema: {
-            text: z.string().min(1).describe('Substring to match against airport name or city.'),
+            text: z
+                .string()
+                .min(1)
+                .describe('Search text, fuzzily matched against airport FAA identifier, name, and city.'),
             limit: z
                 .number()
                 .int()
@@ -124,8 +127,14 @@ export function registerAirportTools(server) {
                 .array(z.enum(FACILITY_TYPE_VALUES))
                 .optional()
                 .describe('Restrict results to these facility types. Omit to include all types.'),
+            minScore: z
+                .number()
+                .min(0)
+                .max(1)
+                .optional()
+                .describe('Minimum match score (exclusive) in [0, 1] a result must reach. Defaults to 0. Raise it to drop weak fuzzy matches.'),
         },
-    }, ({ text, limit, facilityTypes }) => {
+    }, ({ text, limit, facilityTypes, minScore }) => {
         const query = { text };
         if (limit !== undefined) {
             query.limit = limit;
@@ -133,6 +142,9 @@ export function registerAirportTools(server) {
         if (facilityTypes !== undefined) {
             query.types = new Set(facilityTypes);
         }
+        if (minScore !== undefined) {
+            query.minScore = minScore;
+        }
         const results = resolver.search(query);
         return {
             content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],

package/dist/tools/airspace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"airspace.d.ts","sourceRoot":"","sources":["../../src/tools/airspace.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAmFzE;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAmI7D"}
+{"version":3,"file":"airspace.d.ts","sourceRoot":"","sources":["../../src/tools/airspace.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAmFzE;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA0L7D"}

package/dist/tools/airspace.js

@@ -165,4 +165,51 @@ export function registerAirspaceTools(server) {
             structuredContent: { features },
         };
     });
+    server.registerTool('search_airspace', {
+        title: 'Search airspace by name or identifier',
+        description: 'Fuzzy-searches US airspace features across identifier and name. Matching is case-insensitive and tolerant of prefixes, substrings, subsequences, and small typos. Each result carries a match score in [0, 1] (1 is an exact match) and the matched field; results are returned best-match first. Boundary geometry is summarized as a vertex count to keep responses compact.',
+        inputSchema: {
+            text: z
+                .string()
+                .min(1)
+                .describe('Search text, fuzzily matched against airspace identifier and name.'),
+            airspaceTypes: z
+                .array(z.enum(AIRSPACE_TYPE_VALUES))
+                .optional()
+                .describe('Restrict results to these airspace types. Omit to include all types.'),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .optional()
+                .describe('Maximum number of results to return. Defaults to 20.'),
+            minScore: z
+                .number()
+                .min(0)
+                .max(1)
+                .optional()
+                .describe('Minimum match score (exclusive) in [0, 1] a result must reach. Defaults to 0. Raise it to drop weak fuzzy matches.'),
+        },
+    }, ({ text, airspaceTypes, limit, minScore }) => {
+        const query = { text };
+        if (airspaceTypes !== undefined) {
+            query.types = new Set(airspaceTypes);
+        }
+        if (limit !== undefined) {
+            query.limit = limit;
+        }
+        if (minScore !== undefined) {
+            query.minScore = minScore;
+        }
+        const results = airspaceResolver.search(query).map((result) => ({
+            feature: summarizeFeature(result.feature),
+            score: result.score,
+            matchedField: result.matchedField,
+            ranges: result.ranges,
+        }));
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ results }, null, 2) }],
+            structuredContent: { results },
+        };
+    });
 }

package/dist/tools/airways.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"airways.d.ts","sourceRoot":"","sources":["../../src/tools/airways.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAwBzE;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA6G3D"}
+{"version":3,"file":"airways.d.ts","sourceRoot":"","sources":["../../src/tools/airways.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAwBzE;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA2H3D"}

package/dist/tools/airways.js

@@ -84,9 +84,12 @@ export function registerAirwayTools(server) {
     });
     server.registerTool('search_airways', {
         title: 'Search airways by designation',
-        description: 'Searches US airways by case-insensitive substring matching against the airway designation. Results are returned in alphabetical order by designation.',
+        description: 'Fuzzy-searches US airways by designation. Matching is case-insensitive and tolerant of prefixes, substrings, subsequences, and small typos. Each result carries a match score in [0, 1] (1 is an exact match); results are returned best-match first.',
         inputSchema: {
-            text: z.string().min(1).describe('Substring to match against the airway designation.'),
+            text: z
+                .string()
+                .min(1)
+                .describe('Search text, fuzzily matched against the airway designation.'),
             airwayTypes: z
                 .array(z.enum(AIRWAY_TYPE_VALUES))
                 .optional()
@@ -97,8 +100,14 @@ export function registerAirwayTools(server) {
                 .positive()
                 .optional()
                 .describe('Maximum number of results to return. Defaults to 20.'),
+            minScore: z
+                .number()
+                .min(0)
+                .max(1)
+                .optional()
+                .describe('Minimum match score (exclusive) in [0, 1] a result must reach. Defaults to 0. Raise it to drop weak fuzzy matches.'),
         },
-    }, ({ text, airwayTypes, limit }) => {
+    }, ({ text, airwayTypes, limit, minScore }) => {
         const query = { text };
         if (airwayTypes !== undefined) {
             query.types = new Set(airwayTypes);
@@ -106,6 +115,9 @@ export function registerAirwayTools(server) {
         if (limit !== undefined) {
             query.limit = limit;
         }
+        if (minScore !== undefined) {
+            query.minScore = minScore;
+        }
         const airways = airwayResolver.search(query);
         return {
             content: [{ type: 'text', text: JSON.stringify(airways, null, 2) }],

package/dist/tools/fixes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fixes.d.ts","sourceRoot":"","sources":["../../src/tools/fixes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAoBzE;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAsGxD"}
+{"version":3,"file":"fixes.d.ts","sourceRoot":"","sources":["../../src/tools/fixes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAoBzE;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAwJxD"}

package/dist/tools/fixes.js

@@ -36,6 +36,34 @@ export function registerFixTools(server) {
             structuredContent: { fixes },
         };
     });
+    server.registerTool('get_fix_by_ident_at_position', {
+        title: 'Get fix by identifier nearest a position',
+        description: 'Looks up the single US fix/waypoint sharing the given identifier that lies nearest to a geographic position. The same fix identifier can be published in more than one ICAO region; this disambiguates the collision by proximity to a known point such as a map-click location or an adjacent route waypoint. When toleranceNm is provided, matches farther than that distance are excluded and the result is null; when omitted, the nearest match wins regardless of distance. Returns null when no fix carries the identifier.',
+        inputSchema: {
+            ident: z.string().min(1).describe('Fix identifier (case-insensitive).'),
+            lat: z
+                .number()
+                .min(-90)
+                .max(90)
+                .describe('Latitude of the reference position in decimal degrees (WGS84).'),
+            lon: z
+                .number()
+                .min(-180)
+                .max(180)
+                .describe('Longitude of the reference position in decimal degrees (WGS84).'),
+            toleranceNm: z
+                .number()
+                .positive()
+                .optional()
+                .describe('Maximum great-circle distance in nautical miles. Omit to let the nearest match win regardless of distance.'),
+        },
+    }, ({ ident, lat, lon, toleranceNm }) => {
+        const fix = fixResolver.byIdentAtPosition(ident, lat, lon, toleranceNm) ?? null;
+        return {
+            content: [{ type: 'text', text: JSON.stringify(fix, null, 2) }],
+            structuredContent: { fix },
+        };
+    });
     server.registerTool('find_nearest_fixes', {
         title: 'Find nearest fixes',
         description: 'Finds US fixes/waypoints near a geographic position, sorted by great-circle distance in nautical miles.',
@@ -77,9 +105,12 @@ export function registerFixTools(server) {
     });
     server.registerTool('search_fixes', {
         title: 'Search fixes by identifier',
-        description: 'Searches US fixes/waypoints by case-insensitive substring matching against the fix identifier. Results are returned in alphabetical order by identifier.',
+        description: 'Fuzzy-searches US fixes/waypoints by identifier. Matching is case-insensitive and tolerant of prefixes, substrings, subsequences, and small typos. Each result carries a match score in [0, 1] (1 is an exact match); results are returned best-match first.',
         inputSchema: {
-            text: z.string().min(1).describe('Substring to match against the fix identifier.'),
+            text: z
+                .string()
+                .min(1)
+                .describe('Search text, fuzzily matched against the fix identifier.'),
             useCodes: z
                 .array(z.enum(FIX_USE_CODE_VALUES))
                 .optional()
@@ -90,8 +121,14 @@ export function registerFixTools(server) {
                 .positive()
                 .optional()
                 .describe('Maximum number of results to return. Defaults to 20.'),
+            minScore: z
+                .number()
+                .min(0)
+                .max(1)
+                .optional()
+                .describe('Minimum match score (exclusive) in [0, 1] a result must reach. Defaults to 0. Raise it to drop weak fuzzy matches.'),
         },
-    }, ({ text, useCodes, limit }) => {
+    }, ({ text, useCodes, limit, minScore }) => {
         const query = { text };
         if (useCodes !== undefined) {
             query.useCodes = new Set(useCodes);
@@ -99,6 +136,9 @@ export function registerFixTools(server) {
         if (limit !== undefined) {
             query.limit = limit;
         }
+        if (minScore !== undefined) {
+            query.minScore = minScore;
+        }
         const fixes = fixResolver.search(query);
         return {
             content: [{ type: 'text', text: JSON.stringify(fixes, null, 2) }],

package/dist/tools/flightplan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flightplan.d.ts","sourceRoot":"","sources":["../../src/tools/flightplan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAazE;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA4D/D"}
+{"version":3,"file":"flightplan.d.ts","sourceRoot":"","sources":["../../src/tools/flightplan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAmBzE;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAgJ/D"}

package/dist/tools/flightplan.js

@@ -6,7 +6,7 @@
  * package's `resolvers` module.
  */
 import { z } from 'zod';
-import { computeRouteDistance, createFlightplanResolver } from '@squawk/flightplan';
+import { computeRouteDistance, computeRouteTiming, createFlightplanResolver, extractRoutePoints, routeToLineString, } from '@squawk/flightplan';
 import { airportResolver, airwayResolver, fixResolver, navaidResolver, procedureResolver, } from '../resolvers.js';
 /**
  * Registers flight plan parsing and route distance tools on the given MCP
@@ -41,7 +41,7 @@ export function registerFlightplanTools(server) {
     });
     server.registerTool('compute_route_distance', {
         title: 'Compute route distance and ETE',
-        description: 'Parses a flight plan route string and computes the total great-circle distance in nautical miles, the ordered list of legs with cumulative distance, and (when groundSpeedKt is supplied) the estimated time enroute in hours. Uses FAA-published per-segment distances on airway segments when available; otherwise falls back to great-circle computation. Unresolved tokens are surfaced separately so the caller can decide whether to trust the total.',
+        description: 'Parses a flight plan route string and computes the total great-circle distance in nautical miles, the ordered list of legs with cumulative distance, and (when groundSpeedKt is supplied) the estimated time enroute in hours. Each leg carries the from/to point labels and their latitude/longitude in decimal degrees, so the result doubles as a drawable leg-by-leg geometry. Uses FAA-published per-segment distances on airway segments when available; otherwise falls back to great-circle computation. Unresolved tokens are surfaced separately so the caller can decide whether to trust the total. To get the route as a single ordered point sequence or a GeoJSON LineString for map rendering, use get_route_geometry instead.',
         inputSchema: {
             routeString: z
                 .string()
@@ -61,4 +61,70 @@ export function registerFlightplanTools(server) {
             structuredContent: { result },
         };
     });
+    server.registerTool('get_route_geometry', {
+        title: 'Get drawable route geometry',
+        description: 'Parses a flight plan route string and returns its drawable geometry: the ordered sequence of geographic points (each with a label and latitude/longitude in decimal degrees) and a GeoJSON LineString ready to render as a polyline on a map. Airway and SID/STAR segments are expanded into their constituent fixes, and consecutive duplicate points (e.g. an airway entry fix that matches the preceding waypoint) are suppressed. LineString coordinates follow the GeoJSON [lon, lat] ordering. The lineString field is omitted when the route yields fewer than two drawable points, since a LineString requires at least two positions. Use compute_route_distance instead when you need leg distances or estimated time enroute.',
+        inputSchema: {
+            routeString: z
+                .string()
+                .min(1)
+                .describe('Whitespace-separated route string in ICAO Item 15 conventions.'),
+        },
+    }, ({ routeString }) => {
+        const route = resolver.parse(routeString);
+        const points = extractRoutePoints(route);
+        const lineString = routeToLineString(route);
+        const result = { points, lineString };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            structuredContent: result,
+        };
+    });
+    server.registerTool('get_route_timing', {
+        title: 'Compute wind-corrected route timing',
+        description: 'Parses a flight plan route string and computes per-leg, wind-corrected timing. For each leg it solves the wind triangle from the leg true course, the given true airspeed, and a uniform wind, yielding true heading, wind correction angle, and ground speed, then estimated time enroute (and fuel burn when fuelBurnPerHr is given). Supply a uniform wind via the optional wind object (direction the wind blows FROM in degrees true, and speed in knots) applied to every leg; omit it to time the route as calm, where ground speed equals true airspeed. When fuelBurnPerHr and fuelAvailable are both given, the result also reports endurance in hours and whether fuel is sufficient for the total time enroute. A leg whose ground speed is not positive (a pure headwind equal to true airspeed) is left untimed, which makes the route ETE and fuel totals null. Use compute_route_distance for plain distance or a single constant-ground-speed ETE without wind correction.',
+        inputSchema: {
+            routeString: z
+                .string()
+                .min(1)
+                .describe('Whitespace-separated route string in ICAO Item 15 conventions.'),
+            trueAirspeedKt: z
+                .number()
+                .positive()
+                .describe('True airspeed in knots flown on every leg.'),
+            wind: z
+                .object({
+                directionDeg: z
+                    .number()
+                    .min(0)
+                    .max(360)
+                    .describe('Direction the wind blows FROM in degrees true (0-360).'),
+                speedKt: z.number().nonnegative().describe('Wind speed in knots.'),
+            })
+                .optional()
+                .describe('Uniform wind applied to every leg. Omit to time the route as calm (ground speed equals true airspeed).'),
+            fuelBurnPerHr: z
+                .number()
+                .positive()
+                .optional()
+                .describe('Optional fuel burn rate per hour in any consistent unit. When given, per-leg and total fuel are computed.'),
+            fuelAvailable: z
+                .number()
+                .positive()
+                .optional()
+                .describe('Optional fuel on board in the same unit as fuelBurnPerHr. With the burn rate, enables endurance and fuel-sufficiency reporting.'),
+        },
+    }, ({ routeString, trueAirspeedKt, wind, fuelBurnPerHr, fuelAvailable }) => {
+        const route = resolver.parse(routeString);
+        const result = computeRouteTiming(route, {
+            trueAirspeedKt,
+            ...(wind !== undefined ? { windProvider: () => wind } : {}),
+            ...(fuelBurnPerHr !== undefined ? { fuelBurnPerHr } : {}),
+            ...(fuelAvailable !== undefined ? { fuelAvailable } : {}),
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            structuredContent: { result },
+        };
+    });
 }

package/dist/tools/navaids.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"navaids.d.ts","sourceRoot":"","sources":["../../src/tools/navaids.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAsBzE;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA2I3D"}
+{"version":3,"file":"navaids.d.ts","sourceRoot":"","sources":["../../src/tools/navaids.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAsBzE;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA6L3D"}

package/dist/tools/navaids.js

@@ -38,6 +38,34 @@ export function registerNavaidTools(server) {
             structuredContent: { navaids },
         };
     });
+    server.registerTool('get_navaid_by_ident_at_position', {
+        title: 'Get navaid by identifier nearest a position',
+        description: 'Looks up the single US navaid sharing the given identifier that lies nearest to a geographic position. Multiple navaids can publish the same identifier (a co-located NDB and VOR/DME, or two distant stations reusing a code); this disambiguates them by proximity to a known point such as a map-click location or an adjacent route waypoint. When toleranceNm is provided, matches farther than that distance are excluded and the result is null; when omitted, the nearest match wins regardless of distance. Returns null when no navaid carries the identifier.',
+        inputSchema: {
+            ident: z.string().min(1).describe('Navaid identifier (case-insensitive).'),
+            lat: z
+                .number()
+                .min(-90)
+                .max(90)
+                .describe('Latitude of the reference position in decimal degrees (WGS84).'),
+            lon: z
+                .number()
+                .min(-180)
+                .max(180)
+                .describe('Longitude of the reference position in decimal degrees (WGS84).'),
+            toleranceNm: z
+                .number()
+                .positive()
+                .optional()
+                .describe('Maximum great-circle distance in nautical miles. Omit to let the nearest match win regardless of distance.'),
+        },
+    }, ({ ident, lat, lon, toleranceNm }) => {
+        const navaid = navaidResolver.byIdentAtPosition(ident, lat, lon, toleranceNm) ?? null;
+        return {
+            content: [{ type: 'text', text: JSON.stringify(navaid, null, 2) }],
+            structuredContent: { navaid },
+        };
+    });
     server.registerTool('find_navaids_by_frequency', {
         title: 'Find navaids by frequency',
         description: 'Finds US navaids tuned to a given frequency. VOR-family navaids (VOR, VORTAC, VOR/DME, TACAN, DME, VOT) use MHz; NDB-family navaids (NDB, NDB/DME, MARINE_NDB) use kHz. Filter by navaid types when needed to disambiguate the unit.',
@@ -112,9 +140,12 @@ export function registerNavaidTools(server) {
     });
     server.registerTool('search_navaids', {
         title: 'Search navaids by name or identifier',
-        description: 'Searches US navaids using case-insensitive substring matching against the navaid name and identifier. Results are returned in alphabetical order by name.',
+        description: 'Fuzzy-searches US navaids across identifier and name. Matching is case-insensitive and tolerant of prefixes, substrings, subsequences, and small typos. Each result carries a match score in [0, 1] (1 is an exact match) and the matched field; results are returned best-match first.',
         inputSchema: {
-            text: z.string().min(1).describe('Substring to match against navaid name or identifier.'),
+            text: z
+                .string()
+                .min(1)
+                .describe('Search text, fuzzily matched against navaid identifier and name.'),
             navaidTypes: z
                 .array(z.enum(NAVAID_TYPE_VALUES))
                 .optional()
@@ -125,8 +156,14 @@ export function registerNavaidTools(server) {
                 .positive()
                 .optional()
                 .describe('Maximum number of results to return. Defaults to 20.'),
+            minScore: z
+                .number()
+                .min(0)
+                .max(1)
+                .optional()
+                .describe('Minimum match score (exclusive) in [0, 1] a result must reach. Defaults to 0. Raise it to drop weak fuzzy matches.'),
         },
-    }, ({ text, navaidTypes, limit }) => {
+    }, ({ text, navaidTypes, limit, minScore }) => {
         const query = { text };
         if (navaidTypes !== undefined) {
             query.types = new Set(navaidTypes);
@@ -134,6 +171,9 @@ export function registerNavaidTools(server) {
         if (limit !== undefined) {
             query.limit = limit;
         }
+        if (minScore !== undefined) {
+            query.minScore = minScore;
+        }
         const navaids = navaidResolver.search(query);
         return {
             content: [{ type: 'text', text: JSON.stringify(navaids, null, 2) }],

package/dist/tools/procedures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"procedures.d.ts","sourceRoot":"","sources":["../../src/tools/procedures.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAgCzE;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA2M9D"}
+{"version":3,"file":"procedures.d.ts","sourceRoot":"","sources":["../../src/tools/procedures.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAiCzE;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAgQ9D"}

package/dist/tools/procedures.js

@@ -5,6 +5,7 @@
  * `@squawk/procedure-data`.
  */
 import { z } from 'zod';
+import { expansionToLineString, extractLegPoints } from '@squawk/procedures';
 import { procedureResolver } from '../resolvers.js';
 /** All {@link ProcedureType} values, used for input validation. */
 const PROCEDURE_TYPE_VALUES = ['SID', 'STAR', 'IAP'];
@@ -127,7 +128,7 @@ export function registerProcedureTools(server) {
     });
     server.registerTool('expand_procedure', {
         title: 'Expand a procedure into an ordered leg sequence',
-        description: "Expands a procedure at an airport into an ordered leg sequence. Without a transition name, returns the procedure's common route. With a transition name, merges the named transition's legs with the common route in flying order (SID: common then transition for enroute exits, transition then common for runway transitions; STAR: transition then common for enroute entries; IAP: approach transition then final approach segment). Returns null when the airport, procedure, or transition is not found.",
+        description: "Expands a procedure at an airport into an ordered leg sequence. Without a transition name, returns the procedure's common route. With a transition name, merges the named transition's legs with the common route in flying order (SID: common then transition for enroute exits, transition then common for runway transitions; STAR: transition then common for enroute entries; IAP: approach transition then final approach segment). Returns null when the airport, procedure, or transition is not found. To get just the drawable point sequence or a GeoJSON LineString for map rendering, use get_procedure_geometry instead.",
         inputSchema: {
             airportId: z.string().min(1).describe('Airport identifier (case-insensitive).'),
             identifier: z.string().min(1).describe('CIFP procedure identifier (case-insensitive).'),
@@ -155,14 +156,50 @@ export function registerProcedureTools(server) {
             structuredContent: { expansion },
         };
     });
+    server.registerTool('get_procedure_geometry', {
+        title: 'Get drawable procedure geometry',
+        description: 'Expands a procedure at an airport (optionally merging a named transition, exactly like expand_procedure) and returns its drawable geometry: the ordered sequence of fix points (each with a label and latitude/longitude in decimal degrees) and a GeoJSON LineString ready to render as a polyline on a map. Only legs that terminate at a known fix contribute a point; ARINC 424 legs that end at an altitude, DME distance, radial, intercept, or manual event (CA, FA, VA, CD, FD, VD, CR, VR, CI, VI, FM, VM, and the HA/HM holds) carry no coordinate and are skipped, so the line breaks across them and is an approximation rather than a precise flyable track. Consecutive duplicate points are suppressed. LineString coordinates follow the GeoJSON [lon, lat] ordering. The lineString field is omitted when fewer than two fix points are drawable. Returns null when the airport, procedure, or transition is not found. Use expand_procedure instead when you need the full leg fields (constraints, courses, path terminators) rather than just geometry.',
+        inputSchema: {
+            airportId: z
+                .string()
+                .min(1)
+                .describe('Airport identifier (ICAO or FAA, case-insensitive).'),
+            identifier: z.string().min(1).describe('CIFP procedure identifier (case-insensitive).'),
+            transitionName: z
+                .string()
+                .min(1)
+                .optional()
+                .describe('Optional transition name. Omit to use just the common route.'),
+        },
+    }, ({ airportId, identifier, transitionName }) => {
+        const expansion = procedureResolver.expand(airportId, identifier, transitionName);
+        if (expansion === undefined) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Could not expand procedure "${identifier}" at "${airportId}"${transitionName ? ` with transition "${transitionName}"` : ''}.`,
+                    },
+                ],
+                structuredContent: { points: null, lineString: null },
+            };
+        }
+        const points = extractLegPoints(expansion.legs);
+        const lineString = expansionToLineString(expansion.legs);
+        const result = { points, lineString };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            structuredContent: result,
+        };
+    });
     server.registerTool('search_procedures', {
         title: 'Search procedures by name or identifier',
-        description: 'Searches US instrument procedures (SIDs, STARs, IAPs) by case-insensitive substring matching against both the procedure name and identifier. Results are returned sorted by airport and identifier.',
+        description: 'Fuzzy-searches US instrument procedures (SIDs, STARs, IAPs) across identifier and name. Matching is case-insensitive and tolerant of prefixes, substrings, subsequences, and small typos. Each result carries a match score in [0, 1] (1 is an exact match) and the matched field; results are returned best-match first.',
         inputSchema: {
             text: z
                 .string()
                 .min(1)
-                .describe('Substring to match against the procedure name or identifier.'),
+                .describe('Search text, fuzzily matched against the procedure identifier and name.'),
             procedureType: z
                 .enum(PROCEDURE_TYPE_VALUES)
                 .optional()
@@ -177,8 +214,14 @@ export function registerProcedureTools(server) {
                 .positive()
                 .optional()
                 .describe('Maximum number of results to return. Defaults to 20.'),
+            minScore: z
+                .number()
+                .min(0)
+                .max(1)
+                .optional()
+                .describe('Minimum match score (exclusive) in [0, 1] a result must reach. Defaults to 0. Raise it to drop weak fuzzy matches.'),
         },
-    }, ({ text, procedureType, approachType, limit }) => {
+    }, ({ text, procedureType, approachType, limit, minScore }) => {
         const query = { text };
         if (procedureType !== undefined) {
             query.type = procedureType;
@@ -189,6 +232,9 @@ export function registerProcedureTools(server) {
         if (limit !== undefined) {
             query.limit = limit;
         }
+        if (minScore !== undefined) {
+            query.minScore = minScore;
+        }
         const procedures = procedureResolver.search(query);
         return {
             content: [{ type: 'text', text: JSON.stringify(procedures, null, 2) }],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squawk/mcp",
-  "version": "0.9.6",
+  "version": "0.11.0",
   "type": "module",
   "description": "Model Context Protocol server exposing squawk's aviation libraries as tools for LLM clients",
   "author": "Neil Cochran",
@@ -42,24 +42,24 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@squawk/airport-data": "^0.7.3",
-    "@squawk/airports": "^0.6.1",
-    "@squawk/airspace": "^0.8.0",
+    "@squawk/airports": "^0.7.0",
+    "@squawk/airspace": "^0.9.0",
     "@squawk/airspace-data": "^0.5.2",
     "@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/flight-math": "^0.5.3",
-    "@squawk/flightplan": "^0.5.1",
+    "@squawk/flightplan": "^0.6.0",
     "@squawk/geo": "^0.4.3",
     "@squawk/icao-registry": "^0.5.1",
     "@squawk/navaid-data": "^0.6.3",
-    "@squawk/navaids": "^0.4.1",
+    "@squawk/navaids": "^0.6.0",
     "@squawk/notams": "^0.3.5",
     "@squawk/procedure-data": "^0.7.2",
-    "@squawk/procedures": "^0.5.1",
+    "@squawk/procedures": "^0.7.0",
     "@squawk/types": "^0.8.0",
-    "@squawk/weather": "^0.5.5",
+    "@squawk/weather": "^0.6.0",
     "zod": "^4.4.3"
   },
   "peerDependencies": {