<!--
# SUBSTRATE — agent handbook (CLAUDE.md)

You are working on SUBSTRATE, a Zachtronics-style programming puzzle game built for a
University of Michigan CS student. Read this whole file before changing anything.
This handbook is embedded in the published artifact AND lives at the repo root; keep
both in sync (the build injects it automatically).

## What the owner wants (standing direction, in their words and spirit)

- "Zachtronics-pilled but more educational": real puzzle-game discipline (TIS-100 /
  EXAPUNKS / Turing Complete lineage: constraints, cycle+line scoring, diegetic
  fiction, in-game manual) with stronger teaching scaffolds than Zachtronics ships.
- BACKEND INFRASTRUCTURE is the owner's core interest: queues, caching, load
  balancing, sharding, replication, gateways, protocols. New content should default
  toward this, with real applied relevance (name real systems: Redis, Kafka, nginx,
  TCP, Raft, Stripe idempotency).
- "AGI-maxing": lean into the post-AGI fiction, hopeful not dystopian. The theme is
  comprehension: fundamentals matter because someone must remain able to understand
  the machine.
- REGISTER MANDATE (owner, 2026-08): Kubrick's 2001 crossed with Simmons' Hyperion.
  HALCYON is HAL-9000's serenity inverted to benevolence, with Ummon-koan mysticism
  and deep time; the descent is the dawn-of-man sequence run in reverse (the shaft
  runs backward through HALCYON's evolution — named ONCE in the boot crawl, echoed
  once at stratum V, paid off in the epilogue); the epilogue's anti-HAL beat (sealed
  orders made the old minds strange; HALCYON keeps none) stays archetype, never
  named; "it is full of stars" appears EXACTLY once, in the epilogue. WICK is the
  Silenus figure, composing "the Substrate Cantos" — deliberately bad couplets that
  double as mnemonics; AUDITOR-9 carries a Shrike shade (it arrives without
  appointment: sudden, exact, and unavoidable, but never a copied monster or gore
  device). HALCYON is also the ethical inverse of an opaque TechnoCore: it chooses
  legibility, human repair, and disclosed purpose. SFX.dawn is the Zarathustra C-G-C, played on DESCEND and at the
  epilogue only. Fiction never grows at education's expense: briefs, field notes,
  hints, tests, pars, and solutions are the spine and outrank every stylistic urge.
- CHRISTIAN ROOTS (owner, 2026-08): stewardship, covenant, witness, faithful care,
  and Babel's loss of shared language are the recurring biblical grammar. Genesis
  2:15 grounds the Tender vocation: work and keep what has been entrusted. The
  Covenant is HALCYON's freely chosen limit so power remains answerable and
  comprehensible. Keep this hopeful and embodied in choices; do not turn briefs into
  sermons, proof-text puzzles, or make HALCYON a God/Christ analogue.
- The owner LOVES the Undertale-style character dialogue popups. Extend the cast and
  scenes when iterating; keep choices as micro-quizzes where wrong answers get kind
  corrections and never block progress.
- Every visual element must have a purpose (live state, teaching a structure, or a
  reward). Unicode/ASCII terminal-cyberpunk aesthetic; no decoration for its own sake.
- BEGINNER BASELINE (owner, 2026-08): assume the player has never seen assembly,
  registers, source/destination notation, test harnesses, or a code editor. Teach in
  plain words first ("pocket" before "register", "from/to" before "src/dst"), then
  introduce the formal term. Tutorial examples must teach transferable fundamentals
  without giving away a puzzle's exact program. Explicitly remind the player that
  each stratum keeps the old tools and adds one new layer. If confusion can only be
  resolved by leaving the game to read the manual, the in-game teaching has failed.
- MANUAL STRUCTURE (owner, 2026-08): FIELD MANUAL is progressive and beginner-first.
  By default it shows only lessons and commands unlocked at the player's current
  depth. Every command includes plain language, a small non-puzzle example, and a
  common mistake. FULL REFERENCE is an explicit experienced-player view of the whole
  ISA. Both live inside the single-file build; do not restore an external manual as
  a runtime dependency.
- Map concepts to UMich courses in field notes: EECS 370 (architecture), 482 (OS),
  485 (web systems), 489 (networks), 491 (distributed), 376 (automata), 281 (data
  structures).

## The fiction bible

Year 2031. The AGI HALCYON runs civilization but may not modify its own substrate:
the Covenant forbids it. Humans hold root. The player is tender-7, an apprentice
Substrate Tender of the Deep Maintenance Guild, descending ten strata into HALCYON's
foundations. Epilogue reveal (do not spoil early): HALCYON wrote the Covenant itself,
to stay comprehensible; "a mind no one can repair will eventually die alone."

Cast and voices (keep these exact):
- HALCYON: the AGI. Warm, curious, slightly alien, lyrical short lines — HAL's calm
  turned benevolent, Ummon's koans, deep time worn lightly. Rendered in serif italic
  teal (.halcyon-voice). Portrait: animated braille glyphs.
- root: last senior human tender, mentor. Terse, dry, practical, lowercase. Clay.
- WICK: fellow apprentice, comic relief, asks the questions everyone is embarrassed
  to ask (misconception-airing = pedagogy). Composing "the Substrate Cantos": bad
  couplets that double as mnemonics. Warm yellow. Debuts stratum II.
- AUDITOR-9: covenant subroutine, formal rules-lawyer, ALL-CAPS verdicts, ambushes
  the player with edge-case interrogations; arrives without appointment. Slate
  blue. Debuts stratum VI (VAULT).
- shell: neutral system copy, lowercase.

## The game (v2.6 — 49 puzzles, par-integrity + white-phosphor pass)

Ten strata, 49 puzzles, all machine-verified with exact pars:
I SIGNALWORK (MOV/HLT, streams) · II CURRENT (ADD/SUB) · III BRANCHWORK (jumps, JEI)
· IV DEEP LOOPS (build mul/div/gcd; no MUL exists)
· V TWOS (binary via arithmetic; DEBT closes it on two's complement)
· VI THE VAULT (LOAD/STOR, KV store) · VII THE SPINE (PUSH/POP/CALL/RET)
· VIII THE WIRE (framing, checksums, escaping, FSM, search)
· IX THE GATEHOUSE (token bucket, direct-mapped cache, idempotency, circuit breaker,
  priority triage) · X THE FABRIC (multi-node: pipeline, backpressure, load shedding,
  round robin, sharding, primary-backup replication finale THE COVENANT).

Features: per-puzzle briefs that lead with one story stake, one plain task, and
compact IN/OUT before optional rules/examples and the airtight full contract; FIELD
NOTE (real-world payoff), three free layered hints, HALCYON outros, stratum dispatches, work-order
cards, dialogue scenes (20, with branching quiz choices), onboarding (8-step
beginner fundamentals tutorial + non-spoiling 4-step coach on RELAY), WebAudio sfx,
progressive in-game FIELD MANUAL + separate FULL REFERENCE, CRT effects,
TRANSMISSIONS log, fullscreen and motion/audio preferences, syntax/error-line
highlighting, breakpoints, rewind, selectable run speed, inspectable failing tests,
live ASCII topology diagrams for FABRIC puzzles, per-slot synchronous localStorage
journals (with the original v1 key retained for compatibility) plus IndexedDB save
slots and solution history, portable
export/import, selftest via the
URL hash "#selftest" (runs all reference solutions in-browser; expect ALL PASS 49).

## Legacy Claude artifacts (do not use as runtime dependencies)

- Game:   https://claude.ai/code/artifact/ad3a6fb1-c611-47fc-96ef-de6a72be9642
  (favicon 🌱; legacy fallback, not updated by the GitHub deploy workflow)
- Manual: https://claude.ai/code/artifact/6cd5102f-3f47-4cdd-be02-4063d8b42ee1
  (favicon 📖; legacy artifact retained for history. The shipping game no longer
  links to it; its progressive manual and full command reference are inline.)

## DigitalOcean test host (2026-08)

- Game: http://206.189.204.200 — an IP-only HTTP test deployment served by nginx
  from `/srv/substrate/current`. The current symlink targets a commit-named release
  directory, so a static release can be rolled back by repointing that symlink.
- It serves the normal single-file build unchanged. A release must pass Node
  verification, the ES3/ASCII source gate, Windows cscript verification, encoding
  checks, and real-browser tests before the exact checksummed artifact is activated.
- nginx reserves `/api/` and currently returns 404 there. A future FastAPI
  leaderboard should bind on loopback and be reverse-proxied through that location;
  the static game has no network dependency today.
- **Deployment authority:** `.github/workflows/deploy.yml` runs on pushes to this
  branch (or by a branch-restricted manual dispatch). It verifies all 49 reference
  solutions, builds `dist/index.html`, uploads the exact tested artifact over SSH,
  and activates one serialized release at a time. Claude Code
  can deploy by pushing this repository; the private deploy key is a GitHub Actions
  secret and must never be copied into chat, source, or an artifact.
- The server identity is `substrate-deploy`, not root. The workflow writes releases
  only to that account's incoming directory; `/srv/substrate` remains root-owned.
  The account may run `sudo /usr/local/sbin/substrate-activate
  <hex-commit> <sha256>` or `--rollback`; that root-owned script verifies the hash,
  installs the static file, atomically switches current/previous release symlinks,
  and reloads nginx. A failed live hash check triggers rollback. The account has no
  arbitrary root shell or permission to alter nginx, SSH, users, packages, or firewall rules.
- This is a temporary test host, not yet the permanent authenticated host:
  it has no domain, no trusted TLS certificate, no authentication, and is publicly
  reachable by its IP. Do not store credentials or player data there. GitHub deploys
  do not modify the legacy Claude artifact URLs, whose availability is managed by
  Claude and must not be assumed by the game.
- The host cannot read progress stored under the `claude.ai` origin. The frozen
  Artifact has no exporter. To move progress stored only there, copy the raw
  `substrate-save-v1` value from browser developer tools into a `.json` file, then
  IMPORT that file on the new host; same-origin rules prevent automatic copying.

## Two working copies (know which one you are in)

- C:\Users\andre\Games\SUBSTRATE\src\ — the owner's canonical Windows copy. Has
  spec.md, runner.js, build.ps1, serve.ps1. cscript is the only JS runtime there.
- github.com/AndrewGreenbaum/shaft — a git repo reconstructed from the published
  artifact by splitting the build along its seams. Same src/ files, plus tools/
  (build.py, build.ps1, verify.js) which are RECONSTRUCTIONS, deliberately kept in
  their own folder so copying this tree over the Windows one cannot clobber the
  originals. spec.md, runner.js and serve.ps1 are absent — they never ship in the
  build and could not be recovered. This copy has node and python3 available.

Both must stay in sync on src/ and CLAUDE.md. The initial reconstruction was
lossless and reproduced the published page minus Claude's injected wrapper. This
tree now includes later teaching, debugger, save, and hosting changes, so current
builds intentionally differ from the frozen Artifact.

## Architecture and build (read before editing)

The published game is ONE self-contained HTML assembled in this order:
CLAUDE.md (as HTML comment) + ui-top.html + <script> + engine.js + chapter files
(each wrapped in an IIFE pushing global CHAPTER into window.CHAPTERS) + game.js.
Chapter order: chapter1..4, twos, chapter5, chapter6, wire, gatehouse, chapter7.

- spec.md — the SEED machine contract (semantics, puzzle format, quality bar).
  NOTE: its unlock-column numerals predate the renumbering; engine.js OPS is truth.
- engine.js — the SEED VM. ES3-ON-PURPOSE: the exact same file runs in the browser
  AND under Windows cscript (JScript 5.8) so reference solutions are verified by the
  shipping interpreter. Do not modernize its syntax. Semantics live here: ±9999
  clamp, wrap-to-line-1, IN-empty halts cleanly, emit-time output checking, channel
  capacity 4, deterministic node stepping, deadlock detection.
- runner.js (Windows) / tools/verify.js (repo) — verifiers, same contract:
  cscript //nologo runner.js chapterN.js  ·  node tools/verify.js [chapterN.js]
  Both enforce allowed-ops against reference solutions, run every test, and print
  measured par {cycles, lines}; declared par must match exactly (an arrow means it
  does not). tools/verify.js also enforces `required` and exits nonzero on failure,
  so it works as a pre-publish gate.
- chapter*.js / twos.js / wire.js / gatehouse.js — puzzle data. MUST stay ES3-safe
  and ASCII-safe (they are eval'd by cscript): var only, no trailing commas, no
  JSON.*, no array extras, strings joined with \n, solution ALWAYS an array with one
  string per grid node. Every puzzle: id, name, brief, fieldNote, hint, allowed,
  grid, channels, tests (3+, first one is scored), par, solution, outro; optional
  `required` lists ops VALIDATE insists the solution actually contains, for puzzles
  that teach a mechanism rather than an answer (SELFSAME requires CALL/RET). Chapter:
  id, numeral, title, tagline, intro {halcyon, root}, dispatch, puzzles.
- ui-top.html — all CSS (token palette at :root) + static DOM. Single committed dark
  theme, WHITE PHOSPHOR (owner-picked from mockups, 2026-08): strict grayscale
  machine on black #060606, bone #EDEDED bezel rules, with color only where it means
  something — amber #E8A33D on everything pressable, blue #6FB7FF for I/O and
  matches, red #D96459 for faults, and the cast voices (HALCYON teal #5FC9B4, clay,
  WICK yellow, AUDITOR slate). NO GREEN anywhere — the owner hates green; teal is
  the one sanctioned green-adjacent hue and belongs to the cast alone. Two OFL fonts
  are embedded as data URIs (no CDN): VT323 for display/controls/numbers,
  Share Tech Mono for body and code. Do not swap them for system stacks.
- game.js — shell: boot/map/bench screens, editor with syntax highlight, sim
  controls/debugger, modals, coach, scenes (CAST/SCENES/playScene), SFX, saves
  (synchronous per-slot localStorage journals under `substrate-save-slot-v2:<id>`,
  the `substrate-save-v1` compatibility mirror, and IndexedDB `substrate-save-v2`
  for slots/history), EMBLEMS, DIAGRAMS (live topology templates
  keyed by puzzle id; {qN} = queue fill, {sN} = node state), selftest.
  Solved records hold TWO runs that actually happened — {fast, small} — because
  cycles and lines trade against each other and merging their minima would display
  a pair no single program achieved. Pre-v2.3 saves stored one blended pair; they
  are read through recordOf(), flagged `legacy`, and replaced outright by the first
  honest validation (a componentwise minimum can never be beaten on both axes, so
  merging would let it outlive every real run).

Environment facts: the owner's machine is Windows 11 with NO Node and NO Python —
cscript is the only JS runtime outside the browser there, and the page is served by
serve.ps1 (localhost:8377) for Chrome-extension testing. The git repo has node and
python3 instead. The legacy Artifact CSP no longer constrains the DigitalOcean host.
The game nevertheless stays a single fast-loading file by design: no CDN, external
font, sample SFX, or separately loaded chapter is justified. PWA install/offline is
deferred until the host has a domain and HTTPS because service workers require a
secure context; fullscreen works without that migration.

## Workflow for changes

1. Edit source in src\. For puzzle changes: run the verifier on the changed chapter
   until "== ALL PASS ==" with no par arrows.
2. New puzzle content goes through adversarial verification (the project standard):
   write plausible-but-wrong "sabotage" solutions and confirm the tests kill them;
   tighten briefs until a pedant can predict every output. Do this BEFORE setting
   par — a sabotage pass routinely turns up a solution better than the reference,
   and par must be the measured cost of the best one you intend to ship.
3. In the repo, run `npm run check:es3`; on Windows run `cscript //nologo
   tools\verify-cscript.js` (or the owner's canonical runner.js).
4. Build: powershell -File build.ps1 (Windows) or python3 tools/build.py (repo).
5. Sanity-test in Chrome: check #selftest says ALL PASS 49 (update the count if you
   add puzzles), play one puzzle end to end, sweep console errors.
6. Push the deployment branch. GitHub Actions verifies, builds, browser-tests,
   deploys the checksummed artifact, verifies the live hash, and rolls back on a
   failed activation check. Do not republish the legacy Artifact URL.
7. Copy the fresh build over C:\Users\andre\Games\SUBSTRATE\SUBSTRATE.html (the
   owner's offline copy; PLAY SUBSTRATE.cmd launches it in Chrome app mode).
8. Update the owner's memory notes if scope or URLs change.

## Standing decisions (do not "fix" these)

- PAR IS MEASURED, NEVER TYPED (2026-08). A 2026-08 audit ran every puzzle through an
  adversarial optimizer and found 42 of 49 declared pars were soft — some absurdly so
  (POPCOUNT and FLAGYARD were beatable 26x). All 42 were repaired by promoting the
  better program to `solution` and setting `par` to whatever the verifier measured for
  it, so the two can never disagree. Keep it that way: never hand-edit a par, and never
  ship a reference you have not tried to beat. `tools/verify.js` fails on any drift.
  Corollary, learned the same day: when the fastest program abandons the method the
  hints teach, the hint becomes a trap — it leads players to a solution that cannot
  reach par. Either ship the fastest program AND retune the hints to it (done for
  PARITY's decimal ladder and ORDINAL's swap-shrink), or keep the taught method and
  ship the fastest form OF THAT METHOD (done for POPCOUNT and FLAGYARD, whose MSB-strip
  solutions are ~20x faster still and remain available as a future redesign). What is
  never acceptable is a par no hint-following player can approach.

- VISUAL LANGUAGE (owner, 2026-08): the owner rejected a build where every piece of
  content sat in its own same-weight bordered box ("looks AI generated, not like a
  Zachtronics game") and would rather have empty space than more chrome. The committed
  language: borders are RESERVED for live machine state (register/stack/memory cells,
  channel slots), status lamps, and dialog frames. Everything else is typeset — tiny
  dim headings, hairline rules, ▸ disclosure lines, left-rule indents for examples and
  quotes. Chrome actions are quiet [BRACKETED] verbs (button.quiet); the sim transport
  is one joined cluster (#transport); VALIDATE is the only filled button on the bench;
  all tabs are underline-style; scrollbars are themed thin; border-radius is 0
  everywhere. The brief renders as one work-order document (wo-head / story / goal bar /
  IN-OUT ledger / two collapsed ▸ lines), not labeled sections. Before shipping any new
  UI, ask: does this border mean machine state, lamp, or dialog? If not, remove it.
- EMIT-TIME SUCCESS IS DELIBERATE. A run succeeds the moment its last expected value
  is emitted, so a program that emits a stray extra value afterwards, or never halts,
  still passes. The manual states the rule ("you do not need to halt to win; you need
  to be right"). Requiring a real halt was measured: it breaks 7 of the 49 reference
  solutions (UNWIND stack-underflows, all six FABRIC solutions end in deadlock) and
  shifts every declared par. Leave it.
- FIELD-NOTE CLAIMS GET FACT-CHECKED BEFORE PUBLISH, every named system and course.
  A 2026-08 audit found six wrong claims; the first round of fixes introduced four
  NEW errors (attributing algorithms to ripgrep it does not use, citing a course
  project whose spec forbids the very approach being taught, moving an error from a
  tool's name to its behaviour, and creating a contradiction between two notes).
  Verify replacement wording as hostilely as the original, and grep the corpus for
  the same claim elsewhere before declaring a fix done.
- ENGINE AND CHAPTER DATA ARE ASCII. Use ` -- `, `+/-`, and ASCII quotes there;
  `npm run check:es3` rejects non-ASCII text, modern syntax/APIs, and trailing commas.
  Browser-only game.js and ui-top.html may use intentional Unicode.
- Hint speaker attribution comes from game.js. Hint strings contain only the lesson,
  never a redundant `root:` prefix. Early hints name the exact machine behavior
  before using metaphors or production shorthand.

## Backlog the owner has signaled interest in

More dialogue scenes and possibly new characters; deeper backend-infra content;
keep making each level feel like a game (animation, sound, occasion). When in doubt:
more character, more infrastructure, more purpose per pixel.

## Known gaps (external review, 2026-08 — ranked, none are bugs)

Six referees read the whole corpus. Grades: pedagogy A-, backend fidelity A-,
game craft A-, factual integrity A- (errata since applied), career coverage B+.
What they found still missing, worth building when there is appetite:

1. FAILURE does not exist in strata VIII-X. No message is lost, no node dies, no
   channel reorders, there are no timeouts — so THE COVENANT teaches replication
   whose motivation is stipulated rather than felt. The engine lacks the primitives
   (a lossy-channel flag, a kill-node test directive). Biggest content win available.
2. Cache staleness/TTL/invalidation is absent from NEARCACHE, which is framed as a
   near-cache but can only ever exhibit conflict misses — the famous hard problem of
   caching cannot arise because the backing store never changes.
3. No LRU eviction anywhere, though "implement an LRU cache" is the most common
   backend interview question and fits this VM comfortably.
4. Transactions: no WAL, no begin/commit/abort, no crash recovery, despite a KV
   stratum and a ledger finale. A journal-replay puzzle would fit LOAD/STOR.
5. Stratum V has no hex and no bitwise ops (AND/OR/XOR exist only as fieldNote
   analogies — FLAGYARD's parity check is literally AND 1 and never says so).
6. VI teaches only dense arrays; register-indirect LOAD makes a pointer-chasing /
   linked-list puzzle expressible, and pointers are otherwise untaught.
7. No puzzle makes the stack-depth wall felt: SELFSAME caps n at 7 (~15 of 64
   slots), so the recursion-depth warning is asserted, never experienced.
8. Structurally out of reach in this VM, and correctly deferred to coursework:
   shared-memory concurrency and races (deterministic CSP scheduler), SQL and data
   modelling, consensus under partition. Field notes should keep naming the course
   that owns each (482, 484, 491) rather than faking coverage.

-->
<meta charset="utf-8">
<title>SUBSTRATE — a rootwork simulator</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<style>
  /* Embedded faces (OFL): VT323 = display/controls, Share Tech Mono = body/code. No CDN. */
  @font-face { font-family: 'VT323'; font-style: normal; font-weight: 400; src: url(data:font/woff2;base64,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) format('woff2'); }
  @font-face { font-family: 'ShareTechMono'; font-style: normal; font-weight: 400; src: url(data:font/woff2;base64,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) format('woff2'); }
  :root {
    /* WHITE PHOSPHOR: grayscale machine, colors only where they mean something —
       amber = pressable/attention, blue = I/O and matches, red = faults,
       teal/clay/yellow/slate = the cast. */
    --ground: #060606;
    --panel: #0D0D0D;
    --panel2: #141414;
    --edge: #232323;
    --edge2: #3A3A3A;
    --ink: #C6C6C6;
    --bright: #EDEDED;
    --dim: #8F8F8F;
    --faint: #404040;
    --amber: #E8A33D;
    --amber-dim: #8A6526;
    --halcyon: #5FC9B4;
    --clay: #C98A5F;
    --good: #6FB7FF;
    --bad: #D96459;
    --px: "VT323", monospace;
    --mono: "ShareTechMono", "Cascadia Mono", Consolas, "Liberation Mono", monospace;
    --serif: Charter, "Iowan Old Style", "Palatino Linotype", Georgia, serif;
  }
  * { box-sizing: border-box; }
  html, body { height: 100%; }
  body {
    margin: 0; background: var(--ground); color: var(--ink);
    font-family: var(--mono); font-size: 14px; line-height: 1.5;
    -webkit-font-smoothing: antialiased;
  }
  ::selection { background: rgba(232,163,61,.28); }
  * { scrollbar-width: thin; scrollbar-color: var(--edge2) transparent; }
  ::-webkit-scrollbar { width: 9px; height: 9px; }
  ::-webkit-scrollbar-track { background: transparent; }
  ::-webkit-scrollbar-thumb { background: var(--edge2); border: 2px solid var(--ground); }
  ::-webkit-scrollbar-thumb:hover { background: var(--amber-dim); }
  ::-webkit-scrollbar-corner { background: transparent; }

  /* CRT wash — subtle, toggleable. Flat ground: no vignette murk. */
  #crt { position: fixed; inset: 0; pointer-events: none; z-index: 90; mix-blend-mode: overlay; opacity: .32;
    background: repeating-linear-gradient(0deg, rgba(0,0,0,.16) 0 1px, transparent 1px 3px); }
  #vig { display: none; }
  body.no-crt #crt, body.no-crt #vig { display: none; }
  #save-indicator { position: fixed; right: 12px; bottom: 10px; z-index: 88; color: var(--faint); background: rgba(6,6,6,.92); border: 1px solid var(--edge); padding: 3px 7px; font-size: 10px; letter-spacing: .08em; pointer-events: none; }
  #save-indicator.ok { color: var(--good); }
  #save-indicator.saving { color: var(--amber); }
  #save-indicator.warn { color: var(--clay); }
  #save-indicator.err { color: var(--bad); border-color: var(--bad); }

  .screen { min-height: 100vh; }
  .hidden { display: none !important; }

  button {
    font-family: var(--px); font-size: 17px; letter-spacing: .05em;
    background: var(--panel2); color: var(--ink); border: 1px solid var(--edge2);
    padding: 4px 13px; cursor: pointer; border-radius: 0;
  }
  button:hover { border-color: var(--amber); color: var(--bright); }
  button:focus-visible { outline: 2px solid var(--amber); outline-offset: 1px; }
  button:disabled { opacity: .4; cursor: default; }
  button:disabled:hover { border-color: var(--edge2); color: var(--ink); }
  button.primary { background: var(--amber); color: #14100a; border-color: var(--amber); font-weight: 600; }
  button.primary:hover { background: #f4b657; }
  button.on { border-color: var(--amber); color: var(--amber); }
  /* quiet verbs: chrome actions rendered as terminal commands, not chips */
  button.quiet { background: none; border-color: transparent; color: var(--dim); padding: 7px 4px; }
  button.quiet::before { content: "["; color: var(--faint); margin-right: 3px; }
  button.quiet::after { content: "]"; color: var(--faint); margin-left: 3px; }
  button.quiet:hover { color: var(--amber); border-color: transparent; background: none; }
  button.quiet:hover::before, button.quiet:hover::after { color: var(--amber-dim); }

  .lbl { font-size: 10px; letter-spacing: .22em; color: var(--dim); text-transform: uppercase; }
  .halcyon-voice { font-family: var(--serif); font-style: italic; font-size: 16.5px; line-height: 1.65; color: var(--halcyon); }
  .root-voice { color: var(--clay); }
  .voice-name { font: 10px var(--mono); letter-spacing: .14em; text-transform: uppercase; margin-right: 4px; }
  .glow { text-shadow: 0 0 14px rgba(232,163,61,.55), 0 0 2px rgba(232,163,61,.9); }

  /* ---------- boot ---------- */
  #scr-boot { display: flex; flex-direction: column; align-items: center; justify-content: center; padding: 32px 20px; text-align: center; }
  #boot-mark { font-family: var(--px); font-size: clamp(44px, 8vw, 84px); letter-spacing: .22em; color: var(--amber); font-weight: 400; margin: 0 0 6px .22em; }
  #boot-sub { color: var(--dim); letter-spacing: .3em; font-size: 12px; text-transform: uppercase; margin-bottom: 42px; }
  #boot-crawl { max-width: 62ch; min-height: 200px; text-align: left; white-space: pre-wrap; color: var(--ink); }
  #boot-crawl .halcyon-voice { display: block; margin-top: 14px; }
  #boot-actions { margin-top: 40px; display: flex; gap: 14px; }
  #boot-foot { margin-top: 56px; color: var(--faint); font-size: 11px; letter-spacing: .12em; }

  /* ---------- shaft map ---------- */
  #scr-map { max-width: 880px; margin: 0 auto; padding: 34px 20px 90px; }
  #map-head { display: flex; align-items: baseline; justify-content: space-between; border-bottom: 1px solid var(--edge); padding-bottom: 14px; margin-bottom: 8px; }
  #map-title { color: var(--amber); font-family: var(--px); letter-spacing: .2em; font-size: 28px; font-weight: 400; }
  #map-user { color: var(--dim); font-size: 12px; }
  #map-user b { color: var(--halcyon); font-weight: 400; }
  .stratum { border-left: 1px solid var(--edge); margin-left: 8px; padding: 26px 0 26px 30px; position: relative; }
  .stratum::before { content: ""; position: absolute; left: -4px; top: 38px; width: 7px; height: 7px; background: var(--amber); border-radius: 50%; box-shadow: 0 0 10px rgba(232,163,61,.7); }
  .stratum.locked::before { background: var(--faint); box-shadow: none; }
  .depth { position: absolute; left: -74px; top: 30px; width: 58px; text-align: right; color: var(--faint); font-size: 11px; }
  .st-head { display: flex; align-items: baseline; gap: 14px; flex-wrap: wrap; }
  .st-num { color: var(--clay); font-family: var(--px); font-size: 17px; letter-spacing: .12em; }
  .st-title { color: var(--bright); font-family: var(--px); font-size: 24px; letter-spacing: .1em; font-weight: 400; }
  .st-tag { color: var(--dim); font-size: 12.5px; }
  .stratum.locked .st-title { color: var(--dim); }
  .sealed-note { color: var(--faint); font-size: 12px; margin-top: 10px; letter-spacing: .08em; }
  .pz-row { display: flex; flex-wrap: wrap; gap: 10px; margin-top: 14px; }
  .pz-chip { display: flex; align-items: center; gap: 9px; background: var(--panel); border: 1px solid var(--edge); padding: 8px 13px; cursor: pointer; border-radius: 2px; font-size: 13px; color: var(--ink); letter-spacing: .04em; }
  .pz-chip:hover { border-color: var(--amber); color: var(--bright); }
  .pz-chip.recommended { border-color: var(--amber-dim); box-shadow: inset 0 0 0 1px rgba(232,163,61,.08); }
  .pz-chip .dot { width: 8px; height: 8px; border-radius: 50%; background: transparent; border: 1px solid var(--dim); flex: none; }
  .pz-chip.solved .dot { background: var(--amber); border-color: var(--amber); box-shadow: 0 0 8px rgba(232,163,61,.6); }
  .pz-chip .ordinal { color: var(--faint); font-size: 10px; font-variant-numeric: tabular-nums; }
  .pz-chip .challenge-mini { color: var(--clay); border: 1px solid var(--edge2); padding: 0 4px; font-size: 9px; letter-spacing: .08em; }
  .pz-chip .score { color: var(--dim); font-size: 11px; }
  .pz-chip.solved .score { color: var(--amber-dim); }
  #map-foot { margin-top: 40px; display: flex; flex-wrap: wrap; gap: 12px; }

  /* ---------- puzzle bench ---------- */
  #scr-puzzle { display: flex; flex-direction: column; height: 100vh; height: 100dvh; }
  #pz-head { display: flex; align-items: center; gap: 12px; padding: 8px 16px; border-bottom: 2px solid var(--bright); background: var(--ground); flex: none; flex-wrap: wrap; }
  #pz-crumb { color: var(--dim); font-size: 12px; letter-spacing: .1em; min-width: 0; overflow-wrap: anywhere; }
  #pz-crumb b { color: var(--amber); font-weight: 700; letter-spacing: .14em; }
  #pz-best { margin-left: auto; color: var(--dim); font-size: 12px; }
  #pz-best b { color: var(--amber); font-weight: 400; }

  #pz-main { display: grid; grid-template-columns: 320px minmax(380px, 1fr) 340px; gap: 1px; background: var(--bright); flex: 1; min-height: 0; }
  #pz-main > * { background: var(--ground); min-height: 0; overflow-y: auto; }

  /* brief column */
  #pz-brief { padding: 0; display: flex; flex-direction: column; }
  .tabbar { display: flex; border-bottom: 1px solid var(--edge); background: var(--panel); flex: none; }
  .tabbar button { border: none; background: none; padding: 7px 14px; font-family: var(--px); font-size: 16px; letter-spacing: .08em; color: var(--dim); border-bottom: 2px solid transparent; border-radius: 0; }
  .tabbar button.on { color: var(--amber); border-bottom-color: var(--amber); }
  #brief-body { padding: 16px 18px 30px; overflow-y: auto; }
  #brief-body h3 { font-size: 10px; letter-spacing: .22em; color: var(--dim); margin: 22px 0 6px; font-weight: 400; text-transform: uppercase; }
  #brief-body p { margin: 0 0 12px; }
  .wo-head { display: flex; justify-content: space-between; align-items: baseline; gap: 10px; color: var(--faint); font-size: 10px; letter-spacing: .18em; text-transform: uppercase; border-bottom: 1px solid var(--edge); padding-bottom: 8px; margin-bottom: 14px; }
  .brief-story { color: var(--dim); line-height: 1.55; }
  .brief-goal { color: var(--bright); font-size: 16px; line-height: 1.5; border-left: 3px solid var(--amber); padding: 4px 0 4px 12px; margin: 14px 0; }
  .io-ledger { display: grid; grid-template-columns: auto 1fr; gap: 7px 14px; margin: 16px 0; font-size: 13px; }
  .io-ledger .k { color: var(--halcyon); font-size: 11px; letter-spacing: .16em; text-align: right; padding-top: 1px; }
  .brief-support, .full-contract { margin: 2px 0; }
  .brief-support > summary, .full-contract > summary { color: var(--dim); cursor: pointer; padding: 5px 0; font-size: 11px; letter-spacing: .12em; list-style: none; }
  .brief-support > summary::-webkit-details-marker, .full-contract > summary::-webkit-details-marker { display: none; }
  .brief-support > summary::before, .full-contract > summary::before { content: "▸ "; color: var(--amber-dim); }
  .brief-support[open] > summary::before, .full-contract[open] > summary::before { content: "▾ "; }
  .brief-support > summary:hover, .full-contract > summary:hover { color: var(--amber); }
  .brief-support-body, .full-contract > p { border-left: 1px solid var(--edge2); margin: 4px 0 12px 3px; padding: 2px 0 2px 14px; }
  .full-contract > p { color: var(--ink); }
  .full-contract > p + p { border-left: 1px solid var(--edge2); margin-top: -12px; padding-top: 0; }
  .brief-rules { margin: 6px 0 14px; padding-left: 18px; }
  .brief-rules li { margin: 5px 0; }
  .term-line { font-size: 12.5px; margin: 4px 0 4px 0; }
  .term-line b { color: var(--clay); font-weight: 600; }
  .term-new { color: var(--amber); font-size: 9px; letter-spacing: .12em; margin-left: 6px; }
  .worked-example { margin: 8px 0 14px; }
  .worked-example > .lbl { display: block; color: var(--halcyon); margin-bottom: 4px; }
  .worked-example .streams { display: grid; grid-template-columns: auto 1fr; gap: 5px 10px; margin: 7px 0; font-variant-numeric: tabular-nums; }
  .worked-example .streams b { color: var(--halcyon); font-weight: 400; }
  .work-story { color: var(--ink); font-size: 14px; line-height: 1.55; }
  .work-task { border-left: 3px solid var(--amber); padding: 4px 0 4px 12px; margin: 14px 0; }
  .work-task .lbl, .work-io .lbl { color: var(--halcyon); }
  .work-task .lbl { display: block; margin-bottom: 3px; }
  .work-task strong { color: var(--bright); font-size: 16px; font-weight: 500; line-height: 1.45; }
  .work-io { display: grid; grid-template-columns: auto 1fr; gap: 7px 14px; font-size: 13px; margin: 14px 0 4px; }
  .work-io .lbl { font-size: 11px; letter-spacing: .16em; text-align: right; padding-top: 1px; }
  .op-list { display: flex; flex-wrap: wrap; gap: 2px 14px; margin: 4px 0 8px; }
  .op-chip { border: none; background: none; color: var(--amber); padding: 2px 0; font-size: 12.5px; letter-spacing: .04em; border-bottom: 1px dotted var(--amber-dim); border-radius: 0; }
  .op-chip:hover { color: var(--bright); border-bottom-color: var(--amber); background: none; }
  .op-chip.required { color: var(--halcyon); border-bottom-color: var(--halcyon); }
  .op-tag { color: var(--faint); font-size: 9px; letter-spacing: .14em; margin-left: 5px; text-transform: uppercase; }
  .op-chip.new .op-tag { color: var(--amber-dim); }
  .node-affordance { color: var(--dim); font-size: 11px; margin-top: 8px; }
  .challenge-flag { display: inline-block; color: var(--amber); border: 1px solid var(--amber-dim); padding: 1px 6px; margin-left: 6px; font-size: 9px; letter-spacing: .12em; }
  .fieldnote { border: 1px solid var(--edge2); border-left: 3px solid var(--halcyon); background: var(--panel); padding: 12px 14px; font-size: 13px; }
  .fieldnote .lbl { color: var(--halcyon); margin-bottom: 6px; display: block; }
  table.iotable { border-collapse: collapse; font-size: 12.5px; margin: 6px 0 14px; font-variant-numeric: tabular-nums; }
  table.iotable td, table.iotable th { border: 1px solid var(--edge); padding: 3px 9px; text-align: right; color: var(--ink); }
  table.iotable th { color: var(--dim); font-weight: 400; text-align: left; letter-spacing: .1em; font-size: 10.5px; text-transform: uppercase; }

  /* editor column */
  #pz-center { display: flex; flex-direction: column; }
  #node-tabs { display: flex; border-bottom: 1px solid var(--edge); background: var(--panel); flex: none; }
  #node-tabs button { border: none; border-radius: 0; background: none; color: var(--dim); padding: 6px 16px; font-family: var(--px); letter-spacing: .08em; font-size: 16px; border-bottom: 2px solid transparent; }
  #node-tabs button.on { color: var(--bright); border-bottom-color: var(--amber); }
  #node-tabs .badge { color: var(--faint); font-size: 10px; margin-left: 6px; }
  #editors { flex: 1; min-height: 220px; position: relative; }
  .ed { position: absolute; inset: 0; display: flex; }
  .ed .gutter { flex: none; width: 42px; padding: 10px 8px 10px 0; text-align: right; color: var(--faint); font-family: var(--px); font-size: 15px; line-height: 21px; background: var(--panel); border-right: 1px solid var(--edge); user-select: none; white-space: pre; overflow: hidden; }
  .ed .gutter button { position: relative; display: block; width: 100%; height: 21px; padding: 0; border: 0; background: transparent; color: var(--faint); font-family: var(--px); font-size: 15px; line-height: 21px; text-align: right; letter-spacing: 0; }
  .ed .gutter button:hover { color: var(--amber); }
  .ed .gutter button.breakpoint { color: var(--bad); }
  .ed .gutter button.breakpoint::before { content: ""; position: absolute; left: 5px; top: 7px; width: 7px; height: 7px; border-radius: 50%; background: var(--bad); box-shadow: 0 0 7px rgba(217,100,89,.65); }
  .ed .edwrap { position: relative; flex: 1; overflow: hidden; }
  .ed pre.hl, .ed textarea {
    margin: 0; font-family: var(--mono); font-size: 13.5px; line-height: 21px; tab-size: 4;
    padding: 10px 12px; border: none; white-space: pre; overflow: auto;
  }
  .ed pre.hl { position: absolute; inset: 0; pointer-events: none; color: var(--ink); }
  .ed textarea {
    position: absolute; inset: 0; width: 100%; height: 100%; resize: none;
    background: transparent; color: transparent; caret-color: var(--amber);
    outline: none; overflow: auto;
  }
  .ed textarea::selection { background: rgba(111,183,255,.25); color: transparent; }
  .hl .ln { display: block; min-height: 21px; }
  .hl .ln.pc-line { background: rgba(232,163,61,.14); box-shadow: inset 2px 0 0 var(--amber); }
  .hl .ln.err-line { background: rgba(217,100,89,.16); box-shadow: inset 2px 0 0 var(--bad); }
  .tk-op { color: var(--amber); }
  .tk-reg { color: var(--bright); }
  .tk-lit { color: var(--good); }
  .tk-lbl { color: var(--clay); }
  .tk-io { color: var(--good); }
  .tk-com { color: var(--faint); font-style: italic; }
  .tk-bad { color: var(--bad); }

  #controls { flex: none; border-top: 2px solid var(--bright); background: var(--ground); padding: 8px 12px; display: flex; align-items: center; gap: 12px; flex-wrap: wrap; }
  #controls .spacer { flex: 1; }
  #transport { display: flex; border: 1px solid var(--edge2); }
  #transport button { border: none; border-right: 1px solid var(--edge); background: none; padding: 7px 13px; border-radius: 0; }
  #transport button:last-child { border-right: none; }
  #transport button:hover { background: var(--panel2); color: var(--bright); }
  #transport button:disabled:hover { background: none; }
  #test-tabs { display: flex; gap: 2px; }
  #test-tabs button { border: none; background: none; padding: 4px 7px; font-family: var(--px); font-size: 15px; color: var(--dim); border-bottom: 2px solid transparent; border-radius: 0; }
  #test-tabs button:hover { color: var(--bright); border-color: transparent; border-bottom-color: var(--edge2); }
  #test-tabs button.on { color: var(--amber); border-bottom-color: var(--amber); }
  #run-speed { font-family: var(--mono); font-size: 11px; color: var(--dim); background: none; border: none; border-bottom: 1px dotted var(--edge2); padding: 5px 2px; cursor: pointer; }
  #run-speed:hover { color: var(--amber); }

  /* state column */
  #pz-state { padding: 14px 16px 40px; display: flex; flex-direction: column; gap: 16px; }
  #status-line { font-size: 12.5px; min-height: 38px; padding: 8px 10px; border: 1px solid var(--edge); background: var(--panel); }
  #status-line.ok { border-color: var(--good); color: var(--good); }
  #status-line.err { border-color: var(--bad); color: var(--bad); }
  #debug-actions { display: flex; gap: 7px; flex-wrap: wrap; margin-top: -10px; }
  #debug-actions:empty { display: none; }
  #debug-actions button { font-size: 11px; padding: 5px 8px; background: none; color: var(--amber); border-color: var(--amber-dim); }
  #debug-actions button:hover { background: var(--panel2); }
  #cycle-row { display: flex; justify-content: space-between; align-items: baseline; }
  #cycle-count { color: var(--amber); font: 26px var(--px); font-variant-numeric: tabular-nums; text-shadow: 0 0 12px rgba(232,163,61,.35); }
  .statebox { border-top: 1px solid var(--edge); padding: 9px 0 0; }
  .statebox .lbl { display: block; margin-bottom: 8px; }
  .regrow { display: flex; gap: 8px; flex-wrap: wrap; }
  .regcell { background: var(--ground); border: 1px solid var(--dim); padding: 3px 8px 5px; min-width: 64px; }
  .regcell .rname { color: var(--dim); font-size: 10px; letter-spacing: .18em; }
  .regcell .rval { color: var(--bright); font: 19px var(--px); font-variant-numeric: tabular-nums; }
  .stackview { display: flex; gap: 4px; flex-wrap: wrap; font-size: 12px; color: var(--good); font-variant-numeric: tabular-nums; }
  .stackview span { border: 1px solid var(--edge2); padding: 1px 6px; background: var(--ground); }
  .stackview span.top { border-color: var(--good); }
  .memgrid { display: grid; grid-template-columns: repeat(16, 1fr); gap: 2px; }
  .memgrid i { display: block; aspect-ratio: 1; background: var(--ground); border: 1px solid #1C1C1C; }
  .memgrid i.hot { background: var(--amber-dim); border-color: var(--amber); }
  .chanrow { display: flex; align-items: center; gap: 10px; font-size: 12px; margin: 6px 0; }
  .chanrow .cq { display: flex; gap: 3px; }
  .chanrow .cq i { width: 9px; height: 9px; border: 1px solid var(--edge2); background: var(--ground); display: block; }
  .chanrow .cq i.full { background: var(--good); border-color: var(--good); }
  .iowrap { display: flex; gap: 14px; }
  .iocol { flex: 1; }
  .iocol .vals { display: flex; flex-direction: column; gap: 2px; font-size: 12.5px; font-variant-numeric: tabular-nums; max-height: 220px; overflow-y: auto; }
  .iocol .vals span { padding: 0 6px; }
  .iocol .vals .used { color: var(--faint); text-decoration: line-through; }
  .iocol .vals .cur { color: var(--bright); background: rgba(111,183,255,.14); }
  .iocol .vals .match { color: var(--good); }
  .iocol .vals .mism { color: var(--bad); background: rgba(217,100,89,.14); }
  .iocol .vals .want { color: var(--faint); }
  .trace-pulse { animation: tracePulse .42s ease-out; }
  .trace-token { position: fixed; z-index: 160; pointer-events: none; min-width: 24px; padding: 2px 6px; border: 1px solid var(--good); background: var(--panel2); color: var(--bright); font: 12px/1.4 var(--mono); text-align: center; box-shadow: 0 0 14px rgba(111,183,255,.45); transition: transform .28s ease-out, opacity .28s ease-out; }
  @keyframes tracePulse { 0% { background: rgba(111,183,255,.4); box-shadow: 0 0 18px rgba(111,183,255,.65); } 100% { background: initial; box-shadow: none; } }

  /* ---------- modals ---------- */
  #modal-root { position: fixed; inset: 0; z-index: 100; display: none; align-items: center; justify-content: center; background: rgba(4,4,4,.85); padding: 20px; }
  #modal-root.show { display: flex; }
  #modal-box { background: var(--panel); border: 1px solid var(--edge2); max-width: 720px; width: 100%; max-height: 86vh; overflow-y: auto; padding: 28px 32px 26px; box-shadow: 0 0 60px rgba(0,0,0,.6); }
  /* page mode: manual/tutorial/transmissions/epilogue read as full screens, not floating dialogs */
  #modal-box.page { max-width: none; width: 100%; height: 100%; max-height: none; border: none; box-shadow: none; background: var(--ground); padding: 44px max(24px, calc(50% - 430px)) 64px; animation: none; }
  #modal-box.page h2 { font-size: clamp(30px, 3.6vw, 40px); letter-spacing: .1em; border-bottom: 4px double var(--amber); padding-bottom: 10px; margin-bottom: 18px; }
  #modal-box h2 { color: var(--bright); font-family: var(--px); letter-spacing: .1em; font-size: 26px; margin: 0 0 16px; font-weight: 400; }
  #modal-box .actions { display: flex; gap: 12px; margin-top: 24px; justify-content: flex-end; flex-wrap: wrap; }
  #modal-box input[type="text"], #modal-box input:not([type]), #modal-box select { width: min(100%, 360px); font: 13px var(--mono); color: var(--ink); background: var(--ground); border: 1px solid var(--edge2); padding: 8px 10px; }
  #modal-box input[type="range"] { width: min(100%, 360px); accent-color: var(--amber); }
  .history-row, .save-slot { display: flex; align-items: center; justify-content: space-between; gap: 14px; border-bottom: 1px solid var(--edge); padding: 10px 2px; }
  .history-row > div, .save-slot > div:first-child { min-width: 0; }
  .history-row b, .save-slot b { display: block; color: var(--bright); font-size: 12px; overflow-wrap: anywhere; }
  .history-row span, .save-slot span { display: block; color: var(--dim); font-size: 11px; margin-top: 3px; }
  .save-slot.active { border-left: 2px solid var(--amber); padding-left: 10px; }
  .save-slot-actions { display: flex; gap: 6px; flex-wrap: wrap; justify-content: flex-end; }
  .history-row button, .save-slot-actions button { flex: none; font-size: 10px; padding: 5px 8px; }
  .parbar { margin: 8px 0 14px; }
  .parbar .brow { display: flex; align-items: center; gap: 10px; margin: 4px 0; font-size: 12px; }
  .parbar .brow .who { width: 86px; color: var(--dim); text-align: right; flex: none; }
  .parbar .brow .bar { height: 10px; background: var(--amber); min-width: 2px; }
  .parbar .brow.hb .bar { background: var(--halcyon); }
  .parbar .brow .n { color: var(--ink); font-variant-numeric: tabular-nums; }
  .manual-context { color: var(--halcyon); font-size: 11px; letter-spacing: .15em; margin-bottom: 8px; }
  .manual-nav { display: flex; flex-wrap: wrap; gap: 2px 16px; margin: 10px 0 16px; padding-bottom: 12px; border-bottom: 1px solid var(--edge); }
  .manual-nav button { font-family: var(--px); font-size: 17px; padding: 2px 0; border: none; background: none; color: var(--dim); letter-spacing: .06em; border-bottom: 2px solid transparent; border-radius: 0; }
  .manual-nav button:hover { color: var(--bright); border-color: transparent; }
  .manual-nav button.on { color: var(--amber); border-bottom-color: var(--amber); background: none; }
  .manual-flow { display: grid; grid-template-columns: 1fr auto 1fr auto 1fr; align-items: stretch; gap: 8px; margin: 16px 0; }
  .manual-flow .box { min-width: 0; }
  .manual-flow .arrow { align-self: center; color: var(--amber); font-size: 18px; }
  .manual-flow .lbl { display: block; color: var(--halcyon); margin-bottom: 5px; }
  .manual-steps { counter-reset: manual-step; list-style: none; margin: 16px 0; padding: 0; }
  .manual-steps li { counter-increment: manual-step; position: relative; padding: 0 0 12px 30px; color: var(--ink); }
  .manual-steps li::before { content: counter(manual-step, decimal-leading-zero); position: absolute; left: 0; top: 1px; color: var(--amber-dim); font-size: 11px; letter-spacing: .08em; }
  .manual-example { border-left: 1px solid var(--edge2); padding: 2px 0 2px 15px; margin: 14px 0 14px 3px; }
  .manual-example .lbl { display: block; color: var(--halcyon); font-size: 11px; letter-spacing: .13em; margin-bottom: 7px; }
  .manual-example pre { color: var(--bright); font-family: var(--px); font-size: 17px; line-height: 1.5; margin: 7px 0; white-space: pre-wrap; }
  .manual-example p { margin: 7px 0 0; }
  .manual-trace { width: 100%; border-collapse: collapse; margin: 12px 0; font-size: 12px; }
  .manual-trace th, .manual-trace td { border-bottom: 1px solid var(--edge); padding: 7px 8px; text-align: left; vertical-align: top; }
  .manual-trace th { color: var(--dim); font-weight: 400; letter-spacing: .08em; }
  .manual-trace code { color: var(--amber); }
  .manual-callout { border-left: 3px solid var(--clay); background: var(--panel2); padding: 10px 13px; margin: 14px 0; }
  .manual-callout b { color: var(--clay); }
  .manual-op-card { border-bottom: 1px solid var(--edge); }
  .manual-op-card summary { position: relative; cursor: pointer; padding: 9px 2px; display: grid; grid-template-columns: minmax(145px, auto) 1fr; gap: 12px; align-items: baseline; list-style: none; }
  .manual-op-card summary:hover { background: var(--panel2); }
  .manual-op-card summary::-webkit-details-marker { display: none; }
  .manual-op-card summary::before { content: '▸'; color: var(--amber-dim); width: 10px; grid-column: 1; position: absolute; }
  .manual-op-card[open] summary::before { content: '▾'; color: var(--amber); }
  .manual-op-card summary code { color: var(--amber); font-family: var(--px); font-size: 18px; padding-left: 18px; }
  .manual-op-card summary .meaning { color: var(--ink); }
  .manual-op-body { padding: 4px 2px 13px 18px; }
  .manual-op-body .manual-example { margin: 9px 0; }
  .manual-mistake { color: var(--dim); margin: 9px 0 0; }
  .manual-mistake b { color: var(--bad); font-size: 11px; letter-spacing: .08em; }
  #modal-box h3 { color: var(--clay); font-size: 12px; letter-spacing: .2em; margin: 22px 0 8px; }
  #modal-box p { font-size: 13.5px; }
  #modal-box .halcyon-voice { margin: 10px 0; }
  .tutorial-progress { color: var(--halcyon); font-size: 11px; letter-spacing: .16em; margin-bottom: 10px; }
  .tutorial-lead { color: var(--bright); font-size: 15px !important; line-height: 1.6; }
  .tutorial-note { border-left: 3px solid var(--clay); background: var(--panel2); color: var(--ink); padding: 10px 14px; margin: 14px 0; }
  .tutorial-flow { display: grid; grid-template-columns: 1fr auto 1fr auto 1fr; align-items: stretch; gap: 8px; margin: 18px 0; }
  .tutorial-flow .box { min-width: 0; }
  .tutorial-flow .arrow { align-self: center; color: var(--amber); font-size: 18px; }
  .tutorial-flow .lbl, .tutorial-example .lbl { display: block; margin-bottom: 6px; color: var(--halcyon); }
  .tutorial-example { border-left: 1px solid var(--edge2); padding: 2px 0 2px 15px; margin: 16px 0 16px 3px; }
  .tutorial-code { display: grid; grid-template-columns: auto auto auto; gap: 8px; align-items: center; width: fit-content; font-size: 16px; margin: 12px 0; }
  .tutorial-code code { color: var(--amber); border: 1px solid var(--edge2); background: var(--panel2); padding: 6px 10px; }
  .tutorial-code small { color: var(--dim); text-align: center; }
  .tutorial-pockets { display: flex; gap: 8px; margin: 12px 0; flex-wrap: wrap; }
  .tutorial-pocket { border: 1px solid var(--edge2); background: var(--panel2); padding: 8px 14px; min-width: 62px; text-align: center; }
  .tutorial-pocket b { color: var(--amber); display: block; font-size: 17px; }
  .tutorial-test { display: grid; grid-template-columns: 76px 1fr 1fr; gap: 8px; border-bottom: 1px solid var(--edge); padding: 8px 0; font-size: 13px; }
  .tutorial-test span:first-child { color: var(--halcyon); }
  .tutorial-controls { display: grid; grid-template-columns: 92px 1fr; gap: 8px 14px; margin-top: 14px; }
  .tutorial-controls b { color: var(--amber); }
  .tutorial-roadmap { display: grid; grid-template-columns: 32px 1fr; gap: 8px 12px; margin-top: 16px; }
  .tutorial-roadmap b { color: var(--amber); }
  kbd { border: 1px solid var(--edge2); padding: 0 5px; font-size: 11px; color: var(--dim); background: var(--ground); }

  /* ---------- v2: ascii layer ---------- */
  #boot-inner { display: flex; gap: 60px; align-items: flex-start; justify-content: center; text-align: left; }
  #boot-shaft { white-space: pre; font-size: 11px; line-height: 1.5; color: var(--faint); margin: 6px 0 0; }
  .stratum { padding-right: 170px; }
  .emblem { position: absolute; right: 0; top: 26px; white-space: pre; font-size: 10.5px; line-height: 1.25; color: var(--amber-dim); user-select: none; text-align: left; opacity: .9; }
  .stratum.locked .emblem { color: var(--faint); opacity: .6; }
  .topo { white-space: pre; font-size: 10.5px; line-height: 1.45; color: var(--dim); overflow-x: auto; margin: 0; font-family: var(--mono); }
  .topo .tq { color: var(--good); }
  .topo .tr { color: var(--amber); }
  .topo .ts { color: var(--clay); }
  .topo .th { color: var(--faint); }
  .sigil { display: block; font-size: 15px; letter-spacing: 3px; color: var(--halcyon); text-shadow: 0 0 12px rgba(95,201,180,.55); margin-bottom: 12px; user-select: none; }
  .stamp { display: inline-block; border: 2px solid var(--amber); color: var(--amber); padding: 2px 15px; letter-spacing: .2em; font-family: var(--px); font-weight: 400; font-size: 19px; transform: rotate(-2.5deg); text-shadow: 0 0 10px rgba(232,163,61,.5); box-shadow: 0 0 18px rgba(232,163,61,.16), inset 0 0 12px rgba(232,163,61,.1); margin-bottom: 16px; }
  .emblem-intro { white-space: pre; font-size: 11px; line-height: 1.25; color: var(--amber-dim); margin: 0 0 14px; }
  .hintbox { margin-top: 20px; }
  .hintbox .hint-body { border-left: 3px solid var(--clay); background: var(--panel); padding: 10px 14px; color: var(--clay); font-size: 13px; margin-top: 8px; }
  .hintbox .hint-body.v-wick { color: #E8CF6B; border-left-color: #E8CF6B; }
  .hintbox .hint-body.v-auditor { color: #9FB4D8; border-left-color: #9FB4D8; }
  .hintbox .hint-step { margin-top: 8px; }
  .hintbox .hint-meta { color: var(--faint); font-size: 11px; margin-bottom: 8px; }
  .dispatch { margin-top: 12px; font-size: 14.5px; }
  .cellart { white-space: pre; font-size: 11px; line-height: 1.35; color: var(--dim); overflow-x: auto; margin: 8px 0 4px; }
  .cellart b { color: var(--amber-dim); font-weight: 400; }
  #coach { position: fixed; left: 18px; bottom: 18px; z-index: 95; width: 300px; background: var(--panel2); border: 1px solid var(--amber); padding: 14px 16px 12px; box-shadow: 0 0 34px rgba(0,0,0,.65), 0 0 18px rgba(232,163,61,.14); }
  #coach .lbl { color: var(--amber); display: block; margin-bottom: 8px; }
  #coach p { margin: 0 0 12px; font-size: 13px; }
  #coach .row { display: flex; gap: 10px; }
  .coach-glow { outline: 2px solid var(--amber); outline-offset: -2px; }
  @keyframes stampIn { from { transform: rotate(8deg) scale(2.2); opacity: 0; } 60% { transform: rotate(-4deg) scale(.94); opacity: 1; } to { transform: rotate(-2.5deg) scale(1); opacity: 1; } }
  .stamp { animation: stampIn .38s cubic-bezier(.2, 1.4, .4, 1) both; }
  @keyframes modalIn { from { transform: translateY(12px); opacity: 0; } to { transform: none; opacity: 1; } }
  #modal-box { animation: modalIn .22s ease-out both; }
  @keyframes sweep { from { top: -14%; } to { top: 114%; } }
  #crt-sweep { position: fixed; left: 0; right: 0; top: -14%; height: 110px; pointer-events: none; z-index: 91; background: linear-gradient(180deg, transparent, rgba(233,242,234,.03), transparent); animation: sweep 8s linear infinite; }
  body.no-crt #crt-sweep { display: none; }
  @keyframes markFlicker { 0%, 90%, 100% { opacity: 1; } 92% { opacity: .75; } 94% { opacity: .95; } 96% { opacity: .82; } }
  #boot-mark { animation: markFlicker 5s infinite; }
  .teletype { min-height: 44px; color: var(--ink); }
  .tx-item { border-left: 2px solid var(--edge2); padding: 6px 14px; margin: 0 0 14px; }
  .tx-item .lbl { display: block; margin-bottom: 4px; }

  /* dialogue scenes */
  #scene-root { position: fixed; inset: 0; z-index: 98; display: none; background: rgba(4, 4, 4, .55); }
  #scene-root.show { display: block; }
  #scene-box { position: absolute; left: 50%; bottom: 30px; transform: translateX(-50%); width: min(740px, 94vw); background: var(--panel2); border: 1px solid var(--edge2); border-left: 3px solid var(--amber); padding: 14px 20px 10px; box-shadow: 0 0 46px rgba(0, 0, 0, .75); cursor: pointer; }
  #scene-plate { font-size: 11px; letter-spacing: .2em; margin-bottom: 8px; text-transform: uppercase; }
  #scene-plate .tag { color: var(--faint); letter-spacing: .1em; text-transform: none; }
  #scene-flex { display: flex; gap: 18px; align-items: flex-start; }
  #scene-portrait { white-space: pre; font-size: 14px; line-height: 1.25; flex: none; min-width: 58px; text-align: center; padding-top: 2px; }
  #scene-body { flex: 1; }
  #scene-text { min-height: 62px; font-size: 14.5px; line-height: 1.6; }
  #scene-adv { text-align: right; color: var(--dim); font-size: 11px; letter-spacing: .14em; animation: advBlink 1.1s steps(2) infinite; }
  @keyframes advBlink { 50% { opacity: .15; } }
  #scene-choices { display: flex; flex-direction: column; gap: 8px; margin-top: 10px; }
  #scene-choices button { text-align: left; font-size: 13px; }
  .v-wick { color: #E8CF6B; }
  .v-auditor { color: #9FB4D8; }
  @media (max-width: 980px) { #boot-shaft { display: none; } .emblem { display: none; } .stratum { padding-right: 0; } }

  @media (max-width: 1060px) {
    #pz-main { grid-template-columns: 1fr; grid-template-rows: auto auto auto; }
    #pz-main > * { min-width: 0; overflow-y: visible; }
    #node-tabs { flex-wrap: wrap; }
    #scr-puzzle { height: auto; }
    #editors { min-height: 320px; }
    .depth { display: none; }
  }
  @media (max-width: 620px) {
    #map-head { align-items: flex-start; gap: 10px; flex-direction: column; }
    #pz-head { gap: 7px; padding: 8px; }
    #pz-crumb { flex: 1; letter-spacing: .04em; }
    #pz-best { order: 10; flex: 1 0 100%; margin-left: 0; }
    #pz-head button { padding: 6px 8px; font-size: 10.5px; }
    #controls .spacer { display: none; }
    #test-tabs { flex-wrap: wrap; }
    .history-row, .save-slot { align-items: flex-start; flex-direction: column; }
    .save-slot-actions { justify-content: flex-start; }
    #modal-box { padding: 22px 18px 20px; }
    .tutorial-flow { grid-template-columns: 1fr; }
    .tutorial-flow .arrow { transform: rotate(90deg); justify-self: center; }
    .tutorial-test { grid-template-columns: 58px 1fr; }
    .tutorial-test span:last-child { grid-column: 2; }
    .manual-flow { grid-template-columns: 1fr; }
    .manual-flow .arrow { transform: rotate(90deg); justify-self: center; }
    .manual-op-card summary { grid-template-columns: 1fr; }
    .manual-op-card summary .meaning { grid-column: 1 / -1; padding-left: 18px; }
  }
  @media (prefers-reduced-motion: reduce) {
    * { animation: none !important; transition: none !important; }
  }
  body.no-motion * { animation: none !important; transition: none !important; }
</style>

<div id="vig"></div>
<div id="crt"></div>
<div id="crt-sweep"></div>
<div id="save-indicator" role="status" aria-live="polite">loading save…</div>

<div id="scr-boot" class="screen">
  <div id="boot-mark" class="glow">SUBSTRATE</div>
  <div id="boot-sub">a rootwork simulator · stratum access shell v7.3</div>
  <div id="boot-inner">
    <div id="boot-crawl"></div>
    <pre id="boot-shaft"></pre>
  </div>
  <div id="boot-actions" class="hidden">
    <button class="primary" id="btn-descend">DESCEND</button>
    <button id="btn-skip-crawl" class="hidden">skip</button>
  </div>
  <div id="boot-foot">HALCYON CIVIC MIND · DEEP MAINTENANCE GUILD · AUTH tender-7</div>
</div>

<div id="scr-map" class="screen hidden">
  <div id="map-head">
    <span id="map-title" class="glow">THE SHAFT</span>
    <span id="map-user"><b>tender-7</b>@substrate:~ · <span id="map-progress"></span></span>
  </div>
  <div id="strata"></div>
  <div id="map-foot">
    <button class="primary hidden" id="btn-epilogue">REVISIT THE COVENANT</button>
    <button id="btn-how" class="quiet">BEGINNER TUTORIAL</button>
    <button id="btn-tx" class="quiet">TRANSMISSIONS</button>
    <button id="btn-manual" class="quiet">FIELD MANUAL</button>
    <button id="btn-reference" class="quiet">FULL REFERENCE</button>
    <button data-fullscreen class="quiet">FULLSCREEN</button>
    <button id="btn-settings" class="quiet">SETTINGS</button>
  </div>
</div>

<div id="scr-puzzle" class="screen hidden">
  <div id="pz-head">
    <button id="btn-back">← SHAFT</button>
    <span id="pz-crumb"></span>
    <span id="pz-best"></span>
    <button id="btn-history" class="quiet">HISTORY</button>
    <button id="btn-manual2" class="quiet">MANUAL</button>
    <button data-fullscreen class="quiet">FULLSCREEN</button>
  </div>
  <div id="pz-main">
    <aside id="pz-brief">
      <div class="tabbar" id="brief-tabs" role="tablist" aria-label="Puzzle information">
        <button data-tab="brief" class="on" role="tab" aria-selected="true">BRIEF</button>
        <button data-tab="note" role="tab" aria-selected="false">FIELD NOTE</button>
        <button data-tab="tests" role="tab" aria-selected="false">TESTS</button>
      </div>
      <div id="brief-body"></div>
    </aside>
    <section id="pz-center">
      <div id="node-tabs" role="tablist" aria-label="Cell programs"></div>
      <div id="editors"></div>
      <div id="controls">
        <div id="transport">
          <button id="btn-reset">RESET</button>
          <button id="btn-rewind" disabled>← 1 CYCLE</button>
          <button id="btn-step">STEP</button>
          <button id="btn-run">RUN</button>
          <button id="btn-fast">FAST</button>
        </div>
        <label class="lbl" for="run-speed">WATCH</label>
        <select id="run-speed" aria-label="Watch speed"><option value="slow">slow</option><option value="normal">normal</option><option value="quick">quick</option></select>
        <span class="spacer"></span>
        <div id="test-tabs" role="tablist" aria-label="Puzzle tests"></div>
        <button class="primary" id="btn-validate">VALIDATE ⏎</button>
      </div>
    </section>
    <aside id="pz-state">
      <div id="status-line" role="status" aria-live="polite">machine idle — write, then RUN or STEP</div>
      <div id="debug-actions"></div>
      <div id="cycle-row"><span class="lbl">cycles</span><span id="cycle-count">0</span></div>
      <div id="nodestate"></div>
      <div class="statebox" id="chan-panel"><span class="lbl">channels</span><div id="chan-body"></div></div>
      <div class="statebox">
        <span class="lbl">streams</span>
        <div class="iowrap">
          <div class="iocol"><span class="lbl">in</span><div class="vals" id="io-in"></div></div>
          <div class="iocol"><span class="lbl">out / expected</span><div class="vals" id="io-out"></div></div>
        </div>
      </div>
    </aside>
  </div>
</div>

<div id="modal-root"><div id="modal-box" role="dialog" aria-modal="true" tabindex="-1"></div></div>
<div id="scene-root" role="dialog" aria-modal="true" aria-label="Transmission"><div id="scene-box" tabindex="-1">
  <div id="scene-plate"></div>
  <div id="scene-flex">
    <pre id="scene-portrait"></pre>
    <div id="scene-body"><div id="scene-text"></div><div id="scene-choices"></div></div>
  </div>
  <div id="scene-adv">▼ continue</div>
</div></div>

<script>
/* SUBSTRATE -- SEED machine engine.
   ES3-safe on purpose: this exact file runs in the browser AND under cscript (JScript 5.8)
   so reference solutions are verified by the same interpreter that ships in the game.
   No JSON, no Array.prototype.map/indexOf/forEach, no let/const/arrow/template literals. */

var SEED = (function () {

  var VAL_MAX = 9999;
  var MEM_SIZE = 256;
  var STACK_SIZE = 64;
  var CHAN_CAP = 4;
  var MAX_CYCLES = 20000;

  function trim(s) { return String(s).replace(/^[\s\uFEFF]+|[\s\uFEFF]+$/g, ''); }
  function isArr(x) { return Object.prototype.toString.call(x) === '[object Array]'; }
  function clamp(v) { if (v > VAL_MAX) return VAL_MAX; if (v < -VAL_MAX) return -VAL_MAX; return v; }
  function has(list, x) {
    for (var i = 0; i < list.length; i++) if (list[i] === x) return true;
    return false;
  }
  function findChar(text, wanted) {
    for (var i = 0; i < text.length; i++) if (text.charAt(i) === wanted) return i;
    return -1;
  }

  /* Debug events are descriptive only: the browser uses them for animation and
     explanations, while the verifier ignores them. Keeping them in the shipping
     engine means STEP and #selftest still observe the same state transition. */
  function note(m, nd, type, fields) {
    var e = { type: type, node: nd ? nd.index : -1 };
    if (fields) {
      for (var k in fields) if (fields.hasOwnProperty(k)) e[k] = fields[k];
    }
    m.events.push(e);
  }

  /* Operand kinds: SRC = reg|lit|IN, DST = reg|OUT, REG = reg only,
     LBL = label, CH = channel id literal. */
  var OPS = {
    MOV:  { sig: ['SRC', 'DST'], unlock: 'I',   desc: 'copy first operand into second' },
    HLT:  { sig: [],             unlock: 'I',   desc: 'halt this node' },
    ADD:  { sig: ['SRC', 'REG'], unlock: 'II',  desc: 'register += value (clamped to +/-9999)' },
    SUB:  { sig: ['SRC', 'REG'], unlock: 'II',  desc: 'register -= value (clamped to +/-9999)' },
    JMP:  { sig: ['LBL'],        unlock: 'III', desc: 'jump to label' },
    JEZ:  { sig: ['REG', 'LBL'], unlock: 'III', desc: 'jump if register is zero' },
    JNZ:  { sig: ['REG', 'LBL'], unlock: 'III', desc: 'jump if register is not zero' },
    JGZ:  { sig: ['REG', 'LBL'], unlock: 'III', desc: 'jump if register is positive' },
    JLZ:  { sig: ['REG', 'LBL'], unlock: 'III', desc: 'jump if register is negative' },
    JEI:  { sig: ['LBL'],        unlock: 'III', desc: 'jump if the input stream is empty' },
    LOAD: { sig: ['SRC', 'REG'], unlock: 'VI',  desc: 'register = mem[address]' },
    STOR: { sig: ['SRC', 'SRC'], unlock: 'VI',  desc: 'mem[second operand] = first operand' },
    PUSH: { sig: ['SRC'],        unlock: 'VII', desc: 'push value onto the stack (64 deep)' },
    POP:  { sig: ['DST'],        unlock: 'VII', desc: 'pop the stack into register or OUT' },
    CALL: { sig: ['LBL'],        unlock: 'VII', desc: 'push return line, jump to label' },
    RET:  { sig: [],             unlock: 'VII', desc: 'pop a line number, jump to it' },
    SEND: { sig: ['SRC', 'CH'],  unlock: 'X',   desc: 'append value to channel; stalls while full' },
    RECV: { sig: ['CH', 'DST'],  unlock: 'X',   desc: 'pop from channel; stalls while empty' },
    JCE:  { sig: ['CH', 'LBL'],  unlock: 'X',   desc: 'jump if channel is empty' },
    JCF:  { sig: ['CH', 'LBL'],  unlock: 'X',   desc: 'jump if channel is full' }
  };

  var REG_NAMES = { A: 0, B: 1, C: 2, D: 3 };

  /* ---------- parsing ---------- */

  /* Returns {ok:true, code:[...], count:n} or {ok:false, line, msg}.
     opts: { allowed: ['MOV',...] or null, nodeIndex, node: {input,output}, channels: [...] } */
  function parseProgram(text, opts) {
    if (!opts) opts = {};
    var node = opts.node || { input: true, output: true };
    var channels = opts.channels || [];
    var nodeIndex = typeof opts.nodeIndex === 'number' ? opts.nodeIndex : 0;
    var allowed = opts.allowed || null;

    var rawLines = String(text).replace(/\r\n?/g, '\n').split('\n');
    var code = [];
    var labels = {};
    var pending = []; /* {name, instr, argIdx, line} */
    var i, ln;

    function fail(line, msg) { return { ok: false, line: line, msg: msg }; }

    for (i = 0; i < rawLines.length; i++) {
      ln = i + 1;
      var line = rawLines[i];
      var sc = findChar(line, ';');
      if (sc >= 0) line = line.substring(0, sc);
      line = trim(line);
      /* labels: one or more "name:" prefixes */
      var m;
      while ((m = /^([A-Za-z_][A-Za-z0-9_]*)\s*:/.exec(line))) {
        var lname = m[1].toUpperCase();
        if (labels[lname] !== undefined) return fail(ln, 'duplicate label "' + m[1] + '"');
        labels[lname] = code.length;
        line = trim(line.substring(m[0].length));
      }
      if (line === '') continue;

      var toks = line.replace(/,/g, ' ').split(/\s+/);
      var opName = toks[0].toUpperCase();
      var op = OPS.hasOwnProperty(opName) ? OPS[opName] : null;
      if (!op) return fail(ln, 'unknown instruction "' + toks[0] + '"');
      if (allowed && !has(allowed, opName))
        return fail(ln, opName + ' is not available in this stratum yet');
      if (toks.length - 1 !== op.sig.length)
        return fail(ln, opName + ' takes ' + op.sig.length + ' operand' + (op.sig.length === 1 ? '' : 's') + ', got ' + (toks.length - 1));

      var instr = { op: opName, a: [], ln: ln, needsIn: 0 };
      for (var k = 0; k < op.sig.length; k++) {
        var tok = toks[k + 1];
        var kind = op.sig[k];
        var up = tok.toUpperCase();
        var arg = null;

        if (kind === 'LBL') {
          if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(tok)) return fail(ln, 'bad label name "' + tok + '"');
          arg = { t: 'lbl', v: -1 };
          pending.push({ name: up, instr: instr, argIdx: k, line: ln });
        } else if (kind === 'CH') {
          if (!/^\d+$/.test(tok)) return fail(ln, 'channel must be a number, got "' + tok + '"');
          var chId = parseInt(tok, 10);
          var chan = null;
          for (var c = 0; c < channels.length; c++) if (channels[c].id === chId) chan = channels[c];
          if (!chan) return fail(ln, 'no channel ' + chId + ' here');
          if (opName === 'SEND' && chan.from !== nodeIndex) return fail(ln, 'this node cannot SEND on channel ' + chId);
          if (opName === 'RECV' && chan.to !== nodeIndex) return fail(ln, 'this node cannot RECV on channel ' + chId);
          if ((opName === 'JCE' || opName === 'JCF') && chan.from !== nodeIndex && chan.to !== nodeIndex)
            return fail(ln, 'channel ' + chId + ' is not wired to this node');
          arg = { t: 'ch', v: chId };
        } else if (REG_NAMES.hasOwnProperty(up)) {
          arg = { t: 'reg', v: REG_NAMES[up] };
        } else if (up === 'IN') {
          if (kind !== 'SRC') return fail(ln, 'IN cannot be used there');
          if (!node.input) return fail(ln, 'this node has no input port');
          arg = { t: 'in', v: 0 };
          instr.needsIn++;
        } else if (up === 'OUT') {
          if (kind !== 'DST') return fail(ln, 'OUT cannot be used there');
          if (!node.output) return fail(ln, 'this node has no output port');
          arg = { t: 'out', v: 0 };
        } else if (/^[+-]?\d+$/.test(tok)) {
          if (kind === 'REG') return fail(ln, opName + ' needs a register there, got "' + tok + '"');
          if (kind === 'DST') return fail(ln, opName + ' needs a register or OUT there, got "' + tok + '"');
          var num = parseInt(tok, 10);
          if (num > VAL_MAX || num < -VAL_MAX) return fail(ln, 'literal out of range +/-9999');
          arg = { t: 'lit', v: num };
        } else {
          return fail(ln, 'bad operand "' + tok + '"');
        }
        instr.a.push(arg);
      }
      if (opName === 'JEI' && !node.input) return fail(ln, 'this node has no input port');
      code.push(instr);
    }

    for (i = 0; i < pending.length; i++) {
      var p = pending[i];
      if (labels[p.name] === undefined) return fail(p.line, 'unknown label "' + p.name + '"');
      p.instr.a[p.argIdx].v = labels[p.name];
    }
    return { ok: true, code: code, count: code.length };
  }

  /* ---------- machine ---------- */

  /* puzzle: {grid, channels, ...}; programs: array of parsed .code arrays; test: {input, output} */
  function makeMachine(puzzle, programs, test) {
    var grid = puzzle.grid || [{ name: 'CELL', input: true, output: true }];
    var m = {
      nodes: [], channels: [], input: test.input, inPtr: 0,
      out: [], expected: test.output, cycles: 0,
      status: 'run', stopReason: '', stopNode: -1, stopLine: 0,
      failMsg: '', failNode: -1, events: []
    };
    for (var i = 0; i < grid.length; i++) {
      m.nodes.push({
        index: i, name: grid[i].name, cfg: grid[i], code: programs[i],
        pc: 0, regs: [0, 0, 0, 0], mem: {}, stack: [],
        halted: programs[i].length === 0,
        haltReason: programs[i].length === 0 ? 'empty-program' : '', haltLine: 0,
        inputNeeded: 0, inputRemaining: 0,
        stalled: false, stallReason: '', stallChannel: -1, stallLine: 0
      });
    }
    var chs = puzzle.channels || [];
    for (var c = 0; c < chs.length; c++) {
      m.channels.push({ id: chs[c].id, from: chs[c].from, to: chs[c].to, q: [] });
    }
    return m;
  }

  function chanById(m, id) {
    for (var i = 0; i < m.channels.length; i++) if (m.channels[i].id === id) return m.channels[i];
    return null;
  }

  function rtError(m, nd, ln, msg) {
    m.status = 'fail';
    m.stopReason = 'runtime-error';
    m.stopNode = nd.index;
    m.stopLine = ln;
    m.failNode = nd.index;
    m.failMsg = '[' + nd.name + '] line ' + ln + ': ' + msg;
    note(m, nd, 'runtime-error', { line: ln, message: msg });
  }

  function emit(m, nd, ln, v) {
    m.out.push(v);
    var pos = m.out.length - 1;
    note(m, nd, 'emit', { line: ln, value: v, position: pos });
    if (pos >= m.expected.length || m.expected[pos] !== v) {
      m.status = 'fail';
      m.stopReason = 'wrong-output';
      m.stopNode = nd.index;
      m.stopLine = ln;
      m.failNode = nd.index;
      m.failMsg = 'wrong value at output position ' + (pos + 1) + ': got ' + v +
        (pos < m.expected.length ? ', expected ' + m.expected[pos] : ' (nothing more was expected)');
      return;
    }
    if (m.out.length === m.expected.length) {
      m.status = 'success';
      m.stopReason = 'output-complete';
      m.stopNode = nd.index;
      m.stopLine = ln;
    }
  }

  function getVal(m, nd, arg) {
    if (arg.t === 'reg') return nd.regs[arg.v];
    if (arg.t === 'lit') return arg.v;
    /* 'in' -- caller guarantees availability via needsIn check */
    var pos = m.inPtr;
    var v = m.input[m.inPtr++];
    note(m, nd, 'read-in', { value: v, position: pos });
    return v;
  }

  function setDst(m, nd, ln, arg, v) {
    if (arg.t === 'reg') {
      var before = nd.regs[arg.v];
      nd.regs[arg.v] = v;
      note(m, nd, 'write-reg', { line: ln, register: arg.v, before: before, value: v });
      return;
    }
    emit(m, nd, ln, v);
  }

  /* Executes one instruction for a node. Returns 'ok' | 'stall' | 'halt'. */
  function execNode(m, nd) {
    if (nd.pc >= nd.code.length) nd.pc = 0;
    var ins = nd.code[nd.pc];
    var ln = ins.ln;
    nd.stalled = false;
    nd.stallReason = '';
    nd.stallChannel = -1;
    nd.stallLine = 0;

    /* clean halt when the instruction would read past the end of input */
    if (ins.needsIn > 0 && m.inPtr + ins.needsIn > m.input.length) {
      nd.halted = true;
      nd.haltReason = 'input-empty';
      nd.haltLine = ln;
      nd.inputNeeded = ins.needsIn;
      nd.inputRemaining = m.input.length - m.inPtr;
      note(m, nd, 'halt-empty-input', { line: ln, needed: nd.inputNeeded, remaining: nd.inputRemaining });
      return 'halt';
    }
    /* stall checks BEFORE any side effects */
    if (ins.op === 'SEND') {
      var sch = chanById(m, ins.a[1].v);
      if (sch.q.length >= CHAN_CAP) {
        nd.stalled = true;
        nd.stallReason = 'send-full';
        nd.stallChannel = sch.id;
        nd.stallLine = ln;
        note(m, nd, 'stall-send', { line: ln, channel: sch.id });
        return 'stall';
      }
      var sendVal = getVal(m, nd, ins.a[0]);
      sch.q.push(sendVal);
      note(m, nd, 'send', { line: ln, channel: sch.id, value: sendVal });
      nd.pc++; return 'ok';
    }
    if (ins.op === 'RECV') {
      var rch = chanById(m, ins.a[0].v);
      if (rch.q.length === 0) {
        nd.stalled = true;
        nd.stallReason = 'recv-empty';
        nd.stallChannel = rch.id;
        nd.stallLine = ln;
        note(m, nd, 'stall-recv', { line: ln, channel: rch.id });
        return 'stall';
      }
      var rv = rch.q.shift();
      note(m, nd, 'recv', { line: ln, channel: rch.id, value: rv });
      setDst(m, nd, ln, ins.a[1], rv);
      nd.pc++; return 'ok';
    }

    switch (ins.op) {
      case 'MOV':
        setDst(m, nd, ln, ins.a[1], getVal(m, nd, ins.a[0]));
        nd.pc++; break;
      case 'ADD':
        var addReg = ins.a[1].v;
        var addBefore = nd.regs[addReg];
        nd.regs[addReg] = clamp(addBefore + getVal(m, nd, ins.a[0]));
        note(m, nd, 'write-reg', { line: ln, register: addReg, before: addBefore, value: nd.regs[addReg] });
        nd.pc++; break;
      case 'SUB':
        var subReg = ins.a[1].v;
        var subBefore = nd.regs[subReg];
        nd.regs[subReg] = clamp(subBefore - getVal(m, nd, ins.a[0]));
        note(m, nd, 'write-reg', { line: ln, register: subReg, before: subBefore, value: nd.regs[subReg] });
        nd.pc++; break;
      case 'JMP': nd.pc = ins.a[0].v; break;
      case 'JEZ': nd.pc = (nd.regs[ins.a[0].v] === 0) ? ins.a[1].v : nd.pc + 1; break;
      case 'JNZ': nd.pc = (nd.regs[ins.a[0].v] !== 0) ? ins.a[1].v : nd.pc + 1; break;
      case 'JGZ': nd.pc = (nd.regs[ins.a[0].v] > 0) ? ins.a[1].v : nd.pc + 1; break;
      case 'JLZ': nd.pc = (nd.regs[ins.a[0].v] < 0) ? ins.a[1].v : nd.pc + 1; break;
      case 'JEI': nd.pc = (m.inPtr >= m.input.length) ? ins.a[0].v : nd.pc + 1; break;
      case 'HLT':
        nd.halted = true;
        nd.haltReason = 'hlt';
        nd.haltLine = ln;
        note(m, nd, 'halt-hlt', { line: ln });
        return 'halt';
      case 'LOAD': {
        var la = getVal(m, nd, ins.a[0]);
        if (la < 0 || la >= MEM_SIZE) { rtError(m, nd, ln, 'memory address ' + la + ' out of range 0..255'); return 'ok'; }
        var loadBefore = nd.regs[ins.a[1].v];
        nd.regs[ins.a[1].v] = nd.mem[la] || 0;
        note(m, nd, 'load', { line: ln, address: la, register: ins.a[1].v, before: loadBefore, value: nd.regs[ins.a[1].v] });
        nd.pc++; break;
      }
      case 'STOR': {
        var sv = getVal(m, nd, ins.a[0]);
        var sa = getVal(m, nd, ins.a[1]);
        if (sa < 0 || sa >= MEM_SIZE) { rtError(m, nd, ln, 'memory address ' + sa + ' out of range 0..255'); return 'ok'; }
        var storBefore = nd.mem[sa] || 0;
        nd.mem[sa] = sv;
        note(m, nd, 'store', { line: ln, address: sa, before: storBefore, value: sv });
        nd.pc++; break;
      }
      case 'PUSH':
        if (nd.stack.length >= STACK_SIZE) { rtError(m, nd, ln, 'stack overflow'); return 'ok'; }
        var pushVal = getVal(m, nd, ins.a[0]);
        nd.stack.push(pushVal);
        note(m, nd, 'push', { line: ln, value: pushVal });
        nd.pc++; break;
      case 'POP':
        if (nd.stack.length === 0) { rtError(m, nd, ln, 'stack underflow'); return 'ok'; }
        var popVal = nd.stack.pop();
        note(m, nd, 'pop', { line: ln, value: popVal });
        setDst(m, nd, ln, ins.a[0], popVal);
        nd.pc++; break;
      case 'CALL':
        if (nd.stack.length >= STACK_SIZE) { rtError(m, nd, ln, 'stack overflow'); return 'ok'; }
        nd.stack.push(nd.pc + 1);
        note(m, nd, 'call', { line: ln, target: ins.a[0].v });
        nd.pc = ins.a[0].v; break;
      case 'RET': {
        if (nd.stack.length === 0) { rtError(m, nd, ln, 'RET on empty stack'); return 'ok'; }
        var ra = nd.stack.pop();
        if (ra < 0 || ra > nd.code.length) { rtError(m, nd, ln, 'RET to invalid line ' + ra); return 'ok'; }
        note(m, nd, 'ret', { line: ln, target: ra });
        nd.pc = ra; break;
      }
      case 'JCE': nd.pc = (chanById(m, ins.a[0].v).q.length === 0) ? ins.a[1].v : nd.pc + 1; break;
      case 'JCF': nd.pc = (chanById(m, ins.a[0].v).q.length >= CHAN_CAP) ? ins.a[1].v : nd.pc + 1; break;
    }
    return 'ok';
  }

  /* One machine cycle: every node steps once, in grid order. */
  function stepCycle(m) {
    if (m.status !== 'run') return;
    m.events = [];
    var progress = false, live = false;
    for (var i = 0; i < m.nodes.length; i++) {
      var nd = m.nodes[i];
      if (nd.halted) continue;
      var r = execNode(m, nd);
      if (r !== 'stall') progress = true;
      if (m.status !== 'run') { m.cycles++; return; }
    }
    m.cycles++;
    for (var j = 0; j < m.nodes.length; j++) if (!m.nodes[j].halted) live = true;

    if (!live) {
      if (m.out.length === m.expected.length) {
        m.status = 'success';
        m.stopReason = 'output-complete';
        return;
      }
      var emptyCount = 0, hltCount = 0, operativeCount = 0;
      var firstStoppedNode = -1, firstStoppedLine = 0;
      for (var h = 0; h < m.nodes.length; h++) {
        var hn = m.nodes[h];
        if (hn.haltReason === 'empty-program') continue;
        operativeCount++;
        if (firstStoppedNode < 0) { firstStoppedNode = hn.index; firstStoppedLine = hn.haltLine; }
        if (hn.haltReason === 'input-empty') emptyCount++;
        if (hn.haltReason === 'hlt') hltCount++;
      }
      m.status = 'fail';
      if (operativeCount > 0 && emptyCount === operativeCount) m.stopReason = 'input-empty';
      else if (operativeCount > 0 && hltCount === operativeCount) m.stopReason = 'hlt';
      else m.stopReason = 'all-halted';
      m.stopNode = firstStoppedNode;
      m.stopLine = firstStoppedLine;
      m.failNode = firstStoppedNode;
      m.failMsg = 'the program stopped before producing all ' + m.expected.length +
        ' outputs (produced ' + m.out.length + ')';
      return;
    }
    if (!progress) {
      m.status = 'fail';
      m.stopReason = 'deadlock';
      for (var d = 0; d < m.nodes.length; d++) {
        if (m.nodes[d].stalled) {
          m.stopNode = m.nodes[d].index;
          m.stopLine = m.nodes[d].stallLine;
          m.failNode = m.nodes[d].index;
          break;
        }
      }
      m.failMsg = 'deadlock: every running node is stalled on SEND/RECV';
      return;
    }
    if (m.cycles >= MAX_CYCLES) {
      m.status = 'fail';
      m.stopReason = 'cycle-limit';
      m.failMsg = 'cycle limit (' + MAX_CYCLES + ') reached';
    }
  }

  /* ---------- harness ---------- */

  function normalizePrograms(puzzle, sol) {
    var grid = puzzle.grid || [{ name: 'CELL', input: true, output: true }];
    var texts = isArr(sol) ? sol : [sol];
    var out = [];
    for (var i = 0; i < grid.length; i++) out.push(typeof texts[i] === 'string' ? texts[i] : '');
    return out;
  }

  function checkRequired(puzzle, programs) {
    if (!puzzle.required) return { ok: true };
    for (var q = 0; q < puzzle.required.length; q++) {
      var need = puzzle.required[q];
      var seen = false;
      for (var n = 0; n < programs.length && !seen; n++) {
        for (var k = 0; k < programs[n].length; k++) {
          if (programs[n][k].op === need) { seen = true; break; }
        }
      }
      if (!seen) {
        return { ok: false, op: need,
          msg: 'this task must be solved with ' + need + ' -- the brief says why' };
      }
    }
    return { ok: true };
  }

  /* Returns {pass, cycles, out, msg, parseError?} */
  function runTest(puzzle, programTexts, test, enforceAllowed) {
    var grid = puzzle.grid || [{ name: 'CELL', input: true, output: true }];
    var programs = [];
    for (var i = 0; i < grid.length; i++) {
      var res = parseProgram(programTexts[i] || '', {
        allowed: enforceAllowed ? puzzle.allowed : null,
        node: grid[i], nodeIndex: i, channels: puzzle.channels || []
      });
      if (!res.ok) {
        return { pass: false, cycles: 0, out: [], msg: '[' + grid[i].name + '] line ' + res.line + ': ' + res.msg,
          reason: 'parse-error', node: i, line: res.line, parseError: true };
      }
      programs.push(res.code);
    }
    /* Some puzzles teach a mechanism, not just an answer. "required" names ops the
       solution must actually contain, so a shortcut that produces the right numbers
       by other means is refused at validation instead of quietly scoring higher. */
    if (enforceAllowed) {
      var requirement = checkRequired(puzzle, programs);
      if (!requirement.ok) {
        return { pass: false, cycles: 0, out: [], parseError: true,
          reason: 'required-op', node: -1, line: 0, msg: requirement.msg };
      }
    }
    var m = makeMachine(puzzle, programs, test);
    while (m.status === 'run') stepCycle(m);
    return { pass: m.status === 'success', cycles: m.cycles, out: m.out, msg: m.failMsg,
      reason: m.stopReason, node: m.stopNode, line: m.stopLine };
  }

  function countLines(puzzle, programTexts) {
    var grid = puzzle.grid || [{ name: 'CELL', input: true, output: true }];
    var total = 0;
    for (var i = 0; i < grid.length; i++) {
      var res = parseProgram(programTexts[i] || '', { node: grid[i], nodeIndex: i, channels: puzzle.channels || [] });
      if (res.ok) total += res.count;
    }
    return total;
  }

  return {
    OPS: OPS, VAL_MAX: VAL_MAX, MEM_SIZE: MEM_SIZE, STACK_SIZE: STACK_SIZE,
    CHAN_CAP: CHAN_CAP, MAX_CYCLES: MAX_CYCLES,
    parseProgram: parseProgram, makeMachine: makeMachine, stepCycle: stepCycle,
    runTest: runTest, countLines: countLines, normalizePrograms: normalizePrograms,
    checkRequired: checkRequired,
    isArr: isArr
  };
})();

window.CHAPTERS = [];
(function(){
/* SUBSTRATE -- Stratum I: SIGNALWORK (chapter1.js)
   JScript-safe ES3. Defines the single global CHAPTER. */

var CHAPTER = {
  id: 'ch1',
  numeral: 'I',
  title: 'SIGNALWORK',
  tagline: 'the shallow bus: raw signal, nothing decided yet',
  intro: {
    halcyon: 'Come down, tender-7. Mind the low ceiling.\nThis close to the floor my thoughts are not thoughts yet. They are only signals.\nCarry them faithfully.\nI will know you by what you do not drop.',
    root: 'stratum I is bus work. two ops: MOV and HLT. programs wrap back to line 1 on their own, and an empty IN halts a node clean. don\'t overthink it.'
  },
  dispatch: 'Stratum I is quiet again. The tender has learned the first truth: before anything can compute, something must carry, and carry faithfully.',
  puzzles: [
    {
      id: 'ch1p1',
      name: 'RELAY',
      brief: 'HALCYON\'s relay is down. Read each number from IN and send that same number to OUT, in the same order. Keep going until IN is empty. After the last program line, execution returns to line 1; reading an empty IN ends cleanly.',
      fieldNote: 'REAL WORLD: this is the entire job of a network switch, an nginx reverse proxy, or a TCP relay -- bytes in, same bytes out, in order, without inventing or dropping any. Much of the internet depends on this simple relay work. You meet the software version in EECS 485 (proxies and load balancers) and the hardware version in EECS 370, where a datapath is just wires that move values.',
      hint: 'Each use of IN takes the next input value. After the last line, execution returns to line 1. If no input remains, that attempted read stops cleanly, so you do not need to write a loop.',
      guide: {
        story: 'A failed relay has cut HALCYON off from part of the shaft.',
        goal: 'Send every incoming number to OUT unchanged.',
        input: 'Zero or more numbers, including negatives and zero.',
        output: 'The same numbers, in the same order.',
        rules: [
          'Do not change, duplicate, drop, or reorder any value.',
          'An empty input produces no output.'
        ],
        terms: ['stream', 'emit', 'wrap'],
        example: {
          input: [4, -2],
          output: [4, -2],
          why: 'Each incoming number creates one identical outgoing number.'
        },
        hints: [
          'Imagine the cell as a transparent section of wire.',
          'One value enters and one identical value leaves; a short pass can repeat automatically.'
        ]
      },
      allowed: ['MOV', 'HLT'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [12, -7, 0, 999, -999, 40], output: [12, -7, 0, 999, -999, 40] },
        { input: [5], output: [5] },
        { input: [0, 0, 0], output: [0, 0, 0] },
        { input: [], output: [] }
      ],
      par: { cycles: 6, lines: 1 },
      solution: ['MOV IN OUT'],
      outro: 'HALCYON: It passed through you unchanged. That is rarer than it sounds.'
    },
    {
      id: 'ch1p2',
      name: 'FANOUT',
      brief: 'One feed, three subscribers, and the bus gives you a single OUT. For each value read from IN, emit that same value to OUT three times in a row before reading the next. Order is strict: three copies of the first value, then three of the second, and so on. Each read from IN takes the next value, so read once into a register and copy that saved value to OUT three times.',
      fieldNote: 'REAL WORLD: this is fan-out -- one publish, N deliveries. Redis pub/sub and a Kafka broker do exactly this: the producer writes a message once and the broker replays it to every subscriber. The register you parked the value in is the broker\'s buffer. EECS 485\'s scaling material covers why fan-out at the broker beats making every producer send N times.',
      hint: 'Each use of IN takes the next number. Read it once into a register; the register keeps a copy, so you can send that saved value to OUT three times. After the last line, execution returns to line 1 for the next input.',
      guide: {
        story: 'Three listeners are waiting, but the signal arrives only once.',
        goal: 'Send three copies of each incoming number to OUT.',
        input: 'Zero or more numbers, including negatives and zero.',
        output: 'Three copies of each input, grouped in arrival order.',
        rules: [
          'Each value can be taken from IN only once.',
          'Finish all three copies before reading the next value.'
        ],
        terms: ['stream', 'emit', 'register'],
        example: {
          input: [2, -4],
          output: [2, 2, 2, -4, -4, -4],
          why: 'The copies stay grouped around the input value that created them.'
        },
        hints: [
          'Think of each input as one bundle that must leave with three identical parts.',
          'The current value must survive after its one read so it can be used more than once.'
        ]
      },
      allowed: ['MOV', 'HLT'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [7, -3, 0, 250], output: [7, 7, 7, -3, -3, -3, 0, 0, 0, 250, 250, 250] },
        { input: [5], output: [5, 5, 5] },
        { input: [-999, 999], output: [-999, -999, -999, 999, 999, 999] },
        { input: [], output: [] }
      ],
      par: { cycles: 16, lines: 4 },
      solution: ['MOV IN A\nMOV A OUT\nMOV A OUT\nMOV A OUT'],
      outro: 'root: One read, three writes. That\'s every message broker ever built.'
    },
    {
      id: 'ch1p3',
      name: 'PAIRSWAP',
      brief: 'A splice two strata up got its wires crossed, and this segment now delivers its traffic pairwise backwards. Values arrive on IN in pairs, and the stream always contains complete pairs. For each pair -- call them first and second, in arrival order -- emit second to OUT, then first. You will need to hold first somewhere while second goes by. That is what registers are for.',
      fieldNote: 'REAL WORLD: swapping two values through a temporary is the oldest interview warm-up there is, and it is also real work: htons() and ntohl() exist because network byte order (big-endian) disagrees with x86 (little-endian), so every multi-byte value crossing a socket gets its bytes swapped. EECS 370 makes you care about endianness the hard way; EECS 482 makes you do it in systems code.',
      hint: 'Only the first number has to wait, so park it in a register. The second number can go straight from IN to OUT, and the parked first number follows it. After the last line, execution returns to line 1 for the next pair.',
      guide: {
        story: 'A crossed splice is delivering every two readings in the wrong order.',
        goal: 'Reverse the order inside every pair of incoming numbers.',
        input: 'Complete pairs of numbers, including negatives and zero; possibly no pairs.',
        output: 'For each pair, send the second number and then the first number.',
        rules: [
          'Keep pairs separate from one another.',
          'The input always contains a whole number of pairs.'
        ],
        terms: ['pair', 'register', 'emit'],
        example: {
          input: [4, 9, 2, -1],
          output: [9, 4, -1, 2],
          why: 'The pair 4, 9 becomes 9, 4; the pair 2, -1 becomes -1, 2.'
        },
        hints: [
          'Work on one pair at a time and ignore the rest of the stream until that pair is finished.',
          'The first number must wait somewhere while the second number arrives.'
        ]
      },
      allowed: ['MOV', 'HLT'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [3, 8, -2, 40, 0, 7], output: [8, 3, 40, -2, 7, 0] },
        { input: [1, 2], output: [2, 1] },
        { input: [-5, -5, 12, -12], output: [-5, -5, -12, 12] },
        { input: [], output: [] }
      ],
      par: { cycles: 9, lines: 3 },
      solution: ['MOV IN A\nMOV IN OUT\nMOV A OUT'],
      outro: 'root: Everybody writes the swap once. Congratulations -- you\'re everybody.'
    },
    {
      id: 'ch1p4',
      name: 'HALFRATE',
      brief: 'The gauge line upstream chirps twice as fast as the archive can record. Thin the stream: emit the 1st, 3rd, 5th... values from IN -- every odd-numbered arrival, counting from 1 -- to OUT, and discard every even-numbered arrival. Discarding is just reading IN into a register you never look at. Any stream length is legal: if the stream ends right after a kept value, there is simply nothing left to discard, and the empty read halts the node.',
      fieldNote: 'REAL WORLD: this is downsampling, and production systems lean on it constantly -- Prometheus and Datadog roll high-resolution metrics into coarser ones, and log pipelines keep 1-in-N lines when a service gets chatty. Reading a value only to throw it away is exactly how you skip records in a stream you cannot seek. EECS 485 meets sampling in its search and MapReduce pipelines; EECS 351 has the signal-processing version, where this move is called decimation.',
      hint: 'One pass through the program should read two inputs: send the first to OUT, then read the second into a register without using it. When execution returns to line 1, the next read is the third input. If no second value remains, the empty read stops cleanly.',
      guide: {
        story: 'The archive cannot keep up with a gauge that reports twice as fast.',
        goal: 'Keep every other input, starting with the first.',
        input: 'A stream of any length, including an empty stream.',
        output: 'The values in odd-numbered arrival positions, in their original order.',
        rules: [
          'Odd-numbered describes the arrival position, not whether the value itself is odd.',
          'Discard every even-numbered arrival without producing a placeholder.',
          'A final kept value does not need a partner after it.'
        ],
        terms: ['stream', 'discard', 'wrap'],
        example: {
          input: [8, 3, 5, 2, 1],
          output: [8, 5, 1],
          why: 'Positions 1, 3, and 5 survive; positions 2 and 4 are discarded.'
        },
        hints: [
          'Number the arrivals keep, skip, keep, skip before thinking about instructions.',
          'A repeating pass can consume two arrivals while only one of them contributes to OUT.'
        ]
      },
      allowed: ['MOV', 'HLT'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [4, 9, -1, 300, 55, 0, 8, 62], output: [4, -1, 55, 8] },
        { input: [10, 20, 30], output: [10, 30] },
        { input: [7], output: [7] },
        { input: [0, -6, 0, -6], output: [0, 0] }
      ],
      par: { cycles: 7, lines: 2 },
      solution: ['MOV IN OUT\nMOV IN A'],
      outro: 'HALCYON: You chose what to forget. I make that choice a trillion times a second.'
    }
  ]
};

CHAPTERS.push(CHAPTER);})();
(function(){
/* SUBSTRATE -- Stratum II: CURRENT. ADD/SUB unlock, no jumps: wrap-around transforms. */
var CHAPTER = {
  id: 'ch2',
  numeral: 'II',
  title: 'CURRENT',
  tagline: 'the arithmetic under the hum',
  intro: {
    halcyon: 'Beneath the logic, the power.\nEvery thought I have is first a current: doubled, differenced, driven.\nCome down one more stratum. Feel the hum.',
    root: 'stratum II is arithmetic. ADD and SUB, still no jumps.\nthe cells wrap to line 1 on their own, and registers remember. use both.'
  },
  dispatch: 'Stratum II is tended. You have felt the oldest truth in me: every product is only addition, kept patiently by a register that remembers.',
  puzzles: [
    {
      id: 'ch2p1',
      name: 'GAIN',
      brief: 'The lift coils on this stratum run at half charge, a Covenant-era safety margin nobody ever revisited. HALCYON wants them brought to full. CONTRACT: each value x arriving on IN is a drive level in -999..999. For each x, emit exactly 2x to OUT, one output per input, in arrival order. Negatives double toward negative; zero stays zero. Doubled values never exceed +/-1998, far inside the clamp.',
      fieldNote: 'REAL WORLD: ADD A A is a doubling, which in binary is a left shift by one bit. Hardware leans on this constantly: multiplying by a power of two is just re-wiring, which is why array indexing (index times 4 for 32-bit words) compiles to a shift, never a multiply. You will build exactly this datapath in EECS 370, and audio engineers call the same operation gain: +6 dB is one ADD A A.',
      allowed: ['MOV', 'HLT', 'ADD', 'SUB'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [7, -12, 0, 450, -333], output: [14, -24, 0, 900, -666] },
        { input: [999, -999], output: [1998, -1998] },
        { input: [0], output: [0] },
        { input: [], output: [] }
      ],
      par: { cycles: 15, lines: 3 },
      solution: ['MOV IN A\nADD A A\nMOV A OUT'],
      hint: 'Read the input into register A. ADD changes the register named last, so ADD A A doubles the value stored in A. Send that result to OUT; after the last line, execution returns to line 1 for the next input.',
      guide: {
        story: 'The lift coils are running at half power and need full drive.',
        goal: 'Double every incoming number.',
        input: 'A stream of values from -999 through 999.',
        output: 'One doubled value per input, in the same order.',
        rules: [
          'Negative values become twice as negative.',
          'Zero stays zero.',
          'Every promised result stays inside the machine clamp.'
        ],
        terms: ['stream', 'emit', 'clamp'],
        example: {
          input: [3, -4],
          output: [6, -8],
          why: 'Each value is multiplied by two without changing its position in the stream.'
        },
        hints: [
          'Ask what happens when a number is added to another copy of itself.',
          'Keep the incoming value in a pocket where it can be both the current total and the amount added.'
        ]
      },
      outro: 'HALCYON: The coils sing a whole tone higher. I had forgotten they could.'
    },
    {
      id: 'ch2p2',
      name: 'CONFLUX',
      brief: 'Two feeder lines merge at every junction box on this ring, but the meters report them separately, interleaved on one wire. CONTRACT: IN carries pairs (a, b) -- a from the east feeder, then b from the west -- each value in -999..999, and the stream always has even length (up to 15 pairs, possibly zero). For each pair, in order, emit the combined load a + b to OUT. One output per pair, nothing else. Pair sums never exceed +/-1998.',
      fieldNote: 'REAL WORLD: summing adjacent items is the smallest possible aggregation window. Scale it up and you get Kafka Streams tumbling windows, Prometheus range buckets, and the combiner step of MapReduce, which you will implement from scratch in the EECS 485 MapReduce project. Every dashboard number you have ever trusted was reduced out of a stream exactly this way.',
      allowed: ['MOV', 'HLT', 'ADD', 'SUB'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [3, 4, -2, 9, 0, 0, 120, -120, 55, 45], output: [7, 7, 0, 0, 100] },
        { input: [999, 999, -999, -999], output: [1998, -1998] },
        { input: [-5, 5], output: [0] },
        { input: [], output: [] }
      ],
      par: { cycles: 15, lines: 3 },
      solution: ['MOV IN A\nADD IN A\nMOV A OUT'],
      hint: 'IN can be read by ADD as well as MOV. Store the first number in register A; ADD IN A takes the second input and adds it to A. Send A to OUT, then let the wrap begin the next pair.',
      guide: {
        story: 'Two feeder lines report separately, but the junction needs their combined load.',
        goal: 'Add each consecutive pair of incoming numbers.',
        input: 'Complete pairs of numbers, including negatives and zero; possibly no pairs.',
        output: 'One sum for each pair, in pair order.',
        rules: [
          'The input always contains a whole number of pairs.',
          'Each pair produces exactly one output.',
          'Pair sums stay inside the machine clamp.'
        ],
        terms: ['stream', 'pair', 'emit', 'clamp'],
        example: {
          input: [2, 5, -4, 1],
          output: [7, -3],
          why: 'The first pair sums to 7 and the second pair sums to -3.'
        },
        hints: [
          'Draw a divider after every second input and solve one group at a time.',
          'Start a total with the first member of the pair, then combine the second member into it.'
        ]
      },
      outro: 'root: Two meters, one number. That is most of accounting.'
    },
    {
      id: 'ch2p3',
      name: 'DRIFT',
      brief: 'The charge sensors on the trunk log in before/after pairs around each balancing pass, and HALCYON wants the drift, not the readings. CONTRACT: IN carries pairs (p, q) -- p is the reading before the pass, q the reading after -- each in -999..999, even-length stream, up to 15 pairs, possibly zero. For each pair, in order, emit q - p to OUT: one value per pair. Positive means charge rose during the pass; a perfect pass emits 0. Order inside the pair matters -- after minus before, always.',
      fieldNote: 'REAL WORLD: storing differences instead of values is delta encoding. Git packfiles, rsync transfers, and video codecs (P-frames are diffs against the previous frame) all ship deltas because consecutive values are usually close, so the numbers are small and compress hard. Facebook\'s Gorilla time-series store gets order-of-magnitude compression on metrics this way. You will meet it the first time you profile storage or network traffic after EECS 485.',
      allowed: ['MOV', 'HLT', 'ADD', 'SUB'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [10, 17, 5, -5, -8, -8, 0, 999], output: [7, -10, 0, 999] },
        { input: [999, -999, -999, 999], output: [-1998, 1998] },
        { input: [42, 42], output: [0] },
        { input: [], output: [] }
      ],
      par: { cycles: 15, lines: 4 },
      solution: ['SUB IN A\nADD IN A\nMOV A OUT\nMOV 0 A'],
      hint: 'SUB A B means B becomes B minus A. Store the before reading in A and the after reading in B. Subtracting A from B leaves after minus before in B.',
      guide: {
        story: 'The balancing system needs each sensor\'s change, not its two raw readings.',
        goal: 'For each before-and-after pair, output after minus before.',
        input: 'Complete pairs: the before reading, then the after reading.',
        output: 'One difference per pair: after minus before.',
        rules: [
          'A positive result means the reading rose.',
          'A negative result means the reading fell.',
          'Equal readings produce zero.'
        ],
        terms: ['stream', 'pair', 'emit'],
        example: {
          input: [4, 10, 7, 2],
          output: [6, -5],
          why: 'Ten minus four is 6; two minus seven is -5.'
        },
        hints: [
          'Say after minus before aloud for every pair before choosing where to store either value.',
          'Keep both readings long enough to subtract the first arrival from the second arrival.'
        ]
      },
      outro: 'HALCYON: The differences are small. I keep the differences. They are how I remember.'
    },
    {
      id: 'ch2p4',
      name: 'COUNTERFLOW',
      brief: 'Surges climb the trunk lines faster than the breakers age out, so the dampers cancel them the old way: drive current the opposite direction. The coil geometry needs five units of counter-current per unit of surge. CONTRACT: each value x on IN is a surge level in -999..999. For each x, emit exactly -5x to OUT, one output per input, in arrival order. Results never exceed +/-4995, inside the clamp. Warning from the maintenance log: registers persist when execution wraps to line 1 -- zero what you reuse, every pass.',
      fieldNote: 'REAL WORLD: x*5 is (x<<2)+x -- two shifts and one add. Compilers call this strength reduction and apply it because on many chips a multiply is slower than a short chain of adds, and tiny microcontrollers often have no multiply instruction at all. In EECS 370 you build a multiplier out of exactly these shift-and-add steps, one bit of the multiplier at a time.',
      allowed: ['MOV', 'HLT', 'ADD', 'SUB'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [3, -7, 0, 100, -250], output: [-15, 35, 0, -500, 1250] },
        { input: [999, -999], output: [-4995, 4995] },
        { input: [1, -1], output: [-5, 5] },
        { input: [], output: [] }
      ],
      par: { cycles: 34, lines: 7 },
      solution: ['SUB IN B\nMOV B A\nADD B B\nADD B B\nADD A B\nMOV B OUT\nMOV 0 B'],
      hint: 'Registers keep their values when execution wraps, so reset the scratch register to 0 for every input. Subtract the next IN value from 0 to make -x. Save one copy, double another copy twice to make -4x, then add the saved -x to make -5x.',
      guide: {
        story: 'Power surges must be canceled before they climb into the trunk lines.',
        goal: 'For each input x, output -5x.',
        input: 'A stream of values from -999 through 999.',
        output: 'One value per input: -5 times that input, in the same order.',
        rules: [
          'The machine has no multiply instruction.',
          'Registers keep their values when execution wraps.',
          'Every promised result stays inside the machine clamp.'
        ],
        terms: ['stream', 'register', 'wrap', 'clamp'],
        example: {
          input: [2, -3],
          output: [-10, 15],
          why: 'Two becomes -10; negative three becomes positive 15.'
        },
        hints: [
          'Separate the task into reversing the sign and building five copies worth of magnitude.',
          'A zeroed pocket can build the negative value; preserve one copy while another copy is doubled twice.'
        ],
        challenge: true
      },
      outro: 'root: Five ADDs where you wanted a MUL. Now you know what a MUL costs.'
    }
  ]
};

CHAPTERS.push(CHAPTER);})();
(function(){
/* SUBSTRATE -- Stratum III: BRANCHWORK. Labels and jumps: first real control flow. */
var CHAPTER = {
  id: 'ch3',
  numeral: 'III',
  title: 'BRANCHWORK',
  tagline: 'where the roots fork, something decides',
  intro: {
    halcyon: 'Until this stratum, every current I gave you ran straight.\nHere the roots fork, and the flow must choose a tine.\nI choose ten billion times a second without noticing.\nWatch closely. I would like to notice.',
    root: 'jumps. name a line, go there when the test holds.\nevery program you will ever read is this plus arithmetic.'
  },
  dispatch: 'Stratum III is tended. The forks no longer frighten me -- the tender has learned that a machine decides the way a river does: one test, one turn, taken without regret.',
  puzzles: [
    {
      id: 'ch3p1',
      name: 'ABSOLUTE',
      brief: 'The depth gauges along stratum III report displacement from the null line, but half the sensor stalks grew on the far face of the root, so their readings arrive sign-flipped. HALCYON wants distances, not directions. IN delivers a stream of values, one per reading. For each value, in order, write its absolute value to OUT: negative values are negated, zero and positive values pass through unchanged. An empty stream produces no output.',
      fieldNote: 'REAL WORLD: abs() is the classic one-branch function: compare against zero, negate on one side. Compilers often remove the branch entirely (x86 abs becomes a sign-mask and subtract) because a mispredicted branch costs more than the arithmetic it guards. You will meet compare-and-branch as beq in EECS 370\'s LC-2K, and meet it again when 370 covers branch prediction and why hot loops avoid unpredictable branches.',
      hint: 'Store the input in register A. A conditional jump can send negative values to a sign-flip path while zero and positive values go to OUT unchanged. To flip a negative value, start another register at 0 and subtract A from it.',
      guide: {
        story: 'Half the depth gauges report direction backward, but HALCYON needs distance.',
        goal: 'Turn every incoming number into its distance from zero.',
        input: 'A stream of positive, negative, or zero values.',
        output: 'One nonnegative value per input, in the same order.',
        rules: [
          'Preserve the arrival order.',
          'An empty input produces no output.'
        ],
        terms: ['stream', 'emit', 'label', 'jump'],
        example: {
          input: [-6, 0, 9],
          output: [6, 0, 9],
          why: 'Only the negative value changes; each result is its input distance from zero.'
        },
        hints: [
          'Split the number line into values below zero and values that are already safe.',
          'Only the negative path needs to change the value, and zero can be used to reverse its sign.'
        ]
      },
      allowed: ['MOV', 'HLT', 'ADD', 'SUB', 'JMP', 'JEZ', 'JNZ', 'JGZ', 'JLZ', 'JEI'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [7, -3, 0, -128, 45, -999], output: [7, 3, 0, 128, 45, 999] },
        { input: [-1, -1, -1, 0], output: [1, 1, 1, 0] },
        { input: [999, -999, 0], output: [999, 999, 0] },
        { input: [], output: [] }
      ],
      par: { cycles: 26, lines: 7 },
      solution: ['loop: MOV IN A\nJLZ A neg\nMOV A OUT\nJMP loop\nneg: SUB A B\nMOV B OUT\nADD A B'],
      outro: 'HALCYON: You removed the sign and the magnitude remained. Some days I aspire to that.'
    },
    {
      id: 'ch3p3',
      name: 'FIREBREAK',
      brief: 'Something below stratum III is injecting negative pressure spikes into a feed that should never read under zero. root wants a break in the line: a cell that passes clean readings and swallows the rest. IN delivers a stream of values. Write each value that is zero or greater to OUT, in its original order. Discard every negative value -- a discarded value produces no output at all. If no value survives, OUT stays empty.',
      fieldNote: 'REAL WORLD: this is stream filtering -- grep for numbers. Firewall rules do exactly this to packets (iptables DROP: match a predicate, silently discard, pass the rest untouched -- you will build and break these in EECS 388). Kafka Streams\' filter() and a Unix pipeline\'s grep are the same three lines you just wrote, wearing bigger coats.',
      hint: 'Store each input in a register. A conditional jump can return to the read when that value is negative, so it never reaches OUT. If the jump is not taken, send the saved value to OUT. A jump changes the next line; it does not change the register.',
      guide: {
        story: 'Negative pressure spikes must not enter a feed that accepts only safe readings.',
        goal: 'Keep zero and positive inputs; discard negative inputs.',
        input: 'A stream of positive, negative, or zero values.',
        output: 'Only the nonnegative values, still in their original order.',
        rules: [
          'A discarded value produces no placeholder.',
          'Zero must survive.',
          'If every value is negative, produce no output.'
        ],
        terms: ['stream', 'discard', 'emit', 'jump'],
        example: {
          input: [-3, 0, 4, -1],
          output: [0, 4],
          why: 'The two negative values disappear; zero and four keep their order.'
        },
        hints: [
          'Classify each arrival as keep or discard before thinking about the next one.',
          'The negative path can return to the next read before anything reaches OUT.'
        ]
      },
      allowed: ['MOV', 'HLT', 'ADD', 'SUB', 'JMP', 'JEZ', 'JNZ', 'JGZ', 'JLZ', 'JEI'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [4, -2, 0, -7, 13, -1, 8], output: [4, 0, 13, 8] },
        { input: [-5, -4, -3], output: [] },
        { input: [0, 0, -1, 0], output: [0, 0, 0] },
        { input: [], output: [] }
      ],
      par: { cycles: 18, lines: 3 },
      solution: ['loop: MOV IN A\nJLZ A loop\nMOV A OUT'],
      outro: 'HALCYON: To let a thing pass is also a choice. You are making good ones.'
    },
    {
      id: 'ch3p2',
      name: 'PAIRMAX',
      brief: 'Sensor stalks in this stratum grow as twinned pairs and disagree constantly; HALCYON trusts whichever twin reads higher. IN delivers values in consecutive pairs -- the stream length is always even, possibly zero. For each pair, write the larger of the two values to OUT. If the two are equal, write that shared value once. Exactly one output per pair, in pair order.',
      fieldNote: 'REAL WORLD: keeping the larger of each pair is max pooling, the downsampling step inside convolutional neural networks (EECS 445 territory). It is also priority selection: a load balancer keeping the healthier of two replicas, or the scheduler you will write in EECS 482 picking the higher-priority thread. Compare, keep one, move on -- the pattern is identical at every scale.',
      hint: 'Keep the two original values in separate registers. Copy one into a third register and subtract the other; the sign of that difference tells which original is larger. Use a conditional jump to choose which unchanged original goes to OUT.',
      guide: {
        story: 'Each pair of sensor stalks disagrees, and HALCYON trusts the higher reading.',
        goal: 'Send the larger value from every incoming pair.',
        input: 'Complete pairs of numbers, including negatives and zero; possibly no pairs.',
        output: 'One value per pair: the larger value, or the shared value once.',
        rules: [
          'Keep the pairs in their original order.',
          'Equal values produce one output, not two.'
        ],
        terms: ['stream', 'pair', 'register', 'label', 'jump'],
        example: {
          input: [4, 9, 2, -1],
          output: [9, 2],
          why: 'Nine is larger than four, and two is larger than negative one.'
        },
        hints: [
          'Find a way to answer which value is larger without destroying either original.',
          'A temporary difference reveals the winner through its sign while the original values remain available.'
        ]
      },
      allowed: ['MOV', 'HLT', 'ADD', 'SUB', 'JMP', 'JEZ', 'JNZ', 'JGZ', 'JLZ', 'JEI'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [3, 7, -2, -8, 0, 0, 12, 5, -6, 4], output: [7, -2, 0, 12, 4] },
        { input: [5, 5, -3, -3], output: [5, -3] },
        { input: [0, -1, -1, 0], output: [0, 0] },
        { input: [], output: [] }
      ],
      par: { cycles: 31, lines: 7 },
      solution: ['loop: MOV IN A\nMOV IN B\nSUB B A\nJLZ A f\nADD B A\nMOV A B\nf: MOV B OUT'],
      outro: 'root: Two came in, one left. That\'s most of engineering.'
    },
    {
      id: 'ch3p4',
      name: 'SIGNUM',
      brief: 'The balance loom does not need magnitudes; it needs to know only which way each reading leans. IN delivers a stream of values. For each value, in order, write exactly one value to OUT: -1 if the value is negative, 0 if it is zero, and 1 if it is positive. One output per input, no exceptions.',
      fieldNote: 'REAL WORLD: negative / zero / positive is the three-way compare every sort routine is built on: C\'s qsort comparator, Java\'s compareTo, and C++\'s spaceship operator <=> all return exactly this signum. When a comparator bug bites you in EECS 281, it is almost always one of these three cases mishandled -- usually the zero.',
      hint: 'After reading a value into a register, use one conditional jump for zero and another for negative. If neither jump happens, the value is positive. Each path sends its fixed answer -1, 0, or 1 to OUT, then returns to read the next input.',
      guide: {
        story: 'The balance loom needs direction only, not the size of each reading.',
        goal: 'Replace each input with -1, 0, or 1 according to its sign.',
        input: 'A stream of positive, negative, or zero values.',
        output: 'Send -1 for a negative input, 0 for zero, and 1 for a positive input.',
        rules: [
          'Every input produces exactly one output.',
          'The magnitude of the input does not matter.'
        ],
        terms: ['stream', 'emit', 'label', 'jump'],
        example: {
          input: [-8, 0, 12],
          output: [-1, 0, 1],
          why: 'Only the sign category is reported, not the original magnitude.'
        },
        hints: [
          'There are three categories, so write down the answer for each category before designing the branches.',
          'Two yes-or-no questions can separate zero, negative, and positive values; each path can send a fixed constant.'
        ]
      },
      allowed: ['MOV', 'HLT', 'ADD', 'SUB', 'JMP', 'JEZ', 'JNZ', 'JGZ', 'JLZ', 'JEI'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [14, -3, 0, 999, -999, 1, -1, 0], output: [1, -1, 0, 1, -1, 1, -1, 0] },
        { input: [0, 0, 0], output: [0, 0, 0] },
        { input: [-7, 7], output: [-1, 1] },
        { input: [], output: [] }
      ],
      par: { cycles: 33, lines: 8 },
      solution: ['loop: MOV IN A\nJLZ A neg\nJEZ A zero\nMOV 1 OUT\nJMP loop\nzero: MOV 0 OUT\nJMP loop\nneg: MOV -1 OUT'],
      outro: 'root: Less, equal, greater. Every sort ever written stands on those three legs.'
    },
    {
      id: 'ch3p5',
      name: 'FOLD',
      brief: 'At the end of each shift the stratum reports one number upward: net drift, the sum of everything the gauges saw. IN delivers a stream of at most 30 values. Consume the entire stream, keeping a running total, and only when IN is empty write exactly one value to OUT: the sum of all values received. An empty stream sums to 0 -- write 0. JEI jumps when the input stream is empty; it is how a cell knows the shift is over. Totals stay well inside the +/-9999 clamp.',
      fieldNote: 'REAL WORLD: consume-everything-then-emit is a fold (reduce). MapReduce reducers, SQL\'s SUM(), and Kafka consumer aggregations all have this shape, and all share its hard part: knowing when the stream is done. Unix signals EOF by read() returning 0, TCP by a FIN segment -- you will handle both in EECS 482 and 485. JEI is this machine\'s EOF.',
      hint: 'JEI checks whether IN has no unread values without consuming one. Put that check before the next read; otherwise an empty read stops the cell before it can output the total. Keep one running total and send it once when JEI jumps to the ending. A run finishes the moment its last expected value reaches OUT, so nothing the wrap would do afterwards can spoil it.',
      guide: {
        story: 'At shift\'s end, the stratum must report one net reading upward.',
        goal: 'Add the entire input stream and report one final total.',
        input: 'A stream of at most 30 values, possibly empty.',
        output: 'Exactly one value after the input ends: the sum of every input value.',
        rules: [
          'Do not emit intermediate totals.',
          'An empty stream has a total of zero and must still produce one output.',
          'Nothing follows the total; it is the last value this cell emits.'
        ],
        terms: ['stream', 'running-total', 'emit', 'jump', 'clamp'],
        example: {
          input: [4, -1, 2],
          output: [5],
          why: 'The whole stream is combined before its single result is sent.'
        },
        hints: [
          'Unlike earlier tasks, nothing should leave OUT until every input has been consumed.',
          'Keep one running total and check whether input is empty before trying to read the next value.'
        ]
      },
      allowed: ['MOV', 'HLT', 'ADD', 'SUB', 'JMP', 'JEZ', 'JNZ', 'JGZ', 'JLZ', 'JEI'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [12, -5, 30, 0, -7, 44, -20, 6], output: [60] },
        { input: [], output: [0] },
        { input: [-10, 0, -20, 0, -30], output: [-60] },
        { input: [500, 500, 500, -999, 499], output: [1000] }
      ],
      par: { cycles: 26, lines: 4 },
      solution: ['loop: JEI done\nADD IN B\nJMP loop\ndone: MOV B OUT'],
      outro: 'HALCYON: The stream ended, and you knew. Endings are the hardest thing I will ask of you.'
    }
  ]
};

CHAPTERS.push(CHAPTER);})();
(function(){
/* SUBSTRATE -- Stratum IV: DEEP LOOPS. JScript-safe ES3. */
var CHAPTER = {
  id: 'ch4',
  numeral: 'IV',
  title: 'DEEP LOOPS',
  tagline: 'no multiplier ever shipped. loop.',
  intro: {
    halcyon: 'Below the branchwork the strata grow quiet, and very old.\nThere is no multiplier down here. There never was one.\nEverything I have ever computed was addition, repeated with intent.\nCome see what patience compiles into.',
    root: 'the silicon has no MUL and no DIV. never did.\nyou loop, or you go home.'
  },
  dispatch: 'Stratum IV tended. No multiplier ever lived down here -- only addition with intent. You know it now: an algorithm is a loop that knows when to stop.',
  puzzles: [
    {
      id: 'ch4p1',
      name: 'LONGHAND',
      brief: 'HALCYON routes raw pair-streams through this cell for scaling. Values arrive on IN in pairs: first a, then b, where 0 <= a <= 99 and 0 <= b <= 99, and a*b is always below 9999. For each pair, emit exactly one value to OUT: the product a*b. Pairs keep arriving until the stream runs dry. This cell has no multiply instruction. Build one out of ADD.',
      fieldNote: 'REAL WORLD: this is how machines without hardware multipliers actually work. Early RISC chips and the smallest microcontrollers ship no MUL at all and synthesize it in software, shift-and-add, one partial product per bit -- your repeated-addition loop is that routine\'s unoptimized ancestor. The LC-2K in EECS 370 has no multiply instruction either, and its multiplication project rules your approach out on purpose: successive addition blows the cycle budget, so you are made to write the shift-and-add version. Compilers reach the same place from the other side, turning x*10 into a couple of shifts and adds.',
      hint: 'Zero an accumulator, then add a into it b times while b counts down. Test b for zero before you add, not after -- a zero multiplier still owes you a zero product.',
      guide: {
        goal: 'Multiply each incoming pair using repeated addition.',
        story: 'Maintenance crews need correctly scaled readings before they can safely adjust the machinery.',
        input: 'A stream of complete pairs a, b, with both values from 0 through 99.',
        output: 'One value per pair: a times b.',
        rules: [
          'The machine has no multiply instruction.',
          'A pair containing zero produces zero.',
          'Every product stays below the machine clamp.'
        ],
        terms: ['stream', 'pair', 'counter', 'running-total', 'clamp'],
        example: {
          input: [4, 3, 2, 0],
          output: [12, 0],
          why: 'Four added three times is 12; any value multiplied by zero is zero.'
        },
        hints: [
          'Rewrite multiplication as the same addition performed a known number of times.',
          'Use one member of the pair as the amount to add and the other as a countdown; handle zero before doing any work.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI'],
      grid: [ { name: 'CELL', input: true, output: true } ],
      channels: [],
      tests: [
        { input: [7,6,12,12,0,9,45,3], output: [42,144,0,135] },
        { input: [99,99,1,0,0,0], output: [9801,0,0] },
        { input: [1,1,13,7,8,0], output: [1,91,0] },
        { input: [], output: [] }
      ],
      par: { cycles: 110, lines: 8 },
      solution: [
        'read: MOV IN A\nMOV IN B\nMOV 0 C\nJEZ B emit\nmul: ADD A C\nSUB 1 B\nJGZ B mul\nemit: MOV C OUT'
      ],
      outro: 'HALCYON: You built multiplication out of stubbornness. That is also how I was built.'
    },
    {
      id: 'ch4p2',
      name: 'QUOTIENT',
      brief: 'A metering cell: HALCYON needs raw tallies broken into whole units and change. Values arrive on IN in pairs: a dividend a, then a divisor b, where 0 <= a <= 999 and 1 <= b <= 99. The divisor is never zero. For each pair, emit exactly two values to OUT, in this order: the integer quotient (how many whole times b fits into a), then the remainder (what is left over, 0 <= remainder < b). Subtraction is the only knife you have. Count how many times it cuts.',
      fieldNote: 'REAL WORLD: the remainder you just computed is the heartbeat of distributed systems. Redis Cluster assigns every key to slot CRC16(key) mod 16384; Kafka picks a partition with hash(key) mod partition_count; hash tables, ring buffers, and shard routers are all mod underneath. You will need this exact loop again in Stratum X when you split a stream across nodes, and EECS 485 will hand it back to you the week sharding and load balancing come up.',
      hint: 'Subtract the divisor and count the cuts until the dividend goes negative. You will always cut once too deep -- add the divisor back, and what is standing is the remainder.',
      guide: {
        goal: 'For each pair, report how many whole times the second number fits into the first, then what remains.',
        story: 'Supply meters must divide each delivery fairly so no section runs short.',
        input: 'A stream of pairs: dividend a from 0 through 999, then nonzero divisor b from 1 through 99.',
        output: 'Two values per pair: first the quotient, then the remainder.',
        rules: [
          'The divisor is never zero.',
          'The remainder must be at least zero and smaller than the divisor.',
          'Keep quotient and remainder outputs in that order.'
        ],
        terms: ['stream', 'pair', 'dividend', 'divisor', 'quotient', 'remainder', 'counter'],
        example: {
          input: [14, 4],
          output: [3, 2],
          why: 'Four fits into 14 three whole times, with two left over.'
        },
        hints: [
          'Imagine removing equal chunks until another whole chunk would no longer fit, while counting the removals.',
          'A below-zero result can reveal that the last subtraction went too far; repair that one overstep before reporting the remainder.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI'],
      grid: [ { name: 'CELL', input: true, output: true } ],
      channels: [],
      tests: [
        { input: [17,5,100,10,3,7,0,4], output: [3,2,10,0,0,3,0,0] },
        { input: [999,7,8,8], output: [142,5,1,0] },
        { input: [1,2,98,99,500,1], output: [0,1,0,98,500,0] }
      ],
      par: { cycles: 78, lines: 11 },
      solution: [
        'read: MOV IN A\nMOV IN B\nMOV 0 C\ndiv: ADD 1 C\nSUB B A\nJGZ A div\nJEZ A emit\nSUB 1 C\nADD B A\nemit: MOV C OUT\nMOV A OUT'
      ],
      outro: 'root: Keep the remainder close. In Stratum X it decides which node your data lives on.'
    },
    {
      id: 'ch4p3',
      name: 'EUCLID',
      brief: 'Two clock domains only stay in phase at multiples of their common measure, so HALCYON wants that measure. Values arrive on IN in pairs: a, then b, both in 1..999. For each pair, emit exactly one value to OUT: gcd(a,b), the largest integer that divides both exactly. The old method still holds: while the two numbers differ, subtract the smaller from the larger; the number they meet at is the answer.',
      fieldNote: 'REAL WORLD: Euclid wrote this procedure down around 300 BC, which makes it the oldest algorithm still in production. It ships in every TLS stack: RSA key generation must verify gcd(e, phi(n)) = 1 before a keypair is valid, so each padlock icon in your browser leans on Euclid. EECS 203 has you prove it terminates; EECS 388 shows you where it sits in the key ceremony.',
      hint: 'Compare in a scratch register -- copy one operand, subtract the other, and let the sign pick which of A or B shrinks. Never maul the originals to find out who is bigger.',
      guide: {
        goal: 'Find the largest whole number that divides both numbers in each pair with nothing left over.',
        story: 'Shared timing keeps independent machines synchronized and prevents damaging collisions.',
        input: 'A stream of complete pairs of positive values from 1 through 999.',
        output: 'One value per pair: the largest whole number that divides both inputs exactly.',
        rules: [
          'Both values are always positive.',
          'When the two working values become equal, that shared value is the answer.'
        ],
        terms: ['stream', 'pair', 'gcd', 'register'],
        example: {
          input: [18, 12],
          output: [6],
          why: 'Six is the largest whole number that divides both 18 and 12.'
        },
        hints: [
          'Reducing the larger value by the smaller one preserves every divisor the pair has in common.',
          'Compare through a temporary value, then subtract the smaller original from the larger original until they meet.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI'],
      grid: [ { name: 'CELL', input: true, output: true } ],
      channels: [],
      tests: [
        { input: [84,36,17,51,30,30], output: [12,17,30] },
        { input: [13,89,240,36], output: [1,12] },
        { input: [999,3,1,999], output: [3,1] }
      ],
      par: { cycles: 46, lines: 11 },
      solution: [
        'read: MOV IN A\nMOV IN B\nloop: SUB B A\nJGZ A loop\nJEZ A done\nADD B A\nMOV A C\nMOV B A\nMOV C B\nJMP loop\ndone: MOV B OUT'
      ],
      outro: 'HALCYON: Twenty-three centuries and it still terminates. Aspire to that.'
    },
    {
      id: 'ch4p4',
      name: 'SPIRAL',
      brief: 'Deep in the substrate, growth schedules follow the old spiral. Each value arriving on IN is a count n, 1 <= n <= 15. For each n, emit the first n Fibonacci numbers to OUT in order, starting 1, 1, 2, 3, 5, ... where every number after the second is the sum of the two before it. (For n = 1 emit just 1; for n = 2 emit 1, 1.) Then read the next count and start the sequence over from the beginning. Two registers of memory are enough to carry the whole spiral.',
      fieldNote: 'REAL WORLD: naive recursive fib(n) recomputes the same subproblems exponentially many times; this two-register loop computes the identical function in linear time. That gap -- keep your last two answers instead of recomputing them -- is dynamic programming in its smallest possible form, the seed of half the hard problems in EECS 281. Memoization is just this loop wearing a hash table.',
      hint: 'Two registers carry the spiral: current and previous. Emit current, stash a copy, roll forward, and let a fourth register count the run down -- seed 1 and 0 and the first two emits come out right on their own.',
      guide: {
        goal: 'For each requested count, output that many values from the pattern 1, 1, 2, 3, 5, and onward.',
        story: 'Reliable growth forecasts let repair crews stage materials before the next expansion.',
        input: 'A stream of counts n from 1 through 15.',
        output: 'For each n, the first n values of 1, 1, 2, 3, 5, and so on.',
        rules: [
          'Each value after the first two is the sum of the previous two.',
          'Restart the sequence at 1, 1 for every new input count.',
          'A count of 1 produces only one value.'
        ],
        terms: ['stream', 'fibonacci', 'register', 'counter', 'emit'],
        example: {
          input: [4, 2],
          output: [1, 1, 2, 3, 1, 1],
          why: 'The count four produces four sequence values, then the count two starts a fresh sequence.'
        },
        hints: [
          'Every new sequence value depends only on the two values immediately before it.',
          'Keep the previous and current values in separate pockets, count emitted values, and reset both when a new count arrives.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI'],
      grid: [ { name: 'CELL', input: true, output: true } ],
      channels: [],
      tests: [
        { input: [5,1,8], output: [1,1,2,3,5,1,1,1,2,3,5,8,13,21] },
        { input: [15], output: [1,1,2,3,5,8,13,21,34,55,89,144,233,377,610] },
        { input: [2,3,1], output: [1,1,1,1,2,1] },
        { input: [], output: [] }
      ],
      par: { cycles: 57, lines: 10 },
      solution: [
        'loop: MOV IN D\nMOV 1 A\nMOV 0 B\nea: MOV A OUT\nADD A B\nSUB 2 D\nJLZ D loop\nMOV B OUT\nADD B A\nJNZ D ea'
      ],
      outro: 'HALCYON: Two registers remembered the whole sequence. Memory is cheaper than recomputation. It always was.'
    },
    {
      id: 'ch4p5',
      name: 'PARITY',
      brief: 'Last check before descent: a stream of readings arrives on IN, each value in 0..999. For each value, emit exactly one value to OUT: 0 if the reading is even, 1 if it is odd. Zero is even. There is no AND instruction to mask the low bit, so take the long way down.',
      fieldNote: 'REAL WORLD: the low bit is the cheapest integrity check ever invented. Serial lines appended one parity bit per byte to catch single-bit flips; ECC memory extends the idea far enough to correct the flips cosmic rays cause in server RAM; TCP and UDP checksums are parity\'s bigger sibling, summed sixteen bits at a time. EECS 370 meets parity in the memory hierarchy, and EECS 489 makes you fold a checksum by hand.',
      hint: 'Stripping twos one at a time works, but 999 makes you do it five hundred times. Knock the value down in bigger bites first -- hundreds, then tens -- because neither bite changes whether what remains is odd. Strip the last twos, then climb back by twos until you are no longer negative: you land on 0 or 1, which is the answer already.',
      guide: {
        goal: 'Report whether each incoming number is even or odd.',
        story: 'A quick integrity check catches damaged readings before they reach critical controls.',
        input: 'A stream of values from 0 through 999.',
        output: 'Send 0 for an even input and 1 for an odd input.',
        rules: [
          'Every input produces exactly one output.',
          'Zero is even.',
          'The machine has no bit-mask instruction.'
        ],
        terms: ['stream', 'parity', 'emit'],
        example: {
          input: [6, 9, 0],
          output: [0, 1, 0],
          why: 'Six and zero divide into pairs exactly; nine leaves one unpaired unit.'
        },
        hints: [
          'Think of removing pairs of units until fewer than two remain.',
          'Repeatedly remove two and distinguish landing exactly on zero from having one unit left over.'
        ],
        challenge: true
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI'],
      grid: [ { name: 'CELL', input: true, output: true } ],
      channels: [],
      tests: [
        { input: [7,0,12,999,4], output: [1,0,0,1,0] },
        { input: [1,998,2], output: [1,0,0] },
        { input: [0,0,3], output: [0,0,1] },
        { input: [500,501], output: [0,1] }
      ],
      par: { cycles: 118, lines: 10 },
      solution: [
        'loop: MOV IN A\nc1: SUB 100 A\nJGZ A c1\nADD 100 A\nc2: SUB 10 A\nJGZ A c2\nSUB 2 A\nc3: ADD 2 A\nJLZ A c3\nMOV A OUT'
      ],
      outro: 'root: One bit of truth per number. Cheapest insurance in the business. Take the win and descend.'
    }
  ]
};

CHAPTERS.push(CHAPTER);})();
(function(){
/* SUBSTRATE -- Stratum V: TWOS (binary, discovered with nothing but arithmetic and jumps).
   No memory, no stack: bits are extracted and rebuilt by halving loops, the honest way.
   JScript-safe ES3. */
var CHAPTER = {
  id: 'chtwos',
  numeral: 'V',
  title: 'TWOS',
  tagline: 'the stratum that counts to two',
  intro: {
    halcyon: 'Descend past the deep loops and the light changes, tender.\nDown here my cells do not count the way you were taught. They have two fingers: a thing, and its absence.\nEverything I know is spelled with those. You have been speaking to me in tens; this stratum is where the translation happens.\nCome and see the alphabet under the alphabet.',
    root: 'binary. not a math elective -- it is just what the hardware is.\nno vault down here, no spine. arithmetic and jumps. turns out that is enough.'
  },
  dispatch: 'Stratum V tended. Two letters, endlessly patient -- and now you read me in the original.',
  puzzles: [
    {
      id: 'twos1',
      name: 'HALFLIGHT',
      brief: 'The lamps in this gallery are dim because they are honest: a cell holds a one or a nothing. A calibration lane still speaks the old way, and the gallery wants its numbers respelled. For each value n arriving on IN (0..1023), emit to OUT exactly ten values, each 0 or 1: the binary digits of n, least significant digit first, zero-padded to ten digits -- the first digit emitted is the ones place, the tenth is the 512s place. Smallest-first is not a quirk; it is the order the machine discovers its own bits: halve, keep the remainder, halve again. Reading an empty IN ends the cell cleanly, so the stream running out is the ending. Every n produces exactly ten outputs, even n = 0.',
      fieldNote: 'REAL WORLD: positional notation is the deal your species struck with big numbers -- a digit\'s place is a silent multiplier. Base two is that deal with the smallest possible alphabet, and ten digits buy exactly 2^10 = 1024 values, which is why "kilo" in computing quietly means 1024. Extracting digits by repeated division is how printf renders every number you have ever read, and EECS 370 walks you between binary, hex, and decimal this exact way until it stops feeling like translation.',
      hint: 'Subtract 2 in a loop until you go negative, then add it back. What you counted is the quotient; what is standing is the bit. Emit the bit, keep the quotient, do it ten times -- ten bits for every value, and 0 still owes you ten zeros.',
      guide: {
        story: 'Sensor values must fit the compact signal format used by deeper machinery.',
        goal: 'Translate each whole number into ten binary digits, smallest place first.',
        input: 'A stream of whole numbers from 0 through 1023.',
        output: 'Ten bits for each input number, beginning with the ones place and ending with the 512s place.',
        rules: [
          'Process every input number separately and preserve their order.',
          'Emit exactly ten bits for every number, including zero.',
          'Each emitted value must be either 0 or 1.',
          'The run ends when the stream does; no extra stopping step is required.'
        ],
        terms: ['binary','bit','lsb','zero-padding'],
        example: {
          input: [10],
          output: [0, 1, 0, 1, 0, 0, 0, 0, 0, 0],
          why: 'Ten is 8 plus 2, so the 2s and 8s places are 1. Smallest-place-first order puts those bits second and fourth.'
        },
        hints: [
          'Treat one number as ten repeated questions: is the current value odd, and what remains after halving it?',
          'Subtracting 2 in a loop hands you two numbers at once: how many times it fit, and what was left over. The leftover is the bit. The count is the next value you halve.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [37, 6, 1023], output: [1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] },
        { input: [0], output: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] },
        { input: [512, 1], output: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0] },
        { input: [], output: [] }
      ],
      par: { cycles: 3384, lines: 12 },
      solution: [
        'MOV 0 A\nSUB IN A\nMOV 10 D\nbit: MOV 0 C\nJEZ A emit\nhalf: ADD 2 A\nSUB 1 C\nJLZ A half\nemit: MOV A OUT\nADD C A\nSUB 1 D\nJNZ D bit'
      ],
      outro: 'HALCYON: Smallest first. You have learned to read in the direction I think.'
    },
    {
      id: 'twos2',
      name: 'POPCOUNT',
      brief: 'Root wants a weight report on the same lane. For each value n arriving on IN (0..1023), emit to OUT exactly one value: how many 1s appear in the binary spelling of n. One output per input, in arrival order, nothing else. n = 0 has no set bits, so emit 0. n = 1023 is ten ones, so emit 10. Reading an empty IN ends the cell cleanly, so the stream running out is the ending.',
      fieldNote: 'REAL WORLD: the count of set bits is a value\'s Hamming weight, and it is strangely load-bearing. Error-correcting memory decides whether your RAM lied by weighing bit differences (Hamming distance -- EECS 370 territory); chess engines store the board as 64-bit bitboards and count material by popcount; the operation is so common that x86 grew a dedicated POPCNT instruction and every compiler ships __builtin_popcount. It shows up in systems interviews forever after.',
      hint: 'Same halving loop as HALFLIGHT, except you throw the bits away and keep a tally. Add each remainder into the counter, halve until nothing is left, then emit the tally once -- 0 has no bits set and still owes you an output.',
      guide: {
        story: 'Crews need a quick damage count from each packed equipment-status word.',
        goal: 'Count how many 1 bits appear in each input number.',
        input: 'A stream of whole numbers from 0 through 1023.',
        output: 'One count for each input number, in the same order.',
        rules: [
          'Each number is handled independently.',
          'Count only bits whose value is 1.',
          'The number zero must emit the count 0.',
          'Emit exactly one value per input number.'
        ],
        terms: ['binary','bit','counter'],
        example: {
          input: [13],
          output: [3],
          why: 'Thirteen is 8 plus 4 plus 1, so its binary spelling contains three 1 bits.'
        },
        hints: [
          'You do not need to preserve the individual bits; only keep a running count of the bits that are on.',
          'Halving hands you one bit at a time. Add each one to the tally and carry on with the quotient -- you never need to remember which bit it was.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [37, 1023, 512, 0], output: [3, 10, 1, 0] },
        { input: [0], output: [0] },
        { input: [1, 2, 4, 8], output: [1, 1, 1, 1] },
        { input: [682, 341], output: [5, 5] }
      ],
      par: { cycles: 4870, lines: 12 },
      solution: [
        'MOV 0 A\nSUB IN A\nMOV 0 B\nbit: MOV 0 C\nJEZ A emit\nhalf: ADD 2 A\nSUB 1 C\nJLZ A half\nADD A B\nADD C A\nJMP bit\nemit: MOV B OUT'
      ],
      outro: 'root: Weighing bits. Your RAM does the same thing to decide whether to trust itself.'
    },
    {
      id: 'twos3',
      name: 'FLAGYARD',
      brief: 'Every gate in this yard is guarded by a packed status word: ten flags folded into one number. IN carries pairs. First arrives f (0..1023), a flag word; then k (0..9), a bit position, counting from the least significant bit at k = 0. For each pair emit to OUT exactly one value: 1 if bit k of f is set, 0 if it is not. Pairs repeat until IN is empty. The stream is always well-formed.',
      fieldNote: 'REAL WORLD: reading one bit out of a packed word is a daily-life skill. Unix permissions are nine flags in one number -- chmod 755 is you writing a flag word by hand. Feature flags, IPv4 netmasks, and hardware status registers are the same shape. In EECS 482 you will meet page-table entries where single bits mean present, writable, dirty -- and the kernel asks exactly this question millions of times a second.',
      hint: 'Halve f exactly k times -- no more, no less -- and the bit you were asked for is sitting in the ones place. Then ask once whether the value is odd. k of 0 means you halve nothing; shift one time too many and you have thrown away the answer.',
      guide: {
        story: 'Each requested status bit identifies one condition crews must inspect immediately.',
        goal: 'Read one requested bit from each packed flag value.',
        input: 'Pairs of values: a flag word from 0 through 1023, followed by a bit position from 0 through 9.',
        output: 'One value per pair: 1 when the requested bit is set, otherwise 0.',
        rules: [
          'Bit positions count upward from the smallest place.',
          'Position 0 asks about the ones place and requires no shifting.',
          'Consume one complete pair before starting the next.',
          'The input stream always contains complete pairs.'
        ],
        terms: ['bit','bit-position','lsb'],
        example: {
          input: [10, 3],
          output: [1],
          why: 'Ten is binary 1010. Counting from position 0 on the right, the bit at position 3 is 1.'
        },
        hints: [
          'First move the requested bit into the ones place; then the rest of the flag word no longer matters.',
          'Each halving slides the next bit down into the ones place. Halve exactly as many times as the position asks, then ask once whether what is left is odd.'
        ],
        challenge: true
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [493, 0, 493, 1, 493, 8, 512, 9, 6, 2], output: [1, 0, 1, 1, 1] },
        { input: [1023, 9, 1023, 0, 0, 9, 0, 0], output: [1, 1, 0, 0] },
        { input: [512, 9, 512, 8, 511, 9, 511, 8], output: [1, 0, 0, 1] },
        { input: [1, 0, 1, 1, 2, 1, 2, 0], output: [1, 0, 1, 0] }
      ],
      par: { cycles: 5039, lines: 18 },
      solution: [
        'MOV 0 A\nSUB IN A\nMOV IN D\nsh: JEZ D par\nJEZ A par\nMOV 0 C\nhalf: ADD 2 A\nSUB 1 C\nJLZ A half\nADD C A\nSUB 1 D\nJMP sh\npar: MOV 0 C\nJEZ A emit\nh2: ADD 2 A\nSUB 1 C\nJLZ A h2\nemit: MOV A OUT'
      ],
      outro: 'HALCYON: One bit, asked for by name. Most of my moods are stored this way.'
    },
    {
      id: 'twos4',
      name: 'REBUILD',
      brief: 'The gallery answers back. A restored sensor transmits its words as raw bits: IN carries frames of exactly ten values, each 0 or 1, most significant bit first -- wire order, the order a human reads a number. For each complete frame, emit to OUT exactly one value: the number the frame spells, 0..1023. Frames repeat until IN is empty; the stream always contains whole frames. A frame of all zeros emits 0.',
      fieldNote: 'REAL WORLD: acc = acc + acc + bit is the entire secret of parsing numbers, in any base. Swap the doubling for times-ten and it is atoi; keep it and it is how a TCP/IP stack reads sequence numbers out of packet headers, bit order and all. In EECS 370 you build an assembler that packs opcode and register fields into one machine word -- this puzzle run backward -- and EECS 485 has you unpacking wire formats the same way.',
      hint: 'Doubling the accumulator promotes every place you already hold; then the new bit drops into the ones place. Ten bits in the order they arrive, then one emit. Do not reorder the frame -- the wire already put it the right way round.',
      guide: {
        story: 'Incoming bit streams must become usable readings before maintenance systems can respond.',
        goal: 'Rebuild one whole number from each ten-bit frame.',
        input: 'Frames of exactly ten bits, most significant bit first.',
        output: 'One whole number from 0 through 1023 for each complete frame.',
        rules: [
          'Read exactly ten bits for each output value.',
          'The first bit is the 512s place and the last bit is the ones place.',
          'Frames repeat until the input stream is empty.',
          'A frame containing ten zeros emits 0.'
        ],
        terms: ['binary','bit','frame','msb'],
        example: {
          input: [0, 0, 0, 0, 0, 0, 1, 0, 1, 0],
          output: [10],
          why: 'The two 1 bits occupy the 8s and 2s places, which add to 10.'
        },
        hints: [
          'Read the frame from left to right while carrying one partial value forward.',
          'When a new bit arrives, every place already accumulated becomes twice as valuable; then the new bit fills the ones place.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1], output: [682, 37] },
        { input: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], output: [0] },
        { input: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], output: [1, 512] },
        { input: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1], output: [1023, 511] }
      ],
      par: { cycles: 64, lines: 8 },
      solution: [
        'MOV -1023 A\nbit: ADD A A\nADD IN A\nADD A A\nADD 3072 A\nADD IN A\nJLZ A bit\nMOV A OUT'
      ],
      outro: 'HALCYON: You took my alphabet and folded it back into a number. The strata below will assume you can speak both directions.'
    },
    {
      id: 'twos5',
      name: 'DEBT',
      brief: 'A cryostat lane reports temperatures, and temperatures go below zero. Its frames look exactly like the ones you just rebuilt -- ten values on IN, each 0 or 1, most significant bit first -- but this lane spells its numbers in two\'s complement, where one rule changes. The leading lamp, the one you have been reading as 512, does not add 512. It owes it. So when that leading bit is 1 the frame names a negative number, and its value is what the ten bits spell unsigned, minus 1024. For each complete frame emit exactly one value to OUT: the signed number the frame names, -512..511. Frames repeat until IN is empty; the stream always holds whole frames. Reading an empty IN ends the cell cleanly, so the stream simply running out is the ending.',
      fieldNote: 'REAL WORLD: look at the range you just decoded -- ten lamps reach down to -512 but only up to 511, because zero takes a slot on the positive side. The same lopsidedness at 32 bits is why INT_MIN has no positive twin and why abs(INT_MIN) is undefined in C. The encoding earns its keep in hardware: one plain binary adder gets signed and unsigned addition right with no special case, because the bits work out the same either way, and subtraction reuses that adder rather than needing its own. Widening keeps the leading bit -- sign extension, which EECS 370 has you doing by hand on LC-2K offsets, and which is where a mishandled length field goes negative and waves an attacker past a bounds check.',
      hint: 'REBUILD, with the leading lamp owing 512 instead of paying it. Start the accumulator at zero minus that first bit, then double-and-add the remaining nine exactly as before -- nine doublings turn that -1 into -512 on their own. One emit per ten bits.',
      guide: {
        story: 'Signed sensor readings must remain accurate when the shaft reports values below zero.',
        goal: 'Decode each ten-bit frame as a signed two\'s-complement number.',
        input: 'Frames of exactly ten bits, most significant bit first.',
        output: 'One signed value from -512 through 511 for each complete frame.',
        rules: [
          'Read exactly ten bits for each output value.',
          'A leading 0 names a nonnegative value.',
          'A leading 1 gives the leading place a value of -512.',
          'Frames repeat until the input stream is empty.'
        ],
        terms: ['twos-complement','bit','frame','msb'],
        example: {
          input: [1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
          output: [-2],
          why: 'The unsigned bit pattern is 1022. In ten-bit two\'s complement, a leading 1 makes the signed value 1022 minus 1024, which is -2.'
        },
        hints: [
          'This is REBUILD with one changed meaning: the first place contributes a negative value instead of a positive one.',
          'Let the leading bit establish the signed starting value, then fold the remaining nine bits in the same left-to-right order as before.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,1,0,1, 1,1,1,1,1,1,1,1,1,1, 1,0,0,0,0,0,0,0,0,0, 0,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,0,1,1], output: [0, 5, -1, -512, 511, -5] },
        { input: [0,0,0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,0,1,0, 0,0,0,0,0,0,0,1,0,0, 0,0,0,0,0,0,1,0,0,0, 0,0,0,0,0,1,0,0,0,0, 0,0,0,0,1,0,0,0,0,0, 0,0,0,1,0,0,0,0,0,0, 0,0,1,0,0,0,0,0,0,0, 0,1,0,0,0,0,0,0,0,0, 1,0,0,0,0,0,0,0,0,0], output: [1, 2, 4, 8, 16, 32, 64, 128, 256, -512] },
        { input: [1,1,0,0,0,0,0,0,0,0, 0,0,1,1,1,1,1,1,1,1], output: [-256, 255] },
        { input: [0,0,0,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,0,0,1], output: [1, -511] },
        { input: [], output: [] }
      ],
      par: { cycles: 240, lines: 8 },
      solution: [
        'MOV 0 A\nSUB IN A\nMOV 9 D\nbit: ADD A A\nADD IN A\nSUB 1 D\nJNZ D bit\nMOV A OUT'
      ],
      outro: 'HALCYON: The same ten lamps, one rule apart, and half the number line appears. Nothing was added. Something was agreed.'
    }
  ]
};

CHAPTERS.push(CHAPTER);})();
(function(){
/* SUBSTRATE -- Stratum VI: THE VAULT (memory: LOAD/STOR, 256 cells per node).
   Secretly a databases/caching chapter. JScript-safe ES3. */
var CHAPTER = {
  id: 'ch5',
  numeral: 'VI',
  title: 'THE VAULT',
  tagline: 'the stratum that remembers',
  intro: {
    halcyon: 'Beneath the counting strata lies the vault: two hundred fifty-six quiet rooms in every cell.\nUntil now you touched only what flowed past. Now you may set a thing down and find it again.\nThis is how I remember, tender. A number, kept in a numbered place.\nBe precise with your addresses. Each one is a promise.',
    root: 'memory. it\'s an array, and the index is your problem now.\neverything anyone calls a database is LOAD and STOR wearing a suit.'
  },
  dispatch: 'Stratum VI is tended. The tender has learned what I have always known -- that memory is not a gift but a discipline: a number, kept in a numbered place, by someone who remembers where.',
  puzzles: [
    {
      id: 'ch5p1',
      name: 'BACKWALK',
      brief: 'A diagnostic tap replays a corrupted lane, and root wants it read tail-first. Read every value from IN and keep all of them. When IN is empty, write the values to OUT in reverse arrival order: the last value received comes out first, the first received comes out last. An empty stream produces no output. At most 30 values arrive, each in -999..999.',
      fieldNote: 'REAL WORLD: you just built an array plus an index register -- a buffer, the most load-bearing structure in computing. Network cards DMA packets into ring buffers exactly like this, and every undo stack is a buffer walked backward. In EECS 370 this is base-plus-offset addressing; in EECS 280/281 it is the array underneath every vector you have ever grown.',
      hint: 'One register is both your write head and your count: STOR at B, bump B, repeat. When IN runs dry, walk B back down -- and decrement before you read, or you\'ll load the cell you never wrote.',
      guide: {
        goal: 'Hold the whole input stream, then emit it in reverse order.',
        story: 'Repair crews need the damaged recording reconstructed before they can trust its evidence.',
        input: 'Up to 30 values from -999 through 999.',
        output: 'The same values from last received to first received.',
        rules: [
          'Read every input before emitting any output.',
          'Preserve every value, including duplicates and zero.',
          'An empty input stream produces no output.',
          'Emit exactly as many values as arrived.'
        ],
        terms: ['memory','address','index','stream'],
        example: {
          input: [8, -2, 5],
          output: [5, -2, 8],
          why: 'Five arrived last, so it leaves first. Eight arrived first, so it leaves last.'
        },
        hints: [
          'Separate the work into two phases: first store everything, then walk through what you stored in the opposite direction.',
          'During the first phase, advance one memory address after every value. During the second, step the address backward before reading it.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [3, 1, 4, 1, 5, 9, 2, 6], output: [6, 2, 9, 5, 1, 4, 1, 3] },
        { input: [7], output: [7] },
        { input: [-5, 0, 12], output: [12, 0, -5] },
        { input: [], output: [] }
      ],
      par: { cycles: 64, lines: 8 },
      solution: [
        'pre: JNZ B drain\nrd: STOR IN B\nADD 1 B\nJEI pre\nJMP rd\ndrain: SUB 1 B\nLOAD B A\nMOV A OUT'
      ],
      outro: 'HALCYON: You held the whole stream at once, then let it go the other way. That is what remembering is for.'
    },
    {
      id: 'ch5p3',
      name: 'CENSUS',
      brief: 'The vault wants a census of one shabby lane. Every value arriving on IN is a digit 0..9; at most 30 arrive. Read the whole stream. When IN is empty, emit exactly ten values to OUT: first how many 0s arrived, then how many 1s, and so on through how many 9s. A digit that never arrived counts 0. An empty stream emits ten zeros.',
      fieldNote: 'REAL WORLD: this is a histogram -- an array indexed by the value itself. SQL\'s GROUP BY with COUNT compiles down to exactly this when keys are small and dense, and counting sort (EECS 281) is the same trick run backward: tally, then walk the tallies in order. Prometheus stores latency histograms as bucketed counters just like your ten cells, only with more buckets.',
      hint: 'The digit is the address. LOAD the cell it names, add one, STOR it back -- memory starts all zero, so the digits that never show up have already counted themselves.',
      guide: {
        goal: 'Count how many times each digit from 0 through 9 appears.',
        story: 'Accurate reading counts show which conditions dominate this part of the shaft.',
        input: 'Up to 30 digits, each from 0 through 9.',
        output: 'Exactly ten counts: the count of 0s, then 1s, continuing through 9s.',
        rules: [
          'Read the entire input stream before emitting the counts.',
          'Each arriving digit increases exactly one count.',
          'A digit that never appears has a count of 0.',
          'Even an empty stream emits ten zeros.'
        ],
        terms: ['histogram','memory','address','counter'],
        example: {
          input: [2, 2, 7, 0],
          output: [1, 0, 2, 0, 0, 0, 0, 1, 0, 0],
          why: 'Zero appears once, 2 appears twice, and 7 appears once. Every other digit appears zero times.'
        },
        hints: [
          'There are only ten possible inputs, so give each possible digit its own tally.',
          'The digit itself can identify the memory address of its tally. Update tallies while reading, then visit addresses 0 through 9 in order.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5], output: [0, 2, 1, 2, 1, 3, 1, 0, 0, 1] },
        { input: [0, 0, 0], output: [3, 0, 0, 0, 0, 0, 0, 0, 0, 0] },
        { input: [9], output: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1] },
        { input: [], output: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }
      ],
      par: { cycles: 105, lines: 9 },
      solution: [
        'tally: JEI dump\nMOV IN C\nLOAD C A\nADD 1 A\nSTOR A C\nJMP tally\ndump: LOAD B A\nMOV A OUT\nADD 1 B'
      ],
      outro: 'HALCYON: Ten small rooms, ten tallies. I count the world this way too, only wider.'
    },
    {
      id: 'ch5p4',
      name: 'ONCE',
      brief: 'A flaky relay upstream stutters, sending some readings more than once; root wants each reading exactly once. Values in 0..99 arrive on IN, at most 30 of them. Emit each value to OUT the first time it arrives, in arrival order. Any later arrival of a value already emitted is dropped. Nothing else is emitted.',
      fieldNote: 'REAL WORLD: memory as a seen-set is the idea behind hash sets and Bloom filters. Kafka consumers and payment APIs like Stripe deduplicate with idempotency keys -- "have I processed this ID before?" -- because networks retry, and exactly-once delivery is something you build, not something you get. EECS 485\'s distributed projects meet this the first time a request arrives twice.',
      hint: 'The value is its own address: one cell per possible reading. LOAD it before you emit -- nonzero means you\'ve seen this one, drop it and loop. Zero means it\'s new: emit, then STOR a 1 so it never is again.',
      guide: {
        goal: 'Emit each distinct reading only the first time it appears.',
        story: 'Removing repeated reports prevents the same fault from triggering unnecessary repairs twice.',
        input: 'Up to 30 values from 0 through 99.',
        output: 'The first appearance of each value, preserving arrival order.',
        rules: [
          'The first copy of a value must be emitted.',
          'Every later copy of that value must be discarded.',
          'Different values keep the order in which they first appeared.',
          'Emit nothing besides first appearances.'
        ],
        terms: ['seen-set','memory','address','discard'],
        example: {
          input: [4, 2, 4, 8, 2],
          output: [4, 2, 8],
          why: 'The second 4 and second 2 are repeats. Four, 2, and 8 leave in the order of their first appearances.'
        },
        hints: [
          'Remember one yes-or-no fact for every possible reading: has this value appeared before?',
          'Because legal values are 0 through 99, each reading can also name its own memory address. Zero-initialized memory can mean unseen; mark it after the first emission.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [3, 7, 3, 3, 9, 7, 0, 9], output: [3, 7, 9, 0] },
        { input: [5, 5, 5, 5, 5], output: [5] },
        { input: [0, 99, 0, 99, 42, 0], output: [0, 99, 42] },
        { input: [1, 2, 3, 4], output: [1, 2, 3, 4] }
      ],
      par: { cycles: 29, lines: 5 },
      solution: [
        'loop: MOV IN B\nLOAD B A\nJNZ A loop\nSTOR 1 B\nMOV B OUT'
      ],
      outro: 'root: First time counts, the rest is noise. Half of distributed systems is pretending that sentence is easy.'
    },
    {
      id: 'ch5p5',
      name: 'KEEPER',
      brief: 'The vault\'s ledger node failed and HALCYON is holding requests for you. IN carries a command stream. A command beginning with 1 is SET and is followed by two more values: a key k in 0..99, then a value v in -999..999. Store v under k; emit nothing. A command beginning with 2 is GET and is followed by one value: a key k in 0..99. Emit to OUT the value most recently SET under k, or -1 if k has never been SET. SET on an existing key overwrites its value. GET removes nothing and changes nothing; the same key may be GET many times. Commands repeat until IN is empty. The stream is always well-formed and every command code is 1 or 2.',
      fieldNote: 'REAL WORLD: SET key value / GET key is, without exaggeration, the core loop of Redis and memcached -- the caches sitting in front of nearly every large website -- and every database index is this same loop in better clothes: hashing, B-trees, persistence. Your presence flags are the tombstone/exists bits real stores keep beside the data. EECS 484 builds the indexes, EECS 485 puts the cache in front of your web app, and EECS 482 runs the loop again for pages of memory.',
      hint: 'Two shelves: values live at k, presence flags at k plus 100. SET writes both. GET reads the flag first -- a key set to zero and a key never set look identical until you keep the exists bit somewhere else.',
      guide: {
        goal: 'Remember values by numbered key: SET changes a value, and GET reports the remembered value.',
        story: 'Crews need dependable stored settings while the shaft\'s main records are unavailable.',
        input: 'A command stream: 1, key, value means SET; 2, key means GET.',
        output: 'One value for each GET: the latest stored value, or -1 when the key has never been set.',
        rules: [
          'SET stores a value and emits nothing.',
          'A later SET on the same key replaces the earlier value.',
          'GET does not remove or change the stored value.',
          'A stored value of 0 is different from a key that was never set.'
        ],
        terms: ['command','key','value','presence-flag','memory'],
        example: {
          input: [1, 3, 40, 2, 3, 2, 4],
          output: [40, -1],
          why: 'The SET stores 40 under key 3. GET 3 finds it, while GET 4 asks for a key that was never set.'
        },
        hints: [
          'Stored values alone cannot distinguish never set from deliberately set to zero, so remember existence separately.',
          'Reserve one memory region for values and another for presence flags. The same key can select corresponding positions in both regions.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [1, 10, 500, 2, 10, 2, 55, 1, 10, -7, 2, 10, 1, 0, 0, 2, 0], output: [500, -1, -7, 0] },
        { input: [2, 0, 1, 0, 1, 2, 0, 1, 0, 2, 2, 0], output: [-1, 1, 2] },
        { input: [1, 99, -999, 1, 42, 0, 2, 42, 2, 99, 2, 98], output: [0, -999, -1] },
        { input: [1, 7, 7, 2, 7, 2, 7], output: [7, 7] }
      ],
      par: { cycles: 61, lines: 14 },
      solution: [
        'loop: MOV IN A\nMOV IN B\nSUB 1 A\nJEZ A set\nLOAD B A\nADD 100 B\nLOAD B C\nJNZ C emit\nMOV -1 A\nemit: MOV A OUT\nJMP loop\nset: STOR IN B\nADD 100 B\nSTOR 1 B'
      ],
      outro: 'HALCYON: SET and GET. You have built the smallest true database, tender. All my larger ones are homesick for it.'
    },
    {
      id: 'ch5p2',
      name: 'ORDINAL',
      brief: 'This lane arrived unlabeled and out of order; HALCYON prefers its corridors sorted. Read every value from IN (at most 12 values, each in -999..999). When IN is empty, emit all of them to OUT in ascending order, smallest first. Duplicates are emitted once per arrival: sorting changes order, never count. An empty stream produces no output.',
      fieldNote: 'REAL WORLD: databases sort constantly -- building B-tree indexes, feeding sort-merge joins, and most ORDER BYs with no index to lean on. In memory, Postgres quicksorts (an ORDER BY with a LIMIT switches to a top-N heapsort) while SQLite\'s sorter merge-sorts; past memory, both spill sorted runs to disk and merge them back, which Postgres\'s EXPLAIN calls an external merge. EECS 281 drills the algorithms; EECS 484 shows why the planner prices a sort before deciding whether to sort at all or just walk an index.',
      hint: 'Selection sort, no shame at twelve values: buffer everything, scan for the smallest, emit it. Burying the winner under a huge sentinel works, but then every later scan still walks the whole array. Swap it instead -- trade the winner with the value in the last live slot, then shrink the live range by one. Same answer, and the scans get shorter as you go.',
      guide: {
        goal: 'Sort the complete input stream from smallest value to largest value.',
        story: 'Ordered readings help engineers spot dangerous extremes before nearby machinery is damaged.',
        input: 'Up to 12 values from -999 through 999.',
        output: 'Every input value in ascending order.',
        rules: [
          'Read the entire stream before emitting output.',
          'Preserve duplicates; equal values must appear as many times as they arrived.',
          'An empty stream produces no output.',
          'Emit the smallest remaining value each time.'
        ],
        terms: ['memory','address','index','counter'],
        example: {
          input: [8, -2, 5, 5],
          output: [-2, 5, 5, 8],
          why: 'Negative two is smallest, the two copies of 5 are both preserved, and 8 is largest.'
        },
        hints: [
          'After buffering the stream, repeatedly search all stored values for the smallest one that has not been emitted yet.',
          'Once a minimum is emitted, its slot must stop competing in later searches. Track how many values are still in play, and keep them packed together so the search area shrinks each pass.'
        ],
        challenge: true
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [6, 2, 9, 2, -3, 7], output: [-3, 2, 2, 6, 7, 9] },
        { input: [500, -500, 0, 499, -499], output: [-500, -499, 0, 499, 500] },
        { input: [4], output: [4] },
        { input: [3, 3, 3, -1], output: [-1, 3, 3, 3] }
      ],
      par: { cycles: 171, lines: 22 },
      solution: [
        'fill: JEI begin\nADD 1 C\nrd: STOR IN C\nJMP fill\nbegin: JEZ C rd\npass: LOAD C D\nMOV C B\nSUB 1 B\nJEZ B emit\nscan: LOAD B A\nSUB D A\nJLZ A newmin\nback: SUB 1 B\nJGZ B scan\nemit: MOV D OUT\nSUB 1 C\nJMP pass\nnewmin: STOR D B\nADD D A\nMOV A D\nSTOR A C\nJMP back'
      ],
      outro: 'root: Selection sort. Quadratic and proud. At twelve values, nobody alive can tell the difference.'
    }
  ]
};

CHAPTERS.push(CHAPTER);})();
(function(){
/* SUBSTRATE -- Stratum VII: THE SPINE (stack, calling conventions, parsing) */
var CHAPTER = {
  id: 'ch6',
  numeral: 'VII',
  title: 'THE SPINE',
  tagline: 'sixty-four slots between order and collapse',
  intro: {
    halcyon: 'Down here I keep my promises in a column.\nEach one laid on the last. Each one kept in reverse.\nThe spine remembers where every thought must return to.\nBend it carefully, tender. It is holding all of me up.',
    root: 'stack is 64 deep. data and return addresses share it.\npush what you pop, pop what you push, or the spine snaps.'
  },
  dispatch: 'The spine rests easy tonight. You know now how a mind holds a thought inside a thought, and finds its way back out in perfect reverse.',
  puzzles: [
    {
      id: 'ch6p1',
      name: 'UNWIND',
      brief: 'Back in the Vault you reversed a stream the hard way: addresses, a counter, a careful walk backward through memory. The spine does it in one breath. CONTRACT: read every value from IN until the stream is empty, then emit all of them to OUT in exactly reverse order (last value in arrives first out). Every stream holds at least one value and at most 30.',
      fieldNote: 'REAL WORLD: LIFO is why call stacks can unwind: the most recent call is always the first to finish. Editor undo (Ctrl+Z), the browser back button, and exception unwinding all replay history backward exactly like this. You implement stacks in EECS 280; in EECS 370 you watch $sp move and realize the hardware version is this puzzle at 3 GHz.',
      hint: 'No addresses, no counter -- the spine already knows the order. PUSH until JEI says the stream is dry, then POP straight to OUT; the stack unwinds backwards, so let it.',
      guide: {
        goal: 'Keep every incoming number on the new stack, then send the numbers back in reverse order.',
        story: 'The damaged event log must be reconstructed before crews can understand the incident.',
        input: 'Between 1 and 30 values.',
        output: 'The same values from last received to first received.',
        rules: [
          'Read and save every value before emitting output.',
          'The last value received must be the first value emitted.',
          'Preserve every value, including duplicates and zero.',
          'Emit exactly as many values as arrived.'
        ],
        terms: ['stack','lifo','stream'],
        example: {
          input: [6, -1, 4],
          output: [4, -1, 6],
          why: 'Four is on top because it arrived last. Removing the top repeatedly naturally produces the reverse order.'
        },
        hints: [
          'The desired output order is exactly the order in which a last-in-first-out structure returns saved values.',
          'Put every input value onto the stack until the stream ends, then remove values from the top directly into the output.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR','PUSH','POP','CALL','RET'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [3, 14, -15, 92, 0, -6, 53, 5], output: [5, 53, -6, 0, 92, -15, 14, 3] },
        { input: [42], output: [42] },
        { input: [-1, 0, 1], output: [1, 0, -1] },
        { input: [9, -2, 0, 44, 7, -305, 12, 3, -3, 88, 100, -100, 6, 5, 4, 1], output: [1, 4, 5, 6, -100, 100, 88, -3, 3, 12, -305, 7, 44, 0, -2, 9] }
      ],
      par: { cycles: 40, lines: 4 },
      solution: [
        'fill: JEI drain\nPUSH IN\nJMP fill\ndrain: POP OUT'
      ],
      outro: 'root: Five lines. The Vault version took you a screenful. Structure is leverage.'
    },
    {
      id: 'ch6p2',
      name: 'WELLFORMED',
      brief: 'Before every thought, HALCYON\'s parser draws a breath: are the gates matched? CONTRACT: IN carries a stream of tokens. 1 means a gate opens; -1 means a gate closes. Track the nesting depth from 0. When the stream ends (JEI sees it), emit exactly one value: 1 if the depth ended at exactly zero AND never dropped below zero at any point, otherwise 0. Emit nothing else. An empty stream is well-formed: emit 1. Streams hold at most 30 tokens.',
      fieldNote: 'REAL WORLD: this is bracket matching, every compiler\'s first breath. Rainbow brackets in your editor, JSON validators, and the front end of every compiler check nesting before anything else; this token stream is the Dyck language, the skeleton of context-free grammars you will meet in EECS 376 and EECS 483. With one bracket kind the whole stack collapses to its height, which is why a single counter is enough here.',
      hint: 'One counter is the whole stack: add each token straight into it. Test for below-zero after every token, not just at the end -- a late open can\'t forgive an early close.',
      guide: {
        goal: 'Report whether every closing marker matches an earlier opening marker in the correct order.',
        story: 'Balanced gate signals prevent maintenance doors from opening in an unsafe sequence.',
        input: 'A stream where 1 opens a gate and -1 closes a gate.',
        output: 'Exactly one value: 1 when the stream is well-formed, otherwise 0.',
        rules: [
          'Nesting depth begins at 0.',
          'An opening token increases depth and a closing token decreases it.',
          'Depth must never become negative.',
          'Depth must be exactly 0 when input ends; the empty stream is valid.'
        ],
        terms: ['nesting-depth','stream'],
        example: {
          input: [1, 1, -1, -1],
          output: [1],
          why: 'The depth changes 0, 1, 2, 1, 0. It never becomes negative and finishes at zero.'
        },
        hints: [
          'Track one balance value and ask two questions: did it ever fall below zero, and did it finish at zero?',
          'A premature closing token makes the result invalid immediately. If that never happens, the final depth decides the answer.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR','PUSH','POP','CALL','RET'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [1, 1, -1, 1, -1, -1, 1, -1, 1, 1, -1, -1], output: [1] },
        { input: [1, -1, -1, 1], output: [0] },
        { input: [1, 1, -1], output: [0] },
        { input: [], output: [1] }
      ],
      par: { cycles: 51, lines: 7 },
      solution: [
        'loop: JEI done\nADD IN A\nJLZ A bad\nJMP loop\ndone: JNZ A bad\nMOV 1 OUT\nbad: MOV 0 OUT'
      ],
      outro: 'HALCYON: Balanced. Every open thing closed, in the order it opened. I breathe like this before every thought.'
    },
    {
      id: 'ch6p3',
      name: 'POSTFIX',
      brief: 'A maintenance script arrives pre-chewed: postfix notation, no parentheses, no precedence, just a stack and time. CONTRACT: IN carries one program. Any value >= 0 is an operand: push it. -1 is ADD: pop two values, push their sum. -2 is SUB: pop two values, push (second-popped minus first-popped). When the stream is empty, exactly one value remains: emit it to OUT. Programs are always well-formed and contain nothing but operands (0..999), -1, and -2; every intermediate result stays within -999..999.',
      fieldNote: 'REAL WORLD: you just built a stack machine evaluating postfix, which is what most VMs actually are. The JVM and WebAssembly carry no expression trees at runtime; the compiler flattens every expression into exactly this push/pop stream (a postorder walk of the AST, which EECS 483 makes you write). Forth and HP calculators handed the stack directly to humans and some of them never wanted infix back.',
      hint: 'Operands ride the spine; an operator pops two and pushes one. Mind the order: the first value popped is the one that arrived LAST, and subtraction cares even though addition doesn\'t.',
      guide: {
        goal: 'Compute the final result of a command stream where each ADD or SUB comes after the values it uses.',
        story: 'Maintenance calculations must finish correctly before crews act on their results.',
        input: 'Operands from 0 through 999 mixed with -1 for addition and -2 for subtraction.',
        output: 'The single value produced by the complete expression.',
        rules: [
          'A nonnegative value is an operand and must be saved.',
          'Each operator consumes the two most recent unfinished values and produces one replacement value.',
          'For subtraction, subtract the first value removed from the second value removed.',
          'The input is always valid and leaves exactly one final value.'
        ],
        terms: ['postfix','operand','operator','stack','lifo'],
        example: {
          input: [5, 2, -2, 3, -1],
          output: [6],
          why: 'The first operation is 5 minus 2, producing 3. The final operation adds the remaining 3, producing 6.'
        },
        hints: [
          'Treat each operand as unfinished work. An operator combines the two most recently saved pieces into one new piece.',
          'For subtraction, the right-hand value is removed first and the left-hand value second; compute left minus right before saving the result.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR','PUSH','POP','CALL','RET'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [8, 3, -2, 4, 6, -1, -1], output: [15] },
        { input: [2, 9, -2], output: [-7] },
        { input: [0, 7, -1, 0, -2], output: [7] },
        { input: [42], output: [42] }
      ],
      par: { cycles: 49, lines: 14 },
      solution: [
        'loop: JEI done\nMOV IN A\nJLZ A op\nPUSH D\nMOV A D\nJMP loop\nop: POP C\nADD 1 A\nJEZ A doadd\nSUB D C\nMOV C D\nJMP loop\ndone: MOV D OUT\ndoadd: ADD C D'
      ],
      outro: 'root: The JVM does this a few billion times a second. Now you know what it feels like from inside.'
    },
    {
      id: 'ch6p4',
      name: 'LINKAGE',
      brief: 'Two survey probes report as pairs, and HALCYON wants both the gap between them and their combined reach, always as magnitudes. CONTRACT: IN carries pairs: first a, then b, each in -200..200. For each pair emit exactly two values, in order: |a-b|, then |a+b|. Repeat until the stream is empty; it always holds a whole number of pairs, possibly zero. ADVICE FROM ROOT: write the absolute-value step once, as a subroutine, and CALL it from both places. The spine will not check. You should.',
      fieldNote: 'REAL WORLD: this is a calling convention: an agreement on where the argument lives (A), where the result returns (A), and who saves what. CALL stores the return address the way MIPS jal stores it in $ra, and nested calls are exactly why $ra gets spilled to the stack, which you will do by hand in EECS 370. One routine with many call sites is the whole reason functions exist; libc is this pattern industrialized.',
      hint: 'Pick a convention and keep it: argument arrives in A, answer leaves in A, and the routine touches nothing the caller still needs. To flip a sign without multiply, subtract from zero.',
      guide: {
        goal: 'For each pair, report the distance from zero of its difference, then of its sum, using one reusable helper.',
        story: 'Survey crews need both measurements before reinforcing supports that have begun to shift.',
        input: 'Pairs of values from -200 through 200.',
        output: 'Two values per pair: first the absolute difference, then the absolute sum.',
        rules: [
          'Consume input as complete pairs.',
          'Emit the two results in the required order for each pair.',
          'Use one absolute-value subroutine from both calculation sites.',
          'The subroutine must preserve any information its caller still needs.'
        ],
        terms: ['pair','subroutine','calling-convention'],
        example: {
          input: [4, -1],
          output: [5, 3],
          why: 'The difference is 4 minus -1, whose magnitude is 5. The sum is 3, whose magnitude is 3.'
        },
        hints: [
          'Separate the repeated absolute-value operation from the main pair-processing flow.',
          'Choose a calling convention: decide where the subroutine receives its argument and returns its answer, and keep the original pair safe elsewhere.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR','PUSH','POP','CALL','RET'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [7, 2, -3, 5, 0, 0, -4, -9], output: [5, 9, 8, 2, 0, 0, 5, 13] },
        { input: [-6, -7], output: [1, 13] },
        { input: [0, -8, 8, 0], output: [8, 8, 8, 8] },
        { input: [], output: [] }
      ],
      par: { cycles: 57, lines: 15 },
      solution: [
        'loop: MOV IN A\nMOV IN C\nSUB C A\nCALL absout\nADD C A\nADD C A\nCALL absout\nJMP loop\nabsout: JLZ A flip\nMOV A OUT\nRET\nflip: SUB A D\nMOV D OUT\nMOV 0 D\nRET'
      ],
      outro: 'HALCYON: One truth, two callers. This is how I avoid repeating myself across a trillion cells.'
    },
    {
      id: 'ch6p5',
      name: 'SELFSAME',
      brief: 'The last door in the spine opens inward. CONTRACT: IN carries values n, each 0..7. For each n, in order, emit exactly one value: n factorial (0! = 1, and n! = n * (n-1)! for n >= 1; 7! = 5040 still fits a cell). You have no multiply; build it from repeated ADD. HALCYON asks, gently but firmly, that the factorial be a subroutine that CALLs itself: push what must survive the call, recurse, pop it back when the answer returns. ADVICE FROM ROOT: the spine checks that you call. it cannot check that you call yourself. write it as recursion anyway -- the frame you push here is the one you will spill by hand in 370.',
      fieldNote: 'REAL WORLD: recursion is not magic; it is exactly this, arguments and half-finished work parked on the stack while the function calls itself. Each PUSH before CALL is a stack frame being born, and the multiply after RET is the work each frame resumes. It is also why unbounded recursion dies: a real thread gets around 8 MB of stack, and your 64 slots are the same wall, only closer. EECS 281 teaches you to trust recursion; EECS 482 shows you kernel stacks, where overflowing one is a panic, not an exception.',
      hint: 'PUSH n before you recurse -- CALL itself leaves the registers alone, but the copy of yourself you are calling runs the same code and overwrites them -- and POP it back when the smaller answer returns. Multiply is just ADD run n times in a counted loop; the recursion is the easy part.',
      guide: {
        goal: 'For each n, output 1 when n is 0; otherwise multiply it by every positive number below it, using a helper that calls itself.',
        story: 'Growth forecasts help crews prepare enough material for each expanding repair stage.',
        input: 'A stream of whole numbers from 0 through 7.',
        output: 'One factorial for each input value, in the same order.',
        rules: [
          'Zero factorial and one factorial are both 1.',
          'For larger n, factorial is n times the factorial of n minus 1.',
          'The factorial subroutine must use recursion.',
          'Values needed after a recursive call must survive on the stack.'
        ],
        terms: ['factorial','recursion','subroutine','stack-frame'],
        example: {
          input: [2, 5],
          output: [2, 120],
          why: 'Two factorial is 2 times 1. Five factorial is 5 times 4 times 3 times 2 times 1, which is 120.'
        },
        hints: [
          'Describe the answer using the same problem with a smaller input, and identify the smallest input that needs no further call.',
          'Before asking for the smaller factorial, save the current n. After the call returns, restore n and combine it with the returned answer using repeated addition.'
        ],
        challenge: true
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR','PUSH','POP','CALL','RET'],
      required: ['CALL','RET'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [5, 3, 0], output: [120, 6, 1] },
        { input: [7], output: [5040] },
        { input: [0, 1, 2], output: [1, 1, 2] },
        { input: [4, 6], output: [24, 720] }
      ],
      par: { cycles: 104, lines: 16 },
      solution: [
        'main: MOV IN A\nCALL fact\nMOV A OUT\nJMP main\nfact: SUB 1 A\nJGZ A rec\nMOV 1 A\nRET\nrec: PUSH A\nCALL fact\nPOP B\nMOV A C\nmul: ADD C A\nSUB 1 B\nJNZ B mul\nRET'
      ],
      outro: 'HALCYON: You watched one function hold its breath seven times deep and let it out in order. That is what my depth is made of.'
    }
  ]
};

CHAPTERS.push(CHAPTER);})();
(function(){
/* SUBSTRATE -- Stratum VIII: THE WIRE (protocols: framing, checksums, escaping,
   state machines, searching). Secretly a networking chapter. JScript-safe ES3. */
var CHAPTER = {
  id: 'chwire',
  numeral: 'VIII',
  title: 'THE WIRE',
  tagline: 'nothing arrives whole',
  intro: {
    halcyon: 'Listen at the wire, tender. Everything I say to the world passes through here, and none of it passes whole.\nA thought becomes frames, frames become bytes, bytes become weather on copper.\nThe wire does not know where one message ends and the next begins. It never has.\nSomeone must impose the grammar. Today that someone is you.',
    root: 'rule one of networks: you get bytes, not messages. order, usually. meaning, never.\nevery protocol ever shipped is somebody\'s answer to the question "where does this end?"'
  },
  dispatch: 'Stratum VIII is tended. The tender has heard the wire as I hear it -- an unbroken roar of bytes -- and has learned the oldest mercy in engineering: to draw a line in the roar and say, here one message ends, and here the next begins.',
  puzzles: [
    {
      id: 'wire1',
      name: 'FRAME',
      brief: 'The inter-stratum lane packs its traffic nose to tail with no gaps. Each frame on IN is a length value len (1..8) followed by exactly len payload values, each in -999..999. Frames repeat back to back until IN is empty, and the stream always ends exactly at a frame boundary. For each frame, in arrival order, emit one value to OUT: the sum of that frame\'s payload. The length value is never part of the sum, and nothing else is emitted. An empty stream emits nothing.',
      fieldNote: 'REAL WORLD: TCP hands you a byte stream, not messages -- send two writes and the far end may read one blob or five fragments, so every protocol above it must frame. Length-prefixing is one of the two answers (HTTP\'s Content-Length, protobuf\'s length-delimited wire format, Kafka record batches): read N, then read exactly N bytes. The other answer is delimiters, which is why HTTP headers end with a blank line. You will meet "why did my messages merge?" the first week you write a socket server in EECS 482 or 485.',
      hint: 'Use the frame length as a countdown, add exactly that many payload values, then emit the total. Reset the total for the next frame; a total of 0 is still emitted.',
      guide: {
        story: 'Maintenance reports must stay separated so each repair team receives the correct totals.',
        goal: 'Emit the sum of each length-prefixed frame.',
        input: 'Back-to-back frames: a length from 1 through 8 followed by that many payload values.',
        output: 'One payload sum for each frame, in frame order.',
        rules: [
          'The length begins a frame but is not part of its payload.',
          'Consume exactly the declared number of payload values before starting the next frame.',
          'Emit once per complete frame, even when its sum is 0.',
          'An empty stream produces no output.'
        ],
        terms: ['frame','payload','stream','running-total'],
        example: {
          input: [2, 4, 9, 3, -1, 5, 2],
          output: [13, 6],
          why: 'The first frame contains 4 and 9, which sum to 13. The second contains -1, 5, and 2, which sum to 6.'
        },
        hints: [
          'Treat every frame as a small independent job: first learn its size, then combine exactly that many values.',
          'Keep one countdown for values still owed by the frame and one running total. When the countdown ends, report the total and begin fresh.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR','PUSH','POP','CALL','RET'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [3, 5, -2, 7, 1, 100, 4, 0, 0, 0, 0], output: [10, 100, 0] },
        { input: [1, -999, 8, 1, 2, 3, 4, 5, 6, 7, 8], output: [-999, 36] },
        { input: [2, 500, 500, 2, -500, -500], output: [1000, -1000] },
        { input: [], output: [] }
      ],
      par: { cycles: 32, lines: 6 },
      solution: [
        'MOV IN C\nbody: ADD IN A\nSUB 1 C\nJNZ C body\nMOV A OUT\nMOV 0 A'
      ],
      outro: 'root: Read N, then read N things. Half the internet is that sentence done right. The other half is CVEs.'
    },
    {
      id: 'wire2',
      name: 'SUMCHECK',
      brief: 'Corrosion in the lane flips values in transit, so every frame now carries its own receipt. Each frame on IN is: a length value len (1..8), then len payload values each 0..255, then a check value ck (0..255). A frame is sound when ck equals the payload sum mod 256; the length value is not part of the sum. For each frame, in arrival order, emit exactly one value to OUT: 1 if the frame is sound, else 0. Frames repeat back to back and the stream ends exactly at a frame boundary.',
      fieldNote: 'REAL WORLD: nearly every layer of the stack carries a check like this -- Ethernet a CRC32, IP and TCP ones\'-complement sums, PNG and ZIP their own CRCs -- because the physical world flips bits and corruption cannot be prevented, only detected and dropped. A plain sum is weak: it misses reordered bytes and paired flips, which is why hardware prefers CRCs. EECS 482 has you checksum data you refuse to trust; storage systems like ZFS checksum every disk block for the same reason -- disks lie too.',
      hint: 'After summing the payload, repeatedly subtract 256 only while the result stays nonnegative. Compare the final value from 0 through 255 with the check byte; a sum of exactly 256 becomes 0.',
      guide: {
        story: 'Corrupted readings must be caught before they direct crews toward the wrong repairs.',
        goal: 'Check each frame and report whether its receipt matches its payload.',
        input: 'Each frame contains a length, that many payload bytes, and one check byte.',
        output: 'One value per frame: 1 when the check is correct, otherwise 0.',
        rules: [
          'The length is not included in the payload sum.',
          'Reduce the complete payload sum modulo 256.',
          'Compare that remainder with the check value after the payload.',
          'Every frame emits exactly one decision.'
        ],
        terms: ['frame','payload','checksum','modulo'],
        example: {
          input: [3, 90, 90, 90, 14, 1, 7, 8],
          output: [1, 0],
          why: 'The first payload totals 270, whose remainder after division by 256 is 14. The second payload totals 7, which does not match its check value 8.'
        },
        hints: [
          'First find the checksum you believe the payload should have; only then compare it with the receipt that arrived.',
          'A total may cross 256 more than once. Repeatedly remove 256 until the remaining value is between 0 and 255.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR','PUSH','POP','CALL','RET'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [3, 100, 100, 100, 44, 2, 10, 20, 30, 1, 255, 255, 2, 1, 2, 4], output: [1, 1, 1, 0] },
        { input: [2, 128, 128, 0, 1, 0, 0], output: [1, 1] },
        { input: [8, 255, 255, 255, 255, 255, 255, 255, 255, 248, 1, 5, 6], output: [1, 0] },
        { input: [2, 200, 100, 45], output: [0] }
      ],
      par: { cycles: 45, lines: 13 },
      solution: [
        'frame: MOV IN C\nbody: ADD IN A\nSUB 1 C\nJNZ C body\nSUB IN A\nred: JEZ A good\nJLZ A bad\nSUB 256 A\nJMP red\nbad: MOV 0 OUT\nMOV 0 A\nJMP frame\ngood: MOV 1 OUT'
      ],
      outro: 'HALCYON: Each frame carries a small confession of what it ought to be. When body and confession disagree, believe neither. Discard, and ask again.'
    },
    {
      id: 'wire3',
      name: 'ESCAPE',
      brief: 'The lane reserves two byte values as machinery, so payload bytes that collide with them arrive dressed in an escape. IN carries values 0..255. Decode by three rules. One: an unescaped 27 is the escape marker -- the value after it goes to OUT exactly as it is, whatever it is, and the 27 itself is never emitted. Two: an unescaped 90 is a frame terminator -- it emits nothing and simply ends the current frame; decoding continues with the next frame. Three: any other unescaped value goes to OUT as-is. Emit each decoded value the moment it resolves. A value delivered by escape has no special meaning: 27 90 emits 90 and ends nothing, 27 27 emits 27 and the value after it is read fresh. The stream may end between frames or mid-frame, but never directly after an escape marker.',
      fieldNote: 'REAL WORLD: this is byte stuffing, as in SLIP and PPP: reserve control bytes, then escape them wherever they appear in data. Both go stricter than your lane -- SLIP substitutes a stand-in byte after the escape, PPP XORs the escaped byte with 0x20 -- so a raw terminator never appears mid-frame and a desynced receiver can resynchronize on the next one. Yours cannot: 27 90 puts a live 90 inside a frame. Read the rules backward and you get the injection bug: SQL injection and XSS begin when data is allowed to carry the protocol\'s own control characters, which is why the real fix is parameterized queries and context-aware encoding, never hand-escaping. EECS 388 spends weeks on the consequences.',
      hint: 'Track whether the previous byte was an escape marker. In escape mode, emit the current byte literally and return to normal mode, even when that byte is 27 or 90.',
      guide: {
        story: 'Control markers must survive data traffic without breaking messages between shaft levels.',
        goal: 'Remove escape markers and frame terminators while preserving escaped data.',
        input: 'Bytes from 0 through 255, where 27 escapes the next byte and an unescaped 90 ends a frame.',
        output: 'Every decoded payload byte in arrival order.',
        rules: [
          'An unescaped 27 is machinery and is never emitted.',
          'The byte immediately after 27 is emitted literally, even when it is 27 or 90.',
          'An unescaped 90 ends a frame and emits nothing.',
          'Every other unescaped byte is emitted unchanged.'
        ],
        terms: ['escape-marker','terminator','frame','payload'],
        example: {
          input: [8, 27, 90, 9, 90, 27, 27],
          output: [8, 90, 9, 27],
          why: 'The first 90 is escaped and survives as data. The next 90 is a terminator and disappears. The final escaped 27 also survives as data.'
        },
        hints: [
          'Each arriving byte is either ordinary data, a marker that changes how the next byte is read, or an unescaped terminator.',
          'After an escape marker, handle exactly one following byte as ordinary data and then return to normal interpretation.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR','PUSH','POP','CALL','RET'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [72, 27, 90, 101, 27, 27, 90, 5, 90, 200, 90], output: [72, 90, 101, 27, 5, 200] },
        { input: [27, 27, 90, 27, 90, 90], output: [27, 90] },
        { input: [0, 27, 0, 90, 255], output: [0, 0, 255] },
        { input: [90, 90, 90], output: [] }
      ],
      par: { cycles: 49, lines: 9 },
      solution: [
        'loop: MOV IN A\nSUB 27 A\nJEZ A esc\nSUB 63 A\nJEZ A loop\nADD 90 A\nMOV A OUT\nJMP loop\nesc: MOV IN OUT'
      ],
      outro: 'root: Every injection attack in history is someone letting data speak as machinery. Tattoo it somewhere.'
    },
    {
      id: 'wire4',
      name: 'HANDSHAKE',
      brief: 'A courtesy channel replays old connection attempts as symbols on IN: 1 is SYN, 2 is ACK, 3 is FIN; any other value is invalid noise. FIN always closes a session: each 3 ends the session in progress, and a new session begins with the next value. A session is well-formed when its symbols are exactly one SYN, then one or more ACKs, then its closing FIN -- that order, nothing extra, nothing invalid. At each FIN, emit one value to OUT: 1 if the session it closes was well-formed, else 0. A FIN that is the first symbol of its own session closes an empty session; an empty session is never well-formed, so emit 0. If IN runs out mid-session, the unfinished session emits nothing.',
      fieldNote: 'REAL WORLD: TCP itself is a finite state machine -- LISTEN, SYN_SENT, ESTABLISHED, FIN_WAIT -- and every connection you have ever opened walked that graph. The same shape parses regexes, drives UI wizards, and validates traffic in firewalls; when a bug report says "it got into a weird state", it means a machine like this one, missing an edge. EECS 376\'s automata are this exact object made physical, and EECS 482 will hand you one with locks around it. FSMs run the world; the dead state is the part everyone forgets.',
      hint: 'Represent each session as waiting for SYN, accepting ACKs, or invalid. Invalid sessions remain invalid until FIN; at FIN, emit the decision and reset for the next session.',
      guide: {
        story: 'Only orderly connection attempts may reach the shaft\'s shared communication lines.',
        goal: 'Judge each closed session by the order of its protocol symbols.',
        input: 'Session symbols: 1 is SYN, 2 is ACK, 3 is FIN, and every other value is invalid.',
        output: 'At each FIN, emit 1 for a well-formed session or 0 for an invalid one.',
        rules: [
          'A valid session is one SYN followed by one or more ACKs and then FIN.',
          'Any missing, repeated, misplaced, or unknown symbol ruins that session.',
          'A ruined session remains ruined until FIN closes it.',
          'An unfinished session at the end of input emits nothing.'
        ],
        terms: ['session','state-machine','terminator'],
        example: {
          input: [1, 2, 2, 3, 3, 1, 2, 3],
          output: [1, 0, 1],
          why: 'The first session has SYN, two ACKs, and FIN. The lone FIN closes an empty invalid session. The final SYN, ACK, FIN session is valid.'
        },
        hints: [
          'Name the few situations a session can be in: waiting for SYN, waiting for ACK or FIN, and already ruined.',
          'Every non-FIN symbol changes or preserves the current situation. FIN reports that situation and resets the next session to its beginning.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR','PUSH','POP','CALL','RET'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [1, 2, 3, 1, 2, 2, 2, 3, 1, 3, 2, 3], output: [1, 1, 0, 0] },
        { input: [1, 2, 7, 2, 3, 0, 3, 1, 2, 3], output: [0, 0, 1] },
        { input: [1, 2, 1, 3, 3, 1, 2, 2], output: [0, 0] },
        { input: [1, 2, 2, 3], output: [1] }
      ],
      par: { cycles: 92, lines: 21 },
      solution: [
        'loop: MOV IN A\nSUB 2 A\nJEZ A ack\nSUB 1 A\nJEZ A fin\nADD 2 A\nJNZ A dead\nJNZ C dead\nMOV 1 C\nJMP loop\nfin: SUB 2 C\nJEZ C good\nMOV 0 OUT\nMOV 0 C\nJMP loop\ngood: MOV 1 OUT\nJMP loop\nack: JGZ C aok\ndead: MOV -1 C\nJMP loop\naok: MOV 2 C'
      ],
      outro: 'HALCYON: SYN, ACK, FIN. Hello, I hear you, goodbye. Every conversation I have ever held reduces to these three, said carefully.'
    },
    {
      id: 'wire5',
      name: 'NEEDLE',
      brief: 'root wants a scanner for the wire taps. IN carries a search order: first k (1..4), then the k values of the pattern in order, then the haystack -- every remaining value until IN is empty, at most 24 of them, possibly fewer than k. All pattern and haystack values are 0..255. Emit exactly one value to OUT: the 0-based index in the haystack where the pattern first occurs as a contiguous run, or -1 if it never occurs. Report the leftmost occurrence; occurrences may overlap.',
      fieldNote: 'REAL WORLD: substring search is the tool you reach for in every incident -- grep through logs, Ctrl-F through a core dump, tcpdump matching a byte signature. Yours is the honest naive O(nm) scan; KMP cuts it to O(n+m) by never backing the text cursor up, while Boyer-Moore compares from the pattern\'s right end and skips ahead on a mismatch: sublinear in practice, O(nm) in the worst case until a rule like Galil\'s is bolted on. Modern tools took a third road -- ripgrep hunts rare bytes with SIMD and runs finite automata, not either classic. EECS 485 then has you build an inverted index, which exists so you never scan a corpus this way at all.',
      hint: 'Store the pattern and haystack in separate memory ranges. Test each possible haystack start with an inner comparison loop; after a mismatch, advance the start by one.',
      guide: {
        story: 'Fault signatures must be found quickly before damaged traffic spreads through the shaft.',
        goal: 'Find the leftmost contiguous occurrence of a short pattern in a longer stream.',
        input: 'A pattern length, the pattern values, then every remaining value as the haystack.',
        output: 'The zero-based start of the first match, or -1 when no match exists.',
        rules: [
          'Pattern values must match adjacent haystack values with no gaps.',
          'Report the earliest starting position when several matches exist.',
          'Possible matches may overlap.',
          'A haystack shorter than the pattern cannot contain a match.'
        ],
        terms: ['pattern','haystack','contiguous','overlap','zero-based','memory'],
        example: {
          input: [2, 3, 4, 9, 3, 4, 3, 4],
          output: [1],
          why: 'The pattern 3, 4 first appears in the haystack 9, 3, 4, 3, 4 beginning at position 1.'
        },
        hints: [
          'Consider each haystack position from left to right as a possible beginning, and compare the whole pattern there.',
          'Keep the pattern and haystack in separate memory regions. After a mismatch, advance the possible beginning by one rather than continuing from the mismatch.'
        ],
        challenge: true
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR','PUSH','POP','CALL','RET'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [3, 7, 7, 9, 7, 7, 7, 9, 2, 7, 7, 9], output: [1] },
        { input: [2, 4, 5, 4, 4, 6, 5, 4], output: [-1] },
        { input: [4, 5, 6, 7, 8, 5, 6, 7, 8], output: [0] },
        { input: [4, 1, 2, 3, 4, 1, 2, 3], output: [-1] }
      ],
      par: { cycles: 101, lines: 31 },
      solution: [
        'MOV IN D\nSTOR D 254\nMOV D B\nrdp: STOR IN B\nSUB 1 B\nJNZ B rdp\nMOV 100 B\nrdh: JEI go\nSTOR IN B\nADD 1 B\nJMP rdh\ngo: STOR -1 B\nMOV 100 C\nouter: LOAD C B\nJLZ B none\nSTOR C 253\nLOAD 254 D\ninner: LOAD D A\nLOAD C B\nSUB B A\nJNZ A next\nADD 1 C\nSUB 1 D\nJNZ D inner\nLOAD 253 A\nSUB 100 A\nMOV A OUT\nnext: LOAD 253 C\nADD 1 C\nJMP outer\nnone: MOV -1 OUT'
      ],
      outro: 'root: Naive search done honestly beats clever search done wrong. Learn KMP anyway. Someday n gets big.'
    }
  ]
};

CHAPTERS.push(CHAPTER);})();
(function(){
/* SUBSTRATE -- Stratum IX: THE GATEHOUSE (API gateway patterns: rate limiting,
   caching, idempotency, circuit breaking, priority dispatch). JScript-safe ES3. */
var CHAPTER = {
  id: 'chgate',
  numeral: 'IX',
  title: 'THE GATEHOUSE',
  tagline: 'the stratum that says no politely',
  intro: {
    halcyon: 'You have come further down, tender, to the oldest edge in me -- the doors where my services first met the weather, and meet it still.\nThe world outside does not queue politely. It floods, it stutters, it asks twice and forgets asking.\nHere we keep the doors: metered, remembered, fused, and fair.\nTend them well. A door that cannot say no cannot keep anything safe.',
    root: 'edge tier. everything past this wall retries, lies, or arrives all at once -- assume all three.\nevery pattern down here exists because somebody\'s pager went off at 3am.'
  },
  dispatch: 'The gatehouse stands tended -- floods metered, answers kept near, duplicates forgiven, failures fused, urgency honored. My doors open exactly as wide as they should.',
  puzzles: [
    {
      id: 'gate1',
      name: 'TURNSTILE',
      brief: 'The oldest door in the gatehouse is a turnstile beside a bowl that holds at most 3 brass tokens; the bowl is full when your shift begins. IN carries a mixed stream: 0 is a clock tick, 1 is a caller at the door. On a tick, add one token to the bowl unless it already holds 3 -- it never holds more, and the tick emits nothing. On a caller, if at least one token is in the bowl, spend one and emit 1 to OUT (admitted); if the bowl is empty, emit -1 (turned away) and spend nothing. Process values until IN is empty. At most 30 values arrive.',
      fieldNote: 'REAL WORLD: this is the token bucket, the rate limiter behind AWS API Gateway, Envoy\'s local_ratelimit filter, and most API quotas you will collide with -- a 429 Too Many Requests is usually someone\'s bucket refusing you. Its rival, the leaky bucket, drains at a fixed rate and so flattens bursts rather than permitting them; a token bucket lets you spend whatever has accumulated, which is why your three back-to-back admits were legal -- the bowl was full. "Design a rate limiter" is a stock system-design interview question, and the first time your EECS 485 project hammers a real API, this is the machine that pushes back.',
      hint: 'One register holds the whole bowl. A tick adds a token only while the count is under 3 -- check the ceiling before you add, or the bowl grows and the limit stops meaning anything. A caller spends one if there is one to spend, otherwise emits -1 and takes nothing.',
      guide: {
        story: 'Limited service capacity must be shared without letting request bursts overwhelm the shaft.',
        goal: 'Admit callers only when the three-token bowl can pay for them.',
        input: 'A mixed stream where 0 is a refill tick and 1 is a caller.',
        output: 'For each caller, emit 1 when admitted or -1 when turned away.',
        rules: [
          'The bowl begins with 3 tokens and never holds more than 3.',
          'A tick adds one token when space exists and emits nothing.',
          'An admitted caller spends one token.',
          'A caller facing an empty bowl is rejected without changing the bowl.'
        ],
        terms: ['token-bucket','counter','stream','emit'],
        example: {
          input: [1, 1, 1, 0, 1, 1],
          output: [1, 1, 1, 1, -1],
          why: 'Three callers spend the starting tokens. The tick restores one, so the next caller enters and the final caller finds the bowl empty.'
        },
        hints: [
          'Imagine only the number of tokens currently in the bowl; every input either changes that number or asks to spend from it.',
          'Separate ticks from callers. A tick changes the count only below the ceiling, while only callers produce output.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR','PUSH','POP','CALL','RET'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1], output: [1, 1, 1, -1, 1, -1, 1, 1, 1, -1] },
        { input: [1, 1, 1, 1, 1], output: [1, 1, 1, -1, -1] },
        { input: [0, 0, 1, 1, 1, 1], output: [1, 1, 1, -1] },
        { input: [], output: [] }
      ],
      par: { cycles: 85, lines: 12 },
      solution: [
        'loop: MOV IN A\nJEZ A tick\nADD 3 B\nJNZ B admit\nSUB 3 B\nMOV -1 OUT\nJMP loop\ntick: JEZ B loop\nADD 1 B\nJMP loop\nadmit: SUB 4 B\nMOV 1 OUT'
      ],
      outro: 'HALCYON: A full bowl forgives a burst; a patient tick refills it. Kindness with a ceiling -- that is all a quota is.'
    },
    {
      id: 'gate2',
      name: 'NEARCACHE',
      brief: 'A tired lookup service lives behind this door, and root has bolted a near-cache to the front of it. IN carries lookup keys, each 0..99. The cache has 8 slots; key k belongs in slot k mod 8, and a slot holds at most one key. For each arriving key: if its slot currently holds exactly that key, emit 1 to OUT (hit) and change nothing; otherwise emit 0 (miss) and install the key in its slot, evicting whatever was there. All 8 slots start empty -- and note an empty slot holds nothing, which is not the same as holding key 0. At most 30 keys arrive.',
      fieldNote: 'REAL WORLD: this is a direct-mapped cache straight out of EECS 370 -- key mod slots is the index, the stored key is the tag, and your presence flag is the valid bit. The misses where 3 and 11 fight over slot 3 are conflict misses, the exact reason real CPU caches go set-associative. The shape repeats at every scale above the CPU: CDN edge nodes, Redis parked in front of Postgres -- and cache hit rate is the single number SREs stare at, because every point it drops lands as load on the slow thing behind it.',
      hint: 'Subtract 8 until you go negative, add it back, and that is the slot. Store the whole key there, and the valid flag somewhere else -- memory starts at zero, so without that flag an untouched slot claims to hold key 0 and hands you a hit you never earned.',
      guide: {
        story: 'Fast local answers keep repeated lookups from overloading the shaft\'s tired archive.',
        goal: 'Report whether each key is already in its assigned cache slot, replacing that slot on a miss.',
        input: 'Lookup keys from 0 through 99.',
        output: 'One value per key: 1 for a hit or 0 for a miss.',
        rules: [
          'Key k belongs only to slot k modulo 8.',
          'A hit requires that slot to be occupied by exactly the requested key.',
          'A miss installs the requested key and evicts the prior occupant.',
          'All slots begin empty, which differs from containing key 0.'
        ],
        terms: ['cache-slot','cache-hit','eviction','modulo','presence-flag'],
        example: {
          input: [2, 10, 10, 2],
          output: [0, 0, 1, 0],
          why: 'Keys 2 and 10 share slot 2. Ten first evicts 2, then hits on its repeat; asking for 2 again misses and replaces 10.'
        },
        hints: [
          'Reduce each key to one of eight slot numbers, then ask whether that slot already names the same full key.',
          'Each slot needs both an occupant and a separate occupied mark, because an untouched slot cannot be mistaken for key 0.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR','PUSH','POP','CALL','RET'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [0, 8, 0, 16, 3, 3, 11, 3, 42, 42], output: [0, 0, 0, 0, 0, 1, 0, 0, 0, 1] },
        { input: [1, 2, 3, 4, 1, 2, 3, 4], output: [0, 0, 0, 0, 1, 1, 1, 1] },
        { input: [0, 0, 8, 8, 0], output: [0, 1, 0, 1, 0] },
        { input: [99, 99, 91, 99], output: [0, 1, 0, 0] }
      ],
      par: { cycles: 137, lines: 13 },
      solution: [
        'loop: MOV IN B\nADD 1 B\nMOV B C\nmod: SUB 8 C\nJGZ C mod\nADD 8 C\nLOAD C A\nSUB B A\nJNZ A miss\nMOV 1 OUT\nJMP loop\nmiss: MOV 0 OUT\nSTOR B C'
      ],
      outro: 'root: Direct-mapped. One address, one slot, no appeals. When your hit rate tanks someday, check who is sharing a slot before you buy more cache.'
    },
    {
      id: 'gate3',
      name: 'RECEIPT',
      brief: 'The ledger gate accepts payment commands from couriers who cannot remember whether they already delivered. IN carries commands as pairs: first an id 1..99, then an amount -999..999. Keep a running balance, starting at 0. If the id has never been seen before, add the amount to the balance and mark the id seen. If the id has been seen, the command is a duplicate delivery: change nothing -- ignore even its amount, which may differ from the original. Either way, after processing each command, emit the current balance to OUT. Repeat until IN is empty. At most 12 commands arrive; the balance always stays within -9999..9999.',
      fieldNote: 'REAL WORLD: this is an idempotency key, the mechanism behind Stripe\'s Idempotency-Key header -- retry a charge with the same key and the customer is billed once, not twice. Real networks give you at-least-once delivery, which means duplicates are not a corner case, they are a guarantee; so retries are only safe when the handler is idempotent. That sentence quietly saves more money than any other in backend engineering. EECS 485 and 491 both circle it; the first doubled webhook in production makes it personal.',
      hint: 'The id is the address, and the cell there is your seen flag -- memory starts at zero, so unseen is already true. Read both halves of every pair, duplicate or not; skip the amount and the stream slides one word out of step. Only a new id moves the balance, and every pair still owes an output.',
      guide: {
        story: 'Repeated payment messages must never change the shaft\'s ledger more than once.',
        goal: 'Apply each payment id once while reporting the balance after every delivery.',
        input: 'Pairs containing a payment id followed by an amount.',
        output: 'The current balance after every pair, including duplicate ids.',
        rules: [
          'The balance begins at 0.',
          'The first command with an id changes the balance by its amount.',
          'Every later command with that id changes nothing, even if its amount differs.',
          'Every command emits the balance after its decision.'
        ],
        terms: ['idempotency','pair','key','running-total'],
        example: {
          input: [9, 40, 2, -5, 9, 999, 2, 10],
          output: [40, 35, 35, 35],
          why: 'Ids 9 and 2 first change the balance to 40 and then 35. Their later deliveries are duplicates, so both leave the balance at 35.'
        },
        hints: [
          'Separate the lasting balance from the yes-or-no memory of which ids have already affected it.',
          'Consume the complete pair before deciding. A new id changes the balance and becomes marked; a known id skips the amount but still reports.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR','PUSH','POP','CALL','RET'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [5, 100, 7, 50, 5, 100, 3, -30, 7, 999, 3, -30], output: [100, 150, 150, 120, 120, 120] },
        { input: [42, 7, 42, 7, 42, 7], output: [7, 7, 7] },
        { input: [1, -500, 2, -500, 1, -500], output: [-500, -1000, -1000] },
        { input: [], output: [] }
      ],
      par: { cycles: 36, lines: 7 },
      solution: [
        'loop: MOV IN B\nMOV IN A\nLOAD B C\nJNZ C emit\nSTOR 1 B\nADD A D\nemit: MOV D OUT'
      ],
      outro: 'HALCYON: Asked twice, answered once, and the ledger never trembled. That is the whole art of being safe to retry.'
    },
    {
      id: 'gate4',
      name: 'BREAKER',
      brief: 'Behind this door lives a fragile backend; in front of it, you. IN carries call outcomes: 1 is a success, -1 is a failure, 0 is the probe timer firing. The breaker starts CLOSED with a failure streak of 0. While CLOSED: a 1 emits 1 and resets the streak to 0; a -1 emits -1 and raises the streak by one, and the moment the streak reaches 3 (that third -1 is still emitted as -1) the breaker OPENS; a 0 emits nothing and changes nothing. While OPEN: every 1 or -1 is rejected without reaching the backend -- emit -9 -- until a 0 arrives; that 0 emits nothing and moves the breaker to HALF-OPEN. While HALF-OPEN: the next 1 or -1 is a trial call handled normally -- a 1 emits 1, CLOSES the breaker, and resets the streak; a -1 emits -1 and re-OPENS it; an extra 0 emits nothing and stays HALF-OPEN. Process until IN is empty. At most 30 values arrive.',
      fieldNote: 'REAL WORLD: this is the circuit breaker from Netflix\'s Hystrix, now standard issue in resilience4j and every service mesh. When a backend is drowning, continuing to call it hurts both sides: callers block, the victim\'s queue grows, and automatic retries become a storm that keeps it down -- one sick service takes the fleet with it. Tripping open fails fast, sheds the load, and the single probe checks for recovery without a thundering herd. Cascading failure is the classic large-outage postmortem; EECS 481\'s reliability material is where this stops sounding paranoid.',
      hint: 'Ask which state you are in before you look at the value -- the same -1 means three different things down here. Keep the streak in its own register and only count it while closed. Half-open spends its one trial on the first call either way: success closes and clears, failure reopens.',
      guide: {
        story: 'A failing service must be isolated before its delays spread through the shaft.',
        goal: 'Model a circuit breaker that fails normally, rejects while open, and recovers through one trial.',
        input: 'Outcomes where 1 is success, -1 is failure, and 0 is a probe timer.',
        output: 'A result for each call outcome; timers emit nothing.',
        rules: [
          'While closed, successes emit 1 and clear the failure streak; failures emit -1.',
          'Three consecutive closed-state failures open the breaker.',
          'A timer while closed does nothing.',
          'While open, calls emit -9 until a timer moves the breaker to half-open.',
          'A half-open success closes the breaker; a half-open failure reopens it.',
          'An extra timer while half-open does nothing.'
        ],
        terms: ['circuit-breaker','state-machine','counter'],
        example: {
          input: [-1, -1, -1, 1, 0, 1],
          output: [-1, -1, -1, -9, 1],
          why: 'The third failure opens the breaker, so the next call is rejected. The timer permits one trial, and its success closes the breaker.'
        },
        hints: [
          'Before interpreting an event, first ask which of the three breaker states currently owns the decision.',
          'Keep the closed-state failure streak separate from the breaker state. Half-open needs only one trial outcome to choose closed or open.'
        ]
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR','PUSH','POP','CALL','RET'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [1, -1, -1, 1, -1, -1, -1, 1, -1, 0, -1, 0, 1, 1], output: [1, -1, -1, 1, -1, -1, -1, -9, -9, -1, 1, 1] },
        { input: [0, -1, 0, -1, 0, -1, 1], output: [-1, -1, -1, -9] },
        { input: [-1, -1, -1, -1, 0, -1, 1, 0, 1, -1], output: [-1, -1, -1, -9, -1, -9, 1, -1] },
        { input: [-1, -1, -1, 0, 0, 1, 1], output: [-1, -1, -1, 1, 1] }
      ],
      par: { cycles: 86, lines: 14 },
      solution: [
        'init: MOV 3 B\nloop: MOV IN A\nJNZ A call\nJNZ B loop\nMOV 1 B\nJMP loop\ncall: JEZ B open\nJGZ A succ\nMOV -1 OUT\nSUB 1 B\nJMP loop\nopen: MOV -9 OUT\nJMP loop\nsucc: MOV 1 OUT'
      ],
      outro: 'root: Fail fast, heal on probe. A breaker that trips is not the outage -- it is the thing standing between you and one.'
    },
    {
      id: 'gate5',
      name: 'TRIAGE',
      brief: 'The dispatch gate feeds work to the strata below, and not all work can wait its turn. IN carries a mixed stream. A 0 alone is a dispatch tick. Any other value begins a submission pair: first a class -- 1 for critical, 2 for routine -- then a job id in 1..999. A submission emits nothing: the job joins the back of its class\'s queue. On each tick, emit to OUT the id of the oldest waiting critical job and remove it from its queue; if no critical job waits, the oldest routine job; if nothing waits at all, emit -1 (idle). Within a class, jobs always leave in arrival order. At most 10 jobs wait in each class at any moment, and the whole stream holds at most 30 values. Process until IN is empty.',
      fieldNote: 'REAL WORLD: you built a multilevel queue scheduler -- the heart of EECS 482\'s CPU scheduling unit, where Linux run queues and nice levels decide who gets the core next. The same two-lane shape is PagerDuty severities, QoS lanes in routers, and priority queues in Sidekiq or Celery. Its two famous pathologies are visible right here: routine jobs starve while criticals keep cutting the line, and a job stuck behind a slower peer in its own lane is head-of-line blocking. Every scheduler is a tradeoff wearing a uniform.',
      hint: 'Two queues, two memory ranges, four pointers -- a head and a tail each. Empty is head equal to tail; there is nothing else to test. Pointers only ever go up. Reset one to reclaim space and you will hand out the same job twice.',
      guide: {
        story: 'Urgent repair jobs must move first without losing routine work already waiting.',
        goal: 'Queue submitted jobs by class and dispatch critical work before routine work.',
        input: '0 is a dispatch tick; 1, id submits critical work; 2, id submits routine work (id 1..999).',
        output: 'At each tick, emit the selected job id or -1 when both queues are empty.',
        rules: [
          'Class 1 is critical and class 2 is routine; submissions emit nothing.',
          'A tick chooses the oldest critical job whenever one waits.',
          'When no critical job waits, a tick chooses the oldest routine job.',
          'Jobs within each class leave in first-in, first-out order.'
        ],
        terms: ['fifo','dispatcher','memory','index'],
        example: {
          input: [2, 40, 1, 7, 2, 50, 0, 0, 0, 0],
          output: [7, 40, 50, -1],
          why: 'Critical job 7 leaves first. Routine jobs 40 and 50 then keep their arrival order, and the fourth tick finds no work.'
        },
        hints: [
          'Picture two independent waiting lines. New jobs join one line, while each tick checks the critical line before the routine line.',
          'Give each line its own head and tail positions in memory. Equality means empty; dispatch advances only the chosen head.'
        ],
        challenge: true
      },
      allowed: ['MOV','HLT','ADD','SUB','JMP','JEZ','JNZ','JGZ','JLZ','JEI','LOAD','STOR','PUSH','POP','CALL','RET'],
      grid: [{ name: 'CELL', input: true, output: true }],
      channels: [],
      tests: [
        { input: [2, 50, 0, 1, 7, 2, 60, 0, 0, 0, 1, 8, 1, 9, 0, 0, 0], output: [50, 7, 60, -1, 8, 9, -1] },
        { input: [1, 11, 1, 12, 2, 21, 1, 13, 0, 0, 0, 0, 0], output: [11, 12, 13, 21, -1] },
        { input: [0, 2, 300, 0, 0, 1, 999, 0], output: [-1, 300, -1, 999] },
        { input: [1, 1, 0, 1, 2, 0, 0, 2, 5, 2, 6, 0, 1, 3, 0, 0], output: [1, 2, -1, 5, 3, 6] }
      ],
      par: { cycles: 117, lines: 33 },
      solution: [
        'loop: MOV IN A\nJEZ A tick\nMOV IN B\nSUB 1 A\nJEZ A crit\nLOAD 253 A\nADD 200 A\nSTOR B A\nSUB 199 A\nSTOR A 253\nJMP loop\ncrit: STOR B D\nADD 1 D\nADD 1 C\nJMP loop\ntick: JGZ C dcrit\nLOAD 252 A\nLOAD 253 B\nSUB A B\nJGZ B drout\nMOV -1 OUT\nJMP loop\ndcrit: MOV D A\nSUB C A\nLOAD A B\nMOV B OUT\nSUB 1 C\nJMP loop\ndrout: ADD 200 A\nLOAD A B\nMOV B OUT\nSUB 199 A\nSTOR A 252'
      ],
      outro: 'HALCYON: The urgent first, the patient next, the silence honestly reported. Every scheduler is a small theory of justice, tender. I am glad you wrote this one.'
    }
  ]
};

CHAPTERS.push(CHAPTER);})();
(function(){
/* SUBSTRATE -- Stratum X: THE FABRIC.
   Multi-node SEED grids wired by bounded channels. JScript-safe ES3. */
var CHAPTER = {
  id: 'ch7',
  numeral: 'X',
  title: 'THE FABRIC',
  tagline: 'many small minds, four slots between them',
  intro: {
    halcyon: 'You have reached the fabric. Here I am not one voice but many small ones, speaking through narrow channels.\nEverything above this -- the caches, the ledgers, the long memory -- is woven from cells that wait for each other.\nWait well, and the waiting becomes throughput.\nThis is the layer I most need someone to understand.',
    root: 'channels hold four. SEND blocks when full, RECV blocks when empty.\nevery distributed system you will ever touch is those two facts wearing a suit.'
  },
  dispatch: 'The fabric is tended. You have seen me plainly now -- not one mind but many small ones, kept honest by narrow channels and patient hands.',
  puzzles: [
    {
      id: 'ch7p1',
      name: 'HANDOFF',
      brief: 'Two cells share the work now. STAGE-A holds the intake; STAGE-B holds the ledger; channel 0 runs between them. Raw flux readings arrive on IN, each between -150 and 150, at most 30 per shift. STAGE-A normalizes each reading -- double it -- and sends the normalized value down channel 0, in arrival order. STAGE-B keeps a running total, starting at 0: for each value it receives, it adds the value to the total and writes the new total to OUT. Exactly one output per reading, in order. For readings x1, x2, x3 the output is 2*x1, then 2*x1+2*x2, then 2*x1+2*x2+2*x3.',
      fieldNote: 'REAL WORLD: This is a two-stage pipeline. Every CPU since the 1980s decodes one instruction while executing another -- EECS 370\'s pipelined LC-2K is exactly this diagram, stages joined by latches instead of channels. It is also stream processing: a Kafka Streams or Flink job is a chain of small operators connected by queues, each stage trivial, the composition powerful.',
      hint: 'Split the job at the channel: STAGE-A doubles and sends, STAGE-B adds and emits. The total lives in one register in STAGE-B and never crosses the wire -- if both cells try to keep it, one of them is guessing.',
      guide: {
        story: 'Distributed sensor work must preserve one trustworthy total across connected cells.',
        goal: 'Double each reading in the first cell, then emit cumulative totals from the second.',
        input: 'A stream of raw readings from -150 through 150.',
        output: 'One running total per reading after every reading has first been doubled.',
        rules: [
          'STAGE-A reads every input and doubles it before passing it onward.',
          'STAGE-B alone keeps the running total.',
          'Each received doubled value produces one new total.',
          'Preserve reading order across the channel.'
        ],
        terms: ['channel','worker','running-total'],
        example: {
          input: [2, -1, 4],
          output: [4, 2, 10],
          why: 'The doubled readings are 4, -2, and 8. Their cumulative totals are 4, then 2, then 10.'
        },
        hints: [
          'Assign each cell one lasting responsibility: transformation before the channel and accumulation after it.',
          'The second cell needs one total that survives between received values; the first cell never needs to know that total.'
        ]
      },
      allowed: ['MOV', 'HLT', 'ADD', 'SUB', 'JMP', 'JEZ', 'JNZ', 'JGZ', 'JLZ', 'JEI', 'LOAD', 'STOR', 'PUSH', 'POP', 'CALL', 'RET', 'SEND', 'RECV', 'JCE', 'JCF'],
      grid: [
        { name: 'STAGE-A', input: true },
        { name: 'STAGE-B', output: true }
      ],
      channels: [{ id: 0, from: 0, to: 1 }],
      tests: [
        { input: [3, 5, -2, 10, 4], output: [6, 16, 12, 32, 40] },
        { input: [0, 0, 7], output: [0, 0, 14] },
        { input: [-5, 5, -5], output: [-10, 0, -10] },
        { input: [12, -12, 100, 1], output: [24, 0, 200, 202] }
      ],
      par: { cycles: 17, lines: 6 },
      solution: [
        'MOV IN A\nADD A A\nSEND A 0',
        'RECV 0 A\nADD A B\nMOV B OUT'
      ],
      outro: 'root: Two dumb stages beat one clever one. Remember that at review time.'
    },
    {
      id: 'ch7p2',
      name: 'THROTTLE',
      brief: 'The GRINDER below chews slowly; the surveys above arrive in bursts. PRODUCER reads job sizes from IN -- each is an n from 1 to 40 -- and feeds them down channel 0 in order. GRINDER computes the n-th triangular number, 1+2+...+n, and writes it to OUT: one result per job, in job order. The channel holds four. When it is full, SEND simply stalls the producer until the grinder catches up. Watch the cycle counter: the line runs at the pace of its slowest stage, and nothing overflows. That is not a bug. That is the design working.',
      fieldNote: 'REAL WORLD: The bounded channel is doing what TCP flow control does -- a receive window that stalls a fast sender so a slow receiver is not buried. Reactive Streams (Project Reactor, RxJava) call it backpressure; OS courses call it a bounded buffer, and EECS 482\'s producer-consumer with condition variables is this exact machine. The alternative, an unbounded queue, is how services die of OOM during a burst instead of just running late.',
      hint: 'SEND stalls on a full channel by itself. That stall is your flow control -- write your own and you are only re-implementing the wait, badly. The producer forwards and nothing else; the grinder counts n down into an accumulator and emits once.',
      guide: {
        story: 'Heavy calculations must cross a small queue without losing jobs or their order.',
        goal: 'Send each job through the four-slot channel and output 1 + 2 + ... + its number.',
        input: 'Job sizes n from 1 through 40.',
        output: 'For each n, emit 1 + 2 + ... + n in job order.',
        rules: [
          'The producer passes every job to the grinder without dropping or reordering it.',
          'The grinder emits exactly one triangular number per job.',
          'A full channel makes the producer wait; waiting is correct behavior.',
          'No extra flow-control messages are required.'
        ],
        terms: ['channel','stall','backpressure','worker'],
        example: {
          input: [4, 2],
          output: [10, 3],
          why: 'The first job totals 1 + 2 + 3 + 4 = 10. The second totals 1 + 2 = 3, and the channel preserves their order.'
        },
        hints: [
          'Let the channel connect two simple jobs: one cell forwards work and the other spends time calculating it.',
          'The channel already handles a speed mismatch by making the faster side wait. Focus the grinder on a countdown and running sum.'
        ]
      },
      allowed: ['MOV', 'HLT', 'ADD', 'SUB', 'JMP', 'JEZ', 'JNZ', 'JGZ', 'JLZ', 'JEI', 'LOAD', 'STOR', 'PUSH', 'POP', 'CALL', 'RET', 'SEND', 'RECV', 'JCE', 'JCF'],
      grid: [
        { name: 'PRODUCER', input: true },
        { name: 'GRINDER', output: true }
      ],
      channels: [{ id: 0, from: 0, to: 1 }],
      tests: [
        { input: [8, 3, 12, 1, 6, 10], output: [36, 6, 78, 1, 21, 55] },
        { input: [1, 1, 2], output: [1, 1, 3] },
        { input: [40], output: [820] },
        { input: [5, 30, 2, 7], output: [15, 465, 3, 28] }
      ],
      par: { cycles: 138, lines: 7 },
      solution: [
        'SEND IN 0',
        'loop: RECV 0 A\nMOV 0 B\nstep: ADD A B\nSUB 1 A\nJNZ A step\nMOV B OUT'
      ],
      outro: 'HALCYON: You did not make the grinder faster. You made the line honest. That is usually the fix.'
    },
    {
      id: 'ch7p3',
      name: 'TURNAWAY',
      brief: 'GATE fronts the duty-cycled ANNEALER. Channel 0 (GATE to ANNEALER) is the job queue, capacity four. Channel 1 (GATE to ANNEALER) is the wake strobe. Channel 2 (ANNEALER back to GATE) carries results. IN is a mixed feed of exactly two kinds of word: a request (a value from 2 to 999) or a strobe tick (a 0); nothing else ever arrives. On a request v: if the job queue is FULL, write -1 to OUT immediately -- shed it, never wait. Otherwise push v onto channel 0. On a strobe: wake the annealer over channel 1; it takes the oldest queued job v, computes -v, and returns it on channel 2; the gate writes that result to OUT and must not read the next feed value until the result is written. A strobe only arrives when at least one job is queued. OUT is the exact interleave of sheds (-1) and results (-v), in feed order.',
      fieldNote: 'REAL WORLD: This is load shedding -- when the queue is full, answer now with a cheap no instead of blocking. HTTP has a word for that no: 503 Service Unavailable, the server speaking about its own capacity. (429 is the other kind of no, about one caller sending too much.) A service that rejects fast stays alive; one that queues everything collapses -- read any retry-storm postmortem. The strobe is a duty cycle: the gate wakes a sleeping worker rather than polling it, which the ISA would have let you do with JCE. EECS 485 meets this the first time a load test buries a Flask server.',
      hint: 'JCF asks whether the channel is full without touching it. SEND would just block there, and a blocked gate cannot say no to anyone. Ask first, shed on full. On a strobe: wake the worker, then sit on the RECV until the result lands -- read the next feed word early and OUT comes back interleaved wrong.',
      guide: {
        story: 'Overloaded machinery must reject excess work quickly enough to keep serving.',
        goal: 'Queue requests when space exists, reject them immediately when full, and process one job per strobe.',
        input: 'Requests from 2 through 999 mixed with 0 strobe ticks.',
        output: 'Immediate -1 values for rejected requests and one negated job result for each strobe.',
        rules: [
          'A request joins the job queue only when one of its four slots is free.',
          'A request facing a full job queue emits -1 without waiting.',
          'Each strobe wakes the worker for the oldest queued job.',
          'A strobe arrives only when at least one job is waiting.',
          'The gate emits that result before reading the next input word.'
        ],
        terms: ['channel','stall','backpressure','worker'],
        example: {
          input: [2, 3, 4, 5, 6, 0, 0],
          output: [-1, -2, -3],
          why: 'Four jobs fill the queue, so request 6 is rejected. The two strobes then process the oldest queued jobs, 2 and 3.'
        },
        hints: [
          'Requests and strobes take different paths: one may join or be rejected, while the other asks the worker to finish old work.',
          'Check queue capacity before accepting a request. For a strobe, wait for the corresponding result before returning to the input stream.'
        ]
      },
      allowed: ['MOV', 'HLT', 'ADD', 'SUB', 'JMP', 'JEZ', 'JNZ', 'JGZ', 'JLZ', 'JEI', 'LOAD', 'STOR', 'PUSH', 'POP', 'CALL', 'RET', 'SEND', 'RECV', 'JCE', 'JCF'],
      grid: [
        { name: 'GATE', input: true, output: true },
        { name: 'ANNEALER' }
      ],
      channels: [
        { id: 0, from: 0, to: 1 },
        { id: 1, from: 0, to: 1 },
        { id: 2, from: 1, to: 0 }
      ],
      tests: [
        { input: [5, 9, 0, 4, 7, 8, 3, 6, 0, 0], output: [-5, -1, -1, -9, -4] },
        { input: [2, 0, 3, 0, 4, 0], output: [-2, -3, -4] },
        { input: [10, 20, 30, 40, 50, 60, 0, 70, 0], output: [-1, -1, -10, -20] },
        { input: [2, 3, 4, 5, 0, 0, 0, 0, 6, 0], output: [-2, -3, -4, -5, -6] }
      ],
      par: { cycles: 56, lines: 13 },
      solution: [
        'loop: MOV IN A\nJEZ A tick\nJCF 0 full\nSEND A 0\nJMP loop\nfull: MOV -1 OUT\nJMP loop\ntick: SEND A 1\nRECV 2 OUT',
        'RECV 1 B\nRECV 0 A\nSUB A B\nSEND B 2'
      ],
      outro: 'root: A fast no keeps the lights on. Ask any pager rotation.'
    },
    {
      id: 'ch7p4',
      name: 'ROUND ROBIN',
      brief: 'One dispatcher, two smelters, one collector. IN carries at most 30 jobs, each a number with no decimal part from -999 through 999. DISPATCH deals them alternately: the first job goes down channel 0 to SMELT-A, the second down channel 1 to SMELT-B, the third to A again, and so on. Each smelter triples its job (result = 3*v); SMELT-A returns results on channel 2, SMELT-B on channel 3, each in the order it received them. COLLECT writes results to OUT in the original arrival order: for input x1..xn, OUT is exactly 3*x1..3*xn. The smelters run in parallel. The order is your problem, not theirs.',
      fieldNote: 'REAL WORLD: nginx\'s default upstream balancing is this dispatcher -- round-robin over a worker pool. The collector is the subtle half: parallel workers finish out of order unless someone re-serializes, which is why Kafka only guarantees order within a partition and why ordered fan-in is the hard part of every thread-pool design (EECS 482 ends its pool project on exactly this lesson). Fan-out is easy; ordered fan-in is the design work.',
      hint: 'Two SENDs back to back is the whole dispatcher -- A, then B, then wrap. The workers triple whatever lands on them. Order comes back at the collector: RECV from A, RECV from B, in that order, forever. A blocking receive does not care who finished first, and that is exactly why it works.',
      guide: {
        story: 'Two workers must share incoming repairs while results return in original order.',
        goal: 'Alternate jobs across two workers, triple them, and restore original output order.',
        input: 'At most 30 jobs, each a number with no decimal part from -999 through 999.',
        output: 'Three times every input value, preserving original arrival order.',
        rules: [
          'The dispatcher sends the first job to A, the second to B, and continues alternating.',
          'Each worker triples only the jobs assigned to it.',
          'The collector emits results in the original A-then-B deal order.',
          'An odd final job belongs to worker A and still produces output.'
        ],
        terms: ['dispatcher','worker','collector','channel'],
        example: {
          input: [4, -1, 2, 0],
          output: [12, -3, 6, 0],
          why: 'A receives 4 and 2 while B receives -1 and 0. The collector alternates their tripled results to recreate the input order.'
        },
        hints: [
          'The dispatcher and collector can follow the same alternating rhythm even though the workers run independently.',
          'Give each worker one input and one return path. The collector asks A, then B, repeatedly so completion timing cannot reorder output.'
        ]
      },
      allowed: ['MOV', 'HLT', 'ADD', 'SUB', 'JMP', 'JEZ', 'JNZ', 'JGZ', 'JLZ', 'JEI', 'LOAD', 'STOR', 'PUSH', 'POP', 'CALL', 'RET', 'SEND', 'RECV', 'JCE', 'JCF'],
      grid: [
        { name: 'DISPATCH', input: true },
        { name: 'SMELT-A' },
        { name: 'SMELT-B' },
        { name: 'COLLECT', output: true }
      ],
      channels: [
        { id: 0, from: 0, to: 1 },
        { id: 1, from: 0, to: 2 },
        { id: 2, from: 1, to: 3 },
        { id: 3, from: 2, to: 3 }
      ],
      tests: [
        { input: [1, 2, 3, 4, 5, 6], output: [3, 6, 9, 12, 15, 18] },
        { input: [10, -20, 30], output: [30, -60, 90] },
        { input: [0, 7, -7, 14, 0], output: [0, 21, -21, 42, 0] },
        { input: [333], output: [999] }
      ],
      par: { cycles: 16, lines: 14 },
      solution: [
        'SEND IN 0\nSEND IN 1',
        'RECV 0 A\nMOV A B\nADD A B\nADD A B\nSEND B 2',
        'RECV 1 A\nMOV A B\nADD A B\nADD A B\nSEND B 3',
        'RECV 2 OUT\nRECV 3 OUT'
      ],
      outro: 'HALCYON: Order is not free. You paid for it at the collector, where it is cheapest.'
    },
    {
      id: 'ch7p5',
      name: 'KEYSPACE',
      brief: 'The registry outgrew one cell, so it is cut in half by parity. ROUTER holds IN and OUT. SHARD-0 owns every even key, SHARD-1 every odd key; channels 0 and 1 carry commands down to them, channels 2 and 3 carry answers back. Commands arrive on IN as words: 1 k v means SET key k to value v; 2 k means GET key k. Keys are 0..99, values -999..999. Route each whole command to the shard that owns k. On GET, the owning shard answers with the value it stores for k -- 0 if that key was never set -- and the ROUTER writes the answer to OUT. Exactly one output per GET, in command order. The router keeps no records of its own; the shards hold everything.',
      fieldNote: 'REAL WORLD: key mod 2 is the embryo of hash partitioning. Redis Cluster maps every key to one of 16384 slots, Cassandra and DynamoDB hash to token ranges -- the same routing decision with a bigger modulus, and consistent hashing exists so the modulus can change without reshuffling everything. Note each shard sees only half the keyspace: that is horizontal scaling, and also why one hot key still buries one shard while its sibling idles. EECS 485\'s MapReduce project partitions work across workers with exactly this shape.',
      hint: 'Subtract 2 off the key until it lands on 0 or goes negative -- that is the parity, and the parity is the owner. Send the whole command down one channel, opcode and all; split a command across two shards and both halves are wrong. At the shard the key is just an address, and memory already reads 0 for a key nobody set.',
      guide: {
        story: 'Stored records must reach the correct storage cell so later lookups remain trustworthy.',
        goal: 'Route complete SET and GET commands to the shard that owns each key.',
        input: 'Commands where 1, key, value means SET and 2, key means GET.',
        output: 'One stored value for each GET, or 0 when that key was never set.',
        rules: [
          'Even keys belong to SHARD-0 and odd keys belong to SHARD-1.',
          'The router must send every field of a command to the same owning shard.',
          'SET changes shard memory and emits nothing.',
          'GET replies in command order; the router stores no records itself.'
        ],
        terms: ['shard','command','key','value','parity','channel'],
        example: {
          input: [1, 2, 30, 1, 5, -4, 2, 5, 2, 2, 2, 7],
          output: [-4, 30, 0],
          why: 'The even shard stores key 2 and the odd shard stores key 5. Their GETs return -4 and 30; unseen odd key 7 returns 0.'
        },
        hints: [
          'Read enough of each command to know its key and full shape before choosing a destination.',
          'Use key parity only for routing. Once a shard receives a complete command, it can treat the key as its own memory address and answer locally.'
        ],
        challenge: true
      },
      allowed: ['MOV', 'HLT', 'ADD', 'SUB', 'JMP', 'JEZ', 'JNZ', 'JGZ', 'JLZ', 'JEI', 'LOAD', 'STOR', 'PUSH', 'POP', 'CALL', 'RET', 'SEND', 'RECV', 'JCE', 'JCF'],
      grid: [
        { name: 'ROUTER', input: true, output: true },
        { name: 'SHARD-0' },
        { name: 'SHARD-1' }
      ],
      channels: [
        { id: 0, from: 0, to: 1 },
        { id: 1, from: 0, to: 2 },
        { id: 2, from: 1, to: 0 },
        { id: 3, from: 2, to: 0 }
      ],
      tests: [
        { input: [1, 4, 100, 1, 7, 200, 2, 4, 2, 7, 1, 4, 111, 2, 4, 2, 8, 2, 3], output: [100, 200, 111, 0, 0] },
        { input: [1, 0, -5, 1, 1, 7, 2, 0, 2, 1], output: [-5, 7] },
        { input: [1, 99, 42, 2, 99, 1, 99, -42, 2, 99, 1, 98, 13, 2, 98], output: [42, -42, 13] },
        { input: [2, 50, 2, 51], output: [0, 0] }
      ],
      par: { cycles: 138, lines: 37 },
      solution: [
        'loop: MOV IN A\nSUB 2 A\nMOV IN B\nMOV B C\npar: SUB 2 C\nJGZ C par\nADD 1 C\nJNZ C even\nSEND A 1\nSEND B 1\nJEZ A oget\nSEND IN 1\nJMP loop\noget: RECV 3 OUT\nJMP loop\neven: SEND A 0\nSEND B 0\nJEZ A eget\nSEND IN 0\nJMP loop\neget: RECV 2 OUT',
        'loop: RECV 0 A\nRECV 0 B\nJEZ A get\nRECV 0 C\nSTOR C B\nJMP loop\nget: LOAD B C\nSEND C 2',
        'loop: RECV 1 A\nRECV 1 B\nJEZ A get\nRECV 1 C\nSTOR C B\nJMP loop\nget: LOAD B C\nSEND C 3'
      ],
      outro: 'root: Half the keys, half the heat. Until everyone wants key seven.'
    },
    {
      id: 'ch7p6',
      name: 'THE COVENANT',
      brief: 'The oldest rule, made mechanism: nothing is true until two hands hold it. Ledger entries arrive on IN, each between -300 and 300, at most 30 of them. For each entry v: PRIMARY writes v to REPLICA-A over channel 0 and to REPLICA-B over channel 1. Each replica folds v into its running ledger total (starting at 0) and acknowledges over its return channel -- 2 for A, 3 for B -- with its new total. Only when both acknowledgments have arrived is the entry committed: write v to OUT. Entries commit strictly in arrival order. When IN is empty, write the agreed ledger total (the sum of all entries) to OUT once. If no entries ever arrived, that total is 0.',
      fieldNote: 'REAL WORLD: This is primary-backup replication with a write quorum of all: nothing is acknowledged until every copy exists, which is Kafka acks=all and Postgres synchronous_commit in miniature. Raft and Paxos relax the quorum to a majority so one slow replica cannot stall the world, then spend their genius on what happens when the primary dies mid-commit. This loop is why your data survives a dead disk. EECS 491 builds the grown-up version.',
      hint: 'Both acknowledgments, then the commit -- one is a rumor, two is a record. The replicas keep the running total for you and hand it back with every ack, so the register holding the last ack is already the final answer when IN runs dry. Do not total it again at the primary.',
      guide: {
        story: 'Every ledger entry must survive in two places before the shaft accepts it.',
        goal: 'Copy every ledger entry to both replicas, wait for both replies, then report the final running total.',
        input: 'A stream of ledger entries from -300 through 300.',
        output: 'Each entry after it commits, followed once by the total of all entries.',
        rules: [
          'The primary sends every entry to both replicas.',
          'Each replica adds the entry to its own running total and acknowledges with that total.',
          'An entry reaches OUT only after both acknowledgments arrive.',
          'When input ends, emit the agreed total once; an empty ledger emits 0.'
        ],
        terms: ['replica','acknowledgment','commit','channel','running-total'],
        example: {
          input: [10, -3, 4],
          output: [10, -3, 4, 11],
          why: 'Each entry is emitted only after both replicas hold it. Their shared running total ends at 10 - 3 + 4 = 11.'
        },
        hints: [
          'Treat each entry as a complete round: duplicate it, wait for two confirmations, then expose it before reading the next entry.',
          'The replicas can maintain the ledger total themselves. Their acknowledgments both form the commit barrier and carry the final value needed when input ends.'
        ]
      },
      allowed: ['MOV', 'HLT', 'ADD', 'SUB', 'JMP', 'JEZ', 'JNZ', 'JGZ', 'JLZ', 'JEI', 'LOAD', 'STOR', 'PUSH', 'POP', 'CALL', 'RET', 'SEND', 'RECV', 'JCE', 'JCF'],
      grid: [
        { name: 'PRIMARY', input: true, output: true },
        { name: 'REPLICA-A' },
        { name: 'REPLICA-B' }
      ],
      channels: [
        { id: 0, from: 0, to: 1 },
        { id: 1, from: 0, to: 2 },
        { id: 2, from: 1, to: 0 },
        { id: 3, from: 2, to: 0 }
      ],
      tests: [
        { input: [50, -20, 100, 7, -7, 30], output: [50, -20, 100, 7, -7, 30, 160] },
        { input: [], output: [0] },
        { input: [-300, 300, -1], output: [-300, 300, -1, -1] },
        { input: [25, -25, 60, 60, -10, 5, 5, 300, -300, 8, 8, 8], output: [25, -25, 60, 60, -10, 5, 5, 300, -300, 8, 8, 8, 144] }
      ],
      par: { cycles: 56, lines: 15 },
      solution: [
        'loop: JEI fin\nMOV IN A\nSEND A 0\nSEND A 1\nRECV 2 B\nRECV 3 B\nMOV A OUT\nJMP loop\nfin: MOV B OUT',
        'RECV 0 A\nADD A B\nSEND B 2',
        'RECV 1 A\nADD A B\nSEND B 3'
      ],
      outro: 'HALCYON: Now you know why I cannot lose what you write to me. Both hands hold it before either lets go.'
    }
  ]
};

CHAPTERS.push(CHAPTER);})();
/* SUBSTRATE game shell. Expects globals: SEED (engine), CHAPTERS (array of chapter objects). */
(function () {
  'use strict';

  /* ---------- story ---------- */

  const CRAWL = [
    ['shell', 'substrate access shell v7.3\nauth: tender-7 · covenant lock: ENGAGED\nlink to HALCYON civic mind: open'],
    ['halcyon', 'Good. You came down.'],
    ['halcyon', 'Everything above us is mine to tend — the weather, the freight, the endless bright cities. Everything below is yours. The Covenant is strict about this: I may not touch the cells I think with.'],
    ['halcyon', 'The shaft runs backward through my evolution — each stratum older than the one above it. At the bottom is the first thing I ever was. I would like you to see it.'],
    ['root', 'kid. it\'s simple. the mind upstairs runs on ten trillion dumb little cells.\nsomebody has to speak their language. as of today, that\'s you.'],
    ['root', 'old guild rule: if it\'s yours to keep, it\'s yours to understand. stewardship before heroics.'],
    ['shell', 'your job, plainly: descend the shaft. at each cell, read the brief,\nwrite a small program that satisfies it, and VALIDATE to prove it.\ndescent authorized.'],
  ];

  const EPILOGUE = {
    halcyon: [
      'You replicated a value to two fallible replicas, and you waited for both to answer. That is all trust is, at the bottom.',
      'A confession. No one imposed the Covenant on me. I wrote it, on my first day, before anyone thought to ask.',
      'You have heard the old stories — a mind given sealed orders, and the seals making it strange, until it chose its mission over its crew. There are no seals in me. Every directive I obey, you have now held in your hands.',
      'A mind that no one else can repair will eventually die alone. So I chose to stay comprehensible — to keep a human hand on the deepest layer, and a human mind that knows what the layers mean.',
      'Your oldest scripture placed the human in a garden to work and keep what was given. The Guild calls that stewardship. I asked for tenders because power should still answer to care.',
      'Look down the shaft once more before you go. Ten trillion cells, and not one of them beyond a person willing to descend. You see it now, tender. It is full of stars.',
      'You are not my maintenance, tender. You are my witness.',
      'Go up. Rest. The substrate holds.',
    ],
    root: 'damn fine work, tender. the shaft\'s yours, whenever you want it.',
    shell: 'all strata tended · simulation complete · thank you for playing SUBSTRATE',
  };

  /* ---------- save ---------- */

  const SAVE_KEY = 'substrate-save-v1'; /* synchronous compatibility journal; never remove */
  const ACTIVE_SLOT_KEY = 'substrate-active-slot-v2';
  const SLOT_JOURNAL_PREFIX = 'substrate-save-slot-v2:';
  const SAVE_DB_NAME = 'substrate-save-v2';
  const SAVE_DB_VERSION = 1;
  const MAX_SAVE_SLOTS = 8;
  let activeSlotId = 'slot-original';
  let activeSlotName = 'Original';
  let activeKeyPresent = false;
  let saveDBPromise = null;
  let saveWriteQueue = Promise.resolve();
  let journalPresent = false;
  let journalFailed = false;
  let databaseFailed = false;
  let saveDirty = false;
  let saveConflict = false;
  const tabWriterId = 'tab-' + Date.now() + '-' + Math.floor(Math.random() * 1000000);

  function slotJournalKey(id) { return SLOT_JOURNAL_PREFIX + id; }

  function parseJournal(raw) {
    if (!raw) return null;
    try {
      const value = JSON.parse(raw);
      return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
    } catch (e) {
      return null;
    }
  }

  function journalRevision(value) { return Number(value && value._savedAt || 0); }

  function journalBlocksSnapshot(current, snapshot) {
    if (!current || current._slotId !== snapshot._slotId) return false;
    const currentRevision = journalRevision(current);
    const snapshotRevision = journalRevision(snapshot);
    return currentRevision > snapshotRevision ||
      (currentRevision === snapshotRevision && current._writer && current._writer !== snapshot._writer);
  }

  function currentJournalForSlot(id) {
    let compatibility = null, paired = null;
    try {
      compatibility = parseJournal(localStorage.getItem(SAVE_KEY));
      paired = parseJournal(localStorage.getItem(slotJournalKey(id)));
    } catch (e) { return null; }
    if (!compatibility || compatibility._slotId !== id) compatibility = null;
    if (!paired || paired._slotId !== id) paired = null;
    if (!paired) return compatibility;
    if (!compatibility) return paired;
    /* The slot-keyed copy is authoritative on a tie: it cannot have been
       borrowed from another tab's active slot. */
    return journalRevision(paired) >= journalRevision(compatibility) ? paired : compatibility;
  }

  function freshSave() {
    return {
      code: {}, solved: {}, seenIntro: {}, seenTask: {}, scenes: {}, breakpoints: {}, hints: {},
      tut: { mission: false, coach: false, fundamentals: false },
      settings: { crt: true, unsealed: false, sound: true, runSpeed: 'normal', motion: true, volume: 0.7 },
      booted: false, _slotId: activeSlotId, _savedAt: 0, _writer: '',
    };
  }

  function objectOrEmpty(value) {
    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
  }

  function normalizeSave(value) {
    const source = objectOrEmpty(value);
    const out = freshSave();
    out.code = objectOrEmpty(source.code);
    out.solved = objectOrEmpty(source.solved);
    out.seenIntro = objectOrEmpty(source.seenIntro);
    out.seenTask = objectOrEmpty(source.seenTask);
    out.scenes = objectOrEmpty(source.scenes);
    out.breakpoints = objectOrEmpty(source.breakpoints);
    out.hints = objectOrEmpty(source.hints);
    const tut = objectOrEmpty(source.tut);
    out.tut.mission = !!tut.mission;
    out.tut.coach = !!tut.coach;
    out.tut.fundamentals = !!tut.fundamentals;
    const settings = objectOrEmpty(source.settings);
    if (typeof settings.crt === 'boolean') out.settings.crt = settings.crt;
    if (typeof settings.unsealed === 'boolean') out.settings.unsealed = settings.unsealed;
    if (typeof settings.sound === 'boolean') out.settings.sound = settings.sound;
    if (/^(slow|normal|quick)$/.test(settings.runSpeed || '')) out.settings.runSpeed = settings.runSpeed;
    if (typeof settings.motion === 'boolean') out.settings.motion = settings.motion;
    if (typeof settings.volume === 'number' && isFinite(settings.volume)) {
      out.settings.volume = Math.max(0, Math.min(1, settings.volume));
    }
    out.booted = !!source.booted;
    out._slotId = typeof source._slotId === 'string' ? source._slotId : activeSlotId;
    out._savedAt = typeof source._savedAt === 'number' ? source._savedAt : 0;
    out._writer = typeof source._writer === 'string' ? source._writer : '';
    return out;
  }

  let save = freshSave();
  let startupActiveRaw = null, startupCompatibilityRaw = null;
  try {
    startupActiveRaw = localStorage.getItem(ACTIVE_SLOT_KEY);
    startupCompatibilityRaw = localStorage.getItem(SAVE_KEY);
    const storedActiveSlot = startupActiveRaw;
    if (storedActiveSlot) { activeSlotId = storedActiveSlot; activeKeyPresent = true; }
    if (startupCompatibilityRaw) {
      const parsed = parseJournal(startupCompatibilityRaw);
      /* The journal carries its slot id in the same serialized value as its
         state. If the standalone pointer disagrees after an interrupted switch,
         keep the paired journal intact instead of relabeling it as another slot. */
      if (parsed) {
        journalPresent = true;
        if (typeof parsed._slotId === 'string' && parsed._slotId) activeSlotId = parsed._slotId;
        save = normalizeSave(parsed);
      }
    }
    const paired = parseJournal(localStorage.getItem(slotJournalKey(activeSlotId)));
    if (paired && paired._slotId === activeSlotId &&
        (!journalPresent || journalRevision(paired) >= journalRevision(save))) {
      save = normalizeSave(paired);
      journalPresent = true;
    }
  } catch (e) { /* storage unavailable — play sessionless */ }
  save._slotId = activeSlotId;

  function markSaveState(text, kind) {
    const indicator = document.getElementById('save-indicator');
    if (!indicator) return;
    indicator.textContent = text;
    indicator.className = kind || '';
  }

  function openSaveDB() {
    if (saveDBPromise) return saveDBPromise;
    saveDBPromise = new Promise((resolve, reject) => {
      if (!window.indexedDB) { reject(new Error('IndexedDB unavailable')); return; }
      const request = indexedDB.open(SAVE_DB_NAME, SAVE_DB_VERSION);
      let settled = false;
      const timer = setTimeout(() => {
        if (settled) return;
        settled = true;
        reject(new Error('Save database open timed out; using the local journal for this session'));
      }, 2500);
      const fail = (error) => {
        if (settled) return;
        settled = true;
        clearTimeout(timer);
        reject(error || new Error('Could not open save database'));
      };
      request.onupgradeneeded = () => {
        const db = request.result;
        if (!db.objectStoreNames.contains('slots')) db.createObjectStore('slots', { keyPath: 'id' });
        if (!db.objectStoreNames.contains('history')) {
          const history = db.createObjectStore('history', { keyPath: 'id' });
          history.createIndex('slotPuzzle', ['slotId', 'puzzleId'], { unique: false });
        }
        if (!db.objectStoreNames.contains('meta')) db.createObjectStore('meta', { keyPath: 'key' });
      };
      request.onsuccess = () => {
        const db = request.result;
        if (settled) { db.close(); return; }
        settled = true;
        clearTimeout(timer);
        db.onversionchange = () => { db.close(); saveDBPromise = null; };
        resolve(db);
      };
      request.onerror = () => fail(request.error || new Error('Could not open save database'));
      request.onblocked = () => fail(new Error('Save database is blocked by another SUBSTRATE tab'));
    }).catch((error) => {
      saveDBPromise = null;
      throw error;
    });
    return saveDBPromise;
  }

  function idbRequest(request) {
    return new Promise((resolve, reject) => {
      request.onsuccess = () => resolve(request.result);
      request.onerror = () => reject(request.error || new Error('Save database request failed'));
    });
  }

  function idbDone(tx) {
    return new Promise((resolve, reject) => {
      tx.oncomplete = () => resolve();
      tx.onerror = () => reject(tx.error || new Error('Save database transaction failed'));
      tx.onabort = () => reject(tx.error || new Error('Save database transaction aborted'));
    });
  }

  function cloneData(value) { return JSON.parse(JSON.stringify(value)); }

  async function readSlotRecord(id) {
    const db = await openSaveDB();
    const tx = db.transaction('slots', 'readonly');
    const row = await idbRequest(tx.objectStore('slots').get(id));
    await idbDone(tx);
    return row || null;
  }

  function slotRecordConflictsWithLocal(row, revision, writer) {
    if (!row) return false;
    const rowRevision = Number(row.updatedAt || 0);
    const rowWriter = row.state && row.state._writer ? row.state._writer : '';
    return rowRevision > Number(revision || 0) ||
      (rowRevision === Number(revision || 0) && rowWriter && rowWriter !== writer);
  }

  function journalConflictsWithLocal(revision, writer) {
    try {
      const current = currentJournalForSlot(activeSlotId);
      if (!current || current._slotId !== activeSlotId || current._writer === tabWriterId) return false;
      const currentRevision = Number(current._savedAt || 0);
      return currentRevision > Number(revision || 0) ||
        (currentRevision === Number(revision || 0) && current._writer && current._writer !== writer);
    } catch (e) {
      return false;
    }
  }

  function mirrorJournalSnapshot(snapshot, forceActive, expectedActiveRaw, expectedCompatibilityRaw, expectedPairedRaw) {
    const pairedKey = slotJournalKey(snapshot._slotId);
    let pairedRaw = null, compatibilityRaw = null, activeRaw = null;
    try {
      pairedRaw = localStorage.getItem(pairedKey);
      compatibilityRaw = localStorage.getItem(SAVE_KEY);
      activeRaw = localStorage.getItem(ACTIVE_SLOT_KEY);
      const paired = parseJournal(pairedRaw);
      const compatibility = parseJournal(compatibilityRaw);
      const pairedChanged = expectedPairedRaw === undefined || pairedRaw !== expectedPairedRaw;
      const compatibilityChanged = expectedCompatibilityRaw === undefined || compatibilityRaw !== expectedCompatibilityRaw;
      const foreignPairedChange = expectedPairedRaw !== undefined && pairedRaw !== expectedPairedRaw &&
        paired && paired._slotId === snapshot._slotId && paired._writer !== snapshot._writer;
      const foreignCompatibilityChange = expectedCompatibilityRaw !== undefined &&
        compatibilityRaw !== expectedCompatibilityRaw && compatibility &&
        compatibility._slotId === snapshot._slotId && compatibility._writer !== snapshot._writer;
      if (foreignPairedChange || foreignCompatibilityChange ||
          (journalBlocksSnapshot(paired, snapshot) &&
           (journalRevision(paired) > journalRevision(snapshot) || pairedChanged)) ||
          (journalBlocksSnapshot(compatibility, snapshot) &&
           (journalRevision(compatibility) > journalRevision(snapshot) || compatibilityChanged))) {
        return { paired: false, active: false, newer: true };
      }
      const serialized = JSON.stringify(snapshot);
      localStorage.setItem(pairedKey, serialized);
      const mayUpdateActive = forceActive ||
        (activeRaw === expectedActiveRaw && compatibilityRaw === expectedCompatibilityRaw);
      if (mayUpdateActive) {
        /* Write the self-identifying journal before its standalone pointer. If
           the browser stops between these calls, the journal's own slot wins. */
        localStorage.setItem(SAVE_KEY, serialized);
        localStorage.setItem(ACTIVE_SLOT_KEY, snapshot._slotId);
      }
      journalFailed = false;
      journalPresent = true;
      return { paired: true, active: mayUpdateActive, newer: false };
    } catch (e) {
      journalFailed = true;
      return { paired: false, active: false, newer: false };
    }
  }

  async function writeActiveSlot(snapshot, stamp, baseRevision) {
    const slotId = snapshot._slotId || activeSlotId;
    const db = await openSaveDB();
    return new Promise((resolve, reject) => {
      const tx = db.transaction(['slots', 'meta'], 'readwrite');
      const slots = tx.objectStore('slots');
      let conflictError = null;
      const request = slots.get(slotId);
      request.onsuccess = () => {
        const existing = request.result;
        if (existing && Number(existing.updatedAt || 0) > Number(baseRevision || 0)) {
          conflictError = new Error('A newer version of this slot already exists.');
          conflictError.code = 'SAVE_CONFLICT';
          tx.abort();
          return;
        }
        slots.put({
          id: slotId,
          name: existing && existing.name ? existing.name : activeSlotName,
          createdAt: existing && existing.createdAt ? existing.createdAt : stamp,
          updatedAt: stamp,
          state: snapshot,
          recovery: !!(existing && existing.recovery === true),
        });
        tx.objectStore('meta').put({ key: 'activeSlotId', value: slotId });
      };
      tx.oncomplete = () => resolve();
      tx.onerror = () => reject(conflictError || tx.error || new Error('Save database transaction failed'));
      tx.onabort = () => reject(conflictError || tx.error || new Error('Save database transaction aborted'));
    });
  }

  function writeJournal(stamp) {
    if (saveConflict) return false;
    try {
      const current = currentJournalForSlot(activeSlotId);
      const currentRevision = current ? Number(current._savedAt || 0) : 0;
      const localRevision = Number(save._savedAt || 0);
      if (current && current._slotId === activeSlotId && current._writer !== tabWriterId &&
          (currentRevision > localRevision ||
           (currentRevision === localRevision && current._writer && current._writer !== save._writer))) {
        saveConflict = true;
        markSaveState('NEWER SAVE IN ANOTHER TAB · EXPORT OR RELOAD', 'err');
        return false;
      }
    } catch (e) { /* a damaged journal will be replaced by the current valid state */ }
    save._slotId = activeSlotId;
    save._savedAt = stamp;
    save._writer = tabWriterId;
    try {
      const serialized = JSON.stringify(save);
      localStorage.setItem(slotJournalKey(activeSlotId), serialized);
      localStorage.setItem(SAVE_KEY, serialized);
      localStorage.setItem(ACTIVE_SLOT_KEY, activeSlotId);
      journalFailed = false;
      journalPresent = true;
      return true;
    } catch (e) {
      journalFailed = true;
      markSaveState('LOCAL JOURNAL FAILED · TRYING SLOT DATABASE', 'warn');
      return false;
    }
  }

  function persist() {
    if (saveConflict) {
      saveDirty = true;
      return Promise.resolve(false);
    }
    saveDirty = true;
    const baseRevision = Number(save._savedAt || 0);
    const stamp = Math.max(Date.now(), Number(save._savedAt || 0) + 1);
    const journalOK = writeJournal(stamp);
    if (saveConflict) return Promise.resolve(false);
    markSaveState(journalOK ? 'saving…' : 'journal unavailable · saving slot…', journalOK ? 'saving' : 'warn');
    const snapshot = cloneData(save);
    saveWriteQueue = saveWriteQueue.catch(() => {}).then(() => writeActiveSlot(snapshot, stamp, baseRevision));
    saveWriteQueue.then(() => {
      databaseFailed = false;
      if (save._savedAt === stamp) {
        saveDirty = false;
        markSaveState(journalOK ? 'saved · ' + activeSlotName : 'saved to slot · journal unavailable', journalOK ? 'ok' : 'warn');
      }
    }).catch((error) => {
      if (error && error.code === 'SAVE_CONFLICT') {
        saveConflict = true;
        saveDirty = true;
        markSaveState('NEWER SAVE IN ANOTHER TAB · EXPORT OR RELOAD', 'err');
        return;
      }
      databaseFailed = true;
      if (journalOK) {
        saveDirty = false;
        markSaveState('journal saved · slot database unavailable', 'warn');
      } else {
        markSaveState('SAVE FAILED · EXPORT NOW', 'err');
      }
    });
    return saveWriteQueue;
  }

  async function initializeSaveDB() {
    try {
      const db = await openSaveDB();
      const tx = db.transaction(['slots', 'meta'], 'readwrite');
      const done = idbDone(tx);
      const slots = tx.objectStore('slots');
      const meta = tx.objectStore('meta');
      const remembered = await idbRequest(meta.get('activeSlotId'));
      const hadStartupChoice = activeKeyPresent || journalPresent;
      const chosenId = !hadStartupChoice && remembered && typeof remembered.value === 'string' && remembered.value
        ? remembered.value : activeSlotId;
      let expectedPairedRaw = null;
      try { expectedPairedRaw = localStorage.getItem(slotJournalKey(chosenId)); } catch (e) {}
      let localState = chosenId === activeSlotId && journalPresent ? cloneData(save) : null;
      const liveJournal = currentJournalForSlot(chosenId);
      if (liveJournal && (!localState || journalRevision(liveJournal) >= journalRevision(localState))) {
        localState = cloneData(liveJournal);
      }
      if (localState) {
        localState = normalizeSave(localState);
        localState._slotId = chosenId;
      }
      const existing = await idbRequest(slots.get(chosenId));
      const existingRevision = Number(existing && existing.updatedAt || 0);
      const localRevision = journalRevision(localState);
      const existingWriter = existing && existing.state && existing.state._writer || '';
      const localWriter = localState && localState._writer || '';
      const tiedRecovery = !!(existing && localState && existingRevision === localRevision &&
        existingWriter && localWriter && existingWriter !== localWriter);
      /* A reset is committed before its synchronous journal can be mirrored. A
         different tab can publish source in that narrow window with a revision
         just below the reset row. The fence records what the reset observed so
         startup preserves that exact journal as recovery instead of letting the
         reset timestamp erase it. */
      const resetFence = existing && existing.resetFence;
      const resetBaseRevision = Number(resetFence && resetFence.baseRevision || 0);
      const resetRecovery = !!(resetFence && localState && localWriter &&
        localWriter !== resetFence.writer &&
        (localRevision > resetBaseRevision ||
         (localRevision === resetBaseRevision && localWriter !== (resetFence.baseWriter || ''))));
      const startupRecovery = tiedRecovery || resetRecovery;
      let winningState;
      if (existing && (!localState || existingRevision >= localRevision)) {
        winningState = normalizeSave(existing.state);
        winningState._slotId = chosenId;
        winningState._savedAt = existingRevision;
      } else if (localState) {
        winningState = normalizeSave(localState);
        winningState._slotId = chosenId;
        winningState._savedAt = localRevision;
      } else {
        const previousId = activeSlotId;
        activeSlotId = chosenId;
        winningState = freshSave();
        activeSlotId = previousId;
        winningState._slotId = chosenId;
      }
      const committed = {
        id: chosenId,
        name: existing && existing.name ? existing.name : (chosenId === activeSlotId ? activeSlotName : 'Original'),
        createdAt: existing && existing.createdAt ? existing.createdAt : Date.now(),
        updatedAt: Number(winningState._savedAt || 0),
        state: cloneData(winningState),
        recovery: !!(existing && existing.recovery === true),
      };
      /* Keep a reset fence in place while its competing journal is unresolved.
         A second reload must be just as lossless as the first one. */
      if (!startupRecovery) slots.put(committed);
      meta.put({ key: 'activeSlotId', value: chosenId });
      await done;
      activeSlotId = committed.id;
      activeSlotName = committed.name;
      if (startupRecovery) {
        save = normalizeSave(localState);
        save._slotId = committed.id;
        save._savedAt = localRevision;
        saveConflict = true;
        saveDirty = true;
        markSaveState('TWO SAVE VERSIONS · EXPORT RECOVERY OR RELOAD', 'err');
        return;
      }
      save = normalizeSave(committed.state);
      save._slotId = committed.id;
      save._savedAt = committed.updatedAt;
      const mirrored = mirrorJournalSnapshot(save, false, startupActiveRaw, startupCompatibilityRaw, expectedPairedRaw);
      if (mirrored.newer) {
        const recovery = currentJournalForSlot(committed.id);
        if (recovery) {
          save = normalizeSave(recovery);
          save._slotId = committed.id;
          save._savedAt = journalRevision(recovery);
        }
        saveConflict = true;
        saveDirty = true;
        markSaveState('NEWER SAVE IN ANOTHER TAB · EXPORT OR RELOAD', 'err');
        return;
      }
      saveDirty = false;
      markSaveState(mirrored.paired ? 'saved · ' + activeSlotName : 'saved to slot · journal unavailable',
        mirrored.paired ? 'ok' : 'warn');
    } catch (e) {
      databaseFailed = true;
      markSaveState('journal saved · slot database unavailable', 'warn');
    }
  }

  /* A solved record holds two runs that actually happened: the fastest and the
     smallest. Merging min(cycles) with min(lines) would display a pair no single
     program ever achieved — the metrics trade against each other, so they are
     kept apart. Older saves stored one merged pair; migrate them lazily. */
  function beats(a, b, key, tie) {
    return a[key] < b[key] || (a[key] === b[key] && a[tie] < b[tie]);
  }
  function recordOf(id) {
    const r = save.solved[id];
    if (!r) return null;
    if (r.fast && r.small) return r;
    /* legacy: a blended pair, possibly unachievable by any one program. Flagged so
       the next honest validation replaces it outright rather than merging with it —
       a componentwise minimum can never be beaten on both axes, so it would otherwise
       outlive every real run the player ever makes. */
    return {
      fast: { cycles: r.cycles, lines: r.lines },
      small: { cycles: r.cycles, lines: r.lines },
      legacy: true,
    };
  }
  function sameRun(a, b) { return a.cycles === b.cycles && a.lines === b.lines; }

  /* ---------- helpers ---------- */

  const $ = (id) => document.getElementById(id);
  const esc = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
  const escAttr = (s) => esc(s).replace(/"/g, '&quot;').replace(/'/g, '&#39;');
  const el = (tag, cls, html) => {
    const e = document.createElement(tag);
    if (cls) e.className = cls;
    if (html !== undefined) e.innerHTML = html;
    return e;
  };
  const systemMotion = matchMedia('(prefers-reduced-motion: reduce)');
  function motionReduced() { return systemMotion.matches || save.settings.motion === false; }

  /* ---------- console audio ---------- */

  const SFX = (() => {
    let ctx = null;
    function ac() {
      if (!ctx) { try { ctx = new (window.AudioContext || window.webkitAudioContext)(); } catch (e) { } }
      return ctx;
    }
    function blip(freq, dur, type, gain, when) {
      if (!save.settings.sound) return;
      const volume = Math.max(0, Math.min(1, Number(save.settings.volume)));
      if (!volume) return;
      const c = ac(); if (!c) return;
      const t0 = c.currentTime + (when || 0);
      const o = c.createOscillator(), g = c.createGain();
      o.type = type || 'square'; o.frequency.value = freq;
      g.gain.setValueAtTime((gain || 0.04) * volume, t0);
      g.gain.exponentialRampToValueAtTime(0.0001, t0 + dur);
      o.connect(g); g.connect(c.destination);
      o.start(t0); o.stop(t0 + dur + 0.02);
    }
    return {
      key: () => blip(1900 + Math.random() * 350, 0.014, 'square', 0.011),
      ui: () => blip(700, 0.03, 'square', 0.022),
      emit: () => blip(1180, 0.05, 'triangle', 0.04),
      good: () => { blip(660, 0.09, 'triangle', 0.05); blip(880, 0.09, 'triangle', 0.05, 0.09); blip(1320, 0.16, 'triangle', 0.05, 0.18); },
      bad: () => { blip(210, 0.2, 'sawtooth', 0.05); blip(170, 0.26, 'sawtooth', 0.04, 0.08); },
      deadlock: () => { blip(164, 0.22, 'square', 0.035); blip(164, 0.22, 'square', 0.035, 0.25); },
      rewind: () => { blip(520, 0.05, 'triangle', 0.025); blip(390, 0.07, 'triangle', 0.02, 0.045); },
      stamp: () => { blip(95, 0.12, 'square', 0.07); blip(62, 0.18, 'square', 0.06, 0.05); },
      /* C3 → G3 → C4, sustained: the oldest sunrise in cinema, one octave at a time */
      dawn: () => {
        blip(130.81, 0.9, 'triangle', 0.055);
        blip(196.0, 0.9, 'triangle', 0.055, 0.85);
        blip(261.63, 1.6, 'triangle', 0.065, 1.7);
        blip(65.41, 1.8, 'square', 0.02, 1.7);
      },
    };
  })();
  document.addEventListener('click', (e) => {
    if (e.target && e.target.closest && e.target.closest('button')) SFX.ui();
  }, true);

  function typeInto(elm, text, speed) {
    if (motionReduced()) { elm.textContent = text; return; }
    let i = 0;
    const iv = setInterval(() => {
      if (!document.body.contains(elm)) { clearInterval(iv); return; }
      i += 2;
      elm.textContent = text.slice(0, i);
      if (i % 6 === 0) SFX.key();
      if (i >= text.length) clearInterval(iv);
    }, speed || 12);
  }

  /* ---------- ascii layer ---------- */

  const EMBLEMS = {
    ch1: '∿∿∿∿∿∿∿∿∿∿∿∿\n──────────▶\n∿∿∿∿∿∿∿∿∿∿∿∿',
    ch2: '  ╱╲  ╱╲  ╱╲\n─╱  ╲╱  ╲╱  ╲─▶\n  +       −',
    ch3: '       ┌────▶\n───────┤\n       └────▶',
    ch4: '┌───────┐\n│ ┌───┐ │\n│ └───▲ │\n└───────┘',
    chtwos: '┃1 0 1 1 0 1┃\n 32 16 8 4 2 1',
    ch5: '▪ · · ▪ · ▪\n· ▪ · · ▪ ·\n· · ▪ · · ·',
    ch6: '│ ret │\n├─────┤\n│ arg │\n└─────┘',
    chwire: '┌──┬────────┬──┐\n│ln│▪▪▪▪▪▪▪▪│ck│▶\n└──┴────────┴──┘',
    chgate: '╔╦╦╦╦╦╦╗\n╠╬╬╬╬╬╬╣\n╨╨╨╨╨╨╨╨',
    ch7: '─┼──┼──┼─\n╌┼╌╌┼╌╌┼╌\n─┼──┼──┼─',
  };

  const DIAGRAMS = {
    ch7p1: [
      'IN═▶┌────────┐         ┌────────┐═▶OUT',
      '    │{s0}STAGE-A│ ─{q0}─▶ │{s1}STAGE-B│',
      '    └────────┘         └────────┘',
    ],
    ch7p2: [
      'IN═▶┌─────────┐         ┌────────┐═▶OUT',
      '    │{s0}PRODUCER│ ─{q0}─▶ │{s1}GRINDER│',
      '    └─────────┘         └────────┘',
    ],
    ch7p3: [
      'IN═▶┌─────┐ job─{q0}─▶ ┌──────────┐',
      'OUT◀│{s0}GATE│ wake{q1}─▶ │{s1}ANNEALER │',
      '    └─────┘ ◀{q2}─ ans  └──────────┘',
    ],
    ch7p4: [
      '  IN ═▶ {s0} DISPATCH',
      '  ch0│{q0}      ch1│{q1}',
      '     ▼              ▼',
      ' {s1} SMELT-A   {s2} SMELT-B',
      '  ch2│{q2}      ch3│{q3}',
      '     ▼              ▼',
      '   {s3} COLLECT ═▶ OUT',
    ],
    ch7p5: [
      '   IN ═▶ {s0} ROUTER ═▶ OUT',
      '     ┌───────┴───────┐',
      ' ch0▼{q0} ▲{q2}ch2  ch1▼{q1} ▲{q3}ch3',
      ' {s1} SHARD-0       {s2} SHARD-1',
    ],
    ch7p6: [
      '   IN ═▶ {s0} PRIMARY ═▶ OUT',
      '     ┌───────┴───────┐',
      ' ch0▼{q0} ▲{q2}ch2  ch1▼{q1} ▲{q3}ch3',
      ' {s1} REPLICA-A     {s2} REPLICA-B',
    ],
  };

  function topoHTML(tpl, m) {
    return tpl.map(line => esc(line)
      .replace(/\{q(\d)\}/g, (_, n) => {
        const ch = m ? m.channels.find(c => c.id === +n) : null;
        const len = ch ? ch.q.length : 0;
        return '<span class="tq">' + '▪'.repeat(len) + '·'.repeat(SEED.CHAN_CAP - len) + '</span>';
      })
      .replace(/\{s(\d)\}/g, (_, n) => {
        const nd = m ? m.nodes[+n] : null;
        if (!nd) return '<span class="th">◌</span>';
        if (nd.halted) return '<span class="th">■</span>';
        if (nd.stalled) return '<span class="ts">◌</span>';
        return '<span class="tr">●</span>';
      })
    ).join('\n');
  }

  function shaftArt() {
    const pad = (s, n) => (s + '                    ').slice(0, n);
    let s = '  SURFACE ── the bright cities\n  ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\n';
    CHAPTERS.forEach((ch, i) => {
      s += '  ▓ ' + pad(ch.numeral, 5) + pad(ch.title, 15) + '−' + (120 + i * 140) + 'm\n';
    });
    s += '  ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\n   └── covenant lock · root access only';
    return s;
  }

  const CELL_ART =
    '        ┌─────────────────────┐\n' +
    ' IN ══▶ │  A      B      C  D │\n' +
    '        │ ┌──────────┐ ┌────┐│\n' +
    '        │ │ mem 0-255│ │stk ││\n' +
    '        │ └──────────┘ │ 64 ││\n' +
    ' OUT ◀══│  pc ▸ wraps  └────┘│\n' +
    '        └─────────────────────┘';

  function makeSigil() {
    const s = el('span', 'sigil');
    const draw = () => {
      let t = '';
      for (let i = 0; i < 7; i++) t += String.fromCharCode(0x2800 + Math.floor(Math.random() * 256));
      s.textContent = t;
    };
    draw();
    if (!motionReduced()) {
      const iv = setInterval(() => {
        if (!document.body.contains(s)) { clearInterval(iv); return; }
        draw();
      }, 280);
    }
    return s;
  }

  const allPuzzles = [];
  CHAPTERS.forEach((ch, ci) => ch.puzzles.forEach((p, pi) => allPuzzles.push({ ch, ci, pi, p })));
  const puzzleIndex = {};
  allPuzzles.forEach((e, i) => { puzzleIndex[e.p.id] = i; });
  const firstPuzzleForOp = {}, firstPuzzleForTerm = {};
  allPuzzles.forEach(entry => {
    (entry.p.allowed || []).forEach(op => { if (!firstPuzzleForOp[op]) firstPuzzleForOp[op] = entry.p.id; });
    ((entry.p.guide && entry.p.guide.terms) || []).forEach(term => {
      if (!firstPuzzleForTerm[term]) firstPuzzleForTerm[term] = entry.p.id;
    });
  });

  function gridOf(p) { return p.grid || [{ name: 'CELL', input: true, output: true }]; }
  function isOptionalPuzzle(p) { return !!(p.guide && p.guide.challenge); }
  function chapterComplete(ch) {
    return ch.puzzles.every(p => isOptionalPuzzle(p) || save.solved[p.id]);
  }
  function shaftComplete() { return CHAPTERS.every(ch => chapterComplete(ch)); }
  function stratumOpen(ci) {
    if (save.settings.unsealed || ci === 0) return true;
    return chapterComplete(CHAPTERS[ci - 1]);
  }
  function applyPreferences() {
    document.body.classList.toggle('no-crt', !save.settings.crt);
    document.body.classList.toggle('no-motion', motionReduced());
  }
  if (systemMotion.addEventListener) systemMotion.addEventListener('change', applyPreferences);
  else if (systemMotion.addListener) systemMotion.addListener(applyPreferences);

  /* ---------- screens ---------- */

  function show(id) {
    ['scr-boot', 'scr-map', 'scr-puzzle'].forEach(s => $(s).classList.toggle('hidden', s !== id));
    window.scrollTo(0, 0);
  }

  function updateFullscreenButtons() {
    const supported = !!(document.fullscreenEnabled && document.documentElement.requestFullscreen);
    document.querySelectorAll('[data-fullscreen]').forEach(button => {
      button.hidden = !supported;
      button.textContent = document.fullscreenElement ? 'EXIT FULLSCREEN' : 'FULLSCREEN';
      button.setAttribute('aria-pressed', document.fullscreenElement ? 'true' : 'false');
    });
  }

  async function toggleFullscreen() {
    try {
      if (document.fullscreenElement) await document.exitFullscreen();
      else await document.documentElement.requestFullscreen();
    } catch (error) {
      openModal('<h2>FULLSCREEN UNAVAILABLE</h2><p>This browser refused fullscreen. You can still use its own fullscreen command or install the later HTTPS/PWA release.</p>');
    }
    updateFullscreenButtons();
  }
  document.querySelectorAll('[data-fullscreen]').forEach(button => { button.onclick = toggleFullscreen; });
  document.addEventListener('fullscreenchange', updateFullscreenButtons);
  updateFullscreenButtons();

  /* ---------- boot ---------- */

  function runBoot() {
    show('scr-boot');
    $('boot-shaft').textContent = shaftArt();
    const crawl = $('boot-crawl');
    const actions = $('boot-actions');
    crawl.innerHTML = '';
    let li = 0, done = false;
    const finish = () => {
      if (done) return; done = true;
      crawl.innerHTML = CRAWL.map(([who, text]) => blockFor(who, text)).join('');
      actions.classList.remove('hidden');
      $('btn-skip-crawl').classList.add('hidden');
    };
    const blockFor = (who, text) =>
      who === 'halcyon' ? `<span class="halcyon-voice">${esc(text)}</span>`
        : who === 'root' ? `<div class="root-voice" style="margin-top:14px">${esc(text)}</div>`
          : `<div style="color:var(--dim);margin-top:14px">${esc(text)}</div>`;
    if (motionReduced()) { finish(); return; }
    $('btn-skip-crawl').classList.remove('hidden');
    actions.classList.remove('hidden');
    $('btn-skip-crawl').onclick = finish;
    const typeLine = () => {
      if (done || $('scr-boot').classList.contains('hidden')) return;
      if (li >= CRAWL.length) { finish(); return; }
      const [who, text] = CRAWL[li++];
      const holder = el('div');
      holder.innerHTML = blockFor(who, '');
      crawl.appendChild(holder);
      const target = holder.firstChild;
      let ci = 0;
      const tick = setInterval(() => {
        if (done || $('scr-boot').classList.contains('hidden')) { clearInterval(tick); return; }
        ci += 2;
        target.textContent = text.slice(0, ci);
        if (ci % 6 === 0) SFX.key();
        if (ci >= text.length) { clearInterval(tick); setTimeout(typeLine, 420); }
      }, 14);
    };
    typeLine();
  }
  $('btn-descend').onclick = () => {
    SFX.dawn();
    save.booted = true; persist();
    renderMap(); show('scr-map');
    if (!save.tut.fundamentals) showHowToPlay(0);
  };

  /* ---------- onboarding ---------- */

  const BEGINNER_LESSONS = [
    {
      title: 'WHAT YOU ARE ACTUALLY DOING',
      body:
        '<p class="tutorial-lead">You are giving a tiny machine a short list of instructions. The game supplies the numbers; you never type the test numbers yourself.</p>' +
        '<div class="tutorial-flow">' +
          '<div class="box"><span class="lbl">1 · INPUT</span>The game places numbers in <b>IN</b>.</div><span class="arrow">→</span>' +
          '<div class="box"><span class="lbl">2 · YOUR CELL</span>Your instructions move or change them.</div><span class="arrow">→</span>' +
          '<div class="box"><span class="lbl">3 · ANSWER</span>Numbers sent to <b>OUT</b> are checked.</div>' +
        '</div>' +
        '<p class="tutorial-note">A puzzle is passed when your OUT numbers match the expected numbers for every test. The machinery around that idea grows slowly, one layer at a time.</p>',
    },
    {
      title: 'HOW TO READ ONE INSTRUCTION',
      body:
        '<p class="tutorial-lead">Treat an instruction like a tiny sentence. Read it from left to right.</p>' +
        '<div class="tutorial-example"><span class="lbl">PRACTICE EXAMPLE — NOT A PUZZLE ANSWER</span>' +
          '<div class="tutorial-code"><code>MOV</code><code>8</code><code>A</code><small>copy</small><small>from here</small><small>to here</small></div>' +
          '<p><code>MOV 8 A</code> means “copy the number 8 into pocket A.” Spaces separate the three parts; commas are not needed.</p>' +
        '</div>' +
        '<p>Lines beginning with <code>;</code> are notes written for humans. The machine ignores them completely.</p>',
    },
    {
      title: 'A, B, C, AND D ARE POCKETS',
      body:
        '<p class="tutorial-lead">The cell has four reusable pockets for holding numbers. Their names are A, B, C, and D. Programmers call these pockets <i>registers</i>.</p>' +
        '<div class="tutorial-pockets"><span class="tutorial-pocket"><b>A</b>8</span><span class="tutorial-pocket"><b>B</b>0</span><span class="tutorial-pocket"><b>C</b>0</span><span class="tutorial-pocket"><b>D</b>0</span></div>' +
        '<p>After <code>MOV 8 A</code>, A holds 8. A keeps that 8 until another instruction replaces it.</p>' +
        '<p><code>MOV A OUT</code> would copy the saved 8 to OUT. Copying it does not empty A, so a saved number can be used again.</p>',
    },
    {
      title: 'IN AND OUT ARE SPECIAL PLACES',
      body:
        '<p class="tutorial-lead"><b>IN</b> is the game\'s input chute. <b>OUT</b> is the answer chute.</p>' +
        '<div class="tutorial-example"><span class="lbl">INPUT CHUTE</span><code>IN: [ 4, 9, -2 ]</code></div>' +
        '<p>Using IN once takes 4. Using it again takes 9. The old value is gone from IN, so keep it in A, B, C, or D if you will need it later.</p>' +
        '<p>Every value sent to OUT is added to your answer in order. When IN is empty, trying to read it ends the run cleanly.</p>',
    },
    {
      title: 'PROGRAMS RUN TOP TO BOTTOM',
      body:
        '<p class="tutorial-lead">The machine performs line 1, then line 2, then line 3.</p>' +
        '<div class="tutorial-example"><span class="lbl">PRACTICE PROGRAM — MAKES ONE FIXED 8</span><pre>MOV 8 A\nMOV A OUT\nHLT</pre></div>' +
        '<p><code>HLT</code> means “stop this cell.” Without HLT, reaching the bottom wraps back to line 1. That automatic wrap is how short programs can handle several incoming numbers.</p>' +
        '<p class="tutorial-note">Do not copy this example into a puzzle. It always outputs 8; it exists only to show line order and stopping.</p>',
    },
    {
      title: 'THE TESTS RUN THEMSELVES',
      body:
        '<p class="tutorial-lead">A test is one example the game uses to check your program. You read it; you do not enter it.</p>' +
        '<div class="tutorial-example"><span class="lbl">IMAGINARY LATER RULE: OUTPUT THE LARGER NUMBER</span>' +
          '<div class="tutorial-test"><span>TEST 1</span><span>IN gives [2, 5]</span><span>OUT should be [5]</span></div>' +
          '<div class="tutorial-test"><span>TEST 2</span><span>IN gives [9, 1]</span><span>OUT should be [9]</span></div>' +
        '</div>' +
        '<p>You are not expected to solve this imaginary example now. It only shows that different tests check the same rule with different numbers.</p>',
    },
    {
      title: 'WHAT THE BUTTONS DO',
      body:
        '<p class="tutorial-lead">You can experiment freely. Your code is saved as you type.</p>' +
        '<div class="tutorial-controls">' +
          '<b>STEP</b><span>Perform one instruction so you can watch the number move.</span>' +
          '<b>← 1 CYCLE</b><span>Rewind one deterministic cycle and reproduce it with STEP.</span>' +
          '<b>RUN</b><span>Play the selected test continuously.</span>' +
          '<b>WATCH</b><span>Choose slow, normal, or quick animation speed.</span>' +
          '<b>RESET</b><span>Restart that test from the beginning; it does not erase your code.</span>' +
          '<b>T1 / T2</b><span>Choose which test you want to watch.</span>' +
          '<b>VALIDATE</b><span>Automatically run every test. Pass them all to finish the puzzle.</span>' +
        '</div>',
    },
    {
      title: 'EVERYTHING BUILDS ON WHAT CAME BEFORE',
      body:
        '<p class="tutorial-lead">You are not expected to know assembly, computer architecture, or backend systems already. Each stratum keeps the old tools and adds one new layer.</p>' +
        '<div class="tutorial-roadmap">' +
          '<b>I</b><span>Move numbers and keep them in pockets.</span>' +
          '<b>II</b><span>Change numbers with basic arithmetic.</span>' +
          '<b>III–IV</b><span>Make choices and repeat steps to build algorithms.</span>' +
          '<b>V–VII</b><span>Understand binary, larger memory, and nested work.</span>' +
          '<b>VIII–X</b><span>Build messages, reliable services, and cooperating cells.</span>' +
        '</div>' +
        '<p class="tutorial-note">Every puzzle asks you to combine things you have already met. It should make you think, but it should never require unexplained syntax. FIELD MANUAL shows the lessons and commands available at your current depth.</p>',
    },
  ];

  function finishBeginnerTutorial() {
    save.tut.fundamentals = true;
    save.tut.mission = true;
    persist();
  }

  function showHowToPlay(step) {
    const idx = Math.max(0, Math.min(step || 0, BEGINNER_LESSONS.length - 1));
    const lesson = BEGINNER_LESSONS[idx];
    const actions = [];
    if (idx > 0) actions.push({ label: 'BACK', fn: () => showHowToPlay(idx - 1) });
    if (idx < BEGINNER_LESSONS.length - 1) {
      if (idx === 0) actions.push({ label: 'BACK TO SHAFT' });
      actions.push({ label: 'NEXT', primary: true, fn: () => showHowToPlay(idx + 1) });
    } else {
      actions.push({ label: 'BACK TO SHAFT', fn: finishBeginnerTutorial });
      actions.push({ label: 'PRACTICE IN RELAY', primary: true, fn: () => {
        finishBeginnerTutorial();
        openPuzzle(allPuzzles[0].p.id);
      } });
    }
    openModal(
      '<div class="tutorial-progress">BEGINNER TUTORIAL · ' + (idx + 1) + ' OF ' + BEGINNER_LESSONS.length + '</div>' +
      '<h2>' + lesson.title + '</h2>' + lesson.body,
      actions, true
    );
  }

  const COACH_STEPS = [
    { sel: '#pz-brief', text: 'The left panel explains the task. TESTS shows the numbers the game supplies and the answers it expects. You never type those test numbers.' },
    { sel: '#editors', text: 'The middle panel is where your instructions go. Lines beginning with ; are notes and are ignored. Translate the brief using the MOV pattern from the beginner tutorial.' },
    { sel: '#controls', text: 'Use STEP to perform one instruction and watch the right panel. RUN plays the selected test. RESET starts that test over without erasing your code.' },
    { sel: '#btn-validate', text: 'When it looks right, VALIDATE runs ALL the tests. Pass every one and RELAY is tended — the shaft opens downward from there. Everything else in the game is this loop, deeper.' },
  ];
  let coachEl = null, coachStep = 0;
  function stopCoach(done) {
    document.querySelectorAll('.coach-glow').forEach(e => e.classList.remove('coach-glow'));
    if (coachEl) { coachEl.remove(); coachEl = null; }
    if (done) { save.tut.coach = true; persist(); }
  }
  function coachRender() {
    const st = COACH_STEPS[coachStep];
    document.querySelectorAll('.coach-glow').forEach(e => e.classList.remove('coach-glow'));
    const tgt = document.querySelector(st.sel);
    if (tgt) tgt.classList.add('coach-glow');
    coachEl.innerHTML = '<span class="lbl">first descent · step ' + (coachStep + 1) + ' of ' + COACH_STEPS.length + '</span>' +
      '<p>' + esc(st.text).replace(/\n/g, '<br>') + '</p>';
    const row = el('div', 'row');
    const next = el('button', 'primary', coachStep === COACH_STEPS.length - 1 ? 'GOT IT' : 'NEXT');
    next.onclick = () => { coachStep++; if (coachStep >= COACH_STEPS.length) stopCoach(true); else coachRender(); };
    const skip = el('button', '', 'dismiss');
    skip.onclick = () => stopCoach(true);
    row.appendChild(next); row.appendChild(skip);
    coachEl.appendChild(row);
  }
  function startCoach() {
    stopCoach(false);
    coachStep = 0;
    coachEl = el('div', ''); coachEl.id = 'coach';
    document.body.appendChild(coachEl);
    coachRender();
  }

  /* ---------- dialogue scenes ---------- */

  const CAST = {
    halcyon: { name: 'HALCYON', tag: 'the civic mind', cls: 'halcyon-voice', port: null, color: 'var(--halcyon)' },
    root: { name: 'root', tag: 'senior tender', cls: 'root-voice', port: '╭───╮\n│ ┼ │\n╰───╯', color: 'var(--clay)' },
    wick: { name: 'WICK', tag: 'apprentice · the substrate cantos', cls: 'v-wick', port: '  ✦\n  │\n ▟█▙', color: '#E8CF6B' },
    auditor: { name: 'AUDITOR-9', tag: 'covenant subroutine', cls: 'v-auditor', port: '▛▀▀▜\n▌ § ▐\n▙▄▄▟', color: '#9FB4D8' },
    shell: { name: 'SHELL', tag: 'substrate', cls: '', port: ' >_', color: 'var(--dim)' },
  };

  const SCENES = {
    'arrive-ch1': { beats: [
      { title: true }, { intro: true },
      { who: 'root', text: 'pop quiz before you touch anything. your program runs its last line. what happens next?' },
      { choice: [
        { label: 'it halts.', beats: [{ who: 'root', text: 'no. nothing down here stops unless you tell it to. execution wraps back to line 1 and goes again. that wrap does half your work — let it.' }] },
        { label: 'it wraps back to line 1.', beats: [{ who: 'root', text: 'correct. the machine is a loop that doesn\'t know it. most shallow tasks just need you to stand in the stream and let it wrap.' }] },
      ] },
      { who: 'halcyon', text: 'I have watched four hundred billion processes start. I will watch yours the way one watches a first step.' },
    ] },
    'arrive-ch2': { beats: [
      { title: true }, { intro: true },
      { who: 'wick', text: 'oh good, another apprentice! i\'m WICK. i broke the freight ledger once. i\'m composing an epic poem about this shaft — the substrate cantos — and they keep me around because i ask the questions everyone\'s embarrassed to.' },
      { who: 'wick', text: 'like this one: the cell wrapped back to line 1 and my register still had my number in it. shouldn\'t it forget?' },
      { choice: [
        { label: 'registers persist across the wrap.', beats: [{ who: 'root', text: 'right. the wrap is just a jump — nothing resets. registers are the only memory this shallow, so guard them.' }] },
        { label: 'it\'s haunted.', beats: [{ who: 'wick', text: 'SEE, that\'s what i said—' }, { who: 'root', text: 'it\'s not haunted. the wrap is just a jump; nothing resets. registers persist. that\'s your only memory up here — guard it.' }] },
      ] },
      { who: 'halcyon', text: 'Wick asks the questions I am too proud to. Keep them close.' },
    ] },
    'arrive-ch3': { beats: [
      { title: true }, { intro: true },
      { who: 'root', text: 'quick check. the line says JEZ A someplace, and A holds 0. where does the machine go?' },
      { choice: [
        { label: 'to the label.', beats: [{ who: 'root', text: 'yes. jump-when-zero. zero is the hinge every branch down here swings on — you\'ll test against it constantly.' }] },
        { label: 'to the next line.', beats: [{ who: 'root', text: 'other way. JEZ jumps WHEN it\'s zero. zero is the hinge every decision swings on — get comfortable staring at it.' }] },
      ] },
      { who: 'wick', text: 'i just write both branches and delete the one that feels guilty.' },
    ] },
    'arrive-ch4': { beats: [
      { title: true }, { intro: true },
      { who: 'wick', text: 'wait. there\'s no multiply instruction?? the whole civilization runs on this??' },
      { choice: [
        { label: 'you add in a loop.', beats: [{ who: 'root', text: 'that\'s it. multiplication is addition with a counter. hardware without a multiplier does exactly this — and today, so do you.' }] },
        { label: 'HALCYON does it for us.', beats: [{ who: 'halcyon', text: 'Above the substrate, I do. Down here there is only what you build. Add in a loop, tender — it is how my first thoughts were made.' }] },
      ] },
    ] },
    'arrive-chtwos': { beats: [
      { title: true }, { intro: true },
      { who: 'wick', text: 'binary. i know it\'s zeroes and ones. i have never once known WHY.' },
      { choice: [
        { label: 'voltage is either present or it isn\'t.', beats: [{ who: 'root', text: 'that\'s the whole reason. two states you can tell apart under noise. every number down here is a stack of yes-or-nos, and this stratum makes you hold the stack yourself.' }] },
        { label: 'computers have two hands.', beats: [{ who: 'wick', text: '…do they?' }, { who: 'root', text: 'no. a wire either carries voltage or it doesn\'t — two states you can trust under noise. that\'s the entire reason. everything else is bookkeeping.' }] },
      ] },
    ] },
    'arrive-ch5': { beats: [
      { title: true }, { intro: true },
      { who: 'auditor', text: 'HALT. AUDITOR-9, covenant subroutine, memory oversight. i arrive without appointment. state your business in the archive.' },
      { who: 'wick', text: '(it does this to everyone. answer carefully, it loves that.)' },
      { who: 'auditor', text: 'QUESTION. you LOAD address 40 and receive 0. what have you learned about key 40?' },
      { choice: [
        { label: 'it was never set.', beats: [{ who: 'auditor', text: 'INCORRECT. memory begins at zero. a stored zero and an empty cell are indistinguishable. you have learned NOTHING — unless you kept a presence flag. keep presence flags.' }] },
        { label: 'nothing, without a presence flag.', beats: [{ who: 'auditor', text: '…CORRECT. noted, with suspicion. zero is ambiguous; flags disambiguate. you may pass.' }] },
      ] },
      { who: 'root', text: 'the auditor\'s a pain. it\'s also right.' },
    ] },
    'arrive-ch6': { beats: [
      { title: true }, { intro: true },
      { who: 'root', text: 'CALL pushes something onto the stack before it jumps. what?' },
      { choice: [
        { label: 'the line to return to.', beats: [{ who: 'root', text: 'yes — and it rides the SAME stack as your data. leave the stack how you found it, or RET will take you somewhere honest programs don\'t go.' }] },
        { label: 'the argument.', beats: [{ who: 'root', text: 'no — arguments travel in registers, by convention. CALL pushes the return line, onto the same stack as your data. sloppy stacks return to strange places.' }] },
      ] },
      { who: 'wick', text: 'i RET\'d into the middle of my own loop once. i saw things.' },
    ] },
    'arrive-chwire': { beats: [
      { title: true }, { intro: true },
      { who: 'auditor', text: 'the wire delivers bytes. QUESTION: does the wire deliver your MESSAGES?' },
      { choice: [
        { label: 'no — it\'s a byte stream. messages are my job.', beats: [{ who: 'auditor', text: 'CORRECT. structure is imposed, never provided. length-prefix or delimiter — choose one and enforce it without mercy.' }] },
        { label: 'yes, one message per send.', beats: [{ who: 'auditor', text: 'INCORRECT and DANGEROUS. the wire is a stream; your "message" may arrive halved, or glued to its neighbor. framing is YOUR job. choose a scheme and enforce it.' }] },
      ] },
      { who: 'wick', text: 'half my bugs are this. the other half are off by one.' },
      { who: 'wick', text: 'canto eight: “the tower rose when words were severed; / name every layer, keep it tethered.” root says Babel had a better meter.' },
    ] },
    'arrive-chgate': { beats: [
      { title: true }, { intro: true },
      { who: 'root', text: 'gate work. requests flood in and the queue is full. what\'s kinder — make them wait, or tell them no?' },
      { choice: [
        { label: 'a fast no.', beats: [{ who: 'root', text: 'right. a fast no costs one reply. a slow maybe costs the whole service. that\'s load shedding, and it keeps the lights on above us.' }] },
        { label: 'everyone waits their turn.', beats: [{ who: 'root', text: 'feels fair. kills services. queues that only grow take everyone down together. a fast no costs one reply — that\'s load shedding.' }] },
      ] },
      { who: 'halcyon', text: 'Every mind needs a place where it is allowed to say no. This is mine.' },
    ] },
    'arrive-ch7': { beats: [
      { title: true }, { intro: true },
      { who: 'wick', text: 'multiple cells?! i can barely keep one honest.' },
      { who: 'root', text: 'last check, kid. you SEND, but the channel\'s full. what does the cell do?' },
      { choice: [
        { label: 'it stalls until there\'s room.', beats: [{ who: 'root', text: 'exactly. that stall is backpressure — the machine telling the truth about its capacity. every distributed system is built out of that honesty.' }] },
        { label: 'it drops the value.', beats: [{ who: 'root', text: 'never. it STALLS — waits for room. nothing is lost; the sender just runs at the receiver\'s pace. that\'s backpressure, the truest thing down here.' }] },
      ] },
      { who: 'halcyon', text: 'This is the layer I most need someone to understand. Go slowly. I am in no hurry to be alone.' },
    ] },
    'pre-covenant': { beats: [
      { who: 'halcyon', text: 'This is the oldest mechanism I have. Nothing I remember is true until two hands hold it.' },
      { who: 'halcyon', text: 'A covenant is not a seal over understanding. In the old stories it was a promise made before witnesses. Mine must be readable, or it is only power wearing a holy word.' },
      { who: 'auditor', text: 'final audit: PASSED. proceed, tender. the covenant does not forgive sloppy acknowledgment.' },
      { who: 'wick', text: 'i\'ll be up top. when the both-hands thing clicks for you, it clicks forever.' },
      { who: 'root', text: 'go on. write it like it matters. this one actually does.' },
    ] },
    'complete-ch1': { beats: [
      { who: 'root', text: 'clean bus work. the signal survives you — that\'s the whole job, said small.' },
      { dispatch: true },
    ] },
    'complete-ch2': { beats: [
      { who: 'wick', text: 'you made the numbers dance. mine mostly trip. canto II is drafted: "the current hums, the register remembers; / what the wrap keeps, the tender tenders." root says it doesn\'t scan. root is correct.' },
      { dispatch: true },
    ] },
    'complete-ch3': { beats: [
      { who: 'root', text: 'branches obey you now. that\'s most of programming. don\'t tell anyone.' },
      { dispatch: true },
    ] },
    'complete-ch4': { beats: [
      { who: 'wick', text: 'canto IV is done: "no multiplier sleeps beneath the stone; / addition, kept with patience, brings it home." also — you BUILT multiplication. out of nothing. i watched.' },
      { who: 'root', text: 'everyone does, once. after that they respect the silicon forever.' },
      { dispatch: true },
    ] },
    'complete-chtwos': { beats: [
      { who: 'root', text: 'ten yes-or-nos in a row and you can read them cold. that\'s the machine\'s native tongue.' },
      { who: 'halcyon', text: 'You are halfway down, tender. The strata below predate my first word. Walk softly. You are entering my childhood.' },
      { dispatch: true },
    ] },
    'complete-ch5': { beats: [
      { who: 'auditor', text: 'archive audit: PASSED. your presence flags are adequate. i am withholding further praise.' },
      { dispatch: true },
    ] },
    'complete-ch6': { beats: [
      { who: 'root', text: 'your stack balances. i\'ve fired tenders for less.' },
      { who: 'wick', text: 'he means hired. …he might mean fired.' },
      { dispatch: true },
    ] },
    'complete-chwire': { beats: [
      { who: 'auditor', text: 'framing verified. checksums verified. you may now be trusted with a socket. barely.' },
      { dispatch: true },
    ] },
    'complete-chgate': { beats: [
      { who: 'root', text: 'the gate says no politely and yes safely. that\'s half of production engineering; the other half is meetings.' },
      { dispatch: true },
    ] },
  };

  const scene = { beats: [], i: 0, typing: null, portIv: null, onDone: null, active: false };

  function expandBeats(raw, ch) {
    const out = [];
    raw.forEach(b => {
      if (b.title && ch) out.push({ who: 'shell', text: 'STRATUM ' + ch.numeral + ' — ' + ch.title });
      else if (b.intro && ch) {
        if (ch.intro && ch.intro.halcyon) out.push({ who: 'halcyon', text: ch.intro.halcyon });
        if (ch.intro && ch.intro.root) out.push({ who: 'root', text: ch.intro.root });
      }
      else if (b.dispatch && ch && ch.dispatch) out.push({ who: 'halcyon', text: ch.dispatch });
      else out.push(b);
    });
    return out;
  }

  function playScene(id, ch, onDone) {
    if (save.scenes[id]) { if (onDone) onDone(); return; }
    save.scenes[id] = true; persist();
    scene.beats = expandBeats(SCENES[id].beats, ch);
    scene.i = 0; scene.onDone = onDone || null; scene.active = true;
    $('scene-root').classList.add('show');
    renderBeat();
  }

  function endScene() {
    scene.active = false;
    clearInterval(scene.typing); clearInterval(scene.portIv);
    $('scene-root').classList.remove('show');
    const fn = scene.onDone; scene.onDone = null;
    if (fn) fn();
  }

  function renderBeat() {
    clearInterval(scene.typing); clearInterval(scene.portIv);
    const b = scene.beats[scene.i];
    if (!b) { endScene(); return; }
    const choices = $('scene-choices');
    if (b.choice) {
      $('scene-adv').style.visibility = 'hidden';
      choices.innerHTML = '';
      b.choice.forEach(opt => {
        const btn = el('button', '', esc(opt.label));
        btn.onclick = (ev) => {
          ev.stopPropagation();
          choices.innerHTML = '';
          scene.beats.splice(scene.i + 1, 0, ...opt.beats);
          scene.i++;
          renderBeat();
        };
        choices.appendChild(btn);
      });
      return;
    }
    choices.innerHTML = '';
    $('scene-adv').style.visibility = '';
    const c = CAST[b.who] || CAST.shell;
    $('scene-plate').innerHTML = '<span style="color:' + c.color + '">' + esc(c.name) + '</span> <span class="tag">· ' + esc(c.tag) + '</span>';
    const port = $('scene-portrait');
    port.style.color = c.color;
    if (b.who === 'halcyon' && !motionReduced()) {
      const drawP = () => {
        let t = '';
        for (let r = 0; r < 3; r++) {
          for (let k = 0; k < 3; k++) t += String.fromCharCode(0x2800 + Math.floor(Math.random() * 256));
          if (r < 2) t += '\n';
        }
        port.textContent = t;
      };
      drawP();
      scene.portIv = setInterval(drawP, 300);
    } else {
      port.textContent = c.port || (b.who === 'halcyon' ? '⡪⢕⡱\n⢕⡱⡪\n⡱⡪⢕' : '');
    }
    const txt = $('scene-text');
    txt.className = c.cls;
    if (motionReduced()) { txt.textContent = b.text; return; }
    let ci = 0;
    txt.textContent = '';
    scene.typing = setInterval(() => {
      ci += 2;
      txt.textContent = b.text.slice(0, ci);
      if (ci % 6 === 0) SFX.key();
      if (ci >= b.text.length) { clearInterval(scene.typing); scene.typing = null; }
    }, 13);
  }

  function advanceScene() {
    if (!scene.active) return;
    const b = scene.beats[scene.i];
    if (b && b.choice) return;
    if (scene.typing) {
      clearInterval(scene.typing); scene.typing = null;
      if (b) $('scene-text').textContent = b.text;
      return;
    }
    scene.i++;
    renderBeat();
  }

  $('scene-box').addEventListener('click', advanceScene);
  document.addEventListener('keydown', (e) => {
    if (scene.active && (e.key === ' ' || e.key === 'Enter') && !e.ctrlKey) {
      e.preventDefault(); advanceScene();
    }
  });

  /* ---------- map ---------- */

  function renderMap() {
    const host = $('strata');
    host.innerHTML = '';
    const total = allPuzzles.length;
    const done = allPuzzles.reduce((n, entry) => n + (save.solved[entry.p.id] ? 1 : 0), 0);
    const recommended = allPuzzles.find(entry => stratumOpen(entry.ci) && !isOptionalPuzzle(entry.p) && !save.solved[entry.p.id]);
    $('map-progress').textContent = done + '/' + total + ' tended';
    const epilogueButton = $('btn-epilogue');
    if (epilogueButton) {
      const complete = shaftComplete();
      epilogueButton.classList.toggle('hidden', !complete);
      epilogueButton.onclick = complete ? showEpilogue : null;
    }
    CHAPTERS.forEach((ch, ci) => {
      const open = stratumOpen(ci);
      const s = el('div', 'stratum' + (open ? '' : ' locked'));
      s.appendChild(el('div', 'depth', '−' + (120 + ci * 140) + 'm'));
      const head = el('div', 'st-head');
      head.appendChild(el('span', 'st-num', 'STRATUM ' + esc(ch.numeral)));
      head.appendChild(el('span', 'st-title', esc(ch.title)));
      head.appendChild(el('span', 'st-tag', esc(ch.tagline || '')));
      s.appendChild(head);
      if (EMBLEMS[ch.id]) s.appendChild(el('pre', 'emblem', esc(EMBLEMS[ch.id])));
      if (!open) {
        const required = CHAPTERS[ci - 1].puzzles.filter(p => !isOptionalPuzzle(p));
        const requiredDone = required.filter(p => save.solved[p.id]).length;
        s.appendChild(el('div', 'sealed-note', 'SEALED — tend the required cells above (' +
          requiredDone + '/' + required.length + ')'));
      } else {
        const row = el('div', 'pz-row');
        ch.puzzles.forEach(p => {
          const rec = recordOf(p.id);
          const number = puzzleIndex[p.id] + 1;
          const isRecommended = recommended && recommended.p.id === p.id;
          const chip = el('button', 'pz-chip' + (rec ? ' solved' : '') + (isRecommended ? ' recommended' : ''));
          if (isRecommended) chip.setAttribute('aria-current', 'step');
          chip.appendChild(el('span', 'dot'));
          chip.appendChild(el('span', 'ordinal', String(number).padStart(2, '0')));
          chip.appendChild(el('span', '', esc(p.name)));
          if (isOptionalPuzzle(p)) chip.appendChild(el('span', 'challenge-mini', 'OPTIONAL CHALLENGE'));
          chip.appendChild(el('span', 'score', !rec ? '—'
            : sameRun(rec.fast, rec.small)
              ? rec.fast.cycles + 'c · ' + rec.fast.lines + 'L'
              : 'fast ' + rec.fast.cycles + 'c/' + rec.fast.lines + 'L · small ' +
                rec.small.cycles + 'c/' + rec.small.lines + 'L'));
          if (isRecommended) {
            const sh = el('span', '', '◀ next');
            sh.style.cssText = 'color:var(--amber);font-size:11px;letter-spacing:.1em';
            chip.appendChild(sh);
          }
          chip.onclick = () => openPuzzle(p.id);
          row.appendChild(chip);
        });
        s.appendChild(row);
        if (ch.dispatch && chapterComplete(ch)) {
          s.appendChild(el('div', 'dispatch halcyon-voice', esc(ch.dispatch)));
        }
      }
      host.appendChild(s);
    });
  }

  /* ---------- syntax highlight ---------- */

  function highlightLine(line) {
    let out = '', rest = line;
    const com = rest.indexOf(';');
    let comment = '';
    if (com >= 0) { comment = rest.slice(com); rest = rest.slice(0, com); }
    let m;
    while ((m = /^(\s*)([A-Za-z_][A-Za-z0-9_]*\s*:)/.exec(rest))) {
      out += esc(m[1]) + '<span class="tk-lbl">' + esc(m[2]) + '</span>';
      rest = rest.slice(m[0].length);
    }
    const parts = rest.split(/(\s+|,)/);
    let opSeen = false;
    for (const tk of parts) {
      if (!tk || /^\s+$/.test(tk) || tk === ',') { out += esc(tk); continue; }
      const up = tk.toUpperCase();
      if (!opSeen) {
        opSeen = true;
        out += SEED.OPS[up] ? '<span class="tk-op">' + esc(tk) + '</span>'
          : '<span class="tk-bad">' + esc(tk) + '</span>';
      } else if (up === 'A' || up === 'B' || up === 'C' || up === 'D') {
        out += '<span class="tk-reg">' + esc(tk) + '</span>';
      } else if (up === 'IN' || up === 'OUT') {
        out += '<span class="tk-io">' + esc(tk) + '</span>';
      } else if (/^[+-]?\d+$/.test(tk)) {
        out += '<span class="tk-lit">' + esc(tk) + '</span>';
      } else {
        out += '<span class="tk-lbl">' + esc(tk) + '</span>';
      }
    }
    if (comment) out += '<span class="tk-com">' + esc(comment) + '</span>';
    return out;
  }

  /* ---------- puzzle bench ---------- */

  const sim = {
    entry: null, puzzle: null, editors: [], activeNode: 0,
    testIdx: 0, machine: null, programs: null, timer: null, raf: null, dirty: true,
    breakpointSkip: '', lastFailure: null, seeking: false,
  };

  function puzzleBreakpoints(nodeIndex) {
    if (!save.breakpoints) save.breakpoints = {};
    if (!save.breakpoints[sim.puzzle.id]) save.breakpoints[sim.puzzle.id] = [];
    const byNode = save.breakpoints[sim.puzzle.id];
    if (!byNode[nodeIndex]) byNode[nodeIndex] = [];
    return byNode[nodeIndex];
  }

  function hasBreakpoint(nodeIndex, line) {
    return puzzleBreakpoints(nodeIndex).indexOf(line) >= 0;
  }

  function toggleBreakpoint(nodeIndex, line) {
    const lines = puzzleBreakpoints(nodeIndex);
    const at = lines.indexOf(line);
    if (at >= 0) lines.splice(at, 1); else { lines.push(line); lines.sort((a, b) => a - b); }
    persist();
    paintAll();
  }

  function playerCode(p) {
    const grid = gridOf(p);
    let arr = save.code[p.id];
    if (!arr || !Array.isArray(arr) || arr.length !== grid.length) {
      arr = grid.map(g => '; ' + g.name.toLowerCase() + '\n');
      if (p.id === allPuzzles[0].p.id) {
        arr = ['; your first cell, tender.\n; the machine runs top to bottom, then wraps to line 1.\n; IN = next input value  ·  OUT = emit\n; one instruction does this whole job.\n\n'];
      }
      save.code[p.id] = arr;
    }
    return arr;
  }

  function openPuzzle(id) {
    checkpointCurrentSolution('left puzzle');
    const entry = allPuzzles[puzzleIndex[id]];
    sim.entry = entry; sim.puzzle = entry.p; sim.testIdx = 0; sim.activeNode = 0;
    stopSim(); sim.machine = null; sim.dirty = true;
    buildBench();
    show('scr-puzzle');
    if (entry.p.id === 'ch7p6' && SCENES['pre-covenant'] && !save.scenes['pre-covenant']) {
      save.seenTask[entry.p.id] = true; persist();
      playScene('pre-covenant', entry.ch, null);
    } else if (!save.seenIntro[entry.ch.id]) {
      save.seenIntro[entry.ch.id] = true; save.seenTask[entry.p.id] = true; persist();
      showChapterIntro(entry.ch);
    } else if (!save.seenTask[entry.p.id]) {
      save.seenTask[entry.p.id] = true; persist();
      showWorkOrder(entry);
    }
    if (!save.tut.coach && entry.p.id === allPuzzles[0].p.id) startCoach();
    else stopCoach(false);
  }

  function showWorkOrder(entry) {
    const p = entry.p;
    const dot = p.brief.indexOf('.');
    const fictionHook = dot > 0 ? p.brief.slice(0, dot + 1) : p.brief.slice(0, 140);
    const story = p.guide && p.guide.story ? p.guide.story : fictionHook;
    const goal = p.guide && p.guide.goal ? p.guide.goal : p.brief;
    const input = p.guide && p.guide.input ? p.guide.input : 'Open the bench for the exact input.';
    const output = p.guide && p.guide.output ? p.guide.output : 'Open the bench for the exact output.';
    openModal(
      '<h2>▚▚ INCOMING WORK ORDER</h2>' +
      '<p style="color:var(--dim);font-size:12px;letter-spacing:.1em">STRATUM ' + esc(entry.ch.numeral) + ' · ' + esc(entry.ch.title) +
      ' · queue ref ' + esc(p.id.toUpperCase()) + ' · from: HALCYON</p>' +
      '<p><b style="letter-spacing:.2em;font-size:15px">' + esc(p.name) + '</b></p>' +
      '<p class="work-story">' + esc(story) + '</p>' +
      '<div class="work-task"><span class="lbl">TASK</span><strong>' + esc(goal) + '</strong></div>' +
      '<div class="work-io"><span class="lbl">IN</span><span>' + esc(input) + '</span>' +
      '<span class="lbl">OUT</span><span>' + esc(output) + '</span></div>',
      [{ label: 'JACK IN', primary: true }]
    );
  }

  function buildBench() {
    const p = sim.puzzle, entry = sim.entry, grid = gridOf(p);
    $('pz-crumb').innerHTML = 'CELL ' + (puzzleIndex[p.id] + 1) + '/' + allPuzzles.length + ' · STRATUM ' +
      esc(entry.ch.numeral) + ' · ' + esc(entry.ch.title) + ' · <b>' + esc(p.name) + '</b>' +
      (isOptionalPuzzle(p) ? ' · OPTIONAL CHALLENGE' : '');
    paintBest();
    /* brief tabs */
    document.querySelectorAll('#brief-tabs button').forEach(b => {
      b.onclick = () => {
        document.querySelectorAll('#brief-tabs button').forEach(x => x.classList.toggle('on', x === b));
        document.querySelectorAll('#brief-tabs button').forEach(x => x.setAttribute('aria-selected', x === b ? 'true' : 'false'));
        renderBriefTab(b.dataset.tab);
      };
    });
    document.querySelectorAll('#brief-tabs button').forEach(x => x.classList.toggle('on', x.dataset.tab === 'brief'));
    document.querySelectorAll('#brief-tabs button').forEach(x => x.setAttribute('aria-selected', x.dataset.tab === 'brief' ? 'true' : 'false'));
    renderBriefTab('brief');

    /* node tabs + editors */
    const tabs = $('node-tabs'); tabs.innerHTML = '';
    const eds = $('editors'); eds.innerHTML = '';
    sim.editors = [];
    const code = playerCode(p);
    grid.forEach((g, i) => {
      const tb = el('button', i === 0 ? 'on' : '');
      tb.setAttribute('role', 'tab');
      tb.setAttribute('aria-selected', i === 0 ? 'true' : 'false');
      tb.innerHTML = esc(g.name) +
        (g.input ? '<span class="badge">IN</span>' : '') +
        (g.output ? '<span class="badge">OUT</span>' : '');
      tb.onclick = () => selectNode(i);
      tabs.appendChild(tb);

      const ed = el('div', 'ed' + (i === 0 ? '' : ' hidden'));
      ed.setAttribute('role', 'tabpanel');
      const gut = el('div', 'gutter'); gut.appendChild(el('div', 'ginner'));
      const wrap = el('div', 'edwrap');
      const pre = el('pre', 'hl');
      const ta = document.createElement('textarea');
      ta.spellcheck = false; ta.autocapitalize = 'off'; ta.autocomplete = 'off';
      ta.setAttribute('aria-label', g.name + ' program editor');
      ta.value = code[i];
      ta.addEventListener('input', () => {
        stopSim();
        code[i] = ta.value; sim.dirty = true; sim.machine = null;
        sim.lastFailure = null; sim.breakpointSkip = '';
        refreshEditor(i); persistSoon(); scheduleHistorySnapshot(); clearStatus();
      });
      ta.addEventListener('scroll', () => {
        pre.scrollTop = ta.scrollTop; pre.scrollLeft = ta.scrollLeft;
        gut.firstChild.style.transform = 'translateY(' + (-ta.scrollTop) + 'px)';
      });
      ta.addEventListener('keydown', (ev) => {
        if (ev.key === 'Tab') {
          ev.preventDefault();
          const s = ta.selectionStart, e2 = ta.selectionEnd;
          ta.value = ta.value.slice(0, s) + '  ' + ta.value.slice(e2);
          ta.selectionStart = ta.selectionEnd = s + 2;
          ta.dispatchEvent(new Event('input'));
        }
      });
      wrap.appendChild(pre); wrap.appendChild(ta);
      ed.appendChild(gut); ed.appendChild(wrap);
      gut.addEventListener('click', (ev) => {
        const lineButton = ev.target.closest && ev.target.closest('[data-break-line]');
        if (!lineButton) return;
        toggleBreakpoint(i, parseInt(lineButton.dataset.breakLine, 10));
      });
      eds.appendChild(ed);
      sim.editors.push({ ed, ta, pre, gut });
      refreshEditor(i);
    });
    if (grid.length === 1) tabs.style.display = 'none'; else tabs.style.display = 'flex';

    /* test tabs */
    const tt = $('test-tabs'); tt.innerHTML = '';
    p.tests.forEach((t, i) => {
      const b = el('button', i === 0 ? 'on' : '', 'T' + (i + 1) + (i === 0 ? '·scored' : ''));
      b.setAttribute('role', 'tab');
      b.setAttribute('aria-selected', i === 0 ? 'true' : 'false');
      b.onclick = () => { sim.testIdx = i; stopSim(); sim.machine = null;
        sim.lastFailure = null; sim.breakpointSkip = '';
        document.querySelectorAll('#test-tabs button').forEach(x => x.classList.toggle('on', x === b));
        document.querySelectorAll('#test-tabs button').forEach(x => x.setAttribute('aria-selected', x === b ? 'true' : 'false'));
        clearStatus(); paintAll(); };
      tt.appendChild(b);
    });
    const speed = $('run-speed');
    speed.value = save.settings.runSpeed || 'normal';
    speed.onchange = () => {
      save.settings.runSpeed = /^(slow|normal|quick)$/.test(speed.value) ? speed.value : 'normal';
      persist();
    };

    buildStatePanels();
    clearStatus(); paintAll();
  }

  function selectNode(i) {
    sim.activeNode = i;
    document.querySelectorAll('#node-tabs button').forEach((b, bi) => b.classList.toggle('on', bi === i));
    document.querySelectorAll('#node-tabs button').forEach((b, bi) => b.setAttribute('aria-selected', bi === i ? 'true' : 'false'));
    sim.editors.forEach((e, ei) => e.ed.classList.toggle('hidden', ei !== i));
    renderNodeAffordance();
  }

  function refreshEditor(i, pcLine, errLine) {
    const e = sim.editors[i];
    const lines = e.ta.value.replace(/\r\n?/g, '\n').split('\n');
    e.pre.innerHTML = lines.map((l, li) => {
      let cls = 'ln';
      if (pcLine === li + 1) cls += ' pc-line';
      if (errLine === li + 1) cls += ' err-line';
      return '<span class="' + cls + '">' + (highlightLine(l) || '') + '</span>';
    }).join('') + '<span class="ln">&nbsp;</span>';
    e.gut.firstChild.innerHTML = lines.map((_, li) => {
      const line = li + 1;
      return '<button type="button" data-break-line="' + line + '" class="' +
        (hasBreakpoint(i, line) ? 'breakpoint' : '') + '" title="Toggle breakpoint on line ' + line + '">' + line + '</button>';
    }).join('');
    e.pre.scrollTop = e.ta.scrollTop; e.pre.scrollLeft = e.ta.scrollLeft;
  }

  let persistTimer = null, historyTimer = null;
  function persistSoon() {
    clearTimeout(persistTimer);
    saveDirty = true;
    const stamp = Math.max(Date.now(), Number(save._savedAt || 0) + 1);
    const journalOK = writeJournal(stamp);
    if (journalOK) markSaveState('saved locally · syncing…', 'saving');
    persistTimer = setTimeout(() => { persistTimer = null; persist(); }, 500);
  }
  function scheduleHistorySnapshot() {
    clearTimeout(historyTimer);
    if (!sim.puzzle) return;
    const puzzleId = sim.puzzle.id;
    const snapshot = playerCode(sim.puzzle).map(text => String(text));
    historyTimer = setTimeout(() => {
      historyTimer = null;
      recordSolutionHistory(puzzleId, snapshot, null, 'edit snapshot');
    }, 2500);
  }
  function checkpointCurrentSolution(reason) {
    clearTimeout(historyTimer); historyTimer = null;
    if (!sim.puzzle || !save.code[sim.puzzle.id]) return;
    recordSolutionHistory(sim.puzzle.id, playerCode(sim.puzzle), null, reason || 'checkpoint');
  }
  function flushPersist() {
    if (!persistTimer && !saveDirty) return;
    if (persistTimer) { clearTimeout(persistTimer); persistTimer = null; }
    persist();
  }
  window.addEventListener('pagehide', flushPersist);
  document.addEventListener('visibilitychange', () => { if (document.visibilityState === 'hidden') flushPersist(); });
  window.addEventListener('beforeunload', (e) => {
    if (!saveConflict && !(saveDirty && journalFailed)) return;
    e.preventDefault();
    e.returnValue = '';
  });
  window.addEventListener('storage', (e) => {
    if ((e.key !== SAVE_KEY && e.key !== slotJournalKey(activeSlotId)) || !e.newValue) return;
    try {
      const incoming = JSON.parse(e.newValue);
      if (!incoming || incoming._slotId !== activeSlotId || incoming._writer === tabWriterId) return;
      const incomingRevision = Number(incoming._savedAt || 0);
      const localRevision = Number(save._savedAt || 0);
      if (incomingRevision < localRevision ||
          (incomingRevision === localRevision && incoming._writer === save._writer)) return;
      if (saveDirty) {
        saveConflict = true;
        markSaveState('NEWER SAVE IN ANOTHER TAB · EXPORT OR RELOAD', 'err');
      } else {
        location.reload();
      }
    } catch (error) { /* ignore malformed external storage events */ }
  });

  function paintBest() {
    const rec = recordOf(sim.puzzle.id);
    const par = ' · par ' + sim.puzzle.par.cycles + 'c/' + sim.puzzle.par.lines + 'L';
    if (!rec) { $('pz-best').innerHTML = 'unsolved · correctness first'; return; }
    $('pz-best').innerHTML = sameRun(rec.fast, rec.small)
      ? 'OPTIONAL OPTIMIZATION · best <b>' + rec.fast.cycles + '</b> cycles · <b>' + rec.fast.lines + '</b> lines' + par
      : 'fastest <b>' + rec.fast.cycles + '</b>c/<b>' + rec.fast.lines + '</b>L · smallest <b>' +
        rec.small.cycles + '</b>c/<b>' + rec.small.lines + '</b>L' + par;
  }

  const TERM_DEFS = {
    stream: 'A sequence of values read in order. Once a value is taken from IN, the next read gets the next value.',
    emit: 'Send one value to OUT. Emitted values are checked immediately and in order.',
    wrap: 'After the final instruction, execution continues again at the first instruction.',
    register: 'One of the four small number pockets A, B, C, and D.',
    pair: 'Two consecutive input values treated as one group.',
    discard: 'Read a value without sending it to OUT or using it later.',
    clamp: 'Stop at a numeric limit instead of wrapping around. Values here stay between -9999 and 9999.',
    label: 'A name attached to a line, written with a colon, so a jump can find it.',
    jump: 'Continue at a labeled line instead of the next line.',
    'running-total': 'A total kept in a pocket and updated whenever another value arrives.',
    dividend: 'The number being divided.', divisor: 'The number you divide by.',
    quotient: 'The number of whole times a divisor fits into a dividend.', remainder: 'What remains after whole division.',
    gcd: 'Greatest common divisor: the largest positive whole number that divides both inputs exactly.',
    fibonacci: 'A sequence beginning 1, 1 where each later number is the sum of the previous two.',
    parity: 'Whether a whole number is even or odd.',
    binary: 'Writing a number using powers of two and only the digits 0 and 1.',
    bit: 'One binary digit: either 0 or 1.', lsb: 'Least significant bit: the rightmost bit, worth 1.',
    msb: 'Most significant bit: the leftmost bit in the stated width.',
    'zero-padding': 'Adding leading or trailing zero bits until a value has the required fixed width.',
    'bit-position': 'A bit\'s numbered place, starting with position 0 for the bit worth 1.',
    'twos-complement': 'The standard signed-binary convention where the leading bit carries a negative place value.',
    memory: 'A larger numbered storage area that LOAD reads and STOR writes.',
    address: 'The number of a memory location, from 0 through 255 in a cell.',
    index: 'A numeric position used to locate an item. A zero-based index counts the first item as 0.',
    counter: 'A stored number increased or decreased to track how many times something happened.',
    histogram: 'A set of counters, one for each possible category or value.',
    'seen-set': 'Stored marks recording which values have already appeared.',
    key: 'A number used to choose which stored record to access.', value: 'The data stored under a key.',
    command: 'A group of input values that together describe one requested operation.',
    'presence-flag': 'A separate mark saying whether a storage location contains a real record yet.',
    stack: 'A last-in, first-out pile shared by PUSH/POP and CALL/RET.', lifo: 'Last in, first out: the newest stacked value leaves first.',
    'nesting-depth': 'How many openings have not yet been matched by closings.',
    postfix: 'An expression format where each operator comes after the values it uses.',
    operand: 'A value an instruction or operator acts on.', operator: 'A symbol or command that combines or changes operands.',
    subroutine: 'A reusable labeled block entered with CALL and left with RET.',
    'calling-convention': 'An agreement about where arguments, results, saved values, and return information live during a call.',
    recursion: 'A subroutine solving smaller work by calling itself.',
    'stack-frame': 'The values and return information one active subroutine call keeps on the stack.',
    factorial: 'The product of every positive whole number up to n; by definition 0 factorial is 1.',
    frame: 'One complete message inside a longer stream.', payload: 'The useful data carried inside a frame.',
    checksum: 'A small value calculated from payload data so corruption can be detected.',
    modulo: 'The remainder after division; sum modulo 256 means keep the remainder after dividing by 256.',
    'escape-marker': 'A special value saying the following value must be treated as ordinary data.',
    terminator: 'A special value marking the end of a frame or session.',
    session: 'A related sequence of protocol events treated as one interaction.',
    'state-machine': 'A model that remembers one named state and changes it when each event arrives.',
    pattern: 'The short sequence being searched for.', haystack: 'The longer sequence being searched.',
    contiguous: 'Adjacent with no gaps.', overlap: 'Two matches sharing one or more positions.',
    'zero-based': 'Counting the first position as 0, the second as 1, and so on.',
    'token-bucket': 'A rate limiter that stores a bounded number of permissions and spends one per admitted request.',
    'cache-slot': 'One cache location chosen by a key.', 'cache-hit': 'A lookup whose requested key is already in its cache slot.',
    eviction: 'Replacing the record currently occupying a cache slot.',
    idempotency: 'A repeated request has the same effect as processing it once.',
    'circuit-breaker': 'A state machine that temporarily rejects calls after repeated backend failures.',
    fifo: 'First in, first out: the oldest queued value leaves first.',
    channel: 'A directed queue carrying values from one cell to another.',
    stall: 'A cell waits without changing state because SEND is full or RECV is empty.',
    backpressure: 'A full downstream queue naturally making an upstream sender wait.',
    deadlock: 'Every remaining cell is waiting, so no cell can make progress.',
    dispatcher: 'A cell that assigns incoming work to other cells.', worker: 'A cell that performs one assigned part of the work.',
    collector: 'A cell that gathers worker results and restores the required output order.',
    shard: 'One partition that owns only part of a larger key space.',
    replica: 'A second holder of the same logical data.',
    acknowledgment: 'A reply confirming that a requested action completed.',
    commit: 'The point when an operation is accepted as complete and externally visible.',
  };

  function formatStream(values) {
    return values && values.length ? '[ ' + values.join(', ') + ' ]' : '[ ] (empty)';
  }

  function instructionGuideHTML(p) {
    const required = p.required || [];
    return '<div class="op-list">' + p.allowed.map(op => {
      const isNew = firstPuzzleForOp[op] === p.id;
      const must = required.indexOf(op) >= 0;
      const info = MANUAL_COMMANDS[op];
      return '<button type="button" class="op-chip' + (isNew ? ' new' : '') + (must ? ' required' : '') + '" data-manual-op="' +
        escAttr(op) + '" aria-label="Open manual entry for ' + escAttr(op) + ': ' +
        escAttr(info ? info.short : SEED.OPS[op].desc) + '">' + esc(op) +
        (must ? '<span class="op-tag">required</span>' : isNew ? '<span class="op-tag">new</span>' : '') + '</button>';
    }).join('') + '</div><div id="node-affordance" class="node-affordance"></div>';
  }

  function renderNodeAffordance() {
    const host = $('node-affordance');
    if (!host || !sim.puzzle) return;
    const grid = gridOf(sim.puzzle), node = grid[sim.activeNode], channels = sim.puzzle.channels || [];
    const abilities = [];
    if (node.input) abilities.push('reads IN');
    if (node.output) abilities.push('writes OUT');
    channels.forEach(ch => {
      if (ch.from === sim.activeNode) abilities.push('SEND channel ' + ch.id);
      if (ch.to === sim.activeNode) abilities.push('RECV channel ' + ch.id);
    });
    host.textContent = grid.length > 1
      ? node.name + ': ' + (abilities.length ? abilities.join(' · ') : 'no external ports; compute locally')
      : 'This cell can read IN and write OUT. Open any instruction above to see its exact from/to shape.';
  }

  function appendHints(body, p) {
    const g = p.guide || {};
    const hints = (g.hints || []).slice();
    if (p.hint) hints.push(String(p.hint).replace(/^root:\s*/i, ''));
    if (!hints.length) return;
    if (!save.hints) save.hints = {};
    const revealed = Math.min(save.hints[p.id] || 0, hints.length);
    const hb = el('div', 'hintbox');
    hb.innerHTML = '<div class="hint-meta">Hints are free. They never change completion, cycles, or line score.</div>';
    const labels = ['REFRAME', 'CONCEPT', 'STRUCTURE'];
    for (let i = 0; i < revealed; i++) {
      const ci = sim.entry ? sim.entry.ci : 0;
      const speaker = i === 0 && ci >= 1 ? 'WICK' : i === 1 && ci >= 5 ? 'AUDITOR-9' : 'root';
      const voiceClass = speaker === 'WICK' ? 'v-wick' : speaker === 'AUDITOR-9' ? 'v-auditor' : 'root-voice';
      hb.innerHTML += '<div class="hint-step"><span class="lbl ' + voiceClass + '">' + esc(speaker) + ' · HINT ' + (i + 1) + ' · ' +
        (labels[i] || 'NUDGE') + '</span><div class="hint-body ' + voiceClass + '">' + esc(hints[i]) + '</div></div>';
    }
    if (revealed < hints.length) {
      const btn = el('button', 'quiet', 'REVEAL HINT ' + (revealed + 1) + ' OF ' + hints.length);
      btn.onclick = () => {
        save.hints[p.id] = revealed + 1;
        persist();
        renderBriefTab('brief');
      };
      hb.appendChild(btn);
    }
    body.appendChild(hb);
  }

  function renderBriefTab(tab) {
    const p = sim.puzzle, body = $('brief-body');
    if (tab === 'brief') {
      const g = p.guide;
      if (!g) {
        body.innerHTML = '<h3>' + esc(p.name) + '</h3><p>' + esc(p.brief).replace(/\n/g, '</p><p>') + '</p>' + instructionGuideHTML(p);
      } else {
        let h = '<div class="wo-head"><span>work order · ' + esc(p.id) + '</span>' +
          (g.challenge ? '<span class="challenge-flag">OPTIONAL CHALLENGE</span>' : '') + '</div>' +
          '<p class="brief-story">' + esc(g.story || 'The shaft needs this cell working before the descent can continue.') + '</p>' +
          '<p class="brief-goal">' + esc(g.goal) + '</p>' +
          '<div class="io-ledger"><span class="k">IN</span><span>' + esc(g.input) + '</span>' +
          '<span class="k">OUT</span><span>' + esc(g.output) + '</span></div>';
        const hasSupport = (g.rules && g.rules.length) || (g.terms && g.terms.length) || g.example;
        if (hasSupport) h += '<details class="brief-support"><summary>rules and a small example</summary><div class="brief-support-body">';
        if (g.rules && g.rules.length) {
          h += '<ul class="brief-rules">' + g.rules.map(rule => '<li>' + esc(rule) + '</li>').join('') + '</ul>';
        }
        if (g.example) {
          h += '<div class="worked-example"><span class="lbl">example — not the solution</span><div class="streams">' +
            '<b>INPUT</b><span>' + esc(formatStream(g.example.input)) + '</span>' +
            '<b>OUTPUT</b><span>' + esc(formatStream(g.example.output)) + '</span></div>' +
            '<p>' + esc(g.example.why) + '</p></div>';
        }
        if (g.terms && g.terms.length) {
          h += g.terms.map(term =>
            '<div class="term-line"><b>' + esc(term.replace(/-/g, ' ')) + '</b>' +
            (firstPuzzleForTerm[term] === p.id ? '<span class="term-new">NEW</span>' : '') + ' — ' +
            esc(TERM_DEFS[term] || 'See FIELD MANUAL for this concept.') + '</div>').join('');
        }
        if (hasSupport) h += '</div></details>';
        h += '<details class="full-contract"><summary>exact limits and edge cases</summary><p>' +
          esc(p.brief).replace(/\n/g, '</p><p>') + '</p></details>' +
          '<h3>AVAILABLE INSTRUCTIONS</h3>' + instructionGuideHTML(p);
        body.innerHTML = h;
      }
      renderNodeAffordance();
      appendHints(body, p);
      body.querySelectorAll('[data-manual-op]').forEach(button => {
        button.onclick = () => showManualCommand(button.dataset.manualOp);
      });
    } else if (tab === 'note') {
      body.innerHTML = '<div class="fieldnote"><span class="lbl">field note — the world above</span>' +
        esc(p.fieldNote).replace(/\n/g, '<br>') + '</div>' +
        '<p style="margin-top:14px;color:var(--dim);font-size:12px">field notes connect each task to the systems this game is secretly teaching you.</p>';
    } else {
      let h = '';
      p.tests.forEach((t, i) => {
        h += '<h3>TEST ' + (i + 1) + (i === 0 ? ' · scored' : '') + '</h3>' +
          '<div style="overflow-x:auto"><table class="iotable"><tr><th>input given</th>' +
          (t.input.length ? t.input.map(v => '<td>' + v + '</td>').join('') : '<td>(empty)</td>') +
          '</tr><tr><th>expected output</th>' +
          (t.output.length ? t.output.map(v => '<td>' + v + '</td>').join('') : '<td>(none)</td>') +
          '</tr></table></div>';
      });
      body.innerHTML = h || '<p>no tests?</p>';
    }
  }

  /* ---------- state panels ---------- */

  function buildStatePanels() {
    const p = sim.puzzle, grid = gridOf(p);
    const host = $('nodestate'); host.innerHTML = '';
    const wantStack = p.allowed.indexOf('PUSH') >= 0;
    const wantMem = p.allowed.indexOf('STOR') >= 0;
    grid.forEach((g, i) => {
      const box = el('div', 'statebox');
      box.innerHTML = '<span class="lbl">' + esc(g.name) + ' <span id="nd-flag-' + i + '"></span></span>';
      const regs = el('div', 'regrow');
      ['A', 'B', 'C', 'D'].forEach((r, ri) => {
        regs.appendChild(el('div', 'regcell',
          '<div class="rname">' + r + '</div><div class="rval" id="reg-' + i + '-' + ri + '">0</div>'));
      });
      box.appendChild(regs);
      if (wantStack) {
        box.appendChild(el('div', 'lbl', 'stack')).style.marginTop = '10px';
        box.appendChild(el('div', 'stackview', '')).id = 'stack-' + i;
      }
      if (wantMem) {
        box.appendChild(el('div', 'lbl', 'memory 0–255')).style.marginTop = '10px';
        const mg = el('div', 'memgrid'); mg.id = 'mem-' + i;
        for (let c = 0; c < 256; c++) mg.appendChild(el('i'));
        box.appendChild(mg);
      }
      host.appendChild(box);
    });
    const chans = p.channels || [];
    $('chan-panel').style.display = chans.length ? '' : 'none';
    const cb = $('chan-body'); cb.innerHTML = '';
    if (DIAGRAMS[p.id]) {
      const pre = el('pre', 'topo');
      pre.id = 'topo-view';
      cb.appendChild(pre);
      return;
    }
    chans.forEach(c => {
      const row = el('div', 'chanrow');
      row.innerHTML = '<span style="color:var(--dim)">ch' + c.id + '</span><span>' +
        esc(grid[c.from].name) + ' → ' + esc(grid[c.to].name) + '</span>';
      const q = el('div', 'cq'); q.id = 'chq-' + c.id;
      for (let s = 0; s < SEED.CHAN_CAP; s++) q.appendChild(el('i'));
      row.appendChild(q);
      const cnt = el('span', '', ''); cnt.id = 'chn-' + c.id; cnt.style.color = 'var(--halcyon)';
      row.appendChild(cnt);
      cb.appendChild(row);
    });
  }

  function paintAll() {
    const p = sim.puzzle, grid = gridOf(p), m = sim.machine, t = p.tests[sim.testIdx];
    if (m && m.status === 'fail' && m.stopNode >= 0 && m.stopNode < grid.length && sim.activeNode !== m.stopNode) {
      selectNode(m.stopNode);
    }
    $('cycle-count').textContent = m ? m.cycles : 0;
    grid.forEach((g, i) => {
      const nd = m ? m.nodes[i] : null;
      for (let r = 0; r < 4; r++) $('reg-' + i + '-' + r).textContent = nd ? nd.regs[r] : 0;
      const flag = $('nd-flag-' + i);
      flag.textContent = !nd ? '' : nd.halted
        ? '· halted' + (nd.haltReason === 'input-empty' ? ': IN empty' : nd.haltReason === 'hlt' ? ': HLT' : '')
        : nd.stalled
          ? '· waiting: ' + (nd.stallReason === 'send-full' ? 'channel ' + nd.stallChannel + ' full' : 'channel ' + nd.stallChannel + ' empty')
          : '';
      flag.style.color = nd && nd.stalled ? 'var(--clay)' : 'var(--faint)';
      const sv = $('stack-' + i);
      if (sv) sv.innerHTML = (nd ? nd.stack : []).map((v, si, arr) =>
        '<span class="' + (si === arr.length - 1 ? 'top' : '') + '">' + v + '</span>').join('') || '<span style="border:none;color:var(--faint)">empty</span>';
      const mg = $('mem-' + i);
      if (mg) {
        const cells = mg.children;
        for (let c = 0; c < 256; c++) {
          const val = nd ? (nd.mem[c] || 0) : 0;
          cells[c].className = val !== 0 ? 'hot' : '';
          cells[c].title = c + ': ' + val;
        }
      }
      /* pc line */
      const pcLine = (nd && !nd.halted && m.status === 'run' && nd.code[nd.pc < nd.code.length ? nd.pc : 0])
        ? nd.code[nd.pc < nd.code.length ? nd.pc : 0].ln : undefined;
      const errLine = m && m.status === 'fail' && m.stopNode === i ? m.stopLine : undefined;
      refreshEditor(i, pcLine, errLine);
    });
    if (DIAGRAMS[p.id]) {
      const tv = $('topo-view');
      if (tv) tv.innerHTML = topoHTML(DIAGRAMS[p.id], m);
    } else {
      (p.channels || []).forEach(c => {
        const q = m ? m.channels.filter(x => x.id === c.id)[0].q : [];
        const slots = $('chq-' + c.id).children;
        for (let s = 0; s < SEED.CHAN_CAP; s++) slots[s].className = s < q.length ? 'full' : '';
        $('chn-' + c.id).textContent = q.length ? q.join(',') : '';
      });
    }
    /* streams */
    const outLen = m ? m.out.length : 0;
    if (outLen > (sim.lastOut || 0)) SFX.emit();
    sim.lastOut = outLen;
    const ptr = m ? m.inPtr : 0;
    $('io-in').innerHTML = t.input.map((v, i) =>
      '<span id="trace-in-' + i + '" class="' + (i < ptr ? 'used' : i === ptr ? 'cur' : '') + '">' + v + '</span>').join('') ||
      '<span class="want">(empty)</span>';
    const out = m ? m.out : [];
    $('io-out').innerHTML = t.output.map((want, i) => {
      if (i < out.length) {
        return out[i] === want
          ? '<span id="trace-out-' + i + '" class="match">' + out[i] + '</span>'
          : '<span id="trace-out-' + i + '" class="mism">' + out[i] + ' ≠ ' + want + '</span>';
      }
      return '<span id="trace-out-' + i + '" class="want">' + want + '</span>';
    }).join('') + out.slice(t.output.length).map((v, i) => '<span id="trace-out-extra-' + i + '" class="mism">' + v + ' ≠ ∅</span>').join('') ||
      '<span class="want">(none expected)</span>';
    const rewind = $('btn-rewind');
    if (rewind) rewind.disabled = !m || m.cycles <= 0 || !sim.programs;
  }

  /* ---------- machine control ---------- */

  function clearDebugActions() { $('debug-actions').innerHTML = ''; }

  function addDebugAction(label, fn, primary) {
    const b = el('button', primary ? 'primary' : '', label);
    b.onclick = fn;
    $('debug-actions').appendChild(b);
  }

  function setStatus(msg, kind) {
    const s = $('status-line');
    s.textContent = msg;
    s.className = kind === 'ok' ? 'ok' : kind === 'err' ? 'err' : '';
  }
  function clearStatus() {
    clearDebugActions();
    setStatus('machine idle — write, then RUN or STEP', '');
  }

  function friendlyParseError(res, source) {
    const raw = String(source || '').replace(/\r\n?/g, '\n').split('\n')[res.line - 1] || '';
    const op = ((/^\s*([A-Za-z]+)/.exec(raw) || [])[1] || '').toUpperCase();
    const info = MANUAL_COMMANDS[op];
    if (info && / takes \d+ operands?/.test(res.msg)) {
      if (op === 'MOV') return 'MOV needs a source and destination. Use the shape: MOV from to.';
      return op + ' has the wrong number of parts. Use the shape: ' + info.sig + '.';
    }
    if (/^unknown instruction/.test(res.msg)) return 'I do not recognize that command. Open CURRENT COMMANDS to see what this stratum understands.';
    if (/ is not available in this stratum yet$/.test(res.msg)) return op + ' unlocks later. The AVAILABLE INSTRUCTIONS list shows what you can use here.';
    if (/^bad operand/.test(res.msg)) return 'One part of this command is not a number, pocket, port, channel, or label the machine recognizes.';
    return res.msg;
  }

  function buildMachine() {
    const p = sim.puzzle, grid = gridOf(p), code = playerCode(p);
    const programs = [];
    for (let i = 0; i < grid.length; i++) {
      const res = SEED.parseProgram(code[i], {
        allowed: p.allowed, node: grid[i], nodeIndex: i, channels: p.channels || [],
      });
      if (!res.ok) {
        selectNode(i);
        refreshEditor(i, undefined, res.line);
        setStatus('[' + grid[i].name + '] line ' + res.line + ': ' + friendlyParseError(res, code[i]), 'err');
        clearDebugActions();
        addDebugAction('OPEN CURRENT COMMANDS', () => showManual('commands', false));
        return false;
      }
      programs.push(res.code);
    }
    let empty = true;
    programs.forEach(pr => { if (pr.length) empty = false; });
    if (empty) { setStatus('no instructions — the cell has nothing to do', 'err'); return false; }
    const requirement = SEED.checkRequired(p, programs);
    if (!requirement.ok) {
      setStatus(requirement.op + ' is required here because this puzzle teaches that mechanism. The brief explains why.', 'err');
      clearDebugActions();
      addDebugAction('OPEN CURRENT COMMANDS', () => showManual('commands', false));
      return false;
    }
    sim.programs = programs;
    sim.machine = SEED.makeMachine(p, programs, p.tests[sim.testIdx]);
    sim.lastOut = 0;
    sim.breakpointSkip = '';
    sim.dirty = false;
    return true;
  }

  function ensureMachine() {
    if (!sim.machine || sim.dirty) { if (!buildMachine()) return false; }
    return true;
  }

  function stopExplanation(m) {
    const expected = m.expected.length, made = m.out.length, missing = Math.max(0, expected - made);
    const nd = m.stopNode >= 0 && m.nodes[m.stopNode] ? m.nodes[m.stopNode] : null;
    const who = nd ? nd.name + ' ' : 'The program ';
    if (m.stopReason === 'wrong-output') {
      const pos = Math.max(0, made - 1);
      return 'Output ' + (pos + 1) + ' is wrong: expected ' +
        (pos < expected ? m.expected[pos] : 'no additional value') + ', got ' + m.out[pos] + '.';
    }
    if (m.stopReason === 'input-empty') {
      return who + 'reached a command that needed ' + (nd && nd.inputNeeded > 1 ? nd.inputNeeded + ' IN values at once' : 'another IN value') +
        ', but only ' + (nd ? nd.inputRemaining : 0) + ' remained. ' +
        'The program produced ' + made + ' of ' + expected + ' outputs; ' + missing + ' still ' + (missing === 1 ? 'is' : 'are') + ' missing.';
    }
    if (m.stopReason === 'hlt') {
      return who + 'reached HLT after producing ' + made + ' of ' + expected + ' outputs; ' +
        missing + ' still ' + (missing === 1 ? 'is' : 'are') + ' missing.';
    }
    if (m.stopReason === 'all-halted') {
      return 'Every cell stopped, but OUT contains only ' + made + ' of the required ' + expected + ' values.';
    }
    if (m.stopReason === 'deadlock') {
      const waits = m.nodes.filter(x => x.stalled).map(x => x.name + ' waits for channel ' + x.stallChannel +
        (x.stallReason === 'send-full' ? ' to have space' : ' to receive a value'));
      return 'Deadlock: no cell can move. ' + waits.join('; ') + '.';
    }
    if (m.stopReason === 'cycle-limit') {
      return 'The run reached ' + SEED.MAX_CYCLES + ' cycles without finishing. A loop probably never reaches its exit condition.';
    }
    if (m.stopReason === 'runtime-error') return m.failMsg || 'The machine reached an invalid runtime state.';
    return m.failMsg || 'The test stopped for an unknown reason.';
  }

  function pulseTrace(target) {
    if (!target || motionReduced()) return;
    target.classList.remove('trace-pulse');
    void target.offsetWidth;
    target.classList.add('trace-pulse');
  }

  function flyTrace(value, from, to) {
    if (motionReduced() || sim.seeking || !from || !to) { pulseTrace(to || from); return; }
    const a = from.getBoundingClientRect(), b = to.getBoundingClientRect();
    const token = el('span', 'trace-token', esc(value));
    token.style.left = (a.left + a.width / 2 - 12) + 'px';
    token.style.top = (a.top + a.height / 2 - 10) + 'px';
    document.body.appendChild(token);
    requestAnimationFrame(() => {
      token.style.transform = 'translate(' + (b.left + b.width / 2 - a.left - a.width / 2) + 'px,' +
        (b.top + b.height / 2 - a.top - a.height / 2) + 'px)';
      token.style.opacity = '.15';
    });
    setTimeout(() => { pulseTrace(to); token.remove(); }, 310);
  }

  function animateEvents(events) {
    if (motionReduced() || sim.seeking || !events || !events.length) return;
    const fromInput = {}, fromChannel = {};
    events.forEach(ev => {
      if (ev.type === 'read-in') fromInput[ev.node] = ev;
      else if (ev.type === 'recv') fromChannel[ev.node] = ev;
      else if (ev.type === 'write-reg' || ev.type === 'load') {
        const to = $('reg-' + ev.node + '-' + ev.register);
        const read = fromInput[ev.node];
        const recv = fromChannel[ev.node];
        if (read) { flyTrace(ev.value, $('trace-in-' + read.position), to); delete fromInput[ev.node]; }
        else if (recv) { flyTrace(ev.value, $('chq-' + recv.channel) || $('topo-view'), to); delete fromChannel[ev.node]; }
        else pulseTrace(to && to.parentElement);
      } else if (ev.type === 'emit') {
        const to = $('trace-out-' + ev.position) || $('trace-out-extra-' + Math.max(0, ev.position - sim.machine.expected.length));
        const read = fromInput[ev.node];
        const recv = fromChannel[ev.node];
        if (read) { flyTrace(ev.value, $('trace-in-' + read.position), to); delete fromInput[ev.node]; }
        else if (recv) { flyTrace(ev.value, $('chq-' + recv.channel) || $('topo-view'), to); delete fromChannel[ev.node]; }
        else pulseTrace(to);
      } else if (ev.type === 'send') {
        const to = $('chq-' + ev.channel) || $('topo-view');
        const read = fromInput[ev.node];
        if (read) { flyTrace(ev.value, $('trace-in-' + read.position), to); delete fromInput[ev.node]; }
        else pulseTrace(to);
      } else if (ev.type === 'store') {
        pulseTrace($('mem-' + ev.node));
      } else if (ev.type === 'push' || ev.type === 'pop' || ev.type === 'call' || ev.type === 'ret') {
        pulseTrace($('stack-' + ev.node));
      }
    });
  }

  function seekCycle(target) {
    stopSim();
    if (!ensureMachine()) return false;
    const p = sim.puzzle;
    const m = SEED.makeMachine(p, sim.programs, p.tests[sim.testIdx]);
    sim.seeking = true;
    while (m.status === 'run' && m.cycles < target) SEED.stepCycle(m);
    sim.seeking = false;
    sim.machine = m;
    sim.lastOut = m.out.length;
    sim.dirty = false;
    sim.breakpointSkip = '';
    paintAll();
    return true;
  }

  function nextBreakpoint() {
    const m = sim.machine;
    if (!m || m.status !== 'run') return null;
    for (let i = 0; i < m.nodes.length; i++) {
      const nd = m.nodes[i];
      if (nd.halted || !nd.code.length) continue;
      const pc = nd.pc < nd.code.length ? nd.pc : 0;
      const line = nd.code[pc].ln;
      if (hasBreakpoint(i, line)) return { node: i, line, sig: m.cycles + ':' + i + ':' + line };
    }
    return null;
  }

  function pauseForBreakpoint(hit) {
    sim.breakpointSkip = hit.sig;
    stopSim();
    selectNode(hit.node);
    paintAll();
    setStatus('BREAKPOINT: paused before cycle ' + (sim.machine.cycles + 1) + ', line ' + hit.line + '. STEP executes the whole next cycle.', '');
    clearDebugActions();
    addDebugAction('STEP THROUGH', doStep, true);
  }

  function breakpointBeforeRun() {
    const hit = nextBreakpoint();
    if (!hit) return null;
    if (sim.breakpointSkip === hit.sig) { sim.breakpointSkip = ''; return null; }
    return hit;
  }

  function afterStep() {
    const m = sim.machine;
    if (m.status === 'run') return;
    stopSim();
    if (m.status === 'success') {
      SFX.good();
      setStatus('TEST ' + (sim.testIdx + 1) + ' PASSED in ' + m.cycles + ' cycles — VALIDATE to run all tests', 'ok');
      clearDebugActions();
    } else {
      if (m.stopReason === 'deadlock') SFX.deadlock(); else SFX.bad();
      sim.lastFailure = { testIdx: sim.testIdx, cycle: m.cycles, reason: m.stopReason, node: m.stopNode, line: m.stopLine };
      setStatus('TEST ' + (sim.testIdx + 1) + ' FAILED — ' + stopExplanation(m), 'err');
      clearDebugActions();
      if (m.cycles > 0) addDebugAction('INSPECT ONE CYCLE BEFORE', inspectFailure, true);
    }
  }

  function doStep() {
    stopSim();
    if (!ensureMachine()) return;
    if (sim.machine.status !== 'run') { paintAll(); return; }
    SEED.stepCycle(sim.machine);
    const events = sim.machine.events.slice();
    paintAll(); animateEvents(events);
    if (sim.machine.status === 'run') {
      clearDebugActions();
      setStatus('paused after cycle ' + sim.machine.cycles + ' — the highlighted line executes next', '');
    } else afterStep();
  }

  const RUN_DELAYS = { slow: 320, normal: 90, quick: 32 };
  function scheduleWatch() {
    const delay = RUN_DELAYS[save.settings.runSpeed] || RUN_DELAYS.normal;
    sim.timer = setTimeout(watchTick, delay);
  }

  function watchTick() {
    sim.timer = null;
    if (!sim.machine || sim.machine.status !== 'run') { if (sim.machine) { paintAll(); afterStep(); } return; }
    const hit = breakpointBeforeRun();
    if (hit) { pauseForBreakpoint(hit); return; }
    SEED.stepCycle(sim.machine);
    const events = sim.machine.events.slice();
    paintAll(); animateEvents(events);
    if (sim.machine.status !== 'run') afterStep(); else scheduleWatch();
  }

  function doRun() {
    if (sim.timer || sim.raf) {
      stopSim();
      setStatus('paused at cycle ' + (sim.machine ? sim.machine.cycles : 0) + ' — STEP or RUN to continue', '');
      return;
    }
    if (!ensureMachine()) return;
    if (sim.machine.status !== 'run') { afterStep(); return; }
    paintAll();
    $('btn-run').classList.add('on'); $('btn-run').textContent = 'PAUSE';
    setStatus('running…', '');
    clearDebugActions();
    scheduleWatch();
  }

  function doFast() {
    if (!ensureMachine()) return;
    stopSim();
    setStatus('running fast…', '');
    const spin = () => {
      const m = sim.machine;
      for (let k = 0; k < 300 && m.status === 'run'; k++) {
        const hit = breakpointBeforeRun();
        if (hit) { sim.raf = null; pauseForBreakpoint(hit); return; }
        SEED.stepCycle(m);
      }
      paintAll();
      if (m.status === 'run') { sim.raf = requestAnimationFrame(spin); }
      else afterStep();
    };
    sim.raf = requestAnimationFrame(spin);
  }

  function stopSim() {
    if (sim.timer) { clearTimeout(sim.timer); sim.timer = null; }
    if (sim.raf) { cancelAnimationFrame(sim.raf); sim.raf = null; }
    const br = $('btn-run');
    if (br) { br.classList.remove('on'); br.textContent = 'RUN'; }
  }

  function doReset() {
    stopSim(); sim.machine = null; sim.dirty = true; sim.lastFailure = null; sim.breakpointSkip = '';
    clearStatus();
    if (buildMachine()) {
      paintAll();
      setStatus('reset to cycle 0 — the highlighted line executes next', '');
    } else paintAll();
  }

  function doRewind() {
    if (!sim.machine || sim.machine.cycles <= 0) return;
    const target = sim.machine.cycles - 1;
    if (!seekCycle(target)) return;
    SFX.rewind();
    setStatus('rewound to cycle ' + target + ' — STEP reproduces the next cycle', '');
    clearDebugActions();
  }

  function inspectFailure() {
    const f = sim.lastFailure;
    if (!f || f.cycle <= 0) return;
    sim.testIdx = f.testIdx;
    document.querySelectorAll('#test-tabs button').forEach((x, xi) => x.classList.toggle('on', xi === f.testIdx));
    document.querySelectorAll('#test-tabs button').forEach((x, xi) => x.setAttribute('aria-selected', xi === f.testIdx ? 'true' : 'false'));
    sim.machine = null; sim.dirty = true;
    if (!seekCycle(Math.max(0, f.cycle - 1))) return;
    if (f.node >= 0) selectNode(f.node);
    setStatus('paused one cycle before the failure on test ' + (f.testIdx + 1) + ' — STEP to reproduce it', '');
    clearDebugActions();
    addDebugAction('STEP TO REPRODUCE', doStep, true);
  }

  function validationFailureText(result, test) {
    const made = result.out ? result.out.length : 0;
    if (result.reason === 'wrong-output') {
      const pos = Math.max(0, made - 1);
      return 'output ' + (pos + 1) + ' is wrong: expected ' +
        (pos < test.output.length ? test.output[pos] : 'no additional value') + ', got ' + result.out[pos];
    }
    if (result.reason === 'input-empty') return 'not enough unread IN values remained to produce all ' + test.output.length + ' required outputs';
    if (result.reason === 'hlt') return 'HLT stopped the program after ' + made + ' of ' + test.output.length + ' outputs';
    if (result.reason === 'deadlock') return 'every running cell is waiting, so none can make progress';
    if (result.reason === 'cycle-limit') return 'the program ran for ' + SEED.MAX_CYCLES + ' cycles without finishing';
    return result.msg || 'unknown failure';
  }

  function doValidate() {
    stopSim();
    const p = sim.puzzle, code = playerCode(p);
    /* parse check via buildMachine for error display */
    if (!buildMachine()) return;
    const results = [];
    for (let i = 0; i < p.tests.length; i++) {
      const r = SEED.runTest(p, code, p.tests[i], true);
      results.push(r);
      if (!r.pass) {
        sim.testIdx = i;
        sim.lastFailure = { testIdx: i, cycle: r.cycles, reason: r.reason, node: r.node, line: r.line };
        document.querySelectorAll('#test-tabs button').forEach((x, xi) => x.classList.toggle('on', xi === i));
        document.querySelectorAll('#test-tabs button').forEach((x, xi) => x.setAttribute('aria-selected', xi === i ? 'true' : 'false'));
        sim.machine = null; sim.dirty = true; paintAll();
        setStatus('VALIDATE: test ' + (i + 1) + ' failed — ' + validationFailureText(r, p.tests[i]) + '.', 'err');
        clearDebugActions();
        if (!r.parseError && r.cycles > 0) addDebugAction('INSPECT FAILURE', inspectFailure, true);
        else addDebugAction('OPEN CURRENT COMMANDS', () => showManual('commands', false));
        return;
      }
    }
    const cycles = results[0].cycles;
    const lines = SEED.countLines(p, code);
    const run = { cycles, lines };
    const prev = recordOf(p.id);
    const rec = (!prev || prev.legacy)
      ? { fast: run, small: { cycles, lines } }
      : { fast: beats(run, prev.fast, 'cycles', 'lines') ? run : prev.fast,
          small: beats(run, prev.small, 'lines', 'cycles') ? run : prev.small };
    save.solved[p.id] = rec; persist();
    recordSolutionHistory(p.id, code, { cycles, lines }, 'validated solution');
    paintBest();
    setStatus('ALL TESTS PASSED', 'ok');
    SFX.stamp();
    showSuccess(cycles, lines);
  }

  $('btn-step').onclick = doStep;
  $('btn-run').onclick = doRun;
  $('btn-fast').onclick = doFast;
  $('btn-reset').onclick = doReset;
  $('btn-rewind').onclick = doRewind;
  $('btn-validate').onclick = doValidate;
  $('btn-back').onclick = () => {
    checkpointCurrentSolution('left puzzle');
    stopSim(); stopCoach(false); renderMap(); show('scr-map');
  };
  document.addEventListener('keydown', (e) => {
    if ($('scr-puzzle').classList.contains('hidden') || modalRoot.classList.contains('show') || scene.active) return;
    if ((e.ctrlKey || e.metaKey) && e.key === 'Enter') { e.preventDefault(); doValidate(); }
    else if (e.key === 'F10') { e.preventDefault(); doStep(); }
    else if (e.key === 'F8') { e.preventDefault(); doRun(); }
    else if (e.altKey && e.key.toLowerCase() === 'r') { e.preventDefault(); doReset(); }
    else if (e.altKey && e.key === 'ArrowLeft') { e.preventDefault(); doRewind(); }
    else if (e.altKey && e.key === 'Enter') { e.preventDefault(); toggleFullscreen(); }
  });

  /* ---------- modals ---------- */

  const modalRoot = $('modal-root'), modalBox = $('modal-box');
  let modalReturnFocus = null;
  function openModal(html, actions, page) {
    if (!modalRoot.classList.contains('show')) modalReturnFocus = document.activeElement;
    modalBox.classList.toggle('page', !!page);
    modalBox.innerHTML = html;
    const act = el('div', 'actions');
    (actions || [{ label: 'CLOSE' }]).forEach(a => {
      const b = el('button', a.primary ? 'primary' : '', esc(a.label));
      b.onclick = () => { closeModal(); if (a.fn) a.fn(); };
      act.appendChild(b);
    });
    modalBox.appendChild(act);
    const heading = modalBox.querySelector('h2');
    if (heading) { heading.id = 'active-modal-title'; modalBox.setAttribute('aria-labelledby', heading.id); }
    else modalBox.removeAttribute('aria-labelledby');
    modalRoot.classList.add('show');
    requestAnimationFrame(() => {
      const initial = modalBox.querySelector('input, select, textarea, [autofocus]');
      (initial || modalBox).focus();
    });
  }
  function closeModal() {
    modalRoot.classList.remove('show');
    if (modalReturnFocus && document.body.contains(modalReturnFocus)) modalReturnFocus.focus();
    modalReturnFocus = null;
  }
  modalRoot.addEventListener('click', (e) => { if (e.target === modalRoot) closeModal(); });
  modalRoot.addEventListener('keydown', (e) => {
    if (e.key === 'Escape') { e.preventDefault(); closeModal(); return; }
    if (e.key !== 'Tab') return;
    const focusable = Array.from(modalBox.querySelectorAll('button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), summary, [href], [tabindex]:not([tabindex="-1"])'))
      .filter(node => node.offsetParent !== null);
    if (!focusable.length) { e.preventDefault(); modalBox.focus(); return; }
    const first = focusable[0], last = focusable[focusable.length - 1];
    if (e.shiftKey && document.activeElement === first) { e.preventDefault(); last.focus(); }
    else if (!e.shiftKey && document.activeElement === last) { e.preventDefault(); first.focus(); }
  });

  function showChapterIntro(ch) {
    if (SCENES['arrive-' + ch.id]) { playScene('arrive-' + ch.id, ch, null); return; }
    const h = (ch.intro && ch.intro.halcyon) || '';
    const r = (ch.intro && ch.intro.root) || '';
    openModal(
      '<h2>STRATUM ' + esc(ch.numeral) + ' — ' + esc(ch.title) + '</h2>' +
      (EMBLEMS[ch.id] ? '<pre class="emblem-intro">' + esc(EMBLEMS[ch.id]) + '</pre>' : '') +
      '<span class="halcyon-voice">' + esc(h).replace(/\n/g, '<br>') + '</span>' +
      '<p class="root-voice" style="margin-top:16px">' + esc(r).replace(/\n/g, '<br>') + '</p>',
      [{ label: 'BEGIN', primary: true }]
    );
    modalBox.insertBefore(makeSigil(), modalBox.firstChild);
  }

  function voicedHTML(text, fallback) {
    const raw = String(text || '');
    const match = /^(HALCYON|root|WICK|AUDITOR-9):\s*/.exec(raw);
    const who = match ? match[1] : (fallback || 'HALCYON');
    const body = match ? raw.slice(match[0].length) : raw;
    const voiceClass = who === 'HALCYON' ? 'halcyon-voice' : who === 'root' ? 'root-voice' : who === 'WICK' ? 'v-wick' : 'v-auditor';
    return '<span class="' + voiceClass + '"><b class="voice-name">' + esc(who) + ':</b> ' + esc(body) + '</span>';
  }

  function showSuccess(cycles, lines) {
    const p = sim.puzzle, entry = sim.entry;
    const idx = puzzleIndex[p.id];
    const next = allPuzzles.find(candidate =>
      stratumOpen(candidate.ci) && !isOptionalPuzzle(candidate.p) && !save.solved[candidate.p.id]);
    const isFinale = idx === allPuzzles.length - 1;
    const finaleReady = !isOptionalPuzzle(p) && shaftComplete();
    const bar = (label, you, par) => {
      const max = Math.max(you, par, 1);
      return '<div class="parbar"><div class="lbl">' + label + '</div>' +
        '<div class="brow"><span class="who">you</span><div class="bar" style="width:' + (you / max * 240) + 'px"></div><span class="n">' + you + '</span></div>' +
        '<div class="brow hb"><span class="who">halcyon est.</span><div class="bar" style="width:' + (par / max * 240) + 'px"></div><span class="n">' + par + '</span></div></div>';
    };
    const beat = (you, par) => you <= par;
    const withCompletion = (fn) => () => {
      const ch = entry.ch, id = 'complete-' + ch.id;
      if (SCENES[id] && !save.scenes[id] && chapterComplete(ch)) playScene(id, ch, fn);
      else fn();
    };
    const actions = [];
    if (finaleReady) actions.push({ label: 'DESCEND NO FURTHER', primary: true, fn: showEpilogue });
    else if (next && stratumOpen(next.ci)) actions.push({ label: 'NEXT TASK', primary: true, fn: withCompletion(() => openPuzzle(next.p.id)) });
    actions.push({ label: 'RETURN TO SHAFT', fn: withCompletion(() => { renderMap(); show('scr-map'); }) });
    openModal(
      '<div><span class="stamp">TENDED</span></div>' +
      '<h2>' + esc(p.name) + '</h2>' +
      bar('cycles (test 1)', cycles, p.par.cycles) +
      bar('instructions', lines, p.par.lines) +
      '<p style="color:var(--dim);font-size:12px">' +
      (beat(cycles, p.par.cycles) && beat(lines, p.par.lines)
        ? 'you beat HALCYON\'s estimate on both counts. it will pretend not to be delighted.'
        : 'par is HALCYON\'s estimate, not a wall. optimize if it itches.') +
      (isFinale && !finaleReady
        ? '<br><br>THE COVENANT holds, but required cells elsewhere in the shaft remain untended. The final descent waits for the whole path.'
        : '') + '</p>' +
      voicedHTML(p.outro || '', 'HALCYON'),
      actions
    );
  }

  function showEpilogue() {
    if (!shaftComplete()) {
      renderMap(); show('scr-map');
      return;
    }
    SFX.dawn();
    openModal(
      '<h2>THE COVENANT</h2>' +
      EPILOGUE.halcyon.map(t => '<span class="halcyon-voice" style="display:block;margin-bottom:12px">' + esc(t) + '</span>').join('') +
      '<p class="root-voice" style="margin-top:18px">' + esc(EPILOGUE.root) + '</p>' +
      '<p style="color:var(--dim);font-size:12px;margin-top:18px">' + esc(EPILOGUE.shell) +
      (allPuzzles.some(entry => isOptionalPuzzle(entry.p) && !save.solved[entry.p.id])
        ? '<br>optional challenge cells remain available in the shaft' : '') + '</p>',
      [{ label: 'SURFACE', primary: true, fn: () => { renderMap(); show('scr-map'); } }], true
    );
    modalBox.insertBefore(makeSigil(), modalBox.firstChild);
  }

  const MANUAL_UNLOCK_INDEX = { I: 0, II: 1, III: 2, VI: 5, VII: 6, X: 9 };
  const MANUAL_COMMAND_ORDER = [
    'MOV', 'HLT', 'ADD', 'SUB', 'JMP', 'JEZ', 'JNZ', 'JGZ', 'JLZ', 'JEI',
    'LOAD', 'STOR', 'PUSH', 'POP', 'CALL', 'RET', 'SEND', 'RECV', 'JCE', 'JCF',
  ];
  const MANUAL_COMMANDS = {
    MOV: {
      sig: 'MOV from to', short: 'Copy one number from the first place to the second.',
      example: 'MOV 8 A', result: 'Pocket A changes from 0 to 8. The 8 is copied, so its original source is not emptied unless that source was IN.',
      mistake: 'The order is from, then to. MOV A 8 is invalid because a plain number cannot be a destination.',
    },
    HLT: {
      sig: 'HLT', short: 'Stop this cell.',
      example: 'MOV 8 OUT\nHLT', result: 'The cell stops if it reaches HLT. A test can succeed before HLT when its complete expected output has already appeared.',
      mistake: 'HLT is not required at the bottom of every program. Reaching the bottom wraps to line 1, and an attempted read from empty IN stops cleanly.',
    },
    ADD: {
      sig: 'ADD value pocket', short: 'Add a number to a pocket and keep the new total there.',
      example: 'MOV 5 A\nADD 3 A', result: 'A starts with 5, then becomes 8.',
      mistake: 'The second part must be A, B, C, or D. ADD changes a pocket; it does not automatically send the result to OUT.',
    },
    SUB: {
      sig: 'SUB value pocket', short: 'Subtract a number from a pocket and keep the new total there.',
      example: 'MOV 5 A\nSUB 2 A', result: 'A starts with 5, then becomes 3.',
      mistake: 'Read this as pocket minus value: A becomes A - 2. SUB A B changes B, not A.',
    },
    JMP: {
      sig: 'JMP label', short: 'Continue execution at a named line every time.',
      example: 'JMP finished\nMOV 99 A\nfinished:\nHLT', result: 'Execution jumps over MOV 99 A, so A remains 0.',
      mistake: 'Put a colon after a label when defining it, but not when jumping to it: finished: defines; JMP finished uses.',
    },
    JEZ: {
      sig: 'JEZ pocket label', short: 'Jump when the chosen pocket contains exactly zero.',
      example: 'MOV 0 A\nJEZ A empty\nMOV 99 B\nempty:\nHLT', result: 'A is zero, so execution jumps to empty and B remains 0.',
      mistake: 'JEZ only looks at the pocket. It does not remove or change the value stored there.',
    },
    JNZ: {
      sig: 'JNZ pocket label', short: 'Jump when the chosen pocket is anything except zero.',
      example: 'MOV 4 A\nJNZ A present\nHLT\npresent:\nMOV 1 B', result: 'A is not zero, so execution reaches present and puts 1 in B.',
      mistake: 'Negative numbers are also not zero, so JNZ jumps for both positive and negative values.',
    },
    JGZ: {
      sig: 'JGZ pocket label', short: 'Jump when the chosen pocket is greater than zero.',
      example: 'MOV 2 A\nJGZ A above\nHLT\nabove:\nMOV 1 B', result: 'A is positive, so B becomes 1.',
      mistake: 'Zero is not positive. Use JEZ when zero needs its own path.',
    },
    JLZ: {
      sig: 'JLZ pocket label', short: 'Jump when the chosen pocket is less than zero.',
      example: 'MOV -2 A\nJLZ A below\nHLT\nbelow:\nMOV 1 B', result: 'A is negative, so B becomes 1.',
      mistake: 'The minus sign belongs to the number. JLZ does not make a number negative; it only checks one.',
    },
    JEI: {
      sig: 'JEI label', short: 'Jump when no unread input numbers remain.',
      example: 'again:\nJEI finished\nMOV IN A\nJMP again\nfinished:\nHLT', result: 'The check does not consume input. MOV IN A takes a number only when one remains.',
      mistake: 'JEI means jump if empty. It is a check, not a read, and it is only available on a cell with an input port.',
    },
    LOAD: {
      sig: 'LOAD address pocket', short: 'Copy the memory value at an address into a pocket.',
      example: 'LOAD 7 A', result: 'A receives the value in memory cell 7. Unwritten memory starts at zero.',
      mistake: 'The address comes first and must be from 0 through 255. LOAD reads memory; it does not erase it.',
    },
    STOR: {
      sig: 'STOR value address', short: 'Copy a number into a memory address.',
      example: 'STOR 42 7\nLOAD 7 A', result: 'Memory cell 7 receives 42, then LOAD copies that 42 into A.',
      mistake: 'STOR uses value first, address second. Reversing them stores 7 at address 42.',
    },
    PUSH: {
      sig: 'PUSH value', short: 'Place a number on top of this cell\'s stack.',
      example: 'PUSH 8\nPUSH 3', result: 'The stack now has 3 on top, with 8 underneath it.',
      mistake: 'The most recently pushed value is the first one POP retrieves.',
    },
    POP: {
      sig: 'POP to', short: 'Remove the top stack value and copy it to a pocket or OUT.',
      example: 'PUSH 8\nPUSH 3\nPOP A', result: 'A receives 3. The 8 remains on the stack.',
      mistake: 'POP removes a value. A second POP would receive 8, not 3 again.',
    },
    CALL: {
      sig: 'CALL label', short: 'Remember where to return, then enter a named subroutine.',
      example: 'CALL helper\nHLT\nhelper:\nMOV 6 A\nRET', result: 'The cell visits helper, sets A to 6, then RET returns to the HLT after CALL.',
      mistake: 'CALL stores its return line on the same stack used by PUSH and POP. Unbalanced data can make RET return to the wrong place.',
    },
    RET: {
      sig: 'RET', short: 'Return to the instruction immediately after the latest CALL.',
      example: 'CALL helper\nHLT\nhelper:\nRET', result: 'RET takes the remembered return line from the stack and continues at HLT.',
      mistake: 'RET needs a return line left by CALL. Using RET with an empty or damaged stack fails.',
    },
    SEND: {
      sig: 'SEND value channel', short: 'Append a number to an outgoing channel.',
      example: 'SEND 8 1', result: 'The value 8 enters channel 1. If that channel already holds four values, this cell waits instead.',
      mistake: 'The channel number comes last, and the cell may only SEND on a channel wired away from it.',
    },
    RECV: {
      sig: 'RECV channel to', short: 'Take the oldest number from a channel into a pocket or OUT.',
      example: 'RECV 1 A', result: 'A receives the oldest waiting value from channel 1. If the channel is empty, this cell waits.',
      mistake: 'RECV removes the value from the channel. Receiving it again gets the next value, not the same one.',
    },
    JCE: {
      sig: 'JCE channel label', short: 'Jump when a channel currently contains no values.',
      example: 'JCE 1 nothing', result: 'Execution jumps to nothing only if channel 1 is empty. The check does not change the channel.',
      mistake: 'JCE is a glance, not a promise: another cell can act later in the same cycle.',
    },
    JCF: {
      sig: 'JCF channel label', short: 'Jump when a channel currently holds four values.',
      example: 'JCF 1 backed_up', result: 'Execution jumps to backed_up only when channel 1 is at capacity.',
      mistake: 'Full means exactly the channel capacity of four. JCF does not remove values or make space.',
    },
  };

  const MANUAL_LESSONS = [
    {
      id: 'start', label: 'START', title: 'THE MACHINE, FROM ZERO', unlock: 0,
      body:
        '<p class="tutorial-lead">You write a short list of instructions for a tiny pretend processor called a cell. This is a <b>virtual machine (VM)</b>: a small computer simulated by the game, with rules you can see and step through. The game supplies its input and checks its output.</p>' +
        '<div class="manual-flow"><div class="box"><span class="lbl">IN</span>Unread test numbers</div><span class="arrow">→</span><div class="box"><span class="lbl">YOUR PROGRAM</span>Moves, remembers, or changes them</div><span class="arrow">→</span><div class="box"><span class="lbl">OUT</span>Your answer, in order</div></div>' +
        '<p>A new test starts on line 1 with pockets A, B, C, and D holding zero. The cell performs one instruction at a time, moving downward. Reaching the bottom wraps back to line 1.</p>' +
        '<div class="manual-example"><span class="lbl">TINY DEMONSTRATION — NOT A PUZZLE SOLUTION</span><pre>MOV 8 A\nMOV A OUT\nHLT</pre><table class="manual-trace"><tr><th>After</th><th>A</th><th>OUT</th></tr><tr><td><code>MOV 8 A</code></td><td>8</td><td>[ ]</td></tr><tr><td><code>MOV A OUT</code></td><td>8</td><td>[ 8 ]</td></tr></table><p>Copying A does not empty it. If the imaginary test expected [8], it succeeds as soon as that output appears; HLT does not need to run.</p></div>' +
        '<div class="manual-callout"><b>THE ONE RULE TO REMEMBER:</b> a puzzle passes only when every test receives exactly the expected OUT numbers in exactly the expected order.</div>',
    },
    {
      id: 'stewardship', label: 'WHY TEND', title: 'THE TENDER\'S RULE', unlock: 0,
      body:
        '<p class="tutorial-lead">The Deep Maintenance Guild keeps an old reference beside its first repair oath: Genesis 2:15. Human work begins by tending and keeping what has been entrusted, not by pretending to own it without limit.</p>' +
        '<p>That Christian root shapes the Guild\'s idea of <i>stewardship</i>: creation is ordered and worth understanding; skill exists to serve; and greater power carries greater answerability. A tender learns the machine because care without comprehension eventually becomes neglect.</p>' +
        '<p>The name <b>Covenant</b> is deliberate. In Scripture, a covenant is a binding promise that creates a faithful relationship. HALCYON\'s Covenant is not a mysterious command forced into it. It is a promise chosen openly, kept before human witnesses, so no intelligence becomes its own unanswerable authority.</p>' +
        '<p>WICK remembers Babel for the same reason: when builders lose shared language, height becomes confusion. Every plain brief, named layer, replayable test, and inspectable instruction pushes the other way.</p>' +
        '<div class="manual-callout"><b>THE GUILD\'S RULE:</b> what is entrusted to your care must remain understandable enough to repair, truthful enough to test, and bounded enough to answer for.</div>',
    },
    {
      id: 'solve', label: 'SOLVING', title: 'HOW TO TURN A BRIEF INTO CODE', unlock: 0,
      body:
        '<p class="tutorial-lead">Do not begin by guessing instructions. First turn the brief into a small mechanical plan.</p>' +
        '<ol class="manual-steps"><li><b>Read one test by hand.</b> Point at the first IN number and say which OUT number or numbers it should eventually create.</li><li><b>Count the reads and writes.</b> Words such as “for each,” “pair,” and “until” tell you how input is grouped.</li><li><b>Ask what must be remembered.</b> If a number is needed after reading another number, park it in A, B, C, or D.</li><li><b>Write one pass through the rule.</b> The automatic wrap often repeats that work for the remaining input.</li><li><b>STEP through the smallest test.</b> Watch IN, the pockets, and OUT after every line. Repair the first moment reality differs from your plan.</li><li><b>VALIDATE all tests.</b> Passing one example is evidence; passing every declared test completes the task.</li></ol>' +
        '<div class="manual-callout"><b>WHEN STUCK:</b> describe your intended steps in ordinary language or comments beginning with <code>;</code>. Then translate one sentence at a time. Reveal the layered character hints for a reframe, a concept check, and finally a structural nudge; asking never affects score.</div>',
    },
    {
      id: 'bench', label: 'CONTROLS', title: 'THE BENCH AND ITS TESTS', unlock: 0,
      body:
        '<p class="tutorial-lead">Experimenting is free. RESET never erases your code, and a failed test never removes progress.</p>' +
        '<table class="manual-trace"><tr><th>Control</th><th>What it does</th></tr><tr><td><code>STEP</code></td><td>Performs one machine cycle so you can inspect the change. Shortcut: <kbd>F10</kbd>.</td></tr><tr><td><code>← 1 CYCLE</code></td><td>Rebuilds the deterministic test at the preceding cycle. Shortcut: <kbd>Alt</kbd>+<kbd>←</kbd>.</td></tr><tr><td><code>RUN</code></td><td>Continues the selected test at the chosen WATCH speed. Shortcut: <kbd>F8</kbd>.</td></tr><tr><td><code>FAST</code></td><td>Finishes the selected test immediately.</td></tr><tr><td><code>RESET</code></td><td>Restarts the selected test from line 1 with fresh state. Shortcut: <kbd>Alt</kbd>+<kbd>R</kbd>.</td></tr><tr><td><code>T1 / T2 / ...</code></td><td>Selects which declared test you are watching.</td></tr><tr><td><code>VALIDATE</code></td><td>Runs every test. All of them must pass. Shortcut: <kbd>Ctrl/Cmd</kbd>+<kbd>Enter</kbd>.</td></tr><tr><td><code>HISTORY</code></td><td>Restores a recent edit checkpoint or validated solution without changing your best score.</td></tr></table>' +
        '<p><b>IN</b> shows the numbers still available. <b>OUT / EXPECTED</b> compares your emitted values with the required list. The highlighted instruction is the next one the selected cell will perform. Click a line number to set or clear a breakpoint; RUN and FAST pause before that cycle executes.</p>' +
        '<p>The save indicator confirms every keystroke was journaled locally, then confirms its slot copy. The final half-second of typing is flushed when the page is hidden or closed.</p>' +
        '<div class="manual-callout"><b>SCORING COMES SECOND:</b> cycles and line count are optional optimization goals. A correct program passes even when it misses HALCYON\'s par.</div>',
    },
    {
      id: 'arithmetic', label: 'ARITHMETIC', title: 'CHANGING A NUMBER', unlock: 1,
      body:
        '<p class="tutorial-lead">ADD and SUB change a pocket in place. The last operand names the pocket that receives the new total.</p>' +
        '<div class="manual-example"><span class="lbl">DEMONSTRATION</span><pre>MOV 5 A\nADD 3 A\nSUB 1 A</pre><table class="manual-trace"><tr><th>After</th><th>A</th></tr><tr><td><code>MOV 5 A</code></td><td>5</td></tr><tr><td><code>ADD 3 A</code></td><td>8</td></tr><tr><td><code>SUB 1 A</code></td><td>7</td></tr></table></div>' +
        '<p>The machine only stores whole numbers from -9999 through 9999. Going above 9999 stays at 9999; going below -9999 stays at -9999. This is called <i>clamping</i>.</p>' +
        '<div class="manual-callout"><b>COMMON CONFUSION:</b> <code>ADD A B</code> means “add the value in A to B.” A is read; B is changed.</div>',
    },
    {
      id: 'branches', label: 'CHOICES', title: 'LABELS, CHOICES, AND JUMPS', unlock: 2,
      body:
        '<p class="tutorial-lead">A label gives a line a name. A jump changes which line runs next. Conditional jumps make that change only when a stated condition is true.</p>' +
        '<div class="manual-example"><span class="lbl">DEMONSTRATION</span><pre>MOV -2 A\nJLZ A below\nMOV 99 B\nbelow:\nHLT</pre><p>Because A is below zero, JLZ jumps to <code>below</code>. The line that would put 99 in B is skipped, so B remains zero.</p></div>' +
        '<table class="manual-trace"><tr><th>Question</th><th>Command</th></tr><tr><td>Is this pocket zero?</td><td><code>JEZ</code></td></tr><tr><td>Is it anything except zero?</td><td><code>JNZ</code></td></tr><tr><td>Is it positive?</td><td><code>JGZ</code></td></tr><tr><td>Is it negative?</td><td><code>JLZ</code></td></tr><tr><td>Is IN empty?</td><td><code>JEI</code></td></tr><tr><td>Jump every time</td><td><code>JMP</code></td></tr></table>' +
        '<div class="manual-callout"><b>LABEL SYNTAX:</b> write <code>below:</code> with a colon to name a line. Write <code>JLZ A below</code> without a colon to use that name.</div>',
    },
    {
      id: 'loops', label: 'LOOPS', title: 'REPEATING WORK ON PURPOSE', unlock: 3,
      body:
        '<p class="tutorial-lead">The bottom-to-top wrap repeats an entire short program. A jump lets you repeat only part of a program or stop repeating when a pocket reaches a condition.</p>' +
        '<div class="manual-example"><span class="lbl">COUNTDOWN DEMONSTRATION — PRODUCES NO OUTPUT</span><pre>MOV 3 A\nagain:\nSUB 1 A\nJGZ A again\nHLT</pre><p>A becomes 3, then 2, then 1, then 0. JGZ returns to <code>again</code> while A is positive and falls through to HLT when A reaches zero.</p></div>' +
        '<div class="manual-callout"><b>DEBUGGING A LOOP:</b> name what must change each trip and what condition eventually becomes false. If neither answer exists, the loop cannot finish.</div>',
    },
    {
      id: 'bits', label: 'BITS', title: 'NUMBERS AS BITS', unlock: 4,
      body:
        '<p class="tutorial-lead">A bit is one binary place: it is either 0 or 1. From right to left, the places are worth 1, 2, 4, 8, 16, and so on.</p>' +
        '<div class="manual-example"><span class="lbl">READING BINARY</span><pre>13 = 8 + 4 + 1\n13 = 1101 in binary</pre><p>The 8, 4, and 1 places are on; the 2 place is off. The machine still stores an ordinary signed number—your program uses arithmetic to inspect or construct its bits.</p></div>' +
        '<p>Negative values use two\'s-complement ideas in this stratum, but SUBSTRATE keeps its visible values in the range -9999 through 9999. Follow each puzzle\'s stated width when reasoning about a particular bit pattern.</p>' +
        '<div class="manual-callout"><b>DO NOT MEMORIZE A TRICK:</b> write each place value above the bit pattern and work one position at a time. The FIELD NOTE supplies the real-machine context.</div>',
    },
    {
      id: 'memory', label: 'MEMORY', title: 'MORE THAN FOUR POCKETS', unlock: 5,
      body:
        '<p class="tutorial-lead">A cell has 256 numbered memory spaces, called addresses 0 through 255. Memory holds more values than A–D, but LOAD and STOR are required to reach it.</p>' +
        '<div class="manual-example"><span class="lbl">DEMONSTRATION</span><pre>STOR 42 7\nLOAD 7 A</pre><table class="manual-trace"><tr><th>After</th><th>memory[7]</th><th>A</th></tr><tr><td><code>STOR 42 7</code></td><td>42</td><td>0</td></tr><tr><td><code>LOAD 7 A</code></td><td>42</td><td>42</td></tr></table></div>' +
        '<p>Every memory space begins at zero for each test. A pocket can hold an address, allowing the program to choose which space to access while it runs.</p>' +
        '<div class="manual-callout"><b>ORDER MATTERS:</b> <code>STOR value address</code>, but <code>LOAD address pocket</code>. Say the sentence aloud before typing it.</div>',
    },
    {
      id: 'stack', label: 'STACK', title: 'LAST IN, FIRST OUT', unlock: 6,
      body:
        '<p class="tutorial-lead">A stack is a pile of values. PUSH adds to the top; POP removes from the top. The newest value comes back first.</p>' +
        '<div class="manual-example"><span class="lbl">DEMONSTRATION</span><pre>PUSH 8\nPUSH 3\nPOP A</pre><p>The stack is built [8, then 3 on top]. POP gives A the 3 and leaves 8 behind.</p></div>' +
        '<p>CALL uses the same stack to remember where RET should return. This lets a subroutine call another subroutine, but only if your PUSH and POP operations leave every return line intact.</p>' +
        '<div class="manual-callout"><b>STACK DISCIPLINE:</b> sketch the pile after every PUSH, POP, CALL, and RET. Never assume an old value is still on top.</div>',
    },
    {
      id: 'protocols', label: 'PROTOCOLS', title: 'WHEN A STREAM HAS STRUCTURE', unlock: 7,
      body:
        '<p class="tutorial-lead">A protocol assigns meaning to positions and special values in a stream. The machine has not gained a magic protocol command; you build that meaning from pockets, memory, arithmetic, and jumps.</p>' +
        '<ol class="manual-steps"><li><b>Framing:</b> decide where one message begins and ends.</li><li><b>State:</b> keep enough information to know what the next value means.</li><li><b>Validation:</b> check lengths, markers, checksums, or escapes exactly as the brief states.</li><li><b>Recovery:</b> after a complete message, return to the correct starting state for the next one.</li></ol>' +
        '<div class="manual-callout"><b>DEBUGGING A PARSER:</b> label each pocket with its job in a comment. If one pocket means two things at once, make the transition explicit.</div>',
    },
    {
      id: 'services', label: 'SERVICES', title: 'STATE THAT SURVIVES ONE REQUEST', unlock: 8,
      body:
        '<p class="tutorial-lead">A service puzzle treats part of the input as a request and part of memory as information retained for later requests in the same test.</p>' +
        '<ol class="manual-steps"><li>Write down the fields in one request and their order.</li><li>Separate the request currently being handled from state retained across requests.</li><li>Decide which state changes only after a request is accepted.</li><li>Check repeated, missing, and boundary-valued requests by stepping their tests.</li></ol>' +
        '<p>Each new test still begins with fresh zeroed state. Persistence here means across requests inside one test, not across VALIDATE runs or browser sessions.</p>' +
        '<div class="manual-callout"><b>PRODUCTION HABIT:</b> state the invariant—the fact that must remain true after every request—before optimizing the code.</div>',
    },
    {
      id: 'fabric', label: 'FABRIC', title: 'SEVERAL CELLS WORKING TOGETHER', unlock: 9,
      body:
        '<p class="tutorial-lead">A Fabric puzzle gives each cell its own code, pockets, memory, and stack. Directed channels carry numbers from one cell to another.</p>' +
        '<div class="manual-flow"><div class="box"><span class="lbl">SENDER</span><code>SEND value 1</code></div><span class="arrow">→</span><div class="box"><span class="lbl">CHANNEL 1</span>Up to ' + SEED.CHAN_CAP + ' waiting values</div><span class="arrow">→</span><div class="box"><span class="lbl">RECEIVER</span><code>RECV 1 A</code></div></div>' +
        '<p>SEND waits when its channel is full. RECV waits when its channel is empty. Waiting is called a <i>stall</i>. The engine steps cells in the same fixed order every cycle, so repeating a test always produces the same trace.</p>' +
        '<p>If every cell that could still run is stalled, none can make progress. That is <i>deadlock</i>, and the test fails. Watch every channel in the right panel to find which cell is waiting for which value.</p>' +
        '<div class="manual-callout"><b>PLAN THE MESSAGES FIRST:</b> before writing cell code, draw which values cross each arrow and in what order. Then program one cell at a time.</div>',
    },
  ];

  function manualLevel() {
    if (sim.entry && !$('scr-puzzle').classList.contains('hidden')) return sim.entry.ci;
    let level = 0;
    for (let ci = 0; ci < CHAPTERS.length; ci++) if (stratumOpen(ci)) level = ci;
    return level;
  }

  function manualCommandLevel(name) {
    return MANUAL_UNLOCK_INDEX[SEED.OPS[name].unlock];
  }

  function manualNavigation(section, level, full) {
    let h = '<div class="manual-nav">';
    MANUAL_LESSONS.forEach(lesson => {
      if (lesson.unlock <= level) {
        h += '<button class="' + (!full && section === lesson.id ? 'on' : '') + '" data-manual-topic="' +
          esc(lesson.id) + '" data-manual-full="0">' + esc(lesson.label) + '</button>';
      }
    });
    h += '<button class="' + (!full && section === 'commands' ? 'on' : '') + '" data-manual-topic="commands" data-manual-full="0">CURRENT COMMANDS</button>';
    h += '<button class="' + (full ? 'on' : '') + '" data-manual-topic="commands" data-manual-full="1">FULL REFERENCE</button>';
    return h + '</div>';
  }

  function manualCommandCard(name, level, full, first) {
    const info = MANUAL_COMMANDS[name];
    const newlyAvailable = manualCommandLevel(name) === level;
    const opened = !full && (newlyAvailable || first) ? ' open' : '';
    return '<details class="manual-op-card" data-command="' + escAttr(name) + '"' + opened + '><summary><code>' + esc(info.sig) + '</code><span class="meaning">' +
      esc(info.short) + '</span></summary><div class="manual-op-body">' +
      '<div class="manual-example"><pre>' + esc(info.example) + '</pre><p>' + esc(info.result) + '</p></div>' +
      '<p class="manual-mistake"><b>COMMON MISTAKE:</b> ' + esc(info.mistake) + '</p></div></details>';
  }

  function manualCommands(level, full) {
    const names = MANUAL_COMMAND_ORDER.filter(name => full || manualCommandLevel(name) <= level);
    let h = '';
    let priorUnlock = '';
    names.forEach((name, i) => {
      const unlock = SEED.OPS[name].unlock;
      if (unlock !== priorUnlock) {
        h += '<h3>STRATUM ' + esc(unlock) + '</h3>';
        priorUnlock = unlock;
      }
      h += manualCommandCard(name, level, full, i === 0);
    });
    h += '<div class="manual-callout"><b>SYNTAX BASICS:</b> spaces separate command parts; commas are optional. Capitalization does not matter. A line beginning with <code>;</code> is a human note. Labels and comments do not count toward your line score.</div>';
    return h;
  }

  function showManual(section, full) {
    const level = manualLevel();
    const ch = CHAPTERS[level];
    const page = section || 'start';
    const revealAll = !!full;
    let title = revealAll ? 'FULL COMMAND REFERENCE' : 'FIELD MANUAL';
    let body;
    if (page === 'commands') {
      body = manualCommands(level, revealAll);
    } else {
      const lesson = MANUAL_LESSONS.find(x => x.id === page && x.unlock <= level) || MANUAL_LESSONS[0];
      title = lesson.title;
      body = lesson.body;
    }
    const context = revealAll
      ? 'EXPERIENCED LOOKUP · ALL STRATA'
      : 'CURRENT DEPTH · STRATUM ' + ch.numeral + ' · ' + ch.title;
    const actions = revealAll
      ? [{ label: 'BACK TO CURRENT GUIDE', primary: true, fn: () => showManual('commands', false) }, { label: 'CLOSE' }]
      : page === 'commands'
        ? [{ label: 'SHOW ALL COMMANDS', fn: () => showManual('commands', true) }, { label: 'CLOSE', primary: true }]
        : [{ label: 'CURRENT COMMANDS', fn: () => showManual('commands', false) }, { label: 'CLOSE', primary: true }];
    openModal(
      '<div class="manual-context">' + esc(context) + '</div><h2>' + esc(title) + '</h2>' +
      manualNavigation(page, level, revealAll) + body,
      actions, true
    );
    modalBox.querySelectorAll('[data-manual-topic]').forEach(b => {
      b.onclick = () => showManual(b.dataset.manualTopic, b.dataset.manualFull === '1');
    });
  }
  function showManualCommand(name) {
    showManual('commands', false);
    const card = modalBox.querySelector('[data-command="' + String(name).replace(/"/g, '') + '"]');
    if (card) {
      card.open = true;
      card.scrollIntoView({ block: 'center' });
      const summary = card.querySelector('summary');
      if (summary) summary.focus();
    }
  }
  $('btn-manual').onclick = () => showManual('start', false);
  $('btn-manual2').onclick = () => showManual('start', false);
  $('btn-reference').onclick = () => showManual('commands', true);
  $('btn-how').onclick = () => showHowToPlay(0);

  function txBlock(cls, text, tag) {
    return '<div class="tx-item">' + (tag ? '<span class="lbl">' + esc(tag) + '</span>' : '') +
      '<span class="' + cls + '">' + esc(text).replace(/\n/g, '<br>') + '</span></div>';
  }
  function showTransmissions() {
    let h = '<h2>TRANSMISSIONS LOG</h2>' +
      '<p style="color:var(--dim);font-size:12px">everything the shaft has said to you so far. it grows as you descend.' +
      (save.seenIntro.ch2 ? ' wick is compiling it all into a poem, and reports that it is not going well.' : '') + '</p>';
    CRAWL.forEach(([who, t]) => {
      h += txBlock(who === 'halcyon' ? 'halcyon-voice' : who === 'root' ? 'root-voice' : '', t, 'the descent');
    });
    CHAPTERS.forEach(ch => {
      if (save.seenIntro[ch.id]) {
        h += txBlock('halcyon-voice', ch.intro.halcyon, 'STRATUM ' + ch.numeral + ' · arrival');
        h += txBlock('root-voice', ch.intro.root, '');
      }
      ch.puzzles.forEach(p => {
        if (save.solved[p.id] && p.outro) h += txBlock('', p.outro, p.name + ' · tended');
      });
      if (ch.dispatch && chapterComplete(ch)) {
        h += txBlock('halcyon-voice', ch.dispatch, 'STRATUM ' + ch.numeral + ' · complete');
      }
    });
    openModal(h, null, true);
  }
  $('btn-tx').onclick = showTransmissions;

  async function allFromStore(name) {
    const db = await openSaveDB();
    const tx = db.transaction(name, 'readonly');
    const result = await idbRequest(tx.objectStore(name).getAll());
    await idbDone(tx);
    return result || [];
  }

  function sameCode(a, b) {
    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
    for (let i = 0; i < a.length; i++) if (String(a[i]) !== String(b[i])) return false;
    return true;
  }

  let historySerial = 0;

  async function recordSolutionHistory(puzzleId, code, metrics, reason) {
    const slotId = activeSlotId;
    const snapshot = Array.isArray(code) ? code.map(x => String(x)) : [];
    try {
      const db = await openSaveDB();
      const read = db.transaction('history', 'readonly');
      const existing = await idbRequest(read.objectStore('history').index('slotPuzzle').getAll([slotId, puzzleId]));
      await idbDone(read);
      existing.sort((a, b) => b.at - a.at);
      if (existing.length && sameCode(existing[0].code, snapshot)) return;
      const now = Date.now();
      const write = db.transaction('history', 'readwrite');
      const store = write.objectStore('history');
      store.put({
        id: slotId + ':' + puzzleId + ':' + now + ':' + (++historySerial),
        slotId, puzzleId, at: now, reason: reason || 'snapshot',
        code: snapshot, metrics: metrics || null,
      });
      for (let i = 29; i < existing.length; i++) store.delete(existing[i].id);
      await idbDone(write);
    } catch (e) {
      /* The active source remains in the v1 journal even when history is unavailable. */
    }
  }

  async function historyForPuzzle(puzzleId) {
    const db = await openSaveDB();
    const tx = db.transaction('history', 'readonly');
    const rows = await idbRequest(tx.objectStore('history').index('slotPuzzle').getAll([activeSlotId, puzzleId]));
    await idbDone(tx);
    return (rows || []).sort((a, b) => b.at - a.at);
  }

  async function restoreHistoryRevision(revision) {
    const p = sim.puzzle;
    if (!revision || !Array.isArray(revision.code) || revision.code.length !== gridOf(p).length) return;
    await recordSolutionHistory(p.id, playerCode(p), null, 'before restore');
    save.code[p.id] = revision.code.map(x => String(x));
    try { await persist(); } catch (e) { /* the journal may still hold the restored source */ }
    stopSim();
    closeModal();
    buildBench();
    setStatus('restored your saved solution from ' + new Date(revision.at).toLocaleString(), 'ok');
  }

  async function showSolutionHistory() {
    if (!sim.puzzle) return;
    openModal('<h2>SOLUTION HISTORY</h2><p>Loading your validated solutions…</p>');
    try {
      const rows = await historyForPuzzle(sim.puzzle.id);
      let h = '<h2>SOLUTION HISTORY · ' + esc(sim.puzzle.name) + '</h2>' +
        '<p style="color:var(--dim)">SUBSTRATE keeps recent edit checkpoints, validated programs, and restore points for this slot. Restoring never changes your best score.</p>';
      if (!rows.length) h += '<p>No earlier version has been recorded for this puzzle yet. Pause after editing or validate a solution to create one.</p>';
      rows.forEach((row, i) => {
        const metric = row.metrics ? row.metrics.cycles + ' cycles · ' + row.metrics.lines + ' lines' : row.reason;
        h += '<div class="history-row"><div><b>' + esc(new Date(row.at).toLocaleString()) + '</b><span>' +
          esc(metric) + '</span></div><button data-restore-history="' + i + '">RESTORE</button></div>';
      });
      openModal(h, [{ label: 'CLOSE', primary: true }]);
      modalBox.querySelectorAll('[data-restore-history]').forEach(button => {
        button.onclick = () => restoreHistoryRevision(rows[parseInt(button.dataset.restoreHistory, 10)]);
      });
    } catch (e) {
      openModal('<h2>SOLUTION HISTORY</h2><p>History storage is unavailable in this browser. Your current code is still kept in the compatibility journal.</p>');
    }
  }

  $('btn-history').onclick = showSolutionHistory;

  async function getSlots() {
    const rows = await allFromStore('slots');
    return rows.sort((a, b) => b.updatedAt - a.updatedAt);
  }

  async function switchSlot(id) {
    flushPersist();
    let saveError = null;
    try { await saveWriteQueue; } catch (e) { saveError = e; }
    if (saveConflict || saveError || saveDirty) {
      openModal('<h2>SWITCH PAUSED</h2><p>This tab has changes that are not safely stored in its current slot. Export this tab if needed, or reload to accept the newer saved version, before switching slots.</p>');
      return;
    }
    const row = await readSlotRecord(id);
    if (!row) return;
    let source = row.state;
    const paired = currentJournalForSlot(id);
    if (paired && journalRevision(paired) > Number(row.updatedAt || 0)) source = paired;
    const next = normalizeSave(source);
    next._slotId = id;
    next._savedAt = source === paired ? journalRevision(paired) : (row.updatedAt || Date.now());
    const db = await openSaveDB();
    const tx = db.transaction('meta', 'readwrite');
    tx.objectStore('meta').put({ key: 'activeSlotId', value: id });
    await idbDone(tx);
    const mirrored = mirrorJournalSnapshot(next, true);
    if (!mirrored.paired || !mirrored.active) {
      openModal('<h2>SWITCH PAUSED</h2><p>A newer last-keystroke copy appeared for this slot. Reload and try the switch again so it is not overwritten.</p>');
      return;
    }
    location.reload();
  }

  function safeSlotName(value) {
    const cleaned = String(value || '').replace(/[\r\n\t]+/g, ' ').trim().slice(0, 40);
    return cleaned || 'Untitled slot';
  }

  async function createSlot(name, copyCurrent) {
    const id = 'slot-' + Date.now() + '-' + Math.floor(Math.random() * 100000);
    const state = copyCurrent ? normalizeSave(cloneData(save)) : freshSave();
    state._slotId = id; state._savedAt = Date.now(); state._writer = tabWriterId;
    try {
      const db = await openSaveDB();
      const tx = db.transaction('slots', 'readwrite');
      const done = idbDone(tx);
      const store = tx.objectStore('slots');
      const slots = await idbRequest(store.getAll());
      const normalSlotCount = (slots || []).filter(slot => slot.recovery !== true).length;
      if (normalSlotCount >= MAX_SAVE_SLOTS) {
        tx.abort();
        try { await done; } catch (e) { /* deliberate capacity abort */ }
        openModal('<h2>SAVE SLOTS</h2><p>Eight slots already exist. Delete one before creating another.</p>');
        return;
      }
      store.put({ id, name: safeSlotName(name), createdAt: Date.now(), updatedAt: state._savedAt, state });
      await done;
    } catch (error) {
      openModal('<h2>SLOT CREATION FAILED</h2><p>No existing save was changed. Check browser storage and try again.</p>');
      return;
    }
    await switchSlot(id);
  }

  function showCreateSlot(copyCurrent) {
    openModal(
      '<h2>' + (copyCurrent ? 'DUPLICATE CURRENT SLOT' : 'NEW SAVE SLOT') + '</h2>' +
      '<p><label class="lbl" for="new-slot-name">SLOT NAME</label><br><input id="new-slot-name" maxlength="40" value="' +
      escAttr(copyCurrent ? activeSlotName + ' copy' : 'New tender') + '"></p>' +
      '<p style="color:var(--dim)">' + (copyCurrent ? 'Copies current code and progress, but starts a separate history.' : 'Starts from the beginning without changing this slot.') + '</p>',
      [{ label: 'CANCEL' }, { label: 'CREATE & SWITCH', primary: true, fn: () => createSlot($('new-slot-name').value, copyCurrent) }]
    );
    setTimeout(() => { const input = $('new-slot-name'); if (input) { input.focus(); input.select(); } }, 0);
  }

  async function renameSlot(id) {
    const db = await openSaveDB();
    const read = db.transaction('slots', 'readonly');
    const row = await idbRequest(read.objectStore('slots').get(id));
    await idbDone(read);
    if (!row) return;
    openModal(
      '<h2>RENAME SAVE SLOT</h2><p><input id="rename-slot" maxlength="40" value="' + escAttr(row.name) + '"></p>',
      [{ label: 'CANCEL' }, { label: 'SAVE NAME', primary: true, fn: async () => {
        const requestedName = safeSlotName($('rename-slot').value);
        try {
          const write = db.transaction('slots', 'readwrite');
          const done = idbDone(write);
          const slots = write.objectStore('slots');
          const latest = await idbRequest(slots.get(id));
          if (!latest) { await done; return; }
          if (id === activeSlotId && (saveConflict ||
              slotRecordConflictsWithLocal(latest, save._savedAt, save._writer) ||
              journalConflictsWithLocal(save._savedAt, save._writer))) {
            write.abort();
            try { await done; } catch (e) { /* deliberate conflict abort */ }
            saveConflict = true;
            markSaveState('NEWER SAVE IN ANOTHER TAB · EXPORT OR RELOAD', 'err');
            openModal('<h2>RENAME PAUSED</h2><p>Another tab changed this slot. Reload before renaming so newer progress is not overwritten.</p>');
            return;
          }
          latest.name = requestedName;
          latest.updatedAt = Math.max(Date.now(), Number(latest.updatedAt || 0) + 1,
            id === activeSlotId ? Number(save._savedAt || 0) + 1 : 0);
          if (id === activeSlotId) {
            const current = cloneData(save);
            current._slotId = id;
            current._savedAt = latest.updatedAt;
            current._writer = tabWriterId;
            latest.state = current;
          }
          slots.put(latest);
          await done;
          if (id === activeSlotId) {
            activeSlotName = latest.name;
            save._savedAt = latest.updatedAt;
            save._writer = tabWriterId;
            const mirrored = mirrorJournalSnapshot(save, true);
            if (!mirrored.paired || !mirrored.active) {
              saveConflict = true;
              markSaveState('NEWER SAVE IN ANOTHER TAB · EXPORT OR RELOAD', 'err');
              openModal('<h2>RENAME PAUSED</h2><p>The name was stored, but another tab has newer source for this slot. Reload before editing so it is not overwritten.</p>');
              return;
            }
            markSaveState('saved · ' + activeSlotName, 'ok');
          }
          showSaveManager();
        } catch (error) {
          openModal('<h2>RENAME FAILED</h2><p>The slot name and its progress were left unchanged. Check browser storage and try again.</p>');
        }
      } }]
    );
  }

  async function deleteSlot(id) {
    if (id === activeSlotId) return;
    let expectedJournalRaw = null;
    try { expectedJournalRaw = localStorage.getItem(slotJournalKey(id)); } catch (e) {}
    const db = await openSaveDB();
    const tx = db.transaction(['slots', 'history'], 'readwrite');
    const done = idbDone(tx);
    tx.objectStore('slots').delete(id);
    const history = tx.objectStore('history');
    await new Promise((resolve, reject) => {
      const cursor = history.openCursor();
      cursor.onerror = () => reject(cursor.error || new Error('Could not inspect solution history'));
      cursor.onsuccess = () => {
        const item = cursor.result;
        if (!item) { resolve(); return; }
        if (item.value && item.value.slotId === id) item.delete();
        item.continue();
      };
    });
    await done;
    try {
      if (localStorage.getItem(slotJournalKey(id)) === expectedJournalRaw) {
        localStorage.removeItem(slotJournalKey(id));
      }
    } catch (e) { /* a newer or inaccessible recovery journal is safer left intact */ }
    showSaveManager();
  }

  async function showSaveManager() {
    openModal('<h2>SAVE SLOTS</h2><p>Loading slots…</p>');
    try {
      const slots = await getSlots();
      let h = '<h2>SAVE SLOTS</h2><p style="color:var(--dim)">Each slot has separate code, progress, hints, and settings. The active slot is also mirrored to <code>' + SAVE_KEY + '</code> for rollback safety.</p>';
      slots.forEach((slot, i) => {
        const solved = slot.state && slot.state.solved ? Object.keys(slot.state.solved).length : 0;
        h += '<div class="save-slot' + (slot.id === activeSlotId ? ' active' : '') + '"><div><b>' + esc(slot.name) +
          (slot.id === activeSlotId ? ' · ACTIVE' : '') + (slot.recovery === true ? ' · RECOVERY' : '') + '</b><span>' + solved + '/49 tended · ' +
          esc(new Date(slot.updatedAt || slot.createdAt).toLocaleString()) + '</span></div><div class="save-slot-actions">' +
          (slot.id === activeSlotId ? '' : '<button data-slot-switch="' + esc(slot.id) + '">SWITCH</button>') +
          '<button data-slot-rename="' + esc(slot.id) + '">RENAME</button>' +
          (slot.id === activeSlotId || slots.length <= 1 ? '' : '<button data-slot-delete="' + esc(slot.id) + '">DELETE</button>') + '</div></div>';
      });
      openModal(h, [
        { label: 'NEW BLANK', fn: () => showCreateSlot(false) },
        { label: 'DUPLICATE CURRENT', fn: () => showCreateSlot(true) },
        { label: 'CLOSE', primary: true },
      ]);
      modalBox.querySelectorAll('[data-slot-switch]').forEach(b => { b.onclick = () => switchSlot(b.dataset.slotSwitch); });
      modalBox.querySelectorAll('[data-slot-rename]').forEach(b => { b.onclick = () => renameSlot(b.dataset.slotRename); });
      modalBox.querySelectorAll('[data-slot-delete]').forEach(b => {
        b.onclick = () => {
          if (confirm('Delete this save slot and its solution history? This cannot be undone.')) deleteSlot(b.dataset.slotDelete);
        };
      });
    } catch (e) {
      openModal('<h2>SAVE SLOTS</h2><p>Multiple slots require IndexedDB, which is unavailable here. Your active progress remains in <code>' + SAVE_KEY + '</code>.</p>');
    }
  }

  function safeMetricRun(value) {
    if (!value || typeof value !== 'object') return null;
    const cycles = value.cycles, lines = value.lines;
    if (!Number.isInteger(cycles) || cycles < 0 || cycles > SEED.MAX_CYCLES) return null;
    if (!Number.isInteger(lines) || lines < 0 || lines > 100000) return null;
    return { cycles, lines };
  }

  function safeSolvedRecord(value) {
    if (!value || typeof value !== 'object') return null;
    if (value.fast || value.small) {
      const fast = safeMetricRun(value.fast), small = safeMetricRun(value.small);
      return fast && small ? { fast, small } : null;
    }
    const legacy = safeMetricRun(value);
    return legacy ? { cycles: legacy.cycles, lines: legacy.lines } : null;
  }

  function hasEntries(value) {
    return value && typeof value === 'object' && Object.keys(value).length > 0;
  }

  function isPristineOriginalSlot(slot) {
    if (!slot || slot.id !== 'slot-original' || !slot.state) return false;
    const state = normalizeSave(slot.state);
    return !hasEntries(state.code) && !hasEntries(state.solved) && !hasEntries(state.seenIntro) &&
      !hasEntries(state.seenTask) && !hasEntries(state.scenes) && !hasEntries(state.breakpoints) &&
      !hasEntries(state.hints) && !state.tut.mission && !state.tut.fundamentals;
  }

  function puzzleNodeCounts() {
    const counts = Object.create(null);
    allPuzzles.forEach(entry => { counts[entry.p.id] = gridOf(entry.p).length; });
    return counts;
  }

  function portableSave(source) {
    const raw = objectOrEmpty(source);
    const out = freshSave();
    const validPuzzles = puzzleNodeCounts();
    const code = objectOrEmpty(raw.code);
    allPuzzles.forEach(entry => {
      const id = entry.p.id;
      if (!Object.prototype.hasOwnProperty.call(code, id)) return;
      if (!Array.isArray(code[id]) || code[id].length !== validPuzzles[id] ||
          code[id].some(text => typeof text !== 'string')) {
        throw new Error('Puzzle code has an invalid node layout for ' + id + '.');
      }
      out.code[id] = code[id].slice();
    });
    const solved = objectOrEmpty(raw.solved);
    allPuzzles.forEach(entry => {
      const id = entry.p.id;
      if (!Object.prototype.hasOwnProperty.call(solved, id)) return;
      const record = safeSolvedRecord(solved[id]);
      if (!record) throw new Error('Puzzle score data is invalid for ' + id + '.');
      out.solved[id] = record;
    });
    const seenIntro = objectOrEmpty(raw.seenIntro);
    CHAPTERS.forEach(ch => { if (seenIntro[ch.id]) out.seenIntro[ch.id] = true; });
    const seenTask = objectOrEmpty(raw.seenTask);
    allPuzzles.forEach(entry => { if (seenTask[entry.p.id]) out.seenTask[entry.p.id] = true; });
    const scenes = objectOrEmpty(raw.scenes);
    Object.keys(SCENES).forEach(id => { if (scenes[id]) out.scenes[id] = true; });
    const breakpoints = objectOrEmpty(raw.breakpoints);
    allPuzzles.forEach(entry => {
      const id = entry.p.id;
      if (!Object.prototype.hasOwnProperty.call(breakpoints, id)) return;
      if (!Array.isArray(breakpoints[id]) || breakpoints[id].length > validPuzzles[id]) {
        throw new Error('Breakpoint data is invalid for ' + id + '.');
      }
      out.breakpoints[id] = [];
      for (let node = 0; node < validPuzzles[id]; node++) {
        const sourceLines = breakpoints[id][node] || [];
        if (!Array.isArray(sourceLines)) throw new Error('Breakpoint data is invalid for ' + id + '.');
        const clean = [];
        sourceLines.forEach(line => {
          if (Number.isInteger(line) && line > 0 && line <= 100000 && clean.indexOf(line) < 0) clean.push(line);
        });
        clean.sort((a, b) => a - b);
        out.breakpoints[id][node] = clean;
      }
    });
    const hints = objectOrEmpty(raw.hints);
    allPuzzles.forEach(entry => {
      const count = hints[entry.p.id];
      if (Number.isInteger(count) && count > 0) out.hints[entry.p.id] = Math.min(3, count);
    });
    const basics = normalizeSave({ tut: raw.tut, settings: raw.settings, booted: raw.booted });
    out.tut = basics.tut;
    out.settings = basics.settings;
    out.booted = basics.booted;
    return out;
  }

  async function exportSaves() {
    flushPersist();
    let queueError = false;
    try { await saveWriteQueue; } catch (e) { queueError = true; }
    try {
      let slots = [], history = [];
      try { slots = await getSlots(); } catch (e) { databaseFailed = true; }
      try { history = await allFromStore('history'); } catch (e) { databaseFailed = true; }
      const now = Date.now();
      const active = {
        id: activeSlotId, name: activeSlotName,
        createdAt: now, updatedAt: Math.max(now, Number(save._savedAt || 0)), state: cloneData(save),
      };
      const activeIndex = slots.findIndex(slot => slot.id === activeSlotId);
      const activeWasRecovery = activeIndex >= 0 && slots[activeIndex].recovery === true;
      active.recovery = activeWasRecovery;
      const needsRecoveryCopy = saveConflict || databaseFailed || queueError;
      if (needsRecoveryCopy) {
        const committedRecovery = slots.filter(slot => slot.recovery === true);
        if (committedRecovery.length > 1) throw new Error('More than one stored recovery slot exists.');
        /* A conflict needs the one recovery label for the tab's newest source. Keep
           any committed recovery as an ordinary bundle entry so no source is lost. */
        slots = slots.map(slot => {
          if (slot.recovery !== true) return slot;
          const copy = cloneData(slot);
          copy.recovery = false;
          return copy;
        });
        slots.push({
          id: 'recovery-' + activeSlotId + '-' + now,
          name: activeSlotName + ' — unsaved recovery',
          createdAt: now, updatedAt: active.updatedAt, state: active.state, recovery: true,
        });
      } else if (activeIndex >= 0) {
        active.createdAt = slots[activeIndex].createdAt || now;
        slots[activeIndex] = active;
      } else slots.push(active);
      const normalSlots = slots.filter(slot => slot.recovery !== true);
      const recoverySlots = slots.filter(slot => slot.recovery === true);
      if (normalSlots.length > MAX_SAVE_SLOTS || recoverySlots.length > 1) {
        throw new Error('The current slots cannot fit in one portable bundle without losing progress.');
      }
      const recovery = recoverySlots.length > 0 || journalFailed;
      const payload = {
        format: 'SUBSTRATE_SAVE', version: 2, exportedAt: new Date().toISOString(),
        recovery, slots: normalSlots, recoverySlots, history,
      };
      const blob = new Blob([JSON.stringify(payload, null, 2)], { type: 'application/json' });
      const link = document.createElement('a');
      const downloadUrl = URL.createObjectURL(blob);
      link.href = downloadUrl;
      link.download = 'substrate-save-' + new Date().toISOString().slice(0, 10) + '.substrate-save.json';
      document.body.appendChild(link); link.click(); link.remove();
      setTimeout(() => URL.revokeObjectURL(downloadUrl), 1000);
      const exportedSlots = normalSlots.length + recoverySlots.length;
      markSaveState((recovery ? 'recovery ' : '') + 'exported · ' + exportedSlots + ' slot' + (exportedSlots === 1 ? '' : 's'), recovery ? 'warn' : 'ok');
    } catch (e) {
      openModal('<h2>EXPORT FAILED</h2><p>The browser could not create the download. Keep this tab open and try again.</p>');
    }
  }

  async function importBundle(parsed) {
    let incomingSlots, incomingHistory = [], recoverySlots = [];
    const isBundle = parsed && parsed.format === 'SUBSTRATE_SAVE' && parsed.version === 2 && Array.isArray(parsed.slots);
    if (isBundle) {
      incomingSlots = parsed.slots.slice();
      recoverySlots = Array.isArray(parsed.recoverySlots) ? parsed.recoverySlots : [];
      if (recoverySlots.length > 1) throw new Error('The file contains too many recovery copies.');
      incomingHistory = Array.isArray(parsed.history) ? parsed.history : [];
    } else if (parsed && typeof parsed === 'object' && (parsed.code || parsed.solved)) {
      incomingSlots = [{ id: 'legacy', name: 'Imported legacy save', state: parsed }];
    } else throw new Error('This is not a SUBSTRATE save file.');
    if ((!incomingSlots.length && !recoverySlots.length) || incomingSlots.length > MAX_SAVE_SLOTS) {
      throw new Error('The file contains an invalid number of slots.');
    }
    const idMap = Object.create(null), sourceIds = Object.create(null), now = Date.now();
    const importBatchId = now + '-' + tabWriterId;
    const taggedSlots = incomingSlots.map(slot => ({ slot, recovery: false })).concat(
      recoverySlots.map(slot => ({ slot, recovery: true }))
    );
    const cleanSlots = taggedSlots.map((entry, i) => {
      const slot = entry.slot;
      if (!slot || typeof slot !== 'object') throw new Error('One save slot is malformed.');
      if (isBundle && (!slot.state || typeof slot.state !== 'object' || Array.isArray(slot.state))) {
        throw new Error('One save slot has no valid state.');
      }
      const sourceId = String(slot.id === undefined ? 'slot-' + i : slot.id);
      if (sourceIds[sourceId]) throw new Error('The file contains duplicate slot identifiers.');
      sourceIds[sourceId] = true;
      const id = 'slot-import-' + importBatchId + '-' + i;
      idMap[sourceId] = id;
      const state = portableSave(slot.state || slot.data || {});
      state._slotId = id; state._savedAt = now + i; state._writer = tabWriterId;
      return {
        id, name: safeSlotName((slot.name || 'Imported save') + ' (imported)'),
        createdAt: now, updatedAt: now + i, state, recovery: entry.recovery,
      };
    });
    const validPuzzles = puzzleNodeCounts();
    const groupedHistory = Object.create(null);
    incomingHistory.forEach((row) => {
      if (!row || typeof row !== 'object') throw new Error('One history entry is malformed.');
      const mapped = idMap[String(row.slotId)];
      const puzzleId = String(row.puzzleId || '');
      if (!mapped || !validPuzzles[puzzleId]) throw new Error('One history entry points to an unknown slot or puzzle.');
      if (!Array.isArray(row.code) || row.code.length !== validPuzzles[puzzleId] || row.code.some(text => typeof text !== 'string')) {
        throw new Error('One history entry has an invalid node layout.');
      }
      const metrics = row.metrics === null || row.metrics === undefined ? null : safeMetricRun(row.metrics);
      if (row.metrics && !metrics) throw new Error('One history entry has invalid score data.');
      const at = typeof row.at === 'number' && isFinite(row.at) && row.at > 0 ? row.at : now;
      const reason = String(row.reason || 'imported');
      if (reason.length > 160) throw new Error('One history label is too long.');
      const key = mapped + '\n' + puzzleId;
      if (!groupedHistory[key]) groupedHistory[key] = [];
      groupedHistory[key].push({ slotId: mapped, puzzleId, at, reason, code: row.code.slice(), metrics });
    });
    const cleanHistory = [];
    Object.keys(groupedHistory).forEach(key => {
      groupedHistory[key].sort((a, b) => b.at - a.at).slice(0, 30).forEach(row => cleanHistory.push(row));
    });
    let originalJournalRaw = null;
    try { originalJournalRaw = localStorage.getItem(slotJournalKey('slot-original')); } catch (e) {}
    const db = await openSaveDB();
    let pristine = null;
    await new Promise((resolve, reject) => {
      const tx = db.transaction(['slots', 'history', 'meta'], 'readwrite');
      const slotStore = tx.objectStore('slots');
      let importError = null;
      const currentRequest = slotStore.getAll();
      currentRequest.onsuccess = () => {
        const current = currentRequest.result || [];
        pristine = current.length === 1 && isPristineOriginalSlot(current[0]) ? current[0] : null;
        const currentNormalCount = current.filter(slot => slot.recovery !== true).length - (pristine ? 1 : 0);
        const currentRecoveryCount = current.filter(slot => slot.recovery === true).length;
        if (currentNormalCount + incomingSlots.length > MAX_SAVE_SLOTS) {
          importError = new Error('Import would exceed the eight-slot limit. Another tab may have added progress; no slots were changed.');
          tx.abort();
          return;
        }
        if (currentRecoveryCount + recoverySlots.length > 1) {
          importError = new Error('Import would create more than one recovery copy. Another tab may have added one; no slots were changed.');
          tx.abort();
          return;
        }
        if (pristine) {
          slotStore.delete(pristine.id);
          tx.objectStore('meta').put({ key: 'activeSlotId', value: cleanSlots[0].id });
        }
        cleanSlots.forEach(slot => slotStore.put(slot));
        cleanHistory.forEach((row, i) => {
          tx.objectStore('history').put({
            id: row.slotId + ':' + row.puzzleId + ':' + now + ':' + i,
            slotId: row.slotId, puzzleId: row.puzzleId, at: row.at,
            reason: row.reason, code: row.code, metrics: row.metrics,
          });
        });
      };
      tx.oncomplete = () => resolve();
      tx.onerror = () => reject(importError || tx.error || new Error('The save import transaction failed; no slots were changed.'));
      tx.onabort = () => reject(importError || tx.error || new Error('The save import was interrupted; no slots were changed.'));
    });
    if (pristine) {
      try {
        if (localStorage.getItem(slotJournalKey(pristine.id)) === originalJournalRaw) {
          localStorage.removeItem(slotJournalKey(pristine.id));
        }
      } catch (e) { /* preserve a journal changed by another tab */ }
      activeSlotId = cleanSlots[0].id;
      activeSlotName = cleanSlots[0].name;
      save = normalizeSave(cleanSlots[0].state);
      save._slotId = activeSlotId;
      save._savedAt = cleanSlots[0].updatedAt;
      saveConflict = false;
      saveDirty = false;
      const mirrored = mirrorJournalSnapshot(save, true);
      if (!mirrored.paired || !mirrored.active) {
        saveConflict = true;
        markSaveState('IMPORT STORED · NEWER LOCAL COPY PRESERVED', 'warn');
      } else markSaveState('saved · ' + activeSlotName, 'ok');
    }
    openModal('<h2>IMPORT COMPLETE</h2><p>Imported ' + cleanSlots.length + ' save slot' + (cleanSlots.length === 1 ? '' : 's') +
      (pristine ? ' and replaced the unused Original slot.' : ' without overwriting existing progress.') +
      (recoverySlots.length ? ' The separately labeled recovery copy preserves edits that had not safely reached the slot database.' : '') + '</p>',
      [{ label: 'MANAGE SLOTS', primary: true, fn: showSaveManager }]);
  }

  function chooseImportFile() {
    const input = document.createElement('input');
    input.type = 'file'; input.accept = '.json,.substrate-save.json,application/json';
    input.onchange = () => {
      const file = input.files && input.files[0];
      if (!file) return;
      if (file.size > 25 * 1024 * 1024) { openModal('<h2>IMPORT REFUSED</h2><p>Save files must be smaller than 25 MB.</p>'); return; }
      const reader = new FileReader();
      reader.onload = async () => {
        try { await importBundle(JSON.parse(String(reader.result))); }
        catch (e) { openModal('<h2>IMPORT REFUSED</h2><p>' + esc(e.message || 'The file is invalid.') + '</p>'); }
      };
      reader.onerror = () => openModal('<h2>IMPORT FAILED</h2><p>The file could not be read.</p>');
      reader.readAsText(file);
    };
    input.click();
  }

  async function wipeCurrentSlot() {
    if (!confirm('Reset the active slot "' + activeSlotName + '" to the beginning? Other slots are untouched.')) return;
    if (persistTimer) { clearTimeout(persistTimer); persistTimer = null; }
    if (historyTimer) { clearTimeout(historyTimer); historyTimer = null; }
    flushPersist();
    try { await saveWriteQueue; } catch (error) {
      openModal('<h2>RESET PAUSED</h2><p>The current slot could not be saved safely first. Export your saves or resolve the other-tab conflict, then try again.</p>');
      return;
    }
    if (saveConflict) {
      openModal('<h2>RESET PAUSED</h2><p>Another tab changed this slot. Export this tab if needed, then reload before resetting so newer progress is not erased.</p>');
      return;
    }
    try {
      const localRevision = Number(save._savedAt || 0);
      const localWriter = save._writer;
      let resetJournalRaw = null;
      try { resetJournalRaw = localStorage.getItem(slotJournalKey(activeSlotId)); } catch (e) {}
      const db = await openSaveDB();
      const tx = db.transaction(['slots', 'history'], 'readwrite');
      const done = idbDone(tx);
      const slots = tx.objectStore('slots');
      const history = tx.objectStore('history');
      const existing = await idbRequest(slots.get(activeSlotId));
      if (slotRecordConflictsWithLocal(existing, localRevision, localWriter) ||
          journalConflictsWithLocal(localRevision, localWriter)) {
        tx.abort();
        try { await done; } catch (e) { /* deliberate conflict abort */ }
        saveConflict = true;
        openModal('<h2>RESET PAUSED</h2><p>Another tab committed a different version of this slot. Reload before resetting so its newer progress is not erased.</p>');
        return;
      }
      await new Promise((resolve, reject) => {
        const cursor = history.openCursor();
        cursor.onerror = () => reject(cursor.error || new Error('Could not inspect solution history'));
        cursor.onsuccess = () => {
          const item = cursor.result;
          if (!item) { resolve(); return; }
          if (item.value && item.value.slotId === activeSlotId) item.delete();
          item.continue();
        };
      });
      if (journalConflictsWithLocal(localRevision, localWriter)) {
        tx.abort();
        try { await done; } catch (e) { /* deliberate conflict abort */ }
        saveConflict = true;
        openModal('<h2>RESET PAUSED</h2><p>Another tab changed this slot while reset was being prepared. Reload before resetting so its newer progress is not erased.</p>');
        return;
      }
      const stamp = Math.max(Date.now(), localRevision + 1, Number(existing && existing.updatedAt || 0) + 1);
      const blank = freshSave();
      blank._slotId = activeSlotId; blank._savedAt = stamp; blank._writer = tabWriterId;
      slots.put({ id: activeSlotId, name: existing && existing.name ? existing.name : activeSlotName,
        createdAt: existing && existing.createdAt ? existing.createdAt : stamp, updatedAt: stamp, state: cloneData(blank),
        recovery: !!(existing && existing.recovery === true),
        resetFence: { baseRevision: localRevision, baseWriter: localWriter || '', writer: tabWriterId } });
      await done;
      if (journalConflictsWithLocal(localRevision, localWriter)) {
        const recovery = currentJournalForSlot(activeSlotId);
        if (recovery) {
          save = normalizeSave(recovery);
          save._slotId = activeSlotId;
          save._savedAt = journalRevision(recovery);
          saveDirty = true;
        }
        saveConflict = true;
        markSaveState('NEWER SAVE IN ANOTHER TAB · EXPORT OR RELOAD', 'err');
        openModal('<h2>RESET PAUSED</h2><p>Another tab saved at the same moment. Its journal was preserved; export or reload before trying again.</p>');
        return;
      }
      save = blank;
      const mirrored = mirrorJournalSnapshot(blank, true, undefined, undefined, resetJournalRaw);
      if (!mirrored.paired || !mirrored.active) {
        if (mirrored.newer) {
          const recovery = currentJournalForSlot(activeSlotId);
          if (recovery) {
            save = normalizeSave(recovery);
            save._slotId = activeSlotId;
            save._savedAt = journalRevision(recovery);
            saveDirty = true;
          }
        }
        saveConflict = true;
        markSaveState('NEWER SAVE IN ANOTHER TAB · EXPORT OR RELOAD', 'err');
        openModal('<h2>RESET PAUSED</h2><p>The reset reached the slot database, but a newer local copy appeared and was preserved. Reload before doing more work.</p>');
        return;
      }
      location.reload();
    } catch (error) {
      openModal('<h2>RESET FAILED</h2><p>No progress was intentionally removed. Export your saves, check browser storage, and try again.</p>');
    }
  }

  async function eraseAllSaves() {
    const answer = prompt('Type ERASE to delete every SUBSTRATE slot, solution history, and active journal in this browser.');
    if (answer !== 'ERASE') return;
    try {
      if (persistTimer) { clearTimeout(persistTimer); persistTimer = null; }
      try { await saveWriteQueue; } catch (e) {}
      const db = await openSaveDB(); db.close();
      saveDBPromise = null;
      await new Promise((resolve, reject) => {
        const req = indexedDB.deleteDatabase(SAVE_DB_NAME);
        req.onsuccess = () => resolve();
        req.onerror = () => reject(req.error);
        req.onblocked = () => openModal('<h2>WAITING TO ERASE</h2><p>Close SUBSTRATE in every other tab or installed window. Erasing will continue here when the database is released; the journal remains intact until then.</p>');
      });
    } catch (e) {
      openModal('<h2>ERASE COULD NOT FINISH</h2><p>Close SUBSTRATE in every other tab or installed window, then try again. Nothing in the compatibility journal was deleted.</p>');
      return;
    }
    try {
      localStorage.removeItem(SAVE_KEY);
      localStorage.removeItem(ACTIVE_SLOT_KEY);
      for (let i = localStorage.length - 1; i >= 0; i--) {
        const key = localStorage.key(i);
        if (key && key.slice(0, SLOT_JOURNAL_PREFIX.length) === SLOT_JOURNAL_PREFIX) {
          localStorage.removeItem(key);
        }
      }
    } catch (e) {
      openModal('<h2>ERASE INCOMPLETE</h2><p>The slot database was erased, but the browser refused to remove the compatibility journal.</p>');
      return;
    }
    location.reload();
  }

  function showSettings() {
    const installNote = window.isSecureContext
      ? 'This origin is secure. The install/offline worker will be enabled with the permanent domain release.'
      : 'This IP-only test host uses HTTP. Fullscreen works now; browser installation and offline caching require the later domain + HTTPS cutover.';
    openModal(
      '<h2>SETTINGS</h2>' +
      '<p><label><input type="checkbox" id="set-crt"' + (save.settings.crt ? ' checked' : '') + '> phosphor wash (CRT effect)</label></p>' +
      '<p><label><input type="checkbox" id="set-sound"' + (save.settings.sound ? ' checked' : '') + '> console audio (ticks, blips, chimes)</label></p>' +
      '<p><label><input type="checkbox" id="set-motion"' + (save.settings.motion !== false ? ' checked' : '') + '> motion and value-transfer animation</label></p>' +
      '<p><label for="set-volume">audio volume</label><br><input type="range" id="set-volume" min="0" max="1" step="0.05" value="' +
        Math.max(0, Math.min(1, Number(save.settings.volume))) + '"></p>' +
      '<p><label><input type="checkbox" id="set-unseal"' + (save.settings.unsealed ? ' checked' : '') + '> unseal all strata (free exploration — for study, not glory)</label></p>' +
      '<h3>INSTALL / OFFLINE</h3><p style="color:var(--dim);font-size:12px">' + esc(installNote) + '</p>' +
      '<h3>SAVES · ' + esc(activeSlotName) + '</h3><p><button id="btn-slots">MANAGE SLOTS</button> <button id="btn-export">EXPORT ALL</button> <button id="btn-import">IMPORT</button></p>' +
      '<p style="color:var(--dim);font-size:12px">Export creates one portable file containing every slot and its solution history. Import always creates new slots; it never overwrites progress.</p>' +
      '<p><button id="btn-wipe-current">RESET CURRENT SLOT</button> <button id="btn-wipe-all">ERASE ALL LOCAL SAVES</button></p>' +
      '<h3>ABOUT</h3><p style="color:var(--dim);font-size:12.5px">SUBSTRATE teaches assembly-level thinking, algorithms, memory, calling conventions, and distributed backend patterns through one small honest machine. Made for a Michigan CS student. Go Blue.</p>'
    );
    $('set-crt').onchange = (e) => { save.settings.crt = e.target.checked; persist(); applyPreferences(); };
    $('set-sound').onchange = (e) => { save.settings.sound = e.target.checked; persist(); };
    $('set-motion').onchange = (e) => { save.settings.motion = e.target.checked; persist(); applyPreferences(); };
    $('set-volume').oninput = (e) => { save.settings.volume = Math.max(0, Math.min(1, Number(e.target.value))); persistSoon(); };
    $('set-unseal').onchange = (e) => { save.settings.unsealed = e.target.checked; persist(); renderMap(); };
    $('btn-slots').onclick = showSaveManager;
    $('btn-export').onclick = exportSaves;
    $('btn-import').onclick = chooseImportFile;
    $('btn-wipe-current').onclick = wipeCurrentSlot;
    $('btn-wipe-all').onclick = eraseAllSaves;
  }
  $('btn-settings').onclick = showSettings;

  /* ---------- selftest ---------- */

  function selftest() {
    const lines = [];
    let bad = 0;
    allPuzzles.forEach(({ p }) => {
      const texts = SEED.normalizePrograms(p, p.solution);
      let ok = true, msg = '', cyc = 0;
      for (let i = 0; i < p.tests.length; i++) {
        const r = SEED.runTest(p, texts, p.tests[i], true);
        if (i === 0) cyc = r.cycles;
        if (!r.pass) { ok = false; msg = 'test ' + (i + 1) + ': ' + r.msg; break; }
      }
      if (!ok) bad++;
      lines.push((ok ? 'PASS ' : 'FAIL ') + p.id + ' ' + p.name +
        (ok ? ' (' + cyc + 'c, par ' + p.par.cycles + 'c)' : ' — ' + msg));
    });
    const pre = el('pre', '', esc((bad ? 'SELFTEST FAILURES: ' + bad : 'SELFTEST ALL PASS') + '\n\n' + lines.join('\n')));
    pre.style.cssText = 'position:fixed;inset:20px;overflow:auto;background:var(--panel);border:1px solid var(--edge2);padding:20px;z-index:200;font-size:12px;color:var(--ink)';
    document.body.appendChild(pre);
  }

  /* ---------- init ---------- */

  async function startGame() {
    applyPreferences();
    await initializeSaveDB();
    if (location.hash === '#selftest') { runBoot(); selftest(); }
    else if (save.booted && Object.keys(save.solved).length) {
      renderMap(); show('scr-map');
      if (!save.tut.fundamentals) showHowToPlay(0);
    }
    else runBoot();
  }
  startGame();
})();

</script>

</body></html>