monitor error: ${String(e)}

`, {\n status: 500,\n headers: { \"content-type\": \"text/html; charset=utf-8\" },\n });\n }\n}\n",[],[357],"78c94703-df83-49a7-a1c8-0f3b8f7a1bea","llm-match.ts","ee9eef84-b258-11f1-9951-1607ee4eb77e",44,["D",1789623249708],"// llm-match.ts — the LLM judge tier of the market matcher.\n//\n// The deterministic layer (matcher.ts) scans ~27k Kalshi markets for free and\n// hands over a short candidate list. This module asks a small, cheap model one\n// narrow question per Polymarket market: which candidate refers to the same\n// real-world event, and what KIND of relationship is it?\n//\n// Design notes:\n// - PROVIDER-AGNOSTIC. \"valtown\" uses Val Town's built-in OpenAI proxy: no API\n// key, no billing, nano-class model, ~10 requests/min. \"anthropic\" uses\n// Claude Haiku and needs ANTHROPIC_API_KEY. Default is valtown (free); if the\n// key exists, anthropic is preferred. Set explicitly to A/B the two.\n// - GRADED, not binary. A Kalshi market that isn't identical can still inform\n// us. \"same\" = tradeable 1:1. \"nested\" = a sub-option or threshold inside the\n// same question, still directly informative. \"proxy\" = correlated but\n// materially different, corroboration only, never a literal price\n// comparison. \"unrelated\" = drop.\n// - Reports SIDE ALIGNMENT (does Kalshi YES mean the same thing as Polymarket\n// YES), which is what lets us compute an honest price gap.\n// - It NEVER decides a trade. It classifies markets. The deterministic layer\n// still owns every trading decision.\n// - Degrades safely: any failure returns null and the caller falls back to\n// deterministic-only matching.\n// - Judgments are cached in SQLite (keyed by provider) so repeated 6h runs\n// don't re-pay, and so the two providers can be compared on the same pairs.\n\nimport { sqlite } from \"https://esm.town/v/std/sqlite/main.ts\";\nimport type { KMarket } from \"./matcher.ts\";\n\nconst HAIKU = \"claude-haiku-4-5-20251001\";\nconst NANO = \"gpt-4.5-nano\";\nconst ANTHROPIC_API = \"https://api.anthropic.com/v1/messages\";\nconst CACHE_TABLE = \"match_cache\";\n\nexport type Provider = \"valtown\" | \"anthropic\";\nexport type Relation = \"same\" | \"nested\" | \"proxy\" | \"unrelated\";\n\nexport interface Judgment {\n best: number | null; // 1-based index into the candidate list, or null\n relation: Relation;\n confidence: number; // 0..1\n aligned: boolean | null; // does Kalshi YES == Polymarket YES?\n reason: string;\n provider?: Provider;\n cached?: boolean;\n}\n\nconst SYSTEM = `You match prediction markets across two venues (Polymarket and Kalshi).\nGiven one Polymarket question and numbered Kalshi candidate markets, pick the candidate that refers to the same underlying real-world event and classify the relationship.\n\nRelations:\n- \"same\": identical question AND resolution criteria. A position in one is economically equivalent to a position in the other.\n- \"nested\": the same broader question, but one side is a specific sub-option, threshold, bracket, or component of the other (e.g. a specific rate band inside a rate decision, or one party's outcome inside a control-of-chamber market). Directly informative.\n- \"proxy\": correlated but materially different question — different entity, different bar, different mechanism, or a comparative/\"which happens first\" framing. Useful only as soft corroboration, never as a literal price comparison.\n- \"unrelated\": no useful relationship.\n\nAlso report side alignment: does the Kalshi market's YES outcome mean the same real-world outcome as the Polymarket question's YES? true if yes, false if it is inverted, null if unclear or unrelated.\n\nBe strict about \"same\". If resolution criteria or dates could differ, use \"nested\" or \"proxy\".\n\nRespond with ONLY a JSON object, no prose, no code fences:\n{\"best\": <1-based number or null>, \"relation\": \"same\"|\"nested\"|\"proxy\"|\"unrelated\", \"confidence\": <0..1>, \"aligned\": true|false|null, \"reason\": \"\"}`;\n\nfunction hash(s: string): string {\n let h = 5381;\n for (let i = 0; i < s.length; i++) h = ((h << 5) + h + s.charCodeAt(i)) | 0;\n return (h >>> 0).toString(36);\n}\n\nexport function hasAnthropicKey(): boolean {\n return Boolean(Deno.env.get(\"ANTHROPIC_API_KEY\"));\n}\n\n// Free built-in proxy by default; upgrade to Haiku automatically if a key exists.\nexport function defaultProvider(): Provider {\n return hasAnthropicKey() ? \"anthropic\" : \"valtown\";\n}\n\nasync function ensureCache(): Promise {\n await sqlite.execute(\n `CREATE TABLE IF NOT EXISTS ${CACHE_TABLE} (k TEXT PRIMARY KEY, json TEXT NOT NULL, ts TEXT NOT NULL)`,\n );\n}\n\nfunction parseJudgment(text: string): Judgment | null {\n const m = text.match(/\\{[\\s\\S]*\\}/); // tolerate stray prose or code fences\n if (!m) return null;\n try {\n const o = JSON.parse(m[0]);\n const rel = [\"same\", \"nested\", \"proxy\", \"unrelated\"].includes(o.relation) ? o.relation as Relation : \"unrelated\";\n return {\n best: typeof o.best === \"number\" ? o.best : null,\n relation: rel,\n confidence: typeof o.confidence === \"number\" ? Math.max(0, Math.min(1, o.confidence)) : 0,\n aligned: o.aligned === true ? true : o.aligned === false ? false : null,\n reason: typeof o.reason === \"string\" ? o.reason.slice(0, 200) : \"\",\n };\n } catch {\n return null;\n }\n}\n\nasync function callAnthropic(user: string): Promise {\n const key = Deno.env.get(\"ANTHROPIC_API_KEY\");\n if (!key) return null;\n try {\n const res = await fetch(ANTHROPIC_API, {\n method: \"POST\",\n headers: { \"x-api-key\": key, \"anthropic-version\": \"2023-06-01\", \"content-type\": \"application/json\" },\n body: JSON.stringify({\n model: HAIKU,\n max_tokens: 300,\n temperature: 0,\n system: SYSTEM,\n messages: [{ role: \"user\", content: user }],\n }),\n signal: AbortSignal.timeout(20000),\n });\n if (!res.ok) return null;\n const j = await res.json();\n return (j.content ?? []).map((b: any) => b?.text ?? \"\").join(\"\");\n } catch {\n return null;\n }\n}\n\n// Val Town's built-in OpenAI proxy: no API key required.\n// Rate limited (~10 req/min), so callers should throttle and lean on the cache.\nasync function callValtown(user: string): Promise {\n try {\n const { OpenAI } = await import(\"https://esm.town/v/std/openai/main.ts\");\n const openai = new OpenAI();\n const completion = await openai.chat.completions.create({\n model: NANO,\n max_completion_tokens: 300,\n messages: [\n { role: \"system\", content: SYSTEM },\n { role: \"user\", content: user },\n ],\n });\n return completion.choices?.[0]?.message?.content ?? null;\n } catch {\n return null;\n }\n}\n\n// Judge one Polymarket market against its candidate shortlist.\n// Returns null if the model is unavailable or the call fails — callers must\n// fall back to deterministic matching rather than treating null as \"unrelated\".\nexport async function judge(\n polyText: string,\n cands: KMarket[],\n opts: { useCache?: boolean; provider?: Provider } = {},\n): Promise {\n if (cands.length === 0) return null;\n const provider = opts.provider ?? defaultProvider();\n const useCache = opts.useCache !== false;\n\n const listing = cands.map((k, i) => `${i + 1}. ${k.text}`).join(\"\\n\");\n const user = `Polymarket question:\\n${polyText}\\n\\nKalshi candidates:\\n${listing}`;\n const cacheKey = provider + \":\" + hash(polyText + \"||\" + cands.map((c) => c.ticker).join(\",\"));\n\n if (useCache) {\n try {\n await ensureCache();\n const r = await sqlite.execute({ sql: `SELECT json FROM ${CACHE_TABLE} WHERE k = ?`, args: [cacheKey] });\n const row = r.rows?.[0] as any;\n if (row) {\n const raw = typeof row === \"object\" && \"json\" in row ? row.json : row[0];\n return { ...JSON.parse(raw), provider, cached: true };\n }\n } catch {\n // cache is best-effort\n }\n }\n\n const text = provider === \"anthropic\" ? await callAnthropic(user) : await callValtown(user);\n if (!text) return null;\n\n const verdict = parseJudgment(text);\n if (!verdict) return null;\n if (verdict.best != null && (verdict.best < 1 || verdict.best > cands.length)) verdict.best = null;\n verdict.provider = provider;\n\n if (useCache) {\n try {\n await sqlite.execute({\n sql: `INSERT OR REPLACE INTO ${CACHE_TABLE} (k, json, ts) VALUES (?, ?, ?)`,\n args: [cacheKey, JSON.stringify(verdict), new Date().toISOString()],\n });\n } catch {\n // best-effort\n }\n }\n return verdict;\n}\n",[],[363],"7c479c6c-2ac5-49b5-9a73-7f27336a3447","lib.ts","e740e4c2-b217-11f1-aacd-1607ee4eb77e",["D",1789595115886],"// lib.ts — shared logic for the live prediction-market monitor (detect-only).\n// Fetches public Kalshi + Polymarket data, runs fee-aware detection and a\n// predicate/subject/year-aware cross-venue matcher, and renders the dashboard.\n// No account, no keys, no orders. Reads public prices only.\n\nconst STOP = new Set(\n \"a an the of to in on for and or is are be will who what which when where by at as this that it who's whos then do does did have has had not no s\"\n .split(\" \"),\n);\n// Generic words shared across many markets — NOT distinctive. Includes role\n// words (prime minister, chancellor, ceo, ...) so \"next Prime Minister of X\"\n// only matches on the country/person, never on the shared role.\nconst GENERIC = new Set(\n \"democratic democrat republican gop presidential president vice vp nomination nominee nominated election elect electoral senate senator house congress governor gubernatorial mayor mayoral party primary race win wins winner won run runs running candidate candidacy next control chamber seat margin victory popular vote general ticket secretary attorney prime minister chancellor premier king queen pope ceo chairman chair leader head monarch state states us united 2024 2025 2026 2027 2028 2029 2030 before after during term season game match team cup league\"\n .split(\" \"),\n);\nconst WIN = new Set([\"win\", \"wins\", \"winner\", \"won\"]);\nconst RUN = new Set([\"run\", \"runs\", \"running\", \"candidate\", \"candidacy\", \"enter\", \"declare\", \"announce\", \"launch\"]);\nconst RETIRE = new Set([\"retire\", \"retires\", \"retirement\"]);\n// If a Polymarket \"will X WIN\" question is matched to Kalshi, the Kalshi side\n// must be a selection market (contain one of these), else it's a different bet.\nconst SELECTION = new Set([\"nominee\", \"nominated\", \"nomination\", \"winner\", \"win\", \"wins\", \"won\", \"election\", \"elected\"]);\n\nconst KALSHI_EVENTS = \"https://external-api.kalshi.com/trade-api/v2/events?limit=200&status=open&with_nested_markets=true\";\n\nfunction fnum(x: unknown): number {\n const n = parseFloat(String(x));\n return Number.isFinite(n) ? n : 0;\n}\nfunction fee(p: number): number {\n return p > 0 && p < 1 ? 0.07 * p * (1 - p) : 0;\n}\nfunction tok(text: string): string[] {\n return (text || \"\").toLowerCase().match(/[a-z0-9]+/g)?.filter((w) => !STOP.has(w) && w.length >= 2) ?? [];\n}\nfunction subjects(toks: string[]): Set {\n return new Set(toks.filter((w) => !GENERIC.has(w) && w.length >= 3 && !/^(19|20)\\d\\d$/.test(w)));\n}\nfunction years(toks: string[]): Set {\n return new Set(toks.filter((w) => /^(19|20)\\d\\d$/.test(w)));\n}\nfunction action(toks: string[]): string {\n const s = new Set(toks);\n const has = (g: Set) => [...g].some((w) => s.has(w));\n if (has(RETIRE)) return \"RETIRE\";\n if (has(WIN) && !has(RUN)) return \"WIN\";\n if (has(RUN) && !has(WIN)) return \"RUN\";\n return \"UNKNOWN\";\n}\nfunction inter(a: Set, b: Set): number {\n let n = 0;\n for (const x of a) if (b.has(x)) n++;\n return n;\n}\nfunction overlap(a: string[], b: string[]): number {\n const A = new Set(a), B = new Set(b);\n const m = Math.min(A.size, B.size);\n return m ? inter(A, B) / m : 0;\n}\n\nasync function getJson(url: string): Promise {\n const r = await fetch(url, { headers: { \"User-Agent\": \"predmarket-monitor/1.0\" } });\n if (!r.ok) throw new Error(`${url} -> ${r.status}`);\n return r.json();\n}\n\nexport interface KBinary {\n text: string; tok: string[]; subj: Set; yr: Set; act: string;\n yes_ask: number; no_ask: number; vol: number;\n}\nexport interface NetLock { title: string; n: number; lock_net: number; vol: number; }\nexport interface PolyMkt { q: string; subj: Set; yr: Set; act: string; tok: string[]; yes: number; no: number; }\nexport interface Lead { q: string; k: string; score: number; net: number; side: string; }\n\nasync function fetchKalshi(pages: number): Promise<{ binaries: KBinary[]; netLocks: NetLock[] }> {\n const binaries: KBinary[] = [];\n const netLocks: NetLock[] = [];\n let cursor: string | undefined;\n for (let p = 0; p < pages; p++) {\n const data = await getJson(KALSHI_EVENTS + (cursor ? \"&cursor=\" + cursor : \"\"));\n for (const ev of data.events ?? []) {\n const title: string = ev.title ?? \"\";\n const me = Boolean(ev.mutually_exclusive);\n const outs: { ya: number; na: number }[] = [];\n for (const m of ev.markets ?? []) {\n const ya = fnum(m.yes_ask_dollars), na = fnum(m.no_ask_dollars), mv = fnum(m.volume_fp);\n if (me && ya > 0 && ya < 1 && na > 0 && na < 1) outs.push({ ya, na });\n if (mv > 0 && ya > 0 && ya < 1 && na > 0 && na < 1) {\n const sub = m.yes_sub_title || m.subtitle || \"\";\n const text = (title + \" \" + sub).trim();\n const t = tok(text);\n binaries.push({ text, tok: t, subj: subjects(t), yr: years(t), act: action(t), yes_ask: ya, no_ask: na, vol: mv });\n }\n }\n if (me && outs.length >= 2) {\n const n = outs.length;\n const lockGross = (n - 1) - outs.reduce((s, o) => s + o.na, 0);\n const lockNet = lockGross - outs.reduce((s, o) => s + fee(o.na), 0);\n if (lockNet > 0) netLocks.push({ title, n, lock_net: lockNet, vol: ev.markets?.reduce((s: number, m: any) => s + fnum(m.volume_fp), 0) ?? 0 });\n }\n }\n cursor = data.cursor;\n if (!cursor) break;\n }\n netLocks.sort((a, b) => b.lock_net - a.lock_net);\n return { binaries, netLocks };\n}\n\nasync function fetchPoly(): Promise {\n const url = \"https://gamma-api.polymarket.com/markets?limit=250&active=true&closed=false&order=volumeNum&ascending=false\";\n const rows = await getJson(url);\n const list = Array.isArray(rows) ? rows : (rows.data ?? []);\n const out: PolyMkt[] = [];\n for (const m of list) {\n let outs: string[], prices: number[];\n try { outs = JSON.parse(m.outcomes ?? \"[]\"); prices = (JSON.parse(m.outcomePrices ?? \"[]\") as string[]).map(Number); }\n catch { continue; }\n const low = outs.map((o) => String(o).toLowerCase());\n if (low.includes(\"yes\") && low.includes(\"no\") && prices.length === outs.length) {\n const q = m.question ?? \"\";\n const t = tok(q);\n out.push({ q, subj: subjects(t), yr: years(t), act: action(t), tok: t, yes: prices[low.indexOf(\"yes\")], no: prices[low.indexOf(\"no\")] });\n }\n }\n return out;\n}\n\nfunction crossMatch(binaries: KBinary[], poly: PolyMkt[]): Lead[] {\n const index = new Map();\n for (const k of binaries) for (const s of k.subj) (index.get(s) ?? index.set(s, []).get(s)!).push(k);\n const leads: Lead[] = [];\n for (const p of poly) {\n if (p.subj.size < 2) continue;\n const seen = new Set();\n const cands: KBinary[] = [];\n for (const s of p.subj) for (const k of index.get(s) ?? []) if (!seen.has(k)) { seen.add(k); cands.push(k); }\n let best: KBinary | null = null, bestScore = 0;\n for (const k of cands) {\n if (inter(p.subj, k.subj) < 2) continue; // >=2 shared distinctive words\n if ([\"WIN\", \"RUN\", \"RETIRE\"].includes(p.act) && [\"WIN\", \"RUN\", \"RETIRE\"].includes(k.act) && p.act !== k.act) continue;\n if (p.yr.size && k.yr.size && inter(p.yr, k.yr) === 0) continue; // year conflict\n if (p.act === \"WIN\" && !k.tok.some((w) => SELECTION.has(w))) continue; // WIN must match a selection market\n const sc = overlap(p.tok, k.tok);\n if (sc > bestScore) { best = k; bestScore = sc; }\n }\n if (best && bestScore >= 0.5) {\n const netA = 1 - (best.yes_ask + p.no) - fee(best.yes_ask);\n const netB = 1 - (p.yes + best.no_ask) - fee(best.no_ask);\n const [net, side] = netA >= netB ? [netA, \"Kalshi YES + Poly NO\"] : [netB, \"Poly YES + Kalshi NO\"];\n leads.push({ q: p.q, k: best.text, score: bestScore, net, side });\n }\n }\n return leads.sort((a, b) => b.net - a.net);\n}\n\nexport interface MonitorData {\n stamp: string; kalshiCount: number; polyCount: number; netLocks: NetLock[]; leads: Lead[];\n}\n\nexport async function compute(pages = 4): Promise {\n const [{ binaries, netLocks }, poly] = await Promise.all([fetchKalshi(pages), fetchPoly()]);\n const leads = crossMatch(binaries, poly);\n return {\n stamp: new Date().toISOString().replace(\"T\", \" \").slice(0, 19) + \" UTC\",\n kalshiCount: binaries.length, polyCount: poly.length, netLocks, leads,\n };\n}\n\n// Leads worth an email alert: net edge above threshold. Conservative to avoid spam.\nexport function strongLeads(d: MonitorData, minNet = 0.03): Lead[] {\n return d.leads.filter((l) => l.net >= minNet);\n}\n\nconst esc = (s: string) => String(s).replace(/[&<>\"]/g, (c) => ({ \"&\": \"&\", \"<\": \"<\", \">\": \">\", '\"': \""\" }[c]!));\nconst c = (x: number) => (x >= 0 ? \"+\" : \"\") + (x * 100).toFixed(1) + \"c\";\n\nexport function renderDashboard(d: MonitorData, refresh = 60): string {\n const posLeads = d.leads.filter((l) => l.net > 0);\n const tiles = [\n [d.kalshiCount, \"Kalshi markets\"], [d.polyCount, \"Polymarket markets\"],\n [d.leads.length, \"cross-venue matches\"], [posLeads.length, \"net-positive leads\"],\n ].map(([n, l]) => `

${n}

${l}

`).join(\"\");\n\n const leadRows = d.leads.slice(0, 25).map((l) => {\n const cls = l.net > 0 ? \"pos\" : \"neg\";\n const pill = l.net > 0 ? 'lead' : \"\";\n return `${esc(l.q.slice(0, 62))}
${esc(l.k.slice(0, 62))}` +\n `${l.score.toFixed(2)}${c(l.net)}${esc(l.side)}${pill}`;\n }).join(\"\");\n const leadsHtml = d.leads.length\n ? `${leadRows}

Matched pair (Polymarket / Kalshi)	Match	Net edge	Construction

`\n : '

No confident cross-venue matches this cycle.

';\n\n const locksHtml = d.netLocks.length\n ? `${d.netLocks.slice(0, 10).map((m) => ``).join(\"\")}

Event	Outcomes	Net edge
${esc(m.title.slice(0, 60))}	${m.n}	${c(m.lock_net)}

`\n : '

No single-venue lock clears fees this cycle. Normal and expected.

';\n\n return `\n\n\nLive Prediction Market Monitor

Live Prediction Market Monitor

Detect-only, hosted on Val Town. Auto-refreshing every ${refresh}s. Last updated ${esc(d.stamp)}.

${tiles}

Cross-venue leads (Kalshi vs Polymarket)

Same-bet matches with a positive net-of-fees edge. UNVERIFIED leads: confirm identical resolution + date, use executable order-book prices, and check you can trade the Polymarket side as a US resident before trusting any of these.

\n${leadsHtml}

Single-venue locks (Kalshi, fee-aware)

Mutually-exclusive events whose sell-side edge survives estimated fees.

\n${locksHtml}

Live public-data monitor. It only reads; it never trades. Cross-venue edges use indicative Polymarket prices, not executable order-book asks.

`;\n}\n",[],[371],"9ce594b4-8bb1-4cb3-b769-5afafe84045f","lead-sweep.ts","7a24b5c2-b2ed-11f1-9b9d-1607ee4eb77e",216,["D",1789696459484],16,"import { sqlite } from \"https://esm.town/v/std/sqlite/main.ts\";\nimport { study } from \"./reprice.tsx\";\n\n// lead-sweep.ts — background accumulator for the Pillar 3 lead/lag study.\n//\n// WHY A SWEEPER AND NOT A REQUEST: GDELT allows one request every 5 seconds,\n// takes ~15s to answer, and Val Town egresses from a SHARED IP pool, so other\n// tenants' traffic throttles us as well. Measured behaviour: most synchronous\n// attempts come back 429 even after waiting 45 seconds. That makes an\n// on-demand endpoint useless as a research instrument, and it makes a\n// background job that tries often, keeps what succeeds and forgets what does\n// not exactly the right shape. Flakiness stops being a blocker the moment\n// nobody is waiting on any single call.\n//\n// One watchlist row per run, on purpose: it stays inside the time budget and\n// it does not hammer a source that has already asked us to slow down.\n//\n// It measures with the SAME `study()` the HTTP endpoint uses. A sweeper that\n// reimplements the metric is a sweeper that quietly measures something else.\n\nconst GAMMA = \"https://gamma-api.polymarket.com\";\nconst WATCHLIST_MAX = 25;\nconst REFRESH_AFTER_H = 24;\n\n// Sports markets are driven by a schedule and a scoreboard, not by information\n// arriving. Including them would flood the watchlist (there is an NFL market\n// every week) and measure nothing about a catalyst pillar.\nconst SPORTS = /\\bvs\\.?\\b|\\bnfl\\b|\\bnba\\b|\\bmlb\\b|\\bnhl\\b|uefa|champions league|premier league|ncaa|super bowl|world series/i;\n\nconst STOP = new Set(\n (\"will the be in by on at of to a an and or for from with any more than that this it its no not before after\"\n + \" win wins won lose loses reach hit above below between during through into out up down\"\n + \" market resolve resolves resolved yes maybe who what when which how many much other else\"\n + \" us u.s united states president new next year month week day end\"\n // Month names are capitalised and appear in almost every market title\n // (\"...by December 31?\"), so without this they win the proper-noun contest\n // and the sweeper searches the news for \"December\".\n + \" january february march april may june july august september october november december\"\n // Role and office words. Capitalised in every title, and they form long\n // generic phrases that beat the actual subject on length: \"Prime Minister\n // of Sweden\" outranked \"Magdalena Andersson\", which is both narrower as an\n // exact phrase and less like what coverage of her would say.\n + \" prime minister chancellor governor senator secretary mayor premier king queen pope\").split(/\\s+/),\n);\n\n// Lowercase words that belong INSIDE a name: \"Strait of Hormuz\", \"Lula da\n// Silva\". Breaking a run on these turned \"Strait of Hormuz\" into \"Strait\".\nconst CONNECTORS = new Set([\"of\", \"de\", \"da\", \"del\", \"der\", \"van\", \"von\", \"la\", \"le\", \"el\", \"bin\", \"al\"]);\n\n/**\n * Turn a market question into a news query.\n *\n * Proper nouns first: \"Will the U.S. invade Iran before 2027?\" should search\n * for Iran, not for \"invade\". Capitalisation inside the sentence is a cheap\n * and surprisingly good proper-noun detector for these titles. The derived\n * query is STORED so it can be inspected and corrected later rather than being\n * an invisible guess buried in the pipeline.\n */\nconst LEADERS = new Set([\"will\", \"who\", \"what\", \"which\", \"how\", \"when\", \"does\", \"do\", \"is\", \"are\", \"can\", \"should\", \"did\"]);\n\nfunction deriveQuery(question: string): string | null {\n const words = String(question).replace(/[?\".,()]/g, \" \").split(/\\s+/).filter(Boolean);\n // Drop only an actual question-leading word. Skipping index 0 unconditionally\n // was a bug: \"Clarity Act ...\" lost \"Clarity\" and searched for \"Act\".\n const start = words.length && LEADERS.has(words[0].toLowerCase().replace(/[^a-z]/g, \"\")) ? 1 : 0;\n\n // Capitalised RUNS, not isolated words. \"Clarity Act\" and \"Champions League\"\n // are the searchable entities; \"Act\" on its own is a query for everything.\n // Unicode-aware: \"Luiz Inácio Lula da Silva\" must not fail on the accent.\n const isCap = (w: string) => /^\\p{Lu}[\\p{L}.'-]{2,}$/u.test(w) && !STOP.has(w.toLowerCase());\n const runs: string[][] = [];\n let cur: string[] = [];\n for (let i = start; i < words.length; i++) {\n const w = words[i];\n if (isCap(w)) { cur.push(w); continue; }\n // A connector continues the name only if a capitalised word follows it.\n if (cur.length && CONNECTORS.has(w.toLowerCase()) && i + 1 < words.length && isCap(words[i + 1])) {\n cur.push(w);\n continue;\n }\n if (cur.length) runs.push(cur);\n cur = [];\n }\n if (cur.length) runs.push(cur);\n\n // ONE phrase, the longest. GDELT ANDs terms, so two phrases is a very\n // narrow query: pairing the Lula market's name with \"Brazilian\" returned 6\n // articles in five days, well under what spike detection needs. Breadth is\n // the scarcer resource here, and `broaden()` below widens further if even\n // one phrase starves the detector.\n // Rank by word count first, then characters. A two-word proper name is a\n // better search subject than one long word, and ranking by raw length alone\n // was how a role phrase beat a person's name.\n runs.sort((a, b) => (b.length - a.length) || (b.join(\" \").length - a.join(\" \").length));\n if (runs.length) {\n const phrase = runs[0].join(\" \");\n return runs[0].length > 1 ? `\"${phrase}\"` : phrase;\n }\n\n const fallback = words.slice(start)\n .filter((w) => w.length > 4 && !STOP.has(w.toLowerCase()))\n .filter((w, i, a) => a.indexOf(w) === i)\n .slice(0, 2);\n return fallback.length ? fallback.join(\" \") : null;\n}\n\nasync function ensureTables() {\n await sqlite.execute(`CREATE TABLE IF NOT EXISTS lead_watchlist (\n cid TEXT PRIMARY KEY, q TEXT, question TEXT, added TEXT, last_run TEXT, last_status TEXT)`);\n await sqlite.execute(`CREATE TABLE IF NOT EXISTS lead_events (\n k TEXT PRIMARY KEY, cid TEXT, q TEXT, source TEXT, ts INTEGER,\n lead REAL, ratio REAL, pre REAL, post REAL, price REAL, label TEXT, created TEXT)`);\n await sqlite.execute(`CREATE TABLE IF NOT EXISTS lead_sweep_state (k TEXT PRIMARY KEY, v TEXT)`);\n // Marks a row whose query the sweeper widened itself, so the daily refresh\n // does not helpfully overwrite it with the same narrow query that starved.\n try {\n await sqlite.execute(`ALTER TABLE lead_watchlist ADD COLUMN q_broadened INTEGER DEFAULT 0`);\n } catch { /* already present */ }\n}\n\nasync function getState(k: string): Promise {\n const r = (await sqlite.execute({ sql: `SELECT v FROM lead_sweep_state WHERE k = ?`, args: [k] })).rows as any[];\n return r.length ? String(r[0].v) : null;\n}\nasync function setState(k: string, v: string) {\n await sqlite.execute({ sql: `INSERT OR REPLACE INTO lead_sweep_state (k,v) VALUES (?,?)`, args: [k, v] });\n}\n\nasync function refreshWatchlist(): Promise {\n const r = await fetch(\n `${GAMMA}/markets?closed=false&active=true&limit=60&order=volume1mo&ascending=false&offset=0`,\n { headers: { \"User-Agent\": \"predmarket-monitor/1.0\" }, signal: AbortSignal.timeout(20000) },\n );\n if (!r.ok) throw new Error(`gamma ${r.status}`);\n const rows = await r.json() as any[];\n let added = 0;\n for (const m of rows) {\n if (added >= WATCHLIST_MAX) break;\n const question = String(m.question ?? \"\");\n if (!question || SPORTS.test(question)) continue;\n if (!m.conditionId) continue;\n // A market pinned at the extremes has nothing left to react to.\n let price = 0.5;\n try { price = Number(JSON.parse(m.outcomePrices ?? \"[]\")[0] ?? 0.5); } catch { /* */ }\n if (!(price > 0.03 && price < 0.97)) continue;\n const q = deriveQuery(question);\n if (!q) continue;\n await sqlite.execute({\n // Upsert the query, keep the run history. Query derivation will keep\n // improving, and rows stored under an older, worse query should pick up\n // the better one rather than being frozen with it forever.\n sql: `INSERT INTO lead_watchlist (cid,q,question,added,last_run,last_status) VALUES (?,?,?,?,NULL,NULL)\n ON CONFLICT(cid) DO UPDATE SET\n q = CASE WHEN lead_watchlist.q_broadened = 1 THEN lead_watchlist.q ELSE excluded.q END,\n question = excluded.question`,\n args: [String(m.conditionId), q, question.slice(0, 120), new Date().toISOString()],\n });\n added++;\n }\n await setState(\"watchlist_refreshed\", new Date().toISOString());\n return added;\n}\n\nexport default async function () {\n await ensureTables();\n\n const lastRefresh = await getState(\"watchlist_refreshed\");\n const stale = !lastRefresh || (Date.now() - new Date(lastRefresh).getTime()) > REFRESH_AFTER_H * 3600_000;\n if (stale) {\n try {\n const n = await refreshWatchlist();\n console.log(`lead-sweep: watchlist refreshed, ${n} candidates considered`);\n } catch (e) {\n console.log(`lead-sweep: watchlist refresh failed: ${e}`);\n }\n }\n\n // Least-recently-measured first, nulls first. Every market gets its turn\n // instead of the sweeper camping on whichever one happens to work.\n const pick = (await sqlite.execute(\n `SELECT cid, q, question FROM lead_watchlist ORDER BY last_run IS NOT NULL, last_run ASC LIMIT 1`,\n )).rows as any[];\n if (!pick.length) {\n console.log(\"lead-sweep: watchlist empty, nothing to do\");\n return;\n }\n const { cid, q, question } = { cid: String(pick[0].cid), q: String(pick[0].q), question: String(pick[0].question) };\n\n let status = \"\";\n let stored = 0;\n try {\n // retries: nothing is waiting on this run, so it can afford to sit out a\n // rate limit rather than throw the attempt away.\n const out: any = await study(cid, { q, days: 5, detector: \"spikes\", preH: 24, postH: 24, max: 25, retries: 1 });\n if (!out.ok) {\n status = String(out.error ?? \"failed\").slice(0, 120);\n } else {\n for (const e of (out.events ?? []) as any[]) {\n const res = await sqlite.execute({\n sql: `INSERT OR IGNORE INTO lead_events (k,cid,q,source,ts,lead,ratio,pre,post,price,label,created)\n VALUES (?,?,?,?,?,?,?,?,?,?,?,?)`,\n args: [\n `${cid}|${e.ts}`, cid, q, \"gdelt-spike\", e.ts,\n e.leadShare, e.reactionRatio, e.preMove, e.postMove, e.priceAtEvent,\n String(e.label ?? \"\").slice(0, 120), new Date().toISOString(),\n ],\n });\n stored += Number(res.rowsAffected ?? 0);\n }\n // Record WHY a successful run found nothing. \"ok events=0\" on its own is\n // indistinguishable between a flat topic and a threshold set too high.\n const m = out.detectorMeta ?? {};\n status = `ok events=${out.eventsScored} new=${stored}`\n + ` arts=${m.totalArticles ?? \"?\"} med=${m.median ?? \"?\"} mad=${m.mad ?? \"?\"}`\n + ` thr=${m.threshold ?? \"?\"} peak=${m.maxBucket ?? \"?\"} peakVsThr=${m.peakVsThreshold ?? \"?\"}`;\n if (m.error) status += ` note=${String(m.error).slice(0, 50)}`;\n }\n } catch (e) {\n status = `threw: ${String(e).slice(0, 100)}`;\n }\n\n // SELF-BROADENING. A query can be so specific that the topic never clears\n // the coverage floor, and then this market simply never contributes, quietly,\n // forever. When that happens, widen the query one step (drop the quoted\n // phrase down to its most distinctive single word) and store the wider one,\n // so the next pass has a chance instead of repeating a known dead end.\n let nextQ = q;\n if (status.includes(\"too little coverage\") && q.startsWith('\"')) {\n const inner = q.replace(/\"/g, \"\").split(/\\s+/);\n const widest = inner.slice().sort((a, b) => b.length - a.length)[0];\n if (widest && widest !== q) {\n nextQ = widest;\n console.log(`lead-sweep: broadening ${q} -> ${nextQ} (coverage floor)`);\n }\n }\n\n await sqlite.execute({\n sql: `UPDATE lead_watchlist SET last_run = ?, last_status = ?, q = ?, q_broadened = ? WHERE cid = ?`,\n args: [new Date().toISOString(), status, nextQ, nextQ === q ? 0 : 1, cid],\n });\n\n const total = (await sqlite.execute(`SELECT COUNT(*) AS n FROM lead_events`)).rows as any[];\n console.log(`lead-sweep: \"${question.slice(0, 50)}\" q=\"${q}\" -> ${status}; corpus=${total[0]?.n ?? 0}`);\n}\n",[],[378],"6291d64b-3984-4a40-b237-f0e762ebdd04","index.html","01a0ac2c-e909-715a-acf6-aa3cf4df43c1",["D",1789595019450],"\n\n \n Hi there!\n \n \n \n\n \n \n\n \n \n\n \n \n \n \n

Hi there!

\n\n

\n I'm your cool new webpage. Made with Val Town!\n

\n \n",[],[387],"4886164e-124c-4ac0-8f06-c6ce848e30e1","fee-audit.ts","e0199ce4-b306-11f1-9782-1607ee4eb77e",245,["D",1789697868157],"/** fee-audit.ts (http)\n *\n * Checks the load-bearing assumption behind the maker pivot:\n * \"Kalshi charges no maker fee on most markets.\"\n *\n * That claim came from Kalshi's help centre, not from data. The series\n * object exposes `fee_type`, which is the authoritative per-series answer.\n * KXNFLGAME, which is 100% of the current maker corpus, returns\n * \"quadratic_with_maker_fees\" -- so the assumption is already known false\n * somewhere. This measures how far the falsification extends.\n *\n * Routes:\n * ?cat=Sports scan one category, store per-series fee_type\n * ?series=A,B,C fetch named series objects directly\n * ?report=1 tally what has been stored\n */\n\nimport { sqlite } from \"https://esm.town/v/std/sqlite/main.ts\";\n\nconst API = \"https://api.elections.kalshi.com/trade-api/v2\";\nconst UA = { \"User-Agent\": \"predmarket-monitor/1.0 (research)\" };\n\nasync function kj(url: string, tries = 3): Promise {\n for (let i = 0; i < tries; i++) {\n const r = await fetch(url, { headers: UA });\n if (r.ok) return r.json();\n if (r.status === 429) { await new Promise((s) => setTimeout(s, 1200 * (i + 1))); continue; }\n throw new Error(`${r.status} ${url.slice(0, 120)}`);\n }\n throw new Error(`retries exhausted ${url.slice(0, 120)}`);\n}\n\nasync function init() {\n await sqlite.execute(`CREATE TABLE IF NOT EXISTS series_fees (\n ticker TEXT PRIMARY KEY, fee_type TEXT, fee_mult REAL, category TEXT, title TEXT, seen_at INTEGER)`);\n}\n\nasync function store(rows: any[]) {\n const now = Date.now();\n for (const s of rows) {\n if (!s?.ticker) continue;\n await sqlite.execute({\n sql: `INSERT INTO series_fees (ticker, fee_type, fee_mult, category, title, seen_at)\n VALUES (?,?,?,?,?,?) ON CONFLICT(ticker) DO UPDATE SET\n fee_type=excluded.fee_type, fee_mult=excluded.fee_mult, seen_at=excluded.seen_at`,\n args: [s.ticker, s.fee_type ?? \"unknown\", s.fee_multiplier ?? 1,\n s.category ?? \"\", String(s.title ?? \"\").slice(0, 70), now],\n });\n }\n}\n\nexport default async function (req: Request): Promise {\n await init();\n const u = new URL(req.url);\n\n if (u.searchParams.get(\"cat\")) {\n const cat = u.searchParams.get(\"cat\")!;\n const d = await kj(`${API}/series?category=${encodeURIComponent(cat)}`);\n const rows = d.series ?? [];\n // Deliberately no sqlite write here: one INSERT per series is hundreds of\n // round trips and blows the 30s HTTP budget on a category like Sports.\n const byType: Record = {};\n const byMult: Record = {};\n const noMaker: string[] = [];\n for (const s of rows) {\n const ft = s.fee_type ?? \"unknown\";\n byType[ft] = (byType[ft] ?? 0) + 1;\n const k = `${ft}@${s.fee_multiplier ?? 1}`;\n byMult[k] = (byMult[k] ?? 0) + 1;\n if (!String(ft).includes(\"maker\") && noMaker.length < 25) noMaker.push(s.ticker);\n }\n return Response.json({ cat, fetched: rows.length, byType, byMult, noMakerFeeSample: noMaker });\n }\n\n if (u.searchParams.get(\"series\")) {\n const list = u.searchParams.get(\"series\")!.split(\",\").map((s) => s.trim()).filter(Boolean);\n const out: any[] = [];\n for (const t of list) {\n try {\n const d = await kj(`${API}/series/${encodeURIComponent(t)}`);\n const s = d.series;\n out.push({ ticker: t, feeType: s?.fee_type, mult: s?.fee_multiplier, title: s?.title });\n await store([s]);\n } catch (e) {\n out.push({ ticker: t, error: String(e).slice(0, 90) });\n }\n await new Promise((s) => setTimeout(s, 150));\n }\n return Response.json(out);\n }\n\n const total = await sqlite.execute(`SELECT fee_type, COUNT(*) n FROM series_fees GROUP BY fee_type ORDER BY n DESC`);\n const byCat = await sqlite.execute(\n `SELECT category, fee_type, COUNT(*) n FROM series_fees GROUP BY category, fee_type ORDER BY category, n DESC`);\n const mults = await sqlite.execute(`SELECT fee_mult, COUNT(*) n FROM series_fees GROUP BY fee_mult ORDER BY n DESC`);\n const makerExamples = await sqlite.execute(\n `SELECT ticker, title, category FROM series_fees WHERE fee_type LIKE '%maker%' ORDER BY ticker LIMIT 40`);\n\n return Response.json({\n note: \"fee_type is per-series and authoritative. 'quadratic' = taker fee only. \"\n + \"'quadratic_with_maker_fees' = resting orders are charged too.\",\n byFeeType: total.rows,\n byFeeMultiplier: mults.rows,\n byCategory: byCat.rows,\n makerFeeSeriesSample: makerExamples.rows,\n });\n}\n",[],[394],"f8da3c4c-9065-4a06-824d-4611e8553309","favicon.svg","01a0ac2c-e909-715a-acf6-a42e3b3ec658",["D",1789595019450],"",[],[402],"e7857947-dee6-4f31-93ac-03ab2bb89138","desk.tsx","f9d09f46-b245-11f1-bd95-1607ee4eb77e",294,["D",1789705992238],"import { sqlite } from \"https://esm.town/v/std/sqlite/main.ts\";\nimport { ASSUMED_SLIPPAGE_CENTS, kalshiTakerFee } from \"./costs.ts\";\n\n// Agentic Investing — project home.\n//\n// REDESIGNED from the paper-only desk. Three problems drove it:\n//\n// 1. IT LED WITH FIVE NUMBERS IT THEN TOLD YOU TO IGNORE. Five tiles of\n// unrealized marks, one of them literally captioned \"ignore\", above a\n// banner explaining that none of them mean anything yet. The honest lead\n// is the DECISION STATE: can real money go in, and if not, what is the\n// blocker. That is one sentence and one meter, not five dollar figures.\n//\n// 2. IT WAS ONE PILLAR PRETENDING TO BE THE PROJECT. The maker test, the\n// catalyst result and the coherence kill were invisible from here, so the\n// page implied the paper ledger was the whole effort. Every pillar's state\n// now lives in one strip, read from the same database.\n//\n// 3. IT ENCODED EVERYTHING AS RED-OR-GREEN TEXT AND NOTHING AS SHAPE. For a\n// project whose central lesson is that distributions matter and averages\n// lie, it showed only averages, and it showed them in the one color pair\n// that fails colorblind separation (green vs red measures deutan Delta E\n// 4.1, far under the 8 floor). Red/green now appears only as status, always\n// with an icon and a word, never as the sole carrier of meaning; the\n// quantitative marks use a validated blue-red diverging pair.\n//\n// Charts are plain HTML/CSS bars: thin marks, hairline solid rules, a zero\n// baseline, selective direct labels, hover titles, and a table view behind the\n// disclosure at the bottom. No dual axes anywhere.\n\nconst GAMMA = \"https://gamma-api.polymarket.com\";\nconst STAKE = 100;\n\n// TWO DIFFERENT HURDLES, never to be conflated:\n// - COPY_HURDLE: the Polymarket-mid to Kalshi-ask path (Pillar 1). Measured\n// at ~5%/trade across 7 executable positions. This is the cost of copying\n// a signal onto a different venue.\n// - The Kalshi-native taker cost, measured live in the maker corpus below at\n// median 2c spreads, which runs far lower. Presenting one \"hurdle\" for both\n// would flatter the copy strategy with the market-making strategy's costs.\nconst COPY_HURDLE = 5;\nconst EVIDENCE_TARGET = 30; // resolved executable trades before any verdict\nconst HORIZON_DAYS = 45; // paper.ts GATE.maxDaysToResolve\n\nconst esc = (s: any) => String(s ?? \"\").replace(/[&<>\"]/g, (c) => ({ \"&\": \"&\", \"<\": \"<\", \">\": \">\", '\"': \""\" }[c]!));\nconst money = (n: number) => (n < 0 ? \"-$\" : \"$\") + Math.abs(n).toFixed(0);\nconst signed = (n: number, d = 2) => (n > 0 ? \"+\" : n < 0 ? \"-\" : \"\") + Math.abs(n).toFixed(d);\n\n/** Neutral for exactly zero. The old helper returned \"pos\" for 0, painting\n * every untouched \"$0 realized\" cell green as though it were a gain. */\nconst cls = (n: number) => (n > 0 ? \"pos\" : n < 0 ? \"neg\" : \"zero\");\n\nfunction daysToResolve(endDate: unknown): number | null {\n const t = Date.parse(String(endDate ?? \"\"));\n if (!Number.isFinite(t)) return null;\n // A 1970 epoch means a null endDate was stored, not a market that resolved\n // 56 years ago. Unknown, not overdue.\n return t < Date.parse(\"2000-01-01\") ? null : (t - Date.now()) / 86400000;\n}\n\nasync function currentPrices(cids: string[]) {\n const out = new Map();\n for (let i = 0; i < cids.length; i += 20) {\n const qs = cids.slice(i, i + 20).map((c) => `condition_ids=${c}`).join(\"&\");\n try {\n const r = await fetch(`${GAMMA}/markets?${qs}&limit=100`, { signal: AbortSignal.timeout(12000) });\n if (!r.ok) continue;\n for (const m of (await r.json()) as any[]) {\n try {\n out.set(m.conditionId, {\n outcomes: JSON.parse(m.outcomes ?? \"[]\"),\n prices: JSON.parse(m.outcomePrices ?? \"[]\").map(Number),\n });\n } catch { /* skip */ }\n }\n } catch { /* skip */ }\n }\n return out;\n}\n\nconst q = async (sql: string) => {\n try { return (await sqlite.execute(sql)).rows as any[]; } catch { return []; }\n};\nconst one = async (sql: string) => (await q(sql))[0] ?? {};\n\n/**\n * A diverging bar row. The metric is a difference against a baseline, so zero\n * sits mid-track and the sign picks the pole: blue for better, red for worse.\n * Validated pair (light #2a78d6 / #d03b3b, dark #3987e5 / #d03b3b) clears CVD\n * separation at Delta E 23.8 light / 25.7 dark. The sign is also printed, so\n * hue is never the only cue.\n */\nfunction divBar(label: string, sub: string, value: number | null, domain: number, unit = \"c/$\") {\n if (value == null) {\n return `

${esc(label)}${esc(sub)}

no data

`;\n }\n const frac = Math.min(1, Math.abs(value) / domain);\n const pos = value >= 0;\n const bar = `

`;\n return `

${esc(label)}${esc(sub)}

${bar}

${signed(value)}

`;\n}\n\n/** Sequential magnitude bar: one hue, more-is-longer. For counts, not deltas. */\nfunction seqBar(label: string, n: number, max: number, note: string, tone = \"s1\") {\n const w = max > 0 ? (n / max) * 100 : 0;\n return `

${esc(label)}

0 ? 2 : 0, w).toFixed(1)}%\"\n title=\"${esc(label)}: ${n}\">

${n}

${esc(note)}

`;\n}\n\nconst ICON: Record = {\n good: \"✓\", warning: \"●\", serious: \"▲\", critical: \"✗\", idle: \"□\",\n};\n\n/** Status always ships icon + word + color, never color alone. */\nfunction pill(state: keyof typeof ICON, word: string) {\n return `${ICON[state]}${esc(word)}`;\n}\n\nfunction pillarCard(o: {\n name: string; state: keyof typeof ICON; word: string; metric: string;\n metricNote: string; waiting: string; href: string;\n}) {\n return `\n

${esc(o.name)}${pill(o.state, o.word)}

${o.metric}

${esc(o.metricNote)}

${esc(o.waiting)}

`;\n}\n\nexport default async function (): Promise {\n // ---- paper ledger ------------------------------------------------------\n const rows = await q(`SELECT * FROM paper_trades`);\n for (const r of rows) {\n const entry = Number(r.entry) || 0;\n const ex = Number(r.entry_exec) > 0 ? Number(r.entry_exec) : Math.min(0.99, entry + ASSUMED_SLIPPAGE_CENTS / 100);\n r._ex = ex;\n r._fee = kalshiTakerFee(ex);\n r._contracts = ex + r._fee > 0 ? STAKE / (ex + r._fee) : 0;\n r._arm = String(r.arm ?? \"unknown\");\n r._isControl = Number(r.is_control) === 1;\n r._days = daysToResolve(r.endDate);\n }\n\n const open = rows.filter((r) => r.status === \"open\");\n const closed = rows.filter((r) => r.status !== \"open\");\n\n const mk = await currentPrices([...new Set(open.map((r) => String(r.conditionId)))]);\n for (const r of open) {\n const m = mk.get(String(r.conditionId));\n r._cur = null; r._unrealGross = null; r._unrealNet = null;\n if (m) {\n const i = m.outcomes.findIndex((o) => o.toLowerCase() === String(r.side).toLowerCase());\n if (i >= 0 && Number.isFinite(m.prices[i]) && r.entry > 0) {\n r._cur = m.prices[i];\n r._unrealGross = STAKE * (m.prices[i] / Number(r.entry) - 1);\n r._unrealNet = r._contracts * m.prices[i] - STAKE;\n }\n }\n }\n for (const r of closed) {\n r._netPnl = Number(r.pnl_net);\n if (!Number.isFinite(r._netPnl)) r._netPnl = Number(r.won) === 1 ? r._contracts - STAKE : -STAKE;\n }\n\n // Per-position, not summed. A total conflates how many bets were placed with\n // how each one did, so two arms of different size were never comparable on\n // the old tiles.\n const perPos = (set: any[]) => {\n const o = set.filter((r) => r.status === \"open\" && r._unrealNet != null);\n const c = set.filter((r) => r.status !== \"open\");\n return {\n n: set.length, open: set.filter((r) => r.status === \"open\").length, closed: c.length,\n markPct: o.length ? o.reduce((a, r) => a + r._unrealNet, 0) / o.length : null,\n realPct: c.length ? c.reduce((a, r) => a + (r._netPnl ?? 0), 0) / c.length : null,\n totalNet: o.reduce((a, r) => a + r._unrealNet, 0) + c.reduce((a, r) => a + (r._netPnl ?? 0), 0),\n };\n };\n const signal = perPos(rows.filter((r) => !r._isControl));\n const control = perPos(rows.filter((r) => r._isControl));\n const exec = perPos(rows.filter((r) => !r._isControl && r._arm === \"executable\"));\n\n const soonest = open.map((r) => r._days).filter((d): d is number => d != null && d >= 0).sort((a, b) => a - b)[0];\n const buckets: [string, (d: number | null) => boolean][] = [\n [\"This week\", (d) => d != null && d >= 0 && d <= 7],\n [`8 to ${HORIZON_DAYS} days`, (d) => d != null && d > 7 && d <= HORIZON_DAYS],\n [`${HORIZON_DAYS}d to 1 year`, (d) => d != null && d > HORIZON_DAYS && d <= 365],\n [\"Over a year out\", (d) => d != null && d > 365],\n [\"No end date\", (d) => d == null],\n ];\n const bucketCounts = buckets.map(([name, f]) => ({ name, n: open.filter((r) => f(r._days)).length }));\n const bucketMax = Math.max(1, ...bucketCounts.map((b) => b.n));\n const usable = open.filter((r) => r._days != null && r._days >= 0 && r._days <= HORIZON_DAYS).length;\n\n // ---- maker test -------------------------------------------------------\n const mkStat = await one(\n `SELECT COUNT(*) n, COUNT(DISTINCT series) series_n,\n AVG(take_profit) take, AVG(join_profit) join_p, AVG(imp_profit) imp_p,\n AVG(CASE WHEN join_filled=1 THEN 1.0 ELSE 0.0 END) join_fill,\n AVG(CASE WHEN imp_filled=1 THEN 1.0 ELSE 0.0 END) imp_fill,\n AVG(CASE WHEN won=1 THEN 1.0 ELSE 0.0 END) take_win,\n AVG(spread_cents) spread\n FROM maker_rows`,\n );\n const mkTop = await one(`SELECT COUNT(*) c FROM maker_rows GROUP BY series ORDER BY c DESC LIMIT 1`);\n const mkQueue = Number((await one(`SELECT COUNT(*) n FROM maker_queue WHERE done=0`)).n ?? 0);\n const mkJoinWin = Number((await one(`SELECT AVG(CASE WHEN won=1 THEN 1.0 ELSE 0.0 END) w FROM maker_rows WHERE join_filled=1`)).w ?? 0);\n const mkN = Number(mkStat.n ?? 0);\n const mkTopShare = mkN ? (Number(mkTop.c ?? 0) / mkN) * 100 : 0;\n const dJoin = mkN ? (Number(mkStat.join_p) - Number(mkStat.take)) * 100 : null;\n const dImp = mkN ? (Number(mkStat.imp_p) - Number(mkStat.take)) * 100 : null;\n const adverse = mkN ? (mkJoinWin - Number(mkStat.take_win)) * 100 : null;\n\n const mkReady = mkN >= 40 && mkTopShare <= 60;\n const best = Math.max(dJoin ?? -99, dImp ?? -99);\n const mkState: keyof typeof ICON = !mkReady ? \"warning\" : best > 1 ? \"good\" : best < -1 ? \"critical\" : \"serious\";\n const mkWord = !mkReady ? \"accruing\" : best > 1 ? \"posting wins\" : best < -1 ? \"posting loses\" : \"too close\";\n\n // ---- replay screen ----------------------------------------------------\n const rp = await one(`SELECT COUNT(*) n FROM replay_events`);\n const rpN = Number(rp.n ?? 0);\n const conf = Number((await one(`SELECT COUNT(*) n FROM confluence_log`)).n ?? 0);\n\n // ---- the decision state ------------------------------------------------\n const blocker = exec.closed >= EVIDENCE_TARGET\n ? \"Executable arm has enough resolutions to read. Check the verdict below.\"\n : usable === 0\n ? \"Nothing in the ledger resolves inside the horizon, so no evidence is coming.\"\n : `${exec.closed} of ${EVIDENCE_TARGET} executable resolutions. First one ${\n soonest == null ? \"not scheduled\" : soonest < 1 ? \"due today\" : `in ${Math.round(soonest)} days`\n }.`;\n const progress = Math.min(100, (exec.closed / EVIDENCE_TARGET) * 100);\n\n // ---- positions table (collapsed; near-term first) ----------------------\n const nearTerm = open.filter((r) => r._days != null && r._days >= 0 && r._days <= HORIZON_DAYS)\n .sort((a, b) => (a._days ?? 1e9) - (b._days ?? 1e9));\n const later = open.filter((r) => !(r._days != null && r._days >= 0 && r._days <= HORIZON_DAYS))\n .sort((a, b) => (a._days ?? 1e9) - (b._days ?? 1e9));\n\n const posRow = (r: any) => {\n const due = r._days == null ? \"no date\" : r._days < 1 ? \"today\" : r._days > 365 ? `${(r._days / 365).toFixed(1)}y` : `${Math.round(r._days)}d`;\n const un = r._unrealNet;\n return `${esc(r.market)}${\n r.kalshi_ticker ? `
${esc(r.kalshi_ticker)}` : \"\"\n }${esc(r.side)}${Math.round(Number(r.entry) * 100)}c` +\n `${Math.round(r._ex * 100)}c${Number(r.exec_quoted) === 1 ? \"\" : \"*\"}` +\n `${r._cur != null ? Math.round(r._cur * 100) + \"c\" : \"—\"}` +\n `${un == null ? \"—\" : money(un)}` +\n ` HORIZON_DAYS ? \"neg\" : \"pos\"}\">${due}` +\n `${esc(r._isControl ? \"control\" : r._arm)}`;\n };\n const tbl = (set: any[]) =>\n set.map(posRow).join(\"\") || `None.`;\n\n const html = `\n\nAgentic Investing

\n\n

Agentic Investing

\n ${esc(new Date().toISOString().slice(0, 16).replace(\"T\", \" \"))} UTC\n

\n\n

Can real money go in?

Not yet. No position has resolved.

${esc(blocker)} Everything below a resolution is an unrealized mark, which moves\n with the market and says nothing about whether a strategy works.

${exec.closed} resolved in the executable arm${EVIDENCE_TARGET} needed

\n\n

Where each line of work stands

Four independent tracks. The paper ledger is the slowest because it waits on real\n resolutions; the backtests can be settled in an afternoon, which is why they now go first.

\n ${\n pillarCard({\n name: \"Maker execution\",\n state: mkState,\n word: mkWord,\n metric: dJoin == null ? \"—\" : `${signed(dJoin)}`,\n metricNote: `cents per dollar vs crossing · n=${mkN} over ${Number(mkStat.series_n ?? 0)} series`,\n waiting: mkReady\n ? `Adverse selection ${signed(adverse ?? 0, 1)} win-rate points. ${mkQueue} queued to tighten it.`\n : `Needs 40 rows across many series. ${mkQueue} queued.`,\n href: \"https://joaquinrubio--9a5d5ef4b30411f19e6c1607ee4eb77e.web.val.run/\",\n })\n }\n ${\n pillarCard({\n name: \"Catalyst\",\n state: \"serious\",\n word: \"narrowed\",\n metric: `3.1 vs 0.2`,\n metricNote: \"FOMC move vs placebo · median reaction 1.55c\",\n waiting: \"Holds for the announcement that RESOLVES a market. CPI showed 0.9x, so it does not generalize.\",\n href: \"https://joaquinrubio--e0ddf490b2e811f1b3251607ee4eb77e.web.val.run/?report=1\",\n })\n }\n ${\n pillarCard({\n name: \"Whale confluence\",\n state: \"warning\",\n word: \"at the hurdle\",\n metric: `${rpN}`,\n metricNote: `replay events · ${conf} confluences logged`,\n waiting: `Screen only, biased in our favour. Net per theme drifted toward the ${COPY_HURDLE}% hurdle as n grew.`,\n href: \"https://joaquinrubio--ee67d4b0b2e211f18bb81607ee4eb77e.web.val.run/\",\n })\n }\n ${\n pillarCard({\n name: \"Coherence\",\n state: \"critical\",\n word: \"killed\",\n metric: \"0\",\n metricNote: \"violations from 88,393 pairs checked\",\n waiting: \"Clean negative, settled in one afternoon. Cost one scan instead of one quarter.\",\n href: \"https://joaquinrubio--570b6b60b30311f18fdb1607ee4eb77e.web.val.run/\",\n })\n }\n

\n\n

Does posting beat crossing?

The highest-leverage question open, because it attacks the cost bar rather than\n hunting for a better signal. Both arms buy the same side of the same market at the same instant,\n so market selection and directional bias cancel and what is left is the execution effect.\n Missed fills count as zero, and the maker fee is charged.

\n ${divBar(\"Post at the bid\", `fills ${((Number(mkStat.join_fill) || 0) * 100).toFixed(0)}% of the time`, dJoin, 4)}\n ${divBar(\"Post one tick better\", `fills ${((Number(mkStat.imp_fill) || 0) * 100).toFixed(0)}% of the time`, dImp, 4)}\n

-4worse ← cross the spread → better+4

\n beats crossing\n loses to crossing\n Adverse selection: ${signed(adverse ?? 0, 1)} win-rate points when a resting order filled\n

${\n mkReady\n ? `Verdict gate is open: n=${mkN}, largest series ${mkTopShare.toFixed(0)}% of the sample. Both maker arms\n are currently behind crossing, and the winner's curse is showing up exactly as Glosten-Milgrom\n predicts. At ${signed(dJoin ?? 0)} the gap is inside the +/-1 band we set as too-close-to-call,\n so this is leaning negative rather than settled.`\n : `No verdict below 40 rows or above 60% single-series concentration. Currently n=${mkN},\n largest series ${mkTopShare.toFixed(0)}%.`\n } Queue position is not modelled and candles are hourly, both of which flatter the maker arms.

\n\n

When does the paper ledger report?

Feedback latency, not ideas, has been the binding constraint. A 45-day horizon cap\n went into the gate on 2026-09-18; every position opened before it is uncapped, which is why so\n much of the ledger sits beyond the line.

\n ${bucketCounts.map((b) => seqBar(b.name, b.n, bucketMax, b.n === 0 ? \"\" : `${((b.n / open.length) * 100).toFixed(0)}% of open`, b.name.includes(\"year\") || b.name.includes(\"No end\") ? \"mu\" : \"s1\")).join(\"\")}\n

\n inside the horizon, will report\n beyond it, opened before the cap\n

${usable} of ${open.length} open positions resolve inside ${HORIZON_DAYS} days.\n The control arm is the weak point: ${control.open} open, and only ${\n open.filter((r) => r._isControl && r._days != null && r._days >= 0 && r._days <= HORIZON_DAYS).length\n } of those land inside the horizon, so the benchmark effectively restarts from the cap date.

\n\n

Current marks, signal against control

Not a result. This is what the open bets are worth right now, per position rather\n than summed, so arms of different size are comparable. A strategy has to beat the control arm,\n not zero: a gain that random same-band markets also produce is market drift.

\n ${divBar(\"Executable signal\", `${exec.open} open · the only arm that could take real money`, exec.markPct, 12, \"%\")}\n ${divBar(\"All arms\", `${signal.open} open · includes markets with no Kalshi equivalent`, signal.markPct, 12, \"%\")}\n ${divBar(\"Control\", `${control.open} open · random markets, same price band`, control.markPct, 12, \"%\")}\n

-12%per position, marked at what we would have paid+12%

Copying a signal onto Kalshi costs about ${COPY_HURDLE}% per trade, so the\n executable arm needs to clear that much edge before it breaks even. That figure is specific to the\n Polymarket-mid to Kalshi-ask path and is not the same as the Kalshi-native taker cost in the maker\n test above, where the median spread is only ${(Number(mkStat.spread) || 0).toFixed(1)}c.

\n\n

All ${open.length} open positions and the full table view

Resolving inside ${HORIZON_DAYS} days (${nearTerm.length})

\n \n \n ${tbl(nearTerm)}

Market	Side	Entry	Exec	Now	Mark	Due	Arm

Beyond the horizon (${later.length})

\n \n \n ${tbl(later)}

Market	Side	Entry	Exec	Now	Mark	Due	Arm

Entry is the observed Polymarket mid. Exec is what we would actually pay: a real\n Kalshi ask, or the mid plus an assumed half-spread marked *. Mark is\n against Exec and the fee.

\n\n

Detect and paper-execute only; this never places a real trade, and agents generate\nsignals while deterministic code makes every decision. Costs modelled: the Kalshi taker fee, the\nper-series maker fee, and the executable ask where quoted. Not modelled: order-book depth, partial\nfills, early exit. Real capital stays gated on a resolved, cost-aware, control-beaten result.

\n\n

`;\n return new Response(html, { headers: { \"content-type\": \"text/html; charset=utf-8\" } });\n}\n",[],[409],"30ebd3cb-34da-4150-957c-fa652cd92580","data-api.ts","47307b60-b23e-11f1-b0d1-1607ee4eb77e",18,["D",1789611973733],"const DATA = \"https://data-api.polymarket.com\";\n\nexport async function readRows(path: string, params: Record) {\n const url = new URL(path, DATA);\n for (const [key, value] of Object.entries(params)) url.searchParams.set(key, String(value));\n const response = await fetch(url, { signal: AbortSignal.timeout(15000) });\n if (!response.ok) throw new Error(`${path}: HTTP ${response.status}`);\n const rows: unknown = await response.json();\n if (!Array.isArray(rows) || rows.some((r) => !r || typeof r !== \"object\" || Array.isArray(r))) {\n throw new Error(`${path}: expected an array of records`);\n }\n return rows as Record[];\n}\n\n// Authoritative total portfolio value (Polymarket's own computed number), used as\n// the conviction denominator so it includes the long tail of dust we don't page.\nexport async function readValue(wallet: string): Promise {\n const rows = await readRows(\"/value\", { user: wallet });\n const v = rows[0]?.value;\n if (!Number.isFinite(v) || v < 0) throw new Error(\"/value: missing or invalid portfolio value\");\n return v as number;\n}\n\n// MEANINGFUL current positions, largest-value first, stopping once below minValue.\n// Server-side sort (sortBy=CURRENT desc) means even a wallet holding thousands of\n// dust positions returns in a page or two, because we never page past the\n// positions large enough to matter. Still validates identifiers/prices.\nexport async function readPositions(wallet: string, minValue = 0) {\n const rows: Record[] = [];\n const seen = new Set();\n for (let offset = 0; offset <= 20000; offset += 500) {\n const page = await readRows(\"/positions\", {\n user: wallet, limit: 500, offset, sizeThreshold: 0, sortBy: \"CURRENT\", sortDirection: \"DESC\",\n });\n for (const p of page) {\n if (typeof p.asset !== \"string\" || !p.asset || typeof p.conditionId !== \"string\" || !p.conditionId ||\n !Number.isFinite(p.currentValue) || p.currentValue < 0 ||\n !Number.isFinite(p.curPrice) || p.curPrice < 0 || p.curPrice > 1) {\n throw new Error(\"/positions: invalid identifiers or prices\");\n }\n if (p.currentValue < minValue) return rows; // sorted desc: everything after is smaller\n if (seen.has(p.asset)) throw new Error(\"/positions: duplicate asset; unstable pagination\");\n seen.add(p.asset);\n rows.push(p);\n }\n if (page.length < 500) return rows;\n }\n throw new Error(\"/positions: pagination limit reached; incomplete portfolio\");\n}\n",[],[417],"fbc1fba8-f6a4-436d-ab86-93e11db412d6","cron.ts","144328e0-b218-11f1-bc6e-1607ee4eb77e",["D",1789595191397],"import { sqlite } from \"https://esm.town/v/std/sqlite/main.ts\";\nimport { compute } from \"./lib.ts\";\n\n// Runs on a schedule (every 15 min on Val Town free tier) and records one row\n// per cycle, so over days we build the evidence base to answer the real\n// question: does a genuine net-positive edge ever appear, how large, how often?\n// Email alerts are intentionally NOT wired yet — they come with the automated\n// LLM verification step, so we only ever alert on verified leads, never the\n// residual false ones.\nexport default async function (interval: Interval) {\n const d = await compute(5);\n await sqlite.execute(`CREATE TABLE IF NOT EXISTS history (\n ts TEXT, kalshi INTEGER, poly INTEGER, matches INTEGER, pos INTEGER, best_net REAL\n )`);\n const pos = d.leads.filter((l) => l.net > 0);\n const best = d.leads.length ? d.leads[0].net : 0;\n await sqlite.execute({\n sql: \"INSERT INTO history (ts, kalshi, poly, matches, pos, best_net) VALUES (?, ?, ?, ?, ?, ?)\",\n args: [d.stamp, d.kalshiCount, d.polyCount, d.leads.length, pos.length, best],\n });\n console.log(\n `stored ${d.stamp}: kalshi=${d.kalshiCount} poly=${d.polyCount} matches=${d.leads.length} pos=${pos.length} best=${(best * 100).toFixed(1)}c`,\n );\n}\n",[],[425],"d709300f-4f32-4edb-83b7-33c2df2cb8a2","costs.ts","7a7ef62a-b2e0-11f1-9d89-1607ee4eb77e",295,["D",1789709685815],"// costs.ts — execution cost model. The difference between a paper result and a\n// real one.\n//\n// Why this exists: every P&L number the project produced before this was GROSS.\n// Entries were observed Polymarket mid prices, exits were settlement, and no\n// fee or spread was charged. That matters enormously here because the edges we\n// have actually observed are the same size as the costs: our single best\n// venue-price gap was +2.3c while Kalshi's taker fee peaks near 1.75c per\n// contract before any spread. A strategy can look profitable gross and be\n// reliably unprofitable net, and this project's whole purpose is to know the\n// difference before real money is involved.\n//\n// Two distinct prices, never to be conflated:\n// - MID (Polymarket Gamma outcomePrices): an indicative mark. Useful as the\n// \"informed price\" signal. NOT a price anyone can trade at.\n// - ASK (Kalshi yes_ask/no_ask): an actually executable quote. Using the ask\n// already charges us the spread, which is why quoted entries take no extra\n// slippage below.\n//\n// Assumptions are named constants so they can be argued with, not buried.\n\n/** Kalshi taker fee per contract, in dollars. Peaks ≈ $0.0175 at p = 0.50. */\nexport function kalshiTakerFee(p: number): number {\n if (!(p > 0 && p < 1)) return 0;\n return Math.ceil(0.07 * p * (1 - p) * 100) / 100;\n}\n\n// ---------------------------------------------------------------------------\n// MAKER FEES. Correcting a documented-but-unverified assumption.\n//\n// This project ran on \"Kalshi charges no maker fee on most markets\", taken from\n// the help centre. The series object settles it: `fee_type` is per-series and\n// authoritative, and it reads \"quadratic_with_maker_fees\" on KXNFLGAME,\n// KXNBAGAME, KXMLBGAME, KXNCAAFGAME, KXFED and KXCPIYOY — every series with\n// enough liquidity to matter. By count the assumption is nearly true (about 120\n// of ~7,300 catalogued series charge it). By volume it is false, because the\n// charge lands on precisely the markets a maker strategy would work in.\n//\n// Coefficient is a quarter of the taker rate. Two independent secondary sources\n// give the maker term as 0.0175·p·(1−p) against the taker's 0.07·p·(1−p); the\n// official schedule PDF is behind a bot check and has not been read directly,\n// so this constant is corroborated, not verified at source.\nexport const TAKER_COEFF = 0.07;\nexport const MAKER_COEFF = 0.0175;\n\n/**\n * Raw per-contract fee in dollars, before balance rounding.\n *\n * Deliberately NOT rounded up to the cent the way kalshiTakerFee is. Kalshi's\n * fee-rounding rules carry an accumulator across an order's fills that rebates\n * the overpayment, so a real order of any size converges on the raw rate.\n * Ceiling a $0.0044 maker fee to $0.01 would overstate it by 2.3x and would\n * kill the maker thesis with an artefact of our own arithmetic.\n */\nexport function kalshiFeeRaw(p: number, coeff: number, mult = 1): number {\n if (!(p > 0 && p < 1)) return 0;\n return coeff * mult * p * (1 - p);\n}\n\n/**\n * Maker fee per contract. `mult` is the series' fee_multiplier, and 0 for a\n * series whose fee_type is plain \"quadratic\" (no maker fee at all).\n */\nexport function kalshiMakerFee(p: number, mult = 1): number {\n return kalshiFeeRaw(p, MAKER_COEFF, mult);\n}\n\n/** Maps a series' API fee_type + fee_multiplier to the maker multiplier. */\nexport function makerMultFor(feeType: string | null | undefined, feeMult = 1): number {\n return String(feeType ?? \"\").includes(\"maker\") ? feeMult : 0;\n}\n\n/**\n * Extra slippage charged when the entry price was a MID rather than a real\n * executable quote (observational and control positions). Stands in for the\n * half-spread you would actually cross. Quoted Kalshi asks get 0, because the\n * ask already is the far side of the book.\n */\nexport const ASSUMED_SLIPPAGE_CENTS = 1.0;\n\nexport interface NetResult {\n entryExec: number; // price per contract actually paid, dollars\n feePerContract: number;\n contracts: number;\n feeTotal: number;\n pnl: number;\n roi: number;\n}\n\n/**\n * Net P&L for a hold-to-resolution binary position.\n *\n * Capital deployed is fixed at `stake`, and the fee is paid out of it, so\n * contracts = stake / (price + fee). Winning pays $1 per contract; losing pays\n * nothing. Kalshi charges its taker fee on the trade, not on settlement, so a\n * held-to-expiry position pays it once on entry.\n *\n * Note the honest edge case: if price + fee ≥ $1 the position cannot profit\n * even when it wins, and this returns a loss on a win. That is correct.\n */\nexport function netResult(entryExec: number, won: boolean, stake = 100): NetResult {\n const feePerContract = kalshiTakerFee(entryExec);\n const perContract = entryExec + feePerContract;\n const contracts = perContract > 0 ? stake / perContract : 0;\n const pnl = won ? contracts - stake : -stake;\n return {\n entryExec: +entryExec.toFixed(4),\n feePerContract: +feePerContract.toFixed(4),\n contracts: +contracts.toFixed(2),\n feeTotal: +(contracts * feePerContract).toFixed(2),\n pnl: +pnl.toFixed(2),\n roi: +(pnl / stake * 100).toFixed(1),\n };\n}\n\n// ---------------------------------------------------------------------------\n// ROUND TRIPS. Everything above this line prices a HOLD.\n//\n// `netResult` is a hold-to-resolution model and says so. It charges one fee on\n// entry because a held position pays one. That made every number this project\n// has produced an entry-only number, which understates any strategy that plans\n// to sell before resolution — and two of the three live strategies do:\n//\n// - PILLAR 3 (catalyst). The FOMC finding is that the market reprices over\n// about an hour. You capture that by selling into the move, not by holding\n// a contract that settles months later. The pillar cannot be evaluated\n// against a hold-only cost model at all.\n// - MARKET MAKING. A maker's business IS the round trip: buy the bid, sell\n// the ask, repeat. The maker test as first written scored buy-and-hold on\n// both arms, so it measured entry price improvement rather than the\n// strategy whose name was on it.\n//\n// The subtlety worth naming: Kalshi's fee is 0.07·p·(1−p), so it is PRICE\n// DEPENDENT, which means the exit fee depends on where the price went. Exiting\n// a winner at 90c costs about 0.06c per contract; exiting a coin flip at 50c\n// costs 1.75c. Cost and payoff are therefore correlated, and a flat\n// \"double the fee\" approximation gets the sign of that correlation wrong.\n\n/** Which side of the book each leg of a round trip was executed on. */\nexport type Role = \"taker\" | \"maker\";\n\n/** Per-contract fee for one leg, given the role and the series' maker mult. */\nexport function legFee(p: number, role: Role, makerMult = 1): number {\n return role === \"maker\"\n ? kalshiMakerFee(p, makerMult)\n : kalshiFeeRaw(p, TAKER_COEFF, 1);\n}\n\nexport interface RoundTrip {\n entry: number;\n exit: number;\n grossPerContract: number;\n entryFee: number;\n exitFee: number;\n netPerContract: number;\n /** Net as a percentage of capital committed, comparable to the hurdle rates. */\n netPct: number;\n}\n\n/**\n * Net P&L per contract for a completed round trip: buy at `entry`, sell at\n * `exit`, paying the real fee on BOTH legs at the price each leg executed at.\n *\n * Roles matter and are not cosmetic. maker/maker is the market-making case and\n * the cheapest; taker/taker is the panic-exit case and the most expensive;\n * maker/taker is what a maker who has to get out in a hurry actually pays.\n */\nexport function netRoundTrip(\n entry: number,\n exit: number,\n entryRole: Role = \"taker\",\n exitRole: Role = \"taker\",\n makerMult = 1,\n): RoundTrip {\n const entryFee = legFee(entry, entryRole, makerMult);\n const exitFee = legFee(exit, exitRole, makerMult);\n const gross = exit - entry;\n const net = gross - entryFee - exitFee;\n const committed = entry + entryFee;\n return {\n entry: +entry.toFixed(4),\n exit: +exit.toFixed(4),\n grossPerContract: +gross.toFixed(4),\n entryFee: +entryFee.toFixed(4),\n exitFee: +exitFee.toFixed(4),\n netPerContract: +net.toFixed(4),\n netPct: committed > 0 ? +((net / committed) * 100).toFixed(2) : 0,\n };\n}\n\n/**\n * The price move, in cents, that a round trip must capture just to break even.\n * This is the round-trip hurdle, and it is the bar Pillar 3's ~1.55c median\n * reaction actually has to clear. Reported per entry price because the fee\n * curve peaks at 50c: a round trip near the middle of the book is the most\n * expensive place to trade.\n */\nexport function roundTripBreakevenCents(\n entry: number,\n entryRole: Role = \"taker\",\n exitRole: Role = \"taker\",\n makerMult = 1,\n): number {\n // Exit price is unknown in advance, so charge the exit fee at the entry\n // price. Honest for small moves and slightly conservative for large ones,\n // since the fee falls as you move away from 50c.\n return +((legFee(entry, entryRole, makerMult) + legFee(entry, exitRole, makerMult)) * 100).toFixed(3);\n}\n\n/** Gross (pre-cost) P&L — kept only so the two can be reported side by side. */\nexport function grossResult(entry: number, won: boolean, stake = 100) {\n const pnl = won ? stake * (1 - entry) / entry : -stake;\n return { pnl: +pnl.toFixed(2), roi: +(pnl / stake * 100).toFixed(1) };\n}\n",[],[432],"8ef4f237-c489-4f18-b4b8-ff70d96ec5c5","confluence.tsx","0a0ca204-b22a-11f1-ab9a-1607ee4eb77e",["D",1789612429205],"import { leaderboard } from \"./smartmoney.ts\";\nimport { readRows, readValue, readPositions } from \"./data-api.ts\";\n\n// v2.2: integrity-hardened (from Codex's data-integrity pass) + signal-quality\n// refinements (Claude).\n// - Meaningful CURRENT holdings only (>= dust), largest-first; even wallets with\n// thousands of dust positions return fast, so no trader is dropped.\n// - Conviction denominator = authoritative /value portfolio total.\n// - Per-wallet errors are reported, not fatal (partial flag; no blanking).\n// - BOTH-SIDES NETTING: a trader hedged on both outcomes of a market is netted\n// out of it (market-making, not a directional view).\n// - CONVICTION: each holder's position as % of their live book.\n// - INDEPENDENCE: coHold = how many markets a confluence's holders ALL share; a\n// high number means they hold a bit of everything, so the agreement is cheap.\nexport const COLLECTOR_VERSION = \"2.2.0\";\nconst categories = new Set([\"OVERALL\", \"POLITICS\", \"SPORTS\", \"ESPORTS\", \"CRYPTO\", \"CULTURE\", \"MENTIONS\", \"WEATHER\", \"ECONOMICS\", \"TECH\", \"FINANCE\"]);\n\nfunction parameters(url: URL) {\n const category = url.searchParams.get(\"cat\") ?? \"POLITICS\";\n const top = Number(url.searchParams.get(\"top\") ?? 8);\n const minvol = Number(url.searchParams.get(\"minvol\") ?? 250000);\n const dust = Number(url.searchParams.get(\"dust\") ?? 500);\n if (!categories.has(category) || !Number.isInteger(top) || top < 1 || top > 50 ||\n !Number.isFinite(minvol) || minvol < 0 || !Number.isFinite(dust) || dust < 0) {\n throw new Error(\"Invalid parameters: category, top (1-50), minvol or dust\");\n }\n return { category, top, minvol, dust };\n}\n\nconst tradeable = (p: any) => p.redeemable !== true && p.curPrice > 0 && p.curPrice < 1;\n\nexport async function collectSnapshot(url: URL) {\n const params = parameters(url);\n const startedAt = new Date().toISOString();\n const candidates = (await leaderboard(params.category, 1, \"MONTH\")).slice(0, params.top);\n if (new Set(candidates.map((c) => c.proxyWallet.toLowerCase())).size !== candidates.length) {\n throw new Error(\"Duplicate wallet in candidate leaderboard\");\n }\n\n const observations: any[] = [];\n const errors: { wallet: string; message: string }[] = [];\n for (const candidate of candidates) {\n const wallet = candidate.proxyWallet;\n try {\n const all = (await readRows(\"/v1/leaderboard\", { category: params.category, timePeriod: \"ALL\", user: wallet }))[0];\n if (!all || typeof all.proxyWallet !== \"string\" || all.proxyWallet.toLowerCase() !== wallet.toLowerCase() ||\n !Number.isFinite(all.pnl) || !Number.isFinite(all.vol) || all.vol < 0) {\n throw new Error(\"Missing or invalid all-time trader record\");\n }\n const qualified = candidate.pnl > 0 && all.pnl > 0 && all.vol >= params.minvol;\n const bookValue = qualified ? await readValue(wallet) : 0;\n const positions = qualified ? await readPositions(wallet, params.dust) : [];\n observations.push({ wallet, name: candidate.userName || wallet, qualified, month: candidate, allTime: all, bookValue, positions, observedAt: new Date().toISOString() });\n } catch (error) {\n errors.push({ wallet, message: String(error) });\n }\n }\n const qualified = observations.filter((o) => o.qualified);\n\n const sides = new Map();\n for (const trader of qualified) {\n // both-sides netting: drop any market where this trader holds >1 outcome\n const outcomes = new Map>();\n for (const p of trader.positions) {\n if (!tradeable(p)) continue;\n const set = outcomes.get(p.conditionId) ?? new Set();\n set.add(p.asset);\n outcomes.set(p.conditionId, set);\n }\n const hedged = new Set([...outcomes].filter(([, s]) => s.size > 1).map(([cid]) => cid));\n\n for (const p of trader.positions) {\n if (!tradeable(p) || hedged.has(p.conditionId)) continue;\n let side = sides.get(p.asset);\n if (!side) {\n side = { asset: p.asset, conditionId: p.conditionId, market: p.title, side: p.outcome, endDate: p.endDate, holders: [] as any[] };\n sides.set(p.asset, side);\n }\n if (side.conditionId !== p.conditionId || side.side !== p.outcome) {\n throw new Error(\"Inconsistent market identifiers across portfolios\");\n }\n const convictionPct = trader.bookValue > 0 ? +((p.currentValue / trader.bookValue) * 100).toFixed(1) : 0;\n side.holders.push({ name: trader.name, value: p.currentValue, avgPrice: p.avgPrice ?? null, observedPrice: p.curPrice, convictionPct });\n }\n }\n\n // independence: which markets each trader is in, to measure shared breadth\n const heldByTrader = new Map>();\n for (const [asset, s] of sides) {\n for (const h of s.holders) {\n let set = heldByTrader.get(h.name);\n if (!set) { set = new Set(); heldByTrader.set(h.name, set); }\n set.add(asset);\n }\n }\n\n const confluence = [...sides.values()].filter((s) => s.holders.length >= 2).map((s) => {\n const total = s.holders.reduce((a: number, h: any) => a + h.value, 0);\n const minConvictionPct = Math.min(...s.holders.map((h: any) => h.convictionPct));\n const sets = s.holders.map((h: any) => heldByTrader.get(h.name)!);\n let inter = new Set(sets[0]);\n for (const st of sets.slice(1)) inter = new Set([...inter].filter((a) => st.has(a)));\n const coHold = inter.size; // markets ALL these holders share (>=1, this one)\n s.holders.sort((a: any, b: any) => b.value - a.value);\n return {\n asset: s.asset, conditionId: s.conditionId,\n market: s.market, side: s.side, endDate: s.endDate,\n holders: s.holders.length,\n minConvictionPct, coHold,\n currentPrice: +(s.holders[0].observedPrice * 100).toFixed(1),\n totalExposure: \"$\" + Math.round(total), totalExposureValue: Math.round(total),\n who: s.holders.map((h: any) => `${h.name} ($${Math.round(h.value)}, ${h.convictionPct}% of book @ ${h.avgPrice != null ? Math.round(h.avgPrice * 100) : \"?\"}c)`),\n };\n }).sort((a, b) =>\n b.holders - a.holders ||\n a.coHold - b.coHold || // prefer distinct pairs over hold-everything grinders\n b.minConvictionPct - a.minConvictionPct ||\n Number(b.totalExposure.slice(1)) - Number(a.totalExposure.slice(1)));\n\n const complete = errors.length === 0;\n return {\n schemaVersion: 3, collectorVersion: COLLECTOR_VERSION, startedAt, completedAt: new Date().toISOString(),\n complete, partial: !complete,\n params: { ...params, vettedTraders: qualified.length, dustFloor: params.dust },\n vetted: qualified.map((o) => o.name), errors,\n confluenceCount: confluence.length, confluence,\n note: \"Confluence = same market+side held now by 2+ vetted traders, after netting out both-sides hedgers. convictionPct = position as % of that trader's live book. coHold = number of markets these same holders ALL share (higher = cheaper, hold-everything overlap). Gross overlap, NOT a trade recommendation; prices are observations, not executable quotes; positions are paged, not an atomic snapshot.\",\n };\n}\n\nexport default async function (req: Request): Promise {\n if (req.method !== \"GET\") return Response.json({ error: \"GET required\" }, { status: 405 });\n const url = new URL(req.url);\n try { parameters(url); } catch (error) { return Response.json({ error: String(error) }, { status: 400 }); }\n try {\n const snapshot = await collectSnapshot(url);\n return Response.json(snapshot, { status: 200 });\n } catch (error) {\n return Response.json({ complete: false, error: String(error), collectorVersion: COLLECTOR_VERSION }, { status: 502 });\n }\n}\n",[],[440],"6e2fb394-2766-4fba-9c05-488a07c11779","coherence.tsx","570b6b60-b303-11f1-8fdb-1607ee4eb77e",210,["D",1789696348023],"import { getKalshiCatalog, type KMarket } from \"./matcher.ts\";\nimport { kalshiTakerFee } from \"./costs.ts\";\n\n// coherence.tsx — LADDER MONOTONICITY SCANNER.\n//\n// The one coherence constraint that is both unambiguous and checkable against\n// the data we hold. No forecasting: a violation is a logical fact about two\n// prices, not a probabilistic claim needing thirty observations.\n//\n// WHAT THE PROBE RULED OUT FIRST (coherence-probe.tsx, kept deliberately):\n// - The single-market complement check is VACUOUS. Across 5,234 tradeable\n// markets, yesAsk + noAsk never fell below 1.00 (min 1.001, median 1.06).\n// Kalshi quotes NO as the mirror of YES on one book, so that sum is\n// 1 + spread by construction. Building that scanner would have produced\n// zero hits that read as \"no opportunities exist\".\n// - Partition sums are mostly NOT partitions. \"Who will Trump pardon?\" has 52\n// outcomes that are not mutually exclusive, and \"Fed funds rate at end of\n// 2027\" is a ladder, not a partition. A YES sum under 1.00 there is normal.\n//\n// WHAT SURVIVES: nested threshold ladders. If outcome A logically contains\n// outcome B, then P(A) >= P(B), always. \"Above 2.0%\" contains \"Above 2.5%\".\n// \"Before 2040\" contains \"Before 2035\".\n//\n// THE TRADE, when that is violated: buy A's YES and B's NO.\n// B true -> A also true -> 1 + 0 = 1\n// A true, B false -> 1 + 1 = 2\n// A false -> B also false -> 0 + 1 = 1\n// Minimum payoff is 1 for a cost of yesAsk(A) + noAsk(B) plus fees, so any\n// total under 1.00 net of fees is a guaranteed profit rather than an edge.\n//\n// WHY THIS PROBABLY STILL DOES NOT PRINT MONEY, stated up front: an ask of\n// 0.99 usually means nobody is offering, not that the contract is worth 99c.\n// Wide quotes on untraded ten-year-out markets will dominate the raw hits, so\n// every result is scored for liquidity and flagged for staleness, and the\n// headline number is the count that survives those filters, not the raw count.\n\nconst MIN_VOL = 200; // per leg; a violation on an untraded book is not a trade\nconst STALE_ASK = 0.97; // at/above this an ask usually means \"no offers\"\nconst IMPLAUSIBLE = 0.10; // a guaranteed profit above this is a bug, not an edge\n\n/** A rung on a monotone ladder: a threshold plus which way probability runs. */\ninterface Rung {\n m: KMarket;\n threshold: number;\n /** \"up\" = probability DECREASES as threshold rises (\"Above X\", \"X+\").\n * \"down\" = probability INCREASES as threshold rises (\"Before X\", \"Under X\"). */\n dir: \"up\" | \"down\";\n /** Which ladder inside the event this rung belongs to. See below. */\n series: string;\n}\n\nconst MONTHS =\n /\\b(jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec|january|february|march|april|june|july|august|september|october|november|december)\\b/g;\n\nfunction parseRung(m: KMarket): Rung | null {\n const s = String(m.subtitle).trim();\n if (!s) return null;\n const clean = s.replace(/,/g, \"\");\n const lowRaw = s.toLowerCase();\n\n // BUCKETS ARE NOT THRESHOLDS. \"Democratic by 1.0% to 1.99%\" is a band, and\n // bands within one event are mutually exclusive rather than nested, so the\n // containment argument does not apply to them at all. Reading the first\n // number of a band as a threshold turned an exclusive bucket into a fake\n // ladder rung and produced the last five false positives.\n if (/\\bto\\b|\\bbetween\\b|\\d\\s*[-–]\\s*\\d/.test(lowRaw)) return null;\n\n // Prefer a four-digit year when one is present. \"Before Jan 20 2029\" must key\n // on 2029, not on the day of the month — reading the day as the threshold\n // turned a date ladder into nonsense and manufactured a fake arbitrage.\n const year = clean.match(/\\b(19|20)\\d{2}\\b/);\n const num = year ?? clean.match(/-?\\d+(\\.\\d+)?/);\n if (!num) return null;\n const threshold = parseFloat(num[0]);\n if (!Number.isFinite(threshold)) return null;\n const low = s.toLowerCase();\n\n // SERIES KEY — the fix for the worst bug this scanner had.\n // One Kalshi event often contains SEVERAL independent ladders. A margin-of-\n // victory event carries one ladder per candidate: \"Smith, 1+ pts\" and\n // \"Rivet, 2+ pts\" live under the same event title but are MUTUALLY EXCLUSIVE,\n // not nested. Comparing across them claimed 80-cent guaranteed profits on\n // liquid midterm markets, which is the kind of number that should be read as\n // a bug report rather than an opportunity. Strip digits and month names and\n // what remains identifies the ladder a rung belongs to.\n const series = low\n .replace(MONTHS, \" \")\n .replace(/[\\d.,+%$]/g, \" \")\n .replace(/\\s+/g, \" \")\n .trim();\n\n // Direction has to come from the wording, not be assumed. A ladder whose\n // phrasing we cannot read is skipped rather than guessed at.\n if (/\\b(above|over|at least|or more|or higher|greater|exceed)\\b/.test(low) || /\\d\\s*\\+/.test(low)) {\n return { m, threshold, dir: \"up\", series };\n }\n // \"by\" is deliberately NOT in this list. It reads as a deadline in \"by 2030\"\n // but as a margin in \"Democratic by 5 points\", and the second meaning is far\n // more common in this catalog. Including it classified margin markets as date\n // ladders.\n if (/\\b(before|under|below|less than|or fewer|or lower|at most)\\b/.test(low)) {\n return { m, threshold, dir: \"down\", series };\n }\n return null;\n}\n\nexport default async function (req: Request): Promise {\n const u = new URL(req.url);\n const minVol = Number(u.searchParams.get(\"minvol\") ?? MIN_VOL);\n const includeIlliquid = u.searchParams.get(\"all\") === \"1\";\n\n const cat = await getKalshiCatalog({ pages: 8 });\n if (!cat.markets.length) {\n return Response.json({ ok: false, error: \"catalog empty\", catalogError: cat.error }, { status: 503 });\n }\n\n const byEvent = new Map();\n for (const m of cat.markets) {\n if (!byEvent.has(m.eventTitle)) byEvent.set(m.eventTitle, []);\n byEvent.get(m.eventTitle)!.push(m);\n }\n\n interface Hit {\n event: string;\n broader: string;\n narrower: string;\n broaderYesAsk: number;\n narrowerNoAsk: number;\n cost: number;\n fees: number;\n guaranteedProfitCents: number;\n minVolume: number;\n tickers: [string, string];\n flags: string[];\n }\n const hits: Hit[] = [];\n let laddersScanned = 0;\n let pairsChecked = 0;\n\n for (const [title, rows] of byEvent) {\n const parsed = rows.map(parseRung).filter((r): r is Rung => r !== null);\n // Split the event into its separate ladders before comparing anything.\n const bySeries = new Map();\n for (const r of parsed) {\n const key = `${r.series}|${r.dir}`;\n if (!bySeries.has(key)) bySeries.set(key, []);\n bySeries.get(key)!.push(r);\n }\n\n for (const rungs of bySeries.values()) {\n if (rungs.length < 3) continue;\n const dir = rungs[0].dir;\n // Distinct thresholds only; duplicates mean we misread the labels.\n const seen = new Set(rungs.map((r) => r.threshold));\n if (seen.size !== rungs.length) continue;\n laddersScanned++;\n\n rungs.sort((a, b) => a.threshold - b.threshold);\n // dir \"up\": lower threshold is the BROADER event (Above 2.0 contains Above 2.5).\n // dir \"down\": higher threshold is the BROADER event (Before 2040 contains Before 2035).\n const ordered = dir === \"up\" ? rungs : [...rungs].reverse();\n\n for (let i = 0; i < ordered.length; i++) {\n for (let k = i + 1; k < ordered.length; k++) {\n const broad = ordered[i], narrow = ordered[k];\n pairsChecked++;\n const a = broad.m.yesAsk, b = narrow.m.noAsk;\n if (!(a > 0 && b > 0)) continue;\n const fees = kalshiTakerFee(a) + kalshiTakerFee(b);\n const cost = a + b + fees;\n if (cost >= 1) continue; // no guaranteed profit\n\n const minVolume = Math.min(broad.m.vol, narrow.m.vol);\n const flags: string[] = [];\n if (a >= STALE_ASK || b >= STALE_ASK) flags.push(\"ask at/above 0.97 — the book is probably empty, not cheap\");\n if (minVolume < minVol) flags.push(`thin: min leg volume ${Math.round(minVolume)}`);\n if (broad.m.vol === 0 || narrow.m.vol === 0) flags.push(\"a leg has never traded\");\n // SAFETY RAIL. A guaranteed profit of this size cannot exist on a\n // venue with market makers. The first version of this scanner reported\n // 80c \"arbitrages\" on liquid midterm markets, and every one was a\n // parsing bug. Treat implausible size as evidence against the scanner,\n // not as evidence of an opportunity.\n if (1 - cost > IMPLAUSIBLE) {\n flags.push(`implausible: ${((1 - cost) * 100).toFixed(0)}c guaranteed is not a real market inefficiency, suspect a parsing error in this ladder`);\n }\n\n hits.push({\n event: title.slice(0, 80),\n broader: broad.m.subtitle.slice(0, 40),\n narrower: narrow.m.subtitle.slice(0, 40),\n broaderYesAsk: a,\n narrowerNoAsk: b,\n cost: +cost.toFixed(4),\n fees: +fees.toFixed(4),\n guaranteedProfitCents: +((1 - cost) * 100).toFixed(2),\n minVolume: Math.round(minVolume),\n tickers: [broad.m.ticker, narrow.m.ticker],\n flags,\n });\n }\n }\n } // end ladder\n }\n\n hits.sort((x, y) => y.guaranteedProfitCents - x.guaranteedProfitCents);\n const clean = hits.filter((h) => h.flags.length === 0);\n const shown = includeIlliquid ? hits : clean;\n\n return Response.json({\n ok: true,\n catalog: { markets: cat.markets.length, usable: cat.usable, ageMin: +cat.ageMin.toFixed(1) },\n scanned: { events: byEvent.size, laddersScanned, pairsChecked },\n found: {\n rawViolations: hits.length,\n survivingLiquidityAndStalenessFilters: clean.length,\n note:\n \"The raw count is not the finding. A violation on a book with no offers is a quoting artifact, and an ask of 0.99 on a market nobody trades means nobody is offering. Only the filtered count is a candidate for a real trade.\",\n },\n verdict: clean.length === 0\n ? `NO TRADEABLE VIOLATIONS. ${hits.length} raw ladder inconsistencies exist, all of them on thin or unquoted books. That is the expected result on a venue with market makers, and it is a clean negative: this particular idea does not pay, and it took one scan rather than one quarter to find out.`\n : `${clean.length} candidate violations survive the liquidity and staleness filters. Verify each by hand against the live order book before believing it: the catalog is a cached snapshot, depth is not modelled, and both legs must actually fill for the guarantee to hold.`,\n results: shown.slice(0, 25),\n caveats: [\n \"The catalog is a cached snapshot and may be minutes to hours old. A violation that was real when cached can be gone now.\",\n \"Asks carry no depth information here, so a quoted ask may be for a single contract.\",\n \"This assumes both legs fill. Filling one leg and not the other converts a guaranteed profit into an outright directional position, which is the standard way arbitrage strategies actually lose money.\",\n \"Kalshi taker fees are charged on both legs and are included above. Maker execution would change these numbers materially.\",\n ],\n });\n}\n",[],[447],"55fafc34-3cd3-405d-8872-21ed78014cc3","coherence-probe.tsx","22a362d8-b303-11f1-bf06-1607ee4eb77e",202,["D",1789696147249],"import { getKalshiCatalog } from \"./matcher.ts\";\n\n// coherence-probe.tsx — WHAT IS EVEN DETECTABLE?\n//\n// Before building a coherence scanner, find out which logical constraints can\n// actually fire against the data we hold. The obvious check — YES ask plus NO\n// ask costing less than a dollar — may be structurally impossible on Kalshi,\n// because a single order book usually quotes NO as the mirror of YES\n// (no_ask = 100 - yes_bid), in which case yesAsk + noAsk = 100 + spread and is\n// never below 100 by construction. Shipping a scanner built on a vacuous test\n// would return zero hits and read as \"no opportunities exist\", which is the\n// exact failure mode this project keeps producing.\n//\n// So: measure the distribution first, then build the detector around whatever\n// survives.\n\nexport default async function (): Promise {\n const cat = await getKalshiCatalog({ pages: 6 });\n const m = cat.markets;\n if (!m.length) {\n return Response.json({ ok: false, error: \"catalog empty\", cat: { total: cat.total, error: cat.error } }, { status: 503 });\n }\n\n // 1) Complement sum. If this is always >= 1.00, the single-market arbitrage\n // check cannot fire and should not be built.\n const sums = m.filter((x) => x.yesAsk > 0 && x.noAsk > 0).map((x) => x.yesAsk + x.noAsk);\n sums.sort((a, b) => a - b);\n const q = (p: number) => (sums.length ? +sums[Math.floor(p * (sums.length - 1))].toFixed(4) : null);\n const below1 = sums.filter((s) => s < 0.9999).length;\n\n // 2) Event grouping. Multi-outcome events are where partition and ladder\n // constraints live, so count how much structure there is to work with.\n const byEvent = new Map();\n for (const x of m) {\n if (!byEvent.has(x.eventTitle)) byEvent.set(x.eventTitle, []);\n byEvent.get(x.eventTitle)!.push(x);\n }\n const groups = [...byEvent.entries()].map(([title, rows]) => ({ title, n: rows.length, rows }));\n const multi = groups.filter((g) => g.n > 1);\n\n // 3) Ladder detectability: outcomes whose subtitle carries a single number,\n // which is what a threshold ladder looks like.\n const numOf = (s: string): number | null => {\n const mm = String(s).replace(/,/g, \"\").match(/-?\\d+(\\.\\d+)?/);\n return mm ? parseFloat(mm[0]) : null;\n };\n const ladderish = multi.filter((g) => {\n const nums = g.rows.map((r) => numOf(r.subtitle)).filter((x): x is number => x != null);\n return nums.length >= 3 && new Set(nums).size === nums.length;\n });\n\n // 4) For multi-outcome events, what does the YES sum look like? Below 1.00\n // on a mutually exclusive AND exhaustive event is a Dutch book. Exclusivity\n // is an ASSUMPTION here, not a fact, which is why this is a probe.\n const yesSums = multi.map((g) => ({\n title: g.title.slice(0, 70),\n n: g.n,\n yesSum: +g.rows.reduce((a, r) => a + r.yesAsk, 0).toFixed(4),\n noSum: +g.rows.reduce((a, r) => a + r.noAsk, 0).toFixed(4),\n vol: Math.round(g.rows.reduce((a, r) => a + r.vol, 0)),\n }));\n const underOne = yesSums.filter((g) => g.yesSum < 0.999).sort((a, b) => a.yesSum - b.yesSum);\n // For N mutually exclusive outcomes exactly N-1 NO legs pay, so a NO basket\n // costing less than N-1 is the mirror-image Dutch book.\n const noBook = yesSums.filter((g) => g.noSum < g.n - 1 - 0.001).sort((a, b) => (a.noSum - (a.n - 1)) - (b.noSum - (b.n - 1)));\n\n return Response.json({\n ok: true,\n catalog: { total: cat.total, usable: cat.usable, ageMin: +cat.ageMin.toFixed(1), error: cat.error },\n complementSum: {\n n: sums.length,\n min: q(0), p05: q(0.05), median: q(0.5), p95: q(0.95), max: q(1),\n countBelow1: below1,\n verdict: below1 === 0\n ? \"VACUOUS — yesAsk + noAsk is never below 1.00, consistent with NO being quoted as the mirror of YES on one book. A single-market complement scan cannot fire and should not be built.\"\n : `${below1} markets quote both sides for under a dollar — worth a closer look, but check these are real two-sided quotes and not stale data.`,\n },\n structure: {\n events: groups.length,\n multiOutcomeEvents: multi.length,\n largestEvent: Math.max(...groups.map((g) => g.n)),\n ladderShapedEvents: ladderish.length,\n ladderSample: ladderish.slice(0, 5).map((g) => ({\n title: g.title.slice(0, 70),\n outcomes: g.rows.slice(0, 6).map((r) => ({ sub: r.subtitle.slice(0, 24), yes: r.yesAsk })),\n })),\n },\n dutchBookCandidates: {\n yesBasketUnderOne: underOne.length,\n yesSample: underOne.slice(0, 8),\n noBasketUnderNMinus1: noBook.length,\n noSample: noBook.slice(0, 8),\n WARNING:\n \"Exclusivity and exhaustiveness are ASSUMED here, not verified. Many Kalshi events group independent yes/no questions that are not a partition at all, and for those a YES sum below 1.00 is perfectly normal and not an arbitrage. Nothing here is tradeable until the event is confirmed to be a true partition and the asks are confirmed to have depth.\",\n },\n });\n}\n",[],[455],"f788f521-22ac-4929-be66-0cf60d3aef91","README.md","01a0ac2c-e909-715a-acf6-a11d788c48c7",["D",1789595019450],"# Welcome to Val Town\n\nVal Town is the simplest way to get code running in the cloud.\n\nThis is a basic HTML starter template.\n\n## Picking a starter\n\n| Starter | When to pick it |\n| --- | --- |\n| **[`basic-html-starter`](https://www.val.town/x/templates/basic-html-starter)** *(you're here)* | Static HTML pages. Sprinkle of vanilla JS. No server-side rendering. |\n| [`hono-jsx-starter`](https://www.val.town/x/templates/hono-jsx-starter) | Dynamic server-rendered HTML with JSX. API routes. No React, no SPA. |\n| [`react-hono-starter`](https://www.val.town/x/templates/react-hono-starter) | Client-side React SPA with a Hono API backend. |\n\n## Getting started\n\n1. Click `Remix` on this val to get a copy of it\n2. Click `main.tsx` to view the website\n3. Saves to any file will instantly deploy\n\n### ← main.tsx\n\nThis HTTP server hosts all of the other files in this val.\n\nTo view your site in a new tab, click on the `...` menu of `main.tsx` to copy\nyour live HTTP endpoint.\n\n### ← README.md\n\nThat's this file, where you can tell people what your cool website does and how\nyou built it.\n\n### ← index.html\n\nWhere you'll write the content of your website.\n\n### ← style.css\n\nCSS files add styling rules to your content.\n\n### ← script.js\n\nIf you're feeling fancy you can add interactivity to your site with JavaScript.\n\n### ← favicon.svg\n\nThe icon that shows up in the brower tab. Tip: AIs are pretty good at writing\nSVG favicons.\n\n---\n\nThis template was inspired by https://glitch.new/blank.\n",[],[463],["D",1789595019450],["D",1789683064331],{"_11":12,"_134":71},{"_11":12,"_129":130,"_70":71,"_30":69,"_131":132,"_133":24},{"_39":120,"_13":16,"_33":36,"_121":81,"_122":-5,"_123":-5,"_124":-5,"_125":-5,"_126":-5,"_127":14,"_128":12},"ctx",{"_54":-5,"_153":507,"_508":509,"_510":511,"_512":24,"_513":24,"_514":24,"_515":94,"_516":-5,"_517":-7,"_518":-7,"_519":26,"_520":24,"_521":24,"_522":-5,"_523":24,"_524":24,"_525":24,"_526":-5},"ENV",{"_478":479,"_480":481,"_482":16,"_483":484,"_485":486,"_487":488,"_489":490,"_491":492,"_493":494,"_495":496,"_497":498,"_499":500,"_501":502,"_503":504,"_505":506},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","71c1b20804b3232a7e513be260cfffc1932a9e97","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 · smartmoney_http.tsx