@pipeworx/mcp-bts-ontime 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mojibake Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,204 @@
-# Temporary Holding Version
+# @pipeworx/bts-ontime
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+US domestic airline on-time performance and delay causes: monthly on-time %,
+average arrival delay, cancellations, diversions, and delay minutes broken
+down by cause (carrier, weather, air-traffic-control/NAS, security, late
+aircraft) — by route, by carrier, and by arrival airport. Fleet #2953.
+
+Part of [Pipeworx](https://pipeworx.io) — an MCP gateway connecting AI agents to 1779+ live data sources. This is an independent, unofficial integration — not affiliated with, endorsed by, or published by the upstream provider.
+
+## Tools
+
+- `route_ontime(origin, dest, carrier?, months?)` — monthly on-time
+  performance for one origin->destination route, optionally scoped to one
+  carrier. Each month carries flights, completed flights, on-time arrivals
+  and on-time %, average arrival delay, cancellations, diversions, and delay
+  minutes by cause.
+- `carrier_ontime(carrier, airport?, months?)` — the same monthly shape,
+  aggregated across one airline's whole network (or just the flights
+  touching one airport).
+- `bts_airport_delays(airport, year?, month?, limit?, offset?)` —
+  delay-cause breakdown by carrier for flights ARRIVING at one airport,
+  optionally scoped to a year and/or month. `limit` defaults to 50 (max
+  200); a response with more matching rows than returned carries
+  `truncated: true` and `total_matching` rather than silently dropping them.
+- `delay_causes(year, carrier?, airport?, limit?, offset?)` — the same
+  delay-cause rows, organized by year first, for scanning a whole year
+  across carriers or airports. Same `limit`/`truncated`/`total_matching`
+  pagination as `bts_airport_delays`.
+- `list_coverage()` — the earliest/latest month actually loaded, and when.
+  Call this first if you're not sure a given period is covered.
+
+Carrier accepts either the 2-letter reporting-carrier code (`"DL"`) or a
+common airline name (`"Delta"`). Airport codes are validated against what is
+actually loaded (not a static list) — an unrecognized code is refused with a
+clear error, never an empty success.
+
+## Auth
+
+Keyless. The tools answer only through the Pipeworx gateway, which holds the
+data; a standalone `npm install` has no data to read, and every tool throws
+a clear "not bound in this runtime" error there instead of returning an
+empty list.
+
+## Data sources
+
+- US DOT Bureau of Transportation Statistics (BTS), TranStats — "Reporting
+  Carrier On-Time Performance" monthly bulk data. US federal government
+  work: public domain (17 U.S.C. §105). The agency publishes bulk files
+  only (no live query API for this dataset), so this pack builds a copy
+  (`scripts/bts-ontime/load-data.mjs`) rather than proxying — raw
+  flight-level rows (~600k/month) are never stored; the loader aggregates
+  each month down to two small tables and discards the raw file before
+  moving to the next one.
+
+### What `delay_cause` is, and is not
+
+BTS separately publishes its own "Airline Delay Cause" product, which
+apportions each delayed flight's minutes into fractional per-cause *counts*
+via a methodology this pack does not reimplement. The `delay_cause` table
+here is derived from the same underlying per-flight delay-minute fields
+(carrier/weather/NAS/security/late-aircraft) as `route_month`, rolled up by
+carrier x arrival-airport x month, and reported as **minute sums**, not
+fractional counts. It will be consistent with BTS's own published cause
+breakdown but is not guaranteed to match it row-for-row — this is one
+pipeline over one raw source, not a second download of BTS's own aggregate.
+
+### Known gaps — read before extending this pack
+
+**Coverage is the most recent months as of the load, not full history.**
+BTS's bulk-file server throttles hard per connection — one file download
+measured ~170 seconds regardless of a modest concurrency increase helping
+(3 concurrent downloads of this upstream finished in about the same wall
+time as 1 serial one, measured 2026-10-12), so pulling the full 1987-present
+archive (400+ monthly files) in one sitting is a multi-hour job, not a
+pack-build step. This first load covers the most recent 12 months as of
+2026-10-12 (call `list_coverage` for the exact range) for BOTH tables —
+there is no separate 2003-onward backfill for `delay_cause` in this
+commit; it is derived from the same months as `route_month`.
+
+**Extending coverage is mechanical, not research** — see "Refreshing or
+extending the data" below. Re-running the loader with a larger `--months`
+(and a `--concurrency` tuned to be polite to the upstream) pulls further
+back; nothing about the schema or the tools changes.
+
+### Refreshing or extending the data
+
+```bash
+node scripts/bts-ontime/load-data.mjs --months 12                 # default: most recent 12 months
+node scripts/bts-ontime/load-data.mjs --months 36 --concurrency 4 # extend further back
+node scripts/bts-ontime/load-data.mjs --through 2026-7            # pin the "latest" month instead of probing
+```
+
+Needs `wrangler` logged in to the Pipeworx Cloudflare account. Each run
+**replaces** `route_month`, `delay_cause` and `bts_ontime_meta` (DROP +
+reload) rather than appending — BTS's own monthly files are themselves
+revised occasionally, so a clean reload is the only way to be sure stale
+rows from a withdrawn/corrected file don't linger. A monthly refresh (BTS
+publishes with a roughly 2-month lag) should re-run this with a `--months`
+large enough to cover the gap since the last load, not just `12`, or the
+oldest previously-loaded months will quietly drop off the window.
+
+## Quick Start
+
+Add to your MCP client (Claude Desktop, Cursor, Windsurf, etc.):
+
+```json
+{
+  "mcpServers": {
+    "bts-ontime": {
+      "url": "https://gateway.pipeworx.io/bts-ontime/mcp"
+    }
+  }
+}
+```
+
+### What this endpoint actually serves
+
+`tools/list` at `https://gateway.pipeworx.io/bts-ontime/mcp` returns the tools in the table
+above **plus the shared Pipeworx meta-tools** — `ask_pipeworx`,
+`discover_tools`, `search_within`, `remember`/`recall` and the rest of the
+gateway-wide set. So the tool count you see is larger than this table: a
+single-pack endpoint currently lists roughly 30 shared tools alongside the
+pack's own. The connection's `initialize` response states its exact scope, and
+is the authoritative answer for a given day.
+
+This is deliberate, not multiplexing by accident. The meta-tools are what let a
+scoped connection answer a question this pack does not cover — via
+`ask_pipeworx`, which routes across the whole catalog — without you adding a
+second MCP server. There is currently no way to mount a pack endpoint without
+them; if the extra schemas cost you more context than the routing is worth,
+connect to the full gateway once rather than to several pack endpoints.
+
+Or connect to the full Pipeworx gateway to get every pack's tools listed
+directly, instead of just this one's:
+
+```json
+{
+  "mcpServers": {
+    "pipeworx": {
+      "url": "https://gateway.pipeworx.io/mcp"
+    }
+  }
+}
+```
+
+Both URLs reach the same gateway and the same 1779+ data sources. The
+only difference is which pack's tools are listed **directly**; `ask_pipeworx`
+reaches all of them from either one.
+
+## No MCP client? Call it over HTTP
+
+```bash
+curl -X POST https://gateway.pipeworx.io/v1/tools/route_ontime \
+  -H 'Content-Type: application/json' \
+  -d '{"origin":"JFK","dest":"LAX","months":3}'
+```
+
+No account needed for the first calls. Inspect any tool: `GET https://gateway.pipeworx.io/v1/tools/route_ontime`. Find one: `POST https://gateway.pipeworx.io/v1/tools/search_packs` with `{"query":"..."}`.
+
+## Standalone (no gateway account)
+
+This package also runs as a local stdio MCP server — no Pipeworx account, no
+gateway round-trip:
+
+```json
+{
+  "mcpServers": {
+    "bts-ontime": {
+      "command": "npx",
+      "args": ["-y", "@pipeworx/mcp-bts-ontime"]
+    }
+  }
+}
+```
+
+Or run it directly to confirm it starts:
+
+```bash
+npx -y @pipeworx/mcp-bts-ontime
+```
+
+It speaks MCP over stdin/stdout and answers `initialize`/`tools/list`/`tools/call`
+for **only** this pack's tools — none of the shared meta-tools the gateway
+connection above adds. Same source, same tools, no ask_pipeworx routing.
+
+## Using with ask_pipeworx
+
+Instead of calling tools directly, you can ask questions in plain English —
+this works on the pack endpoint above as well as on the full gateway:
+
+```
+ask_pipeworx({ question: "your question about Bts Ontime data" })
+```
+
+The gateway picks the right tool and fills the arguments automatically.
+
+## More
+
+- [Docs and guides](https://pipeworx.io/docs)
+- [pipeworx.io](https://pipeworx.io)
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+//
+// Entry point for `npx @pipeworx/mcp-<slug>`.
+//
+// Packs ship as raw TypeScript (no build step — see publish-pack.sh for why:
+// tsx sidesteps every extensionless-import / bare-JSON-import edge case a
+// per-pack tsc build would have to solve one pack at a time). This file
+// registers tsx's ESM loader programmatically, then hands off to src/server.ts,
+// which wraps the pack's {tools, callTool} export in a stdio MCP server.
+//
+// Copied verbatim into every published pack repo by scripts/publish-pack.sh —
+// edit this file, not a per-pack copy.
+import { register } from 'tsx/esm/api';
+
+register();
+
+await import('../src/server.ts');

package/package.json

@@ -1,6 +1,32 @@
 {
   "name": "@pipeworx/mcp-bts-ontime",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "bts-ontime -- US airline on-time performance and delay causes (fleet #2953).",
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "bin": {
+    "mcp-bts-ontime": "bin/cli.js"
+  },
+  "keywords": ["mcp", "mcp-server", "model-context-protocol", "pipeworx", "bts-ontime"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pipeworx-io/mcp-bts-ontime.git"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "tsx": "^4.19.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "@cloudflare/workers-types": "^4.20260405.1"
+  },
+  "pipeworx": {
+    "sourceHash": "v1-4ccab4bb85e41d533d5ea978010ca37919c66c7500930b64b48559de10ab041c",
+    "sourceCommit": "c1590c25b5e94f477a53686cb61bd09cc196c1ee"
+  }
+}

package/server.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.pipeworx-io/bts-ontime",
+  "title": "Bts Ontime",
+  "description": "bts-ontime -- US airline on-time performance and delay causes (fleet #2953).",
+  "version": "0.1.0",
+  "websiteUrl": "https://pipeworx.io/packs/bts-ontime",
+  "repository": {
+    "url": "https://github.com/pipeworx-io/mcp-bts-ontime",
+    "source": "github"
+  },
+  "remotes": [
+    {
+      "type": "streamable-http",
+      "url": "https://gateway.pipeworx.io/bts-ontime/mcp"
+    }
+  ]
+}

package/src/index.ts

@@ -0,0 +1,362 @@
+interface McpToolDefinition {
+  name: string;
+  description: string;
+  /** Human-facing one-liner (fleet #1967). Optional; consumers fall back to
+   *  description. Kept in step with shared/src/types.ts — scripts/lib/
+   *  check-inlined-types.mjs reports drift at publish time. */
+  summary?: string;
+  inputSchema: {
+    type: 'object';
+    properties: Record<string, unknown>;
+    required?: string[];
+    anyOf?: Array<{ required: string[] }>;
+    oneOf?: Array<{ required: string[] }>;
+    allOf?: Array<{ required: string[] }>;
+  };
+  outputSchema?: Record<string, unknown>;
+}
+
+interface McpToolExport {
+  tools: McpToolDefinition[];
+  callTool: (name: string, args: Record<string, unknown>) => Promise<unknown>;
+  meter?: { credits: number };
+  cost?: Record<string, unknown>;
+  provider?: string;
+}
+
+/**
+ * bts-ontime -- US airline on-time performance and delay causes (fleet #2953).
+ *
+ * Data: US DOT Bureau of Transportation Statistics (BTS) TranStats,
+ * "Reporting Carrier On-Time Performance (1987-present)" monthly bulk CSVs
+ * (transtats.bts.gov/PREZIP). US federal government work -- public domain
+ * (17 U.S.C. §105). The site publishes bulk files only (no live API), so
+ * this pack builds a copy (scripts/bts-ontime/load-data.mjs) into a D1
+ * database the gateway hands it as `_d1` (pack-manifest "d1Binding":
+ * "BTS_ONTIME_DB"). Raw flight-level rows are NEVER stored -- the loader
+ * aggregates each month to two small tables and discards the ~600k-row raw
+ * file before moving to the next month. Design note: this file + store.ts.
+ *
+ * SCOPE: the most recent N months as of the load (see bts_ontime_meta /
+ * list_coverage below) -- not the full 1987-present or 2003-present history,
+ * because BTS throttles per connection hard enough that a multi-decade
+ * backfill is a multi-hour job better run as a scheduled extension than
+ * inline in one build. See README.md "Known gaps" / "Refresh".
+ *
+ * Every response carries `source`, `source_url`, `license` and `data_as_of`
+ * (the latest BTS month actually loaded).
+ */
+import {
+  carrierMonths,
+  clampLimit,
+  clampMonths,
+  delayCauses,
+  delayCausesAtAirport,
+  getMeta,
+  normAirport,
+  requireDb,
+  resolveCarrierCode,
+  routeMonths,
+  SOURCE,
+  validAirport,
+  validCarrier,
+  type D1Like,
+} from './store.js';
+
+const tools: McpToolExport['tools'] = [
+  {
+    name: 'route_ontime',
+    description:
+      'Monthly on-time performance for one US domestic flight route (origin airport -> destination airport), from BTS TranStats Reporting Carrier On-Time Performance. Returns, per month (and per carrier if more than one serves the route): flights, completed flights, on-time arrivals and on-time %, average arrival delay in minutes, cancellations, diversions, and delay minutes broken down by cause (carrier, weather, NAS/air-traffic-control, security, late aircraft). Pass carrier (2-letter code like "DL", or a common name like "Delta") to scope to one airline; omit it to see every carrier that flew the route. months caps how many of the most recently loaded months to return (default 12). Covers the most recent months loaded (see data_as_of and the earliest/latest fields), not full history. Unknown origin/destination airport codes are refused with a clear error, never an empty success.',
+    summary: 'Monthly on-time %, average delay and delay causes for one origin->destination route.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        origin: { type: 'string', description: 'Origin airport code, e.g. "JFK".' },
+        dest: { type: 'string', description: 'Destination airport code, e.g. "LAX".' },
+        carrier: { type: 'string', description: 'Optional: 2-letter carrier code ("DL") or common name ("Delta") to scope to one airline.' },
+        months: { type: 'number', description: 'How many of the most recently loaded months to return, most recent first. Default 12.' },
+      },
+      required: ['origin', 'dest'],
+    },
+  },
+  {
+    name: 'carrier_ontime',
+    description:
+      'Monthly on-time performance for one airline, aggregated across all its routes (or just the routes touching one airport), from BTS TranStats Reporting Carrier On-Time Performance. Pass carrier as a 2-letter code ("WN") or common name ("Southwest"). Pass airport to scope to flights where that airport is the origin or destination. Returns the same per-month shape as route_ontime (flights, on-time %, average arrival delay, cancellations, diversions, delay minutes by cause). months caps how many of the most recently loaded months to return (default 12). Unknown carrier codes are refused with a clear error, never an empty success.',
+    summary: "Monthly on-time %, average delay and delay causes for one airline, system-wide or at one airport.",
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        carrier: { type: 'string', description: '2-letter carrier code ("WN") or common name ("Southwest").' },
+        airport: { type: 'string', description: 'Optional: scope to flights where this airport is the origin or destination.' },
+        months: { type: 'number', description: 'How many of the most recently loaded months to return, most recent first. Default 12.' },
+      },
+      required: ['carrier'],
+    },
+  },
+  {
+    name: 'bts_airport_delays',
+    description:
+      'Delay-cause breakdown at one US airport (as the ARRIVAL airport), by carrier, from BTS TranStats on-time data: arriving flights, how many arrived 15+ minutes late, cancellations, diversions, and delay minutes attributed to carrier, weather, NAS (air-traffic-control/system), security, and late-aircraft causes. Pass year and/or month to scope to a specific period; omit both to get every loaded month, most recent first. Rows beyond `limit` are reported via truncated/total_matching rather than silently dropped -- narrow with year/month or page with limit/offset to see the rest. Unknown airport codes are refused with a clear error, never an empty success.',
+    summary: 'Delay-cause breakdown by carrier for arrivals at one airport.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        airport: { type: 'string', description: 'Airport code, e.g. "ORD".' },
+        year: { type: 'number', description: 'Optional: scope to one calendar year.' },
+        month: { type: 'number', description: 'Optional: scope to one month (1-12). Requires year to be meaningful alongside it, but works alone too (matches that month in any loaded year).' },
+        limit: { type: 'number', description: 'Max rows to return, 1-200. Default 50. A truncated response carries truncated:true and total_matching.' },
+        offset: { type: 'number', description: 'Pagination offset. Default 0.' },
+      },
+      required: ['airport'],
+    },
+  },
+  {
+    name: 'delay_causes',
+    description:
+      'Delay-cause rows for a given year, optionally scoped to one carrier and/or one (arrival) airport, from BTS TranStats on-time data. Same fields as bts_airport_delays (arriving flights, 15+ minute-late arrivals, cancellations, diversions, delay minutes by cause) but organized by year first rather than by airport first -- use this to scan a whole year across carriers/airports, or to compare one carrier\'s delay profile across the airports it serves. Rows beyond `limit` are reported via truncated/total_matching rather than silently dropped -- narrow with carrier/airport or page with limit/offset to see the rest. Unknown carrier or airport codes are refused with a clear error, never an empty success.',
+    summary: 'Year-scoped delay-cause rows, optionally filtered by carrier and/or airport.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        year: { type: 'number', description: 'Calendar year, e.g. 2026.' },
+        carrier: { type: 'string', description: 'Optional: 2-letter carrier code ("AA") or common name ("American").' },
+        airport: { type: 'string', description: 'Optional: arrival-airport code, e.g. "DFW".' },
+        limit: { type: 'number', description: 'Max rows to return, 1-200. Default 50. A truncated response carries truncated:true and total_matching.' },
+        offset: { type: 'number', description: 'Pagination offset. Default 0.' },
+      },
+      required: ['year'],
+    },
+  },
+  {
+    name: 'list_coverage',
+    description:
+      'What this pack actually has loaded right now: the earliest and latest BTS month covered, how many months, and when it was last loaded. Call this before route_ontime/carrier_ontime/bts_airport_delays/delay_causes if you are not sure a given month or year is covered.',
+    summary: 'Earliest/latest BTS month loaded, and when.',
+    inputSchema: { type: 'object' as const, properties: {} },
+  },
+];
+
+function notFoundAirport(code: unknown) {
+  return {
+    found: false,
+    reason: 'unknown_airport',
+    message: `${JSON.stringify(code)} is not a recognized airport code in this pack's loaded data (it may be a valid IATA code that simply had no flights in the loaded window, or a typo). Call list_coverage to see the loaded date range.`,
+  };
+}
+function notFoundCarrier(code: unknown) {
+  return {
+    found: false,
+    reason: 'unknown_carrier',
+    message: `${JSON.stringify(code)} is not a recognized carrier code in this pack's loaded data. Use a 2-letter Reporting Carrier code (e.g. "DL", "WN", "AA") or a common airline name.`,
+  };
+}
+
+async function routeOntimeTool(db: D1Like, args: Record<string, unknown>) {
+  const meta = await getMeta(db);
+  const origin = normAirport(args.origin);
+  const dest = normAirport(args.dest);
+  if (!origin) return { found: false, reason: 'invalid_origin', message: `${JSON.stringify(args.origin)} is not a valid airport code (3-4 letters).`, data_as_of: meta.latest_month };
+  if (!dest) return { found: false, reason: 'invalid_dest', message: `${JSON.stringify(args.dest)} is not a valid airport code (3-4 letters).`, data_as_of: meta.latest_month };
+  if (!(await validAirport(db, origin))) return { ...notFoundAirport(args.origin), data_as_of: meta.latest_month };
+  if (!(await validAirport(db, dest))) return { ...notFoundAirport(args.dest), data_as_of: meta.latest_month };
+
+  let carrierCode: string | null = null;
+  if (args.carrier != null && args.carrier !== '') {
+    carrierCode = resolveCarrierCode(args.carrier);
+    if (!carrierCode || !(await validCarrier(db, carrierCode))) return { ...notFoundCarrier(args.carrier), data_as_of: meta.latest_month };
+  }
+
+  const months = clampMonths(args.months, meta.months_loaded);
+  const rows = await routeMonths(db, origin, dest, carrierCode, months);
+  if (!rows.length) {
+    return {
+      found: false,
+      reason: 'no_flights',
+      origin,
+      dest,
+      carrier: carrierCode,
+      message: `No ${origin}->${dest} flights found in the loaded window (${meta.earliest_month} to ${meta.latest_month})${carrierCode ? ` for carrier ${carrierCode}` : ''}. The airports are valid but this route may not have been flown (or not by that carrier) in that window.`,
+      coverage: { earliest_month: meta.earliest_month, latest_month: meta.latest_month },
+      ...SOURCE,
+      data_as_of: meta.latest_month,
+    };
+  }
+  return {
+    found: true,
+    origin,
+    dest,
+    carrier: carrierCode,
+    returned: rows.length,
+    coverage: { earliest_month: meta.earliest_month, latest_month: meta.latest_month },
+    months: rows,
+    ...SOURCE,
+    data_as_of: meta.latest_month,
+  };
+}
+
+async function carrierOntimeTool(db: D1Like, args: Record<string, unknown>) {
+  const meta = await getMeta(db);
+  const carrierCode = resolveCarrierCode(args.carrier);
+  if (!carrierCode || !(await validCarrier(db, carrierCode))) return { ...notFoundCarrier(args.carrier), data_as_of: meta.latest_month };
+
+  let airport: string | null = null;
+  if (args.airport != null && args.airport !== '') {
+    airport = normAirport(args.airport);
+    if (!airport) return { found: false, reason: 'invalid_airport', message: `${JSON.stringify(args.airport)} is not a valid airport code.`, data_as_of: meta.latest_month };
+    if (!(await validAirport(db, airport))) return { ...notFoundAirport(args.airport), data_as_of: meta.latest_month };
+  }
+
+  const months = clampMonths(args.months, meta.months_loaded);
+  const rows = await carrierMonths(db, carrierCode, airport, months);
+  if (!rows.length) {
+    return {
+      found: false,
+      reason: 'no_flights',
+      carrier: carrierCode,
+      airport,
+      message: `No flights found for carrier ${carrierCode}${airport ? ` at ${airport}` : ''} in the loaded window (${meta.earliest_month} to ${meta.latest_month}).`,
+      coverage: { earliest_month: meta.earliest_month, latest_month: meta.latest_month },
+      ...SOURCE,
+      data_as_of: meta.latest_month,
+    };
+  }
+  return {
+    found: true,
+    carrier: carrierCode,
+    airport,
+    returned: rows.length,
+    coverage: { earliest_month: meta.earliest_month, latest_month: meta.latest_month },
+    months: rows,
+    ...SOURCE,
+    data_as_of: meta.latest_month,
+  };
+}
+
+async function airportDelaysTool(db: D1Like, args: Record<string, unknown>) {
+  const meta = await getMeta(db);
+  const airport = normAirport(args.airport);
+  if (!airport) return { found: false, reason: 'invalid_airport', message: `${JSON.stringify(args.airport)} is not a valid airport code.`, data_as_of: meta.latest_month };
+  if (!(await validAirport(db, airport))) return { ...notFoundAirport(args.airport), data_as_of: meta.latest_month };
+
+  const year = args.year != null && args.year !== '' ? Math.floor(Number(args.year)) : null;
+  if (args.year != null && args.year !== '' && !Number.isFinite(year)) throw new Error('year must be a valid number');
+  const month = args.month != null && args.month !== '' ? Math.floor(Number(args.month)) : null;
+  if (args.month != null && args.month !== '' && (!Number.isFinite(month) || (month as number) < 1 || (month as number) > 12)) {
+    return { found: false, reason: 'invalid_month', message: `month must be 1-12 (got ${JSON.stringify(args.month)}).`, data_as_of: meta.latest_month };
+  }
+
+  const limit = clampLimit(args.limit);
+  const offset = Math.max(0, Math.floor(Number(args.offset) || 0));
+  const { rows, total_matching, truncated } = await delayCausesAtAirport(db, airport, year, month, limit, offset);
+  if (!rows.length) {
+    return {
+      found: false,
+      reason: 'no_data',
+      airport,
+      year,
+      month,
+      message: `No delay-cause rows for ${airport}${year ? ` in ${year}` : ''}${month ? ` month ${month}` : ''} in the loaded window (${meta.earliest_month} to ${meta.latest_month}).`,
+      coverage: { earliest_month: meta.earliest_month, latest_month: meta.latest_month },
+      ...SOURCE,
+      data_as_of: meta.latest_month,
+    };
+  }
+  return {
+    found: true,
+    airport,
+    year,
+    month,
+    returned: rows.length,
+    total_matching,
+    truncated,
+    ...(truncated ? { hint: 'More rows exist than were returned. Narrow with year/month, or page with limit/offset.' } : {}),
+    coverage: { earliest_month: meta.earliest_month, latest_month: meta.latest_month },
+    rows,
+    ...SOURCE,
+    data_as_of: meta.latest_month,
+  };
+}
+
+async function delayCausesTool(db: D1Like, args: Record<string, unknown>) {
+  const meta = await getMeta(db);
+  const year = Math.floor(Number(args.year));
+  if (!Number.isFinite(year)) throw new Error('year must be a valid number');
+
+  let carrierCode: string | null = null;
+  if (args.carrier != null && args.carrier !== '') {
+    carrierCode = resolveCarrierCode(args.carrier);
+    if (!carrierCode || !(await validCarrier(db, carrierCode))) return { ...notFoundCarrier(args.carrier), data_as_of: meta.latest_month };
+  }
+  let airport: string | null = null;
+  if (args.airport != null && args.airport !== '') {
+    airport = normAirport(args.airport);
+    if (!airport) return { found: false, reason: 'invalid_airport', message: `${JSON.stringify(args.airport)} is not a valid airport code.`, data_as_of: meta.latest_month };
+    if (!(await validAirport(db, airport))) return { ...notFoundAirport(args.airport), data_as_of: meta.latest_month };
+  }
+
+  const limit = clampLimit(args.limit);
+  const offset = Math.max(0, Math.floor(Number(args.offset) || 0));
+  const { rows, total_matching, truncated } = await delayCauses(db, carrierCode, airport, year, limit, offset);
+  if (!rows.length) {
+    return {
+      found: false,
+      reason: 'no_data',
+      year,
+      carrier: carrierCode,
+      airport,
+      message: `No delay-cause rows for ${year}${carrierCode ? ` carrier ${carrierCode}` : ''}${airport ? ` airport ${airport}` : ''} in the loaded window (${meta.earliest_month} to ${meta.latest_month}).`,
+      coverage: { earliest_month: meta.earliest_month, latest_month: meta.latest_month },
+      ...SOURCE,
+      data_as_of: meta.latest_month,
+    };
+  }
+  return {
+    found: true,
+    year,
+    carrier: carrierCode,
+    airport,
+    returned: rows.length,
+    total_matching,
+    truncated,
+    ...(truncated ? { hint: 'More rows exist than were returned. Narrow with carrier/airport, or page with limit/offset.' } : {}),
+    coverage: { earliest_month: meta.earliest_month, latest_month: meta.latest_month },
+    rows,
+    ...SOURCE,
+    data_as_of: meta.latest_month,
+  };
+}
+
+async function listCoverageTool(db: D1Like) {
+  const meta = await getMeta(db);
+  return {
+    earliest_month: meta.earliest_month,
+    latest_month: meta.latest_month,
+    months_loaded: meta.months_loaded,
+    loaded_at: meta.loaded_at,
+    note: 'Scoped to the most recent months as of the load, not full BTS history (1987-present). Re-run the loader with a larger --months to extend further back.',
+    ...SOURCE,
+    data_as_of: meta.latest_month,
+  };
+}
+
+async function callTool(name: string, args: Record<string, unknown>): Promise<unknown> {
+  const bound = requireDb(args._d1);
+  switch (name) {
+    case 'route_ontime':
+      return routeOntimeTool(bound, args);
+    case 'carrier_ontime':
+      return carrierOntimeTool(bound, args);
+    case 'bts_airport_delays':
+      return airportDelaysTool(bound, args);
+    case 'delay_causes':
+      return delayCausesTool(bound, args);
+    case 'list_coverage':
+      return listCoverageTool(bound);
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+
+export default { tools, callTool, meter: { credits: 1 } } satisfies McpToolExport;

package/src/server.ts

@@ -0,0 +1,45 @@
+/**
+ * Stdio MCP server entry point for @pipeworx/mcp-bts-ontime.
+ * Generated by scripts/publish-pack.sh — do not hand-edit in the pack repo;
+ * edit scripts/publish-pack.sh (the server.ts heredoc) and republish instead.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import pack from './index.js';
+
+const server = new Server(
+  { name: '@pipeworx/mcp-bts-ontime', version: '0.1.0' },
+  { capabilities: { tools: {} } },
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: pack.tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: t.inputSchema,
+  })),
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    const result = await pack.callTool(name, (args ?? {}) as Record<string, unknown>);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+  } catch (err) {
+    return {
+      content: [{ type: 'text', text: err instanceof Error ? err.message : String(err) }],
+      isError: true,
+    };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  console.error('Fatal error running server:', err);
+  process.exit(1);
+});

package/src/store.ts

@@ -0,0 +1,360 @@
+/**
+ * Reads for bts-ontime (fleet #2953).
+ *
+ * Data: US DOT Bureau of Transportation Statistics (BTS) TranStats,
+ * "Reporting Carrier On-Time Performance (1987-present)" monthly bulk CSVs
+ * (https://transtats.bts.gov/PREZIP/). US federal government work -- public
+ * domain, 17 U.S.C. §105. Loaded into a D1 database the gateway hands this
+ * pack as `_d1` (pack-manifest "d1Binding": "BTS_ONTIME_DB") by
+ * scripts/bts-ontime/load-data.mjs -- never by a deploy.
+ *
+ * Two tables, both derived from the SAME monthly raw file:
+ *   - route_month: carrier x origin x dest x month.
+ *   - delay_cause: carrier x (arrival) airport x month -- delay-minute sums
+ *     by cause, rolled up by arrival airport instead of by route. This is
+ *     NOT the separately-published BTS "Airline Delay Cause" product (which
+ *     apportions delay into fractional per-cause counts); it is the same
+ *     underlying CarrierDelay/WeatherDelay/NASDelay/SecurityDelay/
+ *     LateAircraftDelay minute fields, summed. See README.md.
+ *
+ * SCOPE, found 2026-10-13: loaded the most recent N months as of the run
+ * (see bts_ontime_meta for the exact range) rather than back to 2003 -- BTS's
+ * per-connection throttling (measured: one download ~170s regardless of file
+ * size vs wall time, 3 concurrent downloads of the same upstream in the same
+ * wall time as 1 serial one) makes a multi-decade backfill a multi-hour job
+ * better run as a scheduled extension than inline in one pack-build session.
+ * Re-run the loader with a larger --months to extend further back -- see
+ * README.md "Refresh".
+ */
+
+export interface D1Like {
+  prepare(sql: string): D1StmtLike;
+}
+export interface D1StmtLike {
+  bind(...values: unknown[]): D1StmtLike;
+  all<T = Record<string, unknown>>(): Promise<{ results: T[] }>;
+  first<T = Record<string, unknown>>(): Promise<T | null>;
+}
+
+export class StoreUnavailableError extends Error {
+  constructor() {
+    super(
+      'bts-ontime: the on-time performance store is not bound in this runtime (no _d1). These tools only answer through the Pipeworx gateway; a standalone install has no data to read.',
+    );
+    this.name = 'StoreUnavailableError';
+  }
+}
+export function requireDb(d1: unknown): D1Like {
+  if (!d1 || typeof (d1 as D1Like).prepare !== 'function') throw new StoreUnavailableError();
+  return d1 as D1Like;
+}
+
+export const SOURCE = {
+  source: 'US DOT Bureau of Transportation Statistics (BTS), TranStats "Reporting Carrier On-Time Performance (1987-present)"',
+  source_url: 'https://transtats.bts.gov/PREZIP/',
+  license: 'US federal government work -- public domain (17 U.S.C. §105)',
+};
+
+// ── carrier code resolution ─────────────────────────────────────────────
+// Reporting_Airline in the raw file is already a short code (e.g. "DL",
+// "AA", "WN"); this just lets a caller say a common name instead. Codes NOT
+// in this alias table still work fine as long as they're typed as the code
+// itself -- validity is checked against what the DB actually holds
+// (validCarrier below), not against this list.
+const CARRIER_ALIASES: Record<string, string> = {
+  AA: 'AA', AMERICAN: 'AA', 'AMERICAN AIRLINES': 'AA',
+  DL: 'DL', DELTA: 'DL', 'DELTA AIR LINES': 'DL',
+  UA: 'UA', UNITED: 'UA', 'UNITED AIRLINES': 'UA',
+  WN: 'WN', SOUTHWEST: 'WN', 'SOUTHWEST AIRLINES': 'WN',
+  B6: 'B6', JETBLUE: 'B6', 'JETBLUE AIRWAYS': 'B6',
+  AS: 'AS', ALASKA: 'AS', 'ALASKA AIRLINES': 'AS',
+  NK: 'NK', SPIRIT: 'NK', 'SPIRIT AIRLINES': 'NK',
+  F9: 'F9', FRONTIER: 'F9', 'FRONTIER AIRLINES': 'F9',
+  G4: 'G4', ALLEGIANT: 'G4', 'ALLEGIANT AIR': 'G4',
+  HA: 'HA', HAWAIIAN: 'HA', 'HAWAIIAN AIRLINES': 'HA',
+  OO: 'OO', SKYWEST: 'OO', 'SKYWEST AIRLINES': 'OO',
+  MQ: 'MQ', ENVOY: 'MQ', 'ENVOY AIR': 'MQ',
+  YX: 'YX', REPUBLIC: 'YX', 'REPUBLIC AIRWAYS': 'YX',
+  OH: 'OH', PSA: 'OH', 'PSA AIRLINES': 'OH',
+  '9E': '9E', ENDEAVOR: '9E', 'ENDEAVOR AIR': '9E',
+  YV: 'YV', MESA: 'YV', 'MESA AIRLINES': 'YV',
+  QX: 'QX', HORIZON: 'QX', 'HORIZON AIR': 'QX',
+  ZW: 'ZW', 'AIR WISCONSIN': 'ZW',
+};
+
+/** Normalize caller input to a candidate carrier code -- does NOT guarantee
+ *  the code actually exists in this pack's data; call validCarrier() for that. */
+export function resolveCarrierCode(input: unknown): string | null {
+  if (input == null) return null;
+  const s = String(input).trim().toUpperCase();
+  if (!s) return null;
+  return CARRIER_ALIASES[s] ?? (/^[0-9A-Z]{2}$/.test(s) ? s : null);
+}
+
+export async function validCarrier(db: D1Like, code: string): Promise<boolean> {
+  const r = await db.prepare('SELECT 1 AS x FROM route_month WHERE carrier = ? LIMIT 1').bind(code).first<{ x: number }>();
+  return r != null;
+}
+
+export async function validAirport(db: D1Like, code: string): Promise<boolean> {
+  const r = await db
+    .prepare('SELECT 1 AS x FROM route_month WHERE origin = ? OR dest = ? LIMIT 1')
+    .bind(code, code)
+    .first<{ x: number }>();
+  return r != null;
+}
+
+export function normAirport(input: unknown): string | null {
+  if (input == null) return null;
+  const s = String(input).trim().toUpperCase();
+  return /^[A-Z]{3,4}$/.test(s) ? s : null;
+}
+
+export interface Meta {
+  loaded_at: string;
+  earliest_month: string; // "YYYY-MM"
+  latest_month: string; // "YYYY-MM"
+  months_loaded: number;
+}
+let cachedMeta: Meta | null = null;
+export async function getMeta(db: D1Like): Promise<Meta> {
+  if (cachedMeta) return cachedMeta;
+  const r = await db.prepare('SELECT key, value FROM bts_ontime_meta').all<{ key: string; value: string }>();
+  const m = Object.fromEntries(r.results.map((row) => [row.key, row.value]));
+  cachedMeta = {
+    loaded_at: m.loaded_at ?? '',
+    earliest_month: m.earliest_month ?? '',
+    latest_month: m.latest_month ?? '',
+    months_loaded: Number(m.months_loaded ?? 0),
+  };
+  return cachedMeta;
+}
+
+/** Row-count limit for the delay-cause listing tools: default 50, max 200,
+ *  so a default call stays well under the ~40KB response-size guidance. */
+export function clampLimit(requested: unknown, dflt = 50, max = 200): number {
+  const n = Math.floor(Number(requested));
+  if (!Number.isFinite(n) || n <= 0) return dflt;
+  return Math.min(n, max);
+}
+
+/** How many of the most recent loaded months to look back, clamped to what
+ *  is actually loaded. */
+export function clampMonths(requested: unknown, monthsLoaded: number, dflt = 12): number {
+  const n = Math.floor(Number(requested));
+  if (!Number.isFinite(n) || n <= 0) return Math.min(dflt, monthsLoaded);
+  return Math.min(n, monthsLoaded);
+}
+
+export interface RouteMonthRow {
+  year: number;
+  month: number;
+  carrier: string;
+  origin: string;
+  dest: string;
+  flights: number;
+  completed_flights: number;
+  ontime_arrivals: number;
+  sum_arr_delay: number;
+  cancelled: number;
+  diverted: number;
+  carrier_delay_min: number;
+  weather_delay_min: number;
+  nas_delay_min: number;
+  security_delay_min: number;
+  late_aircraft_delay_min: number;
+}
+
+function shapeRoute(r: RouteMonthRow) {
+  return {
+    year: r.year,
+    month: r.month,
+    carrier: r.carrier,
+    origin: r.origin,
+    dest: r.dest,
+    flights: r.flights,
+    completed_flights: r.completed_flights,
+    cancelled: r.cancelled,
+    diverted: r.diverted,
+    ontime_arrivals: r.ontime_arrivals,
+    ontime_pct: r.completed_flights > 0 ? round2((r.ontime_arrivals / r.completed_flights) * 100) : null,
+    avg_arr_delay_min: r.completed_flights > 0 ? round2(r.sum_arr_delay / r.completed_flights) : null,
+    delay_minutes_by_cause: {
+      carrier: round2(r.carrier_delay_min),
+      weather: round2(r.weather_delay_min),
+      nas: round2(r.nas_delay_min),
+      security: round2(r.security_delay_min),
+      late_aircraft: round2(r.late_aircraft_delay_min),
+    },
+  };
+}
+function round2(n: number): number {
+  return Math.round(n * 100) / 100;
+}
+
+/** Same shape as shapeRoute, but for a carrier-level aggregate that has no
+ *  single origin/dest (it is summed across every route that matched). */
+function shapeCarrierMonth(carrier: string, r: Omit<RouteMonthRow, 'carrier' | 'origin' | 'dest'>) {
+  return {
+    year: r.year,
+    month: r.month,
+    carrier,
+    flights: r.flights,
+    completed_flights: r.completed_flights,
+    cancelled: r.cancelled,
+    diverted: r.diverted,
+    ontime_arrivals: r.ontime_arrivals,
+    ontime_pct: r.completed_flights > 0 ? round2((r.ontime_arrivals / r.completed_flights) * 100) : null,
+    avg_arr_delay_min: r.completed_flights > 0 ? round2(r.sum_arr_delay / r.completed_flights) : null,
+    delay_minutes_by_cause: {
+      carrier: round2(r.carrier_delay_min),
+      weather: round2(r.weather_delay_min),
+      nas: round2(r.nas_delay_min),
+      security: round2(r.security_delay_min),
+      late_aircraft: round2(r.late_aircraft_delay_min),
+    },
+  };
+}
+
+export async function routeMonths(db: D1Like, origin: string, dest: string, carrier: string | null, limitMonths: number) {
+  const where = ['origin = ?', 'dest = ?'];
+  const params: unknown[] = [origin, dest];
+  if (carrier) {
+    where.push('carrier = ?');
+    params.push(carrier);
+  }
+  const sql = `SELECT year, month, carrier, origin, dest, flights, completed_flights, ontime_arrivals, sum_arr_delay, cancelled, diverted, carrier_delay_min, weather_delay_min, nas_delay_min, security_delay_min, late_aircraft_delay_min
+    FROM route_month WHERE ${where.join(' AND ')}
+    ORDER BY year DESC, month DESC, carrier
+    LIMIT ?`;
+  params.push(limitMonths * 20); // generous cap: several carriers per route per month
+  const r = await db.prepare(sql).bind(...params).all<RouteMonthRow>();
+  return r.results.map(shapeRoute);
+}
+
+export async function carrierMonths(db: D1Like, carrier: string, airport: string | null, limitMonths: number) {
+  const where = ['carrier = ?'];
+  const params: unknown[] = [carrier];
+  if (airport) {
+    where.push('(origin = ? OR dest = ?)');
+    params.push(airport, airport);
+  }
+  const sql = `SELECT year, month,
+      SUM(flights) AS flights, SUM(completed_flights) AS completed_flights, SUM(ontime_arrivals) AS ontime_arrivals,
+      SUM(sum_arr_delay) AS sum_arr_delay, SUM(cancelled) AS cancelled, SUM(diverted) AS diverted,
+      SUM(carrier_delay_min) AS carrier_delay_min, SUM(weather_delay_min) AS weather_delay_min,
+      SUM(nas_delay_min) AS nas_delay_min, SUM(security_delay_min) AS security_delay_min, SUM(late_aircraft_delay_min) AS late_aircraft_delay_min
+    FROM route_month WHERE ${where.join(' AND ')}
+    GROUP BY year, month
+    ORDER BY year DESC, month DESC
+    LIMIT ?`;
+  params.push(limitMonths);
+  const r = await db.prepare(sql).bind(...params).all<Omit<RouteMonthRow, 'carrier' | 'origin' | 'dest'>>();
+  return r.results.map((row) => shapeCarrierMonth(carrier, row));
+}
+
+export interface DelayCauseRow {
+  year: number;
+  month: number;
+  carrier: string;
+  airport: string;
+  arr_flights: number;
+  arr_del15: number;
+  arr_cancelled: number;
+  arr_diverted: number;
+  carrier_delay_min: number;
+  weather_delay_min: number;
+  nas_delay_min: number;
+  security_delay_min: number;
+  late_aircraft_delay_min: number;
+}
+function shapeCause(r: DelayCauseRow) {
+  return {
+    year: r.year,
+    month: r.month,
+    carrier: r.carrier,
+    airport: r.airport,
+    arr_flights: r.arr_flights,
+    arr_del15: r.arr_del15,
+    arr_del15_pct: r.arr_flights > 0 ? round2((r.arr_del15 / r.arr_flights) * 100) : null,
+    arr_cancelled: r.arr_cancelled,
+    arr_diverted: r.arr_diverted,
+    delay_minutes_by_cause: {
+      carrier: round2(r.carrier_delay_min),
+      weather: round2(r.weather_delay_min),
+      nas: round2(r.nas_delay_min),
+      security: round2(r.security_delay_min),
+      late_aircraft: round2(r.late_aircraft_delay_min),
+    },
+  };
+}
+
+export interface PagedResult<T> {
+  rows: T[];
+  total_matching: number;
+  truncated: boolean;
+}
+
+export async function delayCausesAtAirport(
+  db: D1Like,
+  airport: string,
+  year: number | null,
+  month: number | null,
+  limit: number,
+  offset: number,
+): Promise<PagedResult<ReturnType<typeof shapeCause>>> {
+  const where = ['airport = ?'];
+  const params: unknown[] = [airport];
+  if (year != null) {
+    where.push('year = ?');
+    params.push(year);
+  }
+  if (month != null) {
+    where.push('month = ?');
+    params.push(month);
+  }
+  const whereSql = where.join(' AND ');
+  const sql = `SELECT year, month, carrier, airport, arr_flights, arr_del15, arr_cancelled, arr_diverted, carrier_delay_min, weather_delay_min, nas_delay_min, security_delay_min, late_aircraft_delay_min
+    FROM delay_cause WHERE ${whereSql}
+    ORDER BY year DESC, month DESC, arr_flights DESC
+    LIMIT ? OFFSET ?`;
+  const countSql = `SELECT COUNT(*) AS n FROM delay_cause WHERE ${whereSql}`;
+  const [r, c] = await Promise.all([
+    db.prepare(sql).bind(...params, limit, offset).all<DelayCauseRow>(),
+    db.prepare(countSql).bind(...params).first<{ n: number }>(),
+  ]);
+  const total = c?.n ?? r.results.length;
+  return { rows: r.results.map(shapeCause), total_matching: total, truncated: offset + r.results.length < total };
+}
+
+export async function delayCauses(
+  db: D1Like,
+  carrier: string | null,
+  airport: string | null,
+  year: number,
+  limit: number,
+  offset: number,
+): Promise<PagedResult<ReturnType<typeof shapeCause>>> {
+  const where = ['year = ?'];
+  const params: unknown[] = [year];
+  if (carrier) {
+    where.push('carrier = ?');
+    params.push(carrier);
+  }
+  if (airport) {
+    where.push('airport = ?');
+    params.push(airport);
+  }
+  const whereSql = where.join(' AND ');
+  const sql = `SELECT year, month, carrier, airport, arr_flights, arr_del15, arr_cancelled, arr_diverted, carrier_delay_min, weather_delay_min, nas_delay_min, security_delay_min, late_aircraft_delay_min
+    FROM delay_cause WHERE ${whereSql}
+    ORDER BY month DESC, arr_flights DESC
+    LIMIT ? OFFSET ?`;
+  const countSql = `SELECT COUNT(*) AS n FROM delay_cause WHERE ${whereSql}`;
+  const [r, c] = await Promise.all([
+    db.prepare(sql).bind(...params, limit, offset).all<DelayCauseRow>(),
+    db.prepare(countSql).bind(...params).first<{ n: number }>(),
+  ]);
+  const total = c?.n ?? r.results.length;
+  return { rows: r.results.map(shapeCause), total_matching: total, truncated: offset + r.results.length < total };
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "types": ["@cloudflare/workers-types"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true
+  },
+  "include": ["src"],
+  "exclude": ["src/server.ts"]
+}