Release Healer Man 0.1.28

DEPLOYMENT.md

@@ -207,6 +207,7 @@ $ReleaseVersion = [ordered]@{
 npm run content:test
 npm run server:test
 npm test
+npm run content:publish
 npm run build
 npm test -- --run src/avatar
 npx vitest run src/game/inputManager.test.ts src/game/inputMath.test.ts
@@ -222,6 +223,11 @@ git push origin main
 git rev-parse HEAD
 ```
 
+`content:publish` is a fail-closed pre-build release check. It must report all
+54 WoW campaign dungeon packs and refuses to replace the manifest when a pack,
+dependency, or catalog-referenced asset is missing. Its local `content/` output
+is ignored and must not be staged.
+
 Before `git commit`, read the staged file list printed by `git status --short`.
 Do not commit a `.env` file, password, API token, keystore, APK, database,
 `content/`, `dist/`, `dist-android/`, `.web-public/`, or `.android-public/`

PLAYTEST_NOTES.md

@@ -4,6 +4,39 @@ This file is the durable record of runtime behavior, regressions, and the
 evidence required before calling a visual bug fixed. Update it whenever scene,
 camera, input, physics, mob-rendering, or asset-loading code changes.
 
+## 2026-09-10 Personal UI templates and desktop action bars
+
+- Opened Wailing Caverns through the normal offline roster, dungeon, and role
+  selection screens, then opened Pause > Edit UI & templates.
+- Verified five bars containing 12 buttons each, including 2 x 6 and 3 x 4
+  arrangements. Default stacking accounts for each bar's height. The editor
+  can collapse or dock on either side so drag handles remain reachable.
+- Clicked Renew and pressed Shift+Q in keybind edit mode. Reassigned Shift+Q
+  to bar 5/button 12 and verified the previous keybind cleared. Assigned Renew
+  to that button through the ability picker; after saving, Shift+Q cast it and
+  displayed its cooldown. No spell fired during key capture.
+- Dragged the minimap, hid party frames, saved/renamed/overwrote PC slot 1,
+  loaded it, and round-tripped all layouts through export text and import.
+  The imported JSON retained the minimap position, hidden party, bar geometry,
+  ability assignment, key chord, and template name. Restoring a hidden widget
+  works, and Cancel discards that visibility edit.
+- At a 390 x 844 viewport, the editor remained within the viewport and the
+  Save UI button was visible and 36 CSS pixels high. The in-app browser's
+  screenshot preview scales the page unusually at this override; DOM bounds
+  confirmed the editor was 310 CSS pixels wide. This was responsive browser
+  verification, not an Android hardware playtest.
+- Evidence: `playtest-artifacts/ui-layout-desktop.png` and
+  `playtest-artifacts/ui-layout-phone-viewport.png`. Restored the offline UI
+  to defaults and removed the temporary template via import after testing.
+- Automated coverage includes migration to six slots, owner isolation,
+  cloud upload/hydration into a separate device cache with a mocked endpoint,
+  malformed imports, key conflicts, and input precedence. No production
+  account credentials were used for the cloud round-trip test.
+- `npm run build` and the focused 67-test suite passed. The development server
+  was restarted after an existing watcher hit EBUSY on generated web-bootstrap
+  assets during a concurrent build; no runtime UI error was logged in the
+  subsequent playtest.
+
 ## 2026-08-18 GM Manastorm administration - COMPLETE
 
 - Server-authorized `Phenom` access, revisioned SQLite configuration, safe
@@ -1728,3 +1761,290 @@ Vite's existing large-chunk advisory remains informational.
   audit covered 12,347 compressed textures with zero fallbacks, and the
   environment-performance audit found no regressions. The existing large-chunk
   advisory and Rapier initialization deprecation warning remain informational.
+
+# 2026-09-08 — WoW dungeon production-functionality audit
+
+- Audited all 54 WoW five-player catalog entries against live runtime contracts,
+  pinned AzerothCore population/object drafts, and instance-script source. The
+  composed-runtime content audit is green for 1,193 mobs, 273 bosses, 4,026
+  attacks, 2,572 specials, and 1,275 native models, but the stricter production-
+  fidelity gate remains blocked at 0/54.
+- The audit found 3,943 source game-object spawns, including 2,321 actionable
+  doors, buttons, chests/resources, transports, traps, and related objects. Raw
+  database rows are no longer passed into the typed world-object renderer; all
+  54 live definitions now have zero malformed world-object records.
+- The follow-up implementation sweep completed source review for all 54
+  instances. Fifty-one now have runtime-wired instance orchestration and the three
+  genuinely empty stock instance scripts are pinned as source-exact no-ops;
+  there are no unreviewed instance scripts left. Wailing Caverns remains the
+  only entry with a reviewed off-mesh link, and the three Ascension-specific
+  dungeons still lack authoritative server population data.
+- Entered Wailing Caverns from the local browser roster as a Priest healer. The
+  3D environment, populated combat route, party, objective, minimap, and HUD all
+  loaded; the minimap strip showed one Power Word: Fortitude entry. No uncaught
+  client runtime errors appeared. Rapier's existing initialization deprecation
+  warning remained informational.
+- The local content manager exposed all 54 WoW entries but only Wailing Caverns
+  was installed; the other 53 were marked download required. Those dungeons were
+  therefore checked by source/runtime-contract audit in this pass, not claimed
+  as completed visual traversal playtests.
+- The follow-up world-object compiler converted all 3,943 source rows—including
+  all 2,321 actionable doors, chests/resources, switches, traps, and
+  transports—into stable typed definitions with transformed coordinates,
+  type-aware states, conservative dimensions, and source/template/spawn/type
+  provenance. Wailing Caverns receives its 57 generated records through the
+  authored-definition enrichment path as well.
+- Client `GameObjectDisplayInfo` metadata resolves a visual display ID for
+  3,905 records, a native model path for 3,837, and exact bounds for 3,547. The
+  generated export manifest deduplicates those instances into 458 native legacy
+  assets, records 38 intentional no-display spell-focus objects, and isolates
+  the remaining nine missing-model display IDs and 68 no-bounds display IDs for
+  review.
+- An initial live pass exposed colored procedural markers for adapted
+  chests/resources. Unreviewed source objects are now deliberately hidden,
+  non-blocking, and non-interactive so incomplete door scripts cannot soft-lock
+  a dungeon and placeholder art cannot leak into normal play. A second live
+  Wailing Caverns pass confirmed the clean 3D scene, party combat, HUD, minimap,
+  and single Fortitude entry. No uncaught client errors appeared; duplicate
+  KTX2-loader warnings occurred only across deliberate hot-reload cycles.
+- The final runtime audit reports 54/54 reviewed dungeons. Fifty-one dungeons use
+  52 rule-bearing instance-controller definitions (Blackrock Spire has separate
+  lower- and upper-spire controllers), while three use verified source-exact
+  no-op scripts. Every catalog objective has a completion action, and the audit
+  found zero malformed-object, duplicate-id, or encounter-contract issues. All
+  51 rule-bearing dungeons retain explicit adaptation/gap notes; native object
+  models and full-route live traversal are not claimed complete.
+- The source-combat follow-up gives every runtime-spawnable boss a sourced kit
+  unless the pinned source really is melee-only. The six deliberate exceptions
+  are Kresh, Deviate Faerie Dragon, Spirestone Battle Lord, Spirestone Butcher,
+  Crystal Fang, and Grubbis. Crystal Fang retains its source-exact 15% rare-spawn
+  behavior and death summon. Trial of the Champion, Utgarde Keep, Hellfire
+  Ramparts, Sethekk Halls, Mana-Tombs, and Slave Pens event bosses now use their
+  pinned spell IDs and timing windows; unsupported vehicle, proc, queue, shared-
+  health, phase, stack, and healing-reduction semantics are explicitly recorded
+  as adaptations instead of being silently invented.
+- Wipe/reset validation exhaustively covered 673,664 reachable encounter states,
+  180 reset paths, every one of the 68 non-initial reset targets, and all 135
+  entity-timeout rules. Durable progression now fails closed on a missing entity,
+  legacy snapshots with unordered action history fail closed, and Frozen Reach's
+  Arktos is attempt-scoped so a wipe respawns him and can still advance the duo
+  encounter on the next pull. The two viable post-reset resume states in Scarlet
+  Cathedral and Halls of Stone are intentional, not soft locks.
+- Same-process checkpoint restore and online follower hydration now accept their
+  trusted save/leader snapshots even when a retained local provider has a newer
+  reset revision; ordinary stale imports remain rejected. A renderer restart
+  preserves the current encounter snapshot. Encounter effects use one delivery
+  path at a time, and obsolete headless queues are cleared on reset or dungeon
+  switch instead of retaining already-applied envelopes for the process lifetime.
+- The generated download topology now contains an installable logical pack for
+  every one of the 54 campaign dungeons. The three custom dungeons without their
+  own creature payload are represented by dependency-only packs, while every
+  non-bundled dungeon pulls its exact environment and shared-creature closure.
+  The existing live content feed was not deployed or mutated during this pass;
+  browser traversal therefore still reflects the packs already available there.
+- Installed packs now persist v2 verification receipts containing their exact
+  file set, byte counts, hashes, and dependencies. Browser-cache and native-file
+  presence are revalidated before entry, production dungeon entry fails closed
+  when a pack or dependency is missing or stale, and `content:publish` validates
+  the complete 54-dungeon dependency graph before any release output is written.
+- Run completion now leaves the final room active so loot can be collected before
+  the player explicitly exits and clears the checkpoint. A wipe returns the party
+  to the saved run spawn while preserving already-cleared bosses and durable run
+  progress; attempt-scoped actors and effects reset for the next pull.
+- The live Priest check used the saved `Rolecheck` character, which advanced from
+  level 11 to level 12 during the dungeon passes. The latest Wailing Caverns run
+  displayed 677/677 health, one Power Word: Fortitude alongside Arcane Intellect
+  (and Holy Concentration while active), and one Frostbolt plus one Icy Touch
+  debuff. Repeated Frostbolt applications refreshed that one entry from 7.1 to
+  21 seconds rather than duplicating it. The deterministic geared level-8 check
+  produced 3,285 mana and increased health from 407 to 437 when Fortitude was
+  applied.
+- Verification remains deliberately split: source coverage, runtime contracts,
+  reset reachability, and automated behavior are green, while the combined
+  production-fidelity audit remains 0/54. Its remaining blockers include native
+  object export/collision, explicitly listed source-semantic gaps, and end-to-end
+  traversal evidence for every production pack—not unfinished instance-script
+  review.
+- Final release verification passed all 1,109 Vitest cases across 202 files,
+  TypeScript project compilation, and the production build with 967 modules
+  transformed. The build staged 5,587 browser-bootstrap files, validated all
+  eight arenas, audited 12,347 compressed textures with zero fallbacks, and found
+  no environment-performance regressions. The release-candidate check accepted
+  all 118 changed paths. The existing large-chunk advisory and Rapier
+  initialization deprecation warning remain informational.
+
+# 2026-09-09 — fixed per-rank classic mana costs
+
+- Imported WoW mana percentages are now converted into fixed costs at each
+  spell rank's source level. Player level, Intellect, equipment, and maximum-mana
+  modifiers no longer increase the cost of an already learned rank; legitimate
+  talent and aura cost reductions are still applied afterward.
+- Shadow Word: Pain rank 4 now costs 133 mana at every level from 26 through 33,
+  including level 32. Learning rank 5 at level 34 raises the cost to 188 mana.
+- AI companions now use real character-scale mana pools so fixed spell costs do
+  not prevent healing or resurrection. The companion display also resolves the
+  active spell rank and the same final affordability result as the primary HUD.
+- Verification passed all 1,133 Vitest cases across 208 files. The production
+  build completed with 974 modules transformed; arena, KTX2, and environment-
+  performance audits remained green, and the release-candidate check passed.
+
+# 2026-09-09 — dungeon wall and nameplate performance regressions
+
+- The 0.1.24 material fallback honored BLEND tags on legacy WoW WMO walls,
+  floors, and ceilings, disabling their depth writes. WoW environments now use
+  their authored material roles again; RuneWaker environments retain their
+  source MASK/BLEND semantics. Shipped Wailing Caverns wall materials, vines,
+  and water are covered by regression tests.
+- The 0.1.25 boss-name occlusion scanned the complete rendered scene with
+  Three.js raycasts. A live Kalin's Shrine CPU profile was dominated by triangle
+  intersection and vertex decoding. Boss names and nearby NPC prompts now use
+  bounded camera-to-label queries against Rapier's existing physical spatial
+  index, at most ten times per second, skipping offscreen labels. Walls, floors,
+  and ceilings occlude labels; actors and trigger sensors do not.
+- In an isolated offline Edge playtest at 1440 x 900 on an AMD RX 9070 XT,
+  Kalin's Shrine improved from about 10 FPS (98.5 ms/frame, 167 draw calls,
+  DPR 1.125) to 55.5-56.1 FPS (17.8-18.0 ms/frame, 168-170 draw calls,
+  DPR 1.5). This is a representative entrance/combat comparison, not an audit
+  of all thirty RoM dungeons. The environment alone took about 0.8 ms CPU and
+  0.5 ms GPU with 14 draw calls.
+- Wailing Caverns screenshots show continuous opaque cavern walls and ceilings.
+  A controlled toggle of the old material flags reproduced the missing wall
+  sections at the same camera position; restoring depth-writing materials fixed
+  them. Its full scene ran at about 57 FPS. No uncaught client errors appeared.
+- Evidence and repeatable local benchmark helpers are under
+  `playtest-artifacts/2026-09-09-dungeon-rendering/`: `kalin-before.cpuprofile`,
+  `kalin-after.cpuprofile`, `kalin-after-metrics.json`, `kalin-before.png`,
+  `kalin-after.png`, `wailing-regression.png`, and `wailing-restored.png`.
+- All 26 focused material, label occlusion, combat sight, aggro visibility,
+  instancing, and NPC-prompt tests passed. Physical-occlusion tests exercise
+  actual Rapier worlds rather than just source-code assertions.
+
+# 2026-09-09 — campaign rendering audit and Thor performance preparation
+
+- Audited the actual visual GLB headers for all 54 WoW campaign dungeons:
+  9,402 materials, including 3,586 legacy BLEND materials restored to opaque
+  rendering by the shared policy. Every WoW package contained affected
+  materials. A permanent shipped-asset test covers all 54 definitions and
+  retains explicit cutout, blend, and additive roles. This is material-policy
+  coverage, not a claim that every room has been visually traversed.
+- Live screenshots checked Wailing Caverns, Shadowfang Keep, Utgarde Pinnacle,
+  the Nexus, and Tinkertech Showdown. The sampled walls, floors, stairs, and
+  ceilings remain solid; authored lighting effects remain transparent. Kalin's
+  Shrine and Forsaken Abbey provided RoM rendering checks. Roster and in-dungeon
+  screenshots show character bodies and equipped weapon silhouettes after the
+  shared character animation change.
+- A controlled Utgarde Pinnacle entrance test found about 1,739 draw calls,
+  1.95 million triangles, and 30.5 FPS on the desktop GPU. Clipping at the
+  existing full-fog distance reduced this to about 209 calls, 567,000 triangles,
+  and 60 FPS at the same viewpoint. The camera now follows each dungeon's fog
+  distance, including transitions that retain the existing Canvas/camera.
+  The background uses the fog color to avoid a clipping seam at the horizon.
+  All 84 dungeon definitions have render-distance coverage.
+- Static dungeon visual transforms are cached until the root or its parent's
+  world transform changes. Tests verify imported matrices, repeated unchanged
+  frames, root movement, and parent movement. Characters, moving world objects,
+  and physics remain outside this immutable visual cache.
+  The final 63-second Utgarde sample held 60 FPS with 213 draw calls:
+  main-thread work averaged 9.2 ms/frame, renderer CPU averaged 7.5 ms
+  (p95 8.3 ms), and GPU averaged 2.7 ms (p95 4.1 ms). Movement and jump input
+  continued to animate the player while the environment remained stationary.
+- Character locomotion and jump clip selections are cached by animation
+  library and weapon stance. The final Kalin CPU profile contains no sampled
+  per-frame base-clip selection/name parsing. Frame-cap deadlines now tolerate
+  sub-millisecond timestamp rounding without drifting or emitting catch-up
+  frames; tests cover 60 FPS on rounded 60 Hz and 120 Hz callbacks.
+- A 31.5-second Kalin sample with a connected browser companion display held
+  60 FPS: main-thread work averaged 8.7 ms/frame, renderer CPU averaged 5.4 ms
+  (p95 5.9 ms), and GPU averaged 2.4 ms (p95 3.4 ms). The companion used about
+  5.1 ms of main-thread time per second. Recent ability-cost snapshot work was
+  not a dominant hotspot in this sample. Startup warmup is bounded to loading;
+  companion snapshots are already limited to ten per second during gameplay.
+- These are isolated offline Edge desktop samples on an AMD RX 9070 XT at
+  1920 x 1080 CSS pixels, DPR 1.5 (2880 x 1620 renderbuffer). Party composition
+  can change between dungeon entries. They do not certify Android performance
+  or sustained busy-combat headroom. ADB listed no connected Android device.
+- Thor acceptance should use the actual model, both native displays, target
+  resolution, and a sustained 20-minute traversal/combat run after warmup.
+  Provisional headroom target: p95 main-thread and GPU work each at or below
+  12 ms, with p99 presented frame intervals within the 16.7 ms 60-FPS budget.
+  Test large pulls, boss effects, menus, and repeated dungeon transitions;
+  record thermal behavior and frame-time spikes, not only average FPS.
+  The environment asset audit still has 60 grandfathered budget exceptions;
+  its green result means no new asset regression, not a Thor FPS guarantee.
+- Evidence is in `playtest-artifacts/2026-09-09-thor-audit/`, including roster,
+  dungeon, and companion screenshots, CPU profiles, and CPU/GPU JSON samples.
+  The full material report is
+  `playtest-artifacts/2026-09-09-dungeon-rendering/wow-material-audit.json`.
+- Validation passed 227 focused tests covering avatar rendering and animation,
+  camera distances, material policies, frame pacing, static transforms, label
+  visibility, and companion snapshots. The final static-cache change also
+  passed the 105-test scene subset. The production build and release-candidate
+  check passed; the existing large-bundle advisory remains.
+
+# 2026-09-09 — additional CPU headroom from culling and shared skeletons
+
+- Prepared dungeon visuals now group static siblings into conservative spatial
+  bounds. One scene hook checks these bounds after the current camera and world
+  matrices update, before Three.js traverses individual meshes. Bounds include
+  complete wall geometry and all instances; lights, animated meshes, and meshes
+  explicitly disabling frustum culling remain outside these groups. The hook
+  supports streamed chunks and restores its predecessor after cleanup.
+- At the same Utgarde Pinnacle entrance, only 16 of 1,383 spatial groups were
+  visible. The renderer examined 108 static meshes instead of 7,002, retaining
+  the same 206 draw calls and 566,913 rendered triangles. Controlled culling
+  toggles produced byte-identical canvas PNGs across eight camera headings.
+- In the same running scene, spatial grouping reduced average main-thread work
+  from 9.45 to 6.83 ms/frame, and renderer CPU from 7.81 to 5.31 ms/frame.
+  Removing containers emptied by static instancing reduced the final fresh-run
+  averages further to 6.49 ms main-thread and 4.85 ms renderer CPU (p95 5.2 ms).
+  The final sample lasted 87.8 seconds and held 60 FPS. Authored empty scene
+  nodes are preserved; only containers emptied by our batching are removed.
+- The shared character renderer still uses SkeletonUtils.clone, then reuses
+  equivalent skeleton palettes within that owned clone. Bone identities, order,
+  and inverse bind matrices must all match; per-mesh bind transforms remain
+  unchanged. Different characters retain independent bones and animations.
+  Owned bone textures are now explicitly disposed during character teardown.
+- A live character audit found 66 skeleton objects for one player palette and
+  256 objects for four party palettes. A Wailing Caverns toggle removed 309
+  duplicate skeletons and produced an identical rendered image. Tests verify
+  posed vertices, differing bind transforms, incompatible palettes, independent
+  cloned characters, and redundant texture disposal.
+  In the same Wailing scene, main-thread work fell from 7.40 to 6.70 ms/frame;
+  renderer CPU fell from 5.51 to 4.86 ms/frame, and allocated GPU textures fell
+  from 292 to 217. This measures palette sharing after spatial culling was
+  already enabled. Both samples held 60 FPS.
+- The final built runtime showed a complete roster body and staff with one
+  skeleton for 66 skinned meshes. Kalin's Shrine showed one player palette and
+  four independent party palettes; walking retained the player body and weapon
+  silhouette. Wailing Caverns and Utgarde screenshots retained solid dungeon
+  surfaces. There were no uncaught client errors during these playtests.
+- All 210 targeted avatar, visibility, instancing, material, camera-distance,
+  and label tests passed. The production build and release-candidate check
+  passed. The existing large-bundle advisory remains.
+- Evidence is under `playtest-artifacts/2026-09-09-static-culling/`: paired PNGs,
+  eight-heading pixel comparisons, profiles, before/after timing JSON, and
+  screenshots. Measurements use the same desktop Edge/RX 9070 XT setup as the
+  preceding audit. These CPU improvements do not certify Thor performance.
+
+# 2026-09-09 — bundled arena assets blocked by the browser content worker
+
+- Reproduced the reported collision-matched fallback in the production build
+  with the content worker active. Warnorken's `visual.glb?arena-runtime=1`
+  returned 404 even though the file was bundled and directly served with 200.
+  The worker omitted `/assets/game/arenas/` from its bundled asset prefixes and
+  incorrectly rejected these files as uninstalled optional content.
+- Added the arena prefix to the worker. Installed updates still take priority;
+  missing optional dungeon content still returns 404. Behavioral worker tests
+  failed for all eight arenas before the fix and now cover visual, collision,
+  and navigation requests with the runtime query parameter.
+- The production build passed. Reloading the same browser session activated
+  the fixed worker without clearing storage or downloading content. Warnorken
+  rendered textured stone geometry and Nagrand rendered its authored arena
+  geometry; neither showed the loading/fallback banner after loading, and no
+  new console errors were recorded. Checks used offline practice in the Codex
+  browser at `http://127.0.0.1:4174/`, backed by a local test server on port 4173.
+- All 22 content tests and the eight-arena asset validator passed. Screenshots,
+  before/after error logs, asset validation, and build output are saved under
+  `playtest-artifacts/2026-09-09-arena-loading/`. The existing large-bundle
+  advisory remains. This verifies the local browser build, not a deployment
+  or an Android package.

RELEASE_RUNBOOK.md

@@ -237,10 +237,15 @@ Gitea tag after the signed APK builds successfully.
 npm run content:test
 npm run server:test
 npm test
+npm run content:publish
 npm run build
 ```
 
-All four commands must succeed.
+All five commands must succeed. `content:publish` is a fail-closed release gate:
+it validates that the generated manifest contains all 54 WoW campaign dungeon
+packs, their exact dependency closure, and every catalog-referenced asset before
+it writes the ignored local `content/` output. Do not build or stage a release
+if that validation fails.
 
 Apply these additional targeted checks whenever the matching area was edited:
 
@@ -540,6 +545,7 @@ Do **not** bump the Android version. Run these exact PowerShell commands:
 ```powershell
 Set-Location F:\Projects\HealerMan
 npm run content:test
+npm run content:publish
 npm run build
 git status --short
 npm run release:check

dungeon-pipeline/FIVE_PLAYER_IMPORT_TODO.md

@@ -1,8 +1,17 @@
 # Five-player dungeon import checklist
 
-Each dungeon is complete only when its actual instance environment, collision,
+This checklist tracks the native asset and population import, not complete
+instance gameplay. A checked dungeon has its environment, collision,
 navigation, AzerothCore population, boss roster, and native animated creature
-models are packaged under `public/assets/game/dungeons/<slug>/`.
+models packaged under `public/assets/game/dungeons/<slug>/`. Use
+`WOW_DUNGEON_FUNCTIONALITY_REPORT.md` for the separate production-fidelity gate
+covering doors, objects, scripted progression, waves, escorts, vehicles,
+traversal, resets, checkpoints, and completion playtests.
+
+Instance-source review status (2026-09-08): 54/54 reviewed, 51/54 backed by an
+executable instance controller, and 3/54 pinned as source-exact no-op instance
+scripts. These counts describe implemented runtime coverage; they do not close
+the native game-object export or end-to-end playtest gates.
 
 Run one dungeon at a time:
 
@@ -88,24 +97,28 @@ TypeScript/production bundle checks passed.
 
 ## Ascension-specific five-player instances
 
-- [ ] Tinkertech Showdown (`821`) - blocked on authoritative Ascension server
-  population/model data. Encounter identity exists for Mechatron (`663012`),
-  but no creature template, display mapping, or spawn rows exist locally.
-- [ ] Frozen Reach (`908`) - blocked on authoritative Ascension server
-  population/model data. Encounter identity exists for Alva (`97700`), but no
-  creature template, display mapping, or spawn rows exist locally.
-- [ ] Forgotten Mine (`1781`) - blocked on authoritative Ascension server
-  population/model data. Encounter identity exists for Geolord Vek (`254272`),
-  but no creature template, display mapping, or spawn rows exist locally.
+- [ ] Tinkertech Showdown (`821`) - playable HealerMan-authored adaptation.
+  Mechatron (`663012`) and the environment are exact; the candidate machine
+  spell cluster, trash, cadence, positions, models, and phase rules remain
+  explicitly authored because no server binding or spawn snapshot survived.
+- [ ] Frozen Reach (`908`) - playable source-backed adaptation. Alva (`97700`),
+  Arktos (`97701`), 85 exact spell rows, and summon links for entries `97703`,
+  `97731`, and `97770` were recovered. Server cadence, positions, stats,
+  models, targeting, and exact phase behavior remain authored.
+- [ ] Forgotten Mine (`1781`) - playable source-backed adaptation. Geolord Vek
+  (`254272`), 33 exact spell rows, Geospike (`254278`), and Resonite Shard
+  (`254051`) were recovered. Server cadence, positions, trash, models, and the
+  exact crystal rule remain authored.
 
-The individual command has been run for all three blocked instances. Their maps
-and encounter identities are present in the installed client, but the installed
-client and available creature caches do not provide the server-only
-entry-to-display and spawn data needed to package their actual mobs/bosses.
-They intentionally remain on the documented procedural fallback until an
-Ascension server snapshot or reviewed creature/spawn export is supplied.
+The individual import command has been run for all three source-limited
+instances. Their checksummed recovery manifest lives under `ascension/` and is
+validated by `npm run dungeon:ascension:recovery:validate`. Runtime adapters
+consume the recovered evidence while retaining explicit `source-backed-adapted`
+or `healer-man-authored` labels. The checklist remains open until an
+authoritative Ascension creature/spawn/object/server-script snapshot and native
+display mappings replace the remaining authored portions.
 
-## Per-dungeon completion gate
+## Per-dungeon asset/import gate
 
 These gates passed for every checked dungeon above:
 
@@ -116,3 +129,7 @@ These gates passed for every checked dungeon above:
 - [x] Boss order, entrance, and coordinates reviewed.
 - [x] Generated campaign catalog points at `/assets/game/dungeons/<slug>/`.
 - [x] Catalog verification, tests, type-check, and production bundle pass.
+
+These checks do not certify instance-script behavior. A dungeon remains
+functionally incomplete until its entry in `WOW_DUNGEON_FUNCTIONALITY_REPORT.md`
+is green.

dungeon-pipeline/README.md

@@ -92,8 +92,10 @@ whose preserved source has no recoverable combat ability is explicitly marked
 
 Stock AzerothCore population is used for the standard dungeons. The three
 Ascension-specific instances—Tinkertech Showdown, Frozen Reach, and Forgotten
-Mine—keep their client encounter identities and use an explicit procedural
-trash-population fallback. Non-Epoch recipes keep explicit procedural actor
+Mine—keep their recovered client identities, spell/summon evidence where
+available, and explicit source-backed or HealerMan-authored runtime adaptations.
+Their remaining procedural population is never labeled authoritative.
+Non-Epoch recipes keep explicit procedural actor
 bodies until reviewed display exports are available. Epoch actors use packaged
 client GLBs with their complete native animation libraries; only event-only
 controllers without a creature display fall back.
@@ -160,10 +162,13 @@ The audit verifies the complete 54-dungeon catalog, authoritative/fallback
 classification, every native environment and creature URL, file sizes,
 checksums, animation presence, and compiled entry-to-model bindings. The
 2026-07-26 batch packaged 50 native imports; together with the Wailing Caverns
-golden fixture, 51/54 dungeons are authoritative. Tinkertech Showdown, Frozen
-Reach, and Forgotten Mine remain documented fallbacks because available local
-sources contain their maps and encounter identities but no authoritative
-Ascension creature templates, display mappings, or spawn rows.
+golden fixture, 51/54 dungeons have authoritative WoW population packages.
+Tinkertech Showdown, Frozen Reach, and Forgotten Mine now have playable,
+provenance-labeled runtime adaptations backed by
+`ascension/ASCENSION_CUSTOM_DUNGEON_RECOVERY.json`. They remain outside the
+authoritative package count because the recovered client evidence does not
+include complete Ascension creature templates, display mappings, spawn/object
+coordinates, or server-side cadence.
 
 1. `npm run dungeon:discover -- <slug>` writes deterministic client/server
    snapshots, a provenance lock, review-required overrides, and—when server
@@ -224,9 +229,14 @@ The default pass recompiles the 54-dungeon campaign, verifies all packaged
 environment and creature assets, audits every mob and boss attack/mechanic,
 opens every unique native creature GLB to verify idle, movement, attack, wound,
 and death clips, proves the procedural animation path for model-less actors,
-and runs the actual runtime-registry coverage test. It writes deterministic
-JSON and Markdown reports to WOW_DUNGEON_CONTENT_REPORT.json and
-WOW_DUNGEON_CONTENT_REPORT.md.
+runs the actual runtime-registry coverage test, and audits instance-level
+functionality. It writes deterministic JSON and Markdown reports to
+WOW_DUNGEON_CONTENT_REPORT.json, WOW_DUNGEON_CONTENT_REPORT.md,
+WOW_DUNGEON_FUNCTIONALITY_REPORT.json, and
+WOW_DUNGEON_FUNCTIONALITY_REPORT.md. Catalog compilation also writes
+WOW_GAMEOBJECT_ASSET_MANIFEST.json, which deduplicates the source-backed object
+spawns by client model path, preserves per-dungeon/display usage, assigns the
+planned shipping GLB URL, and lists unresolved display models and bounds.
 
 Useful batch options:
 
@@ -239,11 +249,40 @@ Useful batch options:
     # Re-run green packages, then build the app after validation.
     npm run dungeon:wow:all -- --refresh --force --build
 
-    # Only re-run combat, mechanic, and animation coverage against current output.
+    # Re-run combat, animation, and instance-functionality audits against current output.
     npm run dungeon:wow:all -- --audit-only
 
-Kresh is intentionally recorded as a source-faithful melee-only boss: entry
-3653 has no spell or SmartAI row in the pinned AzerothCore snapshot. Trial of
-the Champion is likewise documented as a boss-arena population rather than a
-trash route. These exceptions are asserted by exact dungeon/entity IDs; any
-new basic-only boss or mob-less dungeon fails the batch.
+The functionality report is the production-fidelity gate. It separately checks
+typed world-object contracts, source instance scripts, encounter orchestration,
+required interactions, traversal evidence, resets, checkpoints, and completion
+playtests. A green asset or combat audit does not imply that doors, escorts,
+waves, vehicles, keys, chests, or scripted instance progression are implemented.
+The report fails closed and lists concrete edit targets for every remaining
+dungeon gap.
+
+The 2026-09-08 implementation sweep completed an instance-level source review
+for all 54 campaign dungeons. Fifty-one now have runtime-wired reviewed
+orchestration in addition to fleet boss/checkpoint/completion declarations; the
+three stock instance scripts that are genuinely empty are pinned and recorded
+as source-exact no-ops. This means there is no remaining unreviewed instance
+script, not that every source feature is already exact or live-traversal validated. Per-dungeon adaptations,
+missing primitives, native-object export work, and live traversal evidence stay
+open in `WOW_DUNGEON_FUNCTIONALITY_REPORT.md`.
+
+Source-backed object records stay hidden, non-blocking, and non-interactive
+until their manifest asset has been exported and the corresponding instance
+script transition has been reviewed. This lets the typed data ship through the
+runtime contract without leaking placeholder geometry or turning an incomplete
+door/transport port into a dungeon soft lock.
+
+Kresh, the Deviate Faerie Dragon, Grubbis, Spirestone Battle Lord, Spirestone
+Butcher, and Crystal Fang are intentionally recorded as source-faithful
+melee-only bosses. Kresh entry 3653 and the Deviate Faerie Dragon entry 5912
+have no spell or SmartAI row in the pinned AzerothCore snapshot; the latter is
+also despawned by the Wailing Caverns initialization event. Grubbis entry 7361
+has only aggro dialogue and death-completion rows, with no combat spell cast.
+The three Blackrock Spire entries are 15% rare spawns whose database rows
+contain no active combat cast; Crystal Fang's exact on-death Spire Spiderling
+summon is implemented by the reviewed instance adapter. One shared exception
+table supplies the runtime test and composed-content audit; stale, duplicate,
+or newly introduced basic-only boss keys fail the batch.

dungeon-pipeline/WOW_DUNGEON_CONTENT_REPORT.json

@@ -4,19 +4,19 @@
   "scope": "HealerMan WoW five-player combat and animation coverage",
   "summary": {
     "dungeons": 54,
-    "mobs": 1031,
-    "bosses": 253,
-    "attacks": 3765,
-    "specialAttacks": 2481,
-    "nativeModels": 1266,
-    "proceduralModels": 18,
-    "uniqueNativeModels": 1166,
+    "mobs": 1193,
+    "bosses": 273,
+    "attacks": 4026,
+    "specialAttacks": 2572,
+    "nativeModels": 1275,
+    "proceduralModels": 191,
+    "uniqueNativeModels": 1167,
     "nativeStateFallbacks": 18
   },
   "documentedExceptions": [
     {
       "type": "basic-only-boss",
-      "key": "wailing-caverns:entry-3653",
+      "key": "wailing-caverns:kresh",
       "reason": "Kresh is melee-only in the pinned AzerothCore snapshot; the historical server has no spell or SmartAI row for entry 3653."
     },
     {
@@ -25,9 +25,24 @@
       "reason": "The server-faithful rare entry 5912 has no spell rows and is despawned by the Wailing Caverns initialization event."
     },
     {
-      "type": "no-trash-instance",
-      "key": "trial-of-the-champion",
-      "reason": "Trial of the Champion is an encounter arena; its imported combat population is the five Grand Champion bosses, not a trash route."
+      "type": "basic-only-boss",
+      "key": "gnomeregan:wow-classic-batch-three-entry-7361",
+      "reason": "Grubbis is melee-only in the pinned AzerothCore snapshot; entry 7361 has aggro dialogue and instance-completion rows but no combat spell cast."
+    },
+    {
+      "type": "basic-only-boss",
+      "key": "blackrock-spire:entry-9218",
+      "reason": "Spirestone Battle Lord is a 15% rare spawn in the pinned database and has no combat spell cast beyond its basic melee attack."
+    },
+    {
+      "type": "basic-only-boss",
+      "key": "blackrock-spire:entry-9219",
+      "reason": "Spirestone Butcher is a 15% rare spawn in the pinned database and has no combat spell cast beyond its basic melee attack."
+    },
+    {
+      "type": "basic-only-boss",
+      "key": "blackrock-spire:entry-10376",
+      "reason": "Crystal Fang is a 15% rare spawn with no active combat spell in the pinned database; its exact on-death Spire Spiderling summon is implemented by the instance adapter."
     }
   ],
   "animationFallbacks": [
@@ -180,6 +195,18 @@
   ],
   "issues": [],
   "dungeons": [
+    {
+      "id": "wailing-caverns",
+      "title": "Wailing Caverns",
+      "source": "azerothcore",
+      "mobs": 23,
+      "bosses": 9,
+      "attacks": 72,
+      "specialAttacks": 40,
+      "nativeModels": 24,
+      "proceduralModels": 8,
+      "status": "green"
+    },
     {
       "id": "shadowfang-keep",
       "title": "Shadowfang Keep",
@@ -216,18 +243,6 @@
       "proceduralModels": 0,
       "status": "green"
     },
-    {
-      "id": "wailing-caverns",
-      "title": "Wailing Caverns",
-      "source": "azerothcore",
-      "mobs": 12,
-      "bosses": 8,
-      "attacks": 51,
-      "specialAttacks": 31,
-      "nativeModels": 15,
-      "proceduralModels": 5,
-      "status": "green"
-    },
     {
       "id": "razorfen-kraul",
       "title": "Razorfen Kraul",
@@ -244,12 +259,12 @@
       "id": "blackfathom-deeps",
       "title": "Blackfathom Deeps",
       "source": "azerothcore",
-      "mobs": 21,
+      "mobs": 23,
       "bosses": 6,
-      "attacks": 65,
+      "attacks": 67,
       "specialAttacks": 38,
       "nativeModels": 27,
-      "proceduralModels": 0,
+      "proceduralModels": 2,
       "status": "green"
     },
     {
@@ -268,36 +283,36 @@
       "id": "gnomeregan",
       "title": "Gnomeregan",
       "source": "azerothcore",
-      "mobs": 27,
-      "bosses": 4,
-      "attacks": 82,
+      "mobs": 28,
+      "bosses": 5,
+      "attacks": 84,
       "specialAttacks": 51,
       "nativeModels": 31,
-      "proceduralModels": 0,
+      "proceduralModels": 2,
       "status": "green"
     },
     {
       "id": "sunken-temple",
       "title": "Sunken Temple",
       "source": "azerothcore",
-      "mobs": 29,
+      "mobs": 31,
       "bosses": 4,
-      "attacks": 93,
+      "attacks": 95,
       "specialAttacks": 60,
       "nativeModels": 33,
-      "proceduralModels": 0,
+      "proceduralModels": 2,
       "status": "green"
     },
     {
       "id": "razorfen-downs",
       "title": "Razorfen Downs",
       "source": "azerothcore",
-      "mobs": 19,
+      "mobs": 21,
       "bosses": 6,
-      "attacks": 63,
+      "attacks": 65,
       "specialAttacks": 38,
       "nativeModels": 25,
-      "proceduralModels": 0,
+      "proceduralModels": 2,
       "status": "green"
     },
     {
@@ -316,60 +331,60 @@
       "id": "zulfarrak",
       "title": "Zul'Farrak",
       "source": "azerothcore",
-      "mobs": 16,
+      "mobs": 23,
       "bosses": 5,
-      "attacks": 69,
+      "attacks": 76,
       "specialAttacks": 48,
       "nativeModels": 21,
-      "proceduralModels": 0,
+      "proceduralModels": 7,
       "status": "green"
     },
     {
       "id": "blackrock-spire",
       "title": "Blackrock Spire",
       "source": "azerothcore",
-      "mobs": 63,
-      "bosses": 15,
-      "attacks": 273,
-      "specialAttacks": 195,
+      "mobs": 66,
+      "bosses": 17,
+      "attacks": 285,
+      "specialAttacks": 202,
       "nativeModels": 78,
-      "proceduralModels": 0,
+      "proceduralModels": 5,
       "status": "green"
     },
     {
       "id": "blackrock-depths",
       "title": "Blackrock Depths",
       "source": "azerothcore",
-      "mobs": 48,
+      "mobs": 58,
       "bosses": 13,
-      "attacks": 182,
+      "attacks": 192,
       "specialAttacks": 121,
       "nativeModels": 61,
-      "proceduralModels": 0,
+      "proceduralModels": 10,
       "status": "green"
     },
     {
       "id": "scholomance",
       "title": "Scholomance",
       "source": "azerothcore",
-      "mobs": 30,
+      "mobs": 31,
       "bosses": 8,
-      "attacks": 150,
+      "attacks": 151,
       "specialAttacks": 112,
       "nativeModels": 38,
-      "proceduralModels": 0,
+      "proceduralModels": 1,
       "status": "green"
     },
     {
       "id": "stratholme",
       "title": "Stratholme",
       "source": "azerothcore",
-      "mobs": 41,
+      "mobs": 45,
       "bosses": 9,
-      "attacks": 176,
+      "attacks": 180,
       "specialAttacks": 126,
       "nativeModels": 50,
-      "proceduralModels": 0,
+      "proceduralModels": 4,
       "status": "green"
     },
     {
@@ -436,12 +451,12 @@
       "id": "hellfire-ramparts",
       "title": "Hellfire Citadel: Ramparts",
       "source": "azerothcore",
-      "mobs": 10,
-      "bosses": 2,
-      "attacks": 41,
-      "specialAttacks": 29,
+      "mobs": 11,
+      "bosses": 4,
+      "attacks": 47,
+      "specialAttacks": 32,
       "nativeModels": 12,
-      "proceduralModels": 0,
+      "proceduralModels": 3,
       "status": "green"
     },
     {
@@ -460,48 +475,48 @@
       "id": "underbog",
       "title": "Coilfang: The Underbog",
       "source": "azerothcore",
-      "mobs": 18,
+      "mobs": 20,
       "bosses": 4,
-      "attacks": 80,
+      "attacks": 82,
       "specialAttacks": 58,
       "nativeModels": 22,
-      "proceduralModels": 0,
+      "proceduralModels": 2,
       "status": "green"
     },
     {
       "id": "slave-pens",
       "title": "Coilfang: The Slave Pens",
       "source": "azerothcore",
-      "mobs": 18,
-      "bosses": 3,
-      "attacks": 60,
-      "specialAttacks": 39,
+      "mobs": 21,
+      "bosses": 4,
+      "attacks": 66,
+      "specialAttacks": 43,
       "nativeModels": 21,
-      "proceduralModels": 0,
+      "proceduralModels": 4,
       "status": "green"
     },
     {
       "id": "arcatraz",
       "title": "Tempest Keep: The Arcatraz",
       "source": "azerothcore",
-      "mobs": 25,
+      "mobs": 28,
       "bosses": 4,
-      "attacks": 105,
+      "attacks": 108,
       "specialAttacks": 76,
       "nativeModels": 29,
-      "proceduralModels": 0,
+      "proceduralModels": 3,
       "status": "green"
     },
     {
       "id": "botanica",
       "title": "Tempest Keep: The Botanica",
       "source": "azerothcore",
-      "mobs": 24,
+      "mobs": 28,
       "bosses": 5,
-      "attacks": 85,
+      "attacks": 89,
       "specialAttacks": 56,
       "nativeModels": 29,
-      "proceduralModels": 0,
+      "proceduralModels": 4,
       "status": "green"
     },
     {
@@ -532,72 +547,72 @@
       "id": "sethekk-halls",
       "title": "Auchindoun: Sethekk Halls",
       "source": "azerothcore",
-      "mobs": 14,
-      "bosses": 2,
-      "attacks": 50,
-      "specialAttacks": 34,
+      "mobs": 19,
+      "bosses": 3,
+      "attacks": 59,
+      "specialAttacks": 37,
       "nativeModels": 16,
-      "proceduralModels": 0,
+      "proceduralModels": 6,
       "status": "green"
     },
     {
       "id": "mana-tombs",
       "title": "Auchindoun: Mana-Tombs",
       "source": "azerothcore",
-      "mobs": 11,
-      "bosses": 3,
-      "attacks": 46,
-      "specialAttacks": 32,
+      "mobs": 12,
+      "bosses": 4,
+      "attacks": 50,
+      "specialAttacks": 34,
       "nativeModels": 14,
-      "proceduralModels": 0,
+      "proceduralModels": 2,
       "status": "green"
     },
     {
       "id": "auchenai-crypts",
       "title": "Auchindoun: Auchenai Crypts",
       "source": "azerothcore",
-      "mobs": 12,
-      "bosses": 2,
-      "attacks": 44,
-      "specialAttacks": 30,
+      "mobs": 13,
+      "bosses": 3,
+      "attacks": 48,
+      "specialAttacks": 32,
       "nativeModels": 14,
-      "proceduralModels": 0,
+      "proceduralModels": 2,
       "status": "green"
     },
     {
       "id": "magisters-terrace",
       "title": "Magister's Terrace",
       "source": "azerothcore",
-      "mobs": 15,
+      "mobs": 23,
       "bosses": 3,
-      "attacks": 57,
+      "attacks": 65,
       "specialAttacks": 39,
       "nativeModels": 18,
-      "proceduralModels": 0,
+      "proceduralModels": 8,
       "status": "green"
     },
     {
       "id": "black-morass",
       "title": "The Black Morass",
       "source": "azerothcore",
-      "mobs": 4,
+      "mobs": 13,
       "bosses": 3,
-      "attacks": 25,
+      "attacks": 34,
       "specialAttacks": 18,
       "nativeModels": 7,
-      "proceduralModels": 0,
+      "proceduralModels": 9,
       "status": "green"
     },
     {
       "id": "escape-from-durnholde",
       "title": "The Escape From Durnholde",
       "source": "azerothcore",
-      "mobs": 26,
+      "mobs": 32,
       "bosses": 3,
-      "attacks": 53,
+      "attacks": 59,
       "specialAttacks": 24,
       "nativeModels": 29,
-      "proceduralModels": 0,
+      "proceduralModels": 6,
       "status": "green"
     },
     {
@@ -605,107 +620,107 @@
       "title": "Utgarde Keep",
       "source": "azerothcore",
       "mobs": 19,
-      "bosses": 3,
-      "attacks": 44,
-      "specialAttacks": 22,
+      "bosses": 6,
+      "attacks": 55,
+      "specialAttacks": 30,
       "nativeModels": 22,
-      "proceduralModels": 0,
+      "proceduralModels": 3,
       "status": "green"
     },
     {
       "id": "utgarde-pinnacle",
       "title": "Utgarde Pinnacle",
       "source": "azerothcore",
-      "mobs": 13,
+      "mobs": 19,
       "bosses": 4,
-      "attacks": 44,
+      "attacks": 50,
       "specialAttacks": 27,
       "nativeModels": 17,
-      "proceduralModels": 0,
+      "proceduralModels": 6,
       "status": "green"
     },
     {
       "id": "the-nexus",
       "title": "The Nexus",
       "source": "azerothcore",
-      "mobs": 21,
+      "mobs": 24,
       "bosses": 5,
-      "attacks": 61,
+      "attacks": 64,
       "specialAttacks": 35,
       "nativeModels": 26,
-      "proceduralModels": 0,
+      "proceduralModels": 3,
       "status": "green"
     },
     {
       "id": "the-oculus",
       "title": "The Oculus",
       "source": "azerothcore",
-      "mobs": 8,
+      "mobs": 17,
       "bosses": 4,
-      "attacks": 33,
+      "attacks": 42,
       "specialAttacks": 21,
       "nativeModels": 12,
-      "proceduralModels": 0,
+      "proceduralModels": 9,
       "status": "green"
     },
     {
       "id": "culling-of-stratholme",
       "title": "The Culling of Stratholme",
       "source": "azerothcore",
-      "mobs": 16,
+      "mobs": 21,
       "bosses": 4,
-      "attacks": 44,
+      "attacks": 49,
       "specialAttacks": 24,
       "nativeModels": 20,
-      "proceduralModels": 0,
+      "proceduralModels": 5,
       "status": "green"
     },
     {
       "id": "halls-of-stone",
       "title": "Halls of Stone",
       "source": "azerothcore",
-      "mobs": 13,
+      "mobs": 16,
       "bosses": 4,
-      "attacks": 42,
+      "attacks": 45,
       "specialAttacks": 25,
       "nativeModels": 16,
-      "proceduralModels": 1,
+      "proceduralModels": 4,
       "status": "green"
     },
     {
       "id": "draktharon-keep",
       "title": "Drak'Tharon Keep",
       "source": "azerothcore",
-      "mobs": 18,
+      "mobs": 20,
       "bosses": 4,
-      "attacks": 45,
+      "attacks": 47,
       "specialAttacks": 23,
       "nativeModels": 22,
-      "proceduralModels": 0,
+      "proceduralModels": 2,
       "status": "green"
     },
     {
       "id": "azjol-nerub",
       "title": "Azjol-Nerub",
       "source": "azerothcore",
-      "mobs": 10,
+      "mobs": 18,
       "bosses": 3,
-      "attacks": 30,
+      "attacks": 38,
       "specialAttacks": 17,
       "nativeModels": 13,
-      "proceduralModels": 0,
+      "proceduralModels": 8,
       "status": "green"
     },
     {
       "id": "halls-of-lightning",
       "title": "Halls of Lightning",
       "source": "azerothcore",
-      "mobs": 16,
+      "mobs": 19,
       "bosses": 4,
-      "attacks": 49,
+      "attacks": 52,
       "specialAttacks": 29,
       "nativeModels": 20,
-      "proceduralModels": 0,
+      "proceduralModels": 3,
       "status": "green"
     },
     {
@@ -724,24 +739,24 @@
       "id": "violet-hold",
       "title": "Violet Hold",
       "source": "azerothcore",
-      "mobs": 2,
+      "mobs": 17,
       "bosses": 3,
-      "attacks": 24,
+      "attacks": 39,
       "specialAttacks": 19,
       "nativeModels": 5,
-      "proceduralModels": 0,
+      "proceduralModels": 15,
       "status": "green"
     },
     {
       "id": "ahnkahet-old-kingdom",
       "title": "Ahn'kahet: The Old Kingdom",
       "source": "azerothcore",
-      "mobs": 19,
+      "mobs": 23,
       "bosses": 5,
-      "attacks": 60,
+      "attacks": 64,
       "specialAttacks": 36,
       "nativeModels": 24,
-      "proceduralModels": 0,
+      "proceduralModels": 4,
       "status": "green"
     },
     {
@@ -760,36 +775,36 @@
       "id": "trial-of-the-champion",
       "title": "Trial of the Champion",
       "source": "azerothcore",
-      "mobs": 0,
-      "bosses": 5,
-      "attacks": 88,
-      "specialAttacks": 83,
+      "mobs": 6,
+      "bosses": 12,
+      "attacks": 123,
+      "specialAttacks": 105,
       "nativeModels": 5,
-      "proceduralModels": 0,
+      "proceduralModels": 13,
       "status": "green"
     },
     {
       "id": "pit-of-saron",
       "title": "Pit of Saron",
       "source": "azerothcore",
-      "mobs": 27,
+      "mobs": 31,
       "bosses": 3,
-      "attacks": 49,
+      "attacks": 53,
       "specialAttacks": 19,
       "nativeModels": 30,
-      "proceduralModels": 0,
+      "proceduralModels": 4,
       "status": "green"
     },
     {
       "id": "halls-of-reflection",
       "title": "Halls of Reflection",
       "source": "azerothcore",
-      "mobs": 8,
+      "mobs": 16,
       "bosses": 2,
-      "attacks": 38,
+      "attacks": 46,
       "specialAttacks": 28,
       "nativeModels": 10,
-      "proceduralModels": 0,
+      "proceduralModels": 8,
       "status": "green"
     },
     {
@@ -798,8 +813,8 @@
       "source": "procedural-fallback",
       "mobs": 3,
       "bosses": 1,
-      "attacks": 8,
-      "specialAttacks": 4,
+      "attacks": 13,
+      "specialAttacks": 12,
       "nativeModels": 0,
       "proceduralModels": 4,
       "status": "green"
@@ -808,24 +823,24 @@
       "id": "frozen-reach",
       "title": "Frozen Reach",
       "source": "procedural-fallback",
-      "mobs": 3,
+      "mobs": 2,
       "bosses": 1,
-      "attacks": 8,
-      "specialAttacks": 4,
+      "attacks": 19,
+      "specialAttacks": 19,
       "nativeModels": 0,
-      "proceduralModels": 4,
+      "proceduralModels": 3,
       "status": "green"
     },
     {
       "id": "forgotten-mine",
       "title": "Forgotten Mine",
       "source": "procedural-fallback",
-      "mobs": 3,
+      "mobs": 4,
       "bosses": 1,
-      "attacks": 8,
-      "specialAttacks": 4,
+      "attacks": 13,
+      "specialAttacks": 12,
       "nativeModels": 0,
-      "proceduralModels": 4,
+      "proceduralModels": 5,
       "status": "green"
     }
   ]

dungeon-pipeline/WOW_DUNGEON_CONTENT_REPORT.md

@@ -4,72 +4,75 @@ Status: **green**
 
 Scope: executable combat populations and creature animation bindings. This report does not certify instance scripts, doors, interactables, escorts, waves, vehicles, or navigation.
 
-Coverage: 54 dungeons, 1031 mobs, 253 bosses, 3765 executable attacks, and 2481 special attacks/mechanics.
+Coverage: 54 dungeons, 1193 mobs, 273 bosses, 4026 executable attacks, and 2572 special attacks/mechanics.
 
-Animation paths: 1266 native model bindings and 18 procedural bindings across 1166 unique native GLBs; 18 missing native states use the shared procedural fallback.
+Animation paths: 1275 native model bindings and 191 procedural bindings across 1167 unique native GLBs; 18 missing native states use the shared procedural fallback.
 
 | Dungeon | Mobs | Bosses | Attacks | Specials | Native | Procedural | Status |
 | --- | ---: | ---: | ---: | ---: | ---: | ---: | --- |
+| Wailing Caverns | 23 | 9 | 72 | 40 | 24 | 8 | green |
 | Shadowfang Keep | 24 | 7 | 65 | 34 | 31 | 0 | green |
 | Stormwind Stockade | 6 | 5 | 42 | 31 | 11 | 0 | green |
 | The Deadmines | 15 | 7 | 55 | 33 | 22 | 0 | green |
-| Wailing Caverns | 12 | 8 | 51 | 31 | 15 | 5 | green |
 | Razorfen Kraul | 31 | 7 | 87 | 49 | 38 | 0 | green |
-| Blackfathom Deeps | 21 | 6 | 65 | 38 | 27 | 0 | green |
+| Blackfathom Deeps | 23 | 6 | 67 | 38 | 27 | 2 | green |
 | Uldaman | 31 | 7 | 104 | 66 | 38 | 0 | green |
-| Gnomeregan | 27 | 4 | 82 | 51 | 31 | 0 | green |
-| Sunken Temple | 29 | 4 | 93 | 60 | 33 | 0 | green |
-| Razorfen Downs | 19 | 6 | 63 | 38 | 25 | 0 | green |
+| Gnomeregan | 28 | 5 | 84 | 51 | 31 | 2 | green |
+| Sunken Temple | 31 | 4 | 95 | 60 | 33 | 2 | green |
+| Razorfen Downs | 21 | 6 | 65 | 38 | 25 | 2 | green |
 | Scarlet Monastery | 32 | 5 | 107 | 70 | 37 | 0 | green |
-| Zul'Farrak | 16 | 5 | 69 | 48 | 21 | 0 | green |
-| Blackrock Spire | 63 | 15 | 273 | 195 | 78 | 0 | green |
-| Blackrock Depths | 48 | 13 | 182 | 121 | 61 | 0 | green |
-| Scholomance | 30 | 8 | 150 | 112 | 38 | 0 | green |
-| Stratholme | 41 | 9 | 176 | 126 | 50 | 0 | green |
+| Zul'Farrak | 23 | 5 | 76 | 48 | 21 | 7 | green |
+| Blackrock Spire | 66 | 17 | 285 | 202 | 78 | 5 | green |
+| Blackrock Depths | 58 | 13 | 192 | 121 | 61 | 10 | green |
+| Scholomance | 31 | 8 | 151 | 112 | 38 | 1 | green |
+| Stratholme | 45 | 9 | 180 | 126 | 50 | 4 | green |
 | Maraudon | 25 | 8 | 95 | 62 | 33 | 0 | green |
 | Ragefire Chasm | 7 | 4 | 23 | 12 | 11 | 0 | green |
 | Dire Maul | 63 | 12 | 242 | 167 | 75 | 0 | green |
 | Hellfire Citadel: The Shattered Halls | 29 | 3 | 92 | 60 | 32 | 0 | green |
 | Hellfire Citadel: The Blood Furnace | 14 | 3 | 53 | 36 | 17 | 0 | green |
-| Hellfire Citadel: Ramparts | 10 | 2 | 41 | 29 | 12 | 0 | green |
+| Hellfire Citadel: Ramparts | 11 | 4 | 47 | 32 | 12 | 3 | green |
 | Coilfang: The Steamvault | 14 | 3 | 63 | 46 | 17 | 0 | green |
-| Coilfang: The Underbog | 18 | 4 | 80 | 58 | 22 | 0 | green |
-| Coilfang: The Slave Pens | 18 | 3 | 60 | 39 | 21 | 0 | green |
-| Tempest Keep: The Arcatraz | 25 | 4 | 105 | 76 | 29 | 0 | green |
-| Tempest Keep: The Botanica | 24 | 5 | 85 | 56 | 29 | 0 | green |
+| Coilfang: The Underbog | 20 | 4 | 82 | 58 | 22 | 2 | green |
+| Coilfang: The Slave Pens | 21 | 4 | 66 | 43 | 21 | 4 | green |
+| Tempest Keep: The Arcatraz | 28 | 4 | 108 | 76 | 29 | 3 | green |
+| Tempest Keep: The Botanica | 28 | 5 | 89 | 56 | 29 | 4 | green |
 | Tempest Keep: The Mechanar | 14 | 3 | 69 | 52 | 17 | 0 | green |
 | Auchindoun: Shadow Labyrinth | 18 | 4 | 67 | 45 | 22 | 0 | green |
-| Auchindoun: Sethekk Halls | 14 | 2 | 50 | 34 | 16 | 0 | green |
-| Auchindoun: Mana-Tombs | 11 | 3 | 46 | 32 | 14 | 0 | green |
-| Auchindoun: Auchenai Crypts | 12 | 2 | 44 | 30 | 14 | 0 | green |
-| Magister's Terrace | 15 | 3 | 57 | 39 | 18 | 0 | green |
-| The Black Morass | 4 | 3 | 25 | 18 | 7 | 0 | green |
-| The Escape From Durnholde | 26 | 3 | 53 | 24 | 29 | 0 | green |
-| Utgarde Keep | 19 | 3 | 44 | 22 | 22 | 0 | green |
-| Utgarde Pinnacle | 13 | 4 | 44 | 27 | 17 | 0 | green |
-| The Nexus | 21 | 5 | 61 | 35 | 26 | 0 | green |
-| The Oculus | 8 | 4 | 33 | 21 | 12 | 0 | green |
-| The Culling of Stratholme | 16 | 4 | 44 | 24 | 20 | 0 | green |
-| Halls of Stone | 13 | 4 | 42 | 25 | 16 | 1 | green |
-| Drak'Tharon Keep | 18 | 4 | 45 | 23 | 22 | 0 | green |
-| Azjol-Nerub | 10 | 3 | 30 | 17 | 13 | 0 | green |
-| Halls of Lightning | 16 | 4 | 49 | 29 | 20 | 0 | green |
+| Auchindoun: Sethekk Halls | 19 | 3 | 59 | 37 | 16 | 6 | green |
+| Auchindoun: Mana-Tombs | 12 | 4 | 50 | 34 | 14 | 2 | green |
+| Auchindoun: Auchenai Crypts | 13 | 3 | 48 | 32 | 14 | 2 | green |
+| Magister's Terrace | 23 | 3 | 65 | 39 | 18 | 8 | green |
+| The Black Morass | 13 | 3 | 34 | 18 | 7 | 9 | green |
+| The Escape From Durnholde | 32 | 3 | 59 | 24 | 29 | 6 | green |
+| Utgarde Keep | 19 | 6 | 55 | 30 | 22 | 3 | green |
+| Utgarde Pinnacle | 19 | 4 | 50 | 27 | 17 | 6 | green |
+| The Nexus | 24 | 5 | 64 | 35 | 26 | 3 | green |
+| The Oculus | 17 | 4 | 42 | 21 | 12 | 9 | green |
+| The Culling of Stratholme | 21 | 4 | 49 | 24 | 20 | 5 | green |
+| Halls of Stone | 16 | 4 | 45 | 25 | 16 | 4 | green |
+| Drak'Tharon Keep | 20 | 4 | 47 | 23 | 22 | 2 | green |
+| Azjol-Nerub | 18 | 3 | 38 | 17 | 13 | 8 | green |
+| Halls of Lightning | 19 | 4 | 52 | 29 | 20 | 3 | green |
 | Gundrak | 15 | 5 | 53 | 33 | 20 | 0 | green |
-| Violet Hold | 2 | 3 | 24 | 19 | 5 | 0 | green |
-| Ahn'kahet: The Old Kingdom | 19 | 5 | 60 | 36 | 24 | 0 | green |
+| Violet Hold | 17 | 3 | 39 | 19 | 5 | 15 | green |
+| Ahn'kahet: The Old Kingdom | 23 | 5 | 64 | 36 | 24 | 4 | green |
 | The Forge of Souls | 11 | 2 | 23 | 10 | 13 | 0 | green |
-| Trial of the Champion | 0 | 5 | 88 | 83 | 5 | 0 | green |
-| Pit of Saron | 27 | 3 | 49 | 19 | 30 | 0 | green |
-| Halls of Reflection | 8 | 2 | 38 | 28 | 10 | 0 | green |
-| Tinkertech Showdown | 3 | 1 | 8 | 4 | 0 | 4 | green |
-| Frozen Reach | 3 | 1 | 8 | 4 | 0 | 4 | green |
-| Forgotten Mine | 3 | 1 | 8 | 4 | 0 | 4 | green |
+| Trial of the Champion | 6 | 12 | 123 | 105 | 5 | 13 | green |
+| Pit of Saron | 31 | 3 | 53 | 19 | 30 | 4 | green |
+| Halls of Reflection | 16 | 2 | 46 | 28 | 10 | 8 | green |
+| Tinkertech Showdown | 3 | 1 | 13 | 12 | 0 | 4 | green |
+| Frozen Reach | 2 | 1 | 19 | 19 | 0 | 3 | green |
+| Forgotten Mine | 4 | 1 | 13 | 12 | 0 | 5 | green |
 
 ## Documented source-faithful exceptions
 
-- wailing-caverns:entry-3653: Kresh is melee-only in the pinned AzerothCore snapshot; the historical server has no spell or SmartAI row for entry 3653.
+- wailing-caverns:kresh: Kresh is melee-only in the pinned AzerothCore snapshot; the historical server has no spell or SmartAI row for entry 3653.
 - wailing-caverns:deviate-faerie-dragon: The server-faithful rare entry 5912 has no spell rows and is despawned by the Wailing Caverns initialization event.
-- trial-of-the-champion: Trial of the Champion is an encounter arena; its imported combat population is the five Grand Champion bosses, not a trash route.
+- gnomeregan:wow-classic-batch-three-entry-7361: Grubbis is melee-only in the pinned AzerothCore snapshot; entry 7361 has aggro dialogue and instance-completion rows but no combat spell cast.
+- blackrock-spire:entry-9218: Spirestone Battle Lord is a 15% rare spawn in the pinned database and has no combat spell cast beyond its basic melee attack.
+- blackrock-spire:entry-9219: Spirestone Butcher is a 15% rare spawn in the pinned database and has no combat spell cast beyond its basic melee attack.
+- blackrock-spire:entry-10376: Crystal Fang is a 15% rare spawn with no active combat spell in the pinned database; its exact on-death Spire Spiderling summon is implemented by the instance adapter.
 
 ## Issues
 

dungeon-pipeline/ascension/ASCENSION_CUSTOM_DUNGEON_RECOVERY.json

@@ -0,0 +1,858 @@
+{
+  "schemaVersion": 1,
+  "scope": "ascension-custom-five-player-source-recovery",
+  "status": "partial-authoritative-recovery",
+  "sourcePolicy": {
+    "exact": "Values copied from installed-client DBC rows or already checksummed map packages.",
+    "spellLinked": "Creature and gameobject IDs recovered from summon effects in installed-client Spell.dbc. The link is exact even when the missing creature_template or gameobject_template name is inferred from the spell context.",
+    "authored": "Timing, phase ownership, placement, health tuning, and any entity explicitly marked authored are adaptation decisions, not claims about Ascension server behavior."
+  },
+  "sources": [
+    {
+      "id": "ascension-area52-spell-dbc",
+      "kind": "installed-client-dbc",
+      "pathHint": "../LadiksMPQEditor/client-current/area-52/patch-D/DBFilesClient/Spell.dbc",
+      "sha256": "2f77f18b91ffbae32a19568e4bc05ec78ee384b6ba8dd2a6e05f0e97abbb2dce",
+      "header": {
+        "signature": "WDBC",
+        "recordCount": 238891,
+        "fieldCount": 234,
+        "recordSize": 936,
+        "stringBlockSize": 14058299
+      },
+      "localeField": "enUS",
+      "confidence": "exact"
+    },
+    {
+      "id": "manastorm-runtime-catalog",
+      "kind": "installed-client-encounter-export",
+      "path": "src/game/generated/manastormRuntimeCatalog.json",
+      "confidence": "exact"
+    },
+    {
+      "id": "manastorm-asset-packages",
+      "kind": "installed-client-map-export",
+      "path": "src/game/generated/manastormAssetPackages.json",
+      "confidence": "exact-environment-provisional-semantics"
+    },
+    {
+      "id": "campaign-runtime-snapshot",
+      "kind": "generated-runtime-catalog",
+      "path": "src/game/generated/dungeonCampaignCatalog.json",
+      "confidence": "exact-current-state"
+    },
+    {
+      "id": "ascension-db-alva",
+      "kind": "official-public-database",
+      "url": "https://db.ascension.gg/?npc=97700",
+      "confidence": "exact"
+    },
+    {
+      "id": "ascension-db-arktos",
+      "kind": "official-public-database",
+      "url": "https://db.ascension.gg/?npc=97701",
+      "confidence": "exact"
+    },
+    {
+      "id": "ascension-changelog-frozen-reach-blast-arrow",
+      "kind": "official-changelog",
+      "url": "https://ascension.gg/en/changelog/1?page=7",
+      "confidence": "exact-wording-name-differs"
+    },
+    {
+      "id": "ascension-changelog-frozen-reach-rebirth",
+      "kind": "official-changelog",
+      "url": "https://ascension.gg/en/changelog/1?page=8",
+      "confidence": "exact"
+    },
+    {
+      "id": "ascension-changelog-forgotten-mine-crystals",
+      "kind": "official-changelog",
+      "url": "https://ascension.gg/en/changelog/1?page=51",
+      "confidence": "exact"
+    },
+    {
+      "id": "ascension-changelog-forgotten-mine-geospike",
+      "kind": "official-changelog",
+      "url": "https://ascension.gg/en/changelog/1?page=29",
+      "confidence": "exact"
+    }
+  ],
+  "localSearchAudit": {
+    "searchedRoots": [
+      "../wow-pvt-server-backups-2",
+      "../WoW-Pvt-Server-Backups",
+      "../wow-private-server-notes",
+      "../LadiksMPQEditor",
+      "../wow335a/Cache",
+      "../resources/client/Cache"
+    ],
+    "searchedArtifacts": [
+      "creature_template and creature spawn SQL",
+      "gameobject_template and gameobject spawn SQL",
+      "SmartAI and ScriptName bindings",
+      "Lua/XML/JSON/CSV encounter data",
+      "creaturecache.wdb and gameobjectcache.wdb records"
+    ],
+    "missingAuthoritativeData": [
+      "creature templates and display mappings for 663012, 97700, and 254272",
+      "world spawn rows for maps 821, 908, and 1781",
+      "server-side encounter scripts and cast cadence",
+      "authoritative trash population and patrol routes",
+      "authoritative gameobject placements"
+    ],
+    "publicSnapshotCheck": {
+      "repository": "https://github.com/Ascension-Addons/Questie-X-AscensionDB.git",
+      "commit": "cf6710ef94c264d842cf2ea94c4b50e9ece6dd61",
+      "result": "No target boss IDs, names, spawns, or encounter scripts were present."
+    }
+  },
+  "dungeons": [
+    {
+      "mapId": 821,
+      "id": "tinkertech-showdown",
+      "title": "Tinkertech Showdown",
+      "mapDirectory": "TinketechShowdown",
+      "sourceClassification": "identity-and-environment-only",
+      "environment": {
+        "sourceHash": "323c47c081d0a6c39daf9878284863c21e3e38dbced2ba3f58d1d157d080d41d",
+        "rootWmo": "World/wmo/Dungeon/AZ_Subway/Subway_Dungeon.wmo",
+        "anchors": {
+          "player": [
+            3.648781,
+            -4.167801,
+            66.263252
+          ],
+          "trash": [
+            10.220209,
+            -126.067818,
+            1266.206177
+          ],
+          "boss": [
+            -15.779793,
+            -4.267807,
+            2439.406006
+          ]
+        },
+        "semanticStatus": "provisional-geometry-derived"
+      },
+      "encounters": [
+        {
+          "encounterId": 9013,
+          "modeId": 2,
+          "name": "Mechatron",
+          "creatureId": 663012,
+          "identityConfidence": "exact"
+        }
+      ],
+      "currentRuntime": {
+        "bossEntityId": "entry-663012",
+        "proceduralTrashSpawnCount": 15,
+        "proceduralMobEntries": [
+          {
+            "entityId": "tinkertech-showdown-guardian",
+            "serverEntry": 2629079128
+          },
+          {
+            "entityId": "tinkertech-showdown-caster",
+            "serverEntry": 3849447491
+          },
+          {
+            "entityId": "tinkertech-showdown-brute",
+            "serverEntry": 1787979165
+          }
+        ]
+      },
+      "sourceRecovery": {
+        "association": "candidate-client-cluster-only",
+        "associationConfidence": "low",
+        "reason": "These adjacent client rows form a coherent mechanical-machine kit and include Sound: Goblin Head Machine Loop, but no recovered server row links them to creature 663012.",
+        "spellRows": {
+          "257438": "Rocket",
+          "257459": "Gatling Missile Barrage",
+          "257460": "Gatling Missile",
+          "257461": "Gatling Missile",
+          "257462": "Sound: Goblin Head Machine Loop",
+          "257470": "Incineration Beam",
+          "257471": "Energy Ball",
+          "257472": "Electrified Zone",
+          "257473": "Electric Shock"
+        },
+        "families": {
+          "rocket": [
+            257438
+          ],
+          "gatlingMissileBarrage": [
+            257459,
+            257460,
+            257461
+          ],
+          "incinerationBeam": [
+            257470
+          ],
+          "electrifiedZone": [
+            257472,
+            257473
+          ]
+        }
+      },
+      "adaptation": {
+        "status": "custom-authoring-required",
+        "populationPlan": {
+          "disposition": "retain-current-route-as-explicit-adaptation",
+          "packCount": 5,
+          "membersPerPack": 3,
+          "authoredMobs": [
+            {
+              "serverEntry": 2629079128,
+              "name": "Tinkertech Guardbot",
+              "role": "melee-interceptor"
+            },
+            {
+              "serverEntry": 3849447491,
+              "name": "Tinkertech Coilcaster",
+              "role": "electrical-ranged"
+            },
+            {
+              "serverEntry": 1787979165,
+              "name": "Tinkertech Demolisher",
+              "role": "rocket-bruiser"
+            }
+          ]
+        },
+        "encounterPlan": [
+          "Mechatron remains creature 663012 at the provisional boss anchor.",
+          "Rocket uses a 2.0 second target reticle and splash damage on an authored 8 second cadence.",
+          "Gatling Missile Barrage uses a 3.0 second warning followed by eight lane impacts over 4 seconds on an authored 14 second cadence.",
+          "Incineration Beam uses a 2.5 second wind-up and sweeps the subway lane for 5 seconds; immutable web geometry means it visually disables lane sections instead of permanently destroying client platforms.",
+          "Electrified Zone alternates floor strips after a 1.5 second warning, remains active for 8 seconds, and applies a 1.5 second stun on contact.",
+          "At 35 percent health, cadence accelerates by 20 percent and two authored Coilcasters enter from the previous pack anchor."
+        ],
+        "mustBeCustomAuthored": [
+          "all trash identities, placements, and AI",
+          "all boss timing and phase thresholds",
+          "the decision to associate candidate spells 257438 and 257459-257473 with Mechatron",
+          "platform or lane disable behavior",
+          "boss and trash visual composites",
+          "loot and completion scripting"
+        ]
+      },
+      "unresolved": [
+        "No authoritative Mechatron spell-to-creature binding was found.",
+        "No authoritative trash or gameobject IDs were found.",
+        "The custom ADT placement transform and all semantic anchors still require playtest approval."
+      ]
+    },
+    {
+      "mapId": 908,
+      "id": "frozen-reach",
+      "title": "Frozen Reach",
+      "mapDirectory": "Alvaencounter",
+      "sourceClassification": "encounter-spells-and-summons-recovered",
+      "environment": {
+        "sourceHash": "5ab771df79c0e062cea3ebda4e416a9245bcf8a4cc6da048077df5e674081f97",
+        "anchors": {
+          "player": [
+            1858.534668,
+            78.860199,
+            2229.334473
+          ],
+          "trash": [
+            2100.134766,
+            80.860199,
+            2132.93457
+          ],
+          "boss": [
+            2344.134766,
+            62.460205,
+            2134.334717
+          ]
+        },
+        "semanticStatus": "provisional-elevated-encounter-component"
+      },
+      "encounters": [
+        {
+          "encounterId": 2168,
+          "modeId": 0,
+          "name": "Alva",
+          "creatureId": 97700,
+          "identityConfidence": "exact"
+        },
+        {
+          "encounterId": 2170,
+          "modeId": 2,
+          "name": "Alva",
+          "creatureId": 97700,
+          "identityConfidence": "exact"
+        }
+      ],
+      "entities": [
+        {
+          "entryId": 97700,
+          "name": "Alva",
+          "role": "boss",
+          "sourceKind": "encounter-dbc-and-official-db"
+        },
+        {
+          "entryId": 97701,
+          "name": "Arktos",
+          "role": "boss-companion",
+          "sourceKind": "official-db"
+        },
+        {
+          "entryId": 97703,
+          "name": "Blast Arrow summoned unit",
+          "role": "area-trigger",
+          "sourceKind": "spell-linked-name-inferred"
+        },
+        {
+          "entryId": 97731,
+          "name": "Explosive Trap summoned unit",
+          "role": "trap",
+          "sourceKind": "spell-linked-name-inferred"
+        },
+        {
+          "entryId": 97770,
+          "name": "Alvajar summoned unit",
+          "role": "add",
+          "sourceKind": "spell-linked-name-inferred"
+        }
+      ],
+      "currentRuntime": {
+        "bossEntityId": "entry-97700",
+        "proceduralTrashSpawnCount": 15,
+        "proceduralMobEntries": [
+          {
+            "entityId": "frozen-reach-guardian",
+            "serverEntry": 1606324391
+          },
+          {
+            "entityId": "frozen-reach-caster",
+            "serverEntry": 854807736
+          },
+          {
+            "entityId": "frozen-reach-brute",
+            "serverEntry": 2855026892
+          }
+        ]
+      },
+      "sourceRecovery": {
+        "association": "explicit-alva-arktos-client-cluster",
+        "associationConfidence": "high",
+        "spellRows": {
+          "255347": "Auto Shot",
+          "255349": "Rain of Arrows",
+          "255351": "Rain of Arrows",
+          "255352": "Unbridled Arrows",
+          "255353": "Unbridled Arrows",
+          "255358": "Blast Arrow",
+          "255359": "Blast Arrow",
+          "255360": "Pact of the Hunt",
+          "255362": "Blast Arrow",
+          "255363": "Blast Arrow",
+          "255374": "Ice Rock",
+          "255375": "Ice Rock",
+          "255377": "Ice Rock",
+          "255378": "Unholy Frenzy",
+          "255379": "Carnivorous Bite",
+          "255380": "Frost Shield",
+          "255381": "Set Ablaze",
+          "255382": "Blaze",
+          "255387": "Frost Strike",
+          "255389": "Shadow Shroud Surge",
+          "255390": "Shadow Shroud Rebirth",
+          "255393": "Sphere of Grief and Wrath",
+          "255394": "Vengeful Bolt",
+          "255395": "Vengeful Bolt",
+          "255397": "Shadow Veil Lance",
+          "255398": "Shadow Veil Lance",
+          "255399": "Frost Roar",
+          "255401": "Cluster Shot",
+          "255402": "Cluster Shot",
+          "255403": "Cluster Shot",
+          "255410": "Alva's Grief",
+          "255411": "Alva's Grief",
+          "255412": "Frost orb",
+          "255413": "Frozen Pulse",
+          "255417": "Shield Wall",
+          "255418": "Shield Wall",
+          "255419": "Alva's Wrath",
+          "255420": "Throw Explosive Trap",
+          "255421": "Explosive Trap",
+          "255423": "Trap Explosion",
+          "255424": "Charging",
+          "255426": "Explosive Trap",
+          "255427": "Frostblade Strike",
+          "255428": "Frostblade Strike",
+          "255432": "Army of the Dead",
+          "255433": "Army of the Dead",
+          "255434": "Lacerate",
+          "255435": "Lacerate",
+          "255436": "Lacerate",
+          "255437": "Arcing Slice",
+          "255438": "Rain of Arrows",
+          "255439": "Rain of Arrows",
+          "255440": "Cluster Shot",
+          "255441": "Cluster Shot",
+          "255442": "Unbridled Arrows",
+          "255443": "Unbridled Arrows",
+          "255444": "Blast Arrow",
+          "255445": "Blast Arrow",
+          "255446": "Frost Roar",
+          "255447": "Frost Roar",
+          "255448": "Vengeful Bolt",
+          "255449": "Vengeful Bolt",
+          "255450": "Ice Rock",
+          "255451": "Ice Rock",
+          "255452": "Frostblade Strike",
+          "255453": "Frostblade Strike",
+          "255454": "Shadow Shroud Surge",
+          "255455": "Shadow Shroud Surge",
+          "255456": "Shadow Shroud Rebirth",
+          "255457": "Shadow Shroud Rebirth",
+          "255458": "Shadow Veil Lance",
+          "255459": "Shadow Veil Lance",
+          "255460": "Alva's Wrath",
+          "255461": "Alva's Wrath",
+          "255462": "Sphere of Grief and Wrath",
+          "255463": "Sphere of Grief and Wrath",
+          "255464": "Frost Strike",
+          "255465": "Frost Strike",
+          "255466": "Predator's Fury",
+          "255467": "Alva's Grief",
+          "255468": "Alva's Grief",
+          "255469": "Trap Explosion",
+          "255470": "Trap Explosion",
+          "255471": "Frozen Pulse",
+          "255472": "Frozen Pulse"
+        },
+        "families": {
+          "alvaRanged": [
+            255347,
+            255349,
+            255351,
+            255352,
+            255353,
+            255358,
+            255359,
+            255401,
+            255402,
+            255403,
+            255420,
+            255421,
+            255423,
+            255424
+          ],
+          "arktos": [
+            255360,
+            255374,
+            255375,
+            255377,
+            255378,
+            255379,
+            255380,
+            255381,
+            255382,
+            255387,
+            255399,
+            255417,
+            255418,
+            255434
+          ],
+          "alvaVengeance": [
+            255389,
+            255390,
+            255393,
+            255394,
+            255395,
+            255397,
+            255398,
+            255410,
+            255411,
+            255419,
+            255432,
+            255433
+          ],
+          "difficultyOneAndTwoVariants": [
+            255435,
+            255436,
+            255438,
+            255439,
+            255440,
+            255441,
+            255442,
+            255443,
+            255444,
+            255445,
+            255446,
+            255447,
+            255448,
+            255449,
+            255450,
+            255451,
+            255452,
+            255453,
+            255454,
+            255455,
+            255456,
+            255457,
+            255458,
+            255459,
+            255460,
+            255461,
+            255462,
+            255463,
+            255464,
+            255465,
+            255467,
+            255468,
+            255469,
+            255470,
+            255471,
+            255472
+          ]
+        },
+        "summonLinks": [
+          {
+            "spellId": 255363,
+            "effectIndex": 0,
+            "effectType": 28,
+            "targetKind": "creature",
+            "entryId": 97703
+          },
+          {
+            "spellId": 255421,
+            "effectIndex": 0,
+            "effectType": 28,
+            "targetKind": "creature",
+            "entryId": 97731
+          },
+          {
+            "spellId": 255433,
+            "effectIndex": 0,
+            "effectType": 28,
+            "targetKind": "creature",
+            "entryId": 97770
+          }
+        ]
+      },
+      "adaptation": {
+        "status": "source-backed-custom-cadence-required",
+        "populationPlan": {
+          "disposition": "remove-unverified-generic-trash",
+          "reason": "Alvaencounter and the recovered spell cluster describe a contained Alva/Arktos encounter; no evidence supports the current 15 generic hallway creatures.",
+          "encounterEntities": [
+            97700,
+            97701,
+            97703,
+            97731,
+            97770
+          ]
+        },
+        "encounterPlan": [
+          "Phase one starts Alva 97700 and Arktos 97701 together, with Pact of the Hunt 255360 active while they remain close.",
+          "Alva uses Rain of Arrows, Unbridled Arrows, Blast Arrow, Cluster Shot, and summoned Explosive Traps; Arktos uses Carnivorous Bite, Ice Rock, Frost Roar, Lacerate, and defensive Frost Shield or Shield Wall.",
+          "Blast Arrow can strike Arktos and apply Set Ablaze 255381, causing panic movement, Blaze 255382, and increased damage taken. This matches the official changelog's Blast Shot/Arktos interaction despite the DBC naming it Blast Arrow.",
+          "Arktos death leaves Alva's Grief 255410 around the corpse and transitions Alva to the vengeance kit.",
+          "The transition casts Shadow Shroud Rebirth 255390 and summons four Alvajar 97770 around the arena. Rebirth damage must scale by living group size, reaching full value at five or more players per the official changelog.",
+          "Phase two rotates Vengeful Bolt, Shadow Veil Lance, Sphere of Grief and Wrath, Army of the Dead, and stacking Alva's Wrath as the soft enrage.",
+          "Wire ASC D0 rows to the current normal experience. Preserve D1 and D2 rows but do not assign public difficulty labels until an authoritative mode mapping is recovered."
+        ],
+        "authoredCadence": {
+          "rainOfArrowsMs": 12000,
+          "unbridledArrowsMs": 20000,
+          "blastArrowMs": 15000,
+          "clusterShotMs": 18000,
+          "explosiveTrapMs": 16000,
+          "arktosIceRockMs": 12000,
+          "arktosFrostRoarMs": 18000,
+          "vengefulBoltMs": 7000,
+          "shadowVeilLanceMs": 12000,
+          "sphereOfGriefMs": 20000,
+          "alvasWrathMs": 25000
+        },
+        "mustBeCustomAuthored": [
+          "all cast cadence and target-selection rules",
+          "Arktos initial placement and companion pathing",
+          "phase transition and exact death threshold behavior",
+          "Alvajar formation and spawn placement",
+          "trap and area-trigger web-runtime behavior",
+          "boss and add visual composites",
+          "loot and completion scripting"
+        ]
+      },
+      "unresolved": [
+        "The server-side spell schedule and encounter script are absent.",
+        "Creature template stats, display IDs, and exact positions are absent.",
+        "ASC D0/D1/D2 spell ranks cannot be mapped safely beyond D0 without a surviving difficulty script."
+      ]
+    },
+    {
+      "mapId": 1781,
+      "id": "forgotten-mine",
+      "title": "Forgotten Mine",
+      "mapDirectory": "ForgottenMine",
+      "sourceClassification": "encounter-spells-creature-summon-and-gameobject-recovered",
+      "environment": {
+        "sourceHash": "693b7067aa1109e14beb944bc95aed8299bf64e2ec6ae3dc43f4fab7d18f57b6",
+        "anchors": {
+          "player": [
+            1285.886108,
+            149.58075,
+            1724.264526
+          ],
+          "trash": [
+            1857.461304,
+            136.080749,
+            1871.884277
+          ],
+          "boss": [
+            2246.06665,
+            198.180786,
+            2147.866699
+          ]
+        },
+        "semanticStatus": "provisional-main-navigation-component"
+      },
+      "encounters": [
+        {
+          "encounterId": 5069,
+          "modeId": 0,
+          "name": "Geolord Vek",
+          "creatureId": 254272,
+          "identityConfidence": "exact"
+        },
+        {
+          "encounterId": 5071,
+          "modeId": 2,
+          "name": "Geolord Vek",
+          "creatureId": 254272,
+          "identityConfidence": "exact"
+        }
+      ],
+      "entities": [
+        {
+          "entryId": 254272,
+          "name": "Geolord Vek",
+          "role": "boss",
+          "sourceKind": "encounter-dbc"
+        },
+        {
+          "entryId": 254278,
+          "name": "Geospike summoned unit",
+          "role": "hazard",
+          "sourceKind": "spell-linked-name-inferred"
+        }
+      ],
+      "gameObjects": [
+        {
+          "entryId": 254051,
+          "name": "Resonite Shard",
+          "role": "clickable-encounter-countermeasure",
+          "sourceKind": "spell-linked-name-from-create-spell"
+        }
+      ],
+      "currentRuntime": {
+        "bossEntityId": "entry-254272",
+        "proceduralTrashSpawnCount": 15,
+        "proceduralMobEntries": [
+          {
+            "entityId": "forgotten-mine-guardian",
+            "serverEntry": 4175632753
+          },
+          {
+            "entityId": "forgotten-mine-caster",
+            "serverEntry": 647988074
+          },
+          {
+            "entityId": "forgotten-mine-brute",
+            "serverEntry": 2677742134
+          }
+        ]
+      },
+      "sourceRecovery": {
+        "association": "explicit-vek-client-cluster",
+        "associationConfidence": "high",
+        "reason": "The contiguous cluster contains Vek Death and Vek Reset control rows alongside the complete earth and Resonite kit.",
+        "spellRows": {
+          "354000": "Stonebreaker",
+          "354001": "Quake",
+          "354002": "Stone Shield",
+          "354003": "Cosmetic Fear",
+          "354004": "Geospike",
+          "354005": "Geospike",
+          "354006": "Geospike",
+          "354007": "Vek Death",
+          "354008": "Vek Reset",
+          "354009": "Quake",
+          "354010": "Quake",
+          "354011": "Stone Shield",
+          "354012": "Stone Shield",
+          "354013": "Resonance",
+          "354014": "Resonance",
+          "354015": "Geode Barrage",
+          "354016": "Geode Barrage",
+          "354017": "Ruptured Earth",
+          "354018": "Ruptured Earth",
+          "354019": "Stoneskin",
+          "354020": "Stoneskin",
+          "354021": "Stonebreaker",
+          "354022": "Stonebreaker",
+          "354023": "Stonebreaker",
+          "354024": "Stonebreaker",
+          "354025": "Geospike",
+          "354026": "Geospike",
+          "354027": "Geode Barrage",
+          "354028": "Geode Barrage",
+          "354029": "Geode Barrage",
+          "354030": "Geode Barrage",
+          "354031": "Resonite Cleanse",
+          "354032": "Create Resonite Shard"
+        },
+        "families": {
+          "control": [
+            354007,
+            354008
+          ],
+          "quake": [
+            354001,
+            354009,
+            354010
+          ],
+          "stoneShield": [
+            354002,
+            354011,
+            354012
+          ],
+          "geospike": [
+            354004,
+            354005,
+            354006,
+            354025,
+            354026
+          ],
+          "resonance": [
+            354013,
+            354014
+          ],
+          "geodeBarrage": [
+            354015,
+            354016,
+            354027,
+            354028,
+            354029,
+            354030
+          ],
+          "rupturedEarth": [
+            354017,
+            354018
+          ],
+          "stoneskin": [
+            354019,
+            354020
+          ],
+          "stonebreaker": [
+            354000,
+            354021,
+            354022,
+            354023,
+            354024
+          ],
+          "resonite": [
+            354031,
+            354032
+          ]
+        },
+        "summonLinks": [
+          {
+            "spellId": 354004,
+            "effectIndex": 0,
+            "effectType": 28,
+            "targetKind": "creature",
+            "entryId": 254278
+          },
+          {
+            "spellId": 354032,
+            "effectIndex": 0,
+            "effectType": 76,
+            "targetKind": "gameobject",
+            "entryId": 254051
+          }
+        ]
+      },
+      "adaptation": {
+        "status": "source-backed-custom-cadence-required",
+        "populationPlan": {
+          "disposition": "retain-current-route-as-explicit-adaptation",
+          "packCount": 5,
+          "membersPerPack": 3,
+          "authoredMobs": [
+            {
+              "serverEntry": 4175632753,
+              "name": "Forgotten Mine Stoneguard",
+              "role": "shielding-melee"
+            },
+            {
+              "serverEntry": 647988074,
+              "name": "Forgotten Mine Geomancer",
+              "role": "geode-ranged"
+            },
+            {
+              "serverEntry": 2677742134,
+              "name": "Forgotten Mine Quarry Brute",
+              "role": "frontal-bruiser"
+            }
+          ]
+        },
+        "encounterPlan": [
+          "Geolord Vek 254272 remains at the provisional boss anchor and opens with Stone Shield.",
+          "Stonebreaker is a telegraphed frontal strike; Quake is a short-range raid pulse; Geode Barrage repeatedly targets one player; Ruptured Earth creates a marked split-damage pillar.",
+          "Geospike 354004 summons entry 254278 after a clearly visible ground telegraph. The hazard erupts with the matching Geospike damage row and then despawns.",
+          "Three clickable Resonite Shard gameobjects 254051 appear at authored offsets around the boss. Clicking consumes one and applies Resonite Cleanse 354031, which removes one active earth protection or prevents the next Resonance hit.",
+          "At 50 percent health, Resonance begins and Vek alternates Quake with Ruptured Earth. Missing crystals respawn once per 30 second cycle.",
+          "The official changelog requires large, obvious clickable crystal bounds and a high-contrast Geospike telegraph."
+        ],
+        "authoredGameObjectOffsetsFromBoss": [
+          [
+            -12,
+            0,
+            0
+          ],
+          [
+            6,
+            0,
+            10.392
+          ],
+          [
+            6,
+            0,
+            -10.392
+          ]
+        ],
+        "authoredCadence": {
+          "stonebreakerMs": 6500,
+          "geodeBarrageMs": 11000,
+          "geospikeMs": 15000,
+          "quakeMs": 18000,
+          "rupturedEarthMs": 22000,
+          "resoniteCycleMs": 30000
+        },
+        "mustBeCustomAuthored": [
+          "all trash identities, placements, and AI",
+          "all boss cadence, target selection, and phase thresholds",
+          "the exact Resonite Cleanse interaction because the server script is absent",
+          "crystal placement, interaction bounds, and respawn rules",
+          "Geospike hazard placement and lifetime",
+          "boss, hazard, trash, and crystal visual composites",
+          "loot and completion scripting"
+        ]
+      },
+      "unresolved": [
+        "Paired low/high-value spell rows do not expose a safe difficulty-label mapping.",
+        "The authoritative creature and gameobject spawn coordinates are absent.",
+        "Creature template stats and visual display IDs are absent.",
+        "The exact Resonite click result is only constrained by client spell text and official changelog behavior."
+      ]
+    }
+  ]
+}

dungeon-pipeline/ascension/ASCENSION_CUSTOM_DUNGEON_RECOVERY.md

@@ -0,0 +1,97 @@
+# Ascension custom dungeon source recovery
+
+This report separates recoverable client facts from the behavior that HealerMan must author for Tinkertech Showdown (821), Frozen Reach (908), and Forgotten Mine (1781). The machine-readable companion is `ASCENSION_CUSTOM_DUNGEON_RECOVERY.json`; its validator checks both the current generated catalogs and the original installed-client `Spell.dbc`.
+
+## Result
+
+| Map | Recovered exactly | Still requires adaptation |
+| --- | --- | --- |
+| 821 Tinkertech Showdown | Client environment, encounter 9013, boss creature 663012 | Every spawn, trash identity, gameobject, spell binding, boss schedule, phase, visual, loot, and completion rule |
+| 908 Frozen Reach | Client environment, encounters 2168/2170, Alva 97700, Arktos 97701, three summoned entries, and 85 encounter spell rows | Positions, stats, cast schedule, target rules, phase scripting, web hazards, visuals, loot, and completion rules |
+| 1781 Forgotten Mine | Client environment, encounters 5069/5071, Geolord Vek 254272, Geospike summon 254278, Resonite Shard gameobject 254051, and 33 encounter spell rows | Positions, stats, cast schedule, trash roster, crystal behavior, hazard lifetime, visuals, loot, and completion rules |
+
+The local server/reference repositories, installed WDB caches, addon databases, and the public Questie Ascension snapshot do not contain surviving creature templates, world spawn rows, SmartAI, or encounter scripts for these maps. Client spell rows prove names and summon targets, but they do not prove cast cadence, ownership in every case, or coordinates.
+
+## 821: Tinkertech Showdown
+
+Exact client facts:
+
+- Map directory: `TinketechShowdown` (the client spelling omits the second `r`). Source hash: `323c47c081d0a6c39daf9878284863c21e3e38dbced2ba3f58d1d157d080d41d`.
+- The recovered root WMO is `World/wmo/Dungeon/AZ_Subway/Subway_Dungeon.wmo`.
+- Manastorm encounter 9013 names Mechatron and binds it to creature 663012 in mode 2.
+- The player, trash, and boss anchors in the manifest are geometry-derived and provisional, not recovered server spawn points.
+
+Candidate-only evidence:
+
+- Spell 257438 `Rocket`.
+- Spells 257459-257461 `Gatling Missile Barrage` / `Gatling Missile`.
+- Spell 257462 `Sound: Goblin Head Machine Loop`.
+- Spell 257470 `Incineration Beam`, spell 257471 `Energy Ball`, and spells 257472-257473 `Electrified Zone` / `Electric Shock`.
+
+Those rows form a coherent goblin-machine cluster, but no surviving source binds them to creature 663012. They must stay labeled as an adaptation if used.
+
+Concrete adaptation:
+
+- Retain the current route as five authored three-creature packs. Recast generated entries 2629079128, 3849447491, and 1787979165 as `Tinkertech Guardbot`, `Tinkertech Coilcaster`, and `Tinkertech Demolisher`; these IDs and names remain HealerMan-owned.
+- Keep Mechatron 663012 at the provisional boss anchor.
+- Use an authored rotation of Rocket reticles, Gatling lane impacts, Incineration Beam lane sweeps, and alternating Electrified Zones. At 35% health, accelerate the rotation and add two Coilcasters.
+- Model platform destruction as temporary lane disabling because the imported web geometry is immutable.
+
+Everything in that combat implementation except the boss identity and candidate spell names is custom-authored. It should not be represented as recovered Ascension parity.
+
+## 908: Frozen Reach
+
+Exact client facts:
+
+- Map directory: `Alvaencounter`. Source hash: `5ab771df79c0e062cea3ebda4e416a9245bcf8a4cc6da048077df5e674081f97`.
+- Manastorm encounters 2168 and 2170 name Alva and bind her to creature 97700 in modes 0 and 2.
+- The official Ascension database identifies Alva as creature 97700 and Arktos as creature 97701.
+- Spell 255363 summons creature 97703, spell 255421 summons creature 97731, and spell 255433 summons creature 97770. In context these are the Blast Arrow unit, Explosive Trap, and Alvajar add.
+- The client cluster spans 85 exact rows from 255347 through 255472. The principal families are Rain of Arrows, Unbridled Arrows, Blast Arrow, Cluster Shot, Pact of the Hunt, Ice Rock, Carnivorous Bite, Frost Shield, Set Ablaze, Blaze, Frost Strike, Frost Roar, Lacerate, Shield Wall, Shadow Shroud Surge/Rebirth, Vengeful Bolt, Shadow Veil Lance, Sphere of Grief and Wrath, Alva's Grief/Wrath, Explosive Trap, and Army of the Dead.
+- The official changelog confirms that the Blast Arrow/“Blast Shot” interaction can hit Arktos and that Shadow Shroud Rebirth reaches full damage scaling at five or more players.
+
+Concrete adaptation:
+
+- Remove the current 15 procedural hallway creatures (entries 1606324391, 854807736, and 2855026892). Available evidence describes a contained Alva/Arktos encounter and provides no support for that generic trash population.
+- Start Alva 97700 and Arktos 97701 together with Pact of the Hunt. Give Alva the recovered ranged/trap kit and Arktos the recovered bite, ice, roar, lacerate, and defensive kit.
+- Allow Blast Arrow to apply Set Ablaze to Arktos, forcing panic movement and increased damage taken.
+- On Arktos's death, leave Alva's Grief at the corpse, cast Shadow Shroud Rebirth, summon four Alvajar 97770, and move Alva into the recovered vengeance spell family.
+- Preserve D1/D2 spell variants as source data but use D0 for the current normal experience until a surviving difficulty mapping is found.
+
+The exact cadence in the JSON is an explicit HealerMan proposal. Initial positions, transition rules, summon formation, stats, targeting, and hazard implementation all remain custom-authored.
+
+## 1781: Forgotten Mine
+
+Exact client facts:
+
+- Map directory: `ForgottenMine`. Source hash: `693b7067aa1109e14beb944bc95aed8299bf64e2ec6ae3dc43f4fab7d18f57b6`.
+- Manastorm encounters 5069 and 5071 name Geolord Vek and bind him to creature 254272 in modes 0 and 2.
+- The contiguous 354000-354032 spell cluster explicitly contains `Vek Death` and `Vek Reset`, tying the cluster to Vek.
+- The recovered families are Stonebreaker, Quake, Stone Shield, Geospike, Resonance, Geode Barrage, Ruptured Earth, Stoneskin, Resonite Cleanse, and Create Resonite Shard.
+- Spell 354004 summons Geospike creature 254278. Spell 354032 creates gameobject 254051, named by the spell as a Resonite Shard.
+- Client text says Resonite counters the power of Earth. Official changelogs additionally require larger clickable crystal bounds and a visible Geospike telegraph.
+
+Concrete adaptation:
+
+- Retain five authored three-creature route packs only as an explicit approximation. Recast generated entries 4175632753, 647988074, and 2677742134 as `Forgotten Mine Stoneguard`, `Forgotten Mine Geomancer`, and `Forgotten Mine Quarry Brute`; these are not recovered Ascension creatures.
+- Keep Geolord Vek 254272 at the provisional boss anchor. Rotate Stonebreaker, Quake, Geode Barrage, Geospike, and Ruptured Earth, then begin Resonance at 50% health.
+- Spawn three clickable Resonite Shards 254051 at the authored triangular offsets in the JSON. Consuming a shard applies Resonite Cleanse 354031 and removes one active earth protection or prevents the next Resonance hit.
+- Give Geospike 254278 a high-contrast ground warning, eruption, and despawn sequence. Make crystal interaction bounds deliberately generous.
+
+The crystal effect is constrained by spell text and changelog behavior but its exact server-side rule did not survive. Trash, timing, targeting, positions, respawn cadence, and visuals are custom-authored.
+
+## Integration boundary
+
+The recovery files intentionally do not change `compile-campaign-catalog.mjs`. Runtime integration should consume the recovered IDs and family lists while preserving three provenance labels:
+
+- `exact`: copied from checksummed client/catalog data.
+- `spellLinked`: an entry ID read directly from a DBC summon effect; its descriptive name can still be contextual.
+- `authored`: HealerMan timing, placement, visuals, or behavior.
+
+Validate the recovery against the current catalogs and installed client with:
+
+```powershell
+node scripts/dungeon-pipeline/validate-ascension-custom-dungeon-recovery.mjs
+```
+
+Use `--skip-dbc` only on machines without the checksummed Area-52 client, or pass another byte-identical file with `--dbc <path>`.

dungeon-pipeline/recipes/arcatraz.json

@@ -9,7 +9,10 @@
   "mapDirectory": "World/Maps/TempestKeepArcane",
   "environmentMode": "global-wmo",
   "coordinateAlignment": "source",
-  "difficultyVariants": [{"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [65, 70]}],
+  "difficultyVariants": [
+    {"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [65, 70]},
+    {"id": "heroic", "difficulty": "heroic", "spawnMask": 2, "levelRange": [70, 70]}
+  ],
   "clientSource": {"rootEnvironmentVariable": "WOW_CLIENT_ROOT", "relativeDefault": "../wow335a"},
   "serverSource": {"rootEnvironmentVariable": "WOW_SERVER_DATA", "adapter": "normalized-json", "readOnly": true},
   "extraction": {"rootWmo": "World/wmo/Dungeon/OL_TempestKeep/TK_Arcane.wmo", "doodadSets": ["Set_$DefaultGlobal"]},

dungeon-pipeline/recipes/auchenai-crypts.json

@@ -9,7 +9,10 @@
   "mapDirectory": "World/Maps/AuchindounDraenei",
   "environmentMode": "global-wmo",
   "coordinateAlignment": "source",
-  "difficultyVariants": [{"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [65, 70]}],
+  "difficultyVariants": [
+    {"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [65, 70]},
+    {"id": "heroic", "difficulty": "heroic", "spawnMask": 2, "levelRange": [70, 70]}
+  ],
   "clientSource": {"rootEnvironmentVariable": "WOW_CLIENT_ROOT", "relativeDefault": "../wow335a"},
   "serverSource": {"rootEnvironmentVariable": "WOW_SERVER_DATA", "adapter": "normalized-json", "readOnly": true},
   "extraction": {"rootWmo": "World/wmo/Dungeon/OL_Auchindoun/Draenei_wing.wmo", "doodadSets": ["Set_$DefaultGlobal"]},

dungeon-pipeline/recipes/blood-furnace.json

@@ -9,7 +9,10 @@
   "mapDirectory": "World/Maps/HellfireDemon",
   "environmentMode": "global-wmo",
   "coordinateAlignment": "source",
-  "difficultyVariants": [{"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [58, 70]}],
+  "difficultyVariants": [
+    {"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [58, 70]},
+    {"id": "heroic", "difficulty": "heroic", "spawnMask": 2, "levelRange": [70, 70]}
+  ],
   "clientSource": {"rootEnvironmentVariable": "WOW_CLIENT_ROOT", "relativeDefault": "../wow335a"},
   "serverSource": {"rootEnvironmentVariable": "WOW_SERVER_DATA", "adapter": "normalized-json", "readOnly": true},
   "extraction": {"rootWmo": "World/wmo/Dungeon/Hellfire/hellfire_DemonWing.wmo", "doodadSets": ["Set_$DefaultGlobal"]},

dungeon-pipeline/recipes/botanica.json

@@ -9,7 +9,10 @@
   "mapDirectory": "World/Maps/TempestKeepAtrium",
   "environmentMode": "global-wmo",
   "coordinateAlignment": "source",
-  "difficultyVariants": [{"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [65, 70]}],
+  "difficultyVariants": [
+    {"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [65, 70]},
+    {"id": "heroic", "difficulty": "heroic", "spawnMask": 2, "levelRange": [70, 70]}
+  ],
   "clientSource": {"rootEnvironmentVariable": "WOW_CLIENT_ROOT", "relativeDefault": "../wow335a"},
   "serverSource": {"rootEnvironmentVariable": "WOW_SERVER_DATA", "adapter": "normalized-json", "readOnly": true},
   "extraction": {"rootWmo": "World/wmo/Dungeon/OL_TempestKeep/TK_Atrium.wmo", "doodadSets": ["Set_$DefaultGlobal"]},

dungeon-pipeline/recipes/hellfire-ramparts.json

@@ -10,7 +10,10 @@
   "environmentMode": "global-wmo",
   "coordinateAlignment": "source-transform",
   "coordinateTransform": {"origin": [1262.4427, -60.8902, 1622.5397], "yawDegrees": 262.143},
-  "difficultyVariants": [{"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [58, 70]}],
+  "difficultyVariants": [
+    {"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [58, 70]},
+    {"id": "heroic", "difficulty": "heroic", "spawnMask": 2, "levelRange": [70, 70]}
+  ],
   "clientSource": {"rootEnvironmentVariable": "WOW_CLIENT_ROOT", "relativeDefault": "../wow335a"},
   "serverSource": {"rootEnvironmentVariable": "WOW_SERVER_DATA", "adapter": "normalized-json", "readOnly": true},
   "extraction": {"rootWmo": "World/wmo/Dungeon/Hellfire/Hellfire_ramparts.wmo", "doodadSets": ["Set_$DefaultGlobal"]},

dungeon-pipeline/recipes/magisters-terrace.json

@@ -9,7 +9,10 @@
   "mapDirectory": "World/Maps/Sunwell5ManFix",
   "environmentMode": "global-wmo",
   "coordinateAlignment": "source",
-  "difficultyVariants": [{"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [70, 70]}],
+  "difficultyVariants": [
+    {"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [70, 70]},
+    {"id": "heroic", "difficulty": "heroic", "spawnMask": 2, "levelRange": [70, 70]}
+  ],
   "clientSource": {"rootEnvironmentVariable": "WOW_CLIENT_ROOT", "relativeDefault": "../wow335a"},
   "serverSource": {"rootEnvironmentVariable": "WOW_SERVER_DATA", "adapter": "normalized-json", "readOnly": true},
   "extraction": {"rootWmo": "World/wmo/Dungeon/QT_Sunwell_5Man/Sunwell_5Man.wmo", "doodadSets": ["Set_$DefaultGlobal"]},

dungeon-pipeline/recipes/mana-tombs.json

@@ -9,7 +9,10 @@
   "mapDirectory": "World/Maps/AuchindounEthereal",
   "environmentMode": "global-wmo",
   "coordinateAlignment": "source",
-  "difficultyVariants": [{"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [65, 70]}],
+  "difficultyVariants": [
+    {"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [65, 70]},
+    {"id": "heroic", "difficulty": "heroic", "spawnMask": 2, "levelRange": [70, 70]}
+  ],
   "clientSource": {"rootEnvironmentVariable": "WOW_CLIENT_ROOT", "relativeDefault": "../wow335a"},
   "serverSource": {"rootEnvironmentVariable": "WOW_SERVER_DATA", "adapter": "normalized-json", "readOnly": true},
   "extraction": {"rootWmo": "World/wmo/Dungeon/OL_Auchindoun/ethereal_wing.wmo", "doodadSets": ["Set_$DefaultGlobal"]},

dungeon-pipeline/recipes/mechanar.json

@@ -9,7 +9,10 @@
   "mapDirectory": "World/Maps/TempestKeepFactory",
   "environmentMode": "global-wmo",
   "coordinateAlignment": "source",
-  "difficultyVariants": [{"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [65, 70]}],
+  "difficultyVariants": [
+    {"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [65, 70]},
+    {"id": "heroic", "difficulty": "heroic", "spawnMask": 2, "levelRange": [70, 70]}
+  ],
   "clientSource": {"rootEnvironmentVariable": "WOW_CLIENT_ROOT", "relativeDefault": "../wow335a"},
   "serverSource": {"rootEnvironmentVariable": "WOW_SERVER_DATA", "adapter": "normalized-json", "readOnly": true},
   "extraction": {"rootWmo": "World/wmo/Dungeon/OL_TempestKeep/TK_Factory.wmo", "doodadSets": ["Set_$DefaultGlobal"]},

dungeon-pipeline/recipes/sethekk-halls.json

@@ -9,7 +9,10 @@
   "mapDirectory": "World/Maps/AuchindounDemon",
   "environmentMode": "global-wmo",
   "coordinateAlignment": "source",
-  "difficultyVariants": [{"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [65, 70]}],
+  "difficultyVariants": [
+    {"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [65, 70]},
+    {"id": "heroic", "difficulty": "heroic", "spawnMask": 2, "levelRange": [70, 70]}
+  ],
   "clientSource": {"rootEnvironmentVariable": "WOW_CLIENT_ROOT", "relativeDefault": "../wow335a"},
   "serverSource": {"rootEnvironmentVariable": "WOW_SERVER_DATA", "adapter": "normalized-json", "readOnly": true},
   "extraction": {"rootWmo": "World/wmo/Dungeon/OL_Auchindoun/demon_wing.wmo", "doodadSets": ["Set_$DefaultGlobal"]},

dungeon-pipeline/recipes/shadow-labyrinth.json

@@ -9,7 +9,10 @@
   "mapDirectory": "World/Maps/AuchindounShadow",
   "environmentMode": "global-wmo",
   "coordinateAlignment": "source",
-  "difficultyVariants": [{"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [65, 70]}],
+  "difficultyVariants": [
+    {"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [65, 70]},
+    {"id": "heroic", "difficulty": "heroic", "spawnMask": 2, "levelRange": [70, 70]}
+  ],
   "clientSource": {"rootEnvironmentVariable": "WOW_CLIENT_ROOT", "relativeDefault": "../wow335a"},
   "serverSource": {"rootEnvironmentVariable": "WOW_SERVER_DATA", "adapter": "normalized-json", "readOnly": true},
   "extraction": {"rootWmo": "World/wmo/Dungeon/OL_Auchindoun/shadow_council_wing.wmo", "doodadSets": ["Set_$DefaultGlobal"]},

dungeon-pipeline/recipes/shattered-halls.json

@@ -9,7 +9,10 @@
   "mapDirectory": "World/Maps/HellfireMilitary",
   "environmentMode": "global-wmo",
   "coordinateAlignment": "source",
-  "difficultyVariants": [{"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [60, 70]}],
+  "difficultyVariants": [
+    {"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [60, 70]},
+    {"id": "heroic", "difficulty": "heroic", "spawnMask": 2, "levelRange": [70, 70]}
+  ],
   "clientSource": {"rootEnvironmentVariable": "WOW_CLIENT_ROOT", "relativeDefault": "../wow335a"},
   "serverSource": {"rootEnvironmentVariable": "WOW_SERVER_DATA", "adapter": "normalized-json", "readOnly": true},
   "extraction": {"rootWmo": "World/wmo/Dungeon/Hellfire/Hellfire_Military.wmo", "doodadSets": ["Set_$DefaultGlobal"]},

dungeon-pipeline/recipes/slave-pens.json

@@ -9,7 +9,10 @@
   "mapDirectory": "World/Maps/CoilfangDraenei",
   "environmentMode": "global-wmo",
   "coordinateAlignment": "source",
-  "difficultyVariants": [{"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [60, 70]}],
+  "difficultyVariants": [
+    {"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [60, 70]},
+    {"id": "heroic", "difficulty": "heroic", "spawnMask": 2, "levelRange": [70, 70]}
+  ],
   "clientSource": {"rootEnvironmentVariable": "WOW_CLIENT_ROOT", "relativeDefault": "../wow335a"},
   "serverSource": {"rootEnvironmentVariable": "WOW_SERVER_DATA", "adapter": "normalized-json", "readOnly": true},
   "extraction": {"rootWmo": "World/wmo/Dungeon/OL_Coilfang/Coilfang_Draenei.wmo", "doodadSets": ["Set_$DefaultGlobal"]},

dungeon-pipeline/recipes/steamvault.json

@@ -9,7 +9,10 @@
   "mapDirectory": "World/Maps/CoilfangPumping",
   "environmentMode": "global-wmo",
   "coordinateAlignment": "source",
-  "difficultyVariants": [{"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [60, 70]}],
+  "difficultyVariants": [
+    {"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [60, 70]},
+    {"id": "heroic", "difficulty": "heroic", "spawnMask": 2, "levelRange": [70, 70]}
+  ],
   "clientSource": {"rootEnvironmentVariable": "WOW_CLIENT_ROOT", "relativeDefault": "../wow335a"},
   "serverSource": {"rootEnvironmentVariable": "WOW_SERVER_DATA", "adapter": "normalized-json", "readOnly": true},
   "extraction": {"rootWmo": "World/wmo/Dungeon/OL_Coilfang/Coilfang_Pumping.wmo", "doodadSets": ["Set_$DefaultGlobal"]},

dungeon-pipeline/recipes/underbog.json

@@ -9,7 +9,10 @@
   "mapDirectory": "World/Maps/CoilfangMarsh",
   "environmentMode": "global-wmo",
   "coordinateAlignment": "source",
-  "difficultyVariants": [{"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [60, 70]}],
+  "difficultyVariants": [
+    {"id": "normal", "difficulty": "normal", "spawnMask": 1, "levelRange": [60, 70]},
+    {"id": "heroic", "difficulty": "heroic", "spawnMask": 2, "levelRange": [70, 70]}
+  ],
   "clientSource": {"rootEnvironmentVariable": "WOW_CLIENT_ROOT", "relativeDefault": "../wow335a"},
   "serverSource": {"rootEnvironmentVariable": "WOW_SERVER_DATA", "adapter": "normalized-json", "readOnly": true},
   "extraction": {"rootWmo": "World/wmo/Dungeon/OL_Coilfang/Coilfang_Marsh.wmo", "doodadSets": ["Set_$DefaultGlobal"]},

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "healer-man",
-  "version": "0.1.21",
+  "version": "0.1.28",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "healer-man",
-      "version": "0.1.21",
+      "version": "0.1.28",
       "dependencies": {
         "@capacitor/android": "8.4.1",
         "@capacitor/core": "8.4.1",

package.json

@@ -1,7 +1,7 @@
 {
   "name": "healer-man",
   "private": true,
-  "version": "0.1.21",
+  "version": "0.1.28",
   "type": "module",
   "scripts": {
     "dev": "vite --host 0.0.0.0",
@@ -52,8 +52,11 @@
     "dungeon:five-player:import": "node scripts/dungeon-pipeline/import-five-player-dungeon.mjs",
     "dungeon:five-player:import:remaining": "node scripts/dungeon-pipeline/import-remaining-five-player-dungeons.mjs",
     "dungeon:five-player:verify": "node scripts/dungeon-pipeline/verify-five-player-dungeon-imports.mjs",
-    "dungeon:wow:audit": "node scripts/dungeon-pipeline/audit-wow-dungeon-content.mjs",
+    "dungeon:wow:audit": "vite-node scripts/dungeon-pipeline/audit-wow-dungeon-content.mjs",
+    "dungeon:wow:functionality:audit": "vite-node scripts/dungeon-pipeline/audit-wow-dungeon-functionality.ts",
     "dungeon:wow:test": "vitest run src/game/wowDungeonContent.test.ts",
+    "dungeon:wow:export-tool:test": "node --test scripts/dungeon-pipeline/wow-export-tool.test.mjs",
+    "dungeon:ascension:recovery:validate": "node scripts/dungeon-pipeline/validate-ascension-custom-dungeon-recovery.mjs --skip-dbc",
     "dungeon:wow:all": "node scripts/dungeon-pipeline/run-all-wow-dungeons.mjs",
     "dungeon:extract": "node scripts/dungeon-pipeline/cli.mjs extract",
     "dungeon:creatures": "node scripts/dungeon-pipeline/cli.mjs creatures",
@@ -92,6 +95,7 @@
     "runewaker:audit:encounters": "node scripts/runewaker-pipeline/audit-encounter-implementation.mjs && node --test scripts/runewaker-pipeline/encounter-implementation-report.test.mjs",
     "runewaker:audit:environment-assembly": "node scripts/runewaker-pipeline/audit-environment-assembly.mjs && node --test scripts/runewaker-pipeline/environment-assembly.test.mjs",
     "runewaker:audit:navigation": "node scripts/runewaker-pipeline/analyze-navigation-gaps.mjs && vitest run src/game/runewakerObjectiveRouteAudit.test.ts",
+    "runewaker:audit:material-alpha": "node scripts/runewaker-pipeline/audit-material-alpha.mjs",
     "assets:wailing:instance": "gltf-transform instance ../wow335a/dungeon-export-work/WailingCaverns/converted/wailing-caverns.visual.glb src/assets/game/dungeons/wailing-caverns/wailing-caverns-visual.glb --min 3",
     "assets:wailing:creatures:animated": "node scripts/prepareAnimatedCreatures.mjs",
     "assets:wailing:creatures:combat": "node scripts/add-combat-creature-clips.mjs",

public/content-cache-sw.js

@@ -12,6 +12,7 @@ const BUNDLED_ASSET_PREFIXES = [
   "/assets/characters/wow335a-v1/manifest.json",
   "/assets/characters/wow335a-v1/human/",
   "/assets/creatures/wailing-caverns/",
+  "/assets/game/arenas/",
   "/assets/game/dungeons/wailing-caverns/",
 ];
 const BUNDLED_ASSET_PATHS = new Set([

release-version.json

@@ -1,4 +1,4 @@
 {
-  "versionName": "0.1.21",
-  "versionCode": 1021
+  "versionName": "0.1.28",
+  "versionCode": 1028
 }

scripts/content/publish-content.mjs

@@ -3,6 +3,7 @@ import {
   constants,
   copyFile,
   mkdir,
+  readFile,
   readdir,
   rename,
   stat,
@@ -13,8 +14,16 @@ import { fileURLToPath } from "node:url";
 
 const SCRIPT_DIRECTORY = path.dirname(fileURLToPath(import.meta.url));
 export const PROJECT_ROOT = path.resolve(SCRIPT_DIRECTORY, "../..");
+const WOW_CAMPAIGN_CATALOG_PATH = path.join(
+  PROJECT_ROOT,
+  "src",
+  "game",
+  "generated",
+  "dungeonCampaignCatalog.json",
+);
 export const CONTENT_SCHEMA_VERSION = 1;
 export const DEFAULT_MINIMUM_APP_VERSION = "0.1.0";
+export const WOW_CAMPAIGN_DUNGEON_COUNT = 54;
 export const BUNDLED_ANDROID_PACKS = Object.freeze([
   "core:ui",
   "core:equipment",
@@ -179,15 +188,112 @@ export async function scanContentSources(sources = DEFAULT_CONTENT_SOURCES) {
   return [...discovered.values()].sort((left, right) => left.logicalPath.localeCompare(right.logicalPath));
 }
 
-function contentVersion(files) {
+function contentVersion(files, packs) {
   const digest = createHash("sha256");
   for (const file of files) digest.update(`${file.logicalPath}\0${file.sha256}\0${file.bytes}\n`);
+  for (const pack of packs) {
+    digest.update(`pack\0${pack.id}\0${pack.label}\0${pack.bundledOnAndroid}\0${pack.dependencies.join(",")}\n`);
+  }
   return `content-${digest.digest("hex").slice(0, 16)}`;
 }
 
+function assetPackId(url) {
+  if (typeof url !== "string" || !url.startsWith("/")) return null;
+  return contentPackForPath(url.slice(1));
+}
+
+/**
+ * Builds the logical install topology for the 54-dungeon WoW campaign.
+ * Environment files intentionally remain in their independently downloadable
+ * Manastorm packs; a dungeon pack owns its creatures and pulls in exactly the
+ * environment/shared-creature packs referenced by the generated definition.
+ */
+export function campaignDungeonPackDefinitions(definitions) {
+  const packs = new Map();
+  for (const definition of definitions) {
+    const dungeonPackId = `dungeon:${definition.id}`;
+    if (definition.id === "wailing-caverns") {
+      packs.set(dungeonPackId, {
+        id: dungeonPackId,
+        label: definition.title ?? packLabel(dungeonPackId),
+        bundledOnAndroid: true,
+        dependencies: [],
+      });
+      continue;
+    }
+
+    const environmentUrls = [
+      ...(definition.assets?.visual ?? []).map((asset) => asset.url),
+      ...(definition.assets?.collision ?? []).map((asset) => asset.url),
+      definition.assets?.navigation?.url,
+    ].filter(Boolean);
+    const resolvedEnvironmentPacks = environmentUrls.map(assetPackId);
+    if (!resolvedEnvironmentPacks.length || resolvedEnvironmentPacks.some((id) => !id?.startsWith("manastorm:"))) {
+      throw new Error(`${definition.id} has an environment asset outside a Manastorm content pack.`);
+    }
+    const environmentPackIds = new Set(resolvedEnvironmentPacks);
+    if (environmentPackIds.size !== 1) {
+      throw new Error(`${definition.id} must resolve to exactly one Manastorm environment pack.`);
+    }
+    const [environmentPackId] = environmentPackIds;
+    packs.set(environmentPackId, {
+      id: environmentPackId,
+      label: packLabel(environmentPackId),
+      bundledOnAndroid: false,
+      dependencies: [],
+    });
+
+    const creatureUrls = Object.values(definition.entities ?? {})
+      .map((entity) => entity.visual?.model?.url)
+      .filter(Boolean);
+    const resolvedCreaturePacks = creatureUrls.map(assetPackId);
+    if (resolvedCreaturePacks.some((id) => !id)) {
+      throw new Error(`${definition.id} has a creature asset outside a content pack.`);
+    }
+    const referencedCreaturePacks = new Set(resolvedCreaturePacks.filter((id) => id !== dungeonPackId));
+    const unexpectedCreaturePacks = [...referencedCreaturePacks].filter((id) => id !== "shared:creatures");
+    if (unexpectedCreaturePacks.length) {
+      throw new Error(`${definition.id} references unexpected creature packs: ${unexpectedCreaturePacks.join(", ")}`);
+    }
+    packs.set(dungeonPackId, {
+      id: dungeonPackId,
+      label: definition.title ?? packLabel(dungeonPackId),
+      bundledOnAndroid: false,
+      dependencies: [environmentPackId, ...referencedCreaturePacks],
+    });
+  }
+  return [...packs.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+
+export async function loadCampaignDungeonPackDefinitions(
+  catalogPath = WOW_CAMPAIGN_CATALOG_PATH,
+) {
+  const definitions = await loadCampaignDungeonDefinitions(catalogPath);
+  return campaignDungeonPackDefinitions(definitions);
+}
+
+export async function loadCampaignDungeonDefinitions(
+  catalogPath = WOW_CAMPAIGN_CATALOG_PATH,
+) {
+  const campaign = JSON.parse(await readFile(catalogPath, "utf8"));
+  if (!Array.isArray(campaign.definitions)) {
+    throw new Error(`WoW campaign catalog is missing definitions: ${catalogPath}`);
+  }
+  if (campaign.definitions.length !== WOW_CAMPAIGN_DUNGEON_COUNT) {
+    throw new Error(
+      `WoW campaign catalog must contain ${WOW_CAMPAIGN_DUNGEON_COUNT} dungeons; found ${campaign.definitions.length}.`,
+    );
+  }
+  const dungeonIds = campaign.definitions.map((definition) => definition?.id);
+  if (dungeonIds.some((id) => typeof id !== "string" || !id)
+    || new Set(dungeonIds).size !== dungeonIds.length) {
+    throw new Error("WoW campaign catalog contains a missing or duplicate dungeon id.");
+  }
+  return campaign.definitions;
+}
+
 export function createContentManifest(files, options = {}) {
   const baseUrl = String(options.baseUrl ?? "/content/objects").replace(/\/+$/, "");
-  const version = options.version ?? contentVersion(files);
   const packs = new Map();
   const fileEntries = {};
 
@@ -227,16 +333,93 @@ export function createContentManifest(files, options = {}) {
     }
   }
 
+  for (const declared of options.packDefinitions ?? []) {
+    const current = packs.get(declared.id) ?? {
+      id: declared.id,
+      label: packLabel(declared.id),
+      bytes: 0,
+      fileCount: 0,
+      bundledOnAndroid: BUNDLED_ANDROID_PACKS.includes(declared.id),
+      dependencies: [],
+    };
+    packs.set(declared.id, {
+      ...current,
+      label: declared.label ?? current.label,
+      bundledOnAndroid: declared.bundledOnAndroid ?? current.bundledOnAndroid,
+      dependencies: [...declared.dependencies],
+    });
+  }
+
+  const sortedPacks = [...packs.values()].sort((left, right) => left.id.localeCompare(right.id));
+  const version = options.version ?? contentVersion(files, sortedPacks);
+
   return {
     schemaVersion: CONTENT_SCHEMA_VERSION,
     version,
     createdAt: options.createdAt ?? new Date().toISOString(),
     minimumAppVersion: options.minimumAppVersion ?? DEFAULT_MINIMUM_APP_VERSION,
-    packs: [...packs.values()].sort((left, right) => left.id.localeCompare(right.id)),
+    packs: sortedPacks,
     files: fileEntries,
   };
 }
 
+export function assertCampaignDungeonManifest(manifest, definitions) {
+  if (!Array.isArray(definitions) || definitions.length !== WOW_CAMPAIGN_DUNGEON_COUNT) {
+    throw new Error(`Release content requires exactly ${WOW_CAMPAIGN_DUNGEON_COUNT} WoW dungeon definitions.`);
+  }
+  const expectedDefinitions = campaignDungeonPackDefinitions(definitions);
+  const manifestPacks = new Map(manifest.packs.map((pack) => [pack.id, pack]));
+  if (manifestPacks.size !== manifest.packs.length) {
+    throw new Error("Release content manifest contains duplicate pack ids.");
+  }
+
+  for (const expected of expectedDefinitions) {
+    const actual = manifestPacks.get(expected.id);
+    if (!actual) throw new Error(`Release content manifest is missing ${expected.id}.`);
+    if (actual.bundledOnAndroid !== expected.bundledOnAndroid
+      || actual.dependencies.length !== expected.dependencies.length
+      || actual.dependencies.some((dependency, index) => dependency !== expected.dependencies[index])) {
+      throw new Error(`Release content manifest has stale dependencies for ${expected.id}.`);
+    }
+  }
+
+  for (const pack of manifest.packs) {
+    const packFiles = Object.values(manifest.files).filter((entry) => entry.packId === pack.id);
+    const packBytes = packFiles.reduce((total, entry) => total + entry.bytes, 0);
+    if (pack.fileCount !== packFiles.length || pack.bytes !== packBytes) {
+      throw new Error(`Release content manifest has invalid file totals for ${pack.id}.`);
+    }
+    for (const dependency of pack.dependencies) {
+      if (!manifestPacks.has(dependency)) {
+        throw new Error(`Release content manifest is missing dependency ${dependency} for ${pack.id}.`);
+      }
+    }
+  }
+
+  for (const definition of definitions) {
+    const referencedUrls = [
+      ...(definition.assets?.visual ?? []).map((asset) => asset.url),
+      ...(definition.assets?.collision ?? []).map((asset) => asset.url),
+      definition.assets?.navigation?.url,
+      ...Object.values(definition.entities ?? {}).map((entity) => entity.visual?.model?.url),
+    ].filter(Boolean);
+    for (const logicalPath of referencedUrls) {
+      if (!manifest.files[logicalPath]) {
+        throw new Error(`Release content manifest is missing ${definition.id} asset ${logicalPath}.`);
+      }
+    }
+  }
+
+  const dungeonPackCount = definitions.filter((definition) => (
+    manifestPacks.has(`dungeon:${definition.id}`)
+  )).length;
+  if (dungeonPackCount !== WOW_CAMPAIGN_DUNGEON_COUNT) {
+    throw new Error(
+      `Release content manifest contains ${dungeonPackCount}/${WOW_CAMPAIGN_DUNGEON_COUNT} WoW dungeon packs.`,
+    );
+  }
+}
+
 async function copyObjectIfMissing(file, objectDirectory) {
   const objectName = `${file.sha256}${file.extension}`;
   const destination = path.join(objectDirectory, objectName);
@@ -263,20 +446,35 @@ async function replaceJsonAtomically(destination, value) {
 
 export async function publishContent(options = {}) {
   const contentDirectory = path.resolve(options.contentDirectory ?? process.env.CONTENT_DIR ?? path.join(PROJECT_ROOT, "content"));
+  const files = await scanContentSources(options.sources ?? DEFAULT_CONTENT_SOURCES);
+  const includeCampaignPacks = options.includeCampaignPacks !== false;
+  const campaignDefinitions = includeCampaignPacks ? await loadCampaignDungeonDefinitions() : null;
+  const campaignPackDefinitions = campaignDefinitions
+    ? campaignDungeonPackDefinitions(campaignDefinitions)
+    : [];
+  const packDefinitions = [
+    ...campaignPackDefinitions,
+    ...(options.packDefinitions ?? []),
+  ];
+  const manifest = createContentManifest(files, { ...options, packDefinitions });
+  if (campaignDefinitions) assertCampaignDungeonManifest(manifest, campaignDefinitions);
+
   const objectDirectory = path.join(contentDirectory, "objects");
   const manifestDirectory = path.join(contentDirectory, "manifests");
   await mkdir(objectDirectory, { recursive: true });
   await mkdir(manifestDirectory, { recursive: true });
-
-  const files = await scanContentSources(options.sources ?? DEFAULT_CONTENT_SOURCES);
   let copiedObjects = 0;
   for (const file of files) {
     if (await copyObjectIfMissing(file, objectDirectory)) copiedObjects += 1;
   }
-  const manifest = createContentManifest(files, options);
   await replaceJsonAtomically(path.join(manifestDirectory, `${manifest.version}.json`), manifest);
   await replaceJsonAtomically(path.join(contentDirectory, "manifest.json"), manifest);
-  return { contentDirectory, copiedObjects, manifest };
+  return {
+    contentDirectory,
+    copiedObjects,
+    manifest,
+    campaignDungeonPackCount: campaignDefinitions?.length ?? 0,
+  };
 }
 
 function parseCliArguments(argv) {
@@ -296,6 +494,7 @@ if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.me
   const bytes = result.manifest.packs.reduce((total, pack) => total + pack.bytes, 0);
   console.log(`Published ${result.manifest.files ? Object.keys(result.manifest.files).length : 0} files (${bytes} bytes)`);
   console.log(`Content version: ${result.manifest.version}`);
+  console.log(`WoW campaign dungeon packs: ${result.campaignDungeonPackCount}/${WOW_CAMPAIGN_DUNGEON_COUNT}`);
   console.log(`New immutable objects: ${result.copiedObjects}`);
   console.log(`Manifest: ${path.join(result.contentDirectory, "manifest.json")}`);
 }

scripts/content/publish-content.test.mjs

@@ -1,12 +1,15 @@
 import assert from "node:assert/strict";
-import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { access, mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 import {
   BUNDLED_ANDROID_PACKS,
+  PROJECT_ROOT,
+  assertCampaignDungeonManifest,
   contentPackForPath,
   createContentManifest,
+  loadCampaignDungeonPackDefinitions,
   publishContent,
   scanContentSources,
 } from "./publish-content.mjs";
@@ -31,6 +34,160 @@ test("assigns stable player-facing packs from logical asset paths", () => {
   assert.equal(contentPackForPath("basis/basis_transcoder.wasm"), "core:runtime");
 });
 
+test("gives every WoW campaign dungeon an exact install dependency closure", async () => {
+  const campaign = JSON.parse(await readFile(path.join(
+    PROJECT_ROOT,
+    "src",
+    "game",
+    "generated",
+    "dungeonCampaignCatalog.json",
+  ), "utf8"));
+  const packDefinitions = await loadCampaignDungeonPackDefinitions();
+  const dungeonDefinitions = packDefinitions.filter((pack) => pack.id.startsWith("dungeon:"));
+  const wailingCreatureManifest = JSON.parse(await readFile(path.join(
+    PROJECT_ROOT,
+    "public",
+    "assets",
+    "creatures",
+    "wailing-caverns",
+    "animated-manifest.json",
+  ), "utf8"));
+  assert.equal(campaign.definitions.length, 54);
+  assert.equal(dungeonDefinitions.length, 54);
+  assert.equal(wailingCreatureManifest.creatures.length, 16);
+
+  const referencedSourceFiles = [
+    ...campaign.definitions.flatMap((dungeon) => [
+      ...[
+        ...dungeon.assets.visual,
+        ...dungeon.assets.collision,
+        dungeon.assets.navigation,
+      ].map((asset) => ({ dungeonId: dungeon.id, url: asset.url })),
+      ...Object.values(dungeon.entities).flatMap((entity) => (
+        entity.visual?.model?.url ? [{ dungeonId: dungeon.id, url: entity.visual.model.url }] : []
+      )),
+    ]),
+    ...wailingCreatureManifest.creatures.map((creature) => ({
+      dungeonId: "wailing-caverns",
+      url: creature.url,
+    })),
+  ];
+  await Promise.all(referencedSourceFiles.map(async ({ dungeonId, url }) => {
+    try {
+      await access(path.join(PROJECT_ROOT, "public", ...url.slice(1).split("/")));
+    } catch {
+      assert.fail(`${dungeonId} is missing ${url}`);
+    }
+  }));
+  await Promise.all([
+    "wailing-caverns-visual.glb",
+    "wailing-caverns-collision.glb",
+    "wailing-caverns-navigation.glb",
+  ].map((fileName) => access(path.join(
+    PROJECT_ROOT,
+    "src",
+    "assets",
+    "game",
+    "dungeons",
+    "wailing-caverns",
+    fileName,
+  ))));
+
+  const logicalFiles = new Map();
+  const addFile = (logicalPath) => logicalFiles.set(logicalPath, {
+    logicalPath,
+    sourcePath: logicalPath,
+    sha256: "a".repeat(64),
+    bytes: 1,
+    extension: path.extname(logicalPath),
+    packId: contentPackForPath(logicalPath),
+  });
+  addFile("assets/game/dungeons/wailing-caverns/visual.glb");
+  for (const dungeon of campaign.definitions) {
+    for (const asset of [
+      ...dungeon.assets.visual,
+      ...dungeon.assets.collision,
+      dungeon.assets.navigation,
+    ]) addFile(asset.url.slice(1));
+    for (const entity of Object.values(dungeon.entities)) {
+      if (entity.visual?.model?.url) addFile(entity.visual.model.url.slice(1));
+    }
+  }
+  const manifest = createContentManifest([...logicalFiles.values()], {
+    packDefinitions,
+    version: "campaign-contract",
+  });
+  assert.doesNotThrow(() => assertCampaignDungeonManifest(manifest, campaign.definitions));
+  const packs = new Map(manifest.packs.map((pack) => [pack.id, pack]));
+
+  for (const dungeon of campaign.definitions) {
+    const pack = packs.get(`dungeon:${dungeon.id}`);
+    assert.ok(pack, dungeon.id);
+    if (dungeon.id === "wailing-caverns") {
+      assert.equal(pack.bundledOnAndroid, true);
+      assert.deepEqual(pack.dependencies, []);
+      continue;
+    }
+    const environmentPack = contentPackForPath(dungeon.assets.visual[0].url.slice(1));
+    const needsSharedCreatures = Object.values(dungeon.entities).some((entity) => (
+      entity.visual?.model?.url?.startsWith("/assets/game/creatures/shared/")
+    ));
+    assert.deepEqual(
+      pack.dependencies,
+      [environmentPack, ...(needsSharedCreatures ? ["shared:creatures"] : [])],
+      dungeon.id,
+    );
+    assert.deepEqual(packs.get(environmentPack)?.dependencies, [], dungeon.id);
+  }
+
+  for (const [dungeonId, environmentPack] of [
+    ["tinkertech-showdown", "manastorm:821-tinketechshowdown"],
+    ["frozen-reach", "manastorm:908-alvaencounter"],
+    ["forgotten-mine", "manastorm:1781-forgottenmine"],
+  ]) {
+    const pack = packs.get(`dungeon:${dungeonId}`);
+    assert.equal(pack.fileCount, 0);
+    assert.equal(pack.bytes, 0);
+    assert.deepEqual(pack.dependencies, [environmentPack]);
+  }
+});
+
+test("default release publishing fails before writing an incomplete campaign manifest", async () => {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "healer-man-incomplete-content-test-"));
+  const sourceDirectory = path.join(directory, "source");
+  const contentDirectory = path.join(directory, "content");
+  await mkdir(sourceDirectory, { recursive: true });
+  await writeFile(path.join(sourceDirectory, "placeholder.glb"), Buffer.from("incomplete"));
+
+  try {
+    await assert.rejects(publishContent({
+      contentDirectory,
+      sources: [{ directory: sourceDirectory, logicalPrefix: "assets/game/dungeons/placeholder" }],
+    }), /Release content manifest is missing/);
+    await assert.rejects(access(contentDirectory), { code: "ENOENT" });
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("content versions change when only logical pack dependencies change", () => {
+  const files = [{
+    logicalPath: "assets/game/dungeons/test/creature.glb",
+    sourcePath: "creature.glb",
+    sha256: "b".repeat(64),
+    bytes: 1,
+    extension: ".glb",
+    packId: "dungeon:test",
+  }];
+  const first = createContentManifest(files, {
+    packDefinitions: [{ id: "dungeon:test", dependencies: ["manastorm:first"] }],
+  });
+  const second = createContentManifest(files, {
+    packDefinitions: [{ id: "dungeon:test", dependencies: ["manastorm:second"] }],
+  });
+  assert.notEqual(first.version, second.version);
+});
+
 test("publishes objects before a deterministic latest manifest", async () => {
   const directory = await mkdtemp(path.join(os.tmpdir(), "healer-man-content-test-"));
   const sourceDirectory = path.join(directory, "source");
@@ -45,7 +202,12 @@ test("publishes objects before a deterministic latest manifest", async () => {
     assert.equal(Object.keys(firstManifest.files).length, 1);
     assert.equal(firstManifest.packs[0].id, "dungeon:wailing-caverns");
 
-    const first = await publishContent({ contentDirectory, sources, createdAt: "2026-08-14T00:00:00.000Z" });
+    const first = await publishContent({
+      contentDirectory,
+      sources,
+      includeCampaignPacks: false,
+      createdAt: "2026-08-14T00:00:00.000Z",
+    });
     assert.equal(first.copiedObjects, 1);
     const latest = JSON.parse(await readFile(path.join(contentDirectory, "manifest.json"), "utf8"));
     assert.equal(latest.version, first.manifest.version);
@@ -53,7 +215,12 @@ test("publishes objects before a deterministic latest manifest", async () => {
     assert.match(entry.url, /^\/content\/objects\/[a-f0-9]{64}\.glb$/);
     assert.equal(await readFile(path.join(contentDirectory, "objects", path.basename(entry.url)), "utf8"), "glb-one");
 
-    const second = await publishContent({ contentDirectory, sources, createdAt: "2026-08-14T00:00:00.000Z" });
+    const second = await publishContent({
+      contentDirectory,
+      sources,
+      includeCampaignPacks: false,
+      createdAt: "2026-08-14T00:00:00.000Z",
+    });
     assert.equal(second.copiedObjects, 0);
     assert.equal(second.manifest.version, first.manifest.version);
   } finally {

scripts/dungeon-pipeline/audit-wow-dungeon-content.mjs

@@ -2,6 +2,11 @@
 import { open, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { DUNGEON_DEFINITIONS } from "../../src/game/dungeonRegistry";
+import {
+  WOW_DUNGEON_BASIC_ONLY_BOSS_EXCEPTIONS,
+  WOW_DUNGEON_NO_TRASH_EXCEPTIONS,
+} from "../../src/game/wowDungeonContentExceptions";
 
 const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 const publicRoot = path.join(projectRoot, "public");
@@ -18,24 +23,14 @@ const validTargets = new Set([
 ]);
 const validSchools = new Set(["physical", "arcane", "fire", "frost", "nature", "shadow", "holy"]);
 const validEffects = new Set([
-  "damage", "heal", "aura", "control", "transform", "summon", "call-for-help", "encounter-event",
-]);
-const basicOnlyBossExceptions = new Map([
-  [
-    "wailing-caverns:entry-3653",
-    "Kresh is melee-only in the pinned AzerothCore snapshot; the historical server has no spell or SmartAI row for entry 3653.",
-  ],
-  [
-    "wailing-caverns:deviate-faerie-dragon",
-    "The server-faithful rare entry 5912 has no spell rows and is despawned by the Wailing Caverns initialization event.",
-  ],
-]);
-const noTrashExceptions = new Map([
-  [
-    "trial-of-the-champion",
-    "Trial of the Champion is an encounter arena; its imported combat population is the five Grand Champion bosses, not a trash route.",
-  ],
+  "damage", "heal", "aura", "target-aura", "control", "transform", "summon", "call-for-help", "encounter-event",
 ]);
+const basicOnlyBossExceptions = new Map(
+  WOW_DUNGEON_BASIC_ONLY_BOSS_EXCEPTIONS.map(({ key, reason }) => [key, reason]),
+);
+const noTrashExceptions = new Map(
+  WOW_DUNGEON_NO_TRASH_EXCEPTIONS.map(({ key, reason }) => [key, reason]),
+);
 const animationIds = {
   idle: new Set([0]),
   move: new Set([4, 5]),
@@ -152,13 +147,21 @@ const [campaign, catalog, wailingFixture] = await Promise.all([
   readJson("dungeon-pipeline/fixtures/wailing-caverns/runtime-fixture.json"),
 ]);
 const campaignIds = new Set(campaign.dungeons.map((dungeon) => dungeon.slug));
-const definitions = catalog.definitions.filter((definition) => campaignIds.has(definition.id));
+const definitions = DUNGEON_DEFINITIONS.filter((definition) => campaignIds.has(definition.id));
 const coverage = new Map(catalog.coverage.map((entry) => [entry.dungeonId, entry]));
 const wailingModels = wailingFixtureModels(wailingFixture);
 const issues = [];
+if (basicOnlyBossExceptions.size !== WOW_DUNGEON_BASIC_ONLY_BOSS_EXCEPTIONS.length) {
+  issues.push("The shared basic-only boss exception contract contains a duplicate key.");
+}
+if (noTrashExceptions.size !== WOW_DUNGEON_NO_TRASH_EXCEPTIONS.length) {
+  issues.push("The shared no-trash exception contract contains a duplicate key.");
+}
 const modelUsers = new Map();
 const animationFallbacks = [];
 const dungeons = [];
+const actualBasicOnlyBossKeys = new Set();
+const actualNoTrashDungeonKeys = new Set();
 
 if (campaign.dungeons.length !== 54) {
   issues.push("Expected 54 campaign dungeons; found " + campaign.dungeons.length + ".");
@@ -179,15 +182,15 @@ for (const dungeon of definitions) {
   let specialAttacks = 0;
   let nativeModels = 0;
   let proceduralModels = 0;
-  const optionalBossEntityIds = new Set((dungeon.objectiveOrder ?? [])
-    .filter((objective) => objective.optional)
-    .map((objective) => dungeon.staticSpawns?.find((spawn) => spawn.id === objective.id)?.entityId)
-    .filter(Boolean));
-
   if (!entities.length) dungeonIssues.push("has no combat entities.");
   if (!bosses.length) dungeonIssues.push("has no bosses.");
-  if (!mobs.length && !noTrashExceptions.has(dungeon.id)) dungeonIssues.push("has no trash mobs.");
-  if (!(dungeon.staticSpawns?.length || dungeon.roamingPacks?.length)) dungeonIssues.push("has no combat spawns.");
+  if (!mobs.length) {
+    actualNoTrashDungeonKeys.add(dungeon.id);
+    if (!noTrashExceptions.has(dungeon.id)) dungeonIssues.push("has no trash mobs.");
+  }
+  if (!(dungeon.staticSpawns?.length || dungeon.roamingPacks?.length || dungeon.encounterSpawnGroups?.some((group) => group.spawns?.length))) {
+    dungeonIssues.push("has no combat spawns.");
+  }
 
   for (const spawn of dungeon.staticSpawns ?? []) {
     if (!dungeon.entities?.[spawn.entityId]) {
@@ -201,6 +204,13 @@ for (const dungeon of definitions) {
       }
     }
   }
+  for (const group of dungeon.encounterSpawnGroups ?? []) {
+    for (const spawn of group.spawns ?? []) {
+      if (!dungeon.entities?.[spawn.entityId]) {
+        dungeonIssues.push("encounter group " + group.id + " references missing entity " + spawn.entityId + ".");
+      }
+    }
+  }
 
   for (const [entityId, entity] of entities) {
     const entityAttacks = entity.combat?.attacks ?? [];
@@ -209,8 +219,9 @@ for (const dungeon of definitions) {
     attacks += entityAttacks.length;
     const specials = entityAttacks.filter((attack) => attack.id !== "basic-attack");
     specialAttacks += specials.length;
-    if (entity.kind === "boss" && !specials.length && !optionalBossEntityIds.has(entityId)) {
+    if (entity.kind === "boss" && !specials.length) {
       const exceptionKey = dungeon.id + ":" + entityId;
+      actualBasicOnlyBossKeys.add(exceptionKey);
       if (!basicOnlyBossExceptions.has(exceptionKey)) {
         dungeonIssues.push(entityId + " has no boss mechanic beyond its basic attack.");
       }
@@ -247,6 +258,17 @@ for (const dungeon of definitions) {
   });
 }
 
+for (const key of basicOnlyBossExceptions.keys()) {
+  if (!actualBasicOnlyBossKeys.has(key)) {
+    issues.push("Stale basic-only boss exception does not match a runtime boss: " + key + ".");
+  }
+}
+for (const key of noTrashExceptions.keys()) {
+  if (!actualNoTrashDungeonKeys.has(key)) {
+    issues.push("Stale no-trash exception does not match a runtime dungeon: " + key + ".");
+  }
+}
+
 for (const [url, users] of modelUsers) {
   try {
     const names = await readGlbAnimationNames(url);

scripts/dungeon-pipeline/compile-campaign-catalog.mjs

@@ -10,6 +10,11 @@ const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "
 const recipesRoot = path.join(projectRoot, "dungeon-pipeline", "recipes");
 const workRoot = path.resolve(process.env.DUNGEON_PIPELINE_WORK ?? path.join(projectRoot, "..", "HealerMan-Storage", "pipeline-work", "dungeons"));
 const outputFile = path.join(projectRoot, "src", "game", "generated", "dungeonCampaignCatalog.json");
+const gameObjectAssetManifestFile = path.join(
+  projectRoot,
+  "dungeon-pipeline",
+  "WOW_GAMEOBJECT_ASSET_MANIFEST.json",
+);
 const compressedOutputFile = path.join(
   projectRoot,
   "src",
@@ -81,6 +86,19 @@ const epochSpellDbc = path.join(
   "DBFilesClient",
   "Spell.dbc",
 );
+const standardGameObjectDisplayDbc = path.join(
+  workRoot,
+  "deadmines",
+  "client-dbc",
+  "DBFilesClient",
+  "GameObjectDisplayInfo.dbc",
+);
+const epochGameObjectDisplayDbc = path.join(
+  workRoot,
+  "epoch-client",
+  "DBFilesClient",
+  "GameObjectDisplayInfo.dbc",
+);
 
 const WAILING_SERVER_ENCOUNTERS = Object.freeze([
   [3671, "Lady Anacondra"],
@@ -200,6 +218,100 @@ function slugPart(value) {
     .replace(/^-|-$/g, "") || "unknown";
 }
 
+function compileBossProgressionEncounter(recipe, bosses, syntheticTrash) {
+  const runtimeBosses = bosses.filter((boss) => !boss.eventOnly);
+  const requiredBosses = runtimeBosses.filter((boss) => !boss.optional);
+  const rules = runtimeBosses.map((boss, index) => ({
+    id: `boss-${index + 1}-defeated`,
+    trigger: { kind: "entities-dead", entityIds: [boss.id] },
+    actions: [
+      {
+        id: `record-boss-${index + 1}`,
+        kind: "complete-objective",
+        objectiveId: boss.id,
+        persistence: "run",
+      },
+      ...(!boss.optional ? [{
+        id: `checkpoint-boss-${index + 1}`,
+        kind: "set-checkpoint",
+        checkpointId: boss.id,
+        persistence: "checkpoint",
+      }] : []),
+    ],
+  }));
+  const finalBoss = requiredBosses.at(-1);
+  // Event-only objectives belong to detailed instance orchestration. A
+  // baseline must not declare the dungeon complete before that event fires.
+  if (finalBoss && !bosses.some((boss) => boss.eventOnly)) {
+    rules.push({
+      id: "all-required-bosses-defeated",
+      // Re-evaluate persisted objectives independently of kill order. Tying
+      // completion to the catalog's final actor can strand a run when players
+      // defeat that actor early and finish another required boss afterward.
+      trigger: { kind: "tick" },
+      guards: requiredBosses.map((boss) => ({
+        kind: "objective-complete",
+        objectiveId: boss.id,
+        equals: true,
+      })),
+      actions: [
+        {
+          id: "mark-dungeon-complete",
+          kind: "set-flag",
+          flagId: "dungeon-complete",
+          value: true,
+          persistence: "run",
+        },
+        {
+          id: "enter-complete-phase",
+          kind: "set-phase",
+          phase: "complete",
+          persistence: "run",
+        },
+      ],
+    });
+  }
+  const sourceBacked = !syntheticTrash;
+  return {
+    id: `${recipe.slug}:boss-progression`,
+    dungeonId: recipe.slug,
+    initialPhase: "progression",
+    initialState: { flags: { "dungeon-complete": false } },
+    resetPolicy: { bossWipePhase: "progression", checkpointPhase: "progression" },
+    source: {
+      fidelity: sourceBacked ? "source-backed-adapted" : "healer-man-authored",
+      scope: "boss-progression",
+      files: sourceBacked
+        ? [
+          `dungeon-pipeline/work/${recipe.slug}/runtime-draft.json`,
+          "src/game/generated/azerothCoreScriptSpells.json",
+          "src/game/generated/azerothCoreWorldAi.json",
+        ]
+        : [
+          `dungeon-pipeline/recipes/${recipe.slug}.json`,
+          "src/game/generated/manastormRuntimeCatalog.json",
+        ],
+      reviewedBehavior: sourceBacked
+        ? "Live source-backed boss runtime IDs record persistent objective completion and stable post-boss checkpoints; all required non-event bosses complete the baseline run."
+        : "Catalog boss identities record persistent objective completion and stable post-boss checkpoints; all required bosses complete the authored fallback run.",
+      adaptations: [
+        "Boss progression is intentionally order-independent unless a detailed encounter definition supplies an explicit gate.",
+        "Optional rare bosses record completion when present but do not gate the final completion state.",
+        "A checkpoint retains completed objectives and resets temporary combat state; it does not invent a source graveyard or teleport.",
+      ],
+      remainingGaps: [
+        ...(sourceBacked ? [] : [
+          "Replace the authored fallback with authoritative Ascension population and instance-script data when those sources become available.",
+        ]),
+        "Port exact instance-script doors, waves, escorts, vehicles, dialogue, gossip, quests, area triggers, and event-only bosses where the source requires them.",
+        "Enable source game-object visuals, collision, and state transitions only after their client models and script bindings are reviewed.",
+        "Record an end-to-end traversal, wipe/reset, checkpoint reload, HUD, collision, and completion playtest before marking the dungeon validated.",
+      ],
+    },
+    rules,
+  };
+}
+
 function inferEnvironmentMode(recipe, assetPackage) {
   if (recipe.environmentMode !== "detect") return recipe.environmentMode;
   const sourceFiles = assetPackage.visual.flatMap((chunk) => chunk.provenance?.sourceFiles ?? []);
@@ -214,6 +326,395 @@ const ADT_SOURCE_BASES = new Set([
 ]);
 const GLOBAL_WMO_SOURCE_BASES = new Set(["draft", "flip-x"]);
 const COORDINATE_ALIGNMENTS = new Set(["player-anchor", "source", "source-transform"]);
+const SOURCE_GAME_OBJECT_TYPES = new Set(Array.from({ length: 36 }, (_, type) => type));
+
+function rowValue(row, names, fallback = undefined) {
+  for (const name of names) {
+    if (row?.[name] !== undefined && row[name] !== null) return row[name];
+  }
+  return fallback;
+}
+
+function finiteNumber(value, fallback = 0) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function clamp(value, minimum, maximum) {
+  return Math.min(maximum, Math.max(minimum, value));
+}
+
+function sourceGameObjectPosition(row) {
+  const wowX = finiteNumber(rowValue(row, ["position_x", "positionX", "x"]));
+  const wowY = finiteNumber(rowValue(row, ["position_y", "positionY", "y"]));
+  const wowZ = finiteNumber(rowValue(row, ["position_z", "positionZ", "z"]));
+  return [-wowX, wowZ, wowY];
+}
+
+function sourceGameObjectKind(type, name) {
+  const normalized = normalizedName(name);
+  if (type === 0 || type === 35) {
+    if (normalized.includes("bridge") || normalized.includes("drawbridge")) return "bridge";
+    if (normalized.includes("gate") || normalized.includes("portcullis")) return "gate";
+    return "door";
+  }
+  if (type === 1 || type === 31) return "switch";
+  if (type === 2 || type === 10 || type === 23) return "quest-object";
+  if (type === 3) return /vein|deposit|herb|plant|school|node/i.test(name) ? "resource" : "chest";
+  if (type === 5) return "generic";
+  if (type === 6 || type === 12) return "trap";
+  if (type === 7 || type === 32) return "chair";
+  if (type === 8) return "spell-focus";
+  if (type === 9) return "text";
+  if (type === 11 || type === 15) return "transport";
+  if (type === 13) return "camera";
+  if (type === 18) return "ritual";
+  if (type === 19) return "mailbox";
+  if (type === 22) return "spellcaster";
+  if (type === 25) return "fishing-hole";
+  if (type === 33) return "destructible";
+  return type === 30 ? "aura-generator" : "generic";
+}
+
+function sourceGameObjectHalfExtents(kind, sourceSize) {
+  const size = clamp(finiteNumber(sourceSize, 1), 0.1, 6);
+  if (kind === "door" || kind === "gate") return vector([1.25 * size, 2 * size, 0.2 * size]);
+  if (kind === "bridge") return vector([2.5 * size, 0.2 * size, 1.25 * size]);
+  if (kind === "switch") return vector([0.35 * size, 0.5 * size, 0.35 * size]);
+  if (kind === "chest" || kind === "resource") return vector([0.6 * size, 0.45 * size, 0.45 * size]);
+  if (kind === "trap" || kind === "trigger") return vector([0.8 * size, 0.1 * size, 0.8 * size]);
+  if (kind === "transport") return vector([2 * size, 0.25 * size, 2 * size]);
+  if (kind === "destructible") return vector([1.5 * size, 1.5 * size, 1.5 * size]);
+  return vector([0.45 * size, 0.65 * size, 0.45 * size]);
+}
+
+function clientGameObjectHalfExtents(display, sourceSize) {
+  if (!display?.bounds) return null;
+  const size = clamp(finiteNumber(sourceSize, 1), 0.01, 100);
+  const spans = display.bounds.max.map((value, axis) => value - display.bounds.min[axis]);
+  if (!spans.every((value) => Number.isFinite(value) && value > 0 && value <= 1_000)) return null;
+  // Client bounds are x/y/z. Runtime draft space is -x/z/y.
+  return vector([
+    clamp(spans[0] * size / 2, 0.025, 500),
+    clamp(spans[2] * size / 2, 0.025, 500),
+    clamp(spans[1] * size / 2, 0.025, 500),
+  ]);
+}
+
+function parseGameObjectDisplays(buffer) {
+  if (!buffer || buffer.toString("ascii", 0, 4) !== "WDBC") return new Map();
+  const recordCount = buffer.readUInt32LE(4);
+  const fieldCount = buffer.readUInt32LE(8);
+  const recordSize = buffer.readUInt32LE(12);
+  const stringSize = buffer.readUInt32LE(16);
+  if (fieldCount !== 19 || recordSize !== fieldCount * 4) return new Map();
+  const stringsOffset = 20 + recordCount * recordSize;
+  const readString = (offset) => {
+    if (!offset || offset >= stringSize) return "";
+    const start = stringsOffset + offset;
+    const end = buffer.indexOf(0, start);
+    return buffer.toString("utf8", start, end < 0 ? buffer.length : end);
+  };
+  const displays = new Map();
+  for (let index = 0; index < recordCount; index += 1) {
+    const base = 20 + index * recordSize;
+    const id = buffer.readUInt32LE(base);
+    const modelPath = readString(buffer.readUInt32LE(base + 4)).replace(/\\/g, "/");
+    const min = [12, 13, 14].map((field) => rounded(buffer.readFloatLE(base + field * 4)));
+    const max = [15, 16, 17].map((field) => rounded(buffer.readFloatLE(base + field * 4)));
+    displays.set(id, {
+      id,
+      modelPath,
+      bounds: { min, max },
+    });
+  }
+  return displays;
+}
+
+function sourceGameObjectStates(kind) {
+  if (kind === "door" || kind === "gate" || kind === "bridge") {
+    return [
+      // Adapted source objects remain non-blocking until an instance-script
+      // transition has been reviewed; otherwise a closed door with no opener
+      // would turn an incomplete import into an unavoidable soft lock.
+      { id: "closed", label: "Closed", visible: true, blocksMovement: false, blocksSight: false },
+      { id: "open", label: "Open", visible: false, blocksMovement: false, blocksSight: false },
+    ];
+  }
+  if (kind === "trap") {
+    return [
+      { id: "armed", label: "Armed", visible: true, blocksMovement: false, interactionEnabled: false },
+      { id: "disabled", label: "Disabled", visible: false, blocksMovement: false, interactionEnabled: false },
+    ];
+  }
+  if (kind === "transport") {
+    return [
+      { id: "stationary", label: "Stationary", visible: true, blocksMovement: false, interactionEnabled: false },
+      { id: "moving", label: "Moving", visible: true, blocksMovement: false, interactionEnabled: false },
+    ];
+  }
+  if (kind === "destructible") {
+    return [
+      { id: "intact", label: "Intact", visible: true, blocksMovement: false, blocksSight: false },
+      { id: "destroyed", label: "Destroyed", visible: false, blocksMovement: false, blocksSight: false },
+    ];
+  }
+  return [
+    { id: "available", label: "Available", visible: true, blocksMovement: false, interactionEnabled: false },
+    { id: "inactive", label: "Inactive", visible: false, blocksMovement: false, interactionEnabled: false },
+  ];
+}
+
+function sourceGameObjectInitialState(kind, row) {
+  const sourceState = finiteNumber(rowValue(row, ["state", "State"]), 1);
+  if (kind === "door" || kind === "gate" || kind === "bridge") return sourceState === 0 ? "open" : "closed";
+  if (kind === "trap") return sourceState === 0 ? "disabled" : "armed";
+  if (kind === "transport") return sourceState === 0 ? "moving" : "stationary";
+  if (kind === "destructible") return sourceState === 2 ? "destroyed" : "intact";
+  return sourceState === 0 ? "inactive" : "available";
+}
+
+function sourceGameObjectVisual(kind) {
+  const colors = {
+    door: "#5f4932",
+    gate: "#4d4a46",
+    bridge: "#66543c",
+    switch: "#c38d35",
+    chest: "#8f682f",
+    resource: "#54704b",
+    trap: "#713b36",
+    transport: "#53616b",
+    camera: "#475f78",
+    ritual: "#74518f",
+    spellcaster: "#496e87",
+    "spell-focus": "#5f698d",
+    "aura-generator": "#586f80",
+    destructible: "#6b5849",
+    "quest-object": "#8a773b",
+    generic: "#65584b",
+    chair: "#725942",
+    text: "#806c48",
+    mailbox: "#596778",
+    "fishing-hole": "#3d6878",
+    trigger: "#58606a",
+  };
+  return { hidden: true, color: colors[kind] ?? "#65584b" };
+}
+
+function compileSourceGameObjects(draft, mapPosition, recipe, gameObjectDisplays) {
+  const templates = new Map((draft?.gameObjectTemplates ?? []).map((template) => [
+    finiteNumber(rowValue(template, ["entry", "id"]), -1),
+    template,
+  ]));
+  return (draft?.gameObjects ?? [])
+    .map((row, index) => {
+      const templateId = finiteNumber(rowValue(row, ["id", "entry"]), -1);
+      const template = templates.get(templateId);
+      const type = finiteNumber(rowValue(template, ["type", "Type"]), -1);
+      if (!template || !SOURCE_GAME_OBJECT_TYPES.has(type)) return null;
+      const spawnId = finiteNumber(rowValue(row, ["guid", "spawnId"]), index + 1);
+      const name = String(rowValue(template, ["name", "Name"], `Game object ${templateId}`)).trim()
+        || `Game object ${templateId}`;
+      const kind = sourceGameObjectKind(type, name);
+      const displayId = finiteNumber(rowValue(template, ["displayId", "displayID", "DisplayID"]), 0);
+      const display = gameObjectDisplays.get(displayId);
+      const sourceSize = rowValue(template, ["size", "Size"], 1);
+      const clientHalfExtents = clientGameObjectHalfExtents(display, sourceSize);
+      return {
+        id: `gameobject-${spawnId}`,
+        name,
+        kind,
+        position: mapPosition(sourceGameObjectPosition(row)),
+        yaw: rounded(-finiteNumber(rowValue(row, ["orientation", "yaw"]))),
+        halfExtents: clientHalfExtents ?? sourceGameObjectHalfExtents(kind, sourceSize),
+        initialState: sourceGameObjectInitialState(kind, row),
+        states: sourceGameObjectStates(kind),
+        visual: sourceGameObjectVisual(kind),
+        source: {
+          fidelity: "source-backed-adapted",
+          files: [
+            `dungeon-pipeline/work/${recipe.slug}/source-snapshot.json`,
+            `dungeon-pipeline/work/${recipe.slug}/runtime-draft.json`,
+          ],
+          templateId,
+          spawnId,
+          gameObjectType: type,
+          ...(displayId > 0 ? { clientDisplayId: displayId } : {}),
+          ...(display?.modelPath ? { clientModelPath: display.modelPath } : {}),
+          ...(clientHalfExtents ? { clientBounds: display.bounds } : {}),
+          note: clientHalfExtents
+            ? "Source transform/state and exact client display bounds/model path are preserved. Visual assets and collision remain hidden until the model export and instance-script transition are reviewed; interactions remain disabled until ported."
+            : "Source position, orientation, type, initial state, and template scale are preserved. Visuals and collision remain hidden until client-display bounds/models are reviewed; encounter-script interactions remain disabled until ported.",
+        },
+      };
+    })
+    .filter(Boolean)
+    .sort((left, right) => left.id.localeCompare(right.id, undefined, { numeric: true }));
+}
+
+function increment(map, key, amount = 1) {
+  map.set(key, (map.get(key) ?? 0) + amount);
+}
+
+function sortedCountEntries(map, keyName) {
+  return [...map.entries()]
+    .sort(([left], [right]) => String(left).localeCompare(String(right), undefined, { numeric: true }))
+    .map(([key, instances]) => ({ [keyName]: key, instances }));
+}
+
+function gameObjectAssetManifestFor(definitions) {
+  const assets = new Map();
+  const nonVisualObjects = new Map();
+  const unresolvedModels = new Map();
+  const unresolvedBounds = new Map();
+  let typedInstances = 0;
+  let visualDisplayInstances = 0;
+  let resolvedModelInstances = 0;
+  let boundedInstances = 0;
+
+  for (const dungeon of definitions) {
+    for (const object of dungeon.serverGameObjects ?? []) {
+      if (object.source?.fidelity !== "source-backed-adapted") continue;
+      typedInstances += 1;
+      const displayId = Number(object.source.clientDisplayId);
+      const modelPath = String(object.source.clientModelPath ?? "").replace(/\\/g, "/");
+      const hasBounds = Boolean(object.source.clientBounds);
+      if (!Number.isFinite(displayId) || displayId <= 0) {
+        const templateId = Number(object.source.templateId) || 0;
+        let nonVisual = nonVisualObjects.get(templateId);
+        if (!nonVisual) {
+          nonVisual = {
+            templateId,
+            instances: 0,
+            dungeons: new Map(),
+            kinds: new Map(),
+          };
+          nonVisualObjects.set(templateId, nonVisual);
+        }
+        nonVisual.instances += 1;
+        increment(nonVisual.dungeons, dungeon.id);
+        increment(nonVisual.kinds, object.kind);
+        continue;
+      }
+      visualDisplayInstances += 1;
+      if (hasBounds) boundedInstances += 1;
+
+      if (!modelPath) {
+        const key = displayId;
+        let unresolved = unresolvedModels.get(key);
+        if (!unresolved) {
+          unresolved = {
+            displayId: key,
+            instances: 0,
+            dungeons: new Map(),
+            kinds: new Map(),
+            templateIds: new Set(),
+          };
+          unresolvedModels.set(key, unresolved);
+        }
+        unresolved.instances += 1;
+        increment(unresolved.dungeons, dungeon.id);
+        increment(unresolved.kinds, object.kind);
+        if (object.source.templateId) unresolved.templateIds.add(object.source.templateId);
+      } else {
+        resolvedModelInstances += 1;
+        const key = modelPath.toLowerCase();
+        let asset = assets.get(key);
+        if (!asset) {
+          const extension = path.extname(modelPath).toLowerCase().replace(/^\./, "") || "unknown";
+          const targetPath = modelPath.replace(/\.[^/.]+$/, ".glb");
+          asset = {
+            sourceModelPath: modelPath,
+            sourceType: extension,
+            targetUrl: `/assets/game/world-objects/${targetPath}`,
+            instances: 0,
+            boundedInstances: 0,
+            displayIds: new Set(),
+            dungeons: new Map(),
+            kinds: new Map(),
+          };
+          assets.set(key, asset);
+        }
+        asset.instances += 1;
+        if (hasBounds) asset.boundedInstances += 1;
+        asset.displayIds.add(displayId);
+        increment(asset.dungeons, dungeon.id);
+        increment(asset.kinds, object.kind);
+      }
+
+      if (!hasBounds) {
+        const key = displayId;
+        let unresolved = unresolvedBounds.get(key);
+        if (!unresolved) {
+          unresolved = {
+            displayId: key,
+            modelPath: modelPath || undefined,
+            instances: 0,
+            dungeons: new Map(),
+            kinds: new Map(),
+            templateIds: new Set(),
+          };
+          unresolvedBounds.set(key, unresolved);
+        }
+        unresolved.instances += 1;
+        increment(unresolved.dungeons, dungeon.id);
+        increment(unresolved.kinds, object.kind);
+        if (object.source.templateId) unresolved.templateIds.add(object.source.templateId);
+      }
+    }
+  }
+
+  const serializeUnresolved = (entry) => ({
+    displayId: entry.displayId,
+    ...(entry.modelPath ? { modelPath: entry.modelPath } : {}),
+    instances: entry.instances,
+    templateIds: [...entry.templateIds].sort((left, right) => left - right),
+    dungeons: sortedCountEntries(entry.dungeons, "dungeonId"),
+    kinds: sortedCountEntries(entry.kinds, "kind"),
+  });
+  return {
+    schemaVersion: 1,
+    generatedBy: "scripts/dungeon-pipeline/compile-campaign-catalog.mjs",
+    summary: {
+      typedInstances,
+      visualDisplayInstances,
+      nonVisualInstances: typedInstances - visualDisplayInstances,
+      resolvedModelInstances,
+      boundedInstances,
+      uniqueAssets: assets.size,
+      unresolvedModelInstances: visualDisplayInstances - resolvedModelInstances,
+      unresolvedBoundInstances: visualDisplayInstances - boundedInstances,
+      unresolvedModelDisplayIds: unresolvedModels.size,
+      unresolvedBoundDisplayIds: unresolvedBounds.size,
+    },
+    assets: [...assets.values()]
+      .sort((left, right) => left.sourceModelPath.localeCompare(right.sourceModelPath))
+      .map((asset) => ({
+        sourceModelPath: asset.sourceModelPath,
+        sourceType: asset.sourceType,
+        targetUrl: asset.targetUrl,
+        instances: asset.instances,
+        boundedInstances: asset.boundedInstances,
+        displayIds: [...asset.displayIds].sort((left, right) => left - right),
+        dungeons: sortedCountEntries(asset.dungeons, "dungeonId"),
+        kinds: sortedCountEntries(asset.kinds, "kind"),
+      })),
+    nonVisualObjects: [...nonVisualObjects.values()]
+      .sort((left, right) => left.templateId - right.templateId)
+      .map((entry) => ({
+        templateId: entry.templateId,
+        instances: entry.instances,
+        dungeons: sortedCountEntries(entry.dungeons, "dungeonId"),
+        kinds: sortedCountEntries(entry.kinds, "kind"),
+      })),
+    unresolvedModels: [...unresolvedModels.values()]
+      .sort((left, right) => left.displayId - right.displayId)
+      .map(serializeUnresolved),
+    unresolvedBounds: [...unresolvedBounds.values()]
+      .sort((left, right) => left.displayId - right.displayId)
+      .map(serializeUnresolved),
+  };
+}
 
 function sourceBasisFor(recipe, environmentMode) {
   if (environmentMode !== "adt-hybrid") {
@@ -371,13 +872,44 @@ function uniqueDraftEncounters(encounterRows, mapId) {
       ...(resolvedEntry > 0 ? {} : { syntheticGroupEncounter: true }),
     };
     const key = `${creatureId}:${normalizedName(encounter.name)}`;
-    if (!byIdentity.has(key)) byIdentity.set(key, encounter);
+    const previous = byIdentity.get(key);
+    if (!previous) {
+      byIdentity.set(key, encounter);
+      continue;
+    }
+    byIdentity.set(key, {
+      ...previous,
+      modeIds: [...new Set([...previous.modeIds, ...encounter.modeIds])].sort((left, right) => left - right),
+      sourceRowIds: [...new Set([
+        ...(previous.sourceRowIds ?? []),
+        ...(encounter.sourceRowIds ?? []),
+      ])].sort((left, right) => left - right),
+      orderIndex: Math.min(previous.orderIndex, encounter.orderIndex),
+    });
   }
   return [...byIdentity.values()].sort((left, right) => (
     left.orderIndex - right.orderIndex || left.encounterId - right.encounterId
   ));
 }
 
+function encounterSpawnMask(recipe, encounter, candidate) {
+  const declaredMask = recipe.difficultyVariants.reduce(
+    (mask, difficulty) => mask | Number(difficulty.spawnMask ?? 0),
+    0,
+  );
+  const candidateMask = Number(candidate?.spawnMask ?? 0) & declaredMask;
+  if (candidateMask > 0) return candidateMask;
+
+  const modeIds = new Set((encounter.modeIds ?? []).map(Number));
+  const rowMask = recipe.difficultyVariants.reduce((mask, difficulty) => (
+    difficulty.mapDifficultyId !== undefined
+      && modeIds.has(Number(difficulty.mapDifficultyId))
+      ? mask | Number(difficulty.spawnMask ?? 0)
+      : mask
+  ), 0);
+  return rowMask || declaredMask || 1;
+}
+
 function archetypeFor(name) {
   const value = normalizedName(name);
   if (/murloc|murk|glub|fin/.test(value)) return "murloc";
@@ -1032,6 +1564,12 @@ async function compile() {
   const epochSpells = await exists(epochSpellDbc)
     ? parseSpells(await readFile(epochSpellDbc), wantedSpellIds)
     : ascensionSpells;
+  const standardGameObjectDisplays = await exists(standardGameObjectDisplayDbc)
+    ? parseGameObjectDisplays(await readFile(standardGameObjectDisplayDbc))
+    : new Map();
+  const epochGameObjectDisplays = await exists(epochGameObjectDisplayDbc)
+    ? parseGameObjectDisplays(await readFile(epochGameObjectDisplayDbc))
+    : standardGameObjectDisplays;
 
   const previousOutput = await exists(outputFile)
     ? await readJson(outputFile)
@@ -1103,6 +1641,14 @@ async function compile() {
         ?? draft?.spawns?.[0]?.position
         ?? playerAnchor.position,
     );
+    const serverGameObjects = compileSourceGameObjects(
+      draft,
+      mapPosition,
+      recipe,
+      recipe.clientBuild === "3.3.5a-Epoch"
+        ? epochGameObjectDisplays
+        : standardGameObjectDisplays,
+    );
     const sourceEntities = (draft?.entities ?? [])
       .filter((entity) => (
         !(recipe.slug === "wailing-caverns" && Number(entity.entry) === 5912)
@@ -1230,6 +1776,11 @@ async function compile() {
     const usedBossSpawnIds = new Set();
     const bossObjectives = encounters.map((encounter, index) => {
       const candidate = bossCandidatesByEntry.get(Number(encounter.creatureId));
+      const spawnMask = encounterSpawnMask(recipe, encounter, candidate);
+      const declaredDifficultyMask = recipe.difficultyVariants.reduce(
+        (mask, difficulty) => mask | Number(difficulty.spawnMask ?? 0),
+        0,
+      );
       const alpha = encounters.length <= 1 ? 1 : index / (encounters.length - 1);
       const routeAlpha = 0.18 + alpha * 0.82;
       const nativeRoutePosition = nativeRoutePositions.length
@@ -1253,7 +1804,10 @@ async function compile() {
         name: encounter.name,
         position,
         yaw: candidate?.yaw ?? 0,
-        ...(spawnChance < 1 ? { optional: true } : {}),
+        spawnMask,
+        ...(spawnChance < 1 || (spawnMask & declaredDifficultyMask) !== declaredDifficultyMask
+          ? { optional: true }
+          : {}),
         ...(encounter.eventOnly ? { eventOnly: true } : {}),
       };
     });
@@ -1313,7 +1867,7 @@ async function compile() {
         entityId: boss.entityId,
         position: boss.position,
         yaw: boss.yaw,
-        spawnMask: 1,
+        spawnMask: boss.spawnMask,
       });
     }
 
@@ -1426,7 +1980,8 @@ async function compile() {
       bosses,
       objectiveOrder: bosses,
       navigationLinks: [],
-      serverGameObjects: draft?.gameObjects ?? [],
+      encounters: [compileBossProgressionEncounter(recipe, bosses, syntheticTrash)],
+      serverGameObjects,
       provenance: {
         clientBuild: recipe.clientBuild,
         coordinateAlignment,
@@ -1490,7 +2045,13 @@ async function compile() {
   };
   const serialized = JSON.stringify(output);
   const compressed = gzipSync(Buffer.from(serialized), { level: 9 });
+  const gameObjectAssetManifest = gameObjectAssetManifestFor(definitions);
   await writeFile(outputFile, `${serialized}\n`, "utf8");
+  await writeFile(
+    gameObjectAssetManifestFile,
+    `${JSON.stringify(gameObjectAssetManifest, null, 2)}\n`,
+    "utf8",
+  );
   await writeFile(
     compressedOutputFile,
     `// Generated by npm run dungeon:catalog. Do not edit.\nexport default "${compressed.toString("base64")}";\n`,
@@ -1517,6 +2078,7 @@ async function compile() {
     status: "complete",
     output: path.relative(projectRoot, outputFile).replace(/\\/g, "/"),
     compressedOutput: path.relative(projectRoot, compressedOutputFile).replace(/\\/g, "/"),
+    gameObjectAssetManifest: path.relative(projectRoot, gameObjectAssetManifestFile).replace(/\\/g, "/"),
     compressedBytes: compressed.length,
     dungeons: definitions.length,
     encounters: coverage.reduce((total, row) => total + row.encounters, 0),
@@ -1525,6 +2087,11 @@ async function compile() {
     roamingPacks: coverage.reduce((total, row) => total + row.roamingPacks, 0),
     authoritativeDungeons: coverage.filter((row) => row.source === "azerothcore").length,
     fallbackDungeons: coverage.filter((row) => row.source === "procedural-fallback").length,
+    gameObjectInstances: gameObjectAssetManifest.summary.typedInstances,
+    nonVisualGameObjectInstances: gameObjectAssetManifest.summary.nonVisualInstances,
+    gameObjectAssets: gameObjectAssetManifest.summary.uniqueAssets,
+    unresolvedGameObjectModelInstances: gameObjectAssetManifest.summary.unresolvedModelInstances,
+    unresolvedGameObjectBoundInstances: gameObjectAssetManifest.summary.unresolvedBoundInstances,
   }, null, 2));
 }
 

scripts/dungeon-pipeline/export-source.mjs

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { stat } from "node:fs/promises";
 import path from "node:path";
 import {
   clientRootForRecipe,
@@ -10,24 +10,21 @@ import {
   recipesRoot,
   workRoot,
 } from "./lib.mjs";
+import { runWowExporter } from "./wow-export-tool.mjs";
 
-async function runExporter(argumentsList) {
-  const executable = path.resolve(projectRoot, "../wow335a/dungeon-export-work/tools/wow.export-0.2.19/wow.export.exe");
-  if (!await exists(executable)) throw new Error("The patched portable wow.export executable was not found.");
-  await new Promise((resolve, reject) => {
-    const child = spawn(executable, ["--disable-auto-update", ...argumentsList], {
-      cwd: path.dirname(executable),
-      stdio: "inherit",
-      windowsHide: true,
-    });
-    child.once("error", reject);
-    child.once("exit", (code) => code === 0 ? resolve() : reject(new Error(`wow.export exited with code ${code}.`)));
-  });
+async function resultMtime(output) {
+  const resultFile = path.join(output, "automation-result.json");
+  return await exists(resultFile) ? (await stat(resultFile)).mtimeMs : 0;
 }
 
-async function checkedResult(slug, output) {
+async function checkedResult(slug, output, previousMtime) {
   const resultFile = path.join(output, "automation-result.json");
-  if (!await exists(resultFile)) return { status: "blocked", dungeonId: slug, blockers: ["wow.export produced no automation-result.json."] };
+  if (!await exists(resultFile)) return { status: "blocked", dungeonId: slug, blockers: [`wow.export produced no automation result at ${resultFile}.`] };
+  if ((await stat(resultFile)).mtimeMs <= previousMtime) return {
+    status: "blocked",
+    dungeonId: slug,
+    blockers: [`wow.export did not refresh ${resultFile}; refusing to accept a stale result from an earlier run.`],
+  };
   const result = await readJson(resultFile);
   if (!result.ok) return {
     status: "blocked",
@@ -43,13 +40,14 @@ export async function exportDungeonSource(slug) {
   const recipe = await loadRecipe(slug);
   const clientRoot = clientRootForRecipe(recipe);
   const output = path.join(workRoot, slug, "source-export");
-  await runExporter([
+  const previousMtime = await resultMtime(output);
+  await runWowExporter([
     "--export-dungeon",
     "--recipe", path.join(recipesRoot, `${slug}.json`),
     "--client-root", clientRoot,
     "--output", output,
-  ]);
-  const blocked = await checkedResult(slug, output);
+  ], { projectRoot });
+  const blocked = await checkedResult(slug, output, previousMtime);
   if (blocked) return blocked;
   return { status: "green", dungeonId: slug, output: path.relative(projectRoot, output).replace(/\\/g, "/") };
 }
@@ -58,12 +56,15 @@ export async function exportClientDiscoveryTables(slug) {
   const recipe = await loadRecipe(slug);
   const clientRoot = clientRootForRecipe(recipe);
   const output = path.join(workRoot, slug, "client-dbc");
-  await runExporter([
+  const previousMtime = await resultMtime(output);
+  await runWowExporter([
     "--discover-dungeon",
     "--recipe", path.join(recipesRoot, `${slug}.json`),
     "--client-root", clientRoot,
     "--output", output,
-  ]);
+  ], { projectRoot });
+  const blocked = await checkedResult(slug, output, previousMtime);
+  if (blocked) throw new Error(blocked.blockers.join("\n"));
   return output;
 }
 
@@ -88,13 +89,14 @@ export async function exportCreatureSource(slug) {
     blockers: unresolved.map((creature) => `${creature.name ?? creature.slug} has an unresolved display/composite recipe.`),
   };
   const output = path.join(workRoot, slug, "creature-source");
-  await runExporter([
+  const previousMtime = await resultMtime(output);
+  await runWowExporter([
     "--export-creatures",
     "--recipe", selected,
     "--client-root", clientRoot,
     "--output", output,
-  ]);
-  const blocked = await checkedResult(slug, output);
+  ], { projectRoot });
+  const blocked = await checkedResult(slug, output, previousMtime);
   if (blocked) return blocked;
   return { status: "green", dungeonId: slug, output: path.relative(projectRoot, output).replace(/\\/g, "/") };
 }

scripts/dungeon-pipeline/run-all-wow-dungeons.mjs

@@ -45,6 +45,9 @@ function runNpm(script, argumentsList = []) {
 async function main() {
   if (options.has("--audit-only")) {
     await runNpm("dungeon:wow:audit");
+    await runNpm("dungeon:wow:functionality:audit");
+    await runNpm("dungeon:ascension:recovery:validate");
+    await runNpm("dungeon:wow:export-tool:test");
     await runNpm("dungeon:wow:test");
     return;
   }
@@ -63,8 +66,11 @@ async function main() {
   await runNpm("dungeon:catalog");
   await runNpm("dungeon:five-player:verify");
   await runNpm("dungeon:wow:audit");
+  await runNpm("dungeon:wow:functionality:audit");
+  await runNpm("dungeon:ascension:recovery:validate");
+  await runNpm("dungeon:wow:export-tool:test");
   await runNpm("dungeon:wow:test");
   if (options.has("--build")) await runNpm("build");
 }
 
-await main();
+await main();

scripts/dungeon-pipeline/validate-ascension-custom-dungeon-recovery.mjs

@@ -0,0 +1,300 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(scriptDirectory, "..", "..");
+const manifestPath = path.join(
+  projectRoot,
+  "dungeon-pipeline",
+  "ascension",
+  "ASCENSION_CUSTOM_DUNGEON_RECOVERY.json",
+);
+
+function fail(message) {
+  throw new Error(message);
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    fail(message);
+  }
+}
+
+function assertDeepEqual(actual, expected, message) {
+  assert(JSON.stringify(actual) === JSON.stringify(expected), message);
+}
+
+async function readJson(relativePath) {
+  const contents = await readFile(path.join(projectRoot, relativePath), "utf8");
+  return JSON.parse(contents);
+}
+
+function resolveDbcPath(manifest) {
+  const dbcArgumentIndex = process.argv.indexOf("--dbc");
+  if (dbcArgumentIndex !== -1) {
+    const value = process.argv[dbcArgumentIndex + 1];
+    assert(value, "--dbc requires a path");
+    return path.resolve(process.cwd(), value);
+  }
+
+  if (process.env.ASCENSION_SPELL_DBC) {
+    return path.resolve(process.env.ASCENSION_SPELL_DBC);
+  }
+
+  const source = manifest.sources.find(
+    (candidate) => candidate.id === "ascension-area52-spell-dbc",
+  );
+  assert(source?.pathHint, "Spell.dbc source path is missing from the manifest");
+  return path.resolve(projectRoot, source.pathHint);
+}
+
+function readCString(buffer, offset) {
+  const end = buffer.indexOf(0, offset);
+  assert(end !== -1, `Unterminated DBC string at byte ${offset}`);
+  return buffer.toString("utf8", offset, end);
+}
+
+async function validateSpellDbc(manifest) {
+  if (process.argv.includes("--skip-dbc")) {
+    return { skipped: true, reason: "requested with --skip-dbc" };
+  }
+
+  const source = manifest.sources.find(
+    (candidate) => candidate.id === "ascension-area52-spell-dbc",
+  );
+  assert(source, "Spell.dbc source metadata is missing");
+
+  const dbcPath = resolveDbcPath(manifest);
+  let buffer;
+  try {
+    buffer = await readFile(dbcPath);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return { skipped: true, reason: `not installed at ${dbcPath}` };
+    }
+    throw error;
+  }
+
+  const digest = createHash("sha256").update(buffer).digest("hex");
+  assert(digest === source.sha256, `Spell.dbc SHA-256 mismatch: ${digest}`);
+
+  const header = {
+    signature: buffer.toString("ascii", 0, 4),
+    recordCount: buffer.readUInt32LE(4),
+    fieldCount: buffer.readUInt32LE(8),
+    recordSize: buffer.readUInt32LE(12),
+    stringBlockSize: buffer.readUInt32LE(16),
+  };
+  assertDeepEqual(header, source.header, "Spell.dbc header does not match the manifest");
+
+  const expectedNames = new Map();
+  const summonLinks = new Map();
+  for (const dungeon of manifest.dungeons) {
+    for (const [spellId, name] of Object.entries(dungeon.sourceRecovery.spellRows)) {
+      expectedNames.set(Number(spellId), name);
+    }
+    for (const link of dungeon.sourceRecovery.summonLinks ?? []) {
+      const links = summonLinks.get(link.spellId) ?? [];
+      links.push({ ...link, mapId: dungeon.mapId });
+      summonLinks.set(link.spellId, links);
+    }
+  }
+
+  const recordStart = 20;
+  const stringStart = recordStart + header.recordCount * header.recordSize;
+  const expectedLength = stringStart + header.stringBlockSize;
+  assert(
+    expectedLength === buffer.length,
+    `Spell.dbc length mismatch: expected ${expectedLength}, got ${buffer.length}`,
+  );
+
+  const found = new Map();
+  for (let recordIndex = 0; recordIndex < header.recordCount; recordIndex += 1) {
+    const offset = recordStart + recordIndex * header.recordSize;
+    const spellId = buffer.readUInt32LE(offset);
+    if (!expectedNames.has(spellId)) {
+      continue;
+    }
+
+    const nameOffset = buffer.readUInt32LE(offset + 136 * 4);
+    found.set(spellId, {
+      name: readCString(buffer, stringStart + nameOffset),
+      offset,
+    });
+  }
+
+  for (const [spellId, expectedName] of expectedNames) {
+    const row = found.get(spellId);
+    assert(row, `Spell.dbc row ${spellId} is missing`);
+    assert(
+      row.name === expectedName,
+      `Spell.dbc row ${spellId} name mismatch: expected ${JSON.stringify(expectedName)}, got ${JSON.stringify(row.name)}`,
+    );
+  }
+
+  for (const [spellId, links] of summonLinks) {
+    const row = found.get(spellId);
+    assert(row, `Summon spell ${spellId} was not loaded`);
+    for (const link of links) {
+      const effectType = buffer.readUInt32LE(row.offset + (71 + link.effectIndex) * 4);
+      const entryId = buffer.readInt32LE(row.offset + (110 + link.effectIndex) * 4);
+      assert(
+        effectType === link.effectType,
+        `Map ${link.mapId} spell ${spellId} effect ${link.effectIndex} type mismatch: expected ${link.effectType}, got ${effectType}`,
+      );
+      assert(
+        entryId === link.entryId,
+        `Map ${link.mapId} spell ${spellId} effect ${link.effectIndex} entry mismatch: expected ${link.entryId}, got ${entryId}`,
+      );
+    }
+  }
+
+  return {
+    skipped: false,
+    path: dbcPath,
+    spellRows: found.size,
+    summonLinks: [...summonLinks.values()].flat().length,
+  };
+}
+
+function validateCatalogs(manifest, campaign, runtime, assets) {
+  assert(manifest.schemaVersion === 1, "Unsupported recovery manifest schema");
+  assert(manifest.status === "partial-authoritative-recovery", "Unexpected manifest status");
+  assertDeepEqual(
+    manifest.dungeons.map((dungeon) => dungeon.mapId),
+    [821, 908, 1781],
+    "Recovery manifest must contain exactly maps 821, 908, and 1781 in that order",
+  );
+
+  let spellRows = 0;
+  let summonLinks = 0;
+  for (const dungeon of manifest.dungeons) {
+    const definition = campaign.definitions.find(
+      (candidate) => candidate.mapId === dungeon.mapId,
+    );
+    assert(definition, `Campaign definition for map ${dungeon.mapId} is missing`);
+    assert(definition.id === dungeon.id, `Map ${dungeon.mapId} campaign ID drifted`);
+    assert(definition.title === dungeon.title, `Map ${dungeon.mapId} title drifted`);
+
+    const assetPackage = assets.packages.find(
+      (candidate) => candidate.mapId === dungeon.mapId,
+    );
+    assert(assetPackage, `Asset package for map ${dungeon.mapId} is missing`);
+    assert(
+      assetPackage.source.mapDirectory === dungeon.mapDirectory,
+      `Map ${dungeon.mapId} client map directory drifted`,
+    );
+    assert(
+      Object.values(assetPackage.source.checksums).includes(dungeon.environment.sourceHash),
+      `Map ${dungeon.mapId} source checksum drifted`,
+    );
+    for (const kind of ["player", "trash", "boss"]) {
+      const anchor = assetPackage.anchors.find((candidate) => candidate.kind === kind);
+      assert(anchor, `Map ${dungeon.mapId} ${kind} anchor is missing`);
+      assertDeepEqual(
+        anchor.position,
+        dungeon.environment.anchors[kind],
+        `Map ${dungeon.mapId} ${kind} anchor drifted`,
+      );
+    }
+
+    for (const encounter of dungeon.encounters) {
+      const runtimeEncounter = runtime.encounters.find(
+        (candidate) =>
+          candidate.encounterId === encounter.encounterId &&
+          candidate.mapIds.includes(dungeon.mapId) &&
+          candidate.modeIds.includes(encounter.modeId),
+      );
+      assert(
+        runtimeEncounter,
+        `Map ${dungeon.mapId} encounter ${encounter.encounterId} mode ${encounter.modeId} is missing`,
+      );
+      assert(
+        runtimeEncounter.name === encounter.name,
+        `Encounter ${encounter.encounterId} name drifted`,
+      );
+      assert(
+        runtimeEncounter.creatureId === encounter.creatureId,
+        `Encounter ${encounter.encounterId} creature ID drifted`,
+      );
+    }
+
+    const bossEntity = definition.entities[dungeon.currentRuntime.bossEntityId];
+    const bossCreatureId = dungeon.encounters[0].creatureId;
+    assert(bossEntity, `Map ${dungeon.mapId} current boss entity is missing`);
+    assert(
+      bossEntity.combat.serverEntry === bossCreatureId,
+      `Map ${dungeon.mapId} current boss server entry drifted`,
+    );
+
+    const generatedTrash = definition.staticSpawns.filter((spawn) =>
+      spawn.id.startsWith("generated-trash-"),
+    );
+    assert(
+      generatedTrash.length === dungeon.currentRuntime.proceduralTrashSpawnCount,
+      `Map ${dungeon.mapId} procedural trash count drifted`,
+    );
+    for (const proceduralEntity of dungeon.currentRuntime.proceduralMobEntries) {
+      const entity = definition.entities[proceduralEntity.entityId];
+      assert(entity, `Map ${dungeon.mapId} procedural entity ${proceduralEntity.entityId} is missing`);
+      assert(
+        entity.combat.serverEntry === proceduralEntity.serverEntry,
+        `Map ${dungeon.mapId} procedural entity ${proceduralEntity.entityId} server entry drifted`,
+      );
+    }
+
+    const rowIds = new Set(
+      Object.keys(dungeon.sourceRecovery.spellRows).map((spellId) => Number(spellId)),
+    );
+    spellRows += rowIds.size;
+    for (const [family, familyRows] of Object.entries(dungeon.sourceRecovery.families)) {
+      for (const spellId of familyRows) {
+        assert(
+          rowIds.has(spellId),
+          `Map ${dungeon.mapId} family ${family} references absent spell ${spellId}`,
+        );
+      }
+    }
+
+    for (const link of dungeon.sourceRecovery.summonLinks ?? []) {
+      summonLinks += 1;
+      assert(rowIds.has(link.spellId), `Map ${dungeon.mapId} summon spell ${link.spellId} is absent`);
+      const targetCollection = link.targetKind === "gameobject" ? dungeon.gameObjects : dungeon.entities;
+      assert(
+        targetCollection?.some((target) => target.entryId === link.entryId),
+        `Map ${dungeon.mapId} summon target ${link.targetKind} ${link.entryId} is absent`,
+      );
+    }
+
+    assert(
+      dungeon.adaptation.mustBeCustomAuthored.length > 0,
+      `Map ${dungeon.mapId} must explicitly list custom-authored gaps`,
+    );
+  }
+
+  return { dungeons: manifest.dungeons.length, spellRows, summonLinks };
+}
+
+const manifest = await readJson(
+  "dungeon-pipeline/ascension/ASCENSION_CUSTOM_DUNGEON_RECOVERY.json",
+);
+const campaign = await readJson("src/game/generated/dungeonCampaignCatalog.json");
+const runtime = await readJson("src/game/generated/manastormRuntimeCatalog.json");
+const assets = await readJson("src/game/generated/manastormAssetPackages.json");
+
+const catalogResult = validateCatalogs(manifest, campaign, runtime, assets);
+const dbcResult = await validateSpellDbc(manifest);
+
+console.log(
+  `Validated ${catalogResult.dungeons} Ascension custom dungeons, ${catalogResult.spellRows} recovered spell rows, and ${catalogResult.summonLinks} summon links.`,
+);
+if (dbcResult.skipped) {
+  console.log(`Spell.dbc verification skipped: ${dbcResult.reason}.`);
+} else {
+  console.log(
+    `Spell.dbc verified (${dbcResult.spellRows} rows, ${dbcResult.summonLinks} summon links): ${dbcResult.path}`,
+  );
+}

scripts/dungeon-pipeline/wow-export-tool.mjs

@@ -0,0 +1,125 @@
+import { spawn as spawnChild } from "node:child_process";
+import { stat } from "node:fs/promises";
+import path from "node:path";
+
+export const WOW_EXPORT_AUTOMATION_VERSION = "0.2.19";
+export const WOW_EXPORT_REQUIRED_FLAGS = Object.freeze([
+  "--disable-auto-update",
+  "--discover-dungeon",
+  "--export-dungeon",
+  "--export-creatures",
+]);
+
+export function defaultWowExportExecutable(projectRoot) {
+  return path.resolve(
+    projectRoot,
+    `../wow335a/dungeon-export-work/tools/wow.export-${WOW_EXPORT_AUTOMATION_VERSION}/wow.export.exe`,
+  );
+}
+
+async function inspectCandidate(file, statFile) {
+  try {
+    const info = await statFile(file);
+    return info.isFile()
+      ? { usable: true, reason: null }
+      : { usable: false, reason: "path exists but is not a file" };
+  } catch (error) {
+    if (error?.code === "ENOENT") return { usable: false, reason: "file does not exist" };
+    return { usable: false, reason: `cannot inspect file (${error?.code ?? error?.message ?? "unknown error"})` };
+  }
+}
+
+function unavailableMessage(checks, configured) {
+  const checked = checks.map(({ label, file, reason }) => `  - ${label}: ${file} (${reason})`).join("\n");
+  const selection = configured
+    ? "WOW_EXPORT_BIN is set, so the default location was not used. Correct or unset that variable."
+    : "Restore the patched portable bundle at the default location, or set WOW_EXPORT_BIN to its exact executable path.";
+  return [
+    "HealerMan's patched wow.export automation bridge is unavailable.",
+    `Required build: wow.export ${WOW_EXPORT_AUTOMATION_VERSION} with these automation flags: ${WOW_EXPORT_REQUIRED_FLAGS.join(", ")}.`,
+    "Checked:",
+    checked,
+    selection,
+    "A stock GUI-only wow.export executable is not a drop-in replacement unless it includes the HealerMan automation patch.",
+    "No export was started and no placeholder assets were created.",
+  ].join("\n");
+}
+
+export class WowExportUnavailableError extends Error {
+  constructor(checks, configured) {
+    super(unavailableMessage(checks, configured));
+    this.name = "WowExportUnavailableError";
+    this.code = "WOW_EXPORT_AUTOMATION_UNAVAILABLE";
+    this.checks = checks;
+    this.requiredVersion = WOW_EXPORT_AUTOMATION_VERSION;
+    this.requiredFlags = [...WOW_EXPORT_REQUIRED_FLAGS];
+  }
+}
+
+export async function resolveWowExportExecutable({
+  projectRoot,
+  environment = process.env,
+  statFile = stat,
+} = {}) {
+  if (!projectRoot) throw new TypeError("resolveWowExportExecutable requires projectRoot.");
+  const configuredValue = environment.WOW_EXPORT_BIN?.trim();
+  const candidates = configuredValue
+    ? [{ label: "WOW_EXPORT_BIN", file: path.resolve(projectRoot, configuredValue) }]
+    : [{ label: "default portable path", file: defaultWowExportExecutable(projectRoot) }];
+  const checks = [];
+  for (const candidate of candidates) {
+    const inspection = await inspectCandidate(candidate.file, statFile);
+    if (inspection.usable) return candidate.file;
+    checks.push({ ...candidate, reason: inspection.reason });
+  }
+  throw new WowExportUnavailableError(checks, Boolean(configuredValue));
+}
+
+function exporterFailureMessage(executable, argumentsList, detail) {
+  const operation = argumentsList.find((argument) => argument.startsWith("--")) ?? "unknown operation";
+  return [
+    `wow.export automation failed during ${operation}: ${detail}`,
+    `Executable: ${executable}`,
+    `Required automation flags: ${WOW_EXPORT_REQUIRED_FLAGS.join(", ")}.`,
+    "Verify that WOW_EXPORT_BIN points to the HealerMan-patched build, not the stock GUI-only release.",
+    "No placeholder assets were created.",
+  ].join("\n");
+}
+
+export async function runWowExporter(argumentsList, {
+  projectRoot,
+  environment = process.env,
+  statFile = stat,
+  spawn = spawnChild,
+} = {}) {
+  const executable = await resolveWowExportExecutable({ projectRoot, environment, statFile });
+  await new Promise((resolve, reject) => {
+    const child = spawn(executable, ["--disable-auto-update", ...argumentsList], {
+      cwd: path.dirname(executable),
+      stdio: "inherit",
+      windowsHide: true,
+    });
+    let settled = false;
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    };
+    child.once("error", (error) => fail(new Error(exporterFailureMessage(
+      executable,
+      argumentsList,
+      `process could not start (${error?.code ?? error?.message ?? "unknown error"})`,
+    ))));
+    child.once("exit", (code, signal) => {
+      if (settled) return;
+      settled = true;
+      if (code === 0) resolve();
+      else reject(new Error(exporterFailureMessage(
+        executable,
+        argumentsList,
+        signal ? `process exited after signal ${signal}` : `process exited with code ${code}`,
+      )));
+    });
+  });
+  return executable;
+}

scripts/dungeon-pipeline/wow-export-tool.test.mjs

@@ -0,0 +1,125 @@
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import path from "node:path";
+import test from "node:test";
+import {
+  defaultWowExportExecutable,
+  resolveWowExportExecutable,
+  runWowExporter,
+  WOW_EXPORT_REQUIRED_FLAGS,
+} from "./wow-export-tool.mjs";
+
+const projectRoot = path.resolve("fixture/HealerMan");
+const fileInfo = { isFile: () => true };
+
+test("resolveWowExportExecutable uses the versioned portable path by default", async () => {
+  const expected = defaultWowExportExecutable(projectRoot);
+  const inspected = [];
+  const resolved = await resolveWowExportExecutable({
+    projectRoot,
+    environment: {},
+    statFile: async (file) => {
+      inspected.push(file);
+      return fileInfo;
+    },
+  });
+  assert.equal(resolved, expected);
+  assert.deepEqual(inspected, [expected]);
+});
+
+test("resolveWowExportExecutable honors an explicit relative WOW_EXPORT_BIN", async () => {
+  const expected = path.resolve(projectRoot, "tools/patched/wow.export.exe");
+  const resolved = await resolveWowExportExecutable({
+    projectRoot,
+    environment: { WOW_EXPORT_BIN: "tools/patched/wow.export.exe" },
+    statFile: async (file) => {
+      assert.equal(file, expected);
+      return fileInfo;
+    },
+  });
+  assert.equal(resolved, expected);
+});
+
+test("resolveWowExportExecutable rejects a directory with actionable diagnostics", async () => {
+  const configured = path.resolve(projectRoot, "tools/not-an-executable");
+  await assert.rejects(
+    resolveWowExportExecutable({
+      projectRoot,
+      environment: { WOW_EXPORT_BIN: configured },
+      statFile: async () => ({ isFile: () => false }),
+    }),
+    (error) => {
+      assert.equal(error.code, "WOW_EXPORT_AUTOMATION_UNAVAILABLE");
+      assert.match(error.message, /path exists but is not a file/);
+      assert.match(error.message, /Correct or unset that variable/);
+      assert.match(error.message, /No export was started and no placeholder assets were created/);
+      for (const flag of WOW_EXPORT_REQUIRED_FLAGS) assert.ok(error.message.includes(flag));
+      return true;
+    },
+  );
+});
+
+test("resolveWowExportExecutable reports the exact missing default path", async () => {
+  const expected = defaultWowExportExecutable(projectRoot);
+  await assert.rejects(
+    resolveWowExportExecutable({
+      projectRoot,
+      environment: {},
+      statFile: async () => {
+        const error = new Error("missing");
+        error.code = "ENOENT";
+        throw error;
+      },
+    }),
+    (error) => {
+      assert.ok(error.message.includes(expected));
+      assert.match(error.message, /set WOW_EXPORT_BIN/);
+      assert.match(error.message, /stock GUI-only wow\.export executable is not a drop-in replacement/);
+      return true;
+    },
+  );
+});
+
+test("runWowExporter supplies the non-updating automation invocation", async () => {
+  const executable = path.resolve(projectRoot, "tools/wow.export.exe");
+  let invocation;
+  const spawn = (file, args, options) => {
+    invocation = { file, args, options };
+    const child = new EventEmitter();
+    queueMicrotask(() => child.emit("exit", 0, null));
+    return child;
+  };
+  const result = await runWowExporter(["--export-dungeon", "--recipe", "fixture.json"], {
+    projectRoot,
+    environment: { WOW_EXPORT_BIN: executable },
+    statFile: async () => fileInfo,
+    spawn,
+  });
+  assert.equal(result, executable);
+  assert.deepEqual(invocation.args, ["--disable-auto-update", "--export-dungeon", "--recipe", "fixture.json"]);
+  assert.equal(invocation.options.cwd, path.dirname(executable));
+  assert.equal(invocation.options.windowsHide, true);
+});
+
+test("runWowExporter identifies an incompatible executable after a failed launch", async () => {
+  const executable = path.resolve(projectRoot, "tools/wow.export.exe");
+  const spawn = () => {
+    const child = new EventEmitter();
+    queueMicrotask(() => child.emit("exit", 2, null));
+    return child;
+  };
+  await assert.rejects(
+    runWowExporter(["--export-creatures"], {
+      projectRoot,
+      environment: { WOW_EXPORT_BIN: executable },
+      statFile: async () => fileInfo,
+      spawn,
+    }),
+    (error) => {
+      assert.match(error.message, /process exited with code 2/);
+      assert.match(error.message, /HealerMan-patched build/);
+      assert.match(error.message, /No placeholder assets were created/);
+      return true;
+    },
+  );
+});

scripts/manastorm-assets/validate-package-glbs.cjs

@@ -36,6 +36,9 @@ async function main() {
         && hasBasisu
         && /^\/images\/\d+\/mimeType$/.test(issue.pointer ?? "")
         && issue.message.includes("'image/ktx2'")) return false;
+      if (issue.code === "IMAGE_UNRECOGNIZED_FORMAT"
+        && hasBasisu
+        && /^\/images\/\d+$/.test(issue.pointer ?? "")) return false;
       return true;
     });
     rows.push({

scripts/release_manager.py

@@ -75,6 +75,18 @@ class ReleaseVersion:
     version_code: int
 
 
+def full_release_checks(npm: str) -> tuple[tuple[list[str], str], ...]:
+    """Commands that must succeed before a release can be staged."""
+    return (
+        ([npm, "run", "content:test"], "Content tests"),
+        ([npm, "run", "server:test"], "Server tests"),
+        ([npm, "test"], "Application tests"),
+        ([npm, "run", "content:publish"], "Publish verified 54-dungeon content manifest"),
+        ([npm, "run", "build"], "Production build"),
+        ([npm, "run", "android:sync"], "Android web build and Capacitor sync"),
+    )
+
+
 def parse_semver(value: str) -> tuple[int, int, int]:
     match = SEMVER_PATTERN.fullmatch(value.strip())
     if not match:
@@ -239,11 +251,13 @@ def validate_release_candidates(project_root: Path = PROJECT_ROOT) -> list[str]:
                 cwd=project_root,
                 env=environment,
                 stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
+                stderr=subprocess.PIPE,
                 check=False,
             )
             if result.returncode != 0:
-                output = result.stdout.decode("utf-8", errors="replace").strip()
+                output = b"\n".join((result.stdout, result.stderr)).decode(
+                    "utf-8", errors="replace"
+                ).strip()
                 raise ReleaseError(
                     f"Release-candidate Git check failed ({result.returncode}): "
                     f"git {' '.join(args)}\n{output}"
@@ -269,11 +283,15 @@ def validate_release_candidates(project_root: Path = PROJECT_ROOT) -> list[str]:
             encoding="utf-8",
             errors="replace",
             stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
+            stderr=subprocess.PIPE,
             check=False,
         )
         if whitespace_result.returncode != 0:
-            detail = whitespace_result.stdout.strip()
+            detail = "\n".join(
+                part.strip()
+                for part in (whitespace_result.stdout, whitespace_result.stderr)
+                if part.strip()
+            )
             raise ReleaseError(
                 "Release-candidate whitespace check failed. This check includes "
                 f"tracked and untracked files:\n{detail}"
@@ -1096,14 +1114,7 @@ def launch_gui(*, smoke_test: bool = False) -> int:
                     f"Recorded Android version {version.version_name} / {version.version_code}."
                 )
 
-                checks = (
-                    ([npm, "run", "content:test"], "Content tests"),
-                    ([npm, "run", "server:test"], "Server tests"),
-                    ([npm, "test"], "Application tests"),
-                    ([npm, "run", "build"], "Production build"),
-                    ([npm, "run", "android:sync"], "Android web build and Capacitor sync"),
-                )
-                for command, label in checks:
+                for command, label in full_release_checks(npm):
                     self._run_command(command, label)
                 self._run_command(["git", "add", "-A"], "Stage release")
                 staged = True

scripts/release_manager_test.py

@@ -47,6 +47,13 @@ class SafetyTests(unittest.TestCase):
         self.assertIn("pull --ff-only", block)
         self.assertIn('test "$ACTUAL_COMMIT" = "$EXPECTED_COMMIT"', block)
 
+    def test_full_release_publishes_verified_content_before_building(self):
+        checks = release_manager.full_release_checks("npm")
+        commands = [command for command, _label in checks]
+        publish_index = commands.index(["npm", "run", "content:publish"])
+        self.assertLess(publish_index, commands.index(["npm", "run", "build"]))
+        self.assertLess(publish_index, commands.index(["npm", "run", "android:sync"]))
+
 
 class ReleaseCandidateTests(unittest.TestCase):
     def test_checks_untracked_files_without_changing_the_real_index(self):

scripts/runewaker-pipeline/audit-material-alpha.mjs

@@ -0,0 +1,262 @@
+import { createHash } from "node:crypto";
+import { readFile, readdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import sharp from "sharp";
+
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const recipeDirectory = path.join(projectRoot, "scripts", "runewaker-pipeline", "recipes");
+const workRoot = path.join(projectRoot, "runewaker-export-work");
+const shippingRoot = path.join(projectRoot, "src", "assets", "game", "dungeons");
+const resourceCacheRoot = path.join(workRoot, "resource-cache");
+const requestedSlugs = new Set(process.argv.slice(2).filter((value) => !value.startsWith("--")));
+const fix = process.argv.includes("--fix");
+const alphaClassifications = new Map();
+let resourceTextureIndex;
+
+async function exists(file) {
+  try {
+    await stat(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function parseGlb(buffer, file) {
+  if (buffer.length < 20 || buffer.toString("utf8", 0, 4) !== "glTF") {
+    throw new Error(`${file} is not a GLB file.`);
+  }
+  const chunks = [];
+  let json;
+  let offset = 12;
+  while (offset + 8 <= buffer.length) {
+    const chunkLength = buffer.readUInt32LE(offset);
+    const chunkType = buffer.readUInt32LE(offset + 4);
+    const chunkStart = offset + 8;
+    const chunkEnd = chunkStart + chunkLength;
+    if (chunkEnd > buffer.length) break;
+    const data = buffer.subarray(chunkStart, chunkEnd);
+    chunks.push({ type: chunkType, data });
+    if (chunkType === 0x4e4f534a) {
+      json = JSON.parse(data.toString("utf8").replace(/\0+$/u, "").trim());
+    }
+    offset = chunkEnd;
+  }
+  if (!json) throw new Error(`${file} does not contain a JSON chunk.`);
+  return { json, chunks };
+}
+
+function serializeGlb(source, json, chunks) {
+  const encodedJson = Buffer.from(JSON.stringify(json));
+  const paddedJson = Buffer.alloc(Math.ceil(encodedJson.length / 4) * 4, 0x20);
+  encodedJson.copy(paddedJson);
+  const updatedChunks = chunks.map((chunk) => (
+    chunk.type === 0x4e4f534a ? { ...chunk, data: paddedJson } : chunk
+  ));
+  const totalLength = 12 + updatedChunks.reduce((total, chunk) => total + 8 + chunk.data.length, 0);
+  const output = Buffer.alloc(totalLength);
+  source.copy(output, 0, 0, 12);
+  output.writeUInt32LE(totalLength, 8);
+  let offset = 12;
+  for (const chunk of updatedChunks) {
+    output.writeUInt32LE(chunk.data.length, offset);
+    output.writeUInt32LE(chunk.type, offset + 4);
+    chunk.data.copy(output, offset + 8);
+    offset += 8 + chunk.data.length;
+  }
+  return output;
+}
+
+async function classifyAlpha(file) {
+  if (alphaClassifications.has(file)) return alphaClassifications.get(file);
+  const metadata = await sharp(file).metadata();
+  if (!metadata.hasAlpha) {
+    alphaClassifications.set(file, "opaque");
+    return "opaque";
+  }
+
+  const { data, info } = await sharp(file).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  let hasTransparentPixel = false;
+  for (let offset = 3; offset < data.length; offset += info.channels) {
+    const alpha = data[offset];
+    if (alpha === 255) continue;
+    hasTransparentPixel = true;
+    if (alpha > 0) {
+      alphaClassifications.set(file, "blend");
+      return "blend";
+    }
+  }
+  const role = hasTransparentPixel ? "cutout" : "opaque";
+  alphaClassifications.set(file, role);
+  return role;
+}
+
+function sourceImageIndex(texture) {
+  return texture?.extensions?.KHR_texture_basisu?.source ?? texture?.source;
+}
+
+async function indexResourceTextures() {
+  if (resourceTextureIndex) return resourceTextureIndex;
+  resourceTextureIndex = new Map();
+  if (!(await exists(resourceCacheRoot))) return resourceTextureIndex;
+  const cacheDirectories = (await readdir(resourceCacheRoot, { withFileTypes: true }))
+    .filter((entry) => entry.isDirectory())
+    .sort((left, right) => left.name.localeCompare(right.name));
+  for (const cacheDirectory of cacheDirectories) {
+    const textureDirectory = path.join(resourceCacheRoot, cacheDirectory.name, "prepared", "textures");
+    if (!(await exists(textureDirectory))) continue;
+    for (const texture of (await readdir(textureDirectory)).filter((file) => file.endsWith(".png")).sort()) {
+      if (!resourceTextureIndex.has(texture)) {
+        resourceTextureIndex.set(texture, path.join(textureDirectory, texture));
+      }
+    }
+  }
+  return resourceTextureIndex;
+}
+
+async function resolveSourceTexture(localDirectory, imageName) {
+  const fileName = `${imageName}.png`;
+  const localFile = path.join(localDirectory, fileName);
+  if (await exists(localFile)) return localFile;
+  return (await indexResourceTextures()).get(fileName);
+}
+
+function sha256(buffer) {
+  return createHash("sha256").update(buffer).digest("hex");
+}
+
+async function refreshShippingMetadata(metadataFile, metadata, visualArtifact, visualBuffer) {
+  visualArtifact.size = visualBuffer.length;
+  visualArtifact.sha256 = sha256(visualBuffer);
+  await writeFile(metadataFile, `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+
+  const optimizationFile = path.join(path.dirname(metadataFile), "optimization-report.json");
+  if (!(await exists(optimizationFile))) return;
+  const optimization = JSON.parse(await readFile(optimizationFile, "utf8"));
+  if (optimization.optimized) {
+    optimization.optimized.size = visualBuffer.length;
+    if (Object.hasOwn(optimization.optimized, "checksum")) {
+      optimization.optimized.checksum = sha256(visualBuffer);
+    }
+  }
+  await writeFile(optimizationFile, `${JSON.stringify(optimization, null, 2)}\n`, "utf8");
+}
+
+async function auditDungeon(recipe) {
+  const slug = recipe.slug;
+  const metadataFile = path.join(shippingRoot, slug, "import-metadata.json");
+  const preparedTextureDirectory = path.join(workRoot, slug, "prepared", "textures");
+  if (!(await exists(metadataFile))) {
+    return { slug, status: "incomplete", problems: [`Missing ${path.relative(projectRoot, metadataFile)}`] };
+  }
+  if (!(await exists(preparedTextureDirectory))) {
+    return {
+      slug,
+      status: "incomplete",
+      problems: [`Missing ${path.relative(projectRoot, preparedTextureDirectory)}`],
+    };
+  }
+
+  const metadata = JSON.parse(await readFile(metadataFile, "utf8"));
+  const visualArtifact = (metadata.assets ?? metadata.artifacts ?? [])
+    .find((artifact) => artifact.role === "visual");
+  const visualFile = path.join(shippingRoot, slug, visualArtifact?.fileName ?? `${slug}-visual.glb`);
+  if (!(await exists(visualFile))) {
+    return { slug, status: "incomplete", problems: [`Missing ${path.relative(projectRoot, visualFile)}`] };
+  }
+
+  const sourceGlb = await readFile(visualFile);
+  const { json: gltf, chunks } = parseGlb(sourceGlb, visualFile);
+  const materialResults = [];
+  const missingTextures = [];
+  for (const [materialIndex, material] of (gltf.materials ?? []).entries()) {
+    const textureIndex = material.pbrMetallicRoughness?.baseColorTexture?.index;
+    const texture = gltf.textures?.[textureIndex];
+    const image = gltf.images?.[sourceImageIndex(texture)];
+    if (!image?.name) continue;
+
+    const sourceFile = await resolveSourceTexture(preparedTextureDirectory, image.name);
+    if (!sourceFile) {
+      missingTextures.push(`${image.name}.png`);
+      continue;
+    }
+    const expectedRole = await classifyAlpha(sourceFile);
+    const expectedAlphaMode = expectedRole === "blend" ? "BLEND" : expectedRole === "cutout" ? "MASK" : "OPAQUE";
+    const actualAlphaMode = material.alphaMode ?? "OPAQUE";
+    const actualRole = material.extras?.semanticRole ?? "missing";
+    materialResults.push({
+      materialIndex,
+      material: material.name ?? `material-${materialIndex}`,
+      texture: image.name,
+      expectedRole,
+      expectedAlphaMode,
+      actualRole,
+      actualAlphaMode,
+      matches: expectedAlphaMode === actualAlphaMode && expectedRole === actualRole,
+    });
+    if (fix && (expectedAlphaMode !== actualAlphaMode || expectedRole !== actualRole)) {
+      if (expectedAlphaMode === "OPAQUE") delete material.alphaMode;
+      else material.alphaMode = expectedAlphaMode;
+      if (expectedAlphaMode === "MASK") material.alphaCutoff = 0.5;
+      else delete material.alphaCutoff;
+      material.extras = { ...(material.extras ?? {}), semanticRole: expectedRole };
+    }
+  }
+
+  const mismatches = materialResults.filter((result) => !result.matches);
+  const alphaMaterials = materialResults.filter((result) => result.expectedRole !== "opaque");
+  const problems = [
+    ...mismatches.map((result) =>
+      `${result.texture}: expected ${result.expectedAlphaMode}/${result.expectedRole}, got ${result.actualAlphaMode}/${result.actualRole}`,
+    ),
+    ...[...new Set(missingTextures)].map((file) => `Missing prepared source texture ${file}`),
+  ];
+  if (fix && mismatches.length > 0 && missingTextures.length === 0) {
+    const visualBuffer = serializeGlb(sourceGlb, gltf, chunks);
+    await writeFile(visualFile, visualBuffer);
+    if (visualArtifact) {
+      await refreshShippingMetadata(metadataFile, metadata, visualArtifact, visualBuffer);
+    }
+  }
+  return {
+    slug,
+    status: problems.length === 0 ? "green" : fix && missingTextures.length === 0 ? "repaired" : "mismatch",
+    materials: materialResults.length,
+    alphaMaterials: alphaMaterials.map(({ material, texture, expectedAlphaMode }) => ({
+      material,
+      texture,
+      alphaMode: expectedAlphaMode,
+    })),
+    mismatches,
+    problems,
+  };
+}
+
+const recipeFiles = (await readdir(recipeDirectory))
+  .filter((file) => file.endsWith(".json") && !file.endsWith("-population.json"))
+  .sort();
+const recipes = [];
+for (const recipeFile of recipeFiles) {
+  const recipe = JSON.parse(await readFile(path.join(recipeDirectory, recipeFile), "utf8"));
+  if (!recipe.slug || recipe.slug === "runewaker-player-avatars") continue;
+  if (requestedSlugs.size > 0 && !requestedSlugs.has(recipe.slug)) continue;
+  recipes.push(recipe);
+}
+
+const results = [];
+for (const recipe of recipes) {
+  results.push(await auditDungeon(recipe));
+}
+
+const failures = results.filter((result) => !["green", "repaired"].includes(result.status));
+const report = {
+  schemaVersion: 1,
+  dungeonCount: results.length,
+  status: failures.length === 0 ? fix ? "repaired" : "green" : "mismatch",
+  failureCount: failures.length,
+  alphaDungeonCount: results.filter((result) => result.alphaMaterials?.length > 0).length,
+  results,
+};
+console.log(JSON.stringify(report, null, 2));
+if (failures.length > 0) process.exitCode = 1;

scripts/runewaker-pipeline/blender/convert-runewaker.py

@@ -6,6 +6,7 @@ Expected invocation:
 """
 from __future__ import annotations
 
+from array import array
 import json
 import math
 import os
@@ -111,6 +112,69 @@ def material_image_key(material: bpy.types.Material) -> str:
     return f"material:{material.name.casefold()}"
 
 
+def material_image(material: bpy.types.Material) -> bpy.types.Image | None:
+    if not material.use_nodes or material.node_tree is None:
+        return None
+    for node in material.node_tree.nodes:
+        if node.type == "TEX_IMAGE" and node.image is not None:
+            return node.image
+    return None
+
+
+def image_alpha_role(image: bpy.types.Image | None) -> str:
+    """Classify source alpha without turning fully opaque RGBA textures translucent."""
+    if image is None or image.channels < 4:
+        return "opaque"
+    pixels = array("f", [0.0]) * len(image.pixels)
+    image.pixels.foreach_get(pixels)
+    alpha_values = pixels[3::image.channels]
+    if min(alpha_values, default=1.0) >= 0.999:
+        return "opaque"
+    if any(0.001 < alpha < 0.999 for alpha in alpha_values):
+        return "blend"
+    return "cutout"
+
+
+def preserve_material_alpha(material: bpy.types.Material) -> str:
+    image = material_image(material)
+    role = image_alpha_role(image)
+    if role == "opaque" or material.node_tree is None:
+        return role
+
+    image_node = next(
+        node
+        for node in material.node_tree.nodes
+        if node.type == "TEX_IMAGE" and node.image == image
+    )
+    principled = next(
+        (node for node in material.node_tree.nodes if node.type == "BSDF_PRINCIPLED"),
+        None,
+    )
+    if principled is None:
+        return role
+    alpha_output = image_node.outputs.get("Alpha")
+    alpha_input = principled.inputs.get("Alpha")
+    if alpha_output is None or alpha_input is None:
+        return role
+
+    if role == "blend":
+        if not alpha_input.is_linked:
+            material.node_tree.links.new(alpha_output, alpha_input)
+        material.blend_method = "BLEND"
+        if hasattr(material, "surface_render_method"):
+            material.surface_render_method = "BLENDED"
+    else:
+        alpha_clip = material.node_tree.nodes.new("ShaderNodeMath")
+        alpha_clip.name = "RuneWaker Alpha Clip"
+        alpha_clip.operation = "GREATER_THAN"
+        alpha_clip.inputs[1].default_value = 0.5
+        material.node_tree.links.new(alpha_output, alpha_clip.inputs[0])
+        material.node_tree.links.new(alpha_clip.outputs[0], alpha_input)
+        material.blend_method = "CLIP"
+        material.alpha_threshold = 0.5
+    return role
+
+
 def deduplicate_materials(objects: list[bpy.types.Object]) -> dict[str, int]:
     canonical: dict[str, bpy.types.Material] = {}
     replacements = 0
@@ -126,7 +190,7 @@ def deduplicate_materials(objects: list[bpy.types.Object]) -> dict[str, int]:
                     replacements += 1
             else:
                 canonical[key] = material
-                material["semanticRole"] = "opaque"
+                material["semanticRole"] = preserve_material_alpha(material)
                 material["sourceFormat"] = "RuneWaker DDS"
     return {"unique": len(canonical), "replacements": replacements}
 

scripts/runewaker-pipeline/build-environment.mjs

@@ -241,6 +241,7 @@ async function cachedResourceAsset(resourceRecord) {
     throw new Error("source ROS is missing: " + projectPath(sourceFile));
   }
   const sourceSha256 = await sha256(sourceFile);
+  const converterSha256 = await sha256(blenderScript);
   const cacheRoot = path.join(resourceCacheDirectory, resourceRecord.cacheKey);
   const raw = path.join(cacheRoot, "raw");
   const prepared = path.join(cacheRoot, "prepared");
@@ -253,6 +254,7 @@ async function cachedResourceAsset(resourceRecord) {
       .map((file) => path.join(cacheRoot, file));
     if (cached.source?.resource === resourceRecord.normalizedResource
       && cached.source?.sha256 === sourceSha256
+      && cached.toolchain?.converterSha256 === converterSha256
       && cached.coordinateSystem?.metersPerSourceUnit === recipe.coordinateSystem.metersPerSourceUnit
       && (await Promise.all(outputs.map(exists))).every(Boolean)) {
       return {
@@ -300,6 +302,9 @@ async function cachedResourceAsset(resourceRecord) {
       nativeBridge: recipe.coordinateSystem.nativeBridge,
       metersPerSourceUnit: recipe.coordinateSystem.metersPerSourceUnit,
     },
+    toolchain: {
+      converterSha256,
+    },
     visual: {
       file: path.relative(
         cacheRoot,

src/App.tsx

@@ -6,8 +6,14 @@ import { useManastormAdminStore } from "./game/manastormAdminStore";
 import { useAuthoritativeDualScreenSync, useForcedThorDisplays } from "./platform/useThorDualScreen";
 import { LoginScreen } from "./ui/LoginScreen";
 import { OnlineGroupCoordinator } from "./app/OnlineGroupCoordinator";
+import { preloadTalentGameplayResources } from "./ui/talentGameplayResources";
+import {
+  getLoadedGameRuntime,
+  loadGameRuntime,
+  preloadSharedGameplayResources,
+} from "./ui/gameplayResources";
 
-const GameRuntime = lazy(() => import("./GameRuntime"));
+const GameRuntime = lazy(loadGameRuntime);
 const CharacterCreateScreen = lazy(() => import("./ui/CharacterCreateScreen").then((module) => ({ default: module.CharacterCreateScreen })));
 const CharacterSelectScreen = lazy(() => import("./ui/CharacterSelectScreen").then((module) => ({ default: module.CharacterSelectScreen })));
 const ClassHallScreen = lazy(() => import("./ui/ClassHallScreen").then((module) => ({ default: module.ClassHallScreen })));
@@ -32,7 +38,11 @@ function RuntimeCatalogGate({ children }: { readonly children: ReactNode }) {
     if (definition.mode === "conquest") return [...BASE_CLASS_IDS, character.classId];
     return [character.classId, ...(character.secondaryClassId ? [character.secondaryClassId] : [])];
   }, [character]);
+  const talentClassId = character && !character.classId.startsWith("rom-")
+    ? character.classId
+    : null;
   const requestKey = classIds.join(":");
+  const originalMediaEnabled = useShellStore((state) => state.combatPresentationSettings.originalMediaEnabled);
   const [loadedKey, setLoadedKey] = useState("");
   const [failedKey, setFailedKey] = useState("");
 
@@ -40,13 +50,17 @@ function RuntimeCatalogGate({ children }: { readonly children: ReactNode }) {
     if (!requestKey) return;
     let active = true;
     setFailedKey("");
-    void preloadAbilityCatalogsForClasses(classIds).then(() => {
+    void Promise.all([
+      preloadAbilityCatalogsForClasses(classIds),
+      talentClassId ? preloadTalentGameplayResources(talentClassId) : Promise.resolve(),
+      preloadSharedGameplayResources(originalMediaEnabled),
+    ]).then(() => {
       if (active) setLoadedKey(requestKey);
     }).catch(() => {
       if (active) setFailedKey(requestKey);
     });
     return () => { active = false; };
-  }, [classIds, requestKey]);
+  }, [classIds, originalMediaEnabled, requestKey, talentClassId]);
 
   if (!requestKey || loadedKey === requestKey) return children;
   if (failedKey === requestKey) {
@@ -61,6 +75,7 @@ export default function App() {
   const phase = useShellStore((state) => state.phase);
   const session = useShellStore((state) => state.session);
   const refreshManastormConfig = useManastormAdminStore((state) => state.refresh);
+  const PreloadedGameRuntime = getLoadedGameRuntime();
 
   useEffect(() => {
     void refreshManastormConfig(session);
@@ -77,7 +92,9 @@ export default function App() {
   else if (phase === "arenas") screen = <Suspense fallback={<ShellTransition />}><ArenaSelectScreen /></Suspense>;
   else if (phase === "arena-game") screen = <Suspense fallback={<ShellTransition />}><ArenaRuntime /></Suspense>;
   else if (phase === "gm-admin") screen = <Suspense fallback={<ShellTransition />}><GmAdminScreen /></Suspense>;
-  else if (phase === "game") screen = <Suspense fallback={<ShellTransition />}><GameRuntime /></Suspense>;
+  else if (phase === "game") screen = PreloadedGameRuntime
+    ? <PreloadedGameRuntime />
+    : <Suspense fallback={<ShellTransition />}><GameRuntime /></Suspense>;
   const requiresRuntimeCatalog = !["login", "characters", "create-character"].includes(phase);
   return <><OnlineGroupCoordinator />{requiresRuntimeCatalog ? <RuntimeCatalogGate>{screen}</RuntimeCatalogGate> : screen}</>;
 }

src/GameRuntime.tsx

@@ -1,4 +1,5 @@
 import { useEffect } from "react";
+import "./ui/uiLayout.css";
 import { DualDisplayFrame } from "./components/DualDisplayFrame";
 import { installInput, releasePointerLock } from "./game/inputManager";
 import { CombatBridge } from "./game/CombatBridge";
@@ -26,12 +27,27 @@ import { DungeonRunCheckpointBridge } from "./game/DungeonRunCheckpointBridge";
 import { DungeonEncounterEffectBridge } from "./game/DungeonEncounterEffectBridge";
 import { interactWithActiveDungeonObject } from "./game/dungeonWorldInteraction";
 import { DungeonInteractionPrompt } from "./ui/DungeonInteractionPrompt";
+import { UiLayoutEditor } from "./ui/UiLayoutEditor";
+import { EditableHudElement } from "./ui/EditableHudElement";
+import { activeUiLayout, currentUiDevice } from "./game/uiLayoutStore";
+import { actionKeyForEvent, desktopSlotForKey } from "./game/uiLayout";
 
 function InputBridge() {
   const overlay = useGameStore((state) => state.overlay);
   const companionOpen = useGameStore((state) => state.companionOpen);
 
   useEffect(() => installInput({
+    desktopActionBarsActive: () => currentUiDevice() === "pc" && activeUiLayout().wowBars,
+    handleCustomKey: (event) => {
+      const game = useGameStore.getState();
+      if (game.overlay === "ui-layout") return !["Tab", "Enter", "Space", "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"].includes(event.code);
+      if (currentUiDevice() !== "pc" || game.overlay || game.companionOpen || useCombatStore.getState().pendingGroundTarget) return false;
+      const button = desktopSlotForKey(activeUiLayout(), actionKeyForEvent(event));
+      if (!button) return false;
+      if (!event.repeat && button.abilityId) useCombatStore.getState().castAbility(button.abilityId, game.playerPosition, Date.now());
+      game.setInputMode("keyboard");
+      return true;
+    },
     togglePause: () => useGameStore.getState().togglePause(),
     toggleMap: () => useGameStore.getState().toggleMap(),
     toggleInventory: () => useGameStore.getState().toggleOverlay("inventory"),
@@ -98,10 +114,11 @@ export default function GameRuntime() {
           <ManastormBridge />
           <SceneErrorBoundary><GameScene /></SceneErrorBoundary>
           <Hud />
-          <DungeonInteractionPrompt />
+          <EditableHudElement id="interaction"><DungeonInteractionPrompt /></EditableHudElement>
           <MapPanel />
           <GameplayPanels />
           <PauseMenu />
+          <UiLayoutEditor />
           <GmReviewCard />
           <GmWorldEditor />
         </main>

src/app/OnlineGroupCoordinator.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it, vi } from "vitest";
+import type { OnlineGroupActivity } from "./onlineGroupTypes";
+import { enterOnlineGroupActivity } from "./OnlineGroupCoordinator";
+
+const DUNGEON_ACTIVITY: OnlineGroupActivity = {
+  id: "activity-dungeon-1",
+  type: "dungeon",
+  contentId: "deadmines",
+  fillWithAi: true,
+  partySize: 5,
+  startingLevel: null,
+  startedAt: 1,
+};
+
+function entryDependencies(enterDungeon: () => boolean) {
+  return {
+    installDungeonRuntime: vi.fn(async () => undefined),
+    enterDungeon: vi.fn(enterDungeon),
+    installManastormRuntime: vi.fn(async () => undefined),
+    enterManastorm: vi.fn(() => true),
+  };
+}
+
+describe("online group activity entry", () => {
+  it("leaves a dungeon activity unconsumed when dungeon entry fails", async () => {
+    const consumeActivity = vi.fn();
+    const dependencies = entryDependencies(() => false);
+
+    await expect(enterOnlineGroupActivity(
+      DUNGEON_ACTIVITY,
+      "healer",
+      consumeActivity,
+      dependencies,
+    )).resolves.toBe(false);
+
+    expect(dependencies.installDungeonRuntime).toHaveBeenCalledOnce();
+    expect(dependencies.enterDungeon).toHaveBeenCalledWith("deadmines", "healer");
+    expect(consumeActivity).not.toHaveBeenCalled();
+  });
+
+  it("can retry the same dungeon activity and consumes it only after entry succeeds", async () => {
+    const consumeActivity = vi.fn();
+    const enterDungeon = vi.fn()
+      .mockReturnValueOnce(false)
+      .mockReturnValueOnce(true);
+    const dependencies = entryDependencies(enterDungeon);
+
+    await enterOnlineGroupActivity(DUNGEON_ACTIVITY, "tank", consumeActivity, dependencies);
+    expect(consumeActivity).not.toHaveBeenCalled();
+
+    await expect(enterOnlineGroupActivity(
+      DUNGEON_ACTIVITY,
+      "tank",
+      consumeActivity,
+      dependencies,
+    )).resolves.toBe(true);
+
+    expect(dependencies.enterDungeon).toHaveBeenCalledTimes(2);
+    expect(consumeActivity).toHaveBeenCalledOnce();
+    expect(consumeActivity).toHaveBeenCalledWith(DUNGEON_ACTIVITY.id);
+  });
+
+  it("does not consume the activity when loading the dungeon runtime throws", async () => {
+    const consumeActivity = vi.fn();
+    const dependencies = entryDependencies(() => true);
+    dependencies.installDungeonRuntime.mockRejectedValueOnce(new Error("runtime unavailable"));
+
+    await expect(enterOnlineGroupActivity(
+      DUNGEON_ACTIVITY,
+      "damage",
+      consumeActivity,
+      dependencies,
+    )).rejects.toThrow("runtime unavailable");
+
+    expect(dependencies.enterDungeon).not.toHaveBeenCalled();
+    expect(consumeActivity).not.toHaveBeenCalled();
+  });
+});

src/app/OnlineGroupCoordinator.tsx

@@ -1,4 +1,4 @@
-import { useEffect } from "react";
+import { useEffect, useRef } from "react";
 import { selectedCharacter, useShellStore } from "./shellStore";
 import { useOnlineGroupStore } from "./onlineGroupStore";
 import {
@@ -6,11 +6,56 @@ import {
   defaultPartyRoleForClass,
   type PartyRole,
 } from "../game/partyRoles";
-import { isManastormPartySize } from "../game/manastormProgress";
+import { isManastormPartySize, type ManastormPartySize } from "../game/manastormProgress";
+import type { OnlineGroupActivity } from "./onlineGroupTypes";
+import { useContentManagerSnapshot } from "../content/useContentManager";
 
 const GROUP_POLL_MS = 2_500;
 const ACTIVITY_JOIN_WINDOW_MS = 10 * 60 * 1000;
 
+interface OnlineGroupActivityEntryDependencies {
+  readonly installDungeonRuntime: () => Promise<void>;
+  readonly enterDungeon: (dungeonId: string, role?: PartyRole) => boolean;
+  readonly installManastormRuntime: () => Promise<void>;
+  readonly enterManastorm: (role?: PartyRole, partySize?: ManastormPartySize, startingLevel?: number) => boolean;
+}
+
+const DEFAULT_ACTIVITY_ENTRY_DEPENDENCIES: OnlineGroupActivityEntryDependencies = {
+  installDungeonRuntime: async () => {
+    const { installDungeonShellRuntime } = await import("./dungeonShellRuntime");
+    installDungeonShellRuntime();
+  },
+  enterDungeon: (dungeonId, role) => useShellStore.getState().enterDungeon(dungeonId, role),
+  installManastormRuntime: async () => {
+    const { installManastormShellRuntime } = await import("./manastormShellRuntime");
+    installManastormShellRuntime();
+  },
+  enterManastorm: (role, partySize, startingLevel) => useShellStore.getState().enterManastorm(
+    role,
+    partySize,
+    startingLevel,
+  ),
+};
+
+export async function enterOnlineGroupActivity(
+  activity: OnlineGroupActivity,
+  role: PartyRole,
+  consumeActivity: (activityId: string) => void,
+  dependencies: OnlineGroupActivityEntryDependencies = DEFAULT_ACTIVITY_ENTRY_DEPENDENCIES,
+): Promise<boolean> {
+  let entered: boolean;
+  if (activity.type === "dungeon") {
+    await dependencies.installDungeonRuntime();
+    entered = dependencies.enterDungeon(activity.contentId, role);
+  } else {
+    await dependencies.installManastormRuntime();
+    const partySize = isManastormPartySize(activity.partySize) ? activity.partySize : 5;
+    entered = dependencies.enterManastorm(role, partySize, activity.startingLevel ?? undefined);
+  }
+  if (entered) consumeActivity(activity.id);
+  return entered;
+}
+
 export function OnlineGroupCoordinator() {
   const session = useShellStore((state) => state.session);
   const character = useShellStore(selectedCharacter);
@@ -21,6 +66,8 @@ export function OnlineGroupCoordinator() {
   const updateMember = useOnlineGroupStore((state) => state.updateMember);
   const consumeActivity = useOnlineGroupStore((state) => state.consumeActivity);
   const reset = useOnlineGroupStore((state) => state.reset);
+  const { installedRevision } = useContentManagerSnapshot();
+  const pendingActivityIds = useRef(new Set<string>());
 
   useEffect(() => {
     if (!session || session.kind !== "account" || !session.accessToken) {
@@ -60,26 +107,16 @@ export function OnlineGroupCoordinator() {
     if (Date.now() - activity.startedAt > ACTIVITY_JOIN_WINDOW_MS) return;
     const member = snapshot.group?.members.find((candidate) => candidate.accountId === session.ownerId);
     if (!member?.character || !member.role) return;
-    consumeActivity(activity.id);
-    void (async () => {
-      if (activity.type === "dungeon") {
-        const { installDungeonShellRuntime } = await import("./dungeonShellRuntime");
-        installDungeonShellRuntime();
-        useShellStore.getState().enterDungeon(activity.contentId, member.role ?? undefined);
-        return;
-      }
-      const { installManastormShellRuntime } = await import("./manastormShellRuntime");
-      installManastormShellRuntime();
-      const partySize = isManastormPartySize(activity.partySize) ? activity.partySize : 5;
-      useShellStore.getState().enterManastorm(
-        member.role ?? undefined,
-        partySize,
-        activity.startingLevel ?? undefined,
-      );
-    })().catch((error) => {
-      useShellStore.getState().setNotice(error instanceof Error ? error.message : "The group activity could not be opened.");
-    });
-  }, [consumeActivity, consumedActivityIds, phase, session?.ownerId, snapshot.group?.activity?.id]);
+    if (pendingActivityIds.current.has(activity.id)) return;
+    pendingActivityIds.current.add(activity.id);
+    void enterOnlineGroupActivity(activity, member.role, consumeActivity)
+      .catch((error) => {
+        useShellStore.getState().setNotice(error instanceof Error ? error.message : "The group activity could not be opened.");
+      })
+      .finally(() => {
+        pendingActivityIds.current.delete(activity.id);
+      });
+  }, [consumeActivity, consumedActivityIds, installedRevision, phase, session?.ownerId, snapshot.group?.activity?.id]);
 
   return null;
 }

src/app/accountRepository.ts

@@ -1,4 +1,5 @@
 import type { CharacterProfile, PlayerSession } from "./types";
+import { normalizeUiPreferences, type UiPreferences } from "../game/uiLayout";
 import {
   contentCategoryForClass,
   isRomClassId,
@@ -64,6 +65,7 @@ interface ProfileDatabase {
   accounts: LocalAccount[];
   rosters: Record<string, CharacterProfile[]>;
   presentationSettingsByOwner: Record<string, CombatPresentationSettings>;
+  uiPreferencesByOwner?: Record<string, UiPreferences>;
 }
 
 export interface AccountResult {
@@ -202,6 +204,7 @@ function readDatabase(storage: StorageLike | null = browserLocalStorage()): Prof
       accounts?: unknown;
       rosters?: unknown;
       presentationSettingsByOwner?: unknown;
+      uiPreferencesByOwner?: unknown;
     }) | null;
     if (!parsed || ![1, 2, 3, 4, 5].includes(parsed.version ?? 0) || !Array.isArray(parsed.accounts) || !parsed.rosters || typeof parsed.rosters !== "object") {
       return emptyDatabase();
@@ -243,7 +246,9 @@ function readDatabase(storage: StorageLike | null = browserLocalStorage()): Prof
         return [ownerId, normalized];
       }),
     );
-    const database: ProfileDatabase = { version: 5, accounts, rosters, presentationSettingsByOwner };
+    const rawUi = parsed.uiPreferencesByOwner && typeof parsed.uiPreferencesByOwner === "object" ? parsed.uiPreferencesByOwner : {};
+    const uiPreferencesByOwner = Object.fromEntries(Object.entries(rawUi).map(([owner, value]) => [owner, normalizeUiPreferences(value)]));
+    const database: ProfileDatabase = { version: 5, accounts, rosters, presentationSettingsByOwner, uiPreferencesByOwner };
     if (parsed.version !== 5 || presentationSettingsMigrated) writeDatabase(database, storage);
     return database;
   } catch {
@@ -254,11 +259,23 @@ function readDatabase(storage: StorageLike | null = browserLocalStorage()): Prof
 function writeDatabase(database: ProfileDatabase, storage: StorageLike | null = browserLocalStorage()): void {
   storage?.setItem(DATABASE_KEY, JSON.stringify(database));
   if (!storage || !rosterChangeListener) return;
-  for (const [ownerId, characters] of Object.entries(database.rosters)) {
-    rosterChangeListener(ownerId, characters);
+  for (const ownerId of new Set([...Object.keys(database.rosters), ...Object.keys(database.uiPreferencesByOwner ?? {})])) {
+    rosterChangeListener(ownerId, database.rosters[ownerId] ?? []);
   }
 }
 
+export function loadUiPreferences(ownerId: string, storage: StorageLike | null = browserLocalStorage()): UiPreferences {
+  return normalizeUiPreferences(readDatabase(storage).uiPreferencesByOwner?.[ownerId]);
+}
+
+export function saveUiPreferences(ownerId: string, value: unknown, storage: StorageLike | null = browserLocalStorage()): UiPreferences {
+  const database = readDatabase(storage);
+  const preferences = normalizeUiPreferences(value);
+  database.uiPreferencesByOwner = { ...database.uiPreferencesByOwner, [ownerId]: preferences };
+  writeDatabase(database, storage);
+  return preferences;
+}
+
 function bytesToBase64(bytes: Uint8Array): string {
   let result = "";
   for (let index = 0; index < bytes.length; index += 3) {

src/app/dungeonShellRuntime.ts

@@ -11,6 +11,7 @@ import { useShellStore } from "./shellStore";
 import { registerDungeonShellRuntime } from "./dungeonShellRuntimeBridge";
 import { touchCharacter } from "./accountRepository";
 import { specializationById } from "../game/specializationCatalog";
+import { dungeonContentIsUsable } from "../content/contentManager";
 
 export function installDungeonShellRuntime(): void {
   registerDungeonShellRuntime({ enterDungeon });
@@ -22,6 +23,10 @@ function enterDungeon(dungeonId: string, requestedRole?: PartyRole): boolean {
     useShellStore.setState({ notice: "That dungeon is not available yet." });
     return false;
   }
+  if (!dungeonContentIsUsable(dungeonId)) {
+    useShellStore.setState({ notice: "Install this expedition from Downloads before entering." });
+    return false;
+  }
   const { session, selectedCharacterId, characters } = useShellStore.getState();
   if (!session || !selectedCharacterId) {
     useShellStore.setState({ notice: "Select or create a character first." });

src/app/onlineAccountClient.ts

@@ -1,8 +1,11 @@
 import { Capacitor } from "@capacitor/core";
+import { create } from "zustand";
 import {
   listCharacters,
   replaceCharactersForOwner,
   setRosterChangeListener,
+  loadUiPreferences,
+  saveUiPreferences,
   type AccountResult,
 } from "./accountRepository";
 import type { CharacterProfile, PlayerSession } from "./types";
@@ -20,7 +23,7 @@ interface AuthResponse {
 interface CloudSaveResponse {
   revision: number;
   updatedAt: number | null;
-  data: { version?: number; characters?: unknown };
+  data: { version?: number; characters?: unknown; uiPreferences?: unknown };
 }
 
 interface MeResponse {
@@ -39,6 +42,8 @@ let suppressUpload = false;
 let pendingCharacters: CharacterProfile[] | null = null;
 let saveTimer: ReturnType<typeof setTimeout> | null = null;
 let saveQueue = Promise.resolve();
+export const useCloudSaveStatus = create<{ state: "local" | "pending" | "synced" | "error"; message: string }>(() => ({ state: "local", message: "" }));
+let saveSequence = 0;
 
 export function onlineApiOrigin(): string {
   const configured = String(import.meta.env.VITE_API_BASE_URL ?? "").replace(/\/+$/, "");
@@ -100,18 +105,24 @@ function flushCloudSave(): void {
   const characters = pendingCharacters;
   pendingCharacters = null;
   if (!session?.accessToken || !characters) return;
+  const uiPreferences = loadUiPreferences(session.ownerId);
+  const sequence = saveSequence;
   saveQueue = saveQueue.then(async () => {
     await requestOnlineJson<CloudSaveResponse>("/api/cloud-save", {
       method: "PUT",
-      body: JSON.stringify({ data: { version: 1, characters } }),
+      body: JSON.stringify({ data: { version: 1, characters, uiPreferences } }),
     }, session.accessToken);
+    if (activeSession?.ownerId === session.ownerId && sequence === saveSequence) useCloudSaveStatus.setState({ state: "synced", message: "Saved to your account." });
   }).catch((error) => {
     console.error("Healer Man cloud save failed", error);
+    if (activeSession?.ownerId === session.ownerId && sequence === saveSequence) useCloudSaveStatus.setState({ state: "error", message: "Saved on this device. Cloud upload failed; retry before switching devices." });
   });
 }
 
 function queueCloudSave(ownerId: string, characters: readonly CharacterProfile[]): void {
   if (suppressUpload || !activeSession?.accessToken || activeSession.ownerId !== ownerId) return;
+  saveSequence += 1;
+  useCloudSaveStatus.setState({ state: "pending", message: "Uploading to your account…" });
   pendingCharacters = characters.map((character) => ({ ...character }));
   if (saveTimer) clearTimeout(saveTimer);
   saveTimer = setTimeout(() => {
@@ -123,15 +134,23 @@ function queueCloudSave(ownerId: string, characters: readonly CharacterProfile[]
 setRosterChangeListener(queueCloudSave);
 
 export function activateOnlineSession(session: PlayerSession): void {
+  if (activeSession?.ownerId !== session.ownerId && saveTimer) {
+    clearTimeout(saveTimer); saveTimer = null; flushCloudSave();
+  }
   activeSession = session.accessToken ? session : null;
 }
 
+export function retryCloudSave(): void {
+  if (activeSession) queueCloudSave(activeSession.ownerId, listCharacters(activeSession.ownerId));
+}
+
 export async function hydrateOnlineSession(session: PlayerSession): Promise<CharacterProfile[]> {
   if (!session.accessToken) return listCharacters(session.ownerId);
   activateOnlineSession(session);
   const cloud = await requestOnlineJson<CloudSaveResponse>("/api/cloud-save", {}, session.accessToken);
   suppressUpload = true;
   try {
+    saveUiPreferences(session.ownerId, cloud.data?.uiPreferences);
     return replaceCharactersForOwner(session.ownerId, cloud.data?.characters ?? []);
   } finally {
     suppressUpload = false;

src/app/shellStore.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { createDefaultAppearance } from "./characterCatalog";
 import { useShellStore } from "./shellStore";
 import { installDungeonShellRuntime } from "./dungeonShellRuntime";
@@ -79,6 +79,10 @@ function prepareSelectedCharacter(): void {
 }
 
 describe("shell store", () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
   beforeEach(() => {
     useShellStore.setState({
       phase: "login",
@@ -167,6 +171,17 @@ describe("shell store", () => {
     expect(useGameStore.getState().distanceTravelled).toBe(42);
   });
 
+  it("rejects a shipped dungeon whose production content pack is not usable", () => {
+    vi.stubEnv("DEV", false);
+    prepareSelectedCharacter();
+    useShellStore.getState().openMainMenu();
+    useShellStore.getState().openDungeons();
+
+    expect(useShellStore.getState().enterDungeon("deadmines", "healer")).toBe(false);
+    expect(useShellStore.getState().phase).toBe("dungeons");
+    expect(useShellStore.getState().notice).toMatch(/downloads/i);
+  });
+
   it("returns from gameplay to the main menu with the same character selected", () => {
     prepareSelectedCharacter();
     expect(useShellStore.getState().enterDungeon(DUNGEON_MANIFEST.id)).toBe(true);

src/app/uiPreferencesSync.test.ts

@@ -0,0 +1,45 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { loadUiPreferences, saveUiPreferences, setRosterChangeListener } from "./accountRepository";
+import { normalizeUiPreferences } from "../game/uiLayout";
+import type { PlayerSession } from "./types";
+
+function storage() {
+  const values = new Map<string, string>();
+  return { getItem: (key: string) => values.get(key) ?? null, setItem: (key: string, value: string) => { values.set(key, value); }, removeItem: (key: string) => { values.delete(key); } };
+}
+afterEach(() => { vi.useRealTimers(); vi.unstubAllGlobals(); setRosterChangeListener(null); });
+
+describe("profile UI persistence", () => {
+  it("isolates owners and persists templates without requiring a character", () => {
+    const local = storage(); const ui = normalizeUiPreferences(null);
+    ui.slots.pc[1] = { name: "Healer", layout: ui.current.pc };
+    saveUiPreferences("one", ui, local);
+    expect(loadUiPreferences("one", local).slots.pc[1]?.name).toBe("Healer");
+    expect(loadUiPreferences("two", local).slots.pc[1]).toBeNull();
+    ui.slots.pc[1].name = "Unsaved change";
+    expect(loadUiPreferences("one", local).slots.pc[1]?.name).toBe("Healer");
+  });
+  it("uploads all six slots and restores them into a separate device cache", async () => {
+    vi.useFakeTimers();
+    const first = storage(); const second = storage();
+    vi.stubGlobal("window", { localStorage: first });
+    let cloudData: unknown = { version: 1, characters: [] };
+    vi.stubGlobal("fetch", vi.fn(async (_url: string, init: RequestInit) => {
+      if (init.method === "PUT") cloudData = JSON.parse(String(init.body)).data;
+      return new Response(JSON.stringify({ revision: 1, updatedAt: 1, data: cloudData }), { status: 200, headers: { "Content-Type": "application/json" } });
+    }));
+    const client = await import("./onlineAccountClient");
+    const session: PlayerSession = { ownerId: "cloud-user", kind: "account", displayName: "Player", accessToken: "test-token" };
+    client.activateOnlineSession(session);
+    const ui = normalizeUiPreferences(null);
+    ui.slots.pc[2] = { name: "Desktop raid", layout: ui.current.pc };
+    ui.slots.mobile[1] = { name: "On the go", layout: ui.current.mobile };
+    saveUiPreferences(session.ownerId, ui);
+    await vi.advanceTimersByTimeAsync(501);
+    expect(client.useCloudSaveStatus.getState().state).toBe("synced");
+    vi.stubGlobal("window", { localStorage: second });
+    await client.hydrateOnlineSession(session);
+    expect(loadUiPreferences(session.ownerId)).toEqual(ui);
+    expect(loadUiPreferences("different-account").slots.pc[2]).toBeNull();
+  });
+});

src/assets/game/dungeons/aeternal-circle/import-metadata.json

@@ -137,8 +137,8 @@
     {
       "role": "visual",
       "fileName": "aeternal-circle-visual.glb",
-      "size": 4963912,
-      "sha256": "42fdcff1b25b58688943a030f69fd14ea839247a7baabbc31b5f6f7faaf49785",
+      "size": 4963968,
+      "sha256": "de1ba06b7e3a9237fcff75aff2b00093287975e755cc7e98e77de1b7af6a9c14",
       "compression": "meshopt+ktx2"
     },
     {

src/assets/game/dungeons/aeternal-circle/optimization-report.json

@@ -8,8 +8,8 @@
   },
   "optimized": {
     "file": "aeternal-circle-visual.optimized.glb",
-    "size": 4963912,
-    "checksum": "42fdcff1b25b58688943a030f69fd14ea839247a7baabbc31b5f6f7faaf49785"
+    "size": 4963968,
+    "checksum": "de1ba06b7e3a9237fcff75aff2b00093287975e755cc7e98e77de1b7af6a9c14"
   },
   "compression": "meshopt+ktx2",
   "commands": [

src/assets/game/dungeons/barren-caves/import-metadata.json

@@ -137,8 +137,8 @@
     {
       "role": "visual",
       "fileName": "barren-caves-visual.glb",
-      "size": 1710152,
-      "sha256": "d0f733de4b26c0f432c5e160614765f320bf1753a829be269740b340e7415a12",
+      "size": 1710188,
+      "sha256": "e6dc49e6aa6fd20cee1b2afa43324a714f8f8284a6becef8dc514509b432f9bb",
       "compression": "meshopt+ktx2"
     },
     {

src/assets/game/dungeons/barren-caves/optimization-report.json

@@ -8,8 +8,8 @@
   },
   "optimized": {
     "file": "barren-caves-visual.optimized.glb",
-    "size": 1710152,
-    "checksum": "d0f733de4b26c0f432c5e160614765f320bf1753a829be269740b340e7415a12"
+    "size": 1710188,
+    "checksum": "e6dc49e6aa6fd20cee1b2afa43324a714f8f8284a6becef8dc514509b432f9bb"
   },
   "compression": "meshopt+ktx2",
   "commands": [

src/assets/game/dungeons/cave-water-dragon/import-metadata.json

@@ -137,8 +137,8 @@
     {
       "role": "visual",
       "fileName": "cave-water-dragon-visual.glb",
-      "size": 8893112,
-      "sha256": "cc57c0285de77690c4a1cdabaecd8b192791cbd05aca38aa21ed96462688ca31",
+      "size": 8893204,
+      "sha256": "dd1887f88d6ee9102da0e34ea2b4087742e37a2b8ce779c722bc124effe1faca",
       "compression": "meshopt+ktx2"
     },
     {

src/assets/game/dungeons/cave-water-dragon/optimization-report.json

@@ -8,8 +8,8 @@
   },
   "optimized": {
     "file": "cave-water-dragon-visual.optimized.glb",
-    "size": 8893112,
-    "checksum": "cc57c0285de77690c4a1cdabaecd8b192791cbd05aca38aa21ed96462688ca31"
+    "size": 8893204,
+    "checksum": "dd1887f88d6ee9102da0e34ea2b4087742e37a2b8ce779c722bc124effe1faca"
   },
   "compression": "meshopt+ktx2",
   "commands": [

src/assets/game/dungeons/demon-stronghold-125/import-metadata.json

@@ -137,8 +137,8 @@
     {
       "role": "visual",
       "fileName": "demon-stronghold-125-visual.glb",
-      "size": 15134500,
-      "sha256": "ecbacfe274e7eecb104c5807eedf3cc51cd4b7a628967c6331fc93b86396b842",
+      "size": 15135060,
+      "sha256": "e2106115dcc216999d2e37d26eeb52844ce4f41b44e19594699f37a54d7f19b9",
       "compression": "meshopt+ktx2"
     },
     {

src/assets/game/dungeons/demon-stronghold-125/optimization-report.json

@@ -8,8 +8,8 @@
   },
   "optimized": {
     "file": "demon-stronghold-125-visual.optimized.glb",
-    "size": 15134500,
-    "checksum": "ecbacfe274e7eecb104c5807eedf3cc51cd4b7a628967c6331fc93b86396b842"
+    "size": 15135060,
+    "checksum": "e2106115dcc216999d2e37d26eeb52844ce4f41b44e19594699f37a54d7f19b9"
   },
   "compression": "meshopt+ktx2",
   "commands": [

src/assets/game/dungeons/demon-stronghold/import-metadata.json

@@ -137,8 +137,8 @@
     {
       "role": "visual",
       "fileName": "demon-stronghold-visual.glb",
-      "size": 15166984,
-      "sha256": "9368984b3c183a8db6e8b7e18b7818edcf41b8edd45ffeca1d1df28aadc592a2",
+      "size": 15167544,
+      "sha256": "664181dc790b9e68cdc7451dbd0b1170a033a71ca19375743b6e66ca25889723",
       "compression": "meshopt+ktx2"
     },
     {

src/assets/game/dungeons/demon-stronghold/optimization-report.json

@@ -8,8 +8,8 @@
   },
   "optimized": {
     "file": "demon-stronghold-visual.optimized.glb",
-    "size": 15166984,
-    "checksum": "9368984b3c183a8db6e8b7e18b7818edcf41b8edd45ffeca1d1df28aadc592a2"
+    "size": 15167544,
+    "checksum": "664181dc790b9e68cdc7451dbd0b1170a033a71ca19375743b6e66ca25889723"
   },
   "compression": "meshopt+ktx2",
   "commands": [

src/assets/game/dungeons/dungeon-of-dalanis/import-metadata.json

@@ -137,8 +137,8 @@
     {
       "role": "visual",
       "fileName": "dungeon-of-dalanis-visual.glb",
-      "size": 11936864,
-      "sha256": "4c584ef34779e516f8e6ff3a4907eaab1c7c8d49d4c302de66e17b09222d8829",
+      "size": 11937088,
+      "sha256": "45cad819bc348dec8926f7de237c625e9d18697b4200804e0440dd16b8976959",
       "compression": "meshopt+ktx2"
     },
     {

src/assets/game/dungeons/dungeon-of-dalanis/optimization-report.json

@@ -8,8 +8,8 @@
   },
   "optimized": {
     "file": "dungeon-of-dalanis-visual.optimized.glb",
-    "size": 11936864,
-    "checksum": "4c584ef34779e516f8e6ff3a4907eaab1c7c8d49d4c302de66e17b09222d8829"
+    "size": 11937088,
+    "checksum": "45cad819bc348dec8926f7de237c625e9d18697b4200804e0440dd16b8976959"
   },
   "compression": "meshopt+ktx2",
   "commands": [

src/assets/game/dungeons/forsaken-abbey/import-metadata.json

@@ -284,8 +284,8 @@
     {
       "role": "visual",
       "fileName": "forsaken-abbey-visual.glb",
-      "size": 9580212,
-      "sha256": "37800c26cdf784658a57dcc7328ab1b9b23e46d018be6d1e6420f127768b0332",
+      "size": 9580568,
+      "sha256": "ee7afd5e9179e6bcb7ec9171798466282e09d4ef696a3f9639bcd2bbc2ae8f48",
       "compression": "meshopt+ktx2"
     },
     {

src/assets/game/dungeons/forsaken-abbey/optimization-report.json

@@ -8,8 +8,8 @@
   },
   "optimized": {
     "file": "forsaken-abbey-visual.optimized.glb",
-    "size": 9580212,
-    "checksum": "37800c26cdf784658a57dcc7328ab1b9b23e46d018be6d1e6420f127768b0332"
+    "size": 9580568,
+    "checksum": "ee7afd5e9179e6bcb7ec9171798466282e09d4ef696a3f9639bcd2bbc2ae8f48"
   },
   "compression": "meshopt+ktx2",
   "commands": [

src/assets/game/dungeons/grafu-castle/import-metadata.json

@@ -137,8 +137,8 @@
     {
       "role": "visual",
       "fileName": "grafu-castle-visual.glb",
-      "size": 11149716,
-      "sha256": "ba4552484ef9cddc1c00607d0dfd4c8fb0bae5b3cd3f992d215a580dac1e96ed",
+      "size": 11150124,
+      "sha256": "b775778f457d639e3f21982aaa6bd3ee1b0eba951c711d1ba319b0588e24a38f",
       "compression": "meshopt+ktx2"
     },
     {

src/assets/game/dungeons/grafu-castle/optimization-report.json

@@ -8,8 +8,8 @@
   },
   "optimized": {
     "file": "grafu-castle-visual.optimized.glb",
-    "size": 11149716,
-    "checksum": "ba4552484ef9cddc1c00607d0dfd4c8fb0bae5b3cd3f992d215a580dac1e96ed"
+    "size": 11150124,
+    "checksum": "b775778f457d639e3f21982aaa6bd3ee1b0eba951c711d1ba319b0588e24a38f"
   },
   "compression": "meshopt+ktx2",
   "commands": [

src/assets/game/dungeons/hall-of-survivors/import-metadata.json

@@ -137,8 +137,8 @@
     {
       "role": "visual",
       "fileName": "hall-of-survivors-visual.glb",
-      "size": 15216768,
-      "sha256": "18b9d116da599159719ad76eeee45a4d89056ee8c61cc4f21cab9a1d9228fff7",
+      "size": 15216936,
+      "sha256": "96b91b24462b8428e8808295dcea29d26de9be8431ea6667dde92cdded4ddf2a",
       "compression": "meshopt+ktx2"
     },
     {

src/assets/game/dungeons/hall-of-survivors/optimization-report.json

@@ -8,8 +8,8 @@
   },
   "optimized": {
     "file": "hall-of-survivors-visual.optimized.glb",
-    "size": 15216768,
-    "checksum": "18b9d116da599159719ad76eeee45a4d89056ee8c61cc4f21cab9a1d9228fff7"
+    "size": 15216936,
+    "checksum": "96b91b24462b8428e8808295dcea29d26de9be8431ea6667dde92cdded4ddf2a"
   },
   "compression": "meshopt+ktx2",
   "commands": [

src/assets/game/dungeons/hoto/import-metadata.json

@@ -3,7 +3,7 @@
   "dungeonId": "hoto",
   "title": "HOTO",
   "status": "source-packaged",
-  "generatedAt": "2026-08-01T01:00:34.655Z",
+  "generatedAt": "2026-09-09T19:39:49.407Z",
   "source": {
     "recipe": "scripts/runewaker-pipeline/recipes/hoto.json",
     "wdb": "Resource/wdb/dungeon/dgn_echoes_of_the_sea.wdb",
@@ -261,33 +261,37 @@
     {
       "role": "visual",
       "fileName": "hoto-visual.glb",
-      "size": 6667208,
-      "sha256": "0d12b9c6dc477704d2833c81f76113d340da7f07f5885a40bafd1321524e455e",
-      "compression": "meshopt+ktx2"
+      "relativeFile": "hoto-visual.glb",
+      "size": 6710184,
+      "sha256": "beff3a180c55166d5ebd7e3610e65b59f8104edfd7596aa22ac3a49c578fcdc0"
     },
     {
       "role": "collision",
       "fileName": "hoto-collision-000.glb",
+      "relativeFile": "hoto-collision-000.glb",
       "size": 3088036,
       "sha256": "3116529f2d262ff4cab7997e852f9d15caacab6298921360b49dcafd52b8c475"
     },
     {
       "role": "collision",
       "fileName": "hoto-collision-001.glb",
+      "relativeFile": "hoto-collision-001.glb",
       "size": 2989324,
       "sha256": "1f5cbd4b04b5a060029fd7c023ee19db5d8646566fcd01b931473b5b13c13b9f"
     },
     {
       "role": "collision",
       "fileName": "hoto-collision-002.glb",
+      "relativeFile": "hoto-collision-002.glb",
       "size": 526648,
       "sha256": "0a468a6ef30941c04a20456866f0593f7e1f9f9bf8dc0024176d2128975f1879"
     },
     {
       "role": "navigation",
       "fileName": "hoto-navigation.glb",
+      "relativeFile": "hoto-navigation.glb",
       "size": 482260,
-      "sha256": "2cd78e6d8f52cb6488747a1f87cb688eedb77ccf412fb50674c25f70306477fd"
+      "sha256": "a2bde2e4b8ed0d0bac8c4669a05192ff0a35ae9c64df0c0a29fe3735b65cbf4b"
     }
   ],
   "review": {
@@ -300,6 +304,6 @@
   "exceptions": [
     "Secondary WDB doodads/effects remain in the audit; this pass exports the primary ROS hierarchy.",
     "Collision initially includes decorative primary-ROS geometry.",
-    "Original skeletal animations and complex scripted mechanics remain later passes."
+    "Original GR2 actor animations are recovered where source graphs and validation permit; scripted encounter mechanics remain evidence-driven per-instance work."
   ]
 }

src/assets/game/dungeons/hoto/optimization-report.json

@@ -4,15 +4,11 @@
   "status": "review-required",
   "source": {
     "file": "hoto-visual.glb",
-    "size": 26313948
+    "size": 26314004
   },
   "optimized": {
     "file": "hoto-visual.optimized.glb",
-    "size": 6667208,
-    "checksum": "0d12b9c6dc477704d2833c81f76113d340da7f07f5885a40bafd1321524e455e"
+    "size": 6710184
   },
-  "compression": "meshopt+ktx2",
-  "commands": [
-    "node scripts/asset-pipeline/compress-ktx2.mjs <optimized.glb> --concurrency 1 --jobs 2"
-  ]
+  "compression": "meshopt+ktx2"
 }

src/assets/game/dungeons/hoto/wdb-report.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "sourceWdb": "D:\\Projects\\rom-pvt-server-backups\\Runewaker\\Resource\\wdb\\dungeon\\dgn_echoes_of_the_sea.wdb",
+  "sourceWdb": "F:\\Projects\\rom-pvt-server-backups\\Runewaker\\Resource\\wdb\\dungeon\\dgn_echoes_of_the_sea.wdb",
   "coordinateSystem": "runewaker-left-handed-y-up",
   "descriptorCount": 1627,
   "descriptors": [

src/assets/game/dungeons/ice-dwarf-kingdom/import-metadata.json

@@ -137,8 +137,8 @@
     {
       "role": "visual",
       "fileName": "ice-dwarf-kingdom-visual.glb",
-      "size": 9880192,
-      "sha256": "a6b902e85bb6026f18281d77efa235ec880ffc2fc13ea6bfdc431d24af768e00",
+      "size": 9880304,
+      "sha256": "41cef8ce1bf6dbf7df0c4e2797a325e4d50a3870d435d46684600894d4aa92e7",
       "compression": "meshopt+ktx2"
     },
     {

src/assets/game/dungeons/ice-dwarf-kingdom/optimization-report.json

@@ -8,8 +8,8 @@
   },
   "optimized": {
     "file": "ice-dwarf-kingdom-visual.optimized.glb",
-    "size": 9880192,
-    "checksum": "a6b902e85bb6026f18281d77efa235ec880ffc2fc13ea6bfdc431d24af768e00"
+    "size": 9880304,
+    "checksum": "41cef8ce1bf6dbf7df0c4e2797a325e4d50a3870d435d46684600894d4aa92e7"
   },
   "compression": "meshopt+ktx2",
   "commands": [

src/assets/game/dungeons/kal-turok-hive/import-metadata.json

@@ -137,8 +137,8 @@
     {
       "role": "visual",
       "fileName": "kal-turok-hive-visual.glb",
-      "size": 1777616,
-      "sha256": "012867deefc4dc5a18c3e1a507309aa48f119cf4c2e88968fdd2787936ed7c24",
+      "size": 1777728,
+      "sha256": "75c0c596218cec07003e2def1d74c8e1f5ca3010ed370db558a1786b003f4f1c",
       "compression": "meshopt+ktx2"
     },
     {

src/assets/game/dungeons/kal-turok-hive/optimization-report.json

@@ -8,8 +8,8 @@
   },
   "optimized": {
     "file": "kal-turok-hive-visual.optimized.glb",
-    "size": 1777616,
-    "checksum": "012867deefc4dc5a18c3e1a507309aa48f119cf4c2e88968fdd2787936ed7c24"
+    "size": 1777728,
+    "checksum": "75c0c596218cec07003e2def1d74c8e1f5ca3010ed370db558a1786b003f4f1c"
   },
   "compression": "meshopt+ktx2",
   "commands": [

src/assets/game/dungeons/kalins-shrine/import-metadata.json

@@ -3,7 +3,7 @@
   "dungeonId": "kalins-shrine",
   "title": "Kalin's Shrine",
   "status": "source-packaged",
-  "generatedAt": "2026-08-01T00:57:43.432Z",
+  "generatedAt": "2026-09-09T18:51:01.674Z",
   "source": {
     "recipe": "scripts/runewaker-pipeline/recipes/kalins-shrine.json",
     "wdb": "Resource/wdb/dungeon/dgn_kleeon_temple.wdb",
@@ -277,33 +277,37 @@
     {
       "role": "visual",
       "fileName": "kalins-shrine-visual.glb",
-      "size": 8747072,
-      "sha256": "769accb48e23c9f80e28697e3e8454ef4148243a69ce247ed06ba4eb35bb0da7",
-      "compression": "meshopt+ktx2"
+      "relativeFile": "kalins-shrine-visual.glb",
+      "size": 8851724,
+      "sha256": "023c43a56253e97fa0526185c61f76e0e9fa8398b7a35771728566c331cd22a9"
     },
     {
       "role": "collision",
       "fileName": "kalins-shrine-collision-000.glb",
+      "relativeFile": "kalins-shrine-collision-000.glb",
       "size": 4748976,
       "sha256": "ed1e713c159e024b4786ef8befadbfedd3849ba580e7f49970e2785b6f4fff7d"
     },
     {
       "role": "collision",
       "fileName": "kalins-shrine-collision-001.glb",
+      "relativeFile": "kalins-shrine-collision-001.glb",
       "size": 4555800,
       "sha256": "5fea14212353593c8daced2e303f88dae010f8f73aedb9890a3eee67eb8dd7cd"
     },
     {
       "role": "collision",
       "fileName": "kalins-shrine-collision-002.glb",
+      "relativeFile": "kalins-shrine-collision-002.glb",
       "size": 1215728,
       "sha256": "e51d48d1f4521f1a4722fd4c528a90bdfd2978a87d2ace0dd662f23475490565"
     },
     {
       "role": "navigation",
       "fileName": "kalins-shrine-navigation.glb",
+      "relativeFile": "kalins-shrine-navigation.glb",
       "size": 327792,
-      "sha256": "37fd7f8efac36f83279efbfb33df37646453af214db29597bd14c8e9f19ddc04"
+      "sha256": "6b77496f7b46890d401f955f9254ae37d25d9a1287a3bc9e787e9a254f9d9071"
     }
   ],
   "review": {
@@ -316,6 +320,6 @@
   "exceptions": [
     "Secondary WDB doodads/effects remain in the audit; this pass exports the primary ROS hierarchy.",
     "Collision initially includes decorative primary-ROS geometry.",
-    "Original skeletal animations and complex scripted mechanics remain later passes."
+    "Original GR2 actor animations are recovered where source graphs and validation permit; scripted encounter mechanics remain evidence-driven per-instance work."
   ]
 }

src/assets/game/dungeons/kalins-shrine/optimization-report.json

@@ -4,15 +4,11 @@
   "status": "review-required",
   "source": {
     "file": "kalins-shrine-visual.glb",
-    "size": 26551164
+    "size": 26551296
   },
   "optimized": {
     "file": "kalins-shrine-visual.optimized.glb",
-    "size": 8747072,
-    "checksum": "769accb48e23c9f80e28697e3e8454ef4148243a69ce247ed06ba4eb35bb0da7"
+    "size": 8851724
   },
-  "compression": "meshopt+ktx2",
-  "commands": [
-    "node scripts/asset-pipeline/compress-ktx2.mjs <optimized.glb> --concurrency 1 --jobs 2"
-  ]
+  "compression": "meshopt+ktx2"
 }

src/assets/game/dungeons/kalins-shrine/wdb-report.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "sourceWdb": "D:\\Projects\\rom-pvt-server-backups\\Runewaker\\Resource\\wdb\\dungeon\\dgn_kleeon_temple.wdb",
+  "sourceWdb": "F:\\Projects\\rom-pvt-server-backups\\Runewaker\\Resource\\wdb\\dungeon\\dgn_kleeon_temple.wdb",
   "coordinateSystem": "runewaker-left-handed-y-up",
   "descriptorCount": 943,
   "descriptors": [