@mostlyrightmd/core 0.1.0-rc.7

package/dist/index.cjs

@@ -0,0 +1,1624 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthenticationError: () => AuthenticationError,
+  CLIMATE_REPORT_TYPE_PRIORITY: () => CLIMATE_REPORT_TYPE_PRIORITY,
+  DeferredMarketError: () => DeferredMarketError,
+  ForbiddenError: () => ForbiddenError,
+  LIVE_V1_POLICY: () => LIVE_V1_POLICY,
+  LeakageError: () => LeakageError,
+  LiveStreamError: () => LiveStreamError,
+  NoLiveDataError: () => NoLiveDataError,
+  NotFoundError: () => NotFoundError,
+  OBSERVATION_SOURCE_PRIORITY: () => OBSERVATION_SOURCE_PRIORITY,
+  PayloadTooLargeError: () => PayloadTooLargeError,
+  PolymarketEventError: () => PolymarketEventError,
+  QC_ALPHA_RULES: () => QC_ALPHA_RULES,
+  QC_ALPHA_RULES_BY_ID: () => QC_ALPHA_RULES_BY_ID,
+  RateLimitError: () => RateLimitError,
+  STATIONS: () => STATIONS,
+  STATION_BY_CODE: () => STATION_BY_CODE,
+  STATION_BY_ICAO: () => STATION_BY_ICAO,
+  SchemaValidationError: () => SchemaValidationError,
+  ServerError: () => ServerError,
+  SourceMismatchError: () => SourceMismatchError,
+  SourceUnavailableError: () => SourceUnavailableError,
+  TemporalDriftError: () => TemporalDriftError,
+  TherminalError: () => TherminalError,
+  TradewindsError: () => TradewindsError,
+  ValidationError: () => ValidationError,
+  _CLI_PUBLICATION_DELAY_HOURS: () => _CLI_PUBLICATION_DELAY_HOURS,
+  _JAN_REF: () => _JAN_REF,
+  _MARKET_CLOSE_HOUR_LST: () => _MARKET_CLOSE_HOUR_LST,
+  _MARKET_CLOSE_MINUTE_LST: () => _MARKET_CLOSE_MINUTE_LST,
+  _STATION_TZ: () => _STATION_TZ,
+  _lstOffsetHours: () => _lstOffsetHours,
+  _resolveStationTz: () => _resolveStationTz,
+  cliAvailableAt: () => cliAvailableAt,
+  fetchWithRetry: () => fetchWithRetry,
+  helloCore: () => helloCore,
+  marketCloseUtc: () => marketCloseUtc,
+  settlementDateFor: () => settlementDateFor,
+  settlementWindowUtc: () => settlementWindowUtc,
+  toJsonSafe: () => toJsonSafe,
+  version: () => version
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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/data/generated/source-priority.ts
+var OBSERVATION_SOURCE_PRIORITY = {
+  awc: 3,
+  ghcnh: 1,
+  iem: 2
+};
+var CLIMATE_REPORT_TYPE_PRIORITY = {
+  correction: 2,
+  estimated: 0,
+  final: 3,
+  ncei_final: 2.5,
+  preliminary: 1
+};
+var LIVE_V1_POLICY = {
+  name: "LIVE_V1",
+  secondaryKey: [
+    "source_received_at",
+    "ingestion_id"
+  ],
+  sourcePriority: {
+    awc: 3,
+    ghcnh: 1,
+    iem: 2,
+    ncei: 0
+  }
+};
+
+// src/data/generated/qc-alpha-rules.ts
+var QC_ALPHA_RULES = [
+  {
+    bit_position: 0,
+    description: "Temperature outside [-89C, 57C] (world-record bounds).",
+    field: "temp_c",
+    rule_id: "temp_c.out_of_range"
+  },
+  {
+    bit_position: 1,
+    description: "Dewpoint greater than temperature (physically impossible).",
+    field: "dew_point_c",
+    rule_id: "dew_point_c.exceeds_temp"
+  },
+  {
+    bit_position: 2,
+    description: "Wind speed negative.",
+    field: "wind_speed_ms",
+    rule_id: "wind_speed_ms.negative"
+  },
+  {
+    bit_position: 3,
+    description: "Wind direction outside [0, 360].",
+    field: "wind_dir_deg",
+    rule_id: "wind_dir_deg.out_of_range"
+  },
+  {
+    bit_position: 4,
+    description: "Sea-level pressure outside [870, 1085] mb.",
+    field: "slp_hpa",
+    rule_id: "slp_hpa.out_of_range"
+  }
+];
+var QC_ALPHA_RULES_BY_ID = /* @__PURE__ */ new Map([
+  ["temp_c.out_of_range", QC_ALPHA_RULES[0]],
+  ["dew_point_c.exceeds_temp", QC_ALPHA_RULES[1]],
+  ["wind_speed_ms.negative", QC_ALPHA_RULES[2]],
+  ["wind_dir_deg.out_of_range", QC_ALPHA_RULES[3]],
+  ["slp_hpa.out_of_range", QC_ALPHA_RULES[4]]
+]);
+
+// 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;
+  }
+};
+var SourceUnavailableError = class extends TradewindsError {
+  static defaultErrorCode = "SOURCE_UNAVAILABLE";
+  httpStatus;
+  retryable;
+  retryAfterS;
+  underlying;
+  url;
+  constructor(message = "", options = {}) {
+    super(message, options);
+    this.httpStatus = options.httpStatus ?? null;
+    this.retryable = options.retryable ?? false;
+    this.retryAfterS = options.retryAfterS ?? null;
+    this.underlying = options.underlying ?? "";
+    this.url = options.url ?? null;
+  }
+  payload() {
+    return {
+      ...super.payload(),
+      http_status: this.httpStatus,
+      retryable: this.retryable,
+      retry_after_s: this.retryAfterS,
+      underlying: this.underlying,
+      url: this.url
+    };
+  }
+};
+var SchemaValidationError = class extends TradewindsError {
+  static defaultErrorCode = "SCHEMA_VALIDATION_FAILED";
+  schemaId;
+  violations;
+  quarantineCount;
+  sampleViolations;
+  constructor(message, options) {
+    super(message, options);
+    this.schemaId = options.schemaId;
+    this.violations = [...options.violations ?? []];
+    this.quarantineCount = options.quarantineCount ?? 0;
+    this.sampleViolations = [...options.sampleViolations ?? []];
+  }
+  payload() {
+    return {
+      ...super.payload(),
+      schema_id: this.schemaId,
+      violations: this.violations,
+      quarantine_count: this.quarantineCount,
+      sample_violations: this.sampleViolations
+    };
+  }
+};
+var SourceMismatchError = class extends TradewindsError {
+  static defaultErrorCode = "SOURCE_MISMATCH";
+  /** Canonical role-name vocabulary (design.md §R). */
+  static VALID_ROLES = /* @__PURE__ */ new Set([
+    "observations",
+    "forecasts",
+    "settlement"
+  ]);
+  schemaSource;
+  dataSource;
+  role;
+  catalogWarning;
+  constructor(message, options) {
+    super(message, options);
+    this.schemaSource = options.schemaSource;
+    this.dataSource = options.dataSource;
+    this.role = options.role ?? null;
+    this.catalogWarning = options.catalogWarning ?? null;
+  }
+  payload() {
+    return {
+      ...super.payload(),
+      schema_source: this.schemaSource,
+      data_source: this.dataSource,
+      role: this.role,
+      catalog_warning: this.catalogWarning
+    };
+  }
+};
+var LeakageError = class extends TradewindsError {
+  static defaultErrorCode = "LEAKAGE_DETECTED";
+  asOf;
+  violatingCount;
+  sampleViolations;
+  constructor(message, options) {
+    super(message, options);
+    this.asOf = options.asOf;
+    this.violatingCount = options.violatingCount;
+    this.sampleViolations = [...options.sampleViolations ?? []];
+  }
+  payload() {
+    return {
+      ...super.payload(),
+      as_of: this.asOf,
+      violating_count: this.violatingCount,
+      sample_violations: this.sampleViolations
+    };
+  }
+};
+var TemporalDriftError = class extends TradewindsError {
+  static defaultErrorCode = "TEMPORAL_DRIFT";
+  schemaId;
+  assertedRange;
+  violatingRows;
+  sampleViolations;
+  constructor(message, options) {
+    super(message, options);
+    this.schemaId = options.schemaId;
+    this.assertedRange = [options.assertedRange[0], options.assertedRange[1]];
+    this.violatingRows = options.violatingRows;
+    this.sampleViolations = [...options.sampleViolations ?? []];
+  }
+  payload() {
+    return {
+      ...super.payload(),
+      schema_id: this.schemaId,
+      asserted_range: [this.assertedRange[0], this.assertedRange[1]],
+      violating_rows: this.violatingRows,
+      sample_violations: this.sampleViolations
+    };
+  }
+};
+var PayloadTooLargeError = class extends TradewindsError {
+  static defaultErrorCode = "PAYLOAD_TOO_LARGE";
+  declaredSize;
+  limit;
+  acceptedModes;
+  constructor(message, options) {
+    super(message, options);
+    this.declaredSize = options.declaredSize;
+    this.limit = options.limit;
+    this.acceptedModes = [...options.acceptedModes ?? []];
+  }
+  payload() {
+    return {
+      ...super.payload(),
+      declared_size: this.declaredSize,
+      limit: this.limit,
+      accepted_modes: this.acceptedModes
+    };
+  }
+};
+var DeferredMarketError = class extends TradewindsError {
+  static defaultErrorCode = "DEFERRED_MARKET";
+};
+var PolymarketEventError = class extends TradewindsError {
+  static defaultErrorCode = "POLYMARKET_EVENT_INVALID";
+};
+var TherminalError = class extends TradewindsError {
+  static defaultErrorCode = "HTTP_ERROR";
+  statusCode;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.statusCode = options.statusCode ?? null;
+  }
+  payload() {
+    return {
+      ...super.payload(),
+      status_code: this.statusCode
+    };
+  }
+};
+var NotFoundError = class extends TherminalError {
+  static defaultErrorCode = "HTTP_NOT_FOUND";
+  constructor(message = "Resource not found", options = {}) {
+    super(message, { ...options, statusCode: options.statusCode ?? 404 });
+  }
+};
+var RateLimitError = class extends TherminalError {
+  static defaultErrorCode = "HTTP_RATE_LIMITED";
+  retryAfter;
+  constructor(retryAfter = 1, options = {}) {
+    const msg = `Rate limit exceeded. Retry after ${retryAfter ?? "?"}s`;
+    super(msg, { ...options, statusCode: options.statusCode ?? 429 });
+    this.retryAfter = retryAfter;
+  }
+  payload() {
+    return {
+      ...super.payload(),
+      retry_after: this.retryAfter
+    };
+  }
+};
+var ValidationError = class extends TherminalError {
+  static defaultErrorCode = "HTTP_BAD_REQUEST";
+  constructor(message = "Invalid request", options = {}) {
+    super(message, { ...options, statusCode: options.statusCode ?? 400 });
+  }
+};
+var AuthenticationError = class extends TherminalError {
+  static defaultErrorCode = "HTTP_UNAUTHORIZED";
+  constructor(message = "Authentication required", options = {}) {
+    super(message, { ...options, statusCode: options.statusCode ?? 401 });
+  }
+};
+var ForbiddenError = class extends TherminalError {
+  static defaultErrorCode = "HTTP_FORBIDDEN";
+  constructor(message = "Access denied", options = {}) {
+    super(message, { ...options, statusCode: options.statusCode ?? 403 });
+  }
+};
+var ServerError = class extends TherminalError {
+  static defaultErrorCode = "HTTP_SERVER_ERROR";
+  constructor(message = "Server error", options = {}) {
+    super(message, { ...options, statusCode: options.statusCode ?? 500 });
+  }
+};
+var LiveStreamError = class extends TradewindsError {
+  static defaultErrorCode = "LIVE_STREAM_ERROR";
+};
+var NoLiveDataError = class extends LiveStreamError {
+  static defaultErrorCode = "NO_LIVE_DATA";
+  station;
+  constructor(message = "", options) {
+    super(message, { ...options, source: options.source });
+    this.station = options.station;
+  }
+  payload() {
+    return {
+      ...super.payload(),
+      station: this.station
+    };
+  }
+};
+
+// src/snapshot.ts
+var _STATION_TZ = Object.freeze({
+  // Eastern (UTC-5 standard / UTC-4 DST)
+  NYC: "America/New_York",
+  JFK: "America/New_York",
+  LGA: "America/New_York",
+  EWR: "America/New_York",
+  ATL: "America/New_York",
+  BOS: "America/New_York",
+  PHL: "America/New_York",
+  DCA: "America/New_York",
+  IAD: "America/New_York",
+  BWI: "America/New_York",
+  MIA: "America/New_York",
+  MCO: "America/New_York",
+  TPA: "America/New_York",
+  CLT: "America/New_York",
+  RDU: "America/New_York",
+  CLE: "America/New_York",
+  PIT: "America/New_York",
+  BUF: "America/New_York",
+  DTW: "America/Detroit",
+  IND: "America/Indiana/Indianapolis",
+  CVG: "America/New_York",
+  CMH: "America/New_York",
+  SYR: "America/New_York",
+  ALB: "America/New_York",
+  BTV: "America/New_York",
+  ORF: "America/New_York",
+  RIC: "America/New_York",
+  GSO: "America/New_York",
+  CHS: "America/New_York",
+  SAV: "America/New_York",
+  JAX: "America/New_York",
+  RSW: "America/New_York",
+  PBI: "America/New_York",
+  FLL: "America/New_York",
+  // Central (UTC-6 standard / UTC-5 DST)
+  ORD: "America/Chicago",
+  MDW: "America/Chicago",
+  DFW: "America/Chicago",
+  DAL: "America/Chicago",
+  IAH: "America/Chicago",
+  HOU: "America/Chicago",
+  MSP: "America/Chicago",
+  STL: "America/Chicago",
+  MCI: "America/Chicago",
+  OMA: "America/Chicago",
+  MKE: "America/Chicago",
+  MSY: "America/Chicago",
+  MEM: "America/Chicago",
+  BNA: "America/Chicago",
+  OKC: "America/Chicago",
+  SAT: "America/Chicago",
+  AUS: "America/Chicago",
+  DSM: "America/Chicago",
+  TUL: "America/Chicago",
+  LIT: "America/Chicago",
+  BIR: "America/Chicago",
+  SDF: "America/Chicago",
+  HSV: "America/Chicago",
+  BHM: "America/Chicago",
+  MOB: "America/Chicago",
+  BTR: "America/Chicago",
+  SHV: "America/Chicago",
+  // Mountain (UTC-7 standard / UTC-6 DST)
+  DEN: "America/Denver",
+  SLC: "America/Denver",
+  ABQ: "America/Denver",
+  BOI: "America/Boise",
+  BZN: "America/Denver",
+  GJT: "America/Denver",
+  // Arizona: no DST (UTC-7 always)
+  PHX: "America/Phoenix",
+  TUS: "America/Phoenix",
+  // Pacific (UTC-8 standard / UTC-7 DST)
+  LAX: "America/Los_Angeles",
+  SFO: "America/Los_Angeles",
+  SEA: "America/Los_Angeles",
+  PDX: "America/Los_Angeles",
+  LAS: "America/Los_Angeles",
+  SAN: "America/Los_Angeles",
+  OAK: "America/Los_Angeles",
+  SJC: "America/Los_Angeles",
+  SMF: "America/Los_Angeles",
+  RNO: "America/Los_Angeles",
+  FAT: "America/Los_Angeles",
+  SNA: "America/Los_Angeles",
+  ONT: "America/Los_Angeles",
+  BUR: "America/Los_Angeles",
+  // Alaska (UTC-9 standard / UTC-8 DST)
+  ANC: "America/Anchorage",
+  FAI: "America/Anchorage",
+  JNU: "America/Juneau",
+  // Hawaii (UTC-10, no DST)
+  HNL: "Pacific/Honolulu",
+  OGG: "Pacific/Honolulu",
+  KOA: "Pacific/Honolulu",
+  // International (iter-6 H12): minimal set required to un-skip the
+  // case-5 RJTT year-wrap cache behavior test. Python's
+  // `mostlyright.snapshot._resolve_tz` falls back to the broader STATIONS
+  // registry for intl ICAOs; the TS port hasn't ported that fallback
+  // yet (tracked as TS-W6 — exhaustive intl-station tz coverage). This
+  // entry closes H12 cleanly without pulling the whole STATIONS map in.
+  // ICAO key (RJTT) — international stations have no 3-letter NWS code.
+  // Tokyo Haneda — UTC+9 LST, no DST.
+  RJTT: "Asia/Tokyo"
+});
+var _JAN_REF = new Date(Date.UTC(2024, 0, 15, 12, 0, 0));
+var _CLI_PUBLICATION_DELAY_HOURS = 10;
+var _MARKET_CLOSE_HOUR_LST = 16;
+var _MARKET_CLOSE_MINUTE_LST = 30;
+var _OFFSET_CACHE = /* @__PURE__ */ new Map();
+function _lstOffsetHours(stationTz) {
+  const cached = _OFFSET_CACHE.get(stationTz);
+  if (cached !== void 0) return cached;
+  const fmt = new Intl.DateTimeFormat("en-US", {
+    timeZone: stationTz,
+    hour12: false,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  const parts = fmt.formatToParts(_JAN_REF);
+  const get = (type) => {
+    const part = parts.find((p) => p.type === type);
+    if (!part) {
+      throw new Error(`Intl.DateTimeFormat missing ${type} for tz=${stationTz}`);
+    }
+    return Number(part.value);
+  };
+  const year = get("year");
+  const month = get("month");
+  const day = get("day");
+  let hour = get("hour");
+  const minute = get("minute");
+  const second = get("second");
+  if (hour === 24) hour = 0;
+  const localAsUtc = Date.UTC(year, month - 1, day, hour, minute, second);
+  const offsetMs = localAsUtc - _JAN_REF.getTime();
+  const offsetHours = offsetMs / 36e5;
+  _OFFSET_CACHE.set(stationTz, offsetHours);
+  return offsetHours;
+}
+function _stationCodeNormalized(station) {
+  const s = station.trim().toUpperCase();
+  if (s.length === 4 && s.startsWith("K")) {
+    return s.substring(1);
+  }
+  return s;
+}
+function _resolveStationTz(station, tzOverride) {
+  if (tzOverride) return tzOverride;
+  const code = _stationCodeNormalized(station);
+  const tz = _STATION_TZ[code];
+  if (tz) return tz;
+  throw new Error(
+    `Unknown station timezone: ${JSON.stringify(code)}. Add it to _STATION_TZ or pass tzOverride="America/...".`
+  );
+}
+function _parseAsOf(asOf) {
+  if (asOf instanceof Date) {
+    if (Number.isNaN(asOf.getTime())) {
+      throw new Error("Invalid Date passed as asOf");
+    }
+    return asOf;
+  }
+  let s = asOf.trim();
+  if (s.endsWith("Z")) {
+  } else if (!/[+-]\d{2}:?\d{2}$/.test(s)) {
+    s = `${s}Z`;
+  }
+  const ms = Date.parse(s);
+  if (!Number.isFinite(ms)) {
+    throw new Error(`Invalid as_of string: ${JSON.stringify(asOf)}`);
+  }
+  return new Date(ms);
+}
+function _pad2(n) {
+  return n < 10 ? `0${n}` : `${n}`;
+}
+function _isoDate(year, month, day) {
+  return `${year}-${_pad2(month)}-${_pad2(day)}`;
+}
+function settlementDateFor(asOf, station, tzOverride) {
+  const utcDt = _parseAsOf(asOf);
+  const tz = _resolveStationTz(station, tzOverride);
+  const offsetHours = _lstOffsetHours(tz);
+  const lstMs = utcDt.getTime() + offsetHours * 36e5;
+  const lst = new Date(lstMs);
+  return _isoDate(lst.getUTCFullYear(), lst.getUTCMonth() + 1, lst.getUTCDate());
+}
+function settlementWindowUtc(dateStr, station, tzOverride) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(dateStr);
+  if (!match) {
+    throw new Error(`Invalid ISO date for settlement window: ${JSON.stringify(dateStr)}`);
+  }
+  const [, yStr, mStr, dStr] = match;
+  const year = Number(yStr);
+  const month = Number(mStr);
+  const day = Number(dStr);
+  const tz = _resolveStationTz(station, tzOverride);
+  const offsetHours = _lstOffsetHours(tz);
+  const midnightLstAsUtcMs = Date.UTC(year, month - 1, day, 0, 0, 0);
+  const startMs = midnightLstAsUtcMs - offsetHours * 36e5;
+  const start = new Date(startMs);
+  const end = new Date(startMs + 24 * 36e5);
+  return [start, end];
+}
+function cliAvailableAt(dateStr, station, delayHours = _CLI_PUBLICATION_DELAY_HOURS, tzOverride) {
+  const [, windowEnd] = settlementWindowUtc(dateStr, station, tzOverride);
+  return new Date(windowEnd.getTime() + delayHours * 36e5);
+}
+function marketCloseUtc(dateStr, station, tzOverride) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(dateStr);
+  if (!match) {
+    throw new Error(`Invalid ISO date for market close: ${JSON.stringify(dateStr)}`);
+  }
+  const [, yStr, mStr, dStr] = match;
+  const year = Number(yStr);
+  const month = Number(mStr);
+  const day = Number(dStr);
+  const tz = _resolveStationTz(station, tzOverride);
+  const offsetHours = _lstOffsetHours(tz);
+  const marketCloseAsUtcMs = Date.UTC(
+    year,
+    month - 1,
+    day,
+    _MARKET_CLOSE_HOUR_LST,
+    _MARKET_CLOSE_MINUTE_LST,
+    0
+  );
+  return new Date(marketCloseAsUtcMs - offsetHours * 36e5);
+}
+
+// src/internal/http.ts
+var DEFAULT_BASE_DELAY_MS = 1e3;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_TIMEOUT_MS = 6e4;
+var DEFAULT_RETRY_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var MAX_RETRY_AFTER_MS = 12e4;
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      cleanup();
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    const cleanup = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function parseRetryAfter(header) {
+  if (!header) return null;
+  const asInt = Number(header);
+  if (Number.isFinite(asInt) && asInt >= 0) return asInt;
+  const dateMs = Date.parse(header);
+  if (Number.isFinite(dateMs)) {
+    return Math.max(0, Math.round((dateMs - Date.now()) / 1e3));
+  }
+  return null;
+}
+function throwForNonRetryableStatus(status, url, retryAfter) {
+  if (status === 404) {
+    throw new NotFoundError(`HTTP 404 for ${url}`);
+  }
+  if (status === 400) {
+    throw new ValidationError(`HTTP 400 for ${url}`);
+  }
+  if (status === 401) {
+    throw new AuthenticationError(`HTTP 401 for ${url}`);
+  }
+  if (status === 403) {
+    throw new ForbiddenError(`HTTP 403 for ${url}`);
+  }
+  if (status === 429) {
+    throw new RateLimitError(retryAfter, { source: url });
+  }
+  if (status >= 500 && status < 600) {
+    throw new ServerError(`HTTP ${status} for ${url}`, { statusCode: status });
+  }
+  throw new TherminalError(`HTTP ${status} for ${url}`, { statusCode: status });
+}
+async function fetchWithRetry(url, opts = {}) {
+  const baseDelay = opts.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+  const maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const retryStatuses = opts.retryStatuses ?? DEFAULT_RETRY_STATUSES;
+  const headers = { ...opts.headers ?? {} };
+  if (opts.userAgent && !("user-agent" in lowercaseKeys(headers))) {
+    headers["User-Agent"] = opts.userAgent;
+  }
+  let lastError = null;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    const attemptController = new AbortController();
+    const timeoutHandle = setTimeout(() => attemptController.abort(), timeoutMs);
+    const onParentAbort = () => attemptController.abort();
+    if (opts.signal) {
+      if (opts.signal.aborted) {
+        clearTimeout(timeoutHandle);
+        throw new DOMException("Aborted", "AbortError");
+      }
+      opts.signal.addEventListener("abort", onParentAbort, { once: true });
+    }
+    try {
+      const init = {
+        method: opts.method ?? "GET",
+        headers,
+        signal: attemptController.signal
+      };
+      if (opts.body !== void 0 && opts.body !== null) {
+        init.body = opts.body;
+      }
+      const response = await fetch(url, init);
+      if (response.status === 404) {
+        throw new NotFoundError(`HTTP 404 for ${url}`);
+      }
+      if (retryStatuses.has(response.status)) {
+        const retryAfterHeader = parseRetryAfter(response.headers.get("retry-after"));
+        if (attempt < maxRetries - 1) {
+          const jitter = baseDelay * 2 ** attempt * Math.random() * 0.25;
+          const delayMs = baseDelay * 2 ** attempt + jitter;
+          const sleepMs = retryAfterHeader !== null ? Math.min(retryAfterHeader * 1e3, MAX_RETRY_AFTER_MS) : delayMs;
+          await sleep(sleepMs, opts.signal);
+          continue;
+        }
+        throwForNonRetryableStatus(response.status, url, retryAfterHeader);
+      }
+      if (response.status >= 400) {
+        const retryAfterHeader = parseRetryAfter(response.headers.get("retry-after"));
+        throwForNonRetryableStatus(response.status, url, retryAfterHeader);
+      }
+      return response;
+    } catch (err) {
+      if (err instanceof TherminalError && !(err instanceof ServerError) && !(err instanceof RateLimitError)) {
+        throw err;
+      }
+      if (opts.signal?.aborted) {
+        throw err;
+      }
+      lastError = err;
+      if (attempt < maxRetries - 1) {
+        const jitter = baseDelay * 2 ** attempt * Math.random() * 0.25;
+        const delayMs = baseDelay * 2 ** attempt + jitter;
+        await sleep(delayMs, opts.signal);
+        continue;
+      }
+      if (err instanceof TherminalError) throw err;
+      throw new TherminalError(`fetch failed after ${maxRetries} attempts: ${describeError(err)}`, {
+        source: url
+      });
+    } finally {
+      clearTimeout(timeoutHandle);
+      opts.signal?.removeEventListener("abort", onParentAbort);
+    }
+  }
+  if (lastError instanceof Error) throw lastError;
+  throw new TherminalError(`fetch failed: ${describeError(lastError)}`, { source: url });
+}
+function describeError(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+function lowercaseKeys(obj) {
+  const out = {};
+  for (const k of Object.keys(obj)) {
+    out[k.toLowerCase()] = obj[k];
+  }
+  return out;
+}
+
+// src/index.ts
+var version = "0.0.0";
+function helloCore() {
+  return "hello @mostlyrightmd/core";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  CLIMATE_REPORT_TYPE_PRIORITY,
+  DeferredMarketError,
+  ForbiddenError,
+  LIVE_V1_POLICY,
+  LeakageError,
+  LiveStreamError,
+  NoLiveDataError,
+  NotFoundError,
+  OBSERVATION_SOURCE_PRIORITY,
+  PayloadTooLargeError,
+  PolymarketEventError,
+  QC_ALPHA_RULES,
+  QC_ALPHA_RULES_BY_ID,
+  RateLimitError,
+  STATIONS,
+  STATION_BY_CODE,
+  STATION_BY_ICAO,
+  SchemaValidationError,
+  ServerError,
+  SourceMismatchError,
+  SourceUnavailableError,
+  TemporalDriftError,
+  TherminalError,
+  TradewindsError,
+  ValidationError,
+  _CLI_PUBLICATION_DELAY_HOURS,
+  _JAN_REF,
+  _MARKET_CLOSE_HOUR_LST,
+  _MARKET_CLOSE_MINUTE_LST,
+  _STATION_TZ,
+  _lstOffsetHours,
+  _resolveStationTz,
+  cliAvailableAt,
+  fetchWithRetry,
+  helloCore,
+  marketCloseUtc,
+  settlementDateFor,
+  settlementWindowUtc,
+  toJsonSafe,
+  version
+});
+//# sourceMappingURL=index.cjs.map