mostlyright 0.1.0-rc.7

package/dist/index.bundle.mjs

@@ -0,0 +1,4033 @@
+import {
+  IEM_BASE_URL,
+  IEM_POLITE_DELAY_MS,
+  buildIemUrl,
+  downloadIemAsos,
+  yearlyChunksExclusiveEnd
+} from "./chunk-UKIFUUDX.mjs";
+import {
+  CLIMATE_REPORT_TYPE_PRIORITY,
+  LiveStreamError,
+  NoLiveDataError,
+  NotFoundError,
+  STATION_BY_CODE,
+  STATION_BY_ICAO,
+  SourceMismatchError,
+  TherminalError,
+  fetchWithRetry,
+  helloCore,
+  settlementDateFor,
+  src_exports
+} from "./chunk-WYZFDCNR.mjs";
+import {
+  awcToObservation,
+  celsiusToFahrenheit,
+  hpaToInhg,
+  icaoToStationCode,
+  iemToObservation,
+  mapCloudCover,
+  parseAwcVisibility,
+  parseIemCsv
+} from "./chunk-6ERO2BIY.mjs";
+import {
+  MAX_RAW_METAR_LEN,
+  MAX_VISIBILITY_MILES,
+  MAX_WX_CODES_LEN,
+  MAX_YEAR,
+  MIN_YEAR,
+  SKY_BASE_MAX_FT,
+  SLP_MAX_MB,
+  SLP_MIN_MB,
+  STATION_CODE_RE,
+  TEMP_MAX_C,
+  TEMP_MIN_C,
+  boundedFloat,
+  boundedFloatMin,
+  boundedInt
+} from "./chunk-VESWR46G.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// ../weather/src/index.ts
+var src_exports2 = {};
+__export(src_exports2, {
+  AWC_MAX_HOURS: () => AWC_MAX_HOURS,
+  AWC_METAR_URL: () => AWC_METAR_URL,
+  GHCNH_BASE_URL: () => GHCNH_BASE_URL,
+  HIGH_TEMP_MAX_F: () => HIGH_TEMP_MAX_F,
+  HIGH_TEMP_MIN_F: () => HIGH_TEMP_MIN_F,
+  IEM_BASE_URL: () => IEM_BASE_URL,
+  IEM_CLI_BASE_URL: () => IEM_CLI_BASE_URL,
+  IEM_CLI_POLITE_DELAY_MS: () => IEM_CLI_POLITE_DELAY_MS,
+  IEM_POLITE_DELAY_MS: () => IEM_POLITE_DELAY_MS,
+  LOW_TEMP_MAX_F: () => LOW_TEMP_MAX_F,
+  LOW_TEMP_MIN_F: () => LOW_TEMP_MIN_F,
+  LiveStreamError: () => LiveStreamError,
+  NCEI_POLITE_DELAY_MS: () => NCEI_POLITE_DELAY_MS,
+  NoLiveDataError: () => NoLiveDataError,
+  POLITE_FLOORS_S: () => POLITE_FLOORS_S,
+  SOURCE_IDENTITY_TAGS: () => SOURCE_IDENTITY_TAGS,
+  SSID_COLUMNS: () => SSID_COLUMNS,
+  SUPPORTED_SOURCES: () => SUPPORTED_SOURCES,
+  awcToObservation: () => awcToObservation,
+  buildIemUrl: () => buildIemUrl,
+  downloadCli: () => downloadCli,
+  downloadCliRange: () => downloadCliRange,
+  downloadGhcnh: () => downloadGhcnh,
+  downloadGhcnhRange: () => downloadGhcnhRange,
+  downloadIemAsos: () => downloadIemAsos,
+  extractStationCode: () => extractStationCode,
+  fetchAwcMetars: () => fetchAwcMetars,
+  forecastNwp: () => forecastNwp,
+  ghcnhStationToCode: () => ghcnhStationToCode,
+  helloWeather: () => helloWeather,
+  icaoToStationCode: () => icaoToStationCode,
+  iemMosForecasts: () => iemMosForecasts,
+  iemToObservation: () => iemToObservation,
+  inferReportType: () => inferReportType,
+  isLiveSource: () => isLiveSource,
+  latest: () => latest,
+  mapCloudCover: () => mapCloudCover,
+  mergeClimate: () => mergeClimate,
+  parseAwcVisibility: () => parseAwcVisibility,
+  parseCliRecord: () => parseCliRecord,
+  parseCliResponse: () => parseCliResponse,
+  parseGhcnhPsv: () => parseGhcnhPsv,
+  parseGhcnhRow: () => parseGhcnhRow,
+  parseIemCsv: () => parseIemCsv,
+  sourceTag: () => sourceTag,
+  stream: () => stream,
+  validatePollSeconds: () => validatePollSeconds,
+  validateSource: () => validateSource,
+  version: () => version,
+  yearlyChunksExclusiveEnd: () => yearlyChunksExclusiveEnd
+});
+
+// ../weather/src/_fetchers/awc.ts
+var AWC_METAR_URL = "https://aviationweather.gov/api/data/metar";
+var AWC_MAX_HOURS = 168;
+async function fetchAwcMetars(stationIcaos, opts = {}) {
+  if (stationIcaos.length === 0) {
+    return [];
+  }
+  const hours = Math.min(opts.hours ?? AWC_MAX_HOURS, AWC_MAX_HOURS);
+  const idsCsv = stationIcaos.map((s) => encodeURIComponent(s)).join(",");
+  const url = `${AWC_METAR_URL}?ids=${idsCsv}&format=json&taf=false&hours=${hours}`;
+  const { hours: _consumed, ...retryOpts } = opts;
+  let response;
+  try {
+    response = await fetchWithRetry(url, retryOpts);
+  } catch (err) {
+    if (err instanceof TherminalError) {
+      return [];
+    }
+    if (err instanceof DOMException && (err.name === "AbortError" || err.name === "TimeoutError")) {
+      if (opts.signal?.aborted) {
+        throw err;
+      }
+      return [];
+    }
+    return [];
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(data)) {
+    return [];
+  }
+  return data;
+}
+
+// ../weather/src/_fetchers/iem-cli.ts
+var IEM_CLI_BASE_URL = "https://mesonet.agron.iastate.edu/json/cli.py";
+var IEM_CLI_POLITE_DELAY_MS = 1e3;
+var STATION_CODE_RE2 = /^[A-Z]{3,4}$/;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function validateIcao(stationIcao) {
+  if (typeof stationIcao !== "string" || !STATION_CODE_RE2.test(stationIcao)) {
+    throw new Error(
+      `station_icao=${JSON.stringify(
+        stationIcao
+      )} does not match STATION_CODE_RE (3-4 uppercase letters); refusing to use as URL component`
+    );
+  }
+}
+function unwrapResults(data) {
+  if (Array.isArray(data)) {
+    return data;
+  }
+  if (data !== null && typeof data === "object" && "results" in data && Array.isArray(data.results)) {
+    return data.results;
+  }
+  throw new Error(
+    `Unexpected IEM CLI response shape: ${data === null ? "null" : Array.isArray(data) ? "array" : typeof data}`
+  );
+}
+async function downloadCli(stationIcao, year, opts = {}) {
+  validateIcao(stationIcao);
+  const url = `${IEM_CLI_BASE_URL}?station=${stationIcao}&year=${year}`;
+  const response = await fetchWithRetry(url, opts);
+  const data = await response.json();
+  return unwrapResults(data);
+}
+async function downloadCliRange(stationIcao, startYear, endYear, opts = {}) {
+  if (endYear < startYear) {
+    throw new Error(`endYear (${endYear}) must be >= startYear (${startYear})`);
+  }
+  validateIcao(stationIcao);
+  const politenessMs = opts.politenessMs ?? IEM_CLI_POLITE_DELAY_MS;
+  const { politenessMs: _drop, ...fetchOpts } = opts;
+  const out = [];
+  for (let year = startYear; year <= endYear; year++) {
+    if (year > startYear && politenessMs > 0) {
+      await sleep(politenessMs);
+    }
+    try {
+      const records = await downloadCli(stationIcao, year, fetchOpts);
+      out.push(...records);
+    } catch (err) {
+      if (err instanceof NotFoundError) {
+        continue;
+      }
+      throw err;
+    }
+  }
+  return out;
+}
+
+// ../core/dist/internal/merge/index.mjs
+var SOURCE_PRIORITY = Object.freeze({
+  awc: 3,
+  iem: 2,
+  ghcnh: 1
+});
+function mergeObservations(rows) {
+  const best = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = `${row.station_code}\0${row.observed_at}\0${row.observation_type}`;
+    const existing = best.get(key);
+    if (existing === void 0) {
+      best.set(key, row);
+      continue;
+    }
+    const priority = SOURCE_PRIORITY[row.source] ?? 0;
+    const existingPriority = SOURCE_PRIORITY[existing.source] ?? 0;
+    if (priority > existingPriority) {
+      best.set(key, row);
+    }
+  }
+  return Array.from(best.values());
+}
+function mergeClimate(rows) {
+  const best = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = `${row.station_code}\0${row.observation_date}`;
+    const existing = best.get(key);
+    if (existing === void 0) {
+      best.set(key, row);
+      continue;
+    }
+    if (row.report_type_priority > existing.report_type_priority) {
+      best.set(key, row);
+    }
+  }
+  return Array.from(best.values());
+}
+
+// ../weather/src/_parsers/cli.ts
+var HIGH_TEMP_MIN_F = -60;
+var HIGH_TEMP_MAX_F = 150;
+var LOW_TEMP_MIN_F = -80;
+var LOW_TEMP_MAX_F = 130;
+var PRODUCT_TS_RE = /^(\d{12})/;
+var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+function parseProductTimestamp(product) {
+  if (!product) return null;
+  const m = PRODUCT_TS_RE.exec(product);
+  if (m === null) return null;
+  const ts = m[1];
+  if (ts === void 0) return null;
+  const year = Number.parseInt(ts.slice(0, 4), 10);
+  const month = Number.parseInt(ts.slice(4, 6), 10);
+  const day = Number.parseInt(ts.slice(6, 8), 10);
+  const hour = Number.parseInt(ts.slice(8, 10), 10);
+  const minute = Number.parseInt(ts.slice(10, 12), 10);
+  if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day) || !Number.isFinite(hour) || !Number.isFinite(minute)) {
+    return null;
+  }
+  if (month < 1 || month > 12 || day < 1 || day > 31 || hour > 23 || minute > 59) {
+    return null;
+  }
+  const millis = Date.UTC(year, month - 1, day, hour, minute, 0, 0);
+  if (!Number.isFinite(millis)) return null;
+  const d = new Date(millis);
+  if (d.getUTCFullYear() !== year || d.getUTCMonth() !== month - 1 || d.getUTCDate() !== day || d.getUTCHours() !== hour || d.getUTCMinutes() !== minute) {
+    return null;
+  }
+  return d;
+}
+function parseObservationDate(observationDate) {
+  if (!DATE_RE.test(observationDate)) return null;
+  const year = Number.parseInt(observationDate.slice(0, 4), 10);
+  const month = Number.parseInt(observationDate.slice(5, 7), 10);
+  const day = Number.parseInt(observationDate.slice(8, 10), 10);
+  if (month < 1 || month > 12 || day < 1 || day > 31) return null;
+  const millis = Date.UTC(year, month - 1, day);
+  const d = new Date(millis);
+  if (d.getUTCFullYear() !== year || d.getUTCMonth() !== month - 1 || d.getUTCDate() !== day) {
+    return null;
+  }
+  return d;
+}
+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 issuedDayUtc = Date.UTC(issued.getUTCFullYear(), issued.getUTCMonth(), issued.getUTCDate());
+  const obsDayUtc = obs.getTime();
+  const deltaDays = Math.round((issuedDayUtc - obsDayUtc) / 864e5);
+  if (deltaDays <= 0) return "preliminary";
+  if (deltaDays === 1) {
+    const hour = issued.getUTCHours();
+    if (hour >= 4 && hour <= 10) return "final";
+    return "correction";
+  }
+  return "correction";
+}
+function parseTemp(val) {
+  if (val === null || val === void 0 || val === "M" || val === "") return null;
+  const n = typeof val === "number" ? val : Number(val);
+  if (!Number.isFinite(n)) return null;
+  return Math.round(n);
+}
+function parseCliRecord(record, stationCode) {
+  const observationDate = record.valid;
+  if (typeof observationDate !== "string" || observationDate.length === 0) return null;
+  if (parseObservationDate(observationDate) === null) return null;
+  let high = parseTemp(record.high);
+  let low = parseTemp(record.low);
+  if (high !== null && (high < HIGH_TEMP_MIN_F || high > HIGH_TEMP_MAX_F)) {
+    high = null;
+  }
+  if (low !== null && (low < LOW_TEMP_MIN_F || low > LOW_TEMP_MAX_F)) {
+    low = null;
+  }
+  if (high === null && low === null) return null;
+  const product = typeof record.product === "string" && record.product.length > 0 ? record.product : null;
+  const reportType = inferReportType(product, observationDate);
+  const priority = CLIMATE_REPORT_TYPE_PRIORITY[reportType];
+  if (priority === void 0) {
+    throw new Error(
+      `report type ${JSON.stringify(reportType)} missing from CLIMATE_REPORT_TYPE_PRIORITY (codegen drift)`
+    );
+  }
+  let issuedAt = null;
+  if (product !== null) {
+    const issuedDt = parseProductTimestamp(product);
+    if (issuedDt !== null) {
+      issuedAt = `${issuedDt.toISOString().slice(0, 19)}Z`;
+    }
+  }
+  return {
+    station_code: stationCode,
+    observation_date: observationDate,
+    high_temp_f: high,
+    low_temp_f: low,
+    report_type: reportType,
+    report_type_priority: priority,
+    source: "iem",
+    product_id: product,
+    issued_at: issuedAt
+  };
+}
+function parseCliResponse(data, stationCode) {
+  const out = [];
+  for (const record of data) {
+    const parsed = parseCliRecord(record, stationCode);
+    if (parsed !== null) out.push(parsed);
+  }
+  return out;
+}
+
+// ../weather/src/_fetchers/ghcnh.ts
+var GHCNH_BASE_URL = "https://www.ncei.noaa.gov/oa/global-historical-climatology-network/hourly/access";
+var NCEI_POLITE_DELAY_MS = 1e3;
+var GHCNH_STATION_ID_RE = /^[A-Z0-9-]{1,32}$/;
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function validateStationId(stationId) {
+  if (typeof stationId !== "string" || !GHCNH_STATION_ID_RE.test(stationId)) {
+    throw new Error(
+      `station_id=${JSON.stringify(
+        stationId
+      )} does not match GHCNH_STATION_ID_RE (uppercase alphanumeric + hyphen, 1-32 chars); refusing to use as URL component`
+    );
+  }
+}
+function buildGhcnhUrl(stationId, year) {
+  return `${GHCNH_BASE_URL}/by-year/${year}/psv/GHCNh_${stationId}_${year}.psv`;
+}
+async function downloadGhcnh(stationId, year, opts = {}) {
+  validateStationId(stationId);
+  const url = buildGhcnhUrl(stationId, year);
+  const response = await fetchWithRetry(url, opts);
+  const psv = await response.text();
+  return { stationId, year, psv };
+}
+async function downloadGhcnhRange(stationId, startYear, endYear, opts = {}) {
+  validateStationId(stationId);
+  if (endYear < startYear) {
+    return [];
+  }
+  const politenessMs = opts.politenessMs ?? NCEI_POLITE_DELAY_MS;
+  const { politenessMs: _pmDrop, ...fetchOpts } = opts;
+  const out = [];
+  for (let year = startYear; year <= endYear; year++) {
+    let result;
+    try {
+      result = await downloadGhcnh(stationId, year, fetchOpts);
+    } catch (err) {
+      if (err instanceof NotFoundError) {
+        continue;
+      }
+      throw err;
+    }
+    out.push(result);
+    if (politenessMs > 0) {
+      await sleep2(politenessMs);
+    }
+  }
+  return out;
+}
+
+// ../weather/src/_parsers/_station_translator.ts
+var SSID_COLUMNS = [
+  "temperature_Source_Station_ID",
+  "dew_point_temperature_Source_Station_ID",
+  "wind_speed_Source_Station_ID",
+  "wind_direction_Source_Station_ID",
+  "sea_level_pressure_Source_Station_ID",
+  "altimeter_Source_Station_ID",
+  "visibility_Source_Station_ID",
+  "sky_cover_summation_1_Source_Station_ID",
+  "sky_cover_summation_2_Source_Station_ID",
+  "sky_cover_summation_3_Source_Station_ID",
+  "sky_cover_summation_4_Source_Station_ID"
+];
+function ghcnhStationToCode(sourceStationId) {
+  if (!sourceStationId || !sourceStationId.startsWith("ICAO-")) {
+    return null;
+  }
+  const icao = sourceStationId.slice(5);
+  if (!icao) {
+    return null;
+  }
+  const code = icaoToStationCode(icao);
+  if (STATION_CODE_RE.test(code)) {
+    return code;
+  }
+  return null;
+}
+function extractStationCode(row) {
+  for (const col of SSID_COLUMNS) {
+    const ssid = row[col] ?? "";
+    const code = ghcnhStationToCode(ssid);
+    if (code !== null) {
+      return code;
+    }
+  }
+  return null;
+}
+
+// ../weather/src/_parsers/ghcnh.ts
+var MS_TO_KT = 1 / 0.514444;
+var KM_TO_MI = 1 / 1.60934;
+var M_TO_FT = 3.28084;
+var MM_TO_IN = 1 / 25.4;
+var CM_TO_IN = 1 / 2.54;
+var DATE_RE2 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z?$/;
+var ALLOWED_QC = /* @__PURE__ */ new Set(["0", "1", "4", "5"]);
+function safeFloat(val) {
+  if (!val || val === "NA") return null;
+  const f = Number(val);
+  return Number.isFinite(f) ? f : null;
+}
+function safeInt(val) {
+  const f = safeFloat(val);
+  return f === null ? null : Math.round(f);
+}
+function isQcAccepted(qc) {
+  const stripped = qc.trim();
+  if (!stripped) return true;
+  return ALLOWED_QC.has(stripped);
+}
+function parseSkyCover(val) {
+  if (!val) return null;
+  let code;
+  if (val.includes(":")) {
+    const colonIdx = val.indexOf(":");
+    code = val.slice(0, colonIdx);
+  } else {
+    code = val.endsWith(";") ? val.slice(0, -1) : val;
+  }
+  return mapCloudCover(code);
+}
+function parseSkyBaseht(val) {
+  const meters = safeFloat(val);
+  if (meters === null || meters < 0) return null;
+  const feet = Math.round(meters * M_TO_FT);
+  return feet <= SKY_BASE_MAX_FT ? feet : null;
+}
+function parseWeatherCodes(row) {
+  const codes = [];
+  for (let i = 1; i <= 3; i++) {
+    const val = row[`pres_wx_AW${i}`] ?? "";
+    if (!val) continue;
+    const qc = (row[`pres_wx_AW${i}_Quality_Code`] ?? "").trim();
+    if (qc === "3" || qc === "P") continue;
+    const code = val.includes(":") ? val.slice(0, val.indexOf(":")) : val;
+    if (!code) continue;
+    const numericProbe = code.replace(/^[+-]/, "");
+    if (numericProbe.length > 0 && /^\d+$/.test(numericProbe)) continue;
+    codes.push(code);
+  }
+  if (codes.length === 0) return null;
+  const result = codes.join(" ");
+  return result.length > MAX_WX_CODES_LEN ? result.slice(0, MAX_WX_CODES_LEN) : result;
+}
+function isValidCalendarDate(iso) {
+  const stripped = iso.endsWith("Z") ? iso.slice(0, -1) : iso;
+  const year = Number.parseInt(stripped.slice(0, 4), 10);
+  const month = Number.parseInt(stripped.slice(5, 7), 10);
+  const day = Number.parseInt(stripped.slice(8, 10), 10);
+  const hour = Number.parseInt(stripped.slice(11, 13), 10);
+  const minute = Number.parseInt(stripped.slice(14, 16), 10);
+  const second = Number.parseInt(stripped.slice(17, 19), 10);
+  if (month < 1 || month > 12) return false;
+  if (day < 1 || day > 31) return false;
+  if (hour > 23 || minute > 59 || second > 59) return false;
+  const millis = Date.UTC(year, month - 1, day, hour, minute, second, 0);
+  if (!Number.isFinite(millis)) return false;
+  const d = new Date(millis);
+  return d.getUTCFullYear() === year && d.getUTCMonth() === month - 1 && d.getUTCDate() === day && d.getUTCHours() === hour && d.getUTCMinutes() === minute && d.getUTCSeconds() === second;
+}
+function parseGhcnhRow(row) {
+  const stationCode = extractStationCode(row);
+  if (stationCode === null) return null;
+  const dateStr = row.DATE ?? "";
+  if (!dateStr || !DATE_RE2.test(dateStr)) return null;
+  if (!isValidCalendarDate(dateStr)) return null;
+  const year = Number.parseInt(dateStr.slice(0, 4), 10);
+  if (year < MIN_YEAR || year > MAX_YEAR) return null;
+  const observedAt = dateStr.endsWith("Z") ? dateStr : `${dateStr}Z`;
+  const reportType = row.temperature_Report_Type ?? "";
+  const observationType = reportType === "FM16" ? "SPECI" : "METAR";
+  const tempOk = isQcAccepted(row.temperature_Quality_Code ?? "");
+  const dewpOk = isQcAccepted(row.dew_point_temperature_Quality_Code ?? "");
+  const wspdOk = isQcAccepted(row.wind_speed_Quality_Code ?? "");
+  const wdirOk = isQcAccepted(row.wind_direction_Quality_Code ?? "");
+  const wgustOk = isQcAccepted(row.wind_gust_Quality_Code ?? "");
+  const slpOk = isQcAccepted(row.sea_level_pressure_Quality_Code ?? "");
+  const altimOk = isQcAccepted(row.altimeter_Quality_Code ?? "");
+  const visOk = isQcAccepted(row.visibility_Quality_Code ?? "");
+  const precipOk = isQcAccepted(row.precipitation_Quality_Code ?? "");
+  const snowOk = isQcAccepted(row.snow_depth_Quality_Code ?? "");
+  if (!(tempOk || dewpOk || wspdOk || slpOk)) return null;
+  const tempC = tempOk ? boundedFloat(safeFloat(row.temperature ?? ""), TEMP_MIN_C, TEMP_MAX_C, { field: "temp_c" }) : null;
+  const dewpC = dewpOk ? boundedFloat(safeFloat(row.dew_point_temperature ?? ""), TEMP_MIN_C, TEMP_MAX_C, {
+    field: "dewpoint_c"
+  }) : null;
+  const tempF = celsiusToFahrenheit(tempC);
+  const dewpF = celsiusToFahrenheit(dewpC);
+  const windDir = wdirOk ? boundedInt(safeInt(row.wind_direction ?? ""), 0, 360) : null;
+  const windSpeedMs = wspdOk ? safeFloat(row.wind_speed ?? "") : null;
+  const windGustMs = wgustOk ? safeFloat(row.wind_gust ?? "") : null;
+  const windSpeedKt = boundedInt(
+    windSpeedMs !== null ? Math.round(windSpeedMs * MS_TO_KT) : null,
+    0,
+    200
+  );
+  const windGustKt = boundedInt(
+    windGustMs !== null ? Math.round(windGustMs * MS_TO_KT) : null,
+    0,
+    250
+  );
+  let slp = slpOk ? safeFloat(row.sea_level_pressure ?? "") : null;
+  if (slp !== null && (slp < SLP_MIN_MB || slp > SLP_MAX_MB)) {
+    slp = null;
+  }
+  const altimHpa = altimOk ? safeFloat(row.altimeter ?? "") : null;
+  const altimInhg = hpaToInhg(altimHpa);
+  const visKm = visOk ? safeFloat(row.visibility ?? "") : null;
+  let visMiles = null;
+  if (visKm !== null && visKm >= 0) {
+    visMiles = Math.min(visKm * KM_TO_MI, MAX_VISIBILITY_MILES);
+  }
+  const precipMm = precipOk ? safeFloat(row.precipitation ?? "") : null;
+  const precipInches = precipMm !== null ? boundedFloatMin(precipMm * MM_TO_IN, 0) : null;
+  const snowCm = snowOk ? safeFloat(row.snow_depth ?? "") : null;
+  const snowInches = snowCm !== null ? boundedFloatMin(snowCm * CM_TO_IN, 0) : null;
+  const skyCovers = [];
+  const skyBases = [];
+  for (let i = 1; i <= 4; i++) {
+    const covQc = isQcAccepted(row[`sky_cover_summation_${i}_Quality_Code`] ?? "");
+    const baseQc = isQcAccepted(row[`sky_cover_summation_baseht_${i}_Quality_Code`] ?? "");
+    skyCovers.push(covQc ? parseSkyCover(row[`sky_cover_summation_${i}`] ?? "") : null);
+    skyBases.push(baseQc ? parseSkyBaseht(row[`sky_cover_summation_baseht_${i}`] ?? "") : null);
+  }
+  const weatherCodes = parseWeatherCodes(row);
+  const rem = row.REM ?? "";
+  let rawMetar = null;
+  if (rem) {
+    const idxMetar = rem.indexOf("METAR ");
+    const idxSpeci = rem.indexOf("SPECI ");
+    let cleaned;
+    if (idxMetar >= 0 && (idxSpeci < 0 || idxMetar < idxSpeci)) {
+      cleaned = rem.slice(idxMetar);
+    } else if (idxSpeci >= 0) {
+      cleaned = rem.slice(idxSpeci);
+    } else {
+      cleaned = rem;
+    }
+    rawMetar = cleaned.length > MAX_RAW_METAR_LEN ? cleaned.slice(0, MAX_RAW_METAR_LEN) : cleaned;
+  }
+  return {
+    station_code: stationCode,
+    observed_at: observedAt,
+    observation_type: observationType,
+    source: "ghcnh",
+    temp_c: tempC,
+    dewpoint_c: dewpC,
+    temp_f: tempF,
+    dewpoint_f: dewpF,
+    wind_dir_degrees: windDir,
+    wind_speed_kt: windSpeedKt,
+    wind_gust_kt: windGustKt,
+    altimeter_inhg: altimInhg,
+    sea_level_pressure_mb: slp,
+    sky_cover_1: skyCovers[0] ?? null,
+    sky_base_1_ft: skyBases[0] ?? null,
+    sky_cover_2: skyCovers[1] ?? null,
+    sky_base_2_ft: skyBases[1] ?? null,
+    sky_cover_3: skyCovers[2] ?? null,
+    sky_base_3_ft: skyBases[2] ?? null,
+    sky_cover_4: skyCovers[3] ?? null,
+    sky_base_4_ft: skyBases[3] ?? null,
+    visibility_miles: visMiles,
+    weather_codes: weatherCodes,
+    precip_1hr_inches: precipInches,
+    peak_wind_gust_kt: null,
+    peak_wind_dir: null,
+    peak_wind_time: null,
+    snow_depth_inches: snowInches,
+    qc_field: null,
+    raw_metar: rawMetar
+  };
+}
+function parseGhcnhPsv(psvBody) {
+  if (!psvBody) return [];
+  const lines = psvBody.replace(/\r/g, "").split("\n");
+  let headerIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].length > 0) {
+      headerIdx = i;
+      break;
+    }
+  }
+  if (headerIdx < 0) return [];
+  const header = lines[headerIdx].split("|");
+  const out = [];
+  for (let i = headerIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.length === 0) continue;
+    const cells = line.split("|");
+    const row = {};
+    for (let c = 0; c < header.length; c++) {
+      const key = header[c];
+      row[key] = c < cells.length ? cells[c] : "";
+    }
+    const obs = parseGhcnhRow(row);
+    if (obs !== null) out.push(obs);
+  }
+  return out;
+}
+
+// ../weather/src/live/sources.ts
+var SUPPORTED_SOURCES = ["awc", "iem"];
+var POLITE_FLOORS_S = {
+  awc: 30,
+  iem: 60
+};
+var SOURCE_IDENTITY_TAGS = {
+  awc: "awc.live",
+  iem: "iem.live"
+};
+function validateSource(source) {
+  if (source === void 0 || source === null) {
+    return SUPPORTED_SOURCES[0];
+  }
+  const normalized = source.trim().toLowerCase();
+  if (!isLiveSource(normalized)) {
+    throw new Error(
+      `unknown live source ${JSON.stringify(source)}; supported: ${JSON.stringify(
+        SUPPORTED_SOURCES
+      )}`
+    );
+  }
+  return normalized;
+}
+function isLiveSource(s) {
+  return SUPPORTED_SOURCES.includes(s);
+}
+function validatePollSeconds(pollSeconds, source) {
+  const floor = POLITE_FLOORS_S[source];
+  if (pollSeconds === void 0 || pollSeconds === null) {
+    return floor;
+  }
+  if (!Number.isFinite(pollSeconds)) {
+    throw new Error(
+      `pollSeconds=${pollSeconds} is not a finite number; polite floor ${floor}s required for source=${JSON.stringify(
+        source
+      )}`
+    );
+  }
+  if (pollSeconds < floor) {
+    throw new Error(
+      `pollSeconds=${pollSeconds} below polite floor ${floor}s for source=${JSON.stringify(
+        source
+      )}`
+    );
+  }
+  return pollSeconds;
+}
+function sourceTag(source) {
+  return SOURCE_IDENTITY_TAGS[source];
+}
+
+// ../weather/src/live/_fetch.ts
+function normalizeStation(station) {
+  const s = station.trim().toUpperCase();
+  if (s.length === 3) return `K${s}`;
+  return s;
+}
+function asLiveObservation(obs, tag) {
+  return { ...obs, source: tag };
+}
+async function fetchAwcLatest(station) {
+  const icao = normalizeStation(station);
+  const raw = await fetchAwcMetars([icao], { hours: 1 });
+  const tag = sourceTag("awc");
+  const rows = [];
+  for (const m of raw) {
+    const obs = awcToObservation(m);
+    if (obs !== null) {
+      rows.push(asLiveObservation(obs, tag));
+    }
+  }
+  return rows;
+}
+function todayUtcIso() {
+  const d = /* @__PURE__ */ new Date();
+  const y = d.getUTCFullYear();
+  const m = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(d.getUTCDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+function nextDayIso(iso) {
+  const [y, m, d] = iso.split("-").map(Number);
+  const dt = new Date(Date.UTC(y, m - 1, d));
+  dt.setUTCDate(dt.getUTCDate() + 1);
+  const ny = dt.getUTCFullYear();
+  const nm = String(dt.getUTCMonth() + 1).padStart(2, "0");
+  const nd = String(dt.getUTCDate()).padStart(2, "0");
+  return `${ny}-${nm}-${nd}`;
+}
+function previousDayIso(iso) {
+  const [y, m, d] = iso.split("-").map(Number);
+  const dt = new Date(Date.UTC(y, m - 1, d));
+  dt.setUTCDate(dt.getUTCDate() - 1);
+  const py = dt.getUTCFullYear();
+  const pm = String(dt.getUTCMonth() + 1).padStart(2, "0");
+  const pd = String(dt.getUTCDate()).padStart(2, "0");
+  return `${py}-${pm}-${pd}`;
+}
+async function fetchIemLatest(station) {
+  const [{ fetchWithRetry: fetchWithRetry2 }, { STATION_CODE_RE: STATION_CODE_RE3 }, { buildIemUrl: buildIemUrl2 }, { parseIemCsv: parseIemCsv2 }] = await Promise.all([
+    import("./src-5L5C2EE7.mjs"),
+    import("./bounds-KSTXL77E.mjs"),
+    import("./iem-asos-O4CQWBXK.mjs"),
+    import("./iem-5RVPI3TY.mjs")
+  ]);
+  const icao = normalizeStation(station);
+  const stationCode = icao.length === 4 && icao.startsWith("K") ? icao.slice(1) : icao;
+  if (!STATION_CODE_RE3.test(stationCode)) {
+    throw new Error(
+      `station=${JSON.stringify(
+        stationCode
+      )} does not match STATION_CODE_RE (3-4 uppercase letters); refusing to use as IEM URL component`
+    );
+  }
+  const todayIso = todayUtcIso();
+  const startIso = previousDayIso(todayIso);
+  const endIso = nextDayIso(todayIso);
+  const tag = sourceTag("iem");
+  const rows = [];
+  for (const reportType of [3, 4]) {
+    const url = buildIemUrl2(stationCode, startIso, endIso, reportType);
+    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) {
+      rows.push(asLiveObservation(row, tag));
+    }
+  }
+  return rows;
+}
+async function fetchLatest(station, source) {
+  switch (source) {
+    case "awc":
+      return fetchAwcLatest(station);
+    case "iem":
+      return fetchIemLatest(station);
+  }
+}
+function pickMostRecent(rows) {
+  if (rows.length === 0) return null;
+  let best = rows[0];
+  for (let i = 1; i < rows.length; i++) {
+    const cur = rows[i];
+    if (cur.observed_at > best.observed_at) {
+      best = cur;
+    } else if (cur.observed_at === best.observed_at && cur.observation_type === "SPECI" && best.observation_type !== "SPECI") {
+      best = cur;
+    }
+  }
+  return best;
+}
+
+// ../weather/src/live/latest.ts
+async function latest(station, opts = {}) {
+  const src = validateSource(opts.source ?? void 0);
+  const rows = await fetchLatest(station, src);
+  const picked = pickMostRecent(rows);
+  if (picked === null) {
+    throw new NoLiveDataError(
+      `no live data for station=${JSON.stringify(station)} source=${JSON.stringify(src)}`,
+      {
+        station: normalizeStation(station),
+        source: sourceTag(src)
+      }
+    );
+  }
+  return picked;
+}
+
+// ../weather/src/live/stream.ts
+async function sleep3(ms, signal) {
+  if (signal?.aborted) return;
+  await new Promise((resolve) => {
+    const onAbort = () => {
+      clearTimeout(t);
+      resolve();
+    };
+    const t = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function* stream(station, opts = {}) {
+  const src = validateSource(opts.source ?? void 0);
+  const cadenceS = validatePollSeconds(opts.pollSeconds ?? void 0, src);
+  const cadenceMs = cadenceS * 1e3;
+  const icaoUpper = station.trim().toUpperCase();
+  const stationCheck = icaoUpper.length === 3 ? `K${icaoUpper}` : icaoUpper;
+  const STATION_CODE_RE3 = /^[A-Z]{3,4}$/;
+  if (!STATION_CODE_RE3.test(stationCheck)) {
+    throw new Error(
+      `station=${JSON.stringify(stationCheck)} does not match STATION_CODE_RE; refusing to start stream.`
+    );
+  }
+  let lastObservedAt = null;
+  while (true) {
+    if (opts.signal?.aborted) return;
+    let rows = [];
+    try {
+      rows = await fetchLatest(station, src);
+    } catch (err) {
+      if (err instanceof Error && /STATION_CODE_RE/.test(err.message)) {
+        throw err;
+      }
+      rows = [];
+    }
+    const picked = pickMostRecent(rows);
+    if (picked !== null) {
+      const current = picked.observed_at;
+      if (current && current !== lastObservedAt) {
+        lastObservedAt = current;
+        yield picked;
+      }
+    }
+    if (opts.signal?.aborted) return;
+    await sleep3(cadenceMs, opts.signal);
+  }
+}
+
+// ../weather/src/forecasts/iem-mos.ts
+var IEM_MOS_URL = "https://mesonet.agron.iastate.edu/api/1/mos.json";
+var SUPPORTED_MODELS = /* @__PURE__ */ new Set([
+  "nbe",
+  "gfs",
+  "lav",
+  "met",
+  "ecm"
+]);
+var KT_TO_MS = 0.5144444;
+var NBE_CYCLE_CUTOVER = Date.UTC(2026, 5 - 1, 5, 0, 0, 0);
+function runtimeHoursFor(model, fromDt, toDt) {
+  if (model !== "nbe") return [0, 6, 12, 18];
+  const fromMs = fromDt.getTime();
+  const toMs = toDt.getTime();
+  const pre = fromMs < NBE_CYCLE_CUTOVER;
+  const post = toMs >= NBE_CYCLE_CUTOVER;
+  if (pre && post) return [0, 1, 6, 7, 12, 13, 18, 19];
+  if (pre) return [1, 7, 13, 19];
+  return [0, 6, 12, 18];
+}
+function fahrenheitToCelsius(f) {
+  if (f === null || Number.isNaN(f)) return null;
+  return (f - 32) * 5 / 9;
+}
+function knotsToMs(kt) {
+  if (kt === null || Number.isNaN(kt)) return null;
+  return kt * KT_TO_MS;
+}
+function percentToUnit(pct) {
+  if (pct === null || Number.isNaN(pct)) return null;
+  return pct / 100;
+}
+function maybeNumber(value) {
+  if (value === null || value === void 0 || value === "M" || value === "") {
+    return null;
+  }
+  const num = typeof value === "number" ? value : Number(value);
+  if (Number.isNaN(num)) return null;
+  return num;
+}
+function parseDate(value) {
+  if (typeof value !== "string" || !value) return null;
+  const dt = new Date(value);
+  if (Number.isNaN(dt.getTime())) return null;
+  return dt;
+}
+function parseRow(raw, station, model, retrievedAt) {
+  const issuedDt = parseDate(raw.runtime ?? raw.model_runtime);
+  const validDt = parseDate(raw.ftime ?? raw.valid_time);
+  if (issuedDt === null || validDt === null) return null;
+  const forecastHour = Math.round(
+    (validDt.getTime() - issuedDt.getTime()) / 36e5
+  );
+  return {
+    station,
+    model: model.toUpperCase(),
+    issuedAt: issuedDt.toISOString(),
+    validAt: validDt.toISOString(),
+    forecastHour,
+    tempC: fahrenheitToCelsius(maybeNumber(raw.tmp)),
+    dewPointC: fahrenheitToCelsius(maybeNumber(raw.dpt)),
+    windSpeedMs: knotsToMs(maybeNumber(raw.wsp)),
+    windDirDeg: (() => {
+      const d = maybeNumber(raw.wdr);
+      return d === null ? null : Math.round(d);
+    })(),
+    precipProbability: percentToUnit(maybeNumber(raw.pop12)),
+    skyCoverPct: null,
+    source: "iem.archive",
+    retrievedAt
+  };
+}
+function parseIsoDate(iso, endOfDay) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(iso);
+  if (match === null) {
+    throw new Error(
+      `iemMosForecasts: from/to dates must be ISO YYYY-MM-DD; got ${iso}`
+    );
+  }
+  const [, y, m, d] = match;
+  if (endOfDay) {
+    return new Date(Date.UTC(Number(y), Number(m) - 1, Number(d), 23, 59, 59));
+  }
+  return new Date(Date.UTC(Number(y), Number(m) - 1, Number(d)));
+}
+async function iemMosForecasts(station, fromDate, toDate, opts = {}) {
+  const model = opts.model ?? "nbe";
+  if (!SUPPORTED_MODELS.has(model)) {
+    throw new Error(
+      `iemMosForecasts: model must be one of ${[...SUPPORTED_MODELS].sort().join(",")}; got ${model}`
+    );
+  }
+  const fetchFn = opts.fetchFn ?? fetch;
+  const fromDt = parseIsoDate(fromDate, false);
+  const toDt = parseIsoDate(toDate, true);
+  const hours = runtimeHoursFor(model, fromDt, toDt);
+  const retrievedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const rows = [];
+  const dayMs = 864e5;
+  for (let day = fromDt.getTime(); day <= toDt.getTime(); day += dayMs) {
+    for (const h of hours) {
+      const rt = new Date(day);
+      rt.setUTCHours(h, 0, 0, 0);
+      if (rt < fromDt || rt > toDt) continue;
+      const url = `${IEM_MOS_URL}?station=${encodeURIComponent(
+        station
+      )}&model=${encodeURIComponent(model)}&runtime=${encodeURIComponent(
+        rt.toISOString()
+      )}`;
+      const resp = await fetchFn(url);
+      if (resp.status === 404) continue;
+      if (!resp.ok) {
+        throw new Error(
+          `iemMosForecasts: HTTP ${resp.status} on ${url}`
+        );
+      }
+      const payload = await resp.json();
+      for (const raw of payload.data ?? []) {
+        const projected = parseRow(raw, station, model, retrievedAt);
+        if (projected !== null) rows.push(projected);
+      }
+    }
+  }
+  return rows;
+}
+
+// ../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/index.ts
+var version = "0.0.0";
+function helloWeather() {
+  return "hello @mostlyrightmd/weather";
+}
+
+// ../markets/src/index.ts
+var src_exports3 = {};
+__export(src_exports3, {
+  ContractIdError: () => ContractIdError,
+  KALSHI_SETTLEMENT_STATIONS: () => KALSHI_SETTLEMENT_STATIONS,
+  KNOWN_WRONG_STATIONS: () => KNOWN_WRONG_STATIONS,
+  POLYMARKET_CITY_STATIONS: () => POLYMARKET_CITY_STATIONS,
+  helloMarkets: () => helloMarkets,
+  kalshiNhighResolve: () => kalshiNhighResolve,
+  kalshiNlowResolve: () => kalshiNlowResolve,
+  kalshiSettlementFor: () => kalshiSettlementFor,
+  version: () => version2
+});
+
+// ../markets/src/data/generated/kalshi-stations.ts
+var KALSHI_SETTLEMENT_STATIONS = {
+  ATL: {
+    citation: "https://kalshi.com/markets/khighatl (Atlanta Hartsfield-Jackson)",
+    station: "KATL"
+  },
+  AUS: {
+    citation: "https://kalshi.com/markets/khighaus (Austin-Bergstrom; the only Austin station Kalshi cites)",
+    station: "KAUS"
+  },
+  BNA: {
+    citation: "https://kalshi.com/markets/khighbna (Nashville International)",
+    station: "KBNA"
+  },
+  BOS: {
+    citation: "https://kalshi.com/markets/khighbos (Boston Logan)",
+    station: "KBOS"
+  },
+  CHI: {
+    citation: "https://kalshi.com/markets/khighchi (Midway, NOT ORD)",
+    station: "KMDW"
+  },
+  CVG: {
+    citation: "https://kalshi.com/markets/khighcvg (Cincinnati/Northern Kentucky International)",
+    station: "KCVG"
+  },
+  DAL: {
+    citation: "https://kalshi.com/markets/khighdal (DFW, NOT Love Field)",
+    station: "KDFW"
+  },
+  DCA: {
+    citation: "https://kalshi.com/markets/khighdca (Reagan National, NOT Dulles or BWI)",
+    station: "KDCA"
+  },
+  DEN: {
+    citation: "https://kalshi.com/markets/khighden (Denver International)",
+    station: "KDEN"
+  },
+  DTW: {
+    citation: "https://kalshi.com/markets/khighdtw (Detroit Metropolitan)",
+    station: "KDTW"
+  },
+  HOU: {
+    citation: "https://kalshi.com/markets/khighhou (Intercontinental, NOT Hobby; Kalshi cites IAH)",
+    station: "KIAH"
+  },
+  LAX: {
+    citation: "https://kalshi.com/markets/khighlax (LAX international)",
+    station: "KLAX"
+  },
+  MIA: {
+    citation: "https://kalshi.com/markets/khighmia (Miami International)",
+    station: "KMIA"
+  },
+  MSP: {
+    citation: "https://kalshi.com/markets/khighmsp (Minneapolis-St. Paul International)",
+    station: "KMSP"
+  },
+  NYC: {
+    citation: "https://kalshi.com/markets/khighny  (Central Park, NOT LGA/JFK)",
+    station: "KNYC"
+  },
+  PHL: {
+    citation: "https://kalshi.com/markets/khighphl (Philadelphia International)",
+    station: "KPHL"
+  },
+  PHX: {
+    citation: "https://kalshi.com/markets/khighphx (Sky Harbor International)",
+    station: "KPHX"
+  },
+  SEA: {
+    citation: "https://kalshi.com/markets/khighsea (SeaTac, NOT BFI)",
+    station: "KSEA"
+  },
+  SFO: {
+    citation: "https://kalshi.com/markets/khighsfo (San Francisco International, NOT OAK)",
+    station: "KSFO"
+  },
+  SLC: {
+    citation: "https://kalshi.com/markets/khighslc (Salt Lake City International)",
+    station: "KSLC"
+  }
+};
+var KNOWN_WRONG_STATIONS = /* @__PURE__ */ new Set([
+  "KBWI",
+  "KDAL",
+  "KEWR",
+  "KHOU",
+  "KIAD",
+  "KJFK",
+  "KLGA",
+  "KOAK",
+  "KORD"
+]);
+
+// ../markets/src/data/generated/polymarket-city-stations.ts
+var POLYMARKET_CITY_STATIONS = {
+  amsterdam: {
+    default: "EHAM"
+  },
+  atlanta: {
+    default: "KATL"
+  },
+  auckland: {
+    default: "NZAA"
+  },
+  austin: {
+    default: "KAUS"
+  },
+  bangkok: {
+    default: "VTBS"
+  },
+  barcelona: {
+    default: "LEBL"
+  },
+  beijing: {
+    default: "ZBAA"
+  },
+  berlin: {
+    default: "EDDB"
+  },
+  boston: {
+    default: "KBOS"
+  },
+  brisbane: {
+    default: "YBBN"
+  },
+  buenos_aires: {
+    default: "SAEZ"
+  },
+  chicago: {
+    default: "KORD",
+    high: "KORD",
+    low: "KORD"
+  },
+  copenhagen: {
+    default: "EKCH"
+  },
+  dallas: {
+    default: "KDFW"
+  },
+  delhi: {
+    default: "VIDP"
+  },
+  denver: {
+    default: "KDEN"
+  },
+  detroit: {
+    default: "KDTW"
+  },
+  doha: {
+    default: "OTHH"
+  },
+  dubai: {
+    default: "OMDB"
+  },
+  frankfurt: {
+    default: "EDDF"
+  },
+  helsinki: {
+    default: "EFHK"
+  },
+  hong_kong: {
+    default: "VHHH",
+    high: "VHHH",
+    low: "VHHH"
+  },
+  houston: {
+    default: "KIAH"
+  },
+  london: {
+    default: "EGLL"
+  },
+  london_gatwick: {
+    default: "EGKK"
+  },
+  los_angeles: {
+    default: "KLAX",
+    high: "KLAX",
+    low: "KLAX"
+  },
+  madrid: {
+    default: "LEMD"
+  },
+  melbourne: {
+    default: "YMML"
+  },
+  miami: {
+    default: "KMIA"
+  },
+  milan: {
+    default: "LIMC"
+  },
+  minneapolis: {
+    default: "KMSP"
+  },
+  moscow: {
+    default: "UUEE"
+  },
+  mumbai: {
+    default: "VABB"
+  },
+  munich: {
+    default: "EDDM"
+  },
+  nyc: {
+    default: "KLGA",
+    high: "KLGA",
+    low: "KLGA"
+  },
+  paris: {
+    default: "LFPG",
+    high: "LFPG",
+    low: "LFPB"
+  },
+  paris_orly: {
+    default: "LFPO"
+  },
+  philadelphia: {
+    default: "KPHL"
+  },
+  phoenix: {
+    default: "KPHX"
+  },
+  riyadh: {
+    default: "OERK"
+  },
+  rome: {
+    default: "LIRF"
+  },
+  san_francisco: {
+    default: "KSFO"
+  },
+  sao_paulo: {
+    default: "SBGR"
+  },
+  seattle: {
+    default: "KSEA"
+  },
+  seoul: {
+    default: "RKSI"
+  },
+  shanghai: {
+    default: "ZSPD"
+  },
+  singapore: {
+    default: "WSSS"
+  },
+  stockholm: {
+    default: "ESSA"
+  },
+  sydney: {
+    default: "YSSY"
+  },
+  taipei: {
+    default: "RCTP"
+  },
+  tokyo: {
+    default: "RJTT",
+    high: "RJTT",
+    low: "RJTT"
+  },
+  tokyo_narita: {
+    default: "RJAA"
+  },
+  vienna: {
+    default: "LOWW"
+  },
+  warsaw: {
+    default: "EPWA"
+  },
+  washington_dc: {
+    default: "KDCA"
+  },
+  wellington: {
+    default: "NZWN"
+  },
+  zurich: {
+    default: "LSZH"
+  }
+};
+
+// ../markets/src/resolvers/kalshi-nhigh.ts
+var ContractIdError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ContractIdError";
+  }
+};
+function coerceContractDate(value) {
+  if (typeof value === "string") {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+      throw new ContractIdError(
+        `settlementDate string must be YYYY-MM-DD; got ${JSON.stringify(value)}`
+      );
+    }
+    const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00Z`);
+    if (Number.isNaN(parsed.getTime())) {
+      throw new ContractIdError(
+        `settlementDate string is not a valid calendar date; got ${JSON.stringify(value)}`
+      );
+    }
+    const iso = parsed.toISOString().slice(0, 10);
+    if (iso !== value) {
+      throw new ContractIdError(
+        `settlementDate string is not a valid calendar date; got ${JSON.stringify(value)}`
+      );
+    }
+    return value;
+  }
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      throw new ContractIdError("settlementDate is an invalid Date instance");
+    }
+    if (value.getUTCHours() !== 0 || value.getUTCMinutes() !== 0 || value.getUTCSeconds() !== 0 || value.getUTCMilliseconds() !== 0) {
+      throw new ContractIdError(
+        `settlementDate must be a UTC date-only Date (H/M/S/ms = 0); got ${value.toISOString()}. Use new Date('YYYY-MM-DDT00:00:00Z') or pass a 'YYYY-MM-DD' string.`
+      );
+    }
+    return value.toISOString().slice(0, 10);
+  }
+  throw new ContractIdError("settlementDate must be a Date instance or YYYY-MM-DD string");
+}
+function kalshiNhighResolve(contractId, settlementDate) {
+  if (typeof contractId !== "string") {
+    throw new ContractIdError(`contractId must be a string; got ${typeof contractId}`);
+  }
+  const contractDate = coerceContractDate(settlementDate);
+  const cid = contractId.toUpperCase();
+  if (!cid.startsWith("KHIGH") || cid.length <= 5) {
+    throw new ContractIdError(
+      `NHIGH contractId must follow 'KHIGH<CITY>' format; got ${JSON.stringify(contractId)}`
+    );
+  }
+  const cityTicker = cid.slice(5);
+  const station = KALSHI_SETTLEMENT_STATIONS[cityTicker];
+  if (station === void 0) {
+    const known = Object.keys(KALSHI_SETTLEMENT_STATIONS).sort();
+    throw new ContractIdError(
+      `unknown city ${JSON.stringify(cityTicker)} (known: ${known.join(", ")})`
+    );
+  }
+  return Object.freeze({
+    settlementSource: "cli.archive",
+    settlementStation: station.station,
+    cityTicker,
+    contractDate
+  });
+}
+
+// ../markets/src/resolvers/kalshi-nlow.ts
+function coerceContractDate2(value) {
+  if (typeof value === "string") {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+      throw new ContractIdError(
+        `settlementDate string must be YYYY-MM-DD; got ${JSON.stringify(value)}`
+      );
+    }
+    const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00Z`);
+    if (Number.isNaN(parsed.getTime())) {
+      throw new ContractIdError(
+        `settlementDate string is not a valid calendar date; got ${JSON.stringify(value)}`
+      );
+    }
+    const iso = parsed.toISOString().slice(0, 10);
+    if (iso !== value) {
+      throw new ContractIdError(
+        `settlementDate string is not a valid calendar date; got ${JSON.stringify(value)}`
+      );
+    }
+    return value;
+  }
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      throw new ContractIdError("settlementDate is an invalid Date instance");
+    }
+    if (value.getUTCHours() !== 0 || value.getUTCMinutes() !== 0 || value.getUTCSeconds() !== 0 || value.getUTCMilliseconds() !== 0) {
+      throw new ContractIdError(
+        `settlementDate must be a UTC date-only Date (H/M/S/ms = 0); got ${value.toISOString()}. Use new Date('YYYY-MM-DDT00:00:00Z') or pass a 'YYYY-MM-DD' string.`
+      );
+    }
+    return value.toISOString().slice(0, 10);
+  }
+  throw new ContractIdError("settlementDate must be a Date instance or YYYY-MM-DD string");
+}
+function kalshiNlowResolve(contractId, settlementDate) {
+  if (typeof contractId !== "string") {
+    throw new ContractIdError(`contractId must be a string; got ${typeof contractId}`);
+  }
+  const contractDate = coerceContractDate2(settlementDate);
+  const cid = contractId.toUpperCase();
+  if (!cid.startsWith("KLOW") || cid.length <= 4) {
+    throw new ContractIdError(
+      `NLOW contractId must follow 'KLOW<CITY>' format; got ${JSON.stringify(contractId)}`
+    );
+  }
+  const cityTicker = cid.slice(4);
+  const station = KALSHI_SETTLEMENT_STATIONS[cityTicker];
+  if (station === void 0) {
+    const known = Object.keys(KALSHI_SETTLEMENT_STATIONS).sort();
+    throw new ContractIdError(
+      `unknown city ${JSON.stringify(cityTicker)} (known: ${known.join(", ")})`
+    );
+  }
+  return Object.freeze({
+    settlementSource: "cli.archive",
+    settlementStation: station.station,
+    cityTicker,
+    contractDate
+  });
+}
+
+// ../markets/src/kalshi-settlement.ts
+function kalshiSettlementFor(contractId, date) {
+  if (typeof contractId !== "string" || contractId.length === 0) {
+    throw new ContractIdError("contractId must be a non-empty string");
+  }
+  const upper = contractId.toUpperCase();
+  if (upper.startsWith("KHIGH")) return kalshiNhighResolve(upper, date);
+  if (upper.startsWith("KLOW")) return kalshiNlowResolve(upper, date);
+  throw new ContractIdError(
+    `contractId ${JSON.stringify(contractId)} does not start with KHIGH or KLOW`
+  );
+}
+
+// ../markets/src/index.ts
+var version2 = "0.0.0";
+function helloMarkets() {
+  return "hello @mostlyrightmd/markets";
+}
+
+// ../../node_modules/.pnpm/idb@8.0.3/node_modules/idb/build/index.js
+var instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
+var idbProxyableTypes;
+var cursorAdvanceMethods;
+function getIdbProxyableTypes() {
+  return idbProxyableTypes || (idbProxyableTypes = [
+    IDBDatabase,
+    IDBObjectStore,
+    IDBIndex,
+    IDBCursor,
+    IDBTransaction
+  ]);
+}
+function getCursorAdvanceMethods() {
+  return cursorAdvanceMethods || (cursorAdvanceMethods = [
+    IDBCursor.prototype.advance,
+    IDBCursor.prototype.continue,
+    IDBCursor.prototype.continuePrimaryKey
+  ]);
+}
+var transactionDoneMap = /* @__PURE__ */ new WeakMap();
+var transformCache = /* @__PURE__ */ new WeakMap();
+var reverseTransformCache = /* @__PURE__ */ new WeakMap();
+function promisifyRequest(request) {
+  const promise = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      request.removeEventListener("success", success);
+      request.removeEventListener("error", error);
+    };
+    const success = () => {
+      resolve(wrap(request.result));
+      unlisten();
+    };
+    const error = () => {
+      reject(request.error);
+      unlisten();
+    };
+    request.addEventListener("success", success);
+    request.addEventListener("error", error);
+  });
+  reverseTransformCache.set(promise, request);
+  return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+  if (transactionDoneMap.has(tx))
+    return;
+  const done = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      tx.removeEventListener("complete", complete);
+      tx.removeEventListener("error", error);
+      tx.removeEventListener("abort", error);
+    };
+    const complete = () => {
+      resolve();
+      unlisten();
+    };
+    const error = () => {
+      reject(tx.error || new DOMException("AbortError", "AbortError"));
+      unlisten();
+    };
+    tx.addEventListener("complete", complete);
+    tx.addEventListener("error", error);
+    tx.addEventListener("abort", error);
+  });
+  transactionDoneMap.set(tx, done);
+}
+var idbProxyTraps = {
+  get(target, prop, receiver) {
+    if (target instanceof IDBTransaction) {
+      if (prop === "done")
+        return transactionDoneMap.get(target);
+      if (prop === "store") {
+        return receiver.objectStoreNames[1] ? void 0 : receiver.objectStore(receiver.objectStoreNames[0]);
+      }
+    }
+    return wrap(target[prop]);
+  },
+  set(target, prop, value) {
+    target[prop] = value;
+    return true;
+  },
+  has(target, prop) {
+    if (target instanceof IDBTransaction && (prop === "done" || prop === "store")) {
+      return true;
+    }
+    return prop in target;
+  }
+};
+function replaceTraps(callback) {
+  idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+  if (getCursorAdvanceMethods().includes(func)) {
+    return function(...args) {
+      func.apply(unwrap(this), args);
+      return wrap(this.request);
+    };
+  }
+  return function(...args) {
+    return wrap(func.apply(unwrap(this), args));
+  };
+}
+function transformCachableValue(value) {
+  if (typeof value === "function")
+    return wrapFunction(value);
+  if (value instanceof IDBTransaction)
+    cacheDonePromiseForTransaction(value);
+  if (instanceOfAny(value, getIdbProxyableTypes()))
+    return new Proxy(value, idbProxyTraps);
+  return value;
+}
+function wrap(value) {
+  if (value instanceof IDBRequest)
+    return promisifyRequest(value);
+  if (transformCache.has(value))
+    return transformCache.get(value);
+  const newValue = transformCachableValue(value);
+  if (newValue !== value) {
+    transformCache.set(value, newValue);
+    reverseTransformCache.set(newValue, value);
+  }
+  return newValue;
+}
+var unwrap = (value) => reverseTransformCache.get(value);
+function openDB(name, version4, { blocked, upgrade, blocking, terminated } = {}) {
+  const request = indexedDB.open(name, version4);
+  const openPromise = wrap(request);
+  if (upgrade) {
+    request.addEventListener("upgradeneeded", (event) => {
+      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
+    });
+  }
+  if (blocked) {
+    request.addEventListener("blocked", (event) => blocked(
+      // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+      event.oldVersion,
+      event.newVersion,
+      event
+    ));
+  }
+  openPromise.then((db) => {
+    if (terminated)
+      db.addEventListener("close", () => terminated());
+    if (blocking) {
+      db.addEventListener("versionchange", (event) => blocking(event.oldVersion, event.newVersion, event));
+    }
+  }).catch(() => {
+  });
+  return openPromise;
+}
+var readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"];
+var writeMethods = ["put", "add", "delete", "clear"];
+var cachedMethods = /* @__PURE__ */ new Map();
+function getMethod(target, prop) {
+  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === "string")) {
+    return;
+  }
+  if (cachedMethods.get(prop))
+    return cachedMethods.get(prop);
+  const targetFuncName = prop.replace(/FromIndex$/, "");
+  const useIndex = prop !== targetFuncName;
+  const isWrite = writeMethods.includes(targetFuncName);
+  if (
+    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))
+  ) {
+    return;
+  }
+  const method = async function(storeName, ...args) {
+    const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
+    let target2 = tx.store;
+    if (useIndex)
+      target2 = target2.index(args.shift());
+    return (await Promise.all([
+      target2[targetFuncName](...args),
+      isWrite && tx.done
+    ]))[0];
+  };
+  cachedMethods.set(prop, method);
+  return method;
+}
+replaceTraps((oldTraps) => ({
+  ...oldTraps,
+  get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+  has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
+}));
+var advanceMethodProps = ["continue", "continuePrimaryKey", "advance"];
+var methodMap = {};
+var advanceResults = /* @__PURE__ */ new WeakMap();
+var ittrProxiedCursorToOriginalProxy = /* @__PURE__ */ new WeakMap();
+var cursorIteratorTraps = {
+  get(target, prop) {
+    if (!advanceMethodProps.includes(prop))
+      return target[prop];
+    let cachedFunc = methodMap[prop];
+    if (!cachedFunc) {
+      cachedFunc = methodMap[prop] = function(...args) {
+        advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
+      };
+    }
+    return cachedFunc;
+  }
+};
+async function* iterate(...args) {
+  let cursor = this;
+  if (!(cursor instanceof IDBCursor)) {
+    cursor = await cursor.openCursor(...args);
+  }
+  if (!cursor)
+    return;
+  cursor = cursor;
+  const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
+  ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
+  reverseTransformCache.set(proxiedCursor, unwrap(cursor));
+  while (cursor) {
+    yield proxiedCursor;
+    cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
+    advanceResults.delete(proxiedCursor);
+  }
+}
+function isIteratorProp(target, prop) {
+  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === "iterate" && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
+}
+replaceTraps((oldTraps) => ({
+  ...oldTraps,
+  get(target, prop, receiver) {
+    if (isIteratorProp(target, prop))
+      return iterate;
+    return oldTraps.get(target, prop, receiver);
+  },
+  has(target, prop) {
+    return isIteratorProp(target, prop) || oldTraps.has(target, prop);
+  }
+}));
+
+// ../core/dist/internal/chunk-PKJXHY27.mjs
+function lockKeyFor(key) {
+  return `mostlyright:cache:lock:${key}`;
+}
+var MemoryStore = class {
+  #entries = /* @__PURE__ */ new Map();
+  #chain = /* @__PURE__ */ new Map();
+  async get(key) {
+    const e = this.#entries.get(key);
+    if (e === void 0) return null;
+    if (e.expiresAt !== void 0 && Date.now() >= e.expiresAt) {
+      this.#entries.delete(key);
+      return null;
+    }
+    return structuredClone(e.value);
+  }
+  async set(key, value, opts) {
+    const cloned = structuredClone(value);
+    const entry = opts?.ttlMs !== void 0 ? { value: cloned, expiresAt: Date.now() + opts.ttlMs } : { value: cloned };
+    this.#entries.set(key, entry);
+  }
+  async delete(key) {
+    this.#entries.delete(key);
+  }
+  /**
+   * Enumerate live (non-expired) keys with the given prefix.
+   *
+   * TS-W6 Wave 1: `availability()` uses this to count cached observation
+   * months and climate years per station. Expired entries are evicted as a
+   * side effect (same lazy-eviction policy as `.get`).
+   */
+  async listKeys(prefix) {
+    const now = Date.now();
+    const out = [];
+    for (const [key, entry] of this.#entries) {
+      if (entry.expiresAt !== void 0 && now >= entry.expiresAt) {
+        this.#entries.delete(key);
+        continue;
+      }
+      if (key.startsWith(prefix)) {
+        out.push(key);
+      }
+    }
+    return Object.freeze(out);
+  }
+  async withLock(key, fn) {
+    const prev = this.#chain.get(key) ?? Promise.resolve();
+    const next = prev.then(
+      () => fn(),
+      () => fn()
+    );
+    const absorbed = next.then(
+      () => void 0,
+      () => void 0
+    );
+    this.#chain.set(key, absorbed);
+    absorbed.finally(() => {
+      if (this.#chain.get(key) === absorbed) {
+        this.#chain.delete(key);
+      }
+    });
+    return next;
+  }
+};
+var DB_NAME = "mostlyright-cache-v1";
+var STORE_NAME = "entries";
+var SCHEMA_VERSION = 1;
+function getWebLocks() {
+  if (typeof navigator === "undefined") return null;
+  const nav = navigator;
+  return nav.locks ?? null;
+}
+var IndexedDBStore = class {
+  #dbName;
+  #dbPromise;
+  #chain = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    this.#dbName = opts.dbName ?? DB_NAME;
+    this.#dbPromise = openDB(this.#dbName, SCHEMA_VERSION, {
+      upgrade(db) {
+        if (!db.objectStoreNames.contains(STORE_NAME)) {
+          db.createObjectStore(STORE_NAME);
+        }
+      }
+    });
+  }
+  async get(key) {
+    const db = await this.#dbPromise;
+    const entry = await db.get(STORE_NAME, key);
+    if (entry === void 0) return null;
+    if (entry.expiresAt !== void 0 && Date.now() >= entry.expiresAt) {
+      try {
+        await db.delete(STORE_NAME, key);
+      } catch {
+      }
+      return null;
+    }
+    return entry.value;
+  }
+  async set(key, value, opts) {
+    const db = await this.#dbPromise;
+    const entry = opts?.ttlMs !== void 0 ? { value, expiresAt: Date.now() + opts.ttlMs } : { value };
+    await db.put(STORE_NAME, entry, key);
+  }
+  async delete(key) {
+    const db = await this.#dbPromise;
+    await db.delete(STORE_NAME, key);
+  }
+  /**
+   * Enumerate keys with the given prefix using IndexedDB's bounded range
+   * query. Live keys only — expired entries are lazy-evicted on read by
+   * `get()`, so a stale-but-not-yet-evicted entry can appear here; callers
+   * who care about expiration should `get()` to confirm.
+   *
+   * TS-W6 Wave 1: `availability()` uses this to count observation months and
+   * climate years for a station.
+   */
+  async listKeys(prefix) {
+    const db = await this.#dbPromise;
+    const range = IDBKeyRange.bound(prefix, `${prefix}\uFFFF`, false, false);
+    const keys = await db.getAllKeys(STORE_NAME, range);
+    const out = [];
+    for (const k of keys) {
+      if (typeof k === "string" && k.startsWith(prefix)) {
+        out.push(k);
+      }
+    }
+    return Object.freeze(out);
+  }
+  async withLock(key, fn) {
+    const locks = getWebLocks();
+    if (locks !== null) {
+      return locks.request(lockKeyFor(key), { mode: "exclusive" }, () => fn());
+    }
+    const prev = this.#chain.get(key) ?? Promise.resolve();
+    const next = prev.then(
+      () => fn(),
+      () => fn()
+    );
+    const absorbed = next.then(
+      () => void 0,
+      () => void 0
+    );
+    this.#chain.set(key, absorbed);
+    absorbed.finally(() => {
+      if (this.#chain.get(key) === absorbed) this.#chain.delete(key);
+    });
+    return next;
+  }
+};
+var STATIONS = [
+  {
+    code: "EDDB",
+    country: "DE",
+    ghcnh_id: null,
+    icao: "EDDB",
+    latitude: 52.3667,
+    longitude: 13.5033,
+    name: "Berlin Brandenburg",
+    tz: "Europe/Berlin"
+  },
+  {
+    code: "EDDF",
+    country: "DE",
+    ghcnh_id: null,
+    icao: "EDDF",
+    latitude: 50.0379,
+    longitude: 8.5622,
+    name: "Frankfurt am Main",
+    tz: "Europe/Berlin"
+  },
+  {
+    code: "EDDM",
+    country: "DE",
+    ghcnh_id: null,
+    icao: "EDDM",
+    latitude: 48.3538,
+    longitude: 11.7861,
+    name: "Munich Franz Josef Strauss",
+    tz: "Europe/Berlin"
+  },
+  {
+    code: "EFHK",
+    country: "FI",
+    ghcnh_id: null,
+    icao: "EFHK",
+    latitude: 60.3172,
+    longitude: 24.9633,
+    name: "Helsinki-Vantaa",
+    tz: "Europe/Helsinki"
+  },
+  {
+    code: "EGKK",
+    country: "GB",
+    ghcnh_id: null,
+    icao: "EGKK",
+    latitude: 51.1481,
+    longitude: -0.1903,
+    name: "London Gatwick",
+    tz: "Europe/London"
+  },
+  {
+    code: "EGLL",
+    country: "GB",
+    ghcnh_id: null,
+    icao: "EGLL",
+    latitude: 51.4706,
+    longitude: -0.4619,
+    name: "London Heathrow",
+    tz: "Europe/London"
+  },
+  {
+    code: "EHAM",
+    country: "NL",
+    ghcnh_id: null,
+    icao: "EHAM",
+    latitude: 52.3086,
+    longitude: 4.7639,
+    name: "Amsterdam Schiphol",
+    tz: "Europe/Amsterdam"
+  },
+  {
+    code: "EKCH",
+    country: "DK",
+    ghcnh_id: null,
+    icao: "EKCH",
+    latitude: 55.6181,
+    longitude: 12.6561,
+    name: "Copenhagen Kastrup",
+    tz: "Europe/Copenhagen"
+  },
+  {
+    code: "EPWA",
+    country: "PL",
+    ghcnh_id: null,
+    icao: "EPWA",
+    latitude: 52.1657,
+    longitude: 20.9671,
+    name: "Warsaw Chopin",
+    tz: "Europe/Warsaw"
+  },
+  {
+    code: "ESSA",
+    country: "SE",
+    ghcnh_id: null,
+    icao: "ESSA",
+    latitude: 59.6519,
+    longitude: 17.9186,
+    name: "Stockholm Arlanda",
+    tz: "Europe/Stockholm"
+  },
+  {
+    code: "ATL",
+    country: "US",
+    ghcnh_id: "USW00013874",
+    icao: "KATL",
+    latitude: 33.6407,
+    longitude: -84.4277,
+    name: "Hartsfield-Jackson Atlanta International",
+    tz: "America/New_York"
+  },
+  {
+    code: "AUS",
+    country: "US",
+    ghcnh_id: "USW00013904",
+    icao: "KAUS",
+    latitude: 30.1975,
+    longitude: -97.6664,
+    name: "Austin-Bergstrom International",
+    tz: "America/Chicago"
+  },
+  {
+    code: "BOS",
+    country: "US",
+    ghcnh_id: "USW00014739",
+    icao: "KBOS",
+    latitude: 42.3656,
+    longitude: -71.0096,
+    name: "Boston Logan International",
+    tz: "America/New_York"
+  },
+  {
+    code: "DCA",
+    country: "US",
+    ghcnh_id: "USW00013743",
+    icao: "KDCA",
+    latitude: 38.8512,
+    longitude: -77.0402,
+    name: "Washington Reagan National",
+    tz: "America/New_York"
+  },
+  {
+    code: "DEN",
+    country: "US",
+    ghcnh_id: "USW00003017",
+    icao: "KDEN",
+    latitude: 39.8561,
+    longitude: -104.6737,
+    name: "Denver International",
+    tz: "America/Denver"
+  },
+  {
+    code: "DFW",
+    country: "US",
+    ghcnh_id: "USW00003927",
+    icao: "KDFW",
+    latitude: 32.8998,
+    longitude: -97.0403,
+    name: "Dallas-Fort Worth International",
+    tz: "America/Chicago"
+  },
+  {
+    code: "HOU",
+    country: "US",
+    ghcnh_id: "USW00012918",
+    icao: "KHOU",
+    latitude: 29.6454,
+    longitude: -95.2789,
+    name: "Houston Hobby",
+    tz: "America/Chicago"
+  },
+  {
+    code: "LAS",
+    country: "US",
+    ghcnh_id: "USW00023169",
+    icao: "KLAS",
+    latitude: 36.084,
+    longitude: -115.1537,
+    name: "Harry Reid (McCarran) International",
+    tz: "America/Los_Angeles"
+  },
+  {
+    code: "LAX",
+    country: "US",
+    ghcnh_id: "USW00023174",
+    icao: "KLAX",
+    latitude: 33.9425,
+    longitude: -118.4081,
+    name: "Los Angeles International",
+    tz: "America/Los_Angeles"
+  },
+  {
+    code: "MDW",
+    country: "US",
+    ghcnh_id: "USW00014819",
+    icao: "KMDW",
+    latitude: 41.7868,
+    longitude: -87.7522,
+    name: "Chicago Midway International",
+    tz: "America/Chicago"
+  },
+  {
+    code: "MIA",
+    country: "US",
+    ghcnh_id: "USW00012839",
+    icao: "KMIA",
+    latitude: 25.7959,
+    longitude: -80.287,
+    name: "Miami International",
+    tz: "America/New_York"
+  },
+  {
+    code: "MSP",
+    country: "US",
+    ghcnh_id: "USW00014922",
+    icao: "KMSP",
+    latitude: 44.8848,
+    longitude: -93.2223,
+    name: "Minneapolis-St Paul International",
+    tz: "America/Chicago"
+  },
+  {
+    code: "MSY",
+    country: "US",
+    ghcnh_id: "USW00012916",
+    icao: "KMSY",
+    latitude: 29.9934,
+    longitude: -90.258,
+    name: "New Orleans Louis Armstrong International",
+    tz: "America/Chicago"
+  },
+  {
+    code: "NYC",
+    country: "US",
+    ghcnh_id: "USW00094728",
+    icao: "KNYC",
+    latitude: 40.7789,
+    longitude: -73.9692,
+    name: "Central Park, New York",
+    tz: "America/New_York"
+  },
+  {
+    code: "OKC",
+    country: "US",
+    ghcnh_id: "USW00013967",
+    icao: "KOKC",
+    latitude: 35.3931,
+    longitude: -97.6007,
+    name: "Oklahoma City Will Rogers World",
+    tz: "America/Chicago"
+  },
+  {
+    code: "PHL",
+    country: "US",
+    ghcnh_id: "USW00013739",
+    icao: "KPHL",
+    latitude: 39.8721,
+    longitude: -75.2411,
+    name: "Philadelphia International",
+    tz: "America/New_York"
+  },
+  {
+    code: "PHX",
+    country: "US",
+    ghcnh_id: "USW00023183",
+    icao: "KPHX",
+    latitude: 33.4373,
+    longitude: -112.0078,
+    name: "Phoenix Sky Harbor International",
+    tz: "America/Phoenix"
+  },
+  {
+    code: "SAT",
+    country: "US",
+    ghcnh_id: "USW00012921",
+    icao: "KSAT",
+    latitude: 29.5337,
+    longitude: -98.4698,
+    name: "San Antonio International",
+    tz: "America/Chicago"
+  },
+  {
+    code: "SEA",
+    country: "US",
+    ghcnh_id: "USW00024233",
+    icao: "KSEA",
+    latitude: 47.4502,
+    longitude: -122.3088,
+    name: "Seattle-Tacoma International",
+    tz: "America/Los_Angeles"
+  },
+  {
+    code: "SFO",
+    country: "US",
+    ghcnh_id: "USW00023234",
+    icao: "KSFO",
+    latitude: 37.6213,
+    longitude: -122.379,
+    name: "San Francisco International",
+    tz: "America/Los_Angeles"
+  },
+  {
+    code: "LEBL",
+    country: "ES",
+    ghcnh_id: null,
+    icao: "LEBL",
+    latitude: 41.2974,
+    longitude: 2.0833,
+    name: "Barcelona El Prat",
+    tz: "Europe/Madrid"
+  },
+  {
+    code: "LEMD",
+    country: "ES",
+    ghcnh_id: null,
+    icao: "LEMD",
+    latitude: 40.4719,
+    longitude: -3.5626,
+    name: "Madrid Barajas",
+    tz: "Europe/Madrid"
+  },
+  {
+    code: "LFPB",
+    country: "FR",
+    ghcnh_id: null,
+    icao: "LFPB",
+    latitude: 48.9694,
+    longitude: 2.4414,
+    name: "Paris Le Bourget",
+    tz: "Europe/Paris"
+  },
+  {
+    code: "LFPG",
+    country: "FR",
+    ghcnh_id: null,
+    icao: "LFPG",
+    latitude: 49.0097,
+    longitude: 2.5479,
+    name: "Paris Charles de Gaulle",
+    tz: "Europe/Paris"
+  },
+  {
+    code: "LFPO",
+    country: "FR",
+    ghcnh_id: null,
+    icao: "LFPO",
+    latitude: 48.7233,
+    longitude: 2.3794,
+    name: "Paris Orly",
+    tz: "Europe/Paris"
+  },
+  {
+    code: "LIMC",
+    country: "IT",
+    ghcnh_id: null,
+    icao: "LIMC",
+    latitude: 45.6306,
+    longitude: 8.7281,
+    name: "Milan Malpensa",
+    tz: "Europe/Rome"
+  },
+  {
+    code: "LIRF",
+    country: "IT",
+    ghcnh_id: null,
+    icao: "LIRF",
+    latitude: 41.8003,
+    longitude: 12.2389,
+    name: "Rome Fiumicino",
+    tz: "Europe/Rome"
+  },
+  {
+    code: "LOWW",
+    country: "AT",
+    ghcnh_id: null,
+    icao: "LOWW",
+    latitude: 48.1103,
+    longitude: 16.5697,
+    name: "Vienna International",
+    tz: "Europe/Vienna"
+  },
+  {
+    code: "LSZH",
+    country: "CH",
+    ghcnh_id: null,
+    icao: "LSZH",
+    latitude: 47.4647,
+    longitude: 8.5492,
+    name: "Zurich",
+    tz: "Europe/Zurich"
+  },
+  {
+    code: "NZAA",
+    country: "NZ",
+    ghcnh_id: null,
+    icao: "NZAA",
+    latitude: -37.0081,
+    longitude: 174.7917,
+    name: "Auckland",
+    tz: "Pacific/Auckland"
+  },
+  {
+    code: "NZWN",
+    country: "NZ",
+    ghcnh_id: null,
+    icao: "NZWN",
+    latitude: -41.3272,
+    longitude: 174.8053,
+    name: "Wellington",
+    tz: "Pacific/Auckland"
+  },
+  {
+    code: "OERK",
+    country: "SA",
+    ghcnh_id: null,
+    icao: "OERK",
+    latitude: 24.9576,
+    longitude: 46.6988,
+    name: "Riyadh King Khalid International",
+    tz: "Asia/Riyadh"
+  },
+  {
+    code: "OMDB",
+    country: "AE",
+    ghcnh_id: null,
+    icao: "OMDB",
+    latitude: 25.2532,
+    longitude: 55.3657,
+    name: "Dubai International",
+    tz: "Asia/Dubai"
+  },
+  {
+    code: "OTHH",
+    country: "QA",
+    ghcnh_id: null,
+    icao: "OTHH",
+    latitude: 25.2731,
+    longitude: 51.608,
+    name: "Doha Hamad International",
+    tz: "Asia/Qatar"
+  },
+  {
+    code: "RCTP",
+    country: "TW",
+    ghcnh_id: null,
+    icao: "RCTP",
+    latitude: 25.0777,
+    longitude: 121.2328,
+    name: "Taipei Taoyuan",
+    tz: "Asia/Taipei"
+  },
+  {
+    code: "RJAA",
+    country: "JP",
+    ghcnh_id: null,
+    icao: "RJAA",
+    latitude: 35.7647,
+    longitude: 140.3864,
+    name: "Tokyo Narita",
+    tz: "Asia/Tokyo"
+  },
+  {
+    code: "RJTT",
+    country: "JP",
+    ghcnh_id: null,
+    icao: "RJTT",
+    latitude: 35.5522,
+    longitude: 139.78,
+    name: "Tokyo Haneda",
+    tz: "Asia/Tokyo"
+  },
+  {
+    code: "RKSI",
+    country: "KR",
+    ghcnh_id: null,
+    icao: "RKSI",
+    latitude: 37.4691,
+    longitude: 126.4505,
+    name: "Seoul Incheon",
+    tz: "Asia/Seoul"
+  },
+  {
+    code: "SAEZ",
+    country: "AR",
+    ghcnh_id: null,
+    icao: "SAEZ",
+    latitude: -34.8222,
+    longitude: -58.5358,
+    name: "Buenos Aires Ezeiza",
+    tz: "America/Argentina/Buenos_Aires"
+  },
+  {
+    code: "SBGR",
+    country: "BR",
+    ghcnh_id: null,
+    icao: "SBGR",
+    latitude: -23.4356,
+    longitude: -46.4731,
+    name: "S\xE3o Paulo Guarulhos",
+    tz: "America/Sao_Paulo"
+  },
+  {
+    code: "UUEE",
+    country: "RU",
+    ghcnh_id: null,
+    icao: "UUEE",
+    latitude: 55.9728,
+    longitude: 37.4147,
+    name: "Moscow Sheremetyevo",
+    tz: "Europe/Moscow"
+  },
+  {
+    code: "VABB",
+    country: "IN",
+    ghcnh_id: null,
+    icao: "VABB",
+    latitude: 19.0887,
+    longitude: 72.8679,
+    name: "Mumbai Chhatrapati Shivaji",
+    tz: "Asia/Kolkata"
+  },
+  {
+    code: "VHHH",
+    country: "HK",
+    ghcnh_id: null,
+    icao: "VHHH",
+    latitude: 22.308,
+    longitude: 113.9185,
+    name: "Hong Kong International",
+    tz: "Asia/Hong_Kong"
+  },
+  {
+    code: "VIDP",
+    country: "IN",
+    ghcnh_id: null,
+    icao: "VIDP",
+    latitude: 28.5562,
+    longitude: 77.1,
+    name: "Delhi Indira Gandhi",
+    tz: "Asia/Kolkata"
+  },
+  {
+    code: "VTBS",
+    country: "TH",
+    ghcnh_id: null,
+    icao: "VTBS",
+    latitude: 13.69,
+    longitude: 100.7501,
+    name: "Bangkok Suvarnabhumi",
+    tz: "Asia/Bangkok"
+  },
+  {
+    code: "WSSS",
+    country: "SG",
+    ghcnh_id: null,
+    icao: "WSSS",
+    latitude: 1.3644,
+    longitude: 103.9915,
+    name: "Singapore Changi",
+    tz: "Asia/Singapore"
+  },
+  {
+    code: "YBBN",
+    country: "AU",
+    ghcnh_id: null,
+    icao: "YBBN",
+    latitude: -27.3842,
+    longitude: 153.1175,
+    name: "Brisbane",
+    tz: "Australia/Brisbane"
+  },
+  {
+    code: "YMML",
+    country: "AU",
+    ghcnh_id: null,
+    icao: "YMML",
+    latitude: -37.6733,
+    longitude: 144.8433,
+    name: "Melbourne Tullamarine",
+    tz: "Australia/Melbourne"
+  },
+  {
+    code: "YSSY",
+    country: "AU",
+    ghcnh_id: null,
+    icao: "YSSY",
+    latitude: -33.9461,
+    longitude: 151.1772,
+    name: "Sydney Kingsford Smith",
+    tz: "Australia/Sydney"
+  },
+  {
+    code: "ZBAA",
+    country: "CN",
+    ghcnh_id: null,
+    icao: "ZBAA",
+    latitude: 40.0801,
+    longitude: 116.5846,
+    name: "Beijing Capital",
+    tz: "Asia/Shanghai"
+  },
+  {
+    code: "ZSPD",
+    country: "CN",
+    ghcnh_id: null,
+    icao: "ZSPD",
+    latitude: 31.1443,
+    longitude: 121.8083,
+    name: "Shanghai Pudong",
+    tz: "Asia/Shanghai"
+  }
+];
+var STATION_BY_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_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_TZ = Object.freeze({
+  // Eastern (UTC-5 standard / UTC-4 DST)
+  NYC: "America/New_York",
+  JFK: "America/New_York",
+  LGA: "America/New_York",
+  EWR: "America/New_York",
+  ATL: "America/New_York",
+  BOS: "America/New_York",
+  PHL: "America/New_York",
+  DCA: "America/New_York",
+  IAD: "America/New_York",
+  BWI: "America/New_York",
+  MIA: "America/New_York",
+  MCO: "America/New_York",
+  TPA: "America/New_York",
+  CLT: "America/New_York",
+  RDU: "America/New_York",
+  CLE: "America/New_York",
+  PIT: "America/New_York",
+  BUF: "America/New_York",
+  DTW: "America/Detroit",
+  IND: "America/Indiana/Indianapolis",
+  CVG: "America/New_York",
+  CMH: "America/New_York",
+  SYR: "America/New_York",
+  ALB: "America/New_York",
+  BTV: "America/New_York",
+  ORF: "America/New_York",
+  RIC: "America/New_York",
+  GSO: "America/New_York",
+  CHS: "America/New_York",
+  SAV: "America/New_York",
+  JAX: "America/New_York",
+  RSW: "America/New_York",
+  PBI: "America/New_York",
+  FLL: "America/New_York",
+  // Central (UTC-6 standard / UTC-5 DST)
+  ORD: "America/Chicago",
+  MDW: "America/Chicago",
+  DFW: "America/Chicago",
+  DAL: "America/Chicago",
+  IAH: "America/Chicago",
+  HOU: "America/Chicago",
+  MSP: "America/Chicago",
+  STL: "America/Chicago",
+  MCI: "America/Chicago",
+  OMA: "America/Chicago",
+  MKE: "America/Chicago",
+  MSY: "America/Chicago",
+  MEM: "America/Chicago",
+  BNA: "America/Chicago",
+  OKC: "America/Chicago",
+  SAT: "America/Chicago",
+  AUS: "America/Chicago",
+  DSM: "America/Chicago",
+  TUL: "America/Chicago",
+  LIT: "America/Chicago",
+  BIR: "America/Chicago",
+  SDF: "America/Chicago",
+  HSV: "America/Chicago",
+  BHM: "America/Chicago",
+  MOB: "America/Chicago",
+  BTR: "America/Chicago",
+  SHV: "America/Chicago",
+  // Mountain (UTC-7 standard / UTC-6 DST)
+  DEN: "America/Denver",
+  SLC: "America/Denver",
+  ABQ: "America/Denver",
+  BOI: "America/Boise",
+  BZN: "America/Denver",
+  GJT: "America/Denver",
+  // Arizona: no DST (UTC-7 always)
+  PHX: "America/Phoenix",
+  TUS: "America/Phoenix",
+  // Pacific (UTC-8 standard / UTC-7 DST)
+  LAX: "America/Los_Angeles",
+  SFO: "America/Los_Angeles",
+  SEA: "America/Los_Angeles",
+  PDX: "America/Los_Angeles",
+  LAS: "America/Los_Angeles",
+  SAN: "America/Los_Angeles",
+  OAK: "America/Los_Angeles",
+  SJC: "America/Los_Angeles",
+  SMF: "America/Los_Angeles",
+  RNO: "America/Los_Angeles",
+  FAT: "America/Los_Angeles",
+  SNA: "America/Los_Angeles",
+  ONT: "America/Los_Angeles",
+  BUR: "America/Los_Angeles",
+  // Alaska (UTC-9 standard / UTC-8 DST)
+  ANC: "America/Anchorage",
+  FAI: "America/Anchorage",
+  JNU: "America/Juneau",
+  // Hawaii (UTC-10, no DST)
+  HNL: "Pacific/Honolulu",
+  OGG: "Pacific/Honolulu",
+  KOA: "Pacific/Honolulu",
+  // International (iter-6 H12): minimal set required to un-skip the
+  // case-5 RJTT year-wrap cache behavior test. Python's
+  // `mostlyright.snapshot._resolve_tz` falls back to the broader STATIONS
+  // registry for intl ICAOs; the TS port hasn't ported that fallback
+  // yet (tracked as TS-W6 — exhaustive intl-station tz coverage). This
+  // entry closes H12 cleanly without pulling the whole STATIONS map in.
+  // ICAO key (RJTT) — international stations have no 3-letter NWS code.
+  // Tokyo Haneda — UTC+9 LST, no DST.
+  RJTT: "Asia/Tokyo"
+});
+var _JAN_REF = new Date(Date.UTC(2024, 0, 15, 12, 0, 0));
+var _OFFSET_CACHE = /* @__PURE__ */ new Map();
+function _lstOffsetHours(stationTz) {
+  const cached = _OFFSET_CACHE.get(stationTz);
+  if (cached !== void 0) return cached;
+  const fmt = new Intl.DateTimeFormat("en-US", {
+    timeZone: stationTz,
+    hour12: false,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  const parts = fmt.formatToParts(_JAN_REF);
+  const get = (type) => {
+    const part = parts.find((p) => p.type === type);
+    if (!part) {
+      throw new Error(`Intl.DateTimeFormat missing ${type} for tz=${stationTz}`);
+    }
+    return Number(part.value);
+  };
+  const year = get("year");
+  const month = get("month");
+  const day = get("day");
+  let hour = get("hour");
+  const minute = get("minute");
+  const second = get("second");
+  if (hour === 24) hour = 0;
+  const localAsUtc = Date.UTC(year, month - 1, day, hour, minute, second);
+  const offsetMs = localAsUtc - _JAN_REF.getTime();
+  const offsetHours = offsetMs / 36e5;
+  _OFFSET_CACHE.set(stationTz, offsetHours);
+  return offsetHours;
+}
+function _lstOffsetHoursFor(station) {
+  const upper = station.trim().toUpperCase();
+  const byCode = STATION_BY_CODE2.get(upper);
+  if (byCode !== void 0) return _lstOffsetHours(byCode.tz);
+  const byIcao = STATION_BY_ICAO2.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);
+    if (retry !== void 0) return _lstOffsetHours(retry.tz);
+  }
+  throw new RangeError(`unknown station: ${JSON.stringify(station)}`);
+}
+function _nowLst(station, now = /* @__PURE__ */ new Date()) {
+  const offsetHours = _lstOffsetHoursFor(station);
+  return new Date(now.getTime() + offsetHours * 36e5);
+}
+function shouldSkipCacheForCurrentLstMonth(station, year, month, now) {
+  const lst = _nowLst(station, now);
+  return lst.getUTCFullYear() === year && lst.getUTCMonth() + 1 === month;
+}
+function shouldSkipCacheForCurrentLstYear(station, year, now) {
+  const lst = _nowLst(station, now);
+  return lst.getUTCFullYear() === year;
+}
+function isWritableMonth(year, month, now) {
+  const nowYear = now.getUTCFullYear();
+  const nowMonth = now.getUTCMonth() + 1;
+  if (year < nowYear) return true;
+  if (year > nowYear) return false;
+  return month < nowMonth;
+}
+function isWritableYear(year, now) {
+  return year < now.getUTCFullYear();
+}
+function isLiveSource2(source) {
+  return typeof source === "string" && source.length > 0 && source.endsWith(".live");
+}
+function isWithinVolatileWindow(eventDate, archiveAsOf, days = 30) {
+  const e = Date.parse(`${eventDate}T00:00:00Z`);
+  const a = Date.parse(`${archiveAsOf}T00:00:00Z`);
+  if (!Number.isFinite(e) || !Number.isFinite(a)) {
+    throw new RangeError(
+      `invalid YYYY-MM-DD: eventDate=${JSON.stringify(eventDate)} archiveAsOf=${JSON.stringify(archiveAsOf)}`
+    );
+  }
+  const deltaDays = (a - e) / 864e5;
+  return deltaDays >= 0 && deltaDays <= days;
+}
+var MIN_YEAR2 = 1900;
+var MAX_YEAR2 = 2100;
+var SOURCE_RE = /^[a-z0-9_-]+$/;
+function cacheKeyForObservations(station, year, month, source) {
+  if (!Number.isInteger(year) || year < MIN_YEAR2 || year > MAX_YEAR2) {
+    throw new RangeError(`year out of range: ${year}`);
+  }
+  if (!Number.isInteger(month) || month < 1 || month > 12) {
+    throw new RangeError(`month out of range: ${month}`);
+  }
+  const yyyy = String(year).padStart(4, "0");
+  const mm = String(month).padStart(2, "0");
+  const base = `mostlyright:v1:observations:${station.toUpperCase()}:${yyyy}:${mm}`;
+  if (source === void 0) return base;
+  if (typeof source !== "string" || !SOURCE_RE.test(source)) {
+    throw new RangeError(
+      `source must match ${SOURCE_RE.source} (lowercase alnum / hyphen / underscore); got ${JSON.stringify(source)}`
+    );
+  }
+  return `${base}:${source}`;
+}
+function cacheKeyForClimate(station, year) {
+  if (!Number.isInteger(year) || year < MIN_YEAR2 || year > MAX_YEAR2) {
+    throw new RangeError(`year out of range: ${year}`);
+  }
+  const yyyy = String(year).padStart(4, "0");
+  return `mostlyright:v1:climate:${station.toUpperCase()}:${yyyy}`;
+}
+
+// ../core/dist/internal/cache/index.browser.mjs
+async function defaultCacheStore() {
+  if (typeof indexedDB !== "undefined") return new IndexedDBStore();
+  return new MemoryStore();
+}
+
+// ../core/dist/internal/pairs.mjs
+var _STATION_TZ2 = Object.freeze({
+  // Eastern (UTC-5 standard / UTC-4 DST)
+  NYC: "America/New_York",
+  JFK: "America/New_York",
+  LGA: "America/New_York",
+  EWR: "America/New_York",
+  ATL: "America/New_York",
+  BOS: "America/New_York",
+  PHL: "America/New_York",
+  DCA: "America/New_York",
+  IAD: "America/New_York",
+  BWI: "America/New_York",
+  MIA: "America/New_York",
+  MCO: "America/New_York",
+  TPA: "America/New_York",
+  CLT: "America/New_York",
+  RDU: "America/New_York",
+  CLE: "America/New_York",
+  PIT: "America/New_York",
+  BUF: "America/New_York",
+  DTW: "America/Detroit",
+  IND: "America/Indiana/Indianapolis",
+  CVG: "America/New_York",
+  CMH: "America/New_York",
+  SYR: "America/New_York",
+  ALB: "America/New_York",
+  BTV: "America/New_York",
+  ORF: "America/New_York",
+  RIC: "America/New_York",
+  GSO: "America/New_York",
+  CHS: "America/New_York",
+  SAV: "America/New_York",
+  JAX: "America/New_York",
+  RSW: "America/New_York",
+  PBI: "America/New_York",
+  FLL: "America/New_York",
+  // Central (UTC-6 standard / UTC-5 DST)
+  ORD: "America/Chicago",
+  MDW: "America/Chicago",
+  DFW: "America/Chicago",
+  DAL: "America/Chicago",
+  IAH: "America/Chicago",
+  HOU: "America/Chicago",
+  MSP: "America/Chicago",
+  STL: "America/Chicago",
+  MCI: "America/Chicago",
+  OMA: "America/Chicago",
+  MKE: "America/Chicago",
+  MSY: "America/Chicago",
+  MEM: "America/Chicago",
+  BNA: "America/Chicago",
+  OKC: "America/Chicago",
+  SAT: "America/Chicago",
+  AUS: "America/Chicago",
+  DSM: "America/Chicago",
+  TUL: "America/Chicago",
+  LIT: "America/Chicago",
+  BIR: "America/Chicago",
+  SDF: "America/Chicago",
+  HSV: "America/Chicago",
+  BHM: "America/Chicago",
+  MOB: "America/Chicago",
+  BTR: "America/Chicago",
+  SHV: "America/Chicago",
+  // Mountain (UTC-7 standard / UTC-6 DST)
+  DEN: "America/Denver",
+  SLC: "America/Denver",
+  ABQ: "America/Denver",
+  BOI: "America/Boise",
+  BZN: "America/Denver",
+  GJT: "America/Denver",
+  // Arizona: no DST (UTC-7 always)
+  PHX: "America/Phoenix",
+  TUS: "America/Phoenix",
+  // Pacific (UTC-8 standard / UTC-7 DST)
+  LAX: "America/Los_Angeles",
+  SFO: "America/Los_Angeles",
+  SEA: "America/Los_Angeles",
+  PDX: "America/Los_Angeles",
+  LAS: "America/Los_Angeles",
+  SAN: "America/Los_Angeles",
+  OAK: "America/Los_Angeles",
+  SJC: "America/Los_Angeles",
+  SMF: "America/Los_Angeles",
+  RNO: "America/Los_Angeles",
+  FAT: "America/Los_Angeles",
+  SNA: "America/Los_Angeles",
+  ONT: "America/Los_Angeles",
+  BUR: "America/Los_Angeles",
+  // Alaska (UTC-9 standard / UTC-8 DST)
+  ANC: "America/Anchorage",
+  FAI: "America/Anchorage",
+  JNU: "America/Juneau",
+  // Hawaii (UTC-10, no DST)
+  HNL: "Pacific/Honolulu",
+  OGG: "Pacific/Honolulu",
+  KOA: "Pacific/Honolulu",
+  // International (iter-6 H12): minimal set required to un-skip the
+  // case-5 RJTT year-wrap cache behavior test. Python's
+  // `mostlyright.snapshot._resolve_tz` falls back to the broader STATIONS
+  // registry for intl ICAOs; the TS port hasn't ported that fallback
+  // yet (tracked as TS-W6 — exhaustive intl-station tz coverage). This
+  // entry closes H12 cleanly without pulling the whole STATIONS map in.
+  // ICAO key (RJTT) — international stations have no 3-letter NWS code.
+  // Tokyo Haneda — UTC+9 LST, no DST.
+  RJTT: "Asia/Tokyo"
+});
+var _JAN_REF2 = new Date(Date.UTC(2024, 0, 15, 12, 0, 0));
+var _MARKET_CLOSE_HOUR_LST = 16;
+var _MARKET_CLOSE_MINUTE_LST = 30;
+var _OFFSET_CACHE2 = /* @__PURE__ */ new Map();
+function _lstOffsetHours2(stationTz) {
+  const cached = _OFFSET_CACHE2.get(stationTz);
+  if (cached !== void 0) return cached;
+  const fmt = new Intl.DateTimeFormat("en-US", {
+    timeZone: stationTz,
+    hour12: false,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  const parts = fmt.formatToParts(_JAN_REF2);
+  const get = (type) => {
+    const part = parts.find((p) => p.type === type);
+    if (!part) {
+      throw new Error(`Intl.DateTimeFormat missing ${type} for tz=${stationTz}`);
+    }
+    return Number(part.value);
+  };
+  const year = get("year");
+  const month = get("month");
+  const day = get("day");
+  let hour = get("hour");
+  const minute = get("minute");
+  const second = get("second");
+  if (hour === 24) hour = 0;
+  const localAsUtc = Date.UTC(year, month - 1, day, hour, minute, second);
+  const offsetMs = localAsUtc - _JAN_REF2.getTime();
+  const offsetHours = offsetMs / 36e5;
+  _OFFSET_CACHE2.set(stationTz, offsetHours);
+  return offsetHours;
+}
+function _stationCodeNormalized(station) {
+  const s = station.trim().toUpperCase();
+  if (s.length === 4 && s.startsWith("K")) {
+    return s.substring(1);
+  }
+  return s;
+}
+function _resolveStationTz(station, tzOverride) {
+  if (tzOverride) return tzOverride;
+  const code = _stationCodeNormalized(station);
+  const tz = _STATION_TZ2[code];
+  if (tz) return tz;
+  throw new Error(
+    `Unknown station timezone: ${JSON.stringify(code)}. Add it to _STATION_TZ or pass tzOverride="America/...".`
+  );
+}
+function marketCloseUtc(dateStr, station, tzOverride) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(dateStr);
+  if (!match) {
+    throw new Error(`Invalid ISO date for market close: ${JSON.stringify(dateStr)}`);
+  }
+  const [, yStr, mStr, dStr] = match;
+  const year = Number(yStr);
+  const month = Number(mStr);
+  const day = Number(dStr);
+  const tz = _resolveStationTz(station, tzOverride);
+  const offsetHours = _lstOffsetHours2(tz);
+  const marketCloseAsUtcMs = Date.UTC(
+    year,
+    month - 1,
+    day,
+    _MARKET_CLOSE_HOUR_LST,
+    _MARKET_CLOSE_MINUTE_LST,
+    0
+  );
+  return new Date(marketCloseAsUtcMs - offsetHours * 36e5);
+}
+function collectNonNull(obs, key) {
+  const out = [];
+  for (const o of obs) {
+    const v = o[key];
+    if (typeof v === "number" && Number.isFinite(v)) out.push(v);
+  }
+  return out;
+}
+function meanOrNull(vs) {
+  if (vs.length === 0) return null;
+  let s = 0;
+  for (const v of vs) s += v;
+  return s / vs.length;
+}
+function maxOrNull(vs) {
+  if (vs.length === 0) return null;
+  let best = vs[0];
+  for (let i = 1; i < vs.length; i++) {
+    const v = vs[i];
+    if (v > best) best = v;
+  }
+  return best;
+}
+function minOrNull(vs) {
+  if (vs.length === 0) return null;
+  let best = vs[0];
+  for (let i = 1; i < vs.length; i++) {
+    const v = vs[i];
+    if (v < best) best = v;
+  }
+  return best;
+}
+function sumOrNull(vs) {
+  if (vs.length === 0) return null;
+  let s = 0;
+  for (const v of vs) s += v;
+  return s;
+}
+function _obsAggregates(observations) {
+  if (observations.length === 0) {
+    return Object.freeze({
+      obs_high_f: null,
+      obs_low_f: null,
+      obs_mean_f: null,
+      obs_mean_dewpoint_f: null,
+      obs_max_wind_kt: null,
+      obs_max_gust_kt: null,
+      obs_total_precip_in: null,
+      obs_count: 0
+    });
+  }
+  const temps = collectNonNull(observations, "temp_f");
+  const dewps = collectNonNull(observations, "dewpoint_f");
+  const winds = collectNonNull(observations, "wind_speed_kt");
+  const gusts = collectNonNull(observations, "wind_gust_kt");
+  const precips = collectNonNull(observations, "precip_1hr_inches");
+  return Object.freeze({
+    obs_high_f: maxOrNull(temps),
+    obs_low_f: minOrNull(temps),
+    obs_mean_f: meanOrNull(temps),
+    obs_mean_dewpoint_f: meanOrNull(dewps),
+    obs_max_wind_kt: maxOrNull(winds),
+    obs_max_gust_kt: maxOrNull(gusts),
+    obs_total_precip_in: sumOrNull(precips),
+    obs_count: observations.length
+  });
+}
+function buildPairsRow(dateStr, station, observations, climate, opts = {}) {
+  const obsAgg = _obsAggregates(observations);
+  const closeUtc = marketCloseUtc(dateStr, station, opts.tzOverride);
+  const closeIso = `${closeUtc.toISOString().slice(0, 19)}Z`;
+  return Object.freeze({
+    date: dateStr,
+    station,
+    cli_high_f: climate ? climate.high_temp_f : null,
+    cli_low_f: climate ? climate.low_temp_f : null,
+    cli_report_type: climate ? climate.report_type : null,
+    obs_high_f: obsAgg.obs_high_f,
+    obs_low_f: obsAgg.obs_low_f,
+    obs_mean_f: obsAgg.obs_mean_f,
+    obs_mean_dewpoint_f: obsAgg.obs_mean_dewpoint_f,
+    obs_max_wind_kt: obsAgg.obs_max_wind_kt,
+    obs_max_gust_kt: obsAgg.obs_max_gust_kt,
+    obs_total_precip_in: obsAgg.obs_total_precip_in,
+    obs_count: obsAgg.obs_count,
+    fcst_high_f: null,
+    fcst_low_f: null,
+    fcst_model: null,
+    fcst_issued_at: null,
+    fcst_pop_6hr_pct: null,
+    fcst_qpf_6hr_in: null,
+    market_close_utc: closeIso
+  });
+}
+function buildPairs(station, dates, observationsByDate, climateByDate, opts = {}) {
+  const out = [];
+  for (const date of dates) {
+    const obs = observationsByDate[date] ?? [];
+    const climate = climateByDate[date] ?? null;
+    out.push(buildPairsRow(date, station, obs, climate, opts));
+  }
+  return Object.freeze(out);
+}
+
+// src/research.ts
+var AWC_MAX_HOURS2 = 168;
+async function resolveCache(opts) {
+  if (opts.cache === null) return null;
+  if (opts.cache !== void 0) return opts.cache;
+  return await defaultCacheStore();
+}
+var DATE_RE3 = /^\d{4}-\d{2}-\d{2}$/;
+function normalizeStation2(input) {
+  const raw = input.trim().toUpperCase();
+  if (raw.length === 0) {
+    throw new Error("station must be a non-empty string");
+  }
+  const byIcao = STATION_BY_ICAO.get(raw);
+  if (byIcao !== void 0) {
+    if (byIcao.code === null) {
+      throw new Error(`station ${JSON.stringify(raw)} has no 3-letter NWS code`);
+    }
+    return {
+      code: byIcao.code,
+      icao: byIcao.icao,
+      tz: byIcao.tz,
+      country: byIcao.country,
+      ghcnhId: byIcao.ghcnh_id
+    };
+  }
+  const byCode = STATION_BY_CODE.get(raw);
+  if (byCode !== void 0) {
+    if (byCode.code === null) {
+      throw new Error(`station ${JSON.stringify(raw)} has no 3-letter NWS code`);
+    }
+    return {
+      code: byCode.code,
+      icao: byCode.icao,
+      tz: byCode.tz,
+      country: byCode.country,
+      ghcnhId: byCode.ghcnh_id
+    };
+  }
+  if (raw.startsWith("K") && raw.length === 4) {
+    const stripped = raw.slice(1);
+    const retry = STATION_BY_CODE.get(stripped);
+    if (retry !== void 0 && retry.code !== null) {
+      return {
+        code: retry.code,
+        icao: retry.icao,
+        tz: retry.tz,
+        country: retry.country,
+        ghcnhId: retry.ghcnh_id
+      };
+    }
+  }
+  throw new Error(
+    `unknown station ${JSON.stringify(input)} \u2014 not found in STATION_BY_CODE or STATION_BY_ICAO`
+  );
+}
+function parseIsoDate2(s) {
+  if (!DATE_RE3.test(s)) {
+    throw new Error(`expected YYYY-MM-DD, got ${JSON.stringify(s)}`);
+  }
+  const [yStr, mStr, dStr] = s.split("-");
+  const year = Number(yStr);
+  const month = Number(mStr);
+  const day = Number(dStr);
+  const ms = Date.UTC(year, month - 1, day);
+  const d = new Date(ms);
+  if (d.getUTCFullYear() !== year || d.getUTCMonth() !== month - 1 || d.getUTCDate() !== day) {
+    throw new Error(`invalid calendar date ${JSON.stringify(s)}`);
+  }
+  return d;
+}
+function formatDate(d) {
+  const y = d.getUTCFullYear();
+  const m = d.getUTCMonth() + 1;
+  const day = d.getUTCDate();
+  const mm = m < 10 ? `0${m}` : `${m}`;
+  const dd = day < 10 ? `0${day}` : `${day}`;
+  return `${y}-${mm}-${dd}`;
+}
+function buildDateList(fromDate, toDate) {
+  const from = parseIsoDate2(fromDate);
+  const to = parseIsoDate2(toDate);
+  if (from.getTime() > to.getTime()) {
+    throw new Error(`fromDate (${fromDate}) must be <= toDate (${toDate})`);
+  }
+  const dates = [];
+  for (let cursor = from.getTime(); cursor <= to.getTime(); cursor += 24 * 36e5) {
+    dates.push(formatDate(new Date(cursor)));
+  }
+  return dates;
+}
+function plusOneDay(isoDate) {
+  const d = parseIsoDate2(isoDate);
+  return formatDate(new Date(d.getTime() + 24 * 36e5));
+}
+function isUsStation(station) {
+  return station.country === "US";
+}
+function anyDateOverlapsAwc(toDate, hours, now) {
+  const to = parseIsoDate2(toDate);
+  const toEndMs = to.getTime() + 24 * 36e5;
+  const nowMs = now.getTime();
+  const cutoffMs = nowMs - hours * 36e5;
+  return toEndMs >= cutoffMs;
+}
+function observedSettlementDate(observedAt, station) {
+  const ms = Date.parse(observedAt);
+  if (!Number.isFinite(ms)) return null;
+  try {
+    return settlementDateFor(new Date(ms), station);
+  } catch {
+    return null;
+  }
+}
+function sortByObservedAtThenSource(rows) {
+  return [...rows].sort((a, b) => {
+    if (a.observed_at < b.observed_at) return -1;
+    if (a.observed_at > b.observed_at) return 1;
+    if (a.source < b.source) return -1;
+    if (a.source > b.source) return 1;
+    return 0;
+  });
+}
+function isYearVolatile(year, now) {
+  const yearEnd = `${String(year).padStart(4, "0")}-12-31`;
+  return isWithinVolatileWindow(yearEnd, formatDate(now), 30);
+}
+function lastDayOfMonth(year, month) {
+  const d = new Date(Date.UTC(year, month, 0));
+  return formatDate(d);
+}
+function isMonthVolatile(year, month, now) {
+  return isWithinVolatileWindow(lastDayOfMonth(year, month), formatDate(now), 30);
+}
+function monthsInRange(fromIsoDate, toIsoDate) {
+  const from = parseIsoDate2(fromIsoDate);
+  const to = parseIsoDate2(toIsoDate);
+  if (from.getTime() > to.getTime()) {
+    throw new Error(`fromDate (${fromIsoDate}) must be <= toDate (${toIsoDate})`);
+  }
+  const pairs = [];
+  let y = from.getUTCFullYear();
+  let m = from.getUTCMonth() + 1;
+  const endY = to.getUTCFullYear();
+  const endM = to.getUTCMonth() + 1;
+  while (y < endY || y === endY && m <= endM) {
+    pairs.push([y, m]);
+    m += 1;
+    if (m > 12) {
+      m = 1;
+      y += 1;
+    }
+  }
+  return pairs;
+}
+async function fetchCliWithCache(fetchIcao, cacheCode, fromYear, toYear, opts, cache, now) {
+  const acc = [];
+  for (let year = fromYear; year <= toYear; year++) {
+    const writable = isWritableYear(year, now);
+    const skipCurrentYear = shouldSkipCacheForCurrentLstYear(cacheCode, year, now);
+    const skipVolatile = isYearVolatile(year, now);
+    const skip = !writable || skipCurrentYear || skipVolatile;
+    if (cache !== null && !skip) {
+      let cached = null;
+      try {
+        cached = await cache.get(cacheKeyForClimate(cacheCode, year));
+      } catch (cacheErr) {
+        console.warn(
+          `[mostlyright] CLI cache.get failed for code=${cacheCode} year=${year}; falling back to live fetch:`,
+          cacheErr
+        );
+      }
+      if (cached !== null) {
+        acc.push(...cached);
+        continue;
+      }
+    }
+    const cliOpts = {};
+    if (opts.signal !== void 0) cliOpts.signal = opts.signal;
+    if (opts.cliPolitenessMs !== void 0) cliOpts.politenessMs = opts.cliPolitenessMs;
+    const cliRaw = await downloadCliRange(fetchIcao, year, year, cliOpts);
+    const parsed = parseCliResponse(cliRaw, cacheCode);
+    acc.push(...parsed);
+    const sample = parsed[0]?.source;
+    if (cache !== null && !skip && !isLiveSource2(sample)) {
+      try {
+        await cache.set(cacheKeyForClimate(cacheCode, year), parsed);
+      } catch (cacheErr) {
+        console.warn(
+          `[mostlyright] CLI cache.set failed for code=${cacheCode} year=${year}; in-memory rows preserved:`,
+          cacheErr
+        );
+      }
+    }
+  }
+  return acc;
+}
+async function fetchIemAsosWithCache(stationCode, _fromYear, _extendedToYear, fromDate, extendedTo, opts, cache, now) {
+  const acc = [];
+  const yearByReportType = /* @__PURE__ */ new Map();
+  async function fetchYearOnce(year, reportType) {
+    const memoKey = `${year}:${reportType}`;
+    const cached = yearByReportType.get(memoKey);
+    if (cached !== void 0) return cached;
+    const iemOpts = {
+      reportType,
+      politenessMs: opts.iemPolitenessMs ?? 1e3
+    };
+    if (opts.signal !== void 0) iemOpts.signal = opts.signal;
+    const chunks = await downloadIemAsos(stationCode, `${year}-01-01`, `${year}-12-31`, iemOpts);
+    const fetched = [];
+    for (const chunk of chunks) {
+      const parsed = parseIemCsv(chunk.csv, {
+        observationTypeOverride: reportType === 3 ? "METAR" : "SPECI"
+      });
+      fetched.push(...parsed);
+    }
+    yearByReportType.set(memoKey, fetched);
+    return fetched;
+  }
+  function filterMonth(rows, year, month) {
+    const yyyy = String(year).padStart(4, "0");
+    const mm = String(month).padStart(2, "0");
+    const prefix = `${yyyy}-${mm}-`;
+    const out = [];
+    for (const r of rows) {
+      if (r.observed_at.startsWith(prefix)) out.push(r);
+    }
+    return out;
+  }
+  const pairs = monthsInRange(fromDate, extendedTo);
+  for (const [year, month] of pairs) {
+    const cacheKey = cacheKeyForObservations(stationCode, year, month, "iem");
+    const writable = isWritableMonth(year, month, now);
+    const skipCurrentMonth = shouldSkipCacheForCurrentLstMonth(stationCode, year, month, now);
+    const skipVolatile = isMonthVolatile(year, month, now);
+    const skipCache = !writable || skipCurrentMonth || skipVolatile;
+    let monthRows = null;
+    if (cache !== null && !skipCache) {
+      try {
+        const cached = await cache.get(cacheKey);
+        if (cached !== null) monthRows = cached;
+      } catch (cacheErr) {
+        console.warn(
+          `[mostlyright] IEM ASOS cache.get failed for key=${cacheKey}; falling back to live fetch:`,
+          cacheErr
+        );
+      }
+    }
+    if (monthRows === null) {
+      const metar = await fetchYearOnce(year, 3);
+      const speci = await fetchYearOnce(year, 4);
+      const monthMetar = filterMonth(metar, year, month);
+      const monthSpeci = filterMonth(speci, year, month);
+      monthRows = [...monthMetar, ...monthSpeci];
+      const sample = monthRows[0]?.source;
+      if (cache !== null && !skipCache && !isLiveSource2(sample)) {
+        try {
+          await cache.set(cacheKey, monthRows);
+        } catch (cacheErr) {
+          console.warn(
+            `[mostlyright] IEM ASOS cache.set failed for key=${cacheKey}; in-memory rows preserved:`,
+            cacheErr
+          );
+        }
+      }
+    }
+    for (const obs of monthRows) {
+      const obsDate = obs.observed_at.slice(0, 10);
+      if (obsDate >= fromDate && obsDate <= extendedTo) acc.push(obs);
+    }
+  }
+  return acc;
+}
+async function fetchGhcnhWithCache(stationCode, ghcnhId, fromDate, extendedTo, opts, cache, now) {
+  const acc = [];
+  const yearCache = /* @__PURE__ */ new Map();
+  async function fetchYearOnce(year) {
+    const cached = yearCache.get(year);
+    if (cached !== void 0) return cached;
+    const ghcnhOpts = {};
+    if (opts.signal !== void 0) ghcnhOpts.signal = opts.signal;
+    let parsed;
+    try {
+      const yr = await downloadGhcnh(ghcnhId, year, ghcnhOpts);
+      parsed = parseGhcnhPsv(yr.psv);
+    } catch (err) {
+      if (err instanceof NotFoundError) {
+        parsed = [];
+      } else {
+        throw err;
+      }
+    }
+    yearCache.set(year, parsed);
+    return parsed;
+  }
+  function filterMonth(rows, year, month) {
+    const yyyy = String(year).padStart(4, "0");
+    const mm = String(month).padStart(2, "0");
+    const prefix = `${yyyy}-${mm}-`;
+    const out = [];
+    for (const r of rows) {
+      if (r.observed_at.startsWith(prefix) && r.station_code === stationCode) out.push(r);
+    }
+    return out;
+  }
+  const pairs = monthsInRange(fromDate, extendedTo);
+  for (const [year, month] of pairs) {
+    const cacheKey = cacheKeyForObservations(stationCode, year, month, "ghcnh");
+    const writable = isWritableMonth(year, month, now);
+    const skipCurrentMonth = shouldSkipCacheForCurrentLstMonth(stationCode, year, month, now);
+    const skipVolatile = isMonthVolatile(year, month, now);
+    const skipCache = !writable || skipCurrentMonth || skipVolatile;
+    let monthRows = null;
+    if (cache !== null && !skipCache) {
+      try {
+        const cached = await cache.get(cacheKey);
+        if (cached !== null) monthRows = cached;
+      } catch (cacheErr) {
+        console.warn(
+          `[mostlyright] GHCNh cache.get failed for key=${cacheKey}; falling back to live fetch:`,
+          cacheErr
+        );
+      }
+    }
+    if (monthRows === null) {
+      const yearRows = await fetchYearOnce(year);
+      monthRows = filterMonth(yearRows, year, month);
+      const sample = monthRows[0]?.source;
+      if (cache !== null && !skipCache && !isLiveSource2(sample)) {
+        try {
+          await cache.set(cacheKey, monthRows);
+        } catch (cacheErr) {
+          console.warn(
+            `[mostlyright] GHCNh cache.set failed for key=${cacheKey}; in-memory rows preserved:`,
+            cacheErr
+          );
+        }
+      }
+    }
+    for (const obs of monthRows) {
+      const obsDate = obs.observed_at.slice(0, 10);
+      if (obsDate >= fromDate && obsDate <= extendedTo) acc.push(obs);
+    }
+  }
+  return acc;
+}
+async function research(station, fromDate, toDate, opts = {}) {
+  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;
+  const hasStation = typeof station === "string" && station.length > 0;
+  const selectorCount = Number(hasStation) + Number(hasCity) + Number(hasContract) + Number(hasContracts);
+  if (selectorCount === 0) {
+    throw new Error(
+      "research(): exactly one of station, opts.city, opts.contract, opts.contracts must be provided"
+    );
+  }
+  if (selectorCount > 1) {
+    const names = [];
+    if (hasStation) names.push("station");
+    if (hasCity) names.push("city");
+    if (hasContract) names.push("contract");
+    if (hasContracts) names.push("contracts");
+    throw new Error(`research(): selectors are mutually exclusive; got ${JSON.stringify(names)}`);
+  }
+  if (opts.sources !== void 0 && opts.source !== void 0) {
+    throw new Error("research(): sources and source are mutually exclusive");
+  }
+  if (opts.sources !== void 0 || opts.source !== void 0) {
+    throw new Error(
+      "research(): sources / source validation surface is shipped in Phase 10 v0.2 but the data-selection wiring lands in v0.3. For Mode 2 single-source pinning today, use `researchBySource(station, source, ...)` from @mostlyrightmd/meta."
+    );
+  }
+  if (opts.stationOverride !== void 0 && !hasContract) {
+    throw new Error(
+      "research(): stationOverride requires contract (not standalone station/city/contracts)"
+    );
+  }
+  if (opts.includeTrades === true && !(hasContract || hasContracts)) {
+    throw new Error(
+      "research(): includeTrades requires contract or contracts (station/city selectors have no trade timeseries)"
+    );
+  }
+  if (hasCity || hasContract || hasContracts) {
+    throw new Error(
+      "research(): city/contract/contracts selectors are validated in Phase 10 v0.2 but the multi-station/multi-issuer JOIN + trade attachment lands in v0.3. For now, use `discover({city})` to find the station then call `research(station, fromDate, toDate)` directly."
+    );
+  }
+  const resolved = normalizeStation2(station);
+  const dates = buildDateList(fromDate, toDate);
+  const extendedTo = plusOneDay(toDate);
+  const fromYear = Number(fromDate.slice(0, 4));
+  const toYear = Number(toDate.slice(0, 4));
+  const extendedToYear = Number(extendedTo.slice(0, 4));
+  const baseOpts = {};
+  if (opts.signal !== void 0) baseOpts.signal = opts.signal;
+  const cache = await resolveCache(opts);
+  const cacheNow = opts.now ?? /* @__PURE__ */ new Date();
+  let mergedClimate = [];
+  try {
+    const cliRows = await fetchCliWithCache(
+      resolved.icao,
+      resolved.code,
+      fromYear,
+      toYear,
+      opts,
+      cache,
+      cacheNow
+    );
+    mergedClimate = mergeClimate(cliRows);
+  } catch (err) {
+    if (err instanceof DOMException && (err.name === "AbortError" || err.name === "TimeoutError")) {
+      throw err;
+    }
+  }
+  const awcHours = opts.awcHours ?? AWC_MAX_HOURS2;
+  const awcRows = [];
+  if (anyDateOverlapsAwc(toDate, awcHours, opts.now ?? /* @__PURE__ */ new Date())) {
+    const awcOpts = { hours: awcHours };
+    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 iemRows = await fetchIemAsosWithCache(
+    resolved.code,
+    fromYear,
+    extendedToYear,
+    fromDate,
+    extendedTo,
+    opts,
+    cache,
+    cacheNow
+  );
+  let ghcnhRows = [];
+  if (isUsStation(resolved) && resolved.ghcnhId !== null && resolved.ghcnhId.length > 0) {
+    ghcnhRows = await fetchGhcnhWithCache(
+      resolved.code,
+      resolved.ghcnhId,
+      fromDate,
+      extendedTo,
+      opts,
+      cache,
+      cacheNow
+    );
+  }
+  const combinedRaw = [...awcRows, ...iemRows, ...ghcnhRows];
+  const sorted = sortByObservedAtThenSource(combinedRaw);
+  const merged = mergeObservations(sorted);
+  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);
+    if (settleDate === null) continue;
+    if (settleDate < dateLo || settleDate > dateHi) continue;
+    let bucket = observationsByDate[settleDate];
+    if (bucket === void 0) {
+      bucket = [];
+      observationsByDate[settleDate] = bucket;
+    }
+    bucket.push(obs);
+  }
+  const climateByDate = {};
+  for (const cli of mergedClimate) {
+    climateByDate[cli.observation_date] = cli;
+  }
+  return buildPairs(resolved.code, dates, observationsByDate, climateByDate);
+}
+
+// src/mode2.ts
+var MODE2_SOURCES = ["iem.archive", "iem.live", "awc.live", "ghcnh.archive"];
+var SOURCE_ALIASES = /* @__PURE__ */ new Map([
+  ["iem.archive", /* @__PURE__ */ new Set(["iem", "iem.archive"])],
+  ["iem.live", /* @__PURE__ */ new Set(["iem", "iem.live"])],
+  ["awc.live", /* @__PURE__ */ new Set(["awc", "awc.live"])],
+  ["ghcnh.archive", /* @__PURE__ */ new Set(["ghcnh", "ghcnh.archive"])]
+]);
+function isMode2Source(value) {
+  return typeof value === "string" && MODE2_SOURCES.includes(value);
+}
+function assertSourceIdentity(rows, expected, role = "observations") {
+  const accept = typeof expected === "string" ? /* @__PURE__ */ new Set([expected]) : expected;
+  const expectedLabel = typeof expected === "string" ? expected : [...accept].sort().join("|");
+  const distinct = /* @__PURE__ */ new Set();
+  let bad = 0;
+  for (const r of rows) {
+    const src = r?.source;
+    if (typeof src !== "string") continue;
+    if (!accept.has(src)) {
+      distinct.add(src);
+      bad += 1;
+    }
+  }
+  if (bad === 0) return;
+  const others = [...distinct].sort();
+  const first = others[0] ?? "<unknown>";
+  throw new SourceMismatchError(
+    `Mode 2 dispatch requested '${expectedLabel}' but received ${bad} row(s) with other sources: [${others.map((s) => `'${s}'`).join(", ")}]`,
+    {
+      schemaSource: expectedLabel,
+      dataSource: first,
+      role,
+      catalogWarning: null
+    }
+  );
+}
+var AWC_MAX_HOURS3 = 168;
+var DATE_RE4 = /^\d{4}-\d{2}-\d{2}$/;
+function resolveStation(input) {
+  const raw = input.trim().toUpperCase();
+  if (raw.length === 0) {
+    throw new Error("station must be a non-empty string");
+  }
+  const byIcao = STATION_BY_ICAO.get(raw);
+  if (byIcao !== void 0) {
+    if (byIcao.code === null) {
+      throw new Error(`station ${JSON.stringify(raw)} has no 3-letter NWS code`);
+    }
+    return {
+      code: byIcao.code,
+      icao: byIcao.icao,
+      country: byIcao.country,
+      ghcnhId: byIcao.ghcnh_id
+    };
+  }
+  const byCode = STATION_BY_CODE.get(raw);
+  if (byCode !== void 0) {
+    if (byCode.code === null) {
+      throw new Error(`station ${JSON.stringify(raw)} has no 3-letter NWS code`);
+    }
+    return {
+      code: byCode.code,
+      icao: byCode.icao,
+      country: byCode.country,
+      ghcnhId: byCode.ghcnh_id
+    };
+  }
+  if (raw.startsWith("K") && raw.length === 4) {
+    const stripped = raw.slice(1);
+    const retry = STATION_BY_CODE.get(stripped);
+    if (retry !== void 0 && retry.code !== null) {
+      return {
+        code: retry.code,
+        icao: retry.icao,
+        country: retry.country,
+        ghcnhId: retry.ghcnh_id
+      };
+    }
+  }
+  throw new Error(
+    `unknown station ${JSON.stringify(input)} \u2014 not found in STATION_BY_CODE or STATION_BY_ICAO`
+  );
+}
+function validateDateFormat(label, value) {
+  if (!DATE_RE4.test(value)) {
+    throw new Error(`${label} must be YYYY-MM-DD, got ${JSON.stringify(value)}`);
+  }
+}
+function yearOf(isoDate) {
+  return Number(isoDate.slice(0, 4));
+}
+async function researchBySource(station, source, fromDate, toDate, opts = {}) {
+  if (!isMode2Source(source)) {
+    throw new Error(
+      `Mode 2 source must be one of ${JSON.stringify(
+        MODE2_SOURCES
+      )}; got ${JSON.stringify(source)}`
+    );
+  }
+  if (source === "iem.live") {
+    throw new Error(
+      "Mode 2 source 'iem.live' not yet implemented in v0.1.0 (Parity-Ticket: requires per-month live IEM endpoint not yet ported). Use 'iem.archive' for historical IEM rows."
+    );
+  }
+  validateDateFormat("fromDate", fromDate);
+  validateDateFormat("toDate", toDate);
+  if (fromDate > toDate) {
+    throw new Error(`fromDate (${fromDate}) must be <= toDate (${toDate})`);
+  }
+  const resolved = resolveStation(station);
+  const accept = SOURCE_ALIASES.get(source);
+  if (accept === void 0) {
+    throw new Error(`internal: no SOURCE_ALIASES entry for '${source}'`);
+  }
+  let rows;
+  switch (source) {
+    case "awc.live": {
+      const awcOpts = {
+        hours: opts.awcHours ?? AWC_MAX_HOURS3
+      };
+      if (opts.signal !== void 0) awcOpts.signal = opts.signal;
+      const raw = await fetchAwcMetars([resolved.icao], awcOpts);
+      const parsed = [];
+      for (const m of raw) {
+        const obs = awcToObservation(m);
+        if (obs !== null) parsed.push(obs);
+      }
+      rows = parsed.filter((r) => {
+        const d = r.observed_at.slice(0, 10);
+        return d >= fromDate && d <= toDate;
+      });
+      break;
+    }
+    case "iem.archive": {
+      const fromYear = yearOf(fromDate);
+      const toYear = yearOf(toDate);
+      const collected = [];
+      for (let year = fromYear; year <= toYear; year++) {
+        for (const reportType of [3, 4]) {
+          const iemOpts = {
+            reportType,
+            politenessMs: opts.iemPolitenessMs ?? 1e3
+          };
+          if (opts.signal !== void 0) iemOpts.signal = opts.signal;
+          const chunks = await downloadIemAsos(
+            resolved.code,
+            `${year}-01-01`,
+            `${year}-12-31`,
+            iemOpts
+          );
+          for (const chunk of chunks) {
+            const parsed = parseIemCsv(chunk.csv, {
+              observationTypeOverride: reportType === 3 ? "METAR" : "SPECI"
+            });
+            collected.push(...parsed);
+          }
+        }
+      }
+      rows = collected.filter((r) => {
+        const d = r.observed_at.slice(0, 10);
+        return d >= fromDate && d <= toDate;
+      });
+      break;
+    }
+    case "ghcnh.archive": {
+      if (resolved.country !== "US" || resolved.ghcnhId === null || resolved.ghcnhId.length === 0) {
+        throw new NotFoundError(
+          `GHCNh archive is US-only; station ${JSON.stringify(station)} (country=${resolved.country ?? "null"}, ghcnh_id=${resolved.ghcnhId === null ? "null" : JSON.stringify(resolved.ghcnhId)}) has no GHCNh coverage`
+        );
+      }
+      const fromYear = yearOf(fromDate);
+      const toYear = yearOf(toDate);
+      const collected = [];
+      for (let year = fromYear; year <= toYear; year++) {
+        const ghcnhOpts = {};
+        if (opts.signal !== void 0) ghcnhOpts.signal = opts.signal;
+        try {
+          const yr = await downloadGhcnh(resolved.ghcnhId, year, ghcnhOpts);
+          const parsed = parseGhcnhPsv(yr.psv);
+          for (const r of parsed) {
+            if (r.station_code === resolved.code) collected.push(r);
+          }
+        } catch (err) {
+          if (err instanceof NotFoundError) continue;
+          throw err;
+        }
+      }
+      rows = collected.filter((r) => {
+        const d = r.observed_at.slice(0, 10);
+        return d >= fromDate && d <= toDate;
+      });
+      break;
+    }
+  }
+  const filtered = rows.filter((r) => accept.has(r.source));
+  assertSourceIdentity(filtered, accept, "observations");
+  return filtered;
+}
+
+// ../markets/src/polymarket/types.ts
+var NETLOC_TO_RESOLUTION_TYPE = Object.freeze({
+  "wunderground.com": "wunderground",
+  "www.wunderground.com": "wunderground",
+  "weather.gov": "noaa_wrh",
+  "www.weather.gov": "noaa_wrh"
+});
+var POLYMARKET_RESOLUTION_SOURCE_TYPES = Object.freeze([
+  "wunderground",
+  "noaa_wrh",
+  "hko",
+  "cwa",
+  "other"
+]);
+var MAX_DESCRIPTION_BYTES = 16 * 1024;
+var SETTLE_DELAY_HOURS = Object.freeze({
+  wunderground: 6,
+  noaa_wrh: 4,
+  other: 24
+});
+
+// ../markets/src/polymarket/resolver.ts
+var CITY_KEYS_SORTED = Object.freeze(
+  Object.keys(POLYMARKET_CITY_STATIONS).sort((a, b) => b.length - a.length)
+);
+
+// ../markets/src/polymarket/known-wrong-stations.ts
+var POLYMARKET_KNOWN_WRONG_STATIONS = Object.freeze({
+  // NYC: Polymarket uses KLGA. KNYC/KJFK/KEWR are common wrong answers.
+  nyc: /* @__PURE__ */ new Set(["KNYC", "KJFK", "KEWR"]),
+  // Chicago: Polymarket uses KORD. KMDW is the common wrong answer.
+  chicago: /* @__PURE__ */ new Set(["KMDW"]),
+  // Houston: Polymarket uses KIAH. KHOU is the common wrong answer.
+  houston: /* @__PURE__ */ new Set(["KHOU"]),
+  // Dallas: Polymarket uses KDFW. KDAL is the common wrong answer.
+  dallas: /* @__PURE__ */ new Set(["KDAL"]),
+  // SF: Polymarket uses KSFO. KOAK is the common wrong answer.
+  san_francisco: /* @__PURE__ */ new Set(["KOAK"]),
+  // DC: Polymarket uses KDCA. KIAD/KBWI are common wrong answers.
+  washington_dc: /* @__PURE__ */ new Set(["KIAD", "KBWI"])
+});
+
+// src/compose.ts
+var SELECTOR_NAMES = ["station", "city", "contract", "contracts"];
+var KALSHI_TICKER_ALIASES = {
+  NY: "NYC"
+};
+var CITY_SLUG_ALIASES = {
+  // short_kalshi (lower) → [polymarket_long, kalshi_upper]
+  nyc: ["nyc", "NYC"],
+  chi: ["chicago", "CHI"],
+  lax: ["los_angeles", "LAX"],
+  mia: ["miami", "MIA"],
+  den: ["denver", "DEN"],
+  bos: ["boston", "BOS"],
+  aus: ["austin", "AUS"],
+  dca: ["washington_dc", "DCA"],
+  phl: ["philadelphia", "PHL"],
+  sfo: ["san_francisco", "SFO"],
+  sea: ["seattle", "SEA"],
+  atl: ["atlanta", "ATL"],
+  hou: ["houston", "HOU"],
+  dal: ["dallas", "DAL"],
+  phx: ["phoenix", "PHX"],
+  msp: ["minneapolis", "MSP"],
+  dtw: ["detroit", "DTW"]
+};
+var CITY_SLUG_ALIASES_REVERSE = (() => {
+  const out = {};
+  for (const [shortLower, [longPoly, kalshiUpper]] of Object.entries(CITY_SLUG_ALIASES)) {
+    out[longPoly] = [shortLower, kalshiUpper];
+  }
+  return out;
+})();
+function normalizeCitySlugs(city) {
+  const lower = city.toLowerCase();
+  const upper = city.toUpperCase();
+  const direct = CITY_SLUG_ALIASES[lower];
+  if (direct !== void 0) return direct;
+  const reverse = CITY_SLUG_ALIASES_REVERSE[lower];
+  if (reverse !== void 0) return [lower, reverse[1]];
+  return [lower, upper];
+}
+function validateSelectors(args) {
+  const provided = [];
+  if (typeof args.station === "string" && args.station.length > 0) provided.push("station");
+  if (typeof args.city === "string" && args.city.length > 0) provided.push("city");
+  if (typeof args.contract === "string" && args.contract.length > 0) provided.push("contract");
+  if (Array.isArray(args.contracts) && args.contracts.length > 0) provided.push("contracts");
+  if (provided.length === 0) {
+    throw new Error(
+      "research(): exactly one of station, city, contract, contracts must be provided"
+    );
+  }
+  if (provided.length > 1) {
+    throw new Error(
+      `research(): selectors are mutually exclusive; got ${JSON.stringify(provided)}`
+    );
+  }
+  return provided[0];
+}
+function resolveContract(contractId) {
+  if (typeof contractId !== "string" || !contractId.includes(":")) {
+    throw new TypeError(`contract id must be \`<issuer>:<id>\`; got ${JSON.stringify(contractId)}`);
+  }
+  const colonIdx = contractId.indexOf(":");
+  const issuer = contractId.slice(0, colonIdx).toLowerCase();
+  const raw = contractId.slice(colonIdx + 1);
+  const rawUpper = raw.toUpperCase();
+  if (issuer === "kalshi") {
+    let normalized = rawUpper;
+    if (normalized.startsWith("KX")) {
+      normalized = `K${normalized.slice(2)}`;
+    }
+    const cityOnly = normalized.split("-", 1)[0] ?? "";
+    let cityTickerRaw = null;
+    if (cityOnly.startsWith("KHIGH") && cityOnly.length > 5) {
+      cityTickerRaw = cityOnly.slice(5);
+    } else if (cityOnly.startsWith("KLOW") && cityOnly.length > 4) {
+      cityTickerRaw = cityOnly.slice(4);
+    } else {
+      throw new Error(
+        `unsupported kalshi contract format: ${JSON.stringify(raw)}; expected KHIGH<CITY>* / KXHIGH<CITY>* / KLOW<CITY>* / KXLOW<CITY>* prefix`
+      );
+    }
+    const cityTicker = KALSHI_TICKER_ALIASES[cityTickerRaw] ?? cityTickerRaw;
+    const entry = KALSHI_SETTLEMENT_STATIONS[cityTicker];
+    if (entry === void 0) {
+      throw new Error(`unknown Kalshi city ticker: ${JSON.stringify(cityTicker)}`);
+    }
+    return [entry.station, "kalshi"];
+  }
+  if (issuer === "polymarket") {
+    throw new Error(
+      "polymarket contract resolution requires event_id \u2192 station lookup via polymarketDiscover()/polymarketSettle(); Phase 10 v0.2 defers this to v0.3. Use `city: 'nyc'` or pass `stationOverride` until then."
+    );
+  }
+  throw new Error(
+    `unknown issuer prefix: ${JSON.stringify(issuer)}; expected kalshi or polymarket`
+  );
+}
+function resolveCity(city) {
+  if (typeof city !== "string" || !city) {
+    throw new Error(`city must be a non-empty string; got ${JSON.stringify(city)}`);
+  }
+  const [polySlug, kalshiSlug] = normalizeCitySlugs(city);
+  const out = [];
+  const kalshi = KALSHI_SETTLEMENT_STATIONS[kalshiSlug];
+  if (kalshi !== void 0 && !out.includes(kalshi.station)) {
+    out.push(kalshi.station);
+  }
+  const poly = POLYMARKET_CITY_STATIONS[polySlug];
+  if (poly !== void 0) {
+    for (const measure of ["default", "high", "low"]) {
+      const st = poly[measure];
+      if (typeof st === "string" && !out.includes(st)) out.push(st);
+    }
+  }
+  const wrong = POLYMARKET_KNOWN_WRONG_STATIONS[polySlug];
+  if (wrong !== void 0) {
+    const sortedWrong = [...wrong].sort();
+    for (const st of sortedWrong) {
+      if (!out.includes(st)) out.push(st);
+    }
+  }
+  if (out.length === 0) {
+    throw new Error(`unknown city ${JSON.stringify(city)}; not in kalshi or polymarket catalogs`);
+  }
+  return out;
+}
+function annotateSettlesFor(station, city) {
+  if (city === null) return [];
+  const [polySlug, kalshiSlug] = normalizeCitySlugs(city);
+  const out = [];
+  const kalshi = KALSHI_SETTLEMENT_STATIONS[kalshiSlug];
+  if (kalshi !== void 0 && kalshi.station === station) {
+    out.push(`kalshi:${kalshiSlug}`);
+  }
+  const poly = POLYMARKET_CITY_STATIONS[polySlug];
+  if (poly !== void 0) {
+    for (const measure of ["default", "high", "low"]) {
+      if (poly[measure] === station) {
+        out.push(`polymarket:${polySlug}`);
+        break;
+      }
+    }
+  }
+  return out.sort();
+}
+function buildOverrideWarning(contractStation, overrideStation) {
+  return {
+    kind: "StationOverrideWarning",
+    contractStation,
+    overrideStation,
+    message: `stationOverride=${JSON.stringify(overrideStation)} differs from contract's canonical settlement station ${JSON.stringify(contractStation)}; output row will carry settlementMismatch=true`
+  };
+}
+
+// src/discover.ts
+function discover(args) {
+  if (typeof args !== "object" || args === null) {
+    throw new TypeError(`discover(): args must be an object; got ${typeof args}`);
+  }
+  const stations = resolveCity(args.city);
+  const rows = stations.map((station) => ({
+    city: args.city,
+    station,
+    settlesFor: annotateSettlesFor(station, args.city)
+  }));
+  return Object.freeze({
+    rows: Object.freeze(rows),
+    city: args.city,
+    source: "discover"
+  });
+}
+
+// src/index.ts
+var version3 = "0.0.0";
+export {
+  LiveStreamError,
+  MODE2_SOURCES,
+  NoLiveDataError,
+  POLITE_FLOORS_S,
+  SELECTOR_NAMES,
+  SOURCE_ALIASES,
+  SOURCE_IDENTITY_TAGS,
+  SUPPORTED_SOURCES,
+  annotateSettlesFor,
+  assertSourceIdentity,
+  buildOverrideWarning,
+  src_exports as core,
+  discover,
+  helloCore,
+  helloMarkets,
+  helloWeather,
+  isLiveSource,
+  isMode2Source,
+  latest,
+  src_exports3 as markets,
+  research,
+  researchBySource,
+  resolveCity,
+  resolveContract,
+  sourceTag,
+  stream,
+  validatePollSeconds,
+  validateSelectors,
+  validateSource,
+  version3 as version,
+  src_exports2 as weather
+};
+//# sourceMappingURL=index.bundle.mjs.map