μGPT — Online Learning Transformer

[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_508":509,"_510":511},"routes/_app.x.$handle.$name",{"_96":95,"_32":46,"_104":86,"_27":105,"_13":14,"_106":-5,"_11":107,"_108":109,"_110":111,"_112":113,"_114":115,"_20":-5,"_116":-5,"_117":-5,"_118":25,"_119":120,"_121":122,"_123":-5,"_124":-5,"_125":126},"routes/_app.x.$handle.$name.branch.$branch.version.$version.diff",{"_11":12,"_13":14,"_15":16,"_17":-5,"_18":-5},"project",{"_44":45,"_32":46,"_39":47,"_48":-5,"_49":25,"_50":51,"_52":51,"_53":54,"_55":-5,"_18":56,"_57":-5,"_58":25,"_59":-5,"_60":-5,"_61":62,"_63":64,"_65":-5,"_66":-5,"_67":-5,"_68":-5,"_69":70,"_71":70,"_72":73,"_74":73,"_75":73,"_76":70,"_77":70,"_78":79,"_80":81,"_82":83,"_84":25},"version",49,"changes",[19],"aiChatInfo","userId",{"_20":21,"_22":23,"_24":25,"_26":25,"_27":28,"_29":28},"file",{"_30":31,"_32":33,"_34":35,"_36":38,"_39":40,"_41":14,"_42":43,"_24":25},"previous",{"_30":31,"_32":33,"_34":35,"_36":37},"deleted",false,"deletedHere","path","ui/config-panel.ts","latestPath","fileId","f03b5bb0-282a-11f1-a70e-42dde27851f2","name","config-panel.ts","fileType","script","content","/**\n * ui/config-panel.ts — Architecture configuration panel\n */\nimport { html, useState, useMemo } from \"./preact.ts\";\nimport { cfg } from \"../model/core.ts\";\nimport { resolveConfig, estimateParams, PRESETS } from \"../model/config.ts\";\n\nexport function ConfigPanel({ onConfigChange }: { onConfigChange: () => void }) {\n const [localD, setLocalD] = useState(cfg.D);\n const [localHeads, setLocalHeads] = useState(cfg.N_HEAD);\n const [localLayers, setLocalLayers] = useState(cfg.N_LAYER);\n const [localCtx, setLocalCtx] = useState(cfg.CTX);\n const [dirty, setDirty] = useState(false);\n\n const preview = useMemo(() => {\n return resolveConfig({ D: localD, N_HEAD: localHeads, N_LAYER: localLayers, CTX: localCtx });\n }, [localD, localHeads, localLayers, localCtx]);\n\n const estParams = useMemo(() => estimateParams(preview), [preview]);\n\n const apply = () => {\n Object.assign(cfg, preview);\n setDirty(false);\n onConfigChange();\n };\n\n const applyPreset = (name: string) => {\n const p = PRESETS[name];\n if (!p) return;\n const resolved = resolveConfig(p);\n setLocalD(resolved.D);\n setLocalHeads(resolved.N_HEAD);\n setLocalLayers(resolved.N_LAYER);\n setLocalCtx(resolved.CTX);\n setDirty(true);\n };\n\n const changed = (setter: any) => (e: any) => {\n setter(+e.target.value);\n setDirty(true);\n };\n\n const presetNames = Object.keys(PRESETS);\n\n return html`

\n architecture \\u00B7 requires reset to apply\n

\n ${presetNames.map((name: string) => html`\n \n `)}\n

D (width) ${localD}

\n \n

Heads ${localHeads}

\n \n

Layers ${localLayers}

\n \n

Context ${localCtx}

\n \n

\n ${preview.N_LAYER}L / ${preview.N_HEAD}H \\u00D7 ${preview.HD}d / mlp=${preview.MLP_HID} / ctx=${preview.CTX}\n \\u00B7 ${estParams.toLocaleString()} params\n ${dirty && html` \\u00B7 unsaved`}\n

\n ${dirty && html`\n \n `}\n

`;\n}\n","/**\n * ui/config-panel.ts — Architecture configuration\n *\n * Works with the new core/model.ts ModelConfig.\n * Lets users change n_embd, n_head, n_layer, block_size via presets\n * or manual controls. Requires reset to take effect.\n */\nimport { html, useState, useMemo } from \"./preact.ts\";\nimport { type ModelConfig, DEFAULT_CONFIG } from \"../core/model.ts\";\n\nconst PRESETS: Record> = {\n \"nano (4K)\": { n_embd: 16, n_head: 4, n_layer: 1, block_size: 16 },\n \"micro (18K)\": { n_embd: 32, n_head: 4, n_layer: 1, block_size: 24 },\n \"small (36K)\": { n_embd: 32, n_head: 4, n_layer: 2, block_size: 32 },\n \"med (70K)\": { n_embd: 48, n_head: 6, n_layer: 2, block_size: 32 },\n};\n\nfunction estimateParams(c: ModelConfig): number {\n const { n_embd, n_layer, block_size, vocab_size } = c;\n const mlp = 4 * n_embd;\n const embed = vocab_size * n_embd + block_size * n_embd;\n const perLayer = n_embd * n_embd * 4 + mlp * n_embd + n_embd * mlp;\n const head = vocab_size * n_embd;\n return embed + n_layer * perLayer + head;\n}\n\nexport function ConfigPanel({ currentConfig, onApply }: {\n currentConfig: ModelConfig;\n onApply: (cfg: ModelConfig) => void;\n}) {\n const [embd, setEmbd] = useState(currentConfig.n_embd);\n const [heads, setHeads] = useState(currentConfig.n_head);\n const [layers, setLayers] = useState(currentConfig.n_layer);\n const [ctx, setCtx] = useState(currentConfig.block_size);\n const [dirty, setDirty] = useState(false);\n\n const preview = useMemo(() => {\n const hd = Math.max(1, Math.floor(embd / heads));\n const D = hd * heads; // snap to multiple\n return { ...DEFAULT_CONFIG, n_embd: D, n_head: heads, n_layer: layers, block_size: ctx, vocab_size: currentConfig.vocab_size };\n }, [embd, heads, layers, ctx, currentConfig.vocab_size]);\n\n const est = useMemo(() => estimateParams(preview), [preview]);\n\n const applyPreset = (name: string) => {\n const p = PRESETS[name];\n if (!p) return;\n if (p.n_embd) setEmbd(p.n_embd);\n if (p.n_head) setHeads(p.n_head);\n if (p.n_layer) setLayers(p.n_layer);\n if (p.block_size) setCtx(p.block_size);\n setDirty(true);\n };\n\n const ch = (setter: any) => (e: any) => { setter(+e.target.value); setDirty(true); };\n\n return html`

architecture \\u00B7 apply resets model

\n ${Object.keys(PRESETS).map((name: string) => html`\n \n `)}\n

width ${embd}

heads ${heads}

layers ${layers}

context ${ctx}

\n ${preview.n_layer}L / ${preview.n_head}H \\u00D7 ${Math.floor(preview.n_embd / preview.n_head)}d / mlp=${4 * preview.n_embd} / ctx=${preview.block_size}\n \\u00B7 ~${est.toLocaleString()} params\n ${dirty && html` \\u00B7 unsaved`}\n

\n ${dirty && html``}\n

`;\n}\n","createdAt",["D",1774440596797],"branchVersion","branchId","a0faf3a2-27db-11f1-89a2-42dde27851f2","id","a0fa6194-27db-11f1-89a2-42dde27851f2","microgpt",["D",1774395967725],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","Online learning micro-GPT: byte-level decoder transformer","imageUrl","21f2e37e-8066-4730-9dc7-d27cf8d3c9f3","pinnedFileId","pinPreview","pinMigrated","screenshotVersion","likeCount",0,"orgId","0630d977-f678-453e-926c-52043293f59f","tursoName","tursoHostname","tursoMeasuredAt","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_96":95,"_103":99},"org",{"_96":95,"_97":-5,"_98":99,"_18":56,"_100":101,"_102":25},"branch",{"_13":85,"_32":86,"_44":43,"_87":45,"_88":-5,"_89":-5,"_90":-5,"_91":-5,"_92":-5,"_93":46,"_94":95},"isOwned",52,"main","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","c15r","handle","displayName","avatar","https://img.clerk.com/eyJ0eXBlIjoicHJveHkiLCJzcmMiOiJodHRwczovL2ltYWdlcy5jbGVyay5kZXYvb2F1dGhfZ2l0aHViL2ltZ18yb2RJNlc1czZ1NlpZRmoxdGJ2eFVNNVhmeTYifQ","tier","pro","canRestrictVals","profileImageUrl","branchName","","adoptOrgId",{"_44":45,"_32":46,"_39":504,"_48":-5,"_49":25,"_50":51,"_52":51,"_53":54,"_55":-5,"_18":56,"_57":-5,"_58":25,"_59":-5,"_60":-5,"_61":62,"_63":64,"_65":-5,"_66":-5,"_67":-5,"_68":-5,"_69":70,"_71":70,"_72":73,"_74":73,"_75":73,"_76":70,"_77":70,"_78":505,"_80":506,"_82":507,"_84":25},"tree",[206,214,222,225,227,233,235,244,245],"files",[206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245],"counts",{"_196":62,"_197":188,"_198":62,"_199":200,"_201":202},"contents",[127,128,129,130,131,132,133,134,135],"upstreamProject","upstreamBranch","emptyEnvVars","flags",[],"hasHttpFiles",true,"grants","orgs","customDomains",{},{"_44":191,"_32":192,"_30":193,"_139":-5,"_42":43,"_41":165,"_141":122,"_39":194,"_13":62,"_34":160,"_36":-5,"_24":25,"_146":-5,"_27":195},{"_44":185,"_32":186,"_30":187,"_139":-5,"_42":43,"_41":188,"_141":122,"_39":189,"_13":62,"_34":160,"_36":-5,"_24":25,"_146":-5,"_27":190},{"_44":179,"_32":180,"_30":181,"_139":-5,"_42":43,"_41":182,"_141":122,"_39":183,"_13":62,"_34":160,"_36":-5,"_24":25,"_146":-5,"_27":184},{"_44":174,"_32":175,"_30":176,"_139":-5,"_42":43,"_41":143,"_141":122,"_39":177,"_13":62,"_34":160,"_36":-5,"_24":25,"_146":-5,"_27":178},{"_44":168,"_32":169,"_30":170,"_139":-5,"_42":43,"_41":171,"_141":122,"_39":172,"_13":62,"_34":160,"_36":-5,"_24":25,"_146":-5,"_27":173},{"_44":162,"_32":163,"_30":164,"_139":-5,"_42":43,"_41":165,"_141":122,"_39":166,"_13":62,"_34":160,"_36":-5,"_24":25,"_146":-5,"_27":167},{"_44":155,"_32":156,"_30":157,"_139":-5,"_42":43,"_41":158,"_141":122,"_39":159,"_13":62,"_34":160,"_36":-5,"_24":25,"_146":-5,"_27":161},{"_44":148,"_32":149,"_30":150,"_139":-5,"_42":43,"_41":151,"_141":122,"_39":152,"_13":62,"_34":20,"_36":153,"_24":25,"_146":-5,"_27":154},{"_44":136,"_32":137,"_30":138,"_139":-5,"_42":43,"_41":140,"_141":122,"_39":142,"_13":143,"_34":144,"_36":145,"_24":25,"_146":-5,"_27":147},"ddb8fe72-2828-11f1-a452-42dde27851f2","main.ts","d4913e8c-27dc-11f1-a47b-42dde27851f2","parentId",38,"latest",["D",1774429140871],2,"http","/**\n * main.ts — HTTP entry point\n *\n * Serves a thin HTML shell. All application logic lives in ui/app.ts,\n * loaded as an ES module via esm.town. Model, mechanisms, and corpus\n * are imported by ui/app.ts via relative paths that esm.town resolves.\n */\n\nexport default function (req: Request): Response {\n const html = `\n\n\n\n\nμGPT — Online Learning Transformer\n\n\n\n\n\n\n\n

\n\n\n`;\n\n return new Response(html, {\n headers: { \"content-type\": \"text/html; charset=utf-8\" },\n });\n}","label",[137],"5ffea7e4-27dc-11f1-b2a5-42dde27851f2","README.md","5ffea92e-27dc-11f1-b2a5-42dde27851f2",13,["D",1774396288191],"# μGPT — Online Learning Micro-GPT\n\nA faithful minimal decoder-only transformer trained online under the prequential protocol. Byte-level, from scratch, in front of you.\n\n## Architecture\n\n```\nmodel/\n core.ts Config, types, init, RMSNorm, sampling utilities\n forward.ts Full causal self-attention forward pass (all positions)\n backward.ts Full backward pass through causal decoder block\n optim.ts SGD + gradient clipping\n\nmechanisms/\n index.ts Toggleable research-backed mechanisms:\n - Selective-Backprop (skip easy tokens)\n - Experience Replay (reservoir + priority)\n - Adaptive LR (dual-EMA shift detection)\n\ncorpus/\n phases.ts Training data phases, corpus builder, boundary tracking\n\nengine/\n loop.ts Prequential training loop coordinating model + mechanisms\n\nui/\n app.ts (TODO) Interactive frontend — currently inline in main.ts\n\nmain.ts HTTP entry point serving the interactive page\n```\n\n## Model\n\nDecoder-only transformer. 1 layer, 4 heads × 4d, MLP 16→64→16, separate lm_head.\nPre-norm (RMSNorm), residual stream, ~7K parameters. Byte vocabulary (257 = 256 + BOS).\n\nThe forward pass computes hidden states for **all positions** with causal masking.\nThe backward pass propagates gradients through the **entire sequence** in the block.\nThis is what makes it a faithful GPT, not just \"attention LM.\"\n\n## Protocol\n\nPrequential: predict → observe → update. Loss is recorded **before** the update.\nEvery byte is both evaluation and curriculum. No train/test split.\n\n## Mechanisms\n\nFrom the online/continual learning literature:\n\n| Mechanism | Paper | What it does | Strict online? |\n|---|---|---|---|\n| Selective-Backprop | Jiang et al. 2019 | Skip updates when loss < τ | Yes |\n| Experience Replay | Reservoir sampling | Replay past windows weighted by loss | No |\n| Adaptive LR | Dynamic eval literature | Boost LR on distribution shift | Yes |\n| Gradient Clipping | Standard practice | Cap gradient norm for stability | Yes |\n\n## Next steps\n\n- [ ] TinyStories integration for capacity-aligned training data\n- [ ] Client-side ES module imports from val files (eliminate duplication)\n- [ ] Web worker for training loop (unblock UI thread)\n- [ ] kNN/continuous cache mechanism (non-parametric memory)\n- [ ] Multi-layer support with depth controls\n- [ ] Configurable model dimensions in UI\n",[149],"c8760412-27db-11f1-8e32-42dde27851f2","ui","c8760584-27db-11f1-8e32-42dde27851f2",5,["D",1774396033959],"directory",[156],"26dc34ac-2833-11f1-84e7-42dde27851f2","test","019d247b-5ff5-70b9-99b1-2591ad824a0a",48,["D",1774433558516],[163],"a3727a6a-27db-11f1-918a-42dde27851f2","model","a3727b82-27db-11f1-918a-42dde27851f2",1,["D",1774395971862],[169],"a5fddaa4-27db-11f1-8e98-42dde27851f2","mechanisms","a5fddb58-27db-11f1-8e98-42dde27851f2",["D",1774395976131],[175],"c63bb62e-27db-11f1-b2b9-42dde27851f2","engine","c63bb728-27db-11f1-b2b9-42dde27851f2",4,["D",1774396030221],[180],"a80fc690-27db-11f1-948c-42dde27851f2","corpus","a80fc780-27db-11f1-948c-42dde27851f2",3,["D",1774395979606],[186],"26dc3128-2833-11f1-84e7-42dde27851f2","core","019d247b-5ff5-70b9-99b1-20eb7742eb1f",["D",1774433558516],[192],"pulls","branches","forks","envVars",{"_203":62,"_205":62},"connections",{"_203":62,"_204":62},"count","unfilledCount","emptyCount",{"_44":191,"_32":192,"_30":193,"_139":-5,"_42":43,"_41":165,"_141":122,"_39":501,"_13":62,"_34":160,"_36":-5,"_24":25,"_146":-5,"_247":502,"_27":503},{"_44":495,"_32":368,"_30":496,"_139":193,"_42":43,"_41":165,"_141":122,"_39":497,"_13":62,"_34":35,"_36":498,"_24":25,"_146":-5,"_247":499,"_27":500},{"_44":488,"_32":489,"_30":490,"_139":193,"_42":43,"_41":165,"_141":122,"_39":491,"_13":62,"_34":35,"_36":492,"_24":25,"_146":-5,"_247":493,"_27":494},{"_44":481,"_32":482,"_30":483,"_139":193,"_42":43,"_41":165,"_141":122,"_39":484,"_13":62,"_34":35,"_36":485,"_24":25,"_146":-5,"_247":486,"_27":487},{"_44":475,"_32":325,"_30":476,"_139":193,"_42":43,"_41":165,"_141":122,"_39":477,"_13":62,"_34":35,"_36":478,"_24":25,"_146":-5,"_247":479,"_27":480},{"_44":468,"_32":469,"_30":470,"_139":193,"_42":43,"_41":165,"_141":122,"_39":471,"_13":62,"_34":35,"_36":472,"_24":25,"_146":-5,"_247":473,"_27":474},{"_44":461,"_32":462,"_30":463,"_139":193,"_42":43,"_41":165,"_141":122,"_39":464,"_13":62,"_34":35,"_36":465,"_24":25,"_146":-5,"_247":466,"_27":467},{"_44":454,"_32":455,"_30":456,"_139":193,"_42":43,"_41":165,"_141":122,"_39":457,"_13":62,"_34":35,"_36":458,"_24":25,"_146":-5,"_247":459,"_27":460},{"_44":185,"_32":186,"_30":187,"_139":-5,"_42":43,"_41":188,"_141":122,"_39":451,"_13":62,"_34":160,"_36":-5,"_24":25,"_146":-5,"_247":452,"_27":453},{"_44":443,"_32":444,"_30":445,"_139":187,"_42":43,"_41":446,"_141":122,"_39":447,"_13":143,"_34":35,"_36":448,"_24":25,"_146":-5,"_247":449,"_27":450},{"_44":435,"_32":436,"_30":437,"_139":187,"_42":43,"_41":438,"_141":122,"_39":439,"_13":62,"_34":35,"_36":440,"_24":25,"_146":-5,"_247":441,"_27":442},{"_44":429,"_32":368,"_30":430,"_139":187,"_42":43,"_41":165,"_141":25,"_39":431,"_13":62,"_34":35,"_36":432,"_24":25,"_146":-5,"_247":433,"_27":434},{"_44":421,"_32":422,"_30":423,"_139":187,"_42":43,"_41":424,"_141":122,"_39":425,"_13":143,"_34":35,"_36":426,"_24":25,"_146":-5,"_247":427,"_27":428},{"_44":413,"_32":414,"_30":415,"_139":187,"_42":43,"_41":416,"_141":122,"_39":417,"_13":62,"_34":35,"_36":418,"_24":25,"_146":-5,"_247":419,"_27":420},{"_44":405,"_32":406,"_30":407,"_139":187,"_42":43,"_41":408,"_141":122,"_39":409,"_13":62,"_34":35,"_36":410,"_24":25,"_146":-5,"_247":411,"_27":412},{"_44":397,"_32":398,"_30":399,"_139":187,"_42":43,"_41":400,"_141":122,"_39":401,"_13":62,"_34":35,"_36":402,"_24":25,"_146":-5,"_247":403,"_27":404},{"_44":179,"_32":180,"_30":181,"_139":-5,"_42":43,"_41":182,"_141":122,"_39":394,"_13":62,"_34":160,"_36":-5,"_24":25,"_146":-5,"_247":395,"_27":396},{"_44":386,"_32":387,"_30":388,"_139":181,"_42":43,"_41":389,"_141":122,"_39":390,"_13":62,"_34":35,"_36":391,"_24":25,"_146":-5,"_247":392,"_27":393},{"_44":378,"_32":379,"_30":380,"_139":181,"_42":43,"_41":381,"_141":122,"_39":382,"_13":62,"_34":35,"_36":383,"_24":25,"_146":-5,"_247":384,"_27":385},{"_44":174,"_32":175,"_30":176,"_139":-5,"_42":43,"_41":143,"_141":122,"_39":375,"_13":62,"_34":160,"_36":-5,"_24":25,"_146":-5,"_247":376,"_27":377},{"_44":367,"_32":368,"_30":369,"_139":176,"_42":43,"_41":370,"_141":122,"_39":371,"_13":62,"_34":35,"_36":372,"_24":25,"_146":-5,"_247":373,"_27":374},{"_44":168,"_32":169,"_30":170,"_139":-5,"_42":43,"_41":171,"_141":122,"_39":364,"_13":62,"_34":160,"_36":-5,"_24":25,"_146":-5,"_247":365,"_27":366},{"_44":356,"_32":357,"_30":358,"_139":170,"_42":43,"_41":359,"_141":122,"_39":360,"_13":143,"_34":35,"_36":361,"_24":25,"_146":-5,"_247":362,"_27":363},{"_44":348,"_32":349,"_30":350,"_139":170,"_42":43,"_41":351,"_141":122,"_39":352,"_13":62,"_34":35,"_36":353,"_24":25,"_146":-5,"_247":354,"_27":355},{"_44":340,"_32":341,"_30":342,"_139":170,"_42":43,"_41":343,"_141":122,"_39":344,"_13":188,"_34":35,"_36":345,"_24":25,"_146":-5,"_247":346,"_27":347},{"_44":332,"_32":333,"_30":334,"_139":170,"_42":43,"_41":335,"_141":122,"_39":336,"_13":143,"_34":35,"_36":337,"_24":25,"_146":-5,"_247":338,"_27":339},{"_44":324,"_32":325,"_30":326,"_139":170,"_42":43,"_41":327,"_141":122,"_39":328,"_13":143,"_34":35,"_36":329,"_24":25,"_146":-5,"_247":330,"_27":331},{"_44":162,"_32":163,"_30":164,"_139":-5,"_42":43,"_41":165,"_141":122,"_39":321,"_13":62,"_34":160,"_36":-5,"_24":25,"_146":-5,"_247":322,"_27":323},{"_44":314,"_32":315,"_30":316,"_139":164,"_42":43,"_41":165,"_141":122,"_39":317,"_13":62,"_34":35,"_36":318,"_24":25,"_146":-5,"_247":319,"_27":320},{"_44":155,"_32":156,"_30":157,"_139":-5,"_42":43,"_41":158,"_141":122,"_39":311,"_13":62,"_34":160,"_36":-5,"_24":25,"_146":-5,"_247":312,"_27":313},{"_44":303,"_32":304,"_30":305,"_139":157,"_42":43,"_41":306,"_141":122,"_39":307,"_13":62,"_34":35,"_36":308,"_24":25,"_146":-5,"_247":309,"_27":310},{"_44":296,"_32":297,"_30":298,"_139":157,"_42":43,"_41":165,"_141":25,"_39":299,"_13":188,"_34":35,"_36":300,"_24":25,"_146":-5,"_247":301,"_27":302},{"_44":292,"_32":33,"_30":31,"_139":157,"_42":43,"_41":14,"_141":122,"_39":293,"_13":143,"_34":35,"_36":38,"_24":25,"_146":-5,"_247":294,"_27":295},{"_44":285,"_32":286,"_30":287,"_139":157,"_42":43,"_41":165,"_141":122,"_39":288,"_13":171,"_34":35,"_36":289,"_24":25,"_146":-5,"_247":290,"_27":291},{"_44":277,"_32":278,"_30":279,"_139":157,"_42":43,"_41":280,"_141":122,"_39":281,"_13":62,"_34":35,"_36":282,"_24":25,"_146":-5,"_247":283,"_27":284},{"_44":269,"_32":270,"_30":271,"_139":157,"_42":43,"_41":272,"_141":122,"_39":273,"_13":62,"_34":35,"_36":274,"_24":25,"_146":-5,"_247":275,"_27":276},{"_44":261,"_32":262,"_30":263,"_139":157,"_42":43,"_41":264,"_141":122,"_39":265,"_13":62,"_34":35,"_36":266,"_24":25,"_146":-5,"_247":267,"_27":268},{"_44":253,"_32":254,"_30":255,"_139":157,"_42":43,"_41":256,"_141":122,"_39":257,"_13":62,"_34":35,"_36":258,"_24":25,"_146":-5,"_247":259,"_27":260},{"_44":148,"_32":149,"_30":150,"_139":-5,"_42":43,"_41":151,"_141":122,"_39":250,"_13":62,"_34":20,"_36":153,"_24":25,"_146":-5,"_247":251,"_27":252},{"_44":136,"_32":137,"_30":138,"_139":-5,"_42":43,"_41":140,"_141":122,"_39":246,"_13":143,"_34":144,"_36":145,"_24":25,"_146":-5,"_247":248,"_27":249},["D",1774429140871],"children",[],[137],["D",1774396288191],[],[149],"b7557ff6-282a-11f1-91e7-42dde27851f2","widgets.ts","b755810e-282a-11f1-91e7-42dde27851f2",40,["D",1774429935465],"/**\n * ui/widgets.ts — Small reusable UI components\n */\nimport { html, useState } from \"./preact.ts\";\nimport { tokStr } from \"../model/core.ts\";\n\nexport function Toggle({ label, checked, onChange, color = \"#4ade80\", hint }: any) {\n return html`\n

\n ${label}\n ${hint && html`${hint}`}\n `;\n}\n\nexport function Section({ title, children, defaultOpen = false }: any) {\n const [open, setOpen] = useState(defaultOpen);\n return html`

setOpen(!open)} style=${{ cursor: \"pointer\", display: \"flex\", alignItems: \"center\", gap: 5, fontSize: 9, color: \"#555\", letterSpacing: \".08em\", textTransform: \"uppercase\", userSelect: \"none\" }}>\n \\u25B8\n ${title}\n

\n ${open && html`

${children}

`}\n

`;\n}\n\nexport function TopKBars({ items, targetId }: any) {\n if (!items) return null;\n const mx = items[0]?.p || 1;\n return html`

\n ${items.map(({ id, p }: any) => html`\n

${tokStr(id)}

${(p * 100).toFixed(1)}%

`)}\n

`;\n}\n",[],[156,254],"d4b802d0-282a-11f1-9c39-42dde27851f2","pred-stream.ts","d4b80384-282a-11f1-9c39-42dde27851f2",42,["D",1774429984768],"/**\n * ui/pred-stream.ts — Observation stream display\n */\nimport { html } from \"./preact.ts\";\nimport { tokStr } from \"../model/core.ts\";\n\nexport function PredStream({ history, start, count }: any) {\n const vis = history.slice(start, start + count);\n if (!vis.length) return null;\n return html`

\n ${vis.map((h: any, i: number) => {\n const s = Math.min(h.loss / 5.5, 1);\n const bg = s > .7 ? \"rgba(239,68,68,\" + (s * .3) + \")\"\n : s > .3 ? \"rgba(245,158,11,\" + (s * .3) + \")\"\n : \"rgba(74,222,128,\" + (0.15 + 0.2 * (1 - s)) + \")\";\n const bdr = h.skipped ? \"1px solid rgba(100,100,255,.3)\"\n : h.replayed ? \"1px solid rgba(200,130,250,.4)\" : \"none\";\n return html` .7 ? \"#fca5a5\" : s > .3 ? \"#fcd34d\" : \"#bbf7d0\", cursor: \"default\" }}>${tokStr(h.targetId)}`;\n })}\n

`;\n}\n",[],[156,262],"6bb1227c-27e3-11f1-a583-42dde27851f2","preact.ts","6bb12330-27e3-11f1-a583-42dde27851f2",37,["D",1774399314293],"/**\n * ui/preact.ts — Shared preact + htm setup for all UI files\n *\n * Browser caches modules, so multiple files importing this\n * all get the same preact instance.\n */\nimport { h, render, Fragment } from \"https://esm.sh/preact@10.25.4\";\nimport { useState, useRef, useEffect, useCallback, useMemo } from \"https://esm.sh/preact@10.25.4/hooks\";\nimport htm from \"https://esm.sh/htm@3.1.1\";\n\nconst html = htm.bind(h);\n\nexport { h, render, Fragment, useState, useRef, useEffect, useCallback, useMemo, html };\n",[],[156,270],"ccd3c69e-282a-11f1-be27-42dde27851f2","loss-curve.ts","ccd3c770-282a-11f1-be27-42dde27851f2",41,["D",1774429971526],"/**\n * ui/loss-curve.ts — Compression curve with telescoping x-axis\n *\n * X-axis telescopes: recent data gets more pixels, old data compresses.\n * This keeps early epochs visible but gives most space to recent training.\n * Uses a sqrt transform: x_screen = sqrt(step/total) * width\n */\nimport { h } from \"./preact.ts\";\n\nexport function LossCurve(props: any) {\n const { history, boundaries, width, height, hoverStep, onHover, totalCorpus, epoch } = props;\n if (history.length < 2) {\n return h(\"div\", {\n style: { width, height, display: \"flex\", alignItems: \"center\", justifyContent: \"center\", color: \"#333\", fontSize: 11 }\n }, \"awaiting data\\u2026\");\n }\n\n const total = history.length;\n const bs = Math.max(1, Math.floor(total / Math.min(total, 700)));\n const pts: any[] = [];\n for (let i = 0; i < total; i += bs) {\n const end = Math.min(i + bs, total);\n let sum = 0, cnt = 0;\n for (let j = i; j < end; j++) { sum += history[j].loss; cnt++; }\n pts.push({ step: i + Math.floor(cnt / 2), loss: sum / cnt, phase: history[i].phase });\n }\n\n // EMA smoothing\n let ema = pts[0].loss;\n const sm = pts.map((p: any) => { ema = .015 * p.loss + .985 * ema; return { ...p, smooth: ema }; });\n\n const pad = { t: 8, b: 22, l: 34, r: 8 };\n const pw = width - pad.l - pad.r;\n const ph = height - pad.t - pad.b;\n\n // Y axis\n const yMax = Math.min(8, Math.max(...sm.map((p: any) => p.smooth)) * 1.15);\n const yMin = Math.max(0, Math.min(...sm.map((p: any) => p.smooth)) * .8);\n const yR = yMax - yMin || 1;\n const yS = (v: number) => pad.t + (1 - (v - yMin) / yR) * ph;\n\n // X axis — sqrt telescoping: recent gets more space\n const xRaw = (s: number) => s / (total - 1 || 1); // 0..1\n const xTele = (s: number) => Math.sqrt(xRaw(s)); // compressed old, expanded recent\n const xS = (s: number) => pad.l + xTele(s) * pw;\n\n // Phase bands\n const bands: any[] = [];\n if (boundaries.length > 0 && totalCorpus > 0) {\n for (let e = 0; e <= epoch; e++) {\n const off = e * totalCorpus;\n for (const b of boundaries) {\n const s = off + b.start, en = off + b.end;\n if (s < total) bands.push({ x1: xS(s), x2: xS(Math.min(en, total)), color: b.color });\n }\n }\n }\n\n // Epoch dividers\n const epochLines: number[] = [];\n if (totalCorpus > 0) {\n for (let e = 1; e <= epoch; e++) {\n const pos = e * totalCorpus;\n if (pos < total) epochLines.push(xS(pos));\n }\n }\n\n // Smoothed line\n const line = sm.map((p: any) =>\n xS(p.step) + \",\" + yS(Math.max(yMin, Math.min(yMax, p.smooth)))\n ).join(\" \");\n\n // Y ticks\n const yTicks: number[] = [];\n const ySt = yR < 2 ? .5 : yR < 4 ? 1 : 2;\n for (let v = Math.ceil(yMin / ySt) * ySt; v <= yMax; v += ySt) yTicks.push(v);\n\n // X ticks — show step numbers at regular screen intervals\n const xTicks: { x: number; label: string }[] = [];\n const numXTicks = Math.min(6, Math.floor(pw / 60));\n for (let i = 0; i <= numXTicks; i++) {\n const screenFrac = i / numXTicks;\n // Invert sqrt: step = screenFrac^2 * total\n const stepNum = Math.round(screenFrac * screenFrac * (total - 1));\n xTicks.push({ x: pad.l + screenFrac * pw, label: stepNum >= 1000 ? (stepNum / 1000).toFixed(1) + \"k\" : String(stepNum) });\n }\n\n const hx = hoverStep !== null ? xS(hoverStep) : null;\n const last = sm[sm.length - 1];\n\n const onMove = (e: any) => {\n const r = e.currentTarget.getBoundingClientRect();\n const mx = e.clientX - r.left;\n // Invert: screenFrac = (mx - pad.l) / pw, step = screenFrac^2 * (total-1)\n const screenFrac = Math.max(0, Math.min(1, (mx - pad.l) / pw));\n const s = Math.round(screenFrac * screenFrac * (total - 1));\n onHover(Math.max(0, Math.min(total - 1, s)));\n };\n\n // Build SVG children manually with h() to avoid template issues\n const children: any[] = [];\n\n // Phase bands\n for (let i = 0; i < bands.length; i++) {\n const b = bands[i];\n children.push(h(\"rect\", { key: \"b\" + i, x: b.x1, y: pad.t, width: Math.max(0, b.x2 - b.x1), height: ph, fill: b.color, opacity: \".05\" }));\n }\n\n // Y grid + labels\n for (const v of yTicks) {\n children.push(h(\"line\", { key: \"yg\" + v, x1: pad.l, x2: width - pad.r, y1: yS(v), y2: yS(v), stroke: \"#141420\" }));\n children.push(h(\"text\", { key: \"yl\" + v, x: pad.l - 3, y: yS(v) + 3, \"text-anchor\": \"end\", fill: \"#333\", \"font-size\": \"8\" }, v.toFixed(1)));\n }\n\n // X tick labels\n for (const xt of xTicks) {\n children.push(h(\"text\", { key: \"xl\" + xt.label, x: xt.x, y: pad.t + ph + 12, \"text-anchor\": \"middle\", fill: \"#333\", \"font-size\": \"7\" }, xt.label));\n }\n\n // Epoch dividers\n for (let i = 0; i < epochLines.length; i++) {\n children.push(h(\"line\", { key: \"ep\" + i, x1: epochLines[i], x2: epochLines[i], y1: pad.t, y2: pad.t + ph, stroke: \"#444\", \"stroke-dasharray\": \"3,3\", opacity: \".5\" }));\n }\n\n // Smoothed line\n children.push(h(\"polyline\", { key: \"line\", points: line, fill: \"none\", stroke: \"#f59e0b\", \"stroke-width\": \"2\", \"stroke-linejoin\": \"round\", opacity: \".85\" }));\n\n // Hover line\n if (hx !== null) {\n children.push(h(\"line\", { key: \"hover\", x1: hx, x2: hx, y1: pad.t, y2: pad.t + ph, stroke: \"#e2e8f0\", opacity: \".25\" }));\n }\n\n // Endpoint dot\n children.push(h(\"circle\", {\n key: \"dot\",\n cx: xS(last.step),\n cy: yS(Math.max(yMin, Math.min(yMax, last.smooth))),\n r: \"3\", fill: \"#f59e0b\"\n }));\n\n return h(\"svg\", {\n width, height,\n style: \"display:block;cursor:crosshair\",\n onMouseMove: onMove,\n onMouseLeave: () => onHover(null),\n }, ...children);\n}\n",[],[156,278],"26dc83a8-2833-11f1-84e7-42dde27851f2","inference.ts","e23f58f4-282a-11f1-9c39-42dde27851f2",["D",1774433558516],"/**\n * ui/inference.ts — Inference + generation panel\n *\n * Two modes:\n * 1. Type a prompt → see per-char surprise + completion\n * 2. Online toggle: backprop on observed tokens during generation\n */\nimport { html, useState, useCallback } from \"./preact.ts\";\nimport { infer, onlineObserve, softmax } from \"../core/index.ts\";\n\nexport function InferencePanel({ stateRef, configRef, tokRef, paramsRef, adamRef, online }: any) {\n const [prompt, setPrompt] = useState(\"\");\n const [generated, setGenerated] = useState(\"\");\n const [perChar, setPerChar] = useState([]);\n const [avgBPB, setAvgBPB] = useState(0);\n\n const generate = useCallback(() => {\n const sd = stateRef.current;\n const cfg = configRef.current;\n const tok = tokRef.current;\n if (!sd || !cfg || !tok || !prompt) return;\n\n // Encode prompt\n const promptIds = [tok.BOS, ...tok.encode(prompt)];\n\n // Score prompt (per-char surprise)\n const chars: any[] = [];\n let totalBits = 0;\n for (let i = 1; i < promptIds.length; i++) {\n const ctx = promptIds.slice(0, i);\n const { probs } = infer(ctx, sd, cfg);\n const target = promptIds[i];\n const loss = -Math.log(Math.max(probs[target], 1e-10)) / Math.LN2;\n totalBits += loss;\n chars.push({ ch: tok.charOf(target), loss, p: probs[target] });\n }\n setPerChar(chars);\n setAvgBPB(chars.length > 0 ? totalBits / chars.length : 0);\n\n // Generate continuation\n const ctx = [...promptIds];\n let gen = \"\";\n for (let i = 0; i < 60; i++) {\n if (online) {\n // Online: also backprop on each generated token as if \"observed\"\n // But we don't have a target yet — skip for generation, only online on prompt\n }\n const { probs } = infer(ctx, sd, cfg);\n // Sample with temperature 0.5\n const temp = 0.5;\n const scaled = probs.map(p => Math.exp(Math.log(Math.max(p, 1e-10)) / temp));\n const sum = scaled.reduce((a, b) => a + b, 0);\n const normed = scaled.map(p => p / sum);\n let r = Math.random(), cum = 0, sampled = tok.BOS;\n for (let j = 0; j < normed.length; j++) {\n cum += normed[j];\n if (r < cum) { sampled = j; break; }\n }\n if (sampled === tok.BOS) break;\n gen += tok.charOf(sampled);\n ctx.push(sampled);\n if (ctx.length > cfg.block_size) ctx.splice(1, 1); // keep BOS at 0\n }\n setGenerated(gen);\n }, [prompt, stateRef, configRef, tokRef, online]);\n\n return html`

\n inference ${online ? html`\\u00B7 online learning on prompt` : \"\"}\n

setPrompt(e.target.value)}\n        onKeyDown=${(e: any) => { if (e.key === \"Enter\" && !e.shiftKey) { e.preventDefault(); generate(); } }}\n        placeholder=\"type a prompt\\u2026\"\n        style=${{ flex: 1, height: 36, background: \"#0a0a12\", border: \"1px solid #1a1a2e\", color: \"#c9d1d9\", padding: 6, borderRadius: 4, fontSize: 11, resize: \"vertical\", outline: \"none\" }}/>\n      <button class=\"btn\" onClick=${generate} disabled=${!prompt}\n        style=${{ color: prompt ? \"#63b3ed\" : \"#333\" }}>generate</button>\n    </div>\n    ${perChar.length > 0 && html`<div>\n      <div style=${{ fontSize: 9, color: \"#888\", marginBottom: 4 }}>\n        prompt: <span style=${{ color: \"#f59e0b\", fontWeight: 600 }}>${avgBPB.toFixed(2)}</span> bpb\n      </div>\n      <div style=${{ fontSize: 13, lineHeight: 1.7, wordBreak: \"break-all\", marginBottom: 4, fontFamily: \"'JetBrains Mono',monospace\" }}>\n        ${perChar.map((ch: any, i: number) => {\n          const s = Math.min(ch.loss / 5.5, 1);\n          const bg = s > .7 ? \"rgba(239,68,68,\" + (s * .3) + \")\" : s > .3 ? \"rgba(245,158,11,\" + (s * .3) + \")\" : \"rgba(74,222,128,\" + (.15 + .2 * (1 - s)) + \")\";\n          return html`<span key=${i} title=${ch.loss.toFixed(2) + \"b p=\" + (ch.p * 100).toFixed(1) + \"%\"} style=${{ background: bg, color: s > .7 ? \"#fca5a5\" : s > .3 ? \"#fcd34d\" : \"#bbf7d0\" }}>${ch.ch}</span>`;\n        })}\n      </div>\n    </div>`}\n    ${generated && html`<div style=${{ marginTop: 4 }}>\n      <span class=\"sm up\" style=${{ marginRight: 4 }}>completion \\u2192</span>\n      <span style=${{ fontSize: 13, color: \"#63b3ed\", fontFamily: \"'JetBrains Mono',monospace\" }}>${generated}</span>\n    </div>`}\n  </div>`;\n}\n",[],[156,286],"89fb6944-2843-11f1-b8e5-42dde27851f2",["D",1774440596797],[],[156,33],"26dc3664-2833-11f1-84e7-42dde27851f2","app.ts","75a42140-27dd-11f1-a332-42dde27851f2",["D",1774433558516],"/**\n * ui/app.ts — Main application\n *\n * Faithful to microgpt.py: Value autograd, document-level training,\n * Adam optimizer. Plus online toggle for learning during inference.\n */\nimport { html, render, Fragment, useState, useRef, useEffect, useCallback, useMemo } from \"./preact.ts\";\nimport {\n  createStateDict, createAdam, trainStep, onlineObserve, infer,\n  buildTokenizer, DEFAULT_CONFIG,\n  type ModelConfig, type StateDict, type AdamState, type Tokenizer,\n} from \"../core/index.ts\";\nimport { getDefaultDocs, shuffleDocs } from \"../corpus/index.ts\";\nimport { LossCurve } from \"./loss-curve.ts\";\nimport { InferencePanel } from \"./inference.ts\";\nimport { AnalyticsPanel } from \"./analytics-panel.ts\";\nimport { Section } from \"./widgets.ts\";\n\nfunction App() {\n  // Refs for mutable state (not re-rendered on change)\n  const sdRef = useRef<StateDict | null>(null);\n  const paramsRef = useRef<any[]>([]);\n  const adamRef = useRef<AdamState | null>(null);\n  const tokRef = useRef<Tokenizer | null>(null);\n  const cfgRef = useRef<ModelConfig>({ ...DEFAULT_CONFIG });\n  const docsRef = useRef<string[]>([]);\n  const histRef = useRef<any[]>([]);\n  const stepRef = useRef(0);\n  const epochRef = useRef(0);\n  const timerRef = useRef<any>(null);\n\n  // UI state\n  const [, tick] = useState(0);\n  const [running, setRunning] = useState(false);\n  const [speed, setSpeed] = useState(3); // docs per tick\n  const [lr, setLr] = useState(0.01);\n  const [mode, setMode] = useState(\"train\");\n  const [online, setOnline] = useState(false);\n  const [hoverStep, setHoverStep] = useState<number | null>(null);\n  const [customText, setCustomText] = useState(\"\");\n  const [showDocs, setShowDocs] = useState(false);\n\n  // Initialize\n  const doInit = useCallback(() => {\n    const docs = shuffleDocs(getDefaultDocs());\n    docsRef.current = docs;\n    const tok = buildTokenizer(docs);\n    tokRef.current = tok;\n    const cfg = { ...DEFAULT_CONFIG, vocab_size: tok.vocab_size };\n    cfgRef.current = cfg;\n    const { state_dict, params } = createStateDict(cfg);\n    sdRef.current = state_dict;\n    paramsRef.current = params;\n    adamRef.current = createAdam(params.length);\n    histRef.current = [];\n    stepRef.current = 0;\n    epochRef.current = 0;\n    tick(n => n + 1);\n  }, []);\n\n  useEffect(() => { doInit(); }, []);\n\n  // Train one document\n  const trainOne = useCallback(() => {\n    const sd = sdRef.current, params = paramsRef.current, adam = adamRef.current;\n    const tok = tokRef.current, cfg = cfgRef.current, docs = docsRef.current;\n    if (!sd || !adam || !tok || docs.length === 0) return;\n\n    const docIdx = stepRef.current % docs.length;\n    if (docIdx === 0 && stepRef.current > 0) epochRef.current++;\n    const doc = docs[docIdx];\n    const tokens = [tok.BOS, ...tok.encode(doc), tok.BOS];\n\n    const totalSteps = 1000; // for LR decay\n    const lrDecay = lr * (1 - (stepRef.current % totalSteps) / totalSteps);\n    const result = trainStep(tokens, sd, cfg, params, adam, lrDecay);\n    stepRef.current++;\n\n    histRef.current.push({\n      step: stepRef.current,\n      loss: result.lossBits,\n      phase: 0,\n      docIdx,\n      docPreview: doc.slice(0, 30),\n    });\n  }, [lr]);\n\n  // Training loop\n  useEffect(() => {\n    if (timerRef.current) clearInterval(timerRef.current);\n    if (!running || mode !== \"train\") return;\n    timerRef.current = setInterval(() => {\n      for (let i = 0; i < speed; i++) trainOne();\n      tick(n => n + 1);\n    }, 80);\n    return () => { if (timerRef.current) clearInterval(timerRef.current); };\n  }, [running, speed, trainOne, mode]);\n\n  const singleStep = useCallback(() => {\n    setRunning(false);\n    trainOne();\n    tick(n => n + 1);\n  }, [trainOne]);\n\n  const reset = useCallback(() => {\n    setRunning(false);\n    doInit();\n  }, [doInit]);\n\n  const addDoc = useCallback(() => {\n    if (!customText.trim()) return;\n    const lines = customText.split(\"\\n\").map(s => s.trim()).filter(s => s.length > 0);\n    docsRef.current = [...docsRef.current, ...lines];\n    // Rebuild tokenizer with expanded vocab\n    const tok = buildTokenizer(docsRef.current);\n    tokRef.current = tok;\n    // Note: model retains old vocab — user should reset for new chars\n    setCustomText(\"\");\n    tick(n => n + 1);\n  }, [customText]);\n\n  // Derived\n  const hist = histRef.current;\n  const step = stepRef.current;\n  const epoch = epochRef.current;\n  const nDocs = docsRef.current.length;\n  const nParams = paramsRef.current.length;\n  const recentLoss = hist.length > 5 ? hist.slice(-10).reduce((s: number, h: any) => s + h.loss, 0) / Math.min(10, hist.length) : (hist.length > 0 ? hist[hist.length - 1].loss : 0);\n  const lastDoc = hist.length > 0 ? hist[hist.length - 1] : null;\n\n  const [cw, setCw] = useState(600);\n  const containerRef = useRef<any>(null);\n  useEffect(() => {\n    const el = containerRef.current;\n    if (!el) return;\n    const ro = new ResizeObserver((e: any) => { for (const x of e) setCw(x.contentRect.width); });\n    ro.observe(el); return () => ro.disconnect();\n  }, []);\n\n  return html`<div ref=${containerRef} style=${{ minHeight: \"100vh\" }}>\n    \n    <div class=\"pad bdr row\" style=${{ justifyContent: \"space-between\" }}>\n      <div class=\"row\">\n        <h1 style=${{ fontSize: 16, fontWeight: 600, letterSpacing: \"-.02em\", fontFamily: \"'Newsreader',Georgia,serif\" }}>\\u00B5GPT</h1>\n        <span class=\"sm up\">${nParams.toLocaleString()} params \\u00B7 vocab ${tokRef.current?.vocab_size ?? 0}</span>\n        ${running && html`<span style=${{ fontSize: 8, color: \"#f59e0b\", animation: \"pulse 1.5s ease infinite\" }}>\\u25CF</span>`}\n      </div>\n      <div class=\"row\" style=${{ gap: 10 }}>\n        <div><span class=\"sm\">EPOCH </span><span style=${{ fontSize: 13, fontWeight: 600 }}>${epoch}</span></div>\n        <div><span class=\"sm\">DOC </span><span style=${{ fontSize: 13, fontWeight: 600 }}>${step}</span><span class=\"sm\">/${nDocs}</span></div>\n        <div><span class=\"sm\">BPB </span><span style=${{ fontSize: 13, fontWeight: 600, color: recentLoss > 4 ? \"#fca5a5\" : recentLoss > 2 ? \"#fcd34d\" : \"#4ade80\" }}>${recentLoss.toFixed(2)}</span></div>\n      </div>\n    </div>\n\n    \n    <div class=\"pad bdr\" style=${{ paddingTop: 6, paddingBottom: 2 }}>\n      <div class=\"sm up\" style=${{ marginBottom: 2 }}>loss curve (bits/byte per document)</div>\n      <${LossCurve} history=${hist} boundaries=${[]} width=${Math.max(300, cw - 24)} height=${140} hoverStep=${hoverStep} onHover=${setHoverStep} totalCorpus=${nDocs} epoch=${epoch}/>\n    </div>\n\n    \n    <div class=\"pad bdr row\" style=${{ paddingTop: 5, paddingBottom: 5 }}>\n      <div style=${{ display: \"flex\", border: \"1px solid #1e1e30\", borderRadius: 4, overflow: \"hidden\" }}>\n        ${[\"train\", \"infer\"].map((m: string) => html`<button key=${m}\n          onClick=${() => { setMode(m); if (m === \"infer\") setRunning(false); }}\n          style=${{ background: mode === m ? \"#1e1e30\" : \"transparent\", border: \"none\", color: mode === m ? \"#e2e8f0\" : \"#555\", padding: \"2px 8px\", fontSize: 8, textTransform: \"uppercase\" }}>\n          ${m}</button>`)}\n      </div>\n      ${mode === \"train\" && html`<${Fragment}>\n        <button class=\"btn\" onClick=${() => setRunning(!running)}\n          style=${{ color: running ? \"#fcd34d\" : \"#4ade80\" }}>${running ? \"\\u23F8\" : \"\\u25B6\"}</button>\n        <button class=\"btn\" onClick=${singleStep}\n          style=${{ color: \"#63b3ed\", fontSize: 8 }} title=\"single doc\">1\\u23E9</button>\n        <button class=\"btn\" onClick=${reset} style=${{ color: \"#777\" }}>\\u21BA</button>\n        <div class=\"row\" style=${{ gap: 2 }}>\n          <span class=\"sm\">SPD</span>\n          <input type=\"range\" min=\"1\" max=\"20\" value=${speed}\n            onInput=${(e: any) => setSpeed(+e.target.value)} style=${{ width: 50 }}/>\n          <span class=\"sm\">${speed}d/t</span>\n        </div>\n      </${Fragment}>`}\n      <div class=\"row\" style=${{ gap: 2 }}>\n        <span class=\"sm\">LR</span>\n        <input type=\"range\" min=\".001\" max=\".05\" step=\".001\" value=${lr}\n          onInput=${(e: any) => setLr(+e.target.value)} style=${{ width: 40 }}/>\n        <span class=\"sm\">${lr.toFixed(3)}</span>\n      </div>\n      <label style=${{ display: \"flex\", alignItems: \"center\", gap: 3, fontSize: 8, color: online ? \"#4ade80\" : \"#555\", cursor: \"pointer\" }}>\n        <input type=\"checkbox\" checked=${online} onChange=${() => setOnline(!online)}\n          style=${{ accentColor: \"#4ade80\", width: 10, height: 10 }}/>\n        online\n      </label>\n      <button class=\"btn\" onClick=${() => setShowDocs(!showDocs)}\n        style=${{ color: showDocs ? \"#e2e8f0\" : \"#555\", background: showDocs ? \"#1e1e30\" : \"#141420\", fontSize: 7, marginLeft: \"auto\" }}>\n        docs (${nDocs})\n      </button>\n    </div>\n\n    \n    ${showDocs && html`<div class=\"pad bdr\" style=${{ background: \"#0c0c14\", maxHeight: 200, overflowY: \"auto\" }}>\n      <div class=\"sm\" style=${{ marginBottom: 4 }}>${nDocs} documents \\u00B7 add custom lines below</div>\n      <div style=${{ fontSize: 9, color: \"#666\", lineHeight: 1.6, marginBottom: 6 }}>\n        ${docsRef.current.slice(0, 20).map((d: string, i: number) => html`\n          <div key=${i} style=${{ color: \"#555\", overflow: \"hidden\", textOverflow: \"ellipsis\", whiteSpace: \"nowrap\" }}>\n            <span style=${{ color: \"#333\" }}>${i}.</span> ${d.slice(0, 80)}${d.length > 80 ? \"\\u2026\" : \"\"}\n          </div>\n        `)}\n        ${nDocs > 20 && html`<div style=${{ color: \"#333\" }}>\\u2026and ${nDocs - 20} more</div>`}\n      </div>\n      <div class=\"row\">\n        <textarea value=${customText} onInput=${(e: any) => setCustomText(e.target.value)}\n          placeholder=\"add lines (one doc per line)\\u2026\"\n          style=${{ flex: 1, height: 28, background: \"#09090b\", border: \"1px solid #1a1a2e\", color: \"#c9d1d9\", padding: 4, borderRadius: 4, fontSize: 9, resize: \"vertical\", outline: \"none\" }}/>\n        <button class=\"btn\" disabled=${!customText.trim()} onClick=${addDoc}\n          style=${{ color: customText.trim() ? \"#4ade80\" : \"#333\" }}>+ add</button>\n      </div>\n    </div>`}\n\n    \n    <div style=${{ display: \"flex\", flexWrap: \"wrap\" }}>\n      <div style=${{ flex: \"1 1 400px\", padding: \"8px 16px\", borderRight: \"1px solid #141420\", minWidth: 260 }}>\n        ${mode === \"train\" ? html`<div>\n          <div class=\"sm up\" style=${{ marginBottom: 3 }}>training log</div>\n          ${lastDoc ? html`<div style=${{ fontSize: 9, color: \"#888\", marginBottom: 4 }}>\n            last: \"${lastDoc.docPreview}\\u2026\" \\u2192 ${lastDoc.loss.toFixed(2)}b\n          </div>` : html`<div class=\"sm\" style=${{ fontStyle: \"italic\" }}>waiting\\u2026</div>`}\n          <div style=${{ maxHeight: 200, overflowY: \"auto\", fontSize: 9, color: \"#555\", lineHeight: 1.6 }}>\n            ${hist.slice(-30).reverse().map((h: any, i: number) => html`\n              <div key=${i} style=${{ opacity: 1 - i * 0.03 }}>\n                <span style=${{ color: \"#333\" }}>${h.step}.</span>\n                <span style=${{ color: h.loss > 4 ? \"#fca5a5\" : h.loss > 2 ? \"#fcd34d\" : \"#4ade80\" }}>${h.loss.toFixed(2)}b</span>\n                ${\" \"}<span style=${{ color: \"#444\" }}>${h.docPreview}\\u2026</span>\n              </div>\n            `)}\n          </div>\n        </div>` : html`<${InferencePanel}\n          stateRef=${sdRef} configRef=${cfgRef} tokRef=${tokRef}\n          paramsRef=${paramsRef} adamRef=${adamRef} online=${online}/>`}\n      </div>\n\n      <div style=${{ flex: \"0 0 260px\", minWidth: 240, padding: \"8px 12px\", overflowY: \"auto\", maxHeight: 400 }}>\n        <${Section} title=\"curve analytics\" defaultOpen=${true}>\n          <${AnalyticsPanel} history=${hist}/>\n        </${Section}>\n\n        <${Section} title=\"model\">\n          <div style=${{ fontSize: 8, color: \"#666\", lineHeight: 1.6 }}>\n            <div>Value autograd \\u00B7 Adam (\\u03B2\\u2081=0.85, \\u03B2\\u2082=0.99)</div>\n            <div>${cfgRef.current.n_layer}L / ${cfgRef.current.n_head}H \\u00D7 ${cfgRef.current.n_embd / cfgRef.current.n_head}d</div>\n            <div>embd=${cfgRef.current.n_embd} \\u00B7 mlp=${4 * cfgRef.current.n_embd} \\u00B7 ctx=${cfgRef.current.block_size}</div>\n            <div>${nParams.toLocaleString()} params \\u00B7 vocab=${tokRef.current?.vocab_size ?? 0}</div>\n            <div style=${{ color: \"#444\", marginTop: 4, fontStyle: \"italic\" }}>\n              \"Follow GPT-2, blessed among the GPTs\"\n            </div>\n          </div>\n        </${Section}>\n      </div>\n    </div>\n\n    \n    <div class=\"pad\" style=${{ borderTop: \"1px solid #141420\", fontSize: 7, color: \"#1e1e30\", display: \"flex\", justifyContent: \"space-between\", flexWrap: \"wrap\" }}>\n      <span>microgpt: Value autograd \\u2192 document-level training \\u2192 Adam</span>\n      <span>online=${online ? \"on\" : \"off\"} \\u00B7 lr=${lr.toFixed(3)} \\u00B7 speed=${speed}d/tick</span>\n    </div>\n  </div>`;\n}\n\nrender(html`<${App}/>`, document.getElementById(\"root\")!);\n",[],[156,297],"fd673264-282a-11f1-beed-42dde27851f2","analytics-panel.ts","fd673322-282a-11f1-beed-42dde27851f2",45,["D",1774430053024],"/**\n * ui/analytics-panel.ts — Loss curve analytics display\n *\n * Shows windowed slope (learning speed), shift detection,\n * and interpretation. Wires engine/analytics.ts into the UI.\n */\nimport { html, useMemo } from \"./preact.ts\";\nimport { computeSlopes, interpretSlope, detectShifts } from \"../engine/analytics.ts\";\n\nexport function AnalyticsPanel({ history }: { history: any[] }) {\n  const analysis = useMemo(() => {\n    if (history.length < 60) return null;\n    const slopes = computeSlopes(history, 50, 25);\n    if (slopes.length === 0) return null;\n    const current = slopes[slopes.length - 1];\n    const interp = interpretSlope(current.slope);\n    const shifts = detectShifts(slopes);\n    // Compute overall trend: compare first quarter avg to last quarter avg\n    const q = Math.floor(slopes.length / 4);\n    const earlyAvg = q > 0 ? slopes.slice(0, q).reduce((s, x) => s + x.meanLoss, 0) / q : 0;\n    const lateAvg = q > 0 ? slopes.slice(-q).reduce((s, x) => s + x.meanLoss, 0) / q : 0;\n    const improvement = earlyAvg - lateAvg;\n    return { current, interp, shifts, slopes, earlyAvg, lateAvg, improvement };\n  }, [history.length]);\n\n  if (!analysis) {\n    return html`<div style=${{ fontSize: 8, color: \"#333\" }}>collecting data\\u2026 (need ~60 steps)</div>`;\n  }\n\n  const { current, interp, shifts, earlyAvg, lateAvg, improvement } = analysis;\n\n  return html`<div>\n    \n    <div style=${{ display: \"flex\", alignItems: \"center\", gap: 8, marginBottom: 6 }}>\n      <div style=${{\n        width: 8, height: 8, borderRadius: \"50%\",\n        background: interp.color,\n        boxShadow: \"0 0 4px \" + interp.color,\n      }}/>\n      <div>\n        <div style=${{ fontSize: 10, color: interp.color, fontWeight: 600 }}>${interp.label}</div>\n        <div style=${{ fontSize: 7, color: \"#555\" }}>${interp.description}</div>\n      </div>\n    </div>\n\n    \n    <div style=${{ fontSize: 8, color: \"#666\", marginBottom: 4 }}>\n      slope: <span style=${{ color: current.slope < 0 ? \"#4ade80\" : \"#fca5a5\", fontWeight: 600 }}>\n        ${current.slope < 0 ? \"\" : \"+\"}${(current.slope * 1000).toFixed(2)}</span> mb/step\n      \\u00B7 window loss: ${current.meanLoss.toFixed(2)}b\n    </div>\n\n    \n    <div style=${{ fontSize: 8, color: \"#666\", marginBottom: 4 }}>\n      compression: ${earlyAvg.toFixed(2)}b \\u2192 ${lateAvg.toFixed(2)}b\n      (${improvement > 0 ? \"\\u2193\" : \"\\u2191\"}${Math.abs(improvement).toFixed(2)}b)\n    </div>\n\n    \n    ${shifts.length > 0 && html`\n      <div style=${{ fontSize: 8, color: \"#fcd34d\" }}>\n        ${shifts.length} distribution shift${shifts.length > 1 ? \"s\" : \"\"} detected\n        (at step${shifts.length > 1 ? \"s\" : \"\"} ${shifts.slice(-3).join(\", \")}${shifts.length > 3 ? \"\\u2026\" : \"\"})\n      </div>\n    `}\n\n    \n    ${analysis.slopes.length > 3 && html`\n      <div style=${{ marginTop: 6 }}>\n        <div style=${{ fontSize: 7, color: \"#444\", marginBottom: 2 }}>slope over time</div>\n        <div style=${{ display: \"flex\", gap: 1, alignItems: \"center\", height: 20 }}>\n          ${analysis.slopes.slice(-30).map((s: any, i: number) => {\n            const v = Math.max(-0.05, Math.min(0.05, s.slope));\n            const h = Math.abs(v) / 0.05 * 10;\n            const color = v < 0 ? \"#4ade80\" : \"#fca5a5\";\n            return html`<div key=${i} style=${{\n              width: 3, height: Math.max(1, h),\n              background: color, opacity: 0.6, borderRadius: 1,\n              alignSelf: v < 0 ? \"flex-end\" : \"flex-start\",\n            }} title=${\"slope: \" + (v * 1000).toFixed(1) + \" mb/step\"}/>`;\n          })}\n        </div>\n      </div>\n    `}\n  </div>`;\n}\n",[],[156,304],["D",1774396033959],[236,237,238,239,240,241,242,243],[156],"26dc1e68-2833-11f1-84e7-42dde27851f2","smoke.ts","26dc1ee0-2833-11f1-84e7-42dde27851f2",["D",1774433558516],"/**\n * test/smoke.ts — Smoke test: train 20 steps, verify loss drops\n */\nimport { createStateDict, createAdam, trainStep, onlineObserve, buildTokenizer, infer, DEFAULT_CONFIG } from \"../core/index.ts\";\nimport { getDefaultDocs, shuffleDocs } from \"../corpus/index.ts\";\n\nconst docs = shuffleDocs(getDefaultDocs());\nconsole.log(`${docs.length} documents, first: \"${docs[0].slice(0, 50)}...\"`);\n\nconst tok = buildTokenizer(docs);\nconsole.log(`vocab: ${tok.vocab_size} (${tok.chars.length} chars + BOS)`);\n\nconst cfg = { ...DEFAULT_CONFIG, vocab_size: tok.vocab_size, block_size: 16 };\nconst { state_dict, params } = createStateDict(cfg);\nconsole.log(`params: ${params.length}`);\n\nconst adam = createAdam(params.length);\n\n// Train 20 steps on different documents\nconst losses: number[] = [];\nfor (let step = 0; step < 20; step++) {\n  const doc = docs[step % docs.length];\n  const tokens = [tok.BOS, ...tok.encode(doc), tok.BOS];\n  const lr = 0.01 * (1 - step / 100); // linear decay\n  const result = trainStep(tokens, state_dict, cfg, params, adam, lr);\n  losses.push(result.lossBits);\n  if (step % 5 === 0) console.log(`step ${step}: loss ${result.lossBits.toFixed(3)} bits`);\n}\n\nconst early = losses.slice(0, 5).reduce((a, b) => a + b) / 5;\nconst late = losses.slice(-5).reduce((a, b) => a + b) / 5;\nconsole.log(`early avg: ${early.toFixed(3)}, late avg: ${late.toFixed(3)}, delta: ${(early - late).toFixed(3)}`);\nconsole.log(early > late ? \"PASS: loss decreased\" : \"NOTE: loss did not decrease (may need more steps)\");\n\n// Test online observe\nconst ctx = [tok.BOS, ...tok.encode(\"the \")];\nconst obs = onlineObserve(ctx, tok.encode(\"c\")[0], state_dict, cfg, params, adam, 0.005);\nconsole.log(`online observe: loss=${obs.lossBits.toFixed(2)} bits`);\n\n// Test inference\nconst { probs } = infer([tok.BOS], state_dict, cfg);\nconst top5 = probs.map((p, i) => ({ p, c: tok.charOf(i) })).sort((a, b) => b.p - a.p).slice(0, 5);\nconsole.log(`inference top5:`, top5.map(t => `${t.c}:${(t.p * 100).toFixed(1)}%`).join(\" \"));\n\nconsole.log(\"done\");\n",[],[163,315],["D",1774433558516],[234],[163],"61c80d84-27e3-11f1-aa23-42dde27851f2","optim.ts","0e669b1c-27dc-11f1-8a40-42dde27851f2",36,["D",1774399297660],"/**\n * model/optim.ts — SGD and gradient clipping\n * Works with any model size by iterating actual layer arrays.\n */\nimport { type ModelParams, type ModelGrads } from \"./core.ts\";\n\nconst LAYER_KEYS = [\"gn_a\",\"Wq\",\"Wk\",\"Wv\",\"Wo\",\"gn_m\",\"W1\",\"b1\",\"W2\",\"b2\"] as const;\n\nfunction upd(a: any[], b: any[], lr: number) {\n  if (Array.isArray(a[0]) || (a[0] && a[0].length !== undefined)) {\n    for (let i = 0; i < a.length; i++) for (let j = 0; j < a[i].length; j++) {\n      a[i][j] -= lr * b[i][j]; b[i][j] = 0;\n    }\n  } else {\n    for (let i = 0; i < a.length; i++) { a[i] -= lr * b[i]; b[i] = 0; }\n  }\n}\n\nexport function sgdStep(p: ModelParams, g: ModelGrads, lr: number): void {\n  upd(p.te, g.te as any, lr);\n  upd(p.pe, g.pe as any, lr);\n  for (let l = 0; l < p.layers.length; l++) {\n    const ly = p.layers[l] as any, gl = g.layers[l] as any;\n    for (const k of LAYER_KEYS) upd(ly[k], gl[k], lr);\n  }\n  upd(p.gn_f as any, g.gn_f as any, lr);\n  upd(p.lm_head, g.lm_head as any, lr);\n  upd(p.b_out as any, g.b_out as any, lr);\n}\n\nfunction accum(v: any[], norm: { v: number }) {\n  if (Array.isArray(v[0]) || (v[0] && v[0].length !== undefined)) {\n    for (const r of v) for (let i = 0; i < r.length; i++) norm.v += r[i] * r[i];\n  } else {\n    for (let i = 0; i < v.length; i++) norm.v += v[i] * v[i];\n  }\n}\n\nfunction scale(v: any[], s: number) {\n  if (Array.isArray(v[0]) || (v[0] && v[0].length !== undefined)) {\n    for (const r of v) for (let i = 0; i < r.length; i++) r[i] *= s;\n  } else {\n    for (let i = 0; i < v.length; i++) v[i] *= s;\n  }\n}\n\nexport function clipGrads(g: ModelGrads, maxNorm: number): number {\n  const norm = { v: 0 };\n  accum(g.te as any, norm); accum(g.pe as any, norm);\n  for (const gl of g.layers) for (const k of LAYER_KEYS) accum((gl as any)[k], norm);\n  accum(g.gn_f as any, norm); accum(g.lm_head as any, norm); accum(g.b_out as any, norm);\n\n  const n = Math.sqrt(norm.v);\n  if (n > maxNorm) {\n    const s = maxNorm / n;\n    scale(g.te as any, s); scale(g.pe as any, s);\n    for (const gl of g.layers) for (const k of LAYER_KEYS) scale((gl as any)[k], s);\n    scale(g.gn_f as any, s); scale(g.lm_head as any, s); scale(g.b_out as any, s);\n  }\n  return n;\n}\n",[],[169,325],"481ae3fc-27e3-11f1-9891-42dde27851f2","forward.ts","f2c3666a-27db-11f1-9ee9-42dde27851f2",34,["D",1774399254573],"/**\n * model/forward.ts — Full causal self-attention forward pass\n *\n * Reads all dimensions from p.cfg (the config snapshot stored in the model).\n * This means the same code works for any model size.\n */\nimport { rmsnorm, type ModelParams, type ForwardCache } from \"./core.ts\";\n\nexport function forward(p: ModelParams, tokens: number[]): ForwardCache {\n  const { D, N_HEAD, HD, MLP_HID, N_LAYER, VS } = p.cfg;\n  const T = tokens.length;\n  const cache: ForwardCache = {\n    tokens: [...tokens], T,\n    x_layer_in: [], layer_caches: [],\n    x_final: [], fn: { y: [], rms: 0, x_in: [] },\n    z: [], logits: [], probs: [], last_attn: [],\n  };\n\n  // Embeddings: tok + pos\n  const x0: number[][] = [];\n  for (let t = 0; t < T; t++) {\n    const e = new Array(D);\n    for (let j = 0; j < D; j++) e[j] = p.te[tokens[t]][j] + p.pe[t][j];\n    x0.push(e);\n  }\n  let x = x0.map(e => [...e]);\n  cache.x_layer_in = [x0];\n\n  for (let l = 0; l < N_LAYER; l++) {\n    const ly = p.layers[l];\n    const lc: any = {};\n\n    // Attention pre-norm\n    lc.norm_a = [];\n    const u: number[][] = [];\n    for (let t = 0; t < T; t++) {\n      const nr = rmsnorm(x[t], ly.gn_a);\n      lc.norm_a.push({ rms: nr.rms, x_in: [...x[t]] });\n      u.push(nr.y);\n    }\n\n    // QKV projections\n    const Q: number[][] = [], K: number[][] = [], V: number[][] = [];\n    for (let t = 0; t < T; t++) {\n      const q = new Array(D).fill(0), k = new Array(D).fill(0), v = new Array(D).fill(0);\n      for (let j = 0; j < D; j++) for (let m = 0; m < D; m++) {\n        q[j] += u[t][m] * ly.Wq[m][j];\n        k[j] += u[t][m] * ly.Wk[m][j];\n        v[j] += u[t][m] * ly.Wv[m][j];\n      }\n      Q.push(q); K.push(k); V.push(v);\n    }\n    lc.u = u; lc.Q = Q; lc.K = K; lc.V = V;\n\n    // Multi-head causal self-attention\n    const aw: number[][][] = [], ao: number[][] = [];\n    for (let t = 0; t < T; t++) {\n      const aw_t: number[][] = [];\n      const o_t = new Array(D).fill(0);\n      for (let h = 0; h < N_HEAD; h++) {\n        const ho = h * HD;\n        const scores = new Array(t + 1);\n        let maxS = -Infinity;\n        for (let s = 0; s <= t; s++) {\n          let sc = 0;\n          for (let d = 0; d < HD; d++) sc += Q[t][ho + d] * K[s][ho + d];\n          sc /= Math.sqrt(HD);\n          scores[s] = sc;\n          if (sc > maxS) maxS = sc;\n        }\n        let sumE = 0;\n        const attn = new Array(t + 1);\n        for (let s = 0; s <= t; s++) { attn[s] = Math.exp(scores[s] - maxS); sumE += attn[s]; }\n        for (let s = 0; s <= t; s++) attn[s] /= sumE;\n        aw_t.push(attn);\n        for (let d = 0; d < HD; d++) {\n          let acc = 0;\n          for (let s = 0; s <= t; s++) acc += attn[s] * V[s][ho + d];\n          o_t[ho + d] = acc;\n        }\n      }\n      aw.push(aw_t); ao.push(o_t);\n    }\n    lc.attn_weights = aw; lc.attn_out = ao;\n\n    // Output projection + residual\n    const x_mid: number[][] = [];\n    for (let t = 0; t < T; t++) {\n      const proj = new Array(D).fill(0);\n      for (let j = 0; j < D; j++) for (let m = 0; m < D; m++) proj[j] += ao[t][m] * ly.Wo[m][j];\n      const xm = new Array(D);\n      for (let j = 0; j < D; j++) xm[j] = x[t][j] + proj[j];\n      x_mid.push(xm);\n    }\n\n    // MLP pre-norm\n    lc.norm_m = [];\n    const m: number[][] = [];\n    for (let t = 0; t < T; t++) {\n      const nr = rmsnorm(x_mid[t], ly.gn_m);\n      lc.norm_m.push({ rms: nr.rms, x_in: [...x_mid[t]] });\n      m.push(nr.y);\n    }\n    lc.m = m;\n\n    // MLP: D → MLP_HID (ReLU) → D + residual\n    lc.h_pre = []; lc.h = [];\n    const x_out: number[][] = [];\n    for (let t = 0; t < T; t++) {\n      const hp = new Array(MLP_HID).fill(0);\n      for (let j = 0; j < MLP_HID; j++) {\n        for (let k = 0; k < D; k++) hp[j] += m[t][k] * ly.W1[k][j];\n        hp[j] += ly.b1[j];\n      }\n      const h = hp.map((x: number) => x > 0 ? x : 0);\n      const r = new Array(D).fill(0);\n      for (let j = 0; j < D; j++) {\n        for (let k = 0; k < MLP_HID; k++) r[j] += h[k] * ly.W2[k][j];\n        r[j] += ly.b2[j];\n      }\n      lc.h_pre.push(hp); lc.h.push(h);\n      const xo = new Array(D);\n      for (let j = 0; j < D; j++) xo[j] = x_mid[t][j] + r[j];\n      x_out.push(xo);\n    }\n\n    lc.x_mid = x_mid;\n    cache.layer_caches.push(lc);\n    x = x_out;\n    if (l < N_LAYER - 1) cache.x_layer_in.push(x.map(e => [...e]));\n  }\n\n  cache.x_final = x;\n\n  // Final norm → lm_head → softmax\n  const fn = rmsnorm(x[T - 1], p.gn_f);\n  cache.fn = { y: fn.y, rms: fn.rms, x_in: [...x[T - 1]] };\n\n  const logits = new Array(VS).fill(0);\n  for (let i = 0; i < VS; i++) {\n    for (let j = 0; j < D; j++) logits[i] += fn.y[j] * p.lm_head[j][i];\n    logits[i] += p.b_out[i];\n  }\n  const maxL = Math.max(...logits);\n  const expL = logits.map((l: number) => Math.exp(l - maxL));\n  const sumL = expL.reduce((a: number, b: number) => a + b, 0);\n  cache.probs = expL.map((e: number) => e / sumL);\n  cache.z = fn.y;\n  cache.logits = logits;\n  cache.last_attn = cache.layer_caches[N_LAYER - 1].attn_weights[T - 1];\n\n  return cache;\n}\n",[],[169,333],"1b4f0f42-2829-11f1-a8e6-42dde27851f2","core.ts","e02e60a4-27db-11f1-9b54-42dde27851f2",39,["D",1774429244198],"/**\n * model/core.ts — Types, init, RMSNorm, sampling\n *\n * Uses a mutable `cfg` object so the UI can change architecture\n * dimensions before model creation. Import cfg, mutate it, then\n * call createModel().\n */\nimport { type ModelConfig, defaultConfig } from \"./config.ts\";\n\n// Mutable global config — the UI updates this before calling createModel()\nexport const cfg: ModelConfig = defaultConfig();\n\nexport { type ModelConfig } from \"./config.ts\";\nexport { defaultConfig, resolveConfig, estimateParams, PRESETS } from \"./config.ts\";\n\n// ── Types ─────────────────────────────────────────────────────────\nexport interface LayerParams {\n  gn_a: number[];\n  Wq: number[][]; Wk: number[][]; Wv: number[][]; Wo: number[][];\n  gn_m: number[];\n  W1: number[][]; b1: number[];\n  W2: number[][]; b2: number[];\n}\n\nexport interface ModelParams {\n  te: number[][]; pe: number[][];\n  layers: LayerParams[];\n  gn_f: number[];\n  lm_head: number[][]; b_out: number[];\n  /** Snapshot of config at creation time */\n  cfg: ModelConfig;\n}\n\nexport interface LayerGrads {\n  gn_a: Float64Array;\n  Wq: Float64Array[]; Wk: Float64Array[]; Wv: Float64Array[]; Wo: Float64Array[];\n  gn_m: Float64Array;\n  W1: Float64Array[]; b1: Float64Array;\n  W2: Float64Array[]; b2: Float64Array;\n}\n\nexport interface ModelGrads {\n  te: Float64Array[]; pe: Float64Array[];\n  layers: LayerGrads[];\n  gn_f: Float64Array;\n  lm_head: Float64Array[]; b_out: Float64Array;\n}\n\nexport interface ForwardCache {\n  tokens: number[];\n  T: number;\n  x_layer_in: number[][][];\n  layer_caches: LayerCache[];\n  x_final: number[][];\n  fn: { y: number[]; rms: number; x_in: number[] };\n  z: number[];\n  logits: number[];\n  probs: number[];\n  last_attn: number[][];\n}\n\nexport interface LayerCache {\n  norm_a: { rms: number; x_in: number[] }[];\n  u: number[][];\n  Q: number[][]; K: number[][]; V: number[][];\n  attn_weights: number[][][];\n  attn_out: number[][];\n  x_mid: number[][];\n  norm_m: { rms: number; x_in: number[] }[];\n  m: number[][];\n  h_pre: number[][];\n  h: number[][];\n}\n\n// ── Init utilities ────────────────────────────────────────────────\nexport function randn(): number {\n  let u = 0, v = 0;\n  while (!u) u = Math.random();\n  while (!v) v = Math.random();\n  return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);\n}\n\nexport function mat(r: number, c: number, s = 0.02): number[][] {\n  return Array.from({ length: r }, () => Array.from({ length: c }, () => randn() * s));\n}\n\nexport function zmat(r: number, c: number): Float64Array[] {\n  return Array.from({ length: r }, () => new Float64Array(c));\n}\n\nexport function zvec(n: number): Float64Array {\n  return new Float64Array(n);\n}\n\n// ── Model creation (reads from cfg) ───────────────────────────────\nexport function createModel(): ModelParams {\n  const c = cfg;\n  const p: ModelParams = {\n    te: mat(c.VS, c.D),\n    pe: mat(c.CTX, c.D, 0.01),\n    layers: [],\n    gn_f: Array.from({ length: c.D }, () => 1),\n    lm_head: mat(c.D, c.VS, 0.02),\n    b_out: Array(c.VS).fill(0),\n    cfg: { ...c }, // snapshot\n  };\n  for (let l = 0; l < c.N_LAYER; l++) {\n    p.layers.push({\n      gn_a: Array.from({ length: c.D }, () => 1),\n      Wq: mat(c.D, c.D), Wk: mat(c.D, c.D), Wv: mat(c.D, c.D),\n      Wo: mat(c.D, c.D, 0.02 / Math.sqrt(c.N_LAYER)),\n      gn_m: Array.from({ length: c.D }, () => 1),\n      W1: mat(c.D, c.MLP_HID), b1: Array(c.MLP_HID).fill(0),\n      W2: mat(c.MLP_HID, c.D, 0.02 / Math.sqrt(c.N_LAYER)),\n      b2: Array(c.D).fill(0),\n    });\n  }\n  return p;\n}\n\nexport function createGrads(p: ModelParams): ModelGrads {\n  const c = p.cfg;\n  return {\n    te: zmat(c.VS, c.D), pe: zmat(c.CTX, c.D),\n    layers: p.layers.map(() => ({\n      gn_a: zvec(c.D),\n      Wq: zmat(c.D, c.D), Wk: zmat(c.D, c.D),\n      Wv: zmat(c.D, c.D), Wo: zmat(c.D, c.D),\n      gn_m: zvec(c.D),\n      W1: zmat(c.D, c.MLP_HID), b1: zvec(c.MLP_HID),\n      W2: zmat(c.MLP_HID, c.D), b2: zvec(c.D),\n    })),\n    gn_f: zvec(c.D),\n    lm_head: zmat(c.D, c.VS),\n    b_out: zvec(c.VS),\n  };\n}\n\nexport function countParams(p: ModelParams): number {\n  let n = 0;\n  const count = (v: any[]) => {\n    if (Array.isArray(v[0]) || v[0]?.length !== undefined) {\n      for (const r of v) n += r.length;\n    } else n += v.length;\n  };\n  count(p.te); count(p.pe);\n  for (const ly of p.layers) {\n    for (const k of [\"gn_a\",\"Wq\",\"Wk\",\"Wv\",\"Wo\",\"gn_m\",\"W1\",\"b1\",\"W2\",\"b2\"] as const) {\n      count(ly[k] as any[]);\n    }\n  }\n  count(p.gn_f); count(p.lm_head); count(p.b_out);\n  return n;\n}\n\n// ── RMSNorm ───────────────────────────────────────────────────────\nexport function rmsnorm(x: number[], gain: number[]): { y: number[]; rms: number } {\n  const n = x.length;\n  let ss = 0;\n  for (let i = 0; i < n; i++) ss += x[i] * x[i];\n  const rms = Math.sqrt(ss / n + 1e-8);\n  const y = new Array(n);\n  for (let i = 0; i < n; i++) y[i] = gain[i] * x[i] / rms;\n  return { y, rms };\n}\n\nexport function rmsnormBwd(\n  dy: number[], x: number[], gain: number[], rms: number\n): { dx: number[]; dgain: number[] } {\n  const n = x.length;\n  const dx = new Array(n), dgain = new Array(n);\n  let dot = 0;\n  for (let i = 0; i < n; i++) {\n    const xh = x[i] / rms;\n    dot += dy[i] * gain[i] * xh;\n  }\n  const md = dot / n;\n  for (let i = 0; i < n; i++) {\n    const xh = x[i] / rms;\n    dgain[i] = dy[i] * xh;\n    dx[i] = (dy[i] * gain[i] - xh * md) / rms;\n  }\n  return { dx, dgain };\n}\n\n// ── Sampling & display ────────────────────────────────────────────\nexport function sampleFrom(probs: number[]): number {\n  let r = Math.random(), c = 0;\n  for (let i = 0; i < probs.length; i++) {\n    c += probs[i];\n    if (r < c) return i;\n  }\n  return probs.length - 1;\n}\n\nexport function topK(probs: number[], k = 8) {\n  return probs.map((p, i) => ({ id: i, p })).sort((a, b) => b.p - a.p).slice(0, k);\n}\n\nexport function tokStr(id: number): string {\n  if (id === 256) return \"\\u27E8B\\u27E9\";\n  if (id === 10) return \"\\u23CE\";\n  if (id === 32) return \"\\u2423\";\n  if (id === 9) return \"\\u21E5\";\n  if (id < 32 || id === 127) return \"\\u2039\" + id + \"\\u203A\";\n  return String.fromCharCode(id);\n}\n\n\n// ── Convenience re-exports for backward compat ────────────────────\n// These read from the mutable cfg at import time.\n// After changing cfg, re-import or access cfg directly.\nexport const D = cfg.D;\nexport const N_HEAD = cfg.N_HEAD;\nexport const HD = cfg.HD;\nexport const MLP_HID = cfg.MLP_HID;\nexport const CTX = cfg.CTX;\nexport const VS = cfg.VS;\nexport const BOS = cfg.BOS;\nexport const N_LAYER = cfg.N_LAYER;\nexport const EPS = cfg.EPS;\n",[],[169,341],"d059575e-27e2-11f1-8335-42dde27851f2","config.ts","d0595826-27e2-11f1-8335-42dde27851f2",26,["D",1774399053673],"/**\n * model/config.ts — Mutable model hyperparameters\n *\n * Extracted from core.ts so the UI can modify architecture dimensions\n * before model creation. Config is a plain object — change it, then\n * call createModel() to get a model with those dimensions.\n *\n * The key insight from TinyStories: a single-layer, 4-head, 64d model\n * can learn coherent English if the data distribution is simple enough.\n * These defaults are deliberately tiny for interactive browser use.\n */\n\nexport interface ModelConfig {\n  D: number;        // embedding / residual stream width\n  N_HEAD: number;   // attention heads\n  HD: number;       // per-head dimension (derived: D / N_HEAD)\n  MLP_HID: number;  // MLP hidden dimension (typically 4 * D)\n  CTX: number;      // context window (positions)\n  VS: number;       // vocabulary size (257 = 256 bytes + BOS)\n  BOS: number;      // beginning-of-sequence token id\n  N_LAYER: number;  // number of decoder blocks\n  EPS: number;      // RMSNorm epsilon\n}\n\n/** Default config: 1-layer, 4-head, 16d — ~7K params */\nexport function defaultConfig(): ModelConfig {\n  const D = 16;\n  const N_HEAD = 4;\n  return {\n    D,\n    N_HEAD,\n    HD: D / N_HEAD,\n    MLP_HID: 4 * D,\n    CTX: 12,\n    VS: 257,\n    BOS: 256,\n    N_LAYER: 1,\n    EPS: 1e-8,\n  };\n}\n\n/**\n * Validate and derive computed fields.\n * Call after user changes D, N_HEAD, etc.\n */\nexport function resolveConfig(partial: Partial<ModelConfig>): ModelConfig {\n  const base = defaultConfig();\n  const c = { ...base, ...partial };\n  // Derive dependent fields\n  c.HD = Math.floor(c.D / c.N_HEAD);\n  if (c.HD < 1) c.HD = 1;\n  c.D = c.HD * c.N_HEAD; // snap D to multiple of N_HEAD\n  c.MLP_HID = 4 * c.D;\n  c.VS = 257;\n  c.BOS = 256;\n  return c;\n}\n\n/**\n * Estimate parameter count without creating the model.\n */\nexport function estimateParams(c: ModelConfig): number {\n  const { D, VS, CTX, N_LAYER, MLP_HID } = c;\n  const embed = VS * D + CTX * D;                    // te + pe\n  const perLayer = D                                  // gn_a\n    + D * D * 4                                       // Wq, Wk, Wv, Wo\n    + D                                               // gn_m\n    + D * MLP_HID + MLP_HID                           // W1, b1\n    + MLP_HID * D + D;                                // W2, b2\n  const head = D + D * VS + VS;                       // gn_f, lm_head, b_out\n  return embed + N_LAYER * perLayer + head;\n}\n\n/** Preset configs for quick selection */\nexport const PRESETS: Record<string, Partial<ModelConfig>> = {\n  \"nano (7K)\":   { D: 16, N_HEAD: 4, N_LAYER: 1, CTX: 12 },\n  \"micro (30K)\": { D: 32, N_HEAD: 4, N_LAYER: 1, CTX: 16 },\n  \"small (60K)\": { D: 32, N_HEAD: 4, N_LAYER: 2, CTX: 24 },\n  \"med (120K)\":  { D: 48, N_HEAD: 6, N_LAYER: 2, CTX: 32 },\n};\n",[],[169,349],"589f2030-27e3-11f1-8571-42dde27851f2","backward.ts","043dba6c-27dc-11f1-9cf4-42dde27851f2",35,["D",1774399282298],"/**\n * model/backward.ts — Full backward pass through causal decoder block\n *\n * Reads dimensions from p.cfg. Same code works for any model size.\n */\nimport { rmsnormBwd, type ModelParams, type ModelGrads, type ForwardCache } from \"./core.ts\";\n\nexport function backward(p: ModelParams, g: ModelGrads, cache: ForwardCache, target: number): number {\n  const { D, N_HEAD, HD, MLP_HID, VS, N_LAYER } = p.cfg;\n  const { T, probs, z } = cache;\n  const loss = -Math.log(Math.max(probs[target], 1e-10));\n\n  const dl = probs.map((pr, i) => pr - (i === target ? 1 : 0));\n\n  // d_z, d_lm_head, d_b_out\n  const dz = new Array(D).fill(0);\n  for (let j = 0; j < D; j++) {\n    for (let i = 0; i < VS; i++) {\n      g.lm_head[j][i] += z[j] * dl[i];\n      dz[j] += dl[i] * p.lm_head[j][i];\n    }\n  }\n  for (let i = 0; i < VS; i++) g.b_out[i] += dl[i];\n\n  const { dx: dxf, dgain: dgf } = rmsnormBwd(dz, cache.fn.x_in, p.gn_f, cache.fn.rms);\n  for (let j = 0; j < D; j++) g.gn_f[j] += dgf[j];\n\n  const dx = Array.from({ length: T }, () => new Array(D).fill(0));\n  for (let j = 0; j < D; j++) dx[T - 1][j] = dxf[j];\n\n  for (let l = N_LAYER - 1; l >= 0; l--) {\n    const ly = p.layers[l], gl = g.layers[l], lc = cache.layer_caches[l];\n\n    // MLP residual backward\n    const dxm = Array.from({ length: T }, (_, t) => [...dx[t]]);\n    for (let t = 0; t < T; t++) {\n      const dr = [...dx[t]];\n      const dh = new Array(MLP_HID).fill(0);\n      for (let k = 0; k < MLP_HID; k++) for (let j = 0; j < D; j++) {\n        gl.W2[k][j] += lc.h[t][k] * dr[j]; dh[k] += dr[j] * ly.W2[k][j];\n      }\n      for (let j = 0; j < D; j++) gl.b2[j] += dr[j];\n      const dhp = dh.map((d: number, k: number) => lc.h_pre[t][k] > 0 ? d : 0);\n      for (let j = 0; j < MLP_HID; j++) gl.b1[j] += dhp[j];\n      const dm = new Array(D).fill(0);\n      for (let k = 0; k < D; k++) for (let j = 0; j < MLP_HID; j++) {\n        gl.W1[k][j] += lc.m[t][k] * dhp[j]; dm[k] += dhp[j] * ly.W1[k][j];\n      }\n      const { dx: dn, dgain: dg } = rmsnormBwd(dm, lc.norm_m[t].x_in, ly.gn_m, lc.norm_m[t].rms);\n      for (let j = 0; j < D; j++) { gl.gn_m[j] += dg[j]; dxm[t][j] += dn[j]; }\n    }\n\n    // Attention residual backward\n    const dxi = Array.from({ length: T }, (_, t) => [...dxm[t]]);\n    const dao = Array.from({ length: T }, () => new Array(D).fill(0));\n    for (let t = 0; t < T; t++) for (let m = 0; m < D; m++) for (let j = 0; j < D; j++) {\n      gl.Wo[m][j] += lc.attn_out[t][m] * dxm[t][j];\n      dao[t][m] += dxm[t][j] * ly.Wo[m][j];\n    }\n\n    // Multi-head attention backward\n    const dQ = Array.from({ length: T }, () => new Array(D).fill(0));\n    const dK = Array.from({ length: T }, () => new Array(D).fill(0));\n    const dV = Array.from({ length: T }, () => new Array(D).fill(0));\n    for (let t = 0; t < T; t++) for (let h = 0; h < N_HEAD; h++) {\n      const ho = h * HD, attn = lc.attn_weights[t][h];\n      const da = new Array(t + 1).fill(0);\n      for (let s = 0; s <= t; s++) for (let d = 0; d < HD; d++) {\n        da[s] += dao[t][ho + d] * lc.V[s][ho + d];\n        dV[s][ho + d] += attn[s] * dao[t][ho + d];\n      }\n      let dot = 0;\n      for (let s = 0; s <= t; s++) dot += attn[s] * da[s];\n      const scale = 1 / Math.sqrt(HD);\n      for (let s = 0; s <= t; s++) {\n        const ds = attn[s] * (da[s] - dot);\n        for (let d = 0; d < HD; d++) {\n          dQ[t][ho + d] += ds * lc.K[s][ho + d] * scale;\n          dK[s][ho + d] += ds * lc.Q[t][ho + d] * scale;\n        }\n      }\n    }\n\n    // QKV projection backward\n    const du = Array.from({ length: T }, () => new Array(D).fill(0));\n    for (let t = 0; t < T; t++) for (let m = 0; m < D; m++) for (let j = 0; j < D; j++) {\n      gl.Wq[m][j] += lc.u[t][m] * dQ[t][j]; du[t][m] += dQ[t][j] * ly.Wq[m][j];\n      gl.Wk[m][j] += lc.u[t][m] * dK[t][j]; du[t][m] += dK[t][j] * ly.Wk[m][j];\n      gl.Wv[m][j] += lc.u[t][m] * dV[t][j]; du[t][m] += dV[t][j] * ly.Wv[m][j];\n    }\n\n    // Attention pre-norm backward\n    for (let t = 0; t < T; t++) {\n      const { dx: dn, dgain: dg } = rmsnormBwd(du[t], lc.norm_a[t].x_in, ly.gn_a, lc.norm_a[t].rms);\n      for (let j = 0; j < D; j++) { gl.gn_a[j] += dg[j]; dxi[t][j] += dn[j]; }\n    }\n    for (let t = 0; t < T; t++) for (let j = 0; j < D; j++) dx[t][j] = dxi[t][j];\n  }\n\n  // Embedding gradients\n  const toks = cache.tokens;\n  for (let t = 0; t < T; t++) for (let j = 0; j < D; j++) {\n    g.te[toks[t]][j] += dx[t][j]; g.pe[t][j] += dx[t][j];\n  }\n  return loss;\n}\n",[],[169,357],["D",1774395971862],[228,229,230,231,232],[169],"1fba45ee-27dc-11f1-bfd1-42dde27851f2","index.ts","1fba4724-27dc-11f1-bfd1-42dde27851f2",10,["D",1774396179991],"/**\n * mechanisms/index.ts — Research-backed online learning mechanisms\n *\n * Each mechanism is toggleable and self-contained. They modify the\n * update decision in the training loop without touching the model.\n *\n * 1. Selective-Backprop:  Skip updates on low-loss tokens (save compute)\n * 2. ReplayBuffer:        Reservoir sampling + prioritised replay (stability)\n * 3. Adaptive LR:         Dual-EMA shift detection → LR boost (plasticity)\n */\n\n// ═══════════════════════════════════════════════════════════════════════\n// Selective-Backprop (Jiang et al. 2019)\n// Only backprop when loss exceeds threshold — spend compute where wrong\n// ═══════════════════════════════════════════════════════════════════════\nexport interface SelectiveBackpropConfig {\n  enabled: boolean;\n  threshold: number; // bits — skip if loss < threshold\n}\n\nexport function shouldUpdate(\n  lossBits: number,\n  config: SelectiveBackpropConfig,\n): boolean {\n  if (!config.enabled) return true;\n  return lossBits >= config.threshold;\n}\n\n// ═══════════════════════════════════════════════════════════════════════\n// Experience Replay — reservoir sampling + prioritised retrieval\n// Breaks strict prequential but best stability-plasticity tradeoff\n// ═══════════════════════════════════════════════════════════════════════\nexport interface ReplayEntry {\n  window: number[];\n  target: number;\n  loss: number;\n}\n\nexport class ReplayBuffer {\n  private buf: ReplayEntry[] = [];\n  private n = 0;\n\n  constructor(public capacity: number) {}\n\n  add(window: number[], target: number, loss: number): void {\n    this.n++;\n    if (this.buf.length < this.capacity) {\n      this.buf.push({ window: [...window], target, loss });\n    } else {\n      // Reservoir sampling: uniform coverage of stream\n      const j = Math.floor(Math.random() * this.n);\n      if (j < this.capacity) {\n        this.buf[j] = { window: [...window], target, loss };\n      }\n    }\n  }\n\n  /**\n   * Sample proportional to stored loss (surprisal priority).\n   * High-loss examples are replayed more often.\n   */\n  samplePrioritised(k: number): ReplayEntry[] {\n    if (this.buf.length === 0) return [];\n    const total = this.buf.reduce((s, e) => s + e.loss, 0);\n    const samples: ReplayEntry[] = [];\n    for (let i = 0; i < Math.min(k, this.buf.length); i++) {\n      let r = Math.random() * total, cum = 0;\n      for (const entry of this.buf) {\n        cum += entry.loss;\n        if (r < cum) { samples.push(entry); break; }\n      }\n    }\n    return samples;\n  }\n\n  get size(): number { return this.buf.length; }\n\n  clear(): void {\n    this.buf = [];\n    this.n = 0;\n  }\n}\n\n// ═══════════════════════════════════════════════════════════════════════\n// Adaptive LR — dual EMA shift detection\n// Fast EMA tracks recent loss, slow EMA tracks trend.\n// When fast/slow > ratio → distribution shift → boost LR\n// ═══════════════════════════════════════════════════════════════════════\nexport interface AdaptiveLRState {\n  slow: number;  // slow EMA of loss\n  fast: number;  // fast EMA of loss\n  effectiveLR: number;\n}\n\nexport interface AdaptiveLRConfig {\n  enabled: boolean;\n  slowAlpha: number;  // e.g. 0.005\n  fastAlpha: number;  // e.g. 0.05\n  boostRatio: number; // e.g. 1.5 — trigger when fast/slow > this\n  boostFactor: number; // e.g. 3.0 — multiply LR by this during shift\n}\n\nexport function createAdaptiveLRState(initialLoss = 5.5): AdaptiveLRState {\n  return { slow: initialLoss, fast: initialLoss, effectiveLR: 0 };\n}\n\nexport function adaptLR(\n  baseLR: number,\n  lossBits: number,\n  state: AdaptiveLRState,\n  config: AdaptiveLRConfig,\n): number {\n  if (!config.enabled) {\n    state.effectiveLR = baseLR;\n    return baseLR;\n  }\n\n  state.slow = config.slowAlpha * lossBits + (1 - config.slowAlpha) * state.slow;\n  state.fast = config.fastAlpha * lossBits + (1 - config.fastAlpha) * state.fast;\n\n  const ratio = state.fast / (state.slow + 1e-8);\n  const lr = ratio > config.boostRatio ? baseLR * config.boostFactor : baseLR;\n  state.effectiveLR = lr;\n  return lr;\n}\n\n// ═══════════════════════════════════════════════════════════════════════\n// Mechanism stats — counters for UI display\n// ═══════════════════════════════════════════════════════════════════════\nexport interface MechanismStats {\n  updates: number;\n  skips: number;\n  replays: number;\n  clips: number;\n  lrBoosts: number;\n}\n\nexport function createStats(): MechanismStats {\n  return { updates: 0, skips: 0, replays: 0, clips: 0, lrBoosts: 0 };\n}\n",[],[175,368],["D",1774395976131],[226],[175],"50f8f236-27dc-11f1-bdcd-42dde27851f2","loop.ts","50f8f33a-27dc-11f1-bdcd-42dde27851f2",12,["D",1774396262971],"/**\n * engine/loop.ts — Online training loop\n *\n * Implements the prequential protocol: predict → observe → update.\n * Coordinates model, mechanisms, and corpus into a single observation step.\n */\nimport { CTX, BOS, sampleFrom, topK, type ModelParams, type ModelGrads, type ForwardCache } from \"../model/core.ts\";\nimport { forward } from \"../model/forward.ts\";\nimport { backward } from \"../model/backward.ts\";\nimport { sgdStep, clipGrads } from \"../model/optim.ts\";\nimport {\n  shouldUpdate,\n  adaptLR,\n  type SelectiveBackpropConfig,\n  type ReplayBuffer,\n  type AdaptiveLRState,\n  type AdaptiveLRConfig,\n  type MechanismStats,\n} from \"../mechanisms/index.ts\";\nimport { getPhaseAt, type Corpus, type PhaseBoundary } from \"../corpus/phases.ts\";\n\nexport interface HistoryEntry {\n  step: number;\n  targetId: number;\n  predicted: number;\n  loss: number;       // bits\n  pCorrect: number;\n  entropy: number;\n  phase: number;\n  skipped: boolean;\n  replayed: boolean;\n  topk: { id: number; p: number }[] | null;\n  attn: number[][] | null;\n}\n\nexport interface TrainingState {\n  model: ModelParams;\n  grads: ModelGrads;\n  context: number[];\n  step: number;\n  bytePos: number;\n  epoch: number;\n  cumBits: number;\n  history: HistoryEntry[];\n}\n\nexport interface LoopConfig {\n  lr: number;\n  chunkK: number;\n  loop: boolean;\n  selBackprop: SelectiveBackpropConfig;\n  replay: { enabled: boolean; k: number };\n  adaptiveLR: AdaptiveLRConfig;\n  gradClip: { enabled: boolean; maxNorm: number };\n}\n\n/**\n * Process a batch of tokens through the prequential loop.\n * Returns true if reached end of corpus (and not looping).\n */\nexport function processTokens(\n  state: TrainingState,\n  corpus: Corpus,\n  config: LoopConfig,\n  replayBuf: ReplayBuffer,\n  adaptiveLRState: AdaptiveLRState,\n  stats: MechanismStats,\n  count: number,\n  isLastOfBatch: (processed: number, count: number) => boolean = (p, c) => p === c - 1,\n): boolean {\n  const { model: p, grads: g, context: ctx } = state;\n  let processed = 0;\n\n  while (processed < count) {\n    // Epoch wrap\n    if (state.bytePos >= corpus.total) {\n      if (config.loop) {\n        state.bytePos = 0;\n        state.epoch++;\n      } else {\n        return true; // done\n      }\n    }\n\n    const targetId = corpus.bytes[state.bytePos];\n    const phaseIdx = getPhaseAt(corpus.boundaries, state.bytePos);\n    const tokens = ctx.slice(-CTX);\n\n    // Forward pass (prediction)\n    const cache = forward(p, tokens);\n    const predicted = sampleFrom(cache.probs);\n    const lossNats = -Math.log(Math.max(cache.probs[targetId], 1e-10));\n    const lossBits = lossNats / Math.LN2;\n    const entropy = -cache.probs.reduce(\n      (s, pr) => s + (pr > 1e-10 ? pr * Math.log2(pr) : 0), 0\n    );\n\n    state.step++;\n    state.cumBits += lossBits;\n\n    // Compute effective LR\n    const effectiveLR = adaptLR(config.lr, lossBits, adaptiveLRState, config.adaptiveLR);\n    if (config.adaptiveLR.enabled && effectiveLR > config.lr) stats.lrBoosts++;\n\n    // Decide whether to update\n    let skipped = false;\n    let replayed = false;\n    const readyForUpdate = state.step % config.chunkK === 0;\n\n    if (readyForUpdate) {\n      if (!shouldUpdate(lossBits, config.selBackprop)) {\n        skipped = true;\n        stats.skips++;\n      } else {\n        backward(p, g, cache, targetId);\n        stats.updates++;\n\n        // Replay\n        if (config.replay.enabled && replayBuf.size > 0) {\n          const samples = replayBuf.samplePrioritised(config.replay.k);\n          for (const s of samples) {\n            const rCache = forward(p, s.window);\n            backward(p, g, rCache, s.target);\n          }\n          if (samples.length > 0) { replayed = true; stats.replays++; }\n        }\n\n        // Gradient clipping\n        if (config.gradClip.enabled) {\n          const norm = clipGrads(g, config.gradClip.maxNorm);\n          if (norm > config.gradClip.maxNorm) stats.clips++;\n        }\n\n        sgdStep(p, g, effectiveLR);\n      }\n    }\n\n    // Store in replay buffer\n    if (config.replay.enabled) {\n      replayBuf.add(tokens, targetId, lossBits);\n    }\n\n    // Record history\n    const last = isLastOfBatch(processed, count);\n    state.history.push({\n      step: state.step, targetId, predicted, loss: lossBits,\n      pCorrect: cache.probs[targetId], entropy, phase: phaseIdx,\n      skipped, replayed,\n      topk: last ? topK(cache.probs) : null,\n      attn: last ? cache.last_attn : null,\n    });\n\n    // Advance context\n    ctx.push(targetId);\n    if (ctx.length > CTX) ctx.splice(0, ctx.length - CTX);\n    state.bytePos++;\n    processed++;\n  }\n\n  return false; // not done\n}\n",[],[180,379],"0b883318-27e3-11f1-b236-42dde27851f2","analytics.ts","0b88341c-27e3-11f1-b236-42dde27851f2",31,["D",1774399152965],"/**\n * engine/analytics.ts — Loss curve analysis\n *\n * Windowed slope (\"learning rate\" in the information-theoretic sense):\n * how fast is the model compressing? A negative slope means learning\n * is happening. The magnitude tells you how fast. A slope near zero\n * means the model has saturated at this data/capacity combination.\n *\n * Research context:\n * - The loss curve of an online learner is a compression curve.\n *   Cumulative BPB is literally the code length per symbol.\n * - Shannon's source coding theorem gives the floor: entropy of the\n *   source. The gap between model BPB and source entropy = model's\n *   remaining ignorance.\n * - The slope at any point is the instantaneous \"compression gain.\"\n *   Steep negative = rapid learning. Flat = saturated or stuck.\n *   Positive = forgetting (distribution shift, or instability).\n *\n * What windowed slope tells you:\n * - Sustained negative slope → model is still learning useful patterns\n * - Slope flattening → approaching capacity limit (for this data/model)\n * - Sharp positive spike → distribution shift (phase transition)\n * - Slope recovery after spike → adaptation to new distribution\n * - Slope getting less negative each epoch → diminishing returns\n *\n * The \"angle\" metaphor: if you drew a tangent line at any point on\n * the loss curve, the angle below horizontal = learning speed.\n * Horizontal = no learning. Tilting up = forgetting.\n */\n\nexport interface SlopeWindow {\n  startStep: number;\n  endStep: number;\n  slope: number;       // bits/byte per step (negative = improving)\n  meanLoss: number;    // average loss in window\n  phase: number;       // dominant phase in window\n}\n\n/**\n * Compute windowed slopes from history.\n * Returns one SlopeWindow per window of `windowSize` entries,\n * stepping by `stride` entries.\n *\n * Slope is computed by linear regression over the window.\n */\nexport function computeSlopes(\n  history: { loss: number; phase: number }[],\n  windowSize: number = 50,\n  stride: number = 25,\n): SlopeWindow[] {\n  const results: SlopeWindow[] = [];\n  if (history.length < windowSize) return results;\n\n  for (let start = 0; start + windowSize <= history.length; start += stride) {\n    const window = history.slice(start, start + windowSize);\n    const n = window.length;\n\n    // Linear regression: slope of loss vs position\n    let sumX = 0, sumY = 0, sumXY = 0, sumXX = 0;\n    for (let i = 0; i < n; i++) {\n      sumX += i;\n      sumY += window[i].loss;\n      sumXY += i * window[i].loss;\n      sumXX += i * i;\n    }\n    const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);\n    const meanLoss = sumY / n;\n\n    // Dominant phase: mode\n    const phaseCounts: Record<number, number> = {};\n    for (const h of window) phaseCounts[h.phase] = (phaseCounts[h.phase] || 0) + 1;\n    let maxCount = 0, dominantPhase = 0;\n    for (const [p, c] of Object.entries(phaseCounts)) {\n      if (c > maxCount) { maxCount = c; dominantPhase = parseInt(p); }\n    }\n\n    results.push({\n      startStep: start,\n      endStep: start + windowSize - 1,\n      slope,\n      meanLoss,\n      phase: dominantPhase,\n    });\n  }\n\n  return results;\n}\n\n/**\n * Detect distribution shifts: points where slope changes sign\n * from negative to positive (learning → forgetting).\n */\nexport function detectShifts(slopes: SlopeWindow[]): number[] {\n  const shifts: number[] = [];\n  for (let i = 1; i < slopes.length; i++) {\n    if (slopes[i - 1].slope < -0.001 && slopes[i].slope > 0.001) {\n      shifts.push(slopes[i].startStep);\n    }\n  }\n  return shifts;\n}\n\n/**\n * Interpret slope for UI display.\n */\nexport function interpretSlope(slope: number): {\n  label: string;\n  color: string;\n  description: string;\n} {\n  if (slope < -0.01) return {\n    label: \"learning fast\",\n    color: \"#4ade80\",\n    description: \"Model is rapidly improving its compression of this data.\",\n  };\n  if (slope < -0.002) return {\n    label: \"learning\",\n    color: \"#86efac\",\n    description: \"Model is steadily improving. Patterns are being captured.\",\n  };\n  if (slope < 0.002) return {\n    label: \"plateau\",\n    color: \"#fcd34d\",\n    description: \"Model has roughly saturated on current data/capacity.\",\n  };\n  if (slope < 0.01) return {\n    label: \"drifting\",\n    color: \"#fca5a5\",\n    description: \"Loss is increasing slightly. Possible distribution shift.\",\n  };\n  return {\n    label: \"forgetting\",\n    color: \"#ef4444\",\n    description: \"Loss rising sharply. Distribution shift or instability.\",\n  };\n}\n",[],[180,387],["D",1774396030221],[223,224],[180],"db25fc78-27e2-11f1-b51f-42dde27851f2","stories.ts","db25fd2c-27e2-11f1-b51f-42dde27851f2",27,["D",1774399071788],"/**\n * corpus/stories.ts — TinyStories-inspired simple narratives\n *\n * From Eldan & Li (2023): tiny models learn coherent English when the\n * training distribution uses simple vocabulary (3-4 year old level),\n * short sentences, clear narrative arcs, and high repetition of\n * common patterns. The key is matching data complexity to model capacity.\n *\n * These are hand-written in that spirit — short, repetitive structure,\n * limited vocabulary, lots of \"the X did Y\" patterns that a 12-token\n * context window can actually capture.\n */\n\nexport const STORIES_TEXT = `The cat sat on the mat. The cat was happy. The dog came in. The dog saw the cat. The cat ran away. The dog sat on the mat. The dog was happy too.\n\nThe girl had a red ball. She went to the park. She threw the ball. The ball went far. She ran to get the ball. She threw it again. She had fun at the park.\n\nThe boy was sad. He lost his toy. He looked in his room. He looked in the box. He found his toy. The boy was happy. He played with his toy all day.\n\nThe bird sat in the tree. The bird sang a song. The cat heard the song. The cat looked up. The bird flew away. The cat sat down. The bird came back and sang again.\n\nThe sun came up. The day was warm. The girl went out. She saw a dog. The dog was small. She gave the dog some food. The dog was happy. The girl was happy too.\n\nThe boy had a hat. The hat was blue. The wind came. The hat flew away. The boy ran after his hat. He got his hat back. He put it on his head.\n\nIt was time to eat. The girl sat down. She had some bread. She had some milk. The food was good. She ate it all. She was not hungry now.\n\nThe cat and the dog were friends. They played in the yard. The cat ran fast. The dog ran fast too. They were tired. They sat down to rest. They were happy friends.\n\nThe boy went to the lake. He saw a fish. The fish was big. He tried to catch the fish. The fish swam away. The boy tried again. This time he got the fish.\n\nThe girl found a flower. The flower was red. She gave it to her mom. Her mom was happy. She put the flower in a cup. The flower was pretty in the cup.`;\n\nexport const STORIES_PHASE = {\n  name: \"Simple stories\",\n  color: \"#34d399\",\n};\n",[],[186,398],"88ae0170-27e2-11f1-8c2a-42dde27851f2","simple-stories.ts","88ae024c-27e2-11f1-8c2a-42dde27851f2",22,["D",1774398933428],"/** corpus/simple-stories.ts — TinyStories-informed training data (Eldan & Li 2023) */\nexport const SIMPLE_STORIES = `Once there was a little cat named Tom. Tom liked to play in the garden. Every day Tom would run and jump in the grass. He was a happy cat.\n\nOne day Tom saw a big red ball. He wanted to play with the ball. He ran to the ball and pushed it with his nose. The ball rolled away. Tom ran after the ball. He pushed it again and again. Tom was very happy.\n\nThen it started to rain. Tom did not like the rain. He ran back to the house. He sat by the window and watched the rain fall. When the rain stopped Tom went back to the garden to play with his ball.\n\nOnce there was a little girl named Lily. Lily had a small dog named Max. Max was brown and white. Lily and Max liked to go to the park.\n\nAt the park Lily would throw a stick. Max would run and get the stick. He would bring it back to Lily. Then Lily would throw the stick again. They did this many times.\n\nOne day Max found a big puddle. He jumped in the puddle. The water went everywhere. Lily got wet. She laughed and laughed. Then Max shook his body and more water went on Lily. They were both wet but they were happy.\n\nOnce there was a boy named Sam. Sam had a red toy car. He liked to push the car on the floor. The car would go fast. Sam would say zoom zoom.\n\nSam took his car to school. He showed his car to his friend Ben. Ben said it is a nice car. Can I play with it. Sam said yes you can play with it. They took turns pushing the car.\n\nAfter school Sam and Ben went to the park. They pushed the car down the hill. The car went very fast. It went all the way to the tree. Sam and Ben ran to get it. They pushed it down the hill again and again.\n\nOnce there was a small bird. The bird was blue. It lived in a tall tree. Every morning the bird would sing a song. The song was pretty.\n\nOne day the bird flew to a new tree. In the new tree there was another bird. The other bird was yellow. The blue bird sang its song. The yellow bird sang too. They sang together. It was a very pretty song.\n\nThen more birds came. A red bird came. A green bird came. All the birds sang together in the tree. The tree was full of birds and songs. It was the best day.`;\n",[],[186,406],"8bf2e6ca-27e2-11f1-bda3-42dde27851f2","repetitive.ts","8bf2e7b0-27e2-11f1-bda3-42dde27851f2",23,["D",1774398938916],"/** corpus/repetitive.ts — Pattern data for fast-collapse demo */\nexport const REPETITIVE = `the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. the cat sat on the mat. `;\n",[],[186,414],"117bc3de-27e3-11f1-878e-42dde27851f2","phases.ts","30053d3c-27dc-11f1-b87c-42dde27851f2",32,["D",1774399162941],"/**\n * corpus/phases.ts — Corpus management\n *\n * Imports text from separate corpus files and assembles into phases.\n * TinyStories-informed default: lead with simple stories that match\n * the model's capacity, then progressively harder distributions.\n */\nimport { SIMPLE_STORIES } from \"./simple-stories.ts\";\nimport { STORIES_TEXT } from \"./stories.ts\";\nimport { ENGLISH_TEXT } from \"./english.ts\";\nimport { JAVASCRIPT } from \"./code.ts\";\nimport { REPETITIVE } from \"./repetitive.ts\";\n\nexport interface Phase {\n  name: string; color: string; text: string;\n  enabled: boolean; id: number; builtIn: boolean;\n}\nexport interface PhaseBoundary {\n  start: number; end: number; name: string; color: string;\n}\nexport interface Corpus {\n  bytes: number[]; boundaries: PhaseBoundary[]; total: number;\n}\n\nexport const DEFAULT_PHASES: Omit<Phase, \"enabled\" | \"id\" | \"builtIn\">[] = [\n  { name: \"Simple stories\", color: \"#34d399\", text: SIMPLE_STORIES },\n  { name: \"More stories\", color: \"#4ade80\", text: STORIES_TEXT },\n  { name: \"English prose\", color: \"#38bdf8\", text: ENGLISH_TEXT },\n  { name: \"JavaScript\", color: \"#f59e0b\", text: JAVASCRIPT },\n  { name: \"Repetitive\", color: \"#c084fc\", text: REPETITIVE },\n];\n\nexport function buildCorpus(phases: Phase[]): Corpus {\n  const active = phases.filter(ph => ph.enabled);\n  const bytes: number[] = [], boundaries: PhaseBoundary[] = [];\n  let offset = 0;\n  for (const phase of active) {\n    const encoded = new TextEncoder().encode(phase.text);\n    boundaries.push({ start: offset, end: offset + encoded.length, name: phase.name, color: phase.color });\n    for (const b of encoded) bytes.push(b);\n    offset += encoded.length;\n  }\n  return { bytes, boundaries, total: bytes.length };\n}\n\nexport function getPhaseAt(boundaries: PhaseBoundary[], pos: number): number {\n  for (let i = 0; i < boundaries.length; i++) {\n    if (pos >= boundaries[i].start && pos < boundaries[i].end) return i;\n  }\n  return boundaries.length - 1;\n}\n\nexport function createDefaultPhases(): Phase[] {\n  return DEFAULT_PHASES.map((ph, i) => ({ ...ph, enabled: true, id: i, builtIn: true }));\n}\n",[],[186,422],"26dc14fe-2833-11f1-84e7-42dde27851f2","26dc1594-2833-11f1-84e7-42dde27851f2",["D",1774433558516],"/**\n * corpus/index.ts — Document-level corpus for microgpt\n *\n * Instead of a byte stream, provides string[] of documents.\n * Each document is a short line/sentence — matches the microgpt\n * training protocol of one-doc-per-gradient-step.\n *\n * TinyStories insight: simple sentences with constrained vocabulary\n * are what a tiny model can actually learn to compress.\n */\nimport { SIMPLE_STORIES } from \"./simple-stories.ts\";\nimport { REPETITIVE } from \"./repetitive.ts\";\n\n/** Split text into non-empty lines as documents */\nfunction lineDocs(text: string): string[] {\n  return text.split(\"\\n\").map(s => s.trim()).filter(s => s.length > 0);\n}\n\n/** Split on sentence boundaries (period-space) */\nfunction sentenceDocs(text: string): string[] {\n  return text.split(/\\.\\s+/).map(s => s.trim()).filter(s => s.length > 2).map(s => s.endsWith(\".\") ? s : s + \".\");\n}\n\nexport const STORY_DOCS = lineDocs(SIMPLE_STORIES);\nexport const REPEAT_DOCS = sentenceDocs(REPETITIVE);\n\n/** All default documents combined */\nexport function getDefaultDocs(): string[] {\n  return [...STORY_DOCS, ...REPEAT_DOCS];\n}\n\n/** Shuffle docs (Fisher-Yates) */\nexport function shuffleDocs(docs: string[]): string[] {\n  const a = [...docs];\n  for (let i = a.length - 1; i > 0; i--) {\n    const j = Math.floor(Math.random() * (i + 1));\n    [a[i], a[j]] = [a[j], a[i]];\n  }\n  return a;\n}\n",[],[186,368],"e0026ad8-27e2-11f1-b00f-42dde27851f2","english.ts","e0026ba0-27e2-11f1-b00f-42dde27851f2",28,["D",1774399079948],"/**\n * corpus/english.ts — English prose (proverbs, sayings)\n */\nexport const ENGLISH_TEXT = `The quick brown fox jumps over the lazy dog. A stitch in time saves nine. All that glitters is not gold. The pen is mightier than the sword. Actions speak louder than words. Fortune favours the bold. Every cloud has a silver lining. Birds of a feather flock together. When in Rome, do as the Romans do. A journey of a thousand miles begins with a single step. Still waters run deep. The early bird catches the worm. Too many cooks spoil the broth. Necessity is the mother of invention. Rome was not built in a day. Where there is a will there is a way. The grass is always greener on the other side. Honesty is the best policy in life and in love. Practice makes perfect and patience makes progress. Knowledge is power and power is responsibility. The best things in life are free. A friend in need is a friend indeed. Experience is the best teacher of all. Time and tide wait for no man.`;\n\nexport const ENGLISH_PHASE = {\n  name: \"English prose\",\n  color: \"#4ade80\",\n};\n",[],[186,436],"f86be018-27e2-11f1-88c6-42dde27851f2","code.ts","900d39b8-27e2-11f1-b433-42dde27851f2",30,["D",1774399120894],"/**\n * corpus/code.ts — JavaScript code samples\n */\nexport const JAVASCRIPT = `function fibonacci(n) {\n  if (n <= 1) return n;\n  let a = 0, b = 1;\n  for (let i = 2; i <= n; i++) {\n    let temp = a + b;\n    a = b; b = temp;\n  }\n  return b;\n}\nfunction isPrime(n) {\n  if (n < 2) return false;\n  for (let i = 2; i * i <= n; i++) {\n    if (n % i === 0) return false;\n  }\n  return true;\n}\nfunction mergeSort(arr) {\n  if (arr.length <= 1) return arr;\n  const mid = Math.floor(arr.length / 2);\n  return merge(mergeSort(arr.slice(0, mid)), mergeSort(arr.slice(mid)));\n}\nfunction merge(left, right) {\n  const result = []; let i = 0, j = 0;\n  while (i < left.length && j < right.length) {\n    if (left[i] <= right[j]) result.push(left[i++]);\n    else result.push(right[j++]);\n  }\n  return result.concat(left.slice(i)).concat(right.slice(j));\n}\nconsole.log(mergeSort([3, 1, 4, 1, 5, 9, 2, 6]));\n`;\n",[],[186,444],["D",1774395979606],[215,216,217,218,219,220,221],[186],"26dc0414-2833-11f1-84e7-42dde27851f2","value.ts","26dc04b4-2833-11f1-84e7-42dde27851f2",["D",1774433558516],"/**\n * core/value.ts — Scalar autograd engine\n *\n * Direct port of Karpathy's Value class. Each Value wraps a scalar,\n * tracks its children in the computation graph, and stores local\n * gradients. Call backward() on the loss and gradients propagate\n * through the entire graph via the chain rule.\n *\n * \"This is the complete algorithm. Everything else is just efficiency.\"\n */\n\nexport class Value {\n  data: number;\n  grad: number;\n  _children: Value[];\n  _local_grads: number[];\n\n  constructor(data: number, children: Value[] = [], local_grads: number[] = []) {\n    this.data = data;\n    this.grad = 0;\n    this._children = children;\n    this._local_grads = local_grads;\n  }\n\n  add(other: Value | number): Value {\n    const o = other instanceof Value ? other : new Value(other);\n    return new Value(this.data + o.data, [this, o], [1, 1]);\n  }\n\n  mul(other: Value | number): Value {\n    const o = other instanceof Value ? other : new Value(other);\n    return new Value(this.data * o.data, [this, o], [o.data, this.data]);\n  }\n\n  pow(n: number): Value {\n    return new Value(this.data ** n, [this], [n * this.data ** (n - 1)]);\n  }\n\n  log(): Value {\n    return new Value(Math.log(this.data), [this], [1 / this.data]);\n  }\n\n  exp(): Value {\n    const e = Math.exp(this.data);\n    return new Value(e, [this], [e]);\n  }\n\n  relu(): Value {\n    return new Value(Math.max(0, this.data), [this], [this.data > 0 ? 1 : 0]);\n  }\n\n  neg(): Value { return this.mul(-1); }\n  sub(other: Value | number): Value { const o = other instanceof Value ? other : new Value(other); return this.add(o.neg()); }\n  div(other: Value | number): Value { const o = other instanceof Value ? other : new Value(other); return this.mul(o.pow(-1)); }\n\n  backward(): void {\n    // Topological sort\n    const topo: Value[] = [];\n    const visited = new Set<Value>();\n    const build = (v: Value) => {\n      if (visited.has(v)) return;\n      visited.add(v);\n      for (const child of v._children) build(child);\n      topo.push(v);\n    };\n    build(this);\n    // Backprop\n    this.grad = 1;\n    for (let i = topo.length - 1; i >= 0; i--) {\n      const v = topo[i];\n      for (let j = 0; j < v._children.length; j++) {\n        v._children[j].grad += v._local_grads[j] * v.grad;\n      }\n    }\n  }\n}\n\n/** Create a Value-wrapped random gaussian */\nexport function vrand(std = 0.08): Value {\n  // Box-Muller\n  let u = 0, v = 0;\n  while (!u) u = Math.random();\n  while (!v) v = Math.random();\n  return new Value(Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v) * std);\n}\n\n/** Create a matrix of Values */\nexport function matrix(nout: number, nin: number, std = 0.08): Value[][] {\n  return Array.from({ length: nout }, () =>\n    Array.from({ length: nin }, () => vrand(std))\n  );\n}\n",[],[192,455],"26dbe8bc-2833-11f1-84e7-42dde27851f2","train.ts","26dbe934-2833-11f1-84e7-42dde27851f2",["D",1774433558516],"/**\n * core/train.ts — Document-level training step\n *\n * Faithful to microgpt.py: forward an entire document through gpt(),\n * accumulate per-position losses, backward once, Adam step once.\n * One document = one gradient step.\n *\n * The online variant: if online=true during inference, each observed\n * token triggers the same forward→loss→backward→step cycle, but\n * the \"document\" is whatever context has accumulated so far.\n */\nimport { Value } from \"./value.ts\";\nimport { gpt, softmax, type StateDict, type ModelConfig } from \"./model.ts\";\nimport { adamStep, type AdamState } from \"./optim.ts\";\nimport type { Tokenizer } from \"./tokenizer.ts\";\n\nexport interface StepResult {\n  loss: number;          // average loss over document (nats)\n  lossBits: number;      // same in bits\n  perPosition: number[]; // per-position loss (bits) for visualization\n  docLength: number;\n}\n\n/**\n * Train on a single document.\n * tokens = [BOS, ...char_ids, BOS]\n */\nexport function trainStep(\n  tokens: number[],\n  sd: StateDict,\n  cfg: ModelConfig,\n  params: Value[],\n  adam: AdamState,\n  lr: number,\n): StepResult {\n  const n = Math.min(cfg.block_size, tokens.length - 1);\n  const keys: Value[][][] = Array.from({ length: cfg.n_layer }, () => []);\n  const values: Value[][][] = Array.from({ length: cfg.n_layer }, () => []);\n\n  const losses: Value[] = [];\n  const perPosition: number[] = [];\n\n  for (let pos = 0; pos < n; pos++) {\n    const token_id = tokens[pos];\n    const target_id = tokens[pos + 1];\n    const logits = gpt(token_id, pos, keys, values, sd, cfg);\n    const probs = softmax(logits);\n    const loss_t = probs[target_id].log().neg();\n    losses.push(loss_t);\n    perPosition.push(loss_t.data / Math.LN2);\n  }\n\n  // Average loss\n  let loss = new Value(0);\n  for (const l of losses) loss = loss.add(l);\n  loss = loss.div(n);\n\n  // Backward\n  loss.backward();\n\n  // Adam step\n  adamStep(params, adam, lr);\n\n  return {\n    loss: loss.data,\n    lossBits: loss.data / Math.LN2,\n    perPosition,\n    docLength: n,\n  };\n}\n\n/**\n * Online observe: forward the current context, compute loss on\n * the observed next token, backward, step. This is a single-token\n * \"document\" — the online learning version of trainStep.\n */\nexport function onlineObserve(\n  context: number[],  // current token ids in window\n  target_id: number,   // the observed next token\n  sd: StateDict,\n  cfg: ModelConfig,\n  params: Value[],\n  adam: AdamState,\n  lr: number,\n): { loss: number; lossBits: number; probs: number[] } {\n  const keys: Value[][][] = Array.from({ length: cfg.n_layer }, () => []);\n  const values: Value[][][] = Array.from({ length: cfg.n_layer }, () => []);\n\n  // Forward through context\n  let logits: Value[] = [];\n  const window = context.slice(-(cfg.block_size));\n  for (let pos = 0; pos < window.length; pos++) {\n    logits = gpt(window[pos], pos, keys, values, sd, cfg);\n  }\n\n  const probs = softmax(logits);\n  const probData = probs.map(p => p.data);\n  const loss = probs[target_id].log().neg();\n\n  // Backward + step\n  loss.backward();\n  adamStep(params, adam, lr);\n\n  return {\n    loss: loss.data,\n    lossBits: loss.data / Math.LN2,\n    probs: probData,\n  };\n}\n\n/**\n * Inference: forward through context, return probs for next token.\n * No backward, no weight update. Pure prediction.\n */\nexport function infer(\n  context: number[],\n  sd: StateDict,\n  cfg: ModelConfig,\n): { probs: number[]; keys: Value[][][]; values: Value[][][] } {\n  const keys: Value[][][] = Array.from({ length: cfg.n_layer }, () => []);\n  const values: Value[][][] = Array.from({ length: cfg.n_layer }, () => []);\n\n  let logits: Value[] = [];\n  const window = context.slice(-(cfg.block_size));\n  for (let pos = 0; pos < window.length; pos++) {\n    logits = gpt(window[pos], pos, keys, values, sd, cfg);\n  }\n\n  const probs = softmax(logits);\n  return { probs: probs.map(p => p.data), keys, values };\n}\n",[],[192,462],"26dbe1dc-2833-11f1-84e7-42dde27851f2","tokenizer.ts","26dbe254-2833-11f1-84e7-42dde27851f2",["D",1774433558516],"/**\n * core/tokenizer.ts — Character-level tokenizer\n *\n * Scans the corpus to build a sorted unique character set.\n * BOS = len(chars), vocab_size = len(chars) + 1.\n */\n\nexport interface Tokenizer {\n  chars: string[];      // sorted unique characters\n  BOS: number;          // beginning-of-sequence token id\n  vocab_size: number;   // total tokens (chars + BOS)\n  encode: (s: string) => number[];\n  decode: (ids: number[]) => string;\n  charOf: (id: number) => string;\n}\n\nexport function buildTokenizer(docs: string[]): Tokenizer {\n  const chars = [...new Set(docs.join(\"\"))].sort();\n  const BOS = chars.length;\n  const vocab_size = chars.length + 1;\n\n  const charToId = new Map<string, number>();\n  chars.forEach((c, i) => charToId.set(c, i));\n\n  return {\n    chars,\n    BOS,\n    vocab_size,\n    encode: (s: string) => [...s].map(c => charToId.get(c) ?? BOS),\n    decode: (ids: number[]) => ids.filter(id => id !== BOS).map(id => chars[id] ?? \"\").join(\"\"),\n    charOf: (id: number) => id === BOS ? \"\\u27E8BOS\\u27E9\" : (chars[id] ?? \"?\"),\n  };\n}\n",[],[192,469],"26dbda8e-2833-11f1-84e7-42dde27851f2","26dbdb24-2833-11f1-84e7-42dde27851f2",["D",1774433558516],"/**\n * core/optim.ts — Adam optimizer\n *\n * \"Let there be Adam, the blessed optimizer and its buffers\"\n */\nimport { Value } from \"./value.ts\";\n\nexport interface AdamState {\n  m: number[];  // first moment\n  v: number[];  // second moment\n  step: number; // for bias correction\n}\n\nexport function createAdam(numParams: number): AdamState {\n  return { m: new Array(numParams).fill(0), v: new Array(numParams).fill(0), step: 0 };\n}\n\nexport function adamStep(\n  params: Value[],\n  adam: AdamState,\n  lr: number,\n  beta1 = 0.85,\n  beta2 = 0.99,\n  eps = 1e-8,\n): void {\n  adam.step++;\n  for (let i = 0; i < params.length; i++) {\n    const g = params[i].grad;\n    adam.m[i] = beta1 * adam.m[i] + (1 - beta1) * g;\n    adam.v[i] = beta2 * adam.v[i] + (1 - beta2) * g * g;\n    const m_hat = adam.m[i] / (1 - beta1 ** adam.step);\n    const v_hat = adam.v[i] / (1 - beta2 ** adam.step);\n    params[i].data -= lr * m_hat / (Math.sqrt(v_hat) + eps);\n    params[i].grad = 0;\n  }\n}\n",[],[192,325],"26dbbd1a-2833-11f1-84e7-42dde27851f2","model.ts","26dbbd9c-2833-11f1-84e7-42dde27851f2",["D",1774433558516],"/**\n * core/model.ts — GPT model definition\n *\n * Faithful to Karpathy's microgpt: flat state_dict of Value matrices,\n * and the gpt() function that maps (token, position, kv_cache) to logits.\n *\n * \"Follow GPT-2, blessed among the GPTs, with minor differences:\n *  layernorm -> rmsnorm, no biases, GeLU -> ReLU\"\n */\nimport { Value, matrix } from \"./value.ts\";\nimport { linear, softmax, rmsnorm } from \"./math.ts\";\n\nexport interface ModelConfig {\n  n_layer: number;\n  n_embd: number;\n  block_size: number;\n  n_head: number;\n  vocab_size: number;\n}\n\nexport const DEFAULT_CONFIG: ModelConfig = {\n  n_layer: 1,\n  n_embd: 16,\n  block_size: 16,\n  n_head: 4,\n  vocab_size: 0, // set from data\n};\n\nexport interface StateDict {\n  [key: string]: Value[][];\n}\n\nexport function createStateDict(cfg: ModelConfig): { state_dict: StateDict; params: Value[] } {\n  const sd: StateDict = {\n    wte: matrix(cfg.vocab_size, cfg.n_embd),\n    wpe: matrix(cfg.block_size, cfg.n_embd),\n    lm_head: matrix(cfg.vocab_size, cfg.n_embd),\n  };\n  for (let i = 0; i < cfg.n_layer; i++) {\n    sd[`layer${i}.attn_wq`] = matrix(cfg.n_embd, cfg.n_embd);\n    sd[`layer${i}.attn_wk`] = matrix(cfg.n_embd, cfg.n_embd);\n    sd[`layer${i}.attn_wv`] = matrix(cfg.n_embd, cfg.n_embd);\n    sd[`layer${i}.attn_wo`] = matrix(cfg.n_embd, cfg.n_embd);\n    sd[`layer${i}.mlp_fc1`] = matrix(4 * cfg.n_embd, cfg.n_embd);\n    sd[`layer${i}.mlp_fc2`] = matrix(cfg.n_embd, 4 * cfg.n_embd);\n  }\n  // Flatten params\n  const params: Value[] = [];\n  for (const mat of Object.values(sd)) {\n    for (const row of mat) for (const p of row) params.push(p);\n  }\n  return { state_dict: sd, params };\n}\n\n/**\n * The GPT forward pass — one token at a time, building up KV cache.\n * Returns logits over vocab for the next token.\n */\nexport function gpt(\n  token_id: number,\n  pos_id: number,\n  keys: Value[][][],   // [layer][time][embd]\n  values: Value[][][],  // [layer][time][embd]\n  sd: StateDict,\n  cfg: ModelConfig,\n): Value[] {\n  const head_dim = cfg.n_embd / cfg.n_head;\n\n  // Embedding\n  const tok_emb = sd.wte[token_id];\n  const pos_emb = sd.wpe[pos_id];\n  let x = tok_emb.map((t, i) => t.add(pos_emb[i]));\n  x = rmsnorm(x); // initial rmsnorm (not redundant due to residual)\n\n  for (let li = 0; li < cfg.n_layer; li++) {\n    // 1) Multi-head Attention\n    const x_residual = x;\n    x = rmsnorm(x);\n    const q = linear(x, sd[`layer${li}.attn_wq`]);\n    const k = linear(x, sd[`layer${li}.attn_wk`]);\n    const v = linear(x, sd[`layer${li}.attn_wv`]);\n    keys[li].push(k);\n    values[li].push(v);\n\n    const x_attn: Value[] = [];\n    for (let h = 0; h < cfg.n_head; h++) {\n      const hs = h * head_dim;\n      const q_h = q.slice(hs, hs + head_dim);\n      const k_h = keys[li].map(ki => ki.slice(hs, hs + head_dim));\n      const v_h = values[li].map(vi => vi.slice(hs, hs + head_dim));\n\n      // Attention scores\n      const attn_logits = k_h.map(k_t =>\n        q_h.reduce((s, qj, j) => s.add(qj.mul(k_t[j])), new Value(0))\n          .div(Math.sqrt(head_dim))\n      );\n      const attn_weights = softmax(attn_logits);\n\n      // Weighted sum of values\n      for (let j = 0; j < head_dim; j++) {\n        let out = new Value(0);\n        for (let t = 0; t < v_h.length; t++) {\n          out = out.add(attn_weights[t].mul(v_h[t][j]));\n        }\n        x_attn.push(out);\n      }\n    }\n\n    x = linear(x_attn, sd[`layer${li}.attn_wo`]);\n    x = x.map((a, i) => a.add(x_residual[i])); // residual\n\n    // 2) MLP\n    const x_res2 = x;\n    x = rmsnorm(x);\n    x = linear(x, sd[`layer${li}.mlp_fc1`]);\n    x = x.map(xi => xi.relu());\n    x = linear(x, sd[`layer${li}.mlp_fc2`]);\n    x = x.map((a, i) => a.add(x_res2[i])); // residual\n  }\n\n  return linear(x, sd.lm_head);\n}\n\nexport { softmax };\n",[],[192,482],"26dbb612-2833-11f1-84e7-42dde27851f2","math.ts","26dbb6a8-2833-11f1-84e7-42dde27851f2",["D",1774433558516],"/**\n * core/math.ts — Linear algebra on Value arrays\n *\n * These are the exact operations from microgpt.py:\n * linear, softmax, rmsnorm. No surprises.\n */\nimport { Value } from \"./value.ts\";\n\nexport function linear(x: Value[], w: Value[][]): Value[] {\n  return w.map(wo =>\n    wo.reduce((sum, wi, i) => sum.add(wi.mul(x[i])), new Value(0))\n  );\n}\n\nexport function softmax(logits: Value[]): Value[] {\n  const maxVal = Math.max(...logits.map(v => v.data));\n  const exps = logits.map(v => v.sub(maxVal).exp());\n  const total = exps.reduce((s, e) => s.add(e), new Value(0));\n  return exps.map(e => e.div(total));\n}\n\nexport function rmsnorm(x: Value[]): Value[] {\n  const ms = x.reduce((s, xi) => s.add(xi.mul(xi)), new Value(0)).div(x.length);\n  const scale = ms.add(1e-5).pow(-0.5);\n  return x.map(xi => xi.mul(scale));\n}\n",[],[192,489],"26db92b8-2833-11f1-84e7-42dde27851f2","26db9394-2833-11f1-84e7-42dde27851f2",["D",1774433558516],"/**\n * core/index.ts — Barrel export for the microgpt core\n */\nexport { Value, vrand, matrix } from \"./value.ts\";\nexport { linear, softmax, rmsnorm } from \"./math.ts\";\nexport { gpt, createStateDict, DEFAULT_CONFIG, type ModelConfig, type StateDict } from \"./model.ts\";\nexport { createAdam, adamStep, type AdamState } from \"./optim.ts\";\nexport { buildTokenizer, type Tokenizer } from \"./tokenizer.ts\";\nexport { trainStep, onlineObserve, infer, type StepResult } from \"./train.ts\";\n",[],[192,368],["D",1774433558516],[207,208,209,210,211,212,213],[192],["D",1774395967725],{"_96":95,"_103":99},{"_96":95,"_97":-5,"_98":99,"_18":56,"_100":101,"_102":25},{"_13":85,"_32":86,"_44":43,"_87":45,"_88":-5,"_89":-5,"_90":-5,"_91":-5,"_92":-5,"_93":46,"_94":95},"ctx",{"_78":-5,"_124":541,"_542":543,"_544":545,"_546":25,"_547":25,"_548":25,"_549":122,"_550":-5,"_551":-7,"_552":-7,"_553":62,"_554":25,"_555":25,"_556":-5,"_557":25,"_558":25,"_559":25,"_560":-5},"ENV",{"_512":513,"_514":515,"_516":86,"_517":518,"_519":520,"_521":522,"_523":524,"_525":526,"_527":528,"_529":530,"_531":532,"_533":534,"_535":536,"_537":538,"_539":540},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","c73f21da490985bff19c279eb0e09db24d688e4f","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"]
</article></body></html>

Diff · v49