mostlyright 1.1.2 → 1.2.0

package/dist/index.global.js

@@ -962,7 +962,7 @@ var mostlyright = (() => {
     }
     return { _repr_only: true, value: String(value) };
   }
-  var TradewindsError, SourceUnavailableError, SchemaValidationError, SourceMismatchError, LeakageError, TemporalDriftError, PayloadTooLargeError, DeferredMarketError, PolymarketEventError, TherminalError, NotFoundError, RateLimitError, ValidationError, AuthenticationError, ForbiddenError, ServerError, LiveStreamError, NoLiveDataError;
+  var TradewindsError, SourceUnavailableError, DATA_AVAILABILITY_REASONS, DataAvailabilityError, SchemaValidationError, SourceMismatchError, LeakageError, TemporalDriftError, PayloadTooLargeError, DeferredMarketError, PolymarketEventError, TherminalError, NotFoundError, RateLimitError, ValidationError, AuthenticationError, ForbiddenError, ServerError, LiveStreamError, NoLiveDataError;
   var init_exceptions = __esm({
     "../core/src/exceptions/index.ts"() {
       "use strict";
@@ -1026,6 +1026,40 @@ var mostlyright = (() => {
           };
         }
       };
+      DATA_AVAILABILITY_REASONS = [
+        "model_unavailable",
+        "out_of_window",
+        "cache_miss",
+        "source_404",
+        "source_5xx",
+        "rate_limited"
+      ];
+      DataAvailabilityError = class extends TradewindsError {
+        static defaultErrorCode = "DATA_AVAILABILITY";
+        reason;
+        hint;
+        constructor(options) {
+          if (!DATA_AVAILABILITY_REASONS.includes(options.reason)) {
+            throw new RangeError(
+              `DataAvailabilityError: unknown reason "${String(options.reason)}". Valid reasons: ${DATA_AVAILABILITY_REASONS.join(", ")}`
+            );
+          }
+          if (typeof options.hint !== "string" || options.hint.length === 0) {
+            throw new TypeError("DataAvailabilityError: hint is required and must be a non-empty string");
+          }
+          const message = `[${options.reason}] ${options.hint}`;
+          super(message, options);
+          this.reason = options.reason;
+          this.hint = options.hint;
+        }
+        payload() {
+          return {
+            ...super.payload(),
+            reason: this.reason,
+            hint: this.hint
+          };
+        }
+      };
       SchemaValidationError = class extends TradewindsError {
         static defaultErrorCode = "SCHEMA_VALIDATION_FAILED";
         schemaId;
@@ -1212,7 +1246,7 @@ var mostlyright = (() => {
       NoLiveDataError = class extends LiveStreamError {
         static defaultErrorCode = "NO_LIVE_DATA";
         station;
-        constructor(message = "", options) {
+        constructor(message, options) {
           super(message, { ...options, source: options.source });
           this.station = options.station;
         }
@@ -1628,6 +1662,8 @@ var mostlyright = (() => {
   __export(src_exports, {
     AuthenticationError: () => AuthenticationError,
     CLIMATE_REPORT_TYPE_PRIORITY: () => CLIMATE_REPORT_TYPE_PRIORITY,
+    DATA_AVAILABILITY_REASONS: () => DATA_AVAILABILITY_REASONS,
+    DataAvailabilityError: () => DataAvailabilityError,
     DeferredMarketError: () => DeferredMarketError,
     ForbiddenError: () => ForbiddenError,
     LIVE_V1_POLICY: () => LIVE_V1_POLICY,
@@ -2322,8 +2358,8 @@ var mostlyright = (() => {
         const key = header[c];
         row[key] = (cells[c] ?? "").trim();
       }
-      const obs = iemToObservation(row, opts);
-      if (obs !== null) out.push(obs);
+      const obs2 = iemToObservation(row, opts);
+      if (obs2 !== null) out.push(obs2);
     }
     return out;
   }
@@ -2348,6 +2384,7 @@ var mostlyright = (() => {
     MODE2_SOURCES: () => MODE2_SOURCES,
     NoLiveDataError: () => NoLiveDataError,
     POLITE_FLOORS_S: () => POLITE_FLOORS_S,
+    Preprocessing: () => Preprocessing,
     SELECTOR_NAMES: () => SELECTOR_NAMES,
     SOURCE_ALIASES: () => SOURCE_ALIASES,
     SOURCE_IDENTITY_TAGS: () => SOURCE_IDENTITY_TAGS,
@@ -2356,6 +2393,7 @@ var mostlyright = (() => {
     assertSourceIdentity: () => assertSourceIdentity,
     buildOverrideWarning: () => buildOverrideWarning,
     core: () => src_exports,
+    dailyExtremes: () => dailyExtremes,
     discover: () => discover,
     helloCore: () => helloCore,
     helloMarkets: () => helloMarkets,
@@ -2364,6 +2402,8 @@ var mostlyright = (() => {
     isMode2Source: () => isMode2Source,
     latest: () => latest,
     markets: () => src_exports3,
+    obs: () => obs,
+    preprocessing: () => preprocessing_exports,
     research: () => research,
     researchBySource: () => researchBySource,
     resolveCity: () => resolveCity,
@@ -2401,6 +2441,7 @@ var mostlyright = (() => {
     SUPPORTED_SOURCES: () => SUPPORTED_SOURCES,
     awcToObservation: () => awcToObservation,
     buildIemUrl: () => buildIemUrl,
+    dailyExtremes: () => dailyExtremes,
     downloadCli: () => downloadCli,
     downloadCliRange: () => downloadCliRange,
     downloadGhcnh: () => downloadGhcnh,
@@ -2419,12 +2460,14 @@ var mostlyright = (() => {
     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,
@@ -2626,10 +2669,10 @@ var mostlyright = (() => {
     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) {
@@ -3005,8 +3048,8 @@ var mostlyright = (() => {
         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;
   }
@@ -3075,8 +3118,8 @@ var mostlyright = (() => {
     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);
@@ -3084,9 +3127,9 @@ var mostlyright = (() => {
     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;
@@ -3142,8 +3185,8 @@ var mostlyright = (() => {
       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));
       }
     }
@@ -3355,14 +3398,1394 @@ var mostlyright = (() => {
         }
       }
     }
-    return rows;
+    return rows;
+  }
+
+  // ../weather/src/forecasts/nwp-stub.ts
+  init_src();
+  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)
+    });
+  }
+
+  // ../weather/src/dailyExtremes.ts
+  init_src();
+
+  // ../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
+  init_iem_asos();
+  init_awc();
+  init_iem();
+  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/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."
+  // ../weather/src/obs.ts
+  init_src();
+  init_iem_asos();
+  init_awc();
+  init_iem();
+  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
@@ -4057,10 +5480,11 @@ var mostlyright = (() => {
     }
   }));
 
-  // ../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();
@@ -4207,7 +5631,71 @@ var mostlyright = (() => {
       return next;
     }
   };
-  var STATIONS2 = [
+  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, version5) {
+      if (typeof version5 !== "string" || version5.length === 0) {
+        throw new TypeError("versionedCacheStore: version must be a non-empty string");
+      }
+      this.#inner = inner;
+      this.#version = version5;
+    }
+    /**
+     * 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, version5) {
+    return new VersionedCacheStore(inner, version5);
+  }
+  var STATIONS3 = [
     {
       code: "EDDB",
       country: "DE",
@@ -4819,131 +6307,131 @@ var mostlyright = (() => {
       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_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", 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 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_TZ2 = Object.freeze({
     // Eastern (UTC-5 standard / UTC-4 DST)
@@ -5090,13 +6578,13 @@ var mostlyright = (() => {
   }
   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 _lstOffsetHours2(byCode.tz);
-    const byIcao = STATION_BY_ICAO2.get(upper);
+    const byIcao = STATION_BY_ICAO3.get(upper);
     if (byIcao !== void 0) return _lstOffsetHours2(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 _lstOffsetHours2(retry.tz);
     }
     throw new RangeError(`unknown station: ${JSON.stringify(station)}`);
@@ -5168,8 +6656,8 @@ var mostlyright = (() => {
 
   // ../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
@@ -5355,9 +6843,9 @@ var mostlyright = (() => {
     );
     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);
     }
@@ -5452,13 +6940,68 @@ var mostlyright = (() => {
   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) {
@@ -5726,9 +7269,9 @@ var mostlyright = (() => {
           }
         }
       }
-      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;
@@ -5799,14 +7342,22 @@ var mostlyright = (() => {
           }
         }
       }
-      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;
@@ -5882,8 +7433,8 @@ var mostlyright = (() => {
       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(
@@ -5914,8 +7465,8 @@ var mostlyright = (() => {
     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];
@@ -5923,7 +7474,7 @@ var mostlyright = (() => {
         bucket = [];
         observationsByDate[settleDate] = bucket;
       }
-      bucket.push(obs);
+      bucket.push(obs2);
     }
     const climateByDate = {};
     for (const cli of mergedClimate) {
@@ -6058,8 +7609,8 @@ var mostlyright = (() => {
         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);
@@ -6351,6 +7902,129 @@ var mostlyright = (() => {
 
   // src/index.ts
   init_src();
+
+  // ../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 version4 = "0.0.0";
   return __toCommonJS(index_exports);
 })();