@squawk/mcp 0.2.0

package/dist/server.js

@@ -0,0 +1,92 @@
+/**
+ * @packageDocumentation
+ * Server factory for @squawk/mcp. Assembles an {@link McpServer} preloaded
+ * with every squawk aviation tool module.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { registerAirportTools } from './tools/airports.js';
+import { registerAirspaceTools } from './tools/airspace.js';
+import { registerAirwayTools } from './tools/airways.js';
+import { registerDatasetTools } from './tools/datasets.js';
+import { registerFixTools } from './tools/fixes.js';
+import { registerFlightMathTools } from './tools/flight-math.js';
+import { registerFlightplanTools } from './tools/flightplan.js';
+import { registerGeoTools } from './tools/geo.js';
+import { registerIcaoRegistryTools } from './tools/icao-registry.js';
+import { registerNavaidTools } from './tools/navaids.js';
+import { registerNotamTools } from './tools/notams.js';
+import { registerProcedureTools } from './tools/procedures.js';
+import { registerWeatherTools } from './tools/weather.js';
+const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '../package.json');
+const packageMeta = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+/**
+ * Ordered list of tool-module registrars invoked during server construction.
+ * Holding them in a single array keeps {@link createSquawkMcpServer} symmetric
+ * across modules and lets {@link TOOL_MODULE_COUNT} stay accurate without
+ * manual bookkeeping.
+ */
+const TOOL_MODULE_REGISTRARS = [
+    registerGeoTools,
+    registerFlightMathTools,
+    registerAirportTools,
+    registerAirspaceTools,
+    registerNavaidTools,
+    registerFixTools,
+    registerAirwayTools,
+    registerProcedureTools,
+    registerIcaoRegistryTools,
+    registerWeatherTools,
+    registerNotamTools,
+    registerFlightplanTools,
+    registerDatasetTools,
+];
+/**
+ * Number of tool modules registered by {@link createSquawkMcpServer}. Exposed
+ * so the stdio entrypoint can include the count in its startup diagnostic
+ * without re-counting at runtime.
+ */
+export const TOOL_MODULE_COUNT = TOOL_MODULE_REGISTRARS.length;
+/**
+ * Package name as published to npm. Convenient for diagnostic logs that want
+ * to identify the running server without re-reading `package.json`.
+ */
+export const PACKAGE_NAME = packageMeta.name;
+/**
+ * Package version pulled from `package.json` at module load. Mirrored as the
+ * server's `version` field and reused by the stdio entrypoint diagnostic.
+ */
+export const PACKAGE_VERSION = packageMeta.version;
+/**
+ * Creates an MCP server preloaded with every squawk aviation tool module.
+ *
+ * Tool registration triggers eager construction of the shared resolver
+ * singletons in `./resolvers.js` for every domain except the ICAO aircraft
+ * registry, which loads on first lookup. Live weather fetch tools issue
+ * outbound HTTPS requests to the Aviation Weather Center text API only when
+ * invoked.
+ *
+ * ```typescript
+ * import { createSquawkMcpServer } from '@squawk/mcp';
+ * import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+ *
+ * const server = createSquawkMcpServer();
+ * await server.connect(new StdioServerTransport());
+ * ```
+ *
+ * @returns A fully configured MCP server instance. Connect it to a transport
+ *          (typically `StdioServerTransport` for CLI use) via
+ *          `server.connect(transport)` to begin handling protocol messages.
+ */
+export function createSquawkMcpServer() {
+    const server = new McpServer({
+        name: PACKAGE_NAME,
+        version: PACKAGE_VERSION,
+    });
+    for (const register of TOOL_MODULE_REGISTRARS) {
+        register(server);
+    }
+    return server;
+}

package/dist/tools/airports.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @packageDocumentation
+ * MCP tool module wrapping `@squawk/airports` airport lookup methods, backed
+ * by the US NASR snapshot in `@squawk/airport-data`. The dataset is loaded
+ * and indexed eagerly when the shared {@link airportResolver} is imported.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Registers airport lookup tools (by FAA ID, by ICAO code, nearest, text
+ * search) on the given MCP server. Tools share the {@link airportResolver}
+ * singleton built at module load time from the bundled US NASR dataset.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export declare function registerAirportTools(server: McpServer): void;
+//# sourceMappingURL=airports.d.ts.map

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

@@ -0,0 +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;AAgBzE;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA6I5D"}

package/dist/tools/airports.js

@@ -0,0 +1,142 @@
+/**
+ * @packageDocumentation
+ * MCP tool module wrapping `@squawk/airports` airport lookup methods, backed
+ * by the US NASR snapshot in `@squawk/airport-data`. The dataset is loaded
+ * and indexed eagerly when the shared {@link airportResolver} is imported.
+ */
+import { z } from 'zod';
+import { airportResolver } from '../resolvers.js';
+/** All {@link FacilityType} values, used for input validation. */
+const FACILITY_TYPE_VALUES = [
+    'AIRPORT',
+    'HELIPORT',
+    'SEAPLANE_BASE',
+    'GLIDERPORT',
+    'ULTRALIGHT',
+    'BALLOONPORT',
+];
+/**
+ * Registers airport lookup tools (by FAA ID, by ICAO code, nearest, text
+ * search) on the given MCP server. Tools share the {@link airportResolver}
+ * singleton built at module load time from the bundled US NASR dataset.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export function registerAirportTools(server) {
+    const resolver = airportResolver;
+    server.registerTool('get_airport_by_faa_id', {
+        title: 'Get airport by FAA identifier',
+        description: 'Looks up a US airport by its FAA location identifier (e.g. "JFK", "LAX", "3N6"). Returns the full airport record including runways, frequencies, and ILS data, or null if no match is found.',
+        inputSchema: {
+            faaId: z.string().min(1).describe('FAA location identifier (case-insensitive).'),
+        },
+    }, ({ faaId }) => {
+        const airport = resolver.byFaaId(faaId);
+        if (airport === undefined) {
+            return {
+                content: [{ type: 'text', text: `No airport found with FAA ID "${faaId}".` }],
+                structuredContent: { airport: null },
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(airport, null, 2) }],
+            structuredContent: { airport },
+        };
+    });
+    server.registerTool('get_airport_by_icao', {
+        title: 'Get airport by ICAO code',
+        description: 'Looks up a US airport by its ICAO code (e.g. "KJFK", "KLAX"). Returns the full airport record including runways, frequencies, and ILS data, or null if no match is found.',
+        inputSchema: {
+            icao: z.string().min(1).describe('ICAO airport code (case-insensitive).'),
+        },
+    }, ({ icao }) => {
+        const airport = resolver.byIcao(icao);
+        if (airport === undefined) {
+            return {
+                content: [{ type: 'text', text: `No airport found with ICAO code "${icao}".` }],
+                structuredContent: { airport: null },
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(airport, null, 2) }],
+            structuredContent: { airport },
+        };
+    });
+    server.registerTool('find_nearest_airports', {
+        title: 'Find nearest airports',
+        description: 'Finds US airports near a geographic position, sorted by great-circle distance in nautical miles. Supports filtering by facility type and minimum runway length.',
+        inputSchema: {
+            lat: z.number().min(-90).max(90).describe('Latitude in decimal degrees (WGS84).'),
+            lon: z.number().min(-180).max(180).describe('Longitude in decimal degrees (WGS84).'),
+            maxDistanceNm: z
+                .number()
+                .positive()
+                .optional()
+                .describe('Maximum search radius in nautical miles. Defaults to 30.'),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .optional()
+                .describe('Maximum number of results to return. Defaults to 10.'),
+            facilityTypes: z
+                .array(z.enum(FACILITY_TYPE_VALUES))
+                .optional()
+                .describe('Restrict results to these facility types. Omit to include all types.'),
+            minRunwayLengthFt: z
+                .number()
+                .positive()
+                .optional()
+                .describe('Only include airports with at least one runway meeting this length in feet.'),
+        },
+    }, ({ lat, lon, maxDistanceNm, limit, facilityTypes, minRunwayLengthFt }) => {
+        const query = { lat, lon };
+        if (maxDistanceNm !== undefined) {
+            query.maxDistanceNm = maxDistanceNm;
+        }
+        if (limit !== undefined) {
+            query.limit = limit;
+        }
+        if (facilityTypes !== undefined) {
+            query.types = new Set(facilityTypes);
+        }
+        if (minRunwayLengthFt !== undefined) {
+            query.minRunwayLengthFt = minRunwayLengthFt;
+        }
+        const results = resolver.nearest(query);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
+            structuredContent: { results },
+        };
+    });
+    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.',
+        inputSchema: {
+            text: z.string().min(1).describe('Substring to match against airport name or city.'),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .optional()
+                .describe('Maximum number of results to return. Defaults to 20.'),
+            facilityTypes: z
+                .array(z.enum(FACILITY_TYPE_VALUES))
+                .optional()
+                .describe('Restrict results to these facility types. Omit to include all types.'),
+        },
+    }, ({ text, limit, facilityTypes }) => {
+        const query = { text };
+        if (limit !== undefined) {
+            query.limit = limit;
+        }
+        if (facilityTypes !== undefined) {
+            query.types = new Set(facilityTypes);
+        }
+        const results = resolver.search(query);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
+            structuredContent: { results },
+        };
+    });
+}

package/dist/tools/airspace.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @packageDocumentation
+ * MCP tool module wrapping `@squawk/airspace` point-in-airspace queries,
+ * backed by the US NASR airspace GeoJSON snapshot in `@squawk/airspace-data`.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Registers airspace query tools on the given MCP server. The bundled US
+ * airspace GeoJSON snapshot is decoded and indexed eagerly via the shared
+ * {@link airspaceResolver}.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export declare function registerAirspaceTools(server: McpServer): void;
+//# sourceMappingURL=airspace.d.ts.map

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

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

package/dist/tools/airspace.js

@@ -0,0 +1,81 @@
+/**
+ * @packageDocumentation
+ * MCP tool module wrapping `@squawk/airspace` point-in-airspace queries,
+ * backed by the US NASR airspace GeoJSON snapshot in `@squawk/airspace-data`.
+ */
+import { z } from 'zod';
+import { airspaceResolver } from '../resolvers.js';
+/** All {@link AirspaceType} values, used for input validation. */
+const AIRSPACE_TYPE_VALUES = [
+    'CLASS_B',
+    'CLASS_C',
+    'CLASS_D',
+    'CLASS_E2',
+    'CLASS_E3',
+    'CLASS_E4',
+    'CLASS_E5',
+    'CLASS_E6',
+    'CLASS_E7',
+    'MOA',
+    'RESTRICTED',
+    'PROHIBITED',
+    'WARNING',
+    'ALERT',
+    'NSA',
+];
+/**
+ * Strips the polygon boundary from a feature for tool output. The boundary
+ * coordinates are dropped because a single Class B feature can carry hundreds
+ * of vertices, and the MCP client almost always wants the descriptive metadata
+ * (type, identifier, vertical bounds, controlling facility) rather than the
+ * raw geometry. The structured-content schema preserves a `vertexCount` so
+ * callers can tell how detailed the original boundary was.
+ */
+function summarizeFeature(feature) {
+    const ring = feature.boundary.coordinates[0] ?? [];
+    return {
+        type: feature.type,
+        name: feature.name,
+        identifier: feature.identifier,
+        floor: feature.floor,
+        ceiling: feature.ceiling,
+        state: feature.state,
+        controllingFacility: feature.controllingFacility,
+        scheduleDescription: feature.scheduleDescription,
+        vertexCount: ring.length,
+    };
+}
+/**
+ * Registers airspace query tools on the given MCP server. The bundled US
+ * airspace GeoJSON snapshot is decoded and indexed eagerly via the shared
+ * {@link airspaceResolver}.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export function registerAirspaceTools(server) {
+    server.registerTool('query_airspace_at_position', {
+        title: 'Query airspace at a position and altitude',
+        description: 'Returns every US airspace feature whose lateral polygon contains the given position and whose vertical bounds contain the given altitude (feet MSL). Covers Class B/C/D/E controlled airspace and Special Use Airspace (MOA, restricted, prohibited, warning, alert, NSA). The boundary polygon is summarized as a vertex count to keep responses compact - call this tool with multiple altitudes to walk a vertical profile.',
+        inputSchema: {
+            lat: z.number().min(-90).max(90).describe('Latitude in decimal degrees (WGS84).'),
+            lon: z.number().min(-180).max(180).describe('Longitude in decimal degrees (WGS84).'),
+            altitudeFt: z
+                .number()
+                .describe('Altitude in feet MSL to compare against airspace vertical bounds.'),
+            airspaceTypes: z
+                .array(z.enum(AIRSPACE_TYPE_VALUES))
+                .optional()
+                .describe('Restrict results to these airspace types. Omit to include all types.'),
+        },
+    }, ({ lat, lon, altitudeFt, airspaceTypes }) => {
+        const query = { lat, lon, altitudeFt };
+        if (airspaceTypes !== undefined) {
+            query.types = new Set(airspaceTypes);
+        }
+        const features = airspaceResolver(query).map(summarizeFeature);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(features, null, 2) }],
+            structuredContent: { features },
+        };
+    });
+}

package/dist/tools/airways.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @packageDocumentation
+ * MCP tool module wrapping `@squawk/airways` airway lookup, traversal, and
+ * expansion methods, backed by the US NASR snapshot in `@squawk/airway-data`.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Registers airway lookup tools on the given MCP server. Uses the shared
+ * {@link airwayResolver} built at module load time.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export declare function registerAirwayTools(server: McpServer): void;
+//# sourceMappingURL=airways.d.ts.map

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

@@ -0,0 +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;AAsBzE;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA6G3D"}

package/dist/tools/airways.js

@@ -0,0 +1,115 @@
+/**
+ * @packageDocumentation
+ * MCP tool module wrapping `@squawk/airways` airway lookup, traversal, and
+ * expansion methods, backed by the US NASR snapshot in `@squawk/airway-data`.
+ */
+import { z } from 'zod';
+import { airwayResolver } from '../resolvers.js';
+/** All {@link AirwayType} values, used for input validation. */
+const AIRWAY_TYPE_VALUES = [
+    'VICTOR',
+    'JET',
+    'RNAV_Q',
+    'RNAV_T',
+    'GREEN',
+    'RED',
+    'AMBER',
+    'BLUE',
+    'ATLANTIC',
+    'BAHAMA',
+    'PACIFIC',
+    'PUERTO_RICO',
+];
+/**
+ * Registers airway lookup tools on the given MCP server. Uses the shared
+ * {@link airwayResolver} built at module load time.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export function registerAirwayTools(server) {
+    server.registerTool('get_airway_by_designation', {
+        title: 'Get airways by designation',
+        description: 'Looks up US airways by designation (e.g. "V16", "J60", "Q1"). Multiple airways can share the same designation across regions (for example V16 exists in both the contiguous US and Hawaii), so the result is always an array. Returns an empty array when no match is found.',
+        inputSchema: {
+            designation: z.string().min(1).describe('Airway designation (case-insensitive).'),
+        },
+    }, ({ designation }) => {
+        const airways = airwayResolver.byDesignation(designation);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(airways, null, 2) }],
+            structuredContent: { airways },
+        };
+    });
+    server.registerTool('expand_airway_segment', {
+        title: 'Expand an airway between two fixes',
+        description: 'Expands an airway between two fixes, returning the ordered sequence of waypoints from the entry fix to the exit fix (inclusive). Airways can be traversed in either direction. Returns null if the entry/exit fixes are not found on the airway.',
+        inputSchema: {
+            designation: z.string().min(1).describe('Airway designation (case-insensitive).'),
+            entryFix: z.string().min(1).describe('Identifier of the entry fix (case-insensitive).'),
+            exitFix: z.string().min(1).describe('Identifier of the exit fix (case-insensitive).'),
+        },
+    }, ({ designation, entryFix, exitFix }) => {
+        const expansion = airwayResolver.expand(designation, entryFix, exitFix);
+        if (expansion === undefined) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Could not expand airway "${designation}" from "${entryFix}" to "${exitFix}".`,
+                    },
+                ],
+                structuredContent: { expansion: null },
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(expansion, null, 2) }],
+            structuredContent: { expansion },
+        };
+    });
+    server.registerTool('find_airways_by_fix', {
+        title: 'Find airways through a fix',
+        description: 'Finds all US airways that pass through a given fix, navaid, or waypoint identifier. Each result includes the airway record and the waypoint index where the identifier appears in the airway sequence.',
+        inputSchema: {
+            ident: z
+                .string()
+                .min(1)
+                .describe('Fix, navaid, or waypoint identifier (case-insensitive).'),
+        },
+    }, ({ ident }) => {
+        const results = airwayResolver.byFix(ident);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
+            structuredContent: { results },
+        };
+    });
+    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.',
+        inputSchema: {
+            text: z.string().min(1).describe('Substring to match against the airway designation.'),
+            airwayTypes: z
+                .array(z.enum(AIRWAY_TYPE_VALUES))
+                .optional()
+                .describe('Restrict results to these airway types. Omit to include all types.'),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .optional()
+                .describe('Maximum number of results to return. Defaults to 20.'),
+        },
+    }, ({ text, airwayTypes, limit }) => {
+        const query = { text };
+        if (airwayTypes !== undefined) {
+            query.types = new Set(airwayTypes);
+        }
+        if (limit !== undefined) {
+            query.limit = limit;
+        }
+        const airways = airwayResolver.search(query);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(airways, null, 2) }],
+            structuredContent: { airways },
+        };
+    });
+}

package/dist/tools/datasets.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @packageDocumentation
+ * MCP tool module exposing build provenance and record counts for every
+ * bundled FAA snapshot the server loads. Lets an LLM client report exactly
+ * which NASR cycle and registry vintage answered a query - critical context
+ * for aviation use, where stale data is a real safety concern.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Registers the `get_dataset_status` tool on the given MCP server. The tool
+ * takes no input and reports the NASR cycle date, generation timestamp, and
+ * record counts for each loaded snapshot. The lazily-loaded ICAO registry
+ * reports its load state without being initialized as a side effect.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export declare function registerDatasetTools(server: McpServer): void;
+//# sourceMappingURL=datasets.d.ts.map

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

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

package/dist/tools/datasets.js

@@ -0,0 +1,78 @@
+/**
+ * @packageDocumentation
+ * MCP tool module exposing build provenance and record counts for every
+ * bundled FAA snapshot the server loads. Lets an LLM client report exactly
+ * which NASR cycle and registry vintage answered a query - critical context
+ * for aviation use, where stale data is a real safety concern.
+ */
+import { usBundledAirports } from '@squawk/airport-data';
+import { usBundledAirspace } from '@squawk/airspace-data';
+import { usBundledAirways } from '@squawk/airway-data';
+import { usBundledFixes } from '@squawk/fix-data';
+import { usBundledNavaids } from '@squawk/navaid-data';
+import { usBundledProcedures } from '@squawk/procedure-data';
+import { getIcaoRegistryMetadata, isIcaoRegistryLoaded } from '../resolvers.js';
+/**
+ * Registers the `get_dataset_status` tool on the given MCP server. The tool
+ * takes no input and reports the NASR cycle date, generation timestamp, and
+ * record counts for each loaded snapshot. The lazily-loaded ICAO registry
+ * reports its load state without being initialized as a side effect.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export function registerDatasetTools(server) {
+    server.registerTool('get_dataset_status', {
+        title: 'Report status of every bundled dataset',
+        description: 'Returns the FAA NASR cycle effective date, build timestamp, and record counts for each dataset the server loads (airports, airspace, navaids, fixes, airways, procedures, ICAO aircraft registry). Use this when a user asks "how current is the data?" or before answering a question that depends on procedure/navaid currency. The aircraft registry is lazily loaded and reports its load state without forcing initialization.',
+        inputSchema: {},
+    }, () => {
+        const registryMetadata = getIcaoRegistryMetadata();
+        const datasets = {
+            airports: {
+                nasrCycleDate: usBundledAirports.properties.nasrCycleDate,
+                generatedAt: usBundledAirports.properties.generatedAt,
+                recordCount: usBundledAirports.properties.recordCount,
+            },
+            airspace: {
+                nasrCycleDate: usBundledAirspace.properties.nasrCycleDate,
+                generatedAt: usBundledAirspace.properties.generatedAt,
+                featureCount: usBundledAirspace.properties.featureCount,
+            },
+            navaids: {
+                nasrCycleDate: usBundledNavaids.properties.nasrCycleDate,
+                generatedAt: usBundledNavaids.properties.generatedAt,
+                recordCount: usBundledNavaids.properties.recordCount,
+            },
+            fixes: {
+                nasrCycleDate: usBundledFixes.properties.nasrCycleDate,
+                generatedAt: usBundledFixes.properties.generatedAt,
+                recordCount: usBundledFixes.properties.recordCount,
+            },
+            airways: {
+                nasrCycleDate: usBundledAirways.properties.nasrCycleDate,
+                generatedAt: usBundledAirways.properties.generatedAt,
+                recordCount: usBundledAirways.properties.recordCount,
+                waypointCount: usBundledAirways.properties.waypointCount,
+            },
+            procedures: {
+                nasrCycleDate: usBundledProcedures.properties.nasrCycleDate,
+                generatedAt: usBundledProcedures.properties.generatedAt,
+                recordCount: usBundledProcedures.properties.recordCount,
+                sidCount: usBundledProcedures.properties.sidCount,
+                starCount: usBundledProcedures.properties.starCount,
+                waypointCount: usBundledProcedures.properties.waypointCount,
+            },
+            icaoRegistry: registryMetadata !== undefined
+                ? {
+                    loaded: true,
+                    generatedAt: registryMetadata.generatedAt,
+                    recordCount: registryMetadata.recordCount,
+                }
+                : { loaded: isIcaoRegistryLoaded() },
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(datasets, null, 2) }],
+            structuredContent: { datasets },
+        };
+    });
+}

package/dist/tools/fixes.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @packageDocumentation
+ * MCP tool module wrapping `@squawk/fixes` fix/waypoint lookup methods,
+ * backed by the US NASR snapshot in `@squawk/fix-data`.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Registers fix/waypoint lookup tools on the given MCP server. Uses the
+ * shared {@link fixResolver} built at module load time.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export declare function registerFixTools(server: McpServer): void;
+//# sourceMappingURL=fixes.d.ts.map

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

@@ -0,0 +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;AAkBzE;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAsGxD"}