@squawk/mcp 0.2.0

package/dist/tools/flightplan.js

@@ -0,0 +1,64 @@
+/**
+ * @packageDocumentation
+ * MCP tool module wrapping `@squawk/flightplan` route-string parsing and
+ * great-circle distance computation. The flightplan resolver composes the
+ * shared airport, navaid, fix, airway, and procedure resolvers from
+ * {@link ../resolvers.js}.
+ */
+import { computeRouteDistance, createFlightplanResolver } from '@squawk/flightplan';
+import { z } from 'zod';
+import { airportResolver, airwayResolver, fixResolver, navaidResolver, procedureResolver, } from '../resolvers.js';
+/**
+ * Registers flight plan parsing and route distance tools on the given MCP
+ * server. The flightplan resolver is built once at registration time and
+ * shares the bundled NASR data via the resolver singletons.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export function registerFlightplanTools(server) {
+    const resolver = createFlightplanResolver({
+        airports: airportResolver,
+        navaids: navaidResolver,
+        fixes: fixResolver,
+        airways: airwayResolver,
+        procedures: procedureResolver,
+    });
+    server.registerTool('parse_flightplan_route', {
+        title: 'Parse a flight plan route string',
+        description: 'Parses a whitespace-separated flight plan route string (e.g. "KJFK DCT MERIT J60 MARTN DCT KLAX") into structured route elements. Each token is classified as an airport, SID, STAR, airway, direct (DCT), waypoint, lat/lon coordinate, speed/altitude group, or unresolved. Airway tokens are expanded into waypoint sequences between the entry and exit fixes, and SID/STAR tokens are expanded into their first common route.',
+        inputSchema: {
+            routeString: z
+                .string()
+                .min(1)
+                .describe('Whitespace-separated route string in ICAO Item 15 conventions.'),
+        },
+    }, ({ routeString }) => {
+        const route = resolver.parse(routeString);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(route, null, 2) }],
+            structuredContent: { route },
+        };
+    });
+    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.',
+        inputSchema: {
+            routeString: z
+                .string()
+                .min(1)
+                .describe('Whitespace-separated route string in ICAO Item 15 conventions.'),
+            groundSpeedKt: z
+                .number()
+                .positive()
+                .optional()
+                .describe('Optional ground speed in knots used to compute estimated time enroute. Omit to skip ETE.'),
+        },
+    }, ({ routeString, groundSpeedKt }) => {
+        const route = resolver.parse(routeString);
+        const result = computeRouteDistance(route, groundSpeedKt);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            structuredContent: { result },
+        };
+    });
+}

package/dist/tools/geo.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @packageDocumentation
+ * MCP tool module wrapping the great-circle geometry utilities from
+ * `@squawk/geo`. Tools take plain lat/lon inputs and return distances in
+ * nautical miles and bearings in degrees true.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Registers great-circle geometry tools (distance, bearing, midpoint,
+ * destination-point) on the given MCP server.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export declare function registerGeoTools(server: McpServer): void;
+//# sourceMappingURL=geo.d.ts.map

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

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

package/dist/tools/geo.js

@@ -0,0 +1,127 @@
+/**
+ * @packageDocumentation
+ * MCP tool module wrapping the great-circle geometry utilities from
+ * `@squawk/geo`. Tools take plain lat/lon inputs and return distances in
+ * nautical miles and bearings in degrees true.
+ */
+import { greatCircle } from '@squawk/geo';
+import { z } from 'zod';
+/** Reusable zod fragment describing a latitude input. */
+const latFragment = z
+    .number()
+    .min(-90)
+    .max(90)
+    .describe('Latitude in decimal degrees (WGS84, positive north).');
+/** Reusable zod fragment describing a longitude input. */
+const lonFragment = z
+    .number()
+    .min(-180)
+    .max(180)
+    .describe('Longitude in decimal degrees (WGS84, positive east).');
+/**
+ * Registers great-circle geometry tools (distance, bearing, midpoint,
+ * destination-point) on the given MCP server.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export function registerGeoTools(server) {
+    server.registerTool('great_circle_distance', {
+        title: 'Great-circle distance',
+        description: 'Computes the great-circle distance between two geographic positions in nautical miles using the Haversine formula on a spherical Earth.',
+        inputSchema: {
+            lat1: latFragment,
+            lon1: lonFragment,
+            lat2: latFragment,
+            lon2: lonFragment,
+        },
+    }, ({ lat1, lon1, lat2, lon2 }) => {
+        const distanceNm = greatCircle.distanceNm(lat1, lon1, lat2, lon2);
+        return {
+            content: [{ type: 'text', text: `${distanceNm.toFixed(2)} nm` }],
+            structuredContent: { distanceNm },
+        };
+    });
+    server.registerTool('great_circle_bearing', {
+        title: 'Great-circle initial bearing',
+        description: 'Computes the initial great-circle bearing (degrees true, 0-360) from the first position to the second.',
+        inputSchema: {
+            lat1: latFragment,
+            lon1: lonFragment,
+            lat2: latFragment,
+            lon2: lonFragment,
+        },
+    }, ({ lat1, lon1, lat2, lon2 }) => {
+        const bearingDeg = greatCircle.bearing(lat1, lon1, lat2, lon2);
+        return {
+            content: [{ type: 'text', text: `${bearingDeg.toFixed(1)} deg true` }],
+            structuredContent: { bearingDeg },
+        };
+    });
+    server.registerTool('great_circle_bearing_and_distance', {
+        title: 'Great-circle bearing and distance',
+        description: 'Computes the initial great-circle bearing (degrees true, 0-360) and distance (nautical miles) from the first position to the second in one call.',
+        inputSchema: {
+            lat1: latFragment,
+            lon1: lonFragment,
+            lat2: latFragment,
+            lon2: lonFragment,
+        },
+    }, ({ lat1, lon1, lat2, lon2 }) => {
+        const { bearingDeg, distanceNm } = greatCircle.bearingAndDistance(lat1, lon1, lat2, lon2);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `${bearingDeg.toFixed(1)} deg true, ${distanceNm.toFixed(2)} nm`,
+                },
+            ],
+            structuredContent: { bearingDeg, distanceNm },
+        };
+    });
+    server.registerTool('great_circle_midpoint', {
+        title: 'Great-circle midpoint',
+        description: 'Computes the midpoint along the great-circle arc between two geographic positions.',
+        inputSchema: {
+            lat1: latFragment,
+            lon1: lonFragment,
+            lat2: latFragment,
+            lon2: lonFragment,
+        },
+    }, ({ lat1, lon1, lat2, lon2 }) => {
+        const { lat, lon } = greatCircle.midpoint(lat1, lon1, lat2, lon2);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `${lat.toFixed(6)}, ${lon.toFixed(6)}`,
+                },
+            ],
+            structuredContent: { lat, lon },
+        };
+    });
+    server.registerTool('great_circle_destination', {
+        title: 'Great-circle destination point',
+        description: 'Computes the destination point reached by traveling a given distance (nautical miles) along a bearing (degrees true) from a starting position.',
+        inputSchema: {
+            lat: latFragment,
+            lon: lonFragment,
+            bearingDeg: z
+                .number()
+                .describe('Initial bearing in degrees true. Values outside [0, 360) are normalized.'),
+            travelDistanceNm: z
+                .number()
+                .describe('Distance to travel along the bearing in nautical miles. Negative values reverse direction.'),
+        },
+    }, ({ lat, lon, bearingDeg, travelDistanceNm }) => {
+        const destination = greatCircle.destination(lat, lon, bearingDeg, travelDistanceNm);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `${destination.lat.toFixed(6)}, ${destination.lon.toFixed(6)}`,
+                },
+            ],
+            structuredContent: { lat: destination.lat, lon: destination.lon },
+        };
+    });
+}

package/dist/tools/icao-registry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @packageDocumentation
+ * MCP tool module wrapping `@squawk/icao-registry` aircraft registration
+ * lookup, backed by the FAA ReleasableAircraft snapshot in
+ * `@squawk/icao-registry-data`.
+ *
+ * Unlike the other domain modules, the registry data is loaded lazily on the
+ * first tool invocation through {@link getIcaoRegistry}. The bundled data
+ * package decompresses ~40 MB of records on import, which is wasteful for
+ * sessions that never look up an aircraft.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Registers ICAO aircraft registration lookup tools on the given MCP server.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export declare function registerIcaoRegistryTools(server: McpServer): void;
+//# sourceMappingURL=icao-registry.d.ts.map

package/dist/tools/icao-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"icao-registry.d.ts","sourceRoot":"","sources":["../../src/tools/icao-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAOzE;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA6BjE"}

package/dist/tools/icao-registry.js

@@ -0,0 +1,45 @@
+/**
+ * @packageDocumentation
+ * MCP tool module wrapping `@squawk/icao-registry` aircraft registration
+ * lookup, backed by the FAA ReleasableAircraft snapshot in
+ * `@squawk/icao-registry-data`.
+ *
+ * Unlike the other domain modules, the registry data is loaded lazily on the
+ * first tool invocation through {@link getIcaoRegistry}. The bundled data
+ * package decompresses ~40 MB of records on import, which is wasteful for
+ * sessions that never look up an aircraft.
+ */
+import { z } from 'zod';
+import { getIcaoRegistry } from '../resolvers.js';
+/** Pattern matching a valid 24-bit ICAO hex address (1-6 hex digits). */
+const ICAO_HEX_PATTERN = /^[0-9A-Fa-f]{1,6}$/;
+/**
+ * Registers ICAO aircraft registration lookup tools on the given MCP server.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export function registerIcaoRegistryTools(server) {
+    server.registerTool('lookup_aircraft_by_icao_hex', {
+        title: 'Look up an aircraft by ICAO hex address',
+        description: 'Looks up a US-registered aircraft by its 24-bit ICAO hex address (the same identifier transmitted by Mode S and ADS-B). Returns registration, make, model, operator, aircraft type, engine type, and year of manufacture when known. Returns null when no match is found. The first call may take a few hundred milliseconds while the bundled FAA registration snapshot decompresses.',
+        inputSchema: {
+            icaoHex: z
+                .string()
+                .regex(ICAO_HEX_PATTERN, '1-6 hex digits (e.g. "AC82EC", "A4B5F2")')
+                .describe('24-bit ICAO hex address (1-6 hex digits, case-insensitive).'),
+        },
+    }, async ({ icaoHex }) => {
+        const registry = await getIcaoRegistry();
+        const aircraft = registry.lookup(icaoHex);
+        if (aircraft === undefined) {
+            return {
+                content: [{ type: 'text', text: `No aircraft found for ICAO hex "${icaoHex}".` }],
+                structuredContent: { aircraft: null },
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(aircraft, null, 2) }],
+            structuredContent: { aircraft },
+        };
+    });
+}

package/dist/tools/navaids.d.ts

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

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

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

package/dist/tools/navaids.js

@@ -0,0 +1,143 @@
+/**
+ * @packageDocumentation
+ * MCP tool module wrapping `@squawk/navaids` navaid lookup methods, backed
+ * by the US NASR snapshot in `@squawk/navaid-data`.
+ */
+import { z } from 'zod';
+import { navaidResolver } from '../resolvers.js';
+/** All {@link NavaidType} values, used for input validation. */
+const NAVAID_TYPE_VALUES = [
+    'VOR',
+    'VORTAC',
+    'VOR/DME',
+    'TACAN',
+    'DME',
+    'NDB',
+    'NDB/DME',
+    'FAN_MARKER',
+    'MARINE_NDB',
+    'VOT',
+];
+/**
+ * Registers navaid lookup tools on the given MCP server. Uses the shared
+ * {@link navaidResolver} built at module load time.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export function registerNavaidTools(server) {
+    server.registerTool('get_navaid_by_ident', {
+        title: 'Get navaids by identifier',
+        description: 'Looks up US navaids by identifier (e.g. "BOS", "JFK"). Multiple navaids can share the same identifier (for example a co-located NDB and VOR), so the result is always an array. Returns an empty array when no match is found.',
+        inputSchema: {
+            ident: z.string().min(1).describe('Navaid identifier (case-insensitive).'),
+        },
+    }, ({ ident }) => {
+        const navaids = navaidResolver.byIdent(ident);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(navaids, null, 2) }],
+            structuredContent: { navaids },
+        };
+    });
+    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.',
+        inputSchema: {
+            frequency: z
+                .number()
+                .positive()
+                .describe('Frequency value (MHz for VOR-family, kHz for NDB-family).'),
+            navaidTypes: z
+                .array(z.enum(NAVAID_TYPE_VALUES))
+                .optional()
+                .describe('Restrict results to these navaid types. Omit to include all types.'),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .optional()
+                .describe('Maximum number of results to return. Defaults to 20.'),
+        },
+    }, ({ frequency, navaidTypes, limit }) => {
+        const query = { frequency };
+        if (navaidTypes !== undefined) {
+            query.types = new Set(navaidTypes);
+        }
+        if (limit !== undefined) {
+            query.limit = limit;
+        }
+        const navaids = navaidResolver.byFrequency(query);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(navaids, null, 2) }],
+            structuredContent: { navaids },
+        };
+    });
+    server.registerTool('find_nearest_navaids', {
+        title: 'Find nearest navaids',
+        description: 'Finds US navaids near a geographic position, sorted by great-circle distance in nautical miles.',
+        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.'),
+            navaidTypes: z
+                .array(z.enum(NAVAID_TYPE_VALUES))
+                .optional()
+                .describe('Restrict results to these navaid types. Omit to include all types.'),
+        },
+    }, ({ lat, lon, maxDistanceNm, limit, navaidTypes }) => {
+        const query = { lat, lon };
+        if (maxDistanceNm !== undefined) {
+            query.maxDistanceNm = maxDistanceNm;
+        }
+        if (limit !== undefined) {
+            query.limit = limit;
+        }
+        if (navaidTypes !== undefined) {
+            query.types = new Set(navaidTypes);
+        }
+        const results = navaidResolver.nearest(query);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
+            structuredContent: { results },
+        };
+    });
+    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.',
+        inputSchema: {
+            text: z.string().min(1).describe('Substring to match against navaid name or identifier.'),
+            navaidTypes: z
+                .array(z.enum(NAVAID_TYPE_VALUES))
+                .optional()
+                .describe('Restrict results to these navaid types. Omit to include all types.'),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .optional()
+                .describe('Maximum number of results to return. Defaults to 20.'),
+        },
+    }, ({ text, navaidTypes, limit }) => {
+        const query = { text };
+        if (navaidTypes !== undefined) {
+            query.types = new Set(navaidTypes);
+        }
+        if (limit !== undefined) {
+            query.limit = limit;
+        }
+        const navaids = navaidResolver.search(query);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(navaids, null, 2) }],
+            structuredContent: { navaids },
+        };
+    });
+}

package/dist/tools/notams.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @packageDocumentation
+ * MCP tool module wrapping `@squawk/notams` ICAO-format and FAA domestic
+ * NOTAM parsers.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Registers NOTAM parsing tools on the given MCP server.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export declare function registerNotamTools(server: McpServer): void;
+//# sourceMappingURL=notams.d.ts.map

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

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

package/dist/tools/notams.js

@@ -0,0 +1,29 @@
+/**
+ * @packageDocumentation
+ * MCP tool module wrapping `@squawk/notams` ICAO-format and FAA domestic
+ * NOTAM parsers.
+ */
+import { parseFaaNotam, parseNotam } from '@squawk/notams';
+import { z } from 'zod';
+import { runParser } from './tool-helpers.js';
+/**
+ * Registers NOTAM parsing tools on the given MCP server.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export function registerNotamTools(server) {
+    server.registerTool('parse_icao_notam', {
+        title: 'Parse an ICAO-format NOTAM',
+        description: 'Parses a raw ICAO-format NOTAM string into a structured object including the action (NEW/REPLACE/CANCEL), Q-line qualifier (FIR, NOTAM code, traffic, purpose, scope, altitude bounds, coordinates/radius), location codes, effective period, schedule, free-text description, and altitude limits.',
+        inputSchema: {
+            raw: z.string().min(1).describe('Raw ICAO-format NOTAM string.'),
+        },
+    }, ({ raw }) => runParser(raw, parseNotam, 'notam'));
+    server.registerTool('parse_faa_notam', {
+        title: 'Parse an FAA domestic NOTAM',
+        description: 'Parses a raw FAA domestic (legacy) format NOTAM string into a structured object with the location, classification, keyword (RWY/TWY/NAV/AIRSPACE/etc.), text body, and effective period (including PERM/EST/UFN modifiers).',
+        inputSchema: {
+            raw: z.string().min(1).describe('Raw FAA domestic NOTAM string.'),
+        },
+    }, ({ raw }) => runParser(raw, parseFaaNotam, 'notam'));
+}

package/dist/tools/procedures.d.ts

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

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

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

package/dist/tools/procedures.js

@@ -0,0 +1,120 @@
+/**
+ * @packageDocumentation
+ * MCP tool module wrapping `@squawk/procedures` SID/STAR lookup, filtering,
+ * and expansion methods, backed by the US NASR snapshot in
+ * `@squawk/procedure-data`.
+ */
+import { z } from 'zod';
+import { procedureResolver } from '../resolvers.js';
+/** All {@link ProcedureType} values, used for input validation. */
+const PROCEDURE_TYPE_VALUES = ['SID', 'STAR'];
+/**
+ * Registers SID/STAR procedure lookup tools on the given MCP server. Uses
+ * the shared {@link procedureResolver} built at module load time.
+ *
+ * @param server - The MCP server instance to register tools on.
+ */
+export function registerProcedureTools(server) {
+    server.registerTool('get_procedure_by_code', {
+        title: 'Get procedure by FAA computer code',
+        description: 'Looks up a US instrument procedure (SID or STAR) by its FAA computer code (e.g. "AALLE4", "ACCRA5"). Returns null when no match is found.',
+        inputSchema: {
+            computerCode: z
+                .string()
+                .min(1)
+                .describe('FAA computer code for the procedure (case-insensitive).'),
+        },
+    }, ({ computerCode }) => {
+        const procedure = procedureResolver.byName(computerCode);
+        if (procedure === undefined) {
+            return {
+                content: [
+                    { type: 'text', text: `No procedure found with computer code "${computerCode}".` },
+                ],
+                structuredContent: { procedure: null },
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(procedure, null, 2) }],
+            structuredContent: { procedure },
+        };
+    });
+    server.registerTool('find_procedures_by_airport', {
+        title: 'Find procedures associated with an airport',
+        description: 'Finds all US instrument procedures (SIDs and STARs) associated with a given airport identifier (FAA ID). Returns an empty array when no match is found.',
+        inputSchema: {
+            airportId: z.string().min(1).describe('Airport FAA identifier (case-insensitive).'),
+        },
+    }, ({ airportId }) => {
+        const procedures = procedureResolver.byAirport(airportId);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(procedures, null, 2) }],
+            structuredContent: { procedures },
+        };
+    });
+    server.registerTool('expand_procedure', {
+        title: 'Expand a procedure into a waypoint sequence',
+        description: "Expands a procedure into an ordered waypoint sequence. Without a transition, returns the first common route. With a transition name, returns the matching transition's waypoints followed by the first common route's waypoints (with overlapping connecting fixes deduplicated). Returns null when the procedure or transition is not found.",
+        inputSchema: {
+            computerCode: z
+                .string()
+                .min(1)
+                .describe('FAA computer code for the procedure (case-insensitive).'),
+            transitionName: z
+                .string()
+                .min(1)
+                .optional()
+                .describe('Optional transition name (typically the entry/exit fix identifier, case-insensitive). Omit to use the first common route.'),
+        },
+    }, ({ computerCode, transitionName }) => {
+        const expansion = procedureResolver.expand(computerCode, transitionName);
+        if (expansion === undefined) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Could not expand procedure "${computerCode}"${transitionName ? ` with transition "${transitionName}"` : ''}.`,
+                    },
+                ],
+                structuredContent: { expansion: null },
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(expansion, null, 2) }],
+            structuredContent: { expansion },
+        };
+    });
+    server.registerTool('search_procedures', {
+        title: 'Search procedures by name or code',
+        description: 'Searches US instrument procedures by case-insensitive substring matching against both the procedure name and computer code. Results are returned in alphabetical order by computer code.',
+        inputSchema: {
+            text: z
+                .string()
+                .min(1)
+                .describe('Substring to match against the procedure name or computer code.'),
+            procedureType: z
+                .enum(PROCEDURE_TYPE_VALUES)
+                .optional()
+                .describe('Restrict results to SIDs or STARs only. Omit to include both.'),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .optional()
+                .describe('Maximum number of results to return. Defaults to 20.'),
+        },
+    }, ({ text, procedureType, limit }) => {
+        const query = { text };
+        if (procedureType !== undefined) {
+            query.type = procedureType;
+        }
+        if (limit !== undefined) {
+            query.limit = limit;
+        }
+        const procedures = procedureResolver.search(query);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(procedures, null, 2) }],
+            structuredContent: { procedures },
+        };
+    });
+}