mostlyright 1.1.2 → 1.2.0

package/dist/index.bundle.mjs

@@ -4,12 +4,14 @@ import {
   buildIemUrl,
   downloadIemAsos,
   yearlyChunksExclusiveEnd
-} from "./chunk-465FJZTS.mjs";
+} from "./chunk-64FNXDHG.mjs";
 import {
   CLIMATE_REPORT_TYPE_PRIORITY,
+  DataAvailabilityError,
   LiveStreamError,
   NoLiveDataError,
   NotFoundError,
+  STATIONS,
   STATION_BY_CODE,
   STATION_BY_ICAO,
   SourceMismatchError,
@@ -18,7 +20,7 @@ import {
   helloCore,
   settlementDateFor,
   src_exports
-} from "./chunk-IN2UOZYO.mjs";
+} from "./chunk-WKPNA46C.mjs";
 import {
   awcToObservation,
   celsiusToFahrenheit,
@@ -72,6 +74,7 @@ __export(src_exports2, {
   SUPPORTED_SOURCES: () => SUPPORTED_SOURCES,
   awcToObservation: () => awcToObservation,
   buildIemUrl: () => buildIemUrl,
+  dailyExtremes: () => dailyExtremes,
   downloadCli: () => downloadCli,
   downloadCliRange: () => downloadCliRange,
   downloadGhcnh: () => downloadGhcnh,
@@ -90,12 +93,14 @@ __export(src_exports2, {
   latest: () => latest,
   mapCloudCover: () => mapCloudCover,
   mergeClimate: () => mergeClimate,
+  obs: () => obs,
   parseAwcVisibility: () => parseAwcVisibility,
   parseCliRecord: () => parseCliRecord,
   parseCliResponse: () => parseCliResponse,
   parseGhcnhPsv: () => parseGhcnhPsv,
   parseGhcnhRow: () => parseGhcnhRow,
   parseIemCsv: () => parseIemCsv,
+  resolveAutoStrategy: () => resolveAutoStrategy,
   sourceTag: () => sourceTag,
   stream: () => stream,
   validatePollSeconds: () => validatePollSeconds,
@@ -289,10 +294,10 @@ function inferReportType(product, observationDate) {
   if (!product) return "preliminary";
   const issued = parseProductTimestamp(product);
   if (issued === null) return "preliminary";
-  const obs = parseObservationDate(observationDate);
-  if (obs === null) return "preliminary";
+  const obs2 = parseObservationDate(observationDate);
+  if (obs2 === null) return "preliminary";
   const issuedDayUtc = Date.UTC(issued.getUTCFullYear(), issued.getUTCMonth(), issued.getUTCDate());
-  const obsDayUtc = obs.getTime();
+  const obsDayUtc = obs2.getTime();
   const deltaDays = Math.round((issuedDayUtc - obsDayUtc) / 864e5);
   if (deltaDays <= 0) return "preliminary";
   if (deltaDays === 1) {
@@ -655,8 +660,8 @@ function parseGhcnhPsv(psvBody) {
       const key = header[c];
       row[key] = c < cells.length ? cells[c] : "";
     }
-    const obs = parseGhcnhRow(row);
-    if (obs !== null) out.push(obs);
+    const obs2 = parseGhcnhRow(row);
+    if (obs2 !== null) out.push(obs2);
   }
   return out;
 }
@@ -719,8 +724,8 @@ function normalizeStation(station) {
   if (s.length === 3) return `K${s}`;
   return s;
 }
-function asLiveObservation(obs, tag) {
-  return { ...obs, source: tag };
+function asLiveObservation(obs2, tag) {
+  return { ...obs2, source: tag };
 }
 async function fetchAwcLatest(station) {
   const icao = normalizeStation(station);
@@ -728,9 +733,9 @@ async function fetchAwcLatest(station) {
   const tag = sourceTag("awc");
   const rows = [];
   for (const m of raw) {
-    const obs = awcToObservation(m);
-    if (obs !== null) {
-      rows.push(asLiveObservation(obs, tag));
+    const obs2 = awcToObservation(m);
+    if (obs2 !== null) {
+      rows.push(asLiveObservation(obs2, tag));
     }
   }
   return rows;
@@ -762,9 +767,9 @@ function previousDayIso(iso) {
 }
 async function fetchIemLatest(station) {
   const [{ fetchWithRetry: fetchWithRetry2 }, { STATION_CODE_RE: STATION_CODE_RE3 }, { buildIemUrl: buildIemUrl2 }, { parseIemCsv: parseIemCsv2 }] = await Promise.all([
-    import("./src-NP2MZ322.mjs"),
+    import("./src-BBELB6SP.mjs"),
     import("./bounds-KSTXL77E.mjs"),
-    import("./iem-asos-ZPUMH3KM.mjs"),
+    import("./iem-asos-2D5EP2FT.mjs"),
     import("./iem-IO2HIL5V.mjs")
   ]);
   const icao = normalizeStation(station);
@@ -786,8 +791,8 @@ async function fetchIemLatest(station) {
     const response = await fetchWithRetry2(url);
     const csv = await response.text();
     const override = reportType === 3 ? "METAR" : "SPECI";
-    const obs = parseIemCsv2(csv, { observationTypeOverride: override });
-    for (const row of obs) {
+    const obs2 = parseIemCsv2(csv, { observationTypeOverride: override });
+    for (const row of obs2) {
       rows.push(asLiveObservation(row, tag));
     }
   }
@@ -1000,10 +1005,1379 @@ async function iemMosForecasts(station, fromDate, toDate, opts = {}) {
 }
 
 // ../weather/src/forecasts/nwp-stub.ts
-async function forecastNwp(_station, _model, _opts = {}) {
-  throw new Error(
-    "forecastNwp: TS NWP deferred to v1.1 per CONTEXT decision 7. Browser GRIB2 decode is not production-ready in May 2026; the v1.0 TS forecast surface ships iemMosForecasts() only. Use the Python SDK's mostlyright.forecast_nwp() for NWP in v1.0."
+var IEM_MOS_COVERED_STATIONS = /* @__PURE__ */ new Set([
+  "KNYC",
+  "KLAX",
+  "KORD",
+  "KMIA",
+  "KDEN",
+  "KSEA",
+  "KATL"
+]);
+function buildHint(station, model) {
+  const hasMosCoverage = IEM_MOS_COVERED_STATIONS.has(station.toUpperCase());
+  const mosLine = hasMosCoverage ? `Workaround for ${station}: iemMosForecasts("${station}", ...) is available (IEM MOS catalog covers this station).` : `Workaround: this station has no IEM MOS coverage; use the Python SDK's mostlyright.forecast_nwp() in v1.x.`;
+  return `forecastNwp(${station}, "${model}") is a v1.x stub. Browser GRIB2 decode is not production-ready in May 2026 (no eccodes / cfgrib equivalent for the browser; WASM compile time + bundle size make it impractical for v1.x). ${mosLine} See https://mostlyright.md/docs/sdk/typescript/forecasts#typescript-lane for the architectural reason + v1.1+ tracking.`;
+}
+async function forecastNwp(station, model, _opts = {}) {
+  throw new DataAvailabilityError({
+    reason: "model_unavailable",
+    source: "nwp-stub",
+    hint: buildHint(station, model)
+  });
+}
+
+// ../core/dist/discovery/index.mjs
+var STATIONS2 = [
+  {
+    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_CODE2 = /* @__PURE__ */ new Map([
+  ["ATL", STATIONS2[10]],
+  ["AUS", STATIONS2[11]],
+  ["BOS", STATIONS2[12]],
+  ["DCA", STATIONS2[13]],
+  ["DEN", STATIONS2[14]],
+  ["DFW", STATIONS2[15]],
+  ["EDDB", STATIONS2[0]],
+  ["EDDF", STATIONS2[1]],
+  ["EDDM", STATIONS2[2]],
+  ["EFHK", STATIONS2[3]],
+  ["EGKK", STATIONS2[4]],
+  ["EGLL", STATIONS2[5]],
+  ["EHAM", STATIONS2[6]],
+  ["EKCH", STATIONS2[7]],
+  ["EPWA", STATIONS2[8]],
+  ["ESSA", STATIONS2[9]],
+  ["HOU", STATIONS2[16]],
+  ["LAS", STATIONS2[17]],
+  ["LAX", STATIONS2[18]],
+  ["LEBL", STATIONS2[30]],
+  ["LEMD", STATIONS2[31]],
+  ["LFPB", STATIONS2[32]],
+  ["LFPG", STATIONS2[33]],
+  ["LFPO", STATIONS2[34]],
+  ["LIMC", STATIONS2[35]],
+  ["LIRF", STATIONS2[36]],
+  ["LOWW", STATIONS2[37]],
+  ["LSZH", STATIONS2[38]],
+  ["MDW", STATIONS2[19]],
+  ["MIA", STATIONS2[20]],
+  ["MSP", STATIONS2[21]],
+  ["MSY", STATIONS2[22]],
+  ["NYC", STATIONS2[23]],
+  ["NZAA", STATIONS2[39]],
+  ["NZWN", STATIONS2[40]],
+  ["OERK", STATIONS2[41]],
+  ["OKC", STATIONS2[24]],
+  ["OMDB", STATIONS2[42]],
+  ["OTHH", STATIONS2[43]],
+  ["PHL", STATIONS2[25]],
+  ["PHX", STATIONS2[26]],
+  ["RCTP", STATIONS2[44]],
+  ["RJAA", STATIONS2[45]],
+  ["RJTT", STATIONS2[46]],
+  ["RKSI", STATIONS2[47]],
+  ["SAEZ", STATIONS2[48]],
+  ["SAT", STATIONS2[27]],
+  ["SBGR", STATIONS2[49]],
+  ["SEA", STATIONS2[28]],
+  ["SFO", STATIONS2[29]],
+  ["UUEE", STATIONS2[50]],
+  ["VABB", STATIONS2[51]],
+  ["VHHH", STATIONS2[52]],
+  ["VIDP", STATIONS2[53]],
+  ["VTBS", STATIONS2[54]],
+  ["WSSS", STATIONS2[55]],
+  ["YBBN", STATIONS2[56]],
+  ["YMML", STATIONS2[57]],
+  ["YSSY", STATIONS2[58]],
+  ["ZBAA", STATIONS2[59]],
+  ["ZSPD", STATIONS2[60]]
+]);
+var STATION_BY_ICAO2 = /* @__PURE__ */ new Map([
+  ["EDDB", STATIONS2[0]],
+  ["EDDF", STATIONS2[1]],
+  ["EDDM", STATIONS2[2]],
+  ["EFHK", STATIONS2[3]],
+  ["EGKK", STATIONS2[4]],
+  ["EGLL", STATIONS2[5]],
+  ["EHAM", STATIONS2[6]],
+  ["EKCH", STATIONS2[7]],
+  ["EPWA", STATIONS2[8]],
+  ["ESSA", STATIONS2[9]],
+  ["KATL", STATIONS2[10]],
+  ["KAUS", STATIONS2[11]],
+  ["KBOS", STATIONS2[12]],
+  ["KDCA", STATIONS2[13]],
+  ["KDEN", STATIONS2[14]],
+  ["KDFW", STATIONS2[15]],
+  ["KHOU", STATIONS2[16]],
+  ["KLAS", STATIONS2[17]],
+  ["KLAX", STATIONS2[18]],
+  ["KMDW", STATIONS2[19]],
+  ["KMIA", STATIONS2[20]],
+  ["KMSP", STATIONS2[21]],
+  ["KMSY", STATIONS2[22]],
+  ["KNYC", STATIONS2[23]],
+  ["KOKC", STATIONS2[24]],
+  ["KPHL", STATIONS2[25]],
+  ["KPHX", STATIONS2[26]],
+  ["KSAT", STATIONS2[27]],
+  ["KSEA", STATIONS2[28]],
+  ["KSFO", STATIONS2[29]],
+  ["LEBL", STATIONS2[30]],
+  ["LEMD", STATIONS2[31]],
+  ["LFPB", STATIONS2[32]],
+  ["LFPG", STATIONS2[33]],
+  ["LFPO", STATIONS2[34]],
+  ["LIMC", STATIONS2[35]],
+  ["LIRF", STATIONS2[36]],
+  ["LOWW", STATIONS2[37]],
+  ["LSZH", STATIONS2[38]],
+  ["NZAA", STATIONS2[39]],
+  ["NZWN", STATIONS2[40]],
+  ["OERK", STATIONS2[41]],
+  ["OMDB", STATIONS2[42]],
+  ["OTHH", STATIONS2[43]],
+  ["RCTP", STATIONS2[44]],
+  ["RJAA", STATIONS2[45]],
+  ["RJTT", STATIONS2[46]],
+  ["RKSI", STATIONS2[47]],
+  ["SAEZ", STATIONS2[48]],
+  ["SBGR", STATIONS2[49]],
+  ["UUEE", STATIONS2[50]],
+  ["VABB", STATIONS2[51]],
+  ["VHHH", STATIONS2[52]],
+  ["VIDP", STATIONS2[53]],
+  ["VTBS", STATIONS2[54]],
+  ["WSSS", STATIONS2[55]],
+  ["YBBN", STATIONS2[56]],
+  ["YMML", STATIONS2[57]],
+  ["YSSY", STATIONS2[58]],
+  ["ZBAA", STATIONS2[59]],
+  ["ZSPD", STATIONS2[60]]
+]);
+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;
+}
+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)])
+);
+var FEATURE_NAMES = Object.freeze([
+  "calendarFeatures",
+  "clipOutliers",
+  "diff",
+  "diff2",
+  "heatIndex",
+  "lag",
+  "rolling",
+  "spread",
+  "windChill"
+]);
+
+// ../weather/src/dailyExtremes.ts
+var LOW_COVERAGE_THRESHOLD2 = 12;
+function addUtcDays(iso, days) {
+  const [yStr, mStr, dStr] = iso.split("-");
+  const dt = new Date(Date.UTC(Number(yStr), Number(mStr) - 1, Number(dStr)));
+  dt.setUTCDate(dt.getUTCDate() + days);
+  const yyyy = dt.getUTCFullYear();
+  const mm = String(dt.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(dt.getUTCDate()).padStart(2, "0");
+  return `${yyyy}-${mm}-${dd}`;
+}
+function lookupStation(icao) {
+  const upper = icao.toUpperCase();
+  for (const s of STATIONS) {
+    if (s.icao === upper) {
+      return { tz: s.tz, isUs: s.country === "US" };
+    }
+  }
+  throw new Error(`dailyExtremes: station "${icao}" not in registry \u2014 check STATIONS catalog`);
+}
+function cToF2(c) {
+  if (c === null) return null;
+  return c * (9 / 5) + 32;
+}
+function roundHalfUp2(value, decimals) {
+  const m = 10 ** decimals;
+  return Math.round(value * m) / m;
+}
+async function fetchIemAsosObservations(station, fromDate, toDate) {
+  const fromYear = Number.parseInt(fromDate.slice(0, 4), 10);
+  const toYear = Number.parseInt(toDate.slice(0, 4), 10);
+  const out = [];
+  for (let year = fromYear; year <= toYear; year++) {
+    const chunks = await downloadIemAsos(station, `${year}-01-01`, `${year}-12-31`, {
+      reportType: 3,
+      politenessMs: 1e3
+    });
+    for (const chunk of chunks) {
+      const parsed = parseIemCsv(chunk.csv, { observationTypeOverride: "METAR" });
+      for (const row of parsed) {
+        const obsDate = row.observed_at.slice(0, 10);
+        if (obsDate >= fromDate && obsDate <= toDate) {
+          const precipInches = row.precip_1hr_inches ?? null;
+          out.push({
+            observed_at: row.observed_at,
+            temp_c: row.temp_c ?? null,
+            precip_mm_1h: precipInches !== null ? precipInches * 25.4 : null,
+            source: row.source
+          });
+        }
+      }
+    }
+  }
+  return out;
+}
+async function fetchAwcObservations(station, fromDate, toDate) {
+  const raw = await fetchAwcMetars([station]);
+  const out = [];
+  for (const r of raw) {
+    const obs2 = awcToObservation(r);
+    if (obs2 === null) continue;
+    const obsDate = obs2.observed_at.slice(0, 10);
+    if (obsDate >= fromDate && obsDate <= toDate) {
+      const precipInches = obs2.precip_1hr_inches ?? null;
+      out.push({
+        observed_at: obs2.observed_at,
+        temp_c: obs2.temp_c ?? null,
+        precip_mm_1h: precipInches !== null ? precipInches * 25.4 : null,
+        source: obs2.source
+      });
+    }
+  }
+  return out;
+}
+async function fetchForMode(station, fromDate, toDate, mode) {
+  switch (mode) {
+    case "iem_only":
+      return fetchIemAsosObservations(station, fromDate, toDate);
+    case "awc_only":
+      return fetchAwcObservations(station, fromDate, toDate);
+    case "live_v1": {
+      const [iem, awc] = await Promise.all([
+        fetchIemAsosObservations(station, fromDate, toDate),
+        fetchAwcObservations(station, fromDate, toDate).catch(() => [])
+      ]);
+      return [...iem, ...awc];
+    }
+    default: {
+      const _exhaustive = mode;
+      throw new TypeError(`dailyExtremes: unknown merge mode "${String(_exhaustive)}"`);
+    }
+  }
+}
+function projectRow(station, d, isUs) {
+  const lowCoverage = d.nObs < LOW_COVERAGE_THRESHOLD2;
+  const decimals = isUs ? 0 : 1;
+  const precipIn = d.precipMm !== null && d.precipMm !== void 0 ? roundHalfUp2(d.precipMm / 25.4, 2) : null;
+  if (lowCoverage) {
+    return {
+      date: d.localDate,
+      station,
+      tmin_f: null,
+      tmax_f: null,
+      tmean_f: null,
+      precip_in: precipIn,
+      low_coverage: true,
+      n_obs: d.nObs
+    };
+  }
+  return {
+    date: d.localDate,
+    station,
+    tmin_f: d.tempMinF !== null ? roundHalfUp2(d.tempMinF, decimals) : null,
+    tmax_f: d.tempMaxF !== null ? roundHalfUp2(d.tempMaxF, decimals) : null,
+    tmean_f: d.tempMeanC !== null ? roundHalfUp2(cToF2(d.tempMeanC), decimals) : null,
+    precip_in: precipIn,
+    low_coverage: false,
+    n_obs: d.nObs
+  };
+}
+async function dailyExtremes(station, fromDate, toDate, opts = {}) {
+  const { tz, isUs } = lookupStation(station);
+  const merge = opts.merge ?? "live_v1";
+  const fetchFrom = addUtcDays(fromDate, -1);
+  const fetchTo = addUtcDays(toDate, 1);
+  const rows = await fetchForMode(station, fetchFrom, fetchTo, merge);
+  const extremes = internationalDailyExtremes(rows, {
+    stationTz: tz,
+    precision: isUs ? 1 : 0
+  });
+  return extremes.filter((d) => d.localDate >= fromDate && d.localDate <= toDate).map((d) => projectRow(station.toUpperCase(), d, isUs));
+}
+
+// ../weather/src/obs.ts
+function daysBetween(fromDate, toDate) {
+  const from = Date.UTC(
+    Number.parseInt(fromDate.slice(0, 4), 10),
+    Number.parseInt(fromDate.slice(5, 7), 10) - 1,
+    Number.parseInt(fromDate.slice(8, 10), 10)
+  );
+  const to = Date.UTC(
+    Number.parseInt(toDate.slice(0, 4), 10),
+    Number.parseInt(toDate.slice(5, 7), 10) - 1,
+    Number.parseInt(toDate.slice(8, 10), 10)
   );
+  return Math.round((to - from) / (24 * 60 * 60 * 1e3)) + 1;
+}
+function resolveAutoStrategy(fromDate, toDate) {
+  return daysBetween(fromDate, toDate) <= 7 ? "exact_window" : "warm_cache";
+}
+function inchesToMm(inches) {
+  if (inches === null || inches === void 0) return null;
+  return inches * 25.4;
+}
+function mbToInhg(mb) {
+  if (mb === null || mb === void 0) return null;
+  return mb * 0.029529983071445;
+}
+function fromObservation(o) {
+  const tempC = o.temp_c ?? null;
+  const dewC = o.dewpoint_c ?? null;
+  return {
+    station: o.station_code,
+    observed_at: o.observed_at,
+    source: o.source,
+    temp_c: tempC,
+    temp_f: tempC !== null ? tempC * (9 / 5) + 32 : null,
+    dewpoint_c: dewC,
+    dewpoint_f: dewC !== null ? dewC * (9 / 5) + 32 : null,
+    wind_speed_kts: o.wind_speed_kt ?? null,
+    wind_direction_deg: o.wind_dir_degrees ?? null,
+    pressure_inhg: mbToInhg(o.sea_level_pressure_mb),
+    precip_mm_1h: inchesToMm(o.precip_1hr_inches),
+    raw_metar: o.raw_metar ?? null
+  };
+}
+async function fetchIemForWindow(station, fromDate, toDate, resolvedStrategy) {
+  const out = [];
+  if (resolvedStrategy === "exact_window") {
+    const chunks = await downloadIemAsos(station, fromDate, toDate, {
+      reportType: 3,
+      politenessMs: 1e3
+    });
+    for (const chunk of chunks) {
+      const rows = parseIemCsv(chunk.csv, { observationTypeOverride: "METAR" });
+      for (const r of rows) {
+        const d = r.observed_at.slice(0, 10);
+        if (d >= fromDate && d <= toDate) out.push(fromObservation(r));
+      }
+    }
+    return out;
+  }
+  const fromYear = Number.parseInt(fromDate.slice(0, 4), 10);
+  const toYear = Number.parseInt(toDate.slice(0, 4), 10);
+  for (let year = fromYear; year <= toYear; year++) {
+    const chunks = await downloadIemAsos(station, `${year}-01-01`, `${year}-12-31`, {
+      reportType: 3,
+      politenessMs: 1e3
+    });
+    for (const chunk of chunks) {
+      const rows = parseIemCsv(chunk.csv, { observationTypeOverride: "METAR" });
+      for (const r of rows) {
+        const d = r.observed_at.slice(0, 10);
+        if (d >= fromDate && d <= toDate) out.push(fromObservation(r));
+      }
+    }
+  }
+  return out;
+}
+async function fetchAwcForWindow(station, fromDate, toDate) {
+  const raw = await fetchAwcMetars([station]);
+  const out = [];
+  for (const r of raw) {
+    const obs2 = awcToObservation(r);
+    if (obs2 === null) continue;
+    const d = obs2.observed_at.slice(0, 10);
+    if (d >= fromDate && d <= toDate) out.push(fromObservation(obs2));
+  }
+  return out;
+}
+async function fetchByStrategy(station, fromDate, toDate, resolvedStrategy, source) {
+  const wantsIem = source === null || source === void 0 || source === "iem";
+  const wantsAwc = source === null || source === void 0 || source === "awc";
+  const tasks = [];
+  if (wantsIem) tasks.push(fetchIemForWindow(station, fromDate, toDate, resolvedStrategy));
+  if (wantsAwc) tasks.push(fetchAwcForWindow(station, fromDate, toDate).catch(() => []));
+  const results = await Promise.all(tasks);
+  return results.flat();
+}
+async function obs(station, fromDate, toDate, opts = {}) {
+  const strategy = opts.strategy ?? "auto";
+  const source = opts.source ?? null;
+  if (source === "ghcnh") {
+    throw new DataAvailabilityError({
+      reason: "model_unavailable",
+      source: "obs.ghcnh",
+      hint: "source='ghcnh' is a valid Python `obs()` filter but the GHCNh fetcher path is not yet wired in the TypeScript SDK. Use source='iem' or source='awc' (or omit `source` for merged) until the TS GHCNh fetcher ships."
+    });
+  }
+  if (strategy === "hosted") {
+    throw new DataAvailabilityError({
+      reason: "model_unavailable",
+      source: "obs-hosted-stub",
+      hint: "hosted ingest API ships in v0.2.x \u2014 use strategy='exact_window' or 'warm_cache' for v1.x. See https://mostlyright.md/docs/sdk/typescript/ingest-strategies"
+    });
+  }
+  let resolved;
+  if (strategy === "auto") {
+    resolved = resolveAutoStrategy(fromDate, toDate);
+  } else if (strategy === "exact_window" || strategy === "warm_cache") {
+    resolved = strategy;
+  } else {
+    throw new TypeError(
+      `obs: unknown strategy "${String(strategy)}" \u2014 expected one of: auto, exact_window, warm_cache, hosted`
+    );
+  }
+  return fetchByStrategy(station, fromDate, toDate, resolved, source);
 }
 
 // ../weather/src/index.ts
@@ -1692,10 +3066,11 @@ replaceTraps((oldTraps) => ({
   }
 }));
 
-// ../core/dist/internal/chunk-PKJXHY27.mjs
+// ../core/dist/internal/chunk-IPC4XUYW.mjs
 function lockKeyFor(key) {
   return `mostlyright:cache:lock:${key}`;
 }
+var CACHE_SCHEMA_VERSION = "v2-phase18-integer-f";
 var MemoryStore = class {
   #entries = /* @__PURE__ */ new Map();
   #chain = /* @__PURE__ */ new Map();
@@ -1842,7 +3217,71 @@ var IndexedDBStore = class {
     return next;
   }
 };
-var STATIONS = [
+var VERSION_FIELD = "_cache_schema_version";
+function isVersionedEntry(v) {
+  if (v === null || typeof v !== "object") return false;
+  if (!(VERSION_FIELD in v)) return false;
+  return typeof v[VERSION_FIELD] === "string";
+}
+function hasListKeys(s) {
+  return typeof s.listKeys === "function";
+}
+var VersionedCacheStore = class {
+  #inner;
+  #version;
+  constructor(inner, version4) {
+    if (typeof version4 !== "string" || version4.length === 0) {
+      throw new TypeError("versionedCacheStore: version must be a non-empty string");
+    }
+    this.#inner = inner;
+    this.#version = version4;
+  }
+  /**
+   * Test/diagnostics seam: return the underlying store so tests can assert
+   * which concrete backend `defaultCacheStore()` selected. NOT a production
+   * API — production code MUST use the wrapped store so version
+   * invalidation fires on stale reads.
+   *
+   * @internal
+   */
+  __peekInner() {
+    return this.#inner;
+  }
+  async get(key) {
+    const raw = await this.#inner.get(key);
+    if (raw === null) return null;
+    if (!isVersionedEntry(raw)) {
+      return null;
+    }
+    if (raw._cache_schema_version !== this.#version) {
+      return null;
+    }
+    return raw.value;
+  }
+  async set(key, value, opts) {
+    const wrapped = {
+      value,
+      [VERSION_FIELD]: this.#version
+    };
+    await this.#inner.set(key, wrapped, opts);
+  }
+  async delete(key) {
+    await this.#inner.delete(key);
+  }
+  async withLock(key, fn) {
+    return this.#inner.withLock(key, fn);
+  }
+  async listKeys(prefix) {
+    if (hasListKeys(this.#inner)) {
+      return this.#inner.listKeys(prefix);
+    }
+    return Object.freeze([]);
+  }
+};
+function versionedCacheStore(inner, version4) {
+  return new VersionedCacheStore(inner, version4);
+}
+var STATIONS3 = [
   {
     code: "EDDB",
     country: "DE",
@@ -2454,131 +3893,131 @@ var STATIONS = [
     tz: "Asia/Shanghai"
   }
 ];
-var STATION_BY_CODE2 = /* @__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_CODE3 = /* @__PURE__ */ new Map([
+  ["ATL", STATIONS3[10]],
+  ["AUS", STATIONS3[11]],
+  ["BOS", STATIONS3[12]],
+  ["DCA", STATIONS3[13]],
+  ["DEN", STATIONS3[14]],
+  ["DFW", STATIONS3[15]],
+  ["EDDB", STATIONS3[0]],
+  ["EDDF", STATIONS3[1]],
+  ["EDDM", STATIONS3[2]],
+  ["EFHK", STATIONS3[3]],
+  ["EGKK", STATIONS3[4]],
+  ["EGLL", STATIONS3[5]],
+  ["EHAM", STATIONS3[6]],
+  ["EKCH", STATIONS3[7]],
+  ["EPWA", STATIONS3[8]],
+  ["ESSA", STATIONS3[9]],
+  ["HOU", STATIONS3[16]],
+  ["LAS", STATIONS3[17]],
+  ["LAX", STATIONS3[18]],
+  ["LEBL", STATIONS3[30]],
+  ["LEMD", STATIONS3[31]],
+  ["LFPB", STATIONS3[32]],
+  ["LFPG", STATIONS3[33]],
+  ["LFPO", STATIONS3[34]],
+  ["LIMC", STATIONS3[35]],
+  ["LIRF", STATIONS3[36]],
+  ["LOWW", STATIONS3[37]],
+  ["LSZH", STATIONS3[38]],
+  ["MDW", STATIONS3[19]],
+  ["MIA", STATIONS3[20]],
+  ["MSP", STATIONS3[21]],
+  ["MSY", STATIONS3[22]],
+  ["NYC", STATIONS3[23]],
+  ["NZAA", STATIONS3[39]],
+  ["NZWN", STATIONS3[40]],
+  ["OERK", STATIONS3[41]],
+  ["OKC", STATIONS3[24]],
+  ["OMDB", STATIONS3[42]],
+  ["OTHH", STATIONS3[43]],
+  ["PHL", STATIONS3[25]],
+  ["PHX", STATIONS3[26]],
+  ["RCTP", STATIONS3[44]],
+  ["RJAA", STATIONS3[45]],
+  ["RJTT", STATIONS3[46]],
+  ["RKSI", STATIONS3[47]],
+  ["SAEZ", STATIONS3[48]],
+  ["SAT", STATIONS3[27]],
+  ["SBGR", STATIONS3[49]],
+  ["SEA", STATIONS3[28]],
+  ["SFO", STATIONS3[29]],
+  ["UUEE", STATIONS3[50]],
+  ["VABB", STATIONS3[51]],
+  ["VHHH", STATIONS3[52]],
+  ["VIDP", STATIONS3[53]],
+  ["VTBS", STATIONS3[54]],
+  ["WSSS", STATIONS3[55]],
+  ["YBBN", STATIONS3[56]],
+  ["YMML", STATIONS3[57]],
+  ["YSSY", STATIONS3[58]],
+  ["ZBAA", STATIONS3[59]],
+  ["ZSPD", STATIONS3[60]]
 ]);
-var STATION_BY_ICAO2 = /* @__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]]
+var STATION_BY_ICAO3 = /* @__PURE__ */ new Map([
+  ["EDDB", STATIONS3[0]],
+  ["EDDF", STATIONS3[1]],
+  ["EDDM", STATIONS3[2]],
+  ["EFHK", STATIONS3[3]],
+  ["EGKK", STATIONS3[4]],
+  ["EGLL", STATIONS3[5]],
+  ["EHAM", STATIONS3[6]],
+  ["EKCH", STATIONS3[7]],
+  ["EPWA", STATIONS3[8]],
+  ["ESSA", STATIONS3[9]],
+  ["KATL", STATIONS3[10]],
+  ["KAUS", STATIONS3[11]],
+  ["KBOS", STATIONS3[12]],
+  ["KDCA", STATIONS3[13]],
+  ["KDEN", STATIONS3[14]],
+  ["KDFW", STATIONS3[15]],
+  ["KHOU", STATIONS3[16]],
+  ["KLAS", STATIONS3[17]],
+  ["KLAX", STATIONS3[18]],
+  ["KMDW", STATIONS3[19]],
+  ["KMIA", STATIONS3[20]],
+  ["KMSP", STATIONS3[21]],
+  ["KMSY", STATIONS3[22]],
+  ["KNYC", STATIONS3[23]],
+  ["KOKC", STATIONS3[24]],
+  ["KPHL", STATIONS3[25]],
+  ["KPHX", STATIONS3[26]],
+  ["KSAT", STATIONS3[27]],
+  ["KSEA", STATIONS3[28]],
+  ["KSFO", STATIONS3[29]],
+  ["LEBL", STATIONS3[30]],
+  ["LEMD", STATIONS3[31]],
+  ["LFPB", STATIONS3[32]],
+  ["LFPG", STATIONS3[33]],
+  ["LFPO", STATIONS3[34]],
+  ["LIMC", STATIONS3[35]],
+  ["LIRF", STATIONS3[36]],
+  ["LOWW", STATIONS3[37]],
+  ["LSZH", STATIONS3[38]],
+  ["NZAA", STATIONS3[39]],
+  ["NZWN", STATIONS3[40]],
+  ["OERK", STATIONS3[41]],
+  ["OMDB", STATIONS3[42]],
+  ["OTHH", STATIONS3[43]],
+  ["RCTP", STATIONS3[44]],
+  ["RJAA", STATIONS3[45]],
+  ["RJTT", STATIONS3[46]],
+  ["RKSI", STATIONS3[47]],
+  ["SAEZ", STATIONS3[48]],
+  ["SBGR", STATIONS3[49]],
+  ["UUEE", STATIONS3[50]],
+  ["VABB", STATIONS3[51]],
+  ["VHHH", STATIONS3[52]],
+  ["VIDP", STATIONS3[53]],
+  ["VTBS", STATIONS3[54]],
+  ["WSSS", STATIONS3[55]],
+  ["YBBN", STATIONS3[56]],
+  ["YMML", STATIONS3[57]],
+  ["YSSY", STATIONS3[58]],
+  ["ZBAA", STATIONS3[59]],
+  ["ZSPD", STATIONS3[60]]
 ]);
 var _STATION_TZ = Object.freeze({
   // Eastern (UTC-5 standard / UTC-4 DST)
@@ -2725,13 +4164,13 @@ function _lstOffsetHours(stationTz) {
 }
 function _lstOffsetHoursFor(station) {
   const upper = station.trim().toUpperCase();
-  const byCode = STATION_BY_CODE2.get(upper);
+  const byCode = STATION_BY_CODE3.get(upper);
   if (byCode !== void 0) return _lstOffsetHours(byCode.tz);
-  const byIcao = STATION_BY_ICAO2.get(upper);
+  const byIcao = STATION_BY_ICAO3.get(upper);
   if (byIcao !== void 0) return _lstOffsetHours(byIcao.tz);
   if (upper.length === 4 && upper.startsWith("K")) {
     const stripped = upper.slice(1);
-    const retry = STATION_BY_CODE2.get(stripped);
+    const retry = STATION_BY_CODE3.get(stripped);
     if (retry !== void 0) return _lstOffsetHours(retry.tz);
   }
   throw new RangeError(`unknown station: ${JSON.stringify(station)}`);
@@ -2803,8 +4242,8 @@ function cacheKeyForClimate(station, year) {
 
 // ../core/dist/internal/cache/index.browser.mjs
 async function defaultCacheStore() {
-  if (typeof indexedDB !== "undefined") return new IndexedDBStore();
-  return new MemoryStore();
+  const inner = typeof indexedDB !== "undefined" ? new IndexedDBStore() : new MemoryStore();
+  return versionedCacheStore(inner, CACHE_SCHEMA_VERSION);
 }
 
 // ../core/dist/internal/pairs.mjs
@@ -2990,9 +4429,9 @@ function marketCloseUtc(dateStr, station, tzOverride) {
   );
   return new Date(marketCloseAsUtcMs - offsetHours * 36e5);
 }
-function collectNonNull(obs, key) {
+function collectNonNull(obs2, key) {
   const out = [];
-  for (const o of obs) {
+  for (const o of obs2) {
     const v = o[key];
     if (typeof v === "number" && Number.isFinite(v)) out.push(v);
   }
@@ -3087,13 +4526,68 @@ function buildPairsRow(dateStr, station, observations, climate, opts = {}) {
 function buildPairs(station, dates, observationsByDate, climateByDate, opts = {}) {
   const out = [];
   for (const date of dates) {
-    const obs = observationsByDate[date] ?? [];
+    const obs2 = observationsByDate[date] ?? [];
     const climate = climateByDate[date] ?? null;
-    out.push(buildPairsRow(date, station, obs, climate, opts));
+    out.push(buildPairsRow(date, station, obs2, climate, opts));
   }
   return Object.freeze(out);
 }
 
+// src/research.types.ts
+var KNOWN_RESEARCH_OPTION_KEYS = /* @__PURE__ */ new Set([
+  // Pre-Phase-21 fetcher controls.
+  "signal",
+  "awcHours",
+  "iemPolitenessMs",
+  "ghcnhPolitenessMs",
+  "cliPolitenessMs",
+  "now",
+  "cache",
+  // Pre-Phase-21 selectors.
+  "city",
+  "contract",
+  "contracts",
+  "stationOverride",
+  "sources",
+  "source",
+  "includeTrades",
+  "onWarning",
+  // Phase 21 21-01: Python-parity composable kwargs.
+  "include_forecast",
+  "forecast_model",
+  "forecast_models",
+  "qc",
+  "tz_override",
+  "backend",
+  "return_type"
+]);
+function validateResearchKwargs(opts) {
+  const present = (v) => v !== void 0 && v !== null;
+  for (const key of Object.keys(opts)) {
+    if (!KNOWN_RESEARCH_OPTION_KEYS.has(key)) {
+      throw new TypeError(
+        `research(): unknown option key ${JSON.stringify(key)}. Valid keys: ${[...KNOWN_RESEARCH_OPTION_KEYS].sort().join(", ")}`
+      );
+    }
+  }
+  if (present(opts.sources) && present(opts.source)) {
+    throw new TypeError(
+      "research(): sources= and source= are mutually exclusive \u2014 use `sources=` for the LIVE_V1 multi-source selector or `source=` for a single-source query, not both"
+    );
+  }
+  if (present(opts.forecast_model) && present(opts.forecast_models)) {
+    throw new TypeError(
+      "research(): forecast_model= and forecast_models= are mutually exclusive \u2014 use `forecast_models=` for multi-model fan-out or `forecast_model=` for a single model, not both"
+    );
+  }
+  const wantsForecast = present(opts.forecast_model) || present(opts.forecast_models);
+  if (wantsForecast && opts.include_forecast !== true) {
+    throw new TypeError(
+      "research(): forecast_model=/forecast_models= require include_forecast=true; the model filter is otherwise silently ignored"
+    );
+  }
+}
+
 // src/research.ts
 var AWC_MAX_HOURS2 = 168;
 async function resolveCache(opts) {
@@ -3361,9 +4855,9 @@ async function fetchIemAsosWithCache(stationCode, _fromYear, _extendedToYear, fr
         }
       }
     }
-    for (const obs of monthRows) {
-      const obsDate = obs.observed_at.slice(0, 10);
-      if (obsDate >= fromDate && obsDate <= extendedTo) acc.push(obs);
+    for (const obs2 of monthRows) {
+      const obsDate = obs2.observed_at.slice(0, 10);
+      if (obsDate >= fromDate && obsDate <= extendedTo) acc.push(obs2);
     }
   }
   return acc;
@@ -3434,14 +4928,22 @@ async function fetchGhcnhWithCache(stationCode, ghcnhId, fromDate, extendedTo, o
         }
       }
     }
-    for (const obs of monthRows) {
-      const obsDate = obs.observed_at.slice(0, 10);
-      if (obsDate >= fromDate && obsDate <= extendedTo) acc.push(obs);
+    for (const obs2 of monthRows) {
+      const obsDate = obs2.observed_at.slice(0, 10);
+      if (obsDate >= fromDate && obsDate <= extendedTo) acc.push(obs2);
     }
   }
   return acc;
 }
 async function research(station, fromDate, toDate, opts = {}) {
+  validateResearchKwargs(opts);
+  if (opts.backend === "polars") {
+    throw new DataAvailabilityError({
+      reason: "model_unavailable",
+      hint: 'polars backend not available in TypeScript SDK; use Python (mostlyrightmd) for backend="polars". TS returns plain object arrays.',
+      source: "research.backend"
+    });
+  }
   const hasCity = typeof opts.city === "string" && opts.city.length > 0;
   const hasContract = typeof opts.contract === "string" && opts.contract.length > 0;
   const hasContracts = Array.isArray(opts.contracts) && opts.contracts.length > 0;
@@ -3517,8 +5019,8 @@ async function research(station, fromDate, toDate, opts = {}) {
     if (opts.signal !== void 0) awcOpts.signal = opts.signal;
     const awcRaw = await fetchAwcMetars([resolved.icao], awcOpts);
     for (const m of awcRaw) {
-      const obs = awcToObservation(m);
-      if (obs !== null) awcRows.push(obs);
+      const obs2 = awcToObservation(m);
+      if (obs2 !== null) awcRows.push(obs2);
     }
   }
   const iemRows = await fetchIemAsosWithCache(
@@ -3549,8 +5051,8 @@ async function research(station, fromDate, toDate, opts = {}) {
   const observationsByDate = {};
   const dateLo = dates[0] ?? "";
   const dateHi = dates[dates.length - 1] ?? "";
-  for (const obs of merged) {
-    const settleDate = observedSettlementDate(obs.observed_at, resolved.code);
+  for (const obs2 of merged) {
+    const settleDate = observedSettlementDate(obs2.observed_at, resolved.code);
     if (settleDate === null) continue;
     if (settleDate < dateLo || settleDate > dateHi) continue;
     let bucket = observationsByDate[settleDate];
@@ -3558,7 +5060,7 @@ async function research(station, fromDate, toDate, opts = {}) {
       bucket = [];
       observationsByDate[settleDate] = bucket;
     }
-    bucket.push(obs);
+    bucket.push(obs2);
   }
   const climateByDate = {};
   for (const cli of mergedClimate) {
@@ -3692,8 +5194,8 @@ async function researchBySource(station, source, fromDate, toDate, opts = {}) {
       const raw = await fetchAwcMetars([resolved.icao], awcOpts);
       const parsed = [];
       for (const m of raw) {
-        const obs = awcToObservation(m);
-        if (obs !== null) parsed.push(obs);
+        const obs2 = awcToObservation(m);
+        if (obs2 !== null) parsed.push(obs2);
       }
       rows = parsed.filter((r) => {
         const d = r.observed_at.slice(0, 10);
@@ -3983,13 +5485,135 @@ function discover(args) {
   });
 }
 
+// ../core/dist/preprocessing/index.mjs
+var preprocessing_exports = {};
+__export(preprocessing_exports, {
+  PHYSICS_BOUNDS: () => PHYSICS_BOUNDS,
+  clipOutliers: () => clipOutliers,
+  iemCrosscheck: () => crosscheckIemGhcnh
+});
+var PHYSICS_BOUNDS = /* @__PURE__ */ new Map([
+  ["temp_c", [-89, 57]],
+  ["dew_point_c", [-89, 35]],
+  ["dewpoint_c", [-89, 35]],
+  ["wind_speed_ms", [0, 100]],
+  ["wind_speed_kt", [0, 200]],
+  ["wind_dir_deg", [0, 360]],
+  ["wind_dir_degrees", [0, 360]],
+  ["slp_hpa", [870, 1085]],
+  ["sea_level_pressure_mb", [870, 1085]],
+  ["relative_humidity_pct_2m", [0, 100]],
+  ["precip_mm_1h", [0, 305]]
+]);
+function clipOutliers(rows, col, opts = {}) {
+  const std = opts.std ?? 3;
+  const key = `${col}_clipped`;
+  let lo;
+  let hi;
+  let passThrough = false;
+  if (opts.bounds !== void 0) {
+    [lo, hi] = opts.bounds;
+  } else if (PHYSICS_BOUNDS.has(col)) {
+    const b = PHYSICS_BOUNDS.get(col);
+    if (b === void 0) {
+      throw new Error(`PHYSICS_BOUNDS.get(${col}) unexpectedly undefined`);
+    }
+    [lo, hi] = b;
+  } else {
+    if (!Number.isFinite(std) || std <= 0) {
+      throw new RangeError(
+        `clipOutliers: std must be > 0 for the sigma fallback (got ${std}); pass bounds=[lo, hi] or use a physics-default column`
+      );
+    }
+    const vals = [];
+    for (const r of rows) {
+      const v = r?.[col];
+      if (typeof v === "number" && Number.isFinite(v)) vals.push(v);
+    }
+    if (vals.length < 2) {
+      passThrough = true;
+      lo = Number.NEGATIVE_INFINITY;
+      hi = Number.POSITIVE_INFINITY;
+    } else {
+      const mu = vals.reduce((a, b) => a + b, 0) / vals.length;
+      const sumSq = vals.reduce((a, b) => a + (b - mu) ** 2, 0);
+      const sigma = Math.sqrt(sumSq / (vals.length - 1));
+      if (sigma === 0 || !Number.isFinite(sigma)) {
+        passThrough = true;
+        lo = Number.NEGATIVE_INFINITY;
+        hi = Number.POSITIVE_INFINITY;
+      } else {
+        lo = mu - std * sigma;
+        hi = mu + std * sigma;
+      }
+    }
+  }
+  const out = [];
+  for (const r of rows) {
+    const v = r?.[col];
+    let clipped;
+    if (typeof v === "number" && Number.isFinite(v)) {
+      clipped = passThrough ? v : Math.min(Math.max(v, lo), hi);
+    } else {
+      clipped = null;
+    }
+    out.push({ ...r, [key]: clipped });
+  }
+  return out;
+}
+function crosscheckIemGhcnh(iemRows, ghcnhRows, opts = {}) {
+  const tolC = opts.tolC ?? 2;
+  if (iemRows.length === 0 || ghcnhRows.length === 0) return [];
+  for (const r of iemRows) {
+    if (typeof r?.station !== "string" || typeof r?.eventTime !== "string") {
+      throw new Error(
+        "crosscheckIemGhcnh: iem rows must carry 'station' (string) and 'eventTime' (string) keys"
+      );
+    }
+  }
+  for (const r of ghcnhRows) {
+    if (typeof r?.station !== "string" || typeof r?.eventTime !== "string") {
+      throw new Error(
+        "crosscheckIemGhcnh: ghcnh rows must carry 'station' (string) and 'eventTime' (string) keys"
+      );
+    }
+  }
+  const iemMap = /* @__PURE__ */ new Map();
+  for (const r of iemRows) {
+    const key = `${r.station}|${r.eventTime}`;
+    iemMap.set(key, r);
+  }
+  const out = [];
+  for (const g of ghcnhRows) {
+    const key = `${g.station}|${g.eventTime}`;
+    const i = iemMap.get(key);
+    if (i === void 0) continue;
+    const iT = typeof i.temp_c === "number" && Number.isFinite(i.temp_c) ? i.temp_c : null;
+    const gT = typeof g.temp_c === "number" && Number.isFinite(g.temp_c) ? g.temp_c : null;
+    if (iT === null || gT === null) continue;
+    const delta = Math.abs(iT - gT);
+    if (delta > tolC) {
+      out.push({
+        station: g.station,
+        eventTime: g.eventTime,
+        tempCIem: iT,
+        tempCGhcnh: gT,
+        deltaC: delta
+      });
+    }
+  }
+  return out;
+}
+
 // src/index.ts
+var Preprocessing = preprocessing_exports;
 var version3 = "0.0.0";
 export {
   LiveStreamError,
   MODE2_SOURCES,
   NoLiveDataError,
   POLITE_FLOORS_S,
+  Preprocessing,
   SELECTOR_NAMES,
   SOURCE_ALIASES,
   SOURCE_IDENTITY_TAGS,
@@ -3998,6 +5622,7 @@ export {
   assertSourceIdentity,
   buildOverrideWarning,
   src_exports as core,
+  dailyExtremes,
   discover,
   helloCore,
   helloMarkets,
@@ -4006,6 +5631,8 @@ export {
   isMode2Source,
   latest,
   src_exports3 as markets,
+  obs,
+  preprocessing_exports as preprocessing,
   research,
   researchBySource,
   resolveCity,