[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_253":254,"_255":256},"routes/_app.x.$handle.$name",{"_11":12,"_13":14,"_15":16,"_17":18,"_41":-7,"_145":-5,"_19":146,"_147":148,"_149":150,"_151":152,"_153":154,"_21":155,"_156":-5,"_157":-5,"_158":24,"_159":160,"_161":108,"_162":-5,"_163":-5,"_164":165},"routes/_app.x.$handle.$name.branch.$branch.history_.$",{"_11":12,"_13":14,"_15":16,"_17":18,"_19":20,"_21":22,"_23":24,"_25":26,"_27":28,"_29":24,"_30":-5},"handle","jfkll","name","ivmodule","branchName","main","path","surface.ts","project",{"_35":96,"_13":14,"_39":97,"_98":-5,"_99":24,"_100":101,"_102":101,"_103":72,"_104":-5,"_30":70,"_105":106,"_107":108,"_109":-5,"_110":-5,"_111":26,"_43":44,"_112":-5,"_113":-5,"_114":-5,"_115":-5,"_116":117,"_118":117,"_119":120,"_121":120,"_122":120,"_123":117,"_124":117,"_54":125,"_126":127,"_128":129,"_130":24},"file",{"_64":65,"_13":18,"_67":68,"_69":24,"_95":-5},"isDirectory",false,"page",0,"history",[31,32,33,34],"hasNext","userId",{"_35":87,"_37":38,"_39":88,"_41":89,"_43":44,"_45":90,"_47":-5,"_48":-5,"_49":-5,"_50":-5,"_51":-5,"_52":-5,"_53":-5,"_54":91,"_21":92,"_57":-5,"_58":-5,"_59":-5,"_60":-5,"_61":93},{"_35":80,"_37":38,"_39":81,"_41":82,"_43":44,"_45":73,"_47":-5,"_48":-5,"_49":-5,"_50":-5,"_51":-5,"_52":-5,"_53":-5,"_54":83,"_21":84,"_57":-5,"_58":-5,"_59":-5,"_60":-5,"_61":85},{"_35":73,"_37":38,"_39":74,"_41":75,"_43":44,"_45":36,"_47":-5,"_48":-5,"_49":-5,"_50":-5,"_51":-5,"_52":-5,"_53":-5,"_54":76,"_21":77,"_57":-5,"_58":-5,"_59":-5,"_60":-5,"_61":78},{"_35":36,"_37":38,"_39":40,"_41":42,"_43":44,"_45":46,"_47":-5,"_48":-5,"_49":-5,"_50":-5,"_51":-5,"_52":-5,"_53":-5,"_54":55,"_21":56,"_57":-5,"_58":-5,"_59":-5,"_60":-5,"_61":62},"id","7b23b0c7-862b-41a9-9fbc-72df2efc27f5","branchId","9501ca55-9d64-4f95-91aa-9fa7ca96c333","createdAt",["D",1787434952384],"version",30,"orgId","019f98c4-b792-72f1-83e7-7d98b5b52c8e","parentId","e9c70dd3-6574-417b-a380-5fb8e7d36268","incomingCommitId","aiChatMessageId","aiChatThreadId","aiChatThreadUserId","aiChatThreadTitle","source","clientLabel","user",{"_35":70,"_43":44,"_11":12,"_71":72},{"_64":65,"_13":66,"_67":68,"_69":24},"pull","merge","revert","multiple","commits",[63],{"_35":36,"_37":38,"_39":40,"_41":42,"_43":44,"_45":46,"_47":-5,"_48":-5,"_49":-5,"_50":-5,"_51":-5,"_52":-5,"_53":-5,"_54":55,"_21":56,"_57":-5,"_58":-5,"_59":-5},"fileId","617831aa-9e72-11f1-b3ff-1607ee4eb77e","new-file-4222.ts","fileType","script","deleted","edb0ee8b-6eb5-4033-8065-92fa86e65418","avatar","","ad96babf-8d65-4346-a40c-2300ab37eb2a",["D",1787434962589],31,{"_35":70,"_43":44,"_11":12,"_71":72},{"_64":65,"_13":18,"_67":68,"_69":24},[79],{"_35":73,"_37":38,"_39":74,"_41":75,"_43":44,"_45":36,"_47":-5,"_48":-5,"_49":-5,"_50":-5,"_51":-5,"_52":-5,"_53":-5,"_54":76,"_21":77,"_57":-5,"_58":-5,"_59":-5},"a2c176f3-ee3c-4c58-8e33-bfa0f97bad3b",["D",1787434965883],32,{"_35":70,"_43":44,"_11":12,"_71":72},{"_64":65,"_13":18,"_67":68,"_69":24},[86],{"_35":80,"_37":38,"_39":81,"_41":82,"_43":44,"_45":73,"_47":-5,"_48":-5,"_49":-5,"_50":-5,"_51":-5,"_52":-5,"_53":-5,"_54":83,"_21":84,"_57":-5,"_58":-5,"_59":-5},"f2155df1-bdee-423a-bec0-1d64dfd1da7b",["D",1787435129713],34,"1a27b8f3-b4a5-4528-86c3-3f60a03067ba",{"_35":70,"_43":44,"_11":12,"_71":72},{"_64":65,"_13":18,"_67":68,"_69":24},[94],{"_35":87,"_37":38,"_39":88,"_41":89,"_43":44,"_45":90,"_47":-5,"_48":-5,"_49":-5,"_50":-5,"_51":-5,"_52":-5,"_53":-5,"_54":91,"_21":92,"_57":-5,"_58":-5,"_59":-5},"deletedAtVersion","2119d995-ca04-498c-aa95-f7a73f7c0d10",["D",1787415250732],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","imageUrl","pinnedFileId","0ca60dd2-9e72-11f1-83cf-1607ee4eb77e","pinPreview",true,"pinMigrated","screenshotVersion","likeCount","tursoName","tursoHostname","tursoMeasuredAt","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm",{"_11":12,"_144":72},"org",{"_11":12,"_140":72,"_71":72,"_30":70,"_141":142,"_143":24},"branch",{"_41":131,"_13":16,"_35":38,"_132":96,"_133":-5,"_134":-5,"_135":-5,"_136":-5,"_137":-5,"_138":14,"_139":12},"isOwned",63,"projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","displayName","tier","free","canRestrictVals","profileImageUrl","adoptOrgId",{"_35":96,"_13":14,"_39":249,"_98":-5,"_99":24,"_100":101,"_102":101,"_103":72,"_104":-5,"_30":70,"_105":106,"_107":108,"_109":-5,"_110":-5,"_111":26,"_43":44,"_112":-5,"_113":-5,"_114":-5,"_115":-5,"_116":117,"_118":117,"_119":120,"_121":120,"_122":120,"_123":117,"_124":117,"_54":250,"_126":251,"_128":252,"_130":24},"tree",[185,186,187,188,189,190,191],"files",[185,186,187,188,189,190,191],"counts",{"_174":26,"_175":176,"_177":26,"_178":179,"_180":181},"contents",[],{"_35":166,"_37":38,"_64":65,"_13":18,"_167":168,"_67":68,"_41":169,"_45":-5,"_39":170,"_171":89,"_172":-5,"_17":173},"upstreamProject","upstreamBranch","emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},"11970ade-c283-41e2-b474-3a8d0d8ddfa0","content","/**\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}",3,["D",1787435129713],"branchVersion","label",[18],"pulls","branches",1,"forks","envVars",{"_182":26,"_184":26},"connections",{"_182":26,"_183":26},"count","unfilledCount","emptyCount",{"_35":241,"_13":242,"_64":243,"_45":-5,"_37":38,"_171":244,"_192":108,"_39":245,"_41":221,"_67":68,"_167":246,"_69":24,"_172":-5,"_194":247,"_17":248},{"_35":233,"_13":234,"_64":235,"_45":-5,"_37":38,"_171":131,"_192":108,"_39":236,"_41":237,"_67":212,"_167":238,"_69":24,"_172":-5,"_194":239,"_17":240},{"_35":225,"_13":226,"_64":227,"_45":-5,"_37":38,"_171":228,"_192":108,"_39":229,"_41":169,"_67":68,"_167":230,"_69":24,"_172":-5,"_194":231,"_17":232},{"_35":216,"_13":217,"_64":218,"_45":-5,"_37":38,"_171":219,"_192":108,"_39":220,"_41":221,"_67":68,"_167":222,"_69":24,"_172":-5,"_194":223,"_17":224},{"_35":206,"_13":207,"_64":208,"_45":-5,"_37":38,"_171":209,"_192":108,"_39":210,"_41":211,"_67":212,"_167":213,"_69":24,"_172":-5,"_194":214,"_17":215},{"_35":197,"_13":198,"_64":106,"_45":-5,"_37":38,"_171":199,"_192":108,"_39":200,"_41":201,"_67":202,"_167":203,"_69":24,"_172":-5,"_194":204,"_17":205},{"_35":166,"_13":18,"_64":65,"_45":-5,"_37":38,"_171":89,"_192":108,"_39":193,"_41":169,"_67":68,"_167":168,"_69":24,"_172":-5,"_194":195,"_17":196},"latest",["D",1787435129713],"children",[],[18],"0778450b-9c9c-4d39-a2d1-1445a5ef4e45","server.ts",55,["D",1787481627838],13,"http","/**\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}",[],[198],"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}",[],[207],"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}",[],[217],"9d5bec64-6eca-4b39-8fb9-63aa5b02c688","levels.ts","4fc39b2a-9e72-11f1-827f-1607ee4eb77e",56,["D",1787482907306],"/**\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 /**\n * \"ladder\" = full 4-rung-per-side set.\n * \"quad\" = 4 zones total: primary HOD/LOD plus one expansion zone per side,\n * with the expansion probability lift-adjusted for continuation.\n */\n zoneMode: \"ladder\" | \"quad\";\n /** quad mode: P(touch) for the primary zones. */\n primaryRung: number;\n /** quad mode: P(touch) for the expansion zones, before the lift. */\n expansionRung: 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 */\n/**\n * MEASURED CONTINUATION LIFT.\n *\n * At the moment price breaks a zone, does it extend further than a fresh\n * diffusion forecast from that point predicts? Measured on 8,550 break events\n * across 1,579 sessions (primary z=1.0, expansion z=1.8):\n *\n * all breaks lift 1.222 CI [1.151, 1.290]\n * UPSIDE breaks lift 1.064 CI [0.971, 1.166] NOT significant\n * DOWNSIDE breaks lift 1.340 CI [1.242, 1.434]\n * long gamma lift 1.120 CI [1.033, 1.235]\n * short gamma lift 1.313 CI [1.214, 1.407]\n *\n * Continuation is real but overwhelmingly a DOWNSIDE phenomenon - the leverage\n * effect. Downside breaks trigger genuine selling; upside breaks grind, and\n * their confidence interval crosses 1.\n *\n * ON THE OBVIOUS TEST THAT DOES NOT WORK: asking \"given price touched the\n * primary, how often did it reach expansion\" is tautological. Nested barriers\n * mean reaching the far level implies reaching the near one, so the answer is\n * P(exp)/P(prim) by set inclusion - always, in every regime. The numbers above\n * condition on the MOMENT of the break and re-forecast from there, which is\n * the only version that carries information.\n */\nexport const CONTINUATION_LIFT = { up: 1.064, down: 1.340 };\nexport const CONTINUATION_LIFT_SHORT_GAMMA = { up: 1.15, down: 1.45 };\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 zoneMode: \"quad\",\n primaryRung: 0.60,\n expansionRung: 0.25,\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 /** quad mode: which zone this is. */\n role?: \"primary\" | \"expansion\";\n /**\n * Expansion zones only: P(reach this | the primary on this side breaks),\n * after the measured continuation lift. THIS is the number to act on once a\n * break happens - not the unconditional touch probability.\n */\n pReachGivenBreak?: number;\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 let levels = [...buildSide(true), ...buildSide(false)];\n\n // --- quad mode: 4 zones instead of 8 -------------------------------------\n if (cfg.zoneMode === \"quad\") {\n const shortGamma = netGammaNorm < 0;\n const lift = shortGamma ? CONTINUATION_LIFT_SHORT_GAMMA : CONTINUATION_LIFT;\n const picked: Level[] = [];\n for (const side of [\"upper\", \"lower\"] as const) {\n const mine = levels.filter((l) => l.side === side);\n if (!mine.length) continue;\n const near = (target: number) =>\n mine.reduce((a, b) =>\n Math.abs(a.rung - target) < Math.abs(b.rung - target) ? a : b\n );\n const prim = { ...near(cfg.primaryRung), role: \"primary\" as const };\n const expn = { ...near(cfg.expansionRung), role: \"expansion\" as const };\n if (Math.abs(expn.nq - prim.nq) < 1e-6) {\n picked.push(prim);\n continue;\n }\n // Conditional reach, lift-adjusted. The ratio is the diffusion baseline;\n // the lift is what the break itself adds on top of it.\n const k = side === \"upper\" ? lift.up : lift.down;\n expn.pReachGivenBreak = Math.min(\n 0.99,\n (expn.pTouch / Math.max(1e-6, prim.pTouch)) * k,\n );\n picked.push(prim, expn);\n }\n levels = picked;\n }\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}",[],[226],"1d3e3372-c0a7-453e-8365-2e2a5fc49834","compute.ts","cc96f1fe-9e74-11f1-8581-1607ee4eb77e",["D",1787483652706],12,"/**\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 { fromColumnar, gunzip, type Snapshot } from \"./codec.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/** Rolling store of observed (QQQ spot, NQ spot) pairs for the mapping fit. */\nconst MAP_KEY = \"qqq_nq_map\";\nconst MAP_POINTS = 400;\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(\n prior: Map | null,\n): Promise<\n { spot: number; quotes: OptionQuote[]; expiries: string[]; signed: number }\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 let signed = 0;\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\n const q: OptionQuote = {\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 // Attach day-over-day deltas where we have a prior observation, which is\n // what turns the naive sign prior into an actual inference.\n if (prior) {\n const isoExp = `${expiry.slice(0, 4)}-${expiry.slice(4, 6)}-${\n expiry.slice(6, 8)\n }`;\n const p = prior.get(`${isoExp}|${m[3]}|${strike}`);\n if (p) {\n const mid = (Number(o.bid ?? 0) + Number(o.ask ?? 0)) / 2;\n if (mid > 0 && p.mid > 0) {\n q.deltaOi = oi - p.oi;\n q.deltaPrice = mid - p.mid;\n signed++;\n }\n }\n }\n quotes.push(q);\n }\n if (quotes.length < 40) {\n throw new Error(`CBOE: only ${quotes.length} usable contracts`);\n }\n return { spot, quotes, expiries, signed };\n}\n\n// ---------------------------------------------------------------------------\n// QQQ -> NQ mapping, fitted from observation\n// ---------------------------------------------------------------------------\n\n/**\n * NQ = a + b*QQQ, fitted on recently observed spot pairs.\n *\n * The previous version carried a hardcoded ratio (41.09) plus a basis backed\n * out from the current spot. That was modelling the chain QQQ -> NDX -> NQ,\n * which made sense when NDX was in the pipeline. It no longer is, and we\n * observe both QQQ and NQ directly every minute - so fitting the relationship\n * end to end is strictly better. One empirical fit absorbs the index ratio,\n * the futures carry, dividend accrual and the ETF expense drag together,\n * with no assumption about any of them.\n *\n * Least squares on a rolling window, with a slope sanity band: a bad Yahoo or\n * CBOE tick would otherwise drag the fit and misplace every level at once.\n */\nasync function fitMapping(\n qqqSpot: number,\n nq: number,\n): Promise<{ a: number; b: number; n: number; fitted: boolean }> {\n let pts: Array<[number, number]> = [];\n try {\n const v = await blob.getJSON(MAP_KEY);\n if (Array.isArray(v)) pts = v as Array<[number, number]>;\n } catch { /* first run */ }\n\n if (qqqSpot > 0 && nq > 0) {\n pts.push([qqqSpot, nq]);\n if (pts.length > MAP_POINTS) pts = pts.slice(-MAP_POINTS);\n try {\n await blob.setJSON(MAP_KEY, pts);\n } catch { /* best effort */ }\n }\n\n // Need enough spread in QQQ to identify a slope; a cluster of near-identical\n // spots gives a numerically unstable fit that looks fine until it explodes.\n const xs = pts.map((p) => p[0]);\n const spread = xs.length ? Math.max(...xs) - Math.min(...xs) : 0;\n if (pts.length < 30 || spread < 0.5) {\n return { a: nq - 41.09 * qqqSpot, b: 41.09, n: pts.length, fitted: false };\n }\n\n let sx = 0, sy = 0, sxx = 0, sxy = 0;\n for (const [x, y] of pts) {\n sx += x;\n sy += y;\n sxx += x * x;\n sxy += x * y;\n }\n const n = pts.length;\n const den = n * sxx - sx * sx;\n if (Math.abs(den) < 1e-9) {\n return { a: nq - 41.09 * qqqSpot, b: 41.09, n, fitted: false };\n }\n const b = (n * sxy - sx * sy) / den;\n const a = (sy - b * sx) / n;\n if (!(b > 30 && b < 55)) { // sanity band around the structural ~41\n return { a: nq - 41.09 * qqqSpot, b: 41.09, n, fitted: false };\n }\n return { a, b, n, fitted: true };\n}\n\n// ---------------------------------------------------------------------------\n// Dealer sign inference from our own recorded OI history\n// ---------------------------------------------------------------------------\n\n/**\n * The dOI x dPrice proxy needs YESTERDAY's open interest and option price,\n * which the CBOE delayed feed does not carry. But the recorder has been\n * storing full narrowed chains four times a day - so we diff against the most\n * recent snapshot that is at least a session old.\n *\n * This matters more than any modelling change currently on the table: without\n * it every wall falls back to the naive prior (dealers long calls, short puts)\n * at confidence 0.30, and the naive convention is wrong often enough to invert\n * the sign of the gamma field rather than merely weaken it.\n */\nasync function priorChain(): Promise<\n Map | null\n> {\n try {\n const all = await blob.list(\"chain_QQQ_\");\n if (!all.length) return null;\n const keys = all.map((b: any) => b.key).sort();\n const cutoff = Date.now() - 20 * 3600_000; // at least ~a session back\n let chosen: string | null = null;\n for (let i = keys.length - 1; i >= 0; i--) {\n const m = keys[i].match(/chain_QQQ_(\\d{4}-\\d{2}-\\d{2})T/);\n if (!m) continue;\n if (Date.parse(m[1] + \"T23:59:59Z\") < cutoff + 24 * 3600_000) {\n chosen = keys[i];\n break;\n }\n }\n if (!chosen) chosen = keys[0];\n\n const bytes = await blob.get(chosen);\n if (!bytes) return null;\n const buf = new Uint8Array(await (bytes as any).arrayBuffer?.() ?? bytes);\n const snap = JSON.parse(await gunzip(buf)) as Snapshot;\n if (snap?.v !== 2) return null;\n const map = new Map();\n for (const q of fromColumnar(snap)) {\n map.set(`${q.e}|${q.r}|${q.s}`, { oi: q.oi, mid: (q.b + q.a) / 2 });\n }\n return map;\n } catch {\n return null; // sign inference is an enhancement, never a hard dependency\n }\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 prior = await priorChain();\n const [chain, intraday, daily] = await Promise.all([\n fetchChain(prior),\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 /**\n * Most recent 18:00 ET boundary that actually has bars after it.\n *\n * Over a weekend or holiday the true most-recent boundary can be empty:\n * at 20:00 ET Saturday the last boundary is 18:00 ET Saturday, and Globex\n * does not reopen until Sunday. Stopping there leaves overnightRv at zero,\n * which silently drops the sigma forecast back to EWMA-only and throws\n * away the overnight term - worth ~13% of the OOS sigma error.\n *\n * So: walk back a day at a time until a boundary has real bars behind it.\n * The result is the last COMPLETED overnight session, which is the right\n * thing to condition on when the current one has not started.\n */\n const boundaryAt = (backDays: number) => {\n const probe = Date.now() - backDays * 86400_000;\n const pp = etParts(Math.floor(probe / 1000));\n const b = probe - pp.min * 60_000 + SESSION_BOUNDARY_HOUR * 60 * 60_000;\n return b <= Date.now() ? b : b - 86400_000;\n };\n const countAfter = (ms: number) =>\n intraday.t.reduce((n, t) => n + (t * 1000 >= ms ? 1 : 0), 0);\n\n let boundaryMs = boundaryAt(0);\n let boundaryBackDays = 0;\n for (let back = 0; back < 5 && countAfter(boundaryMs) < 12; back++) {\n boundaryBackDays = back + 1;\n boundaryMs = boundaryAt(back + 1);\n }\n /**\n * The overnight window ends at the NEXT RTH OPEN after the boundary, not\n * boundary + 24h.\n *\n * This matters for consistency with the calibration. The 0.455 weight on\n * overnight realised vol was fitted on the PRE-OPEN Globex portion only\n * (18:00 ET through 09:30 ET). A 24-hour window would fold that session's\n * RTH back in, feeding the model a different quantity from the one the\n * coefficient was estimated on - so the blend would be wrong in a way that\n * looks perfectly healthy in the diagnostics.\n */\n const boundaryEndMs = (() => {\n // Walk forward from the boundary to the first 09:30 ET after it.\n for (let h = 1; h <= 30; h++) {\n const probe = boundaryMs + h * 3600_000;\n const pp = etParts(Math.floor(probe / 1000));\n if (pp.min >= RTH_O) return probe - (pp.min - RTH_O) * 60_000;\n }\n return boundaryMs + 15.5 * 3600_000;\n })();\n\n // Session running high/low from today's RTH bars only.\n let hod: number | null = null, lod: number | null = null;\n let onHi: number | null = null, onLo: number | null = null;\n const overnightClose: number[] = [];\n for (let i = 0; i < intraday.t.length; i++) {\n const p = etParts(intraday.t[i]);\n const isToday = p.ymd === nowET.ymd;\n if (isToday && 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 }\n // Overnight = since the MOST RECENT 18:00 ET boundary, by timestamp.\n //\n // The previous form tested \"not today AND after 18:00\", which matches\n // EVERY prior evening in the window, not just the last one. Over a\n // weekend that silently merged three evenings into one \"overnight\" -\n // visible as a 415-point range where a single session is ~150. That\n // inflates overnightRv, which feeds the calibrated sigma blend, so the\n // error propagates into every rung.\n const tms = intraday.t[i] * 1000;\n const sinceBoundary = tms >= boundaryMs && tms < boundaryEndMs;\n if (sinceBoundary) {\n overnightClose.push(intraday.c[i]);\n onHi = onHi === null ? intraday.h[i] : Math.max(onHi, intraday.h[i]);\n onLo = onLo === null ? intraday.l[i] : Math.min(onLo, intraday.l[i]);\n }\n }\n\n // Before RTH opens there is no session extreme yet. Fall back to the\n // Globex extremes so the tool still says something useful overnight,\n // flagged so the client knows which it is looking at.\n const usingOvernightExtremes = hod === null && onHi !== null;\n if (usingOvernightExtremes) {\n hod = onHi;\n lod = onLo;\n }\n\n /**\n * Session fraction, correct outside RTH.\n *\n * The naive clamp of (now - open)/(close - open) breaks overnight: at\n * 22:00 ET it evaluates to 1.92 and clamps to 1, so remaining variance\n * goes to zero, sigma collapses and the ladder degenerates to a point.\n * Since Globex is most of the trading day, that is most of the time.\n *\n * After the close we are forecasting the NEXT RTH session, so the correct\n * value is 0 - the whole session is still ahead. Before the open, likewise.\n */\n const inRth = nowET.min >= RTH_O && nowET.min < RTH_C;\n const sessionFrac = inRth ? (nowET.min - RTH_O) / (RTH_C - RTH_O) : 0;\n const preOpen = !inRth;\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 map = await fitMapping(chain.spot, nq);\n\n const books: ChainSnapshot[] = [{\n symbol: \"QQQ\",\n underlying: chain.spot,\n multiplier: 100,\n toNqScale: map.b,\n toNqBasis: map.a,\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 mapping: {\n slope: map.b,\n intercept: map.a,\n points: map.n,\n fitted: map.fitted,\n },\n signInference: {\n quotesWithPrior: chain.signed,\n coverage: chain.quotes.length\n ? chain.signed / chain.quotes.length\n : 0,\n priorChainFound: prior !== null,\n },\n sessionFrac,\n dayOfWeek: nowET.dow,\n inRth,\n preOpen,\n usingOvernightExtremes,\n overnightBoundary: new Date(boundaryMs).toISOString(),\n overnightBars: overnightClose.length,\n overnightBackDays: boundaryBackDays,\n overnightEnd: new Date(boundaryEndMs).toISOString(),\n ewmaPastRthRv: ewma,\n overnightRv: onrv,\n sigmaBlend: onrv > 0\n ? forecastSessionSigma(ewma, onrv, nowET.dow)\n : null,\n rthOpen: inRth,\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 inRth,\n onExtremes: usingOvernightExtremes,\n onBars: overnightClose.length,\n onFrom: new Date(boundaryMs).toISOString().slice(5, 16),\n onBack: boundaryBackDays,\n onTo: new Date(boundaryEndMs).toISOString().slice(5, 16),\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 mapSlope: +map.b.toFixed(3),\n mapFitted: map.fitted,\n mapPts: map.n,\n signed: chain.signed + \"/\" + chain.quotes.length,\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}",[],[234],"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}",[],[242],["D",1787415250732],{"_11":12,"_144":72},{"_11":12,"_140":72,"_71":72,"_30":70,"_141":142,"_143":24},{"_41":131,"_13":16,"_35":38,"_132":96,"_133":-5,"_134":-5,"_135":-5,"_136":-5,"_137":-5,"_138":14,"_139":12},"ctx",{"_54":-5,"_163":286,"_287":288,"_289":290,"_291":24,"_292":24,"_293":24,"_294":108,"_295":-5,"_296":-7,"_297":-7,"_298":26,"_299":24,"_300":24,"_301":-5,"_302":24,"_303":24,"_304":24,"_305":-5},"ENV",{"_257":258,"_259":260,"_261":16,"_262":263,"_264":265,"_266":267,"_268":269,"_270":271,"_272":273,"_274":275,"_276":277,"_278":279,"_280":281,"_282":283,"_284":285},"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"]

History · surface.ts