diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..681dfb4
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,41 @@
+name: CI
+
+# Pushes to main deploy straight to the live game, so the gate has to sit on the
+# pull request — by the time a bad commit reaches main, it is already shipping.
+on:
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+# A newer push to the same PR makes the previous run irrelevant.
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  verify:
+    name: Typecheck, test, build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+      - run: npm ci
+
+      - name: Typecheck
+        run: npm run typecheck
+
+      - name: Test
+        run: npm test
+
+      # Same build the deploy workflow runs, including the base path, so a
+      # PR cannot pass here and then fail on the way to production.
+      - name: Build
+        run: npm run build
+        env:
+          VITE_BASE_PATH: /lighthouse-ttrpg/
diff --git a/CLAUDE.md b/CLAUDE.md
index 258c7bb..e1b13fa 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -35,3 +35,7 @@ One-way layered deps: `types → data → engine → net → store → component
 ## Deploy
 Pushes to `main` auto-deploy to GitHub Pages (`.github/workflows/deploy.yml`).
 Open a PR for review; don't push straight to `main` unless asked.
+
+Every PR into `main` runs `.github/workflows/ci.yml` — typecheck, the full test
+suite, and the same production build the deploy uses. Because main ships on
+merge, the PR is the only place a break can still be caught.
diff --git a/docs/MAPS.md b/docs/MAPS.md
new file mode 100644
index 0000000..e77cc92
--- /dev/null
+++ b/docs/MAPS.md
@@ -0,0 +1,339 @@
+# The Atlas — Maps, Worlds & the Places You Fight In
+
+> **The vision.** Creators build and sell **maps** the way they already build and
+> sell systems. A map ranges from a single island to a whole globe, and you can
+> zoom from the full world down to one room in one building — with basements,
+> upper floors, and caves. When a fight starts, the battlefield **is** the place
+> the party is standing in. Parties can split up and explore separately.
+
+This doc is the canonical map design, the way [RULES.md](RULES.md) is the
+canonical rules. It records **what was decided and why**, so the reasoning
+survives longer than any one implementation.
+
+Status tags, matching RULES.md: **✅ shipped** · **🔧 designed, not built** ·
+**💭 deliberately deferred**.
+
+---
+
+## 1. The one-sentence architecture
+
+> **The world is a seed. The battlefield is compiled data.**
+
+Two layers, one hard one-way boundary, because the two halves of this feature
+have *opposite* constraints.
+
+| | **World layer** | **Battle layer** |
+|---|---|---|
+| What it is | An `Atlas`: a seed + tuning + the edits a human made | A `Battlefield`: walls, doors, solid hexes, deploy zones |
+| Size | 600 bytes – 30 KB | ~30 bytes open ground, ~1.7 KB a seven-room tavern |
+| Where it lives | Persisted, sold, shared | Inside the `CombatState` snapshot, like everything else |
+| How it's produced | Generated lazily from `f(seed, params, path)` | `compileBattlefield(spec, place)` — a pure function |
+| Status | 🔧 | ✅ shipped |
+
+The atlas does **not** point at a battlefield. It **compiles** one. That single
+choice is what lets the map ship with **zero new combat concepts**: `HexCoord`
+never grows a Z axis, `CombatState` gains no geometry field it doesn't already
+have, and a map-derived fight travels inside the `combat_start` message that
+already exists.
+
+### Why a seed, and not a map file
+
+Every hard constraint in this app is a constraint on **bytes**:
+
+- Distribution is a **clipboard paste** into a `<textarea>`. No file input, no
+  download, no Blob anywhere in `src/`.
+- Storage is **~5 MB of localStorage**, shared with every other project on the
+  `github.io` subdomain, and its quota failure is silent by design.
+- The wire is **PeerJS with no chunking and no backpressure** — a practical
+  budget of tens of KB per message.
+- Rendering is **SVG only**. No canvas, no WebGL, anywhere in the codebase.
+
+A seeded atlas answers all four with the same move. A world is roughly **one
+fifth the size of `skillTree.json`**. There is nowhere in this app for
+materialised map geometry to live, and there is no server coming to hold it.
+
+---
+
+## 2. The scale ladder
+
+A place's address is its identity. `/P7/R3/L2/S9/B0/F-1/K4` is a room, in a
+basement, in a building, in a settlement, in a valley, in a region, on a plate —
+**22 characters**.
+
+| Tag | Level | Roughly |
+|---|---|---|
+| `W` | world | the globe itself — **the only spherical level** |
+| `P` | plate | a continent or an ocean |
+| `R` | region | a country, a large island, an inland sea |
+| `L` | locale | a valley, a forest, a stretch of coast |
+| `S` | site | a settlement, a ruin, a dungeon mouth |
+| `B` | structure | one building, tower, or cave system |
+| `F` | floor | one storey — **the index may be negative** (basements, depths) |
+| `K` | room | one chamber — the leaf, and the natural battlefield |
+
+**A single island, a country, a continent, and a whole planet are the same
+structure with a different `radiusKm`.** That one dial (40 → 6371) is what
+satisfies "range in size" without a second code path.
+
+### Two properties that make the zoom actually work
+
+**Every level below `world` is a locally-flat hex chart with `|q|,|r| ≤ 16.**
+The sphere is used at exactly one rung. Coordinates never leave four significant
+figures, so the float32 `viewBox` collapse that kills every naive deep-zoom
+camera *cannot be constructed*. Deep zoom is a stack of shallow charts, not one
+enormous coordinate space.
+
+**Children totally partition their parent's chart.** Every hex belongs to
+exactly one child, so zooming in *anywhere* always descends into something.
+This is not a detail — a council judge computed that the obvious alternative
+(children as pins scattered on a parent) leaves **93.6% of the globe with
+nothing beneath it**, turning "zoom to a room" into hunting for ~40 pins in a
+row. Total partition is what makes it a zoom instead of a drill.
+
+### Verticality, without touching combat
+
+Floors are **path segments** (`/…/B4/F-1`), each an ordinary sibling place with
+its own chart sharing its parent's lat/lon. `HexCoord` never widens, and the
+protocol never learns that floors exist. Stairs are terrain that links them.
+
+---
+
+## 3. Customisation — the part that has to survive regeneration
+
+The only thing stored is the only thing that cannot be recomputed: **a human's
+deliberate edits**, keyed by *stable path*, never by array index.
+
+```ts
+overrides: Record<PlacePath, PlaceOverride>   // sparse; 40–200 bytes each
+tombstones: PlacePath[]                       // generated children deleted outright
+```
+
+Because the key is a derived path and not an ordinal, adding a sibling never
+perturbs another sibling's seed. An edit either still resolves after
+regeneration, or is reported as **orphaned** — it is never silently dropped.
+
+Three rules protect authored work, and they exist because the research is
+unambiguous that **losing work is the #1 failure of every map tool in this
+market** (Inkarnate's six top-voted bugs are all "my maps won't load"; Dungeon
+Alchemist's crashes plus a broken autosave; Dungeondraft losing maps with their
+asset packs; Wonderdraft's RAM ceiling):
+
+1. **Identity is the key; position is a property.** `PlaceOverride.at` moves a
+   place within its parent's chart *without changing its seed*. "Move this town
+   three hexes" must not silently become a different town with different
+   children — which is exactly what hide-and-re-add would do.
+2. **Generator dials lock once published or heavily edited.** Changing one
+   re-derives the tree and orphans paths. Unlocking is explicit and gated behind
+   a blocking diff: *"Regenerating drops 12 of your 340 edits — Pin / Discard /
+   Cancel."*
+3. **Orphans are reattachable, never discarded for you.** Every silent drop is a
+   bug.
+
+---
+
+## 4. The battle handoff ✅ (the arena) / 🔧 (the compiler)
+
+`compileBattlefield(spec, place, opts) => Battlefield` is a pure engine function
+returning the exact struct combat already consumes. The arena layer is **shipped
+and tested** (commit `486af64`):
+
+- **Walls are edges, not cells.** A wall sits on the border *between* two hexes,
+  so a walled interior costs **zero standable ground** — a seven-room layout is
+  ~100 edge records rather than ~93 of the board's 252 hexes (37%). It also
+  gives doors the right arity: an edge door joins exactly two hexes, where a
+  door *hex* would open in six directions.
+- Doors are a state on an edge. Solid hexes (pillars, pits, deep water) block
+  movement but not sight.
+- **Line of sight gates targeting** at any range, including `Battlefield`.
+- Deployment zones are supplied by the map, because the default midline rows
+  reserve 8 of 14 rows — most of a small board, and meaningless on a cave.
+
+Sanity check against the market: **Foundry VTT and Roll20 both model walls as
+segments with independently configurable movement/sight restriction**, and
+Foundry's v12 rewrite exists specifically because its hex grid had been "a brick
+wall grid" rather than real hexes — a bug Roll20 still ships. Our hex math has
+always used proper axial/cube coordinates.
+
+### Arena size is archetype-driven, not global
+
+Measured against `MOVE_RANGE = 6` and bands Near 2 / Far 4 / Distant 6:
+
+| Archetype | Dims | Mean pairwise distance | % of board within one Move of centre |
+|---|---|---|---|
+| Tavern common room | 10×8 | 4.9 | 99% |
+| Ship deck | 12×6 | 5.1 | 92% |
+| Cave chamber | 12×10 | 6.0 | 85% |
+| Corridor / bridge | 16×5 | 6.3 | 74% |
+| **Current default** | **18×14** | **8.8** | **50%** |
+| Mountain pass | 20×10 | 8.5 | 53% |
+
+> **A finding for Justin, not a change I made.** The invariant that falls out of
+> the tactical-design literature is *mean pairwise distance ≤ your longest range
+> band*. At 18×14 the mean is **8.8 against a Distant band of 6** — the average
+> pair of combatants cannot engage without moving first, and half the board is
+> dead space. Two coherent fixes: drop the default to **14×12** (mean 7.1), or
+> raise Distant to 8–9. **I did not touch it** — §6.1 of RULES.md is a settled
+> rule and rebalancing your game while you sleep isn't my call. Map-derived
+> arenas pick their own size regardless.
+
+Related: deployment currently leaves a **4-hex gap against a 6-hex move**, so
+there is no approach phase. The tabletop convention is a no-man's-land of
+1.5–2× per-turn movement.
+
+---
+
+## 5. Split party 🔧
+
+`PartyGroup` records keyed on **stable `Character.id`s, never `peerId`s** —
+peerIds go stale on every transport reconnect, and the codebase already has
+rebinding machinery precisely because of that.
+
+Fog is `known: PlacePath[]` (the shared discovered world) plus per-group `seen`
+for asymmetric visibility.
+
+**One active fight at a time in v1** 💭. Widening `combatStore.combat` to
+`Record<groupId, CombatState>` touches 33 `useCombatStore(` call sites across 15
+files in the app's most safety-critical store. The real complaint — two players
+watching a banner for thirty minutes — is solved instead by **routing the
+non-fighting group to the atlas** so they keep exploring. Parallel combat stays
+a store change later, not a protocol change: `CombatState.groupId` is present
+from day one.
+
+---
+
+## 6. Selling maps
+
+An `Atlas` mirrors `Worldpack`'s marketplace fields field-for-field, so the
+existing card, fee split, fork, and lineage UI work unchanged. A pack may bundle
+up to four atlases; a map may also be sold standalone.
+
+### What the market says people actually pay for
+
+The single most useful number found: **74% of Forgotten Adventures' paying
+patrons pay 3× the base price for the Foundry tier** — walls, lighting, and
+ambient sound. The *art* is available at the $5 tier. The premium is entirely
+for **pre-authored structure that saves an hour of manual wall-tracing.**
+
+That is the whole thesis of this design. Our generator emits `Battlefield` —
+walls, doors, deployment zones — as data, from the start. **We sell the prep,
+and it's the default rather than the top tier.**
+
+Supporting facts:
+- **Platform cut is 30–35% industry-wide** (Roll20 70/30, DriveThruRPG 70/65,
+  Inkarnate 30%). Our `WORLDFORGE_FEE_RATE` of **15% is half the incumbent rate**.
+- Price expectations are low and clustered: median paid asset ~€4, single maps
+  $1–5, themed packs $5–10, bundles $20–70. Cartography Assets enforces a **€2
+  floor** as an anti-junk mechanism.
+- **Structured metadata is the #1 unmet buyer need.** "I can never find anything
+  in the back catalogue" is the loudest complaint across every creator Patreon.
+- **"What happens to my library when I stop paying" is a question almost nobody
+  answers.** Answering it plainly is a differentiator.
+- **Mandatory AI disclosure is now the industry floor** — DriveThruRPG refuses
+  AI map packs outright, itch.io de-indexes untagged ones, and AI share is
+  inversely correlated with sales tier.
+
+### `fingerprint` is honest about what it is
+
+A hash over the spec plus a fixed probe set. It detects **truncation,
+corruption, and generator mismatch** — not forgery, because it's computed
+client-side with no key by code the recipient also runs. Import still succeeds
+on mismatch; the card shows "unverified". Calling it anti-tampering would be
+marketing, and the UI says so.
+
+---
+
+## 7. Decisions log
+
+Every one of these was contested by at least one council judge and survived.
+
+| # | Decision | Why |
+|---|---|---|
+| A | The atlas **produces** a `Battlefield`, never replaces it | All three architects proposed a non-serializable descriptor. That forks the battle model, makes engine inputs unreproducible from a bug report, and loses edge walls. |
+| B | Terrain **rides every combat snapshot** | `ingest` is a wholesale replace, so a field present on `combat_start` and stripped from playback broadcasts **vanishes mid-fight and never recovers**. 1.7 KB on a message already running 11–60 KB. |
+| C | **No cross-peer regeneration of authoritative geometry** | `Math.tan`/`Math.acos` are not bit-identical across V8 and JavaScriptCore; ECMA-262 doesn't require it. Transmitting the compiled arena makes float drift cosmetic instead of a desync. |
+| D | Zoom is a **stack of local charts**, not one coordinate space | Keeps every coordinate within four significant figures. Deep zoom in SVG dies on float precision otherwise. |
+| E | `childAt` is **total** | Otherwise 93.6% of the world has nothing beneath it. |
+| F | **Binary passability** in v1; no movement cost | Converting the BFS to uniform-cost search would perturb which equidistant hex `closestReachableTo` picks — changing shipped movement for a feature nobody asked for. |
+| G | `RANGE_TO_HEX_DISTANCE.Battlefield` stays `Infinity` | It's asserted by a test and used by authored content in sold worldpacks. On a bounded arena it correctly reads "anywhere on this board". |
+| H | **Three protocol messages, no delta stream** | A dropped patch leaves a client stale but stamped current, with nothing to invalidate it. Full re-send of a ≤30 KB doc is cheaper than the failure mode. |
+| I | GM notes are **stripped before sync** | `AtlasSpec` excludes notes and marketplace metadata, so stripping is lossless for the fingerprint — a player can still verify what they were handed. |
+| J | **No Web Worker, no IndexedDB** | Neither exists in this codebase. A depth-7 descend measured ~1.7 ms cold — inside one frame. And Owlbear Rodeo's own post-mortem on shipping browser-storage-only is blunt: *Safari deletes your data if you don't visit for a week.* |
+| K | Generator freeze begins at the **marketplace phase**, not day one | Phases 1–3 each necessarily change output. Declaring a freeze early guarantees the golden file gets re-blessed twice, training exactly the reflex the mechanism exists to prevent. |
+| L | Coastlines **gain relief detail on zoom; the land/sea boundary never moves** | Evaluated at a fixed octave count per world, derived from `radiusKm`, never from zoom. A shore that creeps as you approach it puts a creator's port town in open ocean. |
+
+### Deliberately rejected
+
+- **Materialised tile pyramids.** Nowhere for the bytes to live.
+- **Harmonic outline signatures** for coastlines — provably star-convex, so no
+  bays, no peninsulas, no corridors, no floor plans.
+- **Storing rendered SVG as the source of truth.** This is Azgaar's Fantasy Map
+  Generator's central sin, and it simultaneously causes its file bloat, its
+  corruption, and its version lock-in. Its `\r\n`-delimited format with embedded
+  SVG has destroyed users' work for years — one lost a month *including their
+  git backups* — because opening the file in an editor normalises line endings.
+- **Hex cells for the globe.** Hex duals of a subdivided icosahedron do **not**
+  nest (a level-*n+1* hex isn't contained in any level-*n* hex). Quads/triangles
+  nest exactly. Promising hex nesting would be a lie.
+- **Fibonacci-lattice cells.** Beautifully even, and there's a published O(1)
+  inverse — but the index depends on *N*, so changing resolution changes every
+  id. Fatal for stable, shareable, lazily-refined addresses.
+
+---
+
+## 8. Build order
+
+| Phase | Delivers | Status |
+|---|---|---|
+| **0** | Wire the shipped `Battlefield` through store + board; fix the latent bugs it exposes | ✅ |
+| **1** | One island, one chart, one fight — seed → terrain → `compileBattlefield` | 🔧 |
+| **2** | The scale ladder + the descend/ascend camera | 🔧 |
+| **3** | Verticality — structures, floors, caves, rooms | 🔧 |
+| **4** | Authoring — overrides, paint tools, the orphan report | 🔧 |
+| **5** | The table — split party, fog, sync | 🔧 |
+| **6** | Marketplace, bundling, generator freeze | 🔧 |
+| **7** | The globe | 🔧 |
+
+**Phase 0 contains no map** — deliberately. It makes a hand-written arena work
+end to end before a single line of generation exists.
+
+### The generator's shape (Phase 1+)
+
+Everything under `src/engine/atlas/**` is **pure**, enforced by a test that
+reads every file in the directory and asserts no React/DOM/timer/`console`/
+`Date.now`/`Math.random` and no store import.
+
+Worldgen takes an explicit `seed: number` rather than the engine's usual
+injected `rng`, because a world needs **random access** — derive child K without
+generating children 0…K−1. This honours the determinism rule more strictly than
+the letter: the function is total, order-independent, and replayable with no
+ambient state and no call-order coupling.
+
+```ts
+seedOf(spec, path) = path.split('/').reduce(deriveSeed, hash32(seed, gen.major))
+```
+
+**The invariant the whole ladder rests on:** terrain at *every* level is sampled
+from **the same 3D noise field on the unit sphere**. One global continuous
+function; only the tessellation is local. Any generator that shortcuts to
+per-chart 2D noise looks perfect in isolation and silently breaks every chart
+border.
+
+---
+
+## 9. Open questions for Justin
+
+Everything needed to build was decided (§7). These are yours:
+
+1. **Battlefield default size.** The measurements in §4 say 18×14 is oversized
+   for the current range bands. Shrink to 14×12, raise Distant to 8–9, or leave
+   it? *(I left it.)*
+2. **Deployment gap.** 4 hexes against a 6-hex move means no approach phase.
+   Widen to 6–8?
+3. **Does a map bought inside a worldpack stay playable if the pack is
+   deactivated?** Nobody in this market answers the equivalent question, which
+   makes answering it a differentiator.
+4. **AI disclosure field on the marketplace card** — the industry floor is now
+   mandatory disclosure. Add it before the catalogue exists, or after?
+5. **Real-world scale.** `metresPerHex` is currently a display concern. Do you
+   want travel time (watches, rations, forced marches) to be *mechanical*, or
+   narration like conditions are?
diff --git a/docs/RULES.md b/docs/RULES.md
index c3525f7..44a099f 100644
--- a/docs/RULES.md
+++ b/docs/RULES.md
@@ -140,7 +140,25 @@ Nodes + directed edges (prerequisite → unlocked) + linked world items. Exactly
 ## 6. Combat
 
 ### 6.1 Battlefield ✅
-Pointy-top hex grid **18 × 14** (tunable). One combatant per hex. Teams deploy near the midline with a gap; the GM repositions during setup.
+Pointy-top hex grid **18 × 14** by default (tunable). One combatant per hex. Teams deploy near the midline with a gap; the GM repositions during setup.
+
+**A fight can instead happen in a *place*.** `CombatState.battlefield` (optional) carries the arena's own `dims`, its structure, and its deployment zones — this is what a map-derived encounter supplies. Absent ⇒ the default open rectangle above, unchanged.
+
+### 6.1a Walls, doors & line of sight ✅ *(inert unless a battlefield supplies them)*
+
+**Walls sit on the border *between* two hexes, not on a hex.** A wall therefore costs no standable ground — a seven-room interior is ~100 edge records instead of ~93 of the board's 252 hexes. It also gives doors the right arity: an edge door joins exactly two hexes, where a door *hex* would open in six directions.
+
+| Rule | Effect |
+|---|---|
+| **Wall** | Blocks movement and sight across that one border, from both sides. |
+| **Door** | An `open` door is as if the border weren't there; `closed` and `locked` block movement and sight. (Opening one is GM narration for now.) |
+| **Solid hex** | A pillar, pit, or deep water — impassable, but does not block sight. |
+| **Line of sight** | A target you cannot see cannot be attacked, targeted by an ability, or caught in an AOE — **regardless of range**, including `Battlefield`. `Self` is a team check and is never gated by geometry. |
+| **Forced movement** | A shove or pull stops at a wall exactly as it stops at the board edge. |
+
+LOS is deliberately **permissive**: it is granted if the line is clear in *either* direction. The underlying hex-line rounding isn't symmetric (8 of 31,626 hex pairs on an 18×14 board disagree about who can see whom), and players forgive "they shouldn't have seen me" far more readily than "I can't shoot the thing I'm looking at."
+
+> On an open field none of this applies and the engine short-circuits it entirely, so a fight with no battlefield resolves exactly as it always has.
 
 ### 6.2 Range bands — `RANGE_TO_HEX_DISTANCE` (tunable) ✅
 
@@ -292,6 +310,7 @@ A "System" can reskin terms and **add abilities/weapons/skill-tree nodes** that
 | Base actions/round | 3 | `stats.ts:216` |
 | Level-1 points / per level | 15 / +10 | `stats.ts:307` |
 | Grid / move range | 18×14 / 6 | `constants.ts` |
+| Max arena accepted off the wire | 200×200 | `normalizeBattlefield` (`lib/combat.ts`) |
 | Range bands | Melee 1 / Near 2 / Far 4 / Distant 6 | `RANGE_TO_HEX_DISTANCE` |
 | Rest | short +50% MP/SP · long full | `REST_RULES` |
 | Unarmed / fallback damage | 1d4 | `combat.ts:880` |
diff --git a/src/engine/atlas/battlefield.test.ts b/src/engine/atlas/battlefield.test.ts
new file mode 100644
index 0000000..caa5958
--- /dev/null
+++ b/src/engine/atlas/battlefield.test.ts
@@ -0,0 +1,227 @@
+import { describe, it, expect } from 'vitest';
+import { compileBattlefield, reachableFrom, DEFAULT_DIMS, type ArenaArchetype } from './battlefield';
+import { hashPath } from './rand';
+import { gridHexes, hexKey, compileTerrain, edgeBlocks, HEX_DIRECTIONS } from '../hex';
+import { normalizeBattlefield } from '@/lib/combat';
+import type { Battlefield, HexCoord } from '@/types';
+
+const ARCHETYPES: ArenaArchetype[] = ['interior', 'cave', 'open'];
+const seedFor = (s: string) => hashPath([s]);
+
+/** Every hex that isn't solid. */
+const openHexes = (f: Battlefield): HexCoord[] => {
+  const solid = new Set(f.solid ?? []);
+  return gridHexes(f.dims).filter((h) => !solid.has(hexKey(h)));
+};
+
+describe.each(ARCHETYPES)('compileBattlefield — %s', (archetype) => {
+  const field = compileBattlefield({ seed: seedFor('a-seed'), archetype });
+
+  it('is deterministic for a seed', () => {
+    const again = compileBattlefield({ seed: seedFor('a-seed'), archetype });
+    expect(again).toEqual(field);
+  });
+
+  it('differs between seeds', () => {
+    const other = compileBattlefield({ seed: seedFor('other-seed'), archetype });
+    expect(other).not.toEqual(field);
+  });
+
+  it('uses the archetype default extent', () => {
+    expect(field.dims).toEqual(DEFAULT_DIMS[archetype]);
+  });
+
+  it('is JSON-safe — it has to ride a combat snapshot and localStorage', () => {
+    const round = JSON.parse(JSON.stringify(field));
+    expect(round).toEqual(field);
+  });
+
+  it('survives the wire trust boundary unchanged', () => {
+    expect(normalizeBattlefield(field)).toEqual(field);
+  });
+
+  it('LEAVES NO STRANDED HEXES — every open hex reaches every other', () => {
+    // The failure this guards against is the one players find, not the author:
+    // a sealed pocket that looks like ordinary floor.
+    const open = openHexes(field);
+    expect(open.length).toBeGreaterThan(10);
+    const reached = reachableFrom(open[0], field);
+    const stranded = open.filter((h) => !reached.has(hexKey(h)));
+    expect(stranded).toEqual([]);
+  });
+
+  it('nominates two disjoint deployment zones', () => {
+    expect(field.zones).toBeDefined();
+    const player = field.zones!.player.map(hexKey);
+    const npc = field.zones!.npc.map(hexKey);
+    expect(player.length).toBeGreaterThan(0);
+    expect(npc.length).toBeGreaterThan(0);
+    expect(player.filter((k) => npc.includes(k))).toEqual([]);
+  });
+
+  it('puts both deployment zones on standable, mutually reachable ground', () => {
+    const solid = new Set(field.solid ?? []);
+    const reached = reachableFrom(field.zones!.player[0], field);
+    for (const h of [...field.zones!.player, ...field.zones!.npc]) {
+      expect(solid.has(hexKey(h))).toBe(false);
+      expect(reached.has(hexKey(h))).toBe(true);
+    }
+  });
+
+  it('starts the two sides apart rather than face to face', () => {
+    const p = field.zones!.player[0];
+    const n = field.zones!.npc[0];
+    const dq = p.q - n.q;
+    const dr = p.r - n.r;
+    const dist = (Math.abs(dq) + Math.abs(dq + dr) + Math.abs(dr)) / 2;
+    expect(dist).toBeGreaterThanOrEqual(6);
+  });
+});
+
+describe('interiors', () => {
+  const field = compileBattlefield({ seed: seedFor('tavern'), archetype: 'interior' });
+
+  it('builds walls without consuming a single standable hex', () => {
+    // The whole reason walls are edges: a seven-room interior costs ~100 edge
+    // records instead of a third of the board.
+    expect(field.walls!.length).toBeGreaterThan(20);
+    expect(field.solid ?? []).toEqual([]);
+    expect(openHexes(field).length).toBe(field.dims.cols * field.dims.rows);
+  });
+
+  it('cuts doors through those walls', () => {
+    expect(Object.keys(field.doors ?? {}).length).toBeGreaterThan(2);
+  });
+
+  it('never leaves a door on the same edge as a wall', () => {
+    // A door that a wall also covers would be a door you can see and not use.
+    const walls = new Set(field.walls ?? []);
+    for (const k of Object.keys(field.doors ?? {})) {
+      expect(walls.has(Number(k))).toBe(false);
+    }
+  });
+
+  it('actually blocks movement across a wall', () => {
+    const terrain = compileTerrain(field);
+    const wall = field.walls![0];
+    let blockedSomewhere = false;
+    for (const h of gridHexes(field.dims)) {
+      for (let d = 0; d < 6; d += 1) {
+        if (edgeBlocks(terrain, h, d)) blockedSomewhere = true;
+      }
+    }
+    expect(wall).toBeGreaterThan(0);
+    expect(blockedSomewhere).toBe(true);
+  });
+
+  it('gives the layout at least one LOOP, not just a spanning tree', () => {
+    // Tested as the property that matters rather than as a door count: a door
+    // whose removal still leaves the arena connected is a second route. With a
+    // pure spanning tree every door is a bridge, every room has exactly one
+    // approach, and the fight degenerates into a corridor queue.
+    const doorIds = Object.keys(field.doors ?? {});
+    expect(doorIds.length).toBeGreaterThan(0);
+
+    const total = field.dims.cols * field.dims.rows;
+    const hasAlternateRoute = doorIds.some((id) => {
+      const sealed: Battlefield = {
+        ...field,
+        walls: [...(field.walls ?? []), Number(id)],
+        doors: Object.fromEntries(Object.entries(field.doors!).filter(([k]) => k !== id)),
+      };
+      return reachableFrom(openHexes(sealed)[0], sealed).size === total;
+    });
+    expect(hasAlternateRoute).toBe(true);
+  });
+});
+
+describe('caves', () => {
+  const field = compileBattlefield({ seed: seedFor('deep'), archetype: 'cave' });
+
+  it('carves rock without inventing walls', () => {
+    expect(field.solid!.length).toBeGreaterThan(0);
+    expect(field.walls ?? []).toEqual([]);
+  });
+
+  it('leaves a playable amount of floor', () => {
+    // B4/S4 at 45% fill is the hex-tuned rule. The square-grid rule ported
+    // naively gives either near-total open space or near-solid rock.
+    const total = field.dims.cols * field.dims.rows;
+    const open = openHexes(field).length;
+    expect(open / total).toBeGreaterThan(0.25);
+    expect(open / total).toBeLessThan(0.85);
+  });
+
+  it('seals the rim so the cave has a boundary', () => {
+    const solid = new Set(field.solid!);
+    for (const h of gridHexes(field.dims)) {
+      if (h.r === 0 || h.r === field.dims.rows - 1) expect(solid.has(hexKey(h))).toBe(true);
+    }
+  });
+});
+
+describe('open ground', () => {
+  const field = compileBattlefield({ seed: seedFor('moor'), archetype: 'open' });
+
+  it('scatters cover without walling anything', () => {
+    expect(field.solid!.length).toBeGreaterThan(3);
+    expect(field.walls ?? []).toEqual([]);
+  });
+
+  it('never places two obstacles adjacent — which is what guarantees connectivity', () => {
+    const solid = new Set(field.solid!);
+    for (const k of solid) {
+      const [q, r] = k.split(',').map(Number);
+      for (let d = 0; d < 6; d += 1) {
+        const nb = hexKey({ q: q + HEX_DIRECTIONS[d].q, r: r + HEX_DIRECTIONS[d].r });
+        expect(solid.has(nb)).toBe(false);
+      }
+    }
+  });
+
+  it('leaves most of the field open', () => {
+    const total = field.dims.cols * field.dims.rows;
+    expect(field.solid!.length / total).toBeLessThan(0.2);
+  });
+});
+
+describe('provenance and labelling', () => {
+  it('carries a label into the arena for the combat log', () => {
+    const field = compileBattlefield({
+      seed: seedFor('x'),
+      archetype: 'interior',
+      label: 'The Salt Lantern — common room',
+    });
+    expect(field.label).toBe('The Salt Lantern — common room');
+  });
+
+  it('records where it was compiled from', () => {
+    const origin = { atlasId: 'atl_1', path: '/P7/R3/L2/S9/B0/F-1/K4', genMajor: 1 };
+    const field = compileBattlefield({ seed: seedFor('x'), archetype: 'cave', origin });
+    expect(field.origin).toEqual(origin);
+    expect(normalizeBattlefield(field)?.dims).toEqual(field.dims);
+  });
+
+  it('honours an explicit size', () => {
+    const field = compileBattlefield({
+      seed: seedFor('x'),
+      archetype: 'interior',
+      dims: { cols: 8, rows: 8 },
+    });
+    expect(field.dims).toEqual({ cols: 8, rows: 8 });
+  });
+});
+
+describe('robustness across many seeds', () => {
+  it.each(ARCHETYPES)('%s stays connected and deployable for 40 seeds', (archetype) => {
+    for (let i = 0; i < 40; i += 1) {
+      const field = compileBattlefield({ seed: seedFor(`seed-${i}`), archetype });
+      const open = openHexes(field);
+      expect(open.length).toBeGreaterThan(10);
+      const reached = reachableFrom(open[0], field);
+      expect(reached.size).toBe(open.length);
+      expect(field.zones?.player.length).toBeGreaterThan(0);
+      expect(field.zones?.npc.length).toBeGreaterThan(0);
+    }
+  });
+});
diff --git a/src/engine/atlas/battlefield.ts b/src/engine/atlas/battlefield.ts
new file mode 100644
index 0000000..03f7818
--- /dev/null
+++ b/src/engine/atlas/battlefield.ts
@@ -0,0 +1,353 @@
+/**
+ * Turning a place into a place you can fight in.
+ *
+ * This is the battle handoff: a pure function from a seed and an archetype to
+ * the exact JSON-safe {@link Battlefield} the combat engine, the normalizer, and
+ * the board already consume. Nothing about combat has to change to accept a
+ * generated arena — the atlas does not *point at* a battlefield, it compiles
+ * one.
+ *
+ * Three archetypes, each with a different failure mode to design against:
+ *
+ * - **interior** — rooms and doors. Subdivision runs on the *offset* rectangle,
+ *   not on axial coordinates: axial space is sheared, so splitting there yields
+ *   parallelograms rather than rooms.
+ * - **cave** — cellular automata. The canonical "4-5 rule" is tuned for the 8
+ *   neighbours of a square grid and does **not** transfer; on six neighbours it
+ *   produces either mush or solid rock. B4/S4 at 45% fill is the hex equivalent.
+ * - **open** — scattered cover. Obstacles are placed with a minimum separation
+ *   of 2, which makes the map connected *by construction*: no two obstacles are
+ *   adjacent, so each is an isolated cell whose six neighbours form a connected
+ *   ring, and removing it cannot disconnect anything.
+ *
+ * Every archetype ends with a reachability sweep, because "the generator made
+ * an unreachable pocket" is a bug the players discover, not the author.
+ */
+import type { Battlefield, DoorState, GridDims, HexCoord } from '@/types';
+import { HEX_DIRECTIONS, edgeId, hexKey, inBounds, gridHexes } from '../hex';
+import { deriveSeed, randInt, rngFor, shuffled, type Seed } from './rand';
+import type { Rng } from '../dice';
+
+export type ArenaArchetype = 'interior' | 'cave' | 'open';
+
+export interface CompileBattlefieldOptions {
+  seed: Seed;
+  archetype: ArenaArchetype;
+  /** Arena extent. Defaults are chosen per archetype (see {@link DEFAULT_DIMS}). */
+  dims?: GridDims;
+  /** Human-readable origin, surfaced in the combat log. */
+  label?: string;
+  /** Provenance, when this came from an atlas. */
+  origin?: Battlefield['origin'];
+}
+
+/**
+ * Default extents, sized against `MOVE_RANGE = 6` and the range bands.
+ *
+ * The rule of thumb the numbers support is *mean pairwise distance ≤ your
+ * longest range band* — otherwise the average pair of combatants cannot engage
+ * without spending a turn walking, and the outer thirds of the board are dead
+ * space.
+ */
+export const DEFAULT_DIMS: Record<ArenaArchetype, GridDims> = {
+  interior: { cols: 12, rows: 10 },
+  cave: { cols: 14, rows: 12 },
+  open: { cols: 16, rows: 12 },
+};
+
+// --- offset <-> axial (odd-r), mirroring src/engine/hex.ts ------------------
+const toAxial = (col: number, row: number): HexCoord => ({
+  q: col - ((row - (row & 1)) >> 1),
+  r: row,
+});
+
+interface Rect {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}
+
+/** Recursive binary subdivision of an offset rectangle into room-sized leaves. */
+function bspLeaves(rng: Rng, rect: Rect, min: number, depth: number): Rect[] {
+  const canSplitH = rect.h >= min * 2 + 1;
+  const canSplitV = rect.w >= min * 2 + 1;
+  if (depth <= 0 || (!canSplitH && !canSplitV)) return [rect];
+  // Split the longer axis, so rooms stay roughly square rather than becoming
+  // corridors by accident.
+  const horizontal = canSplitH && (!canSplitV || rect.h > rect.w || rng() < 0.5);
+  if (horizontal) {
+    const cut = randInt(rng, min, rect.h - min - 1);
+    return [
+      ...bspLeaves(rng, { ...rect, h: cut }, min, depth - 1),
+      ...bspLeaves(rng, { ...rect, y: rect.y + cut, h: rect.h - cut }, min, depth - 1),
+    ];
+  }
+  const cut = randInt(rng, min, rect.w - min - 1);
+  return [
+    ...bspLeaves(rng, { ...rect, w: cut }, min, depth - 1),
+    ...bspLeaves(rng, { ...rect, x: rect.x + cut, w: rect.w - cut }, min, depth - 1),
+  ];
+}
+
+/** Minimal union-find, for the spanning tree that guarantees every room connects. */
+function makeUnionFind(n: number) {
+  const parent = Array.from({ length: n }, (_, i) => i);
+  const find = (i: number): number => {
+    while (parent[i] !== i) {
+      parent[i] = parent[parent[i]];
+      i = parent[i];
+    }
+    return i;
+  };
+  return {
+    find,
+    union(a: number, b: number): boolean {
+      const ra = find(a);
+      const rb = find(b);
+      if (ra === rb) return false;
+      parent[ra] = rb;
+      return true;
+    },
+  };
+}
+
+/** Every ordered pair of in-bounds adjacent hexes, each border visited once. */
+function borders(dims: GridDims): { a: HexCoord; b: HexCoord; dir: number }[] {
+  const out: { a: HexCoord; b: HexCoord; dir: number }[] = [];
+  for (const a of gridHexes(dims)) {
+    // Directions 0..2 only: each hex owns three of its six borders, so walking
+    // just those visits every border in the grid exactly once.
+    for (let d = 0; d < 3; d += 1) {
+      const b = { q: a.q + HEX_DIRECTIONS[d].q, r: a.r + HEX_DIRECTIONS[d].r };
+      if (inBounds(b, dims)) out.push({ a, b, dir: d });
+    }
+  }
+  return out;
+}
+
+/**
+ * Hexes reachable from `start`, honouring walls, doors, and solid cells.
+ * Used to prove the generated arena has no isolated pockets.
+ */
+export function reachableFrom(start: HexCoord, field: Battlefield): Set<string> {
+  const walls = new Set(field.walls ?? []);
+  const doors = new Map(Object.entries(field.doors ?? {}).map(([k, v]) => [Number(k), v]));
+  const solid = new Set(field.solid ?? []);
+  const seen = new Set<string>([hexKey(start)]);
+  const queue: HexCoord[] = [start];
+  while (queue.length) {
+    const c = queue.pop()!;
+    for (let d = 0; d < 6; d += 1) {
+      const id = edgeId(c, d);
+      if (walls.has(id)) continue;
+      const door = doors.get(id);
+      if (door !== undefined && door !== 'open') continue;
+      const n = { q: c.q + HEX_DIRECTIONS[d].q, r: c.r + HEX_DIRECTIONS[d].r };
+      const k = hexKey(n);
+      if (seen.has(k) || !inBounds(n, dims_(field)) || solid.has(k)) continue;
+      seen.add(k);
+      queue.push(n);
+    }
+  }
+  return seen;
+}
+
+const dims_ = (f: Battlefield): GridDims => f.dims;
+
+/** The open hexes of an arena, in row-major order. */
+function openHexes(field: Battlefield): HexCoord[] {
+  const solid = new Set(field.solid ?? []);
+  return gridHexes(field.dims).filter((h) => !solid.has(hexKey(h)));
+}
+
+/**
+ * Pick two deployment zones as far apart as the arena allows, drawn only from
+ * hexes that are actually connected to each other.
+ *
+ * Generated over geometric ends: on an irregular cave the two ends of the
+ * bounding box may both be solid rock, and the classic midline rows may lie
+ * inside a wall.
+ */
+function deployZones(field: Battlefield, want: number): Battlefield['zones'] {
+  const open = openHexes(field);
+  if (open.length === 0) return undefined;
+  const main = reachableFrom(open[0], field);
+  const usable = open.filter((h) => main.has(hexKey(h)));
+  if (usable.length < 2) return undefined;
+
+  // Two extremes along opposite diagonals — cheap, and robust to odd shapes.
+  const score = (h: HexCoord) => h.q + h.r * 0.5;
+  const sorted = usable.slice().sort((a, b) => score(a) - score(b));
+  const npc = sorted.slice(0, want);
+  const player = sorted.slice(-want).reverse();
+  return { player, npc };
+}
+
+// ---------------------------------------------------------------------------
+// Archetypes
+// ---------------------------------------------------------------------------
+
+function compileInterior(rng: Rng, dims: GridDims): { walls: number[]; doors: Record<string, DoorState> } {
+  const leaves = bspLeaves(rng, { x: 0, y: 0, w: dims.cols, h: dims.rows }, 3, 3);
+
+  // Which room owns each hex.
+  const roomOf = new Map<string, number>();
+  leaves.forEach((rect, i) => {
+    for (let row = rect.y; row < rect.y + rect.h; row += 1) {
+      for (let col = rect.x; col < rect.x + rect.w; col += 1) {
+        roomOf.set(hexKey(toAxial(col, row)), i);
+      }
+    }
+  });
+
+  // Every border between two rooms is a wall, and a candidate doorway.
+  const walls = new Set<number>();
+  const candidates = new Map<string, number[]>();
+  for (const { a, b, dir } of borders(dims)) {
+    const ra = roomOf.get(hexKey(a));
+    const rb = roomOf.get(hexKey(b));
+    if (ra === undefined || rb === undefined || ra === rb) continue;
+    const id = edgeId(a, dir);
+    walls.add(id);
+    const pair = ra < rb ? `${ra}-${rb}` : `${rb}-${ra}`;
+    const list = candidates.get(pair);
+    if (list) list.push(id);
+    else candidates.set(pair, [id]);
+  }
+
+  // A spanning tree over the rooms guarantees every room is reachable; the
+  // extra edges matter for play rather than topology, because a pure tree gives
+  // every room exactly one approach and combat degenerates into a queue.
+  const uf = makeUnionFind(leaves.length);
+  const doors: Record<string, DoorState> = {};
+  const leftovers: number[][] = [];
+  for (const pair of shuffled(rng, [...candidates.keys()])) {
+    const [ra, rb] = pair.split('-').map(Number);
+    const edges = candidates.get(pair)!;
+    if (uf.union(ra, rb)) {
+      const id = edges[Math.floor(rng() * edges.length)];
+      walls.delete(id);
+      doors[String(id)] = rng() < 0.25 ? 'closed' : 'open';
+    } else {
+      leftovers.push(edges);
+    }
+  }
+  // At least one loop whenever the layout admits one — a spanning tree alone
+  // gives every room exactly one approach, and the fight becomes a queue.
+  const extra = leftovers.length > 0 ? Math.max(1, Math.round(leftovers.length * 0.25)) : 0;
+  for (const edges of shuffled(rng, leftovers).slice(0, extra)) {
+    const id = edges[Math.floor(rng() * edges.length)];
+    walls.delete(id);
+    doors[String(id)] = 'open';
+  }
+
+  return { walls: [...walls], doors };
+}
+
+/** Cellular-automata caves, tuned for six neighbours rather than eight. */
+function compileCave(rng: Rng, dims: GridDims): string[] {
+  const all = gridHexes(dims);
+  const edgeRow = (h: HexCoord) => {
+    // Force the rim solid so the cave has a boundary rather than an open edge.
+    const { r } = h;
+    return r === 0 || r === dims.rows - 1;
+  };
+  let solid = new Set<string>();
+  for (const h of all) {
+    if (edgeRow(h) || rng() < 0.45) solid.add(hexKey(h));
+  }
+  // B4/S4: a wall is born at 4+ solid neighbours and survives at 4+. The square
+  // grid's B5/S4 leaves ~75% open here; B3/S3 leaves ~5%.
+  for (let step = 0; step < 4; step += 1) {
+    const next = new Set<string>();
+    for (const h of all) {
+      let n = 0;
+      for (let d = 0; d < 6; d += 1) {
+        const nb = { q: h.q + HEX_DIRECTIONS[d].q, r: h.r + HEX_DIRECTIONS[d].r };
+        if (!inBounds(nb, dims) || solid.has(hexKey(nb))) n += 1;
+      }
+      const k = hexKey(h);
+      if (edgeRow(h)) next.add(k);
+      else if (solid.has(k) ? n >= 4 : n >= 4) next.add(k);
+    }
+    solid = next;
+  }
+  return [...solid];
+}
+
+/**
+ * Blue-noise obstacle scatter. Mitchell's best-candidate rather than a full
+ * Poisson-disc sampler: no spatial grid needed, and at a few hundred cells the
+ * quadratic distance check is free.
+ */
+function compileOpen(rng: Rng, dims: GridDims): string[] {
+  const all = gridHexes(dims);
+  const chosen: HexCoord[] = [];
+  const blocked = new Set<string>();
+  const target = Math.floor(all.length * 0.12);
+  for (const h of shuffled(rng, all)) {
+    if (chosen.length >= target) break;
+    if (blocked.has(hexKey(h))) continue;
+    chosen.push(h);
+    // Minimum separation of 2: no two obstacles adjacent, which is what makes
+    // an isolated pocket impossible rather than merely unlikely.
+    blocked.add(hexKey(h));
+    for (let d = 0; d < 6; d += 1) {
+      blocked.add(hexKey({ q: h.q + HEX_DIRECTIONS[d].q, r: h.r + HEX_DIRECTIONS[d].r }));
+    }
+  }
+  return chosen.map(hexKey);
+}
+
+// ---------------------------------------------------------------------------
+
+/**
+ * Compile a place into an arena.
+ *
+ * Deterministic: the same options always produce the same battlefield, on every
+ * peer, forever. The result is transmitted rather than regenerated remotely —
+ * transcendental functions are not required to be bit-identical across
+ * JavaScript engines, so shipping the compiled arena keeps any drift cosmetic
+ * instead of turning it into a movement desync.
+ */
+export function compileBattlefield(opts: CompileBattlefieldOptions): Battlefield {
+  const dims = opts.dims ?? DEFAULT_DIMS[opts.archetype];
+  const rng = rngFor(deriveSeed(opts.seed, 'arena', opts.archetype));
+
+  let field: Battlefield = { dims };
+  if (opts.archetype === 'interior') {
+    const { walls, doors } = compileInterior(rng, dims);
+    field = { dims, walls, doors };
+  } else if (opts.archetype === 'cave') {
+    field = { dims, solid: compileCave(rng, dims) };
+  } else {
+    field = { dims, solid: compileOpen(rng, dims) };
+  }
+
+  // Prune anything the arena's main body can't reach. A cave in particular can
+  // carve a sealed bubble, and a pocket nobody can enter reads as a bug.
+  const open = openHexes(field);
+  if (open.length > 0) {
+    let best = new Set<string>();
+    const visited = new Set<string>();
+    for (const h of open) {
+      if (visited.has(hexKey(h))) continue;
+      const region = reachableFrom(h, field);
+      for (const k of region) visited.add(k);
+      if (region.size > best.size) best = region;
+    }
+    const stranded = open.filter((h) => !best.has(hexKey(h))).map(hexKey);
+    if (stranded.length > 0) {
+      field = { ...field, solid: [...(field.solid ?? []), ...stranded] };
+    }
+  }
+
+  const zones = deployZones(field, 6);
+  return {
+    ...field,
+    ...(zones ? { zones } : {}),
+    ...(opts.label ? { label: opts.label } : {}),
+    ...(opts.origin ? { origin: opts.origin } : {}),
+  };
+}
diff --git a/src/engine/atlas/index.ts b/src/engine/atlas/index.ts
new file mode 100644
index 0000000..8639e15
--- /dev/null
+++ b/src/engine/atlas/index.ts
@@ -0,0 +1,34 @@
+/**
+ * Worldgen — the pure, deterministic half of the map feature.
+ *
+ * Imported as `@/engine/atlas` rather than through the main `@/engine` barrel,
+ * so map code has one import site and combat code doesn't pull worldgen in.
+ *
+ * Everything here is a pure function of its inputs. See `purity.test.ts`, which
+ * enforces that mechanically rather than by convention.
+ */
+export {
+  mix32,
+  hashPath,
+  deriveSeed,
+  seedForPath,
+  rngFor,
+  randInt,
+  pick,
+  shuffled,
+  makeNoise3,
+  fbm3,
+  FBM_GAIN,
+  FBM_LACUNARITY,
+  type Seed,
+  type SeedKey,
+  type Noise3,
+} from './rand';
+
+export {
+  compileBattlefield,
+  reachableFrom,
+  DEFAULT_DIMS,
+  type ArenaArchetype,
+  type CompileBattlefieldOptions,
+} from './battlefield';
diff --git a/src/engine/atlas/purity.test.ts b/src/engine/atlas/purity.test.ts
new file mode 100644
index 0000000..0d06333
--- /dev/null
+++ b/src/engine/atlas/purity.test.ts
@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * The generator has to stay pure, and "we'll be careful" is not a mechanism.
+ *
+ * Worlds are addressed lazily and reproduced from a seed on every peer, so a
+ * single `Date.now()` or `Math.random()` in here doesn't fail loudly — it makes
+ * two players' maps quietly disagree, which is the hardest class of bug this
+ * feature can produce. Cheaper to forbid it than to debug it.
+ */
+const DIR = join(process.cwd(), 'src/engine/atlas');
+
+const sources = readdirSync(DIR).filter((f) => f.endsWith('.ts') && !f.endsWith('.test.ts'));
+
+const FORBIDDEN: { pattern: RegExp; why: string }[] = [
+  { pattern: /\bMath\.random\b/, why: 'randomness must be derived from the seed' },
+  { pattern: /\bDate\.now\b/, why: 'output must not depend on when it ran' },
+  { pattern: /\bnew Date\b/, why: 'output must not depend on when it ran' },
+  { pattern: /\bconsole\./, why: 'the engine emits data, never console output' },
+  { pattern: /\bsetTimeout\b|\bsetInterval\b|requestAnimationFrame/, why: 'no timers in the engine' },
+  { pattern: /\bwindow\b|\bdocument\b|localStorage/, why: 'no DOM or browser storage in the engine' },
+  { pattern: /from '@\/store|from "@\/store/, why: 'the engine must never import a store' },
+  { pattern: /from 'react|from "react/, why: 'no React in the engine' },
+];
+
+describe('src/engine/atlas stays pure', () => {
+  it('has sources to check', () => {
+    expect(sources.length).toBeGreaterThan(0);
+  });
+
+  it.each(sources)('%s contains nothing non-deterministic', (file) => {
+    const text = readFileSync(join(DIR, file), 'utf8');
+    // Strip comments so prose explaining *why* Math.random is banned doesn't
+    // trip the check that bans it.
+    const code = text.replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, '');
+    for (const { pattern, why } of FORBIDDEN) {
+      const hit = code.match(pattern);
+      expect(hit ? `${file}: ${hit[0]} — ${why}` : null).toBeNull();
+    }
+  });
+});
diff --git a/src/engine/atlas/rand.test.ts b/src/engine/atlas/rand.test.ts
new file mode 100644
index 0000000..e598176
--- /dev/null
+++ b/src/engine/atlas/rand.test.ts
@@ -0,0 +1,245 @@
+import { describe, it, expect } from 'vitest';
+import {
+  mix32,
+  hashPath,
+  deriveSeed,
+  seedForPath,
+  rngFor,
+  randInt,
+  pick,
+  shuffled,
+  makeNoise3,
+  fbm3,
+  FBM_GAIN,
+} from './rand';
+
+describe('mix32', () => {
+  it('avalanches — a one-bit input change flips about half the output bits', () => {
+    // A weak mixer here would make sibling seeds correlated, which shows up as
+    // visible repetition across a world rather than as an obvious bug.
+    let total = 0;
+    const trials = 2000;
+    for (let i = 0; i < trials; i += 1) {
+      const a = mix32(i);
+      const b = mix32(i ^ 1);
+      let diff = a ^ b;
+      let bits = 0;
+      while (diff) {
+        bits += diff & 1;
+        diff >>>= 1;
+      }
+      total += bits;
+    }
+    const mean = total / trials;
+    expect(mean).toBeGreaterThan(14);
+    expect(mean).toBeLessThan(18);
+  });
+
+  it('is a pure uint32 function', () => {
+    expect(mix32(12345)).toBe(mix32(12345));
+    expect(mix32(0)).toBeGreaterThanOrEqual(0);
+    expect(Number.isInteger(mix32(-1))).toBe(true);
+  });
+});
+
+describe('hashPath', () => {
+  it('is prefix-free — segment boundaries cannot be ambiguous', () => {
+    // Without type tags and a length prefix these collide, which would silently
+    // make two different places in the world resolve to the same place.
+    expect(hashPath(['ab', 'c'])).not.toBe(hashPath(['a', 'bc']));
+    expect(hashPath(['a', 'b'])).not.toBe(hashPath(['ab']));
+  });
+
+  it('distinguishes a number from its string form', () => {
+    expect(hashPath([12])).not.toBe(hashPath(['12']));
+  });
+
+  it('stays inside the safe-integer range', () => {
+    for (const p of [['a'], ['zzz', 9], [0], ['/P7/R3/L2/S9/B0/F-1/K4']]) {
+      const h = hashPath(p as (string | number)[]);
+      expect(Number.isSafeInteger(h)).toBe(true);
+      expect(h).toBeGreaterThanOrEqual(0);
+    }
+  });
+});
+
+describe('deriveSeed', () => {
+  it('is order-independent — a child does not depend on its siblings existing', () => {
+    // This is the whole laziness mechanism: resolving one room must not require
+    // generating the rooms beside it.
+    const root = hashPath(['world']);
+    const direct = deriveSeed(root, 'K4');
+    for (let i = 0; i < 100; i += 1) deriveSeed(root, `K${i}`);
+    expect(deriveSeed(root, 'K4')).toBe(direct);
+  });
+
+  it('gives 20000 siblings distinct seeds', () => {
+    const root = hashPath(['world']);
+    const seen = new Set<number>();
+    for (let i = 0; i < 20000; i += 1) seen.add(deriveSeed(root, 'S', i));
+    expect(seen.size).toBe(20000);
+  });
+
+  it('decorrelates adjacent siblings', () => {
+    // `parent + i` would leave neighbouring worlds visibly similar.
+    const root = hashPath(['world']);
+    const first: number[] = [];
+    for (let i = 0; i < 3000; i += 1) first.push(rngFor(deriveSeed(root, 'S', i))());
+    let cov = 0;
+    for (let i = 1; i < first.length; i += 1) cov += (first[i] - 0.5) * (first[i - 1] - 0.5);
+    // Uncorrelated uniforms have covariance 0; the variance of one is 1/12, so
+    // a correlation coefficient near zero means |cov/n| << 1/12.
+    expect(Math.abs(cov / first.length)).toBeLessThan(0.005);
+  });
+});
+
+describe('seedForPath', () => {
+  it('matches a hand-rolled fold, and ignores empty segments', () => {
+    const root = hashPath(['w']);
+    const manual = deriveSeed(deriveSeed(deriveSeed(root, 'P7'), 'R3'), 'K4');
+    expect(seedForPath(root, '/P7/R3/K4')).toBe(manual);
+    expect(seedForPath(root, 'P7/R3/K4')).toBe(manual);
+  });
+
+  it('gives a deep path a stable seed', () => {
+    const root = hashPath(['w']);
+    const p = '/P7/R3/L2/S9/B0/F-1/K4';
+    expect(seedForPath(root, p)).toBe(seedForPath(root, p));
+    expect(seedForPath(root, p)).not.toBe(seedForPath(root, '/P7/R3/L2/S9/B0/F-2/K4'));
+  });
+});
+
+describe('rngFor', () => {
+  it('is reproducible and stays in [0,1)', () => {
+    const a = Array.from({ length: 200 }, rngFor(42));
+    const b = Array.from({ length: 200 }, rngFor(42));
+    expect(a).toEqual(b);
+    for (const v of a) {
+      expect(v).toBeGreaterThanOrEqual(0);
+      expect(v).toBeLessThan(1);
+    }
+  });
+
+  it('is roughly uniform', () => {
+    const bins = new Array(10).fill(0);
+    const rng = rngFor(7);
+    for (let i = 0; i < 50000; i += 1) bins[Math.floor(rng() * 10)] += 1;
+    for (const b of bins) {
+      expect(b).toBeGreaterThan(4200);
+      expect(b).toBeLessThan(5800);
+    }
+  });
+
+  it('gives different seeds different streams', () => {
+    expect(Array.from({ length: 10 }, rngFor(1))).not.toEqual(
+      Array.from({ length: 10 }, rngFor(2)),
+    );
+  });
+});
+
+describe('helpers', () => {
+  it('randInt covers its inclusive bounds and never exceeds them', () => {
+    const rng = rngFor(3);
+    const seen = new Set<number>();
+    for (let i = 0; i < 4000; i += 1) {
+      const v = randInt(rng, 2, 5);
+      expect(v).toBeGreaterThanOrEqual(2);
+      expect(v).toBeLessThanOrEqual(5);
+      seen.add(v);
+    }
+    expect([...seen].sort()).toEqual([2, 3, 4, 5]);
+  });
+
+  it('pick never falls off the end of the array', () => {
+    // Guards the classic `rng() === 0.9999…` off-by-one.
+    const items = ['a', 'b', 'c'];
+    const rng = () => 0.999999999;
+    expect(pick(rng, items)).toBe('c');
+  });
+
+  it('shuffled permutes without mutating the input', () => {
+    const src = [1, 2, 3, 4, 5, 6, 7, 8];
+    const out = shuffled(rngFor(9), src);
+    expect(src).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
+    expect(out.slice().sort((a, b) => a - b)).toEqual(src);
+  });
+});
+
+describe('noise3', () => {
+  it('is reproducible for a seed and varies between seeds', () => {
+    const a = makeNoise3(1);
+    const b = makeNoise3(1);
+    const c = makeNoise3(2);
+    expect(a(0.3, 0.7, 1.1)).toBe(b(0.3, 0.7, 1.1));
+    expect(a(0.3, 0.7, 1.1)).not.toBe(c(0.3, 0.7, 1.1));
+  });
+
+  it('stays within roughly [-1, 1]', () => {
+    const n = makeNoise3(5);
+    const rng = rngFor(6);
+    let lo = Infinity;
+    let hi = -Infinity;
+    for (let i = 0; i < 20000; i += 1) {
+      const v = n(rng() * 50, rng() * 50, rng() * 50);
+      lo = Math.min(lo, v);
+      hi = Math.max(hi, v);
+    }
+    expect(lo).toBeGreaterThan(-1.02);
+    expect(hi).toBeLessThan(1.02);
+    // It must actually use its range, not hug zero.
+    expect(hi - lo).toBeGreaterThan(1);
+  });
+
+  it('is continuous — nearby samples give nearby values', () => {
+    const n = makeNoise3(11);
+    const rng = rngFor(12);
+    let worst = 0;
+    for (let i = 0; i < 3000; i += 1) {
+      const x = rng() * 20;
+      const y = rng() * 20;
+      const z = rng() * 20;
+      worst = Math.max(worst, Math.abs(n(x, y, z) - n(x + 1e-4, y, z)));
+    }
+    expect(worst).toBeLessThan(0.05);
+  });
+});
+
+describe('fbm3', () => {
+  it('has the PREFIX PROPERTY — adding octaves never moves existing terrain', () => {
+    // This is what makes zoom feel like zoom. With a running-sum normaliser the
+    // coarse result is rescaled every time an octave is added, and the whole
+    // landscape visibly breathes as you descend.
+    const n = makeNoise3(21);
+    const rng = rngFor(22);
+    let worstShift = 0;
+    for (let i = 0; i < 500; i += 1) {
+      const x = rng() * 10;
+      const y = rng() * 10;
+      const z = rng() * 10;
+      const coarse = fbm3(n, x, y, z, 4);
+      const fine = fbm3(n, x, y, z, 10);
+      // The added octaves can contribute at most the tail of the geometric sum.
+      const maxTail = Math.pow(FBM_GAIN, 4) / (1 - FBM_GAIN) * (1 - FBM_GAIN);
+      worstShift = Math.max(worstShift, Math.abs(fine - coarse) - maxTail);
+    }
+    expect(worstShift).toBeLessThanOrEqual(0);
+  });
+
+  it('is exactly the sum of its octaves for one octave', () => {
+    const n = makeNoise3(31);
+    const one = fbm3(n, 0.25, 0.5, 0.75, 1);
+    expect(one).toBeCloseTo(
+      n(0.25 + 0.5772156649015329, 0.5 + 1.2020569031595943, 0.75 + 2.6854520010653064) * 0.5,
+      12,
+    );
+  });
+
+  it('stays bounded as octaves grow', () => {
+    const n = makeNoise3(41);
+    const rng = rngFor(42);
+    for (let i = 0; i < 2000; i += 1) {
+      const v = fbm3(n, rng() * 30, rng() * 30, rng() * 30, 12);
+      expect(Math.abs(v)).toBeLessThan(1.5);
+    }
+  });
+});
diff --git a/src/engine/atlas/rand.ts b/src/engine/atlas/rand.ts
new file mode 100644
index 0000000..a844559
--- /dev/null
+++ b/src/engine/atlas/rand.ts
@@ -0,0 +1,345 @@
+/**
+ * Deterministic randomness for world generation.
+ *
+ * The rest of the engine takes an injected `rng: () => number`, which is the
+ * right primitive for a die roll: a *stream*, consumed in order. A world needs
+ * the opposite — **random access**. Generating the fourth building on the
+ * basement floor of a settlement must not require generating the three before
+ * it, or the first three, or the settlement's siblings.
+ *
+ * So worldgen takes an explicit `seed: number` and derives child seeds by
+ * hashing. That honours the determinism rule more strictly than the letter of
+ * it: every function here is total, order-independent, and replayable with no
+ * ambient state and no call-order coupling. {@link rngFor} still produces an
+ * ordinary `Rng` wherever the existing engine wants one.
+ *
+ * Everything in this module is pure. No DOM, no timers, no `Math.random`.
+ */
+import type { Rng } from '../dice';
+
+/** A world seed. 53 bits — the whole safe-integer range, not 32. */
+export type Seed = number;
+
+/** A path segment. Strings are names; numbers are indices. */
+export type SeedKey = string | number;
+
+// ---------------------------------------------------------------------------
+// Hashing
+// ---------------------------------------------------------------------------
+
+/**
+ * 32-bit avalanche mixer.
+ *
+ * These constants are the best-known two-round pair from Wellons' hash
+ * prospector search (bias 0.108, against 0.271 for murmur3's `fmix32`).
+ * **They are baked into every seed this app ever persists** — changing them
+ * regenerates every world in existence, so they are pinned, not tuned.
+ *
+ * `Math.imul` is a correctness requirement here, not an optimization: a double
+ * has 53 bits of mantissa, so `(0xDEADBEEF * 2654435761) | 0` loses the low
+ * bits to rounding *before* the truncation can happen and returns the wrong
+ * answer. Only multipliers below ~2^21 are safe with plain `*`.
+ */
+export function mix32(x: number): number {
+  let h = x | 0;
+  h ^= h >>> 16;
+  h = Math.imul(h, 0x21f0aaad);
+  h ^= h >>> 15;
+  h = Math.imul(h, 0xd35a2d97);
+  h ^= h >>> 15;
+  return h >>> 0;
+}
+
+const TAG_NUMBER = 0x9e3;
+const TAG_STRING = 0x85e;
+
+/**
+ * Hash a path into a 53-bit seed.
+ *
+ * The encoding is deliberately **prefix-free** — each part carries a type tag,
+ * and strings carry a length. Without that, `['ab', 'c']` and `['a', 'bc']`
+ * hash identically, which would quietly make two different places in the world
+ * *the same place*. The tags cost two multiplies per segment.
+ *
+ * 53 bits rather than 32 because birthday collisions among 32-bit seeds start
+ * around 65k entities — entirely reachable for a world with named buildings.
+ */
+export function hashPath(parts: readonly SeedKey[]): Seed {
+  let h1 = 0xdeadbeef | 0;
+  let h2 = 0x41c6ce57 | 0;
+  const absorb = (ch: number): void => {
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  };
+  for (const part of parts) {
+    if (typeof part === 'number') {
+      absorb(TAG_NUMBER);
+      const lo = part >>> 0;
+      const hi = Math.floor(part / 4294967296) >>> 0;
+      absorb(lo & 0xffff);
+      absorb(lo >>> 16);
+      absorb(hi & 0xffff);
+      absorb(hi >>> 16);
+    } else {
+      absorb(TAG_STRING);
+      absorb(part.length);
+      for (let i = 0; i < part.length; i += 1) absorb(part.charCodeAt(i));
+    }
+  }
+  h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
+  h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+  h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507);
+  h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+  return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+}
+
+/**
+ * Derive a child seed from a parent and a key.
+ *
+ * This is the whole laziness mechanism. Because it is a pure function of
+ * `(parent, key)` and never of a call order, `deriveSeed(s, 'K4')` is the same
+ * number whether or not `K0..K3` were ever generated — and adding a sibling
+ * never perturbs an existing one. That is precisely why a hand edit keyed by
+ * path survives regeneration.
+ *
+ * Never `parent + index`: for the generator families in common use, sibling
+ * states stay correlated in their low bits.
+ */
+export function deriveSeed(parent: Seed, ...key: SeedKey[]): Seed {
+  return hashPath([parent, ...key]);
+}
+
+/** Walk a `/A1/B2/C3` path into a seed, one `deriveSeed` per segment. */
+export function seedForPath(root: Seed, path: string): Seed {
+  let s = root;
+  for (const seg of path.split('/')) if (seg) s = deriveSeed(s, seg);
+  return s;
+}
+
+// ---------------------------------------------------------------------------
+// The generator
+// ---------------------------------------------------------------------------
+
+/**
+ * sfc32 — 128 bits of state, passes PractRand and BigCrush.
+ *
+ * The 128-bit state is the point. The popular 32-bit alternatives (mulberry32,
+ * splitmix32) are Weyl generators: the state advances by a fixed constant and
+ * the output is a stateless bijection of it, so **the seed is an offset into
+ * one global sequence rather than a selector between independent ones**. Every
+ * child of a world would then walk the same 4-billion-long loop, and siblings
+ * would overlap. Seeding sfc32 from a hash puts children on genuinely
+ * different cycles.
+ */
+function sfc32(a: number, b: number, c: number, d: number): Rng {
+  let s0 = a | 0;
+  let s1 = b | 0;
+  let s2 = c | 0;
+  let s3 = d | 0;
+  return function next(): number {
+    const t = ((s0 + s1) | 0) + s3 | 0;
+    s3 = (s3 + 1) | 0;
+    s0 = s1 ^ (s1 >>> 9);
+    s1 = (s2 + (s2 << 3)) | 0;
+    s2 = (s2 << 21) | (s2 >>> 11);
+    s2 = (s2 + t) | 0;
+    return (t >>> 0) / 4294967296;
+  };
+}
+
+/** Expand a seed into a warmed-up {@link Rng}. The 12 discarded outputs are
+ *  sfc32's own recommended seeding procedure, not superstition. */
+export function rngFor(seed: Seed): Rng {
+  let x = seed >>> 0 | 0;
+  const hi = Math.floor(seed / 4294967296) | 0;
+  const next = (): number => {
+    x = (x + 0x9e3779b9) | 0;
+    return mix32(x ^ hi) | 0;
+  };
+  const rng = sfc32(next(), next(), next(), next());
+  for (let i = 0; i < 12; i += 1) rng();
+  return rng;
+}
+
+/** An integer in `[lo, hi]`, inclusive. */
+export function randInt(rng: Rng, lo: number, hi: number): number {
+  return lo + Math.floor(rng() * (hi - lo + 1));
+}
+
+/** One element of a non-empty array. */
+export function pick<T>(rng: Rng, items: readonly T[]): T {
+  return items[Math.min(items.length - 1, Math.floor(rng() * items.length))];
+}
+
+/** Fisher–Yates, returning a new array. */
+export function shuffled<T>(rng: Rng, items: readonly T[]): T[] {
+  const out = items.slice();
+  for (let i = out.length - 1; i > 0; i -= 1) {
+    const j = Math.floor(rng() * (i + 1));
+    [out[i], out[j]] = [out[j], out[i]];
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Noise
+// ---------------------------------------------------------------------------
+
+/** Gustavson's 3D simplex constants. The output scale is coupled to the
+ *  gradient table and the falloff radius — they cannot be mixed between
+ *  implementations. */
+const F3 = 1 / 3;
+const G3 = 1 / 6;
+const GRAD3 = [
+  1, 1, 0, -1, 1, 0, 1, -1, 0, -1, -1, 0,
+  1, 0, 1, -1, 0, 1, 1, 0, -1, -1, 0, -1,
+  0, 1, 1, 0, -1, 1, 0, 1, -1, 0, -1, -1,
+];
+
+/**
+ * A seeded 3D simplex noise sampler.
+ *
+ * 3D specifically, sampled on a unit direction vector, because that is what
+ * makes a sphere seamless: there is no longitude to wrap and no pole to pinch,
+ * since the sphere is just a level set inside a field that fills space. It is
+ * also cheaper than 3D Perlin (4 corners rather than 8).
+ */
+export interface Noise3 {
+  (x: number, y: number, z: number): number;
+}
+
+export function makeNoise3(seed: Seed): Noise3 {
+  const rng = rngFor(deriveSeed(seed, 'noise'));
+  const p = new Uint8Array(256);
+  for (let i = 0; i < 256; i += 1) p[i] = i;
+  for (let i = 255; i > 0; i -= 1) {
+    const j = Math.floor(rng() * (i + 1));
+    const t = p[i];
+    p[i] = p[j];
+    p[j] = t;
+  }
+  const perm = new Uint8Array(512);
+  const permMod12 = new Uint8Array(512);
+  for (let i = 0; i < 512; i += 1) {
+    perm[i] = p[i & 255];
+    permMod12[i] = perm[i] % 12;
+  }
+
+  return function noise(xin: number, yin: number, zin: number): number {
+    const s = (xin + yin + zin) * F3;
+    const i = Math.floor(xin + s);
+    const j = Math.floor(yin + s);
+    const k = Math.floor(zin + s);
+    const t = (i + j + k) * G3;
+    const x0 = xin - (i - t);
+    const y0 = yin - (j - t);
+    const z0 = zin - (k - t);
+
+    let i1: number, j1: number, k1: number, i2: number, j2: number, k2: number;
+    if (x0 >= y0) {
+      if (y0 >= z0) { i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 1; k2 = 0; }
+      else if (x0 >= z0) { i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 0; k2 = 1; }
+      else { i1 = 0; j1 = 0; k1 = 1; i2 = 1; j2 = 0; k2 = 1; }
+    } else {
+      if (y0 < z0) { i1 = 0; j1 = 0; k1 = 1; i2 = 0; j2 = 1; k2 = 1; }
+      else if (x0 < z0) { i1 = 0; j1 = 1; k1 = 0; i2 = 0; j2 = 1; k2 = 1; }
+      else { i1 = 0; j1 = 1; k1 = 0; i2 = 1; j2 = 1; k2 = 0; }
+    }
+
+    const x1 = x0 - i1 + G3;
+    const y1 = y0 - j1 + G3;
+    const z1 = z0 - k1 + G3;
+    const x2 = x0 - i2 + 2 * G3;
+    const y2 = y0 - j2 + 2 * G3;
+    const z2 = z0 - k2 + 2 * G3;
+    const x3 = x0 - 1 + 3 * G3;
+    const y3 = y0 - 1 + 3 * G3;
+    const z3 = z0 - 1 + 3 * G3;
+
+    const ii = i & 255;
+    const jj = j & 255;
+    const kk = k & 255;
+    let n = 0;
+
+    let t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
+    if (t0 > 0) {
+      const g = permMod12[ii + perm[jj + perm[kk]]] * 3;
+      t0 *= t0;
+      n += t0 * t0 * (GRAD3[g] * x0 + GRAD3[g + 1] * y0 + GRAD3[g + 2] * z0);
+    }
+    let t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
+    if (t1 > 0) {
+      const g = permMod12[ii + i1 + perm[jj + j1 + perm[kk + k1]]] * 3;
+      t1 *= t1;
+      n += t1 * t1 * (GRAD3[g] * x1 + GRAD3[g + 1] * y1 + GRAD3[g + 2] * z1);
+    }
+    let t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
+    if (t2 > 0) {
+      const g = permMod12[ii + i2 + perm[jj + j2 + perm[kk + k2]]] * 3;
+      t2 *= t2;
+      n += t2 * t2 * (GRAD3[g] * x2 + GRAD3[g + 1] * y2 + GRAD3[g + 2] * z2);
+    }
+    let t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
+    if (t3 > 0) {
+      const g = permMod12[ii + 1 + perm[jj + 1 + perm[kk + 1]]] * 3;
+      t3 *= t3;
+      n += t3 * t3 * (GRAD3[g] * x3 + GRAD3[g + 1] * y3 + GRAD3[g + 2] * z3);
+    }
+    return 32 * n;
+  };
+}
+
+/**
+ * Irrational offsets applied to every noise sample.
+ *
+ * A sphere's natural axes align *exactly* with the noise lattice at the poles
+ * and the antimeridian, where a coordinate is ±1e-17 and `Math.floor` sends the
+ * two mirror points into different simplices. Measured, that shows up as a real
+ * discontinuity along the date line; an irrational shift removes it. A rational
+ * offset like 0.5 does not — it just moves the alignment.
+ *
+ * (Euler–Mascheroni, Apéry's constant, Khinchin's constant.)
+ */
+const DOMAIN_OFFSET = [0.5772156649015329, 1.2020569031595943, 2.6854520010653064] as const;
+
+/** Default fBm shape. Lacunarity is deliberately **not** 2.0: at exactly 2 each
+ *  octave's lattice is a sub-lattice of the last, so every octave is zero at the
+ *  same points and the sum shows grid ghosting. Gain 0.5 is the Hurst exponent
+ *  that matches real mountain profiles. */
+export const FBM_LACUNARITY = 1.98;
+export const FBM_GAIN = 0.5;
+
+/**
+ * Fractional Brownian motion — a sum of noise octaves.
+ *
+ * The normaliser is **fixed** at `1 / (1 - gain)` rather than the running sum of
+ * amplitudes actually used. That is what gives the *prefix property*: the
+ * 8-octave value is exactly the first 8 terms of the 15-octave value, so zooming
+ * in **adds detail without moving terrain that is already on screen**. Dividing
+ * by the running sum instead rescales the coarse result by ~0.4% every time an
+ * octave is added — the same order as the detail being added, and visible as the
+ * whole landscape breathing as you zoom.
+ */
+export function fbm3(
+  noise: Noise3,
+  x: number,
+  y: number,
+  z: number,
+  octaves: number,
+  gain: number = FBM_GAIN,
+  lacunarity: number = FBM_LACUNARITY,
+): number {
+  let freq = 1;
+  let amp = 1;
+  let sum = 0;
+  for (let i = 0; i < octaves; i += 1) {
+    sum += amp * noise(
+      x * freq + DOMAIN_OFFSET[0],
+      y * freq + DOMAIN_OFFSET[1],
+      z * freq + DOMAIN_OFFSET[2],
+    );
+    freq *= lacunarity;
+    amp *= gain;
+  }
+  return sum * (1 - gain);
+}
diff --git a/src/engine/combat.ts b/src/engine/combat.ts
index 25f9605..b0775c9 100644
--- a/src/engine/combat.ts
+++ b/src/engine/combat.ts
@@ -31,6 +31,10 @@ import {
 } from './effects';
 import {
   closestReachableTo,
+  compileTerrain,
+  dirIndex,
+  edgeBlocks,
+  hasLineOfSight,
   hexDistance,
   hexEquals,
   hexLineDraw,
@@ -38,6 +42,8 @@ import {
   reachableHexes,
   stepAway,
   stepToward,
+  type GridDims,
+  type Terrain,
 } from './hex';
 import type { AdvantageMode } from '@/types';
 
@@ -81,6 +87,27 @@ export interface RoundStep {
 // Small pure utilities
 // ---------------------------------------------------------------------------
 
+/**
+ * The arena this fight uses. A fight staged from the atlas carries its own
+ * {@link Battlefield}; every other fight gets the default open rectangle, so
+ * omitting it reproduces the game's original behaviour exactly.
+ */
+function dimsOf(state: CombatState): GridDims {
+  return state.battlefield?.dims ?? BATTLE_GRID;
+}
+
+/**
+ * This arena's walls/doors/solid hexes, compiled for lookup — or `undefined` for
+ * an open field, which short-circuits every structure check downstream.
+ *
+ * Recompiled per call rather than cached: a fully-walled board is ~100 entries,
+ * so this costs microseconds, and a cache would be module state the pure engine
+ * is better off without.
+ */
+function terrainOf(state: CombatState): Terrain | undefined {
+  return compileTerrain(state.battlefield);
+}
+
 /** Structured deep clone of combat state, so resolution never mutates input. */
 function cloneState(state: CombatState): CombatState {
   return {
@@ -119,11 +146,30 @@ function pushLog(
   tone?: CombatLogEntry['tone'],
 ): void {
   _logSeq += 1;
-  // `ts` is left at 0 to keep the engine deterministic; callers (the store/UI)
-  // can stamp wall-clock time on ingest if they want chronological ordering.
-  log.push({ id: `log_${_logSeq}_${Math.random().toString(36).slice(2, 8)}`, round, text, tone, ts: 0 });
+  // `ts` is left at 0 and the id is derived from a counter, not `Math.random`,
+  // so a replayed round produces byte-identical output. "The engine is
+  // deterministic" has to be true without an asterisk once a sold map's
+  // verification story is built on top of it.
+  log.push({ id: `log_${round}_${_logSeq}`, round, text, tone, ts: 0 });
+}
+
+/** Reset the log-id counter — called when a fresh combat begins so ids restart
+ *  from a known point rather than drifting up across a whole session. */
+export function resetLogSequence(): void {
+  _logSeq = 0;
 }
 
+/**
+ * Whether a combatant occupies its hex for movement purposes.
+ *
+ * One predicate, imported everywhere, because three call sites used to disagree:
+ * the engine let a mover walk *onto* an unconscious body (`currentHP > 0`) while
+ * the store and the board both blocked it (`!isDead`) — and the board's
+ * hex→combatant map is last-writer-wins, so the stacked unit simply vanished.
+ * A downed body still blocks; a corpse doesn't.
+ */
+export const OCCUPIES = (c: { isDead: boolean }): boolean => !c.isDead;
+
 const find = (state: CombatState, id?: string | null): Combatant | undefined =>
   id ? state.combatants.find((c) => c.id === id) : undefined;
 
@@ -468,13 +514,16 @@ export function isTargetInRange(
   source: Combatant,
   target: Combatant | undefined,
   range: string | undefined,
+  terrain?: Terrain,
 ): boolean {
   if (!source || !target) return false;
   if (range === 'Self') return target.team === source.team;
   const max = range ? RANGE_TO_HEX_DISTANCE[range] : undefined;
   if (max === undefined) return false;
-  if (max === Infinity) return true;
-  return hexDistance(source.position, target.position) <= max;
+  if (max !== Infinity && hexDistance(source.position, target.position) > max) return false;
+  // Walls beat range: you cannot strike, or shoot, through a wall you can't see
+  // past. On an open field (no terrain) this is always true, so nothing changes.
+  return hasLineOfSight(source.position, target.position, terrain);
 }
 
 /** True when a usable only carries supportive (ally-targeting) effects. */
@@ -536,13 +585,16 @@ export function getAOETargets(
   if (!primary || !aoe || aoe === 'Single Target') return [primary];
 
   const supportive = isSupportive(data);
+  const terrain = terrainOf(state);
   const targets: Combatant[] = [];
 
   // Area effects are team-agnostic: a blast catches allies and enemies alike.
   const eligible = (c: Combatant): boolean => {
     if (c.currentHP <= 0 && !c.isUnconscious) return false; // removed from the fight
     if (!supportive && c.isUnconscious) return false; // damage spares the downed
-    return true;
+    // A blast fills the room it goes off in, not the one next door — anyone the
+    // impact point can't see is behind a wall and is spared.
+    return hasLineOfSight(primary.position, c.position, terrain);
   };
 
   if (aoe.includes('AOE')) {
@@ -590,10 +642,12 @@ function moveTarget(
   distance: number,
 ): MoveOutcome {
   const from = { ...target.position };
+  const dims = dimsOf(state);
+  const terrain = terrainOf(state);
 
   const occupied = (h: HexCoord): boolean =>
     state.combatants.some(
-      (c) => c.id !== target.id && c.id !== source.id && c.currentHP > 0 && hexEquals(c.position, h),
+      (c) => c.id !== target.id && c.id !== source.id && OCCUPIES(c) && hexEquals(c.position, h),
     );
 
   if (direction === 'Towards' && hexDistance(target.position, source.position) <= 1) {
@@ -615,7 +669,14 @@ function moveTarget(
       next = stepAway(cursor, source.position);
     }
     if (hexEquals(next, cursor)) break;
-    if (!inBounds(next, BATTLE_GRID)) {
+    // A shove stops at a wall exactly as it stops at the grid edge — otherwise
+    // forced movement is the one way to put a combatant through solid stone.
+    const d = dirIndex(cursor, next);
+    if (d < 0 || edgeBlocks(terrain, cursor, d)) {
+      blockedReason = 'boundary';
+      break;
+    }
+    if (!inBounds(next, dims) || (terrain && terrain.solid.has(`${next.q},${next.r}`))) {
       blockedReason = 'boundary';
       break;
     }
@@ -1384,7 +1445,7 @@ export function rollInitiativeForRound(
 function blockedBy(state: CombatState, mover: Combatant): (h: HexCoord) => boolean {
   return (h: HexCoord) =>
     state.combatants.some(
-      (c) => c.id !== mover.id && c.currentHP > 0 && hexEquals(c.position, h),
+      (c) => c.id !== mover.id && OCCUPIES(c) && hexEquals(c.position, h),
     );
 }
 
@@ -1424,7 +1485,14 @@ function resolveMove(
     return;
   }
 
-  const dest = closestReachableTo(source.position, goal, MOVE_RANGE, blocked, BATTLE_GRID);
+  const dest = closestReachableTo(
+    source.position,
+    goal,
+    MOVE_RANGE,
+    blocked,
+    dimsOf(state),
+    terrainOf(state),
+  );
 
   // When approaching a specific combatant, don't end on top of it: if the closest
   // reachable hex is the target's own hex, fall back toward an adjacent hex.
@@ -1464,7 +1532,13 @@ function resolveFlee(
   // nearest safe spot the move allowance can reach, even if it means sidestepping.
   let best = source.position;
   let bestD = hexDistance(source.position, target.position);
-  for (const c of reachableHexes(source.position, MOVE_RANGE, blocked, BATTLE_GRID)) {
+  for (const c of reachableHexes(
+    source.position,
+    MOVE_RANGE,
+    blocked,
+    dimsOf(state),
+    terrainOf(state),
+  )) {
     const d = hexDistance(c, target.position);
     if (d > bestD) {
       bestD = d;
@@ -1500,7 +1574,14 @@ function resolveChase(
   }
 
   const blocked = blockedBy(state, source);
-  const dest = closestReachableTo(source.position, target.position, MOVE_RANGE, blocked, BATTLE_GRID);
+  const dest = closestReachableTo(
+    source.position,
+    target.position,
+    MOVE_RANGE,
+    blocked,
+    dimsOf(state),
+    terrainOf(state),
+  );
   // Don't end on top of the target — fall back to holding if the only closer hex
   // is the target's own.
   const finalDest = hexEquals(dest, target.position) ? source.position : dest;
@@ -1575,9 +1656,14 @@ function resolveUsable(
     return;
   }
 
-  if (!isTargetInRange(source, target, data.range)) {
-    pushLog(log, round, `${source.name} tries to use ${name}, but ${target?.name ?? 'the target'} is out of range.`, 'muted');
-    results.push({ kind: 'info', text: `Out of range`, targetId: target?.id });
+  const terrain = terrainOf(state);
+  if (!isTargetInRange(source, target, data.range, terrain)) {
+    // Distinguish the two failures — "out of range" for a target the caster
+    // simply can't reach, "behind cover" for one a wall is in the way of.
+    const unseen = target != null && !hasLineOfSight(source.position, target.position, terrain);
+    const why = unseen ? 'behind cover' : 'out of range';
+    pushLog(log, round, `${source.name} tries to use ${name}, but ${target?.name ?? 'the target'} is ${why}.`, 'muted');
+    results.push({ kind: 'info', text: unseen ? 'No line of sight' : 'Out of range', targetId: target?.id });
     return;
   }
 
@@ -1825,8 +1911,15 @@ export function resolveAction(
         pushLog(log, round, `${source.name} tries to attack, but ${target.name} is down.`, 'muted');
         break;
       }
-      if (!isTargetInRange(source, target, weapon.range)) {
-        pushLog(log, round, `${source.name} tries to attack, but ${target.name} is out of range.`, 'muted');
+      const attackTerrain = terrainOf(state);
+      if (!isTargetInRange(source, target, weapon.range, attackTerrain)) {
+        const unseen = !hasLineOfSight(source.position, target.position, attackTerrain);
+        pushLog(
+          log,
+          round,
+          `${source.name} tries to attack, but ${target.name} is ${unseen ? 'behind cover' : 'out of range'}.`,
+          'muted',
+        );
         break;
       }
       const usesAmmo = typeof weapon.clipSize === 'number' && weapon.clipSize > 0;
diff --git a/src/engine/combatTerrain.test.ts b/src/engine/combatTerrain.test.ts
new file mode 100644
index 0000000..a8c0cad
--- /dev/null
+++ b/src/engine/combatTerrain.test.ts
@@ -0,0 +1,208 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import type { Battlefield, Combatant, CombatState, ResolvedAction, SkillNode } from '@/types';
+import { isTargetInRange, resolveAction, resetLogSequence } from './combat';
+import { compileTerrain, edgeId, hexKey } from './hex';
+import { setActiveCatalog, buildActiveCatalog, resetActiveCatalog } from '@/data/skillTree';
+
+const at = (q: number, r: number) => ({ q, r });
+
+const mkCombatant = (o: Partial<Combatant> & { id: string }): Combatant => ({
+  peerId: null,
+  name: o.id,
+  team: 'player',
+  position: at(0, 0),
+  initiativeBonus: 0,
+  maxHP: 20,
+  maxMP: 5,
+  maxSP: 5,
+  currentHP: 20,
+  currentMP: 5,
+  currentSP: 5,
+  ac: 10,
+  statusEffects: [],
+  isUnconscious: false,
+  isDead: false,
+  deathSaves: { successes: 0, failures: 0 },
+  ...o,
+});
+
+const mkState = (combatants: Combatant[], battlefield?: Battlefield): CombatState => ({
+  isActive: true,
+  phase: 'declare',
+  round: 1,
+  battlefield,
+  combatants,
+  declaredActions: {},
+  lockedActions: {},
+  resolutionQueue: [],
+  activeResolutionIndex: -1,
+  log: [],
+});
+
+const move = (sourceId: string, targetHex: { q: number; r: number }): ResolvedAction => ({
+  actionIndex: 0,
+  actionType: 'Move',
+  targetHex,
+  sourceId,
+  sourceTeam: 'player',
+  initiative: 10,
+});
+
+const posOf = (state: CombatState, id: string) => state.combatants.find((c) => c.id === id)!.position;
+
+describe('engine log ids are deterministic', () => {
+  it('replaying the same action twice produces identical log ids', () => {
+    // The engine used to mix Math.random into every log id, which made "combat
+    // is deterministic given a seed" quietly untrue — a bad foundation for a
+    // sold map whose whole verification story is reproducibility.
+    const hero = mkCombatant({ id: 'hero', position: at(0, 0) });
+    const state = mkState([hero]);
+    resetLogSequence();
+    const a = resolveAction(state, move('hero', at(4, 0))).log.map((l) => l.id);
+    resetLogSequence();
+    const b = resolveAction(state, move('hero', at(4, 0))).log.map((l) => l.id);
+
+    expect(a.length).toBeGreaterThan(0);
+    expect(b).toEqual(a);
+    expect(a[0]).toMatch(/^log_\d+_\d+$/);
+  });
+});
+
+describe('battlefield dimensions', () => {
+  it('confines movement to a custom battlefield rather than the default arena', () => {
+    // A cramped 4x4 room: a move aimed well outside it must stop at its edge.
+    const hero = mkCombatant({ id: 'hero', position: at(0, 0) });
+    const state = mkState([hero], { dims: { cols: 4, rows: 4 } });
+    const { state: after } = resolveAction(state, move('hero', at(15, 0)));
+    expect(posOf(after, 'hero').q).toBeLessThanOrEqual(3);
+  });
+
+  it('still uses the default arena when no battlefield is supplied', () => {
+    const hero = mkCombatant({ id: 'hero', position: at(0, 0) });
+    const { state: after } = resolveAction(mkState([hero]), move('hero', at(15, 0)));
+    expect(posOf(after, 'hero').q).toBeGreaterThan(3);
+  });
+});
+
+describe('walls block movement', () => {
+  it('a Move cannot cross a walled border', () => {
+    const hero = mkCombatant({ id: 'hero', position: at(2, 2) });
+    // Seal the hex completely: the hero has nowhere to go.
+    const walls = Array.from({ length: 6 }, (_, d) => edgeId(at(2, 2), d));
+    const state = mkState([hero], { dims: { cols: 8, rows: 8 }, walls });
+    const { state: after, log } = resolveAction(state, move('hero', at(6, 2)));
+    expect(posOf(after, 'hero')).toEqual(at(2, 2));
+    expect(log.map((l) => l.text).join(' ')).toContain('cannot move');
+  });
+
+  it('a Move routes around a wall to reach the far side', () => {
+    const hero = mkCombatant({ id: 'hero', position: at(2, 2) });
+    const goal = at(3, 2);
+    const state = mkState([hero], {
+      dims: { cols: 8, rows: 8 },
+      walls: [edgeId(at(2, 2), 0)], // only the direct border is walled
+    });
+    const { state: after } = resolveAction(state, move('hero', goal));
+    expect(posOf(after, 'hero')).toEqual(goal);
+  });
+
+  it('a solid hex is not a legal destination', () => {
+    const hero = mkCombatant({ id: 'hero', position: at(2, 2) });
+    const pillar = at(3, 2);
+    const state = mkState([hero], { dims: { cols: 8, rows: 8 }, solid: [hexKey(pillar)] });
+    const { state: after } = resolveAction(state, move('hero', pillar));
+    expect(posOf(after, 'hero')).not.toEqual(pillar);
+  });
+});
+
+describe('line of sight gates targeting', () => {
+  const hero = mkCombatant({ id: 'hero', position: at(2, 2) });
+  const foe = mkCombatant({ id: 'foe', team: 'npc', position: at(3, 2) });
+  const wall = compileTerrain({ dims: { cols: 8, rows: 8 }, walls: [edgeId(at(2, 2), 0)] });
+
+  it('a target in range but behind a wall is not targetable', () => {
+    expect(isTargetInRange(hero, foe, 'Melee')).toBe(true);
+    expect(isTargetInRange(hero, foe, 'Melee', wall)).toBe(false);
+  });
+
+  it('an open door restores the shot; a closed one does not', () => {
+    const id = String(edgeId(at(2, 2), 0));
+    const open = compileTerrain({ dims: { cols: 8, rows: 8 }, doors: { [id]: 'open' } });
+    const shut = compileTerrain({ dims: { cols: 8, rows: 8 }, doors: { [id]: 'locked' } });
+    expect(isTargetInRange(hero, foe, 'Melee', open)).toBe(true);
+    expect(isTargetInRange(hero, foe, 'Melee', shut)).toBe(false);
+  });
+
+  it('unbounded "Battlefield" range still respects walls', () => {
+    expect(isTargetInRange(hero, foe, 'Battlefield')).toBe(true);
+    expect(isTargetInRange(hero, foe, 'Battlefield', wall)).toBe(false);
+  });
+
+  it('"Self" is a team check and is never gated by geometry', () => {
+    const ally = mkCombatant({ id: 'ally', position: at(7, 7) });
+    expect(isTargetInRange(hero, ally, 'Self', wall)).toBe(true);
+  });
+});
+
+describe('forced movement respects walls', () => {
+  // Forced movement walks its OWN step loop rather than going through
+  // reachableHexes, so it is the one path that would silently keep shoving
+  // combatants through solid stone if terrain weren't threaded into it.
+  const SHOVE_NODE = {
+    id: 'shove-node',
+    x: 0,
+    y: 0,
+    label: 'Shove',
+    description: '',
+    isCenter: false,
+    linkedItem: {
+      id: 'shove',
+      type: 'Ability',
+      name: 'Shove',
+      description: '',
+      range: 'Melee',
+      aoe: 'Single Target',
+      hitType: 'Auto Hit',
+      combatUse: true,
+      // `rows` is the engine's hop count for a shove (see applyEffect's Move Target).
+      effects: [{ id: 'e1', type: 'Move Target', direction: 'Away From', rows: 3 }],
+    },
+  } as unknown as SkillNode;
+
+  const shove = (): ResolvedAction => ({
+    actionIndex: 0,
+    actionType: 'Use Ability',
+    actionId: 'shove-node',
+    sourceId: 'shover',
+    targetId: 'victim',
+    sourceTeam: 'player',
+    initiative: 10,
+  });
+
+  const runShove = (battlefield: Battlefield) => {
+    setActiveCatalog(buildActiveCatalog({ nodes: [SHOVE_NODE], edges: [], worldItems: {} }, 'extend'));
+    const shover = mkCombatant({ id: 'shover', position: at(1, 2) });
+    const victim = mkCombatant({ id: 'victim', team: 'npc', position: at(2, 2) });
+    return resolveAction(mkState([shover, victim], battlefield), shove(), () => 0.5);
+  };
+
+  afterEach(() => resetActiveCatalog());
+
+  it('pushes freely across open ground', () => {
+    const { state } = runShove({ dims: { cols: 8, rows: 8 } });
+    expect(posOf(state, 'victim').q).toBeGreaterThan(2);
+  });
+
+  it('stops at a wall instead of shoving through solid stone', () => {
+    const { state } = runShove({
+      dims: { cols: 8, rows: 8 },
+      walls: [edgeId(at(2, 2), 0)], // wall immediately behind the victim
+    });
+    expect(posOf(state, 'victim')).toEqual(at(2, 2));
+  });
+
+  it('stops at a solid hex', () => {
+    const { state } = runShove({ dims: { cols: 8, rows: 8 }, solid: [hexKey(at(3, 2))] });
+    expect(posOf(state, 'victim')).toEqual(at(2, 2));
+  });
+});
diff --git a/src/engine/hex.ts b/src/engine/hex.ts
index 66f2908..cf0ea8e 100644
--- a/src/engine/hex.ts
+++ b/src/engine/hex.ts
@@ -4,17 +4,16 @@
  * Coordinates are axial `{q, r}`. All functions here are pure and deterministic;
  * they back both the engine's positioning rules and the isometric board's layout.
  */
-import type { HexCoord } from '@/types';
+import type { HexCoord, GridDims, Battlefield, DoorState } from '@/types';
 
-export interface GridDims {
-  cols: number;
-  rows: number;
-}
+export type { GridDims };
 
 export const hexKey = (c: HexCoord): string => `${c.q},${c.r}`;
 export const hexEquals = (a: HexCoord, b: HexCoord): boolean => a.q === b.q && a.r === b.r;
 
-/** The six axial neighbor directions (pointy-top). */
+/** The six axial neighbor directions (pointy-top). Ordered so that direction `d`
+ *  and direction `(d + 3) % 6` are exact opposites — the edge-ownership scheme
+ *  below depends on that pairing. */
 export const HEX_DIRECTIONS: readonly HexCoord[] = [
   { q: 1, r: 0 },
   { q: 1, r: -1 },
@@ -24,10 +23,138 @@ export const HEX_DIRECTIONS: readonly HexCoord[] = [
   { q: 0, r: 1 },
 ];
 
+/** The direction index from `from` to an adjacent `to`, or -1 if not adjacent. */
+export function dirIndex(from: HexCoord, to: HexCoord): number {
+  const dq = to.q - from.q;
+  const dr = to.r - from.r;
+  for (let i = 0; i < 6; i += 1) {
+    if (HEX_DIRECTIONS[i].q === dq && HEX_DIRECTIONS[i].r === dr) return i;
+  }
+  return -1;
+}
+
 export function hexNeighbors(c: HexCoord): HexCoord[] {
   return HEX_DIRECTIONS.map((d) => ({ q: c.q + d.q, r: c.r + d.r }));
 }
 
+// ---------------------------------------------------------------------------
+// Hex edges — where walls live
+// ---------------------------------------------------------------------------
+
+/**
+ * The greatest magnitude an axial coordinate may reach and still get a unique
+ * {@link edgeId}. A battlefield that wide would hold ~1M hexes, so this is far
+ * beyond any real board; it exists so the packing has a stated contract.
+ *
+ * The packed fields are twice this wide, which matters: naming an edge first
+ * normalizes to the hex that *owns* it, and that can step one hex further out
+ * than the caller's own coordinate. The headroom means a hex at the very limit
+ * still resolves without wrapping into a different edge's id.
+ */
+export const EDGE_COORD_LIMIT = 512;
+const EDGE_FIELD_BIAS = EDGE_COORD_LIMIT * 2;
+
+/**
+ * A stable integer id for the border between two adjacent hexes.
+ *
+ * Each hex **owns** three of its six edges — directions 0, 1, 2 (E, NE, NW) —
+ * and delegates the other three to the neighbour on that side, which owns the
+ * same border from its own perspective. Because `HEX_DIRECTIONS` is ordered so
+ * `opposite(d) === (d + 3) % 6`, normalizing a high direction is just "step to
+ * the neighbour, then subtract 3". Both hexes therefore agree on one id, which
+ * is what lets a wall be stored once and block movement in both directions.
+ *
+ * The result is a plain number (not a string) because this sits in the innermost
+ * loop of every pathfinding call, where a `Set<number>` probe beats allocating a
+ * key string per neighbour.
+ */
+export function edgeId(c: HexCoord, direction: number): number {
+  let q = c.q;
+  let r = c.r;
+  let side = direction;
+  if (side >= 3) {
+    const v = HEX_DIRECTIONS[side];
+    q += v.q;
+    r += v.r;
+    side -= 3;
+  }
+  return ((q + EDGE_FIELD_BIAS) << 14) | ((r + EDGE_FIELD_BIAS) << 3) | side;
+}
+
+/**
+ * A {@link Battlefield}'s structure compiled into lookups the engine can probe
+ * in constant time. Built once per resolution by {@link compileTerrain}; the
+ * wire/persisted form stays plain JSON-safe arrays.
+ */
+export interface Terrain {
+  walls: ReadonlySet<number>;
+  doors: ReadonlyMap<number, DoorState>;
+  solid: ReadonlySet<string>;
+}
+
+/**
+ * Compile a {@link Battlefield}'s JSON arrays into {@link Terrain} lookups.
+ * Returns `undefined` for a battlefield with no structure at all, so every
+ * downstream check short-circuits on a plain open arena.
+ */
+export function compileTerrain(field: Battlefield | undefined): Terrain | undefined {
+  if (!field) return undefined;
+  const walls = new Set<number>();
+  for (const w of field.walls ?? []) if (Number.isFinite(w)) walls.add(w);
+  const doors = new Map<number, DoorState>();
+  for (const [k, state] of Object.entries(field.doors ?? {})) {
+    const id = Number(k);
+    if (Number.isFinite(id)) doors.set(id, state);
+  }
+  const solid = new Set<string>(field.solid ?? []);
+  if (walls.size === 0 && doors.size === 0 && solid.size === 0) return undefined;
+  return { walls, doors, solid };
+}
+
+/**
+ * Whether the border on `direction` from `hex` stops movement or sight. A wall
+ * always blocks; a door blocks unless it is open.
+ */
+export function edgeBlocks(terrain: Terrain | undefined, hex: HexCoord, direction: number): boolean {
+  if (!terrain) return false;
+  const id = edgeId(hex, direction);
+  if (terrain.walls.has(id)) return true;
+  const door = terrain.doors.get(id);
+  return door !== undefined && door !== 'open';
+}
+
+/** Whether a whole hex is impassable terrain (a pillar, a pit, deep water). */
+export function hexIsSolid(terrain: Terrain | undefined, hex: HexCoord): boolean {
+  return terrain ? terrain.solid.has(hexKey(hex)) : false;
+}
+
+/**
+ * Whether `a` can see `b` — false when a wall (or a shut door) lies across the
+ * hex line between them.
+ *
+ * Deliberately **permissive**: {@link hexLineDraw}'s rounding is not symmetric,
+ * so A can have line of sight to B while B does not have it back to A. Rather
+ * than pick an arbitrary winner we check both directions and grant sight if
+ * either path is clear — players forgive "they shouldn't have seen me" far more
+ * readily than "I can't shoot the thing I'm looking at".
+ */
+export function hasLineOfSight(a: HexCoord, b: HexCoord, terrain: Terrain | undefined): boolean {
+  if (!terrain || terrain.walls.size + terrain.doors.size === 0) return true;
+  return clearPath(a, b, terrain) || clearPath(b, a, terrain);
+}
+
+function clearPath(from: HexCoord, to: HexCoord, terrain: Terrain): boolean {
+  const path = hexLineDraw(from, to);
+  for (let i = 0; i < path.length - 1; i += 1) {
+    const d = dirIndex(path[i], path[i + 1]);
+    // A line that skips a hex can't be checked edge-by-edge; treat it as clear
+    // here and let the other direction decide.
+    if (d < 0) continue;
+    if (edgeBlocks(terrain, path[i], d)) return false;
+  }
+  return true;
+}
+
 /** Number of single-step moves between two hexes. */
 export function hexDistance(a: HexCoord, b: HexCoord): number {
   const dq = a.q - b.q;
@@ -133,12 +260,32 @@ export function gridHexes(dims: GridDims): HexCoord[] {
 }
 
 /**
- * Distinct starting hexes for a team, centered horizontally and placed a few rows
- * to either side of the midline (players below, enemies above) — leaving an open
- * gap between the lines instead of pinning them to the back rows. The GM can drag
- * everyone elsewhere during the setup phase. Returns exactly `count` hexes.
+ * Distinct starting hexes for a team.
+ *
+ * With explicit `zones` — which a map-derived battlefield supplies, nominating
+ * e.g. the two entrances of a ruin — the team simply draws from its own list.
+ * That is the only workable answer on an irregular map, where the midline rows
+ * may lie inside a wall or outside the cave entirely.
+ *
+ * Without them, the classic geometry applies: centered horizontally, a few rows
+ * to either side of the midline (players below, enemies above), leaving an open
+ * gap between the lines rather than pinning them to the back rows. Note this
+ * reserves up to 8 rows, which is most of a small board — another reason a
+ * generated interior should nominate its own zones. The GM can drag everyone
+ * elsewhere during the setup phase.
+ *
+ * Returns at most `count` hexes (fewer only when a supplied zone is smaller than
+ * the team; the caller places any overflow).
  */
-export function deployHexes(team: 'player' | 'npc', count: number, dims: GridDims): HexCoord[] {
+export function deployHexes(
+  team: 'player' | 'npc',
+  count: number,
+  dims: GridDims,
+  zones?: Battlefield['zones'],
+): HexCoord[] {
+  const zone = zones?.[team];
+  if (zone && zone.length > 0) return zone.slice(0, count).map((h) => ({ q: h.q, r: h.r }));
+
   const mid = Math.floor(dims.rows / 2);
   // Two-row gap around the midline; rows fan outward from there if more are needed.
   const rows =
@@ -164,15 +311,21 @@ export function hexToPixel(c: HexCoord, size: number): { x: number; y: number }
 }
 
 /**
- * Open hexes reachable from `from` within `maxSteps`, respecting grid bounds and
- * a `blocked` predicate (e.g. hexes occupied by other combatants). Excludes
+ * Open hexes reachable from `from` within `maxSteps`, respecting grid bounds, a
+ * `blocked` predicate (e.g. hexes occupied by other combatants), and — when a
+ * battlefield has structure — walls, shut doors, and solid hexes. Excludes
  * `from` itself.
+ *
+ * `blocked` and `terrain` answer different questions on purpose: a *body*
+ * blocks a hex, a *wall* blocks a border. Omitting `terrain` gives exactly the
+ * open-arena behaviour the game has always had.
  */
 export function reachableHexes(
   from: HexCoord,
   maxSteps: number,
   blocked: (c: HexCoord) => boolean,
   dims: GridDims,
+  terrain?: Terrain,
 ): HexCoord[] {
   const seen = new Set<string>([hexKey(from)]);
   const out: HexCoord[] = [];
@@ -180,9 +333,15 @@ export function reachableHexes(
   for (let step = 0; step < maxSteps; step += 1) {
     const next: HexCoord[] = [];
     for (const c of frontier) {
-      for (const n of hexNeighbors(c)) {
+      // Walk directions by index rather than via hexNeighbors: naming the edge
+      // between two hexes requires the direction, which the neighbour list drops.
+      for (let d = 0; d < 6; d += 1) {
+        if (edgeBlocks(terrain, c, d)) continue;
+        const v = HEX_DIRECTIONS[d];
+        const n = { q: c.q + v.q, r: c.r + v.r };
         const k = hexKey(n);
         if (seen.has(k) || !inBounds(n, dims) || blocked(n)) continue;
+        if (terrain?.solid.has(k)) continue;
         seen.add(k);
         out.push(n);
         next.push(n);
@@ -204,10 +363,11 @@ export function closestReachableTo(
   maxSteps: number,
   blocked: (c: HexCoord) => boolean,
   dims: GridDims,
+  terrain?: Terrain,
 ): HexCoord {
   let best = from;
   let bestD = hexDistance(from, goal);
-  for (const c of reachableHexes(from, maxSteps, blocked, dims)) {
+  for (const c of reachableHexes(from, maxSteps, blocked, dims, terrain)) {
     const d = hexDistance(c, goal);
     if (d < bestD) {
       bestD = d;
diff --git a/src/engine/hexTerrain.test.ts b/src/engine/hexTerrain.test.ts
new file mode 100644
index 0000000..465daa3
--- /dev/null
+++ b/src/engine/hexTerrain.test.ts
@@ -0,0 +1,245 @@
+import { describe, it, expect } from 'vitest';
+import {
+  HEX_DIRECTIONS,
+  dirIndex,
+  edgeId,
+  compileTerrain,
+  edgeBlocks,
+  hexIsSolid,
+  hasLineOfSight,
+  reachableHexes,
+  closestReachableTo,
+  deployHexes,
+  hexKey,
+  EDGE_COORD_LIMIT,
+} from './hex';
+import type { Battlefield, HexCoord } from '@/types';
+
+const DIMS = { cols: 8, rows: 8 };
+const never = () => false;
+const at = (q: number, r: number): HexCoord => ({ q, r });
+const step = (c: HexCoord, d: number): HexCoord => ({
+  q: c.q + HEX_DIRECTIONS[d].q,
+  r: c.r + HEX_DIRECTIONS[d].r,
+});
+
+describe('dirIndex', () => {
+  it('recovers the direction between adjacent hexes', () => {
+    const origin = at(3, 3);
+    for (let d = 0; d < 6; d += 1) {
+      expect(dirIndex(origin, step(origin, d))).toBe(d);
+    }
+  });
+
+  it('returns -1 for hexes that are not adjacent', () => {
+    expect(dirIndex(at(0, 0), at(0, 0))).toBe(-1);
+    expect(dirIndex(at(0, 0), at(3, 0))).toBe(-1);
+  });
+});
+
+describe('edgeId', () => {
+  it('gives both hexes sharing a border the SAME id', () => {
+    // This is the whole point of edge ownership: a wall stored once must block
+    // movement in both directions.
+    const c = at(2, 3);
+    for (let d = 0; d < 6; d += 1) {
+      const n = step(c, d);
+      expect(edgeId(c, d)).toBe(edgeId(n, (d + 3) % 6));
+    }
+  });
+
+  it('is injective across a realistic board — no two borders alias', () => {
+    const ids = new Set<number>();
+    let borders = 0;
+    for (let q = -20; q <= 20; q += 1) {
+      for (let r = -20; r <= 20; r += 1) {
+        for (let d = 0; d < 3; d += 1) {
+          ids.add(edgeId(at(q, r), d));
+          borders += 1;
+        }
+      }
+    }
+    expect(ids.size).toBe(borders);
+  });
+
+  it('stays a non-negative safe integer at the documented coordinate limit', () => {
+    // Naming an edge normalizes to the hex that owns it, which can sit one step
+    // further out than the caller — the packing must not wrap at the boundary.
+    const lim = EDGE_COORD_LIMIT;
+    const corners = [at(lim, lim), at(-lim, -lim), at(lim, -lim), at(-lim, lim)];
+    const ids = new Set<number>();
+    for (const c of corners) {
+      for (let d = 0; d < 6; d += 1) {
+        const id = edgeId(c, d);
+        expect(Number.isSafeInteger(id)).toBe(true);
+        expect(id).toBeGreaterThanOrEqual(0);
+        ids.add(id);
+      }
+    }
+    // Four far-apart hexes share no borders, so all 24 ids must be distinct.
+    expect(ids.size).toBe(24);
+  });
+});
+
+describe('compileTerrain', () => {
+  it('returns undefined for an open arena so every check short-circuits', () => {
+    expect(compileTerrain(undefined)).toBeUndefined();
+    expect(compileTerrain({ dims: DIMS })).toBeUndefined();
+    expect(compileTerrain({ dims: DIMS, walls: [], solid: [], doors: {} })).toBeUndefined();
+  });
+
+  it('parses JSON-safe door keys back into numeric edge ids', () => {
+    const id = edgeId(at(1, 1), 0);
+    const t = compileTerrain({ dims: DIMS, doors: { [String(id)]: 'closed' } });
+    expect(t?.doors.get(id)).toBe('closed');
+  });
+
+  it('drops non-finite wall ids rather than poisoning the lookup', () => {
+    const t = compileTerrain({ dims: DIMS, walls: [NaN, 42, Infinity] } as unknown as Battlefield);
+    expect([...(t?.walls ?? [])]).toEqual([42]);
+  });
+});
+
+describe('edgeBlocks', () => {
+  const c = at(2, 2);
+  const wall = edgeId(c, 0);
+
+  it('blocks from both sides of the wall', () => {
+    const t = compileTerrain({ dims: DIMS, walls: [wall] });
+    expect(edgeBlocks(t, c, 0)).toBe(true);
+    expect(edgeBlocks(t, step(c, 0), 3)).toBe(true);
+  });
+
+  it('treats an open door as passable and a shut one as solid', () => {
+    const open = compileTerrain({ dims: DIMS, doors: { [String(wall)]: 'open' } });
+    expect(edgeBlocks(open, c, 0)).toBe(false);
+    for (const state of ['closed', 'locked'] as const) {
+      const t = compileTerrain({ dims: DIMS, doors: { [String(wall)]: state } });
+      expect(edgeBlocks(t, c, 0)).toBe(true);
+    }
+  });
+
+  it('never blocks without terrain', () => {
+    expect(edgeBlocks(undefined, c, 0)).toBe(false);
+  });
+});
+
+describe('reachableHexes with terrain', () => {
+  it('is unchanged when no terrain is supplied', () => {
+    const plain = reachableHexes(at(3, 3), 2, never, DIMS);
+    const withEmpty = reachableHexes(at(3, 3), 2, never, DIMS, compileTerrain({ dims: DIMS }));
+    expect(withEmpty.map(hexKey).sort()).toEqual(plain.map(hexKey).sort());
+  });
+
+  it('will not step through a wall', () => {
+    const from = at(3, 3);
+    const beyond = step(from, 0);
+    const t = compileTerrain({ dims: DIMS, walls: [edgeId(from, 0)] });
+    const keys = reachableHexes(from, 1, never, DIMS, t).map(hexKey);
+    expect(keys).not.toContain(hexKey(beyond));
+    expect(keys).toContain(hexKey(step(from, 1)));
+  });
+
+  it('seals a hex in completely when all six borders are walled', () => {
+    const from = at(3, 3);
+    const walls = Array.from({ length: 6 }, (_, d) => edgeId(from, d));
+    const t = compileTerrain({ dims: DIMS, walls });
+    expect(reachableHexes(from, 6, never, DIMS, t)).toEqual([]);
+  });
+
+  it('routes around a wall rather than treating it as a dead end', () => {
+    // Wall only the direct border; the neighbour must still be reachable the long way.
+    const from = at(3, 3);
+    const beyond = step(from, 0);
+    const t = compileTerrain({ dims: DIMS, walls: [edgeId(from, 0)] });
+    const keys = reachableHexes(from, 3, never, DIMS, t).map(hexKey);
+    expect(keys).toContain(hexKey(beyond));
+  });
+
+  it('excludes solid hexes', () => {
+    const from = at(3, 3);
+    const pillar = step(from, 0);
+    const t = compileTerrain({ dims: DIMS, solid: [hexKey(pillar)] });
+    expect(reachableHexes(from, 2, never, DIMS, t).map(hexKey)).not.toContain(hexKey(pillar));
+  });
+
+  it('closestReachableTo respects walls', () => {
+    const from = at(3, 3);
+    const goal = at(6, 3);
+    const walls = [edgeId(from, 0), edgeId(from, 1), edgeId(from, 5)];
+    const t = compileTerrain({ dims: DIMS, walls });
+    const open = closestReachableTo(from, goal, 1, never, DIMS);
+    const walled = closestReachableTo(from, goal, 1, never, DIMS, t);
+    expect(hexKey(open)).not.toBe(hexKey(from));
+    expect(hexKey(walled)).toBe(hexKey(from)); // every step toward the goal is walled off
+  });
+});
+
+describe('hasLineOfSight', () => {
+  it('is true everywhere on an open field', () => {
+    expect(hasLineOfSight(at(0, 0), at(5, 2), undefined)).toBe(true);
+    expect(hasLineOfSight(at(0, 0), at(5, 2), compileTerrain({ dims: DIMS }))).toBe(true);
+  });
+
+  it('is blocked by a wall directly between two adjacent hexes', () => {
+    const a = at(2, 2);
+    const t = compileTerrain({ dims: DIMS, walls: [edgeId(a, 0)] });
+    expect(hasLineOfSight(a, step(a, 0), t)).toBe(false);
+  });
+
+  it('gives the same answer in both directions', () => {
+    // hexLineDraw's rounding is not symmetric, so LOS is evaluated both ways and
+    // OR-ed; the observable behaviour must not depend on who is looking.
+    const a = at(1, 1);
+    const b = at(5, 4);
+    const walls = [edgeId(at(3, 2), 0), edgeId(at(3, 2), 1), edgeId(at(2, 3), 0)];
+    const t = compileTerrain({ dims: DIMS, walls });
+    expect(hasLineOfSight(a, b, t)).toBe(hasLineOfSight(b, a, t));
+  });
+
+  it('sees through an open door but not a shut one', () => {
+    const a = at(2, 2);
+    const b = step(a, 0);
+    const id = edgeId(a, 0);
+    expect(hasLineOfSight(a, b, compileTerrain({ dims: DIMS, doors: { [String(id)]: 'open' } }))).toBe(true);
+    expect(hasLineOfSight(a, b, compileTerrain({ dims: DIMS, doors: { [String(id)]: 'closed' } }))).toBe(false);
+  });
+});
+
+describe('hexIsSolid', () => {
+  it('reads the solid set, and is false without terrain', () => {
+    const t = compileTerrain({ dims: DIMS, solid: ['1,1'] });
+    expect(hexIsSolid(t, at(1, 1))).toBe(true);
+    expect(hexIsSolid(t, at(1, 2))).toBe(false);
+    expect(hexIsSolid(undefined, at(1, 1))).toBe(false);
+  });
+});
+
+describe('deployHexes with zones', () => {
+  const zones = {
+    player: [at(0, 7), at(1, 7)],
+    npc: [at(0, 0), at(1, 0), at(2, 0)],
+  };
+
+  it('draws from the supplied zone instead of the midline rows', () => {
+    expect(deployHexes('player', 2, DIMS, zones)).toEqual(zones.player);
+    expect(deployHexes('npc', 2, DIMS, zones)).toEqual(zones.npc.slice(0, 2));
+  });
+
+  it('returns a short list rather than inventing hexes outside the zone', () => {
+    // The caller places the overflow; silently spilling into walls would be worse.
+    expect(deployHexes('player', 5, DIMS, zones)).toHaveLength(2);
+  });
+
+  it('falls back to the classic midline rows when a zone is absent or empty', () => {
+    const classic = deployHexes('player', 3, DIMS);
+    expect(deployHexes('player', 3, DIMS, undefined)).toEqual(classic);
+    expect(deployHexes('player', 3, DIMS, { player: [], npc: [] })).toEqual(classic);
+  });
+
+  it('copies zone hexes so a caller cannot mutate the battlefield', () => {
+    const out = deployHexes('npc', 1, DIMS, zones);
+    out[0].q = 99;
+    expect(zones.npc[0].q).toBe(0);
+  });
+});
diff --git a/src/engine/index.ts b/src/engine/index.ts
index 35e01bc..a62536e 100644
--- a/src/engine/index.ts
+++ b/src/engine/index.ts
@@ -73,9 +73,23 @@ export {
   type GridDims,
 } from './hex';
 
+// Battlefield structure — walls live on the borders between hexes, not on hexes
+export {
+  dirIndex,
+  edgeId,
+  compileTerrain,
+  edgeBlocks,
+  hexIsSolid,
+  hasLineOfSight,
+  EDGE_COORD_LIMIT,
+  type Terrain,
+} from './hex';
+
 // Combat
 export {
   createCombatant,
+  OCCUPIES,
+  resetLogSequence,
   actionSlotsFor,
   isTargetInRange,
   getAOETargets,
diff --git a/src/index.css b/src/index.css
index 9f5c6a8..29d0e57 100644
--- a/src/index.css
+++ b/src/index.css
@@ -97,6 +97,10 @@
     color: theme('colors.arcane.soft');
     text-shadow: 0 0 18px rgba(45, 212, 191, 0.5);
   }
+  .text-glow-mystic {
+    color: theme('colors.mystic.soft');
+    text-shadow: 0 0 18px rgba(167, 139, 250, 0.5);
+  }
 
   /* Animated gradient border for featured cards */
   .lh-ring {
diff --git a/src/lib/combat.test.ts b/src/lib/combat.test.ts
index 6213ad4..d045158 100644
--- a/src/lib/combat.test.ts
+++ b/src/lib/combat.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { normalizeCombatState } from './combat';
+import { normalizeCombatState, normalizeBattlefield } from './combat';
 
 describe('normalizeCombatState', () => {
   it('defaults a missing combatants array so player selectors cannot crash', () => {
@@ -47,4 +47,62 @@ describe('normalizeCombatState', () => {
     expect(c.combatants).toHaveLength(1);
     expect((c.combatants[0] as { id?: string }).id).toBe('x');
   });
+
+  it('carries a battlefield through, normalized', () => {
+    const c = normalizeCombatState({ battlefield: { dims: { cols: 10, rows: 8 } } } as never);
+    expect(c.battlefield?.dims).toEqual({ cols: 10, rows: 8 });
+  });
+
+  it('leaves battlefield absent for a plain-arena snapshot', () => {
+    expect(normalizeCombatState({ isActive: true }).battlefield).toBeUndefined();
+  });
+});
+
+describe('normalizeBattlefield', () => {
+  it('clamps absurd dimensions instead of allocating until the tab dies', () => {
+    const b = normalizeBattlefield({ dims: { cols: 1e9, rows: -5 } });
+    expect(b?.dims.cols).toBe(200);
+    expect(b?.dims.rows).toBe(1);
+  });
+
+  it('coerces missing or non-numeric dimensions to a usable minimum', () => {
+    expect(normalizeBattlefield({}) ?.dims).toEqual({ cols: 1, rows: 1 });
+    expect(normalizeBattlefield({ dims: { cols: 'x', rows: NaN } } as never)?.dims).toEqual({
+      cols: 1,
+      rows: 1,
+    });
+  });
+
+  it('drops wall ids that are not safe integers', () => {
+    const b = normalizeBattlefield({ dims: { cols: 4, rows: 4 }, walls: [1, NaN, 'x', 2.5, 7] } as never);
+    expect(b?.walls).toEqual([1, 7]);
+  });
+
+  it('keeps only recognized door states, keyed by a numeric string', () => {
+    const b = normalizeBattlefield({
+      dims: { cols: 4, rows: 4 },
+      doors: { '10': 'open', '11': 'ajar', notANumber: 'closed', '12': 'locked' },
+    } as never);
+    expect(b?.doors).toEqual({ '10': 'open', '12': 'locked' });
+  });
+
+  it('drops zone hexes with garbage or out-of-range coordinates', () => {
+    const b = normalizeBattlefield({
+      dims: { cols: 4, rows: 4 },
+      zones: { player: [{ q: 1, r: 1 }, { q: NaN, r: 0 }, { q: 99999, r: 0 }, null], npc: 'nope' },
+    } as never);
+    expect(b?.zones?.player).toEqual([{ q: 1, r: 1 }]);
+    expect(b?.zones?.npc).toEqual([]);
+  });
+
+  it('omits empty structure so an open arena short-circuits every check', () => {
+    const b = normalizeBattlefield({ dims: { cols: 4, rows: 4 }, walls: [], solid: [], doors: {} });
+    expect(b).toEqual({ dims: { cols: 4, rows: 4 } });
+  });
+
+  it('returns undefined for a non-object, and never throws', () => {
+    expect(normalizeBattlefield(null)).toBeUndefined();
+    expect(normalizeBattlefield([1, 2])).toBeUndefined();
+    expect(() => normalizeBattlefield('nonsense')).not.toThrow();
+  });
 });
diff --git a/src/lib/combat.ts b/src/lib/combat.ts
index 5e9b8f8..d5cb7a4 100644
--- a/src/lib/combat.ts
+++ b/src/lib/combat.ts
@@ -1,7 +1,85 @@
-import type { CombatPhase, CombatState } from '@/types';
+import type { Battlefield, CombatPhase, CombatState, DoorState, HexCoord } from '@/types';
+import { EDGE_COORD_LIMIT } from '@/engine';
 
 const PHASES: CombatPhase[] = ['setup', 'declare', 'resolving', 'between', 'ended'];
 
+/** Largest arena we will render or path over. A board bigger than this would
+ *  hang the client long before it was playable, so a wire value claiming
+ *  100000×100000 is clamped rather than trusted. */
+const MAX_GRID_SIDE = 200;
+/** Caps on structure, generous for any hand-authored or generated interior. */
+const MAX_WALLS = 20_000;
+const MAX_SOLID = 20_000;
+const MAX_ZONE = 200;
+
+const DOOR_STATES: DoorState[] = ['open', 'closed', 'locked'];
+
+const clampSide = (v: unknown, fallback: number): number =>
+  typeof v === 'number' && Number.isFinite(v)
+    ? Math.min(MAX_GRID_SIDE, Math.max(1, Math.floor(v)))
+    : fallback;
+
+function cleanHexes(v: unknown): HexCoord[] {
+  if (!Array.isArray(v)) return [];
+  const out: HexCoord[] = [];
+  for (const h of v.slice(0, MAX_ZONE)) {
+    if (!h || typeof h !== 'object') continue;
+    const { q, r } = h as HexCoord;
+    if (!Number.isFinite(q) || !Number.isFinite(r)) continue;
+    if (Math.abs(q) > EDGE_COORD_LIMIT || Math.abs(r) > EDGE_COORD_LIMIT) continue;
+    out.push({ q: Math.trunc(q), r: Math.trunc(r) });
+  }
+  return out;
+}
+
+/**
+ * Coerce an untrusted {@link Battlefield} into something safe to path over.
+ *
+ * The danger here isn't malice so much as arithmetic: `dims` feeds `gridHexes`
+ * and the board renderer, so an absurd value would allocate until the tab dies.
+ * Wall ids that don't correspond to any real border are harmless — they simply
+ * never match — so they only need to be finite integers.
+ */
+export function normalizeBattlefield(raw: unknown): Battlefield | undefined {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return undefined;
+  const r = raw as Partial<Battlefield>;
+  const dims = {
+    cols: clampSide(r.dims?.cols, 1),
+    rows: clampSide(r.dims?.rows, 1),
+  };
+
+  const walls = Array.isArray(r.walls)
+    ? r.walls.slice(0, MAX_WALLS).filter((w): w is number => Number.isSafeInteger(w))
+    : undefined;
+
+  let doors: Record<string, DoorState> | undefined;
+  if (r.doors && typeof r.doors === 'object' && !Array.isArray(r.doors)) {
+    doors = {};
+    for (const [k, v] of Object.entries(r.doors).slice(0, MAX_WALLS)) {
+      if (Number.isSafeInteger(Number(k)) && DOOR_STATES.includes(v as DoorState)) {
+        doors[k] = v as DoorState;
+      }
+    }
+  }
+
+  const solid = Array.isArray(r.solid)
+    ? r.solid.slice(0, MAX_SOLID).filter((s): s is string => typeof s === 'string')
+    : undefined;
+
+  const zones = r.zones
+    ? { player: cleanHexes(r.zones.player), npc: cleanHexes(r.zones.npc) }
+    : undefined;
+
+  return {
+    dims,
+    ...(walls?.length ? { walls } : {}),
+    ...(doors && Object.keys(doors).length ? { doors } : {}),
+    ...(solid?.length ? { solid } : {}),
+    ...(zones ? { zones } : {}),
+    ...(typeof r.label === 'string' && r.label.trim() ? { label: r.label.slice(0, 120) } : {}),
+  };
+}
+
 /**
  * Coerce an untrusted combat snapshot (received from the GM over the wire) into a
  * structurally-valid {@link CombatState}. Players apply host snapshots wholesale,
@@ -19,6 +97,7 @@ export function normalizeCombatState(raw: unknown): CombatState {
     isActive: Boolean(r.isActive),
     phase: PHASES.includes(r.phase as CombatPhase) ? (r.phase as CombatPhase) : 'declare',
     round: Number.isFinite(r.round as number) ? (r.round as number) : 1,
+    ...(r.battlefield ? { battlefield: normalizeBattlefield(r.battlefield) } : {}),
     // Keep only real combatant objects — a null/garbage entry from the wire would
     // crash every selector that reads `.team`/`.peerId`/`.position` off each one.
     combatants: Array.isArray(r.combatants)
diff --git a/src/screens/table/combat/BattlefieldOverlay.tsx b/src/screens/table/combat/BattlefieldOverlay.tsx
new file mode 100644
index 0000000..4d394a5
--- /dev/null
+++ b/src/screens/table/combat/BattlefieldOverlay.tsx
@@ -0,0 +1,120 @@
+import { memo, useMemo } from 'react';
+import type { Battlefield, HexCoord } from '@/types';
+import { edgeId, gridHexes, hexKey } from '@/engine';
+
+export interface BattlefieldOverlayProps {
+  field: Battlefield;
+  /** Pixel centre of each hex, keyed by `hexKey` — the board's own layout. */
+  centerByKey: Map<string, { x: number; y: number }>;
+  /** Hex radius in px, matching the tiles. */
+  size: number;
+  width: number;
+  height: number;
+}
+
+/**
+ * Walls and doors, drawn as **one board-spanning SVG** rather than per tile.
+ *
+ * Each `HexTile` is its own absolutely-positioned `<svg>`, so drawing a wall
+ * inside them would paint every shared border twice — a visible seam, doubled
+ * opacity, and two independent entrance animations on one wall.
+ *
+ * The geometry follows `HexTile`'s own vertex convention (pointy-top, first
+ * vertex at −90°, then every 60°), so a wall lands exactly on the boundary
+ * between the two tiles it separates:
+ *
+ * - direction 0 (east)  → the right edge,      vertices 1–2
+ * - direction 1 (NE)    → the upper-right edge, vertices 0–1
+ * - direction 2 (NW)    → the upper-left edge,  vertices 5–0
+ *
+ * Only those three are ever stored: each hex owns three of its six borders and
+ * delegates the rest to its neighbour, so walking 0–2 over every hex visits
+ * each border exactly once.
+ */
+const EDGE_VERTICES: Record<number, [number, number]> = {
+  0: [1, 2],
+  1: [0, 1],
+  2: [5, 0],
+};
+
+function vertex(center: { x: number; y: number }, size: number, k: number) {
+  const angle = (Math.PI / 180) * (60 * k - 90);
+  return { x: center.x + size * Math.cos(angle), y: center.y + size * Math.sin(angle) };
+}
+
+interface Segment {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+  kind: 'wall' | 'closed' | 'locked';
+}
+
+export const BattlefieldOverlay = memo(function BattlefieldOverlay({
+  field,
+  centerByKey,
+  size,
+  width,
+  height,
+}: BattlefieldOverlayProps) {
+  const segments = useMemo(() => {
+    const walls = new Set(field.walls ?? []);
+    const doors = new Map(Object.entries(field.doors ?? {}).map(([k, v]) => [Number(k), v]));
+    if (walls.size === 0 && doors.size === 0) return [];
+
+    const out: Segment[] = [];
+    for (const hex of gridHexes(field.dims)) {
+      const center = centerByKey.get(hexKey(hex));
+      if (!center) continue;
+      for (let d = 0; d < 3; d += 1) {
+        const id = edgeId(hex, d);
+        const door = doors.get(id);
+        // An open door is an absence of wall — nothing to draw.
+        const kind: Segment['kind'] | null = walls.has(id)
+          ? 'wall'
+          : door === 'closed' || door === 'locked'
+            ? door
+            : null;
+        if (!kind) continue;
+        const [a, b] = EDGE_VERTICES[d];
+        const p = vertex(center, size, a);
+        const q = vertex(center, size, b);
+        out.push({ x1: p.x, y1: p.y, x2: q.x, y2: q.y, kind });
+      }
+    }
+    return out;
+  }, [field, centerByKey, size]);
+
+  if (segments.length === 0) return null;
+
+  return (
+    <svg
+      className="pointer-events-none absolute left-0 top-0"
+      width={width}
+      height={height}
+      aria-hidden
+    >
+      {segments.map((s, i) => (
+        <line
+          key={i}
+          x1={s.x1}
+          y1={s.y1}
+          x2={s.x2}
+          y2={s.y2}
+          stroke={s.kind === 'wall' ? 'rgba(120,142,190,0.85)' : 'rgba(245,185,66,0.85)'}
+          strokeWidth={s.kind === 'wall' ? 4 : 5}
+          strokeLinecap="round"
+          // A shut door reads as a barred gap rather than more masonry.
+          strokeDasharray={s.kind === 'wall' ? undefined : '5 4'}
+        />
+      ))}
+    </svg>
+  );
+});
+
+/** The hexes a battlefield marks impassable, as a lookup the board can probe. */
+export function solidKeys(field: Battlefield | undefined): Set<string> {
+  return new Set(field?.solid ?? []);
+}
+
+export type { HexCoord };
diff --git a/src/screens/table/combat/HexBoard.tsx b/src/screens/table/combat/HexBoard.tsx
index 5b52e18..87bbe8f 100644
--- a/src/screens/table/combat/HexBoard.tsx
+++ b/src/screens/table/combat/HexBoard.tsx
@@ -9,6 +9,8 @@ import {
   hexEquals,
   reachableHexes,
   isTargetInRange,
+  compileTerrain,
+  OCCUPIES,
 } from '@/engine';
 import { useCombatStore } from '@/store';
 import { BATTLE_GRID, MOVE_RANGE } from '@/data/constants';
@@ -21,6 +23,7 @@ import {
   type ActionOption,
 } from '../shared/actionOptions';
 import { HexTile, type HexTileTint } from './HexTile';
+import { BattlefieldOverlay, solidKeys } from './BattlefieldOverlay';
 import { BoardToken } from './CombatantToken';
 import { ActionMenu, type ActionMenuItem } from './ActionMenu';
 
@@ -38,6 +41,8 @@ const BASE_SIZE = 40;
 const PIECE_RATIO = 1.7;
 /** Pointer travel (px) before a press becomes a drag instead of a click. */
 const DRAG_THRESHOLD = 6;
+/** How far a small arena may be magnified to fill its container. */
+const MAX_BOARD_SCALE = 2.5;
 
 /** Who is resolving right now (for the active glow + glide emphasis). */
 function useActiveResolutionId(): string | undefined {
@@ -91,6 +96,7 @@ export function HexBoard({
 }: HexBoardProps) {
   const combatants = useCombatStore((s) => s.combat.combatants);
   const phase = useCombatStore((s) => s.combat.phase);
+  const battlefield = useCombatStore((s) => s.combat.battlefield);
   const declareAction = useCombatStore((s) => s.declareAction);
   const placeCombatant = useCombatStore((s) => s.placeCombatant);
   const activeResolutionId = useActiveResolutionId();
@@ -103,6 +109,12 @@ export function HexBoard({
   const boardRef = useRef<HTMLDivElement>(null);
   const planeRef = useRef<HTMLDivElement>(null);
 
+  // The arena this fight happens in — its own size and structure when it came
+  // from a map, otherwise the default open rectangle.
+  const dims = battlefield?.dims ?? BATTLE_GRID;
+  const terrain = useMemo(() => compileTerrain(battlefield), [battlefield]);
+  const solid = useMemo(() => solidKeys(battlefield), [battlefield]);
+
   const actor = useMemo(
     () => combatants.find((c) => c.id === activeActorId) ?? null,
     [combatants, activeActorId],
@@ -138,8 +150,11 @@ export function HexBoard({
   const canDrag = controllable && (isSetup || isDeclare) && !isResolving;
 
   // Layout: flat pixel centers for every hex, normalized to a 0-based box.
+  // Depends on `dims` — an empty dep array here silently pinned the board to
+  // whatever geometry it computed first, which is invisible until an arena
+  // changes size.
   const layout = useMemo(() => {
-    const hexes = gridHexes(BATTLE_GRID);
+    const hexes = gridHexes(dims);
     const raw = hexes.map((h) => ({ hex: h, px: hexToPixel(h, BASE_SIZE) }));
     const xs = raw.map((r) => r.px.x);
     const ys = raw.map((r) => r.px.y);
@@ -157,30 +172,33 @@ export function HexBoard({
     }));
     const centerByKey = new Map(cells.map((c) => [hexKey(c.hex), c.center]));
     return { cells, width, height, centerByKey };
-  }, []);
+  }, [dims]);
 
   // Occupancy: a hex is blocked for movement if a live combatant stands on it.
   const occupiedByOther = useMemo(() => {
     const keys = new Set<string>();
     for (const c of combatants) {
       if (c.id === activeActorId) continue;
-      if (c.isDead) continue; // corpses don't block; downed bodies still do
+      if (!OCCUPIES(c)) continue; // corpses don't block; downed bodies still do
       keys.add(hexKey(c.position));
     }
     return keys;
   }, [combatants, activeActorId]);
 
-  // Reachable tiles for the active actor (declare phase only).
+  // Reachable tiles for the active actor (declare phase only). Passing
+  // `terrain` is what keeps the highlight honest: without it the board would
+  // offer tiles through walls that the engine then refuses to move to.
   const reachableKeys = useMemo(() => {
     if (!declareInteractive || !actor) return new Set<string>();
     const reach = reachableHexes(
       actor.position,
       MOVE_RANGE,
       (c) => occupiedByOther.has(hexKey(c)),
-      BATTLE_GRID,
+      dims,
+      terrain,
     );
     return new Set(reach.map(hexKey));
-  }, [declareInteractive, actor, occupiedByOther]);
+  }, [declareInteractive, actor, occupiedByOther, dims, terrain]);
 
   // Close the menu when interaction context changes out from under it.
   useEffect(() => {
@@ -203,7 +221,9 @@ export function HexBoard({
     if (!el) return;
     const measure = () => {
       const avail = el.clientWidth;
-      const next = Math.min(1, avail / layout.width);
+      // Magnify as well as shrink: a 10x8 tavern should fill the container, not
+      // sit as a postage stamp in the middle of a wide screen.
+      const next = Math.min(MAX_BOARD_SCALE, avail / layout.width);
       setScale(Number.isFinite(next) && next > 0 ? next : 1);
     };
     measure();
@@ -261,7 +281,9 @@ export function HexBoard({
           (isSelf || !opt.needsTarget
             ? true
             : opt.range
-              ? isTargetInRange(actor, target, opt.range)
+              ? // Same call the resolver makes, terrain included — otherwise the
+                // menu offers a target behind a wall that the engine refuses.
+                isTargetInRange(actor, target, opt.range, terrain)
               : true); // no range band (e.g. a thrown consumable) → always reachable
         return {
           option: opt,
@@ -446,21 +468,39 @@ export function HexBoard({
             />
 
             {/* Tiles */}
-            {layout.cells.map(({ hex, center, i }) => (
-              <HexTile
-                key={hexKey(hex)}
-                hex={hex}
-                center={center}
+            {layout.cells.map(({ hex, center, i }) => {
+              const isSolid = solid.has(hexKey(hex));
+              return (
+                <HexTile
+                  key={hexKey(hex)}
+                  hex={hex}
+                  center={center}
+                  size={BASE_SIZE}
+                  tint={tintFor(hex)}
+                  solid={isSolid}
+                  interactive={
+                    tilesInteractive && !isSolid && !combatantByHex.has(hexKey(hex))
+                  }
+                  hovered={hovered != null && hexEquals(hovered, hex)}
+                  onHexClick={handleTileClick}
+                  onHexHover={setHovered}
+                  reducedMotion={reduced}
+                  delayStep={i}
+                />
+              );
+            })}
+
+            {/* Walls and doors — one overlay above the tiles, below the tokens,
+                so a shared border is drawn once rather than by both neighbours. */}
+            {battlefield && (
+              <BattlefieldOverlay
+                field={battlefield}
+                centerByKey={layout.centerByKey}
                 size={BASE_SIZE}
-                tint={tintFor(hex)}
-                interactive={tilesInteractive && !combatantByHex.has(hexKey(hex))}
-                hovered={hovered != null && hexEquals(hovered, hex)}
-                onHexClick={handleTileClick}
-                onHexHover={setHovered}
-                reducedMotion={reduced}
-                delayStep={i}
+                width={layout.width}
+                height={layout.height}
               />
-            ))}
+            )}
 
             {/* Tokens — upright pieces; glide on position change; draggable in setup. */}
             {combatants.map((c) => {
diff --git a/src/screens/table/combat/HexTile.tsx b/src/screens/table/combat/HexTile.tsx
index efd006a..8912262 100644
--- a/src/screens/table/combat/HexTile.tsx
+++ b/src/screens/table/combat/HexTile.tsx
@@ -23,6 +23,8 @@ export interface HexTileProps {
   reducedMotion?: boolean;
   /** Stagger seed (row+col) so the floor shimmers in like a wave. */
   delayStep?: number;
+  /** Impassable terrain — rock, a pit, deep water. Reads as mass, not floor. */
+  solid?: boolean;
 }
 
 /** Pointy-top hexagon vertices for a given radius, as an SVG points string. */
@@ -70,17 +72,24 @@ export const HexTile = memo(function HexTile({
   onHexHover,
   reducedMotion = false,
   delayStep = 0,
+  solid = false,
 }: HexTileProps) {
   const w = Math.sqrt(3) * size; // pointy-top width
   const h = 2 * size; // pointy-top height
   const points = hexPoints(size);
 
-  const fill = tint ? tintFill[tint] : 'rgba(14,22,38,0.55)';
-  const stroke = hovered
-    ? 'rgba(255,212,121,0.85)'
+  const fill = solid
+    ? 'rgba(24,32,52,0.96)'
     : tint
-      ? tintStroke[tint]
-      : 'rgba(46,63,100,0.6)';
+      ? tintFill[tint]
+      : 'rgba(14,22,38,0.55)';
+  const stroke = solid
+    ? 'rgba(58,76,116,0.9)'
+    : hovered
+      ? 'rgba(255,212,121,0.85)'
+      : tint
+        ? tintStroke[tint]
+        : 'rgba(46,63,100,0.6)';
 
   return (
     <motion.svg
diff --git a/src/screens/table/gm/StartCombatModal.tsx b/src/screens/table/gm/StartCombatModal.tsx
index c581392..4c0b3c7 100644
--- a/src/screens/table/gm/StartCombatModal.tsx
+++ b/src/screens/table/gm/StartCombatModal.tsx
@@ -1,9 +1,11 @@
 import { useMemo, useState } from 'react';
-import { Swords, Check, Plus, UserPlus, Skull, Users, BookOpen, Heart, Shield } from 'lucide-react';
+import { nanoid } from 'nanoid';
+import { Swords, Check, Plus, UserPlus, Skull, Users, BookOpen, Heart, Shield, Dices } from 'lucide-react';
 import type { Character, Combatant, PartyMember, Team } from '@/types';
-import { Modal, Button, Avatar, Badge, EmptyState, Divider, NumberStepper, Tabs, SegmentedControl } from '@/components/ui';
+import { Modal, Button, Avatar, Badge, EmptyState, Divider, NumberStepper, Tabs, SegmentedControl, Input } from '@/components/ui';
 import { useRosterStore, useCombatStore, useUIStore } from '@/store';
 import { createCombatant, calculateDerivedStats } from '@/engine';
+import { compileBattlefield, hashPath, type ArenaArchetype } from '@/engine/atlas';
 import { NPC_TEMPLATES, type NpcTemplate } from '@/data/npcTemplates';
 import { cn } from '@/lib/cn';
 
@@ -43,6 +45,23 @@ const TEAM_OPTIONS: { value: Team; label: string }[] = [
   { value: 'player', label: 'Ally' },
 ];
 
+/** Where the fight happens. `field` = the classic open rectangle. */
+type ArenaChoice = 'field' | ArenaArchetype;
+
+const ARENA_OPTIONS: { value: ArenaChoice; label: string }[] = [
+  { value: 'field', label: 'Open field' },
+  { value: 'open', label: 'Broken ground' },
+  { value: 'interior', label: 'Interior' },
+  { value: 'cave', label: 'Cave' },
+];
+
+const ARENA_BLURB: Record<ArenaChoice, string> = {
+  field: 'The classic 18×14 arena — no walls, no cover.',
+  open: 'Scattered boulders and copses for cover. Always fully traversable.',
+  interior: 'Rooms and doors. Walls block movement and line of sight.',
+  cave: 'A carved cavern with an uneven rim and solid rock.',
+};
+
 /**
  * GM combat setup: pick which connected players join the fray (team 'player')
  * and stage other units — either from the saved roster or the drop-in bestiary,
@@ -64,6 +83,32 @@ export function StartCombatModal({ open, onClose, party }: StartCombatModalProps
   const [rosterTeams, setRosterTeams] = useState<Record<string, Team>>({});
   const [bestiaryTeams, setBestiaryTeams] = useState<Record<string, Team>>({});
   const [foeTab, setFoeTab] = useState<FoeTab>('roster');
+  const [arena, setArena] = useState<ArenaChoice>('field');
+  const [arenaSeed, setArenaSeed] = useState('');
+
+  // The arena is a pure function of (seed, archetype), so the preview a GM
+  // shuffles through is exactly what everyone at the table will play on.
+  const battlefield = useMemo(() => {
+    if (arena === 'field') return undefined;
+    const label = ARENA_OPTIONS.find((o) => o.value === arena)?.label;
+    return compileBattlefield({
+      seed: hashPath([arenaSeed || 'lighthouse']),
+      archetype: arena,
+      label,
+    });
+  }, [arena, arenaSeed]);
+
+  const arenaSummary = useMemo(() => {
+    if (!battlefield) return null;
+    const walls = battlefield.walls?.length ?? 0;
+    const doors = Object.keys(battlefield.doors ?? {}).length;
+    const solid = battlefield.solid?.length ?? 0;
+    const parts = [`${battlefield.dims.cols}×${battlefield.dims.rows}`];
+    if (walls) parts.push(`${walls} wall${walls === 1 ? '' : 's'}`);
+    if (doors) parts.push(`${doors} door${doors === 1 ? '' : 's'}`);
+    if (solid) parts.push(`${solid} blocked`);
+    return parts.join(' · ');
+  }, [battlefield]);
 
   const selectedPlayers = useMemo(
     () => party.filter((m) => players[m.peerId] ?? true),
@@ -147,7 +192,7 @@ export function StartCombatModal({ open, onClose, party }: StartCombatModalProps
     }
 
     if (list.length === 0) return;
-    startCombat(list);
+    startCombat(list, battlefield);
     const heroes = selectedPlayers.length + stagedAllies;
     pushToast({
       title: 'Combat begins',
@@ -193,6 +238,47 @@ export function StartCombatModal({ open, onClose, party }: StartCombatModalProps
       }
     >
       <div className="space-y-5">
+        {/* Arena — where the fight happens. */}
+        <section className="space-y-2">
+          <h4 className="text-[0.7rem] font-semibold uppercase tracking-[0.18em] text-ink-faint">
+            The Ground
+          </h4>
+          <SegmentedControl<ArenaChoice>
+            value={arena}
+            onChange={setArena}
+            options={ARENA_OPTIONS}
+            size="sm"
+            fullWidth
+            tone="arcane"
+            aria-label="Choose the battlefield"
+          />
+          <p className="text-xs text-ink-muted">{ARENA_BLURB[arena]}</p>
+          {arena !== 'field' && (
+            <div className="flex items-center gap-2">
+              <Input
+                value={arenaSeed}
+                onChange={(e) => setArenaSeed(e.target.value)}
+                placeholder="seed (optional)"
+                className="h-8 flex-1 font-mono text-xs"
+                aria-label="Battlefield seed"
+              />
+              <Button
+                size="sm"
+                variant="secondary"
+                leftIcon={<Dices className="h-3.5 w-3.5" />}
+                onClick={() => setArenaSeed(nanoid(6))}
+              >
+                Reroll
+              </Button>
+            </div>
+          )}
+          {arenaSummary && (
+            <p className="font-mono text-[0.7rem] text-ink-faint">{arenaSummary}</p>
+          )}
+        </section>
+
+        <Divider label="Who fights" />
+
         {/* Players */}
         <section className="space-y-2">
           <h4 className="text-[0.7rem] font-semibold uppercase tracking-[0.18em] text-ink-faint">
diff --git a/src/store/battlefieldStaging.test.ts b/src/store/battlefieldStaging.test.ts
new file mode 100644
index 0000000..a719d10
--- /dev/null
+++ b/src/store/battlefieldStaging.test.ts
@@ -0,0 +1,142 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { useCombatStore } from './combatStore';
+import { useSessionStore } from './sessionStore';
+import { edgeId, hexKey, OCCUPIES } from '@/engine';
+import type { Battlefield, Combatant } from '@/types';
+
+const at = (q: number, r: number) => ({ q, r });
+
+function mkCombatant(over: Partial<Combatant> & { id: string }): Combatant {
+  return {
+    peerId: null,
+    name: over.id,
+    team: 'player',
+    position: at(0, 0),
+    initiativeBonus: 0,
+    maxHP: 20,
+    maxMP: 5,
+    maxSP: 5,
+    currentHP: 20,
+    currentMP: 5,
+    currentSP: 5,
+    ac: 10,
+    statusEffects: [],
+    isUnconscious: false,
+    isDead: false,
+    deathSaves: { successes: 0, failures: 0 },
+    ...over,
+  };
+}
+
+const combat = () => useCombatStore.getState().combat;
+const posOf = (id: string) => combat().combatants.find((c) => c.id === id)!.position;
+
+beforeEach(() => {
+  useCombatStore.getState().reset();
+  useSessionStore.setState({ role: 'gm', party: [] });
+});
+
+describe('staging a fight on a map-derived arena', () => {
+  it('keeps every combatant inside a small arena instead of the default 18x14', () => {
+    const field: Battlefield = { dims: { cols: 6, rows: 6 }, label: 'The Salt Lantern' };
+    useCombatStore.getState().startCombat(
+      [mkCombatant({ id: 'a' }), mkCombatant({ id: 'b', team: 'npc' })],
+      field,
+    );
+    for (const c of combat().combatants) {
+      // odd-r offset: axial q for a 6x6 board spans roughly -2..5, r 0..5
+      expect(c.position.r).toBeGreaterThanOrEqual(0);
+      expect(c.position.r).toBeLessThan(6);
+    }
+  });
+
+  it('stores the battlefield on the combat state so it rides every snapshot', () => {
+    const field: Battlefield = { dims: { cols: 8, rows: 8 }, walls: [edgeId(at(2, 2), 0)] };
+    useCombatStore.getState().startCombat([mkCombatant({ id: 'a' })], field);
+    expect(combat().battlefield).toEqual(field);
+  });
+
+  it('leaves battlefield absent for an ordinary fight', () => {
+    useCombatStore.getState().startCombat([mkCombatant({ id: 'a' })]);
+    expect(combat().battlefield).toBeUndefined();
+    expect(combat().groupId).toBeUndefined();
+  });
+
+  it('deploys each team into the zones the map nominated', () => {
+    const field: Battlefield = {
+      dims: { cols: 10, rows: 10 },
+      zones: { player: [at(0, 9)], npc: [at(0, 0)] },
+    };
+    useCombatStore.getState().startCombat(
+      [mkCombatant({ id: 'hero' }), mkCombatant({ id: 'foe', team: 'npc' })],
+      field,
+    );
+    expect(posOf('hero')).toEqual(at(0, 9));
+    expect(posOf('foe')).toEqual(at(0, 0));
+  });
+
+  it('does not spill an overflowing team into solid terrain', () => {
+    // One zone hex for two heroes: the second falls through to the overflow
+    // scan, which must skip the pillar rather than standing inside it.
+    const free = at(0, 0);
+    const dims = { cols: 4, rows: 4 };
+    const allButOne: string[] = [];
+    for (let r = 0; r < dims.rows; r += 1) {
+      for (let col = 0; col < dims.cols; col += 1) {
+        const q = col - ((r - (r & 1)) >> 1);
+        const k = hexKey({ q, r });
+        if (k !== hexKey(free)) allButOne.push(k);
+      }
+    }
+    const field: Battlefield = {
+      dims,
+      solid: allButOne,
+      zones: { player: [at(2, 2)], npc: [] },
+    };
+    useCombatStore.getState().startCombat(
+      [mkCombatant({ id: 'first' }), mkCombatant({ id: 'second' })],
+      field,
+    );
+    expect(posOf('first')).toEqual(at(2, 2)); // its nominated zone hex
+    expect(posOf('second')).toEqual(free); // the only hex that isn't solid
+  });
+
+  it('names the place in the opening log line', () => {
+    useCombatStore.getState().startCombat([mkCombatant({ id: 'a' })], {
+      dims: { cols: 8, rows: 8 },
+      label: 'The Salt Lantern — common room',
+    });
+    expect(combat().log[0].text).toContain('The Salt Lantern');
+  });
+
+  it('carries a group id for a split party', () => {
+    useCombatStore.getState().startCombat([mkCombatant({ id: 'a' })], undefined, 'vanguard');
+    expect(combat().groupId).toBe('vanguard');
+  });
+});
+
+describe('occupancy is one rule everywhere', () => {
+  it('a downed body blocks; a corpse does not', () => {
+    expect(OCCUPIES({ isDead: false })).toBe(true);
+    expect(OCCUPIES({ isDead: true })).toBe(false);
+  });
+
+  it('the GM cannot drop a combatant onto an unconscious one', () => {
+    // The engine used to test `currentHP > 0` here while the store and board
+    // tested `!isDead`, so a mover could walk onto a downed body and the board's
+    // hex→combatant map would silently hide one of them.
+    const downed = mkCombatant({
+      id: 'downed',
+      currentHP: 0,
+      isUnconscious: true,
+      position: at(3, 3),
+    });
+    const mover = mkCombatant({ id: 'mover', position: at(0, 0) });
+    useCombatStore.getState().startCombat([downed, mover]);
+    const target = combat().combatants.find((c) => c.id === 'downed')!.position;
+
+    useCombatStore.getState().placeCombatant('mover', target);
+    expect(posOf('mover')).not.toEqual(target);
+  });
+});
+
diff --git a/src/store/combatStore.ts b/src/store/combatStore.ts
index 87a1ffb..b273f36 100644
--- a/src/store/combatStore.ts
+++ b/src/store/combatStore.ts
@@ -1,6 +1,7 @@
 import { create } from 'zustand';
 import { nanoid } from 'nanoid';
 import type {
+  Battlefield,
   Character,
   Combatant,
   CombatState,
@@ -8,7 +9,15 @@ import type {
   DeclaredAction,
 } from '@/types';
 import type { CombatStore } from './contracts';
-import { resolveRound, processEndOfRound, deployHexes, gridHexes, actionSlotsFor } from '@/engine';
+import {
+  resolveRound,
+  processEndOfRound,
+  deployHexes,
+  gridHexes,
+  actionSlotsFor,
+  resetLogSequence,
+  OCCUPIES,
+} from '@/engine';
 import { CONDITIONS, BATTLE_GRID } from '@/data/constants';
 import { useSessionStore } from './sessionStore';
 import { useRosterStore } from './rosterStore';
@@ -63,7 +72,8 @@ function broadcast(combat: CombatState) {
  * the positions are written back in order. This fixes the default `{q:0,r:0}`
  * collision that occurs when combatants are created without an explicit hex.
  */
-function placeCombatants(combatants: Combatant[]): Combatant[] {
+function placeCombatants(combatants: Combatant[], battlefield?: Battlefield): Combatant[] {
+  const dims = battlefield?.dims ?? BATTLE_GRID;
   const byTeam: Record<Combatant['team'], Combatant[]> = { player: [], npc: [] };
   for (const c of combatants) byTeam[c.team].push(c);
 
@@ -71,7 +81,9 @@ function placeCombatants(combatants: Combatant[]): Combatant[] {
   const used = new Set<string>();
   (Object.keys(byTeam) as Combatant['team'][]).forEach((team) => {
     const team_members = byTeam[team];
-    const hexes = deployHexes(team, team_members.length, BATTLE_GRID);
+    // A map-derived arena nominates its own zones (the two entrances of a ruin,
+    // opposite banks of a ford); without them the classic midline rows apply.
+    const hexes = deployHexes(team, team_members.length, dims, battlefield?.zones);
     team_members.forEach((c, i) => {
       const hex = hexes[i];
       if (hex) {
@@ -82,12 +94,17 @@ function placeCombatants(combatants: Combatant[]): Combatant[] {
   });
 
   // Overflow past a team's deploy capacity would otherwise stack at {0,0}; give
-  // any leftover combatant the next free hex anywhere on the grid.
-  const allHexes = gridHexes(BATTLE_GRID);
+  // any leftover combatant the next free hex anywhere on the grid — skipping
+  // solid terrain, or the spillover lands inside a pillar.
+  const solid = new Set(battlefield?.solid ?? []);
+  const allHexes = gridHexes(dims);
   return combatants.map((c) => {
     let hex = positionFor.get(c.id);
     if (!hex) {
-      hex = allHexes.find((h) => !used.has(`${h.q},${h.r}`));
+      hex = allHexes.find((h) => {
+        const k = `${h.q},${h.r}`;
+        return !used.has(k) && !solid.has(k);
+      });
       if (hex) used.add(`${hex.q},${hex.r}`);
     }
     return hex ? { ...c, position: hex } : c;
@@ -158,15 +175,21 @@ function slotCountFor(combatantId: string, combatants: Combatant[]): number {
 export const useCombatStore = create<CombatStoreImpl>()((set, get) => ({
   combat: emptyCombat(),
 
-  startCombat: (combatants) => {
-    const placed = placeCombatants(uniquifyCombatantIds(combatants));
+  startCombat: (combatants, battlefield, groupId) => {
+    resetLogSequence();
+    const placed = placeCombatants(uniquifyCombatantIds(combatants), battlefield);
+    const where = battlefield?.label ? ` — ${battlefield.label}` : '';
     const combat: CombatState = {
       ...emptyCombat(),
       isActive: true,
       phase: 'setup',
       round: 1,
+      ...(battlefield ? { battlefield } : {}),
+      ...(groupId ? { groupId } : {}),
       combatants: placed,
-      log: [logEntry(1, '⚔️ Combat staged. Position your combatants, then begin the round.', 'beam')],
+      log: [
+        logEntry(1, `⚔️ Combat staged${where}. Position your combatants, then begin the round.`, 'beam'),
+      ],
     };
     set({ combat });
     if (isGM()) useSessionStore.getState().send({ type: 'combat_start', payload: { combat, seq: nextSeq() } });
@@ -186,7 +209,7 @@ export const useCombatStore = create<CombatStoreImpl>()((set, get) => ({
     const cur = get().combat;
     if (cur.phase === 'resolving') return;
     const occupied = cur.combatants.some(
-      (c) => c.id !== combatantId && !c.isDead && c.position.q === hex.q && c.position.r === hex.r,
+      (c) => c.id !== combatantId && OCCUPIES(c) && c.position.q === hex.q && c.position.r === hex.r,
     );
     if (occupied) return;
     set({
diff --git a/src/store/contracts.ts b/src/store/contracts.ts
index dbdeb3d..5d8f62e 100644
--- a/src/store/contracts.ts
+++ b/src/store/contracts.ts
@@ -6,6 +6,7 @@
  * from inside the stores, never directly from screens.
  */
 import type {
+  Battlefield,
   Character,
   DerivedStats,
   SkillPointBudget,
@@ -98,7 +99,10 @@ export interface SessionStore {
 
 export interface CombatStore {
   combat: CombatState;
-  startCombat: (combatants: Combatant[]) => void;
+  /** Stage a fight. `battlefield` supplies a map-derived arena (its own size,
+   *  walls, and deploy zones); omitting it uses the default open rectangle.
+   *  `groupId` names the party group fighting, for a split party. */
+  startCombat: (combatants: Combatant[], battlefield?: Battlefield, groupId?: string) => void;
   /** Leave the GM setup/placement phase and begin round 1's declarations. */
   beginRound: () => void;
   /** GM places a combatant on a hex (setup placement + free repositioning). */
diff --git a/src/store/sessionStore.ts b/src/store/sessionStore.ts
index 789270f..86d486d 100644
--- a/src/store/sessionStore.ts
+++ b/src/store/sessionStore.ts
@@ -81,9 +81,14 @@ export const useSessionStore = create<SessionStoreImpl>()((set, get) => {
         combat.combat.combatants.some((c) => c.id === id && c.peerId === from);
       switch (msg.type) {
         case 'player_join': {
+          // Complete the handshake. The greeting is what lets a joiner reset its
+          // snapshot watermark: this GM's outbound sequence counter starts at 0,
+          // and a player carrying a high watermark from a previous host process
+          // would otherwise drop every snapshot for the rest of the session.
+          transport.send(from, { type: 'hello', payload: { role: 'gm', name: get().selfName } });
           // Bring the joiner's resolver registry in line with the GM's active
-          // System FIRST (before party/combat data) so custom content resolves
-          // for them — and so a joiner who lacks the pack can still play it.
+          // System (before party/combat data) so custom content resolves for
+          // them — and so a joiner who lacks the pack can still play it.
           transport.send(from, systemSyncMessage());
           const character = normalizeCharacter(msg.payload.character);
           set((s) => {
@@ -164,6 +169,13 @@ export const useSessionStore = create<SessionStoreImpl>()((set, get) => {
 
     // --- player role: GM is authoritative ---
     switch (msg.type) {
+      case 'hello':
+        // A GM greeting means a fresh host process, and the host's outbound
+        // sequence counter restarts at 0 with it. Without re-baselining, a
+        // player who still holds a high watermark from before the GM reloaded
+        // silently drops every snapshot for the rest of the session.
+        if (msg.payload?.role === 'gm') lastRxSeq = -1;
+        break;
       case 'system_sync': {
         // The GM's active System is authoritative for the session. Build the same
         // catalog locally so our action menus / sheet / combat resolve identically
diff --git a/src/types/combat.ts b/src/types/combat.ts
index 61e66b8..841a9af 100644
--- a/src/types/combat.ts
+++ b/src/types/combat.ts
@@ -8,6 +8,47 @@ export interface HexCoord {
   r: number;
 }
 
+/** Battlefield extent, in offset-rectangular (odd-r) columns and rows. */
+export interface GridDims {
+  cols: number;
+  rows: number;
+}
+
+/** State of a door sitting on the border between two hexes. */
+export type DoorState = 'open' | 'closed' | 'locked';
+
+/**
+ * The physical space a fight happens in — the battlefield's size and structure.
+ *
+ * **Walls are edges, not cells.** A wall sits on the *border between* two hexes
+ * rather than consuming a hex, so a walled interior costs zero standable ground
+ * (a 7-room layout is ~100 edges instead of ~93 of 252 hexes). Edge ids are the
+ * canonical integers produced by `edgeId` (`src/engine/hex.ts`); a door is a
+ * state on an edge, so it renders as a gap in the wall for free.
+ *
+ * Every field is JSON-safe: this crosses the wire inside {@link CombatState} and
+ * is persisted, so no `Set`/`Map` may appear here. The engine compiles it into
+ * fast lookups once per resolution via `compileTerrain`.
+ *
+ * Absent entirely ⇒ the plain rectangular arena the game has always used.
+ */
+export interface Battlefield {
+  dims: GridDims;
+  /** Impassable borders, as canonical `edgeId` integers. */
+  walls?: number[];
+  /** Doors keyed by `String(edgeId)` (JSON object keys are strings). */
+  doors?: Record<string, DoorState>;
+  /** Whole impassable hexes — pillars, pits, deep water — keyed by `hexKey`. */
+  solid?: string[];
+  /** Where each team deploys. Absent ⇒ the default midline rows. */
+  zones?: { player: HexCoord[]; npc: HexCoord[] };
+  /** Human-readable origin, e.g. "The Salt Lantern — common room". */
+  label?: string;
+  /** Where this arena was compiled from, when it came from an atlas. Plain
+   *  strings so this module stays independent of the atlas types. */
+  origin?: { atlasId: string; path: string; genMajor: number };
+}
+
 export interface Combatant {
   id: string;
   /** PeerJS connection id for player combatants; null for GM-controlled NPCs. */
@@ -105,6 +146,13 @@ export interface CombatState {
   isActive: boolean;
   phase: CombatPhase;
   round: number;
+  /** The space this fight happens in. Absent ⇒ the default open arena
+   *  (`BATTLE_GRID`), which is what every fight not staged from a map gets. */
+  battlefield?: Battlefield;
+  /** Which party group is fighting, when the party has split. Absent ⇒ the
+   *  whole party. Carried from the start so running two fights at once later is
+   *  a store change rather than a protocol change. */
+  groupId?: string;
   combatants: Combatant[];
   /** combatantId -> declared actions for the round. */
   declaredActions: Record<string, DeclaredAction[]>;