[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_158":159,"_160":161},"routes/_app.x.$handle.$name",{"_11":12,"_13":14,"_15":16,"_18":19,"_17":-7,"_120":-5,"_20":121,"_22":122,"_123":124,"_125":126,"_25":127,"_24":-5,"_128":-5,"_129":-5,"_130":53,"_131":132,"_133":44,"_134":-5,"_135":-5,"_136":137},"routes/_app.x.$handle.$name.branch.$branch.code.$",{"_11":12,"_13":14,"_15":16,"_17":-7,"_18":19,"_20":21,"_22":23,"_24":-7,"_25":26,"_27":-5,"_28":-5,"_29":-5,"_30":-5,"_31":-5},"handle","cpaulsen5891","name","Weather-val-proxy","branchName","main","version","path","","project",{"_33":61,"_13":14,"_45":62,"_63":-5,"_64":53,"_65":66,"_67":66,"_68":69,"_70":-5,"_71":72,"_73":37,"_74":44,"_75":-5,"_76":-5,"_77":78,"_79":80,"_81":82,"_83":84,"_85":86,"_87":-5,"_88":89,"_90":89,"_91":92,"_93":92,"_94":92,"_95":89,"_96":89,"_97":98,"_99":100,"_101":102,"_103":53},"tree",[56],"file","contents",[32],"upstream","pull","ahead","behind","envVars",{"_33":34,"_13":35,"_36":37,"_38":-5,"_39":40,"_41":42,"_43":44,"_45":46,"_17":47,"_48":49,"_50":51,"_52":53,"_54":-5,"_18":55},"id","9d6802ae-d4d1-45bb-9afd-98d869f7348d","main.ts","fileId","5304f3aa-89c4-11f1-ba7d-1607ee4eb77e","parentId","branchId","e660a3df-4f46-4fa0-b472-cf5bde536ea3","branchVersion",123,"latest",true,"createdAt",["D",1785656963446],5,"fileType","http","content","/**\n * wx-proxy.ts — Val Town HTTP val — single val, no cron required\n *\n * Combines three jobs:\n * 1. NWS passthrough with a real User-Agent (browsers forbid scripts\n * from setting one, which is the whole reason this proxy exists)\n * 2. Nominatim geocoding, rate-limited and cached per their policy\n * 3. GOES-19 GLM lightning — ingested ON DEMAND, served from SQLite\n *\n * WHY REQUEST-DRIVEN INGEST INSTEAD OF A CRON VAL\n * Val Town caps scheduled functions at once per 15 minutes below Pro. At that\n * cadence lightning reaches the user staler than radar, which inverts the only\n * reason to prefer GLM over reflectivity. The client already polls /lightning\n * every 60s while the app is open, so that poll becomes the trigger and\n * freshness returns to 30-60s on the free plan. No app open, no data — which\n * is the correct tradeoff, because nobody is looking.\n *\n * WHY SQLITE AND NOT BLOB\n * Blob would require read-modify-write of a JSON array. Two concurrent polls\n * would clobber each other and strikes would silently vanish. INSERT OR IGNORE\n * against a composite primary key is concurrency-safe by construction.\n *\n * Env vars:\n * WX_CONTACT_EMAIL goes into the User-Agent, per Nominatim policy\n * WX_ALLOW_ORIGIN optional — defaults to \"*\"\n * GLM_SAT \"19\" (East, default) or \"18\" (West)\n * GLM_LAT_MIN / GLM_LAT_MAX / GLM_LON_MIN / GLM_LON_MAX (default CONUS)\n * GLM_RETAIN_MIN rolling window, default 30\n * LIGHTNING_STALE_MS default 5 min — must exceed the client poll interval\n *\n * NOTE: unauthenticated by design — a key in a client-side file is readable\n * by anyone holding it. Abuse is bounded by an inbound per-IP rate limit and\n * an optional Origin allow-list (WX_ALLOW_ORIGIN), plus caching. None of\n * these is a security boundary; they stop casual abuse, which is the real\n * threat to a URL whose traffic goes out under our Nominatim identity.\n *\n * Routes:\n * GET /health\n * GET /geocode?q=Austin+TX\n * GET /nws/\n * GET /lightning?minutes=30&bbox=minLon,minLat,maxLon,maxLat\n */\n\nimport { sqlite } from \"https://esm.town/v/std/sqlite\";\n\n/* ── Config ─────────────────────────────────────────────── */\nconst CONTACT = Deno.env.get(\"WX_CONTACT_EMAIL\") ?? \"\";\nconst UA = `nws-weather-tool/1.0 (${CONTACT || \"no-contact-configured\"})`;\nconst ALLOW_ORIGIN = Deno.env.get(\"WX_ALLOW_ORIGIN\") ?? \"*\";\n\nconst NWS_BASE = \"https://api.weather.gov\";\nconst NOMINATIM = \"https://nominatim.openstreetmap.org/search\";\n\nconst SAT = Deno.env.get(\"GLM_SAT\") === \"18\" ? \"18\" : \"19\";\nconst GLM_BUCKET = `https://noaa-goes${SAT}.s3.amazonaws.com`;\n\nconst LAT_MIN = Number(Deno.env.get(\"GLM_LAT_MIN\") ?? 24);\nconst LAT_MAX = Number(Deno.env.get(\"GLM_LAT_MAX\") ?? 50);\nconst LON_MIN = Number(Deno.env.get(\"GLM_LON_MIN\") ?? -125);\nconst LON_MAX = Number(Deno.env.get(\"GLM_LON_MAX\") ?? -66);\nconst RETAIN_MIN = Number(Deno.env.get(\"GLM_RETAIN_MIN\") ?? 30);\n\nconst AIRNOW_KEY = Deno.env.get(\"AIRNOW_API_KEY\") ?? \"\";\nconst OPENGEO = \"https://opengeo.ncep.noaa.gov/geoserver\";\n\nconst LIGHTNING_STALE_MS = Number(\n Deno.env.get(\"LIGHTNING_STALE_MS\") ?? 5 * 60 * 1000,\n);\nconst LIGHTNING_MAX_FEATURES = 5000;\n\n// Cold start reaches back this far. Not the full retention window: 90 files\n// would cost ~9s on a request the user is waiting behind. ~7 min of history\n// is enough to populate the map while staying responsive.\nconst MAX_BACKFILL_FILES = 20;\n\n// Skip the S3 round trip if this instance ingested very recently. Per-instance\n// only — the DB watermark is what guarantees correctness across instances.\nconst INGEST_DEBOUNCE_MS = 15_000;\n\nconst H5WASM_URL =\n \"https://cdn.jsdelivr.net/npm/h5wasm@0.10.1/dist/esm/hdf5_hl.js\";\n\n/* ── HTTP cache (NWS + geocode only) ────────────────────── */\nconst TTL = {\n geocode: 24 * 60 * 60 * 1000,\n points: 24 * 60 * 60 * 1000,\n obs: 4 * 60 * 1000,\n forecast: 10 * 60 * 1000,\n alerts: 60 * 1000,\n default: 5 * 60 * 1000,\n};\n\ntype Entry = { body: string; status: number; type: string; exp: number };\nconst cache = new Map();\nlet lastGeocodeAt = 0;\n\n/* Nominatim circuit breaker. Verified 2026-07-27: OSM's Fastly edge returns a\n 429 (Error 54113, cache-chi POP) for Val Town's egress pool — a source-address\n block, not a per-caller quota, and therefore not something throttling or a\n corrected User-Agent can clear. Nominatim is retained as a fallback because\n edge blocks do lift, but a standing block must cost one probe per interval\n rather than a 1.1s serialization sleep on every cache miss. */\nlet nominatimBlockedUntil = 0;\nconst NOMINATIM_BREAKER_MS = 10 * 60 * 1000;\n\nfunction cacheGet(k: string): Entry | null {\n const e = cache.get(k);\n if (!e) return null;\n if (Date.now() > e.exp) {\n cache.delete(k);\n return null;\n }\n return e;\n}\n\nfunction cacheSet(k: string, e: Entry) {\n if (cache.size > 500) cache.clear();\n cache.set(k, e);\n}\n\nfunction ttlFor(path: string): number {\n if (path.includes(\"/alerts\")) return TTL.alerts;\n if (path.includes(\"/observations\")) return TTL.obs;\n if (path.includes(\"/forecast\")) return TTL.forecast;\n if (path.startsWith(\"/points\")) return TTL.points;\n return TTL.default;\n}\n\n/* ── Abuse controls ─────────────────────────────────────────\n This proxy is unauthenticated by design — a key embedded in a client-side\n HTML file is readable by anyone holding the file, so it was never a secret.\n What actually matters is that abuse of this URL consumes OTHER people's\n goodwill under our identity: Nominatim blocks by source, and the AirNow key\n has a quota. Caching alone was the only brake, which is not a control.\n\n Two cheap, honest limits below. Neither is a security boundary — a\n determined caller can rotate IPs and forge an Origin header. They stop\n casual abuse and accidental hammering, which is the realistic threat. */\n\n/* A SINGLE origin, not a list. Access-Control-Allow-Origin can only carry one\n value, so a list requires echoing the caller's origin — which means every\n response path needs the request in hand. Thirteen of the fifteen cors()\n call sites here do not have it (passthrough() and friends are called from\n contexts without `req`), so a list would silently send the wrong header to\n every origin but the first. One origin is the real use case: one app val.\n\n Unset means open, preserving behaviour for anyone who has not configured\n it — silently locking an existing deployment out of its own app would be\n worse than the exposure it fixes. */\nconst ORIGIN_ALLOW = (Deno.env.get(\"WX_ALLOW_ORIGIN\") ?? \"\").trim();\n\nconst RATE_WINDOW_MS = 60_000;\n\n/* Two budgets, because two kinds of request are not comparable.\n\n The API budget covers upstream calls that cost someone else something —\n Nominatim, NWS, AirNow. A search makes about 25 of them.\n\n The TILE budget covers image requests. Every visible tile of a filtered WMS\n layer is its own call, so one map view is 12, two layers is 24, and a pan\n or zoom re-requests all of them. A single limit of 120 was tripped by\n ordinary use: two zooms with a detail layer on is over 130 requests, and\n the user saw \"Geocoding service returned 429\" — our own limiter, wearing\n Nominatim's clothes. */\nconst RATE_MAX = Number(Deno.env.get(\"WX_RATE_MAX\") ?? 150); // API, per IP per min\nconst RATE_MAX_TILES = Number(Deno.env.get(\"WX_RATE_MAX_TILES\") ?? 900); // tiles, per IP per min\n\n/** Tile routes are high-volume, cacheable, and cost upstream almost nothing. */\nfunction isTileRoute(path: string): boolean {\n return path.startsWith(\"/radar-tile/\") || path === \"/site-tile\" ||\n path === \"/wms-legend\";\n}\n\ntype Bucket = { count: number; resetAt: number };\nconst buckets = new Map();\n\nfunction clientKey(req: Request): string {\n // Val Town sits behind a proxy, so the socket address is useless; the\n // forwarded header is what identifies the caller.\n const fwd = req.headers.get(\"x-forwarded-for\") ?? \"\";\n return fwd.split(\",\")[0].trim() || \"unknown\";\n}\n\n/** Returns null when allowed, or the seconds to wait. */\nfunction rateCheck(req: Request, tile: boolean): number | null {\n const key = (tile ? \"t:\" : \"a:\") + clientKey(req);\n const limit = tile ? RATE_MAX_TILES : RATE_MAX;\n const now = Date.now();\n\n // Bounded: without this the map grows unbounded under a spray of addresses,\n // which turns a rate limiter into a memory leak.\n if (buckets.size > 5000) buckets.clear();\n\n const b = buckets.get(key);\n if (!b || now > b.resetAt) {\n buckets.set(key, { count: 1, resetAt: now + RATE_WINDOW_MS });\n return null;\n }\n b.count++;\n if (b.count > limit) return Math.ceil((b.resetAt - now) / 1000);\n return null;\n}\n\nfunction originAllowed(req: Request): boolean {\n if (!ORIGIN_ALLOW) return true; // unset = open\n const origin = req.headers.get(\"origin\");\n /* No Origin header: a direct tap, curl, or same-origin navigation. Browsers\n always send it on cross-origin fetches, so absence is not the case being\n defended against — and blocking it would break opening these URLs in a\n tab to check them. */\n if (!origin) return true;\n return origin === ORIGIN_ALLOW;\n}\n\n/* ── HTTP helpers ───────────────────────────────────────── */\nfunction cors(\n extra: Record = {},\n _req?: Request,\n): Record {\n // Single configured origin, so this is constant and every call site is\n // correct whether or not it has the request.\n return {\n \"Access-Control-Allow-Origin\": ORIGIN_ALLOW || \"*\",\n \"Access-Control-Allow-Methods\": \"GET, OPTIONS\",\n \"Access-Control-Allow-Headers\": \"Content-Type\",\n // Custom response headers are invisible to fetch() cross-origin unless\n // listed here. Without it the client's 429-attribution branch was dead\n // code and every limit read as an upstream failure.\n \"Access-Control-Expose-Headers\":\n \"X-RateLimit-Source, X-Proxy-Cache, Retry-After\",\n \"Access-Control-Max-Age\": \"86400\",\n \"Vary\": \"Origin\",\n ...extra,\n };\n}\n\nfunction bytesToB64(b: Uint8Array): string {\n let s = \"\";\n for (let i = 0; i < b.length; i++) s += String.fromCharCode(b[i]);\n return btoa(s);\n}\n\nfunction b64ToBytes(s: string): Uint8Array {\n return Uint8Array.from(atob(s), (c) => c.charCodeAt(0));\n}\n\nfunction json(body: unknown, status = 200, extra: Record = {}) {\n return new Response(JSON.stringify(body), {\n status,\n headers: cors({\n \"Content-Type\": \"application/json; charset=utf-8\",\n ...extra,\n }),\n });\n}\n\nasync function passthrough(\n target: string,\n cacheKey: string,\n ttl: number,\n accept?: string,\n onBody?: (body: string) => Promise,\n): Promise {\n const hit = cacheGet(cacheKey);\n if (hit) {\n return new Response(hit.body, {\n status: hit.status,\n headers: cors({ \"Content-Type\": hit.type, \"X-Proxy-Cache\": \"HIT\" }),\n });\n }\n\n let upstream: Response;\n try {\n upstream = await fetch(target, {\n headers: {\n \"User-Agent\": UA,\n \"Accept\": accept ?? \"application/geo+json,application/json\",\n },\n signal: AbortSignal.timeout(12000),\n });\n } catch (err) {\n return json({ error: \"Upstream unreachable\", detail: String(err) }, 502);\n }\n\n const body = await upstream.text();\n const type = upstream.headers.get(\"Content-Type\") ?? \"application/json\";\n\n // Never cache a failure — a transient 503 must not pin for ten minutes.\n if (upstream.ok) {\n cacheSet(cacheKey, {\n body,\n status: upstream.status,\n type,\n exp: Date.now() + ttl,\n });\n // Awaited deliberately: Val Town may freeze the instance the moment the\n // response is returned, so a floating promise here would often be killed\n // mid-write and the history would develop silent holes.\n if (onBody) await onBody(body);\n }\n\n return new Response(body, {\n status: upstream.status,\n headers: cors({ \"Content-Type\": type, \"X-Proxy-Cache\": \"MISS\" }),\n });\n}\n\n/* ── SQLite ─────────────────────────────────────────────── */\nlet schemaReady = false;\n\nasync function ensureSchema() {\n if (schemaReady) return;\n await sqlite.batch([\n `CREATE TABLE IF NOT EXISTS glm_flashes (\n source_key TEXT NOT NULL,\n flash_id INTEGER NOT NULL,\n lat REAL NOT NULL,\n lon REAL NOT NULL,\n ts INTEGER NOT NULL,\n PRIMARY KEY (source_key, flash_id)\n )`,\n `CREATE INDEX IF NOT EXISTS glm_flashes_ts ON glm_flashes (ts)`,\n `CREATE TABLE IF NOT EXISTS glm_state (\n key TEXT PRIMARY KEY,\n value TEXT NOT NULL\n )`,\n /* Forecast history. Period identity is start_time, NEVER name: \"Saturday\"\n means a different day depending on when you asked, so diffing by name\n silently compares unrelated periods and manufactures changes that never\n happened. start_time is the only stable key. */\n `CREATE TABLE IF NOT EXISTS fc_snap (\n grid TEXT NOT NULL,\n taken_at INTEGER NOT NULL,\n start_time TEXT NOT NULL,\n name TEXT,\n temp INTEGER,\n pop INTEGER,\n short TEXT,\n wind TEXT,\n PRIMARY KEY (grid, taken_at, start_time)\n )`,\n `CREATE INDEX IF NOT EXISTS fc_snap_grid ON fc_snap (grid, taken_at)`,\n /* Observations, for scoring the forecast against what actually happened.\n Keyed by station because that is all the observation path reveals; the\n client supplies the grid pairing when asking for a scorecard. */\n `CREATE TABLE IF NOT EXISTS obs_snap (\n station TEXT NOT NULL,\n ts INTEGER NOT NULL,\n temp_c REAL,\n PRIMARY KEY (station, ts)\n )`,\n `CREATE INDEX IF NOT EXISTS obs_snap_st ON obs_snap (station, ts)`,\n ]);\n\n // Tolerant migration: fc_snap predates these columns by one deploy.\n for (\n const col of [\n \"end_time TEXT\",\n \"is_day INTEGER\",\n \"start_ms INTEGER\",\n \"end_ms INTEGER\",\n ]\n ) {\n try {\n await sqlite.execute({\n sql: `ALTER TABLE fc_snap ADD COLUMN ${col}`,\n args: [],\n });\n } catch { /* already present */ }\n }\n schemaReady = true;\n}\n\nasync function getState(key: string): Promise {\n const r = await sqlite.execute({\n sql: `SELECT value FROM glm_state WHERE key = ?`,\n args: [key],\n });\n return r.rows.length ? String(r.rows[0][0]) : null;\n}\n\nasync function setState(key: string, value: string) {\n await sqlite.execute({\n sql: `INSERT INTO glm_state (key, value) VALUES (?, ?)\n ON CONFLICT(key) DO UPDATE SET value = excluded.value`,\n args: [key, value],\n });\n}\n\n/* ── Forecast history ───────────────────────────────────── */\n\nconst FC_SNAP_MIN_GAP_MS = 30 * 60 * 1000; // NWS issues a few times daily\nconst FC_RETAIN_DAYS = 10;\n\n/** \"/gridpoints/LMK/44,79/forecast\" -> \"LMK/44,79\" */\nfunction gridFromPath(path: string): string | null {\n const m = path.match(/^\\/gridpoints\\/([A-Z]{3})\\/(\\d+,\\d+)\\/forecast$/);\n return m ? `${m[1]}/${m[2]}` : null;\n}\n\nasync function snapshotForecast(grid: string, body: string) {\n try {\n await ensureSchema();\n\n const last = Number(await getState(`fc_last:${grid}`) ?? 0);\n if (Date.now() - last < FC_SNAP_MIN_GAP_MS) return;\n\n const periods = JSON.parse(body)?.properties?.periods;\n if (!Array.isArray(periods) || !periods.length) return;\n\n const takenAt = Date.now();\n await sqlite.batch(\n periods.slice(0, 14).map((p: any) => ({\n sql: `INSERT OR IGNORE INTO fc_snap\n (grid, taken_at, start_time, end_time, start_ms, end_ms,\n is_day, name, temp, pop, short, wind)\n VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,\n args: [\n grid,\n takenAt,\n String(p.startTime ?? \"\"),\n String(p.endTime ?? \"\"),\n Date.parse(p.startTime ?? \"\") || 0,\n Date.parse(p.endTime ?? \"\") || 0,\n p.isDaytime ? 1 : 0,\n p.name ?? null,\n p.temperature ?? null,\n p.probabilityOfPrecipitation?.value ?? null,\n p.shortForecast ?? null,\n p.windSpeed ? `${p.windDirection ?? \"\"} ${p.windSpeed}`.trim() : null,\n ],\n })),\n );\n\n await setState(`fc_last:${grid}`, String(takenAt));\n await sqlite.execute({\n sql: `DELETE FROM fc_snap WHERE taken_at < ?`,\n args: [takenAt - FC_RETAIN_DAYS * 86400_000],\n });\n } catch { /* history is a bonus; never break the forecast passthrough */ }\n}\n\n/** \"/stations/KSDF/observations/latest\" -> \"KSDF\" */\nfunction stationFromPath(path: string): string | null {\n const m = path.match(/^\\/stations\\/([A-Z0-9]{3,5})\\/observations\\/latest$/);\n return m ? m[1] : null;\n}\n\nasync function snapshotObs(station: string, body: string) {\n try {\n await ensureSchema();\n const p = JSON.parse(body)?.properties;\n const t = p?.temperature?.value;\n const ts = p?.timestamp ? new Date(p.timestamp).getTime() : NaN;\n if (t == null || !Number.isFinite(ts)) return;\n\n // Keyed on the observation's own timestamp, so repeat fetches of the same\n // METAR collapse to one row rather than inflating the sample.\n await sqlite.execute({\n sql:\n `INSERT OR IGNORE INTO obs_snap (station, ts, temp_c) VALUES (?, ?, ?)`,\n args: [station, ts, Number(t)],\n });\n await sqlite.execute({\n sql: `DELETE FROM obs_snap WHERE ts < ?`,\n args: [Date.now() - FC_RETAIN_DAYS * 86400_000],\n });\n } catch { /* scoring is a bonus; never break the observation passthrough */ }\n}\n\n/* ── GLM: S3 discovery ──────────────────────────────────── */\nfunction dayOfYearUTC(d: Date): number {\n return Math.floor(\n (d.getTime() - Date.UTC(d.getUTCFullYear(), 0, 0)) / 86400000,\n );\n}\n\nfunction prefixFor(d: Date): string {\n const yyyy = d.getUTCFullYear();\n const ddd = String(dayOfYearUTC(d)).padStart(3, \"0\");\n const hh = String(d.getUTCHours()).padStart(2, \"0\");\n return `GLM-L2-LCFA/${yyyy}/${ddd}/${hh}/`;\n}\n\nasync function listPrefix(prefix: string): Promise {\n const res = await fetch(\n `${GLM_BUCKET}/?list-type=2&prefix=${\n encodeURIComponent(prefix)\n }&max-keys=1000`,\n { signal: AbortSignal.timeout(12000) },\n );\n if (!res.ok) throw new Error(`S3 list ${res.status}`);\n const xml = await res.text();\n return [...xml.matchAll(/([^<]+)<\\/Key>/g)].map((m) => m[1]);\n}\n\n/**\n * Crossing an hour boundary, the current prefix is nearly empty while the\n * previous still holds unprocessed files. Always list both.\n */\nasync function listRecent(): Promise {\n const now = new Date();\n const prev = new Date(now.getTime() - 3600_000);\n const [a, b] = await Promise.all([\n listPrefix(prefixFor(prev)).catch(() => [] as string[]),\n listPrefix(prefixFor(now)).catch(() => [] as string[]),\n ]);\n // Zero-padded embedded timestamps make lexical sort chronological.\n return [...a, ...b].sort();\n}\n\n/**\n * Flash timestamps come from the FILENAME, not the file's time variables.\n *\n * GLM stores time offsets as scaled integers with scale_factor/add_offset\n * attributes. h5wasm returns RAW HDF5 values and does not apply netCDF\n * conventions the way netCDF4-python does. Reading those ints without\n * manually applying the attributes yields numbers that look plausible and\n * are wrong — the worst available failure. The filename encodes the\n * 20-second window directly, which is finer than a 30-minute fade needs.\n *\n * OR_GLM-L2-LCFA_G19_s20262061038200_e... -> 2026 DOY206 10:38:20.0\n */\nfunction timestampFromKey(key: string): number | null {\n const m = key.match(/_s(\\d{4})(\\d{3})(\\d{2})(\\d{2})(\\d{2})(\\d)_/);\n if (!m) return null;\n const [, yyyy, ddd, hh, mm, ss, tenth] = m;\n const base = Date.UTC(\n Number(yyyy),\n 0,\n 1,\n Number(hh),\n Number(mm),\n Number(ss),\n Number(tenth) * 100,\n );\n return base + (Number(ddd) - 1) * 86400000;\n}\n\n/* ── GLM: decode ────────────────────────────────────────── */\ntype Flash = { id: number; lat: number; lon: number };\n\n// Lazily imported so /health, /geocode and /nws never pay the ~68 MB\n// resident cost of libhdf5-wasm.\nlet h5mod: any = null;\nlet h5fs: any = null;\n\nasync function h5() {\n if (!h5mod) {\n const mod = await import(H5WASM_URL);\n h5mod = mod.default ?? mod;\n h5fs = (await h5mod.ready).FS;\n }\n return { h5: h5mod, FS: h5fs };\n}\n\nasync function decodeFlashes(key: string, bytes: Uint8Array): Promise {\n const { h5: mod, FS } = await h5();\n const fname = `glm_${Date.now()}_${Math.random().toString(36).slice(2)}.nc`;\n FS.writeFile(fname, bytes);\n\n const f = new mod.File(fname, \"r\");\n try {\n const keys: string[] = f.keys();\n if (!keys.includes(\"flash_lat\") || !keys.includes(\"flash_lon\")) {\n throw new Error(`${key}: expected flash_lat/flash_lon, schema changed`);\n }\n\n const lat = f.get(\"flash_lat\").value as ArrayLike;\n const lon = f.get(\"flash_lon\").value as ArrayLike;\n const ids = keys.includes(\"flash_id\")\n ? (f.get(\"flash_id\").value as ArrayLike)\n : null;\n // Absent flag means keep, rather than silently discarding everything if\n // the variable is ever renamed upstream.\n const qf = keys.includes(\"flash_quality_flag\")\n ? (f.get(\"flash_quality_flag\").value as ArrayLike)\n : null;\n\n if (lat.length !== lon.length) {\n throw new Error(`${key}: lat/lon length mismatch`);\n }\n\n const out: Flash[] = [];\n for (let i = 0; i < lat.length; i++) {\n if (qf && Number(qf[i]) !== 0) continue;\n const la = Number(lat[i]);\n const lo = Number(lon[i]);\n if (!Number.isFinite(la) || !Number.isFinite(lo)) continue;\n\n // Disk sanity gate before the bbox filter. A scaling regression upstream\n // would otherwise present as \"no lightning\" rather than as an error.\n if (la < -60 || la > 60 || lo < -140 || lo > 10) continue;\n if (la < LAT_MIN || la > LAT_MAX || lo < LON_MIN || lo > LON_MAX) {\n continue;\n }\n\n out.push({ id: ids ? Number(ids[i]) : i, lat: la, lon: lo });\n }\n return out;\n } finally {\n try {\n f.close();\n } catch { /* best effort */ }\n try {\n FS.unlink(fname);\n } catch { /* best effort */ }\n }\n}\n\n/* ── GLM: on-demand ingest ──────────────────────────────── */\nlet lastIngestAttempt = 0;\nlet ingestInFlight: Promise> | null = null;\n\nasync function ingestNow(): Promise> {\n const stat: Record = {};\n const lastKey = await getState(\"last_key\");\n const all = await listRecent();\n\n // Strictly-greater comparison is what makes this idempotent: a concurrent\n // poll re-reads the same watermark and finds nothing new.\n let pending = lastKey ? all.filter((k) => k > lastKey) : all.slice(-6);\n stat.pending = pending.length;\n\n if (pending.length > MAX_BACKFILL_FILES) {\n // Drop the OLDEST on overflow. Recency matters more than completeness for\n // a hazard layer, and a user waiting on the response matters too.\n stat.skipped = pending.length - MAX_BACKFILL_FILES;\n pending = pending.slice(-MAX_BACKFILL_FILES);\n }\n\n let inserted = 0, files = 0, failed = 0;\n\n for (const key of pending) {\n const ts = timestampFromKey(key);\n if (ts === null) {\n failed++;\n continue;\n }\n try {\n const res = await fetch(`${GLM_BUCKET}/${key}`, {\n signal: AbortSignal.timeout(15000),\n });\n if (!res.ok) {\n failed++;\n continue;\n }\n const flashes = await decodeFlashes(\n key,\n new Uint8Array(await res.arrayBuffer()),\n );\n files++;\n\n if (flashes.length) {\n await sqlite.batch(\n flashes.map((fl) => ({\n sql:\n `INSERT OR IGNORE INTO glm_flashes (source_key, flash_id, lat, lon, ts)\n VALUES (?, ?, ?, ?, ?)`,\n args: [key, fl.id, fl.lat, fl.lon, ts],\n })),\n );\n inserted += flashes.length;\n }\n // Advance per file, not per batch, so a mid-run failure resumes.\n await setState(\"last_key\", key);\n } catch {\n failed++;\n }\n }\n\n await sqlite.execute({\n sql: `DELETE FROM glm_flashes WHERE ts < ?`,\n args: [Date.now() - RETAIN_MIN * 60_000],\n });\n\n // Liveness is a different fact from activity. A healthy ingest over a quiet\n // sky inserts nothing and must still prove it ran.\n await setState(\"last_run_ts\", String(Date.now()));\n\n stat.files = files;\n stat.failed = failed;\n stat.inserted = inserted;\n return stat;\n}\n\nasync function maybeIngest(): Promise> {\n // Collapse concurrent polls onto one in-flight ingest. Without this, two\n // overlapping requests both walk S3 and both decode the same files.\n if (ingestInFlight) return await ingestInFlight;\n\n if (Date.now() - lastIngestAttempt < INGEST_DEBOUNCE_MS) {\n return { skipped: \"debounced\" };\n }\n lastIngestAttempt = Date.now();\n\n ingestInFlight = ingestNow()\n .catch((err) => ({ error: String(err) }))\n .finally(() => {\n ingestInFlight = null;\n }) as Promise>;\n\n return await ingestInFlight;\n}\n\n/* ── OGC discovery ──────────────────────────────────────────\n Layer and feature-type names on this GeoServer are not documented in the\n directory page, and guessing them produces a silently empty map rather than\n an error. So they are read from GetCapabilities and cached. Self-discovery\n costs one request a day and removes a whole class of wrong guesses. */\n\nasync function discover(\n url: string,\n cacheKey: string,\n pattern: RegExp,\n): Promise {\n const hit = cacheGet(cacheKey);\n if (hit) return JSON.parse(hit.body);\n try {\n const res = await fetch(url, {\n headers: { \"User-Agent\": UA },\n signal: AbortSignal.timeout(20000),\n });\n if (!res.ok) return [];\n const xml = await res.text();\n const names = [...xml.matchAll(/<(?:wfs:)?Name>([^<]+)<\\/(?:wfs:)?Name>/g)]\n .map((m) => m[1])\n .filter((n) => pattern.test(n));\n const uniq = [...new Set(names)];\n cacheSet(cacheKey, {\n body: JSON.stringify(uniq),\n status: 200,\n type: \"application/json\",\n exp: Date.now() + 86400_000,\n });\n return uniq;\n } catch {\n return [];\n }\n}\n\n/* Ray casting. Warning polygons are small and simple, so the naive algorithm\n is fine — but the antimeridian and poles are not handled, which is\n acceptable for NWS CONUS/OCONUS products and would not be elsewhere. */\nfunction pointInRing(lat: number, lon: number, ring: number[][]): boolean {\n let inside = false;\n for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {\n const [xi, yi] = ring[i], [xj, yj] = ring[j];\n if (\n (yi > lat) !== (yj > lat) &&\n lon < ((xj - xi) * (lat - yi)) / (yj - yi) + xi\n ) inside = !inside;\n }\n return inside;\n}\n\nfunction pointInGeometry(lat: number, lon: number, geom: any): boolean {\n if (!geom) return false;\n const polys = geom.type === \"Polygon\"\n ? [geom.coordinates]\n : geom.type === \"MultiPolygon\"\n ? geom.coordinates\n : [];\n for (const poly of polys) {\n if (!poly.length) continue;\n // First ring is the outer boundary; the rest are holes.\n if (!pointInRing(lat, lon, poly[0])) continue;\n let inHole = false;\n for (let h = 1; h < poly.length; h++) {\n if (pointInRing(lat, lon, poly[h])) inHole = true;\n }\n if (!inHole) return true;\n }\n return false;\n}\n\n/* ── Geocoding backends ─────────────────────────────────────\n Nominatim is demoted to fallback. Two reasons it cannot be primary here:\n Val Town egresses from a shared IP pool and OSM blocks by source address at\n the CDN edge, so our access is spent by strangers and is unreachable from\n our side; and this app is U.S.-only, where ZIP and place-name lookups have\n dedicated keyless services with no such contention.\n\n Both backends return Nominatim-shaped rows so the client parser and the\n cache format are unchanged. */\n\nconst STATE_AB: Record = Object.fromEntries(\n (\"Alabama AL|Alaska AK|Arizona AZ|Arkansas AR|California CA|Colorado CO|\" +\n \"Connecticut CT|Delaware DE|Florida FL|Georgia GA|Hawaii HI|Idaho ID|\" +\n \"Illinois IL|Indiana IN|Iowa IA|Kansas KS|Kentucky KY|Louisiana LA|\" +\n \"Maine ME|Maryland MD|Massachusetts MA|Michigan MI|Minnesota MN|\" +\n \"Mississippi MS|Missouri MO|Montana MT|Nebraska NE|Nevada NV|\" +\n \"New Hampshire NH|New Jersey NJ|New Mexico NM|New York NY|\" +\n \"North Carolina NC|North Dakota ND|Ohio OH|Oklahoma OK|Oregon OR|\" +\n \"Pennsylvania PA|Rhode Island RI|South Carolina SC|South Dakota SD|\" +\n \"Tennessee TN|Texas TX|Utah UT|Vermont VT|Virginia VA|Washington WA|\" +\n \"West Virginia WV|Wisconsin WI|Wyoming WY|District of Columbia DC|\" +\n \"Puerto Rico PR|Guam GU|American Samoa AS|Virgin Islands VI\").split(\"|\")\n .map((s) => {\n const i = s.lastIndexOf(\" \");\n return [s.slice(0, i), s.slice(i + 1)];\n }),\n);\n\n/** null means the call failed. Distinguishing that from an empty result is the\n whole point: one is an outage, the other is a typo. */\nasync function fetchJsonOrNull(target: string, ms = 8000): Promise {\n try {\n const r = await fetch(target, {\n headers: { \"User-Agent\": UA, \"Accept\": \"application/json\" },\n signal: AbortSignal.timeout(ms),\n });\n if (!r.ok) return null;\n return await r.json();\n } catch {\n return null;\n }\n}\n\ntype GeoRow = { lat: string; lon: string; display_name: string };\n\n/** null = every backend failed (502). [] = backends worked, no such place (200). */\nasync function geocodeUS(q: string): Promise {\n /* ZIP path. Checked first because a 5-digit string is unambiguous and this\n is the single most common input the app receives. */\n const zip = q.match(/^\\s*(\\d{5})(?:-\\d{4})?\\s*$/);\n if (zip) {\n const d = await fetchJsonOrNull(`https://api.zippopotam.us/us/${zip[1]}`);\n const p = d?.places?.[0];\n if (p) {\n return [{\n lat: String(p.latitude),\n lon: String(p.longitude),\n display_name: `${p[\"place name\"]}, ${p[\"state abbreviation\"]} ${\n zip[1]\n }`,\n }];\n }\n // 404 arrives as null from fetchJsonOrNull, which is correct for an\n // unassigned ZIP but would otherwise be reported as an outage. A\n // well-formed ZIP that does not resolve is a miss; fall through so the\n // place-name path gets a chance, then Nominatim.\n }\n\n /* Place-name path. \"Austin, TX\" and \"Austin TX\" both parse; a bare name\n takes the highest-population match, which is what a user typing one word\n means in practice. */\n const m = q.match(/^(.*?)[,\\s]+([A-Za-z]{2})\\.?\\s*$/);\n const name = (m ? m[1] : q).trim();\n const st = m ? m[2].toUpperCase() : \"\";\n\n if (name && !/^\\d+$/.test(name)) {\n const d = await fetchJsonOrNull(\n \"https://geocoding-api.open-meteo.com/v1/search\" +\n `?name=${encodeURIComponent(name)}&count=10&language=en&format=json`,\n );\n if (d !== null) {\n const us = (d.results ?? []).filter((r: any) => r.country_code === \"US\");\n if (us.length) {\n // Results arrive population-ordered. A state hint overrides that;\n // without one, \"Springfield\" resolving to the largest Springfield is\n // the least surprising behaviour available.\n const pick = st\n ? (us.find((r: any) => STATE_AB[r.admin1] === st) ?? us[0])\n : us[0];\n return [{\n lat: String(pick.latitude),\n lon: String(pick.longitude),\n display_name: [pick.name, pick.admin1, \"United States\"]\n .filter(Boolean).join(\", \"),\n }];\n }\n }\n }\n\n /* Nominatim fallback: street addresses, and anything the two above miss.\n Circuit-broken, then serialized per their policy if the breaker is open. */\n if (Date.now() < nominatimBlockedUntil) return [];\n\n const gap = Date.now() - lastGeocodeAt;\n if (gap < 1100) await new Promise((r) => setTimeout(r, 1100 - gap));\n lastGeocodeAt = Date.now();\n\n const n = await fetchJsonOrNull(\n `${NOMINATIM}?q=${\n encodeURIComponent(q)\n }&countrycodes=us&format=json&limit=1`,\n );\n if (n === null) {\n nominatimBlockedUntil = Date.now() + NOMINATIM_BREAKER_MS;\n return null;\n }\n return Array.isArray(n) ? (n as GeoRow[]) : [];\n}\n\n/* ── Handler ────────────────────────────────────────────── */\nexport default async function (req: Request): Promise {\n const url = new URL(req.url);\n\n if (req.method === \"OPTIONS\") {\n return new Response(null, { status: 204, headers: cors({}, req) });\n }\n if (req.method !== \"GET\") return json({ error: \"Method not allowed\" }, 405);\n\n if (!originAllowed(req)) {\n return json({ error: \"Origin not permitted\" }, 403);\n }\n\n /* /health stays open so the val can be checked when rate limited. */\n if (url.pathname !== \"/health\") {\n const wait = rateCheck(req, isTileRoute(url.pathname));\n if (wait !== null) {\n return new Response(\n JSON.stringify({\n error: \"Rate limit exceeded\",\n // Named explicitly: without this the client reports our own 429 as\n // \"Geocoding service returned 429\", blaming Nominatim for a limit\n // we imposed. A misattributed error is worse than a loud one.\n source: \"skylon-proxy\",\n retryAfterSeconds: wait,\n }),\n {\n status: 429,\n headers: cors({\n \"Content-Type\": \"application/json; charset=utf-8\",\n \"Retry-After\": String(wait),\n \"X-RateLimit-Source\": \"skylon-proxy\",\n }, req),\n },\n );\n }\n }\n\n if (url.pathname === \"/health\" || url.pathname === \"/\") {\n return json({\n ok: true,\n contactConfigured: Boolean(CONTACT),\n originLocked: Boolean(ORIGIN_ALLOW),\n rateLimitPerMin: RATE_MAX,\n tileLimitPerMin: RATE_MAX_TILES,\n satellite: `GOES-${SAT}`,\n ingestMode: \"on-demand\",\n cacheEntries: cache.size,\n });\n }\n\n /* ── Geocoding ── */\n if (url.pathname === \"/geocode\") {\n const q = (url.searchParams.get(\"q\") ?? \"\").trim();\n if (!q) return json({ error: \"Missing q parameter\" }, 400);\n if (q.length > 200) return json({ error: \"Query too long\" }, 400);\n\n const key = `geo:${q.toLowerCase()}`;\n const hit = cacheGet(key);\n if (hit) {\n return new Response(hit.body, {\n status: hit.status,\n headers: cors({ \"Content-Type\": hit.type, \"X-Proxy-Cache\": \"HIT\" }),\n });\n }\n\n const rows = await geocodeUS(q);\n if (rows === null) {\n // 502, not 429: no upstream is rate-limiting the caller here, every\n // backend is simply unreachable. Reporting this as 429 is what sent\n // the last debugging session at the wrong service.\n return json({\n error: \"Geocoding upstreams unavailable\",\n source: \"upstream-geocoder\",\n }, 502);\n }\n\n const gbody = JSON.stringify(rows);\n // Only a hit is cached. Caching [] would pin a typo for 24 hours.\n if (rows.length) {\n cacheSet(key, {\n body: gbody,\n status: 200,\n type: \"application/json; charset=utf-8\",\n exp: Date.now() + TTL.geocode,\n });\n }\n return new Response(gbody, {\n status: 200,\n headers: cors({\n \"Content-Type\": \"application/json; charset=utf-8\",\n \"X-Proxy-Cache\": \"MISS\",\n }),\n });\n }\n\n /* ── NWS passthrough ── */\n if (url.pathname.startsWith(\"/nws/\")) {\n const rest = url.pathname.slice(4); // keeps the leading slash\n\n // SSRF guard: the upstream host is fixed and the path is validated.\n // No caller-supplied URL is ever fetched.\n if (rest.includes(\"..\") || !/^\\/[A-Za-z0-9/,._~%:-]*$/.test(rest)) {\n return json({ error: \"Invalid path\" }, 400);\n }\n\n const qs = url.searchParams.toString() ? `?${url.searchParams}` : \"\";\n const grid = gridFromPath(rest);\n const station = stationFromPath(rest);\n\n const hook = grid\n ? (body: string) => snapshotForecast(grid, body)\n : station\n ? (body: string) => snapshotObs(station, body)\n : undefined;\n\n return passthrough(\n `${NWS_BASE}${rest}${qs}`,\n `nws:${rest}${qs}`,\n ttlFor(rest),\n undefined,\n hook,\n );\n }\n\n /* ── Warning polygons ──\n Turns \"Tornado Warning\" from a line of text into the only question that\n matters: are you inside the polygon. */\n if (url.pathname === \"/warnings\") {\n const lat = Number(url.searchParams.get(\"lat\"));\n const lon = Number(url.searchParams.get(\"lon\"));\n if (!Number.isFinite(lat) || !Number.isFinite(lon)) {\n return json({ error: \"lat and lon required\" }, 400);\n }\n const pad = Math.min(\n 10,\n Math.max(0.5, Number(url.searchParams.get(\"pad\") ?? 3)),\n );\n\n const types = await discover(\n `${OPENGEO}/wwa/warnings/ows?service=wfs&version=2.0.0&request=GetCapabilities`,\n \"wfs:warnings\",\n /warning/i,\n );\n if (!types.length) {\n return json({ error: \"No warning feature type discovered\" }, 502);\n }\n\n const bbox = [lat - pad, lon - pad, lat + pad, lon + pad].join(\",\");\n const wfs =\n `${OPENGEO}/wwa/warnings/ows?service=WFS&version=2.0.0&request=GetFeature` +\n `&typeNames=${\n encodeURIComponent(types[0])\n }&outputFormat=application/json` +\n `&srsName=EPSG:4326&bbox=${bbox},EPSG:4326&count=200`;\n\n let fc: any;\n try {\n const res = await fetch(wfs, {\n headers: { \"User-Agent\": UA },\n signal: AbortSignal.timeout(20000),\n });\n if (!res.ok) {\n return json(\n { error: `WFS returned ${res.status}`, typeName: types[0] },\n 502,\n );\n }\n fc = await res.json();\n } catch (err) {\n return json({ error: \"WFS unreachable\", detail: String(err) }, 502);\n }\n\n const feats = (fc.features ?? []).map((f: any) => ({\n ...f,\n properties: {\n ...f.properties,\n containsPoint: pointInGeometry(lat, lon, f.geometry),\n },\n }));\n\n return json(\n {\n type: \"FeatureCollection\",\n features: feats,\n properties: {\n typeName: types[0],\n discovered: types,\n count: feats.length,\n containingCount: feats.filter((f: any) =>\n f.properties.containsPoint\n ).length,\n },\n },\n 200,\n { \"Cache-Control\": \"public, max-age=45\" },\n );\n }\n\n /* ── Air quality (AirNow) ── */\n if (url.pathname === \"/aqi\") {\n if (!AIRNOW_KEY) {\n return json({ error: \"AIRNOW_API_KEY not set on this val\" }, 503);\n }\n const lat = Number(url.searchParams.get(\"lat\"));\n const lon = Number(url.searchParams.get(\"lon\"));\n if (!Number.isFinite(lat) || !Number.isFinite(lon)) {\n return json({ error: \"lat and lon required\" }, 400);\n }\n\n const key = `aqi:${lat.toFixed(2)},${lon.toFixed(2)}`;\n const hit = cacheGet(key);\n if (hit) {\n return new Response(hit.body, {\n headers: cors({\n \"Content-Type\": \"application/json\",\n \"X-Proxy-Cache\": \"HIT\",\n }),\n });\n }\n\n const base = \"https://www.airnowapi.org/aq\";\n const q =\n `format=application/json&latitude=${lat.toFixed(4)}&longitude=${\n lon.toFixed(4)\n }` +\n `&distance=50&API_KEY=${encodeURIComponent(AIRNOW_KEY)}`;\n\n let current: any[] = [], forecast: any[] = [];\n try {\n // The forecast endpoint returns an empty array without an explicit\n // date — it does not default to today. Observed live: forecast: [].\n const today = new Date().toISOString().slice(0, 10);\n const [c, f] = await Promise.all([\n fetch(`${base}/observation/latLong/current/?${q}`, {\n headers: { \"User-Agent\": UA },\n signal: AbortSignal.timeout(15000),\n }),\n fetch(`${base}/forecast/latLong/?${q}&date=${today}`, {\n headers: { \"User-Agent\": UA },\n signal: AbortSignal.timeout(15000),\n }),\n ]);\n if (c.ok) current = await c.json();\n if (f.ok) forecast = await f.json();\n } catch (err) {\n return json({ error: \"AirNow unreachable\", detail: String(err) }, 502);\n }\n\n /* AirNow reports each pollutant separately. The headline AQI is the WORST\n of them by definition — averaging pollutants would understate the very\n thing the index exists to flag. */\n const worst = current.reduce(\n (a: any, b: any) => (b?.AQI ?? -1) > (a?.AQI ?? -1) ? b : a,\n current[0] ?? null,\n );\n\n const body = JSON.stringify({\n reportingArea: worst?.ReportingArea ?? null,\n stateCode: worst?.StateCode ?? null,\n observedHour: worst?.HourObserved ?? null,\n observedDate: worst?.DateObserved?.trim() ?? null,\n timeZone: worst?.LocalTimeZone ?? null,\n aqi: worst?.AQI ?? null,\n category: worst?.Category?.Name ?? null,\n dominantPollutant: worst?.ParameterName ?? null,\n pollutants: current.map((o: any) => ({\n parameter: o.ParameterName,\n aqi: o.AQI,\n category: o.Category?.Name,\n })),\n forecast: forecast\n .filter((f: any) => f?.AQI != null && f.AQI >= 0)\n .map((f: any) => ({\n date: f.DateForecast?.trim(),\n parameter: f.ParameterName,\n aqi: f.AQI,\n category: f.Category?.Name,\n })),\n });\n\n // AirNow updates hourly and rate-limits, so cache generously.\n cacheSet(key, {\n body,\n status: 200,\n type: \"application/json\",\n exp: Date.now() + 20 * 60 * 1000,\n });\n return new Response(body, {\n headers: cors({\n \"Content-Type\": \"application/json\",\n \"X-Proxy-Cache\": \"MISS\",\n }),\n });\n }\n\n /* ── Precipitation type (MRMS) ──\n Replaces a forecast-text heuristic with actual data. The forecast string\n \"Rain and Snow Likely\" cannot say which is falling on YOU right now, and\n mixed precipitation is exactly the case where getting it wrong matters:\n freezing rain and snow look identical on reflectivity and behave nothing\n alike.\n\n Layer names on this GeoServer are undocumented, so they are discovered\n from GetCapabilities rather than guessed — a wrong name renders an empty\n overlay with no error anywhere, which looks like clear weather. */\n if (url.pathname === \"/precip-type\") {\n const layers = await discover(\n `${OPENGEO}/conus/ows?service=wms&version=1.3.0&request=GetCapabilities`,\n \"wms:conus\",\n /pcpn_typ|ptype|precip.*type/i,\n );\n\n if (!layers.length) {\n return json({\n error: \"No precipitation-type layer discovered\",\n hint: \"The conus workspace may not publish it under a matching name.\",\n }, 502);\n }\n\n /* No hand-written legend. The first version of this route invented one\n from the MRMS classification values and it was simply wrong — the\n layer's own palette differs, so a July rain event over Kentucky was\n labelled \"snow\" in solid blue. A legend that contradicts the pixels is\n worse than none.\n\n WMS servers publish their real styling via GetLegendGraphic, so the\n client renders that image instead. It cannot disagree with the tiles\n because it comes from the same style definition. */\n const legendUrl = `${OPENGEO}/conus/ows?service=WMS&version=1.3.0` +\n `&request=GetLegendGraphic&format=image/png&width=20&height=20` +\n `&layer=${\n encodeURIComponent(layers[0])\n }&legend_options=fontColor:0xe2eaf8;` +\n `fontAntiAliasing:true;bgColor:0x0f2451;fontSize:11`;\n\n return json(\n {\n wmsUrl: `${OPENGEO}/conus/ows`,\n layer: layers[0],\n discovered: layers,\n legendUrl,\n },\n 200,\n { \"Cache-Control\": \"public, max-age=1800\" },\n );\n }\n\n /* ── WMS legend image passthrough ──\n Host and path are fixed; only the layer name comes from the caller. */\n if (url.pathname === \"/wms-legend\") {\n const layer = url.searchParams.get(\"layer\") ?? \"\";\n if (!/^[a-z0-9_]{3,40}$/i.test(layer)) {\n return json({ error: \"bad layer\" }, 400);\n }\n\n // Version param lets the client bust a bad cached copy; not forwarded.\n const key = `legend:${layer}:${url.searchParams.get(\"v\") ?? \"\"}`;\n const hit = cacheGet(key);\n if (hit) {\n return new Response(b64ToBytes(hit.body), {\n headers: cors({ \"Content-Type\": \"image/png\", \"X-Proxy-Cache\": \"HIT\" }),\n });\n }\n\n /* GetLegendGraphic is an SLD extension, NOT part of the WMS 1.3.0 core\n spec, and GeoServer expects version=1.0.0 for it. Requesting 1.3.0\n returns a valid-but-blank PNG rather than an error, which is why the\n client rendered an empty box with no failure to catch.\n\n Both are attempted, and a response is only accepted if it is actually\n a PNG of non-trivial size — a blank or error image must not be cached\n for a day and served as if it were a legend. */\n const attempts = [\n `${OPENGEO}/conus/ows?service=WMS&version=1.0.0&request=GetLegendGraphic` +\n `&format=image/png&width=18&height=18&layer=${\n encodeURIComponent(layer)\n }` +\n `&legend_options=fontColor:0xe2eaf8;fontAntiAliasing:true;bgColor:0x0f2451;fontSize:11`,\n `${OPENGEO}/conus/wms?service=WMS&version=1.0.0&request=GetLegendGraphic` +\n `&format=image/png&layer=${encodeURIComponent(layer)}`,\n `${OPENGEO}/conus/ows?service=WMS&version=1.3.0&request=GetLegendGraphic` +\n `&format=image/png&layer=${encodeURIComponent(layer)}`,\n ];\n\n const tried: Array> = [];\n for (const target of attempts) {\n try {\n const up = await fetch(target, {\n headers: { \"User-Agent\": UA },\n signal: AbortSignal.timeout(15000),\n });\n const type = up.headers.get(\"Content-Type\") ?? \"\";\n const buf = new Uint8Array(await up.arrayBuffer());\n const isPng = buf[0] === 0x89 && buf[1] === 0x50;\n\n tried.push({\n ok: up.ok,\n status: up.status,\n type,\n bytes: buf.length,\n isPng,\n });\n\n // A legend with real content is comfortably over 400 bytes; a blank\n // or 1x1 placeholder is far smaller.\n if (up.ok && isPng && buf.length > 400) {\n cacheSet(key, {\n body: bytesToB64(buf),\n status: 200,\n type: \"image/png\",\n exp: Date.now() + 24 * 3600_000,\n });\n return new Response(buf, {\n headers: cors({\n \"Content-Type\": \"image/png\",\n \"Cache-Control\": \"public, max-age=86400\",\n }),\n });\n }\n } catch (err) {\n tried.push({ error: String(err) });\n }\n }\n\n // Nothing usable. Report what each attempt returned rather than serving\n // a blank image the client cannot distinguish from a working one.\n return json({ error: \"No usable legend graphic\", layer, tried }, 502);\n }\n\n /* ── Nearest NEXRAD site and its available layers ── */\n if (url.pathname === \"/radar-site\") {\n const lat = Number(url.searchParams.get(\"lat\"));\n const lon = Number(url.searchParams.get(\"lon\"));\n if (!Number.isFinite(lat) || !Number.isFinite(lon)) {\n return json({ error: \"lat and lon required\" }, 400);\n }\n\n let sites: any;\n const hit = cacheGet(\"radar:sites\");\n if (hit) {\n sites = JSON.parse(hit.body);\n } else {\n try {\n const res = await fetch(\n `${OPENGEO}/nws/ows?service=WFS&version=1.0.0&request=GetFeature` +\n `&typeName=nws:radar_sites&outputFormat=application/json`,\n { headers: { \"User-Agent\": UA }, signal: AbortSignal.timeout(20000) },\n );\n if (!res.ok) {\n return json({ error: `Site list returned ${res.status}` }, 502);\n }\n sites = await res.json();\n cacheSet(\"radar:sites\", {\n body: JSON.stringify(sites),\n status: 200,\n type: \"application/json\",\n exp: Date.now() + 86400_000,\n });\n } catch (err) {\n return json(\n { error: \"Site list unreachable\", detail: String(err) },\n 502,\n );\n }\n }\n\n /* Prefer NEXRAD (K-prefixed) over TDWR (T-prefixed).\n TDWR is higher resolution but its base reflectivity is NOT\n quality-controlled: at close range it is dominated by ground clutter,\n which rendered as a solid brown disc covering the whole metro area and\n obscured the actual weather. Finer data that hides the answer is worse\n than coarser data that shows it. TDWR is still offered explicitly via\n ?prefer=tdwr for anyone who wants it. */\n const preferTdwr = url.searchParams.get(\"prefer\") === \"tdwr\";\n const idOf = (p: any) =>\n String(p?.rda_id ?? p?.siteID ?? p?.id ?? \"\").toUpperCase();\n const isTdwr = (p: any) => /^T[A-Z]{3}$/.test(idOf(p));\n\n const R = 3958.8, rad = Math.PI / 180;\n let best: any = null, bestD = Infinity;\n let bestTdwr: any = null, bestTdwrD = Infinity;\n\n for (const f of sites.features ?? []) {\n const c = f.geometry?.coordinates;\n if (!c) continue;\n const [sLon0, sLat0] = c;\n\n /* TDWR is tracked separately rather than skipped. It is not a better or\n worse radar, it is a different trade: ~0.15 km sampling against\n NEXRAD's 0.25, but roughly 90 km of coverage against 230, and no\n quality control. Near a metro area during a storm that trade is worth\n making; as a default it is not. Reporting both lets the client offer\n the choice with the distances visible. */\n if (isTdwr(f.properties)) {\n const dLa0 = (sLat0 - lat) * rad, dLo0 = (sLon0 - lon) * rad;\n const h0 = Math.sin(dLa0 / 2) ** 2 +\n Math.cos(lat * rad) * Math.cos(sLat0 * rad) * Math.sin(dLo0 / 2) ** 2;\n const d0 = 2 * R * Math.asin(Math.min(1, Math.sqrt(h0)));\n if (d0 < bestTdwrD) {\n bestTdwrD = d0;\n bestTdwr = { props: f.properties, lat: sLat0, lon: sLon0 };\n }\n if (!preferTdwr) continue;\n }\n\n const [sLon, sLat] = c;\n const dLa = (sLat - lat) * rad, dLo = (sLon - lon) * rad;\n const h = Math.sin(dLa / 2) ** 2 +\n Math.cos(lat * rad) * Math.cos(sLat * rad) * Math.sin(dLo / 2) ** 2;\n const d = 2 * R * Math.asin(Math.min(1, Math.sqrt(h)));\n if (d < bestD) {\n bestD = d;\n best = { props: f.properties, lat: sLat, lon: sLon };\n }\n }\n if (!best) return json({ error: \"No radar sites parsed\" }, 502);\n\n const id = String(\n best.props?.rda_id ?? best.props?.siteID ?? best.props?.id ??\n best.props?.name ?? \"\",\n ).toLowerCase().trim();\n if (!id) {\n return json({\n error: \"Site id attribute not recognised\",\n sample: best.props,\n }, 502);\n }\n\n // Layer names are discovered, never assumed — a wrong guess renders an\n // empty layer with no error anywhere.\n const layers = await discover(\n `${OPENGEO}/${id}/ows?service=wms&version=1.3.0&request=GetCapabilities`,\n `wms:${id}`,\n /bref|bvel|bdhc|boha|bdsa/i,\n );\n\n return json(\n {\n site: id.toUpperCase(),\n kind: /^t[a-z]{3}$/.test(id) ? \"TDWR\" : \"NEXRAD\",\n name: best.props?.name ?? best.props?.location ?? null,\n lat: best.lat,\n lon: best.lon,\n distanceMi: +bestD.toFixed(1),\n wmsUrl: `${OPENGEO}/${id}/ows`,\n layers,\n reflectivity: layers.find((l) => /sr_bref|bref1|_bref/i.test(l)) ??\n null,\n velocity: layers.find((l) => /sr_bvel|_bvel/i.test(l)) ?? null,\n /* Offered as an alternative, not switched to. TDWR coverage is roughly\n 90 km, so beyond that it would show a small disc of weather and\n nothing around it — worse than the NEXRAD it replaced. The client\n only offers it when the site is close enough to be useful. */\n tdwr: bestTdwr\n ? {\n site: String(bestTdwr.props?.rda_id ?? bestTdwr.props?.siteID ?? \"\")\n .toUpperCase(),\n name: bestTdwr.props?.name ?? bestTdwr.props?.location ?? null,\n distanceMi: +bestTdwrD.toFixed(1),\n usefulRangeMi: 56,\n }\n : null,\n\n // Surfaced so a wrong attribute name is visible rather than mysterious.\n attributes: Object.keys(best.props ?? {}),\n },\n 200,\n { \"Cache-Control\": \"public, max-age=300\" },\n );\n }\n\n /* ── Marine: nearest NDBC buoys ──\n One ~95 kB file carries the latest observation from every NDBC station,\n refreshed every 5 minutes, so a single cached fetch answers any location\n in the country — coasts, Gulf, and the Great Lakes alike. */\n if (url.pathname === \"/marine\") {\n const lat = Number(url.searchParams.get(\"lat\"));\n const lon = Number(url.searchParams.get(\"lon\"));\n if (!Number.isFinite(lat) || !Number.isFinite(lon)) {\n return json({ error: \"lat and lon required\" }, 400);\n }\n const radius = Math.min(\n 200,\n Math.max(1, Number(url.searchParams.get(\"radius\") ?? 40)),\n );\n\n let text: string;\n const hit = cacheGet(\"ndbc:latest\");\n if (hit) {\n text = hit.body;\n } else {\n try {\n const up = await fetch(\n \"https://www.ndbc.noaa.gov/data/latest_obs/latest_obs.txt\",\n {\n headers: { \"User-Agent\": UA },\n signal: AbortSignal.timeout(15000),\n },\n );\n if (!up.ok) return json({ error: `NDBC returned ${up.status}` }, 502);\n text = await up.text();\n cacheSet(\"ndbc:latest\", {\n body: text,\n status: 200,\n type: \"text/plain\",\n exp: Date.now() + 5 * 60 * 1000,\n });\n } catch (err) {\n return json({ error: \"NDBC unreachable\", detail: String(err) }, 502);\n }\n }\n\n /* Names live in a different file entirely — latest_obs.txt carries bare\n IDs. Cached for a day because the roster changes on the order of\n months, not minutes. */\n let names: Record = {};\n const nHit = cacheGet(\"ndbc:names\");\n if (nHit) {\n names = JSON.parse(nHit.body);\n } else {\n try {\n const nres = await fetch(\n \"https://www.ndbc.noaa.gov/activestations.xml\",\n {\n headers: { \"User-Agent\": UA },\n signal: AbortSignal.timeout(15000),\n },\n );\n if (nres.ok) {\n const xml = await nres.text();\n for (const m of xml.matchAll(/]*?)\\/?>/g)) {\n const attrs = m[1];\n const id = attrs.match(/\\bid=\"([^\"]+)\"/)?.[1];\n let nm = attrs.match(/\\bname=\"([^\"]+)\"/)?.[1];\n if (!id || !nm) continue;\n // NDBC appends the ID in parentheses; the card already shows it.\n nm = nm.replace(/\\s*\$[^)]*\$\\s*$/, \"\").trim();\n if (nm) names[id] = nm;\n }\n cacheSet(\"ndbc:names\", {\n body: JSON.stringify(names),\n status: 200,\n type: \"application/json\",\n exp: Date.now() + 86400_000,\n });\n }\n } catch {\n /* names are cosmetic; never fail the reading because of them */\n }\n }\n\n const lines = text.split(\"\\n\");\n /* Column positions are read from the header rather than hardcoded. NDBC\n has changed this layout before (PTDY moved, TIDE appeared), and an\n off-by-one column silently reports wave height as pressure. */\n const headerLine = lines.find((l) => l.startsWith(\"#STN\"));\n if (!headerLine) return json({ error: \"NDBC format not recognised\" }, 502);\n const cols = headerLine.replace(/^#/, \"\").trim().split(/\\s+/);\n const at = (name: string) => cols.indexOf(name);\n\n const iLat = at(\"LAT\"), iLon = at(\"LON\");\n if (iLat < 0 || iLon < 0) {\n return json({ error: \"NDBC header missing LAT/LON\" }, 502);\n }\n\n const num = (f: string[], i: number): number | null => {\n if (i < 0 || i >= f.length) return null;\n const v = f[i];\n // NDBC marks absent readings \"MM\"; treating that as 0 would report\n // flat seas and freezing water wherever a sensor is down.\n if (!v || v === \"MM\" || v === \"-\") return null;\n const n = Number(v);\n return Number.isFinite(n) ? n : null;\n };\n\n const R = 3958.8, rad = Math.PI / 180;\n const distMi = (la: number, lo: number) => {\n const dLa = (la - lat) * rad, dLo = (lo - lon) * rad;\n const h = Math.sin(dLa / 2) ** 2 +\n Math.cos(lat * rad) * Math.cos(la * rad) * Math.sin(dLo / 2) ** 2;\n return 2 * R * Math.asin(Math.min(1, Math.sqrt(h)));\n };\n\n const iY = at(\"YYYY\") >= 0 ? at(\"YYYY\") : at(\"YY\");\n const stations = [];\n\n for (const line of lines) {\n if (!line || line.startsWith(\"#\")) continue;\n const f = line.trim().split(/\\s+/);\n if (f.length < 10) continue;\n\n const sLat = num(f, iLat), sLon = num(f, iLon);\n if (sLat === null || sLon === null) continue;\n\n const d = distMi(sLat, sLon);\n if (d > radius) continue;\n\n let obsMs: number | null = null;\n if (iY >= 0) {\n const y = num(f, iY),\n mo = num(f, iY + 1),\n da = num(f, iY + 2),\n hh = num(f, iY + 3),\n mi = num(f, iY + 4);\n if (y && mo && da != null && hh != null && mi != null) {\n obsMs = Date.UTC(y < 100 ? 2000 + y : y, mo - 1, da, hh, mi);\n }\n }\n\n const wspdMs = num(f, at(\"WSPD\")), gstMs = num(f, at(\"GST\"));\n const wvhtM = num(f, at(\"WVHT\")),\n wtmpC = num(f, at(\"WTMP\")),\n atmpC = num(f, at(\"ATMP\"));\n\n stations.push({\n id: f[0],\n name: names[f[0]] ?? null,\n lat: sLat,\n lon: sLon,\n distanceMi: +d.toFixed(1),\n bearing: Math.round(\n (Math.atan2(\n Math.sin((sLon - lon) * rad) * Math.cos(sLat * rad),\n Math.cos(lat * rad) * Math.sin(sLat * rad) -\n Math.sin(lat * rad) * Math.cos(sLat * rad) *\n Math.cos((sLon - lon) * rad),\n ) / rad + 360) % 360,\n ),\n observedMs: obsMs,\n ageMs: obsMs ? Date.now() - obsMs : null,\n waterTempF: wtmpC === null ? null : Math.round(wtmpC * 9 / 5 + 32),\n airTempF: atmpC === null ? null : Math.round(atmpC * 9 / 5 + 32),\n waveHeightFt: wvhtM === null ? null : +(wvhtM * 3.28084).toFixed(1),\n dominantPeriodS: num(f, at(\"DPD\")),\n waveDirection: num(f, at(\"MWD\")),\n windMph: wspdMs === null ? null : Math.round(wspdMs * 2.23694),\n gustMph: gstMs === null ? null : Math.round(gstMs * 2.23694),\n windDirection: num(f, at(\"WDIR\")),\n });\n }\n\n stations.sort((a, b) => a.distanceMi - b.distanceMi);\n\n // Readings older than three hours are dropped: a buoy that stopped\n // reporting this morning should not present as current conditions.\n const fresh = stations.filter((s) =>\n s.ageMs === null || s.ageMs < 3 * 3600_000\n );\n\n const nearestWith = (k: string) =>\n fresh.find((s) => (s as any)[k] !== null)?.id ?? null;\n\n return json(\n {\n lat,\n lon,\n radiusMi: radius,\n count: fresh.length,\n // The nearest buoy overall often lacks the sensor you want, so the\n // nearest source for each field is named separately.\n nearest: {\n any: fresh[0]?.id ?? null,\n waterTemp: nearestWith(\"waterTempF\"),\n waves: nearestWith(\"waveHeightFt\"),\n wind: nearestWith(\"windMph\"),\n },\n stations: fresh.slice(0, 8),\n },\n 200,\n { \"Cache-Control\": \"public, max-age=120\" },\n );\n }\n\n /* ── Single-site WMS tile, CORS-enabled ──\n Needed so the client can read these tiles back off a canvas and strip\n ground clutter. Host is fixed; only the layer name and bbox come from\n the caller, and both are validated. */\n if (url.pathname === \"/site-tile\") {\n const layer = url.searchParams.get(\"layer\") ?? \"\";\n const bbox = url.searchParams.get(\"bbox\") ?? \"\";\n const site = url.searchParams.get(\"site\") ?? \"\";\n\n if (!/^[a-z0-9_]{3,40}$/i.test(layer)) {\n return json({ error: \"bad layer\" }, 400);\n }\n if (!/^[a-z0-9]{3,6}$/i.test(site)) return json({ error: \"bad site\" }, 400);\n if (!/^-?[\\d.]+(,-?[\\d.]+){3}$/.test(bbox)) {\n return json({ error: \"bad bbox\" }, 400);\n }\n\n const target =\n `${OPENGEO}/${site.toLowerCase()}/ows?service=WMS&version=1.3.0` +\n `&request=GetMap&layers=${encodeURIComponent(layer)}&styles=` +\n `&format=image/png&transparent=true&width=256&height=256` +\n `&crs=EPSG:3857&bbox=${bbox}`;\n\n const key = `sitetile:${layer}:${bbox}`;\n const hit = cacheGet(key);\n if (hit) {\n return new Response(b64ToBytes(hit.body), {\n headers: cors({ \"Content-Type\": \"image/png\", \"X-Proxy-Cache\": \"HIT\" }),\n });\n }\n\n let up: Response;\n try {\n up = await fetch(target, {\n headers: { \"User-Agent\": UA },\n signal: AbortSignal.timeout(15000),\n });\n } catch (err) {\n return json({ error: \"WMS unreachable\", detail: String(err) }, 502);\n }\n if (!up.ok) return json({ error: `WMS ${up.status}` }, up.status);\n\n const buf = new Uint8Array(await up.arrayBuffer());\n cacheSet(key, {\n body: bytesToB64(buf),\n status: 200,\n type: \"image/png\",\n exp: Date.now() + 3 * 60 * 1000,\n });\n\n return new Response(buf, {\n headers: cors({\n \"Content-Type\": \"image/png\",\n \"Cache-Control\": \"public, max-age=180\",\n }),\n });\n }\n\n /* ── Radar frame passthrough ──\n Exists purely to attach CORS headers. The client must read these tiles\n back off a canvas to correlate them, and a cross-origin image without\n CORS taints the canvas and makes getImageData throw. IEM's own headers\n cannot be relied on, so the frames come through here instead. */\n if (url.pathname.startsWith(\"/radar-tile/\")) {\n const parts = url.pathname.slice(\"/radar-tile/\".length).split(\"/\");\n if (parts.length !== 4) {\n return json({ error: \"expected /radar-tile/{ts}/{z}/{x}/{y}.png\" }, 400);\n }\n\n const [ts, z, x, yPng] = parts;\n // Whitelist: \"900913\" or \"900913-mNNm\". Anything else is not a frame this\n // service publishes, and reflecting arbitrary strings into an upstream\n // path is how a proxy becomes an open relay.\n if (!/^900913(-m[0-5][05]m)?$/.test(ts)) {\n return json({ error: \"bad frame id\" }, 400);\n }\n if (\n !/^\\d{1,2}$/.test(z) || !/^\\d{1,7}$/.test(x) ||\n !/^\\d{1,7}\\.png$/.test(yPng)\n ) {\n return json({ error: \"bad tile coordinates\" }, 400);\n }\n\n const target = `https://mesonet.agron.iastate.edu/cache/tile.py/1.0.0/` +\n `nexrad-n0q-${ts}/${z}/${x}/${yPng}`;\n const key = `tile:${ts}/${z}/${x}/${yPng}`;\n\n const hit = cacheGet(key);\n if (hit) {\n return new Response(b64ToBytes(hit.body), {\n headers: cors({ \"Content-Type\": \"image/png\", \"X-Proxy-Cache\": \"HIT\" }),\n });\n }\n\n let up: Response;\n try {\n up = await fetch(target, {\n headers: { \"User-Agent\": UA },\n signal: AbortSignal.timeout(12000),\n });\n } catch (err) {\n return json({ error: \"Tile unreachable\", detail: String(err) }, 502);\n }\n if (!up.ok) return json({ error: `Tile upstream ${up.status}` }, up.status);\n\n const buf = new Uint8Array(await up.arrayBuffer());\n // Frames are immutable once published, so a long TTL is safe and keeps\n // repeated nowcast runs off IEM's server.\n cacheSet(key, {\n body: bytesToB64(buf),\n status: 200,\n type: \"image/png\",\n exp: Date.now() + 4 * 60 * 1000,\n });\n\n return new Response(buf, {\n headers: cors({\n \"Content-Type\": \"image/png\",\n \"X-Proxy-Cache\": \"MISS\",\n \"Cache-Control\": \"public, max-age=240\",\n }),\n });\n }\n\n /* ── Forecast diff: how the forecast has MOVED ── */\n if (url.pathname === \"/forecast-diff\") {\n const grid = (url.searchParams.get(\"grid\") ?? \"\").trim();\n if (!/^[A-Z]{3}\\/\\d+,\\d+$/.test(grid)) {\n return json({ error: \"grid must look like LMK/44,79\" }, 400);\n }\n const hours = Math.min(\n 240,\n Math.max(1, Number(url.searchParams.get(\"hours\") ?? 24)),\n );\n const since = Date.now() - hours * 3600_000;\n\n try {\n await ensureSchema();\n\n const snaps = await sqlite.execute({\n sql: `SELECT DISTINCT taken_at FROM fc_snap\n WHERE grid = ? AND taken_at >= ? ORDER BY taken_at`,\n args: [grid, since],\n });\n const times = snaps.rows.map((r) => Number(r[0]));\n\n if (times.length < 2) {\n // One snapshot is not a history. Saying \"unchanged\" here would be a\n // claim the data cannot support.\n return json(\n {\n grid,\n hours,\n snapshots: times.length,\n status: times.length ? \"building\" : \"none\",\n note: \"Not enough history yet to compare.\",\n periods: [],\n },\n 200,\n { \"Cache-Control\": \"public, max-age=60\" },\n );\n }\n\n const first = times[0];\n const last = times[times.length - 1];\n\n const rows = await sqlite.execute({\n sql: `SELECT start_time, taken_at, name, temp, pop, short\n FROM fc_snap\n WHERE grid = ? AND taken_at >= ?\n ORDER BY start_time, taken_at`,\n args: [grid, since],\n });\n\n // Group by the period's own start time, then measure movement across\n // every snapshot in the window — not just first vs last. A forecast that\n // swung 60 -> 20 -> 60 reads as \"unchanged\" on endpoints alone, and that\n // is precisely the instability worth surfacing.\n const byPeriod = new Map();\n for (const r of rows.rows as unknown[][]) {\n const k = String(r[0]);\n if (!byPeriod.has(k)) byPeriod.set(k, []);\n byPeriod.get(k)!.push({\n takenAt: Number(r[1]),\n name: r[2] ? String(r[2]) : null,\n temp: r[3] == null ? null : Number(r[3]),\n pop: r[4] == null ? null : Number(r[4]),\n short: r[5] ? String(r[5]) : null,\n });\n }\n\n const nowIso = new Date().toISOString();\n const periods = [];\n\n for (const [startTime, hist] of byPeriod) {\n if (startTime < nowIso) continue; // past periods cannot change\n if (hist.length < 2) continue; // no history for this one\n if (hist[hist.length - 1].takenAt !== last) continue; // dropped from latest\n\n const a = hist[0], b = hist[hist.length - 1];\n const temps = hist.map((h) => h.temp).filter((v) =>\n v != null\n ) as number[];\n const pops = hist.map((h) => h.pop).filter((v) =>\n v != null\n ) as number[];\n\n let revisions = 0;\n for (let i = 1; i < hist.length; i++) {\n if (\n hist[i].temp !== hist[i - 1].temp ||\n hist[i].pop !== hist[i - 1].pop ||\n hist[i].short !== hist[i - 1].short\n ) revisions++;\n }\n\n periods.push({\n startTime,\n name: b.name,\n revisions,\n temp: {\n was: a.temp,\n now: b.temp,\n delta: a.temp != null && b.temp != null ? b.temp - a.temp : null,\n swing: temps.length\n ? Math.max(...temps) - Math.min(...temps)\n : null,\n },\n pop: {\n was: a.pop,\n now: b.pop,\n delta: a.pop != null && b.pop != null ? b.pop - a.pop : null,\n swing: pops.length ? Math.max(...pops) - Math.min(...pops) : null,\n },\n short: { was: a.short, now: b.short, changed: a.short !== b.short },\n });\n }\n\n const totalRev = periods.reduce((n, p) => n + p.revisions, 0);\n\n return json(\n {\n grid,\n hours,\n status: \"ok\",\n snapshots: times.length,\n windowStart: new Date(first).toISOString(),\n windowEnd: new Date(last).toISOString(),\n totalRevisions: totalRev,\n // Deliberately descriptive, not a confidence score. This measures how\n // much the forecast MOVED, which is not the same as how wrong it is.\n stability: totalRev === 0\n ? \"steady\"\n : totalRev <= 3\n ? \"minor\"\n : \"volatile\",\n periods,\n },\n 200,\n { \"Cache-Control\": \"public, max-age=120\" },\n );\n } catch (err) {\n return json({\n error: \"Forecast history unavailable\",\n detail: String(err),\n }, 503);\n }\n }\n\n /* ── Forecast skill: how the forecast actually PERFORMED ── */\n if (url.pathname === \"/forecast-skill\") {\n const grid = (url.searchParams.get(\"grid\") ?? \"\").trim();\n const station = (url.searchParams.get(\"station\") ?? \"\").trim()\n .toUpperCase();\n if (!/^[A-Z]{3}\\/\\d+,\\d+$/.test(grid)) {\n return json({ error: \"grid must look like LMK/44,79\" }, 400);\n }\n if (!/^[A-Z0-9]{3,5}$/.test(station)) {\n return json({ error: \"station required, e.g. KSDF\" }, 400);\n }\n const days = Math.min(\n 10,\n Math.max(1, Number(url.searchParams.get(\"days\") ?? 7)),\n );\n const since = Date.now() - days * 86400_000;\n\n try {\n await ensureSchema();\n\n /* Only periods that have ENDED can be scored, and only the LAST forecast\n issued before a period began — scoring a 6-day-out forecast against a\n 6-hour-out one would blend two different questions. Taking the newest\n snapshot whose taken_at precedes start_time gives a consistent\n \"final forecast before the fact\" comparison. */\n const fc = await sqlite.execute({\n sql:\n `SELECT f.start_time, f.end_time, f.is_day, f.name, f.temp, f.taken_at\n FROM fc_snap f\n JOIN (\n SELECT start_time, MAX(taken_at) AS mt\n FROM fc_snap\n WHERE grid = ? AND taken_at >= ?\n AND end_ms > 0 AND end_ms < ?\n AND taken_at < start_ms\n GROUP BY start_time\n ) b ON b.start_time = f.start_time AND b.mt = f.taken_at\n WHERE f.grid = ?\n ORDER BY f.start_time`,\n args: [grid, since, Date.now(), grid],\n });\n\n const obs = await sqlite.execute({\n sql:\n `SELECT ts, temp_c FROM obs_snap WHERE station = ? AND ts >= ? ORDER BY ts`,\n args: [station, since],\n });\n const obsRows = (obs.rows as unknown[][])\n .map((r) => ({ ts: Number(r[0]), c: Number(r[1]) }));\n\n const scored = [];\n for (const r of fc.rows as unknown[][]) {\n const startTime = String(r[0]);\n const endTime = String(r[1]);\n const isDay = Number(r[2]) === 1;\n const name = r[3] ? String(r[3]) : null;\n const fTemp = r[4] == null ? null : Number(r[4]);\n if (fTemp == null || !endTime) continue;\n\n const a = Date.parse(startTime);\n const b = Date.parse(endTime);\n if (!Number.isFinite(a) || !Number.isFinite(b)) continue;\n const win = obsRows.filter((o) => o.ts >= a && o.ts <= b);\n\n /* A daytime period forecasts the HIGH, a night period the LOW, so the\n comparison must use max or min accordingly — averaging would score\n the wrong quantity and flatter the forecast.\n\n Coverage matters too: observations arrive only when someone opened\n the app, so a window with two samples cannot establish a true high.\n Thin windows are reported, not silently averaged in. */\n if (win.length < 3) {\n scored.push({\n startTime,\n name,\n forecastF: fTemp,\n observedF: null,\n samples: win.length,\n skipped: \"insufficient observations\",\n });\n continue;\n }\n\n const temps = win.map((o) => o.c);\n const extreme = isDay ? Math.max(...temps) : Math.min(...temps);\n const observedF = Math.round(extreme * 9 / 5 + 32);\n\n scored.push({\n startTime,\n name,\n isDay,\n forecastF: fTemp,\n observedF,\n errorF: fTemp - observedF, // positive = forecast ran warm\n samples: win.length,\n });\n }\n\n const usable = scored.filter((x) => x.observedF != null);\n const errs = usable.map((x) => x.errorF as number);\n const mean = (a: number[]) => a.reduce((s, v) => s + v, 0) / a.length;\n\n return json(\n {\n grid,\n station,\n days,\n scoredPeriods: usable.length,\n pendingPeriods: scored.length - usable.length,\n // Reported only with enough periods to mean anything. Two samples do\n // not establish a bias, and printing one would invite over-reading.\n summary: usable.length >= 5\n ? {\n meanBiasF: +mean(errs).toFixed(1),\n meanAbsErrorF: +mean(errs.map(Math.abs)).toFixed(1),\n warmCount: errs.filter((e) => e > 0).length,\n coolCount: errs.filter((e) => e < 0).length,\n exactCount: errs.filter((e) => e === 0).length,\n }\n : null,\n note: usable.length >= 5\n ? \"Bias is forecast minus observed; positive means the forecast ran warm.\"\n : \"Needs at least 5 completed periods with observation coverage.\",\n periods: scored,\n },\n 200,\n { \"Cache-Control\": \"public, max-age=300\" },\n );\n } catch (err) {\n return json(\n { error: \"Skill history unavailable\", detail: String(err) },\n 503,\n );\n }\n }\n\n /* ── Lightning: ingest on demand, then serve ── */\n if (url.pathname === \"/lightning\") {\n const minutes = Math.min(\n 60,\n Math.max(1, Number(url.searchParams.get(\"minutes\") ?? 30)),\n );\n const since = Date.now() - minutes * 60_000;\n\n // bbox=minLon,minLat,maxLon,maxLat — GeoJSON axis order, the reverse of\n // Leaflet's LatLngBounds. Mixing them returns an empty set rather than an\n // error, so the order is fixed here and the client must match it.\n const raw = url.searchParams.get(\"bbox\");\n let bounds: number[] | null = null;\n if (raw) {\n const p = raw.split(\",\").map(Number);\n if (p.length !== 4 || p.some((n) => !Number.isFinite(n))) {\n return json({ error: \"bbox must be minLon,minLat,maxLon,maxLat\" }, 400);\n }\n if (p[0] > p[2] || p[1] > p[3]) {\n return json({ error: \"bbox min values must be <= max values\" }, 400);\n }\n bounds = p;\n }\n\n let ingest: Record;\n let rows: unknown[][];\n let newest: number | null;\n let lastRun: number | null;\n\n try {\n await ensureSchema();\n ingest = await maybeIngest();\n\n const where = [\"ts >= ?\"];\n const args: unknown[] = [since];\n if (bounds) {\n where.push(\"lon >= ? AND lat >= ? AND lon <= ? AND lat <= ?\");\n args.push(bounds[0], bounds[1], bounds[2], bounds[3]);\n }\n\n const q = await sqlite.execute({\n sql: `SELECT lon, lat, ts FROM glm_flashes\n WHERE ${where.join(\" AND \")}\n ORDER BY ts DESC LIMIT ?`,\n args: [...args, LIGHTNING_MAX_FEATURES],\n });\n rows = q.rows as unknown[][];\n\n // Freshness is measured across the whole table, never the filtered set.\n // An empty bbox must not be reportable as a dead pipeline, and a dead\n // pipeline must not be reportable as a quiet sky.\n const n = await sqlite.execute({\n sql: `SELECT MAX(ts) FROM glm_flashes`,\n args: [],\n });\n newest = n.rows[0]?.[0] != null ? Number(n.rows[0][0]) : null;\n\n const lr = await sqlite.execute({\n sql: `SELECT value FROM glm_state WHERE key = 'last_run_ts'`,\n args: [],\n });\n lastRun = lr.rows.length ? Number(lr.rows[0][0]) : null;\n } catch (err) {\n return json({ error: \"Lightning unavailable\", detail: String(err) }, 503);\n }\n\n const now = Date.now();\n\n return json(\n {\n type: \"FeatureCollection\",\n features: rows.map((r) => ({\n type: \"Feature\",\n geometry: {\n type: \"Point\",\n coordinates: [Number(r[0]), Number(r[1])],\n },\n properties: { ts: Number(r[2]), ageMs: now - Number(r[2]) },\n })),\n properties: {\n source: `GOES-${SAT} GLM L2`,\n windowMinutes: minutes,\n count: rows.length,\n truncated: rows.length >= LIGHTNING_MAX_FEATURES,\n newestTs: newest,\n\n // Three facts a client must not collapse into one:\n // newestFlashAgeMs - since lightning was last DETECTED\n // ingestAgeMs - since the pipeline last RAN\n // feedHealthy - derived from the second, never the first\n newestFlashAgeMs: newest === null ? null : now - newest,\n ingestAgeMs: lastRun === null ? null : now - lastRun,\n feedAgeMs: lastRun === null ? null : now - lastRun,\n staleThresholdMs: LIGHTNING_STALE_MS,\n feedHealthy: lastRun !== null && (now - lastRun) < LIGHTNING_STALE_MS,\n\n ingest,\n\n // Ships on the wire, not just in the UI. Any consumer owes the user\n // both facts: GLM cannot separate in-cloud from cloud-to-ground, and\n // sunlit cloud tops cut detection efficiency in exactly the\n // conditions a daytime flight would care about.\n caveat:\n \"Total lightning (IC+CG, indistinguishable). Reduced daytime detection efficiency.\",\n },\n },\n 200,\n { \"Cache-Control\": \"public, max-age=20\" },\n );\n }\n\n return json({ error: \"Not found\" }, 404);\n}\n\n/* EOF wx-proxy.ts */","deleted",false,"label",[35],{"_33":34,"_13":35,"_36":37,"_38":-5,"_39":40,"_41":42,"_43":44,"_45":57,"_17":47,"_48":49,"_50":51,"_52":53,"_54":-5,"_58":59,"_18":60},["D",1785656963446],"children",[],[35],"651c6048-78f3-483a-a06a-5ea7cbca4351",["D",1784975245211],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","Weather ap proxy","imageUrl","userId","8c5bf5c7-e8ff-4c1c-8e0f-978729e1a9b1","pinnedFileId","pinPreview","pinMigrated","screenshotVersion","likeCount",0,"orgId","019ed291-fa6e-72ae-a8f5-6626f3f3a93a","tursoName","651c604878f3483aa06a5ea7cbca4351","tursoHostname","651c604878f3483aa06a5ea7cbca4351-val-town.aws-us-east-2.turso.io","tursoMeasuredAt",["D",1789484509295],"pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_11":12,"_119":115},"org",{"_11":12,"_112":113,"_114":115,"_71":72,"_116":117,"_118":53},"branch",{"_17":42,"_13":16,"_33":40,"_104":61,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":14,"_111":12},"isOwned","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","displayName","C R Paul","avatar","https://lh3.googleusercontent.com/a/ACg8ocK4HQKzxkriEkQ-l0ASodEQP1Wd1XwDksPAKbRNTBRjyNBcVA=s96-c","tier","free","canRestrictVals","profileImageUrl","adoptOrgId",{"_33":61,"_13":14,"_45":153,"_63":-5,"_64":53,"_65":66,"_67":66,"_68":69,"_70":-5,"_71":72,"_73":37,"_74":44,"_75":-5,"_76":-5,"_77":78,"_79":80,"_81":82,"_83":84,"_85":154,"_87":-5,"_88":89,"_90":89,"_91":92,"_93":92,"_94":92,"_95":89,"_96":89,"_97":155,"_99":156,"_101":157,"_103":53},[150],"files",[150],"counts",{"_140":78,"_141":142,"_143":78,"_31":144,"_145":146},[138],"upstreamProject","upstreamBranch","emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},{"_33":34,"_13":35,"_36":37,"_38":-5,"_39":40,"_41":42,"_43":44,"_45":46,"_17":47,"_48":49,"_50":51,"_52":53,"_54":-5,"_18":139},[35],"pulls","branches",1,"forks",{"_147":142,"_149":78},"connections",{"_147":78,"_148":78},"count","unfilledCount","emptyCount",{"_33":34,"_13":35,"_36":37,"_38":-5,"_39":40,"_41":42,"_43":44,"_45":57,"_17":47,"_48":49,"_50":51,"_52":53,"_54":-5,"_58":151,"_18":152},[],[35],["D",1784975245211],["D",1789484509295],{"_11":12,"_119":115},{"_11":12,"_112":113,"_114":115,"_71":72,"_116":117,"_118":53},{"_17":42,"_13":16,"_33":40,"_104":61,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5,"_110":14,"_111":12},"ctx",{"_97":-5,"_135":191,"_192":193,"_194":195,"_196":53,"_197":53,"_198":53,"_199":44,"_200":-5,"_201":-7,"_202":-7,"_203":78,"_204":53,"_205":53,"_206":-5,"_207":53,"_208":53,"_209":53,"_210":-5},"ENV",{"_162":163,"_164":165,"_166":16,"_167":168,"_169":170,"_171":172,"_173":174,"_175":176,"_177":178,"_179":180,"_181":182,"_183":184,"_185":186,"_187":188,"_189":190},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]