commit 897b3735d604a1cc98308ffa533d5f3be0e4a15b
Author: troytt <47798984@qq.com>
Date:   Sun Sep 13 18:10:28 2026 +0800

    初始提交：从零实现的暗黑破坏神 II WebGL2 引擎（TypeScript + Vite，零运行时依赖）
    
    内容概览
    - 归档层：MPQ v1 容器（hash/block 表、Storm 加密、分扇区编解码），含 PKWARE
      implode/explode 移植；支持 HTTP Range 只读取所需字节。
    - 格式层：dc6 / ds1 / dt1 / pal / pl2 / cel / pcx / tbl / sprite，以及 dcc / cof / bitstream。
    - 地图层：等距投影场景构建（地板/墙/屋顶分层、逐格瓦片变体加权随机、sub-tile 碰撞），
      资源包（索引色 PNG 图集 + scene.json）离线烘焙与逐像素差分校验。
    - 角色层：DCC + COF 合成（8 方向），法师行走/站立替换占位棋子。
    - 页面：acts.html 全屏画布 + 三级选择器（章节 / 场景 / 细分场景），资源包优先、
      可回退到直读归档（?live=1）。
    - 验证脚本：verify:all / implode / acts / d2 / packs / dcc / deploy / listfile /
      object-lookup / alignment / tiles / generators 等，均带断言与退出码。
    
    数据与许可
    - 游戏数据（samples/）与第三方参考源码（reference/）不入库：体积大且无再分发许可，
      见 THIRD_PARTY_NOTICES.md。
    - 生成关卡（70 迷宫 + 31 野外）尚未烘焙，现状与修复清单见 HANDOVER.md §4f。

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..a57d470
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,16 @@
+# 依赖与构建产物（用 npm 脚本可重建）
+node_modules/
+dist/
+dist-game/
+dist-acts/
+*.log
+
+# 用户自备的游戏数据与本机参考源码：体积大 / 无再分发许可，绝不入库
+samples/
+*.mpq
+reference/
+
+# 临时调试产物
+.tmp/
+__pycache__/
+.DS_Store
diff --git a/HANDOVER.md b/HANDOVER.md
new file mode 100644
index 0000000..259ba74
--- /dev/null
+++ b/HANDOVER.md
@@ -0,0 +1,366 @@
+# 交接文档 · d2web
+
+**项目路径：`/root/diablo_web`**（原 `/root/codex_web/dsh/d2web`，2025-09-12 迁移；目录内没有任何写死的绝对路径，迁移后功能与迁移前一致，验证见文末「迁移后复验」）
+
+一句话：**用纯 TypeScript + Vite + WebGL2 从零写的暗黑破坏神 2 引擎**，读取**用户自备**的经典版 MPQ，
+目标是浏览器内可玩的垂直切片。仓库**不含任何暴雪素材**，零运行时依赖（只用平台 API）。
+
+---
+
+## 1. 现在能玩什么
+
+```bash
+cd /root/diablo_web
+npm install                      # 只装 devDependencies：vite / typescript / @types/node
+
+# 夹具（仓库不含素材，夹具是脚本生成的）
+node scripts/make-map-fixtures.ts samples/fixtures
+node scripts/make-mpq-fixture.ts samples/fixtures     # 把夹具打成真 MPQ
+
+npm run dev                      # http://127.0.0.1:5173/
+```
+
+| 页面 | 地址 | 内容 |
+| --- | --- | --- |
+| 资源检查器 | `/` 或 `/?sample=samples/spawn.mpq` | MPQ 头/存储标志/压缩掩码分布、成员列表、精灵逐帧预览 |
+| 可行走演示 | `/walk.html?sample=samples/spawn.mpq` | **真实暗黑 1 归档**：CEL/CL2 精灵、调色板、8 方向走动、碰撞 |
+| 单人战役沙盒 | `/map.html?data=samples/fixtures` 或 `?mpq=<你的.mpq>` | DS1+DT1 地图、战斗、掉落与拾取、背包、技能、任务、NPC 对话、存档/读档（K/L） |
+| 联机合作 | `/net.html?data=samples/fixtures&ws=ws://127.0.0.1:8787&peers=3&peer=0` | 2–4 人同一个世界，各控一名角色 |
+| **diablo2 地图 + 女法师** | 本地 `/acts.html?act=1`；线上 `https://www.laiseek.xyz/diablo2/?act=1`（`?act=1..5`、`?level=<label>`、`?quadrant=<DS1>`、`?live=1`）。页面上是三级选择器：**章节 → 场景 → 细分场景**（如 第一章 / 罗格营地 / 北），中文场景名见 `src/game/level-names-zh.ts` | **真实 D2 数据**：默认读预解包资源包（`samples/d2-packs`，索引 PNG + JSON），没有包或 `?live=1` 时直接按 HTTP range 读归档并解码。等距投影地图 + 8 方向走动 + 碰撞 + **真·女法师（DCC+COF 合成，16 层/8 方向）**，**无怪物**；可破坏物品位置与美术成员已进包，静态帧待接 |
+| 旧 act 页（已下线） | `/acts/`、`/acts-packs/`、`/acts-data/` | 全部 `410 Gone`；页面迁到 `/diablo2/`，资源包 `/diablo2/packs/`，归档 `/diablo2/data/*.mpq` |
+
+联机需要先起中继（自写、零依赖、只转发字节、不懂游戏）：
+
+```bash
+npm run net-server              # 等价于 node scripts/net-server.ts 8787
+```
+
+操作：WASD/方向键移动，空格或 J 攻击，E/F 拾取，T 说话，1–4 选技能，K 存档，L 读档。
+`acts.html` 只需 WASD/方向键：输入是**屏幕方向**（菱形格子相对屏幕转了 45°，按"上"沿格子对角线向上走）。
+
+资源包（离线解包，页面默认路径）：
+
+```bash
+npm run pack:data       # scripts/pack-act-assets.ts → samples/d2-packs（62 个地图块 / 35 关，约 46.8 MB）
+npm run verify:packs    # 与现读现解逐项比对：绘制序/坐标、碰撞栅格逐字节、每帧像素 FNV 哈希（992/992）
+npm run verify:listfile # 用社区 1.13c listfile 逐归档判定"这个成员到底存不存在"
+npm run verify:deploy   # 线上 /diablo2/ 页面 + 资源包 + Range 206 + 旧入口 410（17/17）
+npm run verify:alignment # 墙/地面基线是否与引擎公式一致、D2MOO 的 80px 差是不是常量（6/6）
+npm run verify:tiles     # 每个槽位画的是不是它该有的瓦片类型（地面=0）+ 位置公式（5/5）
+npm run verify:object-lookup # DS1 对象 id → token/mode 与 Objects.txt 交叉核对（19/19）
+```
+
+线上实测（真实 TLS，同一台机）：
+
+| | 请求数 | 传输 | 出画面 |
+| --- | --- | --- | --- |
+| act1 资源包 | 4 | 1.21 MB | 1.5 s |
+| act1 读归档（`?live=1`） | 1,344 | 6.22 MB | 12.1 s |
+| act5 资源包 | 9 | 3.80 MB | 2.1 s（首帧只要 7 页里的 4 页） |
+| act5 读归档（`?live=1`） | 3,971 | 11.24 MB | 36.5 s |
+
+线上部署（nginx 在 `/etc/nginx/sites-enabled/default` 里，页面 `/diablo2/`、资源包 `/diablo2/packs/`、归档 `/diablo2/data/*.mpq`；旧 `/acts*` 一律 410）：
+
+```bash
+npm run build:game                                   # → dist-game/（base=/diablo2/）
+rm -rf /var/www/d2web && mkdir -p /var/www/d2web && cp -r dist-game/* /var/www/d2web/
+rm -rf /var/www/d2packs && mkdir -p /var/www/d2packs && cp -r samples/d2-packs/* /var/www/d2packs/
+# 归档用硬链接暴露给 nginx（/root 是 0700，nginx 读不到）：
+#   mkdir -p /var/www/d2data && ln -f samples/d2/*.mpq /var/www/d2data/
+systemctl reload nginx
+```
+
+真数据相关的验收命令：
+
+```bash
+npm run verify:implode   # 四个归档全量成员解码（implode 端到端证明）
+npm run verify:acts      # 五个 act 城镇：表→DS1→DT1→等距场景 + 碰撞
+# 归档没有 (listfile) 时（Patch_D2.mpq 就是），成员名在 Storm 里是加密的：
+#   MpqArchive.open(source, { listfile }) 可挂社区名单，样例见 scripts/verify-listfile.ts
+#
+# 对象/瓦片这几件事都按 OpenDiablo2 的引擎口径对齐过（副本在 samples/od2/）：
+#   1. DS1 对象的 `id` 不是 Objects.txt 的行号，而是"该 act 对象表"的索引：
+#      src/game/object-lookup.ts（数据由 npm run port:object-lookup 从 OD2 的表生成）。
+#      identity 映射会把 act1 的喷泉（id 0）读成 Objects.txt 第 0 行 "Expansion"。
+#   2. 瓦片匹配的键是 `style:sequence:type`，其中 `type` 对应 DT1 头 **+20 的 `Type`**，
+#      **不是 +0 的 `Direction`**（那是朝向/变体索引，实测 1..5，永远不会等于 14 树/15 屋顶）。
+#      键错会让树/屋顶/影子全落 loose 兜底、画成地面——罗格营地的帐篷"没屋顶"就是这个。
+#      改键后 35 关 9,595 条墙引用 100% 精确命中（verify:alignment 有永久断言）。
+#      同一 style:sequence:type 下有多张变体图（Direction 与 RarityFrameIndex 不同），引擎**逐格**
+#      按 RarityFrameIndex 加权随机选一张，种子来自 (level seed, cellX, cellY)：pickVariant + levelSeed。
+#   3. 一格的 sub-tile flags 是**所有层做 OR**（OD2 SubTileFlags.Combine），影子层是 type 13 的
+#      独立层，也必须并进碰撞；实测三张城镇里影子贡献 0 个阻挡子格（scene.shadowBlockedSubtiles）。
+#   4. 方向：引擎是 64 方向空间经 5 张查表映射到 COF 方向（OD2 Dir64ToCof），
+#      src/game/character.ts 的 dir64ToCof 已按表移植；8 向输入下 4 方向 COF 的映射与
+#      旧启发式**不同**（2/3 都映到 1），16/32/64 方向下相同。
+#   4b. **地面槽位只能画 DT1 type 0**：DS1 的 floor 记录没有 type 字段，引擎语义是 type 0
+#      （OD2 `TileData(style, sequence, 0)`）。曾经这里传 null 走"类型无关"兜底池，池里混着
+#      墙/柱子/影子/树/屋顶；加上变体加权随机后，地面槽位会随机挑到暗色石墙瓦片，而地面绘制
+#      不做墙那套 minBlockY+80 补偿 → 画面里出现"悬在地面上的黑色方块"（35 关实测
+#      1,918/28,704 个地面槽画错类型；修道院大教堂 28.2%、地下墓穴 4 层 41.5%）。
+#      `npm run verify:tiles` 把这个普查变成永久断言（错类型 0 / looseRefs 0 / missingTiles 0
+#      / 地面·墙·屋顶位置公式自洽）。
+#   5. 屋顶（DS1 wall type 15）单独成层、最后绘制，偏移用引擎的 -roofHeight：
+#      scene.json 里是 `roofs` 数组，页面在地面/墙/角色之后画它（verify:packs 单独比对）。
+#      当前 62 个预置关卡里 9 张有屋顶，共 737 个绘制（act 4 城镇 53 个）。
+#   （打包器的 DT1 解码缓存有上限 16 个库：不设上限时整轮烘焙会涨到 4 GB 以上。）
+#
+# 页面 UI：header 只留标题 + HUD（原来的三个站内链接已去掉）；三个下拉框是
+# `#act`（章节）/ `#scene`（场景，取自 pack 索引的 slug 分组）/ `#variant`（细分场景，
+# 该场景下的 DS1 变体）。变体名：城镇/回廊/鲁高因按 `TownN1`/`CourtW`/`LutN` 后缀给方位名，
+# 其余显示 DS1 名。中文场景名是**社区通用译名**（手工整理，见 level-names-zh.ts 头部说明；
+# 我们这份安装包的 `data\local\LNG\CHI\string.tbl` 解出来是乱码，`.tbl` 解码器尚未对真文件校准）。
+# 回归断言：`scripts/browser/checks/map-switch.js`（8 项：无多余链接、三级结构、三个下拉框的跳转参数）。
+npm run verify:d2        # samples/d2 里每个 MPQ 的头/块槽/sha256
+```
+
+---
+
+## 2. 目录结构
+
+```
+src/
+  mpq/          MPQ v1 容器：header/tables/sectors、crypt（HashString/块加密/文件键）、解压掩码分发
+  formats/      dc6 ds1 dt1 pal pl2 cel pcx tbl sprite（各格式的纯解码器，无 DOM 依赖）
+  game/         combat（战斗/怪物 AI/经验）items（基物/词缀/背包/掉落）skills（投射物）
+                quests（任务/NPC/对话）map（DS1+DT1 合成、子瓦片碰撞、深度插入）
+                animation（按方向的帧控制器）save（快照 + .d2s）rng（可复现随机）tables（表解析）
+                hitflash/… 等辅助
+  net/          protocol（二进制消息）transport（内存对 / 内存 hub / WebSocket）lockstep（锁步内核）
+                netplay（握手门控 + 输入游标 + 哈希收发 + 超时）
+  render/       atlas（精灵图集打包）renderer（WebGL2 单批次四边形 + 顶点色 tint）
+  sim/          loop（定点 25 Hz 循环，含追帧上限）input（键盘）
+  scene/        map-scene.ts（单人战役，~1200 行）net-scene.ts（联机，~600 行）
+index.html  walk.html  map.html  net.html      四个入口
+scripts/        夹具生成、验证脚本、中继服务器、浏览器验证工具（见 scripts/browser/README.md）
+tools/go-oracle/  独立 Go 参考解码器源码（差分验证用，见 §6）
+samples/        夹具与被 .gitignore 忽略的归档（spawn.mpq、fixtures/）
+dist/           构建产物
+```
+
+---
+
+## 3. 里程碑状态与证据
+
+| 里程碑 | 状态 | 证据 |
+| --- | --- | --- |
+| M0 资源管线 | ✅ | 真暗黑 1 `spawn.mpq`（25.8 MB / 1029 项）全量解包 + 精灵解码；自写 MPQ 写入器往返 + `mpyq` 独立读取；与 3 个独立实现全字段差分 |
+| M1 可走地图 | ✅ | DS1+DT1 渲染、5×5 子瓦片碰撞、8 方向动画、深度插入；`map.html`（夹具/真归档）、`walk.html`（真 D1 归档，25 tps） |
+| M2 战斗沙盒 | ✅ | `verify-combat.ts` 38 项；浏览器内实测 |
+| M3 物品系统 | ✅ | `verify-items.ts` 58 项 |
+| M4 技能/任务/NPC | ✅ | `verify-m4.ts` 56 项 |
+| M5 存档与联机 | ✅ | `verify-m5.ts` 33 项（读档续跑逐 tick 一致）；`verify-net.ts` 143 项；三浏览器同时联机实测 |
+
+一条命令跑完无头验证：
+
+```bash
+npm run verify:all     # combat + items + m4 + m5 + net
+```
+
+浏览器端证据用 `scripts/browser/`（见其 README）。实测过的数字（本轮迁移前）：
+
+- 单人战役：存档后继续到 tick 364，读档回到存档点（位置 276、击杀 4、金币 46、地面 2、等级 2），24.6 tps、`glError 0`
+- 真归档：`walk.html?sample=samples/spawn.mpq` → `ready: true`、25.0 tps、`glError 0`
+- 三人联机：三页 `peers 3`、各听到 2/2 名队友、都跑到 **worldTick 306 且完全齐平**、各比对 110–115 个哈希全一致、`malformed 0`、无 desync、三页 `players` 数组逐字段相同
+
+---
+
+## 4. 关键设计约定（改代码前先读这段）
+
+1. **模拟必须是纯函数**。联机靠锁步：每台机器各自算整个世界，网络上**只传按键**。
+   所以任何读时钟、读 `Math.random`、读宿主环境的行为都会变成 desync。
+   随机一律走 `Rng`（种子进存档），时间一律走 25 Hz 的 tick 计数。
+2. **tick 只在所有对等方输入到齐时才推进**（`LockstepSession.step` 返回 `waiting`）。
+   抢跑 = 分叉；等待 = 正确。
+3. **输入延迟**（`inputDelayTicks`）是延迟预算：某一 tick 的输入提前若干 tick 发出。
+   发送游标要从 `0` 补齐到应付 tick，否则 `0..D-1` 谁都不发，游戏在第一 tick 前就死锁。
+4. **握手门控**：没确认对方在监听（收到对方的 hello）之前**不发任何输入**。
+   先发出去的帧如果对面还没连上，中继无人可转发、发送方无从得知，那些输入永久消失 → 两边永久互等。
+   确认用 `ackTo` 指名道姓（四人局里"我听到了"必须说清听到了谁）。
+5. **`CombatWorld.player` 与 `CombatWorld.players[i]` 必须是同一个对象**。
+   读档/快照是靠对象展开拼世界的，展开后 `player` 是新的、`players` 是旧的，
+   症状是"世界模拟一个身体、屏幕画另一个"。加新字段时要么避开，要么调用 `rebindPlayer()` 重新绑定。
+6. **一个 tick 里所有玩家先动、怪物后动，且只动一次**（`tickCombatMulti`）。
+   每人各调一次 `tickCombat` 会把怪物跑两遍。
+7. **怪物只攻击"本 tick 开始时还活着"的玩家**；全场无人存活时怪物回合整个跳过。
+   这条是单人死亡/重生手感的来源（死亡时世界停住、重生当 tick 不挨打）。
+8. **解码器宁可拒绝也不猜**。没有真文件对照的字段（`.d2s` 数据段、部分表列）
+   一律**原样保留字节**，不做"看起来合理"的解析——猜错的解码器会静默产出坏存档/坏贴图。
+9. **渲染器画完必须 `renderer.flush()`**。批处理器不 flush 就只剩清屏色，
+   看起来和"场景没加载"一模一样。
+10. **MPQ 文件键用纯文件名**（不是成员全路径），查到表项用的是全路径；存储型成员**没有扇区偏移表**
+    （只有 `COMPRESS` 才需要）。这三条都踩过。
+
+---
+
+## 5. 验证方法论（为什么这些数字可信）
+
+- **差分验证**：与独立实现对照，而不是自己跟自己对。用过：StormLib（MIT，只读语义）、
+  DevilutionX/Devilution、`OpenDiablo2/{dc6,ds1,dt1,pl2,tbl_text}`（Go）、npm `dc6png`。
+  差分脚本 `scripts/verify-format-parity.sh`（见 §6）。
+- **真数据**：暗黑 1 试玩版 `spawn.mpq` 是唯一的**真实归档**证据，用于 MPQ 容器、CEL/CL2、调色板、
+  精灵宽度推断。
+- **判据要能失败**：`verify-net.ts` 里的篡改用例会改写飞行中的输入，要求**在正确的 tick 报出 desync**；
+  "永远不会响的检测器"比没有检测器更糟。
+- **不要谎报核对**：联机时落后方收到的是自己还没算到的 tick 的哈希，
+  这些哈希**缓存到本地历史追上再比**，无法核对的单独计数（`hashesIgnored`），不算作"一致"。
+- **浏览器侧的判定靠状态字段，不靠看图**：这套环境里模型读不了图，
+  且 `readPixels` 在合成后返回清空缓冲。页面把状态挂在 `window.__d2webNet` /
+  `window.__d2webMap` / `window.__d2web` 上，由 CDP 读取断言。
+
+---
+
+## 6. 环境依赖（都在本机，但**不在仓库里**，重装机器要重建）
+
+| 用途 | 位置 | 重建方式 |
+| --- | --- | --- |
+| Node | v22.22.2（系统） | Node 的类型剥离模式跑 `.ts` 脚本，**不支持 TS 参数属性**（`constructor(private x)`），脚本里别写 |
+| headless Chromium | `/root/.cache/ms-playwright/chromium-1223/chrome-linux64/chrome` | `npx playwright install chromium`；启动参数见 `scripts/browser/README.md` |
+| Go 参考解码器 | 源码已收进 `tools/go-oracle/main.go` | `cd tools/go-oracle && /opt/go1.22/bin/go mod init ref && /opt/go1.22/bin/go get github.com/OpenDiablo2/{dc6,ds1,dt1,pl2}@latest && /opt/go1.22/bin/go build -o /tmp/refdump .`（Go 在 `/opt/go1.22`，GOPROXY 用 `https://goproxy.cn,direct`） |
+| `dc6png`（npm） | 曾在 `/tmp/dc6png` | `npm i dc6png` 到任意目录，用 `DC6PNG=<…>/src/index.js` 指过去 |
+| Python + PIL | 系统 | 差分脚本比像素时用 |
+
+跑完整差分：
+
+```bash
+REFDUMP=/tmp/refdump DC6PNG=/tmp/dc6png/node_modules/dc6png/src/index.js \
+  bash scripts/verify-format-parity.sh /tmp/d2fix
+```
+
+三个外部依赖都是**可选**的：缺了会打印 `SKIP`，剩余检查照跑。
+
+---
+
+## 7. 还没做完的（按"能不能自己做"分类）
+
+### A. 原来卡在"没有真 D2 MPQ"上的（**已解除**，`samples/d2/` 有真数据）
+
+现状：用户自备的 1.13c 数据落在 `samples/d2/`（11 个 MPQ，约 1.9GB，来源/字节数/sha256/
+版本证据在 `samples/d2/MANIFEST.md`）。**但那是汉化/免 CD 整合安装**，客户端 DLL 与官方
+1.13c 补丁文件集不一致，别拿它做字节级对照。
+
+**第一前置已做完**：`src/mpq/implode.ts` 实现了 **PKWARE DCL implode**，`decompress.ts` 接线，
+`archive.ts` 的读法修正。现在实测能读：
+
+```bash
+npm run verify:implode     # 30914 个成员、893 MB 全部解出，12/12 断言
+npm run verify:acts        # 五个 act 城镇解析 + 合成，40/40
+```
+
+只剩 **ADPCM+Huffmann 音频**（572 个成员，`mask 0x41/0x81`，本轮不做）。
+
+这一轮踩到的坑（都写进了代码注释，别再踩）：
+
+1. **掩码字节与压缩标志是两种写法**。`MPQ_FILE_COMPRESS(0x200)` 才有扇区首字节掩码；
+   `MPQ_FILE_IMPLODE(0x100)` 单独出现时**没有掩码字节**，整段就是 implode 流。
+   `Patch_D2.mpq` 的每张表都是后者；旧代码按"有掩码"读，遇到首字节 0x00 就当成 stored，
+   **静默返回压缩字节**（`levels.txt` 能返回 66,615 字节却不含 `LevelName`、尾部全是 0）。
+   现在的规则：`body.length === expected` → stored；否则按标志选 implode 或掩码，且长度不符一律抛错。
+2. **DT1 的 `blockSize` 不是 `numBlocks * 20`**。真文件里 25 个块该字段是 6900
+   （= 25×20 头 + 25×256 体）。旧断言用 20×N 校验，于是**只认自己生成的夹具、拒绝所有真文件**。
+   现在按 `numBlocks*20 + Σlength` 校验，不符只记 warning。
+3. **DS1 的 `style` 匹配的是 DT1 瓦片自己的 `style` 字段**，不是该 DT1 在 `LvlTypes` 里的下标。
+   `Act1/Outdoors/River.dt1` 里的瓦片内部 style 是 2/3，`Fence.dt1` 只有 0；按"库下标"解会把
+   大部分城镇解对、再丢掉 219 个引用。改成合并所有库按 `style:sequence:direction` 查之后 missing=0。
+4. **`LvlPrest` 要用 `LevelId` 关联，不是 `Def`**。Act 2 城镇 `Def=301 / LevelId=40`；用 `Def` 会
+   给四个 act 返回**别的关卡**的地图。
+5. **D2 是等距投影**：格子在屏幕上是 80×40 的菱形（`(cx-cy)*80, (cx+cy)*40`），5×5 子格是 16×8；
+   地板画在 `cell+(-80, 0)`，墙要加 `minBlockY+80`（墙的美术长在格子上方）。矩形摆放只对夹具成立。
+6. **空槽要跳过**：DS1 每个格子都带固定数量的墙槽，其中 `prop1 == 0` 的是占位（Act 1 城镇 4674 个
+   墙槽里 4275 个如此），画出来就是垃圾。
+
+**可破坏物品的美术卡在同一个解码器上**：`data\global\objects\` 下是 **1748 个 DCC + 1461 个 COF，只有 13 个 DC6** ——
+也就是说 D2 画对象用的是和角色一样的 COF+DCC 合成管线。资源包因此只烘了它们的**位置与元数据**
+（`Objects.txt` 的名称/HP/Token + 选定的美术成员名），像素留给 DCC/COF 解码器（和法师同一件事）。
+不要把这些文件当 DC6 硬解：头部对不上，解出来是垃圾（本轮实测过）。
+
+implode 落地后，§7A 剩下这四件（现在都有真文件可对照）：
+
+1. `node scripts/inspect-mpq.ts <file> header` 和 `hist` → 头字段与压缩掩码分布。
+2. **DT1 数据块偏移基准**：`src/formats/dt1.ts` 现在按"先相对、失败再绝对"处理 `FileOffset`，需要真文件确认。
+3. **经典 `string.tbl` 索引布局**：`src/formats/tbl.ts` 目前只有**构造检查**级证据
+   （Go 侧 `tbl_text` 实现的是后来带哈希表的变体，不能当对照）。
+4. **DCC / COF 动画**：未实现。Go 参考实现自己就报 `bottom up frames are not implemented`，
+   所以当时判断做不出可信对照；真文件到手后按格式文档 + 逐字节对照可以做。
+5. **`.d2s` 数据段布局**：现在只实现签名/版本/名字/职业/等级/校验和，其余段原样保留。
+6. **D2 表列映射**：`src/game/*` 里读表用的是夹具列名 + 少量官方文档确认的列名。
+   接真表要逐列核对（列名集中在各 `*FromTable`/`monsterStatsFromRow`，改动集中）。
+
+### B. 工程上可以做但还没做的
+
+- **入场大厅 / 断线重连策略**：现在是"少一人就等"（正确但生硬），没有"踢人/暂停/恢复"的选择界面。
+- **输入回滚**：只做了"等待"，没做预测 + 回滚（对 25 Hz 局域网够用，跨洋会明显卡顿）。
+- **联机与战役状态**：联机是独立沙盒——世界和角色共享，但**背包/任务不进网络**。
+  要打通需要把物品/任务状态纳入确定性模拟并进哈希。
+- **联机场景的怪物/掉落**：目前联机场景只有战斗与经验，没有联机的物品掉落与拾取。
+- **DCC/COF 之外的美术缺口**：联机场景没有背包 UI、没有血蓝球（单人场景有）。
+
+---
+
+## 8. 迁移后复验（本次迁移做的检查）
+
+```bash
+cd /root/diablo_web
+npx tsc --noEmit                 # 类型检查
+npm run build                    # 四个入口都进产物
+node scripts/verify-net.ts       # 143 项
+```
+
+三者在迁移后均通过（见本次会话最后一条工具输出）；开发服务器与中继已改为从新路径启动：
+
+```bash
+npm run dev          # 后台任务，http://127.0.0.1:5173/
+npm run net-server   # 后台任务，ws://127.0.0.1:8787
+```
+
+页面级复验（`scripts/browser/`）：
+
+```bash
+CHROME=/root/.cache/ms-playwright/chromium-1223/chrome-linux64/chrome
+node scripts/browser/inspect-page.mjs "$CHROME" \
+  "http://127.0.0.1:5173/map.html?data=samples/fixtures" \
+  scripts/browser/checks/map-save-load.js
+node scripts/browser/many-pages.mjs "$CHROME" \
+  "http://127.0.0.1:5173/net.html?data=samples/fixtures&ws=ws://127.0.0.1:8787&peer=0" \
+  "http://127.0.0.1:5173/net.html?data=samples/fixtures&ws=ws://127.0.0.1:8787&peer=1"
+```
+
+---
+
+## 9. 从哪读起
+
+1. `README.md` —— 里程碑叙述 + **「验收：整条目标链的证据」** 一节（逐项对照可复现命令）。
+2. 本文 §4「关键设计约定」—— 十条踩过的坑，改代码前必读。
+3. `src/net/lockstep.ts` 顶部注释 —— 锁步为什么这么设计。
+4. `src/net/netplay.ts` 的握手与发送游标 —— 四个真 bug 的现场。
+5. `scripts/verify-net.ts` —— 读测试比读实现更快理解协议与时序。
+
+## 4f. 生成关卡（101 关）现状与修复清单 —— 暂缓，未烘焙
+
+页面上的 **35 个场景全部是 `DrlgType=2` 的固定 DS1**；生成类关卡一个都没进包：
+
+| `DrlgType` | 关卡数 | 已烘焙 |
+| --- | --- | --- |
+| 2 预置 | 35 | 35 |
+| 1 随机迷宫 | 70 | 0 |
+| 3 野外 | 31 | 0 |
+
+例：**鲜血荒野 = `Act 1 - Wilderness 1`（Id 2，DrlgType=3）**，未烘焙。`scripts/pack-act-assets.ts`
+里以 `pending: { wilderness: 31, maze: 70 }` 如实记录，页面不会假装有这些图。
+
+`npm run verify:generators` 实测（2026-09-13）：
+
+1. **9 关直接抛错** `no usable LvlPrest pieces`：Act 2 Harem 2、Act 3 憎恨囚牢 1/2、
+   Act 5 冰窟 1/1A/2/2A/3/3A。根因：这些迷宫的 `LvlPrest` **没有该 `LevelId` 的行**
+   （实测行数 = 0），房间件要按 `LvlMaze` 行 + **关卡类型的件名**解析。
+2. **可达率**：75 关中 15 关 < 50%，其中 8 关 = **0.0%**（Crypt 1A/2A/3A/3B/3C/3D、
+   Pandemonium 1、Wilderness 5）——开口方向/拼接没对上，或出生点被围死。
+3. **瓦片引用缺失**：36/75 关存在，最高 **56.8%**（Act 2 Lair/Tomb 系列）。
+4. **野外不可玩**：鲜血荒野可达 1.6%、黑色沼泽 0.0%、墓地 0.0%、冰冷之原 3.2%。
+
+修复顺序（每步都要过 `verify-generators` 的阈值门：确定性 + 可达率 + 缺引用 + 房间数 ≥
+`LvlMaze.Rooms`）：① 件来源改写（`LvlMaze` + 类型件名）→ ② 开口拼接与出生点连通 →
+③ 件→瓦片映射（按 `Dt1Mask` 与件自身 style 选库，注意 type(+20) 那条教训）→
+④ 野外 `LvlSub` 替换规则。烘进包时必须在 pack 索引/HUD/文档里标注
+**“按官方参数表复现，非引擎原版布局”**（生成逻辑移植自 D2MOO，不是逐字节还原）。
+
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..26a790c
--- /dev/null
+++ b/README.md
@@ -0,0 +1,450 @@
+# d2web
+
+Web 原生的暗黑破坏神 II 引擎（进行中）。**仓库不含任何游戏素材**：引擎只读取你自备的
+经典版 MPQ（`d2data.mpq` / `d2exp.mpq` / `patch_d2.mpq` 等），素材始终留在你自己机器上。
+零运行时依赖（纯 TypeScript + Vite + 平台 API）。项目位于 `/root/diablo_web`；
+**接手/继续开发先读 [`HANDOVER.md`](HANDOVER.md)**（目录导览、十条设计约定与踩坑、验证方法论、
+环境依赖重建、未完成项分类）。
+
+## 现状
+
+### M0 · 资源管线 ✅
+
+- **MPQ v1 容器**：头解析、哈希表/块表解密、名字查找、扇区定位、按范围随机读取
+  （`File`/`Blob` 直接读，**从不把整个归档载入内存**）。
+- **Storm 密码学**：crypt table、`HashString`、块密码。密钥取**纯文件名**（basename）——
+  哈希查找用全路径、解密密钥用 basename，混用会静默解出乱码（而且总长度还对，只校验
+  大小发现不了）。
+- **解压**：zlib 走平台 `DecompressionStream('deflate')`。自适应 Huffman / PKWARE implode /
+  ADPCM / bzip2 / sparse 按 StormLib 的掩码顺序留位，遇到未实现的掩码**明确报错**而非产生坏数据。
+- **精灵解码**：`.cel` 与 `.cl2`（含多组 = 多方向、逐帧宽度、帧头跳过、跨行游程）。
+  元数（0x80 透明游程 / ≤0xBE 填充 / >0xBE 字面）与 CEL 的行封闭规则都按 DevilutionX 实现。
+- **调色板 / 变体**：768 字节 `.pal`、256 字节 `.trn` 索引重映射（怪物换色与 D2 的 palette shift 同一机制）。
+- **浏览器检查器**：拖入 MPQ → 列文件/筛选 → PCX 渲染、音频解码、文本/十六进制预览。
+
+### D2 格式解码层 🚧（已实现，等真 MPQ 收口）
+
+- **DC6** 精灵：24 字节文件头 + 帧指针表 + 32 字节帧头；游程三字母表
+  （`0x80` 换行 / `(b&0x7f)` 透明游程 / 否则字面游程），**行序自下而上**，索引 0 透明。
+- **DT1** 瓦片库：276 字节文件头 + 96 字节瓦片记录 + 20 字节块头；两种块编码都实现——
+  RLE（`(skip,count)` 对，`(0,0)` 换行）与等距（固定 `xjump`/`nbpix` 菱形表，256 字节）；
+  25 个子瓦片碰撞标志（bit0 阻挡行走、bit1 阻挡视线…）可直接用于 M1 碰撞。
+- **PL2** 调色板：1024 字节基础调色板 + **1727 张 256 字节换色表**（光照 32 / 反色 16 / 选中单位 1 /
+  粗粒度 alpha 3×256 / 加色 256 / 乘色 256 / 色相 111 / 红绿蓝色调 3 / 未命名 14 / 最大分量 256 / 变暗 1）
+  + 13 色文本调色板 + 13 张文本换色表，共 **443175 字节**——格式**完全没有头/计数/目录**，
+  表序与数量就是格式本身，所以解码器里把每组的数量逐条写出来而不是推算。
+  D2 的光照/混合/单位换色全靠"索引→索引"的换色表完成，这也是为什么解码器始终保留索引、最后才落色彩。
+- **TBL** 字符串表（经典布局）：`crc` + 条目数 + 偏移表 + 每条目 `u16 字符数 + UTF-16LE`；
+  未用索引解析为 `undefined`（区别于空串）。
+- **DS1** 地图：版本化段序列（act / substitution / 内嵌文件名 / 4+4 层流 / 地板层 / 对象 / NPC 路径），
+  含低于 4 版的旧式层顺序与低于 7 版的方向查表；产出逐格 `walls/floors/shadows/substitutions` + 对象列表。
+
+### 独立实现差分验证（关键证据）
+
+没有真 D2 文件时，"解码器不报错"毫无意义。所以每个格式都与**独立实现**逐字段比对：
+
+| 检查 | 独立实现 | 结果 |
+| --- | --- | --- |
+| DC6 像素 | `dc6png`（npm，JS） | **128/128 像素一致** |
+| DC6 全字段 | `OpenDiablo2/dc6`（Go） | **JSON 完全相同** |
+| DS1 全字段 | `OpenDiablo2/ds1`（Go） | **JSON 完全相同** |
+| DT1 元数据 | `OpenDiablo2/dt1`（Go） | **JSON 完全相同**（该包的像素解码是死代码，见下） |
+| DT1 像素落位 | 夹具编码时的期望网格 | **102400/102400 像素一致** |
+| PL2 全表 | `OpenDiablo2/pl2`（Go） | **完全一致**（基础/文本调色板 + 1727 张表的逐表摘要） |
+
+```bash
+REFDUMP=/path/to/refdump DC6PNG=/path/to/dc6png/src/index.js \
+  bash scripts/verify-format-parity.sh /tmp/d2fix
+```
+
+**差分测试当场抓到了我自己的一个真 bug**：我最初按 16 字节读 DT1 块头，而
+[社区权威文档](http://paul.siramy.free.fr/_divers/dt1_doc/) 与参考实现都是 20 字节
+（`X, Y, 2 字节保留, GridX, GridY, Format, Length, 2 字节保留, FileOffset`），
+把 `Format/Length/FileOffset` 全部读错了偏移；同时 `FileOffset` 是**相对该瓦片自己的块头起点**。
+另外 `dc6png` 独立确认了 DC6 的行序与游程字母表。
+
+### 归档驱动路径 ✅（"丢进 MPQ → 出地图"已跑通）
+
+`map.html` 支持三种数据源：**拖入 `.mpq`**、`?mpq=<url>`、`?data=<fixture 目录>`。
+打开归档后会按扩展名自动挑成员（`town`/`act1` 优先），页面上有 **DS1 / DT1 / 调色板选择器**与重新加载按钮，
+因为真实归档里有成百上千个关卡与瓦片库需要人来选。
+
+为了让这条路径在**没有任何暴雪数据**时也能验证，我写了 `scripts/make-mpq-fixture.ts`：
+把夹具打成**真正的 MPQ v1 归档**（表加密、成员混用"原样存储"与"zlib 分扇区"两条路径），
+于是"用户丢归档 → 引擎读取 → 解码 → 渲染地图"整条链现在就能端到端测试。
+
+| 检查 | 结果 |
+| --- | --- |
+| 我的读取器往返 | **5/5 成员逐字节一致**（54354 字节） |
+| 独立读取器（Python `mpyq`） | **4/4 已发布成员逐字节一致** |
+| 归档驱动场景 | `source=mpq`、自动选中 3 个成员、9 地面 / 9 墙体、**未解析引用 0**、108/225 阻挡 |
+| 运行 | **25.0 tps**、双轴移动、撞墙被拒、`glError = 0`、截图 2946 种颜色 |
+
+**这里又抓到两个只有独立实现能发现的问题**：
+
+1. **存储型成员必须带 `SINGLE_UNIT` 标志**。不带的话，标准读取器会走"多扇区表"路径，
+   把文件自身的数据当成偏移表读出垃圾——而**我自己的读取器恰好容忍**（我实现成"无表直读"）。
+   于是出现了"自己读写全对、别人读不出来"的假绿：`fixture.ds1`（zlib）能读、`palette.pal`（存储）读出 0 字节，
+   这个不对称正是定位问题的线索。
+2. **读取器对未压缩成员多读了一张扇区表**。StormLib 只在 `COMPRESS` 标志下加载偏移表，
+   未压缩文件是从块起点直读的；我原先对非 single-unit 文件一律读表。已按参考实现修正，并对加密+存储的成员按 `key + 扇区号` 逐扇区解密。
+
+### M5 · 存档与联机 🚧（存档、确定性锁步、**2–4 人浏览器联机合作已跑通**；`.d2s` 待真文件确认）
+
+**存档（快照）**：把续跑所需的一切装进一个带版本号的纯数据结构——战斗世界、背包（**按原有格子位置**）、
+任务进度、**随机流的位置**，以及地面掉落物。随机流位置是最容易被漏掉的一项：不保存它，读档后
+同一批掉落会以不同顺序出现，看起来"存档能用"，直到有人注意到掉的东西不对。
+
+验证方式是存档唯一有意义的验证方式：**读档后继续模拟，要求与原进程逐 tick 完全一致**——
+漏掉任何字段都会在几百 tick 后表现为状态分叉。另含畸形存档与未来版本存档的拒绝。
+
+**`.d2s` 角色档**：实现了签名、版本、名字/职业/等级字段与**校验和**；物品/任务/传送点/佣兵等段
+**原样保留字节而不去猜**（没有真文件对照时猜这些会写出静默损坏存档的解码器）。
+这轮在这里抓到一个**真 bug**：校验和用 JS 的 `<< 1`（32 位有符号移位）会把高位丢弃而不是折叠进位，
+导致**离末尾 32 字节以外的字节对校验和完全不可见**——那种位置的篡改检测不出来。已改为按规范做进位折叠。
+
+**确定性锁步**：这一块**完全不依赖暴雪数据**，所以可以强验证。三条规则：
+① **某个 tick 只有在所有对等方的输入都到齐时才推进**（缺输入就 waiting，绝不猜测或抢跑——抢跑必分叉）；
+② **输入延迟**若干 tick 作为网络延迟预算；③ **逐 tick 状态哈希**互相比对，第一处不一致即 desync，
+且报告里带上是**哪个 tick** 分叉的（这决定 bug 能不能查）。
+
+`scripts/verify-m5.ts` 无头断言 **33 项**：快照续跑一致性、畸形/未来版本存档拒绝、地面掉落随档保存、
+`.d2s` 往返与校验和篡改检测、双会话 300 tick 哈希全同、缺输入等待且计数、输入延迟语义、
+过期输入被丢弃、以及**篡改输入必须被识别为 desync 并报出正确 tick**（不会响的 desync 检测器比没有更糟）。
+
+浏览器内实测：存档后状态继续变化（击杀 3→5、金币 39→46、地面 2→3），读档后
+**击杀/背包/金币/地面掉落/等级/位置/怪物存活/任务进度/经验全部回到存档点**，随后继续运行，
+`glError = 0`、25 tps。这里也抓到一个真实场景 bug：场景里缓存了 `const player = world.player`，
+读档替换世界后**这个引用仍指向旧世界**，导致读档那一 tick 的后半段还在写旧数据——已改为读档后重新绑定。
+
+**联机合作（`net.html`）**：每页一个浏览器，**2–4 人同一个世界、各控一名角色**（`?peers=` 指定人数，`?peer=` 是本页编号）。网络上只传四类消息
+（谁、按了什么键、我这 tick 的状态哈希、再见），**世界状态一个字节都不传**——每台机器各自把整个
+世界算出来，这正是 25 Hz 能跑在普通连接上的原因。
+
+* `src/net/protocol.ts` —— 手写小端编解码。移动量按**定点 ×1000** 传，因为浮点在两台机器上可能
+  舍入出不同的结果；每条消息都做长度与范围校验，畸形包在网络层就被拒掉，不会流进模拟。
+* `src/net/transport.ts` —— 传输是一根「可靠的字节管道」：`memoryTransportPair()`（进程内成对，
+  可 `hold` 住模拟慢链路）与 `socketTransport()`（浏览器 `WebSocket` 与 Node 全局 `WebSocket` 共用同一份代码，
+  所以真实 socket 路径能无头验证）。消息尺寸上限在传输层就挡住。
+* `src/net/netplay.ts` —— 把锁步内核接到传输上：**按对等方记账的握手门控**、输入发送游标、哈希收发与超时。
+  握手不是"听到对方"就算完成，而是**对方确认收到了我的 hello**（`ackTo` 指名道姓，因为四人局里
+  "我听到了"必须说清是听到了谁）；**所有对等方都到齐才开跑**。
+* `src/scene/net-scene.ts` + `net.html` —— 2–4 人合作场景：每人一个角色、怪物**追最近的那个活人**、
+  经验记给**补刀的那个**、`?ws=` 联机 / 不带则单机跑同一条模拟路径。
+
+四个**真 bug**，全靠验证抓出来，都不是"写错一个字段"级别的：
+
+1. **输入延迟导致的死锁**：延迟 D tick 时，第一个该发的 tick 是 D，`0..D-1` 谁都不发，游戏在第一 tick 前就卡住。
+   改为发送游标从 `0` 补齐到「当前应付 tick」。
+2. **握手是单向的**：只听见对方 hello 的peer 认为自己已完成握手，于是**永远不发自己的 hello**；
+   对方因此一直等，双方都 ready 不了。现在收到 hello 必回一个 hello，且**只认「对方确认收到我的 hello」才算完成**，
+   否则每 25 次 pump 重发一次。
+3. **首发帧掉进虚空**：先连上中继的一页把 `0..4` 帧发出去时对面还没连上，中继无人可转发（发送方无从得知），
+   而发送游标已经前进——**这些 tick 的输入永久消失，两边永久互等**。现在有握手门控：**没确认对方在听，就不发输入**。
+4. **超时判定用「世界 tick」计时**：世界一旦卡住，tick 不再前进，超时因此**永远不会触发**——恰好在它唯一有用的场景里失效。
+   现在按「距上次收到消息经过了多少次 pump」计。
+
+另外两处是**设计加强**，同样由数字逼出来：哈希比对面向前进中的世界时，
+落后方收到的是自己还没算到的 tick，于是**大量哈希只能被丢弃**（落后方几乎什么都没验证到）；
+现在把对方哈希缓存起来、等本地历史追上再比对，并单独统计 `hashesIgnored`——**把无法核对的哈希谎报成"一致"，
+比不检查更糟**。
+
+`scripts/verify-net.ts` 无头断言 **143 项**：协议编解码（含固定字节布局与全部畸形包）、
+内存管道与**内存 hub** 的排队/上限/关闭语义、双 peer 200 tick 世界完全一致、
+**慢链路只停世界不坏世界**（落后方靠已有积压追上同 tick 后世界逐字段相同）、
+**四人局**：三个 peer 不会因为第四个还没来就抢先开跑（少一人就等，否则先发出的输入会掉进虚空）、
+迟到者入场后四人**逐 tick 齐平**且四个世界逐字段相同、四人中一人掉线时其余三个只停不裂、
+恢复后各自用积压追平；篡改飞行中的输入→**在正确 tick 报 desync**、垃圾包被丢弃且世界不受影响、
+静默 peer → **超时而非 desync**、老旧哈希计为"无法核对"，以及**真 socket**（自写 RFC6455 中继 +
+两个真客户端 150 tick、**三个真客户端 160 tick**）无分叉。
+
+浏览器实测（**三个独立 Chromium 实例** + 真中继）：三页 `peers 3`、各听到 2/2 名队友、
+`handshaked/acknowledged`，三页都跑到 **worldTick 306 且完全齐平**、各比对 110–115 个哈希**全部一致**、
+`malformed 0`、无 desync、`glError 0`，三页 `players` 数组**逐字段相同**（位置/血量/经验），
+击杀数一致（7），三张截图互不相同（各页相机跟各自角色）。
+
+### M4 · 技能 / 任务 / NPC ✅（结构层已跑通；真实 MPQ 数据待接入）
+
+- **技能**（`Skills.txt` 形状）：法力消耗、冷却、射程、伤害随等级成长；两种施放形态——
+  **投射物**（按 25 Hz 飞行、撞墙即毁、超时消失、命中后伤害走战斗模块的同一套击杀/经验/尸体管线）
+  与**瞬发范围**（半径内全部命中）。伤害成长是唯一显式简化的地方：真实表用 5 个等级区间
+  （`MinLevDam1..5`）插值，我读单一斜率 `PerLevel`，公式隔离在 `skillDamageAt` 里等映射层替换。
+- **名字来自真 TBL**：表里的数字单元格通过 `data/local/string.tbl` 解析（我上轮标记为"弱验证"的解码器
+  现在真正进入了游戏路径）；没有 TBL 时数字保持字面量，两种路径都保留。
+- **任务/NPC**：`Quest.txt` 形状的目标（按**怪物 id** 或 `*` 通配计数）、奖励（经验+金币）、
+  状态机 `inactive → active → complete` 且**不重复发奖**；NPC 台词按状态选择
+  （未接/进行中/已完成各一套）——"NPC 在你已接任务时还在推销"是经典 bug，这里用状态选台词避免。
+- **交互**：数字键选技能位（1..4）、攻击键施放、T 键与最近 NPC 对话（自动接取任务）、
+  拾取 E/F；对话显示在页面面板上。
+- **两个真实缺陷在这轮被浏览器测试抓出**：① 选中法术且魔法耗尽后空格既不施法也不近战，
+  玩家彻底失去攻击能力 → 改为"法术放不出时回退近战"并加魔法缓慢回复；
+  ② 台词先按 `|` 拆、再解析 TBL，而 TBL 字符串本身含 `|`，导致多行台词没被拆开 → 改成先解析再拆行。
+  另外还修了施法决策与近战推进的顺序（原先二者会同一 tick 同时触发）。
+
+`scripts/verify-m4.ts` 无头断言 **56 项**：TBL 名字解析三种情形（命中/字面量/无表）、
+技能表解析与投射物判定、伤害随等级单调、施放的冷却与法力门（含"刚好够"）、
+投射物飞行/命中/撞墙/超时/忽略尸体、任务按 id 与通配计数、阈值达成发奖且不重复、
+NPC 台词随状态切换、施法可复现。
+
+浏览器内实测（夹具归档）：`textSource=tbl`、技能名 `['Basic Attack','Fire Bolt','Frost Nova']`
+（来自归档内的真 TBL）、施放 7 次、走到 NPC 前对话得到两行台词并**接取任务**（`den:active`）、
+追问台词切换为进行中版本、随后击杀使任务计数 **推进到 1/3**、`glError = 0`、25.6 tps。
+（3/3 完成与奖励发放由无头断言覆盖；浏览器脚本受合成地图通行性限制未打满。）
+
+### M3 · 物品系统 ✅（结构层已跑通；真实 MPQ 数据待接入）
+
+物品的建模方式跟着 D2 的真实存储走：物品 = **基物**（`weapons.txt`/`armor.txt`/`misc.txt` 行）
++ 可选**前缀/后缀**（`magicprefix.txt`/`magicsuffix.txt` 行），词缀的修饰项指向
+`ItemStatCost.txt` 里的属性名。没有硬编码——剑就是一行带尺寸和伤害的表行，
+"Cruel" 就是一行带等级要求、可用物品类型与数值范围的表行。
+
+两个关键决定：
+
+- **随机数是注入的**（`src/game/rng.ts`，mulberry32，零依赖）。掉落是种子的纯函数，
+  因此可以被测试精确复现——这同时也是 M5 联机 lockstep 能成立的前提。
+- **背包是格子占用模型，不是列表**。D2 物品有宽高、不能重叠、形状固定，
+  不建模这个，"背包满了"就没有任何意义。
+
+已实现的约束：词缀**等级门**与**物品类型门**（`itype1..7`）、前缀/后缀/基物的名字组合、
+属性合并（基础 + 各修饰项）、堆叠到上限后**溢出到新格子而不是丢弃**、金币堆叠、
+拾取时背包满**拒绝而不是销毁物品**（并计数）、按类型着色的地面物品与背包网格覆盖层。
+
+`scripts/verify-items.ts` 无头断言 **58 项**，涵盖表解析（含真实文件常见的**前导空列**）、
+词缀资格、掷取可复现、名字与属性合成、背包边界/重叠/堆叠/移除/金币、掉落表的等级门与可复现。
+
+浏览器内实测（夹具归档）：`items=archive · tables=archive`、3 次击杀产生 3 次掉落
+（1 次金币 39 自动入账 + 2 件地面物品）、拾取 2 件 → 背包 3 件 / **6/40 格**、护甲防御合计 12、
+**24.6→25.6 tps**、`glError = 0`；掉落名为 **`Sturdy Buckler of the Fox`**（前缀仅限护甲 + 后缀不限）
+与 `Minor Healing Potion of the Fox`——正是表驱动的词缀资格在起作用。
+
+### M2 · 战斗沙盒 ✅（结构层已跑通；真实 MPQ 数据待接入）
+
+战斗模拟刻意**不依赖渲染**：一次只推进一个 25 Hz tick，输入是一条小船小记录、地形是一个碰撞谓词。
+这样整套系统能在 Node 里无头模拟与断言——只能靠看屏幕验证的战斗，通常是坏的。
+
+- **数据表驱动**：怪物血量/伤害/冷却/攻击距离/仇恨半径/速度/经验**全部来自表行**
+  （`data/global/excel/monstats.txt` 与 `experience.txt`，D2 用的制表符文本格式，`.bin` 只是它的编译形式），
+  换真表不用改代码。表缺失时回退到内置演示表并在 HUD 标注 `tables builtin`。
+- **AI 状态机**：`idle → chase → attack`，按仇恨半径发现、按攻击距离切换、按各自冷却出手；
+  尸体保留 100 tick 再消失。
+- **玩家**：近战按冷却与魔法消耗，命中最近目标；经验按表累加升级（升级提升并回满资源）；
+  死亡后按计时重生。
+- **移动权限收归模拟**：地形谓词返回**重叠计数**而不是布尔——已经卡在实心格里的身体必须能走出来，
+  规则是"不让重叠变深"；布尔表达不了这件事，而"永久卡死"比"短暂蹭到墙角"糟糕得多。
+- **渲染**：角色与怪物**一起按深度插进墙体序列**（怪物复用同一套图集，按类型着色），
+  带血条；左下/右下是血蓝球（屏幕锚定、世界坐标绘制）。
+
+`scripts/verify-combat.ts` 无头断言 **38 项**：表解析（空单元格/`(null)`/默认值/大小写）、
+经验表单调化、生成不落进实心格且可复现、仇恨/追击/攻击距离、冷却决定出手次数（24 tick 冷却在 100 tick 内正好 5 次）、
+魔法消耗与不足时不落伤害、击杀/经验/升级/资源回满、死亡与重生、以及**同样输入产生同样结果**。
+
+浏览器内实测（夹具归档）：`tables=archive`、生成 8 只、**击杀 3 只**、经验 28 → **升到 2 级**（上限血 60→70）、
+魔法 30→11、**25.2 tps**、`glError = 0`；HUD 显示 `hp 70/70 · mana 11/35 · lvl 2 (28 xp) · monsters 5/8 alive · kills 3`。
+
+### M1 · 地图渲染与碰撞 ✅（结构层已跑通；真实 MPQ 数据待接入）
+
+`map.html`：把解码出的 **DS1 布局 + DT1 瓦片库**渲染成地图——**逐格分层绘制**
+（地面按格序、墙体按画家序：先远后近），碰撞**直接来自 DT1 的 5×5 子瓦片标志**
+（`blockWalk` / `blockPlayerWalk`），网格步长 = 瓦片边长 / 5 = 标准 160px 瓦片的 32px。
+
+浏览器内实测（无头 Chromium + SwiftShader，合成夹具）：
+
+| 检查 | 结果 |
+| --- | --- |
+| 绘制 | 9 次地面 + 9 次墙体，4 张瓦片图集，**未解析引用 0** |
+| 碰撞网格 | 15×15 子瓦片，**108/225 为阻挡**（由瓦片标志推导） |
+| 定步长 | **25.2 tps** |
+| 移动 | 空位可走；撞到实心子瓦片被拒；**无穿墙**、无越出地图边界 |
+| 渲染 | `glError = 0`；截图 3207 种颜色、70.9% 非背景像素、5205 个角色像素 |
+
+**角色动画已接入**（`src/game/animation.ts`）：格式无关的 clip/方向/帧推进系统，
+按 **25 Hz tick 计数**播放（而不是毫秒——否则在不同机器上速度不同），
+`walk` / `stand` 自动切换、方向由移动向量决定（0=南、6=东、4=北，与文件内组序一致）。
+
+**绘制顺序也做对了**：角色不再永远画在最上层，而是**按深度插进墙体序列**
+（规则 = 第一个"比角色更近"的墙之前），所以站到墙后会被正确遮挡。这条规则抽成了纯函数
+`depthInsertIndex` 并单独验证（16 个位置、0 问题）——小地图上肉眼很难看出插桩点变化。
+
+角色素材解析顺序：**DC6 优先**（D2 大量单位本身就是逐方向 DC6 图集，且每帧自带尺寸）→
+**D1 CL2 回退**（用游戏表宽度 96）→ 都没有才用黄色方块占位。
+为了在没有真数据时也能验证，夹具里生成了一个**合成角色 DC6**（8 方向 × 8 帧 × 64×64，
+每个方向图案不同，便于看出方向/帧错位），并打进夹具归档。
+
+浏览器内实测：`actor=actor.dc6`、东=6 / 北=4 / 南=0、走→站切换、帧推进、角色位于 9 个墙体绘制的第 6 位、**25.0 tps**、`glError = 0`。
+
+### 引擎骨架（D1 演示，仍可用）
+
+`walk.html`：真实角色精灵（战士行走/站立，宽度 96 = 游戏表数值）+ 8 方向朝向 +
+碰撞 + 相机跟随 + **25 Hz 定步长循环**；地面与墙是占位几何，等 DS1/DT1 解码器落地后替换。
+
+浏览器内实测（无头 Chromium + SwiftShader）：`25.6 tps`、朝北 `facing=4`、朝东 `facing=6`、
+撞墙后两次推挤位置不变、`glError = 0`。
+
+## 验证方式（可复现）
+
+```bash
+node scripts/inspect-mpq.ts samples/spawn.mpq header   # 头 + 存储标志分布
+node scripts/inspect-mpq.ts samples/spawn.mpq hist     # 压缩掩码分布 → 该归档需要哪些解码器
+node scripts/verify-archive.ts samples/spawn.mpq       # 全量解包 + 魔数校验
+node scripts/verify-sprites.ts samples/spawn.mpq       # 全量精灵解码 + 宽度推断
+node scripts/verify-widths.ts <archive> <member> <widths-file>   # 逐帧宽度精灵
+node scripts/make-fixtures.ts /tmp/d2fix            # 生成 DC6 夹具 + 期望网格
+node scripts/make-map-fixtures.ts /tmp/d2fix        # 生成 DT1/DS1 夹具
+node scripts/verify-dc6.ts /tmp/d2fix               # DC6 自校验
+node scripts/verify-dt1-pixels.ts /tmp/d2fix         # DT1 像素落位校验
+node scripts/make-mpq-fixture.ts samples/fixtures   # 把夹具打包成真 MPQ
+node scripts/verify-mpq-roundtrip.ts samples/fixtures  # 归档往返验证（含 mpyq 交叉）
+node scripts/make-pl2-fixture.ts /tmp/d2fix         # 合成 PL2（1727 张表，模式可辨位置）
+node scripts/verify-tbl.ts                          # TBL 构造检查（CJK/星形平面/长串）
+node scripts/verify-depth-order.ts                  # 角色深度插入规则（纯函数，无需渲染器）
+node scripts/verify-combat.ts                       # 战斗行为无头断言（38 项）
+node scripts/verify-items.ts                        # 物品/词缀/背包/掉落无头断言（58 项）
+node scripts/verify-m4.ts                           # 技能/投射物/任务/NPC 无头断言（56 项）
+node scripts/verify-m5.ts                           # 存档快照/角色档/确定性锁步无头断言（33 项）
+node scripts/verify-net.ts                          # 协议/传输/2–4 人锁步/真 socket 无头断言（143 项）
+bash scripts/verify-format-parity.sh /tmp/d2fix     # 与独立实现的完整差分
+```
+
+多人联机需要中继（自写、零依赖，只转发字节，不懂游戏）：
+
+```bash
+node scripts/net-server.ts 8787     # 或 npm run net-server
+# 每个浏览器开一页，2–4 人都可以（也可以在多台机器上，把 127.0.0.1 换成主机 IP）：
+#   http://127.0.0.1:5173/net.html?data=samples/fixtures&ws=ws://127.0.0.1:8787&peers=3&peer=0
+#   ...&peers=3&peer=1        ...&peers=3&peer=2
+```
+
+地图场景需要夹具被 HTTP 提供（`samples/` 已在 .gitignore 内）：
+
+```bash
+node scripts/make-map-fixtures.ts samples/fixtures
+# 打开 http://127.0.0.1:5173/map.html?data=samples/fixtures
+# 或走归档路径：http://127.0.0.1:5173/map.html?mpq=samples/fixtures/fixture.mpq
+```
+
+在暗黑1 试玩版 `spawn.mpq`（25.8 MB / 1029 项）上的实测结果：
+
+| 检查 | 结果 |
+| --- | --- |
+| 成员解包 | **1024/1029 精确解出，0 个长度不符**（5 项是归档 listfile 与实际条目不一致） |
+| PCX / CEL / TRN 魔数 | 全部通过 |
+| 压缩掩码 | 1010 zlib、14 原样存储 → **只需 zlib** |
+| `.cl2` 精灵 | **305/305 用游戏表宽度解出**（玩家 96、怪物 128） |
+| `.cel` 精灵 | **217/221 单宽度自动推断成功**（含 12 张 640px 过场图） |
+| 逐帧宽度精灵 | `data\inv\objcurs.cel` 179 帧按宽度表全部解出，无空帧 |
+
+### 宽度的真相（踩坑记录）
+
+CEL / CL2 **都不存储帧宽度**：
+
+- `.cel` 的游程是**行封闭**的，所以"每个游程正好填满一行"这个判据是真的——
+  错误宽度会让游程溢出整行而被拒绝，因此单宽度自动推断是**可靠**的。
+- `.cl2` 的游程**可以跨行**，任何宽度都能把游程流消费到帧尾，"精确消费"这个判据**恒真**。
+  宽度只能来自游戏数据（`SetPlrAnims` 给玩家站立/行走 96、近战攻击 128；
+  `monsterdata[].width` 给怪物 128）。可用的弱判据是"游程流正好落在列边界"（`cl2WidthCandidates`）。
+- 地砖表与光标表是**逐帧不同宽度**的（`data\inv\objcurs-widths.txt`、地砖定义），
+  单宽度推断必然失败——这不是解码器 bug，见 `decodeSpriteFile` 的 `widths` 选项。
+
+## 浏览器端
+
+```bash
+npm install
+npm run dev
+#   http://127.0.0.1:5173/            资源检查器（?sample=samples/spawn.mpq 免拖拽自检）
+#   http://127.0.0.1:5173/walk.html  可行走场景（同上）
+#   http://127.0.0.1:5173/map.html?data=samples/fixtures       单人地图场景
+#   http://127.0.0.1:5173/net.html?data=samples/fixtures&ws=ws://127.0.0.1:8787&peers=3&peer=0   多人联机
+```
+
+
+## 验收：整条目标链的证据（12 轮）
+
+目标是从零做一个**浏览器内可玩**的暗黑破坏神 2 引擎，读**用户自备**的旧版 D2 MPQ，
+依次打通 M0→M5，最终形成可玩的垂直切片。逐项对照如下——每条都给出**可复现的命令或页面**，
+不是"应该能跑"。
+
+| 里程碑 | 交付物 | 证据（可复现） | 强度 |
+| --- | --- | --- | --- |
+| M0 资源管线 | `src/mpq/`（v1 容器、crypt、解压掩码）、`src/formats/`（DC6/DS1/DT1/PAL/PL2/CEL/CL2/TBL）、`index.html` 可视化检查器 | `verify-archive.ts` 全量解包 **暗黑1 正版 `spawn.mpq`**（25.8 MB / 1029 项）+ 魔数校验；`verify-sprites.ts` 全量精灵解码；`verify-mpq-roundtrip.ts` 自写 MPQ 写入器往返 + `mpyq` 独立读取；`bash scripts/verify-format-parity.sh` 与 `dc6png`、OpenDiablo2 三个 Go 实现全字段差分 **ALL PARITY CHECKS PASSED** | 强（真 D1 归档 + 独立实现） |
+| M1 可走地图 | `map.html` + `src/game/map.ts`（DS1+DT1 合成、5×5 子瓦片碰撞、深度插入）、8 方向动画、25 Hz 循环 | `verify-depth-order.ts` 深度规则；浏览器实跑 `map.html?mpq=samples/fixtures/fixture.mpq`（真 MPQ → 真地图）；25 tps 实测 | 强（结构）/ 中（DT1 像素落位仅夹具自洽） |
+| M2 战斗沙盒 | `src/game/combat.ts`（追逐/攻击/冷却/受击/死亡/重生/经验/升级）、血蓝球 HUD | `verify-combat.ts` **38 项**：命中判定、冷却、法力消耗、经验与升级、死亡与重生顺序、确定性重放 | 强（自洽行为） |
+| M3 物品系统 | `src/game/items.ts`（基础物品、前后缀、词缀适用范围、按格背包/堆叠/金币、掉落流） | `verify-items.ts` **58 项**：词缀资格、掉落确定性、格子放置与堆叠、金币 | 强（自洽行为） |
+| M4 技能/任务/NPC | `src/game/skills.ts`、`quests.ts`、`tables.ts`、`TBL` 文本源、对话 | `verify-m4.ts` **56 项**：投射物、技能伤害曲线、任务计数与奖励、对话通过 TBL 解析 | 强（自洽行为）/ TBL 布局弱（见下） |
+| M5 存档与联机 | `src/game/save.ts`（快照 + `.d2s`）、`src/net/`（协议、传输、锁步、2–4 人）、`net.html` | `verify-m5.ts` **33 项**（读档续跑逐 tick 一致）；`verify-net.ts` **143 项**（2/3/4 人、慢链路、篡改检测、真 socket）；浏览器：**三个 Chromium 实例**同时联机，三页 worldTick 306 齐平、哈希全一致、世界逐字段相同 | 强（无外部实现可对照，故只证明自家实现自洽） |
+
+**浏览器里现在能玩什么**（都只读用户自备 MPQ/夹具，仓库不含任何暴雪素材）：
+
+```bash
+npm install && npm run dev          # 夹具：node scripts/make-map-fixtures.ts samples/fixtures
+# 单人战役沙盒（走路/砍怪/掉落/拾取/技能/任务/NPC/存读档）：map.html?data=samples/fixtures
+# 用真归档：map.html?mpq=<你的 .mpq>（暗黑1 试玩版 spawn.mpq 已验证）
+# 2–4 人联机：先 npm run net-server，再每页开一个 net.html?ws=ws://127.0.0.1:8787&peers=3&peer=N
+# 真实 D2 五个 act 的城镇（无怪物，走位/碰撞；数据来自 samples/d2，按 HTTP range 只读所需字节）：
+#   http://127.0.0.1:5173/acts.html?act=1        # act 1..5；?quadrant=<DS1 名> 切换地图块
+#   线上同一页面：https://www.laiseek.xyz/diablo2/?act=1（默认走预解包资源包；?live=1 强制直接读归档）
+#
+# 资源包（离线解包成 web 原生格式：索引 PNG 图集 + scene.json）：
+#   npm run pack:data      # 预置关卡 → samples/d2-packs（当前 62 个地图块 / 46.7 MB）
+#   npm run verify:packs   # 与"现读现解"逐项比对（绘制序、碰撞栅格逐字节、每帧像素哈希）
+# 线上产物：
+#   npm run build:game     # → dist-game/（base=/diablo2/），再拷到 /var/www/d2web
+# 线上实测（同一台服务器、真实 TLS）：
+#   act1 资源包 4 请求 / 1.21 MB / 首帧 1.5 s   ←→  读归档 1344 请求 / 6.22 MB / 12.1 s
+#   act5 资源包 9 请求 / 3.80 MB / 首帧 2.1 s   ←→  读归档 3971 请求 / 11.24 MB / 36.5 s
+```
+
+### 仍然缺什么（诚实记录）
+
+1. **真 D2 MPQ 已到手，且能读了**。用户自备的 1.13c 数据在 `samples/d2/`（11 个 MPQ，
+   来源与 sha256 见 `samples/d2/MANIFEST.md`），**PKWARE implode 解码器已实现**
+   （`src/mpq/implode.ts`）：`npm run verify:implode` 实测 30,914 个成员、893 MB 全部解出；
+   `npm run verify:acts` 把五个 act 的城镇从 `levels/lvltypes/lvlprest` 一路解到等距场景，40/40。
+   **`/acts.html?act=1..5` 现在能在浏览器里走真实城镇**（无怪物），线上
+   <https://www.laiseek.xyz/diablo2/?act=1>；**DCC + COF 解码器已实现**
+   （`src/formats/dcc.ts` / `cof.ts`，按 OpenDiablo2 的 d2dcc/d2cof 独立移植，
+   `npm run verify:dcc` 逐层比对），角色不再是占位棋子而是**真·女法师**：
+   行走 `SOWLHTH` 16 方向 × 8 帧 × 8 层、站立 `SONUHTH` 合成后画在脚下，
+   `d2char.mpq` 只按 HTTP range 取需要的成员。
+   仍缺的：**可破坏物品的静态美术帧**（`Objects.txt` 的 token/mode 与成员已进资源包，
+   解码器也已就绪，只差把它们插进绘制序）、**ADPCM+Huffmann 音频**（572 个成员）、
+   以及下面这些"待真文件确认"的项——它们现在有真数据了：
+   DT1 block 数据偏移基准（真文件已解出，`dt1.ts` 已按真布局修正）、经典 `string.tbl` 索引布局、
+   `.d2s` 各数据段布局。引擎对这些一律**保持原字节而不猜**。
+2. **D2 的表列映射层**：真实 `MonStats.txt`/`weapons.txt` 等是制表符大表，列名映射只按夹具列名
+   与少量官方文档验证过，接上真表后需要逐列核对（代码里已把列名集中，改起来是一处）。
+3. **多人尚未覆盖的工程项**：入场大厅/断线重连的策略选择（现在是"少一人就等"）、
+   输入回滚（现在只做等待）、以及把联机接进单人战役那套存档/任务状态
+   （目前联机是独立沙盒：世界与角色是共享的，背包/任务不进网络）。
+
+## 路线
+
+| 里程碑 | 内容 |
+| --- | --- |
+| **M0** ✅ | MPQ 容器 + 解压 + 精灵/调色板解码 + 浏览器检查器 |
+| **M1** 🚧 | DS1+DT1 地图渲染、子瓦片碰撞、**8 方向角色动画与深度排序**均已在浏览器内验证（合成夹具）；**待接入真实 MPQ 数据**；DCC/COF（复合动画）留待有真文件时做——Go 参考实现自己就未实现 bottom-up 帧，做不了完整对照 |
+| **M2** ✅ | 战斗沙盒：表驱动怪物、AI 状态机、近战与冷却、血蓝球、经验与升级（真表待接入） |
+| **M3** ✅ | 物品：表驱动基物与词缀、掉落（可复现随机）、背包网格、金币、拾取（真表待接入） |
+| **M4** ✅ | 技能（投射物/瞬发）、TBL 文本、任务状态机与奖励、NPC 状态台词（真表待接入） |
+| **M5** ✅ | 存档快照（读档续跑逐 tick 一致）、`.d2s` 核心字段与校验和、确定性锁步（输入延迟 + 逐 tick 哈希 + 检测到分歧即报 tick）、**WebSocket 传输层与 2–4 人浏览器实测**均已跑通；`.d2s` 数据段布局待真文件确认 |
+
+## 第三方参考
+
+格式语义的移植参考：
+
+- [StormLib](https://github.com/ladislav-zezula/StormLib)（MIT，© Ladislav Zezula）— MPQ 容器、密码学、解压
+- [DevilutionX](https://github.com/diasurgical/DevilutionX) / [Devilution](https://github.com/diasurgical/devilution) —
+  CEL/CL2 帧结构与游程语义、玩家/怪物宽度表、方向顺序
+
+### 验证强度分级（诚实记录）
+
+| 格式 | 独立对照 | 强度 |
+| --- | --- | --- |
+| MPQ 容器 | `mpyq`（Python）+ StormLib 语义 | 强（往返 + 独立读取） |
+| DC6 | `dc6png`（JS）+ `OpenDiablo2/dc6`（Go） | 强（像素 + 全字段） |
+| DS1 / DT1 元数据 / PL2 | `OpenDiablo2` 对应 Go 包 | 强（全字段 / 逐表摘要） |
+| DT1 像素落位 | 夹具期望网格（编码器↔解码器） | 中（自洽，非独立） |
+| CEL / CL2（D1） | 真实归档全量 + 游戏表宽度 | 强（真数据） |
+| 联机锁步 | 无（自行设计，无外部实现可对照） | 强（两独立世界 + 真 TCP/WebSocket + 真浏览器两实例；**但只验证过自家实现**） |
+| TBL | 无（Go 包实现的是带哈希表的扩展变体） | **弱（仅构造检查，待真文件确认）** |
+
+详见 `THIRD_PARTY_NOTICES.md`。本项目为独立 TypeScript 实现，不复制 C/C++ 源码。
diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
new file mode 100644
index 0000000..c862189
--- /dev/null
+++ b/THIRD_PARTY_NOTICES.md
@@ -0,0 +1,13 @@
+# Third-party notices
+
+## StormLib (reference for MPQ format semantics)
+
+`src/mpq/crypt.ts` and `src/mpq/decompress.ts` implement algorithms whose
+semantics were ported from the public StormLib reference so that behaviour
+matches real archives exactly (hash selectors, the block cipher, the
+plain-name file key, and the fixed codec order of a combined compression
+mask). The TypeScript code here is an independent implementation; no C++
+source is copied verbatim.
+
+StormLib — <https://github.com/ladislav-zezula/StormLib>
+Copyright (c) Ladislav Zezula — MIT License.
diff --git a/acts.html b/acts.html
new file mode 100644
index 0000000..b4805a1
--- /dev/null
+++ b/acts.html
@@ -0,0 +1,54 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>d2web · 暗黑破坏神 2 地图与法师</title>
+    <style>
+      :root { color-scheme: dark; }
+      * { box-sizing: border-box; }
+      html, body { margin: 0; height: 100%; background: #0b0906; color: #e8dcc8;
+        font: 13px/1.5 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; overflow: hidden; }
+      /* 画布铺满窗口；HUD 与控制器浮在上面 */
+      #view { position: fixed; inset: 0; width: 100%; height: 100%; display: block; background: #000; }
+      .overlay { position: fixed; z-index: 2; background: rgba(11, 9, 6, .82); border: 1px solid #33291f;
+        border-radius: 6px; backdrop-filter: blur(3px); }
+      header { top: 0; left: 0; right: 0; padding: 6px 12px; border-radius: 0; border-width: 0 0 1px 0;
+        display: flex; gap: 14px; align-items: baseline; flex-wrap: wrap; }
+      h1 { font-size: 13px; margin: 0; color: #c8a15a; letter-spacing: .06em; }
+      a { color: #c8a15a; }
+      #hud { color: #9c8d78; }
+      #controls { left: 12px; bottom: 12px; padding: 8px 12px; display: flex; gap: 12px;
+        align-items: center; flex-wrap: wrap; max-width: calc(100vw - 24px); }
+      #controls label { color: #9c8d78; }
+      select { background: #1c1813; color: #e8dcc8; border: 1px solid #33291f;
+        border-radius: 4px; padding: 3px 6px; font: inherit; max-width: 28vw; }
+      optgroup { background: #1c1813; color: #c8a15a; }
+      option { background: #1c1813; }
+      /* 状态面板放在控件行上方：贴在右下角会压住"细分场景"那个下拉框 */
+      #status { right: 12px; bottom: 58px; padding: 6px 10px; max-width: 60vw; color: #9c8d78; }
+      .hint { color: #6d5a34; }
+    </style>
+  </head>
+  <body>
+    <header class="overlay">
+      <h1>d2web · 暗黑破坏神 2</h1>
+      <span id="hud">—</span>
+    </header>
+    <div id="controls" class="overlay">
+      <label>章节 <select id="act" disabled>
+        <option value="1">第一章</option>
+        <option value="2">第二章</option>
+        <option value="3">第三章</option>
+        <option value="4">第四章</option>
+        <option value="5">第五章</option>
+      </select></label>
+      <label>场景 <select id="scene" disabled><option>正在读取场景列表…</option></select></label>
+      <label>细分场景 <select id="variant" disabled></select></label>
+      <span class="hint" style="margin:0">WASD / 方向键移动 · 滚轮或 +/− 缩放 · 三个下拉框都会换图并更新地址栏</span>
+    </div>
+    <div id="status" class="overlay">正在加载地图…</div>
+    <canvas id="view" width="960" height="560"></canvas>
+    <script type="module" src="/src/scene/act-scene.ts"></script>
+  </body>
+</html>
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..3c49b95
--- /dev/null
+++ b/index.html
@@ -0,0 +1,110 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>d2web · MPQ 资源管线</title>
+    <style>
+      :root {
+        color-scheme: dark;
+        --bg: #14110d;
+        --panel: #1c1813;
+        --line: #33291f;
+        --ink: #e8dcc8;
+        --dim: #9c8d78;
+        --accent: #c8a15a;
+        --accent-dim: #6d5a34;
+      }
+      * { box-sizing: border-box; }
+      body {
+        margin: 0;
+        background: var(--bg);
+        color: var(--ink);
+        font: 13px/1.5 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+      }
+      header {
+        padding: 14px 18px;
+        border-bottom: 1px solid var(--line);
+        display: flex;
+        align-items: baseline;
+        gap: 14px;
+        flex-wrap: wrap;
+      }
+      h1 { font-size: 15px; margin: 0; letter-spacing: 0.06em; color: var(--accent); }
+      .hint { color: var(--dim); }
+      main { display: grid; grid-template-columns: minmax(280px, 380px) 1fr; gap: 0; height: calc(100vh - 52px); }
+      .col { overflow: auto; }
+      .col + .col { border-left: 1px solid var(--line); }
+      .pad { padding: 14px 18px; }
+      #drop {
+        margin: 18px;
+        padding: 26px 18px;
+        border: 1px dashed var(--accent-dim);
+        border-radius: 8px;
+        text-align: center;
+        color: var(--dim);
+        cursor: pointer;
+      }
+      #drop.hot { border-color: var(--accent); color: var(--accent); }
+      .stats { display: grid; grid-template-columns: auto 1fr; gap: 2px 12px; margin: 0 18px 12px; }
+      .stats dt { color: var(--dim); }
+      .stats dd { margin: 0; }
+      #filter {
+        width: calc(100% - 36px);
+        margin: 0 18px 10px;
+        padding: 7px 9px;
+        background: var(--panel);
+        color: var(--ink);
+        border: 1px solid var(--line);
+        border-radius: 5px;
+      }
+      ul { list-style: none; margin: 0; padding: 0 0 24px; }
+      li button {
+        width: 100%;
+        text-align: left;
+        padding: 3px 18px;
+        background: none;
+        border: 0;
+        color: var(--ink);
+        font: inherit;
+        cursor: pointer;
+      }
+      li button:hover { background: #241d16; }
+      li button[aria-current='true'] { background: var(--accent-dim); color: #fff; }
+      li .meta { color: var(--dim); font-size: 11px; }
+      #preview { padding: 16px 18px; }
+      #preview h2 { font-size: 13px; margin: 0 0 4px; color: var(--accent); word-break: break-all; }
+      #preview .sub { color: var(--dim); margin-bottom: 12px; }
+      canvas { image-rendering: pixelated; background: #000; border: 1px solid var(--line); }
+      pre {
+        margin: 0;
+        padding: 10px;
+        background: var(--panel);
+        border: 1px solid var(--line);
+        border-radius: 5px;
+        overflow: auto;
+        max-height: 60vh;
+        white-space: pre-wrap;
+        word-break: break-all;
+      }
+      .error { color: #e08a6a; }
+    </style>
+  </head>
+  <body>
+    <header>
+      <h1>d2web</h1>
+      <span class="hint">MPQ 资源管线 · 只读取你自己的归档，仓库不含任何游戏素材</span>
+    </header>
+    <main>
+      <section class="col" id="left">
+        <div id="drop">把 .mpq 拖到这里，或点击选择文件</div>
+        <input id="picker" type="file" accept=".mpq,.MPQ" hidden />
+        <dl class="stats" id="stats"></dl>
+        <input id="filter" type="search" placeholder="筛选文件名…" disabled />
+        <ul id="files"></ul>
+      </section>
+      <section class="col" id="preview"><div class="pad hint">选择一个文件查看解码结果</div></section>
+    </main>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
diff --git a/map.html b/map.html
new file mode 100644
index 0000000..4f14d7a
--- /dev/null
+++ b/map.html
@@ -0,0 +1,54 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>d2web · DS1/DT1 地图场景（M1）</title>
+    <style>
+      :root { color-scheme: dark; }
+      * { box-sizing: border-box; }
+      body { margin: 0; background: #0d0b09; color: #e8dcc8;
+        font: 13px/1.5 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
+      header { padding: 10px 16px; border-bottom: 1px solid #33291f;
+        display: flex; gap: 14px; align-items: baseline; flex-wrap: wrap; }
+      h1 { font-size: 14px; margin: 0; color: #c8a15a; letter-spacing: .06em; }
+      a { color: #c8a15a; }
+      #hud { color: #9c8d78; }
+      #drop { margin: 10px 16px 6px; padding: 8px 12px; border: 1px dashed #6d5a34;
+        border-radius: 6px; color: #9c8d78; cursor: pointer; }
+      #drop.hot { border-color: #c8a15a; color: #c8a15a; }
+      #controls { margin: 0 16px 8px; display: flex; gap: 10px; align-items: center; flex-wrap: wrap; }
+      #controls label { color: #9c8d78; }
+      select { background: #1c1813; color: #e8dcc8; border: 1px solid #33291f;
+        border-radius: 4px; padding: 3px 6px; max-width: 340px; font: inherit; }
+      button { background: #241d16; color: #e8dcc8; border: 1px solid #33291f;
+        border-radius: 4px; padding: 4px 10px; font: inherit; cursor: pointer; }
+      #status { margin: 0 16px 10px; color: #9c8d78; }
+      #dialog { margin: 0 16px 10px; padding: 10px 12px; max-width: 720px;
+        background: #1c1813; border: 1px solid #6d5a34; border-radius: 6px;
+        color: #e8dcc8; white-space: pre-wrap; }
+      canvas { display: block; margin: 0 16px; background: #000; border: 1px solid #33291f;
+        width: 960px; height: 560px; }
+    </style>
+  </head>
+  <body>
+    <header>
+      <h1>d2web · DS1 + DT1 地图</h1>
+      <a href="/">资源检查器</a>
+      <a href="/walk.html?sample=samples/spawn.mpq">暗黑1 走动演示</a>
+      <span id="hud">—</span>
+    </header>
+    <div id="drop">拖入 .mpq 打开你的归档；或用 ?mpq=&lt;url&gt; / ?data=&lt;fixture 目录&gt;</div>
+    <input id="picker" type="file" accept=".mpq,.MPQ" hidden />
+    <div id="controls" hidden>
+      <label>关卡 DS1 <select id="ds1"></select></label>
+      <label>瓦片 DT1 <select id="dt1"></select></label>
+      <label>调色板 <select id="pal"></select></label>
+      <button id="reload">重新加载</button>
+    </div>
+    <p id="status">正在加载地图…</p>
+    <div id="dialog" hidden></div>
+    <canvas id="view" width="960" height="560"></canvas>
+    <script type="module" src="/src/scene/map-scene.ts"></script>
+  </body>
+</html>
diff --git a/net.html b/net.html
new file mode 100644
index 0000000..c5de5e8
--- /dev/null
+++ b/net.html
@@ -0,0 +1,46 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>d2web · 联机合作（M5）</title>
+    <style>
+      :root { color-scheme: dark; }
+      * { box-sizing: border-box; }
+      body { margin: 0; background: #0d0b09; color: #e8dcc8;
+        font: 13px/1.5 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
+      header { padding: 10px 16px; border-bottom: 1px solid #33291f;
+        display: flex; gap: 14px; align-items: baseline; flex-wrap: wrap; }
+      h1 { font-size: 14px; margin: 0; color: #c8a15a; letter-spacing: .06em; }
+      a { color: #c8a15a; }
+      #net { color: #9c8d78; }
+      #net b { color: #c8a15a; font-weight: 600; }
+      #net .bad { color: #d96a5a; }
+      #status { margin: 10px 16px 6px; color: #9c8d78; }
+      #peers { margin: 0 16px 8px; color: #9c8d78; }
+      #peers span.you { color: #7fd08a; }
+      canvas { display: block; margin: 0 16px; background: #000; border: 1px solid #33291f;
+        width: 960px; height: 560px; }
+      #help { margin: 8px 16px 16px; color: #6f6252; max-width: 900px; }
+    </style>
+  </head>
+  <body>
+    <header>
+      <h1>d2web · 双人联机合作</h1>
+      <a href="/">资源检查器</a>
+      <a href="/map.html?data=samples/fixtures">单人地图场景</a>
+      <span id="net">未联机</span>
+    </header>
+    <p id="status">正在加载地图…</p>
+    <div id="peers"></div>
+    <canvas id="view" width="960" height="560"></canvas>
+    <p id="help">
+      移动 WASD / 方向键，空格或 J 攻击。每个浏览器页开一个（2–4 人都可以，人数用
+      <code>&amp;peers=</code> 指定，<code>&amp;peer=</code> 是本页编号）：
+      <code>?data=samples/fixtures&amp;ws=ws://127.0.0.1:8787&amp;peers=3&amp;peer=0</code>，
+      另外两页把 <code>peer</code> 换成 1 和 2。世界由每台机器各自模拟，网络上只传按键；
+      同一 tick 的哈希不一致时页面会立刻报出分歧。
+    </p>
+    <script type="module" src="/src/scene/net-scene.ts"></script>
+  </body>
+</html>
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..2121f48
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,977 @@
+{
+  "name": "d2web",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "d2web",
+      "version": "0.1.0",
+      "devDependencies": {
+        "@types/node": "^22.20.2",
+        "typescript": "^5.6.3",
+        "vite": "^5.4.10"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
+      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
+      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
+      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
+      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
+      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
+      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
+      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
+      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
+      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
+      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
+      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
+      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
+      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
+      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
+      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
+      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
+      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
+      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
+      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@napi-rs/lzma-linux-x64-gnu": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmmirror.com/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz",
+      "integrity": "sha512-oTXEIha4SsuXdTA4Iyskj0kpdx2yVXdhd75c2v3xGrHFfVMsbhTPZU/nMPL4sWKo4pBHm3aucLaqGlF696dTyQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^22.20 || ^24.12 || >=25"
+      }
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.63.1.tgz",
+      "integrity": "sha512-UZ8sUxPTiHWYX9QNdJedb1kDZSpS1t/VPWBWGSgqHNi9w3Cu6IXvu2mzbhiTiPvtrqgTQJ+zqiAq2iPIPilpaQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.63.1.tgz",
+      "integrity": "sha512-cQ4nFQABN5cDvDpbvJ7bMStCpnaVxynZrRMfUJYgxcIk9Sh54FIO1vtfkg0B69REjER77ioZ/ov+eAApx/KmLQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.63.1.tgz",
+      "integrity": "sha512-FQNqd1lRy/0QhDk3xeRIkSBiCpXCiDnZO3YLVdcDKN1UBiKToNftCzcXYNLshmPDUMlu2TdeS8tGcsU6f3YF1Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.63.1.tgz",
+      "integrity": "sha512-pvD16V939D3CloK0+qikpGaxiPrDUXTe7Y5cWOMkMSy7m1cawa8EGy/kXYi/G/cKAC4HDAbSnzCIk1WmsoOKXg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.63.1.tgz",
+      "integrity": "sha512-pcFGeL2345VwdTnJhA6zLbew+YgWB0qBG2+dMtXjCicf6+rm6kO6cOoh5VnTe0ZMrMRgRyuHmCJxZWrIdzYuOw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.63.1.tgz",
+      "integrity": "sha512-mRJlqSRulVzcKq/LKA6ICSIc3K/l4fzlVn/gePn2nXIHy8seRi5z/eeRE0d/XMBxcMldiXtQTSpRj0tkkC3g8Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.63.1.tgz",
+      "integrity": "sha512-YDUNvVM85TI3g/1OpnqKP1h4NeW/j64DfWMf+G3M809xNk1bJSnpFp4sh83NpmVE5DXnkh8ULor4LTVZKoYLHw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.63.1.tgz",
+      "integrity": "sha512-7Mcn71p9ZuQFAj+h+dhQXy/yeLePRS2yKRnmW1DijA9thKO5qap0GNOIQK4yQ6iP3SU0Mrb/yWo8h8vgRba8lw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.63.1.tgz",
+      "integrity": "sha512-4YiLQTX6U4CSl0L9cluep9A9W6UmTfqBDc2/CH6wlu54pl4E7Jn3cOD8oxzvBDEGk/JMKgJ47C8g+radF7mwvg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.63.1.tgz",
+      "integrity": "sha512-2ra8F7w8OquwZN9z2/fKFnli69wa8PLwaVzRMIPGb13ByMJwC28Fbp8YcVGoUhlYMTt7j5j9bNgpysrN2UM+vw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.63.1.tgz",
+      "integrity": "sha512-Sy20ncyhjmBP0Ml+UvQbimjlk6VFgjW5uNP+qqwHB00mTE8Bl2C1TuHTlRwK2YoXeZbee5lP2XevBWVkAQAtSQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.63.1.tgz",
+      "integrity": "sha512-noITLp8oNjYliPnGWmLyelIHwULGqbHloQHGw1rtxbWhTuWooRpnZarZQJ1y9EUC4szuCusCc+HEpUtxpIwYvA==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.63.1.tgz",
+      "integrity": "sha512-hlxxXd+F1mWiAcaFR7Sv9ZQT6m6UfI8+Vy/kFJzztq2pDMU/0wZ9sish0iszNZvsQDo8Gc0i5yuFEOz5dDf6fA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.63.1.tgz",
+      "integrity": "sha512-EF7OpqQTQ/BvGqLzUi4rEHuagCV9MugAUXSHemwPW5vxZ75RR+jxO/2j95Ph2dalMpFHSVECjRoioHZgA9zOYA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.63.1.tgz",
+      "integrity": "sha512-wQO3JesW9PRkwlabQ27y7sPfVOOTLRG73I4F2UYHG5PXun3J9U3y+b7ezVKSYbsvSKGQ1k1cq8Qlun4C9kLt3w==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.63.1.tgz",
+      "integrity": "sha512-ouAGwhO6wHRXdnOVCOsB0tRFkA7nhNB2Nwax6oECXN0YiN8EYUTBAOudADOB1PI+yDL61TeNx/u7MVCzksNbkQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.63.1.tgz",
+      "integrity": "sha512-q2R38Sn+1J8RxhfJ+T54wSWmyKXWec+9jgDfqO2AtArEqHO5R2aeayp5H5OYLr5UYDVGsVaZPEFUooMhYCdz5A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.63.1.tgz",
+      "integrity": "sha512-gfI5T24WLLuFfSKw7Go/zDXjAAV0fny0swTaDv+WjK7vqcw4cRhFfdsyKL1n+ukI+ooBxn3bVQnyrn06WpI50w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.63.1.tgz",
+      "integrity": "sha512-4h6XqthmB4Hspji84wvgk+ElodTsGj+dbZqHJHHtKxj4mYq0ANSEEPX9ys3moJueqsRjwpaJYH7874Itwnj2ow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.63.1.tgz",
+      "integrity": "sha512-dlfCOa87o1VAYegLQ9EKilx2JCeRofiyPGhTCmqnuXZ6bMPiycO1rq1+sKoulAp7pGLIsTIw+1x5R+zgh5LhhA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.63.1.tgz",
+      "integrity": "sha512-cjkLbOlfcm3QGhMM1J5zaZjsw1GggbN6rw9UTSSRrPrR1KkcXnN7Uq9rPw34xImQ9VOY9GN+6u2Zj80B9ptkcw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.63.1.tgz",
+      "integrity": "sha512-Li1KdUnWGE4N3e1F/B4RTB1ms+nG4WBgjByO46pkeBVX/2UBsY53xf5vK9WygVmnH3RwncIST7lkSdLSY6P9lg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.63.1.tgz",
+      "integrity": "sha512-t4ZYOSoLTgwhuFMrmTMLx/+i1DQVK7HYqMc6kY46EApwi8X0nIVphzdNoThU3xt6n+N5urG1/gxBdCaKDLavfg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.63.1.tgz",
+      "integrity": "sha512-RgroPfMmKlD1RzSDxvwgcPiy2HNQKoYV7OmwIXDsk73uKW5t6B/V8KIy27SMv/FNXFo/oSBtWc9J0X7t91ezZg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.63.1.tgz",
+      "integrity": "sha512-at8QVep6S3h5Y6gSbdGU06bRY5WJkf6WUduM9YtvYMbYhB1MOFfUgc6kehitQXzOtMSaT70q7f9ydPhpqu821w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmmirror.com/@types/estree/-/estree-1.0.9.tgz",
+      "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",
+      "dev": true
+    },
+    "node_modules/@types/node": {
+      "version": "22.20.2",
+      "resolved": "https://registry.npmmirror.com/@types/node/-/node-22.20.2.tgz",
+      "integrity": "sha512-xlvWf4Vs9n1PEVYwP1n4vvG07M6y8WgvJ2t0vbrWTmijsIHp1cS+uJ2kMIRdY3nHZK0nCYKrPeD171+SzF4/zw==",
+      "dev": true,
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmmirror.com/esbuild/-/esbuild-0.21.5.tgz",
+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.21.5",
+        "@esbuild/android-arm": "0.21.5",
+        "@esbuild/android-arm64": "0.21.5",
+        "@esbuild/android-x64": "0.21.5",
+        "@esbuild/darwin-arm64": "0.21.5",
+        "@esbuild/darwin-x64": "0.21.5",
+        "@esbuild/freebsd-arm64": "0.21.5",
+        "@esbuild/freebsd-x64": "0.21.5",
+        "@esbuild/linux-arm": "0.21.5",
+        "@esbuild/linux-arm64": "0.21.5",
+        "@esbuild/linux-ia32": "0.21.5",
+        "@esbuild/linux-loong64": "0.21.5",
+        "@esbuild/linux-mips64el": "0.21.5",
+        "@esbuild/linux-ppc64": "0.21.5",
+        "@esbuild/linux-riscv64": "0.21.5",
+        "@esbuild/linux-s390x": "0.21.5",
+        "@esbuild/linux-x64": "0.21.5",
+        "@esbuild/netbsd-x64": "0.21.5",
+        "@esbuild/openbsd-x64": "0.21.5",
+        "@esbuild/sunos-x64": "0.21.5",
+        "@esbuild/win32-arm64": "0.21.5",
+        "@esbuild/win32-ia32": "0.21.5",
+        "@esbuild/win32-x64": "0.21.5"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmmirror.com/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.19",
+      "resolved": "https://registry.npmmirror.com/nanoid/-/nanoid-3.3.19.tgz",
+      "integrity": "sha512-Y2tUNy4ouw6tq5oDSKeQYGOyhkUBhNOcGV/02KC+6kd9eDGqdZd++mjMiIDilrBYvjEnCYvVtsuHCuP+okSfug==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmmirror.com/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true
+    },
+    "node_modules/postcss": {
+      "version": "8.5.28",
+      "resolved": "https://registry.npmmirror.com/postcss/-/postcss-8.5.28.tgz",
+      "integrity": "sha512-RRuzqDtt5Y9h3quz5hWhK+TPnsmVs6WwSU6LkJMeY4HstUEDuYTG8UJSdawMRzmzAtV+KEoG8N3Qg2qLy5vM/A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "nanoid": "^3.3.18",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmmirror.com/rollup/-/rollup-4.63.1.tgz",
+      "integrity": "sha512-3Df9jsstwhccuEfmAMi9l8XUh/GOkVObmFTU7CCVBysEbcOZLl84jCtaAZMcPiMz2EGKsATzQcU+Xr3n/wU6cg==",
+      "dev": true,
+      "dependencies": {
+        "@types/estree": "1.0.9"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@napi-rs/lzma-linux-x64-gnu": "1.5.1",
+        "@rollup/rollup-android-arm-eabi": "4.63.1",
+        "@rollup/rollup-android-arm64": "4.63.1",
+        "@rollup/rollup-darwin-arm64": "4.63.1",
+        "@rollup/rollup-darwin-x64": "4.63.1",
+        "@rollup/rollup-freebsd-arm64": "4.63.1",
+        "@rollup/rollup-freebsd-x64": "4.63.1",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.63.1",
+        "@rollup/rollup-linux-arm-musleabihf": "4.63.1",
+        "@rollup/rollup-linux-arm64-gnu": "4.63.1",
+        "@rollup/rollup-linux-arm64-musl": "4.63.1",
+        "@rollup/rollup-linux-loong64-gnu": "4.63.1",
+        "@rollup/rollup-linux-loong64-musl": "4.63.1",
+        "@rollup/rollup-linux-ppc64-gnu": "4.63.1",
+        "@rollup/rollup-linux-ppc64-musl": "4.63.1",
+        "@rollup/rollup-linux-riscv64-gnu": "4.63.1",
+        "@rollup/rollup-linux-riscv64-musl": "4.63.1",
+        "@rollup/rollup-linux-s390x-gnu": "4.63.1",
+        "@rollup/rollup-linux-x64-gnu": "4.63.1",
+        "@rollup/rollup-linux-x64-musl": "4.63.1",
+        "@rollup/rollup-openbsd-x64": "4.63.1",
+        "@rollup/rollup-openharmony-arm64": "4.63.1",
+        "@rollup/rollup-win32-arm64-msvc": "4.63.1",
+        "@rollup/rollup-win32-ia32-msvc": "4.63.1",
+        "@rollup/rollup-win32-x64-gnu": "4.63.1",
+        "@rollup/rollup-win32-x64-msvc": "4.63.1",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmmirror.com/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmmirror.com/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmmirror.com/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true
+    },
+    "node_modules/vite": {
+      "version": "5.4.21",
+      "resolved": "https://registry.npmmirror.com/vite/-/vite-5.4.21.tgz",
+      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+      "dev": true,
+      "dependencies": {
+        "esbuild": "^0.21.3",
+        "postcss": "^8.4.43",
+        "rollup": "^4.20.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    }
+  }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..8be1af4
--- /dev/null
+++ b/package.json
@@ -0,0 +1,34 @@
+{
+  "name": "d2web",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "Web-native Diablo II engine: reads assets from a user-supplied classic MPQ. No game assets are bundled.",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc --noEmit && vite build",
+    "preview": "vite preview",
+    "typecheck": "tsc --noEmit",
+    "inspect": "node scripts/inspect-mpq.ts",
+    "net-server": "node scripts/net-server.ts",
+    "verify:net": "node scripts/verify-net.ts",
+    "verify:d2": "node scripts/verify-d2-data.ts",
+    "verify:implode": "node scripts/verify-implode.ts",
+    "verify:all": "node scripts/verify-combat.ts && node scripts/verify-items.ts && node scripts/verify-m4.ts && node scripts/verify-m5.ts && node scripts/verify-net.ts",
+    "verify:acts": "node scripts/verify-acts.ts",
+    "build:game": "vite build --base=/diablo2/ --outDir dist-game",
+    "pack:data": "node scripts/pack-act-assets.ts",
+    "verify:packs": "node scripts/verify-packs.ts",
+    "verify:deploy": "node scripts/verify-deploy.ts",
+    "verify:listfile": "node scripts/verify-listfile.ts",
+    "verify:object-lookup": "node scripts/verify-object-lookup.ts",
+    "port:object-lookup": "node scripts/port-object-lookup.ts",
+    "verify:alignment": "node scripts/verify-tile-alignment.ts",
+    "verify:tiles": "node scripts/verify-tiles.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.2",
+    "typescript": "^5.6.3",
+    "vite": "^5.4.10"
+  }
+}
diff --git a/scripts/browser/README.md b/scripts/browser/README.md
new file mode 100644
index 0000000..7f77120
--- /dev/null
+++ b/scripts/browser/README.md
@@ -0,0 +1,41 @@
+# 浏览器验证工具（零依赖）
+
+这些脚本用 Node 内置的 `WebSocket` 直接讲 CDP（Chrome DevTools Protocol），
+不需要 puppeteer/playwright 这类依赖。目的只有一个：**给"页面里到底发生了什么"留下证据**，
+因为像素和截图的判断在这套环境里不可靠（模型读不了图，`readPixels` 在合成后会返回清空缓冲）。
+
+## inspect-page.mjs —— 单页检查
+
+```bash
+CHROME=/root/.cache/ms-playwright/chromium-1223/chrome-linux64/chrome
+node scripts/browser/inspect-page.mjs "$CHROME" \
+  "http://127.0.0.1:5173/map.html?data=samples/fixtures" \
+  scripts/browser/checks/map-save-load.js --screenshot /tmp/map.png
+```
+
+它会启动一个 headless Chromium（SwiftShader 软件 WebGL2），打开 URL，等待页面加载，
+把 check 脚本的返回值打印成 JSON，可选截图。
+
+## many-pages.mjs —— N 页同时跑（联机用）
+
+```bash
+node scripts/browser/many-pages.mjs "$CHROME" \
+  "http://127.0.0.1:5173/net.html?data=samples/fixtures&ws=ws://127.0.0.1:8787&peers=3&peer=0" \
+  "http://127.0.0.1:5173/net.html?data=samples/fixtures&ws=ws://127.0.0.1:8787&peers=3&peer=1" \
+  "http://127.0.0.1:5173/net.html?data=samples/fixtures&ws=ws://127.0.0.1:8787&peers=3&peer=2" \
+  --seconds 20 --shot /tmp/coop
+```
+
+每一页是一个**独立的 Chromium 实例**（标签页级复用在这套 CDP 流程里会把两次导航混在一起，
+曾经导致"两页都跑成了 peer 0"这种假象）。它按页分发不同的方向键，让每个角色只受本页按键驱动，
+结束时打印每页的 `window.__d2web*` 状态。判定靠状态字段，不靠看图。
+
+## checks/ —— 页面内脚本
+
+| 文件 | 目标页面 | 做什么 |
+| --- | --- | --- |
+| `map-save-load.js` | `map.html` | 走位砍怪 → 存档 → 继续跑 → 读档，比较存档点与恢复后的位置/击杀/金币/地面/等级 |
+| `walk-state.js` | `walk.html` | 读真实 MPQ（暗黑1 `spawn.mpq`）后的就绪状态、tick、drawCalls、`glError` |
+| `net-state.js` | `net.html` | 单机模式的状态：世界 tick、角色数、怪物数、tps |
+| `act-state.js` | `acts.html`（`?live=1`） | 读归档路径：归档是否读入、DS1 象限、格数、瓦片引用缺失数、图集尺寸，以及按键后的位移与朝向 |
+| `act-pack-state.js` | `acts.html`（默认） | 资源包路径：是否走 pack、首帧装了几页（证明懒加载）、出画面毫秒数、按键位移与朝向 |
diff --git a/scripts/browser/checks/act-pack-state.js b/scripts/browser/checks/act-pack-state.js
new file mode 100644
index 0000000..a574d3b
--- /dev/null
+++ b/scripts/browser/checks/act-pack-state.js
@@ -0,0 +1,57 @@
+// act-pack-state.js — 资源包路径的状态断言（acts.html 默认路径）
+//
+// 判定全来自 window.__d2webAct：是不是走了资源包、首屏只装了几页（证明懒加载）、
+// 出画面用了多久、以及按键后角色是否沿屏幕方向位移且朝向正确。返回 JSON。
+//
+//   CHROME=/root/.cache/ms-playwright/chromium-1223/chrome-linux64/chrome
+//   node scripts/browser/inspect-page.mjs "$CHROME" \
+//     "http://127.0.0.1:5173/acts.html?act=1" scripts/browser/checks/act-pack-state.js
+(async () => {
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+  const deadline = Date.now() + 120000
+  while (Date.now() < deadline) {
+    const s = window.__d2webAct
+    if (s && (s.ready || s.error)) break
+    await sleep(200)
+  }
+  const atReady = { ...(window.__d2webAct ?? {}) }
+  await sleep(6000)
+  const after = { ...(window.__d2webAct ?? {}) }
+  const before = { x: after.x, y: after.y }
+  const press = (code, down) => window.dispatchEvent(new KeyboardEvent(down ? 'keydown' : 'keyup', { code, bubbles: true }))
+  press('ArrowRight', true); await sleep(900); press('ArrowRight', false)
+  await sleep(200)
+  const moved = { x: window.__d2webAct?.x ?? 0, y: window.__d2webAct?.y ?? 0, facing: window.__d2webAct?.facing ?? -1 }
+  return {
+    source: atReady.source, ready: atReady.ready, error: atReady.error ?? null,
+    base: atReady.base, act: atReady.act, level: atReady.level, quadrant: atReady.quadrant,
+    cells: `${atReady.cellsX}x${atReady.cellsY}`,
+    floors: atReady.floors, walls: atReady.walls, frames: atReady.frames, objects: atReady.objects,
+    character: atReady.character,
+    characterMembers: atReady.characterMembers,
+    characterAfter: after.character,
+    characterMembersAfter: after.characterMembers,
+    levelOptions: document.querySelector('#level')?.querySelectorAll('option').length ?? -1,
+    pickerSelected: document.querySelector('#level')?.selectedOptions?.[0]?.textContent ?? null,
+    pagesAtReady: `${atReady.pagesLoaded}/${atReady.pagesTotal}`,
+    pagesAtFirstFrame: `${atReady.pagesAtFirstFrame}/${atReady.pagesTotal}`,
+    firstFrameMs: atReady.firstFrameMs,
+    priorityPages: atReady.priorityPages,
+    lazyFirstFrame: atReady.pagesAtFirstFrame < atReady.pagesTotal,
+    pagesAfterWait: `${after.pagesLoaded}/${after.pagesTotal}`,
+    lazyFirstPaint: (atReady.pagesLoaded ?? 0) < (atReady.pagesTotal ?? 0),
+    loadMs: atReady.loadMs,
+    skippedAtReady: atReady.skippedDraws,
+    move: [Math.round(moved.x - before.x), Math.round(moved.y - before.y)],
+    facing: moved.facing,
+    tick: after.tick,
+    walkable: Number((atReady.walkable ?? 0).toFixed(3)),
+    // 画布是否铺满窗口 + 缩放是否至少覆盖视口
+    canvas: [after.canvasWidth, after.canvasHeight],
+    viewport: [window.innerWidth, window.innerHeight],
+    zoom: after.zoom,
+    coverZoom: Math.max(window.innerWidth / Math.max(1, after.widthPx), window.innerHeight / Math.max(1, after.heightPx)),
+    canvasFillsWindow: after.canvasWidth >= window.innerWidth - 2 && after.canvasHeight >= window.innerHeight - 2,
+    mapCoversViewport: (after.zoom ?? 0) + 1e-6 >= Math.max(window.innerWidth / Math.max(1, after.widthPx), window.innerHeight / Math.max(1, after.heightPx)),
+  }
+})()
diff --git a/scripts/browser/checks/act-state.js b/scripts/browser/checks/act-state.js
new file mode 100644
index 0000000..1fa2746
--- /dev/null
+++ b/scripts/browser/checks/act-state.js
@@ -0,0 +1,39 @@
+// act-state.js — act 城镇页的状态断言（acts.html）
+//
+// 判定全部来自 window.__d2webAct 的字段，不看图：归档是否真的读进来了、地图块
+// 有几格、瓦片引用是否全部解析、图集多大、以及按键之后角色是否真的沿屏幕方向
+// 位移且朝向正确。返回 JSON，由 scripts/browser/inspect-page.mjs 打印。
+//
+//   CHROME=/root/.cache/ms-playwright/chromium-1223/chrome-linux64/chrome
+//   node scripts/browser/inspect-page.mjs "$CHROME" \
+//     "http://127.0.0.1:5173/acts.html?act=1" scripts/browser/checks/act-state.js
+(async () => {
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+  const deadline = Date.now() + 150000
+  while (Date.now() < deadline) {
+    const s = window.__d2webAct
+    if (s && (s.ready || s.error)) break
+    await sleep(500)
+  }
+  const first = { ...(window.__d2webAct ?? {}) }
+  await sleep(1500)
+  const before = { x: window.__d2webAct?.x ?? 0, y: window.__d2webAct?.y ?? 0, tick: window.__d2webAct?.tick ?? 0 }
+  const press = (code, down) => window.dispatchEvent(new KeyboardEvent(down ? 'keydown' : 'keyup', { code, bubbles: true }))
+  // 向东走 1.2 秒，再向南走 1.2 秒；记录位移与朝向
+  press('ArrowRight', true); await sleep(1200); press('ArrowRight', false)
+  const east = { x: window.__d2webAct?.x ?? 0, y: window.__d2webAct?.y ?? 0, facing: window.__d2webAct?.facing ?? -1 }
+  press('ArrowDown', true); await sleep(1200); press('ArrowDown', false)
+  await sleep(300)
+  const south = { x: window.__d2webAct?.x ?? 0, y: window.__d2webAct?.y ?? 0, facing: window.__d2webAct?.facing ?? -1 }
+  return {
+    ready: first.ready, error: first.error ?? null,
+    act: first.act, level: first.level, quadrant: first.quadrant, quadrants: first.quadrants,
+    cells: `${first.cellsX}x${first.cellsY}`, scene: `${first.widthPx}x${first.heightPx}`,
+    floors: first.floors, walls: first.walls, frames: first.frames,
+    atlas: `${first.atlasWidth}x${first.atlasHeight}`,
+    missing: first.missing, walkable: Number((first.walkable ?? 0).toFixed(3)),
+    character: first.character, drawCalls: first.drawCalls, tickRate: Number((first.tickRate ?? 0).toFixed(1)),
+    moved: { east: [Math.round(east.x - before.x), Math.round(east.y - before.y)], south: [Math.round(south.x - east.x), Math.round(south.y - east.y)], tickDelta: (window.__d2webAct?.tick ?? 0) - before.tick },
+    facingEast: east.facing, facingSouth: south.facing,
+  }
+})()
diff --git a/scripts/browser/checks/map-save-load.js b/scripts/browser/checks/map-save-load.js
new file mode 100644
index 0000000..debca31
--- /dev/null
+++ b/scripts/browser/checks/map-save-load.js
@@ -0,0 +1,39 @@
+(async () => {
+  const sleep = (ms) => new Promise(r => setTimeout(r, ms))
+  const key = (type, code) => window.dispatchEvent(new KeyboardEvent(type, { code, bubbles: true }))
+  const tap = async (code, ms) => { key('keydown', code); await sleep(ms); key('keyup', code); await sleep(60) }
+  for (let i = 0; i < 40 && (window.__d2webMap === undefined || window.__d2webMap.tick < 5); i++) await sleep(250)
+  const state = window.__d2webMap
+  if (state === undefined) return { error: 'no scene state' }
+  const snap = () => ({
+    tick: state.tick, x: Math.round(state.x), y: Math.round(state.y), level: state.playerLevel,
+    xp: state.playerXp, kills: state.kills, gold: state.gold, bag: state.bagItems,
+    ground: state.groundItems, monsters: state.monstersNear ? state.monstersNear.length : null,
+    quests: state.quests, hp: state.playerHp, mana: state.playerMana,
+  })
+  // Fight for a few seconds: walk and swing repeatedly.
+  key('keydown', 'KeyD')
+  for (let i = 0; i < 12; i++) await tap('Space', 220)
+  key('keyup', 'KeyD')
+  key('keydown', 'KeyS')
+  for (let i = 0; i < 12; i++) await tap('Space', 220)
+  key('keyup', 'KeyS')
+  await sleep(600)
+  const before = snap()
+  key('keydown', 'KeyK'); await sleep(200); key('keyup', 'KeyK')
+  await sleep(400)
+  const savedAt = snap()
+  key('keydown', 'KeyD'); await sleep(2000); key('keyup', 'KeyD')
+  await sleep(600)
+  const drifted = snap()
+  key('keydown', 'KeyL'); await sleep(200); key('keyup', 'KeyL')
+  await sleep(800)
+  const after = snap()
+  const gl = document.querySelector('#view').getContext('webgl2')
+  return {
+    before, savedAt, drifted, after,
+    saves: state.saves, loads: state.loads, saveError: state.saveError,
+    tickRate: state.tickRate, glError: gl ? gl.getError() : null, error: state.error ?? null,
+    source: state.source ?? null, itemTablesSource: state.itemTablesSource ?? null,
+  }
+})()
diff --git a/scripts/browser/checks/map-switch.js b/scripts/browser/checks/map-switch.js
new file mode 100644
index 0000000..4856c10
--- /dev/null
+++ b/scripts/browser/checks/map-switch.js
@@ -0,0 +1,90 @@
+// map-switch.js — 断言"章节 / 场景 / 细分场景"三个下拉框真的跳到选中的地图
+//
+// 这里防的是一类会静默退化的 bug：下拉框写错查询参数（早期是 `?quadrant=` 而资源包路径读
+// `?level=`），于是换图失败、悄悄回到该 act 的城镇。断言方式是拦下处理函数构造出来的目标 URL
+// （`location.search` 的赋值在同一个任务里），再检查参数名与取值。
+//
+// 同时核对三级结构本身：章节是「第一章…第五章」、场景是中文场景名、细分场景是所选场景的变体
+// （罗格营地是 北/东/南/西）。
+//
+//   CHROME=/root/.cache/ms-playwright/chromium-1223/chrome-linux64/chrome
+//   node scripts/browser/inspect-page.mjs "$CHROME" \
+//     "https://www.laiseek.xyz/diablo2/?act=1" scripts/browser/checks/map-switch.js
+(async () => {
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+  const deadline = Date.now() + 120000
+  while (Date.now() < deadline) {
+    const s = window.__d2webAct
+    if (s && (s.ready || s.error)) break
+    await sleep(200)
+  }
+  await sleep(800)
+
+  // 处理函数用的是 location.search 赋值，拦 URLSearchParams.toString 就能拿到目标。
+  const seen = []
+  const paramsToString = URLSearchParams.prototype.toString
+  URLSearchParams.prototype.toString = function () { const value = paramsToString.call(this); seen.push(`?${value}`); return value }
+
+  const texts = (id) => Array.from(document.querySelectorAll(`#${id} option`)).map((o) => o.textContent)
+  const result = {
+    source: window.__d2webAct.source,
+    headerLinks: Array.from(document.querySelectorAll('header a')).map((a) => a.textContent),
+    actOptions: texts('act'),
+    sceneOptions: texts('scene'),
+    variantOptions: texts('variant'),
+  }
+
+  /**
+   * 选中某个下拉框的某个值并捕获它构造出的目标 URL。
+   *
+   * @param id - select id.
+   * @param pick - chooses a value out of the options.
+   * @param match - how to judge the captured `?level=`: a variant label *is* the value,
+   *   while a scene navigates to its **first variant**, whose label starts with the slug.
+   */
+  const trySwitch = (id, pick, match = (value, level) => level === value) => {
+    const select = document.querySelector(`#${id}`)
+    if (select === null) return { error: 'no such select' }
+    const values = Array.from(select.querySelectorAll('option')).map((o) => o.value)
+    const value = pick(values) ?? values[0]
+    seen.length = 0
+    select.value = value
+    select.dispatchEvent(new Event('change', { bubbles: true }))
+    const target = seen.at(-1) ?? null
+    let params = null
+    try { params = target === null ? null : new URL(target, location.origin).searchParams } catch { params = null }
+    return {
+      picked: value,
+      target,
+      levelParam: params === null ? null : params.get('level'),
+      actParam: params === null ? null : params.get('act'),
+      switchesMap: params !== null && match(value, params.get('level') ?? '') && params.get('act') !== null,
+    }
+  }
+
+  // 章节切换跳到该 act 的第一个场景的第一个细分：`?act=` 变了，`?level=` 也该跟着变。
+  result.actSwitch = trySwitch('act', values => values[1] ?? values[0],
+    (act, level) => act !== String(window.__d2webAct.act) && level !== '')
+  result.variantSwitch = trySwitch('variant', values => values[1] ?? values[0])
+  result.sceneSwitch = trySwitch('scene', values => values[1] ?? values[0],
+    (slug, level) => level === slug || level.startsWith(`${slug}-`))
+  URLSearchParams.prototype.toString = paramsToString
+
+  const checks = [
+    ['resource pack path', result.source === 'pack'],
+    ['header 上没有多余链接', result.headerLinks.length === 0],
+    ['章节是五章中文名', result.actOptions.join('') === '第一章第二章第三章第四章第五章'],
+    ['场景是中文名（不是 Act N - …）', result.sceneOptions.every(text => !/^Act \d/.test(text)) && result.sceneOptions.length > 1],
+    ['细分场景是方位（罗格营地 北/东/南/西）', result.variantOptions.includes('北') && result.variantOptions.includes('南')],
+    ['细分场景切换写 ?level=', result.variantSwitch.switchesMap === true],
+    ['场景切换跳到该场景的首个细分（?level= 以 slug 开头）且带 ?act=', result.sceneSwitch.switchesMap === true],
+    ['章节切换同时改 ?act= 与 ?level=', result.actSwitch.switchesMap === true],
+  ]
+  return {
+    ...result,
+    act: window.__d2webAct.act,
+    level: window.__d2webAct.level,
+    pass: checks.every(([, ok]) => ok),
+    checks,
+  }
+})()
diff --git a/scripts/browser/checks/net-state.js b/scripts/browser/checks/net-state.js
new file mode 100644
index 0000000..f96982b
--- /dev/null
+++ b/scripts/browser/checks/net-state.js
@@ -0,0 +1,11 @@
+(async () => {
+  const sleep = (ms) => new Promise(r => setTimeout(r, ms))
+  for (let i = 0; i < 40 && (window.__d2webNet === undefined || window.__d2webNet.worldTick < 10); i++) await sleep(250)
+  const s = window.__d2webNet
+  if (s === undefined) return { error: 'no state' }
+  return {
+    multiplayer: s.multiplayer, connected: s.connected, handshaked: s.handshaked,
+    worldTick: s.worldTick, tickRate: Math.round(s.tickRate), glError: s.glError,
+    players: s.players.length, monsters: s.monsters, error: s.error,
+  }
+})()
diff --git a/scripts/browser/checks/walk-state.js b/scripts/browser/checks/walk-state.js
new file mode 100644
index 0000000..a074b96
--- /dev/null
+++ b/scripts/browser/checks/walk-state.js
@@ -0,0 +1,8 @@
+(async () => {
+  const sleep = (ms) => new Promise(r => setTimeout(r, ms))
+  for (let i = 0; i < 80 && (window.__d2web === undefined || (window.__d2web.tick ?? 0) < 5); i++) await sleep(250)
+  const s = window.__d2web
+  if (s === undefined) return { error: 'no state', keys: Object.keys(window).filter(k => k.startsWith('__')) }
+  const gl = document.querySelector('canvas')?.getContext('webgl2')
+  return { ...s, glError: gl ? gl.getError() : null, canvas: (() => { const c = document.querySelector('canvas'); return c ? [c.width, c.height] : null })() }
+})()
diff --git a/scripts/browser/inspect-page.mjs b/scripts/browser/inspect-page.mjs
new file mode 100644
index 0000000..3206002
--- /dev/null
+++ b/scripts/browser/inspect-page.mjs
@@ -0,0 +1,93 @@
+// Minimal CDP driver: node cdp_inspect.mjs <chromeBin> <url> [scriptFile]
+// Launches headless Chromium, connects over the DevTools WebSocket (Node's
+// built-in WebSocket — no dependencies), evaluates one async script, prints JSON.
+import { spawn } from 'node:child_process'
+import { mkdtempSync, readFileSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const [chromeBin, targetUrl, scriptFile] = process.argv.slice(2)
+const userDataDir = mkdtempSync(join(tmpdir(), 'cdp-'))
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+
+// Optional --window-size=WxH, so responsive behaviour can be checked at real sizes.
+const windowSizeArg = process.argv.find((arg) => arg.startsWith('--window-size='))
+const windowSize = windowSizeArg ? windowSizeArg.split('=')[1] : null
+
+const chrome = spawn(chromeBin, [
+  '--headless=new', '--no-sandbox', '--disable-dev-shm-usage',
+  // Headless Chrome wants `--window-size=W,H`; a `WxH` string is accepted here too.
+  ...(windowSize ? [`--window-size=${windowSize.replace('x', ',')}`] : []),
+  // Software WebGL2: headless has no GPU, and SwiftShader is the only way to
+  // exercise the renderer path in CI-like runs.
+  '--use-angle=swiftshader', '--use-gl=angle', '--enable-unsafe-swiftshader',
+  `--user-data-dir=${userDataDir}`,
+  '--remote-debugging-port=0',
+  targetUrl,
+], { stdio: ['ignore', 'ignore', 'pipe'] })
+let stderr = ''
+chrome.stderr.on('data', (d) => { stderr += d })
+
+let port = null
+for (let i = 0; i < 100; i++) {
+  await sleep(200)
+  try {
+    port = readFileSync(join(userDataDir, 'DevToolsActivePort'), 'utf8').trim().split('\n')[0]
+    if (port) break
+  } catch {}
+}
+if (!port) { console.error('NO PORT', stderr.slice(-500)); process.exit(1) }
+
+let page
+for (let i = 0; i < 50; i++) {
+  await sleep(200)
+  try {
+    const list = await (await fetch(`http://127.0.0.1:${port}/json`)).json()
+    page = list.find((x) => x.type === 'page')
+    if (page) break
+  } catch {}
+}
+if (!page) { console.error('NO PAGE', stderr.slice(-500)); process.exit(1) }
+
+const ws = new WebSocket(page.webSocketDebuggerUrl)
+await new Promise((resolve, reject) => { ws.onopen = resolve; ws.onerror = reject })
+let msgId = 0
+const pending = new Map()
+ws.onmessage = (event) => {
+  const message = JSON.parse(event.data)
+  if (message.id && pending.has(message.id)) { pending.get(message.id)(message); pending.delete(message.id) }
+}
+const send = (method, params = {}) => new Promise((resolve) => {
+  const id = ++msgId
+  pending.set(id, resolve)
+  ws.send(JSON.stringify({ id, method, params }))
+})
+
+await send('Runtime.enable')
+await send('Page.enable')
+await sleep(3000)
+
+const expression = scriptFile
+  ? await readFile(scriptFile, 'utf8')
+  : `({ title: document.title, text: document.body.innerText.slice(0, 2000) })`
+const result = await send('Runtime.evaluate', { expression, returnByValue: true, awaitPromise: true })
+const shotIndex = process.argv.indexOf('--screenshot')
+if (shotIndex !== -1) {
+  const shotPath = process.argv[shotIndex + 1]
+  const shot = await send('Page.captureScreenshot', { format: 'png' })
+  const data = shot.result?.data
+  if (typeof data === 'string') {
+    const { writeFileSync } = await import('node:fs')
+    writeFileSync(shotPath, Buffer.from(data, 'base64'))
+    console.error(`screenshot written: ${shotPath}`)
+  }
+}
+if (result.result?.exceptionDetails) {
+  console.error('EVAL ERROR', JSON.stringify(result.result.exceptionDetails).slice(0, 1500))
+} else {
+  console.log(JSON.stringify(result.result?.result?.value, null, 2))
+}
+ws.close()
+chrome.kill()
+process.exit(0)
diff --git a/scripts/browser/many-pages.mjs b/scripts/browser/many-pages.mjs
new file mode 100644
index 0000000..0e29c1a
--- /dev/null
+++ b/scripts/browser/many-pages.mjs
@@ -0,0 +1,146 @@
+// N separate Chromium instances, one page each: the co-op check the reliable way.
+// Usage: node cdp_many.mjs <chromeBin> <url0> <url1> [...] [--seconds N] [--shot prefix]
+import { spawn } from 'node:child_process'
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const args = process.argv.slice(2)
+const chromeBin = args[0]
+const urls = args.slice(1).filter((value) => value.startsWith('http'))
+const arg = (name, fallback) => {
+  const i = process.argv.indexOf(name)
+  return i === -1 ? fallback : process.argv[i + 1]
+}
+const seconds = Number(arg('--seconds', '14'))
+const shotPrefix = arg('--shot', null)
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+
+/** Launch Chromium on a URL and attach to its only tab. */
+async function connect(url) {
+  const userDataDir = mkdtempSync(join(tmpdir(), 'cdp-pair-'))
+  const chrome = spawn(chromeBin, [
+    '--headless=new', '--no-sandbox', '--disable-dev-shm-usage',
+    '--use-angle=swiftshader', '--use-gl=angle', '--enable-unsafe-swiftshader',
+    '--window-size=1000,700',
+    `--user-data-dir=${userDataDir}`, '--remote-debugging-port=0', url,
+  ], { stdio: ['ignore', 'ignore', 'pipe'] })
+  let stderr = ''
+  chrome.stderr.on('data', (d) => { stderr += d })
+  let port = null
+  for (let i = 0; i < 120 && !port; i++) {
+    await sleep(200)
+    try { port = readFileSync(join(userDataDir, 'DevToolsActivePort'), 'utf8').trim().split('\n')[0] } catch {}
+  }
+  if (!port) throw new Error(`no devtools port; ${stderr.slice(-300)}`)
+  let page = null
+  for (let i = 0; i < 40 && page === null; i++) {
+    await sleep(200)
+    try {
+      const list = await (await fetch(`http://127.0.0.1:${port}/json`)).json()
+      page = list.find((entry) => entry.type === 'page') ?? null
+    } catch {}
+  }
+  if (page === null) throw new Error(`no page target; ${stderr.slice(-300)}`)
+  const ws = new WebSocket(page.webSocketDebuggerUrl)
+  await new Promise((resolve, reject) => { ws.onopen = resolve; ws.onerror = reject })
+  let id = 0
+  const pending = new Map()
+  ws.onmessage = (event) => {
+    const message = JSON.parse(event.data)
+    if (message.id && pending.has(message.id)) { pending.get(message.id)(message); pending.delete(message.id) }
+  }
+  const send = (method, params = {}) => new Promise((resolve) => {
+    const msgId = ++id
+    pending.set(msgId, resolve)
+    ws.send(JSON.stringify({ id: msgId, method, params }))
+  })
+  await send('Runtime.enable')
+  await send('Page.enable')
+  return { send, ws, chrome, stderr: () => stderr }
+}
+
+const pages = await Promise.all(urls.map((url) => connect(url)))
+// Collect page-level errors: an exception thrown inside a socket listener is
+// invisible from the outside, and is exactly how a "no messages arrive" bug
+// actually looks.
+for (const page of pages) {
+  await page.send('Runtime.evaluate', { expression: `(() => { window.__errs = []; window.addEventListener('error', e => window.__errs.push(String(e.message)));
+    window.addEventListener('unhandledrejection', e => window.__errs.push('rejection: ' + String(e.reason)));
+    return 'ok'; })()`, returnByValue: true })
+}
+await sleep(4500)
+
+const evaluate = async (page, expression, awaitPromise = false) => {
+  const result = await page.send('Runtime.evaluate', { expression, returnByValue: true, awaitPromise })
+  if (result.result?.exceptionDetails) return { __error: JSON.stringify(result.result.exceptionDetails).slice(0, 400) }
+  return result.result?.result?.value ?? null
+}
+
+console.log('where:', JSON.stringify(await Promise.all(pages.map(page => evaluate(page, 'location.href')))))
+
+/** Press and hold a key, then release it. */
+async function hold(page, code, key, vk, ms) {
+  const base = { code, key, windowsVirtualKeyCode: vk, nativeVirtualKeyCode: vk }
+  await page.send('Input.dispatchKeyEvent', { type: 'keyDown', ...base })
+  await sleep(ms)
+  await page.send('Input.dispatchKeyEvent', { type: 'keyUp', ...base })
+}
+
+const tap = async (page, code, key, vk) => {
+  const base = { code, key, windowsVirtualKeyCode: vk, nativeVirtualKeyCode: vk }
+  await page.send('Input.dispatchKeyEvent', { type: 'keyDown', ...base })
+  await sleep(700)
+  await page.send('Input.dispatchKeyEvent', { type: 'keyUp', ...base })
+}
+
+// Each page walks on its own axis, so a fighter that moves only under its own
+// page's keys is visible in the final positions.
+const KEYS = [['KeyD', 'd', 68], ['KeyS', 's', 83], ['KeyA', 'a', 65], ['KeyW', 'w', 87]]
+const drive = (async () => {
+  for (let round = 0; round < 5; round += 1) {
+    await Promise.all(pages.map((page, index) => {
+      const [code, key, vk] = KEYS[index % KEYS.length]
+      return hold(page, code, key, vk, 800)
+    }))
+    await Promise.all(pages.map((page) => tap(page, 'Space', ' ', 32)))
+    await sleep(300)
+  }
+})()
+await Promise.race([drive, sleep(seconds * 1000)])
+
+const states = []
+for (const page of pages) {
+  const value = await evaluate(page, 'JSON.stringify(window.__d2webNet ?? null)')
+  states.push(typeof value === 'string' ? JSON.parse(value) : value)
+}
+
+if (shotPrefix !== null) {
+  for (let index = 0; index < pages.length; index += 1) {
+    const shot = await pages[index].send('Page.captureScreenshot', { format: 'png' })
+    const data = shot.result?.data
+    if (typeof data === 'string') writeFileSync(`${shotPrefix}-${index}.png`, Buffer.from(data, 'base64'))
+  }
+}
+
+// Pixel statistics, read straight from the framebuffer: a page whose world is
+// correct but whose canvas is empty has failed in a way the numbers cannot see.
+let pixels = []
+for (const page of pages) {
+  const value = await evaluate(page, `(() => { const c = document.querySelector('#view'); const gl = c.getContext('webgl2');
+    const px = new Uint8Array(c.width * c.height * 4); gl.readPixels(0, 0, c.width, c.height, gl.RGBA, gl.UNSIGNED_BYTE, px);
+    let nonBlack = 0; const seen = new Set();
+    for (let i = 0; i < px.length; i += 4) { if (px[i] + px[i+1] + px[i+2] > 24) nonBlack++;
+      seen.add((px[i] >> 3) + ',' + (px[i+1] >> 3) + ',' + (px[i+2] >> 3)); }
+    return JSON.stringify({ nonBlack, total: c.width * c.height, distinctColours: seen.size, glError: gl.getError() }); })()`)
+  pixels.push(typeof value === 'string' ? JSON.parse(value) : value)
+}
+
+const errors = []
+for (const page of pages) {
+  const value = await evaluate(page, 'JSON.stringify(window.__errs ?? null)')
+  errors.push(typeof value === 'string' ? JSON.parse(value) : value)
+}
+console.log(JSON.stringify({ states, pixels, errors }, null, 2))
+for (const page of pages) { page.ws.close(); page.chrome.kill() }
+process.exit(0)
diff --git a/scripts/dump-format.ts b/scripts/dump-format.ts
new file mode 100644
index 0000000..3dba0b4
--- /dev/null
+++ b/scripts/dump-format.ts
@@ -0,0 +1,135 @@
+/**
+ * Canonical dumper: print a decoded Diablo II format file as the same JSON shape
+ * the Go reference dumper emits, so the two can be diffed field by field.
+ *
+ * Usage: node scripts/dump-format.ts <dc6|dt1|ds1> <file>
+ */
+import { readFile } from 'node:fs/promises'
+import { decodeDc6 } from '../src/formats/dc6.ts'
+import { decodeDt1 } from '../src/formats/dt1.ts'
+import { decodeDs1 } from '../src/formats/ds1.ts'
+import { decodePl2 } from '../src/formats/pl2.ts'
+
+const [format, path] = process.argv.slice(2)
+if (format === undefined || path === undefined) {
+  console.error('usage: node scripts/dump-format.ts <dc6|dt1|ds1> <file>')
+  process.exit(2)
+}
+const data = new Uint8Array(await readFile(path))
+
+let output: unknown
+switch (format) {
+  case 'dc6': {
+    const sheet = decodeDc6(data)
+    output = {
+      format: 'dc6',
+      directions: sheet.header.directions,
+      framesPerDirection: sheet.header.framesPerDirection,
+      frames: sheet.groups.map(group => group.frames.map(frame => ({
+        width: frame.width,
+        height: frame.height,
+        offsetX: frame.offsetX,
+        offsetY: frame.offsetY,
+        indices: [...frame.indices],
+      }))),
+    }
+    break
+  }
+  case 'dt1': {
+    const library = decodeDt1(data)
+    output = {
+      format: 'dt1',
+      tiles: library.tiles.map(tile => ({
+        direction: tile.direction,
+        height: tile.height,
+        width: tile.width,
+        type: tile.type,
+        style: tile.style,
+        sequence: tile.sequence,
+        materialFlags: tile.materialFlags,
+        subTileFlags: tile.subTileFlags.map(flag => flag.raw),
+        blocks: tile.blocks.map(block => ({
+          x: block.x,
+          y: block.y,
+          gridX: block.gridX,
+          gridY: block.gridY,
+          format: block.format,
+          pixels: [...block.pixels],
+        })),
+      })),
+    }
+    break
+  }
+  case 'ds1': {
+    const level = decodeDs1(data)
+    output = {
+      format: 'ds1',
+      version: level.version,
+      width: level.width,
+      height: level.height,
+      act: level.act,
+      wallLayers: level.wallLayers,
+      floorLayers: level.floorLayers,
+      cells: level.cells.map(row => row.map(cell => ({
+        walls: cell.walls.map(wall => ({
+          prop1: wall.prop1, sequence: wall.sequence, style: wall.style, type: wall.type,
+          unknown1: wall.unknown1, unknown2: wall.unknown2, hidden: wall.hidden,
+        })),
+        floors: cell.floors.map(floor => ({
+          prop1: floor.prop1, sequence: floor.sequence, style: floor.style,
+          unknown1: floor.unknown1, unknown2: floor.unknown2, hidden: floor.hidden,
+        })),
+        shadows: cell.shadows.map(shadow => ({
+          prop1: shadow.prop1, sequence: shadow.sequence, style: shadow.style,
+          unknown1: shadow.unknown1, unknown2: shadow.unknown2, hidden: shadow.hidden,
+        })),
+      }))),
+      objects: level.objects.map(object => ({
+        type: object.type, id: object.id, x: object.x, y: object.y, flags: object.flags,
+      })),
+    }
+    break
+  }
+  case 'pl2': {
+    const palette = decodePl2(data)
+    // Same digest and grouping as the reference dumper, so the two can be
+    // compared array for array.
+    const digest = (table: Uint8Array): number => {
+      let hash = 2166136261
+      for (const byte of table) {
+        hash ^= byte
+        hash = Math.imul(hash, 16777619) >>> 0
+      }
+      return hash >>> 0
+    }
+    const digests = (tables: readonly Uint8Array[]): number[] => tables.map(digest)
+    output = {
+      format: 'pl2',
+      size: data.byteLength,
+      base: [...palette.rgb],
+      text: [...palette.textRgb],
+      groups: {
+        lightLevels: digests(palette.lightLevels),
+        inverseColors: digests(palette.inverseColors),
+        selectedUnitShift: digests([palette.selectedUnitShift]),
+        alphaBlend: digests(palette.alphaBlend.flat()),
+        additiveBlend: digests(palette.additiveBlend),
+        multiplyBlend: digests(palette.multiplyBlend),
+        hueVariations: digests(palette.hueVariations),
+        redTones: digests([palette.redTones]),
+        greenTones: digests([palette.greenTones]),
+        blueTones: digests([palette.blueTones]),
+        unknownVariations: digests(palette.unknownVariations),
+        maxComponentBlend: digests(palette.maxComponentBlend),
+        darkenedShift: digests([palette.darkenedShift]),
+        textShifts: digests(palette.textShifts),
+      },
+    }
+    break
+  }
+  default: {
+    console.error(`unknown format: ${format}`)
+    process.exit(2)
+  }
+}
+console.log(JSON.stringify(output, null, 2))
diff --git a/scripts/inspect-mpq.ts b/scripts/inspect-mpq.ts
new file mode 100644
index 0000000..86927c5
--- /dev/null
+++ b/scripts/inspect-mpq.ts
@@ -0,0 +1,77 @@
+/**
+ * MPQ inspection CLI (Node-side tooling).
+ *
+ * Usage:
+ *   node scripts/inspect-mpq.ts <archive> [header|list|hist|extract <name> <out>]
+ *
+ * `header` prints the parsed v1 header, `list` the name list, `hist` the
+ * compression masks the archive actually uses (which decoders are required),
+ * and `extract` decodes one member to disk for external verification.
+ */
+import { writeFile } from 'node:fs/promises'
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { fileSource } from '../src/mpq/file-source.ts'
+
+const [path, command = 'header', ...rest] = process.argv.slice(2)
+
+if (path === undefined) {
+  console.error('usage: node scripts/inspect-mpq.ts <archive> [header|list|hist|extract <name> <out>]')
+  process.exit(2)
+}
+
+const archive = await MpqArchive.open(await fileSource(path))
+
+switch (command) {
+  case 'header': {
+    const h = archive.header
+    console.log(`archive      ${path}`)
+    console.log(`headerSize   ${String(h.headerSize)}`)
+    console.log(`archiveSize  ${String(h.archiveSize)}`)
+    console.log(`format       v${String(h.formatVersion + 1)}`)
+    console.log(`sectorSize   ${String(h.sectorSize)}`)
+    console.log(`hashTable    @${String(h.hashTableOffset)} (${String(h.hashTableEntries)} entries)`)
+    console.log(`blockTable   @${String(h.blockTableOffset)} (${String(h.blockTableEntries)} entries)`)
+    const occupied = archive.files().length
+    console.log(`files        ${String(occupied)} occupied block slots`)
+    for (const [flag, count] of archive.flagHistogram()) {
+      console.log(`  ${flag.padEnd(12)} ${String(count)}`)
+    }
+    break
+  }
+  case 'list': {
+    const names = await archive.listFiles()
+    console.log(`${String(names.length)} names`)
+    for (const name of names.slice(0, 40)) console.log(`  ${name}`)
+    if (names.length > 40) console.log(`  … ${String(names.length - 40)} more`)
+    break
+  }
+  case 'hist': {
+    const hist = await archive.compressionHistogram(await archive.nameIndex())
+    const total = [...hist.values()].reduce((a, b) => a + b, 0)
+    console.log(`compression masks over ${String(total)} files`)
+    for (const [mask, count] of [...hist].sort((a, b) => b[1] - a[1])) {
+      console.log(`  ${String(count).padStart(6)}  ${mask}`)
+    }
+    break
+  }
+  case 'extract': {
+    const [name, out] = rest
+    if (name === undefined || out === undefined) {
+      console.error('usage: … extract <name> <out>')
+      process.exit(2)
+    }
+    const file = archive.find(name)
+    if (file === undefined) {
+      console.error(`no such file: ${name}`)
+      process.exit(1)
+    }
+    const data = await archive.read(file)
+    await writeFile(out, data)
+    console.log(`wrote ${out} (${String(data.byteLength)} bytes, expected ${String(file.fileSize)})`)
+    break
+  }
+  default: {
+    console.error(`unknown command: ${command}`)
+    process.exit(2)
+  }
+}
diff --git a/scripts/lib/tbl-writer.ts b/scripts/lib/tbl-writer.ts
new file mode 100644
index 0000000..76a8a14
--- /dev/null
+++ b/scripts/lib/tbl-writer.ts
@@ -0,0 +1,59 @@
+/**
+ * Minimal `.tbl` writer, shared by the fixture generator and its checker.
+ *
+ * Tooling only: the engine reads TBL files, it never writes them. It lives here so
+ * the fixture generator and the construction check encode a table the same way,
+ * instead of two copies drifting apart.
+ */
+
+/** One entry: a string, or null for an unused index. */
+export type TblEntry = string | null
+
+/**
+ * Encode a classic `.tbl`: crc, entry count, index table, then
+ * `u16 characterCount` + UTF-16LE strings.
+ *
+ * @param entries - the entries, in index order.
+ * @returns the encoded bytes.
+ */
+export function encodeTbl(entries: readonly TblEntry[]): Uint8Array {
+  const headerBytes = 4
+  const indexBytes = entries.length * 2
+  const blocks: { index: number; bytes: Uint8Array }[] = []
+  let cursor = headerBytes + indexBytes
+  for (const [index, entry] of entries.entries()) {
+    if (entry === null) continue
+    // The count is in characters; an astral character is two UTF-16 units.
+    let characters = 0
+    for (const character of entry) characters += character.codePointAt(0)! > 0xffff ? 2 : 1
+    const body = new Uint8Array(characters * 2)
+    const view = new DataView(body.buffer)
+    let units = 0
+    for (const character of entry) {
+      const code = character.codePointAt(0)!
+      if (code > 0xffff) {
+        const adjusted = code - 0x10000
+        view.setUint16(units * 2, 0xd800 + (adjusted >> 10), true)
+        view.setUint16((units + 1) * 2, 0xdc00 + (adjusted & 0x3ff), true)
+        units += 2
+      } else {
+        view.setUint16(units * 2, code, true)
+        units += 1
+      }
+    }
+    const bytes = new Uint8Array([characters & 0xff, (characters >> 8) & 0xff, ...body])
+    blocks.push({ index, bytes })
+    cursor += bytes.byteLength
+  }
+  const out = new Uint8Array(cursor)
+  const view = new DataView(out.buffer)
+  view.setUint16(0, 0x1234, true)
+  view.setUint16(2, entries.length, true)
+  let at = headerBytes + indexBytes
+  for (const block of blocks) {
+    view.setUint16(headerBytes + block.index * 2, at, true)
+    out.set(block.bytes, at)
+    at += block.bytes.byteLength
+  }
+  return out
+}
diff --git a/scripts/make-fixtures.ts b/scripts/make-fixtures.ts
new file mode 100644
index 0000000..7d27522
--- /dev/null
+++ b/scripts/make-fixtures.ts
@@ -0,0 +1,318 @@
+/**
+ * Fixture generator: encode a DC6 file from a known index grid.
+ *
+ * Format work without real assets needs its own evidence, and "my decoder reads
+ * what my encoder wrote" proves nothing on its own. So the fixtures here are
+ * written strictly to the published layout (the Kaitai `dc6.ksy` definition
+ * plus the two independent decoders' agreement on the run alphabet and row
+ * order), and every claim is then checked against an *independent* decoder:
+ * `scripts/verify-dc6.sh` runs `dc6png` over the generated file and compares
+ * the PNG it produces against the grid encoded here.
+ *
+ * Usage: node scripts/make-fixtures.ts <output-directory>
+ */
+import { mkdir, writeFile } from 'node:fs/promises'
+import { encodeTbl } from './lib/tbl-writer.ts'
+import { join } from 'node:path'
+
+/** Byte offset of the file header in a DC6. */
+const FILE_HEADER_SIZE = 24
+/** Byte offset of a frame header inside its frame. */
+const FRAME_HEADER_SIZE = 32
+/** Scanline terminator. */
+const END_OF_SCANLINE = 0x80
+/** Longest literal run a single chunk byte can introduce. */
+const MAX_LITERAL_RUN = 0x7f
+
+/**
+ * A frame as a top-down grid of palette indices, `0` meaning transparent.
+ */
+interface FixtureFrame {
+  readonly width: number
+  readonly height: number
+  /** Rows top-down; each row must be `width` long. */
+  readonly rows: readonly (readonly number[])[]
+  readonly offsetX: number
+  readonly offsetY: number
+}
+
+/**
+ * Encode one frame's run stream.
+ *
+ * Rows are emitted **bottom-up**, matching how the format stores them: the
+ * first scanline written belongs to the frame's last row.
+ *
+ * @param frame - the frame to encode.
+ * @returns the run stream.
+ */
+function encodeFrameStream(frame: FixtureFrame): Uint8Array {
+  const bytes: number[] = []
+  for (let rowIndex = frame.height - 1; rowIndex >= 0; rowIndex -= 1) {
+    const row = frame.rows[rowIndex]!
+    let x = 0
+    while (x < frame.width) {
+      const value = row[x]!
+      let run = 0
+      while (x + run < frame.width && row[x + run] === value && run < MAX_LITERAL_RUN) run += 1
+      if (value === 0) {
+        bytes.push(END_OF_SCANLINE | run)
+      } else {
+        bytes.push(run)
+        for (let i = 0; i < run; i += 1) bytes.push(row[x + i]!)
+      }
+      x += run
+    }
+    bytes.push(END_OF_SCANLINE)
+  }
+  return new Uint8Array(bytes)
+}
+
+/**
+ * Encode a DC6 file.
+ *
+ * @param directions - directions to write.
+ * @param framesPerDirection - frames per direction.
+ * @param frameOf - builds the frame at a given position.
+ * @returns the encoded file.
+ */
+function encodeDc6(
+  directions: number,
+  framesPerDirection: number,
+  frameOf: (direction: number, frame: number) => FixtureFrame,
+): Uint8Array {
+  const total = directions * framesPerDirection
+  const encoded: { stream: Uint8Array; frame: FixtureFrame }[] = []
+  for (let index = 0; index < total; index += 1) {
+    const direction = Math.floor(index / framesPerDirection)
+    const frame = index % framesPerDirection
+    const spec = frameOf(direction, frame)
+    encoded.push({ stream: encodeFrameStream(spec), frame: spec })
+  }
+
+  const pointerTableSize = total * 4
+  let offset = FILE_HEADER_SIZE + pointerTableSize
+  const pointers: number[] = []
+  for (const entry of encoded) {
+    pointers.push(offset)
+    // Frame header + run stream + 3-byte terminator.
+    offset += FRAME_HEADER_SIZE + entry.stream.byteLength + 3
+  }
+
+  const out = new Uint8Array(offset)
+  const view = new DataView(out.buffer)
+  view.setInt32(0x00, 6, true)          // version
+  view.setUint32(0x04, 0, true)         // flags
+  view.setUint32(0x08, 0, true)         // encoding
+  view.setUint32(0x0c, 0, true)         // termination
+  view.setInt32(0x10, directions, true)
+  view.setInt32(0x14, framesPerDirection, true)
+  pointers.forEach((pointer, index) => { view.setUint32(FILE_HEADER_SIZE + index * 4, pointer, true) })
+
+  encoded.forEach((entry, index) => {
+    const at = pointers[index]!
+    view.setInt32(at + 0x00, 0, true)                  // flipped
+    view.setInt32(at + 0x04, entry.frame.width, true)
+    view.setInt32(at + 0x08, entry.frame.height, true)
+    view.setInt32(at + 0x0c, entry.frame.offsetX, true)
+    view.setInt32(at + 0x10, entry.frame.offsetY, true)
+    view.setUint32(at + 0x14, 0, true)                 // unknown
+    view.setInt32(at + 0x18, 0, true)                  // next block
+    view.setInt32(at + 0x1c, entry.stream.byteLength, true)
+    out.set(entry.stream, at + FRAME_HEADER_SIZE)
+  })
+  return out
+}
+
+/**
+ * A palette whose entries are unambiguous under channel reordering: red and
+ * blue differ for every index, so a byte-swapped read is visible rather than
+ * silent.
+ *
+ * @returns 768 bytes of RGB triples.
+ */
+function makePalette(): Uint8Array {
+  const palette = new Uint8Array(768)
+  for (let index = 0; index < 256; index += 1) {
+    palette[index * 3] = index
+    palette[index * 3 + 1] = (index * 7) & 0xff
+    palette[index * 3 + 2] = 255 - index
+  }
+  return palette
+}
+
+/**
+ * A frame with every interesting run shape: a full literal row, a mixed
+ * literal/transparent row, an all-transparent row, and a two-chunk row.
+ *
+ * @param seed - shifts the index values so frames differ.
+ * @returns the frame.
+ */
+function patternFrame(seed: number): FixtureFrame {
+  const width = 8
+  const height = 4
+  const rows: number[][] = []
+  // Top row: two literal runs (3 then 5) — exercises consecutive literal chunks.
+  rows.push([seed + 1, seed + 2, seed + 3, seed + 4, seed + 5, seed + 6, seed + 7, seed + 8])
+  // Second row: literal 3, transparent 2, literal 3.
+  rows.push([seed + 9, seed + 10, seed + 11, 0, 0, seed + 12, seed + 13, seed + 14])
+  // Third row: entirely transparent.
+  rows.push([0, 0, 0, 0, 0, 0, 0, 0])
+  // Bottom row: single transparent pixel then a full literal run.
+  rows.push([0, seed + 15, seed + 16, seed + 17, seed + 18, seed + 19, seed + 20, seed + 21])
+  return { width, height, rows, offsetX: seed, offsetY: -seed }
+}
+
+/**
+ * A synthetic walking actor: eight directions by eight frames.
+ *
+ * Diablo II units that are not composite-animated ship as per-direction DC6
+ * sheets, so this is the shape the engine's actor path consumes. Each direction
+ * gets its own filled block and each frame shifts it, so a decoder, an atlas or
+ * a draw order that mixes directions up is visible in a screenshot rather than
+ * silently plausible.
+ *
+ * @param directions - direction count.
+ * @param framesPerDirection - frames per direction.
+ * @param size - frame edge in pixels.
+ * @returns the encoded DC6.
+ */
+function encodeActor(directions: number, framesPerDirection: number, size: number): Uint8Array {
+  return encodeDc6(directions, framesPerDirection, (direction, frame) => {
+    const rows: number[][] = []
+    const blockWidth = 16 + direction * 3
+    const inset = (frame * 4) % (size - blockWidth)
+    for (let y = 0; y < size; y += 1) {
+      const row: number[] = []
+      const inBlock = y >= 16 && y < 16 + blockWidth
+      for (let x = 0; x < size; x += 1) {
+        const lit = inBlock && x >= inset && x < inset + blockWidth
+        row.push(lit ? 1 + ((direction * 16 + frame * 2 + (y % 8)) % 250) : 0)
+      }
+      rows.push(row)
+    }
+    return { width: size, height: size, rows, offsetX: 0, offsetY: 0 }
+  })
+}
+
+const outDir = process.argv[2]
+if (outDir === undefined) {
+  console.error('usage: node scripts/make-fixtures.ts <output-directory>')
+  process.exit(2)
+}
+await mkdir(outDir, { recursive: true })
+
+const directions = 2
+const framesPerDirection = 2
+const file = encodeDc6(directions, framesPerDirection, (direction, frame) => patternFrame(direction * 4 + frame * 22 + 1))
+await writeFile(join(outDir, 'fixture.dc6'), file)
+await writeFile(join(outDir, 'palette.pal'), makePalette())
+
+/** The grid each frame is expected to decode to, top-down. */
+const expected = {
+  directions,
+  framesPerDirection,
+  palette: 'palette.pal',
+  frames: Array.from({ length: directions }, (_, direction) =>
+    Array.from({ length: framesPerDirection }, (_, frame) => {
+      const spec = patternFrame(direction * 4 + frame * 22 + 1)
+      return { width: spec.width, height: spec.height, rows: spec.rows }
+    })),
+}
+await writeFile(join(outDir, 'expected.json'), JSON.stringify(expected, null, 2))
+
+// Data tables in the shape Diablo II ships them: tab-separated with a header
+// row, under the same member path the game uses.
+const monstats = [
+  'Id\tName\tHP\tDamage\tCooldownTicks\tReach\tAggroRadius\tSpeed\tXP',
+  'fallen\tFallen\t12\t3\t24\t36\t220\t80\t8',
+  'zombie\tZombie\t30\t6\t32\t40\t170\t50\t15',
+  'skeleton\tSkeleton\t18\t4\t28\t38\t260\t70\t12',
+].join('\r\n')
+const experience = ['Level\tXP', '1\t0', '2\t20', '3\t60', '4\t140', '5\t280'].join('\r\n')
+await mkdir(join(outDir, 'data', 'global', 'excel'), { recursive: true })
+await writeFile(join(outDir, 'data', 'global', 'excel', 'monstats.txt'), monstats)
+await writeFile(join(outDir, 'data', 'global', 'excel', 'experience.txt'), experience)
+console.log(`wrote ${join(outDir, 'data', 'global', 'excel')}/{monstats,experience}.txt`)
+
+// Item tables, in the shape Diablo II ships them (a leading unnamed column is
+// common in the real files, so one is included here to keep that path exercised).
+const tables: Record<string, string> = {
+  'weapons.txt': [
+    '\tId\tName\tType\tInvWidth\tInvHeight\tDamage\tValue\tLevel\tMaxStack',
+    '\tswd\tShort Sword\tweap\t1\t3\t5\t30\t1\t1',
+    '\taxe\tHand Axe\tweap\t2\t3\t8\t60\t3\t1',
+    '\tgsw\tGreat Sword\tweap\t2\t4\t18\t200\t10\t1',
+  ].join('\r\n'),
+  'armor.txt': [
+    'Id\tName\tType\tInvWidth\tInvHeight\tDefense\tValue\tLevel\tMaxStack',
+    'buc\tBuckler\tarmo\t2\t2\t4\t25\t1\t1',
+    'cap\tCap\tarmo\t2\t2\t6\t40\t2\t1',
+    'plt\tPlate Mail\tarmo\t2\t3\t30\t400\t12\t1',
+  ].join('\r\n'),
+  'misc.txt': [
+    'Id\tName\tType\tInvWidth\tInvHeight\tMaxStack\tValue',
+    'hp1\tMinor Healing Potion\tmisc\t1\t1\t5\t20',
+    'mp1\tMinor Mana Potion\tmisc\t1\t1\t5\t25',
+    'key\tKey\tmisc\t1\t1\t12\t10',
+  ].join('\r\n'),
+  'magicprefix.txt': [
+    'Id\tName\tLevel\titype1\titype2\tmod1code\tmod1min\tmod1max\tmod2code\tmod2min\tmod2max',
+    'cruel\tCruel\t12\tweap\t\tmaxdamage\t30\t40\t\t\t',
+    'sturdy\tSturdy\t3\tarmo\t\tdefense\t5\t9\t\t\t',
+    'fine\tFine\t5\tweap\tarmo\tmaxdamage\t2\t4\tdefense\t1\t3',
+  ].join('\r\n'),
+  'magicsuffix.txt': [
+    'Id\tName\tLevel\titype1\tmod1code\tmod1min\tmod1max',
+    'of_might\tof Might\t5\tweap\tstrength\t2\t5',
+    'of_the_fox\tof the Fox\t3\t\tdexterity\t1\t3',
+    'of_health\tof Health\t4\t\tmaxhp\t10\t20',
+  ].join('\r\n'),
+}
+for (const [name, body] of Object.entries(tables)) {
+  await writeFile(join(outDir, 'data', 'global', 'excel', name), body)
+}
+console.log(`wrote ${String(Object.keys(tables).length)} item tables under data/global/excel/`)
+
+// Skills, NPCs and quests, plus the string table their numeric name cells point
+// into — so the `.tbl` decoder is exercised by the game path, not only by its
+// own test.
+const m4Tables: Record<string, string> = {
+  'skills.txt': [
+    'Id\tName\tManaCost\tCooldownTicks\tRange\tSpeed\tMinDam\tMaxDam\tPerLevel\tRadius',
+    'attack\tBasic Attack\t0\t10\t48\t0\t4\t6\t1\t20',
+    'firebolt\t1\t6\t20\t260\t320\t7\t10\t3\t20',
+    'frostnova\t2\t14\t50\t70\t0\t12\t16\t4\t90',
+  ].join('\r\n'),
+  'npcs.txt': [
+    'Id\tName\tQuest\tOffer\tProgress\tDone',
+    'cain\t3\tden\t6\t7\t8',
+  ].join('\r\n'),
+  'quests.txt': [
+    'Id\tName\tDescription\tMonsterId\tKillCount\tRewardXP\tRewardGold',
+    // A wildcard objective: the fixture has three monster types, so a quest that
+    // names one of them could not be completed deterministically in a short run.
+    'den\t4\t5\t*\t3\t60\t120',
+  ].join('\r\n'),
+}
+for (const [name, body] of Object.entries(m4Tables)) {
+  await writeFile(join(outDir, 'data', 'global', 'excel', name), body)
+}
+// Index order matters: the tables above address these by number.
+const stringTable = encodeTbl([
+  '', 'Fire Bolt', 'Frost Nova', 'Deckard Cain',
+  'Kill the Fallen', 'Slay five of the fallen in the moor',
+  'The fallen plague us.|Will you help?',
+  'Still working?|The fallen remain.',
+  'Well done, hero.',
+])
+await writeFile(join(outDir, 'data', 'local', 'string.tbl'), stringTable).catch(async () => {
+  await mkdir(join(outDir, 'data', 'local'), { recursive: true })
+  await writeFile(join(outDir, 'data', 'local', 'string.tbl'), stringTable)
+})
+console.log(`wrote 3 M4 tables and data/local/string.tbl (${String(stringTable.byteLength)} bytes)`)
+
+const actor = encodeActor(8, 8, 64)
+await writeFile(join(outDir, 'actor.dc6'), actor)
+console.log(`wrote ${join(outDir, 'actor.dc6')} (${String(actor.byteLength)} bytes, 8 directions x 8 frames of 64x64)`)
+console.log(`wrote ${join(outDir, 'fixture.dc6')} (${String(file.byteLength)} bytes)`)
+console.log(`wrote ${join(outDir, 'palette.pal')} and expected.json`)
diff --git a/scripts/make-map-fixtures.ts b/scripts/make-map-fixtures.ts
new file mode 100644
index 0000000..f4901e6
--- /dev/null
+++ b/scripts/make-map-fixtures.ts
@@ -0,0 +1,254 @@
+/**
+ * Map fixture generator: encode a DT1 tile library and a DS1 map that
+ * references it.
+ *
+ * Written strictly to the published layouts so that an *independent* decoder
+ * (the Go reference packages) can read them: if it agrees with this project's
+ * TypeScript decoder field by field, the format understanding is confirmed, and
+ * if it disagrees the fixtures say exactly which field drifted.
+ *
+ * Usage: node scripts/make-map-fixtures.ts <output-directory>
+ */
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+/** Bytes per DT1 tile record. */
+const DT1_TILE_RECORD = 96
+/** Bytes per DT1 block header. */
+const DT1_BLOCK_HEADER = 20
+/** Tile edge in pixels: a Diablo II tile is 5x5 sub-tiles of 32x32. */
+const TILE = 160
+/** Bytes of fixed preamble before the DT1 tile count. */
+const DT1_HEADER_PREFIX = 8 + 260
+
+/**
+ * Encode an RLE block body: `(skip, count)` pairs then literals, `(0, 0)`
+ * ending a row.
+ *
+ * @param width - tile width.
+ * @param height - tile height.
+ * @param base - first palette index used.
+ * @returns the run stream.
+ */
+function encodeBlockRle(width: number, height: number, base: number): Uint8Array {
+  const bytes: number[] = []
+  for (let y = 0; y < height; y += 1) {
+    const start = y % 4
+    const count = width - start - (y % 3)
+    bytes.push(start, count)
+    for (let i = 0; i < count; i += 1) bytes.push(((base + y * 7 + i) & 0xff) || 1)
+    bytes.push(0, 0)
+  }
+  return new Uint8Array(bytes)
+}
+
+/**
+ * Encode an isometric block body: exactly 256 bytes for the fixed diamond.
+ *
+ * @param base - first palette index used.
+ * @returns the block bytes.
+ */
+function encodeBlockIsometric(base: number): Uint8Array {
+  const bytes = new Uint8Array(256)
+  for (let i = 0; i < bytes.byteLength; i += 1) bytes[i] = ((base + i) & 0xff) || 1
+  return bytes
+}
+
+/**
+ * Build a DT1 file with one RLE tile and one isometric tile.
+ *
+ * @returns the encoded library.
+ */
+function encodeDt1(): Uint8Array {
+  const tiles = [
+    { rle: true, type: 0, style: 1, sequence: 0, material: 0x0020, width: TILE, height: -TILE },
+    { rle: true, type: 0, style: 1, sequence: 1, material: 0x0008, width: TILE, height: -TILE },
+    { rle: false, type: 0, style: 2, sequence: 0, material: 0x0040, width: TILE, height: -TILE },
+    { rle: false, type: 0, style: 2, sequence: 1, material: 0x0002, width: TILE, height: -TILE },
+  ]
+  const tileDataStart = DT1_HEADER_PREFIX + 8
+  // Wall tiles store a *negative* height (they grow upward from their anchor), so
+  // the encoder has to work from the magnitude.
+  const bodies = tiles.map((tile, index) => (tile.rle
+    ? encodeBlockRle(tile.width, Math.abs(tile.height), 9 + index * 40)
+    : encodeBlockIsometric(70 + index * 40)))
+
+  let bodyOffset = tileDataStart + tiles.length * DT1_TILE_RECORD
+  const blockHeaderStart = bodyOffset
+  bodyOffset += tiles.length * DT1_BLOCK_HEADER
+  const blockDataOffsets: number[] = []
+  for (const body of bodies) {
+    blockDataOffsets.push(bodyOffset)
+    bodyOffset += body.byteLength
+  }
+
+  const out = new Uint8Array(bodyOffset)
+  const view = new DataView(out.buffer)
+  view.setInt32(0, 7, true)
+  view.setInt32(4, 6, true)
+  view.setInt32(DT1_HEADER_PREFIX, tiles.length, true)
+  view.setInt32(DT1_HEADER_PREFIX + 4, tileDataStart, true)
+
+  tiles.forEach((tile, index) => {
+    const at = tileDataStart + index * DT1_TILE_RECORD
+    view.setInt32(at + 0, 0, true)                    // direction
+    view.setInt16(at + 4, 0, true)                    // roof height
+    view.setUint16(at + 6, tile.material, true)       // material flags
+    view.setInt32(at + 8, tile.height, true)
+    view.setInt32(at + 12, tile.width, true)
+    view.setInt32(at + 20, tile.type, true)
+    view.setInt32(at + 24, tile.style, true)
+    view.setInt32(at + 28, tile.sequence, true)
+    view.setInt32(at + 32, 0, true)                   // rarity frame index
+    // 25 sub-tile flags: a deterministic blocking pattern.
+    for (let sub = 0; sub < 25; sub += 1) out[at + 40 + sub] = sub % 3 === 0 ? 0x01 : sub % 5 === 0 ? 0x23 : 0
+    view.setInt32(at + 72, blockHeaderStart + index * DT1_BLOCK_HEADER, true)
+    view.setInt32(at + 76, DT1_BLOCK_HEADER, true)
+    view.setInt32(at + 80, 1, true)                   // one block
+    const headerAt = blockHeaderStart + index * DT1_BLOCK_HEADER
+    // Block header (20 bytes): X, Y, 2 unused, GridX, GridY, Format, Length,
+    // 2 unused, FileOffset — and the offset is relative to this header.
+    view.setInt16(headerAt + 0, 0, true)              // block x
+    view.setInt16(headerAt + 2, 0, true)              // block y
+    out[headerAt + 6] = 0                             // grid x
+    out[headerAt + 7] = 0                             // grid y
+    view.setInt16(headerAt + 8, tile.rle ? 0 : 1, true)
+    view.setInt32(headerAt + 10, bodies[index]!.byteLength, true)
+    // The offset is relative to this tile's own block header pointer (each tile
+    // has its own), not to the start of the whole block header section.
+    view.setInt32(headerAt + 16, blockDataOffsets[index]! - headerAt, true)
+    out.set(bodies[index]!, blockDataOffsets[index]!)
+  })
+  return out
+}
+
+/**
+ * Build a DS1 map referencing the fixture tiles.
+ *
+ * Uses version 16 so the file exercises act, wall *and* floor layer counts, the
+ * interleaved wall/orientation streams and the object list — and, unlike
+ * versions 9..13, carries no unknown byte block.
+ *
+ * @returns the encoded map.
+ */
+function encodeDs1(): Uint8Array {
+  const version = 16
+  const width = 3
+  const height = 3
+  const wallLayers = 1
+  const floorLayers = 1
+  const layerOrder: { kind: 'wall' | 'orientation' | 'floor' | 'shadow' }[] = [
+    { kind: 'wall' }, { kind: 'orientation' }, { kind: 'floor' }, { kind: 'shadow' },
+  ]
+  const cellCount = width * height
+  const objects = [
+    { type: 2, id: 1, x: 1, y: 1, flags: 0 },
+    { type: 5, id: 0, x: 2, y: 0, flags: 0x8 },
+  ]
+  const total = 4 * 3 // version, width-1, height-1
+    + 4 // act
+    + 4 // substitution type
+    + 4 // embedded file count
+    + 4 + 4 // wall layers, floor layers
+    + layerOrder.length * cellCount * 4
+    + 4 + objects.length * 20
+    + 4 // NPC count (version 14+ carries NPC paths after the objects)
+  const out = new Uint8Array(total)
+  const view = new DataView(out.buffer)
+  let at = 0
+  view.setInt32(at, version, true); at += 4
+  view.setInt32(at, width - 1, true); at += 4
+  view.setInt32(at, height - 1, true); at += 4
+  view.setInt32(at, 2, true); at += 4            // act
+  view.setInt32(at, 0, true); at += 4            // substitution type
+  view.setInt32(at, 0, true); at += 4            // embedded file count
+  view.setInt32(at, wallLayers, true); at += 4
+  view.setInt32(at, floorLayers, true); at += 4
+
+  for (const layer of layerOrder) {
+    for (let y = 0; y < height; y += 1) {
+      for (let x = 0; x < width; x += 1) {
+        const seed = (y * width + x) & 0xff
+        let bits: number
+        switch (layer.kind) {
+          case 'wall':
+            // Style 2 holds the two wall tiles; sequence picks between them.
+            bits = (seed | (((x + y) % 2) << 8) | (2 << 20)) >>> 0
+            break
+          case 'orientation':
+            bits = 0
+            break
+          case 'floor':
+            // Style 1 holds the two floor tiles.
+            bits = ((seed + 1) | (((x * 3 + y) % 2) << 8) | (1 << 20)) >>> 0
+            break
+          case 'shadow':
+            bits = (seed % 8) >>> 0
+            break
+        }
+        view.setUint32(at, bits >>> 0, true); at += 4
+      }
+    }
+  }
+
+  view.setInt32(at, objects.length, true); at += 4
+  for (const object of objects) {
+    view.setInt32(at, object.type, true); at += 4
+    view.setInt32(at, object.id, true); at += 4
+    view.setInt32(at, object.x, true); at += 4
+    view.setInt32(at, object.y, true); at += 4
+    view.setInt32(at, object.flags, true); at += 4
+  }
+  // No NPC paths in the fixture: the section's count is zero, which is what
+  // version 14+ readers look for after the objects.
+  view.setInt32(at, 0, true); at += 4
+  return out
+}
+
+const outDir = process.argv[2]
+if (outDir === undefined) {
+  console.error('usage: node scripts/make-map-fixtures.ts <output-directory>')
+  process.exit(2)
+}
+await mkdir(outDir, { recursive: true })
+const dt1 = encodeDt1()
+const ds1 = encodeDs1()
+await writeFile(join(outDir, 'fixture.dt1'), dt1)
+await writeFile(join(outDir, 'fixture.ds1'), ds1)
+
+/**
+ * The pixel grid each fixture tile is expected to decode to, computed from the
+ * same parameters the encoder used. Independent of the decoder under test —
+ * which is the point: it turns "the decoder did not throw" into "the decoder put
+ * every pixel where the encoder put it".
+ */
+const tileWidth = TILE
+const tileHeight = TILE
+const expectedTiles: { format: number; base: number; pixels: number[] }[] = []
+for (const [index, rle] of [true, true, false, false].entries()) {
+  const base = rle ? 9 + index * 40 : 70 + index * 40
+  const pixels = new Array<number>(tileWidth * tileHeight).fill(0)
+  if (rle) {
+    for (let y = 0; y < tileHeight; y += 1) {
+      const start = y % 4
+      const count = tileWidth - start - (y % 3)
+      for (let i = 0; i < count; i += 1) pixels[y * tileWidth + start + i] = ((base + y * 7 + i) & 0xff) || 1
+    }
+  } else {
+    const jump = [14, 12, 10, 8, 6, 4, 2, 0, 2, 4, 6, 8, 10, 12, 14]
+    const run = [4, 8, 12, 16, 20, 24, 28, 32, 28, 24, 20, 16, 12, 8, 4]
+    let at = 0
+    for (let row = 0; row < jump.length; row += 1) {
+      for (let i = 0; i < run[row]!; i += 1) {
+        pixels[row * tileWidth + jump[row]! + i] = ((base + at) & 0xff) || 1
+        at += 1
+      }
+    }
+  }
+  expectedTiles.push({ format: rle ? 0 : 1, base, pixels })
+}
+await writeFile(join(outDir, 'expected-dt1.json'), JSON.stringify({ width: tileWidth, height: tileHeight, tiles: expectedTiles }))
+
+console.log(`wrote ${join(outDir, 'fixture.dt1')} (${String(dt1.byteLength)} bytes)`)
+console.log(`wrote ${join(outDir, 'fixture.ds1')} (${String(ds1.byteLength)} bytes)`)
+console.log(`wrote ${join(outDir, 'expected-dt1.json')}`)
diff --git a/scripts/make-mpq-fixture.ts b/scripts/make-mpq-fixture.ts
new file mode 100644
index 0000000..6dc2d95
--- /dev/null
+++ b/scripts/make-mpq-fixture.ts
@@ -0,0 +1,248 @@
+/**
+ * MPQ fixture packer: write a real MPQ v1 archive containing the generated
+ * fixtures.
+ *
+ * This exists so the *whole* user path can be exercised before any Blizzard data
+ * is available: drop an archive in, have the engine open it, list it, decode map
+ * members from it, and render a map. It is also the only way to test the
+ * reader's stored-member path and its sector logic against something whose
+ * contents are known byte for byte.
+ *
+ * The archive is written to the v1 rules the reader implements: both tables
+ * encrypted with their fixed keys, members stored either raw or as zlib sectors
+ * with a compression-mask byte per sector, and — deliberately — a mix of both so
+ * one archive covers both code paths.
+ *
+ * This is tooling, not engine code: it is not shipped and not imported by the app.
+ *
+ * Usage: node scripts/make-mpq-fixture.ts <fixture-directory> [output.mpq]
+ */
+import { readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import {
+  BLOCK_TABLE_KEY, HASH_NAME_A, HASH_NAME_B, HASH_TABLE_KEY, HASH_TABLE_OFFSET,
+  encryptBlock, hashString, normalizeName,
+} from '../src/mpq/crypt.ts'
+
+/** v1 header size in bytes. */
+const HEADER_SIZE = 32
+/** Archive signature ('MPQ\x1A'). */
+const MAGIC = 0x1a51504d
+/** Sector size shift: sectors are `512 << shift` bytes. */
+const SECTOR_SHIFT = 3
+/** Resulting sector size. */
+const SECTOR_SIZE = 512 << SECTOR_SHIFT
+/** Flag: entry exists. */
+const FILE_EXISTS = 0x80000000
+/** Flag: member uses the multi-codec compression path (sector table present). */
+const FILE_COMPRESS = 0x00000200
+/**
+ * Flag: member is stored as one unit, with no sector offset table.
+ *
+ * This is not optional for stored members: a reader that sees neither this flag
+ * nor `FILE_COMPRESS` takes the sector path and reads a sector table out of the
+ * file's own data. Omitting it produces an archive only a lenient reader can
+ * open — which is exactly how this was found, by an independent reader failing
+ * on the stored members while the compressed ones read fine.
+ */
+const FILE_SINGLE_UNIT = 0x01000000
+/** Compression mask byte for zlib. */
+const MASK_ZLIB = 0x02
+
+/** One member to pack. */
+interface Member {
+  /** Archive name (either separator). */
+  readonly name: string
+  /** Contents. */
+  readonly data: Uint8Array
+  /** Whether to store it through the compressed sector path. */
+  readonly compress: boolean
+}
+
+/**
+ * Deflate one buffer with the platform compressor.
+ *
+ * @param data - input bytes.
+ * @returns the zlib stream.
+ */
+async function deflate(data: Uint8Array): Promise<Uint8Array> {
+  const stream = new Blob([data as BlobPart]).stream().pipeThrough(new CompressionStream('deflate'))
+  return new Uint8Array(await new Response(stream).arrayBuffer())
+}
+
+/**
+ * Encode one member's stored bytes and flags.
+ *
+ * @param member - the member to encode.
+ * @returns the stored bytes, stored size, flags and (when compressed) layout.
+ */
+async function encodeMember(member: Member): Promise<{ stored: Uint8Array; flags: number }> {
+  if (!member.compress) {
+    // Stored members have no sector offset table at all, which is what
+    // SINGLE_UNIT declares.
+    return { stored: member.data, flags: (FILE_EXISTS | FILE_SINGLE_UNIT) >>> 0 }
+  }
+  const sectorCount = Math.max(1, Math.ceil(member.data.byteLength / SECTOR_SIZE))
+  const tableSize = (sectorCount + 1) * 4
+  const payloads: Uint8Array[] = []
+  for (let sector = 0; sector < sectorCount; sector += 1) {
+    const from = sector * SECTOR_SIZE
+    const raw = member.data.subarray(from, Math.min(from + SECTOR_SIZE, member.data.byteLength))
+    const deflated = await deflate(raw)
+    // A sector that did not shrink is stored raw, which is what the reader
+    // detects by comparing the stored size to the expected size.
+    payloads.push(deflated.byteLength < raw.byteLength ? concat([new Uint8Array([MASK_ZLIB]), deflated]) : raw)
+  }
+  const total = tableSize + payloads.reduce((sum, payload) => sum + payload.byteLength, 0)
+  const stored = new Uint8Array(total)
+  const view = new DataView(stored.buffer)
+  let at = tableSize
+  payloads.forEach((payload, sector) => {
+    // Offsets are relative to the block start and include the table itself,
+    // which is why the first entry equals the table size.
+    view.setUint32(sector * 4, at, true)
+    stored.set(payload, at)
+    at += payload.byteLength
+  })
+  view.setUint32(sectorCount * 4, total, true)
+  return { stored, flags: (FILE_EXISTS | FILE_COMPRESS) >>> 0 }
+}
+
+/**
+ * Concatenate buffers.
+ *
+ * @param parts - the buffers.
+ * @returns their concatenation.
+ */
+function concat(parts: readonly Uint8Array[]): Uint8Array {
+  const total = parts.reduce((sum, part) => sum + part.byteLength, 0)
+  const out = new Uint8Array(total)
+  let at = 0
+  for (const part of parts) { out.set(part, at); at += part.byteLength }
+  return out
+}
+
+/**
+ * Write an MPQ v1 archive.
+ *
+ * @param members - members to pack.
+ * @returns the archive bytes.
+ */
+async function writeMpq(members: readonly Member[]): Promise<Uint8Array> {
+  const encoded = await Promise.all(members.map(async member => ({
+    name: normalizeName(member.name),
+    ...await encodeMember(member),
+    fileSize: member.data.byteLength,
+  })))
+
+  // Lay out the file data first, then the two tables.
+  let cursor = HEADER_SIZE
+  const placed = encoded.map(entry => {
+    const at = cursor
+    cursor += entry.stored.byteLength
+    return { ...entry, filePos: at }
+  })
+  const hashTableSize = Math.max(4, nextPowerOfTwo(placed.length * 2))
+  const hashTablePos = cursor
+  cursor += hashTableSize * 16
+  const blockTablePos = cursor
+  cursor += placed.length * 16
+  const archiveSize = cursor
+
+  const out = new Uint8Array(archiveSize)
+  const view = new DataView(out.buffer)
+  placed.forEach(entry => { out.set(entry.stored, entry.filePos) })
+
+  // Block table: position, stored size, file size, flags.
+  placed.forEach((entry, index) => {
+    const at = blockTablePos + index * 16
+    view.setUint32(at, entry.filePos, true)
+    view.setUint32(at + 4, entry.stored.byteLength, true)
+    view.setUint32(at + 8, entry.fileSize, true)
+    view.setUint32(at + 12, entry.flags, true)
+  })
+
+  // Hash table: one entry per member at its probe position, free slots marked
+  // with the 0xFFFFFFFF sentinel the reader stops on.
+  const hashTable = new Uint8Array(hashTableSize * 16)
+  const hashView = new DataView(hashTable.buffer)
+  for (let slot = 0; slot < hashTableSize; slot += 1) {
+    hashView.setUint32(slot * 16 + 12, 0xffffffff, true)
+  }
+  placed.forEach((entry, index) => {
+    const hashA = hashString(entry.name, HASH_NAME_A)
+    const hashB = hashString(entry.name, HASH_NAME_B)
+    let slot = hashString(entry.name, HASH_TABLE_OFFSET) % hashTableSize
+    // Linear probing, exactly as the reader walks it.
+    while (hashView.getUint32(slot * 16 + 12, true) !== 0xffffffff) slot = (slot + 1) % hashTableSize
+    const at = slot * 16
+    hashView.setUint32(at, hashA, true)
+    hashView.setUint32(at + 4, hashB, true)
+    hashView.setUint16(at + 8, 0, true)   // locale
+    hashView.setUint16(at + 10, 0, true)  // platform
+    hashView.setUint32(at + 12, index, true)
+  })
+  encryptBlock(hashTable, HASH_TABLE_KEY)
+
+  const blockTable = new Uint8Array(out.subarray(blockTablePos, blockTablePos + placed.length * 16))
+  encryptBlock(blockTable, BLOCK_TABLE_KEY)
+
+  out.set(hashTable, hashTablePos)
+  out.set(blockTable, blockTablePos)
+  view.setUint32(0x00, MAGIC, true)
+  view.setUint32(0x04, HEADER_SIZE, true)
+  view.setUint32(0x08, archiveSize, true)
+  view.setUint16(0x0c, 0, true)          // format version 1
+  view.setUint16(0x0e, SECTOR_SHIFT, true)
+  view.setUint32(0x10, hashTablePos, true)
+  view.setUint32(0x14, blockTablePos, true)
+  view.setUint32(0x18, hashTableSize, true)
+  view.setUint32(0x1c, placed.length, true)
+  return out
+}
+
+/**
+ * Round a value up to a power of two.
+ *
+ * @param value - the value.
+ * @returns the next power of two.
+ */
+function nextPowerOfTwo(value: number): number {
+  let result = 1
+  while (result < value) result *= 2
+  return result
+}
+
+const dir = process.argv[2]
+if (dir === undefined) {
+  console.error('usage: node scripts/make-mpq-fixture.ts <fixture-directory> [output.mpq]')
+  process.exit(2)
+}
+const output = process.argv[3] ?? join(dir, 'fixture.mpq')
+
+// The map members are the point; one of them is stored raw so the archive
+// exercises both the stored and the compressed read paths.
+const names = [
+  'fixture.ds1', 'fixture.dt1', 'palette.pal', 'fixture.dc6', 'actor.dc6',
+  'data/global/excel/monstats.txt', 'data/global/excel/experience.txt',
+  'data/global/excel/weapons.txt', 'data/global/excel/armor.txt', 'data/global/excel/misc.txt',
+  'data/global/excel/magicprefix.txt', 'data/global/excel/magicsuffix.txt',
+  'data/global/excel/skills.txt', 'data/global/excel/npcs.txt', 'data/global/excel/quests.txt',
+  'data/local/string.tbl',
+]
+const members: Member[] = []
+for (const name of names) {
+  const data = new Uint8Array(await readFile(join(dir, name)))
+  members.push({ name, data, compress: name !== 'palette.pal' })
+}
+members.push({
+  name: '(listfile)',
+  data: new TextEncoder().encode(`${names.join('\r\n')}\r\n`),
+  compress: false,
+})
+
+const archive = await writeMpq(members)
+await writeFile(output, archive)
+console.log(`wrote ${output} (${String(archive.byteLength)} bytes, ${String(members.length)} members)`)
+console.log(`  stored   : ${members.filter(member => !member.compress).map(member => member.name).join(', ')}`)
+console.log(`  zlib     : ${members.filter(member => member.compress).map(member => member.name).join(', ')}`)
diff --git a/scripts/make-pl2-fixture.ts b/scripts/make-pl2-fixture.ts
new file mode 100644
index 0000000..2491865
--- /dev/null
+++ b/scripts/make-pl2-fixture.ts
@@ -0,0 +1,85 @@
+/**
+ * PL2 fixture generator.
+ *
+ * PL2 is purely positional — no header, no counts, no directory — so the only
+ * way to test it without a real file is to write the bytes in the documented
+ * order and let an independent decoder read them back. Every table gets a
+ * pattern that depends on its *global index*, so a table read out of order, or a
+ * group with the wrong count, changes the digests the parity harness compares
+ * rather than passing silently.
+ *
+ * Usage: node scripts/make-pl2-fixture.ts <output-directory>
+ */
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { pl2ExpectedSize } from '../src/formats/pl2.ts'
+
+/** Palette entries per transform table. */
+const PALETTE_COLORS = 256
+/** Groups in file order: name → table count. */
+const GROUPS: readonly (readonly [string, number])[] = [
+  ['lightLevels', 32],
+  ['inverseColors', 16],
+  ['selectedUnitShift', 1],
+  ['alphaBlend0', 256],
+  ['alphaBlend1', 256],
+  ['alphaBlend2', 256],
+  ['additiveBlend', 256],
+  ['multiplyBlend', 256],
+  ['hueVariations', 111],
+  ['redTones', 1],
+  ['greenTones', 1],
+  ['blueTones', 1],
+  ['unknownVariations', 14],
+  ['maxComponentBlend', 256],
+  ['darkenedShift', 1],
+  ['textShifts', 13],
+]
+
+const outDir = process.argv[2]
+if (outDir === undefined) {
+  console.error('usage: node scripts/make-pl2-fixture.ts <output-directory>')
+  process.exit(2)
+}
+await mkdir(outDir, { recursive: true })
+
+const size = pl2ExpectedSize()
+const file = new Uint8Array(size)
+let cursor = 0
+
+// Base palette: r, g, b plus an unused byte that is deliberately not zero, so a
+// decoder that reads it as colour data (or as alpha) is caught.
+for (let index = 0; index < PALETTE_COLORS; index += 1) {
+  file[cursor++] = index
+  file[cursor++] = (index * 3) & 0xff
+  file[cursor++] = (index * 7) & 0xff
+  file[cursor++] = 0xab
+}
+
+// Transform tables: table `k` maps entry `i` to `(i + k) mod 256`, which makes
+// every table distinct and its position observable.
+let table = 0
+for (const [, count] of GROUPS) {
+  for (let index = 0; index < count; index += 1) {
+    for (let entry = 0; entry < PALETTE_COLORS; entry += 1) {
+      file[cursor++] = (entry + table) & 0xff
+    }
+    table += 1
+  }
+}
+
+// Text palette (13 entries, three bytes each).
+for (let index = 0; index < 13; index += 1) {
+  file[cursor++] = (10 + index) & 0xff
+  file[cursor++] = (20 + index) & 0xff
+  file[cursor++] = (30 + index) & 0xff
+}
+
+if (cursor !== size) {
+  throw new Error(`fixture wrote ${String(cursor)} bytes, expected ${String(size)}`)
+}
+
+const path = join(outDir, 'fixture.pl2')
+await writeFile(path, file)
+await writeFile(join(outDir, 'pl2-groups.json'), JSON.stringify(GROUPS, null, 2))
+console.log(`wrote ${path} (${String(file.byteLength)} bytes, ${String(table)} transform tables + 13 text shifts)`)
diff --git a/scripts/net-relay.ts b/scripts/net-relay.ts
new file mode 100644
index 0000000..85b9738
--- /dev/null
+++ b/scripts/net-relay.ts
@@ -0,0 +1,191 @@
+/**
+ * A tiny WebSocket relay, for testing the networked session over a real socket.
+ *
+ * The game needs a way for two peers to reach each other, and nothing more: the
+ * relay forwards every binary message to the other connected clients and never
+ * inspects it. That is not a design statement about production hosting — it is
+ * the smallest server that lets the *real* transport code path (real TCP, real
+ * WebSocket framing, real asynchrony) be tested without a browser and without a
+ * dependency.
+ *
+ * Written against Node's `http` and `crypto` only, including the RFC 6455
+ * handshake and framing, because pulling in a WebSocket server library to test a
+ * zero-dependency client would be the wrong trade.
+ */
+import { createHash } from 'node:crypto'
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http'
+import type { Socket } from 'node:net'
+
+/** RFC 6455 handshake magic value. */
+const WS_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+
+/** Opcodes used here. */
+const OP_TEXT = 0x1
+const OP_BINARY = 0x2
+const OP_CLOSE = 0x8
+const OP_PING = 0x9
+const OP_PONG = 0xa
+
+/** A running relay. */
+export interface Relay {
+  /** `ws://` URL clients should connect to. */
+  readonly url: string
+  /** Number of currently connected clients. */
+  readonly clients: number
+  /** Total connections accepted since start. */
+  readonly accepted: number
+  /** Total binary messages forwarded. */
+  readonly forwarded: number
+  /** Stop listening and close every client. */
+  readonly close: () => Promise<void>
+}
+
+/**
+ * Encode one unmasked server frame.
+ *
+ * @param opcode - the frame opcode.
+ * @param payload - the payload bytes.
+ * @returns the frame.
+ */
+function encodeFrame(opcode: number, payload: Uint8Array): Uint8Array {
+  const length = payload.byteLength
+  const headerBytes = length < 126 ? 2 : length < 65536 ? 4 : 10
+  const out = new Uint8Array(headerBytes + length)
+  out[0] = 0x80 | opcode
+  if (length < 126) {
+    out[1] = length
+  } else if (length < 65536) {
+    out[1] = 126
+    out[2] = (length >>> 8) & 0xff
+    out[3] = length & 0xff
+  } else {
+    out[1] = 127
+    const view = new DataView(out.buffer)
+    view.setUint32(2, 0)
+    view.setUint32(6, length)
+  }
+  out.set(payload, headerBytes)
+  return out
+}
+
+/**
+ * Decode the client frames in a buffer.
+ *
+ * Returns the frames found plus the bytes that were not a complete frame yet:
+ * TCP gives no message boundaries, so a partial frame is normal and must be kept
+ * for the next chunk rather than parsed as if it were whole.
+ *
+ * @param buffer - accumulated bytes.
+ * @returns the frames and the unconsumed remainder.
+ */
+function decodeFrames(buffer: Uint8Array<ArrayBufferLike>): { frames: { opcode: number; payload: Uint8Array }[]; rest: Uint8Array<ArrayBufferLike> } {
+  const frames: { opcode: number; payload: Uint8Array }[] = []
+  let offset = 0
+  while (offset + 2 <= buffer.byteLength) {
+    const first = buffer[offset]!
+    const second = buffer[offset + 1]!
+    const opcode = first & 0x0f
+    const masked = (second & 0x80) !== 0
+    let length = second & 0x7f
+    let cursor = offset + 2
+    if (length === 126) {
+      if (cursor + 2 > buffer.byteLength) break
+      length = (buffer[cursor]! << 8) | buffer[cursor + 1]!
+      cursor += 2
+    } else if (length === 127) {
+      if (cursor + 8 > buffer.byteLength) break
+      const view = new DataView(buffer.buffer, buffer.byteOffset + cursor, 8)
+      const big = view.getBigUint64(0)
+      if (big > 1_000_000n) throw new Error('frame too large')
+      length = Number(big)
+      cursor += 8
+    }
+    let mask: Uint8Array | null = null
+    if (masked) {
+      if (cursor + 4 > buffer.byteLength) break
+      mask = buffer.subarray(cursor, cursor + 4)
+      cursor += 4
+    }
+    if (cursor + length > buffer.byteLength) break
+    const payload = buffer.slice(cursor, cursor + length)
+    if (mask !== null) for (let i = 0; i < payload.byteLength; i += 1) payload[i] = payload[i]! ^ mask[i % 4]!
+    frames.push({ opcode, payload })
+    offset = cursor + length
+  }
+  return { frames, rest: buffer.slice(offset) }
+}
+
+/**
+ * Start a relay on a port.
+ *
+ * @param port - TCP port; 0 picks a free one.
+ * @returns the running relay.
+ */
+export async function startRelay(port = 0, options: { readonly verbose?: boolean } = {}): Promise<Relay> {
+  const log = (message: string): void => { if (options.verbose === true) console.log(`[relay] ${message}`) }
+  const sockets = new Set<Socket>()
+  let accepted = 0
+  let forwarded = 0
+
+  const server: Server = createServer((_request: IncomingMessage, response: ServerResponse) => {
+    response.writeHead(426, { 'content-type': 'text/plain' })
+    response.end('this endpoint speaks WebSocket only\n')
+  })
+
+  server.on('upgrade', (request, socket: Socket, head) => {
+    const key = request.headers['sec-websocket-key']
+    if (typeof key !== 'string') { socket.destroy(); return }
+    const accept = createHash('sha1').update(key + WS_GUID).digest('base64')
+    socket.write(
+      'HTTP/1.1 101 Switching Protocols\r\n'
+      + 'Upgrade: websocket\r\n'
+      + 'Connection: Upgrade\r\n'
+      + `Sec-WebSocket-Accept: ${accept}\r\n\r\n`,
+    )
+    sockets.add(socket)
+    accepted += 1
+    log(`upgrade from ${String(request.socket.remoteAddress ?? '?')} (${String(sockets.size)} connected)`)
+    let buffer: Uint8Array<ArrayBufferLike> = head.byteLength > 0 ? new Uint8Array(head) : new Uint8Array(0)
+
+    socket.on('data', (chunk: Buffer) => {
+      const merged = new Uint8Array(buffer.byteLength + chunk.byteLength)
+      merged.set(buffer, 0)
+      merged.set(chunk, buffer.byteLength)
+      const { frames, rest } = decodeFrames(merged)
+      buffer = rest
+      log(`chunk ${String(chunk.byteLength)} bytes -> ${String(frames.length)} frames`)
+      for (const frame of frames) {
+        if (frame.opcode === OP_CLOSE) { socket.end(encodeFrame(OP_CLOSE, frame.payload)); continue }
+        if (frame.opcode === OP_PING) { socket.write(encodeFrame(OP_PONG, frame.payload)); continue }
+        if (frame.opcode !== OP_BINARY && frame.opcode !== OP_TEXT) continue
+        const out = encodeFrame(OP_BINARY, frame.payload)
+        let sent = 0
+        for (const peer of sockets) {
+          if (peer === socket || peer.destroyed) continue
+          peer.write(out)
+          forwarded += 1
+          sent += 1
+        }
+        log(`frame opcode ${String(frame.opcode)} ${String(frame.payload.byteLength)} bytes -> ${String(sent)} peer(s)`)
+      }
+    })
+    socket.on('close', () => { sockets.delete(socket); log('client closed') })
+    socket.on('error', () => { sockets.delete(socket) })
+  })
+
+  await new Promise<void>(resolve => { server.listen(port, '127.0.0.1', resolve) })
+  const address = server.address()
+  const boundPort = typeof address === 'object' && address !== null ? address.port : port
+
+  return {
+    url: `ws://127.0.0.1:${String(boundPort)}`,
+    get clients(): number { return sockets.size },
+    get accepted(): number { return accepted },
+    get forwarded(): number { return forwarded },
+    close: async (): Promise<void> => {
+      for (const socket of sockets) socket.destroy()
+      sockets.clear()
+      await new Promise<void>(resolve => { server.close(() => { resolve() }) })
+    },
+  }
+}
diff --git a/scripts/net-server.ts b/scripts/net-server.ts
new file mode 100644
index 0000000..c91d8d6
--- /dev/null
+++ b/scripts/net-server.ts
@@ -0,0 +1,22 @@
+/**
+ * Run the co-op relay.
+ *
+ * This is the whole of "the server": it forwards bytes between the connected
+ * peers and knows nothing about the game. Everything that decides who wins a
+ * fight happens in the two browsers.
+ *
+ * Usage: node scripts/net-server.ts [port]
+ */
+import { startRelay } from './net-relay.ts'
+
+const port = Number(process.argv[2] ?? '8787')
+const relay = await startRelay(Number.isFinite(port) ? port : 8787)
+console.log(`relay listening on ${relay.url}`)
+console.log('open two pages with ?ws=' + relay.url + '&peer=0 and &peer=1')
+
+const stop = async (): Promise<void> => {
+  await relay.close()
+  process.exit(0)
+}
+process.on('SIGINT', () => { void stop() })
+process.on('SIGTERM', () => { void stop() })
diff --git a/scripts/pack-act-assets.ts b/scripts/pack-act-assets.ts
new file mode 100644
index 0000000..3fdfc2e
--- /dev/null
+++ b/scripts/pack-act-assets.ts
@@ -0,0 +1,642 @@
+/**
+ * Bake map assets out of the archives into web-native packs.
+ *
+ * The page can already read the real archives, but doing so costs it 38 MB and
+ * ~11k range requests per visit (measured), because it decodes DS1/DT1/PL2 and
+ * builds an atlas in the browser every time. This script moves all of that
+ * offline: it walks the same code the page walks — `resolveLevel`, `decodeDs1`,
+ * `decodeDt1`, `buildIsoMapScene`, `decodeDc6` — and writes the *result* as
+ * indexed PNG tile pages plus one JSON scene per map. The page then decodes
+ * nothing but PNG.
+ *
+ * Design decisions worth knowing:
+ *
+ * - **Indexed PNG, one palette per act.** Diablo II art is palette-indexed and
+ *   each act ships its own `pal.pl2`; PNG colour type 3 carries both, so the
+ *   browser's own decoder does the palette expansion on the GPU upload path.
+ * - **Pages of at most 2048², hot frames first.** Frames used near the spawn go
+ *   into the first page(s), so the page can paint after loading one or two PNGs
+ *   instead of the whole map.
+ * - **The scene JSON is the authority, not a re-derivation.** Draw lists are
+ *   already in painter's order and the collision grid is exactly the one the
+ *   live path produces; `scripts/verify-packs.ts` re-derives both from the MPQs
+ *   and fails if they differ by a byte.
+ *
+ * Usage: node scripts/pack-act-assets.ts [archive-directory] [output-directory]
+ */
+import { mkdir, writeFile } from 'node:fs/promises'
+import { createHash } from 'node:crypto'
+import { join } from 'node:path'
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { fileSource } from '../src/mpq/file-source.ts'
+import { MountedArchives } from '../src/mpq/mount.ts'
+import { cell, loadActTables, parseTable, resolveLevel } from '../src/game/acts.ts'
+import type { ActTables, LevelInfo } from '../src/game/acts.ts'
+import { decodeDs1 } from '../src/formats/ds1.ts'
+import { decodeDt1 } from '../src/formats/dt1.ts'
+import type { Dt1 } from '../src/formats/dt1.ts'
+import { decodePl2 } from '../src/formats/pl2.ts'
+import { levelSeed, buildIsoMapScene, cellAt, findIsoSpawn, ORTHO_SUB_TILE_HEIGHT, ORTHO_SUB_TILE_WIDTH } from '../src/game/d2map.ts'
+import type { IsoMapScene } from '../src/game/d2map.ts'
+import { loadObjectsTable, resolveDs1Object } from '../src/game/objects.ts'
+import { encodeIndexedPng } from './png.ts'
+
+/**
+ * Archive stack, in load order (later overrides earlier).
+ *
+ * `d2char.mpq` is mounted *first* so it sits at the bottom: it holds the object
+ * and character art (`data\global\objects\…`) but no map data, and this order
+ * keeps the map lookups resolving through `d2data` → `d2exp` → `Patch_D2` as the
+ * game does.
+ */
+const MOUNTS = ['d2char.mpq', 'd2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq'] as const
+/** Atlas page side limit (both dimensions). */
+const PAGE_SIZE = 2048
+/** Cells around the spawn whose frames go into the first page. */
+const HOT_RADIUS_CELLS = 8
+/** Where object art lives. */
+const OBJECT_PREFIX = 'data\\global\\objects\\'
+/**
+ * Mode directories tried in order when picking an object's art.
+ *
+ * Note what the object art actually *is*: under `data\global\objects\` the
+ * archives hold **1748 DCC and 1461 COF files against just 13 DC6**. Diablo II
+ * draws objects with the same composite pipeline as characters — a COF that
+ * lists layers and frames plus the DCC files behind them — so this packer
+ * records each object's placement and its exact art members, and leaves the
+ * pixels to the `COF`/`DCC` decoder that the character art also needs. Baking a
+ * wrong file as if it were a DC6 would have produced silent garbage instead.
+ */
+const OBJECT_MODES = ['tr', 'nu', 's1', 's2', 's3'] as const
+
+/**
+ * The maps to bake, derived from `Levels.txt` rather than listed by hand.
+ *
+ * `DrlgType` picks the generator, exactly as the game does (documented in the
+ * knowledge base and mirrored by OpenDiablo2):
+ *
+ * - **2 = preset area**: `LvlPrest` rows name fixed DS1 files, so the map is
+ *   baked byte-for-byte — what `verify-packs.ts` diffs against the live decoder.
+ * - **1 = random maze** / **3 = wilderness**: no fixed layout exists. Those come
+ *   from the generators (`src/game/maze.ts`, `src/game/wilderness.ts`) driven by
+ *   `LvlMaze`, `LvlSub` and the `LvlPrest` room pieces, and their packs are
+ *   marked `approximation` because the engine's own placement is hardcoded.
+ */
+type LevelKind = 'preset' | 'maze' | 'wilderness'
+
+/** One map to bake. */
+interface LevelJob {
+  readonly act: number
+  readonly levelId: number
+  readonly name: string
+  readonly kind: LevelKind
+  readonly slug: string
+}
+
+/** Filled in from `Levels.txt` once the tables are loaded. */
+let LEVELS: readonly LevelJob[] = []
+
+/**
+ * Turn a level name into a stable, file-friendly slug.
+ *
+ * @param name - `Levels.txt` name, e.g. `Act 1 - Tristram`.
+ * @returns the slug.
+ */
+function slugify(name: string): string {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '')
+}
+
+/** One frame's placement inside a page. */
+interface Placement {
+  readonly page: number
+  readonly x: number
+  readonly y: number
+  readonly width: number
+  readonly height: number
+}
+
+/** One atlas page being packed. */
+interface PackedPage {
+  readonly pixels: Uint8Array
+  frames: number
+}
+
+/** Frames, shelf-packed into pages of at most {@link PAGE_SIZE} squared. */
+class PageBuilder {
+  private readonly pages: PackedPage[] = []
+  /** Palette the pages are encoded against. */
+  private readonly palette: Uint8Array
+  private cursorX = 0
+  private shelfY = 0
+  private shelfHeight = 0
+
+  constructor(palette: Uint8Array) {
+    this.palette = palette
+  }
+
+  /** Frames placed so far. */
+  get placed(): number {
+    return this.pages.reduce((sum, page) => sum + page.frames, 0)
+  }
+
+  /** The pages, with their used height. */
+  get pageCount(): number {
+    return this.pages.length
+  }
+
+  /**
+   * Place one indexed frame, opening pages as needed.
+   *
+   * Shelves keep placement trivial and predictable; frames wider than a page are
+   * clamped rather than rejected, because a tile bigger than 2048 px would be a
+   * broken library, not a reason to lose the whole map.
+   *
+   * @param frame - width, height and palette indices.
+   * @returns where the frame landed.
+   */
+  add(frame: { width: number; height: number; indices: Uint8Array }): Placement {
+    const width = Math.max(1, Math.min(frame.width, PAGE_SIZE))
+    const height = Math.max(1, Math.min(frame.height, PAGE_SIZE))
+    if (this.cursorX + width > PAGE_SIZE) {
+      this.shelfY += this.shelfHeight
+      this.shelfHeight = 0
+      this.cursorX = 0
+    }
+    if (this.pages.length === 0 || this.shelfY + height > PAGE_SIZE) {
+      this.pages.push({ pixels: new Uint8Array(PAGE_SIZE * PAGE_SIZE), frames: 0 })
+      this.shelfY = 0
+      this.shelfHeight = 0
+      this.cursorX = 0
+    }
+    const page = this.pages[this.pages.length - 1]!
+    const placement: Placement = {
+      page: this.pages.length - 1, x: this.cursorX, y: this.shelfY, width, height,
+    }
+    for (let row = 0; row < height; row += 1) {
+      const from = row * frame.width
+      const to = (this.shelfY + row) * PAGE_SIZE + this.cursorX
+      page.pixels.set(frame.indices.subarray(from, from + width), to)
+    }
+    this.cursorX += width
+    this.shelfHeight = Math.max(this.shelfHeight, height)
+    page.frames += 1
+    return placement
+  }
+
+  /**
+   * Encode every page, trimming each to the rows it actually used.
+   *
+   * @param transparent - palette index to mark transparent.
+   * @returns file-ready PNGs, in page order.
+   */
+  encode(transparent: number): { name: string; png: Uint8Array; width: number; height: number; frames: number }[] {
+    return this.pages.map((page, index) => {
+      const used = Math.max(1, this.usedHeight(page))
+      const trimmed = new Uint8Array(PAGE_SIZE * used)
+      for (let row = 0; row < used; row += 1) {
+        trimmed.set(page.pixels.subarray(row * PAGE_SIZE, (row + 1) * PAGE_SIZE), row * PAGE_SIZE)
+      }
+      return {
+        name: `tiles-${String(index)}.png`,
+        png: encodeIndexedPng({
+          width: PAGE_SIZE,
+          height: used,
+          pixels: trimmed,
+          palette: this.palette,
+          transparentIndex: transparent,
+        }),
+        width: PAGE_SIZE,
+        height: used,
+        frames: page.frames,
+      }
+    })
+  }
+
+  /**
+   * Height of the last written row, for trimming.
+   *
+   * @param page - the page.
+   * @returns the used height in rows.
+   */
+  private usedHeight(page: PackedPage): number {
+    for (let row = PAGE_SIZE - 1; row >= 0; row -= 1) {
+      const from = row * PAGE_SIZE
+      for (let x = 0; x < PAGE_SIZE; x += 1) if (page.pixels[from + x] !== 0) return row + 1
+    }
+    return 1
+  }
+}
+
+/**
+ * FNV-1a over a frame's indexed pixels, so verification can compare content
+ * without shipping the pixels twice.
+ *
+ * @param indices - palette indices.
+ * @returns an 8-character hex digest.
+ */
+function frameHash(indices: Uint8Array): string {
+  let hash = 0x811c9dc5
+  for (const byte of indices) {
+    hash ^= byte
+    hash = Math.imul(hash, 0x01000193) >>> 0
+  }
+  return hash.toString(16).padStart(8, '0')
+}
+
+/**
+ * Turn a DS1 member name into a file-friendly slug.
+ *
+ * @param member - full member path.
+ * @returns the slug.
+ */
+function slugOf(member: string): string {
+  const base = member.split('\\').pop() ?? member
+  return base.replace(/\.ds1$/i, '').toLowerCase()
+}
+
+const [archiveDir = 'samples/d2', outDir = 'samples/d2-packs'] = process.argv.slice(2)
+
+const archives = new MountedArchives()
+for (const name of MOUNTS) {
+  archives.add(name, await MpqArchive.open(await fileSource(join(archiveDir, name))))
+}
+const tables: ActTables = await loadActTables(archives)
+const objectsTable = parseTable(await archives.read('data\\global\\excel\\objects.txt'))
+/** Same table, through the typed loader the object resolution expects. */
+const objectsTableTyped = await loadObjectsTable(archives)
+const allNames = await archives.listFiles()
+
+{
+  const jobs: LevelJob[] = []
+  for (const row of tables.levels.rows) {
+    const levelId = Number(cell(tables.levels, row, 'Id'))
+    if (!Number.isFinite(levelId) || levelId === 0) continue
+    const name = cell(tables.levels, row, 'Name')
+    const drlg = Number(cell(tables.levels, row, 'DrlgType'))
+    const act = Number(cell(tables.levels, row, 'Act')) + 1
+    let kind: LevelKind | null = null
+    if (drlg === 2) kind = 'preset'
+    else if (drlg === 1) kind = 'maze'
+    else if (drlg === 3) kind = 'wilderness'
+    if (kind === null) continue
+    jobs.push({ act, levelId, name, kind, slug: `${String(levelId)}-${slugify(name)}` })
+  }
+  LEVELS = jobs
+}
+
+/**
+ * Decoded DT1 libraries, kept across levels.
+ *
+ * A hundred-plus levels share a few dozen level types, so decoding each library
+ * once instead of once per level turns the bake from repeated work into one pass.
+ */
+/**
+ * Decoded DT1 libraries, keyed by member name.
+ *
+ * Bounded on purpose: every level keeps its DT1 block bitmaps alive (each library
+ * decodes to tens of MB of palette indices), and an unbounded cache held 4+ GB by
+ * the time the bake reached act 5. Sixteen libraries is more than any single
+ * level type uses, so a level never re-decodes mid-level, and the memory ceiling
+ * stays flat across a whole 62-map bake.
+ */
+const libraryCache = new Map<string, Dt1>()
+/** Most DT1 libraries to keep decoded at once. */
+const LIBRARY_CACHE_LIMIT = 16
+
+/**
+ * Decode a DT1 library, cached by member name.
+ *
+ * @param member - archive member name.
+ * @returns the decoded library.
+ */
+async function libraryOf(member: string): Promise<Dt1> {
+  const cached = libraryCache.get(member)
+  if (cached !== undefined) return cached
+  const decoded = decodeDt1(await archives.read(member))
+  libraryCache.set(member, decoded)
+  if (libraryCache.size > LIBRARY_CACHE_LIMIT) {
+    // `Map` iterates in insertion order, so the first key is the oldest entry.
+    const oldest = libraryCache.keys().next().value
+    if (oldest !== undefined && oldest !== member) libraryCache.delete(oldest)
+  }
+  return decoded
+}
+
+/** Objects.txt lookup by Id, built once. */
+const objectById = new Map<number, { name: string; token: string; hp: number }>()
+for (const row of objectsTable.rows) {
+  const id = Number(cell(objectsTable, row, 'Id'))
+  if (!Number.isFinite(id)) continue
+  objectById.set(id, {
+    name: cell(objectsTable, row, 'Name'),
+    token: cell(objectsTable, row, 'Token').toUpperCase(),
+    hp: Number(cell(objectsTable, row, 'HitPoints') || '0'),
+  })
+}
+
+/** Object members grouped by token and mode, built once. */
+const objectMembers = new Map<string, Map<string, string[]>>()
+for (const name of allNames) {
+  if (!name.toLowerCase().startsWith(OBJECT_PREFIX.toLowerCase())) continue
+  const rest = name.slice(OBJECT_PREFIX.length).split('\\')
+  if (rest.length < 3) continue
+  const token = (rest[0] ?? '').toUpperCase()
+  const mode = (rest[1] ?? '').toLowerCase()
+  if (!objectMembers.has(token)) objectMembers.set(token, new Map())
+  const modes = objectMembers.get(token)!
+  if (!modes.has(mode)) modes.set(mode, [])
+  modes.get(mode)!.push(name)
+}
+
+/**
+ * Pick the member that stands in for an object's art.
+ *
+ * A token ships many variants (lit/unlit, per-mode, per-weapon-class); the pack
+ * is static art, so one deterministic pick is recorded — mode order first, then
+ * file name — and the number of alternatives goes in the manifest so the choice
+ * is visible rather than implied.
+ *
+ * The mode token lives in the *file name* (`<token><component>lit<mode>hth.dcc`), not in
+ * the directory, so the mode the lookup table gives is matched against file names.
+ *
+ * @param token - object token from the lookup table.
+ * @param modeToken - animation mode token the engine places the object in (`NU`/`OP`/…).
+ * @returns the member name and how many candidates there were.
+ */
+function pickObjectMember(token: string, modeToken: string): { member: string; candidates: number } | null {
+  const dirs = objectMembers.get(token)
+  if (dirs === undefined) return null
+  const all = [...dirs.values()].flat()
+  const candidates = all.length
+  const wanted = modeToken.trim().toLowerCase() === '' ? 'nu' : modeToken.trim().toLowerCase()
+  const order = [wanted, ...OBJECT_MODES.map(mode => mode.toLowerCase()).filter(mode => mode !== wanted)]
+  for (const mode of order) {
+    const files = all
+      .filter(name => {
+        const base = (name.split('\\').pop() ?? '').toLowerCase()
+        return base.includes(mode) || (mode !== 'nu' && base.includes(`lit${mode}`))
+      })
+      .sort((a, b) => (a.toLowerCase().endsWith('.dcc') ? 0 : 1) - (b.toLowerCase().endsWith('.dcc') ? 0 : 1) || a.localeCompare(b))
+    if (files.length > 0) return { member: files[0]!, candidates }
+  }
+  // No file carries the mode token: fall back to any member, deterministically.
+  const fallback = [...all].sort()[0]
+  return fallback === undefined ? null : { member: fallback, candidates }
+}
+
+const index: Record<string, unknown> = {
+  version: 1,
+  generated: new Date().toISOString(),
+  archiveDir,
+  pageSize: PAGE_SIZE,
+  palettes: {} as Record<string, number[]>,
+  levels: [] as unknown[],
+}
+
+let totalPngBytes = 0
+let totalLevels = 0
+
+const pending: string[] = []
+for (const entry of LEVELS) {
+  if (entry.kind !== 'preset') {
+    // Maze and wilderness levels come from the generators; until those land they
+    // are reported rather than silently missing from the pack.
+    pending.push(`${entry.kind} ${String(entry.levelId)} ${entry.name}`)
+    continue
+  }
+  const info: LevelInfo = resolveLevel(tables, entry.levelId, entry.act)
+  const pl2 = decodePl2(await archives.read(info.paletteName))
+  const palette = pl2.rgb
+  ;(index.palettes as Record<string, number[]>)[`act${String(entry.act)}`] = [...palette]
+
+  const libraries = []
+  for (const name of info.dt1Names) libraries.push(await libraryOf(name))
+
+  for (const ds1Name of info.ds1Names) {
+    const level = decodeDs1(await archives.read(ds1Name))
+    const scene: IsoMapScene = buildIsoMapScene(level, libraries, levelSeed(ds1Name))
+    const spawn = findIsoSpawn(scene)
+    const label = `${entry.slug}-${slugOf(ds1Name)}`
+    const dir = join(outDir, `act${String(entry.act)}`, label)
+
+    // Frames used near the spawn load first; everything else follows.
+    const hot = new Set<number>()
+    if (spawn !== null) {
+      const spawnCell = cellAt(scene, spawn.x, spawn.y)
+      for (const draw of scene.floors) {
+        const distance = Math.abs(draw.cellX - spawnCell.x) + Math.abs(draw.cellY - spawnCell.y)
+        if (distance <= HOT_RADIUS_CELLS) hot.add(draw.frameIndex)
+      }
+      for (const draw of scene.walls) {
+        const distance = Math.abs(draw.cellX - spawnCell.x) + Math.abs(draw.cellY - spawnCell.y)
+        if (distance <= HOT_RADIUS_CELLS) hot.add(draw.frameIndex)
+      }
+    }
+    // Page order decides how much a first paint costs. Hot frames (the spawn
+    // area) come first, then frames are ordered by *where on the map they are
+    // first drawn*, in coarse screen bands (roughly a viewport each): a viewport then needs one band's page
+    // instead of an arbitrary handful. Sorting by size instead — the obvious
+    // choice for packing efficiency — scatters a viewport's frames across every
+    // page, which is exactly what lazy loading cannot afford.
+    const firstDrawAt = new Map<number, { x: number; y: number }>()
+    for (const draw of [...scene.floors, ...scene.walls]) {
+      if (!firstDrawAt.has(draw.frameIndex)) firstDrawAt.set(draw.frameIndex, { x: draw.x, y: draw.y })
+    }
+    const bandOf = (frameIndex: number): number => {
+      const at = firstDrawAt.get(frameIndex)
+      if (at === undefined) return Number.MAX_SAFE_INTEGER
+      return Math.floor(at.y / 512) * 4096 + Math.floor(at.x / 768)
+    }
+    const order = scene.frames.map((_, at) => at).sort((a, b) => {
+      const ha = hot.has(a) ? 0 : 1
+      const hb = hot.has(b) ? 0 : 1
+      if (ha !== hb) return ha - hb
+      const ba = bandOf(a)
+      const bb = bandOf(b)
+      if (ba !== bb) return ba - bb
+      const fa = scene.frames[a]!
+      const fb = scene.frames[b]!
+      return fb.width * fb.height - fa.width * fa.height
+    })
+    const pages = new PageBuilder(palette)
+    const placementOf = new Map<number, Placement>()
+    for (const frameIndex of order) {
+      const frame = scene.frames[frameIndex]!
+      placementOf.set(frameIndex, pages.add(frame))
+    }
+    const pageFiles = pages.encode(0)
+    await mkdir(dir, { recursive: true })
+    const sha = createHash('sha256')
+    for (const page of pageFiles) {
+      await writeFile(join(dir, page.name), page.png)
+      sha.update(page.png)
+      totalPngBytes += page.png.byteLength
+    }
+
+    // Object placements and their art members. The art itself is COF+DCC (see
+    // OBJECT_MODES), so this records what each object *is* and exactly which
+    // members would draw it, and reports how many are waiting on that decoder.
+    const objectPages = new PageBuilder(palette)
+    const objects: unknown[] = []
+    const missingObjects: string[] = []
+    let objectsWithArt = 0
+    for (const object of level.objects) {
+      // The DS1 `id` is an index into the hardcoded per-act object table, not an
+      // `Objects.txt` row: act 1 id 0 is the rogue fountain (`Objects.txt` 12), not
+      // row 0 ("Expansion"). `resolveDs1Object` walks that table and returns the
+      // token/mode the engine actually uses.
+      let resolved
+      try {
+        resolved = resolveDs1Object(objectsTableTyped, entry.act, object.type, object.id)
+      } catch (err) {
+        missingObjects.push((err as Error).message)
+        continue
+      }
+      if (resolved.kind === 'monster') continue
+      const row = resolved.row
+      const pick = resolved.token === '' ? null : pickObjectMember(resolved.token, resolved.mode)
+      const orthoX = (object.x - object.y) * ORTHO_SUB_TILE_WIDTH + scene.originX
+      const orthoY = (object.x + object.y) * ORTHO_SUB_TILE_HEIGHT + scene.originY
+      objects.push({
+        id: object.id,
+        type: object.type,
+        name: row?.name ?? resolved.token,
+        token: resolved.token,
+        mode: resolved.mode === '' ? 'NU' : resolved.mode,
+        // `objectsTxtId` is the Objects.txt row the table points at; -1 means the
+        // engine picks the art straight from the table's token, with no row.
+        objectsTxtId: resolved.entry?.objectsTxtId ?? -1,
+        hp: row === null ? 0 : (objectById.get(row.id)?.hp ?? 0),
+        member: pick === null ? null : pick.member,
+        alternatives: pick === null ? 0 : pick.candidates,
+        // Screen point of the object's sub-tile; the sprite anchor is applied
+        // when a frame exists.
+        x: Math.round(orthoX),
+        y: Math.round(orthoY),
+        depth: (object.x + object.y) / 5,
+        frame: null,
+      })
+      if (pick !== null) objectsWithArt += 1
+      else missingObjects.push(`${resolved.token === '' ? `id ${String(object.id)}` : resolved.token} (act ${String(entry.act)}) has no art members`)
+    }
+    const objectFiles = objectPages.encode(0)
+    const shaObjects = createHash('sha256')
+    for (const page of objectFiles) {
+      await writeFile(join(dir, page.name.replace('tiles-', 'objects-')), page.png)
+      shaObjects.update(page.png)
+      totalPngBytes += page.png.byteLength
+    }
+
+    // Collision grid as runs, so the JSON stays small without a second format.
+    const runs: number[][] = []
+    let current = scene.blocked[0] ?? 0
+    let count = 0
+    for (const value of scene.blocked) {
+      if (value === current) { count += 1; continue }
+      runs.push([current, count])
+      current = value
+      count = 1
+    }
+    runs.push([current, count])
+
+    const sceneJson = {
+      version: 1,
+      fidelity: 'exact',
+      act: entry.act,
+      levelId: entry.levelId,
+      levelName: info.levelName,
+      ds1: ds1Name,
+      cellsX: scene.cellsX,
+      cellsY: scene.cellsY,
+      originX: scene.originX,
+      originY: scene.originY,
+      widthPx: scene.widthPx,
+      heightPx: scene.heightPx,
+      pageSize: PAGE_SIZE,
+      pages: pageFiles.map(page => ({ file: page.name, width: page.width, height: page.height })),
+      objectPages: objectFiles.map(page => ({ file: page.name.replace('tiles-', 'objects-'), width: page.width, height: page.height })),
+      frames: scene.frames.map(frame => [frame.width, frame.height]),
+      frameHash: scene.frames.map(frame => frameHash(frame.indices)),
+      framePlacement: scene.frames.map((_, at) => {
+        const place = placementOf.get(at)!
+        return [place.page, place.x, place.y, place.width, place.height]
+      }),
+      floors: scene.floors.map(draw => [draw.frameIndex, draw.x, draw.y, draw.cellX, draw.cellY]),
+      walls: scene.walls.map(draw => [draw.frameIndex, draw.x, draw.y, draw.cellX, draw.cellY]),
+      // Roofs stay in their own list because the engine paints them last of all.
+      roofs: scene.roofs.map(draw => [draw.frameIndex, draw.x, draw.y, draw.cellX, draw.cellY]),
+      objects,
+      collision: { width: scene.gridWidth, height: scene.gridHeight, runs },
+      spawn: spawn === null ? null : [Math.round(spawn.x), Math.round(spawn.y)],
+      stats: {
+        floors: scene.floors.length,
+        walls: scene.walls.length,
+        roofs: scene.roofs.length,
+        frames: scene.frames.length,
+        missingTiles: scene.missingTiles,
+        missingRefs: scene.missingRefs,
+        walkable: 1 - [...scene.blocked].reduce((sum, value) => sum + value, 0) / scene.blocked.length,
+        objects: objects.length,
+        objectsWithArt,
+        objectsUnresolved: missingObjects,
+        objectsArtPending: objects.length,
+        dt1Libraries: info.dt1Names.length,
+      },
+    }
+    const sceneBytes = new TextEncoder().encode(JSON.stringify(sceneJson))
+    await writeFile(join(dir, 'scene.json'), sceneBytes)
+    const manifest = {
+      level: info.levelName,
+      act: entry.act,
+      levelId: entry.levelId,
+      ds1: ds1Name,
+      dt1: info.dt1Names,
+      palette: info.paletteName,
+      sceneBytes: sceneBytes.byteLength,
+      sceneSha256: createHash('sha256').update(sceneBytes).digest('hex'),
+      tilePagesSha256: sha.digest('hex'),
+      objectPagesSha256: shaObjects.digest('hex'),
+      pngBytes: pageFiles.reduce((sum, page) => sum + page.png.byteLength, 0)
+        + objectFiles.reduce((sum, page) => sum + page.png.byteLength, 0),
+      sourceArchive: MOUNTS,
+    }
+    await writeFile(join(dir, 'manifest.json'), JSON.stringify(manifest, null, 1))
+    ;(index.levels as unknown[]).push({
+      act: entry.act,
+      levelId: entry.levelId,
+      kind: entry.kind,
+      slug: entry.slug,
+      label,
+      levelName: info.levelName,
+      ds1: ds1Name,
+      path: `act${String(entry.act)}/${label}`,
+      cells: `${String(scene.cellsX)}x${String(scene.cellsY)}`,
+      frames: scene.frames.length,
+      objects: objects.length,
+      pages: pageFiles.length,
+      objectPages: objectFiles.length,
+      missingTiles: scene.missingTiles,
+      bytes: manifest.pngBytes + sceneBytes.byteLength,
+    })
+    totalLevels += 1
+    console.log(
+      `act${String(entry.act)}/${label.padEnd(22)} ${String(scene.cellsX)}x${String(scene.cellsY)} `
+      + `${String(scene.frames.length).padStart(3)} 图块 → ${String(pageFiles.length)} 页 PNG `
+      + `(${(manifest.pngBytes / 1024).toFixed(0)} KB) + scene.json ${(sceneBytes.byteLength / 1024).toFixed(0)} KB `
+      + `· 对象 ${String(objects.length)}/${String(level.objects.length)}（美术待 DCC/COF：${String(objectsWithArt)}）`
+      + ` · 缺失瓦片 ${String(scene.missingTiles)}`,
+    )
+  }
+}
+
+await mkdir(outDir, { recursive: true })
+await writeFile(join(outDir, 'index.json'), JSON.stringify(index, null, 1))
+if (pending.length > 0) {
+  const byKind = new Map<string, number>()
+  for (const item of pending) {
+    const kind = item.split(' ')[0] ?? '?'
+    byKind.set(kind, (byKind.get(kind) ?? 0) + 1)
+  }
+  console.log(`尚未生成（需要生成器）：${[...byKind].map(([k, v]) => `${k} ${String(v)} 个`).join('，')}`)
+}
+console.log(`\n打包完成：${String(totalLevels)} 张地图，PNG 合计 ${(totalPngBytes / 1048576).toFixed(1)} MB，输出 ${outDir}`)
diff --git a/scripts/png.ts b/scripts/png.ts
new file mode 100644
index 0000000..2a124a3
--- /dev/null
+++ b/scripts/png.ts
@@ -0,0 +1,172 @@
+/**
+ * Indexed-colour PNG writer for the offline asset packs.
+ *
+ * Diablo II's art is palette-indexed, so PNG's indexed colour type is the right
+ * target rather than RGBA: the browser decodes it natively, the file is roughly
+ * a quarter of the size, and the palette travels in the same file. Index 0 is
+ * made transparent through `tRNS`, which is how the decoders already mark
+ * "no pixel".
+ *
+ * Only what the packer needs is implemented — no interlacing, no 16-bit, no
+ * colour types other than 3 — because a half-implemented encoder that silently
+ * produces a file another tool misreads is worse than a small one.
+ *
+ * Node's `zlib` does the deflate; everything else is written here.
+ */
+import { deflateSync } from 'node:zlib'
+
+/** PNG's 8-byte signature. */
+const SIGNATURE = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])
+
+/** CRC-32 table, built once. */
+const CRC_TABLE: Uint32Array = (() => {
+  const table = new Uint32Array(256)
+  for (let n = 0; n < 256; n += 1) {
+    let c = n
+    for (let k = 0; k < 8; k += 1) c = (c & 1) !== 0 ? (0xedb88320 ^ (c >>> 1)) >>> 0 : c >>> 1
+    table[n] = c >>> 0
+  }
+  return table
+})()
+
+/**
+ * CRC-32 of a byte range, as PNG chunks require.
+ *
+ * @param bytes - the bytes.
+ * @returns the checksum.
+ */
+function crc32(bytes: Uint8Array): number {
+  let c = 0xffffffff
+  for (const byte of bytes) c = (CRC_TABLE[(c ^ byte) & 0xff]! ^ (c >>> 8)) >>> 0
+  return (c ^ 0xffffffff) >>> 0
+}
+
+/**
+ * One PNG chunk: length, type, payload, CRC.
+ *
+ * @param type - four-character chunk type.
+ * @param payload - chunk body.
+ * @returns the serialised chunk.
+ */
+function chunk(type: string, payload: Uint8Array): Uint8Array {
+  const out = new Uint8Array(12 + payload.byteLength)
+  const view = new DataView(out.buffer)
+  view.setUint32(0, payload.byteLength)
+  for (let i = 0; i < 4; i += 1) out[4 + i] = type.charCodeAt(i)
+  out.set(payload, 8)
+  view.setUint32(8 + payload.byteLength, crc32(out.subarray(4, 8 + payload.byteLength)))
+  return out
+}
+
+/** An indexed image ready to encode. */
+export interface IndexedImage {
+  /** Width in pixels. */
+  readonly width: number
+  /** Height in pixels. */
+  readonly height: number
+  /** Palette indices, row-major, `width * height` bytes. */
+  readonly pixels: Uint8Array
+  /** Palette as 768 RGB bytes. */
+  readonly palette: Uint8Array
+  /** Index treated as fully transparent, if any (usually 0). */
+  readonly transparentIndex?: number | undefined
+}
+
+/**
+ * Apply a PNG row filter in place into a destination buffer.
+ *
+ * @param type - filter type (0 none, 1 sub, 2 up).
+ * @param row - the row's bytes.
+ * @param previous - the row above, or null for the first row.
+ * @param stride - bytes per pixel (1 for indexed).
+ * @param out - destination, `row.byteLength` bytes.
+ */
+function filterRow(type: number, row: Uint8Array, previous: Uint8Array | null, stride: number, out: Uint8Array): void {
+  for (let i = 0; i < row.byteLength; i += 1) {
+    const raw = row[i]!
+    const left = i >= stride ? row[i - stride]! : 0
+    const up = previous === null ? 0 : previous[i]!
+    const value = type === 0 ? raw : type === 1 ? raw - left : raw - up
+    out[i] = value & 0xff
+  }
+}
+
+/**
+ * Sum of absolute differences after treating bytes as signed, the standard
+ * filter-choice heuristic: the filter that leaves the flattest rows compresses
+ * best.
+ *
+ * @param bytes - filtered row.
+ * @returns the score.
+ */
+function score(bytes: Uint8Array): number {
+  let total = 0
+  for (const byte of bytes) total += byte < 128 ? byte : 256 - byte
+  return total
+}
+
+/**
+ * Encode an indexed image as a PNG.
+ *
+ * Each row picks its own filter (none / sub / up) by the usual minimum-sum-of-
+ * absolute-differences rule. For tile art — large flat regions with sharp edges
+ * — that is worth a solid fraction of the file size over "no filter everywhere",
+ * and it costs one pass over the data.
+ *
+ * @param image - the image.
+ * @returns the PNG bytes.
+ */
+export function encodeIndexedPng(image: IndexedImage): Uint8Array {
+  const { width, height, pixels, palette } = image
+  if (pixels.byteLength !== width * height) {
+    throw new Error(`pixel buffer is ${String(pixels.byteLength)} bytes for ${String(width)}x${String(height)}`)
+  }
+  if (palette.byteLength % 3 !== 0 || palette.byteLength === 0 || palette.byteLength > 768) {
+    throw new Error(`palette must be 3..768 bytes of RGB triples, got ${String(palette.byteLength)}`)
+  }
+
+  const ihdr = new Uint8Array(13)
+  const ihdrView = new DataView(ihdr.buffer)
+  ihdrView.setUint32(0, width)
+  ihdrView.setUint32(4, height)
+  ihdr[8] = 8 // bit depth
+  ihdr[9] = 3 // colour type: indexed
+  ihdr[10] = 0 // deflate
+  ihdr[11] = 0 // adaptive filtering
+  ihdr[12] = 0 // no interlace
+
+  const plte = Uint8Array.from(palette)
+  const trns = new Uint8Array((image.transparentIndex ?? 0) + 1)
+  trns.fill(255)
+  if (image.transparentIndex !== undefined) trns[image.transparentIndex] = 0
+
+  const stride = 1
+  const raw = new Uint8Array((width * stride + 1) * height)
+  const candidate = new Uint8Array(width)
+  let at = 0
+  for (let y = 0; y < height; y += 1) {
+    const row = pixels.subarray(y * width, (y + 1) * width)
+    const previous = y === 0 ? null : pixels.subarray((y - 1) * width, y * width)
+    let bestType = 0
+    let bestScore = Number.POSITIVE_INFINITY
+    for (const type of [0, 1, 2]) {
+      filterRow(type, row, previous, stride, candidate)
+      const value = score(candidate)
+      if (value < bestScore) { bestScore = value; bestType = type }
+    }
+    filterRow(bestType, row, previous, stride, candidate)
+    raw[at] = bestType
+    raw.set(candidate, at + 1)
+    at += width + 1
+  }
+
+  const idat = new Uint8Array(deflateSync(raw, { level: 9 }))
+  const parts = [SIGNATURE, chunk('IHDR', ihdr), chunk('PLTE', plte)]
+  if (image.transparentIndex !== undefined) parts.push(chunk('tRNS', trns))
+  parts.push(chunk('IDAT', idat), chunk('IEND', new Uint8Array(0)))
+  const size = parts.reduce((sum, part) => sum + part.byteLength, 0)
+  const out = new Uint8Array(size)
+  let offset = 0
+  for (const part of parts) { out.set(part, offset); offset += part.byteLength }
+  return out
+}
diff --git a/scripts/port-object-lookup.ts b/scripts/port-object-lookup.ts
new file mode 100644
index 0000000..1e1c80b
--- /dev/null
+++ b/scripts/port-object-lookup.ts
@@ -0,0 +1,184 @@
+// port-object-lookup.ts — 把 OpenDiablo2 的"DS1 对象 id → Objects.txt"硬编码表转成本项目的紧凑数据模块
+//
+// 背景（为什么需要它）：DS1 里对象的 `id` **不是** `Objects.txt` 的行号，而是"该 act 的对象表
+// 索引"，这张表硬编码在游戏里。OpenDiablo2 把它整理成了
+// `d2core/d2records/object_lookup_record_data.go`（7,891 行，来源是一份社区整理的表格），
+// 并在 `d2mapstamp/stamp.go` 里用它做查找：
+//
+//     lookup := records.LookupObject(act, object.Type, object.ID)
+//     objectRecord := records.Object.Details[lookup.ObjectsTxtId]
+//
+// 本脚本只做机械转换：读那份 Go 数据表 → 生成 `src/game/object-lookup-data.ts`
+// （每个 act 一串 `id:obj:token:mode` 记录），运行时有解析器。
+//
+//   node scripts/port-object-lookup.ts [--source=samples/od2/object_lookup_record_data.go]
+//
+// 退出码非 0 表示源文件与预期不符（换了版本就必须重新核对，而不是默默接受）。
+
+export {}
+
+import { createHash } from 'node:crypto'
+import { readFileSync, writeFileSync } from 'node:fs'
+
+/** OpenDiablo2 的数据表（已保存在 samples/od2 下，见 samples/od2/MANIFEST.md）。 */
+const SOURCE = process.argv.find(argument => argument.startsWith('--source='))?.slice('--source='.length)
+  ?? 'samples/od2/object_lookup_record_data.go'
+/** 生成物。 */
+const TARGET = 'src/game/object-lookup-data.ts'
+/** 源文件里应有的记录行数；不符就说明源换了版本。 */
+const EXPECTED_ROWS = 7891
+/** 只移植 `ObjectTypeItem`（物体）；`ObjectTypeCharacter` 是怪物/NPC，本项目无怪物。 */
+const WANTED_TYPE = 'Item'
+
+/** 一条解析出来的记录。 */
+interface LookupRow {
+  act: number
+  id: number
+  objectsTxtId: number
+  token: string
+  mode: string
+  direction: number
+  base: string
+}
+
+/**
+ * 从一行 Go 结构体字面量里取一个字符串字段。
+ *
+ * @param line - the source line.
+ * @param name - field name.
+ * @returns the value without quotes, or null when absent.
+ */
+function stringField(line: string, name: string): string | null {
+  const match = new RegExp(`\\b${name}: "([^"]*)"`).exec(line)
+  return match?.[1] ?? null
+}
+
+/**
+ * 从一行 Go 结构体字面量里取一个数字字段。
+ *
+ * @param line - the source line.
+ * @param name - field name.
+ * @returns the value, or null when absent.
+ */
+function numberField(line: string, name: string): number | null {
+  const match = new RegExp(`\\b${name}: (-?\\d+)`).exec(line)
+  return match?.[1] === undefined ? null : Number(match[1])
+}
+
+/**
+ * 解析整个 Go 数据表。
+ *
+ * @param text - file contents.
+ * @returns the rows worth porting, in source order.
+ */
+function parse(text: string): { rows: LookupRow[]; total: number } {
+  const rows: LookupRow[] = []
+  let total = 0
+  for (const line of text.split('\n')) {
+    if (!line.trim().startsWith('{Act:')) continue
+    total += 1
+    const type = /Type: d2enum\.ObjectType(\w+)/.exec(line)?.[1]
+    if (type !== WANTED_TYPE) continue
+    const act = numberField(line, 'Act')
+    const id = numberField(line, 'Id')
+    const objectsTxtId = numberField(line, 'ObjectsTxtId')
+    if (act === null || id === null || objectsTxtId === null) continue
+    rows.push({
+      act,
+      id,
+      objectsTxtId,
+      token: stringField(line, 'Token') ?? '',
+      mode: stringField(line, 'Mode') ?? '',
+      direction: numberField(line, 'Direction') ?? -1,
+      base: stringField(line, 'Base') ?? '',
+    })
+  }
+  return { rows, total }
+}
+
+/**
+ * 把一条记录压成 `id:obj:token:mode` 串，非默认字段追加在后面。
+ *
+ * 编码规则（解析器在 `src/game/object-lookup.ts`）：
+ * `id:obj:token:mode[:d⟨direction⟩][:m]`，其中 `m` 表示 Base 指向 Monsters 而不是 Objects。
+ *
+ * @param row - the record.
+ * @returns the packed record.
+ */
+function pack(row: LookupRow): string {
+  const parts = [String(row.id), String(row.objectsTxtId), row.token, row.mode]
+  if (row.direction !== -1) parts.push(`d${String(row.direction)}`)
+  if (/monsters/i.test(row.base)) parts.push('m')
+  return parts.join(':')
+}
+
+/**
+ * 主流程。
+ */
+function main(): void {
+  const text = readFileSync(SOURCE, 'utf8')
+  const sha256 = createHash('sha256').update(text).digest('hex')
+  const { rows, total } = parse(text)
+  if (total !== EXPECTED_ROWS) {
+    throw new Error(`${SOURCE}: parsed ${String(total)} rows, expected ${String(EXPECTED_ROWS)} — the table changed, re-verify before porting`)
+  }
+
+  // 运行时按 (act, ds1Id) 建 Map，所以重复的 id 会互相覆盖；这里就按同样的规则去重，
+  // 让"生成物里的统计量"与"运行时解析出来的记录数"严格相等（实测有 1 条重复）。
+  const byAct = new Map<number, Map<number, string>>()
+  for (const row of rows) {
+    let bucket = byAct.get(row.act)
+    if (bucket === undefined) { bucket = new Map<number, string>(); byAct.set(row.act, bucket) }
+    bucket.set(row.id, pack(row))
+  }
+  const deduped = [...byAct.values()].reduce((sum, bucket) => sum + bucket.size, 0)
+  // 有 token 才有美术：token 空的行是不可见/占位 id，Objects.txt 行号有没有都不影响这一条。
+  const unique: LookupRow[] = []
+  for (const bucket of byAct.values()) {
+    for (const packedRecord of bucket.values()) {
+      const found = rows.find(row => pack(row) === packedRecord)
+      if (found !== undefined) unique.push(found)
+    }
+  }
+  const withArt = unique.filter(row => row.token !== '').length
+  const artless = unique.length - withArt
+  const withRow = unique.filter(row => row.objectsTxtId >= 0).length
+
+  const lines: string[] = []
+  lines.push('// object-lookup-data.ts — 由 scripts/port-object-lookup.ts 生成，请勿手改。')
+  lines.push('//')
+  lines.push('// 数据来源：OpenDiablo2，d2core/d2records/object_lookup_record_data.go')
+  lines.push(`//   sha256 ${sha256}`)
+  lines.push(`//   共 ${String(total)} 行，其中 ObjectTypeItem ${String(rows.length)} 行、去重后 ${String(deduped)} 条`)
+  lines.push('//   （怪物/NPC 行未移植：本项目没有怪物）')
+  lines.push('//')
+  lines.push('// 含义：DS1 里 `(act, type=Object, id)` → `Objects.txt` 行号 + 引擎用的 token/mode。')
+  lines.push('// DS1 的 id 是"该 act 的对象表索引"，不是 Objects.txt 的行号，这张表就是那层映射。')
+  lines.push('//')
+  lines.push('// 编码：`<ds1Id>:<objectsTxtId>:<token>:<mode>[:d<direction>][:m]`，多条用 `;` 连接；')
+  lines.push('// `objectsTxtId` 为 -1 表示该 id 在 Objects.txt 里没有行（不可见/占位对象）；')
+  lines.push('// `m` 表示 Base 指向 /Data/Global/Monsters 而不是 /Data/Global/Objects。')
+  lines.push('')
+  lines.push('/** 每个 act 的物体查找表，值是打包后的记录串。 */')
+  lines.push('export const OBJECT_LOOKUP_ROWS: Readonly<Record<number, string>> = {')
+  for (const [act, bucket] of [...byAct].sort((left, right) => left[0] - right[0])) {
+    lines.push(`  ${String(act)}: '${[...bucket.values()].join(';')}',`)
+  }
+  lines.push('}')
+  lines.push('')
+  lines.push('/** 表里带 token（= 有美术可查）的记录数。 */')
+  lines.push(`export const OBJECT_LOOKUP_WITH_ART = ${String(withArt)}`)
+  lines.push('')
+  lines.push('/** 表里 token 为空的记录数：这些是不可见/占位对象，画不出来是对的。 */')
+  lines.push(`export const OBJECT_LOOKUP_WITHOUT_ART = ${String(artless)}`)
+  lines.push('')
+  lines.push('/** 表里能对到 `Objects.txt` 行的记录数（其余只有 token/mode，没有名称与尺寸等元数据）。 */')
+  lines.push(`export const OBJECT_LOOKUP_WITH_ROW = ${String(withRow)}`)
+  lines.push('')
+
+  writeFileSync(TARGET, lines.join('\n'))
+  console.log(`${TARGET}: ${String(rows.length)} 行原始记录 → 去重后 ${String(deduped)} 条（有 token ${String(withArt)}，无 token ${String(artless)}，有 Objects.txt 行 ${String(withRow)}）`)
+  console.log(`acts: ${[...byAct.keys()].sort((a, b) => a - b).join(', ')}`)
+}
+
+main()
diff --git a/scripts/verify-acts.ts b/scripts/verify-acts.ts
new file mode 100644
index 0000000..0ddf746
--- /dev/null
+++ b/scripts/verify-acts.ts
@@ -0,0 +1,121 @@
+/**
+ * Resolve and build all five act towns from the real archives.
+ *
+ * This runs the exact data chain the browser page uses — mount, tables, DS1,
+ * DT1, palette, isometric scene — and reports numbers instead of impressions:
+ * which DS1 quadrants each town has, whether every tile reference resolved,
+ * how much of the map is walkable, and whether a spawn point exists. It is the
+ * check that says the geometry is self-consistent before anything is drawn.
+ *
+ * Usage:
+ *   node scripts/verify-acts.ts [directory]
+ */
+import { MountedArchives } from '../src/mpq/mount.ts'
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { fileSource } from '../src/mpq/file-source.ts'
+import { loadActTables, loadActTown } from '../src/game/acts.ts'
+import { levelSeed, buildIsoMapScene, findIsoSpawn, isBlockedAt } from '../src/game/d2map.ts'
+import { SUB_TILES_PER_TILE } from '../src/game/map.ts'
+
+const dir = process.argv[2] ?? 'samples/d2'
+/** Mount order: later archives override earlier ones, exactly as the game loads them. */
+const MOUNTS = ['d2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq']
+const CHARACTER_ARCHIVE = 'd2char.mpq'
+
+let checks = 0
+let failures = 0
+
+/**
+ * Assert one expectation.
+ *
+ * @param ok - whether it held.
+ * @param message - what was checked.
+ */
+function check(ok: boolean, message: string): void {
+  checks += 1
+  if (!ok) failures += 1
+  console.log(`   ${ok ? 'ok  ' : 'FAIL'} ${message}`)
+}
+
+const archives = new MountedArchives()
+for (const name of [...MOUNTS, CHARACTER_ARCHIVE]) {
+  try {
+    archives.add(name, await MpqArchive.open(await fileSource(`${dir}/${name}`)))
+  } catch (err) {
+    console.log(`skip ${name}: ${String(err)}`)
+  }
+}
+if (archives.size === 0) {
+  console.log(`no archives found in ${dir}`)
+  process.exit(2)
+}
+console.log(`== mounted ${String(archives.size)} archives ==`)
+for (const line of archives.describe()) console.log(`   ${line}`)
+
+const tables = await loadActTables(archives)
+console.log(`\n== tables ==`)
+console.log(`   levels.txt   ${String(tables.levels.rows.length)} rows, ${String(tables.levels.header.length)} columns`)
+console.log(`   lvltypes.txt ${String(tables.lvltypes.rows.length)} rows`)
+console.log(`   lvlprest.txt ${String(tables.lvlprest.rows.length)} rows`)
+
+for (let act = 1; act <= 5; act += 1) {
+  console.log(`\n-- Act ${String(act)}`)
+  const loaded = await loadActTown(archives, tables, act)
+  const { town } = loaded
+  console.log(`   level    ${town.levelName} (Id ${String(town.levelId)}, ${String(town.sizeX)}x${String(town.sizeY)} cells, level type "${town.levelTypeName}")`)
+  console.log(`   palette  ${town.paletteName} (${String(loaded.palette.rgb.length / 3)} colours, ${String(loaded.palette.lightLevels.length)} light tables)`)
+  console.log(`   ds1      ${town.ds1Names.map(name => name.split('\\').pop()).join(', ')}`)
+  console.log(`   dt1      ${String(town.dt1Names.length)} libraries, mask 0x${town.dt1Mask.toString(16)}`)
+  check(town.ds1Names.length > 0, `Act ${String(act)}: has at least one DS1`)
+  check(town.dt1Names.length > 0, `Act ${String(act)}: has at least one DT1 library`)
+  check(loaded.levels.every(level => level.version >= 8), `Act ${String(act)}: DS1 versions carry the act field`)
+
+  let scene = null as ReturnType<typeof buildIsoMapScene> | null
+  let quadrant = ''
+  for (const level of loaded.levels) {
+    // The largest quadrant is the one the page opens; smaller ones are corridors.
+    const built = buildIsoMapScene(level, loaded.libraries)
+    if (scene === null || built.frames.length > scene.frames.length) {
+      scene = built
+      quadrant = `${String(level.width)}x${String(level.height)}`
+    }
+  }
+  if (scene === null) { check(false, `Act ${String(act)}: built a scene`); continue }
+
+  let blocked = 0
+  for (const value of scene.blocked) if (value === 1) blocked += 1
+  const walkable = 1 - blocked / scene.blocked.length
+  const spawn = findIsoSpawn(scene)
+  console.log(`   scene    ${String(scene.widthPx)}x${String(scene.heightPx)} px, ${String(scene.floors.length)} floors, ${String(scene.walls.length)} walls, ${String(scene.frames.length)} distinct frames`)
+  console.log(`   collision ${String(scene.gridWidth)}x${String(scene.gridHeight)} sub-tiles, walkable ${(walkable * 100).toFixed(1)}%`)
+  console.log(`   warnings missing=${String(scene.missingTiles)} clipped=${String(scene.clippedTiles)} duplicate-refs=${String(scene.duplicateRefs)}`)
+  // A handful of unresolved references is a quirk of the shipped DS1 data (the
+  // game draws nothing there); a broken chain produces hundreds, so the bound is
+  // tight in relative terms and the offenders are always printed.
+  const references = scene.floors.length + scene.walls.length + scene.missingTiles
+  const missingShare = scene.missingTiles / Math.max(1, references)
+  check(
+    missingShare <= 0.002,
+    `Act ${String(act)}: ${String(scene.missingTiles)}/${String(references)} references unresolved (${(missingShare * 100).toFixed(2)}%)`,
+  )
+  for (const ref of scene.missingRefs.slice(0, 3)) console.log(`   note     unresolved: ${ref}`)
+  // A town is mostly open ground; Act 4's fortress courtyard is 92% walkable, so
+  // the bound only rejects maps that are entirely one or the other.
+  check(walkable > 0.1 && walkable < 0.99, `Act ${String(act)}: walkable share ${(walkable * 100).toFixed(1)}% is a map, not a wall`)
+  check(spawn !== null, `Act ${String(act)}: a walkable spawn exists`)
+  if (spawn !== null) {
+    check(!isBlockedAt(scene, spawn.x, spawn.y), `Act ${String(act)}: spawn is on a walkable sub-tile`)
+    // Walk a short straight line and confirm the collision grid answers.
+    let reached = 0
+    for (let step = 0; step < 40; step += 1) {
+      if (!isBlockedAt(scene, spawn.x + step * 4, spawn.y)) reached += 1
+    }
+    console.log(`   probe     ${String(reached)}/40 four-pixel steps east of spawn are walkable`)
+  }
+  check(scene.frames.length > 0, `Act ${String(act)}: scene references at least one frame`)
+  console.log(`   note     ${String(scene.clippedTiles)} tiles needed a bitmap taller than their declared height`)
+  void SUB_TILES_PER_TILE
+}
+
+console.log(`\n${String(checks - failures)}/${String(checks)} checks passed`)
+if (failures > 0) process.exit(1)
diff --git a/scripts/verify-archive.ts b/scripts/verify-archive.ts
new file mode 100644
index 0000000..0a5649e
--- /dev/null
+++ b/scripts/verify-archive.ts
@@ -0,0 +1,99 @@
+/**
+ * Full-archive verification: decode every named member and check the magic
+ * bytes of the formats whose signature is known.
+ *
+ * A decode that merely returns without throwing proves little, so the checks
+ * below assert real structure (RIFF headers, PCX manufacturer bytes, CEL frame
+ * counts, palette sizes). Run:
+ *   node scripts/verify-archive.ts <archive> [--write <dir>]
+ */
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { fileSource } from '../src/mpq/file-source.ts'
+
+const [path, ...flags] = process.argv.slice(2)
+if (path === undefined) {
+  console.error('usage: node scripts/verify-archive.ts <archive> [--write <dir>]')
+  process.exit(2)
+}
+const writeIndex = flags.indexOf('--write')
+const outDir = writeIndex === -1 ? undefined : flags[writeIndex + 1]
+
+const archive = await MpqArchive.open(await fileSource(path))
+const names = await archive.listFiles()
+const byExt = new Map<string, number>()
+let decoded = 0
+let sizeMismatch = 0
+const failures: string[] = []
+const magicFails: string[] = []
+
+const ext = (name: string): string => {
+  const cut = name.lastIndexOf('.')
+  return cut === -1 ? '(none)' : name.slice(cut).toLowerCase()
+}
+
+/** Check a decoded member against its format's signature. */
+function checkMagic(name: string, data: Uint8Array): void {
+  const ascii = (at: number, length: number): string =>
+    String.fromCharCode(...data.subarray(at, at + length))
+  switch (ext(name)) {
+    case '.wav':
+      if (data.byteLength < 12 || ascii(0, 4) !== 'RIFF' || ascii(8, 4) !== 'WAVE') {
+        magicFails.push(`${name}: not RIFF/WAVE`)
+      }
+      break
+    case '.pcx':
+      if (data.byteLength < 4 || data[0] !== 0x0a || data[2] !== 1) {
+        magicFails.push(`${name}: not a PCX (enc=${String(data[2])})`)
+      }
+      break
+    case '.cel': {
+      const view = new DataView(data.buffer, data.byteOffset, Math.min(4, data.byteLength))
+      const frames = view.getUint32(0, true)
+      if (data.byteLength < 8 || frames === 0 || frames > 512) {
+        magicFails.push(`${name}: implausible CEL frame count ${String(frames)}`)
+      }
+      break
+    }
+    case '.trn':
+      if (data.byteLength !== 256) magicFails.push(`${name}: .trn is ${String(data.byteLength)} bytes, expected 256`)
+      break
+    default:
+      break
+  }
+}
+
+for (const name of names) {
+  byExt.set(ext(name), (byExt.get(ext(name)) ?? 0) + 1)
+  const file = archive.find(name)
+  if (file === undefined) { failures.push(`${name}: hash lookup failed`); continue }
+  try {
+    const data = await archive.read(file)
+    if (data.byteLength !== file.fileSize) {
+      sizeMismatch += 1
+      failures.push(`${name}: ${String(data.byteLength)} != ${String(file.fileSize)}`)
+      continue
+    }
+    checkMagic(name, data)
+    decoded += 1
+    if (outDir !== undefined) {
+      const target = join(outDir, name.replace(/\\/g, '/'))
+      await mkdir(join(target, '..'), { recursive: true })
+      await writeFile(target, data)
+    }
+  } catch (error) {
+    failures.push(`${name}: ${(error as Error).message}`)
+  }
+}
+
+console.log(`archive   ${path}`)
+console.log(`named     ${String(names.length)}`)
+console.log(`decoded   ${String(decoded)}`)
+console.log(`mismatch  ${String(sizeMismatch)}`)
+console.log(`failures  ${String(failures.length)}`)
+console.log(`magic     ${magicFails.length === 0 ? 'all known signatures OK' : `${String(magicFails.length)} bad`}`)
+for (const line of magicFails.slice(0, 10)) console.log(`  ! ${line}`)
+for (const line of failures.slice(0, 10)) console.log(`  - ${line}`)
+const exts = [...byExt].sort((a, b) => b[1] - a[1]).slice(0, 12)
+console.log(`by ext    ${exts.map(([e, n]) => `${e}:${String(n)}`).join('  ')}`)
diff --git a/scripts/verify-combat.ts b/scripts/verify-combat.ts
new file mode 100644
index 0000000..8908115
--- /dev/null
+++ b/scripts/verify-combat.ts
@@ -0,0 +1,239 @@
+/**
+ * M2 combat checks: the simulation, headless.
+ *
+ * The combat model is written to be driven one tick at a time from a small input
+ * record precisely so it can be tested like this — without a canvas, without
+ * input events, and without a map. Each check below states a behaviour the
+ * sandbox must have (aggro, reach, cooldowns, resource costs, experience,
+ * death and respawn) and asserts it against a simulated run, so a regression
+ * shows up as a failing number rather than as something subtly wrong on screen.
+ *
+ * Usage: node scripts/verify-combat.ts
+ */
+import {
+  createWorld, experienceTable, monsterStatsFromRow, monsterStatsFromTable,
+  spawnMonsters, tickCombat,
+} from '../src/game/combat.ts'
+import type { CombatOptions, CombatWorld, MonsterStats } from '../src/game/combat.ts'
+import { parseTable, numberCell, findRow } from '../src/game/tables.ts'
+
+const problems: string[] = []
+let checks = 0
+
+/**
+ * Assert one condition.
+ *
+ * @param condition - the condition to hold.
+ * @param description - what it means.
+ */
+function expect(condition: boolean, description: string): void {
+  checks += 1
+  if (!condition) problems.push(description)
+}
+
+/** A table shaped like the real `MonStats.txt`, including its rough edges. */
+const MONSTATS_TEXT = [
+  'Id\tName\tHP\tDamage\tCooldownTicks\tReach\tAggroRadius\tSpeed\tXP',
+  'fallen\tFallen\t12\t3\t24\t36\t200\t80\t8',
+  'zombie\tZombie\t30\t6\t32\t40\t160\t50\t15\t\t',
+  'skeleton\tSkeleton\t18\t4\t28\t38\t240\t70\t12',
+  'empty\tSmall Rat\t\t2\t\t\t\t\t4',      // missing cells: defaults must apply
+  'nulled\tNull Beast\t(null)\t5\t30\t40\t180\t60\t9',
+].join('\r\n')
+
+const options: CombatOptions = {
+  playerSpeed: 200,
+  playerReach: 48,
+  playerCooldownTicks: 25,
+  playerDamage: 6,
+  playerManaPerAttack: 2,
+  respawnTicks: 50,
+}
+
+/** Flat ground: nothing is ever overlapped. */
+const openTerrain = { overlap: () => 0 }
+
+// --- tables -----------------------------------------------------------------
+
+const monstats = parseTable(MONSTATS_TEXT)
+expect(monstats.columns[0] === 'Id', 'header columns are read in order')
+expect(monstats.rows.length === 5, 'every non-empty line becomes a record')
+expect(monstats.rows[2]?.Id === 'skeleton', 'records are keyed by column name')
+expect(monstats.rows[3]?.HP === undefined, 'an empty cell is absent, not empty-string')
+expect(monstats.rows[4]?.HP === undefined, 'the (null) marker means absent')
+expect(numberCell(monstats.rows[3] ?? {}, 'HP', 20) === 20, 'a missing numeric cell falls back to the default')
+expect(findRow(monstats, 'Id', 'ZOMBIE')?.Name === 'Zombie', 'row lookup is case-insensitive')
+
+const stats = monsterStatsFromTable(monstats)
+expect(stats.length === 5, 'every record becomes a definition')
+expect(stats[3]?.hp === 20, 'a definition with no HP column uses the default')
+expect(stats[4]?.hp === 20, 'a definition with a null HP uses the default')
+expect(stats[0]?.name === 'Fallen' && stats[0]?.xp === 8, 'names and experience come from the table')
+
+const xpTable = experienceTable(parseTable([
+  'Level\tXP',
+  '1\t0',
+  '2\t500',
+  '3\t1500',
+  '4\t400',
+].join('\n')))
+expect(xpTable[2] === 500 && xpTable[3] === 1500, 'experience thresholds are read per level')
+expect(xpTable[4] === 1500, 'a non-monotonic table is clamped upward')
+
+// --- spawning ---------------------------------------------------------------
+
+const world: CombatWorld = createWorld(0, 0)
+const blockedHalf = { overlap: (x: number) => (x < 0 ? 1 : 0) }
+const placed = spawnMonsters(world, stats, 6, { x: 0, y: 0 }, 200, blockedHalf)
+expect(placed === 6 && world.monsters.length === 6, 'spawns fill up to the requested count')
+expect(world.monsters.every(monster => monster.x >= 0), 'no monster is dropped into blocked ground')
+const deterministic: CombatWorld = createWorld(0, 0)
+spawnMonsters(deterministic, stats, 6, { x: 0, y: 0 }, 200, blockedHalf)
+expect(
+  JSON.stringify(world.monsters.map(monster => [Math.round(monster.x), Math.round(monster.y)]))
+  === JSON.stringify(deterministic.monsters.map(monster => [Math.round(monster.x), Math.round(monster.y)])),
+  'spawn positions are reproducible',
+)
+
+// --- aggro, chase, reach ----------------------------------------------------
+
+const idleWorld = createWorld(1000, 1000)
+const idleStats: MonsterStats = { ...stats[0]!, aggroRadius: 100, speed: 100, reach: 30 }
+idleWorld.monsters.push({
+  index: 0, stats: idleStats, x: 0, y: 0, hp: idleStats.hp, cooldown: 0,
+  state: 'idle', facing: 0, hitFlash: 0, corpseTicks: 0,
+})
+tickCombat(idleWorld, { movement: { x: 0, y: 0 }, attack: false }, options, openTerrain, xpTable)
+expect(idleWorld.monsters[0]?.state === 'idle', 'a monster outside its aggro radius stays idle')
+
+// Inside the monster's aggro radius: a monster that never notices the player is
+// tested by the idle case above, so this one must be within range to chase.
+const chaseWorld = createWorld(80, 0)
+chaseWorld.monsters.push({
+  index: 0, stats: idleStats, x: 0, y: 0, hp: idleStats.hp, cooldown: 0,
+  state: 'idle', facing: 0, hitFlash: 0, corpseTicks: 0,
+})
+const startDistance = Math.hypot(80, 0)
+for (let i = 0; i < 10; i += 1) tickCombat(chaseWorld, { movement: { x: 0, y: 0 }, attack: false }, options, openTerrain, xpTable)
+const chaseDistance = Math.hypot(chaseWorld.monsters[0]!.x - 80, chaseWorld.monsters[0]!.y)
+expect(chaseWorld.monsters[0]?.state === 'chase' || chaseWorld.monsters[0]?.state === 'attack', 'a monster inside aggro closes in')
+expect(chaseDistance < startDistance, 'closing in actually reduces the distance')
+
+const reachWorld = createWorld(20, 0)
+reachWorld.monsters.push({
+  index: 0, stats: idleStats, x: 0, y: 0, hp: 1000, cooldown: 0,
+  state: 'idle', facing: 0, hitFlash: 0, corpseTicks: 0,
+})
+const hpBefore = reachWorld.player.hp
+for (let i = 0; i < 100; i += 1) tickCombat(reachWorld, { movement: { x: 0, y: 0 }, attack: false }, options, openTerrain, xpTable)
+const taken = hpBefore - reachWorld.player.hp
+// Attacks land on ticks 1, 25, 49, 73 and 97 for a 24-tick cooldown: five hits
+// in a hundred ticks, which is what "respects the cooldown" has to mean.
+expect(taken === 5 * idleStats.damage, `monster damage respects its cooldown (took ${String(taken)}, expected ${String(5 * idleStats.damage)})`)
+expect(reachWorld.monsters[0]?.state === 'attack', 'a monster in reach switches to attacking')
+
+// --- player attack, mana, cooldowns -----------------------------------------
+
+const attackWorld = createWorld(20, 0)
+attackWorld.monsters.push({
+  index: 0, stats: { ...idleStats, hp: 100, xp: 40 }, x: 0, y: 0, hp: 100, cooldown: 999,
+  state: 'idle', facing: 0, hitFlash: 0, corpseTicks: 0,
+})
+const manaBefore = attackWorld.player.mana
+for (let i = 0; i < 100; i += 1) tickCombat(attackWorld, { movement: { x: 0, y: 0 }, attack: true }, options, openTerrain, xpTable)
+const monsterDamage = 100 - (attackWorld.monsters[0]?.hp ?? 0)
+expect(monsterDamage === 4 * options.playerDamage, `player attacks respect the cooldown (dealt ${String(monsterDamage)})`)
+expect(manaBefore - attackWorld.player.mana === 4 * options.playerManaPerAttack, 'each attack spends its mana')
+
+const noManaWorld = createWorld(20, 0)
+noManaWorld.player.mana = 1
+noManaWorld.monsters.push({
+  index: 0, stats: idleStats, x: 0, y: 0, hp: 100, cooldown: 999,
+  state: 'idle', facing: 0, hitFlash: 0, corpseTicks: 0,
+})
+tickCombat(noManaWorld, { movement: { x: 0, y: 0 }, attack: true }, options, openTerrain, xpTable)
+expect(noManaWorld.events.some(event => event.kind === 'noMana'), 'an unaffordable attack reports no-mana instead of landing')
+expect(noManaWorld.monsters[0]?.hp === 100, 'an unaffordable attack deals no damage')
+
+const whiffWorld = createWorld(0, 0)
+for (let i = 0; i < 3; i += 1) tickCombat(whiffWorld, { movement: { x: 0, y: 0 }, attack: true }, options, openTerrain, xpTable)
+expect(whiffWorld.player.cooldown >= 0, 'attacking with nothing in reach is legal and still costs the cooldown')
+
+// --- kill, experience, level up ---------------------------------------------
+
+const killWorld = createWorld(20, 0)
+const killStats: MonsterStats = { ...idleStats, hp: 12, xp: 600, cooldownTicks: 999 }
+killWorld.monsters.push({
+  index: 0, stats: killStats, x: 0, y: 0, hp: 12, cooldown: 999,
+  state: 'idle', facing: 0, hitFlash: 0, corpseTicks: 0,
+})
+let sawKill = false
+let sawLevelUp = false
+for (let i = 0; i < 60; i += 1) {
+  tickCombat(killWorld, { movement: { x: 0, y: 0 }, attack: true }, options, openTerrain, xpTable)
+  if (killWorld.events.some(event => event.kind === 'kill')) sawKill = true
+  if (killWorld.events.some(event => event.kind === 'levelUp')) sawLevelUp = true
+}
+expect(sawKill, 'killing a monster emits a kill event')
+expect(killWorld.kills === 1, 'the kill is counted')
+expect(killWorld.monsters[0]?.state === 'dead', 'the monster is left dead, not removed mid-frame')
+expect(killWorld.player.xp === 600, 'experience is awarded from the monster table')
+expect(sawLevelUp && killWorld.player.level === 2, 'crossing the table threshold levels the player up')
+expect(killWorld.player.maxHp > 60 && killWorld.player.hp === killWorld.player.maxHp, 'a level up raises and refills resources')
+
+// --- death and respawn ------------------------------------------------------
+
+const deathWorld = createWorld(20, 0)
+deathWorld.player.hp = 5
+deathWorld.monsters.push({
+  index: 0, stats: { ...idleStats, damage: 50, reach: 60 }, x: 0, y: 0, hp: 100, cooldown: 0,
+  state: 'idle', facing: 0, hitFlash: 0, corpseTicks: 0,
+})
+tickCombat(deathWorld, { movement: { x: 0, y: 0 }, attack: false }, options, openTerrain, xpTable)
+expect(!deathWorld.player.alive, 'lethal damage kills the player')
+expect(deathWorld.player.respawnIn === options.respawnTicks, 'death starts the respawn timer')
+for (let i = 0; i < options.respawnTicks + 2; i += 1) {
+  tickCombat(deathWorld, { movement: { x: 0, y: 0 }, attack: false }, options, openTerrain, xpTable)
+}
+expect(deathWorld.player.alive, 'the player comes back after the respawn delay')
+expect(deathWorld.player.hp === deathWorld.player.maxHp, 'respawn restores health')
+expect(deathWorld.player.mana === deathWorld.player.maxMana, 'respawn restores mana')
+
+// --- determinism ------------------------------------------------------------
+
+/**
+ * Digest a world's observable state.
+ *
+ * @param target - the world.
+ * @returns a string digest.
+ */
+function digest(target: CombatWorld): string {
+  return JSON.stringify([
+    target.tick, target.kills, target.player.hp, target.player.xp,
+    target.monsters.map(monster => [Math.round(monster.x * 100), Math.round(monster.y * 100), monster.hp, monster.state]),
+  ])
+}
+
+/**
+ * Run a fixed scenario for a number of ticks.
+ *
+ * @param ticks - how many ticks to run.
+ * @returns the world digest.
+ */
+function runScenario(ticks: number): string {
+  const scenario = createWorld(0, 0)
+  spawnMonsters(scenario, stats, 4, { x: 120, y: 0 }, 120, openTerrain)
+  for (let i = 0; i < ticks; i += 1) {
+    const movement = i % 40 < 20 ? { x: 1, y: 0 } : { x: 0, y: 1 }
+    const attack = i % 7 === 0
+    tickCombat(scenario, { movement, attack }, options, openTerrain, xpTable)
+  }
+  return digest(scenario)
+}
+expect(runScenario(300) === runScenario(300), 'the same inputs and seed produce the same simulation')
+
+console.log(`checks     ${String(checks)}`)
+console.log(`problems   ${String(problems.length)}`)
+for (const problem of problems.slice(0, 12)) console.log(`  - ${problem}`)
+console.log(problems.length === 0 ? 'RESULT     combat behaviours hold' : 'RESULT     FAILED')
+process.exit(problems.length === 0 ? 0 : 1)
diff --git a/scripts/verify-d2-data.ts b/scripts/verify-d2-data.ts
new file mode 100644
index 0000000..525c893
--- /dev/null
+++ b/scripts/verify-d2-data.ts
@@ -0,0 +1,138 @@
+/**
+ * Validate the real Diablo II archives dropped into `samples/d2/`.
+ *
+ * User-supplied game data lives outside version control (`samples/` is
+ * ignored), so this script is the only durable record of what is actually on
+ * disk. It opens every archive with the project's own reader — the point is to
+ * prove this decoder copes with real Blizzard containers, not to trust a
+ * third-party tool's opinion.
+ *
+ * Usage:
+ *   node scripts/verify-d2-data.ts [directory]
+ *
+ * Exits non-zero when a hard expectation fails. A readable `(listfile)` is NOT
+ * one of them: Diablo II 1.13 archives compress it with PKWARE implode
+ * (`mask 0x8`), which `src/mpq/decompress.ts` does not implement yet, so the
+ * failure is reported as a known gap with the exact mask.
+ */
+import { createHash } from 'node:crypto'
+import { createReadStream } from 'node:fs'
+import { readdir, stat } from 'node:fs/promises'
+import { join, relative } from 'node:path'
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { fileSource } from '../src/mpq/file-source.ts'
+import { compressionMaskName } from '../src/mpq/decompress.ts'
+
+/** Archives the rest of the project expects to find, with why they matter. */
+const REQUIRED = new Map([
+  ['d2data.mpq', 'classic base data: tiles, sprites, palettes'],
+  ['d2exp.mpq', 'expansion data: Act 5, new monsters, expansion tables'],
+  ['d2char.mpq', 'character animations (DCC/COF sources)'],
+  ['patch_d2.mpq', 'the 1.13 data delta the engine actually mounts'],
+])
+
+const root = process.argv[2] ?? 'samples/d2'
+
+/** Every `.mpq` under `root`, recursively, case-insensitively. */
+async function findArchives(dir: string): Promise<string[]> {
+  const out: string[] = []
+  for (const entry of await readdir(dir, { withFileTypes: true })) {
+    const path = join(dir, entry.name)
+    if (entry.isDirectory()) out.push(...(await findArchives(path)))
+    else if (entry.name.toLowerCase().endsWith('.mpq')) out.push(path)
+  }
+  return out.sort()
+}
+
+async function sha256(path: string): Promise<string> {
+  const hash = createHash('sha256')
+  for await (const chunk of createReadStream(path)) hash.update(chunk)
+  return hash.digest('hex')
+}
+
+let failures = 0
+let checks = 0
+const note = (ok: boolean, message: string): void => {
+  checks += 1
+  if (!ok) failures += 1
+  console.log(`   ${ok ? 'ok  ' : 'FAIL'} ${message}`)
+}
+
+let archives: string[]
+try {
+  archives = await findArchives(root)
+} catch (err) {
+  console.error(`cannot read ${root}: ${String(err)}`)
+  process.exit(2)
+}
+
+console.log(`== samples/d2 archives (${String(archives.length)} found) ==`)
+if (archives.length === 0) {
+  console.log('   nothing to check — put the user-supplied MPQs in samples/d2/ first')
+  process.exit(0)
+}
+
+const seen = new Set<string>()
+for (const path of archives) {
+  const name = relative(root, path).replaceAll('\\', '/')
+  const nameLower = name.toLowerCase()
+  const info = await stat(path)
+  const digest = await sha256(path)
+  console.log(`\n-- ${name}`)
+  console.log(`   bytes    ${String(info.size)}`)
+  console.log(`   sha256   ${digest}`)
+  note(/\.mpq$/i.test(name), 'has the .mpq extension')
+
+  let archive: MpqArchive
+  try {
+    archive = await MpqArchive.open(await fileSource(path))
+  } catch (err) {
+    note(false, `opens as an MPQ archive (${String(err)})`)
+    continue
+  }
+
+  const h = archive.header
+  console.log(`   header   v${String(h.formatVersion + 1)} headerSize=${String(h.headerSize)} sectorSize=${String(h.sectorSize)}`)
+  console.log(`   tables   hash @${String(h.hashTableOffset)} (${String(h.hashTableEntries)}), block @${String(h.blockTableOffset)} (${String(h.blockTableEntries)})`)
+  console.log(`   blocks   ${String(archive.files().length)} occupied slots`)
+  console.log(`   flags    ${[...archive.flagHistogram()].map(([k, v]) => `${k}=${String(v)}`).join(', ')}`)
+
+  note(h.formatVersion === 0, 'is an MPQ v1 header (the only format this reader supports)')
+  note((h.hashTableEntries & (h.hashTableEntries - 1)) === 0 && h.hashTableEntries > 0, 'hash table size is a non-zero power of two')
+  note(h.sectorSize === 4096 || h.sectorSize === 512, `sector size ${String(h.sectorSize)} is plausible`)
+  note(
+    h.archiveSize === info.size,
+    h.archiveSize === info.size
+      ? 'header archiveSize matches the file length'
+      : `header archiveSize ${String(h.archiveSize)} != file length ${String(info.size)} (trailing data or a truncated copy)`,
+  )
+  note(archive.files().length > 0, 'at least one occupied block slot')
+
+  if (REQUIRED.has(nameLower)) seen.add(nameLower)
+
+  // Names are the interesting part: does the archive still carry a listfile?
+  try {
+    const names = await archive.listFiles()
+    console.log(`   names    ${String(names.length)} from (listfile)`)
+    const sample = names.filter((n) => /\.(dt1|dcc|dc6|tbl|bin|txt|pal|cel)$/i.test(n)).slice(0, 6)
+    if (sample.length > 0) console.log(`   sample   ${sample.join(', ')}`)
+  } catch (err) {
+    const mask = typeof (err as { mask?: unknown }).mask === 'number' ? (err as { mask: number }).mask : undefined
+    const label = mask === undefined ? 'unknown' : `mask 0x${mask.toString(16)} ${compressionMaskName(mask)}`
+    console.log(`   names    unreadable: ${String(err)}`)
+    console.log(`   known gap: (listfile) needs ${label} — not implemented in src/mpq/decompress.ts`)
+  }
+}
+
+console.log('\n== required data files ==')
+for (const [name, why] of REQUIRED) {
+  const present = seen.has(name)
+  note(present, `${name} present${present ? '' : ` (${why})`}`)
+}
+
+console.log(`\n${String(checks - failures)}/${String(checks)} checks passed`)
+if (failures > 0) {
+  console.log('NOTE: real Diablo II archives are only fully readable once PKWARE implode (mask 0x8) lands;')
+  console.log('      listfile gaps above are informational, not counted as failures.')
+  process.exit(1)
+}
diff --git a/scripts/verify-dc6.ts b/scripts/verify-dc6.ts
new file mode 100644
index 0000000..5e404f9
--- /dev/null
+++ b/scripts/verify-dc6.ts
@@ -0,0 +1,80 @@
+/**
+ * Self-check for the DC6 decoder against the generated fixture.
+ *
+ * This proves the decoder and the encoder agree; it does *not* prove the
+ * format understanding is right. That second claim is what
+ * `scripts/verify-dc6.sh` establishes, by having the independent `dc6png`
+ * decoder read the same fixture and produce the same image.
+ *
+ * Usage: node scripts/verify-dc6.ts <fixture-directory>
+ */
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { decodeDc6 } from '../src/formats/dc6.ts'
+
+interface ExpectedFrame {
+  readonly width: number
+  readonly height: number
+  readonly rows: readonly (readonly number[])[]
+}
+interface Expected {
+  readonly directions: number
+  readonly framesPerDirection: number
+  readonly frames: readonly (readonly ExpectedFrame[])[]
+}
+
+const dir = process.argv[2]
+if (dir === undefined) {
+  console.error('usage: node scripts/verify-dc6.ts <fixture-directory>')
+  process.exit(2)
+}
+
+const expected = JSON.parse(await readFile(join(dir, 'expected.json'), 'utf8')) as Expected
+const sheet = decodeDc6(new Uint8Array(await readFile(join(dir, 'fixture.dc6'))))
+
+const problems: string[] = []
+if (sheet.header.directions !== expected.directions) {
+  problems.push(`directions: ${String(sheet.header.directions)} != ${String(expected.directions)}`)
+}
+if (sheet.header.framesPerDirection !== expected.framesPerDirection) {
+  problems.push(`frames per direction: ${String(sheet.header.framesPerDirection)} != ${String(expected.framesPerDirection)}`)
+}
+if (sheet.header.version !== 6) problems.push(`version: ${String(sheet.header.version)} != 6`)
+
+let frames = 0
+for (let direction = 0; direction < expected.directions; direction += 1) {
+  const group = sheet.groups[direction]
+  if (group === undefined) { problems.push(`direction ${String(direction)} missing`); continue }
+  for (let frameIndex = 0; frameIndex < expected.framesPerDirection; frameIndex += 1) {
+    const want = expected.frames[direction]?.[frameIndex]
+    const got = group.frames[frameIndex]
+    if (want === undefined || got === undefined) { problems.push(`frame ${String(direction)}/${String(frameIndex)} missing`); continue }
+    frames += 1
+    if (got.width !== want.width || got.height !== want.height) {
+      problems.push(`frame ${String(direction)}/${String(frameIndex)} size ${String(got.width)}x${String(got.height)} != ${String(want.width)}x${String(want.height)}`)
+      continue
+    }
+    for (let y = 0; y < want.height; y += 1) {
+      for (let x = 0; x < want.width; x += 1) {
+        const at = y * want.width + x
+        const wantIndex = want.rows[y]?.[x] ?? 0
+        const gotIndex = got.indices[at] ?? 0
+        const wantOpaque = wantIndex === 0 ? 0 : 1
+        if (gotIndex !== wantIndex || (got.mask[at] ?? 0) !== wantOpaque) {
+          problems.push(`frame ${String(direction)}/${String(frameIndex)} px ${String(x)},${String(y)}: index ${String(gotIndex)}/mask ${String(got.mask[at] ?? 0)} != ${String(wantIndex)}/${String(wantOpaque)}`)
+        }
+      }
+    }
+    // Placement fields travel through untouched.
+    if (got.offsetX !== direction * 4 + frameIndex * 22 + 1 || got.offsetY !== -(direction * 4 + frameIndex * 22 + 1)) {
+      problems.push(`frame ${String(direction)}/${String(frameIndex)} anchors ${String(got.offsetX)},${String(got.offsetY)} are wrong`)
+    }
+  }
+}
+
+console.log(`fixture    ${join(dir, 'fixture.dc6')}`)
+console.log(`decoded    ${String(frames)} frames, ${String(sheet.header.directions)} directions x ${String(sheet.header.framesPerDirection)}`)
+console.log(`mismatches ${String(problems.length)}`)
+for (const problem of problems.slice(0, 12)) console.log(`  - ${problem}`)
+console.log(problems.length === 0 ? 'RESULT     decoder matches the encoded grid exactly' : 'RESULT     FAILED')
+process.exit(problems.length === 0 ? 0 : 1)
diff --git a/scripts/verify-dcc.ts b/scripts/verify-dcc.ts
new file mode 100644
index 0000000..902bc96
--- /dev/null
+++ b/scripts/verify-dcc.ts
@@ -0,0 +1,698 @@
+/**
+ * Verify the `.cof` and `.dcc` decoders against the real Diablo II archives.
+ *
+ * The Sorceress is the interesting case because her art is COF+DCC only: a COF
+ * names no sprite files, so the run has to reconstruct the DCC path from the
+ * COF's own name plus each layer record's composite type, then decode every
+ * layer of every direction and frame and confirm it produced opaque pixels. A
+ * decoder that silently returned zeroed frames would pass a "does it throw?"
+ * test and fail this one.
+ *
+ * Object art (barrels, chests, urns, doors) goes through the same path from the
+ * data archive, so a regression that only affects non-character art or
+ * single-direction animations is caught too.
+ *
+ * After the gated checks the script sweeps the whole Sorceress DCC set. That
+ * sweep is what puts a real number on the `bottom-up` frame flag: the decoder
+ * flips those frames vertically, the reference implementation panics on them
+ * instead, and nothing else in this project can tell how often that judgement
+ * call is exercised. Sweep failures are reported with their exact reason but do
+ * not fail the run, because the run's exit code is defined by the walk/stand
+ * members the renderer depends on.
+ *
+ * Nothing here grades its own homework: every assertion is about bytes read out
+ * of a Blizzard archive the user supplied.
+ *
+ * Usage:
+ *   node scripts/verify-dcc.ts [directory] [--quick]
+ *
+ * Exits non-zero when a Sorceress walk/stand member — or an object member —
+ * fails to decode.
+ */
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { fileSource } from '../src/mpq/file-source.ts'
+import { cofLayerOrder, decodeCof } from '../src/formats/cof.ts'
+import type { CofFile } from '../src/formats/cof.ts'
+import { decodeDcc } from '../src/formats/dcc.ts'
+import type { DccFile } from '../src/formats/dcc.ts'
+import { decodePal } from '../src/formats/pal.ts'
+import type { Palette } from '../src/formats/pal.ts'
+import type { SpriteFrame } from '../src/formats/sprite.ts'
+
+/**
+ * Composite type → the archive directory holding that component's art.
+ *
+ * A COF layer record stores only the composite type and a weapon class, so this
+ * is the mapping that turns "layer 6 is a head" into `.../hd/...`. Objects use
+ * the same table: the shipped object COFs declare type 1, whose art lives in the
+ * `tr` directory, exactly as a character torso does.
+ */
+const LAYER_COMPONENT = [
+  'hd',
+  'tr',
+  'lg',
+  'ra',
+  'la',
+  'rh',
+  'lh',
+  'sh',
+  's1',
+  's2',
+  's3',
+  's4',
+  's5',
+  's6',
+  's7',
+  's8',
+]
+
+/** Archive holding the character art, opened first because it gates the run. */
+const CHARACTER_ARCHIVE = 'd2char.mpq'
+/** Archive holding object art, palettes and object COFs. */
+const DATA_ARCHIVE = 'd2data.mpq'
+/** The class COFs this project needs before the Sorceress can be drawn. */
+const CLASS_ANIMATIONS: readonly { readonly label: string; readonly member: string }[] = [
+  { label: 'walk', member: 'data\\global\\chars\\so\\cof\\sowlhth.cof' },
+  { label: 'stand', member: 'data\\global\\chars\\so\\cof\\sonuhth.cof' },
+]
+/** Object members decoded directly, with no COF involved. */
+const OBJECT_DCCS: readonly string[] = [
+  'data\\global\\objects\\c5\\tr\\c5trlitnuhth.dcc',
+  'data\\global\\objects\\l2\\tr\\l2trlitnuhth.dcc',
+]
+/** Object COF decoded to exercise the COF→DCC path outside the character tree. */
+const OBJECT_COFS: readonly { readonly label: string; readonly member: string }[] = [
+  { label: 'object l2 neutral', member: 'data\\global\\objects\\l2\\cof\\l2nuhth.cof' },
+]
+/** Directory whose DCCs the bottom-up sweep covers. */
+const SWEEP_PREFIX = 'data/global/chars/so/'
+/** Sweep cap in `--quick` mode, so the script stays usable in a loop. */
+const QUICK_LIMIT = 150
+/** Cap on individually printed sweep failures. */
+const MAX_REPORTED_SWEEP_FAILURES = 20
+/** Brightness ramp for the text rendering; index 0 is reserved for empty space. */
+const ASCII_RAMP = ' .:-=+*#%@'
+/** Cap on the ASCII rendering's width and height, in characters. */
+const ASCII_COLUMNS = 50
+const ASCII_ROWS = 30
+
+/** What one decoded DCC member contributed, for the running totals. */
+interface MemberStats {
+  readonly member: string
+  readonly directions: number
+  readonly frames: number
+  readonly bottomUp: number
+  readonly minArtWidth: number
+  readonly maxArtWidth: number
+  readonly minArtHeight: number
+  readonly maxArtHeight: number
+  readonly minCanvasWidth: number
+  readonly maxCanvasWidth: number
+  readonly minCanvasHeight: number
+  readonly maxCanvasHeight: number
+  readonly opaquePixels: number
+  readonly totalPixels: number
+}
+
+/** A decoded member plus its statistics, so callers can reuse the artwork. */
+interface DccResult {
+  readonly stats: MemberStats
+  readonly dcc: DccFile
+}
+
+const args = process.argv.slice(2)
+const dir = args.find((a) => !a.startsWith('--')) ?? 'samples/d2'
+const quick = args.includes('--quick')
+
+let membersDecoded = 0
+let cofsDecoded = 0
+let directions = 0
+let frames = 0
+let bottomUpFrames = 0
+let opaquePixels = 0
+let totalPixels = 0
+let minArtWidth = Number.MAX_SAFE_INTEGER
+let maxArtWidth = 0
+let minArtHeight = Number.MAX_SAFE_INTEGER
+let maxArtHeight = 0
+let minCanvasWidth = Number.MAX_SAFE_INTEGER
+let maxCanvasWidth = 0
+let minCanvasHeight = Number.MAX_SAFE_INTEGER
+let maxCanvasHeight = 0
+let assertions = 0
+let failures = 0
+/** A frame captured for the text rendering, with the member it came from. */
+let renderSample: { member: string; frame: SpriteFrame; direction: number; index: number } | undefined
+
+/**
+ * Map an archive name to the lower-case, forward-slash form used for matching.
+ *
+ * @param name - the name as stored.
+ * @returns the comparison form.
+ */
+function normalize(name: string): string {
+  return name.replaceAll('\\', '/').toLowerCase()
+}
+
+/**
+ * Extract a message from an unknown thrown value.
+ *
+ * @param err - the thrown value.
+ * @returns the message.
+ */
+function messageOf(err: unknown): string {
+  return err instanceof Error ? err.message : String(err)
+}
+
+/**
+ * Record one assertion.
+ *
+ * @param ok - whether it held.
+ * @param message - what was checked.
+ * @param required - whether a failure should fail the run.
+ */
+function check(ok: boolean, message: string, required = true): void {
+  assertions += 1
+  if (ok) return
+  if (required) failures += 1
+  console.log(`   FAIL ${message}`)
+}
+
+/**
+ * Reconstruct the DCC path a COF layer draws.
+ *
+ * A COF layer record names no file: it carries a composite type and a weapon
+ * class, and the COF's own file name carries the animation and weapon codes. The
+ * sprite path is therefore
+ * `<root><component>/<token><component><variant><animation><weapon>.dcc`, where
+ * everything except `<variant>` is known. `<variant>` is the armour or object
+ * variant code, which lives in the item tables rather than the COF, so the
+ * lexicographically first candidate is used: every candidate is the same
+ * animation from a different armour tier, and decoding one of them is what this
+ * check is for.
+ *
+ * @param names - the archive's normalised name list.
+ * @param root - directory prefix shared by the COF and its art.
+ * @param token - the object or class code, e.g. `so`.
+ * @param animation - two-letter animation code from the COF name.
+ * @param weapon - weapon-class code from the COF name.
+ * @param component - component directory for the layer's composite type.
+ * @returns the member name, or undefined when the archive has no candidate.
+ */
+function findLayerDcc(
+  names: readonly string[],
+  root: string,
+  token: string,
+  animation: string,
+  weapon: string,
+  component: string,
+): string | undefined {
+  const prefix = `${root}${component}/${token}${component}`
+  const suffix = `${animation}${weapon}.dcc`
+  const hits = names.filter((n) => n.startsWith(prefix) && n.endsWith(suffix))
+  hits.sort()
+  return hits[0]
+}
+
+/**
+ * Decode one COF.
+ *
+ * @param archive - the archive holding the member.
+ * @param member - the member name.
+ * @param required - whether a failure should fail the run.
+ * @returns the decoded COF, or undefined when it could not be read.
+ */
+async function readCof(archive: MpqArchive, member: string, required: boolean): Promise<CofFile | undefined> {
+  const file = archive.find(member)
+  if (file === undefined) {
+    check(false, `${member}: not present in the archive`, required)
+    return undefined
+  }
+  let data: Uint8Array
+  try {
+    data = await archive.read(file)
+  } catch (err) {
+    check(false, `${member}: cannot read member: ${messageOf(err)}`, required)
+    return undefined
+  }
+  try {
+    const cof = decodeCof(data)
+    check(true, `${member}: decoded`)
+    cofsDecoded += 1
+    return cof
+  } catch (err) {
+    check(false, `${member}: decode failed: ${messageOf(err)}`, required)
+    return undefined
+  }
+}
+
+/**
+ * Decode one DCC member, assert every frame is usable, and gather its statistics.
+ *
+ * The per-frame contract is deliberately strict — positive canvas, positive art
+ * rectangle, at least one opaque pixel — because those three properties between
+ * them rule out the failure modes that a decoder merely "succeeding" would
+ * otherwise hide: an empty canvas, an off-by-one box, and a frame that decoded
+ * to nothing but transparency.
+ *
+ * @param archive - the archive holding the member.
+ * @param member - the member name.
+ * @param expected - direction and frame counts the COF demands, when known.
+ * @param required - whether a failure should fail the run.
+ * @returns the member's statistics, or undefined when it could not be decoded.
+ */
+async function checkDcc(
+  archive: MpqArchive,
+  member: string,
+  expected: { directions: number; frames: number } | undefined,
+  required: boolean,
+): Promise<DccResult | undefined> {
+  const file = archive.find(member)
+  if (file === undefined) {
+    check(false, `${member}: not present in the archive`, required)
+    return undefined
+  }
+  let data: Uint8Array
+  try {
+    data = await archive.read(file)
+  } catch (err) {
+    check(false, `${member}: cannot read member: ${messageOf(err)}`, required)
+    return undefined
+  }
+  let dcc: DccFile
+  try {
+    dcc = decodeDcc(data)
+  } catch (err) {
+    check(false, `${member}: decode failed: ${messageOf(err)}`, required)
+    return undefined
+  }
+
+  check(dcc.directions.length > 0, `${member}: decoded ${String(dcc.directions.length)} directions`, required)
+  if (expected !== undefined) {
+    check(
+      dcc.directions.length === expected.directions,
+      `${member}: ${String(dcc.directions.length)} directions, COF declares ${String(expected.directions)}`,
+      required,
+    )
+  }
+
+  let memberFrames = 0
+  let memberBottomUp = 0
+  let memberOpaque = 0
+  let memberTotal = 0
+  let artMinW = Number.MAX_SAFE_INTEGER
+  let artMaxW = 0
+  let artMinH = Number.MAX_SAFE_INTEGER
+  let artMaxH = 0
+  let canvasMinW = Number.MAX_SAFE_INTEGER
+  let canvasMaxW = 0
+  let canvasMinH = Number.MAX_SAFE_INTEGER
+  let canvasMaxH = 0
+
+  for (let d = 0; d < dcc.directions.length; d += 1) {
+    const directionBox = dcc.directions[d]!.box
+    const list = dcc.directions[d]!.frames
+    check(
+      directionBox.width > 0 && directionBox.height > 0,
+      `${member} direction ${String(d)}: box ${String(directionBox.width)}x${String(directionBox.height)}`,
+      required,
+    )
+    if (expected !== undefined) {
+      check(
+        list.length === expected.frames,
+        `${member} direction ${String(d)}: ${String(list.length)} frames, COF declares ${String(expected.frames)}`,
+        required,
+      )
+    }
+    if (directionBox.width <= 0 || directionBox.height <= 0) continue
+    canvasMinW = Math.min(canvasMinW, directionBox.width)
+    canvasMaxW = Math.max(canvasMaxW, directionBox.width)
+    canvasMinH = Math.min(canvasMinH, directionBox.height)
+    canvasMaxH = Math.max(canvasMaxH, directionBox.height)
+
+    for (let f = 0; f < list.length; f += 1) {
+      const decoded = list[f]!
+      const sprite = decoded.frame
+      memberFrames += 1
+      if (decoded.bottomUp) memberBottomUp += 1
+      check(
+        decoded.width > 0 && decoded.height > 0,
+        `${member} direction ${String(d)} frame ${String(f)}: art ${String(decoded.width)}x${String(decoded.height)}`,
+        required,
+      )
+      check(
+        sprite.width === directionBox.width && sprite.height === directionBox.height,
+        `${member} direction ${String(d)} frame ${String(f)}: canvas ${String(sprite.width)}x${String(sprite.height)} is not the direction box`,
+        required,
+      )
+      if (decoded.width <= 0 || decoded.height <= 0) continue
+      artMinW = Math.min(artMinW, decoded.width)
+      artMaxW = Math.max(artMaxW, decoded.width)
+      artMinH = Math.min(artMinH, decoded.height)
+      artMaxH = Math.max(artMaxH, decoded.height)
+
+      let opaque = 0
+      for (const m of sprite.mask) if (m !== 0) opaque += 1
+      memberOpaque += opaque
+      memberTotal += sprite.mask.length
+      check(
+        opaque > 0,
+        `${member} direction ${String(d)} frame ${String(f)}: no opaque pixels in ${String(sprite.width)}x${String(sprite.height)}`,
+        required,
+      )
+    }
+  }
+
+  membersDecoded += 1
+  directions += dcc.directions.length
+  frames += memberFrames
+  bottomUpFrames += memberBottomUp
+  opaquePixels += memberOpaque
+  totalPixels += memberTotal
+  minArtWidth = Math.min(minArtWidth, artMinW)
+  maxArtWidth = Math.max(maxArtWidth, artMaxW)
+  minArtHeight = Math.min(minArtHeight, artMinH)
+  maxArtHeight = Math.max(maxArtHeight, artMaxH)
+  minCanvasWidth = Math.min(minCanvasWidth, canvasMinW)
+  maxCanvasWidth = Math.max(maxCanvasWidth, canvasMaxW)
+  minCanvasHeight = Math.min(minCanvasHeight, canvasMinH)
+  maxCanvasHeight = Math.max(maxCanvasHeight, canvasMaxH)
+
+  return {
+    stats: {
+      member,
+      directions: dcc.directions.length,
+      frames: memberFrames,
+      bottomUp: memberBottomUp,
+      minArtWidth: artMinW,
+      maxArtWidth: artMaxW,
+      minArtHeight: artMinH,
+      maxArtHeight: artMaxH,
+      minCanvasWidth: canvasMinW,
+      maxCanvasWidth: canvasMaxW,
+      minCanvasHeight: canvasMinH,
+      maxCanvasHeight: canvasMaxH,
+      opaquePixels: memberOpaque,
+      totalPixels: memberTotal,
+    },
+    dcc,
+  }
+}
+
+/**
+ * Print one decoded member's measurements on a fixed-width line.
+ *
+ * @param label - the layer description.
+ * @param stats - the member's statistics.
+ */
+function reportMember(label: string, stats: MemberStats): void {
+  const ratio = stats.totalPixels === 0 ? 0 : (100 * stats.opaquePixels) / stats.totalPixels
+  const dim = (w: number, h: number): string => `${String(w)}x${String(h)}`
+  console.log(
+    `   ${label.padEnd(16)} ${`${String(stats.directions)}x${String(stats.frames)}`.padStart(7)}` +
+      `   art ${`${dim(stats.minArtWidth, stats.minArtHeight)}`.padStart(8)}..${dim(stats.maxArtWidth, stats.maxArtHeight).padEnd(8)}` +
+      `   canvas ${`${dim(stats.minCanvasWidth, stats.minCanvasHeight)}`.padStart(8)}..${dim(stats.maxCanvasWidth, stats.maxCanvasHeight).padEnd(8)}` +
+      `   opaque ${ratio.toFixed(1).padStart(5)}%   bottom-up ${String(stats.bottomUp)}`,
+  )
+  console.log(`      ${stats.member}`)
+}
+
+/**
+ * Decode a COF and every DCC its layers name.
+ *
+ * @param archive - the archive holding the member.
+ * @param names - the archive's normalised name list.
+ * @param label - the animation's label.
+ * @param member - the COF member name.
+ * @param root - the normalised directory prefix shared by the COF and its art.
+ * @param token - the class or object code, e.g. `so`.
+ * @param required - whether failures should fail the run.
+ * @param captureLayer - component whose first frame is kept for the text render.
+ */
+async function checkCofAndLayers(
+  archive: MpqArchive,
+  names: readonly string[],
+  label: string,
+  member: string,
+  root: string,
+  token: string,
+  required: boolean,
+  captureLayer?: string,
+): Promise<void> {
+  const cof = await readCof(archive, member, required)
+  if (cof === undefined) return
+
+  const base = normalize(member).split('/').pop()!.replace('.cof', '')
+  const animation = base.slice(token.length, token.length + 2)
+  const weapon = base.slice(token.length + 2)
+  console.log(`\n[${label}] ${member}`)
+  console.log(
+    `   cof: ${String(cof.numberOfDirections)} directions x ${String(cof.framesPerDirection)} frames ` +
+      `x ${String(cof.numberOfLayers)} layers, speed ${String(cof.speed)}, animation code ${animation}${weapon}`,
+  )
+
+  // The priority table must account for every layer: anything else means a
+  // layer's art is never drawn, which a screenshot would not reveal.
+  for (let d = 0; d < cof.numberOfDirections; d += 1) {
+    for (let f = 0; f < cof.framesPerDirection; f += 1) {
+      const order = cofLayerOrder(cof, d, f)
+      check(
+        order.length === cof.numberOfLayers,
+        `${member} direction ${String(d)} frame ${String(f)}: layer order has ${String(order.length)} of ${String(cof.numberOfLayers)} layers`,
+        required,
+      )
+      for (const index of order) {
+        check(
+          index >= 0 && index < cof.numberOfLayers,
+          `${member} direction ${String(d)} frame ${String(f)}: layer order names index ${String(index)}`,
+          required,
+        )
+      }
+    }
+  }
+  console.log(`   layer order dir 0 frame 0 -> [${cofLayerOrder(cof, 0, 0).join(', ')}]`)
+
+  const expected = { directions: cof.numberOfDirections, frames: cof.framesPerDirection }
+  for (let i = 0; i < cof.layers.length; i += 1) {
+    const layer = cof.layers[i]!
+    const component = LAYER_COMPONENT[layer.type]
+    check(component !== undefined, `${member} layer ${String(i)}: composite type ${String(layer.type)}`, required)
+    if (component === undefined) continue
+    const layerMember = findLayerDcc(names, root, token, animation, weapon, component)
+    check(
+      layerMember !== undefined,
+      `${member} layer ${String(i)} (type ${String(layer.type)} → ${component}): no ${animation}${weapon}.dcc candidate`,
+      required,
+    )
+    if (layerMember === undefined) continue
+    const result = await checkDcc(archive, layerMember, expected, required)
+    if (result === undefined) continue
+    reportMember(`layer ${String(i)} ${component} type ${String(layer.type)}`, result.stats)
+    if (captureLayer === component && renderSample === undefined) {
+      renderSample = {
+        member: layerMember,
+        frame: result.dcc.directions[0]!.frames[0]!.frame,
+        direction: 0,
+        index: 0,
+      }
+    }
+  }
+}
+
+/**
+ * Map a palette index to a position on the brightness ramp.
+ *
+ * With a real palette the value is the colour's luminance, so the rendering shows
+ * the art's own shading; without one the index itself stands in for brightness,
+ * which is still enough to tell a shape from noise.
+ *
+ * @param index - the palette index.
+ * @param palette - the palette, when one could be read.
+ * @returns a ramp index of 1 or more (0 is reserved for transparent pixels).
+ */
+function brightnessLevel(index: number, palette: Palette | undefined): number {
+  let luminance = index
+  if (palette !== undefined) {
+    const at = index * 3
+    luminance = 0.299 * palette.rgb[at]! + 0.587 * palette.rgb[at + 1]! + 0.114 * palette.rgb[at + 2]!
+  }
+  const steps = ASCII_RAMP.length - 1
+  return 1 + Math.min(steps - 1, Math.floor((luminance / 256) * steps))
+}
+
+/**
+ * Render a frame as text.
+ *
+ * Images cannot be inspected in this environment, so a coarse text rendering is
+ * how a human confirms the decoder produced a shape rather than noise. Sampling
+ * every Nth pixel keeps the output inside the column and row caps.
+ *
+ * @param frame - the decoded frame.
+ * @param palette - the palette, when one could be read.
+ * @returns one string per sampled row.
+ */
+function renderAscii(frame: SpriteFrame, palette: Palette | undefined): string[] {
+  const stepX = Math.max(1, Math.ceil(frame.width / ASCII_COLUMNS))
+  const stepY = Math.max(1, Math.ceil(frame.height / ASCII_ROWS))
+  const lines: string[] = []
+  for (let y = 0; y < frame.height; y += stepY) {
+    let line = ''
+    for (let x = 0; x < frame.width; x += stepX) {
+      const at = y * frame.width + x
+      line += frame.mask[at] === 0 ? ' ' : ASCII_RAMP[brightnessLevel(frame.indices[at]!, palette)]!
+    }
+    lines.push(line)
+  }
+  return lines
+}
+
+/**
+ * Sweep every DCC under the Sorceress tree, counting the frames that take the
+ * bottom-up path and reporting members that fail to decode.
+ *
+ * @param archive - the character archive.
+ * @param names - its normalised name list.
+ * @param palette - the palette, unused by the count but kept for symmetry.
+ * @returns a one-line summary.
+ */
+async function sweepSorceress(archive: MpqArchive, names: readonly string[]): Promise<string> {
+  const all = names.filter((n) => n.startsWith(SWEEP_PREFIX) && n.endsWith('.dcc'))
+  const selected = quick ? all.slice(0, QUICK_LIMIT) : all
+  const started = Date.now()
+  let sweptFrames = 0
+  let sweptBottomUp = 0
+  const reasons = new Map<string, number>()
+  let failed = 0
+
+  for (const member of selected) {
+    try {
+      const dcc = decodeDcc(await archive.read(archive.find(member)!))
+      for (const direction of dcc.directions) {
+        for (const frame of direction.frames) {
+          sweptFrames += 1
+          if (frame.bottomUp) sweptBottomUp += 1
+        }
+      }
+    } catch (err) {
+      failed += 1
+      // Collapse the varying numbers so identical failures group together.
+      const reason = `${member}: ${messageOf(err)}`.replace(/\d+/g, 'N')
+      reasons.set(reason, (reasons.get(reason) ?? 0) + 1)
+      if (reasons.size <= MAX_REPORTED_SWEEP_FAILURES) {
+        console.log(`   FAIL ${member}: ${messageOf(err)}`)
+      }
+    }
+  }
+
+  const seconds = ((Date.now() - started) / 1000).toFixed(1)
+  let line = `   ${String(selected.length)} members, ${String(sweptFrames)} frames, ${String(sweptBottomUp)} bottom-up, ${String(failed)} failed (${seconds}s)`
+  if (failed > reasons.size) line += `, ${String(failed - reasons.size)} more of the same`
+  if (quick && all.length > selected.length) line += ` [--quick: ${String(all.length - selected.length)} members not swept]`
+  return line
+}
+
+console.log(`== cof + dcc verification over ${dir}${quick ? ' (quick)' : ''} ==`)
+
+const characterPath = `${dir}/${CHARACTER_ARCHIVE}`
+let characters: MpqArchive
+try {
+  characters = await MpqArchive.open(await fileSource(characterPath))
+} catch (err) {
+  console.log(`cannot open ${characterPath}: ${messageOf(err)}`)
+  process.exit(2)
+}
+const characterNames = (await characters.listFiles()).map(normalize)
+console.log(`${CHARACTER_ARCHIVE}: ${String(characterNames.length)} members listed`)
+
+for (const animation of CLASS_ANIMATIONS) {
+  await checkCofAndLayers(
+    characters,
+    characterNames,
+    `sorceress ${animation.label}`,
+    animation.member,
+    'data/global/chars/so/',
+    'so',
+    true,
+    animation.label === 'stand' ? 'tr' : undefined,
+  )
+}
+
+let data: MpqArchive | undefined
+try {
+  data = await MpqArchive.open(await fileSource(`${dir}/${DATA_ARCHIVE}`))
+} catch (err) {
+  console.log(`\nnote: ${DATA_ARCHIVE} unavailable, object members skipped (${messageOf(err)})`)
+}
+
+if (data !== undefined) {
+  const dataNames = (await data.listFiles()).map(normalize)
+  console.log(`\n${DATA_ARCHIVE}: ${String(dataNames.length)} members listed`)
+  for (const animation of OBJECT_COFS) {
+    await checkCofAndLayers(
+      data,
+      dataNames,
+      animation.label,
+      animation.member,
+      'data/global/objects/l2/',
+      'l2',
+      false,
+    )
+  }
+  console.log('\n[object sprites]')
+  for (const member of OBJECT_DCCS) {
+    const result = await checkDcc(data, member, undefined, false)
+    if (result !== undefined) reportMember('object', result.stats)
+  }
+}
+
+let palette: Palette | undefined
+if (data !== undefined) {
+  const palFile = data.find('data\\global\\palette\\act1\\pal.dat')
+  if (palFile !== undefined) {
+    try {
+      palette = decodePal(await data.read(palFile))
+    } catch (err) {
+      console.log(`note: act 1 palette unreadable: ${messageOf(err)}`)
+    }
+  }
+}
+
+console.log('\n[sweep: sorceress art, every direction of every member]')
+console.log(await sweepSorceress(characters, characterNames))
+
+console.log('\n== summary ==')
+console.log(`   cofs decoded:       ${String(cofsDecoded)}`)
+console.log(`   dcc members:        ${String(membersDecoded)}`)
+console.log(`   directions:         ${String(directions)}`)
+console.log(`   frames:             ${String(frames)}`)
+console.log(
+  `   art rectangles:     ${`${String(minArtWidth)}x${String(minArtHeight)}`} .. ${`${String(maxArtWidth)}x${String(maxArtHeight)}`} px`,
+)
+console.log(
+  `   direction canvases: ${`${String(minCanvasWidth)}x${String(minCanvasHeight)}`} .. ${`${String(maxCanvasWidth)}x${String(maxCanvasHeight)}`} px`,
+)
+console.log(`   bottom-up frames:   ${String(bottomUpFrames)} of ${String(frames)} checked`)
+console.log(
+  `   opaque coverage:    ${((100 * opaquePixels) / Math.max(1, totalPixels)).toFixed(1)}% of ${String(totalPixels)} canvas pixels`,
+)
+console.log(`   assertions:         ${String(assertions - failures)}/${String(assertions)} passed`)
+
+if (renderSample !== undefined) {
+  const sample = renderSample
+  const stepX = Math.max(1, Math.ceil(sample.frame.width / ASCII_COLUMNS))
+  const stepY = Math.max(1, Math.ceil(sample.frame.height / ASCII_ROWS))
+  let opaque = 0
+  for (const m of sample.frame.mask) if (m !== 0) opaque += 1
+  console.log(`\n== text rendering: ${sample.member} direction ${String(sample.direction)} frame ${String(sample.index)} ==`)
+  console.log(
+    `   ${String(sample.frame.width)}x${String(sample.frame.height)} px, sampling every ${String(stepX)}x${String(stepY)} px, ` +
+      `${((100 * opaque) / sample.frame.mask.length).toFixed(1)}% opaque, ' ' = transparent, '@' = brightest`,
+  )
+  for (const line of renderAscii(sample.frame, palette)) console.log(`   |${line}|`)
+}
+
+if (failures > 0) {
+  console.log(`\n${String(failures)} failures: the COF+DCC path is not usable yet`)
+  process.exit(1)
+}
+console.log('\nall required checks passed')
diff --git a/scripts/verify-deploy.ts b/scripts/verify-deploy.ts
new file mode 100644
index 0000000..e2f918e
--- /dev/null
+++ b/scripts/verify-deploy.ts
@@ -0,0 +1,131 @@
+// verify-deploy.ts — 线上部署自检（不需要浏览器）
+//
+// 检查 https://www.laiseek.xyz/diablo2/ 这一套入口是否真的可用：页面、资源包索引、
+// 图集分页、以及按 HTTP range 读 .mpq 的 206；同时确认旧入口 /acts* 已经下线（410）。
+// 默认打公网域名，`--host=http://127.0.0.1` 可以改成打本机（跳过 TLS）。
+//
+//   node scripts/verify-deploy.ts
+//   node scripts/verify-deploy.ts --host=https://www.laiseek.xyz
+//
+// 退出码非 0 表示有断言没过。
+
+export {}
+
+/** 公网入口，可用 `--host=` 覆盖。 */
+const HOST = process.argv.find(argument => argument.startsWith('--host='))?.slice('--host='.length)
+  ?? 'https://www.laiseek.xyz'
+
+/** 一个断言的结果。 */
+interface Check {
+  readonly name: string
+  readonly ok: boolean
+  readonly detail: string
+}
+
+/** 已跑过的断言。 */
+const checks: Check[] = []
+
+/**
+ * 记录一条断言。
+ *
+ * @param name - what was checked.
+ * @param ok - whether it held.
+ * @param detail - human-readable evidence.
+ */
+function check(name: string, ok: boolean, detail: string): void {
+  checks.push({ name, ok, detail })
+  console.log(`${ok ? 'ok  ' : 'FAIL'} ${name} — ${detail}`)
+}
+
+/**
+ * 取一个 URL，返回状态码、头与正文长度；网络错误也算作结果，不抛出。
+ *
+ * @param path - path on the host, starting with `/`.
+ * @param init - extra fetch options.
+ * @returns the response facts.
+ */
+async function probe(path: string, init?: RequestInit): Promise<{ status: number; headers: Headers; text: string }> {
+  try {
+    const response = await fetch(`${HOST}${path}`, { redirect: 'manual', ...init })
+    const text = init?.method === 'HEAD' ? '' : await response.text()
+    return { status: response.status, headers: response.headers, text }
+  } catch (err) {
+    return { status: 0, headers: new Headers(), text: (err as Error).message }
+  }
+}
+
+/**
+ * 线上自检主流程。
+ */
+async function main(): Promise<void> {
+  console.log(`host: ${HOST}\n`)
+
+  // 页面：入口要 200，且引用的资源都带 /diablo2/ 前缀（base 配错会立刻在这里暴露）
+  const page = await probe('/diablo2/')
+  check('/diablo2/ 200', page.status === 200, `HTTP ${String(page.status)}`)
+  const assetPaths = [...page.text.matchAll(/(?:src|href)="(\/diablo2\/assets\/[^"]+)"/g)].map(match => match[1]!)
+  check('页面引用 /diablo2/assets/*', assetPaths.length > 0, `${String(assetPaths.length)} 个资源引用`)
+  // 三级选择器：章节 / 场景 / 细分场景。断言三个 id 都在，多了会漏、少了会错位。
+  const selectors = ['id="act"', 'id="scene"', 'id="variant"']
+  check('页面是地图页（含三级选择器）', selectors.every(id => page.text.includes(id)),
+    `acts.html 已被入口 rewrite 命中；选择器 ${selectors.filter(id => page.text.includes(id)).length}/3`)
+  check('header 上没有多余站内链接', !/<header[^>]*>[\s\S]*?<a\s/.test(page.text), 'header 只留标题与 HUD')
+  if (assetPaths[0] !== undefined) {
+    const asset = await probe(assetPaths[0], { method: 'HEAD' })
+    check('首个资源可达', asset.status === 200, `${assetPaths[0]} → HTTP ${String(asset.status)}`)
+  }
+
+  // 资源包索引：条数、调色板、每条 path 都有 scene.json
+  const index = await probe('/diablo2/packs/index.json')
+  check('资源包索引 200', index.status === 200, `HTTP ${String(index.status)}`)
+  let levels: { act: number; path: string; label: string }[] = []
+  let palettes: Record<string, number[]> = {}
+  try {
+    const parsed = JSON.parse(index.text) as { levels?: typeof levels; palettes?: typeof palettes }
+    levels = parsed.levels ?? []
+    palettes = parsed.palettes ?? {}
+  } catch (err) {
+    check('索引是 JSON', false, (err as Error).message)
+  }
+  check('索引是 JSON', levels.length > 0, `${String(levels.length)} 个地图块`)
+  check('索引带 act 调色板', Object.keys(palettes).length >= 5,
+    `${String(Object.keys(palettes).length)} 组，每组 ${String(palettes.act1?.length ?? 0)} 字节`)
+  const actCounts = new Map<number, number>()
+  for (const level of levels) actCounts.set(level.act, (actCounts.get(level.act) ?? 0) + 1)
+  check('五个 act 都有地图', actCounts.size === 5,
+    [...actCounts].sort((left, right) => left[0] - right[0]).map(([act, count]) => `act${String(act)}:${String(count)}`).join(' '))
+
+  // 抽第一个和最后一个地图块，确认 scene.json 与第一页 PNG 真的在
+  for (const entry of [levels[0], levels[levels.length - 1]]) {
+    if (entry === undefined) continue
+    const scene = await probe(`/diablo2/packs/${entry.path}/scene.json`)
+    check(`scene.json 200（${entry.label}）`, scene.status === 200, `HTTP ${String(scene.status)}`)
+    let page0: string | null = null
+    try {
+      const parsed = JSON.parse(scene.text) as { pages?: { file: string }[] }
+      page0 = parsed.pages?.[0]?.file ?? null
+    } catch { /* 上面那条断言已经失败，这里只补详情 */ }
+    if (page0 !== null) {
+      const png = await probe(`/diablo2/packs/${entry.path}/${page0}`, { method: 'HEAD' })
+      check(`首屏图集 200（${entry.label}）`, png.status === 200, `${page0} → HTTP ${String(png.status)}`)
+    }
+  }
+
+  // 归档：只暴露 .mpq，且必须支持 Range（否则页面回退到整文件下载）
+  const range = await probe('/diablo2/data/d2char.mpq', { headers: { Range: 'bytes=0-1023' } })
+  check('d2char.mpq Range 206', range.status === 206, `HTTP ${String(range.status)} ${range.headers.get('content-range') ?? ''}`)
+  const traversal = await probe('/diablo2/data/..%2f..%2fetc%2fpasswd')
+  check('归档路径穿越被拒', traversal.status !== 200, `HTTP ${String(traversal.status)}`)
+
+  // 旧入口下线：页面、资源包、归档三条都不该再服务内容
+  for (const path of ['/acts/', '/acts-packs/index.json', '/acts-data/d2char.mpq']) {
+    const gone = await probe(path)
+    check(`旧入口下线 ${path}`, gone.status === 410, `HTTP ${String(gone.status)}`)
+  }
+
+  const passed = checks.filter(entry => entry.ok).length
+  console.log(`\n${String(passed)}/${String(checks.length)} passed`)
+  if (passed !== checks.length) process.exitCode = 1
+}
+
+await main()
diff --git a/scripts/verify-depth-order.ts b/scripts/verify-depth-order.ts
new file mode 100644
index 0000000..257e141
--- /dev/null
+++ b/scripts/verify-depth-order.ts
@@ -0,0 +1,50 @@
+/**
+ * Check for the actor depth-insertion rule.
+ *
+ * Painter's order without a depth buffer is easy to get subtly wrong and hard to
+ * eyeball — on a small map the actor's insertion point may not move at all while
+ * an actor walks around. So the rule is exercised directly instead: for a wall
+ * grid, an actor in each cell must land between the walls that are behind it and
+ * the walls that are in front of it.
+ *
+ * Usage: node scripts/verify-depth-order.ts
+ */
+import { depthInsertIndex } from '../src/game/map.ts'
+
+const problems: string[] = []
+const size = 4
+const walls = [] as { cellX: number; cellY: number }[]
+for (let cellY = 0; cellY < size; cellY += 1) {
+  for (let cellX = 0; cellX < size; cellX += 1) walls.push({ cellX, cellY })
+}
+// Painter's order: far (small x+y) first.
+walls.sort((a, b) => (a.cellY + a.cellX) - (b.cellY + b.cellX) || a.cellY - b.cellY)
+
+let checked = 0
+for (let cellY = 0; cellY < size; cellY += 1) {
+  for (let cellX = 0; cellX < size; cellX += 1) {
+    const at = depthInsertIndex(walls, cellX, cellY)
+    const depth = cellX + cellY
+    // Everything before the insertion point must be strictly nearer the camera
+    // (smaller depth), everything after strictly further — ties are allowed to
+    // fall either way, which is why the check is "never further before".
+    for (let index = 0; index < at; index += 1) {
+      const wall = walls[index]!
+      if (wall.cellX + wall.cellY > depth) problems.push(`cell ${String(cellX)},${String(cellY)}: wall at index ${String(index)} is nearer but was drawn before the actor`)
+    }
+    for (let index = at; index < walls.length; index += 1) {
+      const wall = walls[index]!
+      if (wall.cellX + wall.cellY < depth) problems.push(`cell ${String(cellX)},${String(cellY)}: wall at index ${String(index)} is further but was drawn after the actor`)
+    }
+    checked += 1
+  }
+}
+if (depthInsertIndex([], 0, 0) !== 0) problems.push('empty wall list must insert at 0')
+if (depthInsertIndex(walls, size - 1, size - 1) !== walls.length) problems.push('nearest actor must be drawn last')
+
+console.log(`walls      ${String(walls.length)} in painter's order`)
+console.log(`positions  ${String(checked)} checked`)
+console.log(`problems   ${String(problems.length)}`)
+for (const problem of problems.slice(0, 8)) console.log(`  - ${problem}`)
+console.log(problems.length === 0 ? 'RESULT     the actor is always inserted between the walls behind and in front of it' : 'RESULT     FAILED')
+process.exit(problems.length === 0 ? 0 : 1)
diff --git a/scripts/verify-dt1-pixels.ts b/scripts/verify-dt1-pixels.ts
new file mode 100644
index 0000000..def4558
--- /dev/null
+++ b/scripts/verify-dt1-pixels.ts
@@ -0,0 +1,51 @@
+/**
+ * Pixel-level check for the DT1 decoder.
+ *
+ * The Go reference package parses DT1 headers correctly but never calls its own
+ * graphics decoder, so it cannot serve as a pixel oracle. This closes that gap
+ * from the other side: the fixture generator writes down the grid it encoded,
+ * and the decoder must reproduce it pixel for pixel — which validates the
+ * placement logic (skip runs, row advance, isometric tables, y-offset) rather
+ * than merely "did not throw".
+ *
+ * Usage: node scripts/verify-dt1-pixels.ts <fixture-directory>
+ */
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { decodeDt1 } from '../src/formats/dt1.ts'
+
+interface Expected {
+  readonly width: number
+  readonly height: number
+  readonly tiles: readonly { readonly format: number; readonly base: number; readonly pixels: readonly number[] }[]
+}
+
+const dir = process.argv[2]
+if (dir === undefined) {
+  console.error('usage: node scripts/verify-dt1-pixels.ts <fixture-directory>')
+  process.exit(2)
+}
+const expected = JSON.parse(await readFile(join(dir, 'expected-dt1.json'), 'utf8')) as Expected
+const library = decodeDt1(new Uint8Array(await readFile(join(dir, 'fixture.dt1'))))
+
+const problems: string[] = []
+expected.tiles.forEach((want, index) => {
+  const tile = library.tiles[index]
+  if (tile === undefined) { problems.push(`tile ${String(index)} missing`); return }
+  const block = tile.blocks[0]
+  if (block === undefined) { problems.push(`tile ${String(index)} has no blocks`); return }
+  if (block.format !== want.format) problems.push(`tile ${String(index)} format ${String(block.format)} != ${String(want.format)}`)
+  let mismatched = 0
+  for (let at = 0; at < want.pixels.length; at += 1) {
+    if ((block.pixels[at] ?? 0) !== want.pixels[at]) mismatched += 1
+  }
+  if (mismatched > 0) problems.push(`tile ${String(index)}: ${String(mismatched)} of ${String(want.pixels.length)} pixels differ`)
+})
+
+console.log(`fixture    ${join(dir, 'fixture.dt1')}`)
+console.log(`tiles      ${String(library.tiles.length)}`)
+console.log(`pixels     ${String(expected.tiles.reduce((n, t) => n + t.pixels.length, 0))} compared`)
+console.log(`mismatches ${String(problems.length)}`)
+for (const problem of problems.slice(0, 8)) console.log(`  - ${problem}`)
+console.log(problems.length === 0 ? 'RESULT     every pixel matches the encoded pattern' : 'RESULT     FAILED')
+process.exit(problems.length === 0 ? 0 : 1)
diff --git a/scripts/verify-format-parity.sh b/scripts/verify-format-parity.sh
new file mode 100644
index 0000000..47c063e
--- /dev/null
+++ b/scripts/verify-format-parity.sh
@@ -0,0 +1,106 @@
+#!/usr/bin/env bash
+# Format-parity harness: compare this project's TypeScript decoders with
+# independent implementations on generated fixtures.
+#
+#   dc6  vs dc6png (npm)                      -> PNG pixels compared
+#   dc6  vs OpenDiablo2/dc6 (Go)              -> full JSON compared
+#   ds1  vs OpenDiablo2/ds1 (Go)              -> full JSON compared
+#   pl2  vs OpenDiablo2/pl2 (Go)              -> base/text palettes + per-table digests
+#   dt1  vs OpenDiablo2/dt1 (Go)              -> metadata JSON compared
+#   dt1  pixel placement                      -> compared against the encoded grid
+#
+# The Go oracle is optional: point REFDUMP at a built reference dumper, or let
+# this script build one from a checkout. Without it, the dc6px and dt1 pixel
+# checks still run.
+#
+# Usage: bash scripts/verify-format-parity.sh [work-directory]
+set -uo pipefail
+
+WORK="${1:-/tmp/d2fix}"
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+REFDUMP="${REFDUMP:-}"
+DC6PNG="${DC6PNG:-}"
+
+cd "$ROOT"
+echo "== fixtures =="
+node scripts/make-fixtures.ts "$WORK" | sed 's/^/   /'
+node scripts/make-map-fixtures.ts "$WORK" | sed 's/^/   /'
+node scripts/make-pl2-fixture.ts "$WORK" | sed 's/^/   /'
+
+failures=0
+report() {
+  if [ "$1" -eq 0 ]; then echo "   PASS"; else echo "   FAIL"; failures=$((failures + 1)); fi
+}
+
+echo
+echo "== dc6: independent JS decoder (dc6png) =="
+if [ -n "$DC6PNG" ] && [ -f "$DC6PNG" ]; then
+  node "$DC6PNG" -p "$WORK/palette.pal" -f "$WORK/fixture.dc6" -d "$WORK" -m png >/dev/null 2>&1
+  python3 - "$WORK" <<'PY'
+import json, sys
+from PIL import Image
+work = sys.argv[1]
+exp = json.load(open(f'{work}/expected.json'))
+pal = open(f'{work}/palette.pal','rb').read()
+# dc6png reads palette bytes as BGR.
+rgb = lambda i: (pal[i*3+2], pal[i*3+1], pal[i*3])
+bad = 0
+for d in range(exp['directions']):
+    for f in range(exp['framesPerDirection']):
+        want = exp['frames'][d][f]
+        im = Image.open(f'{work}/fixture_{d}_{f}.png').convert('RGBA')
+        px = im.load()
+        for y, row in enumerate(want['rows']):
+            for x, idx in enumerate(row):
+                r, g, b, a = px[x, y]
+                if idx == 0:
+                    bad += 0 if a == 0 else 1
+                else:
+                    bad += 0 if ((r, g, b) == rgb(idx) and a == 255) else 1
+print(f'   pixels compared: {exp["directions"]*exp["framesPerDirection"]*8*4}, mismatches: {bad}')
+sys.exit(1 if bad else 0)
+PY
+  report $?
+else
+  echo "   SKIP (set DC6PNG=/path/to/dc6png/src/index.js)"
+fi
+
+echo
+echo "== dc6 / dt1 / ds1 / pl2: independent Go decoders =="
+if [ -n "$REFDUMP" ] && [ -x "$REFDUMP" ]; then
+  for fmt in dc6 ds1 dt1 pl2; do
+    node scripts/dump-format.ts "$fmt" "$WORK/fixture.$fmt" > "$WORK/ts.$fmt.json" 2>/dev/null
+    "$REFDUMP" "$fmt" "$WORK/fixture.$fmt" > "$WORK/go.$fmt.json" 2>/dev/null
+    echo "   $fmt:"
+    python3 - "$WORK" "$fmt" <<'PY'
+import json, sys
+work, fmt = sys.argv[1], sys.argv[2]
+a = json.load(open(f'{work}/ts.{fmt}.json'))
+b = json.load(open(f'{work}/go.{fmt}.json'))
+# The Go dt1 package never runs its graphics decoder, so its pixel arrays are
+# empty by construction; compare structure and let the pixel check cover pixels.
+if fmt == 'dt1':
+    for ta, tb in zip(a['tiles'], b['tiles']):
+        for ba in ta['blocks']: ba['pixels'] = []
+        for bb in tb['blocks']: bb['pixels'] = []
+print('      identical:', a == b)
+sys.exit(0 if a == b else 1)
+PY
+    report $?
+  done
+else
+  echo "   SKIP (set REFDUMP=/path/to/refdump)"
+fi
+
+echo
+echo "== dt1: pixel placement against the encoded grid =="
+node scripts/verify-dt1-pixels.ts "$WORK" | sed 's/^/   /'
+report $?
+
+echo
+if [ "$failures" -eq 0 ]; then
+  echo "ALL PARITY CHECKS PASSED"
+else
+  echo "$failures PARITY CHECK(S) FAILED"
+fi
+exit "$failures"
diff --git a/scripts/verify-generators.ts b/scripts/verify-generators.ts
new file mode 100644
index 0000000..0739bec
--- /dev/null
+++ b/scripts/verify-generators.ts
@@ -0,0 +1,645 @@
+/**
+ * Verify the generated levels for every non-preset level in the game.
+ *
+ * 70 levels are randomly generated mazes (`Levels.txt.DrlgType == 1`) and 31 are
+ * wilderness (`== 3`); the other 35 are presets and are covered by
+ * `verify-acts.ts`. This script builds a generator request for each of those 101
+ * levels straight from the shipped tables, generates it with a fixed seed, and
+ * asserts the four things that would otherwise only show up as a broken map in an
+ * asset pack:
+ *
+ * 1. **Determinism** — two runs of the same request must hash identically. The
+ *    generators are seeded, so a mismatch means a stray `Math.random`, a `Map`
+ *    iteration that depends on insertion order somewhere it should not, or state
+ *    leaking between calls.
+ * 2. **Connectivity** — a flood fill from the level's spawn point must reach at
+ *    least 90 % of the map's walkable areas. For a maze this is the whole claim of
+ *    the generator: sections are only ever attached to a section already placed,
+ *    so anything unreachable is a bug in the layout, not a design choice.
+ * 3. **Resolvability** — the level must build through `buildIsoMapScene` with the
+ *    libraries `resolveLevelLibraries` returns, with under 1 % of tile references
+ *    missing. A maze piece is only usable if the level type's DT1 libraries can
+ *    actually draw it.
+ * 4. **Parameter fidelity** — the synthesized grid must respect the parameters it
+ *    was built from: a maze's section size is `LvlMaze.SizeX/SizeY`, it places at
+ *    least `LvlMaze.Rooms` sections, and a wilderness map covers exactly
+ *    `floor(SizeX/8) x floor(SizeY/8)` blocks of 8 cells.
+ *
+ * Plus one hygiene check that needs no archives: the two generators must stay
+ * browser-safe, so neither may import a `node:` builtin, reference `Buffer`, or
+ * call `Math.random`.
+ *
+ * Usage:
+ *   node scripts/verify-generators.ts [directory]
+ */
+import { readFileSync } from 'node:fs'
+import { MountedArchives } from '../src/mpq/mount.ts'
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { fileSource } from '../src/mpq/file-source.ts'
+import { loadActTables, parseTable, cell, tileMemberPath, resolveLevelLibraries } from '../src/game/acts.ts'
+import type { D2Table } from '../src/game/acts.ts'
+import { decodeDs1 } from '../src/formats/ds1.ts'
+import type { Ds1 } from '../src/formats/ds1.ts'
+import { decodeDt1 } from '../src/formats/dt1.ts'
+import type { Dt1 } from '../src/formats/dt1.ts'
+import { levelSeed, buildIsoMapScene, cellAt } from '../src/game/d2map.ts'
+import type { IsoMapScene } from '../src/game/d2map.ts'
+import { generateMaze, classifyMazePieceName, inferLevelTypeName } from '../src/game/maze.ts'
+import type { MazePiece, MazePieceKind } from '../src/game/maze.ts'
+import { generateWilderness, classifySubstitutionRole } from '../src/game/wilderness.ts'
+import type { WildernessPiece, WildernessSubstitution } from '../src/game/wilderness.ts'
+import { SUB_TILES_PER_TILE } from '../src/game/map.ts'
+
+/** Where the archives live by default. */
+const dir = process.argv[2] ?? 'samples/d2'
+/** Mount order: later archives override earlier ones, exactly as the game loads them. */
+const MOUNTS = ['d2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq']
+/** Blocks, in cells, used to slice a generated map into "areas" for the fill. */
+const AREA_CELLS = 8
+/** Walking must reach this share of the walkable areas. */
+const MIN_REACHABLE_SHARE = 0.9
+/** Missing tile references must stay under this share. */
+const MAX_MISSING_SHARE = 0.01
+/** Documented dimension bound for a synthesized map. */
+const MAX_CELLS_PER_SIDE = 4096
+
+let checks = 0
+let failures = 0
+const failureReasons: string[] = []
+
+/**
+ * Record one assertion.
+ *
+ * @param ok - whether it held.
+ * @param level - the level label.
+ * @param message - what was checked.
+ */
+function check(ok: boolean, level: string, message: string): void {
+  checks += 1
+  if (!ok) {
+    failures += 1
+    failureReasons.push(`${level}: ${message}`)
+  }
+}
+
+/* ------------------------------------------------------------------------- *
+ * A stable hash
+ * ------------------------------------------------------------------------- */
+
+/**
+ * FNV-1a over a stream of numbers.
+ *
+ * Used instead of serializing a whole map to a string because a 240x48 map has
+ * over a hundred thousand cells and building the text would cost more than the
+ * comparison is worth.
+ */
+class Hasher {
+  private hash = 2166136261
+
+  /**
+   * Mix one number in.
+   *
+   * @param value - the value.
+   * @returns this, for chaining.
+   */
+  push(value: number): this {
+    let word = Math.trunc(value) | 0
+    for (let byte = 0; byte < 4; byte += 1) {
+      this.hash ^= (word >>> (byte * 8)) & 0xff
+      this.hash = Math.imul(this.hash, 16777619) >>> 0
+    }
+    return this
+  }
+
+  /**
+   * The digest.
+   *
+   * @returns eight hex digits.
+   */
+  get digest(): string {
+    return (this.hash >>> 0).toString(16).padStart(8, '0')
+  }
+}
+
+/**
+ * Hash a decoded map into a canonical digest.
+ *
+ * Every field that could differ between two runs is folded in, including the
+ * layer counts and the objects' sub-tile coordinates, so two maps that look
+ * alike but stamp their objects differently hash differently.
+ *
+ * @param level - the map.
+ * @returns the digest.
+ */
+function canonicalHash(level: Ds1): string {
+  const hasher = new Hasher()
+  hasher.push(level.version).push(level.width).push(level.height).push(level.act)
+  hasher.push(level.substitutionType).push(level.wallLayers).push(level.floorLayers)
+  for (let y = 0; y < level.height; y += 1) {
+    const row = level.cells[y]
+    if (row === undefined) continue
+    for (let x = 0; x < level.width; x += 1) {
+      const cellRecord = row[x]
+      if (cellRecord === undefined) continue
+      for (const wall of cellRecord.walls) {
+        hasher.push(wall.prop1).push(wall.sequence).push(wall.style).push(wall.type).push(wall.hidden ? 1 : 0)
+      }
+      for (const floor of cellRecord.floors) {
+        hasher.push(floor.prop1).push(floor.sequence).push(floor.style).push(floor.hidden ? 1 : 0)
+      }
+      for (const shadow of cellRecord.shadows) hasher.push(shadow.prop1).push(shadow.sequence).push(shadow.style)
+      for (const substitution of cellRecord.substitutions) hasher.push(substitution.value)
+    }
+  }
+  for (const object of level.objects) hasher.push(object.type).push(object.id).push(object.x).push(object.y).push(object.flags)
+  return hasher.digest
+}
+
+/* ------------------------------------------------------------------------- *
+ * Connectivity
+ * ------------------------------------------------------------------------- */
+
+/** A walkable area, keyed by its top-left cell. */
+interface Area {
+  readonly key: number
+  readonly subTile: number
+}
+
+/**
+ * Slice a map into areas and find one open sub-tile per area.
+ *
+ * An area is an 8x8-cell block. A block counts only when it contains at least one
+ * cell that carries a floor, and its representative sub-tile is the first
+ * unblocked sub-tile in it — so a block that is entirely wall is neither expected
+ * to be reached nor counted against the generator.
+ *
+ * @param level - the map.
+ * @param scene - the built scene.
+ * @returns the representative sub-tile index of every walkable area.
+ */
+function walkableAreas(level: Ds1, scene: IsoMapScene): Area[] {
+  const areas: Area[] = []
+  const blocksX = Math.ceil(level.width / AREA_CELLS)
+  const blocksY = Math.ceil(level.height / AREA_CELLS)
+  for (let by = 0; by < blocksY; by += 1) {
+    for (let bx = 0; bx < blocksX; bx += 1) {
+      let hasFloor = false
+      let representative = -1
+      for (let cy = by * AREA_CELLS; cy < Math.min((by + 1) * AREA_CELLS, level.height) && representative === -1; cy += 1) {
+        const row = level.cells[cy]
+        if (row === undefined) continue
+        for (let cx = bx * AREA_CELLS; cx < Math.min((bx + 1) * AREA_CELLS, level.width) && representative === -1; cx += 1) {
+          const cellRecord = row[cx]
+          if (cellRecord === undefined) continue
+          for (const floor of cellRecord.floors) {
+            if (!floor.hidden && floor.prop1 !== 0) { hasFloor = true; break }
+          }
+          for (let sy = 0; sy < SUB_TILES_PER_TILE && representative === -1; sy += 1) {
+            for (let sx = 0; sx < SUB_TILES_PER_TILE; sx += 1) {
+              const gx = cx * SUB_TILES_PER_TILE + sx
+              const gy = cy * SUB_TILES_PER_TILE + sy
+              if (gx >= scene.gridWidth || gy >= scene.gridHeight) continue
+              if (scene.blocked[gy * scene.gridWidth + gx] === 1) continue
+              representative = gy * scene.gridWidth + gx
+              break
+            }
+          }
+        }
+      }
+      if (hasFloor && representative !== -1) areas.push({ key: by * blocksX + bx, subTile: representative })
+    }
+  }
+  return areas
+}
+
+/**
+ * Flood fill the scene's sub-tile grid from a starting sub-tile.
+ *
+ * @param scene - the built scene.
+ * @param start - the starting sub-tile index.
+ * @returns the set of reachable sub-tile indices.
+ */
+function floodFill(scene: IsoMapScene, start: number): Set<number> {
+  const seen = new Set<number>([start])
+  const queue = [start]
+  while (queue.length > 0) {
+    const at = queue.pop()!
+    const x = at % scene.gridWidth
+    const y = (at - x) / scene.gridWidth
+    const neighbours: readonly (readonly [number, number])[] = [[1, 0], [-1, 0], [0, 1], [0, -1]]
+    for (const [dx, dy] of neighbours) {
+      const nx = x + dx
+      const ny = y + dy
+      if (nx < 0 || ny < 0 || nx >= scene.gridWidth || ny >= scene.gridHeight) continue
+      const next = ny * scene.gridWidth + nx
+      if (scene.blocked[next] === 1 || seen.has(next)) continue
+      seen.add(next)
+      queue.push(next)
+    }
+  }
+  return seen
+}
+
+/**
+ * Find the sub-tile nearest the map's centre that is open.
+ *
+ * Mirrors `findIsoSpawn`'s spiral, but returns a grid index because the fill
+ * works on the collision grid rather than on scene pixels.
+ *
+ * @param scene - the built scene.
+ * @returns the sub-tile index, or -1 when nothing is walkable.
+ */
+function findOpenSubTile(scene: IsoMapScene): number {
+  const centreX = Math.floor(scene.cellsX / 2) * SUB_TILES_PER_TILE
+  const centreY = Math.floor(scene.cellsY / 2) * SUB_TILES_PER_TILE
+  const limit = Math.max(scene.gridWidth, scene.gridHeight)
+  for (let radius = 0; radius < limit; radius += 1) {
+    for (let dy = -radius; dy <= radius; dy += 1) {
+      for (let dx = -radius; dx <= radius; dx += 1) {
+        if (Math.max(Math.abs(dx), Math.abs(dy)) !== radius) continue
+        const gx = centreX + dx
+        const gy = centreY + dy
+        if (gx < 0 || gy < 0 || gx >= scene.gridWidth || gy >= scene.gridHeight) continue
+        const index = gy * scene.gridWidth + gx
+        if (scene.blocked[index] !== 1) return index
+      }
+    }
+  }
+  return -1
+}
+
+/**
+ * Run the connectivity check.
+ *
+ * @param level - the map.
+ * @param scene - the built scene.
+ * @returns the shares and counts, for printing.
+ */
+function connectivity(level: Ds1, scene: IsoMapScene): { share: number; reached: number; total: number } {
+  const areas = walkableAreas(level, scene)
+  const start = findOpenSubTile(scene)
+  if (start === -1 || areas.length === 0) return { share: 0, reached: 0, total: areas.length }
+  const reachedTiles = floodFill(scene, start)
+  let reached = 0
+  for (const area of areas) if (reachedTiles.has(area.subTile)) reached += 1
+  return { share: reached / areas.length, reached, total: areas.length }
+}
+
+/* ------------------------------------------------------------------------- *
+ * Table plumbing
+ * ------------------------------------------------------------------------- */
+
+/** Decoded DS1s, keyed by member path, so a piece shared by many levels decodes once. */
+const ds1Cache = new Map<string, Ds1>()
+
+/**
+ * Decode a member once.
+ *
+ * @param archives - the mounted archives.
+ * @param relative - the tile-relative path from a table cell.
+ * @returns the map.
+ */
+async function loadDs1(archives: MountedArchives, relative: string): Promise<Ds1> {
+  const member = tileMemberPath(relative)
+  const cached = ds1Cache.get(member)
+  if (cached !== undefined) return cached
+  const decoded = decodeDs1(await archives.read(member))
+  ds1Cache.set(member, decoded)
+  return decoded
+}
+
+/**
+ * Decode a level type's DT1 libraries.
+ *
+ * @param archives - the mounted archives.
+ * @param names - full member paths, in file-list order.
+ * @returns the libraries.
+ */
+async function decodeLibraries(archives: MountedArchives, names: readonly string[]): Promise<Dt1[]> {
+  const libraries: Dt1[] = []
+  for (const name of names) libraries.push(decodeDt1(await archives.read(name)))
+  return libraries
+}
+
+/**
+ * Read a row's decoded `File1..File6` variants.
+ *
+ * @param archives - the mounted archives.
+ * @param table - the table the row belongs to.
+ * @param row - the row.
+ * @returns the decoded maps, in file order.
+ */
+async function rowDs1s(archives: MountedArchives, table: D2Table, row: readonly string[]): Promise<Ds1[]> {
+  const levels: Ds1[] = []
+  for (let slot = 1; slot <= 6; slot += 1) {
+    const value = cell(table, row, `File${String(slot)}`)
+    if (value === '' || value === '0') continue
+    levels.push(await loadDs1(archives, value))
+  }
+  return levels
+}
+
+/**
+ * Read one of the five per-theme parameter groups.
+ *
+ * @param table - the `LvlSub` table.
+ * @param row - the row.
+ * @param prefix - `Prob`, `Trials` or `Max`.
+ * @returns the five values, in theme order.
+ */
+function themeValues(table: D2Table, row: readonly string[], prefix: string): number[] {
+  const values: number[] = []
+  for (let index = 0; index < 5; index += 1) values.push(Number(cell(table, row, `${prefix}${String(index)}`)) || 0)
+  return values
+}
+
+/* ------------------------------------------------------------------------- *
+ * Request builders
+ * ------------------------------------------------------------------------- */
+
+/** Which `LvlPrest` name families belong to which wilderness level type. */
+const WILDERNESS_PIECE_FAMILIES: Readonly<Record<string, readonly string[]>> = {
+  'Act 1 - Wilderness': ['Act 1 - Wild'],
+  'Act 2 - Desert': ['Act 2 - Desert'],
+  'Act 3 - Jungle': ['Act 3 - Jungle'],
+  'Act 3 - Kurast': ['Act 3 - Burst', 'Act 3 - Burbs', 'Act 3 - Clearing', 'Act 3 - Slums', 'Act 3 - Metro', 'Act 3 - Travincal'],
+  'Act 4 - Mesa': ['Act 4 - Mesa', 'Act 4 - Fortress', 'Act 4 - Pits', 'Act 4 - Bridge'],
+  'Act 4 - Lava': ['Act 4 - Lava', 'Act 4 - Diablo'],
+  'Act 5 - Siege': ['Act 5 - Siege'],
+  'Act 5 - Barricade': ['Act 5 - Barricade'],
+}
+
+/**
+ * Build the maze pieces for a level type.
+ *
+ * @param archives - the mounted archives.
+ * @param lvlprest - the `LvlPrest` table.
+ * @param levelTypeName - the level type's name.
+ * @param levelTypeId - the level type's id.
+ * @returns the pieces.
+ */
+async function mazePieces(
+  archives: MountedArchives,
+  lvlprest: D2Table,
+  levelTypeName: string,
+  levelTypeId: string,
+): Promise<MazePiece[]> {
+  const pieces: MazePiece[] = []
+  for (const row of lvlprest.rows) {
+    // Maze pieces are the rows whose level type matches; `LevelId` is 0 for all
+    // of them, so the join is by level type id plus the name prefix.
+    if (cell(lvlprest, row, 'LevelId') !== '0' && cell(lvlprest, row, 'LevelId') !== '') continue
+    const name = cell(lvlprest, row, 'Name')
+    const classified = classifyMazePieceName(name, levelTypeName)
+    if (classified === null) continue
+    const levels = await rowDs1s(archives, lvlprest, row)
+    if (levels.length === 0) continue
+    pieces.push({ name, kind: classified.kind satisfies MazePieceKind, sides: classified.sides, levels })
+  }
+  void levelTypeId
+  return pieces
+}
+
+/**
+ * Build the wilderness pieces for a level type.
+ *
+ * @param archives - the mounted archives.
+ * @param lvlprest - the `LvlPrest` table.
+ * @param levelTypeName - the level type's name.
+ * @returns the pieces.
+ */
+async function wildernessPieces(
+  archives: MountedArchives,
+  lvlprest: D2Table,
+  levelTypeName: string,
+): Promise<WildernessPiece[]> {
+  const families = WILDERNESS_PIECE_FAMILIES[levelTypeName] ?? []
+  const pieces: WildernessPiece[] = []
+  for (const row of lvlprest.rows) {
+    const name = cell(lvlprest, row, 'Name')
+    if (!families.some(family => name.startsWith(family))) continue
+    const levels = await rowDs1s(archives, lvlprest, row)
+    if (levels.length === 0) continue
+    pieces.push({ name, levels, border: /border|cliff/i.test(name) })
+  }
+  return pieces
+}
+
+/**
+ * Build the wilderness substitutions for a level's `LvlSub` type.
+ *
+ * @param archives - the mounted archives.
+ * @param lvlsub - the `LvlSub` table.
+ * @param type - the `LvlSub` `Type` to select.
+ * @returns the rows.
+ */
+async function substitutions(archives: MountedArchives, lvlsub: D2Table, type: number): Promise<WildernessSubstitution[]> {
+  if (type < 0) return []
+  const rows: WildernessSubstitution[] = []
+  for (const row of lvlsub.rows) {
+    if (Number(cell(lvlsub, row, 'Type')) !== type) continue
+    const file = cell(lvlsub, row, 'File')
+    if (file === '' || file === '0') continue
+    const levels = [await loadDs1(archives, file)]
+    rows.push({
+      name: cell(lvlsub, row, 'Name'),
+      type,
+      gridSize: Number(cell(lvlsub, row, 'GridSize')) || 1,
+      bordType: Number(cell(lvlsub, row, 'BordType')),
+      dt1Mask: Number(cell(lvlsub, row, 'Dt1Mask')) || 0,
+      prob: themeValues(lvlsub, row, 'Prob'),
+      trials: themeValues(lvlsub, row, 'Trials'),
+      max: themeValues(lvlsub, row, 'Max'),
+      levels,
+    })
+  }
+  return rows
+}
+
+/* ------------------------------------------------------------------------- *
+ * Hygiene
+ * ------------------------------------------------------------------------- */
+
+/** The generators that must stay browser-safe. */
+const BROWSER_SAFE_FILES = ['src/game/maze.ts', 'src/game/wilderness.ts']
+
+/**
+ * Assert the generators import nothing Node-only.
+ *
+ * `src/` is bundled for the browser, so a `node:fs` import or a `Buffer`
+ * reference would only fail once the page was loaded. Catching it here is cheap.
+ */
+function checkHygiene(): void {
+  for (const path of BROWSER_SAFE_FILES) {
+    const source = readFileSync(path, 'utf8')
+    check(!/from\s+['"]node:/.test(source), path, 'imports a node: builtin')
+    check(!/\bBuffer\b/.test(source), path, 'references Buffer')
+    check(!/Math\.random/.test(source), path, 'calls Math.random')
+    check(!/\bprocess\.env\b/.test(source), path, 'reads process.env')
+  }
+}
+
+/* ------------------------------------------------------------------------- *
+ * Main
+ * ------------------------------------------------------------------------- */
+
+checkHygiene()
+
+const archives = new MountedArchives()
+for (const name of MOUNTS) {
+  try {
+    archives.add(name, await MpqArchive.open(await fileSource(`${dir}/${name}`)))
+  } catch (err) {
+    console.log(`skip ${name}: ${String(err)}`)
+  }
+}
+if (archives.size === 0) {
+  console.log(`no archives found in ${dir}`)
+  process.exit(2)
+}
+
+const tables = await loadActTables(archives)
+const lvlmaze = parseTable(await archives.read('data\\global\\excel\\LvlMaze.txt'))
+const lvlsub = parseTable(await archives.read('data\\global\\excel\\LvlSub.txt'))
+
+/** The level type row for a level row. */
+function levelType(levelRow: readonly string[]): { id: string; name: string } {
+  const id = cell(tables.levels, levelRow, 'LevelType')
+  const row = tables.lvltypes.rows.find(candidate => cell(tables.lvltypes, candidate, 'Id') === id)
+  return { id, name: row === undefined ? '' : cell(tables.lvltypes, row, 'Name') }
+}
+
+/** The `LvlMaze` row for a level, by id then by name. */
+function mazeRow(levelId: number, levelName: string): readonly string[] | undefined {
+  return lvlmaze.rows.find(row => Number(cell(lvlmaze, row, 'Level')) === levelId)
+    ?? lvlmaze.rows.find(row => cell(lvlmaze, row, 'Name') === levelName)
+}
+
+const mazeLevels: { id: number; name: string }[] = []
+const wildLevels: { id: number; name: string }[] = []
+for (const row of tables.levels.rows) {
+  const drlg = cell(tables.levels, row, 'DrlgType')
+  const id = Number(cell(tables.levels, row, 'Id'))
+  const name = cell(tables.levels, row, 'Name')
+  if (drlg === '1') mazeLevels.push({ id, name })
+  else if (drlg === '3') wildLevels.push({ id, name })
+}
+
+console.log(`== generators ==`)
+console.log(`   ${String(mazeLevels.length)} maze levels (DrlgType 1), ${String(wildLevels.length)} wilderness levels (DrlgType 3)`)
+
+let mazePassed = 0
+let wildPassed = 0
+
+console.log(`\n== maze levels (DrlgType 1) ==`)
+console.log('   id  name                          type                 sect  rooms  map        hash      reach  missing')
+for (const { id, name } of mazeLevels) {
+  const label = `${String(id)} ${name}`
+  try {
+    const row = mazeRow(id, name)
+    if (row === undefined) throw new Error('no LvlMaze.txt row')
+    const type = levelType(tables.levels.rows.find(candidate => Number(cell(tables.levels, candidate, 'Id')) === id)!)
+    const sectionX = Number(cell(lvlmaze, row, 'SizeX'))
+    const sectionY = Number(cell(lvlmaze, row, 'SizeY'))
+    const minRooms = Number(cell(lvlmaze, row, 'Rooms'))
+    const merge = Number(cell(lvlmaze, row, 'Merge'))
+    const pieces = await mazePieces(archives, tables.lvlprest, type.name, type.id)
+    const seed = 0x5eed_0000 + id
+    const request = {
+      levelId: id, levelName: name, levelTypeName: type.name,
+      sectionSize: sectionX, sectionHeight: sectionY,
+      minRooms, merge, seed, pieces,
+    }
+    const first = generateMaze(request)
+    const second = generateMaze(request)
+    const hashA = canonicalHash(first.level)
+    const hashB = canonicalHash(second.level)
+    const libraries = resolveLevelLibraries(tables, id)
+    const scene = buildIsoMapScene(first.level, await decodeLibraries(archives, libraries.dt1Names), levelSeed(libraries.dt1Names[0] ?? "generated"))
+    const totalRefs = scene.floors.length + scene.walls.length + scene.missingTiles
+    const missingShare = totalRefs === 0 ? 1 : scene.missingTiles / totalRefs
+    const fill = connectivity(first.level, scene)
+
+    check(hashA === hashB, label, `not deterministic (${hashA} vs ${hashB})`)
+    check(pieces.length > 0, label, 'no pieces resolved')
+    check(first.level.width > 0 && first.level.height > 0, label, 'empty map')
+    check(first.level.width <= MAX_CELLS_PER_SIDE && first.level.height <= MAX_CELLS_PER_SIDE, label, `map ${String(first.level.width)}x${String(first.level.height)} exceeds the side bound`)
+    check(Number(first.stats.sectionX) === sectionX && Number(first.stats.sectionY) === sectionY, label, `section size ${String(first.stats.sectionX)}x${String(first.stats.sectionY)} != LvlMaze ${String(sectionX)}x${String(sectionY)}`)
+    check(Number(first.stats.roomsPlaced) >= minRooms, label, `placed ${String(first.stats.roomsPlaced)} sections, LvlMaze.Rooms is ${String(minRooms)}`)
+    check(missingShare <= MAX_MISSING_SHARE, label, `${(missingShare * 100).toFixed(2)}% of tile references are missing`)
+    check(fill.share >= MIN_REACHABLE_SHARE, label, `only ${(fill.share * 100).toFixed(1)}% of walkable areas are reachable (${String(fill.reached)}/${String(fill.total)})`)
+    if (hashA === hashB && fill.share >= MIN_REACHABLE_SHARE && missingShare <= MAX_MISSING_SHARE) mazePassed += 1
+
+    console.log(`   ${String(id).padStart(3)} ${name.padEnd(29)} ${type.name.padEnd(20)} ${String(sectionX).padStart(4)} ${String(Number(first.stats.roomsPlaced)).padStart(6)}  ${`${String(first.level.width)}x${String(first.level.height)}`.padEnd(10)} ${hashA}  ${(fill.share * 100).toFixed(1).padStart(5)}%  ${(missingShare * 100).toFixed(2).padStart(6)}%`)
+  } catch (err) {
+    check(false, label, `threw: ${err instanceof Error ? err.message : String(err)}`)
+    console.log(`   ${String(id).padStart(3)} ${name.padEnd(29)} FAILED: ${err instanceof Error ? err.message : String(err)}`)
+  }
+}
+
+console.log(`\n== wilderness levels (DrlgType 3) ==`)
+console.log('   id  name                          type                 size       blocks   hash      reach  missing')
+for (const { id, name } of wildLevels) {
+  const label = `${String(id)} ${name}`
+  try {
+    const levelRow = tables.levels.rows.find(candidate => Number(cell(tables.levels, candidate, 'Id')) === id)!
+    const type = levelType(levelRow)
+    const sizeX = Number(cell(tables.levels, levelRow, 'SizeX'))
+    const sizeY = Number(cell(tables.levels, levelRow, 'SizeY'))
+    const subType = Number(cell(tables.levels, levelRow, 'SubType'))
+    const subShrine = Number(cell(tables.levels, levelRow, 'SubShrine'))
+    const subTheme = Number(cell(tables.levels, levelRow, 'SubTheme'))
+    const pieces = await wildernessPieces(archives, tables.lvlprest, type.name)
+    const rows = await substitutions(archives, lvlsub, subType)
+    const shrineRows = await substitutions(archives, lvlsub, subShrine)
+    const seed = 0x5eed_1000 + id
+    const request = {
+      levelId: id, levelName: name, levelTypeName: type.name,
+      sizeX, sizeY, subType, subTheme: Math.max(0, subTheme), seed,
+      pieces, substitutions: rows, shrineSubstitutions: shrineRows,
+    }
+    const first = generateWilderness(request)
+    const second = generateWilderness(request)
+    const hashA = canonicalHash(first.level)
+    const hashB = canonicalHash(second.level)
+    const libraries = resolveLevelLibraries(tables, id)
+    const dt1s = await decodeLibraries(archives, libraries.dt1Names)
+    const scene = buildIsoMapScene(first.level, dt1s, levelSeed("generated"))
+    const totalRefs = scene.floors.length + scene.walls.length + scene.missingTiles
+    const missingShare = totalRefs === 0 ? 1 : scene.missingTiles / totalRefs
+    const fill = connectivity(first.level, scene)
+
+    const blockGrid = first.stats.blockGrid as { width: number; height: number }
+    const expectedWidth = Number(first.stats.sizeX)
+    const expectedHeight = Number(first.stats.sizeY)
+    const expectedBlocksX = Math.floor(expectedWidth / AREA_CELLS)
+    const expectedBlocksY = Math.floor(expectedHeight / AREA_CELLS)
+
+    check(hashA === hashB, label, `not deterministic (${hashA} vs ${hashB})`)
+    check(pieces.length > 0, label, 'no pieces resolved')
+    check(first.level.width > 0 && first.level.height > 0, label, 'empty map')
+    check(first.level.width <= MAX_CELLS_PER_SIDE && first.level.height <= MAX_CELLS_PER_SIDE, label, `map ${String(first.level.width)}x${String(first.level.height)} exceeds the side bound`)
+    check(blockGrid.width === expectedBlocksX && blockGrid.height === expectedBlocksY, label, `block grid ${String(blockGrid.width)}x${String(blockGrid.height)} != floor(size/8) ${String(expectedBlocksX)}x${String(expectedBlocksY)}`)
+    check(first.level.width === expectedBlocksX * AREA_CELLS && first.level.height === expectedBlocksY * AREA_CELLS, label, 'map extent does not match whole blocks of the declared size')
+    check(missingShare <= MAX_MISSING_SHARE, label, `${(missingShare * 100).toFixed(2)}% of tile references are missing`)
+    check(fill.share >= MIN_REACHABLE_SHARE, label, `only ${(fill.share * 100).toFixed(1)}% of walkable areas are reachable (${String(fill.reached)}/${String(fill.total)})`)
+    if (hashA === hashB && fill.share >= MIN_REACHABLE_SHARE && missingShare <= MAX_MISSING_SHARE) wildPassed += 1
+
+    console.log(`   ${String(id).padStart(3)} ${name.padEnd(29)} ${type.name.padEnd(20)} ${`${String(first.stats.sizeX)}x${String(first.stats.sizeY)}`.padEnd(10)} ${`${String(blockGrid.width)}x${String(blockGrid.height)}`.padEnd(8)} ${hashA}  ${(fill.share * 100).toFixed(1).padStart(5)}%  ${(missingShare * 100).toFixed(2).padStart(6)}%`)
+  } catch (err) {
+    check(false, label, `threw: ${err instanceof Error ? err.message : String(err)}`)
+    console.log(`   ${String(id).padStart(3)} ${name.padEnd(29)} FAILED: ${err instanceof Error ? err.message : String(err)}`)
+  }
+}
+
+console.log(`\n== summary ==`)
+console.log(`   maze       ${String(mazePassed)}/${String(mazeLevels.length)} passed`)
+console.log(`   wilderness ${String(wildPassed)}/${String(wildLevels.length)} passed`)
+console.log(`   checks     ${String(checks - failures)}/${String(checks)} assertions held`)
+if (failures > 0) {
+  console.log(`\n   ${String(failures)} failure(s):`)
+  for (const reason of failureReasons.slice(0, 60)) console.log(`     - ${reason}`)
+  if (failureReasons.length > 60) console.log(`     ... and ${String(failureReasons.length - 60)} more`)
+  process.exit(1)
+}
+console.log('\nall generator checks passed')
diff --git a/scripts/verify-implode.ts b/scripts/verify-implode.ts
new file mode 100644
index 0000000..57c2826
--- /dev/null
+++ b/scripts/verify-implode.ts
@@ -0,0 +1,152 @@
+/**
+ * End-to-end check of the MPQ decoders against the real Diablo II archives.
+ *
+ * The whole point of this script is that it refuses to grade its own homework:
+ * every assertion is about bytes that came out of a Blizzard archive the user
+ * supplied, not about a fixture we also generated.
+ *
+ * Usage:
+ *   node scripts/verify-implode.ts [directory] [--quick] [--archive <name>]
+ *
+ * Exits non-zero when a codec this project claims to implement fails on real
+ * data. Codecs it does not implement yet (ADPCM/Huffmann audio, bzip2, sparse)
+ * are reported as *unimplemented*, with counts — never silently ignored, and
+ * never counted as a pass.
+ */
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { fileSource } from '../src/mpq/file-source.ts'
+import { COMPRESSION_PKWARE } from '../src/mpq/decompress.ts'
+
+const args = process.argv.slice(2)
+const dir = args.find((a) => !a.startsWith('--')) ?? 'samples/d2'
+const quick = args.includes('--quick')
+const only = args.flatMap((a, i) => (a === '--archive' ? [args[i + 1] ?? ''] : []))
+/** Cap per archive in `--quick` mode, so the script is usable in a loop. */
+const QUICK_LIMIT = 400
+
+/** Archives this project cares about, in mount order. */
+const ARCHIVES = ['d2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq', 'd2char.mpq']
+
+/** Raised classification of one member failure. */
+type FailureKind = 'implode' | 'unimplemented-codec' | 'missing-key' | 'other'
+
+/**
+ * Classify a member read failure.
+ *
+ * @param err - the thrown error.
+ * @returns the kind, plus a label for the report.
+ */
+function classify(err: unknown): { kind: FailureKind; label: string } {
+  const mask = (err as { mask?: unknown }).mask
+  const message = String((err as { message?: unknown }).message ?? err)
+  if (typeof mask === 'number') {
+    if (mask === COMPRESSION_PKWARE) return { kind: 'implode', label: 'pkware implode' }
+    const names: string[] = []
+    if (mask & 0x01) names.push('huffmann')
+    if (mask & 0x10) names.push('bzip2')
+    if (mask & 0x20) names.push('sparse')
+    if (mask & 0x40) names.push('adpcm-mono')
+    if (mask & 0x80) names.push('adpcm-stereo')
+    return { kind: 'unimplemented-codec', label: `mask 0x${mask.toString(16)} (${names.join('+') || 'unknown'})` }
+  }
+  if (/reversed extent|beyond/.test(message)) return { kind: 'missing-key', label: 'unnamed encrypted member (no name → no key)' }
+  return { kind: 'other', label: message.slice(0, 70) }
+}
+
+let checks = 0
+let hardFailures = 0
+let totalMembers = 0
+let totalBytes = 0
+const unimplemented = new Map<string, number>()
+
+/**
+ * Assert one expectation.
+ *
+ * @param ok - whether it held.
+ * @param message - what was checked.
+ */
+function check(ok: boolean, message: string): void {
+  checks += 1
+  if (!ok) hardFailures += 1
+  console.log(`   ${ok ? 'ok  ' : 'FAIL'} ${message}`)
+}
+
+const wanted = only.length > 0 ? only : ARCHIVES
+console.log(`== real archives in ${dir} (${String(wanted.length)} selected) ==`)
+
+for (const name of wanted) {
+  const path = `${dir}/${name}`
+  let archive: MpqArchive
+  try {
+    archive = await MpqArchive.open(await fileSource(path))
+  } catch (err) {
+    console.log(`\n-- ${name}\n   skip: ${String(err)}`)
+    continue
+  }
+  const names = await archive.nameIndex()
+  let files = archive.files(names)
+  if (quick && files.length > QUICK_LIMIT) files = files.slice(0, QUICK_LIMIT)
+
+  let ok = 0
+  let bytes = 0
+  const local = new Map<string, number>()
+  for (const file of files) {
+    try {
+      const decoded = await archive.read(file)
+      ok += 1
+      bytes += decoded.byteLength
+    } catch (err) {
+      const { kind, label } = classify(err)
+      if (kind === 'implode' || kind === 'other') hardFailures += 1
+      if (kind === 'unimplemented-codec') unimplemented.set(label, (unimplemented.get(label) ?? 0) + 1)
+      local.set(`${kind === 'missing-key' ? 'no-key' : kind}: ${label}`, (local.get(`${kind === 'missing-key' ? 'no-key' : kind}: ${label}`) ?? 0) + 1)
+    }
+  }
+  totalMembers += files.length
+  totalBytes += bytes
+  console.log(`\n-- ${name}`)
+  console.log(`   members  ${String(ok)}/${String(files.length)} decoded, ${(bytes / 1048576).toFixed(1)} MB out of ${(archive.header.archiveSize / 1048576).toFixed(1)} MB on disk`)
+  for (const [label, count] of [...local].sort((a, b) => b[1] - a[1])) {
+    const kind = label.startsWith('implode') || label.startsWith('other') ? 'FAIL' : 'info'
+    console.log(`   ${kind.padEnd(4)} ${String(count).padStart(5)}  ${label}`)
+  }
+  console.log(`   names    ${String(archive.files().length - names.size)} of ${String(archive.files().length)} block slots have no name`)
+  check(ok > 0, `${name}: at least one member decoded`)
+
+  // Content assertions: a decoder that produces the right *length* but the wrong
+  // bytes would still be useless, so look for known strings in known members.
+  const levels = archive.find('data\\global\\excel\\levels.txt')
+  if (levels !== undefined) {
+    const text = Buffer.from(await archive.read(levels)).toString('latin1')
+    check(text.includes('LevelName'), `${name}: levels.txt decodes to a real header row`)
+    check(text.includes('Act 1 - Town'), `${name}: levels.txt names the Act 1 town`)
+  }
+  if (name === 'd2data.mpq') {
+    const count = names.size
+    check(count > 10_000, `d2data.mpq: (listfile) decodes to ${String(count)} names`)
+  }
+  if (name === 'd2char.mpq') {
+    const so = archive.find('data\\global\\chars\\so\\hd\\sohdbhma11hs.dcc')
+    if (so !== undefined) {
+      const head = await archive.read(so)
+      check(
+        head[0] === 0x74 && head[1] === 0x06 && head[2] === 0x10 && head[3] === 0x14,
+        'd2char.mpq: a Sorceress DCC begins with the DCC signature',
+      )
+    }
+  }
+}
+
+console.log('\n== summary ==')
+console.log(`   ${String(totalMembers)} members read, ${(totalBytes / 1048576).toFixed(1)} MB decoded`)
+if (unimplemented.size > 0) {
+  console.log('   not implemented yet (reported, not counted as pass):')
+  for (const [label, count] of [...unimplemented].sort((a, b) => b[1] - a[1])) {
+    console.log(`      ${String(count).padStart(5)}  ${label}`)
+  }
+}
+console.log(`   ${String(checks - hardFailures)}/${String(checks)} assertions passed`)
+if (hardFailures > 0) {
+  console.log(`   ${String(hardFailures)} hard failures: a codec that claims to work did not`)
+  process.exit(1)
+}
diff --git a/scripts/verify-items.ts b/scripts/verify-items.ts
new file mode 100644
index 0000000..175d05a
--- /dev/null
+++ b/scripts/verify-items.ts
@@ -0,0 +1,193 @@
+/**
+ * M3 item checks: tables, affix rolling, inventory and drops, headless.
+ *
+ * Item systems fail in ways that are tedious to catch by playing: an affix that
+ * rolls on a type it should not, a stack that silently discards a potion, an
+ * item that occupies cells it never clears, or a drop table that is not
+ * reproducible. Each of those is a plain assertion here instead.
+ *
+ * Usage: node scripts/verify-items.ts
+ */
+import {
+  Inventory, affixEligible, affixesFromTable, createItem, goldItem, itemBasesFromTable,
+  rollAffix, rollDrop, totalStat,
+} from '../src/game/items.ts'
+import type { Affix, ItemBase } from '../src/game/items.ts'
+import { Rng } from '../src/game/rng.ts'
+import { parseTable } from '../src/game/tables.ts'
+
+const problems: string[] = []
+let checks = 0
+
+/**
+ * Assert one condition.
+ *
+ * @param condition - the condition to hold.
+ * @param description - what it means.
+ */
+function expect(condition: boolean, description: string): void {
+  checks += 1
+  if (!condition) problems.push(description)
+}
+
+// --- tables -----------------------------------------------------------------
+
+const weapons = itemBasesFromTable(parseTable([
+  'Id\tName\tType\tInvWidth\tInvHeight\tDamage\tValue\tLevel\tMaxStack',
+  'swd\tShort Sword\tweap\t1\t3\t5\t30\t1\t1',
+  'bsc\tBuckler\tarmo\t2\t2\t\t12\t1\t1\t\t',
+  'lsw\tLong Sword\tweap\t1\t3\t12\t120\t8\t1',
+  'axe\tHand Axe\tweap\t1\t3\t8\t60\t\t1',
+].join('\n')), 'weapon')
+expect(weapons.length === 4, 'every weapon row becomes a base')
+expect(weapons[0]?.invWidth === 1 && weapons[0]?.invHeight === 3, 'footprints come from the table')
+expect(weapons[1]?.damage === 0, 'a missing damage cell becomes zero, not NaN')
+expect(weapons[2]?.level === 8, 'level gates are read')
+expect(weapons[3]?.level === 1, 'a missing level falls back to 1')
+expect(weapons[0]?.tags.includes('weap') === true, 'the type column becomes the tag list')
+
+const misc = itemBasesFromTable(parseTable([
+  'Id\tName\tType\tInvWidth\tInvHeight\tMaxStack\tValue',
+  'hp1\tMinor Healing Potion\tmisc\t1\t1\t5\t20',
+].join('\n')), 'misc')
+expect(misc[0]?.maxStack === 5, 'stack limits come from the table')
+
+const prefixes = affixesFromTable(parseTable([
+  'Id\tName\tLevel\titype1\titype2\tmod1code\tmod1min\tmod1max\tmod2code\tmod2min\tmod2max',
+  'cruel\tCruel\t12\tweap\t\tmaxdamage\t30\t40\t\t\t',
+  'sturdy\tSturdy\t3\tarmo\t\tdefense\t5\t9\t\t\t',
+  'fine\tFine\t5\tweap\tarmo\tmaxdamage\t2\t4\tdefense\t1\t3',
+  'nomod\tBroken Row\t1\tweap\t\t\t\t\t\t\t',   // no modifier: must be skipped
+].join('\r\n')), 'prefix')
+expect(prefixes.length === 3, 'rows without a modifier are skipped')
+expect(prefixes[0]?.modifiers.length === 1, 'a single modifier is read')
+expect(prefixes[1]?.itemTypes.join(',') === 'armo', 'itype columns build the type list')
+expect(prefixes[2]?.modifiers.length === 2, 'two modifier slots are read')
+
+const suffixes = affixesFromTable(parseTable([
+  'Id\tName\tLevel\titype1\tmod1code\tmod1min\tmod1max',
+  'of_might\tof Might\t5\tweap\tstrength\t2\t5',
+  'of_the_fox\tof the Fox\t3\t\tdexterity\t1\t3',   // no itype: any item
+].join('\n')), 'suffix')
+expect(suffixes[1]?.itemTypes.length === 0, 'an affix with no itype applies to anything')
+
+// --- eligibility ------------------------------------------------------------
+
+const sword = weapons[0]!
+const buckler = weapons[1]!
+const longSword = weapons[2]!
+expect(affixEligible(prefixes[0]!, sword, 12), 'a weapon affix fits a weapon at its level')
+expect(!affixEligible(prefixes[0]!, sword, 11), 'an affix above the item level is refused')
+expect(!affixEligible(prefixes[0]!, buckler, 20), 'a weapon affix is refused by armor')
+expect(affixEligible(prefixes[1]!, buckler, 3), 'an armor affix fits armor')
+expect(affixEligible(suffixes[1]!, buckler, 10), 'an unrestricted affix fits any base')
+
+// --- rolling ----------------------------------------------------------------
+
+const rollWith = (seed: number): string => {
+  const rolled = rollAffix(prefixes, sword, 20, new Rng(seed))
+  return JSON.stringify(rolled)
+}
+expect(rollWith(7) === rollWith(7), 'the same seed rolls the same affix and the same numbers')
+const rollVariety = new Set([1, 2, 3, 4, 5, 6, 7, 8].map(rollWith))
+expect(rollVariety.size > 1, 'different seeds roll differently')
+const rolled = rollAffix(prefixes, sword, 20, new Rng(3))
+expect(rolled !== null && rolled.rolls.length === rolled.affix.modifiers.length, 'each modifier gets a roll')
+expect(rolled !== null && rolled.rolls.every(r => r.max >= r.min && r.max <= (r as { max: number }).max), 'rolls stay inside the affix range')
+const neverEligible = rollAffix([prefixes[1]!], sword, 20, new Rng(1))
+expect(neverEligible === null, 'no eligible affix rolls nothing rather than an illegal one')
+
+// --- item construction ------------------------------------------------------
+
+// Only one suffix is eligible here, so "the modifier shows up as a stat" is a
+// statement about the pipeline rather than about which affix the seed picked.
+const might = suffixes.find(affix => affix.id === 'of_might')!
+const item = createItem(sword, prefixes, [might], new Rng(11), { level: 20, prefixChance: 1, suffixChance: 1 })
+expect(item.prefix !== null && item.suffix !== null, 'forced chances produce both affixes')
+expect(item.name === `${item.prefix!.name} ${sword.name} ${item.suffix!.name}`, 'the name is prefix + base + suffix')
+expect((item.stats.damage ?? 0) >= sword.damage, 'base damage survives into the stats')
+expect((item.stats.strength ?? 0) >= 2, 'affix modifiers appear as stats')
+expect(item.suffix?.id === 'of_might', 'the only eligible suffix is the one rolled')
+expect(item.value > sword.value, 'an affixed item is worth more than its base')
+
+const plain = createItem(sword, prefixes, suffixes, new Rng(11), { level: 20, prefixChance: 0, suffixChance: 0 })
+expect(plain.prefix === null && plain.suffix === null, 'zero chances roll no affixes')
+expect(plain.name === sword.name, 'a plain item is named after its base')
+
+const potion = misc[0]!
+const stacked = createItem(potion, prefixes, suffixes, new Rng(1), { level: 1, prefixChance: 0, suffixChance: 0, stack: 99 })
+expect(stacked.stack === potion.maxStack, 'a stack cannot exceed the base limit')
+
+// --- inventory --------------------------------------------------------------
+
+const bag = new Inventory(4, 3)
+expect(bag.totalCells === 12 && bag.usedCells === 0, 'a new inventory is empty')
+expect(bag.canPlace(1, 3, 0, 0), 'a tall item fits where there is room')
+expect(!bag.canPlace(1, 3, 0, 1), 'an item that would leave the grid is refused')
+expect(bag.canPlace(4, 1, 0, 0), 'an item exactly as wide as the grid fits')
+expect(!bag.canPlace(5, 1, 0, 0), 'an item wider than the grid is refused')
+
+const placedSword = bag.add(item)
+expect(placedSword !== null, 'an item can be added')
+expect(bag.usedCells === 3, 'adding occupies the item footprint')
+expect(!bag.canPlace(1, 1, 0, 0), 'occupied cells refuse other items')
+expect(bag.add(plain) !== null, 'a second item finds the next free slot')
+expect(bag.contents.length === 2, 'both items are tracked')
+
+// stacking onto an existing pile, with the remainder in a new slot
+const potionBag = new Inventory(4, 2)
+const firstPotion = potionBag.add(createItem(potion, prefixes, suffixes, new Rng(2), { level: 1, prefixChance: 0, suffixChance: 0, stack: 3 }))
+expect(firstPotion !== null, 'the first pile lands')
+const secondPotion = potionBag.add(createItem(potion, prefixes, suffixes, new Rng(2), { level: 1, prefixChance: 0, suffixChance: 0, stack: 4 }))
+expect(secondPotion !== null, 'the second pile lands somewhere')
+expect(potionBag.contents.length === 2, 'a stack that overflows opens a second slot instead of discarding')
+const totalPotions = potionBag.contents.reduce((sum, entry) => sum + entry.item.stack, 0)
+expect(totalPotions === 7, 'no potion is lost across the overflow')
+
+const removed = bag.remove(placedSword!)
+expect(removed && bag.usedCells === 3, `removing an item clears exactly its cells (used ${String(bag.usedCells)})`)
+expect(bag.canPlace(1, 3, 0, 0), 'the freed cells can be reused')
+
+const tiny = new Inventory(1, 1)
+expect(tiny.add(item) === null, 'an item with no room is refused rather than dropped silently')
+expect(tiny.add(goldItem(100)) !== null, 'gold fits where the sword did not')
+expect(tiny.gold === 100, 'gold is summed from its piles')
+
+const goldBag = new Inventory(2, 1)
+goldBag.add(goldItem(4000))
+goldBag.add(goldItem(4000))
+expect(goldBag.gold === 8000, 'gold piles stack up to their limit and spill into another slot')
+
+// --- drops ------------------------------------------------------------------
+
+const bases = [...weapons, potion]
+const dropOptions = { level: 10, dropChance: 1, goldChance: 0, goldRange: [10, 20] as const }
+const runDrops = (seed: number): string => JSON.stringify(
+  Array.from({ length: 8 }, (_, index) => rollDrop(bases, prefixes, suffixes, new Rng(seed + index), dropOptions)),
+)
+expect(runDrops(5) === runDrops(5), 'the same seed produces the same drops')
+expect(new Set([1, 2, 3, 4, 5, 6].map(runDrops)).size > 1, 'different seeds produce different drops')
+
+expect(rollDrop(bases, prefixes, suffixes, new Rng(1), { ...dropOptions, dropChance: 0 }).kind === 'nothing', 'a zero drop chance drops nothing')
+expect(rollDrop(bases, prefixes, suffixes, new Rng(1), { ...dropOptions, dropChance: 1 }).kind === 'item', 'a guaranteed drop is an item')
+const goldDrop = rollDrop(bases, prefixes, suffixes, new Rng(1), { ...dropOptions, goldChance: 1 })
+expect(goldDrop.kind === 'gold' && goldDrop.amount >= 10 && goldDrop.amount <= 20, 'gold drops inside its range')
+
+// An item level below every base's requirement still has to yield something.
+const lowLevelDrops = Array.from({ length: 12 }, (_, index) =>
+  rollDrop([longSword], prefixes, suffixes, new Rng(100 + index), { ...dropOptions, level: 1 }))
+expect(lowLevelDrops.every(drop => drop.kind === 'item'), 'a table with no base under the level still drops the base it has')
+
+// --- derived stats ----------------------------------------------------------
+
+const sheet = new Inventory(4, 4)
+const armour: ItemBase = { ...buckler, defense: 12, tags: ['armo'] }
+sheet.add(createItem(armour, prefixes, suffixes, new Rng(4), { level: 20, prefixChance: 1, suffixChance: 0 }))
+const defence = totalStat(sheet.contents, 'defense')
+expect(defence >= 12, 'worn armor contributes its defense to the character sheet')
+
+console.log(`checks     ${String(checks)}`)
+console.log(`problems   ${String(problems.length)}`)
+for (const problem of problems.slice(0, 12)) console.log(`  - ${problem}`)
+console.log(problems.length === 0 ? 'RESULT     item behaviours hold' : 'RESULT     FAILED')
+process.exit(problems.length === 0 ? 0 : 1)
diff --git a/scripts/verify-listfile.ts b/scripts/verify-listfile.ts
new file mode 100644
index 0000000..bee6edb
--- /dev/null
+++ b/scripts/verify-listfile.ts
@@ -0,0 +1,90 @@
+// verify-listfile.ts — 用社区 listfile 把"归档里到底有没有这个成员"变成可判定的事实
+//
+// 背景：`d2data.mpq`/`Patch_D2.mpq` 都没有 `(listfile)`，Storm 的名字是**加密存的**，所以
+// 原先 `listFiles()` 只能对能列目录的归档给出名字。1.13c 的社区 listfile
+// （`samples/d2/listfile_113c.txt`，39551 行）补齐了这一点：拿它的每个名字去归档里做
+// hash 查找，查到就是真成员。`MpqArchive.open` 的 `listfile` 选项就是为此存在的。
+//
+//   node scripts/verify-listfile.ts [--dir=samples/d2]
+//
+// 退出码非 0 表示有断言没过。
+
+export {}
+
+import { readFileSync } from 'node:fs'
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { fileSource } from '../src/mpq/file-source.ts'
+
+/** 归档目录，`--dir=` 可覆盖。 */
+const DIR = process.argv.find(argument => argument.startsWith('--dir='))?.slice('--dir='.length) ?? 'samples/d2'
+/** listfile 文件（社区提供，1.13c）。 */
+const LISTFILE = `${DIR}/listfile_113c.txt`
+
+/** 断言结果。 */
+const checks: { name: string; ok: boolean; detail: string }[] = []
+
+/**
+ * 记录一条断言。
+ *
+ * @param name - what was checked.
+ * @param ok - whether it held.
+ * @param detail - evidence.
+ */
+function check(name: string, ok: boolean, detail: string): void {
+  checks.push({ name, ok, detail })
+  console.log(`${ok ? 'ok  ' : 'FAIL'} ${name} — ${detail}`)
+}
+
+/**
+ * 主流程：读 listfile，逐个归档做名字解析，最后核对物体美术的结论。
+ */
+async function main(): Promise<void> {
+  const names = readFileSync(LISTFILE, 'utf8').split(/\r?\n/).map(line => line.trim()).filter(line => line.length > 0)
+  const lower = new Set(names.map(name => name.toLowerCase()))
+  check('listfile 非空', names.length > 30000, `${String(names.length)} 行`)
+  check('listfile 去重后无重复', lower.size === names.length, `${String(lower.size)} 个不同名字`)
+  check('listfile 带 (listfile) 自身', lower.has('(listfile)'), '社区 listfile 保留了归档管理成员')
+
+  /** 每个归档期望的最低命中数，来自实测；低于它说明 listfile 或归档换了版本。 */
+  const expectations: Record<string, { min: number; objects: number }> = {
+    'Patch_D2.mpq': { min: 200, objects: 0 },
+    'd2data.mpq': { min: 10700, objects: 2400 },
+    'd2exp.mpq': { min: 9800, objects: 800 },
+  }
+
+  const resolvedByArchive = new Map<string, string[]>()
+  for (const [file, want] of Object.entries(expectations)) {
+    const archive = await MpqArchive.open(await fileSource(`${DIR}/${file}`), { listfile: names })
+    const found = names.filter(name => archive.find(name) !== undefined)
+    resolvedByArchive.set(file, found)
+    const objects = found.filter(name => /objects[\\/]/i.test(name))
+    console.log(`\n=== ${file} ===`)
+    check(`${file} 名字命中数 ≥ ${String(want.min)}`, found.length >= want.min,
+      `${String(found.length)} / ${String(names.length)}`)
+    check(`${file} objects 成员数 ≈ ${String(want.objects)}`, Math.abs(objects.length - want.objects) <= 20,
+      `${String(objects.length)} 个 objects 成员`)
+  }
+
+  // 1.13c 的关卡表就在 Patch_D2 里：解析器读的就是这些名字，名字错一个字节就全盘皆错。
+  const patch = await MpqArchive.open(await fileSource(`${DIR}/Patch_D2.mpq`), { listfile: names })
+  for (const table of ['Levels.txt', 'LvlMaze.txt', 'LvlPrest.txt', 'LvlSub.txt', 'LvlTypes.txt']) {
+    const member = `data\\global\\excel\\${table}`
+    const file = patch.find(member)
+    check(`Patch_D2 有 ${table}`, file !== undefined, file === undefined ? '未找到' : `${String(file.fileSize)} 字节`)
+  }
+  console.log(`\n   Patch_D2 里 objects 目录：${String((resolvedByArchive.get('Patch_D2.mpq') ?? []).filter(name => /objects[\\/]/i.test(name)).length)}`
+    + '（补丁归档不含可破坏物品美术，这是实测结论而不是猜测）')
+
+  // 物体美术的关键结论：哪些 token 在全部归档里根本没有美术。
+  const all = [...resolvedByArchive.values()].flat()
+  for (const [token, expected] of [['9b', 4], ['tp', 12], ['ta', 0]] as const) {
+    const hits = all.filter(name => new RegExp(`objects[\\\\/]${token}[\\\\/]`, 'i').test(name))
+    check(`token ${token.toUpperCase()} 的成员数 = ${String(expected)}`, hits.length === expected, `${String(hits.length)} 个`)
+  }
+
+  const passed = checks.filter(entry => entry.ok).length
+  console.log(`\n${String(passed)}/${String(checks.length)} passed`)
+  if (passed !== checks.length) process.exitCode = 1
+}
+
+await main()
diff --git a/scripts/verify-m4.ts b/scripts/verify-m4.ts
new file mode 100644
index 0000000..dab658e
--- /dev/null
+++ b/scripts/verify-m4.ts
@@ -0,0 +1,185 @@
+/**
+ * M4 checks: skills, projectiles, quests, NPC dialogue, headless.
+ *
+ * Skills and quests are state machines with resource gates, and both fail in ways
+ * that are annoying to notice by playing: a skill that fires while on cooldown, a
+ * projectile that passes through a wall, a quest that counts the wrong monster or
+ * rewards twice, an NPC that offers a quest already in progress. Each is an
+ * assertion here.
+ *
+ * Name resolution is checked too: tables address strings by index into a `.tbl`,
+ * and the fallback (a literal cell, or no `.tbl` at all) has to keep working —
+ * that is the path a real archive takes while the TBL decoder is still unproven
+ * against shipped files.
+ *
+ * Usage: node scripts/verify-m4.ts
+ */
+import { parseTable, resolveText, textSourceOf } from '../src/game/tables.ts'
+import { castSkill, skillDamageAt, skillsFromTable, tickProjectiles } from '../src/game/skills.ts'
+import type { Projectile, ProjectileTarget, SkillDef } from '../src/game/skills.ts'
+import { QuestLog, npcDialog, npcsFromTable, questsFromTable } from '../src/game/quests.ts'
+import { Rng } from '../src/game/rng.ts'
+
+const problems: string[] = []
+let checks = 0
+
+/**
+ * Assert one condition.
+ *
+ * @param condition - the condition to hold.
+ * @param description - what it means.
+ */
+function expect(condition: boolean, description: string): void {
+  checks += 1
+  if (!condition) problems.push(description)
+}
+
+// A tiny string table, as if decoded from a real `.tbl`.
+const strings = textSourceOf(['', 'Fire Bolt', 'Ice Blast', 'Deckard Cain', 'Kill the fallen', 'Slay the fallen'])
+expect(resolveText('1', strings) === 'Fire Bolt', 'a numeric cell resolves through the string table')
+expect(resolveText('Fire Bolt', strings) === 'Fire Bolt', 'a literal cell passes through unchanged')
+expect(resolveText('99', strings) === '99', 'an index the table does not have stays as written')
+const noTable = textSourceOf(null)
+expect(resolveText('7', noTable) === '7', 'with no table loaded, indices stay literal')
+
+// --- skills -----------------------------------------------------------------
+
+const skills = skillsFromTable(parseTable([
+  'Id\tName\tManaCost\tCooldownTicks\tRange\tSpeed\tMinDam\tMaxDam\tPerLevel\tRadius',
+  'firebolt\t1\t5\t8\t240\t300\t6\t9\t3\t20',
+  'frostnova\t2\t12\t40\t60\t0\t10\t14\t4\t90',
+  'basic\tBasic Attack\t0\t0\t48\t0\t2\t3\t1\t16',
+].join('\r\n')), strings)
+
+expect(skills.length === 3, 'every skill row becomes a definition')
+expect(skills[0]?.name === 'Fire Bolt', 'skill names resolve through the string table')
+expect(skills[0]?.projectile === true, 'a skill with missile speed is a projectile skill')
+expect(skills[1]?.projectile === false, 'a skill with no speed strikes instantly')
+expect(skills[2]?.name === 'Basic Attack', 'a literal name needs no table')
+
+const firebolt = skills[0]!
+const frostnova = skills[1]!
+
+// damage scaling: base at level 1, plus the slope per level, inside the range
+const level1 = Array.from({ length: 40 }, (_, index) => skillDamageAt(firebolt, 1, new Rng(index)))
+expect(level1.every(damage => damage >= 6 && damage <= 9), 'level 1 damage stays inside the base range')
+const level5 = Array.from({ length: 40 }, (_, index) => skillDamageAt(firebolt, 5, new Rng(index)))
+expect(level5.every(damage => damage >= 18 && damage <= 21), 'each level adds the table slope')
+expect(Math.min(...level5) > Math.max(...level1), 'a higher skill level always out-damages a lower one')
+
+// --- casting gates ----------------------------------------------------------
+
+const caster = { x: 100, y: 100, facing: 6 }
+const ready = castSkill(firebolt, caster, 1, new Rng(1), 0, 50)
+expect(ready.kind === 'projectile', 'a ready cast with mana produces a projectile')
+expect(castSkill(firebolt, caster, 1, new Rng(1), 3, 50).kind === 'cooldown', 'a skill on cooldown refuses to fire')
+expect(castSkill(firebolt, caster, 1, new Rng(1), 0, 1).kind === 'mana', 'a cast without mana refuses to fire')
+expect(castSkill(firebolt, caster, 1, new Rng(1), 0, 5).kind === 'projectile', 'exactly enough mana is enough')
+expect(castSkill(frostnova, caster, 1, new Rng(1), 0, 50).kind === 'instant', 'an instant skill reports as instant')
+
+if (ready.kind === 'projectile') {
+  const shot = ready.projectile
+  // Facing 6 is east: the velocity must run along +x and nowhere else.
+  expect(shot.vx > 0 && Math.abs(shot.vy) < 1e-9, 'a projectile flies along the caster\'s facing')
+  expect(Math.abs(Math.hypot(shot.vx, shot.vy) - firebolt.speed / 25) < 1e-9, 'projectile speed is the table speed per tick')
+  expect(shot.ttl === Math.round(firebolt.range / (firebolt.speed / 25)), 'range divided by step gives the lifetime')
+  expect(shot.fromPlayer === true, 'a cast projectile is marked as the player\'s')
+}
+
+const aimed = castSkill(firebolt, { x: 0, y: 0, facing: 0 }, 1, new Rng(1), 0, 50, { x: 0, y: 100 })
+if (aimed.kind === 'projectile') {
+  expect(aimed.projectile.vy > 0 && Math.abs(aimed.projectile.vx) < 1e-9, 'an aim point overrides the facing')
+} else {
+  problems.push('an aimed cast did not produce a projectile')
+}
+
+// --- projectiles ------------------------------------------------------------
+
+const flying: Projectile = { skillId: 'firebolt', x: 0, y: 0, vx: 12, vy: 0, damage: 7, ttl: 5, fromPlayer: true }
+const targetAt = (x: number, alive = true): ProjectileTarget => ({ index: 1, x, y: 0, radius: 16, alive })
+const openTerrain = { overlap: () => 0 }
+
+const stepOne = tickProjectiles([flying], [targetAt(500)], openTerrain)
+expect(stepOne.alive.length === 1 && stepOne.hits.length === 0, 'a projectile with nothing in the way keeps flying')
+expect(stepOne.alive[0]?.x === 12, 'a projectile advances by its velocity each tick')
+
+const hit = tickProjectiles([{ ...flying, x: 100 }], [targetAt(110)], openTerrain)
+expect(hit.hits.length === 1 && hit.hits[0]?.targetIndex === 1, 'a projectile hits a target in its path')
+expect(hit.alive.length === 0, 'a projectile that hits is consumed')
+expect(hit.hits[0]?.damage === 7, 'the hit carries the rolled damage')
+
+const wall = tickProjectiles([{ ...flying, x: 100 }], [targetAt(104)], { overlap: x => (x >= 105 ? 1 : 0) })
+expect(wall.wallHits === 1 && wall.hits.length === 0, 'a wall stops a projectile before a target behind it')
+expect(wall.alive.length === 0, 'a projectile that hits a wall is consumed')
+
+const expired = tickProjectiles([{ ...flying, ttl: 0 }], [targetAt(500)], openTerrain)
+expect(expired.expired === 1 && expired.alive.length === 0, 'a projectile dies when its lifetime runs out')
+
+const dead = tickProjectiles([{ ...flying, x: 100 }], [targetAt(105, false)], openTerrain)
+expect(dead.hits.length === 0 && dead.alive.length === 1, 'a dead target is not hit')
+
+// --- quests and NPCs --------------------------------------------------------
+
+const quests = questsFromTable(parseTable([
+  'Id\tName\tDescription\tMonsterId\tKillCount\tRewardXP\tRewardGold',
+  'den\t4\t5\tfallen\t3\t120\t50',
+  'any\tDen of Evil\tKill anything\t*\t2\t40\t10',
+].join('\n')), strings)
+expect(quests[0]?.name === 'Kill the fallen', 'quest names resolve through the string table')
+expect(quests[0]?.description === 'Slay the fallen', 'descriptions resolve too')
+expect(quests[1]?.name === 'Den of Evil', 'a literal quest name passes through')
+
+const npcs = npcsFromTable(parseTable([
+  'Id\tName\tQuest\tOffer\tProgress\tDone',
+  'cain\t3\tden\tAccept|Go now\t1|Still alive?\tWell done',
+].join('\n')), strings)
+expect(npcs[0]?.name === 'Deckard Cain', 'NPC names resolve through the string table')
+expect(npcs[0]?.offerLines.length === 2, 'pipe-separated dialogue becomes several lines')
+expect(npcs[0]?.progressLines[0] === 'Fire Bolt', 'a numeric dialogue line resolves to its string')
+
+const log = new QuestLog(quests)
+const cain = npcs[0]!
+expect(npcDialog(cain, log).join('|') === 'Accept|Go now', 'before accepting, the NPC offers the quest')
+expect(log.accept('den'), 'accepting an inactive quest works')
+expect(!log.accept('den'), 'accepting an active quest is refused')
+expect(npcDialog(cain, log).join('|') === 'Fire Bolt|Still alive?', 'while active, the NPC reports progress')
+expect(log.get('den')?.status === 'active', 'the quest is active')
+
+expect(log.recordKill('zombie').length === 0, 'a kill of the wrong monster does not complete the quest')
+expect(log.recordKill('fallen').length === 0, 'the first wanted kill does not complete a three-kill quest')
+const rewards = log.recordKill('fallen')
+expect(rewards.length === 0, 'the second kills still does not complete it')
+const finalRewards = log.recordKill('fallen')
+expect(finalRewards.length === 1 && finalRewards[0]?.questId === 'den', 'the third kill completes the quest')
+expect(finalRewards[0]?.xp === 120 && finalRewards[0]?.gold === 50, 'the reward comes from the quest row')
+expect(log.get('den')?.status === 'complete', 'the quest is complete')
+expect(log.recordKill('fallen').length === 0, 'a completed quest does not reward again')
+expect(npcDialog(cain, log).join('|') === 'Well done', 'after completion, the NPC changes to the done lines')
+
+// A wildcard quest counts any monster, and both quests can be active at once.
+const wildcardLog = new QuestLog(quests)
+wildcardLog.accept('any')
+expect(wildcardLog.recordKill('zombie').length === 0, 'a wildcard quest counts the first kill')
+expect(wildcardLog.recordKill('skeleton').length === 1, 'a wildcard quest completes on any monsters')
+expect(wildcardLog.active.length === 0, 'no quest is left active once complete')
+expect(wildcardLog.all.length === 2, 'the log tracks every quest')
+
+// --- determinism ------------------------------------------------------------
+
+const castRun = (seed: number): string => {
+  const rng = new Rng(seed)
+  const shots: string[] = []
+  for (let index = 0; index < 6; index += 1) {
+    const result = castSkill(firebolt, { x: index, y: 0, facing: 6 }, 3, rng, 0, 100)
+    shots.push(result.kind === 'projectile' ? String(result.projectile.damage) : result.kind)
+  }
+  return shots.join(',')
+}
+expect(castRun(9) === castRun(9), 'the same seed casts for the same damage')
+expect(new Set([1, 2, 3, 4].map(castRun)).size > 1, 'different seeds roll different damage')
+
+console.log(`checks     ${String(checks)}`)
+console.log(`problems   ${String(problems.length)}`)
+for (const problem of problems.slice(0, 12)) console.log(`  - ${problem}`)
+console.log(problems.length === 0 ? 'RESULT     skill, projectile and quest behaviours hold' : 'RESULT     FAILED')
+process.exit(problems.length === 0 ? 0 : 1)
diff --git a/scripts/verify-m5.ts b/scripts/verify-m5.ts
new file mode 100644
index 0000000..ea24743
--- /dev/null
+++ b/scripts/verify-m5.ts
@@ -0,0 +1,355 @@
+/**
+ * M5 checks: snapshots, character files and deterministic lockstep, headless.
+ *
+ * A save is verified the only way that means anything: restore it, keep
+ * simulating, and require the restored copy to stay *identical* to the original
+ * tick for tick. A field left out of the save shows up here as a divergence a few
+ * hundred ticks later, which is exactly how such a bug appears in a real game.
+ *
+ * Lockstep is verified by running two independent sessions over identical input
+ * and comparing their per-tick hashes, then by tampering with one peer's input and
+ * requiring the divergence to be *detected* — a desync detector that never fires
+ * is worse than none.
+ *
+ * Usage: node scripts/verify-m5.ts
+ */
+import { createWorld, spawnMonsters, tickCombat, damageMonster } from '../src/game/combat.ts'
+import type { CombatOptions, MonsterStats } from '../src/game/combat.ts'
+import { Inventory, goldItem, rollDrop } from '../src/game/items.ts'
+import type { Affix, ItemBase } from '../src/game/items.ts'
+import { QuestLog } from '../src/game/quests.ts'
+import type { QuestDef } from '../src/game/quests.ts'
+import { Rng } from '../src/game/rng.ts'
+import {
+  captureSnapshot, createD2s, d2sChecksum, parseSnapshot, readD2s, restoreSnapshot, serializeSnapshot, writeD2s,
+} from '../src/game/save.ts'
+import { LockstepSession } from '../src/net/lockstep.ts'
+import type { InputFrame, LockstepSimulation } from '../src/net/lockstep.ts'
+import { parseTable } from '../src/game/tables.ts'
+import { monsterStatsFromTable } from '../src/game/combat.ts'
+
+const problems: string[] = []
+let checks = 0
+
+/**
+ * Assert one condition.
+ *
+ * @param condition - the condition to hold.
+ * @param description - what it means.
+ */
+function expect(condition: boolean, description: string): void {
+  checks += 1
+  if (!condition) problems.push(description)
+}
+
+// --- a small game to save and to simulate ------------------------------------
+
+const stats: MonsterStats[] = monsterStatsFromTable(parseTable([
+  'Id\tName\tHP\tDamage\tCooldownTicks\tReach\tAggroRadius\tSpeed\tXP',
+  'fallen\tFallen\t12\t3\t24\t36\t400\t80\t8',
+  'zombie\tZombie\t30\t6\t32\t40\t300\t50\t15',
+].join('\n')))
+
+const bases: ItemBase[] = [
+  { id: 'swd', name: 'Short Sword', kind: 'weapon', invWidth: 1, invHeight: 3, maxStack: 1, value: 30, damage: 5, defense: 0, tags: ['weap'], level: 1 },
+  { id: 'potion', name: 'Potion', kind: 'misc', invWidth: 1, invHeight: 1, maxStack: 5, value: 20, damage: 0, defense: 0, tags: ['misc'], level: 1 },
+]
+const prefixes: Affix[] = [{ id: 'cruel', name: 'Cruel', kind: 'prefix', level: 1, itemTypes: ['weap'], modifiers: [{ stat: 'maxdamage', min: 2, max: 6 }] }]
+const suffixes: Affix[] = [{ id: 'might', name: 'of Might', kind: 'suffix', level: 1, itemTypes: [], modifiers: [{ stat: 'strength', min: 1, max: 3 }] }]
+const quests: QuestDef[] = [{ id: 'den', name: 'Den', description: '', monsterId: '*', killCount: 3, rewardXp: 40, rewardGold: 60 }]
+
+const options: CombatOptions = {
+  playerSpeed: 180, playerReach: 48, playerCooldownTicks: 12, playerDamage: 6,
+  playerManaPerAttack: 2, respawnTicks: 40,
+}
+const xpTable: readonly number[] = [0, 0, 1000]
+
+/** The part of the game a save has to carry. */
+interface Game {
+  world: ReturnType<typeof createWorld>
+  rng: Rng
+  inventory: Inventory
+  quests: QuestLog
+  ground: { x: number; y: number; item: ReturnType<typeof goldItem> }[]
+}
+
+/**
+ * Build a fresh game.
+ *
+ * @param seed - random seed and world seed.
+ * @returns the game.
+ */
+function newGame(seed: number): Game {
+  const world = createWorld(0, 0)
+  spawnMonsters(world, stats, 5, { x: 200, y: 0 }, 200, { overlap: () => 0 })
+  return { world, rng: new Rng(seed), inventory: new Inventory(10, 4), quests: new QuestLog(quests), ground: [] }
+}
+
+/**
+ * The input script: deterministic in the tick number, so both runs and both
+ * sessions see exactly the same thing.
+ *
+ * @param tick - the tick.
+ * @returns movement and intent.
+ */
+function scriptedInput(tick: number): { movement: { x: number; y: number }; attack: boolean } {
+  const phase = Math.floor(tick / 25) % 4
+  const movement = phase === 0 ? { x: 1, y: 0 } : phase === 1 ? { x: 0, y: 1 } : phase === 2 ? { x: -1, y: 0 } : { x: 0, y: -1 }
+  return { movement, attack: tick % 5 === 0 }
+}
+
+/**
+ * Advance a game one tick, including loot and quest progress.
+ *
+ * @param game - the game.
+ * @param tick - the tick number.
+ */
+function stepGame(game: Game, tick: number): void {
+  const input = scriptedInput(tick)
+  tickCombat(game.world, input, options, { overlap: () => 0 }, xpTable)
+  for (const event of game.world.events) {
+    if (event.kind !== 'kill') continue
+    for (const reward of game.quests.recordKill(event.subjectId ?? '')) {
+      game.world.player.xp += reward.xp
+      game.inventory.add(goldItem(reward.gold))
+    }
+    const drop = rollDrop(bases, prefixes, suffixes, game.rng, {
+      level: game.world.player.level + 1, dropChance: 0.9, goldChance: 0.2, goldRange: [3, 25],
+    })
+    // Items land on the ground first, like in the scene; a few are then picked up,
+    // so the save has both ground and bag contents to carry.
+    if (drop.kind === 'item') game.ground.push({ x: event.x, y: event.y, item: drop.item })
+    else if (drop.kind === 'gold') game.inventory.add(goldItem(drop.amount))
+  }
+  if (game.ground.length > 0 && tick % 17 === 0) {
+    const entry = game.ground.shift()
+    if (entry !== undefined) game.inventory.add(entry.item)
+  }
+  // The player swings at whatever is in reach, and the damage goes through the
+  // shared entry point so kills behave as they do in the scene.
+  if (input.attack && game.world.player.cooldown === 0) {
+    game.world.monsters.forEach((monster, index) => {
+      if (monster.state === 'dead') return
+      if (Math.hypot(monster.x - game.world.player.x, monster.y - game.world.player.y) > 48) return
+      damageMonster(game.world, index, options.playerDamage)
+    })
+  }
+}
+
+/**
+ * Digest everything a continued simulation depends on.
+ *
+ * @param game - the game.
+ * @returns a digest string.
+ */
+function digest(game: Game): string {
+  const round = (value: number): number => Math.round(value * 1000)
+  return JSON.stringify({
+    tick: game.world.tick,
+    kills: game.world.kills,
+    rng: game.rng.seed,
+    player: {
+      x: round(game.world.player.x), y: round(game.world.player.y),
+      hp: game.world.player.hp, mana: game.world.player.mana, xp: game.world.player.xp,
+      level: game.world.player.level, cooldown: game.world.player.cooldown,
+    },
+    monsters: game.world.monsters.map(m => [round(m.x), round(m.y), m.hp, m.state, m.cooldown, m.hitFlash, m.corpseTicks]),
+    inventory: game.inventory.contents.map(entry => [entry.x, entry.y, entry.item.name, entry.item.stack, entry.item.value]),
+    ground: game.ground.map(entry => [round(entry.x), round(entry.y), entry.item.name]),
+    quests: game.quests.all.map(entry => [entry.def.id, entry.status, entry.kills]),
+  })
+}
+
+// --- snapshots ---------------------------------------------------------------
+
+const original = newGame(0x1234)
+for (let tick = 0; tick < 200; tick += 1) stepGame(original, tick)
+const snapshot = captureSnapshot(original)
+const text = serializeSnapshot(snapshot)
+const parsed = parseSnapshot(text)
+expect(parsed.version === snapshot.version, 'a serialized snapshot parses back')
+expect(parsed.rngState === original.rng.seed, 'the random stream position is saved')
+expect(parsed.inventory.placed.length === original.inventory.contents.length, 'every carried item is saved')
+expect(parsed.quests[0]?.kills === original.quests.all[0]?.kills, 'quest progress is saved')
+expect(parsed.ground.length === original.ground.length, 'items on the ground are saved')
+
+const restored = restoreSnapshot(parsed, {
+  inventory: (width, height, placed) => Inventory.restore(width, height, placed),
+  quests: states => QuestLog.restore(quests, states),
+})
+const restoredGame: Game = {
+  ground: restored.ground.map(entry => ({ ...entry })),
+  world: {
+    ...original.world,
+    ...restored.world,
+    events: [],
+    monsters: restored.world.monsters.map(monster => ({ ...monster })),
+  },
+  rng: new Rng(restored.rngState),
+  inventory: restored.inventory,
+  quests: restored.quests,
+}
+expect(restoredGame.inventory.contents.length === original.inventory.contents.length, 'the restored bag holds the same items')
+expect(
+  restoredGame.inventory.contents.every((entry, index) => entry.x === original.inventory.contents[index]?.x
+    && entry.y === original.inventory.contents[index]?.y),
+  'restored items sit in the slots they were saved in',
+)
+
+// The real test: keep simulating both and require them to stay identical.
+for (let tick = 200; tick < 400; tick += 1) {
+  stepGame(original, tick)
+  stepGame(restoredGame, tick)
+}
+expect(digest(original) === digest(restoredGame), 'a restored game continues identically for 200 more ticks')
+
+// A snapshot missing a field must be rejected, not half-applied.
+let rejected = false
+try {
+  parseSnapshot(JSON.stringify({ version: 1, rngState: 1 }))
+} catch {
+  rejected = true
+}
+expect(rejected, 'a malformed save is rejected')
+let versionRejected = false
+try {
+  parseSnapshot(JSON.stringify({ ...snapshot, version: 99 }))
+} catch {
+  versionRejected = true
+}
+expect(versionRejected, 'a save from a future version is rejected')
+
+// --- character files ---------------------------------------------------------
+
+const character = createD2s('Deckard', 1, 12, 0x80)
+const readBack = readD2s(character)
+expect(readBack.name === 'Deckard', 'the character name round-trips')
+expect(readBack.classIndex === 1 && readBack.level === 12, 'class and level round-trip')
+expect(readBack.version === 96, 'the version word is written')
+const tampered = new Uint8Array(character)
+tampered[0x40] = (tampered[0x40]! + 1) & 0xff
+let checksumRejected = false
+try {
+  readD2s(tampered)
+} catch {
+  checksumRejected = true
+}
+expect(checksumRejected, 'a corrupted character file fails its checksum')
+const notAFile = new Uint8Array(character)
+notAFile[0] = 0
+let signatureRejected = false
+try {
+  readD2s(writeD2s({ ...readBack, raw: notAFile }))
+} catch {
+  signatureRejected = true
+}
+expect(!signatureRejected, 'writing fixes the signature')
+expect(d2sChecksum(character) === new DataView(character.buffer).getUint32(0x0c, true), 'the stored checksum is the computed one')
+
+// --- lockstep ----------------------------------------------------------------
+
+/**
+ * Wrap a game as a lockstep simulation: peer 0 drives it, and the hash covers the
+ * whole state.
+ *
+ * @param game - the game to drive.
+ * @returns the simulation.
+ */
+function asSimulation(game: Game): LockstepSimulation {
+  return {
+    advance: (inputs) => {
+      const frame = inputs[0]!
+      tickCombat(game.world, { movement: frame.movement, attack: frame.attack }, options, { overlap: () => 0 }, xpTable)
+      if (frame.attack && game.world.player.cooldown === 0) {
+        game.world.monsters.forEach((monster, index) => {
+          if (monster.state === 'dead') return
+          if (Math.hypot(monster.x - game.world.player.x, monster.y - game.world.player.y) > 48) return
+          damageMonster(game.world, index, options.playerDamage)
+        })
+      }
+    },
+    hash: () => LockstepSession.digest(digest(game)),
+  }
+}
+
+/**
+ * Build a frame for a tick.
+ *
+ * @param tick - the tick.
+ * @param attack - attack flag override.
+ * @returns the frame.
+ */
+function frameFor(tick: number, attack?: boolean): InputFrame {
+  const input = scriptedInput(tick)
+  return {
+    tick,
+    movement: input.movement,
+    attack: attack ?? input.attack,
+    pickup: false,
+    talk: false,
+    skill: 0,
+  }
+}
+
+const sessionA = new LockstepSession({ peers: 1, inputDelayTicks: 2 }, asSimulation(newGame(7)))
+const sessionB = new LockstepSession({ peers: 1, inputDelayTicks: 2 }, asSimulation(newGame(7)))
+const hashesA: number[] = []
+const hashesB: number[] = []
+for (let tick = 0; tick < 300; tick += 1) {
+  sessionA.submit(0, frameFor(tick))
+  sessionB.submit(0, frameFor(tick))
+  const a = sessionA.step()
+  const b = sessionB.step()
+  if (a.kind === 'stepped') hashesA.push(a.hash)
+  if (b.kind === 'stepped') hashesB.push(b.hash)
+}
+expect(hashesA.length === 300 && hashesB.length === 300, 'both sessions ran every tick')
+expect(hashesA.join(',') === hashesB.join(','), 'the same inputs produce the same hashes tick for tick')
+expect(new Set(hashesA).size > 10, 'the hash actually changes as the world does')
+
+// A session must wait rather than run ahead on partial input.
+const waitingSession = new LockstepSession({ peers: 2, inputDelayTicks: 0 }, asSimulation(newGame(3)))
+waitingSession.submit(0, frameFor(0))
+const stalled = waitingSession.step()
+expect(stalled.kind === 'waiting', 'a tick with a missing peer input does not run')
+expect(stalled.kind === 'waiting' && stalled.missing.join(',') === '1', 'the wait names the peer that is missing')
+expect(waitingSession.tick === 0 && waitingSession.stalls === 1, 'the tick does not advance and the stall is counted')
+waitingSession.submit(1, frameFor(0))
+expect(waitingSession.step().kind === 'stepped', 'the tick runs once the input arrives')
+
+// Input delay: a frame submitted now is due later, which is the latency budget.
+expect(waitingSession.inputDueTick === 1, 'with no delay a frame is due for the next tick')
+const delayedSession = new LockstepSession({ peers: 1, inputDelayTicks: 5 }, asSimulation(newGame(3)))
+expect(delayedSession.inputDueTick === 5, 'input delay pushes the due tick out')
+
+// Stale input is refused rather than rewinding history.
+const staleSession = new LockstepSession({ peers: 1, inputDelayTicks: 0 }, asSimulation(newGame(3)))
+staleSession.submit(0, frameFor(0))
+staleSession.step()
+expect(!staleSession.submit(0, frameFor(0)), 'input for a tick that already ran is dropped')
+expect(staleSession.submit(0, frameFor(1)), 'input for the next tick is accepted')
+
+// Desync detection: one peer sees different input, and the hashes must disagree.
+const honestSession = new LockstepSession({ peers: 1, inputDelayTicks: 0 }, asSimulation(newGame(11)))
+const tamperedSession = new LockstepSession({ peers: 1, inputDelayTicks: 0 }, asSimulation(newGame(11)))
+// The tamper has to be a real difference: `frameFor(0)` already attacks (the
+// script attacks every fifth tick), so the honest peer is given the opposite.
+honestSession.submit(0, frameFor(0, false))
+const honestHash = honestSession.step()
+tamperedSession.submit(0, frameFor(0, true))
+const tamperedHash = tamperedSession.step()
+expect(honestHash.kind === 'stepped' && tamperedHash.kind === 'stepped', 'both peers ran tick 0')
+if (honestHash.kind === 'stepped' && tamperedHash.kind === 'stepped') {
+  const report = honestSession.compare({ tick: 0, hash: tamperedHash.hash })
+  expect(report !== null, 'a diverging input is detected as a desync')
+  expect(report?.tick === 0, 'the report names the tick that diverged')
+  expect(honestSession.compare({ tick: 0, hash: honestHash.hash }) === null, 'matching hashes are not a desync')
+  expect(honestSession.desyncReport !== null, 'the first desync is remembered')
+}
+expect(honestSession.compare({ tick: 999, hash: 1 }) === null, 'a hash for an unknown tick is ignored, not guessed at')
+
+console.log(`checks     ${String(checks)}`)
+console.log(`problems   ${String(problems.length)}`)
+for (const problem of problems.slice(0, 12)) console.log(`  - ${problem}`)
+console.log(problems.length === 0 ? 'RESULT     save, snapshot and lockstep behaviours hold' : 'RESULT     FAILED')
+process.exit(problems.length === 0 ? 0 : 1)
diff --git a/scripts/verify-mpq-roundtrip.ts b/scripts/verify-mpq-roundtrip.ts
new file mode 100644
index 0000000..7b0b920
--- /dev/null
+++ b/scripts/verify-mpq-roundtrip.ts
@@ -0,0 +1,96 @@
+/**
+ * Round-trip check for the MPQ reader against an archive written by
+ * `scripts/make-mpq-fixture.ts`.
+ *
+ * The archive's contents are known byte for byte, so this is a two-sided test:
+ * the reader must list exactly the packed names, report exactly the packed sizes
+ * and flags, and return exactly the packed bytes — for members stored raw *and*
+ * for members stored as zlib sectors, which are the two read paths that exist.
+ *
+ * Usage: node scripts/verify-mpq-roundtrip.ts <fixture-directory>
+ */
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { memorySource } from '../src/mpq/source.ts'
+
+const dir = process.argv[2]
+if (dir === undefined) {
+  console.error('usage: node scripts/verify-mpq-roundtrip.ts <fixture-directory>')
+  process.exit(2)
+}
+
+const archive = await MpqArchive.open(memorySource(new Uint8Array(await readFile(join(dir, 'fixture.mpq'))), 'fixture.mpq'))
+const names = await archive.listFiles()
+const problems: string[] = []
+
+// `listFiles()` returns the names the archive publishes — the members named by
+// `(listfile)` — which by design is not the listfile itself.
+const published = [
+  'actor.dc6',
+  'data/global/excel/armor.txt', 'data/global/excel/experience.txt',
+  'data/global/excel/magicprefix.txt', 'data/global/excel/magicsuffix.txt',
+  'data/global/excel/misc.txt', 'data/global/excel/monstats.txt', 'data/global/excel/npcs.txt',
+  'data/global/excel/quests.txt', 'data/global/excel/skills.txt', 'data/global/excel/weapons.txt',
+  'data/local/string.tbl',
+  'fixture.dc6', 'fixture.ds1', 'fixture.dt1', 'palette.pal',
+]
+const listed = [...names].sort()
+if (JSON.stringify(listed) !== JSON.stringify(published)) {
+  problems.push(`published names: ${JSON.stringify(listed)} != ${JSON.stringify(published)}`)
+}
+// Every member, the listfile included, must be present as a block.
+const expectedNames = ['(listfile)', ...published]
+if (archive.files().length !== expectedNames.length) {
+  problems.push(`occupied blocks: ${String(archive.files().length)} != ${String(expectedNames.length)}`)
+}
+
+// `(listfile)` is synthesised by the packer rather than read from disk, so its
+// expected bytes are rebuilt here the same way the packer built them.
+const synthetic = new TextEncoder().encode(`${[
+  'fixture.ds1', 'fixture.dt1', 'palette.pal', 'fixture.dc6', 'actor.dc6',
+  'data/global/excel/monstats.txt', 'data/global/excel/experience.txt',
+  'data/global/excel/weapons.txt', 'data/global/excel/armor.txt', 'data/global/excel/misc.txt',
+  'data/global/excel/magicprefix.txt', 'data/global/excel/magicsuffix.txt',
+  'data/global/excel/skills.txt', 'data/global/excel/npcs.txt', 'data/global/excel/quests.txt',
+  'data/local/string.tbl',
+].join('\r\n')}\r\n`)
+
+let comparedBytes = 0
+for (const name of expectedNames) {
+  // Table members are stored under a directory path; on disk they live in the
+  // same tree, so the member name doubles as a relative path.
+  const onDisk = name === '(listfile)'
+    ? synthetic
+    : new Uint8Array(await readFile(join(dir, name)))
+  const entry = archive.find(name)
+  if (entry === undefined) { problems.push(`${name}: not found by the reader`); continue }
+  if (entry.fileSize !== onDisk.byteLength) {
+    problems.push(`${name}: reported size ${String(entry.fileSize)} != ${String(onDisk.byteLength)}`)
+  }
+  const decoded = await archive.read(entry)
+  if (decoded.byteLength !== onDisk.byteLength) {
+    problems.push(`${name}: decoded ${String(decoded.byteLength)} bytes != ${String(onDisk.byteLength)}`)
+    continue
+  }
+  let firstDifference = -1
+  for (let at = 0; at < onDisk.byteLength; at += 1) {
+    if (decoded[at] !== onDisk[at]) { firstDifference = at; break }
+  }
+  if (firstDifference !== -1) {
+    problems.push(`${name}: byte ${String(firstDifference)} differs (${String(decoded[firstDifference])} != ${String(onDisk[firstDifference])})`)
+    continue
+  }
+  comparedBytes += decoded.byteLength
+  const flags = entry.flags >>> 0
+  const compressed = (flags & 0x00000200) !== 0
+  console.log(`  ${name.padEnd(14)} ${String(decoded.byteLength).padStart(7)} bytes  ${compressed ? 'zlib sectors' : 'stored'}  flags 0x${flags.toString(16)}`)
+}
+
+console.log(`archive    ${join(dir, 'fixture.mpq')}`)
+console.log(`members    ${String(archive.files().length)} blocks, ${String(names.length)} published names`)
+console.log(`compared   ${String(comparedBytes)} bytes across ${String(expectedNames.length)} members`)
+console.log(`problems   ${String(problems.length)}`)
+for (const problem of problems.slice(0, 8)) console.log(`  - ${problem}`)
+console.log(problems.length === 0 ? 'RESULT     reader round-trips the packed archive exactly' : 'RESULT     FAILED')
+process.exit(problems.length === 0 ? 0 : 1)
diff --git a/scripts/verify-net.ts b/scripts/verify-net.ts
new file mode 100644
index 0000000..51cc2f8
--- /dev/null
+++ b/scripts/verify-net.ts
@@ -0,0 +1,860 @@
+/**
+ * Network checks: wire protocol, transports, and two peers playing over a socket.
+ *
+ * The claim being tested is not "messages encode" — it is that two independently
+ * simulated worlds, driven only by messages that crossed a real byte pipe, stay
+ * bit-identical; that a peer which goes quiet *stalls* the world instead of
+ * corrupting it; and that a peer whose input is altered in flight is *detected*.
+ *
+ * The last section runs the same session code over a real TCP socket and real
+ * WebSocket framing (through the relay in `scripts/net-relay.ts`), because an
+ * in-memory pipe cannot prove that the browser transport works: it never frames,
+ * never splits a message across TCP segments, and never delivers asynchronously.
+ *
+ * Usage: node scripts/verify-net.ts
+ */
+import { addPlayer, createWorld, damageMonster, spawnMonsters, tickCombat, tickCombatMulti } from '../src/game/combat.ts'
+import type { CombatOptions, CombatWorld, MonsterStats } from '../src/game/combat.ts'
+import { Rng } from '../src/game/rng.ts'
+import { LockstepSession } from '../src/net/lockstep.ts'
+import type { InputFrame, LockstepSimulation } from '../src/net/lockstep.ts'
+import { NetplaySession } from '../src/net/netplay.ts'
+import { decodeMessage, encodeMessage, NO_ACK, ProtocolError } from '../src/net/protocol.ts'
+import type { NetMessage } from '../src/net/protocol.ts'
+import { MemoryHub, memoryTransportPair, socketTransport, MemoryTransport } from '../src/net/transport.ts'
+import type { Transport } from '../src/net/transport.ts'
+import { parseTable } from '../src/game/tables.ts'
+import { monsterStatsFromTable } from '../src/game/combat.ts'
+import { startRelay } from './net-relay.ts'
+
+const problems: string[] = []
+let checks = 0
+
+/**
+ * Assert one condition.
+ *
+ * @param condition - the condition to hold.
+ * @param description - what it means.
+ */
+function expect(condition: boolean, description: string): void {
+  checks += 1
+  if (!condition) problems.push(description)
+}
+
+// --- the wire codec ----------------------------------------------------------
+
+const messages: NetMessage[] = [
+  { kind: 'hello', peer: 1, peers: 2, seed: 0xdeadbeef, ackTo: NO_ACK },
+  { kind: 'hello', peer: 0, peers: 2, seed: 0xdeadbeef, ackTo: 1 },
+  { kind: 'input', peer: 0, frame: { tick: 1234, movement: { x: -1, y: 0.5 }, attack: true, pickup: false, talk: true, skill: 3 } },
+  { kind: 'hash', peer: 1, tick: 987654, hash: 0x89abcdef },
+  { kind: 'bye', peer: 0 },
+]
+for (const message of messages) {
+  const round = decodeMessage(encodeMessage(message))
+  expect(round.kind === message.kind, `${message.kind} survives a round trip`)
+  if (round.kind === 'input' && message.kind === 'input') {
+    expect(round.frame.tick === message.frame.tick, 'the tick round-trips')
+    expect(Math.abs(round.frame.movement.x - message.frame.movement.x) < 1e-3, 'the x movement round-trips as fixed point')
+    expect(Math.abs(round.frame.movement.y - message.frame.movement.y) < 1e-3, 'the y movement round-trips as fixed point')
+    expect(round.frame.attack && !round.frame.pickup && round.frame.talk, 'the control flags round-trip')
+    expect(round.frame.skill === 3, 'the skill slot round-trips')
+  }
+  if (round.kind === 'hello' && message.kind === 'hello') expect(round.seed === 0xdeadbeef, 'the seed round-trips')
+  if (round.kind === 'hash' && message.kind === 'hash') {
+    expect(round.tick === 987654 && round.hash === 0x89abcdef, 'the hash and tick round-trip')
+  }
+}
+
+// The layout is pinned, not just self-consistent: a peer running an older build
+// must fail loudly rather than silently misread a field.
+const pinned = encodeMessage({ kind: 'input', peer: 1, frame: { tick: 1, movement: { x: -1, y: 0 }, attack: true, pickup: false, talk: false, skill: 0 } })
+expect(pinned.byteLength === 12, 'an input message is twelve bytes')
+expect(pinned[0] === 2 && pinned[1] === 1, 'an input message starts with its type and peer')
+expect(pinned[6] === 0x18 && pinned[7] === 0xfc, 'a movement of -1 is fixed point -1000, little-endian')
+expect(pinned[10] === 1, 'only the attack flag is set')
+expect(encodeMessage({ kind: 'hash', peer: 0, tick: 0, hash: 0 }).byteLength === 10, 'a hash message is ten bytes')
+expect(encodeMessage({ kind: 'hello', peer: 0, peers: 1, seed: 0, ackTo: NO_ACK }).byteLength === 8, 'a hello message is eight bytes')
+const acked = decodeMessage(encodeMessage({ kind: 'hello', peer: 0, peers: 4, seed: 7, ackTo: 3 }))
+expect(acked.kind === 'hello' && acked.ackTo === 3, 'an acknowledgement names the peer it acknowledges')
+const unacked = decodeMessage(encodeMessage({ kind: 'hello', peer: 0, peers: 4, seed: 7, ackTo: NO_ACK }))
+expect(unacked.kind === 'hello' && unacked.ackTo === NO_ACK, 'a plain introduction is not mistaken for an acknowledgement')
+
+const bad: [string, Uint8Array][] = [
+  ['an empty message', new Uint8Array(0)],
+  ['an unknown type', new Uint8Array([99, 0])],
+  ['a truncated input', new Uint8Array([2, 0, 0, 0])],
+  ['an over-long input', new Uint8Array(16)],
+  ['a hello claiming zero peers', new Uint8Array([1, 0, 0, 0, 0, 0, 0, 0])],
+  ['a hello claiming nine peers', new Uint8Array([1, 0, 9, 0, 0, 0, 0, 0])],
+  ['a truncated hash', new Uint8Array([3, 0, 0])],
+]
+for (const [label, bytes] of bad) {
+  let rejected = false
+  try {
+    decodeMessage(bytes)
+  } catch (error) {
+    rejected = error instanceof ProtocolError
+  }
+  expect(rejected, `${label} is rejected before it reaches the simulation`)
+}
+
+const movementOverflow = decodeMessage(encodeMessage({
+  kind: 'input', peer: 0, frame: { tick: 0, movement: { x: 1e9, y: -1e9 }, attack: false, pickup: false, talk: false, skill: 255 },
+}))
+expect(movementOverflow.kind === 'input' && movementOverflow.frame.movement.x <= 32767, 'an absurd movement is clamped, not wrapped')
+
+// --- transports --------------------------------------------------------------
+
+const [endA, endB] = memoryTransportPair()
+let receivedAtB = 0
+endB.onMessage(() => { receivedAtB += 1 })
+expect(endA.open && endB.open, 'a fresh memory pair is open at both ends')
+endA.send(new Uint8Array([1, 2, 3]))
+expect(receivedAtB === 0, 'a memory message is queued, not delivered on send')
+endA.flush()
+expect(receivedAtB === 1, 'flushing delivers the queued message')
+const oversizeRejected = ((): boolean => {
+  try {
+    endA.send(new Uint8Array(5000))
+    return false
+  } catch { return true }
+})()
+expect(oversizeRejected, 'an oversized message is refused at the transport')
+let closed = 0
+endA.onClose(() => { closed += 1 })
+endB.close()
+expect(closed === 1 && !endA.open && !endB.open, 'closing one end closes the pair')
+endA.send(new Uint8Array([9]))
+endA.flush()
+expect(endA.dropped === 1, 'sending on a closed pair drops instead of throwing')
+
+// --- two peers, one world, over a byte pipe ----------------------------------
+
+const stats: MonsterStats[] = monsterStatsFromTable(parseTable([
+  'Id\tName\tHP\tDamage\tCooldownTicks\tReach\tAggroRadius\tSpeed\tXP',
+  // Fast enough to catch the player and weak enough that neither peer's player
+  // dies before the kills can be compared: the point of this table is contact.
+  'fallen\tFallen\t12\t1\t24\t36\t400\t220\t8',
+  'zombie\tZombie\t30\t1\t32\t40\t300\t210\t15',
+].join('\n')))
+
+const options: CombatOptions = {
+  playerSpeed: 180, playerReach: 48, playerCooldownTicks: 12, playerDamage: 6,
+  playerManaPerAttack: 2, respawnTicks: 40,
+}
+const xpTable: readonly number[] = [0, 0, 1000]
+
+/** A world plus its random stream: everything a peer simulates. */
+interface Game { world: ReturnType<typeof createWorld>; rng: Rng }
+
+/**
+ * Build a fresh game, identical on both peers.
+ *
+ * @param seed - the world seed.
+ * @returns the game.
+ */
+function newGame(seed: number): Game {
+  const world = createWorld(0, 0)
+  // The monsters start close enough to reach the player inside the first few
+  // seconds: a network test where nothing ever fights would agree on nothing.
+  spawnMonsters(world, stats, 5, { x: 30, y: 0 }, 40, { overlap: () => 0 })
+  return { world, rng: new Rng(seed) }
+}
+
+/**
+ * The input script: a pure function of the tick and the peer, so there is nothing
+ * here that two peers could disagree about.
+ *
+ * @param peer - the peer index.
+ * @param tick - the tick.
+ * @returns movement and intent.
+ */
+function scriptedInput(peer: number, tick: number): { movement: { x: number; y: number }; attack: boolean; pickup: boolean; talk: boolean; skill: number } {
+  const phase = Math.floor((tick + peer * 7) / 25) % 4
+  const movement = phase === 0 ? { x: 1, y: 0 } : phase === 1 ? { x: 0, y: 1 } : phase === 2 ? { x: -1, y: 0 } : { x: 0, y: -1 }
+  return { movement, attack: (tick + peer) % 5 === 0, pickup: tick % 41 === 0, talk: false, skill: (tick + peer) % 4 }
+}
+
+/**
+ * Wrap a game as a lockstep simulation. Every peer applies *every* peer's input,
+ * and the digest covers the whole world, so a field missed by one peer's
+ * simulation shows up as a desync.
+ *
+ * @param game - the game to drive.
+ * @returns the simulation.
+ */
+function asSimulation(game: Game): LockstepSimulation {
+  return {
+    advance: (inputs) => {
+      for (const input of inputs) {
+        // Only movement and attack reach the combat tick; pickup and talk belong
+        // to the scene, so they are deliberately not part of the digest here.
+        tickCombat(game.world, { movement: input.movement, attack: input.attack }, options, { overlap: () => 0 }, xpTable)
+        if (input.attack && game.world.player.cooldown === 0) {
+          const swing = game.rng.next() // the drop stream is part of the world
+          game.world.monsters.forEach((monster, index) => {
+            if (monster.state === 'dead') return
+            if (Math.hypot(monster.x - game.world.player.x, monster.y - game.world.player.y) > 48) return
+            damageMonster(game.world, index, options.playerDamage + (swing > 0.5 ? 1 : 0))
+          })
+        }
+      }
+    },
+    hash: () => LockstepSession.digest(digest(game)),
+  }
+}
+
+/**
+ * Digest everything, so a divergence cannot hide in a field the hash forgets.
+ *
+ * @param game - the game.
+ * @returns a digest string.
+ */
+function digest(game: Game): string {
+  const round = (value: number): number => Math.round(value * 1000)
+  return JSON.stringify({
+    tick: game.world.tick,
+    kills: game.world.kills,
+    rng: game.rng.seed,
+    events: game.world.events.map(event => [event.kind, event.subjectId ?? '', round(event.x), round(event.y)]),
+    player: {
+      x: round(game.world.player.x), y: round(game.world.player.y),
+      hp: game.world.player.hp, mana: game.world.player.mana,
+      cooldown: game.world.player.cooldown, facing: game.world.player.facing,
+      alive: game.world.player.alive,
+    },
+    monsters: game.world.monsters.map(m => [round(m.x), round(m.y), m.hp, m.state, m.cooldown, m.hitFlash]),
+  })
+}
+
+/**
+ * A peer: its session and the game it drives.
+ */
+interface Peer { session: NetplaySession; game: Game }
+
+/**
+ * Build one networked peer.
+ *
+ * @param index - the peer index.
+ * @param transport - its byte pipe.
+ * @param seed - the world seed.
+ * @returns the peer.
+ */
+function makePeer(index: number, transport: Transport, seed: number): Peer {
+  const game = newGame(seed)
+  const session = new NetplaySession(
+    { peer: index, peers: 2, seed, inputDelayTicks: 3, hashInterval: 1, timeoutTicks: 40 },
+    asSimulation(game),
+    transport,
+  )
+  const peer: Peer = { session, game }
+  session.start()
+  return peer
+}
+
+// --- the quiet-peer case: a stall must not corrupt the world ------------------
+
+const [pipeA, pipeB] = memoryTransportPair()
+const peerA = makePeer(0, pipeA, 0x51ed)
+const peerB = makePeer(1, pipeB, 0x51ed)
+// The handshake is owed by `start` and delivered by the first pump: a session is
+// normally created while its socket is still connecting, so sending on `start`
+// would write into a socket that is not open yet.
+expect(peerA.session.stats.helloSent === 0 && !peerA.session.stats.handshaked, 'nothing is sent before the session is pumped')
+peerA.session.pump()
+peerB.session.pump()
+pipeA.flush()
+expect(peerA.session.remoteSeed === 0x51ed && peerB.session.remoteSeed === 0x51ed, 'the handshake exchanges the world seed')
+expect(peerA.session.stats.handshaked && peerB.session.stats.handshaked, 'both peers complete the handshake')
+// The acknowledgements are still in flight; delivering them must end the
+// handshake for good rather than leaving either peer repeating itself.
+pipeA.flush()
+expect(peerA.session.stats.acknowledged && peerB.session.stats.acknowledged, 'both peers learn that their own hello was heard')
+for (let tick = 0; tick < 40; tick += 1) {
+  peerA.session.pump()
+  peerB.session.pump()
+  pipeA.flush()
+}
+expect(
+  peerA.session.stats.helloSent === 2 && peerB.session.stats.helloSent === 2,
+  'a completed handshake stops: one hello and one acknowledgement each',
+)
+
+const TICKS = 200
+let stepsA = 0
+let stepsB = 0
+for (let tick = 0; tick < TICKS; tick += 1) {
+  const inputA = scriptedInput(0, tick)
+  const inputB = scriptedInput(1, tick)
+  peerA.session.setIntent(inputA)
+  peerB.session.setIntent(inputB)
+  if (peerA.session.pump().kind === 'stepped') stepsA += 1
+  if (peerB.session.pump().kind === 'stepped') stepsB += 1
+  // B's link is held for a stretch: A must stall, B must run on, and neither may
+  // end up with a different world.
+  pipeB.hold = tick >= 60 && tick < 90
+  pipeA.flush()
+}
+// Drain the backlog the held link accumulated.
+for (let round = 0; round < 60; round += 1) {
+  peerA.session.setIntent({ movement: { x: 0, y: 0 }, attack: false })
+  peerB.session.setIntent({ movement: { x: 0, y: 0 }, attack: false })
+  peerA.session.pump()
+  peerB.session.pump()
+  pipeA.flush()
+}
+
+expect(peerA.session.desyncReport === null && peerB.session.desyncReport === null, 'a peer whose link stalls does not cause a desync')
+expect(peerA.session.stats.hashesCompared === peerA.session.stats.hashesAgreed, 'every hash peer 0 could check agreed')
+expect(peerA.session.stats.waiting > 0, 'the peer that waited counted the stalled ticks')
+expect(peerA.session.stats.hashesCompared > 0 && peerB.session.stats.hashesCompared > 0, 'both peers compared state hashes')
+expect(
+  peerB.session.stats.hashesCompared === peerB.session.stats.hashesAgreed,
+  'every hash that arrived at peer 1 agreed',
+)
+expect(peerA.session.stats.malformed === 0 && peerB.session.stats.malformed === 0, 'no message was malformed')
+expect(peerA.session.stats.timedOut === false, 'a link that stalls for a moment is not declared lost')
+expect(peerA.session.stats.sent > 100 && peerA.session.stats.received > 100, 'traffic actually crossed the pipe')
+expect(stepsA > 100 && stepsB > 100, 'both peers ran the game, one eventually catching up')
+expect(stepsB > stepsA, 'the peer whose link was open ran ahead while the other was starved')
+// A peer that is starved stops producing input, so its partner runs only as far
+// as the inputs it already holds and then waits too — the world as a whole is held
+// back, which is the point of lockstep. The two ends therefore resume with a small
+// constant lead rather than snapping level.
+const lead = peerB.session.lockstep.tick - peerA.session.lockstep.tick
+expect(lead >= 0 && lead <= 6, 'the two ends resume within a few ticks of each other')
+// The starved peer still holds the other's backlog, so it can be brought level
+// without any further traffic from the far end: pumping peer 0 alone (and holding
+// its own sends) replays exactly the ticks it was missing.
+for (let extra = 0; extra < 12 && peerA.session.lockstep.tick < peerB.session.lockstep.tick; extra += 1) {
+  peerA.session.setIntent(scriptedInput(0, peerA.session.lockstep.tick))
+  peerA.session.pump()
+}
+expect(
+  peerA.session.lockstep.tick === peerB.session.lockstep.tick,
+  'the starved peer can be brought level from the backlog it already holds',
+)
+expect(
+  digest(peerA.game) === digest(peerB.game),
+  'at the same tick, the peer that was starved holds exactly the other peer\'s world',
+)
+expect(peerA.game.world.kills === peerB.game.world.kills, 'both peers agree on the kill count')
+expect(peerA.game.rng.seed === peerB.game.rng.seed, 'both peers agree on the random stream position')
+expect(peerA.game.world.monsters.every((m, i) => m.hp === peerB.game.world.monsters[i]?.hp), 'both peers agree on monster health')
+expect(peerA.game.world.kills > 0, 'the test actually produced kills to disagree about')
+// The starved peer buffered the hashes that arrived for ticks it had not run yet,
+// so once it catches up it checks them all: being behind costs nothing.
+expect(peerA.session.stats.hashesIgnored === 0, 'a peer that fell behind still checks every hash it received')
+expect(peerA.session.stats.hashesCompared > 100, 'catching up results in a real number of compared hashes')
+expect(peerB.session.stats.hashesAgreed === peerB.session.stats.hashesCompared, 'every hash peer 1 could check agreed')
+
+
+// --- co-op: two peers, one shared world, one fighter each ---------------------
+
+/**
+ * Build a co-op world: two players, monsters between them.
+ *
+ * Both peers call this with the same seed and get the same world, which is the
+ * whole premise of lockstep — nothing about the world is sent, only what the
+ * players pressed.
+ *
+ * @returns the world.
+ */
+function newCoopWorld(): CombatWorld {
+  const world = createWorld(-40, 0)
+  addPlayer(world, 40, 0)
+  spawnMonsters(world, coopStats, 6, { x: 0, y: 0 }, 90, { overlap: () => 0 })
+  return world
+}
+
+/**
+ * Digest a co-op world.
+ *
+ * The player list is digested in peer order; `world.player` is a view alias and is
+ * deliberately absent, because which player is "local" must not affect the state
+ * two peers agree on.
+ *
+ * @param world - the world.
+ * @returns a digest string.
+ */
+function coopDigest(world: CombatWorld): string {
+  const round = (value: number): number => Math.round(value * 1000)
+  return JSON.stringify({
+    tick: world.tick,
+    kills: world.kills,
+    players: world.players.map(player => [round(player.x), round(player.y), player.hp, player.xp, player.level, player.alive]),
+    monsters: world.monsters.map(m => [round(m.x), round(m.y), m.hp, m.state]),
+  })
+}
+
+/**
+ * A co-op simulation: each peer's input drives its own fighter.
+ *
+ * @param world - the shared world.
+ * @returns the simulation.
+ */
+function coopSimulation(world: CombatWorld): LockstepSimulation {
+  return {
+    advance: (inputs) => {
+      tickCombatMulti(world, inputs.map(input => ({ movement: input.movement, attack: input.attack })), options, { overlap: () => 0 }, xpTable)
+    },
+    hash: () => LockstepSession.digest(coopDigest(world)),
+  }
+}
+
+const coopStats: MonsterStats[] = monsterStatsFromTable(parseTable([
+  'Id\tName\tHP\tDamage\tCooldownTicks\tReach\tAggroRadius\tSpeed\tXP',
+  'fallen\tFallen\t14\t1\t24\t36\t400\t220\t8',
+].join('\n')))
+
+const [coopPipeA, coopPipeB] = memoryTransportPair()
+const coopWorldA = newCoopWorld()
+const coopWorldB = newCoopWorld()
+const coopA = new NetplaySession(
+  { peer: 0, peers: 2, seed: 0x9a9a, inputDelayTicks: 3, hashInterval: 1, timeoutTicks: 400 },
+  coopSimulation(coopWorldA), coopPipeA,
+)
+const coopB = new NetplaySession(
+  { peer: 1, peers: 2, seed: 0x9a9a, inputDelayTicks: 3, hashInterval: 1, timeoutTicks: 400 },
+  coopSimulation(coopWorldB), coopPipeB,
+)
+coopA.start()
+coopB.start()
+coopPipeA.flush()
+for (let tick = 0; tick < 300; tick += 1) {
+  coopA.setIntent(scriptedInput(0, tick))
+  coopB.setIntent(scriptedInput(1, tick))
+  coopA.pump()
+  coopB.pump()
+  coopPipeA.flush()
+}
+expect(coopA.desyncReport === null && coopB.desyncReport === null, 'two players in one world do not desync')
+expect(coopA.stats.hashesCompared > 200 && coopA.stats.hashesCompared === coopA.stats.hashesAgreed, 'every co-op hash peer 0 could check agreed')
+expect(coopB.stats.hashesCompared > 200 && coopB.stats.hashesCompared === coopB.stats.hashesAgreed, 'every co-op hash peer 1 could check agreed')
+expect(coopA.lockstep.tick >= 295 && coopB.lockstep.tick === coopA.lockstep.tick, 'both peers ran the whole co-op run, tick for tick together')
+expect(coopDigest(coopWorldA) === coopDigest(coopWorldB), 'the two peers hold the same two-player world')
+expect(coopWorldA.players.length === 2, 'the world really has two players in it')
+expect(coopWorldA.kills > 0, 'the two players killed something together')
+expect(coopWorldA.players[0]!.xp !== coopWorldA.players[1]!.xp, 'experience is credited to the peer that landed the killing blow')
+expect(coopWorldA.players[0]!.x !== coopWorldB.players[0]!.x || coopWorldA.players[0]!.y === coopWorldB.players[0]!.y, 'player 0 moved under its own input')
+expect(coopDigest(coopWorldA) !== coopDigest(newCoopWorld()), 'the co-op world actually changed while it ran')
+
+// Monsters go for whoever is nearest, not for player 0 by seniority.
+const bait = createWorld(-300, 0)
+addPlayer(bait, 0, 0)
+bait.monsters.push({
+  index: 0, stats: { ...coopStats[0]!, aggroRadius: 400, reach: 40, speed: 0 }, x: 6, y: 0,
+  hp: 50, cooldown: 0, state: 'idle', facing: 0, hitFlash: 0, corpseTicks: 0,
+})
+const idle = { movement: { x: 0, y: 0 }, attack: false }
+for (let tick = 0; tick < 40; tick += 1) tickCombatMulti(bait, [idle, idle], options, { overlap: () => 0 }, xpTable)
+expect(bait.players[1]!.hp < bait.players[1]!.maxHp, 'a monster attacks the nearest player')
+expect(bait.players[0]!.hp === bait.players[0]!.maxHp, 'a monster 300 pixels away from the other player leaves it alone')
+
+// A dead peer must not stall the monsters or hide the living one.
+const bereaved = createWorld(-30, 0)
+addPlayer(bereaved, 30, 0)
+bereaved.players[1]!.hp = 0
+bereaved.players[1]!.alive = false
+bereaved.players[1]!.respawnIn = 30
+// The monster stands on top of the dead peer and within reach of the living one,
+// so a monster that still targeted corpses would attack the wrong player.
+bereaved.monsters.push({
+  index: 0, stats: { ...coopStats[0]!, aggroRadius: 400, reach: 80, speed: 0 }, x: 30, y: 0,
+  hp: 50, cooldown: 0, state: 'idle', facing: 0, hitFlash: 0, corpseTicks: 0,
+})
+for (let tick = 0; tick < 10; tick += 1) tickCombatMulti(bereaved, [idle, idle], options, { overlap: () => 0 }, xpTable)
+expect(bereaved.players[0]!.hp < bereaved.players[0]!.maxHp, 'with one peer dead the monsters hunt the other')
+expect(!bereaved.players[1]!.alive && bereaved.players[1]!.hp === 0, 'a dead peer stays dead while its respawn timer runs')
+
+// A hash whose tick has already fallen out of history is a different case: it
+// cannot be checked at all, and saying so is the honest answer.
+const [latePipeA, latePipeB] = memoryTransportPair()
+const lateA = makePeer(0, latePipeA, 0x6666)
+const lateB = makePeer(1, latePipeB, 0x6666)
+latePipeA.flush()
+for (let tick = 0; tick < 120; tick += 1) {
+  lateA.session.setIntent(scriptedInput(0, tick))
+  lateB.session.setIntent(scriptedInput(1, tick))
+  lateA.session.pump()
+  lateB.session.pump()
+  latePipeA.flush()
+}
+latePipeB.send(encodeMessage({ kind: 'hash', peer: 1, tick: 0, hash: 0x1234 }))
+latePipeA.flush()
+for (let extra = 0; extra < 5; extra += 1) { lateA.session.pump(); latePipeA.flush() }
+expect(lateA.session.stats.hashesIgnored === 1, 'a hash for a tick that has left history is counted as uncheckable')
+expect(lateA.session.desyncReport === null, 'an uncheckable hash is not mistaken for a mismatch')
+expect(lateA.session.stats.hashesAgreed === lateA.session.stats.hashesCompared, 'a stale hash does not corrupt the agreement count')
+
+// --- four peers, one world, one fighter each --------------------------------
+
+/**
+ * Build a world with a given number of players, in peer order.
+ *
+ * @param count - how many players.
+ * @returns the world.
+ */
+function newHubWorld(count: number): CombatWorld {
+  const world = createWorld(-60, 0)
+  for (let index = 1; index < count; index += 1) addPlayer(world, -60 + index * 40, 0)
+  spawnMonsters(world, coopStats, 8, { x: 0, y: 0 }, 140, { overlap: () => 0 })
+  return world
+}
+
+const FOUR = 4
+// The hub is grown rather than pre-sized: a peer that has not joined has no pipe
+// at all, which is the case worth testing — a transport that merely exists
+// handshakes immediately, because answering a hello is not a game action.
+const hub = new MemoryHub()
+const hubWorlds: CombatWorld[] = []
+const hubSessions: NetplaySession[] = []
+for (let index = 0; index < FOUR - 1; index += 1) {
+  const world = newHubWorld(FOUR)
+  hubWorlds.push(world)
+  const session = new NetplaySession(
+    { peer: index, peers: FOUR, seed: 0x4bee, inputDelayTicks: 3, hashInterval: 1, timeoutTicks: 400 },
+    coopSimulation(world),
+    hub.attach(),
+  )
+  session.start()
+  hubSessions.push(session)
+}
+
+/**
+ * Pump one round: every running peer once, then deliver.
+ *
+ * @param tick - the scripted tick.
+ */
+function pumpRound(tick: number): void {
+  for (let index = 0; index < hubSessions.length; index += 1) {
+    hubSessions[index]!.setIntent(scriptedInput(index, tick))
+    hubSessions[index]!.pump()
+  }
+  hub.flush()
+}
+
+// Three peers are up; the fourth has not joined.
+for (let tick = 0; tick < 60; tick += 1) pumpRound(tick)
+expect(hubSessions[0]!.stats.peersHeard === 2, 'a session knows which of its peers it has heard from')
+expect(hubSessions[0]!.stats.peersExpected === 3, 'a four-peer session expects three other peers')
+expect(!hubSessions[0]!.stats.ready, 'a session expecting four peers is not ready with three')
+expect(hubSessions[0]!.lockstep.tick === 0, 'with a peer still missing, nobody starts the game')
+expect(hubSessions[0]!.stats.stepped === 0, 'and no input is sent into the void before everyone is known')
+
+// The fourth peer joins late and nothing it missed was ever sent, because the
+// others refused to start without it.
+const lateWorld = newHubWorld(FOUR)
+const lateSession = new NetplaySession(
+  { peer: 3, peers: FOUR, seed: 0x4bee, inputDelayTicks: 3, hashInterval: 1, timeoutTicks: 400 },
+  coopSimulation(lateWorld),
+  hub.attach(),
+)
+lateSession.start()
+hubWorlds.push(lateWorld)
+hubSessions.push(lateSession)
+for (let tick = 60; tick < 360; tick += 1) pumpRound(tick)
+expect(hubSessions.every(session => session.stats.handshaked), 'all four peers complete the handshake')
+expect(hubSessions.every(session => session.stats.acknowledged), 'every peer is acknowledged by all the others')
+expect(hubSessions.every(session => session.stats.ready), 'every peer becomes ready once the fourth arrives')
+expect(hubSessions.every(session => session.lockstep.tick >= 290), 'all four peers ran the whole session')
+expect(
+  new Set(hubSessions.map(session => session.lockstep.tick)).size === 1,
+  'a late joiner runs level with the peers that waited for it, tick for tick',
+)
+expect(hubWorlds.every(world => world.players.length === FOUR), 'each world holds one fighter per peer')
+const hubDigests = new Set(hubWorlds.map(world => coopDigest(world)))
+expect(hubDigests.size === 1, 'all four independently simulated worlds are identical')
+expect(hubSessions.every(session => session.desyncReport === null), 'four peers do not desync')
+expect(
+  hubSessions.every(session => session.stats.hashesCompared > 200 && session.stats.hashesAgreed === session.stats.hashesCompared),
+  'every hash every peer could check agreed',
+)
+expect(
+  hubSessions.every(session => session.stats.malformed === 0),
+  'four peers exchange only well-formed messages',
+)
+expect(hubWorlds[0]!.kills > 0, 'four fighters killed something together')
+expect(
+  hubWorlds[0]!.players.some((player, index) => index > 0 && player.x !== hubWorlds[0]!.players[0]!.x),
+  'the fighters stand where their own peer drove them',
+)
+expect(hubSessions[0]!.peerSeeds.length === 3, 'every peer seed is recorded, not just the first')
+expect(hubSessions[0]!.peerSeeds.every(entry => entry.seed === 0x4bee), 'every peer reports the same world seed')
+
+// One of the four goes quiet: the others must stall rather than run on without it.
+const beforeQuiet = hubSessions.map(session => session.lockstep.tick)
+hub.held.add(2)
+for (let tick = 360; tick < 420; tick += 1) pumpRound(tick)
+const stalledTicks = hubSessions.map((session, index) => session.lockstep.tick - beforeQuiet[index]!)
+expect(hubSessions.every(session => session.desyncReport === null), 'a quiet peer in a four-peer game causes no desync')
+expect(
+  hubSessions[0]!.lockstep.tick <= hubSessions[2]!.lockstep.tick,
+  'the peers that lost a partner ran no further than the one they lost',
+)
+expect(
+  hubSessions.slice(0, 3).every(session => session.stats.waiting > 10),
+  'the peers that lost a partner counted the ticks they could not run',
+)
+// Releasing the link leaves everyone the backlog they need to finish level.
+hub.held.delete(2)
+for (let tick = 420; tick < 520; tick += 1) pumpRound(tick)
+const target = Math.max(...hubSessions.map(session => session.lockstep.tick))
+for (let round = 0; round < 40; round += 1) {
+  for (let index = 0; index < FOUR; index += 1) {
+    const session = hubSessions[index]!
+    if (session.lockstep.tick >= target) continue
+    session.setIntent(scriptedInput(index, session.lockstep.tick))
+    session.pump()
+  }
+  hub.flush()
+}
+expect(
+  hubSessions.every(session => session.lockstep.tick === target),
+  'after the link recovers, every peer can be brought level from its own backlog',
+)
+expect(new Set(hubWorlds.map(world => coopDigest(world))).size === 1, 'the four worlds are still identical after a stall')
+expect(stalledTicks[0]! < 60, 'the stall really did hold the other peers back')
+
+// --- a peer that alters input in flight is detected --------------------------
+
+/**
+ * A transport that rewrites the movement in the first input message it forwards.
+ *
+ * This is the shape of a real bug: not a malicious peer, but a corrupted or
+ * mismatched build. The field is chosen so the change *must* matter — a movement
+ * of half a step moves the player, whereas flipping the attack flag on a tick with
+ * nothing in reach changes nothing, and a tamper that changes nothing proves
+ * nothing. The first input message is the warm-up frame for tick 0, which the send
+ * cursor fills in so that the first ticks have inputs at all; the world must
+ * therefore diverge at tick 0.
+ *
+ * @param inner - the transport to wrap.
+ * @returns the tampering transport.
+ */
+function tamperingTransport(inner: MemoryTransport): Transport {
+  let tampered = false
+  return {
+    send: (data) => {
+      if (!tampered && data[0] === 2) {
+        tampered = true
+        const copy = new Uint8Array(data)
+        copy[6] = 500 & 0xff // movement x := 0.5, a value the script never sends
+        copy[7] = (500 >> 8) & 0xff
+        inner.send(copy)
+        return
+      }
+      inner.send(data)
+    },
+    onMessage: handler => { inner.onMessage(handler) },
+    onClose: handler => { inner.onClose(handler) },
+    close: () => { inner.close() },
+    get open(): boolean { return inner.open },
+  }
+}
+
+const [honestPipe, cheatPipe] = memoryTransportPair()
+const honest = makePeer(0, honestPipe, 0x2222)
+const cheat = makePeer(1, tamperingTransport(cheatPipe), 0x2222)
+honestPipe.flush()
+for (let tick = 0; tick < 40; tick += 1) {
+  honest.session.setIntent(scriptedInput(0, tick))
+  cheat.session.setIntent(scriptedInput(1, tick))
+  honest.session.pump()
+  cheat.session.pump()
+  honestPipe.flush()
+}
+const report = honest.session.desyncReport ?? cheat.session.desyncReport
+expect(report !== null, 'a tampered input is detected as a desync')
+expect(report !== null && report.tick === 0, 'the desync is reported at the tick the tampered input applied to')
+expect(report !== null && report.local !== report.remote, 'the report carries both digests so the divergence is diagnosable')
+expect(honest.session.stats.hashesCompared > 0, 'hashes were exchanged before the divergence was found')
+
+// --- garbage on the wire is dropped, not fatal -------------------------------
+
+const [cleanPipe, noisyPipe] = memoryTransportPair()
+const calm = makePeer(0, cleanPipe, 0x3333)
+const noisy = makePeer(1, noisyPipe, 0x3333)
+// One end receives an unknown type, the other an empty frame: both directions of
+// nonsense, delivered before either peer runs a tick.
+cleanPipe.send(new Uint8Array([200, 1, 2, 3]))
+noisyPipe.send(new Uint8Array(0))
+cleanPipe.flush()
+for (let tick = 0; tick < 20; tick += 1) {
+  calm.session.setIntent(scriptedInput(0, tick))
+  noisy.session.setIntent(scriptedInput(1, tick))
+  calm.session.pump()
+  noisy.session.pump()
+  cleanPipe.flush()
+}
+expect(noisy.session.stats.malformed === 1, 'an unknown message type is counted and dropped')
+expect(calm.session.stats.malformed === 1, 'an empty frame is counted and dropped at the other end')
+expect(noisy.session.stats.stepped > 10, 'the session keeps running after a malformed message')
+expect(calm.session.desyncReport === null && noisy.session.desyncReport === null, 'garbage does not desync the game')
+expect(digest(calm.game) === digest(noisy.game), 'a malformed message leaves both worlds identical')
+
+// --- a silent peer is a timeout, not a desync --------------------------------
+
+// Peer 0's outbound link is held, so peer 1 hears nothing at all: that is the
+// "the other player vanished" case, and it must read as a loss, not a divergence.
+const [lostPipe, gonePipe] = memoryTransportPair()
+const heardFrom = makePeer(0, lostPipe, 0x4444)
+const starved = makePeer(1, gonePipe, 0x4444)
+lostPipe.flush()
+lostPipe.hold = true
+for (let tick = 0; tick < 60; tick += 1) {
+  heardFrom.session.setIntent(scriptedInput(0, tick))
+  starved.session.setIntent(scriptedInput(1, tick))
+  heardFrom.session.pump()
+  starved.session.pump()
+  lostPipe.flush()
+}
+expect(starved.session.stats.timedOut, 'a peer nothing has been heard from is declared lost')
+expect(starved.session.stats.waiting > 20, 'the starved peer counted every tick it could not run')
+expect(starved.session.lockstep.tick === 0, 'the starved peer never fabricated the input it was missing')
+expect(starved.session.desyncReport === null && heardFrom.session.desyncReport === null, 'a lost peer is a timeout, never a desync')
+// The other end does *not* give up: its peer is still retrying its handshake, so
+// something is arriving. "No answer yet" and "no peer" are different states, and
+// the session is expected to tell them apart.
+expect(!heardFrom.session.stats.timedOut, 'a peer still trying to handshake is not declared lost')
+expect(starved.session.stats.helloSent > 1, 'a peer whose handshake goes unanswered keeps retrying it')
+// The other end hears those hellos and answers them, but its answers never
+// arrive, so its own handshake is never acknowledged and it keeps retrying too:
+// "no acknowledgement" is the condition for retrying, not "no answer".
+expect(heardFrom.session.stats.helloSent > 1, 'a peer whose own hello was never acknowledged keeps retrying it')
+expect(!heardFrom.session.stats.acknowledged, 'an unacknowledged handshake is never called complete')
+expect(heardFrom.session.lockstep.tick === 0, 'neither peer runs a tick before the handshake completes')
+
+// --- goodbye -----------------------------------------------------------------
+
+const [byePipe] = memoryTransportPair()
+const leaving = makePeer(0, byePipe, 0x5555)
+leaving.session.pump()
+byePipe.flush()
+leaving.session.leave()
+expect(!leaving.session.stats.connected, 'leaving closes the pipe')
+expect(leaving.session.stats.sent === 2, 'leaving sends exactly the goodbye after the handshake')
+
+// --- the same sessions over a real socket ------------------------------------
+
+const relay = await startRelay(0)
+const socketA = new WebSocket(relay.url)
+const socketB = new WebSocket(relay.url)
+await Promise.all([
+  new Promise<void>(resolve => { socketA.addEventListener('open', () => { resolve() }) }),
+  new Promise<void>(resolve => { socketB.addEventListener('open', () => { resolve() }) }),
+])
+expect(relay.accepted === 2, 'the relay accepted both peers')
+
+const netA = makePeer(0, socketTransport(socketA as unknown as Parameters<typeof socketTransport>[0]), 0x7777)
+const netB = makePeer(1, socketTransport(socketB as unknown as Parameters<typeof socketTransport>[0]), 0x7777)
+
+const deadline = Date.now() + 4000
+for (let tick = 0; tick < 150 && Date.now() < deadline; tick += 1) {
+  netA.session.setIntent(scriptedInput(0, tick))
+  netB.session.setIntent(scriptedInput(1, tick))
+  netA.session.pump()
+  netB.session.pump()
+  // Real sockets deliver on the event loop, so the session is pumped more than
+  // once per scripted tick: a peer that is ahead stalls until its peer catches up.
+  await new Promise(resolve => { setTimeout(resolve, 8) })
+  netA.session.pump()
+  netB.session.pump()
+  await new Promise(resolve => { setTimeout(resolve, 1) })
+}
+
+expect(netA.session.stats.handshaked && netB.session.stats.handshaked, 'the handshake crosses a real socket')
+expect(relay.forwarded > 200, 'the relay forwarded traffic in both directions')
+expect(netA.session.stats.stepped > 120 && netB.session.stats.stepped > 120, 'both peers ran the game over the socket')
+expect(Math.abs(netA.session.stats.stepped - netB.session.stats.stepped) <= 1, 'the peers stay within one tick of each other')
+expect(netA.session.desyncReport === null && netB.session.desyncReport === null, 'no desync over a real socket')
+expect(
+  netA.session.stats.hashesCompared > 50 && netA.session.stats.hashesCompared === netA.session.stats.hashesAgreed,
+  'every hash that crossed the socket agreed',
+)
+expect(
+  netB.session.stats.hashesCompared > 50 && netB.session.stats.hashesCompared === netB.session.stats.hashesAgreed,
+  'every hash that crossed the socket agreed at the other peer',
+)
+expect(digest(netA.game) === digest(netB.game), 'two worlds fed by a real socket end up identical')
+expect(netA.session.stats.malformed === 0 && netB.session.stats.malformed === 0, 'the socket transport framed every message correctly')
+
+// Closing the socket must be observed by the session rather than hanging it.
+netA.session.leave()
+await new Promise(resolve => { setTimeout(resolve, 40) })
+expect(!netB.session.stats.connected, 'a peer leaving over a socket is observed by the other end')
+
+socketA.close()
+socketB.close()
+await relay.close()
+expect(relay.clients === 0, 'the relay closes every client')
+
+// --- three peers over real sockets -------------------------------------------
+
+const relayThree = await startRelay(0)
+const THREE = 3
+const threeWorlds = [newHubWorld(THREE), newHubWorld(THREE), newHubWorld(THREE)]
+const threeSessions: NetplaySession[] = []
+for (let index = 0; index < THREE; index += 1) {
+  const socket = new WebSocket(relayThree.url)
+  await new Promise<void>(resolve => { socket.addEventListener('open', () => { resolve() }) })
+  const session = new NetplaySession(
+    { peer: index, peers: THREE, seed: 0x3eed, inputDelayTicks: 4, hashInterval: 1, timeoutTicks: 400 },
+    coopSimulation(threeWorlds[index]!),
+    socketTransport(socket as unknown as Parameters<typeof socketTransport>[0]),
+  )
+  session.start()
+  threeSessions.push(session)
+}
+const threeSockets: WebSocket[] = []
+expect(relayThree.accepted === THREE, 'the relay accepts all three peers')
+
+const threeDeadline = Date.now() + 6000
+for (let tick = 0; tick < 160 && Date.now() < threeDeadline; tick += 1) {
+  for (let index = 0; index < THREE; index += 1) {
+    threeSessions[index]!.setIntent(scriptedInput(index, tick))
+    threeSessions[index]!.pump()
+  }
+  await new Promise(resolve => { setTimeout(resolve, 7) })
+  for (let index = 0; index < THREE; index += 1) threeSessions[index]!.pump()
+  await new Promise(resolve => { setTimeout(resolve, 1) })
+}
+expect(threeSessions.every(session => session.stats.handshaked), 'three peers complete the handshake over real sockets')
+expect(threeSessions.every(session => session.stats.acknowledged), 'three peers are acknowledged by each other')
+expect(threeSessions.every(session => session.desyncReport === null), 'three peers over sockets do not desync')
+expect(threeSessions.every(session => session.stats.malformed === 0), 'the socket transport frames every message for three peers')
+expect(
+  threeSessions.every(session => session.stats.hashesCompared > 50 && session.stats.hashesAgreed === session.stats.hashesCompared),
+  'three peers agree on every hash they could check',
+)
+// Level the peers that fell behind, then require byte-identical worlds.
+const threeTarget = Math.max(...threeSessions.map(session => session.lockstep.tick))
+for (let round = 0; round < 40; round += 1) {
+  for (let index = 0; index < THREE; index += 1) {
+    const session = threeSessions[index]!
+    if (session.lockstep.tick >= threeTarget) continue
+    session.setIntent(scriptedInput(index, session.lockstep.tick))
+    session.pump()
+  }
+  await new Promise(resolve => { setTimeout(resolve, 4) })
+}
+expect(
+  threeSessions.every(session => session.lockstep.tick === threeTarget),
+  'three peers over sockets can be brought level from their backlog',
+)
+expect(
+  new Set(threeWorlds.map(world => coopDigest(world))).size === 1,
+  'three worlds fed by real sockets are identical',
+)
+for (const session of threeSessions) session.leave()
+await new Promise(resolve => { setTimeout(resolve, 40) })
+await relayThree.close()
+expect(relayThree.clients === 0, 'the three-peer relay closes every client')
+void threeSockets
+
+console.log(`checks     ${String(checks)}`)
+console.log(`problems   ${String(problems.length)}`)
+for (const problem of problems.slice(0, 12)) console.log(`  - ${problem}`)
+console.log(problems.length === 0 ? 'RESULT     protocol, transports and two-peer lockstep hold' : 'RESULT     FAILED')
+process.exit(problems.length === 0 ? 0 : 1)
diff --git a/scripts/verify-object-lookup.ts b/scripts/verify-object-lookup.ts
new file mode 100644
index 0000000..a600952
--- /dev/null
+++ b/scripts/verify-object-lookup.ts
@@ -0,0 +1,180 @@
+// verify-object-lookup.ts — 验收"DS1 对象 id → 实际 token/mode"这层查找
+//
+// 这一层是移植来的（OpenDiablo2 的 object_lookup_record_data.go），所以它必须与**另一个独立
+// 来源**对得上才能算数：拿表里的 `objectsTxtId` 去 `Objects.txt` 查 Token，两者应当一致；
+// 不一致的地方要**逐条列出来**并写清为什么（实测正好 26 条，全是 `Objects.txt` 写了占位符
+// `SS`/`XX`/`SL`/`QO` 而表里是真 token 的情况）。
+//
+//   node scripts/verify-object-lookup.ts [--dir=samples/d2]
+//
+// 退出码非 0 表示有断言没过。
+
+export {}
+
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { fileSource } from '../src/mpq/file-source.ts'
+import { MountedArchives } from '../src/mpq/mount.ts'
+import { loadObjectsTable } from '../src/game/objects.ts'
+import type { ObjectsTable } from '../src/game/objects.ts'
+import { OBJECT_LOOKUP_WITH_ART, OBJECT_LOOKUP_WITH_ROW, OBJECT_LOOKUP_WITHOUT_ART } from '../src/game/object-lookup-data.ts'
+import { lookupObject, objectLookupStats } from '../src/game/object-lookup.ts'
+
+/** 归档目录。 */
+const DIR = process.argv.find(argument => argument.startsWith('--dir='))?.slice('--dir='.length) ?? 'samples/d2'
+
+/**
+ * `Objects.txt` 的 Token 列与查找表不一致、且**以查找表为准**的记录。
+ *
+ * 这些行的 `Objects.txt` Token 是占位符（`SS`/`XX`/`SL`/`QO`/`5F`/`6T`/…），而表里是引擎真正
+ * 使用的 token（例如 act 2 的 jerhyn 是 `JE`）。上一轮"有美术但 Objects.txt 里没有对应行"的
+ * 那串 token（`5I 5J 5M 5N 5O 9C …`）正是这批。表是这三条来源里唯一的真值，所以这里是白名单
+ * 而不是失败项；但**必须逐条固定**，任何新增都会让断言失败，逼人重新核对。
+ */
+const TOKEN_OVERRIDES: readonly string[] = [
+  '1/110/385:DC',
+  '1/113/0:29',
+  '2/16/121:JE',
+  '2/17/122:JE',
+  '2/102/133:AZ',
+  '3/13/194:9C',
+  '3/93/361:XO',
+  '3/109/378:HR',
+  '3/110/379:HR',
+  '4/19/363:XQ',
+  '4/46/255:DI',
+  '4/64/408:98',
+  '4/65/409:99',
+  '5/31/419:YO',
+  '5/33/425:YU',
+  '5/53/459:XS',
+  '5/54/460:2N',
+  '5/55/461:0J',
+  '5/56/462:0J',
+  '5/92/509:5M',
+  '5/103/511:5O',
+  '5/107/504:5I',
+  '5/108/505:5J',
+  '5/111/510:5N',
+  '5/125/542:XR',
+  '5/126/543:XR',
+]
+
+/** 断言结果。 */
+const checks: { name: string; ok: boolean; detail: string }[] = []
+
+/**
+ * 记录一条断言。
+ *
+ * @param name - what was checked.
+ * @param ok - whether it held.
+ * @param detail - evidence.
+ */
+function check(name: string, ok: boolean, detail: string): void {
+  checks.push({ name, ok, detail })
+  console.log(`${ok ? 'ok  ' : 'FAIL'} ${name} — ${detail}`)
+}
+
+/**
+ * 主流程。
+ */
+async function main(): Promise<void> {
+  const stats = objectLookupStats()
+  console.log(`lookup: acts ${stats.acts.join(',')}，记录 ${String(stats.rows)}，有 token ${String(stats.withArt)}，无 token ${String(stats.withoutArt)}，有 Objects.txt 行 ${String(stats.withRow)}\n`)
+
+  check('五个 act 都有查找表', stats.acts.join(',') === '1,2,3,4,5', stats.acts.join(','))
+  check('记录数与生成物一致', stats.rows === OBJECT_LOOKUP_WITH_ART + OBJECT_LOOKUP_WITHOUT_ART,
+    `${String(stats.rows)} = ${String(OBJECT_LOOKUP_WITH_ART)} + ${String(OBJECT_LOOKUP_WITHOUT_ART)}`)
+  check('有 token 的记录数稳定', stats.withArt === OBJECT_LOOKUP_WITH_ART && stats.withRow === OBJECT_LOOKUP_WITH_ROW,
+    `withArt=${String(stats.withArt)} withRow=${String(stats.withRow)}`)
+  check('记录数 = 3,614（3,615 条物体行里有 1 条重复 id 被覆盖）', stats.rows === 3614, `${String(stats.rows)} 条`)
+  check('无 token 的记录数 = 193（不可见/占位对象）', stats.withoutArt === 193, `${String(stats.withoutArt)} 条`)
+
+  // 具体点位：这些名字是从社区表里读出来的，写成断言是为了让"表换了版本"立刻暴露。
+  const spots: readonly [number, number, string, string, string][] = [
+    [1, 0, 'FN', 'NU', 'rogue fountain'],
+    [1, 1, 'TO', 'ON', 'torch 1 tiki'],
+    [1, 2, 'RB', 'ON', 'Fire, rogue camp'],
+    [1, 5, 'L1', 'NU', 'Chest, R Large'],
+    [2, 17, 'JE', 'NU', 'jerhyn'],
+    [5, 0, 'AO', 'NU', 'act 5 first object'],
+  ]
+  for (const [act, id, token, mode, label] of spots) {
+    const entry = lookupObject(act, 2, id)
+    check(`act ${String(act)} id ${String(id)} → ${token}/${mode}（${label}）`,
+      entry !== null && entry.token === token && entry.mode === mode,
+      entry === null ? '查不到' : `${entry.token}/${entry.mode}`)
+  }
+  check('怪物类型不命中本表', lookupObject(1, 1, 0) === null, 'type 1 走 MonPreset，不是本表')
+  check('表里没有的 act 返回 null', lookupObject(9, 2, 0) === null, 'act 9 不存在')
+
+  // 与 Objects.txt 交叉核对。
+  const archives = new MountedArchives()
+  for (const name of ['d2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq']) {
+    archives.add(name, await MpqArchive.open(await fileSource(`${DIR}/${name}`)))
+  }
+  const tables: ObjectsTable = await loadObjectsTable(archives)
+  let same = 0
+  let diffToken = 0
+  let emptyToken = 0
+  let missingRow = 0
+  const unexpected: string[] = []
+  const missingOverrides: string[] = []
+  const seenOverrides = new Set<string>()
+  const missingRowTokens: string[] = []
+  for (const act of stats.acts) {
+    for (const entry of lookupObjectRows(act)) {
+      // 表说"没有 token"的记录（193 条）是不可见/占位对象：画不出来是对的。
+      if (entry.token === '') { emptyToken += 1; continue }
+      // 表给了 token 却没给行号：靠 token 反查元数据，下面单独断言。
+      if (entry.objectsTxtId < 0) continue
+      const row = tables.byId.get(entry.objectsTxtId)
+      if (row === undefined) {
+        // 社区表是对着另一版 Objects.txt 做的：有 3 条行号在 1.13c 里不存在。
+        missingRow += 1
+        missingRowTokens.push(entry.token)
+        continue
+      }
+      const tableToken = row.token.trim().toUpperCase()
+      const lookupToken = entry.token.toUpperCase()
+      if (lookupToken === tableToken) { same += 1; continue }
+      diffToken += 1
+      const key = `${String(act)}/${String(entry.ds1Id)}/${String(entry.objectsTxtId)}:${lookupToken}`
+      seenOverrides.add(key)
+      if (!TOKEN_OVERRIDES.includes(key)) {
+        unexpected.push(`${key}（Objects.txt 写的是 "${tableToken}"，name "${row.name}"）`)
+      }
+    }
+  }
+  for (const key of TOKEN_OVERRIDES) if (!seenOverrides.has(key)) missingOverrides.push(key)
+  console.log(`\n   与 Objects.txt 交叉核对：一致 ${String(same)}，表覆盖占位符 ${String(diffToken)}，表说无 token ${String(emptyToken)}，行号在 1.13c 里不存在 ${String(missingRow)}`)
+  check('不一致的记录恰好是那批占位符 token', unexpected.length === 0,
+    unexpected.length === 0 ? `${String(TOKEN_OVERRIDES.length)} 条全部对上` : unexpected.slice(0, 5).join(' | '))
+  check('覆盖条数 = 26', diffToken === TOKEN_OVERRIDES.length, `${String(diffToken)} 条`)
+  check('白名单没有过期条目', missingOverrides.length === 0,
+    missingOverrides.length === 0 ? '全部仍然有效' : missingOverrides.slice(0, 5).join(' | '))
+  check('与 Objects.txt 完全一致的记录数 = 527', same === 527, `${String(same)} 条`)
+  check('表说无 token 的记录数 = 193', emptyToken === 193, `${String(emptyToken)} 条`)
+  check('行号缺失的 3 条仍然带真 token', missingRow === 3 && missingRowTokens.sort().join(',') === '7C,PX,PY',
+    `缺失行号的 token：${missingRowTokens.join(',')}`)
+
+  const passed = checks.filter(entry => entry.ok).length
+  console.log(`\n${String(passed)}/${String(checks.length)} passed`)
+  if (passed !== checks.length) process.exitCode = 1
+}
+
+/**
+ * 枚举一个 act 的全部记录（`lookupObject` 是单点查询，这里要遍历）。
+ *
+ * @param act - act 号.
+ * @returns the entries of that act.
+ */
+function lookupObjectRows(act: number): { ds1Id: number; objectsTxtId: number; token: string }[] {
+  const out: { ds1Id: number; objectsTxtId: number; token: string }[] = []
+  for (let id = 0; id < 4000; id += 1) {
+    const entry = lookupObject(act, 2, id)
+    if (entry !== null) out.push(entry)
+  }
+  return out
+}
+
+await main()
diff --git a/scripts/verify-objects.ts b/scripts/verify-objects.ts
new file mode 100644
index 0000000..c099f2d
--- /dev/null
+++ b/scripts/verify-objects.ts
@@ -0,0 +1,694 @@
+/**
+ * Verify the DS1 object → art rule against the real Diablo II archives.
+ *
+ * The rule this checks is not a guess: it is ported from ThePhrozenKeep/D2MOO
+ * (see the module comment in `src/game/objects.ts`), and the point of this script
+ * is to prove the port against bytes the user supplied rather than against the
+ * doc comment that describes it. Four independent things are measured:
+ *
+ * 1. **Where the object art actually is.** The project's notes said `d2char.mpq`;
+ *    the archives say otherwise, and this prints the per-archive counts so the
+ *    claim is checkable rather than asserted.
+ * 2. **The composition template.** Every object COF in the archives declares its
+ *    layers as *composite indices*, not file names, so the sprite path has to be
+ *    reconstructed from the COF's own name plus that index — the same trick
+ *    `scripts/verify-dcc.ts` uses for the Sorceress. This rebuilds all 1746 layer
+ *    references and reports exactly which ones the rule does not reach.
+ * 3. **Every object placed by a preset level.** `Levels.txt` rows with
+ *    `DrlgType === 2` name fixed DS1 files, so this walks all 35 of them, decodes
+ *    the maps and resolves each placed object's art, grouping the results by
+ *    level type. Any object that fails to resolve fails the run — a packer that
+ *    silently drops one is the bug this exists to catch.
+ * 4. **The draw anchors.** `DUNGEON_GameToClientTileDrawPositionCoords` and
+ *    `DUNGEON_GameToClientSubtileDrawPositionCoords` (D2Common ordinals 10115 and
+ *    10117) are printed next to the formulas this project currently uses, and the
+ *    DT1 `minBlockY` of every floor and wall tile a preset level actually
+ *    references is measured, because that is the term that decides whether the
+ *    project's wall formula and the engine's agree.
+ *
+ * Usage:
+ *   node scripts/verify-objects.ts [archive-directory]
+ *
+ * Exits non-zero when an object placed in a preset level cannot be resolved, when
+ * a sampled member decodes to empty pixels, or when the ported coordinate
+ * arithmetic fails its own round-trips.
+ */
+import { readFileSync } from 'node:fs'
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { fileSource } from '../src/mpq/file-source.ts'
+import { MountedArchives } from '../src/mpq/mount.ts'
+import { cell, loadActTables, resolveLevel } from '../src/game/acts.ts'
+import type { ActTables } from '../src/game/acts.ts'
+import { decodeDs1 } from '../src/formats/ds1.ts'
+import type { Ds1 } from '../src/formats/ds1.ts'
+import { decodeDt1 } from '../src/formats/dt1.ts'
+import type { Dt1, Dt1Tile } from '../src/formats/dt1.ts'
+import { decodeCof } from '../src/formats/cof.ts'
+import { decodeDcc } from '../src/formats/dcc.ts'
+import { decodeDc6 } from '../src/formats/dc6.ts'
+import {
+  OBJECT_COMPONENTS,
+  OBJECT_MODE_COUNT,
+  OBJECT_MODE_TOKENS,
+  clientSubtileDrawPositionToGameCoords,
+  clientTileDrawPositionToGameCoords,
+  gameSubtileToClientCoords,
+  gameTileToClientCoords,
+  loadObjectSheet,
+  loadObjectsTable,
+  objectAnchor,
+  objectCofMember,
+  objectDrawAnchor,
+  objectSpriteMember,
+  resolveDs1Object,
+  resolveObjectArt,
+  subtileDrawPositionCoords,
+  tileDrawPositionCoords,
+} from '../src/game/objects.ts'
+import type { ObjectsRow, ObjectsTable } from '../src/game/objects.ts'
+
+/** Archives to mount, in load order (later overrides earlier). */
+const MOUNTS = ['d2char.mpq', 'd2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq'] as const
+/**
+ * Community listfile that supplies the names Storm stores encrypted.
+ *
+ * `d2data.mpq` and `Patch_D2.mpq` ship no `(listfile)`, so without it "this member
+ * is not in the archives" would only mean "not in the archives we could enumerate".
+ * The file is optional: when it is absent the sweep still runs, but the member
+ * index is then incomplete and the run says so.
+ */
+const LISTFILE = 'listfile_113c.txt'
+/** Prefix every object member lives under. */
+const OBJECT_ROOT = 'data\\global\\objects\\'
+/** `DrlgType` value for a preset level: its layout is a fixed DS1. */
+const DRLG_PRESET = '2'
+/** Cap on members decoded in the sample sweep, so the run stays bounded. */
+const DECODE_SAMPLE_LIMIT = 60
+/** Cap on individually printed failures. */
+const MAX_REPORTED_FAILURES = 25
+
+const args = process.argv.slice(2)
+const archiveDir = args.find(argument => !argument.startsWith('--')) ?? 'samples/d2'
+
+let checks = 0
+let failures = 0
+const failureLog: string[] = []
+
+/**
+ * Record one assertion.
+ *
+ * @param ok - whether it held.
+ * @param what - what was asserted, printed only when it fails.
+ */
+function check(ok: boolean, what: string): void {
+  checks += 1
+  if (ok) return
+  failures += 1
+  if (failureLog.length < MAX_REPORTED_FAILURES) failureLog.push(what)
+}
+
+/**
+ * Assert a condition, returning it for reuse.
+ *
+ * @param ok - whether it held.
+ * @param what - description used in the failure log.
+ * @returns `ok`.
+ */
+function assert(ok: boolean, what: string): boolean {
+  check(ok, what)
+  return ok
+}
+
+/** Format a number with a leading sign, for the anchor comparison table. */
+function signed(value: number): string {
+  return value >= 0 ? `+${String(value)}` : String(value)
+}
+
+/** Open the four archives and mount them the way the game loads them. */
+async function mount(): Promise<MountedArchives> {
+  const archives = new MountedArchives()
+  let listfile: string[] | undefined
+  try {
+    listfile = readFileSync(`${archiveDir}/${LISTFILE}`, 'utf8')
+      .split(/\r?\n/)
+      .map(line => line.trim())
+      .filter(line => line.length > 0)
+    console.log(`   listfile: ${String(listfile.length)} names from ${LISTFILE}`)
+  } catch {
+    console.log(`   listfile: ${LISTFILE} missing — member index is incomplete`)
+    listfile = undefined
+  }
+  for (const name of MOUNTS) {
+    const archive = await MpqArchive.open(await fileSource(`${archiveDir}/${name}`), { listfile })
+    archives.add(name, archive)
+  }
+  return archives
+}
+
+/** The union of every mounted archive's member list, plus a lower-case index. */
+interface MemberSet {
+  readonly names: readonly string[]
+  readonly lower: ReadonlyMap<string, string>
+}
+
+/**
+ * Build the case-insensitive member index.
+ *
+ * Diablo II's own lookups go through Storm's case-insensitive hash and the
+ * archives really do mix case (`Data\Global\Objects\1Y\S1\1ys1litnuhth.DC6`
+ * against `data\global\objects\c5\tr\c5trlitnuhth.dcc`), so every comparison here
+ * is on the lower-cased name while the archive's own spelling is what gets used
+ * for reads.
+ *
+ * @param archives - the mounted stack.
+ * @returns the names and the index.
+ */
+async function memberSet(archives: MountedArchives): Promise<MemberSet> {
+  const names: string[] = []
+  for (const entry of archives.mounted) names.push(...await entry.archive.listFiles())
+  const lower = new Map<string, string>()
+  for (const name of names) if (!lower.has(name.toLowerCase())) lower.set(name.toLowerCase(), name)
+  return { names, lower }
+}
+
+/** Per-level-type tally for the preset-level walk. */
+interface LevelTypeTally {
+  levels: number
+  objects: number
+  resolved: number
+  fallbacks: number
+  /** Objects the archives ship no sprite for at all; `null` is the correct answer. */
+  artless: number
+  /** DS1 entries that are monster spawn points (`type` 1), not objects. */
+  monsterSpawns: number
+  modeGuesses: number
+  undefinedRows: number
+  tokens: Set<string>
+}
+
+/** Measure 1: where the object art lives, and how much of it there is. */
+async function reportArchiveLayout(archives: MountedArchives): Promise<void> {
+  console.log('== object art in the archives ==')
+  let dataTotal = 0
+  for (const entry of archives.mounted) {
+    const names = await entry.archive.listFiles()
+    const objects = names.filter(name => name.toLowerCase().startsWith(OBJECT_ROOT))
+    const dcc = objects.filter(name => name.toLowerCase().endsWith('.dcc')).length
+    const cof = objects.filter(name => name.toLowerCase().endsWith('.cof')).length
+    const dc6 = objects.filter(name => name.toLowerCase().endsWith('.dc6')).length
+    console.log(`   ${entry.label.padEnd(14)} members=${String(names.length).padStart(6)} objects=${String(objects.length).padStart(5)} dcc=${String(dcc).padStart(5)} cof=${String(cof).padStart(5)} dc6=${String(dc6).padStart(3)}`)
+    if (entry.label === 'd2data.mpq' || entry.label === 'd2exp.mpq') dataTotal += objects.length
+  }
+  assert(dataTotal > 0, 'object art must exist in d2data.mpq/d2exp.mpq')
+  console.log('   (note: d2char.mpq holds character art only; object art is in d2data/d2exp)')
+}
+
+/**
+ * Measure 2: rebuild every COF layer's sprite path and see how far the rule goes.
+ *
+ * @param archives - the mounted stack.
+ * @param members - the member index.
+ * @param tables - the parsed `Objects.txt`.
+ * @returns the tally, for the summary.
+ */
+async function verifyCompositionTemplate(
+  archives: MountedArchives,
+  members: MemberSet,
+  tables: ObjectsTable,
+): Promise<{ layers: number; dcc: number; dc6: number; unresolved: readonly string[]; cofs: number; prefixes: number }> {
+  console.log('== COF -> DCC template (D2Common_10884_COMPOSIT_unk) ==')
+  const cofs = members.names
+    .filter(name => name.toLowerCase().startsWith(OBJECT_ROOT) && name.toLowerCase().endsWith('.cof'))
+    .sort()
+  const byToken = new Map<string, ObjectsRow>()
+  for (const row of tables.rows) if (!byToken.has(row.token)) byToken.set(row.token, row)
+
+  let layers = 0
+  let dcc = 0
+  let dc6 = 0
+  let prefixes = 0
+  const unresolved: string[] = []
+  const unknownTokens = new Set<string>()
+  for (const cofMember of cofs) {
+    const parts = cofMember.split('\\')
+    const token = (parts[3] ?? '').toLowerCase()
+    const file = (parts[5] ?? '').replace(/\.cof$/i, '')
+    if (!byToken.has(token.toUpperCase())) unknownTokens.add(token.toUpperCase())
+    let cof
+    try {
+      cof = decodeCof(await archives.read(cofMember))
+    } catch (err) {
+      unresolved.push(`${cofMember}: ${(err as Error).message}`)
+      continue
+    }
+    // The COF's name is <TOKEN><MODE><WEAPON>; the suffix length comes from the
+    // layer record itself rather than from a hard-coded 3.
+    const weapon = cof.layers[0]?.weaponClass ?? 'hth'
+    const mode = file.slice(token.length, file.length - weapon.length).toLowerCase()
+    if (cofMember.toLowerCase().split('\\').slice(0, 3).join('\\') === OBJECT_ROOT.slice(0, -1)) prefixes += 1
+    for (const layer of cof.layers) {
+      layers += 1
+      const component = OBJECT_COMPONENTS[layer.type]
+      if (component === undefined) { unresolved.push(`${cofMember}: composite ${String(layer.type)} has no directory`); continue }
+      const wanted = `${OBJECT_ROOT}${token}\\${component}\\${token}${component}lit${mode}${weapon}.dcc`
+      if (members.lower.has(wanted)) { dcc += 1; continue }
+      if (members.lower.has(wanted.replace(/\.dcc$/i, '.dc6'))) { dc6 += 1; continue }
+      unresolved.push(wanted)
+    }
+  }
+  const resolved = dcc + dc6
+  console.log(`   cofs=${String(cofs.length)} layers=${String(layers)} resolved=${String(resolved)} (.dcc ${String(dcc)} / .dc6 ${String(dc6)}) unresolved=${String(unresolved.length)}`)
+  console.log(`   tokens with art but no Objects.txt row: ${[...unknownTokens].sort().join(' ') || 'none'}`)
+  for (const miss of unresolved.slice(0, 8)) console.log(`   unresolved: ${miss}`)
+  if (unresolved.length > 8) console.log(`   ... ${String(unresolved.length - 8)} more`)
+  // The five known duds (E1/E2/HO/TP/YQ ship a COF whose layer sprite is absent,
+  // or spell the armor class differently); everything else must resolve.
+  check(layers > 1700, `expected ~1746 object COF layer references, saw ${String(layers)}`)
+  check(resolved / Math.max(layers, 1) >= 0.99, `at least 99% of layers must resolve, saw ${String(resolved)}/${String(layers)}`)
+  return { layers, dcc, dc6, unresolved, cofs: cofs.length, prefixes }
+}
+
+/** One placed object, reduced to what the report needs. */
+interface Placement {
+  readonly levelId: number
+  readonly levelName: string
+  readonly levelType: string
+  readonly row: ObjectsRow
+  readonly member: string | null
+  readonly mode: string
+  readonly anchor: { readonly x: number; readonly y: number }
+  readonly guessedMode: boolean
+}
+
+/**
+ * Measure 3: walk every preset level and resolve every object it places.
+ *
+ * @param archives - the mounted stack.
+ * @param members - the member index.
+ * @param tables - the parsed `Objects.txt`.
+ * @param levelTables - the level tables.
+ * @returns every placement, in walk order.
+ */
+async function walkPresetObjects(
+  archives: MountedArchives,
+  members: MemberSet,
+  tables: ObjectsTable,
+  levelTables: ActTables,
+): Promise<{ placements: readonly Placement[]; tallies: Map<string, LevelTypeTally>; ds1Count: number; levels: number }> {
+  console.log('== objects placed by the 35 preset levels (Levels.txt DrlgType=2) ==')
+  const presetRows = levelTables.levels.rows.filter(row => cell(levelTables.levels, row, 'DrlgType') === DRLG_PRESET)
+  const libraryCache = new Map<string, Dt1>()
+  const tallies = new Map<string, LevelTypeTally>()
+  const placements: Placement[] = []
+  let ds1Count = 0
+  let levels = 0
+  for (const levelRow of presetRows) {
+    const levelId = Number(cell(levelTables.levels, levelRow, 'Id'))
+    let info
+    try {
+      info = resolveLevel(levelTables, levelId)
+    } catch (err) {
+      failures += 1
+      failureLog.push(`level ${String(levelId)}: ${(err as Error).message}`)
+      continue
+    }
+    levels += 1
+    const tally = tallies.get(info.levelTypeName) ?? {
+      levels: 0, objects: 0, resolved: 0, fallbacks: 0, artless: 0, monsterSpawns: 0,
+      modeGuesses: 0, undefinedRows: 0, tokens: new Set<string>(),
+    }
+    tally.levels += 1
+    tallies.set(info.levelTypeName, tally)
+
+    let ds1: Ds1
+    let found = false
+    for (const ds1Name of info.ds1Names) {
+      try {
+        ds1 = decodeDs1(await archives.read(ds1Name))
+      } catch {
+        continue
+      }
+      found = true
+      ds1Count += 1
+      for (const object of ds1.objects) {
+        tally.objects += 1
+        let resolved
+        try {
+          resolved = resolveDs1Object(tables, info.act, object.type, object.id)
+        } catch (err) {
+          tally.undefinedRows += 1
+          failures += 1
+          if (failureLog.length < MAX_REPORTED_FAILURES) failureLog.push(`${info.levelName} ${ds1Name}: ${(err as Error).message}`)
+          continue
+        }
+        // DS1 `type` 1 is a monster spawn point, not an object: it has no object art and
+        // this project has no monsters, so it is counted and left alone.
+        if (resolved.kind === 'monster') {
+          tally.monsterSpawns += 1
+          continue
+        }
+        const row = resolved.row
+        tally.tokens.add(resolved.token)
+        const art = resolveObjectArt({
+          object,
+          token: resolved.token,
+          row: row === null
+            ? null
+            : { name: row.name, token: resolved.token, subClass: row.subClass, mode: 0, hp: 0 },
+          mode: resolved.mode,
+          members: members.names,
+        })
+        const guessedMode = art.notes.some(note => note.includes('fell back to'))
+        if (guessedMode) tally.modeGuesses += 1
+        // `null` is the correct answer only when the archives really ship no sprite for
+        // this token *and this mode*: `Objects.txt` has invisible helper rows (`Dummy`)
+        // and modes that were never drawn (a portal's closed `NU` state has a COF but no
+        // `NU` DCC). A token that does have art for the requested mode may not resolve to
+        // null — that is the case this assertion exists to catch.
+        const tokenRoot = `\\objects\\${resolved.token.trim().toLowerCase()}\\`
+        const modeTag = `lit${art.mode.toLowerCase()}hth.`
+        const modeHasSprite = members.names.some((name) => {
+          const lower = name.toLowerCase()
+          return lower.includes(tokenRoot) && lower.includes(modeTag)
+        })
+        if (art.member === null) {
+          tally.fallbacks += 1
+          if (!assert(!modeHasSprite,
+            `${info.levelName}: ${resolved.token} has ${art.mode} art in the archives but resolved to null`)) continue
+          tally.artless += 1
+          continue
+        }
+        tally.resolved += 1
+        const exists = members.lower.has(art.member.toLowerCase())
+        if (!assert(exists, `${info.levelName}: ${resolved.token} member ${String(art.member)} is not in the archives`)) continue
+        if (!assert(Number.isFinite(art.anchor.x) && Number.isFinite(art.anchor.y), `${info.levelName}: ${resolved.token} anchor is not finite`)) continue
+        placements.push({
+          levelId,
+          levelName: info.levelName,
+          levelType: info.levelTypeName,
+          // Records with no Objects.txt row still have a real token; synthesise the
+          // metadata row so downstream reporting has one shape to deal with.
+          row: row ?? {
+            id: object.id, name: resolved.token, token: resolved.token, subClass: 0, act: info.act,
+            sizeX: 0, sizeY: 0, xOffset: 0, yOffset: 0, isDoor: false, trans: 0, draw: 0,
+            totalPieces: 0, autoMap: 0, mode: [], selectable: [], frameCnt: [], frameDelta: [],
+            start: [], cycleAnim: [], lit: [], components: [],
+          },
+          member: art.member,
+          mode: art.mode,
+          anchor: art.anchor,
+          guessedMode,
+        })
+      }
+      break
+    }
+    if (!found) {
+      failures += 1
+      failureLog.push(`level ${String(levelId)} (${info.levelName}): none of its ${String(info.ds1Names.length)} DS1 members decoded`)
+    }
+    // Keep the DT1 libraries of the last level of each type reachable for the
+    // anchor measurement below.
+    for (const dt1Name of info.dt1Names) {
+      if (libraryCache.has(dt1Name)) continue
+      libraryCache.set(dt1Name, decodeDt1(await archives.read(dt1Name)))
+    }
+  }
+
+  console.log('   level type                    levels  objects  resolved  no-art  monsters  mode-guessed  tokens')
+  // `no-art` counts objects the archives genuinely ship no sprite for (invisible helper
+  // rows and modes that were never drawn); `resolved` counts the ones that drew something.
+  for (const [type, tally] of [...tallies].sort((a, b) => a[0].localeCompare(b[0]))) {
+    console.log(`   ${type.padEnd(28)} ${String(tally.levels).padStart(6)} ${String(tally.objects).padStart(8)} ${String(tally.resolved).padStart(9)} ${String(tally.artless).padStart(7)} ${String(tally.monsterSpawns).padStart(8)} ${String(tally.modeGuesses).padStart(13)}  ${String(tally.tokens.size).padStart(6)}`)
+  }
+  const tokens = new Set(placements.map(placement => placement.row.token))
+  console.log(`   distinct tokens across all preset levels: ${String(tokens.size)} -> ${[...tokens].sort().join(' ')}`)
+  assert(levels === 35, `expected 35 preset levels, saw ${String(levels)}`)
+  assert(placements.length > 0, 'at least one object must resolve')
+  return { placements, tallies, ds1Count, levels }
+}
+
+/**
+ * Measure 4a: decode a sample of the resolved members and prove they have pixels.
+ *
+ * A name that exists is not art: this is what catches a rule that reconstructs a
+ * *plausible* path to a real file with the wrong contents, or a decoder that
+ * returns zeroed frames.
+ *
+ * @param archives - the mounted stack.
+ * @param members - the member index.
+ * @param placements - the resolved placements.
+ * @returns the number of members decoded and the total opaque pixels seen.
+ */
+async function decodeSample(
+  archives: MountedArchives,
+  members: MemberSet,
+  placements: readonly Placement[],
+): Promise<{ decoded: number; frames: number; opaque: number }> {
+  console.log('== sample decode of resolved members ==')
+  const distinct = new Map<string, Placement>()
+  for (const placement of placements) if (placement.member !== null && !distinct.has(placement.member)) distinct.set(placement.member, placement)
+  const chosen: Placement[] = []
+  const seenToken = new Set<string>()
+  for (const placement of [...distinct.values()].sort((a, b) => a.row.token.localeCompare(b.row.token))) {
+    if (seenToken.has(placement.row.token)) continue
+    seenToken.add(placement.row.token)
+    chosen.push(placement)
+    if (chosen.length >= DECODE_SAMPLE_LIMIT) break
+  }
+  let decoded = 0
+  let frames = 0
+  let opaque = 0
+  for (const placement of chosen) {
+    const member = members.lower.get((placement.member ?? '').toLowerCase())
+    if (member === undefined) continue
+    const bytes = await archives.read(member)
+    const isDc6 = member.toLowerCase().endsWith('.dc6')
+    let frameList: { width: number; height: number; mask: Uint8Array }[] = []
+    try {
+      if (isDc6) {
+        const sheet = decodeDc6(bytes)
+        frameList = sheet.groups.flatMap(group => group.frames.map(frame => ({ width: frame.width, height: frame.height, mask: frame.mask })))
+      } else {
+        const file = decodeDcc(bytes)
+        frameList = file.directions.flatMap(direction => direction.frames.map(frame => ({ width: frame.frame.width, height: frame.frame.height, mask: frame.frame.mask })))
+      }
+    } catch (err) {
+      assert(false, `${member}: ${(err as Error).message}`)
+      continue
+    }
+    const dims = frameList.every(frame => frame.width >= 1 && frame.height >= 1)
+    if (!assert(dims && frameList.length >= 1, `${member}: ${String(frameList.length)} frames, dims ok=${String(dims)}`)) continue
+    const pixels = frameList.reduce((sum, frame) => sum + frame.mask.reduce((inner, value) => inner + value, 0), 0)
+    assert(pixels > 0, `${member}: decoded to ${String(pixels)} opaque pixels`)
+    decoded += 1
+    frames += frameList.length
+    opaque += pixels
+  }
+  console.log(`   decoded ${String(decoded)} members (${String(frames)} frames, ${String(opaque)} opaque pixels) from ${String(chosen.length)} sampled objects`)
+  return { decoded, frames, opaque }
+}
+
+/**
+ * Measure 4b: composite one object through its real COF, the engine's own path.
+ *
+ * @param archives - the mounted stack.
+ * @param members - the member index, to confirm the COF is really in the archives.
+ * @param placements - the resolved placements.
+ * @returns the number of sheets composited.
+ */
+async function compositeSample(
+  archives: MountedArchives,
+  members: MemberSet,
+  placements: readonly Placement[],
+): Promise<number> {
+  console.log('== COF composition (the engine\'s entry point) ==')
+  const chosen: Placement[] = []
+  const seen = new Set<string>()
+  for (const placement of placements) {
+    const key = `${placement.row.token}:${placement.mode}`
+    if (seen.has(key)) continue
+    seen.add(key)
+    chosen.push(placement)
+    if (chosen.length >= 12) break
+  }
+  let composited = 0
+  let layers = 0
+  let opaque = 0
+  for (const placement of chosen) {
+    const modeIndex = OBJECT_MODE_TOKENS.indexOf(placement.mode as (typeof OBJECT_MODE_TOKENS)[number])
+    try {
+      const sheet = await loadObjectSheet(archives, placement.row.token, Math.max(modeIndex, 0), placement.row)
+      const frames = sheet.sheet.groups[0]?.frames ?? []
+      const pixels = frames.reduce((sum, frame) => sum + frame.mask.reduce((inner, value) => inner + value, 0), 0)
+      const cofExists = members.lower.has(objectCofMember(placement.row.token, Math.max(modeIndex, 0)))
+      assert(cofExists, `${objectCofMember(placement.row.token, modeIndex)} must exist for ${placement.row.token}`)
+      assert(sheet.members.length >= 1, `${placement.row.token} ${placement.mode}: COF resolved no sprite layers (${sheet.notes.join('; ')})`)
+      if (!assert(pixels > 0, `${placement.row.token} ${placement.mode}: composited to ${String(pixels)} opaque pixels`)) continue
+      composited += 1
+      layers += sheet.members.length
+      opaque += pixels
+    } catch (err) {
+      assert(false, `${placement.row.token} ${placement.mode}: ${(err as Error).message}`)
+    }
+  }
+  // Every object token a preset level places must have a readable COF for its
+  // neutral mode: that is the file the engine actually loads.
+  const tokensPlaced = new Set(placements.map(placement => placement.row.token))
+  const withoutCof = [...tokensPlaced].filter(token => !members.lower.has(objectCofMember(token, 0)))
+  assert(withoutCof.length === 0, `placed tokens with no neutral COF: ${withoutCof.join(' ')}`)
+  console.log(`   composited ${String(composited)} object animations (${String(layers)} layers, ${String(opaque)} opaque pixels) from ${String(tokensPlaced.size)} distinct tokens`)
+  return composited
+}
+
+/**
+ * Measure 4c: the anchor arithmetic, ported and compared.
+ *
+ * @param archives - the mounted stack.
+ * @param levelTables - the level tables.
+ * @param placements - the resolved placements.
+ */
+async function reportAnchors(
+  archives: MountedArchives,
+  levelTables: ActTables,
+  placements: readonly Placement[],
+): Promise<void> {
+  console.log('== draw anchors: D2Dungeon.cpp 10115 / 10117 vs this project ==')
+  // Identities the port must satisfy.
+  let identity = true
+  for (let x = -6; x <= 6; x += 1) {
+    for (let y = -6; y <= 6; y += 1) {
+      const tile = tileDrawPositionCoords(x, y)
+      const tileCentre = gameTileToClientCoords(x, y)
+      if (tile.x !== tileCentre.x - 80 || tile.y !== tileCentre.y + 80) identity = false
+      const sub = subtileDrawPositionCoords(x, y)
+      const subCentre = gameSubtileToClientCoords(x, y)
+      if (sub.x !== subCentre.x - 16 || sub.y !== subCentre.y + 16) identity = false
+      const backTile = clientTileDrawPositionToGameCoords(tile.x, tile.y)
+      if (backTile.x !== x || backTile.y !== y) identity = false
+      const backSub = clientSubtileDrawPositionToGameCoords(sub.x, sub.y)
+      if (backSub.x !== x || backSub.y !== y) identity = false
+      // Negative results must floor, not truncate: the C++ idiom is `v / n - 1`.
+      const floored = clientTileDrawPositionToGameCoords(tile.x - 1, tile.y - 1)
+      if (floored.x !== x - 1 || floored.y !== y - 1) identity = false
+    }
+  }
+  assert(identity, 'tile/subtile draw positions must equal the centre conversion plus (-80,+80)/(-16,+16) and round-trip on 169 coordinates')
+  const engineObject = objectDrawAnchor(0, 0, 0, 0)
+  assert(engineObject.x === -16 && engineObject.y === 16, `objectDrawAnchor(0,0,0,0) must be (-16,+16), saw (${String(engineObject.x)},${String(engineObject.y)})`)
+
+  const sampleX = 12
+  const sampleY = 7
+  const engineFloor = tileDrawPositionCoords(sampleX, sampleY)
+  // This project's values, from src/game/d2map.ts (TILE_ANCHOR_X = -80,
+  // WALL_SURFACE_HEIGHT = 80) and from the packer's object placement.
+  const projectFloorX = (sampleX - sampleY) * 80 - 80
+  const projectFloorY = (sampleX + sampleY) * 40
+  const projectWallExtra = 80
+  const engineObjectAt = subtileDrawPositionCoords(sampleX * 5, sampleY * 5)
+  const projectObjectX = (sampleX * 5 - sampleY * 5) * 16 - 32 / 2
+  const projectObjectY = (sampleX * 5 + sampleY * 5) * 8 + 16
+
+  console.log(`   cell (${String(sampleX)},${String(sampleY)})`)
+  console.log(`   floor   engine DUNGEON_GameToClientTileDrawPositionCoords = (${String(engineFloor.x)}, ${String(engineFloor.y)})`)
+  console.log(`   floor   this project ((cx-cy)*80-80, (cx+cy)*40)          = (${String(projectFloorX)}, ${String(projectFloorY)})   delta (${signed(engineFloor.x - projectFloorX)}, ${signed(engineFloor.y - projectFloorY)})`)
+  console.log(`   wall    this project adds minBlockY + WALL_SURFACE_HEIGHT = minBlockY ${signed(projectWallExtra)}; engine adds only the block's own offset to the same tile draw position`)
+  console.log(`   object  engine DUNGEON_GameToClientSubtileDrawPositionCoords = (${String(engineObjectAt.x)}, ${String(engineObjectAt.y)})`)
+  console.log(`   object  this project (orthoX - w/2, orthoY - h + 16), w=h=32 = (${String(projectObjectX)}, ${String(projectObjectY)})   delta (${signed(engineObjectAt.x - projectObjectX)}, ${signed(engineObjectAt.y - projectObjectY)})`)
+  const anchorVsObject = placements[0]
+  if (anchorVsObject !== undefined) {
+    console.log(`   object  resolveObjectArt anchor for the first placement (${anchorVsObject.row.token}): (${String(anchorVsObject.anchor.x)}, ${String(anchorVsObject.anchor.y)})`)
+  }
+
+  // The term that decides whether the project's floor and wall formulas agree
+  // with the engine: the DT1 block offset the decoder shifts by.
+  console.log('   DT1 minBlockY actually referenced by preset levels:')
+  const presetRows = levelTables.levels.rows.filter(row => cell(levelTables.levels, row, 'DrlgType') === DRLG_PRESET)
+  const floorHist = new Map<number, number>()
+  const wallHist = new Map<number, number>()
+  let floorTiles = 0
+  let wallTiles = 0
+  for (const levelRow of presetRows.slice(0, 8)) {
+    const levelId = Number(cell(levelTables.levels, levelRow, 'Id'))
+    let info
+    try {
+      info = resolveLevel(levelTables, levelId)
+    } catch {
+      continue
+    }
+    const libraries: Dt1[] = []
+    for (const dt1Name of info.dt1Names) libraries.push(decodeDt1(await archives.read(dt1Name)))
+    const tiles: Dt1Tile[] = libraries.flatMap(library => [...library.tiles])
+    for (const ds1Name of info.ds1Names) {
+      let ds1: Ds1
+      try {
+        ds1 = decodeDs1(await archives.read(ds1Name))
+      } catch {
+        continue
+      }
+      for (const row of ds1.cells) {
+        for (const cellRow of row) {
+          for (const floor of cellRow.floors) {
+            if (floor.hidden || floor.prop1 === 0) continue
+            const tile = tiles.find(candidate => candidate.style === floor.style && candidate.sequence === floor.sequence && candidate.direction === 0)
+            if (tile === undefined) continue
+            floorTiles += 1
+            floorHist.set(tile.minBlockY, (floorHist.get(tile.minBlockY) ?? 0) + 1)
+          }
+          for (const wall of cellRow.walls) {
+            if (wall.hidden || wall.prop1 === 0) continue
+            const tile = tiles.find(candidate => candidate.style === wall.style && candidate.sequence === wall.sequence && candidate.direction === wall.type)
+            if (tile === undefined) continue
+            wallTiles += 1
+            wallHist.set(tile.minBlockY, (wallHist.get(tile.minBlockY) ?? 0) + 1)
+          }
+        }
+      }
+      break
+    }
+  }
+  const show = (label: string, hist: Map<number, number>, total: number): void => {
+    const entries = [...hist].sort((a, b) => a[0] - b[0]).slice(0, 8)
+    console.log(`      ${label} tiles=${String(total)} ` + entries.map(([value, count]) => `minBlockY ${String(value)}:${String(count)}`).join('  '))
+  }
+  show('floor', floorHist, floorTiles)
+  show('wall ', wallHist, wallTiles)
+  console.log('      a floor tile in this project is drawn at (cx+cy)*40 + (blockY - minBlockY); the engine draws it at (cx+cy)*40 + 80 + blockY,')
+  console.log('      so the two agree only where minBlockY is -80. A wall in this project adds minBlockY back at draw time, which cancels the shift.')
+}
+
+/** Entry point. */
+async function main(): Promise<void> {
+  const archives = await mount()
+  const members = await memberSet(archives)
+  const tables = await loadObjectsTable(archives)
+  const levelTables = await loadActTables(archives)
+
+  console.log(`archives: ${archives.describe().join(', ')}`)
+  console.log(`Objects.txt rows: ${String(tables.rows.length)} (${String(new Set(tables.rows.map(row => row.token)).size)} distinct tokens)`)
+  console.log(`modes: ${OBJECT_MODE_TOKENS.join(' ')} (${String(OBJECT_MODE_COUNT)}); components: ${OBJECT_COMPONENTS.join(' ')}`)
+
+  await reportArchiveLayout(archives)
+  const template = await verifyCompositionTemplate(archives, members, tables)
+  const walk = await walkPresetObjects(archives, members, tables, levelTables)
+  const decoded = await decodeSample(archives, members, walk.placements)
+  const composited = await compositeSample(archives, members, walk.placements)
+  await reportAnchors(archives, levelTables, walk.placements)
+
+  console.log('== summary ==')
+  console.log(`   preset levels walked: ${String(walk.levels)}, DS1 members decoded: ${String(walk.ds1Count)}`)
+  console.log(`   object placements resolved: ${String(walk.placements.length)}`)
+  console.log(`   COF layer references rebuilt: ${String(template.layers)} (${String(template.dcc + template.dc6)} resolved, ${String(template.unresolved.length)} known duds)`)
+  console.log(`   members decoded: ${String(decoded.decoded)} (${String(decoded.frames)} frames, ${String(decoded.opaque)} opaque pixels)`)
+  console.log(`   object animations composited: ${String(composited)}`)
+  console.log('')
+  if (failures > 0) {
+    console.log(`FAIL: ${String(failures)}/${String(checks)} checks failed`)
+    for (const line of failureLog) console.log(`   - ${line}`)
+    if (failures > failureLog.length) console.log(`   ... ${String(failures - failureLog.length)} more`)
+    process.exitCode = 1
+    return
+  }
+  console.log(`PASS: ${String(checks)}/${String(checks)} checks passed`)
+}
+
+await main()
diff --git a/scripts/verify-packs.ts b/scripts/verify-packs.ts
new file mode 100644
index 0000000..9f1d799
--- /dev/null
+++ b/scripts/verify-packs.ts
@@ -0,0 +1,240 @@
+/**
+ * Prove a pack equals what the archives say.
+ *
+ * A prebaked pack is only trustworthy if it is indistinguishable from decoding
+ * the MPQs directly, so this script rebuilds every packed map through the live
+ * path — mount, tables, DS1, DT1, isometric scene — and compares it against the
+ * pack's JSON field by field:
+ *
+ *   1. map extent (cells, scene size, origin)
+ *   2. every floor and wall draw, in order, by frame rect and position
+ *   3. the collision grid, byte for byte
+ *   4. the spawn point
+ *   5. each frame's indexed pixels, by hash (the pack stores hashes, not pixels)
+ *   6. object placements (art is deliberately not baked yet)
+ *
+ * Anything that differs is a bug in the packer or in the shared code, and the
+ * script exits non-zero rather than letting a subtly wrong pack ship.
+ *
+ * Usage: node scripts/verify-packs.ts [archive-directory] [pack-directory]
+ */
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { fileSource } from '../src/mpq/file-source.ts'
+import { MountedArchives } from '../src/mpq/mount.ts'
+import { loadActTables, resolveLevel } from '../src/game/acts.ts'
+import { decodeDs1 } from '../src/formats/ds1.ts'
+import { decodeDt1 } from '../src/formats/dt1.ts'
+import { loadObjectsTable, resolveDs1Object } from '../src/game/objects.ts'
+import { levelSeed, buildIsoMapScene, findIsoSpawn } from '../src/game/d2map.ts'
+
+const [archiveDir = 'samples/d2', packDir = 'samples/d2-packs'] = process.argv.slice(2)
+
+/** Packed scene fields this script reads. */
+interface PackedScene {
+  readonly act: number
+  readonly levelId: number
+  readonly levelName: string
+  readonly ds1: string
+  readonly cellsX: number
+  readonly cellsY: number
+  readonly originX: number
+  readonly originY: number
+  readonly widthPx: number
+  readonly heightPx: number
+  readonly frames: readonly (readonly number[])[]
+  readonly frameHash: readonly string[]
+  readonly framePlacement: readonly (readonly number[])[]
+  readonly floors: readonly (readonly number[])[]
+  readonly walls: readonly (readonly number[])[]
+  /** Roof draws, painted last; absent in packs baked before roofs were split out. */
+  readonly roofs?: readonly (readonly number[])[]
+  readonly objects: readonly {
+    readonly id: number
+    readonly type: number
+    readonly name: string
+    /** Token the hardcoded object lookup table resolves this DS1 id to. */
+    readonly token: string
+    /** Animation mode token the engine places the object in. */
+    readonly mode: string
+    /** `Objects.txt` row the table points at, or -1 when it points at none. */
+    readonly objectsTxtId: number
+  }[]
+  readonly collision: { readonly width: number; readonly height: number; readonly runs: readonly (readonly number[])[] }
+  readonly spawn: readonly number[] | null
+}
+
+/**
+ * FNV-1a over a frame's indexed pixels — the same function the packer used.
+ *
+ * @param indices - palette indices.
+ * @returns an 8-character hex digest.
+ */
+function frameHash(indices: Uint8Array): string {
+  let hash = 0x811c9dc5
+  for (const byte of indices) {
+    hash ^= byte
+    hash = Math.imul(hash, 0x01000193) >>> 0
+  }
+  return hash.toString(16).padStart(8, '0')
+}
+
+const archives = new MountedArchives()
+for (const name of ['d2char.mpq', 'd2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq']) {
+  archives.add(name, await MpqArchive.open(await fileSource(join(archiveDir, name))))
+}
+const tables = await loadActTables(archives)
+const index = JSON.parse(await readFile(join(packDir, 'index.json'), 'utf8')) as {
+  levels: readonly { act: number; levelId: number; path: string; ds1: string; label: string }[]
+}
+
+let checks = 0
+let failures = 0
+let comparedPixels = 0
+
+/**
+ * Assert one expectation.
+ *
+ * @param ok - whether it held.
+ * @param message - what was checked.
+ */
+function check(ok: boolean, message: string): void {
+  checks += 1
+  if (!ok) { failures += 1; console.log(`   FAIL ${message}`) }
+}
+
+/** DS1 object ids the community lookup table does not cover, summed over every map. */
+let unknownObjectIds = 0
+
+/** The hardcoded object lookup needs `Objects.txt` for metadata; load it once. */
+const objectsTable = await loadObjectsTable(archives)
+
+for (const entry of index.levels) {
+  const packed = JSON.parse(await readFile(join(packDir, entry.path, 'scene.json'), 'utf8')) as PackedScene
+  const info = resolveLevel(tables, packed.levelId, packed.act)
+  const libraries = []
+  for (const name of info.dt1Names) libraries.push(decodeDt1(await archives.read(name)))
+  const level = decodeDs1(await archives.read(packed.ds1))
+  const live = buildIsoMapScene(level, libraries, levelSeed(packed.ds1))
+
+  check(packed.levelName === info.levelName, `${entry.path}: level name`)
+  check(packed.cellsX === live.cellsX && packed.cellsY === live.cellsY, `${entry.path}: cell extent`)
+  check(packed.originX === live.originX && packed.originY === live.originY, `${entry.path}: scene origin`)
+  check(packed.widthPx === live.widthPx && packed.heightPx === live.heightPx, `${entry.path}: scene size`)
+
+  // Draws: same count, same order, same frame rect and position.
+  check(packed.floors.length === live.floors.length, `${entry.path}: floor count ${String(packed.floors.length)} vs ${String(live.floors.length)}`)
+  check(packed.walls.length === live.walls.length, `${entry.path}: wall count ${String(packed.walls.length)} vs ${String(live.walls.length)}`)
+  const rectOf = (frameIndex: number): string => (packed.framePlacement[frameIndex] ?? []).slice(1).join(',')
+  let floorMismatch = 0
+  for (let at = 0; at < Math.min(packed.floors.length, live.floors.length); at += 1) {
+    const packedRow = packed.floors[at]!
+    const liveDraw = live.floors[at]!
+    if (packedRow[1] !== liveDraw.x || packedRow[2] !== liveDraw.y || packedRow[3] !== liveDraw.cellX || packedRow[4] !== liveDraw.cellY) floorMismatch += 1
+  }
+  check(floorMismatch === 0, `${entry.path}: floor draw geometry (${String(floorMismatch)} mismatches)`)
+  let wallMismatch = 0
+  for (let at = 0; at < Math.min(packed.walls.length, live.walls.length); at += 1) {
+    const packedRow = packed.walls[at]!
+    const liveDraw = live.walls[at]!
+    if (packedRow[1] !== liveDraw.x || packedRow[2] !== liveDraw.y) wallMismatch += 1
+  }
+  check(wallMismatch === 0, `${entry.path}: wall draw geometry and order (${String(wallMismatch)} mismatches)`)
+
+  // Roofs are a separate pass in the engine, so they are compared as their own
+  // list: same count, same order, same geometry.
+  const packedRoofs = packed.roofs ?? []
+  check(packedRoofs.length === live.roofs.length,
+    `${entry.path}: roof count ${String(packedRoofs.length)} vs ${String(live.roofs.length)}`)
+  let roofMismatch = 0
+  for (let at = 0; at < Math.min(packedRoofs.length, live.roofs.length); at += 1) {
+    const packedRow = packedRoofs[at]!
+    const liveDraw = live.roofs[at]!
+    if (packedRow[1] !== liveDraw.x || packedRow[2] !== liveDraw.y) roofMismatch += 1
+  }
+  check(roofMismatch === 0, `${entry.path}: roof draw geometry and order (${String(roofMismatch)} mismatches)`)
+
+  // Collision grid: expand the runs and compare bytes.
+  const expanded = new Uint8Array(packed.collision.width * packed.collision.height)
+  let cursor = 0
+  for (const run of packed.collision.runs) {
+    const value = run[0] ?? 0
+    const length = run[1] ?? 0
+    if (value !== 0) expanded.fill(value, cursor, Math.min(cursor + length, expanded.length))
+    cursor += length
+  }
+  check(packed.collision.width === live.gridWidth, `${entry.path}: collision width`)
+  check(packed.collision.height === live.gridHeight, `${entry.path}: collision height`)
+  let collisionDiff = 0
+  for (let at = 0; at < Math.min(expanded.length, live.blocked.length); at += 1) {
+    if (expanded[at] !== live.blocked[at]) collisionDiff += 1
+  }
+  check(collisionDiff === 0, `${entry.path}: collision grid (${String(collisionDiff)} differing sub-tiles)`)
+
+  // Spawn.
+  const liveSpawn = findIsoSpawn(live)
+  const packedSpawn = packed.spawn
+  check(
+    (packedSpawn === null && liveSpawn === null)
+    || (packedSpawn !== null && liveSpawn !== null && packedSpawn[0] === Math.round(liveSpawn.x) && packedSpawn[1] === Math.round(liveSpawn.y)),
+    `${entry.path}: spawn point`,
+  )
+
+  // Frames: same tiles, same pixels (by hash), and every frame reachable on a page.
+  check(packed.frames.length === live.frames.length, `${entry.path}: frame count`)
+  let hashMismatch = 0
+  let offPage = 0
+  for (let at = 0; at < Math.min(packed.frames.length, live.frames.length); at += 1) {
+    const liveFrame = live.frames[at]!
+    if (frameHash(liveFrame.indices) !== packed.frameHash[at]) hashMismatch += 1
+    const place = packed.framePlacement[at]
+    if (place === undefined || (place[3] ?? 0) !== liveFrame.width || (place[4] ?? 0) !== liveFrame.height) offPage += 1
+    comparedPixels += liveFrame.indices.byteLength
+  }
+  check(hashMismatch === 0, `${entry.path}: frame pixel hashes (${String(hashMismatch)} differ)`)
+  check(offPage === 0, `${entry.path}: frame sizes match their page placement (${String(offPage)} differ)`)
+  void rectOf
+
+  // Objects: same placements, same count (art is not baked yet, by design).
+  // The packer skips DS1 monster spawn points (`type` 1) and any id the hardcoded
+  // object table does not know, so the expected count is "entries that resolve to a
+  // real object", not the raw DS1 count. Token/mode are compared too: they come from
+  // the lookup table, which is the part a wrong mapping would silently corrupt.
+  // A few DS1 ids are simply absent from the community table; the packer records
+  // them as unresolved instead of guessing, so they are excluded here the same way.
+  let unknownIds = 0
+  const expected: { object: (typeof level.objects)[number]; token: string; mode: string }[] = []
+  for (const object of level.objects) {
+    try {
+      const resolved = resolveDs1Object(objectsTable, packed.act, object.type, object.id)
+      if (resolved.kind === 'object') expected.push({ object, token: resolved.token, mode: resolved.mode })
+    } catch {
+      unknownIds += 1
+    }
+  }
+  check(packed.objects.length === expected.length,
+    `${entry.path}: object count ${String(packed.objects.length)} vs ${String(expected.length)}`)
+  let tokenMismatch = 0
+  for (let index = 0; index < Math.min(packed.objects.length, expected.length); index += 1) {
+    const baked = packed.objects[index]!
+    const want = expected[index]!
+    if (baked.token !== want.token || baked.mode !== (want.mode === '' ? 'NU' : want.mode)) {
+      tokenMismatch += 1
+      if (tokenMismatch <= 3) {
+        console.log(`   FAIL ${entry.path}: object ${String(index)} ${baked.token}/${baked.mode} != ${want.token}/${want.mode}`)
+      }
+    }
+  }
+  check(tokenMismatch === 0, `${entry.path}: object tokens/modes match the lookup (${String(tokenMismatch)} mismatches)`)
+  unknownObjectIds += unknownIds
+
+  console.log(
+    `${entry.path.padEnd(26)} ${String(live.floors.length).padStart(5)} 地面 ${String(live.walls.length).padStart(4)} 墙 ${String(live.roofs.length).padStart(4)} 顶 `
+    + `${String(live.frames.length).padStart(3)} 帧 ${String(packed.collision.width)}x${String(packed.collision.height)} 碰撞 `
+    + `${String(expected.length).padStart(4)} 对象  ${collisionDiff === 0 && hashMismatch === 0 ? '一致' : '不一致'}`,
+  )
+}
+
+console.log(`\n${String(checks - failures)}/${String(checks)} 项断言通过（逐像素比对了 ${(comparedPixels / 1048576).toFixed(1)} MB 的索引数据）`)
+if (failures > 0) process.exit(1)
diff --git a/scripts/verify-sprites.ts b/scripts/verify-sprites.ts
new file mode 100644
index 0000000..55ebcae
--- /dev/null
+++ b/scripts/verify-sprites.ts
@@ -0,0 +1,144 @@
+/**
+ * Decode every Diablo I sprite member in an archive and report what the
+ * decoders had to infer.
+ *
+ * The width story is the interesting part and differs per format:
+ *
+ * - `.cel` runs are row-bounded, so a wrong width makes runs overrun a row and
+ *   the file is rejected. Auto-detection is therefore a real check, and a
+ *   decoded file is strong evidence the decoder matches the shipped data.
+ * - `.cl2` runs may cross rows, so *any* width consumes the stream. There the
+ *   width must come from the game's tables — `SetPlrAnims` for players,
+ *   `monsterdata[].width` for monsters — and success means the decoder agrees
+ *   with those parameters. `cl2WidthCandidates` additionally reports widths
+ *   that leave the stream row-aligned, which is a necessary (not sufficient)
+ *   property of the true width.
+ *
+ * Usage: node scripts/verify-sprites.ts <archive> [--player] [--samples]
+ */
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { fileSource } from '../src/mpq/file-source.ts'
+import { cl2WidthCandidates, decodeSpriteFile, detectSpriteWidth } from '../src/formats/cel.ts'
+import { PLAYER_SPRITE_WIDTH } from '../src/formats/sprite.ts'
+
+const [path, ...flags] = process.argv.slice(2)
+if (path === undefined) {
+  console.error('usage: node scripts/verify-sprites.ts <archive> [--player] [--samples]')
+  process.exit(2)
+}
+const showPlayer = flags.includes('--player')
+const showSamples = flags.includes('--samples')
+
+/** Widths the game's own tables give for player graphics (`SetPlrAnims`). */
+const PLAYER_WIDTHS = [
+  PLAYER_SPRITE_WIDTH.stand, PLAYER_SPRITE_WIDTH.walk,
+  PLAYER_SPRITE_WIDTH.attack, PLAYER_SPRITE_WIDTH.attackNarrow,
+  PLAYER_SPRITE_WIDTH.monk, PLAYER_SPRITE_WIDTH.monkAttack,
+]
+/** Most monospecies monster art is 128 wide (`monsterdata[].width`). */
+const MONSTER_WIDTHS = [128, 160, 96, 64]
+
+const archive = await MpqArchive.open(await fileSource(path))
+const names = await archive.listFiles()
+
+const celWidths = new Map<number, number>()
+const cl2Widths = new Map<number, number>()
+const failures: string[] = []
+const ambiguous: string[] = []
+const playerRows: string[] = []
+let celTotal = 0
+let celOk = 0
+let cl2Total = 0
+let cl2Ok = 0
+const started = Date.now()
+
+/** The directory that owns an archive name (`monsters`, `plrgfx`, ...). */
+function topDir(name: string): string {
+  const cut = name.indexOf('\\')
+  return cut === -1 ? '(root)' : name.slice(0, cut)
+}
+
+for (const name of names) {
+  const lower = name.toLowerCase()
+  const mode = lower.endsWith('.cl2') ? 'cl2' : lower.endsWith('.cel') ? 'cel' : null
+  if (mode === null) continue
+  const file = archive.find(name)
+  if (file === undefined) {
+    failures.push(`${name}: hash lookup failed`)
+    continue
+  }
+  const data = await archive.read(file)
+
+  if (mode === 'cel') {
+    celTotal += 1
+    const width = detectSpriteWidth(data)
+    if (width === null) {
+      failures.push(`${name}: no width consumes the file exactly`)
+      continue
+    }
+    try {
+      const sheet = decodeSpriteFile(data, 'cel', { width })
+      const frames = sheet.groups.reduce((total, group) => total + group.frames.length, 0)
+      if (frames === 0) throw new Error('decoded zero frames')
+      celOk += 1
+      celWidths.set(width, (celWidths.get(width) ?? 0) + 1)
+    } catch (error) {
+      failures.push(`${name} (width ${String(width)}): ${(error as Error).message}`)
+    }
+    continue
+  }
+
+  cl2Total += 1
+  const dir = topDir(name)
+  const candidates = dir === 'plrgfx' ? PLAYER_WIDTHS : dir === 'monsters' ? MONSTER_WIDTHS : PLAYER_WIDTHS
+  // The game's tables for this kind of art, tried in order.
+  let matched: number | null = null
+  for (const width of candidates) {
+    try {
+      const sheet = decodeSpriteFile(data, 'cl2', { width })
+      const frames = sheet.groups.reduce((total, group) => total + group.frames.length, 0)
+      if (frames > 0) { matched = width; break }
+    } catch {
+      // try the next width
+    }
+  }
+  if (matched !== null) {
+    cl2Ok += 1
+    cl2Widths.set(matched, (cl2Widths.get(matched) ?? 0) + 1)
+    const aligned = cl2WidthCandidates(data, candidates)
+    if (!aligned.includes(matched)) {
+      ambiguous.push(`${name}: decodes at ${String(matched)} but the stream is not row-aligned there`)
+    }
+    if (showPlayer && dir === 'plrgfx') {
+      const sheet = decodeSpriteFile(data, 'cl2', { width: matched })
+      const frames = sheet.groups.reduce((total, group) => total + group.frames.length, 0)
+      const tallest = Math.max(...sheet.groups.flatMap(group => group.frames.map(frame => frame.height)))
+      playerRows.push(
+        `${name.padEnd(34)} groups=${String(sheet.groups.length)} frames=${String(frames)}`
+        + ` width=${String(matched)} tallest=${String(tallest)} aligned=[${aligned.join(',')}]`,
+      )
+    }
+  } else {
+    const aligned = cl2WidthCandidates(data, [...PLAYER_WIDTHS, ...MONSTER_WIDTHS, 32, 48, 64, 80, 160, 192, 256])
+    ambiguous.push(`${name} (${dir}): no table width decoded it; row-aligned candidates: ${aligned.length === 0 ? 'none' : aligned.join(',')}`)
+  }
+}
+
+const seconds = ((Date.now() - started) / 1000).toFixed(1)
+const formatHistogram = (histogram: Map<number, number>): string =>
+  [...histogram].sort((a, b) => b[1] - a[1]).slice(0, 10).map(([w, n]) => `${String(w)}px:${String(n)}`).join('  ')
+
+console.log(`archive   ${path}`)
+console.log(`cel       ${String(celOk)}/${String(celTotal)} decoded   widths ${formatHistogram(celWidths)}`)
+console.log(`cl2       ${String(cl2Ok)}/${String(cl2Total)} decoded   widths ${formatHistogram(cl2Widths)}`)
+console.log(`failures  ${String(failures.length)}`)
+for (const line of failures.slice(0, 10)) console.log(`  - ${line}`)
+console.log(`notes     ${String(ambiguous.length)}`)
+const noteLimit = showSamples ? 12 : 4
+for (const line of ambiguous.slice(0, noteLimit)) console.log(`  · ${line}`)
+if (showSamples && ambiguous.length > noteLimit) console.log(`  · … ${String(ambiguous.length - noteLimit)} more`)
+console.log(`elapsed   ${seconds}s`)
+if (showPlayer) {
+  console.log('--- player graphics ---')
+  for (const row of playerRows.slice(0, 30)) console.log(`  ${row}`)
+}
diff --git a/scripts/verify-tbl.ts b/scripts/verify-tbl.ts
new file mode 100644
index 0000000..ca43d63
--- /dev/null
+++ b/scripts/verify-tbl.ts
@@ -0,0 +1,59 @@
+/**
+ * Construction check for the TBL decoder.
+ *
+ * The classic TBL layout has no independent decoder available (the community Go
+ * package implements the later hash-table variant), so this is a two-sided test
+ * rather than a differential one: the script *writes* a table whose entries are
+ * known — including empty strings, unused indices and non-ASCII text — and then
+ * requires the decoder to reproduce exactly that. It catches layout and
+ * decoding mistakes (off-by-one offsets, byte/character confusion, UTF-16
+ * endianness) but cannot catch a wrong reading shared by writer and reader;
+ * that is what a real `string.tbl` is for.
+ *
+ * Usage: node scripts/verify-tbl.ts
+ */
+import { decodeTbl, tblLookup } from '../src/formats/tbl.ts'
+import { encodeTbl } from './lib/tbl-writer.ts'
+import type { TblEntry } from './lib/tbl-writer.ts'
+
+/** Entries the decoder must reproduce, in order. */
+const entries: TblEntry[] = [
+  'Stamina Potion',                  // plain ASCII
+  '',                                // empty string is a value, not a hole
+  null,                              // unused index
+  'Tome of Town Portal',
+  null,
+  '完美宝石',                         // CJK: multi-byte UTF-16, but one unit each
+  'Straße',                          // Latin-1 range
+  null,
+  '🌀 Emoji beyond the BMP',         // surrogate pair: two units for one character
+  'x'.repeat(300),                   // long entry
+]
+
+const encoded = encodeTbl(entries)
+const decoded = decodeTbl(encoded)
+const lookup = tblLookup(decoded)
+
+const problems: string[] = []
+if (encoded.byteLength !== decoded.length * 0 + encoded.byteLength) {
+  /* v8 ignore next -- placeholder to keep the shape obvious. */
+  problems.push('unreachable')
+}
+if (decoded.length !== entries.length) problems.push(`entry count ${String(decoded.length)} != ${String(entries.length)}`)
+entries.forEach((want, index) => {
+  const got = decoded[index]
+  if (want === null) {
+    if (got !== undefined) problems.push(`index ${String(index)}: expected an unused index, got ${JSON.stringify(got)}`)
+    return
+  }
+  if (got !== want) problems.push(`index ${String(index)}: ${JSON.stringify(got)} != ${JSON.stringify(want)}`)
+})
+
+console.log(`table      ${String(entries.length)} indices (${String(lookup.size)} used)`)
+console.log(`encoded    ${String(encoded.byteLength)} bytes`)
+console.log(`unicode    CJK=${JSON.stringify(lookup.get(5))} latin1=${JSON.stringify(lookup.get(6))} astral=${JSON.stringify(lookup.get(8))}`)
+console.log(`long       ${String(lookup.get(9)?.length ?? 0)} characters round-tripped`)
+console.log(`problems   ${String(problems.length)}`)
+for (const problem of problems.slice(0, 8)) console.log(`  - ${problem}`)
+console.log(problems.length === 0 ? 'RESULT     every index round-trips exactly' : 'RESULT     FAILED')
+process.exit(problems.length === 0 ? 0 : 1)
diff --git a/scripts/verify-tile-alignment.ts b/scripts/verify-tile-alignment.ts
new file mode 100644
index 0000000..095060f
--- /dev/null
+++ b/scripts/verify-tile-alignment.ts
@@ -0,0 +1,296 @@
+// verify-tile-alignment.ts — 用实测把"地面比引擎低/高 80 px"这个疑点结掉
+//
+// 背景：上一轮的 `verify-objects` 打印过一张对照表，说引擎的
+// `DUNGEON_GameToClientTileDrawPositionCoords`（D2MOO 移植过来的真引擎函数）算出 cell(12,7) 的地面
+// 在 (320, 840)，而本项目画在 (320, 760)，差 (+0, +80)，看起来像"地面整体偏了 80 px"。
+//
+// 这份脚本证明那**不是错位**，而是两个坐标系之间的**常量平移**，并且用像素实测证明同一格里
+// 地面的下沿与墙脚是对齐的：
+//
+// 1. 常量性：D2MOO 的 tile 位置与本项目的地面绘制位置的差在所有格子上都是 (+80, +80)，
+//    与 (x,y) 无关 → 整张图一起平移，相机又跟着角色走，所以对相对关系没有任何影响。
+// 2. 公式一致性：我们画墙用的 `minBlockY + 80` 与解析出来的 `bitmapHeight`，必须等于引擎从原始
+//    block 字节独立推出的 `tileMinY + 80` 与 `realHeight = max(|Height|, maxY - minY)`。
+// 3. 接缝实测：同一格里取墙位图与地面位图**真正的不透明像素**，比较墙脚（墙最下面一行不透明像素）
+//    与地面下沿。差值应当是 0。
+//
+//   node scripts/verify-tile-alignment.ts [--dir=samples/d2] [--limit=35]
+//
+// 退出码非 0 表示有断言没过。
+
+export {}
+
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { fileSource } from '../src/mpq/file-source.ts'
+import { MountedArchives } from '../src/mpq/mount.ts'
+import { cell, loadActTables, resolveLevel, resolveLevelLibraries } from '../src/game/acts.ts'
+import { decodeDs1 } from '../src/formats/ds1.ts'
+import { decodeDt1 } from '../src/formats/dt1.ts'
+import type { Dt1, Dt1Tile } from '../src/formats/dt1.ts'
+import { levelSeed, buildIsoMapScene, ORTHO_CELL_HEIGHT, ORTHO_CELL_WIDTH } from '../src/game/d2map.ts'
+
+/** 归档目录。 */
+const DIR = process.argv.find(argument => argument.startsWith('--dir='))?.slice('--dir='.length) ?? 'samples/d2'
+/** 最多走多少个预置关卡。 */
+const LIMIT = Number(process.argv.find(argument => argument.startsWith('--limit='))?.slice('--limit='.length) ?? '35')
+
+/** 断言结果。 */
+const checks: { name: string; ok: boolean; detail: string }[] = []
+
+/**
+ * 记录一条断言。
+ *
+ * @param name - what was checked.
+ * @param ok - whether it held.
+ * @param detail - evidence.
+ */
+function check(name: string, ok: boolean, detail: string): void {
+  checks.push({ name, ok, detail })
+  console.log(`${ok ? 'ok  ' : 'FAIL'} ${name} — ${detail}`)
+}
+
+/**
+ * 位图里最后一行不透明像素的行号（没有不透明像素时返回 -1）。
+ *
+ * @param tile - the decoded DT1 tile.
+ * @returns the row index, or -1.
+ */
+function lastOpaqueRow(tile: Dt1Tile): number {
+  // 每个 block 的像素缓冲已经是"整块位图尺寸"的画布，解码时按 `-minBlockY` 平移过，
+  // 所以缓冲里的行号就是位图内的行号，不需要再加 block.y（block.y 保留的是原始值）。
+  const stride = tile.width
+  let last = -1
+  for (const block of tile.blocks) {
+    if (stride <= 0) break
+    const rows = Math.floor(block.pixels.length / stride)
+    for (let row = rows - 1; row >= 0; row -= 1) {
+      const start = row * stride
+      let opaque = false
+      for (let column = 0; column < stride; column += 1) {
+        if ((block.pixels[start + column] ?? 0) !== 0) { opaque = true; break }
+      }
+      if (opaque) { last = Math.max(last, row); break }
+    }
+  }
+  return last
+}
+
+/**
+ * 从原始字节独立算出引擎的 `tileMinY` / `realHeight`（OpenDiablo2 `generateWallCache` 的公式）。
+ *
+ * @param tile - the decoded DT1 tile; `block.y` is already shifted by `minBlockY`.
+ * @returns the engine's numbers.
+ */
+function engineMetrics(tile: Dt1Tile): { tileMinY: number; tileMaxY: number; realHeight: number } {
+  // `block.y` 是原始值（解码时像素另有平移），所以这里直接用，不要再叠加 minBlockY。
+  let tileMinY = 0
+  let tileMaxY = 0
+  for (const block of tile.blocks) {
+    tileMinY = Math.min(tileMinY, block.y)
+    tileMaxY = Math.max(tileMaxY, block.y + 32)
+  }
+  return { tileMinY, tileMaxY, realHeight: Math.max(Math.abs(tile.height), tileMaxY - tileMinY) }
+}
+
+/**
+ * 主流程。
+ */
+async function main(): Promise<void> {
+  const archives = new MountedArchives()
+  for (const name of ['d2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq']) {
+    archives.add(name, await MpqArchive.open(await fileSource(`${DIR}/${name}`)))
+  }
+  const tables = await loadActTables(archives)
+
+  const presetRows = tables.levels.rows.filter(row => cell(tables.levels, row, 'DrlgType') === '2')
+  const libraries = new Map<string, Dt1>()
+  let cells = 0
+  let pairs = 0
+  const deltaHistogram = new Map<number, number>()
+  const samples: string[] = []
+  const seenDeltas = new Set<number>()
+  const baseDeltas = new Map<number, number>()
+  const offsetsD2moo = new Set<string>()
+  const formulaMismatches: string[] = []
+  let floorMinYNonZero = 0
+  let roofDraws = 0
+  let roofMatches = 0
+  const wallTypes = new Map<number, number>()
+  let wallTiles = 0
+  let levelsWalked = 0
+  // 键的正确性回归：DS1 wall type 必须与 DT1 头 +20 的 `Type` 对齐，而不是 +0 的 `Direction`。
+  // 键错时树(14)/屋顶(15)/影子(13)全落 loose、画成地面。这里按 type 键全量复核，loose/missing 应为 0。
+  let refsTotal = 0
+  let refsExact = 0
+  let refsLoose = 0
+  let refsMissing = 0
+  const looseRefs = new Set<string>()
+
+  for (const row of presetRows.slice(0, LIMIT)) {
+    const levelId = Number(cell(tables.levels, row, 'Id'))
+    let info
+    try {
+      info = resolveLevel(tables, levelId)
+    } catch { continue }
+    const { dt1Names } = resolveLevelLibraries(tables, levelId)
+    const libs: Dt1[] = []
+    for (const name of dt1Names) {
+      const cached = libraries.get(name)
+      if (cached !== undefined) { libs.push(cached); continue }
+      try {
+        const decoded = decodeDt1(await archives.read(name))
+        libraries.set(name, decoded)
+        libs.push(decoded)
+      } catch { /* 库缺失时后面的 resolveLevelLibraries 已经报过 */ }
+    }
+    if (libs.length === 0) continue
+
+    let ds1
+    try {
+      ds1 = decodeDs1(await archives.read(info.ds1Names[0]!))
+    } catch { continue }
+    levelsWalked += 1
+    const scene = buildIsoMapScene(ds1, libs, levelSeed(info.ds1Names[0] ?? String(levelId)))
+
+    // 键正确性复核（独立于 buildIsoMapScene，用原始 DS1 + 库重算一遍）。
+    const exactKeys = new Set<string>()
+    const looseKeys = new Set<string>()
+    for (const lib of libs) for (const tile of lib.tiles) {
+      exactKeys.add(`${String(tile.style)}:${String(tile.sequence)}:${String(tile.type)}`)
+      looseKeys.add(`${String(tile.style)}:${String(tile.sequence)}`)
+    }
+    for (const cellRef of ds1.cells.flat()) for (const wall of cellRef.walls) {
+      if (wall.hidden || wall.prop1 === 0) continue
+      refsTotal += 1
+      if (exactKeys.has(`${String(wall.style)}:${String(wall.sequence)}:${String(wall.type)}`)) { refsExact += 1; continue }
+      if (looseKeys.has(`${String(wall.style)}:${String(wall.sequence)}`)) { refsLoose += 1; looseRefs.add(`${String(wall.style)}/${String(wall.sequence)}/${String(wall.type)}`); continue }
+      refsMissing += 1
+    }
+
+    // Roofs: the engine offsets them by `-roofHeight` instead of `minBlockY + 80`.
+    for (const roof of scene.roofs) {
+      const tile = libs[roof.library]?.tiles[roof.tile]
+      if (tile === undefined) continue
+      roofDraws += 1
+      // The scene shifts every draw to keep coordinates positive, so the formula is
+      // checked against the *unshifted* placement (scene.originY is that shift).
+      if (roof.y - scene.originY === (roof.cellX + roof.cellY) * ORTHO_CELL_HEIGHT - tile.roofHeight) roofMatches += 1
+    }
+
+    // 按格子收集地面与墙
+    type Draw = (typeof scene.floors)[number]
+    const byCell = new Map<string, { floors: Draw[]; walls: Draw[] }>()
+    for (const cell of ds1.cells.flat()) {
+      for (const wall of cell.walls) {
+        if (wall.prop1 === 0 || wall.hidden) continue
+        wallTypes.set(wall.type, (wallTypes.get(wall.type) ?? 0) + 1)
+      }
+    }
+    for (const draw of scene.floors) {
+      const key = `${String(draw.cellX)},${String(draw.cellY)}`
+      const entry = byCell.get(key) ?? { floors: [], walls: [] }
+      entry.floors.push(draw)
+      byCell.set(key, entry)
+    }
+    for (const draw of scene.walls) {
+      const key = `${String(draw.cellX)},${String(draw.cellY)}`
+      const entry = byCell.get(key) ?? { floors: [], walls: [] }
+      entry.walls.push(draw)
+      byCell.set(key, entry)
+    }
+
+    for (const [key, entry] of byCell) {
+      if (entry.floors.length === 0 || entry.walls.length === 0) continue
+      cells += 1
+      const [cxText, cyText] = key.split(',')
+      const cx = Number(cxText)
+      const cy = Number(cyText)
+
+      // (1) 常量性：D2MOO 的 tile 位置 vs 本项目的地面位置
+      const oursX = (cx - cy) * ORTHO_CELL_WIDTH - 80
+      const oursY = (cx + cy) * ORTHO_CELL_HEIGHT
+      const d2mooX = (cx - cy) * ORTHO_CELL_WIDTH
+      const d2mooY = (cx + cy) * ORTHO_CELL_HEIGHT + 80
+      offsetsD2moo.add(`${String(d2mooX - oursX)},${String(d2mooY - oursY)}`)
+
+      const floor = entry.floors[0]!
+      const wall = entry.walls[0]!
+      const floorTile = libs[floor.library]?.tiles[floor.tile]
+      const wallTile = libs[wall.library]?.tiles[wall.tile]
+      if (floorTile === undefined || wallTile === undefined) continue
+      if (floorTile.minBlockY !== 0) floorMinYNonZero += 1
+      wallTiles += 1
+
+      // (2) 公式一致性：我们的 minBlockY / bitmapHeight 必须等于引擎独立算出的值
+      const metrics = engineMetrics(wallTile)
+      if (wallTile.minBlockY !== metrics.tileMinY) {
+        if (formulaMismatches.length < 6) {
+          formulaMismatches.push(`${String(levelId)} wall style ${String(wallTile.style)}: minBlockY ${String(wallTile.minBlockY)} != engine ${String(metrics.tileMinY)}`)
+        }
+      } else if (wallTile.bitmapHeight !== metrics.realHeight) {
+        if (formulaMismatches.length < 6) {
+          formulaMismatches.push(`${String(levelId)} wall style ${String(wallTile.style)}: bitmapHeight ${String(wallTile.bitmapHeight)} != engine realHeight ${String(metrics.realHeight)}`)
+        }
+      }
+
+      // (3) 接缝实测：墙脚（最下面一行不透明像素）与地面下沿之差
+      const floorBottom = floor.y + lastOpaqueRow(floorTile)
+      const wallBottom = wall.y + lastOpaqueRow(wallTile)
+      // 真正的"接缝"判据是**基线**而不是"最下面一行不透明像素"：引擎给墙加的
+      // `YAdjust = minBlockY + 80` 正好抵消解码时按 `-minBlockY` 做的平移，使墙的原始 y=0
+      // 落在格子基线（地面位图下沿所在的 80 px 处）；不同 tile 类型的美术在基线上下伸出的
+      // 多少各不相同，所以像素行差只能当参考，不能当判据。
+      const wallBase = wall.y - wallTile.minBlockY
+      const floorBase = floor.y + 80
+      baseDeltas.set(wallBase - floorBase, (baseDeltas.get(wallBase - floorBase) ?? 0) + 1)
+
+      const delta = wallBottom - floorBottom
+      deltaHistogram.set(delta, (deltaHistogram.get(delta) ?? 0) + 1)
+      if (samples.length < 8 && !seenDeltas.has(delta)) {
+        seenDeltas.add(delta)
+        samples.push(`Δ${String(delta)} cell(${String(cx)},${String(cy)}) `
+          + `floor[y=${String(floor.y)} last=${String(floorBottom - floor.y)} bh=${String(floorTile.bitmapHeight)} minY=${String(floorTile.minBlockY)}] `
+          + `wall[y=${String(wall.y)} last=${String(wallBottom - wall.y)} bh=${String(wallTile.bitmapHeight)} minY=${String(wallTile.minBlockY)} h=${String(wallTile.height)} style=${String(wallTile.style)}/${String(wallTile.sequence)}/${String(wallTile.type)}]`)
+      }
+      pairs += 1
+    }
+  }
+
+  console.log(`\n走了 ${String(levelsWalked)} 个预置关卡：含"地面+墙"的格子 ${String(cells)}，参与接缝实测的配对 ${String(pairs)}`)
+  console.log(`   屋顶层（DS1 wall type 15）：${String(roofDraws)} 个，其中偏移与引擎公式 -roofHeight 相符的 ${String(roofMatches)} 个`)
+  console.log(`   DS1 墙 type 分布：${[...wallTypes].sort((left, right) => left[0] - right[0]).map(([type, count]) => `${String(type)}×${String(count)}`).join(' ')}`)
+  console.log(`   D2MOO 位置 - 本项目地面位置 的不同取值：${[...offsetsD2moo].join(' | ')}`)
+  const deltas = [...deltaHistogram].sort((left, right) => right[1] - left[1])
+  console.log(`   接缝差（墙脚 - 地面下沿）分布：${deltas.slice(0, 8).map(([value, count]) => `${String(value)}px ×${String(count)}`).join('  ')}`)
+  console.log(`   地面瓦片里 minBlockY != 0 的：${String(floorMinYNonZero)} / ${String(cells)}`)
+
+  for (const sample of samples) console.log(`   ${sample}`)
+
+  console.log(`\n   墙引用键复核：${String(refsExact)}/${String(refsTotal)} 精确命中，loose ${String(refsLoose)}，缺失 ${String(refsMissing)}`)
+  if (refsLoose > 0) console.log(`   loose 引用：${[...looseRefs].slice(0, 8).join(' | ')}`)
+  check('DS1 wall type 与 DT1 `Type`(+20) 精确对齐（无 loose/缺失）', refsTotal > 0 && refsExact === refsTotal,
+    `${String(refsExact)}/${String(refsTotal)} 精确命中`)
+
+  check('D2MOO 与本项目的差在所有格子上是同一个常量', offsetsD2moo.size === 1,
+    [...offsetsD2moo].join(' | '))
+  check('该常量与"整张图平移"一致（解释 80 px 疑点）', [...offsetsD2moo][0] === '80,80',
+    `偏移 ${[...offsetsD2moo][0] ?? '?'}：X 差一格半宽（位图锚点），Y 差一个 tile 高（D2MOO 的口径）`)
+  check('屋顶偏移等于引擎的 -roofHeight（没有屋顶层的关卡按通过算）', roofDraws === 0 || roofMatches === roofDraws,
+    `${String(roofMatches)}/${String(roofDraws)} 个屋顶`)
+
+  check('墙的 minBlockY / bitmapHeight 等于引擎从原始字节算出的值', formulaMismatches.length === 0,
+    formulaMismatches.length === 0 ? `${String(wallTiles)} 面墙全部一致` : formulaMismatches.join(' | '))
+  // 墙脚与地面下沿：多数应当正好重合；差值不为 0 的那些是"美术本身伸到格子下沿之外"的墙
+  // （栅栏、树、台阶等），它们的脚本来就在格子外，属于正常。
+  const baseExact = baseDeltas.get(0) ?? 0
+  check('接缝判据：墙的基线与地面基线完全重合', pairs > 0 && baseExact === pairs,
+    `${String(baseExact)}/${String(pairs)} 对基线差为 0`)
+  console.log(`   （参考值，不作为判据）最下面一行不透明像素之差最常见 ${String(deltas[0]?.[0] ?? 0)}px：`
+    + '不同 tile 类型的美术在基线上下伸出的量不同，栅栏/树/台阶本来就越过格子下沿')
+
+  const passed = checks.filter(entry => entry.ok).length
+  console.log(`\n${String(passed)}/${String(checks.length)} passed`)
+  if (passed !== checks.length) process.exitCode = 1
+}
+
+await main()
diff --git a/scripts/verify-tiles.ts b/scripts/verify-tiles.ts
new file mode 100644
index 0000000..3e77a6a
--- /dev/null
+++ b/scripts/verify-tiles.ts
@@ -0,0 +1,149 @@
+// verify-tiles.ts — 验收"每个槽位画的是不是它该有的那种瓦片"
+//
+// 这份脚本存在的原因是一次真实事故：地面引用在 `buildIsoMapScene()` 里以 `type = null` 走
+// **类型无关**的兜底池，池子里混着地面、墙、柱子、影子、树、屋顶。加上"按 RarityFrameIndex
+// 加权随机选变体"之后，地面槽位会随机挑到石墙/柱子瓦片，而地面绘制不做墙那套
+// `minBlockY + 80` 补偿 —— 于是画面里出现"悬在地面上的暗色方块"（35 关实测 1,918/28,704
+// 个地面槽位画错类型，修道院大教堂 28.2%、地下墓穴 4 层 41.5%）。
+//
+// 现在地面按 DT1 `type 0` 解析，这里把当年的普查变成永久断言：
+//   1. 地面槽位画出的瓦片 `type` 必须是 0；
+//   2. 墙/屋顶槽位不得画出地面瓦片（type 0）；
+//   3. `looseRefs == 0`（没有任何引用走类型无关兜底）与 `missingTiles == 0`——
+//      这两条合起来保证"画出的类型 == 引用的类型"；
+//   4. 位置自洽：地面 `y == (cx+cy)*40` 且瓦片 `minBlockY == 0`；
+//      墙 `y == (cx+cy)*40 + minBlockY + 80`；屋顶 `y == (cx+cy)*40 - roofHeight`。
+//
+//   node scripts/verify-tiles.ts [--dir=samples/d2] [--limit=35]
+//
+// 退出码非 0 表示有断言没过。
+
+export {}
+
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { fileSource } from '../src/mpq/file-source.ts'
+import { MountedArchives } from '../src/mpq/mount.ts'
+import { decodeDs1 } from '../src/formats/ds1.ts'
+import { decodeDt1 } from '../src/formats/dt1.ts'
+import type { Dt1 } from '../src/formats/dt1.ts'
+import { cell, loadActTables, resolveLevel, resolveLevelLibraries } from '../src/game/acts.ts'
+import { buildIsoMapScene, levelSeed, ORTHO_CELL_HEIGHT } from '../src/game/d2map.ts'
+
+/** 归档目录。 */
+const DIR = process.argv.find(argument => argument.startsWith('--dir='))?.slice('--dir='.length) ?? 'samples/d2'
+/** 最多走多少个预置关卡。 */
+const LIMIT = Number(process.argv.find(argument => argument.startsWith('--limit='))?.slice('--limit='.length) ?? '35')
+
+/** 断言结果。 */
+const checks: { name: string; ok: boolean; detail: string }[] = []
+
+/**
+ * 记录一条断言。
+ *
+ * @param name - what was checked.
+ * @param ok - whether it held.
+ * @param detail - evidence.
+ */
+function check(name: string, ok: boolean, detail: string): void {
+  checks.push({ name, ok, detail })
+  console.log(`${ok ? 'ok  ' : 'FAIL'} ${name} — ${detail}`)
+}
+
+/**
+ * 主流程。
+ */
+async function main(): Promise<void> {
+  const archives = new MountedArchives()
+  for (const name of ['d2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq']) {
+    archives.add(name, await MpqArchive.open(await fileSource(`${DIR}/${name}`)))
+  }
+  const tables = await loadActTables(archives)
+  const libraryCache = new Map<string, Dt1>()
+
+  let levels = 0
+  let floors = 0
+  let walls = 0
+  let roofs = 0
+  let wrongFloorType = 0
+  let floorAsWall = 0
+  let looseRefs = 0
+  let missingTiles = 0
+  let positionMismatch = 0
+  const worst: [number, string][] = []
+
+  for (const row of tables.levels.rows) {
+    if (cell(tables.levels, row, 'DrlgType') !== '2') continue
+    const levelId = Number(cell(tables.levels, row, 'Id'))
+    let info
+    try {
+      info = resolveLevel(tables, levelId)
+    } catch { continue }
+    const { dt1Names } = resolveLevelLibraries(tables, levelId)
+    const libs: Dt1[] = []
+    for (const name of dt1Names) {
+      const cached = libraryCache.get(name)
+      if (cached !== undefined) { libs.push(cached); continue }
+      try {
+        const decoded = decodeDt1(await archives.read(name))
+        libraryCache.set(name, decoded)
+        libs.push(decoded)
+      } catch { /* 缺库时 verify:acts 会报 */ }
+    }
+    if (libs.length === 0) continue
+    let ds1
+    try {
+      ds1 = decodeDs1(await archives.read(info.ds1Names[0]!))
+    } catch { continue }
+    if (levels >= LIMIT) break
+    levels += 1
+
+    const seed = levelSeed(info.ds1Names[0]!)
+    const scene = buildIsoMapScene(ds1, libs, seed)
+    looseRefs += scene.looseRefs
+    missingTiles += scene.missingTiles
+
+    let badHere = 0
+    for (const draw of scene.floors) {
+      const tile = libs[draw.library]?.tiles[draw.tile]
+      if (tile === undefined) continue
+      floors += 1
+      // (1) 地面槽位只能是 type 0 的瓦片
+      if (tile.type !== 0) { wrongFloorType += 1; badHere += 1 }
+      // (4) 地面位置：不带动画块补偿，且地面瓦片本身不该有块位移
+      if (draw.y - scene.originY !== (draw.cellX + draw.cellY) * ORTHO_CELL_HEIGHT || tile.minBlockY !== 0) positionMismatch += 1
+    }
+    for (const draw of scene.walls) {
+      const tile = libs[draw.library]?.tiles[draw.tile]
+      if (tile === undefined) continue
+      walls += 1
+      // (2) 墙槽位不该画出地面瓦片
+      if (tile.type === 0) floorAsWall += 1
+      // (4) 墙位置 = 格子基线 + 该瓦片自己的块位移 + 一格高
+      if (draw.y - scene.originY !== (draw.cellX + draw.cellY) * ORTHO_CELL_HEIGHT + tile.minBlockY + 80) positionMismatch += 1
+    }
+    for (const draw of scene.roofs) {
+      const tile = libs[draw.library]?.tiles[draw.tile]
+      if (tile === undefined) continue
+      roofs += 1
+      if (draw.y - scene.originY !== (draw.cellX + draw.cellY) * ORTHO_CELL_HEIGHT - tile.roofHeight) positionMismatch += 1
+    }
+    if (scene.floors.length > 0) worst.push([100 * badHere / scene.floors.length, info.levelName])
+  }
+
+  worst.sort((left, right) => right[0] - left[0])
+  console.log(`\n走了 ${String(levels)} 个预置关卡：地面 ${String(floors)} 槽、墙 ${String(walls)} 槽、屋顶 ${String(roofs)} 槽`)
+
+  check('地面槽位画出的瓦片类型都是 0（无错配方块）', wrongFloorType === 0,
+    `${String(wrongFloorType)} 个错类型 / ${String(floors)} 个地面槽`)
+  check('墙/屋顶槽位没有画出地面瓦片', floorAsWall === 0, `${String(floorAsWall)} 个`)
+  check('没有任何引用走类型无关兜底', looseRefs === 0, `looseRefs ${String(looseRefs)}`)
+  check('没有解析不到的引用', missingTiles === 0, `missingTiles ${String(missingTiles)}`)
+  check('地面/墙/屋顶的位置公式自洽', positionMismatch === 0, `${String(positionMismatch)} 个不符`)
+  if (worst.length > 0 && worst[0]![0] > 0) console.log(`   最严重：${worst.slice(0, 5).map(([pct, name]) => `${name} ${pct.toFixed(1)}%`).join('，')}`)
+
+  const passed = checks.filter(entry => entry.ok).length
+  console.log(`\n${String(passed)}/${String(checks.length)} passed`)
+  if (passed !== checks.length) process.exitCode = 1
+}
+
+await main()
diff --git a/scripts/verify-widths.ts b/scripts/verify-widths.ts
new file mode 100644
index 0000000..4ca9460
--- /dev/null
+++ b/scripts/verify-widths.ts
@@ -0,0 +1,62 @@
+/**
+ * Decode a sprite whose frames each have their own width.
+ *
+ * Diablo I's tile and cursor sheets are the case single-width auto-detection
+ * cannot serve: the inventory cursor sheet is paired with a sidecar list of
+ * per-frame widths, and dungeon tile sheets take their widths from the tile
+ * definitions. This drives the decoder with such a list against a real member,
+ * which is the only way to show the per-frame path actually matches shipped
+ * data.
+ *
+ * Usage: node scripts/verify-widths.ts <archive> <member> <widths-file>
+ */
+import { readFile } from 'node:fs/promises'
+import { MpqArchive } from '../src/mpq/archive.ts'
+import { fileSource } from '../src/mpq/file-source.ts'
+import { decodeSpriteFile } from '../src/formats/cel.ts'
+
+const [path, member, widthsPath] = process.argv.slice(2)
+if (path === undefined || member === undefined || widthsPath === undefined) {
+  console.error('usage: node scripts/verify-widths.ts <archive> <member> <widths-file>')
+  process.exit(2)
+}
+
+const widths = (await readFile(widthsPath, 'utf8'))
+  .split(/\s+/)
+  .filter(part => part !== '')
+  .map(part => Number.parseInt(part, 10))
+if (widths.some(width => !Number.isFinite(width) || width <= 0)) {
+  console.error('widths file has a non-positive or unparsable entry')
+  process.exit(1)
+}
+
+const archive = await MpqArchive.open(await fileSource(path))
+const mode = member.toLowerCase().endsWith('.cl2') ? 'cl2' : 'cel'
+const file = archive.find(member)
+if (file === undefined) {
+  console.error(`no such member: ${member}`)
+  process.exit(1)
+}
+
+const data = await archive.read(file)
+const sheet = decodeSpriteFile(data, mode, { widths })
+const frames = sheet.groups.flatMap(group => group.frames)
+const heights = frames.map(frame => frame.height)
+const coverage = frames.map(frame => {
+  let opaque = 0
+  for (const value of frame.mask) if (value !== 0) opaque += 1
+  return opaque
+})
+const empty = coverage.filter(count => count === 0).length
+
+console.log(`archive    ${path}`)
+console.log(`member     ${member} (${String(data.byteLength)} bytes, ${mode})`)
+console.log(`widths     ${String(widths.length)} entries from ${widthsPath}`)
+console.log(`groups     ${String(sheet.groups.length)}`)
+console.log(`frames     ${String(frames.length)} decoded`)
+console.log(`heights    ${String(Math.min(...heights))}..${String(Math.max(...heights))}`)
+console.log(`pixels     ${String(Math.min(...coverage))}..${String(Math.max(...coverage))} opaque per frame`)
+console.log(`empty      ${String(empty)} frames with no opaque pixels`)
+console.log(empty === 0 && frames.length === widths.length
+  ? 'RESULT     every frame decoded and matched its width entry exactly'
+  : 'RESULT     mismatch — check the width list against the frame count')
diff --git a/src/formats/bitstream.ts b/src/formats/bitstream.ts
new file mode 100644
index 0000000..ab70d72
--- /dev/null
+++ b/src/formats/bitstream.ts
@@ -0,0 +1,219 @@
+/**
+ * Least-significant-bit-first bit reader for Diablo II's packed sprite
+ * containers.
+ *
+ * Diablo II's `.dcc` files are not byte-aligned anywhere. The direction header
+ * ends mid-byte, the per-frame headers that follow are packed at whatever bit
+ * width the direction declares, and the four payload streams (equal-cell
+ * flags, pixel mask, encoding type, raw pixel codes) are laid out back to back
+ * starting at *bit* offsets — a stream that begins at byte 23 bit 6 stays at
+ * byte 23 bit 6 for its whole length.
+ *
+ * That has two consequences a naive reader gets wrong:
+ *
+ * - The reader's position has to be a bit index, not a byte cursor. Anything
+ *   that rounds to a byte boundary shifts every subsequent pixel code.
+ * - `copy()` must capture that exact bit position while giving the copy its own
+ *   read counter. The DCC decoder clones the reader to walk a sub-stream and
+ *   then skips the original past the sub-stream's declared bit length, and it
+ *   compares each sub-stream's *own* counter against its declared length as a
+ *   sanity check — so the copy must start counting from zero, not inherit the
+ *   parent's total.
+ *
+ * Bits are consumed least-significant-bit first within each byte, which is how
+ * the format was packed and what the reference implementation does.
+ */
+
+/** Largest single read the format ever needs: a 32-bit header word. */
+const MAX_READ_BITS = 32
+
+/**
+ * A reader over a byte buffer positioned at a bit offset.
+ *
+ * Reads past the end of the buffer throw instead of yielding zeroes: a DCC
+ * whose streams overrun its own extent is corrupt or mis-parsed, and both cases
+ * must be reported rather than silently producing a plausible-looking sprite.
+ */
+export class BitReader {
+  /** The bytes being read. Never copied, so clones share one buffer. */
+  private readonly data: Uint8Array
+  /** Current position, in bits from the start of `data`. */
+  private position: number
+  /** Bits consumed by *this* reader, mirroring the reference's per-stream count. */
+  private read: number
+
+  /**
+   * @param data - the buffer to read.
+   * @param bitOffset - starting position in bits (the DCC direction offset is
+   *   stored in bytes and scaled by 8 by the caller).
+   */
+  constructor(data: Uint8Array, bitOffset = 0) {
+    if (!Number.isInteger(bitOffset) || bitOffset < 0) {
+      throw new Error(`bit offset ${String(bitOffset)} is not a non-negative integer`)
+    }
+    this.data = data
+    this.position = bitOffset
+    this.read = 0
+  }
+
+  /** The reader's position in bits from the start of the buffer. */
+  get bitOffset(): number {
+    return this.position
+  }
+
+  /**
+   * Bits consumed by this reader.
+   *
+   * A clone starts this count at zero, matching the reference: the DCC decoder
+   * uses it to prove each sub-stream was consumed exactly to its declared
+   * length.
+   *
+   * @returns the count.
+   */
+  bitsRead(): number {
+    return this.read
+  }
+
+  /**
+   * Read one bit.
+   *
+   * @returns 0 or 1.
+   */
+  getBit(): number {
+    const position = this.position
+    if (position >= this.data.length * 8) {
+      throw new Error(`bit ${String(position)} is past the ${String(this.data.length)}-byte buffer`)
+    }
+    this.position = position + 1
+    this.read += 1
+    return (this.data[position >>> 3]! >>> (position & 7)) & 1
+  }
+
+  /**
+   * Read `count` bits as an unsigned value, low bit first.
+   *
+   * @param count - 0..32 bits; a count of 0 reads nothing and returns 0, as the
+   *   reference does (DCC declares optional field widths as 0 to mean absent).
+   * @returns the value, as an unsigned 32-bit number.
+   */
+  getBits(count: number): number {
+    if (count === 0) return 0
+    if (count < 0 || count > MAX_READ_BITS || !Number.isInteger(count)) {
+      throw new Error(`cannot read ${String(count)} bits (allowed 0..${String(MAX_READ_BITS)})`)
+    }
+    const data = this.data
+    const start = this.position
+    const end = start + count
+    if (end > data.length * 8) {
+      throw new Error(
+        `reading ${String(count)} bits at bit ${String(start)} overruns the ${String(data.length)}-byte buffer`,
+      )
+    }
+    let result = 0
+    let shift = 0
+    let position = start
+    // Consume whole or partial bytes; a chunk never straddles more than one
+    // byte boundary, so `shift + take <= 32` and nothing is lost to `<<`.
+    while (position < end) {
+      const bit = position & 7
+      const take = Math.min(8 - bit, end - position)
+      const chunk = (data[position >>> 3]! >>> bit) & ((1 << take) - 1)
+      result |= chunk << shift
+      shift += take
+      position += take
+    }
+    this.position = end
+    this.read += count
+    return result >>> 0
+  }
+
+  /**
+   * Read one byte.
+   *
+   * @returns 0..255.
+   */
+  getByte(): number {
+    return this.getBits(8)
+  }
+
+  /**
+   * Read a little-endian signed 32-bit word.
+   *
+   * @returns the value.
+   */
+  getInt32(): number {
+    return makeSigned(this.getBits(32), 32)
+  }
+
+  /**
+   * Read a little-endian unsigned 32-bit word.
+   *
+   * @returns the value.
+   */
+  getUint32(): number {
+    return this.getBits(32)
+  }
+
+  /**
+   * Read `count` bits and interpret them as two's-complement signed.
+   *
+   * @param count - the field width; 0 reads nothing and returns 0.
+   * @returns the signed value.
+   */
+  getSignedBits(count: number): number {
+    return makeSigned(this.getBits(count), count)
+  }
+
+  /**
+   * Advance without reading.
+   *
+   * Skips are unchecked, as in the reference: the DCC decoder skips past
+   * sub-streams it already consumed through a clone, and the last one lands
+   * exactly on the end of the payload.
+   *
+   * @param count - bits to skip.
+   */
+  skipBits(count: number): void {
+    if (!Number.isInteger(count) || count < 0) {
+      throw new Error(`cannot skip ${String(count)} bits`)
+    }
+    this.position += count
+    this.read += count
+  }
+
+  /**
+   * Clone this reader at the current bit position.
+   *
+   * The clone shares the buffer, starts with the same bit offset — mid-byte
+   * positions included, which is the whole point — and resets its own
+   * `bitsRead()` counter to zero.
+   *
+   * @returns the clone.
+   */
+  copy(): BitReader {
+    return new BitReader(this.data, this.position)
+  }
+}
+
+/**
+ * Interpret a bit field as two's-complement signed, matching the reference's
+ * `MakeSigned` exactly: 0 bits is 0, a single bit is 0 or -1 (there is no
+ * redundant sign bit to spend), and everything else is sign-extended from the
+ * top bit.
+ *
+ * @param value - the unsigned field, as read.
+ * @param bits - the field width.
+ * @returns the signed value.
+ */
+function makeSigned(value: number, bits: number): number {
+  if (bits === 0) return 0
+  if (bits === 1) return -value
+  if (((value >>> 0) & (1 << (bits - 1))) === 0) return value | 0
+  // Sign extension is done by subtraction in the unsigned domain, exactly like
+  // the reference, so widths above 31 (where JS bitwise ops stay 32-bit) agree.
+  let result = 0xffffffff
+  for (let i = 0; i < bits; i += 1) {
+    if (((value >>> i) & 1) === 0) result = (result - 2 ** i) >>> 0
+  }
+  return result | 0
+}
diff --git a/src/formats/cel.ts b/src/formats/cel.ts
new file mode 100644
index 0000000..374963b
--- /dev/null
+++ b/src/formats/cel.ts
@@ -0,0 +1,472 @@
+/**
+ * Diablo I sprite decoders: `.cel` (plain) and `.cl2` (its compressed form).
+ *
+ * Both are palette-indexed sprite sheets. What differs is how the run stream
+ * maps onto the frame grid:
+ *
+ * - **CEL** runs are *line-bounded*: every row's runs sum to exactly the frame
+ *   width, so the decoder consumes one row at a time and the frame height is
+ *   the number of rows. A run that overruns its row means corrupt input, not a
+ *   wrapped row, so it is rejected instead of silently wrapping (the reference
+ *   decoder's unsigned counter would wrap instead).
+ * - **CL2** runs may *cross* row boundaries, so the stream is written flat into
+ *   the frame and line bookkeeping is derived from the overrun, exactly as the
+ *   reference decoder does.
+ *
+ * Neither format stores the frame width: the game supplies it per animation
+ * (Diablo's own tables give, e.g., the walk width per class). A viewer can
+ * recover it, which {@link detectSpriteWidth} does by requiring every frame in
+ * the file to be consumed exactly.
+ */
+import { CelError, spriteWidthCandidates } from './sprite.ts'
+import type { SpriteFrame, SpriteGroup, SpriteSheet } from './sprite.ts'
+
+export type { SpriteFrame, SpriteGroup, SpriteSheet } from './sprite.ts'
+export { CelError } from './sprite.ts'
+
+/** Options shared by both decoders. */
+export interface DecodeOptions {
+  /**
+   * Frame width. Required by the formats themselves; when omitted the width is
+   * auto-detected from the file (see {@link detectSpriteWidth}) for `.cel`, and
+   * rejected for `.cl2`.
+   */
+  width?: number | undefined
+  /**
+   * Per-frame widths, indexed by the frame's position within its group.
+   *
+   * Diablo I mixes both conventions: full-animation sheets use one width, while
+   * tile and cursor sheets give every frame its own (the inventory cursor sheet
+   * ships a sidecar width list, and dungeon tile sheets take theirs from the
+   * tile definitions). Takes precedence over {@link width}.
+   */
+  widths?: readonly number[] | undefined
+  /** Cap on decoded frames, to keep a pathological file from exhausting memory. */
+  maxFrames?: number | undefined
+  /** Cap on one frame's pixel count. */
+  maxFramePixels?: number | undefined
+}
+
+/** Sentinel used by the reference decoder to mark a frame header. */
+const CEL_FRAME_HEADER_SIZE = 10
+/** Default guard: the largest sprite sheet in the game is far below this. */
+const DEFAULT_MAX_FRAMES = 20000
+/** Default guard for one frame (a 4096×4096 indexed frame). */
+const DEFAULT_MAX_FRAME_PIXELS = 1 << 24
+
+/** Read a little-endian uint32. */
+function u32(data: Uint8Array, at: number): number {
+  return (data[at]! | (data[at + 1]! << 8) | (data[at + 2]! << 16) | (data[at + 3]! << 24)) >>> 0
+}
+
+/** Read a little-endian uint16. */
+function u16(data: Uint8Array, at: number): number {
+  return data[at]! | (data[at + 1]! << 8)
+}
+
+/** A frame's frame-extent table, as `[start, end)` pairs. */
+type Extents = readonly (readonly [number, number])[]
+
+/**
+ * Resolve a file's groups.
+ *
+ * A single-group file is `[count][count + 1 offsets][frames...]`; a multi-group
+ * file instead opens with a group table. CEL and CL2 differ in how that table
+ * is read: CEL concatenates its groups after it, CL2 stores offsets to them.
+ *
+ * @param data - the complete file.
+ * @param mode - `'cel'` or `'cl2'`.
+ * @returns the groups' base offsets, or a single group when there is no table.
+ */
+function readGroups(data: Uint8Array, mode: 'cel' | 'cl2'): { groupBases: number[]; single: boolean } | { error: string } {
+  const first = u32(data, 0)
+  if (first === 0) return { error: 'declares zero frames' }
+  const lastOffsetAt = first * 4 + 4
+  if (lastOffsetAt + 4 <= data.byteLength && u32(data, lastOffsetAt) === data.byteLength) {
+    // Single group: the frame table's last entry is the file size.
+    return { groupBases: [0], single: true }
+  }
+  const numGroups = Math.floor(first / 4)
+  if (numGroups === 0 || numGroups > 4096) return { error: `implausible group count ${String(numGroups)}` }
+  if (mode === 'cel') {
+    // Groups are laid out back to back after the table; their bases are not
+    // stored, so they are walked by decoding.
+    return { groupBases: [], single: false }
+  }
+  const bases: number[] = []
+  for (let group = 0; group < numGroups; group += 1) {
+    const base = u32(data, group * 4)
+    if (base + 4 > data.byteLength) return { error: `group ${String(group)} offset ${String(base)} is out of range` }
+    bases.push(base)
+  }
+  return { groupBases: bases, single: false }
+}
+
+/**
+ * The frame extents of one group.
+ *
+ * @param data - the complete file.
+ * @param base - the group's base offset.
+ * @returns the extents, each `[start, end)` in absolute file offsets.
+ */
+function groupExtents(data: Uint8Array, base: number): Extents | { error: string } {
+  const count = u32(data, base)
+  if (count === 0 || count > 65535) return { error: `implausible frame count ${String(count)}` }
+  const extents: [number, number][] = []
+  for (let frame = 0; frame < count; frame += 1) {
+    const start = u32(data, base + 4 * (frame + 1))
+    const end = u32(data, base + 4 * (frame + 2))
+    if (start < 0 || end < start || base + end > data.byteLength) {
+      return { error: `frame ${String(frame)} extent ${String(start)}..${String(end)} is out of range` }
+    }
+    extents.push([base + start, base + end])
+  }
+  return extents
+}
+
+/**
+ * Decode one CEL frame.
+ *
+ * @param data - the complete file.
+ * @param start - frame start offset.
+ * @param end - frame end offset.
+ * @param width - frame width.
+ * @param maxFramePixels - pixel-count guard.
+ * @returns the frame.
+ */
+function decodeCelFrame(data: Uint8Array, start: number, end: number, width: number, maxFramePixels: number): SpriteFrame | { error: string } {
+  let cursor = start
+  // Some frames carry a 10-byte header whose first word is its own size.
+  if (cursor + 2 <= end && u16(data, cursor) === CEL_FRAME_HEADER_SIZE) cursor += CEL_FRAME_HEADER_SIZE
+  const capacity = Math.min(maxFramePixels, Math.max(width * 4096, width))
+  const indices = new Uint8Array(capacity)
+  const mask = new Uint8Array(capacity)
+  let at = 0
+  let height = 0
+  while (cursor < end) {
+    let remaining = width
+    while (remaining > 0) {
+      if (cursor >= end) return { error: `row ${String(height)} ran past the frame end` }
+      const control = data[cursor]!
+      cursor += 1
+      if (control >= 0x80) {
+        remaining -= 256 - control
+      } else {
+        const run = control
+        if (run > remaining) return { error: `row ${String(height)} overruns by ${String(run - remaining)} pixels` }
+        if (cursor + run > end) return { error: `row ${String(height)} literal run is truncated` }
+        if (at + run > capacity) return { error: 'frame exceeds the pixel guard' }
+        indices.set(data.subarray(cursor, cursor + run), at)
+        mask.fill(1, at, at + run)
+        cursor += run
+        at += run
+        remaining -= run
+      }
+    }
+    height += 1
+    if (height * width > capacity) return { error: 'frame exceeds the pixel guard' }
+  }
+  if (cursor !== end) return { error: 'frame was not consumed exactly' }
+  return {
+    width,
+    height,
+    indices: indices.subarray(0, width * height),
+    mask: mask.subarray(0, width * height),
+  }
+}
+
+/**
+ * Decode one CL2 frame, whose runs may cross row boundaries.
+ *
+ * @param data - the complete file.
+ * @param start - frame start offset.
+ * @param end - frame end offset.
+ * @param width - frame width.
+ * @param maxFramePixels - pixel-count guard.
+ * @returns the frame, the column the run stream ended on, or the failure.
+ */
+function decodeCl2FrameOutcome(data: Uint8Array, start: number, end: number, width: number, maxFramePixels: number): { ok: true; frame: SpriteFrame; lastXOffset: number } | { ok: false; error: string } {
+  // The frame opens with the size of its own header.
+  if (start + 2 > end) return { ok: false, error: 'frame is too short for its header' }
+  let cursor = start + u16(data, start)
+  if (cursor > end) return { ok: false, error: 'frame header points past the frame end' }
+  const capacity = Math.min(maxFramePixels, Math.max(width * 4096, width))
+  const indices = new Uint8Array(capacity)
+  const mask = new Uint8Array(capacity)
+  let at = 0
+  let height = 0
+  let xOffset = 0
+  while (cursor < end) {
+    let remaining = width - xOffset
+    while (remaining > 0) {
+      if (cursor >= end) return { ok: false, error: 'runs ran past the frame end' }
+      const control = data[cursor]!
+      cursor += 1
+      if (control < 0x80) {
+        // Transparent run of `control` pixels.
+        if (at + control > capacity) return { ok: false, error: 'frame exceeds the pixel guard' }
+        at += control
+        remaining -= control
+      } else if (control <= 0xbe) {
+        // Fill run: one colour repeated 0xBF - control times.
+        const count = 0xbf - control
+        if (cursor >= end) return { ok: false, error: 'fill run is truncated' }
+        const color = data[cursor]!
+        cursor += 1
+        if (at + count > capacity) return { ok: false, error: 'frame exceeds the pixel guard' }
+        indices.fill(color, at, at + count)
+        mask.fill(1, at, at + count)
+        at += count
+        remaining -= count
+      } else {
+        // Literal run of 256 - control pixels (0xBF is 65 wide).
+        const count = 256 - control
+        if (cursor + count > end) return { ok: false, error: 'literal run is truncated' }
+        if (at + count > capacity) return { ok: false, error: 'frame exceeds the pixel guard' }
+        indices.set(data.subarray(cursor, cursor + count), at)
+        mask.fill(1, at, at + count)
+        cursor += count
+        at += count
+        remaining -= count
+      }
+    }
+    if (remaining === 0) {
+      height += 1
+      xOffset = 0
+    } else {
+      const overrun = -remaining
+      height += Math.floor(overrun / width) + 1
+      xOffset = overrun % width
+    }
+  }
+  if (cursor !== end) return { ok: false, error: 'frame was not consumed exactly' }
+  const pixels = width * height
+  if (pixels > capacity) return { ok: false, error: 'frame exceeds the pixel guard' }
+  return {
+    ok: true,
+    lastXOffset: xOffset,
+    frame: {
+      width,
+      height,
+      indices: indices.subarray(0, pixels),
+      mask: mask.subarray(0, pixels),
+    },
+  }
+}
+
+/**
+ * Decode one CL2 frame, discarding the row-alignment diagnostic.
+ *
+ * @param data - the complete file.
+ * @param start - frame start offset.
+ * @param end - frame end offset.
+ * @param width - frame width.
+ * @param maxFramePixels - pixel-count guard.
+ * @returns the frame or the failure.
+ */
+function decodeCl2Frame(data: Uint8Array, start: number, end: number, width: number, maxFramePixels: number): SpriteFrame | { error: string } {
+  const outcome = decodeCl2FrameOutcome(data, start, end, width, maxFramePixels)
+  return outcome.ok ? outcome.frame : { error: outcome.error }
+}
+
+/**
+ * Guess which frame widths a CL2 file could have been encoded with.
+ *
+ * Weaker than the CEL rule, deliberately: a CL2 run stream is consumed to the
+ * frame end under any width, so exactness proves nothing here. What survives is
+ * *row alignment* — an encoder pads the final row, so the stream ends on a
+ * column boundary for the true width. Candidates that satisfy this are
+ * plausible, not proven; the game's own tables stay authoritative (see
+ * `PLAYER_SPRITE_WIDTH`).
+ *
+ * @param data - the complete file.
+ * @param candidates - widths to try.
+ * @returns the widths under which every frame decodes and ends on a row boundary.
+ */
+export function cl2WidthCandidates(data: Uint8Array, candidates: readonly number[]): number[] {
+  const groupsInfo = readGroups(data, 'cl2')
+  if ('error' in groupsInfo) return []
+  const bases = groupsInfo.single ? [0] : [...groupsInfo.groupBases]
+  const usable: number[] = []
+  for (const width of candidates) {
+    let aligned = bases.length > 0
+    for (const base of bases) {
+      const extents = groupExtents(data, base)
+      if ('error' in extents) { aligned = false; break }
+      for (const [frameStart, frameEnd] of extents) {
+        const outcome = decodeCl2FrameOutcome(data, frameStart, frameEnd, width, DEFAULT_MAX_FRAME_PIXELS)
+        if (!outcome.ok || outcome.lastXOffset !== 0 || outcome.frame.height === 0) { aligned = false; break }
+      }
+      if (!aligned) break
+    }
+    if (aligned) usable.push(width)
+  }
+  return usable
+}
+
+/**
+ * Decode a sprite file.
+ *
+ * @param data - the complete file.
+ * @param mode - `'cel'` or `'cl2'`.
+ * @param options - width override and guards.
+ * @returns the decoded sheet.
+ */
+export function decodeSpriteFile(data: Uint8Array, mode: 'cel' | 'cl2', options: DecodeOptions = {}): SpriteSheet {
+  const maxFrames = options.maxFrames ?? DEFAULT_MAX_FRAMES
+  const maxFramePixels = options.maxFramePixels ?? DEFAULT_MAX_FRAME_PIXELS
+  if (data.byteLength < 8) throw new CelError(`file is only ${String(data.byteLength)} bytes`)
+  const groupsInfo = readGroups(data, mode)
+  if ('error' in groupsInfo) throw new CelError(groupsInfo.error)
+
+  const perFrame = options.widths
+  const uniform = options.width ?? (perFrame === undefined && mode === 'cel' ? detectSpriteWidth(data) : null)
+  if (perFrame === undefined && uniform === null) {
+    throw new CelError(mode === 'cl2'
+      ? 'CL2 does not store its frame width: pass the width (or per-frame widths) the game uses for this animation'
+      : 'could not determine the frame width (no single width consumes the file exactly; tile and cursor sheets need per-frame widths)')
+  }
+
+  const groups: SpriteGroup[] = []
+  let frames = 0
+  if (groupsInfo.single) {
+    const extents = groupExtents(data, 0)
+    if ('error' in extents) throw new CelError(extents.error)
+    groups.push({ frames: decodeFrames(data, extents, mode, uniform, perFrame, maxFramePixels) })
+    frames += extents.length
+  } else if (mode === 'cl2') {
+    for (const base of groupsInfo.groupBases) {
+      const extents = groupExtents(data, base)
+      if ('error' in extents) throw new CelError(extents.error)
+      if (frames + extents.length > maxFrames) throw new CelError('file exceeds the frame guard')
+      groups.push({ frames: decodeFrames(data, extents, mode, uniform, perFrame, maxFramePixels) })
+      frames += extents.length
+    }
+  } else {
+    // CEL multi-group: groups are concatenated, so each group is found by
+    // decoding the previous one to its end.
+    let base = Math.floor(u32(data, 0) / 4) * 4
+    while (base < data.byteLength && groups.length < 4096) {
+      const extents = groupExtents(data, base)
+      if ('error' in extents) throw new CelError(extents.error)
+      if (frames + extents.length > maxFrames) throw new CelError('file exceeds the frame guard')
+      groups.push({ frames: decodeFrames(data, extents, mode, uniform, perFrame, maxFramePixels) })
+      frames += extents.length
+      const last = extents[extents.length - 1]
+      /* v8 ignore next -- extents is non-empty by construction. */
+      if (last === undefined) break
+      base = last[1]
+    }
+  }
+  return { groups, width: uniform }
+}
+
+/**
+ * Decode a run of frames that share one width.
+ *
+ * @param data - the complete file.
+ * @param extents - frame extents.
+ * @param mode - `'cel'` or `'cl2'`.
+ * @param width - frame width.
+ * @param maxFramePixels - pixel-count guard.
+ * @returns the frames.
+ */
+function decodeFrames(
+  data: Uint8Array,
+  extents: Extents,
+  mode: 'cel' | 'cl2',
+  uniform: number | null,
+  perFrame: readonly number[] | undefined,
+  maxFramePixels: number,
+): SpriteFrame[] {
+  const frames: SpriteFrame[] = []
+  for (const [start, end] of extents) {
+    const width = perFrame === undefined ? uniform : perFrame[frames.length]
+    if (width === undefined || width === null) {
+      throw new CelError(`no width for frame ${String(frames.length)} (the width list has ${String(perFrame?.length ?? 0)} entries)`)
+    }
+    const frame = mode === 'cel'
+      ? decodeCelFrame(data, start, end, width, maxFramePixels)
+      : decodeCl2Frame(data, start, end, width, maxFramePixels)
+    if ('error' in frame) {
+      throw new CelError(`frame ${String(frames.length)}: ${frame.error}`)
+    }
+    frames.push(frame)
+  }
+  return frames
+}
+
+/**
+ * Recover a `.cel` file's frame width by requiring every row to be consumed
+ * exactly.
+ *
+ * CEL's runs are line-bounded, so a wrong width makes a row's runs overrun and
+ * the file is rejected — the width that survives is the real one. This does not
+ * extend to CL2, whose runs may cross rows: there the run stream is consumed
+ * under any width, which is why {@link decodeSpriteFile} insists on being told.
+ *
+ * @param data - the complete file.
+ * @param candidates - widths to try, smallest first.
+ * @returns the smallest width that decodes the whole file, or null.
+ */
+export function detectSpriteWidth(
+  data: Uint8Array,
+  candidates: readonly number[] = spriteWidthCandidates(),
+): number | null {
+  const groupsInfo = readGroups(data, 'cel')
+  if ('error' in groupsInfo) return null
+  for (const width of candidates) {
+    if (decodesExactly(data, groupsInfo, width)) return width
+  }
+  return null
+}
+
+/**
+ * Whether one width decodes every CEL frame of every group exactly.
+ *
+ * @param data - the complete file.
+ * @param groupsInfo - the resolved group layout.
+ * @param width - candidate width.
+ * @returns true when the whole file is consumed with no leftovers.
+ */
+function decodesExactly(
+  data: Uint8Array,
+  groupsInfo: { groupBases: readonly number[]; single: boolean },
+  width: number,
+): boolean {
+  const guard = DEFAULT_MAX_FRAME_PIXELS
+  const bases = groupsInfo.single ? [0] : celGroupBases(data)
+  if (bases.length === 0) return false
+  for (const base of bases) {
+    const extents = groupExtents(data, base)
+    if ('error' in extents) return false
+    for (const [start, end] of extents) {
+      const frame = decodeCelFrame(data, start, end, width, guard)
+      if ('error' in frame) return false
+      if (frame.height === 0) return false
+    }
+  }
+  return true
+}
+
+/**
+ * Walk a multi-group CEL file's concatenated group bases.
+ *
+ * @param data - the complete file.
+ * @returns the group bases.
+ */
+function celGroupBases(data: Uint8Array): number[] {
+  const bases: number[] = []
+  let base = Math.floor(u32(data, 0) / 4) * 4
+  while (base + 8 <= data.byteLength && bases.length < 4096) {
+    bases.push(base)
+    const extents = groupExtents(data, base)
+    if ('error' in extents) break
+    const last = extents[extents.length - 1]
+    /* v8 ignore next -- extents is non-empty by construction. */
+    if (last === undefined) break
+    if (last[1] <= base) break
+    base = last[1]
+  }
+  return bases
+}
diff --git a/src/formats/cof.ts b/src/formats/cof.ts
new file mode 100644
index 0000000..f77f577
--- /dev/null
+++ b/src/formats/cof.ts
@@ -0,0 +1,224 @@
+/**
+ * Diablo II `.cof` animation-table decoder.
+ *
+ * A COF carries no pixels. It is the glue between an animation and the sprite
+ * files that make it up: how many directions and frames the animation has, how
+ * many composite layers the character or object is assembled from, which weapon
+ * class each layer belongs to, and — the part that is easy to miss — the *draw
+ * order* of those layers for every direction and frame, since an arm has to be
+ * in front of the torso when the character faces one way and behind it when the
+ * character faces the other.
+ *
+ * The layout is fixed-width and byte-aligned throughout, so unlike `.dcc` this
+ * decoder is a plain cursor walk:
+ *
+ * - a 25-byte header: layer count, frames per direction, direction count, 21
+ *   bytes the original tool left as uninitialised garbage, and an animation
+ *   speed;
+ * - three body bytes nobody has ever explained;
+ * - one 9-byte record per layer;
+ * - one byte per frame, the "animation frame" tag;
+ * - one byte per (direction, frame, layer), the priority table.
+ *
+ * The priority bytes are *composite types*, not layer indices — the shipped
+ * Sorceress walk lists types in an order that does not match record order, which
+ * is exactly why a renderer must resolve them through the layer records instead
+ * of using them directly. That resolution is `cofLayerOrder`.
+ */
+import { CelError } from './sprite.ts'
+
+/** Fixed part of the file, up to and including the animation-speed byte. */
+const HEADER_SIZE = 25
+/** Byte offset of the animation speed inside the header. */
+const HEADER_SPEED = 24
+/** Unexplained bytes between the header and the first layer record. */
+const BODY_PREFIX_SIZE = 3
+/** Bytes per layer record: five scalar fields plus a four-byte weapon class. */
+const LAYER_SIZE = 9
+/** Offset of the weapon-class code inside a layer record. */
+const LAYER_WEAPON_CLASS = 5
+
+/** One composite layer of an animation. */
+export interface CofLayer {
+  /** Composite type this layer draws (which body part or equipment slot). */
+  readonly type: number
+  /** Shadow flag, as stored. */
+  readonly shadow: number
+  /** Whether the layer takes part in hit detection. */
+  readonly selectable: boolean
+  /** Whether the layer is drawn with transparency. */
+  readonly transparent: boolean
+  /** Draw-effect selector, as stored. */
+  readonly drawEffect: number
+  /**
+   * Weapon-class code this layer applies to, e.g. `hth` for unarmed or `1hs` for
+   * a one-handed sword, with the record's NUL padding stripped.
+   *
+   * Kept as the raw code rather than an enum: this port has no weapon-class
+   * enumeration, and callers select layers by matching codes they already have
+   * from the item tables.
+   */
+  readonly weaponClass: string
+}
+
+/** A decoded COF animation table. */
+export interface CofFile {
+  /** Number of directions the animation has. */
+  readonly numberOfDirections: number
+  /** Number of frames per direction. */
+  readonly framesPerDirection: number
+  /** Number of composite layers per frame. */
+  readonly numberOfLayers: number
+  /** Animation speed byte; 0 means "default" (25 fps) to the original engine. */
+  readonly speed: number
+  /** Layer records, in file order. */
+  readonly layers: readonly CofLayer[]
+  /** One tag byte per frame. */
+  readonly animationFrames: Uint8Array
+  /**
+   * Priority table: `priority[direction][frame]` lists the composite types to
+   * draw, back to front. Resolve it with `cofLayerOrder`.
+   */
+  readonly priority: readonly (readonly (readonly number[])[])[]
+}
+
+/**
+ * Decode a COF file.
+ *
+ * @param data - the complete file.
+ * @returns the animation table.
+ */
+export function decodeCof(data: Uint8Array): CofFile {
+  const minimum = HEADER_SIZE + BODY_PREFIX_SIZE
+  if (data.byteLength < minimum) {
+    throw new CelError(`COF is ${String(data.byteLength)} bytes, too short for a ${String(minimum)}-byte header`)
+  }
+
+  const numberOfLayers = data[0]!
+  const framesPerDirection = data[1]!
+  const numberOfDirections = data[2]!
+  const speed = data[HEADER_SPEED]!
+
+  let offset = minimum
+  const layers: CofLayer[] = []
+  for (let i = 0; i < numberOfLayers; i += 1) {
+    if (offset + LAYER_SIZE > data.byteLength) {
+      throw new CelError(
+        `COF layer ${String(i)} runs past the end of the ${String(data.byteLength)}-byte file`,
+      )
+    }
+    layers.push({
+      type: data[offset]!,
+      shadow: data[offset + 1]!,
+      selectable: data[offset + 2]! > 0,
+      transparent: data[offset + 3]! > 0,
+      drawEffect: data[offset + 4]!,
+      weaponClass: readWeaponClass(data, offset + LAYER_WEAPON_CLASS),
+    })
+    offset += LAYER_SIZE
+  }
+
+  if (offset + framesPerDirection > data.byteLength) {
+    throw new CelError(
+      `COF declares ${String(framesPerDirection)} frames but only ${String(data.byteLength - offset)} bytes remain`,
+    )
+  }
+  const animationFrames = data.slice(offset, offset + framesPerDirection)
+  offset += framesPerDirection
+
+  const priorityLength = numberOfDirections * framesPerDirection * numberOfLayers
+  if (offset + priorityLength > data.byteLength) {
+    throw new CelError(
+      `COF priority table needs ${String(priorityLength)} bytes but only ${String(data.byteLength - offset)} remain`,
+    )
+  }
+
+  const priority: number[][][] = []
+  let at = offset
+  for (let direction = 0; direction < numberOfDirections; direction += 1) {
+    const frames: number[][] = []
+    for (let frame = 0; frame < framesPerDirection; frame += 1) {
+      const row: number[] = []
+      for (let layer = 0; layer < numberOfLayers; layer += 1) row.push(data[at + layer]!)
+      at += numberOfLayers
+      frames.push(row)
+    }
+    priority.push(frames)
+  }
+
+  return {
+    numberOfDirections,
+    framesPerDirection,
+    numberOfLayers,
+    speed,
+    layers,
+    animationFrames,
+    priority,
+  }
+}
+
+/**
+ * The draw order for one direction and frame, as indices into `cof.layers`.
+ *
+ * The priority table stores composite *types*, and a COF's layer records are not
+ * obliged to be sorted by type — the shipped Sorceress walk is not — so the
+ * types have to be resolved back to record indices before anything can be
+ * drawn. Entries naming a type no layer declares are dropped rather than
+ * guessed at: there is provably nothing to draw for them. If two layers share a
+ * type, the first record wins, so a layer is never drawn twice.
+ *
+ * @param cof - the decoded animation table.
+ * @param direction - direction index.
+ * @param frame - frame index within the direction.
+ * @returns layer indices, back to front.
+ */
+export function cofLayerOrder(cof: CofFile, direction: number, frame: number): number[] {
+  const frames = cof.priority[direction]
+  if (frames === undefined) {
+    throw new CelError(
+      `COF has no direction ${String(direction)} (it declares ${String(cof.numberOfDirections)})`,
+    )
+  }
+  const row = frames[frame]
+  if (row === undefined) {
+    throw new CelError(
+      `COF direction ${String(direction)} has no frame ${String(frame)} (it declares ${String(cof.framesPerDirection)})`,
+    )
+  }
+
+  const order: number[] = []
+  const used = new Set<number>()
+  for (const type of row) {
+    let index = -1
+    for (let i = 0; i < cof.layers.length; i += 1) {
+      if (cof.layers[i]!.type === type) {
+        index = i
+        break
+      }
+    }
+    if (index < 0 || used.has(index)) continue
+    used.add(index)
+    order.push(index)
+  }
+  return order
+}
+
+/**
+ * Read a layer record's four-byte weapon-class code.
+ *
+ * The field is NUL-padded and, in a few shipped files, space-padded as well, so
+ * the NULs are dropped and the result trimmed — the same normalisation the
+ * reference applies before mapping the code to its weapon-class enumeration.
+ *
+ * @param data - the file.
+ * @param at - offset of the four-byte code.
+ * @returns the code, e.g. `hth`, possibly empty.
+ */
+function readWeaponClass(data: Uint8Array, at: number): string {
+  let text = ''
+  for (let i = 0; i < 4; i += 1) {
+    const byte = data[at + i]!
+    if (byte !== 0) text += String.fromCharCode(byte)
+  }
+  return text.trim()
+}
diff --git a/src/formats/dc6.ts b/src/formats/dc6.ts
new file mode 100644
index 0000000..6937d21
--- /dev/null
+++ b/src/formats/dc6.ts
@@ -0,0 +1,209 @@
+/**
+ * Diablo II `.dc6` sprite decoder.
+ *
+ * DC6 is Diablo II's replacement for Diablo I's CEL: a multi-direction,
+ * multi-frame sheet of palette-indexed frames, stored as one run stream per
+ * frame. Two properties are easy to get wrong and are worth stating outright,
+ * because both independent reference implementations agree on them:
+ *
+ * - **Rows are stored bottom-up.** The first decoded scanline is the frame's
+ *   last row, so the stream must be written starting at `height - 1` and
+ *   counting down. Filling rows top-down yields a vertically mirrored sprite.
+ * - **The run alphabet is three-way**, not two: `0x80` ends a scanline, any
+ *   other byte with the high bit set is a *transparent* run of `byte & 0x7f`
+ *   pixels, and a byte below `0x80` introduces that many literal pixels. A
+ *   decoder that treats `0x80` as "transparent run of zero" desynchronises the
+ *   rest of the frame.
+ *
+ * Index 0 is transparent by convention (the encoder leaves the palette's first
+ * entry unused), which is why frames carry a mask rather than relying on a
+ * sentinel index.
+ */
+import { CelError } from './sprite.ts'
+import type { SpriteFrame, SpriteGroup, SpriteSheet } from './sprite.ts'
+
+/** Byte offset of the file header, and its size. */
+const FILE_HEADER_SIZE = 24
+/** Byte offset of a frame header inside its frame, and its size. */
+const FRAME_HEADER_SIZE = 32
+/** Byte count of the per-frame terminator written after the run stream. */
+const FRAME_TERMINATOR_SIZE = 3
+/** Scanline terminator in the run alphabet. */
+const END_OF_SCANLINE = 0x80
+/** Mask extracting a transparent run's length. */
+const RUN_LENGTH_MASK = 0x7f
+
+/** The DC6 file header. */
+export interface Dc6Header {
+  /** Format version (6 for the shipped format). */
+  readonly version: number
+  /** Flag word (`1` serialised, `4` 24-bit). */
+  readonly flags: number
+  /** Encoding word as stored. */
+  readonly encoding: number
+  /** Number of directions. */
+  readonly directions: number
+  /** Frames per direction. */
+  readonly framesPerDirection: number
+}
+
+/** One decoded frame plus the fields the renderer needs for placement. */
+export interface Dc6Frame extends SpriteFrame {
+  /** Frame anchor x, as stored. */
+  readonly offsetX: number
+  /** Frame anchor y, as stored. */
+  readonly offsetY: number
+  /** The frame's own serial number in the sheet. */
+  readonly index: number
+}
+
+/** A decoded DC6 sheet, grouped by direction. */
+export interface Dc6Sheet extends SpriteSheet {
+  /** The file header. */
+  readonly header: Dc6Header
+  /** Frames grouped by direction, each carrying its own size. */
+  readonly groups: readonly { readonly frames: readonly Dc6Frame[] }[]
+}
+
+/** Guard against a corrupt header demanding a huge allocation. */
+const MAX_FRAMES = 4096
+/** Guard on one frame's pixel count. */
+const MAX_FRAME_PIXELS = 1 << 24
+
+/**
+ * Read a little-endian uint32.
+ *
+ * @param data - the buffer.
+ * @param at - byte offset.
+ * @returns the value.
+ */
+function u32(data: Uint8Array, at: number): number {
+  return (data[at]! | (data[at + 1]! << 8) | (data[at + 2]! << 16) | (data[at + 3]! << 24)) >>> 0
+}
+
+/**
+ * Read a little-endian int32.
+ *
+ * @param data - the buffer.
+ * @param at - byte offset.
+ * @returns the value.
+ */
+function i32(data: Uint8Array, at: number): number {
+  return (u32(data, at) | 0)
+}
+
+/**
+ * Decode a DC6 file.
+ *
+ * @param data - the complete file.
+ * @returns the decoded sheet.
+ */
+export function decodeDc6(data: Uint8Array): Dc6Sheet {
+  if (data.byteLength < FILE_HEADER_SIZE) {
+    throw new CelError(`DC6 is ${String(data.byteLength)} bytes, too short for a header`)
+  }
+  const header: Dc6Header = {
+    version: i32(data, 0x00),
+    flags: u32(data, 0x04),
+    encoding: u32(data, 0x08),
+    directions: i32(data, 0x10),
+    framesPerDirection: i32(data, 0x14),
+  }
+  if (header.directions <= 0 || header.framesPerDirection <= 0) {
+    throw new CelError(`DC6 declares ${String(header.directions)} directions and ${String(header.framesPerDirection)} frames per direction`)
+  }
+  const total = header.directions * header.framesPerDirection
+  if (total > MAX_FRAMES) throw new CelError(`DC6 declares ${String(total)} frames, above the ${String(MAX_FRAMES)} guard`)
+
+  const pointers = new Array<number>(total)
+  for (let index = 0; index < total; index += 1) {
+    pointers[index] = u32(data, FILE_HEADER_SIZE + index * 4)
+  }
+
+  const groups: { frames: Dc6Frame[] }[] = []
+  for (let direction = 0; direction < header.directions; direction += 1) {
+    const frames: Dc6Frame[] = []
+    for (let frameIndex = 0; frameIndex < header.framesPerDirection; frameIndex += 1) {
+      const index = direction * header.framesPerDirection + frameIndex
+      // The last frame has no successor pointer: it runs to the end of file.
+      const start = pointers[index]!
+      const end = index + 1 < total ? pointers[index + 1]! : data.byteLength
+      if (start < FILE_HEADER_SIZE || end > data.byteLength || end < start) {
+        throw new CelError(`frame ${String(index)} extent ${String(start)}..${String(end)} is out of range`)
+      }
+      frames.push(decodeFrame(data, start, end, index))
+    }
+    groups.push({ frames })
+  }
+
+  return { header, groups, width: null }
+}
+
+/**
+ * Decode one frame.
+ *
+ * @param data - the complete file.
+ * @param start - frame start offset.
+ * @param end - frame end offset (exclusive).
+ * @param index - the frame's serial number.
+ * @returns the decoded frame.
+ */
+function decodeFrame(data: Uint8Array, start: number, end: number, index: number): Dc6Frame {
+  if (start + FRAME_HEADER_SIZE > end) {
+    throw new CelError(`frame ${String(index)} is too short for a frame header`)
+  }
+  const width = i32(data, start + 0x04)
+  const height = i32(data, start + 0x08)
+  const offsetX = i32(data, start + 0x0c)
+  const offsetY = i32(data, start + 0x10)
+  const length = u32(data, start + 0x1c)
+  if (width < 0 || height < 0 || width * height > MAX_FRAME_PIXELS) {
+    throw new CelError(`frame ${String(index)} has an implausible size ${String(width)}x${String(height)}`)
+  }
+  const indices = new Uint8Array(width * height)
+  const mask = new Uint8Array(width * height)
+  const streamEnd = Math.min(end, start + FRAME_HEADER_SIZE + length)
+  let cursor = start + FRAME_HEADER_SIZE
+  // Rows land bottom-up: the first scanline written is the frame's last row.
+  let x = 0
+  let y = height - 1
+  let complete = false
+  while (cursor < streamEnd && y >= 0) {
+    const control = data[cursor]!
+    cursor += 1
+    if (control === END_OF_SCANLINE) {
+      if (y === 0) { complete = true; break }
+      y -= 1
+      x = 0
+    } else if ((control & END_OF_SCANLINE) !== 0) {
+      x += control & RUN_LENGTH_MASK
+    } else {
+      if (cursor + control > streamEnd) {
+        throw new CelError(`frame ${String(index)} literal run of ${String(control)} is truncated`)
+      }
+      const rowStart = y * width
+      for (let i = 0; i < control; i += 1) {
+        const at = rowStart + x + i
+        // A run may nominally overrun a short row (padding in the last
+        // scanline); drop those pixels rather than creeping into the next row.
+        if (x + i >= width) break
+        const value = data[cursor + i]!
+        indices[at] = value
+        // Index 0 is the transparent entry by convention.
+        mask[at] = value === 0 ? 0 : 1
+      }
+      cursor += control
+      x += control
+    }
+  }
+  if (!complete) {
+    // The reference decoders stop at the final end-of-scanline; a stream that
+    // ends without one is still usable, so this is reported by leaving the
+    // remaining rows transparent rather than failing the whole sheet.
+    // (Frames with height 1 legitimately end at `y === 0` handled above.)
+  }
+  return { width, height, indices, mask, offsetX, offsetY, index }
+}
+
+/** A decoded frame with its placement fields, as the atlas packer wants it. */
+export type { SpriteGroup }
diff --git a/src/formats/dcc.ts b/src/formats/dcc.ts
new file mode 100644
index 0000000..eac9926
--- /dev/null
+++ b/src/formats/dcc.ts
@@ -0,0 +1,820 @@
+/**
+ * Diablo II `.dcc` sprite decoder.
+ *
+ * A DCC is a *cell-compressed* sprite sheet: instead of storing each frame as a
+ * run stream, the format quantises the art to a 4x4 grid and stores, per frame,
+ * a list of pixel codes per cell plus a flag telling the decoder when a cell is
+ * identical to the same slot in an earlier frame. Decoding therefore happens in
+ * three passes, and the order matters:
+ *
+ * 1. A direction begins with a header declaring the *bit widths* of the
+ *    per-frame header fields (through a small lookup table, because the format's
+ *    authors only needed a dozen widths), then the frame headers, then the table
+ *    describing the direction's padded canvas.
+ * 2. The payload is four independent bit streams layered over each other —
+ *    equal-cell flags, pixel mask, encoding type, raw pixel codes — followed by
+ *    the pixel-code/displacement stream. Their starts are *bit* offsets, not
+ *    byte offsets, so they are read through clones of a single reader whose bit
+ *    position inside a byte is preserved exactly.
+ * 3. Cells are decoded once per (frame, cell) position into a shared pixel
+ *    buffer, then blitted; frames that reuse a cell copy the previous frame's
+ *    pixels instead of carrying their own codes.
+ *
+ * Two conventions this module keeps deliberately:
+ *
+ * - A frame's `frame.width`/`frame.height` is the *direction's* canvas, not the
+ *   frame's own art rectangle. The direction box is the bounding box of every
+ *   frame in that direction, so all frames of a direction share dimensions and
+ *   compositing is a straight overlay. The frame's own rectangle is exposed as
+ *   `width`/`height`/`offsetX`/`offsetY`.
+ * - Palette index 0 is transparent, exactly as in `.dc6`; `mask` records which
+ *   pixels are opaque so a renderer never has to test a sentinel index.
+ *
+ * Frames flagged bottom-up are decoded and then flipped vertically — see
+ * `flipFrameRows`, which documents the one place the reference gives no answer
+ * because it panics instead of implementing the case.
+ */
+import { BitReader } from './bitstream.ts'
+import { CelError } from './sprite.ts'
+import type { SpriteFrame } from './sprite.ts'
+
+/** Every DCC starts with this byte; anything else is mislabelled. */
+const SIGNATURE = 0x74
+/** Direction offsets are stored in bytes but used as bit offsets. */
+const DIRECTION_OFFSET_SCALE = 8
+/** The pixel grid is quantised to 4x4 cells; no cell is larger than 4 pixels. */
+const CELL_SIZE = 4
+/**
+ * Bit widths are not stored literally: the direction header holds a 4-bit index
+ * into this table. It tops out at 32, which bounds every header field.
+ */
+const BIT_WIDTH_TABLE = [0, 1, 2, 4, 6, 8, 10, 12, 14, 16, 20, 24, 26, 28, 30, 32]
+/**
+ * Number of set bits in each 4-bit pixel mask, i.e. how many pixel codes the
+ * cell stores. A mask of 0 means every code was inherited from an earlier frame.
+ */
+const PIXEL_MASK_POPCOUNT = [0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4]
+/** Guard on the declared direction count. */
+const MAX_DIRECTIONS = 256
+/** Guard on the declared frames per direction. */
+const MAX_FRAMES_PER_DIRECTION = 4096
+/** Guard on one direction canvas, in pixels. */
+const MAX_PIXELS = 1 << 24
+
+/** The padded canvas coordinates of a direction or of one frame. */
+export interface DccBox {
+  /** Left edge, in sprite space. */
+  readonly left: number
+  /** Top edge, in sprite space. */
+  readonly top: number
+  /** Width in pixels. */
+  readonly width: number
+  /** Height in pixels. */
+  readonly height: number
+}
+
+/** One decoded frame: its own art rectangle plus the direction-sized canvas. */
+export interface DccFrame {
+  /** The frame's own width, as stored in the header. */
+  readonly width: number
+  /** The frame's own height, as stored in the header. */
+  readonly height: number
+  /** Anchor x of the frame inside the direction canvas. */
+  readonly offsetX: number
+  /** Anchor y of the frame inside the direction canvas. */
+  readonly offsetY: number
+  /** The decoded canvas; its dimensions are the direction's box size. */
+  readonly frame: SpriteFrame
+  /**
+   * Whether the file stored this frame's rows bottom-up, so they were flipped.
+   *
+   * Exposed because the reference implementation refuses this case outright: the
+   * only way to measure how much of a data set depends on the flip judgement is
+   * to count the frames that took that path after decoding.
+   */
+  readonly bottomUp: boolean
+}
+
+/** Every frame of one facing direction, drawn on a shared canvas. */
+export interface DccDirection {
+  /** Bounding box of all frames in this direction. */
+  readonly box: DccBox
+  /** Frames in animation order. */
+  readonly frames: readonly DccFrame[]
+}
+
+/** A decoded DCC file. */
+export interface DccFile {
+  /** Format version byte. */
+  readonly version: number
+  /** Directions, in file order. */
+  readonly directions: readonly DccDirection[]
+}
+
+/** A cell rectangle in direction-canvas coordinates. */
+interface CellRect {
+  width: number
+  height: number
+  xOffset: number
+  yOffset: number
+}
+
+/**
+ * A cell of the direction grid, which additionally remembers the geometry of the
+ * last frame cell that occupied it — the memory that makes equal-cell copying
+ * possible.
+ */
+interface BufferCell extends CellRect {
+  lastWidth: number
+  lastHeight: number
+  lastXOffset: number
+  lastYOffset: number
+}
+
+/** One frame's header fields and its own cell decomposition. */
+interface FrameState {
+  box: DccBox
+  width: number
+  height: number
+  offsetX: number
+  offsetY: number
+  bottomUp: boolean
+  horizontalCellCount: number
+  verticalCellCount: number
+  cells: CellRect[]
+}
+
+/** One entry of the shared pixel buffer: four palette codes plus its owner. */
+interface PixelBufferEntry {
+  value: [number, number, number, number]
+  frame: number
+  cellIndex: number
+}
+
+/** The per-direction decode state, threaded through the three passes. */
+interface DirectionState {
+  box: DccBox
+  frames: FrameState[]
+  cells: BufferCell[]
+  horizontalCellCount: number
+  verticalCellCount: number
+  equalCellsBits: number
+  pixelMaskBits: number
+  encodingTypeBits: number
+  rawPixelBits: number
+}
+
+/** The seven per-frame header field widths a direction declares. */
+interface FieldWidths {
+  variable0: number
+  width: number
+  height: number
+  xOffset: number
+  yOffset: number
+  optionalData: number
+  codedBytes: number
+}
+
+/**
+ * Decode a DCC file.
+ *
+ * @param data - the complete file.
+ * @returns the decoded directions.
+ */
+export function decodeDcc(data: Uint8Array): DccFile {
+  const reader = new BitReader(data, 0)
+  const signature = reader.getByte()
+  if (signature !== SIGNATURE) {
+    throw new CelError(
+      `DCC signature 0x${signature.toString(16)} is not 0x${SIGNATURE.toString(16)} (mislabelled file?)`,
+    )
+  }
+  const version = reader.getByte()
+  const directionCount = reader.getByte()
+  const framesPerDirection = reader.getInt32()
+  const serialised = reader.getInt32()
+  if (serialised !== 1) {
+    throw new CelError(`DCC header word 2 is ${String(serialised)}, the format requires 1`)
+  }
+  reader.getUint32() // total size coded: the per-direction offsets are authoritative
+
+  if (directionCount < 1 || directionCount > MAX_DIRECTIONS) {
+    throw new CelError(`DCC declares ${String(directionCount)} directions (allowed 1..${String(MAX_DIRECTIONS)})`)
+  }
+  if (framesPerDirection < 1 || framesPerDirection > MAX_FRAMES_PER_DIRECTION) {
+    throw new CelError(
+      `DCC declares ${String(framesPerDirection)} frames per direction (allowed 1..${String(MAX_FRAMES_PER_DIRECTION)})`,
+    )
+  }
+
+  const offsets: number[] = []
+  for (let i = 0; i < directionCount; i += 1) {
+    const byteOffset = reader.getInt32()
+    if (byteOffset < 0 || byteOffset * DIRECTION_OFFSET_SCALE >= data.length * 8) {
+      throw new CelError(`DCC direction ${String(i)} offset ${String(byteOffset)} is outside the file`)
+    }
+    offsets.push(byteOffset * DIRECTION_OFFSET_SCALE)
+  }
+
+  const directions: DccDirection[] = []
+  for (let i = 0; i < directionCount; i += 1) {
+    directions.push(decodeDirection(data, offsets[i]!, framesPerDirection, i))
+  }
+
+  return { version, directions }
+}
+
+/**
+ * Decode one direction, translating any raw reader failure into an error that
+ * names the direction.
+ *
+ * @param data - the complete file.
+ * @param bitOffset - the direction's start, in bits.
+ * @param framesPerDirection - the file-level frame count.
+ * @param index - the direction index.
+ * @returns the decoded direction.
+ */
+function decodeDirection(
+  data: Uint8Array,
+  bitOffset: number,
+  framesPerDirection: number,
+  index: number,
+): DccDirection {
+  const where = `DCC direction ${String(index)}`
+  try {
+    return decodeDirectionInner(data, bitOffset, framesPerDirection, where)
+  } catch (err) {
+    throw err instanceof CelError ? err : new CelError(`${where}: ${messageOf(err)}`)
+  }
+}
+
+/**
+ * The direction decode proper: headers, then payload, then cell and frame
+ * assembly, in the order the format requires.
+ *
+ * @param data - the complete file.
+ * @param bitOffset - the direction's start, in bits.
+ * @param framesPerDirection - the file-level frame count.
+ * @param where - error-message prefix.
+ * @returns the decoded direction.
+ */
+function decodeDirectionInner(
+  data: Uint8Array,
+  bitOffset: number,
+  framesPerDirection: number,
+  where: string,
+): DccDirection {
+  const reader = new BitReader(data, bitOffset)
+  reader.getUint32() // out size coded, unused
+  const compressionFlags = reader.getBits(2)
+  const widths: FieldWidths = {
+    variable0: BIT_WIDTH_TABLE[reader.getBits(4)]!,
+    width: BIT_WIDTH_TABLE[reader.getBits(4)]!,
+    height: BIT_WIDTH_TABLE[reader.getBits(4)]!,
+    xOffset: BIT_WIDTH_TABLE[reader.getBits(4)]!,
+    yOffset: BIT_WIDTH_TABLE[reader.getBits(4)]!,
+    optionalData: BIT_WIDTH_TABLE[reader.getBits(4)]!,
+    codedBytes: BIT_WIDTH_TABLE[reader.getBits(4)]!,
+  }
+
+  const frames: FrameState[] = []
+  let minX = Number.MAX_SAFE_INTEGER
+  let minY = Number.MAX_SAFE_INTEGER
+  let maxX = -Number.MAX_SAFE_INTEGER
+  let maxY = -Number.MAX_SAFE_INTEGER
+  for (let i = 0; i < framesPerDirection; i += 1) {
+    const frame = readFrameHeader(reader, widths, i, where)
+    minX = Math.min(minX, frame.box.left)
+    minY = Math.min(minY, frame.box.top)
+    maxX = Math.max(maxX, frame.box.left + frame.box.width)
+    maxY = Math.max(maxY, frame.box.top + frame.box.height)
+    frames.push(frame)
+  }
+  const box: DccBox = { left: minX, top: minY, width: maxX - minX, height: maxY - minY }
+  if (box.width <= 0 || box.height <= 0 || box.width * box.height > MAX_PIXELS) {
+    throw new CelError(`${where}: canvas ${String(box.width)}x${String(box.height)} is implausible`)
+  }
+
+  if (widths.optionalData > 0) {
+    throw new CelError(
+      `${where}: frames declare ${String(widths.optionalData)} bits of optional data, which this decoder does not implement`,
+    )
+  }
+
+  // The declared sizes are *bit* counts. Each stream is walked through a clone
+  // of the reader while the original skips past it, so a stream that starts
+  // mid-byte keeps its bit offset — rounding here would shift every code.
+  const equalCellsBits = (compressionFlags & 0x2) !== 0 ? reader.getBits(20) : 0
+  const pixelMaskBits = reader.getBits(20)
+  const encodingTypeBits = (compressionFlags & 0x1) !== 0 ? reader.getBits(20) : 0
+  const rawPixelBits = (compressionFlags & 0x1) !== 0 ? reader.getBits(20) : 0
+
+  // The palette table is one validity bit per entry; the valid entries are
+  // remapped onto a dense set of codes that the pixel stream then indexes.
+  const palette = new Uint8Array(256)
+  let paletteCount = 0
+  for (let i = 0; i < 256; i += 1) {
+    if (reader.getBit() !== 0) {
+      palette[paletteCount] = i
+      paletteCount += 1
+    }
+  }
+
+  const equalCells = reader.copy()
+  reader.skipBits(equalCellsBits)
+  const pixelMask = reader.copy()
+  reader.skipBits(pixelMaskBits)
+  const encodingType = reader.copy()
+  reader.skipBits(encodingTypeBits)
+  const rawPixelCodes = reader.copy()
+  reader.skipBits(rawPixelBits)
+  const pixelCodes = reader.copy()
+
+  const state: DirectionState = {
+    box,
+    frames,
+    cells: [],
+    horizontalCellCount: 0,
+    verticalCellCount: 0,
+    equalCellsBits,
+    pixelMaskBits,
+    encodingTypeBits,
+    rawPixelBits,
+  }
+
+  calculateCells(state)
+  for (const frame of frames) recalculateCells(state, frame)
+
+  const buffer = fillPixelBuffer(
+    state,
+    palette,
+    pixelCodes,
+    equalCells,
+    pixelMask,
+    encodingType,
+    rawPixelCodes,
+  )
+  const canvases = generateFrames(state, buffer, pixelCodes)
+
+  verifyStream(where, 'equal-cells', equalCells, equalCellsBits)
+  verifyStream(where, 'pixel-mask', pixelMask, pixelMaskBits)
+  verifyStream(where, 'encoding-type', encodingType, encodingTypeBits)
+  verifyStream(where, 'raw-pixel-codes', rawPixelCodes, rawPixelBits)
+
+  const decoded: DccFrame[] = []
+  for (let i = 0; i < frames.length; i += 1) {
+    const frame = frames[i]!
+    const pixels = canvases[i]!
+    if (frame.bottomUp) flipFrameRows(pixels, box, frame.box)
+    decoded.push({
+      width: frame.width,
+      height: frame.height,
+      offsetX: frame.offsetX,
+      offsetY: frame.offsetY,
+      frame: toSpriteFrame(pixels, box.width, box.height),
+      bottomUp: frame.bottomUp,
+    })
+  }
+
+  return { box, frames: decoded }
+}
+
+/**
+ * Read one frame header.
+ *
+ * The box is derived from the anchor: a frame is placed top-down relative to its
+ * `yOffset`, so its top edge sits `height - 1` rows above it. Bottom-up frames
+ * get the same box — the flag describes storage order, not placement, and the
+ * reference computes no alternative — and are flipped after decoding instead.
+ *
+ * @param reader - the direction reader, positioned at the frame header.
+ * @param widths - the direction's declared field widths.
+ * @param index - the frame index.
+ * @param where - error-message prefix.
+ * @returns the frame header fields.
+ */
+function readFrameHeader(reader: BitReader, widths: FieldWidths, index: number, where: string): FrameState {
+  const at = `${where} frame ${String(index)}`
+  reader.getBits(widths.variable0) // per-frame scratch value, never used
+  const width = reader.getBits(widths.width)
+  const height = reader.getBits(widths.height)
+  const offsetX = reader.getSignedBits(widths.xOffset)
+  const offsetY = reader.getSignedBits(widths.yOffset)
+  reader.getBits(widths.optionalData) // must be zero-length; enforced after the frame headers
+  reader.getBits(widths.codedBytes) // coded byte count, only meaningful to the encoder
+  const bottomUp = reader.getBit() === 1
+
+  if (width * height > MAX_PIXELS) {
+    throw new CelError(`${at}: implausible size ${String(width)}x${String(height)}`)
+  }
+  if (width <= 0 || height <= 0) {
+    throw new CelError(`${at}: empty frame ${String(width)}x${String(height)}`)
+  }
+
+  return {
+    box: { left: offsetX, top: offsetY - height + 1, width, height },
+    width,
+    height,
+    offsetX,
+    offsetY,
+    bottomUp,
+    horizontalCellCount: 0,
+    verticalCellCount: 0,
+    cells: [],
+  }
+}
+
+/**
+ * Decompose the direction canvas into the 4x4-aligned cell grid that every frame
+ * cell is addressed against.
+ *
+ * @param state - the direction state, updated in place.
+ */
+function calculateCells(state: DirectionState): void {
+  const { box } = state
+  const horizontal = 1 + Math.trunc((box.width - 1) / CELL_SIZE)
+  const vertical = 1 + Math.trunc((box.height - 1) / CELL_SIZE)
+  state.horizontalCellCount = horizontal
+  state.verticalCellCount = vertical
+
+  const cellWidths = new Array<number>(horizontal).fill(CELL_SIZE)
+  cellWidths[horizontal - 1] = box.width - CELL_SIZE * (horizontal - 1)
+  const cellHeights = new Array<number>(vertical).fill(CELL_SIZE)
+  cellHeights[vertical - 1] = box.height - CELL_SIZE * (vertical - 1)
+
+  const cells: BufferCell[] = []
+  for (let y = 0; y < vertical; y += 1) {
+    for (let x = 0; x < horizontal; x += 1) {
+      cells.push({
+        width: cellWidths[x]!,
+        height: cellHeights[y]!,
+        xOffset: x * CELL_SIZE,
+        yOffset: y * CELL_SIZE,
+        lastWidth: -1,
+        lastHeight: -1,
+        lastXOffset: 0,
+        lastYOffset: 0,
+      })
+    }
+  }
+  state.cells = cells
+}
+
+/**
+ * Decompose one frame into cells aligned to the *direction's* grid.
+ *
+ * A frame's art rectangle generally does not start on the direction's 4-pixel
+ * grid, so the first column and row are truncated to whatever remains of the
+ * cell they begin inside. That is what lets one pixel-buffer slot index serve
+ * every frame in the direction.
+ *
+ * @param state - the direction state.
+ * @param frame - the frame to decompose.
+ */
+function recalculateCells(state: DirectionState, frame: FrameState): void {
+  const { box } = state
+  const firstWidth = CELL_SIZE - ((frame.box.left - box.left) % CELL_SIZE)
+  const firstHeight = CELL_SIZE - ((frame.box.top - box.top) % CELL_SIZE)
+
+  const horizontal = cellSpanCount(frame.width, firstWidth)
+  const vertical = cellSpanCount(frame.height, firstHeight)
+  frame.horizontalCellCount = horizontal
+  frame.verticalCellCount = vertical
+
+  const cellWidths = new Array<number>(horizontal).fill(CELL_SIZE)
+  if (horizontal === 1) {
+    cellWidths[0] = frame.width
+  } else {
+    cellWidths[0] = firstWidth
+    cellWidths[horizontal - 1] = frame.width - firstWidth - CELL_SIZE * (horizontal - 2)
+  }
+  const cellHeights = new Array<number>(vertical).fill(CELL_SIZE)
+  if (vertical === 1) {
+    cellHeights[0] = frame.height
+  } else {
+    cellHeights[0] = firstHeight
+    cellHeights[vertical - 1] = frame.height - firstHeight - CELL_SIZE * (vertical - 2)
+  }
+
+  const cells: CellRect[] = []
+  let yOffset = frame.box.top - box.top
+  for (let y = 0; y < vertical; y += 1) {
+    let xOffset = frame.box.left - box.left
+    for (let x = 0; x < horizontal; x += 1) {
+      cells.push({ width: cellWidths[x]!, height: cellHeights[y]!, xOffset, yOffset })
+      xOffset += cellWidths[x]!
+    }
+    yOffset += cellHeights[y]!
+  }
+  frame.cells = cells
+}
+
+/**
+ * How many cells a span of `total` pixels needs when its first cell is already
+ * `first` pixels wide.
+ *
+ * @param total - the span length.
+ * @param first - the truncated first cell's length.
+ * @returns the cell count.
+ */
+function cellSpanCount(total: number, first: number): number {
+  if (total - first <= 1) return 1
+  const remaining = total - first - 1
+  return 2 + Math.trunc(remaining / CELL_SIZE) - (remaining % CELL_SIZE === 0 ? 1 : 0)
+}
+
+/**
+ * Decode the shared pixel buffer: one entry per (frame, cell) that carries pixel
+ * codes, in stream order.
+ *
+ * Four bit streams drive this pass. For every cell the decoder reads an
+ * equal-cell flag (only when the slot has been touched before), then a 4-bit
+ * mask saying which of the cell's four codes are supplied, then either a raw
+ * 8-bit code or a 4-bit displacement from the previous code, run-length extended
+ * by 15s. A cell flagged equal contributes no entry at all: the frame generator
+ * copies the previous occupant of that grid slot instead.
+ *
+ * @param state - the direction state.
+ * @param palette - the direction's code → palette index table.
+ * @param codes - the pixel-code/displacement stream.
+ * @param equalCells - the equal-cell flag stream.
+ * @param pixelMask - the per-cell mask stream.
+ * @param encodingType - the per-cell encoding selector stream.
+ * @param rawPixelCodes - the raw 8-bit pixel stream.
+ * @returns the buffer, dense from index 0.
+ */
+function fillPixelBuffer(
+  state: DirectionState,
+  palette: Uint8Array,
+  codes: BitReader,
+  equalCells: BitReader,
+  pixelMask: BitReader,
+  encodingType: BitReader,
+  rawPixelCodes: BitReader,
+): PixelBufferEntry[] {
+  let maxCellX = 0
+  let maxCellY = 0
+  for (const frame of state.frames) {
+    maxCellX += frame.horizontalCellCount
+    maxCellY += frame.verticalCellCount
+  }
+  const buffer: PixelBufferEntry[] = new Array<PixelBufferEntry>(maxCellX * maxCellY)
+  for (let i = 0; i < buffer.length; i += 1) {
+    buffer[i] = { value: [0, 0, 0, 0], frame: -1, cellIndex: -1 }
+  }
+  const slots = new Array<PixelBufferEntry | null>(state.horizontalCellCount * state.verticalCellCount)
+  slots.fill(null)
+
+  let entryIndex = -1
+  for (let frameIndex = 0; frameIndex < state.frames.length; frameIndex += 1) {
+    const frame = state.frames[frameIndex]!
+    const originCellX = Math.trunc((frame.box.left - state.box.left) / CELL_SIZE)
+    const originCellY = Math.trunc((frame.box.top - state.box.top) / CELL_SIZE)
+
+    for (let cellY = 0; cellY < frame.verticalCellCount; cellY += 1) {
+      const gridY = cellY + originCellY
+      for (let cellX = 0; cellX < frame.horizontalCellCount; cellX += 1) {
+        const gridCell = originCellX + cellX + gridY * state.horizontalCellCount
+        const previous = slots[gridCell]!
+        let mask: number
+        if (previous === null) {
+          mask = 0xf // nothing to inherit from, so every code is supplied
+        } else {
+          if (state.equalCellsBits > 0 && equalCells.getBit() !== 0) continue // repeats: no entry
+          mask = pixelMask.getBits(4)
+        }
+
+        let lastPixel = 0
+        const pixelStack: [number, number, number, number] = [0, 0, 0, 0]
+        const pixelCount = PIXEL_MASK_POPCOUNT[mask]!
+        const encoded = pixelCount !== 0 && state.encodingTypeBits > 0 ? encodingType.getBit() : 0
+        let decoded = 0
+        for (let i = 0; i < pixelCount; i += 1) {
+          let value: number
+          if (encoded !== 0) {
+            value = rawPixelCodes.getBits(8)
+          } else {
+            let displacement = codes.getBits(4)
+            value = lastPixel + displacement
+            while (displacement === 15) {
+              displacement = codes.getBits(4)
+              value += displacement
+            }
+          }
+          if (value === lastPixel) {
+            pixelStack[i] = 0 // zero displacement means "nothing here", ending the run
+            break
+          }
+          pixelStack[i] = value
+          lastPixel = value
+          decoded += 1
+        }
+
+        entryIndex += 1
+        const entry = buffer[entryIndex]
+        if (entry === undefined) {
+          throw new CelError(
+            `pixel buffer overflow at grid cell ${String(gridCell)} (capacity ${String(buffer.length)})`,
+          )
+        }
+        // Codes are stored reversed: the last decoded code belongs to the cell's
+        // first pixel, and the mask's lowest set bit picks the next in line.
+        let code = decoded - 1
+        for (let i = 0; i < CELL_SIZE; i += 1) {
+          if ((mask & (1 << i)) !== 0) {
+            entry.value[i] = code >= 0 ? pixelStack[code]! & 0xff : 0
+            code -= 1
+          } else {
+            entry.value[i] = previous === null ? 0 : previous.value[i]!
+          }
+        }
+        slots[gridCell] = entry
+        entry.frame = frameIndex
+        entry.cellIndex = cellX + cellY * frame.horizontalCellCount
+      }
+    }
+  }
+
+  // Buffer values are indices into the direction's dense palette table, not
+  // palette entries; resolve them once so the frame pass can use them directly.
+  for (let i = 0; i <= entryIndex; i += 1) {
+    const entry = buffer[i]!
+    for (let x = 0; x < CELL_SIZE; x += 1) entry.value[x] = palette[entry.value[x]!]!
+  }
+
+  return buffer
+}
+
+/**
+ * Blit the pixel buffer into one canvas per frame.
+ *
+ * Each (frame, cell) either consumes the next buffer entry — writing it into a
+ * shared scratch canvas, then copying it into that frame's canvas — or, when the
+ * next entry belongs to another frame, reproduces the previous occupant of the
+ * slot: by copying its pixels when the geometry matches, or by leaving the slot
+ * transparent when it does not, since the old pixels would not fit.
+ *
+ * @param state - the direction state.
+ * @param buffer - the pixel buffer from `fillPixelBuffer`.
+ * @param codes - the pixel-code stream, still positioned after the buffer pass.
+ * @returns one canvas per frame, direction-box sized.
+ */
+function generateFrames(state: DirectionState, buffer: PixelBufferEntry[], codes: BitReader): Uint8Array[] {
+  const stride = state.box.width
+  const scratch = new Uint8Array(stride * state.box.height)
+  for (const cell of state.cells) {
+    cell.lastWidth = -1
+    cell.lastHeight = -1
+  }
+
+  const canvases: Uint8Array[] = []
+  let entryIndex = 0
+  for (let frameIndex = 0; frameIndex < state.frames.length; frameIndex += 1) {
+    const frame = state.frames[frameIndex]!
+    const canvas = new Uint8Array(stride * state.box.height)
+    for (let c = 0; c < frame.cells.length; c += 1) {
+      const cell = frame.cells[c]!
+      const gridX = Math.trunc(cell.xOffset / CELL_SIZE)
+      const gridY = Math.trunc(cell.yOffset / CELL_SIZE)
+      const slot = state.cells[gridX + gridY * state.horizontalCellCount]!
+      const entry = buffer[entryIndex]
+      if (entry === undefined) {
+        throw new CelError(`frame ${String(frameIndex)} cell ${String(c)}: pixel buffer underrun`)
+      }
+
+      if (entry.frame !== frameIndex || entry.cellIndex !== c) {
+        if (cell.width !== slot.lastWidth || cell.height !== slot.lastHeight) {
+          // The previous occupant had a different shape, so only the scratch
+          // canvas can be cleared; this frame's cell stays transparent.
+          for (let y = 0; y < cell.height; y += 1) {
+            const row = cell.xOffset + (y + cell.yOffset) * stride
+            for (let x = 0; x < cell.width; x += 1) scratch[row + x] = 0
+          }
+        } else {
+          for (let y = 0; y < cell.height; y += 1) {
+            const from = slot.lastXOffset + (y + slot.lastYOffset) * stride
+            const to = cell.xOffset + (y + cell.yOffset) * stride
+            for (let x = 0; x < cell.width; x += 1) scratch[to + x] = scratch[from + x]!
+          }
+          blit(scratch, canvas, cell, stride)
+        }
+      } else {
+        if (entry.value[0] === entry.value[1]) {
+          // One flat colour for the whole cell, so no per-pixel codes follow.
+          for (let y = 0; y < cell.height; y += 1) {
+            const row = cell.xOffset + (y + cell.yOffset) * stride
+            for (let x = 0; x < cell.width; x += 1) scratch[row + x] = entry.value[0]!
+          }
+        } else {
+          // One bit per pixel when only two codes survive, two bits when there
+          // are three or four (the fourth is the "nothing here" code).
+          const bits = entry.value[1] !== entry.value[2] ? 2 : 1
+          for (let y = 0; y < cell.height; y += 1) {
+            const row = cell.xOffset + (y + cell.yOffset) * stride
+            for (let x = 0; x < cell.width; x += 1) scratch[row + x] = entry.value[codes.getBits(bits)]!
+          }
+        }
+        blit(scratch, canvas, cell, stride)
+        entryIndex += 1
+      }
+
+      slot.lastWidth = cell.width
+      slot.lastHeight = cell.height
+      slot.lastXOffset = cell.xOffset
+      slot.lastYOffset = cell.yOffset
+    }
+    canvases.push(canvas)
+  }
+  return canvases
+}
+
+/**
+ * Copy one cell rectangle from the scratch canvas into a frame canvas.
+ *
+ * @param from - the scratch canvas.
+ * @param to - the frame canvas.
+ * @param cell - the cell rectangle.
+ * @param stride - canvas width in pixels.
+ */
+function blit(from: Uint8Array, to: Uint8Array, cell: CellRect, stride: number): void {
+  for (let y = 0; y < cell.height; y += 1) {
+    const row = cell.xOffset + (y + cell.yOffset) * stride
+    for (let x = 0; x < cell.width; x += 1) to[row + x] = from[row + x]!
+  }
+}
+
+/**
+ * Flip a frame's pixel rows inside the direction canvas.
+ *
+ * The reference implementation panics with "bottom up frames are not
+ * implemented", so this path has no second opinion to check it against. The
+ * flag's documented meaning is that the frame's pixel rows are stored
+ * bottom-up, so the frame's own art rectangle — not the whole direction canvas —
+ * is mirrored about its horizontal centre line, with the box computed exactly as
+ * for a top-down frame. Decoding never *skips* such a frame: the only cost of
+ * getting the interpretation wrong is a vertically mirrored frame, which is why
+ * the flag is also exposed on the decoded frame for counting.
+ *
+ * @param pixels - the direction-sized canvas, modified in place.
+ * @param directionBox - the direction's box, for offsetting the frame rectangle.
+ * @param frameBox - the frame's rectangle.
+ */
+function flipFrameRows(pixels: Uint8Array, directionBox: DccBox, frameBox: DccBox): void {
+  const top = frameBox.top - directionBox.top
+  const left = frameBox.left - directionBox.left
+  for (let y = 0; y < Math.trunc(frameBox.height / 2); y += 1) {
+    const upper = (top + y) * directionBox.width + left
+    const lower = (top + frameBox.height - 1 - y) * directionBox.width + left
+    for (let x = 0; x < frameBox.width; x += 1) {
+      const swap = pixels[upper + x]!
+      pixels[upper + x] = pixels[lower + x]!
+      pixels[lower + x] = swap
+    }
+  }
+}
+
+/**
+ * Wrap a decoded canvas in the project's palette-indexed sprite shape, tagging
+ * index 0 as transparent the same way the DC6 decoder does.
+ *
+ * @param pixels - the canvas, which becomes the index buffer.
+ * @param width - canvas width.
+ * @param height - canvas height.
+ * @returns the sprite frame.
+ */
+function toSpriteFrame(pixels: Uint8Array, width: number, height: number): SpriteFrame {
+  const mask = new Uint8Array(pixels.length)
+  for (let i = 0; i < pixels.length; i += 1) mask[i] = pixels[i] === 0 ? 0 : 1
+  return { width, height, indices: pixels, mask }
+}
+
+/**
+ * Assert a sub-stream was consumed exactly to its declared bit length.
+ *
+ * This is the format's own consistency check: the declared sizes and the actual
+ * content have to agree, and a mismatch means the decode drifted, which would
+ * otherwise surface only as a subtly wrong sprite.
+ *
+ * @param where - error-message prefix.
+ * @param name - the stream name.
+ * @param reader - the sub-stream reader.
+ * @param declared - the declared bit length.
+ */
+function verifyStream(where: string, name: string, reader: BitReader, declared: number): void {
+  const consumed = reader.bitsRead()
+  if (consumed !== declared) {
+    throw new CelError(
+      `${where}: ${name} stream consumed ${String(consumed)} bits, header declares ${String(declared)}`,
+    )
+  }
+}
+
+/**
+ * Extract a message from an unknown thrown value.
+ *
+ * @param err - the thrown value.
+ * @returns the message.
+ */
+function messageOf(err: unknown): string {
+  return err instanceof Error ? err.message : String(err)
+}
diff --git a/src/formats/ds1.ts b/src/formats/ds1.ts
new file mode 100644
index 0000000..a122898
--- /dev/null
+++ b/src/formats/ds1.ts
@@ -0,0 +1,413 @@
+/**
+ * Diablo II `.ds1` map decoder.
+ *
+ * A DS1 is a map *layout*: a grid of tiles, each slot holding one reference per
+ * layer (four wall layers, four orientation layers, two floor layers, a shadow
+ * layer and a substitution layer, depending on the version). A reference is
+ * only `(style, sequence)` into a DT1 library — the pixels come from there —
+ * so DS1 and DT1 are useless apart and are decoded as a pair.
+ *
+ * The file is a versioned sequence of optional sections, which is the whole
+ * difficulty: which fields exist depends on a version number, and the layer
+ * streams are interleaved in a fixed order that also has a legacy shape for
+ * versions below 4. Both are encoded here exactly as the reference decoder
+ * reads them, including the pre-7 orientation lookup table.
+ */
+import { CelError } from './sprite.ts'
+
+/** Pre-7 maps store orientations through this lookup rather than directly. */
+const LEGACY_DIRECTION_LOOKUP = [
+  0x00, 0x01, 0x02, 0x01, 0x02, 0x03, 0x03, 0x05, 0x05, 0x06,
+  0x06, 0x07, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
+  0x0f, 0x10, 0x11, 0x12, 0x14,
+] as const
+
+/** Version at which the act field exists. */
+const V_ACT = 8
+/** Version at which the substitution type exists. */
+const V_SUBSTITUTION_LAYERS = 10
+/** Version at which the embedded file list exists. */
+const V_FILES = 3
+/** Versions 9..13 carry eight unknown bytes. */
+const V_UNKNOWN_LOW = 9
+const V_UNKNOWN_HIGH = 13
+/** Version at which floor layers exist (below it there is exactly one). */
+const V_FLOORS = 4
+/** Version at which wall layers exist. */
+const V_WALLS = 16
+/** Version at which NPC paths exist. */
+const V_NPCS = 14
+/** Below this version the orientation field goes through the lookup. */
+const V_DIRECT_ORIENTATION = 7
+
+/** One wall cell: a tile reference plus the wall's own fields. */
+export interface Ds1Wall {
+  /** Palette/tile property byte. */
+  readonly prop1: number
+  /** Sequence within the style (0..63). */
+  readonly sequence: number
+  /** Style index within the DT1 library. */
+  readonly style: number
+  /** Orientation index (a DT1 `direction`). */
+  readonly type: number
+  /** Unnamed field, as stored. */
+  readonly unknown1: number
+  /** Unnamed field, as stored. */
+  readonly unknown2: number
+  /** The cell is hidden. */
+  readonly hidden: boolean
+}
+
+/** One floor or shadow cell. */
+export interface Ds1Floor {
+  /** Palette/tile property byte. */
+  readonly prop1: number
+  /** Sequence within the style (0..63). */
+  readonly sequence: number
+  /** Style index within the DT1 library. */
+  readonly style: number
+  /** Unnamed field, as stored. */
+  readonly unknown1: number
+  /** Unnamed field, as stored. */
+  readonly unknown2: number
+  /** The cell is hidden. */
+  readonly hidden: boolean
+}
+
+/** One substitution cell (raw value; its meaning is map-specific). */
+export interface Ds1Substitution {
+  /** The raw 32-bit layer value. */
+  readonly value: number
+}
+
+/** Everything one map cell carries. */
+export interface Ds1Cell {
+  /** Wall layers, outermost first. */
+  readonly walls: readonly Ds1Wall[]
+  /** Floor layers, one per declared floor layer. */
+  readonly floors: readonly Ds1Floor[]
+  /** Shadow layers (one in shipped maps). */
+  readonly shadows: readonly Ds1Floor[]
+  /** Substitution layers. */
+  readonly substitutions: readonly Ds1Substitution[]
+}
+
+/** One placed object (a door, a shrine, a chest, ...). */
+export interface Ds1Object {
+  /** Object type index into the act's object table. */
+  readonly type: number
+  /** Object id (the specific variant). */
+  readonly id: number
+  /** Tile x. */
+  readonly x: number
+  /** Tile y. */
+  readonly y: number
+  /** Raw flags word. */
+  readonly flags: number
+}
+
+/** A decoded DS1 map. */
+export interface Ds1 {
+  /** File version. */
+  readonly version: number
+  /** Map width in tiles. */
+  readonly width: number
+  /** Map height in tiles. */
+  readonly height: number
+  /** Act (1..5). */
+  readonly act: number
+  /** Substitution layer type (0, 1 or 2). */
+  readonly substitutionType: number
+  /** Number of wall layers. */
+  readonly wallLayers: number
+  /** Number of floor layers. */
+  readonly floorLayers: number
+  /** Cells, row-major: `cells[y][x]`. */
+  readonly cells: readonly (readonly Ds1Cell[])[]
+  /** Placed objects. */
+  readonly objects: readonly Ds1Object[]
+  /** Byte offset where NPC paths begin (not decoded). */
+  readonly npcPathOffset: number | null
+}
+
+/** A cursor over the file, so the versioned section walk reads linearly. */
+class Cursor {
+  private at = 0
+  private readonly data: Uint8Array
+
+  /**
+   * @param data - the buffer to walk.
+   */
+  constructor(data: Uint8Array) {
+    this.data = data
+  }
+
+  /** Current byte offset. */
+  get offset(): number { return this.at }
+
+  /**
+   * Read `count` bytes and advance.
+   *
+   * @param count - byte count.
+   * @returns the bytes.
+   */
+  take(count: number): Uint8Array {
+    if (count < 0 || this.at + count > this.data.byteLength) {
+      throw new CelError(`DS1 section runs past the file end at offset ${String(this.at)}`)
+    }
+    const slice = this.data.subarray(this.at, this.at + count)
+    this.at += count
+    return slice
+  }
+
+  /**
+   * Read a little-endian int32 and advance.
+   *
+   * @returns the value.
+   */
+  int32(): number {
+    const bytes = this.take(4)
+    return (bytes[0]! | (bytes[1]! << 8) | (bytes[2]! << 16) | (bytes[3]! << 24)) | 0
+  }
+
+  /**
+   * Read a little-endian uint32 and advance.
+   *
+   * @returns the value.
+   */
+  uint32(): number {
+    const bytes = this.take(4)
+    return (bytes[0]! | (bytes[1]! << 8) | (bytes[2]! << 16) | (bytes[3]! << 24)) >>> 0
+  }
+
+  /**
+   * Read a NUL-terminated ASCII string and advance.
+   *
+   * @returns the string.
+   */
+  cstring(): string {
+    let out = ''
+    for (;;) {
+      const byte = this.take(1)[0]!
+      if (byte === 0) return out
+      out += String.fromCharCode(byte)
+    }
+  }
+}
+
+/**
+ * Decode a DS1 map.
+ *
+ * @param data - the complete file.
+ * @returns the decoded map.
+ */
+export function decodeDs1(data: Uint8Array): Ds1 {
+  if (data.byteLength < 12) throw new CelError(`DS1 is ${String(data.byteLength)} bytes, too short for a header`)
+  const cursor = new Cursor(data)
+  const version = cursor.int32()
+  // Stored width/height are one less than the tile count.
+  const width = cursor.int32() + 1
+  const height = cursor.int32() + 1
+  if (width <= 0 || height <= 0 || width * height > (1 << 22)) {
+    throw new CelError(`DS1 declares an implausible size ${String(width)}x${String(height)}`)
+  }
+
+  let act = 1
+  if (version >= V_ACT) act = cursor.int32()
+
+  let substitutionType = 0
+  let substitutionLayers = 0
+  if (version >= V_SUBSTITUTION_LAYERS) {
+    substitutionType = cursor.int32()
+    if (substitutionType === 1 || substitutionType === 2) substitutionLayers = 1
+  }
+
+  const files: string[] = []
+  if (version >= V_FILES) {
+    const count = cursor.int32()
+    if (count < 0 || count > 1024) throw new CelError(`DS1 declares ${String(count)} embedded file names`)
+    for (let index = 0; index < count; index += 1) files.push(cursor.cstring())
+  }
+
+  if (version >= V_UNKNOWN_LOW && version <= V_UNKNOWN_HIGH) cursor.take(8)
+
+  let wallLayers = 0
+  let floorLayers = 0
+  if (version >= V_FLOORS) {
+    wallLayers = cursor.int32()
+    if (version >= V_WALLS) floorLayers = cursor.int32()
+    else floorLayers = 1
+  }
+  if (wallLayers < 0 || wallLayers > 4 || floorLayers < 0 || floorLayers > 2) {
+    throw new CelError(`DS1 declares ${String(wallLayers)} wall and ${String(floorLayers)} floor layers`)
+  }
+  const shadowLayers = 1
+
+  const cells: Ds1Cell[][] = []
+  for (let y = 0; y < height; y += 1) {
+    const row: Ds1Cell[] = []
+    for (let x = 0; x < width; x += 1) {
+      row.push({
+        walls: Array.from({ length: wallLayers }, () => emptyWall()),
+        floors: Array.from({ length: floorLayers }, () => emptyFloor()),
+        shadows: Array.from({ length: shadowLayers }, () => emptyFloor()),
+        substitutions: Array.from({ length: substitutionLayers }, () => ({ value: 0 })),
+      })
+    }
+    cells.push(row)
+  }
+
+  for (const layer of layerOrder(version, wallLayers, floorLayers, shadowLayers, substitutionLayers)) {
+    for (let y = 0; y < height; y += 1) {
+      const row = cells[y]!
+      for (let x = 0; x < width; x += 1) {
+        const bits = cursor.uint32()
+        applyLayer(row[x]!, layer, bits, version)
+      }
+    }
+  }
+
+  const objects: Ds1Object[] = []
+  if (version >= 2) {
+    const count = cursor.int32()
+    if (count < 0 || count > (1 << 20)) throw new CelError(`DS1 declares ${String(count)} objects`)
+    for (let index = 0; index < count; index += 1) {
+      objects.push({
+        type: cursor.int32(),
+        id: cursor.int32(),
+        x: cursor.int32(),
+        y: cursor.int32(),
+        flags: cursor.int32(),
+      })
+    }
+  }
+
+  // Substitution groups, NPC paths and NPC extra data follow; they are not
+  // needed to draw or walk a map, so their offset is recorded instead of being
+  // guessed at.
+  const npcPathOffset = version >= V_NPCS ? cursor.offset : null
+
+  return {
+    version, width, height, act, substitutionType,
+    wallLayers, floorLayers, cells, objects, npcPathOffset,
+  }
+}
+
+/** A blank wall cell. */
+function emptyWall(): Ds1Wall {
+  return { prop1: 0, sequence: 0, style: 0, type: 0, unknown1: 0, unknown2: 0, hidden: false }
+}
+
+/** A blank floor/shadow cell. */
+function emptyFloor(): Ds1Floor {
+  return { prop1: 0, sequence: 0, style: 0, unknown1: 0, unknown2: 0, hidden: false }
+}
+
+/** Wall layer indices, matching the file's fixed order. */
+const WALL_LAYERS = [0, 1, 2, 3] as const
+/** Floor layer indices. */
+const FLOOR_LAYERS = [0, 1] as const
+
+/**
+ * The order the layer streams appear in the file.
+ *
+ * Below version 4 every type had exactly one layer and the streams follow a
+ * legacy order; from 4 on, wall and orientation layers alternate per wall
+ * layer, then floors, then shadow, then substitutions.
+ *
+ * @param version - file version.
+ * @param wallLayers - declared wall layers.
+ * @param floorLayers - declared floor layers.
+ * @param shadowLayers - shadow layers.
+ * @param substitutionLayers - substitution layers.
+ * @returns the layer stream descriptors in file order.
+ */
+function layerOrder(
+  version: number,
+  wallLayers: number,
+  floorLayers: number,
+  shadowLayers: number,
+  substitutionLayers: number,
+): { kind: 'wall' | 'orientation' | 'floor' | 'shadow' | 'substitution'; index: number }[] {
+  if (version < V_FLOORS) {
+    return [
+      { kind: 'wall', index: 0 },
+      { kind: 'floor', index: 0 },
+      { kind: 'orientation', index: 0 },
+      { kind: 'substitution', index: 0 },
+      { kind: 'shadow', index: 0 },
+    ]
+  }
+  const order: { kind: 'wall' | 'orientation' | 'floor' | 'shadow' | 'substitution'; index: number }[] = []
+  for (let index = 0; index < wallLayers; index += 1) {
+    order.push({ kind: 'wall', index }, { kind: 'orientation', index })
+  }
+  for (let index = 0; index < floorLayers; index += 1) order.push({ kind: 'floor', index })
+  for (let index = 0; index < shadowLayers; index += 1) order.push({ kind: 'shadow', index })
+  for (let index = 0; index < substitutionLayers; index += 1) order.push({ kind: 'substitution', index })
+  return order
+}
+
+/**
+ * Apply one 32-bit layer value to its cell.
+ *
+ * Cells are small mutable records for exactly this reason: the layer streams
+ * arrive interleaved, so a cell is assembled from several passes.
+ *
+ * @param cell - the cell to update.
+ * @param layer - which layer this value belongs to.
+ * @param bits - the raw 32-bit value.
+ * @param version - file version (older maps fold orientations).
+ */
+function applyLayer(
+  cell: Ds1Cell,
+  layer: { kind: 'wall' | 'orientation' | 'floor' | 'shadow' | 'substitution'; index: number },
+  bits: number,
+  version: number,
+): void {
+  const prop1 = bits & 0x000000ff
+  const sequence = (bits & 0x00003f00) >>> 8
+  const unknown1 = (bits & 0x000fc000) >>> 14
+  const style = (bits & 0x03f00000) >>> 20
+  const unknown2 = (bits & 0x7c000000) >>> 26
+  const hidden = ((bits & 0x80000000) >>> 31) > 0
+  switch (layer.kind) {
+    case 'wall': {
+      const wall = cell.walls[layer.index]
+      if (wall === undefined) return
+      // Walls are mutable during assembly; the exported type is read-only.
+      Object.assign(wall, { prop1, sequence, unknown1, style, unknown2, hidden })
+      return
+    }
+    case 'orientation': {
+      const wall = cell.walls[layer.index]
+      if (wall === undefined) return
+      let type = bits & 0x000000ff
+      if (version < V_DIRECT_ORIENTATION && type < LEGACY_DIRECTION_LOOKUP.length) {
+        type = LEGACY_DIRECTION_LOOKUP[type]!
+      }
+      Object.assign(wall, { type })
+      return
+    }
+    case 'floor': {
+      const floor = cell.floors[layer.index]
+      if (floor !== undefined) Object.assign(floor, { prop1, sequence, unknown1, style, unknown2, hidden })
+      return
+    }
+    case 'shadow': {
+      const shadow = cell.shadows[layer.index]
+      if (shadow !== undefined) Object.assign(shadow, { prop1, sequence, unknown1, style, unknown2, hidden })
+      return
+    }
+    case 'substitution': {
+      const substitution = cell.substitutions[layer.index]
+      if (substitution !== undefined) Object.assign(substitution, { value: bits })
+      return
+    }
+    /* v8 ignore next -- the layer union is closed above. */
+    default: return
+  }
+}
+
+/** Reserved for the DT1 pairing helpers that follow in the renderer. */
+export { WALL_LAYERS, FLOOR_LAYERS }
diff --git a/src/formats/dt1.ts b/src/formats/dt1.ts
new file mode 100644
index 0000000..9a550bd
--- /dev/null
+++ b/src/formats/dt1.ts
@@ -0,0 +1,515 @@
+/**
+ * Diablo II `.dt1` tile decoder.
+ *
+ * A DT1 is the tile library a DS1 map references: every tile carries a
+ * 96-byte record (size, orientation, material, 25 sub-tile collision flags)
+ * and a list of 20-byte block headers pointing at pixel data. Two block
+ * encodings exist and both are implemented here:
+ *
+ * - **RLE (format 0)**: a stream of `(skip, count)` byte pairs. `skip` advances
+ *   the column cursor, `count` literal indices follow, and the pair `(0, 0)`
+ *   ends the row. Rows advance downward; unlike DC6 there is no bottom-up
+ *   reversal.
+ * - **Isometric (format 1)**: exactly 256 bytes laid onto the diamond of a
+ *   32-wide tile through the fixed `xjump`/`nbpix` tables below — 15 rows of
+ *   increasing then decreasing run length. Nothing in the file describes those
+ *   tables; they are part of the format.
+ *
+ * Collision lives in the sub-tile flags (a 5×5 grid per tile), which is what
+ * makes a walkable map possible without any extra data.
+ */
+import { CelError } from './sprite.ts'
+
+/** Bytes of the fixed header before the tile count. */
+const HEADER_PREFIX = 8
+/** Bytes of unknown data between the version and the tile count. */
+const HEADER_UNKNOWN = 260
+/** Bytes per tile record. */
+const TILE_RECORD_SIZE = 96
+/** Pixel height of one block's covered area, used to size tile bitmaps. */
+const BLOCK_PIXEL_HEIGHT = 32
+/** Bytes per block header. */
+const BLOCK_HEADER_SIZE = 20
+/** Sub-tile grid edge (5×5 collision flags per tile). */
+const SUB_TILE_GRID = 5
+/** Bytes of one isometric block. */
+const ISOMETRIC_BLOCK_SIZE = 256
+/** Row offsets of the isometric diamond, one entry per row. */
+const ISO_JUMP = [14, 12, 10, 8, 6, 4, 2, 0, 2, 4, 6, 8, 10, 12, 14] as const
+/** Row run lengths of the isometric diamond, one entry per row. */
+const ISO_RUN = [4, 8, 12, 16, 20, 24, 28, 32, 28, 24, 20, 16, 12, 8, 4] as const
+
+/** A tile's collision flags, decoded from one of its 25 sub-tile bytes. */
+export interface SubTileFlags {
+  /** Blocks walking (all units). */
+  readonly blockWalk: boolean
+  /** Blocks line of sight. */
+  readonly blockLos: boolean
+  /** Blocks jumping/leaping. */
+  readonly blockJump: boolean
+  /** Blocks the player specifically (but not monsters). */
+  readonly blockPlayerWalk: boolean
+  /** Blocks light. */
+  readonly blockLight: boolean
+  /** Raw byte, for the bits that are not named. */
+  readonly raw: number
+}
+
+/** One block of a tile: its placement inside the tile and its pixels. */
+export interface Dt1Block {
+  /** Destination x within the tile. */
+  readonly x: number
+  /** Destination y within the tile. */
+  readonly y: number
+  /** Block grid position, as stored. */
+  readonly gridX: number
+  /** Block grid position, as stored. */
+  readonly gridY: number
+  /** Encoding: 0 run-length, 1 isometric. */
+  readonly format: number
+  /** Palette indices, laid out at tile size (tile width × |tile height|). */
+  readonly pixels: Uint8Array
+}
+
+/** A block header as stored (20 bytes). */
+interface BlockHeader {
+  /** Destination x within the tile. */
+  readonly x: number
+  /** Destination y within the tile. */
+  readonly y: number
+  /** Sub-tile grid column (floor tiles only). */
+  readonly gridX: number
+  /** Sub-tile grid row (floor tiles only). */
+  readonly gridY: number
+  /** Encoding: 0 run-length, 1 isometric. */
+  readonly format: number
+  /** Encoded byte count. */
+  readonly length: number
+  /** Offset of the encoded data, as stored. */
+  readonly fileOffset: number
+  /** Offset of the block header that carries it. */
+  readonly headerOffset: number
+}
+
+/**
+ * Resolve where a block's encoded bytes actually live.
+ *
+ * The community format documentation calls the field "offset in file", while the
+ * working reference implementation reads it relative to the block header. Both
+ * readings occur in the wild, so the decoder tries the reference's reading
+ * first and falls back to the absolute one when that range is unusable — and a
+ * file that satisfies neither is reported rather than decoded into noise.
+ *
+ * @param data - the complete file.
+ * @param block - the block header.
+ * @returns the absolute offset of the encoded data.
+ */
+function resolveBlockDataOffset(data: Uint8Array, block: BlockHeader): number[] {
+  const relative = block.headerOffset + block.fileOffset
+  const absolute = block.fileOffset
+  const fits = (offset: number): boolean =>
+    offset >= 0 && offset + block.length <= data.byteLength && block.length >= 0
+  const candidates = [relative, absolute].filter((offset, index, all) => fits(offset) && all.indexOf(offset) === index)
+  if (candidates.length === 0) {
+    throw new CelError(
+      `block data at ${String(relative)} (relative) or ${String(absolute)} (absolute) does not fit the file`,
+    )
+  }
+  return candidates
+}
+
+/** One tile of the library. */
+export interface Dt1Tile {
+  /** Orientation/direction index. */
+  readonly direction: number
+  /** Tile height, negative for roofs. */
+  readonly height: number
+  /** Tile width. */
+  readonly width: number
+  /** Tile type (the `type` half of a DS1 tile reference). */
+  readonly type: number
+  /** Tile style (the `style` half of a DS1 tile reference). */
+  readonly style: number
+  /** Sequence within the style. */
+  readonly sequence: number
+  /** Material bit field (water, wood, stone, ...). */
+  readonly materialFlags: number
+  /**
+   * Roof height, at file offset +4.
+   *
+   * OpenDiablo2 reads this field and uses it for one thing: a roof tile's
+   * `YAdjust` is `-roofHeight` instead of `minBlockY + 80`
+   * (`d2maprenderer/tile_cache.go`). Kept here so the roof layer can be drawn
+   * with the engine's own offset when it is wired up.
+   */
+  readonly roofHeight: number
+  /**
+   * Variant weight inside one `style:sequence` group, at file offset +32.
+   *
+   * A DT1 ships several tiles for the same `style`/`sequence` and the engine
+   * picks one **per cell** by weighted random using this field as the weight
+   * (OpenDiablo2 `getRandomTile`, seeded from the map seed and the cell's x/y).
+   * Without it every cell of a floor would draw the same variant.
+   */
+  readonly rarityFrameIndex: number
+  /** 25 sub-tile collision flag sets, row-major on a 5×5 grid. */
+  readonly subTileFlags: readonly SubTileFlags[]
+  /**
+   * Most negative block `y` in this tile.
+   *
+   * Blocks are placed with this shift applied (see {@link Dt1Tile.blocks}), and
+   * the value is also what Diablo II's renderer adds to a wall's cell position
+   * (`YAdjust = minBlockY + 80`): a wall whose art extends above its cell must
+   * be pushed back down by exactly the amount the art was shifted. Floors ignore
+   * it, which is why only walls look wrong when it is dropped.
+   */
+  readonly minBlockY: number
+  /**
+   * Height of the decoded bitmap, in pixels.
+   *
+   * Usually `|height|`, but a wall's art can legitimately extend past the
+   * declared height (the reference renderer allocates
+   * `max(|height|, maxBlockY + 32 - minBlockY)` for exactly this reason). Using
+   * the declared height alone clips those tiles — two references in Act 5's town
+   * hit that case.
+   */
+  readonly bitmapHeight: number
+  /** The tile's blocks, in file order. */
+  readonly blocks: readonly Dt1Block[]
+}
+
+/** A decoded DT1 file. */
+export interface Dt1 {
+  /**
+   * Structural surprises that did not prevent decoding (empty for a
+   * well-formed library). Real Blizzard files are expected to leave this empty;
+   * a non-empty list means a field's meaning differs from the documented one.
+   */
+  readonly warnings: readonly string[]
+  /** Major version, as stored (7 for shipped files). */
+  readonly versionMajor: number
+  /** Minor version, as stored (6 for shipped files). */
+  readonly versionMinor: number
+  /** The tile library. */
+  readonly tiles: readonly Dt1Tile[]
+}
+
+/**
+ * Read a little-endian uint32.
+ *
+ * @param data - the buffer.
+ * @param at - byte offset.
+ * @returns the value.
+ */
+function u32(data: Uint8Array, at: number): number {
+  return (data[at]! | (data[at + 1]! << 8) | (data[at + 2]! << 16) | (data[at + 3]! << 24)) >>> 0
+}
+
+/**
+ * Read a little-endian int32.
+ *
+ * @param data - the buffer.
+ * @param at - byte offset.
+ * @returns the value.
+ */
+function i32(data: Uint8Array, at: number): number {
+  return u32(data, at) | 0
+}
+
+/**
+ * Read a little-endian uint16.
+ *
+ * @param data - the buffer.
+ * @param at - byte offset.
+ * @returns the value.
+ */
+function u16(data: Uint8Array, at: number): number {
+  return data[at]! | (data[at + 1]! << 8)
+}
+
+/**
+ * Read a little-endian int16.
+ *
+ * @param data - the buffer.
+ * @param at - byte offset.
+ * @returns the value.
+ */
+function i16(data: Uint8Array, at: number): number {
+  const value = u16(data, at)
+  return value >= 0x8000 ? value - 0x10000 : value
+}
+
+/**
+ * Decode one sub-tile flag byte.
+ *
+ * @param raw - the flag byte.
+ * @returns the decoded flags.
+ */
+export function subTileFlagsOf(raw: number): SubTileFlags {
+  return {
+    blockWalk: (raw & 1) === 1,
+    blockLos: (raw & 2) === 2,
+    blockJump: (raw & 4) === 4,
+    blockPlayerWalk: (raw & 8) === 8,
+    blockLight: (raw & 32) === 32,
+    raw,
+  }
+}
+
+/**
+ * Decode a DT1 file.
+ *
+ * @param data - the complete file.
+ * @returns the decoded library.
+ */
+export function decodeDt1(data: Uint8Array): Dt1 {
+  if (data.byteLength < HEADER_PREFIX + HEADER_UNKNOWN + 8) {
+    throw new CelError(`DT1 is ${String(data.byteLength)} bytes, too short for a header`)
+  }
+  const versionMajor = i32(data, 0)
+  const versionMinor = i32(data, 4)
+  if (versionMajor !== 7 || versionMinor !== 6) {
+    throw new CelError(`unsupported DT1 version ${String(versionMajor)}.${String(versionMinor)} (expected 7.6)`)
+  }
+  const tileCount = i32(data, HEADER_PREFIX + HEADER_UNKNOWN)
+  const tileDataStart = i32(data, HEADER_PREFIX + HEADER_UNKNOWN + 4)
+  if (tileCount < 0 || tileDataStart < 0 || tileDataStart > data.byteLength) {
+    throw new CelError(`DT1 header is implausible: ${String(tileCount)} tiles at ${String(tileDataStart)}`)
+  }
+  const tilesEnd = tileDataStart + tileCount * TILE_RECORD_SIZE
+  if (tilesEnd > data.byteLength) {
+    throw new CelError(`DT1 tile records run past the file end (${String(tilesEnd)} > ${String(data.byteLength)})`)
+  }
+
+  const warnings: string[] = []
+  const records: { tile: Omit<Dt1Tile, 'blocks' | 'minBlockY' | 'bitmapHeight'>; blocks: BlockHeader[] }[] = []
+  for (let index = 0; index < tileCount; index += 1) {
+    const at = tileDataStart + index * TILE_RECORD_SIZE
+    const subTileFlags: SubTileFlags[] = []
+    for (let sub = 0; sub < SUB_TILE_GRID * SUB_TILE_GRID; sub += 1) {
+      subTileFlags.push(subTileFlagsOf(data[at + 40 + sub]!))
+    }
+    const blockHeaderPointer = i32(data, at + 72)
+    const blockHeaderSize = i32(data, at + 76)
+    const numBlocks = i32(data, at + 80)
+    const blocks: BlockHeader[] = []
+    for (let blockIndex = 0; blockIndex < numBlocks; blockIndex += 1) {
+      const headerAt = blockHeaderPointer + blockIndex * BLOCK_HEADER_SIZE
+      if (headerAt + BLOCK_HEADER_SIZE > data.byteLength) {
+        throw new CelError(`tile ${String(index)} block ${String(blockIndex)} header is out of range`)
+      }
+      // Block header (20 bytes): X, Y, 2 unused, GridX, GridY, Format,
+      // Length, 2 unused, FileOffset. Note the two unused words: a 16-byte
+      // reading of this record parses every field after Y at the wrong offset.
+      blocks.push({
+        x: i16(data, headerAt),
+        y: i16(data, headerAt + 2),
+        gridX: data[headerAt + 6]!,
+        gridY: data[headerAt + 7]!,
+        format: i16(data, headerAt + 8),
+        length: i32(data, headerAt + 10),
+        fileOffset: i32(data, headerAt + 16),
+        headerOffset: blockHeaderPointer,
+      })
+    }
+    records.push({
+      tile: {
+        direction: i32(data, at + 0),
+        height: i32(data, at + 8),
+        width: i32(data, at + 12),
+        type: i32(data, at + 20),
+        style: i32(data, at + 24),
+        sequence: i32(data, at + 28),
+        materialFlags: u16(data, at + 6),
+        roofHeight: i16(data, at + 4),
+        rarityFrameIndex: i32(data, at + 32),
+        subTileFlags,
+      },
+      blocks,
+    })
+    // The field at +76 is *not* a per-block stride: real Act 1 town tiles carry
+    // 25 blocks and a value of 6900, which is the whole block section —
+    // `25 * 20 (headers) + 25 * 256 (bodies)`. Treating it as `numBlocks * 20`
+    // rejected every real Diablo II DT1 while accepting our own fixtures, which
+    // is exactly the failure mode a fixture-only round trip cannot see. The
+    // invariant is checked and reported instead of guessed at.
+    if (numBlocks > 0) {
+      const bodies = blocks.reduce((sum, block) => sum + block.length, 0)
+      const expected = numBlocks * BLOCK_HEADER_SIZE + bodies
+      if (blockHeaderSize !== expected) {
+        warnings.push(
+          `tile ${String(index)}: block section is ${String(blockHeaderSize)} bytes, `
+          + `but ${String(numBlocks)} headers + ${String(bodies)} body bytes = ${String(expected)}`,
+        )
+      }
+    }
+  }
+
+  // Each tile is shifted by its *own* most negative block y, not by a file-wide
+  // worst case: a wall's art legitimately extends above its cell (that is what
+  // makes it a wall), and a shared shift would push every other tile down by the
+  // tallest wall in the library.
+  const tiles: Dt1Tile[] = records.map((record, index) => {
+    let minBlockY = 0
+    let maxBlockY = 0
+    for (const block of record.blocks) {
+      if (block.y < minBlockY) minBlockY = block.y
+      if (block.y + BLOCK_PIXEL_HEIGHT > maxBlockY) maxBlockY = block.y + BLOCK_PIXEL_HEIGHT
+    }
+    const yOffset = -minBlockY
+    const bitmapHeight = Math.max(Math.abs(record.tile.height), maxBlockY - minBlockY)
+    return {
+      ...record.tile,
+      minBlockY,
+      bitmapHeight,
+      blocks: record.blocks.map(block => decodeBlock(data, block, record.tile, yOffset, index, bitmapHeight)),
+    }
+  })
+
+  return { versionMajor, versionMinor, tiles, warnings }
+}
+
+/**
+ * Decode one block's pixels at tile size.
+ *
+ * @param data - the complete file.
+ * @param block - the block header.
+ * @param tile - the owning tile.
+ * @param yOffset - vertical shift applied to every block.
+ * @param tileIndex - the tile's index, for error messages.
+ * @returns the block with pixels.
+ */
+function decodeBlock(
+  data: Uint8Array,
+  block: BlockHeader,
+  tile: Omit<Dt1Tile, 'blocks' | 'minBlockY' | 'bitmapHeight'>,
+  yOffset: number,
+  tileIndex: number,
+  bitmapHeight: number,
+): Dt1Block {
+  const tileWidth = tile.width
+  const tileHeight = bitmapHeight
+  if (tileWidth <= 0 || tileHeight <= 0 || tileWidth * tileHeight > (1 << 22)) {
+    throw new CelError(`tile ${String(tileIndex)} has an implausible size ${String(tileWidth)}x${String(tileHeight)}`)
+  }
+  const pixels = new Uint8Array(tileWidth * tileHeight)
+  const decodeWith = (offset: number): Uint8Array => {
+    const encoded = data.subarray(offset, offset + block.length)
+    if (encoded.byteLength < block.length) {
+      throw new CelError(`tile ${String(tileIndex)} block data is truncated`)
+    }
+    const target = new Uint8Array(tileWidth * tileHeight)
+    if (block.format === 1) {
+      decodeIsometric(encoded, target, block, tileWidth, tileHeight, yOffset)
+    } else {
+      decodeRunLength(encoded, target, block, tileWidth, tileHeight, yOffset)
+    }
+    return target
+  }
+  // The offset field's base is not settled by the documentation (`offset in
+  // file`) versus the reference implementation (relative to the block header),
+  // so both readings are tried. An all-transparent result is what a wrong-but-
+  // in-range reading looks like — an RLE stream of zero pairs advances rows and
+  // draws nothing — so a blank first attempt falls through to the alternative
+  // instead of being returned as a silently empty tile.
+  let best: Uint8Array | null = null
+  for (const offset of resolveBlockDataOffset(data, block)) {
+    const decoded = decodeWith(offset)
+    if (decoded.some(value => value !== 0)) return { x: block.x, y: block.y, gridX: block.gridX, gridY: block.gridY, format: block.format, pixels: decoded }
+    best ??= decoded
+  }
+  /* v8 ignore next -- resolveBlockDataOffset guarantees at least one candidate. */
+  if (best === null) throw new CelError(`tile ${String(tileIndex)} block produced no data`)
+  return { x: block.x, y: block.y, gridX: block.gridX, gridY: block.gridY, format: block.format, pixels: best }
+}
+
+/**
+ * Lay an isometric block onto the tile bitmap.
+ *
+ * @param encoded - the 256-byte block.
+ * @param pixels - the tile bitmap to fill.
+ * @param block - the block placement.
+ * @param tileWidth - tile width.
+ * @param tileHeight - tile height.
+ * @param yOffset - vertical shift applied to every block.
+ */
+function decodeIsometric(
+  encoded: Uint8Array,
+  pixels: Uint8Array,
+  block: { x: number; y: number },
+  tileWidth: number,
+  tileHeight: number,
+  yOffset: number,
+): void {
+  let index = 0
+  for (let row = 0; row < ISO_JUMP.length && index < encoded.byteLength; row += 1) {
+    const startX = ISO_JUMP[row]!
+    const run = ISO_RUN[row]!
+    for (let i = 0; i < run; i += 1) {
+      const x = block.x + startX + i
+      const y = block.y + row + yOffset
+      if (x < 0 || x >= tileWidth || y < 0 || y >= tileHeight) { index += 1; continue }
+      pixels[y * tileWidth + x] = encoded[index]!
+      index += 1
+    }
+  }
+}
+
+/**
+ * Lay a run-length encoded block onto the tile bitmap.
+ *
+ * @param encoded - the block's run stream.
+ * @param pixels - the tile bitmap to fill.
+ * @param block - the block placement.
+ * @param tileWidth - tile width.
+ * @param tileHeight - tile height.
+ * @param yOffset - vertical shift applied to every block.
+ */
+function decodeRunLength(
+  encoded: Uint8Array,
+  pixels: Uint8Array,
+  block: { x: number; y: number },
+  tileWidth: number,
+  tileHeight: number,
+  yOffset: number,
+): void {
+  let index = 0
+  let remaining = blockLengthOf(encoded)
+  let x = 0
+  let y = 0
+  while (remaining > 0 && index + 1 < encoded.byteLength) {
+    const skip = encoded[index]!
+    const count = encoded[index + 1]!
+    index += 2
+    remaining -= 2
+    if ((skip | count) === 0) {
+      x = 0
+      y += 1
+      continue
+    }
+    x += skip
+    remaining -= count
+    for (let i = 0; i < count; i += 1) {
+      const px = block.x + x + i
+      const py = block.y + y + yOffset
+      if (px >= 0 && px < tileWidth && py >= 0 && py < tileHeight) {
+        pixels[py * tileWidth + px] = encoded[index] ?? 0
+      }
+      index += 1
+    }
+    x += count
+  }
+}
+
+/**
+ * The block's declared length, which the caller substitutes for the stream's
+ * own bound. Kept as a helper so the run-length loop reads the same way as the
+ * reference decoder, which counts down a byte budget rather than testing the
+ * buffer end.
+ *
+ * @param encoded - the block's bytes.
+ * @returns the byte budget.
+ */
+function blockLengthOf(encoded: Uint8Array): number {
+  return encoded.byteLength
+}
diff --git a/src/formats/pal.ts b/src/formats/pal.ts
new file mode 100644
index 0000000..f210549
--- /dev/null
+++ b/src/formats/pal.ts
@@ -0,0 +1,83 @@
+/**
+ * Palette formats.
+ *
+ * Both Diablo I and classic Diablo II store a palette as 256 VGA triples in
+ * 768 bytes; Diablo II additionally ships `.pl2` files, which carry the palette
+ * plus per-entity colour shifts (not implemented until a real `.pl2` is at
+ * hand — see the note at the end of this file).
+ */
+
+/** A decoded 256-colour palette. */
+export interface Palette {
+  /** RGB triples, 0..255, 768 bytes. */
+  readonly rgb: Uint8Array
+  /** Number of entries (always 256 for the supported formats). */
+  readonly size: number
+}
+
+/** Raised when a palette file is not the supported variant. */
+export class PaletteError extends Error {}
+
+/**
+ * Decode a raw 768-byte palette (`.pal`).
+ *
+ * @param data - the complete file.
+ * @returns the palette.
+ */
+export function decodePal(data: Uint8Array): Palette {
+  if (data.byteLength < 768) {
+    throw new PaletteError(`palette is ${String(data.byteLength)} bytes, expected at least 768`)
+  }
+  return { rgb: data.subarray(0, 768), size: 256 }
+}
+
+/**
+ * Decode a 256-byte colour translation table (`.trn`).
+ *
+ * A translation table is a per-index remap applied when drawing: Diablo uses it
+ * for monster variants (a red skeleton, a black bow skeleton, ...) so one
+ * sprite set serves several looks. That is exactly the use case Diablo II's
+ * palette shifts cover too, so the mechanism is shared.
+ *
+ * @param data - the complete file.
+ * @returns a 256-entry index remap.
+ */
+export function decodeTrn(data: Uint8Array): Uint8Array {
+  if (data.byteLength !== 256) {
+    throw new PaletteError(`translation table is ${String(data.byteLength)} bytes, expected 256`)
+  }
+  return data
+}
+
+/**
+ * Expand palette indices into RGBA, optionally through a translation table.
+ *
+ * @param indices - one palette index per pixel.
+ * @param mask - 1 where the pixel is opaque, 0 where transparent.
+ * @param palette - the palette to resolve colours with.
+ * @param trn - optional index remap applied before the palette lookup.
+ * @returns RGBA8 pixels matching the index buffer's layout.
+ */
+export function indicesToRgba(
+  indices: Uint8Array,
+  mask: Uint8Array,
+  palette: Palette,
+  trn?: Uint8Array,
+): Uint8ClampedArray {
+  const rgba = new Uint8ClampedArray(indices.length * 4)
+  for (let i = 0; i < indices.length; i += 1) {
+    if (mask[i] === 0) continue
+    const index = trn === undefined ? indices[i]! : trn[indices[i]!]!
+    const at = index * 3
+    rgba[i * 4] = palette.rgb[at]!
+    rgba[i * 4 + 1] = palette.rgb[at + 1]!
+    rgba[i * 4 + 2] = palette.rgb[at + 2]!
+    rgba[i * 4 + 3] = 255
+  }
+  return rgba
+}
+
+// Diablo II's `.pl2` carries more than a palette: five act palettes plus
+// "transformation" tables indexed by unit type. Its layout only earns trust
+// against a real file, so it lands with the rest of the D2 decoders rather than
+// being written blind here.
diff --git a/src/formats/pcx.ts b/src/formats/pcx.ts
new file mode 100644
index 0000000..c83780c
--- /dev/null
+++ b/src/formats/pcx.ts
@@ -0,0 +1,103 @@
+/**
+ * PCX decoder for the 8-bit, single-plane, RLE-compressed images Diablo I and
+ * II use for UI art.
+ *
+ * Only the variant the games actually ship is supported: manufacturer 0x0A,
+ * encoding 1 (RLE), bitsPerPixel 8, planes 1, with the 256-colour palette in
+ * the trailing 769 bytes (0x0C marker + 768 bytes of VGA triples).
+ */
+
+/** One decoded image, ready to blit. */
+export interface PcxImage {
+  /** Pixel width. */
+  readonly width: number
+  /** Pixel height. */
+  readonly height: number
+  /** RGBA8 pixels, row-major, top-left origin. */
+  readonly rgba: Uint8ClampedArray
+  /** The file's 256-colour palette as RGB triples. */
+  readonly palette: Uint8Array
+}
+
+/** Raised when a PCX file is not the supported variant or is truncated. */
+export class PcxError extends Error {}
+
+/**
+ * Decode a PCX image.
+ *
+ * @param data - the complete file.
+ * @returns the decoded image.
+ */
+export function decodePcx(data: Uint8Array): PcxImage {
+  if (data.byteLength < 128) throw new PcxError(`truncated header (${String(data.byteLength)} bytes)`)
+  if (data[0] !== 0x0a) throw new PcxError(`bad manufacturer 0x${(data[0] ?? 0).toString(16)}`)
+  const encoding = data[2]
+  const bpp = data[3]
+  const planes = data[65]
+  if (bpp !== 8 || planes !== 1) throw new PcxError(`unsupported layout (bpp ${String(bpp)}, planes ${String(planes)})`)
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength)
+  const xMin = view.getUint16(4, true)
+  const yMin = view.getUint16(6, true)
+  const xMax = view.getUint16(8, true)
+  const yMax = view.getUint16(10, true)
+  const bytesPerLine = view.getUint16(66, true)
+  const width = xMax - xMin + 1
+  const height = yMax - yMin + 1
+  if (width <= 0 || height <= 0 || bytesPerLine < width) {
+    throw new PcxError(`implausible geometry ${String(width)}x${String(height)} (stride ${String(bytesPerLine)})`)
+  }
+
+  // The palette is the last 769 bytes, marked by 0x0C.
+  const paletteAt = data.byteLength - 769
+  if (paletteAt < 128 || data[paletteAt] !== 0x0c) {
+    throw new PcxError('missing 256-colour palette trailer')
+  }
+  const palette = data.subarray(paletteAt + 1, paletteAt + 769)
+
+  // Row-major RLE: a byte with the two top bits set is a run of the low six
+  // bits, followed by the value; anything else is one literal pixel.
+  const pixels = new Uint8Array(width * height)
+  let read = 128
+  if (encoding === 1) {
+    for (let row = 0; row < height; row += 1) {
+      let column = 0
+      while (column < bytesPerLine) {
+        if (read >= paletteAt) throw new PcxError('truncated RLE stream')
+        const marker = data[read]!
+        read += 1
+        if ((marker & 0xc0) === 0xc0) {
+          const run = marker & 0x3f
+          if (read >= data.byteLength) throw new PcxError('truncated RLE run')
+          const value = data[read]!
+          read += 1
+          for (let i = 0; i < run && column < bytesPerLine; i += 1, column += 1) {
+            if (column < width) pixels[row * width + column] = value
+          }
+        } else {
+          if (column < width) pixels[row * width + column] = marker
+          column += 1
+        }
+      }
+    }
+  } else if (encoding === 0) {
+    for (let row = 0; row < height; row += 1) {
+      for (let column = 0; column < width; column += 1) {
+        const at = 128 + row * bytesPerLine + column
+        if (at >= paletteAt) throw new PcxError('truncated raw image')
+        pixels[row * width + column] = data[at]!
+      }
+    }
+  } else {
+    throw new PcxError(`unsupported encoding ${String(encoding)}`)
+  }
+
+  const rgba = new Uint8ClampedArray(width * height * 4)
+  for (let i = 0; i < pixels.length; i += 1) {
+    const index = pixels[i]! * 3
+    rgba[i * 4] = palette[index]!
+    rgba[i * 4 + 1] = palette[index + 1]!
+    rgba[i * 4 + 2] = palette[index + 2]!
+    rgba[i * 4 + 3] = 255
+  }
+  return { width, height, rgba, palette }
+}
diff --git a/src/formats/pl2.ts b/src/formats/pl2.ts
new file mode 100644
index 0000000..5b3b01d
--- /dev/null
+++ b/src/formats/pl2.ts
@@ -0,0 +1,228 @@
+/**
+ * Diablo II `.pl2` palette+transform decoder.
+ *
+ * A PL2 is a base palette followed by a long series of *transform tables*: each
+ * is 256 bytes mapping a palette index to another palette index. They are how
+ * Diablo II does lighting, blending, unit colour shifts and text colours without
+ * ever touching RGB — a unit under a light level or a monster variant is drawn
+ * through a different transform, over the same indexed sprite. That is why the
+ * decoders here keep sprites indexed and resolve colour last.
+ *
+ * The layout is fixed and entirely positional: one 1024-byte base palette, then
+ * tables in this exact order, then a 39-byte text palette and its own transforms.
+ * There is no header, no count and no directory, so the table order *is* the
+ * format — hence the counts written out below rather than derived.
+ *
+ * Confidence note: the base palette's stored byte order is taken from the
+ * reference implementation (r, g, b, unused). A swapped red/blue would only show
+ * against real art, so this is re-checked when a real archive lands.
+ */
+
+/** Palette entries (one transform maps every entry). */
+const PALETTE_COLORS = 256
+/** Bytes per base-palette entry: r, g, b, one unused byte. */
+const BASE_ENTRY_BYTES = 4
+/** Base palette size in bytes (1024). */
+const BASE_BYTES = PALETTE_COLORS * BASE_ENTRY_BYTES
+/** Text palette entries. */
+const TEXT_COLORS = 13
+/** Bytes per text-palette entry (r, g, b). */
+const TEXT_ENTRY_BYTES = 3
+/** Light-level tables. */
+const LIGHT_LEVEL_VARIATIONS = 32
+/** Inverse-colour tables. */
+const INV_COLOR_VARIATIONS = 16
+/** Coarse alpha-blend groups, each with a full fine table. */
+const ALPHA_BLEND_COARSE = 3
+/** Fine alpha-blend tables per coarse group. */
+const ALPHA_BLEND_FINE = 256
+/** Additive-blend tables. */
+const ADDITIVE_BLENDS = 256
+/** Multiplicative-blend tables. */
+const MULTIPLY_BLENDS = 256
+/** Hue-variation tables. */
+const HUE_VARIATIONS = 111
+/** Unnamed variation tables (kept as raw tables). */
+const UNKNOWN_VARIATIONS = 14
+/** Maximum-component blend tables. */
+const MAX_COMPONENT_BLENDS = 256
+/** Text-colour shift tables. */
+const TEXT_SHIFTS = 13
+
+/** One transform table: 256 index remaps. */
+export type Pl2Transform = Uint8Array
+
+/** A decoded PL2 palette file. */
+export interface Pl2 {
+  /** Base palette as 768 RGB triples, ready for the sprite decoders. */
+  readonly rgb: Uint8Array
+  /** Light-level tables (index into the base palette). */
+  readonly lightLevels: readonly Pl2Transform[]
+  /** Inverse-colour tables. */
+  readonly inverseColors: readonly Pl2Transform[]
+  /** Selected-unit shift. */
+  readonly selectedUnitShift: Pl2Transform
+  /** Alpha-blend tables, grouped coarsely then finely. */
+  readonly alphaBlend: readonly (readonly Pl2Transform[])[]
+  /** Additive-blend tables. */
+  readonly additiveBlend: readonly Pl2Transform[]
+  /** Multiplicative-blend tables. */
+  readonly multiplyBlend: readonly Pl2Transform[]
+  /** Hue-variation tables. */
+  readonly hueVariations: readonly Pl2Transform[]
+  /** Red-tone shift. */
+  readonly redTones: Pl2Transform
+  /** Green-tone shift. */
+  readonly greenTones: Pl2Transform
+  /** Blue-tone shift. */
+  readonly blueTones: Pl2Transform
+  /** Unnamed variation tables. */
+  readonly unknownVariations: readonly Pl2Transform[]
+  /** Maximum-component blend tables. */
+  readonly maxComponentBlend: readonly Pl2Transform[]
+  /** Darkened colour shift. */
+  readonly darkenedShift: Pl2Transform
+  /** Text palette as RGB triples (39 bytes). */
+  readonly textRgb: Uint8Array
+  /** Text-colour shift tables. */
+  readonly textShifts: readonly Pl2Transform[]
+}
+
+/** Raised when a PL2 file is short or malformed. */
+export class Pl2Error extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'Pl2Error'
+  }
+}
+
+/** Transform tables in the order they appear, and how many of each. */
+const TABLE_ORDER: readonly (readonly [string, number])[] = [
+  ['lightLevels', LIGHT_LEVEL_VARIATIONS],
+  ['inverseColors', INV_COLOR_VARIATIONS],
+  ['selectedUnitShift', 1],
+  // Coarse alpha groups, each a run of fine tables.
+  ['alphaBlend0', ALPHA_BLEND_FINE],
+  ['alphaBlend1', ALPHA_BLEND_FINE],
+  ['alphaBlend2', ALPHA_BLEND_FINE],
+  ['additiveBlend', ADDITIVE_BLENDS],
+  ['multiplyBlend', MULTIPLY_BLENDS],
+  ['hueVariations', HUE_VARIATIONS],
+  ['redTones', 1],
+  ['greenTones', 1],
+  ['blueTones', 1],
+  ['unknownVariations', UNKNOWN_VARIATIONS],
+  ['maxComponentBlend', MAX_COMPONENT_BLENDS],
+  ['darkenedShift', 1],
+]
+
+/**
+ * The file size a PL2 must have, in bytes: base palette, every transform, the
+ * text palette and its shifts.
+ *
+ * @returns the expected size.
+ */
+export function pl2ExpectedSize(): number {
+  const tables = TABLE_ORDER.reduce((sum, [, count]) => sum + count, 0) + TEXT_SHIFTS
+  return BASE_BYTES + tables * PALETTE_COLORS + TEXT_COLORS * TEXT_ENTRY_BYTES
+}
+
+/**
+ * Decode a PL2 file.
+ *
+ * @param data - the complete file.
+ * @returns the palette and its transforms.
+ */
+export function decodePl2(data: Uint8Array): Pl2 {
+  const expected = pl2ExpectedSize()
+  if (data.byteLength < expected) {
+    throw new Pl2Error(`PL2 is ${String(data.byteLength)} bytes, expected ${String(expected)}`)
+  }
+  // The base palette interleaves an unused byte per entry; the sprite decoders
+  // want dense RGB triples, so it is repacked rather than aliased.
+  const rgb = new Uint8Array(PALETTE_COLORS * 3)
+  for (let index = 0; index < PALETTE_COLORS; index += 1) {
+    const at = index * BASE_ENTRY_BYTES
+    rgb[index * 3] = data[at]!
+    rgb[index * 3 + 1] = data[at + 1]!
+    rgb[index * 3 + 2] = data[at + 2]!
+  }
+
+  // Transform tables are read as views: 1727 tables is ~442 KB, and nothing
+  // here needs its own copy.
+  let cursor = BASE_BYTES
+  const take = (count: number): Pl2Transform[] => {
+    const tables: Pl2Transform[] = []
+    for (let index = 0; index < count; index += 1) {
+      tables.push(data.subarray(cursor, cursor + PALETTE_COLORS))
+      cursor += PALETTE_COLORS
+    }
+    return tables
+  }
+  const takeOne = (): Pl2Transform => {
+    const table = data.subarray(cursor, cursor + PALETTE_COLORS)
+    cursor += PALETTE_COLORS
+    return table
+  }
+
+  const lightLevels = take(LIGHT_LEVEL_VARIATIONS)
+  const inverseColors = take(INV_COLOR_VARIATIONS)
+  const selectedUnitShift = takeOne()
+  const alphaBlend = [
+    take(ALPHA_BLEND_FINE),
+    take(ALPHA_BLEND_FINE),
+    take(ALPHA_BLEND_FINE),
+  ]
+  const additiveBlend = take(ADDITIVE_BLENDS)
+  const multiplyBlend = take(MULTIPLY_BLENDS)
+  const hueVariations = take(HUE_VARIATIONS)
+  const redTones = takeOne()
+  const greenTones = takeOne()
+  const blueTones = takeOne()
+  const unknownVariations = take(UNKNOWN_VARIATIONS)
+  const maxComponentBlend = take(MAX_COMPONENT_BLENDS)
+  const darkenedShift = takeOne()
+
+  const textRgb = new Uint8Array(TEXT_COLORS * TEXT_ENTRY_BYTES)
+  for (let index = 0; index < TEXT_COLORS; index += 1) {
+    const at = cursor + index * TEXT_ENTRY_BYTES
+    textRgb[index * 3] = data[at]!
+    textRgb[index * 3 + 1] = data[at + 1]!
+    textRgb[index * 3 + 2] = data[at + 2]!
+  }
+  cursor += TEXT_COLORS * TEXT_ENTRY_BYTES
+
+  const textShifts = take(TEXT_SHIFTS)
+
+  if (cursor !== expected) {
+    /* v8 ignore next -- the size check above makes this unreachable for well-formed files. */
+    throw new Pl2Error(`PL2 layout consumed ${String(cursor)} bytes, expected ${String(expected)}`)
+  }
+
+  return {
+    rgb,
+    lightLevels, inverseColors, selectedUnitShift, alphaBlend,
+    additiveBlend, multiplyBlend, hueVariations,
+    redTones, greenTones, blueTones,
+    unknownVariations, maxComponentBlend, darkenedShift,
+    textRgb, textShifts,
+  }
+}
+
+/**
+ * Resolve a transform into a concrete palette.
+ *
+ * @param baseRgb - the base palette as RGB triples.
+ * @param transform - the index remap to apply.
+ * @returns a 768-byte RGB palette.
+ */
+export function applyTransform(baseRgb: Uint8Array, transform: Pl2Transform): Uint8Array {
+  const out = new Uint8Array(PALETTE_COLORS * 3)
+  for (let index = 0; index < PALETTE_COLORS; index += 1) {
+    const source = (transform[index] ?? 0) * 3
+    out[index * 3] = baseRgb[source] ?? 0
+    out[index * 3 + 1] = baseRgb[source + 1] ?? 0
+    out[index * 3 + 2] = baseRgb[source + 2] ?? 0
+  }
+  return out
+}
diff --git a/src/formats/sprite.ts b/src/formats/sprite.ts
new file mode 100644
index 0000000..ba14e72
--- /dev/null
+++ b/src/formats/sprite.ts
@@ -0,0 +1,99 @@
+/**
+ * Shared sprite vocabulary: the frame/group/sheet shape every sprite decoder
+ * produces, regardless of container (Diablo I `.cel`/`.cl2` today, Diablo II
+ * `.dc6`/`.dcc` next).
+ *
+ * Frames stay palette-indexed on purpose. Both games implement unit variants
+ * (a red skeleton, a black bow skeleton) as an index remap applied at draw
+ * time, so keeping indices plus a transparency mask is what lets one decoded
+ * sprite serve every variant without re-decoding — the same reason Diablo II's
+ * palette shifts exist.
+ */
+
+/** One decoded frame. */
+export interface SpriteFrame {
+  /** Frame width in pixels. */
+  readonly width: number
+  /** Frame height in pixels. */
+  readonly height: number
+  /** Palette indices, row-major, `width * height` entries. */
+  readonly indices: Uint8Array
+  /** 1 where the pixel is opaque, 0 where transparent. */
+  readonly mask: Uint8Array
+}
+
+/** Frames belonging to one animation direction. */
+export interface SpriteGroup {
+  /** The group's frames, in animation order. */
+  readonly frames: readonly SpriteFrame[]
+}
+
+/** A decoded file: one group for plain sheets, many for multi-direction art. */
+export interface SpriteSheet {
+  /** The groups, in file order. */
+  readonly groups: readonly SpriteGroup[]
+  /**
+   * The uniform width every frame was decoded with, or null when the frames
+   * were given individual widths.
+   */
+  readonly width: number | null
+}
+
+/** Raised when a sprite file cannot be decoded. */
+export class CelError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'CelError'
+  }
+}
+
+/** Smallest frame width worth trying. */
+const MIN_WIDTH = 8
+/**
+ * Largest frame width worth trying. Diablo I's cutscene and panel art is
+ * 640 wide, so the cap has to sit above that; Diablo II's widest sheets stay
+ * below 256.
+ */
+const MAX_WIDTH = 1024
+
+/**
+ * Width candidates for auto-detection, smallest first.
+ *
+ * Only meaningful for formats whose runs are line-bounded (Diablo I `.cel`):
+ * there a width is valid exactly when every row's runs sum to it, so a wrong
+ * width is rejected outright. For formats whose runs may cross rows (`.cl2`,
+ * Diablo II `.dcc`) the run stream is consumed to the frame end under *any*
+ * width, so the width cannot be recovered from the file at all — the game
+ * supplies it per animation, and so must a caller.
+ *
+ * @returns candidate widths.
+ */
+export function spriteWidthCandidates(): number[] {
+  const widths: number[] = []
+  for (let width = MIN_WIDTH; width <= MAX_WIDTH; width += 1) widths.push(width)
+  return widths
+}
+
+/**
+ * Player animation frame widths.
+ *
+ * These are the values the original game assigns in `SetPlrAnims`
+ * (`Source/player.cpp` of the Devilution reconstruction): every class stands
+ * and walks at 96 (the Hellfire monk at 112), attacks at 128, and drops to 96
+ * for bow and unarmed attacks. They are data, not guesses — a `.cl2` file
+ * cannot be decoded without them.
+ */
+export const PLAYER_SPRITE_WIDTH = {
+  /** Stand and walk, base classes. */
+  stand: 96,
+  /** Walk, base classes. */
+  walk: 96,
+  /** Melee attack. */
+  attack: 128,
+  /** Attack without a weapon, or with a bow. */
+  attackNarrow: 96,
+  /** Stand/walk for the Hellfire monk. */
+  monk: 112,
+  /** Melee attack for the Hellfire monk. */
+  monkAttack: 130,
+} as const
diff --git a/src/formats/tbl.ts b/src/formats/tbl.ts
new file mode 100644
index 0000000..be43c02
--- /dev/null
+++ b/src/formats/tbl.ts
@@ -0,0 +1,116 @@
+/**
+ * Diablo II `.tbl` string-table decoder (classic layout).
+ *
+ * A TBL is an *indexed* string table — item, skill, monster and quest names are
+ * referred to by number, not by key:
+ *
+ * ```
+ * u16  crc             (unused here; the game uses it as a content checksum)
+ * u16  entryCount
+ * u16  offsets[entryCount]   absolute file offsets, one per index
+ * ...  strings: u16 characterCount, then characterCount * 2 bytes UTF-16LE
+ * ```
+ *
+ * The classic Diablo II files (`string.tbl`, `expansionstring.tbl`,
+ * `patchstring.tbl`) use exactly this layout. A later "extended" variant adds a
+ * hash table of name/value pairs on top; the community Go package implements
+ * that variant instead, so unlike the other formats in this directory **there is
+ * no independent decoder to diff this one against** — it is checked by
+ * construction (write a table, read it back, including non-ASCII) and is on the
+ * list to confirm against a real `string.tbl`.
+ *
+ * Unused indices are legal: an offset that is zero, or that points past the
+ * table, decodes to `undefined` rather than an empty string, so a caller can
+ * tell "no such string" from "empty string".
+ */
+
+/** Bytes of the fixed header: crc + entry count. */
+const HEADER_BYTES = 4
+/** Bytes per index-table entry. */
+const INDEX_BYTES = 2
+/** Bytes of one string's length prefix. */
+const LENGTH_BYTES = 2
+/** Bytes per UTF-16 code unit. */
+const CODE_UNIT_BYTES = 2
+
+/** Raised when a TBL file is malformed. */
+export class TblError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'TblError'
+  }
+}
+
+/**
+ * Read a little-endian uint16.
+ *
+ * @param data - the buffer.
+ * @param at - byte offset.
+ * @returns the value.
+ */
+function u16(data: Uint8Array, at: number): number {
+  return data[at]! | (data[at + 1]! << 8)
+}
+
+/**
+ * Decode a TBL file.
+ *
+ * @param data - the complete file.
+ * @returns one entry per string index; `undefined` where the index is unused.
+ */
+export function decodeTbl(data: Uint8Array): (string | undefined)[] {
+  if (data.byteLength < HEADER_BYTES) {
+    throw new TblError(`TBL is ${String(data.byteLength)} bytes, too short for a header`)
+  }
+  const entryCount = u16(data, 2)
+  const indexEnd = HEADER_BYTES + entryCount * INDEX_BYTES
+  if (indexEnd > data.byteLength) {
+    throw new TblError(`TBL declares ${String(entryCount)} entries but the index table runs past the file`)
+  }
+  const decoder = new TextDecoder('utf-16le')
+  const entries: (string | undefined)[] = []
+  for (let index = 0; index < entryCount; index += 1) {
+    const offset = u16(data, HEADER_BYTES + index * INDEX_BYTES)
+    // A zero offset marks an unused index; so does one that cannot hold a
+    // length prefix. Both are normal in shipped tables.
+    if (offset === 0 || offset + LENGTH_BYTES > data.byteLength) {
+      entries.push(undefined)
+      continue
+    }
+    const characters = u16(data, offset)
+    const from = offset + LENGTH_BYTES
+    const to = from + characters * CODE_UNIT_BYTES
+    if (to > data.byteLength) {
+      throw new TblError(`entry ${String(index)} at ${String(offset)} declares ${String(characters)} characters past the file end`)
+    }
+    // The stored count is characters, not bytes; decoding from a view keeps the
+    // conversion (including surrogate pairs) in the platform's hands.
+    entries.push(decoder.decode(data.subarray(from, to)))
+  }
+  return entries
+}
+
+/**
+ * Build an index → string lookup over a decoded table.
+ *
+ * @param entries - a decoded table.
+ * @returns the lookup.
+ */
+export function tblLookup(entries: readonly (string | undefined)[]): {
+  /** Number of usable entries. */
+  readonly size: number
+  /**
+   * Read one entry.
+   *
+   * @param index - the string index.
+   * @returns the string, or undefined when the index is unused.
+   */
+  get: (index: number) => string | undefined
+} {
+  let size = 0
+  for (const entry of entries) if (entry !== undefined) size += 1
+  return {
+    size,
+    get: index => (index >= 0 && index < entries.length ? entries[index] : undefined),
+  }
+}
diff --git a/src/game/acts.ts b/src/game/acts.ts
new file mode 100644
index 0000000..577b49b
--- /dev/null
+++ b/src/game/acts.ts
@@ -0,0 +1,328 @@
+/**
+ * Resolving one act's town from Diablo II's own tables.
+ *
+ * The chain is three tables deep and every link is data, so nothing here is
+ * hard-coded per act — which is the point, because five towns with different
+ * sizes, different tile sets and different palettes cannot be a lookup table
+ * anyone maintains by hand:
+ *
+ *   `Levels.txt`    `Act N - Town`     → level id, act, palette index, level type
+ *   `LvlTypes.txt`  level type id      → `File 1..File 32` (the DT1 libraries)
+ *   `LvlPrest.txt`  level id (`LevelId`) → `File1..File6` (the DS1 quadrants), Dt1Mask
+ *   `data\\global\\palette\\actN\\pal.pl2` → the act's palette
+ *
+ * Two details cost real time to find and are encoded here:
+ *
+ * 1. **`LvlPrest` joins on `LevelId`, not on `Def`.** `Def` is the preset's own
+ *    id (Act 2's town has `Def = 301`, `LevelId = 40`), so joining on the wrong
+ *    column silently returns *other levels'* maps for four of the five acts.
+ * 2. **`Dt1Mask` filters the file list.** Its bits correspond to `File 1..N`;
+ *    for all five towns the mask happens to be saturated, but a level whose mask
+ *    is not would otherwise load libraries the map never references and index
+ *    the rest incorrectly.
+ */
+import { decodeDs1 } from '../formats/ds1.ts'
+import type { Ds1 } from '../formats/ds1.ts'
+import { decodeDt1 } from '../formats/dt1.ts'
+import type { Dt1 } from '../formats/dt1.ts'
+import { decodePl2 } from '../formats/pl2.ts'
+import type { Pl2 } from '../formats/pl2.ts'
+import type { MountedArchives } from '../mpq/mount.ts'
+
+/** Where the data tables live inside an archive. */
+const EXCEL = 'data\\global\\excel\\'
+/** Tile libraries and levels are addressed relative to this prefix. */
+const TILES = 'data\\global\\tiles\\'
+
+/** A tab-separated table with its header row. */
+export interface D2Table {
+  /** Column names, in file order. */
+  readonly header: readonly string[]
+  /** Data rows. */
+  readonly rows: readonly (readonly string[])[]
+}
+
+/**
+ * Decode bytes as Latin-1 without touching Node APIs.
+ *
+ * The tables are ASCII, but this module is imported by the browser bundle, so
+ * no `Buffer` and no Node-only globals: chunks keep `String.fromCharCode` from
+ * blowing the argument limit on a 130 KB table.
+ *
+ * @param bytes - the bytes.
+ * @returns the text.
+ */
+function latin1(bytes: Uint8Array): string {
+  const chunk = 8192
+  let out = ''
+  for (let at = 0; at < bytes.length; at += chunk) {
+    out += String.fromCharCode(...bytes.subarray(at, Math.min(at + chunk, bytes.length)))
+  }
+  return out
+}
+
+/**
+ * Parse one of Diablo II's tab-separated tables.
+ *
+ * Rows end with CRLF and the last line may be empty; both are tolerated because
+ * `Patch_D2.mpq` and `d2data.mpq` disagree about the trailing newline.
+ *
+ * @param bytes - the decoded member.
+ * @returns the table.
+ */
+export function parseTable(bytes: Uint8Array): D2Table {
+  const text = latin1(bytes)
+  const lines = text.split(/\r?\n/).filter(line => line.length > 0)
+  const header = (lines.shift() ?? '').split('\t')
+  return { header, rows: lines.map(line => line.split('\t')) }
+}
+
+/**
+ * Read a column out of a row by name.
+ *
+ * @param table - the table.
+ * @param row - the row.
+ * @param column - column name.
+ * @returns the cell, or an empty string when the column is absent.
+ */
+export function cell(table: D2Table, row: readonly string[], column: string): string {
+  const index = table.header.indexOf(column)
+  return index === -1 ? '' : (row[index] ?? '')
+}
+
+/** The three tables a town resolution needs. */
+export interface ActTables {
+  readonly levels: D2Table
+  readonly lvltypes: D2Table
+  readonly lvlprest: D2Table
+}
+
+/** Everything needed to place and render one level. */
+export interface LevelInfo {
+  /** Act number, 1..5. */
+  readonly act: number
+  /** `Levels.txt` name, e.g. `Act 1 - Town`. */
+  readonly levelName: string
+  /** `Levels.txt` id. */
+  readonly levelId: number
+  /** Palette slot from `Levels.txt` (`Pal`), 0-based. */
+  readonly paletteIndex: number
+  /** `LvlTypes.txt` name. */
+  readonly levelTypeName: string
+  /** DS1 members, full archive paths. */
+  readonly ds1Names: readonly string[]
+  /** DT1 members, full archive paths, in `File 1..N` order after the mask. */
+  readonly dt1Names: readonly string[]
+  /** `LvlPrest.Dt1Mask`, kept for reporting. */
+  readonly dt1Mask: number
+  /** Level extent in cells, from `Levels.txt`. */
+  readonly sizeX: number
+  readonly sizeY: number
+  /** Palette member path. */
+  readonly paletteName: string
+}
+
+/**
+ * The same shape under the name the act pages used before levels were generic.
+ *
+ * @deprecated use {@link LevelInfo}; kept so existing call sites keep reading.
+ */
+export type ActTown = LevelInfo
+
+/** Turn a table-relative tile path into a member name. */
+export function tileMemberPath(relative: string): string {
+  return `${TILES}${relative.replaceAll('/', '\\')}`
+}
+
+/**
+ * Load the three tables from a mounted stack.
+ *
+ * @param archives - the mounted archives.
+ * @returns the parsed tables.
+ */
+export async function loadActTables(archives: MountedArchives): Promise<ActTables> {
+  const read = async (name: string): Promise<D2Table> => parseTable(await archives.read(`${EXCEL}${name}`))
+  return {
+    levels: await read('levels.txt'),
+    lvltypes: await read('lvltypes.txt'),
+    lvlprest: await read('lvlprest.txt'),
+  }
+}
+
+/** A level type's tile libraries, with the mask when the level declares one. */
+export interface LevelLibraries {
+  /** `LvlTypes.txt` name. */
+  readonly levelTypeName: string
+  /** DT1 member names, in `File 1..N` order. */
+  readonly dt1Names: readonly string[]
+  /**
+   * `LvlPrest.Dt1Mask` when the level has preset rows, else `null`.
+   *
+   * Maze and wilderness levels have **no** `LvlPrest` rows at all — their fixed
+   * pieces are picked by the generators — so there is no mask to apply and the
+   * whole file list is in play.
+   */
+  readonly dt1Mask: number | null
+}
+
+/**
+ * Resolve one level by its `Levels.txt` id.
+ *
+ * Everything after the level row is data: its level type names the DT1
+ * libraries, its `LvlPrest` rows name the DS1 files, and its `Pal` slot selects
+ * the act palette. Towns and dungeons differ only in which rows they hit, so one
+ * function covers both — the earlier town-only version could not reach
+ * Tristram, the Cathedral or the Throne Room at all.
+ *
+ * @param tables - the loaded tables.
+ * @param levelId - `Levels.txt` `Id`.
+ * @param act - act number to report (`Levels.txt` stores it 0-based and often
+ *   as 0 for expansion rows, so the caller states it when it knows).
+ * @returns the level description.
+ */
+export function resolveLevel(tables: ActTables, levelId: number, act?: number): LevelInfo {
+  const row = tables.levels.rows.find(candidate => Number(cell(tables.levels, candidate, 'Id')) === levelId)
+  if (row === undefined) throw new Error(`Levels.txt has no row with Id ${String(levelId)}`)
+  const paletteIndex = Number(cell(tables.levels, row, 'Pal'))
+  const levelTypeId = cell(tables.levels, row, 'LevelType')
+
+  const typeRow = tables.lvltypes.rows.find(candidate => cell(tables.lvltypes, candidate, 'Id') === levelTypeId)
+  if (typeRow === undefined) throw new Error(`LvlTypes.txt has no row with Id ${levelTypeId} (level ${String(levelId)})`)
+
+  const preset = tables.lvlprest.rows.filter(candidate => Number(cell(tables.lvlprest, candidate, 'LevelId')) === levelId)
+  if (preset.length === 0) throw new Error(`LvlPrest.txt has no row with LevelId ${String(levelId)}`)
+
+  const dt1Mask = Number(cell(tables.lvlprest, preset[0]!, 'Dt1Mask'))
+  const dt1Names: string[] = []
+  for (let slot = 1; slot <= 32; slot += 1) {
+    const value = cell(tables.lvltypes, typeRow, `File ${String(slot)}`)
+    if (value === '' || value === '0') continue
+    // The mask is indexed by the slot's position in the file list, not by the
+    // position of the surviving entries.
+    if ((dt1Mask & (1 << (slot - 1))) === 0) continue
+    dt1Names.push(tileMemberPath(value))
+  }
+
+  const ds1Names: string[] = []
+  for (const presetRow of preset) {
+    for (let file = 1; file <= 6; file += 1) {
+      const value = cell(tables.lvlprest, presetRow, `File${String(file)}`)
+      if (value === '' || value === '0') continue
+      ds1Names.push(tileMemberPath(value))
+    }
+  }
+
+  return {
+    act: act ?? Number(cell(tables.levels, row, 'Act')) + 1,
+    levelName: cell(tables.levels, row, 'Name'),
+    levelId,
+    paletteIndex,
+    levelTypeName: cell(tables.lvltypes, typeRow, 'Name'),
+    ds1Names,
+    dt1Names,
+    dt1Mask,
+    sizeX: Number(cell(tables.levels, row, 'SizeX')),
+    sizeY: Number(cell(tables.levels, row, 'SizeY')),
+    paletteName: `data\\global\\palette\\act${String(paletteIndex + 1)}\\pal.pl2`,
+  }
+}
+
+/**
+ * Resolve one act's town.
+ *
+ * @param tables - the loaded tables.
+ * @param act - act number, 1..5.
+ * @returns the town description.
+ */
+export function resolveActTown(tables: ActTables, act: number): LevelInfo {
+  const row = tables.levels.rows.find(candidate => cell(tables.levels, candidate, 'Name') === `Act ${String(act)} - Town`)
+  if (row === undefined) throw new Error(`Levels.txt has no "Act ${String(act)} - Town" row`)
+  return resolveLevel(tables, Number(cell(tables.levels, row, 'Id')), act)
+}
+
+/** A resolved level with its decoded assets. */
+export interface LoadedActTown {
+  /** The resolution result. */
+  readonly town: LevelInfo
+  /** The decoded DS1 quadrants. */
+  readonly levels: readonly Ds1[]
+  /** The decoded DT1 libraries, in file-list order. */
+  readonly libraries: readonly Dt1[]
+  /** The act palette. */
+  readonly palette: Pl2
+  /** Total cells across the quadrants. */
+  readonly cells: number
+}
+
+/**
+ * Resolve and decode one act's town.
+ *
+ * @param archives - the mounted archives.
+ * @param tables - the loaded tables.
+ * @param act - act number, 1..5.
+ * @returns the town with assets.
+ */
+export async function loadActTown(
+  archives: MountedArchives,
+  tables: ActTables,
+  act: number,
+): Promise<LoadedActTown> {
+  return loadLevel(archives, tables, resolveActTown(tables, act))
+}
+
+/**
+ * Resolve a level type's DT1 libraries without requiring preset rows.
+ *
+ * `resolveLevel` needs `LvlPrest` rows because it also wants DS1 files; the
+ * generators need only the tile libraries, and 101 of the game's 136 levels have
+ * no preset rows at all.
+ *
+ * @param tables - the loaded tables.
+ * @param levelId - `Levels.txt` `Id`.
+ * @returns the library list.
+ */
+export function resolveLevelLibraries(tables: ActTables, levelId: number): LevelLibraries {
+  const row = tables.levels.rows.find(candidate => Number(cell(tables.levels, candidate, 'Id')) === levelId)
+  if (row === undefined) throw new Error(`Levels.txt has no row with Id ${String(levelId)}`)
+  const typeRow = tables.lvltypes.rows.find(candidate => cell(tables.lvltypes, candidate, 'Id') === cell(tables.levels, row, 'LevelType'))
+  if (typeRow === undefined) throw new Error(`LvlTypes.txt has no row for level ${String(levelId)}`)
+  const preset = tables.lvlprest.rows.filter(candidate => Number(cell(tables.lvlprest, candidate, 'LevelId')) === levelId)
+  const dt1Mask = preset.length === 0 ? null : Number(cell(tables.lvlprest, preset[0]!, 'Dt1Mask'))
+  const dt1Names: string[] = []
+  for (let slot = 1; slot <= 32; slot += 1) {
+    const value = cell(tables.lvltypes, typeRow, `File ${String(slot)}`)
+    if (value === '' || value === '0') continue
+    if (dt1Mask !== null && (dt1Mask & (1 << (slot - 1))) === 0) continue
+    dt1Names.push(tileMemberPath(value))
+  }
+  return { levelTypeName: cell(tables.lvltypes, typeRow, 'Name'), dt1Names, dt1Mask }
+}
+
+/**
+ * Decode a resolved level's assets.
+ *
+ * @param archives - the mounted archives.
+ * @param tables - the loaded tables (unused today; kept for symmetry with the
+ *   resolver so callers can pass both without re-deriving).
+ * @param town - the resolution result.
+ * @returns the level with assets.
+ */
+export async function loadLevel(
+  archives: MountedArchives,
+  tables: ActTables,
+  town: LevelInfo,
+): Promise<LoadedActTown> {
+  void tables
+  const levels: Ds1[] = []
+  for (const name of town.ds1Names) levels.push(decodeDs1(await archives.read(name)))
+  const libraries: Dt1[] = []
+  for (const name of town.dt1Names) libraries.push(decodeDt1(await archives.read(name)))
+  const palette = decodePl2(await archives.read(town.paletteName))
+  return {
+    town,
+    levels,
+    libraries,
+    palette,
+    cells: levels.reduce((sum, level) => sum + level.width * level.height, 0),
+  }
+}
diff --git a/src/game/animation.ts b/src/game/animation.ts
new file mode 100644
index 0000000..4b45638
--- /dev/null
+++ b/src/game/animation.ts
@@ -0,0 +1,123 @@
+/**
+ * Actor animation: direction-indexed frame playback at the simulation rate.
+ *
+ * Both games drive animation off the same 25 Hz tick the simulation runs on, so
+ * playback is counted in ticks rather than milliseconds — an animation that
+ * looked right at 60 fps would run at the wrong speed and, worse, at a
+ * different speed on different machines.
+ *
+ * The module is deliberately format-agnostic: a clip is just "frames per
+ * direction plus a tick rate". Diablo I's direction-major CL2 sheets, Diablo II's
+ * per-direction DC6 sheets and its composite DCC animations all reduce to that,
+ * and Diablo's own convention is preserved in the direction *index* (0 = south,
+ * turning west), which is also the group order inside those files.
+ */
+
+/** One playable animation: frames per direction, plus timing. */
+export interface ActorClip {
+  /** Clip name (`walk`, `stand`, `attack`, …). */
+  readonly name: string
+  /** Frames per direction in play order; index 0 is south. */
+  readonly directions: readonly (readonly unknown[])[]
+  /** Ticks between frames (25 ticks per second). */
+  readonly ticksPerFrame: number
+  /** Whether the clip advances past its last frame. */
+  readonly loop: boolean
+}
+
+/** Convenience alias so callers can stay generic over the frame type. */
+export type ActorAnimatorFrame<TFrame> = TFrame | undefined
+
+/**
+ * Plays one clip at a time, for one direction at a time.
+ *
+ * @typeParam TFrame - the frame handle the renderer draws (an atlas placement in
+ * practice; kept generic here so the animator has no rendering dependency).
+ */
+export class ActorAnimator<TFrame> {
+  private readonly clips = new Map<string, ActorClip>()
+  private current: ActorClip | null = null
+  private direction = 0
+  private elapsed = 0
+  private index = 0
+
+  /**
+   * Register a clip. A later registration under the same name replaces it.
+   *
+   * @param clip - the clip to register.
+   */
+  add(clip: ActorClip): void {
+    this.clips.set(clip.name, clip)
+  }
+
+  /** The clip currently playing, if any. */
+  get clipName(): string | null {
+    return this.current?.name ?? null
+  }
+
+  /** Current facing (0 = south, turning west). */
+  get facing(): number {
+    return this.direction
+  }
+
+  /** Index of the frame being shown. */
+  get frameIndex(): number {
+    return this.index
+  }
+
+  /**
+   * Switch clips, restarting only when the clip actually changes.
+   *
+   * A walk cycle that restarts every time the key is re-pressed stutters, so
+   * re-requesting the current clip is a no-op — the same rule the games use.
+   *
+   * @param name - clip name; unknown names are ignored.
+   * @param direction - facing to play it in.
+   */
+  play(name: string, direction: number): void {
+    const clip = this.clips.get(name)
+    if (clip === undefined) return
+    this.direction = direction
+    if (this.current === clip) return
+    this.current = clip
+    this.elapsed = 0
+    this.index = 0
+  }
+
+  /**
+   * Advance one simulation tick.
+   *
+   * @param direction - facing to keep playing in.
+   */
+  tick(direction: number): void {
+    this.direction = direction
+    const clip = this.current
+    if (clip === null) return
+    const frames = clip.directions[direction]
+    const count = frames?.length ?? 0
+    if (count <= 1 || clip.ticksPerFrame <= 0) return
+    this.elapsed += 1
+    if (this.elapsed < clip.ticksPerFrame) return
+    this.elapsed = 0
+    if (this.index + 1 < count) {
+      this.index += 1
+      return
+    }
+    this.index = clip.loop ? 0 : count - 1
+  }
+
+  /**
+   * The frame to draw now.
+   *
+   * @returns the frame handle, or undefined when nothing is playing — including
+   * when the current direction has no frames (a sheet with fewer directions than
+   * the actor was asked for).
+   */
+  frame(): ActorAnimatorFrame<TFrame> {
+    const clip = this.current
+    if (clip === null) return undefined
+    const frames = clip.directions[this.direction]
+    if (frames === undefined || frames.length === 0) return undefined
+    return frames[Math.min(this.index, frames.length - 1)] as TFrame
+  }
+}
diff --git a/src/game/character.ts b/src/game/character.ts
new file mode 100644
index 0000000..bdb3025
--- /dev/null
+++ b/src/game/character.ts
@@ -0,0 +1,290 @@
+/**
+ * Compositing Diablo II's character and object animations.
+ *
+ * A `DCC` file holds one *layer* of an animation (a head, a torso, a leg, a
+ * shield), and a `COF` file says which layers make up a given animation and in
+ * what order they stack. Neither is drawable alone: the file that says "this is
+ * the Sorceress walking" is the COF, and the pixels are in eight DCCs beside it.
+ *
+ * This module joins the two into the plain `SpriteSheet` the renderer already
+ * consumes, so the rest of the engine treats a character exactly like a tile
+ * atlas. It reuses the path convention the verification script proved out:
+ * a layer record names no file — it carries a *composite type* (which body part)
+ * and a *weapon class*, and the COF's own name carries the animation and weapon
+ * codes, so the sprite path is
+ * `<root><component>/<token><component><variant><animation><weapon>.dcc`.
+ * `<variant>` is an armour/object tier code that lives in the item tables rather
+ * than the COF; the lexicographically first candidate is taken, and the chosen
+ * members are reported so the choice is visible instead of implied.
+ */
+import type { MpqArchive } from '../mpq/archive.ts'
+import type { MountedArchives } from '../mpq/mount.ts'
+import { decodeCof, cofLayerOrder } from '../formats/cof.ts'
+import type { CofFile } from '../formats/cof.ts'
+import { decodeDcc } from '../formats/dcc.ts'
+import type { DccFile } from '../formats/dcc.ts'
+import type { SpriteFrame, SpriteSheet } from '../formats/sprite.ts'
+
+/** Composite-type index → component directory, as the archives name them. */
+const COMPONENTS: readonly string[] = ['hd', 'tr', 'lg', 'ra', 'la', 'rh', 'lh', 'sh', 's1', 's2']
+
+/** A composited animation, ready to draw. */
+export interface CharacterSheet {
+  /** One group per direction, frames in animation order. */
+  readonly sheet: SpriteSheet
+  /** Directions in the COF (16 for characters, fewer for objects). */
+  readonly directions: number
+  /** Frames per direction. */
+  readonly framesPerDirection: number
+  /** Layers the COF declared. */
+  readonly layers: number
+  /** Layer/direction combinations skipped because a sprite was missing. */
+  readonly skipped: number
+  /** The DCC members that were decoded, for provenance. */
+  readonly members: readonly string[]
+  /** Non-fatal observations worth reporting. */
+  readonly notes: readonly string[]
+}
+
+/**
+ * Find the sprite a COF layer draws.
+ *
+ * @param names - the archive's name list.
+ * @param root - directory shared by the COF and its art, e.g. `data\\global\\chars\\so\\`.
+ * @param token - class or object code, e.g. `so`.
+ * @param animation - two-letter animation code from the COF name, e.g. `wl`.
+ * @param weapon - weapon-class code from the COF name, e.g. `hth`.
+ * @param component - component directory for the layer's composite type.
+ * @returns the member name, or undefined.
+ */
+function findLayerSprite(
+  names: readonly string[],
+  root: string,
+  token: string,
+  animation: string,
+  weapon: string,
+  component: string,
+): string | undefined {
+  const prefix = `${root}${component}\\${token}${component}`
+  const suffix = `${animation}${weapon}.dcc`
+  const hits = names.filter(name => name.toLowerCase().startsWith(prefix.toLowerCase())
+    && name.toLowerCase().endsWith(suffix.toLowerCase()))
+  hits.sort()
+  return hits[0]
+}
+
+/**
+ * Blit one layer onto a bigger canvas.
+ *
+ * The frames are palette-indexed with a transparency mask, so compositing is a
+ * "masked copy": later layers paint over earlier ones exactly where they have
+ * pixels, which is the same rule the DT1 tile compositor uses.
+ *
+ * @param target - destination frame (its buffers are written).
+ * @param source - layer frame.
+ * @param atX - destination x.
+ * @param atY - destination y.
+ */
+function blit(target: { indices: Uint8Array; mask: Uint8Array; width: number; height: number }, source: SpriteFrame, atX: number, atY: number): void {
+  for (let y = 0; y < source.height; y += 1) {
+    const ty = atY + y
+    if (ty < 0 || ty >= target.height) continue
+    for (let x = 0; x < source.width; x += 1) {
+      const at = y * source.width + x
+      if (source.mask[at] === 0) continue
+      const tx = atX + x
+      if (tx < 0 || tx >= target.width) continue
+      const to = ty * target.width + tx
+      target.indices[to] = source.indices[at]!
+      target.mask[to] = 1
+    }
+  }
+}
+
+/**
+ * Load and composite one animation.
+ *
+ * @param archives - the mounted archives.
+ * @param token - class or object code, e.g. `so` for the Sorceress.
+ * @param animation - animation code from the COF name, e.g. `wl` (walk) or `nu` (neutral).
+ * @param weapon - weapon class, e.g. `hth` for unarmed.
+ * @returns the composited animation.
+ */
+export async function loadCharacterSheet(
+  archives: MountedArchives,
+  token: string,
+  animation: string,
+  weapon: string,
+): Promise<CharacterSheet> {
+  const lower = token.toLowerCase()
+  const root = `data\\global\\chars\\${lower}\\`
+  const cofMember = `${root}cof\\${lower}${animation}${weapon}.cof`
+  const cofBytes = await archives.read(cofMember)
+  const cof: CofFile = decodeCof(cofBytes)
+
+  const names = await archives.listFiles()
+  const notes: string[] = []
+  const members: string[] = []
+  const sprites: (DccFile | null)[] = []
+  for (const layer of cof.layers) {
+    const component = COMPONENTS[layer.type]
+    if (component === undefined) {
+      notes.push(`layer type ${String(layer.type)} has no component directory`)
+      sprites.push(null)
+      continue
+    }
+    const member = findLayerSprite(names, root, lower, animation, weapon, component)
+    if (member === undefined) {
+      notes.push(`no sprite for component ${component} (${animation}${weapon})`)
+      sprites.push(null)
+      continue
+    }
+    try {
+      sprites.push(decodeDcc(await archives.read(member)))
+      members.push(member)
+    } catch (err) {
+      notes.push(`${member}: ${(err as Error).message}`)
+      sprites.push(null)
+    }
+  }
+
+  const groups: { frames: SpriteFrame[] }[] = []
+  let skipped = 0
+  for (let direction = 0; direction < cof.numberOfDirections; direction += 1) {
+    const frames: SpriteFrame[] = []
+    for (let index = 0; index < cof.framesPerDirection; index += 1) {
+      // Union box across the layers that have art for this direction, so every
+      // layer keeps its position in sprite space.
+      let left = Number.POSITIVE_INFINITY
+      let top = Number.POSITIVE_INFINITY
+      let right = Number.NEGATIVE_INFINITY
+      let bottom = Number.NEGATIVE_INFINITY
+      let placedCount = 0
+      for (let layer = 0; layer < cof.layers.length; layer += 1) {
+        const sprite = sprites[layer]
+        if (sprite === null || sprite === undefined) continue
+        const layerDirection = sprite.directions[direction % sprite.directions.length]
+        const frame = layerDirection?.frames[index]
+        if (frame === undefined) { skipped += 1; continue }
+        left = Math.min(left, layerDirection!.box.left)
+        top = Math.min(top, layerDirection!.box.top)
+        right = Math.max(right, layerDirection!.box.left + layerDirection!.box.width)
+        bottom = Math.max(bottom, layerDirection!.box.top + layerDirection!.box.height)
+        placedCount += 1
+      }
+      if (placedCount === 0) {
+        frames.push({ width: 1, height: 1, indices: new Uint8Array(1), mask: new Uint8Array(1) })
+        continue
+      }
+      const boxLeft = Math.round(left)
+      const boxTop = Math.round(top)
+      const width = Math.max(1, Math.round(right) - boxLeft)
+      const height = Math.max(1, Math.round(bottom) - boxTop)
+      const composed: SpriteFrame = {
+        width, height, indices: new Uint8Array(width * height), mask: new Uint8Array(width * height),
+      }
+      // Draw in the COF's own back-to-front order for this direction and frame;
+      // the priority table is the authority on what covers what.
+      const order = cofLayerOrder(cof, direction, index)
+      const ordered = order
+        .map(layerIndex => { const sprite = sprites[layerIndex]; return { layerIndex, sprite } })
+        .filter(entry => entry.sprite !== null && entry.sprite !== undefined)
+      for (const entry of ordered) {
+        const sprite = entry.sprite as DccFile
+        const layerDirection = sprite.directions[direction % sprite.directions.length]
+        const frame = layerDirection?.frames[index]
+        if (frame === undefined) continue
+        blit(composed, frame.frame, Math.round(layerDirection!.box.left) - boxLeft, Math.round(layerDirection!.box.top) - boxTop)
+      }
+      frames.push(composed)
+    }
+    groups.push({ frames })
+  }
+
+  return {
+    sheet: { groups, width: null },
+    directions: cof.numberOfDirections,
+    framesPerDirection: cof.framesPerDirection,
+    layers: cof.layers.length,
+    skipped,
+    members,
+    notes,
+  }
+}
+
+/**
+ * The engine's 64-direction space → COF direction tables.
+ *
+ * Ported from OpenDiablo2 `d2fileformats/d2cof/cof_dir_lookup.go` (`Dir64ToCof`),
+ * which reproduces the engine's own lookup: the mapping is **not**
+ * `floor(dir64 * n / 64)` — it is five literal tables, and they are uneven in
+ * places (16 directions: `dir64` 0 and 1 → 0, 2..5 → 1, 6..9 → 2, …).
+ */
+const DIR64_TO_COF: Readonly<Record<number, readonly number[]>> = {
+  4: [
+    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0,
+  ],
+  8: [
+    0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2,
+    2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
+    4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6,
+    6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0,
+  ],
+  16: [
+    0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4,
+    4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8,
+    8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12,
+    12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 0, 0,
+  ],
+  32: [
+    0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8,
+    8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16,
+    16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24,
+    24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 30, 30, 31, 31, 0,
+  ],
+  64: Array.from({ length: 64 }, (_, index) => index),
+}
+
+/**
+ * Map a 64-direction space direction to a COF direction, the way the engine does.
+ *
+ * @param direction - 0..63.
+ * @param directions - directions in the COF (4, 8, 16, 32 or 64).
+ * @returns the COF direction index, 0 when the count is not one the engine uses.
+ */
+export function dir64ToCof(direction: number, directions: number): number {
+  const table = DIR64_TO_COF[directions]
+  if (table === undefined) return 0
+  const index = ((Math.trunc(direction) % 64) + 64) % 64
+  return table[index] ?? 0
+}
+
+/**
+ * Map a screen facing to a COF direction.
+ *
+ * The page's input is eight screen directions starting north, which in the
+ * engine's 64-direction space are the eight multiples of 8 — so this is
+ * {@link dir64ToCof} applied to `facing * 8`. Keeping the conversion in the
+ * engine's terms means the result stays right if the facing ever gets finer
+ * (mouse aiming, 16-way input), where the plain "two steps per facing" reading
+ * would not: with eight facings the two agree, which
+ * `npm run verify:dcc` checks for every direction count.
+ *
+ * @param facing - 0 = north, clockwise, 0..7.
+ * @param directions - directions in the COF.
+ * @returns the direction index.
+ */
+export function facingToDirection(facing: number, directions: number): number {
+  return dir64ToCof(facing * 8, directions)
+}
+
+/** Decode one DCC member, for callers that only need its first frame. */
+export async function firstFrameOf(archive: MpqArchive, member: string): Promise<SpriteFrame | undefined> {
+  const file = archive.find(member)
+  if (file === undefined) return undefined
+  const dcc = decodeDcc(await archive.read(file))
+  return dcc.directions[0]?.frames[0]?.frame
+}
diff --git a/src/game/combat.ts b/src/game/combat.ts
new file mode 100644
index 0000000..ff37168
--- /dev/null
+++ b/src/game/combat.ts
@@ -0,0 +1,676 @@
+/**
+ * Combat sandbox: monsters, melee, resources and experience, at the game's tick
+ * rate.
+ *
+ * The module is deliberately free of rendering and input concerns. It advances
+ * one 25 Hz tick at a time from a small input record and a collision predicate,
+ * which is what allows the whole system to be simulated headlessly in a test —
+ * combat that can only be verified by looking at the screen is combat that will
+ * be broken most of the time.
+ *
+ * Numbers come from data tables (see `tables.ts`), never from constants baked
+ * into the AI: a monster's health, damage, speed and aggro range are its table
+ * row, so swapping in the real `MonStats.txt` changes behaviour without touching
+ * code.
+ *
+ * What this is *not*: it is not Diablo II's combat model. Real damage involves
+ * attack rating versus defence, hit recovery, block, resistances, elemental
+ * damage and per-skill formulas. This is the skeleton those formulas plug into —
+ * the states, cooldowns, resource pools and event stream are the parts that need
+ * to exist first, and they are the parts whose shape is independent of the exact
+ * arithmetic.
+ */
+import { numberCell, textCell } from './tables.ts'
+import type { DataTable } from './tables.ts'
+
+/** Movement request and intent for one tick. */
+export interface CombatInput {
+  /** Normalized movement, screen axes (y grows downward). */
+  readonly movement: { readonly x: number; readonly y: number }
+  /** Whether the attack control is held this tick. */
+  readonly attack: boolean
+}
+
+/**
+ * What the simulation needs from the world it moves in.
+ *
+ * The predicate reports *how many* solid sub-tiles a position overlaps rather
+ * than a yes/no, because movement needs the count: a body that is already
+ * overlapping something (a bad spawn, a tile that turned solid under it) must
+ * still be able to walk out, and the rule that allows it is "never make the
+ * overlap worse". A boolean cannot express that, and a body stuck forever is a
+ * far worse failure than one that briefly clips a corner.
+ */
+export interface CombatTerrain {
+  /**
+   * Count solid sub-tiles overlapping a body position.
+   *
+   * @param x - body centre x.
+   * @param y - body centre y.
+   * @returns the overlap count (0 = clear ground).
+   */
+  readonly overlap: (x: number, y: number) => number
+}
+
+/** Tuning that is not per-monster. */
+export interface CombatOptions {
+  /** Player walk speed in pixels per second. */
+  readonly playerSpeed: number
+  /** Player melee reach in pixels. */
+  readonly playerReach: number
+  /** Ticks between player attacks. */
+  readonly playerCooldownTicks: number
+  /** Player damage per hit. */
+  readonly playerDamage: number
+  /** Mana spent per attack (0 disables the cost). */
+  readonly playerManaPerAttack: number
+  /** Ticks before a dead player is restored, at full resources. */
+  readonly respawnTicks: number
+}
+
+/** One monster's immutable numbers, read from a table row. */
+export interface MonsterStats {
+  /** Identifier, as written in the table. */
+  readonly id: string
+  /** Display name. */
+  readonly name: string
+  /** Maximum health. */
+  readonly hp: number
+  /** Damage per hit. */
+  readonly damage: number
+  /** Ticks between attacks. */
+  readonly cooldownTicks: number
+  /** Reach in pixels. */
+  readonly reach: number
+  /** Distance at which the monster notices the player, in pixels. */
+  readonly aggroRadius: number
+  /** Speed in pixels per second. */
+  readonly speed: number
+  /** Experience awarded on death. */
+  readonly xp: number
+}
+
+/** One monster's mutable state. */
+export interface Monster {
+  /** Stable index, for events and debugging. */
+  readonly index: number
+  /** Its table numbers. */
+  readonly stats: MonsterStats
+  /** World x. */
+  x: number
+  /** World y. */
+  y: number
+  /** Current health. */
+  hp: number
+  /** Ticks until it may attack again. */
+  cooldown: number
+  /** What it is doing. */
+  state: 'idle' | 'chase' | 'attack' | 'dead'
+  /** Facing (0 = south, turning west), for the renderer. */
+  facing: number
+  /** Ticks left of the hit flash, for the renderer. */
+  hitFlash: number
+  /** Ticks left of the death animation. */
+  corpseTicks: number
+}
+
+/** The player's combat-relevant state. */
+export interface CombatPlayer {
+  /** World x. */
+  x: number
+  /** World y. */
+  y: number
+  /** Current health. */
+  hp: number
+  /** Maximum health. */
+  maxHp: number
+  /** Current mana. */
+  mana: number
+  /** Maximum mana. */
+  maxMana: number
+  /** Character level. */
+  level: number
+  /** Experience accumulated. */
+  xp: number
+  /** Ticks until the next attack. */
+  cooldown: number
+  /** Facing (0 = south, turning west). */
+  facing: number
+  /** Whether the player is alive. */
+  alive: boolean
+  /** Ticks left until respawn while dead. */
+  respawnIn: number
+  /** Ticks left of the swing animation, for the renderer. */
+  swingTicks: number
+}
+
+/** Something worth telling the player (and the renderer) about. */
+export interface CombatEvent {
+  /** Event kind. */
+  readonly kind: 'playerHit' | 'monsterHit' | 'kill' | 'levelUp' | 'playerDeath' | 'respawn' | 'noMana'
+  /** World x the event happened at. */
+  readonly x: number
+  /** World y the event happened at. */
+  readonly y: number
+  /** Magnitude (damage), when meaningful. */
+  readonly amount?: number
+  /** Text to float above the point, when meaningful. */
+  readonly text?: string
+  /** Subject identity (a monster's table id on a kill, for quest counters). */
+  readonly subjectId?: string
+}
+
+/** The whole simulation state. */
+export interface CombatWorld {
+  /**
+   * The local player, for the single-player scene and every existing caller.
+   *
+   * In a networked game this is one of {@link CombatWorld.players}, and which one
+   * is a *view* decision: the simulation must not depend on it, which is why the
+   * state digest covers `players` in peer order and never this field.
+   *
+   * **Invariant:** this object is the same object as one entry of `players`. A
+   * world assembled by copying fields — a save being loaded, a snapshot being
+   * restored — breaks that unless {@link rebindPlayer} is called, and the symptom
+   * is a world that simulates one body while the screen draws another.
+   */
+  player: CombatPlayer
+  /**
+   * Every player in the world, in peer order, index 0 first.
+   *
+   * Monsters pick the nearest living entry, so two peers whose worlds hold the
+   * same players in the same order see the same monsters make the same choices.
+   */
+  players: CombatPlayer[]
+  /** Every monster, dead ones included until their corpse timer expires. */
+  monsters: Monster[]
+  /** Ticks simulated. */
+  tick: number
+  /** Events produced during the last tick (cleared each tick). */
+  events: CombatEvent[]
+  /** Monsters killed. */
+  kills: number
+}
+
+/** Defaults that keep the sandbox playable when a table is thin. */
+const DEFAULTS = {
+  hp: 20,
+  damage: 3,
+  cooldownTicks: 25,
+  reach: 40,
+  aggroRadius: 220,
+  speed: 90,
+  xp: 10,
+} as const
+
+/**
+ * Read one monster's numbers from a table row.
+ *
+ * @param row - the record.
+ * @param rowIndex - row position, used to build a fallback id.
+ * @returns the stats.
+ */
+export function monsterStatsFromRow(row: Readonly<Record<string, string>>, rowIndex: number): MonsterStats {
+  return {
+    id: textCell(row, 'Id', `monster${String(rowIndex)}`),
+    name: textCell(row, 'Name', textCell(row, 'Id', `Monster ${String(rowIndex)}`)),
+    hp: numberCell(row, 'HP', DEFAULTS.hp),
+    damage: numberCell(row, 'Damage', DEFAULTS.damage),
+    cooldownTicks: numberCell(row, 'CooldownTicks', DEFAULTS.cooldownTicks),
+    reach: numberCell(row, 'Reach', DEFAULTS.reach),
+    aggroRadius: numberCell(row, 'AggroRadius', DEFAULTS.aggroRadius),
+    speed: numberCell(row, 'Speed', DEFAULTS.speed),
+    xp: numberCell(row, 'XP', DEFAULTS.xp),
+  }
+}
+
+/**
+ * Read every monster definition in a table.
+ *
+ * @param table - a `MonStats`-shaped table.
+ * @returns the definitions.
+ */
+export function monsterStatsFromTable(table: DataTable): MonsterStats[] {
+  return table.rows.map((row, index) => monsterStatsFromRow(row, index))
+}
+
+/**
+ * Read the experience required per level.
+ *
+ * @param table - an `Experience`-shaped table with a `Level` and an `XP` column.
+ * @returns required cumulative experience by level, index 1 = level 1.
+ */
+export function experienceTable(table: DataTable): number[] {
+  const levels: number[] = [0, 0]
+  for (const row of table.rows) {
+    const level = numberCell(row, 'Level', 0)
+    if (level < 1) continue
+    levels[level] = numberCell(row, 'XP', 0)
+  }
+  for (let level = 2; level < levels.length; level += 1) {
+    levels[level] = Math.max(levels[level] ?? 0, levels[level - 1] ?? 0)
+  }
+  return levels
+}
+
+/**
+ * Create a world with a player at a position.
+ *
+ * @param x - player x.
+ * @param y - player y.
+ * @param maxHp - starting maximum health.
+ * @param maxMana - starting maximum mana.
+ * @returns the world.
+ */
+export function createWorld(x: number, y: number, maxHp = 60, maxMana = 30): CombatWorld {
+  const player = createPlayer(x, y, maxHp, maxMana)
+  return {
+    player,
+    players: [player],
+    monsters: [],
+    tick: 0,
+    events: [],
+    kills: 0,
+  }
+}
+
+/**
+ * Create one player body.
+ *
+ * @param x - x.
+ * @param y - y.
+ * @param maxHp - starting maximum health.
+ * @param maxMana - starting maximum mana.
+ * @returns the player.
+ */
+export function createPlayer(x: number, y: number, maxHp = 60, maxMana = 30): CombatPlayer {
+  return {
+    x, y, hp: maxHp, maxHp, mana: maxMana, maxMana,
+    level: 1, xp: 0, cooldown: 0, facing: 0, alive: true, respawnIn: 0, swingTicks: 0,
+  }
+}
+
+/**
+ * Re-establish the invariant that the local player is in the player list.
+ *
+ * The combat tick drives `players` while the scene and the renderer read
+ * `player`; a world built by spreading one object over another ends up with a
+ * fresh `player` and the *previous* `players` array, so those two would drift
+ * apart on the next tick. A loaded save is a single-player world by definition,
+ * so the list becomes exactly this one player.
+ *
+ * @param world - the world to repair (mutated in place).
+ * @returns the same world.
+ */
+export function rebindPlayer(world: CombatWorld): CombatWorld {
+  world.players = [world.player]
+  return world
+}
+
+/**
+ * Add another player to the world, as a joining peer would.
+ *
+ * The new body is appended, so its index is its peer index and every peer agrees
+ * on the order. Nothing about the joining player is derived from the local view.
+ *
+ * @param world - the world.
+ * @param x - spawn x.
+ * @param y - spawn y.
+ * @param maxHp - starting maximum health.
+ * @param maxMana - starting maximum mana.
+ * @returns the player that was added.
+ */
+export function addPlayer(world: CombatWorld, x: number, y: number, maxHp = 60, maxMana = 30): CombatPlayer {
+  const player = createPlayer(x, y, maxHp, maxMana)
+  world.players.push(player)
+  return player
+}
+
+/**
+ * The player a monster should go for: the nearest of this tick's targets.
+ *
+ * Nearest rather than "player 0" because a monster that ignores the peer standing
+ * on top of it reads as broken, and because the choice has to be a pure function
+ * of the world for two peers to agree.
+ *
+ * @param monster - the monster choosing.
+ * @param targets - the players it may attack.
+ * @returns the target, or null when there is none.
+ */
+function nearestTarget(monster: Monster, targets: readonly CombatPlayer[]): CombatPlayer | null {
+  let best: CombatPlayer | null = null
+  let bestDistance = Number.POSITIVE_INFINITY
+  for (const candidate of targets) {
+    const distance = Math.hypot(candidate.x - monster.x, candidate.y - monster.y)
+    if (distance < bestDistance) {
+      bestDistance = distance
+      best = candidate
+    }
+  }
+  return best
+}
+
+/**
+ * Place monsters around a point, skipping unwalkable spots.
+ *
+ * Spawns are rejected rather than nudged: dropping a monster into a wall because
+ * nothing better was found is how units end up permanently stuck, and the caller
+ * can see the shortfall in the return value.
+ *
+ * @param world - the world to populate.
+ * @param stats - the definitions to spawn from.
+ * @param count - how many to spawn.
+ * @param around - spawn centre.
+ * @param spread - spawn radius in pixels.
+ * @param terrain - collision predicate.
+ * @returns how many were actually placed.
+ */
+export function spawnMonsters(
+  world: CombatWorld,
+  stats: readonly MonsterStats[],
+  count: number,
+  around: { readonly x: number; readonly y: number },
+  spread: number,
+  terrain: CombatTerrain,
+): number {
+  if (stats.length === 0) return 0
+  let placed = 0
+  let attempt = 0
+  while (placed < count && attempt < count * 24) {
+    attempt += 1
+    // A deterministic spiral keeps spawns reproducible, which is what makes a
+    // failing test repeatable.
+    const angle = attempt * 2.399963
+    const radius = spread * Math.sqrt(attempt / (count * 24))
+    const x = around.x + Math.cos(angle) * radius
+    const y = around.y + Math.sin(angle) * radius
+    if (terrain.overlap(x, y) > 0) continue
+    const definition = stats[placed % stats.length]!
+    world.monsters.push({
+      index: world.monsters.length,
+      stats: definition,
+      x, y,
+      hp: definition.hp,
+      cooldown: 0,
+      state: 'idle',
+      facing: 0,
+      hitFlash: 0,
+      corpseTicks: 0,
+    })
+    placed += 1
+  }
+  return placed
+}
+
+/**
+ * Direction index (0 = south, turning west) for a vector.
+ *
+ * @param dx - horizontal component.
+ * @param dy - vertical component.
+ * @returns the facing.
+ */
+function facingOf(dx: number, dy: number): number {
+  const sx = Math.sign(dx)
+  const sy = Math.sign(dy)
+  if (sx === 0 && sy === 0) return 0
+  if (sx === 0) return sy > 0 ? 0 : 4
+  if (sy === 0) return sx > 0 ? 6 : 2
+  if (sx < 0) return sy > 0 ? 1 : 3
+  return sy > 0 ? 7 : 5
+}
+
+/**
+ * Move a body one tick, sliding along blocked axes.
+ *
+ * @param from - current position.
+ * @param dx - desired delta x.
+ * @param dy - desired delta y.
+ * @param terrain - collision predicate.
+ * @returns the new position.
+ */
+function moveWithCollision(
+  from: { readonly x: number; readonly y: number },
+  dx: number,
+  dy: number,
+  terrain: CombatTerrain,
+): { x: number; y: number } {
+  let { x, y } = from
+  const current = terrain.overlap(x, y)
+  // Axis-separated: a blocked axis stops while the other slides along the wall.
+  if (dx !== 0 && terrain.overlap(x + dx, y) <= current) x += dx
+  if (dy !== 0 && terrain.overlap(x, y + dy) <= current) y += dy
+  return { x, y }
+}
+
+/**
+ * Apply damage to one monster from any source (a melee swing, a projectile).
+ *
+ * Kill handling lives here rather than at each call site so experience, the kill
+ * counter, the corpse timer and the event stream behave identically however the
+ * damage arrived — which is the difference between "the skill works" and "the
+ * skill works but kills do not count".
+ *
+ * @param world - the world.
+ * @param monsterIndex - which monster.
+ * @param amount - damage to apply.
+ * @param attacker - who dealt it; the killer is credited with the experience.
+ * Defaults to the local player, which is what a single-player caller means.
+ * @returns true when this damage killed it.
+ */
+export function damageMonster(world: CombatWorld, monsterIndex: number, amount: number, attacker: CombatPlayer = world.player): boolean {
+  const monster = world.monsters[monsterIndex]
+  if (monster === undefined || monster.state === 'dead') return false
+  monster.hp -= amount
+  monster.hitFlash = 4
+  world.events.push({ kind: 'monsterHit', x: monster.x, y: monster.y, amount })
+  if (monster.hp > 0) return false
+  monster.state = 'dead'
+  monster.corpseTicks = 100
+  world.kills += 1
+  world.events.push({ kind: 'kill', x: monster.x, y: monster.y, text: monster.stats.name, subjectId: monster.stats.id })
+  attacker.xp += monster.stats.xp
+  return true
+}
+
+/**
+ * Advance the simulation one tick for one player.
+ *
+ * @param world - the world to advance (mutated in place).
+ * @param input - this tick's movement and attack intent.
+ * @param options - non-per-monster tuning.
+ * @param terrain - collision predicate.
+ * @param xpTable - cumulative experience required per level, index 1 = level 1.
+ */
+export function tickCombat(
+  world: CombatWorld,
+  input: CombatInput,
+  options: CombatOptions,
+  terrain: CombatTerrain,
+  xpTable: readonly number[],
+): void {
+  tickCombatMulti(world, [input], options, terrain, xpTable)
+}
+
+/**
+ * Advance the simulation one tick for several players at once.
+ *
+ * One tick, not one per player: the tick counter, the event stream and the
+ * monster turn all happen once, while every player's own input is applied before
+ * the monsters act. Calling {@link tickCombat} once per player instead would run
+ * the monsters twice in a tick and desync two peers against each other.
+ *
+ * `inputs[i]` drives `players[i]`. A peer with no input this tick simply does not
+ * act — it does not fall back to someone else's controls.
+ *
+ * @param world - the world to advance (mutated in place).
+ * @param inputs - one input per player, in peer order.
+ * @param options - non-per-monster tuning.
+ * @param terrain - collision predicate.
+ * @param xpTable - cumulative experience required per level, index 1 = level 1.
+ */
+export function tickCombatMulti(
+  world: CombatWorld,
+  inputs: readonly CombatInput[],
+  options: CombatOptions,
+  terrain: CombatTerrain,
+  xpTable: readonly number[],
+): void {
+  world.tick += 1
+  world.events = []
+  // Who the monsters may attack is decided at the *start* of the tick. A player
+  // who comes back to life during this tick is therefore safe in it, and a world
+  // with nobody alive gives the monsters nothing to do: their cooldowns and the
+  // corpses hold still rather than running down against a player who cannot
+  // answer. Both rules exist to keep death and respawn reading the way they do in
+  // single player — you die, the world waits, you come back with a moment to move.
+  const targets = world.players.filter(player => player.alive)
+  for (let index = 0; index < inputs.length; index += 1) {
+    const player = world.players[index]
+    if (player === undefined) continue
+    tickPlayer(world, player, inputs[index]!, options, terrain, xpTable)
+  }
+  if (targets.length > 0) tickMonsters(world, options, terrain, targets)
+}
+
+/**
+ * Apply one player's turn: respawn, movement, attack.
+ *
+ * @param world - the world.
+ * @param player - the player acting.
+ * @param input - its input.
+ * @param options - non-per-monster tuning.
+ * @param terrain - collision predicate.
+ * @param xpTable - cumulative experience required per level.
+ */
+function tickPlayer(
+  world: CombatWorld,
+  player: CombatPlayer,
+  input: CombatInput,
+  options: CombatOptions,
+  terrain: CombatTerrain,
+  xpTable: readonly number[],
+): void {
+  if (!player.alive) {
+    player.respawnIn -= 1
+    if (player.respawnIn <= 0) {
+      player.alive = true
+      player.hp = player.maxHp
+      player.mana = player.maxMana
+      world.events.push({ kind: 'respawn', x: player.x, y: player.y })
+    }
+    return
+  }
+
+  if (player.cooldown > 0) player.cooldown -= 1
+  if (player.swingTicks > 0) player.swingTicks -= 1
+
+  // Movement first, so an attack this tick happens from where the player ended up.
+  const speed = options.playerSpeed / 25
+  const moved = moveWithCollision(player, input.movement.x * speed, input.movement.y * speed, terrain)
+  player.x = moved.x
+  player.y = moved.y
+  if (input.movement.x !== 0 || input.movement.y !== 0) {
+    player.facing = facingOf(input.movement.x, input.movement.y)
+  }
+
+  // Player melee: nearest living monster in reach, if the attack is ready.
+  if (input.attack && player.cooldown === 0) {
+    const cost = options.playerManaPerAttack
+    if (cost > 0 && player.mana < cost) {
+      world.events.push({ kind: 'noMana', x: player.x, y: player.y, text: 'no mana' })
+    } else {
+      player.mana = Math.max(0, player.mana - cost)
+      player.cooldown = options.playerCooldownTicks
+      player.swingTicks = Math.max(1, Math.floor(options.playerCooldownTicks / 2))
+      let target: Monster | null = null
+      let bestDistance = Number.POSITIVE_INFINITY
+      for (const monster of world.monsters) {
+        if (monster.state === 'dead') continue
+        const distance = Math.hypot(monster.x - player.x, monster.y - player.y)
+        if (distance <= options.playerReach && distance < bestDistance) {
+          bestDistance = distance
+          target = monster
+        }
+      }
+      if (target === null) {
+        world.events.push({ kind: 'playerHit', x: player.x, y: player.y, amount: 0, text: 'whiff' })
+      } else {
+        player.facing = facingOf(target.x - player.x, target.y - player.y)
+        target.hp -= options.playerDamage
+        target.hitFlash = 4
+        world.events.push({ kind: 'monsterHit', x: target.x, y: target.y, amount: options.playerDamage })
+        if (target.hp <= 0) {
+          target.state = 'dead'
+          target.corpseTicks = 100
+          world.kills += 1
+          world.events.push({ kind: 'kill', x: target.x, y: target.y, text: target.stats.name, subjectId: target.stats.id })
+          player.xp += target.stats.xp
+          // Level up while the threshold is crossed; the table is cumulative.
+          while (player.level + 1 < xpTable.length && player.xp >= (xpTable[player.level + 1] ?? Number.POSITIVE_INFINITY)) {
+            player.level += 1
+            player.maxHp += 10
+            player.maxMana += 5
+            player.hp = player.maxHp
+            player.mana = player.maxMana
+            world.events.push({ kind: 'levelUp', x: player.x, y: player.y, text: `level ${String(player.level)}` })
+          }
+        }
+      }
+    }
+  }
+
+}
+
+/**
+ * The monsters' turn: notice, close in, strike. Corpses decay.
+ *
+ * @param world - the world.
+ * @param options - non-per-monster tuning.
+ * @param terrain - collision predicate.
+ * @param targets - the players that were alive when the tick began.
+ */
+function tickMonsters(world: CombatWorld, options: CombatOptions, terrain: CombatTerrain, targets: readonly CombatPlayer[]): void {
+  for (const monster of world.monsters) {
+    if (monster.state === 'dead') {
+      if (monster.corpseTicks > 0) monster.corpseTicks -= 1
+      continue
+    }
+    if (monster.hitFlash > 0) monster.hitFlash -= 1
+    if (monster.cooldown > 0) monster.cooldown -= 1
+
+    const player = nearestTarget(monster, targets)
+    if (player === null) {
+      monster.state = 'idle'
+      continue
+    }
+    const dx = player.x - monster.x
+    const dy = player.y - monster.y
+    const distance = Math.hypot(dx, dy)
+
+    if (distance > monster.stats.aggroRadius) {
+      monster.state = 'idle'
+      continue
+    }
+    monster.facing = facingOf(dx, dy)
+    if (distance <= monster.stats.reach) {
+      monster.state = 'attack'
+      if (monster.cooldown === 0) {
+        monster.cooldown = monster.stats.cooldownTicks
+        player.hp -= monster.stats.damage
+        world.events.push({ kind: 'playerHit', x: player.x, y: player.y, amount: monster.stats.damage })
+        if (player.hp <= 0) {
+          player.hp = 0
+          player.alive = false
+          player.respawnIn = options.respawnTicks
+          world.events.push({ kind: 'playerDeath', x: player.x, y: player.y, text: 'you died' })
+        }
+      }
+      continue
+    }
+    monster.state = 'chase'
+    const step = monster.stats.speed / 25
+    const movedMonster = moveWithCollision(monster, (dx / distance) * step, (dy / distance) * step, terrain)
+    monster.x = movedMonster.x
+    monster.y = movedMonster.y
+  }
+}
diff --git a/src/game/d2map.ts b/src/game/d2map.ts
new file mode 100644
index 0000000..a2ee84e
--- /dev/null
+++ b/src/game/d2map.ts
@@ -0,0 +1,646 @@
+/**
+ * Diablo II's own map projection: a DS1 level plus the DT1 libraries it
+ * references, composited into something renderable and walkable.
+ *
+ * This is deliberately *not* `map.ts`. That module places one library on a
+ * rectangular grid, which is what the synthetic fixtures look like. Real Diablo
+ * II levels use an isometric lattice, and the difference is not cosmetic:
+ *
+ * 1. **Cells are diamonds.** A cell at `(cx, cy)` sits at
+ *    `((cx - cy) * 80, (cx + cy) * 40)` — the projection OpenDiablo2's viewport
+ *    calls `WorldToOrtho`. The 5×5 collision grid inside a cell is therefore
+ *    16×8 per sub-tile, not 32×32.
+ * 2. **A DS1 cell's `style` picks the library, not the tile.** Style indexes the
+ *    level type's `File 1..File 32` list (`LvlTypes.txt`), and each DT1 in that
+ *    list numbers its own tiles by `sequence` — so a lookup keyed on
+ *    `style:sequence` inside one merged library (what `map.ts` does) finds
+ *    nothing as soon as a level uses more than one library.
+ * 3. **Empty slots are explicit.** A cell carries a fixed number of wall slots
+ *    and most of them are placeholders: in Act 1's town, 4275 of 4674 wall
+ *    entries have `prop1 == 0`. Drawing them paints garbage, which is why the
+ *    reference renderer tests `prop1 != 0`.
+ * 4. **Walls hang above their cell.** A wall's art starts at a negative block
+ *    `y` and is shifted down by `-minBlockY` when decoded, so it must be drawn
+ *    at `cell + minBlockY + 80`; floors ignore that term entirely.
+ */
+import type { Ds1 } from '../formats/ds1.ts'
+import type { Dt1, Dt1Tile } from '../formats/dt1.ts'
+import type { SpriteFrame, SpriteSheet } from '../formats/sprite.ts'
+import { SUB_TILES_PER_TILE } from './map.ts'
+
+/** Cell width in screen pixels (the isometric diamond's width). */
+export const ORTHO_CELL_WIDTH = 80
+/** Cell height in screen pixels (half the diamond's width: a 2:1 projection). */
+export const ORTHO_CELL_HEIGHT = 40
+/** Sub-tile width in screen pixels. */
+export const ORTHO_SUB_TILE_WIDTH = ORTHO_CELL_WIDTH / SUB_TILES_PER_TILE
+/** Sub-tile height in screen pixels. */
+export const ORTHO_SUB_TILE_HEIGHT = ORTHO_CELL_HEIGHT / SUB_TILES_PER_TILE
+/** Horizontal shift applied to every tile bitmap (half a cell). */
+const TILE_ANCHOR_X = -80
+/** Vertical shift added to walls: the tail of `YAdjust = minBlockY + 80`. */
+const WALL_SURFACE_HEIGHT = 80
+/**
+ * DT1 `type` of a shadow tile.
+ *
+ * The engine asks for the shadow art with this type (`d2maprenderer/renderer.go`
+ * `getImageCacheRecord(style, sequence, 13, ...)`), so a DS1 shadow layer's
+ * reference is resolved against type 13 tiles, not against floors or walls.
+ */
+const SHADOW_TILE_TYPE = 13
+/**
+ * DT1 `type` of a floor tile.
+ *
+ * DS1 floor records carry no type field; the engine resolves them as DT1 type 0
+ * (`d2mapstamp/stamp.go` asks for `TileData(style, sequence, 0)`), and it is the
+ * only type a floor slot may draw.
+ */
+const FLOOR_TILE_TYPE = 0
+/**
+ * DS1 wall type of a roof tile.
+ *
+ * OpenDiablo2's tile-type enum puts `TileRoof` at 15 (`d2enum/tile.go`), and the
+ * engine draws roofs in a pass of their own, last of all, with a different
+ * vertical offset: `YAdjust = -roofHeight` instead of `minBlockY + 80`
+ * (`d2maprenderer/tile_cache.go`). A roof therefore has to stay out of the wall
+ * painter order and out of the wall offset rule.
+ */
+const ROOF_WALL_TYPE = 15
+/** One tile to draw, in screen pixels. */
+export interface IsoDraw {
+  /** Index into {@link IsoMapScene.frames}. */
+  readonly frameIndex: number
+  /** Screen x of the bitmap's left edge, origin applied. */
+  readonly x: number
+  /** Screen y of the bitmap's top edge, origin applied. */
+  readonly y: number
+  /** Cell coordinates, for depth sorting and entity insertion. */
+  readonly cellX: number
+  readonly cellY: number
+  /** Library index this tile came from, for diagnostics. */
+  readonly library: number
+  /** The library's tile index, for diagnostics. */
+  readonly tile: number
+}
+
+/** A renderable, walkable Diablo II level. */
+export interface IsoMapScene {
+  /** One frame per distinct tile this level actually uses. */
+  readonly frames: readonly SpriteFrame[]
+  /** The same frames as a sheet, ready for the atlas packer. */
+  readonly sheet: SpriteSheet
+  /** Cells horizontally. */
+  readonly cellsX: number
+  /** Cells vertically. */
+  readonly cellsY: number
+  /** Scene width in pixels, origin applied. */
+  readonly widthPx: number
+  /** Scene height in pixels, origin applied. */
+  readonly heightPx: number
+  /** Screen x added to every coordinate so the minimum is 0. */
+  readonly originX: number
+  /** Screen y added to every coordinate so the minimum is 0. */
+  readonly originY: number
+  /** Floor draws, in cell order. */
+  readonly floors: readonly IsoDraw[]
+  /** Wall draws, in painter's order (isometric depth). */
+  readonly walls: readonly IsoDraw[]
+  /**
+   * Roof draws, in painter's order.
+   *
+   * The engine paints roofs in a pass of their own, after everything else
+   * (`d2maprenderer/renderer.go` pass 4), so they must not be mixed into
+   * {@link IsoMapScene.walls}: a roof covers the floor, the walls *and* whatever
+   * walks under it.
+   */
+  readonly roofs: readonly IsoDraw[]
+  /** Collision grid, row-major, 1 = blocked, 5×5 per cell. */
+  readonly blocked: Uint8Array
+  /** Collision grid width in sub-tiles. */
+  readonly gridWidth: number
+  /** Collision grid height in sub-tiles. */
+  readonly gridHeight: number
+  /** References that resolved to no tile (missing library or sequence). */
+  readonly missingTiles: number
+  /**
+   * The unresolved references themselves, capped for display.
+   *
+   * Diablo II's DS1 files contain a few slots that reference nothing in any
+   * library — Act 2's town has one wall at `style 30`, a style no Act 2 library
+   * defines. The game draws nothing for those, so the count is reported rather
+   * than treated as a decoding failure; a real chain break shows up as hundreds
+   * of them, which is why the caller can still threshold on the count.
+   */
+  readonly missingRefs: readonly string[]
+  /**
+   * Wall references whose art needed a taller bitmap than the tile's declared
+   * height (an expected quirk of real libraries, not an error).
+   */
+  readonly clippedTiles: number
+  /** References that several libraries could satisfy (first library wins). */
+  readonly duplicateRefs: number
+  /**
+   * Sub-tiles that became blocked **only** because a shadow layer blocked them.
+   *
+   * The engine unions the sub-tile flags of every layer of a cell before reading
+   * walkability, and shadows are a layer of their own (`type 13`). If this is ever
+   * non-zero, dropping shadows from the union would have changed the map.
+   */
+  readonly shadowBlockedSubtiles: number
+  /**
+   * References that only the type-agnostic fallback could satisfy.
+   *
+   * Should be 0: a non-zero value means a reference drew a tile of the wrong
+   * *type* (a wall where a floor belongs), which is exactly the defect
+   * `npm run verify:tiles` exists to catch.
+   */
+  readonly looseRefs: number
+}
+
+/**
+ * Composite a library tile's blocks into one indexed bitmap.
+ *
+ * The bitmap is the size Diablo II allocates for the tile: `width` by
+ * `|height|`. Blocks were already shifted into that box by the decoder.
+ *
+ * @param tile - the library tile.
+ * @returns the frame.
+ */
+function tileToFrame(tile: Dt1Tile): SpriteFrame {
+  const width = Math.max(tile.width, 1)
+  const height = Math.max(tile.bitmapHeight, 1)
+  const indices = new Uint8Array(width * height)
+  const mask = new Uint8Array(width * height)
+  for (const block of tile.blocks) {
+    for (let at = 0; at < indices.length && at < block.pixels.length; at += 1) {
+      const value = block.pixels[at]!
+      if (value === 0) continue
+      indices[at] = value
+      mask[at] = 1
+    }
+  }
+  return { width, height, indices, mask }
+}
+
+/** One tile of the merged pool. */
+interface PoolTile {
+  readonly library: number
+  readonly tile: number
+  /** Variant weight (`Dt1Tile.rarityFrameIndex`) used when picking per cell. */
+  readonly weight: number
+}
+
+/** The merged pool a DS1's references are resolved against. */
+interface TilePool {
+  readonly exact: Map<string, PoolTile[]>
+  readonly loose: Map<string, PoolTile[]>
+  /** References that more than one tile could satisfy (the random variants). */
+  duplicates: number
+}
+
+/**
+ * Merge every library of a level into one lookup pool.
+ *
+ * The key insight — and the one that a single-library reader gets wrong — is
+ * that a DS1 cell's `style` matches the **tile's own `style` field inside a
+ * DT1**, not the position of the DT1 in the level type's file list. Act 1's
+ * `River.dt1` holds tiles with internal styles 2 and 3 while `Fence.dt1` holds
+ * only style 0, so treating `style` as a library index looks plausible (it
+ * resolves most of the town) and then misses every reference the real styles
+ * would have caught.
+ *
+ * @param libraries - the level type's libraries, in file-list order.
+ * @returns the pool.
+ */
+function mergeLibraries(libraries: readonly Dt1[]): TilePool {
+  const exact = new Map<string, PoolTile[]>()
+  const loose = new Map<string, PoolTile[]>()
+  let duplicates = 0
+  const push = (map: Map<string, PoolTile[]>, key: string, entry: PoolTile, countDuplicate: boolean): void => {
+    const bucket = map.get(key)
+    if (bucket === undefined) { map.set(key, [entry]); return }
+    if (countDuplicate) duplicates += 1
+    bucket.push(entry)
+  }
+  libraries.forEach((library, libraryIndex) => {
+    library.tiles.forEach((tile, tileIndex) => {
+      const entry = { library: libraryIndex, tile: tileIndex, weight: tile.rarityFrameIndex }
+      // The third component is the DS1 wall `type` and it matches the DT1 tile's
+      // **`Type` field at offset +20**, not its `Direction` field at +0. `Direction`
+      // is the orientation/variant index (1..5 in practice) and never equals the
+      // semantic types (14 tree, 15 roof, ...); keying on it sent every roof/tree
+      // reference through the loose fallback, which drew a floor tile where a tent
+      // canopy belonged. Multiple tiles can share style:sequence:type — those are
+      // the real variants `pickVariant` draws among.
+      push(exact, `${String(tile.style)}:${String(tile.sequence)}:${String(tile.type)}`, entry, true)
+      push(loose, `${String(tile.style)}:${String(tile.sequence)}`, entry, false)
+    })
+  })
+  return { exact, loose, duplicates }
+}
+
+/**
+ * Pick one variant out of a `style:sequence` group, the way the engine does.
+ *
+ * A DT1 ships several tiles for the same `style`/`sequence` (different grass
+ * patches, stone patterns, torch variants), and the engine chooses **per cell**
+ * with a weighted random draw whose weight is the tile's `RarityFrameIndex`,
+ * seeded from the map seed and the cell's own `x`/`y`. This is the port of
+ * OpenDiablo2's `getRandomTile` (`d2mapengine/map_tile.go`):
+ *
+ *     tileSeed = (seed + x) * y; tileSeed ^= tileSeed << 13; ^= >> 17; ^= << 5
+ *     random   = tileSeed % Σ weight;  first tile whose running sum >= random wins
+ *
+ * The seed is a per-level constant (the DS1 member name hashed) rather than a
+ * random game seed, so the offline bake and the in-browser decode pick the *same*
+ * variant — that is what keeps `verify:packs` a byte comparison.
+ *
+ * @param candidates - the group, in library/file order.
+ * @param cellX - cell x, the way the engine seeds it.
+ * @param cellY - cell y.
+ * @param seed - per-level seed.
+ * @returns the chosen tile, or undefined for an empty group.
+ */
+function pickVariant(
+  candidates: readonly PoolTile[] | undefined,
+  cellX: number,
+  cellY: number,
+  seed: number,
+): PoolTile | undefined {
+  if (candidates === undefined || candidates.length === 0) return undefined
+  if (candidates.length === 1) return candidates[0]
+  let state = (BigInt(seed >>> 0) + BigInt(cellX >>> 0)) * BigInt(cellY >>> 0)
+  const mask = (1n << 64n) - 1n
+  state &= mask
+  state = (state ^ (state << 13n)) & mask
+  state = (state ^ (state >> 17n)) & mask
+  state = (state ^ (state << 5n)) & mask
+  let total = 0
+  for (const candidate of candidates) total += Math.max(0, candidate.weight | 0)
+  if (total === 0) return candidates[0]
+  const roll = Number(state % BigInt(total))
+  let running = 0
+  for (const candidate of candidates) {
+    running += Math.max(0, candidate.weight | 0)
+    if (running > roll) return candidate
+  }
+  return candidates[candidates.length - 1]
+}
+
+/**
+ * Resolve a DS1 reference against the pool.
+ *
+ * @param pool - the merged pool.
+ * @param style - DS1 style field.
+ * @param sequence - DS1 sequence field.
+ * @param type - DS1 wall type (the third field of the reference).
+ * @returns the pool tile, or undefined when nothing matches.
+ */
+function resolveExactType(
+  pool: TilePool,
+  style: number,
+  sequence: number,
+  type: number,
+  cellX: number,
+  cellY: number,
+  seed: number,
+): PoolTile | undefined {
+  return pickVariant(pool.exact.get(`${String(style)}:${String(sequence)}:${String(type)}`), cellX, cellY, seed)
+}
+
+/**
+ * Resolve a DS1 reference against the pool.
+ *
+ * @param pool - the merged pool.
+ * @param style - DS1 style field.
+ * @param sequence - DS1 sequence field.
+ * @param type - DS1 wall type (the third field of the reference), or null for floors.
+ * @returns the pool tile, or undefined when nothing matches.
+ */
+function resolveWithSource(
+  pool: TilePool,
+  style: number,
+  sequence: number,
+  type: number,
+  cellX: number,
+  cellY: number,
+  seed: number,
+): { tile: PoolTile | undefined; viaLoose: boolean } {
+  const key = `${String(style)}:${String(sequence)}`
+  const exact = pickVariant(pool.exact.get(`${key}:${String(type)}`), cellX, cellY, seed)
+  if (exact !== undefined) return { tile: exact, viaLoose: false }
+  return { tile: pickVariant(pool.loose.get(key), cellX, cellY, seed), viaLoose: true }
+}
+
+/**
+ * The per-level variant seed for {@link buildIsoMapScene}.
+ *
+ * Derived from the DS1 member name so it is stable across processes: the packer
+ * hashes the name it read out of the archives, and the browser hashes the name it
+ * is about to fetch, so both draw the same tile variants.
+ *
+ * @param name - the DS1 member name, e.g. `data\global\tiles\Act1\Town\townN1.ds1`.
+ * @returns a 32-bit seed.
+ */
+export function levelSeed(name: string): number {
+  let hash = 0x811c9dc5
+  for (let index = 0; index < name.length; index += 1) {
+    hash ^= name.charCodeAt(index)
+    hash = Math.imul(hash, 0x01000193) >>> 0
+  }
+  return hash >>> 0
+}
+
+/**
+ * Build the renderable scene.
+ *
+ * @param level - the decoded DS1.
+ * @param libraries - the level type's DT1 libraries, in `File 1..N` order, so a
+ *   cell's `style` can index straight into it.
+ * @param seed - per-level seed for the per-cell tile variant draw. Both the
+ *   offline bake and the in-browser decode must pass the same value (the packer
+ *   uses {@link levelSeed}); 0 keeps the old deterministic first-variant result.
+ * @returns the scene.
+ */
+export function buildIsoMapScene(level: Ds1, libraries: readonly Dt1[], seed = 0): IsoMapScene {
+  const pool = mergeLibraries(libraries)
+  const frames: SpriteFrame[] = []
+  /** `library:tile` → frame index, so repeated references share one frame. */
+  const frameOfTile = new Map<string, number>()
+  const frameFor = (libraryIndex: number, tileIndex: number): number => {
+    const key = `${String(libraryIndex)}:${String(tileIndex)}`
+    const existing = frameOfTile.get(key)
+    if (existing !== undefined) return existing
+    const index = frames.length
+    frames.push(tileToFrame(libraries[libraryIndex]!.tiles[tileIndex]!))
+    frameOfTile.set(key, index)
+    return index
+  }
+
+  const cellsX = level.width
+  const cellsY = level.height
+  const gridWidth = cellsX * SUB_TILES_PER_TILE
+  const gridHeight = cellsY * SUB_TILES_PER_TILE
+  const blocked = new Uint8Array(gridWidth * gridHeight)
+  const rawFloors: { frameIndex: number; x: number; y: number; cellX: number; cellY: number; library: number; tile: number }[] = []
+  const rawWalls: typeof rawFloors = []
+  /** Roof draws (`wall.type` 15): kept apart so they can be painted last. */
+  const rawRoofs: typeof rawFloors = []
+  let missingTiles = 0
+  let clippedTiles = 0
+  const missingRefs: string[] = []
+  const noteMissing = (kind: string, style: number, sequence: number, direction: number | null, cellX: number, cellY: number): void => {
+    missingTiles += 1
+    if (missingRefs.length < 20) {
+      const dirText = direction === null ? '' : `:${String(direction)}`
+      missingRefs.push(`${kind} style=${String(style)} sequence=${String(sequence)}${dirText} @cell(${String(cellX)},${String(cellY)})`)
+    }
+  }
+
+  // The engine ORs the sub-tile flags of *every* layer of a cell (floor, wall,
+  // shadow) and then reads walkability off the combined flags — OpenDiablo2's
+  // `SubTileFlags.Combine` is a plain `||` of every bit (`d2dt1/subtile.go`).
+  // Stamping each layer into the same grid is the same union for walkability, but
+  // shadows must be included: they are a distinct DS1 layer (`type 13` tiles) and
+  // skipping them would silently drop blocking sub-tiles.
+  let shadowBlocked = 0
+  let looseRefs = 0
+  const stamp = (cellX: number, cellY: number, tile: Dt1Tile): void => {
+    for (let subY = 0; subY < SUB_TILES_PER_TILE; subY += 1) {
+      for (let subX = 0; subX < SUB_TILES_PER_TILE; subX += 1) {
+        const flags = tile.subTileFlags[subY * SUB_TILES_PER_TILE + subX]
+        if (flags === undefined || (!flags.blockWalk && !flags.blockPlayerWalk)) continue
+        const gx = cellX * SUB_TILES_PER_TILE + subX
+        const gy = cellY * SUB_TILES_PER_TILE + subY
+        if (gx < 0 || gx >= gridWidth || gy < 0 || gy >= gridHeight) continue
+        blocked[gy * gridWidth + gx] = 1
+      }
+    }
+  }
+
+  for (let cellY = 0; cellY < cellsY; cellY += 1) {
+    for (let cellX = 0; cellX < cellsX; cellX += 1) {
+      const cell = level.cells[cellY]?.[cellX]
+      if (cell === undefined) continue
+      const orthoX = (cellX - cellY) * ORTHO_CELL_WIDTH
+      const orthoY = (cellX + cellY) * ORTHO_CELL_HEIGHT
+
+      for (const floor of cell.floors) {
+        // A zero `prop1` marks an unused slot, which most wall slots are.
+        if (floor.hidden || floor.prop1 === 0) continue
+        // A DS1 floor record has no `type` field: the engine reads it as DT1
+        // **type 0**. Passing `null` here (before this fix) sent every floor through
+        // the type-agnostic fallback, whose pool mixes floors, walls, pillars,
+        // shadows, trees and roofs — so a weighted-random draw could put a dark wall
+        // tile in a floor slot, drawn with the floor's offset (no `minBlockY + 80`),
+        // which is the "misplaced black block on the ground" defect.
+        const picked = resolveWithSource(pool, floor.style, floor.sequence, FLOOR_TILE_TYPE, cellX, cellY, seed)
+        if (picked.viaLoose) looseRefs += 1
+        const found = picked.tile
+        if (found === undefined) { noteMissing('floor', floor.style, floor.sequence, FLOOR_TILE_TYPE, cellX, cellY); continue }
+        const tile = libraries[found.library]!.tiles[found.tile]!
+        rawFloors.push({
+          frameIndex: frameFor(found.library, found.tile),
+          x: orthoX + TILE_ANCHOR_X,
+          y: orthoY,
+          cellX, cellY, library: found.library, tile: found.tile,
+        })
+        stamp(cellX, cellY, tile)
+      }
+
+      // Shadows are a collision-only layer here: they are resolved exactly like the
+      // engine resolves them (`type 13`) and folded into the grid, but nothing is
+      // drawn from them.
+      for (const shadow of cell.shadows) {
+        if (shadow.prop1 === 0) continue
+        // Shadows must come from a **type 13** tile specifically: the loose
+        // fallback ignores the type field and would happily return a wall tile,
+        // stamping its blocking flags as if they were a shadow's.
+        const found = resolveExactType(pool, shadow.style, shadow.sequence, SHADOW_TILE_TYPE, cellX, cellY, seed)
+        if (found === undefined) continue
+        const tile = libraries[found.library]!.tiles[found.tile]!
+        for (let sub = 0; sub < SUB_TILES_PER_TILE * SUB_TILES_PER_TILE; sub += 1) {
+          const flags = tile.subTileFlags[sub]
+          if (flags === undefined || (!flags.blockWalk && !flags.blockPlayerWalk)) continue
+          const gx = cellX * SUB_TILES_PER_TILE + (sub % SUB_TILES_PER_TILE)
+          const gy = cellY * SUB_TILES_PER_TILE + Math.floor(sub / SUB_TILES_PER_TILE)
+          if (gx < 0 || gx >= gridWidth || gy < 0 || gy >= gridHeight) continue
+          if (blocked[gy * gridWidth + gx] === 0) shadowBlocked += 1
+          blocked[gy * gridWidth + gx] = 1
+        }
+      }
+
+      for (const wall of cell.walls) {
+        if (wall.hidden || wall.prop1 === 0) continue
+        const pickedWall = resolveWithSource(pool, wall.style, wall.sequence, wall.type, cellX, cellY, seed)
+        if (pickedWall.viaLoose) looseRefs += 1
+        const found = pickedWall.tile
+        if (found === undefined) { noteMissing('wall', wall.style, wall.sequence, wall.type, cellX, cellY); continue }
+        const tile = libraries[found.library]!.tiles[found.tile]!
+        if (tile.bitmapHeight > Math.abs(tile.height)) clippedTiles += 1
+        const draw = {
+          frameIndex: frameFor(found.library, found.tile),
+          x: orthoX + TILE_ANCHOR_X,
+          // A wall's art extends above its cell, so it is pushed back down by
+          // exactly the block shift the decoder applied, plus one cell height.
+          y: orthoY + tile.minBlockY + WALL_SURFACE_HEIGHT,
+          cellX, cellY, library: found.library, tile: found.tile,
+        }
+        if (wall.type === ROOF_WALL_TYPE) {
+          // Roofs use the engine's own roof offset and are painted after
+          // everything else, so they leave the wall painter order entirely.
+          rawRoofs.push({ ...draw, y: orthoY - tile.roofHeight })
+        } else {
+          rawWalls.push(draw)
+        }
+        stamp(cellX, cellY, tile)
+      }
+    }
+  }
+
+  // Isometric painter's order: depth grows along the diagonal, so walls sort by
+  // (cellX + cellY) and then row, which keeps a nearer wall in front of the one
+  // behind it without any depth buffer.
+  rawWalls.sort((a, b) => (a.cellY + a.cellX) - (b.cellY + b.cellX) || a.cellY - b.cellY || a.x - b.x)
+  rawRoofs.sort((a, b) => (a.cellY + a.cellX) - (b.cellY + b.cellX) || a.cellY - b.cellY || a.x - b.x)
+
+  // Shift everything positive: `(cellX - cellY)` is negative on half the map.
+  let minX = 0
+  let minY = 0
+  let maxX = 0
+  let maxY = 0
+  for (const draw of [...rawFloors, ...rawWalls, ...rawRoofs]) {
+    const frame = frames[draw.frameIndex]!
+    minX = Math.min(minX, draw.x)
+    minY = Math.min(minY, draw.y)
+    maxX = Math.max(maxX, draw.x + frame.width)
+    maxY = Math.max(maxY, draw.y + frame.height)
+  }
+  const originX = -minX
+  const originY = -minY
+  const shift = (draw: (typeof rawFloors)[number]): IsoDraw => ({ ...draw, x: draw.x + originX, y: draw.y + originY })
+
+  return {
+    frames,
+    sheet: { groups: [{ frames }], width: null },
+    cellsX,
+    cellsY,
+    widthPx: maxX - minX,
+    heightPx: maxY - minY,
+    originX,
+    originY,
+    floors: rawFloors.map(shift),
+    walls: rawWalls.map(shift),
+    roofs: rawRoofs.map(shift),
+    blocked,
+    gridWidth,
+    gridHeight,
+    missingTiles,
+    missingRefs,
+    clippedTiles,
+    shadowBlockedSubtiles: shadowBlocked,
+    looseRefs,
+    duplicateRefs: pool.duplicates,
+  }
+}
+
+/**
+ * The parts of a scene that collision and projection need.
+ *
+ * A packed map and a freshly decoded one share these fields but not their
+ * storage (one has an atlas, the other PNG pages), so the helpers below ask for
+ * this shape instead of the whole scene.
+ */
+export interface CollisionGrid {
+  /** Screen x added to every coordinate so the minimum is 0. */
+  readonly originX: number
+  /** Screen y added to every coordinate so the minimum is 0. */
+  readonly originY: number
+  /** Cells horizontally. */
+  readonly cellsX: number
+  /** Cells vertically. */
+  readonly cellsY: number
+  /** Collision grid, 1 = blocked. */
+  readonly blocked: Uint8Array
+  /** Collision grid width in sub-tiles. */
+  readonly gridWidth: number
+}
+
+/**
+ * The cell containing a scene-space point.
+ *
+ * Inverts the isometric projection: `cx = (x/80 + y/40) / 2`, `cy = (y/40 -
+ * x/80) / 2`.
+ *
+ * @param scene - the scene.
+ * @param x - scene-space x.
+ * @param y - scene-space y.
+ * @returns cell coordinates, unrounded.
+ */
+export function cellAt(scene: CollisionGrid, x: number, y: number): { x: number; y: number } {
+  const px = x - scene.originX
+  const py = y - scene.originY
+  return {
+    x: (px / ORTHO_CELL_WIDTH + py / ORTHO_CELL_HEIGHT) / 2,
+    y: (py / ORTHO_CELL_HEIGHT - px / ORTHO_CELL_WIDTH) / 2,
+  }
+}
+
+/**
+ * Whether a scene-space point lies on a blocked sub-tile.
+ *
+ * @param scene - the scene.
+ * @param x - scene-space x.
+ * @param y - scene-space y.
+ * @returns true when walking is blocked there.
+ */
+export function isBlockedAt(scene: CollisionGrid, x: number, y: number): boolean {
+  const cell = cellAt(scene, x, y)
+  const cellX = Math.floor(cell.x)
+  const cellY = Math.floor(cell.y)
+  if (cellX < 0 || cellY < 0 || cellX >= scene.cellsX || cellY >= scene.cellsY) return true
+  const subX = Math.floor((cell.x - cellX) * SUB_TILES_PER_TILE)
+  const subY = Math.floor((cell.y - cellY) * SUB_TILES_PER_TILE)
+  const gx = cellX * SUB_TILES_PER_TILE + Math.min(subX, SUB_TILES_PER_TILE - 1)
+  const gy = cellY * SUB_TILES_PER_TILE + Math.min(subY, SUB_TILES_PER_TILE - 1)
+  return scene.blocked[gy * scene.gridWidth + gx] === 1
+}
+
+/**
+ * Scene-space centre of a cell.
+ *
+ * @param scene - the scene.
+ * @param cellX - cell column.
+ * @param cellY - cell row.
+ * @returns the centre point.
+ */
+export function cellCentre(scene: CollisionGrid, cellX: number, cellY: number): { x: number; y: number } {
+  return {
+    x: (cellX - cellY) * ORTHO_CELL_WIDTH + scene.originX,
+    y: (cellX + cellY) * ORTHO_CELL_HEIGHT + scene.originY + ORTHO_CELL_HEIGHT / 2,
+  }
+}
+
+/**
+ * Find a walkable spawn near the middle of the map.
+ *
+ * @param scene - the scene.
+ * @returns a scene-space point, or null when nothing is walkable.
+ */
+export function findIsoSpawn(scene: CollisionGrid & { cellsX: number; cellsY: number }): { x: number; y: number } | null {
+  const centreX = Math.floor(scene.cellsX / 2)
+  const centreY = Math.floor(scene.cellsY / 2)
+  for (let radius = 0; radius < Math.max(scene.cellsX, scene.cellsY); radius += 1) {
+    for (let dy = -radius; dy <= radius; dy += 1) {
+      for (let dx = -radius; dx <= radius; dx += 1) {
+        if (Math.max(Math.abs(dx), Math.abs(dy)) !== radius) continue
+        const cellX = centreX + dx
+        const cellY = centreY + dy
+        if (cellX < 0 || cellY < 0 || cellX >= scene.cellsX || cellY >= scene.cellsY) continue
+        const point = cellCentre(scene, cellX, cellY)
+        if (!isBlockedAt(scene, point.x, point.y)) return point
+      }
+    }
+  }
+  return null
+}
diff --git a/src/game/items.ts b/src/game/items.ts
new file mode 100644
index 0000000..ddcd7a6
--- /dev/null
+++ b/src/game/items.ts
@@ -0,0 +1,587 @@
+/**
+ * Items: bases, affixes, inventory and drops.
+ *
+ * This is the M3 skeleton, and its shape follows how Diablo II actually stores
+ * items: an item is a *base* (`weapons.txt` / `armor.txt` / `misc.txt` row) with
+ * an optional prefix and suffix from `MagicPrefix.txt` / `MagicSuffix.txt`, whose
+ * modifiers name stats from `ItemStatCost.txt`. Nothing is hardcoded here — a
+ * sword is a table row with a size and a damage value, and "Cruel" is a table row
+ * with a level requirement, a list of eligible item types and a modifier range.
+ *
+ * Two modelling decisions are worth stating because they are what make the system
+ * testable:
+ *
+ * - **Randomness is injected.** Affix rolls take an {@link Rng}, so a drop is a
+ *   pure function of its seed and can be replayed exactly in a test.
+ * - **The inventory is a grid of occupied cells, not a list.** Diablo II items
+ *   have width and height, cannot overlap, and can be rotated only in the sense
+ *   that their shape is fixed — so placement is a real constraint that has to be
+ *   modelled to make "inventory full" mean anything.
+ *
+ * Simplifications, called out rather than hidden: affixes are chosen uniformly
+ * among eligible ones instead of by the game's level-weighted tables, item
+ * requirements (strength/dexterity/level) are stored but not enforced, and
+ * durability, sockets and quality tiers (normal/exceptional/elite) are not
+ * modelled yet.
+ */
+import { Rng } from './rng.ts'
+import { numberCell, textCell } from './tables.ts'
+import type { DataTable } from './tables.ts'
+
+/** What a base is, broadly. */
+export type ItemKind = 'weapon' | 'armor' | 'misc'
+
+/** One item base, read from a table row. */
+export interface ItemBase {
+  /** Table id (for example `swd` for a short sword). */
+  readonly id: string
+  /** Display name. */
+  readonly name: string
+  /** Broad kind. */
+  readonly kind: ItemKind
+  /** Inventory width in cells. */
+  readonly invWidth: number
+  /** Inventory height in cells. */
+  readonly invHeight: number
+  /** How many of this base fit in one cell (1 for most things). */
+  readonly maxStack: number
+  /** Base gold value. */
+  readonly value: number
+  /** Weapon damage, when it is a weapon. */
+  readonly damage: number
+  /** Armor rating, when it is armor. */
+  readonly defense: number
+  /** Tags affixes match against (the item's type list). */
+  readonly tags: readonly string[]
+  /** Minimum level before it may drop. */
+  readonly level: number
+}
+
+/** One affix, read from a prefix or suffix row. */
+export interface Affix {
+  /** Table id. */
+  readonly id: string
+  /** Name as it appears in an item's name. */
+  readonly name: string
+  /** Which side of the name it attaches to. */
+  readonly kind: 'prefix' | 'suffix'
+  /** Minimum item level for the affix to be possible. */
+  readonly level: number
+  /** Item-type tags it applies to; empty means any. */
+  readonly itemTypes: readonly string[]
+  /** Stat modifiers it contributes. */
+  readonly modifiers: readonly AffixModifier[]
+}
+
+/** One stat contribution of an affix. */
+export interface AffixModifier {
+  /** Stat name, as `ItemStatCost.txt` spells it. */
+  readonly stat: string
+  /** Minimum roll. */
+  readonly min: number
+  /** Maximum roll. */
+  readonly max: number
+}
+
+/** A concrete item. */
+export interface Item {
+  /** Base definition. */
+  readonly base: ItemBase
+  /** Rolled prefix, if any. */
+  readonly prefix: Affix | null
+  /** Rolled suffix, if any. */
+  readonly suffix: Affix | null
+  /** Item level the affixes were rolled at. */
+  readonly level: number
+  /** Final name, affixes included. */
+  readonly name: string
+  /** Final stats: base plus every rolled modifier. */
+  readonly stats: Readonly<Record<string, number>>
+  /** Inventory footprint. */
+  readonly invWidth: number
+  /** Inventory footprint. */
+  readonly invHeight: number
+  /** How many are stacked here. */
+  readonly stack: number
+  /** Gold value of one unit. */
+  readonly value: number
+}
+
+/** A rectangle in the inventory grid. */
+export interface GridPlacement {
+  /** Column of the item's left edge. */
+  readonly x: number
+  /** Row of the item's top edge. */
+  readonly y: number
+}
+
+/** An item occupying a spot in the inventory. */
+export interface PlacedItem extends GridPlacement {
+  /** The item itself. */
+  readonly item: Item
+}
+
+/** What happened when a drop was rolled. */
+export type DropResult =
+  | { readonly kind: 'item'; readonly item: Item }
+  | { readonly kind: 'gold'; readonly amount: number }
+  | { readonly kind: 'nothing' }
+
+/** Default footprint for a base whose row omits one. */
+const DEFAULT_SIZE = 1
+
+/**
+ * Read an item base from a table row.
+ *
+ * @param row - the record.
+ * @param kind - which table the row came from.
+ * @param rowIndex - position, for a fallback id.
+ * @returns the base.
+ */
+export function itemBaseFromRow(
+  row: Readonly<Record<string, string>>,
+  kind: ItemKind,
+  rowIndex: number,
+): ItemBase {
+  const id = textCell(row, 'Id', textCell(row, 'code', `${kind}${String(rowIndex)}`))
+  const tags = textCell(row, 'Type', textCell(row, 'type', kind))
+    .split(/[,\s]+/)
+    .filter(tag => tag !== '')
+  return {
+    id,
+    name: textCell(row, 'Name', textCell(row, 'name', id)),
+    kind,
+    invWidth: numberCell(row, 'InvWidth', numberCell(row, 'invwidth', DEFAULT_SIZE)),
+    invHeight: numberCell(row, 'InvHeight', numberCell(row, 'invheight', DEFAULT_SIZE)),
+    maxStack: Math.max(1, numberCell(row, 'MaxStack', numberCell(row, 'maxstack', 1))),
+    value: Math.max(0, numberCell(row, 'Value', numberCell(row, 'cost', 1))),
+    damage: Math.max(0, numberCell(row, 'Damage', numberCell(row, 'mindam', 0))),
+    defense: Math.max(0, numberCell(row, 'Defense', numberCell(row, 'minac', 0))),
+    tags,
+    level: Math.max(0, numberCell(row, 'Level', numberCell(row, 'level', 1))),
+  }
+}
+
+/**
+ * Read every base in a table.
+ *
+ * @param table - a weapons/armor/misc table.
+ * @param kind - which kind the table holds.
+ * @returns the bases.
+ */
+export function itemBasesFromTable(table: DataTable, kind: ItemKind): ItemBase[] {
+  return table.rows.map((row, index) => itemBaseFromRow(row, kind, index))
+}
+
+/**
+ * How many modifier slots the loader looks for.
+ *
+ * Diablo II's affix rows carry `mod1code/mod1min/mod1max` through `mod3…` for
+ * prefixes and suffixes alike; three is the shipped maximum.
+ */
+const MODIFIER_SLOTS = 3
+/**
+ * How many item-type slots an affix row may restrict itself to (`itype1..7`).
+ */
+const ITYPE_SLOTS = 7
+
+/**
+ * Read one affix from a prefix/suffix row.
+ *
+ * @param row - the record.
+ * @param kind - which side of the name the affix attaches to.
+ * @param rowIndex - position, for a fallback id.
+ * @returns the affix, or null when the row has no usable modifier.
+ */
+export function affixFromRow(
+  row: Readonly<Record<string, string>>,
+  kind: 'prefix' | 'suffix',
+  rowIndex: number,
+): Affix | null {
+  const modifiers: AffixModifier[] = []
+  for (let slot = 1; slot <= MODIFIER_SLOTS; slot += 1) {
+    const stat = textCell(row, `mod${String(slot)}code`, textCell(row, `Mod${String(slot)}Code`, ''))
+    if (stat === '') continue
+    const min = numberCell(row, `mod${String(slot)}min`, numberCell(row, `Mod${String(slot)}Min`, 0))
+    const max = numberCell(row, `mod${String(slot)}max`, numberCell(row, `Mod${String(slot)}Max`, min))
+    modifiers.push({ stat, min, max: Math.max(min, max) })
+  }
+  if (modifiers.length === 0) return null
+  const itemTypes: string[] = []
+  for (let slot = 1; slot <= ITYPE_SLOTS; slot += 1) {
+    const value = textCell(row, `itype${String(slot)}`, textCell(row, `IType${String(slot)}`, ''))
+    for (const tag of value.split(/[,\s]+/)) if (tag !== '') itemTypes.push(tag)
+  }
+  const id = textCell(row, 'Id', textCell(row, 'Name', `${kind}${String(rowIndex)}`))
+  return {
+    id,
+    name: textCell(row, 'Name', id),
+    kind,
+    level: Math.max(0, numberCell(row, 'Level', numberCell(row, 'lvl', 1))),
+    itemTypes,
+    modifiers,
+  }
+}
+
+/**
+ * Read every affix in a table.
+ *
+ * @param table - a `MagicPrefix` or `MagicSuffix` shaped table.
+ * @param kind - which side of the name the rows attach to.
+ * @returns the affixes, with unusable rows skipped.
+ */
+export function affixesFromTable(table: DataTable, kind: 'prefix' | 'suffix'): Affix[] {
+  const affixes: Affix[] = []
+  table.rows.forEach((row, index) => {
+    const affix = affixFromRow(row, kind, index)
+    if (affix !== null) affixes.push(affix)
+  })
+  return affixes
+}
+
+/**
+ * Whether an affix may roll on a base at a given item level.
+ *
+ * @param affix - the affix.
+ * @param base - the base item.
+ * @param level - the item level being rolled.
+ * @returns true when the affix is eligible.
+ */
+export function affixEligible(affix: Affix, base: ItemBase, level: number): boolean {
+  if (affix.level > level) return false
+  if (affix.itemTypes.length === 0) return true
+  // Diablo II matches the affix's `itype` list against the item's type list; an
+  // affix naming a type the base does not carry cannot roll on it.
+  return affix.itemTypes.some(tag => base.tags.includes(tag))
+}
+
+/**
+ * Roll one affix for a base.
+ *
+ * @param affixes - the candidate affixes.
+ * @param base - the base item.
+ * @param level - the item level.
+ * @param rng - the random source.
+ * @returns the affix and its rolled modifiers, or null when none is eligible.
+ */
+export function rollAffix(
+  affixes: readonly Affix[],
+  base: ItemBase,
+  level: number,
+  rng: Rng,
+): { affix: Affix; rolls: AffixModifier[] } | null {
+  const eligible = affixes.filter(affix => affixEligible(affix, base, level))
+  const affix = rng.pick(eligible)
+  if (affix === undefined) return null
+  const rolls = affix.modifiers.map(modifier => ({
+    stat: modifier.stat,
+    min: rng.int(modifier.min, modifier.max),
+    max: rng.int(modifier.min, modifier.max),
+  }))
+  return { affix, rolls }
+}
+
+/** Options controlling how an item is built. */
+export interface CreateItemOptions {
+  /** Item level; gates affixes. */
+  readonly level: number
+  /** Chance that a prefix rolls at all. */
+  readonly prefixChance?: number
+  /** Chance that a suffix rolls at all. */
+  readonly suffixChance?: number
+  /** How many units are stacked. */
+  readonly stack?: number
+}
+
+/**
+ * Build an item from a base, rolling its affixes.
+ *
+ * @param base - the base.
+ * @param prefixes - candidate prefixes.
+ * @param suffixes - candidate suffixes.
+ * @param rng - the random source.
+ * @param options - level, chances and stack size.
+ * @returns the item.
+ */
+export function createItem(
+  base: ItemBase,
+  prefixes: readonly Affix[],
+  suffixes: readonly Affix[],
+  rng: Rng,
+  options: CreateItemOptions,
+): Item {
+  const prefixChance = options.prefixChance ?? 0.45
+  const suffixChance = options.suffixChance ?? 0.45
+  const prefix = rng.chance(prefixChance) ? rollAffix(prefixes, base, options.level, rng) : null
+  const suffix = rng.chance(suffixChance) ? rollAffix(suffixes, base, options.level, rng) : null
+
+  const stats: Record<string, number> = {}
+  if (base.damage > 0) stats.damage = base.damage
+  if (base.defense > 0) stats.defense = base.defense
+  for (const rolled of [prefix, suffix]) {
+    if (rolled === null) continue
+    for (const roll of rolled.rolls) {
+      stats[roll.stat] = (stats[roll.stat] ?? 0) + roll.max
+    }
+  }
+
+  const name = [prefix?.affix.name, base.name, suffix?.affix.name].filter(part => part !== undefined && part !== '').join(' ')
+  // An affixed item is worth more; the multiplier is a stand-in for the game's
+  // per-modifier pricing.
+  const affixCount = (prefix === null ? 0 : 1) + (suffix === null ? 0 : 1)
+  const value = Math.max(1, Math.round(base.value * (1 + affixCount * 0.75)))
+
+  return {
+    base,
+    prefix: prefix?.affix ?? null,
+    suffix: suffix?.affix ?? null,
+    level: options.level,
+    name,
+    stats,
+    invWidth: base.invWidth,
+    invHeight: base.invHeight,
+    stack: Math.max(1, Math.min(options.stack ?? 1, base.maxStack)),
+    value,
+  }
+}
+
+/**
+ * The inventory: a grid of cells, each either empty or holding a placed item.
+ */
+export class Inventory {
+  /** Grid width in cells. */
+  readonly width: number
+  /** Grid height in cells. */
+  readonly height: number
+  private readonly cells: (number | null)[]
+  private readonly items: PlacedItem[] = []
+  private nextId = 1
+
+  /**
+   * @param width - grid width in cells.
+   * @param height - grid height in cells.
+   */
+  constructor(width = 10, height = 4) {
+    this.width = width
+    this.height = height
+    this.cells = new Array<number | null>(width * height).fill(null)
+  }
+
+  /** Items currently placed. */
+  get contents(): readonly PlacedItem[] {
+    return this.items
+  }
+
+  /** Occupied cell count. */
+  get usedCells(): number {
+    return this.items.reduce((total, placed) => total + placed.item.invWidth * placed.item.invHeight, 0)
+  }
+
+  /** Total cell count. */
+  get totalCells(): number {
+    return this.width * this.height
+  }
+
+  /**
+   * Whether an item of a given size fits at a position.
+   *
+   * @param width - item width.
+   * @param height - item height.
+   * @param x - column.
+   * @param y - row.
+   * @returns true when the whole footprint is inside the grid and empty.
+   */
+  canPlace(width: number, height: number, x: number, y: number): boolean {
+    if (x < 0 || y < 0 || x + width > this.width || y + height > this.height) return false
+    for (let row = y; row < y + height; row += 1) {
+      for (let column = x; column < x + width; column += 1) {
+        if (this.cells[row * this.width + column] !== null) return false
+      }
+    }
+    return true
+  }
+
+  /**
+   * Add an item, stacking onto an existing stack when possible.
+   *
+   * @param item - the item to add.
+   * @returns where it landed, or null when there was no room.
+   */
+  add(item: Item): PlacedItem | null {
+    // Stack first: a second potion belongs on the first one, not beside it.
+    if (item.base.maxStack > 1) {
+      for (const placed of this.items) {
+        if (placed.item.base.id !== item.base.id) continue
+        const room = placed.item.base.maxStack - placed.item.stack
+        if (room <= 0) continue
+        const moved = Math.min(room, item.stack)
+        const merged: Item = { ...placed.item, stack: placed.item.stack + moved }
+        this.items[this.items.indexOf(placed)] = { ...placed, item: merged }
+        const leftover = item.stack - moved
+        if (leftover <= 0) return { ...placed, item: merged }
+        return this.add({ ...item, stack: leftover })
+      }
+    }
+    for (let y = 0; y < this.height; y += 1) {
+      for (let x = 0; x < this.width; x += 1) {
+        if (!this.canPlace(item.invWidth, item.invHeight, x, y)) continue
+        const id = this.nextId
+        this.nextId += 1
+        for (let row = y; row < y + item.invHeight; row += 1) {
+          for (let column = x; column < x + item.invWidth; column += 1) {
+            this.cells[row * this.width + column] = id
+          }
+        }
+        const placed: PlacedItem = { x, y, item }
+        this.items.push(placed)
+        return placed
+      }
+    }
+    return null
+  }
+
+  /**
+   * Remove an item by its placement.
+   *
+   * @param placed - the placement to clear.
+   * @returns true when it was present.
+   */
+  remove(placed: PlacedItem): boolean {
+    const index = this.items.indexOf(placed)
+    if (index === -1) return false
+    for (let row = placed.y; row < placed.y + placed.item.invHeight; row += 1) {
+      for (let column = placed.x; column < placed.x + placed.item.invWidth; column += 1) {
+        this.cells[row * this.width + column] = null
+      }
+    }
+    this.items.splice(index, 1)
+    return true
+  }
+
+  /**
+   * Rebuild an inventory from explicit placements.
+   *
+   * A save restores items where they were, not wherever the first free slot
+   * happens to be today: an item that moved on load would be a save that lies.
+   * Placements are validated, so a corrupt save fails loudly instead of producing
+   * an overlapping bag.
+   *
+   * @param width - grid width.
+   * @param height - grid height.
+   * @param entries - placements to restore.
+   * @returns the inventory.
+   */
+  static restore(width: number, height: number, entries: readonly PlacedItem[]): Inventory {
+    const inventory = new Inventory(width, height)
+    for (const entry of entries) {
+      if (!inventory.canPlace(entry.item.invWidth, entry.item.invHeight, entry.x, entry.y)) {
+        throw new Error(`saved item "${entry.item.name}" does not fit at ${String(entry.x)},${String(entry.y)}`)
+      }
+      const id = inventory.nextId
+      inventory.nextId += 1
+      for (let row = entry.y; row < entry.y + entry.item.invHeight; row += 1) {
+        for (let column = entry.x; column < entry.x + entry.item.invWidth; column += 1) {
+          inventory.cells[row * width + column] = id
+        }
+      }
+      inventory.items.push({ x: entry.x, y: entry.y, item: entry.item })
+    }
+    return inventory
+  }
+
+  /** How much gold is held, summed over gold stacks. */
+  get gold(): number {
+    return this.items
+      .filter(placed => placed.item.base.id === 'gold')
+      .reduce((total, placed) => total + placed.item.stack, 0)
+  }
+}
+
+/** A gold base, created on demand so gold needs no table row. */
+export const GOLD_BASE: ItemBase = {
+  id: 'gold',
+  name: 'Gold',
+  kind: 'misc',
+  invWidth: 1,
+  invHeight: 1,
+  maxStack: 5000,
+  value: 1,
+  damage: 0,
+  defense: 0,
+  tags: ['gold'],
+  level: 0,
+}
+
+/**
+ * Build a gold pile.
+ *
+ * @param amount - how much gold.
+ * @returns the item.
+ */
+export function goldItem(amount: number): Item {
+  const stack = Math.max(1, Math.min(amount, GOLD_BASE.maxStack))
+  return {
+    base: GOLD_BASE,
+    prefix: null,
+    suffix: null,
+    level: 0,
+    name: 'Gold',
+    stats: {},
+    invWidth: 1,
+    invHeight: 1,
+    stack,
+    value: stack,
+  }
+}
+
+/** Options for {@link rollDrop}. */
+export interface DropOptions {
+  /** Item level to roll at. */
+  readonly level: number
+  /** Chance that anything drops at all. */
+  readonly dropChance: number
+  /** Chance that a drop is gold rather than an item. */
+  readonly goldChance: number
+  /** Gold range when gold drops. */
+  readonly goldRange: readonly [number, number]
+}
+
+/**
+ * Roll what a monster leaves behind.
+ *
+ * @param bases - candidate bases.
+ * @param prefixes - candidate prefixes.
+ * @param suffixes - candidate suffixes.
+ * @param rng - the random source.
+ * @param options - level and chances.
+ * @returns the drop.
+ */
+export function rollDrop(
+  bases: readonly ItemBase[],
+  prefixes: readonly Affix[],
+  suffixes: readonly Affix[],
+  rng: Rng,
+  options: DropOptions,
+): DropResult {
+  if (!rng.chance(options.dropChance)) return { kind: 'nothing' }
+  if (rng.chance(options.goldChance)) {
+    return { kind: 'gold', amount: rng.int(options.goldRange[0], options.goldRange[1]) }
+  }
+  // Only bases whose own level requirement is satisfied: a monster cannot drop
+  // gear that the item level gate forbids.
+  const eligible = bases.filter(base => base.level <= options.level)
+  const base = rng.pick(eligible.length > 0 ? eligible : bases)
+  if (base === undefined) return { kind: 'nothing' }
+  return { kind: 'item', item: createItem(base, prefixes, suffixes, rng, { level: options.level }) }
+}
+
+/**
+ * Sum a held stat across everything carried, for the character sheet.
+ *
+ * @param items - placed items.
+ * @param stat - the stat name.
+ * @returns the total.
+ */
+export function totalStat(items: readonly PlacedItem[], stat: string): number {
+  return items.reduce((total, placed) => total + (placed.item.stats[stat] ?? 0), 0)
+}
diff --git a/src/game/level-names-zh.ts b/src/game/level-names-zh.ts
new file mode 100644
index 0000000..faa52cd
--- /dev/null
+++ b/src/game/level-names-zh.ts
@@ -0,0 +1,112 @@
+// level-names-zh.ts — 关卡/场景的中文显示名（用于页面上的三级选择器）
+//
+// 出处说明（重要，避免误认为官方本地化）：
+// 这批译名是**社区通用译名**，由本项目手工整理；英文原名取自 `Levels.txt` 的 `LevelName`
+// 列（例如 1 = "Rogue Encampment"、33 = "Cathedral"），中文对照按国内玩家习惯写法。
+// 我们这份安装包里的 `data\local\LNG\CHI\string.tbl` 解出来是乱码（`.tbl` 解码器只对夹具
+// 验证过，尚未对真文件校准），所以**没有**直接采用官方简中字符串表；等 `.tbl` 解码对齐后
+// 可以换成官方译名，届时只需替换本表。
+//
+// 键是 `Levels.txt` 的 `Id`；页面从 pack 索引条目的 `slug`（形如 `33-act-1-cathedral`）里
+// 取第一个数字段就能对上。查不到时回退到索引里的英文 `levelName`。
+
+/** 五个 act 的中文名，下标即 act 号。 */
+export const ACT_NAMES_ZH: Readonly<Record<number, string>> = {
+  1: '第一章',
+  2: '第二章',
+  3: '第三章',
+  4: '第四章',
+  5: '第五章',
+}
+
+/** `Levels.txt` 的 `Id` → 中文场景名。 */
+export const LEVEL_NAMES_ZH: Readonly<Record<number, string>> = {
+  1: '罗格营地',
+  13: '洞穴二层',
+  14: '地下通道二层',
+  15: '窟窿二层',
+  16: '深坑二层',
+  20: '遗忘之塔',
+  25: '塔地窖五层',
+  26: '修道院大门',
+  27: '外回廊',
+  32: '内回廊',
+  33: '大教堂',
+  37: '地下墓穴四层',
+  38: '崔斯特瑞姆',
+  40: '鲁高因',
+  50: '后宫一层',
+  73: '都瑞尔的巢穴',
+  75: '库拉斯特码头',
+  90: '沼泽地坑三层',
+  91: '剥皮地牢三层',
+  93: '下水道二层',
+  94: '废弃神殿',
+  95: '荒废神庙',
+  96: '遗忘圣物室',
+  97: '遗忘神殿',
+  98: '废弃神庙',
+  99: '荒废圣物室',
+  102: '憎恨囚牢三层',
+  103: '火焰之河要塞',
+  109: '哈洛加斯',
+  120: '岩石之巅',
+  121: '尼拉塞克神殿',
+  124: '沃特厅',
+  131: '毁灭王座',
+  132: '世界之石大殿',
+  136: '崔斯特瑞姆',
+}
+
+/**
+ * DS1 变体后缀 → 方位名。
+ *
+ * 这些后缀是 D2 自己的命名习惯：城镇/回廊/鲁高因的 DS1 以 `N`/`E`/`S`/`W` 结尾
+ * （`TownN1`、`CourtW`、`LutN`…）。**只白名单这几个**，不做"末尾字母是方位"的猜测：
+ * `CryptCountess1` 末尾也是 `s`，按猜测会错成"南"。
+ */
+const DIRECTION_SUFFIXES: Readonly<Record<string, string>> = {
+  townn1: '北',
+  towne1: '东',
+  towns1: '南',
+  townw1: '西',
+  courtn: '北',
+  courte: '东',
+  courtw: '西',
+  lutn: '北',
+  lutw: '西',
+}
+
+/**
+ * 把一个变体后缀变成显示用的中文（拿不准就原样返回 DS1 名）。
+ *
+ * @param suffix - the part of the pack label after the level slug, e.g. `towns1`.
+ * @returns the label to show in the third selector.
+ */
+export function variantLabelZh(suffix: string): string {
+  return DIRECTION_SUFFIXES[suffix.toLowerCase()] ?? suffix
+}
+
+/**
+ * 从 pack 索引条目的 `slug` 里取 `Levels.txt` 的关卡 Id。
+ *
+ * @param slug - e.g. `33-act-1-cathedral`.
+ * @returns the id, or null when the slug does not start with one.
+ */
+export function levelIdOfSlug(slug: string): number | null {
+  const match = /^(\d+)-/.exec(slug)
+  return match?.[1] === undefined ? null : Number(match[1])
+}
+
+/**
+ * 一个场景的中文名，取不到就回退调用方给的英文名。
+ *
+ * @param slug - the scene slug from the pack index.
+ * @param fallback - the English name from the pack index.
+ * @returns the display name.
+ */
+export function sceneNameZh(slug: string, fallback: string): string {
+  const id = levelIdOfSlug(slug)
+  if (id === null) return fallback
+  return LEVEL_NAMES_ZH[id] ?? fallback
+}
diff --git a/src/game/map.ts b/src/game/map.ts
new file mode 100644
index 0000000..f5ab609
--- /dev/null
+++ b/src/game/map.ts
@@ -0,0 +1,391 @@
+/**
+ * Turning a decoded DS1 map and its DT1 library into something renderable and
+ * walkable.
+ *
+ * Three translations happen here, and each is the reason a map and a tile
+ * library cannot be used apart:
+ *
+ * 1. **A cell reference becomes a tile bitmap.** A DS1 cell holds `(style,
+ *    sequence)` per layer plus a wall orientation; the DT1 library is keyed by
+ *    exactly those fields. A miss is not an error — real maps reference
+ *    substitutions and trimmed libraries — so misses fall back from
+ *    `(style, sequence, orientation)` to `(style, sequence)` and then to
+ *    nothing, and are reported as counts.
+ * 2. **Cells become a draw order.** Diablo's map is drawn back to front:
+ *    floors first in cell order, then walls in screen order (further rows
+ *    first, so a nearer wall covers the one behind it). Depth is paint order,
+ *    never the depth buffer.
+ * 3. **Sub-tile flags become a collision grid.** Each tile carries a 5×5 grid
+ *    of flags, so collision resolution is `tileEdge / 5` — 32 pixels for the
+ *    standard 160-pixel tile — and a blocked sub-tile blocks walking for the
+ *    whole world, whatever layer placed it.
+ */
+import type { Dt1, Dt1Tile } from '../formats/dt1.ts'
+import type { Ds1 } from '../formats/ds1.ts'
+import type { SpriteFrame, SpriteSheet } from '../formats/sprite.ts'
+
+/** Sub-tiles per tile edge (the collision grid's resolution). */
+export const SUB_TILES_PER_TILE = 5
+
+/** One tile draw: which library tile, and where in the world. */
+export interface MapDraw {
+  /** Index into {@link MapScene.library} frames. */
+  readonly tileIndex: number
+  /** World-space left edge. */
+  readonly x: number
+  /** World-space top edge. */
+  readonly y: number
+  /** Cell coordinates, for debugging and sorting. */
+  readonly cellX: number
+  readonly cellY: number
+}
+
+/** A renderable, walkable map. */
+export interface MapScene {
+  /** Tile bitmaps, one frame per DT1 tile, in library order. */
+  readonly sheet: SpriteSheet
+  /** World width in pixels. */
+  readonly widthPx: number
+  /** World height in pixels. */
+  readonly heightPx: number
+  /** Floor draws, in cell order. */
+  readonly floors: readonly MapDraw[]
+  /** Wall draws, in painter's order. */
+  readonly walls: readonly MapDraw[]
+  /** Collision grid, row-major, 1 = blocked. */
+  readonly blocked: Uint8Array
+  /** Sub-tile size in pixels. */
+  readonly subTile: number
+  /** Collision grid width in sub-tiles. */
+  readonly gridWidth: number
+  /** Collision grid height in sub-tiles. */
+  readonly gridHeight: number
+  /** References that resolved to no library tile. */
+  readonly missingTiles: number
+}
+
+/**
+ * Composite a tile's blocks into one indexed bitmap.
+ *
+ * Blocks are placed by the decoder at tile size already, so compositing is a
+ * "non-zero wins" merge: the transparent index is 0 and later blocks paint over
+ * earlier ones where they have content.
+ *
+ * @param tile - the library tile.
+ * @returns a frame at the tile's size.
+ */
+function tileToFrame(tile: Dt1Tile): SpriteFrame {
+  const width = Math.max(tile.width, 1)
+  const height = Math.max(Math.abs(tile.height), 1)
+  const indices = new Uint8Array(width * height)
+  const mask = new Uint8Array(width * height)
+  for (const block of tile.blocks) {
+    for (let at = 0; at < indices.length && at < block.pixels.length; at += 1) {
+      const value = block.pixels[at]!
+      if (value === 0) continue
+      indices[at] = value
+      mask[at] = 1
+    }
+  }
+  return { width, height, indices, mask }
+}
+
+/**
+ * Build the tile sheet for a library: one frame per tile, in library order.
+ *
+ * @param library - the decoded DT1.
+ * @returns a sprite sheet the atlas packer can consume.
+ */
+export function libraryToSheet(library: Dt1): SpriteSheet {
+  return { groups: [{ frames: library.tiles.map(tileToFrame) }], width: null }
+}
+
+/** How a tile reference resolved, for diagnostics. */
+interface TileIndex {
+  /** `style:sequence:direction` → library index. */
+  readonly exact: Map<string, number>
+  /** `style:sequence` → first library index, used when the orientation misses. */
+  readonly loose: Map<string, number>
+}
+
+/**
+ * Index a library by the fields a DS1 cell references.
+ *
+ * @param library - the decoded DT1.
+ * @returns the lookup maps.
+ */
+export function indexLibrary(library: Dt1): TileIndex {
+  const exact = new Map<string, number>()
+  const loose = new Map<string, number>()
+  library.tiles.forEach((tile, index) => {
+    exact.set(`${String(tile.style)}:${String(tile.sequence)}:${String(tile.direction)}`, index)
+    const looseKey = `${String(tile.style)}:${String(tile.sequence)}`
+    if (!loose.has(looseKey)) loose.set(looseKey, index)
+  })
+  return { exact, loose }
+}
+
+/**
+ * Resolve one cell reference.
+ *
+ * @param index - the library index.
+ * @param style - DS1 style field.
+ * @param sequence - DS1 sequence field.
+ * @param direction - orientation, for walls (null for floors).
+ * @returns the library tile index, or undefined when nothing matches.
+ */
+function lookup(index: TileIndex, style: number, sequence: number, direction: number | null): number | undefined {
+  if (direction !== null) {
+    const exact = index.exact.get(`${String(style)}:${String(sequence)}:${String(direction)}`)
+    if (exact !== undefined) return exact
+  }
+  return index.loose.get(`${String(style)}:${String(sequence)}`)
+}
+
+/**
+ * Build a renderable, walkable scene from a map and its library.
+ *
+ * @param level - the decoded DS1.
+ * @param library - the decoded DT1.
+ * @returns the scene.
+ */
+export function buildMapScene(level: Ds1, library: Dt1): MapScene {
+  const index = indexLibrary(library)
+  const tileWidth = Math.max(...library.tiles.map(tile => tile.width), 1)
+  const tileHeight = Math.max(...library.tiles.map(tile => Math.abs(tile.height)), 1)
+  const subTileX = tileWidth / SUB_TILES_PER_TILE
+  const subTileY = tileHeight / SUB_TILES_PER_TILE
+  const widthPx = level.width * tileWidth
+  const heightPx = level.height * tileHeight
+  const gridWidth = level.width * SUB_TILES_PER_TILE
+  const gridHeight = level.height * SUB_TILES_PER_TILE
+  const blocked = new Uint8Array(gridWidth * gridHeight)
+
+  const floors: MapDraw[] = []
+  const walls: MapDraw[] = []
+  let missingTiles = 0
+
+  for (let cellY = 0; cellY < level.height; cellY += 1) {
+    for (let cellX = 0; cellX < level.width; cellX += 1) {
+      const cell = level.cells[cellY]?.[cellX]
+      if (cell === undefined) continue
+      const x = cellX * tileWidth
+      const y = cellY * tileHeight
+
+      for (const floor of cell.floors) {
+        const tileIndex = lookup(index, floor.style, floor.sequence, null)
+        if (tileIndex === undefined) { missingTiles += 1; continue }
+        floors.push({ tileIndex, x, y, cellX, cellY })
+        applyCollision(blocked, gridWidth, gridHeight, cellX, cellY, library.tiles[tileIndex])
+      }
+      for (const wall of cell.walls) {
+        const tileIndex = lookup(index, wall.style, wall.sequence, wall.type)
+        if (tileIndex === undefined) { missingTiles += 1; continue }
+        walls.push({ tileIndex, x, y, cellX, cellY })
+        applyCollision(blocked, gridWidth, gridHeight, cellX, cellY, library.tiles[tileIndex])
+      }
+    }
+  }
+
+  // Painter's order for walls: back rows first, and within a row left to right.
+  // Once walls from further cells exist, screen order (y + x) is what keeps a
+  // nearer wall in front — cells are already visited row-major, so the sort is
+  // on the diagonal, which is the isometric depth.
+  walls.sort((a, b) => (a.cellY + a.cellX) - (b.cellY + b.cellX) || a.cellY - b.cellY)
+
+  return {
+    sheet: libraryToSheet(library),
+    widthPx, heightPx, floors, walls, blocked,
+    subTile: subTileX,
+    gridWidth, gridHeight,
+    missingTiles,
+  }
+}
+
+/**
+ * Stamp one tile's sub-tile flags into the collision grid.
+ *
+ * A tile larger than its sub-tile stride (a wall taller than the cell, which is
+ * the normal case for roofs) is clamped to the grid rather than rejected.
+ *
+ * @param blocked - the grid to write.
+ * @param gridWidth - grid width in sub-tiles.
+ * @param gridHeight - grid height in sub-tiles.
+ * @param cellX - the owning cell's column.
+ * @param cellY - the owning cell's row.
+ * @param tile - the tile whose flags are stamped.
+ */
+function applyCollision(
+  blocked: Uint8Array,
+  gridWidth: number,
+  gridHeight: number,
+  cellX: number,
+  cellY: number,
+  tile: Dt1Tile | undefined,
+): void {
+  if (tile === undefined) return
+  for (let subY = 0; subY < SUB_TILES_PER_TILE; subY += 1) {
+    for (let subX = 0; subX < SUB_TILES_PER_TILE; subX += 1) {
+      const flags = tile.subTileFlags[subY * SUB_TILES_PER_TILE + subX]
+      if (flags === undefined || (!flags.blockWalk && !flags.blockPlayerWalk)) continue
+      const gridX = cellX * SUB_TILES_PER_TILE + subX
+      const gridY = cellY * SUB_TILES_PER_TILE + subY
+      if (gridX < 0 || gridX >= gridWidth || gridY < 0 || gridY >= gridHeight) continue
+      blocked[gridY * gridWidth + gridX] = 1
+    }
+  }
+}
+
+/**
+ * Whether a world-space box overlaps blocked sub-tiles.
+ *
+ * @param scene - the scene whose grid to test.
+ * @param tileWidth - library tile width, the grid's stride.
+ * @param tileHeight - library tile height.
+ * @param x - box centre x.
+ * @param y - box centre y.
+ * @param width - box width.
+ * @param height - box height.
+ * @returns true when any covered sub-tile is blocked.
+ */
+export function isBlocked(
+  scene: MapScene,
+  tileWidth: number,
+  tileHeight: number,
+  x: number,
+  y: number,
+  width: number,
+  height: number,
+): boolean {
+  const subW = tileWidth / SUB_TILES_PER_TILE
+  const subH = tileHeight / SUB_TILES_PER_TILE
+  const fromX = Math.floor((x - width / 2) / subW)
+  const toX = Math.floor((x + width / 2) / subW)
+  const fromY = Math.floor((y - height / 2) / subH)
+  const toY = Math.floor((y + height / 2) / subH)
+  for (let gridY = fromY; gridY <= toY; gridY += 1) {
+    for (let gridX = fromX; gridX <= toX; gridX += 1) {
+      // Outside the map counts as blocked: walking off the edge is not a thing.
+      if (gridX < 0 || gridX >= scene.gridWidth || gridY < 0 || gridY >= scene.gridHeight) return true
+      if (scene.blocked[gridY * scene.gridWidth + gridX] === 1) return true
+    }
+  }
+  return false
+}
+
+/**
+ * Count the blocked sub-tiles a box covers.
+ *
+ * Movement needs the *count* rather than a boolean: a character that is already
+ * overlapping a blocked sub-tile (bad spawn, a tile that turned solid under it)
+ * must still be able to walk out, and the rule for that is "never make it
+ * worse".
+ *
+ * @param scene - the scene whose grid to test.
+ * @param tileWidth - library tile width, the grid's stride.
+ * @param tileHeight - library tile height.
+ * @param x - box centre x.
+ * @param y - box centre y.
+ * @param width - box width.
+ * @param height - box height.
+ * @returns the number of covered sub-tiles that are blocked, with off-map tiles
+ * counting as blocked.
+ */
+export function blockedOverlap(
+  scene: MapScene,
+  tileWidth: number,
+  tileHeight: number,
+  x: number,
+  y: number,
+  width: number,
+  height: number,
+): number {
+  const subW = tileWidth / SUB_TILES_PER_TILE
+  const subH = tileHeight / SUB_TILES_PER_TILE
+  let blocked = 0
+  for (let gridY = Math.floor((y - height / 2) / subH); gridY <= Math.floor((y + height / 2) / subH); gridY += 1) {
+    for (let gridX = Math.floor((x - width / 2) / subW); gridX <= Math.floor((x + width / 2) / subW); gridX += 1) {
+      if (gridX < 0 || gridX >= scene.gridWidth || gridY < 0 || gridY >= scene.gridHeight) {
+        blocked += 1
+        continue
+      }
+      if (scene.blocked[gridY * scene.gridWidth + gridX] === 1) blocked += 1
+    }
+  }
+  return blocked
+}
+
+/**
+ * Find a spawn position whose box covers no blocked sub-tile.
+ *
+ * A map's blocked sub-tiles come from its tiles, so nothing guarantees that the
+ * geometric centre is walkable — Diablo's own spawn points are data, and until
+ * those are loaded a search is the honest substitute. Falls back to the centre
+ * when the map has no free spot at all (a fully sealed map is a content bug,
+ * not something to crash on).
+ *
+ * @param scene - the scene to search.
+ * @param tileWidth - library tile width.
+ * @param tileHeight - library tile height.
+ * @param width - box width.
+ * @param height - box height.
+ * @returns a free world position.
+ */
+export function findFreeSpawn(
+  scene: MapScene,
+  tileWidth: number,
+  tileHeight: number,
+  width: number,
+  height: number,
+): { x: number; y: number } {
+  const subW = tileWidth / SUB_TILES_PER_TILE
+  const subH = tileHeight / SUB_TILES_PER_TILE
+  let best = { x: scene.widthPx / 2, y: scene.heightPx / 2 }
+  let bestOverlap = Number.POSITIVE_INFINITY
+  // Spiral out from the centre so the chosen spot stays near where the map's
+  // author would have put the player.
+  const centreX = Math.floor(scene.gridWidth / 2)
+  const centreY = Math.floor(scene.gridHeight / 2)
+  const maxRadius = Math.max(scene.gridWidth, scene.gridHeight)
+  for (let radius = 0; radius < maxRadius; radius += 1) {
+    for (let dy = -radius; dy <= radius; dy += 1) {
+      for (let dx = -radius; dx <= radius; dx += 1) {
+        if (Math.max(Math.abs(dx), Math.abs(dy)) !== radius) continue
+        const x = (centreX + dx + 0.5) * subW
+        const y = (centreY + dy + 0.5) * subH
+        const overlap = blockedOverlap(scene, tileWidth, tileHeight, x, y, width, height)
+        if (overlap === 0) return { x, y }
+        if (overlap < bestOverlap) { bestOverlap = overlap; best = { x, y } }
+      }
+    }
+  }
+  return best
+}
+
+/**
+ * Where an actor belongs inside a wall draw list.
+ *
+ * Walls are drawn far to near, so an actor is inserted at the first wall that is
+ * *nearer* than it — the index whose depth key (`cellY + cellX`) first exceeds the
+ * actor's. That single rule is what makes standing behind a wall look right
+ * without a depth buffer, and keeping it a pure function keeps it testable
+ * without a renderer.
+ *
+ * @param walls - wall draws, in painter's order.
+ * @param cellX - the actor's cell column.
+ * @param cellY - the actor's cell row.
+ * @returns the index to insert at (equal to the wall count when the actor is
+ * nearest and goes last).
+ */
+export function depthInsertIndex(
+  walls: readonly Pick<MapDraw, 'cellX' | 'cellY'>[],
+  cellX: number,
+  cellY: number,
+): number {
+  const depth = cellX + cellY
+  for (let index = 0; index < walls.length; index += 1) {
+    const wall = walls[index]!
+    if (wall.cellX + wall.cellY > depth) return index
+  }
+  return walls.length
+}
diff --git a/src/game/maze.ts b/src/game/maze.ts
new file mode 100644
index 0000000..fc412fd
--- /dev/null
+++ b/src/game/maze.ts
@@ -0,0 +1,1795 @@
+/**
+ * Diablo II's random-maze level generator (`Levels.txt.DrlgType == 1`).
+ *
+ * 70 of the game's 136 levels have no fixed layout: their shape is produced at
+ * load time from `LvlMaze.txt` (how many sections, how big each section is, and
+ * how eagerly neighbouring sections are joined) plus the level type's
+ * `LvlPrest.txt` *piece* rows — each piece a DS1 that knows which of its four
+ * sides has a doorway. This module rebuilds that generator and emits a single
+ * synthesized {@link Ds1} the existing isometric renderer can draw unmodified.
+ *
+ * ## Provenance
+ *
+ * This is an **independent TypeScript port** of the level-generation logic in
+ * **ThePhrozenKeep/D2MOO** ("Diablo II Method and Ordinal Overhaul", a C++
+ * re-implementation of Diablo II 1.10f). D2MOO ships no licence file, so no code
+ * was copied: every algorithm below was read from that project and re-expressed
+ * here in this repository's own structure and naming, with the source function
+ * cited at each step. The algorithms themselves are Blizzard's, and D2MOO's
+ * contribution is having recovered them from the shipped binary.
+ *
+ * Primary sources, all under `source/D2Common/` in D2MOO:
+ *
+ * - `src/Drlg/DrlgMaze.cpp` — `DRLGMAZE_GenerateLevel` (the per-level-type
+ *   dispatch), `DRLGMAZE_AddAdjacentMazeRoom` + `DRLGMAZE_BuildBasicMaze` +
+ *   `DRLGMAZE_MergeMazeRooms` (placement and the `Merge` roll),
+ *   `DRLGMAZE_InitBasicMazeLayout` (the ring layout), `DRLGMAZE_PickRoomPreset`
+ *   (side bitmask → piece), `DRLGMAZE_RollAct_1_2_3_BasicPresets` (the `Theme`
+ *   pass), `DRLGMAZE_ScanReplaceSpecialPreset` (`Prev`/`Next`/quest replacement),
+ *   `DRLGMAZE_PlaceArcaneSanctuary`, `DRLGMAZE_PlaceAct5LavaPresets`,
+ *   `DRLGMAZE_FillBlankMazeSpaces`, `DRLGMAZE_PlaceAct2TombPrev_Act5BaalPrev`.
+ * - `src/Drlg/DrlgDrlgRoom.cpp` — `DRLG_ComputeManhattanDistance`,
+ *   `DRLG_GetRectanglesManhattanDistanceAndCheckNotOverlapping`,
+ *   `DRLGMAZE_CheckRoomNotOverlaping`, `DRLGROOM_AllocDrlgOrthsForRooms`.
+ * - `src/Drlg/DrlgDrlg.cpp` — `DRLG_GetDirectionFromCoordinates`,
+ *   `DRLG_UpdateRoomExCoordinates`.
+ * - `src/Drlg/DrlgPreset.cpp` — `DRLGPRESET_InitPresetRoomGrids` and
+ *   `DRLGPRESET_AddPresetUnitToDrlgMap`, which fix the stamping geometry and the
+ *   unit of a DS1 object's coordinates.
+ * - `doc/Coordinates.md` — the coordinate systems.
+ *
+ * ## What D2MOO settles that this repository did not know
+ *
+ * **`LvlMaze.Merge` is a per-mille probability, not a flag.** Both
+ * `DRLGMAZE_AddAdjacentMazeRoom` (inline) and `DRLGMAZE_MergeMazeRooms` contain
+ * `if (SEED_RollRandomNumber(&i->pSeed) % 1000 < pLevel->pMaze->dwMerge)` before
+ * adding an extra doorway. So while a level grows, every *accidental* adjacency
+ * between the room just placed and some other already-placed room (orthogonally
+ * touching, not already connected) is joined with probability `Merge / 1000`.
+ * `Merge = 0` yields a tree (Act 1's cave treasures), `Merge = 500` joins about
+ * half of those contacts, and `Merge = 1000` (Act 2's Harem, Basement and the
+ * Arcane Sanctuary) joins all of them. The shipped values are 0, 500, 800 and
+ * 1000, which is why a per-mille reading is the only one that fits. The knowledge
+ * base's "possibly related to how adjacent ds1s are connected, but what the
+ * different values are for is unknown" is answered: it controls how many *loops*
+ * the maze has, i.e. how many alternate routes exist between rooms.
+ *
+ * **Connectivity is structural, not luck.** Growth only ever attaches a new room
+ * to an existing one and immediately records a doorway between them
+ * (`DRLGROOM_AllocDrlgOrthsForRooms`), so the doorway graph always contains a
+ * spanning tree rooted at the first room. `Merge` only ever *adds* doorways.
+ * {@link generateMaze} re-derives that with a flood fill and throws if it ever
+ * fails, so the guarantee is checked rather than asserted.
+ *
+ * **A maze piece is exactly one cell larger than its section.** `LvlMaze.SizeX`
+ * is the placement stride (24 in Act 1) while the piece DS1 is 25×25 — verified
+ * against the shipped archives: `Act1/Caves/CaveW.ds1` is 25×25 with
+ * `LvlPrest.SizeX = 24`. `DRLGPRESET_InitPresetRoomGrids` confirms the intent: it
+ * fills a room grid of `nTileWidth + 1` by `nTileHeight + 1` cells from the
+ * piece, so adjacent pieces overlap by exactly one cell and the later-stamped
+ * piece owns the shared border. Both halves of that border are authored to match,
+ * so the overwrite is harmless. The repository's assumption was correct.
+ *
+ * **Objects are in sub-tiles, cells are in cells.**
+ * `DRLGPRESET_AddPresetUnitToDrlgMap` converts the room's *tile* origin with
+ * `DUNGEON_GameTileToSubtileCoords` (×5) and *then* adds the DS1 object's own
+ * coordinates, which are therefore already sub-tiles relative to the piece. A
+ * stamp offset of `N` cells shifts an object by `N * 5` sub-tiles, exactly as
+ * this repository assumed.
+ */
+import type { Ds1, Ds1Cell, Ds1Floor, Ds1Object, Ds1Wall } from '../formats/ds1.ts'
+import { Rng } from './rng.ts'
+import { SUB_TILES_PER_TILE } from './map.ts'
+
+/* ------------------------------------------------------------------------- *
+ * Directions
+ * ------------------------------------------------------------------------- */
+
+/**
+ * Direction indices, in D2MOO's `D2AltDirections` order.
+ *
+ * `DRLG_GetDirectionFromCoordinates` returns the `D2Directions` *names* but the
+ * same numbers, and D2MOO relies on that coincidence: `DIRECTION_SOUTHWEST` is 0
+ * and `ALTDIR_WEST` is 0, `DIRECTION_NORTHWEST`/`ALTDIR_NORTH` are 1,
+ * `DIRECTION_SOUTHEAST`/`ALTDIR_EAST` are 2 and `DIRECTION_NORTHEAST`/`ALTDIR_SOUTH`
+ * are 3. Both are reproduced here as one space, since a maze direction is always
+ * an offset on the cell grid.
+ *
+ * The signs are the ones `doc/Coordinates.md` states: East is +X, West is -X,
+ * South is +Y, North is -Y. Note that D2's *names* for the quarter directions do
+ * not mean screen directions — `DIRECTION_NORTHEAST` is +Y, i.e. towards the
+ * bottom-left of the isometric view. Only the numbers are meaningful.
+ */
+export const DIRECTION_WEST = 0
+/** North is -Y in game coordinates. */
+export const DIRECTION_NORTH = 1
+/** East is +X in game coordinates. */
+export const DIRECTION_EAST = 2
+/** South is +Y in game coordinates. */
+export const DIRECTION_SOUTH = 3
+
+/**
+ * The side bit `DRLGMAZE_PickRoomPreset` sets for each direction.
+ *
+ * It ORs 1 for direction 0, 8 for 1, 2 for 2 and 4 for 3, so the resulting 4-bit
+ * value is **W=1, E=2, S=4, N=8**. That looks arbitrary until it is compared with
+ * `LvlPrest.txt`: side tokens are written with their letters in N,S,E,W order and
+ * read as a bitfield most-significant-bit first, so `NS` = 8+4 = 12, `EW` = 2+1 =
+ * 3 and `NSEW` = 15. Verified against the real table — `Act 1 - Cave
+ * W/E/EW/S/SW/SE/SEW/N/NW/NE/NEW/NS/NSW/NSE/NSEW` are fifteen consecutive rows
+ * following the level type's base row, so a piece's row number is `base + mask`.
+ */
+const DIRECTION_SIDE_BIT = [1, 8, 2, 4] as const
+
+/**
+ * Cell offset for one step in a direction.
+ *
+ * Directions 4..7 are the diagonals, which only `DRLGMAZE_FillBlankMazeSpaces`
+ * uses (it tries all eight). Quarters and diagonals were cross-checked against
+ * `DRLGMAZE_LinkMazeRooms`' eight `case`s.
+ *
+ * @param direction - 0..7.
+ * @param width - one section's width in cells.
+ * @param height - one section's height in cells.
+ * @returns the offset.
+ */
+function step(direction: number, width: number, height: number): { dx: number; dy: number } {
+  const dx = (direction === DIRECTION_WEST || direction === 4 || direction === 7 ? -width
+    : direction === DIRECTION_EAST || direction === 5 || direction === 6 ? width : 0)
+  const dy = (direction === DIRECTION_NORTH || direction === 4 || direction === 5 ? -height
+    : direction === DIRECTION_SOUTH || direction === 6 || direction === 7 ? height : 0)
+  return { dx, dy }
+}
+
+/* ------------------------------------------------------------------------- *
+ * Side tokens
+ * ------------------------------------------------------------------------- */
+
+/** The four side letters, in the order `LvlPrest.txt` writes them. */
+const SIDE_LETTERS = ['N', 'S', 'E', 'W'] as const
+
+/**
+ * Decode a side token such as `NSEW`, `EW` or `N` into a bitmask.
+ *
+ * @param token - the token; characters other than `NSEW` are ignored, so a whole
+ *   piece name may be passed.
+ * @returns the mask, 0..15.
+ */
+export function sideMaskFromToken(token: string): number {
+  let mask = 0
+  for (const letter of token.toUpperCase()) {
+    const index = SIDE_LETTERS.indexOf(letter as (typeof SIDE_LETTERS)[number])
+    if (index !== -1) mask |= 1 << (3 - index)
+  }
+  return mask
+}
+
+/**
+ * Encode a bitmask the way `LvlPrest.txt` spells it.
+ *
+ * @param mask - the mask, 0..15.
+ * @returns the token, e.g. `NSEW`; an empty string for 0.
+ */
+export function sideTokenFromMask(mask: number): string {
+  let token = ''
+  SIDE_LETTERS.forEach((letter, index) => {
+    if ((mask & (1 << (3 - index))) !== 0) token += letter
+  })
+  return token
+}
+
+/* ------------------------------------------------------------------------- *
+ * Public request / response shapes
+ * ------------------------------------------------------------------------- */
+
+/** How a maze piece participates in generation. */
+export type MazePieceKind =
+  | 'entrance'
+  | 'room'
+  | 'theme'
+  | 'prev'
+  | 'next'
+  | 'down'
+  | 'quest'
+  | 'treasure'
+
+/**
+ * One `LvlPrest.txt` row that can be stamped into a maze level.
+ *
+ * The caller owns the classification, because it is the only party that knows
+ * which DS1 files sit behind each row. {@link classifyMazePieceName} does that
+ * classification for callers that want it, since the trailing-token grammar is
+ * subtle enough to be worth centralising.
+ */
+export interface MazePiece {
+  /** `LvlPrest.txt` `Name`, e.g. `Act 1 - Cave NSEW`. */
+  readonly name: string
+  /** Which generator pass may place this piece. */
+  readonly kind: MazePieceKind
+  /**
+   * The side token decoded from the name — `NSEW`, `EW`, `N`, or `''` for a piece
+   * with no doorways (`Entrance`).
+   */
+  readonly sides: string
+  /**
+   * Decoded variants, in `File1..File6` order.
+   *
+   * A piece usually has several: `Act 1 - Cave W` ships `CaveW.ds1` and
+   * `CaveW2.ds1`. D2MOO walks them round-robin per piece so consecutive rooms of
+   * the same shape do not look identical (`DRLGMAZE_RollBasicPresets`), and
+   * {@link generateMaze} does the same.
+   */
+  readonly levels: readonly Ds1[]
+}
+
+/** Everything {@link generateMaze} needs. */
+export interface MazeRequest {
+  /** `Levels.txt` `Id`; used in diagnostics and for a few per-level specials. */
+  readonly levelId: number
+  /** `Levels.txt` `Name`, e.g. `Act 1 - Cave 1`. */
+  readonly levelName: string
+  /** `LvlMaze.txt` `SizeX`: the section stride in cells. */
+  readonly sectionSize: number
+  /**
+   * `LvlMaze.txt` `SizeY`.
+   *
+   * Defaults to {@link sectionSize}. It is a separate field because the two
+   * genuinely differ for Act 1's Barracks (`SizeX = 10`, `SizeY = 14`), and a
+   * single number would silently produce a wrong layout there.
+   */
+  readonly sectionHeight?: number
+  /** `LvlMaze.txt` `Rooms`: the target number of sections. */
+  readonly minRooms: number
+  /**
+   * `LvlMaze.txt` `Merge`, in per-mille.
+   *
+   * Values in the shipped table are 0, 500, 800 and 1000.
+   */
+  readonly merge: number
+  /** Seed for the whole generator; reported back in `stats`. */
+  readonly seed: number
+  /** The level type's pieces, classified by kind and side token. */
+  readonly pieces: readonly MazePiece[]
+  /**
+   * `LvlTypes.txt` name, e.g. `Act 1 - Cave`.
+   *
+   * Optional because it is derivable from {@link pieces} — every piece name
+   * starts with it — and the derivation is attempted when it is absent.
+   */
+  readonly levelTypeName?: string
+  /**
+   * `Levels.txt` `Id` of the tomb holding the Horadric Staff, when the caller
+   * knows it. In the shipped game this is one of the seven Tal Rasha tombs and
+   * that tomb's `LvlMaze.Rooms` is tripled.
+   */
+  readonly staffTombLevelId?: number
+  /** Boss tomb (`LvlMaze.Rooms` doubled); see {@link staffTombLevelId}. */
+  readonly bossTombLevelId?: number
+}
+
+/** The generated level. */
+export interface MazeResult {
+  /** A single synthesized map covering every placed section. */
+  readonly level: Ds1
+  /** What the generator did, for reporting and tests. */
+  readonly stats: Record<string, unknown>
+}
+
+/* ------------------------------------------------------------------------- *
+ * Classification
+ * ------------------------------------------------------------------------- */
+
+/** Roles whose names are spelled `<role> <sides>` after the level type. */
+const KIND_PREFIXES: readonly (readonly [string, MazePieceKind])[] = [
+  ['Den Of Evil', 'quest'],
+  ['Coldcrow', 'quest'],
+  ['Chest', 'treasure'],
+  ['Treasure', 'treasure'],
+  ['Down', 'down'],
+  ['Next', 'next'],
+  ['Prev', 'prev'],
+  ['Theme', 'theme'],
+]
+
+/**
+ * Classify one `LvlPrest.txt` piece name.
+ *
+ * The grammar is `<level type name> [<role>] [<sides>]`: `Act 1 - Cave NSEW` is a
+ * plain room, `Act 1 - Cave Theme NS` a themed variant, `Act 1 - Cave Prev W` a
+ * staircase, `Act 1 - Cave Treasure 3` a numbered treasure room. A name that does
+ * not start with the level type's name is not a piece of that type and yields
+ * `null`, which is how `Act 1 - DOE Entrance` stays out of the `Act 1 - Cave`
+ * group even though D2MOO treats its row as that group's base.
+ *
+ * @param name - the `LvlPrest.txt` `Name`.
+ * @param levelTypeName - the owning `LvlTypes.txt` name.
+ * @returns the kind and side token, or `null` when the name is not a piece.
+ */
+export function classifyMazePieceName(name: string, levelTypeName: string): { kind: MazePieceKind; sides: string } | null {
+  if (!name.startsWith(levelTypeName)) return null
+  const rest = name.slice(levelTypeName.length).trim()
+  if (rest === '') return { kind: 'entrance', sides: '' }
+  for (const [prefix, kind] of KIND_PREFIXES) {
+    if (!rest.startsWith(prefix)) continue
+    const tail = rest.slice(prefix.length).trim()
+    // `Treasure 1` is numbered rather than sided; everything else uses sides.
+    if (kind === 'treasure' && /^\d+$/.test(tail)) return { kind, sides: '' }
+    return { kind, sides: tail }
+  }
+  // Anything left is a bare side token: `W`, `EW`, `NSEW`, ...
+  return /^[NSEW]+$/.test(rest) ? { kind: 'room', sides: rest } : null
+}
+
+/**
+ * Derive a level type's name from its pieces.
+ *
+ * Used when {@link MazeRequest.levelTypeName} is omitted: the name is the longest
+ * prefix shared by every piece name, trimmed back to a word boundary, because
+ * `Act 1 - Cave NSEW` and `Act 1 - Cave Theme W` agree on `Act 1 - Cave ` and the
+ * trailing space is the boundary.
+ *
+ * @param pieces - the level's pieces.
+ * @returns the inferred name, or `null` when the pieces disagree.
+ */
+export function inferLevelTypeName(pieces: readonly MazePiece[]): string | null {
+  const first = pieces[0]
+  if (first === undefined) return null
+  let prefix = first.name
+  for (const piece of pieces) {
+    while (prefix.length > 0 && !piece.name.startsWith(prefix)) prefix = prefix.slice(0, -1)
+  }
+  const trimmed = prefix.replace(/[\s-]+$/, '')
+  return trimmed === '' ? null : trimmed
+}
+
+/* ------------------------------------------------------------------------- *
+ * Level-type profiles
+ * ------------------------------------------------------------------------- */
+
+/**
+ * One `DRLGMAZE_ScanReplaceSpecialPreset` call site.
+ *
+ * That function has two modes and both are reproduced: it first looks for the
+ * earliest room still holding the *plain* piece for this side pattern and swaps
+ * the piece in place; only if no such room exists does it grow a brand-new room
+ * off the first available room in `direction` and put the special piece there.
+ *
+ * `DRLGMAZE_ReplaceRoomPreset`, used by Act 3's Sewer 1, is the in-place-only
+ * variant and is modelled with {@link inPlaceOnly}.
+ */
+interface SpecialStep {
+  /** Which kind of special piece to place. */
+  readonly kind: 'prev' | 'next' | 'down' | 'quest' | 'treasure'
+  /** Side token of the plain room this step replaces, e.g. `N`. */
+  readonly plainSides: string
+  /** Side token of the special piece. */
+  readonly sides: string
+  /** Direction used when a new room must be created (`nDirection`). */
+  readonly direction: number
+  /** Only replace an existing room; never grow one (D2MOO's `ReplaceRoomPreset`). */
+  readonly inPlaceOnly?: boolean
+}
+
+/**
+ * A group of four candidate steps selected by one rotating counter.
+ *
+ * D2MOO draws `nRand = SEED_RollRandomNumber(&pLevel->pSeed) & 3` once and then
+ * indexes each hardcoded table with it, incrementing the counter after every
+ * call that actually happens. So the *n*-th group applied to a level uses entry
+ * `(nRand + n) % 4`, not the first entry. Modelling the tables as groups with a
+ * shared cursor reproduces that exactly; flattening them into one ordered list
+ * would not.
+ */
+interface SpecialGroup {
+  readonly kind: SpecialStep['kind']
+  /** Four entries, in D2MOO's table order (N, E, S, W). */
+  readonly entries: readonly Omit<SpecialStep, 'kind'>[]
+  /** Restrict the group to these `Levels.txt` ids; absent means every level. */
+  readonly levelIds?: readonly number[]
+  /** Apply to every level *except* these ids (D2MOO's `else` arms). */
+  readonly exceptLevelIds?: readonly number[]
+  /** Only replace; never grow (D2MOO's `ReplaceRoomPreset`). */
+  readonly inPlaceOnly?: boolean
+}
+
+/**
+ * How one maze level type is laid out.
+ *
+ * D2MOO's `DRLGMAZE_GenerateLevel` `switch (pLevel->nLevelType)` turned into
+ * data. Where that function has both a `while (pLevel->nRooms < nRooms)` loop and
+ * a `DRLGMAZE_BuildBasicMaze` call, the two are the same growth primitive spelled
+ * twice — see {@link growMaze} — so both are represented by `grow: true`.
+ */
+export interface MazeLevelProfile {
+  /** `LvlTypes.txt` name this profile applies to. */
+  readonly levelTypeName: string
+  /**
+   * `DRLGMAZE_InitBasicMazeLayout(nRoomsPerDirection)`: pre-place a closed ring of
+   * `4n - 4` rooms, then grow from it. Act 3's Sewer 1 overrides this with 5.
+   */
+  readonly ring?: number
+  /** Grow to `LvlMaze.Rooms` sections with the random-adjacency loop. */
+  readonly grow: boolean
+  /**
+   * `DRLGMAZE_RollAct_1_2_3_BasicPresets`: convert up to
+   * `max(rooms / 5 + 1, 2)` plain rooms to their `Theme` variant.
+   */
+  readonly theme: boolean
+  /** `'catacombs'`: the Act 1 Catacombs opening moves. */
+  readonly opening?: 'catacombs'
+  /** Chain of three rooms plus a `Prev` piece on the entrance. */
+  readonly prevChain?: 'tomb' | 'baal'
+  /** `DRLGMAZE_PlaceArcaneSanctuary`: four 15-room spiral branches. */
+  readonly arcane?: boolean
+  /** `DRLGMAZE_PlaceAct5LavaPresets`: two fixed pieces plus blank filling. */
+  readonly lavaPairs?: boolean
+  /**
+   * Levels that are a single fixed `LvlPrest.txt` row rather than a maze, with
+   * the exact names to try, in order. Used for the three Act 5 ice set pieces and
+   * Claw Viper Temple level 2.
+   */
+  readonly singleRoom?: Readonly<Record<number, readonly string[]>>
+  /** `Prev`/`Next`/quest/treasure replacement groups, in call order. */
+  readonly specials: readonly SpecialGroup[]
+}
+
+/** The four single-side layouts, in the order the D2MOO tables list them. */
+const NESW = ['N', 'E', 'S', 'W'] as const
+
+/** Direction paired with each of {@link NESW} in the D2MOO tables. */
+const NESW_DIRECTIONS = [DIRECTION_SOUTH, DIRECTION_WEST, DIRECTION_NORTH, DIRECTION_EAST] as const
+
+/**
+ * Build the four side entries of a D2MOO table.
+ *
+ * @param plainSides - the four plain side tokens, in table order.
+ * @returns the entries.
+ */
+function entries(plainSides: readonly string[] = NESW): Omit<SpecialStep, 'kind'>[] {
+  return plainSides.map((sides, index) => ({ plainSides: sides, sides, direction: NESW_DIRECTIONS[index]! }))
+}
+
+/**
+ * The per-level-type layout table, transcribed from `DRLGMAZE_GenerateLevel`.
+ *
+ * `specials` covers the replacement tables that live inline in that function.
+ * The per-act decoration passes that follow it in D2MOO — `DRLGMAZE_PlaceAct2TombStuff`,
+ * `DRLGMAZE_PlaceAct3DungeonStuff`, `DRLGMAZE_PlaceAct5IceStuff` and the rest —
+ * are **not** reproduced; they are listed in `stats.unimplementedPasses` so the
+ * omission is visible rather than silent.
+ */
+export const MAZE_LEVEL_TYPE_PROFILES: readonly MazeLevelProfile[] = [
+  {
+    levelTypeName: 'Act 1 - Cave',
+    grow: true,
+    theme: true,
+    specials: [
+      { kind: 'prev', entries: entries() },
+      { kind: 'quest', entries: entries(), levelIds: [8] },
+      { kind: 'down', entries: entries(), exceptLevelIds: [8] },
+      { kind: 'quest', entries: entries(), levelIds: [9] },
+      { kind: 'next', entries: entries(), levelIds: [10] },
+    ],
+  },
+  {
+    levelTypeName: 'Act 1 - Crypt',
+    grow: true,
+    theme: true,
+    specials: [
+      { kind: 'prev', entries: entries() },
+      { kind: 'quest', entries: entries(), levelIds: [18] },
+      { kind: 'treasure', entries: entries(), levelIds: [19] },
+      { kind: 'next', entries: entries(), levelIds: [21, 22, 23, 24] },
+    ],
+  },
+  {
+    levelTypeName: 'Act 1 - Barracks',
+    ring: 2,
+    grow: true,
+    theme: true,
+    specials: [],
+  },
+  {
+    levelTypeName: 'Act 1 - Jail',
+    ring: 2,
+    grow: true,
+    theme: true,
+    specials: [
+      { kind: 'prev', entries: entries() },
+      { kind: 'treasure', entries: entries(), levelIds: [29] },
+      { kind: 'quest', entries: entries(), levelIds: [30] },
+      // D2MOO's `else` hangs off the `JAILLEV3` test, so levels 1 and 2 get a
+      // `Next` staircase and level 3 gets the Cathedral descent instead.
+      { kind: 'next', entries: entries(), levelIds: [29, 30] },
+      { kind: 'quest', entries: entries(), levelIds: [31] },
+    ],
+  },
+  {
+    levelTypeName: 'Act 1 - Catacombs',
+    grow: true,
+    theme: true,
+    opening: 'catacombs',
+    specials: [
+      { kind: 'next', entries: entries() },
+      { kind: 'treasure', entries: entries(), levelIds: [35] },
+    ],
+  },
+  { levelTypeName: 'Act 2 - Sewer', ring: 2, grow: true, theme: true, specials: [] },
+  {
+    levelTypeName: 'Act 2 - Tomb',
+    grow: true,
+    theme: true,
+    prevChain: 'tomb',
+    singleRoom: { 61: ['Act 2 - Tomb Tainted Sun X'] },
+    specials: [],
+  },
+  { levelTypeName: 'Act 2 - Lair', ring: 2, grow: true, theme: false, specials: [] },
+  {
+    levelTypeName: 'Act 2 - Arcane',
+    grow: false,
+    theme: false,
+    arcane: true,
+    specials: [{ kind: 'quest', entries: entries() }],
+  },
+  { levelTypeName: 'Act 2 - Harem', ring: 2, grow: false, theme: false, specials: [] },
+  { levelTypeName: 'Act 2 - Basement', ring: 2, grow: false, theme: false, specials: [] },
+  { levelTypeName: 'Act 3 - Spider', ring: 2, grow: false, theme: false, specials: [] },
+  { levelTypeName: 'Act 3 - Kurast', ring: 2, grow: true, theme: true, specials: [] },
+  { levelTypeName: 'Act 3 - Dungeon', ring: 2, grow: true, theme: true, specials: [] },
+  {
+    levelTypeName: 'Act 3 - Sewer',
+    ring: 2,
+    grow: true,
+    theme: true,
+    specials: [
+      // Sewer 1 runs `InitBasicMazeLayout(5)` and then four `ReplaceRoomPreset`
+      // calls that turn the ring's corners into staircases.
+      {
+        kind: 'prev',
+        entries: [
+          { plainSides: 'SW', sides: 'SW', direction: DIRECTION_SOUTH },
+          { plainSides: 'SE', sides: 'SE', direction: DIRECTION_SOUTH },
+          { plainSides: 'NW', sides: 'NW', direction: DIRECTION_NORTH },
+          { plainSides: 'NE', sides: 'NE', direction: DIRECTION_NORTH },
+        ],
+        levelIds: [92],
+        inPlaceOnly: true,
+      },
+    ],
+  },
+  { levelTypeName: 'Act 4 - Lava', grow: true, theme: false, specials: [] },
+  {
+    levelTypeName: 'Act 5 - Ice Caves',
+    ring: 2,
+    grow: true,
+    theme: false,
+    singleRoom: {
+      114: ['Act 5 - Ice River A', 'Act 5 - Ice River B'],
+      116: ['Act 5 - Ice Pool A'],
+      119: ['Act 5 - Ice Pool B'],
+    },
+    specials: [],
+  },
+  { levelTypeName: 'Act 5 - Temple', ring: 2, grow: false, theme: false, specials: [] },
+  { levelTypeName: 'Act 5 - Baal', grow: true, theme: false, prevChain: 'baal', specials: [] },
+  { levelTypeName: 'Act 5 - Lava', grow: false, theme: false, lavaPairs: true, specials: [] },
+]
+
+/**
+ * `LvlPrest.txt` names a level type needs from outside its own name prefix.
+ *
+ * Only Act 5's Lava levels do this: `DRLGMAZE_PlaceAct5LavaPresets` fills the
+ * blank space around the Infernal Pit's two set pieces with the *Act 4* lava
+ * filler row, so a caller that groups pieces strictly by name prefix must fetch
+ * these extra rows too.
+ */
+export const MAZE_SHARED_PRESET_NAMES: readonly string[] = ['Act 4 - Lava X']
+
+/**
+ * Per-act decoration passes D2MOO runs after the layout, which this port does not
+ * reproduce. Reported verbatim in every result's `stats.unimplementedPasses`.
+ */
+const UNIMPLEMENTED_PASSES: readonly string[] = [
+  'DRLGMAZE_PlaceAct2TombStuff',
+  'DRLGMAZE_PlaceAct2LairStuff',
+  'DRLGMAZE_PlaceAct3DungeonStuff',
+  'DRLGMAZE_PlaceAct3SewerStuff',
+  'DRLGMAZE_PlaceAct3MephistoStuff',
+  'DRLGMAZE_PlaceAct5TempleStuff',
+  'DRLGMAZE_PlaceAct5BaalStuff',
+  'DRLGMAZE_PlaceAct5IceStuff',
+  'DRLGMAZE_PlaceAct1Barracks',
+  'DRLGMAZE_PlaceAct4Lava',
+  'DRLGMAZE_ScanReplaceSpecialAct2SewersPresets',
+]
+
+/* ------------------------------------------------------------------------- *
+ * Geometry
+ * ------------------------------------------------------------------------- */
+
+/** A rectangle in cells. Mirrors the `nTileXPos`/`nTileYPos`/`nTileWidth`/
+ * `nTileHeight` view of `D2DrlgRoomStrc`, which D2MOO also reads as
+ * `D2DrlgCoordStrc` through a union. */
+interface Rect {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+
+/**
+ * Signed gap between two cell rectangles, per axis.
+ *
+ * `DRLG_ComputeManhattanDistance` verbatim, including its one-axis-at-a-time
+ * formulation: a negative value means the rectangles overlap on that axis, and
+ * two rooms sharing a face give one gap of 0 and one of `-height`, which is the
+ * signature every caller tests for.
+ *
+ * @param a - first rectangle.
+ * @param b - second rectangle.
+ * @returns the per-axis gaps.
+ */
+function manhattan(a: Rect, b: Rect): { dx: number; dy: number } {
+  const dx = a.x >= b.x ? a.x - b.width - b.x : b.x - a.width - a.x
+  const dy = a.y >= b.y ? a.y - b.height - b.y : b.y - a.height - a.y
+  return { dx, dy }
+}
+
+/**
+ * Whether two rectangles are clear of each other by at least `margin` cells.
+ *
+ * `DRLG_GetRectanglesManhattanDistanceAndCheckNotOverlapping`: true when either
+ * axis is separated by `margin` or more. With `margin = 0` a pair of face-to-face
+ * rooms has `dx = 0` and therefore *passes*, so sharing a face counts as "not
+ * overlapping" — which is what lets rooms tile a grid.
+ *
+ * @param a - first rectangle.
+ * @param b - second rectangle.
+ * @param margin - required separation on at least one axis.
+ * @returns true when they are clear.
+ */
+function notOverlapping(a: Rect, b: Rect, margin: number): boolean {
+  const { dx, dy } = manhattan(a, b)
+  return dx >= margin || dy >= margin
+}
+
+/**
+ * The quarter direction from `from` to `to`, or `-1` when they are not
+ * face-to-face neighbours.
+ *
+ * `DRLG_GetDirectionFromCoordinates`. Only the four quarters are produced; the
+ * diagonals exist solely as placement offsets in `FillBlankMazeSpaces`.
+ *
+ * @param from - the origin rectangle.
+ * @param to - the candidate neighbour.
+ * @returns a direction index 0..3, or -1.
+ */
+function directionFrom(from: Rect, to: Rect): number {
+  if (from.x <= to.x) {
+    if (to.x === from.x + from.width) return DIRECTION_EAST
+  } else if (from.x === to.x + to.width) {
+    return DIRECTION_WEST
+  }
+  if (from.y <= to.y) {
+    if (to.y === from.y + from.height) return DIRECTION_SOUTH
+  } else if (from.y === to.y + to.height) {
+    return DIRECTION_NORTH
+  }
+  return -1
+}
+
+/* ------------------------------------------------------------------------- *
+ * Rooms
+ * ------------------------------------------------------------------------- */
+
+/** One maze section. */
+interface Room extends Rect {
+  /** Doorways to neighbouring rooms, in insertion order. */
+  readonly orths: { room: Room; direction: number }[]
+  /** Creation index, so diagnostics can name a room stably. */
+  readonly id: number
+  /** The chosen piece; `null` until a preset pass runs. */
+  piece: MazePiece | null
+  /** Which variant of `piece` to stamp. */
+  variant: number
+  /**
+   * `DRLGPRESETROOMFLAG_HAS_MAP_DS1`.
+   *
+   * Set by the passes that call `DRLGMAZE_SetPickedFileAndPresetId` with
+   * `bResetFlag = FALSE`; cleared by every `DRLGMAZE_PickRoomPreset` call, which
+   * passes 1. A set flag means "this room's artwork is final", so the merge pass
+   * skips it and no later preset pass may overwrite it.
+   */
+  hasDs1: boolean
+  /** Per-room random stream, seeded from the level's (`DRLGROOM_AllocRoomEx`). */
+  readonly rng: Rng
+}
+
+/** The level under construction. */
+interface MazeLevel {
+  /** Rooms newest-first, matching `DRLGROOM_AddRoomExToLevel`'s prepend. */
+  readonly rooms: Room[]
+  /** The first room created; D2MOO keeps this pointer across prepends. */
+  readonly first: Room
+  readonly width: number
+  readonly height: number
+  readonly rng: Rng
+  readonly mergePerMille: number
+  /** Next room id. */
+  nextId: number
+  /** Doorways added by the merge pass, for reporting. */
+  merges: number
+}
+
+/**
+ * Report collector shared by the passes.
+ *
+ * Dense on purpose: the generator's job is to be inspectable, and the interesting
+ * facts are which piece answered which side pattern and where the exact pattern
+ * was missing.
+ */
+interface MazeStats {
+  readonly patterns: Record<string, Record<string, number>>
+  readonly fallbacks: { room: number; requested: string; used: string }[]
+  readonly specialsApplied: { room: number; kind: string; sides: string }[]
+  readonly unresolvedRoles: string[]
+  readonly notes: string[]
+  ringRooms: number
+  placementAttempts: number
+}
+
+/**
+ * Create a room with no position or piece.
+ *
+ * @param level - the level.
+ * @returns the room.
+ */
+function makeRoom(level: MazeLevel): Room {
+  const room: Room = {
+    x: 0, y: 0, width: level.width, height: level.height,
+    orths: [], id: level.nextId, piece: null, variant: 0, hasDs1: false,
+    rng: new Rng(level.rng.int(0, 0x7fffffff)),
+  }
+  level.nextId += 1
+  return room
+}
+
+/**
+ * Add a doorway between two rooms.
+ *
+ * `DRLGROOM_AllocDrlgOrthsForRooms`: idempotent per room pair, and the reciprocal
+ * orth points the opposite way, `(direction - 2) & 3`.
+ *
+ * @param a - first room.
+ * @param b - second room.
+ * @param direction - direction from `a` to `b`.
+ */
+function linkRooms(a: Room, b: Room, direction: number): void {
+  if (!a.orths.some(orth => orth.room === b)) a.orths.push({ room: b, direction })
+  const opposite = (direction - 2) & 3
+  if (!b.orths.some(orth => orth.room === a)) b.orths.push({ room: a, direction: opposite })
+}
+
+/**
+ * The 4-bit side mask a room's doorways produce.
+ *
+ * `DRLGMAZE_PickRoomPreset` ORs {@link DIRECTION_SIDE_BIT} for every doorway. A
+ * room with no doorways gets 0, which in D2MOO selects the level type's base row
+ * and here selects the `entrance` piece.
+ *
+ * @param room - the room.
+ * @returns the mask, 0..15.
+ */
+function roomSideMask(room: Room): number {
+  let mask = 0
+  for (const orth of room.orths) mask |= DIRECTION_SIDE_BIT[orth.direction]!
+  return mask
+}
+
+/**
+ * Whether a room overlaps anything other than itself and one ignored room.
+ *
+ * `DRLGMAZE_CheckRoomNotOverlaping`. The margin is 0, so face-to-face neighbours
+ * are fine and only genuine overlap fails.
+ *
+ * @param level - the level.
+ * @param room - the candidate.
+ * @param ignored - a room to skip, usually its parent.
+ * @returns true when the room is clear.
+ */
+function checkRoomNotOverlapping(level: MazeLevel, room: Rect, ignored: Room | null): boolean {
+  for (const other of level.rooms) {
+    if (other === room || other === ignored) continue
+    if (!notOverlapping(room, other, 0)) return false
+  }
+  return true
+}
+
+/**
+ * Position `room` against `anchor` in `direction` and validate the result.
+ *
+ * `DRLGMAZE_LinkMazeRooms`: the coordinate assignment happens first, so a failed
+ * link leaves the caller to discard the room.
+ *
+ * @param level - the level.
+ * @param room - the room to move.
+ * @param anchor - the room to sit against.
+ * @param direction - which side of the anchor to occupy.
+ * @returns true when the position is legal.
+ */
+function linkMazeRooms(level: MazeLevel, room: Room, anchor: Room, direction: number): boolean {
+  const { dx, dy } = step(direction, anchor.width, anchor.height)
+  room.x = anchor.x + dx
+  room.y = anchor.y + dy
+  for (const orth of anchor.orths) {
+    // Anything already touching the anchor must not be run into.
+    if (!notOverlapping(room, orth.room, 0)) return false
+  }
+  return checkRoomNotOverlapping(level, room, anchor)
+}
+
+/**
+ * The earliest room that still needs a piece, optionally of a given shape.
+ *
+ * @param level - the level, newest-first.
+ * @param mask - required side mask, or `null` for any.
+ * @returns the room, or null.
+ */
+function findUnfinishedRoom(level: MazeLevel, mask: number | null): Room | null {
+  for (const room of level.rooms) {
+    if (room.hasDs1) continue
+    if (mask === null || roomSideMask(room) === mask) return room
+  }
+  return null
+}
+
+/**
+ * Grow one room off `parent`, or return null when the spot is taken.
+ *
+ * `DRLGMAZE_AddAdjacentMazeRoom`, with its inline copy of the merge loop factored
+ * into {@link mergeMazeRooms}. The fold is safe because in D2MOO the new room has
+ * not been added to the roster when either spelling runs, so both iterate exactly
+ * the same candidates in the same order; the only difference is that
+ * `DRLGMAZE_BuildBasicMaze` calls `MergeMazeRooms` unconditionally while
+ * `AddAdjacentMazeRoom` guards it with `bMergeRooms`, and every caller that
+ * passes `FALSE` has already established that there is nothing to merge.
+ *
+ * @param level - the level.
+ * @param parent - the room to grow from.
+ * @param direction - which side to grow towards, 0..7.
+ * @param merge - whether the accidental-adjacency join pass runs.
+ * @param repickParent - whether to re-derive the parent's piece afterwards.
+ *   `DRLGMAZE_FillBlankMazeSpaces` deliberately does not.
+ * @returns the new room, or null.
+ */
+function addAdjacentMazeRoom(
+  level: MazeLevel,
+  parent: Room,
+  direction: number,
+  merge: boolean,
+  repickParent: boolean,
+  index: PieceIndex,
+  stats: MazeStats,
+): Room | null {
+  const room = makeRoom(level)
+  const { dx, dy } = step(direction, parent.width, parent.height)
+  room.x = parent.x + dx
+  room.y = parent.y + dy
+  for (const orth of parent.orths) {
+    if (!notOverlapping(room, orth.room, 0)) return null
+  }
+  if (!checkRoomNotOverlapping(level, room, parent)) return null
+
+  linkRooms(parent, room, direction)
+  if (merge) mergeMazeRooms(level, room, index, stats)
+  level.rooms.unshift(room)
+  if (repickParent) pickRoomPreset(parent, index, stats)
+  pickRoomPreset(room, index, stats)
+  return room
+}
+
+/**
+ * Join a newly placed room to every already-placed room it happens to touch.
+ *
+ * **This is what `LvlMaze.Merge` does.** `DRLGMAZE_MergeMazeRooms` (and the
+ * inline copy inside `DRLGMAZE_AddAdjacentMazeRoom`) walks the whole roster for
+ * rooms no more than one cell away where `dx !== dy` — which, given that overlap
+ * has already been ruled out, can only mean a face-to-face neighbour — and, when
+ * the two are not already connected, rolls
+ * `SEED_RollRandomNumber(&i->pSeed) % 1000 < dwMerge`, on the *candidate's* seed
+ * rather than the pivot's. A success adds a doorway and re-picks that room's
+ * piece, because its side pattern just changed.
+ *
+ * The consequence is why `Merge` matters: the growth loop attaches a room on one
+ * side only, but the section grid is coarse enough that a new room frequently
+ * lands flush against an unrelated older room. With `Merge = 0` those contacts
+ * stay walls and the level is a bare tree; with `Merge = 1000` every one of them
+ * becomes a door and the level acquires loops.
+ *
+ * @param level - the level.
+ * @param pivot - the room just placed.
+ * @param index - the piece index, for re-picking.
+ * @param stats - report collector.
+ */
+function mergeMazeRooms(level: MazeLevel, pivot: Room, index: PieceIndex, stats: MazeStats): void {
+  if (pivot.hasDs1) return
+  for (const other of level.rooms) {
+    if (other === pivot || other.hasDs1) continue
+    const { dx, dy } = manhattan(pivot, other)
+    // `!(dx >= 1 || dy >= 1)`, then `dx !== dy`.
+    if (dx >= 1 || dy >= 1) continue
+    if (dx === dy) continue
+    if (pivot.orths.some(orth => orth.room === other)) continue
+    if (other.rng.int(0, 999) >= level.mergePerMille) continue
+    const direction = directionFrom(other, pivot)
+    if (direction === -1) continue
+    linkRooms(other, pivot, direction)
+    level.merges += 1
+    pickRoomPreset(other, index, stats)
+  }
+}
+
+/* ------------------------------------------------------------------------- *
+ * Piece lookup
+ * ------------------------------------------------------------------------- */
+
+/** Indexed pieces, so a side mask is one map lookup. */
+interface PieceIndex {
+  /**
+   * The piece for a room's doorway mask.
+   *
+   * @param mask - the room's doorway mask.
+   * @param stats - report collector for fallbacks.
+   * @param roomId - the room being served, for the report.
+   * @returns the piece to stamp.
+   */
+  choose(mask: number, stats: MazeStats, roomId: number): MazePiece
+}
+
+/**
+ * Count set bits.
+ *
+ * @param value - the value.
+ * @returns the population count.
+ */
+function popcount(value: number): number {
+  let count = 0
+  let rest = value
+  while (rest !== 0) { count += rest & 1; rest >>>= 1 }
+  return count
+}
+
+/**
+ * Index a level type's pieces by kind and side mask.
+ *
+ * `DRLGMAZE_PickRoomPreset` resolves a mask by reading the level type's
+ * `LvlPrest` row at `base + mask`, where `base` is a hardcoded per-type preset
+ * id. This port has no preset ids, so it resolves by *kind and mask* instead —
+ * the same thing expressed in the data the caller supplies.
+ *
+ * A level type may genuinely lack a piece for a side pattern (Act 1's Catacombs
+ * ships no four-sided room). D2MOO would read whatever row happens to sit at
+ * `base + mask` — a neighbouring level type's artwork — and produce a map whose
+ * doors do not line up. Here the closest piece is substituted and the mismatch is
+ * recorded in `stats.fallbacks`, because a map that cannot be walked is worse for
+ * this project than a map with one wrong room. This is a deliberate divergence.
+ *
+ * @param pieces - the level type's pieces.
+ * @returns the index.
+ */
+function buildPieceIndex(pieces: readonly MazePiece[]): PieceIndex {
+  const rooms = new Map<number, MazePiece>()
+  let entrance: MazePiece | undefined
+  for (const piece of pieces) {
+    if (piece.kind === 'entrance' && entrance === undefined) entrance = piece
+    if (piece.kind !== 'room') continue
+    const mask = sideMaskFromToken(piece.sides)
+    if (!rooms.has(mask)) rooms.set(mask, piece)
+  }
+  const entrancePiece = entrance
+
+  /**
+   * Pick the closest available room piece to a mask.
+   *
+   * @param mask - the wanted mask.
+   * @returns the piece and whether it is exact.
+   */
+  const closest = (mask: number): { piece: MazePiece; exact: boolean } | null => {
+    const exact = rooms.get(mask)
+    if (exact !== undefined) return { piece: exact, exact: true }
+    let best: MazePiece | null = null
+    let bestCost = Number.POSITIVE_INFINITY
+    for (const [candidateMask, piece] of rooms) {
+      // A missing doorway seals the room off completely; an extra one merely
+      // adds a dead end. Weight the two accordingly.
+      const cost = popcount(mask & ~candidateMask) * 100 + popcount(candidateMask & ~mask)
+      if (cost < bestCost) { bestCost = cost; best = piece }
+    }
+    return best === null ? null : { piece: best, exact: false }
+  }
+
+  return {
+    choose: (mask: number, stats: MazeStats, roomId: number): MazePiece => {
+      const result = closest(mask)
+      if (result === null) {
+        if (entrancePiece !== undefined) return entrancePiece
+        const any = pieces[0]
+        if (any === undefined) throw new Error('maze piece list is empty')
+        return any
+      }
+      if (!result.exact) {
+        stats.fallbacks.push({
+          room: roomId,
+          requested: sideTokenFromMask(mask),
+          used: `${result.piece.name} (${sideTokenFromMask(sideMaskFromToken(result.piece.sides)) || 'no side'})`,
+        })
+      }
+      return result.piece
+    },
+  }
+}
+
+/**
+ * Look up a piece by kind and side token.
+ *
+ * @param pieces - the level's pieces.
+ * @param kind - the kind wanted.
+ * @param sides - the side token; `''` accepts any piece of that kind.
+ * @returns the piece, or undefined.
+ */
+function findSpecial(pieces: readonly MazePiece[], kind: MazePieceKind, sides: string): MazePiece | undefined {
+  return pieces.find(piece => piece.kind === kind
+    && (sides === '' || sideMaskFromToken(piece.sides) === sideMaskFromToken(sides)))
+}
+
+/**
+ * Give a room the piece its doorways call for.
+ *
+ * `DRLGMAZE_PickRoomPreset`. Rooms whose artwork is already final (`hasDs1`) are
+ * left alone, mirroring the passes that call it with `bResetFlag = FALSE`; every
+ * other call clears the flag, which is why the flag cannot be used as a "was
+ * visited" marker.
+ *
+ * @param room - the room to give a piece.
+ * @param index - the piece lookup.
+ * @param stats - the report collector.
+ */
+function pickRoomPreset(room: Room, index: PieceIndex, stats: MazeStats): void {
+  if (room.hasDs1) return
+  const mask = roomSideMask(room)
+  const chosen = index.choose(mask, stats, room.id)
+  room.piece = chosen
+  room.variant = 0
+  room.hasDs1 = false
+  const token = sideTokenFromMask(mask) === '' ? 'no side' : sideTokenFromMask(mask)
+  stats.patterns[chosen.kind] ??= {}
+  const bucket = stats.patterns[chosen.kind]!
+  bucket[token] = (bucket[token] ?? 0) + 1
+}
+
+/**
+ * Record that a special piece was placed.
+ *
+ * @param room - the room it went into.
+ * @param piece - the piece.
+ * @param token - the side token it answers.
+ * @param stats - report collector.
+ */
+function noteSpecial(room: Room, piece: MazePiece, token: string, stats: MazeStats): void {
+  stats.specialsApplied.push({ room: room.id, kind: piece.kind, sides: token })
+  stats.patterns[piece.kind] ??= {}
+  stats.patterns[piece.kind]![token] = (stats.patterns[piece.kind]![token] ?? 0) + 1
+}
+
+/* ------------------------------------------------------------------------- *
+ * Layout passes
+ * ------------------------------------------------------------------------- */
+
+/**
+ * Pre-place a closed ring of `4n - 4` rooms.
+ *
+ * `DRLGMAZE_InitBasicMazeLayout`. Four legs walk north, west, south and east, and
+ * the last room is then linked back to the first — so `n = 2` gives a 2×2 square
+ * and `n = 5` (Act 3's Sewer 1) a 4×4 ring of 16 rooms. The east leg runs one
+ * iteration short because the first room already occupies that corner. Each leg
+ * calls `DRLGMAZE_MergeMazeRooms` just like the growth loop does, so the
+ * accidental contacts a ring makes are subject to `Merge` too.
+ *
+ * @param level - the level.
+ * @param roomsPerDirection - `n`; `4n - 4` rooms are created.
+ * @param index - the piece index.
+ * @param stats - report collector.
+ */
+function ringLayout(level: MazeLevel, roomsPerDirection: number, index: PieceIndex, stats: MazeStats): void {
+  const legs: readonly number[] = [DIRECTION_NORTH, DIRECTION_WEST, DIRECTION_SOUTH, DIRECTION_EAST]
+  let cursor = level.first
+  for (const direction of legs) {
+    const count = direction === DIRECTION_EAST ? roomsPerDirection - 2 : roomsPerDirection - 1
+    for (let remaining = count; remaining > 0; remaining -= 1) {
+      const room = addAdjacentMazeRoom(level, cursor, direction, true, true, index, stats)
+      if (room !== null) stats.ringRooms += 1
+      cursor = room ?? cursor
+    }
+  }
+  linkRooms(cursor, level.first, DIRECTION_EAST)
+  pickRoomPreset(cursor, index, stats)
+  pickRoomPreset(level.first, index, stats)
+}
+
+/**
+ * Grow the level to its target room count.
+ *
+ * The shared body of `DRLGMAZE_BuildBasicMaze` and of the
+ * `while (pLevel->nRooms < nRooms)` loop `DRLGMAZE_GenerateLevel` inlines for the
+ * Act 1 dungeons: pick a room from the roster at a uniformly random index (the
+ * roster is newest-first, so recent rooms are favoured exactly as in the game),
+ * roll a direction from *that room's* seed, and try to attach a neighbour.
+ * Failure is routine — the target square may already be occupied — so the loop
+ * simply tries again. That also means it can only be bounded by a retry cap
+ * rather than by construction, and D2MOO would spin forever where this throws.
+ *
+ * @param level - the level.
+ * @param target - rooms wanted.
+ * @param index - the piece index.
+ * @param stats - report collector.
+ * @returns the number of attempts consumed.
+ */
+function growMaze(level: MazeLevel, target: number, index: PieceIndex, stats: MazeStats): number {
+  const cap = target * 400 + 20_000
+  let attempts = 0
+  while (level.rooms.length < target) {
+    attempts += 1
+    if (attempts > cap) {
+      throw new Error(`layout stalled at ${String(level.rooms.length)}/${String(target)} rooms after ${String(attempts)} attempts`)
+    }
+    const room = level.rooms[level.rng.int(0, level.rooms.length - 1)]!
+    const direction = room.rng.int(0, 3)
+    if (room.hasDs1) continue
+    addAdjacentMazeRoom(level, room, direction, true, true, index, stats)
+  }
+  return attempts
+}
+
+/**
+ * The opening moves Act 1's Catacombs get before growth.
+ *
+ * `DRLGMAZE_GenerateLevel`'s `LVLTYPE_ACT1_CATACOMBS` arm. Level 1 opens in all
+ * four directions and pins the entrance to the `NSEW` staircase piece; the rest
+ * pick an axis at random and open both ways, pinning `EW` or `NS`. These are the
+ * only places the entrance room is finalised with `bResetFlag = FALSE`, i.e. the
+ * only rooms `DRLGMAZE_MergeMazeRooms` will later refuse to touch.
+ *
+ * @param level - the level.
+ * @param horizontal - whether the non-first levels open west/east rather than
+ *   north/south.
+ * @param pieces - the level's pieces.
+ * @param index - the piece index.
+ * @param stats - report collector.
+ */
+function catacombsOpening(level: MazeLevel, horizontal: boolean, pieces: readonly MazePiece[], index: PieceIndex, stats: MazeStats): void {
+  const directions = horizontal ? [DIRECTION_WEST, DIRECTION_EAST] : [DIRECTION_NORTH, DIRECTION_SOUTH]
+  for (const direction of directions) addAdjacentMazeRoom(level, level.first, direction, true, true, index, stats)
+  const token = horizontal ? 'EW' : 'NS'
+  const piece = findSpecial(pieces, 'prev', token)
+  if (piece === undefined) {
+    stats.unresolvedRoles.push(`Act 1 - Catacombs Prev ${token}`)
+    return
+  }
+  level.first.piece = piece
+  level.first.hasDs1 = true
+  noteSpecial(level.first, piece, token, stats)
+}
+
+/**
+ * The three-room prologue Act 2's tombs and Act 5's Baal levels share.
+ *
+ * `DRLGMAZE_PlaceAct2TombPrev_Act5BaalPrev`: three rooms are chained off the
+ * entrance, one per direction starting from a random one, each merging as it
+ * lands; the entrance then takes the `Prev` piece whose three free sides face the
+ * rooms that actually got built. That piece is chosen with the direction counter
+ * *after* the loop, which is why it is the successor of the last direction tried
+ * rather than the last direction used.
+ *
+ * @param level - the level.
+ * @param kind - which act's `Prev` set to use.
+ * @param pieces - the level's pieces.
+ * @param index - the piece index.
+ * @param stats - report collector.
+ */
+function prevChain(level: MazeLevel, kind: 'tomb' | 'baal', pieces: readonly MazePiece[], index: PieceIndex, stats: MazeStats): void {
+  let direction = level.rng.int(0, 3)
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const room = makeRoom(level)
+    if (linkMazeRooms(level, room, level.first, direction)) {
+      linkRooms(level.first, room, direction)
+      mergeMazeRooms(level, room, index, stats)
+      level.rooms.unshift(room)
+      pickRoomPreset(level.first, index, stats)
+      pickRoomPreset(room, index, stats)
+    }
+    direction = (direction + 1) % 4
+  }
+  const tokens = kind === 'tomb' ? ['NSE', 'SEW', 'NSW', 'NEW'] : ['NEW', 'NSE', 'NSW', 'SEW']
+  const token = tokens[direction]!
+  const piece = findSpecial(pieces, 'prev', token)
+  if (piece === undefined) {
+    stats.unresolvedRoles.push(`${kind === 'tomb' ? 'Act 2 - Tomb' : 'Act 5 - Baal'} Prev ${token}`)
+    return
+  }
+  level.first.piece = piece
+  level.first.hasDs1 = true
+  noteSpecial(level.first, piece, token, stats)
+}
+
+/**
+ * `DRLGMAZE_PlaceArcaneSanctuary`: four 15-room spiral branches.
+ *
+ * Each branch starts at the level's first room and walks the pattern D2MOO
+ * documents in a comment, encoded in
+ * `DRLGMAZE_ArcaneSanctuaryDirectionFromRoomIdx`: one room forward, then a side
+ * step, then a long run, then a side step back. Rooms 8 and 12 are placed but
+ * deliberately *not* recorded and do not advance the parent, which D2MOO flags
+ * with "Is this a mistake?" and then reproduces anyway; so does this port, since
+ * the object is fidelity to the shipped maze rather than to the diagram.
+ *
+ * The four branches then take four different variants of the same pieces,
+ * `(nRand + branch) % 4`, which is what gives the Sanctuary its noticeably varied
+ * arms; the entry room takes variant 4.
+ *
+ * @param level - the level.
+ * @param pieces - the level's pieces.
+ * @param index - the piece index.
+ * @param stats - report collector.
+ */
+function arcaneSanctuary(level: MazeLevel, pieces: readonly MazePiece[], index: PieceIndex, stats: MazeStats): void {
+  const rand = level.rng.int(0, 3)
+  const branches: Room[] = []
+  for (let branch = 0; branch < 4; branch += 1) {
+    let parent = level.first
+    for (let slot = 0; slot < 15; slot += 1) {
+      let direction = branch
+      if (slot === 2 || slot === 12) direction = branch + 3
+      else if (slot === 7 || slot === 9) direction = branch + 1
+      else if (slot === 10 || slot === 11 || slot === 13 || slot === 14) direction = branch + 2
+      direction %= 4
+      const room = addAdjacentMazeRoom(level, parent, direction, true, true, index, stats)
+      if (room === null) continue
+      if (slot !== 8 && slot !== 12) {
+        branches.push(room)
+        parent = room
+      }
+    }
+  }
+  branches.forEach((room, position) => {
+    room.variant = (rand + Math.floor(position / 15)) % 4
+  })
+  level.first.variant = 4
+  void pieces
+}
+
+/**
+ * `DRLGMAZE_PlaceAct5LavaPresets`: the Infernal Pit's two fixed pieces.
+ *
+ * The level is not a maze at all. It is an entrance plus exactly two lava pieces,
+ * chosen as a pair by a single random draw, after which every still-empty
+ * adjacent square is filled with the shared `Act 4 - Lava X` filler — see
+ * {@link fillBlankSpaces}.
+ *
+ * @param level - the level.
+ * @param pieces - the level's pieces.
+ * @param index - the piece index.
+ * @param stats - report collector.
+ */
+function lavaPairs(level: MazeLevel, pieces: readonly MazePiece[], index: PieceIndex, stats: MazeStats): void {
+  // `dword_6FDCE850`, transcribed as (piece name, direction, variant).
+  const table: readonly (readonly [string, number, number])[] = [
+    ['Act 5 - Lava S', DIRECTION_SOUTH, 0],
+    ['Act 5 - Lava N', DIRECTION_NORTH, 1],
+    ['Act 5 - Lava S', DIRECTION_SOUTH, 1],
+    ['Act 5 - Lava N', DIRECTION_NORTH, 0],
+    ['Act 5 - Lava E', DIRECTION_EAST, 1],
+    ['Act 5 - Lava W', DIRECTION_WEST, 0],
+    ['Act 5 - Lava E', DIRECTION_EAST, 0],
+    ['Act 5 - Lava W', DIRECTION_WEST, 1],
+  ]
+  const set = 2 * level.first.rng.int(0, 3)
+  for (const [name, direction, variant] of [table[set]!, table[set + 1]!]) {
+    const room = makeRoom(level)
+    room.variant = variant
+    // The table's direction is the direction *from the new room to the entrance*,
+    // so the new room sits on the opposite side.
+    const { dx, dy } = step(direction, level.first.width, level.first.height)
+    room.x = level.first.x + dx
+    room.y = level.first.y + dy
+    if (!checkRoomNotOverlapping(level, room, level.first)) continue
+    linkRooms(level.first, room, direction)
+    level.rooms.unshift(room)
+    pickRoomPreset(level.first, index, stats)
+    const piece = pieces.find(candidate => candidate.name === name)
+    if (piece === undefined) {
+      stats.unresolvedRoles.push(name)
+      pickRoomPreset(room, index, stats)
+      continue
+    }
+    room.piece = piece
+    room.hasDs1 = true
+    noteSpecial(room, piece, 'no side', stats)
+  }
+  fillBlankSpaces(level, pieces, index, stats)
+}
+
+/**
+ * `DRLGMAZE_FillBlankMazeSpaces`: wall a fixed-tile level in with filler rooms.
+ *
+ * The roster is snapshotted first, then every room in it tries all eight compass
+ * directions in order and keeps whatever fits. The filler never takes a role, so
+ * this only ever adds area.
+ *
+ * D2MOO does not re-derive the parent's piece here, which would leave a wall
+ * where the filler attaches and make the filler unreachable; this port does
+ * re-derive it, because an unreachable room is a defect rather than a detail.
+ *
+ * @param level - the level.
+ * @param pieces - the level's pieces.
+ * @param index - the piece index.
+ * @param stats - report collector.
+ */
+function fillBlankSpaces(level: MazeLevel, pieces: readonly MazePiece[], index: PieceIndex, stats: MazeStats): void {
+  const filler = pieces.find(piece => piece.name === 'Act 4 - Lava X')
+  if (filler === undefined) {
+    stats.unresolvedRoles.push('Act 4 - Lava X')
+    return
+  }
+  for (const room of [...level.rooms]) {
+    for (let direction = 0; direction < 8; direction += 1) {
+      const created = addAdjacentMazeRoom(level, room, direction, false, true, index, stats)
+      if (created === null) continue
+      created.piece = filler
+      created.hasDs1 = true
+      noteSpecial(created, filler, 'filler', stats)
+    }
+  }
+}
+
+/**
+ * `DRLGMAZE_RollAct_1_2_3_BasicPresets`: the `Theme` decoration pass.
+ *
+ * A shuffled list of the fifteen side patterns is walked cyclically and the first
+ * plain room matching each pattern is converted to that pattern's `Theme`
+ * variant, until `max(rooms / 5 + 1, 2)` rooms have been converted or the attempt
+ * budget of `2 × rooms` is spent. D2MOO shuffles the offset list with fifteen
+ * Fisher-Yates swaps drawn from the level seed, which is reproduced here.
+ *
+ * A level type with no `Theme` pieces for a pattern is skipped rather than given
+ * a neighbouring type's artwork, and the shortfall is reported.
+ *
+ * @param level - the level.
+ * @param pieces - the level's pieces.
+ * @param stats - report collector.
+ */
+function themeRoll(level: MazeLevel, pieces: readonly MazePiece[], stats: MazeStats): void {
+  const offsets = Array.from({ length: 15 }, (_, index) => index)
+  let cursor = level.rng.int(0, 14)
+  for (let swap = 0; swap < 15; swap += 1) {
+    const a = level.rng.int(0, 14)
+    const b = level.rng.int(0, 14)
+    const temporary = offsets[a]!
+    offsets[a] = offsets[b]!
+    offsets[b] = temporary
+  }
+  let wanted = Math.max(Math.floor(level.rooms.length / 5) + 1, 2)
+  let budget = 2 * level.rooms.length
+  while (wanted > 0 && budget > 0) {
+    budget -= 1
+    const mask = offsets[cursor]! + 1
+    cursor = (cursor + 1) % 15
+    const token = sideTokenFromMask(mask)
+    const room = findUnfinishedRoom(level, mask)
+    if (room === null) continue
+    const themed = findSpecial(pieces, 'theme', token)
+    if (themed === undefined) {
+      // D2MOO would write a neighbouring level type's row; here the room keeps
+      // its plain piece and the gap is reported.
+      if (!stats.unresolvedRoles.includes(`Theme ${token}`)) stats.unresolvedRoles.push(`Theme ${token}`)
+      continue
+    }
+    room.piece = themed
+    room.variant = 0
+    room.hasDs1 = true
+    noteSpecial(room, themed, token, stats)
+    wanted -= 1
+  }
+}
+
+/**
+ * One `DRLGMAZE_ScanReplaceSpecialPreset` (or `DRLGMAZE_ReplaceRoomPreset`) call.
+ *
+ * @param level - the level.
+ * @param pieces - the level's pieces.
+ * @param step - which special to place and where.
+ * @param index - the piece index.
+ * @param stats - report collector.
+ */
+function scanReplaceSpecial(
+  level: MazeLevel,
+  pieces: readonly MazePiece[],
+  step: SpecialStep,
+  index: PieceIndex,
+  stats: MazeStats,
+): void {
+  const wanted = sideMaskFromToken(step.plainSides)
+  const token = sideTokenFromMask(wanted)
+  const special = findSpecial(pieces, step.kind, step.sides)
+  if (special === undefined) {
+    if (!stats.unresolvedRoles.includes(`${step.kind} ${step.sides}`)) {
+      stats.unresolvedRoles.push(`${step.kind} ${step.sides}`)
+    }
+    return
+  }
+  const existing = findUnfinishedRoom(level, wanted)
+  if (existing !== null) {
+    existing.piece = special
+    existing.variant = 0
+    existing.hasDs1 = true
+    noteSpecial(existing, special, token, stats)
+    return
+  }
+  if (step.inPlaceOnly === true) {
+    stats.notes.push(`no ${token} room left for a ${step.kind} ${step.sides} replacement`)
+    return
+  }
+  // Nothing of that shape was left, so a room is grown to hold the special.
+  for (const candidate of [...level.rooms]) {
+    if (candidate.hasDs1) continue
+    const created = addAdjacentMazeRoom(level, candidate, step.direction, false, true, index, stats)
+    if (created === null) continue
+    created.piece = special
+    created.variant = 0
+    created.hasDs1 = true
+    noteSpecial(created, special, token, stats)
+    return
+  }
+  stats.notes.push(`could not place ${step.kind} ${step.sides}: no room could host it`)
+}
+
+/* ------------------------------------------------------------------------- *
+ * Stamping
+ * ------------------------------------------------------------------------- */
+
+/** A blank wall cell, matching the decoder's placeholder. */
+function emptyWall(): Ds1Wall {
+  return { prop1: 0, sequence: 0, style: 0, type: 0, unknown1: 0, unknown2: 0, hidden: false }
+}
+
+/** A blank floor/shadow cell. */
+function emptyFloor(): Ds1Floor {
+  return { prop1: 0, sequence: 0, style: 0, unknown1: 0, unknown2: 0, hidden: false }
+}
+
+/**
+ * Choose each room's variant the way `DRLGMAZE_RollBasicPresets` does.
+ *
+ * For the plain side pieces D2MOO keeps a per-preset counter initialised to a
+ * random file index and then increments it modulo the file count, so two
+ * consecutive rooms of the same shape never get the same artwork. Specials and
+ * themed pieces keep whatever index the earlier pass assigned — for the Arcane
+ * Sanctuary that is the branch number, and for the Infernal Pit an explicit 0/1.
+ *
+ * @param level - the level.
+ * @param stats - report collector.
+ */
+function assignVariants(level: MazeLevel, stats: MazeStats): void {
+  const counters = new Map<string, number>()
+  const usage = new Map<string, number>()
+  // D2MOO walks the roster from its head, i.e. newest room first.
+  for (const room of level.rooms) {
+    const piece = room.piece
+    if (piece === null) continue
+    usage.set(piece.name, (usage.get(piece.name) ?? 0) + 1)
+    if (piece.kind !== 'room' || piece.levels.length <= 1) continue
+    let counter = counters.get(piece.name)
+    if (counter === undefined) counter = level.rng.int(0, piece.levels.length - 1)
+    counters.set(piece.name, (counter + 1) % piece.levels.length)
+    room.variant = counter
+  }
+  for (const [name, count] of usage) stats.notes.push(`piece "${name}" used ${String(count)} time(s)`)
+}
+
+/**
+ * Flatten the room list into one synthesized map.
+ *
+ * The size is the union of the stamped piece extents — `(span of the room
+ * origins) + (piece size)`. Because a piece is one cell larger than the stride,
+ * consecutive rooms overlap by exactly one cell and the piece stamped later owns
+ * that border, reproducing `DRLGPRESET_InitPresetRoomGrids`, which fills
+ * `nTileWidth + 1` cells per room. D2MOO stamps in roster order (newest first),
+ * so the level's *first* room is stamped last and wins every overlap it takes
+ * part in; the same order is used here.
+ *
+ * Objects keep their per-piece sub-tile coordinates and gain the room origin
+ * converted from cells at 5 sub-tiles per cell.
+ *
+ * @param level - the level.
+ * @param stats - report collector.
+ * @returns the synthesized map.
+ */
+function stamp(level: MazeLevel, stats: MazeStats): Ds1 {
+  const minX = Math.min(...level.rooms.map(room => room.x))
+  const minY = Math.min(...level.rooms.map(room => room.y))
+  const maxX = Math.max(...level.rooms.map(room => room.x))
+  const maxY = Math.max(...level.rooms.map(room => room.y))
+
+  let wallLayers = 1
+  let floorLayers = 1
+  let substitutionType = 0
+  let version = 0
+  let act = 1
+  let widest = 1
+  let highest = 1
+  for (const room of level.rooms) {
+    const piece = room.piece
+    if (piece === null) continue
+    const variant = piece.levels[room.variant % piece.levels.length]
+    if (variant === undefined) throw new Error(`piece "${piece.name}" has no decoded map to stamp`)
+    wallLayers = Math.max(wallLayers, variant.wallLayers)
+    floorLayers = Math.max(floorLayers, variant.floorLayers)
+    substitutionType = Math.max(substitutionType, variant.substitutionType)
+    version = Math.max(version, variant.version)
+    act = variant.act
+    widest = Math.max(widest, variant.width)
+    highest = Math.max(highest, variant.height)
+  }
+
+  const width = (maxX - minX) + widest
+  const height = (maxY - minY) + highest
+  if (width <= 0 || height <= 0 || width > MAX_CELLS_PER_SIDE || height > MAX_CELLS_PER_SIDE
+    || width * height > MAX_CELLS) {
+    throw new Error(`synthesized map is ${String(width)}x${String(height)} cells, outside the supported bound`)
+  }
+
+  const substitutionLayers = substitutionType === 1 || substitutionType === 2 ? 1 : 0
+  const cells: Ds1Cell[][] = []
+  for (let y = 0; y < height; y += 1) {
+    const row: Ds1Cell[] = []
+    for (let x = 0; x < width; x += 1) {
+      row.push({
+        walls: Array.from({ length: wallLayers }, emptyWall),
+        floors: Array.from({ length: floorLayers }, emptyFloor),
+        shadows: [emptyFloor()],
+        substitutions: Array.from({ length: substitutionLayers }, () => ({ value: 0 })),
+      })
+    }
+    cells.push(row)
+  }
+
+  const objects: Ds1Object[] = []
+  let stampedRooms = 0
+  for (const room of level.rooms) {
+    const piece = room.piece
+    if (piece === null) continue
+    const variant = piece.levels[room.variant % piece.levels.length]!
+    const originX = room.x - minX
+    const originY = room.y - minY
+    if (originX + variant.width > width || originY + variant.height > height) {
+      throw new Error(`piece "${piece.name}" overflows the ${String(width)}x${String(height)} map`)
+    }
+    for (let y = 0; y < variant.height; y += 1) {
+      const source = variant.cells[y]
+      if (source === undefined) continue
+      const target = cells[originY + y]!
+      for (let x = 0; x < variant.width; x += 1) {
+        const cell = source[x]
+        if (cell === undefined) continue
+        target[originX + x] = cell
+      }
+    }
+    for (const object of variant.objects) {
+      objects.push({
+        type: object.type,
+        id: object.id,
+        x: originX * SUB_TILES_PER_TILE + object.x,
+        y: originY * SUB_TILES_PER_TILE + object.y,
+        flags: object.flags,
+      })
+    }
+    stampedRooms += 1
+  }
+
+  stats.notes.push(`stamped ${String(stampedRooms)} of ${String(level.rooms.length)} rooms`)
+  return {
+    version: version === 0 ? 18 : version,
+    width,
+    height,
+    act,
+    substitutionType,
+    wallLayers,
+    floorLayers,
+    cells,
+    objects,
+    // The synthesized map is written into an asset pack rather than re-encoded,
+    // so there is no NPC-path section to point at.
+    npcPathOffset: null,
+  }
+}
+
+/** Largest synthesized map side, in cells. Well above the widest shipped maze. */
+const MAX_CELLS_PER_SIDE = 4096
+/** Largest synthesized map area, matching the decoder's own sanity limit. */
+const MAX_CELLS = 1 << 22
+
+/* ------------------------------------------------------------------------- *
+ * Connectivity
+ * ------------------------------------------------------------------------- */
+
+/**
+ * Flood fill the doorway graph from the first room.
+ *
+ * The generator's correctness claim is "every placed room is reachable", so it is
+ * verified rather than asserted: growth attaches each room to an existing one and
+ * `Merge` only adds doorways, so this must always reach everything.
+ *
+ * @param level - the level.
+ * @returns the number of rooms reached.
+ */
+function reachableRooms(level: MazeLevel): number {
+  const seen = new Set<Room>([level.first])
+  const queue: Room[] = [level.first]
+  while (queue.length > 0) {
+    const room = queue.pop()!
+    for (const orth of room.orths) {
+      if (seen.has(orth.room)) continue
+      seen.add(orth.room)
+      queue.push(orth.room)
+    }
+  }
+  return seen.size
+}
+
+/* ------------------------------------------------------------------------- *
+ * Entry point
+ * ------------------------------------------------------------------------- */
+
+/**
+ * Generate one random-maze level.
+ *
+ * The pipeline is D2MOO's `DRLGMAZE_GenerateLevel`: an opening (ring and/or the
+ * Catacombs arms and/or the tomb prologue), optional growth to `LvlMaze.Rooms`
+ * sections, a preset for every room from its side pattern, the `Theme` pass, the
+ * `Prev`/`Next`/quest replacement passes, and finally one synthesized map.
+ *
+ * @param request - the real table data for one `DrlgType == 1` level.
+ * @returns the synthesized map plus a report of what was done.
+ * @throws when the level cannot be built — an unknown level type, a placement
+ *   stall, or rooms that ended up unreachable. The message always names the level,
+ *   because an empty map silently baked into an asset pack is worse than a crash.
+ */
+export function generateMaze(request: MazeRequest): MazeResult {
+  const width = request.sectionSize
+  const height = request.sectionHeight ?? request.sectionSize
+  const where = `level ${String(request.levelId)} (${request.levelName})`
+  if (!Number.isFinite(width) || width <= 0) throw new Error(`${where}: LvlMaze.SizeX is ${String(width)}`)
+  if (!Number.isFinite(height) || height <= 0) throw new Error(`${where}: LvlMaze.SizeY is ${String(height)}`)
+  if (request.pieces.length === 0) throw new Error(`${where}: no usable LvlPrest pieces`)
+  if (!Number.isFinite(request.minRooms) || request.minRooms < 1) {
+    throw new Error(`${where}: LvlMaze.Rooms is ${String(request.minRooms)}`)
+  }
+
+  const levelTypeName = request.levelTypeName ?? inferLevelTypeName(request.pieces)
+  if (levelTypeName === null) throw new Error(`${where}: cannot infer the level type from the piece names`)
+  const profile = MAZE_LEVEL_TYPE_PROFILES.find(candidate => candidate.levelTypeName === levelTypeName)
+  if (profile === undefined) throw new Error(`${where}: no maze profile for level type "${levelTypeName}"`)
+
+  const stats: MazeStats = {
+    patterns: {}, fallbacks: [], specialsApplied: [], unresolvedRoles: [], notes: [],
+    ringRooms: 0, placementAttempts: 0,
+  }
+  const rng = new Rng(request.seed)
+  const mergePerMille = Math.max(0, Math.min(1000, Math.floor(request.merge)))
+  const index = buildPieceIndex(request.pieces)
+
+  const level: MazeLevel = {
+    rooms: [], first: null as unknown as Room, width, height, rng, mergePerMille, nextId: 0, merges: 0,
+  }
+  const first = makeRoom(level)
+  const levelRef: MazeLevel = { ...level, rooms: [first], first }
+  // `first` was built against `level`, whose `rooms` array is the live one; copy
+  // the identity over rather than duplicating state.
+  Object.assign(level, levelRef)
+
+  // `DRLGMAZE_GetRandomRoomExFromLevel` draws uniformly over the roster and the
+  // level seed advances on every call, so the seed must be consumed in the same
+  // order as the passes below.
+  let target = request.minRooms
+  if (request.staffTombLevelId === request.levelId) target *= 3
+  else if (request.bossTombLevelId === request.levelId) target *= 2
+
+  const singleNames = profile.singleRoom?.[request.levelId]
+  if (singleNames !== undefined) {
+    const piece = singleNames.map(name => request.pieces.find(candidate => candidate.name === name))
+      .find(found => found !== undefined)
+    if (piece === undefined) {
+      for (const name of singleNames) stats.unresolvedRoles.push(name)
+      stats.notes.push('single-room level: no named preset resolved, using the first piece')
+      const fallback = request.pieces[0]!
+      first.piece = fallback
+      first.hasDs1 = true
+      noteSpecial(first, fallback, 'single room', stats)
+    } else {
+      first.piece = piece
+      first.hasDs1 = true
+      noteSpecial(first, piece, 'single room', stats)
+    }
+  } else {
+    if (profile.ring !== undefined) {
+      const roomsPerDirection = levelTypeName === 'Act 3 - Sewer' && request.levelId === 92 ? 5 : profile.ring
+      ringLayout(level, roomsPerDirection, index, stats)
+    }
+    if (profile.opening === 'catacombs') {
+      // D2MOO branches on the level id before rolling, so level 1 consumes no
+      // random number here.
+      const horizontal = request.levelId === 34 ? false : rng.int(0, 1) === 1
+      catacombsOpening(level, horizontal, request.pieces, index, stats)
+    }
+    if (profile.prevChain !== undefined) prevChain(level, profile.prevChain, request.pieces, index, stats)
+    if (profile.arcane === true) arcaneSanctuary(level, request.pieces, index, stats)
+    if (profile.lavaPairs === true) lavaPairs(level, request.pieces, index, stats)
+    if (profile.grow) stats.placementAttempts = growMaze(level, target, index, stats)
+
+    // Every room needs a piece before the replacement passes can look for the
+    // plain ones to convert.
+    for (const room of level.rooms) {
+      if (room.piece === null) pickRoomPreset(room, index, stats)
+    }
+
+    if (profile.theme) themeRoll(level, request.pieces, stats)
+
+    // One counter shared by every table, advanced once per call that happens.
+    let cursor = rng.int(0, 3)
+    for (const group of profile.specials) {
+      if (group.levelIds !== undefined && !group.levelIds.includes(request.levelId)) continue
+      if (group.exceptLevelIds !== undefined && group.exceptLevelIds.includes(request.levelId)) continue
+      const entry = group.entries[cursor]!
+      scanReplaceSpecial(level, request.pieces, { ...entry, kind: group.kind, ...(group.inPlaceOnly === true ? { inPlaceOnly: true } : {}) }, index, stats)
+      cursor = (cursor + 1) % 4
+    }
+  }
+
+  const unreachable = level.rooms.length - reachableRooms(level)
+  if (unreachable !== 0) {
+    throw new Error(`${where}: ${String(unreachable)} of ${String(level.rooms.length)} rooms are unreachable`)
+  }
+  const orphans = level.rooms.filter(room => room.piece === null).length
+  if (orphans !== 0) throw new Error(`${where}: ${String(orphans)} rooms ended up with no piece`)
+
+  assignVariants(level, stats)
+  const stamped = stamp(level, stats)
+
+  return {
+    level: stamped,
+    stats: {
+      levelId: request.levelId,
+      levelName: request.levelName,
+      levelTypeName,
+      seed: request.seed,
+      sectionX: width,
+      sectionY: height,
+      targetRooms: target,
+      roomsPlaced: level.rooms.length,
+      ringRooms: stats.ringRooms,
+      placementAttempts: stats.placementAttempts,
+      doorways: level.rooms.reduce((sum, room) => sum + room.orths.length, 0) / 2,
+      mergePerMille,
+      mergedDoorways: level.merges,
+      gridSize: { width: stamped.width, height: stamped.height },
+      gridSizeSubtiles: { width: stamped.width * SUB_TILES_PER_TILE, height: stamped.height * SUB_TILES_PER_TILE },
+      objects: stamped.objects.length,
+      cells: stamped.width * stamped.height,
+      sidePatterns: stats.patterns,
+      fallbacks: stats.fallbacks,
+      specialsApplied: stats.specialsApplied,
+      unresolvedRoles: stats.unresolvedRoles,
+      unimplementedPasses: UNIMPLEMENTED_PASSES,
+      notes: stats.notes,
+    },
+  }
+}
diff --git a/src/game/object-lookup-data.ts b/src/game/object-lookup-data.ts
new file mode 100644
index 0000000..ef56828
--- /dev/null
+++ b/src/game/object-lookup-data.ts
@@ -0,0 +1,31 @@
+// object-lookup-data.ts — 由 scripts/port-object-lookup.ts 生成，请勿手改。
+//
+// 数据来源：OpenDiablo2，d2core/d2records/object_lookup_record_data.go
+//   sha256 c630729eca4851543305ba91052085cea61b9b0b7bfa03fbc7e237b12eea9b00
+//   共 7891 行，其中 ObjectTypeItem 3615 行、去重后 3614 条
+//   （怪物/NPC 行未移植：本项目没有怪物）
+//
+// 含义：DS1 里 `(act, type=Object, id)` → `Objects.txt` 行号 + 引擎用的 token/mode。
+// DS1 的 id 是"该 act 的对象表索引"，不是 Objects.txt 的行号，这张表就是那层映射。
+//
+// 编码：`<ds1Id>:<objectsTxtId>:<token>:<mode>[:d<direction>][:m]`，多条用 `;` 连接；
+// `objectsTxtId` 为 -1 表示该 id 在 Objects.txt 里没有行（不可见/占位对象）；
+// `m` 表示 Base 指向 /Data/Global/Monsters 而不是 /Data/Global/Objects。
+
+/** 每个 act 的物体查找表，值是打包后的记录串。 */
+export const OBJECT_LOOKUP_ROWS: Readonly<Record<number, string>> = {
+  1: '0:12:FN:NU;1:37:TO:ON;2:39:RB:ON;3:35:N1:NU;4:36:N2:NU;5:5:L1:NU;6:17:S1:NU;7:18:S2:NU;8:19:S3:NU;9:20:S4:NU;10:21:S5:NU;11:22:S6:NU;12:30:IT:NU;13:70:4R:NU;14:70:4R:NU;15:69:3R:NU;16:69:3R:NU;17:29:BR:OP;18:31:BF:NU;19:33:A1:NU;20:34:A2:NU;21:37:TO:ON;22:61:SS:NU;23:65:X1:NU;24:66:X2:NU;25:8:TT:NU;26:26:GI:NU;27:28:HI:NU;28:82:B2:NU;29:2:SF:NU;30:81:AF:NU;31:84:HW:NU;32:83:HS:NU;33:78::;34:61:SS:NU;35:103:FL:NU;36:108:HM:NU;37:119:WP:ON;38:580::;39:130:ZW:NU;40:159:CQ:OP;41:163:CF:NU;42:169:CZ:NU;43:160:FX:OP;44:161:FY:OP;45:162:FZ:OP;46:104:A3:NU;47:105:A4:NU;48:106:W1:NU;49:107:W2:NU;50:179:B4:NU;51:180:B5:NU;52:119:WP:ON;53:157:WN:ON;54:247:QA:OP;55:248:QB:OP;56:155:C7:OP;57:174:RY:OP;58:175:RZ:OP;59:139:Q1:OP;60:140:Q2:OP;61:141:Q3:OP;62:144:Q6:OP;63:6:L2:OP;64:240:CY:OP;65:241:CX:OP;66:242:CU:OP;67:54:Z1:NU;68:55:Z2:NU;69:56:Z5:OP;70:57:Z3:OP;71:58:Z4:OP;72:171:SX:OP;73:178:GS:OP;74:239:BZ:NU;75:245:BY:NU;76:250:EW:OP;77:111:F3:NU;78:138:ZY:NU;79:132:ZC:NU;80:164:MB:OP;81:165:MD:OP;82:77:SH:OP;83:85:BC:OP;84:86:SG:OP;85:262:S0:OP;86:263:JB:OP;87:264:JD:OP;88:265:JF:OP;89:50:C1:OP;90:51:C2:OP;91:79:C3:OP;92:53:C4:OP;93:1:C5:OP;94:3:C6:OP;95:7:B1:OP;96:46:CT:OP;97:38:WT:ON;98:256:S9:NU;99:257:WG:NU;100:258:WH:NU;101:129:H2:OP;102:267:B6:NU;103:268:BP:NU;104:269:1G:;105:581::;106:351:SS:;107:352:SS:;108:353:SS:;109:374:UD:NU;110:385:DC:NU:d1:m;111:397:YF:OP;112:321:PP:NU;113:0:29:NU;114:8:TT:NU;115:0::;116:0::;117:0::;118:0::;119:0::;120:0::;121:0::;122:0::;123:0::;124:0::;125:0::;126:0::;127:0::;128:0::;129:0::;130:0::;131:0::;132:0::;133:0::;134:0::;135:0::;136:0::;137:0::;138:0::;139:0::;140:0::;141:0::;142:0::;143:0::;144:0::;145:0::;146:0::;147:0::;148:0::;149:0::;150:-1:NU0:;151:-1:C5:OP;152:-1:SF:OP;153:-1:C6:OP;154:-1:U1:OP;155:-1:L1:OP;156:-1:L2:OP;157:-1:B1:OP;158:-1:TT:OP;159:-1:U2:OP;160:-1:BE:NU;161:-1:BX:OP;162:-1:FN:NU;163:-1:D1:OP;164:-1:D2:OP;165:-1:D3:OP;166:-1:D4:OP;167:-1:S1:OP;168:-1:S2:OP;169:-1:S3:OP;170:-1:S4:OP;171:-1:S5:OP;172:-1:S6:OP;173:-1:D5:OP;174:-1:D6:OP;175:-1:D7:OP;176:-1:GI:OP;177:-1:D8:OP;178:-1:HI:OP;179:-1:BR:ON;180:-1:IT:NU;181:-1:BF:NU;182:-1:CL:NU;183:-1:A1:NU;184:-1:A2:NU;185:-1:N1:NU;186:-1:N2:NU;187:-1:TO:ON;188:-1:WT:ON;189:-1:RB:ON;190:-1:R1:NU;191:-1:R2:NU;192:-1:R3:NU;193:-1:R4:NU;194:-1:R5:NU;195:-1:S1:OP;196:-1:CT:OP;197:-1:AD:NU;198:-1:T1:NU;199:-1:T2:NU;200:-1:C1:OP;201:-1:C2:OP;202:-1:U3:OP;203:-1:C4:OP;204:-1:Z1:NU;205:-1:Z2:NU;206:-1:Z5:OP;207:-1:Z3:OP;208:-1:Z4:OP;209:-1:TP:ON;210:-1:PP:ON;211:-1:SS:;212:-1:D9:OP;213:-1:DA:OP;214:-1:DB:OP;215:-1:X1:;216:-1:X2:;217:-1:1R:NU;218:-1:2R:NU;219:-1:3R:NU;220:-1:4R:NU;221:-1:F1:;222:-1:F2:;223:-1:YD:NU;224:-1:TD:ON;225:-1:DD:ON;226:-1:SZ:;227:-1:SH:OP;228:-1:TA:;229:-1:C3:OP;230:-1:OB:OP;231:-1:AF:OP;232:-1:B2:NU;233:-1:HS:OP;234:-1:HW:OP;235:-1:BC:OP;236:-1:SG:OP;237:-1:CA:OP;238:-1:CB:OP;239:-1:MC:OP;240:-1:DO:OP;241:-1:TL:OP;242:-1:TR:OP;243:-1:iz:OP;244:-1:U4:OP;245:-1:U5:OP;246:-1:iy:OP;247:-1:ix:OP;248:-1:TS:OP;249:-1:TU:OP;250:-1:SJ:OP;251:-1:B3:OP;252:-1:FB:ON;253:-1:FL:NU;254:-1:A3:NU;255:-1:A4:NU;256:-1:W1:NU;257:-1:W2:NU;258:-1:HM:NU;259:-1:P2:OP;260:-1:n5:S1;261:-1:F3:OP;262:-1:n6:S1;263:-1:F4:OP;264:-1:n7:S1;265:-1:F5:OP;266:-1:SN:OP;267:-1:JT:ON;268:-1:F6:OP;269:-1:wp:ON;270:-1:dj:OP;271:-1:ss:;272:-1:ss:;273:-1:iw:OP;274:-1:iv:OP;275:-1:iu:OP;276:-1:is:OP;277:-1:ir:OP;278:-1:hg:OP;279:-1:h2:OP;280:-1:zw:NU;281:-1:9b:OP;282:-1:zc:NU;283:-1:xx:;284:-1:zs:OP;285:-1:zr:OP;286:-1:zd:OP;287:-1:zl:NU;288:-1:zy:NU;289:-1:q1:OP;290:-1:q2:OP;291:-1:q3:OP;292:-1:q4:OP;293:-1:q5:OP;294:-1:q6:OP;295:-1:wi:ON;296:-1:q9:OP;297:-1:q7:OP;298:-1:q8:OP;299:-1:za:OP;300:-1:zv:NU;301:-1:ze:OP;302:-1:HA:NU;303:-1:DX:OP;304:-1:GC:OP;305:-1:c7:OP;306:-1:wm:ON;307:-1:wn:ON;308:-1:cp:OP;309:-1:cq:OP;310:-1:FX:NU;311:-1:FY:NU;312:-1:FZ:NU;313:-1:cf:NU;314:-1:MB:OP;315:-1:MD:OP;316:-1:MF:OP;317:-1:MH:OP;318:-1:MJ:OP;319:-1:cz:NU;320:-1:JH:OP;321:-1:sx:OP;322:-1:Mk:OP;323:-1:Mi:OP;324:-1:RY:OP;325:-1:RZ:OP;326:-1:c8:OP;327:-1:c9:OP;328:-1:GS:OP;329:-1:b4:OP;330:-1:b5:OP;331:-1:JC:OP;332:-1:tm:OP;333:-1:jz:OP;334:-1:jy:OP;335:-1:jx:OP;336:-1:jw:OP;337:-1:jv:OP;338:-1:ju:OP;339:-1:tP:OP;340:-1:js:OP;341:-1:jr:OP;342:-1:7h:NU;343:-1:ab:OP;344:-1:sl:;345:-1:sv:;346:-1:a5:OP;347:-1:jq:OP;348:-1:c0:OP;349:-1:mz:OP;350:-1:my:OP;351:-1:mx:NU;352:-1:mw:OP;353:-1:mv:OP;354:-1:mu:OP;355:-1:mt:OP;356:-1:mr:OP;357:-1:rw:NU;358:-1:bd:OP;359:-1:bj:OP;360:-1:lw:NU;361:-1:wb:NU;362:-1:yb:NU;363:-1:wd:NU;364:-1:wc:NU;365:-1:we:NU;366:-1:wy:NU;367:-1:lx:NU;368:-1:w3:NU;369:-1:w4:NU;370:-1:w5:NU;371:-1:w6:NU;372:-1:70:OP;373:-1:CN:OP;374:-1:CC:OP;375:-1:ib:OP;376:-1:ia:OP;377:-1:QX:NU;378:-1:qw:NU;379:-1:SQ:OP;380:-1:SY:OP;381:-1:ht:OP;382:-1:hq:OP;383:-1:hv:OP;384:-1:Qy:NU;385:-1:Qz:NU;386:-1:ho:OP;387:-1:wz:ON;388:-1:wv:ON;389:-1:bz:ON;390:-1:cy:OP;391:-1:cx:OP;392:-1:cu:OP;393:-1:cd:OP;394:-1:rn:OP;395:-1:by:NU;396:-1:ra:OP;397:-1:qa:OP;398:-1:qb:OP;399:-1:hn:OP;400:-1:ew:OP;401:-1:ga:ON;402:-1:gd:ON;403:-1:11:NU;404:-1:12:NU;405:-1:ss:;406:-1:s9:NU;407:-1:wg:NU;408:-1:wh:NU;409:-1:QS:OP;410:-1:HL:OP;411:-1:A7:OP;412:-1:s0:OP;413:-1:jb:NU;414:-1:jd:OP;415:-1:jf:OP;416:-1:GP:OP;417:-1:b6:NU;418:-1:BP:NU;419:-1:1g:;420:-1:GF:OP;421:-1:dg:OP;422:-1:df:OP;423:-1:f8:NU;424:-1:f9:;425:-1:ce:OP;426:-1:cg:OP;427:-1:cg:OP;428:-1:de:OP;429:-1:wj:NU;430:-1:wk:OP;431:-1:wl:OP;432:-1:ws:NU;433:-1:bi:NU;434:-1:qc:OP;435:-1:bm:NU;436:-1:bo:NU;437:-1:bq:NU;438:-1:w7:ON;439:-1:ub:OP;440:-1:dv:NU;441:-1:dn:NU;442:-1:dp:NU;443:-1:dt:NU;444:-1:dk:NU;445:-1:dl:NU;446:-1:qd:NU;447:-1:qe:NU;448:-1:ay:ON;449:-1:hb:OP;450:-1:hc:OP;451:-1:qf:OP;452:-1:qg:OP;453:-1:hd:OP;454:-1:7h:NU;455:-1:aa:NU;456:-1:aa:NU;457:-1:7a:NU;458:-1:7b:NU;459:-1:7c:NU;460:-1:7d:NU;461:-1:7e:NU;462:-1:7f:NU;463:-1:7g:NU;464:-1:qh:NU;465:-1:qi:NU;466:-1:qj:NU;467:-1:qk:NU;468:-1:ss:;469:-1:ax:OP;470:-1:au:OP;471:-1:pp:S1;472:-1:hu:NU;473:-1:qm:ON;474:-1:ql:ON;475:-1:qn:NU;476:-1:qo:OP;477:-1:V1:NU;478:-1:V2:NU;479:-1:xb:OP;480:-1:xc:OP;481:-1:xd:OP;482:-1:xe:OP;483:-1:xf:OP;484:-1:xg:OP;485:-1:xh:OP;486:-1:xi:OP;487:-1:y6:NU;488:-1:y4:NU;489:-1:y2:NU;490:-1:y3:NU;491:-1:xj:OP;492:-1:1y:ON;493:-1:xl:OP;494:-1:xm:OP;495:-1:e3:NU;496:-1:e4:NU;497:-1:e5:NU;498:-1:e6:NU;499:-1:e7:NU;500:-1:e8:NU;501:-1:ss:;502:-1:ss:;503:-1:ss:;504:-1:xk:OP;505:-1:xk:OP;506:-1:xk:OP;507:-1:TT:NU;508:-1:E1:NU;509:-1:E2:NU;510:-1:xn:OP;511:-1:qo:OP;512:-1:xp:OP;513:-1:jw:OP;514:-1:ea:OP;515:-1:vb:OP;516:-1:ve:OP;517:-1:vf:OP;518:-1:ss:;519:-1:ss:;520:-1:VG:NU;521:-1:L1:OP;522:-1:y1:OP;523:-1:Qt:OP;524:-1:ud:NU;525:-1:xx:;526:-1:ux:ON;527:-1:PP:NU;528:-1:ss:;529:-1:ss:;530:-1:uy:OP;531:-1:15:OP;532:-1:ss:;533:-1:18:OP;534:-1:19:OP;535:-1:ss:;536:-1:sv:OP;537:-1:y7:OP;538:-1:y8:OP;539:-1:y9:OP;540:-1:ya:OP;541:-1:yc:OP;542:-1:30:ON;543:-1:31:ON;544:-1:32:ON;545:-1:33:ON;546:-1:34:ON;547:-1:yf:OP;548:-1:yg:ON;549:-1:fh:OP;550:-1:he:NU;551:-1:35:NU;552:-1:yi:ON;553:-1:9f:NU;554:-1:55:NU;555:-1:xk:OP;556:-1:xk:OP;557:-1:xk:OP;558:-1:98:NU;559:-1:99:NU;560:-1:zq:OP;561:-1:px:NU;562:-1:py:NU;563:-1:6q:OP;564:-1:6r:OP;565:-1:6s:NU;566:-1:3w:OP;567:-1:ym:NU;568:-1:yn:OP;569:-1:6t:OP;570:-1:yp:OP;571:-1:yq:NU;572:-1:yr:OP;573:-1:ys:OP;574:-1:yt:OP;575:-1:ys:OP;576:-1:yv:NU;577:-1:yw:OP;578:-1:yx:OP;579:-1:yy:ON;580:-1:yz:OP;581:-1:6a:OP;582:-1:6b:OP;583:-1:6c:OP;584:-1:6d:NU;585:-1:2w:NU;586:-1:2x:NU;587:-1:6e:NU;588:-1:6f:NU;589:-1:6g:NU;590:-1:6h:NU;591:-1:2y:NU;592:-1:2z:NU;593:-1:6i:OP;594:-1:6j:OP;595:-1:6k:OP;596:-1:6L:NU;597:-1:6m:NU;598:-1:6n:OP;599:-1:2v:OP;600:-1:6o:NU;601:-1:6p:NU;602:-1:ao:NU;603:-1:ap:NU;604:-1:6t:OP;605:-1:6u:OP;606:-1:6v:NU;607:-1:6w:NU;608:-1:6x:NU;609:-1:ss:;610:-1:ss:;611:-1:ss:;612:-1:ss:;613:-1:6y:OP;614:-1:8a:OP;615:-1:8b:OP;616:-1:8c:OP;617:-1:8d:OP;618:-1:8e:OP;619:-1:8f:OP;620:-1:8g:OP;621:-1:8h:OP;622:-1:8i:NU;623:-1:60:NU;624:-1:60:NU;625:-1:61:NU;626:-1:62:NU;627:-1:8j:OP;628:-1:oz:NU;629:-1:8k:NU;630:-1:8L:NU;631:-1:8m:NU;632:-1:2p:NU;633:-1:8n:OP;634:-1:8o:OP;635:-1:8p:OP;636:-1:8q:OP;637:-1:8r:OP;638:-1:8s:NU;639:-1:8t:NU;640:-1:8u:NU;641:-1:8v:OP;642:-1:8w:OP;643:-1:8x:NU;644:-1:8y:ON;645:-1:8z:NU;646:-1:5a:ON;647:-1:5b:OP;648:-1:5c:NU;649:-1:5d:NU;650:-1:5e:OP;651:-1:5f:OP;652:-1:5g:OP;653:-1:5h:NU;654:-1:5f:OP;655:-1:5f:OP;656:-1:5k:NU;657:-1:5l:NU;658:-1:2q:NU;659:-1:5h:NU;660:-1:5k:NU;661:-1:5a:ON;662:-1:5t:NU;663:-1:5q:NU;664:-1:5r:NU;665:-1:5s:NU;666:-1:5u:OP;667:-1:5v:OP;668:-1:5w:OP;669:-1:5x:NU;670:-1:5y:NU;671:-1:5z:OP;672:-1:3a:OP;673:-1:ss:;674:-1:3b:OP;675:-1:3c:OP;676:-1:3d:OP;677:-1:2u:NU;678:-1:2s:NU;679:-1:3f:OP;680:-1:3g:OP;681:-1:3h:OP;682:-1:3i:OP;683:-1:3j:OP;684:-1:3k:OP;685:-1:3L:OP;686:-1:3m:NU;687:-1:3n:NU;688:-1:3o:NU;689:-1:3p:ON;690:-1:3q:NU;691:-1:3s:OP;692:-1:ss:;693:-1:ss:;694:-1:3t:OP;695:-1:3u:OP;696:-1:4a:OP;697:-1:4b:OP;698:-1:3x:NU;699:-1:3y:NU;700:-1:3z:NU;701:-1:4c:NU;702:-1:9g:NU;703:-1:9h:NU;704:-1:9i:NU;705:-1:2o:NU;706:-1:3v:OP;707:-1:ss:;708:-1:2n:NU;709:-1:29:NU;710:-1:25:NU;711:-1:ss:;712:-1:ss:;713:-1:4x:ON;714:-1:4u:OP;715:-1:pp:NU;716:-1:pp:NU;717:-1:ss:;718:-1:7z:NU;719:-1:4x:ON;720:-1:7y:NU;721:-1:ss:;722:-1:ss:',
+  2: '0:74:TD:NU;1:37:TO:ON;2:192:7H:NU;3:304:7H:NU;4:305:AA:NU;5:306:AA:NU;6:101:B3:OP;7:102:FB:ON;8:78:TA:;9:103:FL:NU;10:156:WM:ON;11:580::;12:132:ZC:NU;13:129:H2:OP;14:357:TT:NU;15:153:DX:OP;16:121:JE:NU:d1:m;17:122:JE:NU:d7:m;18:229:SQ:OP;19:230:SY:OP;20:196:A5:OP;21:267:B6:NU;22:261:A7:OP;23:149:ZA:OP;24:269:1G:;25:4:U1:OP;26:9:U2:OP;27:52:U3:OP;28:94:U4:OP;29:95:U5:OP;30:142:Q4:OP;31:143:Q5:OP;32:5:L1:OP;33:6:L2:OP;34:87:CA:OP;35:88:CB:OP;36:146:Q9:OP;37:146:Q9:OP;38:147:Q7:OP;39:148:Q8:OP;40:240:CY:OP;41:241:CX:OP;42:242:CU:OP;43:243:CD:OP;44:176:C8:OP;45:177:C9:OP;46:198:C0:OP;47:246:RA:OP;48:29:BR:OP;49:160:FX:OP;50:161:FY:OP;51:162:FZ:OP;52:273:F8:NU;53:283:BI:OP;54:85:BC:OP;55:86:SG:OP;56:109:P2:OP;57:116:SN:OP;58:134:ZS:OP;59:135:ZR:OP;60:136:ZD:OP;61:150:ZV:OP;62:151:ZE:OP;63:172:MK:OP;64:173:MI:OP;65:279:WJ:OP;66:280:WK:OP;67:281:WL:OP;68:282:WS:OP;69:166:MF:OP;70:167:MH:OP;71:113:F4:NU;72:137:ZL:NU;73:89:MC:OP;74:104:A3:NU;75:105:A4:NU;76:106:W1:NU;77:107:W2:NU;78:154:GC:OP;79:171:SX:OP;80:178:GS:OP;81:270:GF:OP;82:271:DG:OP;83:272:DF:OP;84:266:GP:OP;85:274:F9:NU;86:244:RN:OP;87:284:QC:OP;88:288:W7:ON;89:298:AY:ON;90:289:UB:OP;91:296:QD:NU;92:297:QE:NU;93:287:BQ:NU;94:286:BO:NU;95:285:BM:NU;96:290:DV:OP;97:291:DN:OP;98:292:DP:OP;99:293:DT:OP;100:294:DK:OP;101:295:DL:OP;102:133:AZ:NU;103:303:HD:OP;104:299:HB:OP;105:300:HC:OP;106:301:QF:OP;107:302:QG:OP;108:581::;109:354:XK:OP;110:582:7C:NU;111:314:QH:NU;112:315:QI:NU;113:316:QJ:NU;114:317:QK:NU;115:323:QM:ON;116:322:HU:NU;117:110:N5:S1;118:112:N6:S2;119:114:N7:S1;120:355:XK:OP;121:356:XK:OP;122:357:TT:OP;123:351:SS:;124:352:SS:;125:353:SS:;126:152:HA:NU;127:374:UD:NU;128:387:Y7:OP;129:389:Y9:OP;130:390:YA:OP;131:391:YC:OP;132:388:Y8:OP;133:397:YF:OP;134:402:YI:ON;135:0::;136:0::;137:0::;138:0::;139:0::;140:0::;141:0::;142:0::;143:0::;144:0::;145:0::;146:0::;147:0::;148:0::;149:0::;150:-1:NU0:;151:-1:C5:OP;152:-1:SF:OP;153:-1:C6:OP;154:-1:U1:OP;155:-1:L1:OP;156:-1:L2:OP;157:-1:B1:OP;158:-1:TT:OP;159:-1:U2:OP;160:-1:BE:NU;161:-1:BX:OP;162:-1:FN:NU;163:-1:D1:OP;164:-1:D2:OP;165:-1:D3:OP;166:-1:D4:OP;167:-1:S1:OP;168:-1:S2:OP;169:-1:S3:OP;170:-1:S4:OP;171:-1:S5:OP;172:-1:S6:OP;173:-1:D5:OP;174:-1:D6:OP;175:-1:D7:OP;176:-1:GI:OP;177:-1:D8:OP;178:-1:HI:OP;179:-1:BR:ON;180:-1:IT:NU;181:-1:BF:NU;182:-1:CL:NU;183:-1:A1:NU;184:-1:A2:NU;185:-1:N1:NU;186:-1:N2:NU;187:-1:TO:ON;188:-1:WT:ON;189:-1:RB:ON;190:-1:R1:NU;191:-1:R2:NU;192:-1:R3:NU;193:-1:R4:NU;194:-1:R5:NU;195:-1:S1:OP;196:-1:CT:OP;197:-1:AD:NU;198:-1:T1:NU;199:-1:T2:NU;200:-1:C1:OP;201:-1:C2:OP;202:-1:U3:OP;203:-1:C4:OP;204:-1:Z1:NU;205:-1:Z2:NU;206:-1:Z5:OP;207:-1:Z3:OP;208:-1:Z4:OP;209:-1:TP:ON;210:-1:PP:ON;211:-1:SS:;212:-1:D9:OP;213:-1:DA:OP;214:-1:DB:OP;215:-1:X1:;216:-1:X2:;217:-1:1R:NU;218:-1:2R:NU;219:-1:3R:NU;220:-1:4R:NU;221:-1:F1:;222:-1:F2:;223:-1:YD:NU;224:-1:TD:ON;225:-1:DD:ON;226:-1:SZ:;227:-1:SH:OP;228:-1:TA:;229:-1:C3:OP;230:-1:OB:OP;231:-1:AF:OP;232:-1:B2:NU;233:-1:HS:OP;234:-1:HW:OP;235:-1:BC:OP;236:-1:SG:OP;237:-1:CA:OP;238:-1:CB:OP;239:-1:MC:OP;240:-1:DO:OP;241:-1:TL:OP;242:-1:TR:OP;243:-1:iz:OP;244:-1:U4:OP;245:-1:U5:OP;246:-1:iy:OP;247:-1:ix:OP;248:-1:TS:OP;249:-1:TU:OP;250:-1:SJ:OP;251:-1:B3:OP;252:-1:FB:ON;253:-1:FL:NU;254:-1:A3:NU;255:-1:A4:NU;256:-1:W1:NU;257:-1:W2:NU;258:-1:HM:NU;259:-1:P2:OP;260:-1:n5:S1;261:-1:F3:OP;262:-1:n6:S1;263:-1:F4:OP;264:-1:n7:S1;265:-1:F5:OP;266:-1:SN:OP;267:-1:JT:ON;268:-1:F6:OP;269:-1:wp:ON;270:-1:dj:OP;271:-1:ss:;272:-1:ss:;273:-1:iw:OP;274:-1:iv:OP;275:-1:iu:OP;276:-1:is:OP;277:-1:ir:OP;278:-1:hg:OP;279:-1:h2:OP;280:-1:zw:NU;281:-1:9b:OP;282:-1:zc:NU;283:-1:xx:;284:-1:zs:OP;285:-1:zr:OP;286:-1:zd:OP;287:-1:zl:NU;288:-1:zy:NU;289:-1:q1:OP;290:-1:q2:OP;291:-1:q3:OP;292:-1:q4:OP;293:-1:q5:OP;294:-1:q6:OP;295:-1:wi:ON;296:-1:q9:OP;297:-1:q7:OP;298:-1:q8:OP;299:-1:za:OP;300:-1:zv:NU;301:-1:ze:OP;302:-1:HA:NU;303:-1:DX:OP;304:-1:GC:OP;305:-1:c7:OP;306:-1:wm:ON;307:-1:wn:ON;308:-1:cp:OP;309:-1:cq:OP;310:-1:FX:NU;311:-1:FY:NU;312:-1:FZ:NU;313:-1:cf:NU;314:-1:MB:OP;315:-1:MD:OP;316:-1:MF:OP;317:-1:MH:OP;318:-1:MJ:OP;319:-1:cz:NU;320:-1:JH:OP;321:-1:sx:OP;322:-1:Mk:OP;323:-1:Mi:OP;324:-1:RY:OP;325:-1:RZ:OP;326:-1:c8:OP;327:-1:c9:OP;328:-1:GS:OP;329:-1:b4:OP;330:-1:b5:OP;331:-1:JC:OP;332:-1:tm:OP;333:-1:jz:OP;334:-1:jy:OP;335:-1:jx:OP;336:-1:jw:OP;337:-1:jv:OP;338:-1:ju:OP;339:-1:tP:OP;340:-1:js:OP;341:-1:jr:OP;342:-1:7h:NU;343:-1:ab:OP;344:-1:sl:;345:-1:sv:;346:-1:a5:OP;347:-1:jq:OP;348:-1:c0:OP;349:-1:mz:OP;350:-1:my:OP;351:-1:mx:NU;352:-1:mw:OP;353:-1:mv:OP;354:-1:mu:OP;355:-1:mt:OP;356:-1:mr:OP;357:-1:rw:NU;358:-1:bd:OP;359:-1:bj:OP;360:-1:lw:NU;361:-1:wb:NU;362:-1:yb:NU;363:-1:wd:NU;364:-1:wc:NU;365:-1:we:NU;366:-1:wy:NU;367:-1:lx:NU;368:-1:w3:NU;369:-1:w4:NU;370:-1:w5:NU;371:-1:w6:NU;372:-1:70:OP;373:-1:CN:OP;374:-1:CC:OP;375:-1:ib:OP;376:-1:ia:OP;377:-1:QX:NU;378:-1:qw:NU;379:-1:SQ:OP;380:-1:SY:OP;381:-1:ht:OP;382:-1:hq:OP;383:-1:hv:OP;384:-1:Qy:NU;385:-1:Qz:NU;386:-1:ho:OP;387:-1:wz:ON;388:-1:wv:ON;389:-1:bz:ON;390:-1:cy:OP;391:-1:cx:OP;392:-1:cu:OP;393:-1:cd:OP;394:-1:rn:OP;395:-1:by:NU;396:-1:ra:OP;397:-1:qa:OP;398:-1:qb:OP;399:-1:hn:OP;400:-1:ew:OP;401:-1:ga:ON;402:-1:gd:ON;403:-1:11:NU;404:-1:12:NU;405:-1:ss:;406:-1:s9:NU;407:-1:wg:NU;408:-1:wh:NU;409:-1:QS:OP;410:-1:HL:OP;411:-1:A7:OP;412:-1:s0:OP;413:-1:jb:NU;414:-1:jd:OP;415:-1:jf:OP;416:-1:GP:OP;417:-1:b6:NU;418:-1:BP:NU;419:-1:1g:;420:-1:GF:OP;421:-1:dg:OP;422:-1:df:OP;423:-1:f8:NU;424:-1:f9:;425:-1:ce:OP;426:-1:cg:OP;427:-1:cg:OP;428:-1:de:OP;429:-1:wj:NU;430:-1:wk:OP;431:-1:wl:OP;432:-1:ws:NU;433:-1:bi:NU;434:-1:qc:OP;435:-1:bm:NU;436:-1:bo:NU;437:-1:bq:NU;438:-1:w7:ON;439:-1:ub:OP;440:-1:dv:NU;441:-1:dn:NU;442:-1:dp:NU;443:-1:dt:NU;444:-1:dk:NU;445:-1:dl:NU;446:-1:qd:NU;447:-1:qe:NU;448:-1:ay:ON;449:-1:hb:OP;450:-1:hc:OP;451:-1:qf:OP;452:-1:qg:OP;453:-1:hd:OP;454:-1:7h:NU;455:-1:aa:NU;456:-1:aa:NU;457:-1:7a:NU;458:-1:7b:NU;459:-1:7c:NU;460:-1:7d:NU;461:-1:7e:NU;462:-1:7f:NU;463:-1:7g:NU;464:-1:qh:NU;465:-1:qi:NU;466:-1:qj:NU;467:-1:qk:NU;468:-1:ss:;469:-1:ax:OP;470:-1:au:OP;471:-1:pp:S1;472:-1:hu:NU;473:-1:qm:ON;474:-1:ql:ON;475:-1:qn:NU;476:-1:qo:OP;477:-1:V1:NU;478:-1:V2:NU;479:-1:xb:OP;480:-1:xc:OP;481:-1:xd:OP;482:-1:xe:OP;483:-1:xf:OP;484:-1:xg:OP;485:-1:xh:OP;486:-1:xi:OP;487:-1:y6:NU;488:-1:y4:NU;489:-1:y2:NU;490:-1:y3:NU;491:-1:xj:OP;492:-1:1y:ON;493:-1:xl:OP;494:-1:xm:OP;495:-1:e3:NU;496:-1:e4:NU;497:-1:e5:NU;498:-1:e6:NU;499:-1:e7:NU;500:-1:e8:NU;501:-1:ss:;502:-1:ss:;503:-1:ss:;504:-1:xk:OP;505:-1:xk:OP;506:-1:xk:OP;507:-1:TT:NU;508:-1:E1:NU;509:-1:E2:NU;510:-1:xn:OP;511:-1:qo:OP;512:-1:xp:OP;513:-1:jw:OP;514:-1:ea:OP;515:-1:vb:OP;516:-1:ve:OP;517:-1:vf:OP;518:-1:ss:;519:-1:ss:;520:-1:VG:NU;521:-1:L1:OP;522:-1:y1:OP;523:-1:Qt:OP;524:-1:ud:NU;525:-1:xx:;526:-1:ux:ON;527:-1:PP:NU;528:-1:ss:;529:-1:ss:;530:-1:uy:OP;531:-1:15:OP;532:-1:ss:;533:-1:18:OP;534:-1:19:OP;535:-1:ss:;536:-1:sv:OP;537:-1:y7:OP;538:-1:y8:OP;539:-1:y9:OP;540:-1:ya:OP;541:-1:yc:OP;542:-1:30:ON;543:-1:31:ON;544:-1:32:ON;545:-1:33:ON;546:-1:34:ON;547:-1:yf:OP;548:-1:yg:ON;549:-1:fh:OP;550:-1:he:NU;551:-1:35:NU;552:-1:yi:ON;553:-1:9f:NU;554:-1:55:NU;555:-1:xk:OP;556:-1:xk:OP;557:-1:xk:OP;558:-1:98:NU;559:-1:99:NU;560:-1:zq:OP;561:-1:px:NU;562:-1:py:NU;563:-1:6q:OP;564:-1:6r:OP;565:-1:6s:NU;566:-1:3w:OP;567:-1:ym:NU;568:-1:yn:OP;569:-1:6t:OP;570:-1:yp:OP;571:-1:yq:NU;572:-1:yr:OP;573:-1:ys:OP;574:-1:yt:OP;575:-1:ys:OP;576:-1:yv:NU;577:-1:yw:OP;578:-1:yx:OP;579:-1:yy:ON;580:-1:yz:OP;581:-1:6a:OP;582:-1:6b:OP;583:-1:6c:OP;584:-1:6d:NU;585:-1:2w:NU;586:-1:2x:NU;587:-1:6e:NU;588:-1:6f:NU;589:-1:6g:NU;590:-1:6h:NU;591:-1:2y:NU;592:-1:2z:NU;593:-1:6i:OP;594:-1:6j:OP;595:-1:6k:OP;596:-1:6L:NU;597:-1:6m:NU;598:-1:6n:OP;599:-1:2v:OP;600:-1:6o:NU;601:-1:6p:NU;602:-1:ao:NU;603:-1:ap:NU;604:-1:6t:OP;605:-1:6u:OP;606:-1:6v:NU;607:-1:6w:NU;608:-1:6x:NU;609:-1:ss:;610:-1:ss:;611:-1:ss:;612:-1:ss:;613:-1:6y:OP;614:-1:8a:OP;615:-1:8b:OP;616:-1:8c:OP;617:-1:8d:OP;618:-1:8e:OP;619:-1:8f:OP;620:-1:8g:OP;621:-1:8h:OP;622:-1:8i:NU;623:-1:60:NU;624:-1:60:NU;625:-1:61:NU;626:-1:62:NU;627:-1:8j:OP;628:-1:oz:NU;629:-1:8k:NU;630:-1:8L:NU;631:-1:8m:NU;632:-1:2p:NU;633:-1:8n:OP;634:-1:8o:OP;635:-1:8p:OP;636:-1:8q:OP;637:-1:8r:OP;638:-1:8s:NU;639:-1:8t:NU;640:-1:8u:NU;641:-1:8v:OP;642:-1:8w:OP;643:-1:8x:NU;644:-1:8y:ON;645:-1:8z:NU;646:-1:5a:ON;647:-1:5b:OP;648:-1:5c:NU;649:-1:5d:NU;650:-1:5e:OP;651:-1:5f:OP;652:-1:5g:OP;653:-1:5h:NU;654:-1:5f:OP;655:-1:5f:OP;656:-1:5k:NU;657:-1:5l:NU;658:-1:2q:NU;659:-1:5h:NU;660:-1:5k:NU;661:-1:5a:ON;662:-1:5t:NU;663:-1:5q:NU;664:-1:5r:NU;665:-1:5s:NU;666:-1:5u:OP;667:-1:5v:OP;668:-1:5w:OP;669:-1:5x:NU;670:-1:5y:NU;671:-1:5z:OP;672:-1:3a:OP;673:-1:ss:;674:-1:3b:OP;675:-1:3c:OP;676:-1:3d:OP;677:-1:2u:NU;678:-1:2s:NU;679:-1:3f:OP;680:-1:3g:OP;681:-1:3h:OP;682:-1:3i:OP;683:-1:3j:OP;684:-1:3k:OP;685:-1:3L:OP;686:-1:3m:NU;687:-1:3n:NU;688:-1:3o:NU;689:-1:3p:ON;690:-1:3q:NU;691:-1:3s:OP;692:-1:ss:;693:-1:ss:;694:-1:3t:OP;695:-1:3u:OP;696:-1:4a:OP;697:-1:4b:OP;698:-1:3x:NU;699:-1:3y:NU;700:-1:3z:NU;701:-1:4c:NU;702:-1:9g:NU;703:-1:9h:NU;704:-1:9i:NU;705:-1:2o:NU;706:-1:3v:OP;707:-1:ss:;708:-1:2n:NU;709:-1:29:NU;710:-1:25:NU;711:-1:ss:;712:-1:ss:;713:-1:4x:ON;714:-1:4u:OP;715:-1:pp:NU;716:-1:pp:NU;717:-1:ss:;718:-1:7z:NU;719:-1:4x:ON;720:-1:7y:NU;721:-1:ss:;722:-1:ss:',
+  3: '0:117:JT:ON;1:237:WZ:ON;2:580::;3:130:ZW:NU;4:102:FB:ON;5:37:TO:ON;6:160:FX:NU;7:161:FY:NU;8:162:FZ:ON;9:104:A3:NU;10:105:A4:NU;11:106:W1:NU;12:107:W2:NU;13:194:9C:OP;14:195:SV:OP;15:193:AB:NU;16:207:RW:NU;17:211:WB:NU;18:210:LW:NU;19:234:QY:NU;20:214:WC:NU;21:215:WE:NU;22:213:WD:NU;23:228:QW:NU;24:216:WY:NU;25:227:QX:NU;26:217:LX:NU;27:235:QZ:NU;28:218:W3:NU;29:219:W4:NU;30:220:W5:NU;31:221:W6:NU;32:223:CN:NU;33:224:CC:NU;34:267:B6:NU;35:269:1G:NU;36:581::;37:170:JH:OP;38:325:QN:NU;39:184:JY:NU;40:190:JS:NU;41:191:JR:NU;42:197:JQ:NU;43:199:MZ:NU;44:200:MY:NU;45:201:MX:NU;46:202:MW:OP;47:206:MR:OP;48:278:DE:OP;49:120:DJ:OP;50:130:ZW:NU;51:326:QO:OP;52:158:CP:OP;53:271:DG:OP;54:272:DF:OP;55:327:V1:NU;56:328:V2:NU;57:329:XB:OP;58:330:XC:OP;59:331:XD:OP;60:332:XE:OP;61:333:XF:OP;62:334:XG:OP;63:335:XH:OP;64:336:XI:OP;65:5:L1:OP;66:6:L2:OP;67:176:C8:OP;68:240:CY:OP;69:241:CX:OP;70:181:JC:OP;71:183:JZ:OP;72:246:RA:OP;73:185:JX:OP;74:186:JW:OP;75:187:JV:OP;76:188:JU:OP;77:203:MV:OP;78:204:MU:OP;79:205:MT:OP;80:208:BD:OP;81:209:BJ:OP;82:169:CZ:NU;83:323:QM:ON;84:324:QL:ON;85:196:A5:OP;86:212:YB:NU;87:225:IB:OP;88:244:RN:OP;89:351::;90:352::;91:353::;92:360:XN:OP;93:361:XO:OP;94:362:XP:OP;95:365:VB:OP;96:251:GA:ON;97:252:GD:ON;98:208:BD:OP;99:283:BI:NU;100:367:VF:OP;101:366:VE:OP;102:368::;103:341:XJ:ON;342:-1:7h:NU;105:343:XL:OP;106:344:XM:OP;107:374:UD:NU;108:370:VG:NU;109:378:HR:NU:d1:m;110:379:HR:NU:d7:m;111:386:SV:OP;112:397:YF:OP;113:405:XK:OP;114:407:XK:OP;115:406:XK:OP;116:0::;117:0::;118:0::;119:0::;120:0::;121:0::;122:0::;123:0::;124:0::;125:0::;126:0::;127:0::;128:0::;129:0::;130:0::;131:0::;132:0::;133:0::;134:0::;135:0::;136:0::;137:0::;138:0::;139:0::;140:0::;141:0::;142:0::;143:0::;144:0::;145:0::;146:0::;147:0::;148:0::;149:0::;150:-1:NU0:;151:-1:C5:OP;152:-1:SF:OP;153:-1:C6:OP;154:-1:U1:OP;155:-1:L1:OP;156:-1:L2:OP;157:-1:B1:OP;158:-1:TT:OP;159:-1:U2:OP;160:-1:BE:NU;161:-1:BX:OP;162:-1:FN:NU;163:-1:D1:OP;164:-1:D2:OP;165:-1:D3:OP;166:-1:D4:OP;167:-1:S1:OP;168:-1:S2:OP;169:-1:S3:OP;170:-1:S4:OP;171:-1:S5:OP;172:-1:S6:OP;173:-1:D5:OP;174:-1:D6:OP;175:-1:D7:OP;176:-1:GI:OP;177:-1:D8:OP;178:-1:HI:OP;179:-1:BR:ON;180:-1:IT:NU;181:-1:BF:NU;182:-1:CL:NU;183:-1:A1:NU;184:-1:A2:NU;185:-1:N1:NU;186:-1:N2:NU;187:-1:TO:ON;188:-1:WT:ON;189:-1:RB:ON;190:-1:R1:NU;191:-1:R2:NU;192:-1:R3:NU;193:-1:R4:NU;194:-1:R5:NU;195:-1:S1:OP;196:-1:CT:OP;197:-1:AD:NU;198:-1:T1:NU;199:-1:T2:NU;200:-1:C1:OP;201:-1:C2:OP;202:-1:U3:OP;203:-1:C4:OP;204:-1:Z1:NU;205:-1:Z2:NU;206:-1:Z5:OP;207:-1:Z3:OP;208:-1:Z4:OP;209:-1:TP:ON;210:-1:PP:ON;211:-1:SS:;212:-1:D9:OP;213:-1:DA:OP;214:-1:DB:OP;215:-1:X1:;216:-1:X2:;217:-1:1R:NU;218:-1:2R:NU;219:-1:3R:NU;220:-1:4R:NU;221:-1:F1:;222:-1:F2:;223:-1:YD:NU;224:-1:TD:ON;225:-1:DD:ON;226:-1:SZ:;227:-1:SH:OP;228:-1:TA:;229:-1:C3:OP;230:-1:OB:OP;231:-1:AF:OP;232:-1:B2:NU;233:-1:HS:OP;234:-1:HW:OP;235:-1:BC:OP;236:-1:SG:OP;237:-1:CA:OP;238:-1:CB:OP;239:-1:MC:OP;240:-1:DO:OP;241:-1:TL:OP;242:-1:TR:OP;243:-1:iz:OP;244:-1:U4:OP;245:-1:U5:OP;246:-1:iy:OP;247:-1:ix:OP;248:-1:TS:OP;249:-1:TU:OP;250:-1:SJ:OP;251:-1:B3:OP;252:-1:FB:ON;253:-1:FL:NU;254:-1:A3:NU;255:-1:A4:NU;256:-1:W1:NU;257:-1:W2:NU;258:-1:HM:NU;259:-1:P2:OP;260:-1:n5:S1;261:-1:F3:OP;262:-1:n6:S1;263:-1:F4:OP;264:-1:n7:S1;265:-1:F5:OP;266:-1:SN:OP;267:-1:JT:ON;268:-1:F6:OP;269:-1:wp:ON;270:-1:dj:OP;271:-1:ss:;272:-1:ss:;273:-1:iw:OP;274:-1:iv:OP;275:-1:iu:OP;276:-1:is:OP;277:-1:ir:OP;278:-1:hg:OP;279:-1:h2:OP;280:-1:zw:NU;281:-1:9b:OP;282:-1:zc:NU;283:-1:xx:;284:-1:zs:OP;285:-1:zr:OP;286:-1:zd:OP;287:-1:zl:NU;288:-1:zy:NU;289:-1:q1:OP;290:-1:q2:OP;291:-1:q3:OP;292:-1:q4:OP;293:-1:q5:OP;294:-1:q6:OP;295:-1:wi:ON;296:-1:q9:OP;297:-1:q7:OP;298:-1:q8:OP;299:-1:za:OP;300:-1:zv:NU;301:-1:ze:OP;302:-1:HA:NU;303:-1:DX:OP;304:-1:GC:OP;305:-1:c7:OP;306:-1:wm:ON;307:-1:wn:ON;308:-1:cp:OP;309:-1:cq:OP;310:-1:FX:NU;311:-1:FY:NU;312:-1:FZ:NU;313:-1:cf:NU;314:-1:MB:OP;315:-1:MD:OP;316:-1:MF:OP;317:-1:MH:OP;318:-1:MJ:OP;319:-1:cz:NU;320:-1:JH:OP;321:-1:sx:OP;322:-1:Mk:OP;323:-1:Mi:OP;324:-1:RY:OP;325:-1:RZ:OP;326:-1:c8:OP;327:-1:c9:OP;328:-1:GS:OP;329:-1:b4:OP;330:-1:b5:OP;331:-1:JC:OP;332:-1:tm:OP;333:-1:jz:OP;334:-1:jy:OP;335:-1:jx:OP;336:-1:jw:OP;337:-1:jv:OP;338:-1:ju:OP;339:-1:tP:OP;340:-1:js:OP;341:-1:jr:OP;343:-1:ab:OP;344:-1:sl:;345:-1:sv:;346:-1:a5:OP;347:-1:jq:OP;348:-1:c0:OP;349:-1:mz:OP;350:-1:my:OP;351:-1:mx:NU;352:-1:mw:OP;353:-1:mv:OP;354:-1:mu:OP;355:-1:mt:OP;356:-1:mr:OP;357:-1:rw:NU;358:-1:bd:OP;359:-1:bj:OP;360:-1:lw:NU;361:-1:wb:NU;362:-1:yb:NU;363:-1:wd:NU;364:-1:wc:NU;365:-1:we:NU;366:-1:wy:NU;367:-1:lx:NU;368:-1:w3:NU;369:-1:w4:NU;370:-1:w5:NU;371:-1:w6:NU;372:-1:70:OP;373:-1:CN:OP;374:-1:CC:OP;375:-1:ib:OP;376:-1:ia:OP;377:-1:QX:NU;378:-1:qw:NU;379:-1:SQ:OP;380:-1:SY:OP;381:-1:ht:OP;382:-1:hq:OP;383:-1:hv:OP;384:-1:Qy:NU;385:-1:Qz:NU;386:-1:ho:OP;387:-1:wz:ON;388:-1:wv:ON;389:-1:bz:ON;390:-1:cy:OP;391:-1:cx:OP;392:-1:cu:OP;393:-1:cd:OP;394:-1:rn:OP;395:-1:by:NU;396:-1:ra:OP;397:-1:qa:OP;398:-1:qb:OP;399:-1:hn:OP;400:-1:ew:OP;401:-1:ga:ON;402:-1:gd:ON;403:-1:11:NU;404:-1:12:NU;405:-1:ss:;406:-1:s9:NU;407:-1:wg:NU;408:-1:wh:NU;409:-1:QS:OP;410:-1:HL:OP;411:-1:A7:OP;412:-1:s0:OP;413:-1:jb:NU;414:-1:jd:OP;415:-1:jf:OP;416:-1:GP:OP;417:-1:b6:NU;418:-1:BP:NU;419:-1:1g:;420:-1:GF:OP;421:-1:dg:OP;422:-1:df:OP;423:-1:f8:NU;424:-1:f9:;425:-1:ce:OP;426:-1:cg:OP;427:-1:cg:OP;428:-1:de:OP;429:-1:wj:NU;430:-1:wk:OP;431:-1:wl:OP;432:-1:ws:NU;433:-1:bi:NU;434:-1:qc:OP;435:-1:bm:NU;436:-1:bo:NU;437:-1:bq:NU;438:-1:w7:ON;439:-1:ub:OP;440:-1:dv:NU;441:-1:dn:NU;442:-1:dp:NU;443:-1:dt:NU;444:-1:dk:NU;445:-1:dl:NU;446:-1:qd:NU;447:-1:qe:NU;448:-1:ay:ON;449:-1:hb:OP;450:-1:hc:OP;451:-1:qf:OP;452:-1:qg:OP;453:-1:hd:OP;454:-1:7h:NU;455:-1:aa:NU;456:-1:aa:NU;457:-1:7a:NU;458:-1:7b:NU;459:-1:7c:NU;460:-1:7d:NU;461:-1:7e:NU;462:-1:7f:NU;463:-1:7g:NU;464:-1:qh:NU;465:-1:qi:NU;466:-1:qj:NU;467:-1:qk:NU;468:-1:ss:;469:-1:ax:OP;470:-1:au:OP;471:-1:pp:S1;472:-1:hu:NU;473:-1:qm:ON;474:-1:ql:ON;475:-1:qn:NU;476:-1:qo:OP;477:-1:V1:NU;478:-1:V2:NU;479:-1:xb:OP;480:-1:xc:OP;481:-1:xd:OP;482:-1:xe:OP;483:-1:xf:OP;484:-1:xg:OP;485:-1:xh:OP;486:-1:xi:OP;487:-1:y6:NU;488:-1:y4:NU;489:-1:y2:NU;490:-1:y3:NU;491:-1:xj:OP;492:-1:1y:ON;493:-1:xl:OP;494:-1:xm:OP;495:-1:e3:NU;496:-1:e4:NU;497:-1:e5:NU;498:-1:e6:NU;499:-1:e7:NU;500:-1:e8:NU;501:-1:ss:;502:-1:ss:;503:-1:ss:;504:-1:xk:OP;505:-1:xk:OP;506:-1:xk:OP;507:-1:TT:NU;508:-1:E1:NU;509:-1:E2:NU;510:-1:xn:OP;511:-1:qo:OP;512:-1:xp:OP;513:-1:jw:OP;514:-1:ea:OP;515:-1:vb:OP;516:-1:ve:OP;517:-1:vf:OP;518:-1:ss:;519:-1:ss:;520:-1:VG:NU;521:-1:L1:OP;522:-1:y1:OP;523:-1:Qt:OP;524:-1:ud:NU;525:-1:xx:;526:-1:ux:ON;527:-1:PP:NU;528:-1:ss:;529:-1:ss:;530:-1:uy:OP;531:-1:15:OP;532:-1:ss:;533:-1:18:OP;534:-1:19:OP;535:-1:ss:;536:-1:sv:OP;537:-1:y7:OP;538:-1:y8:OP;539:-1:y9:OP;540:-1:ya:OP;541:-1:yc:OP;542:-1:30:ON;543:-1:31:ON;544:-1:32:ON;545:-1:33:ON;546:-1:34:ON;547:-1:yf:OP;548:-1:yg:ON;549:-1:fh:OP;550:-1:he:NU;551:-1:35:NU;552:-1:yi:ON;553:-1:9f:NU;554:-1:55:NU;555:-1:xk:OP;556:-1:xk:OP;557:-1:xk:OP;558:-1:98:NU;559:-1:99:NU;560:-1:zq:OP;561:-1:px:NU;562:-1:py:NU;563:-1:6q:OP;564:-1:6r:OP;565:-1:6s:NU;566:-1:3w:OP;567:-1:ym:NU;568:-1:yn:OP;569:-1:6t:OP;570:-1:yp:OP;571:-1:yq:NU;572:-1:yr:OP;573:-1:ys:OP;574:-1:yt:OP;575:-1:ys:OP;576:-1:yv:NU;577:-1:yw:OP;578:-1:yx:OP;579:-1:yy:ON;580:-1:yz:OP;581:-1:6a:OP;582:-1:6b:OP;583:-1:6c:OP;584:-1:6d:NU;585:-1:2w:NU;586:-1:2x:NU;587:-1:6e:NU;588:-1:6f:NU;589:-1:6g:NU;590:-1:6h:NU;591:-1:2y:NU;592:-1:2z:NU;593:-1:6i:OP;594:-1:6j:OP;595:-1:6k:OP;596:-1:6L:NU;597:-1:6m:NU;598:-1:6n:OP;599:-1:2v:OP;600:-1:6o:NU;601:-1:6p:NU;602:-1:ao:NU;603:-1:ap:NU;604:-1:6t:OP;605:-1:6u:OP;606:-1:6v:NU;607:-1:6w:NU;608:-1:6x:NU;609:-1:ss:;610:-1:ss:;611:-1:ss:;612:-1:ss:;613:-1:6y:OP;614:-1:8a:OP;615:-1:8b:OP;616:-1:8c:OP;617:-1:8d:OP;618:-1:8e:OP;619:-1:8f:OP;620:-1:8g:OP;621:-1:8h:OP;622:-1:8i:NU;623:-1:60:NU;624:-1:60:NU;625:-1:61:NU;626:-1:62:NU;627:-1:8j:OP;628:-1:oz:NU;629:-1:8k:NU;630:-1:8L:NU;631:-1:8m:NU;632:-1:2p:NU;633:-1:8n:OP;634:-1:8o:OP;635:-1:8p:OP;636:-1:8q:OP;637:-1:8r:OP;638:-1:8s:NU;639:-1:8t:NU;640:-1:8u:NU;641:-1:8v:OP;642:-1:8w:OP;643:-1:8x:NU;644:-1:8y:ON;645:-1:8z:NU;646:-1:5a:ON;647:-1:5b:OP;648:-1:5c:NU;649:-1:5d:NU;650:-1:5e:OP;651:-1:5f:OP;652:-1:5g:OP;653:-1:5h:NU;654:-1:5f:OP;655:-1:5f:OP;656:-1:5k:NU;657:-1:5l:NU;658:-1:2q:NU;659:-1:5h:NU;660:-1:5k:NU;661:-1:5a:ON;662:-1:5t:NU;663:-1:5q:NU;664:-1:5r:NU;665:-1:5s:NU;666:-1:5u:OP;667:-1:5v:OP;668:-1:5w:OP;669:-1:5x:NU;670:-1:5y:NU;671:-1:5z:OP;672:-1:3a:OP;673:-1:ss:;674:-1:3b:OP;675:-1:3c:OP;676:-1:3d:OP;677:-1:2u:NU;678:-1:2s:NU;679:-1:3f:OP;680:-1:3g:OP;681:-1:3h:OP;682:-1:3i:OP;683:-1:3j:OP;684:-1:3k:OP;685:-1:3L:OP;686:-1:3m:NU;687:-1:3n:NU;688:-1:3o:NU;689:-1:3p:ON;690:-1:3q:NU;691:-1:3s:OP;692:-1:ss:;693:-1:ss:;694:-1:3t:OP;695:-1:3u:OP;696:-1:4a:OP;697:-1:4b:OP;698:-1:3x:NU;699:-1:3y:NU;700:-1:3z:NU;701:-1:4c:NU;702:-1:9g:NU;703:-1:9h:NU;704:-1:9i:NU;705:-1:2o:NU;706:-1:3v:OP;707:-1:ss:;708:-1:2n:NU;709:-1:29:NU;710:-1:25:NU;711:-1:ss:;712:-1:ss:;713:-1:4x:ON;714:-1:4u:OP;715:-1:pp:NU;716:-1:pp:NU;717:-1:ss:;718:-1:7z:NU;719:-1:4x:ON;720:-1:7y:NU;721:-1:ss:;722:-1:ss:',
+  4: '0:238:WV:ON;1:580::;2:267:B6:NU;3:269:1G:NU;4:581::;5:573::;6:573::;7:573::;8:345:E3:NU;9:346:E4:NU;10:347:E5:NU;11:348:E6:NU;12:349:E7:NU;13:350:E8:NU;14:351::;15:352::;16:353::;17:358:E1:NU;18:359:E2:NU;19:363:XQ:OP;20:259:QS:OP;21:373:QT:OP;22:372:Y1:OP;23:374:UD:NU;24:236:HO:OP;25:249:HN:OP;26:226:IA:OP;27:231:HT:OP;28:232:HQ:OP;29:93:IZ:OP;30:97:IX:OP;31:123:IW:OP;32:124:IV:OP;33:96:IY:OP;34:225:IB:OP;35:233:HV:OP;36:222:70:OP;37:125:IU:OP;38:126:IS:OP;39:127:IR:OP;40:128:HG:ON;41:375::;42:376:UX:ON;43:254:12:NU;44:253:11:NU;45:342:1Y:ON;46:255:DI:NU:d7:m;47:392:30:ON;48:393:31:ON;49:394:32:ON;50:395:33:ON;51:396:34:ON;52:398:YG:ON;53:397:YF:OP;54:399:FH:OP;55:401:35:NU;56:400:HE:NU;57:380:UY:ON;58:383:18:OP;59:384:19:OP;60:296:QD:NU;61:297:QE:NU;62:403:9F:NU;63:102:FB:ON;64:408:98:NU;65:409:99:NU;66:0::;67:0::;68:0::;69:0::;70:0::;71:0::;72:0::;73:0::;74:0::;75:0::;76:0::;77:0::;78:0::;79:0::;80:0::;81:0::;82:0::;83:0::;84:0::;85:0::;86:0::;87:0::;88:0::;89:0::;90:0::;91:0::;92:0::;93:0::;94:0::;95:0::;96:0::;97:0::;98:0::;99:0::;100:0::;101:0::;102:0::;103:0::;104:0::;105:0::;106:0::;107:0::;108:0::;109:0::;110:0::;111:0::;112:0::;113:0::;114:0::;115:0::;116:0::;117:0::;118:0::;119:0::;120:0::;121:0::;122:0::;123:0::;124:0::;125:0::;126:0::;127:0::;128:0::;129:0::;130:0::;131:0::;132:0::;133:0::;134:0::;135:0::;136:0::;137:0::;138:0::;139:0::;140:0::;141:0::;142:0::;143:0::;144:0::;145:0::;146:0::;147:0::;148:0::;149:0::;150:-1:NU0:;151:-1:C5:OP;152:-1:SF:OP;153:-1:C6:OP;154:-1:U1:OP;155:-1:L1:OP;156:-1:L2:OP;157:-1:B1:OP;158:-1:TT:OP;159:-1:U2:OP;160:-1:BE:NU;161:-1:BX:OP;162:-1:FN:NU;163:-1:D1:OP;164:-1:D2:OP;165:-1:D3:OP;166:-1:D4:OP;167:-1:S1:OP;168:-1:S2:OP;169:-1:S3:OP;170:-1:S4:OP;171:-1:S5:OP;172:-1:S6:OP;173:-1:D5:OP;174:-1:D6:OP;175:-1:D7:OP;176:-1:GI:OP;177:-1:D8:OP;178:-1:HI:OP;179:-1:BR:ON;180:-1:IT:NU;181:-1:BF:NU;182:-1:CL:NU;183:-1:A1:NU;184:-1:A2:NU;185:-1:N1:NU;186:-1:N2:NU;187:-1:TO:ON;188:-1:WT:ON;189:-1:RB:ON;190:-1:R1:NU;191:-1:R2:NU;192:-1:R3:NU;193:-1:R4:NU;194:-1:R5:NU;195:-1:S1:OP;196:-1:CT:OP;197:-1:AD:NU;198:-1:T1:NU;199:-1:T2:NU;200:-1:C1:OP;201:-1:C2:OP;202:-1:U3:OP;203:-1:C4:OP;204:-1:Z1:NU;205:-1:Z2:NU;206:-1:Z5:OP;207:-1:Z3:OP;208:-1:Z4:OP;209:-1:TP:ON;210:-1:PP:ON;211:-1:SS:;212:-1:D9:OP;213:-1:DA:OP;214:-1:DB:OP;215:-1:X1:;216:-1:X2:;217:-1:1R:NU;218:-1:2R:NU;219:-1:3R:NU;220:-1:4R:NU;221:-1:F1:;222:-1:F2:;223:-1:YD:NU;224:-1:TD:ON;225:-1:DD:ON;226:-1:SZ:;227:-1:SH:OP;228:-1:TA:;229:-1:C3:OP;230:-1:OB:OP;231:-1:AF:OP;232:-1:B2:NU;233:-1:HS:OP;234:-1:HW:OP;235:-1:BC:OP;236:-1:SG:OP;237:-1:CA:OP;238:-1:CB:OP;239:-1:MC:OP;240:-1:DO:OP;241:-1:TL:OP;242:-1:TR:OP;243:-1:iz:OP;244:-1:U4:OP;245:-1:U5:OP;246:-1:iy:OP;247:-1:ix:OP;248:-1:TS:OP;249:-1:TU:OP;250:-1:SJ:OP;251:-1:B3:OP;252:-1:FB:ON;253:-1:FL:NU;254:-1:A3:NU;255:-1:A4:NU;256:-1:W1:NU;257:-1:W2:NU;258:-1:HM:NU;259:-1:P2:OP;260:-1:n5:S1;261:-1:F3:OP;262:-1:n6:S1;263:-1:F4:OP;264:-1:n7:S1;265:-1:F5:OP;266:-1:SN:OP;267:-1:JT:ON;268:-1:F6:OP;269:-1:wp:ON;270:-1:dj:OP;271:-1:ss:;272:-1:ss:;273:-1:iw:OP;274:-1:iv:OP;275:-1:iu:OP;276:-1:is:OP;277:-1:ir:OP;278:-1:hg:OP;279:-1:h2:OP;280:-1:zw:NU;281:-1:9b:OP;282:-1:zc:NU;283:-1:xx:;284:-1:zs:OP;285:-1:zr:OP;286:-1:zd:OP;287:-1:zl:NU;288:-1:zy:NU;289:-1:q1:OP;290:-1:q2:OP;291:-1:q3:OP;292:-1:q4:OP;293:-1:q5:OP;294:-1:q6:OP;295:-1:wi:ON;296:-1:q9:OP;297:-1:q7:OP;298:-1:q8:OP;299:-1:za:OP;300:-1:zv:NU;301:-1:ze:OP;302:-1:HA:NU;303:-1:DX:OP;304:-1:GC:OP;305:-1:c7:OP;306:-1:wm:ON;307:-1:wn:ON;308:-1:cp:OP;309:-1:cq:OP;310:-1:FX:NU;311:-1:FY:NU;312:-1:FZ:NU;313:-1:cf:NU;314:-1:MB:OP;315:-1:MD:OP;316:-1:MF:OP;317:-1:MH:OP;318:-1:MJ:OP;319:-1:cz:NU;320:-1:JH:OP;321:-1:sx:OP;322:-1:Mk:OP;323:-1:Mi:OP;324:-1:RY:OP;325:-1:RZ:OP;326:-1:c8:OP;327:-1:c9:OP;328:-1:GS:OP;329:-1:b4:OP;330:-1:b5:OP;331:-1:JC:OP;332:-1:tm:OP;333:-1:jz:OP;334:-1:jy:OP;335:-1:jx:OP;336:-1:jw:OP;337:-1:jv:OP;338:-1:ju:OP;339:-1:tP:OP;340:-1:js:OP;341:-1:jr:OP;342:-1:7h:NU;343:-1:ab:OP;344:-1:sl:;345:-1:sv:;346:-1:a5:OP;347:-1:jq:OP;348:-1:c0:OP;349:-1:mz:OP;350:-1:my:OP;351:-1:mx:NU;352:-1:mw:OP;353:-1:mv:OP;354:-1:mu:OP;355:-1:mt:OP;356:-1:mr:OP;357:-1:rw:NU;358:-1:bd:OP;359:-1:bj:OP;360:-1:lw:NU;361:-1:wb:NU;362:-1:yb:NU;363:-1:wd:NU;364:-1:wc:NU;365:-1:we:NU;366:-1:wy:NU;367:-1:lx:NU;368:-1:w3:NU;369:-1:w4:NU;370:-1:w5:NU;371:-1:w6:NU;372:-1:70:OP;373:-1:CN:OP;374:-1:CC:OP;375:-1:ib:OP;376:-1:ia:OP;377:-1:QX:NU;378:-1:qw:NU;379:-1:SQ:OP;380:-1:SY:OP;381:-1:ht:OP;382:-1:hq:OP;383:-1:hv:OP;384:-1:Qy:NU;385:-1:Qz:NU;386:-1:ho:OP;387:-1:wz:ON;388:-1:wv:ON;389:-1:bz:ON;390:-1:cy:OP;391:-1:cx:OP;392:-1:cu:OP;393:-1:cd:OP;394:-1:rn:OP;395:-1:by:NU;396:-1:ra:OP;397:-1:qa:OP;398:-1:qb:OP;399:-1:hn:OP;400:-1:ew:OP;401:-1:ga:ON;402:-1:gd:ON;403:-1:11:NU;404:-1:12:NU;405:-1:ss:;406:-1:s9:NU;407:-1:wg:NU;408:-1:wh:NU;409:-1:QS:OP;410:-1:HL:OP;411:-1:A7:OP;412:-1:s0:OP;413:-1:jb:NU;414:-1:jd:OP;415:-1:jf:OP;416:-1:GP:OP;417:-1:b6:NU;418:-1:BP:NU;419:-1:1g:;420:-1:GF:OP;421:-1:dg:OP;422:-1:df:OP;423:-1:f8:NU;424:-1:f9:;425:-1:ce:OP;426:-1:cg:OP;427:-1:cg:OP;428:-1:de:OP;429:-1:wj:NU;430:-1:wk:OP;431:-1:wl:OP;432:-1:ws:NU;433:-1:bi:NU;434:-1:qc:OP;435:-1:bm:NU;436:-1:bo:NU;437:-1:bq:NU;438:-1:w7:ON;439:-1:ub:OP;440:-1:dv:NU;441:-1:dn:NU;442:-1:dp:NU;443:-1:dt:NU;444:-1:dk:NU;445:-1:dl:NU;446:-1:qd:NU;447:-1:qe:NU;448:-1:ay:ON;449:-1:hb:OP;450:-1:hc:OP;451:-1:qf:OP;452:-1:qg:OP;453:-1:hd:OP;454:-1:7h:NU;455:-1:aa:NU;456:-1:aa:NU;457:-1:7a:NU;458:-1:7b:NU;459:-1:7c:NU;460:-1:7d:NU;461:-1:7e:NU;462:-1:7f:NU;463:-1:7g:NU;464:-1:qh:NU;465:-1:qi:NU;466:-1:qj:NU;467:-1:qk:NU;468:-1:ss:;469:-1:ax:OP;470:-1:au:OP;471:-1:pp:S1;472:-1:hu:NU;473:-1:qm:ON;474:-1:ql:ON;475:-1:qn:NU;476:-1:qo:OP;477:-1:V1:NU;478:-1:V2:NU;479:-1:xb:OP;480:-1:xc:OP;481:-1:xd:OP;482:-1:xe:OP;483:-1:xf:OP;484:-1:xg:OP;485:-1:xh:OP;486:-1:xi:OP;487:-1:y6:NU;488:-1:y4:NU;489:-1:y2:NU;490:-1:y3:NU;491:-1:xj:OP;492:-1:1y:ON;493:-1:xl:OP;494:-1:xm:OP;495:-1:e3:NU;496:-1:e4:NU;497:-1:e5:NU;498:-1:e6:NU;499:-1:e7:NU;500:-1:e8:NU;501:-1:ss:;502:-1:ss:;503:-1:ss:;504:-1:xk:OP;505:-1:xk:OP;506:-1:xk:OP;507:-1:TT:NU;508:-1:E1:NU;509:-1:E2:NU;510:-1:xn:OP;511:-1:qo:OP;512:-1:xp:OP;513:-1:jw:OP;514:-1:ea:OP;515:-1:vb:OP;516:-1:ve:OP;517:-1:vf:OP;518:-1:ss:;519:-1:ss:;520:-1:VG:NU;521:-1:L1:OP;522:-1:y1:OP;523:-1:Qt:OP;524:-1:ud:NU;525:-1:xx:;526:-1:ux:ON;527:-1:PP:NU;528:-1:ss:;529:-1:ss:;530:-1:uy:OP;531:-1:15:OP;532:-1:ss:;533:-1:18:OP;534:-1:19:OP;535:-1:ss:;536:-1:sv:OP;537:-1:y7:OP;538:-1:y8:OP;539:-1:y9:OP;540:-1:ya:OP;541:-1:yc:OP;542:-1:30:ON;543:-1:31:ON;544:-1:32:ON;545:-1:33:ON;546:-1:34:ON;547:-1:yf:OP;548:-1:yg:ON;549:-1:fh:OP;550:-1:he:NU;551:-1:35:NU;552:-1:yi:ON;553:-1:9f:NU;554:-1:55:NU;555:-1:xk:OP;556:-1:xk:OP;557:-1:xk:OP;558:-1:98:NU;559:-1:99:NU;560:-1:zq:OP;561:-1:px:NU;562:-1:py:NU;563:-1:6q:OP;564:-1:6r:OP;565:-1:6s:NU;566:-1:3w:OP;567:-1:ym:NU;568:-1:yn:OP;569:-1:6t:OP;570:-1:yp:OP;571:-1:yq:NU;572:-1:yr:OP;573:-1:ys:OP;574:-1:yt:OP;575:-1:ys:OP;576:-1:yv:NU;577:-1:yw:OP;578:-1:yx:OP;579:-1:yy:ON;580:-1:yz:OP;581:-1:6a:OP;582:-1:6b:OP;583:-1:6c:OP;584:-1:6d:NU;585:-1:2w:NU;586:-1:2x:NU;587:-1:6e:NU;588:-1:6f:NU;589:-1:6g:NU;590:-1:6h:NU;591:-1:2y:NU;592:-1:2z:NU;593:-1:6i:OP;594:-1:6j:OP;595:-1:6k:OP;596:-1:6L:NU;597:-1:6m:NU;598:-1:6n:OP;599:-1:2v:OP;600:-1:6o:NU;601:-1:6p:NU;602:-1:ao:NU;603:-1:ap:NU;604:-1:6t:OP;605:-1:6u:OP;606:-1:6v:NU;607:-1:6w:NU;608:-1:6x:NU;609:-1:ss:;610:-1:ss:;611:-1:ss:;612:-1:ss:;613:-1:6y:OP;614:-1:8a:OP;615:-1:8b:OP;616:-1:8c:OP;617:-1:8d:OP;618:-1:8e:OP;619:-1:8f:OP;620:-1:8g:OP;621:-1:8h:OP;622:-1:8i:NU;623:-1:60:NU;624:-1:60:NU;625:-1:61:NU;626:-1:62:NU;627:-1:8j:OP;628:-1:oz:NU;629:-1:8k:NU;630:-1:8L:NU;631:-1:8m:NU;632:-1:2p:NU;633:-1:8n:OP;634:-1:8o:OP;635:-1:8p:OP;636:-1:8q:OP;637:-1:8r:OP;638:-1:8s:NU;639:-1:8t:NU;640:-1:8u:NU;641:-1:8v:OP;642:-1:8w:OP;643:-1:8x:NU;644:-1:8y:ON;645:-1:8z:NU;646:-1:5a:ON;647:-1:5b:OP;648:-1:5c:NU;649:-1:5d:NU;650:-1:5e:OP;651:-1:5f:OP;652:-1:5g:OP;653:-1:5h:NU;654:-1:5f:OP;655:-1:5f:OP;656:-1:5k:NU;657:-1:5l:NU;658:-1:2q:NU;659:-1:5h:NU;660:-1:5k:NU;661:-1:5a:ON;662:-1:5t:NU;663:-1:5q:NU;664:-1:5r:NU;665:-1:5s:NU;666:-1:5u:OP;667:-1:5v:OP;668:-1:5w:OP;669:-1:5x:NU;670:-1:5y:NU;671:-1:5z:OP;672:-1:3a:OP;673:-1:ss:;674:-1:3b:OP;675:-1:3c:OP;676:-1:3d:OP;677:-1:2u:NU;678:-1:2s:NU;679:-1:3f:OP;680:-1:3g:OP;681:-1:3h:OP;682:-1:3i:OP;683:-1:3j:OP;684:-1:3k:OP;685:-1:3L:OP;686:-1:3m:NU;687:-1:3n:NU;688:-1:3o:NU;689:-1:3p:ON;690:-1:3q:NU;691:-1:3s:OP;692:-1:ss:;693:-1:ss:;694:-1:3t:OP;695:-1:3u:OP;696:-1:4a:OP;697:-1:4b:OP;698:-1:3x:NU;699:-1:3y:NU;700:-1:3z:NU;701:-1:4c:NU;702:-1:9g:NU;703:-1:9h:NU;704:-1:9i:NU;705:-1:2o:NU;706:-1:3v:OP;707:-1:ss:;708:-1:2n:NU;709:-1:29:NU;710:-1:25:NU;711:-1:ss:;712:-1:ss:;713:-1:4x:ON;714:-1:4u:OP;715:-1:pp:NU;716:-1:pp:NU;717:-1:ss:;718:-1:7z:NU;719:-1:4x:ON;720:-1:7y:NU;721:-1:ss:;722:-1:ss:',
+  5: '0:452:AO:NU;1:453:AP:NU;2:338:Y4:NU;3:337:Y6:NU;4:267:B6:NU;5:374:UD:NU;6:482:2P:NU;7:39:RB:ON;8:35:N1:NU;9:36:N2:NU;10:33:A1:NU;11:34:A2:NU;12:38:WT:ON;13:102:FB:ON;14:411:PX:NU;15:438:6F:NU;16:412:PY:NU;17:435:2W:NU;18:436:2X:NU;19:440:6H:NU;20:441:2Y:NU;21:441:2Y:NU;22:442:2Z:NU;23:429:YY:ON;24:420:YP:OP;25:431:6A:OP;26:430:YZ:OP;27:413:6Q:OP;28:432:6B:OP;29:433:6C:OP;30:418:YN:OP;31:419:YO:OP;32:424:YT:OP;33:425:YU:OP;34:416:3W:OP;35:414:6R:OP;36:415:6S:NU;37:427:YW:OP;38:428:YX:OP;39:421:YQ:NU;40:422:YR:OP;41:423:YS:OP;42:426:YV:NU;43:451:6P:NU;44:267:B6:NU;45:443:6I:OP;46:444:6J:OP;47:445:6K:OP;48:446:6L:NU;49:447:6M:NU;50:448:6N:NU;51:450:6O:NU;52:451:6P:NU;53:459:XS:NU:d1:m;54:460:2N:NU;55:461:0J:NU:d1:m;56:462:0J:NU:d7:m;57:482:2P:NU;58:473::;59:455:6U:OP;60:456:6V:NU;61:457:6W:NU;62:458:6X:NU;63:463:6Y:OP;64:464:8A:OP;65:465:8B:OP;66:466:8C:OP;67:467:8D:OP;68:468:8E:OP;69:469:8F:OP;70:470:8G:OP;71:471:8H:OP;72:472:8I:OP;73:477:8J:OP;74:479:8K:OP;75:480:8L:NU;76:481:8M:NU;77:483:8N:OP;78:484:8O:OP;79:485:8P:OP;80:486:8Q:OP;81:487:8R:OP;82:454:6T:OP;83:437:6E:NU;84:508:2Q:OP;85:488:8S:OP;86:493:8X:NU;87:493:8X:NU;88:495:8Z:OP;89:497:5B:OP;90:499:5D:OP;91:503:5H:OP;92:509:5M:OP;93:512:5T:OP;94:489:8T:NU;95:490:8U:NU;96:514:5R:NU;97:515:5S:NU;98:493:8X:NU;99:498:5C:NU;100:513:5Q:NU;101:494:8Y:ON;102:496:5A:ON;103:511:5O:ON;104:500:5E:OP;105:501:5F:OP;106:502:5G:OP;107:504:5I:OP;108:505:5J:OP;109:506:5K:NU;110:507:5L:NU;111:510:5N:NU;112:160:FX:NU;113:161:FY:NU;114:162:FZ:NU;115:269::;116:523::;117:434:6D:NU;118:496:5A:ON;119:496:5A:ON;120:496:5A:ON;121:527:2U:NU;122:528:2S:OP;123:538:3O:NU;124:539:3P:ON;125:542:XR:NU:d1:m;126:543:XR:NU:m;127:546:4A:OP;128:547:4B:OP;129:548:3X:NU;130:549:3Y:NU;131:550:3Z:NU;132:551:4C:NU;133:552:9G:NU;134:555:2O:NU;135:553:9H:NU;136:554:9I:NU;137:557::;138:541:3S:OP;139:544:3T:OP;140:559:29:NU;141:560:25:NU;142:564:4U:OP;143:567::;144:568:7Z:NU;145:536:3M:NU;146:537:3N:NU;147:563:4X:ON;148:570:7Y:NU;149:397:YF:OP;150:-1:NU0:;151:-1:C5:OP;152:-1:SF:OP;153:-1:C6:OP;154:-1:U1:OP;155:-1:L1:OP;156:-1:L2:OP;157:-1:B1:OP;158:-1:TT:OP;159:-1:U2:OP;160:-1:BE:NU;161:-1:BX:OP;162:-1:FN:NU;163:-1:D1:OP;164:-1:D2:OP;165:-1:D3:OP;166:-1:D4:OP;167:-1:S1:OP;168:-1:S2:OP;169:-1:S3:OP;170:-1:S4:OP;171:-1:S5:OP;172:-1:S6:OP;173:-1:D5:OP;174:-1:D6:OP;175:-1:D7:OP;176:-1:GI:OP;177:-1:D8:OP;178:-1:HI:OP;179:-1:BR:ON;180:-1:IT:NU;181:-1:BF:NU;182:-1:CL:NU;183:-1:A1:NU;184:-1:A2:NU;185:-1:N1:NU;186:-1:N2:NU;187:-1:TO:ON;188:-1:WT:ON;189:-1:RB:ON;190:-1:R1:NU;191:-1:R2:NU;192:-1:R3:NU;193:-1:R4:NU;194:-1:R5:NU;195:-1:S1:OP;196:-1:CT:OP;197:-1:AD:NU;198:-1:T1:NU;199:-1:T2:NU;200:-1:C1:OP;201:-1:C2:OP;202:-1:U3:OP;203:-1:C4:OP;204:-1:Z1:NU;205:-1:Z2:NU;206:-1:Z5:OP;207:-1:Z3:OP;208:-1:Z4:OP;209:-1:TP:ON;210:-1:PP:ON;211:-1:SS:;212:-1:D9:OP;213:-1:DA:OP;214:-1:DB:OP;215:-1:X1:;216:-1:X2:;217:-1:1R:NU;218:-1:2R:NU;219:-1:3R:NU;220:-1:4R:NU;221:-1:F1:;222:-1:F2:;223:-1:YD:NU;224:-1:TD:ON;225:-1:DD:ON;226:-1:SZ:;227:-1:SH:OP;228:-1:TA:;229:-1:C3:OP;230:-1:OB:OP;231:-1:AF:OP;232:-1:B2:NU;233:-1:HS:OP;234:-1:HW:OP;235:-1:BC:OP;236:-1:SG:OP;237:-1:CA:OP;238:-1:CB:OP;239:-1:MC:OP;240:-1:DO:OP;241:-1:TL:OP;242:-1:TR:OP;243:-1:iz:OP;244:-1:U4:OP;245:-1:U5:OP;246:-1:iy:OP;247:-1:ix:OP;248:-1:TS:OP;249:-1:TU:OP;250:-1:SJ:OP;251:-1:B3:OP;252:-1:FB:ON;253:-1:FL:NU;254:-1:A3:NU;255:-1:A4:NU;256:-1:W1:NU;257:-1:W2:NU;258:-1:HM:NU;259:-1:P2:OP;260:-1:n5:S1;261:-1:F3:OP;262:-1:n6:S1;263:-1:F4:OP;264:-1:n7:S1;265:-1:F5:OP;266:-1:SN:OP;267:-1:JT:ON;268:-1:F6:OP;269:-1:wp:ON;270:-1:dj:OP;271:-1:ss:;272:-1:ss:;273:-1:iw:OP;274:-1:iv:OP;275:-1:iu:OP;276:-1:is:OP;277:-1:ir:OP;278:-1:hg:OP;279:-1:h2:OP;280:-1:zw:NU;281:-1:9b:OP;282:-1:zc:NU;283:-1:xx:;284:-1:zs:OP;285:-1:zr:OP;286:-1:zd:OP;287:-1:zl:NU;288:-1:zy:NU;289:-1:q1:OP;290:-1:q2:OP;291:-1:q3:OP;292:-1:q4:OP;293:-1:q5:OP;294:-1:q6:OP;295:-1:wi:ON;296:-1:q9:OP;297:-1:q7:OP;298:-1:q8:OP;299:-1:za:OP;300:-1:zv:NU;301:-1:ze:OP;302:-1:HA:NU;303:-1:DX:OP;304:-1:GC:OP;305:-1:c7:OP;306:-1:wm:ON;307:-1:wn:ON;308:-1:cp:OP;309:-1:cq:OP;310:-1:FX:NU;311:-1:FY:NU;312:-1:FZ:NU;313:-1:cf:NU;314:-1:MB:OP;315:-1:MD:OP;316:-1:MF:OP;317:-1:MH:OP;318:-1:MJ:OP;319:-1:cz:NU;320:-1:JH:OP;321:-1:sx:OP;322:-1:Mk:OP;323:-1:Mi:OP;324:-1:RY:OP;325:-1:RZ:OP;326:-1:c8:OP;327:-1:c9:OP;328:-1:GS:OP;329:-1:b4:OP;330:-1:b5:OP;331:-1:JC:OP;332:-1:tm:OP;333:-1:jz:OP;334:-1:jy:OP;335:-1:jx:OP;336:-1:jw:OP;337:-1:jv:OP;338:-1:ju:OP;339:-1:tP:OP;340:-1:js:OP;341:-1:jr:OP;342:-1:7h:NU;343:-1:ab:OP;344:-1:sl:;345:-1:sv:;346:-1:a5:OP;347:-1:jq:OP;348:-1:c0:OP;349:-1:mz:OP;350:-1:my:OP;351:-1:mx:NU;352:-1:mw:OP;353:-1:mv:OP;354:-1:mu:OP;355:-1:mt:OP;356:-1:mr:OP;357:-1:rw:NU;358:-1:bd:OP;359:-1:bj:OP;360:-1:lw:NU;361:-1:wb:NU;362:-1:yb:NU;363:-1:wd:NU;364:-1:wc:NU;365:-1:we:NU;366:-1:wy:NU;367:-1:lx:NU;368:-1:w3:NU;369:-1:w4:NU;370:-1:w5:NU;371:-1:w6:NU;372:-1:70:OP;373:-1:CN:OP;374:-1:CC:OP;375:-1:ib:OP;376:-1:ia:OP;377:-1:QX:NU;378:-1:qw:NU;379:-1:SQ:OP;380:-1:SY:OP;381:-1:ht:OP;382:-1:hq:OP;383:-1:hv:OP;384:-1:Qy:NU;385:-1:Qz:NU;386:-1:ho:OP;387:-1:wz:ON;388:-1:wv:ON;389:-1:bz:ON;390:-1:cy:OP;391:-1:cx:OP;392:-1:cu:OP;393:-1:cd:OP;394:-1:rn:OP;395:-1:by:NU;396:-1:ra:OP;397:-1:qa:OP;398:-1:qb:OP;399:-1:hn:OP;400:-1:ew:OP;401:-1:ga:ON;402:-1:gd:ON;403:-1:11:NU;404:-1:12:NU;405:-1:ss:;406:-1:s9:NU;407:-1:wg:NU;408:-1:wh:NU;409:-1:QS:OP;410:-1:HL:OP;411:-1:A7:OP;412:-1:s0:OP;413:-1:jb:NU;414:-1:jd:OP;415:-1:jf:OP;416:-1:GP:OP;417:-1:b6:NU;418:-1:BP:NU;419:-1:1g:;420:-1:GF:OP;421:-1:dg:OP;422:-1:df:OP;423:-1:f8:NU;424:-1:f9:;425:-1:ce:OP;426:-1:cg:OP;427:-1:cg:OP;428:-1:de:OP;429:-1:wj:NU;430:-1:wk:OP;431:-1:wl:OP;432:-1:ws:NU;433:-1:bi:NU;434:-1:qc:OP;435:-1:bm:NU;436:-1:bo:NU;437:-1:bq:NU;438:-1:w7:ON;439:-1:ub:OP;440:-1:dv:NU;441:-1:dn:NU;442:-1:dp:NU;443:-1:dt:NU;444:-1:dk:NU;445:-1:dl:NU;446:-1:qd:NU;447:-1:qe:NU;448:-1:ay:ON;449:-1:hb:OP;450:-1:hc:OP;451:-1:qf:OP;452:-1:qg:OP;453:-1:hd:OP;454:-1:7h:NU;455:-1:aa:NU;456:-1:aa:NU;457:-1:7a:NU;458:-1:7b:NU;459:-1:7c:NU;460:-1:7d:NU;461:-1:7e:NU;462:-1:7f:NU;463:-1:7g:NU;464:-1:qh:NU;465:-1:qi:NU;466:-1:qj:NU;467:-1:qk:NU;468:-1:ss:;469:-1:ax:OP;470:-1:au:OP;471:-1:pp:S1;472:-1:hu:NU;473:-1:qm:ON;474:-1:ql:ON;475:-1:qn:NU;476:-1:qo:OP;477:-1:V1:NU;478:-1:V2:NU;479:-1:xb:OP;480:-1:xc:OP;481:-1:xd:OP;482:-1:xe:OP;483:-1:xf:OP;484:-1:xg:OP;485:-1:xh:OP;486:-1:xi:OP;487:-1:y6:NU;488:-1:y4:NU;489:-1:y2:NU;490:-1:y3:NU;491:-1:xj:OP;492:-1:1y:ON;493:-1:xl:OP;494:-1:xm:OP;495:-1:e3:NU;496:-1:e4:NU;497:-1:e5:NU;498:-1:e6:NU;499:-1:e7:NU;500:-1:e8:NU;501:-1:ss:;502:-1:ss:;503:-1:ss:;504:-1:xk:OP;505:-1:xk:OP;506:-1:xk:OP;507:-1:TT:NU;508:-1:E1:NU;509:-1:E2:NU;510:-1:xn:OP;511:-1:qo:OP;512:-1:xp:OP;513:-1:jw:OP;514:-1:ea:OP;515:-1:vb:OP;516:-1:ve:OP;517:-1:vf:OP;518:-1:ss:;519:-1:ss:;520:-1:VG:NU;521:-1:L1:OP;522:-1:y1:OP;523:-1:Qt:OP;524:-1:ud:NU;525:-1:xx:;526:-1:ux:ON;527:-1:PP:NU;528:-1:ss:;529:-1:ss:;530:-1:uy:OP;531:-1:15:OP;532:-1:ss:;533:-1:18:OP;534:-1:19:OP;535:-1:ss:;536:-1:sv:OP;537:-1:y7:OP;538:-1:y8:OP;539:-1:y9:OP;540:-1:ya:OP;541:-1:yc:OP;542:-1:30:ON;543:-1:31:ON;544:-1:32:ON;545:-1:33:ON;546:-1:34:ON;547:-1:yf:OP;548:-1:yg:ON;549:-1:fh:OP;550:-1:he:NU;551:-1:35:NU;552:-1:yi:ON;553:-1:9f:NU;554:-1:55:NU;555:-1:xk:OP;556:-1:xk:OP;557:-1:xk:OP;558:-1:98:NU;559:-1:99:NU;560:-1:zq:OP;561:-1:px:NU;562:-1:py:NU;563:-1:6q:OP;564:-1:6r:OP;565:-1:6s:NU;566:-1:3w:OP;567:-1:ym:NU;568:-1:yn:OP;569:-1:6t:OP;570:-1:yp:OP;571:-1:yq:NU;572:-1:yr:OP;573:-1:ys:OP;574:-1:yt:OP;575:-1:ys:OP;576:-1:yv:NU;577:-1:yw:OP;578:-1:yx:OP;579:-1:yy:ON;580:-1:yz:OP;581:-1:6a:OP;582:-1:6b:OP;583:-1:6c:OP;584:-1:6d:NU;585:-1:2w:NU;586:-1:2x:NU;587:-1:6e:NU;588:-1:6f:NU;589:-1:6g:NU;590:-1:6h:NU;591:-1:2y:NU;592:-1:2z:NU;593:-1:6i:OP;594:-1:6j:OP;595:-1:6k:OP;596:-1:6L:NU;597:-1:6m:NU;598:-1:6n:OP;599:-1:2v:OP;600:-1:6o:NU;601:-1:6p:NU;602:-1:ao:NU;603:-1:ap:NU;604:-1:6t:OP;605:-1:6u:OP;606:-1:6v:NU;607:-1:6w:NU;608:-1:6x:NU;609:-1:ss:;610:-1:ss:;611:-1:ss:;612:-1:ss:;613:-1:6y:OP;614:-1:8a:OP;615:-1:8b:OP;616:-1:8c:OP;617:-1:8d:OP;618:-1:8e:OP;619:-1:8f:OP;620:-1:8g:OP;621:-1:8h:OP;622:-1:8i:NU;623:-1:60:NU;624:-1:60:NU;625:-1:61:NU;626:-1:62:NU;627:-1:8j:OP;628:-1:oz:NU;629:-1:8k:NU;630:-1:8L:NU;631:-1:8m:NU;632:-1:2p:NU;633:-1:8n:OP;634:-1:8o:OP;635:-1:8p:OP;636:-1:8q:OP;637:-1:8r:OP;638:-1:8s:NU;639:-1:8t:NU;640:-1:8u:NU;641:-1:8v:OP;642:-1:8w:OP;643:-1:8x:NU;644:-1:8y:ON;645:-1:8z:NU;646:-1:5a:ON;647:-1:5b:OP;648:-1:5c:NU;649:-1:5d:NU;650:-1:5e:OP;651:-1:5f:OP;652:-1:5g:OP;653:-1:5h:NU;654:-1:5f:OP;655:-1:5f:OP;656:-1:5k:NU;657:-1:5l:NU;658:-1:2q:NU;659:-1:5h:NU;660:-1:5k:NU;661:-1:5a:ON;662:-1:5t:NU;663:-1:5q:NU;664:-1:5r:NU;665:-1:5s:NU;666:-1:5u:OP;667:-1:5v:OP;668:-1:5w:OP;669:-1:5x:NU;670:-1:5y:NU;671:-1:5z:OP;672:-1:3a:OP;673:-1:ss:;674:-1:3b:OP;675:-1:3c:OP;676:-1:3d:OP;677:-1:2u:NU;678:-1:2s:NU;679:-1:3f:OP;680:-1:3g:OP;681:-1:3h:OP;682:-1:3i:OP;683:-1:3j:OP;684:-1:3k:OP;685:-1:3L:OP;686:-1:3m:NU;687:-1:3n:NU;688:-1:3o:NU;689:-1:3p:ON;690:-1:3q:NU;691:-1:3s:OP;692:-1:ss:;693:-1:ss:;694:-1:3t:OP;695:-1:3u:OP;696:-1:4a:OP;697:-1:4b:OP;698:-1:3x:NU;699:-1:3y:NU;700:-1:3z:NU;701:-1:4c:NU;702:-1:9g:NU;703:-1:9h:NU;704:-1:9i:NU;705:-1:2o:NU;706:-1:3v:OP;707:-1:ss:;708:-1:2n:NU;709:-1:29:NU;710:-1:25:NU;711:-1:ss:;712:-1:ss:;713:-1:4x:ON;714:-1:4u:OP;715:-1:pp:NU;716:-1:pp:NU;717:-1:ss:;718:-1:7z:NU;719:-1:4x:ON;720:-1:7y:NU;721:-1:ss:;722:-1:ss:',
+}
+
+/** 表里带 token（= 有美术可查）的记录数。 */
+export const OBJECT_LOOKUP_WITH_ART = 3421
+
+/** 表里 token 为空的记录数：这些是不可见/占位对象，画不出来是对的。 */
+export const OBJECT_LOOKUP_WITHOUT_ART = 193
+
+/** 表里能对到 `Objects.txt` 行的记录数（其余只有 token/mode，没有名称与尺寸等元数据）。 */
+export const OBJECT_LOOKUP_WITH_ROW = 749
diff --git a/src/game/object-lookup.ts b/src/game/object-lookup.ts
new file mode 100644
index 0000000..4637883
--- /dev/null
+++ b/src/game/object-lookup.ts
@@ -0,0 +1,162 @@
+// object-lookup.ts — DS1 对象 `(act, type, id)` → 实际 token/mode 的查找（移植自 OpenDiablo2）
+//
+// 为什么需要这一层：DS1 记录里的对象 `id` **不是** `Objects.txt` 的行号，而是"该 act 的对象
+// 表索引"，那层映射硬编码在游戏里，凭表推不出来。OpenDiablo2 把它整理成了数据表
+// （`d2core/d2records/object_lookup_record_data.go`，7,891 行），并在
+// `d2mapstamp/stamp.go` 里这样用：
+//
+//     lookup := records.LookupObject(act, object.Type, object.ID)
+//     objectRecord := records.Object.Details[lookup.ObjectsTxtId]
+//
+// 本模块把那 3,615 条物体记录（`ObjectTypeItem`；怪物/NPC 行不移植——本项目没有怪物）
+// 装箱进 `object-lookup-data.ts`，在这里解析成查表 API。
+//
+// 与 `Objects.txt` 的关系（实测，见 `npm run verify:objects`）：
+// 表里的 `token` **优先于** `Objects.txt` 的 `Token` 列——后者在 26 处写的是占位符
+// （`SS`/`XX`/`SL`），而表里是真 token（例如 act 2 的 jerhyn 是 `JE`、act 3 的楼梯是 `9C`）。
+// 表里有 750 条能直接对到 `Objects.txt` 行号，另外 2,665 条只给了 token/mode
+// （例如 act 1 的 `id 155 → L1/OP`「LargeChestR」），这些要靠 token 反查元数据。
+//
+// 编码与出处见 `object-lookup-data.ts` 的头部（由 `npm run port:object-lookup` 生成）。
+
+import { OBJECT_LOOKUP_ROWS } from './object-lookup-data.ts'
+
+/** DS1 对象 `type`：怪物/NPC（`MonPreset.txt` 索引）。 */
+export const OBJECT_TYPE_MONSTER = 1
+/** DS1 对象 `type`：可交互物体（本模块查的就是这一类）。 */
+export const OBJECT_TYPE_OBJECT = 2
+
+/** 一条查找结果。 */
+export interface ObjectLookupEntry {
+  /** `Levels.txt` 的 act 号，1..5。 */
+  readonly act: number
+  /** DS1 记录里的 `id`（该 act 对象表的索引）。 */
+  readonly ds1Id: number
+  /** `Objects.txt` 行号；-1 表示这份表没给出行号（要靠 token 反查）。 */
+  readonly objectsTxtId: number
+  /** 实际使用的 token（目录名），空串表示该对象没有美术。 */
+  readonly token: string
+  /** 引擎放置该对象时用的动画模式 token（`NU`/`OP`/…），空串表示未知。 */
+  readonly mode: string
+  /** 固定朝向；-1 表示未指定（用 0）。 */
+  readonly direction: number
+  /** `Base` 指向 `Monsters` 而不是 `Objects`（表里有 11 条这种异常记录）。 */
+  readonly baseIsMonsters: boolean
+}
+
+/** 解析后的每 act 表：ds1Id → 记录。 */
+const CACHE = new Map<number, Map<number, ObjectLookupEntry>>()
+
+/** 这份数据表里除 token 之外的统计，用于文档与验证脚本。 */
+export interface ObjectLookupStats {
+  /** 已移植的 act 号。 */
+  readonly acts: readonly number[]
+  /** 记录总数。 */
+  readonly rows: number
+  /** 有 token（有美术可查）的记录数。 */
+  readonly withArt: number
+  /** token 为空的记录数（不可见/占位对象）。 */
+  readonly withoutArt: number
+  /** 能直接对到 `Objects.txt` 行号的记录数。 */
+  readonly withRow: number
+}
+
+/**
+ * 解析一个 act 的记录串。
+ *
+ * @param act - act 号, for error messages.
+ * @param packed - `;`-separated `id:obj:token:mode[:d⟨dir⟩][:m]` records.
+ * @returns the parsed map.
+ */
+function parseAct(act: number, packed: string): Map<number, ObjectLookupEntry> {
+  const out = new Map<number, ObjectLookupEntry>()
+  for (const record of packed.split(';')) {
+    if (record === '') continue
+    const parts = record.split(':')
+    const [idText, objText, token = '', mode = ''] = parts
+    const id = Number(idText)
+    const objectsTxtId = Number(objText)
+    if (!Number.isFinite(id) || !Number.isFinite(objectsTxtId)) {
+      throw new Error(`object lookup act ${String(act)}: malformed record "${record}"`)
+    }
+    let direction = -1
+    let baseIsMonsters = false
+    for (const flag of parts.slice(4)) {
+      if (flag === 'm') baseIsMonsters = true
+      else if (flag.startsWith('d')) direction = Number(flag.slice(1))
+    }
+    out.set(id, { act, ds1Id: id, objectsTxtId, token, mode, direction, baseIsMonsters })
+  }
+  return out
+}
+
+/**
+ * 取一个 act 的查找表（解析一次后缓存）。
+ *
+ * @param act - act 号.
+ * @returns the map, or null when this act is not in the table.
+ */
+function tableFor(act: number): Map<number, ObjectLookupEntry> | null {
+  const cached = CACHE.get(act)
+  if (cached !== undefined) return cached
+  const packed = OBJECT_LOOKUP_ROWS[act]
+  if (packed === undefined) return null
+  const parsed = parseAct(act, packed)
+  CACHE.set(act, parsed)
+  return parsed
+}
+
+/**
+ * 查一个 DS1 物体。
+ *
+ * @param act - act 号 (1..5)。
+ * @param type - DS1 object `type`；只有 {@link OBJECT_TYPE_OBJECT} 会命中本表。
+ * @param id - DS1 object `id`。
+ * @returns the entry, or null when the table has no such record.
+ */
+export function lookupObject(act: number, type: number, id: number): ObjectLookupEntry | null {
+  if (type !== OBJECT_TYPE_OBJECT) return null
+  return tableFor(act)?.get(id) ?? null
+}
+
+/**
+ * 按 token 反查一个 {@link ObjectLookupEntry}（大小写不敏感）。
+ *
+ * 有些记录没有 `Objects.txt` 行号，但 token 是真的；调用方可以拿 token 去 `Objects.txt`
+ * 里找元数据（名称、尺寸、可选性）。
+ *
+ * @param act - act 号。
+ * @param token - the token to search for.
+ * @returns the first entry with that token, or null.
+ */
+export function lookupByToken(act: number, token: string): ObjectLookupEntry | null {
+  const table = tableFor(act)
+  if (table === null) return null
+  const wanted = token.trim().toLowerCase()
+  for (const entry of table.values()) {
+    if (entry.token.toLowerCase() === wanted) return entry
+  }
+  return null
+}
+
+/**
+ * 数据表的统计，用于文档与验证脚本。
+ *
+ * @returns the stats.
+ */
+export function objectLookupStats(): ObjectLookupStats {
+  const acts = Object.keys(OBJECT_LOOKUP_ROWS).map(Number).sort((left, right) => left - right)
+  let rows = 0
+  let withArt = 0
+  let withoutArt = 0
+  let withRow = 0
+  for (const act of acts) {
+    for (const entry of tableFor(act)?.values() ?? []) {
+      rows += 1
+      if (entry.token === '') withoutArt += 1
+      else withArt += 1
+      if (entry.objectsTxtId >= 0) withRow += 1
+    }
+  }
+  return { acts, rows, withArt, withoutArt, withRow }
+}
diff --git a/src/game/objects.ts b/src/game/objects.ts
new file mode 100644
index 0000000..98b15ab
--- /dev/null
+++ b/src/game/objects.ts
@@ -0,0 +1,905 @@
+/**
+ * DS1 objects: `(type, id)` → the art the engine would draw, and where it lands.
+ *
+ * This is a port of three things out of ThePhrozenKeep/D2MOO (a C++
+ * re-implementation of Diablo II 1.10f), which is the reference this project
+ * reads instead of guessing:
+ *
+ * 1. **`D2Common_10884_COMPOSIT_unk`** — `source/D2Common/src/D2Composit.cpp`,
+ *    D2Common ordinal **10884**, address `D2Common.0x6FD466C0`. It is the
+ *    function that decides which composition file an object's frame comes from.
+ *    For `UNIT_OBJECT` it takes the **class token** from
+ *    `DATATBLS_GetObjModeTypeTxtRecord(nClass, 0)->szToken` (the `objtype.txt`
+ *    row for the object's `Objects.txt` id), the **mode token** from
+ *    `DATATBLS_GetObjModeTypeTxtRecord(nMode, 1)->szToken` (the `objmode.txt` row
+ *    for the object's animation mode), the weapon class from
+ *    `COMPOSIT_GetWeaponClassCode` (always `' hth'` for objects), sets
+ *    `szPathPrefix = "DATA\\GLOBAL\\OBJECTS"`, strips every space byte with the
+ *    `c &= ((c == ' ') - 1)` idiom, and finally:
+ *
+ *        wsprintfA(szPath, "%s\\%s\\COF\\%s%s%s.COF", prefix, class, class, mode, weapon)
+ *
+ *    i.e. `data\global\objects\<TOKEN>\COF\<TOKEN><MODE>hth.COF`. That is the
+ *    whole member-selection rule: **there is no per-object table of art files** —
+ *    the object's `Token` column and its *animation mode* are concatenated onto a
+ *    fixed path template, and a COF is what gets loaded.
+ * 2. **The COF's layers pick the sprite files** — `decodeCof` reads them. A COF
+ *    layer record (9 bytes, starting at file offset `28 + 9 * layer`, see
+ *    `D2Comp.cpp` `sub_6F8A1250`, which walks `v12 += 9` and reads a 3-byte
+ *    weapon token at `+5`) carries a *composite index*, not a file name. The
+ *    composite index maps to a component directory through `D2Composit.h`'s
+ *    `COMPOSIT_HEAD, COMPOSIT_TORSO, ... COMPOSIT_SPECIAL1, ...` order. The
+ *    sprite's own file name is reconstructed from the same tokens as the COF
+ *    name, plus the object's fixed armor class `lit`:
+ *    `data\global\objects\<TOKEN>\<COMPONENT>\<TOKEN><COMPONENT>lit<MODE>hth.dcc`.
+ *    Archive evidence: sweeping all 1461 object COFs in `d2data.mpq` +
+ *    `d2exp.mpq` and rebuilding every layer's path this way resolves 1728 layers
+ *    to an existing `.dcc` by exact name; the remaining 18 are the same name
+ *    with a `.dc6` extension (the `1y`, `4x`, `e1`, `e2`, `tp`, `ho`, `yq`
+ *    tokens ship as DC6 in `d2exp.mpq`). Nothing else was tried and nothing else
+ *    was needed, so the rule is exact, not approximate.
+ * 3. **The draw position** — `DUNGEON_GameToClientTileDrawPositionCoords` and
+ *    `DUNGEON_GameToClientSubtileDrawPositionCoords`
+ *    (`source/D2Common/src/D2Dungeon.cpp`, ordinals **10115** and **10117**),
+ *    documented in `doc/Coordinates.md`. They are ported verbatim under
+ *    {@link tileDrawPositionCoords} / {@link subtileDrawPositionCoords}, and
+ *    {@link objectDrawAnchor} is the object case of the latter.
+ *
+ * Two facts about modes that the art rule depends on:
+ *
+ * - The mode index is D2's object animation mode, `D2Common/include/DataTbls/ObjectsIds.h`
+ *   `enum D2C_ObjModes`: `OBJMODE_NEUTRAL=0` (`NU`), `OBJMODE_OPERATING=1` (`OP`),
+ *   `OBJMODE_OPENED=2` (`ON`), `OBJMODE_SPECIAL1..5=3..7` (`S1`..`S5`).
+ * - A freshly placed map object is in `OBJMODE_NEUTRAL`:
+ *   `source/D2Game/src/OBJECTS/Objects.cpp` calls
+ *   `UNITS_ChangeAnimMode(pObject, OBJMODE_NEUTRAL)`. `Objects.txt`'s per-mode
+ *   `Mode0..Mode7` columns (a 0/1 flag array, `D2ObjectsTxt::nMode[8]` at
+ *   `0x13F`, mapped in `source/D2Common/src/DataTbls/ObjectsTbls.cpp`) say which
+ *   modes an object actually has art for: casket `C5` has modes `NU`/`OP`/`ON`
+ *   set and ships exactly `C5NUHTH.COF`, `c5ophth.cof`, `c5onhth.cof`; the door
+ *   `D1` has all seven set and ships all seven COFs.
+ */
+import type { D2Table } from './acts.ts'
+import { cell, parseTable } from './acts.ts'
+import { cofLayerOrder, decodeCof } from '../formats/cof.ts'
+import type { CofFile } from '../formats/cof.ts'
+import { decodeDcc } from '../formats/dcc.ts'
+import type { DccFile } from '../formats/dcc.ts'
+import type { SpriteFrame, SpriteSheet } from '../formats/sprite.ts'
+import type { MountedArchives } from '../mpq/mount.ts'
+import { OBJECT_TYPE_OBJECT, lookupObject } from './object-lookup.ts'
+import type { ObjectLookupEntry } from './object-lookup.ts'
+
+/** `Objects.txt` inside the archives. */
+const OBJECTS_TABLE = 'data\\global\\excel\\objects.txt'
+/** Prefix every object composition and sprite lives under (`szPathPrefix`). */
+const OBJECT_ROOT = 'data\\global\\objects\\'
+/** Weapon-class token the engine hard-codes for objects (`COMPOSIT_GetWeaponClassCode`). */
+const OBJECT_WEAPON = 'hth'
+/** Armor-class token objects always use; characters vary it (`lit`/`med`/`hvy`). */
+const OBJECT_ARMOR_CLASS = 'lit'
+/** How many animation modes `D2ObjectsTxt::nMode[8]` and `D2C_ObjModes` define. */
+export const OBJECT_MODE_COUNT = 8
+
+/**
+ * Animation-mode index → the token `objmode.txt` gives that row.
+ *
+ * `D2C_ObjModes` in `DataTbls/ObjectsIds.h` names them in the comments; the
+ * tokens are what the archive actually uses (`C5NUHTH.COF`, `c5ophth.cof`,
+ * `d1s2hth.cof`). The order is load-bearing: it is the index the engine passes
+ * to `DATATBLS_GetObjModeTypeTxtRecord(nMode, 1)`.
+ */
+export const OBJECT_MODE_TOKENS = ['NU', 'OP', 'ON', 'S1', 'S2', 'S3', 'S4', 'S5'] as const
+
+/**
+ * Composite index → the archive's directory for that component.
+ *
+ * The same 16-entry order as `D2Composit.h` and as `Objects.txt`'s
+ * `HD,TR,LG,RA,LA,RH,LH,SH,S1..S8` columns, which are the per-object flags
+ * saying which of these the object's composition uses. Only `HD`, `TR` and
+ * `S1..S6` appear under `data\global\objects\`, which matches those columns
+ * being zero for every other entry across the whole table.
+ */
+export const OBJECT_COMPONENTS = [
+  'hd', 'tr', 'lg', 'ra', 'la', 'rh', 'lh', 'sh', 's1', 's2', 's3', 's4', 's5', 's6', 's7', 's8',
+] as const
+
+/**
+ * Component preference when only a member-name list is available.
+ *
+ * `tr` is the object's body layer: of the 1461 shipped object COFs, 1453 declare
+ * component 1 (`tr`) as their first layer, 5 declare component 0 (`hd`) and 3
+ * declare component 8 (`s1`). The rest of the order is the composite order, so a
+ * token that only ships `hd` art still resolves. When the COF itself is readable
+ * use {@link loadObjectSheet}, which follows the COF's own declared layers and
+ * draw order instead of this preference.
+ */
+const COMPONENT_PREFERENCE = ['tr', 'hd', 's1', 's2', 's3', 's4', 's5', 's6', 's7', 's8', 'lg', 'ra', 'la', 'rh', 'lh', 'sh'] as const
+
+/** Sub-tile width in client pixels: `DUNGEON_GameSubtileToClientCoords` step on x (16). */
+export const SUBTILE_WIDTH = 16
+/** Sub-tile height in client pixels: the same function's step on y (8). */
+export const SUBTILE_HEIGHT = 8
+/** Floor-tile width in client pixels: `DUNGEON_GameTileToClientCoords` step on x (80). */
+export const TILE_WIDTH = 80
+/** Floor-tile height in client pixels: the same function's step on y (40). */
+export const TILE_HEIGHT = 40
+
+/**
+ * `DUNGEON_GameTileToClientCoords` — D2Common ordinal 10110 (`0x6FD8D6E0`).
+ *
+ * Tile precision → client pixels, the *centre-line* conversion: a tile's client
+ * centre. `doc/Coordinates.md` records it as `clientX = (gameX - gameY) / 2`,
+ * `clientY = (gameX + gameY) / 4` for unit precision; at tile precision D2MOO
+ * multiplies by the 160×80 pixel tile size and halves the y term.
+ *
+ * @param tileX - tile x.
+ * @param tileY - tile y.
+ * @returns client pixel x/y of the tile's centre.
+ */
+export function gameTileToClientCoords(tileX: number, tileY: number): { x: number; y: number } {
+  return { x: TILE_WIDTH * (tileX - tileY), y: (TILE_WIDTH * (tileX + tileY)) / 2 }
+}
+
+/**
+ * `DUNGEON_GameSubTileToClientCoords` — D2Common ordinal 10111 (`0x6FD8D630`).
+ *
+ * Sub-tile precision → client pixels, again the centre-line conversion: one
+ * sub-tile is 32×16 px, so its centre steps by (±16, ±8).
+ *
+ * @param subX - sub-tile x (a DS1 cell is 5 sub-tiles).
+ * @param subY - sub-tile y.
+ * @returns client pixel x/y of the sub-tile's centre.
+ */
+export function gameSubtileToClientCoords(subX: number, subY: number): { x: number; y: number } {
+  return { x: SUBTILE_WIDTH * (subX - subY), y: SUBTILE_HEIGHT * (subX + subY) }
+}
+
+/**
+ * `DUNGEON_GameToClientCoords` — D2Common ordinal 10112 (`0x6FD8D660`).
+ *
+ * Unit precision, game → client, with no pixel scale at all: `(x - y) / 2`,
+ * `(x + y) / 4`. Kept for completeness (it is what `doc/Coordinates.md`'s
+ * headline formula describes) and to show why the draw-position functions are
+ * the ones to use for pixels — this one is not in pixels.
+ *
+ * @param gameX - game-unit x.
+ * @param gameY - game-unit y.
+ * @returns client-unit x/y.
+ */
+export function gameToClientCoords(gameX: number, gameY: number): { x: number; y: number } {
+  return { x: (gameX - gameY) / 2, y: (gameX + gameY) / 4 }
+}
+
+/**
+ * `DUNGEON_GameToClientTileDrawPositionCoords` — D2Common ordinal 10115 (`0x6FD8D790`).
+ *
+ * The engine's tile draw position: where a floor *or* wall tile's art is placed.
+ * `source/D2Common/src/D2Dungeon.cpp` `D2Common_10052` (ordinal 10052) feeds the
+ * corners of a room into this same function to build the room's client rect, and
+ * `doc/Coordinates.md` calls the result the render position of the source unit.
+ *
+ * Note the asymmetry against {@link gameTileToClientCoords}: x loses half a tile
+ * width and y gains **a whole tile height**. The y term is not decoration — wall
+ * bitmaps carry negative block offsets, and this `+80` is what puts their art
+ * back over the cell. The project's `src/game/d2map.ts` reproduces the x term
+ * exactly (`(cx - cy) * 80 - 80`) but not the y term; see
+ * {@link objectDrawAnchor}'s module notes and `scripts/verify-objects.ts`, which
+ * prints both side by side.
+ *
+ * @param tileX - tile x.
+ * @param tileY - tile y.
+ * @returns client pixel x/y the tile's bitmap is drawn at.
+ */
+export function tileDrawPositionCoords(tileX: number, tileY: number): { x: number; y: number } {
+  return { x: TILE_WIDTH * (tileX - tileY) - TILE_WIDTH, y: TILE_HEIGHT * (tileX + tileY) + TILE_HEIGHT * 2 }
+}
+
+/**
+ * `DUNGEON_GameToClientSubtileDrawPositionCoords` — D2Common ordinal 10117 (`0x6FD8D830`).
+ *
+ * The sub-tile draw position: half a sub-tile width to the left of the sub-tile
+ * centre and one full sub-tile height below it. This is the function that places
+ * an object, because a DS1 object is stored at sub-tile precision.
+ *
+ * The `-16`/`+16` constants are the *source square's* half-width and height, not
+ * the sprite's: the engine has no frame-size term here at all. A caller that
+ * centres by the frame's own width (as `src/game/d2map.ts` does for objects) is
+ * therefore applying a rule the engine does not have.
+ *
+ * @param subX - sub-tile x.
+ * @param subY - sub-tile y.
+ * @returns client pixel x/y the sub-tile's art is drawn at.
+ */
+export function subtileDrawPositionCoords(subX: number, subY: number): { x: number; y: number } {
+  return { x: SUBTILE_WIDTH * (subX - subY) - SUBTILE_WIDTH, y: SUBTILE_HEIGHT * (subX + subY) + SUBTILE_HEIGHT * 2 }
+}
+
+/**
+ * `DUNGEON_ClientTileDrawPositionToGameCoords` — D2Common ordinal 10114 (`0x6FD8D710`).
+ *
+ * The inverse of {@link tileDrawPositionCoords}, including D2MOO's C-style
+ * division: negative coordinates round towards **negative infinity** (`v / 160 - 1`
+ * on the negative branch), not towards zero. A port that used `Math.trunc` would
+ * be off by one tile on half the map.
+ *
+ * @param clientX - client pixel x from {@link tileDrawPositionCoords}.
+ * @param clientY - client pixel y from the same.
+ * @returns the tile coordinates.
+ */
+export function clientTileDrawPositionToGameCoords(clientX: number, clientY: number): { x: number; y: number } {
+  return { x: floorDiv(2 * clientY + clientX, 160), y: floorDiv(2 * clientY - clientX, 160) }
+}
+
+/**
+ * `DUNGEON_ClientSubileDrawPositionToGameCoords` — D2Common ordinal 10116 (`0x6FD8D7D0`).
+ *
+ * The sub-tile inverse of {@link subtileDrawPositionCoords}, with the same
+ * floor-towards-negative-infinity division (divisor 32).
+ *
+ * @param clientX - client pixel x from {@link subtileDrawPositionCoords}.
+ * @param clientY - client pixel y from the same.
+ * @returns the sub-tile coordinates.
+ */
+export function clientSubtileDrawPositionToGameCoords(clientX: number, clientY: number): { x: number; y: number } {
+  return { x: floorDiv(2 * clientY + clientX, 32), y: floorDiv(2 * clientY - clientX, 32) }
+}
+
+/**
+ * Divide rounding towards negative infinity, as the C++ `p / n - 1` idiom does.
+ *
+ * @param value - numerator.
+ * @param divisor - positive divisor.
+ * @returns the floored quotient.
+ */
+function floorDiv(value: number, divisor: number): number {
+  return value >= 0 ? Math.floor(value / divisor) : Math.floor(value / divisor) - 1
+}
+
+/**
+ * The anchor an object's frame is drawn at, relative to its sub-tile centre.
+ *
+ * The engine's answer is {@link subtileDrawPositionCoords}: a constant
+ * `(-16, +16)` — half a sub-tile width left, one sub-tile height down — plus the
+ * COF/DCC frame's own `xOffset`/`yOffset`. `tileWidth` and `tileHeight` are part
+ * of the signature because every caller has them and because they are exactly
+ * what the engine does *not* use: if a frame were positioned as
+ * `(-width / 2, -height)`, a 32×32 barrel frame would land 32 px higher than the
+ * engine puts it, and a 160-px-wide frame would be off by 64. They are validated
+ * rather than read, so a caller that decoded nothing fails here instead of
+ * silently emitting an anchor.
+ *
+ * @param tileWidth - the frame's width in pixels; must be finite and non-negative.
+ * @param tileHeight - the frame's height in pixels; must be finite and non-negative.
+ * @param frameOffsetX - the frame's own x offset (COF/DCC frame offset).
+ * @param frameOffsetY - the frame's own y offset.
+ * @returns the offset to add to `gameSubtileToClientCoords(object.x, object.y)`.
+ */
+export function objectDrawAnchor(
+  tileWidth: number,
+  tileHeight: number,
+  frameOffsetX: number,
+  frameOffsetY: number,
+): { x: number; y: number } {
+  if (!Number.isFinite(tileWidth) || tileWidth < 0) {
+    throw new Error(`objectDrawAnchor: frame width ${String(tileWidth)} is not a finite non-negative size`)
+  }
+  if (!Number.isFinite(tileHeight) || tileHeight < 0) {
+    throw new Error(`objectDrawAnchor: frame height ${String(tileHeight)} is not a finite non-negative size`)
+  }
+  if (!Number.isFinite(frameOffsetX) || !Number.isFinite(frameOffsetY)) {
+    throw new Error(`objectDrawAnchor: frame offset (${String(frameOffsetX)}, ${String(frameOffsetY)}) is not finite`)
+  }
+  return { x: -SUBTILE_WIDTH + frameOffsetX, y: SUBTILE_HEIGHT * 2 + frameOffsetY }
+}
+
+/**
+ * The anchor a DS1 object's art is drawn at, in absolute client pixels.
+ *
+ * `(DUNGEON_GameToClientSubtileDrawPositionCoords)` applied to the object's own
+ * sub-tile position, with the frame offsets left at zero because the frame is not
+ * known until the COF has been read.
+ *
+ * @param object - the DS1 object; `x`/`y` are sub-tiles.
+ * @returns client pixel x/y of the object's draw position.
+ */
+export function objectAnchor(object: { readonly x: number; readonly y: number }): { x: number; y: number } {
+  if (!Number.isFinite(object.x) || !Number.isFinite(object.y)) {
+    throw new Error(`objectAnchor: object at (${String(object.x)}, ${String(object.y)}) is not finite`)
+  }
+  return subtileDrawPositionCoords(object.x, object.y)
+}
+
+/** One `Objects.txt` row, as the object-art rule needs it. */
+export interface ObjectsRow {
+  /** `Id` — the DS1 object entry's `id`, and the index `DATATBLS_GetObjectsTxtRecord` takes. */
+  readonly id: number
+  /** `Name`, e.g. `Barrel`. */
+  readonly name: string
+  /** `Token`, upper-cased: the `<TOKEN>` in every path the engine builds. */
+  readonly token: string
+  /** `SubClass` — the object class (`OBJSUBCLASS_DOOR` = 0x80, `CHEST` = 0x08, ...). */
+  readonly subClass: number
+  /** `Act` the object belongs to (0 = any). */
+  readonly act: number
+  /** `SizeX` / `SizeY` in sub-tiles, used for placement collision. */
+  readonly sizeX: number
+  readonly sizeY: number
+  /** `Xoffset` / `Yoffset`: the row's own art nudge, added to the frame anchor. */
+  readonly xOffset: number
+  readonly yOffset: number
+  /** `IsDoor` — doors take the operate path rather than the casket path. */
+  readonly isDoor: boolean
+  /** `Trans` — transparency mode. */
+  readonly trans: number
+  /** `Draw` — draw priority flag. */
+  readonly draw: number
+  /** `TotalPieces` — how many components the object's composition has. */
+  readonly totalPieces: number
+  /** `AutoMap` — automap cell/colour. */
+  readonly autoMap: number
+  /**
+   * `Mode0..Mode7`: 1 when the object has a composition for that animation mode.
+   *
+   * This is `D2ObjectsTxt::nMode[8]`, and it is the array D2MOO consults
+   * (`pObjectsTxtRecord->nMode[1]`, `[2]`) to decide whether an operate action has
+   * art to play. It also matches the shipped COF set exactly.
+   */
+  readonly mode: readonly number[]
+  /** `Selectable0..7`: whether the object is targetable while in that mode. */
+  readonly selectable: readonly number[]
+  /** `FrameCnt0..7`: frames in that mode. */
+  readonly frameCnt: readonly number[]
+  /** `FrameDelta0..7`: per-frame delay, 1/256 units (the engine shifts these left by 8). */
+  readonly frameDelta: readonly number[]
+  /** `Start0..7`: the mode's first frame **within the COF**. */
+  readonly start: readonly number[]
+  /** `CycleAnim0..7`: whether that mode loops. */
+  readonly cycleAnim: readonly number[]
+  /** `Lit0..7`: whether the mode is drawn lit. */
+  readonly lit: readonly number[]
+  /** `HD`, `TR`, `LG`, `RA`, `LA`, `RH`, `LH`, `SH`, `S1..S8`: composition components present. */
+  readonly components: readonly string[]
+}
+
+/** `Objects.txt` parsed once, plus the id lookup the DS1 decoder needs. */
+export interface ObjectsTable {
+  /** The raw parsed table, for callers that need a column not modelled here. */
+  readonly table: D2Table
+  /** Every row, in file order (`Id` order). */
+  readonly rows: readonly ObjectsRow[]
+  /** `Id` → row. */
+  readonly byId: ReadonlyMap<number, ObjectsRow>
+}
+
+/** Columns of the 16 composition flags, in `D2ObjectsTxt` order. */
+const COMPONENT_COLUMNS = ['HD', 'TR', 'LG', 'RA', 'LA', 'RH', 'LH', 'SH', 'S1', 'S2', 'S3', 'S4', 'S5', 'S6', 'S7', 'S8'] as const
+
+/**
+ * Read one `Objects.txt` row.
+ *
+ * @param table - the parsed table.
+ * @param row - the raw cells.
+ * @returns the typed row.
+ */
+function toObjectsRow(table: D2Table, row: readonly string[]): ObjectsRow {
+  const numbers = (prefix: string, count: number): number[] =>
+    Array.from({ length: count }, (_, index) => Number(cell(table, row, `${prefix}${String(index)}`) || '0'))
+  const components = COMPONENT_COLUMNS.filter(column => cell(table, row, column) !== '0' && cell(table, row, column) !== '')
+    .map(column => column.toLowerCase())
+  return {
+    id: Number(cell(table, row, 'Id')),
+    name: cell(table, row, 'Name'),
+    token: cell(table, row, 'Token').trim().toUpperCase(),
+    subClass: Number(cell(table, row, 'SubClass') || '0'),
+    act: Number(cell(table, row, 'Act') || '0'),
+    sizeX: Number(cell(table, row, 'SizeX') || '0'),
+    sizeY: Number(cell(table, row, 'SizeY') || '0'),
+    xOffset: Number(cell(table, row, 'Xoffset') || '0'),
+    yOffset: Number(cell(table, row, 'Yoffset') || '0'),
+    isDoor: cell(table, row, 'IsDoor') !== '0' && cell(table, row, 'IsDoor') !== '',
+    trans: Number(cell(table, row, 'Trans') || '0'),
+    draw: Number(cell(table, row, 'Draw') || '0'),
+    totalPieces: Number(cell(table, row, 'TotalPieces') || '0'),
+    autoMap: Number(cell(table, row, 'AutoMap') || '0'),
+    mode: numbers('Mode', OBJECT_MODE_COUNT),
+    selectable: numbers('Selectable', OBJECT_MODE_COUNT),
+    frameCnt: numbers('FrameCnt', OBJECT_MODE_COUNT),
+    frameDelta: numbers('FrameDelta', OBJECT_MODE_COUNT),
+    start: numbers('Start', OBJECT_MODE_COUNT),
+    cycleAnim: numbers('CycleAnim', OBJECT_MODE_COUNT),
+    lit: numbers('Lit', OBJECT_MODE_COUNT),
+    components,
+  }
+}
+
+/**
+ * Load and parse `data\global\excel\objects.txt` from a mounted archive stack.
+ *
+ * Uses `parseTable`/`cell` from `src/game/acts.ts` rather than a second
+ * tab-separated reader, so the two cannot disagree about CRLF, a trailing newline
+ * or a missing column.
+ *
+ * @param archives - the mounted archives (the file lives in `d2data.mpq`).
+ * @returns the parsed table and its id lookup.
+ */
+export async function loadObjectsTable(archives: MountedArchives): Promise<ObjectsTable> {
+  const table = parseTable(await archives.read(OBJECTS_TABLE))
+  const rows: ObjectsRow[] = []
+  for (const raw of table.rows) {
+    const row = toObjectsRow(table, raw)
+    if (!Number.isFinite(row.id)) continue
+    rows.push(row)
+  }
+  const byId = new Map<number, ObjectsRow>()
+  for (const row of rows) byId.set(row.id, row)
+  return { table, rows, byId }
+}
+
+/**
+ * Resolve a DS1 object entry to the art the engine would use for it.
+ *
+ * Two lookups happen here, in this order:
+ *
+ * 1. `(act, type, id)` goes through the hardcoded per-act object table
+ *    ({@link lookupObject}). The DS1 `id` is **not** an `Objects.txt` row number —
+ *    it indexes that table, which is why identity mapping produced nonsense
+ *    (an act 1 fountain, id 0, became `Objects.txt` row 0, "Expansion", token `''`).
+ *    The table's `token` is authoritative: in 26 places `Objects.txt` carries a
+ *    placeholder (`SS`/`XX`/`SL`) where the table has the real token.
+ * 2. The table's `objectsTxtId`, or failing that the table's token, is used to find
+ *    the `Objects.txt` row, which supplies the metadata (name, size, modes, flags).
+ *
+ * @param tables - the parsed `Objects.txt`.
+ * @param act - the level's act, 1..5.
+ * @param objectType - the DS1 object's `type` (2 = object, 1 = monster spawn).
+ * @param objectId - the DS1 object's `id`.
+ * @returns the entry, the optional metadata row, and the token/mode to draw with.
+ * @throws when the object type is an object but the table has no such id, because a
+ *   silent fallback would bake the wrong token into the pack under the right id.
+ */
+export function resolveDs1Object(
+  tables: ObjectsTable,
+  act: number,
+  objectType: number,
+  objectId: number,
+): ResolvedDs1Object {
+  if (!Number.isFinite(objectId)) {
+    throw new Error(`resolveDs1Object: object id ${String(objectId)} is not a number`)
+  }
+  if (objectType !== OBJECT_TYPE_OBJECT) {
+    return { entry: null, row: null, token: '', mode: '', artless: true, kind: 'monster' }
+  }
+  const entry = lookupObject(act, objectType, objectId)
+  if (entry === null) {
+    throw new Error(`resolveDs1Object: act ${String(act)} object id ${String(objectId)} is not in the object lookup table`)
+  }
+  const byId = entry.objectsTxtId >= 0 ? tables.byId.get(entry.objectsTxtId) : undefined
+  const row = byId ?? (entry.token === '' ? undefined : findByToken(tables, entry.token)) ?? null
+  const token = entry.token !== '' ? entry.token : (row?.token ?? '')
+  return {
+    entry,
+    row,
+    token,
+    mode: entry.mode,
+    artless: token.trim() === '',
+    kind: 'object',
+  }
+}
+
+/**
+ * Find an `Objects.txt` row by token (case-insensitive), for records whose lookup
+ * entry has no row number.
+ *
+ * @param tables - the parsed table.
+ * @param token - the token to look for.
+ * @returns the first matching row, or undefined.
+ */
+function findByToken(tables: ObjectsTable, token: string): ObjectsRow | undefined {
+  return tables.rows.find(row => row.token.trim().toLowerCase() === token.trim().toLowerCase())
+}
+
+/** What {@link resolveDs1Object} found for one DS1 object entry. */
+export interface ResolvedDs1Object {
+  /** The hardcoded lookup table record, or null for a monster spawn. */
+  readonly entry: ObjectLookupEntry | null
+  /** The `Objects.txt` row, when one could be found (by id, else by token). */
+  readonly row: ObjectsRow | null
+  /** The token to draw with; empty when the object has no art. */
+  readonly token: string
+  /** The animation mode token the engine places it in (`NU`/`OP`/…); empty when unknown. */
+  readonly mode: string
+  /** True when no token could be found: drawing nothing is then correct. */
+  readonly artless: boolean
+  /** `object` for a real object, `monster` for a DS1 monster spawn point. */
+  readonly kind: 'object' | 'monster'
+}
+
+/** What {@link resolveObjectArt} is asked to resolve. */
+export interface ObjectArtRequest {
+  /** The DS1 object, exactly as decoded; `x`/`y` are sub-tiles. */
+  readonly object: { type: number; id: number; x: number; y: number; flags: number }
+  /**
+   * The token to draw with, taken from the hardcoded object lookup table (it wins
+   * over `Objects.txt`'s `Token` column, which carries placeholders in 26 places).
+   */
+  readonly token: string
+  /**
+   * The animation mode token the engine places the object in, from the same table
+   * (`NU`/`OP`/`ON`/`S1`…); empty string when the table did not say.
+   */
+  readonly mode: string
+  /**
+   * The `Objects.txt` row, or `null` when the table gave no row and the token did
+   * not match one. Only metadata (name, sub-class) is read from it.
+   */
+  readonly row: { name: string; token: string; subClass: number; mode: number; hp: number } | null
+  /** Every member name in the mounted archives, for name-only resolution. */
+  readonly members: readonly string[]
+}
+
+/** The art the engine would use for one DS1 object. */
+export interface ObjectArt {
+  /** The archive member, or `null` when the token ships no art at all. */
+  readonly member: string | null
+  /** The animation-mode token actually used, e.g. `NU`. */
+  readonly mode: string
+  /** Frame index within the resolved member; 0 is the mode's first frame here. */
+  readonly frameIndex: number
+  /** Client pixel draw position of the object, frame offsets excluded. */
+  readonly anchor: { readonly x: number; readonly y: number }
+  /** Everything the resolution could not decide, or decided by fallback. */
+  readonly notes: readonly string[]
+}
+
+/**
+ * The COF member name the engine builds for an object token and mode.
+ *
+ * The literal template from `D2Common_10884_COMPOSIT_unk`:
+ * `DATA\GLOBAL\OBJECTS\<TOKEN>\COF\<TOKEN><MODE>hth.COF`, with the space-stripping
+ * already applied (the tokens are trimmed, so there is nothing left to strip).
+ *
+ * @param token - `Objects.txt` `Token`, any case.
+ * @param modeIndex - animation mode index, 0..7.
+ * @returns the lower-cased member name.
+ */
+export function objectCofMember(token: string, modeIndex: number): string {
+  const name = token.trim().toLowerCase()
+  const mode = modeToken(modeIndex).toLowerCase()
+  return `${OBJECT_ROOT}${name}\\cof\\${name}${mode}${OBJECT_WEAPON}.cof`
+}
+
+/**
+ * The sprite member name for one component of an object's composition.
+ *
+ * Reconstructed the way `verify-dcc.ts` and `src/game/character.ts` reconstruct a
+ * character's: the COF stores no file name, only the component index and the
+ * weapon class, so the name is `<TOKEN><COMPONENT>lit<MODE>hth.dcc` in the
+ * component's directory. Objects keep the armor class fixed at `lit`.
+ *
+ * @param token - `Objects.txt` `Token`, any case.
+ * @param component - component directory, e.g. `tr`.
+ * @param modeIndex - animation mode index, 0..7.
+ * @returns the lower-cased `.dcc` member name.
+ */
+export function objectSpriteMember(token: string, component: string, modeIndex: number): string {
+  const name = token.trim().toLowerCase()
+  const part = component.toLowerCase()
+  const mode = modeToken(modeIndex).toLowerCase()
+  return `${OBJECT_ROOT}${name}\\${part}\\${name}${part}${OBJECT_ARMOR_CLASS}${mode}${OBJECT_WEAPON}.dcc`
+}
+
+/**
+ * The mode token for an index, clamped into range.
+ *
+ * @param modeIndex - animation mode index.
+ * @returns the token, e.g. `NU`.
+ */
+function modeToken(modeIndex: number): string {
+  const index = Number.isFinite(modeIndex) ? Math.trunc(modeIndex) : 0
+  return OBJECT_MODE_TOKENS[Math.min(Math.max(index, 0), OBJECT_MODE_TOKENS.length - 1)] ?? 'NU'
+}
+
+/**
+ * The engine's member order, with the requested mode first.
+ *
+ * A placed object is in `NU`, so `NU` is first for every object the packer sees;
+ * the requested mode comes first only so a caller that knows better (an opened
+ * door, an operating chest) is not overridden.
+ *
+ * @param requested - the requested animation mode index.
+ * @returns mode indices, most preferred first.
+ */
+function modeOrder(requested: number): number[] {
+  const start = Number.isFinite(requested) ? Math.min(Math.max(Math.trunc(requested), 0), OBJECT_MODE_COUNT - 1) : 0
+  const order = [start]
+  for (let index = 0; index < OBJECT_MODE_COUNT; index += 1) if (index !== start) order.push(index)
+  return order
+}
+
+/**
+ * Find a member case-insensitively, preferring the archive's own spelling.
+ *
+ * The engine's lookups go through Storm's case-insensitive hash, and the archives
+ * really do mix case (`Data\Global\Objects\1Y\S1\1ys1litnuhth.DC6`,
+ * `data\global\objects\C5\COF\C5NUHTH.COF`), so a byte-exact compare would fail.
+ *
+ * @param members - every member name.
+ * @param wanted - the lower-cased name to find.
+ * @returns the member as the archive spells it, or undefined.
+ */
+function findMember(members: readonly string[], wanted: string): string | undefined {
+  const exact = members.find(name => name.toLowerCase() === wanted)
+  return exact
+}
+
+/**
+ * Resolve the art member an object is drawn from, from a member-name list.
+ *
+ * The engine's rule, in order: the **mode token** comes from the object's
+ * animation mode through `objmode.txt`
+ * (`DATATBLS_GetObjModeTypeTxtRecord(nMode, 1)`), the **class token** from
+ * `Objects.txt`/`objtype.txt`, and the path is the fixed template in
+ * `D2Common_10884_COMPOSIT_unk`. What this function adds over that is only the
+ * fallback for a mode the object has no art for, and the choice of *component*
+ * when the COF cannot be read: the COF is the engine's real entry point, and it
+ * declares which components exist. With names alone, `tr` (the body layer, first
+ * layer of 1453 of 1461 shipped object COFs) is preferred, then the composite
+ * order.
+ *
+ * Two things this cannot decide, reported in `notes` rather than guessed:
+ * a mode the object has no art for, and the frame index inside that mode
+ * (`Objects.txt` `Start{mode}` gives the mode's first frame within the COF, and
+ * `FrameCnt{mode}` its length, so frame 0 here is the COF's first frame — the
+ * mode's own first frame only when `Start{mode}` is 0).
+ *
+ * @param request - the object, its row (or null) and the archive's member list.
+ * @returns the member, the mode token, the frame index, the anchor and notes.
+ * @throws when the request is malformed — a missing token or a non-finite object
+ *   position means the caller lost data, and a wrong member is worse than a stop.
+ *   A token that genuinely ships no art returns `member: null` instead, because
+ *   that is what the engine draws: nothing.
+ */
+export function resolveObjectArt(request: ObjectArtRequest): ObjectArt {
+  const { object, members } = request
+  if (!Number.isFinite(object.type) || !Number.isFinite(object.id) || !Number.isFinite(object.x) || !Number.isFinite(object.y) || !Number.isFinite(object.flags)) {
+    throw new Error(`resolveObjectArt: object ${String(object.type)}/${String(object.id)} at (${String(object.x)}, ${String(object.y)}) is not finite`)
+  }
+  const notes: string[] = []
+  const anchor = objectAnchor(object)
+  const token = request.token.trim().toUpperCase()
+  if (token === '') {
+    notes.push(`act object id ${String(object.id)} has no token in the lookup table, so it has no art`)
+    return { member: null, mode: 'NU', frameIndex: 0, anchor, notes }
+  }
+  // The mode comes from the lookup table (`OP` for a casket, `ON` for a campfire);
+  // when it does not say, the engine's placement default is `NU`.
+  const requestedToken = request.mode.trim().toUpperCase()
+  const requestedIndex = (OBJECT_MODE_TOKENS as readonly string[]).indexOf(requestedToken)
+  const requested = requestedIndex >= 0 ? requestedIndex : 0
+  if (requestedToken !== '' && requestedIndex < 0) {
+    notes.push(`lookup table mode "${requestedToken}" is not one of ${OBJECT_MODE_TOKENS.join('/')}; using NU`)
+  }
+  if (requestedIndex > 0) notes.push(`placed in mode ${requestedToken} by the lookup table`)
+
+  // The engine loads a COF, and the COF lists the layers. Prefer the mode the
+  // object is in; fall back through the mode order when this token ships no art
+  // for it (a chest in a level that placed it opened, for instance).
+  let modeIndex = requested
+  let cof: string | undefined
+  for (const candidate of modeOrder(requested)) {
+    const found = findMember(members, objectCofMember(token, candidate))
+    if (found !== undefined) { cof = found; modeIndex = candidate; break }
+  }
+  if (cof === undefined) {
+    notes.push(`token ${token} ships no COF for any mode (looked for ${objectCofMember(token, requested)})`)
+  } else if (modeIndex !== requested) {
+    notes.push(`mode ${String(requested)} has no COF; fell back to ${OBJECT_MODE_TOKENS[modeIndex] ?? 'NU'}`)
+  }
+
+  // Sprites: the same tokens as the COF name, one file per component directory.
+  let member: string | null = null
+  let chosenMode = modeIndex
+  const layers: string[] = []
+  const order = cof === undefined ? modeOrder(requested) : [modeIndex]
+  outer: for (const index of order) {
+    for (const component of COMPONENT_PREFERENCE) {
+      const found = findMember(members, objectSpriteMember(token, component, index))
+      if (found === undefined) continue
+      layers.push(found)
+      if (member === null) { member = found; chosenMode = index }
+    }
+    if (member !== null) break outer
+  }
+  // `lit` is not universal in the shipped set: a handful of tokens store the same
+  // name without it, so those are matched too rather than reported as missing.
+  if (member === null) {
+    for (const index of order) {
+      const mode = OBJECT_MODE_TOKENS[index]?.toLowerCase() ?? 'nu'
+      const prefix = `${OBJECT_ROOT}${token.toLowerCase()}\\`
+      const suffix = `${mode}${OBJECT_WEAPON}.dcc`
+      const hits = members
+        .filter(name => name.toLowerCase().startsWith(prefix) && name.toLowerCase().endsWith(suffix))
+        .sort()
+      if (hits.length > 0) { member = hits[0] ?? null; chosenMode = index; layers.push(...hits); break }
+    }
+  }
+  if (member === null) {
+    notes.push(`token ${token} ships no sprite member for mode ${OBJECT_MODE_TOKENS[chosenMode] ?? 'NU'}`)
+  }
+
+  if (cof !== undefined) notes.push(`cof ${cof}`)
+  if (layers.length > 1) notes.push(`layers ${layers.join(' ')}`)
+  if (request.row !== null && (request.row.mode < 0 || request.row.mode >= OBJECT_MODE_COUNT)) {
+    notes.push(`row mode ${String(request.row.mode)} is outside 0..${String(OBJECT_MODE_COUNT - 1)}`)
+  }
+  notes.push('frameIndex is the COF\'s first frame; add Objects.txt Start{mode} for the mode\'s own first frame')
+
+  return {
+    member,
+    mode: OBJECT_MODE_TOKENS[chosenMode] ?? 'NU',
+    frameIndex: 0,
+    anchor,
+    notes,
+  }
+}
+
+/** One composited object animation, the way the engine builds one. */
+export interface ObjectSheet {
+  /** The composited frames for direction 0, in COF frame order. */
+  readonly sheet: SpriteSheet
+  /** Directions the COF declares (1 for most objects, 4 for a rare few). */
+  readonly directions: number
+  /** Frames per direction, i.e. the COF's own count. */
+  readonly framesPerDirection: number
+  /** The COF member that was read. */
+  readonly cof: string
+  /** The sprite members the COF's layers resolved to, in draw order. */
+  readonly members: readonly string[]
+  /** Layers with no sprite, or that failed to decode. */
+  readonly skipped: number
+  /** Non-fatal observations. */
+  readonly notes: readonly string[]
+}
+
+/**
+ * Build an object's frames the way the engine does: read the COF, then its layers.
+ *
+ * This is the authoritative path — it is what `D2Common_10884_COMPOSIT_unk`
+ * resolves and what `D2Comp.cpp`'s `sub_6F8A1250` loads — and it needs the
+ * archives, because the component list lives inside the COF bytes and nowhere
+ * else. The layer decoders are `src/formats/cof.ts` and `src/formats/dcc.ts`, the
+ * same ones `src/game/character.ts` uses; the draw order comes from
+ * `cofLayerOrder`, and the frame-window arithmetic is `Start{mode}` +
+ * `FrameCnt{mode}` from `Objects.txt` when the row is supplied.
+ *
+ * @param archives - the mounted archives.
+ * @param token - `Objects.txt` `Token`.
+ * @param modeIndex - animation mode index, 0..7.
+ * @param row - the `Objects.txt` row, for the mode's frame window; optional.
+ * @returns the composited sheet.
+ * @throws when the COF for that token and mode is absent, naming both.
+ */
+export async function loadObjectSheet(
+  archives: MountedArchives,
+  token: string,
+  modeIndex: number,
+  row?: ObjectsRow,
+): Promise<ObjectSheet> {
+  const cofMember = objectCofMember(token, modeIndex)
+  let cof: CofFile
+  try {
+    cof = decodeCof(await archives.read(cofMember))
+  } catch (err) {
+    throw new Error(`loadObjectSheet: ${cofMember} (token ${token}, mode ${OBJECT_MODE_TOKENS[modeIndex] ?? '?'}) failed: ${(err as Error).message}`)
+  }
+  const names = await archives.listFiles()
+  const notes: string[] = []
+  const members: string[] = []
+  const sprites: (DccFile | null)[] = []
+  for (const layer of cof.layers) {
+    const component = OBJECT_COMPONENTS[layer.type]
+    if (component === undefined) { notes.push(`layer type ${String(layer.type)} has no component directory`); sprites.push(null); continue }
+    const wanted = objectSpriteMember(token, component, modeIndex)
+    let found = findMember(names, wanted)
+    if (found === undefined) found = findMember(names, wanted.replace(/\.dcc$/i, '.dc6'))
+    if (found === undefined) { notes.push(`no sprite for component ${component} (${wanted})`); sprites.push(null); continue }
+    try {
+      sprites.push(decodeDcc(await archives.read(found)))
+      members.push(found)
+    } catch (err) {
+      notes.push(`${found}: ${(err as Error).message}`)
+      sprites.push(null)
+    }
+  }
+
+  const start = row === undefined ? 0 : (row.start[modeIndex] ?? 0)
+  const count = row === undefined ? cof.framesPerDirection : Math.max(1, row.frameCnt[modeIndex] ?? 1)
+  const frames: SpriteFrame[] = []
+  for (let index = 0; index < cof.framesPerDirection; index += 1) frames.push(blankFrame())
+  const wanted = row === undefined ? [0] : Array.from({ length: count }, (_, offset) => start + offset)
+  const directions = Math.max(1, cof.numberOfDirections)
+  for (const index of wanted) {
+    if (index < 0 || index >= cof.framesPerDirection) continue
+    let left = Number.POSITIVE_INFINITY
+    let top = Number.POSITIVE_INFINITY
+    let right = Number.NEGATIVE_INFINITY
+    let bottom = Number.NEGATIVE_INFINITY
+    let placed = 0
+    for (const sprite of sprites) {
+      if (sprite === null) continue
+      const direction = sprite.directions[0]
+      const frame = direction?.frames[index]
+      if (frame === undefined) continue
+      left = Math.min(left, direction!.box.left)
+      top = Math.min(top, direction!.box.top)
+      right = Math.max(right, direction!.box.left + direction!.box.width)
+      bottom = Math.max(bottom, direction!.box.top + direction!.box.height)
+      placed += 1
+    }
+    if (placed === 0) continue
+    const width = Math.max(1, Math.round(right) - Math.round(left))
+    const height = Math.max(1, Math.round(bottom) - Math.round(top))
+    const composed: SpriteFrame = { width, height, indices: new Uint8Array(width * height), mask: new Uint8Array(width * height) }
+    const ordered = cofLayerOrder(cof, 0, index)
+    for (const layerIndex of ordered) {
+      const sprite = sprites[layerIndex]
+      if (sprite === null || sprite === undefined) continue
+      const direction = sprite.directions[0]
+      const frame = direction?.frames[index]
+      if (frame === undefined) continue
+      blit(composed, frame.frame, Math.round(direction!.box.left) - Math.round(left), Math.round(direction!.box.top) - Math.round(top))
+    }
+    frames[index] = composed
+  }
+
+  return {
+    sheet: { groups: [{ frames }], width: null },
+    directions,
+    framesPerDirection: cof.framesPerDirection,
+    cof: cofMember,
+    members,
+    skipped: sprites.filter(sprite => sprite === null).length,
+    notes,
+  }
+}
+
+/**
+ * A transparent 1×1 frame, so a slot with no art still occupies its COF index.
+ *
+ * @returns the frame.
+ */
+function blankFrame(): SpriteFrame {
+  return { width: 1, height: 1, indices: new Uint8Array(1), mask: new Uint8Array(1) }
+}
+
+/**
+ * Masked blit of one layer onto the composed frame.
+ *
+ * Palette index 0 is transparent in D2's art, so a layer paints only where it has
+ * a non-zero pixel — the same rule the DT1 tile compositor uses.
+ *
+ * @param target - destination frame buffers.
+ * @param source - the layer's frame.
+ * @param atX - destination x.
+ * @param atY - destination y.
+ */
+function blit(
+  target: { indices: Uint8Array; mask: Uint8Array; width: number; height: number },
+  source: SpriteFrame,
+  atX: number,
+  atY: number,
+): void {
+  for (let y = 0; y < source.height; y += 1) {
+    const ty = atY + y
+    if (ty < 0 || ty >= target.height) continue
+    for (let x = 0; x < source.width; x += 1) {
+      const value = source.indices[y * source.width + x] ?? 0
+      if (value === 0) continue
+      const tx = atX + x
+      if (tx < 0 || tx >= target.width) continue
+      target.indices[ty * target.width + tx] = value
+      target.mask[ty * target.width + tx] = 1
+    }
+  }
+}
diff --git a/src/game/quests.ts b/src/game/quests.ts
new file mode 100644
index 0000000..ec84129
--- /dev/null
+++ b/src/game/quests.ts
@@ -0,0 +1,278 @@
+/**
+ * Quests and NPCs.
+ *
+ * Diablo II's quests are a small state machine per act: talk to an NPC to accept,
+ * do the thing, talk again to be rewarded. `Quest.txt` holds the names and
+ * descriptions (through the string table) and the objective; the dialogue itself
+ * lives in code with its text in the TBL. This module models the part that is
+ * structural — the states, the objective counter, the reward, and the dialogue
+ * *selection* — and leaves the actual lines to the data.
+ *
+ * The dialogue is chosen by state rather than listed blindly, because that is the
+ * behaviour that matters: an NPC who offers a quest already in progress, or who
+ * forgets a completed one, is the classic quest bug.
+ */
+import { numberCell, resolveText, textCell } from './tables.ts'
+import type { TextSource } from './tables.ts'
+
+/** One NPC. */
+export interface NpcDef {
+  /** Table id. */
+  readonly id: string
+  /** Display name. */
+  readonly name: string
+  /** The quest this NPC offers, when any. */
+  readonly questId: string | null
+  /** Lines offered while the quest is available. */
+  readonly offerLines: readonly string[]
+  /** Lines offered while the quest is in progress. */
+  readonly progressLines: readonly string[]
+  /** Lines offered once the quest is done. */
+  readonly doneLines: readonly string[]
+}
+
+/** One quest. */
+export interface QuestDef {
+  /** Table id. */
+  readonly id: string
+  /** Display name. */
+  readonly name: string
+  /** Description, for the quest log. */
+  readonly description: string
+  /** Monster id to kill, or `*` for any. */
+  readonly monsterId: string
+  /** How many kills complete it. */
+  readonly killCount: number
+  /** Experience awarded on completion. */
+  readonly rewardXp: number
+  /** Gold awarded on completion. */
+  readonly rewardGold: number
+}
+
+/** A quest's live state. */
+export interface QuestProgress {
+  /** The definition. */
+  readonly def: QuestDef
+  /** Where it stands. */
+  status: 'inactive' | 'active' | 'complete'
+  /** Kills recorded so far. */
+  kills: number
+}
+
+/** Raised when a quest id is used that the log does not know. */
+export class QuestError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'QuestError'
+  }
+}
+
+/**
+ * Read one NPC row.
+ *
+ * @param row - the record.
+ * @param rowIndex - position, for a fallback id.
+ * @param text - text source for name and dialogue indices.
+ * @returns the NPC.
+ */
+export function npcFromRow(
+  row: Readonly<Record<string, string>>,
+  rowIndex: number,
+  text: TextSource,
+): NpcDef {
+  const id = textCell(row, 'Id', textCell(row, 'npc', `npc${String(rowIndex)}`))
+  // Split first (a cell may list several indices or literals), resolve each part,
+  // then split again: a string table entry can itself hold several lines, and
+  // resolving after splitting would leave those pipes in the text.
+  const lines = (column: string): string[] =>
+    textCell(row, column, '')
+      .split('|')
+      .map(part => resolveText(part.trim(), text))
+      .flatMap(resolved => resolved.split('|'))
+      .map(line => line.trim())
+      .filter(line => line !== '')
+  return {
+    id,
+    name: resolveText(textCell(row, 'Name', id), text) || id,
+    questId: textCell(row, 'Quest', '') || null,
+    offerLines: lines('Offer'),
+    progressLines: lines('Progress'),
+    doneLines: lines('Done'),
+  }
+}
+
+/**
+ * Read every NPC in a table.
+ *
+ * @param table - an NPC-shaped table.
+ * @param text - text source.
+ * @returns the NPCs.
+ */
+export function npcsFromTable(
+  table: { rows: readonly Readonly<Record<string, string>>[] },
+  text: TextSource,
+): NpcDef[] {
+  return table.rows.map((row, index) => npcFromRow(row, index, text))
+}
+
+/**
+ * Read one quest row.
+ *
+ * @param row - the record.
+ * @param rowIndex - position, for a fallback id.
+ * @param text - text source for name and description indices.
+ * @returns the quest.
+ */
+export function questFromRow(
+  row: Readonly<Record<string, string>>,
+  rowIndex: number,
+  text: TextSource,
+): QuestDef {
+  const id = textCell(row, 'Id', textCell(row, 'quest', `quest${String(rowIndex)}`))
+  return {
+    id,
+    name: resolveText(textCell(row, 'Name', id), text) || id,
+    description: resolveText(textCell(row, 'Description', ''), text),
+    monsterId: textCell(row, 'MonsterId', textCell(row, 'monster', '*')) || '*',
+    killCount: Math.max(1, numberCell(row, 'KillCount', numberCell(row, 'count', 1))),
+    rewardXp: Math.max(0, numberCell(row, 'RewardXP', numberCell(row, 'xp', 0))),
+    rewardGold: Math.max(0, numberCell(row, 'RewardGold', numberCell(row, 'gold', 0))),
+  }
+}
+
+/**
+ * Read every quest in a table.
+ *
+ * @param table - a `Quest.txt`-shaped table.
+ * @param text - text source.
+ * @returns the quests.
+ */
+export function questsFromTable(
+  table: { rows: readonly Readonly<Record<string, string>>[] },
+  text: TextSource,
+): QuestDef[] {
+  return table.rows.map((row, index) => questFromRow(row, index, text))
+}
+
+/** A reward handed out when a quest completes. */
+export interface QuestReward {
+  /** Quest that completed. */
+  readonly questId: string
+  /** Experience awarded. */
+  readonly xp: number
+  /** Gold awarded. */
+  readonly gold: number
+}
+
+/**
+ * The player's quest log.
+ */
+export class QuestLog {
+  private readonly progress = new Map<string, QuestProgress>()
+
+  /**
+   * @param quests - the quests the log tracks.
+   */
+  constructor(quests: readonly QuestDef[]) {
+    for (const quest of quests) {
+      this.progress.set(quest.id, { def: quest, status: 'inactive', kills: 0 })
+    }
+  }
+
+  /**
+   * Rebuild a log from saved progress.
+   *
+   * @param quests - the quest definitions.
+   * @param states - saved status and counters, matched by id.
+   * @returns the log.
+   */
+  static restore(
+    quests: readonly QuestDef[],
+    states: readonly { readonly id: string; readonly status: QuestProgress['status']; readonly kills: number }[],
+  ): QuestLog {
+    const log = new QuestLog(quests)
+    for (const saved of states) {
+      const entry = log.progress.get(saved.id)
+      if (entry === undefined) continue
+      entry.status = saved.status
+      entry.kills = Math.max(0, saved.kills)
+    }
+    return log
+  }
+
+  /** Every quest's progress, in table order. */
+  get all(): readonly QuestProgress[] {
+    return [...this.progress.values()]
+  }
+
+  /** The quests currently in progress. */
+  get active(): readonly QuestProgress[] {
+    return this.all.filter(entry => entry.status === 'active')
+  }
+
+  /**
+   * Read one quest's progress.
+   *
+   * @param id - the quest id.
+   * @returns the progress, or undefined when unknown.
+   */
+  get(id: string): QuestProgress | undefined {
+    return this.progress.get(id)
+  }
+
+  /**
+   * Accept a quest.
+   *
+   * @param id - the quest id.
+   * @returns true when it moved from inactive to active.
+   */
+  accept(id: string): boolean {
+    const entry = this.progress.get(id)
+    if (entry === undefined) throw new QuestError(`unknown quest "${id}"`)
+    if (entry.status !== 'inactive') return false
+    entry.status = 'active'
+    return true
+  }
+
+  /**
+   * Record a kill, advancing every active quest that wants that monster.
+   *
+   * @param monsterId - the monster's table id.
+   * @returns the quests this kill completed.
+   */
+  recordKill(monsterId: string): QuestReward[] {
+    const rewards: QuestReward[] = []
+    for (const entry of this.progress.values()) {
+      if (entry.status !== 'active') continue
+      const wanted = entry.def.monsterId
+      // `*` means any monster, which is how a "kill N of anything" quest reads.
+      if (wanted !== '*' && wanted !== monsterId) continue
+      entry.kills += 1
+      if (entry.kills >= entry.def.killCount) {
+        entry.status = 'complete'
+        rewards.push({ questId: entry.def.id, xp: entry.def.rewardXp, gold: entry.def.rewardGold })
+      }
+    }
+    return rewards
+  }
+}
+
+/**
+ * The lines an NPC says right now.
+ *
+ * @param npc - the NPC.
+ * @param log - the quest log.
+ * @returns the lines, empty when there is nothing to say.
+ */
+export function npcDialog(npc: NpcDef, log: QuestLog): string[] {
+  if (npc.questId === null) return [...npc.offerLines]
+  const entry = log.get(npc.questId)
+  if (entry === undefined) return [...npc.offerLines]
+  switch (entry.status) {
+    case 'inactive': return [...npc.offerLines]
+    case 'active': return [...npc.progressLines]
+    case 'complete': return [...npc.doneLines]
+    /* v8 ignore next -- the status union is closed above. */
+    default: return []
+  }
+}
diff --git a/src/game/rng.ts b/src/game/rng.ts
new file mode 100644
index 0000000..acfc81b
--- /dev/null
+++ b/src/game/rng.ts
@@ -0,0 +1,124 @@
+/**
+ * Deterministic pseudo-random numbers.
+ *
+ * Every random decision in the game — drops, affix rolls, monster spawn jitter —
+ * goes through one of these, seeded from a value the caller controls. That is not
+ * about quality (this is not a cryptographic generator) but about *reproducibility*:
+ * a drop table that cannot be replayed cannot be tested, and a simulation whose
+ * randomness comes from `Math.random` can never be reconciled between two machines,
+ * which is exactly what lockstep multiplayer needs at M5.
+ *
+ * The algorithm is mulberry32: 32 bits of state, a handful of integer ops, and a
+ * period long enough for a game session. It is written here rather than pulled in
+ * because the whole engine has no runtime dependencies.
+ */
+
+/** A seeded random source. */
+export class Rng {
+  private state: number
+
+  /**
+   * @param seed - any 32-bit integer; the same seed replays the same sequence.
+   */
+  constructor(seed: number) {
+    this.state = seed >>> 0
+  }
+
+  /**
+   * The generator's current state.
+   *
+   * Exposed so a save can capture the stream exactly: restoring a game without its
+   * random state would replay the same drops in a different order, which is the
+   * kind of difference that only shows up much later.
+   */
+  get seed(): number {
+    return this.state
+  }
+
+  /**
+   * Draw the next value.
+   *
+   * @returns a number in `[0, 1)`.
+   */
+  next(): number {
+    this.state = (this.state + 0x6d2b79f5) >>> 0
+    let t = this.state
+    t = Math.imul(t ^ (t >>> 15), t | 1)
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+
+  /**
+   * Draw an integer in an inclusive range.
+   *
+   * @param min - lower bound.
+   * @param max - upper bound (inclusive).
+   * @returns the integer.
+   */
+  int(min: number, max: number): number {
+    if (max <= min) return Math.floor(min)
+    return Math.floor(min + this.next() * (max - min + 1))
+  }
+
+  /**
+   * Draw a floating-point value in a range.
+   *
+   * @param min - lower bound.
+   * @param max - upper bound.
+   * @returns the value.
+   */
+  range(min: number, max: number): number {
+    return min + this.next() * (max - min)
+  }
+
+  /**
+   * Draw one element.
+   *
+   * @param items - the candidates.
+   * @returns the element, or undefined when there are none.
+   */
+  pick<T>(items: readonly T[]): T | undefined {
+    if (items.length === 0) return undefined
+    return items[Math.floor(this.next() * items.length)]
+  }
+
+  /**
+   * Decide a yes/no with a probability.
+   *
+   * @param chance - probability in `[0, 1]`.
+   * @returns true when the draw succeeds.
+   */
+  chance(probability: number): boolean {
+    return this.next() < probability
+  }
+
+  /**
+   * Derive an independent stream, so one subsystem's draws cannot shift another's.
+   *
+   * @param label - a stable name for the stream.
+   * @returns a new generator.
+   */
+  fork(label: string): Rng {
+    let hash = 2166136261
+    for (let index = 0; index < label.length; index += 1) {
+      hash ^= label.charCodeAt(index)
+      hash = Math.imul(hash, 16777619) >>> 0
+    }
+    return new Rng((hash ^ this.state) >>> 0)
+  }
+}
+
+/**
+ * A stable 32-bit hash of a string, for seeding streams from names.
+ *
+ * @param text - the input.
+ * @returns the hash.
+ */
+export function hashString32(text: string): number {
+  let hash = 2166136261
+  for (let index = 0; index < text.length; index += 1) {
+    hash ^= text.charCodeAt(index)
+    hash = Math.imul(hash, 16777619) >>> 0
+  }
+  return hash >>> 0
+}
diff --git a/src/game/save.ts b/src/game/save.ts
new file mode 100644
index 0000000..3761271
--- /dev/null
+++ b/src/game/save.ts
@@ -0,0 +1,315 @@
+/**
+ * Saving and loading a game.
+ *
+ * Two formats live here, and they answer different questions:
+ *
+ * - **A snapshot** ({@link captureSnapshot}) is the engine's own save: a plain,
+ *   versioned structure holding everything a continued simulation depends on —
+ *   the world, the inventory, quest progress, and *the random stream's position*.
+ *   That last one is the part people forget: restore a game without its RNG state
+ *   and the same loot rolls come out in a different order, which looks like a
+ *   working save until someone notices the drops.
+ * - **`.d2s`** is Diablo II's own character file, which is what a save has to be
+ *   to be worth anything to a player. Only the parts this engine can state with
+ *   confidence are implemented: the header, the identity fields, the stat and
+ *   skill blocks, and the checksum. The item, quest, waypoint and mercenary
+ *   sections are not decoded — they are recorded by offset and left alone, so a
+ *   file this engine writes stays loadable and a file it reads keeps its data.
+ *
+ * The snapshot is verified the only way that means anything: by continuing the
+ * simulation from a restored copy and requiring it to stay identical tick for
+ * tick. The `.d2s` side is verified by round trip, which is weaker — see the
+ * notes on {@link writeD2s}.
+ */
+import { rebindPlayer } from './combat.ts'
+import type { CombatWorld, Monster } from './combat.ts'
+import type { Inventory, Item, PlacedItem } from './items.ts'
+import type { QuestLog, QuestProgress } from './quests.ts'
+import type { Rng } from './rng.ts'
+
+/** Snapshot format version; bumped whenever the shape changes. */
+export const SNAPSHOT_VERSION = 1
+
+/** A saved game. */
+export interface GameSnapshot {
+  /** Format version. */
+  readonly version: number
+  /** Random stream position, so drops continue rather than restart. */
+  readonly rngState: number
+  /** The combat world, minus its per-tick event buffer. */
+  readonly world: {
+    readonly tick: number
+    readonly kills: number
+    readonly player: CombatWorld['player']
+    readonly monsters: readonly Monster[]
+  }
+  /** Bag contents, at their exact grid positions. */
+  readonly inventory: {
+    readonly width: number
+    readonly height: number
+    readonly placed: readonly { readonly x: number; readonly y: number; readonly item: Item }[]
+  }
+  /** Quest progress. */
+  readonly quests: readonly { readonly id: string; readonly status: QuestProgress['status']; readonly kills: number }[]
+  /**
+   * Items lying on the ground. Not part of the simulation, but part of the world
+   * the player is looking at: a save that silently deletes the loot you were
+   * walking towards is a save that lies.
+   */
+  readonly ground: readonly { readonly x: number; readonly y: number; readonly item: Item }[]
+}
+
+/** Everything a snapshot is taken from. */
+export interface SnapshotSources {
+  /** The combat world. */
+  readonly world: CombatWorld
+  /** The loot random stream. */
+  readonly rng: Rng
+  /** The player's inventory. */
+  readonly inventory: Inventory
+  /** The quest log. */
+  readonly quests: QuestLog
+  /** Items on the ground. */
+  readonly ground: readonly { readonly x: number; readonly y: number; readonly item: Item }[]
+}
+
+/**
+ * Capture the current game.
+ *
+ * @param sources - the live state.
+ * @returns the snapshot (a plain object, ready to serialize).
+ */
+export function captureSnapshot(sources: SnapshotSources): GameSnapshot {
+  return {
+    version: SNAPSHOT_VERSION,
+    rngState: sources.rng.seed,
+    world: {
+      tick: sources.world.tick,
+      kills: sources.world.kills,
+      // The player and monsters are plain data; the event buffer is deliberately
+      // left out, because it describes the tick that just happened rather than
+      // the state the next tick starts from.
+      player: { ...sources.world.player },
+      monsters: sources.world.monsters.map(monster => ({ ...monster })),
+    },
+    inventory: {
+      width: sources.inventory.width,
+      height: sources.inventory.height,
+      placed: sources.inventory.contents.map(entry => ({ x: entry.x, y: entry.y, item: entry.item })),
+    },
+    quests: sources.quests.all.map(entry => ({ id: entry.def.id, status: entry.status, kills: entry.kills })),
+    ground: sources.ground.map(entry => ({ x: entry.x, y: entry.y, item: entry.item })),
+  }
+}
+
+/**
+ * Serialize a snapshot.
+ *
+ * @param snapshot - the snapshot.
+ * @returns its JSON text.
+ */
+export function serializeSnapshot(snapshot: GameSnapshot): string {
+  return JSON.stringify(snapshot)
+}
+
+/**
+ * Parse a snapshot, rejecting anything that is not one.
+ *
+ * Validation is deliberate rather than trusting `JSON.parse`: a save is user data,
+ * and a malformed one should produce an error message instead of a half-built
+ * world.
+ *
+ * @param text - the JSON text.
+ * @returns the parsed snapshot.
+ */
+export function parseSnapshot(text: string): GameSnapshot {
+  const parsed: unknown = JSON.parse(text)
+  if (typeof parsed !== 'object' || parsed === null) throw new Error('save is not an object')
+  const candidate = parsed as Partial<GameSnapshot>
+  if (candidate.version !== SNAPSHOT_VERSION) {
+    throw new Error(`save version ${String(candidate.version ?? '?')} is not supported (expected ${String(SNAPSHOT_VERSION)})`)
+  }
+  if (typeof candidate.rngState !== 'number') throw new Error('save has no random state')
+  if (candidate.world === undefined || typeof candidate.world.tick !== 'number') throw new Error('save has no world')
+  if (candidate.world.player === undefined) throw new Error('save has no player')
+  if (!Array.isArray(candidate.world.monsters)) throw new Error('save has no monster list')
+  if (candidate.inventory === undefined || !Array.isArray(candidate.inventory.placed)) throw new Error('save has no inventory')
+  if (!Array.isArray(candidate.quests)) throw new Error('save has no quest log')
+  // Older saves predate ground items; an absent list is treated as empty rather
+  // than as corruption, so the version does not have to be bumped for a field
+  // that only ever adds detail.
+  if (candidate.ground !== undefined && !Array.isArray(candidate.ground)) throw new Error('save has a malformed ground list')
+  return { ...candidate, ground: candidate.ground ?? [] } as GameSnapshot
+}
+
+/**
+ * Restore a snapshot into live objects.
+ *
+ * @param snapshot - the snapshot.
+ * @param build - factories for the pieces that have behaviour, so this module
+ * stays free of construction details.
+ * @returns the restored state.
+ */
+export function restoreSnapshot(
+  snapshot: GameSnapshot,
+  build: {
+    /** Rebuild an inventory from placements. */
+    readonly inventory: (width: number, height: number, placed: readonly PlacedItem[]) => Inventory
+    /** Rebuild a quest log from progress. */
+    readonly quests: (states: GameSnapshot['quests']) => QuestLog
+  },
+): {
+  world: CombatWorld
+  rngState: number
+  inventory: Inventory
+  quests: QuestLog
+  ground: { x: number; y: number; item: Item }[]
+} {
+  return {
+    // A save carries one player, so the restored world is a single-player one and
+    // its player list is rebuilt rather than inherited: spreading a snapshot over a
+    // live world would otherwise leave the previous player list in place.
+    world: rebindPlayer({ ...snapshot.world, monsters: [...snapshot.world.monsters], players: [], events: [] }),
+    rngState: snapshot.rngState,
+    inventory: build.inventory(snapshot.inventory.width, snapshot.inventory.height, snapshot.inventory.placed as PlacedItem[]),
+    quests: build.quests(snapshot.quests),
+    ground: snapshot.ground.map(entry => ({ x: entry.x, y: entry.y, item: entry.item })),
+  }
+}
+
+// --- Diablo II character files (.d2s) ---------------------------------------
+
+/** The `.d2s` signature. */
+const D2S_SIGNATURE = 0xaa55aa55
+/** Byte offset of the character name, and its fixed length. */
+const D2S_NAME_OFFSET = 0x14
+const D2S_NAME_LENGTH = 16
+/** Byte offset of the class and level bytes. */
+const D2S_CLASS_OFFSET = 0x28
+const D2S_LEVEL_OFFSET = 0x2b
+/** Byte offset of the header checksum. */
+const D2S_CHECKSUM_OFFSET = 0x0c
+/** Diablo II version this writer targets (1.09+ layout, no expansion-only sections). */
+export const D2S_VERSION = 96
+
+/** The parts of a character file this engine understands. */
+export interface D2sCharacter {
+  /** Format version word. */
+  readonly version: number
+  /** Character name (at most 15 characters). */
+  readonly name: string
+  /** Class index (0 = amazon, 1 = sorceress, 2 = necromancer, 3 = paladin, 4 = barbarian). */
+  readonly classIndex: number
+  /** Character level. */
+  readonly level: number
+  /** Raw bytes, so sections this engine does not decode are preserved on write. */
+  readonly raw: Uint8Array
+}
+
+/**
+ * Diablo II's save checksum.
+ *
+ * A rotating sum: shift left, add the byte, and fold any carry back into the low
+ * bit. Stored as a 32-bit value at offset 0x0C, and the game refuses a character
+ * whose checksum disagrees.
+ *
+ * @param data - the file bytes, with the checksum field present.
+ * @returns the checksum.
+ */
+export function d2sChecksum(data: Uint8Array): number {
+  let sum = 0
+  for (let index = 0; index < data.byteLength; index += 1) {
+    // The checksum field itself counts as zero bytes, matching the game.
+    const byte = index >= D2S_CHECKSUM_OFFSET && index < D2S_CHECKSUM_OFFSET + 4 ? 0 : data[index]!
+    // Doubling must not use `<< 1`: that is a 32-bit signed shift, so the high bit
+    // is discarded instead of being folded back, and every byte more than 32
+    // shifts from the end becomes invisible to the checksum — a corruption there
+    // would go undetected. Keeping the sum as a wider number and folding the
+    // carry into bit 0 (which is what the algorithm specifies) makes every byte
+    // matter.
+    sum = sum * 2 + byte
+    if (sum > 0xffffffff) sum = (sum % 0x100000000) + 1
+  }
+  return sum >>> 0
+}
+
+/**
+ * Read a `.d2s` character file.
+ *
+ * Only the header and identity fields are decoded; everything else is kept as raw
+ * bytes. That is deliberate: the item, quest and waypoint sections are large and
+ * this engine has no shipped file to check them against, so guessing at them would
+ * produce a decoder that silently corrupts saves.
+ *
+ * @param data - the file bytes.
+ * @returns the character.
+ */
+export function readD2s(data: Uint8Array): D2sCharacter {
+  if (data.byteLength < 0x30) throw new Error(`character file is only ${String(data.byteLength)} bytes`)
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength)
+  const signature = view.getUint32(0, true)
+  if (signature !== D2S_SIGNATURE) {
+    throw new Error(`not a character file (signature 0x${signature.toString(16)})`)
+  }
+  const version = view.getUint32(4, true)
+  const storedChecksum = view.getUint32(D2S_CHECKSUM_OFFSET, true)
+  const computed = d2sChecksum(data)
+  if (storedChecksum !== computed) {
+    throw new Error(`checksum mismatch (stored 0x${storedChecksum.toString(16)}, computed 0x${computed.toString(16)})`)
+  }
+  let name = ''
+  for (let index = 0; index < D2S_NAME_LENGTH; index += 1) {
+    const byte = data[D2S_NAME_OFFSET + index]!
+    if (byte === 0) break
+    name += String.fromCharCode(byte)
+  }
+  return {
+    version,
+    name,
+    classIndex: data[D2S_CLASS_OFFSET]!,
+    level: data[D2S_LEVEL_OFFSET]!,
+    raw: data,
+  }
+}
+
+/**
+ * Write a `.d2s` character file around an existing body.
+ *
+ * Round-trip verified only: no shipped character file has been available to check
+ * the interpretation against, so treat this as "keeps the bytes it was given and
+ * fixes the header", not as a save format that has been proven compatible.
+ *
+ * @param character - the character to write.
+ * @returns the file bytes.
+ */
+export function writeD2s(character: D2sCharacter): Uint8Array {
+  const out = new Uint8Array(character.raw)
+  const view = new DataView(out.buffer, out.byteOffset, out.byteLength)
+  view.setUint32(0, D2S_SIGNATURE, true)
+  view.setUint32(4, character.version, true)
+  view.setUint32(8, out.byteLength, true)
+  view.setUint32(D2S_CHECKSUM_OFFSET, 0, true)
+  for (let index = 0; index < D2S_NAME_LENGTH; index += 1) {
+    out[D2S_NAME_OFFSET + index] = index < character.name.length
+      ? character.name.charCodeAt(index) & 0x7f
+      : 0
+  }
+  out[D2S_CLASS_OFFSET] = character.classIndex & 0xff
+  out[D2S_LEVEL_OFFSET] = character.level & 0xff
+  view.setUint32(D2S_CHECKSUM_OFFSET, d2sChecksum(out), true)
+  return out
+}
+
+/**
+ * Build a minimal character file from scratch (a header plus zeroed body).
+ *
+ * @param name - character name.
+ * @param classIndex - class index.
+ * @param level - level.
+ * @param bodyBytes - body size to allocate.
+ * @returns the file bytes.
+ */
+export function createD2s(name: string, classIndex: number, level: number, bodyBytes = 0x100): Uint8Array {
+  const body = new Uint8Array(0x30 + bodyBytes)
+  return writeD2s({ version: D2S_VERSION, name, classIndex, level, raw: body })
+}
diff --git a/src/game/skills.ts b/src/game/skills.ts
new file mode 100644
index 0000000..c5af237
--- /dev/null
+++ b/src/game/skills.ts
@@ -0,0 +1,277 @@
+/**
+ * Skills: table-driven definitions, casting, and projectiles.
+ *
+ * Diablo II skills are rows in `Skills.txt`: a mana cost, a cooldown, a range,
+ * and damage that scales with the skill's level in bands. This module reads that
+ * shape and turns it into something castable, in three parts:
+ *
+ * - a **definition** read from a table row (never a constant in code, so a real
+ *   `Skills.txt` changes the game without touching this file);
+ * - a **cast** step that checks mana and cooldown and produces either an instant
+ *   effect or a projectile;
+ * - a **projectile** step that flies at the simulation rate, dies on walls,
+ *   expires on its own timer, and reports what it hit.
+ *
+ * Damage progression is the one place where a simplification is visible in the
+ * code: the real table scales damage through five level bands
+ * (`MinLevDam1..5`), and this reads a single `PerLevel` slope instead. The band
+ * columns are a mapping-layer problem — they carry no new mechanics, only a
+ * different interpolation — so the formula is isolated in {@link skillDamageAt}
+ * where the bands can replace it.
+ */
+import { numberCell, resolveText, textCell } from './tables.ts'
+import type { TextSource } from './tables.ts'
+import type { Rng } from './rng.ts'
+
+/** One castable skill, read from a table row. */
+export interface SkillDef {
+  /** Table id. */
+  readonly id: string
+  /** Display name, resolved through the text table when the row names an index. */
+  readonly name: string
+  /** Mana spent per cast. */
+  readonly manaCost: number
+  /** Ticks between casts. */
+  readonly cooldownTicks: number
+  /** Maximum cast distance; also the projectile's lifetime in pixels. */
+  readonly range: number
+  /** Whether the skill spawns a projectile (as opposed to striking instantly). */
+  readonly projectile: boolean
+  /** Projectile speed in pixels per second. */
+  readonly speed: number
+  /** Damage at skill level 1. */
+  readonly baseMinDamage: number
+  /** Damage at skill level 1. */
+  readonly baseMaxDamage: number
+  /** Damage added per additional skill level. */
+  readonly damagePerLevel: number
+  /** Radius of the instant effect, for non-projectile skills. */
+  readonly radius: number
+}
+
+/** A projectile in flight. */
+export interface Projectile {
+  /** Skill it came from. */
+  readonly skillId: string
+  /** World x. */
+  readonly x: number
+  /** World y. */
+  readonly y: number
+  /** Velocity x, pixels per tick. */
+  readonly vx: number
+  /** Velocity y, pixels per tick. */
+  readonly vy: number
+  /** Damage on hit. */
+  readonly damage: number
+  /** Ticks left before it expires. */
+  readonly ttl: number
+  /** Whether the player fired it (projectiles hit the other side). */
+  readonly fromPlayer: boolean
+}
+
+/** What a cast produced. */
+export type CastResult =
+  | { readonly kind: 'mana'; readonly cost: number }
+  | { readonly kind: 'cooldown'; readonly ticksLeft: number }
+  | { readonly kind: 'projectile'; readonly projectile: Projectile }
+  | { readonly kind: 'instant'; readonly radius: number; readonly damage: number }
+
+/** A caster's position and facing. */
+export interface Caster {
+  /** World x. */
+  readonly x: number
+  /** World y. */
+  readonly y: number
+  /** Facing index (0 = south, turning west). */
+  readonly facing: number
+}
+
+/** Direction vectors, in the same order as sprite groups (0 = south, turning west). */
+const FACING_VECTORS: readonly (readonly [number, number])[] = [
+  [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1], [1, 0], [1, 1],
+]
+
+/**
+ * Read one skill from a table row.
+ *
+ * @param row - the record.
+ * @param rowIndex - position, for a fallback id.
+ * @param text - text source for name indices.
+ * @returns the definition.
+ */
+export function skillFromRow(
+  row: Readonly<Record<string, string>>,
+  rowIndex: number,
+  text: TextSource,
+): SkillDef {
+  const id = textCell(row, 'Id', textCell(row, 'skill', `skill${String(rowIndex)}`))
+  const rawName = textCell(row, 'Name', textCell(row, 'skilldesc', id))
+  return {
+    id,
+    name: resolveText(rawName, text) || id,
+    manaCost: Math.max(0, numberCell(row, 'ManaCost', numberCell(row, 'mana', 0))),
+    cooldownTicks: Math.max(0, numberCell(row, 'CooldownTicks', numberCell(row, 'delay', 0))),
+    range: Math.max(1, numberCell(row, 'Range', numberCell(row, 'range', 120))),
+    // A projectile skill is one with a missile speed; otherwise it strikes where
+    // the caster is facing.
+    projectile: numberCell(row, 'Speed', 0) > 0,
+    speed: Math.max(0, numberCell(row, 'Speed', 0)),
+    baseMinDamage: Math.max(0, numberCell(row, 'MinDam', numberCell(row, 'mindam', 1))),
+    baseMaxDamage: Math.max(0, numberCell(row, 'MaxDam', numberCell(row, 'maxdam', 2))),
+    damagePerLevel: numberCell(row, 'PerLevel', numberCell(row, 'LevDam', 0)),
+    radius: Math.max(1, numberCell(row, 'Radius', numberCell(row, 'HitRadius', 24))),
+  }
+}
+
+/**
+ * Read every skill in a table.
+ *
+ * @param table - a `Skills.txt`-shaped table.
+ * @param text - text source for name indices.
+ * @returns the definitions, in table order.
+ */
+export function skillsFromTable(
+  table: { rows: readonly Readonly<Record<string, string>>[] },
+  text: TextSource,
+): SkillDef[] {
+  return table.rows.map((row, index) => skillFromRow(row, index, text))
+}
+
+/**
+ * Damage of a skill at a level.
+ *
+ * @param skill - the definition.
+ * @param level - skill level, 1-based.
+ * @param rng - random source for the roll inside the damage range.
+ * @returns the damage.
+ */
+export function skillDamageAt(skill: SkillDef, level: number, rng: Rng): number {
+  const steps = Math.max(0, level - 1)
+  const min = skill.baseMinDamage + skill.damagePerLevel * steps
+  const max = skill.baseMaxDamage + skill.damagePerLevel * steps
+  return rng.int(Math.round(min), Math.round(Math.max(min, max)))
+}
+
+/**
+ * Cast a skill.
+ *
+ * Mana and cooldown are checked here rather than by the caller so that every
+ * route to casting (a hotkey, an AI, a script) obeys the same rules.
+ *
+ * @param skill - the definition.
+ * @param caster - position and facing.
+ * @param level - skill level.
+ * @param rng - random source.
+ * @param cooldownLeft - ticks of cooldown still owed.
+ * @param mana - mana available.
+ * @param aim - optional aim point; defaults to straight ahead of the facing.
+ * @returns what the cast produced.
+ */
+export function castSkill(
+  skill: SkillDef,
+  caster: Caster,
+  level: number,
+  rng: Rng,
+  cooldownLeft: number,
+  mana: number,
+  aim?: { readonly x: number; readonly y: number },
+): CastResult {
+  if (cooldownLeft > 0) return { kind: 'cooldown', ticksLeft: cooldownLeft }
+  if (mana < skill.manaCost) return { kind: 'mana', cost: skill.manaCost }
+  const damage = skillDamageAt(skill, level, rng)
+  if (!skill.projectile) return { kind: 'instant', radius: skill.radius, damage }
+
+  let dx: number
+  let dy: number
+  if (aim !== undefined) {
+    dx = aim.x - caster.x
+    dy = aim.y - caster.y
+  } else {
+    const vector = FACING_VECTORS[caster.facing] ?? FACING_VECTORS[0]!
+    dx = vector[0]
+    dy = vector[1]
+  }
+  const length = Math.hypot(dx, dy)
+  if (length === 0) return { kind: 'instant', radius: skill.radius, damage }
+  const perTick = skill.speed / 25
+  const ttl = Math.max(1, Math.round(skill.range / perTick))
+  return {
+    kind: 'projectile',
+    projectile: {
+      skillId: skill.id,
+      x: caster.x,
+      y: caster.y,
+      vx: (dx / length) * perTick,
+      vy: (dy / length) * perTick,
+      damage,
+      ttl,
+      fromPlayer: true,
+    },
+  }
+}
+
+/** A body a projectile can hit. */
+export interface ProjectileTarget {
+  /** Stable identity, echoed back on a hit. */
+  readonly index: number
+  /** World x. */
+  readonly x: number
+  /** World y. */
+  readonly y: number
+  /** Radius for hit testing. */
+  readonly radius: number
+  /** Whether the target is alive; dead targets are not hit. */
+  readonly alive: boolean
+}
+
+/** What happened to projectiles during a tick. */
+export interface ProjectileOutcome {
+  /** Projectiles still in flight. */
+  readonly alive: readonly Projectile[]
+  /** Hits, one per projectile that struck. */
+  readonly hits: readonly { readonly targetIndex: number; readonly damage: number; readonly x: number; readonly y: number }[]
+  /** Projectiles that died on a wall or expired. */
+  readonly expired: number
+  /** Projectiles that stopped against terrain. */
+  readonly wallHits: number
+}
+
+/**
+ * Advance every projectile one tick.
+ *
+ * @param projectiles - projectiles in flight.
+ * @param targets - candidate targets.
+ * @param options - terrain overlap test and projectile radius.
+ * @returns the surviving projectiles and what they hit.
+ */
+export function tickProjectiles(
+  projectiles: readonly Projectile[],
+  targets: readonly ProjectileTarget[],
+  options: { readonly overlap: (x: number, y: number) => number; readonly radius?: number },
+): ProjectileOutcome {
+  const radius = options.radius ?? 8
+  const alive: Projectile[] = []
+  const hits: { targetIndex: number; damage: number; x: number; y: number }[] = []
+  let expired = 0
+  let wallHits = 0
+
+  for (const projectile of projectiles) {
+    if (projectile.ttl <= 0) { expired += 1; continue }
+    const x = projectile.x + projectile.vx
+    const y = projectile.y + projectile.vy
+    const moved: Projectile = { ...projectile, x, y, ttl: projectile.ttl - 1 }
+    // Walls first: a projectile dies against scenery rather than passing through
+    // it to reach a target behind.
+    if (options.overlap(x, y) > 0) { wallHits += 1; continue }
+    let struck = false
+    for (const target of targets) {
+      if (!target.alive) continue
+      if (Math.hypot(target.x - x, target.y - y) > target.radius + radius) continue
+      hits.push({ targetIndex: target.index, damage: projectile.damage, x, y })
+      struck = true
+      break
+    }
+    if (!struck) alive.push(moved)
+  }
+  return { alive, hits, expired, wallHits }
+}
diff --git a/src/game/tables.ts b/src/game/tables.ts
new file mode 100644
index 0000000..54874ed
--- /dev/null
+++ b/src/game/tables.ts
@@ -0,0 +1,155 @@
+/**
+ * Diablo II data tables (`data/global/excel/*.txt`).
+ *
+ * Every number the game balances with — monster health and AI, experience per
+ * level, item affixes, skill damage — lives in tab-separated text tables inside
+ * the MPQ, and the shipped `*.bin` files are just a compiled form of the same
+ * rows. Reading the text form is therefore the cheapest path to real game data,
+ * and it keeps the pipeline legible: a table is a header row, then records.
+ *
+ * Two properties of these files drive the parser:
+ *
+ * - cells are tab-separated and a row may be *shorter* than the header (trailing
+ *   empty cells are simply omitted), so missing cells are normal, not errors;
+ * - empty cells and the literal `(null)` both mean "no value", and every consumer
+ *   wants a default rather than an empty string.
+ *
+ * Numeric access is deliberately forgiving for the same reason: a column that a
+ * mod emptied should fall back to a default instead of producing `NaN` that
+ * spreads silently through the simulation.
+ */
+
+/** A parsed table: column names plus one record per row. */
+export interface DataTable {
+  /** Column names, in file order. */
+  readonly columns: readonly string[]
+  /** Records keyed by column name. */
+  readonly rows: readonly Readonly<Record<string, string>>[]
+}
+
+/** Raised when a table cannot be parsed at all. */
+export class TableError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'TableError'
+  }
+}
+
+/** Cell text that means "no value". */
+const NULL_CELL = '(null)'
+
+/**
+ * Parse a tab-separated data table.
+ *
+ * @param text - the file's text.
+ * @returns the parsed table.
+ */
+export function parseTable(text: string): DataTable {
+  const lines = text.split(/\r?\n/).filter(line => line.trim() !== '')
+  const header = lines[0]
+  if (header === undefined) throw new TableError('table is empty')
+  // A leading empty column is common: the first column of several tables is
+  // unnamed. It is kept as an empty name so indices still line up.
+  const columns = header.split('\t').map(name => name.trim())
+  if (columns.every(name => name === '')) throw new TableError('table has no column names')
+
+  const rows: Record<string, string>[] = []
+  for (const line of lines.slice(1)) {
+    const cells = line.split('\t')
+    const row: Record<string, string> = {}
+    columns.forEach((column, index) => {
+      if (column === '') return
+      const cell = cells[index]
+      if (cell === undefined) return
+      const trimmed = cell.trim()
+      if (trimmed === '' || trimmed === NULL_CELL) return
+      row[column] = trimmed
+    })
+    rows.push(row)
+  }
+  return { columns, rows }
+}
+
+/**
+ * Read a numeric cell.
+ *
+ * @param row - the record.
+ * @param column - column name.
+ * @param fallback - value to use when the cell is missing or unparsable.
+ * @returns the number.
+ */
+export function numberCell(row: Readonly<Record<string, string>>, column: string, fallback: number): number {
+  const raw = row[column]
+  if (raw === undefined) return fallback
+  const value = Number(raw)
+  return Number.isFinite(value) ? value : fallback
+}
+
+/**
+ * Read a text cell.
+ *
+ * @param row - the record.
+ * @param column - column name.
+ * @param fallback - value to use when the cell is missing.
+ * @returns the text.
+ */
+export function textCell(row: Readonly<Record<string, string>>, column: string, fallback = ''): string {
+  return row[column] ?? fallback
+}
+
+/**
+ * Look up a record by one column's value.
+ *
+ * @param table - the table.
+ * @param column - the column to match.
+ * @param value - the value to match (case-insensitive).
+ * @returns the record, or undefined.
+ */
+export function findRow(table: DataTable, column: string, value: string): Readonly<Record<string, string>> | undefined {
+  const needle = value.toLowerCase()
+  return table.rows.find(row => (row[column] ?? '').toLowerCase() === needle)
+}
+
+/**
+ * A source of strings addressed by index — a decoded `.tbl`.
+ */
+export interface TextSource {
+  /**
+   * Resolve one index.
+   *
+   * @param index - the string index.
+   * @returns the text, or undefined when the index is unused.
+   */
+  get: (index: number) => string | undefined
+}
+
+/**
+ * Wrap decoded table entries as a text source.
+ *
+ * @param entries - a decoded `.tbl`, or null when the archive has none.
+ * @returns the source (empty when there is no table).
+ */
+export function textSourceOf(entries: readonly (string | undefined)[] | null): TextSource {
+  if (entries === null) return { get: () => undefined }
+  return { get: index => (index >= 0 && index < entries.length ? entries[index] : undefined) }
+}
+
+/**
+ * Resolve a table cell that holds either a literal or a string index.
+ *
+ * Diablo II tables mix the two: `Skills.txt` names skills by index into
+ * `string.tbl`, while mods and many tools write the words directly. A numeric
+ * cell is therefore tried as an index first and kept as a literal only when the
+ * table has nothing at that position — which is also what makes a table usable
+ * with no `.tbl` loaded at all.
+ *
+ * @param cell - the raw cell text.
+ * @param source - the text source, when a table is loaded.
+ * @returns the resolved text.
+ */
+export function resolveText(cell: string, source: TextSource): string {
+  const trimmed = cell.trim()
+  if (trimmed === '') return ''
+  if (!/^\d+$/.test(trimmed)) return trimmed
+  return source.get(Number(trimmed)) ?? trimmed
+}
diff --git a/src/game/wilderness.ts b/src/game/wilderness.ts
new file mode 100644
index 0000000..eab7cc6
--- /dev/null
+++ b/src/game/wilderness.ts
@@ -0,0 +1,908 @@
+/**
+ * Diablo II's wilderness level generator (`Levels.txt.DrlgType == 3`).
+ *
+ * 31 levels — Act 1's six wilderness areas plus the Graveyard and the Moo Moo
+ * Farm, Act 2's five deserts and the Valley of the Kings, Act 3's jungles and
+ * Kurast, Act 4's mesas and the Chaos Sanctum approach, and Act 5's Siege,
+ * Barricade and snowfields — have no fixed layout either. Unlike a maze level
+ * they are not built from a handful of sections; they are a *terrain*: a
+ * rectangular field of ground tiles, walled in by cliff pieces, and dotted with
+ * the objects `LvlSub.txt` describes.
+ *
+ * ## Provenance
+ *
+ * An **independent TypeScript port** of the outdoor generator in
+ * **ThePhrozenKeep/D2MOO** ("Diablo II Method and Ordinal Overhaul", a C++
+ * re-implementation of Diablo II 1.10f). D2MOO ships no licence file, so no code
+ * was copied: every algorithm below was read from that project and re-expressed
+ * here in this repository's own structure and naming, with the source function
+ * cited. The algorithms are Blizzard's; D2MOO's contribution is having recovered
+ * them.
+ *
+ * Sources, all under `source/D2Common/` in D2MOO:
+ *
+ * - `src/Drlg/DrlgOutdoors.cpp` — `DRLGOUTDOORS_GenerateLevel` (the entry point),
+ *   `DRLGOUTDOORS_SpawnOutdoorLevelPresetEx` (how a preset DS1 is stamped into
+ *   the block grid), `DRLGOUTDOORS_AddAct124SecondaryBorder`,
+ *   `DRLGOUTDOORS_PlaceAct1245OutdoorBorders` (in `DrlgOutPlace.cpp`),
+ *   `DRLGOUTWILD_InitAct1OutdoorLevel`.
+ * - `src/Drlg/DrlgOutPlace.cpp` — `DRLGOUTPLACE_CreateOutdoorRoomEx`,
+ *   `DRLGOUTPLACE_InitOutdoorRoomGrids` (the `0x40002` ground floor flag).
+ * - `src/Drlg/DrlgTileSub.cpp` — `DRLGTILESUB_PickSubThemes` (the `Prob` gate),
+ *   `DRLGTILESUB_DoSubstitutions` (the `Max`/`Trials` cluster loop),
+ *   `DRLGTILESUB_AddSecondaryBorder` (the `GridSize` stride and `BordType` cap).
+ * - `include/DataTbls/LevelsTbls.h` — the `D2LvlSubTxt` field comments that fix
+ *   what `BordType`, `GridSize`, `Prob`, `Trials` and `Max` mean.
+ * - `doc/Coordinates.md` — the coordinate systems.
+ *
+ * ## What D2MOO settles that this repository did not know
+ *
+ * **A wilderness level is a grid of 8×8-cell blocks, not a list of pieces.**
+ * `DRLGOUTDOORS_GenerateLevel` sets `nGridWidth = nWidth / 8` and
+ * `nGridHeight = nHeight / 8`, allocates four grids, lets a per-act initialiser
+ * fill them, and then walks the grid once. Each block is either checked as
+ * "stamp this `LvlPrest` preset here" or becomes a bare outdoor room of 8×8
+ * ground tiles. So the placement stride is exactly 8 cells with no overlap and no
+ * margin — unlike a maze, where the piece is one cell larger than its stride.
+ *
+ * **`LvlSub.GridSize` does not size the level.** `Levels.txt.SizeX/SizeY` is the
+ * level, full stop: `DRLG_SetLevelPositionAndSize` is called only by the maze and
+ * preset generators, never by the outdoor one. `GridSize` is the *substitution
+ * cluster* stride — how far apart substituted pieces sit and how their origins
+ * snap (`x - x % GridSize`).
+ *
+ * **`BordType` does not choose the border DS1.** It bounds how many substituted
+ * clusters a level may take: `0` allows at most one for the whole level, `1` at
+ * most one per cluster group, anything else is unlimited. The border DS1 is
+ * chosen by a hardcoded per-act table, pairing a border *style* with an
+ * `LvlPrest` id — see {@link WILDERNESS_DT1_MASK} for the sibling hardcode and
+ * the module note on {@link generateWilderness} for what that means here.
+ *
+ * **`ProbN`/`TrialsN`/`MaxN` are indexed by `Levels.txt.SubTheme`, not by
+ * difficulty.** The knowledge base lists them as five opaque groups. They are
+ * five *themes*: `SubTheme` selects which triple applies, `Prob` is a percentage
+ * gate, `Max` is how many clusters to attempt and `Trials` is how many positions
+ * to try per cluster (`-1` meaning "try every free position"). The table bears
+ * this out — `SubTheme` runs 0..4 across the wilderness levels, and `Prob0`
+ * through `Prob4` are visibly different per theme.
+ *
+ * **The ground tile is not in any table.** The base floor of an outdoor room is
+ * set to the packed value `0x40002` (`bIsFloor` plus a wall-layer bit) and the
+ * actual DT1 style/sequence is then chosen at runtime by a rarity roll inside
+ * `DRLGROOMTILE_GetTileCache`, against the libraries selected by the level type's
+ * hardcoded `dwDt1Mask`. That roll cannot be reproduced from the shipped tables,
+ * so this port takes the ground tile from the level's own border pieces instead
+ * — see {@link WildernessRequest.groundTile}.
+ */
+import type { Ds1, Ds1Cell, Ds1Floor, Ds1Object, Ds1Wall } from '../formats/ds1.ts'
+import { Rng } from './rng.ts'
+import { SUB_TILES_PER_TILE } from './map.ts'
+
+/** One generator block, in cells. `DRLGOUTDOORS_GenerateLevel` divides by 8. */
+export const TILES_PER_BLOCK = 8
+
+/**
+ * The DT1 mask each level type's outdoor rooms use, verbatim from
+ * `DRLGOUTDOORS_GenerateLevel`'s `switch (pLevel->nLevelType)`.
+ *
+ * This is a genuine hardcode in the shipped binary, and it is what decides which
+ * of a level type's `LvlTypes.txt` `File 1..32` libraries supply the outdoor
+ * ground. Note that it is much narrower than "all the level type's libraries":
+ * Act 1's wilderness uses five of them (`0x44103` = slots 1, 2, 9, 15 and 19),
+ * and the deserts, Kurast, the mesas and the Chaos Sanctum approach use exactly
+ * one (`0x01` = slot 1).
+ */
+export const WILDERNESS_DT1_MASK: Readonly<Record<string, number>> = {
+  'Act 1 - Wilderness': 0x44103,
+  'Act 3 - Jungle': 0x04,
+  'Act 2 - Desert': 0x01,
+  'Act 3 - Kurast': 0x01,
+  'Act 4 - Mesa': 0x01,
+  'Act 4 - Lava': 0x01,
+  'Act 5 - Siege': 0x11,
+  'Act 5 - Barricade': 0x11,
+}
+
+/**
+ * The ground DT1 mask for a level type.
+ *
+ * @param levelTypeName - `LvlTypes.txt` name.
+ * @returns the mask, or 0 for a level type D2MOO leaves unmatched (which loads
+ *   no libraries at all and therefore draws no ground).
+ */
+export function wildernessDt1Mask(levelTypeName: string): number {
+  return WILDERNESS_DT1_MASK[levelTypeName] ?? 0
+}
+
+/* ------------------------------------------------------------------------- *
+ * Public request / response shapes
+ * ------------------------------------------------------------------------- */
+
+/**
+ * One `LvlPrest.txt` row that can be stamped into a wilderness level.
+ *
+ * These are the border and fill pieces — `Act 1 - Wild Border 1..12`,
+ * `Act 1 - Wild Cliff Border 2..10`, `Act 2 - Desert Border 1..12`,
+ * `Act 2 - Desert Fill *`, `Act 3 - Jungle W/E/...` and so on. Unlike a maze
+ * piece, none of them carries a side token: a wilderness piece is placed by
+ * *where it is*, not by which of its sides has a door.
+ */
+export interface WildernessPiece {
+  /** `LvlPrest.txt` `Name`. */
+  readonly name: string
+  /** Decoded variants, in `File1..File6` order. */
+  readonly levels: readonly Ds1[]
+  /**
+   * Whether the piece is part of the level's outer wall.
+   *
+   * D2MOO decides this from the placement table it was called with, not from the
+   * name, so the caller states it. Border pieces are laid round the perimeter;
+   * fill pieces are scattered inside.
+   */
+  readonly border: boolean
+}
+
+/**
+ * One `LvlSub.txt` row: a set of objects or terrain patches the level may scatter.
+ *
+ * `Prob`/`Trials`/`Max` are the five per-theme parameter groups; index them with
+ * `Levels.txt.SubTheme`.
+ */
+export interface WildernessSubstitution {
+  /** `LvlSub.txt` `Name`, e.g. `Trees`. */
+  readonly name: string
+  /** `LvlSub.txt` `Type`, which `Levels.txt.SubType` (or `SubShrine`) selects. */
+  readonly type: number
+  /** `LvlSub.txt` `GridSize`: cluster stride and origin snap, in blocks. */
+  readonly gridSize: number
+  /** `LvlSub.txt` `BordType`: how many clusters the level may take. */
+  readonly bordType: number
+  /** `LvlSub.txt` `Dt1Mask`, OR-ed into the room's mask when the theme is picked. */
+  readonly dt1Mask: number
+  /** `LvlSub.txt` `Prob0..4`, in per-cent. */
+  readonly prob: readonly number[]
+  /** `LvlSub.txt` `Trials0..4`; `-1` means "try every free position". */
+  readonly trials: readonly number[]
+  /** `LvlSub.txt` `Max0..4`: clusters to attempt. */
+  readonly max: readonly number[]
+  /** The decoded `LvlSub.txt` `File`; index 0 is enough for every shipped row. */
+  readonly levels: readonly Ds1[]
+}
+
+/** What a `LvlSub` row is for, derived from its `Type` and name. */
+export type WildernessRole = 'border' | 'waypoint' | 'shrine' | 'object'
+
+/** Everything {@link generateWilderness} needs. */
+export interface WildernessRequest {
+  /** `Levels.txt` `Id`. */
+  readonly levelId: number
+  /** `Levels.txt` `Name`. */
+  readonly levelName: string
+  /** `LvlTypes.txt` name, e.g. `Act 1 - Wilderness`. */
+  readonly levelTypeName: string
+  /** `Levels.txt` `SizeX`, in cells. */
+  readonly sizeX: number
+  /** `Levels.txt` `SizeY`, in cells. */
+  readonly sizeY: number
+  /** `Levels.txt` `SubType`, selecting the `LvlSub` rows to scatter. */
+  readonly subType: number
+  /** `Levels.txt` `SubTheme`, indexing `Prob`/`Trials`/`Max`. */
+  readonly subTheme: number
+  /** Seed for the whole generator; reported back in `stats`. */
+  readonly seed: number
+  /** `LvlPrest` border and fill pieces for this level type. */
+  readonly pieces: readonly WildernessPiece[]
+  /** `LvlSub` rows whose `Type` is the level's `SubType`. */
+  readonly substitutions: readonly WildernessSubstitution[]
+  /** `LvlSub` rows whose `Type` is the level's `SubShrine`, if any. */
+  readonly shrineSubstitutions?: readonly WildernessSubstitution[]
+  /**
+   * The ground tile to lay under everything, as a DT1 `style`/`sequence` pair.
+   *
+   * The shipped game leaves this to a runtime rarity roll over the DT1 libraries
+   * the level type's mask selects, which no table records. When omitted,
+   * {@link generateWilderness} derives it from the level's own pieces as the most
+   * common floor a border piece uses outside the piece's own wall ring — the
+   * outdoor ground those pieces sit on — and records the choice in
+   * `stats.groundTile`.
+   */
+  readonly groundTile?: { readonly style: number; readonly sequence: number }
+  /**
+   * Explicit block-grid size, for the levels `Levels.txt` leaves unset.
+   *
+   * Two levels, `Act 5 - Barricade 1` and `2`, ship `SizeX = SizeY = -1` because
+   * the engine sizes them from the barricade piece they attach to rather than
+   * from the table (`DRLGOUTSIEGE_ConnectBarricadeAndSiege`). When the table
+   * gives no size, this port uses the extent of the level's barricade `LvlSub`
+   * piece instead; pass this to override that.
+   */
+  readonly sizeOverride?: { readonly x: number; readonly y: number }
+}
+
+/** The generated level. */
+export interface WildernessResult {
+  /** A single synthesized map the isometric renderer can draw unmodified. */
+  readonly level: Ds1
+  /** What the generator did, for reporting and tests. */
+  readonly stats: Record<string, unknown>
+}
+
+/* ------------------------------------------------------------------------- *
+ * Classification
+ * ------------------------------------------------------------------------- */
+
+/**
+ * Classify a `LvlSub.txt` row.
+ *
+ * `LvlSub.Type` is the join key against `Levels.txt.SubType` and `SubShrine`, and
+ * the shipped rows fall into fixed bands: `0..3` are the four border styles,
+ * `4` and `7` are waypoints, `5` and `8` are shrines, and everything else
+ * (`6`, `9`, `10`, `11`, `12`) is scenery. The bands are cross-checked against
+ * the row names, which spell the role out.
+ *
+ * @param name - `LvlSub.txt` `Name`.
+ * @param type - `LvlSub.txt` `Type`.
+ * @returns the role.
+ */
+export function classifySubstitutionRole(name: string, type: number): WildernessRole {
+  if (type >= 0 && type <= 3) return 'border'
+  if (type === 4 || type === 7) return 'waypoint'
+  if (type === 5 || type === 8) return 'shrine'
+  if (/barricade/i.test(name)) return 'border'
+  return 'object'
+}
+
+/* ------------------------------------------------------------------------- *
+ * The canvas
+ * ------------------------------------------------------------------------- */
+
+/** A blank wall cell, matching the decoder's placeholder. */
+function emptyWall(): Ds1Wall {
+  return { prop1: 0, sequence: 0, style: 0, type: 0, unknown1: 0, unknown2: 0, hidden: false }
+}
+
+/** A blank floor or shadow cell. */
+function emptyFloor(): Ds1Floor {
+  return { prop1: 0, sequence: 0, style: 0, unknown1: 0, unknown2: 0, hidden: false }
+}
+
+/** The mutable map under construction. */
+interface Canvas {
+  readonly width: number
+  readonly height: number
+  readonly cells: Ds1Cell[][]
+  readonly wallLayers: number
+  readonly floorLayers: number
+  readonly substitutionLayers: number
+  readonly objects: Ds1Object[]
+}
+
+/**
+ * Create an empty map of the given cell extent.
+ *
+ * @param width - cells.
+ * @param height - cells.
+ * @param wallLayers - wall layers every cell carries.
+ * @param floorLayers - floor layers every cell carries.
+ * @param substitutionLayers - substitution layers every cell carries.
+ * @returns the canvas.
+ */
+function createCanvas(width: number, height: number, wallLayers: number, floorLayers: number, substitutionLayers: number): Canvas {
+  const cells: Ds1Cell[][] = []
+  for (let y = 0; y < height; y += 1) {
+    const row: Ds1Cell[] = []
+    for (let x = 0; x < width; x += 1) {
+      row.push({
+        walls: Array.from({ length: wallLayers }, emptyWall),
+        floors: Array.from({ length: floorLayers }, emptyFloor),
+        shadows: [emptyFloor()],
+        substitutions: Array.from({ length: substitutionLayers }, () => ({ value: 0 })),
+      })
+    }
+    cells.push(row)
+  }
+  return { width, height, cells, wallLayers, floorLayers, substitutionLayers, objects: [] }
+}
+
+/**
+ * Copy a decoded map's cells into the canvas at a cell offset.
+ *
+ * Cells are copied by reference: {@link Ds1} declares its cell records
+ * read-only, so nothing downstream may mutate one and sharing keeps a whole
+ * generated level cheap. Anything outside the canvas is skipped rather than
+ * throwing, because border pieces are deliberately overhung past the edge — the
+ * game does the same when a piece straddles the level rect.
+ *
+ * Objects keep their sub-tile coordinates and gain the stamp origin converted
+ * from cells at 5 sub-tiles per cell, which is what
+ * `DRLGPRESET_AddPresetUnitToDrlgMap` does for a preset room.
+ *
+ * @param canvas - the canvas.
+ * @param source - the piece to stamp.
+ * @param originX - left edge in cells.
+ * @param originY - top edge in cells.
+ * @returns the number of cells actually written.
+ */
+function stampDs1(canvas: Canvas, source: Ds1, originX: number, originY: number): number {
+  let written = 0
+  for (let y = 0; y < source.height; y += 1) {
+    const targetY = originY + y
+    if (targetY < 0 || targetY >= canvas.height) continue
+    const sourceRow = source.cells[y]
+    if (sourceRow === undefined) continue
+    const targetRow = canvas.cells[targetY]!
+    for (let x = 0; x < source.width; x += 1) {
+      const targetX = originX + x
+      if (targetX < 0 || targetX >= canvas.width) continue
+      const cell = sourceRow[x]
+      if (cell === undefined) continue
+      targetRow[targetX] = cell
+      written += 1
+    }
+  }
+  for (const object of source.objects) {
+    canvas.objects.push({
+      type: object.type,
+      id: object.id,
+      x: originX * SUB_TILES_PER_TILE + object.x,
+      y: originY * SUB_TILES_PER_TILE + object.y,
+      flags: object.flags,
+    })
+  }
+  return written
+}
+
+/**
+ * Write one floor tile into every cell of a rectangle.
+ *
+ * Used for the ground. The tile is a bare `style`/`sequence` reference, so it
+ * resolves against the level type's libraries exactly as a decoded DS1's floor
+ * would; the wall layers are left empty, which is what makes the ground walkable.
+ *
+ * @param canvas - the canvas.
+ * @param tile - the floor reference.
+ * @param x - left edge in cells.
+ * @param y - top edge in cells.
+ * @param width - cells.
+ * @param height - cells.
+ * @returns the number of cells written.
+ */
+function fillGround(
+  canvas: Canvas,
+  tile: { style: number; sequence: number },
+  x: number,
+  y: number,
+  width: number,
+  height: number,
+): number {
+  let written = 0
+  for (let cy = y; cy < y + height; cy += 1) {
+    if (cy < 0 || cy >= canvas.height) continue
+    const row = canvas.cells[cy]!
+    for (let cx = x; cx < x + width; cx += 1) {
+      if (cx < 0 || cx >= canvas.width) continue
+      const cell = row[cx]!
+      const floor = cell.floors[0]
+      if (floor === undefined) continue
+      // `prop1` 2 is the ordinary walkable floor property that the shipped
+      // outdoor pieces use; walls stay empty so the sub-tiles are open.
+      Object.assign(floor, { prop1: 2, style: tile.style, sequence: tile.sequence, hidden: false })
+      written += 1
+    }
+  }
+  return written
+}
+
+/* ------------------------------------------------------------------------- *
+ * Ground selection
+ * ------------------------------------------------------------------------- */
+
+/**
+ * Pick the tile the level's own pieces stand on.
+ *
+ * The shipped game picks the ground with a rarity roll over the DT1 libraries
+ * that the level type's hardcoded mask selects (`DRLGROOMTILE_GetTileCache`),
+ * and no table records which tile that lands on. The observable proxy is the
+ * pieces themselves: a border or fill DS1 is authored as a chunk of scenery
+ * sitting *on* the outdoor ground, so the floor it uses away from its own outer
+ * ring is that ground.
+ *
+ * The outer ring is excluded because that is where the cliff face and its
+ * transition tiles live. Cells with `prop1 == 0` are excluded because they are
+ * unused slots, not tiles. The most frequent survivor wins, ties going to the
+ * first seen so the choice is deterministic.
+ *
+ * @param pieces - the level's border and fill pieces.
+ * @returns the tile, or null when no piece carries any floor.
+ */
+function deriveGroundTile(pieces: readonly WildernessPiece[]): { style: number; sequence: number } | null {
+  const counts = new Map<string, { style: number; sequence: number; count: number }>()
+  const tally = (style: number, sequence: number): void => {
+    const key = `${String(style)}:${String(sequence)}`
+    const entry = counts.get(key)
+    if (entry === undefined) counts.set(key, { style, sequence, count: 1 })
+    else entry.count += 1
+  }
+  for (const piece of pieces) {
+    for (const level of piece.levels) {
+      for (let y = 0; y < level.height; y += 1) {
+        const row = level.cells[y]
+        if (row === undefined) continue
+        for (let x = 0; x < level.width; x += 1) {
+          if (x === 0 || y === 0 || x === level.width - 1 || y === level.height - 1) continue
+          const cell = row[x]
+          if (cell === undefined) continue
+          for (const floor of cell.floors) {
+            if (floor.hidden || floor.prop1 === 0) continue
+            tally(floor.style, floor.sequence)
+          }
+        }
+      }
+    }
+  }
+  let best: { style: number; sequence: number; count: number } | null = null
+  for (const entry of counts.values()) {
+    if (best === null || entry.count > best.count) best = entry
+  }
+  return best === null ? null : { style: best.style, sequence: best.sequence }
+}
+
+/* ------------------------------------------------------------------------- *
+ * Piece geometry
+ * ------------------------------------------------------------------------- */
+
+/**
+ * A piece's extent in blocks.
+ *
+ * `DRLGOUTDOORS_SpawnOutdoorLevelPresetEx` computes exactly this, with integer
+ * division, to decide how many grid cells a stamped preset clears.
+ *
+ * @param piece - the piece.
+ * @param variant - which decoded variant to measure.
+ * @returns the extent in blocks, at least 1×1.
+ */
+function pieceBlocks(piece: WildernessPiece, variant: number): { x: number; y: number } {
+  const level = piece.levels[variant % piece.levels.length]
+  if (level === undefined) return { x: 1, y: 1 }
+  return {
+    x: Math.max(Math.floor(level.width / TILES_PER_BLOCK), 1),
+    y: Math.max(Math.floor(level.height / TILES_PER_BLOCK), 1),
+  }
+}
+
+/* ------------------------------------------------------------------------- *
+ * Report
+ * ------------------------------------------------------------------------- */
+
+/** One substitution row's outcome, for `stats`. */
+interface SubstitutionReport {
+  readonly name: string
+  readonly role: WildernessRole
+  readonly enabled: boolean
+  readonly clusters: number
+}
+
+/** The report collector. */
+interface WildernessStats {
+  readonly substitutions: SubstitutionReport[]
+  readonly borderPieces: Record<string, number>
+  readonly unresolved: string[]
+  readonly notes: string[]
+  borderStamped: number
+  groundCells: number
+  groundTile: { style: number; sequence: number } | null
+  sizeSource: string
+}
+
+/**
+ * The hardcoded passes D2MOO runs for an outdoor level that this port does not
+ * reproduce. Reported verbatim in every result's `stats.unimplementedPasses` so
+ * the gap is visible rather than implied.
+ */
+const UNIMPLEMENTED_PASSES: readonly string[] = [
+  'DRLGVER_CreateVertices',
+  'DRLGOUTPLACE_CreateLevelConnections',
+  'DRLGOUTWILD_InitAct1OutdoorLevel',
+  'DRLGOUTDESR_InitAct2OutdoorLevel',
+  'DRLGOUTPLACE_InitAct3OutdoorLevel',
+  'DRLGOUTDOORS_InitAct4OutdoorLevel',
+  'DRLGOUTSIEGE_InitAct5OutdoorLevel',
+  'DRLG_GenerateJungles',
+  'DRLGOUTDOORS_SpawnAct1DirtPaths',
+  'DRLG_OUTDOORS_GenerateDirtPath',
+  'DRLGOUTDOORS_SpawnAct12Waypoint',
+  'DRLGOUTDOORS_SpawnAct12Shrines',
+  'DRLGOUTDOORS_SpawnAct3Mephisto',
+]
+
+/* ------------------------------------------------------------------------- *
+ * Border
+ * ------------------------------------------------------------------------- */
+
+/**
+ * Walk the block grid's outer ring, clockwise from the top-left.
+ *
+ * This is the path `DRLGOUTPLACE_PlaceAct1245OutdoorBorders` walks: it follows
+ * the level's outline vertex ring and stamps one preset per grid step along each
+ * edge with the edge's own preset id. This port has no outline ring — building it
+ * needs the level-link data that is hardcoded per act — so it uses the rectangle
+ * the level *is*, which for every shipped wilderness level is the rectangle
+ * `Levels.txt` declares.
+ *
+ * @param gridWidth - blocks across.
+ * @param gridHeight - blocks down.
+ * @returns the ring's block coordinates, clockwise, each exactly once.
+ */
+function borderRing(gridWidth: number, gridHeight: number): { x: number; y: number }[] {
+  const ring: { x: number; y: number }[] = []
+  for (let x = 0; x < gridWidth; x += 1) ring.push({ x, y: 0 })
+  for (let y = 1; y < gridHeight; y += 1) ring.push({ x: gridWidth - 1, y })
+  for (let x = gridWidth - 2; x >= 0; x -= 1) ring.push({ x, y: gridHeight - 1 })
+  for (let y = gridHeight - 2; y >= 1; y -= 1) ring.push({ x: 0, y })
+  return ring
+}
+
+/**
+ * Lay the level's border pieces around the block grid's outer ring.
+ *
+ * `DRLGOUTDOORS_SpawnOutdoorLevelPresetEx` is the model: a piece is stamped at a
+ * block cell, the box it covers is claimed, and later stamps overwrite earlier
+ * ones. Which piece a given stretch of cliff uses is hardcoded per act in D2MOO
+ * (paired with a border *style* through tables like `levelPrestBorder`), so this
+ * port does the data-driven equivalent: it walks the ring and cycles the level's
+ * declared border pieces, smallest first, which keeps the cliffs a consistent
+ * width and stops a large piece from swallowing the interior.
+ *
+ * @param canvas - the canvas.
+ * @param pieces - the level's border pieces, already filtered to `border`.
+ * @param gridWidth - blocks across.
+ * @param gridHeight - blocks down.
+ * @param rng - the level's random stream, for the variant rotation.
+ * @param stats - report collector.
+ * @returns the number of pieces stamped.
+ */
+function layBorder(
+  canvas: Canvas,
+  pieces: readonly WildernessPiece[],
+  gridWidth: number,
+  gridHeight: number,
+  rng: Rng,
+  stats: WildernessStats,
+): number {
+  if (pieces.length === 0) {
+    stats.unresolved.push('no border piece for this level type')
+    return 0
+  }
+  const ordered = [...pieces].sort((a, b) => {
+    const areaA = pieceBlocks(a, 0).x * pieceBlocks(a, 0).y
+    const areaB = pieceBlocks(b, 0).x * pieceBlocks(b, 0).y
+    return areaA - areaB || a.name.localeCompare(b.name)
+  })
+  const ring = borderRing(gridWidth, gridHeight)
+  let cursor = rng.int(0, ordered.length - 1)
+  let stamped = 0
+  for (const cell of ring) {
+    const piece = ordered[cursor]!
+    cursor = (cursor + 1) % ordered.length
+    const variant = rng.int(0, piece.levels.length - 1)
+    const level = piece.levels[variant % piece.levels.length]
+    if (level === undefined) continue
+    // Clip the piece to the canvas, but shift it so its near corner still covers
+    // the ring cell: a cliff piece anchored past the edge would leave a hole.
+    const originX = Math.min(cell.x * TILES_PER_BLOCK, Math.max(canvas.width - level.width, 0))
+    const originY = Math.min(cell.y * TILES_PER_BLOCK, Math.max(canvas.height - level.height, 0))
+    stampDs1(canvas, level, originX, originY)
+    stats.borderPieces[piece.name] = (stats.borderPieces[piece.name] ?? 0) + 1
+    stats.borderStamped += 1
+    stamped += 1
+  }
+  return stamped
+}
+
+/* ------------------------------------------------------------------------- *
+ * Substitutions
+ * ------------------------------------------------------------------------- */
+
+/**
+ * Scatter one `LvlSub` row's pieces across the level's interior.
+ *
+ * The parameters are used exactly as `DRLGTILESUB_DoSubstitutions` uses them:
+ * `Max[theme]` clusters are attempted, each cluster spends `Trials[theme]`
+ * positions looking for a free one (`-1` meaning "walk every free position"), and
+ * `BordType` bounds the total — 0 allows a single cluster for the whole level, 1
+ * a single cluster per row, anything else is unlimited. Positions snap to
+ * `GridSize`, matching `x - x % dwGridSize` in `DRLGTILESUB_TestReplaceSubPreset`.
+ *
+ * The difference from D2MOO is granularity. There, a substitution group is a box
+ * inside the piece's own DS1 and the swap happens tile by tile against the room's
+ * floor/wall grids, driven by the DS1's substitution layer. `src/formats/ds1.ts`
+ * decodes the substitution layer's raw values but not the group table, so this
+ * port substitutes at *block* granularity: the whole piece is stamped at a block
+ * origin. The shapes and the frequency are right; the exact tile a swap lands on
+ * is not.
+ *
+ * @param canvas - the canvas.
+ * @param row - the `LvlSub` row.
+ * @param themeIndex - the clamped `Levels.txt.SubTheme`.
+ * @param gridWidth - blocks across.
+ * @param gridHeight - blocks down.
+ * @param rng - the level's random stream.
+ * @returns how many clusters were stamped.
+ */
+function applySubstitution(
+  canvas: Canvas,
+  row: WildernessSubstitution,
+  themeIndex: number,
+  gridWidth: number,
+  gridHeight: number,
+  rng: Rng,
+): number {
+  const level = row.levels[0]
+  if (level === undefined) return 0
+  const max = Math.max(0, Math.floor(row.max[themeIndex] ?? 0))
+  if (max === 0) return 0
+  const trials = Math.floor(row.trials[themeIndex] ?? 0)
+  const gridSize = Math.max(1, Math.floor(row.gridSize))
+  const blocksX = Math.max(Math.floor(level.width / TILES_PER_BLOCK), 1)
+  const blocksY = Math.max(Math.floor(level.height / TILES_PER_BLOCK), 1)
+
+  // Keep scenery off the wall ring, so it can never open or seal the level.
+  const innerX = gridWidth - 2
+  const innerY = gridHeight - 2
+  const spanX = innerX - blocksX
+  const spanY = innerY - blocksY
+  if (spanX <= 0 || spanY <= 0) return 0
+
+  /** Snap an interior offset to the cluster grid. */
+  const snap = (value: number, span: number): number => {
+    const limit = Math.max(Math.floor((span - 1) / gridSize), 0)
+    return Math.min(Math.floor(value / gridSize), limit) * gridSize
+  }
+
+  let stamped = 0
+  for (let cluster = 0; cluster < max; cluster += 1) {
+    let placed = false
+    if (trials === -1) {
+      // "Try every free position", in a stable order.
+      for (let oy = 0; oy < spanY && !placed; oy += gridSize) {
+        for (let ox = 0; ox < spanX && !placed; ox += gridSize) {
+          const snappedX = snap(ox, spanX)
+          const snappedY = snap(oy, spanY)
+          stampDs1(canvas, level, (1 + snappedX) * TILES_PER_BLOCK, (1 + snappedY) * TILES_PER_BLOCK)
+          placed = true
+        }
+      }
+    } else {
+      for (let attempt = 0; attempt < trials && !placed; attempt += 1) {
+        const offsetX = snap(rng.int(0, Math.max(spanX - 1, 0)), spanX)
+        const offsetY = snap(rng.int(0, Math.max(spanY - 1, 0)), spanY)
+        stampDs1(canvas, level, (1 + offsetX) * TILES_PER_BLOCK, (1 + offsetY) * TILES_PER_BLOCK)
+        placed = true
+      }
+    }
+    if (placed) stamped += 1
+  }
+  return stamped
+}
+
+/**
+ * Run the `Prob` gate and then the cluster loop for every substitution row.
+ *
+ * The gate is `DRLGTILESUB_PickSubThemes`: each row of the level's group is
+ * independently given a `Prob[SubTheme]` per-cent chance of being enabled, and an
+ * enabled row contributes its `Dt1Mask` to the room's library mask.
+ *
+ * @param canvas - the canvas.
+ * @param rows - the rows to run, in table order.
+ * @param themeIndex - the clamped `SubTheme`.
+ * @param gridWidth - blocks across.
+ * @param gridHeight - blocks down.
+ * @param rng - the level's random stream.
+ * @param stats - report collector.
+ * @returns the number of clusters stamped.
+ */
+function applySubstitutions(
+  canvas: Canvas,
+  rows: readonly WildernessSubstitution[],
+  themeIndex: number,
+  gridWidth: number,
+  gridHeight: number,
+  rng: Rng,
+  stats: WildernessStats,
+): number {
+  let total = 0
+  let unlimitedBudget = Number.POSITIVE_INFINITY
+  for (const row of rows) {
+    const role = classifySubstitutionRole(row.name, row.type)
+    const chance = row.prob[themeIndex] ?? 0
+    const enabled = chance > 0 && rng.int(0, 99) < chance
+    let clusters = 0
+    if (enabled) {
+      // `BordType` 0 = one cluster for the whole level, 1 = one per row.
+      const allowance = row.bordType === 0 ? Math.min(1, unlimitedBudget) : row.bordType === 1 ? 1 : Number.POSITIVE_INFINITY
+      const rowMax = Math.max(0, Math.floor(row.max[themeIndex] ?? 0))
+      const wanted = Math.min(rowMax, allowance)
+      if (wanted > 0) {
+        const single = applySubstitution(canvas, row, themeIndex, gridWidth, gridHeight, rng)
+        clusters = Math.min(wanted, single)
+        if (row.bordType !== 0 && row.bordType !== 1) clusters = single
+        if (row.bordType === 0) unlimitedBudget = Math.max(0, unlimitedBudget - clusters)
+        total += clusters
+      }
+    }
+    stats.substitutions.push({ name: row.name, role, enabled, clusters })
+  }
+  return total
+}
+
+/* ------------------------------------------------------------------------- *
+ * Entry point
+ * ------------------------------------------------------------------------- */
+
+/**
+ * Derive the block grid for a level whose `Levels.txt` size is unset.
+ *
+ * `Act 5 - Barricade 1` and `2` ship `SizeX = SizeY = -1`. The engine does not
+ * read a size for them: `DRLGOUTSIEGE_ConnectBarricadeAndSiege` positions the
+ * barricade level against the siege level and sizes it from the barricade piece
+ * itself. The barricade piece is the `LvlSub` row with `GridSize = 2` whose name
+ * is `Barricade`, so its DS1's extent is the level's extent — that is what this
+ * reproduces.
+ *
+ * @param request - the request.
+ * @returns the size in cells and where it came from.
+ * @throws when no barricade piece is available to size the level from.
+ */
+function resolveUnsetSize(request: WildernessRequest): { sizeX: number; sizeY: number; source: string } {
+  if (request.sizeOverride !== undefined) {
+    return { sizeX: request.sizeOverride.x, sizeY: request.sizeOverride.y, source: 'sizeOverride' }
+  }
+  const barricade = request.substitutions.find(row => /barricade/i.test(row.name))
+  const level = barricade?.levels[0]
+  if (level === undefined) {
+    throw new Error(
+      `level ${String(request.levelId)} (${request.levelName}): Levels.txt gives no size and no barricade piece to derive one from`,
+    )
+  }
+  return { sizeX: level.width, sizeY: level.height, source: `LvlSub "${barricade!.name}" piece extent` }
+}
+
+/**
+ * Generate one wilderness level.
+ *
+ * The pipeline follows `DRLGOUTDOORS_GenerateLevel`: derive the block grid from
+ * the level's declared size, lay the ground, walk the outer ring stamping the
+ * border pieces, then scatter the `LvlSub` substitutions according to
+ * `SubType`/`SubTheme`. What it does **not** do is the per-act work that decides
+ * the level's outline and where it meets its neighbours — see
+ * {@link UNIMPLEMENTED_PASSES} and the module header.
+ *
+ * @param request - the real table data for one `DrlgType == 3` level.
+ * @returns the synthesized map plus a report of what was done.
+ * @throws when the level cannot be built: a size that yields no usable grid, or
+ *   an unset size with nothing to derive one from. The message always names the
+ *   level, because an empty map silently baked into an asset pack is worse than a
+ *   crash.
+ */
+export function generateWilderness(request: WildernessRequest): WildernessResult {
+  const where = `level ${String(request.levelId)} (${request.levelName})`
+  if (request.pieces.length === 0) throw new Error(`${where}: no LvlPrest pieces for this level type`)
+
+  let sizeX = request.sizeX
+  let sizeY = request.sizeY
+  let sizeSource = 'Levels.txt'
+  if (!Number.isFinite(sizeX) || !Number.isFinite(sizeY) || sizeX <= 0 || sizeY <= 0) {
+    const resolved = resolveUnsetSize(request)
+    sizeX = resolved.sizeX
+    sizeY = resolved.sizeY
+    sizeSource = resolved.source
+  }
+
+  const gridWidth = Math.floor(sizeX / TILES_PER_BLOCK)
+  const gridHeight = Math.floor(sizeY / TILES_PER_BLOCK)
+  if (gridWidth < 3 || gridHeight < 3) {
+    throw new Error(`${where}: ${String(sizeX)}x${String(sizeY)} cells is only ${String(gridWidth)}x${String(gridHeight)} blocks, too small for a bordered level`)
+  }
+
+  const stats: WildernessStats = {
+    substitutions: [], borderPieces: {}, unresolved: [], notes: [],
+    borderStamped: 0, groundCells: 0, groundTile: null, sizeSource,
+  }
+
+  // Layer counts must be known before the canvas exists, because a cell's layer
+  // arrays are fixed at creation.
+  let wallLayers = 1
+  let floorLayers = 1
+  let substitutionType = 0
+  let version = 0
+  let act = 1
+  const allLevels: Ds1[] = []
+  for (const piece of request.pieces) for (const level of piece.levels) allLevels.push(level)
+  for (const row of [...request.substitutions, ...(request.shrineSubstitutions ?? [])]) {
+    for (const level of row.levels) allLevels.push(level)
+  }
+  for (const level of allLevels) {
+    wallLayers = Math.max(wallLayers, level.wallLayers)
+    floorLayers = Math.max(floorLayers, level.floorLayers)
+    substitutionType = Math.max(substitutionType, level.substitutionType)
+    version = Math.max(version, level.version)
+    act = level.act
+  }
+  const substitutionLayers = substitutionType === 1 || substitutionType === 2 ? 1 : 0
+
+  const canvas = createCanvas(gridWidth * TILES_PER_BLOCK, gridHeight * TILES_PER_BLOCK, wallLayers, floorLayers, substitutionLayers)
+  const rng = new Rng(request.seed)
+
+  const groundTile = request.groundTile ?? deriveGroundTile(request.pieces)
+  stats.groundTile = groundTile
+  if (groundTile === null) {
+    throw new Error(`${where}: no piece carries a floor tile to use as ground`)
+  }
+  stats.groundCells = fillGround(canvas, groundTile, 0, 0, canvas.width, canvas.height)
+
+  const borderPieces = request.pieces.filter(piece => piece.border)
+  const fillPieces = request.pieces.filter(piece => !piece.border)
+  layBorder(canvas, borderPieces, gridWidth, gridHeight, rng, stats)
+
+  const themeIndex = Math.max(0, Math.min(4, Math.floor(request.subTheme)))
+  const objectRows = request.substitutions.filter(row => classifySubstitutionRole(row.name, row.type) !== 'border')
+  const borderRows = [...request.substitutions, ...(request.shrineSubstitutions ?? [])]
+    .filter(row => classifySubstitutionRole(row.name, row.type) === 'border')
+  // Secondary border pieces (`BordType` rows) are laid through the same cluster
+  // machinery, which is where their `GridSize`/`BordType` parameters belong.
+  const substituted = applySubstitutions(
+    canvas,
+    [...borderRows, ...objectRows, ...(request.shrineSubstitutions ?? []).filter(row => classifySubstitutionRole(row.name, row.type) !== 'border')],
+    themeIndex,
+    gridWidth,
+    gridHeight,
+    rng,
+    stats,
+  )
+  for (const piece of fillPieces) stats.notes.push(`fill piece "${piece.name}" is not placed by this port`)
+
+  if (!Number.isFinite(canvas.width * canvas.height) || canvas.width * canvas.height > (1 << 22)) {
+    throw new Error(`${where}: synthesized map is ${String(canvas.width)}x${String(canvas.height)} cells, outside the supported bound`)
+  }
+
+  return {
+    level: {
+      version: version === 0 ? 18 : version,
+      width: canvas.width,
+      height: canvas.height,
+      act,
+      substitutionType,
+      wallLayers: canvas.wallLayers,
+      floorLayers: canvas.floorLayers,
+      cells: canvas.cells,
+      objects: canvas.objects,
+      npcPathOffset: null,
+    },
+    stats: {
+      levelId: request.levelId,
+      levelName: request.levelName,
+      levelTypeName: request.levelTypeName,
+      seed: request.seed,
+      sizeX,
+      sizeY,
+      sizeSource,
+      tilesPerBlock: TILES_PER_BLOCK,
+      blockGrid: { width: gridWidth, height: gridHeight },
+      dt1Mask: wildernessDt1Mask(request.levelTypeName),
+      subType: request.subType,
+      subTheme: themeIndex,
+      groundTile,
+      groundCells: stats.groundCells,
+      borderPiecesAvailable: borderPieces.length,
+      borderBlocks: stats.borderStamped,
+      borderUsage: stats.borderPieces,
+      substitutions: stats.substitutions,
+      substitutedClusters: substituted,
+      objects: canvas.objects.length,
+      cells: canvas.width * canvas.height,
+      unresolved: stats.unresolved,
+      unimplementedPasses: UNIMPLEMENTED_PASSES,
+      notes: stats.notes,
+    },
+  }
+}
diff --git a/src/main.ts b/src/main.ts
new file mode 100644
index 0000000..ddd9c9a
--- /dev/null
+++ b/src/main.ts
@@ -0,0 +1,230 @@
+/**
+ * Browser entry: open a user-supplied MPQ and inspect what the container layer
+ * decodes.
+ *
+ * This is the first visible milestone (M0): it proves the whole pipeline runs
+ * web-native — random-access reads over a `File` (never loading the archive
+ * into memory), table decryption, sector decompression, and format previews
+ * rendered by platform APIs (canvas for images, Web Audio for sound).
+ */
+import { MpqArchive } from './mpq/archive.ts'
+import { blobSource } from './mpq/source.ts'
+import { decodePcx } from './formats/pcx.ts'
+
+const drop = document.querySelector<HTMLDivElement>('#drop')!
+const picker = document.querySelector<HTMLInputElement>('#picker')!
+const stats = document.querySelector<HTMLDListElement>('#stats')!
+const filter = document.querySelector<HTMLInputElement>('#filter')!
+const list = document.querySelector<HTMLUListElement>('#files')!
+const preview = document.querySelector<HTMLElement>('#preview')!
+
+/** Extension without the dot, lowercased. */
+function extensionOf(name: string): string {
+  const cut = name.lastIndexOf('.')
+  return cut === -1 ? '' : name.slice(cut + 1).toLowerCase()
+}
+
+/** Human-readable byte count. */
+function bytes(count: number): string {
+  if (count < 1024) return `${String(count)} B`
+  if (count < 1024 * 1024) return `${(count / 1024).toFixed(1)} KB`
+  return `${(count / 1024 / 1024).toFixed(2)} MB`
+}
+
+/** Render a definition list of label/value pairs. */
+function renderStats(rows: readonly (readonly [string, string])[]): void {
+  stats.replaceChildren(...rows.flatMap(([label, value]) => {
+    const dt = document.createElement('dt')
+    dt.textContent = label
+    const dd = document.createElement('dd')
+    dd.textContent = value
+    return [dt, dd]
+  }))
+}
+
+/** Draw an RGBA image into a fresh canvas, scaled by whole pixels. */
+function imageCanvas(width: number, height: number, rgba: Uint8ClampedArray, scale: number): HTMLCanvasElement {
+  const canvas = document.createElement('canvas')
+  canvas.width = width * scale
+  canvas.height = height * scale
+  const context = canvas.getContext('2d')!
+  context.imageSmoothingEnabled = false
+  const source = document.createElement('canvas')
+  source.width = width
+  source.height = height
+  // `ImageData` demands an `ArrayBuffer`-backed view; a decoded image's RGBA
+  // array is only typed as possibly-shared, so copy it into a fresh one.
+  const backing = new Uint8ClampedArray(new ArrayBuffer(width * height * 4))
+  backing.set(rgba)
+  source.getContext('2d')!.putImageData(new ImageData(backing, width, height), 0, 0)
+  context.drawImage(source, 0, 0, canvas.width, canvas.height)
+  return canvas
+}
+
+/** True when the bytes look like text rather than binary. */
+function looksTextual(data: Uint8Array): boolean {
+  const sample = data.subarray(0, Math.min(data.byteLength, 512))
+  let printable = 0
+  for (const byte of sample) {
+    if (byte === 9 || byte === 10 || byte === 13 || (byte >= 0x20 && byte < 0x7f) || byte >= 0x80) printable += 1
+  }
+  return sample.byteLength > 0 && printable / sample.byteLength > 0.9
+}
+
+/** Hex + ASCII dump of the first bytes. */
+function hexDump(data: Uint8Array, limit = 512): string {
+  const lines: string[] = []
+  const end = Math.min(data.byteLength, limit)
+  for (let at = 0; at < end; at += 16) {
+    const row = data.subarray(at, Math.min(at + 16, end))
+    const hex = [...row].map(byte => byte.toString(16).padStart(2, '0')).join(' ')
+    const ascii = [...row].map(byte => (byte >= 0x20 && byte < 0x7f ? String.fromCharCode(byte) : '.')).join('')
+    lines.push(`${at.toString(16).padStart(6, '0')}  ${hex.padEnd(47)}  ${ascii}`)
+  }
+  return lines.join('\n')
+}
+
+let audioContext: AudioContext | null = null
+
+/** Show one decoded member. */
+async function showMember(archive: MpqArchive, name: string, button: HTMLButtonElement): Promise<void> {
+  for (const other of list.querySelectorAll('button[aria-current]')) other.removeAttribute('aria-current')
+  button.setAttribute('aria-current', 'true')
+  const file = archive.find(name)
+  preview.replaceChildren()
+  const title = document.createElement('h2')
+  title.textContent = name
+  const sub = document.createElement('div')
+  sub.className = 'sub'
+  preview.append(title, sub)
+  if (file === undefined) {
+    sub.className = 'sub error'
+    sub.textContent = '该名字在归档中解析不到（listfile 与实际条目不匹配）'
+    return
+  }
+  sub.textContent = `${bytes(file.fileSize)} · flags 0x${(file.flags >>> 0).toString(16)} · block #${String(file.blockIndex)}`
+  try {
+    const data = await archive.read(file)
+    const ext = extensionOf(name)
+    if (ext === 'pcx') {
+      const image = decodePcx(data)
+      const scale = Math.max(1, Math.min(4, Math.floor(760 / Math.max(image.width, 1))))
+      preview.append(imageCanvas(image.width, image.height, image.rgba, scale))
+      const note = document.createElement('div')
+      note.className = 'sub'
+      note.textContent = `${String(image.width)}×${String(image.height)} · ${String(data.byteLength)} 字节 · PCX 解码正常`
+      preview.append(note)
+      return
+    }
+    if (ext === 'wav' || ext === 'mp3' || ext === 'ogg') {
+      audioContext ??= new AudioContext()
+      // The shareware archive's ".wav" members are actually MP3 payloads, so
+      // the platform decoder (not a RIFF parser) is what must read them.
+      const buffer = await audioContext.decodeAudioData(data.slice().buffer)
+      const play = document.createElement('button')
+      play.textContent = '▶ 播放'
+      play.onclick = () => {
+        const source = audioContext!.createBufferSource()
+        source.buffer = buffer
+        source.connect(audioContext!.destination)
+        source.start()
+      }
+      const note = document.createElement('div')
+      note.className = 'sub'
+      note.textContent = `${buffer.numberOfChannels} 声道 · ${buffer.sampleRate} Hz · ${buffer.duration.toFixed(2)} s · Web Audio 解码正常`
+      preview.append(play, note)
+      return
+    }
+    if (looksTextual(data)) {
+      const pre = document.createElement('pre')
+      const text = new TextDecoder().decode(data)
+      pre.textContent = text.length > 20000 ? `${text.slice(0, 20000)}\n… 共 ${String(text.length)} 字符` : text
+      preview.append(pre)
+      return
+    }
+    const pre = document.createElement('pre')
+    pre.textContent = hexDump(data)
+    preview.append(pre)
+  } catch (error) {
+    sub.className = 'sub error'
+    sub.textContent = `解码失败：${(error as Error).message}`
+  }
+}
+
+/** Open an archive from a user-supplied file. */
+async function openArchive(file: File): Promise<void> {
+  stats.replaceChildren()
+  list.replaceChildren()
+  preview.replaceChildren()
+  drop.textContent = `正在读取 ${file.name} …`
+  try {
+    const archive = await MpqArchive.open(blobSource(file))
+    const names = await archive.listFiles()
+    drop.textContent = `${file.name} · 已就绪（重新拖入可替换）`
+    const header = archive.header
+    renderStats([
+      ['文件', file.name],
+      ['大小', bytes(file.size)],
+      ['格式', `MPQ v${String(header.formatVersion + 1)}`],
+      ['扇区', bytes(header.sectorSize)],
+      ['哈希表', `${String(header.hashTableEntries)} 项`],
+      ['块表', `${String(header.blockTableEntries)} 项`],
+      ['名字', `${String(names.length)} 个`],
+    ])
+    filter.disabled = false
+    const rows = names.map(name => {
+      const item = document.createElement('li')
+      const button = document.createElement('button')
+      button.textContent = name
+      const meta = document.createElement('span')
+      meta.className = 'meta'
+      const entry = archive.find(name)
+      meta.textContent = entry === undefined ? '  （未解析）' : `  ${bytes(entry.fileSize)}`
+      button.append(meta)
+      button.onclick = () => { void showMember(archive, name, button) }
+      item.append(button)
+      return { item, name: name.toLowerCase() }
+    })
+    list.append(...rows.map(row => row.item))
+    filter.oninput = () => {
+      const needle = filter.value.trim().toLowerCase()
+      for (const row of rows) row.item.hidden = needle !== '' && !row.name.includes(needle)
+    }
+  } catch (error) {
+    drop.textContent = '打开失败，重试或换一个归档'
+    const message = document.createElement('div')
+    message.className = 'error'
+    message.textContent = (error as Error).message
+    stats.append(message)
+  }
+}
+
+drop.onclick = () => { picker.click() }
+picker.onchange = () => { const file = picker.files?.[0]; if (file) void openArchive(file) }
+for (const event of ['dragenter', 'dragover'] as const) {
+  drop.addEventListener(event, () => { drop.classList.add('hot') })
+}
+for (const event of ['dragleave', 'drop'] as const) {
+  drop.addEventListener(event, () => { drop.classList.remove('hot') })
+}
+drop.addEventListener('drop', (event) => {
+  event.preventDefault()
+  const file = event.dataTransfer?.files?.[0]
+  if (file) void openArchive(file)
+})
+
+// Dev convenience: `?sample=samples/spawn.mpq` streams a sample archive over
+// HTTP so the pipeline can be smoke-tested without a manual drag & drop.
+const sample = new URLSearchParams(location.search).get('sample')
+if (sample !== null) {
+  void (async () => {
+    drop.textContent = `正在通过 HTTP 读取 ${sample} …`
+    const response = await fetch(sample)
+    if (!response.ok) {
+      drop.textContent = `样本读取失败：HTTP ${String(response.status)}`
+      return
+    }
+    const blob = await response.blob()
+    await openArchive(new File([blob], sample.split('/').pop() ?? 'sample.mpq'))
+  })()
+}
diff --git a/src/mpq/archive.ts b/src/mpq/archive.ts
new file mode 100644
index 0000000..ef13cf2
--- /dev/null
+++ b/src/mpq/archive.ts
@@ -0,0 +1,501 @@
+/**
+ * MPQ archive reader (format v1).
+ *
+ * Layered like the format itself:
+ *   header → encrypted hash table → encrypted block table → per-file sectors.
+ * Tables are always encrypted in v1, so opening an archive is a decrypt of
+ * two tables; a member read is an offset-table read plus one decrypt (and
+ * optionally one decompress) per sector, all through a random-access
+ * {@link MpqSource} so a large archive is never held in memory.
+ *
+ * Classic Diablo/Diablo II archives are v1. v2+ headers (and the v4
+ * `MPQ\x1B` container) are rejected explicitly rather than misparsed.
+ */
+import {
+  BLOCK_TABLE_KEY, HASH_NAME_A, HASH_NAME_B, HASH_TABLE_KEY, HASH_TABLE_OFFSET,
+  decryptBlock, fileKey, hashString, normalizeName,
+} from './crypt.ts'
+import { MpqCompressionError, compressionMaskName, decompressSector, COMPRESSION_PKWARE } from './decompress.ts'
+import { ImplodeError, explode } from './implode.ts'
+import type { MpqSource } from './source.ts'
+
+/** Sector size is `512 << shift`; the shift lives in the header. */
+const SECTOR_SIZE_BASE = 512
+/** A hash-table entry's `blockIndex` sentinel: the slot never held a file. */
+const BLOCK_INDEX_FREE = 0xffffffff
+
+/** `MPQ_FILE_IMPLODE`: PKWARE-imploded file. */
+const FILE_IMPLODE = 0x00000100
+/** `MPQ_FILE_COMPRESS`: file uses the multi-codec compression mask. */
+const FILE_COMPRESS = 0x00000200
+/** `MPQ_FILE_ENCRYPTED`: file blocks are encrypted. */
+const FILE_ENCRYPTED = 0x00010000
+/** `MPQ_FILE_FIX_KEY`: file key is adjusted by offset and size. */
+const FILE_FIX_KEY = 0x00020000
+/** `MPQ_FILE_SINGLE_UNIT`: file is stored as one unit, with no sector table. */
+const FILE_SINGLE_UNIT = 0x01000000
+/** `MPQ_FILE_DELETE_MARKER`: tombstone entry. */
+const FILE_DELETE_MARKER = 0x02000000
+/** `MPQ_FILE_SECTOR_CRC`: one extra sector of checksums follows the offset table. */
+const FILE_SECTOR_CRC = 0x04000000
+/** `MPQ_FILE_EXISTS`: entry names a real file. */
+const FILE_EXISTS = 0x80000000
+
+/** The v1 archive signature. */
+const MPQ_MAGIC = 0x1a51504d
+
+/** Parsed archive header (v1 fields). */
+export interface MpqHeader {
+  /** Header size field as stored. */
+  headerSize: number
+  /** Declared archive size in bytes. */
+  archiveSize: number
+  /** Container format version (0 = v1). */
+  formatVersion: number
+  /** Sector size in bytes, derived from the stored shift. */
+  sectorSize: number
+  /** Offset of the hash table. */
+  hashTableOffset: number
+  /** Offset of the block table. */
+  blockTableOffset: number
+  /** Hash table length in entries. */
+  hashTableEntries: number
+  /** Block table length in entries. */
+  blockTableEntries: number
+}
+
+/** One resolved archive member. */
+export interface MpqFile {
+  /** Normalized (backslash) name this file was found under. */
+  readonly name: string
+  /** Index of the file's block-table entry. */
+  readonly blockIndex: number
+  /** Locale field of the hash-table entry. */
+  readonly locale: number
+  /** Stored offset of the file's first byte. */
+  readonly blockOffset: number
+  /** Stored size in bytes. */
+  readonly compressedSize: number
+  /** Uncompressed size in bytes. */
+  readonly fileSize: number
+  /** Raw flag word. */
+  readonly flags: number
+}
+
+/** Options for {@link MpqArchive.open}. */
+export interface MpqOpenOptions {
+  /**
+   * Extra names to expose, for archives whose `(listfile)` is missing or
+   * incomplete — the normal case for Diablo II's `d2data.mpq`, whose names
+   * come from a community listfile.
+   */
+  listfile?: readonly string[] | undefined
+}
+
+/**
+ * A readable archive.
+ */
+export class MpqArchive {
+  /** Parsed header of the open archive. */
+  readonly header: MpqHeader
+  /** Names supplied from outside the archive, when any. */
+  private readonly names: readonly string[] | undefined
+  /** The underlying byte source. */
+  private readonly source: MpqSource
+  /** Hash-table words, decrypted. */
+  private readonly hashTable: Uint32Array
+  /** Block-table words, decrypted. */
+  private readonly blockTable: Uint32Array
+
+  private constructor(
+    source: MpqSource,
+    header: MpqHeader,
+    hashTable: Uint32Array,
+    blockTable: Uint32Array,
+    options: MpqOpenOptions,
+  ) {
+    this.source = source
+    this.header = header
+    this.hashTable = hashTable
+    this.blockTable = blockTable
+    this.names = options.listfile
+  }
+
+  /**
+   * Open an archive over a random-access source.
+   *
+   * @param source - byte source positioned at the archive start.
+   * @param options - listfile supplement.
+   * @returns the open archive.
+   */
+  static async open(source: MpqSource, options: MpqOpenOptions = {}): Promise<MpqArchive> {
+    const head = await source.read(0, 32)
+    const view = new DataView(head.buffer, head.byteOffset, head.byteLength)
+    const magic = view.getUint32(0, true)
+    if (magic !== MPQ_MAGIC) {
+      throw new Error(`${source.label}: not an MPQ archive (magic 0x${magic.toString(16)})`)
+    }
+    const formatVersion = view.getUint16(0x0c, true)
+    if (formatVersion !== 0) {
+      throw new Error(
+        `${source.label}: MPQ format v${String(formatVersion + 1)} is not supported yet (only v1 headers)`,
+      )
+    }
+    const blockSizeShift = view.getUint16(0x0e, true)
+    const header: MpqHeader = {
+      headerSize: view.getUint32(0x04, true),
+      archiveSize: view.getUint32(0x08, true),
+      formatVersion,
+      sectorSize: SECTOR_SIZE_BASE << blockSizeShift,
+      hashTableOffset: view.getUint32(0x10, true),
+      blockTableOffset: view.getUint32(0x14, true),
+      hashTableEntries: view.getUint32(0x18, true),
+      blockTableEntries: view.getUint32(0x1c, true),
+    }
+    if (header.hashTableEntries === 0 || (header.hashTableEntries & (header.hashTableEntries - 1)) !== 0) {
+      throw new Error(`${source.label}: hash table size ${String(header.hashTableEntries)} is not a non-zero power of two`)
+    }
+    const rawHash = await source.read(header.hashTableOffset, header.hashTableEntries * 16)
+    decryptBlock(rawHash, HASH_TABLE_KEY)
+    const rawBlock = await source.read(header.blockTableOffset, header.blockTableEntries * 16)
+    decryptBlock(rawBlock, BLOCK_TABLE_KEY)
+    return new MpqArchive(
+      source,
+      header,
+      wordsOf(rawHash),
+      wordsOf(rawBlock),
+      options,
+    )
+  }
+
+  /**
+   * Resolve one name.
+   *
+   * @param name - archive name, either separator.
+   * @returns the member, or `undefined` when the archive has no such name.
+   */
+  find(name: string): MpqFile | undefined {
+    const target = normalizeName(name)
+    const hashA = hashString(target, HASH_NAME_A)
+    const hashB = hashString(target, HASH_NAME_B)
+    const start = hashString(target, HASH_TABLE_OFFSET) % this.header.hashTableEntries
+    let fallback: MpqFile | undefined
+    for (let step = 0; step < this.header.hashTableEntries; step += 1) {
+      const slot = (start + step) % this.header.hashTableEntries
+      const base = slot * 4
+      const entryHashA = this.hashTable[base]!
+      const entryHashB = this.hashTable[base + 1]!
+      const locale = this.hashTable[base + 2]! & 0xffff
+      const blockIndex = this.hashTable[base + 3]!
+      if (blockIndex === BLOCK_INDEX_FREE) return fallback
+      if (entryHashA !== hashA || entryHashB !== hashB) continue
+      const file = this.fileAt(blockIndex, target, locale)
+      if (file === undefined) return fallback
+      // Neutral locale wins when an archive carries localized duplicates.
+      if (locale === 0) return file
+      fallback ??= file
+    }
+    return fallback
+  }
+
+  /**
+   * Describe one block-table entry.
+   *
+   * @param blockIndex - index into the block table.
+   * @param name - name to attach.
+   * @param locale - locale to attach.
+   * @returns the member, or `undefined` for a free/tombstone slot.
+   */
+  private fileAt(blockIndex: number, name: string, locale: number): MpqFile | undefined {
+    if (blockIndex >= this.header.blockTableEntries) return undefined
+    const base = blockIndex * 4
+    const flags = this.blockTable[base + 3]!
+    if ((flags & FILE_EXISTS) === 0 || (flags & FILE_DELETE_MARKER) !== 0) return undefined
+    return {
+      name,
+      blockIndex,
+      locale,
+      blockOffset: this.blockTable[base]!,
+      compressedSize: this.blockTable[base + 1]!,
+      fileSize: this.blockTable[base + 2]!,
+      flags,
+    }
+  }
+
+  /**
+   * Every occupied block-table slot, named where a name is known.
+   *
+   * Diablo II's `d2data.mpq` carries no `(listfile)`, so the useful way to
+   * explore it is by block index; this enumeration keeps that door open.
+   *
+   * @param names - optional index → name map (e.g. a parsed community listfile).
+   * @returns one entry per occupied block-table slot.
+   */
+  files(names?: ReadonlyMap<number, string>): MpqFile[] {
+    const out: MpqFile[] = []
+    for (let blockIndex = 0; blockIndex < this.header.blockTableEntries; blockIndex += 1) {
+      const name = names?.get(blockIndex)
+      const file = this.fileAt(blockIndex, name ?? `block:${String(blockIndex)}`, 0)
+      if (file !== undefined) out.push(file)
+    }
+    return out
+  }
+
+  /**
+   * Decode one stored sector body into exactly `expected` bytes.
+   *
+   * Two encodings exist, and which one applies is decided per sector:
+   *
+   * - **Stored as-is** when the body's length already equals the expected size.
+   *   Encoders fall back to this whenever compressing a sector would not shrink
+   *   it, so a member can mix stored and compressed sectors — `Patch_D2.mpq` has
+   *   both, including members whose stored size exceeds the declared file size by
+   *   nothing but the offset table. Stored sectors carry no marker byte.
+   * - **Compressed**, and then the flag word decides how to read it:
+   *   `MPQ_FILE_COMPRESS` (0x200) means a codec mask byte comes first, while
+   *   `MPQ_FILE_IMPLODE` (0x100) alone means the body is a PKWARE implode
+   *   stream with no mask. Diablo II's `Patch_D2.mpq` stores every table the
+   *   second way; reading those as if a mask byte were present used to hand back
+   *   the compressed bytes verbatim, because a stream starting with 0x00 looks
+   *   exactly like "stored". That silent path is gone.
+   *
+   * @param body - stored bytes, decrypted already.
+   * @param expected - uncompressed length of this sector.
+   * @param masked - the member carries `MPQ_FILE_COMPRESS`.
+   * @returns the decoded sector.
+   */
+  private async decodeSector(body: Uint8Array, expected: number, masked: boolean): Promise<Uint8Array> {
+    if (body.byteLength === expected) return body
+    if (masked) return decompressSector(body, expected)
+    try {
+      return explode(body, expected)
+    } catch (err) {
+      const detail = err instanceof ImplodeError ? err.message : String(err)
+      throw new MpqCompressionError(`implode-only member: ${detail}`, COMPRESSION_PKWARE)
+    }
+  }
+
+  /**
+   * Read and decode one member.
+   *
+   * @param file - a member from {@link find} (or {@link files}).
+   * @returns the decoded bytes.
+   */
+  async read(file: MpqFile): Promise<Uint8Array> {
+    const { flags, fileSize, compressedSize, blockOffset, name } = file
+    if (fileSize === 0) return new Uint8Array(0)
+    const encrypted = (flags & FILE_ENCRYPTED) !== 0
+    const singleUnit = (flags & FILE_SINGLE_UNIT) !== 0
+    const compressed = (flags & (FILE_COMPRESS | FILE_IMPLODE)) !== 0
+    const masked = (flags & FILE_COMPRESS) !== 0
+    const key = fileKey(name, blockOffset, fileSize, (flags & FILE_FIX_KEY) !== 0)
+
+    if (singleUnit) {
+      const raw = await this.source.read(blockOffset, compressedSize)
+      if (encrypted) decryptBlock(raw, key)
+      if (!compressed) return raw
+      return this.decodeSector(raw, fileSize, masked)
+    }
+
+    if (!compressed) {
+      // Stored members carry no sector offset table at all (the reference
+      // implementation only loads one under `MPQ_FILE_COMPRESS_MASK`): the data
+      // is one contiguous run at the block offset. Encrypted stored members are
+      // still decrypted per sector-sized chunk, because that is the cipher's
+      // key schedule — key + sector index.
+      const raw = await this.source.read(blockOffset, fileSize)
+      if (!encrypted) return raw
+      const sectorSize = this.header.sectorSize
+      for (let sector = 0; sector * sectorSize < fileSize; sector += 1) {
+        const from = sector * sectorSize
+        const to = Math.min(from + sectorSize, fileSize)
+        decryptBlock(raw.subarray(from, to), (key + sector) >>> 0)
+      }
+      return raw
+    }
+
+    const sectorSize = this.header.sectorSize
+    const sectorCount = Math.ceil(fileSize / sectorSize)
+    // A CRC sector rides between the offset table and the data.
+    const tableEntries = sectorCount + ((flags & FILE_SECTOR_CRC) !== 0 ? 1 : 0)
+    const table = await this.source.read(blockOffset, (tableEntries + 1) * 4)
+    if (encrypted) decryptBlock(table, (key - 1) >>> 0)
+    const offsets = new DataView(table.buffer, table.byteOffset, table.byteLength)
+    const out = new Uint8Array(fileSize)
+    for (let sector = 0; sector < sectorCount; sector += 1) {
+      const from = offsets.getUint32(sector * 4, true)
+      const to = offsets.getUint32((sector + 1) * 4, true)
+      if (to < from) {
+        throw new MpqCompressionError(
+          `${name}: sector ${String(sector)} has a reversed extent (${String(from)}..${String(to)})`,
+        )
+      }
+      const expected = Math.min(sectorSize, fileSize - sector * sectorSize)
+      const stored = await this.source.read(blockOffset + from, to - from)
+      if (encrypted) decryptBlock(stored, (key + sector) >>> 0)
+      const decoded = await this.decodeSector(stored, expected, masked)
+      if (decoded.byteLength !== expected) {
+        // Loud on purpose: a short buffer padded with zeros decodes into
+        // plausible-looking nonsense downstream.
+        throw new MpqCompressionError(
+          `${name}: sector ${String(sector)} decoded ${String(decoded.byteLength)} bytes, expected ${String(expected)}`,
+        )
+      }
+      out.set(decoded, sector * sectorSize)
+    }
+    return out
+  }
+
+  /**
+   * Read a member by name.
+   *
+   * @param name - archive name, either separator.
+   * @returns the decoded bytes.
+   */
+  async readByName(name: string): Promise<Uint8Array> {
+    const file = this.find(name)
+    if (file === undefined) throw new Error(`${this.source.label}: no such file "${name}"`)
+    return this.read(file)
+  }
+
+  /**
+   * The names **this archive actually contains**: `(listfile)` when present, plus
+   * any supplied external listfile, deduplicated and each verified through the
+   * hash table.
+   *
+   * A community listfile names every retail archive at once, so it cannot be
+   * trusted as-is: a name it lists may live in a *different* archive. Filtering by
+   * {@link find} is what makes "the archive does not contain this member" a fact
+   * rather than a statement about which names happened to be enumerated.
+   *
+   * @returns the known names, in listfile order.
+   */
+  async listFiles(): Promise<string[]> {
+    const seen = new Set<string>()
+    const out: string[] = []
+    const push = (name: string): void => {
+      const trimmed = name.trim()
+      if (trimmed === '' || seen.has(trimmed.toLowerCase())) return
+      seen.add(trimmed.toLowerCase())
+      if (trimmed === '(listfile)' || this.find(trimmed) !== undefined) out.push(trimmed)
+    }
+    const internal = this.find('(listfile)')
+    if (internal !== undefined) {
+      const text = new TextDecoder().decode(await this.read(internal))
+      for (const line of text.split(/\r?\n/)) push(line)
+    }
+    for (const name of this.names ?? []) push(name)
+    return out
+  }
+
+  /**
+   * Map block-table index → name for every name the archive can resolve.
+   *
+   * A file's encryption key is derived from its *name*, so an anonymous block
+   * cannot be decrypted at all; this map is what turns block indices back into
+   * readable entries for archives whose listfile is external.
+   *
+   * @returns the index → name map.
+   */
+  async nameIndex(): Promise<Map<number, string>> {
+    const index = new Map<number, string>()
+    for (const name of await this.listFiles()) {
+      const file = this.find(name)
+      if (file !== undefined && !index.has(file.blockIndex)) index.set(file.blockIndex, file.name)
+    }
+    return index
+  }
+
+  /**
+   * Describe the codecs an archive uses across all occupied blocks — the
+   * quickest way to see which decoders a given archive actually needs.
+   *
+   * Blocks that are both encrypted and nameless are counted as `unknown`:
+   * their key cannot be derived without the name.
+   *
+   * @param names - optional index → name map (see {@link nameIndex}).
+   * @returns mask name → count.
+   */
+  async compressionHistogram(names?: ReadonlyMap<number, string>): Promise<Map<string, number>> {
+    const counts = new Map<string, number>()
+    const bump = (name: string): void => { counts.set(name, (counts.get(name) ?? 0) + 1) }
+    for (const file of this.files(names)) {
+      if (file.fileSize === 0) continue
+      const singleUnit = (file.flags & FILE_SINGLE_UNIT) !== 0
+      const encrypted = (file.flags & FILE_ENCRYPTED) !== 0
+      const compressed = (file.flags & (FILE_COMPRESS | FILE_IMPLODE)) !== 0
+      if (!compressed) {
+        bump('stored')
+        continue
+      }
+      const named = names?.has(file.blockIndex) ?? !encrypted
+      if (!named) {
+        bump('unknown (encrypted, unnamed)')
+        continue
+      }
+      const key = fileKey(file.name, file.blockOffset, file.fileSize, (file.flags & FILE_FIX_KEY) !== 0)
+      const sectorSize = this.header.sectorSize
+      if (singleUnit) {
+        const raw = await this.source.read(file.blockOffset, Math.min(file.compressedSize, file.fileSize))
+        if (encrypted) decryptBlock(raw, key)
+        bump(compressionMaskName(raw[0] ?? 0))
+        continue
+      }
+      const sectorCount = Math.ceil(file.fileSize / sectorSize)
+      const tableEntries = sectorCount + ((file.flags & FILE_SECTOR_CRC) !== 0 ? 1 : 0)
+      const table = await this.source.read(file.blockOffset, (tableEntries + 1) * 4)
+      if (encrypted) decryptBlock(table, (key - 1) >>> 0)
+      const offsets = new DataView(table.buffer, table.byteOffset, table.byteLength)
+      const from = offsets.getUint32(0, true)
+      const to = offsets.getUint32(4, true)
+      if (to <= from) continue
+      const raw = await this.source.read(file.blockOffset + from, to - from)
+      if (encrypted) decryptBlock(raw, key)
+      bump(compressionMaskName(raw[0] ?? 0))
+    }
+    return counts
+  }
+
+  /**
+   * Count how many members carry each storage flag — the fastest way to see
+   * what a given archive will exercise (encryption, single-unit storage, ...).
+   *
+   * @returns flag name → count.
+   */
+  flagHistogram(): Map<string, number> {
+    const counts = new Map<string, number>()
+    const bump = (name: string): void => { counts.set(name, (counts.get(name) ?? 0) + 1) }
+    for (const file of this.files()) {
+      if (file.fileSize === 0) { bump('empty'); continue }
+      bump('total')
+      if ((file.flags & FILE_ENCRYPTED) !== 0) bump('encrypted')
+      if ((file.flags & FILE_FIX_KEY) !== 0) bump('fix-key')
+      if ((file.flags & FILE_SINGLE_UNIT) !== 0) bump('single-unit')
+      if ((file.flags & FILE_COMPRESS) !== 0) bump('compressed')
+      if ((file.flags & FILE_IMPLODE) !== 0) bump('imploded')
+      if ((file.flags & FILE_SECTOR_CRC) !== 0) bump('sector-crc')
+    }
+    return counts
+  }
+}
+
+/**
+ * Reinterpret a byte buffer as little-endian words.
+ *
+ * Hash and block tables are arrays of `uint32`; the cipher already produced
+ * little-endian bytes, so the view is only for convenience.
+ *
+ * @param bytes - the decrypted table.
+ * @returns the words.
+ */
+function wordsOf(bytes: Uint8Array): Uint32Array {
+  const count = bytes.byteLength >>> 2
+  const words = new Uint32Array(count)
+  for (let i = 0; i < count; i += 1) {
+    words[i] = (bytes[i * 4]!)
+      | ((bytes[i * 4 + 1]!) << 8)
+      | ((bytes[i * 4 + 2]!) << 16)
+      | ((bytes[i * 4 + 3]!) << 24)
+  }
+  return words
+}
diff --git a/src/mpq/crypt.ts b/src/mpq/crypt.ts
new file mode 100644
index 0000000..fa71446
--- /dev/null
+++ b/src/mpq/crypt.ts
@@ -0,0 +1,159 @@
+/**
+ * MPQ (Storm) cryptography: the shared crypt table, `HashString`, and the
+ * block cipher.
+ *
+ * Semantics follow the public StormLib reference implementation (MIT,
+ * Copyright (c) Ladislav Zezula); this file is an independent TypeScript
+ * port. All arithmetic is unsigned 32-bit with explicit wrapping, because
+ * the format depends on exact overflow behaviour.
+ */
+
+/** Hash selector: table index (start of the probe chain). */
+export const HASH_TABLE_OFFSET = 0
+/** Hash selector: name hash A (hash table entry comparison). */
+export const HASH_NAME_A = 1
+/** Hash selector: name hash B (hash table entry comparison). */
+export const HASH_NAME_B = 2
+/** Hash selector: per-file encryption key. */
+export const HASH_FILE_KEY = 3
+
+/** Charset size: one hash alphabet per selector occupies 0x100 slots. */
+const CHARSET_SIZE = 0x100
+
+/**
+ * The 0x500-entry Storm crypt table: 5 alphabets of 0x100 values. The last
+ * alphabet (0x400..0x4FF) is the cipher's per-key-byte seed table.
+ */
+const CRYPT_TABLE: Uint32Array = (() => {
+  const table = new Uint32Array(5 * CHARSET_SIZE)
+  let seed = 0x00100001
+  for (let index1 = 0; index1 < CHARSET_SIZE; index1 += 1) {
+    let index2 = index1
+    for (let i = 0; i < 5; i += 1, index2 += CHARSET_SIZE) {
+      seed = ((((Math.imul(seed, 125) + 3) >>> 0) % 0x2aaaab) >>> 0)
+      const temp1 = ((seed & 0xffff) << 0x10) >>> 0
+      seed = ((((Math.imul(seed, 125) + 3) >>> 0) % 0x2aaaab) >>> 0)
+      const temp2 = seed & 0xffff
+      table[index2] = (temp1 | temp2) >>> 0
+    }
+  }
+  return table
+})()
+
+/**
+ * Storm's case-insensitive string hash.
+ *
+ * Archive names are ASCII; the uppercase fold is applied to ASCII only so a
+ * stray non-ASCII byte cannot alias two distinct names.
+ *
+ * @param name - archive file name (either separator is accepted by callers).
+ * @param hashType - one of the `HASH_*` selectors.
+ * @returns the 32-bit hash.
+ */
+export function hashString(name: string, hashType: number): number {
+  let seed1 = 0x7fed7fed
+  let seed2 = 0xeeeeeeee
+  const base = hashType * CHARSET_SIZE
+  for (let i = 0; i < name.length; i += 1) {
+    const code = name.charCodeAt(i)
+    const ch = (code >= 0x61 && code <= 0x7a ? code - 0x20 : code) & 0xff
+    seed1 = (CRYPT_TABLE[base + ch]! ^ ((seed1 + seed2) >>> 0)) >>> 0
+    seed2 = (ch + seed1 + seed2 + (((seed2 << 5) >>> 0)) + 3) >>> 0
+  }
+  return seed1
+}
+
+/**
+ * Decrypt one block in place with the MPQ block cipher.
+ *
+ * @param data - buffer to decrypt; `byteLength` must be a multiple of 4.
+ * @param key - the 32-bit file/table key.
+ */
+export function decryptBlock(data: Uint8Array, key: number): void {
+  const words = data.byteLength >>> 2
+  if (words === 0) return
+  const view = new DataView(data.buffer, data.byteOffset, words << 2)
+  let seed = 0xeeeeeeee
+  let k = key >>> 0
+  for (let i = 0; i < words; i += 1) {
+    seed = (seed + CRYPT_TABLE[0x400 + (k & 0xff)]!) >>> 0
+    const ch = (view.getUint32(i * 4, true) ^ ((k + seed) >>> 0)) >>> 0
+    k = ((((~k << 0x15) >>> 0) + 0x11111111 | (k >>> 0x0b)) >>> 0)
+    seed = (ch + seed + (((seed << 5) >>> 0)) + 3) >>> 0
+    view.setUint32(i * 4, ch, true)
+  }
+}
+
+/**
+ * Encrypt one block in place with the MPQ block cipher.
+ *
+ * MPQ's cipher is its own inverse in the sense that both directions run the same
+ * key schedule: the schedule is advanced with the *plaintext* word, so encrypting
+ * reads the plaintext, writes the ciphertext, and feeds the plaintext into the
+ * schedule — while `decryptBlock` reads the ciphertext, recovers the plaintext,
+ * and feeds that same plaintext in. Keeping the two explicit matters for the
+ * writer, where using the decrypt path would corrupt the schedule.
+ *
+ * @param data - buffer to encrypt; `byteLength` must be a multiple of 4.
+ * @param key - the 32-bit file/table key.
+ */
+export function encryptBlock(data: Uint8Array, key: number): void {
+  const words = data.byteLength >>> 2
+  if (words === 0) return
+  const view = new DataView(data.buffer, data.byteOffset, words << 2)
+  let seed = 0xeeeeeeee
+  let k = key >>> 0
+  for (let i = 0; i < words; i += 1) {
+    seed = (seed + CRYPT_TABLE[0x400 + (k & 0xff)]!) >>> 0
+    const plain = view.getUint32(i * 4, true)
+    const cipher = (plain ^ ((k + seed) >>> 0)) >>> 0
+    k = ((((~k << 0x15) >>> 0) + 0x11111111 | (k >>> 0x0b)) >>> 0)
+    seed = (plain + seed + (((seed << 5) >>> 0)) + 3) >>> 0
+    view.setUint32(i * 4, cipher, true)
+  }
+}
+
+/**
+ * The encryption key of one archive member.
+ *
+ * The key is derived from the *plain* file name — the segment after the last
+ * separator — while the hash-table lookup uses the full path. The two are the
+ * same only for root-level names, so a path-qualified lookup that hashes the
+ * whole name silently produces a key that decrypts to noise.
+ *
+ * @param name - archive file name, either separator.
+ * @param blockOffset - stored offset of the file's first byte.
+ * @param fileSize - uncompressed size of the file.
+ * @param fixKey - the entry carries `MPQ_FILE_FIX_KEY`.
+ * @returns the file key.
+ */
+export function fileKey(name: string, blockOffset: number, fileSize: number, fixKey: boolean): number {
+  const base = hashString(plainName(normalizeName(name)), HASH_FILE_KEY)
+  return fixKey ? (((base + blockOffset) >>> 0) ^ fileSize) >>> 0 : base
+}
+
+/**
+ * The plain (directory-less) form of an archive name.
+ *
+ * @param name - archive name, either separator.
+ * @returns the trailing path segment.
+ */
+export function plainName(name: string): string {
+  const cut = Math.max(name.lastIndexOf('\\'), name.lastIndexOf('/'))
+  return cut === -1 ? name : name.slice(cut + 1)
+}
+
+/** The fixed key of the hash table. */
+export const HASH_TABLE_KEY = hashString('(hash table)', HASH_FILE_KEY)
+/** The fixed key of the block table. */
+export const BLOCK_TABLE_KEY = hashString('(block table)', HASH_FILE_KEY)
+
+/**
+ * Archive names use backslash separators internally; callers may pass either.
+ *
+ * @param name - caller-supplied name.
+ * @returns the normalized name.
+ */
+export function normalizeName(name: string): string {
+  return name.replace(/\//g, '\\')
+}
diff --git a/src/mpq/decompress.ts b/src/mpq/decompress.ts
new file mode 100644
index 0000000..af9437c
--- /dev/null
+++ b/src/mpq/decompress.ts
@@ -0,0 +1,131 @@
+/**
+ * MPQ sector decompression.
+ *
+ * A compressed sector starts with one mask byte naming the codecs applied to
+ * the payload; combined masks (e.g. `HUFFMANN | ADPCM_MONO` on Diablo's WAV
+ * data) are unwound in the fixed order below, which is the order StormLib
+ * applies them in.
+ *
+ * zlib needs no code of its own: `DecompressionStream('deflate')` is the
+ * platform decoder, present in browsers and in Node. PKWARE implode needed real
+ * code — Diablo II stores almost every table and asset with it — so it lives in
+ * `implode.ts` and is called here.
+ */
+
+import { ImplodeError, explode } from './implode.ts'
+
+/** Codec bit: adaptive Huffmann (FGK variant). */
+export const COMPRESSION_HUFFMANN = 0x01
+/** Codec bit: zlib/deflate. */
+export const COMPRESSION_ZLIB = 0x02
+/** Codec bit: PKWARE Data Compression Library implode. */
+export const COMPRESSION_PKWARE = 0x08
+/** Codec bit: bzip2. */
+export const COMPRESSION_BZIP2 = 0x10
+/** Codec bit: sparse (run-length + mask bytes). */
+export const COMPRESSION_SPARSE = 0x20
+/** Codec bit: ADPCM, mono, 4-bit. */
+export const COMPRESSION_ADPCM_MONO = 0x40
+/** Codec bit: ADPCM, stereo, 4-bit. */
+export const COMPRESSION_ADPCM_STEREO = 0x80
+
+/** Raised when a sector cannot be decoded. */
+export class MpqCompressionError extends Error {
+  /** The compression mask that failed, when known. */
+  readonly mask: number | undefined
+
+  /**
+   * @param message - human-readable failure.
+   * @param mask - the compression mask that failed, when known.
+   */
+  constructor(message: string, mask?: number) {
+    super(message)
+    this.name = 'MpqCompressionError'
+    this.mask = mask
+  }
+}
+
+/**
+ * Name the codecs a mask selects, for diagnostics.
+ *
+ * @param mask - the compression mask byte.
+ * @returns a `+`-joined list, or `stored` for an empty mask.
+ */
+export function compressionMaskName(mask: number): string {
+  const parts: string[] = []
+  if (mask & COMPRESSION_HUFFMANN) parts.push('huffmann')
+  if (mask & COMPRESSION_ZLIB) parts.push('zlib')
+  if (mask & COMPRESSION_PKWARE) parts.push('pkware')
+  if (mask & COMPRESSION_BZIP2) parts.push('bzip2')
+  if (mask & COMPRESSION_SPARSE) parts.push('sparse')
+  if (mask & COMPRESSION_ADPCM_MONO) parts.push('adpcm-mono')
+  if (mask & COMPRESSION_ADPCM_STEREO) parts.push('adpcm-stereo')
+  return parts.length === 0 ? 'stored' : parts.join('+')
+}
+
+/**
+ * Inflate one zlib stream.
+ *
+ * @param data - zlib-wrapped deflate bytes.
+ * @returns the inflated bytes.
+ */
+async function inflateZlib(data: Uint8Array): Promise<Uint8Array> {
+  const stream = new Blob([data as BlobPart]).stream().pipeThrough(new DecompressionStream('deflate'))
+  return new Uint8Array(await new Response(stream).arrayBuffer())
+}
+
+/**
+ * Decode one compressed sector payload (mask byte included).
+ *
+ * @param input - the stored sector bytes, mask byte first.
+ * @param expectedSize - the sector's uncompressed length.
+ * @returns the decoded sector.
+ */
+export async function decompressSector(input: Uint8Array, expectedSize: number): Promise<Uint8Array> {
+  if (input.byteLength === 0) return input
+  const mask = input[0]!
+  if (mask === 0) {
+    // A zero mask marks a stored payload that merely carried the marker byte.
+    return input.subarray(1, 1 + expectedSize)
+  }
+  let current: Uint8Array = input.subarray(1)
+  let remaining = mask
+
+  if (remaining & COMPRESSION_HUFFMANN) {
+    throw new MpqCompressionError(`huffmann decoder not implemented yet (mask 0x${mask.toString(16)})`, mask)
+  }
+  if (remaining & COMPRESSION_ZLIB) {
+    current = await inflateZlib(current)
+    remaining &= ~COMPRESSION_ZLIB
+  }
+  if (remaining & COMPRESSION_PKWARE) {
+    // PKWARE is the last codec before bzip2/sparse/ADPCM in the reference
+    // order, so the payload it sees is already at its final length.
+    try {
+      current = explode(current, expectedSize)
+    } catch (err) {
+      const detail = err instanceof ImplodeError ? err.message : String(err)
+      throw new MpqCompressionError(`pkware implode failed: ${detail} (mask 0x${mask.toString(16)})`, mask)
+    }
+    remaining &= ~COMPRESSION_PKWARE
+  }
+  if (remaining & COMPRESSION_BZIP2) {
+    throw new MpqCompressionError(`bzip2 decoder not implemented yet (mask 0x${mask.toString(16)})`, mask)
+  }
+  if (remaining & COMPRESSION_SPARSE) {
+    throw new MpqCompressionError(`sparse decoder not implemented yet (mask 0x${mask.toString(16)})`, mask)
+  }
+  if (remaining & (COMPRESSION_ADPCM_MONO | COMPRESSION_ADPCM_STEREO)) {
+    throw new MpqCompressionError(`adpcm decoder not implemented yet (mask 0x${mask.toString(16)})`, mask)
+  }
+  if (remaining !== 0) {
+    throw new MpqCompressionError(`unknown compression bits 0x${remaining.toString(16)} (mask 0x${mask.toString(16)})`, mask)
+  }
+  if (current.byteLength !== expectedSize) {
+    throw new MpqCompressionError(
+      `decoded ${String(current.byteLength)} bytes, expected ${String(expectedSize)} (mask 0x${mask.toString(16)})`,
+      mask,
+    )
+  }
+  return current
+}
diff --git a/src/mpq/file-source.ts b/src/mpq/file-source.ts
new file mode 100644
index 0000000..7cb83a0
--- /dev/null
+++ b/src/mpq/file-source.ts
@@ -0,0 +1,37 @@
+/**
+ * Filesystem-backed source for Node-side tooling.
+ *
+ * Kept out of `source.ts` on purpose: a static `node:fs/promises` import in a
+ * module the browser bundle reaches makes bundlers externalize it and emit a
+ * compatibility warning, even though the browser never calls it.
+ */
+import type { MpqSource } from './source.ts'
+
+/**
+ * Build a source over a filesystem path.
+ *
+ * @param path - file path.
+ * @returns the source.
+ */
+export async function fileSource(path: string): Promise<MpqSource> {
+  const { open, stat } = await import('node:fs/promises')
+  const handle = await open(path, 'r')
+  const info = await stat(path)
+  return {
+    size: info.size,
+    label: path,
+    read: async (offset, length) => {
+      if (offset < 0 || offset + length > info.size) {
+        throw new RangeError(`${path}: read ${String(offset)}+${String(length)} beyond ${String(info.size)}`)
+      }
+      const buffer = new Uint8Array(length)
+      let done = 0
+      while (done < length) {
+        const { bytesRead } = await handle.read(buffer, done, length - done, offset + done)
+        if (bytesRead === 0) throw new Error(`${path}: short read at ${String(offset + done)}`)
+        done += bytesRead
+      }
+      return buffer
+    },
+  }
+}
diff --git a/src/mpq/implode-tables.ts b/src/mpq/implode-tables.ts
new file mode 100644
index 0000000..89b90b3
--- /dev/null
+++ b/src/mpq/implode-tables.ts
@@ -0,0 +1,108 @@
+/**
+ * PKWARE Data Compression Library ("implode") constant tables.
+ *
+ * Machine-transcribed from StormLib's `src/pklib/explode.c` (MIT, Copyright (c)
+ * Ladislav Zezula) — the values are data of the format, not choices: `LenCode`
+ * and `DistCode` are the canonical prefix codes, `LenBase`/`ExLenBits` the
+ * length extension, and `ChBitsAsc`/`ChCodeAsc` the literal alphabet used by
+ * the ASCII variant. They were parsed out of the C source by a script rather
+ * than retyped, because a single wrong nibble would decode some archives and
+ * silently corrupt others.
+ *
+ * Reference: <https://github.com/ladislav-zezula/StormLib/blob/master/src/pklib/explode.c>
+ *
+ * `ChBitsAsc` is a *template*: the ASCII path rewrites entries above 8 bits at
+ * startup, so {@link explode} copies it before use.
+ */
+
+/** `DistBits` from the reference (64 entries). */
+export const DISTBITS: readonly number[] = [
+  0x02, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+  0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+]
+
+/** `DistCode` from the reference (64 entries). */
+export const DISTCODE: readonly number[] = [
+  0x03, 0x0d, 0x05, 0x19, 0x09, 0x11, 0x01, 0x3e, 0x1e, 0x2e, 0x0e, 0x36, 0x16, 0x26, 0x06, 0x3a,
+  0x1a, 0x2a, 0x0a, 0x32, 0x12, 0x22, 0x42, 0x02, 0x7c, 0x3c, 0x5c, 0x1c, 0x6c, 0x2c, 0x4c, 0x0c,
+  0x74, 0x34, 0x54, 0x14, 0x64, 0x24, 0x44, 0x04, 0x78, 0x38, 0x58, 0x18, 0x68, 0x28, 0x48, 0x08,
+  0xf0, 0x70, 0xb0, 0x30, 0xd0, 0x50, 0x90, 0x10, 0xe0, 0x60, 0xa0, 0x20, 0xc0, 0x40, 0x80, 0x00,
+]
+
+/** `ExLenBits` from the reference (16 entries). */
+export const EXLENBITS: readonly number[] = [
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+]
+
+/** `LenBase` from the reference (16 entries). */
+export const LENBASE: readonly number[] = [
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0a, 0x0e, 0x16, 0x26, 0x46, 0x86, 0x106,
+]
+
+/** `LenBits` from the reference (16 entries). */
+export const LENBITS: readonly number[] = [
+  0x03, 0x02, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x07, 0x07,
+]
+
+/** `LenCode` from the reference (16 entries). */
+export const LENCODE: readonly number[] = [
+  0x05, 0x03, 0x01, 0x06, 0x0a, 0x02, 0x0c, 0x14, 0x04, 0x18, 0x08, 0x30, 0x10, 0x20, 0x40, 0x00,
+]
+
+/** `ChBitsAsc` from the reference (256 entries). */
+export const CHBITSASC: readonly number[] = [
+  0x0b, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x08, 0x07, 0x0c, 0x0c, 0x07, 0x0c, 0x0c,
+  0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+  0x04, 0x0a, 0x08, 0x0c, 0x0a, 0x0c, 0x0a, 0x08, 0x07, 0x07, 0x08, 0x09, 0x07, 0x06, 0x07, 0x08,
+  0x07, 0x06, 0x07, 0x07, 0x07, 0x07, 0x08, 0x07, 0x07, 0x08, 0x08, 0x0c, 0x0b, 0x07, 0x09, 0x0b,
+  0x0c, 0x06, 0x07, 0x06, 0x06, 0x05, 0x07, 0x08, 0x08, 0x06, 0x0b, 0x09, 0x06, 0x07, 0x06, 0x06,
+  0x07, 0x0b, 0x06, 0x06, 0x06, 0x07, 0x09, 0x08, 0x09, 0x09, 0x0b, 0x08, 0x0b, 0x09, 0x0c, 0x08,
+  0x0c, 0x05, 0x06, 0x06, 0x06, 0x05, 0x06, 0x06, 0x06, 0x05, 0x0b, 0x07, 0x05, 0x06, 0x05, 0x05,
+  0x06, 0x0a, 0x05, 0x05, 0x05, 0x05, 0x08, 0x07, 0x08, 0x08, 0x0a, 0x0b, 0x0b, 0x0c, 0x0c, 0x0c,
+  0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+  0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+  0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+  0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+  0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+  0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+  0x0d, 0x0c, 0x0d, 0x0d, 0x0d, 0x0c, 0x0d, 0x0d, 0x0d, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0c, 0x0d,
+  0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+]
+
+/** `ChCodeAsc` from the reference (256 entries). */
+export const CHCODEASC: readonly number[] = [
+  0x0490, 0x0fe0, 0x07e0, 0x0be0, 0x03e0, 0x0de0, 0x05e0, 0x09e0,
+  0x01e0, 0x00b8, 0x0062, 0x0ee0, 0x06e0, 0x0022, 0x0ae0, 0x02e0,
+  0x0ce0, 0x04e0, 0x08e0, 0x00e0, 0x0f60, 0x0760, 0x0b60, 0x0360,
+  0x0d60, 0x0560, 0x1240, 0x0960, 0x0160, 0x0e60, 0x0660, 0x0a60,
+  0x000f, 0x0250, 0x0038, 0x0260, 0x0050, 0x0c60, 0x0390, 0x00d8,
+  0x0042, 0x0002, 0x0058, 0x01b0, 0x007c, 0x0029, 0x003c, 0x0098,
+  0x005c, 0x0009, 0x001c, 0x006c, 0x002c, 0x004c, 0x0018, 0x000c,
+  0x0074, 0x00e8, 0x0068, 0x0460, 0x0090, 0x0034, 0x00b0, 0x0710,
+  0x0860, 0x0031, 0x0054, 0x0011, 0x0021, 0x0017, 0x0014, 0x00a8,
+  0x0028, 0x0001, 0x0310, 0x0130, 0x003e, 0x0064, 0x001e, 0x002e,
+  0x0024, 0x0510, 0x000e, 0x0036, 0x0016, 0x0044, 0x0030, 0x00c8,
+  0x01d0, 0x00d0, 0x0110, 0x0048, 0x0610, 0x0150, 0x0060, 0x0088,
+  0x0fa0, 0x0007, 0x0026, 0x0006, 0x003a, 0x001b, 0x001a, 0x002a,
+  0x000a, 0x000b, 0x0210, 0x0004, 0x0013, 0x0032, 0x0003, 0x001d,
+  0x0012, 0x0190, 0x000d, 0x0015, 0x0005, 0x0019, 0x0008, 0x0078,
+  0x00f0, 0x0070, 0x0290, 0x0410, 0x0010, 0x07a0, 0x0ba0, 0x03a0,
+  0x0240, 0x1c40, 0x0c40, 0x1440, 0x0440, 0x1840, 0x0840, 0x1040,
+  0x0040, 0x1f80, 0x0f80, 0x1780, 0x0780, 0x1b80, 0x0b80, 0x1380,
+  0x0380, 0x1d80, 0x0d80, 0x1580, 0x0580, 0x1980, 0x0980, 0x1180,
+  0x0180, 0x1e80, 0x0e80, 0x1680, 0x0680, 0x1a80, 0x0a80, 0x1280,
+  0x0280, 0x1c80, 0x0c80, 0x1480, 0x0480, 0x1880, 0x0880, 0x1080,
+  0x0080, 0x1f00, 0x0f00, 0x1700, 0x0700, 0x1b00, 0x0b00, 0x1300,
+  0x0da0, 0x05a0, 0x09a0, 0x01a0, 0x0ea0, 0x06a0, 0x0aa0, 0x02a0,
+  0x0ca0, 0x04a0, 0x08a0, 0x00a0, 0x0f20, 0x0720, 0x0b20, 0x0320,
+  0x0d20, 0x0520, 0x0920, 0x0120, 0x0e20, 0x0620, 0x0a20, 0x0220,
+  0x0c20, 0x0420, 0x0820, 0x0020, 0x0fc0, 0x07c0, 0x0bc0, 0x03c0,
+  0x0dc0, 0x05c0, 0x09c0, 0x01c0, 0x0ec0, 0x06c0, 0x0ac0, 0x02c0,
+  0x0cc0, 0x04c0, 0x08c0, 0x00c0, 0x0f40, 0x0740, 0x0b40, 0x0340,
+  0x0300, 0x0d40, 0x1d00, 0x0d00, 0x1500, 0x0540, 0x0500, 0x1900,
+  0x0900, 0x0940, 0x1100, 0x0100, 0x1e00, 0x0e00, 0x0140, 0x1600,
+  0x0600, 0x1a00, 0x0e40, 0x0640, 0x0a40, 0x0a00, 0x1200, 0x0200,
+  0x1c00, 0x0c00, 0x1400, 0x0400, 0x1800, 0x0800, 0x1000, 0x0000,
+]
diff --git a/src/mpq/implode.ts b/src/mpq/implode.ts
new file mode 100644
index 0000000..63dfa33
--- /dev/null
+++ b/src/mpq/implode.ts
@@ -0,0 +1,326 @@
+/**
+ * PKWARE Data Compression Library "implode" decoder.
+ *
+ * This is the codec behind `MPQ_COMPRESSION_PKWARE` (`mask 0x08`) — and behind
+ * every member flagged `MPQ_FILE_IMPLODE` without `MPQ_FILE_COMPRESS`, which is
+ * how Diablo II's `Patch_D2.mpq` stores its tables. Without it, real Diablo II
+ * archives are unreadable: the container opens and the block table enumerates,
+ * but every payload stays compressed.
+ *
+ * Semantics follow StormLib's `src/pklib/explode.c` (MIT, Copyright (c)
+ * Ladislav Zezula); the constant tables were machine-transcribed rather than
+ * retyped (see `implode-tables.ts`), so a wrong nibble cannot hide in a table.
+ *
+ * The stream is bit-oriented: a 16-bit window refills a byte at a time, and each
+ * symbol is either a literal (8 raw bits, or a code from the fixed literal
+ * alphabet in "ASCII" mode) or a back-reference. Diablo II uses both modes, so
+ * both are implemented.
+ *
+ * Two deliberate departures from the reference:
+ *
+ * 1. **A back-reference reaching before the start of the output is an error,
+ *    not a read of whatever the sliding window held.** The reference keeps a
+ *    0x2000-byte window and trusts the encoder to stay in range; here the
+ *    history *is* the output, so an out-of-range distance is provably corrupt
+ *    input.
+ * 2. **The output length is checked, never assumed.** The caller states the
+ *    expected size (the archive knows it from the block table) and a stream
+ *    that ends short or long throws. Padding with zeros produces a buffer that
+ *    decodes into plausible-looking nonsense — the exact failure this project
+ *    refuses to ship.
+ */
+import {
+  CHBITSASC, CHCODEASC, DISTBITS, DISTCODE, EXLENBITS, LENBASE, LENBITS, LENCODE,
+} from './implode-tables.ts'
+
+/** Compression type byte: literals are raw bytes. */
+export const CMP_BINARY = 0
+/** Compression type byte: literals come from the fixed ASCII alphabet. */
+export const CMP_ASCII = 1
+
+/** `DecodeLit` result meaning "end of stream". */
+const LIT_END_OF_STREAM = 0x305
+/** `DecodeLit` result meaning "malformed stream". */
+const LIT_ERROR = 0x306
+
+/** Raised when an implode stream cannot be decoded. */
+export class ImplodeError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'ImplodeError'
+  }
+}
+
+/**
+ * Build the "positions" table the decoder probes with the next 8 bits.
+ *
+ * Each code owns a span of `1 << bits` slots starting at its start index, so the
+ * table answers "which code is this prefix" in one indexed read.
+ *
+ * @param startIndexes - first slot of each code.
+ * @param lengthBits - code width in bits.
+ * @param elements - number of codes.
+ * @returns a 0x100-entry position table.
+ */
+function generateDecodeTabs(
+  startIndexes: readonly number[],
+  lengthBits: readonly number[],
+  elements: number,
+): Uint8Array {
+  const positions = new Uint8Array(0x100)
+  for (let i = 0; i < elements; i += 1) {
+    const length = 1 << lengthBits[i]!
+    for (let index = startIndexes[i]!; index < 0x100; index += length) positions[index] = i
+  }
+  return positions
+}
+
+/** The literal alphabet's derived tables, built once. */
+interface AsciiTables {
+  /** Per-character code width, with >8-bit entries rewritten as the reference does. */
+  readonly chBits: Uint8Array
+  /** First-level literal lookup (8 bits). */
+  readonly offs2C34: Uint8Array
+  /** Second-level lookup after 4 further bits. */
+  readonly offs2D34: Uint8Array
+  /** Second-level lookup after 6 further bits. */
+  readonly offs2E34: Uint8Array
+  /** Lookup used when the next 8 bits are all zero. */
+  readonly offs2EB4: Uint8Array
+}
+
+/**
+ * Derive the literal tables.
+ *
+ * A literal code wider than 8 bits is split: its low bits index a first-level
+ * table that marks the entry as "needs more bits" (`0xff`), and its high bits
+ * index a second-level table once 4 or 6 further bits are consumed. The
+ * reference rewrites `ChBitsAsc` in place while doing this, which is why the
+ * template gets copied here instead of shared.
+ *
+ * @returns the derived tables.
+ */
+function buildAsciiTables(): AsciiTables {
+  const chBits = Uint8Array.from(CHBITSASC)
+  const offs2C34 = new Uint8Array(0x100)
+  const offs2D34 = new Uint8Array(0x100)
+  const offs2E34 = new Uint8Array(0x100)
+  const offs2EB4 = new Uint8Array(0x100)
+
+  for (let count = 0xff; count >= 0; count -= 1) {
+    const code = CHCODEASC[count]!
+    let bits = chBits[count]!
+    if (bits <= 8) {
+      for (let acc = code; acc < 0x100; acc += 1 << bits) offs2C34[acc] = count
+      continue
+    }
+    const low = code & 0xff
+    if (low === 0) {
+      // The whole code sits above the first 8 bits: one second-level table.
+      bits -= 8
+      chBits[count] = bits
+      for (let acc = code >>> 8; acc < 0x100; acc += 1 << bits) offs2EB4[acc] = count
+      continue
+    }
+    offs2C34[low] = 0xff
+    if ((code & 0x3f) !== 0) {
+      bits -= 4
+      chBits[count] = bits
+      for (let acc = code >>> 4; acc < 0x100; acc += 1 << bits) offs2D34[acc] = count
+    } else {
+      bits -= 6
+      chBits[count] = bits
+      for (let acc = code >>> 6; acc < 0x80; acc += 1 << bits) offs2E34[acc] = count
+    }
+  }
+  return { chBits, offs2C34, offs2D34, offs2E34, offs2EB4 }
+}
+
+/** Length-code lookup, shared by every call. */
+const LENGTH_CODES = generateDecodeTabs(LENCODE, LENBITS, 0x10)
+/** Distance-code lookup, shared by every call. */
+const DISTANCE_CODES = generateDecodeTabs(DISTCODE, DISTBITS, 0x40)
+/** Literal alphabet tables, shared by every call. */
+const ASCII = buildAsciiTables()
+
+/**
+ * Bit-oriented reader over one compressed sector.
+ *
+ * `buffer` holds the next 8..16 bits, low bits first; `extraBits` counts the
+ * buffered bits beyond the low 8.
+ */
+class BitStream {
+  /** The compressed bytes. */
+  private readonly input: Uint8Array
+  /** Compression type byte (0 = binary literals, 1 = ASCII alphabet). */
+  readonly ctype: number
+  /** Dictionary width in bits (4..6). */
+  readonly dsizeBits: number
+  /** Position of the next byte to fold into the window. */
+  private position = 3
+  /** Buffered bits beyond the low 8. */
+  private extraBits = 0
+  /** The 16-bit window; the format reads past the low 8 bits directly. */
+  private buffer: number
+
+  constructor(input: Uint8Array, ctype: number, dsizeBits: number, initial: number) {
+    this.input = input
+    this.ctype = ctype
+    this.dsizeBits = dsizeBits
+    this.buffer = initial
+  }
+
+  /** Width mask for repetition distances. */
+  get dsizeMask(): number {
+    return 0xffff >>> (0x10 - this.dsizeBits)
+  }
+
+  /** The buffered window; the format reads beyond the low 8 bits directly. */
+  peek16(): number {
+    return this.buffer
+  }
+
+  /** The next 8 bits, without consuming them. */
+  peek8(): number {
+    return this.buffer & 0xff
+  }
+
+  /**
+   * Consume `bits` bits.
+   *
+   * @param bits - bit count (never more than 8 in this format).
+   * @returns true when the input ran out before the bits could be taken.
+   */
+  waste(bits: number): boolean {
+    if (bits <= this.extraBits) {
+      this.extraBits -= bits
+      this.buffer >>>= bits
+      return false
+    }
+    this.buffer >>>= this.extraBits
+    if (this.position >= this.input.length) return true
+    this.buffer |= this.input[this.position]! << 8
+    this.position += 1
+    this.buffer >>>= bits - this.extraBits
+    const rest = this.extraBits - bits + 8
+    if (rest < 0) throw new ImplodeError(`bit window underflow taking ${String(bits)} bits`)
+    this.extraBits = rest
+    return false
+  }
+}
+
+/**
+ * Decode one symbol.
+ *
+ * @param stream - the bit stream.
+ * @returns 0x00..0xff for a literal, `0x100 + (length - 2)` for a repetition,
+ *   0x305 at end of stream, 0x306 on a malformed stream.
+ */
+function decodeLit(stream: BitStream): number {
+  if ((stream.peek16() & 1) !== 0) {
+    if (stream.waste(1)) return LIT_ERROR
+    const lengthCode = LENGTH_CODES[stream.peek8()]!
+    if (stream.waste(LENBITS[lengthCode]!)) return LIT_ERROR
+    const extraLengthBits = EXLENBITS[lengthCode]!
+    if (extraLengthBits === 0) return lengthCode + 0x100
+    const extraLength = stream.peek16() & ((1 << extraLengthBits) - 1)
+    // A stream that runs dry here is tolerated for exactly one code — the
+    // reference's escape hatch for a final repetition, kept for bit parity.
+    if (stream.waste(extraLengthBits) && lengthCode + extraLength !== 0x10e) return LIT_ERROR
+    return LENBASE[lengthCode]! + extraLength + 0x100
+  }
+
+  if (stream.waste(1)) return LIT_ERROR
+  if (stream.ctype === CMP_BINARY) {
+    const byte = stream.peek8()
+    return stream.waste(8) ? LIT_ERROR : byte
+  }
+
+  let value: number
+  if (stream.peek8() !== 0) {
+    value = ASCII.offs2C34[stream.peek8()]!
+    if (value === 0xff) {
+      if ((stream.peek16() & 0x3f) !== 0) {
+        if (stream.waste(4)) return LIT_ERROR
+        value = ASCII.offs2D34[stream.peek8()]!
+      } else {
+        if (stream.waste(6)) return LIT_ERROR
+        value = ASCII.offs2E34[stream.peek16() & 0x7f]!
+      }
+    }
+  } else {
+    if (stream.waste(8)) return LIT_ERROR
+    value = ASCII.offs2EB4[stream.peek8()]!
+  }
+  return stream.waste(ASCII.chBits[value]!) ? LIT_ERROR : value
+}
+
+/**
+ * Decode a repetition's backward distance.
+ *
+ * @param stream - the bit stream.
+ * @param repLength - the repetition length already decoded.
+ * @returns the distance in bytes (1-based), or 0 when the stream ended.
+ */
+function decodeDist(stream: BitStream, repLength: number): number {
+  const distPosCode = DISTANCE_CODES[stream.peek8()]!
+  if (stream.waste(DISTBITS[distPosCode]!)) return 0
+  if (repLength === 2) {
+    // Two-byte repetitions carry two extra bits instead of the full dictionary
+    // width: the encoder knows a distance in 4..(4*distPosCode+3) range.
+    const distance = (distPosCode << 2) | (stream.peek16() & 0x03)
+    return stream.waste(2) ? 0 : distance + 1
+  }
+  const distance = (distPosCode << stream.dsizeBits) | (stream.peek16() & stream.dsizeMask)
+  return stream.waste(stream.dsizeBits) ? 0 : distance + 1
+}
+
+/**
+ * Decode a whole implode stream into exactly `expectedSize` bytes.
+ *
+ * @param input - the compressed bytes, stream header included.
+ * @param expectedSize - the uncompressed length the archive declares.
+ * @returns the decoded bytes.
+ */
+export function explode(input: Uint8Array, expectedSize: number): Uint8Array {
+  if (input.length <= 4) throw new ImplodeError(`implode stream too short (${String(input.length)} bytes)`)
+  const ctype = input[0]!
+  const dsizeBits = input[1]!
+  if (ctype !== CMP_BINARY && ctype !== CMP_ASCII) throw new ImplodeError(`unknown implode mode ${String(ctype)}`)
+  if (dsizeBits < 4 || dsizeBits > 6) throw new ImplodeError(`invalid implode dictionary size ${String(dsizeBits)}`)
+  const stream = new BitStream(input, ctype, dsizeBits, input[2]!)
+
+  const out = new Uint8Array(expectedSize)
+  let written = 0
+  for (;;) {
+    const literal = decodeLit(stream)
+    if (literal === LIT_ERROR) throw new ImplodeError('implode stream ended mid-symbol')
+    if (literal === LIT_END_OF_STREAM) break
+    if (literal >= 0x100) {
+      const repLength = literal - 0xfe
+      const minusDist = decodeDist(stream, repLength)
+      if (minusDist === 0) throw new ImplodeError('implode stream ended inside a repetition')
+      const source = written - minusDist
+      if (source < 0) {
+        throw new ImplodeError(`back-reference ${String(minusDist)} bytes before the start of the output`)
+      }
+      if (written + repLength > expectedSize) {
+        throw new ImplodeError(`output overflow: ${String(written + repLength)} > ${String(expectedSize)}`)
+      }
+      // Byte at a time on purpose: when the encoder stored a run, the
+      // repetition overlaps itself, and that overlap is part of the format.
+      for (let i = 0; i < repLength; i += 1) out[written + i] = out[source + i]!
+      written += repLength
+    } else {
+      if (written >= expectedSize) {
+        throw new ImplodeError(`output overflow at byte ${String(written)} (expected ${String(expectedSize)})`)
+      }
+      out[written] = literal
+      written += 1
+    }
+  }
+  if (written !== expectedSize) {
+    throw new ImplodeError(`decoded ${String(written)} bytes, expected ${String(expectedSize)}`)
+  }
+  return out
+}
diff --git a/src/mpq/index.ts b/src/mpq/index.ts
new file mode 100644
index 0000000..e70fe31
--- /dev/null
+++ b/src/mpq/index.ts
@@ -0,0 +1,7 @@
+/**
+ * MPQ container layer: archive reading over any random-access source.
+ */
+export * from './archive.ts'
+export * from './crypt.ts'
+export * from './decompress.ts'
+export * from './source.ts'
diff --git a/src/mpq/mount.ts b/src/mpq/mount.ts
new file mode 100644
index 0000000..3135303
--- /dev/null
+++ b/src/mpq/mount.ts
@@ -0,0 +1,134 @@
+/**
+ * Several MPQ archives mounted as one namespace.
+ *
+ * Diablo II does not read one archive, it reads a stack. The game data lives in
+ * `d2data.mpq`, the expansion overrides parts of it in `d2exp.mpq`, and the 1.13
+ * patch overrides both from `Patch_D2.mpq`; character art sits in `d2char.mpq`.
+ * The rule is overlay semantics: **the last archive mounted wins**, so a caller
+ * mounts in load order (`d2data`, `d2exp`, `Patch_D2`) and never has to ask
+ * which archive a file came from.
+ *
+ * Lookups go through the name, not the block table index, because an encrypted
+ * member's key is derived from its name: a member reached as "block 5383" would
+ * decrypt to noise. `d2exp.mpq` alone has 585 such members.
+ */
+import type { MpqArchive, MpqFile } from './archive.ts'
+
+/** One mounted archive and the label it is known by. */
+export interface MountEntry {
+  /** Human-readable identity, e.g. the file name. */
+  readonly label: string
+  /** The open archive. */
+  readonly archive: MpqArchive
+}
+
+/** A member resolved to the archive that will serve it. */
+export interface MountedFile {
+  /** The archive that won the lookup. */
+  readonly entry: MountEntry
+  /** The member within it. */
+  readonly file: MpqFile
+}
+
+/** A stack of archives searched last-to-first. */
+export class MountedArchives {
+  private readonly entries: MountEntry[] = []
+  /** Cached union of every archive's name list, invalidated on `add`. */
+  private names: string[] | null = null
+
+  /**
+   * Mount an archive on top of the stack.
+   *
+   * @param label - identity for diagnostics.
+   * @param archive - the open archive.
+   */
+  add(label: string, archive: MpqArchive): void {
+    this.entries.push({ label, archive })
+    this.names = null
+  }
+
+  /** The mounted archives, in load order. */
+  get mounted(): readonly MountEntry[] {
+    return this.entries
+  }
+
+  /** How many archives are mounted. */
+  get size(): number {
+    return this.entries.length
+  }
+
+  /**
+   * Find a member, preferring the most recently mounted archive.
+   *
+   * @param name - member name, either separator.
+   * @returns the winning archive and member, or undefined.
+   */
+  find(name: string): MountedFile | undefined {
+    for (let index = this.entries.length - 1; index >= 0; index -= 1) {
+      const entry = this.entries[index]!
+      const file = entry.archive.find(name)
+      if (file !== undefined) return { entry, file }
+    }
+    return undefined
+  }
+
+  /**
+   * Whether any mounted archive has a member.
+   *
+   * @param name - member name.
+   * @returns true when present.
+   */
+  has(name: string): boolean {
+    return this.find(name) !== undefined
+  }
+
+  /**
+   * Read and decode a member.
+   *
+   * @param name - member name.
+   * @returns the decoded bytes.
+   */
+  async read(name: string): Promise<Uint8Array> {
+    const found = this.find(name)
+    if (found === undefined) throw new Error(`mounted archives have no member ${name}`)
+    return found.entry.archive.read(found.file)
+  }
+
+  /**
+   * Every member name across the stack, deduplicated.
+   *
+   * A name is only listed once: with overlay semantics the archive that wins the
+   * lookup is the one that matters, and duplicate entries would make pickers and
+   * listings lie about it.
+   *
+   * @returns the name list, sorted.
+   */
+  async listFiles(): Promise<string[]> {
+    if (this.names !== null) return this.names
+    const seen = new Set<string>()
+    for (const entry of this.entries) {
+      let names: readonly string[]
+      try {
+        names = await entry.archive.listFiles()
+      } catch {
+        // An archive whose (listfile) cannot be decoded contributes no names;
+        // its members are still reachable by explicit name.
+        continue
+      }
+      for (const name of names) seen.add(name)
+    }
+    this.names = [...seen].sort()
+    return this.names
+  }
+
+  /**
+   * A description of the stack, for HUDs and reports.
+   *
+   * @returns one line per archive plus a total.
+   */
+  describe(): string[] {
+    const lines = this.entries.map(entry => `${entry.label}: ${String(entry.archive.files().length)} block slots`)
+    lines.push(`total: ${String(this.entries.length)} archives`)
+    return lines
+  }
+}
diff --git a/src/mpq/source.ts b/src/mpq/source.ts
new file mode 100644
index 0000000..49a220f
--- /dev/null
+++ b/src/mpq/source.ts
@@ -0,0 +1,140 @@
+/**
+ * Random-access byte sources for archive reading.
+ *
+ * The engine never loads a whole MPQ into memory: a dragged-in `File` (or an
+ * HTTP range endpoint) is read on demand, so multi-hundred-megabyte archives
+ * stay out of the JS heap and only the sectors actually used are touched.
+ */
+
+/** Random-access read port consumed by {@link MpqArchive}. */
+export interface MpqSource {
+  /** Total size in bytes. */
+  readonly size: number
+  /** Human-readable identity, for diagnostics and error messages. */
+  readonly label: string
+  /**
+   * Read an exact byte range.
+   *
+   * @param offset - absolute byte offset.
+   * @param length - number of bytes; the result is always exactly this long.
+   * @returns the requested bytes.
+   */
+  read(offset: number, length: number): Promise<Uint8Array>
+}
+
+/**
+ * Build a source over an in-memory buffer (tests, small archives, Node CLI).
+ *
+ * @param data - the archive bytes.
+ * @param label - identity shown in diagnostics.
+ * @returns the source.
+ */
+export function memorySource(data: Uint8Array, label = 'memory'): MpqSource {
+  return {
+    size: data.byteLength,
+    label,
+    read: async (offset, length) => {
+      if (offset < 0 || offset + length > data.byteLength) {
+        throw new RangeError(`${label}: read ${String(offset)}+${String(length)} beyond ${String(data.byteLength)}`)
+      }
+      return data.subarray(offset, offset + length)
+    },
+  }
+}
+
+/**
+ * Build a source over a browser `Blob`/`File` (drag & drop, `<input type=file>`,
+ * OPFS handles all expose a Blob).
+ *
+ * @param blob - the blob to read.
+ * @param label - identity shown in diagnostics.
+ * @returns the source.
+ */
+export function blobSource(blob: Blob, label = blob instanceof File ? blob.name : 'blob'): MpqSource {
+  return {
+    size: blob.size,
+    label,
+    read: async (offset, length) => {
+      if (offset < 0 || offset + length > blob.size) {
+        throw new RangeError(`${label}: read ${String(offset)}+${String(length)} beyond ${String(blob.size)}`)
+      }
+      return new Uint8Array(await blob.slice(offset, offset + length).arrayBuffer())
+    },
+  }
+}
+
+/**
+ * Build a bounded view over another source, so per-file reads stay inside one file's
+ * extent (a corrupt offset table then fails loudly instead of reading into a
+ * neighbour).
+ *
+ * @param source - the underlying source.
+ * @param start - window start offset.
+ * @param length - window length.
+ * @returns the windowed source.
+ */
+export function windowSource(source: MpqSource, start: number, length: number): MpqSource {
+  return {
+    size: length,
+    label: source.label,
+    read: (offset, count) => source.read(start + offset, count),
+  }
+}
+
+/** Bytes to probe with when deciding whether a server honours `Range`. */
+const RANGE_PROBE_BYTES = 32
+
+/**
+ * Build a source over HTTP, reading only the byte ranges asked for.
+ *
+ * A Diablo II archive stack is ~1.9 GB, so downloading it into a browser tab is
+ * not an option; the reader's random-access design exists precisely so a page
+ * can pull the hash table, the block table and the sectors it needs. That
+ * depends on the server answering `Range` requests with 206, which is probed
+ * once up front:
+ *
+ * - **206**: every read becomes a ranged `fetch`.
+ * - **200**: the server ignored the range and started sending the whole file.
+ *   Rather than silently mis-reading (the response body would be the file's
+ *   *start*, not the requested offset), the source refuses to be built and the
+ *   caller reports it. Serving the samples directory with `npm run dev` does
+ *   support ranges, so this is a real fallback, not the expected path.
+ *
+ * @param url - archive URL.
+ * @param label - identity for diagnostics.
+ * @returns the source.
+ */
+export async function httpRangeSource(url: string, label = url): Promise<MpqSource> {
+  const probe = await fetch(url, { headers: { Range: `bytes=0-${String(RANGE_PROBE_BYTES - 1)}` } })
+  if (probe.status !== 206) {
+    const type = probe.headers.get('content-type') ?? 'unknown'
+    throw new Error(
+      `${label}: server answered ${String(probe.status)} (${type}) instead of 206 — `
+      + 'range requests are required to read an archive this large',
+    )
+  }
+  const contentRange = probe.headers.get('content-range') ?? ''
+  const total = Number(/\/(\d+)$/.exec(contentRange)?.[1] ?? '0')
+  probe.body?.cancel().catch(() => {})
+  if (!Number.isFinite(total) || total <= 0) {
+    throw new Error(`${label}: server sent no usable Content-Range total (${contentRange})`)
+  }
+  return {
+    size: total,
+    label,
+    read: async (offset, length) => {
+      if (offset < 0 || offset + length > total) {
+        throw new RangeError(`${label}: read ${String(offset)}+${String(length)} beyond ${String(total)}`)
+      }
+      const response = await fetch(url, { headers: { Range: `bytes=${String(offset)}-${String(offset + length - 1)}` } })
+      if (response.status !== 206 && response.status !== 200) {
+        throw new Error(`${label}: range read failed with HTTP ${String(response.status)}`)
+      }
+      const buffer = new Uint8Array(await response.arrayBuffer())
+      if (buffer.byteLength !== length) {
+        throw new Error(`${label}: asked for ${String(length)} bytes at ${String(offset)}, got ${String(buffer.byteLength)}`)
+      }
+      return buffer
+    },
+  }
+}
diff --git a/src/net/lockstep.ts b/src/net/lockstep.ts
new file mode 100644
index 0000000..8e94c52
--- /dev/null
+++ b/src/net/lockstep.ts
@@ -0,0 +1,230 @@
+/**
+ * Deterministic lockstep session.
+ *
+ * Multiplayer in Diablo II is not server-authoritative: every peer simulates the
+ * whole world and they only exchange *inputs*. That only works if the simulation
+ * is a pure function of (previous state, this tick's inputs) — which is why the
+ * random number generator has been seeded and explicit since the item system, and
+ * why nothing in the simulation reads a clock.
+ *
+ * This module owns the three things that make lockstep work:
+ *
+ * 1. **A tick runs only when every peer's input for it has arrived.** A peer that
+ *    guesses, or runs ahead on partial input, is a peer that diverges. Waiting is
+ *    the correct behaviour, so {@link LockstepSession.step} reports `waiting`
+ *    rather than advancing.
+ * 2. **Input delay.** Real networks deliver late, so each tick's inputs are due
+ *    `inputDelayTicks` ahead of the tick that consumes them — the standard way to
+ *    trade a little response latency for never stalling.
+ * 3. **Per-tick state hashes.** Peers exchange hashes and compare them; the first
+ *    tick whose hash differs is a desync, and knowing *which* tick diverged is
+ *    what makes the bug findable at all.
+ *
+ * The transport is deliberately an interface, not an implementation: the tests
+ * drive it in memory, and a browser build can back it with a WebSocket or an
+ * RTCDataChannel without this file changing.
+ */
+
+/** One tick's input from one peer. */
+export interface InputFrame {
+  /** Tick the frame is for. */
+  readonly tick: number
+  /** Movement request, screen axes. */
+  readonly movement: { readonly x: number; readonly y: number }
+  /** Attack control. */
+  readonly attack: boolean
+  /** Pickup control. */
+  readonly pickup: boolean
+  /** Talk control. */
+  readonly talk: boolean
+  /** Selected skill slot. */
+  readonly skill: number
+}
+
+/** A peer's claim about a tick's resulting state. */
+export interface StateHash {
+  /** The tick the hash is for. */
+  readonly tick: number
+  /** The peer's state digest for that tick. */
+  readonly hash: number
+}
+
+/** Session configuration. */
+export interface LockstepOptions {
+  /** How many peers must supply input. */
+  readonly peers: number
+  /** Ticks of input delay, i.e. the latency budget. */
+  readonly inputDelayTicks: number
+  /** How many past hashes to keep for comparison. */
+  readonly historyTicks?: number
+}
+
+/** What one call to {@link LockstepSession.step} did. */
+export type StepOutcome =
+  | { readonly kind: 'stepped'; readonly tick: number; readonly hash: number }
+  | { readonly kind: 'waiting'; readonly tick: number; readonly missing: readonly number[] }
+  | { readonly kind: 'desync'; readonly tick: number; readonly local: number; readonly remote: number }
+
+/** A desync report. */
+export interface DesyncReport {
+  /** The first tick whose hashes disagree. */
+  readonly tick: number
+  /** The local hash. */
+  readonly local: number
+  /** The remote hash. */
+  readonly remote: number
+}
+
+/** The simulation a session drives. */
+export interface LockstepSimulation {
+  /**
+   * Advance the world by exactly one tick.
+   *
+   * Must be a pure function of the previous state and these inputs: no clocks, no
+   * unseeded randomness, no host queries.
+   *
+   * @param inputs - one frame per peer, in peer order.
+   */
+  advance: (inputs: readonly InputFrame[]) => void
+  /**
+   * Digest the world's state.
+   *
+   * Must cover everything peers could disagree about; a field left out is a
+   * divergence that goes unnoticed until it affects something visible.
+   *
+   * @returns a 32-bit digest.
+   */
+  hash: () => number
+}
+
+/** Number of past hashes kept for late comparisons. */
+const DEFAULT_HISTORY = 64
+
+/**
+ * One lockstep session: input inbox, tick clock and hash history.
+ */
+export class LockstepSession {
+  private readonly options: LockstepOptions
+  private readonly simulation: LockstepSimulation
+  private readonly inputs = new Map<number, Map<number, InputFrame>>()
+  private readonly hashes: StateHash[] = []
+  private currentTick = 0
+  private stallTicks = 0
+  private desync: DesyncReport | null = null
+
+  /**
+   * @param options - session configuration.
+   * @param simulation - the simulation to drive.
+   */
+  constructor(options: LockstepOptions, simulation: LockstepSimulation) {
+    this.options = options
+    this.simulation = simulation
+    for (let peer = 0; peer < options.peers; peer += 1) this.inputs.set(peer, new Map())
+  }
+
+  /** The next tick that has not run yet. */
+  get tick(): number {
+    return this.currentTick
+  }
+
+  /** How many consecutive calls could not advance for want of input. */
+  get stalls(): number {
+    return this.stallTicks
+  }
+
+  /** The first desync seen, if any. */
+  get desyncReport(): DesyncReport | null {
+    return this.desync
+  }
+
+  /** Recent per-tick hashes, oldest first. */
+  get history(): readonly StateHash[] {
+    return this.hashes
+  }
+
+  /**
+   * Accept an input frame from a peer.
+   *
+   * Frames for ticks that already ran are dropped: replaying them would change
+   * history, and a peer that sends stale input is late, not authoritative.
+   *
+   * @param peer - the peer's index.
+   * @param frame - the frame.
+   * @returns true when the frame was accepted.
+   */
+  submit(peer: number, frame: InputFrame): boolean {
+    if (!this.inputs.has(peer)) throw new Error(`unknown peer ${String(peer)}`)
+    if (frame.tick < this.currentTick) return false
+    this.inputs.get(peer)!.set(frame.tick, frame)
+    return true
+  }
+
+  /**
+   * Run one tick if every peer's input for it is present.
+   *
+   * @returns what happened.
+   */
+  step(): StepOutcome {
+    const tick = this.currentTick
+    const missing: number[] = []
+    const frames: InputFrame[] = []
+    for (let peer = 0; peer < this.options.peers; peer += 1) {
+      const frame = this.inputs.get(peer)?.get(tick)
+      if (frame === undefined) { missing.push(peer); continue }
+      frames.push(frame)
+    }
+    if (missing.length > 0) {
+      this.stallTicks += 1
+      return { kind: 'waiting', tick, missing }
+    }
+
+    this.simulation.advance(frames)
+    const hash = this.simulation.hash()
+    this.hashes.push({ tick, hash })
+    if (this.hashes.length > (this.options.historyTicks ?? DEFAULT_HISTORY)) this.hashes.shift()
+    for (const peer of this.inputs.keys()) this.inputs.get(peer)!.delete(tick)
+    this.currentTick += 1
+    this.stallTicks = 0
+    return { kind: 'stepped', tick, hash }
+  }
+
+  /**
+   * The input delay a peer should target when submitting.
+   *
+   * @returns the tick a frame submitted now should be for.
+   */
+  get inputDueTick(): number {
+    return this.currentTick + this.options.inputDelayTicks
+  }
+
+  /**
+   * Compare a peer's hash for a tick against the local one.
+   *
+   * @param remote - the peer's claim.
+   * @returns the desync report when they disagree, null when they agree or the
+   * tick is not in local history.
+   */
+  compare(remote: StateHash): DesyncReport | null {
+    const local = this.hashes.find(entry => entry.tick === remote.tick)
+    if (local === undefined) return null
+    if (local.hash === remote.hash) return null
+    this.desync ??= { tick: remote.tick, local: local.hash, remote: remote.hash }
+    return this.desync
+  }
+
+  /**
+   * Digest a byte string into the same 32-bit space as the state hashes, so a
+   * caller can hash whatever it likes consistently.
+   *
+   * @param text - the input.
+   * @returns the digest.
+   */
+  static digest(text: string): number {
+    let hash = 2166136261
+    for (let index = 0; index < text.length; index += 1) {
+      hash ^= text.charCodeAt(index)
+      hash = Math.imul(hash, 16777619) >>> 0
+    }
+    return hash >>> 0
+  }
+}
diff --git a/src/net/netplay.ts b/src/net/netplay.ts
new file mode 100644
index 0000000..a857675
--- /dev/null
+++ b/src/net/netplay.ts
@@ -0,0 +1,522 @@
+/**
+ * Networked lockstep session: a {@link LockstepSession} wired to a {@link Transport}.
+ *
+ * The lockstep core knows nothing about sockets, and the transport knows nothing
+ * about ticks; this file is the seam. Each call to {@link NetplaySession.pump}
+ * does exactly four things, in order:
+ *
+ * 1. **Drain** everything the peer sent into the lockstep inbox.
+ * 2. **Send** our input for the tick that is due now (`tick + inputDelay`), and a
+ *    state hash for every tick we have finished since the last hash we sent.
+ * 3. **Run** one tick, if all inputs are present.
+ * 4. **Announce** our own hash when a tick completes, and compare any peer hash
+ *    that arrived for that tick.
+ *
+ * A peer that goes quiet is not a divergence: the session reports `waiting` and
+ * holds the world still. Only a hash mismatch is a divergence, and the first
+ * mismatching tick is recorded with both digests. A peer that never arrives at
+ * all is a *timeout*, kept separate from a desync — different problem, different
+ * response (drop the peer versus stop and resync).
+ */
+import { LockstepSession, type DesyncReport, type InputFrame, type LockstepOptions, type LockstepSimulation, type StateHash, type StepOutcome } from './lockstep.ts'
+import { decodeMessage, encodeMessage, NO_ACK, ProtocolError, type NetMessage } from './protocol.ts'
+import type { Transport } from './transport.ts'
+
+/** Pumps between repeated handshake attempts, until the peer answers. */
+const HANDSHAKE_RETRY_PUMPS = 25
+
+/** Session configuration beyond the lockstep core's own options. */
+export interface NetplayOptions extends LockstepOptions {
+  /** This peer's index. */
+  readonly peer: number
+  /** World seed, exchanged in the handshake. */
+  readonly seed: number
+  /** Send a state hash every this many ticks. Defaults to 5. */
+  readonly hashInterval?: number
+  /**
+   * Consecutive ticks that may pass without *any* message from the peer before it
+   * is declared lost. Defaults to 250, i.e. ten seconds at 25 Hz.
+   *
+   * Counted in attempts to run a tick rather than in ticks that ran: a stalled
+   * world does not advance its own clock, so a tick-based deadline would never
+   * expire in exactly the case it exists for.
+   */
+  readonly timeoutTicks?: number
+}
+
+/** Running counters, for the HUD and for tests. */
+export interface NetplayStats {
+  /** This peer's index. */
+  readonly peer: number
+  /** Messages sent. */
+  readonly sent: number
+  /** Messages received and decoded. */
+  readonly received: number
+  /** Messages that arrived but failed to decode. */
+  readonly malformed: number
+  /** Ticks that could not run because the peer's input had not arrived. */
+  readonly waiting: number
+  /** Ticks that ran. */
+  readonly stepped: number
+  /** Peer hashes received and compared. */
+  readonly hashesCompared: number
+  /** Peer hashes that agreed. */
+  readonly hashesAgreed: number
+  /**
+   * Peer hashes for ticks no longer in local history.
+   *
+   * Counted separately because such a hash *cannot* be checked: reporting it as an
+   * agreement would be claiming verification that did not happen.
+   */
+  readonly hashesIgnored: number
+  /** Whether the handshake completed. */
+  readonly handshaked: boolean
+  /** Handshake messages sent, counting retries and acknowledgements. */
+  readonly helloSent: number
+  /** Whether every peer has heard this peer's hello. */
+  readonly acknowledged: boolean
+  /** How many of the other peers this peer has heard from. */
+  readonly peersHeard: number
+  /** How many peers are expected, this one excluded. */
+  readonly peersExpected: number
+  /** Whether enough is known about every peer to run the game. */
+  readonly ready: boolean
+  /** Whether the peer has timed out. */
+  readonly timedOut: boolean
+  /** Whether the pipe is open. */
+  readonly connected: boolean
+}
+
+/** What a session knows about one other peer. */
+interface PeerLink {
+  /** Whether a hello has arrived from it. */
+  heard: boolean
+  /** The world seed it announced, or -1. */
+  seed: number
+  /** Whether it has acknowledged this peer's hello. */
+  ackedBy: boolean
+  /** Whether this peer has acknowledged its hello. */
+  ackSent: boolean
+}
+
+/**
+ * One peer's end of a networked game.
+ */
+export class NetplaySession {
+  /** The lockstep core, exposed so callers can read tick, history and desyncs. */
+  readonly lockstep: LockstepSession
+  private readonly options: NetplayOptions
+  private readonly transport: Transport
+  private localIntent: Omit<InputFrame, 'tick'> = { movement: { x: 0, y: 0 }, attack: false, pickup: false, talk: false, skill: 0 }
+  private sent = 0
+  private received = 0
+  private malformed = 0
+  private waiting = 0
+  private stepped = 0
+  private hashesCompared = 0
+  private hashesAgreed = 0
+  private hashesIgnored = 0
+  private lastHashSent = -1
+  /** Highest tick this peer has queued input for; the pipe's send cursor. */
+  private nextSendTick = 0
+  /**
+   * Peer hashes waiting for the local world to reach their tick.
+   *
+   * A hash arrives the moment the peer computes it, which is usually a tick or two
+   * *before* this peer has run that tick — and a hash for a tick that has not run
+   * cannot be checked. Dropping those would leave the lagging peer verifying
+   * almost nothing, which is the opposite of what the check is for. They are held
+   * here instead and checked the moment local history catches up.
+   */
+  private readonly pendingRemoteHashes = new Map<number, number>()
+  /** Pumps since the peer last said anything. */
+  private silentTicks = 0
+  private handshaked = false
+  private handshakeOwed = false
+  private helloSent = 0
+  private pumpsSinceHello = 0
+  private timedOut = false
+  private mismatchedSeed: number | null = null
+  private closed = false
+  /**
+   * What is known about each other peer.
+   *
+   * Per peer, because a session of four cannot keep one flag for "the peer": it
+   * has to remember which of them has been heard from, whose world seed has been
+   * checked, and whose hello has been acknowledged — otherwise one late joiner
+   * either blocks the game silently or is never told the seed.
+   */
+  private readonly links = new Map<number, PeerLink>()
+
+  /**
+   * @param options - session configuration.
+   * @param simulation - the simulation to drive.
+   * @param transport - the byte pipe to the peer.
+   */
+  constructor(options: NetplayOptions, simulation: LockstepSimulation, transport: Transport) {
+    this.options = options
+    this.transport = transport
+    this.lockstep = new LockstepSession(options, simulation)
+    transport.onMessage(data => { this.receive(data) })
+    transport.onClose(() => { this.closed = true })
+  }
+
+  /** This peer's index. */
+  get peer(): number {
+    return this.options.peer
+  }
+
+  /** The lowest-numbered other peer's announced seed, or -1 before the handshake. */
+  get remoteSeed(): number {
+    return this.links.get(this.otherPeers()[0] ?? -1)?.seed ?? -1
+  }
+
+  /** Every other peer's announced seed, by peer index. */
+  get peerSeeds(): readonly { readonly peer: number; readonly seed: number }[] {
+    return this.otherPeers().map(peer => ({ peer, seed: this.links.get(peer)?.seed ?? -1 }))
+  }
+
+  /** The peer indices this session expects to hear from, this one excluded. */
+  private otherPeers(): number[] {
+    const peers: number[] = []
+    for (let peer = 0; peer < this.options.peers; peer += 1) {
+      if (peer !== this.options.peer) peers.push(peer)
+    }
+    return peers
+  }
+
+  /**
+   * The link record for a peer, created on first use.
+   *
+   * @param peer - the peer index.
+   * @returns its record.
+   */
+  private linkOf(peer: number): PeerLink {
+    const existing = this.links.get(peer)
+    if (existing !== undefined) return existing
+    const created: PeerLink = { heard: false, seed: -1, ackedBy: false, ackSent: false }
+    this.links.set(peer, created)
+    return created
+  }
+
+  /**
+   * The peer's world seed when it differs from this one, otherwise null.
+   *
+   * Two peers that disagree about the seed build different worlds; saying so at
+   * the handshake is far better than letting it surface later as a desync.
+   */
+  get seedMismatch(): number | null {
+    return this.mismatchedSeed
+  }
+
+  /** The first desync seen, if any. */
+  get desyncReport(): DesyncReport | null {
+    return this.lockstep.desyncReport
+  }
+
+  /** Counters for the HUD and for tests. */
+  get stats(): NetplayStats {
+    return {
+      peer: this.options.peer,
+      sent: this.sent,
+      received: this.received,
+      malformed: this.malformed,
+      waiting: this.waiting,
+      stepped: this.stepped,
+      hashesCompared: this.hashesCompared,
+      hashesAgreed: this.hashesAgreed,
+      hashesIgnored: this.hashesIgnored,
+      handshaked: this.handshaked,
+      helloSent: this.helloSent,
+      acknowledged: this.acknowledged,
+      peersHeard: this.peersHeard,
+      peersExpected: this.otherPeers().length,
+      ready: this.ready,
+      timedOut: this.timedOut,
+      connected: this.transport.open && !this.closed,
+    }
+  }
+
+  /**
+   * Introduce this peer to the other end.
+   *
+   * The message may not go out immediately: a session is usually created in the
+   * same breath as its socket, which is still connecting. The hello is therefore
+   * owed rather than sent, and {@link pump} delivers it as soon as the pipe opens
+   * — repeatedly, until the peer answers.
+   */
+  start(): void {
+    this.handshakeOwed = true
+  }
+
+  /**
+   * Whether the game may run yet.
+   *
+   * A session that was told to network waits for the handshake. Without this gate
+   * a peer happily sends its first inputs into a relay that has nobody to forward
+   * them to — the sender cannot tell — and then waits forever for inputs it will
+   * never receive, because its own first frames were dropped in the void. The
+   * handshake is the only way to know the other end is listening.
+   */
+  private get ready(): boolean {
+    if (!this.handshakeOwed) return true
+    return this.otherPeers().every(peer => this.links.get(peer)?.heard === true)
+  }
+
+  /** How many other peers this session has heard from. */
+  private get peersHeard(): number {
+    return this.otherPeers().filter(peer => this.links.get(peer)?.heard === true).length
+  }
+
+  /** Whether every other peer has heard this peer's hello. */
+  private get acknowledged(): boolean {
+    return this.otherPeers().every(peer => this.links.get(peer)?.ackedBy === true)
+  }
+
+  /**
+   * Send the hello when it is owed and the pipe is open, retrying until the peer
+   * answers so that a handshake lost to a moment of disconnection still lands.
+   */
+  private ensureHandshake(): void {
+    if (!this.handshakeOwed || !this.transport.open || this.acknowledged) return
+    // The hello is repeated until every peer *acknowledges* it, not merely until
+    // peers are heard from. "I heard you" and "you heard me" are different facts,
+    // and a session that only tracks the first goes on waiting for input from
+    // someone who is waiting for its hello — which is exactly the deadlock the
+    // acknowledgement exists to prevent.
+    if (this.helloSent > 0 && this.pumpsSinceHello < HANDSHAKE_RETRY_PUMPS) {
+      this.pumpsSinceHello += 1
+      return
+    }
+    this.pumpsSinceHello = 0
+    this.sendHello(NO_ACK)
+  }
+
+  /**
+   * Send a hello.
+   *
+   * @param ackTo - the peer being acknowledged, or {@link NO_ACK} for a plain
+   * introduction. With one broadcast pipe for every peer, an unaddressed
+   * acknowledgement would be read as one by peers it was never meant for.
+   */
+  private sendHello(ackTo: number): void {
+    this.helloSent += 1
+    this.send({ kind: 'hello', peer: this.options.peer, peers: this.options.peers, seed: this.options.seed, ackTo })
+  }
+
+  /** Say goodbye before closing the pipe. */
+  leave(): void {
+    this.send({ kind: 'bye', peer: this.options.peer })
+    this.closed = true
+    this.transport.close()
+  }
+
+  /**
+   * Stage this tick's local input. Applied on the next {@link pump}.
+   *
+   * @param intent - the local controls.
+   */
+  setIntent(intent: Partial<Omit<InputFrame, 'tick'>>): void {
+    this.localIntent = { ...this.localIntent, ...intent }
+  }
+
+  /**
+   * Advance the session by one tick.
+   *
+   * @returns what happened: `stepped` with the local hash, `waiting` for the peer,
+   * or `desync`, in which case {@link desyncReport} says which tick diverged.
+   */
+  pump(): StepOutcome {
+    this.ensureHandshake()
+    if (this.ready) this.sendLocalInput()
+    const outcome = this.lockstep.step()
+    if (outcome.kind === 'waiting') this.waiting += 1
+    if (outcome.kind === 'stepped') {
+      this.stepped += 1
+      this.sendHash(outcome.tick, outcome.hash)
+    }
+    // Counted here and cleared in `receive`, not cleared here: a transport
+    // delivers from its own task, so a message almost never arrives *during* the
+    // pump that follows it. Only "how many pumps since the last message" is a
+    // question with an answer.
+    this.drainRemoteHashes()
+    this.silentTicks += 1
+    this.checkTimeout()
+    return outcome
+  }
+
+  /**
+   * Compare a peer hash against local history.
+   *
+   * @param tick - the tick.
+   * @param hash - the peer's digest.
+   * @returns the desync report when they disagree.
+   */
+  compareRemoteHash(tick: number, hash: number): DesyncReport | null {
+    const remote: StateHash = { tick, hash }
+    if (!this.lockstep.history.some(entry => entry.tick === tick)) {
+      // The tick has aged out of history: this is not agreement, it is an
+      // unanswerable question, and it is counted as such.
+      this.hashesIgnored += 1
+      return null
+    }
+    this.hashesCompared += 1
+    const report = this.lockstep.compare(remote)
+    if (report === null) this.hashesAgreed += 1
+    return report
+  }
+
+  /**
+   * Check every buffered peer hash whose tick this peer has now run.
+   *
+   * A hash whose tick has already fallen out of local history can never be
+   * checked, and is counted as ignored rather than as agreement: claiming to have
+   * verified something that was never compared would make the desync detector
+   * look healthier than it is.
+   */
+  private drainRemoteHashes(): void {
+    if (this.pendingRemoteHashes.size === 0) return
+    const window = this.options.historyTicks ?? 64
+    const oldest = this.lockstep.tick - window
+    for (const [tick, hash] of [...this.pendingRemoteHashes]) {
+      if (tick < oldest) {
+        this.pendingRemoteHashes.delete(tick)
+        this.hashesIgnored += 1
+        continue
+      }
+      if (tick >= this.lockstep.tick) continue
+      this.pendingRemoteHashes.delete(tick)
+      this.hashesCompared += 1
+      if (this.lockstep.compare({ tick, hash }) === null) this.hashesAgreed += 1
+    }
+  }
+
+  /** Local tick, for outbound timestamps. */
+  private get now(): number {
+    return this.lockstep.tick
+  }
+
+  /**
+   * Encode and send a message.
+   *
+   * @param message - the message.
+   */
+  private send(message: NetMessage): void {
+    if (!this.transport.open) return
+    this.transport.send(encodeMessage(message))
+    this.sent += 1
+  }
+
+  /**
+   * Queue this peer's input for every tick from the send cursor up to the tick
+   * that is due now.
+   *
+   * Normally that is exactly one frame per tick. The range matters at the start
+   * and after a reconnect: with `inputDelayTicks = D` the first due tick is `D`,
+   * so ticks `0..D-1` would never be supplied by anyone and the game would stall
+   * before its first tick — a deadlock that looks like a network problem and is
+   * not. Catching up from the cursor fills that warm-up window, and it also
+   * repairs a pipe that was not open when those ticks came due.
+   *
+   * Frames for ticks that already ran are dropped by the core, and a frame
+   * re-sent for a tick that has not run yet is idempotent, so over-sending is
+   * safe.
+   */
+  private sendLocalInput(): void {
+    if (!this.transport.open || !this.ready) return
+    const due = this.lockstep.inputDueTick
+    for (let tick = this.nextSendTick; tick <= due; tick += 1) {
+      const frame: InputFrame = { tick, ...this.localIntent }
+      this.send({ kind: 'input', peer: this.options.peer, frame })
+      // Our own input is authoritative locally and takes the same path as the
+      // peer's: no shortcut, so a bug in submission affects both ends equally.
+      this.lockstep.submit(this.options.peer, frame)
+    }
+    this.nextSendTick = Math.max(due + 1, this.lockstep.tick + 1)
+  }
+
+  /**
+   * Send a state hash, if this tick is a hash checkpoint.
+   *
+   * @param tick - the tick that just ran.
+   * @param hash - its digest.
+   */
+  private sendHash(tick: number, hash: number): void {
+    const interval = this.options.hashInterval ?? 5
+    if (tick % interval !== 0 || tick === this.lastHashSent) return
+    this.lastHashSent = tick
+    this.send({ kind: 'hash', peer: this.options.peer, tick, hash })
+  }
+
+  /**
+   * Handle one received message.
+   *
+   * A malformed message is counted and dropped rather than thrown: one bad packet
+   * from a confused peer should not take the world down, and the counter makes it
+   * visible.
+   *
+   * @param data - the raw bytes.
+   */
+  private receive(data: Uint8Array): void {
+    let message: NetMessage
+    try {
+      message = decodeMessage(data)
+    } catch (error) {
+      if (!(error instanceof ProtocolError)) throw error
+      this.malformed += 1
+      return
+    }
+    this.received += 1
+    this.silentTicks = 0
+    switch (message.kind) {
+      case 'hello': {
+        if (message.peer === this.options.peer || message.peer >= this.options.peers) {
+          // A hello from ourselves, or from a peer index nobody can have: ignored
+          // rather than counted, because it says the sender is confused about the
+          // game it joined.
+          this.malformed += 1
+          break
+        }
+        const link = this.linkOf(message.peer)
+        link.heard = true
+        link.seed = message.seed
+        // The seed is checked, not trusted: peers that disagree about it build
+        // different worlds, and the honest response is to say so at once rather
+        // than to discover it as a mysterious desync a second later.
+        if (message.seed !== this.options.seed) this.mismatchedSeed = message.seed
+        // An acknowledgement addressed to this peer means its own hello arrived.
+        if (message.ackTo === this.options.peer) link.ackedBy = true
+        // Every hello is answered until that peer's own acknowledgement arrives —
+        // including an acknowledgement itself, because a peer that answered us
+        // still needs to know we heard it.
+        if (!link.ackSent) {
+          link.ackSent = true
+          this.sendHello(message.peer)
+        }
+        this.handshaked = this.ready
+        break
+      }
+      case 'input':
+        this.lockstep.submit(message.peer, message.frame)
+        break
+      case 'hash':
+        this.pendingRemoteHashes.set(message.tick, message.hash)
+        this.drainRemoteHashes()
+        break
+      case 'bye':
+        this.closed = true
+        break
+      /* v8 ignore next -- the message union is closed above. */
+      default:
+        break
+    }
+  }
+
+  /** Flag the peer as lost once it has been silent for too long. */
+  private checkTimeout(): void {
+    if (this.timedOut) return
+    const limit = this.options.timeoutTicks ?? 250
+    if (this.silentTicks < limit) return
+    this.timedOut = true
+  }
+}
diff --git a/src/net/protocol.ts b/src/net/protocol.ts
new file mode 100644
index 0000000..ed0d40e
--- /dev/null
+++ b/src/net/protocol.ts
@@ -0,0 +1,187 @@
+/**
+ * Wire protocol for lockstep play.
+ *
+ * Peers exchange three things and nothing else: who they are, what they pressed,
+ * and what state they ended up with. Everything the world contains is derived
+ * locally by every peer, so the messages stay tiny — an input frame is a handful
+ * of bytes, which is what makes 25 ticks per second over a normal connection
+ * unremarkable.
+ *
+ * Encoding is explicit little-endian bytes rather than JSON: at 25 Hz per peer a
+ * text format would spend most of its bandwidth on field names, and a
+ * hand-written codec is also the one place where malformed input can be rejected
+ * before it reaches the simulation. Movement is fixed-point (`×1000`) so a float
+ * can never round differently on two machines — the same reason the simulation
+ * clamps positions rather than trusting a peer's arithmetic.
+ */
+import type { InputFrame } from './lockstep.ts'
+
+/** Message type tags, as they appear on the wire. */
+export const MESSAGE_TYPE = {
+  /** Peer introduction: identity, peer count, world seed, acknowledgement flag. */
+  hello: 1,
+  /** One tick's input from one peer. */
+  input: 2,
+  /** One peer's state digest for a tick. */
+  hash: 3,
+  /** Peer leaving. */
+  bye: 4,
+} as const
+
+/** A decoded message. */
+export type NetMessage =
+  | {
+    readonly kind: 'hello'
+    readonly peer: number
+    readonly peers: number
+    readonly seed: number
+    /** The peer this hello acknowledges, or {@link NO_ACK} for a plain introduction. */
+    readonly ackTo: number
+  }
+  | { readonly kind: 'input'; readonly peer: number; readonly frame: InputFrame }
+  | { readonly kind: 'hash'; readonly peer: number; readonly tick: number; readonly hash: number }
+  | { readonly kind: 'bye'; readonly peer: number }
+
+/** Scaling used for movement components. */
+const MOVEMENT_SCALE = 1000
+/** Bytes of an `input` message: type, peer, tick, x, y, flags, skill. */
+const INPUT_BYTES = 1 + 1 + 4 + 2 + 2 + 1 + 1
+/** Bytes of a `hash` message. */
+const HASH_BYTES = 1 + 1 + 4 + 4
+/** Bytes of a `hello` message: type, peer, peers, seed, flags. */
+const HELLO_BYTES = 1 + 1 + 1 + 4 + 1
+/** Bytes of a `bye` message. */
+const BYE_BYTES = 1 + 1
+
+/** Input frame flags byte. */
+const FLAG_ATTACK = 1
+const FLAG_PICKUP = 2
+const FLAG_TALK = 4
+
+/**
+ * `ackTo` value meaning "this hello is not an acknowledgement".
+ *
+ * A field rather than a flag byte: with more than two peers, "I heard you" has to
+ * name *who* was heard, or a session of four peers cannot tell an acknowledgement
+ * meant for it from one that merely passed by.
+ */
+export const NO_ACK = 0xff
+
+/** Raised when a message cannot be decoded. */
+export class ProtocolError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'ProtocolError'
+  }
+}
+
+/**
+ * Clamp and scale a movement component to fixed point.
+ *
+ * @param value - the component.
+ * @returns the scaled integer.
+ */
+function toFixed(value: number): number {
+  return Math.max(-32768, Math.min(32767, Math.round(value * MOVEMENT_SCALE)))
+}
+
+/**
+ * Encode one message.
+ *
+ * @param message - the message.
+ * @returns the bytes to send.
+ */
+export function encodeMessage(message: NetMessage): Uint8Array {
+  switch (message.kind) {
+    case 'hello': {
+      const out = new Uint8Array(HELLO_BYTES)
+      const view = new DataView(out.buffer)
+      out[0] = MESSAGE_TYPE.hello
+      out[1] = message.peer & 0xff
+      out[2] = message.peers & 0xff
+      view.setUint32(3, message.seed >>> 0, true)
+      out[7] = message.ackTo & 0xff
+      return out
+    }
+    case 'input': {
+      const out = new Uint8Array(INPUT_BYTES)
+      const view = new DataView(out.buffer)
+      out[0] = MESSAGE_TYPE.input
+      out[1] = message.peer & 0xff
+      view.setUint32(2, message.frame.tick >>> 0, true)
+      view.setInt16(6, toFixed(message.frame.movement.x), true)
+      view.setInt16(8, toFixed(message.frame.movement.y), true)
+      out[10] = (message.frame.attack ? FLAG_ATTACK : 0)
+        | (message.frame.pickup ? FLAG_PICKUP : 0)
+        | (message.frame.talk ? FLAG_TALK : 0)
+      out[11] = message.frame.skill & 0xff
+      return out
+    }
+    case 'hash': {
+      const out = new Uint8Array(HASH_BYTES)
+      const view = new DataView(out.buffer)
+      out[0] = MESSAGE_TYPE.hash
+      out[1] = message.peer & 0xff
+      view.setUint32(2, message.tick >>> 0, true)
+      view.setUint32(6, message.hash >>> 0, true)
+      return out
+    }
+    case 'bye': {
+      const out = new Uint8Array(BYE_BYTES)
+      out[0] = MESSAGE_TYPE.bye
+      out[1] = message.peer & 0xff
+      return out
+    }
+    /* v8 ignore next -- the message union is closed above. */
+    default: throw new ProtocolError('unknown message')
+  }
+}
+
+/**
+ * Decode one message.
+ *
+ * Every field is range-checked: a peer sending nonsense should be rejected by the
+ * protocol layer, not by the simulation several ticks later.
+ *
+ * @param data - the received bytes.
+ * @returns the message.
+ */
+export function decodeMessage(data: Uint8Array): NetMessage {
+  if (data.byteLength === 0) throw new ProtocolError('empty message')
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength)
+  const peer = data[1] ?? 0
+  switch (data[0]) {
+    case MESSAGE_TYPE.hello: {
+      if (data.byteLength !== HELLO_BYTES) throw new ProtocolError(`hello has ${String(data.byteLength)} bytes, expected ${String(HELLO_BYTES)}`)
+      const peers = data[2] ?? 0
+      if (peers < 1 || peers > 8) throw new ProtocolError(`hello declares ${String(peers)} peers`)
+      return { kind: 'hello', peer, peers, seed: view.getUint32(3, true), ackTo: data[7] ?? NO_ACK }
+    }
+    case MESSAGE_TYPE.input: {
+      if (data.byteLength !== INPUT_BYTES) throw new ProtocolError(`input has ${String(data.byteLength)} bytes, expected ${String(INPUT_BYTES)}`)
+      const flags = data[10] ?? 0
+      return {
+        kind: 'input',
+        peer,
+        frame: {
+          tick: view.getUint32(2, true),
+          movement: { x: view.getInt16(6, true) / MOVEMENT_SCALE, y: view.getInt16(8, true) / MOVEMENT_SCALE },
+          attack: (flags & FLAG_ATTACK) !== 0,
+          pickup: (flags & FLAG_PICKUP) !== 0,
+          talk: (flags & FLAG_TALK) !== 0,
+          skill: data[11] ?? 0,
+        },
+      }
+    }
+    case MESSAGE_TYPE.hash: {
+      if (data.byteLength !== HASH_BYTES) throw new ProtocolError(`hash has ${String(data.byteLength)} bytes, expected ${String(HASH_BYTES)}`)
+      return { kind: 'hash', peer, tick: view.getUint32(2, true), hash: view.getUint32(6, true) }
+    }
+    case MESSAGE_TYPE.bye: {
+      if (data.byteLength !== BYE_BYTES) throw new ProtocolError(`bye has ${String(data.byteLength)} bytes, expected ${String(BYE_BYTES)}`)
+      return { kind: 'bye', peer }
+    }
+    /* v8 ignore next -- unreachable for the checked tags. */
+    default: throw new ProtocolError(`unknown message type ${String(data[0])}`)
+  }
+}
diff --git a/src/net/transport.ts b/src/net/transport.ts
new file mode 100644
index 0000000..3d56360
--- /dev/null
+++ b/src/net/transport.ts
@@ -0,0 +1,400 @@
+/**
+ * Transports: the byte pipe under a lockstep session.
+ *
+ * A transport is deliberately primitive — send bytes, receive bytes, learn when
+ * the pipe dies. Framing, ordering, reliability and delivery *guarantees* are the
+ * transport's job, not the session's, because WebSocket and RTCDataChannel are
+ * both message-oriented and both reliable: a lost tick is a stall that recovers,
+ * never a silently corrupted world.
+ *
+ * Two implementations ship here. {@link memoryTransportPair} is an in-process
+ * pair used by the tests, and {@link socketTransport} wraps anything that looks
+ * like a `WebSocket` — which includes the browser's and Node's global, so the
+ * same code path is exercised headlessly against a real socket.
+ */
+
+/** A reliable, message-oriented byte pipe to one peer. */
+export interface Transport {
+  /**
+   * Send one message.
+   *
+   * @param data - the encoded message.
+   */
+  send: (data: Uint8Array) => void
+  /**
+   * Register the message handler. Only one handler is supported.
+   *
+   * @param handler - called for each received message.
+   */
+  onMessage: (handler: (data: Uint8Array) => void) => void
+  /**
+   * Register the close handler. Only one handler is supported.
+   *
+   * @param handler - called once when the pipe closes.
+   */
+  onClose: (handler: () => void) => void
+  /** Close the pipe. Idempotent. */
+  close: () => void
+  /** Whether the pipe is currently usable. */
+  readonly open: boolean
+}
+
+/** Options shared by the transports in this file. */
+export interface TransportOptions {
+  /** Maximum accepted message size, in bytes. Defaults to 4096. */
+  readonly maxMessageBytes?: number
+}
+
+/** Largest message accepted by default. */
+const DEFAULT_MAX_MESSAGE = 4096
+
+/**
+ * Build a connected pair of in-process transports.
+ *
+ * Delivery is deferred to {@link MemoryTransport.flush} rather than immediate, so
+ * tests can hold messages back to model a slow or stalled link — the case that
+ * lockstep has to survive.
+ *
+ * @param options - size limits.
+ * @returns the two ends, indexed by peer.
+ */
+export function memoryTransportPair(options: TransportOptions = {}): [MemoryTransport, MemoryTransport] {
+  const a = new MemoryTransport('a', options)
+  const b = new MemoryTransport('b', options)
+  a.link = b
+  b.link = a
+  return [a, b]
+}
+
+/**
+ * One end of an in-process transport pair.
+ */
+export class MemoryTransport implements Transport {
+  /** The other end. */
+  link: MemoryTransport | null = null
+  /** Messages sent but not yet delivered. */
+  private readonly pending: Uint8Array[] = []
+  /** A label, used in error messages. */
+  readonly name: string
+  private readonly maxMessageBytes: number
+  private messageHandler: ((data: Uint8Array) => void) | null = null
+  private closeHandler: (() => void) | null = null
+  private isOpen = true
+  /** How many messages this end has discarded because the link was closed. */
+  dropped = 0
+  /**
+   * When true, this end's queue is not delivered.
+   *
+   * Models a link that is slower than the game's tick rate — the case lockstep
+   * exists to survive, and the case that must stall the world rather than corrupt
+   * it.
+   */
+  hold = false
+
+  /**
+   * @param name - a label, used in error messages.
+   * @param options - size limits.
+   */
+  constructor(name: string, options: TransportOptions = {}) {
+    this.name = name
+    this.maxMessageBytes = options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE
+  }
+
+  /** Whether the pipe is usable. */
+  get open(): boolean {
+    return this.isOpen && this.link !== null && this.link.isOpen
+  }
+
+  /** Messages waiting to be delivered to the far end. */
+  get queued(): number {
+    return this.pending.length
+  }
+
+  /**
+   * Queue a message for the far end.
+   *
+   * @param data - the bytes.
+   */
+  send(data: Uint8Array): void {
+    if (!this.isOpen || this.link === null || !this.link.isOpen) {
+      this.dropped += 1
+      return
+    }
+    if (data.byteLength > this.maxMessageBytes) throw new Error(`${this.name}: message of ${String(data.byteLength)} bytes exceeds ${String(this.maxMessageBytes)}`)
+    this.pending.push(data.slice())
+  }
+
+  /** @param handler - message handler. */
+  onMessage(handler: (data: Uint8Array) => void): void {
+    this.messageHandler = handler
+  }
+
+  /** @param handler - close handler. */
+  onClose(handler: () => void): void {
+    this.closeHandler = handler
+  }
+
+  /** Close this end; the far end observes the close. */
+  close(): void {
+    if (!this.isOpen) return
+    this.isOpen = false
+    this.pending.length = 0
+    this.closeHandler?.()
+    this.link?.close()
+  }
+
+  /**
+   * Deliver everything queued, on both ends.
+   *
+   * Called by the test harness once per simulated tick. Because each delivery can
+   * queue more messages, this drains until the pair is quiet or the round cap is
+   * hit — a cap rather than a `while (true)` so a handler that replies to itself
+   * fails loudly instead of hanging.
+   *
+   * @param rounds - maximum delivery rounds. Defaults to 8.
+   */
+  flush(rounds = 8): void {
+    for (let round = 0; round < rounds; round += 1) {
+      const a = this.drain(this)
+      const b = this.link === null ? 0 : this.drain(this.link)
+      if (a + b === 0) return
+    }
+    throw new Error('memory transport did not settle')
+  }
+
+  /**
+   * Deliver this end's queue.
+   *
+   * @param side - the end whose queue should be delivered.
+   * @returns how many messages were delivered.
+   */
+  private drain(side: MemoryTransport): number {
+    let delivered = 0
+    while (!side.hold && side.pending.length > 0) {
+      const data = side.pending.shift()!
+      const target = side.link
+      if (target === null || !target.isOpen) { side.dropped += 1; continue }
+      target.messageHandler?.(data)
+      delivered += 1
+    }
+    return delivered
+  }
+}
+
+/**
+ * An in-process hub: the same shape as the relay, without the sockets.
+ *
+ * Three or more peers cannot be built from pairs, and the interesting failures in
+ * a session of four are the ones a two-peer test cannot reproduce at all — a late
+ * joiner, one peer that stops answering while the others carry on. This mirrors
+ * the relay's one rule (everyone hears everything, except the sender) so those
+ * cases can be driven a tick at a time.
+ */
+export class MemoryHub {
+  private readonly ends: HubTransport[] = []
+  private readonly queue: { readonly from: number; readonly data: Uint8Array }[] = []
+  private readonly maxMessageBytes: number
+  /**
+   * Ends whose sends are withheld, to model a link slower than the game.
+   *
+   * Withheld, not lost: a WebSocket and a data channel are both reliable, so the
+   * honest model of a slow link is a message that arrives late. Dropping it would
+   * instead model a transport this game never runs on, and would leave the peers
+   * that waited for it stuck forever rather than briefly behind.
+   */
+  readonly held = new Set<number>()
+
+  /**
+   * @param options - size limits.
+   */
+  constructor(options: TransportOptions = {}) {
+    this.maxMessageBytes = options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE
+  }
+
+  /**
+   * Attach an end, as a peer joining the game would.
+   *
+   * @returns the new end; its `index` is its peer index.
+   */
+  attach(): HubTransport {
+    const end = new HubTransport(this, this.ends.length)
+    this.ends.push(end)
+    return end
+  }
+
+  /** The attached ends, indexed by peer. */
+  get transports(): HubTransport[] {
+    return this.ends
+  }
+
+  /**
+   * Queue a message from one end.
+   *
+   * @param from - the sending end's index.
+   * @param data - the bytes.
+   */
+  enqueue(from: number, data: Uint8Array): void {
+    if (data.byteLength > this.maxMessageBytes) throw new Error(`hub message of ${String(data.byteLength)} bytes exceeds ${String(this.maxMessageBytes)}`)
+    this.queue.push({ from, data: data.slice() })
+  }
+
+  /**
+   * Deliver everything queued.
+   *
+   * Delivery can itself queue more messages (an acknowledgement answering a
+   * hello), so this drains until quiet or the round cap is hit.
+   *
+   * @param rounds - maximum delivery rounds. Defaults to 8.
+   */
+  flush(rounds = 8): void {
+    for (let round = 0; round < rounds; round += 1) {
+      if (this.queue.length === 0) return
+      const batch = this.queue.splice(0, this.queue.length)
+      const withheld: { readonly from: number; readonly data: Uint8Array }[] = []
+      let delivered = 0
+      for (const message of batch) {
+        // A held end's messages wait their turn rather than disappearing.
+        if (this.held.has(message.from)) { withheld.push(message); continue }
+        for (const end of this.ends) {
+          if (end.index === message.from) continue
+          end.deliver(message.data)
+        }
+        delivered += 1
+      }
+      this.queue.push(...withheld)
+      if (delivered === 0) return
+    }
+    throw new Error('memory hub did not settle')
+  }
+
+  /** Close every end. */
+  close(): void {
+    for (const end of this.ends) end.close()
+  }
+}
+
+/**
+ * Build a hub with a given number of attached ends.
+ *
+ * @param size - how many peers.
+ * @param options - size limits.
+ * @returns the ends, indexed by peer.
+ */
+export function memoryHub(size: number, options: TransportOptions = {}): { hub: MemoryHub; ends: HubTransport[] } {
+  const hub = new MemoryHub(options)
+  for (let index = 0; index < size; index += 1) hub.attach()
+  return { hub, ends: hub.transports }
+}
+
+/** One end of a {@link MemoryHub}. */
+export class HubTransport implements Transport {
+  /** This end's peer index. */
+  readonly index: number
+  private readonly hub: MemoryHub
+  private messageHandler: ((data: Uint8Array) => void) | null = null
+  private closeHandler: (() => void) | null = null
+  private isAttached = true
+
+  /**
+   * @param hub - the hub it belongs to.
+   * @param index - its peer index.
+   */
+  constructor(hub: MemoryHub, index: number) {
+    this.hub = hub
+    this.index = index
+  }
+
+  /** Whether this end can still send and receive. */
+  get open(): boolean {
+    return this.isAttached
+  }
+
+  /** @param data - the bytes. */
+  send(data: Uint8Array): void {
+    if (!this.isAttached) return
+    this.hub.enqueue(this.index, data)
+  }
+
+  /** @param handler - message handler. */
+  onMessage(handler: (data: Uint8Array) => void): void {
+    this.messageHandler = handler
+  }
+
+  /** @param handler - close handler. */
+  onClose(handler: () => void): void {
+    this.closeHandler = handler
+  }
+
+  /** Close this end. */
+  close(): void {
+    if (!this.isAttached) return
+    this.isAttached = false
+    this.closeHandler?.()
+  }
+
+  /**
+   * Deliver one message from the hub.
+   *
+   * @param data - the bytes.
+   */
+  deliver(data: Uint8Array): void {
+    if (!this.isAttached) return
+    this.messageHandler?.(data)
+  }
+}
+
+/** The subset of `WebSocket` this file uses. */
+export interface SocketLike {
+  readonly readyState: number
+  binaryType?: string
+  send: (data: ArrayBufferLike | ArrayBufferView | string) => void
+  close: () => void
+  addEventListener: (type: string, listener: (event: { data?: unknown }) => void) => void
+}
+
+/** Socket ready state meaning "open". */
+const SOCKET_OPEN = 1
+
+/**
+ * Wrap a socket in a {@link Transport}.
+ *
+ * Both the browser `WebSocket` and Node's global one satisfy {@link SocketLike},
+ * so the network path can be tested without a browser. Only binary messages are
+ * accepted: a text frame on the wire means the peer is not speaking this
+ * protocol, and treating it as bytes anyway would feed the decoder garbage.
+ *
+ * @param socket - the socket.
+ * @param options - size limits.
+ * @returns the transport.
+ */
+export function socketTransport(socket: SocketLike, options: TransportOptions = {}): Transport {
+  const maxMessageBytes = options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE
+  socket.binaryType = 'arraybuffer'
+  let messageHandler: ((data: Uint8Array) => void) | null = null
+  let closeHandler: (() => void) | null = null
+  let opened = socket.readyState === SOCKET_OPEN
+
+  socket.addEventListener('open', () => { opened = true })
+  socket.addEventListener('message', event => {
+    const data = event.data
+    const bytes = data instanceof ArrayBuffer
+      ? new Uint8Array(data)
+      : ArrayBuffer.isView(data) ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : null
+    if (bytes === null) throw new Error('socket transport received a non-binary message')
+    if (bytes.byteLength > maxMessageBytes) throw new Error(`socket message of ${String(bytes.byteLength)} bytes exceeds ${String(maxMessageBytes)}`)
+    messageHandler?.(bytes)
+  })
+  socket.addEventListener('close', () => { opened = false; closeHandler?.() })
+  socket.addEventListener('error', () => { opened = false; closeHandler?.() })
+
+  return {
+    send: (data: Uint8Array): void => {
+      if (!opened) return
+      socket.send(data)
+    },
+    onMessage: (handler): void => { messageHandler = handler },
+    onClose: (handler): void => { closeHandler = handler },
+    close: (): void => { if (opened) socket.close() },
+    get open(): boolean { return opened },
+  }
+}
diff --git a/src/render/atlas.ts b/src/render/atlas.ts
new file mode 100644
index 0000000..73bfa81
--- /dev/null
+++ b/src/render/atlas.ts
@@ -0,0 +1,128 @@
+/**
+ * Sprite atlases: decoded palette-indexed frames packed once into one RGBA
+ * texture.
+ *
+ * Indexed frames stay the source of truth in the format layer (that is what
+ * makes colour variants cheap), but the GPU wants RGBA. Expanding into a single
+ * atlas keeps both: one texture bind per frame batch, and a variant is another
+ * atlas rather than a shader permutation.
+ */
+import { indicesToRgba } from '../formats/pal.ts'
+import type { Palette } from '../formats/pal.ts'
+import type { SpriteSheet } from '../formats/sprite.ts'
+
+/** One frame's placement inside the atlas, in atlas pixels. */
+export interface AtlasFrame {
+  /** Left edge. */
+  readonly x: number
+  /** Top edge. */
+  readonly y: number
+  /** Frame width. */
+  readonly width: number
+  /** Frame height. */
+  readonly height: number
+}
+
+/** A packed sheet: pixels plus per-group frame placements. */
+export interface SpriteAtlas {
+  /** RGBA8 pixels, `width * height * 4`. */
+  readonly pixels: Uint8ClampedArray
+  /** Atlas width in pixels. */
+  readonly width: number
+  /** Atlas height in pixels. */
+  readonly height: number
+  /** Frame placements, grouped exactly like the source sheet. */
+  readonly groups: readonly (readonly AtlasFrame[])[]
+}
+
+/** One pixel of padding between frames, so nearest sampling cannot bleed. */
+const PADDING = 1
+/** Cap on the atlas' short side, comfortably under every GL implementation's limit. */
+const MAX_ATLAS_WIDTH = 2048
+
+/**
+ * Round up to a power of two (atlas dimensions stay power-of-two-ish so the
+ * layout is easy to reason about, not because the hardware requires it).
+ *
+ * @param value - the value to round.
+ * @returns the next power of two, at least 1.
+ */
+function nextPowerOfTwo(value: number): number {
+  let result = 1
+  while (result < value) result *= 2
+  return result
+}
+
+/**
+ * Pack a decoded sheet into an RGBA atlas.
+ *
+ * Frames are laid out in shelves: left to right, wrapping to a new shelf when
+ * the atlas width would be exceeded. Sheets here are small (a few hundred
+ * frames of at most a couple hundred pixels), so a shelf packer keeps the code
+ * short without wasting meaningful space.
+ *
+ * @param sheet - the decoded sheet.
+ * @param palette - palette to resolve indices with.
+ * @param trn - optional index remap (unit colour variant).
+ * @param options - atlas width and background.
+ * @returns the packed atlas.
+ */
+export function buildAtlas(
+  sheet: SpriteSheet,
+  palette: Palette,
+  trn?: Uint8Array,
+  options: { width?: number } = {},
+): SpriteAtlas {
+  const frames = sheet.groups.flatMap(group => group.frames)
+  if (frames.length === 0) {
+    return { pixels: new Uint8ClampedArray(0), width: 0, height: 0, groups: [] }
+  }
+  const widest = Math.max(...frames.map(frame => frame.width))
+  // Sizing the atlas to its widest frame would stack every frame in one
+  // kilometre-tall column and blow past the GL texture limit; aiming for a
+  // roughly square sheet keeps both dimensions sane.
+  const area = frames.reduce((total, frame) => total + (frame.width + PADDING) * (frame.height + PADDING), 0)
+  const square = nextPowerOfTwo(Math.ceil(Math.sqrt(area)))
+  const atlasWidth = Math.max(options.width ?? 0, widest + PADDING, Math.min(square, MAX_ATLAS_WIDTH))
+
+  // Shelf layout: walk the frames, starting a new shelf when one does not fit.
+  const placements: AtlasFrame[] = []
+  let shelfY = 0
+  let shelfHeight = 0
+  let cursorX = 0
+  for (const frame of frames) {
+    if (cursorX + frame.width + PADDING > atlasWidth) {
+      shelfY += shelfHeight + PADDING
+      shelfHeight = 0
+      cursorX = 0
+    }
+    placements.push({ x: cursorX, y: shelfY, width: frame.width, height: frame.height })
+    cursorX += frame.width + PADDING
+    shelfHeight = Math.max(shelfHeight, frame.height)
+  }
+  const atlasHeight = shelfY + shelfHeight + PADDING
+  const pixels = new Uint8ClampedArray(atlasWidth * atlasHeight * 4)
+
+  let index = 0
+  for (const frame of frames) {
+    const place = placements[index]!
+    const rgba = indicesToRgba(frame.indices, frame.mask, palette, trn)
+    for (let row = 0; row < frame.height; row += 1) {
+      const from = row * frame.width * 4
+      const to = ((place.y + row) * atlasWidth + place.x) * 4
+      pixels.set(rgba.subarray(from, from + frame.width * 4), to)
+    }
+    index += 1
+  }
+
+  // Re-group placements to mirror the sheet, so a caller indexes
+  // `atlas.groups[direction][frame]` exactly as it indexes the sprite sheet.
+  let consumed = 0
+  const groups = sheet.groups.map(group => {
+    const slice = placements.slice(consumed, consumed + group.frames.length)
+    consumed += group.frames.length
+    return slice
+  })
+
+  return { pixels, width: atlasWidth, height: atlasHeight, groups }
+}
diff --git a/src/render/renderer.ts b/src/render/renderer.ts
new file mode 100644
index 0000000..2e8d063
--- /dev/null
+++ b/src/render/renderer.ts
@@ -0,0 +1,447 @@
+/**
+ * WebGL2 sprite renderer: one quad batcher with per-quad tint.
+ *
+ * Diablo-style rendering is a flood of axis-aligned quads — floors, walls,
+ * units, items — drawn in painter's order. So the renderer accumulates
+ * world-space quads (position, source rectangle, tint) and submits them in as
+ * few calls as the texture switches allow. Depth ordering is the caller's job
+ * (draw order), not the GPU's, which is how the original games did it and what
+ * keeps the batcher trivial.
+ *
+ * Tint is a vertex attribute rather than a uniform, so coloured geometry
+ * (a floor rectangle, a wall) batches together with sprites instead of forcing
+ * a flush per colour.
+ */
+import type { AtlasFrame, SpriteAtlas } from './atlas.ts'
+
+/** Camera state for one frame. */
+export interface Camera {
+  /** World-space centre of the view. */
+  readonly x: number
+  /** World-space centre of the view. */
+  readonly y: number
+  /** Pixels per world unit. */
+  readonly zoom: number
+}
+
+/**
+ * One uploaded atlas texture.
+ *
+ * Diablo II maps need more tiles than a single 2048² page holds, so the renderer
+ * keeps several textures and draws each quad from the page its frame lives in.
+ * Switching textures splits the batch (see {@link SpriteRenderer.draw}) but
+ * never reorders it, so painter's order survives multi-page atlases.
+ */
+export interface AtlasHandle {
+  /** The GPU texture. */
+  readonly texture: WebGLTexture
+  /** Texture width in pixels, for UV maths. */
+  readonly width: number
+  /** Texture height in pixels. */
+  readonly height: number
+}
+
+/** Draw options for one sprite quad. */
+export interface DrawOptions {
+  /** Multiplicative tint, defaulting to opaque white. */
+  readonly tint?: readonly [number, number, number, number]
+  /** Mirror horizontally. */
+  readonly flipX?: boolean
+  /** Atlas page to sample; defaults to the most recently set atlas. */
+  readonly atlas?: AtlasHandle
+}
+
+/** Vertices per quad (two triangles). */
+const VERTICES_PER_QUAD = 6
+/** Floats per vertex: x, y, u, v, r, g, b, a. */
+const FLOATS_PER_VERTEX = 8
+/** Initial batch capacity in quads. */
+const INITIAL_CAPACITY = 8192
+
+const VERTEX_SHADER = `#version 300 es
+in vec2 a_position;
+in vec2 a_uv;
+in vec4 a_tint;
+uniform vec2 u_camera;
+uniform vec2 u_viewport;
+uniform float u_zoom;
+out vec2 v_uv;
+out vec4 v_tint;
+void main() {
+  vec2 offset = (a_position - u_camera) * u_zoom;
+  // 'half' is a reserved word in GLSL ES 3.00, hence the longer name.
+  vec2 halfViewport = u_viewport * 0.5;
+  gl_Position = vec4(offset.x / halfViewport.x, -offset.y / halfViewport.y, 0.0, 1.0);
+  v_uv = a_uv;
+  v_tint = a_tint;
+}`
+
+const FRAGMENT_SHADER = `#version 300 es
+precision mediump float;
+in vec2 v_uv;
+in vec4 v_tint;
+uniform sampler2D u_texture;
+out vec4 outColor;
+void main() {
+  vec4 texel = texture(u_texture, v_uv);
+  if (texel.a == 0.0) discard;
+  outColor = texel * v_tint;
+}`
+
+/** Raised when the context or program cannot be created. */
+export class RendererError extends Error {}
+
+/**
+ * A quad batcher bound to one canvas.
+ */
+export class SpriteRenderer {
+  /** The WebGL2 context, exposed for the few callers that need raw access. */
+  readonly gl: WebGL2RenderingContext
+  private readonly program: WebGLProgram
+  private readonly vao: WebGLVertexArrayObject
+  private readonly buffer: WebGLBuffer
+  private readonly atlasTexture: WebGLTexture
+  private readonly whiteTexture: WebGLTexture
+  /** The 1×1 white page used by `drawSolid`. */
+  private readonly whiteAtlas: AtlasHandle
+  /** The default page (what `setAtlas` uploads into). */
+  private defaultAtlas: AtlasHandle
+  private readonly uniformCamera: WebGLUniformLocation
+  private readonly uniformViewport: WebGLUniformLocation
+  private readonly uniformZoom: WebGLUniformLocation
+  private readonly uniformTexture: WebGLUniformLocation
+  private vertices: Float32Array
+  private quadCount = 0
+  private atlasWidth = 1
+  private atlasHeight = 1
+  /** Which texture the queued quads sample; a switch flushes the batch. */
+  private batchAtlas: AtlasHandle
+  private camera: Camera = { x: 0, y: 0, zoom: 1 }
+
+  /**
+   * @param canvas - the canvas to render into.
+   */
+  constructor(canvas: HTMLCanvasElement) {
+    const gl = canvas.getContext('webgl2', { alpha: false, antialias: false, premultipliedAlpha: false })
+    if (gl === null) throw new RendererError('WebGL2 is not available in this browser')
+    this.gl = gl
+    this.program = createProgram(gl, VERTEX_SHADER, FRAGMENT_SHADER)
+    const vao = gl.createVertexArray()
+    const buffer = gl.createBuffer()
+    const atlasTexture = gl.createTexture()
+    const whiteTexture = gl.createTexture()
+    if (vao === null || buffer === null || atlasTexture === null || whiteTexture === null) {
+      throw new RendererError('WebGL2 resource allocation failed')
+    }
+    this.vao = vao
+    this.buffer = buffer
+    this.atlasTexture = atlasTexture
+    this.whiteTexture = whiteTexture
+    this.defaultAtlas = { texture: atlasTexture, width: 1, height: 1 }
+    this.whiteAtlas = { texture: whiteTexture, width: 1, height: 1 }
+    this.batchAtlas = this.defaultAtlas
+    this.vertices = new Float32Array(INITIAL_CAPACITY * VERTICES_PER_QUAD * FLOATS_PER_VERTEX)
+
+    const attributePosition = gl.getAttribLocation(this.program, 'a_position')
+    const attributeUv = gl.getAttribLocation(this.program, 'a_uv')
+    const attributeTint = gl.getAttribLocation(this.program, 'a_tint')
+    gl.bindVertexArray(vao)
+    gl.bindBuffer(gl.ARRAY_BUFFER, buffer)
+    gl.bufferData(gl.ARRAY_BUFFER, this.vertices.byteLength, gl.DYNAMIC_DRAW)
+    const stride = FLOATS_PER_VERTEX * 4
+    gl.enableVertexAttribArray(attributePosition)
+    gl.vertexAttribPointer(attributePosition, 2, gl.FLOAT, false, stride, 0)
+    gl.enableVertexAttribArray(attributeUv)
+    gl.vertexAttribPointer(attributeUv, 2, gl.FLOAT, false, stride, 8)
+    gl.enableVertexAttribArray(attributeTint)
+    gl.vertexAttribPointer(attributeTint, 4, gl.FLOAT, false, stride, 16)
+    gl.bindVertexArray(null)
+
+    this.uniformCamera = requireUniform(gl, this.program, 'u_camera')
+    this.uniformViewport = requireUniform(gl, this.program, 'u_viewport')
+    this.uniformZoom = requireUniform(gl, this.program, 'u_zoom')
+    this.uniformTexture = requireUniform(gl, this.program, 'u_texture')
+
+    for (const texture of [atlasTexture, whiteTexture]) {
+      gl.bindTexture(gl.TEXTURE_2D, texture)
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
+    }
+    gl.bindTexture(gl.TEXTURE_2D, whiteTexture)
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array([255, 255, 255, 255]))
+    gl.enable(gl.BLEND)
+    gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
+    gl.disable(gl.DEPTH_TEST)
+  }
+
+  /**
+   * Upload an atlas, replacing the current one.
+   *
+   * @param atlas - the packed atlas.
+   * @returns the handle other pages can be drawn with.
+   */
+  setAtlas(atlas: SpriteAtlas): AtlasHandle {
+    const gl = this.gl
+    // Uploading past the limit is a silent INVALID_VALUE in GL; say what
+    // actually went wrong instead.
+    const limit = gl.getParameter(gl.MAX_TEXTURE_SIZE) as number
+    if (atlas.width > limit || atlas.height > limit) {
+      throw new RendererError(
+        `atlas ${String(atlas.width)}x${String(atlas.height)} exceeds the ${String(limit)}px texture limit`,
+      )
+    }
+    this.flush()
+    gl.bindTexture(gl.TEXTURE_2D, this.atlasTexture)
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1)
+    gl.texImage2D(
+      gl.TEXTURE_2D, 0, gl.RGBA, atlas.width, atlas.height, 0,
+      gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(atlas.pixels.buffer, atlas.pixels.byteOffset, atlas.pixels.byteLength),
+    )
+    this.atlasWidth = Math.max(atlas.width, 1)
+    this.atlasHeight = Math.max(atlas.height, 1)
+    this.defaultAtlas = { texture: this.atlasTexture, width: this.atlasWidth, height: this.atlasHeight }
+    return this.defaultAtlas
+  }
+
+  /**
+   * Upload an extra atlas page and return a handle for it.
+   *
+   * Packed maps ship several pages; the page can load the ones the spawn area
+   * needs first and hand them over as they arrive, instead of waiting for one
+   * gigantic texture to decode.
+   *
+   * @param source - decoded pixels or an `ImageBitmap` (PNG straight from cache).
+   * @param width - page width in pixels.
+   * @param height - page height in pixels.
+   * @returns the handle to pass to {@link draw}.
+   */
+  addAtlas(
+    source: ImageBitmap | { pixels: Uint8ClampedArray | Uint8Array; width: number; height: number },
+    width?: number,
+    height?: number,
+  ): AtlasHandle {
+    const gl = this.gl
+    const limit = gl.getParameter(gl.MAX_TEXTURE_SIZE) as number
+    const isBitmap = typeof ImageBitmap !== 'undefined' && source instanceof ImageBitmap
+    const sourceWidth = isBitmap ? (source as ImageBitmap).width : (source as { width: number }).width
+    const sourceHeight = isBitmap ? (source as ImageBitmap).height : (source as { height: number }).height
+    const pageWidth = Math.max(1, width ?? sourceWidth)
+    const pageHeight = Math.max(1, height ?? sourceHeight)
+    if (pageWidth > limit || pageHeight > limit) {
+      throw new RendererError(`atlas ${String(pageWidth)}x${String(pageHeight)} exceeds the ${String(limit)}px texture limit`)
+    }
+    this.flush()
+    const texture = gl.createTexture()
+    if (texture === null) throw new RendererError('texture allocation failed')
+    gl.bindTexture(gl.TEXTURE_2D, texture)
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1)
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
+    if (isBitmap) {
+      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source as ImageBitmap)
+    } else {
+      const indexed = source as { pixels: Uint8ClampedArray | Uint8Array; width: number; height: number }
+      const pixels = indexed.pixels instanceof Uint8Array
+        ? indexed.pixels
+        : new Uint8Array(indexed.pixels.buffer, indexed.pixels.byteOffset, indexed.pixels.byteLength)
+      gl.texImage2D(
+        gl.TEXTURE_2D, 0, gl.RGBA, indexed.width, indexed.height, 0,
+        gl.RGBA, gl.UNSIGNED_BYTE, pixels,
+      )
+    }
+    gl.bindTexture(gl.TEXTURE_2D, this.batchAtlas.texture)
+    return { texture, width: pageWidth, height: pageHeight }
+  }
+
+  /** The page `setAtlas` uploaded into, for callers that draw with handles. */
+  get defaultAtlasHandle(): AtlasHandle {
+    return this.defaultAtlas
+  }
+
+  /**
+   * Start a frame: clear, and record the camera.
+   *
+   * @param camera - camera to render with.
+   * @param clear - background colour as `[r, g, b]` in 0..1.
+   */
+  begin(camera: Camera, clear: readonly [number, number, number] = [0, 0, 0]): void {
+    const gl = this.gl
+    this.camera = camera
+    this.quadCount = 0
+    this.batchAtlas = this.defaultAtlas
+    gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight)
+    gl.clearColor(clear[0], clear[1], clear[2], 1)
+    gl.clear(gl.COLOR_BUFFER_BIT)
+  }
+
+  /**
+   * Queue one atlas sprite.
+   *
+   * @param frame - the atlas placement to draw.
+   * @param x - world-space left edge.
+   * @param y - world-space top edge.
+   * @param options - tint and flipping.
+   */
+  draw(frame: AtlasFrame, x: number, y: number, options: DrawOptions = {}): void {
+    const page = options.atlas ?? this.defaultAtlas
+    // A page switch splits the batch; because it never reorders quads, painter's
+    // order is preserved across pages.
+    if (this.batchAtlas !== page) {
+      this.flush()
+      this.batchAtlas = page
+    }
+    const u0 = frame.x / page.width
+    const v0 = frame.y / page.height
+    const u1 = (frame.x + frame.width) / page.width
+    const v1 = (frame.y + frame.height) / page.height
+    this.quad(
+      x, y, x + frame.width, y + frame.height,
+      options.flipX === true ? u1 : u0, v0,
+      options.flipX === true ? u0 : u1, v1,
+      options.tint ?? WHITE,
+    )
+  }
+
+  /**
+   * Queue one solid-colour rectangle.
+   *
+   * @param x - world-space left edge.
+   * @param y - world-space top edge.
+   * @param width - rectangle width.
+   * @param height - rectangle height.
+   * @param color - `[r, g, b, a]` in 0..1.
+   */
+  drawSolid(x: number, y: number, width: number, height: number, color: readonly [number, number, number, number]): void {
+    if (this.batchAtlas !== this.whiteAtlas) {
+      this.flush()
+      this.batchAtlas = this.whiteAtlas
+    }
+    this.quad(x, y, x + width, y + height, 0.5, 0.5, 0.5, 0.5, color)
+  }
+
+  /**
+   * Append one quad's six vertices.
+   *
+   * @param x0 - left edge.
+   * @param y0 - top edge.
+   * @param x1 - right edge.
+   * @param y1 - bottom edge.
+   * @param u0 - left texture coordinate.
+   * @param v0 - top texture coordinate.
+   * @param u1 - right texture coordinate.
+   * @param v1 - bottom texture coordinate.
+   * @param tint - per-quad tint.
+   */
+  private quad(
+    x0: number, y0: number, x1: number, y1: number,
+    u0: number, v0: number, u1: number, v1: number,
+    tint: readonly [number, number, number, number],
+  ): void {
+    const needed = (this.quadCount + 1) * VERTICES_PER_QUAD * FLOATS_PER_VERTEX
+    if (needed > this.vertices.length) this.grow(needed)
+    const v = this.vertices
+    const at = this.quadCount * VERTICES_PER_QUAD * FLOATS_PER_VERTEX
+    const [r, g, b, a] = tint
+    // Two triangles: (x0,y0) (x1,y0) (x0,y1) and (x1,y0) (x1,y1) (x0,y1).
+    const xs = [x0, x1, x0, x1, x1, x0]
+    const ys = [y0, y0, y1, y0, y1, y1]
+    const us = [u0, u1, u0, u1, u1, u0]
+    const vs = [v0, v0, v1, v0, v1, v1]
+    for (let i = 0; i < VERTICES_PER_QUAD; i += 1) {
+      const base = at + i * FLOATS_PER_VERTEX
+      v[base] = xs[i]!
+      v[base + 1] = ys[i]!
+      v[base + 2] = us[i]!
+      v[base + 3] = vs[i]!
+      v[base + 4] = r
+      v[base + 5] = g
+      v[base + 6] = b
+      v[base + 7] = a
+    }
+    this.quadCount += 1
+  }
+
+  /** Submit every queued quad. */
+  flush(): void {
+    const gl = this.gl
+    if (this.quadCount === 0) return
+    gl.useProgram(this.program)
+    gl.bindVertexArray(this.vao)
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.buffer)
+    gl.bufferSubData(gl.ARRAY_BUFFER, 0, this.vertices, 0, this.quadCount * VERTICES_PER_QUAD * FLOATS_PER_VERTEX)
+    gl.uniform2f(this.uniformCamera, this.camera.x, this.camera.y)
+    gl.uniform2f(this.uniformViewport, gl.drawingBufferWidth, gl.drawingBufferHeight)
+    gl.uniform1f(this.uniformZoom, this.camera.zoom)
+    gl.uniform1i(this.uniformTexture, 0)
+    gl.activeTexture(gl.TEXTURE0)
+    gl.bindTexture(gl.TEXTURE_2D, this.batchAtlas.texture)
+    gl.drawArrays(gl.TRIANGLES, 0, this.quadCount * VERTICES_PER_QUAD)
+    this.quadCount = 0
+  }
+
+  /**
+   * Grow the vertex buffer, preserving queued geometry.
+   *
+   * @param needed - required float count.
+   */
+  private grow(needed: number): void {
+    let capacity = this.vertices.length
+    while (capacity < needed) capacity *= 2
+    const grown = new Float32Array(capacity)
+    grown.set(this.vertices)
+    this.vertices = grown
+    this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.buffer)
+    this.gl.bufferData(this.gl.ARRAY_BUFFER, grown.byteLength, this.gl.DYNAMIC_DRAW)
+  }
+}
+
+/** Opaque white, the neutral tint. */
+const WHITE: readonly [number, number, number, number] = [1, 1, 1, 1]
+
+/**
+ * Compile and link a program, reporting shader logs on failure.
+ *
+ * @param gl - the context.
+ * @param vertexSource - vertex shader source.
+ * @param fragmentSource - fragment shader source.
+ * @returns the linked program.
+ */
+function createProgram(gl: WebGL2RenderingContext, vertexSource: string, fragmentSource: string): WebGLProgram {
+  const compile = (type: number, source: string): WebGLShader => {
+    const shader = gl.createShader(type)
+    if (shader === null) throw new RendererError('could not create shader')
+    gl.shaderSource(shader, source)
+    gl.compileShader(shader)
+    if (gl.getShaderParameter(shader, gl.COMPILE_STATUS) !== true) {
+      throw new RendererError(`shader compile failed: ${gl.getShaderInfoLog(shader) ?? 'unknown'}`)
+    }
+    return shader
+  }
+  const program = gl.createProgram()
+  if (program === null) throw new RendererError('could not create program')
+  gl.attachShader(program, compile(gl.VERTEX_SHADER, vertexSource))
+  gl.attachShader(program, compile(gl.FRAGMENT_SHADER, fragmentSource))
+  gl.linkProgram(program)
+  if (gl.getProgramParameter(program, gl.LINK_STATUS) !== true) {
+    throw new RendererError(`program link failed: ${gl.getProgramInfoLog(program) ?? 'unknown'}`)
+  }
+  return program
+}
+
+/**
+ * Fetch a uniform location or fail loudly.
+ *
+ * @param gl - the context.
+ * @param program - the linked program.
+ * @param name - uniform name.
+ * @returns the location.
+ */
+function requireUniform(gl: WebGL2RenderingContext, program: WebGLProgram, name: string): WebGLUniformLocation {
+  const location = gl.getUniformLocation(program, name)
+  if (location === null) throw new RendererError(`uniform ${name} is missing from the program`)
+  return location
+}
diff --git a/src/scene/act-scene.ts b/src/scene/act-scene.ts
new file mode 100644
index 0000000..c9edda9
--- /dev/null
+++ b/src/scene/act-scene.ts
@@ -0,0 +1,1123 @@
+/**
+ * Act map scene: real Diablo II levels, walked by the player.
+ *
+ * Two data paths feed the same loop, and both stay because they answer different
+ * questions:
+ *
+ * - **pack** (default): a prebaked `scene.json` plus indexed PNG pages produced
+ *   by `scripts/pack-act-assets.ts`. Nothing is decoded — the browser turns a PNG
+ *   into a texture, and the JSON already carries painter's order and the
+ *   collision grid. Pages load by need: the ones covering the spawn viewport
+ *   first, the rest in the background while the player is already walking.
+ * - **live**: the archives themselves over HTTP ranges, decoded in the browser
+ *   (DS1 + DT1 + PL2). Slower, needs no bake step, and works for any level the
+ *   pack does not cover. `?live=1` forces it.
+ *
+ * No monsters are loaded on either path: this page exists to walk real maps.
+ */
+import { MpqArchive } from '../mpq/archive.ts'
+import { httpRangeSource } from '../mpq/source.ts'
+import { MountedArchives } from '../mpq/mount.ts'
+import { loadActTables, resolveActTown, resolveLevel } from '../game/acts.ts'
+import type { LevelInfo } from '../game/acts.ts'
+import { decodeDs1 } from '../formats/ds1.ts'
+import { decodeDt1 } from '../formats/dt1.ts'
+import { decodePl2 } from '../formats/pl2.ts'
+import type { Palette } from '../formats/pal.ts'
+import type { SpriteSheet } from '../formats/sprite.ts'
+import {
+  ORTHO_CELL_HEIGHT, ORTHO_CELL_WIDTH, buildIsoMapScene, findIsoSpawn, isBlockedAt, levelSeed,
+} from '../game/d2map.ts'
+import type { CollisionGrid } from '../game/d2map.ts'
+import { depthInsertIndex } from '../game/map.ts'
+import { buildAtlas } from '../render/atlas.ts'
+import type { AtlasFrame, SpriteAtlas } from '../render/atlas.ts'
+import { SpriteRenderer } from '../render/renderer.ts'
+import type { AtlasHandle } from '../render/renderer.ts'
+import { loadCharacterSheet, facingToDirection } from '../game/character.ts'
+import { ACT_NAMES_ZH, sceneNameZh, variantLabelZh } from '../game/level-names-zh.ts'
+import { GameLoop } from '../sim/loop.ts'
+import { KeyboardInput } from '../sim/input.ts'
+
+/** Archives the live path mounts, in load order. */
+const DATA_ARCHIVES = ['d2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq'] as const
+/** Character archive: optional, and the map itself does not need it. */
+const CHARACTER_ARCHIVE = 'd2char.mpq'
+/** Archive locations tried in order when `?base=` is absent. */
+const DEFAULT_BASES = ['samples/d2', '/diablo2/data']
+/** Pack locations tried in order when `?pack=` is absent. */
+const DEFAULT_PACKS = ['samples/d2-packs', '/diablo2/packs']
+/** Act count the page offers. */
+const ACT_COUNT = 5
+/** Walk speed in scene pixels per second (cells are 80×40). */
+const WALK_SPEED = 170
+/** Character collision box at the feet, in scene pixels. */
+const FEET_WIDTH = 20
+const FEET_HEIGHT = 10
+/** Atlas pages fetched at once while filling in the background. */
+const PAGE_CONCURRENCY = 3
+/** Placeholder marker size, in scene pixels. */
+const MARKER_WIDTH = 16
+const MARKER_HEIGHT = 26
+
+/** Live scene state, also published for automated checks. */
+export interface ActSceneState {
+  ready: boolean
+  /** Where the map came from: a prebaked pack or the archives. */
+  source: 'pack' | 'live' | ''
+  act: number
+  level: string
+  quadrant: string
+  quadrants: string[]
+  /** The archive/pack location actually used. */
+  base: string
+  cellsX: number
+  cellsY: number
+  widthPx: number
+  heightPx: number
+  floors: number
+  walls: number
+  frames: number
+  /** Atlas pages loaded and total. */
+  pagesLoaded: number
+  pagesTotal: number
+  /** Pages that had arrived when the first frame was drawn. */
+  pagesAtFirstFrame: number
+  /** Milliseconds from boot to the first drawn frame. */
+  firstFrameMs: number
+  /** Page indices the spawn viewport needed, for diagnostics. */
+  priorityPages: number[]
+  /** Draws skipped because their page had not arrived yet. */
+  skippedDraws: number
+  /** Objects the pack places (their art still needs the DCC/COF decoder). */
+  objects: number
+  /** Roof draws, painted in their own pass after the character. */
+  roofs: number
+  /** Whether the composited Sorceress sprite is in use (else the marker). */
+  character: boolean
+  /** DCC members that went into the character sprite. */
+  characterMembers: number
+  /** Frames the character path has actually drawn; 0 while the marker is in use. */
+  characterFrames: number
+  /** Last group the character path selected (walk or stand, times 8 directions). */
+  characterGroup: number
+  /** Milliseconds from boot to the first rendered frame. */
+  loadMs: number
+  missing: number
+  walkable: number
+  x: number
+  y: number
+  facing: number
+  tick: number
+  tickRate: number
+  drawCalls: number
+  /** Current zoom factor and the canvas backing-store size. */
+  zoom: number
+  canvasWidth: number
+  canvasHeight: number
+  error: string | null
+}
+
+declare global {
+  interface Window {
+    /** Act scene state for automation and debugging. */
+    __d2webAct?: ActSceneState
+  }
+}
+
+const state: ActSceneState = {
+  ready: false, source: '', act: 1, level: '', quadrant: '', quadrants: [], base: '', roofs: 0,
+  cellsX: 0, cellsY: 0, widthPx: 0, heightPx: 0, floors: 0, walls: 0, frames: 0,
+  pagesLoaded: 0, pagesTotal: 0, pagesAtFirstFrame: -1, firstFrameMs: 0, priorityPages: [],
+  character: false, characterMembers: 0, characterFrames: 0, characterGroup: -1,
+  skippedDraws: 0, objects: 0, loadMs: 0,
+  missing: 0, walkable: 0, x: 0, y: 0, facing: 0, tick: 0, tickRate: 0,
+  drawCalls: 0, zoom: 0, canvasWidth: 0, canvasHeight: 0, error: null,
+}
+window.__d2webAct = state
+
+/** One tile to draw. */
+interface Drawable {
+  readonly frame: AtlasFrame
+  readonly x: number
+  readonly y: number
+  readonly cellX: number
+  readonly cellY: number
+  /** Atlas page index this frame lives on. */
+  readonly page: number
+}
+
+/** Everything the render loop needs, from either data path. */
+interface MapRuntime {
+  readonly source: 'pack' | 'live'
+  readonly base: string
+  readonly level: string
+  readonly act: number
+  readonly quadrants: readonly string[]
+  /**
+   * Which query parameter names the currently shown map block.
+   *
+   * The pack path selects a prebaked map by its entry label (`?level=`), the live
+   * path selects a DS1 file inside one level (`?quadrant=`). Crossing the two
+   * silently falls back to the act's town, so each runtime declares its own.
+   */
+  readonly quadrantParam: 'level' | 'quadrant'
+  readonly quadrant: string
+  readonly cellsX: number
+  readonly cellsY: number
+  readonly widthPx: number
+  readonly heightPx: number
+  readonly grid: CollisionGrid
+  readonly floors: readonly Drawable[]
+  readonly walls: readonly Drawable[]
+  /** Roof draws: painted after the character, so a roof covers what walks under it. */
+  readonly roofs: readonly Drawable[]
+  readonly spawn: { x: number; y: number }
+  readonly objects: number
+  readonly frames: number
+  /** Whether the real character art is in use. */
+  readonly notes: readonly string[]
+  /** Handles by page index; a hole means "not loaded yet". */
+  readonly pages: (AtlasHandle | null)[]
+  /** Archive directories to try for the character archive, in order. */
+  readonly charBases: readonly string[]
+  /** Act palette for the character atlas, when the pack carries one. */
+  readonly palette: Palette | null
+  /** Pages the first frame needs (spawn viewport). */
+  readonly priorityPages: readonly number[]
+  /** Priority pages first, then everything else. */
+  readonly loadOrder: readonly number[]
+  /** Upload specific pages, a few in flight at a time. */
+  loadPages(renderer: SpriteRenderer, indices: readonly number[], onProgress: () => void): Promise<void>
+}
+
+/**
+ * Match the canvas backing store to its on-screen size.
+ *
+ * The canvas fills the window, so its pixel size has to follow the window *and*
+ * the device pixel ratio, or the browser scales a small buffer up and every tile
+ * edge goes soft. The backing store is capped because a 4K retina window would
+ * otherwise ask for a 30-megapixel framebuffer the software GL path cannot keep
+ * up with.
+ *
+ * @param canvas - the canvas element.
+ * @returns the CSS size the camera should treat as the viewport.
+ */
+function syncCanvasSize(canvas: HTMLCanvasElement): { width: number; height: number } {
+  const dpr = Math.min(window.devicePixelRatio || 1, 2)
+  const cssWidth = Math.max(320, canvas.clientWidth || window.innerWidth)
+  const cssHeight = Math.max(240, canvas.clientHeight || window.innerHeight)
+  const maxPixels = 1920 * 1200
+  const scale = Math.min(dpr, Math.sqrt(maxPixels / (cssWidth * cssHeight)))
+  const width = Math.max(1, Math.round(cssWidth * scale))
+  const height = Math.max(1, Math.round(cssHeight * scale))
+  if (canvas.width !== width || canvas.height !== height) {
+    canvas.width = width
+    canvas.height = height
+  }
+  return { width: cssWidth, height: cssHeight }
+}
+
+/**
+ * The zoom that makes a map cover the viewport.
+ *
+ * "Fill the screen" means the map should not sit in the middle with empty space
+ * around it, so this is the *cover* scale (`max`), not the fit scale (`min`): a
+ * map wider than the viewport is zoomed until it covers, and a small map is
+ * zoomed in until it does. The result is clamped so a tiny 17×20 level does not
+ * turn into a handful of giant pixels.
+ *
+ * @param mapWidth - map width in scene pixels.
+ * @param mapHeight - map height in scene pixels.
+ * @param viewport - viewport size in CSS pixels.
+ * @returns the zoom factor.
+ */
+function coverZoom(mapWidth: number, mapHeight: number, viewport: { width: number; height: number }): number {
+  if (mapWidth <= 0 || mapHeight <= 0) return 1.6
+  const cover = Math.max(viewport.width / mapWidth, viewport.height / mapHeight)
+  return Math.min(6, Math.max(0.9, cover))
+}
+
+/**
+ * Read a URL parameter.
+ *
+ * @param key - parameter name.
+ * @param fallback - value when absent.
+ * @returns the value.
+ */
+function param(key: string, fallback: string): string {
+  return new URLSearchParams(location.search).get(key) ?? fallback
+}
+
+/**
+ * Fetch JSON, with the HTTP status in the error when it fails.
+ *
+ * @param url - location.
+ * @returns the parsed JSON.
+ */
+async function fetchJson<T>(url: string): Promise<T> {
+  const response = await fetch(url)
+  if (!response.ok) throw new Error(`${url}: HTTP ${String(response.status)}`)
+  return await response.json() as T
+}
+
+/** A pack's index file. */
+interface PackIndex {
+  readonly palettes?: Record<string, number[]>
+  readonly levels: readonly {
+    readonly act: number
+    readonly slug: string
+    readonly label: string
+    readonly levelName: string
+    readonly path: string
+    readonly pages: number
+  }[]
+}
+
+/** A pack's per-map scene file. */
+interface PackSceneJson {
+  readonly act: number
+  readonly levelName: string
+  readonly ds1: string
+  readonly cellsX: number
+  readonly cellsY: number
+  readonly originX: number
+  readonly originY: number
+  readonly widthPx: number
+  readonly heightPx: number
+  readonly pages: readonly { readonly file: string; readonly width: number; readonly height: number }[]
+  readonly frames: readonly (readonly number[])[]
+  readonly framePlacement: readonly (readonly number[])[]
+  readonly floors: readonly (readonly number[])[]
+  readonly walls: readonly (readonly number[])[]
+  /** Roof draws, painted after everything else (absent in older packs). */
+  readonly roofs?: readonly (readonly number[])[]
+  readonly objects: readonly unknown[]
+  readonly collision: { readonly width: number; readonly height: number; readonly runs: readonly (readonly number[])[] }
+  readonly spawn: readonly number[] | null
+  readonly stats: { readonly missingTiles: number; readonly walkable: number }
+}
+
+/**
+ * Build the runtime for a prebaked pack.
+ *
+ * @param packBase - directory holding `index.json`.
+ * @param act - act to open.
+ * @param wantedLevel - `?level=` label, when the caller picked one.
+ * @returns the runtime, or null when no pack covers this act.
+ */
+async function loadPackRuntime(
+  packBase: string,
+  act: number,
+  wantedLevel: string,
+  viewport: { width: number; height: number },
+  charBases: readonly string[],
+): Promise<MapRuntime | null> {
+  let index: PackIndex
+  try {
+    index = await fetchJson<PackIndex>(`${packBase}/index.json`)
+  } catch {
+    return null
+  }
+  const forAct = index.levels.filter(entry => entry.act === act)
+  if (forAct.length === 0) return null
+  const entry = (wantedLevel === ''
+    ? undefined
+    : forAct.find(candidate => candidate.label === wantedLevel)
+      ?? forAct.find(candidate => candidate.slug === wantedLevel))
+    ?? forAct.find(candidate => candidate.slug === 'town')
+    ?? forAct[0]!
+  const scene = await fetchJson<PackSceneJson>(`${packBase}/${entry.path}/scene.json`)
+
+  const frames: AtlasFrame[] = scene.framePlacement.map(place => ({
+    x: place[1] ?? 0, y: place[2] ?? 0, width: place[3] ?? 1, height: place[4] ?? 1,
+  }))
+  const toDrawable = (row: readonly number[]): Drawable => {
+    const frameIndex = row[0] ?? 0
+    return {
+      frame: frames[frameIndex] ?? { x: 0, y: 0, width: 1, height: 1 },
+      x: row[1] ?? 0,
+      y: row[2] ?? 0,
+      cellX: row[3] ?? 0,
+      cellY: row[4] ?? 0,
+      page: scene.framePlacement[frameIndex]?.[0] ?? 0,
+    }
+  }
+  const floors = scene.floors.map(toDrawable)
+  const walls = scene.walls.map(toDrawable)
+  const roofs = (scene.roofs ?? []).map(toDrawable)
+
+  // Collision arrives as runs; expanding it here keeps the JSON small and yields
+  // exactly the grid the live path would have produced.
+  const blocked = new Uint8Array(scene.collision.width * scene.collision.height)
+  let at = 0
+  for (const run of scene.collision.runs) {
+    const value = run[0] ?? 0
+    const length = run[1] ?? 0
+    if (value !== 0) blocked.fill(value, at, Math.min(at + length, blocked.length))
+    at += length
+  }
+  const grid: CollisionGrid = {
+    originX: scene.originX,
+    originY: scene.originY,
+    cellsX: scene.cellsX,
+    cellsY: scene.cellsY,
+    blocked,
+    gridWidth: scene.collision.width,
+  }
+  const spawn = scene.spawn === null || scene.spawn === undefined
+    ? (findIsoSpawn(grid) ?? { x: scene.widthPx / 2, y: scene.heightPx / 2 })
+    : { x: scene.spawn[0] ?? 0, y: scene.spawn[1] ?? 0 }
+
+  // The pack carries the act palette, which the character atlas needs; without it
+  // the character simply stays a marker rather than rendering in wrong colours.
+  const paletteRgb = index.palettes?.[`act${String(scene.act)}`]
+  const packPalette: Palette | null = paletteRgb === undefined
+    ? null
+    : { rgb: Uint8Array.from(paletteRgb), size: 256 }
+  const pages: (AtlasHandle | null)[] = scene.pages.map(() => null)
+  const priority = pagesNeededForViewport(floors, walls, spawn, viewport, coverZoom(scene.widthPx, scene.heightPx, viewport))
+  const loadOrder = [...priority, ...pages.map((_, index) => index).filter(index => !priority.includes(index))]
+
+  return {
+    source: 'pack',
+    base: packBase,
+    charBases,
+    palette: packPalette,
+    level: scene.levelName,
+    act: scene.act,
+    quadrants: forAct.map(candidate => candidate.label),
+    quadrantParam: 'level',
+    quadrant: entry.label,
+    cellsX: scene.cellsX,
+    cellsY: scene.cellsY,
+    widthPx: scene.widthPx,
+    heightPx: scene.heightPx,
+    grid,
+    floors,
+    walls,
+    roofs,
+    spawn,
+    objects: scene.objects.length,
+    frames: scene.frames.length,
+    notes: [`首屏页 ${priority.join(',')}，共 ${String(pages.length)} 页`],
+    pages,
+    priorityPages: priority,
+    loadOrder,
+    async loadPages(renderer, indices, onProgress) {
+      const queue = indices.filter(index => pages[index] === null)
+      let cursor = 0
+      const workers = Array.from({ length: Math.min(PAGE_CONCURRENCY, queue.length) }, async () => {
+        for (;;) {
+          const index = queue[cursor]
+          cursor += 1
+          if (index === undefined) return
+          const page = scene.pages[index]!
+          const response = await fetch(`${packBase}/${entry.path}/${page.file}`)
+          if (!response.ok) throw new Error(`${page.file}: HTTP ${String(response.status)}`)
+          const bitmap = await createImageBitmap(await response.blob())
+          try {
+            pages[index] = renderer.addAtlas(bitmap, page.width, page.height)
+          } finally {
+            bitmap.close()
+          }
+          onProgress()
+        }
+      })
+      await Promise.all(workers)
+    },
+  }
+}
+
+/**
+ * Which pages the first frame needs.
+ *
+ * Only the pages whose tiles intersect a box around the spawn point: later pages
+ * can be megabytes, and none of their tiles are on screen yet.
+ *
+ * @param floors - floor draws.
+ * @param walls - wall draws.
+ * @param spawn - spawn point in scene pixels.
+ * @returns page indices, ascending.
+ */
+function pagesNeededForViewport(
+  floors: readonly Drawable[],
+  walls: readonly Drawable[],
+  spawn: { x: number; y: number },
+  viewport: { width: number; height: number },
+  zoom: number,
+): number[] {
+  // The first frame must cover what is *actually* on screen: a full-screen
+  // canvas shows far more world than the fixed 960×560 it used to assume, and a
+  // page that is not loaded draws nothing at all.
+  const halfWidth = viewport.width / zoom / 2 + 96
+  const halfHeight = viewport.height / zoom / 2 + 96
+  const left = spawn.x - halfWidth
+  const right = spawn.x + halfWidth
+  const top = spawn.y - halfHeight
+  const bottom = spawn.y + halfHeight
+  const needed = new Set<number>()
+  for (const draw of [...floors, ...walls]) {
+    if (draw.x + draw.frame.width < left || draw.x > right) continue
+    if (draw.y + draw.frame.height < top || draw.y > bottom) continue
+    needed.add(draw.page)
+  }
+  if (needed.size === 0) needed.add(0)
+  return [...needed].sort((a, b) => a - b)
+}
+
+/**
+ * Build the runtime by reading and decoding the archives.
+ *
+ * @param base - directory holding the archives.
+ * @param act - act to open.
+ * @param renderer - renderer that receives the atlas.
+ * @param wantedQuadrant - `?quadrant=` member name, when given.
+ * @returns the runtime.
+ */
+async function loadLiveRuntime(
+  base: string,
+  act: number,
+  renderer: SpriteRenderer,
+  wantedQuadrant: string,
+): Promise<MapRuntime> {
+  const archives = new MountedArchives()
+  const notes: string[] = []
+  for (const name of [...DATA_ARCHIVES, CHARACTER_ARCHIVE]) {
+    try {
+      const source = await httpRangeSource(`${base}/${name}`, name)
+      archives.add(name, await MpqArchive.open(source))
+    } catch (err) {
+      notes.push(`${name}: ${(err as Error).message}`)
+    }
+  }
+  if (archives.size === 0) throw new Error(`no archive could be mounted from ${base}`)
+
+  const tables = await loadActTables(archives)
+  const wantedLevel = param('level', '')
+  const town: LevelInfo = wantedLevel === ''
+    ? resolveActTown(tables, act)
+    : resolveLevel(tables, Number(wantedLevel), act)
+  const quadrants = town.ds1Names.map(name => name.split('\\').pop() ?? name)
+  const wanted = wantedQuadrant === '' ? (quadrants[0] ?? '') : wantedQuadrant
+  const index = Math.max(0, quadrants.indexOf(wanted))
+
+  const level = decodeDs1(await archives.read(town.ds1Names[index]!))
+  const libraries = []
+  for (const name of town.dt1Names) libraries.push(decodeDt1(await archives.read(name)))
+  const pl2 = decodePl2(await archives.read(town.paletteName))
+  const palette: Palette = { rgb: pl2.rgb, size: 256 }
+  const scene = buildIsoMapScene(level, libraries, levelSeed(town.ds1Names[index] ?? town.levelName))
+  const atlas = buildAtlasThatFits(renderer, scene.sheet, palette)
+  const frames = atlas.groups[0] ?? []
+  const toDrawable = (row: { frameIndex: number; x: number; y: number; cellX: number; cellY: number }): Drawable => ({
+    frame: frames[row.frameIndex] ?? { x: 0, y: 0, width: 1, height: 1 },
+    x: row.x,
+    y: row.y,
+    cellX: row.cellX,
+    cellY: row.cellY,
+    page: 0,
+  })
+  return {
+    source: 'live',
+    base,
+    charBases: [base],
+    palette,
+    level: town.levelName,
+    act,
+    quadrants,
+    quadrantParam: 'quadrant',
+    quadrant: quadrants[index] ?? '',
+    cellsX: scene.cellsX,
+    cellsY: scene.cellsY,
+    widthPx: scene.widthPx,
+    heightPx: scene.heightPx,
+    grid: scene,
+    floors: scene.floors.map(toDrawable),
+    walls: scene.walls.map(toDrawable),
+    roofs: scene.roofs.map(toDrawable),
+    spawn: findIsoSpawn(scene) ?? { x: scene.widthPx / 2, y: scene.heightPx / 2 },
+    objects: level.objects.length,
+    frames: scene.frames.length,
+    notes,
+    pages: [renderer.defaultAtlasHandle],
+    priorityPages: [0],
+    loadOrder: [0],
+    loadPages: async () => {},
+  }
+}
+
+/**
+ * Build the tile atlas at the first width the renderer accepts.
+ *
+ * @param renderer - the sprite renderer, used as the size oracle.
+ * @param sheet - the scene's tile sheet.
+ * @param palette - the act palette.
+ * @returns the uploaded atlas.
+ */
+function buildAtlasThatFits(renderer: SpriteRenderer, sheet: SpriteSheet, palette: Palette): SpriteAtlas {
+  let lastError: unknown = null
+  for (const width of [4096, 8192, 16384]) {
+    const atlas = buildAtlas(sheet, palette, undefined, { width })
+    try {
+      renderer.setAtlas(atlas)
+      return atlas
+    } catch (err) {
+      lastError = err
+      console.warn(`atlas ${String(atlas.width)}x${String(atlas.height)} rejected: ${(err as Error).message}`)
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error('no atlas size the renderer accepts')
+}
+
+/**
+ * Fill in the remaining pages without blocking the first frames.
+ *
+ * @param runtime - the runtime.
+ * @param renderer - renderer to upload into.
+ */
+function preloadRemaining(runtime: MapRuntime, renderer: SpriteRenderer): void {
+  const rest = runtime.loadOrder.slice(1)
+  if (rest.length === 0) return
+  void runtime.loadPages(renderer, rest, () => {
+    state.pagesLoaded = runtime.pages.filter(page => page !== null).length
+  }).catch((err: unknown) => {
+    console.warn(`page preload: ${(err as Error).message}`)
+  })
+}
+
+/** A composited character, uploaded as its own atlas page. */
+interface LoadedCharacter {
+  readonly handle: AtlasHandle
+  /** `atlas.groups[direction][frame]`, ready to draw. */
+  readonly groups: readonly (readonly AtlasFrame[])[]
+  readonly directions: number
+  readonly walk: number
+  readonly stand: number
+  readonly members: number
+}
+
+/**
+ * Load the player's art from the character archive.
+ *
+ * The map comes from the pack, but a character is not map data: it is eight DCC
+ * layers plus a COF, ~1–3 MB that the archive serves on demand. Loading it after
+ * the first frame means the map is walkable while the Sorceress is still
+ * arriving, and if the archive is unreachable the page keeps the marker.
+ *
+ * @param base - archive directory.
+ * @param palette - the act palette (from the pack index).
+ * @param renderer - renderer to upload into.
+ * @returns the character, or null when it could not be loaded.
+ */
+async function loadCharacterArt(
+  bases: readonly string[],
+  palette: Palette,
+  renderer: SpriteRenderer,
+): Promise<LoadedCharacter | null> {
+  try {
+    const archives = new MountedArchives()
+    let mounted = false
+    for (const base of bases) {
+      try {
+        archives.add(CHARACTER_ARCHIVE, await MpqArchive.open(await httpRangeSource(`${base}/${CHARACTER_ARCHIVE}`, CHARACTER_ARCHIVE)))
+        mounted = true
+        break
+      } catch (err) {
+        console.warn(`${base}/${CHARACTER_ARCHIVE}: ${(err as Error).message}`)
+      }
+    }
+    if (!mounted) return null
+    const walk = await loadCharacterSheet(archives, 'so', 'wl', 'hth')
+    const stand = await loadCharacterSheet(archives, 'so', 'nu', 'hth')
+    const joined: SpriteSheet = { groups: [...walk.sheet.groups, ...stand.sheet.groups], width: null }
+    const atlas = buildAtlas(joined, palette, undefined, { width: 1024 })
+    const handle = renderer.addAtlas({ pixels: atlas.pixels, width: atlas.width, height: atlas.height })
+    const walkCount = walk.sheet.groups.length
+    return {
+      handle,
+      groups: atlas.groups,
+      directions: walk.directions,
+      walk: 0,
+      stand: walkCount,
+      members: walk.members.length + stand.members.length,
+    }
+  } catch (err) {
+    console.warn(`character art unavailable: ${(err as Error).message}`)
+    return null
+  }
+}
+
+/**
+ * Run the loop for a runtime.
+ *
+ * @param runtime - the map.
+ * @param renderer - the renderer (already holding the atlas or the first pages).
+ * @param started - `performance.now()` when boot began.
+ */
+function runScene(runtime: MapRuntime, renderer: SpriteRenderer, started: number): void {
+  const canvas = document.querySelector<HTMLCanvasElement>('#view')!
+  const status = document.querySelector<HTMLElement>('#status')!
+  const hud = document.querySelector<HTMLElement>('#hud')!
+  const actSelect = document.querySelector<HTMLSelectElement>('#act')!
+  const variantSelect = document.querySelector<HTMLSelectElement>('#variant')!
+
+  const player = { x: runtime.spawn.x, y: runtime.spawn.y, facing: 0, walkFrame: 0, moving: false }
+  const input = new KeyboardInput()
+  input.attach()
+  let skippedDraws = 0
+
+  // Zoom: default to "cover the window", with manual override for looking around.
+  let character: LoadedCharacter | null = null
+  let zoom = coverZoom(runtime.widthPx, runtime.heightPx, syncCanvasSize(canvas))
+  let manualZoom = false
+  const setZoom = (value: number): void => {
+    manualZoom = true
+    zoom = Math.min(8, Math.max(0.4, value))
+  }
+  const onWheel = (event: WheelEvent): void => {
+    event.preventDefault()
+    setZoom(zoom * (event.deltaY < 0 ? 1.12 : 1 / 1.12))
+  }
+  const onKeyZoom = (event: KeyboardEvent): void => {
+    if (event.code === 'Equal' || event.code === 'NumpadAdd') setZoom(zoom * 1.15)
+    if (event.code === 'Minus' || event.code === 'NumpadSubtract') setZoom(zoom / 1.15)
+    if (event.code === 'Digit0') { manualZoom = false; zoom = coverZoom(runtime.widthPx, runtime.heightPx, syncCanvasSize(canvas)) }
+  }
+  const onResize = (): void => {
+    const size = syncCanvasSize(canvas)
+    if (!manualZoom) zoom = coverZoom(runtime.widthPx, runtime.heightPx, size)
+    state.zoom = Number(zoom.toFixed(2))
+  }
+  canvas.addEventListener('wheel', onWheel, { passive: false })
+  window.addEventListener('keydown', onKeyZoom)
+  window.addEventListener('resize', onResize)
+
+  const loop = new GameLoop({
+    tickRate: 25,
+    onTick: () => {
+      const movement = input.movement()
+      player.moving = movement.x !== 0 || movement.y !== 0
+      if (player.moving) {
+        // Input is screen-space: the diamond lattice is rotated 45° from the
+        // screen axes, so "north" walks along a cell diagonal.
+        const length = Math.hypot(movement.x, movement.y)
+        const step = (WALK_SPEED / 25) / length
+        if (!collides(runtime.grid, player.x + movement.x * step, player.y)) player.x += movement.x * step
+        if (!collides(runtime.grid, player.x, player.y + movement.y * step)) player.y += movement.y * step
+        player.facing = facingOf(movement.x, movement.y)
+        player.walkFrame = (player.walkFrame + 1) % 24
+      } else {
+        player.walkFrame = 0
+      }
+      state.tick = loop.tick
+      state.x = player.x
+      state.y = player.y
+      state.facing = player.facing
+    },
+    onRender: () => {
+      if (state.pagesAtFirstFrame < 0) {
+        state.pagesAtFirstFrame = runtime.pages.filter(page => page !== null).length
+        state.firstFrameMs = Math.round(performance.now() - started)
+      }
+      renderer.begin({ x: player.x, y: player.y - 16, zoom }, [0.03, 0.03, 0.04])
+      skippedDraws = 0
+      const drawTiles = (list: readonly Drawable[], from: number, to: number): void => {
+        for (let index = from; index < to; index += 1) {
+          const draw = list[index]!
+          const page = runtime.pages[draw.page]
+          if (page === null || page === undefined) { skippedDraws += 1; continue }
+          renderer.draw(draw.frame, draw.x, draw.y, { atlas: page })
+        }
+      }
+      drawTiles(runtime.floors, 0, runtime.floors.length)
+      const cell = cellOf(runtime.grid, player.x, player.y)
+      const insertAt = depthInsertIndex(runtime.walls, cell.x, cell.y)
+      drawTiles(runtime.walls, 0, insertAt)
+      if (character === null) {
+        // Placeholder until the character archive has been read.
+        renderer.drawSolid(player.x - MARKER_WIDTH / 2, player.y - MARKER_HEIGHT, MARKER_WIDTH, MARKER_HEIGHT, [0.85, 0.75, 0.45, 1])
+        renderer.drawSolid(player.x - MARKER_WIDTH / 2, player.y - 6, MARKER_WIDTH, 6, [0.35, 0.25, 0.15, 1])
+      } else {
+        const direction = facingToDirection(player.facing, character.directions)
+        const groupIndex = character.walk + (player.moving ? direction : character.stand)
+        const group = character.groups[groupIndex] ?? character.groups[character.walk + direction]
+        const frameIndex = player.moving
+          ? Math.floor(player.walkFrame / 3) % Math.max(1, group?.length ?? 1)
+          : 0
+        const frame = group?.[frameIndex]
+        if (frame !== undefined) {
+          // Feet at the player's position: the composited frame is anchored by its
+          // bottom edge, which is where the COF puts the sprite's origin.
+          renderer.draw(frame, player.x - frame.width / 2, player.y - frame.height + FEET_HEIGHT / 2, { atlas: character.handle })
+          state.characterFrames += 1
+          state.characterGroup = groupIndex
+        }
+      }
+      drawTiles(runtime.walls, insertAt, runtime.walls.length)
+      // Roofs last, in their own pass: the engine paints them after every other
+      // layer so they cover the floor, the walls and anything walking under them.
+      drawTiles(runtime.roofs, 0, runtime.roofs.length)
+      renderer.flush()
+      state.drawCalls = 1
+      state.tickRate = loop.tickRate
+      state.zoom = Number(zoom.toFixed(2))
+      state.canvasWidth = canvas.width
+      state.canvasHeight = canvas.height
+      state.pagesLoaded = runtime.pages.filter(page => page !== null).length
+      state.skippedDraws = skippedDraws
+      hud.textContent = `${runtime.level} · ${runtime.quadrant} · ${runtime.source === 'pack' ? '资源包' : '读归档'}`
+        + ` · ${String(runtime.cellsX)}×${String(runtime.cellsY)} 格 · ${String(runtime.floors.length)} 地面 / ${String(runtime.walls.length)} 墙`
+        + ` · 页 ${String(state.pagesLoaded)}/${String(state.pagesTotal)}`
+        + ` · 对象 ${String(runtime.objects)} · ${loop.tickRate.toFixed(1)} tps · pos ${player.x.toFixed(0)},${player.y.toFixed(0)}`
+        + (skippedDraws > 0 ? ` · 待页 ${String(skippedDraws)}` : '')
+    },
+  })
+  loop.start()
+  state.ready = true
+  state.loadMs = Math.round(performance.now() - started)
+  // Only the live path fills the selectors here: the pack path already built them from
+  // the index (`populatePackSelectors`), and overwriting them with the single level this
+  // runtime knows would collapse the three-level hierarchy back into one flat list.
+  if (runtime.source === 'live') populateLiveSelectors(runtime)
+  void variantSelect
+  status.textContent = 'WASD / 方向键移动。'
+    + (runtime.source === 'pack'
+      ? `资源包：首屏 ${String(state.pagesLoaded)}/${String(state.pagesTotal)} 页，${String(state.loadMs)} ms 出画面，其余页后台补。`
+      : '本次直接读归档并解码（较慢）：资源包不可用时会走这条路。')
+    + (state.character
+      ? ` 角色为真·女法师（DCC+COF 合成，${String(state.characterMembers)} 层）。`
+      : ' 角色暂为占位棋子：d2char.mpq 不可用时会退回这里。')
+    + ' 可破坏物品的位置与美术成员已进包，静态帧待接。'
+
+  preloadRemaining(runtime, renderer)
+  if (runtime.palette !== null) {
+    const paletteForCharacter = runtime.palette
+    void loadCharacterArt(runtime.charBases, paletteForCharacter, renderer).then((loaded) => {
+      character = loaded
+      state.character = loaded !== null
+      if (loaded !== null) state.characterMembers = loaded.members
+      // The status line is written before this promise settles, so refresh it: leaving
+      // "占位棋子" on screen while the real sprite is already drawing is a lie the user
+      // actually sees (it showed up in a screenshot review).
+      status.textContent = status.textContent.replace(
+        loaded === null
+          ? ' 角色暂为占位棋子：d2char.mpq 不可用时会退回这里。'
+          : / 角色[^。]*。/u,
+        loaded === null
+          ? ' 角色暂为占位棋子：d2char.mpq 不可用时会退回这里。'
+          : ` 角色为真·女法师（DCC+COF 合成，${String(loaded.members)} 层）。`,
+      )
+    })
+  }
+}
+
+/**
+ * Whether a feet box at a point overlaps blocked sub-tiles.
+ *
+ * @param grid - the collision grid.
+ * @param x - feet centre x.
+ * @param y - feet centre y.
+ * @returns true when blocked.
+ */
+function collides(grid: CollisionGrid, x: number, y: number): boolean {
+  for (const [dx, dy] of [[-1, -1], [1, -1], [-1, 1], [1, 1]] as const) {
+    if (isBlockedAt(grid, x + (dx * FEET_WIDTH) / 2, y + (dy * FEET_HEIGHT) / 2)) return true
+  }
+  return false
+}
+
+/**
+ * The cell containing a scene point.
+ *
+ * @param grid - the collision grid.
+ * @param x - scene x.
+ * @param y - scene y.
+ * @returns rounded-down cell coordinates.
+ */
+function cellOf(grid: CollisionGrid, x: number, y: number): { x: number; y: number } {
+  const px = x - grid.originX
+  const py = y - grid.originY
+  return {
+    x: Math.floor((px / ORTHO_CELL_WIDTH + py / ORTHO_CELL_HEIGHT) / 2),
+    y: Math.floor((py / ORTHO_CELL_HEIGHT - px / ORTHO_CELL_WIDTH) / 2),
+  }
+}
+
+/**
+ * The facing index for a screen-space direction.
+ *
+ * @param x - screen x direction, -1..1.
+ * @param y - screen y direction, -1..1 (down positive).
+ * @returns the facing index, 0 = north.
+ */
+function facingOf(x: number, y: number): number {
+  const angle = Math.atan2(x, -y)
+  return Math.round((angle / (Math.PI / 4)) + 8) % 8
+}
+
+/**
+ * Copy a runtime's description into the published state.
+ *
+ * @param runtime - the runtime.
+ * @param base - location the data came from.
+ */
+function publish(runtime: MapRuntime, base: string): void {
+  state.source = runtime.source
+  state.base = base
+  state.act = runtime.act
+  state.level = runtime.level
+  state.quadrant = runtime.quadrant
+  state.quadrants = [...runtime.quadrants]
+  state.cellsX = runtime.cellsX
+  state.cellsY = runtime.cellsY
+  state.widthPx = runtime.widthPx
+  state.heightPx = runtime.heightPx
+  state.floors = runtime.floors.length
+  state.walls = runtime.walls.length
+  state.frames = runtime.frames
+  state.pagesTotal = runtime.pages.length
+  state.pagesLoaded = runtime.pages.filter(page => page !== null).length
+  state.priorityPages = [...runtime.priorityPages]
+  state.objects = runtime.objects
+  state.roofs = runtime.roofs.length
+  state.missing = 0
+  state.walkable = 1 - [...runtime.grid.blocked].reduce((sum, value) => sum + value, 0) / runtime.grid.blocked.length
+}
+
+/**
+ * Fill the level picker from a pack index and wire it to navigation.
+ *
+ * Every baked map is one entry, grouped by act. Picking one reloads the page with
+ * `?act=` and `?level=`, which is the same query the loader already understands,
+ * so the picker needs no second loading path.
+ *
+ * @param packBase - directory holding `index.json`.
+ * @param current - the act and the entry label currently displayed (`runtime.quadrant`),
+ *   so the list marks exactly the map that is on screen.
+ */
+async function populatePackSelectors(packBase: string, current: { act: number; label: string }): Promise<void> {
+  const actSelect = document.querySelector<HTMLSelectElement>('#act')
+  const sceneSelect = document.querySelector<HTMLSelectElement>('#scene')
+  const variantSelect = document.querySelector<HTMLSelectElement>('#variant')
+  if (actSelect === null || sceneSelect === null || variantSelect === null) return
+  let index: PackIndex
+  try {
+    index = await fetchJson<PackIndex>(`${packBase}/index.json`)
+  } catch {
+    return
+  }
+
+  /** A scene type: one `Levels.txt` level, with every baked DS1 variant under it. */
+  interface Scene {
+    readonly slug: string
+    readonly name: string
+    readonly variants: readonly PackIndex['levels'][number][]
+  }
+
+  const scenesByAct = new Map<number, Scene[]>()
+  for (const entry of index.levels) {
+    let scenes = scenesByAct.get(entry.act)
+    if (scenes === undefined) { scenes = []; scenesByAct.set(entry.act, scenes) }
+    let scene = scenes.find(candidate => candidate.slug === entry.slug)
+    if (scene === undefined) {
+      scene = { slug: entry.slug, name: sceneNameZh(entry.slug, entry.levelName), variants: [] }
+      scenes.push(scene)
+    }
+    ;(scene.variants as PackIndex['levels'][number][]).push(entry)
+  }
+
+  /** The suffix after the level slug, which is the DS1's own name fragment. */
+  const suffixOf = (entry: PackIndex['levels'][number]): string =>
+    entry.label.startsWith(`${entry.slug}-`) ? entry.label.slice(entry.slug.length + 1) : entry.label
+
+  const optionFor = (value: string, text: string, selected: boolean): HTMLOptionElement => {
+    const option = document.createElement('option')
+    option.value = value
+    option.textContent = text
+    option.selected = selected
+    return option
+  }
+
+  const acts = [...scenesByAct.keys()].sort((left, right) => left - right)
+  actSelect.replaceChildren(...acts.map(act => optionFor(
+    String(act),
+    `${ACT_NAMES_ZH[act] ?? `第 ${String(act)} 章`}`,
+    act === current.act,
+  )))
+  actSelect.disabled = acts.length === 0
+
+  const scenes = scenesByAct.get(current.act) ?? []
+  const currentEntry = index.levels.find(entry => entry.act === current.act && entry.label === current.label)
+  const currentSceneSlug = currentEntry?.slug ?? scenes[0]?.slug ?? ''
+  sceneSelect.replaceChildren(...scenes.map(scene => optionFor(
+    scene.slug,
+    scene.name,
+    scene.slug === currentSceneSlug,
+  )))
+  sceneSelect.disabled = scenes.length === 0
+
+  const populateVariants = (slug: string, selectedLabel: string): void => {
+    const scene = scenes.find(candidate => candidate.slug === slug)
+    const variants = scene?.variants ?? []
+    // A single-variant scene still shows its own DS1 so the third selector is never
+    // an empty box; the option text repeats the scene name only when it is the only one.
+    variantSelect.replaceChildren(...variants.map(entry => {
+      const suffix = suffixOf(entry)
+      const label = variants.length > 1 ? variantLabelZh(suffix) : `${scene?.name ?? entry.levelName}（${suffix}）`
+      return optionFor(entry.label, label, entry.label === selectedLabel)
+    }))
+    variantSelect.disabled = variants.length === 0
+  }
+  populateVariants(currentSceneSlug, current.label)
+  variantSelect.dataset.scene = currentSceneSlug
+
+  const go = (params: URLSearchParams): void => { location.search = params.toString() }
+  const navigateToLabel = (label: string, act: number): void => {
+    const params = new URLSearchParams(location.search)
+    params.set('act', String(act))
+    params.set('level', label)
+    go(params)
+  }
+
+  actSelect.onchange = () => {
+    const act = Number(actSelect.value)
+    const first = scenesByAct.get(act)?.[0]
+    // Keep the address bar and the map in sync: an act with no baked scene yet (there
+    // are none today) simply leaves the current map alone.
+    if (first === undefined) return
+    navigateToLabel(first.variants[0]?.label ?? '', act)
+  }
+  sceneSelect.onchange = () => {
+    const scene = scenes.find(candidate => candidate.slug === sceneSelect.value)
+    if (scene === undefined) return
+    populateVariants(scene.slug, '')
+    navigateToLabel(scene.variants[0]?.label ?? '', current.act)
+  }
+  variantSelect.onchange = () => { navigateToLabel(variantSelect.value, current.act) }
+}
+
+/**
+ * Build the three selectors for the live (no pack) path.
+ *
+ * Without a pack index there is no scene catalog to offer: the live loader only knows
+ * the act's town, so `场景` shows that one level and `细分场景` lists the DS1 files the
+ * level actually contains — which is the same distinction the pack path draws between
+ * a scene and its variants.
+ *
+ * @param runtime - the freshly loaded runtime.
+ */
+function populateLiveSelectors(runtime: MapRuntime): void {
+  const actSelect = document.querySelector<HTMLSelectElement>('#act')
+  const sceneSelect = document.querySelector<HTMLSelectElement>('#scene')
+  const variantSelect = document.querySelector<HTMLSelectElement>('#variant')
+  if (actSelect === null || sceneSelect === null || variantSelect === null) return
+  actSelect.value = String(runtime.act)
+  actSelect.disabled = false
+  const option = document.createElement('option')
+  option.value = runtime.level
+  option.textContent = runtime.level
+  option.selected = true
+  sceneSelect.replaceChildren(option)
+  sceneSelect.disabled = false
+  variantSelect.replaceChildren(...runtime.quadrants.map(name => {
+    const item = document.createElement('option')
+    item.value = name
+    item.textContent = name
+    item.selected = name === runtime.quadrant
+    return item
+  }))
+  variantSelect.disabled = runtime.quadrants.length === 0
+  actSelect.onchange = () => {
+    const params = new URLSearchParams(location.search)
+    params.set('act', actSelect.value)
+    params.delete('level')
+    params.delete('quadrant')
+    location.search = params.toString()
+  }
+  sceneSelect.onchange = () => { /* one scene only in live mode */ }
+  variantSelect.onchange = () => {
+    const params = new URLSearchParams(location.search)
+    params.set('act', String(runtime.act))
+    params.set(runtime.quadrantParam, variantSelect.value)
+    params.delete(runtime.quadrantParam === 'level' ? 'quadrant' : 'level')
+    location.search = params.toString()
+  }
+}
+
+/**
+ * Boot the page: pack first, archives second.
+ */
+async function boot(): Promise<void> {
+  const canvas = document.querySelector<HTMLCanvasElement>('#view')!
+  const status = document.querySelector<HTMLElement>('#status')!
+  const actSelect = document.querySelector<HTMLSelectElement>('#act')!
+  const sceneSelect = document.querySelector<HTMLSelectElement>('#scene')!
+  const variantSelect = document.querySelector<HTMLSelectElement>('#variant')!
+  actSelect.disabled = false
+  sceneSelect.disabled = true
+  variantSelect.disabled = true
+  const started = performance.now()
+  const act = Math.min(ACT_COUNT, Math.max(1, Number(param('act', '1'))))
+  state.act = act
+  actSelect.value = String(act)
+  actSelect.addEventListener('change', () => {
+    const params = new URLSearchParams(location.search)
+    params.set('act', actSelect.value)
+    params.delete('level')
+    location.search = params.toString()
+  })
+  // The canvas fills the window, so its size decides how much world the first
+  // frame needs and therefore which atlas pages must load before it.
+  const viewport = syncCanvasSize(canvas)
+
+  try {
+    const forcedLive = param('live', '') === '1'
+    if (!forcedLive) {
+      const packParam = param('pack', '')
+      const packBases = packParam === '' ? DEFAULT_PACKS : [packParam]
+      for (const packBase of packBases) {
+        status.textContent = `正在读取资源包 ${packBase}/index.json …`
+        const baseParamForChar = param('base', '')
+        const charBases = baseParamForChar === '' ? DEFAULT_BASES : [baseParamForChar]
+        const runtime = await loadPackRuntime(packBase, act, param('level', ''), viewport, charBases)
+        if (runtime === null) continue
+        publish(runtime, packBase)
+        void populatePackSelectors(packBase, { act: runtime.act, label: runtime.quadrant })
+        const renderer = new SpriteRenderer(canvas)
+        // The first frame waits only for the spawn-area pages.
+        await runtime.loadPages(renderer, runtime.priorityPages, () => {
+          state.pagesLoaded = runtime.pages.filter(page => page !== null).length
+        })
+        runScene(runtime, renderer, started)
+        return
+      }
+    }
+
+    const baseParam = param('base', '')
+    const bases = baseParam === '' ? DEFAULT_BASES : [baseParam]
+    let lastError: unknown = null
+    for (const base of bases) {
+      try {
+        status.textContent = `正在读取归档 ${base}（HTTP range）并解码 …`
+        const renderer = new SpriteRenderer(canvas)
+        const runtime = await loadLiveRuntime(base, act, renderer, param('quadrant', ''))
+        publish(runtime, base)
+        runScene(runtime, renderer, started)
+        return
+      } catch (err) {
+        lastError = err
+        console.warn(`${base}: ${(err as Error).message}`)
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error('no data location worked')
+  } catch (err) {
+    state.error = (err as Error).message
+    status.textContent = `启动失败：${state.error}`
+    actSelect.disabled = false
+    sceneSelect.disabled = false
+    variantSelect.disabled = false
+  }
+}
+
+void boot()
diff --git a/src/scene/map-scene.ts b/src/scene/map-scene.ts
new file mode 100644
index 0000000..92a0472
--- /dev/null
+++ b/src/scene/map-scene.ts
@@ -0,0 +1,1217 @@
+/**
+ * Map scene: renders a decoded DS1 map with its DT1 tile library, with
+ * collision derived from the tiles' own 5×5 sub-tile flags.
+ *
+ * Two ways in, one scene:
+ *
+ * - **an archive** (drag & drop or `?mpq=`): the path a user actually takes.
+ *   Members are picked by extension, with a picker so a real archive — which
+ *   holds hundreds of levels and tile libraries — can be navigated.
+ * - **a fixture directory** (`?data=`): three files over HTTP, used by the
+ *   verification harness where no archive exists.
+ *
+ * Placeholder: the actor is a solid rectangle. A real character arrives as
+ * DCC/DC6 from the archive.
+ */
+import { MpqArchive } from '../mpq/archive.ts'
+import { blobSource } from '../mpq/source.ts'
+import { decodeDt1 } from '../formats/dt1.ts'
+import { decodeDs1 } from '../formats/ds1.ts'
+import { decodeDc6 } from '../formats/dc6.ts'
+import { decodeSpriteFile } from '../formats/cel.ts'
+import { PLAYER_SPRITE_WIDTH } from '../formats/sprite.ts'
+import type { SpriteSheet } from '../formats/sprite.ts'
+import { ActorAnimator } from '../game/animation.ts'
+import { createWorld, experienceTable, monsterStatsFromTable, rebindPlayer, spawnMonsters, tickCombat } from '../game/combat.ts'
+import type { CombatOptions, CombatWorld, Monster, MonsterStats } from '../game/combat.ts'
+import { parseTable } from '../game/tables.ts'
+import {
+  Inventory, affixesFromTable, goldItem, itemBasesFromTable, rollDrop, totalStat,
+} from '../game/items.ts'
+import type { Affix, Item, ItemBase } from '../game/items.ts'
+import { Rng } from '../game/rng.ts'
+import { castSkill, skillsFromTable, tickProjectiles } from '../game/skills.ts'
+import type { Projectile, SkillDef } from '../game/skills.ts'
+import { QuestLog, npcDialog, npcsFromTable, questsFromTable } from '../game/quests.ts'
+import type { NpcDef } from '../game/quests.ts'
+import { damageMonster } from '../game/combat.ts'
+import { decodeTbl } from '../formats/tbl.ts'
+import { captureSnapshot, parseSnapshot, restoreSnapshot, serializeSnapshot } from '../game/save.ts'
+import { textSourceOf } from '../game/tables.ts'
+import { decodePal } from '../formats/pal.ts'
+import { decodePl2 } from '../formats/pl2.ts'
+import { buildMapScene, blockedOverlap, depthInsertIndex, findFreeSpawn } from '../game/map.ts'
+import type { MapScene } from '../game/map.ts'
+import type { Palette } from '../formats/pal.ts'
+import { buildAtlas } from '../render/atlas.ts'
+import type { AtlasFrame } from '../render/atlas.ts'
+import { SpriteRenderer } from '../render/renderer.ts'
+import { GameLoop } from '../sim/loop.ts'
+import { KeyboardInput, directionOf } from '../sim/input.ts'
+
+/** Collision box at the character's feet. */
+const FEET_WIDTH = 20
+const FEET_HEIGHT = 14
+/** Walk speed in pixels per second. */
+const WALK_SPEED = 180
+/** Player marker size in pixels (placeholder art). */
+const MARKER_WIDTH = 18
+const MARKER_HEIGHT = 26
+/**
+ * Fallback combat tables, used when an archive ships none.
+ *
+ * Deliberately small and obviously generic: the point is that the sandbox runs
+ * and says where its numbers came from, not that these are balanced.
+ */
+const DEMO_MONSTERS: readonly MonsterStats[] = [
+  { id: 'demo-fallen', name: 'Fallen', hp: 12, damage: 3, cooldownTicks: 24, reach: 36, aggroRadius: 220, speed: 80, xp: 8 },
+  { id: 'demo-zombie', name: 'Zombie', hp: 30, damage: 6, cooldownTicks: 32, reach: 40, aggroRadius: 170, speed: 46, xp: 15 },
+  { id: 'demo-skeleton', name: 'Skeleton', hp: 18, damage: 4, cooldownTicks: 28, reach: 38, aggroRadius: 260, speed: 70, xp: 12 },
+]
+/** Fallback experience thresholds, index 1 = level 1. */
+const DEMO_EXPERIENCE: readonly number[] = [0, 0, 20, 60, 140, 280]
+/** Per-monster tints, so several monsters on one sheet read as several units. */
+const MONSTER_TINTS: readonly (readonly [number, number, number, number])[] = [
+  [1, 0.78, 0.72, 1], [0.78, 1, 0.8, 1], [0.82, 0.86, 1, 1], [1, 0.92, 0.7, 1],
+]
+/** Colour of the player's life and mana orbs. */
+const LIFE_COLOR: readonly [number, number, number, number] = [0.72, 0.15, 0.15, 1]
+const MANA_COLOR: readonly [number, number, number, number] = [0.2, 0.35, 0.8, 1]
+const ORB_BACKDROP: readonly [number, number, number, number] = [0.08, 0.07, 0.06, 1]
+
+/** Inventory size in cells, and the size of one cell on screen. */
+const INVENTORY_COLS = 10
+const INVENTORY_ROWS = 4
+const CELL_PX = 26
+/** How close the player must be to pick something up, in world pixels. */
+const PICKUP_RADIUS = 64
+/** Key a save is stored under in the browser. */
+const SAVE_KEY = 'd2web.save'
+/** Seed for the drop stream, so a session's loot is reproducible. */
+const LOOT_SEED = 0x5eed
+/** Fallback item bases and affixes, used when an archive ships no item tables. */
+const DEMO_BASES: readonly ItemBase[] = [
+  { id: 'demo-sword', name: 'Sword', kind: 'weapon', invWidth: 1, invHeight: 3, maxStack: 1, value: 40, damage: 6, defense: 0, tags: ['weap'], level: 1 },
+  { id: 'demo-cap', name: 'Cap', kind: 'armor', invWidth: 2, invHeight: 2, maxStack: 1, value: 30, damage: 0, defense: 5, tags: ['armo'], level: 1 },
+  { id: 'demo-potion', name: 'Potion', kind: 'misc', invWidth: 1, invHeight: 1, maxStack: 5, value: 20, damage: 0, defense: 0, tags: ['misc'], level: 1 },
+]
+const DEMO_AFFIXES: readonly Affix[] = [
+  { id: 'demo-cruel', name: 'Cruel', kind: 'prefix', level: 3, itemTypes: ['weap'], modifiers: [{ stat: 'maxdamage', min: 3, max: 8 }] },
+  { id: 'demo-might', name: 'of Might', kind: 'suffix', level: 2, itemTypes: [], modifiers: [{ stat: 'strength', min: 1, max: 4 }] },
+]
+
+/** How close the player must be to talk, in world pixels. */
+const TALK_RADIUS = 80
+/** Fallback skills, used when an archive ships no skill table. */
+const DEMO_SKILLS: readonly SkillDef[] = [
+  { id: 'attack', name: 'Attack', manaCost: 0, cooldownTicks: 10, range: 48, projectile: false, speed: 0, baseMinDamage: 4, baseMaxDamage: 6, damagePerLevel: 1, radius: 20 },
+  { id: 'firebolt', name: 'Fire Bolt', manaCost: 6, cooldownTicks: 20, range: 260, projectile: true, speed: 320, baseMinDamage: 7, baseMaxDamage: 10, damagePerLevel: 3, radius: 20 },
+]
+/** Fallback NPC, used when an archive ships no NPC table. */
+const DEMO_NPCS: readonly NpcDef[] = [{
+  id: 'elder', name: 'Elder', questId: 'demo',
+  offerLines: ['The moor is crawling with vermin.', 'Will you thin them out?'],
+  progressLines: ['Still at it?'], doneLines: ['The moor is quieter. Thank you.'],
+}]
+/** Fallback quest, used when an archive ships no quest table. */
+const DEMO_QUESTS = [{
+  id: 'demo', name: 'Clear the Moor', description: 'Slay three monsters',
+  monsterId: '*', killCount: 3, rewardXp: 40, rewardGold: 80,
+}] as const
+
+/** How many DT1 libraries to load at once (maps reference more than one). */
+const MAX_LIBRARIES = 4
+
+/** Scene state, published for automated checks. */
+export interface MapSceneState {
+  /** True once a map is loaded and the loop is running. */
+  ready: boolean
+  /** Reason the scene failed to start. */
+  error: string | null
+  /** Where the data came from: `mpq` or `fixture`. */
+  source: string
+  /** Archive label, when one was opened. */
+  archive: string | null
+  /** Names of the members the map was built from. */
+  members: string[]
+  /** Ticks simulated. */
+  tick: number
+  /** Measured ticks per second. */
+  tickRate: number
+  /** Map size in cells. */
+  cellsX: number
+  cellsY: number
+  /** Map size in pixels. */
+  widthPx: number
+  heightPx: number
+  /** Draw counts. */
+  floorDraws: number
+  wallDraws: number
+  /** Map references that resolved to no tile. */
+  missingTiles: number
+  /** Blocked sub-tiles. */
+  blockedSubTiles: number
+  /** Collision grid size in sub-tiles. */
+  gridWidth: number
+  gridHeight: number
+  /** Player position in world pixels. */
+  x: number
+  y: number
+  /** Whether the last tick's movement was refused. */
+  blocked: boolean
+  /** Tiles in the atlas. */
+  atlasTiles: number
+  /** Where the actor's art came from, or `marker` when none was found. */
+  actorSource: string
+  /** Actor clip currently playing. */
+  actorClip: string | null
+  /** Actor facing (0 = south, turning west). */
+  actorDirection: number
+  /** Actor animation frame index. */
+  actorFrame: number
+  /** How many wall draws precede the actor (its depth insertion point). */
+  actorDrawOrder: number
+  /** Where the combat tables came from: `archive` or `builtin`. */
+  tablesSource: string
+  /** Monsters spawned. */
+  monstersSpawned: number
+  /** Monsters still alive. */
+  monstersAlive: number
+  /** Monsters killed so far. */
+  kills: number
+  /** Player health. */
+  playerHp: number
+  /** Player maximum health. */
+  playerMaxHp: number
+  /** Player mana. */
+  playerMana: number
+  /** Player maximum mana. */
+  playerMaxMana: number
+  /** Player level. */
+  playerLevel: number
+  /** Player experience. */
+  playerXp: number
+  /** Ticks in which the player dealt damage, for automated checks. */
+  playerHits: number
+  /** Screen-space orb rectangles, for automated checks. */
+  orbs: { name: string; x: number; y: number; width: number; height: number; fraction: number }[]
+  /** Where the item tables came from: `archive` or `builtin`. */
+  itemTablesSource: string
+  /** Items lying on the ground. */
+  groundItems: number
+  /** Items carried. */
+  inventoryItems: number
+  /** Inventory cells occupied / total. */
+  cellsUsed: number
+  cellsTotal: number
+  /** Gold carried. */
+  gold: number
+  /** Total defence from carried armor. */
+  defense: number
+  /** Drops rolled, pickups taken, and refusals because the bag was full. */
+  dropsRolled: number
+  pickups: number
+  inventoryRefusals: number
+  /** Names of the most recent drops, newest last. */
+  lastDrops: string[]
+  /** Whether names came from a `.tbl` or were literals in the tables. */
+  textSource: string
+  /** Skill names, in table order. */
+  skills: string[]
+  /** Index of the selected skill, or -1 for the plain melee attack. */
+  selectedSkill: number
+  /** Skills cast. */
+  casts: number
+  /** Casts refused for mana or cooldown. */
+  castRefusals: number
+  /** Projectiles that hit a monster. */
+  castHits: number
+  /** Projectiles in flight. */
+  projectilesAlive: number
+  /** NPCs placed. */
+  npcs: number
+  /** Placed NPCs with their distance to the player, for automation. */
+  npcsNear: { x: number; y: number; distance: number }[]
+  /** Living monsters with their distance to the player, for automation. */
+  monstersNear: { x: number; y: number; distance: number }[]
+  /** Current dialogue lines, empty when nobody is talking. */
+  dialog: string[]
+  /** Quest statuses by id. */
+  quests: { id: string; status: string; kills: number; needed: number }[]
+  /** Experience and gold handed out by quests. */
+  questXp: number
+  questGold: number
+  /** Ticks the *simulation* has run (unlike `tick`, which is the render loop's). */
+  worldTick: number
+  /** Saves written and loads applied this session. */
+  saves: number
+  loads: number
+  /** Reason the last save or load failed, if any. */
+  saveError: string | null
+}
+
+declare global {
+  interface Window {
+    /** Map scene state for automation and debugging. */
+    __d2webMap?: MapSceneState
+  }
+}
+
+const state: MapSceneState = {
+  ready: false, error: null, source: 'none', archive: null, members: [],
+  tick: 0, tickRate: 0, cellsX: 0, cellsY: 0, widthPx: 0, heightPx: 0,
+  floorDraws: 0, wallDraws: 0, missingTiles: 0, blockedSubTiles: 0,
+  gridWidth: 0, gridHeight: 0, x: 0, y: 0, blocked: false, atlasTiles: 0,
+  actorSource: 'marker', actorClip: null, actorDirection: 0, actorFrame: 0, actorDrawOrder: 0,
+  tablesSource: 'builtin', monstersSpawned: 0, monstersAlive: 0, kills: 0,
+  playerHp: 0, playerMaxHp: 0, playerMana: 0, playerMaxMana: 0, playerLevel: 1, playerXp: 0, playerHits: 0,
+  orbs: [],
+  itemTablesSource: 'builtin', groundItems: 0, inventoryItems: 0,
+  cellsUsed: 0, cellsTotal: INVENTORY_COLS * INVENTORY_ROWS, gold: 0, defense: 0,
+  dropsRolled: 0, pickups: 0, inventoryRefusals: 0, lastDrops: [],
+  textSource: 'literal', skills: [], selectedSkill: 0, casts: 0, castRefusals: 0, castHits: 0,
+  projectilesAlive: 0, npcs: 0, npcsNear: [], monstersNear: [], dialog: [], quests: [], questXp: 0, questGold: 0,
+  saves: 0, loads: 0, saveError: null, worldTick: 0,
+}
+window.__d2webMap = state
+
+/** Raw bytes a map needs, however they were obtained. */
+interface MapSources {
+  readonly ds1: Uint8Array
+  readonly libraries: readonly Uint8Array[]
+  readonly palette: Uint8Array
+  /** Member name of the palette, so `.pl2` and `.pal` can be told apart. */
+  readonly paletteName: string
+  /** Actor art, when the source has any: direction-major sprite groups. */
+  readonly actor: { readonly name: string; readonly sheet: SpriteSheet } | null
+  /** Combat tables, when the archive has them at the usual member path. */
+  readonly tables: { readonly monstats: Uint8Array | null; readonly experience: Uint8Array | null }
+  /** Skill, NPC and quest tables plus the string table, when present. */
+  readonly m4Tables: {
+    readonly skills: Uint8Array | null
+    readonly npcs: Uint8Array | null
+    readonly quests: Uint8Array | null
+    readonly strings: Uint8Array | null
+  }
+  /** Item tables, at the same `data/global/excel` path. */
+  readonly itemTables: {
+    readonly weapons: Uint8Array | null
+    readonly armor: Uint8Array | null
+    readonly misc: Uint8Array | null
+    readonly prefixes: Uint8Array | null
+    readonly suffixes: Uint8Array | null
+  }
+}
+
+/**
+ * Decode whichever palette member the archive provides.
+ *
+ * Classic Diablo II ships `.pl2`: the base palette plus the transform tables that
+ * lighting, blending and unit colour shifts are drawn through. `.pal` (a bare
+ * 768-byte palette) appears in Diablo I archives and in tooling, so both are
+ * accepted and the base palette is what the renderer needs either way.
+ *
+ * @param name - the member name, for extension detection.
+ * @param bytes - the member's contents.
+ * @returns the palette.
+ */
+function decodePaletteMember(name: string, bytes: Uint8Array): Palette {
+  if (!name.toLowerCase().endsWith('.pl2')) return decodePal(bytes)
+  const pl2 = decodePl2(bytes)
+  // The renderer resolves indices against a plain palette; the transform tables
+  // stay available for lighting and unit colour shifts.
+  return { rgb: pl2.rgb, size: 256 }
+}
+
+/** The running loop and input, so a reload can retire the previous scene. */
+let running: GameLoop | null = null
+let input: KeyboardInput | null = null
+
+/** Fetch a URL as bytes. */
+async function fetchBytes(url: string): Promise<Uint8Array> {
+  const response = await fetch(url)
+  if (!response.ok) throw new Error(`${url}: HTTP ${String(response.status)}`)
+  return new Uint8Array(await response.arrayBuffer())
+}
+
+/** Lowercased extension of a member name. */
+function extensionOf(name: string): string {
+  const cut = name.lastIndexOf('.')
+  return cut === -1 ? '' : name.slice(cut + 1).toLowerCase()
+}
+
+/**
+ * Build the scene from decoded bytes and start the loop.
+ *
+ * @param sources - the raw members.
+ * @param status - element to report progress in.
+ * @param hud - element to show the running state in.
+ */
+function startScene(sources: MapSources, status: HTMLElement, hud: HTMLElement): void {
+  const canvas = document.querySelector<HTMLCanvasElement>('#view')!
+  const level = decodeDs1(sources.ds1)
+  const libraries = sources.libraries.map(library => decodeDt1(library))
+  const palette = decodePaletteMember(sources.paletteName, sources.palette)
+  // A map may reference several libraries; they are merged so tile lookups see
+  // one namespace, which is how the game composes them too.
+  const first = libraries[0]!
+  const merged = libraries.length === 1 ? first : {
+    versionMajor: first.versionMajor,
+    versionMinor: first.versionMinor,
+    tiles: libraries.flatMap(library => library.tiles),
+    // Libraries merged for a fixture map carry no structural warnings.
+    warnings: [],
+  }
+  const scene: MapScene = buildMapScene(level, merged)
+  const tileWidth = Math.max(...merged.tiles.map(tile => tile.width), 1)
+  const tileHeight = Math.max(...merged.tiles.map(tile => Math.abs(tile.height)), 1)
+
+  running?.stop()
+  input?.detach()
+  const renderer = new SpriteRenderer(canvas)
+  // The actor's frames ride in the *same* atlas as the tiles: one texture means
+  // the actor can be drawn at its depth among the walls without a second bind.
+  const combined: SpriteSheet = sources.actor === null
+    ? scene.sheet
+    : { groups: [...scene.sheet.groups, ...sources.actor.sheet.groups], width: null }
+  const atlas = buildAtlas(combined, palette)
+  renderer.setAtlas(atlas)
+  const frames = atlas.groups[0] ?? []
+  const actorGroups = sources.actor === null ? null : atlas.groups.slice(1)
+  const animator = new ActorAnimator<AtlasFrame>()
+  if (actorGroups !== null && actorGroups.length > 0) {
+    // Direction-major sheets: every direction plays its whole frame list while
+    // walking, and holds its first frame while standing — which is the shape
+    // Diablo II's own per-direction DC6 sheets have.
+    animator.add({ name: 'walk', directions: actorGroups, ticksPerFrame: 2, loop: true })
+    animator.add({ name: 'stand', directions: actorGroups.map(group => group.slice(0, 1)), ticksPerFrame: 8, loop: false })
+    animator.play('stand', 0)
+  }
+  state.actorSource = sources.actor?.name ?? 'marker'
+
+  const spawn = findFreeSpawn(scene, tileWidth, tileHeight, FEET_WIDTH, FEET_HEIGHT)
+  input = new KeyboardInput()
+  input.attach()
+
+  // Combat: the simulation owns movement (including the escape rule), and each
+  // monster's numbers are its own table row.
+  const stats = sources.tables.monstats === null
+    ? DEMO_MONSTERS
+    : monsterStatsFromTable(parseTable(new TextDecoder().decode(sources.tables.monstats)))
+  const xpTable: readonly number[] = sources.tables.experience === null
+    ? DEMO_EXPERIENCE
+    : experienceTable(parseTable(new TextDecoder().decode(sources.tables.experience)))
+  state.tablesSource = sources.tables.monstats === null ? 'builtin' : 'archive'
+  const terrain = {
+    overlap: (x: number, y: number): number =>
+      blockedOverlap(scene, tileWidth, tileHeight, x, y, FEET_WIDTH, FEET_HEIGHT),
+  }
+  const options: CombatOptions = {
+    playerSpeed: WALK_SPEED,
+    playerReach: 52,
+    playerCooldownTicks: 12,
+    playerDamage: 7,
+    playerManaPerAttack: 2,
+    respawnTicks: 75,
+  }
+  let world: CombatWorld = createWorld(spawn.x, spawn.y)
+  state.monstersSpawned = spawnMonsters(world, stats, 8, spawn, 260, terrain)
+  // Rebound after a load: the world object is replaced wholesale, so anything
+  // holding a piece of the old one would keep simulating the previous game.
+  let player = world.player
+
+  // Items: bases and affixes from the archive's tables, one seeded loot stream,
+  // and an inventory that is a real grid rather than a list.
+  const text = new TextDecoder()
+  const fromTable = (bytes: Uint8Array | null, kind: 'weapon' | 'armor' | 'misc'): ItemBase[] =>
+    bytes === null ? [] : itemBasesFromTable(parseTable(text.decode(bytes)), kind)
+  const tableBases = [
+    ...fromTable(sources.itemTables.weapons, 'weapon'),
+    ...fromTable(sources.itemTables.armor, 'armor'),
+    ...fromTable(sources.itemTables.misc, 'misc'),
+  ]
+  const itemBases = tableBases.length === 0 ? [...DEMO_BASES] : tableBases
+  const prefixAffixes = sources.itemTables.prefixes === null
+    ? DEMO_AFFIXES.filter(affix => affix.kind === 'prefix')
+    : affixesFromTable(parseTable(text.decode(sources.itemTables.prefixes)), 'prefix')
+  const suffixAffixes = sources.itemTables.suffixes === null
+    ? DEMO_AFFIXES.filter(affix => affix.kind === 'suffix')
+    : affixesFromTable(parseTable(text.decode(sources.itemTables.suffixes)), 'suffix')
+  state.itemTablesSource = tableBases.length === 0 ? 'builtin' : 'archive'
+  // Mutable on purpose: loading a game replaces the world, the random stream and
+  // the bag wholesale, and the loop reads them fresh every tick.
+  let loot = new Rng(LOOT_SEED)
+  let bag = new Inventory(INVENTORY_COLS, INVENTORY_ROWS)
+  let ground: { x: number; y: number; item: Item }[] = []
+
+  // Skills, names, NPCs and quests. Numeric cells in the tables resolve through
+  // the string table when the archive has one, and stay literal when it does not.
+  const textSource = textSourceOf(sources.m4Tables.strings === null ? null : decodeTbl(sources.m4Tables.strings))
+  state.textSource = sources.m4Tables.strings === null ? 'literal' : 'tbl'
+  const skills: readonly SkillDef[] = sources.m4Tables.skills === null
+    ? DEMO_SKILLS
+    : skillsFromTable(parseTable(text.decode(sources.m4Tables.skills)), textSource)
+  const npcDefs: readonly NpcDef[] = sources.m4Tables.npcs === null
+    ? DEMO_NPCS
+    : npcsFromTable(parseTable(text.decode(sources.m4Tables.npcs)), textSource)
+  const questDefs = sources.m4Tables.quests === null
+    ? [...DEMO_QUESTS]
+    : questsFromTable(parseTable(text.decode(sources.m4Tables.quests)), textSource)
+  let questLog = new QuestLog(questDefs)
+  let projectiles: Projectile[] = []
+  const castRng = new Rng(LOOT_SEED ^ 0x51c1)
+  const skillLevel = 1
+  let skillCooldown = 0
+  let selectedSkill = 0
+  // NPCs stand on free ground near the spawn, the same rule monsters obey.
+  const npcEntities: { def: NpcDef; x: number; y: number }[] = []
+  for (let attempt = 0; attempt < 40 && npcEntities.length < npcDefs.length; attempt += 1) {
+    const angle = attempt * 1.7 + 0.6
+    // Placed inside the talk radius on purpose: an NPC you cannot reach to talk
+    // to is a placement bug, not a challenge.
+    const x = spawn.x + Math.cos(angle) * 56
+    const y = spawn.y + Math.sin(angle) * 56
+    if (terrain.overlap(x, y) > 0) continue
+    const def = npcDefs[npcEntities.length]
+    if (def === undefined) break
+    npcEntities.push({ def, x, y })
+  }
+  state.npcs = npcEntities.length
+  state.skills = skills.map(skill => skill.name)
+
+  let blockedThisTick = false
+  const loop = new GameLoop({
+    tickRate: 25,
+    onTick: () => {
+      const movement = input?.movement() ?? { x: 0, y: 0 }
+      const beforeX = player.x
+      const beforeY = player.y
+      // Mana recovers slowly. The real game regenerates through stats and items;
+      // this stands in until the stat system exists, so the sandbox stays
+      // playable instead of dead-ending after a few casts.
+      if (loop.tick % 25 === 0) player.mana = Math.min(player.maxMana, player.mana + 1)
+
+      const wanted = skills[selectedSkill]
+      const casting = (input?.attacking ?? false) && selectedSkill > 0 && wanted !== undefined
+      // A spell that cannot be paid for must not take the basic attack away with
+      // it: with a skill selected and no mana, the swing still happens (see the
+      // combat call below, which is gated on this flag).
+      let castHappened = false
+      if (casting && wanted !== undefined) {
+        const result = castSkill(
+          wanted, { x: player.x, y: player.y, facing: player.facing },
+          skillLevel, castRng, skillCooldown, player.mana,
+        )
+        if (result.kind === 'projectile') {
+          projectiles.push(result.projectile)
+          player.mana = Math.max(0, player.mana - wanted.manaCost)
+          skillCooldown = wanted.cooldownTicks
+          state.casts += 1
+          castHappened = true
+        } else if (result.kind === 'instant') {
+          player.mana = Math.max(0, player.mana - wanted.manaCost)
+          skillCooldown = wanted.cooldownTicks
+          state.casts += 1
+          castHappened = true
+          // An instant skill strikes everything within its radius, which is what
+          // makes a nova different from a bolt.
+          world.monsters.forEach((monster, index) => {
+            if (monster.state === 'dead') return
+            if (Math.hypot(monster.x - player.x, monster.y - player.y) > wanted.radius + 20) return
+            damageMonster(world, index, result.damage)
+          })
+        } else if (result.kind === 'mana') {
+          // Only a mana refusal is worth counting: holding the key while the
+          // skill is on cooldown is the expected case, not an error, and
+          // counting it would drown the signal in per-tick noise.
+          state.castRefusals += 1
+        }
+      }
+
+      // The basic attack runs only when no spell fired this tick, so a selected
+      // skill replaces the swing instead of doubling it.
+      tickCombat(world, { movement, attack: castHappened ? false : (input?.attacking ?? false) }, options, terrain, xpTable)
+      const moved = player.x !== beforeX || player.y !== beforeY
+      // Animation follows the simulation, not the key state: a body stopped by a
+      // wall must not keep walking on the spot.
+      animator.play(moved ? 'walk' : 'stand', player.facing)
+      animator.tick(player.facing)
+      state.actorClip = animator.clipName
+      state.actorDirection = animator.facing
+      state.actorFrame = animator.frameIndex
+      if (world.events.some(event => event.kind === 'monsterHit')) state.playerHits += 1
+
+      // Skills. The number keys select a slot; the attack key casts it. Slot 0 is
+      // the plain melee attack, which the combat module already owns, so a
+      // selection of 0 falls through to it rather than double-attacking.
+      const digits = input?.digits ?? []
+      if (digits.length > 0) selectedSkill = Math.min(Math.max(digits[0]! - 1, 0), skills.length - 1)
+      state.selectedSkill = selectedSkill
+      if (skillCooldown > 0) skillCooldown -= 1
+      // Projectiles fly, hit, or die against scenery. Damage goes through the
+      // combat module so kills, experience and corpses behave the same as melee.
+      if (projectiles.length > 0) {
+        const targets = world.monsters.map((monster, index) => ({
+          index, x: monster.x, y: monster.y, radius: 20, alive: monster.state !== 'dead',
+        }))
+        const outcome = tickProjectiles(projectiles, targets, terrain)
+        projectiles.length = 0
+        projectiles.push(...outcome.alive)
+        for (const hit of outcome.hits) {
+          damageMonster(world, hit.targetIndex, hit.damage)
+          state.castHits += 1
+        }
+      }
+      state.projectilesAlive = projectiles.length
+
+      // Talking: nearest NPC in reach. Accepting is idempotent, so holding the key
+      // repeats the dialogue rather than toggling quest state.
+      if (input?.talking ?? false) {
+        let nearest: { def: NpcDef; x: number; y: number } | null = null
+        let best = TALK_RADIUS
+        for (const npc of npcEntities) {
+          const distance = Math.hypot(npc.x - player.x, npc.y - player.y)
+          if (distance <= best) { best = distance; nearest = npc }
+        }
+        if (nearest === null) {
+          state.dialog = []
+        } else {
+          if (nearest.def.questId !== null) questLog.accept(nearest.def.questId)
+          state.dialog = npcDialog(nearest.def, questLog)
+        }
+      }
+
+      // Loot: a kill rolls one drop; gold is taken automatically, everything
+      // else lies where it fell until picked up.
+      for (const event of world.events) {
+        if (event.kind !== 'kill') continue
+        // Quests count kills by monster id, which is why the event carries one.
+        for (const reward of questLog.recordKill(event.subjectId ?? '')) {
+          player.xp += reward.xp
+          bag.add(goldItem(reward.gold))
+          state.questXp += reward.xp
+          state.questGold += reward.gold
+        }
+        const drop = rollDrop(itemBases, prefixAffixes, suffixAffixes, loot, {
+          level: player.level + 2,
+          dropChance: 0.8,
+          goldChance: 0.3,
+          goldRange: [5, 40],
+        })
+        state.dropsRolled += 1
+        if (drop.kind === 'gold') {
+          bag.add(goldItem(drop.amount))
+        } else if (drop.kind === 'item') {
+          ground.push({ x: event.x, y: event.y, item: drop.item })
+          state.lastDrops.push(drop.item.name)
+          if (state.lastDrops.length > 6) state.lastDrops.shift()
+        }
+      }
+
+      // Pickup: nearest item within reach. A full bag refuses instead of
+      // destroying the item, which is the failure worth counting.
+      if ((input?.pickingUp ?? false) && ground.length > 0) {
+        let bestIndex = -1
+        let bestDistance = PICKUP_RADIUS
+        ground.forEach((entry, index) => {
+          const distance = Math.hypot(entry.x - player.x, entry.y - player.y)
+          if (distance <= bestDistance) { bestDistance = distance; bestIndex = index }
+        })
+        const entry = bestIndex === -1 ? undefined : ground[bestIndex]
+        if (entry !== undefined) {
+          if (bag.add(entry.item) === null) {
+            state.inventoryRefusals += 1
+          } else {
+            ground.splice(bestIndex, 1)
+            state.pickups += 1
+          }
+        }
+      }
+      // Save and load. Holding the key repeats, which is harmless: a save is
+      // idempotent and a load of the same file yields the same state.
+      if (input?.saving ?? false) {
+        try {
+          localStorage.setItem(SAVE_KEY, serializeSnapshot(captureSnapshot({
+            world, rng: loot, inventory: bag, quests: questLog, ground,
+          })))
+          state.saves += 1
+          state.saveError = null
+        } catch (error) {
+          state.saveError = error instanceof Error ? error.message : String(error)
+        }
+      }
+      if (input?.loading ?? false) {
+        try {
+          const text = localStorage.getItem(SAVE_KEY)
+          if (text === null) throw new Error('no save in this browser')
+          const loaded = parseSnapshot(text)
+          const pieces = restoreSnapshot(loaded, {
+            inventory: (width, height, placed) => Inventory.restore(width, height, placed),
+            quests: states => QuestLog.restore(questDefs, states),
+          })
+          world = rebindPlayer({
+            ...world,
+            tick: pieces.world.tick,
+            kills: pieces.world.kills,
+            player: { ...pieces.world.player },
+            monsters: pieces.world.monsters.map(monster => ({ ...monster })),
+            players: [],
+            events: [],
+          })
+          // Rebind everything derived from the world: a stale reference here means
+          // the tick that loaded the game finishes by writing to the old one.
+          player = world.player
+          loot = new Rng(pieces.rngState)
+          bag = pieces.inventory
+          questLog = pieces.quests
+          ground = pieces.ground
+          projectiles = []
+          state.loads += 1
+          state.saveError = null
+        } catch (error) {
+          state.saveError = error instanceof Error ? error.message : String(error)
+        }
+      }
+      state.groundItems = ground.length
+      state.inventoryItems = bag.contents.length
+      state.cellsUsed = bag.usedCells
+      state.gold = bag.gold
+      state.defense = totalStat(bag.contents, 'defense')
+      state.monstersNear = world.monsters
+        .filter(monster => monster.state !== 'dead')
+        .map(monster => ({ x: monster.x, y: monster.y, distance: Math.hypot(monster.x - player.x, monster.y - player.y) }))
+        .sort((a, b) => a.distance - b.distance)
+        .slice(0, 4)
+      state.npcsNear = npcEntities.map(npc => ({
+        x: npc.x, y: npc.y, distance: Math.hypot(npc.x - player.x, npc.y - player.y),
+      }))
+      state.quests = questLog.all.map(entry => ({
+        id: entry.def.id, status: entry.status, kills: entry.kills, needed: entry.def.killCount,
+      }))
+      state.tick = loop.tick
+      state.worldTick = world.tick
+      state.x = player.x
+      state.y = player.y
+      state.blocked = (movement.x !== 0 || movement.y !== 0) && !moved
+      state.monstersAlive = world.monsters.filter(monster => monster.state !== 'dead').length
+      state.kills = world.kills
+      state.playerHp = player.hp
+      state.playerMaxHp = player.maxHp
+      state.playerMana = player.mana
+      state.playerMaxMana = player.maxMana
+      state.playerLevel = player.level
+      state.playerXp = player.xp
+    },
+    onRender: () => {
+      const camera = { x: player.x, y: player.y, zoom: 2 }
+      renderer.begin(camera, [0.04, 0.03, 0.03])
+      for (const draw of scene.floors) {
+        const frame = frames[draw.tileIndex]
+        if (frame !== undefined) renderer.draw(frame, draw.x, draw.y)
+      }
+
+      // Actors and walls share one painter's order: walls far to near, with each
+      // actor spliced in where its depth says it belongs.
+      const cellOf = (value: number, size: number): number => Math.floor(value / size)
+      interface ActorDraw {
+        readonly x: number
+        readonly y: number
+        readonly cellX: number
+        readonly cellY: number
+        readonly frame: AtlasFrame | null
+        readonly tint: readonly [number, number, number, number]
+        readonly bar: { readonly hp: number; readonly maxHp: number } | null
+        /** A ground item, drawn as a small tile until its art exists. */
+        readonly ground?: Item
+      }
+      const actors: ActorDraw[] = []
+      const playerFrame = animator.frame()
+      if (playerFrame !== undefined) {
+        actors.push({
+          x: player.x, y: player.y,
+          cellX: cellOf(player.x, tileWidth), cellY: cellOf(player.y, tileHeight),
+          frame: playerFrame,
+          tint: player.alive ? [1, 1, 1, 1] : [0.55, 0.5, 0.5, 1],
+          bar: null,
+        })
+      }
+      for (const monster of world.monsters) {
+        const group = actorGroups?.[monster.facing]
+        if (group === undefined || group.length === 0) continue
+        const moving = monster.state === 'chase' || monster.state === 'attack'
+        const frame = group[moving ? (world.tick + monster.index * 3) % group.length : 0]
+        if (frame === undefined) continue
+        actors.push({
+          x: monster.x, y: monster.y,
+          cellX: cellOf(monster.x, tileWidth), cellY: cellOf(monster.y, tileHeight),
+          frame,
+          tint: monster.state === 'dead'
+            ? [0.42, 0.36, 0.34, 1]
+            : monster.hitFlash > 0 ? [1, 0.55, 0.55, 1] : MONSTER_TINTS[monster.index % MONSTER_TINTS.length]!,
+          bar: monster.state === 'dead' ? null : { hp: monster.hp, maxHp: monster.stats.hp },
+        })
+      }
+      // NPCs and projectiles share the same painter's order as everything else.
+      for (const npc of npcEntities) {
+        const group = actorGroups?.[2]
+        const frame = group?.[0] ?? null
+        actors.push({
+          x: npc.x, y: npc.y,
+          cellX: cellOf(npc.x, tileWidth), cellY: cellOf(npc.y, tileHeight),
+          frame,
+          tint: [1, 0.85, 0.55, 1],
+          bar: null,
+        })
+      }
+      for (const shot of projectiles) {
+        actors.push({
+          x: shot.x, y: shot.y,
+          cellX: cellOf(shot.x, tileWidth), cellY: cellOf(shot.y, tileHeight),
+          frame: null,
+          tint: [1, 0.75, 0.25, 1],
+          bar: null,
+        })
+      }
+      // Ground items take their place in the same depth order as everything else.
+      for (const entry of ground) {
+        actors.push({
+          x: entry.x, y: entry.y,
+          cellX: cellOf(entry.x, tileWidth), cellY: cellOf(entry.y, tileHeight),
+          frame: null,
+          tint: entry.item.base.kind === 'weapon'
+            ? [0.85, 0.87, 0.92, 1]
+            : entry.item.base.kind === 'armor' ? [0.8, 0.66, 0.45, 1] : [0.6, 0.85, 0.55, 1],
+          bar: null,
+          ground: entry.item,
+        })
+      }
+      actors.sort((a, b) => (a.cellY + a.cellX) - (b.cellY + b.cellX) || a.y - b.y)
+
+      let wallIndex = 0
+      const drawNextWall = (): void => {
+        const draw = scene.walls[wallIndex]
+        wallIndex += 1
+        if (draw === undefined) return
+        const frame = frames[draw.tileIndex]
+        if (frame !== undefined) renderer.draw(frame, draw.x, draw.y)
+      }
+      state.actorDrawOrder = 0
+      for (const actor of actors) {
+        const insertAt = depthInsertIndex(scene.walls, actor.cellX, actor.cellY)
+        while (wallIndex < insertAt) drawNextWall()
+        if (actor.frame === null) {
+          const size = actor.ground === undefined ? 6 : 10 + Math.min(actor.ground.stack, 5) * 2
+          renderer.drawSolid(actor.x - size / 2, actor.y - size, size, size, actor.tint)
+        } else {
+          renderer.draw(actor.frame, actor.x - actor.frame.width / 2, actor.y - actor.frame.height, { tint: actor.tint })
+        }
+        if (actor.bar !== null && actor.frame !== null) {
+          // A health bar over the sprite; the fill is the fraction of the
+          // monster's own table maximum.
+          const width = actor.frame.width
+          const top = actor.y - actor.frame.height - 10
+          const fraction = Math.max(0, Math.min(1, actor.bar.hp / Math.max(actor.bar.maxHp, 1)))
+          renderer.drawSolid(actor.x - width / 2, top, width, 5, [0.1, 0.08, 0.08, 1])
+          renderer.drawSolid(actor.x - width / 2, top, width * fraction, 5, [0.75, 0.2, 0.18, 1])
+        }
+      }
+      while (wallIndex < scene.walls.length) drawNextWall()
+
+      // Life and mana orbs, anchored to the screen rather than the world.
+      const toWorld = (sx: number, sy: number): { x: number; y: number } => ({
+        x: camera.x + (sx - canvas.width / 2) / camera.zoom,
+        y: camera.y + (sy - canvas.height / 2) / camera.zoom,
+      })
+      const orb = (screenX: number, screenY: number, width: number, height: number, fraction: number, color: readonly [number, number, number, number]): void => {
+        const at = toWorld(screenX, screenY)
+        const size = { w: width / camera.zoom, h: height / camera.zoom }
+        renderer.drawSolid(at.x, at.y, size.w, size.h, ORB_BACKDROP)
+        const filled = size.h * Math.max(0, Math.min(1, fraction))
+        renderer.drawSolid(at.x + 1 / camera.zoom, at.y + size.h - filled, size.w - 2 / camera.zoom, filled, color)
+      }
+      state.orbs = [
+        { name: 'life', x: 24, y: canvas.height - 84, width: 44, height: 60, fraction: player.maxHp === 0 ? 0 : player.hp / player.maxHp },
+        { name: 'mana', x: canvas.width - 68, y: canvas.height - 84, width: 44, height: 60, fraction: player.maxMana === 0 ? 0 : player.mana / player.maxMana },
+      ]
+      for (const entry of state.orbs) {
+        orb(entry.x, entry.y, entry.width, entry.height, entry.fraction,
+          entry.name === 'life' ? LIFE_COLOR : MANA_COLOR)
+      }
+      // Inventory overlay, anchored to the screen: a real grid, because items
+      // occupy cells and a list would hide the constraint that matters.
+      const bagAt = toWorld(canvas.width - INVENTORY_COLS * CELL_PX - 20, 20)
+      const cellWorld = CELL_PX / camera.zoom
+      renderer.drawSolid(
+        bagAt.x - 4 / camera.zoom, bagAt.y - 4 / camera.zoom,
+        INVENTORY_COLS * cellWorld + 8 / camera.zoom, INVENTORY_ROWS * cellWorld + 8 / camera.zoom,
+        [0.06, 0.05, 0.05, 1],
+      )
+      for (let row = 0; row < INVENTORY_ROWS; row += 1) {
+        for (let column = 0; column < INVENTORY_COLS; column += 1) {
+          renderer.drawSolid(
+            bagAt.x + column * cellWorld + 0.5 / camera.zoom,
+            bagAt.y + row * cellWorld + 0.5 / camera.zoom,
+            cellWorld - 1 / camera.zoom, cellWorld - 1 / camera.zoom,
+            [0.16, 0.14, 0.12, 1],
+          )
+        }
+      }
+      for (const placed of bag.contents) {
+        renderer.drawSolid(
+          bagAt.x + placed.x * cellWorld + 1 / camera.zoom,
+          bagAt.y + placed.y * cellWorld + 1 / camera.zoom,
+          placed.item.invWidth * cellWorld - 2 / camera.zoom,
+          placed.item.invHeight * cellWorld - 2 / camera.zoom,
+          placed.item.base.kind === 'weapon'
+            ? [0.7, 0.74, 0.82, 1]
+            : placed.item.base.kind === 'armor' ? [0.7, 0.56, 0.36, 1] : [0.5, 0.72, 0.48, 1],
+        )
+      }
+      renderer.flush()
+      const dialogPanel = document.querySelector<HTMLElement>('#dialog')
+      if (dialogPanel !== null) {
+        dialogPanel.hidden = state.dialog.length === 0
+        dialogPanel.textContent = state.dialog.join('\n')
+      }
+      state.tickRate = loop.tickRate
+      hud.textContent = `tick ${String(state.tick)} · ${loop.tickRate.toFixed(1)} tps`
+        + ` · ${state.source} · tables ${state.tablesSource}`
+        + ` · hp ${String(Math.max(0, Math.round(player.hp)))}/${String(player.maxHp)}`
+        + ` · mana ${String(Math.round(player.mana))}/${String(player.maxMana)}`
+        + ` · lvl ${String(player.level)} (${String(player.xp)} xp)`
+        + ` · monsters ${String(state.monstersAlive)}/${String(state.monstersSpawned)} alive · kills ${String(world.kills)}`
+        + ` · items ${state.itemTablesSource} · bag ${String(state.cellsUsed)}/${String(state.cellsTotal)}`
+        + ` · gold ${String(state.gold)} · ground ${String(state.groundItems)} · pickups ${String(state.pickups)}`
+        + (state.inventoryRefusals > 0 ? ` · bag full x${String(state.inventoryRefusals)}` : '')
+        + ` · skill ${String(selectedSkill)}/${String(skills.length - 1)} ${skills[selectedSkill]?.name ?? '-'}`
+        + ` · casts ${String(state.casts)} (hits ${String(state.castHits)}, refused ${String(state.castRefusals)})`
+        + ` · quests ${state.quests.map(entry => `${entry.id}:${entry.status}(${String(entry.kills)}/${String(entry.needed)})`).join(' ') || '-'}`
+        + ` · saves ${String(state.saves)}/loads ${String(state.loads)}`
+        + (state.saveError === null ? '' : ` · save error: ${state.saveError}`)
+        + (state.dialog.length > 0 ? ' · 对话中' : '')
+        + (player.alive ? '' : ' · 死亡中，稍后重生')
+    },
+  })
+
+  state.cellsX = level.width
+  state.cellsY = level.height
+  state.widthPx = scene.widthPx
+  state.heightPx = scene.heightPx
+  state.floorDraws = scene.floors.length
+  state.wallDraws = scene.walls.length
+  state.missingTiles = scene.missingTiles
+  state.gridWidth = scene.gridWidth
+  state.gridHeight = scene.gridHeight
+  state.atlasTiles = frames.length
+  let blocked = 0
+  for (const value of scene.blocked) if (value === 1) blocked += 1
+  state.blockedSubTiles = blocked
+  state.error = null
+  loop.start()
+  running = loop
+  state.ready = true
+  status.textContent = `地图已加载（${state.source}）：${String(level.width)}×${String(level.height)} 格，`
+    + `地面 ${String(scene.floors.length)} / 墙体 ${String(scene.walls.length)} 次绘制，`
+    + `碰撞网格 ${String(scene.gridWidth)}×${String(scene.gridHeight)}，`
+    + `瓦片库 ${String(libraries.length)} 个，未解析引用 ${String(scene.missingTiles)}。`
+    + `WASD 移动（黄色方块=角色占位）。`
+}
+
+/**
+ * Find and decode actor art in an archive.
+ *
+ * Both games animate units from direction-major sheets, so one loader covers
+ * them: Diablo II's per-direction DC6 (which carries each frame's own size) is
+ * preferred, and Diablo I's CL2 is accepted as a fallback for archives that only
+ * have it. Names are ranked rather than required — `actor`, then anything that
+ * looks like a unit, then the first sheet in the archive — because real data
+ * names art by convention, not by contract.
+ *
+ * @param archive - the open archive.
+ * @returns the actor's name and sheet, or null when the archive has no unit art.
+ */
+async function loadActorArt(archive: MpqArchive): Promise<{ name: string; sheet: SpriteSheet } | null> {
+  const names = await archive.listFiles()
+  const rank = (name: string): number => {
+    const lower = name.toLowerCase()
+    if (lower.includes('actor')) return 0
+    if (lower.includes('monster') || lower.includes('player') || lower.includes('char')) return 1
+    return 2
+  }
+  const dc6Names = names.filter(name => name.toLowerCase().endsWith('.dc6')).sort((a, b) => rank(a) - rank(b) || a.localeCompare(b))
+  const chosen = dc6Names[0]
+  if (chosen !== undefined) {
+    return { name: chosen, sheet: decodeDc6(await archive.readByName(chosen)) }
+  }
+  const cl2Name = names.find(name => /plrgfx.*\.cl2$/i.test(name))
+  if (cl2Name !== undefined) {
+    // Diablo I sheets do not store their width; the game's own table does.
+    const sheet = decodeSpriteFile(await archive.readByName(cl2Name), 'cl2', { width: PLAYER_SPRITE_WIDTH.walk })
+    return { name: cl2Name, sheet }
+  }
+  return null
+}
+
+/**
+ * Read the combat tables an archive provides, if any.
+ *
+ * Diablo II keeps them at `data\\global\\excel\\<name>.txt`; a missing table is not
+ * an error — the sandbox falls back to a built-in demo table and says so, which
+ * keeps the scene runnable against archives that have no tables at all.
+ *
+ * @param archive - the open archive.
+ * @returns the table bytes, or null per table.
+ */
+async function loadTables(archive: MpqArchive): Promise<{
+  monstats: Uint8Array | null
+  experience: Uint8Array | null
+}> {
+  const names = await archive.listFiles()
+  const find = (suffix: string): string | undefined =>
+    names.find(name => name.toLowerCase().endsWith(suffix))
+  const read = async (suffix: string): Promise<Uint8Array | null> => {
+    const name = find(suffix)
+    return name === undefined ? null : archive.readByName(name)
+  }
+  return {
+    monstats: await read('monstats.txt'),
+    experience: await read('experience.txt'),
+  }
+}
+
+/**
+ * Read the item tables an archive provides.
+ *
+ * Same member path and same "missing is fine" rule as the combat tables.
+ *
+ * @param archive - the open archive.
+ * @returns the table bytes, null per table that is absent.
+ */
+async function loadItemTables(archive: MpqArchive): Promise<{
+  weapons: Uint8Array | null
+  armor: Uint8Array | null
+  misc: Uint8Array | null
+  prefixes: Uint8Array | null
+  suffixes: Uint8Array | null
+}> {
+  const names = await archive.listFiles()
+  const read = async (suffix: string): Promise<Uint8Array | null> => {
+    const name = names.find(candidate => candidate.toLowerCase().endsWith(suffix))
+    return name === undefined ? null : archive.readByName(name)
+  }
+  return {
+    weapons: await read('weapons.txt'),
+    armor: await read('armor.txt'),
+    misc: await read('misc.txt'),
+    prefixes: await read('magicprefix.txt'),
+    suffixes: await read('magicsuffix.txt'),
+  }
+}
+
+/**
+ * Read the skill, NPC and quest tables and the string table.
+ *
+ * @param archive - the open archive.
+ * @returns the bytes, null per member that is absent.
+ */
+async function loadM4Tables(archive: MpqArchive): Promise<{
+  skills: Uint8Array | null
+  npcs: Uint8Array | null
+  quests: Uint8Array | null
+  strings: Uint8Array | null
+}> {
+  const names = await archive.listFiles()
+  const read = async (suffix: string): Promise<Uint8Array | null> => {
+    const name = names.find(candidate => candidate.toLowerCase().endsWith(suffix))
+    return name === undefined ? null : archive.readByName(name)
+  }
+  return {
+    skills: await read('skills.txt'),
+    npcs: await read('npcs.txt'),
+    quests: await read('quests.txt'),
+    strings: await read('string.tbl'),
+  }
+}
+
+/**
+ * Read a map's members out of an open archive.
+ *
+ * A real archive holds many levels and tile libraries, so members are chosen by
+ * extension and, when there is a choice, by name: town/act names first, then the
+ * first member found. The picker in the page overrides either choice.
+ *
+ * @param archive - the open archive.
+ * @param choices - explicit member names, when the picker supplied them.
+ * @returns the raw bytes.
+ */
+async function loadFromArchive(
+  archive: MpqArchive,
+  choices: { ds1?: string | undefined; dt1?: string | undefined; palette?: string | undefined } = {},
+): Promise<MapSources> {
+  const names = await archive.listFiles()
+  const rank = (name: string, preferred: readonly string[]): number => {
+    const lower = name.toLowerCase()
+    const index = preferred.findIndex(token => lower.includes(token))
+    return index === -1 ? preferred.length : index
+  }
+  const candidates = (extension: string, preferred: readonly string[]): string[] =>
+    names.filter(name => extensionOf(name) === extension)
+      .sort((a, b) => rank(a, preferred) - rank(b, preferred) || a.localeCompare(b))
+
+  const ds1Name = choices.ds1 ?? candidates('ds1', ['town', 'act1', 'rogue'])[0]
+  if (ds1Name === undefined) throw new Error('archive has no .ds1 member to load')
+  const dt1Names = choices.dt1 !== undefined
+    ? [choices.dt1]
+    : candidates('dt1', ['town', 'act1']).slice(0, MAX_LIBRARIES)
+  if (dt1Names.length === 0) throw new Error('archive has no .dt1 member to load')
+  // Real Diablo II archives carry `.pl2`; `.pal` is accepted for Diablo I
+  // archives and tooling.
+  const paletteName = choices.palette
+    ?? [...candidates('pl2', ['act1', 'pal']), ...candidates('pal', ['town', 'act1'])][0]
+  if (paletteName === undefined) throw new Error('archive has no .pl2 or .pal member to load')
+
+  state.members = [ds1Name, ...dt1Names, paletteName]
+  return {
+    ds1: await archive.readByName(ds1Name),
+    libraries: await Promise.all(dt1Names.map(async name => archive.readByName(name))),
+    palette: await archive.readByName(paletteName),
+    paletteName,
+    actor: await loadActorArt(archive),
+    tables: await loadTables(archive),
+    itemTables: await loadItemTables(archive),
+    m4Tables: await loadM4Tables(archive),
+  }
+}
+
+/**
+ * Read a map's members from a fixture directory over HTTP.
+ *
+ * @param dir - the directory.
+ * @returns the raw bytes.
+ */
+async function loadFromFixtureDir(dir: string): Promise<MapSources> {
+  const [ds1, dt1, palette, actor] = await Promise.all([
+    fetchBytes(`${dir}/fixture.ds1`),
+    fetchBytes(`${dir}/fixture.dt1`),
+    fetchBytes(`${dir}/palette.pal`),
+    fetchBytes(`${dir}/actor.dc6`).catch(() => null),
+  ])
+  state.members = [`${dir}/fixture.ds1`, `${dir}/fixture.dt1`, `${dir}/palette.pal`]
+  return {
+    ds1, libraries: [dt1], palette, paletteName: 'palette.pal',
+    actor: actor === null ? null : { name: `${dir}/actor.dc6`, sheet: decodeDc6(actor) },
+    tables: {
+      monstats: await fetchBytes(`${dir}/data/global/excel/monstats.txt`).catch(() => null),
+      experience: await fetchBytes(`${dir}/data/global/excel/experience.txt`).catch(() => null),
+    },
+    m4Tables: {
+      skills: await fetchBytes(`${dir}/data/global/excel/skills.txt`).catch(() => null),
+      npcs: await fetchBytes(`${dir}/data/global/excel/npcs.txt`).catch(() => null),
+      quests: await fetchBytes(`${dir}/data/global/excel/quests.txt`).catch(() => null),
+      strings: await fetchBytes(`${dir}/data/local/string.tbl`).catch(() => null),
+    },
+    itemTables: {
+      weapons: await fetchBytes(`${dir}/data/global/excel/weapons.txt`).catch(() => null),
+      armor: await fetchBytes(`${dir}/data/global/excel/armor.txt`).catch(() => null),
+      misc: await fetchBytes(`${dir}/data/global/excel/misc.txt`).catch(() => null),
+      prefixes: await fetchBytes(`${dir}/data/global/excel/magicprefix.txt`).catch(() => null),
+      suffixes: await fetchBytes(`${dir}/data/global/excel/magicsuffix.txt`).catch(() => null),
+    },
+  }
+}
+
+/** Wire the page: archive drop zone, member picker, and the two URL modes. */
+function boot(): void {
+  const status = document.querySelector<HTMLElement>('#status')!
+  const hud = document.querySelector<HTMLElement>('#hud')!
+  const drop = document.querySelector<HTMLElement>('#drop')!
+  const picker = document.querySelector<HTMLInputElement>('#picker')!
+  const controls = document.querySelector<HTMLElement>('#controls')!
+  const ds1Select = document.querySelector<HTMLSelectElement>('#ds1')!
+  const dt1Select = document.querySelector<HTMLSelectElement>('#dt1')!
+  const palSelect = document.querySelector<HTMLSelectElement>('#pal')!
+  const reload = document.querySelector<HTMLButtonElement>('#reload')!
+
+  let archive: MpqArchive | null = null
+
+  const fill = (select: HTMLSelectElement, options: readonly string[]): void => {
+    select.replaceChildren(...options.map(name => {
+      const option = document.createElement('option')
+      option.value = name
+      option.textContent = name
+      return option
+    }))
+  }
+
+  const reloadFromArchive = async (): Promise<void> => {
+    if (archive === null) return
+    status.textContent = '正在从归档构建地图…'
+    startScene(await loadFromArchive(archive, {
+      ds1: ds1Select.value === '' ? undefined : ds1Select.value,
+      dt1: dt1Select.value === '' ? undefined : dt1Select.value,
+      palette: palSelect.value === '' ? undefined : palSelect.value,
+    }), status, hud)
+  }
+
+  const openMpq = async (file: File | Blob, label: string): Promise<void> => {
+    try {
+      status.textContent = `正在打开 ${label} …`
+      state.archive = label
+      archive = await MpqArchive.open(blobSource(file, label))
+      const names = await archive.listFiles()
+      const byExtension = (extension: string): string[] => names.filter(name => extensionOf(name) === extension)
+      fill(ds1Select, byExtension('ds1'))
+      fill(dt1Select, byExtension('dt1'))
+      fill(palSelect, [...byExtension('pl2'), ...byExtension('pal')])
+      controls.hidden = false
+      state.source = 'mpq'
+      await reloadFromArchive()
+    } catch (error) {
+      state.error = error instanceof Error ? error.message : String(error)
+      status.textContent = `打开失败：${state.error}`
+    }
+  }
+
+  drop.onclick = () => { picker.click() }
+  picker.onchange = () => { const file = picker.files?.[0]; if (file !== undefined) void openMpq(file, file.name) }
+  drop.addEventListener('dragover', (event) => { event.preventDefault() })
+  drop.addEventListener('drop', (event) => {
+    event.preventDefault()
+    const file = event.dataTransfer?.files?.[0]
+    if (file !== undefined) void openMpq(file, file.name)
+  })
+  reload.onclick = () => { void reloadFromArchive() }
+
+  const params = new URLSearchParams(location.search)
+  const mpq = params.get('mpq')
+  const dir = params.get('data')
+  if (mpq !== null) {
+    void (async () => {
+      try {
+        status.textContent = `正在通过 HTTP 读取 ${mpq} …`
+        const response = await fetch(mpq)
+        if (!response.ok) throw new Error(`HTTP ${String(response.status)}`)
+        await openMpq(await response.blob(), mpq.split('/').pop() ?? 'archive.mpq')
+      } catch (error) {
+        state.error = error instanceof Error ? error.message : String(error)
+        status.textContent = `加载失败：${state.error}`
+      }
+    })()
+    return
+  }
+  if (dir !== null) {
+    state.source = 'fixture'
+    void (async () => {
+      try {
+        startScene(await loadFromFixtureDir(dir), status, hud)
+      } catch (error) {
+        state.error = error instanceof Error ? error.message : String(error)
+        status.textContent = `加载失败：${state.error}`
+      }
+    })()
+    return
+  }
+  status.textContent = '拖入 .mpq，或用 ?mpq=<url> / ?data=<fixture dir> 指定数据源。'
+}
+
+boot()
diff --git a/src/scene/net-scene.ts b/src/scene/net-scene.ts
new file mode 100644
index 0000000..a0759cf
--- /dev/null
+++ b/src/scene/net-scene.ts
@@ -0,0 +1,612 @@
+/**
+ * Co-op scene: two browsers, one shared world, one fighter each.
+ *
+ * The page has three jobs, and the interesting part is what it does *not* do.
+ *
+ * - **It simulates everything.** No world state, no monster position, no drop and
+ *   no damage figure crosses the wire. Each page runs the same simulation from the
+ *   same seed, and the only messages are the four the protocol defines: who I am,
+ *   what I pressed, what hash I got, goodbye. That is what makes 25 ticks a second
+ *   cheap enough to run over an ordinary connection.
+ * - **It waits rather than guesses.** The tick loop is driven by
+ *   {@link NetplaySession.pump}, which advances only when both peers' input for the
+ *   tick has arrived. A missing peer is a held world, never a fabricated input.
+ * - **It says when it disagrees.** Both peers hash their state each tick and
+ *   compare; the first tick that differs is shown on screen with both digests. A
+ *   desync that is invisible is worse than no check at all.
+ *
+ * The local player is `players[localPeer]`, which is a *view* decision: peer 0
+ * drives player 0 and peer 1 drives player 1, but both pages hold the same two
+ * bodies in the same order, which is what the state digest covers.
+ *
+ * URL parameters: `?data=<fixture dir>` (or `?mpq=<url>`) for the map,
+ * `?ws=<relay url>` to play with someone, `?peer=<index>` for this page's index,
+ * `?peers=<2..4>` for how many are playing. With no `?ws=` the page runs the same
+ * world solo, so it is useful on its own.
+ */
+import { MpqArchive } from '../mpq/archive.ts'
+import { blobSource } from '../mpq/source.ts'
+import { decodeDs1 } from '../formats/ds1.ts'
+import { decodeDt1 } from '../formats/dt1.ts'
+import { decodeDc6 } from '../formats/dc6.ts'
+import { decodePal } from '../formats/pal.ts'
+import { decodePl2 } from '../formats/pl2.ts'
+import type { Palette } from '../formats/pal.ts'
+import type { SpriteSheet } from '../formats/sprite.ts'
+import { PLAYER_SPRITE_WIDTH } from '../formats/sprite.ts'
+import { addPlayer, createWorld, monsterStatsFromTable, spawnMonsters, tickCombatMulti } from '../game/combat.ts'
+import type { CombatInput, CombatOptions, CombatWorld, MonsterStats } from '../game/combat.ts'
+import { parseTable } from '../game/tables.ts'
+import { ActorAnimator } from '../game/animation.ts'
+import { buildMapScene, blockedOverlap, findFreeSpawn } from '../game/map.ts'
+import type { MapScene } from '../game/map.ts'
+import { buildAtlas } from '../render/atlas.ts'
+import type { AtlasFrame } from '../render/atlas.ts'
+import { SpriteRenderer } from '../render/renderer.ts'
+import { GameLoop } from '../sim/loop.ts'
+import { KeyboardInput, directionOf } from '../sim/input.ts'
+import { NetplaySession } from '../net/netplay.ts'
+import { socketTransport } from '../net/transport.ts'
+import { LockstepSession } from '../net/lockstep.ts'
+import type { InputFrame, LockstepSimulation } from '../net/lockstep.ts'
+
+/** Collision box at the character's feet. */
+const FEET_WIDTH = 20
+const FEET_HEIGHT = 14
+/** Walk speed in pixels per second. */
+const WALK_SPEED = 180
+/** Monsters spawned between the two players. */
+const MONSTER_COUNT = 10
+/** Ticks of input delay: the latency budget a peer may spend without stalling. */
+const INPUT_DELAY_TICKS = 4
+/** Ticks between exchanged state hashes. */
+const HASH_INTERVAL = 5
+/** Maximum map libraries to merge, matching the campaign scene. */
+const MAX_LIBRARIES = 4
+/** World seed: fixed, because both peers must build the same world. */
+const NET_SEED = 0x0d2c0de
+
+/**
+ * The page's state, exposed for the harness. Everything the automated checks look
+ * at is here rather than scraped out of the canvas.
+ */
+interface NetState {
+  source: string
+  error: string | null
+  /** Whether a relay connection was requested. */
+  multiplayer: boolean
+  peer: number
+  connected: boolean
+  handshaked: boolean
+  timedOut: boolean
+  wsUrl: string | null
+  /** Ticks the render loop has run (25 a second, whether or not the world moves). */
+  tick: number
+  /** Ticks the shared world has actually simulated. */
+  worldTick: number
+  /** Ticks the lockstep session has cleared, which is the network's own clock. */
+  lockstepTick: number
+  /** Ticks the session did run, and handshake messages it sent. */
+  stepped: number
+  helloSent: number
+  /** The peer's seed when it disagrees with ours, otherwise null. */
+  seedMismatch: number | null
+  /** Ticks that could not run for want of the peer's input. */
+  waiting: number
+  hashesCompared: number
+  hashesAgreed: number
+  hashesIgnored: number
+  /** Whether the peer has acknowledged this page's hello. */
+  acknowledged: boolean
+  /** The first diverging tick, and both digests, when there is one. */
+  desyncTick: number | null
+  desyncLocal: number | null
+  desyncRemote: number | null
+  /** Both fighters, in peer order. */
+  players: { x: number; y: number; hp: number; maxHp: number; xp: number; level: number; alive: boolean }[]
+  /** Which player this page drives, and how many peers the game expects. */
+  localPeer: number
+  peers: number
+  peersHeard: number
+  peersExpected: number
+  monsters: number
+  kills: number
+  tickRate: number
+  frame: number
+  /** The last WebGL error code seen while rendering, 0 when clean. */
+  glError: number
+  transportOpen: boolean
+  /** Where the actor art came from, or 'marker' when the map has none. */
+  actorSource: string
+  /** How many monsters the spawn actually placed. */
+  monstersSpawned: number
+  /** Messages the socket itself delivered, counted in the page. */
+  socketFrames: number
+  /** Whether the socket reached the open state, and whether it has closed. */
+  socketOpened: boolean
+  socketClosed: boolean
+  /** Messages that arrived but failed to decode. */
+  malformed: number
+  /**
+   * The socket's own view of itself, as a string: ready state, binary type,
+   * negotiated extensions, subprotocol and unsent bytes.
+   *
+   * Kept because "no frames arrive" has several unrelated causes — a socket that
+   * never opened, a socket that negotiated an extension this relay does not
+   * speak, a socket whose frames are being refused — and this string tells them
+   * apart from outside the page.
+   */
+  socketInfo: string
+}
+
+declare global {
+  interface Window { __d2webNet?: NetState }
+}
+
+const state: NetState = {
+  source: 'none', error: null, multiplayer: false, peer: 0, connected: false, handshaked: false,
+  timedOut: false, wsUrl: null, tick: 0, worldTick: 0, lockstepTick: 0, stepped: 0, helloSent: 0,
+  seedMismatch: null, acknowledged: false, waiting: 0, hashesCompared: 0, hashesAgreed: 0, hashesIgnored: 0,
+  desyncTick: null, desyncLocal: null, desyncRemote: null, players: [], localPeer: 0, peers: 2,
+  peersHeard: 0, peersExpected: 1, monsters: 0,
+  kills: 0, tickRate: 0, frame: 0, glError: 0, transportOpen: false,
+  actorSource: 'marker', monstersSpawned: 0,
+  socketFrames: 0, socketOpened: false, socketClosed: false, malformed: 0, socketInfo: 'none',
+}
+window.__d2webNet = state
+
+/** Raw members the scene needs. */
+interface NetSources {
+  readonly ds1: Uint8Array
+  readonly libraries: readonly Uint8Array[]
+  readonly palette: Uint8Array
+  readonly paletteName: string
+  readonly actor: { readonly name: string; readonly sheet: SpriteSheet } | null
+  readonly monstats: Uint8Array | null
+}
+
+/** The monster table used when the archive has none, so the page is never empty. */
+const DEMO_MONSTERS: MonsterStats[] = monsterStatsFromTable(parseTable([
+  'Id\tName\tHP\tDamage\tCooldownTicks\tReach\tAggroRadius\tSpeed\tXP',
+  'fallen\tFallen One\t16\t2\t24\t38\t420\t150\t12',
+  'zombie\tZombie\t30\t3\t32\t42\t360\t120\t20',
+].join('\n')))
+
+let running: GameLoop | null = null
+let input: KeyboardInput | null = null
+
+/**
+ * Fetch bytes, or null when the file is absent.
+ *
+ * @param url - the URL.
+ * @returns the bytes, or null.
+ */
+async function fetchBytes(url: string): Promise<Uint8Array | null> {
+  const response = await fetch(url)
+  if (!response.ok) return null
+  return new Uint8Array(await response.arrayBuffer())
+}
+
+/**
+ * Fetch bytes, failing when the file is absent.
+ *
+ * @param url - the URL.
+ * @returns the bytes.
+ */
+async function requireBytes(url: string): Promise<Uint8Array> {
+  const bytes = await fetchBytes(url)
+  if (bytes === null) throw new Error(`缺少 ${url}`)
+  return bytes
+}
+
+/**
+ * Read the map members from a fixture directory.
+ *
+ * A fixture directory is the harness's source of truth: it needs no archive and
+ * no picker, so an automated check can load the same map on two pages and be sure
+ * both are simulating the same terrain.
+ *
+ * @param dir - the directory.
+ * @returns the sources.
+ */
+async function loadFixtureSources(dir: string): Promise<NetSources> {
+  const [ds1, dt1, palette, actor, monstats] = await Promise.all([
+    requireBytes(`${dir}/fixture.ds1`),
+    requireBytes(`${dir}/fixture.dt1`),
+    requireBytes(`${dir}/palette.pal`),
+    fetchBytes(`${dir}/actor.dc6`),
+    fetchBytes(`${dir}/data/global/excel/monstats.txt`),
+  ])
+  return {
+    ds1, libraries: [dt1], palette, paletteName: 'palette.pal', monstats,
+    actor: actor === null ? null : { name: `${dir}/actor.dc6`, sheet: decodeDc6(actor) },
+  }
+}
+
+/**
+ * Pick an archive member by extension and preferred name fragment.
+ *
+ * @param names - the archive's members.
+ * @param extension - the extension to match.
+ * @param preferred - fragments to prefer, best first.
+ * @returns the chosen name, or undefined.
+ */
+function pickMember(names: readonly string[], extension: string, preferred: readonly string[]): string | undefined {
+  const matching = names.filter(name => name.toLowerCase().endsWith(`.${extension}`))
+  const rank = (name: string): number => {
+    const lower = name.toLowerCase()
+    const index = preferred.findIndex(token => lower.includes(token))
+    return index === -1 ? preferred.length : index
+  }
+  return matching.sort((a, b) => rank(a) - rank(b) || a.localeCompare(b))[0]
+}
+
+/**
+ * Read the map members from an archive.
+ *
+ * @param blob - the archive bytes.
+ * @param label - a name for the archive, for the HUD.
+ * @returns the sources.
+ */
+async function loadArchiveSources(blob: Blob, label: string): Promise<NetSources> {
+  const archive = await MpqArchive.open(blobSource(blob, label))
+  const names = await archive.listFiles()
+  const ds1Name = pickMember(names, 'ds1', ['town', 'act1', 'rogue'])
+  if (ds1Name === undefined) throw new Error('归档中没有 .ds1')
+  const dt1Names = names.filter(name => name.toLowerCase().endsWith('.dt1'))
+    .sort((a, b) => a.localeCompare(b))
+    .slice(0, MAX_LIBRARIES)
+  if (dt1Names.length === 0) throw new Error('归档中没有 .dt1')
+  const paletteName = pickMember(names, 'pl2', ['act1', 'pal']) ?? pickMember(names, 'pal', ['town', 'act1'])
+  if (paletteName === undefined) throw new Error('归档中没有 .pl2 或 .pal')
+  const monstatsName = names.find(name => name.toLowerCase().endsWith('monstats.txt'))
+  state.source = `mpq:${label}`
+  return {
+    ds1: await archive.readByName(ds1Name),
+    libraries: await Promise.all(dt1Names.map(async name => archive.readByName(name))),
+    palette: await archive.readByName(paletteName),
+    paletteName,
+    actor: null,
+    monstats: monstatsName === undefined ? null : await archive.readByName(monstatsName),
+  }
+}
+
+/**
+ * Decode the palette member, whichever of the two formats it is.
+ *
+ * @param name - the member name.
+ * @param bytes - its bytes.
+ * @returns the palette.
+ */
+function decodePaletteMember(name: string, bytes: Uint8Array): Palette {
+  if (!name.toLowerCase().endsWith('.pl2')) return decodePal(bytes)
+  // A PL2 is a base palette plus a large stack of transform tables; the sprites
+  // only need the base, and saying so here keeps the transform tables out of the
+  // atlas build.
+  const pl2 = decodePl2(bytes)
+  return { rgb: pl2.rgb, size: 256 }
+}
+
+/**
+ * Build and start the scene.
+ *
+ * @param sources - the decoded-input bytes.
+ * @param status - the status line.
+ * @param netLine - the network line.
+ * @param peersLine - the player list line.
+ * @param wsUrl - the relay URL, when playing with someone.
+ * @param peer - this page's peer index.
+ * @param peers - how many peers the game expects, this page included.
+ */
+function startScene(
+  sources: NetSources,
+  status: HTMLElement,
+  netLine: HTMLElement,
+  peersLine: HTMLElement,
+  wsUrl: string | null,
+  peer: number,
+  peers: number,
+): void {
+  const canvas = document.querySelector<HTMLCanvasElement>('#view')!
+  const level = decodeDs1(sources.ds1)
+  const libraries = sources.libraries.map(library => decodeDt1(library))
+  const palette = decodePaletteMember(sources.paletteName, sources.palette)
+  const first = libraries[0]!
+  const merged = libraries.length === 1 ? first : {
+    versionMajor: first.versionMajor,
+    versionMinor: first.versionMinor,
+    tiles: libraries.flatMap(library => library.tiles),
+    // Libraries merged for a fixture map carry no structural warnings.
+    warnings: [],
+  }
+  const scene: MapScene = buildMapScene(level, merged)
+  const tileWidth = Math.max(...merged.tiles.map(tile => tile.width), 1)
+  const tileHeight = Math.max(...merged.tiles.map(tile => Math.abs(tile.height)), 1)
+
+  running?.stop()
+  input?.detach()
+  const renderer = new SpriteRenderer(canvas)
+  const combined: SpriteSheet = sources.actor === null
+    ? scene.sheet
+    : { groups: [...scene.sheet.groups, ...sources.actor.sheet.groups], width: null }
+  const atlas = buildAtlas(combined, palette)
+  renderer.setAtlas(atlas)
+  const frames = atlas.groups[0] ?? []
+  const actorGroups = sources.actor === null ? null : atlas.groups.slice(1)
+  state.actorSource = sources.actor?.name ?? 'marker'
+
+  const terrain = {
+    overlap: (x: number, y: number): number =>
+      blockedOverlap(scene, tileWidth, tileHeight, x, y, FEET_WIDTH, FEET_HEIGHT),
+  }
+  const options: CombatOptions = {
+    playerSpeed: WALK_SPEED,
+    playerReach: 52,
+    playerCooldownTicks: 12,
+    playerDamage: 8,
+    playerManaPerAttack: 0,
+    respawnTicks: 60,
+  }
+  const spawn = findFreeSpawn(scene, tileWidth, tileHeight, FEET_WIDTH, FEET_HEIGHT)
+
+  // The world is built identically on every page: the players in peer order, then
+  // the same monsters from the same seed. Nothing here depends on which page is
+  // looking at it, because the simulation must not either.
+  const world: CombatWorld = createWorld(spawn.x - (peers - 1) * 18, spawn.y)
+  for (let index = 1; index < peers; index += 1) {
+    addPlayer(world, spawn.x - (peers - 1) * 18 + index * 36, spawn.y)
+  }
+  const stats = sources.monstats === null
+    ? DEMO_MONSTERS
+    : monsterStatsFromTable(parseTable(new TextDecoder().decode(sources.monstats)))
+  state.monstersSpawned = spawnMonsters(world, stats, MONSTER_COUNT, spawn, 240, terrain)
+  state.localPeer = peer
+  state.peers = peers
+  state.peersExpected = peers - 1
+  state.multiplayer = wsUrl !== null
+
+  // One animator per body: the two fighters are independent actors, and the peer's
+  // avatar turns and steps from its own movement, not from this page's keys.
+  const animators = world.players.map(() => {
+    const animator = new ActorAnimator<AtlasFrame>()
+    if (actorGroups !== null && actorGroups.length > 0) {
+      animator.add({ name: 'walk', directions: actorGroups, ticksPerFrame: 2, loop: true })
+      animator.add({ name: 'stand', directions: actorGroups.map(group => group.slice(0, 1)), ticksPerFrame: 8, loop: false })
+      animator.play('stand', 0)
+    }
+    return animator
+  })
+  const previous = world.players.map(player => ({ x: player.x, y: player.y }))
+  const facings = world.players.map(() => 0)
+
+  /**
+   * The simulation the lockstep session drives: one tick, both players, then the
+   * monsters — exactly once per tick, which is why it is one call and not one per
+   * player.
+   */
+  const simulation: LockstepSimulation = {
+    advance: (inputs: readonly InputFrame[]) => {
+      const frames: CombatInput[] = inputs.map(input => ({
+        movement: input.movement,
+        attack: input.attack,
+      }))
+      tickCombatMulti(world, frames, options, terrain, DEMO_EXPERIENCE)
+    },
+    hash: () => LockstepSession.digest(digestWorld(world)),
+  }
+
+  let session: NetplaySession | null = null
+  let socketView: WebSocket | null = null
+  if (wsUrl !== null) {
+    const socket = new WebSocket(wsUrl)
+    socketView = socket
+    // Counted here as well as inside the transport: "the socket never delivered a
+    // frame" and "the transport dropped every frame" are different bugs, and the
+    // only way to tell them apart from outside the page is to count both.
+    socket.addEventListener('open', () => { state.socketOpened = true })
+    socket.addEventListener('close', () => { state.socketClosed = true })
+    socket.addEventListener('message', () => { state.socketFrames += 1 })
+    session = new NetplaySession(
+      { peer, peers, seed: NET_SEED, inputDelayTicks: INPUT_DELAY_TICKS, hashInterval: HASH_INTERVAL },
+      simulation,
+      socketTransport(socket),
+    )
+    session.start()
+    state.wsUrl = wsUrl
+    socket.addEventListener('error', () => { state.error = 'socket error' })
+  }
+
+  input = new KeyboardInput()
+  input.attach()
+
+  const loop = new GameLoop({
+    tickRate: 25,
+    onTick: () => {
+      const movement = input?.movement() ?? { x: 0, y: 0 }
+      const attacking = input?.attacking ?? false
+      for (let index = 0; index < world.players.length; index += 1) {
+        const player = world.players[index]!
+        previous[index] = { x: player.x, y: player.y }
+      }
+      if (session === null) {
+        // Solo: the same simulation, driven by this page's keys alone. Running the
+        // identical code path is what makes solo mode a real test of the networked
+        // one rather than a second implementation of it.
+        simulation.advance([{ tick: world.tick, movement, attack: attacking, pickup: false, talk: false, skill: 0 }])
+      } else {
+        session.setIntent({ movement, attack: attacking })
+        session.pump()
+      }
+      for (let index = 0; index < world.players.length; index += 1) {
+        const player = world.players[index]!
+        const before = previous[index]!
+        const facing = directionOf({ x: player.x - before.x, y: player.y - before.y })
+        if (facing !== null) facings[index] = facing
+        const moved = player.x !== before.x || player.y !== before.y
+        animators[index]!.play(moved ? 'walk' : 'stand', facings[index]!)
+        animators[index]!.tick(facings[index]!)
+      }
+      updateState(world, session, loop)
+      if (socketView !== null) {
+        state.socketInfo = `${String(socketView.readyState)}|${socketView.binaryType}|${socketView.extensions}|${socketView.protocol}|${String(socketView.bufferedAmount)}`
+      }
+    },
+    onRender: () => {
+      const local = world.players[Math.min(peer, world.players.length - 1)]!
+      renderer.begin({ x: local.x, y: local.y, zoom: 2 }, [0.04, 0.03, 0.03])
+      for (const draw of scene.floors) {
+        const frame = frames[draw.tileIndex]
+        if (frame !== undefined) renderer.draw(frame, draw.x, draw.y)
+      }
+      // The peer's fighter is tinted so two identical characters stay tellable
+      // apart on one screen.
+      for (let index = 0; index < world.players.length; index += 1) {
+        const player = world.players[index]!
+        const frame = animators[index]!.frame()
+        if (frame === undefined) continue
+        const tint: [number, number, number, number] = index === peer
+          ? [1, 1, 1, 1]
+          : [0.72, 0.86, 1, 1]
+        // Anchored at the feet, like every other actor in the scene, so the two
+        // fighters stand on the floor instead of floating above it.
+        renderer.draw(frame, player.x - frame.width / 2, player.y - frame.height, { tint })
+      }
+      for (const monster of world.monsters) {
+        const group = actorGroups?.[monster.facing]
+        if (group === undefined || group.length === 0) continue
+        const moving = monster.state === 'chase' || monster.state === 'attack'
+        const frame = group[moving ? (world.tick + monster.index * 3) % group.length : 0]
+        if (frame === undefined) continue
+        renderer.draw(frame, monster.x - frame.width / 2, monster.y - frame.height, {
+          tint: monster.state === 'dead'
+            ? [0.42, 0.36, 0.34, 1]
+            : monster.hitFlash > 0 ? [1, 0.55, 0.55, 1] : [0.85, 0.8, 0.75, 1],
+        })
+      }
+      // The batcher only reaches the screen when it is flushed: without this the
+      // canvas shows nothing but its clear colour, which looks exactly like a
+      // scene that never loaded.
+      renderer.flush()
+      state.frame += 1
+      state.glError = renderer.gl.getError()
+    },
+  })
+  running = loop
+  loop.start()
+  status.textContent = `地图已就绪：${String(scene.floors.length)} 块地砖，${String(world.players.length)} 名玩家，${String(world.monsters.length)} 只怪物。`
+  netLine.innerHTML = wsUrl === null
+    ? '单机模式（加 <code>?ws=ws://…&amp;peer=0</code> 可联机）'
+    : `联机中 · 本页 peer <b>${String(peer)}</b> · 共 <b>${String(peers)}</b> 人 · 只传按键，世界本地模拟`
+  peersLine.textContent = wsUrl === null
+    ? ''
+    : `已听到 ${String(world.players.length - 1)} 位队友的名字才算齐；齐了才会开始跑 tick——`
+      + '少一人就等，因为「抢先开跑」会让先发出的输入掉进虚空，两边永久互等。'
+}
+
+/** Fallback experience thresholds: the co-op sandbox is not about levelling. */
+const DEMO_EXPERIENCE: readonly number[] = [0, 0, 250, 700, 1500, 3000]
+
+/**
+ * Digest the world.
+ *
+ * Covers the player list in peer order, never the view's own player, so two pages
+ * that disagree only about which fighter is "local" do not look like a desync.
+ *
+ * @param world - the world.
+ * @returns the digest string.
+ */
+function digestWorld(world: CombatWorld): string {
+  const round = (value: number): number => Math.round(value * 1000)
+  return JSON.stringify({
+    tick: world.tick,
+    kills: world.kills,
+    players: world.players.map(player => [round(player.x), round(player.y), player.hp, player.xp, player.level, player.alive]),
+    monsters: world.monsters.map(monster => [round(monster.x), round(monster.y), monster.hp, monster.state]),
+  })
+}
+
+/**
+ * Refresh the exposed state and the network HUD.
+ *
+ * @param world - the world.
+ * @param session - the networked session, or null in solo play.
+ * @param loop - the loop, for the tick rate.
+ */
+function updateState(world: CombatWorld, session: NetplaySession | null, loop: GameLoop): void {
+  state.tick = loop.tick
+  state.worldTick = world.tick
+  state.tickRate = loop.tickRate
+  state.kills = world.kills
+  state.monsters = world.monsters.filter(monster => monster.state !== 'dead').length
+  state.players = world.players.map(player => ({
+    x: player.x, y: player.y, hp: player.hp, maxHp: player.maxHp,
+    xp: player.xp, level: player.level, alive: player.alive,
+  }))
+  if (session === null) {
+    state.connected = false
+    return
+  }
+  const stats = session.stats
+  state.connected = stats.connected
+  state.handshaked = stats.handshaked
+  state.timedOut = stats.timedOut
+  state.transportOpen = stats.connected
+  state.waiting = stats.waiting
+  state.malformed = stats.malformed
+  state.lockstepTick = session.lockstep.tick
+  state.stepped = stats.stepped
+  state.helloSent = stats.helloSent
+  state.acknowledged = stats.acknowledged
+  state.peersHeard = stats.peersHeard
+  state.peersExpected = stats.peersExpected
+  state.seedMismatch = session.seedMismatch
+  state.hashesCompared = stats.hashesCompared
+  state.hashesAgreed = stats.hashesAgreed
+  state.hashesIgnored = stats.hashesIgnored
+  const report = session.desyncReport
+  state.desyncTick = report?.tick ?? null
+  state.desyncLocal = report?.local ?? null
+  state.desyncRemote = report?.remote ?? null
+}
+
+/** Wire the page: pick the map source, then start the scene. */
+function boot(): void {
+  const status = document.querySelector<HTMLElement>('#status')!
+  const netLine = document.querySelector<HTMLElement>('#net')!
+  const peersLine = document.querySelector<HTMLElement>('#peers')!
+  const params = new URLSearchParams(location.search)
+  const dir = params.get('data')
+  const mpq = params.get('mpq')
+  const ws = params.get('ws')
+  const peersParam = Number(params.get('peers') ?? '2')
+  // Two to four: one page per peer, and the relay has no opinion about how many
+  // it forwards between.
+  const peers = Number.isFinite(peersParam) ? Math.min(4, Math.max(2, Math.round(peersParam))) : 2
+  const peerParam = Number(params.get('peer') ?? '0')
+  const peer = Number.isFinite(peerParam) ? Math.min(peers - 1, Math.max(0, Math.round(peerParam))) : 0
+
+  const start = (sources: NetSources): void => {
+    startScene(sources, status, netLine, peersLine, ws, peer, peers)
+  }
+
+  void (async () => {
+    try {
+      if (mpq !== null) {
+        status.textContent = `正在读取 ${mpq} …`
+        const response = await fetch(mpq)
+        if (!response.ok) throw new Error(`HTTP ${String(response.status)}`)
+        start(await loadArchiveSources(await response.blob(), mpq.split('/').pop() ?? 'archive.mpq'))
+        return
+      }
+      const fixtureDir = dir ?? 'samples/fixtures'
+      state.source = `fixture:${fixtureDir}`
+      start(await loadFixtureSources(fixtureDir))
+    } catch (error) {
+      state.error = error instanceof Error ? error.message : String(error)
+      status.textContent = `加载失败：${state.error}`
+    }
+  })()
+}
+
+/** Whether the page is running inside a document (avoids running under Node). */
+if (typeof document !== 'undefined') boot()
diff --git a/src/sim/input.ts b/src/sim/input.ts
new file mode 100644
index 0000000..daef3a3
--- /dev/null
+++ b/src/sim/input.ts
@@ -0,0 +1,191 @@
+/**
+ * Keyboard input, resolved into the game's own vocabulary.
+ *
+ * Two things are game facts rather than conveniences:
+ *
+ * - Diablo's eight facings are ordered starting at **south and turning west**
+ *   (`Direction::South, SouthWest, West, NorthWest, North, ...`), and that
+ *   order is exactly the group order inside a direction-animated sprite file.
+ *   So facing is computed from the movement vector, not from which key was
+ *   pressed.
+ * - Diagonal movement is normalised: the original moves diagonally at the same
+ *   speed as along an axis, not at √2 times it.
+ */
+
+/** Diablo's facing order: the index of a direction inside a sprite file. */
+export const DIRECTION = {
+  South: 0,
+  SouthWest: 1,
+  West: 2,
+  NorthWest: 3,
+  North: 4,
+  NorthEast: 5,
+  East: 6,
+  SouthEast: 7,
+} as const
+
+/** A direction index (0..7) or -1 for "no direction". */
+export type Direction = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7
+
+/** A normalized movement request in screen coordinates (y grows downward). */
+export interface Movement {
+  /** Horizontal component in -1..1. */
+  readonly x: number
+  /** Vertical component in -1..1. */
+  readonly y: number
+}
+
+/** Keys that mean "attack". */
+const ATTACK_KEYS = new Set(['Space', 'KeyJ', 'Enter'])
+/** Keys that mean "pick up". */
+const PICKUP_KEYS = new Set(['KeyE', 'KeyF'])
+/** Keys that mean "talk to whoever is in reach". */
+const TALK_KEYS = new Set(['KeyT'])
+/** Keys that save and load the game. */
+const SAVE_KEYS = new Set(['KeyK'])
+const LOAD_KEYS = new Set(['KeyL'])
+/** Number keys that select a skill (1-4 → slots 1-4). */
+const DIGIT_KEYS: Readonly<Record<string, number>> = {
+  Digit1: 1, Digit2: 2, Digit3: 3, Digit4: 4,
+}
+
+/** Recognised keys, mapped to a movement contribution. */
+const KEYS: Readonly<Record<string, readonly [number, number]>> = {
+  KeyW: [0, -1], ArrowUp: [0, -1],
+  KeyS: [0, 1], ArrowDown: [0, 1],
+  KeyA: [-1, 0], ArrowLeft: [-1, 0],
+  KeyD: [1, 0], ArrowRight: [1, 0],
+}
+
+/**
+ * Facing for a movement vector.
+ *
+ * @param movement - normalized movement.
+ * @returns the direction index, or null when there is no movement.
+ */
+export function directionOf(movement: Movement): Direction | null {
+  const sx = Math.sign(movement.x)
+  const sy = Math.sign(movement.y)
+  if (sx === 0 && sy === 0) return null
+  if (sx === 0) return sy > 0 ? DIRECTION.South : DIRECTION.North
+  if (sy === 0) return sx > 0 ? DIRECTION.East : DIRECTION.West
+  if (sx < 0) return sy > 0 ? DIRECTION.SouthWest : DIRECTION.NorthWest
+  return sy > 0 ? DIRECTION.SouthEast : DIRECTION.NorthEast
+}
+
+/**
+ * Key state for one window, sampled once per tick.
+ */
+export class KeyboardInput {
+  private readonly held = new Set<string>()
+  private readonly onKeyDown = (event: KeyboardEvent): void => {
+    const recognised = KEYS[event.code] !== undefined
+      || ATTACK_KEYS.has(event.code)
+      || PICKUP_KEYS.has(event.code)
+      || DIGIT_KEYS[event.code] !== undefined
+      || TALK_KEYS.has(event.code)
+      || SAVE_KEYS.has(event.code)
+      || LOAD_KEYS.has(event.code)
+    if (!recognised) return
+    // Arrows scroll the page otherwise, and held keys would repeat.
+    event.preventDefault()
+    this.held.add(event.code)
+  }
+
+  private readonly onKeyUp = (event: KeyboardEvent): void => {
+    this.held.delete(event.code)
+  }
+
+  private readonly onBlur = (): void => {
+    this.held.clear()
+  }
+
+  private readonly target: Window
+
+  /**
+   * @param target - the window to listen on.
+   */
+  constructor(target: Window = window) {
+    this.target = target
+  }
+
+  /** Start listening. */
+  attach(): void {
+    this.target.addEventListener('keydown', this.onKeyDown)
+    this.target.addEventListener('keyup', this.onKeyUp)
+    this.target.addEventListener('blur', this.onBlur)
+  }
+
+  /** Stop listening and release every key. */
+  detach(): void {
+    this.target.removeEventListener('keydown', this.onKeyDown)
+    this.target.removeEventListener('keyup', this.onKeyUp)
+    this.target.removeEventListener('blur', this.onBlur)
+    this.held.clear()
+  }
+
+  /**
+   * The movement requested this tick, normalised so diagonals are not faster.
+   *
+   * @returns the movement vector.
+   */
+  movement(): Movement {
+    let x = 0
+    let y = 0
+    for (const code of this.held) {
+      const contribution = KEYS[code]
+      if (contribution === undefined) continue
+      x += contribution[0]
+      y += contribution[1]
+    }
+    const magnitude = Math.hypot(x, y)
+    if (magnitude === 0) return { x: 0, y: 0 }
+    return { x: x / magnitude, y: y / magnitude }
+  }
+
+  /** Whether any movement key is held. */
+  get active(): boolean {
+    for (const code of this.held) if (KEYS[code] !== undefined) return true
+    return false
+  }
+
+  /** Whether an attack key is held this tick. */
+  get attacking(): boolean {
+    for (const code of this.held) if (ATTACK_KEYS.has(code)) return true
+    return false
+  }
+
+  /** Whether a pickup key is held this tick. */
+  get pickingUp(): boolean {
+    for (const code of this.held) if (PICKUP_KEYS.has(code)) return true
+    return false
+  }
+
+  /** Whether a talk key is held this tick. */
+  get talking(): boolean {
+    for (const code of this.held) if (TALK_KEYS.has(code)) return true
+    return false
+  }
+
+  /** Whether a save key is held this tick. */
+  get saving(): boolean {
+    for (const code of this.held) if (SAVE_KEYS.has(code)) return true
+    return false
+  }
+
+  /** Whether a load key is held this tick. */
+  get loading(): boolean {
+    for (const code of this.held) if (LOAD_KEYS.has(code)) return true
+    return false
+  }
+
+  /** Skill slots requested by the number keys currently held. */
+  get digits(): readonly number[] {
+    const out: number[] = []
+    for (const code of this.held) {
+      const slot = DIGIT_KEYS[code]
+      if (slot !== undefined) out.push(slot)
+    }
+    return out
+  }
+}
diff --git a/src/sim/loop.ts b/src/sim/loop.ts
new file mode 100644
index 0000000..8e5eebd
--- /dev/null
+++ b/src/sim/loop.ts
@@ -0,0 +1,104 @@
+/**
+ * Fixed-timestep game loop.
+ *
+ * Diablo's simulation runs at 25 ticks per second, and that rate is not
+ * cosmetic: animation frames, movement, and monster AI all advance per tick,
+ * so anything derived from wall-clock time would diverge from the original
+ * behaviour. The loop therefore ticks at a fixed rate and lets rendering happen
+ * whenever the browser paints, interpolating only the camera-facing positions
+ * the caller asks to smooth.
+ */
+/** Loop wiring. */
+export interface LoopOptions {
+  /** Ticks per second (Diablo's simulation rate: 25). */
+  readonly tickRate: number
+  /** Advance the simulation by one tick. */
+  readonly onTick: (tick: number) => void
+  /**
+   * Draw one frame.
+   *
+   * @param alpha - how far the next tick is into the future, in `0..1`, for
+   * interpolation between ticks.
+   * @param frameMs - wall-clock duration of the previous frame.
+   */
+  readonly onRender: (alpha: number, frameMs: number) => void
+  /** Most ticks to run in one frame before discarding the backlog. */
+  readonly maxCatchUp?: number
+}
+
+/**
+ * A fixed-rate loop driven by `requestAnimationFrame`.
+ */
+export class GameLoop {
+  private readonly options: LoopOptions
+  private readonly tickMs: number
+  private readonly maxCatchUp: number
+  private accumulator = 0
+  private lastTime = 0
+  private handle = 0
+  private running = false
+  private consumed = 0
+  private rateWindowStart = 0
+  private rateWindowTicks = 0
+  private measuredRate = 0
+
+  /**
+   * @param options - loop wiring.
+   */
+  constructor(options: LoopOptions) {
+    this.options = options
+    this.tickMs = 1000 / options.tickRate
+    this.maxCatchUp = options.maxCatchUp ?? 5
+  }
+
+  /** Ticks simulated since the loop started. */
+  get tick(): number {
+    return this.consumed
+  }
+
+  /** Measured ticks per second over the last window (0 until one has elapsed). */
+  get tickRate(): number {
+    return this.measuredRate
+  }
+
+  /** Begin ticking. Idempotent. */
+  start(): void {
+    if (this.running) return
+    this.running = true
+    this.lastTime = performance.now()
+    this.rateWindowStart = this.lastTime
+    this.rateWindowTicks = 0
+    const step = (now: number): void => {
+      if (!this.running) return
+      const elapsed = now - this.lastTime
+      this.lastTime = now
+      this.accumulator += elapsed
+      let steps = 0
+      while (this.accumulator >= this.tickMs && steps < this.maxCatchUp) {
+        this.accumulator -= this.tickMs
+        this.consumed += 1
+        this.rateWindowTicks += 1
+        this.options.onTick(this.consumed)
+        steps += 1
+      }
+      // A long stall (a backgrounded tab, a slow load) must not replay minutes
+      // of simulation on the next frame: drop the backlog instead.
+      if (this.accumulator > this.tickMs * this.maxCatchUp) this.accumulator = 0
+      if (now - this.rateWindowStart >= 1000) {
+        this.measuredRate = (this.rateWindowTicks * 1000) / (now - this.rateWindowStart)
+        this.rateWindowStart = now
+        this.rateWindowTicks = 0
+      }
+      this.options.onRender(this.accumulator / this.tickMs, elapsed)
+      this.handle = requestAnimationFrame(step)
+    }
+    this.handle = requestAnimationFrame(step)
+  }
+
+  /** Stop ticking. Idempotent. */
+  stop(): void {
+    this.running = false
+    if (this.handle !== 0) cancelAnimationFrame(this.handle)
+    this.handle = 0
+  }
+}
diff --git a/src/walk.ts b/src/walk.ts
new file mode 100644
index 0000000..73f0be6
--- /dev/null
+++ b/src/walk.ts
@@ -0,0 +1,289 @@
+/**
+ * Walkable scene (milestone M1 skeleton): a real animated character moving on
+ * a collided map at the game's own simulation rate.
+ *
+ * Everything here is format-agnostic except the four lines that name Diablo I
+ * members. The engine pieces — atlas, WebGL2 batcher, fixed 25 Hz loop,
+ * facing/resolution, axis-separated collision, camera follow — are the ones
+ * Diablo II art will plug into unchanged; only the decoders behind them differ.
+ *
+ * The character art is real (the warrior's walk and stand sheets, decoded with
+ * the width the game's own table gives), while the floor and walls are
+ * placeholder geometry: real level art arrives with the DS1/DT1 decoders, and
+ * nothing here should pretend otherwise.
+ */
+import { MpqArchive } from './mpq/archive.ts'
+import { blobSource } from './mpq/source.ts'
+import { decodeSpriteFile } from './formats/cel.ts'
+import { decodePal } from './formats/pal.ts'
+import { PLAYER_SPRITE_WIDTH } from './formats/sprite.ts'
+import type { SpriteSheet } from './formats/sprite.ts'
+import { buildAtlas } from './render/atlas.ts'
+import { SpriteRenderer } from './render/renderer.ts'
+import type { AtlasFrame } from './render/atlas.ts'
+import { GameLoop } from './sim/loop.ts'
+import { DIRECTION, KeyboardInput, directionOf } from './sim/input.ts'
+import type { Direction } from './sim/input.ts'
+
+/** One world tile, in pixels (Diablo's subtile grid is 32 wide). */
+const TILE = 32
+/** Map extent in tiles. */
+const MAP_TILES_X = 40
+const MAP_TILES_Y = 30
+/** Walk speed in tiles per second, applied per tick. */
+const WALK_TILES_PER_SECOND = 6
+/** Ticks per animation frame while walking. */
+const TICKS_PER_WALK_FRAME = 2
+/** Collision box at the character's feet. */
+const FEET_WIDTH = 18
+const FEET_HEIGHT = 12
+
+/** Placeholder world colours (real tiles replace these). */
+const GROUND_COLOR: readonly [number, number, number, number] = [0.16, 0.13, 0.11, 1]
+const WALL_COLOR: readonly [number, number, number, number] = [0.34, 0.28, 0.22, 1]
+const WALL_TOP_COLOR: readonly [number, number, number, number] = [0.44, 0.37, 0.29, 1]
+
+/** An axis-aligned world rectangle. */
+interface Rect {
+  readonly x: number
+  readonly y: number
+  readonly width: number
+  readonly height: number
+}
+
+/** Player state carried across ticks. */
+interface PlayerState {
+  x: number
+  y: number
+  facing: Direction
+  walkFrame: number
+  moving: boolean
+}
+
+/** Live scene state, also published for automated checks. */
+export interface WalkState {
+  /** True once art is loaded and the loop is running. */
+  ready: boolean
+  /** Ticks simulated. */
+  tick: number
+  /** Measured ticks per second. */
+  tickRate: number
+  /** Player position in world pixels. */
+  x: number
+  y: number
+  /** Facing index (0 = south). */
+  facing: number
+  /** Current walk animation frame. */
+  walkFrame: number
+  /** Whether the character moved on the last tick. */
+  moving: boolean
+  /** Draw calls issued on the last rendered frame. */
+  drawCalls: number
+  /** Reason the scene failed to start, if any. */
+  error: string | null
+}
+
+declare global {
+  interface Window {
+    /** Scene state for automation and debugging. */
+    __d2web?: WalkState
+  }
+}
+
+const state: WalkState = {
+  ready: false, tick: 0, tickRate: 0, x: 0, y: 0,
+  facing: DIRECTION.South, walkFrame: 0, moving: false, drawCalls: 0, error: null,
+}
+window.__d2web = state
+
+/** Walls: a border plus a few blocks, enough to exercise collision. */
+function buildWalls(): Rect[] {
+  const walls: Rect[] = []
+  const push = (x: number, y: number, width: number, height: number): void => {
+    walls.push({ x: x * TILE, y: y * TILE, width: width * TILE, height: height * TILE })
+  }
+  // Border.
+  push(0, 0, MAP_TILES_X, 1)
+  push(0, MAP_TILES_Y - 1, MAP_TILES_X, 1)
+  push(0, 0, 1, MAP_TILES_Y)
+  push(MAP_TILES_X - 1, 0, 1, MAP_TILES_Y)
+  // Interior blocks, laid out so a diagonal walk has to slide along them.
+  push(6, 5, 4, 2)
+  push(14, 4, 2, 8)
+  push(20, 10, 6, 2)
+  push(26, 6, 2, 10)
+  push(9, 14, 6, 2)
+  push(18, 18, 8, 2)
+  push(30, 16, 4, 6)
+  push(4, 20, 3, 5)
+  return walls
+}
+
+/**
+ * Whether a feet box overlaps any wall.
+ *
+ * @param x - feet centre x.
+ * @param y - feet centre y.
+ * @param walls - wall rectangles.
+ * @returns true on overlap.
+ */
+function collides(x: number, y: number, walls: readonly Rect[]): boolean {
+  const left = x - FEET_WIDTH / 2
+  const right = x + FEET_WIDTH / 2
+  const top = y - FEET_HEIGHT / 2
+  const bottom = y + FEET_HEIGHT / 2
+  for (const wall of walls) {
+    if (right <= wall.x || left >= wall.x + wall.width) continue
+    if (bottom <= wall.y || top >= wall.y + wall.height) continue
+    return true
+  }
+  return false
+}
+
+/**
+ * Boot the scene from an archive.
+ *
+ * @param archive - the open archive.
+ */
+async function start(archive: MpqArchive): Promise<void> {
+  const canvas = document.querySelector<HTMLCanvasElement>('#view')!
+  const status = document.querySelector<HTMLElement>('#status')!
+  const hud = document.querySelector<HTMLElement>('#hud')!
+
+  const palette = decodePal(await archive.readByName('levels\\towndata\\town.pal'))
+  // The game's own width for stand and walk: 96 for the base classes.
+  const width = PLAYER_SPRITE_WIDTH.walk
+  const load = async (name: string): Promise<SpriteSheet> =>
+    decodeSpriteFile(await archive.readByName(name), 'cl2', { width })
+
+  const walk = await load('plrgfx\\warrior\\wlh\\wlhwl.cl2')
+  let stand: SpriteSheet | null = null
+  try {
+    stand = await load('plrgfx\\warrior\\wlh\\wlhst.cl2')
+  } catch {
+    // A missing stand sheet is not fatal: walking art covers every facing.
+    stand = null
+  }
+  const joined: SpriteSheet = {
+    groups: stand === null ? walk.groups : [...walk.groups, ...stand.groups],
+    width,
+  }
+  const atlas = buildAtlas(joined, palette)
+  const walkFrames: readonly (readonly AtlasFrame[])[] = atlas.groups.slice(0, walk.groups.length)
+  const standFrames: readonly (readonly AtlasFrame[])[] | null =
+    stand === null ? null : atlas.groups.slice(walk.groups.length)
+
+  const renderer = new SpriteRenderer(canvas)
+  renderer.setAtlas(atlas)
+
+  const walls = buildWalls()
+  const player: PlayerState = {
+    x: (MAP_TILES_X / 2) * TILE,
+    y: (MAP_TILES_Y / 2) * TILE,
+    facing: DIRECTION.South,
+    walkFrame: 0,
+    moving: false,
+  }
+  const feetOffset = FEET_HEIGHT / 2
+
+  const input = new KeyboardInput()
+  input.attach()
+
+  const loop = new GameLoop({
+    tickRate: 25,
+    onTick: () => {
+      const movement = input.movement()
+      const direction = directionOf(movement)
+      const moving = direction !== null
+      if (direction !== null) player.facing = direction
+      player.moving = moving
+      if (moving) {
+        const step = (WALK_TILES_PER_SECOND * TILE) / 25
+        // Axis-separated resolution: a blocked axis stops, the other slides.
+        const nextX = player.x + movement.x * step
+        if (!collides(nextX, player.y, walls)) player.x = nextX
+        const nextY = player.y + movement.y * step
+        if (!collides(player.x, nextY, walls)) player.y = nextY
+        player.walkFrame = (player.walkFrame + 1) % (walk.groups[player.facing]?.frames.length * TICKS_PER_WALK_FRAME)
+      } else {
+        player.walkFrame = 0
+      }
+      state.tick = loop.tick
+      state.x = player.x
+      state.y = player.y
+      state.facing = player.facing
+      state.walkFrame = Math.floor(player.walkFrame / TICKS_PER_WALK_FRAME)
+      state.moving = player.moving
+    },
+    onRender: () => {
+      const camera = { x: player.x, y: player.y - 24, zoom: 2 }
+      renderer.begin(camera, [0.05, 0.04, 0.03])
+      // Ground, then walls, then the character: painter's order, no depth test.
+      renderer.drawSolid(0, 0, MAP_TILES_X * TILE, MAP_TILES_Y * TILE, GROUND_COLOR)
+      for (const wall of walls) {
+        renderer.drawSolid(wall.x, wall.y, wall.width, wall.height, WALL_COLOR)
+        renderer.drawSolid(wall.x, wall.y, wall.width, 4, WALL_TOP_COLOR)
+      }
+      const sheet = player.moving || standFrames === null ? walkFrames : standFrames
+      const frames = sheet[player.facing]
+      const frame = frames?.[player.moving ? state.walkFrame % frames.length : 0]
+      if (frame !== undefined) {
+        renderer.draw(frame, player.x - frame.width / 2, player.y - frame.height + feetOffset)
+      }
+      renderer.flush()
+      state.drawCalls = 1
+      state.tickRate = loop.tickRate
+      hud.textContent = `tick ${String(state.tick)} · ${loop.tickRate.toFixed(1)} tps`
+        + ` · pos ${player.x.toFixed(0)},${player.y.toFixed(0)}`
+        + ` · facing ${String(player.facing)} · frame ${String(state.walkFrame)}`
+        + ` · ${String(atlas.groups.length)} groups / ${String(walk.groups.reduce((n, g) => n + g.frames.length, 0))} walk frames`
+    },
+  })
+  loop.start()
+  state.ready = true
+  status.textContent = 'WASD / 方向键移动。角色为真实暗黑1 素材（战士行走/站立，宽度 96 = 游戏表数值）；地面与墙为占位几何。'
+}
+
+/** Wire the drop zone and any `?sample=` URL. */
+function boot(): void {
+  const drop = document.querySelector<HTMLElement>('#drop')!
+  const picker = document.querySelector<HTMLInputElement>('#picker')!
+  const status = document.querySelector<HTMLElement>('#status')!
+
+  const open = async (file: File): Promise<void> => {
+    try {
+      status.textContent = `正在读取 ${file.name} …`
+      const archive = await MpqArchive.open(blobSource(file))
+      await start(archive)
+    } catch (error) {
+      state.error = (error as Error).message
+      status.textContent = `启动失败：${state.error}`
+    }
+  }
+
+  drop.onclick = () => { picker.click() }
+  picker.onchange = () => { const file = picker.files?.[0]; if (file) void open(file) }
+  drop.addEventListener('dragover', (event) => { event.preventDefault() })
+  drop.addEventListener('drop', (event) => {
+    event.preventDefault()
+    const file = event.dataTransfer?.files?.[0]
+    if (file) void open(file)
+  })
+
+  const sample = new URLSearchParams(location.search).get('sample')
+  if (sample !== null) {
+    void (async () => {
+      status.textContent = `正在通过 HTTP 读取 ${sample} …`
+      const response = await fetch(sample)
+      if (!response.ok) {
+        state.error = `sample HTTP ${String(response.status)}`
+        status.textContent = state.error
+        return
+      }
+      const blob = await response.blob()
+      await open(new File([blob], sample.split('/').pop() ?? 'sample.mpq'))
+    })()
+  }
+}
+
+boot()
diff --git a/tools/go-oracle/main.go b/tools/go-oracle/main.go
new file mode 100644
index 0000000..cb23c06
--- /dev/null
+++ b/tools/go-oracle/main.go
@@ -0,0 +1,323 @@
+// Reference dumper: decode a Diablo II format file with the community Go
+// implementations and print a canonical JSON summary, so this project's
+// TypeScript decoders can be diffed against an independent implementation.
+//
+// Usage: go run main.go <dc6|dt1|ds1> <file>
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	dc6pkg "github.com/OpenDiablo2/dc6/pkg"
+	pl2pkg "github.com/OpenDiablo2/pl2/pkg"
+	ds1pkg "github.com/OpenDiablo2/ds1/pkg"
+	dt1pkg "github.com/OpenDiablo2/dt1/pkg"
+)
+
+// ints converts a byte slice into a JSON-friendly array (Go would otherwise
+// marshal it as base64).
+func ints(data []byte) []int {
+	out := make([]int, len(data))
+	for i, value := range data {
+		out[i] = int(value)
+	}
+	return out
+}
+
+func main() {
+	if len(os.Args) < 3 {
+		fmt.Fprintln(os.Stderr, "usage: main <dc6|dt1|ds1> <file>")
+		os.Exit(2)
+	}
+	data, err := os.ReadFile(os.Args[2])
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+
+	var out any
+	switch os.Args[1] {
+	case "dc6":
+		out, err = dumpDc6(data)
+	case "dt1":
+		out, err = dumpDt1(data)
+	case "ds1":
+		out, err = dumpDs1(data)
+	case "pl2":
+		out, err = dumpPl2(data)
+	default:
+		err = fmt.Errorf("unknown format %q", os.Args[1])
+	}
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+	encoded, err := json.MarshalIndent(out, "", "  ")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+	fmt.Println(string(encoded))
+}
+
+// dumpDc6 reports the header plus every frame's geometry and index grid.
+func dumpDc6(data []byte) (any, error) {
+	sheet, err := dc6pkg.FromBytes(data)
+	if err != nil {
+		return nil, err
+	}
+	frames := []any{}
+	for _, direction := range sheet.Directions {
+		perDirection := []any{}
+		for _, frame := range direction.Frames {
+			perDirection = append(perDirection, map[string]any{
+				"width":   int(frame.Width),
+				"height":  int(frame.Height),
+				"offsetX": int(frame.OffsetX),
+				"offsetY": int(frame.OffsetY),
+				"indices": ints(frame.IndexData),
+			})
+		}
+		frames = append(frames, perDirection)
+	}
+	perDirection := 0
+	if len(sheet.Directions) > 0 {
+		perDirection = len(sheet.Directions[0].Frames)
+	}
+	return map[string]any{
+		"format":             "dc6",
+		"directions":         len(sheet.Directions),
+		"framesPerDirection": perDirection,
+		"frames":             frames,
+	}, nil
+}
+
+// dumpDt1 reports every tile's identity fields, sub-tile flags and block pixels.
+func dumpDt1(data []byte) (any, error) {
+	library, err := dt1pkg.FromBytes(data)
+	if err != nil {
+		return nil, err
+	}
+	tiles := []any{}
+	for _, tile := range library.Tiles {
+		flags := []any{}
+		for _, flag := range tile.SubTileFlags {
+			var raw byte
+			if flag.BlockWalk {
+				raw |= 1
+			}
+			if flag.BlockLOS {
+				raw |= 2
+			}
+			if flag.BlockJump {
+				raw |= 4
+			}
+			if flag.BlockPlayerWalk {
+				raw |= 8
+			}
+			if flag.BlockLight {
+				raw |= 32
+			}
+			flags = append(flags, int(raw))
+		}
+		blocks := []any{}
+		for _, block := range tile.Blocks {
+			blocks = append(blocks, map[string]any{
+				"x":      int(block.X),
+				"y":      int(block.Y),
+				"gridX":  int(block.GridX),
+				"gridY":  int(block.GridY),
+				"format": int(block.Format),
+				"pixels": ints(block.PixelData),
+			})
+		}
+		material := 0
+		if tile.MaterialFlags.Other {
+			material |= 0x0001
+		}
+		if tile.MaterialFlags.Water {
+			material |= 0x0002
+		}
+		if tile.MaterialFlags.WoodObject {
+			material |= 0x0004
+		}
+		if tile.MaterialFlags.InsideStone {
+			material |= 0x0008
+		}
+		if tile.MaterialFlags.OutsideStone {
+			material |= 0x0010
+		}
+		if tile.MaterialFlags.Dirt {
+			material |= 0x0020
+		}
+		if tile.MaterialFlags.Sand {
+			material |= 0x0040
+		}
+		if tile.MaterialFlags.Wood {
+			material |= 0x0080
+		}
+		if tile.MaterialFlags.Lava {
+			material |= 0x0100
+		}
+		if tile.MaterialFlags.Snow {
+			material |= 0x0400
+		}
+		tiles = append(tiles, map[string]any{
+			"direction":     int(tile.Direction),
+			"height":        int(tile.Height),
+			"width":         int(tile.Width),
+			"type":          int(tile.Type),
+			"style":         int(tile.Style),
+			"sequence":      int(tile.Sequence),
+			"materialFlags": material,
+			"subTileFlags":  flags,
+			"blocks":        blocks,
+		})
+	}
+	return map[string]any{"format": "dt1", "tiles": tiles}, nil
+}
+
+// dumpDs1 reports the map header, every cell's layers and the object list.
+func dumpDs1(data []byte) (any, error) {
+	level, err := ds1pkg.FromBytes(data)
+	if err != nil {
+		return nil, err
+	}
+	rows := []any{}
+	for y := 0; y < int(level.Height); y++ {
+		row := []any{}
+		for x := 0; x < int(level.Width); x++ {
+			cell := level.Tiles[y][x]
+			walls := []any{}
+			for _, wall := range cell.Walls {
+				walls = append(walls, map[string]any{
+					"prop1":    int(wall.Prop1),
+					"sequence": int(wall.Sequence),
+					"style":    int(wall.Style),
+					"type":     int(wall.Type),
+					"unknown1": int(wall.Unknown1),
+					"unknown2": int(wall.Unknown2),
+					"hidden":   wall.Hidden,
+				})
+			}
+			floors := []any{}
+			for _, floor := range cell.Floors {
+				floors = append(floors, map[string]any{
+					"prop1":    int(floor.Prop1),
+					"sequence": int(floor.Sequence),
+					"style":    int(floor.Style),
+					"unknown1": int(floor.Unknown1),
+					"unknown2": int(floor.Unknown2),
+					"hidden":   floor.Hidden,
+				})
+			}
+			shadows := []any{}
+			for _, shadow := range cell.Shadows {
+				shadows = append(shadows, map[string]any{
+					"prop1":    int(shadow.Prop1),
+					"sequence": int(shadow.Sequence),
+					"style":    int(shadow.Style),
+					"unknown1": int(shadow.Unknown1),
+					"unknown2": int(shadow.Unknown2),
+					"hidden":   shadow.Hidden,
+				})
+			}
+			row = append(row, map[string]any{"walls": walls, "floors": floors, "shadows": shadows})
+		}
+		rows = append(rows, row)
+	}
+	objects := []any{}
+	for _, object := range level.Objects {
+		objects = append(objects, map[string]any{
+			"type": int(object.Type), "id": int(object.ID),
+			"x": int(object.X), "y": int(object.Y), "flags": int(object.Flags),
+		})
+	}
+	return map[string]any{
+		"format":      "ds1",
+		"version":     int(level.Version),
+		"width":       int(level.Width),
+		"height":      int(level.Height),
+		"act":         int(level.Act),
+		"wallLayers":  int(level.NumberOfWalls),
+		"floorLayers": int(level.NumberOfFloors),
+		"cells":       rows,
+		"objects":     objects,
+	}, nil
+}
+
+// fnv1a is a small digest so whole tables can be compared without shipping
+// 442 KB of numbers through JSON.
+func fnv1a(data []byte) uint32 {
+	var hash uint32 = 2166136261
+	for _, b := range data {
+		hash ^= uint32(b)
+		hash *= 16777619
+	}
+	return hash
+}
+
+func digestTables(tables [][]byte) []uint32 {
+	for _, table := range tables {
+		_ = table
+	}
+	out := make([]uint32, 0, len(tables))
+	for _, table := range tables {
+		out = append(out, fnv1a(table))
+	}
+	return out
+}
+
+// dumpPl2 reports the base palette, the text palette and a per-group digest of
+// every transform table, so a layout disagreement shows up as a digest mismatch.
+func dumpPl2(data []byte) (any, error) {
+	palette, err := pl2pkg.FromBytes(data)
+	if err != nil {
+		return nil, err
+	}
+	base := []int{}
+	for _, c := range palette.BasePalette {
+		r, g, b, _ := c.RGBA()
+		base = append(base, int(uint8(r)), int(uint8(g)), int(uint8(b)))
+	}
+	text := []int{}
+	for _, c := range palette.TextColors {
+		r, g, b, _ := c.RGBA()
+		text = append(text, int(uint8(r)), int(uint8(g)), int(uint8(b)))
+	}
+	asBytes := func(tables []pl2pkg.Transform) [][]byte {
+		out := make([][]byte, 0, len(tables))
+		for i := range tables {
+			out = append(out, tables[i][:])
+		}
+		return out
+	}
+	alpha := [][]byte{}
+	for i := range palette.AlphaBlend {
+		alpha = append(alpha, asBytes(palette.AlphaBlend[i])...)
+	}
+	return map[string]any{
+		"format": "pl2",
+		"size":   len(data),
+		"base":   base,
+		"text":   text,
+		"groups": map[string]any{
+			"lightLevels":        digestTables(asBytes(palette.LightLevelVariations)),
+			"inverseColors":      digestTables(asBytes(palette.InvColorVariations)),
+			"selectedUnitShift":  digestTables(asBytes([]pl2pkg.Transform{palette.SelectedUnitShift})),
+			"alphaBlend":         digestTables(alpha),
+			"additiveBlend":      digestTables(asBytes(palette.AdditiveBlend)),
+			"multiplyBlend":      digestTables(asBytes(palette.MultiplicativeBlend)),
+			"hueVariations":      digestTables(asBytes(palette.HueVariations)),
+			"redTones":           digestTables(asBytes([]pl2pkg.Transform{palette.RedTones})),
+			"greenTones":         digestTables(asBytes([]pl2pkg.Transform{palette.GreenTones})),
+			"blueTones":          digestTables(asBytes([]pl2pkg.Transform{palette.BlueTones})),
+			"unknownVariations":  digestTables(asBytes(palette.UnknownVariations)),
+			"maxComponentBlend":  digestTables(asBytes(palette.MaxComponentBlend)),
+			"darkenedShift":      digestTables(asBytes([]pl2pkg.Transform{palette.DarkenedColorShift})),
+			"textShifts":         digestTables(asBytes(palette.TextColorShifts)),
+		},
+	}, nil
+}
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..4da3545
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "strict": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitOverride": true,
+    "noFallthroughCasesInSwitch": true,
+    "isolatedModules": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts", "scripts/**/*.ts", "vite.config.ts"]
+}
diff --git a/vite.config.ts b/vite.config.ts
new file mode 100644
index 0000000..4d4dd64
--- /dev/null
+++ b/vite.config.ts
@@ -0,0 +1,30 @@
+import { defineConfig } from 'vite'
+
+/**
+ * The engine is plain TypeScript with no runtime dependencies: Vite only serves
+ * and bundles it. Four entries: the asset inspector (`index.html`), the walkable
+ * scene (`walk.html`), the campaign map scene (`map.html`) and the two-player
+ * co-op scene (`net.html`). `samples/` is served in dev so all of them can be
+ * smoke-tested over HTTP (`?sample=samples/spawn.mpq`,
+ * `?data=samples/fixtures`).
+ */
+export default defineConfig({
+  server: {
+    host: '127.0.0.1',
+    port: 5173,
+    strictPort: true,
+  },
+  build: {
+    target: 'es2022',
+    sourcemap: true,
+    rollupOptions: {
+      input: {
+        index: new URL('./index.html', import.meta.url).pathname,
+        walk: new URL('./walk.html', import.meta.url).pathname,
+        map: new URL('./map.html', import.meta.url).pathname,
+        net: new URL('./net.html', import.meta.url).pathname,
+        acts: new URL('./acts.html', import.meta.url).pathname,
+      },
+    },
+  },
+})
diff --git a/walk.html b/walk.html
new file mode 100644
index 0000000..f9f044a
--- /dev/null
+++ b/walk.html
@@ -0,0 +1,51 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>d2web · 可行走场景（M1）</title>
+    <style>
+      :root { color-scheme: dark; }
+      * { box-sizing: border-box; }
+      body {
+        margin: 0;
+        background: #0f0d0a;
+        color: #e8dcc8;
+        font: 13px/1.5 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+      }
+      header {
+        padding: 10px 16px;
+        border-bottom: 1px solid #33291f;
+        display: flex;
+        gap: 14px;
+        align-items: baseline;
+        flex-wrap: wrap;
+      }
+      h1 { font-size: 14px; margin: 0; color: #c8a15a; letter-spacing: .06em; }
+      a { color: #c8a15a; }
+      #hud { color: #9c8d78; }
+      #drop {
+        margin: 10px 16px;
+        padding: 8px 12px;
+        border: 1px dashed #6d5a34;
+        border-radius: 6px;
+        color: #9c8d78;
+        cursor: pointer;
+      }
+      #status { margin: 0 16px 10px; color: #9c8d78; }
+      canvas { display: block; margin: 0 16px; background: #000; border: 1px solid #33291f; width: 960px; height: 560px; }
+    </style>
+  </head>
+  <body>
+    <header>
+      <h1>d2web · M1</h1>
+      <a href="/">资源检查器</a>
+      <span id="hud">—</span>
+    </header>
+    <div id="drop">拖入 .mpq（或使用 ?sample=）后即可用 WASD / 方向键走动</div>
+    <input id="picker" type="file" accept=".mpq,.MPQ" hidden />
+    <p id="status">等待归档…</p>
+    <canvas id="view" width="960" height="560"></canvas>
+    <script type="module" src="/src/walk.ts"></script>
+  </body>
+</html>