import { GFS_BUCKET, gfsObjectKey, selectLatestGfsCycle, } from './wind/catalog.js'; import { fetchText, fetchRange, parseGfsIdx, windMessageRanges, } from './wind/gfs.js'; import { decodeWindGribMessage } from './wind/decode.js'; import { resampleWindGrid } from './wind/grid.js'; /** * NOAA GFS 10 m wind proxy. * * Selects the latest available GFS cycle, reads its `.idx` inventory, byte-range * fetches only the UGRD/VGRD 10 m GRIB2 messages, decodes them with ecCodes * (WASM), resamples to a compact grid, and serves a manifest plus a Float32 * grid (U values then V values). Keyless; cached per cycle for an hour. * * Routes (mounted at `/api/wind`): * GET /api/wind/manifest → manifest JSON * GET /api/wind/grid/.bin → Float32 U…V payload * GET /api/wind/status → manifest without `gridUrl` * * @param {{fetchImpl?: Function, now?: Function, decodeImpl?: Function, * targetDx?: number, ttlMs?: number}} [options] * @returns {import('vite').Plugin} */ export function windProxy({ fetchImpl = fetch, now = () => Date.now(), decodeImpl = decodeWindGribMessage, targetDx = 1, ttlMs = 3600_000, } = {}) { /** @type {?{id: string, idGrid: string, fetchedAt: number, manifest: object, grid: ?object}} */ let cached = null; /** @type {?Promise} */ let loading = null; let lastAttempt = -Infinity; let controller = null; let waiters = 0; const sendJson = (res, value, status = 200) => { res.writeHead(status, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store', }); res.end(JSON.stringify(value)); }; const cycleRunIso = (cycle) => `${cycle.date.slice(0, 4)}-${cycle.date.slice(4, 6)}-${cycle.date.slice(6)}T${String(cycle.hour).padStart(2, '0')}:00:00.000Z`; async function refresh() { const cycle = selectLatestGfsCycle(now()); const id = `${cycle.date}-${cycle.hour}`; if (cached && cached.id === id && now() - cached.fetchedAt < ttlMs) return cached; if (loading) return loading; if (cached && now() - lastAttempt < 60_000) return cached; lastAttempt = now(); controller = new AbortController(); const signal = controller.signal; const timer = setTimeout(() => controller.abort(), 40_000); loading = (async () => { try { const base = `https://${GFS_BUCKET}.s3.amazonaws.com/${gfsObjectKey(cycle)}`; const index = await fetchText({ url: `${base}.idx`, fetchImpl, signal }); const ranges = windMessageRanges(parseGfsIdx(index.toString())); const [uBuffer, vBuffer] = await Promise.all([ fetchRange({ url: base, ...ranges.u, fetchImpl, signal }), fetchRange({ url: base, ...ranges.v, fetchImpl, signal }), ]); const [u, v] = await Promise.all([ decodeImpl(uBuffer), decodeImpl(vBuffer), ]); const grid = resampleWindGrid({ u: u.values, v: v.values, ni: u.ni, nj: u.nj, lo1: u.lo1, la1: u.la1, di: u.di, dj: u.dj, dx: targetDx, dy: targetDx, }); signal.throwIfAborted(); if ((!grid.u.every(Number.isFinite) || !grid.v.every(Number.isFinite))) throw new Error('Invalid wind grid'); const idGrid = `${id}-${targetDx}`; const manifest = { schemaVersion: 1, model: 'gfs', cycle: { ...cycle, forecastHour: 0, runIso: cycleRunIso(cycle), validIso: cycleRunIso(cycle) }, fetchedAt: now(), level: '10 m above ground', units: 'm/s', grid: { nx: grid.nx, ny: grid.ny, lo1: grid.lo1, la1: grid.la1, dx: grid.dx, dy: grid.dy, }, stale: false, unavailable: false, reason: null, gridUrl: `/api/wind/grid/${idGrid}.bin`, }; cached = { id, idGrid, fetchedAt: manifest.fetchedAt, manifest, grid }; return cached; } catch (error) { if (cached) { cached = { ...cached, manifest: { ...cached.manifest, stale: true, reason: 'Wind upstream unavailable' }, }; } else { cached = { id: null, idGrid: null, fetchedAt: now(), grid: null, manifest: { schemaVersion: 1, model: 'gfs', stale: true, unavailable: true, reason: 'Wind upstream unavailable', }, }; } return cached; } finally { clearTimeout(timer); loading = null; controller = null; } })(); return loading; } const handler = async (req, res) => { const path = new URL(req.url, 'http://localhost').pathname; if (req.method !== 'GET') return sendJson(res, { error: 'method_not_allowed' }, 405); if (!['/', '/manifest', '/status'].includes(path) && !/^\/grid\/[\w.-]+\.bin$/.test(path)) return sendJson(res, { error: 'not_found' }, 404); // Grid reads never initiate acquisition; an issued manifest owns its cached grid. if (path.startsWith('/grid/') && (!cached?.grid || path !== `/grid/${cached.idGrid}.bin`)) return sendJson(res, { error: 'unknown_grid' }, 404); let disconnected = false; const close = () => { disconnected = true; waiters -= 1; if (waiters === 0) controller?.abort(); }; waiters += 1; res.once?.('close', close); let state; try { state = path.startsWith('/grid/') ? cached : await refresh(); } finally { res.removeListener?.('close', close); if (!disconnected) waiters -= 1; } if (disconnected) return; if (path === '/status') { const { gridUrl, ...manifest } = state.manifest; return sendJson(res, manifest); } if (path.startsWith('/grid/')) { if (!state.grid || path !== `/grid/${state.idGrid}.bin`) return sendJson(res, { error: 'unknown_grid' }, 404); const payload = Buffer.concat([ Buffer.from(state.grid.u.buffer, state.grid.u.byteOffset, state.grid.u.byteLength), Buffer.from(state.grid.v.buffer, state.grid.v.byteOffset, state.grid.v.byteLength), ]); res.writeHead(200, { 'Content-Type': 'application/octet-stream', 'Cache-Control': 'public, max-age=3600, immutable', }); return res.end(payload); } return sendJson(res, state.manifest); }; return { name: 'wind', configureServer({ middlewares }) { middlewares.use('/api/wind', handler); }, configurePreviewServer({ middlewares }) { middlewares.use('/api/wind', handler); }, }; }