@mostlyrightmd/markets 0.1.0-rc.7

package/dist/polymarket/index.cjs

@@ -0,0 +1,893 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/polymarket/index.ts
+var polymarket_exports = {};
+__export(polymarket_exports, {
+  DEFERRED_STATIONS: () => DEFERRED_STATIONS,
+  EVENT_ID_RE: () => EVENT_ID_RE,
+  MAX_DESCRIPTION_BYTES: () => MAX_DESCRIPTION_BYTES,
+  NETLOC_TO_RESOLUTION_TYPE: () => NETLOC_TO_RESOLUTION_TYPE,
+  POLYMARKET_KNOWN_WRONG_STATIONS: () => POLYMARKET_KNOWN_WRONG_STATIONS,
+  POLYMARKET_RESOLUTION_SOURCE_TYPES: () => POLYMARKET_RESOLUTION_SOURCE_TYPES,
+  PayloadTooLargeError: () => PayloadTooLargeError,
+  PolymarketEventError: () => PolymarketEventError,
+  PolymarketSettlementError: () => PolymarketSettlementError,
+  RESOLUTION_SOURCE_ALLOWLIST: () => RESOLUTION_SOURCE_ALLOWLIST,
+  SETTLE_DELAY_HOURS: () => SETTLE_DELAY_HOURS,
+  SLUG_DATE_RE: () => SLUG_DATE_RE,
+  TooEarlyToSettleError: () => TooEarlyToSettleError,
+  deriveCity: () => deriveCity,
+  detectMarketMeasure: () => detectMarketMeasure,
+  extractIcaoFromResolutionSource: () => extractIcaoFromResolutionSource,
+  extractResolutionSourceType: () => extractResolutionSourceType,
+  fetchEventById: () => fetchEventById,
+  fetchEvents: () => fetchEvents,
+  polymarketDiscover: () => polymarketDiscover,
+  polymarketSettle: () => polymarketSettle,
+  polymarketSettleById: () => polymarketSettleById,
+  resolveStationForEvent: () => resolveStationForEvent,
+  settlementDateFromSlug: () => settlementDateFromSlug,
+  validateDescription: () => validateDescription
+});
+module.exports = __toCommonJS(polymarket_exports);
+
+// src/polymarket/client.ts
+var import_core = require("@mostlyrightmd/core");
+var GAMMA_BASE = "https://gamma-api.polymarket.com";
+var PAGE_SIZE = 100;
+var MAX_EVENTS = 1e4;
+var DEFAULT_USER_AGENT = "mostlyright-ts/0.1.0 (+https://github.com/Tarabcak/mostlyright)";
+var DEFAULT_SLEEP_BETWEEN_MS = 200;
+var RETRY_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+async function sleep(ms, signal) {
+  if (ms <= 0) return;
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      cleanup();
+      reject(signal?.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    function cleanup() {
+      clearTimeout(timer);
+      if (signal !== void 0) signal.removeEventListener("abort", onAbort);
+    }
+    if (signal !== void 0) {
+      if (signal.aborted) {
+        cleanup();
+        reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+async function fetchEvents(opts = {}) {
+  const sleepMs = opts.sleepBetweenMs ?? DEFAULT_SLEEP_BETWEEN_MS;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (let offset = 0; offset < MAX_EVENTS; offset += PAGE_SIZE) {
+    const url = `${GAMMA_BASE}/events?limit=${PAGE_SIZE}&offset=${offset}&active=true&closed=false`;
+    const fetchOpts = {
+      headers: { Accept: "application/json" },
+      userAgent: DEFAULT_USER_AGENT,
+      retryStatuses: RETRY_STATUSES
+    };
+    if (opts.signal !== void 0) fetchOpts.signal = opts.signal;
+    const customInit = {
+      headers: { ...fetchOpts.headers, "User-Agent": DEFAULT_USER_AGENT }
+    };
+    if (opts.signal !== void 0) customInit.signal = opts.signal;
+    const resp = await (opts.fetchFn !== void 0 ? (
+      // Custom fetch override (tests). Bypass retry — caller mock-controls statuses.
+      opts.fetchFn(url, customInit)
+    ) : (0, import_core.fetchWithRetry)(url, fetchOpts));
+    if (!resp.ok) {
+      throw new Error(`Gamma API returned ${resp.status} ${resp.statusText} for offset=${offset}`);
+    }
+    const raw = await resp.json();
+    let page;
+    if (Array.isArray(raw)) {
+      page = raw;
+    } else if (raw !== null && typeof raw === "object" && Array.isArray(raw.data)) {
+      page = raw.data;
+    } else {
+      throw new Error(
+        `Gamma API returned an unexpected page shape at offset=${offset} (expected array or {data: array}, got ${raw === null ? "null" : typeof raw}). The upstream contract may have changed; check https://docs.polymarket.com/.`
+      );
+    }
+    if (page.length === 0) break;
+    for (const ev of page) {
+      const slug = typeof ev.slug === "string" ? ev.slug : null;
+      if (slug === null || seen.has(slug)) continue;
+      seen.add(slug);
+      out.push(ev);
+    }
+    if (page.length < PAGE_SIZE) break;
+    if (sleepMs > 0 && offset + PAGE_SIZE < MAX_EVENTS) {
+      await sleep(sleepMs, opts.signal);
+    }
+  }
+  return out;
+}
+async function fetchEventById(eventId, opts = {}) {
+  const url = `${GAMMA_BASE}/events/${encodeURIComponent(eventId)}`;
+  const fetchOpts = {
+    headers: { Accept: "application/json" },
+    userAgent: DEFAULT_USER_AGENT,
+    retryStatuses: RETRY_STATUSES
+  };
+  if (opts.signal !== void 0) fetchOpts.signal = opts.signal;
+  const customInit = {
+    headers: { ...fetchOpts.headers, "User-Agent": DEFAULT_USER_AGENT }
+  };
+  if (opts.signal !== void 0) customInit.signal = opts.signal;
+  let resp;
+  try {
+    resp = opts.fetchFn !== void 0 ? await opts.fetchFn(url, customInit) : await (0, import_core.fetchWithRetry)(url, fetchOpts);
+  } catch (err) {
+    if (err instanceof import_core.NotFoundError) return null;
+    throw err;
+  }
+  if (resp.status === 404) return null;
+  if (!resp.ok) {
+    throw new Error(`Gamma API returned ${resp.status} ${resp.statusText} for event=${eventId}`);
+  }
+  return await resp.json();
+}
+
+// src/polymarket/errors.ts
+var import_core2 = require("@mostlyrightmd/core");
+var PolymarketEventError = class extends import_core2.TradewindsError {
+  constructor(message) {
+    super(message);
+    this.name = "PolymarketEventError";
+  }
+  static defaultErrorCode = "POLYMARKET_EVENT_INVALID";
+};
+var PolymarketSettlementError = class extends import_core2.TradewindsError {
+  constructor(message) {
+    super(message);
+    this.name = "PolymarketSettlementError";
+  }
+  static defaultErrorCode = "POLYMARKET_SETTLEMENT_FAILED";
+};
+var TooEarlyToSettleError = class extends import_core2.TradewindsError {
+  waitHours;
+  resolutionSourceType;
+  constructor(message, opts) {
+    super(message);
+    this.name = "TooEarlyToSettleError";
+    this.waitHours = opts.waitHours;
+    this.resolutionSourceType = opts.resolutionSourceType;
+  }
+  static defaultErrorCode = "POLYMARKET_TOO_EARLY";
+  payload() {
+    return {
+      ...super.payload(),
+      wait_hours: this.waitHours,
+      resolution_source_type: this.resolutionSourceType
+    };
+  }
+};
+var PayloadTooLargeError = class extends import_core2.TradewindsError {
+  constructor(message) {
+    super(message);
+    this.name = "PayloadTooLargeError";
+  }
+  static defaultErrorCode = "POLYMARKET_PAYLOAD_TOO_LARGE";
+};
+
+// src/polymarket/types.ts
+var RESOLUTION_SOURCE_ALLOWLIST = /* @__PURE__ */ new Set([
+  "wunderground.com",
+  "www.wunderground.com",
+  "weather.gov",
+  "www.weather.gov"
+]);
+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 EVENT_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
+var MAX_DESCRIPTION_BYTES = 16 * 1024;
+var SETTLE_DELAY_HOURS = Object.freeze({
+  wunderground: 6,
+  noaa_wrh: 4,
+  other: 24
+});
+var SLUG_DATE_RE = /(\d{4})-(\d{2})-(\d{2})/g;
+var DEFERRED_STATIONS = /* @__PURE__ */ new Set(["VHHH", "RCTP"]);
+
+// src/polymarket/description.ts
+var URL_RE = /https?:\/\/[^\s<>"')]{1,2048}/g;
+function validateDescription(description) {
+  if (typeof description !== "string") {
+    throw new PolymarketEventError(
+      `description must be a string; got ${description === null ? "null" : typeof description}`
+    );
+  }
+  const byteLen = new TextEncoder().encode(description).length;
+  if (byteLen > MAX_DESCRIPTION_BYTES) {
+    throw new PayloadTooLargeError(
+      `description exceeds 16 KB cap (got ${byteLen} bytes; oversized payloads indicate hostile input)`
+    );
+  }
+  for (const match of description.matchAll(URL_RE)) {
+    const url = match[0];
+    let netloc;
+    try {
+      netloc = new URL(url).host.toLowerCase();
+    } catch {
+      throw new PolymarketEventError(`unparseable resolution-source URL ${JSON.stringify(url)}`);
+    }
+    if (netloc.length > 0 && !RESOLUTION_SOURCE_ALLOWLIST.has(netloc)) {
+      throw new PolymarketEventError(
+        `resolution-source URL ${JSON.stringify(url)} not in allowlist [${[
+          ...RESOLUTION_SOURCE_ALLOWLIST
+        ].sort().join(", ")}]`
+      );
+    }
+  }
+}
+function extractResolutionSourceType(description) {
+  for (const match of description.matchAll(URL_RE)) {
+    const url = match[0];
+    let netloc;
+    try {
+      netloc = new URL(url).host.toLowerCase();
+    } catch {
+      continue;
+    }
+    const mapped = NETLOC_TO_RESOLUTION_TYPE[netloc];
+    if (mapped !== void 0) {
+      return mapped;
+    }
+  }
+  return "other";
+}
+
+// src/polymarket/discover.ts
+var import_core4 = require("@mostlyrightmd/core");
+
+// src/polymarket/resolver.ts
+var import_core3 = require("@mostlyrightmd/core");
+
+// 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"
+  }
+};
+
+// src/polymarket/resolver.ts
+function detectMarketMeasure(event) {
+  const text = [event.title, event.slug, event.name].filter((v) => typeof v === "string").join(" ").toLowerCase();
+  const hasHigh = /\b(highest|high|hottest|warmest|max(?:imum)?)\b/.test(text);
+  const hasLow = /\b(lowest|low|coldest|coolest|min(?:imum)?)\b/.test(text);
+  if (hasLow && !hasHigh) return "low";
+  if (hasHigh && !hasLow) return "high";
+  return "default";
+}
+var CITY_KEYS_SORTED = Object.freeze(
+  Object.keys(POLYMARKET_CITY_STATIONS).sort((a, b) => b.length - a.length)
+);
+function deriveCity(event) {
+  const parts = [];
+  const slug = typeof event.slug === "string" ? event.slug.toLowerCase() : "";
+  const title = typeof event.title === "string" ? event.title.toLowerCase() : "";
+  parts.push(slug, title);
+  const tags = event.tags;
+  if (Array.isArray(tags)) {
+    for (const tag of tags) {
+      if (typeof tag === "string") parts.push(tag.toLowerCase());
+      else if (tag !== null && typeof tag === "object") {
+        const label = tag.label ?? tag.slug;
+        if (typeof label === "string") parts.push(label.toLowerCase());
+      }
+    }
+  }
+  const haystack = ` ${parts.join(" ")} `;
+  for (const key of CITY_KEYS_SORTED) {
+    const needles = [key, key.replace(/_/g, "-"), key.replace(/_/g, " ")];
+    for (const n of needles) {
+      if (n.length === 0) continue;
+      const escaped = n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const re = new RegExp(`(^|[^A-Za-z0-9])${escaped}(?=[^A-Za-z0-9]|$)`);
+      if (re.test(haystack)) return key;
+    }
+  }
+  return null;
+}
+var WUNDERGROUND_ICAO_RE = /https?:\/\/(?:www\.)?wunderground\.com\/(?:dashboard\/)?(?:pws|history\/daily|history\/airport|weather-station|cat\/forecasts)\/(?:[a-z0-9-]+\/)*(K[A-Z]{3})(?![A-Za-z0-9_-])/g;
+function extractIcaoFromResolutionSource(text) {
+  if (typeof text !== "string" || text.length === 0) return null;
+  const matches = [...text.matchAll(WUNDERGROUND_ICAO_RE)];
+  if (matches.length === 0) return null;
+  const unique = /* @__PURE__ */ new Set();
+  for (const m of matches) {
+    if (m[1] !== void 0) unique.add(m[1].toUpperCase());
+  }
+  if (unique.size !== 1) return null;
+  return [...unique][0] ?? null;
+}
+function resolveStationForEvent(event, marketMeasure) {
+  let cityKey = null;
+  const explicit = event.city;
+  if (typeof explicit === "string") {
+    const low = explicit.toLowerCase();
+    if (Object.prototype.hasOwnProperty.call(POLYMARKET_CITY_STATIONS, low)) {
+      cityKey = low;
+    }
+  }
+  const desc = typeof event.description === "string" ? event.description : "";
+  const resSrc = typeof event.resolutionSource === "string" ? event.resolutionSource : "";
+  const urlText = `${desc} ${resSrc}`;
+  const extractedIcao = extractIcaoFromResolutionSource(urlText);
+  if (extractedIcao !== null) {
+    if (extractedIcao === "RCTP") {
+      throw new import_core3.DeferredMarketError(
+        `Polymarket market for station ${extractedIcao} is deferred until the v0.2 CWA client lands`
+      );
+    }
+    if (extractedIcao === "VHHH" && marketMeasure === "low") {
+      throw new import_core3.DeferredMarketError(
+        `Polymarket low-extreme market for station ${extractedIcao} is deferred until the v0.2 HKO client lands`
+      );
+    }
+    if (DEFERRED_STATIONS.has(extractedIcao) && marketMeasure === "default") {
+      throw new import_core3.DeferredMarketError(
+        `Polymarket market for deferred station ${extractedIcao} (measure=default) requires v0.2 client`
+      );
+    }
+    const cityForRow = cityKey ?? deriveCity(event) ?? "";
+    return { city: cityForRow, icao: extractedIcao, stationMeasure: marketMeasure };
+  }
+  if (cityKey === null) {
+    cityKey = deriveCity(event);
+  }
+  if (cityKey === null) return null;
+  const entry = POLYMARKET_CITY_STATIONS[cityKey];
+  if (entry === void 0) return null;
+  let stationMeasure = "default";
+  if (marketMeasure === "high" && typeof entry.high === "string") stationMeasure = "high";
+  else if (marketMeasure === "low" && typeof entry.low === "string") stationMeasure = "low";
+  const icao = entry[stationMeasure] ?? entry.default;
+  if (typeof icao !== "string") return null;
+  if (icao === "RCTP") {
+    throw new import_core3.DeferredMarketError(
+      `Polymarket market for station ${icao} is deferred until the v0.2 CWA client lands`
+    );
+  }
+  if (icao === "VHHH" && marketMeasure === "low") {
+    throw new import_core3.DeferredMarketError(
+      `Polymarket low-extreme market for station ${icao} is deferred until the v0.2 HKO client lands`
+    );
+  }
+  if (DEFERRED_STATIONS.has(icao) && marketMeasure === "default") {
+    throw new import_core3.DeferredMarketError(
+      `Polymarket market for deferred station ${icao} (measure=default) requires v0.2 client`
+    );
+  }
+  return { city: cityKey, icao, stationMeasure };
+}
+function settlementDateFromSlug(slug) {
+  const matches = slug.matchAll(/(\d{4})-(\d{2})-(\d{2})/g);
+  let last = null;
+  for (const m2 of matches) last = m2;
+  if (last === null) {
+    throw new PolymarketSettlementError(
+      `no resolution date in slug ${JSON.stringify(slug)} (expected YYYY-MM-DD)`
+    );
+  }
+  const [_, y, m, d] = last;
+  const year = Number(y);
+  const month = Number(m);
+  const day = Number(d);
+  const ts = Date.UTC(year, month - 1, day);
+  const back = new Date(ts);
+  if (back.getUTCFullYear() !== year || back.getUTCMonth() !== month - 1 || back.getUTCDate() !== day) {
+    throw new PolymarketSettlementError(
+      `slug ${JSON.stringify(slug)} carries malformed date ${y}-${m}-${d}`
+    );
+  }
+  return `${y}-${m}-${d}`;
+}
+
+// src/polymarket/discover.ts
+async function polymarketDiscover(opts = {}) {
+  const raw = await fetchEvents(opts);
+  const out = [];
+  for (const ev of raw) {
+    const slug = typeof ev.slug === "string" ? ev.slug : null;
+    const title = typeof ev.title === "string" ? ev.title : null;
+    const endTime = typeof ev.endDate === "string" ? ev.endDate : null;
+    const eventId = typeof ev.id === "string" ? ev.id : null;
+    const marketMeasure = detectMarketMeasure(ev);
+    let icao = null;
+    let cityKey = null;
+    let measureOut = null;
+    try {
+      const resolved = resolveStationForEvent(ev, marketMeasure);
+      if (resolved === null) {
+        opts.onSkip?.({ slug, reason: "no city match in catalog" });
+        continue;
+      }
+      icao = resolved.icao;
+      cityKey = resolved.city === "" ? null : resolved.city;
+      measureOut = marketMeasure;
+    } catch (err) {
+      if (err instanceof import_core4.DeferredMarketError) {
+        cityKey = deriveCity(ev);
+        icao = null;
+        measureOut = null;
+      } else {
+        throw err;
+      }
+    }
+    const description = typeof ev.description === "string" ? ev.description : "";
+    let resolutionSourceType = "other";
+    if (description.length > 0) {
+      try {
+        validateDescription(description);
+        resolutionSourceType = extractResolutionSourceType(description);
+      } catch (err) {
+        if (err instanceof PolymarketEventError || err instanceof PayloadTooLargeError) {
+          opts.onSkip?.({ slug, reason: `description rejected: ${err.message}` });
+          resolutionSourceType = null;
+        } else {
+          throw err;
+        }
+      }
+    }
+    out.push(
+      Object.freeze({
+        eventId,
+        slug,
+        title,
+        city: cityKey,
+        icao,
+        measure: measureOut,
+        endTime,
+        resolutionSourceType
+      })
+    );
+  }
+  return out;
+}
+
+// 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/polymarket/settle.ts
+var import_core5 = require("@mostlyrightmd/core");
+var import_discovery = require("@mostlyrightmd/core/discovery");
+function tzForStation(icao) {
+  for (const s of import_core5.STATIONS) {
+    if (s.icao === icao) return s.tz;
+  }
+  return null;
+}
+function safeUuidIsh(eventId) {
+  return typeof eventId === "string" && EVENT_ID_RE.test(eventId);
+}
+async function polymarketSettle(args) {
+  const event = args.event;
+  const eventId = typeof event.id === "string" ? event.id : "";
+  if (!safeUuidIsh(eventId)) {
+    throw new PolymarketEventError(
+      `event id ${JSON.stringify(eventId)} does not match ${EVENT_ID_RE.source}`
+    );
+  }
+  const slug = typeof event.slug === "string" ? event.slug : "";
+  if (slug.length === 0) {
+    throw new PolymarketSettlementError("event.slug is required for settlement (carries the date)");
+  }
+  const description = args.description ?? (typeof event.description === "string" ? event.description : "");
+  validateDescription(description);
+  const resolutionSourceType = description.length > 0 ? extractResolutionSourceType(description) : "other";
+  const marketMeasure = detectMarketMeasure(event);
+  const resolved = resolveStationForEvent(event, marketMeasure);
+  if (resolved === null) {
+    throw new PolymarketSettlementError(
+      `unable to resolve station for slug=${JSON.stringify(slug)} \u2014 no matching city in catalog`
+    );
+  }
+  const settlementDate = settlementDateFromSlug(slug);
+  const now = args.now ?? /* @__PURE__ */ new Date();
+  const tz = tzForStation(resolved.icao) ?? "UTC";
+  const localEodMs = stationLocalEodUtcMs(settlementDate, tz);
+  const delayHours = SETTLE_DELAY_HOURS[resolutionSourceType] ?? SETTLE_DELAY_HOURS.other ?? 24;
+  const delayMs = delayHours * 3600 * 1e3;
+  const earliestSettleMs = localEodMs + delayMs;
+  if (now.getTime() < earliestSettleMs) {
+    const waitMs = earliestSettleMs - now.getTime();
+    throw new TooEarlyToSettleError(
+      `settlement for ${resolved.icao} on ${settlementDate} (source=${resolutionSourceType}) requires another ${(waitMs / 3600 / 1e3).toFixed(2)} h`,
+      { waitHours: waitMs / 3600 / 1e3, resolutionSourceType }
+    );
+  }
+  const loader = args.loader ?? defaultEmptyLoader;
+  const rows = await loader({
+    icao: resolved.icao,
+    fromDate: settlementDate,
+    toDate: settlementDate
+  });
+  if (rows.length === 0) {
+    throw new PolymarketSettlementError(
+      `no observation rows for station=${resolved.icao} date=${settlementDate} \u2014 warm the cache first`
+    );
+  }
+  const extremes = (0, import_discovery.internationalDailyExtremes)(rows, { stationTz: tz });
+  const day = extremes.find((r) => r.localDate === settlementDate);
+  if (day === void 0) {
+    throw new PolymarketSettlementError(
+      `no daily extreme for station=${resolved.icao} on local date ${settlementDate}`
+    );
+  }
+  let resolvedValueC = null;
+  let resolvedValueF = null;
+  if (marketMeasure === "low") {
+    resolvedValueC = day.tempMinC;
+    resolvedValueF = day.tempMinF;
+  } else if (marketMeasure === "high") {
+    resolvedValueC = day.tempMaxC;
+    resolvedValueF = day.tempMaxF;
+  } else {
+    throw new PolymarketSettlementError(
+      `event ${JSON.stringify(eventId)} (slug=${JSON.stringify(slug)}) has ambiguous measure ("default" \u2014 title carries neither high nor low keyword); refusing to settle silently. Disambiguate at the caller.`
+    );
+  }
+  if (resolvedValueC === null || resolvedValueF === null) {
+    throw new PolymarketSettlementError(
+      `daily extreme for ${resolved.icao} on ${settlementDate} has null ${marketMeasure} (low coverage)`
+    );
+  }
+  const isUsStation = import_core5.STATIONS.find((s) => s.icao === resolved.icao)?.country === "US";
+  const unit = args.unit ?? (isUsStation ? "fahrenheit" : "celsius");
+  const resolvedValue = unit === "celsius" ? resolvedValueC : resolvedValueF;
+  let dataQualityAlert = null;
+  if (typeof args.polymarketPublishedValue === "number") {
+    const diff = Math.abs(resolvedValue - args.polymarketPublishedValue);
+    const threshold = unit === "celsius" ? 0.6 : 1;
+    const unitSym = unit === "celsius" ? "\xB0C" : "\xB0F";
+    if (diff > threshold) {
+      dataQualityAlert = `mostlyright resolved ${resolvedValue}${unitSym} but Polymarket published ${args.polymarketPublishedValue}${unitSym} (\u0394=${diff.toFixed(2)}${unitSym} > ${threshold}${unitSym} threshold)`;
+    }
+  }
+  return Object.freeze({
+    eventId,
+    settlementDate,
+    icao: resolved.icao,
+    measure: marketMeasure,
+    resolvedValue,
+    resolvedValueC,
+    resolvedValueF,
+    unit,
+    resolutionSourceType,
+    dataQualityAlert
+  });
+}
+async function polymarketSettleById(eventId, args) {
+  if (!safeUuidIsh(eventId)) {
+    throw new PolymarketEventError(
+      `event id ${JSON.stringify(eventId)} does not match ${EVENT_ID_RE.source}`
+    );
+  }
+  const event = await fetchEventById(eventId);
+  if (event === null) {
+    throw new PolymarketSettlementError(
+      `Gamma returned 404 for event id ${JSON.stringify(eventId)}`
+    );
+  }
+  return polymarketSettle({ ...args, event });
+}
+async function defaultEmptyLoader() {
+  return [];
+}
+function stationLocalEodUtcMs(localDate, tz) {
+  const noon = /* @__PURE__ */ new Date(`${localDate}T12:00:00Z`);
+  const fmt = new Intl.DateTimeFormat("en-US", {
+    timeZone: tz,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  });
+  const parts = fmt.formatToParts(noon);
+  let y = "";
+  let m = "";
+  let d = "";
+  for (const p of parts) {
+    if (p.type === "year") y = p.value;
+    else if (p.type === "month") m = p.value;
+    else if (p.type === "day") d = p.value;
+  }
+  const nextDay = /* @__PURE__ */ new Date(`${localDate}T00:00:00Z`);
+  nextDay.setUTCDate(nextDay.getUTCDate() + 1);
+  const expectedDate = nextDayDate(localDate);
+  const minuteFmt = new Intl.DateTimeFormat("en-US", {
+    timeZone: tz,
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+  const STEP_MIN = 15;
+  const RANGE_MIN = 15 * 60;
+  for (let offsetMin = -RANGE_MIN; offsetMin <= RANGE_MIN; offsetMin += STEP_MIN) {
+    const candidate = new Date(nextDay.getTime() + offsetMin * 60 * 1e3);
+    const cParts = fmt.formatToParts(candidate);
+    let cy = "";
+    let cm = "";
+    let cd = "";
+    for (const p of cParts) {
+      if (p.type === "year") cy = p.value;
+      else if (p.type === "month") cm = p.value;
+      else if (p.type === "day") cd = p.value;
+    }
+    if (`${cy}-${cm}-${cd}` !== expectedDate) continue;
+    const tParts = minuteFmt.formatToParts(candidate);
+    const hourStr = tParts.find((p) => p.type === "hour")?.value ?? "00";
+    const minStr = tParts.find((p) => p.type === "minute")?.value ?? "00";
+    const hour = hourStr === "24" ? 0 : Number(hourStr);
+    const minute = Number(minStr);
+    if (hour === 0 && minute === 0) {
+      return candidate.getTime() - 1e3;
+    }
+  }
+  return (/* @__PURE__ */ new Date(`${localDate}T23:59:59Z`)).getTime();
+}
+function nextDayDate(localDate) {
+  const d = /* @__PURE__ */ new Date(`${localDate}T00:00:00Z`);
+  d.setUTCDate(d.getUTCDate() + 1);
+  return d.toISOString().slice(0, 10);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFERRED_STATIONS,
+  EVENT_ID_RE,
+  MAX_DESCRIPTION_BYTES,
+  NETLOC_TO_RESOLUTION_TYPE,
+  POLYMARKET_KNOWN_WRONG_STATIONS,
+  POLYMARKET_RESOLUTION_SOURCE_TYPES,
+  PayloadTooLargeError,
+  PolymarketEventError,
+  PolymarketSettlementError,
+  RESOLUTION_SOURCE_ALLOWLIST,
+  SETTLE_DELAY_HOURS,
+  SLUG_DATE_RE,
+  TooEarlyToSettleError,
+  deriveCity,
+  detectMarketMeasure,
+  extractIcaoFromResolutionSource,
+  extractResolutionSourceType,
+  fetchEventById,
+  fetchEvents,
+  polymarketDiscover,
+  polymarketSettle,
+  polymarketSettleById,
+  resolveStationForEvent,
+  settlementDateFromSlug,
+  validateDescription
+});
+//# sourceMappingURL=index.cjs.map