[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_157":158,"_159":160},"routes/_app.x.$handle.$name",{"_16":17,"_20":21,"_83":65,"_84":85,"_63":-7,"_86":-5,"_13":87,"_88":89,"_11":90,"_91":92,"_93":94,"_95":-5,"_96":-5,"_97":-5,"_98":26,"_99":100,"_101":26,"_102":-5,"_103":-5,"_104":105},"routes/_app.x.$handle.$name.search.$(branch)",{"_11":12,"_13":14,"_15":-5,"_16":17},"files",[],"project",{"_18":19,"_20":21,"_22":23,"_24":-5,"_25":26,"_27":28,"_29":28,"_30":31,"_32":-5,"_33":34,"_35":-5,"_36":26,"_37":-5,"_38":-5,"_39":40,"_41":42,"_43":-5,"_44":-5,"_45":-5,"_46":-5,"_47":48,"_49":48,"_50":51,"_52":51,"_53":51,"_54":48,"_55":48,"_56":57,"_58":59,"_60":61,"_62":26},"query","handle","jacksonfletcher","id","55f60870-4258-4e48-bbed-3ebd67f03698","name","Btc15min","createdAt",["D",1784564217723],"deletedAt","legacyEnvVars",false,"privacy","public","httpPrivacy","description","Kalshi","imageUrl","userId","0d0668e7-655b-4c3f-8602-34537c20e4a8","pinnedFileId","pinPreview","pinMigrated","screenshotVersion","likeCount",0,"orgId","019f8050-3a37-73e3-b02c-b23386b6c3b5","tursoName","tursoHostname","tursoMeasuredAt","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_16":17,"_82":78},"org",{"_16":17,"_75":76,"_77":78,"_33":34,"_79":80,"_81":26},"branch",{"_63":64,"_20":65,"_18":66,"_67":19,"_68":-5,"_69":-5,"_70":-5,"_71":-5,"_72":-5,"_73":21,"_74":17},"isOwned","version",28,"main","7d80b9e9-61e6-4b7e-aa7e-befb6ac4d8bb","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","displayName","Jackson Fletcher","avatar","https://lh3.googleusercontent.com/a/ACg8ocJMqzuUVu9STAa6peNRYaFwCk02iTiYv5A5jX7kptevo5AyGvMW=s96-c","tier","pro","canRestrictVals","profileImageUrl","branchName","path","","adoptOrgId",{"_18":19,"_20":21,"_22":153,"_24":-5,"_25":26,"_27":28,"_29":28,"_30":31,"_32":-5,"_33":34,"_35":-5,"_36":26,"_37":-5,"_38":-5,"_39":40,"_41":42,"_43":-5,"_44":-5,"_45":-5,"_46":-5,"_47":48,"_49":48,"_50":51,"_52":51,"_53":51,"_54":48,"_55":48,"_56":154,"_58":155,"_60":156,"_62":26},"tree",[144,145],[144,145],"counts",{"_133":40,"_134":135,"_136":40,"_137":138,"_139":140},"contents",[106,107],"file","upstreamProject","upstreamBranch","emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},{"_18":126,"_20":127,"_110":128,"_112":-5,"_113":66,"_114":129,"_115":116,"_22":130,"_63":40,"_119":95,"_121":131,"_123":26,"_124":-5,"_84":132},{"_18":108,"_20":109,"_110":111,"_112":-5,"_113":66,"_114":64,"_115":116,"_22":117,"_63":118,"_119":120,"_121":122,"_123":26,"_124":-5,"_84":125},"bde8fe2c-a86a-4c9e-9d2e-d93be9fc351d","main.ts","fileId","6e47ec80-8456-11f1-b0cd-1607ee4eb77e","parentId","branchId","branchVersion","latest",true,["D",1788704728937],26,"fileType","interval","content","import { blob } from \"https://esm.town/v/std/blob\";\n\nconst CRON_VERSION = \"v15-waits-for-the-market\";\n\nconst MAX_TICKS = 1440;\nconst VOL_LOOKBACK_MIN = 240;\n// Raised from 3000. At 96 rounds/day the old cap held ~31 days, which meant\n// the smallest edge the record could ever resolve was ~2.6pp -- larger than\n// any realistic edge in a liquid market. The log rolled over and discarded\n// data before statistical power arrived. 8000 holds ~83 days and brings the\n// detectable floor to ~1.6pp. The log is only READ when a window actually\n// settles now (see the calibration cache below), so the bigger buffer\n// doesn't turn into per-minute blob traffic.\nconst MAX_LOG = 8000;\n// Kalshi settles a closed market a short while after close, not instantly.\n// A window waits here for its official result; if that never arrives we\n// fall back to our own spot comparison and tag the record accordingly.\nconst SETTLE_TIMEOUT_MS = 12 * 60 * 1000;\n// Hard backstop. An entry that can satisfy NEITHER exit -- Kalshi never\n// returns a settled result AND the spot-fallback branch is skipped (a\n// missing closeMs makes \"now - closeMs > TIMEOUT\" evaluate NaN > n, which is\n// false forever; a missing fallbackResult fails its own null-check) -- would\n// sit in the queue permanently. Because the queue is capped and drops from\n// the FRONT, a few such entries push every newly-closed window off the end\n// unheard, and grading stops for good with no way to recover. Past this age\n// an entry is graded from whatever we have or discarded outright. There is\n// now no path that keeps a slot forever.\nconst HARD_EVICT_MS = 60 * 60 * 1000;\n// Raised from 8. At one close per 15 minutes this holds ~6 hours of backlog,\n// so a transient stall no longer silently eats new rounds.\nconst MAX_AWAITING = 24;\nconst MAX_SETTLE_CHECKS_PER_TICK = 3;\n// Kalshi lists a new 15-minute market ~25-30s AFTER the window opens. The\n// cron fires about once a minute at an arbitrary offset, so a tick landing\n// at :05 finds nothing, returns, and doesn't look again until :65 -- by\n// which point the window is either locked 65s late (and then thrown out by\n// the sanity filter) or lost entirely. That coin flip is the root cause of\n// every missing row in the history list.\n// One invocation can span the moment the market appears, even though the\n// cron itself can't run more often than once a minute. So when a window has\n// just opened and isn't listed yet, wait here and re-check instead of\n// throwing the window away.\nconst MARKET_WAIT_MS = 40 * 1000;\nconst MARKET_POLL_MS = 6 * 1000;\nconst WINDOW_MS = 15 * 60 * 1000;\n// Kalshi's trading fee, approximately: ceil(0.07 * contracts * P * (1-P)).\n// Per contract that is 0.07*P*(1-P) dollars -- about 1.75c at a 50c price.\n// VERIFY against Kalshi's current published fee schedule; this figure is\n// the one used to turn gross EV into net EV everywhere below.\nconst KALSHI_FEE_COEF = 0.07;\nfunction tradingFee(price) {\n if (price == null || !isFinite(price) || price <= 0 || price >= 1) {\n return null;\n }\n return KALSHI_FEE_COEF * price * (1 - price);\n}\n// Gross EV minus the fee you'd actually pay to take that side.\nfunction netEV(grossEV, askPrice) {\n const fee = tradingFee(askPrice);\n return grossEV == null || fee == null ? null : grossEV - fee;\n}\n\nfunction erf(x) {\n const s = x < 0 ? -1 : 1;\n x = Math.abs(x);\n const t = 1 / (1 + 0.3275911 * x);\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(-x * x);\n return s * y;\n}\nconst normCdf = (z) => 0.5 * (1 + erf(z / Math.SQRT2));\n\nfunction median(arr) {\n const s = [...arr].sort((a, b) => a - b);\n const mid = Math.floor(s.length / 2);\n return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;\n}\n\n// Fetches all three sources concurrently and cross-validates instead of\n// trusting whichever one answers first. A single bad tick from any one\n// source used to flow straight into sigmaLn (contaminating volatility for up\n// to 240 minutes forward) with no check at all.\nasync function fetchBTC(lastKnownPrice) {\n const sources = [\n {\n name: \"coinbase\",\n url: \"https://api.coinbase.com/v2/prices/BTC-USD/spot\",\n parse: (j) => parseFloat(j.data.amount),\n },\n {\n name: \"binance\",\n url: \"https://api.binance.com/api/v3/ticker/price?symbol=BTCUSDT\",\n parse: (j) => parseFloat(j.price),\n },\n {\n name: \"kraken\",\n url: \"https://api.kraken.com/0/public/Ticker?pair=XBTUSD\",\n parse: (j) => parseFloat(Object.values(j.result)[0].c[0]),\n },\n ];\n const settled = await Promise.allSettled(\n sources.map(async (s) => {\n const r = await fetch(s.url);\n if (!r.ok) throw new Error(\"http \" + r.status);\n const j = await r.json();\n const p = s.parse(j);\n if (!p || !isFinite(p) || p <= 0) throw new Error(\"bad price shape\");\n return { source: s.name, price: p };\n }),\n );\n const results = settled.filter((r) => r.status === \"fulfilled\").map((r) =>\n r.value\n );\n if (results.length === 0) return null;\n\n if (results.length >= 2) {\n const med = median(results.map((r) => r.price));\n // Keep only sources within 1% of the median -- catches one bad source\n // without requiring every source to agree exactly. Trusted regardless of\n // how large the move is, since two independent sources agreeing is real\n // corroboration, not a reason to second-guess a genuine crash.\n const agreeing = results.filter((r) => Math.abs(r.price / med - 1) <= 0.01);\n if (agreeing.length >= 2) return median(agreeing.map((r) => r.price));\n console.log(\n \"BTC sources disagree, no 2-way agreement:\",\n JSON.stringify(results),\n );\n }\n\n // Down to a single usable price. Sanity-check against the last known good\n // tick -- generous enough to never reject a genuine BTC move, but catches\n // gross data errors. Still used even if it fails, since a wrong-looking\n // lone source might still be true and a skipped tick costs ~60s of\n // visibility -- but it's logged so it's debuggable.\n const candidate = results[0];\n if (lastKnownPrice != null) {\n const moveFrac = Math.abs(candidate.price / lastKnownPrice - 1);\n if (moveFrac > 0.08) {\n console.log(\n `Suspect price: ${candidate.source} returned $${candidate.price} -- ` +\n `${\n (moveFrac * 100).toFixed(1)\n }% move from last known $${lastKnownPrice} in one tick, ` +\n `no second source to corroborate. Using it anyway.`,\n );\n }\n }\n return candidate.price;\n}\n\n// Kalshi publishes the actual settled outcome for every market. Reading it is\n// ground truth and removes an entire class of error: we were previously\n// deciding the result ourselves from a single spot reading taken up to 60s\n// after close, against a market that settles on a 60-SECOND AVERAGE of its\n// own reference price. Roughly a fifth of rounds settle within $40 of the\n// strike, where that timing gap alone flips the answer several percent of the\n// time -- concentrated exactly on the rounds the model is least sure about.\nasync function fetchKalshiSettled(ticker) {\n const bases = [\n \"https://api.elections.kalshi.com\",\n \"https://external-api.kalshi.com\",\n ];\n for (const base of bases) {\n try {\n const r = await fetch(\n base + \"/trade-api/v2/markets/\" + encodeURIComponent(ticker),\n );\n if (!r.ok) continue;\n const j = await r.json();\n const m = j && j.market;\n if (!m) continue;\n const res = String(m.result || \"\").toLowerCase();\n if (res === \"yes\") return { ok: true, settled: true, result: 1 };\n if (res === \"no\") return { ok: true, settled: true, result: 0 };\n return { ok: true, settled: false, status: m.status || null };\n } catch (e) {}\n }\n return { ok: false };\n}\n\nasync function fetchKalshi(spot, opts) {\n opts = opts || {};\n const path =\n \"/trade-api/v2/markets?series_ticker=KXBTC15M&status=open&limit=200\";\n const bases = [\n \"https://api.elections.kalshi.com\",\n \"https://external-api.kalshi.com\",\n ];\n const sleep = (ms) => new Promise((res) => setTimeout(res, ms));\n // Up to 2 attempts per base before moving on -- cheap insurance against a\n // single transient network blip, which is a different failure mode from\n // Kalshi being genuinely down.\n for (const base of bases) {\n let r = null;\n for (let attempt = 0; attempt < 2; attempt++) {\n try {\n r = await fetch(base + path);\n if (r.ok) break;\n } catch (e) {\n r = null;\n }\n if (attempt === 0) await sleep(400);\n }\n try {\n if (!r || !r.ok) continue;\n const j = await r.json();\n const now = Date.now();\n const markets = (j.markets || [])\n .map((m) => ({ ...m, closeMs: new Date(m.close_time).getTime() }))\n .filter((m) => m.closeMs > now)\n .sort((a, b) => a.closeMs - b.closeMs);\n if (!markets.length) continue;\n\n let win;\n if (opts.requireTicker) {\n const exact = markets.find((m) => m.ticker === opts.requireTicker);\n if (!exact) return { ok: false };\n win = [exact];\n } else {\n const nearest = markets[0].closeMs;\n win = markets.filter((m) => m.closeMs === nearest);\n if (spot != null) {\n win.sort(\n (a, b) =>\n Math.abs((a.floor_strike ?? 1e12) - spot) -\n Math.abs((b.floor_strike ?? 1e12) - spot),\n );\n }\n }\n const m = win[0];\n const px = (v, d) => {\n const raw = d != null ? d : v != null ? v / 100 : null;\n if (raw == null) return null;\n const n = Number(raw);\n return isFinite(n) ? n : null;\n };\n // A real bid/ask on an active, liquid market essentially never sits\n // within half a cent of the boundary -- there's always some residual\n // spread. A quote that close to certain is far more likely to be a data\n // artifact (a field that wasn't populated this tick, coming through as\n // a near-zero placeholder) than a genuine quote.\n const pxQuote = (v, d) => {\n const raw = px(v, d);\n return raw != null && raw >= 0.005 && raw <= 0.995 ? raw : null;\n };\n const yesBid = pxQuote(m.yes_bid, m.yes_bid_dollars);\n const yesAsk = pxQuote(m.yes_ask, m.yes_ask_dollars);\n let noBid = pxQuote(m.no_bid, m.no_bid_dollars);\n let noAsk = pxQuote(m.no_ask, m.no_ask_dollars);\n if (noBid == null && yesAsk != null) noBid = 1 - yesAsk;\n if (noAsk == null && yesBid != null) noAsk = 1 - yesBid;\n const last = px(m.last_price, m.last_price_dollars); // a real trade CAN settle at exactly 0 or 1, unlike a live quote\n if (yesBid == null && yesAsk == null) {\n console.log(\n \"Kalshi bid/ask missing — raw fields:\",\n JSON.stringify({\n yes_bid: m.yes_bid,\n yes_ask: m.yes_ask,\n yes_bid_dollars: m.yes_bid_dollars,\n yes_ask_dollars: m.yes_ask_dollars,\n last_price: m.last_price,\n last_price_dollars: m.last_price_dollars,\n }),\n );\n }\n return {\n ok: true,\n ticker: m.ticker,\n strike: m.floor_strike ?? m.cap_strike ?? null,\n closeMs: m.closeMs,\n yesBid,\n yesAsk,\n noBid,\n noAsk,\n last,\n };\n } catch (e) {}\n }\n return { ok: false };\n}\n\nexport default async function (interval) {\n const now = Date.now();\n\n const ticks = (await blob.getJSON(\"btc_kalshi_ticks\")) || [];\n const lastKnownPrice = ticks.length ? ticks[ticks.length - 1].p : null;\n\n const price = await fetchBTC(lastKnownPrice);\n if (price == null) {\n console.log(\"tick skipped: no price source responded\");\n return;\n }\n\n ticks.push({ t: now, p: price });\n while (ticks.length > MAX_TICKS) ticks.shift();\n await blob.setJSON(\"btc_kalshi_ticks\", ticks);\n\n const rec = ticks.filter((t) => now - t.t <= VOL_LOOKBACK_MIN * 60000);\n let sigmaLn = 0.0005;\n if (rec.length > 5) {\n const rets = [];\n for (let i = 1; i < rec.length; i++) {\n const dtMin = (rec[i].t - rec[i - 1].t) / 60000;\n if (dtMin > 0) {\n rets.push(Math.log(rec[i].p / rec[i - 1].p) / Math.sqrt(dtMin));\n }\n }\n if (rets.length > 3) {\n const mean = rets.reduce((a, b) => a + b, 0) / rets.length;\n const v = rets.reduce((a, b) => a + (b - mean) ** 2, 0) / rets.length;\n const est = Math.sqrt(v);\n if (est > 0 && isFinite(est)) sigmaLn = Math.max(est, 0.00005);\n }\n }\n\n const pendingBefore = await blob.getJSON(\"btc_kalshi_pending\");\n const windowStillOpen = pendingBefore && now < pendingBefore.closeMs;\n const napFor = (ms) => new Promise((res) => setTimeout(res, ms));\n let kalshi = windowStillOpen\n ? await fetchKalshi(price, { requireTicker: pendingBefore.id })\n : await fetchKalshi(price, {});\n\n // Hold this invocation open until the new market appears, rather than\n // handing the window to a tick 60 seconds from now. Only worth doing near\n // the start of a window -- later in the window a missing market means\n // Kalshi is genuinely unreachable, and sleeping wouldn't help.\n const msIntoWindow = now % WINDOW_MS;\n let marketPolls = 0;\n if (\n !windowStillOpen && !(kalshi.ok && kalshi.strike != null) &&\n msIntoWindow < MARKET_WAIT_MS\n ) {\n const deadline = now + (MARKET_WAIT_MS - msIntoWindow);\n while (Date.now() < deadline) {\n await napFor(MARKET_POLL_MS);\n marketPolls++;\n kalshi = await fetchKalshi(price, {});\n if (kalshi.ok && kalshi.strike != null) break;\n }\n if (marketPolls) {\n console.log(\n `waited ${marketPolls} poll(s) for Kalshi to list this window — ` +\n (kalshi.ok && kalshi.strike != null\n ? `listed at +${Math.round((Date.now() % WINDOW_MS) / 1000)}s`\n : \"still not listed, giving up this tick\"),\n );\n }\n }\n\n const MOMENTUM_LOOKBACK_MIN = 15;\n let liveMomentumZ = null;\n {\n const target = now - MOMENTUM_LOOKBACK_MIN * 60000;\n let ref = null;\n for (let i = ticks.length - 1; i >= 0; i--) {\n if (ticks[i].t <= target) {\n ref = ticks[i];\n break;\n }\n }\n if (ref && ref.p > 0 && sigmaLn > 0) {\n const denom = sigmaLn * Math.sqrt(MOMENTUM_LOOKBACK_MIN);\n liveMomentumZ = Math.log(price / ref.p) / denom;\n }\n }\n\n // Forward-chaining walk-forward validation. Splits chronologically into\n // numFolds+1 chunks; for each fold, fits the best candidate using ONLY the\n // data up to that point, then measures the Brier improvement on the NEXT\n // chunk -- data the fit never touched. This is what tells you whether a\n // parameter generalizes, versus fitting and grading against the same data.\n function walkForwardBrierImprovement(\n entries,\n candidates,\n brierAtFn,\n baselineValue,\n numFolds,\n ) {\n const n = entries.length;\n const chunkSize = Math.floor(n / (numFolds + 1));\n if (chunkSize < 1) {\n return { folds: [], avgImprovement: -Infinity, positiveFolds: 0 };\n }\n const folds = [];\n for (let i = 1; i <= numFolds; i++) {\n const fitEnd = chunkSize * i;\n const valEnd = i === numFolds ? n : chunkSize * (i + 1);\n const fitSet = entries.slice(0, fitEnd);\n const valSet = entries.slice(fitEnd, valEnd);\n if (valSet.length < 5) continue;\n let bestVal = baselineValue,\n bestFitBrier = brierAtFn(fitSet, baselineValue);\n for (const c of candidates) {\n const b = brierAtFn(fitSet, c);\n if (b < bestFitBrier) {\n bestFitBrier = b;\n bestVal = c;\n }\n }\n const improvement = brierAtFn(valSet, baselineValue) -\n brierAtFn(valSet, bestVal);\n folds.push({\n fitN: fitSet.length,\n valN: valSet.length,\n fittedValue: bestVal,\n improvement,\n });\n }\n if (folds.length === 0) {\n return { folds: [], avgImprovement: -Infinity, positiveFolds: 0 };\n }\n const avgImprovement = folds.reduce((a, f) => a + f.improvement, 0) /\n folds.length;\n const positiveFolds = folds.filter((f) => f.improvement > 0).length;\n return { folds, avgImprovement, positiveFolds };\n }\n const WALK_FORWARD_FOLDS = 4;\n // Require the average out-of-sample improvement to clear the bar AND most\n // individual folds to be non-negative -- guards against one lucky fold\n // carrying three bad ones to a passing average.\n function walkForwardHoldsUp(wf, minImprovement) {\n return wf.folds.length > 0 &&\n wf.avgImprovement >= minImprovement &&\n wf.positiveFolds >= Math.ceil(wf.folds.length * 0.75);\n }\n\n const MOM_MIN_N = 600;\n const MOM_MIN_IMPROVEMENT = 0.008;\n const MOM_CANDIDATES = [];\n for (let w = -1.5; w <= 1.5001; w += 0.1) {\n MOM_CANDIDATES.push(Math.round(w * 100) / 100);\n }\n function computeMomentumWeight(entries) {\n const withBoth = entries.filter(\n (r) =>\n r.z != null && isFinite(r.z) && r.momentumZ != null &&\n isFinite(r.momentumZ),\n );\n if (withBoth.length < MOM_MIN_N) {\n return { w: 0, n: withBoth.length, active: false };\n }\n const brierAtSet = (set, w) => {\n let sum = 0;\n for (const r of set) {\n sum += (normCdf(r.z + w * r.momentumZ) - r.result) ** 2;\n }\n return sum / set.length;\n };\n const wf = walkForwardBrierImprovement(\n withBoth,\n MOM_CANDIDATES,\n brierAtSet,\n 0,\n WALK_FORWARD_FOLDS,\n );\n // The production weight is still fit on the FULL dataset -- walk-forward\n // decides WHETHER to trust that process, not what the number is.\n let bestW = 0, bestBrier = brierAtSet(withBoth, 0);\n for (const c of MOM_CANDIDATES) {\n const b = brierAtSet(withBoth, c);\n if (b < bestBrier) {\n bestBrier = b;\n bestW = c;\n }\n }\n if (!walkForwardHoldsUp(wf, MOM_MIN_IMPROVEMENT)) {\n return {\n w: 0,\n n: withBoth.length,\n active: false,\n wouldBeW: bestW,\n walkForward: wf,\n };\n }\n return { w: bestW, n: withBoth.length, active: true, walkForward: wf };\n }\n\n const CALIB_MIN_N = 300;\n const CALIB_MIN_IMPROVEMENT = 0.005;\n const CALIB_CANDIDATES = [];\n for (let k = 0.4; k <= 3.0001; k += 0.05) {\n CALIB_CANDIDATES.push(Math.round(k * 100) / 100);\n }\n function computeCalibration(effZEntries) {\n const withZ = effZEntries.filter((r) => r.effZ != null && isFinite(r.effZ));\n if (withZ.length < CALIB_MIN_N) {\n return { k: 1, n: withZ.length, active: false };\n }\n const brierAtSet = (set, k) => {\n let sum = 0;\n for (const r of set) sum += (normCdf(r.effZ / k) - r.result) ** 2;\n return sum / set.length;\n };\n const wf = walkForwardBrierImprovement(\n withZ,\n CALIB_CANDIDATES,\n brierAtSet,\n 1,\n WALK_FORWARD_FOLDS,\n );\n let bestK = 1, bestBrier = brierAtSet(withZ, 1);\n for (const c of CALIB_CANDIDATES) {\n const b = brierAtSet(withZ, c);\n if (b < bestBrier) {\n bestBrier = b;\n bestK = c;\n }\n }\n if (!walkForwardHoldsUp(wf, CALIB_MIN_IMPROVEMENT)) {\n return {\n k: 1,\n n: withZ.length,\n active: false,\n wouldBeK: bestK,\n walkForward: wf,\n };\n }\n return { k: bestK, n: withZ.length, active: true, walkForward: wf };\n }\n\n const WINDOW_DURATION_MS = 15 * 60 * 1000;\n\n function finalizeGrade(a, result, gradeSource) {\n const windowOpenMs = a.closeMs - WINDOW_DURATION_MS;\n return {\n ts: now,\n closeMs: a.closeMs,\n lockedAt: a.lockedAt != null ? a.lockedAt : null,\n lockLatencyMs: a.lockedAt != null ? a.lockedAt - windowOpenMs : null,\n strike: a.strike,\n strikeSource: a.strikeSource != null ? a.strikeSource : \"kalshi\",\n finalSpot: a.finalSpot != null ? a.finalSpot : null,\n // \"kalshi\" = Kalshi's own settled result, ground truth, no timing error.\n // \"spot\" = no settled result arrived and we fell back to our own price\n // comparison, which IS timing-sensitive near the strike.\n gradeSource,\n gradeLatencyMs: a.capturedAt != null ? a.capturedAt - a.closeMs : null,\n result,\n modelUp: a.modelUp,\n z: a.z != null ? a.z : null,\n momentumZ: a.momentumZ != null ? a.momentumZ : null,\n marketUp: a.marketUp,\n modelCorrect: (a.modelUp >= 0.5 ? 1 : 0) === result ? 1 : 0,\n marketCorrect: a.marketUp != null\n ? ((a.marketUp >= 0.5 ? 1 : 0) === result ? 1 : 0)\n : null,\n lockUpEV: a.upEV != null ? a.upEV : null,\n lockDownEV: a.downEV != null ? a.downEV : null,\n lockUpEVNet: a.upEVNet != null ? a.upEVNet : null,\n lockDownEVNet: a.downEVNet != null ? a.downEVNet : null,\n };\n }\n\n const awaiting = (await blob.getJSON(\"btc_kalshi_awaiting\")) || [];\n const stillAwaiting = [];\n const newlyGraded = [];\n let settleChecks = 0;\n let evicted = 0;\n for (const a of awaiting) {\n // A malformed entry can't be aged out by arithmetic, so treat an\n // unusable closeMs as infinitely old rather than never old.\n const age = a && isFinite(a.closeMs) ? now - a.closeMs : Infinity;\n let result = null, gradeSource = null;\n\n const isRealTicker = a && a.id && String(a.id).indexOf(\"auto-\") !== 0;\n if (isRealTicker && settleChecks < MAX_SETTLE_CHECKS_PER_TICK) {\n settleChecks++;\n const st = await fetchKalshiSettled(a.id);\n if (st.ok && st.settled) {\n result = st.result;\n gradeSource = \"kalshi\";\n }\n }\n // Only fall back to our own reading once Kalshi has had a fair chance.\n // Require a usable closeMs before grading: a record with a broken one\n // would be written into the log and then rejected by every downstream\n // filter anyway. Better to evict it than to store junk.\n if (\n result == null && isFinite(a && a.closeMs) && age > SETTLE_TIMEOUT_MS &&\n a.fallbackResult != null\n ) {\n result = a.fallbackResult;\n gradeSource = \"spot\";\n }\n\n if (result != null) {\n newlyGraded.push(finalizeGrade(a, result, gradeSource));\n continue;\n }\n // Unconditional exit. Nothing gets to hold a slot past this point.\n if (age > HARD_EVICT_MS) {\n evicted++;\n console.log(\n \"evicting unresolvable awaiting entry: \" +\n JSON.stringify({\n id: a && a.id,\n closeMs: a && a.closeMs,\n hasFallback: !!(a && a.fallbackResult != null),\n }),\n );\n continue;\n }\n stillAwaiting.push(a);\n }\n if (evicted) {\n console.log(\n `evicted ${evicted} stuck entr${\n evicted === 1 ? \"y\" : \"ies\"\n } from the settlement queue`,\n );\n }\n\n // The log is only read when something actually settled, or on a cold start.\n // It used to be read on EVERY tick purely to recompute calibration -- at\n // the 8000-record cap that would be megabytes of blob traffic every minute\n // for numbers that move very slowly.\n let log = null;\n if (newlyGraded.length) {\n log = (await blob.getJSON(\"btc_kalshi_log\")) || [];\n for (const g of newlyGraded) log.push(g);\n while (log.length > MAX_LOG) log.shift();\n await blob.setJSON(\"btc_kalshi_log\", log);\n console.log(\n `graded ${newlyGraded.length} window(s) — ` +\n newlyGraded.map((g) => `${g.gradeSource}:${g.result ? \"UP\" : \"DOWN\"}`)\n .join(\", \"),\n );\n }\n\n let calib = await blob.getJSON(\"btc_kalshi_calibration\");\n let mom = await blob.getJSON(\"btc_kalshi_momentum\");\n if (newlyGraded.length || !calib || !mom) {\n if (!log) log = (await blob.getJSON(\"btc_kalshi_log\")) || [];\n mom = computeMomentumWeight(log);\n const effZEntries = log.map((r) => ({\n effZ: r.z != null\n ? r.z + mom.w * (r.momentumZ != null ? r.momentumZ : 0)\n : null,\n result: r.result,\n }));\n calib = computeCalibration(effZEntries);\n await blob.setJSON(\"btc_kalshi_calibration\", calib);\n await blob.setJSON(\"btc_kalshi_momentum\", mom);\n }\n\n // Only a real, published Kalshi market gives a real strike to predict\n // against. The old fallback INVENTED one (strike = current spot), which\n // made ln(price/strike) = ln(1) = 0, forcing modelUp to exactly 50.0% every\n // time -- a guaranteed non-prediction dressed up as a call.\n const haveRealMarket = kalshi.ok && kalshi.strike != null;\n const currentId = windowStillOpen\n ? pendingBefore.id\n : haveRealMarket\n ? kalshi.ticker\n : null;\n const currentCloseMs = windowStillOpen\n ? pendingBefore.closeMs\n : haveRealMarket\n ? kalshi.closeMs\n : null;\n const currentStrike = windowStillOpen\n ? pendingBefore.strike\n : haveRealMarket\n ? kalshi.strike\n : null;\n const currentStrikeSource = windowStillOpen\n ? pendingBefore.strikeSource\n : haveRealMarket\n ? \"kalshi\"\n : null;\n\n function num(x) {\n if (x == null) return null;\n const n = Number(x);\n return isFinite(n) ? n : null;\n }\n function estimateMarketUp(k) {\n if (!k.ok) return null;\n const yb = num(k.yesBid),\n ya = num(k.yesAsk),\n nb = num(k.noBid),\n na = num(k.noAsk),\n ls = num(k.last);\n if (yb != null && ya != null) return (yb + ya) / 2;\n if (ya != null && na != null && ya + na > 0) return ya / (ya + na);\n if (yb != null && nb != null && yb + nb > 0) return yb / (yb + nb);\n if (ya != null) return ya;\n if (yb != null) return yb;\n if (na != null) return 1 - na;\n if (nb != null) return 1 - nb;\n if (ls != null) return ls;\n return null;\n }\n const currentMarketUp = estimateMarketUp(kalshi);\n if (kalshi.ok && currentMarketUp == null) {\n console.log(\n \"marketUp still null despite kalshi.ok — raw fields:\",\n JSON.stringify({\n yesBid: kalshi.yesBid,\n yesAsk: kalshi.yesAsk,\n noBid: kalshi.noBid,\n noAsk: kalshi.noAsk,\n last: kalshi.last,\n }),\n );\n }\n const currentYesAsk = kalshi.ok ? kalshi.yesAsk : null;\n const currentNoAsk = kalshi.ok ? kalshi.noAsk : null;\n\n // All of these stay null while we're waiting on a real market -- there is\n // genuinely nothing to predict against yet, and reporting a number here\n // would just be the old fake-50% behaviour by another route.\n const liveTimeLeftMin = currentCloseMs != null\n ? Math.max(0, (currentCloseMs - now) / 60000)\n : null;\n let liveZ = null, liveModelUp = null, liveUpEV = null, liveDownEV = null;\n let liveUpEVNet = null, liveDownEVNet = null;\n if (currentStrike != null && liveTimeLeftMin != null) {\n liveZ = liveTimeLeftMin > 0\n ? Math.log(price / currentStrike) / (sigmaLn * Math.sqrt(liveTimeLeftMin))\n : price >= currentStrike\n ? 8\n : -8;\n const liveCombinedZ = liveZ +\n mom.w * (liveMomentumZ != null ? liveMomentumZ : 0);\n liveModelUp = normCdf(liveCombinedZ / calib.k);\n liveUpEV = currentYesAsk != null ? liveModelUp - currentYesAsk : null;\n liveDownEV = currentNoAsk != null ? 1 - liveModelUp - currentNoAsk : null;\n // What you'd actually keep after Kalshi's fee. The gross figures ignored\n // fees entirely, overstating every signal by ~1.75c at mid-range prices.\n liveUpEVNet = netEV(liveUpEV, currentYesAsk);\n liveDownEVNet = netEV(liveDownEV, currentNoAsk);\n }\n\n let pending = pendingBefore;\n\n if (\n pending &&\n (now >= pending.closeMs || (currentId != null && pending.id !== currentId))\n ) {\n // We no longer decide the outcome here. Park the round and ask Kalshi for\n // its official settled result on a later tick. The spot reading is kept\n // only as a fallback for the case where that never arrives.\n stillAwaiting.push({\n id: pending.id,\n closeMs: pending.closeMs,\n lockedAt: pending.lockedAt != null ? pending.lockedAt : null,\n strike: pending.strike,\n strikeSource: pending.strikeSource,\n modelUp: pending.modelUp,\n z: pending.z,\n momentumZ: pending.momentumZ,\n marketUp: pending.marketUp,\n upEV: pending.upEV,\n downEV: pending.downEV,\n upEVNet: pending.upEVNet,\n downEVNet: pending.downEVNet,\n fallbackResult: price >= pending.strike ? 1 : 0,\n finalSpot: price,\n capturedAt: now,\n });\n pending = null;\n }\n\n const readyToLock = currentId != null &&\n (!pending || pending.id !== currentId);\n\n if (readyToLock) {\n pending = {\n id: currentId,\n closeMs: currentCloseMs,\n strike: currentStrike,\n strikeSource: currentStrikeSource,\n modelUp: liveModelUp,\n z: liveZ,\n momentumZ: liveMomentumZ,\n marketUp: currentMarketUp,\n yesAsk: currentYesAsk,\n noAsk: currentNoAsk,\n upEV: liveUpEV,\n downEV: liveDownEV,\n upEVNet: liveUpEVNet,\n downEVNet: liveDownEVNet,\n // Real wall-clock time of the lock. Using the tick's start time would\n // hide the seconds spent waiting above and understate the latency.\n lockedAt: Date.now(),\n };\n }\n // Always write, INCLUDING when pending is null. This previously only wrote\n // on a truthy value, which was safe only because the old fallback\n // guaranteed a new window was re-locked on the same tick.\n await blob.setJSON(\"btc_kalshi_pending\", pending);\n while (stillAwaiting.length > MAX_AWAITING) {\n const lost = stillAwaiting.shift();\n console.log(\n \"settlement queue over capacity, dropping oldest: \" +\n JSON.stringify({ id: lost && lost.id, closeMs: lost && lost.closeMs }),\n );\n }\n await blob.setJSON(\"btc_kalshi_awaiting\", stillAwaiting);\n\n await blob.setJSON(\"btc_kalshi_latest\", {\n now,\n price,\n strike: pending ? pending.strike : currentStrike,\n strikeSource: pending ? pending.strikeSource : currentStrikeSource,\n closeMs: pending ? pending.closeMs : currentCloseMs,\n // True when no window is locked because Kalshi hasn't published the new\n // market yet -- lets the dashboard say so plainly.\n waitingForMarket: !pending && !haveRealMarket,\n modelUp: liveModelUp,\n marketUp: currentMarketUp,\n lockedModelUp: pending ? pending.modelUp : null,\n lockedMarketUp: pending ? pending.marketUp : null,\n lockedUpEV: pending ? pending.upEV : null,\n lockedDownEV: pending ? pending.downEV : null,\n lockedUpEVNet: pending ? pending.upEVNet : null,\n lockedDownEVNet: pending ? pending.downEVNet : null,\n lockedAt: pending ? pending.lockedAt : null,\n yesAsk: currentYesAsk,\n noAsk: currentNoAsk,\n upEV: liveUpEV,\n downEV: liveDownEV,\n upEVNet: liveUpEVNet,\n downEVNet: liveDownEVNet,\n awaitingSettlement: stillAwaiting.length,\n awaitingOldestMin: stillAwaiting.length\n ? Math.round(\n Math.max.apply(\n null,\n stillAwaiting.map((a) => (isFinite(a.closeMs) ? now - a.closeMs : 0)),\n ) / 60000,\n )\n : 0,\n marketPolls,\n sigmaLn,\n calibK: calib.k,\n calibN: calib.n,\n calibActive: calib.active,\n momW: mom.w,\n momN: mom.n,\n momActive: mom.active,\n kalshiOk: kalshi.ok,\n kalshiTicker: kalshi.ok ? kalshi.ticker : null,\n });\n\n const shownStrike = pending ? pending.strike : currentStrike;\n console.log(\n `[${CRON_VERSION}] $${price.toFixed(2)} · ` +\n (shownStrike != null\n ? `strike $${shownStrike.toFixed(2)} (${\n pending ? pending.strikeSource : currentStrikeSource\n }) · `\n : `no strike yet — waiting for Kalshi to publish this window's market · `) +\n (liveModelUp != null\n ? `live modelUp ${(liveModelUp * 100).toFixed(1)}%`\n : \"live modelUp: n/a\") +\n (currentMarketUp != null\n ? ` · live marketUp ${(currentMarketUp * 100).toFixed(1)}%`\n : \" · live marketUp: null\") +\n ` · queue ${stillAwaiting.length}` +\n (marketPolls ? ` · waited ${marketPolls} poll(s)` : \"\") +\n (pending\n ? ` · [locked for grading: modelUp ${\n (pending.modelUp * 100).toFixed(1)\n }%` +\n (pending.marketUp != null\n ? `, marketUp ${(pending.marketUp * 100).toFixed(1)}%`\n : \"\") +\n `]`\n : \" · [nothing locked — no real market to lock against yet]\"),\n );\n}","deleted","label",[109],"6a5d4998-7df5-4f73-b3d7-b83fde009d82","README.md","d2c72b4a-8482-11f1-b043-1607ee4eb77e",9,["D",1784583284189],"# Btc15min",[127],"pulls","branches",1,"forks","envVars",{"_141":40,"_143":40},"connections",{"_141":40,"_142":40},"count","unfilledCount","emptyCount",{"_18":126,"_20":127,"_110":128,"_112":-5,"_113":66,"_114":129,"_115":116,"_22":150,"_63":40,"_119":95,"_121":131,"_123":26,"_124":-5,"_147":151,"_84":152},{"_18":108,"_20":109,"_110":111,"_112":-5,"_113":66,"_114":64,"_115":116,"_22":146,"_63":118,"_119":120,"_121":122,"_123":26,"_124":-5,"_147":148,"_84":149},["D",1788704728937],"children",[],[109],["D",1784583284189],[],[127],["D",1784564217723],{"_16":17,"_82":78},{"_16":17,"_75":76,"_77":78,"_33":34,"_79":80,"_81":26},{"_63":64,"_20":65,"_18":66,"_67":19,"_68":-5,"_69":-5,"_70":-5,"_71":-5,"_72":-5,"_73":21,"_74":17},"ctx",{"_56":-5,"_103":190,"_191":192,"_193":194,"_195":26,"_196":26,"_197":26,"_198":116,"_199":-5,"_200":-7,"_201":-7,"_202":40,"_203":26,"_204":26,"_205":-5,"_206":26,"_207":26,"_208":26,"_209":-5},"ENV",{"_161":162,"_163":164,"_165":65,"_166":167,"_168":169,"_170":171,"_172":173,"_174":175,"_176":177,"_178":179,"_180":181,"_182":183,"_184":185,"_186":187,"_188":189},"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"]

Search