[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_230":231,"_232":233},"routes/_app.x.$handle.$name",{"_96":95,"_32":45,"_103":86,"_27":53,"_13":14,"_104":-5,"_11":105,"_106":107,"_108":109,"_110":111,"_112":113,"_20":-5,"_114":-5,"_115":-5,"_116":25,"_117":118,"_119":58,"_120":-5,"_121":-5,"_122":123},"routes/_app.x.$handle.$name.branch.$branch.version.$version.diff",{"_11":12,"_13":14,"_15":16,"_17":-5,"_18":-5},"project",{"_43":44,"_32":45,"_38":46,"_47":-5,"_48":25,"_49":50,"_51":50,"_52":53,"_54":-5,"_18":55,"_56":31,"_57":58,"_59":-5,"_60":-5,"_61":62,"_63":64,"_65":-5,"_66":-5,"_67":-5,"_68":-5,"_69":70,"_71":70,"_72":73,"_74":73,"_75":73,"_76":70,"_77":70,"_78":79,"_80":81,"_82":83,"_84":25},"version",55,"changes",[19],"aiChatInfo","userId",{"_20":21,"_22":23,"_24":25,"_26":25,"_27":28,"_29":28},"file",{"_30":31,"_32":28,"_33":34,"_35":37,"_38":39,"_40":14,"_41":42,"_24":25},"previous",{"_30":31,"_32":28,"_33":34,"_35":36},"deleted",false,"deletedHere","path","server.ts","latestPath","fileId","0ca60dd2-9e72-11f1-83cf-1607ee4eb77e","name","fileType","http","content","/**\n * server.ts — the read-only endpoint. Deploy as an HTTP val.\n *\n * Does NO maths and fetches NO data. It serves whatever compute.ts last wrote\n * to blob storage. That split means one compute per minute regardless of how\n * many clients are connected, and it keeps CBOE and Yahoo rate-limit exposure\n * fixed rather than proportional to community size.\n *\n * The MotiveWave JAR calls this and plots the result verbatim.\n */\n\nimport { blob } from \"https://esm.town/v/std/blob/main.ts\";\nimport { computeAndStore } from \"./compute.ts\";\n\nconst OUT_KEY = \"levels_current\";\nconst LOCK_KEY = \"levels_lock\";\n\n/**\n * LAZY RECOMPUTE.\n *\n * The free tier caps cron at 15 minutes, which is far too stale for a level\n * tool. Instead the cache is refreshed on demand: if the payload is older than\n * FRESH_TTL_SEC, the request that notices recomputes it. Everyone arriving in\n * the meantime reads the existing payload.\n *\n * Net effect matches the per-minute cron we wanted - one compute per minute at\n * most, independent of how many clients are connected - with no cron at all.\n */\nconst FRESH_TTL_SEC = 60;\n\n/**\n * Thundering-herd guard. Blob storage has no atomic compare-and-swap, so this\n * is advisory: a marker is written before computing, and other requests seeing\n * a recent marker serve the existing payload instead of starting a second\n * compute. A brief race can duplicate work; it can never corrupt anything,\n * because the write is a single whole-object setJSON.\n */\nconst LOCK_TTL_SEC = 25;\n\n/** Payload older than this is served with stale=true rather than withheld. */\nconst STALE_AFTER_SEC = 300;\n\nfunction ageOf(payload: any): number | null {\n const at = payload?.meta?.computedAt;\n return at ? Math.round((Date.now() - Date.parse(at)) / 1000) : null;\n}\n\nasync function refreshIfStale(\n payload: any,\n): Promise<{ payload: any; recomputed: boolean }> {\n const age = ageOf(payload);\n if (payload && age !== null && age < FRESH_TTL_SEC) {\n return { payload, recomputed: false };\n }\n\n let lockAge = Infinity;\n try {\n const lock: any = await blob.getJSON(LOCK_KEY);\n if (lock?.at) lockAge = (Date.now() - lock.at) / 1000;\n } catch { /* no lock present */ }\n\n // Someone else is already on it and we have something to serve.\n if (lockAge < LOCK_TTL_SEC && payload) return { payload, recomputed: false };\n\n try {\n await blob.setJSON(LOCK_KEY, { at: Date.now() });\n } catch { /* advisory only */ }\n await computeAndStore();\n try {\n return { payload: await blob.getJSON(OUT_KEY), recomputed: true };\n } catch {\n return { payload, recomputed: true };\n }\n}\n\n/**\n * AUTH IS CURRENTLY DISABLED. Setting an API_KEY env var turns it back on, so\n * a public endpoint cannot be shipped by forgetting a flag. Quote/whitespace\n * tolerant, because a stray shell quote on a pasted key is a common paste\n * artefact and the resulting 401 looks like a code bug.\n */\nconst cleanKey = (v: string | null | undefined) =>\n (v ?? \"\").trim().replace(/^[\"']|[\"']$/g, \"\");\n\nasync function authorised(req: Request): Promise<{ ok: boolean; via: string }> {\n const expected = cleanKey(Deno.env.get(\"API_KEY\"));\n if (!expected) return { ok: true, via: \"AUTH DISABLED\" };\n\n const sp = new URL(req.url).searchParams;\n const given = cleanKey(req.headers.get(\"X-Api-Key\") ?? sp.get(\"key\"));\n if (given && given === expected) return { ok: true, via: \"api_key\" };\n\n const token = cleanKey(req.headers.get(\"X-Session\") ?? sp.get(\"session\"));\n if (!token) return { ok: false, via: \"no key or session supplied\" };\n for (\n const k of [`session_${token}`, `sess_${token}`, `sessions/${token}`, token]\n ) {\n try {\n const rec: any = await blob.getJSON(k);\n if (!rec) continue;\n const exp = Number(\n rec.exp ?? rec.expires ?? rec.expiresAt ?? rec.expiry ?? 0,\n );\n if (!exp || exp > (exp > 1e12 ? Date.now() : Date.now() / 1000)) {\n return { ok: true, via: \"session\" };\n }\n } catch { /* try next shape */ }\n }\n return { ok: false, via: \"session not recognised\" };\n}\n\nexport default async function (req: Request): Promise {\n const auth = await authorised(req);\n if (!auth.ok) {\n return Response.json({ error: \"unauthorised\", reason: auth.via }, {\n status: 401,\n });\n }\n\n let cached: any = null;\n try {\n cached = await blob.getJSON(OUT_KEY);\n } catch { /* first run */ }\n\n let payload: any, recomputed = false;\n try {\n ({ payload, recomputed } = await refreshIfStale(cached));\n } catch (e: any) {\n payload = cached;\n if (!payload) {\n return Response.json({ error: `compute failed: ${e?.message ?? e}` }, {\n status: 503,\n });\n }\n }\n\n if (!payload) {\n return Response.json({ error: \"no levels available\" }, { status: 503 });\n }\n\n const ageSec = ageOf(payload);\n\n // Never hide staleness. A JAR plotting a 40-minute-old ladder as if it were\n // live is worse than a JAR plotting nothing.\n payload.meta = {\n ...(payload.meta ?? {}),\n ageSec,\n stale: ageSec === null || ageSec > STALE_AFTER_SEC,\n servedAt: new Date().toISOString(),\n authVia: auth.via,\n recomputedThisRequest: recomputed,\n freshTtlSec: FRESH_TTL_SEC,\n };\n\n return Response.json(payload, {\n headers: {\n \"cache-control\": \"no-store\",\n \"access-control-allow-origin\": \"*\",\n },\n });\n}","/**\n * server.ts — the read-only endpoint. Deploy as an HTTP val.\n *\n * Does NO maths and fetches NO data. It serves whatever compute.ts last wrote\n * to blob storage. That split means one compute per minute regardless of how\n * many clients are connected, and it keeps CBOE and Yahoo rate-limit exposure\n * fixed rather than proportional to community size.\n *\n * The MotiveWave JAR calls this and plots the result verbatim.\n */\n\nimport { blob } from \"https://esm.town/v/std/blob/main.ts\";\nimport { ARCHIVE_PREFIX, computeAndStore } from \"./compute.ts\";\n\nconst OUT_KEY = \"levels_current\";\nconst LOCK_KEY = \"levels_lock\";\n\n/**\n * LAZY RECOMPUTE.\n *\n * The free tier caps cron at 15 minutes, which is far too stale for a level\n * tool. Instead the cache is refreshed on demand: if the payload is older than\n * FRESH_TTL_SEC, the request that notices recomputes it. Everyone arriving in\n * the meantime reads the existing payload.\n *\n * Net effect matches the per-minute cron we wanted - one compute per minute at\n * most, independent of how many clients are connected - with no cron at all.\n */\nconst FRESH_TTL_SEC = 60;\n\n/**\n * Thundering-herd guard. Blob storage has no atomic compare-and-swap, so this\n * is advisory: a marker is written before computing, and other requests seeing\n * a recent marker serve the existing payload instead of starting a second\n * compute. A brief race can duplicate work; it can never corrupt anything,\n * because the write is a single whole-object setJSON.\n */\nconst LOCK_TTL_SEC = 25;\n\n/** Payload older than this is served with stale=true rather than withheld. */\nconst STALE_AFTER_SEC = 300;\n\nfunction ageOf(payload: any): number | null {\n const at = payload?.meta?.computedAt;\n return at ? Math.round((Date.now() - Date.parse(at)) / 1000) : null;\n}\n\nasync function refreshIfStale(\n payload: any,\n): Promise<{ payload: any; recomputed: boolean }> {\n const age = ageOf(payload);\n if (payload && age !== null && age < FRESH_TTL_SEC) {\n return { payload, recomputed: false };\n }\n\n let lockAge = Infinity;\n try {\n const lock: any = await blob.getJSON(LOCK_KEY);\n if (lock?.at) lockAge = (Date.now() - lock.at) / 1000;\n } catch { /* no lock present */ }\n\n // Someone else is already on it and we have something to serve.\n if (lockAge < LOCK_TTL_SEC && payload) return { payload, recomputed: false };\n\n try {\n await blob.setJSON(LOCK_KEY, { at: Date.now() });\n } catch { /* advisory only */ }\n await computeAndStore();\n try {\n return { payload: await blob.getJSON(OUT_KEY), recomputed: true };\n } catch {\n return { payload, recomputed: true };\n }\n}\n\n/**\n * AUTH IS CURRENTLY DISABLED. Setting an API_KEY env var turns it back on, so\n * a public endpoint cannot be shipped by forgetting a flag. Quote/whitespace\n * tolerant, because a stray shell quote on a pasted key is a common paste\n * artefact and the resulting 401 looks like a code bug.\n */\nconst cleanKey = (v: string | null | undefined) =>\n (v ?? \"\").trim().replace(/^[\"']|[\"']$/g, \"\");\n\nasync function authorised(req: Request): Promise<{ ok: boolean; via: string }> {\n const expected = cleanKey(Deno.env.get(\"API_KEY\"));\n if (!expected) return { ok: true, via: \"AUTH DISABLED\" };\n\n const sp = new URL(req.url).searchParams;\n const given = cleanKey(req.headers.get(\"X-Api-Key\") ?? sp.get(\"key\"));\n if (given && given === expected) return { ok: true, via: \"api_key\" };\n\n const token = cleanKey(req.headers.get(\"X-Session\") ?? sp.get(\"session\"));\n if (!token) return { ok: false, via: \"no key or session supplied\" };\n for (\n const k of [`session_${token}`, `sess_${token}`, `sessions/${token}`, token]\n ) {\n try {\n const rec: any = await blob.getJSON(k);\n if (!rec) continue;\n const exp = Number(\n rec.exp ?? rec.expires ?? rec.expiresAt ?? rec.expiry ?? 0,\n );\n if (!exp || exp > (exp > 1e12 ? Date.now() : Date.now() / 1000)) {\n return { ok: true, via: \"session\" };\n }\n } catch { /* try next shape */ }\n }\n return { ok: false, via: \"session not recognised\" };\n}\n\nexport default async function (req: Request): Promise {\n const auth = await authorised(req);\n if (!auth.ok) {\n return Response.json({ error: \"unauthorised\", reason: auth.via }, {\n status: 401,\n });\n }\n\n const sp = new URL(req.url).searchParams;\n\n // --- history mode --------------------------------------------------------\n // ?history=10 returns the archived OPENING ladder for the last N sessions,\n // each with its own 18:00-to-18:00 ET span so the client can bound the lines\n // to the session they actually applied to.\n const histN = Number(sp.get(\"history\") ?? 0);\n if (histN > 0) {\n try {\n const all = await blob.list(ARCHIVE_PREFIX);\n const keys = all.map((b: any) => b.key).sort().slice(\n -Math.min(90, histN),\n );\n const sessions: any[] = [];\n for (const k of keys) {\n try {\n const v = await blob.getJSON(k);\n if (v) sessions.push(v);\n } catch { /* skip */ }\n }\n return Response.json({\n sessions,\n count: sessions.length,\n requested: histN,\n note: sessions.length < histN\n ? \"fewer sessions available than requested; the archive only accumulates forward from when archiving was enabled\"\n : undefined,\n }, {\n headers: {\n \"cache-control\": \"no-store\",\n \"access-control-allow-origin\": \"*\",\n },\n });\n } catch (e: any) {\n return Response.json(\n { error: `history unavailable: ${e?.message ?? e}` },\n { status: 503 },\n );\n }\n }\n\n let cached: any = null;\n try {\n cached = await blob.getJSON(OUT_KEY);\n } catch { /* first run */ }\n\n let payload: any, recomputed = false;\n try {\n ({ payload, recomputed } = await refreshIfStale(cached));\n } catch (e: any) {\n payload = cached;\n if (!payload) {\n return Response.json({ error: `compute failed: ${e?.message ?? e}` }, {\n status: 503,\n });\n }\n }\n\n if (!payload) {\n return Response.json({ error: \"no levels available\" }, { status: 503 });\n }\n\n const ageSec = ageOf(payload);\n\n // Never hide staleness. A JAR plotting a 40-minute-old ladder as if it were\n // live is worse than a JAR plotting nothing.\n payload.meta = {\n ...(payload.meta ?? {}),\n ageSec,\n stale: ageSec === null || ageSec > STALE_AFTER_SEC,\n servedAt: new Date().toISOString(),\n authVia: auth.via,\n recomputedThisRequest: recomputed,\n freshTtlSec: FRESH_TTL_SEC,\n };\n\n return Response.json(payload, {\n headers: {\n \"cache-control\": \"no-store\",\n \"access-control-allow-origin\": \"*\",\n },\n });\n}","createdAt",["D",1787481627838],"branchVersion","branchId","9501ca55-9d64-4f95-91aa-9fa7ca96c333","id","2119d995-ca04-498c-aa95-f7a73f7c0d10","ivmodule",["D",1787415250732],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","","imageUrl","edb0ee8b-6eb5-4033-8065-92fa86e65418","pinnedFileId","pinPreview",true,"pinMigrated","screenshotVersion","likeCount",0,"orgId","019f98c4-b792-72f1-83e7-7d98b5b52c8e","tursoName","tursoHostname","tursoMeasuredAt","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_96":95,"_102":53},"org",{"_96":95,"_97":53,"_98":53,"_18":55,"_99":100,"_101":25},"branch",{"_13":85,"_32":86,"_43":42,"_87":44,"_88":-5,"_89":-5,"_90":-5,"_91":-5,"_92":-5,"_93":45,"_94":95},"isOwned",63,"main","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","jfkll","handle","displayName","avatar","tier","free","canRestrictVals","profileImageUrl","branchName","adoptOrgId",{"_43":44,"_32":45,"_38":226,"_47":-5,"_48":25,"_49":50,"_51":50,"_52":53,"_54":-5,"_18":55,"_56":31,"_57":58,"_59":-5,"_60":-5,"_61":62,"_63":64,"_65":-5,"_66":-5,"_67":-5,"_68":-5,"_69":70,"_71":70,"_72":73,"_74":73,"_75":73,"_76":70,"_77":70,"_78":227,"_80":228,"_82":229,"_84":25},"tree",[197,198,199,200,201,202,203],"files",[197,198,199,200,201,202,203],"counts",{"_186":62,"_187":188,"_189":62,"_190":191,"_192":193},"contents",[124,125,126,127,128,129,130],"upstreamProject","upstreamBranch","emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},{"_43":179,"_32":180,"_30":181,"_134":-5,"_41":42,"_40":182,"_136":58,"_38":183,"_13":161,"_33":139,"_35":184,"_24":25,"_141":-5,"_27":185},{"_43":171,"_32":172,"_30":173,"_134":-5,"_41":42,"_40":174,"_136":25,"_38":175,"_13":176,"_33":153,"_35":177,"_24":25,"_141":-5,"_27":178},{"_43":164,"_32":165,"_30":166,"_134":-5,"_41":42,"_40":167,"_136":25,"_38":168,"_13":161,"_33":139,"_35":169,"_24":25,"_141":-5,"_27":170},{"_43":156,"_32":157,"_30":158,"_134":-5,"_41":42,"_40":159,"_136":58,"_38":160,"_13":161,"_33":139,"_35":162,"_24":25,"_141":-5,"_27":163},{"_43":147,"_32":148,"_30":149,"_134":-5,"_41":42,"_40":150,"_136":58,"_38":151,"_13":152,"_33":153,"_35":154,"_24":25,"_141":-5,"_27":155},{"_43":143,"_32":28,"_30":31,"_134":-5,"_41":42,"_40":14,"_136":58,"_38":144,"_13":145,"_33":34,"_35":37,"_24":25,"_141":-5,"_27":146},{"_43":131,"_32":132,"_30":133,"_134":-5,"_41":42,"_40":135,"_136":58,"_38":137,"_13":138,"_33":139,"_35":140,"_24":25,"_141":-5,"_27":142},"11970ade-c283-41e2-b474-3a8d0d8ddfa0","surface.ts","617831aa-9e72-11f1-b3ff-1607ee4eb77e","parentId",34,"latest",["D",1787435129713],3,"script","/**\n * surface.ts — the implied volatility surface layer.\n *\n * This is the module that makes the tool use IV WALLS proper, not just gamma\n * walls. Three outputs, in increasing order of ambition:\n *\n * 1. A smooth arbitrage-checked smile -> clean per-strike IV for gamma\n * 2. Curvature residuals -> IV WALLS (the actual signal)\n * 3. Risk-neutral density + local vol -> the market's own distribution\n *\n * The key economic point: gamma walls are built from OPEN INTEREST, which is\n * positioning, which is backward-looking and updates after clearing. IV walls\n * are built from PRICES, which are forward-looking and update every quote.\n * When they disagree, that disagreement is information.\n *\n * Zero dependencies. Pure. Same replay guarantees as the rest of the engine.\n */\n\n// ---------------------------------------------------------------------------\n// SVI\n// ---------------------------------------------------------------------------\n\n/**\n * Raw SVI (Gatheral) in total implied variance:\n *\n * w(k) = a + b * ( rho*(k - m) + sqrt( (k-m)^2 + sig^2 ) )\n *\n * where w = iv^2 * tau and k = ln(K / F).\n */\nexport interface SviParams {\n a: number;\n b: number;\n rho: number;\n m: number;\n sig: number;\n tau: number;\n /** Root-mean-square fit error in vol points. */\n rmse: number;\n /** True if Gatheral's butterfly condition g(k) >= 0 holds across the fit. */\n arbFree: boolean;\n nPoints: number;\n}\n\nexport function sviTotalVar(p: SviParams, k: number): number {\n const km = k - p.m;\n return p.a + p.b * (p.rho * km + Math.sqrt(km * km + p.sig * p.sig));\n}\n\nexport function sviIv(p: SviParams, k: number): number {\n const w = sviTotalVar(p, k);\n return w > 0 && p.tau > 0 ? Math.sqrt(w / p.tau) : 0;\n}\n\n/** dw/dk */\nexport function sviDw(p: SviParams, k: number): number {\n const km = k - p.m;\n return p.b * (p.rho + km / Math.sqrt(km * km + p.sig * p.sig));\n}\n\n/** d2w/dk2 */\nexport function sviD2w(p: SviParams, k: number): number {\n const km = k - p.m;\n const r = Math.sqrt(km * km + p.sig * p.sig);\n return (p.b * p.sig * p.sig) / (r * r * r);\n}\n\nexport interface SmilePoint {\n /** log-moneyness ln(K/F) */\n k: number;\n /** market implied vol */\n iv: number;\n /** weight — use open interest or 1/spread. Down-weights junk quotes. */\n weight: number;\n strike: number;\n}\n\n/**\n * Fit raw SVI by exploiting the fact that for FIXED (m, sig) the model is\n * LINEAR in (a, b*rho, b):\n *\n * w = a + c1 * (k-m) + c2 * sqrt((k-m)^2 + sig^2), c1 = b*rho, c2 = b\n *\n * So we grid over the two nonlinear parameters and solve a weighted 3x3\n * normal-equation system at each node. Deterministic, no optimiser, no\n * random restarts — which matters because the whole engine must replay\n * identically on historical snapshots.\n */\nexport function fitSvi(points: SmilePoint[], tau: number): SviParams | null {\n const pts = points.filter(\n (p) => Number.isFinite(p.k) && p.iv > 0.001 && p.iv < 5 && p.weight > 0,\n );\n if (pts.length < 6 || tau <= 0) return null;\n\n const ks = pts.map((p) => p.k);\n const kMin = Math.min(...ks);\n const kMax = Math.max(...ks);\n const kRange = Math.max(1e-4, kMax - kMin);\n\n let best: SviParams | null = null;\n let bestSse = Infinity;\n\n const M_STEPS = 24;\n const S_STEPS = 18;\n\n for (let mi = 0; mi <= M_STEPS; mi++) {\n const m = kMin - 0.25 * kRange + (1.5 * kRange * mi) / M_STEPS;\n for (let si = 1; si <= S_STEPS; si++) {\n const sig = (kRange * si) / S_STEPS * 1.2;\n\n // Weighted normal equations for [a, c1, c2].\n const A = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];\n const rhs = [0, 0, 0];\n\n for (const p of pts) {\n const km = p.k - m;\n const basis = [1, km, Math.sqrt(km * km + sig * sig)];\n const w = p.iv * p.iv * tau;\n const wt = p.weight;\n for (let i = 0; i < 3; i++) {\n for (let j = 0; j < 3; j++) A[i][j] += wt * basis[i] * basis[j];\n rhs[i] += wt * basis[i] * w;\n }\n }\n\n const sol = solve3x3(A, rhs);\n if (!sol) continue;\n const [a, c1, c2] = sol;\n\n const b = c2;\n if (!(b > 0)) continue;\n const rho = c1 / b;\n if (!(Math.abs(rho) < 0.999)) continue;\n // No-arbitrage necessary condition: a + b*sig*sqrt(1-rho^2) >= 0\n if (a + b * sig * Math.sqrt(1 - rho * rho) < 0) continue;\n\n const cand: SviParams = {\n a,\n b,\n rho,\n m,\n sig,\n tau,\n rmse: 0,\n arbFree: true,\n nPoints: pts.length,\n };\n\n let sse = 0;\n let wsum = 0;\n let ok = true;\n for (const p of pts) {\n const wModel = sviTotalVar(cand, p.k);\n if (wModel <= 0) {\n ok = false;\n break;\n }\n const ivModel = Math.sqrt(wModel / tau);\n const e = ivModel - p.iv;\n sse += p.weight * e * e;\n wsum += p.weight;\n }\n if (!ok || wsum <= 0) continue;\n\n if (sse / wsum < bestSse) {\n bestSse = sse / wsum;\n cand.rmse = Math.sqrt(sse / wsum);\n best = cand;\n }\n }\n }\n\n if (best) best.arbFree = checkButterfly(best, kMin, kMax);\n return best;\n}\n\nfunction solve3x3(A: number[][], b: number[]): [number, number, number] | null {\n const M = [\n [A[0][0], A[0][1], A[0][2], b[0]],\n [A[1][0], A[1][1], A[1][2], b[1]],\n [A[2][0], A[2][1], A[2][2], b[2]],\n ];\n for (let col = 0; col < 3; col++) {\n let piv = col;\n for (let r = col + 1; r < 3; r++) {\n if (Math.abs(M[r][col]) > Math.abs(M[piv][col])) piv = r;\n }\n if (Math.abs(M[piv][col]) < 1e-14) return null;\n [M[col], M[piv]] = [M[piv], M[col]];\n for (let r = 0; r < 3; r++) {\n if (r === col) continue;\n const f = M[r][col] / M[col][col];\n for (let c = col; c < 4; c++) M[r][c] -= f * M[col][c];\n }\n }\n return [M[0][3] / M[0][0], M[1][3] / M[1][1], M[2][3] / M[2][2]];\n}\n\n/**\n * Gatheral's g function. g(k) >= 0 for all k is equivalent to the absence of\n * butterfly arbitrage, i.e. a non-negative risk-neutral density.\n *\n * g(k) = (1 - k*w'/(2w))^2 - (w'^2/4)(1/w + 1/4) + w''/2\n */\nexport function gatheralG(p: SviParams, k: number): number {\n const w = sviTotalVar(p, k);\n if (w <= 0) return -1;\n const dw = sviDw(p, k);\n const d2w = sviD2w(p, k);\n const t1 = Math.pow(1 - (k * dw) / (2 * w), 2);\n const t2 = ((dw * dw) / 4) * (1 / w + 0.25);\n return t1 - t2 + d2w / 2;\n}\n\nfunction checkButterfly(p: SviParams, kMin: number, kMax: number): boolean {\n for (let i = 0; i <= 40; i++) {\n const k = kMin + ((kMax - kMin) * i) / 40;\n if (gatheralG(p, k) < -1e-6) return false;\n }\n return true;\n}\n\n// ---------------------------------------------------------------------------\n// IV WALLS — curvature residual detection\n// ---------------------------------------------------------------------------\n\nexport interface IvWall {\n strike: number;\n /** Log-moneyness. */\n k: number;\n /** market IV minus fitted IV, in vol points. */\n residual: number;\n /** Second difference of the residual across neighbouring strikes. */\n curvature: number;\n /** Robust z-score of curvature vs the rest of the smile. */\n z: number;\n /**\n * vol_premium = market pays UP for vol here vs the smooth smile.\n * It is pricing a discontinuity: barrier / breakout candidate.\n * vol_discount = market pays DOWN for vol here.\n * It is pricing suppression: pin / magnet candidate.\n */\n kind: \"vol_premium\" | \"vol_discount\";\n}\n\n/**\n * An IV wall is a LOCAL CONVEXITY ANOMALY in the smile — a strike where the\n * market's own price is paying for a discontinuity that the smooth model does\n * not explain.\n *\n * Why the RESIDUAL and not the raw smile: the raw smile is convex everywhere\n * (that is just skew). What carries information is convexity the fitted model\n * fails to reproduce. Detrending against SVI is what turns \"there is a smile\"\n * into \"there is something HERE\".\n *\n * TWO gates, both required:\n *\n * 1. Statistical — robust z-score of curvature (MAD-based, because a few\n * genuine walls would inflate a standard deviation and hide themselves).\n * 2. ECONOMIC — an absolute floor on |residual| in vol points.\n *\n * Gate 2 exists because gate 1 alone is scale-free and therefore dangerous.\n * On a clean smile the residuals are float noise, the MAD collapses toward\n * zero, and dividing by it manufactures z-scores in the thousands out of\n * rounding error. Measured: 10 false positives on a synthetic clean smile.\n * A detector that fires on clean data is a noise generator. The absolute\n * floor is what makes \"no walls today\" an output the engine can actually\n * produce — and being able to say nothing is the point.\n */\nexport function detectIvWalls(\n points: SmilePoint[],\n fit: SviParams,\n zThreshold = 2.0,\n /** Minimum |residual| in vol points to qualify. 0.0015 = 0.15 vol pts. */\n minResidual = 0.0015,\n): IvWall[] {\n const sorted = [...points]\n .filter((p) => p.iv > 0.001 && p.weight > 0)\n .sort((a, b) => a.k - b.k);\n if (sorted.length < 7) return [];\n\n const resid = sorted.map((p) => p.iv - sviIv(fit, p.k));\n\n // Second difference on a possibly non-uniform k grid.\n const curv: number[] = new Array(sorted.length).fill(0);\n for (let i = 1; i < sorted.length - 1; i++) {\n const hL = sorted[i].k - sorted[i - 1].k;\n const hR = sorted[i + 1].k - sorted[i].k;\n if (hL <= 0 || hR <= 0) continue;\n curv[i] =\n (2 * (hR * resid[i - 1] - (hL + hR) * resid[i] + hL * resid[i + 1])) /\n (hL * hR * (hL + hR));\n }\n\n const interior = curv.slice(1, -1).filter((c) =>\n Number.isFinite(c) && c !== 0\n );\n if (interior.length < 5) return [];\n\n const med = median(interior);\n const mad = median(interior.map((c) => Math.abs(c - med)));\n\n // Floor the scale at the curvature a minResidual-sized kink would produce\n // over typical strike spacing. Below this, z-scores are meaningless.\n const typicalH = (sorted[sorted.length - 1].k - sorted[0].k) /\n (sorted.length - 1);\n const curvFloor = minResidual / Math.max(1e-9, typicalH * typicalH);\n const scale = Math.max(1.4826 * mad, curvFloor * 0.15);\n\n const walls: IvWall[] = [];\n for (let i = 1; i < sorted.length - 1; i++) {\n if (!Number.isFinite(curv[i]) || curv[i] === 0) continue;\n // Gate 2: economic significance, checked first because it is cheap.\n if (Math.abs(resid[i]) < minResidual) continue;\n // Clamp for reporting sanity. On a very clean smile the MAD collapses and\n // the raw z runs to hundreds, which looks like a stronger signal than it\n // is. The RESIDUAL is the number with economic meaning; z is only a\n // relative-to-local-noise check, so a saturated z is capped rather than\n // shown. Results are sorted by residual for exactly this reason.\n const zRaw = (curv[i] - med) / scale;\n if (Math.abs(zRaw) < zThreshold) continue;\n const z = Math.max(-50, Math.min(50, zRaw));\n walls.push({\n strike: sorted[i].strike,\n k: sorted[i].k,\n residual: resid[i],\n curvature: curv[i],\n z,\n // Classified by residual SIGN, not curvature sign. A local IV spike is a\n // peak in the residual and therefore has NEGATIVE second difference —\n // labelling off curvature would invert the economic meaning.\n kind: resid[i] > 0 ? \"vol_premium\" : \"vol_discount\",\n });\n }\n return walls.sort((a, b) => Math.abs(b.residual) - Math.abs(a.residual));\n}\n\nfunction median(xs: number[]): number {\n if (!xs.length) return 0;\n const s = [...xs].sort((a, b) => a - b);\n const h = Math.floor(s.length / 2);\n return s.length % 2 ? s[h] : 0.5 * (s[h - 1] + s[h]);\n}\n\n// ---------------------------------------------------------------------------\n// Risk-neutral density (Breeden-Litzenberger, via SVI)\n// ---------------------------------------------------------------------------\n\n/**\n * The RND is the market's OWN probability distribution over terminal price.\n * The engine's PDE independently produces a terminal distribution. Comparing\n * them is free validation that costs no extra data.\n *\n * Under SVI the density in log-moneyness is:\n * p(k) = g(k) / sqrt(2*pi*w(k)) * exp( -d2(k)^2 / 2 )\n * d2 = -k/sqrt(w) - sqrt(w)/2\n */\nexport function riskNeutralDensity(\n p: SviParams,\n kGrid: number[],\n): { k: number; density: number }[] {\n return kGrid.map((k) => {\n const w = sviTotalVar(p, k);\n if (w <= 0) return { k, density: 0 };\n const d2 = -k / Math.sqrt(w) - Math.sqrt(w) / 2;\n const g = Math.max(0, gatheralG(p, k));\n return {\n k,\n density: (g / Math.sqrt(2 * Math.PI * w)) * Math.exp(-0.5 * d2 * d2),\n };\n });\n}\n\n// ---------------------------------------------------------------------------\n// Local volatility\n// ---------------------------------------------------------------------------\n\n/**\n * Dupire local vol from the SVI surface.\n *\n * sigma_loc^2 = (dw/dT) / [ 1 - (k/w) dw/dk + 0.25(-0.25 - 1/w + k^2/w^2)(dw/dk)^2 + 0.5 d2w/dk2 ]\n *\n * IMPORTANT LIMITATION, stated plainly: dw/dT requires at least TWO expiries.\n * With a single expiry it cannot be computed and this returns null. The caller\n * must then fall back to the smile proxy below.\n *\n * This matters for the engine design: if two expiries are available, sigma_eff\n * can be READ OFF THE SURFACE instead of being fitted, which removes\n * lambda_sigma as a free parameter entirely. Fewer knobs is less overfitting.\n */\nexport function dupireLocalVol(\n near: SviParams,\n far: SviParams,\n k: number,\n): number | null {\n if (far.tau <= near.tau) return null;\n const wNear = sviTotalVar(near, k);\n const wFar = sviTotalVar(far, k);\n const dwdT = (wFar - wNear) / (far.tau - near.tau);\n if (!(dwdT > 0)) return null; // calendar arbitrage; refuse rather than fabricate\n\n const w = wNear;\n if (w <= 0) return null;\n const dw = sviDw(near, k);\n const d2w = sviD2w(near, k);\n\n const denom = 1 -\n (k / w) * dw +\n 0.25 * (-0.25 - 1 / w + (k * k) / (w * w)) * dw * dw +\n 0.5 * d2w;\n\n if (!(denom > 1e-8)) return null;\n const v2 = dwdT / denom;\n return v2 > 0 ? Math.sqrt(v2) : null;\n}\n\n/**\n * Single-expiry fallback: the smile evaluated at the log-moneyness the price\n * would have if it moved there. This is NOT Dupire local vol and should not be\n * called that — it is a proxy that captures the right qualitative shape\n * (higher vol where the market prices higher vol) without the term-structure\n * term. Honest naming prevents it being trusted more than it deserves.\n */\nexport function smileVolProxy(p: SviParams, k: number): number {\n return sviIv(p, k);\n}","label",[132],"0778450b-9c9c-4d39-a2d1-1445a5ef4e45",["D",1787481627838],13,[28],"2fde5d06-aae8-4bd0-9f77-c96ef12e225e","recorder.ts","9694b27e-9e44-11f1-90c3-1607ee4eb77e",18,["D",1787415993679],7,"interval","/**\n * recorder.ts — Val.town scheduled snapshot recorder.\n *\n * PURPOSE: every day this does not run is a day of calibration data you cannot\n * buy back cheaply. Historical intraday chain snapshots are expensive or simply\n * unavailable at retail pricing. Recording your own from a free delayed source\n * costs nothing and starts the clock immediately.\n *\n * LICENSING: this deliberately uses DELAYED data (>=15 min) and stores only\n * what is needed to reconstruct the gamma field. OPRA charges no display or\n * non-display fees on data delayed 15 minutes or more. The derived levels the\n * engine ultimately publishes cannot be reverse-engineered back into a chain,\n * which is the standard test derived-data clauses apply.\n *\n * DEPLOY: paste into a Val.town Val, set type to \"Cron\", schedule below.\n *\n * Recommended cron (UTC, covers the RTH session at 4 points):\n * 35 14,16,18,19 * * 1-5\n * These UTC hours fall inside RTH in BOTH regimes:\n * EDT (UTC-4): 10:35, 12:35, 14:35, 15:35 ET\n * EST (UTC-5): 09:35, 11:35, 13:35, 14:35 ET\n * so no seasonal edit is needed when the US changes clocks.\n *\n * STATUS: the CBOE adapter reached the live endpoint successfully on first\n * run (both QQQ and NDX fetched, parsed, narrowed and written to blob). The\n * only failure was in the index bookkeeping below, now fixed.\n */\n\n// SCOPED blob storage (per-val, Amazon S3). Note the /main.ts suffix - that is\n// what selects scoped over the older global (account-wide, Cloudflare R2)\n// store at \"https://esm.town/v/std/blob\". They are DIFFERENT stores: anything\n// written via the global import will not appear in this val's blob panel.\nimport { blob } from \"https://esm.town/v/std/blob/main.ts\";\nimport {\n gzip,\n type RecordedQuote,\n type Snapshot,\n toColumnar,\n} from \"./codec.ts\";\n\n// ---------------------------------------------------------------------------\n// Config\n// ---------------------------------------------------------------------------\n\nconst SYMBOLS = [\n { key: \"QQQ\", cboe: \"QQQ\" },\n { key: \"NDX\", cboe: \"_NDX\" }, // CBOE prefixes index symbols with underscore\n];\n\n/** Keep strikes within this many percent of spot. Far strikes carry ~0 gamma. */\nconst STRIKE_WINDOW_PCT = 0.08;\n\n/** Keep this many nearest expiries. 0DTE + next two is plenty. */\nconst MAX_EXPIRIES = 3;\n\n/**\n * Delete snapshots older than this.\n *\n * STORAGE BUDGET - this is the binding constraint, not the cron rate:\n * Val Town free plan = 10 MB total\n * Val Town pro plan = 1024 MB total\n *\n * Uncompressed, one capture round is ~115 KB across both symbols, so 4 runs a\n * day is ~460 KB/day and the FREE TIER FILLS IN ABOUT THREE WEEKS. With\n * columnar layout + gzip below, a round drops to roughly 12-18 KB, so:\n * free tier ~= 5-7 months of history\n * pro tier ~= many years\n *\n * If you stay on free, drop RETAIN_DAYS to ~150 or move to 2 runs/day.\n */\nconst RETAIN_DAYS = 200;\n\n/**\n * Which scheduled run does the retention sweep. MUST be one of the UTC hours\n * in your cron expression or the sweep silently never runs.\n * Cron: 35 14,16,18,19 * * 1-5\n */\nconst RETENTION_SWEEP_UTC_HOUR = 14;\n\n// ---------------------------------------------------------------------------\n// CBOE delayed-quote adapter\n// ---------------------------------------------------------------------------\n\n/**\n * CBOE publishes a free delayed chain as a single JSON document per symbol.\n * Option symbols are OCC-format: ROOT + YYMMDD + C|P + strike*1000 padded to 8.\n */\nfunction parseOccSymbol(\n occ: string,\n): { expiry: string; right: \"C\" | \"P\"; strike: number } | null {\n const m = occ.match(/^([A-Z_]+)(\\d{6})([CP])(\\d{8})$/);\n if (!m) return null;\n const [, , ymd, right, strikeRaw] = m;\n const yy = ymd.slice(0, 2);\n const expiry = `20${yy}-${ymd.slice(2, 4)}-${ymd.slice(4, 6)}`;\n return {\n expiry,\n right: right as \"C\" | \"P\",\n strike: parseInt(strikeRaw, 10) / 1000,\n };\n}\n\nasync function fetchCboe(\n cboeSym: string,\n): Promise<{ spot: number; rows: RecordedQuote[] }> {\n const url =\n `https://cdn.cboe.com/api/global/delayed_quotes/options/${cboeSym}.json`;\n const res = await fetch(url, {\n headers: { \"User-Agent\": \"Mozilla/5.0\", Accept: \"application/json\" },\n });\n if (!res.ok) throw new Error(`CBOE ${cboeSym} HTTP ${res.status}`);\n const j: any = await res.json();\n\n const spot = Number(j?.data?.current_price ?? j?.data?.close);\n if (!(spot > 0)) throw new Error(`CBOE ${cboeSym}: no usable spot`);\n\n const raw: any[] = j?.data?.options ?? [];\n const rows: RecordedQuote[] = [];\n for (const o of raw) {\n const p = parseOccSymbol(String(o.option ?? \"\"));\n if (!p) continue;\n rows.push({\n s: p.strike,\n r: p.right,\n e: p.expiry,\n iv: Number(o.iv ?? 0),\n oi: Number(o.open_interest ?? 0),\n v: Number(o.volume ?? 0),\n b: Number(o.bid ?? 0),\n a: Number(o.ask ?? 0),\n });\n }\n return { spot, rows };\n}\n\n// ---------------------------------------------------------------------------\n// Narrowing\n// ---------------------------------------------------------------------------\n\n/**\n * Narrow hard. A full QQQ chain is ~15k contracts; within +/-8% of spot on the\n * three nearest expiries it is a few hundred. Strikes far from spot contribute\n * essentially zero gamma, so nothing of value is lost and blob storage stays\n * comfortably inside the free tier.\n */\nfunction narrow(\n rows: RecordedQuote[],\n spot: number,\n asof: Date,\n): { kept: RecordedQuote[]; expiries: string[]; droppedExpired: number } {\n const lo = spot * (1 - STRIKE_WINDOW_PCT);\n const hi = spot * (1 + STRIKE_WINDOW_PCT);\n\n // Drop expiries that have already passed. CBOE's delayed feed still lists\n // them after the close, and a dead expiry silently eats one of the\n // MAX_EXPIRIES slots while contributing nothing (tau <= 0 => zero gamma).\n const today = asof.toISOString().slice(0, 10);\n const allExpiries = [...new Set(rows.map((r) => r.e))].sort();\n const live = allExpiries.filter((e) => e >= today);\n const droppedExpired = allExpiries.length - live.length;\n\n const expiries = live.slice(0, MAX_EXPIRIES);\n const keepExp = new Set(expiries);\n\n const kept = rows.filter(\n (r) => keepExp.has(r.e) && r.s >= lo && r.s <= hi && r.oi > 0 && r.iv > 0,\n );\n return { kept, expiries, droppedExpired };\n}\n\n// ---------------------------------------------------------------------------\n// Main\n// ---------------------------------------------------------------------------\n\nexport default async function record(): Promise {\n const started = Date.now();\n const now = new Date();\n const stamp = now.toISOString().replace(/[:.]/g, \"-\");\n const results: any[] = [];\n\n for (const sym of SYMBOLS) {\n const t0 = Date.now();\n try {\n const { spot, rows } = await fetchCboe(sym.cboe);\n const { kept, expiries, droppedExpired } = narrow(rows, spot, now);\n\n if (kept.length < 20) {\n results.push({\n sym: sym.key,\n ok: false,\n error: `only ${kept.length} usable contracts`,\n });\n continue;\n }\n\n const snap: Snapshot = {\n sym: sym.key,\n ts: now.toISOString(),\n spot,\n src: \"cboe_delayed\",\n delayed: true,\n v: 2,\n cols: toColumnar(kept, expiries),\n expiries,\n diag: {\n fetched: rows.length,\n kept: kept.length,\n expiries,\n droppedExpired,\n ms: Date.now() - t0,\n },\n };\n\n const raw = JSON.stringify(snap);\n const packed = await gzip(raw);\n await blob.set(`chain_${sym.key}_${stamp}.json.gz`, packed);\n const bytes = packed.byteLength;\n\n // Maintain a lightweight index so the calibration job can enumerate\n // snapshots without listing the whole blob store every time.\n const idxKey = `chainidx_${now.toISOString().slice(0, 10)}`;\n let idx: string[] = [];\n try {\n const existing = await blob.getJSON(idxKey);\n // Val Town's blob.getJSON returns undefined for a missing key rather\n // than throwing, so a bare try/catch never fires and idx stays\n // undefined. Check the shape, don't rely on the catch.\n if (Array.isArray(existing)) idx = existing as string[];\n } catch { /* key does not exist yet - empty index is correct */ }\n idx.push(`chain_${sym.key}_${stamp}.json.gz`);\n await blob.setJSON(idxKey, idx);\n\n results.push({\n sym: sym.key,\n ok: true,\n spot,\n fetched: rows.length,\n kept: kept.length,\n expiries,\n droppedExpired,\n // NAMING MATTERS HERE: `raw` is ALREADY columnar, so raw/bytes measures\n // only the gzip step (~3x), not the total saving. The columnar layout\n // contributes a further ~2.7x on top. Reporting a single \"ratio\" made\n // the pipeline look 3x effective when it is closer to 8x.\n colKb: +(raw.length / 1024).toFixed(1),\n gzKb: +(bytes / 1024).toFixed(1),\n gzipRatio: +(raw.length / bytes).toFixed(1),\n // vs the v1 row-oriented uncompressed format, for comparison against\n // the legacy blobs still sitting in the global store.\n totalRatio: +((kept.length * 92) / bytes).toFixed(1),\n ms: Date.now() - t0,\n });\n } catch (e: any) {\n results.push({ sym: sym.key, ok: false, error: String(e?.message ?? e) });\n }\n }\n\n // Retention sweep, cheap and only once a day.\n if (now.getUTCHours() === RETENTION_SWEEP_UTC_HOUR) {\n try {\n const cutoff = new Date(Date.now() - RETAIN_DAYS * 864e5).toISOString();\n const all = await blob.list(\"chain_\");\n let purged = 0;\n let totalBytes = 0;\n for (const b of all) {\n const m = b.key.match(/chain_[A-Z]+_(\\d{4}-\\d{2}-\\d{2})/);\n if (m && m[1] < cutoff.slice(0, 10)) {\n await blob.delete(b.key);\n purged++;\n } else totalBytes += (b as any).size ?? 0;\n }\n // Surface storage use every day so the 10 MB free ceiling cannot creep up\n // and start failing writes silently mid-calibration.\n results.push({\n retention: {\n purged,\n cutoff: cutoff.slice(0, 10),\n blobsKept: all.length - purged,\n storageMb: +(totalBytes / 1048576).toFixed(2),\n freeTierPct: +((totalBytes / 1048576 / 10) * 100).toFixed(1),\n },\n });\n } catch (e: any) {\n results.push({ retention: { error: String(e?.message ?? e) } });\n }\n }\n\n const summary = {\n ok: results.every((r) => r.ok !== false),\n at: now.toISOString(),\n totalMs: Date.now() - started,\n results,\n };\n\n // Cron ignores the return value, so log it or you will never see it.\n console.log(JSON.stringify(summary, null, 2));\n\n return Response.json(summary, { headers: { \"cache-control\": \"no-store\" } });\n}",[148],"cb090138-a9be-4c9d-8df8-b695c47aa1a4","numerics.ts","570981b0-9e72-11f1-8367-1607ee4eb77e",29,["D",1787434942688],2,"/**\n * numerics.ts — zero-dependency numerical core.\n *\n * Everything here is pure and deterministic. No I/O, no Date.now(), no Math.random().\n * That is deliberate: the whole engine must be replayable against historical\n * snapshots for calibration, and Monte Carlo noise on a probability output\n * destroys downstream calibration.\n */\n\n// ---------------------------------------------------------------------------\n// Normal distribution\n// ---------------------------------------------------------------------------\n\nexport function normPdf(x: number): number {\n return Math.exp(-0.5 * x * x) / Math.sqrt(2 * Math.PI);\n}\n\n/** Abramowitz & Stegun 7.1.26-based erf; ~1.5e-7 absolute accuracy. Plenty. */\nexport function normCdf(x: number): number {\n const sign = x < 0 ? -1 : 1;\n const z = Math.abs(x) / Math.SQRT2;\n const t = 1 / (1 + 0.3275911 * z);\n const y = 1 -\n ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) *\n t +\n 0.254829592) *\n t *\n Math.exp(-z * z);\n return 0.5 * (1 + sign * y);\n}\n\n// ---------------------------------------------------------------------------\n// Black-Scholes\n// ---------------------------------------------------------------------------\n\nexport interface BsInputs {\n S: number; // spot / forward\n K: number; // strike\n tau: number; // time to expiry, YEARS\n sigma: number; // implied vol for THIS strike (not ATM)\n r?: number; // carry rate\n}\n\nexport function d1(i: BsInputs): number {\n const r = i.r ?? 0;\n if (i.tau <= 0 || i.sigma <= 0) return i.S > i.K ? 50 : -50;\n return (\n (Math.log(i.S / i.K) + (r + 0.5 * i.sigma * i.sigma) * i.tau) /\n (i.sigma * Math.sqrt(i.tau))\n );\n}\n\n/** Per-contract gamma: d(delta)/dS. */\nexport function bsGamma(i: BsInputs): number {\n if (i.tau <= 0 || i.sigma <= 0) return 0;\n return normPdf(d1(i)) / (i.S * i.sigma * Math.sqrt(i.tau));\n}\n\n/** Charm for a CALL: d(delta)/d(t). Put charm = callCharm (same magnitude, delta differs by constant). */\nexport function bsCharmCall(i: BsInputs): number {\n if (i.tau <= 0 || i.sigma <= 0) return 0;\n const r = i.r ?? 0;\n const D1 = d1(i);\n const D2 = D1 - i.sigma * Math.sqrt(i.tau);\n return (\n -normPdf(D1) * ((2 * r * i.tau - D2 * i.sigma * Math.sqrt(i.tau)) /\n (2 * i.tau * i.sigma * Math.sqrt(i.tau)))\n );\n}\n\n/** Vanna: d(delta)/d(sigma) = d(vega)/dS. */\nexport function bsVanna(i: BsInputs): number {\n if (i.tau <= 0 || i.sigma <= 0) return 0;\n const D1 = d1(i);\n const D2 = D1 - i.sigma * Math.sqrt(i.tau);\n return (-normPdf(D1) * D2) / i.sigma;\n}\n\n// ---------------------------------------------------------------------------\n// Tridiagonal (Thomas algorithm)\n// ---------------------------------------------------------------------------\n\n/**\n * Solves A x = d where A is tridiagonal with sub a, diag b, super c.\n * Arrays are mutated internally on copies; inputs are not modified.\n */\nexport function thomas(\n a: Float64Array,\n b: Float64Array,\n c: Float64Array,\n d: Float64Array,\n): Float64Array {\n const n = b.length;\n const cp = new Float64Array(n);\n const dp = new Float64Array(n);\n\n cp[0] = c[0] / b[0];\n dp[0] = d[0] / b[0];\n for (let i = 1; i < n; i++) {\n const m = b[i] - a[i] * cp[i - 1];\n cp[i] = c[i] / m;\n dp[i] = (d[i] - a[i] * dp[i - 1]) / m;\n }\n\n const x = new Float64Array(n);\n x[n - 1] = dp[n - 1];\n for (let i = n - 2; i >= 0; i--) x[i] = dp[i] - cp[i] * x[i + 1];\n return x;\n}\n\n// ---------------------------------------------------------------------------\n// First-passage PDE\n// ---------------------------------------------------------------------------\n\nexport interface FirstPassageSpec {\n /** Log-price grid, ascending, uniform spacing. x = ln(S/S_ref). */\n x: Float64Array;\n /** Index into x of the current spot. */\n spotIdx: number;\n /** drift(x, tIdx) in log space, per unit of clock time. */\n drift: (x: number, tIdx: number) => number;\n /** volatility(x, tIdx) in log space, per sqrt(unit clock time). */\n vol: (x: number, tIdx: number) => number;\n /** Number of backward time steps. */\n nSteps: number;\n /** Total remaining clock time (same units as drift/vol). */\n tau: number;\n /** Barrier index in x. Absorbing. */\n barrierIdx: number;\n /** true = barrier is above spot (upper), false = below. */\n upper: boolean;\n}\n\n/**\n * Backward Kolmogorov for u(x,t) = P(hit barrier before T | X_t = x).\n *\n * du/dt + mu(x) du/dx + 0.5 sigma^2(x) d2u/dx2 = 0, u(barrier,.) = 1, u(x,T) = 0\n *\n * Crank-Nicolson in time, central differences in space, Thomas solve per step.\n * Returns P(touch before T) evaluated at the spot node.\n */\nexport function firstPassageProb(s: FirstPassageSpec): number {\n const { x, drift, vol, nSteps, tau, barrierIdx, upper, spotIdx } = s;\n\n // Restrict the domain to the side of the barrier the spot lives on.\n const lo = upper ? 0 : barrierIdx;\n const hi = upper ? barrierIdx : x.length - 1;\n const n = hi - lo + 1;\n if (n < 4) {\n return upper\n ? (spotIdx >= barrierIdx ? 1 : 0)\n : (spotIdx <= barrierIdx ? 1 : 0);\n }\n\n const dx = x[1] - x[0];\n const dt = tau / nSteps;\n\n let u = new Float64Array(n); // terminal condition: 0 everywhere except barrier\n const bIdxLocal = upper ? n - 1 : 0;\n u[bIdxLocal] = 1;\n\n const a = new Float64Array(n);\n const b = new Float64Array(n);\n const c = new Float64Array(n);\n const d = new Float64Array(n);\n\n for (let step = nSteps - 1; step >= 0; step--) {\n for (let i = 0; i < n; i++) {\n const gi = i + lo;\n\n // Dirichlet at the absorbing barrier.\n if (i === bIdxLocal) {\n a[i] = 0;\n b[i] = 1;\n c[i] = 0;\n d[i] = 1;\n continue;\n }\n // Far boundary: absorbing at 0 (probability of reaching the barrier from\n // very far away in the remaining time is negligible). Cheap and stable.\n if (i === 0 || i === n - 1) {\n a[i] = 0;\n b[i] = 1;\n c[i] = 0;\n d[i] = 0;\n continue;\n }\n\n const mu = drift(x[gi], step);\n const sg = vol(x[gi], step);\n const v2 = sg * sg;\n\n const A = (0.5 * v2) / (dx * dx); // diffusion coefficient\n const B = mu / (2 * dx); // convection coefficient\n\n // CN: (I - dt/2 L) u^n = (I + dt/2 L) u^{n+1}\n const lSub = A - B;\n const lDiag = -2 * A;\n const lSup = A + B;\n\n a[i] = -0.5 * dt * lSub;\n b[i] = 1 - 0.5 * dt * lDiag;\n c[i] = -0.5 * dt * lSup;\n\n d[i] = u[i] +\n 0.5 * dt * (lSub * u[i - 1] + lDiag * u[i] + lSup * u[i + 1]);\n }\n\n u = thomas(a, b, c, d);\n\n // Probabilities must stay in [0,1]; CN can overshoot marginally near the\n // barrier on the first steps. Clamp rather than switch to fully implicit,\n // which would cost accuracy everywhere to fix a boundary artefact.\n for (let i = 0; i < n; i++) u[i] = u[i] < 0 ? 0 : u[i] > 1 ? 1 : u[i];\n }\n\n const localSpot = spotIdx - lo;\n if (localSpot < 0) return upper ? 0 : 1;\n if (localSpot > n - 1) return upper ? 1 : 0;\n return u[localSpot];\n}\n\n// ---------------------------------------------------------------------------\n// Layer 0 null model — reflection principle\n// ---------------------------------------------------------------------------\n\n/**\n * P(running max of driftless arithmetic BM reaches b>0 before T).\n * This is the benchmark every layer above must beat out-of-sample.\n */\nexport function reflectionTouchProb(\n b: number,\n sigma: number,\n tau: number,\n): number {\n if (tau <= 0 || sigma <= 0) return b <= 0 ? 1 : 0;\n if (b <= 0) return 1;\n return Math.min(1, 2 * normCdf(-b / (sigma * Math.sqrt(tau))));\n}\n\n/** Expected range of driftless BM: 2*sqrt(2/pi)*sigma*sqrt(tau) (Parkinson). */\nexport function expectedRange(sigma: number, tau: number): number {\n return 2 * Math.sqrt(2 / Math.PI) * sigma * Math.sqrt(tau);\n}",[157],"8b9a4f20-fe27-4777-a16c-ba46df7259d5","levels.ts","4fc39b2a-9e72-11f1-827f-1607ee4eb77e",26,["D",1787434928980],"/**\n * levels.ts — the Phase 0 pure function.\n *\n * computeLevels(chain, market, config) -> LevelSet\n *\n * No I/O. No clock reads. No randomness. Given identical inputs it returns\n * identical output, which is what makes historical replay and calibration\n * possible at all.\n *\n * Design notes that differ from the report, because building it exposed better\n * choices:\n *\n * 1. sigma_eff = sigma0 / (1 + lambda*Ghat) rather than / (1 - lambda*G).\n * The report's form has a pole at lambda*G -> 1. This form is monotone,\n * bounded and needs no ad-hoc clamp to stay physical.\n *\n * 2. Gamma enters BOTH as an OU reversion rate theta(S) AND as a local vol\n * modifier. These are the same mechanism seen from two angles: theta\n * captures the directional pull toward the gamma centroid, sigma_eff\n * captures the reduction in diffusion. Using only one under-reads the\n * effect; the OU-bands framing needs theta, the report's framing needs\n * sigma_eff, and the truth needs both.\n *\n * 3. The ladder is produced by inverting a monotone P(touch) curve rather\n * than by placing bands at fixed sigma multiples. That is what makes the\n * rungs mean what they claim to mean.\n */\n\nimport {\n bsGamma,\n bsVanna,\n expectedRange,\n firstPassageProb,\n reflectionTouchProb,\n} from \"./numerics.ts\";\nimport {\n detectIvWalls,\n dupireLocalVol,\n fitSvi,\n type IvWall,\n type SmilePoint,\n sviIv,\n type SviParams,\n} from \"./surface.ts\";\n\n// ---------------------------------------------------------------------------\n// Inputs\n// ---------------------------------------------------------------------------\n\nexport interface OptionQuote {\n strike: number;\n right: \"C\" | \"P\";\n /** Expiry in YEARS from the snapshot instant. 0DTE at 14:00 ET ~ 0.0008. */\n tau: number;\n /** This strike's own IV. Never substitute ATM IV — it misprices the wings. */\n iv: number;\n openInterest: number;\n /** Change in OI vs prior session close. Used for the cheap sign proxy. */\n deltaOi?: number;\n /** Change in this contract's price vs prior close. Used for the sign proxy. */\n deltaPrice?: number;\n}\n\nexport interface ChainSnapshot {\n /** \"NDX\" | \"QQQ\" | \"NQ\" — used for notional normalisation. */\n symbol: string;\n /** Spot of THIS book's underlying (NDX index, QQQ share price, NQ future). */\n underlying: number;\n /** Contract multiplier: 100 for NDX/QQQ, 20 for NQ. */\n multiplier: number;\n /** Multiply this book's price axis by this to reach NQ points. */\n toNqScale: number;\n /** Additive basis applied AFTER scaling, in NQ points. Carry, not a ratio. */\n toNqBasis: number;\n quotes: OptionQuote[];\n}\n\nexport interface MarketState {\n /** Current NQ price. */\n nqSpot: number;\n /** Session running high in NQ points, or null pre-open. */\n runningHigh: number | null;\n /** Session running low in NQ points, or null pre-open. */\n runningLow: number | null;\n /** Fraction of the RTH session elapsed, 0 = 09:30 ET, 1 = 16:00 ET. */\n sessionFrac: number;\n /** ATM 0DTE implied vol, annualised. Drives the baseline diffusion. */\n atmIv: number;\n /**\n * Optional measured-vol path. When BOTH are supplied, the engine uses\n * forecastSessionSigma() instead of atmIv, because the measured blend\n * out-predicts implied vol for realised session range (13% better OOS RMSE\n * than EWMA alone; IV carries a variance risk premium that biases it high).\n * Units: session log-return sigma, NOT annualised.\n */\n ewmaPastRthRv?: number;\n overnightRv?: number;\n /** JS day-of-week (0=Sun..6=Sat) for the DOW sigma correction. */\n dayOfWeek?: number;\n /**\n * Volatility stress: sigma_exante / rolling_median_sigma - 1, clipped [0,2].\n * Drives calibration shrinkage. 0 if unknown (calibration applied in full).\n */\n stress?: number;\n}\n\nexport interface EngineConfig {\n /** Gamma -> OU reversion coupling. Calibrate; do not assume. */\n lambdaTheta: number;\n /** Gamma -> local vol coupling. Calibrate; do not assume. */\n lambdaSigma: number;\n /** Baseline OU reversion with zero dealer gamma. Usually small. */\n thetaBaseline: number;\n /** Weight on the dOI x dPrice sign proxy vs the structural prior, 0..1. */\n signProxyWeight: number;\n /** Ladder rungs to emit, as P(touch before close). */\n ladderRungs: number[];\n /** Space grid nodes. 241 is ample; cost is linear. */\n gridNodes: number;\n /** Backward time steps. */\n timeSteps: number;\n /** Grid half-width in units of remaining-session sigma. */\n gridWidthSigmas: number;\n /** Isotonic calibration map as (raw, calibrated) knots. Identity if empty. */\n calibration: Array<[number, number]>;\n /** Apply the measured fat-tail correction to touch probabilities. */\n useFatTailAdjust: boolean;\n /**\n * Shrinks the calibration map toward identity as stress rises:\n * w = 1/(1 + k*stress), final = w*calibrated + (1-w)*raw\n * where stress = sigma_exante / rolling_median_sigma - 1, clipped to [0,2].\n * Worth +0.54% OOS Brier over a plain global map. Marginal. Set 0 to disable.\n */\n stressShrinkK: number;\n /** Use the fitted SVI smile for gamma instead of raw quoted IVs. */\n useSviForGamma: boolean;\n /**\n * Use Dupire local vol from the surface for sigma_eff when >=2 expiries are\n * available. When this succeeds, lambdaSigma is NOT used — sigma_eff is READ\n * from the market rather than fitted, removing a free parameter.\n */\n useDupireLocalVol: boolean;\n /** |z| threshold for the IV-wall curvature detector. */\n ivWallZ: number;\n /** Minimum |residual| in vol points for an IV wall. */\n ivWallMinResidual: number;\n}\n\n/**\n * Fat-tail correction, MEASURED on 2,985 NQ sessions.\n *\n * The Gaussian first-passage law materially under-predicts touch at distance.\n * Realised vs an UPPER BOUND on the Gaussian two-sided rate (4*Phi(-z), which\n * over-counts by ignoring the overlap of the two barriers):\n *\n * z=1.5 Gaussian <=26.7% realised 28.2%\n * z=2.0 Gaussian <= 9.1% realised 13.6%\n * z=2.5 Gaussian <= 2.5% realised 6.3%\n * z=3.0 Gaussian <= 0.5% realised 3.2%\n *\n * Realised exceeds even the upper bound from z=2 out, so this is not an\n * artefact of the approximation. It survives switching to a fast EWMA vol\n * estimator, so it is not a slow-estimator artefact either. Excess kurtosis of\n * daily returns is 23.5.\n *\n * Interpretation: genuine jumps. Applied as a distance-dependent inflation of\n * the tail. This is a stopgap - the principled fix is the compound-Poisson\n * jump term, which needs the event calendar to condition intensity on.\n */\nexport function fatTailAdjust(p: number, z: number): number {\n if (!(z > 1.2)) return p;\n const excess = Math.min(0.06, 0.018 * (z - 1.2));\n return Math.min(1, p + excess);\n}\n\n/**\n * MEASURED gamma coupling. Fitted on 1,987 QQQ sessions, 2018-02 to 2026-01,\n * 22,067 forward 30-minute observations.\n *\n * log(rv^2) = a + b*log(expected_var) + TOD fixed effects + d*log(atm_iv)\n * + e*log(prior_rv^2) + c*Ghat\n *\n * c = -0.1044 95% CI [-0.1168, -0.0944]\n *\n * Since rv ~ exp(c*Ghat/2) and sigma_eff = sigma_0/(1 + lambdaSigma*Ghat)\n * ~ sigma_0*exp(-lambdaSigma*Ghat) for small lambda, the mapping is\n * lambdaSigma = -c/2 = 0.052.\n *\n * An OOS sweep on ladder Brier score puts the optimum around 0.10-0.20 - flat\n * across that range, so 0.10 is chosen as the conservative end of the plateau\n * rather than the peak. Note what the sweep says about the demo's illustrative\n * 0.45: it makes the ladder WORSE than no gamma at all (-1.70% OOS). Guessing\n * this parameter would have been actively harmful.\n *\n * HOW MUCH IS IT WORTH: pooled OOS ladder Brier 0.15134 -> 0.15007, about\n * +0.84%. Real, positive in 6 of 7 walk-forward years, and small. Layer 0\n * carries the skill (0.151 vs 0.245 climatology, ~38%); gamma refines it.\n *\n * WHY lambdaTheta STAYS ZERO: a symmetric placebo run on the same panel found\n * gamma predicts PAST variance about twice as strongly as future variance\n * (backward c = -0.208 vs forward -0.105, P(forward stronger) = 0.000). So\n * gamma is predominantly a contemporaneous measure of vol conditions with a\n * real but secondary forecasting component. That supports scaling the\n * DIFFUSION, which is a variance statement. It does not support a directional\n * DRIFT toward the gamma centroid, which would be a much stronger claim than\n * the evidence carries.\n */\nexport const DEFAULT_CONFIG: EngineConfig = {\n lambdaTheta: 0.0, // measured evidence does not support a drift term\n lambdaSigma: 0.10, // MEASURED (see above); demo's 0.45 was illustrative\n thetaBaseline: 0.0,\n signProxyWeight: 0.6,\n ladderRungs: [0.75, 0.55, 0.35, 0.20],\n gridNodes: 241,\n timeSteps: 60,\n gridWidthSigmas: 3.2,\n /**\n * MEASURED isotonic calibration map, P_touch space.\n *\n * Fitted on 47,995 observations across 3,004 NQ sessions (2014-2026), eight\n * intraday checkpoints per session, both sides. Validated under purged\n * walk-forward CV (train on all prior years, test on the next).\n *\n * WHAT IT IS WORTH: pooled OOS Brier 0.1507 raw -> 0.1488 calibrated, about\n * +1.3%. Small. The raw model already scores 0.1507 against a climatology\n * baseline of 0.2391, so the MODEL carries the skill (~37%) and calibration\n * is polish. Do not expect a calibration map to rescue a weak model.\n *\n * PROVISIONAL: these knots were fitted with sigma driven by EWMA realised\n * vol, because that is what 12 years of OHLCV supports. In production sigma\n * comes from 0DTE ATM implied vol, a different input distribution. The map\n * must be refitted once the recorder has accumulated enough chain history.\n * Until then treat this as a sensible prior, not a finished calibration.\n */\n calibration: [\n [0.02, 0.0],\n [0.08, 0.087],\n [0.14, 0.132],\n [0.2, 0.171],\n [0.26, 0.222],\n [0.32, 0.254],\n [0.38, 0.32],\n [0.44, 0.343],\n [0.5, 0.403],\n [0.56, 0.462],\n [0.62, 0.543],\n [0.68, 0.624],\n [0.74, 0.663],\n [0.8, 0.728],\n [0.86, 0.84],\n [0.92, 0.913],\n [0.98, 0.988],\n ],\n useFatTailAdjust: true,\n stressShrinkK: 1.0,\n useSviForGamma: true,\n useDupireLocalVol: true,\n ivWallZ: 2.0,\n ivWallMinResidual: 0.0015,\n};\n\n// ---------------------------------------------------------------------------\n// Outputs\n// ---------------------------------------------------------------------------\n\nexport type Regime = \"suppressive\" | \"neutral\" | \"amplifying\";\nexport type Stance = \"fade\" | \"extreme_in\" | \"breakout\";\n\nexport interface Level {\n nq: number;\n side: \"upper\" | \"lower\";\n /** The rung this level represents. */\n rung: number;\n pTouch: number;\n pTouchNull: number;\n /** Distance in units of remaining-session sigma. All thresholds live here. */\n z: number;\n /** Nearest gamma wall within half a rung spacing, if any. */\n nearestWall: Wall | null;\n /** Nearest IV wall within half a rung spacing, if any. */\n nearestIvWall: IvWallNq | null;\n stanceWeights: Record;\n}\n\nexport interface Wall {\n nq: number;\n /** Dealer $gamma per 1% move, in NQ-point-normalised units. */\n gammaNotional: number;\n /** Positive = dealers long gamma here (suppressive). */\n sign: number;\n /** 0..1 confidence in the sign inference. */\n signConfidence: number;\n source: string;\n}\n\n/** An IV wall mapped onto the NQ price axis. */\nexport interface IvWallNq {\n nq: number;\n book: string;\n expiry: number;\n residual: number;\n z: number;\n kind: \"vol_premium\" | \"vol_discount\";\n}\n\nexport interface LevelSet {\n asofSessionFrac: number;\n nqSpot: number;\n /** Remaining-session sigma in NQ points. The unit everything is measured in. */\n sessionSigmaNq: number;\n expectedRangeNq: number;\n regime: {\n state: Regime;\n /** tanh-squashed. SATURATES at +/-1: see gammaSaturated. */\n netGammaNormalised: number;\n /**\n * True when |netGammaNormalised| > 0.99, i.e. the tanh has saturated and\n * the normalised value has stopped carrying magnitude information. The\n * regime call is still valid (the sign is right) but the depth proxy needs\n * rescaling before lambdaTheta can be calibrated meaningfully.\n */\n gammaSaturated: boolean;\n /** Raw net dealer $gamma per 1% move at spot, pre-normalisation. */\n netGammaRaw: number;\n hhi: number;\n gammaCentroidNq: number | null;\n };\n running: {\n pHighSurvives: number | null;\n pLowSurvives: number | null;\n pHighSurvivesNull: number | null;\n pLowSurvivesNull: number | null;\n };\n walls: Wall[];\n ivWalls: IvWallNq[];\n /**\n * Where a gamma wall and an IV wall sit on the same price. Gamma walls come\n * from OPEN INTEREST (positioning, backward-looking, updates after clearing);\n * IV walls come from PRICES (forward-looking, updates every quote). Agreement\n * is a strong level. Disagreement is itself information.\n */\n confluence: Array<\n { nq: number; gammaSign: number; ivKind: string; agree: boolean }\n >;\n levels: Level[];\n diagnostics: {\n contractsUsed: number;\n contractsDropped: number;\n booksMerged: string[];\n layer0Only: boolean;\n surfacesFitted: number;\n sviRmse: number | null;\n localVolSource: \"dupire\" | \"lambda_sigma\" | \"none\";\n };\n}\n\n// ---------------------------------------------------------------------------\n// Intraday variance profile\n// ---------------------------------------------------------------------------\n\n/**\n * MEASURED intraday variance profile for NQ RTH.\n *\n * 26 x 15-minute buckets, 08:30-15:00 CT, normalised to mean 1.0.\n * Estimated from 3,005 clean RTH sessions, 2014-01-02 to 2026-01-30,\n * roll-adjusted (Panama) 1-minute bars.\n *\n * This REPLACES a parametric guess that was materially wrong in both\n * directions: it understated the opening bucket by ~40% and overstated the\n * closing hour by ~35%. Since the ladder's width is driven by remaining\n * variance, that guess made the ladder too tight at the open and too wide\n * into the close - errors in opposite directions at the two times of day\n * when levels matter most.\n *\n * Note bucket 18 (13:00-13:15 CT = 14:00-14:15 ET). The local bump is the\n * FOMC statement release imprinting itself on a 12-year average. It is a\n * calendar effect, not a time-of-day effect, and on non-FOMC days it should\n * be suppressed. Left in for now because removing it needs an event calendar.\n */\nexport const EMPIRICAL_VAR_PROFILE = [\n 2.7173,\n 1.9100,\n 1.9269,\n 1.4734,\n 1.3247,\n 1.0526,\n 1.0029,\n 0.8668,\n 0.8311,\n 0.7520,\n 0.7205,\n 0.6339,\n 0.6279,\n 0.5752,\n 0.6522,\n 0.6320,\n 0.6341,\n 0.6046,\n 0.9821,\n 0.7359,\n 0.8010,\n 0.7707,\n 0.8865,\n 0.8171,\n 0.9166,\n 1.1522,\n];\n\n/**\n * Instantaneous variance multiplier at session fraction u, linearly\n * interpolated between bucket centres.\n */\nexport function varianceMultiplier(u: number): number {\n const c = Math.max(0, Math.min(1, u));\n const n = EMPIRICAL_VAR_PROFILE.length;\n const x = c * n - 0.5;\n if (x <= 0) return EMPIRICAL_VAR_PROFILE[0];\n if (x >= n - 1) return EMPIRICAL_VAR_PROFILE[n - 1];\n const i = Math.floor(x);\n const w = x - i;\n return EMPIRICAL_VAR_PROFILE[i] * (1 - w) + EMPIRICAL_VAR_PROFILE[i + 1] * w;\n}\n\n/** Remaining variance fraction of a full session, from u to close. */\nexport function remainingVarianceFraction(u: number, nQuad = 64): number {\n const a = Math.max(0, Math.min(1, u));\n if (a >= 1) return 0;\n let acc = 0;\n const h = (1 - a) / nQuad;\n for (let i = 0; i < nQuad; i++) {\n const m0 = varianceMultiplier(a + i * h);\n const m1 = varianceMultiplier(a + (i + 1) * h);\n acc += 0.5 * (m0 + m1) * h;\n }\n return acc;\n}\n\n// ---------------------------------------------------------------------------\n// Session volatility forecast\n// ---------------------------------------------------------------------------\n\n/**\n * MEASURED session-sigma forecast.\n *\n * Sigma sets the width of every rung, so it is the single highest-leverage\n * input in the engine. Fitted on 3,004 NQ sessions (2014-2026):\n *\n * log(RTH_rv) = -0.030 + 0.509*log(EWMA_past_RTH_rv) + 0.455*log(overnight_rv)\n *\n * in-sample R2 0.711 (EWMA alone) -> 0.788 (+ overnight)\n * OOS RMSE 0.3095 -> 0.2692 (13% better)\n *\n * The overnight session carries almost as much weight as five days of RTH\n * history (0.455 vs 0.509). That is a large effect and it is free - the\n * information is sitting in the Globex tape every morning before the open.\n *\n * NOTE ON IMPLIED VOL: once the recorder has chain history, ATM IV should join\n * this blend and the weights be refitted three-way. IV is forward-looking and\n * should carry real weight, but it also embeds a variance risk premium, so it\n * is a biased estimator of realised vol and cannot simply replace this.\n */\n/**\n * MEASURED day-of-week correction to the sigma forecast. Index 0 = Monday.\n *\n * The blend above is BIASED by weekday, strongly and significantly:\n *\n * Mon x0.9016 (t = -8.28) Thu x1.0365 (t = +3.58)\n * Tue x1.0046 (t = +0.45) Fri x0.9838 (t = -1.58)\n * Wed x1.0688 (t = +6.30)\n *\n * WHY Monday is the big one: the Sunday-evening-to-Monday-morning Globex\n * session carries weekend gap risk, so its realised vol runs ~9% hot. But that\n * excess is largely weekend news being repriced BEFORE the open - it does not\n * carry into Monday's RTH session. The regression applies one uniform weight to\n * overnight vol, so on Mondays it over-forecasts by ~10%.\n *\n * This mattered beyond the sigma itself: uncorrected, it made Monday's\n * normalised range look 7.9% below average, when the raw range is only 3.7%\n * below. Roughly half of an apparent \"quiet Monday\" effect was this bug.\n *\n * Worth +1.92% OOS RMSE on the log-sigma error. Small, but free and unbiased.\n */\nexport const DOW_SIGMA_CORRECTION = [0.9016, 1.0046, 1.0688, 1.0365, 0.9838];\n\nexport function forecastSessionSigma(\n /** EWMA (halflife ~5 sessions) of past RTH realised vol, log-return units. */\n ewmaPastRth: number,\n /** Realised vol of the overnight Globex session just ended, same units. */\n overnightRv: number,\n /** JS day-of-week, 0=Sunday..6=Saturday. Omit to skip the correction. */\n jsDayOfWeek?: number,\n): number {\n let base: number;\n if (!(ewmaPastRth > 0)) base = overnightRv > 0 ? overnightRv : 0;\n else if (!(overnightRv > 0)) base = ewmaPastRth;\n else {base = Math.exp(\n -0.030 + 0.509 * Math.log(ewmaPastRth) + 0.455 * Math.log(overnightRv),\n );}\n\n if (jsDayOfWeek === undefined) return base;\n const i = jsDayOfWeek - 1; // Mon(1) -> 0 ... Fri(5) -> 4\n if (i < 0 || i > 4) return base; // weekend: no correction\n return base * DOW_SIGMA_CORRECTION[i];\n}\n\n/**\n * NEGATIVE RESULT: monthly OPEX gamma is NOT detectable in NQ price data.\n *\n * OPEX is a calendar-determined spike in dealer gamma, so if gamma suppressed\n * excursion we should see it without any options data. Once day-of-week is\n * controlled (OPEX day is always a Friday, so it must be compared to other\n * Fridays), over 3,003 sessions:\n *\n * OPEX day vs other Fridays -3.90% t = -1.20 (not significant)\n * OPEX week Mon-Fri -3.58% t = -1.94 (marginal)\n * week before OPEX -3.54% t = -1.42 (not significant)\n *\n * The sign is right - suppression - but the magnitude is small and the\n * evidence weak. Worse for the thesis, the era split runs BACKWARDS: the\n * effect is largest in 2014-2018 (-8.3%) and smallest in 2022-2026 (-2.9%),\n * the 0DTE era when gamma effects should be strongest. None are significant\n * and the per-era samples are 35-59 sessions, so this is suggestive at best.\n *\n * For calibration: this is a WEAK PRIOR on lambdaTheta. It does not refute the\n * gamma thesis - OPEX gamma is a blunt monthly proxy for a continuous\n * intraday field, and NQ is enormous relative to any options book - but it\n * argues against expecting a large effect. Set expectations accordingly when\n * the chain history arrives.\n */\nexport const OPEX_GAMMA_EFFECT_IS_WEAK = true;\n\n/**\n * NEGATIVE RESULT, recorded so it does not get re-proposed.\n *\n * Overnight high/low are NOT attractors for the RTH extreme. Measured over the\n * same 3,004 sessions, hit rate vs a chance baseline at matched tolerance:\n *\n * tol 0.05 sigma HOD near ON high 7.8% chance 7.4%\n * tol 0.10 sigma 14.9% chance 14.8%\n * tol 0.20 sigma 28.8% chance 29.6%\n *\n * Indistinguishable from chance, and slightly BELOW it at the widest band.\n * Supporting evidence: RTH takes out the overnight high 64.8% of sessions and\n * the overnight low 57.9%, and only 4.0% of sessions stay entirely inside the\n * overnight range. The overnight range contains nothing.\n *\n * The overnight session is therefore useful for its VOLATILITY (above), not\n * for its levels. No ON-high/ON-low levels are emitted.\n */\nexport const OVERNIGHT_LEVELS_ARE_NOT_PREDICTIVE = true;\n\n// ---------------------------------------------------------------------------\n// Sign inference\n// ---------------------------------------------------------------------------\n\n/**\n * Under $100/mo there is no exchange open-close data and no OPRA trade+quote\n * feed, so per-trade side classification is off the table. This is the best\n * available EOD proxy:\n *\n * OI rose AND contract price rose -> customers opened longs -> dealers SHORT\n * OI rose AND contract price fell -> customers opened shorts -> dealers LONG\n * OI fell -> closing; weak signal, decay toward prior\n *\n * Noisy per strike, but it aggregates. Blended with a structural prior that\n * encodes the persistent call-overwriting population (dealers long calls).\n */\nfunction inferDealerSign(\n q: OptionQuote,\n proxyWeight: number,\n): { sign: number; conf: number } {\n // Structural prior: dealers long calls (overwriting supply), short puts\n // (protection demand). This is a prior, not a fact.\n const prior = q.right === \"C\" ? +1 : -1;\n\n if (\n q.deltaOi === undefined || q.deltaPrice === undefined || q.openInterest <= 0\n ) {\n return { sign: prior, conf: 0.3 };\n }\n\n const turnover = Math.min(\n 1,\n Math.abs(q.deltaOi) / Math.max(1, q.openInterest),\n );\n if (q.deltaOi <= 0 || turnover < 0.02) {\n return { sign: prior, conf: 0.3 + 0.2 * turnover };\n }\n\n const proxy = q.deltaPrice > 0 ? -1 : +1; // customer bought -> dealer short\n const blended = proxyWeight * proxy * turnover + (1 - proxyWeight) * prior;\n const sign = blended >= 0 ? +1 : -1;\n const conf = Math.min(0.9, 0.3 + 0.6 * turnover * proxyWeight);\n return { sign, conf };\n}\n\n// ---------------------------------------------------------------------------\n// Gamma field\n// ---------------------------------------------------------------------------\n\n// ---------------------------------------------------------------------------\n// Surface layer\n// ---------------------------------------------------------------------------\n\nexport interface BookSurface {\n book: string;\n expiry: number; // tau in years\n fit: SviParams;\n ivWalls: IvWall[];\n forward: number; // this book's forward for that expiry\n toNqScale: number;\n toNqBasis: number;\n}\n\n/**\n * Fit one SVI smile per (book, expiry) and detect IV walls against it.\n *\n * Weighting by open interest matters: a 2-lot quote at a far strike carries\n * the same IV as a 50,000-lot ATM quote but a fraction of the information.\n * Unweighted fits get dragged around by junk at the wings.\n */\nexport function buildSurfaces(\n books: ChainSnapshot[],\n cfg: EngineConfig,\n): BookSurface[] {\n const out: BookSurface[] = [];\n\n for (const book of books) {\n const byTau = new Map();\n for (const q of book.quotes) {\n if (!(q.tau > 0) || !(q.iv > 0) || !(q.openInterest > 0)) continue;\n const key = Math.round(q.tau * 3650000) / 3650000;\n const arr = byTau.get(key);\n if (arr) arr.push(q);\n else byTau.set(key, [q]);\n }\n\n for (const [tau, quotes] of byTau) {\n const F = book.underlying;\n\n // OTM-only smile: use puts below the forward and calls above. ITM quotes\n // are wide and their IVs are noisy, and including both rights at the same\n // strike double-counts the same information at different quality.\n const pts: SmilePoint[] = [];\n for (const q of quotes) {\n const otm = (q.right === \"P\" && q.strike <= F) ||\n (q.right === \"C\" && q.strike > F);\n if (!otm) continue;\n const k = Math.log(q.strike / F);\n if (!Number.isFinite(k) || Math.abs(k) > 0.30) continue;\n pts.push({\n k,\n iv: q.iv,\n weight: Math.max(1, q.openInterest),\n strike: q.strike,\n });\n }\n if (pts.length < 8) continue;\n\n const fit = fitSvi(pts, tau);\n if (!fit) continue;\n\n out.push({\n book: book.symbol,\n expiry: tau,\n fit,\n ivWalls: detectIvWalls(pts, fit, cfg.ivWallZ, cfg.ivWallMinResidual),\n forward: F,\n toNqScale: book.toNqScale,\n toNqBasis: book.toNqBasis,\n });\n }\n }\n\n return out.sort((a, b) => a.expiry - b.expiry);\n}\n\n/** Look up the fitted IV for a strike, falling back to the quoted value. */\nfunction surfaceIv(\n surfaces: BookSurface[],\n bookSym: string,\n tau: number,\n strike: number,\n forward: number,\n fallback: number,\n): number {\n for (const s of surfaces) {\n if (s.book !== bookSym) continue;\n if (Math.abs(s.expiry - tau) > 1e-9) continue;\n const iv = sviIv(s.fit, Math.log(strike / forward));\n return iv > 0.001 && iv < 5 ? iv : fallback;\n }\n return fallback;\n}\n\ninterface StrikeGamma {\n nq: number;\n signedGammaAt: (nqPrice: number) => number;\n peakNotional: number;\n sign: number;\n signConfidence: number;\n source: string;\n}\n\nfunction buildStrikeGammas(\n books: ChainSnapshot[],\n cfg: EngineConfig,\n surfaces: BookSurface[],\n): { strikes: StrikeGamma[]; used: number; dropped: number } {\n const strikes: StrikeGamma[] = [];\n let used = 0;\n let dropped = 0;\n\n for (const book of books) {\n for (const q of book.quotes) {\n if (!(q.iv > 0) || !(q.tau > 0) || !(q.openInterest > 0)) {\n dropped++;\n continue;\n }\n used++;\n\n const { sign, conf } = inferDealerSign(q, cfg.signProxyWeight);\n const strikeNq = q.strike * book.toNqScale + book.toNqBasis;\n\n // Use the FITTED smile IV, not the raw quote. Quoted IVs are noisy and\n // occasionally absent; the fit smooths them while preserving skew. This\n // is the strike-own-IV requirement done properly rather than by\n // substituting a single ATM number across the chain.\n const ivUse = cfg.useSviForGamma\n ? surfaceIv(\n surfaces,\n book.symbol,\n q.tau,\n q.strike,\n book.underlying,\n q.iv,\n )\n : q.iv;\n\n // Notional normalisation: dollar gamma per 1% move, then expressed on a\n // common NQ-point axis. Raw OI is NOT comparable across these books —\n // an NDX contract carries roughly 41x the notional of a QQQ contract.\n const notionalScale = book.multiplier * q.openInterest * book.toNqScale;\n\n const fn = (nqPrice: number) => {\n const bookSpot = (nqPrice - book.toNqBasis) / book.toNqScale;\n if (!(bookSpot > 0)) return 0;\n const g = bsGamma({\n S: bookSpot,\n K: q.strike,\n tau: q.tau,\n sigma: ivUse,\n });\n // dollar gamma per 1% move\n return sign * g * bookSpot * bookSpot * 0.01 * notionalScale;\n };\n\n const peak = Math.abs(fn(strikeNq));\n\n strikes.push({\n nq: strikeNq,\n signedGammaAt: fn,\n peakNotional: peak,\n sign,\n signConfidence: conf,\n source: `${book.symbol}_${q.right}${q.strike}`,\n });\n }\n }\n\n return { strikes, used, dropped };\n}\n\n// ---------------------------------------------------------------------------\n// Calibration map\n// ---------------------------------------------------------------------------\n\nfunction applyCalibration(p: number, knots: Array<[number, number]>): number {\n if (knots.length < 2) return p;\n if (p <= knots[0][0]) return knots[0][1];\n const last = knots[knots.length - 1];\n if (p >= last[0]) return last[1];\n for (let i = 1; i < knots.length; i++) {\n const [x0, y0] = knots[i - 1];\n const [x1, y1] = knots[i];\n if (p <= x1) {\n const w = (p - x0) / Math.max(1e-12, x1 - x0);\n return y0 + w * (y1 - y0);\n }\n }\n return p;\n}\n\n// ---------------------------------------------------------------------------\n// Stance weighting\n// ---------------------------------------------------------------------------\n\nfunction stanceWeights(\n regime: Regime,\n signConf: number,\n): Record {\n const base: Record> = {\n suppressive: { fade: 0.70, extreme_in: 0.25, breakout: 0.05 },\n neutral: { fade: 0.30, extreme_in: 0.50, breakout: 0.20 },\n // Fade weight is exactly ZERO here, not merely small. Fading a level while\n // dealer hedging amplifies moves is where the drawdowns come from.\n amplifying: { fade: 0.00, extreme_in: 0.30, breakout: 0.70 },\n };\n const w = { ...base[regime] };\n // Low sign confidence pulls everything toward the neutral book.\n const k = Math.max(0, Math.min(1, (signConf - 0.3) / 0.5));\n const n = base.neutral;\n return {\n fade: k * w.fade + (1 - k) * n.fade,\n extreme_in: k * w.extreme_in + (1 - k) * n.extreme_in,\n breakout: k * w.breakout + (1 - k) * n.breakout,\n };\n}\n\n// ---------------------------------------------------------------------------\n// Main entry point\n// ---------------------------------------------------------------------------\n\nexport function computeLevels(\n books: ChainSnapshot[],\n mkt: MarketState,\n cfg: EngineConfig = DEFAULT_CONFIG,\n): LevelSet {\n const S0 = mkt.nqSpot;\n\n // --- remaining-session sigma, variance-time scaled -----------------------\n const SESSION_YEARS = 6.5 / 24 / 365;\n const remFrac = remainingVarianceFraction(mkt.sessionFrac);\n const sessionVarYears = SESSION_YEARS * remFrac;\n // Prefer the measured blend when both realised-vol inputs are present;\n // fall back to implied otherwise.\n const measured =\n mkt.ewmaPastRthRv !== undefined && mkt.overnightRv !== undefined\n ? forecastSessionSigma(mkt.ewmaPastRthRv, mkt.overnightRv, mkt.dayOfWeek)\n : null;\n const sigmaLog = measured !== null\n ? measured * Math.sqrt(Math.max(1e-12, remFrac))\n : mkt.atmIv * Math.sqrt(Math.max(1e-12, sessionVarYears));\n const sessionSigmaNq = sigmaLog * S0;\n\n // --- surface layer -------------------------------------------------------\n const surfaces = buildSurfaces(books, cfg);\n\n // Prefer the INDEX book for the volatility surface: it is the direct\n // underlying, so its smile describes NQ dynamics without a ratio conversion\n // in the middle. Fall back to whichever book fitted the most points.\n const indexSurfaces = surfaces.filter((s) => s.toNqScale === 1);\n const surfPool = indexSurfaces.length >= 2 ? indexSurfaces : surfaces;\n\n // --- gamma field ---------------------------------------------------------\n const { strikes, used, dropped } = buildStrikeGammas(books, cfg, surfaces);\n\n const gammaAt = (nqPrice: number): number => {\n let acc = 0;\n for (const s of strikes) acc += s.signedGammaAt(nqPrice);\n return acc;\n };\n\n const netGammaSpot = gammaAt(S0);\n\n // Normalise gamma to a dimensionless scale so lambda is portable across\n // regimes and notional levels. Scale = median |peak gamma| across strikes\n // within the tradeable window, which is a crude depth proxy. With a real\n // depth measure from the Rithmic book this should be replaced.\n const nearby = strikes\n .filter((s) => Math.abs(s.nq - S0) < 2.0 * sessionSigmaNq)\n .map((s) => s.peakNotional)\n .sort((a, b) => a - b);\n const depthProxy = nearby.length\n ? Math.max(\n 1e-9,\n nearby[Math.floor(nearby.length / 2)] * Math.max(4, nearby.length) * 0.25,\n )\n : 1e-9;\n\n const gHat = (nqPrice: number) => Math.tanh(gammaAt(nqPrice) / depthProxy);\n\n // --- walls ---------------------------------------------------------------\n const wallMap = new Map();\n for (const s of strikes) {\n if (Math.abs(s.nq - S0) > 3.0 * sessionSigmaNq) continue;\n const key = Math.round(s.nq * 4) / 4; // NQ tick\n const prev = wallMap.get(key);\n const contrib = s.sign * s.peakNotional;\n if (prev) {\n prev.gammaNotional += contrib;\n prev.signConfidence = Math.max(prev.signConfidence, s.signConfidence);\n } else {\n wallMap.set(key, {\n nq: key,\n gammaNotional: contrib,\n sign: s.sign,\n signConfidence: s.signConfidence,\n source: s.source,\n });\n }\n }\n const walls = [...wallMap.values()]\n .map((w) => ({ ...w, sign: w.gammaNotional >= 0 ? 1 : -1 }))\n .sort((a, b) => Math.abs(b.gammaNotional) - Math.abs(a.gammaNotional))\n .slice(0, 12);\n\n // --- IV walls, mapped onto the NQ axis -----------------------------------\n const ivWalls: IvWallNq[] = [];\n for (const surf of surfaces) {\n for (const w of surf.ivWalls) {\n const nq = w.strike * surf.toNqScale + surf.toNqBasis;\n if (Math.abs(nq - S0) > 3.0 * sessionSigmaNq) continue;\n ivWalls.push({\n nq: Math.round(nq * 4) / 4,\n book: surf.book,\n expiry: surf.expiry,\n residual: w.residual,\n z: w.z,\n kind: w.kind,\n });\n }\n }\n ivWalls.sort((a, b) => Math.abs(b.residual) - Math.abs(a.residual));\n\n // --- concentration (HHI) -------------------------------------------------\n const window = strikes.filter((s) =>\n Math.abs(s.nq - S0) < 1.5 * sessionSigmaNq\n );\n const total = window.reduce((a, s) => a + s.peakNotional, 0);\n const hhi = total > 0\n ? window.reduce((a, s) => a + Math.pow(s.peakNotional / total, 2), 0)\n : 0;\n\n // --- gamma centroid: the OU anchor --------------------------------------\n let wsum = 0;\n let wacc = 0;\n for (const s of window) {\n const w = s.peakNotional * (s.sign > 0 ? 1 : 0); // only long-gamma pins\n wsum += w;\n wacc += w * s.nq;\n }\n const gammaCentroid = wsum > 0 ? wacc / wsum : null;\n\n // --- regime --------------------------------------------------------------\n const netGammaNorm = Math.tanh(netGammaSpot / depthProxy);\n let state: Regime;\n if (netGammaNorm > 0.15 && hhi > 0.06) state = \"suppressive\";\n else if (netGammaNorm < -0.15) state = \"amplifying\";\n else state = \"neutral\";\n\n const layer0Only = cfg.lambdaTheta === 0 && cfg.lambdaSigma === 0;\n\n // --- PDE grid ------------------------------------------------------------\n const halfWidth = cfg.gridWidthSigmas * sigmaLog;\n const n = cfg.gridNodes;\n const x = new Float64Array(n);\n for (let i = 0; i < n; i++) x[i] = -halfWidth + (2 * halfWidth * i) / (n - 1);\n const spotIdx = Math.round((n - 1) / 2);\n\n const anchorLog = gammaCentroid !== null ? Math.log(gammaCentroid / S0) : 0;\n const tauClock = 1; // work in normalised session time; vol already carries scale\n\n // PRECOMPUTED FIELDS.\n //\n // The gamma field is a function of price only, so it is constant across time\n // steps and across barrier solves. Evaluating it inside the PDE inner loop\n // costs O(nodes x steps x barriers x strikes) — measured at 15 SECONDS on a\n // 155-contract chain, which would blow any serverless budget. Precomputing\n // on the grid makes it O(nodes x strikes), a ~1000x reduction.\n const gHatGrid = new Float64Array(n);\n const thetaGrid = new Float64Array(n);\n const volScaleGrid = new Float64Array(n);\n for (let i = 0; i < n; i++) {\n const g = layer0Only ? 0 : gHat(S0 * Math.exp(x[i]));\n gHatGrid[i] = g;\n thetaGrid[i] = layer0Only ? 0 : cfg.thetaBaseline + cfg.lambdaTheta * g;\n // Monotone, bounded, no pole. Long gamma (g>0) suppresses diffusion.\n volScaleGrid[i] = layer0Only ? 1 : 1 / (1 + cfg.lambdaSigma * g);\n }\n\n // Time-step vol multipliers also precompute: they depend only on tIdx.\n const timeVolMult = new Float64Array(cfg.timeSteps + 1);\n for (let s = 0; s <= cfg.timeSteps; s++) {\n const u = mkt.sessionFrac + (1 - mkt.sessionFrac) * (s / cfg.timeSteps);\n const instVar = varianceMultiplier(u) / Math.max(1e-9, remFrac);\n timeVolMult[s] = Math.sqrt(Math.max(1e-9, instVar));\n }\n\n // Dupire local vol, if the surface supports it. When this works, sigma_eff\n // is READ FROM THE MARKET rather than fitted, and lambdaSigma goes unused.\n // One fewer free parameter is one fewer thing to overfit.\n let localVolSource: \"dupire\" | \"lambda_sigma\" | \"none\" = layer0Only\n ? \"none\"\n : \"lambda_sigma\";\n const dupireGrid = new Float64Array(n);\n if (!layer0Only && cfg.useDupireLocalVol && surfPool.length >= 2) {\n const near = surfPool[0];\n const far = surfPool[1];\n let good = 0;\n for (let i = 0; i < n; i++) {\n const lv = dupireLocalVol(near.fit, far.fit, x[i]);\n if (lv !== null && lv > 0.01 && lv < 3.0) {\n dupireGrid[i] = lv;\n good++;\n }\n }\n // Require most of the grid to resolve. A patchy local vol surface is worse\n // than none: it would silently mix two different vol models across price.\n if (good > 0.8 * n) {\n localVolSource = \"dupire\";\n // Fill any gaps by nearest-neighbour so the PDE sees a continuous field.\n for (let i = 0; i < n; i++) {\n if (dupireGrid[i] > 0) continue;\n let j = i;\n while (j >= 0 && dupireGrid[j] <= 0) j--;\n let k2 = i;\n while (k2 < n && dupireGrid[k2] <= 0) k2++;\n dupireGrid[i] = j >= 0 ? dupireGrid[j] : (k2 < n ? dupireGrid[k2] : 0);\n }\n } else if (!layer0Only) {\n localVolSource = \"lambda_sigma\";\n }\n }\n\n // Dupire returns an ANNUALISED vol; convert to the same remaining-session\n // log-sigma units the rest of the solver works in.\n const dupireScale = new Float64Array(n);\n if (localVolSource === \"dupire\") {\n const atmIdxDup = spotIdx;\n const ref = dupireGrid[atmIdxDup] > 0 ? dupireGrid[atmIdxDup] : mkt.atmIv;\n for (let i = 0; i < n; i++) {\n dupireScale[i] = ref > 0\n ? dupireGrid[i] / ref\n : 1;\n }\n }\n\n const dxGrid = x[1] - x[0];\n const idxOf = (xv: number) => {\n let i = Math.round((xv - x[0]) / dxGrid);\n return i < 0 ? 0 : i > n - 1 ? n - 1 : i;\n };\n\n const driftFn = (xv: number, _tIdx: number) => {\n if (layer0Only) return 0;\n const i = idxOf(xv);\n return thetaGrid[i] * (anchorLog - xv);\n };\n\n const volFn = (xv: number, tIdx: number) => {\n const base = sigmaLog * timeVolMult[tIdx];\n if (layer0Only) return base;\n const i = idxOf(xv);\n // Market-read local vol wins over the fitted lambda_sigma path when it is\n // available and clean, because it needs no calibration at all.\n if (localVolSource === \"dupire\") return base * dupireScale[i];\n return base * volScaleGrid[i];\n };\n\n const touchProbAtIdx = (bIdx: number, upper: boolean): number => {\n if (bIdx === spotIdx) return 1;\n const raw = firstPassageProb({\n x,\n spotIdx,\n drift: driftFn,\n vol: volFn,\n nSteps: cfg.timeSteps,\n tau: tauClock,\n barrierIdx: bIdx,\n upper,\n });\n const z = Math.abs(x[bIdx]) / Math.max(1e-12, sigmaLog);\n const adj = cfg.useFatTailAdjust ? fatTailAdjust(raw, z) : raw;\n const cal = applyCalibration(adj, cfg.calibration);\n // Shrink toward the raw model as stress rises. Measured: the calibration\n // map is fitted mostly on calm sessions and actively HURT in 2018, 2020\n // and 2022 (the 48-63%-stressed years) when applied at full strength.\n const stress = Math.max(0, Math.min(2, mkt.stress ?? 0));\n const w = 1 / (1 + cfg.stressShrinkK * stress);\n return w * cal + (1 - w) * adj;\n };\n\n // --- probability curve, then invert to get the ladder --------------------\n const buildSide = (upper: boolean): Level[] => {\n const idxs: number[] = [];\n const step = 3;\n if (upper) {\n for (let i = spotIdx + step; i < n; i += step) idxs.push(i);\n } else {\n for (let i = spotIdx - step; i >= 0; i -= step) idxs.push(i);\n }\n\n const curve = idxs.map((i) => ({\n idx: i,\n nq: S0 * Math.exp(x[i]),\n p: touchProbAtIdx(i, upper),\n }));\n\n // Enforce monotonicity (guards against tiny CN wiggle near the barrier).\n for (let i = 1; i < curve.length; i++) {\n if (curve[i].p > curve[i - 1].p) curve[i].p = curve[i - 1].p;\n }\n\n const out: Level[] = [];\n for (const rung of cfg.ladderRungs) {\n let found: number | null = null;\n for (let i = 1; i < curve.length; i++) {\n const a = curve[i - 1];\n const b = curve[i];\n if (a.p >= rung && b.p <= rung) {\n const w = (a.p - rung) / Math.max(1e-12, a.p - b.p);\n found = a.nq + w * (b.nq - a.nq);\n break;\n }\n }\n if (found === null) continue;\n\n const dist = Math.abs(found - S0);\n const z = dist / Math.max(1e-9, sessionSigmaNq);\n const nullP = reflectionTouchProb(Math.log(1 + dist / S0), sigmaLog, 1);\n\n const spacing = 0.35 * sessionSigmaNq;\n let nearestWall: Wall | null = null;\n let bestD = Infinity;\n for (const w of walls) {\n const d = Math.abs(w.nq - found);\n if (d < spacing && d < bestD) {\n bestD = d;\n nearestWall = w;\n }\n }\n\n let nearestIvWall: IvWallNq | null = null;\n let bestIvD = Infinity;\n for (const w of ivWalls) {\n const d = Math.abs(w.nq - found);\n if (d < spacing && d < bestIvD) {\n bestIvD = d;\n nearestIvWall = w;\n }\n }\n\n out.push({\n nq: Math.round(found * 4) / 4,\n side: upper ? \"upper\" : \"lower\",\n rung,\n pTouch: rung,\n pTouchNull: nullP,\n z,\n nearestWall,\n nearestIvWall,\n stanceWeights: stanceWeights(\n state,\n nearestWall ? nearestWall.signConfidence : 0.3,\n ),\n });\n }\n return out;\n };\n\n const levels = [...buildSide(true), ...buildSide(false)];\n\n // --- survival of the running extremes ------------------------------------\n const survives = (\n extreme: number | null,\n upper: boolean,\n ): [number | null, number | null] => {\n if (extreme === null) return [null, null];\n const logB = Math.log(extreme / S0);\n if ((upper && logB <= 0) || (!upper && logB >= 0)) return [0, 0];\n let bIdx = Math.round(((logB + halfWidth) / (2 * halfWidth)) * (n - 1));\n bIdx = Math.max(0, Math.min(n - 1, bIdx));\n const p = 1 - touchProbAtIdx(bIdx, upper);\n const pNull = 1 - reflectionTouchProb(Math.abs(logB), sigmaLog, 1);\n return [p, pNull];\n };\n\n const [pHigh, pHighNull] = survives(mkt.runningHigh, true);\n const [pLow, pLowNull] = survives(mkt.runningLow, false);\n\n // --- confluence between the two independent wall families ----------------\n //\n // \"Agree\" is not merely co-location. A long-gamma strike (dealers suppress\n // moves) lining up with a vol_discount strike (market prices LESS vol there)\n // is two independent sources saying the same thing: this is a pin. A\n // long-gamma strike sitting on a vol_premium is a contradiction worth seeing\n // rather than averaging away.\n const confluence: LevelSet[\"confluence\"] = [];\n const tol = 0.12 * sessionSigmaNq;\n for (const gw of walls) {\n for (const iw of ivWalls) {\n if (Math.abs(gw.nq - iw.nq) > tol) continue;\n const agree = (gw.sign > 0 && iw.kind === \"vol_discount\") ||\n (gw.sign < 0 && iw.kind === \"vol_premium\");\n confluence.push({\n nq: gw.nq,\n gammaSign: gw.sign,\n ivKind: iw.kind,\n agree,\n });\n break;\n }\n }\n\n return {\n asofSessionFrac: mkt.sessionFrac,\n nqSpot: S0,\n sessionSigmaNq,\n expectedRangeNq: expectedRange(sigmaLog, 1) * S0,\n regime: {\n state,\n netGammaNormalised: netGammaNorm,\n gammaSaturated: Math.abs(netGammaNorm) > 0.99,\n netGammaRaw: netGammaSpot,\n hhi,\n gammaCentroidNq: gammaCentroid,\n },\n running: {\n pHighSurvives: pHigh,\n pLowSurvives: pLow,\n pHighSurvivesNull: pHighNull,\n pLowSurvivesNull: pLowNull,\n },\n walls,\n ivWalls: ivWalls.slice(0, 12),\n confluence,\n levels,\n diagnostics: {\n contractsUsed: used,\n contractsDropped: dropped,\n booksMerged: books.map((b) => b.symbol),\n layer0Only,\n surfacesFitted: surfaces.length,\n sviRmse: surfaces.length\n ? surfaces.reduce((a, s2) => a + s2.fit.rmse, 0) / surfaces.length\n : null,\n localVolSource,\n },\n };\n}",[165],"919426ef-d604-4565-b05f-f6d5c84098fe","compute.ts","cc96f1fe-9e74-11f1-8581-1607ee4eb77e",54,["D",1787481618107],5,"/**\n * compute.ts — the brain. Deploy as a CRON val.\n *\n * Runs on a schedule, sources EVERY input itself, computes the final level set,\n * and writes it to blob storage. The HTTP endpoint (server.ts) then just serves\n * that cached JSON, and the MotiveWave JAR just plots it. No maths anywhere\n * downstream.\n *\n * WHY CRON RATHER THAN COMPUTE-PER-REQUEST:\n * every client would otherwise trigger its own CBOE fetch, Yahoo fetch, SVI fit\n * and PDE solve for byte-identical output. With a Discord community behind it\n * that is N times the work and N times the rate-limit exposure against two\n * third-party endpoints. One compute, many readers.\n *\n * DATA SOURCES (both free, no keys):\n * CBOE delayed chain -> strikes, OI, IV, QQQ spot\n * Yahoo v8 chart NQ=F -> live NQ price, intraday bars, daily history\n *\n * The 15-minute chain delay is deliberate and load-bearing: it keeps this\n * outside OPRA's display and non-display fee schedule. Open interest only\n * updates after clearing anyway, so the delay costs almost nothing. NQ price\n * is the input that must be live, and Yahoo supplies it.\n *\n * DEPLOYMENT: this file exports computeAndStore() for server.ts to call\n * lazily, plus a default handler you can wire to a Cron trigger as a floor.\n *\n * The free Val Town tier caps cron at once per 15 minutes, which is far too\n * stale for a level tool. So the freshness path is LAZY RECOMPUTE: server.ts\n * checks the cache age on each request and refreshes when it exceeds the TTL.\n * That preserves the one-compute-per-minute property (the first caller after\n * expiry does the work, everyone else reads the result) without needing a\n * per-minute cron at all. Keep the 15-minute cron as a floor so a payload\n * exists even during quiet periods.\n */\n\nimport { blob } from \"https://esm.town/v/std/blob/main.ts\";\nimport {\n type ChainSnapshot,\n computeLevels,\n DEFAULT_CONFIG,\n forecastSessionSigma,\n type MarketState,\n type OptionQuote,\n} from \"./levels.ts\";\n\nexport const OUT_KEY = \"levels_current\";\nexport const ARCHIVE_PREFIX = \"ladder_\";\n\n/** Sessions of archived ladders to retain. */\nconst ARCHIVE_KEEP = 60;\n\n/**\n * Globex session boundary, 18:00 ET. A session labelled D runs 18:00 ET on D\n * to 18:00 ET on D+1, which is the span the archived ladder is drawn across.\n */\nconst SESSION_BOUNDARY_HOUR = 18;\n\n/**\n * The archived ladder for a session is the FIRST one computed after the\n * session opens - i.e. the prediction made at the start, before the session\n * revealed anything.\n *\n * That choice matters for honesty. Archiving a late-session ladder would look\n * far more accurate on the chart, because by 15:00 the running extremes are\n * mostly set and the rungs have collapsed around them. Only the opening ladder\n * is a genuine forecast, and only a genuine forecast is worth scoring.\n */\nfunction sessionKeyET(\n nowSec: number,\n): { key: string; startMs: number; endMs: number } {\n const p = etParts(nowSec);\n const d = new Date(`${p.ymd}T00:00:00Z`);\n // Before 18:00 ET we are still inside the session that opened yesterday.\n if (p.min < SESSION_BOUNDARY_HOUR * 60) d.setUTCDate(d.getUTCDate() - 1);\n const key = d.toISOString().slice(0, 10);\n // Approximate ET offset from the current timestamp rather than hardcoding,\n // so this survives the DST switch without a seasonal edit.\n const offsetMin = Math.round(\n (Date.parse(\n `${p.ymd}T${String(Math.floor(p.min / 60)).padStart(2, \"0\")}:${\n String(p.min % 60).padStart(2, \"0\")\n }:00Z`,\n ) -\n nowSec * 1000) / 60000,\n );\n const startMs =\n Date.parse(\n `${key}T${String(SESSION_BOUNDARY_HOUR).padStart(2, \"0\")}:00:00Z`,\n ) - offsetMin * 60000;\n return { key, startMs, endMs: startMs + 24 * 3600_000 };\n}\nconst MAX_EXPIRIES = 3;\nconst STRIKE_WINDOW = 0.08;\n\n// ---------------------------------------------------------------------------\n// CBOE chain\n// ---------------------------------------------------------------------------\n\nasync function fetchChain(): Promise<\n { spot: number; quotes: OptionQuote[]; expiries: string[] }\n> {\n const r = await fetch(\n \"https://cdn.cboe.com/api/global/delayed_quotes/options/QQQ.json\",\n { headers: { \"User-Agent\": \"Mozilla/5.0\" } },\n );\n if (!r.ok) throw new Error(`CBOE HTTP ${r.status}`);\n const j: any = await r.json();\n const spot = Number(j?.data?.current_price ?? j?.data?.close);\n if (!(spot > 0)) throw new Error(\"CBOE: no spot\");\n\n const raw = (j?.data?.options ?? []) as any[];\n const today = new Date().toISOString().slice(0, 10).replace(/-/g, \"\");\n const parse = (o: any) =>\n String(o.option ?? \"\").match(/^([A-Z_]+)(\\d{6})([CP])(\\d{8})$/);\n\n const expiries = [\n ...new Set(\n raw.map((o) => {\n const m = parse(o);\n return m ? `20${m[2]}` : null;\n })\n .filter((e): e is string => !!e && e >= today),\n ),\n ].sort().slice(0, MAX_EXPIRIES);\n const keep = new Set(expiries);\n\n const quotes: OptionQuote[] = [];\n for (const o of raw) {\n const m = parse(o);\n if (!m) continue;\n const expiry = `20${m[2]}`;\n if (!keep.has(expiry)) continue;\n const strike = parseInt(m[4], 10) / 1000;\n if (Math.abs(strike / spot - 1) > STRIKE_WINDOW) continue;\n const iv = Number(o.iv ?? 0), oi = Number(o.open_interest ?? 0);\n if (!(iv > 0) || !(oi > 0)) continue;\n const y = +`20${m[2].slice(0, 2)}`,\n mo = +m[2].slice(2, 4),\n da = +m[2].slice(4, 6);\n const days = Math.max(0, (Date.UTC(y, mo - 1, da) - Date.now()) / 864e5);\n quotes.push({\n strike,\n right: m[3] as \"C\" | \"P\",\n tau: Math.max(1e-6, days / 365 + (6.5 / 24 / 365) * 0.5),\n iv,\n openInterest: oi,\n });\n }\n if (quotes.length < 40) {\n throw new Error(`CBOE: only ${quotes.length} usable contracts`);\n }\n return { spot, quotes, expiries };\n}\n\n// ---------------------------------------------------------------------------\n// Yahoo NQ=F\n// ---------------------------------------------------------------------------\n\ninterface Bars {\n t: number[];\n o: number[];\n h: number[];\n l: number[];\n c: number[];\n last: number;\n}\n\nasync function yahoo(interval: string, range: string): Promise {\n const url =\n `https://query1.finance.yahoo.com/v8/finance/chart/NQ%3DF?interval=${interval}&range=${range}`;\n const r = await fetch(url, { headers: { \"User-Agent\": \"Mozilla/5.0\" } });\n if (!r.ok) throw new Error(`Yahoo HTTP ${r.status}`);\n const j: any = await r.json();\n const res = j?.chart?.result?.[0];\n if (!res) throw new Error(\"Yahoo: empty result\");\n const q = res.indicators?.quote?.[0] ?? {};\n const t: number[] = res.timestamp ?? [];\n const keep: number[] = [];\n for (let i = 0; i < t.length; i++) if (q.close?.[i] != null) keep.push(i);\n return {\n t: keep.map((i) => t[i]),\n o: keep.map((i) => q.open[i]),\n h: keep.map((i) => q.high[i]),\n l: keep.map((i) => q.low[i]),\n c: keep.map((i) => q.close[i]),\n last: Number(\n res.meta?.regularMarketPrice ?? q.close[keep[keep.length - 1]],\n ),\n };\n}\n\n/** Realised vol of a bar series, as sum of squared log returns. */\nfunction rv(c: number[]): number {\n let s = 0;\n for (let i = 1; i < c.length; i++) {\n if (c[i] > 0 && c[i - 1] > 0) {\n const r = Math.log(c[i] / c[i - 1]);\n s += r * r;\n }\n }\n return Math.sqrt(s);\n}\n\n/** ET wall-clock parts for a unix second, without pulling in a date library. */\nfunction etParts(sec: number) {\n const d = new Date(sec * 1000);\n const f = new Intl.DateTimeFormat(\"en-US\", {\n timeZone: \"America/New_York\",\n hour12: false,\n year: \"numeric\",\n month: \"2-digit\",\n day: \"2-digit\",\n hour: \"2-digit\",\n minute: \"2-digit\",\n weekday: \"short\",\n }).formatToParts(d);\n const g = (k: string) => f.find((p) => p.type === k)?.value ?? \"\";\n return {\n ymd: `${g(\"year\")}-${g(\"month\")}-${g(\"day\")}`,\n min: +g(\"hour\") * 60 + +g(\"minute\"),\n dow: [\"Sun\", \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\"].indexOf(\n g(\"weekday\"),\n ),\n };\n}\n\n// ---------------------------------------------------------------------------\n\nexport interface ComputeResult {\n ok: boolean;\n ms: number;\n error?: string;\n}\n\n/**\n * Fetch everything, compute the level set, write it to blob.\n * Safe to call concurrently: worst case is duplicated work, never corruption,\n * because the write is a single whole-object setJSON.\n */\nexport async function computeAndStore(): Promise {\n const started = Date.now();\n try {\n const [chain, intraday, daily] = await Promise.all([\n fetchChain(),\n yahoo(\"5m\", \"5d\"),\n yahoo(\"1d\", \"3mo\"),\n ]);\n\n const nowET = etParts(Math.floor(Date.now() / 1000));\n const RTH_O = 9 * 60 + 30, RTH_C = 16 * 60;\n\n // Session running high/low from today's RTH bars only.\n let hod: number | null = null, lod: number | null = null;\n const todayRthClose: number[] = [];\n const overnightClose: number[] = [];\n for (let i = 0; i < intraday.t.length; i++) {\n const p = etParts(intraday.t[i]);\n if (p.ymd !== nowET.ymd) continue;\n if (p.min >= RTH_O && p.min < RTH_C) {\n hod = hod === null ? intraday.h[i] : Math.max(hod, intraday.h[i]);\n lod = lod === null ? intraday.l[i] : Math.min(lod, intraday.l[i]);\n todayRthClose.push(intraday.c[i]);\n } else if (p.min < RTH_O) {\n overnightClose.push(intraday.c[i]);\n }\n }\n\n const sessionFrac = Math.max(\n 0,\n Math.min(1, (nowET.min - RTH_O) / (RTH_C - RTH_O)),\n );\n\n // Ex-ante vol inputs. EWMA over daily closes; overnight from tonight's bars.\n const dc = daily.c.slice(-40);\n const dailyRets: number[] = [];\n for (let i = 1; i < dc.length; i++) {\n dailyRets.push(Math.log(dc[i] / dc[i - 1]));\n }\n let ewma = 0, w = 0;\n const hl = 5, decay = Math.pow(0.5, 1 / hl);\n for (let i = dailyRets.length - 1, k = 0; i >= 0; i--, k++) {\n const wt = Math.pow(decay, k);\n ewma += wt * dailyRets[i] * dailyRets[i];\n w += wt;\n }\n ewma = w > 0 ? Math.sqrt(ewma / w) : 0.01;\n const onrv = overnightClose.length > 3 ? rv(overnightClose) : 0;\n\n const nq = intraday.last;\n const ratio = 41.09;\n const basis = nq - chain.spot * ratio;\n\n const books: ChainSnapshot[] = [{\n symbol: \"QQQ\",\n underlying: chain.spot,\n multiplier: 100,\n toNqScale: ratio,\n toNqBasis: basis,\n quotes: chain.quotes,\n }];\n\n const atm = chain.quotes.filter((q) =>\n Math.abs(q.strike / chain.spot - 1) < 0.01\n )\n .map((q) => q.iv).sort((a, b) => a - b);\n const atmIv = atm.length ? atm[Math.floor(atm.length / 2)] : 0.20;\n\n const mkt: MarketState = {\n nqSpot: nq,\n runningHigh: hod,\n runningLow: lod,\n sessionFrac,\n atmIv,\n ewmaPastRthRv: ewma > 0 ? ewma : undefined,\n overnightRv: onrv > 0 ? onrv : undefined,\n dayOfWeek: nowET.dow,\n };\n\n const levels = computeLevels(books, mkt, DEFAULT_CONFIG);\n\n const payload = {\n ...levels,\n meta: {\n computedAt: new Date().toISOString(),\n nqSource: \"yahoo:NQ=F\",\n chainSource: \"cboe_delayed\",\n chainDelayedMinutes: 15,\n chainExpiries: chain.expiries,\n contracts: chain.quotes.length,\n qqqSpot: chain.spot,\n ratio,\n basis,\n sessionFrac,\n dayOfWeek: nowET.dow,\n ewmaPastRthRv: ewma,\n overnightRv: onrv,\n sigmaBlend: onrv > 0\n ? forecastSessionSigma(ewma, onrv, nowET.dow)\n : null,\n rthOpen: nowET.min >= RTH_O && nowET.min < RTH_C,\n computeMs: Date.now() - started,\n },\n };\n\n await blob.setJSON(OUT_KEY, payload);\n\n // --- archive the session's OPENING ladder, once ------------------------\n try {\n const sess = sessionKeyET(Math.floor(Date.now() / 1000));\n const aKey = ARCHIVE_PREFIX + sess.key;\n let existing: any = null;\n try {\n existing = await blob.getJSON(aKey);\n } catch { /* first of session */ }\n if (!existing) {\n await blob.setJSON(aKey, {\n session: sess.key,\n startMs: sess.startMs,\n endMs: sess.endMs,\n computedAt: payload.meta.computedAt,\n nqSpot: levels.nqSpot,\n sessionSigmaNq: levels.sessionSigmaNq,\n regime: levels.regime.state,\n // Trimmed deliberately: the archive is for plotting, not analysis,\n // and full payloads x60 sessions would be a needless blob budget.\n levels: levels.levels.map((l) => ({\n nq: l.nq,\n rung: l.rung,\n side: l.side,\n wallSign: l.nearestWall ? l.nearestWall.sign : 0,\n })),\n });\n\n // Retention sweep, only on the write that creates a new session.\n const all = await blob.list(ARCHIVE_PREFIX);\n const keys = all.map((b: any) => b.key).sort();\n for (\n const k of keys.slice(0, Math.max(0, keys.length - ARCHIVE_KEEP))\n ) {\n try {\n await blob.delete(k);\n } catch { /* best effort */ }\n }\n }\n } catch (e) {\n // Archiving must never break the live path.\n console.log(\"archive skipped: \" + String(e));\n }\n console.log(JSON.stringify(\n {\n ok: true,\n nq,\n hod,\n lod,\n frac: +sessionFrac.toFixed(3),\n regime: levels.regime.state,\n levels: levels.levels.length,\n walls: levels.walls.length,\n ivWalls: levels.ivWalls.length,\n surfaces: levels.diagnostics.surfacesFitted,\n sigmaSrc: levels.diagnostics.localVolSource,\n ms: Date.now() - started,\n },\n null,\n 2,\n ));\n return { ok: true, ms: Date.now() - started };\n } catch (e: any) {\n const err = {\n ok: false,\n error: String(e?.message ?? e),\n at: new Date().toISOString(),\n };\n console.log(JSON.stringify(err, null, 2));\n // Stamp the failure onto the cached payload rather than leaving a silently\n // old one in place - a level set with no freshness signal is worse than none.\n try {\n const prev: any = await blob.getJSON(OUT_KEY);\n if (prev) {\n prev.meta = { ...(prev.meta ?? {}), lastError: err };\n await blob.setJSON(OUT_KEY, prev);\n }\n } catch { /* nothing cached yet */ }\n return { ok: false, ms: Date.now() - started, error: err.error };\n }\n}\n\n/** Cron entry point. Use as a 15-minute floor: 3,18,33,48 * * * 1-5 */\nexport default async function (): Promise {\n const r = await computeAndStore();\n return Response.json(r, { status: r.ok ? 200 : 500 });\n}",[172],"0f012e38-3569-4162-ae43-464945b956ee","codec.ts","1f0b8eb0-9e46-11f1-93fe-1607ee4eb77e",17,["D",1787415978344],"/**\n * codec.ts — pure storage format. No I/O, no blob, no network.\n *\n * Separated from recorder.ts so that BOTH the writer (recorder) and the\n * readers (calibration job, level server, local tests) can use it without\n * pulling in Val Town's blob import, which only resolves inside Val Town.\n */\n\nexport interface RecordedQuote {\n s: number; // strike\n r: \"C\" | \"P\"; // right\n e: string; // expiry YYYY-MM-DD\n iv: number;\n oi: number;\n v: number; // volume\n b: number; // bid\n a: number; // ask\n}\n\n/**\n * COLUMNAR layout, not an array of objects.\n *\n * A row-oriented array repeats every field name ~1,200 times per snapshot.\n * Columnar stores each field name once and puts the values in parallel arrays,\n * which also gives gzip long runs of similar numbers to work with. Between the\n * two, a snapshot shrinks by roughly 8-10x. Against a 10 MB free-tier cap that\n * is the difference between three weeks and most of a year of history.\n */\nexport interface Snapshot {\n sym: string;\n ts: string; // ISO timestamp of capture\n spot: number;\n src: string;\n delayed: true;\n v: 2; // schema version - readers MUST check this\n cols: {\n s: number[]; // strike\n r: number[]; // 0 = call, 1 = put\n e: number[]; // index into `expiries`\n iv: number[];\n oi: number[];\n vol: number[];\n b: number[];\n a: number[];\n };\n expiries: string[];\n diag: {\n fetched: number;\n kept: number;\n expiries: string[];\n droppedExpired: number;\n ms: number;\n };\n}\n\nexport function toColumnar(rows: RecordedQuote[], expiries: string[]) {\n const eIdx = new Map(expiries.map((e, i) => [e, i]));\n const c = {\n s: [] as number[],\n r: [] as number[],\n e: [] as number[],\n iv: [] as number[],\n oi: [] as number[],\n vol: [] as number[],\n b: [] as number[],\n a: [] as number[],\n };\n for (const q of rows) {\n c.s.push(q.s);\n c.r.push(q.r === \"C\" ? 0 : 1);\n c.e.push(eIdx.get(q.e) ?? 0);\n // Round to the precision that actually matters. Trailing float noise costs\n // real bytes and buys nothing: IV to 4dp, prices to 2dp.\n c.iv.push(Math.round(q.iv * 1e4) / 1e4);\n c.oi.push(q.oi);\n c.vol.push(q.v);\n c.b.push(Math.round(q.b * 100) / 100);\n c.a.push(Math.round(q.a * 100) / 100);\n }\n return c;\n}\n\n/** Inverse of toColumnar - what the calibration job uses to read snapshots. */\nexport function fromColumnar(snap: Snapshot): RecordedQuote[] {\n const { cols, expiries } = snap;\n const out: RecordedQuote[] = [];\n for (let i = 0; i < cols.s.length; i++) {\n out.push({\n s: cols.s[i],\n r: cols.r[i] === 0 ? \"C\" : \"P\",\n e: expiries[cols.e[i]],\n iv: cols.iv[i],\n oi: cols.oi[i],\n v: cols.vol[i],\n b: cols.b[i],\n a: cols.a[i],\n });\n }\n return out;\n}\n\n/** gzip a string via the platform CompressionStream. */\nexport async function gzip(text: string): Promise {\n const cs = new CompressionStream(\"gzip\");\n const stream = new Blob([text]).stream().pipeThrough(cs);\n const buf = await new Response(stream).arrayBuffer();\n return new Uint8Array(buf);\n}\n\n/** gunzip back to a string. Pair with fromColumnar to read a snapshot. */\nexport async function gunzip(bytes: Uint8Array): Promise {\n const ds = new DecompressionStream(\"gzip\");\n const stream = new Blob([bytes as BlobPart]).stream().pipeThrough(ds);\n return await new Response(stream).text();\n}",[180],"pulls","branches",1,"forks","envVars",{"_194":62,"_196":62},"connections",{"_194":62,"_195":62},"count","unfilledCount","emptyCount",{"_43":179,"_32":180,"_30":181,"_134":-5,"_41":42,"_40":182,"_136":58,"_38":223,"_13":161,"_33":139,"_35":184,"_24":25,"_141":-5,"_205":224,"_27":225},{"_43":171,"_32":172,"_30":173,"_134":-5,"_41":42,"_40":174,"_136":25,"_38":220,"_13":176,"_33":153,"_35":177,"_24":25,"_141":-5,"_205":221,"_27":222},{"_43":164,"_32":165,"_30":166,"_134":-5,"_41":42,"_40":167,"_136":25,"_38":217,"_13":161,"_33":139,"_35":169,"_24":25,"_141":-5,"_205":218,"_27":219},{"_43":156,"_32":157,"_30":158,"_134":-5,"_41":42,"_40":159,"_136":58,"_38":214,"_13":161,"_33":139,"_35":162,"_24":25,"_141":-5,"_205":215,"_27":216},{"_43":147,"_32":148,"_30":149,"_134":-5,"_41":42,"_40":150,"_136":58,"_38":211,"_13":152,"_33":153,"_35":154,"_24":25,"_141":-5,"_205":212,"_27":213},{"_43":143,"_32":28,"_30":31,"_134":-5,"_41":42,"_40":14,"_136":58,"_38":208,"_13":145,"_33":34,"_35":37,"_24":25,"_141":-5,"_205":209,"_27":210},{"_43":131,"_32":132,"_30":133,"_134":-5,"_41":42,"_40":135,"_136":58,"_38":204,"_13":138,"_33":139,"_35":140,"_24":25,"_141":-5,"_205":206,"_27":207},["D",1787435129713],"children",[],[132],["D",1787481627838],[],[28],["D",1787415993679],[],[148],["D",1787434942688],[],[157],["D",1787434928980],[],[165],["D",1787481618107],[],[172],["D",1787415978344],[],[180],["D",1787415250732],{"_96":95,"_102":53},{"_96":95,"_97":53,"_98":53,"_18":55,"_99":100,"_101":25},{"_13":85,"_32":86,"_43":42,"_87":44,"_88":-5,"_89":-5,"_90":-5,"_91":-5,"_92":-5,"_93":45,"_94":95},"ctx",{"_78":-5,"_121":263,"_264":265,"_266":267,"_268":25,"_269":25,"_270":25,"_271":58,"_272":-5,"_273":-7,"_274":-7,"_275":62,"_276":25,"_277":25,"_278":-5,"_279":25,"_280":25,"_281":25,"_282":-5},"ENV",{"_234":235,"_236":237,"_238":86,"_239":240,"_241":242,"_243":244,"_245":246,"_247":248,"_249":250,"_251":252,"_253":254,"_255":256,"_257":258,"_259":260,"_261":262},"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"]

Diff · v55