[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_187":188,"_189":190},"routes/_app.x.$handle.$name",{"_11":12,"_13":14,"_15":16,"_18":19,"_17":-7,"_140":-5,"_20":141,"_22":142,"_143":144,"_145":146,"_25":147,"_24":-5,"_148":-5,"_149":-5,"_150":55,"_151":152,"_153":55,"_154":-5,"_155":-5,"_156":157},"routes/_app.x.$handle.$name.branch.$branch.code.$",{"_11":12,"_13":14,"_15":16,"_17":-7,"_18":19,"_20":21,"_22":23,"_24":-7,"_25":26,"_27":-5,"_28":-5,"_29":-5,"_30":-5,"_31":-5},"handle","stevekrouse","name","autollm","branchName","main","version","path","","project",{"_35":87,"_13":14,"_47":88,"_89":-5,"_90":55,"_91":92,"_93":92,"_94":19,"_95":19,"_96":97,"_98":-5,"_99":55,"_100":-5,"_101":-5,"_102":63,"_103":104,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":110,"_111":110,"_112":113,"_114":113,"_115":113,"_116":110,"_117":110,"_118":119,"_120":121,"_122":123,"_124":55},"tree",[74,75,76],"file","contents",[32,33,34],"upstream","pull","ahead","behind","envVars",{"_35":66,"_13":67,"_38":68,"_40":-5,"_41":42,"_43":69,"_45":46,"_47":70,"_17":71,"_50":24,"_52":72,"_54":55,"_56":-5,"_18":73},{"_35":58,"_13":59,"_38":60,"_40":-5,"_41":42,"_43":61,"_45":46,"_47":62,"_17":63,"_50":24,"_52":64,"_54":55,"_56":-5,"_18":65},{"_35":36,"_13":37,"_38":39,"_40":-5,"_41":42,"_43":44,"_45":46,"_47":48,"_17":49,"_50":51,"_52":53,"_54":55,"_56":-5,"_18":57},"id","05e75316-11e6-11f1-8441-42dde27851f2","main.ts","fileId","445f2eb8-11e4-11f1-97e5-42dde27851f2","parentId","branchId","445d2d34-11e4-11f1-97e5-42dde27851f2","branchVersion",24,"latest",true,"createdAt",["D",1771981506429],21,"fileType","script","content","// microgpt_conal.ts\n// Conal-style reverse-mode AD in TypeScript: every computation returns\n// (value, backprop-function). Backprop functions compose automatically.\n//\n// Goal: char-level next-token predictor trained on the full\n// Karpathy makemore names.txt (~32K names), then sample new names.\n// Architecture: embedding -> concat -> hidden(tanh) -> output\n//\n// Run with: npx tsx microgpt_conal.ts\n\ntype Mat = Float32Array; // row-major, shape (rows, cols)\n\nfunction nowMs() {\n return Date.now();\n}\n\n// ---------- fetch the full dataset ----------\nconst NAMES_URL =\n \"https://raw.githubusercontent.com/karpathy/makemore/refs/heads/master/names.txt\";\n\nconst resp = await fetch(NAMES_URL);\nconst text = await resp.text();\nconst allDocs = text.trim().split(\"\\n\").map((l) => l.trim()).filter(Boolean);\nconsole.log(`Loaded ${allDocs.length} names from names.txt`);\n\nfunction shuffle(a: T[], seed = 0) {\n let x = seed >>> 0;\n function rnd() {\n x = (1664525 * x + 1013904223) >>> 0;\n return x / 2 ** 32;\n }\n for (let i = a.length - 1; i > 0; i--) {\n const j = Math.floor(rnd() * (i + 1));\n [a[i], a[j]] = [a[j], a[i]];\n }\n}\n\nshuffle(allDocs, 0);\nconst splitIdx = Math.floor(allDocs.length * 0.9);\nconst trainDocs = allDocs.slice(0, splitIdx);\nconst testDocs = allDocs.slice(splitIdx);\nconsole.log(`Train: ${trainDocs.length}, Test: ${testDocs.length}`);\n\n// vocab\nconst BOS = \".\";\nconst charSet = new Set();\nfor (const d of allDocs) for (const ch of d) charSet.add(ch);\nconst chars = Array.from(charSet).sort();\nconst vocab = [BOS, ...chars];\nconst stoi = new Map(vocab.map((c, i) => [c, i]));\nconst itos = vocab;\nconst V = vocab.length;\nconsole.log(`Vocab size: ${V}`);\n\nfunction encodeName(s: string): number[] {\n const ids: number[] = [stoi.get(BOS)!];\n for (const ch of s) ids.push(stoi.get(ch)!);\n ids.push(stoi.get(BOS)!);\n return ids;\n}\n\n// dataset: context window K predicts next char\nconst K = 5;\nfunction buildDataset(docs: string[]): { xs: number[][]; ys: number[] } {\n const xs: number[][] = [];\n const ys: number[] = [];\n for (const d of docs) {\n const t = encodeName(d);\n const ctx = new Array(K).fill(stoi.get(BOS)!);\n for (let i = 1; i < t.length; i++) {\n xs.push(ctx.slice());\n ys.push(t[i]);\n ctx.shift();\n ctx.push(t[i]);\n }\n }\n return { xs, ys };\n}\n\nconst { xs, ys } = buildDataset(trainDocs);\nconst N = xs.length;\nconst { xs: testXs, ys: testYs } = buildDataset(testDocs);\nconsole.log(`Training examples: ${N}, Test examples: ${testXs.length}`);\n\n// ---------- Conal-style AD core ----------\n//\n// ELI5: A Node is \"a value\" plus \"a function that knows how to send blame backward\".\n// - v: the computed number(s)\n// - back(g): given upstream sensitivity g, propagate it to this node's inputs\n//\n// This back(g) *is* the derivative object, represented in reverse form.\nclass Node {\n v: T;\n back: (g: any) => void;\n constructor(v: T, back?: (g: any) => void) {\n this.v = v;\n this.back = back ?? (() => {});\n }\n}\n\n// A Param is a trainable knob θ.\n// ELI5: It stores its current value, and a gradient bucket.\nclass Param {\n v: Mat;\n g: Mat;\n rows: number;\n cols: number;\n\n constructor(rows: number, cols: number, scale = 0.01, seed = 0) {\n this.rows = rows;\n this.cols = cols;\n this.v = new Float32Array(rows * cols);\n this.g = new Float32Array(rows * cols);\n let x = (seed >>> 0) || 1;\n function rndn() {\n let s = 0;\n for (let i = 0; i < 6; i++) {\n x = (1664525 * x + 1013904223) >>> 0;\n s += x / 2 ** 32;\n }\n return s - 3;\n }\n for (let i = 0; i < this.v.length; i++) this.v[i] = scale * rndn();\n }\n\n zeroGrad() {\n this.g.fill(0);\n }\n\n node(): Node {\n return new Node(this.v, (g: Mat) => {\n for (let i = 0; i < this.g.length; i++) this.g[i] += g[i];\n });\n }\n}\n\n// ---------- math helpers ----------\nfunction mi(r: number, c: number, cols: number) {\n return r * cols + c;\n}\n\nfunction softmax1(logits: Float64Array): Float64Array {\n let max = -Infinity;\n for (let i = 0; i < logits.length; i++) if (logits[i] > max) max = logits[i];\n let sum = 0;\n const exps = new Float64Array(logits.length);\n for (let i = 0; i < logits.length; i++) {\n exps[i] = Math.exp(logits[i] - max);\n sum += exps[i];\n }\n for (let i = 0; i < logits.length; i++) exps[i] /= sum;\n return exps;\n}\n\n// ---------- primitives (each returns Node(value, backprop)) ----------\n\n// gather_rows: E:(V,Emb), idx:(B,K) -> out:(B, K*Emb) (concatenated!)\n// ELI5: look up secret codes for each letter, then glue them together into one long vector\nfunction gatherAndConcat(\n E: Node,\n idx: number[][],\n V: number,\n Emb: number,\n): Node {\n const B = idx.length;\n const outDim = K * Emb;\n const out = new Float32Array(B * outDim);\n\n for (let b = 0; b < B; b++) {\n for (let k = 0; k < K; k++) {\n const row = idx[b][k];\n for (let d = 0; d < Emb; d++) {\n out[b * outDim + k * Emb + d] = E.v[mi(row, d, Emb)];\n }\n }\n }\n\n const back = (g: Float32Array) => {\n const dE = new Float32Array(V * Emb);\n for (let b = 0; b < B; b++) {\n for (let k = 0; k < K; k++) {\n const row = idx[b][k];\n for (let d = 0; d < Emb; d++) {\n dE[mi(row, d, Emb)] += g[b * outDim + k * Emb + d];\n }\n }\n }\n E.back(dE);\n };\n\n return new Node(out, back);\n}\n\n// matmul: X:(B,inD) @ W^T where W:(outD,inD) + bias:(outD) => out:(B,outD)\n// ELI5: each hidden neuron looks at the whole input and forms an opinion\nfunction linearLayer(\n X: Node,\n W: Node,\n bias: Node,\n B: number,\n inD: number,\n outD: number,\n): Node {\n const out = new Float32Array(B * outD);\n\n for (let b = 0; b < B; b++) {\n for (let o = 0; o < outD; o++) {\n let s = bias.v[o];\n for (let i = 0; i < inD; i++) s += X.v[b * inD + i] * W.v[mi(o, i, inD)];\n out[b * outD + o] = s;\n }\n }\n\n const back = (g: Float32Array) => {\n // dX = g @ W\n const dX = new Float32Array(B * inD);\n for (let b = 0; b < B; b++) {\n for (let i = 0; i < inD; i++) {\n let s = 0;\n for (let o = 0; o < outD; o++) s += g[b * outD + o] * W.v[mi(o, i, inD)];\n dX[b * inD + i] = s;\n }\n }\n\n // dW = g^T @ X\n const dW = new Float32Array(outD * inD);\n for (let o = 0; o < outD; o++) {\n for (let i = 0; i < inD; i++) {\n let s = 0;\n for (let b = 0; b < B; b++) s += g[b * outD + o] * X.v[b * inD + i];\n dW[mi(o, i, inD)] = s;\n }\n }\n\n // dBias = sum over batch\n const dBias = new Float32Array(outD);\n for (let b = 0; b < B; b++) {\n for (let o = 0; o < outD; o++) {\n dBias[o] += g[b * outD + o];\n }\n }\n\n X.back(dX);\n W.back(dW);\n bias.back(dBias);\n };\n\n return new Node(out, back);\n}\n\n// tanh activation: elementwise tanh\n// ELI5: squish each number into the range (-1, 1) — keeps things from exploding\nfunction tanhAct(\n x: Node,\n len: number,\n): Node {\n const out = new Float32Array(len);\n for (let i = 0; i < len; i++) out[i] = Math.tanh(x.v[i]);\n\n const back = (g: Float32Array) => {\n // dtanh/dx = 1 - tanh(x)^2\n const dx = new Float32Array(len);\n for (let i = 0; i < len; i++) dx[i] = g[i] * (1 - out[i] * out[i]);\n x.back(dx);\n };\n\n return new Node(out, back);\n}\n\n// cross-entropy loss from logits, mean over batch\nfunction xentFromLogits(\n logits: Node,\n y: number[],\n B: number,\n V: number,\n): Node {\n const probs = new Float64Array(B * V);\n let loss = 0;\n\n for (let b = 0; b < B; b++) {\n const row = new Float64Array(V);\n for (let v = 0; v < V; v++) row[v] = logits.v[b * V + v];\n const p = softmax1(row);\n for (let v = 0; v < V; v++) probs[b * V + v] = p[v];\n loss += -Math.log(p[y[b]] + 1e-12);\n }\n loss /= B;\n\n const back = (gscalar: number) => {\n const dLogits = new Float32Array(B * V);\n for (let b = 0; b < B; b++) {\n for (let v = 0; v < V; v++) {\n let g = probs[b * V + v];\n if (v === y[b]) g -= 1.0;\n dLogits[b * V + v] = (g / B) * gscalar;\n }\n }\n logits.back(dLogits);\n };\n\n return new Node(loss, back);\n}\n\n// ---------- model ----------\n//\n// Architecture (Bengio-style MLP, like Karpathy's makemore part 2):\n// emb = E[ctx] -> (B, K*Emb) concatenated embeddings\n// h = tanh(emb @ W1^T + b1) -> (B, H) hidden layer\n// logits = h @ W2^T + b2 -> (B, V) output logits\n// loss = cross-entropy(logits, target)\n\nconst Emb = 10; // embedding dimension per character\nconst H = 128; // hidden layer size\nconst inDim = K * Emb; // 3 * 10 = 30\n\n// Kaiming-ish init for tanh: scale = gain / sqrt(fan_in)\n// gain for tanh ≈ 5/3\nconst w1Scale = (5 / 3) / Math.sqrt(inDim);\nconst w2Scale = 0.01; // small init for output layer\n\nconst pE = new Param(V, Emb, 0.1, 1); // embedding table\nconst pW1 = new Param(H, inDim, w1Scale, 2); // hidden weights\nconst pB1 = new Param(1, H, 0, 3); // hidden biases (zero init)\nconst pW2 = new Param(V, H, w2Scale, 4); // output weights\nconst pB2 = new Param(1, V, 0, 5); // output biases (zero init)\n\nconst allParams = [pE, pW1, pB1, pW2, pB2];\nconst totalParams = allParams.reduce((s, p) => s + p.v.length, 0);\nconsole.log(`Model parameters: ${totalParams}`);\n\nfunction forwardBatch(xb: number[][], yb: number[]): Node {\n const B = xb.length;\n const En = pE.node();\n const W1n = pW1.node();\n const B1n = pB1.node();\n const W2n = pW2.node();\n const B2n = pB2.node();\n\n const emb = gatherAndConcat(En, xb, V, Emb);\n const preact = linearLayer(emb, W1n, B1n, B, inDim, H);\n const h = tanhAct(preact, B * H);\n const logits = linearLayer(h, W2n, B2n, B, H, V);\n return xentFromLogits(logits, yb, B, V);\n}\n\n// evaluate loss on a dataset (no gradient needed)\nfunction evalLoss(exs: number[][], eys: number[]): number {\n const chunkSize = 1024;\n let totalLoss = 0;\n let totalCount = 0;\n for (let i = 0; i < exs.length; i += chunkSize) {\n const end = Math.min(i + chunkSize, exs.length);\n const xb = exs.slice(i, end);\n const yb = eys.slice(i, end);\n const B = xb.length;\n\n const En = new Node(pE.v);\n const W1n = new Node(pW1.v);\n const B1n = new Node(pB1.v);\n const W2n = new Node(pW2.v);\n const B2n = new Node(pB2.v);\n\n const emb = gatherAndConcat(En, xb, V, Emb);\n const preact = linearLayer(emb, W1n, B1n, B, inDim, H);\n const h = tanhAct(preact, B * H);\n const logits = linearLayer(h, W2n, B2n, B, H, V);\n const loss = xentFromLogits(logits, yb, B, V);\n totalLoss += loss.v * B;\n totalCount += B;\n }\n return totalLoss / totalCount;\n}\n\n// ---------- training ----------\nfunction randint(n: number, seedObj: { x: number }) {\n seedObj.x = (1664525 * seedObj.x + 1013904223) >>> 0;\n return seedObj.x % n;\n}\n\nconst TIMEOUT_MS = 10_000;\nconst seedObj = { x: 123 };\nconst t0 = nowMs();\nlet steps = 0;\nlet lastLoss = NaN;\n\nconsole.log(`\\nTraining for ${TIMEOUT_MS / 1000}s...`);\n\nwhile (true) {\n if (nowMs() - t0 >= TIMEOUT_MS) break;\n\n const B = 64;\n const xb: number[][] = new Array(B);\n const yb: number[] = new Array(B);\n for (let i = 0; i < B; i++) {\n const j = randint(N, seedObj);\n xb[i] = xs[j];\n yb[i] = ys[j];\n }\n\n for (const p of allParams) p.zeroGrad();\n\n const loss = forwardBatch(xb, yb);\n lastLoss = loss.v;\n\n // ELI5: kick off reverse mode — \"the loss depends on itself by 1\"\n loss.back(1.0);\n\n // learning rate with step decay\n const lr = steps < 2500 ? 0.5 : 0.05;\n for (const p of allParams) {\n for (let i = 0; i < p.v.length; i++) p.v[i] -= lr * p.g[i];\n }\n\n steps++;\n\n if (steps % 1000 === 0) {\n const elapsed = ((nowMs() - t0) / 1000).toFixed(1);\n console.log(` step ${steps} | loss ${lastLoss.toFixed(4)} | lr ${lr} | ${elapsed}s`);\n }\n}\n\nconst elapsed = (nowMs() - t0) / 1000;\nconsole.log(`\\nTraining done!`);\nconsole.log(` Elapsed: ${elapsed.toFixed(3)}s`);\nconsole.log(` Steps: ${steps}`);\nconsole.log(` Final train batch loss: ${lastLoss.toFixed(4)}`);\n\nconst trainLoss = evalLoss(xs, ys);\nconst testLoss = evalLoss(testXs, testYs);\nconsole.log(` Full train loss: ${trainLoss.toFixed(4)}`);\nconsole.log(` Full test loss: ${testLoss.toFixed(4)}`);\n\n// ---------- sampling ----------\nfunction sample(n = 20, maxlen = 16, temperature = 0.8) {\n const out: string[] = [];\n for (let s = 0; s < n; s++) {\n const ctx = new Array(K).fill(stoi.get(BOS)!);\n let name = \"\";\n for (let t = 0; t < maxlen; t++) {\n // forward pass for single example\n const emb = new Float32Array(inDim);\n for (let k = 0; k < K; k++) {\n const row = ctx[k];\n for (let d = 0; d < Emb; d++) emb[k * Emb + d] = pE.v[mi(row, d, Emb)];\n }\n\n // hidden = tanh(emb @ W1^T + b1)\n const h = new Float32Array(H);\n for (let o = 0; o < H; o++) {\n let s2 = pB1.v[o];\n for (let i = 0; i < inDim; i++) s2 += emb[i] * pW1.v[mi(o, i, inDim)];\n h[o] = Math.tanh(s2);\n }\n\n // logits = h @ W2^T + b2\n const logits = new Float64Array(V);\n for (let v = 0; v < V; v++) {\n let s2 = pB2.v[v];\n for (let i = 0; i < H; i++) s2 += h[i] * pW2.v[mi(v, i, H)];\n logits[v] = s2 / Math.max(1e-8, temperature);\n }\n const p = softmax1(logits);\n\n // categorical sample\n seedObj.x = (1664525 * seedObj.x + 1013904223) >>> 0;\n let r = seedObj.x / 2 ** 32;\n let acc = 0;\n let nxt = 0;\n for (let v = 0; v < V; v++) {\n acc += p[v];\n if (r <= acc) {\n nxt = v;\n break;\n }\n }\n\n if (nxt === stoi.get(BOS)!) break;\n name += itos[nxt];\n ctx.shift();\n ctx.push(nxt);\n }\n out.push(name);\n }\n return out;\n}\n\nconsole.log(\"\\nGenerated names:\");\nfor (const [i, s] of sample(20).entries()) {\n console.log(String(i + 1).padStart(2, \" \"), \":\", s);\n}\n","deleted",false,"label",[37],"11d72bb8-1247-11f1-ae9d-42dde27851f2","diffusion.md","11d72c6c-1247-11f1-ae9d-42dde27851f2",26,["D",1772023187641],0,"# 🌊 From Characters to Diffusion: A Denotational Design\n\n> **\"Don't start with the implementation. Start with what the thing *means*.\"**\n> — The Conal Elliott principle\n\nThis document records our thinking about how to extend AutoLLM from autoregressive (one-character-at-a-time) generation to **diffusion-style generation** (all characters at once). We follow Conal Elliott's **denotational design** methodology: pin down the mathematical meaning first, derive the implementation from it, and let the algebra tell us what the code must be.\n\n---\n\n## 🎯 The Question\n\nAutoLLM currently generates names left-to-right:\n\n```\n. → e → m → m → a → .\n```\n\nWhat if we generated the whole name at once — like how a diffusion model generates an entire image simultaneously?\n\n## 🔑 Step 1: The Current Denotation\n\nBefore changing anything, we must be precise about what the current model *means*.\n\n**Semantic type of the autoregressive model:**\n\n```\nnextChar : Vector(K, Char) → Distribution(Char)\n```\n\nGiven K characters of context, produce a probability distribution over the next character. The joint probability of a whole name factors as a product of conditionals:\n\n```\nP(\"emma\") = P(e|.) · P(m|.e) · P(m|.em) · P(a|.emm) · P(.|.emma)\n```\n\nThis factorization **is** the meaning. Left-to-right generation isn't a design choice — it's an inevitable consequence of the semantics. If we want a different generation strategy, we need a different denotation.\n\n**Conal's lesson:** You can't get \"all at once\" generation by patching the sampling loop. You need to change what the model *means*.\n\n## 🔑 Step 2: The New Denotation\n\nFor \"all at once\" generation, we need a model whose meaning is the **joint distribution over entire names** — not factored left-to-right.\n\nThe direct joint `P(x₁, x₂, ..., x_L)` is intractable (27^L possibilities). So we need a tractable representation. Three candidates, each a different mathematical object:\n\n### Candidate A: Independent Positions\n\n```\nP(x₁, ..., x_L) ≈ ∏ᵢ P(xᵢ)\n```\n\nEach position independent. **Too weak** — knowing position 1 is \"e\" tells you a lot about position 2. This denotation can't capture the structure of names.\n\n### Candidate B: Markov Chain of Refinements (Discrete Diffusion) ✅\n\n```\nP(x₁, ..., x_L) = Σ over paths: P(x⁰) · ∏ₜ P(xᵗ | xᵗ⁻¹)\n```\n\nwhere `x⁰` is pure noise (all masks), `xᵀ` is the clean name, and each transition is a **denoising step** that makes the whole sequence a little less corrupted.\n\n### Candidate C: Conditional Independence Given Latent (VAE)\n\n```\nP(x₁, ..., x_L) = ∫ P(z) · ∏ᵢ P(xᵢ | z) dz\n```\n\nA latent variable z captures the \"identity\" of the name; conditioned on z, characters are independent.\n\n**We choose Candidate B** — the Markov chain of refinements — because it's closest to the diffusion intuition and decomposes naturally into repeated application of a single learned function.\n\n## 🔑 Step 3: Pinning Down the Semantic Type\n\nThe denotation is a single function:\n\n```\ndenoise : MaskedName × NoiseLevel → Vector(L, Distribution(Char))\n```\n\nwhere:\n\n- `Name = Vector(L, Char)` — a fixed-length sequence of characters\n- `MaskedName = Vector(L, Char ∪ {MASK})` — same, but some positions are masked\n- `NoiseLevel ∈ [0, 1]` — the fraction of positions currently masked\n- `Distribution(Char)` — a categorical distribution over the 27-character vocabulary\n\nThe model takes a corrupted name and produces, for each position, a probability distribution over what character belongs there.\n\n**This type signature is the north star.** Every design decision that follows must be consistent with it.\n\n## 🔑 Step 4: The Laws\n\nConal would insist: **what laws must this function satisfy?** These laws define correctness — they are what it *means* for the model to be right.\n\n### Law 1: Identity at Zero Noise\n\n```\ndenoise(name, 0) = pointDistribution(name)\n```\n\nIf nothing is masked, the model should predict exactly what it sees, with probability 1. This is a boundary condition: a perfect denoiser at noise level 0 is the identity function.\n\n### Law 2: Marginal at Full Noise\n\n```\ndenoise(MASK...MASK, 1) ≈ marginal distribution over characters at each position\n```\n\nWhen everything is masked, there's no context to use. The model can only rely on positional priors (e.g., names tend to start with consonants, end with vowels). This is another boundary condition.\n\n### Law 3: Consistency Across Noise Levels\n\nThe predictions at noise level `t` should be consistent with predictions at noise level `t + ε`. Masking one more position shouldn't cause the predictions for the *remaining* positions to wildly contradict what they were before. Formally: the Markov chain should converge, not oscillate.\n\n### Law 4: Permutation Equivariance of Masking\n\nThe model's predictions for position `i` should depend on *which* positions are masked, not on the *order* in which they were masked. Masking is a set operation, not a sequence operation.\n\n**These four laws are our specification.** Training is: find parameters such that these laws hold approximately on the data distribution.\n\n## 🔑 Step 5: Deriving the Loss Function\n\nThe loss function isn't a design choice — it **follows from the denotation**.\n\nThe model's meaning at each position is `Distribution(Char)`. The natural measure of fit between a predicted distribution and an observed character is the negative log-likelihood:\n\n```\nℒ = -Σᵢ [isMasked(i)] · log P_model(xᵢ | corrupted_name, noise_level)\n```\n\nWe sum only over masked positions because:\n- At unmasked positions, Law 1 says the prediction should be trivial (just copy the input)\n- The interesting learning signal comes from reconstructing what's been hidden\n\nThis is cross-entropy — the same loss we already have. The denotation tells us we're applying it per-position over masked slots rather than once for a single next-character prediction.\n\n## 🔑 Step 6: Deriving the Sampling Algorithm\n\nThe sampling procedure is also **determined by the denotation**, not invented separately.\n\nSince the meaning is a Markov chain of refinements, generation is iteration of `denoise` from high noise to low noise:\n\n```\nx⁰ = [MASK, MASK, MASK, ..., MASK] (noise_level = 1.0)\nx¹ = unmask some positions via denoise (noise_level ≈ 0.8)\nx² = unmask more positions via denoise (noise_level ≈ 0.5)\n...\nxᵀ = fully unmasked name (noise_level = 0.0)\n```\n\nAt each step, the model predicts all positions, and we **unmask the most confident** predictions — the positions where the model's predicted distribution has the lowest entropy.\n\nThe number of diffusion steps T and the schedule (how many to unmask per step) are parameters, but the *structure* — iterate denoise from noise to clarity — is forced by the denotation.\n\n## 🔑 Step 7: From Denotation to Architecture\n\n**Only now** does Conal let us think about implementation.\n\nThe denotation constrains the **interface** but not the **internals**:\n\n| Constraint (from denotation) | What it forces |\n|---|---|\n| Input is a whole sequence | Model must be **bidirectional** (not left-to-right) |\n| Output is per-position distributions | Output shape is `L × V` |\n| Conditions on noise level | Noise level must be an explicit input |\n| Must handle MASK tokens | Vocabulary grows by 1 (V: 27 → 28) |\n| Fixed-length representation | Names padded to max length L |\n\nThe **representation choice** (MLP vs. attention vs. convolution) is free. For our MLP-based model, the simplest realization:\n\n```\nInput: L character IDs (some are MASK), plus noise_level\nEmbed: Look up each character in E (28 × Emb), concatenate all L\nConcat: Append noise_level embedding to the flat vector\nHidden: h = tanh(W₁ · concat + b₁) (bidirectional: sees all positions)\nOutput: logits = W₂ · h + b₂ shape: (L × V)\n```\n\nThis is almost identical to what we have now. The only structural differences:\n- Input is the full name (L positions) rather than a K-character left context\n- Output is L × V logits rather than 1 × V\n- The MASK token exists in the vocabulary\n- Noise level is threaded through as a conditioning signal\n\n## 🔑 Step 8: The Homomorphism Is Already Correct\n\nThe deepest Conal move: the AD framework should be a **homomorphism** — it should map the algebraic structure of function composition to the algebraic structure of the chain rule:\n\n```\nD(f ∘ g) = D(f) ∘ D(g)\n```\n\nOur `Node` / `back(g)` pattern already satisfies this. Every primitive returns `(value, backpropagator)`, and backpropagators compose by calling each other. This is a correct homomorphism from the category of smooth functions to the category of linear maps.\n\n**For the diffusion model, nothing changes here.** We might add new primitives (masking, noise-level embedding, multi-position output), and each one gets a `(value, back)` pair. They compose the same way. The AD framework is already correct — we just compose different things.\n\n## 📋 Summary of Changes\n\n| Aspect | Current (Autoregressive) | New (Diffusion) |\n|---|---|---|\n| **Denotation** | `P(xₜ ∣ x₁...xₜ₋₁)` | `denoise : MaskedName × NoiseLevel → Vector(L, Dist(Char))` |\n| **Generation** | Sequential: one char at a time | Iterative: all chars, refine over T steps |\n| **Vocab** | 27 (a-z + BOS) | 28 (+ MASK) |\n| **Input** | K=5 char left context | L=16 chars (full name, some masked) |\n| **Output** | V=27 logits (one position) | L×V logits (all positions) |\n| **Loss** | Cross-entropy on next char | Cross-entropy on masked positions |\n| **Dataset** | Sliding window within names | Whole names with random masking |\n| **AD framework** | `Node`, unchanged | `Node`, unchanged |\n| **Laws** | Chain rule of probability | Identity at noise=0, marginal at noise=1, consistency, equivariance |\n\n## 🧭 The Conal Checklist\n\nBefore writing any code, verify:\n\n- [x] **Denotation stated precisely** — semantic type is `denoise : MaskedName × NoiseLevel → Vector(L, Distribution(Char))`\n- [x] **Laws identified** — identity, marginal, consistency, equivariance\n- [x] **Loss derived from meaning** — cross-entropy follows from the `Distribution(Char)` codomain\n- [x] **Sampling derived from meaning** — iterative unmasking follows from the Markov chain structure\n- [x] **Architecture constrained by type** — bidirectional, multi-position output, noise-level conditioning\n- [x] **AD homomorphism preserved** — `Node` pattern unchanged\n- [ ] **Implementation** — write the code, confident that every choice is forced by the mathematics\n\n---\n\n*The model changes. The framework doesn't. That's the power of getting the denotation right.*\n",[59],"4376b2e6-11f3-11f1-a70c-42dde27851f2","README.md","a63696d0-11e4-11f1-98e2-42dde27851f2",25,["D",1771987193163],2,"# 🧒 AutoLLM — An LLM You Can Explain to a 5-Year-Old\n\n> **What if building a language model was like playing with LEGOs?**\n\nThis is a **character-level language model** that learns to invent new baby names — built from scratch with **Conal Elliott-style reverse-mode automatic differentiation**. No PyTorch. No TensorFlow. Just TypeScript, `Float32Array`s, and vibes.\n\nIt trains in **~10 seconds** on all **32,033 names** from [Karpathy's makemore dataset](https://github.com/karpathy/makemore) and then dreams up new ones like \"aylies\", \"marya\", \"laina\", and \"kari\".\n\n### 🗺️ How to Read This\n\nPick your depth:\n\n| Time | What you'll get |\n|---|---|\n| ⏱️ **30 seconds** | Read the ELI5 section — you'll know what this does |\n| ⏱️ **5 minutes** | Add the Architecture section — you'll know *how* it works |\n| ⏱️ **20 minutes** | Read \"One Training Step, Traced\" — you'll *feel* the math with real numbers |\n| ⏱️ **1 hour** | Read `main.ts` guided by the inline comments — you'll understand every line |\n| ⏱️ **Beyond** | Read \"From Names to Sentences\" — you'll see how this becomes ChatGPT |\n\n---\n\n## 🤔 ELI5: What's Going On? ⏱️ 30 sec\n\nImagine you're a kid trying to guess the next letter in a name:\n\n```\n\"e\", \"m\", \"m\" → probably \"a\" (emma!)\n\"s\", \"o\", \"p\" → probably \"h\" (sophia!)\n```\n\nThis program learns those patterns by:\n\n1. 📖 Looking at 32K real names (fetched live from GitHub!)\n2. 🔢 Turning each letter into a secret code (an **embedding**)\n3. 📏 Gluing 5 codes together into one long vector (the **concat**)\n4. 🧠 Passing through a hidden brain layer with **tanh** squishing\n5. 🧮 Scoring every possible next letter\n6. ❌ Getting told \"nope, wrong!\" (the **loss**)\n7. 🔙 Tracing *backward* through the math to figure out how to do better (the **backprop**)\n8. 🔧 Nudging all the knobs a little bit (the **gradient descent**)\n9. 🔁 Repeating ~3,400 times in ten seconds\n\n## 🧠 The Conal Elliott Secret Sauce ⏱️ 5 min\n\nMost ML frameworks treat autodiff as a graph-rewriting compiler pass. **Conal Elliott's insight** is far more elegant: the derivative *is just a function*. Every computation returns a pair:\n\n```\n(value, backpropagator)\n```\n\nThe `backpropagator` is a first-class function that, given upstream sensitivity, pushes gradient to its inputs. Composition of programs gives composition of backpropagators — no tape, no graph, no magic.\n\nHere, that shows up as the `Node` class:\n\n```typescript\nclass Node {\n v: T; // the value we computed\n back: (g) => void; // \"hey inputs, here's how much you matter\"\n}\n```\n\n**ELI5:** A `Node` is like a kid who knows their answer AND knows who to blame if the answer is wrong.\n\n## 🏗️ Architecture ⏱️ 5 min\n\nThe model is a **Bengio-style MLP** (like [Karpathy's makemore Part 2](https://github.com/karpathy/nn-zero-to-hero)):\n\n```mermaid\nflowchart LR\n subgraph Context[\"📝 Context Window (K=5)\"]\n C1[\"char[-5]\"]\n C2[\"char[-4]\"]\n C3[\"char[-3]\"]\n C4[\"char[-2]\"]\n C5[\"char[-1]\"]\n end\n\n subgraph Embed[\"🔢 Embedding Table E\"]\n E[\"E\\n(27 × 10)\"]\n end\n\n C1 --> E\n C2 --> E\n C3 --> E\n C4 --> E\n C5 --> E\n\n E -->|\"5 vectors\\n(each dim 10)\"| Concat[\"📏 Concat\"]\n Concat -->|\"(dim 50)\"| Linear1[\"⚡ W₁x + b₁\"]\n Linear1 -->|\"(dim 128)\"| Tanh[\"🌊 tanh\"]\n Tanh -->|\"(dim 128)\"| Linear2[\"⚡ W₂x + b₂\"]\n Linear2 -->|\"logits\\n(dim 27)\"| Softmax[\"🎲 Softmax\"]\n Softmax -->|\"probabilities\"| Next[\"Next char\\nprediction\"]\n```\n\n**7,721 parameters** total — small enough to fit in a tweet, powerful enough to dream up names.\n\n### Forward + Backward in One Picture\n\n```mermaid\nflowchart TB\n subgraph Forward[\"⏩ Forward Pass — build the computation\"]\n direction TB\n F1[\"gatherAndConcat: look up + glue embeddings for 5 context chars\"]\n F2[\"linearLayer: W₁ · emb + b₁ (50 → 128)\"]\n F3[\"tanhAct: squish into (-1, 1)\"]\n F4[\"linearLayer: W₂ · h + b₂ (128 → 27)\"]\n F5[\"xentFromLogits: softmax + cross-entropy loss\"]\n F1 --> F2 --> F3 --> F4 --> F5\n end\n\n subgraph Backward[\"⏪ Backward Pass — Conal-style blame propagation\"]\n direction BT\n B5[\"loss.back(1.0) — seed: 'loss matters by 1'\"]\n B4[\"∂loss/∂logits → push to output linear\"]\n B3[\"∂loss/∂h, ∂loss/∂W₂, ∂loss/∂b₂ → push to tanh\"]\n B2[\"∂loss/∂preact · (1-tanh²) → push to hidden linear\"]\n B1[\"∂loss/∂emb, ∂loss/∂W₁, ∂loss/∂b₁ → scatter into E\"]\n B5 --> B4 --> B3 --> B2 --> B1\n end\n\n F5 -. \"each Node stores its back(g)\" .-> B5\n\n style Forward fill:#e8f5e9,stroke:#388e3c\n style Backward fill:#fce4ec,stroke:#c62828\n```\n\n### The Conal Pattern\n\nEvery primitive follows the same shape — this is the whole trick:\n\n```mermaid\nflowchart LR\n Input[\"Input Node(s)\\n(value, back)\"] --> Prim[\"Primitive Op\\n(gatherAndConcat, linear,\\ntanh, xent)\"]\n Prim --> Output[\"Output Node\\n(new value, new back)\"]\n Output -. \"back(g) calls\\ninput.back(∂g)\" .-> Input\n```\n\nNo tape. No graph object. Just **functions calling functions**.\n\n## 📦 What's in the Box?\n\n| Concept | Code | ELI5 |\n|---|---|---|\n| **Node\\** | `class Node` | A value that knows who to blame |\n| **Param** | `class Param` | A trainable knob with a gradient bucket |\n| **gatherAndConcat** | `E[ctx]` → `(B, K·Emb)` | \"Look up codes for 5 letters, glue into one vector\" |\n| **linearLayer** | `X @ W^T + b` | \"Each neuron forms an opinion about the input\" |\n| **tanhAct** | `tanh(x)` | \"Squish numbers to stay calm\" |\n| **xentFromLogits** | softmax + `-log(p)` | \"How surprised were we by the right answer?\" |\n| **loss.back(1.0)** | reverse-mode AD | \"OK everyone, trace back the blame!\" |\n\n## 🔍 One Training Step, Traced ⏱️ 20 min\n\nAbstract math gets real when you follow one example through. Here's what actually happens inside a single training step. Every number below is real — this is what the code computes.\n\n### The Setup\n\nThe model sees the context `\".\", \"e\", \"m\", \"m\", \"a\"` and must predict the next character. (The name is \"emma\", and `\".\"` is the BOS/start token.) The correct answer is `\".\"` — the name is over.\n\n### Step 1: Embedding Lookup\n\nEach of the 5 context characters looks up its row in the embedding table E (27 × 10). The character `\"e\"` (id=5) pulls out 10 numbers, `\"m\"` (id=13) pulls out its 10 numbers, etc. Then we **glue** all 5 vectors together:\n\n```\nembed = [ e's 10 floats | m's 10 floats | m's 10 floats | a's 10 floats | .'s 10 floats ]\n = 50 numbers total\n```\n\nNote: `\"m\"` appears twice, so the same 10 numbers appear in two places. During backprop, the gradients from both positions **add up** — that's the `+=` in `gatherAndConcat`'s backward pass.\n\n### Step 2: Hidden Layer\n\nThe 50-number embedding hits the hidden layer: `h = tanh(W₁ · embed + b₁)`. Each of the 128 hidden neurons computes a weighted sum of all 50 inputs, adds its bias, then gets squished through tanh into the range (-1, +1):\n\n```\npre-tanh neuron 0: 0.02×embed[0] + (-0.01)×embed[1] + ... + bias[0] = 1.47\nafter tanh: tanh(1.47) = 0.90\n\npre-tanh neuron 1: ... = -0.83\nafter tanh: tanh(-0.83) = -0.68\n\n... (128 neurons total)\n```\n\n### Step 3: Output Scores (Logits)\n\nThe 128 hidden activations hit the output layer: `logits = W₂ · h + b₂`. This produces 27 raw scores, one per character:\n\n```\nlogit[\".\"] = 1.2, logit[\"a\"] = 2.1, logit[\"b\"] = -0.5, ... logit[\"m\"] = 1.8, ...\n```\n\nThese are just scores — they can be any number, positive or negative.\n\n### Step 4: Softmax → Probabilities\n\nSoftmax turns scores into probabilities (all positive, sum to 1):\n\n```\np[\".\"] = exp(1.2) / Σexp(all) = 0.07 ← the model gives 7% to the right answer\np[\"a\"] = exp(2.1) / Σexp(all) = 0.18\np[\"m\"] = exp(1.8) / Σexp(all) = 0.14\n... (all 27 sum to 1.0)\n```\n\n### Step 5: Loss — \"How Surprised Are We?\"\n\nThe target is `\".\"` (id=0). The loss is:\n\n```\nloss = -log(p[\".\"]) = -log(0.07) = 2.66\n```\n\n**Interpretation:** If the model had put 100% on `\".\"`, loss = -log(1) = 0 (not surprised at all). If it had put 0.01% on `\".\"`, loss = -log(0.0001) = 9.2 (very surprised). Our 7% gives a loss of 2.66 — not great, not terrible.\n\n### Step 6: Backward — \"Who's to Blame?\"\n\nHere's where the Conal magic happens. We call `loss.back(1.0)` and blame flows backward through every layer:\n\n**Gradient on logits** (the beautiful shortcut — no chain rule needed here!):\n```\n∂loss/∂logit[\".\"] = p[\".\"] - 1 = 0.07 - 1 = -0.93 ← \"push this score UP a lot\"\n∂loss/∂logit[\"a\"] = p[\"a\"] - 0 = +0.18 ← \"push this score down a bit\"\n∂loss/∂logit[\"m\"] = p[\"m\"] - 0 = +0.14 ← \"push this score down a bit\"\n... (all non-targets get pushed down by their probability)\n```\n\nThis is why the softmax+cross-entropy gradient is so elegant: it's just `(probability - target)`. The model put too much probability on \"a\" and \"m\", too little on \".\", so the gradient says \"fix that.\"\n\n**Gradient flows through W₂** → **through tanh** (multiplied by `1 - tanh²`) → **through W₁** → **back into the embedding table**.\n\nAt the end of backward, every one of the 7,721 parameters has a gradient telling it \"here's how to nudge yourself to make this prediction less surprising.\"\n\n### Step 7: Update — \"Nudge the Knobs\"\n\nSimple gradient descent: `param -= learning_rate × gradient`. Every parameter shifts slightly. After thousands of steps, the model gets less and less surprised by the training data, and starts generating plausible new names.\n\n## 📊 Results\n\nTraining on 32,033 names (90/10 train/test split) for 10 seconds:\n\n| Metric | Value |\n|---|---|\n| Dataset | 32,033 names from [names.txt](https://github.com/karpathy/makemore/blob/master/names.txt) |\n| Parameters | 7,721 |\n| Steps | ~3,400 |\n| Train loss | ~2.33 |\n| Test loss | ~2.33 |\n| Time | 10 seconds |\n\nSample generated names: `aylies`, `avurie`, `kari`, `marya`, `laina`, `dorie`, `alyni`, `elia`\n\n## 🗺️ From Names to Sentences ⏱️ Beyond\n\nThis model generates baby names. ChatGPT completes sentences. What's between them? Less than you'd think.\n\n### Level 1: Swap the Data 🟢\n\nRight now we train on 32K names with 27 characters (a-z + BOS). To handle sentences, just swap in a text file — say, [Tiny Shakespeare](https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt) (~1MB). The vocab grows to ~65 characters (add capitals, spaces, punctuation). **Nothing else changes** — the loss function, the training loop, the AD framework all work identically. V just becomes 65 instead of 27.\n\nWhat you'd get: babble that *looks* like English character patterns, but no coherent words. Why? Because K=5 characters is barely one word of context.\n\n### Level 2: See More Context 🟡\n\nWith K=5 you see 5 characters of history. English words average ~5 characters, so you can barely see one word back. To complete sentences you'd want K=64 or K=128+.\n\nBut here's the problem: our model **concatenates** the K embeddings into one flat vector. With K=128 and Emb=10, that's a 1,280-dim input. The model must learn *completely separate* weights for \"e in position 1\" vs. \"e in position 47\", even though they're the same letter. The parameter count explodes, and there's no way for character 3 to selectively attend to character 97.\n\n**This is exactly the problem attention solves.**\n\n### Level 3: Add Attention 🔴\n\nAttention replaces our concat-everything approach with a *selective* mechanism: each position gets to **look at all previous positions** and decide what's relevant, using learned Query/Key/Value projections.\n\nThe beautiful thing: in our Conal framework, attention decomposes into primitives we almost already have:\n\n```\nQ, K, V = three linear projections ← we already have linearLayer!\nscores = Q · Kᵀ / √d ← dot products, we can do this\nweights = softmax(scores) ← we already have softmax!\noutput = weights · V ← another matmul\n```\n\nEach of these would get a `back(g)` function, just like our existing primitives. The `Node` pattern doesn't change at all.\n\nWith attention + a few more standard pieces (layer normalization, residual connections, multiple layers), you'd need ~500K–2M parameters and minutes-to-hours of training. But the result would complete basic sentences.\n\n### 🔑 What Stays the Same All the Way to ChatGPT\n\nHere's the punchline that surprises most people:\n\n| Component | This Project | ChatGPT |\n|---|---|---|\n| **Loss function** | `-log(softmax(logits)[target])` | `-log(softmax(logits)[target])` |\n| **AD framework** | `Node` with `back(g)` | Same idea, on tensors + GPUs |\n| **Training loop** | forward → loss → backward → update | forward → loss → backward → update |\n| **What it learns** | \"after 'emm', 'a' is likely\" | \"after 'The capital of France is', 'Paris' is likely\" |\n\nThe core algorithm is **identical**. Everything between here and ChatGPT is scale (more data, bigger model, faster hardware) and a few architectural upgrades (attention, normalization, better optimizers). The *essence* — predict the next token, measure surprise, trace blame backward, nudge the knobs — that's all here in 491 lines of TypeScript.\n\n## 🏃 Running It\n\n```bash\n# In Val Town — just hit Run on main.ts\n# Locally:\nnpx tsx main.ts\n```\n\n## 🎓 Further Reading\n\n- [Conal Elliott — *The Simple Essence of Automatic Differentiation*](http://conal.net/papers/essence-of-ad/) — the paper that inspired this style\n- [Andrej Karpathy — *makemore*](https://github.com/karpathy/makemore) — similar char-level model in Python\n- [Andrej Karpathy — *microgpt*](http://karpathy.github.io/2026/02/12/microgpt/) — the beautiful 243-line GPT\n- [Bengio et al. 2003 — *A Neural Probabilistic Language Model*](https://www.jmlr.org/papers/volume3/bengio03a/bengio03a.pdf) — the original MLP LM paper\n- [3Blue1Brown — *Neural Networks*](https://www.youtube.com/playlist?list=PLZHQObOWTQDNU6R1_67000Dx_ZCJB-3pi) — visual intuition for backprop\n\n---\n\n*Built with zero dependencies. Just math, types, and the Conal Elliott conviction that derivatives are functions, not data structures.* ✨\n",[67],{"_35":66,"_13":67,"_38":68,"_40":-5,"_41":42,"_43":69,"_45":46,"_47":84,"_17":71,"_50":24,"_52":72,"_54":55,"_56":-5,"_78":85,"_18":86},{"_35":58,"_13":59,"_38":60,"_40":-5,"_41":42,"_43":61,"_45":46,"_47":81,"_17":63,"_50":24,"_52":64,"_54":55,"_56":-5,"_78":82,"_18":83},{"_35":36,"_13":37,"_38":39,"_40":-5,"_41":42,"_43":44,"_45":46,"_47":77,"_17":49,"_50":51,"_52":53,"_54":55,"_56":-5,"_78":79,"_18":80},["D",1771981506429],"children",[],[37],["D",1772023187641],[],[59],["D",1771987193163],[],[67],"445cde1a-11e4-11f1-97e5-42dde27851f2",["D",1771980752229],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","imageUrl","userId","a0bf3b31-15a5-4d5c-880e-4b1e22c9bc18","pinnedFileId","pinPreview","pinMigrated","screenshotVersion","likeCount","orgId","e81e7335-6d4c-4764-a902-d0962bbfa9f7","tursoName","tursoHostname","tursoMeasuredAt","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_11":12,"_139":135},"org",{"_11":12,"_133":-5,"_134":135,"_96":97,"_136":137,"_138":55},"branch",{"_17":61,"_13":16,"_35":42,"_125":87,"_126":-5,"_127":-5,"_128":-5,"_129":-5,"_130":-5,"_131":14,"_132":12},"isOwned","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","displayName","avatar","https://images.clerk.dev/uploaded/img_2PqHa2Gsy93xQrjh2w78Xu0cChW.jpeg","tier","pro","canRestrictVals","profileImageUrl","adoptOrgId",{"_35":87,"_13":14,"_47":183,"_89":-5,"_90":55,"_91":92,"_93":92,"_94":19,"_95":19,"_96":97,"_98":-5,"_99":55,"_100":-5,"_101":-5,"_102":63,"_103":104,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":110,"_111":110,"_112":113,"_114":113,"_115":113,"_116":110,"_117":110,"_118":184,"_120":185,"_122":186,"_124":55},[174,175,176],"files",[174,175,176],"counts",{"_164":63,"_165":166,"_167":63,"_31":168,"_169":170},[158,159,160],"upstreamProject","upstreamBranch","emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},{"_35":66,"_13":67,"_38":68,"_40":-5,"_41":42,"_43":69,"_45":46,"_47":70,"_17":71,"_50":24,"_52":72,"_54":55,"_56":-5,"_18":163},{"_35":58,"_13":59,"_38":60,"_40":-5,"_41":42,"_43":61,"_45":46,"_47":62,"_17":63,"_50":24,"_52":64,"_54":55,"_56":-5,"_18":162},{"_35":36,"_13":37,"_38":39,"_40":-5,"_41":42,"_43":44,"_45":46,"_47":48,"_17":49,"_50":51,"_52":53,"_54":55,"_56":-5,"_18":161},[37],[59],[67],"pulls","branches",1,"forks",{"_171":63,"_173":63},"connections",{"_171":63,"_172":63},"count","unfilledCount","emptyCount",{"_35":66,"_13":67,"_38":68,"_40":-5,"_41":42,"_43":69,"_45":46,"_47":84,"_17":71,"_50":24,"_52":72,"_54":55,"_56":-5,"_78":181,"_18":182},{"_35":58,"_13":59,"_38":60,"_40":-5,"_41":42,"_43":61,"_45":46,"_47":81,"_17":63,"_50":24,"_52":64,"_54":55,"_56":-5,"_78":179,"_18":180},{"_35":36,"_13":37,"_38":39,"_40":-5,"_41":42,"_43":44,"_45":46,"_47":77,"_17":49,"_50":51,"_52":53,"_54":55,"_56":-5,"_78":177,"_18":178},[],[37],[],[59],[],[67],["D",1771980752229],{"_11":12,"_139":135},{"_11":12,"_133":-5,"_134":135,"_96":97,"_136":137,"_138":55},{"_17":61,"_13":16,"_35":42,"_125":87,"_126":-5,"_127":-5,"_128":-5,"_129":-5,"_130":-5,"_131":14,"_132":12},"ctx",{"_118":-5,"_155":220,"_221":222,"_223":224,"_225":55,"_226":55,"_227":55,"_228":46,"_229":-5,"_230":-7,"_231":-7,"_232":63,"_233":55,"_234":55,"_235":-5,"_236":55,"_237":55,"_238":55,"_239":-5},"ENV",{"_191":192,"_193":194,"_195":16,"_196":197,"_198":199,"_200":201,"_202":203,"_204":205,"_206":207,"_208":209,"_210":211,"_212":213,"_214":215,"_216":217,"_218":219},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]