@mostlyrightmd/core 0.1.0-rc.7

package/dist/discovery/index.mjs

@@ -0,0 +1,1609 @@
+// src/data/generated/stations.ts
+var STATIONS = [
+  {
+    code: "EDDB",
+    country: "DE",
+    ghcnh_id: null,
+    icao: "EDDB",
+    latitude: 52.3667,
+    longitude: 13.5033,
+    name: "Berlin Brandenburg",
+    tz: "Europe/Berlin"
+  },
+  {
+    code: "EDDF",
+    country: "DE",
+    ghcnh_id: null,
+    icao: "EDDF",
+    latitude: 50.0379,
+    longitude: 8.5622,
+    name: "Frankfurt am Main",
+    tz: "Europe/Berlin"
+  },
+  {
+    code: "EDDM",
+    country: "DE",
+    ghcnh_id: null,
+    icao: "EDDM",
+    latitude: 48.3538,
+    longitude: 11.7861,
+    name: "Munich Franz Josef Strauss",
+    tz: "Europe/Berlin"
+  },
+  {
+    code: "EFHK",
+    country: "FI",
+    ghcnh_id: null,
+    icao: "EFHK",
+    latitude: 60.3172,
+    longitude: 24.9633,
+    name: "Helsinki-Vantaa",
+    tz: "Europe/Helsinki"
+  },
+  {
+    code: "EGKK",
+    country: "GB",
+    ghcnh_id: null,
+    icao: "EGKK",
+    latitude: 51.1481,
+    longitude: -0.1903,
+    name: "London Gatwick",
+    tz: "Europe/London"
+  },
+  {
+    code: "EGLL",
+    country: "GB",
+    ghcnh_id: null,
+    icao: "EGLL",
+    latitude: 51.4706,
+    longitude: -0.4619,
+    name: "London Heathrow",
+    tz: "Europe/London"
+  },
+  {
+    code: "EHAM",
+    country: "NL",
+    ghcnh_id: null,
+    icao: "EHAM",
+    latitude: 52.3086,
+    longitude: 4.7639,
+    name: "Amsterdam Schiphol",
+    tz: "Europe/Amsterdam"
+  },
+  {
+    code: "EKCH",
+    country: "DK",
+    ghcnh_id: null,
+    icao: "EKCH",
+    latitude: 55.6181,
+    longitude: 12.6561,
+    name: "Copenhagen Kastrup",
+    tz: "Europe/Copenhagen"
+  },
+  {
+    code: "EPWA",
+    country: "PL",
+    ghcnh_id: null,
+    icao: "EPWA",
+    latitude: 52.1657,
+    longitude: 20.9671,
+    name: "Warsaw Chopin",
+    tz: "Europe/Warsaw"
+  },
+  {
+    code: "ESSA",
+    country: "SE",
+    ghcnh_id: null,
+    icao: "ESSA",
+    latitude: 59.6519,
+    longitude: 17.9186,
+    name: "Stockholm Arlanda",
+    tz: "Europe/Stockholm"
+  },
+  {
+    code: "ATL",
+    country: "US",
+    ghcnh_id: "USW00013874",
+    icao: "KATL",
+    latitude: 33.6407,
+    longitude: -84.4277,
+    name: "Hartsfield-Jackson Atlanta International",
+    tz: "America/New_York"
+  },
+  {
+    code: "AUS",
+    country: "US",
+    ghcnh_id: "USW00013904",
+    icao: "KAUS",
+    latitude: 30.1975,
+    longitude: -97.6664,
+    name: "Austin-Bergstrom International",
+    tz: "America/Chicago"
+  },
+  {
+    code: "BOS",
+    country: "US",
+    ghcnh_id: "USW00014739",
+    icao: "KBOS",
+    latitude: 42.3656,
+    longitude: -71.0096,
+    name: "Boston Logan International",
+    tz: "America/New_York"
+  },
+  {
+    code: "DCA",
+    country: "US",
+    ghcnh_id: "USW00013743",
+    icao: "KDCA",
+    latitude: 38.8512,
+    longitude: -77.0402,
+    name: "Washington Reagan National",
+    tz: "America/New_York"
+  },
+  {
+    code: "DEN",
+    country: "US",
+    ghcnh_id: "USW00003017",
+    icao: "KDEN",
+    latitude: 39.8561,
+    longitude: -104.6737,
+    name: "Denver International",
+    tz: "America/Denver"
+  },
+  {
+    code: "DFW",
+    country: "US",
+    ghcnh_id: "USW00003927",
+    icao: "KDFW",
+    latitude: 32.8998,
+    longitude: -97.0403,
+    name: "Dallas-Fort Worth International",
+    tz: "America/Chicago"
+  },
+  {
+    code: "HOU",
+    country: "US",
+    ghcnh_id: "USW00012918",
+    icao: "KHOU",
+    latitude: 29.6454,
+    longitude: -95.2789,
+    name: "Houston Hobby",
+    tz: "America/Chicago"
+  },
+  {
+    code: "LAS",
+    country: "US",
+    ghcnh_id: "USW00023169",
+    icao: "KLAS",
+    latitude: 36.084,
+    longitude: -115.1537,
+    name: "Harry Reid (McCarran) International",
+    tz: "America/Los_Angeles"
+  },
+  {
+    code: "LAX",
+    country: "US",
+    ghcnh_id: "USW00023174",
+    icao: "KLAX",
+    latitude: 33.9425,
+    longitude: -118.4081,
+    name: "Los Angeles International",
+    tz: "America/Los_Angeles"
+  },
+  {
+    code: "MDW",
+    country: "US",
+    ghcnh_id: "USW00014819",
+    icao: "KMDW",
+    latitude: 41.7868,
+    longitude: -87.7522,
+    name: "Chicago Midway International",
+    tz: "America/Chicago"
+  },
+  {
+    code: "MIA",
+    country: "US",
+    ghcnh_id: "USW00012839",
+    icao: "KMIA",
+    latitude: 25.7959,
+    longitude: -80.287,
+    name: "Miami International",
+    tz: "America/New_York"
+  },
+  {
+    code: "MSP",
+    country: "US",
+    ghcnh_id: "USW00014922",
+    icao: "KMSP",
+    latitude: 44.8848,
+    longitude: -93.2223,
+    name: "Minneapolis-St Paul International",
+    tz: "America/Chicago"
+  },
+  {
+    code: "MSY",
+    country: "US",
+    ghcnh_id: "USW00012916",
+    icao: "KMSY",
+    latitude: 29.9934,
+    longitude: -90.258,
+    name: "New Orleans Louis Armstrong International",
+    tz: "America/Chicago"
+  },
+  {
+    code: "NYC",
+    country: "US",
+    ghcnh_id: "USW00094728",
+    icao: "KNYC",
+    latitude: 40.7789,
+    longitude: -73.9692,
+    name: "Central Park, New York",
+    tz: "America/New_York"
+  },
+  {
+    code: "OKC",
+    country: "US",
+    ghcnh_id: "USW00013967",
+    icao: "KOKC",
+    latitude: 35.3931,
+    longitude: -97.6007,
+    name: "Oklahoma City Will Rogers World",
+    tz: "America/Chicago"
+  },
+  {
+    code: "PHL",
+    country: "US",
+    ghcnh_id: "USW00013739",
+    icao: "KPHL",
+    latitude: 39.8721,
+    longitude: -75.2411,
+    name: "Philadelphia International",
+    tz: "America/New_York"
+  },
+  {
+    code: "PHX",
+    country: "US",
+    ghcnh_id: "USW00023183",
+    icao: "KPHX",
+    latitude: 33.4373,
+    longitude: -112.0078,
+    name: "Phoenix Sky Harbor International",
+    tz: "America/Phoenix"
+  },
+  {
+    code: "SAT",
+    country: "US",
+    ghcnh_id: "USW00012921",
+    icao: "KSAT",
+    latitude: 29.5337,
+    longitude: -98.4698,
+    name: "San Antonio International",
+    tz: "America/Chicago"
+  },
+  {
+    code: "SEA",
+    country: "US",
+    ghcnh_id: "USW00024233",
+    icao: "KSEA",
+    latitude: 47.4502,
+    longitude: -122.3088,
+    name: "Seattle-Tacoma International",
+    tz: "America/Los_Angeles"
+  },
+  {
+    code: "SFO",
+    country: "US",
+    ghcnh_id: "USW00023234",
+    icao: "KSFO",
+    latitude: 37.6213,
+    longitude: -122.379,
+    name: "San Francisco International",
+    tz: "America/Los_Angeles"
+  },
+  {
+    code: "LEBL",
+    country: "ES",
+    ghcnh_id: null,
+    icao: "LEBL",
+    latitude: 41.2974,
+    longitude: 2.0833,
+    name: "Barcelona El Prat",
+    tz: "Europe/Madrid"
+  },
+  {
+    code: "LEMD",
+    country: "ES",
+    ghcnh_id: null,
+    icao: "LEMD",
+    latitude: 40.4719,
+    longitude: -3.5626,
+    name: "Madrid Barajas",
+    tz: "Europe/Madrid"
+  },
+  {
+    code: "LFPB",
+    country: "FR",
+    ghcnh_id: null,
+    icao: "LFPB",
+    latitude: 48.9694,
+    longitude: 2.4414,
+    name: "Paris Le Bourget",
+    tz: "Europe/Paris"
+  },
+  {
+    code: "LFPG",
+    country: "FR",
+    ghcnh_id: null,
+    icao: "LFPG",
+    latitude: 49.0097,
+    longitude: 2.5479,
+    name: "Paris Charles de Gaulle",
+    tz: "Europe/Paris"
+  },
+  {
+    code: "LFPO",
+    country: "FR",
+    ghcnh_id: null,
+    icao: "LFPO",
+    latitude: 48.7233,
+    longitude: 2.3794,
+    name: "Paris Orly",
+    tz: "Europe/Paris"
+  },
+  {
+    code: "LIMC",
+    country: "IT",
+    ghcnh_id: null,
+    icao: "LIMC",
+    latitude: 45.6306,
+    longitude: 8.7281,
+    name: "Milan Malpensa",
+    tz: "Europe/Rome"
+  },
+  {
+    code: "LIRF",
+    country: "IT",
+    ghcnh_id: null,
+    icao: "LIRF",
+    latitude: 41.8003,
+    longitude: 12.2389,
+    name: "Rome Fiumicino",
+    tz: "Europe/Rome"
+  },
+  {
+    code: "LOWW",
+    country: "AT",
+    ghcnh_id: null,
+    icao: "LOWW",
+    latitude: 48.1103,
+    longitude: 16.5697,
+    name: "Vienna International",
+    tz: "Europe/Vienna"
+  },
+  {
+    code: "LSZH",
+    country: "CH",
+    ghcnh_id: null,
+    icao: "LSZH",
+    latitude: 47.4647,
+    longitude: 8.5492,
+    name: "Zurich",
+    tz: "Europe/Zurich"
+  },
+  {
+    code: "NZAA",
+    country: "NZ",
+    ghcnh_id: null,
+    icao: "NZAA",
+    latitude: -37.0081,
+    longitude: 174.7917,
+    name: "Auckland",
+    tz: "Pacific/Auckland"
+  },
+  {
+    code: "NZWN",
+    country: "NZ",
+    ghcnh_id: null,
+    icao: "NZWN",
+    latitude: -41.3272,
+    longitude: 174.8053,
+    name: "Wellington",
+    tz: "Pacific/Auckland"
+  },
+  {
+    code: "OERK",
+    country: "SA",
+    ghcnh_id: null,
+    icao: "OERK",
+    latitude: 24.9576,
+    longitude: 46.6988,
+    name: "Riyadh King Khalid International",
+    tz: "Asia/Riyadh"
+  },
+  {
+    code: "OMDB",
+    country: "AE",
+    ghcnh_id: null,
+    icao: "OMDB",
+    latitude: 25.2532,
+    longitude: 55.3657,
+    name: "Dubai International",
+    tz: "Asia/Dubai"
+  },
+  {
+    code: "OTHH",
+    country: "QA",
+    ghcnh_id: null,
+    icao: "OTHH",
+    latitude: 25.2731,
+    longitude: 51.608,
+    name: "Doha Hamad International",
+    tz: "Asia/Qatar"
+  },
+  {
+    code: "RCTP",
+    country: "TW",
+    ghcnh_id: null,
+    icao: "RCTP",
+    latitude: 25.0777,
+    longitude: 121.2328,
+    name: "Taipei Taoyuan",
+    tz: "Asia/Taipei"
+  },
+  {
+    code: "RJAA",
+    country: "JP",
+    ghcnh_id: null,
+    icao: "RJAA",
+    latitude: 35.7647,
+    longitude: 140.3864,
+    name: "Tokyo Narita",
+    tz: "Asia/Tokyo"
+  },
+  {
+    code: "RJTT",
+    country: "JP",
+    ghcnh_id: null,
+    icao: "RJTT",
+    latitude: 35.5522,
+    longitude: 139.78,
+    name: "Tokyo Haneda",
+    tz: "Asia/Tokyo"
+  },
+  {
+    code: "RKSI",
+    country: "KR",
+    ghcnh_id: null,
+    icao: "RKSI",
+    latitude: 37.4691,
+    longitude: 126.4505,
+    name: "Seoul Incheon",
+    tz: "Asia/Seoul"
+  },
+  {
+    code: "SAEZ",
+    country: "AR",
+    ghcnh_id: null,
+    icao: "SAEZ",
+    latitude: -34.8222,
+    longitude: -58.5358,
+    name: "Buenos Aires Ezeiza",
+    tz: "America/Argentina/Buenos_Aires"
+  },
+  {
+    code: "SBGR",
+    country: "BR",
+    ghcnh_id: null,
+    icao: "SBGR",
+    latitude: -23.4356,
+    longitude: -46.4731,
+    name: "S\xE3o Paulo Guarulhos",
+    tz: "America/Sao_Paulo"
+  },
+  {
+    code: "UUEE",
+    country: "RU",
+    ghcnh_id: null,
+    icao: "UUEE",
+    latitude: 55.9728,
+    longitude: 37.4147,
+    name: "Moscow Sheremetyevo",
+    tz: "Europe/Moscow"
+  },
+  {
+    code: "VABB",
+    country: "IN",
+    ghcnh_id: null,
+    icao: "VABB",
+    latitude: 19.0887,
+    longitude: 72.8679,
+    name: "Mumbai Chhatrapati Shivaji",
+    tz: "Asia/Kolkata"
+  },
+  {
+    code: "VHHH",
+    country: "HK",
+    ghcnh_id: null,
+    icao: "VHHH",
+    latitude: 22.308,
+    longitude: 113.9185,
+    name: "Hong Kong International",
+    tz: "Asia/Hong_Kong"
+  },
+  {
+    code: "VIDP",
+    country: "IN",
+    ghcnh_id: null,
+    icao: "VIDP",
+    latitude: 28.5562,
+    longitude: 77.1,
+    name: "Delhi Indira Gandhi",
+    tz: "Asia/Kolkata"
+  },
+  {
+    code: "VTBS",
+    country: "TH",
+    ghcnh_id: null,
+    icao: "VTBS",
+    latitude: 13.69,
+    longitude: 100.7501,
+    name: "Bangkok Suvarnabhumi",
+    tz: "Asia/Bangkok"
+  },
+  {
+    code: "WSSS",
+    country: "SG",
+    ghcnh_id: null,
+    icao: "WSSS",
+    latitude: 1.3644,
+    longitude: 103.9915,
+    name: "Singapore Changi",
+    tz: "Asia/Singapore"
+  },
+  {
+    code: "YBBN",
+    country: "AU",
+    ghcnh_id: null,
+    icao: "YBBN",
+    latitude: -27.3842,
+    longitude: 153.1175,
+    name: "Brisbane",
+    tz: "Australia/Brisbane"
+  },
+  {
+    code: "YMML",
+    country: "AU",
+    ghcnh_id: null,
+    icao: "YMML",
+    latitude: -37.6733,
+    longitude: 144.8433,
+    name: "Melbourne Tullamarine",
+    tz: "Australia/Melbourne"
+  },
+  {
+    code: "YSSY",
+    country: "AU",
+    ghcnh_id: null,
+    icao: "YSSY",
+    latitude: -33.9461,
+    longitude: 151.1772,
+    name: "Sydney Kingsford Smith",
+    tz: "Australia/Sydney"
+  },
+  {
+    code: "ZBAA",
+    country: "CN",
+    ghcnh_id: null,
+    icao: "ZBAA",
+    latitude: 40.0801,
+    longitude: 116.5846,
+    name: "Beijing Capital",
+    tz: "Asia/Shanghai"
+  },
+  {
+    code: "ZSPD",
+    country: "CN",
+    ghcnh_id: null,
+    icao: "ZSPD",
+    latitude: 31.1443,
+    longitude: 121.8083,
+    name: "Shanghai Pudong",
+    tz: "Asia/Shanghai"
+  }
+];
+var STATION_BY_CODE = /* @__PURE__ */ new Map([
+  ["ATL", STATIONS[10]],
+  ["AUS", STATIONS[11]],
+  ["BOS", STATIONS[12]],
+  ["DCA", STATIONS[13]],
+  ["DEN", STATIONS[14]],
+  ["DFW", STATIONS[15]],
+  ["EDDB", STATIONS[0]],
+  ["EDDF", STATIONS[1]],
+  ["EDDM", STATIONS[2]],
+  ["EFHK", STATIONS[3]],
+  ["EGKK", STATIONS[4]],
+  ["EGLL", STATIONS[5]],
+  ["EHAM", STATIONS[6]],
+  ["EKCH", STATIONS[7]],
+  ["EPWA", STATIONS[8]],
+  ["ESSA", STATIONS[9]],
+  ["HOU", STATIONS[16]],
+  ["LAS", STATIONS[17]],
+  ["LAX", STATIONS[18]],
+  ["LEBL", STATIONS[30]],
+  ["LEMD", STATIONS[31]],
+  ["LFPB", STATIONS[32]],
+  ["LFPG", STATIONS[33]],
+  ["LFPO", STATIONS[34]],
+  ["LIMC", STATIONS[35]],
+  ["LIRF", STATIONS[36]],
+  ["LOWW", STATIONS[37]],
+  ["LSZH", STATIONS[38]],
+  ["MDW", STATIONS[19]],
+  ["MIA", STATIONS[20]],
+  ["MSP", STATIONS[21]],
+  ["MSY", STATIONS[22]],
+  ["NYC", STATIONS[23]],
+  ["NZAA", STATIONS[39]],
+  ["NZWN", STATIONS[40]],
+  ["OERK", STATIONS[41]],
+  ["OKC", STATIONS[24]],
+  ["OMDB", STATIONS[42]],
+  ["OTHH", STATIONS[43]],
+  ["PHL", STATIONS[25]],
+  ["PHX", STATIONS[26]],
+  ["RCTP", STATIONS[44]],
+  ["RJAA", STATIONS[45]],
+  ["RJTT", STATIONS[46]],
+  ["RKSI", STATIONS[47]],
+  ["SAEZ", STATIONS[48]],
+  ["SAT", STATIONS[27]],
+  ["SBGR", STATIONS[49]],
+  ["SEA", STATIONS[28]],
+  ["SFO", STATIONS[29]],
+  ["UUEE", STATIONS[50]],
+  ["VABB", STATIONS[51]],
+  ["VHHH", STATIONS[52]],
+  ["VIDP", STATIONS[53]],
+  ["VTBS", STATIONS[54]],
+  ["WSSS", STATIONS[55]],
+  ["YBBN", STATIONS[56]],
+  ["YMML", STATIONS[57]],
+  ["YSSY", STATIONS[58]],
+  ["ZBAA", STATIONS[59]],
+  ["ZSPD", STATIONS[60]]
+]);
+var STATION_BY_ICAO = /* @__PURE__ */ new Map([
+  ["EDDB", STATIONS[0]],
+  ["EDDF", STATIONS[1]],
+  ["EDDM", STATIONS[2]],
+  ["EFHK", STATIONS[3]],
+  ["EGKK", STATIONS[4]],
+  ["EGLL", STATIONS[5]],
+  ["EHAM", STATIONS[6]],
+  ["EKCH", STATIONS[7]],
+  ["EPWA", STATIONS[8]],
+  ["ESSA", STATIONS[9]],
+  ["KATL", STATIONS[10]],
+  ["KAUS", STATIONS[11]],
+  ["KBOS", STATIONS[12]],
+  ["KDCA", STATIONS[13]],
+  ["KDEN", STATIONS[14]],
+  ["KDFW", STATIONS[15]],
+  ["KHOU", STATIONS[16]],
+  ["KLAS", STATIONS[17]],
+  ["KLAX", STATIONS[18]],
+  ["KMDW", STATIONS[19]],
+  ["KMIA", STATIONS[20]],
+  ["KMSP", STATIONS[21]],
+  ["KMSY", STATIONS[22]],
+  ["KNYC", STATIONS[23]],
+  ["KOKC", STATIONS[24]],
+  ["KPHL", STATIONS[25]],
+  ["KPHX", STATIONS[26]],
+  ["KSAT", STATIONS[27]],
+  ["KSEA", STATIONS[28]],
+  ["KSFO", STATIONS[29]],
+  ["LEBL", STATIONS[30]],
+  ["LEMD", STATIONS[31]],
+  ["LFPB", STATIONS[32]],
+  ["LFPG", STATIONS[33]],
+  ["LFPO", STATIONS[34]],
+  ["LIMC", STATIONS[35]],
+  ["LIRF", STATIONS[36]],
+  ["LOWW", STATIONS[37]],
+  ["LSZH", STATIONS[38]],
+  ["NZAA", STATIONS[39]],
+  ["NZWN", STATIONS[40]],
+  ["OERK", STATIONS[41]],
+  ["OMDB", STATIONS[42]],
+  ["OTHH", STATIONS[43]],
+  ["RCTP", STATIONS[44]],
+  ["RJAA", STATIONS[45]],
+  ["RJTT", STATIONS[46]],
+  ["RKSI", STATIONS[47]],
+  ["SAEZ", STATIONS[48]],
+  ["SBGR", STATIONS[49]],
+  ["UUEE", STATIONS[50]],
+  ["VABB", STATIONS[51]],
+  ["VHHH", STATIONS[52]],
+  ["VIDP", STATIONS[53]],
+  ["VTBS", STATIONS[54]],
+  ["WSSS", STATIONS[55]],
+  ["YBBN", STATIONS[56]],
+  ["YMML", STATIONS[57]],
+  ["YSSY", STATIONS[58]],
+  ["ZBAA", STATIONS[59]],
+  ["ZSPD", STATIONS[60]]
+]);
+
+// src/discovery/availability.ts
+function hasListKeys(store) {
+  return typeof store.listKeys === "function";
+}
+var STATION_RE = /^[A-Z0-9]{3,5}$/;
+function normalizeStation(station) {
+  const upper = station.toUpperCase();
+  if (!STATION_RE.test(upper)) {
+    throw new RangeError(
+      `availability: station must be a 3-5 char alphanumeric code; got ${JSON.stringify(station)}`
+    );
+  }
+  const byIcao = STATION_BY_ICAO.get(upper);
+  if (byIcao !== void 0) {
+    return byIcao.code ?? byIcao.icao;
+  }
+  const byCode = STATION_BY_CODE.get(upper);
+  if (byCode !== void 0) {
+    return byCode.code ?? byCode.icao;
+  }
+  return upper;
+}
+var OBS_KEY_RE = /^mostlyright:v1:observations:([A-Z0-9]+):(\d{4}):(\d{2})(?::[a-z0-9_-]+)?$/;
+var CLIMATE_KEY_RE = /^mostlyright:v1:climate:([A-Z0-9]+):(\d{4})$/;
+async function availability(station, cache, opts = {}) {
+  const stationCode = normalizeStation(station);
+  const empty = Object.freeze({
+    station: stationCode,
+    monthsCached: 0,
+    firstMonth: null,
+    lastMonth: null,
+    climateYears: 0,
+    firstClimateYear: null,
+    lastClimateYear: null
+  });
+  if (!hasListKeys(cache)) {
+    return empty;
+  }
+  const upperInput = station.toUpperCase();
+  const scanCodes = upperInput === stationCode ? [stationCode] : [stationCode, upperInput];
+  const obsPrefixes = scanCodes.map((c) => `mostlyright:v1:observations:${c}:`);
+  const climatePrefixes = scanCodes.map((c) => `mostlyright:v1:climate:${c}:`);
+  const obsKeySets = await Promise.all(obsPrefixes.map((p) => cache.listKeys(p)));
+  const climateKeySets = await Promise.all(climatePrefixes.map((p) => cache.listKeys(p)));
+  const obsKeys = obsKeySets.flat();
+  const climateKeys = climateKeySets.flat();
+  const monthCandidates = /* @__PURE__ */ new Map();
+  for (const key of obsKeys) {
+    const m = OBS_KEY_RE.exec(key);
+    if (m === null) continue;
+    const keyStation = m[1];
+    if (!scanCodes.includes(keyStation)) continue;
+    const ym = `${m[2]}-${m[3]}`;
+    const arr = monthCandidates.get(ym) ?? [];
+    arr.push(key);
+    monthCandidates.set(ym, arr);
+  }
+  const yearCandidates = /* @__PURE__ */ new Map();
+  for (const key of climateKeys) {
+    const m = CLIMATE_KEY_RE.exec(key);
+    if (m === null) continue;
+    const keyStation = m[1];
+    if (!scanCodes.includes(keyStation)) continue;
+    const y = m[2];
+    const arr = yearCandidates.get(y) ?? [];
+    arr.push(key);
+    yearCandidates.set(y, arr);
+  }
+  let months;
+  let years;
+  if (opts.validate === true) {
+    const monthChecks = await Promise.all(
+      [...monthCandidates.entries()].map(async ([ym, keys]) => {
+        for (const k of keys) {
+          if (await cache.get(k) !== null) return ym;
+        }
+        return null;
+      })
+    );
+    months = monthChecks.filter((v) => v !== null).sort();
+    const yearChecks = await Promise.all(
+      [...yearCandidates.entries()].map(async ([y, keys]) => {
+        for (const k of keys) {
+          if (await cache.get(k) !== null) return y;
+        }
+        return null;
+      })
+    );
+    years = yearChecks.filter((v) => v !== null).sort();
+  } else {
+    months = [...monthCandidates.keys()].sort();
+    years = [...yearCandidates.keys()].sort();
+  }
+  return Object.freeze({
+    station: stationCode,
+    monthsCached: months.length,
+    firstMonth: months[0] ?? null,
+    lastMonth: months.at(-1) ?? null,
+    climateYears: years.length,
+    firstClimateYear: years[0] ?? null,
+    lastClimateYear: years.at(-1) ?? null
+  });
+}
+
+// src/discovery/international.ts
+var LOW_COVERAGE_THRESHOLD = 12;
+var PARTS_CACHE = /* @__PURE__ */ new Map();
+function getDateFormatter(tz) {
+  let f = PARTS_CACHE.get(tz);
+  if (f === void 0) {
+    f = new Intl.DateTimeFormat("en-US", {
+      timeZone: tz,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    });
+    PARTS_CACHE.set(tz, f);
+  }
+  return f;
+}
+function localDateFor(instant, tz) {
+  const parts = getDateFormatter(tz).formatToParts(instant);
+  let y = "";
+  let m = "";
+  let d = "";
+  for (const p of parts) {
+    if (p.type === "year") y = p.value;
+    else if (p.type === "month") m = p.value;
+    else if (p.type === "day") d = p.value;
+  }
+  return `${y}-${m}-${d}`;
+}
+function parseInstant(observed) {
+  if (observed === void 0 || observed === null || observed.length === 0) {
+    return null;
+  }
+  const ms = Date.parse(observed);
+  if (Number.isNaN(ms)) return null;
+  return new Date(ms);
+}
+function roundHalfUp(value, places) {
+  if (!Number.isFinite(value)) return value;
+  const scale = 10 ** places;
+  const sign = value < 0 ? -1 : 1;
+  const abs = Math.abs(value);
+  const rounded = Math.floor(abs * scale + 0.5 + abs * 1e-12) / scale;
+  return sign * rounded;
+}
+function cToF(c) {
+  return c * 1.8 + 32;
+}
+function internationalDailyExtremes(rows, opts) {
+  const tz = opts.stationTz;
+  if (typeof tz !== "string" || tz.length === 0) {
+    throw new RangeError("internationalDailyExtremes: stationTz is required (non-empty string)");
+  }
+  const precision = opts.precision ?? 0;
+  const minObs = opts.minObs ?? LOW_COVERAGE_THRESHOLD;
+  try {
+    getDateFormatter(tz);
+  } catch (e) {
+    throw new RangeError(
+      `internationalDailyExtremes: invalid stationTz ${JSON.stringify(tz)}: ${e.message}`
+    );
+  }
+  const byLocalDate = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const instant = parseInstant(row.observed_at);
+    if (instant === null) continue;
+    const localDate = localDateFor(instant, tz);
+    let bucket = byLocalDate.get(localDate);
+    if (bucket === void 0) {
+      bucket = { temps: [], precipMm: 0 };
+      byLocalDate.set(localDate, bucket);
+    }
+    const t = row.temp_c;
+    if (typeof t === "number" && Number.isFinite(t)) {
+      bucket.temps.push({ value: t, source: row.source ?? null });
+    }
+    const p = row.precip_mm_1h;
+    if (typeof p === "number" && Number.isFinite(p)) {
+      bucket.precipMm += p;
+    }
+  }
+  const out = [];
+  const sortedDates = [...byLocalDate.keys()].sort();
+  for (const localDate of sortedDates) {
+    const bucket = byLocalDate.get(localDate);
+    if (bucket === void 0) continue;
+    const nObs = bucket.temps.length;
+    let tempMinC = null;
+    let tempMaxC = null;
+    let tempMeanC = null;
+    let sourceTmin = null;
+    let sourceTmax = null;
+    if (nObs > 0 && nObs >= minObs) {
+      let minIdx = 0;
+      let maxIdx = 0;
+      let sum = 0;
+      for (let i = 0; i < bucket.temps.length; i += 1) {
+        const v = bucket.temps[i];
+        sum += v.value;
+        const minRow2 = bucket.temps[minIdx];
+        const maxRow2 = bucket.temps[maxIdx];
+        if (v.value < minRow2.value) minIdx = i;
+        if (v.value > maxRow2.value) maxIdx = i;
+      }
+      const mean = sum / nObs;
+      const minRow = bucket.temps[minIdx];
+      const maxRow = bucket.temps[maxIdx];
+      tempMinC = roundHalfUp(minRow.value, precision);
+      tempMaxC = roundHalfUp(maxRow.value, precision);
+      tempMeanC = roundHalfUp(mean, precision);
+      sourceTmin = minRow.source;
+      sourceTmax = maxRow.source;
+    }
+    out.push(
+      Object.freeze({
+        localDate,
+        nObs,
+        tempMinC,
+        tempMaxC,
+        tempMeanC,
+        tempMinF: tempMinC === null ? null : roundHalfUp(cToF(tempMinC), precision),
+        tempMaxF: tempMaxC === null ? null : roundHalfUp(cToF(tempMaxC), precision),
+        precipMm: roundHalfUp(bucket.precipMm, 4),
+        sourceTmin,
+        sourceTmax
+      })
+    );
+  }
+  return out;
+}
+
+// src/exceptions/index.ts
+function toJsonSafe(value, seen) {
+  const visited = seen ?? /* @__PURE__ */ new WeakSet();
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value === "bigint") {
+    if (value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)) {
+      return Number(value);
+    }
+    return { _repr_only: true, value: value.toString() };
+  }
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      return null;
+    }
+    return value.toISOString();
+  }
+  if (Array.isArray(value)) {
+    if (visited.has(value)) {
+      return { _cycle: true, value: String(value) };
+    }
+    visited.add(value);
+    try {
+      return value.map((item) => toJsonSafe(item, visited));
+    } finally {
+      visited.delete(value);
+    }
+  }
+  if (typeof value === "object") {
+    if (visited.has(value)) {
+      return { _cycle: true, value: String(value) };
+    }
+    visited.add(value);
+    try {
+      const out = {};
+      for (const key of Object.keys(value)) {
+        if (typeof key !== "string") {
+          throw new TypeError(`toJsonSafe dict keys must be string; got ${typeof key}`);
+        }
+        out[key] = toJsonSafe(value[key], visited);
+      }
+      return out;
+    } finally {
+      visited.delete(value);
+    }
+  }
+  return { _repr_only: true, value: String(value) };
+}
+var TradewindsError = class extends Error {
+  /** Subclass override — the stable string enum surfaced via `errorCode`. */
+  static defaultErrorCode = "TRADEWINDS_ERROR";
+  errorCode;
+  source;
+  requestId;
+  constructor(message = "", options = {}) {
+    super(message);
+    this.name = new.target.name;
+    const ctor = this.constructor;
+    this.errorCode = options.errorCode ?? ctor.defaultErrorCode;
+    this.source = options.source ?? null;
+    this.requestId = options.requestId ?? null;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /**
+   * Subclass hook returning the structured attributes for `toDict`.
+   * Values are passed through `toJsonSafe` by `toDict()`, so subclasses
+   * don't need to coerce values themselves.
+   */
+  payload() {
+    return {
+      error_code: this.errorCode,
+      message: this.message,
+      source: this.source,
+      request_id: this.requestId
+    };
+  }
+  /** Return a JSON-safe dict suitable for MCP `error.data`. */
+  toDict() {
+    const safe = toJsonSafe(this.payload());
+    return safe;
+  }
+};
+
+// src/formats/toon.ts
+var SAFE_KEY_RE = /^[A-Za-z_][A-Za-z0-9_.]*$/;
+var NUMERIC_LIKE_RE = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+var NEEDS_QUOTE_CHARS_RE = /[:\\\"'\[\]{}\x00-\x1f\x7f\x85\u2028\u2029]/;
+var UNSUPPORTED_CTRL_RE = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f\x85\u2028\u2029]/g;
+function formatNumber(n) {
+  if (!Number.isFinite(n)) return "null";
+  if (n === 0) return "0";
+  if (Number.isInteger(n) && Math.abs(n) <= 2 ** 53) return String(n);
+  let s = String(n);
+  if (/[eE]/.test(s)) {
+    s = expandExponent(s);
+  }
+  return s;
+}
+function expandExponent(s) {
+  const m = /^(-?)(\d+(?:\.\d+)?)[eE]([+-]?\d+)$/.exec(s);
+  if (!m) return s;
+  const sign = m[1] ?? "";
+  const mantissa = m[2] ?? "";
+  const exp = Number(m[3]);
+  const [intPart, fracPart = ""] = mantissa.split(".");
+  const digits = (intPart ?? "") + fracPart;
+  const pointPos = (intPart ?? "").length + exp;
+  let out;
+  if (pointPos <= 0) {
+    out = `0.${"0".repeat(-pointPos)}${digits}`.replace(/0+$/, "");
+    if (out.endsWith(".")) out = out.slice(0, -1);
+  } else if (pointPos >= digits.length) {
+    out = digits + "0".repeat(pointPos - digits.length);
+  } else {
+    out = `${digits.slice(0, pointPos)}.${digits.slice(pointPos)}`.replace(/0+$/, "");
+    if (out.endsWith(".")) out = out.slice(0, -1);
+  }
+  return sign + out;
+}
+function needsQuoting(s, delimiter) {
+  if (s.length === 0) return true;
+  const first = s.charAt(0);
+  const last = s.charAt(s.length - 1);
+  if (first === " " || first === "	") return true;
+  if (last === " " || last === "	") return true;
+  if (s === "true" || s === "false" || s === "null") return true;
+  if (first === "-" || first === "+") return true;
+  if (first >= "0" && first <= "9") return true;
+  if (NUMERIC_LIKE_RE.test(s)) return true;
+  if (s.includes(delimiter)) return true;
+  if (NEEDS_QUOTE_CHARS_RE.test(s)) return true;
+  return false;
+}
+function quoteString(s) {
+  let out = s.replace(UNSUPPORTED_CTRL_RE, "");
+  out = out.replace(/\\/g, "\\\\");
+  out = out.replace(/"/g, '\\"');
+  out = out.replace(/\n/g, "\\n");
+  out = out.replace(/\r/g, "\\r");
+  out = out.replace(/\t/g, "\\t");
+  return `"${out}"`;
+}
+function formatKey(key) {
+  if (typeof key !== "string") {
+    throw new TypeError(`TOON keys must be strings; got ${typeof key}`);
+  }
+  if (SAFE_KEY_RE.test(key)) return key;
+  return quoteString(key);
+}
+function encodeScalar(value, delimiter) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") return formatNumber(value);
+  if (typeof value === "string") {
+    if (needsQuoting(value, delimiter)) return quoteString(value);
+    return value;
+  }
+  if (typeof value === "object") {
+    if (Array.isArray(value)) {
+      return quoteString(JSON.stringify(value));
+    }
+    const sorted = sortedJson(value);
+    return quoteString(sorted);
+  }
+  return quoteString(String(value));
+}
+function sortedJson(obj) {
+  const keys = Object.keys(obj).sort();
+  const parts = keys.map((k) => `${JSON.stringify(k)}:${JSON.stringify(obj[k])}`);
+  return `{${parts.join(",")}}`;
+}
+var ToonTabularError = class extends RangeError {
+  name = "ToonTabularError";
+};
+function isToonPrimitive(v) {
+  if (v === null || v === void 0) return true;
+  const t = typeof v;
+  return t === "string" || t === "number" || t === "boolean";
+}
+function assertTabular(rows) {
+  if (rows.length === 0) return;
+  const first = rows[0];
+  const expectedKeys = Object.keys(first);
+  if (expectedKeys.length === 0) {
+    throw new ToonTabularError(
+      "toonDumps requires non-empty rows; first row has no keys (Python parity: encode_tabular rejects empty key set)"
+    );
+  }
+  const expectedKeySet = new Set(expectedKeys);
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    const rowKeys = Object.keys(row);
+    if (rowKeys.length !== expectedKeySet.size) {
+      throw new ToonTabularError(
+        `toonDumps requires uniform rows; row ${i} has ${rowKeys.length} key(s) vs row 0's ${expectedKeySet.size}. Python encode_tabular rejects rows whose key sets differ.`
+      );
+    }
+    for (const k of rowKeys) {
+      if (!expectedKeySet.has(k)) {
+        throw new ToonTabularError(
+          `toonDumps requires uniform rows; row ${i} has key ${JSON.stringify(k)} not present in row 0. Python encode_tabular rejects rows whose key sets differ.`
+        );
+      }
+    }
+    for (const k of expectedKeys) {
+      const v = row[k];
+      if (!isToonPrimitive(v)) {
+        throw new ToonTabularError(
+          `toonDumps requires primitive cell values; row ${i} column ${JSON.stringify(k)} has non-primitive value of type ${typeof v}. Python encode_tabular rejects nested objects/arrays at the cell level.`
+        );
+      }
+    }
+  }
+}
+function toonDumps(rows, columns) {
+  if (rows.length === 0) {
+    if (columns !== void 0) {
+      const cols2 = columns.map((c) => formatKey(String(c))).join(",");
+      return `rows[0]{${cols2}}:`;
+    }
+    return "rows[0]:";
+  }
+  assertTabular(rows);
+  const cols = Object.keys(rows[0]);
+  const colHeader = cols.map((c) => formatKey(c)).join(",");
+  const header = `rows[${rows.length}]{${colHeader}}:`;
+  const dataLines = rows.map((r) => {
+    const vals = cols.map((c) => encodeScalar(r[c], ","));
+    return `  ${vals.join(",")}`;
+  });
+  return `${header}
+${dataLines.join("\n")}`;
+}
+
+// src/discovery/snapshot.ts
+function normalizeKnowledgeTime(value) {
+  if (value === void 0) {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      throw new RangeError("buildSnapshot: knowledgeTime is an invalid Date");
+    }
+    return value.toISOString();
+  }
+  const ms = Date.parse(value);
+  if (Number.isNaN(ms)) {
+    throw new RangeError(
+      `buildSnapshot: knowledgeTime ${JSON.stringify(value)} is not a parseable ISO 8601 timestamp`
+    );
+  }
+  return new Date(ms).toISOString();
+}
+function freezeRows(rows) {
+  const out = [];
+  for (const r of rows) {
+    out.push(Object.freeze({ ...r }));
+  }
+  return Object.freeze(out);
+}
+function buildSnapshot(opts) {
+  if (typeof opts.schemaId !== "string" || opts.schemaId.length === 0) {
+    throw new RangeError("buildSnapshot: schemaId must be a non-empty string");
+  }
+  if (typeof opts.source !== "string" || opts.source.length === 0) {
+    throw new RangeError("buildSnapshot: source must be a non-empty string");
+  }
+  if (!Array.isArray(opts.rows)) {
+    throw new RangeError("buildSnapshot: rows must be an array");
+  }
+  const knowledgeTime = normalizeKnowledgeTime(opts.knowledgeTime);
+  const schemaId = opts.schemaId;
+  const source = opts.source;
+  const rows = freezeRows(opts.rows);
+  const dataVersion = opts.dataVersion ?? null;
+  const metadata = Object.freeze({ ...opts.metadata ?? {} });
+  const snapshot = {
+    knowledgeTime,
+    schemaId,
+    source,
+    rows,
+    dataVersion,
+    metadata,
+    toDict() {
+      return toJsonSafe({
+        knowledge_time: knowledgeTime,
+        schema_id: schemaId,
+        source,
+        rows,
+        data_version: dataVersion,
+        metadata
+      });
+    },
+    toToon() {
+      return toonDumps(rows);
+    }
+  };
+  return Object.freeze(snapshot);
+}
+
+// src/discovery/data-version.ts
+var HEX = "0123456789abcdef";
+function bytesToHex(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 1) {
+    const b = bytes[i];
+    out += HEX[b >> 4 & 15];
+    out += HEX[b & 15];
+  }
+  return out;
+}
+async function dataVersionFromComponents(components) {
+  const sortedSchemaIds = [...components.schemaIds].sort();
+  const sortedSources = [...components.sources].sort();
+  const canonical = [
+    components.sdkVersion,
+    sortedSchemaIds.join(","),
+    sortedSources.join(","),
+    components.codeSha,
+    components.dataSha
+  ].join("|");
+  const encoded = new TextEncoder().encode(canonical);
+  const digest = await crypto.subtle.digest("SHA-256", encoded);
+  const token = bytesToHex(new Uint8Array(digest));
+  return Object.freeze({
+    sdkVersion: components.sdkVersion,
+    schemaIds: Object.freeze([...components.schemaIds]),
+    sources: Object.freeze([...components.sources]),
+    codeSha: components.codeSha,
+    dataSha: components.dataSha,
+    token
+  });
+}
+async function dataVersionForResearch(args) {
+  return dataVersionFromComponents({
+    sdkVersion: args.sdkVersion,
+    schemaIds: ["schema.observation.v1", "schema.forecast.iem_mos.v1", "schema.settlement.cli.v1"],
+    sources: ["iem.archive", "iem.live", "awc.live", "ghcnh", "nws.cli"],
+    codeSha: `research:${args.station}:${args.fromDate}:${args.toDate}`,
+    dataSha: args.dataSha
+  });
+}
+
+// src/discovery/describe.ts
+var BUILT_IN_SCHEMAS = Object.freeze([
+  {
+    id: "schema.observation.v1",
+    title: "schema.observation.v1",
+    columnCount: 20,
+    columns: [
+      { name: "dew_point_c", description: "units: celsius \u2014 bounded", nullable: true },
+      { name: "event_time", description: "observation valid time", nullable: false },
+      {
+        name: "metar_raw",
+        description: "raw METAR text if source has it; null for AWC JSON (structured-only)",
+        nullable: true
+      },
+      {
+        name: "observation_type",
+        description: "METAR | SPECI; defaults METAR when source can't distinguish (e.g. AWC JSON)",
+        nullable: false
+      },
+      {
+        name: "precip_mm_1h",
+        description: "units: mm \u2014 hourly precip (METAR p01i, converted from inches)",
+        nullable: true
+      },
+      {
+        name: "sky_base_1_m",
+        description: "units: meters \u2014 first cloud layer base height (converted from feet)",
+        nullable: true
+      },
+      { name: "sky_base_2_m", description: "units: meters", nullable: true },
+      { name: "sky_base_3_m", description: "units: meters", nullable: true },
+      { name: "sky_base_4_m", description: "units: meters", nullable: true },
+      { name: "sky_cover_1", description: "first cloud layer cover code", nullable: true },
+      { name: "sky_cover_2", description: "second layer; null if not present", nullable: true },
+      { name: "sky_cover_3", description: "third layer; null if not present", nullable: true },
+      { name: "sky_cover_4", description: "fourth layer; null if not present", nullable: true },
+      {
+        name: "slp_hpa",
+        description: "units: hPa \u2014 sea-level pressure (canonical aviation unit, not converted across modes)",
+        nullable: true
+      },
+      { name: "station", description: "ICAO/ASOS station ID (e.g. KORD)", nullable: false },
+      {
+        name: "temp_c",
+        description: "units: celsius \u2014 bounded TEMP_MIN_C..TEMP_MAX_C",
+        nullable: true
+      },
+      {
+        name: "visibility_m",
+        description: "units: meters \u2014 converted from statute miles",
+        nullable: true
+      },
+      {
+        name: "wind_dir_deg",
+        description: "units: degrees \u2014 0-360, bounded",
+        nullable: true
+      },
+      { name: "wind_gust_ms", description: "units: m/s \u2014 converted from kt", nullable: true },
+      { name: "wind_speed_ms", description: "units: m/s \u2014 converted from kt", nullable: true }
+    ]
+  },
+  {
+    id: "schema.forecast.iem_mos.v1",
+    title: "schema.forecast.iem_mos.v1",
+    columnCount: 11,
+    columns: [
+      { name: "dew_point_c", description: "units: celsius", nullable: true },
+      {
+        name: "forecast_hour",
+        description: "units: hours \u2014 (valid_at - issued_at).total_seconds() / 3600",
+        nullable: false
+      },
+      {
+        name: "issued_at",
+        description: "model run time (from source `runtime` field)",
+        nullable: false
+      },
+      { name: "model", description: "e.g. NBE, GFS, LAV, MET", nullable: false },
+      {
+        name: "precip_probability",
+        description: "units: probability \u2014 bounded [0, 1]",
+        nullable: true
+      },
+      {
+        name: "sky_cover_pct",
+        description: "units: percent \u2014 bounded [0, 100]",
+        nullable: true
+      },
+      { name: "station", description: "", nullable: false },
+      { name: "temp_c", description: "units: celsius", nullable: true },
+      {
+        name: "valid_at",
+        description: "forecast target time (from source `ftime`)",
+        nullable: false
+      },
+      { name: "wind_dir_deg", description: "units: degrees", nullable: true },
+      { name: "wind_speed_ms", description: "units: m/s", nullable: true }
+    ]
+  },
+  {
+    id: "schema.settlement.cli.v1",
+    title: "schema.settlement.cli.v1",
+    columnCount: 12,
+    columns: [
+      {
+        name: "cli_data_quality",
+        description: "NWS CLI data-quality marker (Pitfall 6/16). Allows downstream code to filter or weight settlement rows by issuer quality without re-parsing the product header.",
+        nullable: false
+      },
+      {
+        name: "event_time",
+        description: "00:00 local time on observation_date converted to UTC; for sort/join only",
+        nullable: false
+      },
+      {
+        name: "observation_date",
+        description: "local climate day per NWS convention (no timezone applied to the date itself)",
+        nullable: false
+      },
+      { name: "precipitation_in", description: "units: inches", nullable: true },
+      {
+        name: "product_release_time",
+        description: "parsed from CLI product header (_climate.py::_parse_product_timestamp)",
+        nullable: false
+      },
+      {
+        name: "report_type",
+        description: "preliminary | final | correction; dedup priority preliminary < final < correction",
+        nullable: false
+      },
+      {
+        name: "settlement_finality",
+        description: "provisional | final | superseded. Kalshi NHIGH/NLOW settlement contractually requires 'final'; 'provisional' values are kept for early-look research only.",
+        nullable: false
+      },
+      { name: "snowfall_in", description: "units: inches", nullable: true },
+      { name: "station", description: "ICAO/ASOS station ID", nullable: false },
+      {
+        name: "station_tz",
+        description: "IANA timezone for the station (e.g. America/Chicago for KORD). Required for local-climate-day semantics; see \xA7U.",
+        nullable: false
+      },
+      {
+        name: "temp_max_F",
+        description: "units: fahrenheit \u2014 daily high (uppercase F for consistency with obs imperial mode)",
+        nullable: true
+      },
+      { name: "temp_min_F", description: "units: fahrenheit \u2014 daily low", nullable: true }
+    ]
+  },
+  {
+    id: "schema.observation_ledger.v1",
+    title: "schema.observation_ledger.v1",
+    columnCount: 15,
+    columns: [
+      { name: "as_of_time", description: "", nullable: true },
+      { name: "dewpoint_c", description: "units: celsius", nullable: true },
+      { name: "ingestion_id", description: "", nullable: true },
+      { name: "observation_kind", description: "", nullable: true },
+      {
+        name: "observation_quality",
+        description: "Lineage row-quality flag per LINEAGE-01; distinct from qc_status enum slot AND distinct from the obs_qc_status bitmask column per QC-05.",
+        nullable: true
+      },
+      { name: "observation_type", description: "", nullable: false },
+      { name: "observed_at", description: "", nullable: false },
+      { name: "parser_name", description: "", nullable: true },
+      { name: "parser_version", description: "", nullable: true },
+      { name: "provenance", description: "", nullable: true },
+      { name: "qc_status", description: "", nullable: true },
+      {
+        name: "source",
+        description: "ncei reserved per D-2.1-09; never written in v0.1.0.",
+        nullable: false
+      },
+      { name: "source_received_at", description: "", nullable: true },
+      { name: "station_code", description: "", nullable: false },
+      { name: "temp_c", description: "units: celsius", nullable: true }
+    ]
+  },
+  {
+    id: "schema.observation_qc.v1",
+    title: "schema.observation_qc.v1",
+    columnCount: 13,
+    columns: [
+      { name: "as_of_time", description: "", nullable: true },
+      {
+        name: "detector_metadata",
+        description: "JSON-serialized detector payload; shape per qc_system.",
+        nullable: true
+      },
+      {
+        name: "field",
+        description: "Observation column the rule evaluated (e.g. temp_c).",
+        nullable: false
+      },
+      { name: "flag", description: "", nullable: false },
+      { name: "ingestion_id", description: "", nullable: true },
+      { name: "observation_kind", description: "", nullable: true },
+      { name: "observed_at", description: "", nullable: false },
+      { name: "parser_name", description: "", nullable: true },
+      { name: "qc_system", description: "", nullable: false },
+      { name: "qc_version", description: "", nullable: false },
+      { name: "rule_id", description: "", nullable: false },
+      { name: "source", description: "", nullable: false },
+      { name: "station_code", description: "", nullable: false }
+    ]
+  }
+]);
+function deepFreezeSchema(info) {
+  const frozenCols = Object.freeze(info.columns.map((c) => Object.freeze({ ...c })));
+  return Object.freeze({ ...info, columns: frozenCols });
+}
+var REGISTRY = new Map(
+  BUILT_IN_SCHEMAS.map((info) => [info.id, deepFreezeSchema(info)])
+);
+function registerSchema(info) {
+  REGISTRY.set(info.id, deepFreezeSchema(info));
+}
+function describe(schemaId) {
+  const info = REGISTRY.get(schemaId);
+  if (info === void 0) {
+    const known = [...REGISTRY.keys()].sort();
+    throw new UnknownSchemaError(
+      `Unknown schemaId ${JSON.stringify(schemaId)}; registered: ${known.length === 0 ? "<none>" : known.join(", ")}`
+    );
+  }
+  const lines = [`Schema: ${info.id}`, `  Title: ${info.title}`, `  Columns: ${info.columnCount}`];
+  for (const col of info.columns) {
+    const nullable = col.nullable ? "?" : "";
+    const desc = col.description.length === 0 ? "" : ` \u2014 ${col.description}`;
+    lines.push(`    - ${col.name}${nullable}${desc}`);
+  }
+  return lines.join("\n");
+}
+var UnknownSchemaError = class extends TradewindsError {
+  constructor(message) {
+    super(message);
+    this.name = "UnknownSchemaError";
+  }
+  static defaultErrorCode = "UNKNOWN_SCHEMA";
+};
+var FEATURE_NAMES = Object.freeze([
+  "calendarFeatures",
+  "clipOutliers",
+  "diff",
+  "diff2",
+  "heatIndex",
+  "lag",
+  "rolling",
+  "spread",
+  "windChill"
+]);
+function featureCatalog() {
+  return FEATURE_NAMES;
+}
+function climateGaps(_station, _fromDate, _toDate) {
+  throw new ClimateGapsNotImplementedError(
+    "climateGaps is Python-only in v0.1.0; the TS climate cache lands in v0.2"
+  );
+}
+var ClimateGapsNotImplementedError = class extends TradewindsError {
+  constructor(message) {
+    super(message);
+    this.name = "ClimateGapsNotImplementedError";
+  }
+  static defaultErrorCode = "NOT_IMPLEMENTED";
+};
+export {
+  ClimateGapsNotImplementedError,
+  UnknownSchemaError,
+  availability,
+  buildSnapshot,
+  climateGaps,
+  dataVersionForResearch,
+  dataVersionFromComponents,
+  describe,
+  featureCatalog,
+  internationalDailyExtremes,
+  registerSchema
+};
+//# sourceMappingURL=index.mjs.map