docs(M03): accept M2 runtime rebuild classifier

RENDER.md

@@ -30,6 +30,12 @@ Paired run 2026-07-11 подтвердил крупный coordinate/placement g
 - `src/render/wmo/wmo_placement_resolver.gd` - value-only WMO path, identity and transform rules.
 - `src/render/wmo/wmo_placement_registry.gd` - WMO placement-key to tile/global reference sets; Nodes and render jobs remain in the streamer.
 - `src/render/wmo/wmo_render_build_step_planner.gd` - mesh-first lightweight WMO group operation and cursor planning without Nodes or Resources.
+- `src/render/wmo/wmo_render_build_queue.gd` / `wmo_render_build_job.gd` - typed pending group jobs, FIFO placement keys and strong root/resource references without engine destruction.
+- `src/render/wmo/wmo_render_resource_cache_state.gd` - validated lightweight WMO render Resources, negative cache and pending cache paths without ResourceLoader I/O.
+- `src/render/wmo/wmo_scene_resource_cache_state.gd` - validated cached-WMO PackedScenes, negative cache and pending `.tscn` paths without file/I/O/Node ownership.
+- `src/render/liquid/adt_water_load_pipeline_state.gd` - ADT water pending FIFO/dedupe, active task IDs and worker-safe parsed-result mailbox without parser or Node ownership.
+- `src/render/liquid/adt_water_scene_finalizer.gd` - stateless main-thread ADT water build/attach and optional persisted Editor ownership through the existing ADTBuilder.
+- `src/render/m2/m2_runtime_mesh_rebuild_classifier.gd` - memoized billboard/UV-rotation decision for stale cached M2 runtime mesh refresh.
 - `src/scenes/streaming/eastern_kingdoms_streaming.tscn` - текущая сцена для проверки Azeroth/Eastern Kingdoms.
 - `addons/mpq_extractor/loaders/adt_builder.gd` - сборка ADT terrain, control splat материалов и MH2O liquids.
 - `addons/mpq_extractor/loaders/m2_builder.gd` - сборка статического M2 mesh/material.
@@ -401,6 +407,8 @@ Known limits:
   the parallel key-to-Node map and performs final-release cancellation/free;
 - `WmoRenderBuildStepPlanner` selects one mesh or MultiMesh group and its next
   cursors; the streamer still materializes Nodes and consumes the frame permit;
+- `WmoRenderBuildQueue` owns pending typed jobs/FIFO keys and releases references
+  on cancel/reset; the streamer still validates and frees engine objects;
 - большие WMO не должны инстанцироваться как тяжелые `.tscn` во время движения;
 - добавлен lightweight render-cache path для WMO groups;
 - `wmo_render_group_ops_per_tick` ограничивает подключение WMO groups по кадрам;
@@ -1032,6 +1040,22 @@ $exe = Join-Path $env:TEMP 'godot-4.6.1-openwc\Godot_v4.6.1-stable_win64.exe'
 - Cache formats, quality profiles, batching output and visible rules are unchanged.
   Asset-backed p95/p99 and spatial-cell batching evidence remain pending.
 
+## 2026-07-17 M2 Runtime Mesh Rebuild Classifier Extraction
+
+- `M2RuntimeMeshRebuildClassifier` now owns the memoized decision used when a
+  stale cached M2 mesh may need an in-memory rebuild from raw data.
+- Existing triggers are unchanged: any billboard flag/positive billboard vertex
+  count, or a referenced non-identity UV rotation/absolute rotation speed above
+  `0.000001` across at most four texture stages.
+- Invalid batch variants and combo/transform indices remain skipped. The first
+  decision for a normalized path remains cached until the same two historical
+  map/shutdown clear sites.
+- `StreamingWorldLoader` still loads raw M2 data, checks
+  `M2_MATERIAL_REFRESH_VERSION`, calls `M2Builder`, adopts/falls back to Meshes
+  and owns ResourceLoader/finalization budgets.
+- No cache version, shader, material, geometry or visible rule changed. Synthetic
+  predicate timing is not asset-backed descriptor-pressure/p95/p99 evidence.
+
 ## 2026-07-17 WMO Placement Resolver Extraction
 
 - `WmoPlacementResolver` now owns lowercase/slash cache-key normalization,
@@ -1044,6 +1068,67 @@ $exe = Join-Path $env:TEMP 'godot-4.6.1-openwc\Godot_v4.6.1-stable_win64.exe'
 - Cache formats, placement values, profiles and visible rules are unchanged.
   Asset-backed placement/p95/p99 and general WMO parity remain pending.
 
+## 2026-07-17 WMO Render Resource Cache State Extraction
+
+- `WmoRenderResourceCacheState` now owns validated lightweight-WMO render
+  Resources, negative entries and normalized-path to pending-cache-path records.
+- `StreamingWorldLoader` still constructs cache paths, calls `ResourceLoader`,
+  polls requests and validates `WMOStreamingResource` script identity plus
+  `FORMAT_VERSION` before completing cache state.
+- Map reset and orderly request draining clear pending/negative state while
+  retaining accepted Resources; final runtime cache release clears all state.
+- Missing render-cache files still are not negatively cached, preserving retry
+  and cached-scene/live fallback behavior. Formats, profiles and visuals are unchanged.
+- Asset-backed corrupt-cache, traversal/leak p95/p99 and paired fidelity evidence
+  remain pending.
+
+## 2026-07-17 WMO Scene Resource Cache State Extraction
+
+- `WmoSceneResourceCacheState` now owns validated cached-WMO PackedScenes,
+  negative entries and normalized-path to pending-`.tscn` records.
+- `StreamingWorldLoader` still checks file existence and
+  `wmo_max_runtime_scene_mb`, calls `ResourceLoader`, instantiates a validation
+  probe, checks WMOBuilder cache metadata and frees the probe before adoption.
+- Missing files, oversize scenes, request errors, load failures and stale scenes
+  retain their prior negative-cache and live-prototype fallback behavior.
+- Map reset clears pending/negative state while retaining accepted scenes; final
+  shutdown releases all scene state. Formats, profiles and visuals are unchanged.
+- Asset-backed oversize/stale fixtures, traversal/leak p95/p99 and paired fidelity
+  evidence remain pending.
+
+## 2026-07-17 ADT Water Load Pipeline State Extraction
+
+- `AdtWaterLoadPipelineState` now owns ADT water pending FIFO/deduplication,
+  active WorkerThreadPool task IDs and the mutex-protected parsed-result mailbox.
+- `StreamingWorldLoader` still selects concurrency, starts/waits tasks, invokes
+  `ADTLoader`, consumes `WATER_FINALIZE` permits, rejects stale tile/path/root
+  results and owns `water_loaded` timing. Main-thread Water subtree construction
+  and attachment are delegated separately as described below.
+- Tile release still cancels only pending water requests; active work completes
+  and its result is discarded when tile ownership is stale. Shutdown waits task
+  IDs before clearing state; reset does not interrupt workers.
+- Pending-plus-active `water` metrics, parsing, formats, materials, profiles and
+  visible behavior are unchanged.
+- Asset-backed MH2O/MCLQ fidelity, long-traversal leak/p95/p99 and paired capture
+  evidence remain pending.
+
+## 2026-07-17 ADT Water Scene Finalizer Extraction
+
+- `AdtWaterSceneFinalizer` now owns the two main-thread operations that turn
+  validated parsed ADT data into a Water subtree: the existing
+  `ADTBuilder.build_tile_water_scene` call and attachment to the tile root.
+- Both raw tile finalization and delayed cached-tile water results use the same
+  service. Optional persisted Editor ownership is assigned recursively only
+  when the loader supplies its existing edited-scene owner.
+- The service is stateless and retains no Node, Mesh, material or RID. The tile
+  SceneTree subtree remains the lifetime owner; dry data still causes ADTBuilder
+  to free its temporary empty Water root.
+- Parsing, task/result state, concurrency, stale validation, `WATER_FINALIZE`
+  permits, `enable_water` and `water_loaded` timing remain loader-owned.
+- Geometry, materials, coordinates, cache formats, profiles and visible output
+  are unchanged. Synthetic geometry/ownership evidence is not an MH2O/MCLQ or
+  original-client parity claim; asset-backed traversal/p95/p99 remains pending.
+
 ## 2026-07-16 World Environment Snapshot Facade
 
 - `WorldEnvironmentSnapshot` carries one immutable finite time-of-day value,

coordination/claims/M03-RND-ADT-WATER-LOAD-PIPELINE-001.md

@@ -0,0 +1,115 @@
+# M03-RND-ADT-WATER-LOAD-PIPELINE-001 — ADT water load pipeline state
+
+<!-- OPENWC_CLAIM:M03-RND-ADT-WATER-LOAD-PIPELINE-001:sindo-main-codex:2026-07-20 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-adt-water-load-pipeline`
+- Lease expires UTC: 2026-07-20
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Extract ADT water pending-request FIFO/deduplication, active worker task IDs and
+worker-safe result mailbox from the loader while preserving loader-owned parse,
+budget, stale-result and scene finalization behavior.
+
+## Non-goals
+
+- Instantiate `ADTLoader`, start/wait WorkerThreadPool tasks or parse ADT bytes.
+- Consume `WATER_FINALIZE` permits or choose concurrency/profile limits.
+- Build/attach/free water Nodes, materials, Meshes or RIDs.
+- Change tile/path stale checks, empty-data behavior or `water_loaded` timing.
+- Change MH2O/MCLQ parsing or claim liquid fidelity/performance parity.
+
+## Paths
+
+- Exclusive: `src/render/liquid/adt_water_load_pipeline_state.gd`,
+  `src/tools/verify_adt_water_load_pipeline_state.gd`,
+  `docs/modules/adt-water-load-pipeline-state.md`, this claim
+- Shared/hotspots: `src/scenes/streaming/streaming_world_loader.gd`,
+  `src/tools/verify_render_runtime_cache_shutdown.gd`,
+  `docs/modules/world-renderer.md`, `docs/modules/README.md`, `RENDER.md`,
+  `targets/03-renderer-facade.md`
+- Generated/ignored: `.godot`, native DLL, generated ADT resources, caches and
+  proprietary renderer corpus
+
+## Contracts and data
+
+- Pending requests preserve FIFO and tile-key deduplication.
+- Tile release removes all matching pending entries but does not cancel active work.
+- Active task IDs are loader-created opaque integers keyed by tile.
+- Worker publication and main-thread result pop/clear are mutex protected.
+- Result order and Dictionary payload identity remain unchanged.
+- Clear releases bookkeeping only; loader waits tasks at orderly shutdown.
+- Water parsing, coordinate, material, profile and visual rules are unchanged.
+
+## Dependencies
+
+- Requires: current master `4387c66`; accepted scheduler and renderer lifecycle
+- Blocks: further liquid parse/finalization decomposition
+- External state: none; verification uses synthetic task IDs and payloads
+
+## Verification
+
+- Commands: dedicated FIFO/dedupe/task/result/cancel/clear/thread/source/timing
+  verifier; shutdown, water/material and adjacent renderer/streaming/coordinate/
+  documentation/coordination gates
+- Fixtures: synthetic tile/path requests, task IDs and water dictionaries
+- Fidelity evidence: exact current queue/task/result transitions preserved
+- Performance budget: 100 cycles over 256 requests/results under 1 second
+
+## Documentation deliverables
+
+- Inline public API docs
+- Module specification with inputs/outputs, ownership and source map
+- Data-flow, lifecycle/state, worker sequence and dependency diagrams
+- World-renderer, module registry and RENDER status updates
+
+## Simplicity and naming
+
+- Important names introduced: `AdtWaterLoadPipelineState`
+- Simplest considered solution: one RefCounted with FIFO/dedupe/task maps and one mutex mailbox
+- Rejected complexity/abstractions: generic async scheduler, signals, callbacks,
+  WorkerThreadPool wrapper, parser/material ownership or multi-lane framework
+- Unavoidable complexity and justification: result mailbox crosses worker/main threads
+- Measured optimization evidence: bounded synthetic lifecycle loop
+
+## Status
+
+- State: accepted
+- Done: pipeline state implemented; loader enqueue/start/publish/drain/release/
+  reset/shutdown/metrics adapters migrated; required documentation added
+- Next: continue liquid parse/finalization extraction or another remaining M03
+  service boundary
+- Blocked by:
+
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-ADT-WATER-LOAD-PIPELINE-001:f470775 -->
+
+## Handoff
+
+- Commit: `b7c036f`
+- Results: water pipeline PASS (`cases=12`, `iterations=100`,
+  `elapsed_ms=86.170`; initial direct cold run `94.576ms`); real Thread result
+  publication, FIFO/dedupe/task/cancel/clear/source contracts PASS; WMO caches/
+  queue/planner/registry/resolver, materials, shutdown and 18 adjacent M2/terrain/
+  facade/scheduler/streaming/coordinate regressions PASS; documentation and
+  coordination gates PASS; checkpoint dry-run PASS `7/7`.
+- Remaining risks: clear does not interrupt active WorkerThreadPool work and a
+  post-reset publication remains stale until drained/cleared, matching prior
+  behavior; payload Dictionaries require no mutation after publication; parser,
+  main-thread water materialization and asset-backed MH2O/MCLQ traversal/leak/
+  p95/p99/original-client evidence remain pending.
+- Documentation updated: inline public API; new
+  `docs/modules/adt-water-load-pipeline-state.md`; module registry, world renderer
+  and `RENDER.md`; data-flow/state/sequence/dependency diagrams, ownership,
+  threading, failure/recovery, profiles, performance limit and source map included.
+- Integration: merged as `f470775`; post-merge water pipeline (`cases=12`,
+  `iterations=100`, `elapsed_ms=86.935`), shutdown, renderer materials, facade,
+  internal-access (`private_symbols=36`), `7/7` manifest, documentation and
+  coordination gates passed.
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-ADT-WATER-LOAD-PIPELINE-001:b7c036f -->

coordination/claims/M03-RND-ADT-WATER-SCENE-FINALIZER-001.md

@@ -0,0 +1,116 @@
+# M03-RND-ADT-WATER-SCENE-FINALIZER-001 — ADT water scene finalizer
+
+<!-- OPENWC_CLAIM:M03-RND-ADT-WATER-SCENE-FINALIZER-001:sindo-main-codex:2026-07-20 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-adt-water-scene-finalizer`
+- Lease expires UTC: 2026-07-20
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Extract main-thread ADT water subtree construction, tile-root attachment and
+optional recursive editor ownership from `StreamingWorldLoader` while retaining
+the existing `ADTBuilder` geometry/material implementation.
+
+## Non-goals
+
+- Parse or reinterpret MH2O/MCLQ data.
+- Own pending requests, WorkerThreadPool tasks or parsed-result delivery.
+- Consume `WATER_FINALIZE` permits or validate tile/path/result staleness.
+- Mark tile state `water_loaded` or choose whether water is enabled.
+- Change liquid geometry, materials, coordinates, cache formats or profiles.
+
+## Paths
+
+- Exclusive: `src/render/liquid/adt_water_scene_finalizer.gd`,
+  `src/tools/verify_adt_water_scene_finalizer.gd`,
+  `docs/modules/adt-water-scene-finalizer.md`, this claim
+- Shared/hotspots: `src/scenes/streaming/streaming_world_loader.gd`,
+  `src/tools/verify_adt_water_load_pipeline_state.gd`,
+  `docs/modules/adt-water-load-pipeline-state.md`,
+  `docs/modules/world-renderer.md`, `docs/modules/README.md`, `RENDER.md`,
+  `targets/03-renderer-facade.md`
+- Generated/ignored: `.godot`, native DLL, generated ADT resources, caches and
+  proprietary renderer corpus
+
+## Contracts and data
+
+- Empty water data or invalid tile root produces no Node and no scene mutation.
+- Existing `ADTBuilder.build_tile_water_scene` remains the only geometry/material source.
+- A non-empty built Water root is attached exactly once to the supplied tile root.
+- Optional editor ownership is assigned recursively only when explicitly enabled
+  and an edited scene root is available.
+- The returned Node is borrowed and remains owned by the tile SceneTree subtree.
+
+## Dependencies
+
+- Requires: accepted water pipeline package on current master `e1b2886`
+- Blocks: further liquid finalization/material responsibility extraction
+- External state: none; verification uses synthetic liquid dictionaries
+
+## Verification
+
+- Commands: dedicated empty/invalid/build/attach/editor-owner/source/timing
+  verifier; water pipeline, materials, shutdown, facade, internal-access,
+  manifest, documentation and coordination gates
+- Fixtures: synthetic one-cell liquid mask/heights and temporary Node roots
+- Fidelity evidence: exact existing ADTBuilder output and two attachment paths preserved
+- Performance budget: 100 empty finalization attempts under 1 second
+
+## Documentation deliverables
+
+- Inline public API docs
+- Module specification with inputs/outputs, ownership and source map
+- Data-flow, lifecycle/state, main-thread sequence and dependency diagrams
+- Water-pipeline, world-renderer, module registry and RENDER status updates
+
+## Simplicity and naming
+
+- Important names introduced: `AdtWaterSceneFinalizer`
+- Simplest considered solution: one RefCounted with one explicit attach operation
+- Rejected complexity/abstractions: generic scene finalizer, signals, callbacks,
+  builder interface, queue ownership or alternate liquid renderer
+- Unavoidable complexity and justification: editor-persisted generated subtrees
+  require recursive owner assignment after SceneTree attachment
+- Measured optimization evidence: bounded synthetic no-water loop
+
+## Status
+
+- State: accepted
+- Done: stateless finalizer implemented; both loader water paths migrated;
+  synthetic scene/owner regression and required documentation added
+- Next: continue liquid parsing/task execution extraction or another remaining M03 boundary
+- Blocked by:
+
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-ADT-WATER-SCENE-FINALIZER-001:874fd0f -->
+
+## Handoff
+
+- Commit: `235be3a`
+- Results: scene finalizer PASS (`cases=8`, `iterations=100`,
+  `elapsed_ms=0.042`; initial `0.024ms`); synthetic liquid produced one
+  four-vertex/six-index surface with tile attachment and recursive owner; water
+  pipeline (`119.648ms`), WMO/M2/terrain/facade/scheduler/streaming/coordinate,
+  materials, shutdown, internal-access `36` and 32 headless contract regressions
+  PASS; documentation and coordination gates PASS; checkpoint dry-run PASS `7/7`.
+- Remaining risks: main-thread mesh/material construction remains synchronous
+  behind one existing permit; the Dictionary builder boundary remains untyped;
+  proprietary MH2O/MCLQ traversal/leak/p95/p99/original-client evidence is absent.
+  A verifier launched concurrently with the initial cold editor import observed
+  the pre-existing global-class cache race; serialized editor parse and shutdown
+  rerun passed, with only expected missing private asset diagnostics.
+- Documentation updated: inline public API; new
+  `docs/modules/adt-water-scene-finalizer.md`; water-pipeline spec, module registry,
+  world renderer and `RENDER.md`; data-flow/state/sequence/dependency diagrams,
+  ownership, main-thread effects, failure/recovery, migration and source map included.
+- Integration: merged as `874fd0f`; post-merge finalizer (`cases=8`,
+  `iterations=100`, `elapsed_ms=0.025`), water pipeline (`98.398ms`), shutdown,
+  renderer materials, facade, internal-access (`private_symbols=36`), `7/7`
+  manifest, documentation and coordination gates passed.
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-ADT-WATER-SCENE-FINALIZER-001:235be3a -->

coordination/claims/M03-RND-M2-RUNTIME-REBUILD-CLASSIFIER-001.md

@@ -0,0 +1,115 @@
+# M03-RND-M2-RUNTIME-REBUILD-CLASSIFIER-001 — M2 runtime rebuild classifier
+
+<!-- OPENWC_CLAIM:M03-RND-M2-RUNTIME-REBUILD-CLASSIFIER-001:sindo-main-codex:2026-07-20 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-m2-runtime-rebuild-classifier`
+- Lease expires UTC: 2026-07-20
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Extract the memoized decision that stale cached M2 meshes require an in-memory
+runtime rebuild because raw batches contain billboard vertices or referenced UV
+rotation transforms.
+
+## Non-goals
+
+- Load raw M2 files or cache Resources.
+- Build, replace or mutate Meshes, materials, Nodes or RIDs.
+- Change `M2_MATERIAL_REFRESH_VERSION` or cache formats.
+- Interpret animation, particles, ribbons or general M2 shader fidelity.
+- Change path normalization, ResourceLoader transitions or finalize budgets.
+
+## Paths
+
+- Exclusive: `src/render/m2/m2_runtime_mesh_rebuild_classifier.gd`,
+  `src/tools/verify_m2_runtime_mesh_rebuild_classifier.gd`,
+  `docs/modules/m2-runtime-mesh-rebuild-classifier.md`, this claim
+- Shared/hotspots: `src/scenes/streaming/streaming_world_loader.gd`,
+  `docs/modules/world-renderer.md`, `docs/modules/README.md`, `RENDER.md`,
+  `targets/03-renderer-facade.md`
+- Generated/ignored: `.godot`, native DLL, generated ADT/M2 resources, caches
+  and proprietary renderer corpus
+
+## Contracts and data
+
+- Billboard metadata requires rebuild when `has_billboard` is true or
+  `billboard_vertex_count` is positive in any Dictionary batch.
+- UV rotation requires non-empty transforms and combos plus a referenced
+  non-identity `Vector4` rotation or absolute rotation speed above `0.000001`.
+- Only up to four texture stages per batch are inspected; invalid variants and
+  out-of-range combo/transform indices are skipped.
+- The first decision for a normalized path is memoized until clear, matching the
+  existing loader cache lifetime.
+
+## Dependencies
+
+- Requires: current accepted master `90b1dac`
+- Blocks: further M2 mesh request/cache/finalization extraction
+- External state: none; verification uses synthetic raw M2 Dictionaries
+
+## Verification
+
+- Commands: dedicated billboard/UV/index/stage/cache/clear/source/timing verifier;
+  M2 builder/grouper/transform/registry, materials, shutdown, facade,
+  internal-access, manifest, documentation and coordination gates
+- Fixtures: synthetic batches, transform combos and rotation dictionaries
+- Fidelity evidence: exact existing predicate thresholds, stage cap and cache lifetime preserved
+- Performance budget: 100 classifications over 256 paths under 1 second
+
+## Documentation deliverables
+
+- Inline public API docs
+- Module specification with inputs/outputs, ownership and source map
+- Data-flow, lifecycle/state, sequence and dependency diagrams
+- World-renderer, module registry and RENDER status updates
+
+## Simplicity and naming
+
+- Important names introduced: `M2RuntimeMeshRebuildClassifier`
+- Simplest considered solution: one RefCounted with one memoized query and clear
+- Rejected complexity/abstractions: generic predicate cache, strategy interface,
+  ResourceLoader wrapper, signals or typed rewrite of raw parser Dictionaries
+- Unavoidable complexity and justification: four-stage combo indirection is the
+  existing build-12340 M2 material boundary
+- Measured optimization evidence: bounded synthetic classification loop
+
+## Status
+
+- State: accepted
+- Done: classifier/cache implemented; loader query and both clear sites migrated;
+  synthetic predicate/cache verifier and required documentation added
+- Next: continue M2 mesh request/cache/finalization extraction
+- Blocked by:
+
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-M2-RUNTIME-REBUILD-CLASSIFIER-001:38f831e -->
+
+## Handoff
+
+- Commit: `19ca8f4`
+- Results: classifier PASS (`cases=12`, `iterations=100`,
+  `elapsed_ms=64.585`; initial `35.461ms`); billboard flag/count, invalid
+  variants/indices, UV rotation/speed/epsilon, four-stage cap, memoization,
+  detached diagnostics and clear contracts PASS; 33 M2/WMO/liquid/terrain/
+  facade/scheduler/streaming/coordinate/material/shutdown regressions PASS;
+  internal-access decreased to `35`; documentation and coordination gates PASS;
+  checkpoint dry-run PASS `7/7`.
+- Remaining risks: raw parser data remains Dictionary-based; the first decision
+  for a path remains authoritative until clear; classification covers the current
+  four-stage material implementation only; private asset descriptor-pressure,
+  traversal, p95/p99 and paired original-client evidence remain absent.
+- Documentation updated: inline public API; new
+  `docs/modules/m2-runtime-mesh-rebuild-classifier.md`; module registry, world
+  renderer and `RENDER.md`; data-flow/state/sequence/dependency diagrams,
+  ownership, failure/recovery, thresholds, cache lifetime and source map included.
+- Integration: merged as `38f831e`; post-merge classifier (`cases=12`,
+  `iterations=100`, `elapsed_ms=45.439`), materials, shutdown, M2 batch planner,
+  facade, internal-access (`private_symbols=35`), `7/7` manifest, documentation
+  and coordination gates passed.
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-M2-RUNTIME-REBUILD-CLASSIFIER-001:19ca8f4 -->

coordination/claims/M03-RND-WMO-RENDER-BUILD-QUEUE-001.md

@@ -0,0 +1,117 @@
+# M03-RND-WMO-RENDER-BUILD-QUEUE-001 — WMO render build queue
+
+<!-- OPENWC_CLAIM:M03-RND-WMO-RENDER-BUILD-QUEUE-001:sindo-main-codex:2026-07-20 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-wmo-render-build-queue`
+- Lease expires UTC: 2026-07-20
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Extract typed lightweight-WMO render build jobs and their FIFO key queue from
+the loader while leaving all engine-object destruction and materialization in
+the loader.
+
+## Non-goals
+
+- Queue-free Nodes or free Resources/RIDs.
+- Move material refresh, Node creation, editor ownership or budget permits.
+- Change duplicate enqueue, stale-key cleanup, cancel or clear ordering.
+- Change placement, cache loading/versioning, transforms, shadows or visibility.
+- Claim asset-backed WMO fidelity, leak acceptance or traversal p95/p99.
+
+## Paths
+
+- Exclusive: `src/render/wmo/wmo_render_build_job.gd`,
+  `src/render/wmo/wmo_render_build_queue.gd`,
+  `src/tools/verify_wmo_render_build_queue.gd`,
+  `docs/modules/wmo-render-build-queue.md`, this claim
+- Shared/hotspots: `src/scenes/streaming/streaming_world_loader.gd`,
+  `docs/modules/wmo-render-build-step-planner.md`,
+  `docs/modules/world-renderer.md`, `docs/modules/README.md`, `RENDER.md`,
+  `targets/03-renderer-facade.md`
+- Generated/ignored: `.godot`, native DLL, generated ADT/WMO resources, caches
+  and proprietary renderer corpus
+
+## Contracts and data
+
+- Typed job: placement key, strong Node3D/Resource references and two cursors
+- FIFO queue preserves duplicate key append and first-occurrence erase behavior
+- Stale front keys remain observable for loader-compatible pop-and-continue
+- Cancel releases the keyed job reference and first queued key only
+- Clear releases every job/key reference idempotently; never frees engine objects
+- Loader retains validity checks, planner invocation, cursor adoption,
+  materialization, permits, cancellation reactions and Node destruction
+- Cache/schema/coordinate/profile versions: unchanged
+
+## Dependencies
+
+- Requires: current master `1e740aa`, accepted WMO build step planner
+- Blocks: further WMO cache/load and materialization decomposition
+- External state: none; verification uses synthetic Node3D/Resource instances
+
+## Verification
+
+- Commands: dedicated invalid/FIFO/duplicate/stale/cursor/cancel/clear/
+  diagnostics/source/timing verifier; WMO planner/registry/resolver/material/
+  shutdown plus M2/terrain/facade/internal-access/manifest/scheduler/streaming/
+  coordinate/docs/coord gates
+- Fidelity evidence: exact current queue/dictionary behavior preserved
+- Performance budget: 100 cycles over 256 jobs under 1 second
+
+## Documentation deliverables
+
+- Inline job/queue API documentation
+- New module spec with inputs/outputs, data flow, state/sequence, ownership,
+  threading, failure/recovery, performance/fidelity limits and source map
+- Build-step planner, renderer module registry, world renderer and RENDER updates
+
+## Simplicity and naming
+
+- Important names: `WmoRenderBuildJob`, `WmoRenderBuildQueue`
+- Simplest solution: one typed record plus Dictionary/Array queue composition
+- Rejected complexity: generic job scheduler, signals, callbacks, mutexes,
+  Resources as job records or engine lifetime callbacks
+- Unavoidable complexity: duplicate keys can intentionally leave stale entries
+- Measured optimization evidence: bounded synthetic enqueue/cancel/clear loop
+
+## Status
+
+- State: accepted
+- Done: typed job/queue implemented; three clear sites, metrics, enqueue, drain and
+  cancel migrated; engine destruction/materialization retained in loader
+- Next: WMO cache/load state or liquid service extraction
+- Blocked by:
+
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-WMO-RENDER-BUILD-QUEUE-001:60603e1 -->
+
+## Handoff
+
+- Commit: `e576ae2` (implementation `e1bb105` plus cold-load fix)
+- Results: queue PASS (`cases=11`, `iterations=100`, `elapsed_ms=59.874`);
+  WMO planner/registry/resolver/material/shutdown and 18 adjacent M2/terrain/
+  facade/scheduler/streaming/coordinate regressions PASS; documentation and
+  coordination gates PASS; checkpoint dry-run PASS `7/7`.
+- Cold-load recovery: post-merge smoke exposed an editor class-cache dependency;
+  typed queue accessors removed the loader/global-class dependency and a fresh
+  run without `.godot` passed (`cases=11`, `elapsed_ms=57.835`).
+- Remaining risks: strong Node/Resource references require every loader cancel/
+  clear path; duplicate enqueue intentionally preserves stale FIFO keys; no
+  proprietary WMO corpus, original-client paired capture, leak run or traversal
+  p95/p99; dry-run reports expected missing ADT/DBC/character assets.
+- Documentation updated: inline job/queue API;
+  `docs/modules/wmo-render-build-queue.md`, build-step planner spec, module
+  registry, world renderer and `RENDER.md`; data-flow/state/sequence diagrams,
+  ownership, threading, failure/recovery and source map included.
+- Integration: implementation merged as `a878e7c`; its first post-merge smoke
+  exposed and rejected a cold global-class registration dependency. Fix merged
+  as `60603e1`; post-fix master queue (`cases=11`, `iterations=100`,
+  `elapsed_ms=56.454`), planner, registry, resolver, shutdown, facade,
+  documentation and coordination gates passed without parse diagnostics.
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-WMO-RENDER-BUILD-QUEUE-001:e576ae2 -->

coordination/claims/M03-RND-WMO-RENDER-RESOURCE-CACHE-001.md

@@ -0,0 +1,115 @@
+# M03-RND-WMO-RENDER-RESOURCE-CACHE-001 — WMO render resource cache state
+
+<!-- OPENWC_CLAIM:M03-RND-WMO-RENDER-RESOURCE-CACHE-001:sindo-main-codex:2026-07-20 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-wmo-render-resource-cache`
+- Lease expires UTC: 2026-07-20
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Extract lightweight-WMO render Resource cache, negative cache and asynchronous
+request bookkeeping from the loader while preserving loader-owned I/O and
+cache-format validation.
+
+## Non-goals
+
+- Call `ResourceLoader`, construct cache paths or inspect files.
+- Validate `WMOStreamingResource` script identity or format version.
+- Own cached WMO scenes, live prototypes, placement/build jobs or Nodes/RIDs.
+- Change fallback order, retry behavior, quality profiles or visual output.
+- Claim asset-backed WMO fidelity, leak acceptance or traversal p95/p99.
+
+## Paths
+
+- Exclusive: `src/render/wmo/wmo_render_resource_cache_state.gd`,
+  `src/tools/verify_wmo_render_resource_cache_state.gd`,
+  `docs/modules/wmo-render-resource-cache-state.md`, this claim
+- Shared/hotspots: `src/scenes/streaming/streaming_world_loader.gd`,
+  `src/tools/verify_render_runtime_cache_shutdown.gd`,
+  `docs/modules/wmo-render-build-queue.md`, `docs/modules/world-renderer.md`,
+  `docs/modules/README.md`, `RENDER.md`, `targets/03-renderer-facade.md`
+- Generated/ignored: `.godot`, native DLL, generated ADT/WMO resources, caches
+  and proprietary renderer corpus
+
+## Contracts and data
+
+- State keys are loader-normalized relative WMO paths copied as `String`.
+- Cached values are already validated `Resource` references.
+- Pending values are cache paths for loader-owned `ResourceLoader` requests.
+- Terminal request removal precedes validated-resource or missing-state adoption.
+- Request/missing reset preserves accepted resources; full clear releases all.
+- Cache/schema/coordinate/profile versions and validation rules remain unchanged.
+
+## Dependencies
+
+- Requires: current master `c954704`, accepted WMO render build queue
+- Blocks: further WMO cached-scene/load and materialization decomposition
+- External state: none; verification uses synthetic Resources and paths
+
+## Verification
+
+- Commands: dedicated lifecycle/request/cache/reset/diagnostics/source/timing
+  verifier; WMO queue/planner/registry/resolver/material/shutdown plus adjacent
+  renderer/streaming/coordinate/documentation/coordination gates
+- Fixtures: synthetic Resource instances and normalized relative/cache paths
+- Fidelity evidence: exact current cache/missing/request transitions preserved
+- Performance budget: 100 cycles over 256 resource/request keys under 1 second
+
+## Documentation deliverables
+
+- Inline public API docs
+- Module specification with inputs/outputs, ownership and source map
+- Data-flow, lifecycle/state and loader interaction sequence diagrams
+- World-renderer, module registry, WMO queue and RENDER status updates
+
+## Simplicity and naming
+
+- Important names introduced: `WmoRenderResourceCacheState`
+- Simplest considered solution: one RefCounted around three Dictionaries
+- Rejected complexity/abstractions: generic cache, callbacks, signals, mutexes,
+  ResourceLoader wrapper, persistence layer or shared WMO/M2 cache hierarchy
+- Unavoidable complexity and justification: partial reset must retain validated
+  Resources while discarding pending/negative state at map reset and shutdown
+- Measured optimization evidence: bounded synthetic store/request/reset loop
+
+## Status
+
+- State: accepted
+- Done: state holder implemented; loader cache/request/reset/metrics adapters
+  migrated; shutdown regression and required documentation updated
+- Next: cached WMO scene/load state or liquid service extraction
+- Blocked by:
+
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-WMO-RENDER-RESOURCE-CACHE-001:b4955d6 -->
+
+## Handoff
+
+- Commit: `d39f591`
+- Results: cache-state PASS (`cases=10`, `iterations=100`,
+  `elapsed_ms=58.727`); direct no-`.godot` cache-state run PASS (`45.361ms`);
+  WMO queue/planner/registry/resolver/material/shutdown plus 18 adjacent
+  M2/terrain/facade/scheduler/streaming/coordinate regressions PASS;
+  documentation and coordination gates PASS; checkpoint dry-run PASS `7/7`.
+- Remaining risks: accepted Resources remain strongly referenced until full
+  shutdown release; cached-scene and ResourceLoader I/O seams remain in loader;
+  no proprietary corrupt-cache fixture, asset-backed WMO traversal/leak run,
+  p95/p99 or original-client paired evidence. Full loader cannot be used as a
+  direct empty-class-cache smoke because pre-existing typed global coordinate/
+  focus dependencies require editor class registration; the extracted service
+  itself passed cold and normal editor parse passed.
+- Documentation updated: inline public API; new
+  `docs/modules/wmo-render-resource-cache-state.md`; module registry, WMO queue,
+  world renderer and `RENDER.md`; data-flow/state/sequence diagrams, ownership,
+  threading, cache-version boundary, failure/recovery and source map included.
+- Integration: merged as `b4955d6`; post-merge cache state (`cases=10`,
+  `iterations=100`, `elapsed_ms=51.949`), shutdown, WMO queue/resolver, facade,
+  internal-access (`private_symbols=41`), `7/7` manifest, documentation and
+  coordination gates passed.
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-WMO-RENDER-RESOURCE-CACHE-001:d39f591 -->

coordination/claims/M03-RND-WMO-SCENE-RESOURCE-CACHE-001.md

@@ -0,0 +1,117 @@
+# M03-RND-WMO-SCENE-RESOURCE-CACHE-001 — WMO cached-scene resource state
+
+<!-- OPENWC_CLAIM:M03-RND-WMO-SCENE-RESOURCE-CACHE-001:sindo-main-codex:2026-07-20 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-wmo-scene-resource-cache`
+- Lease expires UTC: 2026-07-20
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Extract cached-WMO `PackedScene`, negative-cache and asynchronous request state
+from the loader while preserving loader-owned file limits, I/O and scene-cache
+version validation.
+
+## Non-goals
+
+- Call `ResourceLoader`/`FileAccess`, construct `.tscn` paths or measure files.
+- Instantiate scenes or validate WMO builder cache metadata/version.
+- Own live WMO prototypes, placement/build jobs, instantiated Nodes or RIDs.
+- Change missing/oversize/request-error fallback behavior or debug output.
+- Claim asset-backed WMO fidelity, leak acceptance or traversal p95/p99.
+
+## Paths
+
+- Exclusive: `src/render/wmo/wmo_scene_resource_cache_state.gd`,
+  `src/tools/verify_wmo_scene_resource_cache_state.gd`,
+  `docs/modules/wmo-scene-resource-cache-state.md`, this claim
+- Shared/hotspots: `src/scenes/streaming/streaming_world_loader.gd`,
+  `src/tools/verify_render_runtime_cache_shutdown.gd`,
+  `docs/modules/wmo-render-resource-cache-state.md`,
+  `docs/modules/world-renderer.md`, `docs/modules/README.md`, `RENDER.md`,
+  `targets/03-renderer-facade.md`
+- Generated/ignored: `.godot`, native DLL, generated ADT/WMO resources, caches
+  and proprietary renderer corpus
+
+## Contracts and data
+
+- State keys are loader-normalized relative WMO paths copied as `String`.
+- Cached values are loader-validated `PackedScene` references.
+- Pending values are `.tscn` paths for loader-owned threaded requests.
+- Missing state accepts absent file, oversize, request-start, load and validation failures.
+- Terminal pending removal precedes validated-scene or missing adoption.
+- Transient clear retains accepted scenes; full clear releases all state.
+- Cache metadata/version, file-size limit, profile and fallback rules are unchanged.
+
+## Dependencies
+
+- Requires: current master `e690756`; accepted WMO render Resource cache state
+- Blocks: further WMO I/O/fallback and materialization decomposition
+- External state: none; verification uses synthetic PackedScenes and paths
+
+## Verification
+
+- Commands: dedicated lifecycle/request/missing/reset/diagnostics/source/timing
+  verifier; WMO render-cache/queue/planner/registry/resolver/material/shutdown plus
+  adjacent renderer/streaming/coordinate/documentation/coordination gates
+- Fixtures: synthetic PackedScene instances and normalized relative/cache paths
+- Fidelity evidence: exact current cached-scene/missing/request transitions preserved
+- Performance budget: 100 cycles over 256 scene/request keys under 1 second
+
+## Documentation deliverables
+
+- Inline public API docs
+- Module specification with inputs/outputs, ownership and source map
+- Data-flow, lifecycle/state and loader interaction sequence diagrams
+- World-renderer, module registry, render-cache and RENDER status updates
+
+## Simplicity and naming
+
+- Important names introduced: `WmoSceneResourceCacheState`
+- Simplest considered solution: one RefCounted around three Dictionaries
+- Rejected complexity/abstractions: generic cache hierarchy, callbacks, signals,
+  mutexes, ResourceLoader wrapper, persistence layer or render/scene cache merger
+- Unavoidable complexity and justification: missing can be recorded without a
+  pending request, and partial reset must retain validated PackedScenes
+- Measured optimization evidence: bounded synthetic store/request/reset loop
+
+## Status
+
+- State: accepted
+- Done: state holder implemented; loader lookup/request/drain/reset/metrics
+  adapters migrated; shutdown regression and required documentation updated
+- Next: WMO I/O/live fallback or liquid service extraction
+- Blocked by:
+
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-WMO-SCENE-RESOURCE-CACHE-001:ada0fd9 -->
+
+## Handoff
+
+- Commit: `c839294`
+- Results: scene cache-state PASS (`cases=11`, `iterations=100`,
+  `elapsed_ms=40.768`; initial direct cold run `43.636ms`); render cache-state,
+  WMO queue/planner/registry/resolver/material/shutdown plus 18 adjacent
+  M2/terrain/facade/scheduler/streaming/coordinate regressions PASS;
+  documentation and coordination gates PASS; checkpoint dry-run PASS `7/7`.
+- Remaining risks: accepted PackedScenes remain strongly referenced until full
+  shutdown release; ResourceLoader/FileAccess I/O, cache-validation probes and
+  live fallback remain in loader; no proprietary stale/oversize fixture,
+  asset-backed traversal/leak run, p95/p99 or original-client paired evidence.
+  The extracted scene state passed cold; full loader cold execution still needs
+  editor class registration for pre-existing focus/coordinate global classes.
+- Documentation updated: inline public API; new
+  `docs/modules/wmo-scene-resource-cache-state.md`; render-cache spec, module
+  registry, world renderer and `RENDER.md`; data-flow/state/sequence diagrams,
+  ownership, threading, file-size/cache-version boundary, failure/recovery and
+  source map included.
+- Integration: merged as `ada0fd9`; post-merge scene state (`cases=11`,
+  `iterations=100`, `elapsed_ms=40.113`), render state (`43.434ms`), shutdown,
+  WMO queue/resolver, facade, internal-access (`private_symbols=40`), `7/7`
+  manifest, documentation and coordination gates passed.
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-WMO-SCENE-RESOURCE-CACHE-001:c839294 -->

docs/modules/README.md

@@ -15,13 +15,19 @@
 | Terrain quality Mesh cache | Implemented extraction | [`terrain-quality-mesh-cache.md`](terrain-quality-mesh-cache.md) |
 | Terrain chunk LOD planner | Implemented extraction | [`terrain-chunk-lod-planner.md`](terrain-chunk-lod-planner.md) |
 | Terrain chunk geometry queue planner | Implemented extraction | [`terrain-chunk-geometry-queue-planner.md`](terrain-chunk-geometry-queue-planner.md) |
+| ADT water load pipeline state | Implemented extraction | [`adt-water-load-pipeline-state.md`](adt-water-load-pipeline-state.md) |
+| ADT water scene finalizer | Implemented extraction | [`adt-water-scene-finalizer.md`](adt-water-scene-finalizer.md) |
 | M2 unique placement registry | Implemented extraction | [`m2-unique-placement-registry.md`](m2-unique-placement-registry.md) |
 | M2 placement transform resolver | Implemented | [`m2-placement-transform-resolver.md`](m2-placement-transform-resolver.md) |
 | M2 placement grouper | Implemented extraction | [`m2-placement-grouper.md`](m2-placement-grouper.md) |
 | M2 build batch planner | Implemented extraction | [`m2-build-batch-planner.md`](m2-build-batch-planner.md) |
+| M2 runtime mesh rebuild classifier | Implemented extraction | [`m2-runtime-mesh-rebuild-classifier.md`](m2-runtime-mesh-rebuild-classifier.md) |
 | WMO placement resolver | Implemented extraction | [`wmo-placement-resolver.md`](wmo-placement-resolver.md) |
 | WMO placement registry | Implemented extraction | [`wmo-placement-registry.md`](wmo-placement-registry.md) |
 | WMO render build step planner | Implemented extraction | [`wmo-render-build-step-planner.md`](wmo-render-build-step-planner.md) |
+| WMO render build queue | Implemented extraction | [`wmo-render-build-queue.md`](wmo-render-build-queue.md) |
+| WMO render Resource cache state | Implemented extraction | [`wmo-render-resource-cache-state.md`](wmo-render-resource-cache-state.md) |
+| WMO scene Resource cache state | Implemented extraction | [`wmo-scene-resource-cache-state.md`](wmo-scene-resource-cache-state.md) |
 | Third-person camera | Implemented | [`third-person-camera.md`](third-person-camera.md) |
 | Character presentation | Implemented boundary / Partial fidelity | [`character-presentation.md`](character-presentation.md) |
 | Renderer | Partial | [`world-renderer.md`](world-renderer.md), [`../../RENDER.md`](../../RENDER.md) |

docs/modules/adt-water-load-pipeline-state.md

@@ -0,0 +1,252 @@
+# ADT Water Load Pipeline State
+
+## Metadata
+
+| Field | Value |
+|---|---|
+| Status | Implemented |
+| Target/work package | M03 / `M03-RND-ADT-WATER-LOAD-PIPELINE-001` |
+| Owners | ADT water pending FIFO/dedupe, active task IDs and worker-safe result mailbox |
+| Last verified | Worktree `work/sindo-main-codex/m03-adt-water-load-pipeline`, 2026-07-17 |
+| Profiles/capabilities | ADT MH2O/MCLQ water loading; profile-independent state |
+
+## Purpose
+
+Own the cross-frame and cross-thread bookkeeping for asynchronous ADT water
+loads outside `StreamingWorldLoader`: FIFO requests, queued-key deduplication,
+opaque active task IDs and parsed-result delivery. The loader retains task
+execution, parsing, budgets, stale-result decisions and scene finalization.
+
+## Non-goals
+
+- Start, cancel or wait WorkerThreadPool tasks.
+- Instantiate `ADTLoader` or interpret MH2O/MCLQ data.
+- Select concurrency limits or consume render permits.
+- Create, attach or free Nodes, Meshes, materials or RIDs.
+- Change liquid visuals, coordinates, tile acceptance or loaded-state timing.
+
+## Context and boundaries
+
+```mermaid
+flowchart LR
+    Tile[Loaded tile needing water] --> Loader[StreamingWorldLoader]
+    Loader --> State[AdtWaterLoadPipelineState]
+    State --> Request[Oldest tile/path request]
+    Request --> Loader
+    Loader --> Worker[WorkerThreadPool ADTLoader task]
+    Worker --> State
+    State --> Result[Parsed ADT result]
+    Result --> Loader
+    Loader --> Budget[WATER_FINALIZE permit]
+    Loader --> Finalizer[AdtWaterSceneFinalizer]
+    Finalizer --> Builder[ADTBuilder water scene]
+    Finalizer --> Scene[Main-thread tile Node attach]
+```
+
+Allowed dependencies are RefCounted, Dictionary/Array/String and one Godot
+`Mutex` around results. WorkerThreadPool, ADTLoader, scheduler, tile state,
+scene-tree/render resources and gameplay/editor/network are forbidden.
+
+## Public API
+
+| Symbol | Kind | Purpose | Thread/lifetime | Errors |
+|---|---|---|---|---|
+| `enqueue_request(tile_key, adt_path)` | Command/query | Append deduplicated FIFO request | Renderer main thread; until dequeue/cancel/clear | Empty/queued/active returns false |
+| `take_next_request()` | Command/query | Pop oldest request and release queued marker | Renderer main thread | Empty returns `{}` |
+| `cancel_pending_requests(tile_key)` | Command/query | Remove all matching pending entries | Tile release/main thread | Empty/unknown removes zero; active unaffected |
+| `remember_active_task(tile_key, task_id)` | Command/query | Retain loader-created opaque task ID | Main thread; until completion/clear | Empty/duplicate returns false |
+| `has_active_task` / `active_task_id_for` | Query | Test/borrow active task identity | Main thread | Unknown ID is `-1` |
+| `complete_active_task(tile_key)` | Command/query | Remove and return completed task ID | Main thread after wait | Unknown returns `-1` |
+| `active_task_ids_snapshot()` | Query | Copy IDs for orderly shutdown waiting | Main thread | Detached Array |
+| `publish_result(tile_key, path, data)` | Command/query | Append parsed result under mutex | Worker or main thread | Empty key/path returns false |
+| `has_result()` / `pop_result()` | Query/command | Observe/pop oldest result under mutex | Main-thread drain | Empty pop returns `{}` |
+| `total_load_count()` | Query | Pending plus active metric | Main thread | Results intentionally excluded |
+| `pending_request_count()` / `active_task_count()` | Query | Support loader concurrency loop | Main thread | None |
+| `clear()` | Command | Release all bookkeeping and results | Main thread after wait or map reset | Does not interrupt workers |
+| `diagnostic_snapshot()` | Query | Return detached scalar requests/tasks/results | Main thread; result mailbox locked | Water data omitted |
+
+## Inputs and outputs
+
+| Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
+|---|---|---|---|---|---|
+| Input | Tile key and ADT path | Loader tile state | Pending FIFO | Copied Strings | Until dequeue/cancel/clear |
+| Input | Opaque task ID | Loader WorkerThreadPool adapter | Active task map | Integer value | Until wait/completion/clear |
+| Input | Tile/path/parsed ADT Dictionary | Worker parser adapter | Result mailbox | Dictionary reference retained | Until pop/clear |
+| Output | Oldest request Dictionary | Pipeline state | Loader task-start adapter | Fresh record from FIFO | One start attempt |
+| Output | Active task ID snapshot | Pipeline state | Loader shutdown wait | Detached Array | Shutdown loop |
+| Output | Oldest result Dictionary | Pipeline state | Loader finalize adapter | Mailbox record transferred | One finalize attempt |
+| Output | Scalar diagnostics | Pipeline state | Verifier/future metrics | Detached records | Snapshot lifetime |
+
+Side effects are limited to collection mutation, reference retention and result
+mutex locking. Parsing, permits and scene mutation remain outside the module.
+
+## Data flow
+
+```mermaid
+flowchart TD
+    Enqueue[enqueue tile/path] --> Duplicate{Queued or active?}
+    Duplicate -->|yes| Reject[false; unchanged]
+    Duplicate -->|no| FIFO[Append FIFO and queued key]
+    FIFO --> Take[take next; release queued marker]
+    Take --> Validate[Loader checks tile/path]
+    Validate --> Start[Loader starts worker and remembers task ID]
+    Start --> Parse[Worker parses ADT]
+    Parse --> Publish[Mutex-protected publish result]
+    Publish --> Permit[Loader obtains WATER_FINALIZE permit]
+    Permit --> Pop[Pop oldest result]
+    Pop --> Wait[Loader waits task and completes active ID]
+    Wait --> Stale{Tile/path/root current?}
+    Stale -->|no| Discard[Discard result]
+    Stale -->|yes| Attach[Build and attach water scene]
+```
+
+## Lifecycle/state
+
+A tile request progresses through `Absent`, `Queued`, `Active` and
+`ResultReady`; the loader wait/completion returns bookkeeping to `Absent` before
+validating/attaching the result. Queued tile release cancels only `Queued`.
+Active work is not interrupted; a later stale result is drained and discarded.
+
+```mermaid
+stateDiagram-v2
+    [*] --> Absent
+    Absent --> Queued: accepted enqueue
+    Queued --> Absent: pending cancellation or invalid dequeue
+    Queued --> Active: loader starts task
+    Active --> ResultReady: worker publishes result
+    ResultReady --> Absent: loader waits and completes task
+    Queued --> Absent: clear
+    Active --> Absent: clear bookkeeping only
+    ResultReady --> Absent: clear
+```
+
+## Main sequence
+
+```mermaid
+sequenceDiagram
+    participant Loader as StreamingWorldLoader main thread
+    participant State as AdtWaterLoadPipelineState
+    participant Worker as WorkerThreadPool task
+    participant Budget as RenderBudgetScheduler
+    participant Finalizer as AdtWaterSceneFinalizer
+    Loader->>State: enqueue_request(tile key, ADT path)
+    Loader->>State: take_next_request()
+    Loader->>Worker: add_task(parse binding)
+    Loader->>State: remember_active_task(key, task ID)
+    Worker->>Worker: ADTLoader.load_adt(path)
+    Worker->>State: publish_result(key, path, data)
+    Note over State: result mutex protects publication/pop
+    Loader->>Budget: try_consume_permit(WATER_FINALIZE)
+    Loader->>State: pop_result()
+    Loader->>Worker: wait_for_task_completion(task ID)
+    Loader->>State: complete_active_task(key)
+    Loader->>Loader: reject stale tile/path/root
+    Loader->>Finalizer: attach_water_scene(data, origin, tile root, editor owner)
+    Loader->>Loader: mark water_loaded
+```
+
+## Dependency diagram
+
+```mermaid
+flowchart TB
+    Loader[StreamingWorldLoader] --> State[AdtWaterLoadPipelineState]
+    Loader --> Scheduler[RenderBudgetScheduler]
+    Loader --> Worker[WorkerThreadPool / ADTLoader]
+    Loader --> Finalizer[AdtWaterSceneFinalizer]
+    Finalizer --> Builder[ADTBuilder / SceneTree]
+    Worker -->|publish only| State
+    State -. no dependency .-> Scheduler
+    State -. no dependency .-> Finalizer
+```
+
+## Ownership, threading and resources
+
+- Main thread owns pending and active-task collection mutation.
+- Worker threads may call only `publish_result`; result observe/pop/clear also lock.
+- Parsed water Dictionary identity is retained until main-thread pop.
+- Loader owns WorkerThreadPool task lifetime and must wait before orderly shutdown clear.
+- Loader owns tile states and the tile subtree; `AdtWaterSceneFinalizer` performs
+  the main-thread ADTBuilder call and attachment without retaining Nodes.
+- `clear` cannot cancel a worker; post-reset publication becomes a stale result
+  and is discarded because no active task/tile ownership remains.
+
+## Errors, cancellation and recovery
+
+| Failure | Detection | Behavior | Diagnostic | Recovery |
+|---|---|---|---|---|
+| Empty/duplicate request | Enqueue guards | Reject unchanged | Contract verifier | Correct caller state |
+| Tile removed while queued | Loader release | Remove matching pending requests | Source/lifecycle verifier | Reload can enqueue later |
+| Tile removed while active | Loader stale check after result | Wait task, remove active ID, discard result | Existing metrics | Reload can enqueue later |
+| Parser unavailable/empty | Worker publishes empty Dictionary | Loader marks `water_loaded` without Node | Existing behavior | Future tile reload |
+| Path changed | Loader compares result path | Discard after task completion | Source regression | Current tile can request again |
+| Shutdown | Loader snapshots/waits active IDs | Clear all bookkeeping/results | Shutdown/source verifier | New loader starts empty |
+
+## Configuration and capabilities
+
+| Setting/capability | Default | Profile | Runtime mutable | Effect |
+|---|---|---|---|---|
+| `enable_water` | Loader setting | Quality/custom | Yes | Gates enqueue/process, unchanged |
+| `max_concurrent_water_tasks` | Loader setting | Quality/custom | Yes | Bounds active tasks outside state |
+| `water_finalize_ops_per_tick` | Loader setting | Quality/custom | Yes | Bounds result pops via scheduler |
+
+## Persistence, cache and migration
+
+No state is serialized or cached. ADT source/cache formats and liquid material
+versions are unchanged; no migration or rebuild is required.
+
+## Diagnostics and observability
+
+- `total_load_count` preserves the prior pending-plus-active `water` metric.
+- Snapshot exposes FIFO tile/path, sorted active keys and result tile/path only.
+- Parsed liquid payloads, Nodes and task internals are not exposed.
+- No logs or correlation IDs are introduced.
+
+## Verification
+
+- `verify_adt_water_load_pipeline_state.gd`: invalid/dedupe/FIFO behavior,
+  active IDs, payload identity, real Thread publication, pending cancellation,
+  clear, detached diagnostics, loader boundaries and bounded timing.
+- Existing material/shutdown/facade/streaming regressions cover adjacent behavior.
+- Fidelity evidence is preservation of current scheduling/finalize transitions;
+  no MH2O/MCLQ visual or original-client parity claim is made.
+- Performance budget: 100 cycles of 256 request/task/result transitions under 1 second.
+
+## Extension points
+
+- ADT parse execution can later move behind a parser/job adapter without changing state.
+- Water scene materialization is now delegated to `AdtWaterSceneFinalizer`,
+  independently of this async bookkeeping service.
+
+## Capability status
+
+| Capability | Status | Evidence | Gap/next step |
+|---|---|---|---|
+| ADT water load pipeline state | Implemented extraction | FIFO/task/thread/source/timing verifier | Asset-backed traversal/leak evidence pending |
+| ADT liquid parsing | Existing/loader-owned adapter | Native ADTLoader and dry-run paths | MH2O/MCLQ fidelity fixtures pending |
+| Water scene finalization | Implemented extraction | Dedicated synthetic scene/ownership verifier | Asset-backed traversal/hitch evidence pending |
+
+## Known gaps and risks
+
+- `clear` intentionally does not interrupt active WorkerThreadPool work.
+- Result payload Dictionaries are retained by reference and must not be mutated after publication.
+- Result availability and pop use separate mutex acquisitions; one serialized
+  main-thread consumer preserves ordering, but the API is not a multi-consumer queue.
+- No proprietary liquid corpus, traversal/leak run, p95/p99 or paired capture is included.
+
+## Source map
+
+| Path | Responsibility |
+|---|---|
+| `src/render/liquid/adt_water_load_pipeline_state.gd` | Request/task/result bookkeeping and result mutex |
+| `src/render/liquid/adt_water_scene_finalizer.gd` | Main-thread ADTBuilder call, attach and optional editor ownership |
+| `src/scenes/streaming/streaming_world_loader.gd` | Parse task execution, permits, stale checks and tile loaded timing |
+| `addons/mpq_extractor/loaders/adt_builder.gd` | ADT liquid geometry/material construction |
+| `src/tools/verify_adt_water_load_pipeline_state.gd` | Lifecycle/thread/boundary/timing regression |
+
+## Related decisions and references
+
+- [`world-renderer.md`](world-renderer.md)
+- [`adt-water-scene-finalizer.md`](adt-water-scene-finalizer.md)
+- [`render-budget-scheduler.md`](render-budget-scheduler.md)
+- [`../../RENDER.md`](../../RENDER.md)
+- [`../../targets/roadmap/02-rendering-and-graphics.md`](../../targets/roadmap/02-rendering-and-graphics.md)

docs/modules/adt-water-scene-finalizer.md

@@ -0,0 +1,232 @@
+# ADT Water Scene Finalizer
+
+## Metadata
+
+| Field | Value |
+|---|---|
+| Status | Implemented extraction |
+| Target/work package | M03 / `M03-RND-ADT-WATER-SCENE-FINALIZER-001` |
+| Owners | Main-thread ADT water subtree build, attach and optional editor ownership |
+| Last verified | Worktree `work/sindo-main-codex/m03-adt-water-scene-finalizer`, 2026-07-17 |
+| Profiles/capabilities | Existing ADT MH2O/MCLQ scene output; profile-independent adapter |
+
+## Purpose
+
+Provide one liquid-specific main-thread boundary for converting parsed ADT
+water data through the existing `ADTBuilder`, attaching the resulting `Water`
+subtree to a caller-owned tile root and assigning optional persisted Editor
+ownership. The service is stateless and retains no Node or Resource.
+
+## Non-goals
+
+- Parse or validate MH2O/MCLQ binary structures.
+- Replace ADTBuilder geometry, material or coordinate calculations.
+- Own water request/task/result state, permits or concurrency.
+- Validate tile/path/root freshness beyond receiving a valid root.
+- Mark `water_loaded`, enable water or remove water subtrees.
+
+## Context and boundaries
+
+```mermaid
+flowchart LR
+    Parse[Parsed ADT Dictionary] --> Loader[StreamingWorldLoader]
+    Loader -->|validated data, origin, tile root| Finalizer[AdtWaterSceneFinalizer]
+    Finalizer --> Builder[ADTBuilder]
+    Builder --> Water[Water Node3D or null]
+    Water --> Finalizer
+    Finalizer -->|main-thread add_child| Tile[Caller-owned tile root]
+    Loader -->|after return| Loaded[water_loaded timing]
+```
+
+Allowed dependencies are `ADTBuilder` and Godot Node/mesh types needed to adopt
+its output. WorkerThreadPool, scheduler, tile-state dictionaries, facade,
+gameplay, network and editor plugin packages are forbidden.
+
+## Public API
+
+| Symbol | Kind | Purpose | Thread/lifetime | Errors |
+|---|---|---|---|---|
+| `attach_water_scene(water_data, tile_origin_godot_units, tile_root, editor_owner)` | Command/query | Build and attach one existing-format water subtree | Renderer main thread; returned Node is borrowed for tile lifetime | Empty data, invalid root or dry build returns null without attachment |
+
+`editor_owner` is optional. When supplied it must be an ancestor suitable for
+Godot `Node.owner`; ownership is recursively assigned to the generated subtree.
+
+## Inputs and outputs
+
+| Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
+|---|---|---|---|---|---|
+| Input | Parsed ADT water-containing Dictionary | ADTLoader/raw tile path | Finalizer/ADTBuilder | Caller retains Dictionary; not mutated | One main-thread call |
+| Input | Tile origin in Godot world units | Loader tile state/ADTBuilder | Finalizer | Value copy | One call |
+| Input | Valid tile root | StreamingWorldLoader | Finalizer | Caller/SceneTree-owned | Must outlive call and attached subtree |
+| Input | Optional edited scene root | Loader Editor policy | Finalizer | SceneTree-owned borrowed Node | One call |
+| Output | Attached `Water` Node3D or null | Finalizer | Loader/SceneTree | Tile root owns attached Node | Tile subtree lifetime |
+
+Side effects are limited to ADTBuilder mesh/material creation, `add_child` and
+optional recursive `Node.owner` assignment. No cache, filesystem, task or tile
+state is mutated.
+
+## Data flow
+
+```mermaid
+flowchart TD
+    Input[water data + Godot origin + tile root] --> Guard{Data and root valid?}
+    Guard -->|no| None[Return null; unchanged]
+    Guard -->|yes| Build[ADTBuilder.build_tile_water_scene]
+    Build --> Dry{Water root exists?}
+    Dry -->|no| None
+    Dry -->|yes| Attach[tile root add_child]
+    Attach --> Owner{Editor owner supplied?}
+    Owner -->|yes| Assign[Assign owner recursively]
+    Owner -->|no| Return[Return borrowed root]
+    Assign --> Return
+```
+
+## Lifecycle/state
+
+The service has no retained lifecycle. Each call moves one temporary builder
+result through the following call-local states.
+
+```mermaid
+stateDiagram-v2
+    [*] --> Validating
+    Validating --> Rejected: empty data or invalid root
+    Validating --> Building: valid input
+    Building --> Dry: no geometry
+    Building --> Attached: Water root built
+    Attached --> EditorOwned: owner supplied
+    Attached --> Complete: no owner
+    EditorOwned --> Complete
+    Rejected --> [*]
+    Dry --> [*]
+    Complete --> [*]
+```
+
+## Main sequence
+
+```mermaid
+sequenceDiagram
+    participant Loader as StreamingWorldLoader main thread
+    participant Finalizer as AdtWaterSceneFinalizer
+    participant Builder as ADTBuilder
+    participant Tile as Tile root
+    Loader->>Finalizer: attach_water_scene(data, origin, tile, editor owner)
+    Finalizer->>Builder: build_tile_water_scene(data, origin)
+    Builder-->>Finalizer: Water root or null
+    alt Water root exists
+        Finalizer->>Tile: add_child(Water)
+        opt editor owner supplied
+            Finalizer->>Finalizer: assign owner recursively
+        end
+        Finalizer-->>Loader: borrowed Water root
+    else dry/invalid
+        Finalizer-->>Loader: null
+    end
+    Loader->>Loader: preserve existing water_loaded timing
+```
+
+## Dependency diagram
+
+```mermaid
+flowchart TB
+    Loader[StreamingWorldLoader] --> Finalizer[AdtWaterSceneFinalizer]
+    Finalizer --> Builder[ADTBuilder]
+    Builder --> Material[WowLiquidMaterial]
+    Finalizer --> Scene[Godot SceneTree]
+    Pipeline[AdtWaterLoadPipelineState] --> Loader
+    Scheduler[RenderBudgetScheduler] --> Loader
+    Finalizer -. no dependency .-> Pipeline
+    Finalizer -. no dependency .-> Scheduler
+```
+
+## Ownership, threading and resources
+
+- The method is main-thread only because it creates Mesh/Material/Node objects
+  and mutates the SceneTree.
+- `ADTBuilder` owns temporary construction. It frees an empty `Water` root and
+  returns null for dry/invalid liquid geometry.
+- After `add_child`, the caller's tile subtree owns the returned Water root and
+  all MeshInstance children; the finalizer retains no references.
+- Optional editor ownership affects serialization ownership only and does not
+  replace SceneTree lifetime ownership.
+- Parsed Dictionaries are borrowed and not mutated.
+
+## Errors, cancellation and recovery
+
+| Failure | Detection | Behavior | Diagnostic | Recovery |
+|---|---|---|---|---|
+| Empty parsed data | Input guard | Return null, no builder call | Contract verifier | Loader preserves existing loaded timing |
+| Missing/freed tile root | Input guard | Return null, no scene mutation | Contract verifier | Stale-result validation normally rejects earlier |
+| Dry or malformed liquid arrays | ADTBuilder returns null | No attachment | Builder/shutdown regression | Reload after corrected source |
+| Tile/path stale | Loader before call | Finalizer is not invoked | Existing loader behavior | Current tile may enqueue again |
+| Shutdown/cancellation | Loader drains/cancels before call | No retained finalizer work | Shutdown verifier | New loader starts stateless |
+
+## Configuration and capabilities
+
+| Setting/capability | Default | Profile | Runtime mutable | Effect |
+|---|---|---|---|---|
+| `enable_water` | Loader setting | Quality/custom | Yes | Gates both caller paths; not owned here |
+| `water_finalize_ops_per_tick` | `1` | Quality/custom | Yes | Budgets async calls before finalizer |
+| `editor_persist_generated_nodes` | `false` | Editor only | Yes | Supplies or omits editor owner |
+
+## Persistence, cache and migration
+
+The service writes no files and changes no cache/resource schema. Existing ADT,
+terrain cache and liquid material versions remain valid; no rebuild or migration
+is required. Persisted Editor ownership follows the loader's existing opt-in.
+
+## Diagnostics and observability
+
+- Logs: none; existing loader/builder diagnostics remain authoritative.
+- Metrics: no independent counters; existing water queue/finalize metrics remain.
+- Debug views: generated `Water/Liquid_<id>` names remain unchanged.
+- Correlation IDs: tile/path correlation stays in loader pipeline state.
+
+## Verification
+
+- `verify_adt_water_scene_finalizer.gd`: empty/invalid/dry guards, one-cell
+  geometry, attachment, recursive owner, loader delegation and bounded timing.
+- `verify_adt_water_load_pipeline_state.gd`: adjacent async ownership and loaded timing.
+- Renderer material and shutdown verifiers cover material construction and dry-root cleanup.
+- Fidelity evidence is the unchanged ADTBuilder implementation and unchanged two
+  loader call positions; no new original-client liquid parity claim is made.
+- Performance budget: 100 empty calls under one second.
+
+## Extension points
+
+- A future liquid renderer may replace the internal builder only after paired
+  MH2O/MCLQ fixtures establish equivalent geometry/material behavior.
+- Removal/eviction remains ordinary tile subtree ownership and needs no parallel API.
+
+## Capability status
+
+| Capability | Status | Evidence | Gap/next step |
+|---|---|---|---|
+| ADT water scene finalization seam | Implemented extraction | Synthetic geometry/attach/owner/source verifier | Asset-backed traversal and hitch metrics pending |
+| ADT liquid geometry/materials | Existing implementation | ADTBuilder/material/checkpoint evidence | MH2O/MCLQ and original-client parity incomplete |
+| Async water scheduling | Existing extracted state | Water pipeline verifier | Active worker interruption remains loader-owned |
+
+## Known gaps and risks
+
+- The service intentionally wraps the existing Dictionary-based ADTBuilder boundary.
+- It does not verify that `editor_owner` is an ancestor; the loader supplies the
+  edited scene root under the existing policy.
+- Mesh/material creation remains synchronous main-thread work behind the existing permit.
+- No proprietary liquid corpus, long traversal leak run, p95/p99 or paired capture is included.
+
+## Source map
+
+| Path | Responsibility |
+|---|---|
+| `src/render/liquid/adt_water_scene_finalizer.gd` | Main-thread build, attach and optional recursive editor ownership |
+| `addons/mpq_extractor/loaders/adt_builder.gd` | Existing ADT liquid geometry/material creation and dry-root cleanup |
+| `src/render/liquid/adt_water_load_pipeline_state.gd` | Pending/task/result state before finalization |
+| `src/scenes/streaming/streaming_world_loader.gd` | Permits, stale checks, tile state and finalizer calls |
+| `src/tools/verify_adt_water_scene_finalizer.gd` | Synthetic scene/ownership/boundary/timing regression |
+
+## Related decisions and references
+
+- [`adt-water-load-pipeline-state.md`](adt-water-load-pipeline-state.md)
+- [`world-renderer.md`](world-renderer.md)
+- [`render-budget-scheduler.md`](render-budget-scheduler.md)
+- [`../../RENDER.md`](../../RENDER.md)
+- [`../../targets/roadmap/02-rendering-and-graphics.md`](../../targets/roadmap/02-rendering-and-graphics.md)

docs/modules/m2-runtime-mesh-rebuild-classifier.md

@@ -0,0 +1,221 @@
+# M2 Runtime Mesh Rebuild Classifier
+
+## Metadata
+
+| Field | Value |
+|---|---|
+| Status | Implemented extraction |
+| Target/work package | M03 / `M03-RND-M2-RUNTIME-REBUILD-CLASSIFIER-001` |
+| Owners | Billboard/UV-rotation rebuild decision and per-path memoization |
+| Last verified | Worktree `work/sindo-main-codex/m03-m2-runtime-rebuild-classifier`, 2026-07-17 |
+| Profiles/capabilities | Existing M2 material-refresh path; profile-independent |
+
+## Purpose
+
+Determine whether a stale cached M2 mesh must be rebuilt in memory from raw M2
+data to restore billboard custom attributes or UV-rotation material inputs. The
+first decision is memoized by normalized relative path for the current map/
+runtime-cache lifetime.
+
+## Non-goals
+
+- Read M2 files or invoke `M2Loader`/`M2Builder`.
+- Own cached Meshes, scenes, materials, Nodes or RIDs.
+- Select cache paths, perform ResourceLoader transitions or consume permits.
+- Change refresh/cache format versions or shader behavior.
+- Classify animation, particles, ribbons or general visual fidelity.
+
+## Context and boundaries
+
+```mermaid
+flowchart LR
+    Cache[Stale cached M2 Mesh] --> Loader[StreamingWorldLoader]
+    Loader --> Raw[M2Loader raw Dictionary]
+    Raw --> Classifier[M2RuntimeMeshRebuildClassifier]
+    Classifier --> Decision[Memoized rebuild boolean]
+    Decision --> Loader
+    Loader -->|true| Builder[M2Builder rebuild]
+    Loader -->|false| Refresh[Mark material refresh version]
+```
+
+Allowed dependencies are Dictionary/Array, `PackedInt32Array`, `Vector4` and
+scalar math. Files, ResourceLoader, parser/builder classes, SceneTree,
+WorkerThreadPool, Mesh/Node/RID ownership and other layers are forbidden.
+
+## Public API
+
+| Symbol | Kind | Purpose | Thread/lifetime | Errors |
+|---|---|---|---|---|
+| `needs_runtime_mesh_rebuild(normalized_relative_path, raw_m2_data)` | Memoized query | Detect billboard or referenced UV rotation requirements | Renderer main thread; cached until clear | Invalid variants/indices are skipped; first path decision wins |
+| `clear()` | Command | Drop all memoized path decisions | Main thread; map reset/shutdown | Idempotent |
+| `cached_path_count()` | Query | Return memoized path count | Main thread | None |
+| `diagnostic_snapshot()` | Query | Return detached path/decision map | Main thread; caller-owned | None |
+
+## Inputs and outputs
+
+| Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
+|---|---|---|---|---|---|
+| Input | Normalized M2 relative path | Loader cache lookup | Classifier cache key | String value copied | Until clear |
+| Input | Raw M2 batches/transforms/combos Dictionary | Native `M2Loader` adapter | Classifier | Borrowed; not mutated | First classification call per path |
+| Output | Rebuild-required boolean | Classifier | Loader material-refresh adapter | Scalar | Memoized until clear |
+| Output | Detached decision Dictionary | Classifier | Verifier/future diagnostics | Caller-owned copy | Snapshot lifetime |
+
+Side effects are limited to inserting and clearing boolean memoization entries.
+
+## Data flow
+
+```mermaid
+flowchart TD
+    Query[path + raw M2 data] --> Cached{Path cached?}
+    Cached -->|yes| Return[Return first decision]
+    Cached -->|no| Billboard{Any billboard flag or positive vertex count?}
+    Billboard -->|yes| StoreTrue[Store true]
+    Billboard -->|no| Inputs{Transforms and combos present?}
+    Inputs -->|no| StoreFalse[Store false]
+    Inputs -->|yes| Batch[For each Dictionary batch]
+    Batch --> Stage[Inspect at most four referenced stages]
+    Stage --> Rotation{Non-identity rotation or speed above epsilon?}
+    Rotation -->|yes| StoreTrue
+    Rotation -->|no| StoreFalse
+    StoreTrue --> Return
+    StoreFalse --> Return
+```
+
+## Lifecycle/state
+
+Each path moves from unknown to one immutable cached boolean. Clear returns all
+paths to unknown; no resource lifecycle participates.
+
+```mermaid
+stateDiagram-v2
+    [*] --> Unknown
+    Unknown --> RebuildRequired: billboard or referenced UV rotation
+    Unknown --> RebuildNotRequired: no relevant metadata
+    RebuildRequired --> RebuildRequired: repeated query
+    RebuildNotRequired --> RebuildNotRequired: repeated query
+    RebuildRequired --> Unknown: clear
+    RebuildNotRequired --> Unknown: clear
+```
+
+## Main sequence
+
+```mermaid
+sequenceDiagram
+    participant Loader as StreamingWorldLoader
+    participant Native as M2Loader
+    participant Classifier as M2RuntimeMeshRebuildClassifier
+    participant Builder as M2Builder
+    Loader->>Native: load_m2(normalized path)
+    Native-->>Loader: raw Dictionary
+    Loader->>Classifier: needs_runtime_mesh_rebuild(path, data)
+    Classifier-->>Loader: memoized boolean
+    alt rebuild required
+        Loader->>Builder: rebuild mesh from raw data
+    else no rebuild required
+        Loader->>Loader: stamp material refresh version
+    end
+```
+
+## Dependency diagram
+
+```mermaid
+flowchart TB
+    Loader[StreamingWorldLoader] --> Classifier[M2RuntimeMeshRebuildClassifier]
+    Loader --> Native[M2Loader]
+    Loader --> Builder[M2Builder]
+    Loader --> Cache[M2 Mesh/Scene caches]
+    Classifier -. no dependency .-> Native
+    Classifier -. no dependency .-> Builder
+    Classifier -. no dependency .-> Cache
+```
+
+## Ownership, threading and resources
+
+- The classifier owns only normalized-path boolean entries.
+- The loader owns raw loading, cache/resource selection, Mesh replacement and
+  material refresh metadata.
+- Raw Dictionaries are borrowed and never retained; only the computed boolean is cached.
+- Current calls and clears are serialized on the renderer main thread.
+- No Node, Resource, Mesh, material or RID reference crosses into the classifier.
+
+## Errors, cancellation and recovery
+
+| Failure | Detection | Behavior | Diagnostic | Recovery |
+|---|---|---|---|---|
+| Non-Dictionary batch/transform | Type guard | Skip entry or use identity defaults | Synthetic verifier | Correct parser data on next cleared lifetime |
+| Missing transforms/combos | Empty guard | No UV-driven rebuild | Synthetic verifier | Billboard classification still applies |
+| Invalid combo/transform index | Bounds guard | Skip stage | Synthetic verifier | Correct raw data and clear |
+| Repeated path with changed data | Cache hit | Preserve first decision | Memoization fixture | Map/reset clear recomputes |
+| Load/build failure | Outside classifier | Existing mesh fallback remains | Loader diagnostics | Existing reload/fallback path |
+
+## Configuration and capabilities
+
+| Setting/capability | Default | Profile | Runtime mutable | Effect |
+|---|---|---|---|---|
+| Maximum texture stages inspected | `4` | Existing M2 material path | No | Preserves historical four-stage shader boundary |
+| UV rotation-speed epsilon | `0.000001` exclusive | Existing M2 material path | No | Larger absolute speed requires rebuild |
+| `M2_MATERIAL_REFRESH_VERSION` | Loader constant `2` | All | Code version | Gates whether classifier is called |
+
+## Persistence, cache and migration
+
+Memoized booleans are runtime-only and are cleared at the two historical loader
+reset/shutdown sites. No persisted cache version or rebuild instruction changes.
+
+## Diagnostics and observability
+
+- Logs: none.
+- Metrics: `cached_path_count` is contract-level only and not added to runtime logs.
+- Debug views: detached path-to-boolean snapshot.
+- Correlation IDs: normalized M2 relative path.
+
+## Verification
+
+- `verify_m2_runtime_mesh_rebuild_classifier.gd`: billboard flag/count, invalid
+  variants, identity/non-identity rotation, positive/negative speed, exact
+  epsilon, four-stage cap, invalid indices, memoization, clear, source boundary
+  and 100-by-256 timing.
+- Existing M2 builder/material verifiers cover downstream shader/cache behavior.
+- Fidelity evidence is exact predicate/cache extraction. No new asset-backed or
+  original-client parity claim is made.
+- Performance budget: 25,600 classifications and clears under one second.
+
+## Extension points
+
+- A typed raw M2 material descriptor may replace the Dictionary only with parser
+  fixtures and a compatibility adapter.
+- Mesh request/cache/finalization state can be extracted separately without
+  changing this rebuild predicate.
+
+## Capability status
+
+| Capability | Status | Evidence | Gap/next step |
+|---|---|---|---|
+| Billboard rebuild classification | Implemented extraction | Flag/count fixtures | Asset-backed cache refresh timing pending |
+| UV-rotation rebuild classification | Implemented extraction | Combo/stage/threshold fixtures | More build-12340 material fixtures pending |
+| Runtime memoization lifetime | Implemented extraction | First-decision/clear/source fixtures | Byte/count runtime metric not exposed |
+| M2 mesh loading/finalization | Existing loader-owned | Material/shutdown regressions | Separate state extraction pending |
+
+## Known gaps and risks
+
+- Raw parser data remains Dictionary-based.
+- The first decision wins even if different raw data is passed for the same path;
+  this intentionally preserves prior cache behavior.
+- Only four texture stages are inspected, matching current material support.
+- No private asset traversal, descriptor-pressure, p95/p99 or paired visual run is included.
+
+## Source map
+
+| Path | Responsibility |
+|---|---|
+| `src/render/m2/m2_runtime_mesh_rebuild_classifier.gd` | Predicate, thresholds and boolean memoization |
+| `src/scenes/streaming/streaming_world_loader.gd` | Raw loading, Mesh rebuild/adoption, refresh version and clear calls |
+| `addons/mpq_extractor/loaders/m2_builder.gd` | Mesh/material rebuild implementation |
+| `src/tools/verify_m2_runtime_mesh_rebuild_classifier.gd` | Synthetic predicate/cache/boundary/timing regression |
+
+## Related decisions and references
+
+- [`m2-build-batch-planner.md`](m2-build-batch-planner.md)
+- [`m2-placement-grouper.md`](m2-placement-grouper.md)
+- [`world-renderer.md`](world-renderer.md)
+- [`../../RENDER.md`](../../RENDER.md)
+- [`../../targets/roadmap/02-rendering-and-graphics.md`](../../targets/roadmap/02-rendering-and-graphics.md)

docs/modules/wmo-render-build-queue.md

@@ -0,0 +1,244 @@
+# WMO Render Build Queue
+
+## Metadata
+
+| Field | Value |
+|---|---|
+| Status | Implemented |
+| Target/work package | M03 / `M03-RND-WMO-RENDER-BUILD-QUEUE-001` |
+| Owners | Typed lightweight-WMO build jobs and FIFO placement-key queue |
+| Last verified | Worktree `work/sindo-main-codex/m03-wmo-render-build-queue`, 2026-07-17 |
+| Profiles/capabilities | Lightweight WMO render-cache path; profile-independent |
+
+## Purpose
+
+Own pending lightweight-WMO render build records and their FIFO placement-key
+order outside the monolithic loader. Each typed job retains its placement key,
+scene root, render resource and mesh/MultiMesh cursors while the loader performs
+all validation, planning, materialization, permit consumption and destruction.
+
+## Non-goals
+
+- Free or queue-free Nodes, Resources or RIDs.
+- Create MeshInstance3D/MultiMeshInstance3D or refresh materials.
+- Own frame permits, placement references, render cache state or load I/O.
+- Change duplicate enqueue, stale-key cleanup, cancellation or ordering.
+- Change cache versions, WMO transforms, shadows, visibility or fidelity rules.
+
+## Context and boundaries
+
+```mermaid
+flowchart LR
+    Placement[Successful WMO placement] --> Loader[StreamingWorldLoader]
+    Root[Node3D root] --> Loader
+    Cache[WMOStreamingResource] --> Loader
+    Loader --> Queue[WmoRenderBuildQueue]
+    Queue --> Job[WmoRenderBuildJob]
+    Job --> Loader
+    Loader --> Planner[WmoRenderBuildStepPlanner]
+    Planner --> Step[Operation and next cursors]
+    Step --> Loader
+    Loader --> Scene[Main-thread group Node attach]
+    Loader --> Budget[RenderBudgetScheduler permit]
+```
+
+The queue may strongly reference Node3D and Resource through typed jobs, but it
+must not destroy, mutate or inspect their render content. RenderingServer, RID,
+Mesh/MultiMesh instances, files, worker threads, mutexes, gameplay, network and
+editor UI are forbidden dependencies.
+
+## Public API
+
+### `WmoRenderBuildJob`
+
+| Symbol | Kind | Purpose | Thread/lifetime | Errors |
+|---|---|---|---|---|
+| constructor `(placement_key, root, render_resource)` | Constructor | Create cursor-zero job with strong references | Renderer main thread; until cancel/clear/replacement | Queue validates inputs before construction |
+| `placement_key()` | Query | Return immutable queue identity | Any serialized caller; job lifetime | None |
+| `root()` | Query | Borrow retained Node3D reference | Main thread; no ownership transfer | May later be invalid; loader checks |
+| `render_resource()` | Query | Borrow retained Resource reference | Main thread; no ownership transfer | Queue does not validate cache contents |
+| `mesh_index()` / `multimesh_index()` | Query | Return current group cursors | Serialized job drain | None |
+| `adopt_cursors(next_mesh_index, next_multimesh_index)` | Command | Atomically adopt planner cursors | Renderer main thread | Raw integers are accepted |
+| `diagnostic_snapshot()` | Query | Return detached scalar state and presence flags | Caller-owned result | Never exposes engine objects |
+
+### `WmoRenderBuildQueue`
+
+| Symbol | Kind | Purpose | Thread/lifetime | Errors |
+|---|---|---|---|---|
+| `enqueue(placement_key, root, render_resource)` | Command | Replace keyed job and append FIFO key | Renderer main thread; map session | Empty/null input returns false |
+| `has_pending()` / `pending_count()` | Query | Observe FIFO entries including duplicate/stale keys | Renderer main thread | None |
+| `active_job_count()` | Query | Count current keyed jobs | Renderer main thread | None |
+| `front_key()` / `pop_front()` | Queue operation | Inspect/remove one front FIFO key | Renderer main thread | Empty queue returns empty String |
+| `has_job(placement_key)` | Query | Distinguish a live job from a stale FIFO key | Renderer main thread | Unknown key returns false |
+| `job_for(placement_key)` | Diagnostic/test query | Borrow current job through its `RefCounted` base or return null | Renderer main thread | Runtime loader uses typed accessors instead |
+| `root_for` / `render_resource_for` | Typed query | Borrow current engine references without exposing job implementation type | Renderer main thread | Stale key returns null |
+| `mesh_index_for` / `multimesh_index_for` | Typed query | Return current cursors | Renderer main thread | Stale key returns zero |
+| `adopt_cursors(placement_key, next_mesh_index, next_multimesh_index)` | Command/query | Atomically update current job cursors | Renderer main thread | Stale key returns false |
+| `cancel(placement_key)` | Command/query | Remove keyed job and first matching FIFO key | Renderer main thread | Unknown key returns false; stale duplicates remain |
+| `clear()` | Command | Release all job/key references idempotently | Reset/shutdown | Does not free engine objects |
+| `diagnostic_snapshot()` | Query | Return detached FIFO order and key-sorted scalar jobs | Caller-owned result | None |
+
+## Inputs and outputs
+
+| Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
+|---|---|---|---|---|---|
+| Input | Resolved placement key | Placement/build adapter | Queue/job | Copied String | Until cancel/clear/replacement |
+| Input | WMO root Node3D | Loader instance adapter | Job | Strong reference; loader owns engine lifetime | Until job release |
+| Input | Validated WMOStreamingResource | Loader cache adapter | Job | Strong Resource reference; cache/loader owns semantics | Until job release |
+| Input | Next mesh/MultiMesh cursors | Build step planner through loader | Job | Integer values | Until next adoption |
+| Output | FIFO front key and typed job | Queue | Loader drain | Borrowed references | One drain iteration |
+| Output | Detached scalar diagnostics | Job/queue | Verifier/future facade adapter | Fresh values | Caller lifetime |
+
+Side effects are limited to reference retention/release, cursor mutation and
+Dictionary/Array ordering. Scene tree, material, RID, file and permit effects
+remain outside the module.
+
+## Data flow
+
+```mermaid
+flowchart TD
+    Enqueue[enqueue key/root/resource] --> Valid{Inputs valid?}
+    Valid -->|no| Reject[false; unchanged]
+    Valid -->|yes| Replace[Replace keyed typed job]
+    Replace --> Append[Append key even when duplicate]
+    Drain[front key] --> Lookup{Current keyed job exists?}
+    Lookup -->|no stale| Pop[pop front and continue]
+    Lookup -->|yes| Borrow[Borrow job to loader]
+    Borrow --> Plan[Loader invokes step planner]
+    Plan --> Adopt[Job adopts both next cursors]
+    Cancel[cancel key] --> EraseJob[Erase keyed job]
+    EraseJob --> EraseFirst[Erase first matching FIFO key]
+```
+
+## Lifecycle/state
+
+The queue can be `Empty`, `Pending` or `StaleFront`. Duplicate enqueue followed
+by cancel can intentionally produce `StaleFront`, matching the previous separate
+Dictionary/Array behavior. The loader pops a stale front without consuming a
+permit. `clear` returns every state to `Empty` without freeing engine objects.
+
+```mermaid
+stateDiagram-v2
+    [*] --> Empty
+    Empty --> Pending: valid enqueue
+    Pending --> Pending: enqueue / cursor adoption
+    Pending --> Empty: final cancel or clear
+    Pending --> StaleFront: duplicate key then cancel first occurrence
+    StaleFront --> Pending: pop stale, more live entries remain
+    StaleFront --> Empty: pop stale or clear
+```
+
+## Main sequence
+
+```mermaid
+sequenceDiagram
+    participant Loader as StreamingWorldLoader
+    participant Queue as WmoRenderBuildQueue
+    participant Job as WmoRenderBuildJob
+    participant Planner as WmoRenderBuildStepPlanner
+    Loader->>Queue: enqueue(key, root, resource)
+    loop while permit and pending key
+        Loader->>Queue: front_key + has_job
+        alt stale key
+            Loader->>Queue: pop_front
+        else live job
+            Loader->>Queue: typed root/resource/cursor accessors
+            Loader->>Planner: plan_step(counts, job cursors)
+            Planner-->>Loader: operation and next cursors
+            Loader->>Loader: materialize one group on main thread
+            Loader->>Queue: adopt_cursors(key, next mesh, next MultiMesh)
+            Loader->>Loader: consume one permit
+        end
+    end
+    Loader->>Queue: cancel(key) or clear()
+    Note over Queue: references released; Nodes/Resources not freed
+```
+
+## Ownership, threading and resources
+
+- Queue owns its job Dictionary and FIFO key Array.
+- Job owns strong references, but loader owns Node/Resource semantic lifetime.
+- Loader checks `is_instance_valid`, creates/frees Nodes and controls caches.
+- Loader invokes planner and adopts cursor output on the main thread.
+- Queue/job contain no mutex; all mutation is serialized by the renderer drain.
+- `clear` may release the last Resource reference but never calls engine free APIs.
+
+## Errors, cancellation and recovery
+
+| Failure/state | Detection | Behavior | Diagnostic | Recovery |
+|---|---|---|---|---|
+| Empty key/null root/resource | Enqueue guards | Reject without mutation | Contract verifier | Repair caller input |
+| Duplicate key | Existing keyed job | Replace job and append key | Queue diagnostics | Historical stale handling remains |
+| Stale FIFO key | `job_for` returns null | Loader pops front without permit | Contract/source verifier | Continue drain |
+| Root invalidated externally | Loader validity check | Loader cancels keyed job | Shutdown/runtime diagnostics | Placement can rebuild later |
+| Resource absent | Loader check | Loader cancels keyed job | Runtime diagnostics | Reload/requeue placement |
+| Final placement release | Placement registry returns final | Loader cancels build then frees Node | Registry/shutdown regressions | Later placement starts fresh |
+| Reset/shutdown | Loader lifecycle | Queue clear releases references | Shutdown verifier | Next map starts empty |
+
+## Configuration and capabilities
+
+The module introduces no settings or profile branches. WMO group permit count,
+quality presets, cache limits, visibility and shadows remain loader-owned.
+
+## Persistence, cache and migration
+
+No data is serialized. WMO cache format/version/path and load request behavior
+are unchanged. No migration or cache rebuild is required.
+
+## Diagnostics and observability
+
+`pending_count` preserves existing queue metrics, including stale/duplicate keys.
+The detached snapshot exposes FIFO order, cursor values and root/resource presence
+without exposing mutable jobs or engine objects. No runtime logs are emitted.
+
+## Verification
+
+- `verify_wmo_render_build_queue.gd`: invalid inputs, FIFO, typed references,
+  cursor adoption, duplicate replacement, stale pop, first-key cancel, clear,
+  engine lifetime, detached sorted diagnostics, source boundaries and timing.
+- WMO planner/registry/resolver/material/shutdown and renderer regressions verify
+  unchanged ordering, permit use, destruction and surrounding lifecycle.
+- Fidelity evidence is exact preservation of current queue/Dictionary semantics;
+  no original-client visual or asset-backed performance claim is made.
+
+## Extension points
+
+- Cache/load-request ownership can be extracted separately without changing jobs.
+- A later typed materialization command may consume the borrowed job and planner
+  output while this queue remains the pending-state owner.
+
+## Capability status
+
+| Capability | Status | Evidence | Gap/next step |
+|---|---|---|---|
+| WMO render build pending-state ownership | Implemented | Lifecycle/source/timing verifier | Asset-backed traversal/leak evidence pending |
+| WMO group planning | Implemented | Build-step planner verifier | Asset-backed p95/p99 pending |
+| WMO render Resource state | Implemented extraction | Cache-state lifecycle/source/timing verifier | Asset-backed traversal/leak evidence pending |
+| WMO materialization/cache I/O | Partial | Existing runtime regressions | Cached-scene and I/O seams remain |
+
+## Known gaps and risks
+
+- Jobs intentionally retain strong Node/Resource references until cancel/clear.
+- Duplicate enqueue preserves a stale-key edge case rather than normalizing it.
+- Resource array shape remains a WMO cache-builder invariant.
+- No proprietary WMO corpus, traversal profile or original-client paired capture
+  is included in this package.
+
+## Source map
+
+| Path | Responsibility |
+|---|---|
+| `src/render/wmo/wmo_render_build_job.gd` | Typed references and cursors |
+| `src/render/wmo/wmo_render_build_queue.gd` | Keyed jobs, FIFO order, cancel/clear and diagnostics |
+| `src/render/wmo/wmo_render_build_step_planner.gd` | Pure operation/cursor planning |
+| `src/scenes/streaming/streaming_world_loader.gd` | Validation, materialization, permits and engine destruction |
+| `src/tools/verify_wmo_render_build_queue.gd` | Lifecycle, ownership, boundary and timing regression |
+
+## Related decisions and references
+
+- [`wmo-render-build-step-planner.md`](wmo-render-build-step-planner.md)
+- [`wmo-render-resource-cache-state.md`](wmo-render-resource-cache-state.md)
+- [`wmo-placement-registry.md`](wmo-placement-registry.md)
+- [`world-renderer.md`](world-renderer.md)
+- [`../../RENDER.md`](../../RENDER.md)
+- [`../../targets/roadmap/02-rendering-and-graphics.md`](../../targets/roadmap/02-rendering-and-graphics.md)

docs/modules/wmo-render-build-step-planner.md

@@ -104,7 +104,8 @@ sequenceDiagram
 ## Ownership, threading and resources
 
 - The planner owns only call-local scalar comparisons and the returned value map.
-- The loader owns Resources, mesh arrays, build jobs/queue and cursor adoption.
+- `WmoRenderBuildQueue` owns typed jobs, FIFO keys and strong Node3D/Resource
+  references. The loader owns mesh-array interpretation and engine lifetime.
 - The loader creates and owns every MeshInstance3D/MultiMeshInstance3D and
   performs material refresh and editor-owner assignment on the main thread.
 - `RenderBudgetScheduler` owns permits; the planner neither reads nor consumes one.
@@ -149,8 +150,8 @@ existing loader/facade diagnostics.
 
 ## Extension points
 
-- WMO render build job/queue ownership may be extracted separately after a typed
-  cancellation and Resource lifetime contract exists.
+- `WmoRenderBuildQueue` now owns typed pending state; cache/load requests and
+  materialization remain separate extraction seams.
 - Materialization can later receive typed commands without changing this planner.
 
 ## Capability status
@@ -158,7 +159,7 @@ existing loader/facade diagnostics.
 | Capability | Status | Evidence | Gap/next step |
 |---|---|---|---|
 | WMO render build step planning | Implemented | Pure contract/source/timing verifier | Asset-backed traversal p95/p99 pending |
-| WMO build job/resource ownership | Partial | Existing loader/runtime regressions | Separate state/cancellation package |
+| WMO build job/queue ownership | Implemented | Typed lifecycle/source/timing verifier | Asset-backed traversal/leak evidence pending |
 | WMO visual/portal/material fidelity | Partial | Renderer baseline/material checks | Original-client paired evidence pending |
 
 ## Known gaps and risks
@@ -173,12 +174,15 @@ existing loader/facade diagnostics.
 | Path | Responsibility |
 |---|---|
 | `src/render/wmo/wmo_render_build_step_planner.gd` | Pure operation and cursor selection |
-| `src/scenes/streaming/streaming_world_loader.gd` | Resource validation, jobs/queues, materialization, permits and cancellation |
+| `src/render/wmo/wmo_render_build_job.gd` | Typed engine references and cursors |
+| `src/render/wmo/wmo_render_build_queue.gd` | Pending jobs, FIFO keys and cancellation state |
+| `src/scenes/streaming/streaming_world_loader.gd` | Resource validation, materialization, permits and engine lifetime |
 | `src/tools/verify_wmo_render_build_step_planner.gd` | Contract, boundary and timing regression |
 
 ## Related decisions and references
 
 - [`wmo-placement-registry.md`](wmo-placement-registry.md)
+- [`wmo-render-build-queue.md`](wmo-render-build-queue.md)
 - [`wmo-placement-resolver.md`](wmo-placement-resolver.md)
 - [`world-renderer.md`](world-renderer.md)
 - [`../../RENDER.md`](../../RENDER.md)

docs/modules/wmo-render-resource-cache-state.md

@@ -0,0 +1,220 @@
+# WMO Render Resource Cache State
+
+## Metadata
+
+| Field | Value |
+|---|---|
+| Status | Implemented |
+| Target/work package | M03 / `M03-RND-WMO-RENDER-RESOURCE-CACHE-001` |
+| Owners | Validated lightweight-WMO render Resources, negative cache and pending request paths |
+| Last verified | Worktree `work/sindo-main-codex/m03-wmo-render-resource-cache`, 2026-07-17 |
+| Profiles/capabilities | Lightweight WMO render-cache path; profile-independent |
+
+## Purpose
+
+Own the mutually exclusive cached, missing and pending states for normalized
+lightweight-WMO render paths outside the monolithic streamer. The state holder
+accepts only caller-validated `Resource` references and records cache paths for
+threaded requests whose I/O lifecycle remains in `StreamingWorldLoader`.
+
+## Non-goals
+
+- Normalize WMO paths or construct `.res` cache paths.
+- Call `ResourceLoader`, inspect files or validate script/format versions.
+- Own WMO cached scenes, live prototypes, placements, build jobs or engine Nodes.
+- Change fallback order, retry timing, quality profiles or visible output.
+- Persist, migrate or build WMO caches.
+
+## Context and boundaries
+
+```mermaid
+flowchart LR
+    Placement[Normalized WMO render lookup] --> Loader[StreamingWorldLoader]
+    Loader --> State[WmoRenderResourceCacheState]
+    State -->|cached Resource| Loader
+    Loader -->|cache path| ResourceLoader[Godot ResourceLoader]
+    ResourceLoader -->|status and loaded Resource| Loader
+    Loader --> Validate[Script and FORMAT_VERSION validation]
+    Validate -->|accepted Resource or missing| State
+    Loader --> Fallback[Cached scene or live-prototype fallback]
+```
+
+The module may retain validated `Resource` references and copied path Strings.
+It has no FileAccess, ResourceLoader, Node, RID, worker, mutex, gameplay, network
+or editor dependency. Cache validation stays at the I/O boundary in the loader.
+
+## Public API
+
+| Symbol | Kind | Purpose | Thread/lifetime | Errors |
+|---|---|---|---|---|
+| `resource_for(path)` | Query | Borrow validated cached Resource | Renderer main thread; until full clear | Empty/unknown returns null |
+| `contains_resource(path)` | Query | Test accepted cache state | Renderer main thread | Empty returns false |
+| `is_missing(path)` | Query | Test negative cache state | Renderer main thread | Empty returns false |
+| `has_request(path)` | Query | Test pending threaded-request state | Renderer main thread | Empty returns false |
+| `remember_request(path, cache_path)` | Command/query | Record one loader-started request | Renderer main thread; until terminal/reset | Invalid or occupied state returns false |
+| `request_paths_snapshot()` | Query | Copy pending normalized/cache-path mapping | Poll or shutdown drain | Detached Dictionary |
+| `complete_request_with_resource(path, resource)` | Command/query | Remove pending request and adopt caller-validated Resource | Terminal loader poll | Unknown/null returns false |
+| `complete_request_as_missing(path)` | Command/query | Remove pending request and adopt negative state | Terminal loader poll | Unknown returns false |
+| `clear_transient_state()` | Command | Clear pending and missing while retaining accepted Resources | Map reset/request drain | Idempotent |
+| `clear_all()` | Command | Release Resources, pending and missing | Final runtime cache release | Idempotent |
+| `pending_request_count()` | Query | Preserve renderer queue metric contribution | Renderer diagnostics | None |
+| `diagnostic_snapshot()` | Query | Return sorted detached scalar keys | Tests/diagnostics | Never exposes Resources |
+
+## Inputs and outputs
+
+| Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
+|---|---|---|---|---|---|
+| Input | Normalized relative WMO path | Placement resolver through loader | Cache state | Copied String | Map/cache lifetime |
+| Input | `.res` cache path after accepted threaded-request result | Loader | Pending state | Copied String | Until terminal/reset |
+| Input | Script/version-validated WMO Resource | Loader validation adapter | Resource cache | Strong reference | Until full clear |
+| Output | Borrowed validated Resource | Cache state | Loader render-root/build adapters | State retains reference | Lookup/build start |
+| Output | Detached pending-path snapshot | Cache state | Loader ResourceLoader polling/shutdown | Caller-owned Dictionary | One drain pass |
+| Output | Sorted scalar diagnostic keys | Cache state | Verifier/future metrics | Caller-owned values | Snapshot lifetime |
+
+## Data flow
+
+```mermaid
+flowchart TD
+    Lookup[Lookup normalized path] --> Cached{Cached?}
+    Cached -->|yes| Return[Return validated Resource]
+    Cached -->|no| Blocked{Missing or pending?}
+    Blocked -->|yes| Null[Return null; loader waits/falls back]
+    Blocked -->|no| Start[Loader starts threaded request]
+    Start --> Remember[remember_request]
+    Remember --> Poll[Loader polls detached request snapshot]
+    Poll --> Terminal{Loaded or failed?}
+    Terminal -->|no| Poll
+    Terminal -->|failed| Missing[complete as missing]
+    Terminal -->|loaded| Validate[Loader validates script/version]
+    Validate -->|valid| Adopt[complete with Resource]
+    Validate -->|invalid| Missing
+```
+
+## Lifecycle/state
+
+Each normalized path is `Absent`, `Pending`, `Cached` or `Missing`. Valid request
+completion leaves exactly one terminal state. Transient clear moves `Pending` and
+`Missing` to `Absent` but retains `Cached`; full clear moves every state to
+`Absent` and releases retained Resources.
+
+```mermaid
+stateDiagram-v2
+    [*] --> Absent
+    Absent --> Pending: remember valid request
+    Pending --> Cached: validated Resource completion
+    Pending --> Missing: load/validation failure
+    Pending --> Absent: clear transient/full
+    Missing --> Absent: clear transient/full
+    Cached --> Absent: full clear
+```
+
+## Main sequence
+
+```mermaid
+sequenceDiagram
+    participant Loader as StreamingWorldLoader
+    participant State as WmoRenderResourceCacheState
+    participant RL as ResourceLoader
+    Loader->>State: cached/missing/pending queries
+    Loader->>RL: exists + load_threaded_request(cache path)
+    Loader->>State: remember_request(normalized, cache path)
+    loop renderer tick
+        Loader->>State: request_paths_snapshot()
+        Loader->>RL: load_threaded_get_status(cache path)
+    end
+    alt load failed
+        Loader->>State: complete_request_as_missing(normalized)
+    else loaded
+        Loader->>RL: load_threaded_get(cache path)
+        Loader->>Loader: validate script and FORMAT_VERSION
+        Loader->>State: complete with Resource or as missing
+    end
+```
+
+## Ownership, threading and resources
+
+- The state owns three Dictionaries and strong references to accepted Resources.
+- The loader owns normalization, cache paths, ResourceLoader calls and validation.
+- All mutation is serialized by the renderer main-thread lookup/drain lifecycle.
+- No mutex or callback is needed; detached request snapshots permit safe removal.
+- The loader/build queue borrow Resources without transferring ownership.
+
+## Errors, cancellation and recovery
+
+| Failure/state | Detection | Behavior | Diagnostic | Recovery |
+|---|---|---|---|---|
+| Empty path/cache path | Request guard | Reject unchanged | Contract verifier | Repair caller input |
+| Duplicate or occupied path | State membership | Reject request unchanged | Contract/source verifier | Await terminal/reset |
+| Threaded load failed | Loader status | Complete as missing | Existing renderer metrics | Transient reset permits retry |
+| Wrong script/old format | Loader validation | Complete as missing | Cache-version source gate | Rebuild cache, then reset |
+| Shutdown while pending | Loader drains ResourceLoader snapshot | Clear transient afterward | Shutdown verifier | Next runtime starts absent |
+| Final cache release | Loader shutdown lifecycle | Full clear releases Resources | Shutdown verifier | Recreated with loader |
+
+## Configuration and capabilities
+
+The module adds no setting or profile branch. `wmo_render_cache_dir`, resource
+format version, request scheduling and WMO build budgets remain loader-owned.
+
+## Persistence, cache and migration
+
+The state is runtime-only and serializes nothing. `WMOStreamingResource` script
+identity and `FORMAT_VERSION` validation remain unchanged in the loader; no cache
+migration or rebuild is introduced by this extraction.
+
+## Diagnostics and observability
+
+`pending_request_count` preserves the existing `wmobuild` metric contribution.
+Diagnostics expose only sorted normalized-path keys for cached/missing/pending
+states; Resource references and cache file paths are not exposed. No logs emit.
+
+## Verification
+
+- `verify_wmo_render_resource_cache_state.gd`: invalid input, detached requests,
+  successful/missing terminal transitions, exclusivity, partial/full reset,
+  sorted diagnostics, ownership/source boundary and bounded timing.
+- `verify_render_runtime_cache_shutdown.gd`: full release of accepted Resources
+  and negative state through the loader lifecycle.
+- WMO queue/planner/registry/resolver and surrounding renderer regressions verify
+  unchanged fallback/build behavior. This package makes no visual parity claim.
+
+## Extension points
+
+- Cached WMO scene request state is a separate typed module because its size
+  limit, PackedScene validation and missing-file behavior differ.
+- A later loader I/O adapter may consume the detached request snapshot while
+  preserving this state contract and cache-version boundary.
+
+## Capability status
+
+| Capability | Status | Evidence | Gap/next step |
+|---|---|---|---|
+| Lightweight WMO render Resource state | Implemented extraction | Lifecycle/source/timing and shutdown verifiers | Asset-backed traversal/leak evidence pending |
+| Cache script/version validation | Preserved in loader | Source boundary and WMO regressions | Dedicated corrupt-cache fixture could follow |
+| Cached WMO scene state | Implemented extraction | Scene-cache lifecycle/source/timing verifier | Asset-backed traversal/leak evidence pending |
+| WMO materialization | Partial/loader-owned | Queue/planner regressions | Further safe extraction |
+
+## Known gaps and risks
+
+- Strong Resource references live until final cache release, matching prior state.
+- Missing cache files remain unrecorded for render Resources, so lookup can retry;
+  this intentionally differs from the cached-scene path.
+- No proprietary WMO corpus, corrupt-version fixture, leak run, traversal p95/p99
+  or paired original-client capture is included.
+
+## Source map
+
+| Path | Responsibility |
+|---|---|
+| `src/render/wmo/wmo_render_resource_cache_state.gd` | Resource/missing/request state and resets |
+| `src/scenes/streaming/streaming_world_loader.gd` | Normalize, request, poll, validate, fallback and shutdown I/O |
+| `src/tools/verify_wmo_render_resource_cache_state.gd` | State, boundary and timing regression |
+| `src/tools/verify_render_runtime_cache_shutdown.gd` | Loader final Resource ownership regression |
+
+## Related decisions and references
+
+- [`wmo-render-build-queue.md`](wmo-render-build-queue.md)
+- [`wmo-scene-resource-cache-state.md`](wmo-scene-resource-cache-state.md)
+- [`wmo-placement-resolver.md`](wmo-placement-resolver.md)
+- [`world-renderer.md`](world-renderer.md)
+- [`../../RENDER.md`](../../RENDER.md)
+- [`../../targets/roadmap/02-rendering-and-graphics.md`](../../targets/roadmap/02-rendering-and-graphics.md)

docs/modules/wmo-scene-resource-cache-state.md

@@ -0,0 +1,212 @@
+# WMO Scene Resource Cache State
+
+## Metadata
+
+| Field | Value |
+|---|---|
+| Status | Implemented |
+| Target/work package | M03 / `M03-RND-WMO-SCENE-RESOURCE-CACHE-001` |
+| Owners | Validated cached-WMO PackedScenes, negative cache and pending request paths |
+| Last verified | Worktree `work/sindo-main-codex/m03-wmo-scene-resource-cache`, 2026-07-17 |
+| Profiles/capabilities | Cached WMO `.tscn` fallback; profile-independent state |
+
+## Purpose
+
+Own mutually exclusive cached, missing and pending states for normalized WMO
+scene paths. The state accepts only caller-validated `PackedScene` references and
+records `.tscn` paths for threaded requests whose I/O, size limit and cache
+metadata validation remain in `StreamingWorldLoader`.
+
+## Non-goals
+
+- Normalize WMO paths, build `.tscn` paths or measure files.
+- Call ResourceLoader/FileAccess, instantiate scenes or validate cache metadata.
+- Own live prototypes, placement/build jobs, instantiated Nodes or RIDs.
+- Change missing, oversize, request-error, retry or fallback behavior.
+- Persist, migrate or build WMO caches.
+
+## Context and boundaries
+
+```mermaid
+flowchart LR
+    Lookup[Normalized WMO scene lookup] --> Loader[StreamingWorldLoader]
+    Loader --> State[WmoSceneResourceCacheState]
+    Loader --> Size[File existence and size limit]
+    Size --> ResourceLoader[Godot ResourceLoader]
+    ResourceLoader --> Loader
+    Loader --> Probe[Instantiate, metadata/version check, free]
+    Probe -->|accepted PackedScene or missing| State
+    Loader --> Live[Live-prototype fallback]
+```
+
+The module retains validated PackedScenes and copied paths only. ResourceLoader,
+FileAccess, WMOBuilder, Node, RID, worker, gameplay, network and editor concerns
+remain outside it.
+
+## Public API
+
+| Symbol | Kind | Purpose | Thread/lifetime | Errors |
+|---|---|---|---|---|
+| `scene_for(path)` / `contains_scene(path)` | Query | Borrow/test validated PackedScene | Renderer main thread; until full clear | Empty/unknown returns null/false |
+| `is_missing(path)` / `has_request(path)` | Query | Test negative/pending state | Renderer main thread | Empty returns false |
+| `remember_request(path, cache_path)` | Command/query | Record loader-started request | Until terminal/reset | Invalid/occupied returns false |
+| `mark_missing(path)` | Command/query | Record absent/oversize/request-start failure without pending state | Until transient/full clear | Invalid/occupied returns false |
+| `request_paths_snapshot()` | Query | Copy pending normalized/cache-path mapping | Poll/shutdown drain | Detached Dictionary |
+| `complete_request_with_scene(path, scene)` | Command/query | Remove pending and adopt validated PackedScene | Terminal poll | Unknown/null returns false |
+| `complete_request_as_missing(path)` | Command/query | Remove pending and adopt negative state | Terminal poll | Unknown returns false |
+| `clear_transient_state()` | Command | Clear pending/missing and retain scenes | Map reset/request drain | Idempotent |
+| `clear_all()` | Command | Release scenes and transient state | Final runtime-cache release | Idempotent |
+| `pending_request_count()` | Query | Preserve renderer queue metric | Diagnostics | None |
+| `diagnostic_snapshot()` | Query | Return sorted detached scalar keys | Tests/diagnostics | No PackedScene exposure |
+
+## Inputs and outputs
+
+| Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
+|---|---|---|---|---|---|
+| Input | Normalized WMO path | Placement resolver through loader | State | Copied String | Cache lifetime |
+| Input | `.tscn` path after accepted request start | Loader | Pending state | Copied String | Until terminal/reset |
+| Input | Metadata/version-validated PackedScene | Loader probe adapter | Scene cache | Strong reference | Until full clear |
+| Input | Missing decision | Loader file/size/request/load/validation adapters | Negative cache | Boolean membership | Until transient/full clear |
+| Output | Borrowed PackedScene | State | Loader scene instantiation | State retains reference | Lookup/instantiate call |
+| Output | Detached request snapshot | State | Loader polling/shutdown | Caller-owned Dictionary | One drain pass |
+
+## Data flow
+
+```mermaid
+flowchart TD
+    Lookup --> Known{Cached, missing or pending?}
+    Known -->|cached| Return[Return PackedScene]
+    Known -->|missing/pending| Null[Return null]
+    Known -->|absent| Check[Loader checks file and size]
+    Check -->|missing/oversize| Mark[mark_missing]
+    Check -->|allowed| Request[Start threaded request]
+    Request -->|error| Mark
+    Request -->|accepted| Remember[remember_request]
+    Remember --> Poll[Loader polls snapshot]
+    Poll -->|failure| CompleteMissing[complete as missing]
+    Poll -->|loaded| Validate[Instantiate and validate cache metadata]
+    Validate -->|valid| CompleteScene[complete with scene]
+    Validate -->|invalid| CompleteMissing
+```
+
+## Lifecycle/state
+
+Each normalized path is `Absent`, `Pending`, `Cached` or `Missing`. Direct file,
+size and request-start rejection moves `Absent` directly to `Missing`; terminal
+loads move `Pending` to `Cached` or `Missing`. Transient clear retains `Cached`,
+while full clear returns every path to `Absent`.
+
+```mermaid
+stateDiagram-v2
+    [*] --> Absent
+    Absent --> Pending: accepted request
+    Absent --> Missing: absent, oversize or request error
+    Pending --> Cached: validated PackedScene
+    Pending --> Missing: load or validation failure
+    Pending --> Absent: transient/full clear
+    Missing --> Absent: transient/full clear
+    Cached --> Absent: full clear
+```
+
+## Main sequence
+
+```mermaid
+sequenceDiagram
+    participant Loader as StreamingWorldLoader
+    participant State as WmoSceneResourceCacheState
+    participant RL as ResourceLoader
+    Loader->>State: cached/missing/pending queries
+    Loader->>Loader: exists and wmo_max_runtime_scene_mb check
+    Loader->>RL: load_threaded_request(.tscn)
+    Loader->>State: remember_request(normalized, path)
+    loop renderer tick
+        Loader->>State: request_paths_snapshot()
+        Loader->>RL: load_threaded_get_status(path)
+    end
+    Loader->>RL: load_threaded_get(path)
+    Loader->>Loader: instantiate, validate WMO metadata, free probe
+    Loader->>State: complete with scene or as missing
+```
+
+## Ownership, threading and resources
+
+- State owns three Dictionaries and strong references to accepted PackedScenes.
+- Loader owns paths, file measurement, requests, validation and all Node lifetime.
+- All mutation is serialized on the renderer main thread; no mutex is required.
+- Detached request snapshots allow terminal removal while polling.
+- Scene instantiation borrows the PackedScene and does not transfer cache ownership.
+
+## Errors, cancellation and recovery
+
+| Failure/state | Detection | Behavior | Recovery |
+|---|---|---|---|
+| Missing `.tscn` | Loader ResourceLoader existence check | Direct missing state | Transient reset permits later retry |
+| Oversize `.tscn` | Loader byte limit | Missing plus unchanged debug log | Raise limit/rebuild, then reset |
+| Request-start/load failure | Loader error/status | Direct or terminal missing | Reset and retry later |
+| Wrong type/stale metadata | Loader PackedScene/probe validation | Terminal missing; probe freed | Rebuild cache and reset |
+| Shutdown while pending | Loader drains snapshot | Clear transient, then full cache release | New loader starts absent |
+
+## Configuration and capabilities
+
+No setting is added. `wmo_cache_dir`, `wmo_max_runtime_scene_mb`, request timing,
+quality profiles and WMO build budgets stay loader-owned.
+
+## Persistence, cache and migration
+
+The module is runtime-only. Existing WMOBuilder cache metadata/version checks
+remain unchanged and execute before state adoption. No cache format, migration or
+rebuild is introduced.
+
+## Diagnostics and observability
+
+Pending count preserves the existing `wmobuild` metric contribution. The snapshot
+exposes sorted scene/missing/request keys only. Existing oversize logging remains
+in the loader; the state emits no logs.
+
+## Verification
+
+- `verify_wmo_scene_resource_cache_state.gd`: invalid input, direct missing,
+  exclusivity, request completion, partial/full reset, diagnostics, boundaries
+  and bounded timing.
+- `verify_render_runtime_cache_shutdown.gd`: loader full release of scenes,
+  negative and pending state.
+- Adjacent WMO/renderer regressions verify unchanged lookup/fallback behavior.
+  This extraction makes no visual or build-12340 parity claim.
+
+## Extension points
+
+- A later I/O adapter may consume request snapshots while retaining this contract.
+- Scene instantiation/material preparation can be extracted separately because it
+  owns Nodes and main-thread side effects rather than cache state.
+
+## Capability status
+
+| Capability | Status | Evidence | Gap/next step |
+|---|---|---|---|
+| Cached WMO PackedScene state | Implemented extraction | Lifecycle/source/timing and shutdown verifiers | Asset-backed traversal/leak evidence pending |
+| Size and cache metadata validation | Preserved in loader | Source boundary and WMO regressions | Oversize/stale asset fixtures could follow |
+| ResourceLoader I/O and live fallback | Partial/loader-owned | Existing runtime behavior | Separate extraction if justified |
+
+## Known gaps and risks
+
+- PackedScenes remain strongly referenced until final shutdown cache release.
+- Negative caching suppresses retries until transient reset, matching prior behavior.
+- No proprietary WMO corpus, stale/oversize asset fixture, leak run, traversal
+  p95/p99 or paired original-client capture is included.
+
+## Source map
+
+| Path | Responsibility |
+|---|---|
+| `src/render/wmo/wmo_scene_resource_cache_state.gd` | Scene/missing/request state and resets |
+| `src/scenes/streaming/streaming_world_loader.gd` | Paths, file limit, requests, validation, fallback and Node lifetime |
+| `src/tools/verify_wmo_scene_resource_cache_state.gd` | State, boundary and timing regression |
+| `src/tools/verify_render_runtime_cache_shutdown.gd` | Loader final cache ownership regression |
+
+## Related decisions and references
+
+- [`wmo-render-resource-cache-state.md`](wmo-render-resource-cache-state.md)
+- [`wmo-render-build-queue.md`](wmo-render-build-queue.md)
+- [`world-renderer.md`](world-renderer.md)
+- [`../../RENDER.md`](../../RENDER.md)
+- [`../../targets/roadmap/02-rendering-and-graphics.md`](../../targets/roadmap/02-rendering-and-graphics.md)

docs/modules/world-renderer.md

@@ -7,7 +7,7 @@
 | Status | Partial |
 | Target/work package | M00 baseline; `M01-RND-STREAMING-FOCUS-001`; `M01-QAR-SERVER-SPAWN-RENDERER-001`; M03 facade/planner/scheduler/internal-access/ground/environment/entity packages; M03 terrain packages; M03 M2 packages; M03 WMO placement package |
 | Owners | Renderer workstream / milestone integrator |
-| Last verified | Worktree `work/sindo-main-codex/m03-wmo-render-build-planner`, 2026-07-17 |
+| Last verified | Worktree `work/sindo-main-codex/m03-m2-runtime-rebuild-classifier`, 2026-07-17 |
 | Profiles/capabilities | `Performance`, `Balanced`, `High`, `Custom`; Blizzlike fidelity incomplete |
 
 ## Purpose
@@ -60,6 +60,8 @@ flowchart LR
     WmoRegistry --> Loader
     Loader --> WmoBuildStep[WmoRenderBuildStepPlanner]
     WmoBuildStep --> Loader
+    Loader --> WmoBuildQueue[WmoRenderBuildQueue]
+    WmoBuildQueue --> Loader
     Native --> Parsed[Parsed tile/model data]
     Parsed --> Loader
     Loader --> Scene[SceneTree nodes]
@@ -130,9 +132,15 @@ from externally reading/writing loader-private queue, task, cache and tile-state
 | `M2PlacementTransformResolver.resolve_basis/resolve_origin_offset` | Internal pure M2 service | Resolves regular and calibrated model-specific ADT placement transforms | Worker/main thread; stateless | Unknown paths use regular basis and zero offset |
 | `M2PlacementGrouper.group_placements` | Internal pure M2 service | Validates and groups ordered tile-local placement transforms by normalized path | Worker/main thread; stateless | Invalid variants/name IDs/empty paths are skipped |
 | `M2BuildBatchPlanner.plan_batch` | Internal pure M2 service | Selects static/animated batch count and next group cursor | Main/any thread; stateless | Non-positive selected limit clamps to one; empty range completes |
+| `M2RuntimeMeshRebuildClassifier` | Internal memoized M2 service | Detects billboard/UV-rotation metadata requiring stale cached-mesh rebuild | Renderer main thread; cached until reset | Invalid variants/indices skipped; first path decision wins |
 | `WmoPlacementResolver.normalize_relative_path/resolve_unique_key/resolve_world_transform` | Internal pure WMO service | Resolves cache key, registry identity and world transform | Main/any thread; stateless | Missing UID uses tile/index fallback; transform fields use historical defaults |
 | `WmoPlacementRegistry.add_reference/release_reference/contains/active_count/diagnostic_snapshot/clear` | Internal WMO service | Owns placement-key to tile/global reference sets | Renderer main thread; map session | Empty/unknown/non-owner input is rejected without mutation |
 | `WmoRenderBuildStepPlanner.plan_step` | Internal pure WMO service | Selects one mesh-first lightweight render-group operation and next cursors | Main/any thread; stateless | Raw integer comparisons are preserved without clamping |
+| `WmoRenderBuildQueue` / `WmoRenderBuildJob` | Internal WMO pending-state service | Owns typed root/resource/cursor jobs and FIFO placement keys | Renderer main thread; map session | Invalid enqueue rejected; duplicate/stale behavior preserved |
+| `WmoRenderResourceCacheState` | Internal WMO cache-state service | Owns validated Resources, negative entries and pending cache paths | Renderer main thread; map/cache session | Invalid/occupied request and unknown completion are rejected |
+| `WmoSceneResourceCacheState` | Internal WMO cache-state service | Owns validated PackedScenes, negative entries and pending `.tscn` paths | Renderer main thread; map/cache session | Direct missing and terminal request transitions remain distinct |
+| `AdtWaterLoadPipelineState` | Internal liquid async-state service | Owns ADT water FIFO/dedupe, active task IDs and mutex result mailbox | Main-thread state; worker result publication | Invalid/duplicate requests rejected; clear does not interrupt workers |
+| `AdtWaterSceneFinalizer.attach_water_scene` | Internal liquid main-thread service | Builds and attaches one existing-format ADT Water subtree | Main thread; stateless, returned Node tile-owned | Empty/invalid/dry input returns null without attachment |
 
 Публичным contract не считаются `StreamingWorldLoader` methods/properties,
 внутренние dictionaries, queues, job records и generated node names. Scene-owned
@@ -164,6 +172,10 @@ loader configuration remains transitional composition data, not a caller API.
 | Internal WMO placement | Path, MODF placement, tile/index | Loader / `WmoPlacementResolver` | WMO caches, registry and three instance adapters | Value-only String/Transform3D | Lookup/placement lifetime |
 | Internal WMO ownership | Resolved placement key and tile/global reference key | Loader / `WmoPlacementRegistry` | Loader create/retain/final-free decisions | Registry-owned String sets; detached diagnostics | Map session or final release |
 | Internal WMO build step | Mesh/MultiMesh counts and job cursors | Loader / `WmoRenderBuildStepPlanner` | Loader materialization/cursor adapter | Fresh scalar Dictionary | One group operation |
+| Internal WMO pending build | Placement key, Node3D root, WMO Resource and cursors | Loader / `WmoRenderBuildQueue` | Loader drain and step planner adapter | Queue-owned job and strong references | Until cancel/clear/replacement |
+| Internal WMO render cache | Normalized path, cache path and validated Resource | Loader / `WmoRenderResourceCacheState` | Loader lookup, ResourceLoader poll and build queue | State-owned Resource/path references; detached request snapshots | Until transient/full clear |
+| Internal WMO scene cache | Normalized path, `.tscn` path and validated PackedScene | Loader / `WmoSceneResourceCacheState` | Loader lookup, request poll and scene instantiation | State-owned PackedScene/path references; detached request snapshots | Until transient/full clear |
+| Internal ADT water load | Tile key, ADT path, task ID and parsed Dictionary | Loader/worker / `AdtWaterLoadPipelineState` | Loader task start, budgeted drain and finalization | State-owned records; mutex result mailbox | Request through result completion/reset |
 | Output | Desired tile/detail operations | Streamer plan application | Finalize queues | Loader-owned | Cross-frame |
 | Output | Terrain/M2/WMO/liquid instances | Loader/builders | Godot world/renderer | Loader/world owner | Main-thread attach |
 | Output | Detached renderer metrics | `WorldRenderFacade` | Capture/baseline tools | Caller-owned deep copy | On demand |
@@ -214,7 +226,8 @@ flowchart TD
     M2Batch --> M2
     R --> WmoPlacement[WmoPlacementResolver]
     WmoPlacement --> WmoRegistry[WmoPlacementRegistry]
-    WmoRegistry --> WmoBuildStep[WmoRenderBuildStepPlanner]
+    WmoRegistry --> WmoBuildQueue[WmoRenderBuildQueue]
+    WmoBuildQueue --> WmoBuildStep[WmoRenderBuildStepPlanner]
     WmoBuildStep --> WMO
     R --> B[RenderBudgetScheduler permits]
     B --> Terrain[Terrain attach/upgrade]
@@ -340,8 +353,22 @@ sequenceDiagram
 - `WmoPlacementResolver` is stateless and owns only call-local cache-key,
   identity and transform values. `WmoPlacementRegistry` owns only placement-key
   reference sets. `WmoRenderBuildStepPlanner` owns only a call-local operation
-  and cursor plan. The loader retains the key-to-Node map, caches, jobs, queues,
-  resources, cursor adoption, permits, cancellation and every Node lifecycle action.
+  and cursor plan. `WmoRenderBuildQueue` owns typed pending jobs, FIFO keys and
+  strong root/resource references without freeing engine objects.
+  `WmoRenderResourceCacheState` owns validated render Resources, negative entries
+  and pending cache paths. `WmoSceneResourceCacheState` similarly owns validated
+  PackedScenes, negative entries and pending `.tscn` paths. The loader retains
+  ResourceLoader/FileAccess I/O, size and cache-version validation, live fallback,
+  materialization, permits, validity reactions and every Node lifecycle action.
+- `AdtWaterLoadPipelineState` owns pending request order/deduplication, opaque
+  active task IDs and the worker-safe parsed-result mailbox. The loader retains
+  WorkerThreadPool start/wait, ADTLoader parsing, concurrency/finalize permits,
+  stale tile/path/root checks and `water_loaded` timing. `AdtWaterSceneFinalizer`
+  performs the existing ADTBuilder call, tile attach and optional recursive
+  Editor ownership on the main thread without retaining the generated subtree.
+- `M2RuntimeMeshRebuildClassifier` owns only normalized-path boolean decisions
+  for billboard/UV-rotation material refresh. The loader retains raw M2 loading,
+  refresh-version checks, Mesh rebuild/adoption and both historical clear sites.
 - Rendered-ground query results and diagnostic snapshots are caller-owned values;
   the facade never returns Mesh, Node, tile-state or queue references.
 - Loaded-mesh ground sampling is renderer diagnostics, not authoritative gameplay
@@ -439,6 +466,17 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
   lifecycle, detached sorted diagnostics, source ownership and bounded timing.
 - WMO render build step contract: mesh-before-MultiMesh order, one-index cursor
   transition, completion/raw integer behavior, source ownership and bounded timing.
+- WMO render build queue contract: typed references/cursors, FIFO, duplicate
+  replacement, stale-front cleanup, cancel/clear engine lifetime and bounded timing.
+- WMO render Resource cache contract: invalid/duplicate request rejection,
+  validated/missing terminal transitions, transient/full reset, detached sorted
+  diagnostics, loader-owned version validation and bounded timing.
+- WMO scene Resource cache contract: direct missing sources, pending terminal
+  transitions, transient/full reset, detached diagnostics, loader-owned size/
+  metadata validation and bounded timing.
+- ADT water load pipeline contract: FIFO/dedupe, active task identity, real
+  worker-thread publication, pending-only cancellation, result payload/order,
+  clear/source boundaries and bounded timing.
 - Budget scheduler contract: exact lane exhaustion, shared chunk removal/create
   priority, independent lanes, frame reset, invalid limits, terminal cancellation,
   dependency boundaries and bounded permit timing without loading a world scene.
@@ -474,8 +512,12 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
 | M2 build batch planner | Implemented extraction | Scene-free limit/count/cursor/source/timing contract | Queue/resource state, spatial cells and asset-backed p95/p99 remain pending |
 | WMO placement resolver | Implemented extraction | Scene-free path/identity/transform/source/timing contract | Asset-backed comparison pending |
 | WMO placement registry | Implemented extraction | Scene-free ownership/lifecycle/source/timing contract | Build/resource state and asset-backed cross-tile corpus pending |
-| WMO render build step planner | Implemented extraction | Scene-free order/cursor/source/timing contract | Job/resource ownership and asset-backed traversal p95/p99 pending |
+| WMO render build step planner | Implemented extraction | Scene-free order/cursor/source/timing contract | Asset-backed traversal p95/p99 pending |
+| WMO render build queue | Implemented extraction | Typed lifecycle/order/ownership/source/timing contract | Materialization and asset-backed traversal/leak evidence pending |
+| WMO render Resource cache state | Implemented extraction | Scene-free lifecycle/exclusivity/source/timing plus shutdown contract | ResourceLoader I/O and asset-backed traversal/leak evidence pending |
+| WMO scene Resource cache state | Implemented extraction | Scene-free lifecycle/direct-missing/source/timing plus shutdown contract | ResourceLoader/live-fallback extraction and asset-backed traversal/leak evidence pending |
 | WMO rendering | Partial | Cached group rendering | Portals/rooms/material parity |
+| ADT water load pipeline state | Implemented extraction | Scene-free FIFO/task/thread/source/timing contract | Parse/finalization and asset-backed traversal/leak evidence pending |
 | Liquids | Partial | MH2O/MLIQ paths | LiquidType/depth/shore fidelity |
 | Sky/light | Partial | DBC controller/logs | Zone transition paired validation |
 | Character presentation | Prototype | Character creator/player experiment | Full customization/equipment states |
@@ -525,6 +567,9 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
 | `src/render/entities/world_entity_presenter.gd` | Main-thread entity visual subtree ownership and lifecycle |
 | `src/render/terrain/rendered_ground_sample.gd` | Immutable renderer-owned available/unavailable ground query result |
 | `src/render/terrain/terrain_quality_mesh_cache.gd` | Full-quality terrain revisit Mesh retention and LRU ownership |
+| `src/render/liquid/adt_water_load_pipeline_state.gd` | ADT water request/task/result bookkeeping and worker-safe mailbox |
+| `src/render/liquid/adt_water_scene_finalizer.gd` | Main-thread ADT water build, tile attachment and optional editor ownership |
+| `src/render/m2/m2_runtime_mesh_rebuild_classifier.gd` | Billboard/UV-rotation stale cached-mesh rebuild decision and memoization |
 | `src/render/streaming/streaming_target_planner.gd` | Scene-free wanted/retained ADT target calculation |
 | `src/render/streaming/streaming_target_policy.gd` | Immutable renderer radius/prefetch policy |
 | `src/render/streaming/streaming_target_plan.gd` | Immutable planner result with read-only tile-key sets |
@@ -537,6 +582,9 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
 | `src/tools/verify_world_entity_presentation.gd` | Entity snapshot, create/update/replace/remove and ownership regression |
 | `src/tools/verify_rendered_ground_sample.gd` | Cold-start renderer ground result invariant regression |
 | `src/tools/verify_terrain_quality_mesh_cache.gd` | Terrain cache admission, LRU, ownership and loader-boundary regression |
+| `src/tools/verify_adt_water_load_pipeline_state.gd` | ADT water FIFO/task/thread/boundary/timing regression |
+| `src/tools/verify_adt_water_scene_finalizer.gd` | Synthetic ADT water scene/ownership/boundary/timing regression |
+| `src/tools/verify_m2_runtime_mesh_rebuild_classifier.gd` | M2 rebuild predicate/cache/boundary/timing regression |
 | `src/tools/verify_streaming_target_planner.gd` | Planner behavior, dependency and bounded timing regression |
 | `src/tools/verify_render_budget_scheduler.gd` | Scheduler bounds, shared-lane priority, cancellation and timing regression |
 | `src/tools/verify_renderer_internal_access.gd` | Gameplay/EditorPlugin/registered renderer-tool boundary gate derived from private streamer fields |

src/render/liquid/adt_water_load_pipeline_state.gd

@@ -0,0 +1,167 @@
+class_name AdtWaterLoadPipelineState
+extends RefCounted
+
+## Owns ADT water request, active-task and worker-result bookkeeping. The caller
+## owns WorkerThreadPool operations, ADT parsing, permits and scene finalization.
+
+var _pending_requests: Array[Dictionary] = []
+var _queued_tile_keys: Dictionary = {}
+var _active_task_ids_by_tile_key: Dictionary = {}
+var _result_mutex := Mutex.new()
+var _results: Array[Dictionary] = []
+
+
+## Appends one tile/path request in FIFO order. Invalid, queued or active tile
+## keys are rejected without mutation.
+func enqueue_request(tile_key: String, adt_path: String) -> bool:
+	if tile_key.is_empty() or adt_path.is_empty():
+		return false
+	if _queued_tile_keys.has(tile_key) or _active_task_ids_by_tile_key.has(tile_key):
+		return false
+	_pending_requests.append({
+		"key": tile_key,
+		"path": adt_path,
+	})
+	_queued_tile_keys[tile_key] = true
+	return true
+
+
+## Removes and returns the oldest request, also releasing its queued-key marker.
+## An empty Dictionary means no pending request exists.
+func take_next_request() -> Dictionary:
+	if _pending_requests.is_empty():
+		return {}
+	var request: Dictionary = _pending_requests.pop_front()
+	_queued_tile_keys.erase(String(request.get("key", "")))
+	return request
+
+
+## Removes all pending requests for one tile without affecting active work.
+## Returns the number of removed FIFO entries.
+func cancel_pending_requests(tile_key: String) -> int:
+	if tile_key.is_empty():
+		return 0
+	_queued_tile_keys.erase(tile_key)
+	var removed_count := 0
+	for request_index in range(_pending_requests.size() - 1, -1, -1):
+		var request: Dictionary = _pending_requests[request_index]
+		if String(request.get("key", "")) != tile_key:
+			continue
+		_pending_requests.remove_at(request_index)
+		removed_count += 1
+	return removed_count
+
+
+## Records one caller-started worker task. The opaque task ID is retained until
+## the caller waits for and completes it.
+func remember_active_task(tile_key: String, task_id: int) -> bool:
+	if tile_key.is_empty() or _active_task_ids_by_tile_key.has(tile_key):
+		return false
+	_active_task_ids_by_tile_key[tile_key] = task_id
+	return true
+
+
+## Returns whether a worker task is active for the tile.
+func has_active_task(tile_key: String) -> bool:
+	return not tile_key.is_empty() and _active_task_ids_by_tile_key.has(tile_key)
+
+
+## Returns the opaque active task ID, or -1 for an unknown tile.
+func active_task_id_for(tile_key: String) -> int:
+	return int(_active_task_ids_by_tile_key.get(tile_key, -1))
+
+
+## Removes and returns one completed task ID, or -1 for an unknown tile.
+func complete_active_task(tile_key: String) -> int:
+	if tile_key.is_empty() or not _active_task_ids_by_tile_key.has(tile_key):
+		return -1
+	var task_id := int(_active_task_ids_by_tile_key[tile_key])
+	_active_task_ids_by_tile_key.erase(tile_key)
+	return task_id
+
+
+## Returns a detached snapshot of opaque task IDs for orderly shutdown waiting.
+func active_task_ids_snapshot() -> Array:
+	return _active_task_ids_by_tile_key.values().duplicate()
+
+
+## Publishes one parsed ADT result from a worker thread. Payload identity is
+## retained; the caller must not mutate it after publication.
+func publish_result(tile_key: String, adt_path: String, water_data: Dictionary) -> bool:
+	if tile_key.is_empty() or adt_path.is_empty():
+		return false
+	_result_mutex.lock()
+	_results.append({
+		"key": tile_key,
+		"path": adt_path,
+		"data": water_data,
+	})
+	_result_mutex.unlock()
+	return true
+
+
+## Returns whether a worker result is currently ready.
+func has_result() -> bool:
+	_result_mutex.lock()
+	var result_available := not _results.is_empty()
+	_result_mutex.unlock()
+	return result_available
+
+
+## Removes and returns the oldest worker result. An empty Dictionary means no
+## result was ready. Intended for the serialized renderer main thread.
+func pop_result() -> Dictionary:
+	_result_mutex.lock()
+	var result: Dictionary = {}
+	if not _results.is_empty():
+		result = _results.pop_front()
+	_result_mutex.unlock()
+	return result
+
+
+## Returns pending plus active load count for existing renderer metrics.
+func total_load_count() -> int:
+	return _pending_requests.size() + _active_task_ids_by_tile_key.size()
+
+
+## Returns the pending request count.
+func pending_request_count() -> int:
+	return _pending_requests.size()
+
+
+## Returns the active worker-task count.
+func active_task_count() -> int:
+	return _active_task_ids_by_tile_key.size()
+
+
+## Clears bookkeeping and queued results without interrupting worker tasks.
+## Orderly shutdown must wait the task-ID snapshot before calling this method.
+func clear() -> void:
+	_pending_requests.clear()
+	_queued_tile_keys.clear()
+	_active_task_ids_by_tile_key.clear()
+	_result_mutex.lock()
+	_results.clear()
+	_result_mutex.unlock()
+
+
+## Returns detached FIFO/task/result scalar diagnostics without water payloads.
+func diagnostic_snapshot() -> Dictionary:
+	var pending_requests: Array[Dictionary] = []
+	for request in _pending_requests:
+		pending_requests.append(request.duplicate())
+	var active_tile_keys: Array = _active_task_ids_by_tile_key.keys()
+	active_tile_keys.sort()
+	_result_mutex.lock()
+	var result_records: Array[Dictionary] = []
+	for result in _results:
+		result_records.append({
+			"key": String(result.get("key", "")),
+			"path": String(result.get("path", "")),
+		})
+	_result_mutex.unlock()
+	return {
+		"pending_requests": pending_requests,
+		"active_tile_keys": active_tile_keys.duplicate(),
+		"result_records": result_records,
+	}

src/render/liquid/adt_water_load_pipeline_state.gd.uid

@@ -0,0 +1 @@
+uid://pwqm3n25pnn7

src/render/liquid/adt_water_scene_finalizer.gd

@@ -0,0 +1,40 @@
+class_name AdtWaterSceneFinalizer
+extends RefCounted
+
+## Builds and attaches one ADT water subtree on the renderer main thread. The
+## supplied tile root owns the returned subtree; this service retains no state.
+
+const ADT_BUILDER_SCRIPT := preload("res://addons/mpq_extractor/loaders/adt_builder.gd")
+
+
+## Builds water from parsed ADT data and attaches it once to [param tile_root].
+## [param tile_origin_godot_units] is the existing Godot-world tile origin used
+## by [ADTBuilder]. When [param editor_owner] is non-null and is an ancestor,
+## ownership is assigned recursively for persisted Editor previews. Returns the
+## attached borrowed root, or null for empty/invalid input or dry ADT data.
+## This method mutates the SceneTree and must run on the main thread.
+func attach_water_scene(
+		water_data: Dictionary,
+		tile_origin_godot_units: Vector3,
+		tile_root: Node,
+		editor_owner: Node = null) -> Node3D:
+	if water_data.is_empty() or tile_root == null or not is_instance_valid(tile_root):
+		return null
+
+	var water_root: Node3D = ADT_BUILDER_SCRIPT.build_tile_water_scene(
+		water_data,
+		tile_origin_godot_units
+	)
+	if water_root == null:
+		return null
+
+	tile_root.add_child(water_root)
+	if editor_owner != null and is_instance_valid(editor_owner):
+		_assign_owner_recursive(water_root, editor_owner)
+	return water_root
+
+
+func _assign_owner_recursive(generated_node: Node, editor_owner: Node) -> void:
+	generated_node.owner = editor_owner
+	for child in generated_node.get_children():
+		_assign_owner_recursive(child, editor_owner)

src/render/liquid/adt_water_scene_finalizer.gd.uid

@@ -0,0 +1 @@
+uid://ck4sdc8a3kg00

src/render/m2/m2_runtime_mesh_rebuild_classifier.gd

@@ -0,0 +1,93 @@
+class_name M2RuntimeMeshRebuildClassifier
+extends RefCounted
+
+## Memoizes whether raw M2 billboard or UV-rotation metadata requires replacing
+## a stale cached runtime mesh. Owns no parser, Mesh, material, Node or RID.
+
+const UV_ROTATION_SPEED_EPSILON := 0.000001
+const MAXIMUM_TEXTURE_STAGES := 4
+
+var _rebuild_required_by_normalized_path: Dictionary = {}
+
+
+## Returns the first memoized rebuild decision for [param normalized_relative_path].
+## [param raw_m2_data] is borrowed and not mutated. The decision remains cached
+## until [method clear], matching the loader map/shutdown reset lifetime.
+func needs_runtime_mesh_rebuild(
+		normalized_relative_path: String,
+		raw_m2_data: Dictionary) -> bool:
+	if _rebuild_required_by_normalized_path.has(normalized_relative_path):
+		return bool(_rebuild_required_by_normalized_path[normalized_relative_path])
+	var rebuild_required := (
+		_raw_data_has_billboards(raw_m2_data)
+		or _raw_data_has_uv_rotation(raw_m2_data)
+	)
+	_rebuild_required_by_normalized_path[normalized_relative_path] = rebuild_required
+	return rebuild_required
+
+
+## Clears every memoized path decision. No Mesh or resource is retained or freed.
+func clear() -> void:
+	_rebuild_required_by_normalized_path.clear()
+
+
+## Returns the number of memoized normalized paths.
+func cached_path_count() -> int:
+	return _rebuild_required_by_normalized_path.size()
+
+
+## Returns a detached normalized-path to boolean decision snapshot.
+func diagnostic_snapshot() -> Dictionary:
+	return _rebuild_required_by_normalized_path.duplicate()
+
+
+func _raw_data_has_billboards(raw_m2_data: Dictionary) -> bool:
+	for batch_variant in raw_m2_data.get("batches", []):
+		if not (batch_variant is Dictionary):
+			continue
+		var batch: Dictionary = batch_variant
+		if (
+				bool(batch.get("has_billboard", false))
+				or int(batch.get("billboard_vertex_count", 0)) > 0
+		):
+			return true
+	return false
+
+
+func _raw_data_has_uv_rotation(raw_m2_data: Dictionary) -> bool:
+	var texture_transforms: Array = raw_m2_data.get("texture_transforms", [])
+	if texture_transforms.is_empty():
+		return false
+	var texture_transform_combos: PackedInt32Array = raw_m2_data.get(
+		"texture_transform_combos",
+		PackedInt32Array()
+	)
+	if texture_transform_combos.is_empty():
+		return false
+	for batch_variant in raw_m2_data.get("batches", []):
+		if not (batch_variant is Dictionary):
+			continue
+		var batch: Dictionary = batch_variant
+		var texture_count := maxi(1, int(batch.get("texture_count", 1)))
+		var base_combo_index := int(batch.get("texture_transform_combo_index", -1))
+		for texture_stage in mini(texture_count, MAXIMUM_TEXTURE_STAGES):
+			var combo_index := base_combo_index + texture_stage
+			if combo_index < 0 or combo_index >= texture_transform_combos.size():
+				continue
+			var transform_index := int(texture_transform_combos[combo_index])
+			if transform_index < 0 or transform_index >= texture_transforms.size():
+				continue
+			var texture_transform: Dictionary = (
+				texture_transforms[transform_index]
+				if texture_transforms[transform_index] is Dictionary
+				else {}
+			)
+			var rotation: Vector4 = texture_transform.get(
+				"rotation",
+				Vector4(1.0, 0.0, 0.0, 1.0)
+			)
+			if not rotation.is_equal_approx(Vector4(1.0, 0.0, 0.0, 1.0)):
+				return true
+			if absf(float(texture_transform.get("rotation_speed", 0.0))) > UV_ROTATION_SPEED_EPSILON:
+				return true
+	return false

src/render/m2/m2_runtime_mesh_rebuild_classifier.gd.uid

@@ -0,0 +1 @@
+uid://breu8vpmm88en

src/render/wmo/wmo_render_build_job.gd

@@ -0,0 +1,59 @@
+class_name WmoRenderBuildJob
+extends RefCounted
+
+## Holds one lightweight-WMO build cursor and strong engine-object references.
+## Releasing this record never frees the referenced Node or Resource.
+
+var _placement_key: String
+var _root: Node3D
+var _render_resource: Resource
+var _mesh_index: int = 0
+var _multimesh_index: int = 0
+
+
+func _init(placement_key: String, root: Node3D, render_resource: Resource) -> void:
+	_placement_key = placement_key
+	_root = root
+	_render_resource = render_resource
+
+
+## Returns the immutable placement identity used by the queue.
+func placement_key() -> String:
+	return _placement_key
+
+
+## Returns the strongly referenced scene root without transferring ownership.
+func root() -> Node3D:
+	return _root
+
+
+## Returns the strongly referenced render resource without transferring ownership.
+func render_resource() -> Resource:
+	return _render_resource
+
+
+## Returns the current mesh-group cursor.
+func mesh_index() -> int:
+	return _mesh_index
+
+
+## Returns the current doodad MultiMesh-group cursor.
+func multimesh_index() -> int:
+	return _multimesh_index
+
+
+## Atomically adopts both cursor values returned by the pure step planner.
+func adopt_cursors(next_mesh_index: int, next_multimesh_index: int) -> void:
+	_mesh_index = next_mesh_index
+	_multimesh_index = next_multimesh_index
+
+
+## Returns detached scalar state and never exposes engine-object references.
+func diagnostic_snapshot() -> Dictionary:
+	return {
+		"placement_key": _placement_key,
+		"mesh_index": _mesh_index,
+		"multimesh_index": _multimesh_index,
+		"has_root": _root != null,
+		"has_render_resource": _render_resource != null,
+	}

src/render/wmo/wmo_render_build_job.gd.uid

@@ -0,0 +1 @@
+uid://gyjq5dqueyi7

src/render/wmo/wmo_render_build_queue.gd

@@ -0,0 +1,139 @@
+class_name WmoRenderBuildQueue
+extends RefCounted
+
+## Owns pending lightweight-WMO job records and FIFO placement keys.
+
+const JOB_SCRIPT := preload("res://src/render/wmo/wmo_render_build_job.gd")
+
+var _jobs_by_placement_key: Dictionary = {}
+var _queued_placement_keys: Array[String] = []
+
+
+## Enqueues a new typed job. Duplicate placement keys replace the keyed job but
+## append another FIFO entry, preserving the loader's historical behavior.
+func enqueue(placement_key: String, root: Node3D, render_resource: Resource) -> bool:
+	if placement_key.is_empty() or root == null or render_resource == null:
+		return false
+	_jobs_by_placement_key[placement_key] = JOB_SCRIPT.new(
+		placement_key,
+		root,
+		render_resource
+	)
+	_queued_placement_keys.append(placement_key)
+	return true
+
+
+## Returns whether at least one FIFO key, including a stale key, is pending.
+func has_pending() -> bool:
+	return not _queued_placement_keys.is_empty()
+
+
+## Returns the front FIFO key, or an empty String when the queue is empty.
+func front_key() -> String:
+	if _queued_placement_keys.is_empty():
+		return ""
+	return _queued_placement_keys.front()
+
+
+## Returns whether a FIFO placement key still has a current job record.
+func has_job(placement_key: String) -> bool:
+	return _jobs_by_placement_key.has(placement_key)
+
+
+## Returns the current job record as its engine base type, or null for a stale
+## key. Runtime consumers should prefer the typed accessors below.
+func job_for(placement_key: String) -> RefCounted:
+	return _jobs_by_placement_key.get(placement_key, null) as RefCounted
+
+
+## Returns the borrowed root for a current job, or null for a stale key.
+func root_for(placement_key: String) -> Node3D:
+	var job := job_for(placement_key)
+	if job == null:
+		return null
+	return job.call("root") as Node3D
+
+
+## Returns the borrowed render resource for a current job, or null when stale.
+func render_resource_for(placement_key: String) -> Resource:
+	var job := job_for(placement_key)
+	if job == null:
+		return null
+	return job.call("render_resource") as Resource
+
+
+## Returns the current mesh cursor, or zero for a stale key.
+func mesh_index_for(placement_key: String) -> int:
+	var job := job_for(placement_key)
+	if job == null:
+		return 0
+	return int(job.call("mesh_index"))
+
+
+## Returns the current MultiMesh cursor, or zero for a stale key.
+func multimesh_index_for(placement_key: String) -> int:
+	var job := job_for(placement_key)
+	if job == null:
+		return 0
+	return int(job.call("multimesh_index"))
+
+
+## Adopts both cursors for a current job and returns whether it existed.
+func adopt_cursors(
+		placement_key: String,
+		next_mesh_index: int,
+		next_multimesh_index: int
+) -> bool:
+	var job := job_for(placement_key)
+	if job == null:
+		return false
+	job.call("adopt_cursors", next_mesh_index, next_multimesh_index)
+	return true
+
+
+## Pops and returns the front FIFO key, or an empty String when already empty.
+func pop_front() -> String:
+	if _queued_placement_keys.is_empty():
+		return ""
+	return _queued_placement_keys.pop_front()
+
+
+## Cancels the keyed job and erases only the first matching FIFO key. Returns
+## whether an active job record existed. Engine objects are never freed here.
+func cancel(placement_key: String) -> bool:
+	var had_job := _jobs_by_placement_key.has(placement_key)
+	_jobs_by_placement_key.erase(placement_key)
+	_queued_placement_keys.erase(placement_key)
+	return had_job
+
+
+## Releases all job/key references without freeing referenced engine objects.
+func clear() -> void:
+	_jobs_by_placement_key.clear()
+	_queued_placement_keys.clear()
+
+
+## Returns FIFO entry count, including duplicate and stale keys.
+func pending_count() -> int:
+	return _queued_placement_keys.size()
+
+
+## Returns active keyed job count, excluding stale FIFO keys.
+func active_job_count() -> int:
+	return _jobs_by_placement_key.size()
+
+
+## Returns detached FIFO order and placement-key-sorted scalar job diagnostics.
+func diagnostic_snapshot() -> Dictionary:
+	var placement_keys: Array = _jobs_by_placement_key.keys()
+	placement_keys.sort()
+	var jobs: Array[Dictionary] = []
+	for placement_key_variant in placement_keys:
+		var placement_key := String(placement_key_variant)
+		var job: RefCounted = job_for(placement_key)
+		if job != null:
+			jobs.append(job.call("diagnostic_snapshot") as Dictionary)
+	return {
+		"queued_placement_keys": _queued_placement_keys.duplicate(),
+		"jobs": jobs,
+	}

src/render/wmo/wmo_render_build_queue.gd.uid

@@ -0,0 +1 @@
+uid://b165sgg76lrt8

src/render/wmo/wmo_render_resource_cache_state.gd

@@ -0,0 +1,126 @@
+class_name WmoRenderResourceCacheState
+extends RefCounted
+
+## Owns validated lightweight-WMO render resources and their load state.
+## ResourceLoader I/O and cache-format validation remain caller responsibilities.
+
+var _resources_by_normalized_path: Dictionary = {}
+var _missing_normalized_paths: Dictionary = {}
+var _request_cache_paths_by_normalized_path: Dictionary = {}
+
+
+## Returns the validated cached Resource for a normalized WMO path, or null.
+func resource_for(normalized_relative_path: String) -> Resource:
+	if normalized_relative_path.is_empty():
+		return null
+	return _resources_by_normalized_path.get(normalized_relative_path) as Resource
+
+
+## Returns whether a validated Resource is cached for the normalized WMO path.
+func contains_resource(normalized_relative_path: String) -> bool:
+	return (
+		not normalized_relative_path.is_empty()
+		and _resources_by_normalized_path.has(normalized_relative_path)
+	)
+
+
+## Returns whether the normalized WMO path is in the negative cache.
+func is_missing(normalized_relative_path: String) -> bool:
+	return (
+		not normalized_relative_path.is_empty()
+		and _missing_normalized_paths.has(normalized_relative_path)
+	)
+
+
+## Returns whether the normalized WMO path has a pending threaded load request.
+func has_request(normalized_relative_path: String) -> bool:
+	return (
+		not normalized_relative_path.is_empty()
+		and _request_cache_paths_by_normalized_path.has(normalized_relative_path)
+	)
+
+
+## Records one loader-owned threaded request. Cached, missing, duplicate or empty
+## paths are rejected so each normalized WMO path has exactly one state.
+func remember_request(normalized_relative_path: String, cache_path: String) -> bool:
+	if normalized_relative_path.is_empty() or cache_path.is_empty():
+		return false
+	if (
+			_resources_by_normalized_path.has(normalized_relative_path)
+			or _missing_normalized_paths.has(normalized_relative_path)
+			or _request_cache_paths_by_normalized_path.has(normalized_relative_path)
+	):
+		return false
+	_request_cache_paths_by_normalized_path[normalized_relative_path] = cache_path
+	return true
+
+
+## Returns a detached normalized-path to cache-path snapshot for loader-owned
+## ResourceLoader polling or shutdown draining.
+func request_paths_snapshot() -> Dictionary:
+	return _request_cache_paths_by_normalized_path.duplicate()
+
+
+## Completes a pending request with a caller-validated Resource. Returns false
+## for unknown requests or null Resources and otherwise adopts the reference.
+func complete_request_with_resource(
+		normalized_relative_path: String,
+		validated_resource: Resource
+) -> bool:
+	if (
+			normalized_relative_path.is_empty()
+			or validated_resource == null
+			or not _request_cache_paths_by_normalized_path.has(normalized_relative_path)
+	):
+		return false
+	_request_cache_paths_by_normalized_path.erase(normalized_relative_path)
+	_missing_normalized_paths.erase(normalized_relative_path)
+	_resources_by_normalized_path[normalized_relative_path] = validated_resource
+	return true
+
+
+## Completes a pending request as missing after load failure or validation
+## rejection. Returns false for an unknown request.
+func complete_request_as_missing(normalized_relative_path: String) -> bool:
+	if (
+			normalized_relative_path.is_empty()
+			or not _request_cache_paths_by_normalized_path.has(normalized_relative_path)
+	):
+		return false
+	_request_cache_paths_by_normalized_path.erase(normalized_relative_path)
+	_resources_by_normalized_path.erase(normalized_relative_path)
+	_missing_normalized_paths[normalized_relative_path] = true
+	return true
+
+
+## Clears pending requests and negative entries while retaining validated
+## Resources for map reset or orderly shutdown request draining.
+func clear_transient_state() -> void:
+	_request_cache_paths_by_normalized_path.clear()
+	_missing_normalized_paths.clear()
+
+
+## Releases every cached Resource and transient entry. Safe to call repeatedly.
+func clear_all() -> void:
+	_resources_by_normalized_path.clear()
+	clear_transient_state()
+
+
+## Returns the number of pending threaded load requests.
+func pending_request_count() -> int:
+	return _request_cache_paths_by_normalized_path.size()
+
+
+## Returns detached, sorted scalar keys without exposing Resource references.
+func diagnostic_snapshot() -> Dictionary:
+	var resource_paths: Array = _resources_by_normalized_path.keys()
+	var missing_paths: Array = _missing_normalized_paths.keys()
+	var request_paths: Array = _request_cache_paths_by_normalized_path.keys()
+	resource_paths.sort()
+	missing_paths.sort()
+	request_paths.sort()
+	return {
+		"resource_paths": resource_paths.duplicate(),
+		"missing_paths": missing_paths.duplicate(),
+		"request_paths": request_paths.duplicate(),
+	}

src/render/wmo/wmo_render_resource_cache_state.gd.uid

@@ -0,0 +1 @@
+uid://b1g4s1rqrptsw

src/render/wmo/wmo_scene_resource_cache_state.gd

@@ -0,0 +1,134 @@
+class_name WmoSceneResourceCacheState
+extends RefCounted
+
+## Owns validated cached-WMO PackedScenes and their load state. File limits,
+## ResourceLoader I/O and scene-cache validation remain caller responsibilities.
+
+var _scenes_by_normalized_path: Dictionary = {}
+var _missing_normalized_paths: Dictionary = {}
+var _request_cache_paths_by_normalized_path: Dictionary = {}
+
+
+## Returns the validated PackedScene for a normalized WMO path, or null.
+func scene_for(normalized_relative_path: String) -> PackedScene:
+	if normalized_relative_path.is_empty():
+		return null
+	return _scenes_by_normalized_path.get(normalized_relative_path) as PackedScene
+
+
+## Returns whether a validated PackedScene is cached for the normalized path.
+func contains_scene(normalized_relative_path: String) -> bool:
+	return (
+		not normalized_relative_path.is_empty()
+		and _scenes_by_normalized_path.has(normalized_relative_path)
+	)
+
+
+## Returns whether the normalized path is in the negative cache.
+func is_missing(normalized_relative_path: String) -> bool:
+	return (
+		not normalized_relative_path.is_empty()
+		and _missing_normalized_paths.has(normalized_relative_path)
+	)
+
+
+## Returns whether the normalized path has a pending threaded load request.
+func has_request(normalized_relative_path: String) -> bool:
+	return (
+		not normalized_relative_path.is_empty()
+		and _request_cache_paths_by_normalized_path.has(normalized_relative_path)
+	)
+
+
+## Records one loader-started request. Occupied or empty paths are rejected.
+func remember_request(normalized_relative_path: String, cache_path: String) -> bool:
+	if normalized_relative_path.is_empty() or cache_path.is_empty():
+		return false
+	if _has_any_state(normalized_relative_path):
+		return false
+	_request_cache_paths_by_normalized_path[normalized_relative_path] = cache_path
+	return true
+
+
+## Records an absent, oversize or request-start failure without requiring a
+## pending request. Occupied and empty paths are rejected.
+func mark_missing(normalized_relative_path: String) -> bool:
+	if normalized_relative_path.is_empty() or _has_any_state(normalized_relative_path):
+		return false
+	_missing_normalized_paths[normalized_relative_path] = true
+	return true
+
+
+## Returns a detached normalized-path to cache-path snapshot for loader polling.
+func request_paths_snapshot() -> Dictionary:
+	return _request_cache_paths_by_normalized_path.duplicate()
+
+
+## Completes a pending request with a caller-validated PackedScene.
+func complete_request_with_scene(
+		normalized_relative_path: String,
+		validated_scene: PackedScene
+) -> bool:
+	if (
+			normalized_relative_path.is_empty()
+			or validated_scene == null
+			or not _request_cache_paths_by_normalized_path.has(normalized_relative_path)
+	):
+		return false
+	_request_cache_paths_by_normalized_path.erase(normalized_relative_path)
+	_missing_normalized_paths.erase(normalized_relative_path)
+	_scenes_by_normalized_path[normalized_relative_path] = validated_scene
+	return true
+
+
+## Completes a pending request as missing after load or validation failure.
+func complete_request_as_missing(normalized_relative_path: String) -> bool:
+	if (
+			normalized_relative_path.is_empty()
+			or not _request_cache_paths_by_normalized_path.has(normalized_relative_path)
+	):
+		return false
+	_request_cache_paths_by_normalized_path.erase(normalized_relative_path)
+	_scenes_by_normalized_path.erase(normalized_relative_path)
+	_missing_normalized_paths[normalized_relative_path] = true
+	return true
+
+
+## Clears pending and negative state while retaining validated PackedScenes.
+func clear_transient_state() -> void:
+	_request_cache_paths_by_normalized_path.clear()
+	_missing_normalized_paths.clear()
+
+
+## Releases every cached scene and transient entry. Safe to call repeatedly.
+func clear_all() -> void:
+	_scenes_by_normalized_path.clear()
+	clear_transient_state()
+
+
+## Returns the number of pending threaded load requests.
+func pending_request_count() -> int:
+	return _request_cache_paths_by_normalized_path.size()
+
+
+## Returns detached, sorted scalar keys without exposing PackedScene references.
+func diagnostic_snapshot() -> Dictionary:
+	var scene_paths: Array = _scenes_by_normalized_path.keys()
+	var missing_paths: Array = _missing_normalized_paths.keys()
+	var request_paths: Array = _request_cache_paths_by_normalized_path.keys()
+	scene_paths.sort()
+	missing_paths.sort()
+	request_paths.sort()
+	return {
+		"scene_paths": scene_paths.duplicate(),
+		"missing_paths": missing_paths.duplicate(),
+		"request_paths": request_paths.duplicate(),
+	}
+
+
+func _has_any_state(normalized_relative_path: String) -> bool:
+	return (
+		_scenes_by_normalized_path.has(normalized_relative_path)
+		or _missing_normalized_paths.has(normalized_relative_path)
+		or _request_cache_paths_by_normalized_path.has(normalized_relative_path)
+	)

src/render/wmo/wmo_scene_resource_cache_state.gd.uid

@@ -0,0 +1 @@
+uid://b4geepupdscu7

src/scenes/streaming/streaming_world_loader.gd

@@ -18,6 +18,15 @@ const WMO_PLACEMENT_REGISTRY_SCRIPT := preload(
 const WMO_RENDER_BUILD_STEP_PLANNER_SCRIPT := preload(
 	"res://src/render/wmo/wmo_render_build_step_planner.gd"
 )
+const WMO_RENDER_BUILD_QUEUE_SCRIPT := preload(
+	"res://src/render/wmo/wmo_render_build_queue.gd"
+)
+const WMO_RENDER_RESOURCE_CACHE_STATE_SCRIPT := preload(
+	"res://src/render/wmo/wmo_render_resource_cache_state.gd"
+)
+const WMO_SCENE_RESOURCE_CACHE_STATE_SCRIPT := preload(
+	"res://src/render/wmo/wmo_scene_resource_cache_state.gd"
+)
 const M2_BUILDER_SCRIPT := preload("res://addons/mpq_extractor/loaders/m2_builder.gd")
 const M2_NATIVE_ANIMATED_BUILDER_SCRIPT := preload("res://addons/mpq_extractor/loaders/m2_native_animated_builder.gd")
 const M2_NATIVE_ANIMATOR_SCRIPT := preload("res://src/scenes/streaming/m2_native_animator.gd")
@@ -33,6 +42,12 @@ const TERRAIN_CHUNK_LOD_PLANNER_SCRIPT := preload("res://src/render/terrain/terr
 const TERRAIN_CHUNK_GEOMETRY_QUEUE_PLANNER_SCRIPT := preload(
 	"res://src/render/terrain/terrain_chunk_geometry_queue_planner.gd"
 )
+const ADT_WATER_LOAD_PIPELINE_STATE_SCRIPT := preload(
+	"res://src/render/liquid/adt_water_load_pipeline_state.gd"
+)
+const ADT_WATER_SCENE_FINALIZER_SCRIPT := preload(
+	"res://src/render/liquid/adt_water_scene_finalizer.gd"
+)
 const M2_UNIQUE_PLACEMENT_REGISTRY_SCRIPT := preload(
 	"res://src/render/m2/m2_unique_placement_registry.gd"
 )
@@ -45,6 +60,9 @@ const M2_PLACEMENT_GROUPER_SCRIPT := preload(
 const M2_BUILD_BATCH_PLANNER_SCRIPT := preload(
 	"res://src/render/m2/m2_build_batch_planner.gd"
 )
+const M2_RUNTIME_MESH_REBUILD_CLASSIFIER_SCRIPT := preload(
+	"res://src/render/m2/m2_runtime_mesh_rebuild_classifier.gd"
+)
 const STREAMING_TARGET_PLANNER_SCRIPT := preload("res://src/render/streaming/streaming_target_planner.gd")
 const STREAMING_TARGET_POLICY_SCRIPT := preload("res://src/render/streaming/streaming_target_policy.gd")
 const RENDER_BUDGET_SCHEDULER_SCRIPT := preload("res://src/render/streaming/render_budget_scheduler.gd")
@@ -232,10 +250,12 @@ var _m2_unique_placement_registry := (
 var _m2_placement_transform_resolver := M2_PLACEMENT_TRANSFORM_RESOLVER_SCRIPT.new()
 var _m2_placement_grouper := M2_PLACEMENT_GROUPER_SCRIPT.new()
 var _m2_build_batch_planner := M2_BUILD_BATCH_PLANNER_SCRIPT.new()
+var _m2_runtime_mesh_rebuild_classifier := (
+	M2_RUNTIME_MESH_REBUILD_CLASSIFIER_SCRIPT.new()
+)
 var _m2_mesh_cache: Dictionary = {}
 var _m2_mesh_load_requests: Dictionary = {}
 var _m2_mesh_finalize_queue: Array = []
-var _m2_runtime_rebuild_required_cache: Dictionary = {}
 var _m2_animation_load_requests: Dictionary = {}
 var _m2_animation_finalize_queue: Array = []
 var _wmo_build_jobs: Dictionary = {}
@@ -247,11 +267,8 @@ var _terrain_splat_cache_tasks: Dictionary = {}
 var _terrain_splat_tasks: Dictionary = {}
 var _terrain_splat_result_mutex := Mutex.new()
 var _terrain_splat_result_queue: Array = []
-var _water_load_queue: Array = []
-var _water_load_queued: Dictionary = {}
-var _water_load_tasks: Dictionary = {}
-var _water_result_mutex := Mutex.new()
-var _water_result_queue: Array = []
+var _adt_water_load_pipeline_state := ADT_WATER_LOAD_PIPELINE_STATE_SCRIPT.new()
+var _adt_water_scene_finalizer := ADT_WATER_SCENE_FINALIZER_SCRIPT.new()
 var _tile_result_mutex := Mutex.new()
 var _tile_result_queue: Array = []
 var _shared_tex_cache: Dictionary = {}
@@ -277,14 +294,9 @@ var _tile_mesh_cache: Dictionary = {}
 var _tile_mesh_cache_order: Array = []
 var _terrain_quality_mesh_cache: RefCounted = TERRAIN_QUALITY_MESH_CACHE_SCRIPT.new()
 var _wmo_prototype_cache: Dictionary = {}
-var _wmo_render_cache: Dictionary = {}
-var _wmo_render_missing_cache: Dictionary = {}
-var _wmo_render_load_requests: Dictionary = {}
-var _wmo_render_build_jobs: Dictionary = {}
-var _wmo_render_build_queue: Array = []
-var _wmo_scene_resource_cache: Dictionary = {}
-var _wmo_scene_cache_missing: Dictionary = {}
-var _wmo_scene_load_requests: Dictionary = {}
+var _wmo_render_resource_cache_state := WMO_RENDER_RESOURCE_CACHE_STATE_SCRIPT.new()
+var _wmo_render_build_queue := WMO_RENDER_BUILD_QUEUE_SCRIPT.new()
+var _wmo_scene_resource_cache_state := WMO_SCENE_RESOURCE_CACHE_STATE_SCRIPT.new()
 var _wmo_missing_cache: Dictionary = {}
 var _wmo_placement_resolver := WMO_PLACEMENT_RESOLVER_SCRIPT.new()
 var _m2_scene_cache: Dictionary = {}
@@ -465,10 +477,8 @@ func _release_runtime_caches_for_shutdown() -> void:
 	_m2_mesh_cache.clear()
 	_m2_static_animation_cache.clear()
 	_m2_missing_cache.clear()
-	_wmo_render_cache.clear()
-	_wmo_scene_resource_cache.clear()
-	_wmo_render_missing_cache.clear()
-	_wmo_scene_cache_missing.clear()
+	_wmo_render_resource_cache_state.clear_all()
+	_wmo_scene_resource_cache_state.clear_all()
 	_wmo_missing_cache.clear()
 	_shared_tex_cache.clear()
 
@@ -997,14 +1007,18 @@ func _log_hitch_profile(start_usec: int, timings: Array[String], did_refresh: bo
 		_terrain_upgrade_tasks.size(),
 		_terrain_control_splat_cache_tasks.size(),
 		_terrain_splat_queue_size(),
-		_water_load_queue.size() + _water_load_tasks.size(),
+		_adt_water_load_pipeline_state.total_load_count(),
 		_detail_asset_queue.size(),
 		_m2_group_tasks.size(),
 		_m2_animation_finalize_queue.size() + _m2_animation_load_requests.size(),
 		_m2_mesh_finalize_queue.size() + _m2_mesh_load_requests.size(),
 		_m2_build_queue.size(),
-		_wmo_build_queue.size() + _wmo_scene_load_requests.size() + _wmo_render_load_requests.size(),
-		_wmo_render_build_queue.size(),
+		(
+			_wmo_build_queue.size()
+			+ _wmo_scene_resource_cache_state.pending_request_count()
+			+ _wmo_render_resource_cache_state.pending_request_count()
+		),
+		_wmo_render_build_queue.pending_count(),
 		_tile_lod_create_queue.size(),
 		_tile_lod_remove_queue.size(),
 		_chunk_create_queue.size(),
@@ -1024,14 +1038,18 @@ func render_baseline_snapshot() -> Dictionary:
 			"terrain_upgrade": _terrain_upgrade_tasks.size(),
 			"terrain_control": _terrain_control_splat_cache_tasks.size(),
 			"terrain_splat": _terrain_splat_queue_size(),
-			"water": _water_load_queue.size() + _water_load_tasks.size(),
+			"water": _adt_water_load_pipeline_state.total_load_count(),
 			"detail": _detail_asset_queue.size(),
 			"m2_task": _m2_group_tasks.size(),
 			"m2_animation": _m2_animation_finalize_queue.size() + _m2_animation_load_requests.size(),
 			"m2_mesh": _m2_mesh_finalize_queue.size() + _m2_mesh_load_requests.size(),
 			"m2_build": _m2_build_queue.size(),
-			"wmo_build": _wmo_build_queue.size() + _wmo_scene_load_requests.size() + _wmo_render_load_requests.size(),
-			"wmo_groups": _wmo_render_build_queue.size(),
+			"wmo_build": (
+				_wmo_build_queue.size()
+				+ _wmo_scene_resource_cache_state.pending_request_count()
+				+ _wmo_render_resource_cache_state.pending_request_count()
+			),
+			"wmo_groups": _wmo_render_build_queue.pending_count(),
 			"lod_create": _tile_lod_create_queue.size(),
 			"lod_remove": _tile_lod_remove_queue.size(),
 			"chunk_create": _chunk_create_queue.size(),
@@ -1295,7 +1313,7 @@ func _tick_runtime_stats(delta: float) -> void:
 		_terrain_upgrade_tasks.size(),
 		_terrain_control_splat_cache_tasks.size(),
 		_terrain_splat_queue_size(),
-		_water_load_queue.size() + _water_load_tasks.size(),
+		_adt_water_load_pipeline_state.total_load_count(),
 		terrain_baked_full,
 		terrain_control_splat,
 		terrain_splat,
@@ -1312,8 +1330,12 @@ func _tick_runtime_stats(delta: float) -> void:
 		_m2_animation_finalize_queue.size() + _m2_animation_load_requests.size(),
 		_m2_mesh_finalize_queue.size() + _m2_mesh_load_requests.size(),
 		_m2_build_queue.size(),
-		_wmo_build_queue.size() + _wmo_scene_load_requests.size() + _wmo_render_load_requests.size(),
-		_wmo_render_build_queue.size(),
+		(
+			_wmo_build_queue.size()
+			+ _wmo_scene_resource_cache_state.pending_request_count()
+			+ _wmo_render_resource_cache_state.pending_request_count()
+		),
+		_wmo_render_build_queue.pending_count(),
 		_tile_lod_create_queue.size(),
 		_tile_lod_remove_queue.size(),
 		_chunk_create_queue.size(),
@@ -2216,24 +2238,20 @@ func _request_tile_water_load(state: Dictionary) -> void:
 	var path := String(state.get("path", ""))
 	if key.is_empty() or path.is_empty():
 		return
-	if _water_load_tasks.has(key) or _water_load_queued.has(key):
-		return
-	_water_load_queue.append({
-		"key": key,
-		"path": path,
-	})
-	_water_load_queued[key] = true
+	_adt_water_load_pipeline_state.enqueue_request(key, path)
 
 
 func _process_water_load_queue() -> void:
 	if not enable_water:
 		return
 	var limit := maxi(1, max_concurrent_water_tasks)
-	while _water_load_tasks.size() < limit and not _water_load_queue.is_empty():
-		var request: Dictionary = _water_load_queue.pop_front()
+	while (
+			_adt_water_load_pipeline_state.active_task_count() < limit
+			and _adt_water_load_pipeline_state.pending_request_count() > 0
+	):
+		var request: Dictionary = _adt_water_load_pipeline_state.take_next_request()
 		var key := String(request.get("key", ""))
-		_water_load_queued.erase(key)
-		if key.is_empty() or _water_load_tasks.has(key):
+		if key.is_empty() or _adt_water_load_pipeline_state.has_active_task(key):
 			continue
 		if not _tile_states.has(key):
 			continue
@@ -2241,7 +2259,7 @@ func _process_water_load_queue() -> void:
 		if path.is_empty():
 			continue
 		var task_id: int = WorkerThreadPool.add_task(_load_tile_water_task.bind(key, path))
-		_water_load_tasks[key] = task_id
+		_adt_water_load_pipeline_state.remember_active_task(key, task_id)
 
 
 func _load_tile_water_task(key: String, adt_path: String) -> void:
@@ -2250,13 +2268,7 @@ func _load_tile_water_task(key: String, adt_path: String) -> void:
 	if loader:
 		data = loader.call("load_adt", adt_path)
 
-	_water_result_mutex.lock()
-	_water_result_queue.append({
-		"key": key,
-		"path": adt_path,
-		"data": data,
-	})
-	_water_result_mutex.unlock()
+	_adt_water_load_pipeline_state.publish_result(key, adt_path, data)
 
 
 func _drain_water_load_results() -> void:
@@ -2264,20 +2276,20 @@ func _drain_water_load_results() -> void:
 	if not _render_budget_scheduler.has_remaining_permit(RENDER_BUDGET_SCHEDULER_SCRIPT.WATER_FINALIZE):
 		return
 
-	_water_result_mutex.lock()
-	while not _water_result_queue.is_empty() and _render_budget_scheduler.try_consume_permit(
+	while _adt_water_load_pipeline_state.has_result() and _render_budget_scheduler.try_consume_permit(
 			RENDER_BUDGET_SCHEDULER_SCRIPT.WATER_FINALIZE):
-		results.append(_water_result_queue.pop_front())
-	_water_result_mutex.unlock()
+		results.append(_adt_water_load_pipeline_state.pop_result())
 
 	for result in results:
 		var key := String(result.get("key", ""))
 		if key.is_empty():
 			continue
-		if not _water_load_tasks.has(key):
+		if not _adt_water_load_pipeline_state.has_active_task(key):
 			continue
-		WorkerThreadPool.wait_for_task_completion(int(_water_load_tasks[key]))
-		_water_load_tasks.erase(key)
+		WorkerThreadPool.wait_for_task_completion(
+			_adt_water_load_pipeline_state.active_task_id_for(key)
+		)
+		_adt_water_load_pipeline_state.complete_active_task(key)
 		if _shutting_down or not _tile_states.has(key):
 			continue
 
@@ -2291,10 +2303,12 @@ func _drain_water_load_results() -> void:
 		var data: Dictionary = result.get("data", {})
 		if not data.is_empty():
 			var origin: Vector3 = state.get("origin", Vector3.ZERO)
-			var water_root: Node3D = _builder.build_tile_water_scene(data, origin)
-			if water_root:
-				tile_root.add_child(water_root)
-				_set_editor_owner_recursive(water_root)
+			_adt_water_scene_finalizer.attach_water_scene(
+				data,
+				origin,
+				tile_root,
+				_editor_owner_for_generated_nodes()
+			)
 
 		state["water_loaded"] = true
 		_tile_states[key] = state
@@ -2333,7 +2347,7 @@ func _wait_for_tile_tasks() -> void:
 			ResourceLoader.load_threaded_get(path)
 	_m2_mesh_load_requests.clear()
 	_m2_mesh_finalize_queue.clear()
-	_m2_runtime_rebuild_required_cache.clear()
+	_m2_runtime_mesh_rebuild_classifier.clear()
 
 	for pending in _m2_animation_load_requests.values():
 		var path: String = String(pending.get("path", ""))
@@ -2345,26 +2359,27 @@ func _wait_for_tile_tasks() -> void:
 	_m2_animation_load_requests.clear()
 	_m2_animation_finalize_queue.clear()
 
-	for path_variant in _wmo_scene_load_requests.values():
+	var wmo_scene_request_paths := _wmo_scene_resource_cache_state.request_paths_snapshot()
+	for path_variant in wmo_scene_request_paths.values():
 		var path := String(path_variant)
 		if path.is_empty():
 			continue
 		var status := ResourceLoader.load_threaded_get_status(path)
 		if status == ResourceLoader.THREAD_LOAD_IN_PROGRESS or status == ResourceLoader.THREAD_LOAD_LOADED:
 			ResourceLoader.load_threaded_get(path)
-	_wmo_scene_load_requests.clear()
+	_wmo_scene_resource_cache_state.clear_transient_state()
 
-	for path_variant in _wmo_render_load_requests.values():
+	var wmo_render_request_paths := (
+		_wmo_render_resource_cache_state.request_paths_snapshot()
+	)
+	for path_variant in wmo_render_request_paths.values():
 		var path := String(path_variant)
 		if path.is_empty():
 			continue
 		var status := ResourceLoader.load_threaded_get_status(path)
 		if status == ResourceLoader.THREAD_LOAD_IN_PROGRESS or status == ResourceLoader.THREAD_LOAD_LOADED:
 			ResourceLoader.load_threaded_get(path)
-	_wmo_render_load_requests.clear()
-	_wmo_render_missing_cache.clear()
-	_wmo_scene_cache_missing.clear()
-	_wmo_render_build_jobs.clear()
+	_wmo_render_resource_cache_state.clear_transient_state()
 	_wmo_render_build_queue.clear()
 
 	for pending in _terrain_upgrade_tasks.values():
@@ -2404,14 +2419,9 @@ func _wait_for_tile_tasks() -> void:
 	_terrain_splat_result_queue.clear()
 	_terrain_splat_result_mutex.unlock()
 
-	for task_id in _water_load_tasks.values():
+	for task_id in _adt_water_load_pipeline_state.active_task_ids_snapshot():
 		WorkerThreadPool.wait_for_task_completion(int(task_id))
-	_water_load_tasks.clear()
-	_water_load_queue.clear()
-	_water_load_queued.clear()
-	_water_result_mutex.lock()
-	_water_result_queue.clear()
-	_water_result_mutex.unlock()
+	_adt_water_load_pipeline_state.clear()
 
 
 func _should_accept_loaded_tile(request: Dictionary) -> bool:
@@ -2449,10 +2459,12 @@ func _finalize_loaded_tile(request: Dictionary, data: Dictionary) -> void:
 	tile_root.position = tile_origin
 
 	if enable_water:
-		var water_root: Node3D = _builder.build_tile_water_scene(data, tile_origin)
-		if water_root:
-			tile_root.add_child(water_root)
-			_set_editor_owner_recursive(water_root)
+		_adt_water_scene_finalizer.attach_water_scene(
+			data,
+			tile_origin,
+			tile_root,
+			_editor_owner_for_generated_nodes()
+		)
 	if enable_m2_placeholders:
 		_build_tile_m2_placeholders(
 			tile_root,
@@ -2946,11 +2958,7 @@ func _release_tile(key: String) -> void:
 	_terrain_control_splat_cache_tasks.erase(key)
 	_terrain_splat_cache_tasks.erase(key)
 	_terrain_splat_tasks.erase(key)
-	_water_load_queued.erase(key)
-	for i in range(_water_load_queue.size() - 1, -1, -1):
-		var pending: Dictionary = _water_load_queue[i]
-		if String(pending.get("key", "")) == key:
-			_water_load_queue.remove_at(i)
+	_adt_water_load_pipeline_state.cancel_pending_requests(key)
 	var tile_lod_rid: RID = state.get("tile_lod_rid", RID())
 	if tile_lod_rid.is_valid():
 		_free_render_instance(tile_lod_rid)
@@ -2981,12 +2989,7 @@ func _clear_streamed_world() -> void:
 	_terrain_splat_result_mutex.lock()
 	_terrain_splat_result_queue.clear()
 	_terrain_splat_result_mutex.unlock()
-	_water_load_queue.clear()
-	_water_load_queued.clear()
-	_water_load_tasks.clear()
-	_water_result_mutex.lock()
-	_water_result_queue.clear()
-	_water_result_mutex.unlock()
+	_adt_water_load_pipeline_state.clear()
 	_detail_asset_queue.clear()
 	_detail_asset_queued.clear()
 	for key in _m2_build_jobs.keys():
@@ -2995,16 +2998,13 @@ func _clear_streamed_world() -> void:
 	_m2_unique_placement_registry.clear()
 	_m2_mesh_load_requests.clear()
 	_m2_mesh_finalize_queue.clear()
-	_m2_runtime_rebuild_required_cache.clear()
+	_m2_runtime_mesh_rebuild_classifier.clear()
 	_m2_animation_load_requests.clear()
 	_m2_animation_finalize_queue.clear()
 	_wmo_build_jobs.clear()
 	_wmo_build_queue.clear()
-	_wmo_scene_load_requests.clear()
-	_wmo_render_load_requests.clear()
-	_wmo_render_missing_cache.clear()
-	_wmo_scene_cache_missing.clear()
-	_wmo_render_build_jobs.clear()
+	_wmo_scene_resource_cache_state.clear_transient_state()
+	_wmo_render_resource_cache_state.clear_transient_state()
 	_wmo_render_build_queue.clear()
 
 	_tile_result_mutex.lock()
@@ -3589,12 +3589,12 @@ func _process_wmo_build_jobs() -> void:
 						var normalized_rel := _wmo_placement_resolver.normalize_relative_path(
 							rel_path
 						)
-						if _wmo_render_load_requests.has(normalized_rel):
+						if _wmo_render_resource_cache_state.has_request(normalized_rel):
 							advance_job = false
 						else:
 							var scene := _get_wmo_scene_or_request(rel_path)
 							if scene == null:
-								if _wmo_scene_load_requests.has(normalized_rel):
+								if _wmo_scene_resource_cache_state.has_request(normalized_rel):
 									advance_job = false
 								else:
 									var live_instance := _instantiate_wmo_world(rel_path, placement)
@@ -3649,33 +3649,36 @@ func _process_wmo_build_jobs() -> void:
 
 
 func _drain_wmo_scene_loads() -> void:
-	for normalized_rel_variant in _wmo_scene_load_requests.keys():
+	var request_paths := _wmo_scene_resource_cache_state.request_paths_snapshot()
+	for normalized_rel_variant in request_paths.keys():
 		var normalized_rel := String(normalized_rel_variant)
-		var path := String(_wmo_scene_load_requests[normalized_rel])
+		var path := String(request_paths[normalized_rel])
 		var status := ResourceLoader.load_threaded_get_status(path)
 		if status != ResourceLoader.THREAD_LOAD_LOADED and status != ResourceLoader.THREAD_LOAD_FAILED:
 			continue
-		_wmo_scene_load_requests.erase(normalized_rel)
 		if status != ResourceLoader.THREAD_LOAD_LOADED:
-			_wmo_scene_cache_missing[normalized_rel] = true
+			_wmo_scene_resource_cache_state.complete_request_as_missing(normalized_rel)
 			continue
 		var resource: Resource = ResourceLoader.load_threaded_get(path)
 		if resource is PackedScene and _is_wmo_scene_cache_current(resource as PackedScene):
-			_wmo_scene_resource_cache[normalized_rel] = resource as PackedScene
+			_wmo_scene_resource_cache_state.complete_request_with_scene(
+				normalized_rel,
+				resource as PackedScene
+			)
 		else:
-			_wmo_scene_cache_missing[normalized_rel] = true
+			_wmo_scene_resource_cache_state.complete_request_as_missing(normalized_rel)
 
 
 func _drain_wmo_render_loads() -> void:
-	for normalized_rel_variant in _wmo_render_load_requests.keys():
+	var request_paths := _wmo_render_resource_cache_state.request_paths_snapshot()
+	for normalized_rel_variant in request_paths.keys():
 		var normalized_rel := String(normalized_rel_variant)
-		var path := String(_wmo_render_load_requests[normalized_rel])
+		var path := String(request_paths[normalized_rel])
 		var status := ResourceLoader.load_threaded_get_status(path)
 		if status != ResourceLoader.THREAD_LOAD_LOADED and status != ResourceLoader.THREAD_LOAD_FAILED:
 			continue
-		_wmo_render_load_requests.erase(normalized_rel)
 		if status != ResourceLoader.THREAD_LOAD_LOADED:
-			_wmo_render_missing_cache[normalized_rel] = true
+			_wmo_render_resource_cache_state.complete_request_as_missing(normalized_rel)
 			continue
 		var resource: Resource = ResourceLoader.load_threaded_get(path)
 		if (
@@ -3683,20 +3686,23 @@ func _drain_wmo_render_loads() -> void:
 				and resource.get_script() == WMO_STREAMING_SCRIPT
 				and int(resource.get("format_version")) >= WMO_STREAMING_SCRIPT.FORMAT_VERSION
 		):
-			_wmo_render_cache[normalized_rel] = resource
+			_wmo_render_resource_cache_state.complete_request_with_resource(
+				normalized_rel,
+				resource
+			)
 		else:
-			_wmo_render_missing_cache[normalized_rel] = true
+			_wmo_render_resource_cache_state.complete_request_as_missing(normalized_rel)
 
 
 func _get_wmo_render_or_request(rel_path: String) -> Resource:
 	var normalized_rel := _wmo_placement_resolver.normalize_relative_path(rel_path)
 	if normalized_rel.is_empty():
 		return null
-	if _wmo_render_cache.has(normalized_rel):
-		return _wmo_render_cache[normalized_rel]
-	if _wmo_render_missing_cache.has(normalized_rel):
+	if _wmo_render_resource_cache_state.contains_resource(normalized_rel):
+		return _wmo_render_resource_cache_state.resource_for(normalized_rel)
+	if _wmo_render_resource_cache_state.is_missing(normalized_rel):
 		return null
-	if _wmo_render_load_requests.has(normalized_rel):
+	if _wmo_render_resource_cache_state.has_request(normalized_rel):
 		return null
 
 	var cache_path := wmo_render_cache_dir.path_join(normalized_rel.get_basename() + ".res")
@@ -3709,7 +3715,7 @@ func _get_wmo_render_or_request(rel_path: String) -> Resource:
 		false,
 		ResourceLoader.CACHE_MODE_REUSE)
 	if err == OK or err == ERR_BUSY:
-		_wmo_render_load_requests[normalized_rel] = cache_path
+		_wmo_render_resource_cache_state.remember_request(normalized_rel, cache_path)
 	return null
 
 
@@ -3717,23 +3723,23 @@ func _get_wmo_scene_or_request(rel_path: String) -> PackedScene:
 	var normalized_rel := _wmo_placement_resolver.normalize_relative_path(rel_path)
 	if normalized_rel.is_empty():
 		return null
-	if _wmo_scene_resource_cache.has(normalized_rel):
-		return _wmo_scene_resource_cache[normalized_rel]
-	if _wmo_scene_cache_missing.has(normalized_rel):
+	if _wmo_scene_resource_cache_state.contains_scene(normalized_rel):
+		return _wmo_scene_resource_cache_state.scene_for(normalized_rel)
+	if _wmo_scene_resource_cache_state.is_missing(normalized_rel):
 		return null
-	if _wmo_scene_load_requests.has(normalized_rel):
+	if _wmo_scene_resource_cache_state.has_request(normalized_rel):
 		return null
 
 	var cache_path := wmo_cache_dir.path_join(normalized_rel.get_basename() + ".tscn")
 	if not ResourceLoader.exists(cache_path):
-		_wmo_scene_cache_missing[normalized_rel] = true
+		_wmo_scene_resource_cache_state.mark_missing(normalized_rel)
 		return null
 
 	if wmo_max_runtime_scene_mb > 0.0:
 		var size_bytes := _get_resource_file_size(cache_path)
 		var max_bytes := int(wmo_max_runtime_scene_mb * 1024.0 * 1024.0)
 		if size_bytes > max_bytes:
-			_wmo_scene_cache_missing[normalized_rel] = true
+			_wmo_scene_resource_cache_state.mark_missing(normalized_rel)
 			if debug_streaming:
 				print("StreamingWorld: skipping large WMO %.2f MB: %s" % [
 					float(size_bytes) / (1024.0 * 1024.0),
@@ -3747,9 +3753,9 @@ func _get_wmo_scene_or_request(rel_path: String) -> PackedScene:
 		false,
 		ResourceLoader.CACHE_MODE_REUSE)
 	if err == OK or err == ERR_BUSY:
-		_wmo_scene_load_requests[normalized_rel] = cache_path
+		_wmo_scene_resource_cache_state.remember_request(normalized_rel, cache_path)
 	else:
-		_wmo_scene_cache_missing[normalized_rel] = true
+		_wmo_scene_resource_cache_state.mark_missing(normalized_rel)
 	return null
 
 
@@ -3761,32 +3767,23 @@ func _instantiate_wmo_render_root(rel_path: String, placement: Dictionary) -> No
 
 
 func _start_wmo_render_build(unique_key: String, root: Node3D, render_resource: Resource) -> void:
-	if unique_key.is_empty() or root == null or render_resource == null:
-		return
-	_wmo_render_build_jobs[unique_key] = {
-		"root": root,
-		"resource": render_resource,
-		"mesh_index": 0,
-		"multimesh_index": 0,
-	}
-	_wmo_render_build_queue.append(unique_key)
+	_wmo_render_build_queue.enqueue(unique_key, root, render_resource)
 
 
 func _process_wmo_render_build_jobs() -> void:
 	while _render_budget_scheduler.has_remaining_permit(
-			RENDER_BUDGET_SCHEDULER_SCRIPT.WMO_RENDER_GROUP_BUILD) and not _wmo_render_build_queue.is_empty():
-		var unique_key := String(_wmo_render_build_queue.front())
-		if not _wmo_render_build_jobs.has(unique_key):
+			RENDER_BUDGET_SCHEDULER_SCRIPT.WMO_RENDER_GROUP_BUILD) and _wmo_render_build_queue.has_pending():
+		var unique_key := _wmo_render_build_queue.front_key()
+		if not _wmo_render_build_queue.has_job(unique_key):
 			_wmo_render_build_queue.pop_front()
 			continue
 
-		var job: Dictionary = _wmo_render_build_jobs[unique_key]
-		var root: Node = job.get("root", null)
+		var root: Node = _wmo_render_build_queue.root_for(unique_key)
 		if root == null or not is_instance_valid(root):
 			_cancel_wmo_render_build_job(unique_key)
 			continue
 
-		var render_resource: Resource = job.get("resource", null)
+		var render_resource: Resource = _wmo_render_build_queue.render_resource_for(unique_key)
 		if render_resource == null:
 			_cancel_wmo_render_build_job(unique_key)
 			continue
@@ -3794,11 +3791,11 @@ func _process_wmo_render_build_jobs() -> void:
 		var meshes: Array = render_resource.get("meshes")
 		var mesh_transforms: Array = render_resource.get("mesh_transforms")
 		var mesh_names: PackedStringArray = render_resource.get("mesh_names")
-		var mesh_index: int = int(job.get("mesh_index", 0))
+		var mesh_index := _wmo_render_build_queue.mesh_index_for(unique_key)
 		var multimeshes: Array = render_resource.get("multimeshes")
 		var multimesh_transforms: Array = render_resource.get("multimesh_transforms")
 		var multimesh_names: PackedStringArray = render_resource.get("multimesh_names")
-		var multimesh_index: int = int(job.get("multimesh_index", 0))
+		var multimesh_index := _wmo_render_build_queue.multimesh_index_for(unique_key)
 		var build_step: Dictionary = _wmo_render_build_step_planner.plan_step(
 			meshes.size(),
 			mesh_index,
@@ -3829,8 +3826,11 @@ func _process_wmo_render_build_jobs() -> void:
 					mesh_instance.visibility_range_end_margin = CHUNK_SIZE
 				(root as Node3D).add_child(mesh_instance)
 				_set_editor_owner_recursive(mesh_instance)
-			job["mesh_index"] = int(build_step["next_mesh_index"])
-			_wmo_render_build_jobs[unique_key] = job
+			_wmo_render_build_queue.adopt_cursors(
+				unique_key,
+				int(build_step["next_mesh_index"]),
+				int(build_step["next_multimesh_index"])
+			)
 			_render_budget_scheduler.try_consume_permit(RENDER_BUDGET_SCHEDULER_SCRIPT.WMO_RENDER_GROUP_BUILD)
 			continue
 
@@ -3857,8 +3857,11 @@ func _process_wmo_render_build_jobs() -> void:
 					multimesh_instance.visibility_range_end_margin = CHUNK_SIZE
 				(root as Node3D).add_child(multimesh_instance)
 				_set_editor_owner_recursive(multimesh_instance)
-			job["multimesh_index"] = int(build_step["next_multimesh_index"])
-			_wmo_render_build_jobs[unique_key] = job
+			_wmo_render_build_queue.adopt_cursors(
+				unique_key,
+				int(build_step["next_mesh_index"]),
+				int(build_step["next_multimesh_index"])
+			)
 			_render_budget_scheduler.try_consume_permit(RENDER_BUDGET_SCHEDULER_SCRIPT.WMO_RENDER_GROUP_BUILD)
 			continue
 
@@ -3866,9 +3869,7 @@ func _process_wmo_render_build_jobs() -> void:
 
 
 func _cancel_wmo_render_build_job(unique_key: String) -> void:
-	if _wmo_render_build_jobs.has(unique_key):
-		_wmo_render_build_jobs.erase(unique_key)
-	_wmo_render_build_queue.erase(unique_key)
+	_wmo_render_build_queue.cancel(unique_key)
 
 
 func _get_resource_file_size(path: String) -> int:
@@ -4043,7 +4044,6 @@ func _unregister_tile_wmos(state: Dictionary) -> void:
 
 
 func _clear_wmo_registry() -> void:
-	_wmo_render_build_jobs.clear()
 	_wmo_render_build_queue.clear()
 	for node_variant in _wmo_instance_nodes_by_unique_key.values():
 		if not (node_variant is Node):
@@ -4650,7 +4650,9 @@ func _prepare_m2_mesh_for_runtime(normalized_rel: String, mesh: Mesh) -> Mesh:
 	if int(mesh.get_meta("wow_m2_material_refresh_version", 0)) >= M2_MATERIAL_REFRESH_VERSION:
 		return mesh
 	var data := _load_m2_raw_data_for_refresh(normalized_rel)
-	if data.is_empty() or not _m2_raw_data_needs_runtime_mesh_rebuild(normalized_rel, data):
+	if data.is_empty() or not _m2_runtime_mesh_rebuild_classifier.needs_runtime_mesh_rebuild(
+			normalized_rel,
+			data):
 		mesh.set_meta("wow_m2_material_refresh_version", M2_MATERIAL_REFRESH_VERSION)
 		return mesh
 	var rebuilt := _rebuild_m2_mesh_from_data(data)
@@ -4684,53 +4686,6 @@ func _load_m2_raw_data_for_refresh(normalized_rel: String) -> Dictionary:
 	return data if data is Dictionary else {}
 
 
-func _m2_raw_data_needs_runtime_mesh_rebuild(normalized_rel: String, data: Dictionary) -> bool:
-	if _m2_runtime_rebuild_required_cache.has(normalized_rel):
-		return bool(_m2_runtime_rebuild_required_cache[normalized_rel])
-	var needs_rebuild := _m2_raw_data_has_billboards(data) or _m2_raw_data_has_uv_rotation(data)
-	_m2_runtime_rebuild_required_cache[normalized_rel] = needs_rebuild
-	return needs_rebuild
-
-
-func _m2_raw_data_has_billboards(data: Dictionary) -> bool:
-	for batch_variant in data.get("batches", []):
-		if not (batch_variant is Dictionary):
-			continue
-		var batch: Dictionary = batch_variant
-		if bool(batch.get("has_billboard", false)) or int(batch.get("billboard_vertex_count", 0)) > 0:
-			return true
-	return false
-
-
-func _m2_raw_data_has_uv_rotation(data: Dictionary) -> bool:
-	var transforms: Array = data.get("texture_transforms", [])
-	if transforms.is_empty():
-		return false
-	var combos: PackedInt32Array = data.get("texture_transform_combos", PackedInt32Array())
-	if combos.is_empty():
-		return false
-	for batch_variant in data.get("batches", []):
-		if not (batch_variant is Dictionary):
-			continue
-		var batch: Dictionary = batch_variant
-		var texture_count := maxi(1, int(batch.get("texture_count", 1)))
-		var base_combo := int(batch.get("texture_transform_combo_index", -1))
-		for stage in mini(texture_count, 4):
-			var combo_index := base_combo + stage
-			if combo_index < 0 or combo_index >= combos.size():
-				continue
-			var transform_index := int(combos[combo_index])
-			if transform_index < 0 or transform_index >= transforms.size():
-				continue
-			var transform: Dictionary = transforms[transform_index] if transforms[transform_index] is Dictionary else {}
-			var rotation: Vector4 = transform.get("rotation", Vector4(1.0, 0.0, 0.0, 1.0))
-			if not rotation.is_equal_approx(Vector4(1.0, 0.0, 0.0, 1.0)):
-				return true
-			if absf(float(transform.get("rotation_speed", 0.0))) > 0.000001:
-				return true
-	return false
-
-
 func _rebuild_m2_mesh_from_data(data: Dictionary) -> Mesh:
 	if data.is_empty():
 		return null
@@ -5434,12 +5389,7 @@ func _tile_key(tx: int, ty: int) -> String:
 
 
 func _set_editor_owner_recursive(node: Node) -> void:
-	if not Engine.is_editor_hint():
-		return
-	if not editor_persist_generated_nodes:
-		return
-
-	var edited_root := get_tree().edited_scene_root
+	var edited_root := _editor_owner_for_generated_nodes()
 	if edited_root == null:
 		return
 
@@ -5448,6 +5398,12 @@ func _set_editor_owner_recursive(node: Node) -> void:
 		_set_editor_owner_recursive(child)
 
 
+func _editor_owner_for_generated_nodes() -> Node:
+	if not Engine.is_editor_hint() or not editor_persist_generated_nodes:
+		return null
+	return get_tree().edited_scene_root
+
+
 func _make_editor_signature() -> String:
 	var values := [
 		extracted_dir,

src/tools/verify_adt_water_load_pipeline_state.gd

@@ -0,0 +1,350 @@
+extends SceneTree
+
+## Asset-free lifecycle, threading, boundary and timing regression for ADT water loads.
+
+const PIPELINE_SCRIPT := preload(
+	"res://src/render/liquid/adt_water_load_pipeline_state.gd"
+)
+const PIPELINE_PATH := "res://src/render/liquid/adt_water_load_pipeline_state.gd"
+const LOADER_PATH := "res://src/scenes/streaming/streaming_world_loader.gd"
+
+
+func _initialize() -> void:
+	var failures: Array[String] = []
+	_verify_invalid_dedupe_and_fifo(failures)
+	_verify_active_task_lifecycle(failures)
+	_verify_result_mailbox_and_payload_identity(failures)
+	_verify_worker_publication(failures)
+	_verify_pending_cancellation(failures)
+	_verify_clear_and_detached_diagnostics(failures)
+	_verify_ownership_boundaries(failures)
+	var elapsed_milliseconds := _verify_bounded_timing(failures)
+	if not failures.is_empty():
+		for failure in failures:
+			push_error("ADT_WATER_LOAD_PIPELINE_STATE: %s" % failure)
+		quit(1)
+		return
+	print(
+		"ADT_WATER_LOAD_PIPELINE_STATE PASS cases=12 iterations=100 elapsed_ms=%.3f"
+		% elapsed_milliseconds
+	)
+	quit(0)
+
+
+func _verify_invalid_dedupe_and_fifo(failures: Array[String]) -> void:
+	var pipeline: RefCounted = PIPELINE_SCRIPT.new()
+	_expect_false(
+		pipeline.call("enqueue_request", "", "res://tile.adt"),
+		"empty tile key rejected",
+		failures
+	)
+	_expect_false(
+		pipeline.call("enqueue_request", "31:49", ""),
+		"empty path rejected",
+		failures
+	)
+	_expect_true(
+		pipeline.call("enqueue_request", "31:49", "res://a.adt"),
+		"first request accepted",
+		failures
+	)
+	_expect_false(
+		pipeline.call("enqueue_request", "31:49", "res://duplicate.adt"),
+		"queued duplicate rejected",
+		failures
+	)
+	pipeline.call("enqueue_request", "32:49", "res://b.adt")
+	_expect_equal(int(pipeline.call("pending_request_count")), 2, "pending count", failures)
+	var first_request: Dictionary = pipeline.call("take_next_request")
+	var second_request: Dictionary = pipeline.call("take_next_request")
+	_expect_string_equal(String(first_request["key"]), "31:49", "FIFO first key", failures)
+	_expect_string_equal(String(second_request["key"]), "32:49", "FIFO second key", failures)
+	_expect_true(
+		pipeline.call("enqueue_request", "31:49", "res://retry.adt"),
+		"dequeued key can be requested again",
+		failures
+	)
+
+
+func _verify_active_task_lifecycle(failures: Array[String]) -> void:
+	var pipeline: RefCounted = PIPELINE_SCRIPT.new()
+	_expect_false(
+		pipeline.call("remember_active_task", "", 7),
+		"empty active key rejected",
+		failures
+	)
+	_expect_true(
+		pipeline.call("remember_active_task", "31:49", 101),
+		"active task accepted",
+		failures
+	)
+	_expect_false(
+		pipeline.call("remember_active_task", "31:49", 202),
+		"duplicate active task rejected",
+		failures
+	)
+	_expect_true(
+		pipeline.call("has_active_task", "31:49"),
+		"active task observable",
+		failures
+	)
+	_expect_equal(
+		int(pipeline.call("active_task_id_for", "31:49")),
+		101,
+		"opaque task ID retained",
+		failures
+	)
+	_expect_false(
+		pipeline.call("enqueue_request", "31:49", "res://active.adt"),
+		"active tile rejects enqueue",
+		failures
+	)
+	_expect_equal(
+		int(pipeline.call("complete_active_task", "31:49")),
+		101,
+		"completion returns task ID",
+		failures
+	)
+	_expect_equal(
+		int(pipeline.call("complete_active_task", "31:49")),
+		-1,
+		"unknown completion rejected",
+		failures
+	)
+
+
+func _verify_result_mailbox_and_payload_identity(failures: Array[String]) -> void:
+	var pipeline: RefCounted = PIPELINE_SCRIPT.new()
+	var water_data := {"chunks": [{"liquid": true}]}
+	_expect_false(
+		pipeline.call("publish_result", "", "res://a.adt", water_data),
+		"empty result key rejected",
+		failures
+	)
+	_expect_true(
+		pipeline.call("publish_result", "31:49", "res://a.adt", water_data),
+		"valid result published",
+		failures
+	)
+	_expect_true(pipeline.call("has_result"), "published result observable", failures)
+	var result: Dictionary = pipeline.call("pop_result")
+	_expect_string_equal(String(result["key"]), "31:49", "result key", failures)
+	_expect_string_equal(String(result["path"]), "res://a.adt", "result path", failures)
+	_expect_true(result["data"] == water_data, "water payload identity retained", failures)
+	_expect_false(pipeline.call("has_result"), "result pop empties mailbox", failures)
+	_expect_true(
+		(pipeline.call("pop_result") as Dictionary).is_empty(),
+		"empty result pop is safe",
+		failures
+	)
+
+
+func _verify_worker_publication(failures: Array[String]) -> void:
+	var pipeline: RefCounted = PIPELINE_SCRIPT.new()
+	var worker := Thread.new()
+	var start_error := worker.start(
+		Callable(pipeline, "publish_result").bind(
+			"worker",
+			"res://worker.adt",
+			{"worker": true}
+		)
+	)
+	_expect_equal(int(start_error), OK, "worker publication starts", failures)
+	if start_error == OK:
+		worker.wait_to_finish()
+	_expect_true(pipeline.call("has_result"), "worker result safely visible", failures)
+	var result: Dictionary = pipeline.call("pop_result")
+	_expect_string_equal(String(result.get("key", "")), "worker", "worker result key", failures)
+
+
+func _verify_pending_cancellation(failures: Array[String]) -> void:
+	var pipeline: RefCounted = PIPELINE_SCRIPT.new()
+	pipeline.call("enqueue_request", "31:49", "res://a.adt")
+	pipeline.call("enqueue_request", "32:49", "res://b.adt")
+	pipeline.call("remember_active_task", "31:49-active", 12)
+	_expect_equal(
+		int(pipeline.call("cancel_pending_requests", "31:49")),
+		1,
+		"tile cancellation removes pending request",
+		failures
+	)
+	_expect_equal(int(pipeline.call("pending_request_count")), 1, "other pending retained", failures)
+	_expect_true(
+		pipeline.call("has_active_task", "31:49-active"),
+		"pending cancellation leaves active work",
+		failures
+	)
+	_expect_equal(
+		int(pipeline.call("cancel_pending_requests", "unknown")),
+		0,
+		"unknown cancellation unchanged",
+		failures
+	)
+
+
+func _verify_clear_and_detached_diagnostics(failures: Array[String]) -> void:
+	var pipeline: RefCounted = PIPELINE_SCRIPT.new()
+	pipeline.call("enqueue_request", "32:49", "res://b.adt")
+	pipeline.call("enqueue_request", "31:49", "res://a.adt")
+	pipeline.call("remember_active_task", "z", 2)
+	pipeline.call("remember_active_task", "a", 1)
+	pipeline.call("publish_result", "result", "res://result.adt", {"secret": "payload"})
+	var snapshot: Dictionary = pipeline.call("diagnostic_snapshot")
+	_expect_string_array(
+		snapshot["active_tile_keys"],
+		["a", "z"],
+		"active diagnostics sorted",
+		failures
+	)
+	_expect_equal(
+		(snapshot["pending_requests"] as Array).size(),
+		2,
+		"pending diagnostics count",
+		failures
+	)
+	_expect_false(
+		(snapshot["result_records"][0] as Dictionary).has("data"),
+		"diagnostics omit water payload",
+		failures
+	)
+	(snapshot["pending_requests"] as Array).clear()
+	var fresh_snapshot: Dictionary = pipeline.call("diagnostic_snapshot")
+	_expect_equal(
+		(fresh_snapshot["pending_requests"] as Array).size(),
+		2,
+		"diagnostics detached",
+		failures
+	)
+	pipeline.call("clear")
+	pipeline.call("clear")
+	_expect_equal(int(pipeline.call("total_load_count")), 0, "clear load count", failures)
+	_expect_false(pipeline.call("has_result"), "clear result mailbox", failures)
+
+
+func _verify_ownership_boundaries(failures: Array[String]) -> void:
+	var loader_source := _read_text(LOADER_PATH, failures)
+	var pipeline_source := _read_text(PIPELINE_PATH, failures)
+	_expect_true(
+		loader_source.contains("ADT_WATER_LOAD_PIPELINE_STATE_SCRIPT.new()"),
+		"loader composes pipeline state",
+		failures
+	)
+	for legacy_field in [
+		"var _water_load_queue:",
+		"var _water_load_queued:",
+		"var _water_load_tasks:",
+		"var _water_result_mutex",
+		"var _water_result_queue:",
+	]:
+		_expect_false(loader_source.contains(legacy_field), "loader removes %s" % legacy_field, failures)
+	for retained_loader_rule in [
+		"ClassDB.instantiate(\"ADTLoader\")",
+		"WorkerThreadPool.add_task(_load_tile_water_task.bind(key, path))",
+		"RENDER_BUDGET_SCHEDULER_SCRIPT.WATER_FINALIZE",
+		"_adt_water_scene_finalizer.attach_water_scene(",
+		"state[\"water_loaded\"] = true",
+	]:
+		_expect_true(loader_source.contains(retained_loader_rule), "loader retains %s" % retained_loader_rule, failures)
+	for forbidden_token in [
+		"WorkerThreadPool.",
+		"ADTLoader",
+		"RenderBudgetScheduler",
+		"Node3D",
+		"Mesh",
+		"RID",
+		"_tile_states",
+	]:
+		_expect_false(
+			pipeline_source.contains(forbidden_token),
+			"pipeline omits %s ownership" % forbidden_token,
+			failures
+		)
+	_expect_equal(
+		_count_occurrences(loader_source, "_adt_water_load_pipeline_state.clear()"),
+		2,
+		"loader retains two clear sites",
+		failures
+	)
+
+
+func _verify_bounded_timing(failures: Array[String]) -> float:
+	var pipeline: RefCounted = PIPELINE_SCRIPT.new()
+	var started_microseconds := Time.get_ticks_usec()
+	for iteration in range(100):
+		for tile_index in range(256):
+			var tile_key := "tile:%d" % tile_index
+			pipeline.call("enqueue_request", tile_key, "res://tile_%d.adt" % tile_index)
+		while int(pipeline.call("pending_request_count")) > 0:
+			var request: Dictionary = pipeline.call("take_next_request")
+			var tile_key := String(request["key"])
+			pipeline.call("remember_active_task", tile_key, tile_key.hash())
+			pipeline.call("publish_result", tile_key, String(request["path"]), {})
+		while pipeline.call("has_result"):
+			var result: Dictionary = pipeline.call("pop_result")
+			pipeline.call("complete_active_task", String(result["key"]))
+		pipeline.call("clear")
+		_expect_equal(
+			int(pipeline.call("total_load_count")),
+			0,
+			"timing cycle %d clears" % iteration,
+			failures
+		)
+	var elapsed_milliseconds := float(Time.get_ticks_usec() - started_microseconds) / 1000.0
+	_expect_true(
+		elapsed_milliseconds < 1000.0,
+		"100 request/task/result cycles remain bounded",
+		failures
+	)
+	return elapsed_milliseconds
+
+
+func _read_text(path: String, failures: Array[String]) -> String:
+	var file := FileAccess.open(path, FileAccess.READ)
+	if file == null:
+		failures.append("cannot open %s" % path)
+		return ""
+	return file.get_as_text()
+
+
+func _count_occurrences(text: String, token: String) -> int:
+	return text.split(token).size() - 1
+
+
+func _expect_equal(
+		actual_value: int,
+		expected_value: int,
+		label: String,
+		failures: Array[String]
+) -> void:
+	if actual_value != expected_value:
+		failures.append("%s expected %d, got %d" % [label, expected_value, actual_value])
+
+
+func _expect_string_equal(
+		actual_value: String,
+		expected_value: String,
+		label: String,
+		failures: Array[String]
+) -> void:
+	if actual_value != expected_value:
+		failures.append("%s expected %s, got %s" % [label, expected_value, actual_value])
+
+
+func _expect_string_array(
+		actual_values: Array,
+		expected_values: Array,
+		label: String,
+		failures: Array[String]
+) -> void:
+	if actual_values != expected_values:
+		failures.append("%s expected %s, got %s" % [label, expected_values, actual_values])
+
+
+func _expect_true(actual_value: bool, label: String, failures: Array[String]) -> void:
+	if not actual_value:
+		failures.append("%s expected true" % label)
+
+
+func _expect_false(actual_value: bool, label: String, failures: Array[String]) -> void:
+	if actual_value:
+		failures.append("%s expected false" % label)

src/tools/verify_adt_water_load_pipeline_state.gd.uid

@@ -0,0 +1 @@
+uid://bb3v38yw47utf

src/tools/verify_adt_water_scene_finalizer.gd

@@ -0,0 +1,194 @@
+extends SceneTree
+
+## Synthetic main-thread scene, ownership, boundary and timing regression for
+## ADT water finalization.
+
+const FINALIZER_SCRIPT := preload("res://src/render/liquid/adt_water_scene_finalizer.gd")
+const FINALIZER_PATH := "res://src/render/liquid/adt_water_scene_finalizer.gd"
+const LOADER_PATH := "res://src/scenes/streaming/streaming_world_loader.gd"
+
+
+func _initialize() -> void:
+	var failures: Array[String] = []
+	_verify_invalid_and_dry_input(failures)
+	_verify_build_attach_geometry_and_owner(failures)
+	_verify_ownership_boundaries(failures)
+	var elapsed_milliseconds := _verify_bounded_timing(failures)
+	if not failures.is_empty():
+		for failure in failures:
+			push_error("ADT_WATER_SCENE_FINALIZER: %s" % failure)
+		quit(1)
+		return
+	print(
+		"ADT_WATER_SCENE_FINALIZER PASS cases=8 iterations=100 elapsed_ms=%.3f"
+		% elapsed_milliseconds
+	)
+	quit(0)
+
+
+func _verify_invalid_and_dry_input(failures: Array[String]) -> void:
+	var finalizer: RefCounted = FINALIZER_SCRIPT.new()
+	var tile_root := Node3D.new()
+	_expect_null(
+		finalizer.call("attach_water_scene", {}, Vector3.ZERO, tile_root, null),
+		"empty water data returns null",
+		failures
+	)
+	_expect_equal(tile_root.get_child_count(), 0, "empty data does not mutate tile", failures)
+	_expect_null(
+		finalizer.call("attach_water_scene", _synthetic_water_data(), Vector3.ZERO, null, null),
+		"missing tile root returns null",
+		failures
+	)
+	_expect_null(
+		finalizer.call(
+			"attach_water_scene",
+			{"chunks": [{"origin": Vector3.ZERO, "liquids": []}]},
+			Vector3.ZERO,
+			tile_root,
+			null
+		),
+		"dry parsed ADT returns null",
+		failures
+	)
+	_expect_equal(tile_root.get_child_count(), 0, "dry data does not mutate tile", failures)
+	tile_root.free()
+
+
+func _verify_build_attach_geometry_and_owner(failures: Array[String]) -> void:
+	var finalizer: RefCounted = FINALIZER_SCRIPT.new()
+	var editor_scene_root := Node3D.new()
+	var tile_root := Node3D.new()
+	get_root().add_child(editor_scene_root)
+	editor_scene_root.add_child(tile_root)
+
+	var tile_origin := Vector3(10.0, 20.0, 30.0)
+	var water_root: Node3D = finalizer.call(
+		"attach_water_scene",
+		_synthetic_water_data(tile_origin),
+		tile_origin,
+		tile_root,
+		editor_scene_root
+	)
+	_expect_not_null(water_root, "synthetic liquid builds a water root", failures)
+	if water_root != null:
+		_expect_true(water_root.get_parent() == tile_root, "water root attached once", failures)
+		_expect_equal(tile_root.get_child_count(), 1, "tile owns one water root", failures)
+		_expect_true(water_root.owner == editor_scene_root, "water root editor owner", failures)
+		_expect_equal(water_root.get_child_count(), 1, "one liquid surface grouped", failures)
+		if water_root.get_child_count() == 1:
+			var liquid_mesh_instance := water_root.get_child(0) as MeshInstance3D
+			_expect_not_null(liquid_mesh_instance, "liquid child is MeshInstance3D", failures)
+			if liquid_mesh_instance != null:
+				_expect_true(
+					liquid_mesh_instance.owner == editor_scene_root,
+					"liquid child editor owner",
+					failures
+				)
+				var liquid_mesh := liquid_mesh_instance.mesh as ArrayMesh
+				_expect_not_null(liquid_mesh, "liquid surface has ArrayMesh", failures)
+				if liquid_mesh != null:
+					_expect_equal(
+						liquid_mesh.surface_get_array_len(0),
+						4,
+						"one enabled liquid cell has four vertices",
+						failures
+					)
+					_expect_equal(
+						liquid_mesh.surface_get_array_index_len(0),
+						6,
+						"one enabled liquid cell has six indices",
+						failures
+					)
+	editor_scene_root.free()
+
+
+func _verify_ownership_boundaries(failures: Array[String]) -> void:
+	var finalizer_source := FileAccess.get_file_as_string(FINALIZER_PATH)
+	var loader_source := FileAccess.get_file_as_string(LOADER_PATH)
+	_expect_true(
+		finalizer_source.contains("ADT_BUILDER_SCRIPT.build_tile_water_scene"),
+		"finalizer retains existing ADTBuilder implementation",
+		failures
+	)
+	_expect_true(
+		finalizer_source.contains("tile_root.add_child(water_root)"),
+		"finalizer owns water subtree attachment",
+		failures
+	)
+	_expect_equal(
+		loader_source.count("_adt_water_scene_finalizer.attach_water_scene("),
+		2,
+		"both loader water paths delegate finalization",
+		failures
+	)
+	_expect_false(
+		loader_source.contains("_builder.build_tile_water_scene"),
+		"loader no longer builds water scenes directly",
+		failures
+	)
+	_expect_true(
+		loader_source.contains("state[\"water_loaded\"] = true"),
+		"loader retains water-loaded timing",
+		failures
+	)
+	_expect_true(
+		loader_source.contains("WATER_FINALIZE"),
+		"loader retains finalization permit ownership",
+		failures
+	)
+
+
+func _verify_bounded_timing(failures: Array[String]) -> float:
+	var finalizer: RefCounted = FINALIZER_SCRIPT.new()
+	var tile_root := Node3D.new()
+	var started_microseconds := Time.get_ticks_usec()
+	for _iteration in range(100):
+		finalizer.call("attach_water_scene", {}, Vector3.ZERO, tile_root, null)
+	var elapsed_milliseconds := float(Time.get_ticks_usec() - started_microseconds) / 1000.0
+	_expect_true(elapsed_milliseconds < 1000.0, "100 empty attempts under 1 second", failures)
+	_expect_equal(tile_root.get_child_count(), 0, "timing loop creates no nodes", failures)
+	tile_root.free()
+	return elapsed_milliseconds
+
+
+func _synthetic_water_data(tile_origin: Vector3 = Vector3.ZERO) -> Dictionary:
+	var liquid_mask := PackedByteArray()
+	liquid_mask.resize(64)
+	liquid_mask.fill(0)
+	liquid_mask[0] = 1
+	var liquid_heights := PackedFloat32Array()
+	liquid_heights.resize(81)
+	liquid_heights.fill(tile_origin.y + 5.0)
+	return {
+		"chunks": [{
+			"origin": tile_origin,
+			"liquids": [{
+				"liquid_id": 7,
+				"mask": liquid_mask,
+				"heights": liquid_heights,
+			}],
+		}],
+	}
+
+
+func _expect_true(condition: bool, label: String, failures: Array[String]) -> void:
+	if not condition:
+		failures.append(label)
+
+
+func _expect_false(condition: bool, label: String, failures: Array[String]) -> void:
+	_expect_true(not condition, label, failures)
+
+
+func _expect_null(value: Variant, label: String, failures: Array[String]) -> void:
+	_expect_true(value == null, label, failures)
+
+
+func _expect_not_null(value: Variant, label: String, failures: Array[String]) -> void:
+	_expect_true(value != null, label, failures)
+
+
+func _expect_equal(actual: int, expected: int, label: String, failures: Array[String]) -> void:
+	if actual != expected:
+		failures.append("%s expected=%d actual=%d" % [label, expected, actual])

src/tools/verify_adt_water_scene_finalizer.gd.uid

@@ -0,0 +1 @@
+uid://c1gqfpxg7ajsh

src/tools/verify_m2_runtime_mesh_rebuild_classifier.gd

@@ -0,0 +1,248 @@
+extends SceneTree
+
+## Synthetic predicate, memoization, boundary and timing regression for stale
+## cached M2 runtime mesh rebuild decisions.
+
+const CLASSIFIER_SCRIPT := preload(
+	"res://src/render/m2/m2_runtime_mesh_rebuild_classifier.gd"
+)
+const CLASSIFIER_PATH := "res://src/render/m2/m2_runtime_mesh_rebuild_classifier.gd"
+const LOADER_PATH := "res://src/scenes/streaming/streaming_world_loader.gd"
+
+
+func _initialize() -> void:
+	var failures: Array[String] = []
+	_verify_billboard_decisions(failures)
+	_verify_uv_rotation_decisions(failures)
+	_verify_stage_and_index_boundaries(failures)
+	_verify_memoization_clear_and_diagnostics(failures)
+	_verify_ownership_boundaries(failures)
+	var elapsed_milliseconds := _verify_bounded_timing(failures)
+	if not failures.is_empty():
+		for failure in failures:
+			push_error("M2_RUNTIME_MESH_REBUILD_CLASSIFIER: %s" % failure)
+		quit(1)
+		return
+	print(
+		"M2_RUNTIME_MESH_REBUILD_CLASSIFIER PASS cases=12 iterations=100 elapsed_ms=%.3f"
+		% elapsed_milliseconds
+	)
+	quit(0)
+
+
+func _verify_billboard_decisions(failures: Array[String]) -> void:
+	_expect_false(_classify("empty", {}), "empty data does not rebuild", failures)
+	_expect_false(
+		_classify("invalid", {"batches": ["invalid", 7, null]}),
+		"non-Dictionary batches skipped",
+		failures
+	)
+	_expect_true(
+		_classify("flag", {"batches": [{"has_billboard": true}]}),
+		"billboard flag rebuilds",
+		failures
+	)
+	_expect_true(
+		_classify("vertices", {"batches": [{"billboard_vertex_count": 1}]}),
+		"positive billboard vertex count rebuilds",
+		failures
+	)
+	_expect_false(
+		_classify("zero_vertices", {"batches": [{"billboard_vertex_count": 0}]}),
+		"zero billboard vertex count does not rebuild",
+		failures
+	)
+
+
+func _verify_uv_rotation_decisions(failures: Array[String]) -> void:
+	_expect_false(
+		_classify("identity", _uv_data([_rotation_transform()])),
+		"identity UV rotation does not rebuild",
+		failures
+	)
+	_expect_true(
+		_classify(
+			"rotation",
+			_uv_data([_rotation_transform(Vector4(0.0, 1.0, -1.0, 0.0))])
+		),
+		"non-identity UV rotation rebuilds",
+		failures
+	)
+	_expect_true(
+		_classify("positive_speed", _uv_data([_rotation_transform(Vector4(1, 0, 0, 1), 0.000002)])),
+		"positive UV rotation speed rebuilds",
+		failures
+	)
+	_expect_true(
+		_classify("negative_speed", _uv_data([_rotation_transform(Vector4(1, 0, 0, 1), -0.000002)])),
+		"negative UV rotation speed rebuilds",
+		failures
+	)
+	_expect_false(
+		_classify("epsilon", _uv_data([_rotation_transform(Vector4(1, 0, 0, 1), 0.000001)])),
+		"exact UV rotation epsilon does not rebuild",
+		failures
+	)
+
+
+func _verify_stage_and_index_boundaries(failures: Array[String]) -> void:
+	var fifth_stage_transforms: Array = [
+		_rotation_transform(),
+		_rotation_transform(),
+		_rotation_transform(),
+		_rotation_transform(),
+		_rotation_transform(Vector4(0.0, 1.0, -1.0, 0.0)),
+	]
+	_expect_false(
+		_classify(
+			"fifth_stage",
+			_uv_data(fifth_stage_transforms, PackedInt32Array([0, 1, 2, 3, 4]), 5)
+		),
+		"fifth texture stage remains ignored",
+		failures
+	)
+	_expect_false(
+		_classify(
+			"invalid_indices",
+			_uv_data([_rotation_transform(Vector4(0, 1, -1, 0))], PackedInt32Array([-1, 9]), 2)
+		),
+		"invalid transform indices skipped",
+		failures
+	)
+	_expect_false(
+		_classify(
+			"invalid_transform",
+			_uv_data(["not-a-transform"], PackedInt32Array([0]), 1)
+		),
+		"non-Dictionary transform uses identity defaults",
+		failures
+	)
+
+
+func _verify_memoization_clear_and_diagnostics(failures: Array[String]) -> void:
+	var classifier: RefCounted = CLASSIFIER_SCRIPT.new()
+	var billboard_data := {"batches": [{"has_billboard": true}]}
+	_expect_true(
+		classifier.call("needs_runtime_mesh_rebuild", "world/tree.m2", billboard_data),
+		"first true decision",
+		failures
+	)
+	_expect_true(
+		classifier.call("needs_runtime_mesh_rebuild", "world/tree.m2", {}),
+		"first path decision memoized",
+		failures
+	)
+	classifier.call("needs_runtime_mesh_rebuild", "world/rock.m2", {})
+	_expect_equal(int(classifier.call("cached_path_count")), 2, "cached path count", failures)
+	var snapshot: Dictionary = classifier.call("diagnostic_snapshot")
+	snapshot["world/tree.m2"] = false
+	_expect_true(
+		classifier.call("needs_runtime_mesh_rebuild", "world/tree.m2", {}),
+		"diagnostics detached",
+		failures
+	)
+	classifier.call("clear")
+	_expect_equal(int(classifier.call("cached_path_count")), 0, "clear count", failures)
+	_expect_false(
+		classifier.call("needs_runtime_mesh_rebuild", "world/tree.m2", {}),
+		"clear allows recomputation",
+		failures
+	)
+
+
+func _verify_ownership_boundaries(failures: Array[String]) -> void:
+	var classifier_source := FileAccess.get_file_as_string(CLASSIFIER_PATH)
+	var loader_source := FileAccess.get_file_as_string(LOADER_PATH)
+	_expect_true(
+		loader_source.contains("M2_RUNTIME_MESH_REBUILD_CLASSIFIER_SCRIPT.new()"),
+		"loader composes classifier",
+		failures
+	)
+	_expect_equal(
+		loader_source.count("_m2_runtime_mesh_rebuild_classifier.clear()"),
+		2,
+		"loader retains two classifier clear sites",
+		failures
+	)
+	_expect_false(
+		loader_source.contains("_m2_runtime_rebuild_required_cache"),
+		"loader removes legacy rebuild cache",
+		failures
+	)
+	for removed_function in [
+		"func _m2_raw_data_needs_runtime_mesh_rebuild",
+		"func _m2_raw_data_has_billboards",
+		"func _m2_raw_data_has_uv_rotation",
+	]:
+		_expect_false(loader_source.contains(removed_function), "loader removes %s" % removed_function, failures)
+	for forbidden_dependency in [
+		"ResourceLoader.",
+		"WorkerThreadPool.",
+		"M2_BUILDER_SCRIPT",
+		"ClassDB.instantiate",
+		"FileAccess.",
+	]:
+		_expect_false(
+			classifier_source.contains(forbidden_dependency),
+			"classifier omits %s dependency" % forbidden_dependency,
+			failures
+		)
+
+
+func _verify_bounded_timing(failures: Array[String]) -> float:
+	var classifier: RefCounted = CLASSIFIER_SCRIPT.new()
+	var ordinary_data := {"batches": [{"has_billboard": false}]}
+	var started_microseconds := Time.get_ticks_usec()
+	for iteration in range(100):
+		for path_index in range(256):
+			classifier.call(
+				"needs_runtime_mesh_rebuild",
+				"world/model_%d.m2" % path_index,
+				ordinary_data
+			)
+		classifier.call("clear")
+	var elapsed_milliseconds := float(Time.get_ticks_usec() - started_microseconds) / 1000.0
+	_expect_true(elapsed_milliseconds < 1000.0, "100 by 256 classifications under 1 second", failures)
+	return elapsed_milliseconds
+
+
+func _classify(normalized_path: String, raw_data: Dictionary) -> bool:
+	var classifier: RefCounted = CLASSIFIER_SCRIPT.new()
+	return bool(classifier.call("needs_runtime_mesh_rebuild", normalized_path, raw_data))
+
+
+func _uv_data(
+		texture_transforms: Array,
+		texture_transform_combos: PackedInt32Array = PackedInt32Array([0]),
+		texture_count: int = 1) -> Dictionary:
+	return {
+		"texture_transforms": texture_transforms,
+		"texture_transform_combos": texture_transform_combos,
+		"batches": [{
+			"texture_count": texture_count,
+			"texture_transform_combo_index": 0,
+		}],
+	}
+
+
+func _rotation_transform(
+		rotation: Vector4 = Vector4(1.0, 0.0, 0.0, 1.0),
+		rotation_speed: float = 0.0) -> Dictionary:
+	return {
+		"rotation": rotation,
+		"rotation_speed": rotation_speed,
+	}
+
+
+func _expect_true(condition: bool, label: String, failures: Array[String]) -> void:
+	if not condition:
+		failures.append(label)
+
+
+func _expect_false(condition: bool, label: String, failures: Array[String]) -> void:
+	_expect_true(not condition, label, failures)
+
+
+func _expect_equal(actual: int, expected: int, label: String, failures: Array[String]) -> void:
+	if actual != expected:
+		failures.append("%s expected=%d actual=%d" % [label, expected, actual])

src/tools/verify_m2_runtime_mesh_rebuild_classifier.gd.uid

@@ -0,0 +1 @@
+uid://cc62iwxjrkte6

src/tools/verify_render_runtime_cache_shutdown.gd

@@ -38,10 +38,15 @@ func _verify_runtime_cache_ownership() -> void:
 	loader.set("_m2_mesh_cache", {"mesh": ArrayMesh.new()})
 	loader.set("_m2_static_animation_cache", {"static": true})
 	loader.set("_m2_missing_cache", {"missing": true})
-	loader.set("_wmo_render_cache", {"render": Resource.new()})
-	loader.set("_wmo_scene_resource_cache", {"scene": PackedScene.new()})
-	loader.set("_wmo_render_missing_cache", {"missing": true})
-	loader.set("_wmo_scene_cache_missing", {"missing": true})
+	var wmo_render_cache_state: RefCounted = loader.get("_wmo_render_resource_cache_state")
+	wmo_render_cache_state.call("remember_request", "render", "res://render.res")
+	wmo_render_cache_state.call("complete_request_with_resource", "render", Resource.new())
+	wmo_render_cache_state.call("remember_request", "missing", "res://missing.res")
+	wmo_render_cache_state.call("complete_request_as_missing", "missing")
+	var wmo_scene_cache_state: RefCounted = loader.get("_wmo_scene_resource_cache_state")
+	wmo_scene_cache_state.call("remember_request", "scene", "res://scene.tscn")
+	wmo_scene_cache_state.call("complete_request_with_scene", "scene", PackedScene.new())
+	wmo_scene_cache_state.call("mark_missing", "missing")
 	loader.set("_wmo_missing_cache", {"missing": true})
 	loader.set("_shared_tex_cache", {"texture": ImageTexture.new()})
 
@@ -57,15 +62,30 @@ func _verify_runtime_cache_ownership() -> void:
 		"_m2_mesh_cache",
 		"_m2_static_animation_cache",
 		"_m2_missing_cache",
-		"_wmo_render_cache",
-		"_wmo_scene_resource_cache",
-		"_wmo_render_missing_cache",
-		"_wmo_scene_cache_missing",
 		"_wmo_missing_cache",
 		"_shared_tex_cache",
 	]:
 		var cache: Dictionary = loader.get(cache_name)
 		_expect(cache.is_empty(), "%s should be empty after shutdown" % cache_name)
+	var wmo_render_snapshot: Dictionary = wmo_render_cache_state.call("diagnostic_snapshot")
+	_expect(
+		(wmo_render_snapshot["resource_paths"] as Array).is_empty(),
+		"WMO render Resources should be empty after shutdown"
+	)
+	_expect(
+		(wmo_render_snapshot["missing_paths"] as Array).is_empty(),
+		"WMO render negative cache should be empty after shutdown"
+	)
+	_expect(
+		(wmo_render_snapshot["request_paths"] as Array).is_empty(),
+		"WMO render requests should be empty after shutdown"
+	)
+	var wmo_scene_snapshot: Dictionary = wmo_scene_cache_state.call("diagnostic_snapshot")
+	for state_key in ["scene_paths", "missing_paths", "request_paths"]:
+		_expect(
+			(wmo_scene_snapshot[state_key] as Array).is_empty(),
+			"WMO scene %s should be empty after shutdown" % state_key
+		)
 
 	loader.free()
 

src/tools/verify_wmo_render_build_queue.gd

@@ -0,0 +1,205 @@
+extends SceneTree
+
+## Asset-free lifecycle, ordering, ownership and timing regression for WMO jobs.
+
+const QUEUE_SCRIPT := preload("res://src/render/wmo/wmo_render_build_queue.gd")
+const QUEUE_PATH := "res://src/render/wmo/wmo_render_build_queue.gd"
+const JOB_PATH := "res://src/render/wmo/wmo_render_build_job.gd"
+const LOADER_PATH := "res://src/scenes/streaming/streaming_world_loader.gd"
+
+
+func _initialize() -> void:
+	var failures: Array[String] = []
+	_verify_invalid_and_fifo_jobs(failures)
+	_verify_cursor_adoption(failures)
+	_verify_duplicate_and_stale_key_behavior(failures)
+	_verify_cancel_clear_and_engine_lifetime(failures)
+	_verify_detached_sorted_diagnostics(failures)
+	_verify_loader_and_engine_lifetime_boundaries(failures)
+	var elapsed_milliseconds := _verify_bounded_timing(failures)
+	if not failures.is_empty():
+		for failure in failures:
+			push_error("WMO_RENDER_BUILD_QUEUE: %s" % failure)
+		quit(1)
+		return
+	print(
+		"WMO_RENDER_BUILD_QUEUE PASS cases=11 iterations=100 elapsed_ms=%.3f"
+		% elapsed_milliseconds
+	)
+	quit(0)
+
+
+func _verify_invalid_and_fifo_jobs(failures: Array[String]) -> void:
+	var queue: RefCounted = QUEUE_SCRIPT.new()
+	var root := Node3D.new()
+	var render_resource := Resource.new()
+	_expect_false(queue.call("enqueue", "", root, render_resource), "empty key rejected", failures)
+	_expect_false(queue.call("enqueue", "uid:1", null, render_resource), "null root rejected", failures)
+	_expect_false(queue.call("enqueue", "uid:1", root, null), "null resource rejected", failures)
+	_expect_true(queue.call("enqueue", "uid:2", root, render_resource), "first enqueue", failures)
+	_expect_true(queue.call("enqueue", "uid:3", root, render_resource), "second enqueue", failures)
+	_expect_string_equal(String(queue.call("front_key")), "uid:2", "FIFO front", failures)
+	_expect_equal(int(queue.call("pending_count")), 2, "FIFO pending count", failures)
+	_expect_equal(int(queue.call("active_job_count")), 2, "FIFO active count", failures)
+	var first_job: RefCounted = queue.call("job_for", "uid:2")
+	_expect_string_equal(String(first_job.call("placement_key")), "uid:2", "typed job key", failures)
+	_expect_true(first_job.call("root") == root, "job retains root", failures)
+	_expect_true(first_job.call("render_resource") == render_resource, "job retains resource", failures)
+	queue.call("clear")
+	root.free()
+
+
+func _verify_cursor_adoption(failures: Array[String]) -> void:
+	var queue: RefCounted = QUEUE_SCRIPT.new()
+	var root := Node3D.new()
+	queue.call("enqueue", "uid:4", root, Resource.new())
+	var job: RefCounted = queue.call("job_for", "uid:4")
+	_expect_equal(int(job.call("mesh_index")), 0, "initial mesh cursor", failures)
+	_expect_equal(int(job.call("multimesh_index")), 0, "initial multimesh cursor", failures)
+	job.call("adopt_cursors", 7, 3)
+	_expect_equal(int(job.call("mesh_index")), 7, "adopted mesh cursor", failures)
+	_expect_equal(int(job.call("multimesh_index")), 3, "adopted multimesh cursor", failures)
+	queue.call("clear")
+	root.free()
+
+
+func _verify_duplicate_and_stale_key_behavior(failures: Array[String]) -> void:
+	var queue: RefCounted = QUEUE_SCRIPT.new()
+	var first_root := Node3D.new()
+	var second_root := Node3D.new()
+	queue.call("enqueue", "uid:5", first_root, Resource.new())
+	queue.call("enqueue", "uid:5", second_root, Resource.new())
+	_expect_equal(int(queue.call("pending_count")), 2, "duplicate keys append", failures)
+	_expect_equal(int(queue.call("active_job_count")), 1, "duplicate job replaces", failures)
+	var replacement_job: RefCounted = queue.call("job_for", "uid:5")
+	_expect_true(replacement_job.call("root") == second_root, "duplicate latest job wins", failures)
+	_expect_true(queue.call("cancel", "uid:5"), "duplicate cancel finds job", failures)
+	_expect_equal(int(queue.call("pending_count")), 1, "cancel erases first duplicate key", failures)
+	_expect_true(queue.call("job_for", "uid:5") == null, "remaining duplicate key is stale", failures)
+	_expect_string_equal(String(queue.call("pop_front")), "uid:5", "stale front pop", failures)
+	_expect_false(queue.call("has_pending"), "stale queue drained", failures)
+	first_root.free()
+	second_root.free()
+
+
+func _verify_cancel_clear_and_engine_lifetime(failures: Array[String]) -> void:
+	var queue: RefCounted = QUEUE_SCRIPT.new()
+	var root := Node3D.new()
+	queue.call("enqueue", "uid:6", root, Resource.new())
+	_expect_false(queue.call("cancel", "uid:missing"), "unknown cancel", failures)
+	_expect_true(is_instance_valid(root), "unknown cancel keeps root valid", failures)
+	queue.call("clear")
+	queue.call("clear")
+	_expect_equal(int(queue.call("pending_count")), 0, "clear idempotent", failures)
+	_expect_true(is_instance_valid(root), "clear does not free root", failures)
+	root.free()
+
+
+func _verify_detached_sorted_diagnostics(failures: Array[String]) -> void:
+	var queue: RefCounted = QUEUE_SCRIPT.new()
+	var root := Node3D.new()
+	queue.call("enqueue", "uid:20", root, Resource.new())
+	queue.call("enqueue", "uid:10", root, Resource.new())
+	var snapshot: Dictionary = queue.call("diagnostic_snapshot")
+	_expect_string_array(
+		snapshot["queued_placement_keys"],
+		["uid:20", "uid:10"],
+		"diagnostic queue order",
+		failures
+	)
+	var jobs: Array = snapshot["jobs"]
+	_expect_string_equal(String(jobs[0]["placement_key"]), "uid:10", "diagnostic job sort", failures)
+	(snapshot["queued_placement_keys"] as Array).append("mutated")
+	jobs[0]["mesh_index"] = 99
+	var fresh_snapshot: Dictionary = queue.call("diagnostic_snapshot")
+	_expect_string_array(
+		fresh_snapshot["queued_placement_keys"],
+		["uid:20", "uid:10"],
+		"diagnostic queue detached",
+		failures
+	)
+	_expect_equal(int((fresh_snapshot["jobs"] as Array)[0]["mesh_index"]), 0, "job diagnostic detached", failures)
+	queue.call("clear")
+	root.free()
+
+
+func _verify_loader_and_engine_lifetime_boundaries(failures: Array[String]) -> void:
+	var loader_source := _read_text(LOADER_PATH, failures)
+	var queue_source := _read_text(QUEUE_PATH, failures)
+	var job_source := _read_text(JOB_PATH, failures)
+	_expect_true(
+		loader_source.contains("WMO_RENDER_BUILD_QUEUE_SCRIPT.new()"),
+		"loader composes queue",
+		failures
+	)
+	_expect_true(loader_source.contains("_wmo_render_build_queue.enqueue("), "loader delegates enqueue", failures)
+	_expect_true(loader_source.contains("_wmo_render_build_queue.has_job("), "loader checks stale keys", failures)
+	_expect_true(loader_source.contains("_wmo_render_build_queue.root_for("), "loader borrows root", failures)
+	_expect_true(loader_source.contains("_wmo_render_build_queue.render_resource_for("), "loader borrows resource", failures)
+	_expect_true(loader_source.contains("_wmo_render_build_queue.adopt_cursors("), "loader delegates cursors", failures)
+	_expect_true(loader_source.contains("_wmo_render_build_queue.cancel("), "loader delegates cancel", failures)
+	_expect_true(loader_source.contains("_wmo_render_build_queue.clear()"), "loader delegates clear", failures)
+	_expect_false(loader_source.contains("var _wmo_render_build_jobs"), "legacy job dictionary removed", failures)
+	_expect_true(
+		loader_source.contains("MeshInstance3D.new()")
+		and loader_source.contains("MultiMeshInstance3D.new()")
+		and loader_source.contains("try_consume_permit("),
+		"loader retains materialization and permits",
+		failures
+	)
+	for forbidden_token in ["queue_free", "RenderingServer", "RID", "MeshInstance3D", "MultiMeshInstance3D", "FileAccess", "Thread", "Mutex"]:
+		_expect_false(
+			queue_source.contains(forbidden_token) or job_source.contains(forbidden_token),
+			"queue/job omit %s ownership" % forbidden_token,
+			failures
+		)
+
+
+func _verify_bounded_timing(failures: Array[String]) -> float:
+	var queue: RefCounted = QUEUE_SCRIPT.new()
+	var root := Node3D.new()
+	var render_resource := Resource.new()
+	var started_microseconds := Time.get_ticks_usec()
+	for _iteration in range(100):
+		for job_index in range(256):
+			queue.call("enqueue", "uid:%d" % job_index, root, render_resource)
+		for job_index in range(256):
+			queue.call("cancel", "uid:%d" % job_index)
+		_expect_equal(int(queue.call("pending_count")), 0, "timing cycle drains", failures)
+	var elapsed_milliseconds := float(Time.get_ticks_usec() - started_microseconds) / 1000.0
+	_expect_true(elapsed_milliseconds < 1000.0, "100 queue cycles remain bounded", failures)
+	root.free()
+	return elapsed_milliseconds
+
+
+func _read_text(path: String, failures: Array[String]) -> String:
+	var file := FileAccess.open(path, FileAccess.READ)
+	if file == null:
+		failures.append("cannot open %s" % path)
+		return ""
+	return file.get_as_text()
+
+
+func _expect_equal(actual_value: int, expected_value: int, label: String, failures: Array[String]) -> void:
+	if actual_value != expected_value:
+		failures.append("%s expected %d, got %d" % [label, expected_value, actual_value])
+
+
+func _expect_string_equal(actual_value: String, expected_value: String, label: String, failures: Array[String]) -> void:
+	if actual_value != expected_value:
+		failures.append("%s expected %s, got %s" % [label, expected_value, actual_value])
+
+
+func _expect_string_array(actual_values: Array, expected_values: Array, label: String, failures: Array[String]) -> void:
+	if actual_values != expected_values:
+		failures.append("%s expected %s, got %s" % [label, expected_values, actual_values])
+
+
+func _expect_true(actual_value: bool, label: String, failures: Array[String]) -> void:
+	if not actual_value:
+		failures.append("%s expected true" % label)
+
+
+func _expect_false(actual_value: bool, label: String, failures: Array[String]) -> void:
+	if actual_value:
+		failures.append("%s expected false" % label)

src/tools/verify_wmo_render_build_queue.gd.uid

@@ -0,0 +1 @@
+uid://s6bsyt6bv1uq

src/tools/verify_wmo_render_resource_cache_state.gd

@@ -0,0 +1,335 @@
+extends SceneTree
+
+## Asset-free lifecycle, ownership, dependency and timing regression for the
+## lightweight-WMO render Resource cache state.
+
+const CACHE_STATE_SCRIPT := preload(
+	"res://src/render/wmo/wmo_render_resource_cache_state.gd"
+)
+const CACHE_STATE_PATH := "res://src/render/wmo/wmo_render_resource_cache_state.gd"
+const LOADER_PATH := "res://src/scenes/streaming/streaming_world_loader.gd"
+
+
+func _initialize() -> void:
+	var failures: Array[String] = []
+	_verify_invalid_and_request_state(failures)
+	_verify_validated_resource_completion(failures)
+	_verify_missing_completion_and_exclusivity(failures)
+	_verify_transient_and_full_clear(failures)
+	_verify_detached_sorted_diagnostics(failures)
+	_verify_ownership_boundaries(failures)
+	var elapsed_milliseconds := _verify_bounded_timing(failures)
+	if not failures.is_empty():
+		for failure in failures:
+			push_error("WMO_RENDER_RESOURCE_CACHE_STATE: %s" % failure)
+		quit(1)
+		return
+	print(
+		"WMO_RENDER_RESOURCE_CACHE_STATE PASS cases=10 iterations=100 elapsed_ms=%.3f"
+		% elapsed_milliseconds
+	)
+	quit(0)
+
+
+func _verify_invalid_and_request_state(failures: Array[String]) -> void:
+	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
+	_expect_false(
+		cache_state.call("remember_request", "", "res://cache.res"),
+		"empty normalized path rejected",
+		failures
+	)
+	_expect_false(
+		cache_state.call("remember_request", "world/a.wmo", ""),
+		"empty cache path rejected",
+		failures
+	)
+	_expect_true(
+		cache_state.call("remember_request", "world/a.wmo", "res://cache/a.res"),
+		"valid request accepted",
+		failures
+	)
+	_expect_true(
+		cache_state.call("has_request", "world/a.wmo"),
+		"pending request observable",
+		failures
+	)
+	_expect_false(
+		cache_state.call("remember_request", "world/a.wmo", "res://cache/other.res"),
+		"duplicate request rejected",
+		failures
+	)
+	var request_snapshot: Dictionary = cache_state.call("request_paths_snapshot")
+	_expect_string_equal(
+		String(request_snapshot.get("world/a.wmo", "")),
+		"res://cache/a.res",
+		"request cache path preserved",
+		failures
+	)
+	request_snapshot.clear()
+	_expect_true(
+		cache_state.call("has_request", "world/a.wmo"),
+		"request snapshot detached",
+		failures
+	)
+
+
+func _verify_validated_resource_completion(failures: Array[String]) -> void:
+	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
+	var validated_resource := Resource.new()
+	cache_state.call("remember_request", "world/b.wmo", "res://cache/b.res")
+	_expect_false(
+		cache_state.call("complete_request_with_resource", "world/b.wmo", null),
+		"null completion rejected",
+		failures
+	)
+	_expect_true(
+		cache_state.call(
+			"complete_request_with_resource",
+			"world/b.wmo",
+			validated_resource
+		),
+		"validated Resource completes request",
+		failures
+	)
+	_expect_false(
+		cache_state.call("has_request", "world/b.wmo"),
+		"successful completion removes request",
+		failures
+	)
+	_expect_true(
+		cache_state.call("contains_resource", "world/b.wmo"),
+		"successful completion cached",
+		failures
+	)
+	_expect_true(
+		cache_state.call("resource_for", "world/b.wmo") == validated_resource,
+		"cached Resource identity preserved",
+		failures
+	)
+	_expect_false(
+		cache_state.call("remember_request", "world/b.wmo", "res://cache/b2.res"),
+		"cached path rejects request",
+		failures
+	)
+
+
+func _verify_missing_completion_and_exclusivity(failures: Array[String]) -> void:
+	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
+	_expect_false(
+		cache_state.call("complete_request_as_missing", "world/unknown.wmo"),
+		"unknown completion rejected",
+		failures
+	)
+	cache_state.call("remember_request", "world/missing.wmo", "res://cache/missing.res")
+	_expect_true(
+		cache_state.call("complete_request_as_missing", "world/missing.wmo"),
+		"failed request completes as missing",
+		failures
+	)
+	_expect_true(
+		cache_state.call("is_missing", "world/missing.wmo"),
+		"negative cache observable",
+		failures
+	)
+	_expect_false(
+		cache_state.call("has_request", "world/missing.wmo"),
+		"missing completion removes request",
+		failures
+	)
+	_expect_false(
+		cache_state.call(
+			"remember_request",
+			"world/missing.wmo",
+			"res://cache/retry.res"
+		),
+		"negative cache rejects request",
+		failures
+	)
+
+
+func _verify_transient_and_full_clear(failures: Array[String]) -> void:
+	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
+	var retained_resource := Resource.new()
+	cache_state.call("remember_request", "world/retained.wmo", "res://cache/retained.res")
+	cache_state.call(
+		"complete_request_with_resource",
+		"world/retained.wmo",
+		retained_resource
+	)
+	cache_state.call("remember_request", "world/pending.wmo", "res://cache/pending.res")
+	cache_state.call("remember_request", "world/missing.wmo", "res://cache/missing.res")
+	cache_state.call("complete_request_as_missing", "world/missing.wmo")
+	cache_state.call("clear_transient_state")
+	_expect_true(
+		cache_state.call("resource_for", "world/retained.wmo") == retained_resource,
+		"transient clear retains validated Resource",
+		failures
+	)
+	_expect_equal(
+		int(cache_state.call("pending_request_count")),
+		0,
+		"transient clear removes requests",
+		failures
+	)
+	_expect_false(
+		cache_state.call("is_missing", "world/missing.wmo"),
+		"transient clear removes negative cache",
+		failures
+	)
+	cache_state.call("clear_all")
+	cache_state.call("clear_all")
+	_expect_false(
+		cache_state.call("contains_resource", "world/retained.wmo"),
+		"full clear idempotently releases Resource",
+		failures
+	)
+
+
+func _verify_detached_sorted_diagnostics(failures: Array[String]) -> void:
+	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
+	for normalized_path in ["world/z.wmo", "world/a.wmo"]:
+		cache_state.call("remember_request", normalized_path, "res://cache/%s.res" % normalized_path)
+	var snapshot: Dictionary = cache_state.call("diagnostic_snapshot")
+	_expect_string_array(
+		snapshot["request_paths"],
+		["world/a.wmo", "world/z.wmo"],
+		"request diagnostics sorted",
+		failures
+	)
+	(snapshot["request_paths"] as Array).clear()
+	var fresh_snapshot: Dictionary = cache_state.call("diagnostic_snapshot")
+	_expect_equal(
+		(fresh_snapshot["request_paths"] as Array).size(),
+		2,
+		"diagnostics detached",
+		failures
+	)
+
+
+func _verify_ownership_boundaries(failures: Array[String]) -> void:
+	var loader_source := _read_text(LOADER_PATH, failures)
+	var cache_state_source := _read_text(CACHE_STATE_PATH, failures)
+	_expect_true(
+		loader_source.contains("WMO_RENDER_RESOURCE_CACHE_STATE_SCRIPT.new()"),
+		"loader composes cache state",
+		failures
+	)
+	for legacy_field in [
+		"var _wmo_render_cache:",
+		"var _wmo_render_missing_cache:",
+		"var _wmo_render_load_requests:",
+	]:
+		_expect_false(
+			loader_source.contains(legacy_field),
+			"loader removes %s" % legacy_field,
+			failures
+		)
+	for loader_owned_token in [
+		"ResourceLoader.",
+		"FileAccess.",
+		"WMO_STREAMING_SCRIPT",
+		"format_version",
+		"Node3D",
+		"RID",
+		"Thread",
+		"Mutex",
+		"Semaphore",
+	]:
+		_expect_false(
+			cache_state_source.contains(loader_owned_token),
+			"cache state omits %s dependency" % loader_owned_token,
+			failures
+		)
+	_expect_true(
+		loader_source.contains("resource.get_script() == WMO_STREAMING_SCRIPT"),
+		"loader retains script validation",
+		failures
+	)
+	_expect_true(
+		loader_source.contains("WMO_STREAMING_SCRIPT.FORMAT_VERSION"),
+		"loader retains cache format validation",
+		failures
+	)
+
+
+func _verify_bounded_timing(failures: Array[String]) -> float:
+	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
+	var started_microseconds := Time.get_ticks_usec()
+	for iteration in range(100):
+		for resource_index in range(256):
+			var normalized_path := "world/object_%d.wmo" % resource_index
+			cache_state.call(
+				"remember_request",
+				normalized_path,
+				"res://cache/object_%d.res" % resource_index
+			)
+			if resource_index % 2 == 0:
+				cache_state.call(
+					"complete_request_with_resource",
+					normalized_path,
+					Resource.new()
+				)
+			else:
+				cache_state.call("complete_request_as_missing", normalized_path)
+		cache_state.call("clear_all")
+		_expect_equal(
+			int(cache_state.call("pending_request_count")),
+			0,
+			"timing cycle %d clears" % iteration,
+			failures
+		)
+	var elapsed_milliseconds := float(Time.get_ticks_usec() - started_microseconds) / 1000.0
+	_expect_true(
+		elapsed_milliseconds < 1000.0,
+		"100 resource/request cycles remain bounded",
+		failures
+	)
+	return elapsed_milliseconds
+
+
+func _read_text(path: String, failures: Array[String]) -> String:
+	var file := FileAccess.open(path, FileAccess.READ)
+	if file == null:
+		failures.append("cannot open %s" % path)
+		return ""
+	return file.get_as_text()
+
+
+func _expect_equal(
+		actual_value: int,
+		expected_value: int,
+		label: String,
+		failures: Array[String]
+) -> void:
+	if actual_value != expected_value:
+		failures.append("%s expected %d, got %d" % [label, expected_value, actual_value])
+
+
+func _expect_string_equal(
+		actual_value: String,
+		expected_value: String,
+		label: String,
+		failures: Array[String]
+) -> void:
+	if actual_value != expected_value:
+		failures.append("%s expected %s, got %s" % [label, expected_value, actual_value])
+
+
+func _expect_string_array(
+		actual_values: Array,
+		expected_values: Array,
+		label: String,
+		failures: Array[String]
+) -> void:
+	if actual_values != expected_values:
+		failures.append("%s expected %s, got %s" % [label, expected_values, actual_values])
+
+
+func _expect_true(actual_value: bool, label: String, failures: Array[String]) -> void:
+	if not actual_value:
+		failures.append("%s expected true" % label)
+
+
+func _expect_false(actual_value: bool, label: String, failures: Array[String]) -> void:
+	if actual_value:
+		failures.append("%s expected false" % label)

src/tools/verify_wmo_render_resource_cache_state.gd.uid

@@ -0,0 +1 @@
+uid://b5kuqdm8au7o1

src/tools/verify_wmo_scene_resource_cache_state.gd

@@ -0,0 +1,363 @@
+extends SceneTree
+
+## Asset-free state, ownership, dependency and timing regression for cached WMO scenes.
+
+const CACHE_STATE_SCRIPT := preload(
+	"res://src/render/wmo/wmo_scene_resource_cache_state.gd"
+)
+const CACHE_STATE_PATH := "res://src/render/wmo/wmo_scene_resource_cache_state.gd"
+const LOADER_PATH := "res://src/scenes/streaming/streaming_world_loader.gd"
+
+
+func _initialize() -> void:
+	var failures: Array[String] = []
+	_verify_invalid_and_request_state(failures)
+	_verify_direct_missing_and_exclusivity(failures)
+	_verify_validated_scene_completion(failures)
+	_verify_failed_request_completion(failures)
+	_verify_transient_and_full_clear(failures)
+	_verify_detached_sorted_diagnostics(failures)
+	_verify_ownership_boundaries(failures)
+	var elapsed_milliseconds := _verify_bounded_timing(failures)
+	if not failures.is_empty():
+		for failure in failures:
+			push_error("WMO_SCENE_RESOURCE_CACHE_STATE: %s" % failure)
+		quit(1)
+		return
+	print(
+		"WMO_SCENE_RESOURCE_CACHE_STATE PASS cases=11 iterations=100 elapsed_ms=%.3f"
+		% elapsed_milliseconds
+	)
+	quit(0)
+
+
+func _verify_invalid_and_request_state(failures: Array[String]) -> void:
+	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
+	_expect_false(
+		cache_state.call("remember_request", "", "res://cache/a.tscn"),
+		"empty normalized path rejected",
+		failures
+	)
+	_expect_false(
+		cache_state.call("remember_request", "world/a.wmo", ""),
+		"empty cache path rejected",
+		failures
+	)
+	_expect_true(
+		cache_state.call("remember_request", "world/a.wmo", "res://cache/a.tscn"),
+		"valid request accepted",
+		failures
+	)
+	_expect_true(
+		cache_state.call("has_request", "world/a.wmo"),
+		"pending request observable",
+		failures
+	)
+	_expect_equal(
+		int(cache_state.call("pending_request_count")),
+		1,
+		"pending request count",
+		failures
+	)
+	_expect_false(
+		cache_state.call("remember_request", "world/a.wmo", "res://cache/other.tscn"),
+		"duplicate request rejected",
+		failures
+	)
+	var request_snapshot: Dictionary = cache_state.call("request_paths_snapshot")
+	_expect_string_equal(
+		String(request_snapshot.get("world/a.wmo", "")),
+		"res://cache/a.tscn",
+		"request cache path preserved",
+		failures
+	)
+	request_snapshot.clear()
+	_expect_true(
+		cache_state.call("has_request", "world/a.wmo"),
+		"request snapshot detached",
+		failures
+	)
+
+
+func _verify_direct_missing_and_exclusivity(failures: Array[String]) -> void:
+	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
+	_expect_false(cache_state.call("mark_missing", ""), "empty missing rejected", failures)
+	_expect_true(
+		cache_state.call("mark_missing", "world/missing.wmo"),
+		"direct missing accepted",
+		failures
+	)
+	_expect_true(
+		cache_state.call("is_missing", "world/missing.wmo"),
+		"direct missing observable",
+		failures
+	)
+	_expect_false(
+		cache_state.call("mark_missing", "world/missing.wmo"),
+		"duplicate missing rejected",
+		failures
+	)
+	_expect_false(
+		cache_state.call(
+			"remember_request",
+			"world/missing.wmo",
+			"res://cache/retry.tscn"
+		),
+		"missing path rejects request",
+		failures
+	)
+
+
+func _verify_validated_scene_completion(failures: Array[String]) -> void:
+	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
+	var validated_scene := PackedScene.new()
+	cache_state.call("remember_request", "world/b.wmo", "res://cache/b.tscn")
+	_expect_false(
+		cache_state.call("complete_request_with_scene", "world/b.wmo", null),
+		"null completion rejected",
+		failures
+	)
+	_expect_true(
+		cache_state.call("complete_request_with_scene", "world/b.wmo", validated_scene),
+		"validated PackedScene completes request",
+		failures
+	)
+	_expect_false(
+		cache_state.call("has_request", "world/b.wmo"),
+		"successful completion removes request",
+		failures
+	)
+	_expect_true(
+		cache_state.call("contains_scene", "world/b.wmo"),
+		"successful completion cached",
+		failures
+	)
+	_expect_true(
+		cache_state.call("scene_for", "world/b.wmo") == validated_scene,
+		"cached PackedScene identity preserved",
+		failures
+	)
+	_expect_false(
+		cache_state.call("mark_missing", "world/b.wmo"),
+		"cached scene rejects missing state",
+		failures
+	)
+
+
+func _verify_failed_request_completion(failures: Array[String]) -> void:
+	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
+	_expect_false(
+		cache_state.call("complete_request_as_missing", "world/unknown.wmo"),
+		"unknown request completion rejected",
+		failures
+	)
+	cache_state.call("remember_request", "world/failed.wmo", "res://cache/failed.tscn")
+	_expect_true(
+		cache_state.call("complete_request_as_missing", "world/failed.wmo"),
+		"failed request completes as missing",
+		failures
+	)
+	_expect_true(
+		cache_state.call("is_missing", "world/failed.wmo"),
+		"failed request negative-cached",
+		failures
+	)
+	_expect_false(
+		cache_state.call("has_request", "world/failed.wmo"),
+		"failed completion removes request",
+		failures
+	)
+
+
+func _verify_transient_and_full_clear(failures: Array[String]) -> void:
+	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
+	var retained_scene := PackedScene.new()
+	cache_state.call("remember_request", "world/retained.wmo", "res://retained.tscn")
+	cache_state.call("complete_request_with_scene", "world/retained.wmo", retained_scene)
+	cache_state.call("remember_request", "world/pending.wmo", "res://pending.tscn")
+	cache_state.call("mark_missing", "world/missing.wmo")
+	cache_state.call("clear_transient_state")
+	_expect_true(
+		cache_state.call("scene_for", "world/retained.wmo") == retained_scene,
+		"transient clear retains PackedScene",
+		failures
+	)
+	_expect_equal(
+		int(cache_state.call("pending_request_count")),
+		0,
+		"transient clear removes requests",
+		failures
+	)
+	_expect_false(
+		cache_state.call("is_missing", "world/missing.wmo"),
+		"transient clear removes missing state",
+		failures
+	)
+	cache_state.call("clear_all")
+	cache_state.call("clear_all")
+	_expect_false(
+		cache_state.call("contains_scene", "world/retained.wmo"),
+		"full clear idempotently releases PackedScene",
+		failures
+	)
+
+
+func _verify_detached_sorted_diagnostics(failures: Array[String]) -> void:
+	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
+	cache_state.call("remember_request", "world/z.wmo", "res://z.tscn")
+	cache_state.call("remember_request", "world/a.wmo", "res://a.tscn")
+	cache_state.call("mark_missing", "world/m.wmo")
+	var snapshot: Dictionary = cache_state.call("diagnostic_snapshot")
+	_expect_string_array(
+		snapshot["request_paths"],
+		["world/a.wmo", "world/z.wmo"],
+		"request diagnostics sorted",
+		failures
+	)
+	_expect_string_array(
+		snapshot["missing_paths"],
+		["world/m.wmo"],
+		"missing diagnostics",
+		failures
+	)
+	(snapshot["request_paths"] as Array).clear()
+	var fresh_snapshot: Dictionary = cache_state.call("diagnostic_snapshot")
+	_expect_equal(
+		(fresh_snapshot["request_paths"] as Array).size(),
+		2,
+		"diagnostics detached",
+		failures
+	)
+
+
+func _verify_ownership_boundaries(failures: Array[String]) -> void:
+	var loader_source := _read_text(LOADER_PATH, failures)
+	var cache_state_source := _read_text(CACHE_STATE_PATH, failures)
+	_expect_true(
+		loader_source.contains("WMO_SCENE_RESOURCE_CACHE_STATE_SCRIPT.new()"),
+		"loader composes scene cache state",
+		failures
+	)
+	for legacy_field in [
+		"var _wmo_scene_resource_cache:",
+		"var _wmo_scene_cache_missing:",
+		"var _wmo_scene_load_requests:",
+	]:
+		_expect_false(
+			loader_source.contains(legacy_field),
+			"loader removes %s" % legacy_field,
+			failures
+		)
+	for loader_owned_token in [
+		"ResourceLoader.",
+		"FileAccess.",
+		"WMO_BUILDER_SCRIPT",
+		"instantiate()",
+		"Node3D",
+		"RID",
+		"Mutex",
+		"Semaphore",
+	]:
+		_expect_false(
+			cache_state_source.contains(loader_owned_token),
+			"scene cache state omits %s dependency" % loader_owned_token,
+			failures
+		)
+	for retained_loader_rule in [
+		"wmo_max_runtime_scene_mb",
+		"_get_resource_file_size(cache_path)",
+		"_is_wmo_scene_cache_current(resource as PackedScene)",
+		"scene.instantiate() as Node3D",
+		"WMO_BUILDER_SCRIPT.is_scene_cache_current(node)",
+	]:
+		_expect_true(
+			loader_source.contains(retained_loader_rule),
+			"loader retains %s" % retained_loader_rule,
+			failures
+		)
+
+
+func _verify_bounded_timing(failures: Array[String]) -> float:
+	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
+	var started_microseconds := Time.get_ticks_usec()
+	for iteration in range(100):
+		for scene_index in range(256):
+			var normalized_path := "world/object_%d.wmo" % scene_index
+			if scene_index % 3 == 0:
+				cache_state.call("mark_missing", normalized_path)
+			else:
+				cache_state.call(
+					"remember_request",
+					normalized_path,
+					"res://cache/object_%d.tscn" % scene_index
+				)
+				if scene_index % 2 == 0:
+					cache_state.call(
+						"complete_request_with_scene",
+						normalized_path,
+						PackedScene.new()
+					)
+				else:
+					cache_state.call("complete_request_as_missing", normalized_path)
+		cache_state.call("clear_all")
+		_expect_equal(
+			int(cache_state.call("pending_request_count")),
+			0,
+			"timing cycle %d clears" % iteration,
+			failures
+		)
+	var elapsed_milliseconds := float(Time.get_ticks_usec() - started_microseconds) / 1000.0
+	_expect_true(
+		elapsed_milliseconds < 1000.0,
+		"100 scene/request cycles remain bounded",
+		failures
+	)
+	return elapsed_milliseconds
+
+
+func _read_text(path: String, failures: Array[String]) -> String:
+	var file := FileAccess.open(path, FileAccess.READ)
+	if file == null:
+		failures.append("cannot open %s" % path)
+		return ""
+	return file.get_as_text()
+
+
+func _expect_equal(
+		actual_value: int,
+		expected_value: int,
+		label: String,
+		failures: Array[String]
+) -> void:
+	if actual_value != expected_value:
+		failures.append("%s expected %d, got %d" % [label, expected_value, actual_value])
+
+
+func _expect_string_equal(
+		actual_value: String,
+		expected_value: String,
+		label: String,
+		failures: Array[String]
+) -> void:
+	if actual_value != expected_value:
+		failures.append("%s expected %s, got %s" % [label, expected_value, actual_value])
+
+
+func _expect_string_array(
+		actual_values: Array,
+		expected_values: Array,
+		label: String,
+		failures: Array[String]
+) -> void:
+	if actual_values != expected_values:
+		failures.append("%s expected %s, got %s" % [label, expected_values, actual_values])
+
+
+func _expect_true(actual_value: bool, label: String, failures: Array[String]) -> void:
+	if not actual_value:
+		failures.append("%s expected true" % label)
+
+
+func _expect_false(actual_value: bool, label: String, failures: Array[String]) -> void:
+	if actual_value:
+		failures.append("%s expected false" % label)

src/tools/verify_wmo_scene_resource_cache_state.gd.uid

@@ -0,0 +1 @@
+uid://ccuuoqli83f6f

targets/03-renderer-facade.md

@@ -27,7 +27,7 @@ Runtime и Editor используют facade; planner/scheduler тестиру
 ## Evidence
 
 - Date: 2026-07-17
-- Revision/worktree: master merges `7ece2ab`, `7e35de7`, `80cb084`, `d6e5b53`, `c69abd6`, `606770c`, `630a0c1`, `f36fabb`, `24aef13`, `2342430`, `396be5e`, `f88bf97`, `3f84717`, `d2cb52f`, `f9e5a4f`, `c06aed5`;
+- Revision/worktree: master merges `7ece2ab`, `7e35de7`, `80cb084`, `d6e5b53`, `c69abd6`, `606770c`, `630a0c1`, `f36fabb`, `24aef13`, `2342430`, `396be5e`, `f88bf97`, `3f84717`, `d2cb52f`, `f9e5a4f`, `c06aed5`, `a878e7c`, `60603e1`, `b4955d6`, `ada0fd9`, `f470775`, `874fd0f`, `38f831e`;
   packages `M03-RND-SCHEDULER-001`, `M03-RND-INTERNAL-ACCESS-GATE-001`,
   `M03-RND-FACADE-GROUND-QUERY-001`, `M03-RND-FACADE-ENVIRONMENT-001`,
   `M03-RND-FACADE-ENTITY-001`, `M03-RND-TERRAIN-CACHE-SERVICE-001`,
@@ -38,7 +38,13 @@ Runtime и Editor используют facade; planner/scheduler тестиру
   `M03-RND-M2-BUILD-BATCH-PLANNER-001`,
   `M03-RND-WMO-PLACEMENT-RESOLVER-001`,
   `M03-RND-WMO-PLACEMENT-REGISTRY-001`,
-  `M03-RND-WMO-RENDER-BUILD-PLANNER-001`
+  `M03-RND-WMO-RENDER-BUILD-PLANNER-001`,
+  `M03-RND-WMO-RENDER-BUILD-QUEUE-001`,
+  `M03-RND-WMO-RENDER-RESOURCE-CACHE-001`,
+  `M03-RND-WMO-SCENE-RESOURCE-CACHE-001`,
+  `M03-RND-ADT-WATER-LOAD-PIPELINE-001`,
+  `M03-RND-ADT-WATER-SCENE-FINALIZER-001`,
+  `M03-RND-M2-RUNTIME-REBUILD-CLASSIFIER-001`
 - Commands: dedicated scheduler/planner/facade/focus/coordinate/manifest/shutdown
   headless verifiers; Godot cold editor parse; coordination, documentation and diff gates.
 - Results: scheduler `cases=6 iterations=20000 elapsed_ms=10.216`; planner
@@ -85,6 +91,50 @@ Runtime и Editor используют facade; planner/scheduler тестиру
   regressions and the `7/7` checkpoint dry-run passed; post-merge planner
   (`11.059ms`), registry, resolver, shutdown, facade, documentation and
   coordination gates remained green.
+  WMO render build queue passed `cases=11 iterations=100 elapsed_ms=59.874`;
+  WMO planner/registry/resolver/material/shutdown, 18 adjacent regressions and
+  the `7/7` checkpoint dry-run passed. The first post-merge smoke exposed an
+  editor class-cache dependency; a fresh no-`.godot` run verified the fix
+  (`57.835ms`), and post-fix master passed queue (`56.454ms`), planner,
+  registry, resolver, shutdown, facade, documentation and coordination gates
+  without parse diagnostics.
+  WMO render Resource cache state passed `cases=10 iterations=100
+  elapsed_ms=58.727`; direct no-`.godot` service verification passed
+  (`45.361ms`), WMO queue/planner/registry/resolver/material/shutdown and 18
+  adjacent regressions passed, and the checkpoint dry-run retained `7/7` plans.
+  Post-merge cache state (`51.949ms`), shutdown, WMO queue/resolver, facade,
+  internal-access `41`, `7/7` manifest, documentation and coordination gates
+  remained green.
+  WMO scene Resource cache state passed `cases=11 iterations=100
+  elapsed_ms=40.768`; its initial direct no-`.godot` run passed (`43.636ms`),
+  render-cache state, WMO queue/planner/registry/resolver/material/shutdown and
+  18 adjacent regressions passed, and checkpoint dry-run retained `7/7` plans.
+  Post-merge scene state (`40.113ms`), render state (`43.434ms`), shutdown,
+  WMO queue/resolver, facade, internal-access `40`, `7/7` manifest,
+  documentation and coordination gates remained green.
+  ADT water load pipeline state passed `cases=12 iterations=100
+  elapsed_ms=86.170`; its initial direct no-`.godot` run passed (`94.576ms`),
+  WMO caches/queue/planner/registry/resolver/material/shutdown and 18 adjacent
+  M2/terrain/facade/scheduler/streaming/coordinate regressions passed, and the
+  checkpoint dry-run retained `7/7` plans. Post-merge water state (`86.935ms`),
+  shutdown, renderer materials, facade, internal-access `36`, `7/7` manifest,
+  documentation and coordination gates remained green.
+  ADT water scene finalizer passed `cases=8 iterations=100 elapsed_ms=0.042`
+  after an initial `0.024ms` run; synthetic data produced one four-vertex/
+  six-index liquid surface with exact tile attachment and recursive editor owner.
+  Water pipeline, WMO/M2/terrain/facade/scheduler/streaming/coordinate, material,
+  shutdown and 32 headless contract regressions passed; checkpoint dry-run
+  retained `7/7` plans. Post-merge finalizer (`0.025ms`), water pipeline
+  (`98.398ms`), shutdown, materials, facade, internal-access `36`, `7/7`
+  manifest, documentation and coordination gates remained green.
+  M2 runtime mesh rebuild classifier passed `cases=12 iterations=100
+  elapsed_ms=64.585` after an initial `35.461ms` run; billboard flag/count,
+  invalid variants/indices, UV rotation/speed/epsilon, four-stage cap,
+  memoization, detached diagnostics and both clear sites passed. Thirty-three
+  M2/WMO/liquid/terrain/facade/scheduler/streaming/coordinate/material/shutdown
+  regressions and checkpoint dry-run `7/7` passed. Post-merge classifier
+  (`45.439ms`), materials, shutdown, M2 batch planner, facade, internal-access
+  `35`, `7/7` manifest, documentation and coordination gates remained green.
   M02 terrain-query regression
   remained green (13 pre-existing expired M00 claim warnings).
 - Fidelity comparison: all 16 historical operation limits and drain sites were
@@ -122,6 +172,34 @@ Runtime и Editor используют facade; planner/scheduler тестиру
   Lightweight WMO render groups retain mesh-before-MultiMesh order, one cursor
   increment and one budget permit per valid or null group; completion still
   cancels the job after both raw integer cursor comparisons are exhausted.
+  Pending WMO render builds retain typed root/resource/cursors, FIFO order,
+  duplicate replacement, stale-front pop, first-occurrence cancel and three
+  idempotent clear sites. Queue release never frees engine objects; the loader
+  retains validity checks, materialization, permits and Node destruction.
+  Lightweight WMO render cache paths retain the same cached/pending/missing
+  transitions, retry behavior for absent files and map-reset versus final-shutdown
+  lifetime. `ResourceLoader`, script identity and `FORMAT_VERSION` validation
+  remain loader-owned before the extracted state accepts a Resource.
+  Cached WMO scene paths retain direct negative caching for missing/oversize/
+  request-start failures, terminal missing state for load/validation failures and
+  the prior transient-reset versus final-shutdown lifetime. File-size limits,
+  `PackedScene` probe instantiation, WMOBuilder metadata validation and probe-node
+  destruction remain loader-owned before state accepts a scene.
+  ADT water requests retain FIFO order and tile-key deduplication; tile release
+  removes pending requests without cancelling active work, task completion and
+  result publication order are unchanged, and the mutex remains limited to the
+  worker/main-thread mailbox. The loader still owns ADT parsing, concurrency and
+  profile limits, stale tile/path/root rejection, `WATER_FINALIZE` permits,
+  tile subtree lifetime and `water_loaded` timing.
+  Both raw-tile and delayed cached-tile water paths now call the same stateless
+  finalizer. It invokes the unchanged `ADTBuilder.build_tile_water_scene`,
+  attaches the returned root once and applies the existing optional recursive
+  Editor ownership; tile subtree lifetime and dry-root cleanup are unchanged.
+  M2 stale-cache rebuild selection retains the same positive billboard flag/
+  vertex-count tests, referenced non-identity UV rotation, exclusive
+  `0.000001` speed threshold, four-stage cap and first-decision-per-path cache
+  lifetime. Raw loading, material refresh version, M2Builder rebuild/fallback and
+  Mesh adoption remain loader-owned.
   No new build-12340 parity claim is made; asset-backed visual/p95/p99 comparison remains pending.
 - Changed files: scene-free scheduler and verifier; streamer budget composition/
   permit delegation; scheduler module spec; world renderer/module registry/RENDER notes;
@@ -138,9 +216,18 @@ Runtime и Editor используют facade; planner/scheduler тестиру
   stateless WMO placement resolver and seven cache/identity/transform adapters,
   stateful WMO placement registry and global/tile add/release/clear adapters,
   stateless WMO render build step planner and loader cursor-adoption adapter,
+  typed WMO render build job/queue and loader enqueue/drain/cancel/clear adapters,
+  lightweight WMO render Resource/missing/request state and loader I/O/validation/
+  reset adapters,
+  cached WMO PackedScene/missing/request state and loader file-size/I/O/probe/
+  validation/reset adapters,
+  ADT water pending/task/result pipeline state and loader enqueue/start/publish/
+  drain/release/reset/shutdown/metrics adapters,
+  stateless ADT water scene finalizer and both loader build/attach adapters,
+  memoized M2 runtime mesh rebuild classifier and loader query/clear adapters,
   expanded facade/internal-access/coordinate verifiers; work-package claims and this evidence.
-- Remaining risks: queue storage length and worker concurrency/stale-result logic
-  remain streamer-owned; cancellation stops new permits but does not interrupt
+- Remaining risks: worker concurrency and stale-result validation remain
+  streamer-owned; cancellation stops new permits but does not interrupt
   in-flight work; the environment snapshot currently covers world time but not weather
   or indoor state; entity PackedScene loading is synchronous and not accepted for
   network-scale hot paths; terrain cache is entry-count bounded without Mesh-byte
@@ -151,8 +238,14 @@ Runtime и Editor используют facade; planner/scheduler тестиру
   private Azeroth data was absent for the asset-backed ADT placement probe; M2
   asset-backed visual transform recheck, grouping/build/tasks/caches/finalization
   and boundary traversal p95/p99 remain pending; path grouping is not yet
-  culling-driven spatial-cell grouping; M2 resource/queue transitions and raw
-  build-job Dictionaries remain in the loader; WMO build job/resource state and
-  asset-backed placement/portal/material evidence remain pending;
-  M03 still needs further terrain/M2/WMO/liquid service extraction
-  and dependency/performance acceptance.
+  culling-driven spatial-cell grouping; M2 rebuild classification is separated,
+  but raw loading, resource/queue transitions and mesh finalization remain in
+  the loader; raw
+  WMO ResourceLoader/FileAccess I/O, live fallback and group materialization
+  remain in the loader;
+  asset-backed WMO placement/portal/material/leak/p95/p99 evidence remains pending;
+  ADT water parsing and active worker interruption remain loader-owned;
+  materialization is separated but remains synchronous main-thread work behind
+  the existing permit, and asset-backed MH2O/MCLQ traversal/leak/p95/p99/
+  original-client evidence is pending; M03 still needs further terrain/M2/WMO/
+  liquid service extraction and dependency/performance acceptance.