docs(M03): accept M2 unique placement registry

Work-Package: M03-RND-STREAMING-PLANNER-001
Agent: sindo-main-codex
Tests: post-merge planner/facade/focus/coordinate/manifest/shutdown and repository gates pass
Fidelity: target selection formulas and renderer behavior preserved

RENDER.md

@@ -25,7 +25,8 @@ Paired run 2026-07-11 подтвердил крупный coordinate/placement g
 
 ## Основные файлы
 
-- `src/scenes/streaming/streaming_world_loader.gd` - главный runtime streamer мира.
+- `src/render/world_render_facade.gd` - стабильная граница runtime/tools для focus и metrics.
+- `src/scenes/streaming/streaming_world_loader.gd` - внутренний runtime streamer мира.
 - `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.
@@ -873,6 +874,163 @@ $exe = Join-Path $env:TEMP 'godot-4.6.1-openwc\Godot_v4.6.1-stable_win64.exe'
 - This closes a coordinate/renderer integration criterion only. It does not
   claim TrinityCore row equivalence or visual parity with the original client.
 
+## 2026-07-15 WorldRenderFacade First Seam
+
+- Runtime streaming scenes, checkpoint capture and renderer probes now submit
+  typed focus through `WorldRenderFacade`; those callers no longer call the
+  monolithic streamer's focus methods or configure its focus source directly.
+- Baseline capture reads queue/cache/activity counts through
+  `renderer_metrics_snapshot()`. The facade returns a deep copy, so diagnostics
+  cannot mutate renderer-owned state.
+- `StreamingWorldLoader` remains the internal implementation and still owns all
+  queues, tasks, caches, nodes and RIDs. The facade adds no parallel state or
+  replacement scheduler.
+- This package does not alter targets, budgets, cache versions, placement,
+  visibility, materials or animation. Environment, entity visuals and ground
+  query remain explicit follow-up facade contracts in M03.
+
+## 2026-07-15 StreamingTargetPlanner Extraction
+
+- Runtime and editor wanted/retained ADT set calculation now lives in the
+  scene-free `StreamingTargetPlanner`.
+- `StreamingTargetPolicy` preserves existing chunk/tile radii, warm/prewarm/
+  retain margins and the clamped boundary-prefetch threshold.
+- `StreamingTargetPlan` freezes its focus/wanted/retained result; the streamer
+  still owns available paths, load-queue distance sorting, loaded-tile LOD/detail
+  state, async work, caches, nodes and RIDs.
+- Asset-free fixtures cover center, edge/corner prefetch, catalog filtering,
+  clamp and editor behavior plus bounded High-like iteration timing.
+- Cache versions, quality profiles, queue priority and visible rendering rules
+  are unchanged by the extraction.
+
+## 2026-07-16 RenderBudgetScheduler Extraction
+
+- The scene-free `RenderBudgetScheduler` now owns the per-frame counters for 16
+  named renderer operation lanes. It owns no queue, task, cache, Node or RID.
+- `StreamingWorldLoader` snapshots its existing exported limits once per process
+  frame and asks for a boolean permit immediately before each historically
+  budgeted operation.
+- Chunk removals and creations intentionally share one `chunk_geometry` lane;
+  the existing removal-first drain order and combined limit are preserved.
+- Loader teardown cancels permit issuance before waiting for asynchronous work.
+  Existing worker/result staleness checks and resource cleanup remain unchanged.
+- Asset-free contracts cover exact bounds, independent/shared lanes, frame reset,
+  invalid inputs, terminal cancellation, detached diagnostics and hot-path timing.
+- Defaults, quality presets, queue order, cache versions and visible rendering
+  rules are unchanged. Asset-backed p95/p99 comparison remains required.
+
+## 2026-07-16 Streamer Internal Access Gate
+
+- `verify_renderer_internal_access.gd` derives private queue, task, cache and
+  tile-state field names from `StreamingWorldLoader` declarations and rejects
+  external member/reflection access in gameplay and Godot `EditorPlugin` package sources.
+- The gate follows the implementation inventory instead of duplicating a manual
+  list, so a newly named private renderer field is covered automatically when it
+  matches those ownership categories.
+- Scene composition may still reference the loader script and the facade's
+  implementation path; those are composition details, not mutable queue access.
+- Renderer diagnostic probes are added explicitly as their facade contracts land.
+- This is a source-only boundary check and changes no renderer behavior or fidelity.
+
+## 2026-07-16 Rendered Ground Query Facade
+
+- `WorldRenderFacade.sample_ground_height()` accepts `GodotWorldPosition` and
+  returns renderer-owned immutable `RenderedGroundSample` from already loaded
+  quality/tile-LOD render meshes, avoiding a render-to-gameplay dependency.
+- Its factories load the predeclared Script path instead of relying on a warm
+  global-class cache; a dedicated cold-start verifier covers this bootstrap path.
+- `renderer_ground_query_snapshot()` preserves the terrain probe's tile readiness,
+  queue position, mesh bounds and nearby seam-fallback diagnostics as a detached
+  Dictionary; callers receive no queue, tile-state, Mesh or Node reference.
+- `probe_render_terrain_height.gd` now uses this facade snapshot and no longer reads
+  `_tile_states`, `_tile_load_queue`, `_tile_loading_tasks` or `_available_tiles`.
+- Gameplay continues using the independently composed M02 `TerrainQuery`/
+  `AdtTerrainQuery`. Loaded render meshes are diagnostic and are not authoritative
+  movement collision.
+- The ray height, 3x3 tile search and `2/5/10/20/40`-unit nearby fallback are
+  preserved. No terrain geometry, cache, streaming or visual behavior changed.
+
+## 2026-07-16 Terrain Chunk LOD Planner Extraction
+
+- `TerrainChunkLodPlanner` now owns the pure mapping from populated parsed ADT
+  chunk indices to desired terrain LOD 0/1/2.
+- `TerrainChunkLodPolicy` snapshots the existing enabled flag, three raw chunk
+  radii and chunk size once per streaming-target application.
+- Horizontal XZ distance to the chunk center, inclusive squared thresholds,
+  sparse-index omission and historical negative-radius squaring are unchanged.
+- `StreamingWorldLoader` still owns tile/chunk state, queues, operation budgets,
+  creation/removal, Mesh/Node/RID finalization and tile-LOD fallback.
+- Cache formats, quality presets and visible behavior are unchanged. The
+  scene-free contract is formula evidence only; asset-backed p95/p99 and visual
+  acceptance remain required.
+
+## 2026-07-16 Terrain Chunk Geometry Queue Planner Extraction
+
+- `TerrainChunkGeometryQueuePlanner` now compares current and desired chunk state
+  and returns fresh chunk create/remove request arrays.
+- LOD mismatches and absent chunks retain the existing request shape; creates
+  remain sorted by horizontal distance from chunk origin to streaming focus.
+- Desired tile LOD still removes every current chunk, while sparse parsed chunk
+  records retain the existing tile-origin distance fallback.
+- `StreamingWorldLoader` still owns queue storage/drains, removal-first execution,
+  the shared `chunk_geometry` budget lane and every Mesh/Node/RID side effect.
+- Cache formats, quality profiles and visual rules are unchanged. Asset-backed
+  p95/p99 and visual acceptance remain required.
+
+## 2026-07-16 M2 Unique Placement Registry Extraction
+
+- `M2UniquePlacementRegistry` now owns positive ADT `MDDF.uniqueId` reservations
+  across streamed tiles using the existing `uid:<decimal>` keys.
+- Missing/zero/negative IDs remain untracked; duplicates inside one reservation
+  call are suppressed and another tile records one skipped key until owner release.
+- Owner release still lets the loader find eligible waiting tiles and enqueue the
+  existing detail retry path. First ownership remains tile-processing-order based.
+- `StreamingWorldLoader` still owns tile state, retry queues, grouping/build tasks,
+  M2 caches, MultiMesh/Node/Mesh/material/RID creation and all operation budgets.
+- M2/ADT cache formats, transforms, profiles and visible rules are unchanged.
+  Asset-backed cross-boundary p95/p99 and visual acceptance remain required.
+
+## 2026-07-16 World Environment Snapshot Facade
+
+- `WorldEnvironmentSnapshot` carries one immutable finite time-of-day value,
+  normalized to `[0, 24)` hours; invalid non-finite input is explicit.
+- `WorldRenderFacade.apply_environment_snapshot()` delegates the snapshot to the
+  scene-owned `WowSkyController`. The facade owns no `Environment`, sun, skybox,
+  shader global or DBC sampling state.
+- Checkpoint capture now submits its manifest time through the facade instead of
+  locating `WowSkyController` and mutating `use_system_time`, `time_speed` and
+  `fixed_time_hours` directly.
+- Applying a snapshot performs the same three fixed-clock assignments as the old
+  capture path. Light/Area/Skybox DBC lookup, interpolation, fog, sun and shader
+  behavior remain unchanged; weather and indoor environment state are follow-up work.
+
+## 2026-07-16 World Entity Presentation Facade
+
+- `EntityPresentationSnapshot` contract version 1 combines session `EntityId`,
+  typed Godot world position, visual PackedScene path, finite yaw/scale and visibility.
+- `WorldRenderFacade.present_entity()` and `remove_entity()` delegate to an explicit
+  scene-owned `WorldEntityPresenter`; both runtime scenes compose that service.
+- The presenter owns only visual subtrees. Same-path snapshots update transform/
+  visibility, changed paths replace after successful instantiation, and removal
+  detaches plus queues the owned root for deletion.
+- The local player, authoritative state, GUID mapping and asset/display selection
+  remain outside this service. Runtime emits no entity commands yet, so baseline
+  output is unchanged.
+- PackedScene loading is currently synchronous on create/replace and is a documented
+  prototype limitation, not an accepted network-scale frame-critical path.
+
+## 2026-07-16 Terrain Quality Mesh Cache Extraction
+
+- `TerrainQualityMeshCache` now owns full-quality terrain revisit Mesh references,
+  tile-key LRU order and source admission outside `StreamingWorldLoader`.
+- The historical rules are unchanged: successful restore touches newest; store
+  trims oldest to `terrain_quality_mesh_cache_limit`; zero/negative capacity keeps
+  no entries; control-splat/splat sources are never retained in this revisit cache.
+- The loader keeps three narrow adapters: restore into tile state, store after a
+  full-quality result and clear during existing world reset/shutdown.
+- ADT parsing, quality tasks/results, tile state, cache format versions, material/
+  Node/RID finalization, budgets and visible terrain behavior remain loader-owned.
+
 ## Practical Rule For Future Work
 
 If something improves quality but creates visible hitch, it is not done. Move it to bake/cache/background work, split finalization over frames, or prewarm it before the player can see it.

coordination/claims/M02-GMP-INPUT-001.md

@@ -2,6 +2,7 @@
 
 <!-- OPENWC_CLAIM:M02-GMP-INPUT-001:sindo-main-codex:2026-07-16 -->
 <!-- OPENWC_HANDOFF:READY:M02-GMP-INPUT-001:6bd2e84 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M02-GMP-INPUT-001:14dead1 -->
 
 ## Ownership
 

coordination/claims/M02-GMP-INPUT-PROFILE-335-001.md

@@ -0,0 +1,136 @@
+# M02-GMP-INPUT-PROFILE-335-001 — WoW 3.3.5a input profile
+
+<!-- OPENWC_CLAIM:M02-GMP-INPUT-PROFILE-335-001:sindo-main-codex:2026-07-17 -->
+
+## Ownership
+
+- Target: M02
+- Program: GMP/QAR
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m02-input-profile-335`
+- Lease expires UTC: 2026-07-17
+- Integrator: M02 milestone integrator
+
+## Outcome
+
+Add a profile-aware, remappable `Blizzlike335` input path whose default movement
+bindings match the extracted build-12340 binding table while preserving the
+existing `RenderSandbox` controls. Add deterministic turn intent and keyboard
+turn consumption at the server-contract default turn rate.
+
+## Non-goals
+
+- Implement jump/fall/swim, network prediction or server reconciliation.
+- Claim complete movement or camera parity from binding and turn-rate evidence.
+- Persist user keybindings or build keybinding UI.
+- Commit proprietary extracted client files.
+- Mark M02 complete or edit its checklist/Evidence.
+
+## Paths
+
+- Exclusive: `src/tests/fixtures/player_input_profile_335.json`, this claim
+- Shared/hotspots: `project.godot`, `src/domain/input/move_intent.gd`,
+  `src/gameplay/input/player_input_actions.gd`,
+  `src/gameplay/input/player_input_source.gd`,
+  `src/gameplay/movement/local_player_movement_controller.gd`,
+  `src/scenes/player/third_person_wow_controller.gd`,
+  `src/scenes/player/third_person_camera_rig.gd`, player/movement verifiers
+  and regression scene, `docs/modules/player-input.md`,
+  `docs/modules/local-player-movement.md`, `docs/modules/third-person-camera.md`
+- Generated/ignored: local `.godot`, native DLL and proprietary extracted corpus
+
+## Contracts and data
+
+- `MoveIntent` gains an immutable, clamped signed turn axis.
+- `PlayerInputSource` selects explicit sandbox or compatibility action sets at
+  construction and routes compatibility A/D to strafe while camera rotation is held.
+- `LocalPlayerMovementController` converts turn intent into a deterministic yaw
+  delta without reading engine input or owning a scene transform.
+- A sanitized JSON fixture records selected binding facts, source hashes and the
+  pinned TrinityCore 3.3.5 server-contract commit.
+
+## Dependencies
+
+- Requires: merged sandbox capability package on master `c3094c9`.
+- Blocks: final M02 integration audit and milestone closeout.
+- External state: local extracted build-12340 binding files are evidence inputs
+  only; committed tests are reproducible without them.
+
+## Verification
+
+- Fixture schema/provenance and selected default-binding regression.
+- Pure profile composition, A/D turn, Q/E strafe and camera-held A/D strafe cases.
+- Deterministic turn-rate and controller integration regression.
+- Existing M02 and repository gates remain required.
+
+## Documentation deliverables
+
+- Updated input/movement public API, profile matrix, data flow, sequence,
+  failure/recovery, fidelity provenance and source maps.
+
+## Simplicity and naming
+
+- Important names: `turn_axis`, `BLIZZLIKE_STRAFE_LEFT`, `TURN_LEFT`.
+- Simplest approach: one profile selection at composition plus one scalar intent.
+- Rejected complexity: input-context framework, command bus and persisted binding store.
+- Unavoidable complexity: compatibility A/D behavior depends on camera-rotate state.
+- Measured optimization evidence: not applicable.
+
+## Status
+
+- State: ready-for-review
+- Done: added distinct remappable profiles, signed turn intent/controller path,
+  camera-yaw synchronization, sanitized provenance fixture, regression coverage
+  and updated module specifications
+- Next: milestone integrator reviews and merges `8776a6b`
+- Blocked by:
+
+<!-- OPENWC_HANDOFF:READY:M02-GMP-INPUT-PROFILE-335-001:8776a6b -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M02-GMP-INPUT-PROFILE-335-001:eb122d5 -->
+
+## Handoff
+
+- Branch/commit: `work/sindo-main-codex/m02-input-profile-335` at `8776a6b`.
+- Outcome: `RenderSandbox` retains A/D strafe and debug E/Q/Space/Shift behavior;
+  `Blizzlike335` now samples W/S and Up/Down forward/back, Q/E strafe, A/D and
+  Left/Right turn, with A/D routed to strafe while right-mouse rotation is active.
+- Public contracts: `MoveIntent.turn_axis`; profile-selecting
+  `PlayerInputSource.new(profile_id)`; pure compatibility composition;
+  `LocalPlayerMovementController.calculate_yaw_delta_radians(...)`; camera yaw
+  synchronization after keyboard turn. Unknown input profiles fail closed to
+  `Blizzlike335`.
+- Project configuration: four additive compatibility actions; existing action
+  names and sandbox mappings remain valid. W/S also gain the original Up/Down
+  secondary defaults.
+- Verification: player input `actions=16 intent_cases=9 profiles=3 fixture=1
+  controller=1 regression_scene=3`; movement `cases=15 state_transitions=2`;
+  capabilities `profiles=3 sprint=2 flight=2 scenes=2`; terrain
+  `contract=4 interpolation=1 cache=1 failures=2`; camera
+  `state_cases=12 policy_cases=3`; presentation `appearance_cases=9
+  animation_cases=10`; coordinate boundaries `files=101`; StreamingFocus
+  `runtime_scenes=2 capture_tools=3`.
+- Renderer: unified dry-run passed project/material/dedupe/cache/manifest/
+  calibration/coordinate/server-spawn gates and planned all seven checkpoints;
+  coordinate gate reported `files=103`. Missing proprietary GLB/DBC/ADT inputs
+  produced the expected diagnostics only.
+- Repository gates: documentation `module_specs=8`; coordination
+  `fallback_claims=31`, with the same five unrelated expired M00 warnings.
+- Fidelity: local build-12340 `DefaultBindings.wtf` SHA-256
+  `35FFA0E4E2356A13A0633A848F9E57ABE7DF9D8A16C2245E15D33013AD2F56A5`
+  and `Bindings.xml` SHA-256
+  `2E01276AFB7462F1417710F13B4BF1A456341F7F28CC8AE0D6D9C7442D7F6793`
+  were rechecked and selected facts sanitized into the committed fixture.
+  TrinityCore revision `2853a621d6af91a803787a2b8a509f4ce3e0300d` supplies the
+  3.141594 rad/s player server-contract turn rate. WoWee revision
+  `626243e937fb93965fa583a6507ed5a1aa7dda4b` supports right-mouse A/D routing.
+- Fidelity limits: server turn rate and public reference routing are not direct
+  original-client timing/behavior proof. Jump, autorun and left-button
+  camera/select defaults are recorded but not implemented. This package does
+  not claim complete input, movement or camera parity.
+- Migration/cache: no persisted settings or cache schema. Future saved bindings
+  must migrate stable action names; current project users receive additive actions.
+- Documentation: updated input, movement and camera APIs, inputs/outputs, data
+  flow, sequence, ownership, failure/recovery, configuration, fidelity and source maps.
+- Recommended merge order: merge after sandbox capabilities (already on master),
+  then run the final M02 integration/evidence audit without marking the target
+  done solely from this package.

coordination/claims/M02-GMP-MOVEMENT-001.md

@@ -2,6 +2,7 @@
 
 <!-- OPENWC_CLAIM:M02-GMP-MOVEMENT-001:sindo-main-codex:2026-07-16 -->
 <!-- OPENWC_HANDOFF:READY:M02-GMP-MOVEMENT-001:435e1c9 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M02-GMP-MOVEMENT-001:5206c42 -->
 
 ## Ownership
 

coordination/claims/M02-GMP-SANDBOX-CAPABILITIES-001.md

@@ -0,0 +1,127 @@
+# M02-GMP-SANDBOX-CAPABILITIES-001 — Debug movement capability gate
+
+<!-- OPENWC_CLAIM:M02-GMP-SANDBOX-CAPABILITIES-001:sindo-main-codex:2026-07-16 -->
+
+## Ownership
+
+- Target: M02
+- Program: GMP/FND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m02-sandbox-capabilities`
+- Lease expires UTC: 2026-07-16
+- Integrator: M02 milestone integrator
+
+## Outcome
+
+Introduce an immutable local-player movement capability contract and require it
+at the movement boundary so debug sprint and free flight execute only in the
+explicit `RenderSandbox` profile and are rejected by `Blizzlike335`.
+
+## Non-goals
+
+- Claim that current movement values or `Blizzlike335` locomotion are 1:1.
+- Build a global application/profile framework before the application shell exists.
+- Remove debug Input Map actions or change their current sandbox bindings.
+- Implement jump, fall, swim, collision, server authority or reconciliation.
+- Mark M02 complete or edit its checklist/Evidence.
+
+## Paths
+
+- Exclusive: `src/gameplay/movement/player_movement_capabilities.gd`,
+  `src/tools/verify_player_movement_capabilities.gd`, this claim
+- Shared/hotspots: `src/gameplay/movement/local_player_movement_controller.gd`,
+  `src/scenes/player/third_person_wow_controller.gd`, movement/input verifiers,
+  player regression scene, `docs/modules/local-player-movement.md`,
+  `docs/modules/player-input.md`
+- Generated/ignored: local `.godot`, native DLL, generated resources and renderer corpus
+
+## Contracts and data
+
+- `PlayerMovementCapabilities` owns immutable profile ID plus explicit debug
+  sprint/flight booleans and safe named factories.
+- `LocalPlayerMovementController` requires the capability value; missing input
+  falls back to `Blizzlike335`, never sandbox.
+- Player scene maps its exported profile selection once at the composition boundary.
+- Input actions and `MoveIntent` remain unchanged; rejected debug requests have no effect.
+
+## Dependencies
+
+- Requires: merged character presentation package on master `8c71e46`.
+- Blocks: final M02 integration audit and milestone closeout.
+- External state: none; verification is asset-free.
+
+## Verification
+
+- Pure profile factory/default and immutability regression.
+- Sprint accepted in RenderSandbox and ignored in Blizzlike335.
+- Flight toggle/vertical basis accepted in RenderSandbox and rejected in Blizzlike335.
+- Real regression scene verifies both profile compositions.
+- Existing input/movement/terrain/camera/presentation and renderer gates remain required.
+- Fidelity evidence: negative proof that debug capabilities cannot affect the
+  compatibility profile; no positive movement parity claim.
+
+## Documentation deliverables
+
+- Inline public API and profile semantics on the capability/controller boundary.
+- Updated movement and input specs: API, inputs/outputs, data flow, lifecycle,
+  failure/recovery, capability matrix and source map.
+
+## Simplicity and naming
+
+- Important name: `PlayerMovementCapabilities`.
+- Simplest approach: one immutable value injected into the existing controller.
+- Rejected complexity: autoload singleton, generic feature-flag service and global profile registry.
+- Unavoidable complexity: one profile-to-capability mapping at scene composition.
+- Measured optimization evidence: not applicable.
+
+## Status
+
+- State: ready-for-review
+- Done: added immutable capability contract, gated sprint/free-flight, covered
+  pure and real-scene profiles and updated movement/input specifications
+- Next: milestone integrator reviews and merges `742c415`
+- Blocked by:
+
+<!-- OPENWC_HANDOFF:READY:M02-GMP-SANDBOX-CAPABILITIES-001:742c415 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M02-GMP-SANDBOX-CAPABILITIES-001:c3094c9 -->
+
+## Handoff
+
+- Branch/commit: `work/sindo-main-codex/m02-sandbox-capabilities` at `742c415`.
+- Outcome: debug sprint and free flight now require explicit
+  `PlayerMovementCapabilities.render_sandbox()`; `Blizzlike335`, unknown and
+  null capability inputs reject both effects.
+- Public contract: immutable profile ID plus `allows_debug_sprint` and
+  `allows_debug_free_flight`; named factories map configuration once at the
+  composition boundary. The movement controller exposes its effective profile ID.
+- Runtime composition: `ThirdPersonWowController.movement_profile_id` defaults
+  to `RenderSandbox`, preserving renderer-scene behavior. Selecting
+  `Blizzlike335` keeps ordinary movement while ignoring Shift/Space/E/Q effects.
+- Verification: capability `profiles=3 sprint=2 flight=2 scenes=2 boundary=1`,
+  movement `cases=12 state_transitions=2`, input `actions=12 intent_cases=6`,
+  terrain `contract=4 interpolation=1 cache=1 failures=2`, camera
+  `state_cases=12 policy_cases=3`, presentation
+  `appearance_cases=9 animation_cases=10`, coordinate boundaries
+  `files=101 consumers=5`, and StreamingFocus `runtime_scenes=2 capture_tools=3` passed.
+- Renderer: dry-run passed project/material/dedupe/cache/manifest/calibration/
+  coordinate/server-spawn gates and planned all seven checkpoints; the combined
+  run reported coordinate `files=103`. Missing proprietary GLB/DBC/ADT inputs
+  produced the expected diagnostics only.
+- Repository gates: documentation `module_specs=8`, coordination
+  `fallback_claims=30`; five unrelated expired M00 claim warnings remain.
+- Fidelity: this package provides negative evidence that sandbox-only debug
+  movement cannot alter the `Blizzlike335` profile. It does not prove ordinary
+  movement, bindings, flight or timing match build 12340.
+- Migration: direct `LocalPlayerMovementController.new(...)` callers that need
+  debug behavior must now pass `render_sandbox()`; omitted/null capability is
+  intentionally compatibility-safe. Existing repository scenes require no edit.
+- Cache/persistence: no schema, cache, binding or stored-profile migration.
+- Local ignored inputs: native extension DLL, UID cache and generated ADT
+  resource scripts supported renderer verification and are not committed.
+- Risks: runtime renderer scenes still default to `RenderSandbox`; the future
+  application shell must explicitly choose its profile. `Blizzlike335` currently
+  guarantees only debug exclusion, not complete movement fidelity.
+- Recommended merge order: merge after presentation (already on master), then
+  perform the final M02 integration/evidence audit before any target closeout.
+- Documentation: updated movement/input API, inputs/outputs, data flow, state,
+  sequence, ownership, failure/recovery, capabilities, verification and source maps.

coordination/claims/M02-GMP-TERRAIN-QUERY-001.md

@@ -2,6 +2,7 @@
 
 <!-- OPENWC_CLAIM:M02-GMP-TERRAIN-QUERY-001:sindo-main-codex:2026-07-16 -->
 <!-- OPENWC_HANDOFF:READY:M02-GMP-TERRAIN-QUERY-001:a45d521 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M02-GMP-TERRAIN-QUERY-001:f5bb64e -->
 
 ## Ownership
 

coordination/claims/M02-QAR-INTEGRATOR-CLOSEOUT-001.md

@@ -0,0 +1,111 @@
+# M02-QAR-INTEGRATOR-CLOSEOUT-001 — M02 milestone closeout
+
+<!-- OPENWC_CLAIM:M02-QAR-INTEGRATOR-CLOSEOUT-001:sindo-main-codex:2026-07-17 -->
+
+## Ownership
+
+- Target: M02
+- Program: QAR
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m02-integrator-closeout`
+- Lease expires UTC: 2026-07-17
+- Integrator: sindo-main-codex, continuing the user-directed milestone workflow on 2026-07-15
+
+## Outcome
+
+Audit every merged M02 package on current master, record final structural and
+fidelity evidence, close M02 and activate M03 only when all target and repository
+gates pass.
+
+## Non-goals
+
+- Change player, movement, terrain, camera, presentation or renderer behavior.
+- Claim complete WoW 3.3.5a locomotion/camera parity.
+- Implement recorded jump/fall/swim/fly, collision or timing gaps.
+- Commit proprietary assets, generated UIDs, caches or user scene changes.
+
+## Paths
+
+- Exclusive: M02/M03 target status, M02 final Evidence, all M02 claim acceptance markers
+- Shared/hotspots: `targets/README.md`, `targets/DEVELOPMENT_ROADMAP.md`, this claim
+- Generated/ignored: local Godot imports, native DLL, renderer corpus and `user://` reports
+
+## Contracts and data
+
+- Runtime APIs, Input Map actions, fixture schemas and cache formats: unchanged
+- Consumers: milestone sequence and future M03 renderer-facade packages
+- Fidelity classification distinguishes direct build-12340 binding evidence,
+  server/reference compatibility evidence and explicitly unverified gaps
+
+## Dependencies
+
+- Requires: all seven M02 READY packages integrated through master `eb122d5`
+- Blocks: M03 activation
+- External state: private original-client files are hash/provenance inputs only
+
+## Verification
+
+- Commands: all M02 input/movement/capability/terrain/camera/presentation tests,
+  coordinate/streaming boundaries, unified renderer dry-run, documentation,
+  coordination and diff hygiene
+- Fidelity evidence: build-12340 default binding hashes and selected facts;
+  pinned TrinityCore turn rate; public reference routing; explicit remaining gaps
+- Performance: no runtime change; renderer baseline remains the performance guard
+
+## Documentation deliverables
+
+- M02 final target Evidence/checklist and limitation statement
+- M02 claim integration-acceptance markers
+- Target index and roadmap transition to M03
+- Existing API/module specifications and diagrams audited without behavioral edits
+
+## Simplicity and naming
+
+- Important names introduced: none beyond the closeout work-package ID
+- Simplest approach: evidence/status-only integrator patch
+- Rejected complexity: behavioral fixes or a new closeout framework
+- Unavoidable complexity: explicit evidence classification prevents false 1:1 claims
+
+## Status
+
+- State: ready-for-review
+- Done: accepted seven M02 packages, reran post-merge gates, recorded complete
+  target Evidence, closed M02 and activated M03
+- Next: merge closeout commit `1bf5b52` before starting an M03 implementation claim
+- Blocked by:
+
+<!-- OPENWC_HANDOFF:READY:M02-QAR-INTEGRATOR-CLOSEOUT-001:1bf5b52 -->
+
+## Handoff
+
+- Commit: `1bf5b52`.
+- Branch: `work/sindo-main-codex/m02-integrator-closeout`.
+- Outcome: M02 is `DONE` with all eight structural checklist items and complete
+  classified Evidence; M03 is the only `ACTIVE` target and the target index/
+  roadmap point to renderer-facade extraction.
+- Integration audit: all seven READY implementation commits are ancestors of
+  merged master `eb122d5`; their claims now carry the corresponding
+  `OPENWC_INTEGRATION:ACCEPTED` merge markers.
+- Verification: input `16/9/3/1/3`, movement `15` cases and `2` transitions,
+  capability `3` profiles and `2` scenes, terrain `4/1/1/2`, camera `12/3`,
+  presentation `9/10/3`, coordinate boundaries `103` files and StreamingFocus
+  `2` runtime scenes/`3` capture tools all passed. Unified renderer dry-run
+  passed project/material/dedupe/shutdown gates, manifest `7/7/7`, calibration
+  maximum error `0.000015`, server-spawn renderer and seven checkpoint plans.
+- Repository gates: documentation passed with `8` module specs and `7` required
+  files. Coordination passed with one active target; `13` expired M00 claim
+  warnings are historical and unrelated to M02.
+- Fidelity: direct build-12340 binding hashes/facts are preserved in the
+  sanitized fixture. TrinityCore turn rate and WoWee mouse routing remain
+  explicitly reference-only. Translation speeds/camera values are sandbox
+  regressions, and jump/fall/swim/fly parity remains unimplemented/unverified.
+  Debug sprint/free flight is negatively proven absent from `Blizzlike335`.
+- Remaining risks: target Evidence carries exact follow-up scope for M09/M10/M12:
+  movement/camera timing, jump/fall/swim/fly, autorun/LMB semantics, active
+  collision, terrain/liquid policy, persisted bindings, server authority and
+  prediction/reconciliation. No complete `1:1` claim is made.
+- Runtime/cache/migration: no behavioral change, dependency, cache schema or
+  persisted settings migration in closeout.
+- Documentation: M02 target Evidence/checklist, seven acceptance markers,
+  target index and roadmap state updated. Existing input, movement, terrain,
+  camera and presentation API/module specs and diagrams passed the documentation gate.

coordination/claims/M02-RND-CAMERA-001.md

@@ -90,6 +90,7 @@ no-collision sandbox baseline.
 - Blocked by:
 
 <!-- OPENWC_HANDOFF:READY:M02-RND-CAMERA-001:8c1cf9b -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M02-RND-CAMERA-001:68e6f60 -->
 
 ## Handoff
 

coordination/claims/M02-RND-CHARACTER-PRESENTATION-001.md

@@ -0,0 +1,125 @@
+# M02-RND-CHARACTER-PRESENTATION-001 — Character presentation boundary
+
+<!-- OPENWC_CLAIM:M02-RND-CHARACTER-PRESENTATION-001:sindo-main-codex:2026-07-16 -->
+
+## Ownership
+
+- Target: M02
+- Program: RND/GMP
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m02-character-presentation`
+- Lease expires UTC: 2026-07-16
+- Integrator: M02 milestone integrator
+
+## Outcome
+
+Move character GLB composition, geoset/texture/outfit setup and locomotion
+animation selection from `ThirdPersonWowController` into independently
+replaceable `CharacterAppearancePresenter` and `CharacterAnimationPresenter`
+components without changing the current sandbox presentation.
+
+## Non-goals
+
+- Add new model, equipment, animation or build-12340 behavior.
+- Change character asset formats, DBC parsing, texture composition or geoset rules.
+- Add network-driven appearance/movement snapshots.
+- Change input, movement, terrain, camera or renderer streaming behavior.
+- Mark M02 complete or edit its checklist/Evidence.
+
+## Paths
+
+- Exclusive: `src/scenes/character/character_appearance_presenter.gd`,
+  `src/scenes/character/character_animation_presenter.gd`,
+  `src/tools/verify_character_presentation.gd`,
+  `docs/modules/character-presentation.md`, this claim
+- Shared/hotspots: `src/scenes/player/third_person_wow_controller.gd`, runtime
+  streaming scenes, player regression scene, `src/tools/verify_player_input.gd`,
+  `docs/modules/local-player-movement.md`, `docs/modules/README.md`
+- Reused unchanged: geoset controller, texture compositor and outfit resolver
+- Generated/ignored: local `.godot`, native DLL, generated resources and renderer corpus
+
+## Contracts and data
+
+- Appearance API loads/replaces one character root under the existing `Visual` node.
+- Animation API binds an `AnimationPlayer` from that root and accepts a typed
+  moving/stationary presentation state.
+- Scene paths, model defaults, DBC/cache/coordinate contracts remain unchanged.
+- Consumers: player scene composition and renderer viewport only.
+
+## Dependencies
+
+- Requires: merged camera package on master `68e6f60`.
+- Blocks: final M02 sandbox-profile gate and target integration audit.
+- External state: asset-free tests use a synthetic mesh and AnimationPlayer.
+
+## Verification
+
+- Dedicated appearance composition, replacement, grounding and failure regression.
+- Dedicated animation discovery, fallback, looping, blend and state regression.
+- Player source-boundary and three-scene wiring checks.
+- Existing input/movement/terrain/camera regressions, coordinate gates and renderer dry-run.
+- Fidelity evidence: preserve current sandbox model path, scale, yaw, outfit,
+  Stand/Idle and Run/Walk selection only; no original-client parity claim.
+
+## Documentation deliverables
+
+- Inline public API/export documentation for both presenters.
+- Module specification with inputs/outputs, data-flow, lifecycle/state and sequence diagrams.
+- Updated movement consumer/source map and module registry.
+
+## Simplicity and naming
+
+- Important names: `CharacterAppearancePresenter`, `CharacterAnimationPresenter`.
+- Simplest approach: two small scene components on the existing `Visual` subtree.
+- Rejected complexity: generic presenter framework, async asset scheduler and duplicated character systems.
+- Unavoidable complexity: scene-tree composition and AnimationPlayer discovery run on the main thread.
+- Measured optimization evidence: not applicable.
+
+## Status
+
+- State: ready-for-review
+- Done: extracted both presenters, migrated all runtime/regression scenes,
+  added asset-free regressions and completed required module documentation
+- Next: milestone integrator reviews and merges `97bb53f`
+- Blocked by:
+
+<!-- OPENWC_HANDOFF:READY:M02-RND-CHARACTER-PRESENTATION-001:97bb53f -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M02-RND-CHARACTER-PRESENTATION-001:8c71e46 -->
+
+## Handoff
+
+- Branch/commit: `work/sindo-main-codex/m02-character-presentation` at `97bb53f`.
+- Outcome: `CharacterAppearancePresenter` owns model/geoset/compositor/outfit
+  composition and `CharacterAnimationPresenter` owns AnimationPlayer discovery,
+  loop preparation and moving/stationary playback. The player is now only the
+  composition and horizontal-velocity adapter.
+- Changed composition: both runtime scenes and the player regression scene keep
+  `ThirdPersonPlayer/Visual`; they add `Visual/AnimationPresenter`.
+- Public contracts: appearance load/read-root/ready signal and animation
+  bind/present/read-state APIs documented in the module specification.
+- Verification: presentation `appearance_cases=9 animation_cases=10 scenes=3`,
+  input `actions=12 intent_cases=6`, movement `cases=12 state_transitions=2`,
+  terrain `contract=4 interpolation=1 cache=1 failures=2`, camera
+  `state_cases=12 policy_cases=3`, coordinate boundaries `files=99 consumers=5`,
+  and StreamingFocus `runtime_scenes=2 capture_tools=3` passed.
+- Renderer: dry-run passed project/material/dedupe/cache/manifest/calibration/
+  coordinate/server-spawn gates and planned all seven checkpoints. Missing
+  proprietary HumanMale GLB, DBC and ADT corpus produced expected diagnostics.
+- Repository gates: documentation `module_specs=8`, coordination
+  `fallback_claims=29`; five unrelated expired M00 claim warnings remain.
+- Fidelity: current model path, scale `1`, yaw `90 degrees`, class `1`, blend
+  `0.15 seconds`, starter outfit and Stand/Idle/Run/Walk selection are preserved.
+  No build-12340 appearance or animation parity claim is made.
+- Migration: repository scenes are migrated. External/custom scenes must move
+  model/class/scale/yaw exports from the player node to the scripted `Visual`
+  node and add `Visual/AnimationPresenter`. No cache/database rebuild is needed.
+- Local ignored inputs: native extension DLL, UID cache and generated ADT
+  resource scripts supported the dry-run and are not committed.
+- Risks: synchronous model load may hitch; first descendant AnimationPlayer wins;
+  moving state is a sandbox threshold boolean; complete equipment/animation
+  fidelity remains open.
+- Recommended merge order: merge this package after camera (already on master),
+  then implement the sandbox profile gate and perform the final M02 integration audit.
+- Documentation: added character-presentation API, inputs/outputs, data-flow,
+  lifecycle/state, sequence, ownership/failure and source-map sections; updated
+  the module registry and movement presentation consumer map.

coordination/claims/M03-RND-FACADE-001.md

@@ -0,0 +1,117 @@
+# M03-RND-FACADE-001 — Renderer facade first seam
+
+<!-- OPENWC_CLAIM:M03-RND-FACADE-001:sindo-main-codex:2026-07-17 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-renderer-facade`
+- Lease expires UTC: 2026-07-17
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Introduce `WorldRenderFacade` as the only runtime/tool caller surface for typed
+streaming focus updates and read-only renderer metrics, while retaining
+`StreamingWorldLoader` as the unchanged internal implementation.
+
+## Non-goals
+
+- Extract the pure target planner or budget scheduler in this package.
+- Add environment or entity-presentation commands before their contracts exist.
+- Replace the M02 `TerrainQuery` gameplay boundary in this package.
+- Change streaming radii, queues, cache formats, visuals or quality presets.
+- Mark M03 complete or edit its checklist/Evidence.
+
+## Paths
+
+- Exclusive: `src/render/world_render_facade.gd`,
+  `src/tools/verify_world_render_facade.gd`, this claim
+- Shared/hotspots: both runtime streaming scenes, three renderer capture/probe
+  tools, `src/tools/verify_streaming_focus.gd`, `docs/modules/world-renderer.md`,
+  `docs/modules/README.md`, `RENDER.md`
+- Generated/ignored: local `.godot`, native build outputs, caches and proprietary
+  renderer corpus
+
+## Contracts and data
+
+- Public API: `set_streaming_focus`, `refresh_streaming_focus`,
+  `renderer_metrics_snapshot`
+- Scene adapter: explicit `streaming_focus_source_path` owned by the facade
+- Internal implementation seam: `streaming_world_loader_path`; callers must not
+  read streamer queues or call its methods directly
+- Schema/cache/coordinate contracts: unchanged
+- Consumers: runtime scenes, capture tool and renderer probes
+
+## Dependencies
+
+- Requires: M01 `StreamingFocus` and merged M02 closeout on master `4f566b1`
+- Blocks: environment/entity/ground facade contracts and planner extraction
+- External state: none; contract verification uses a test double
+
+## Verification
+
+- Commands: dedicated facade verifier, streaming-focus regression, renderer
+  baseline manifest/dry-run, coordinate boundary and repository gates
+- Fixtures: typed focus, source Node3D and read-only metrics test double
+- Fidelity evidence: no renderer configuration, planner, queue, placement,
+  visibility, material, animation or cache behavior changes
+- Performance budget: one source position sample per process frame; target
+  recomputation remains throttled inside the existing streamer
+
+## Documentation deliverables
+
+- Inline public API docs for facade properties and methods
+- Updated world-renderer module specification
+- Updated data-flow, sequence and dependency diagrams
+- Updated source map/status and renderer notes
+
+## Simplicity and naming
+
+- Important names: `WorldRenderFacade`, `renderer_metrics_snapshot`
+- Simplest approach: one small Node adapter delegating to the existing streamer
+- Rejected complexity: service container, generic command bus, streamer rewrite
+  or duplicate queue/cache state
+- Unavoidable complexity: scene-relative source and implementation paths are
+  resolved on the main thread with explicit diagnostics
+- Measured optimization evidence: not applicable; behavior-preserving seam
+
+## Status
+
+- State: ready-for-review
+- Done: introduced the facade, migrated two runtime scenes and three renderer
+  tools, added regression coverage and updated renderer documentation
+- Next: M03 integrator reviews and merges `3d528e3`
+- Blocked by:
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-FACADE-001:3d528e3 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-FACADE-001:a100ced -->
+
+## Handoff
+
+- Commit: `3d528e3`
+- Integration: accepted in master merge `a100ced`
+- Results: `WorldRenderFacade` is the runtime/tool surface for typed focus and
+  detached metrics; the existing streamer remains the sole owner of queues,
+  caches, tasks, nodes and RIDs.
+- Verification: facade `delegation=3 runtime_scenes=2 tools=3`; streaming focus
+  `contract=1 runtime_scenes=2 capture_tools=3`; coordinate boundary
+  `files=105 native_boundary=1 oracle=1 consumers=5 classifier_cases=6`;
+  render manifest `checkpoints=7 coverage=7 caches=7`; seven-checkpoint headless
+  dry-run; coordination/documentation/diff gates passed.
+- Fidelity: no changes to renderer target calculation, budgets, queue order,
+  cache versions, placement, visibility, materials or animation. The dry-run
+  retained all seven checkpoint plans. No build-12340 parity claim is added.
+- External/local inputs: ignored native DLL and generated ADT resource scripts
+  were copied from master only to run the worktree smoke. Proprietary extracted
+  ADT and character GLB data were unavailable, producing the expected dry-run
+  degraded-data diagnostics.
+- Remaining risks: environment, entity visuals and ground query are not yet
+  facade contracts; streamer exported configuration remains transitional scene
+  composition; focus-source sampling adds one small main-thread adapter step per
+  process frame while target refresh remains streamer-throttled.
+- Documentation updated: inline facade API, `docs/modules/world-renderer.md`
+  public API/inputs/outputs/data-flow/sequence/ownership/recovery/status/source
+  map, and `RENDER.md` file map plus implementation note.

coordination/claims/M03-RND-FACADE-ENTITY-001.md

@@ -0,0 +1,130 @@
+# M03-RND-FACADE-ENTITY-001 — World entity presentation commands
+
+<!-- OPENWC_CLAIM:M03-RND-FACADE-ENTITY-001:sindo-main-codex:2026-07-18 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-facade-entity`
+- Lease expires UTC: 2026-07-18
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Add immutable, versioned world-entity presentation input and stable facade
+commands for idempotent present/update and removal, backed by a renderer-owned
+scene service with explicit entity subtree ownership.
+
+## Non-goals
+
+- Define authoritative entity/gameplay/network state or allocate/map identities.
+- Move the local player controller/presenters behind the world-entity service.
+- Implement build-12340 display IDs, equipment, animation, effects or visibility rules.
+- Add background loading, pooling, MultiMesh conversion or a generic ECS/framework.
+- Change streamer queues, caches, world assets, baseline visuals or target status.
+
+## Paths
+
+- Exclusive: `src/render/entities/entity_presentation_snapshot.gd`,
+  `src/render/entities/world_entity_presenter.gd`,
+  `src/tools/verify_world_entity_presentation.gd`,
+  `src/tests/scenes/world_entity_visual_replacement_fixture.tscn`,
+  `docs/modules/world-entity-presentation.md`, this claim
+- Shared/hotspots: `src/render/world_render_facade.gd`, both runtime streaming
+  scenes, `src/tools/verify_world_render_facade.gd`, `docs/modules/world-renderer.md`,
+  `docs/modules/README.md`, `RENDER.md`, `targets/03-renderer-facade.md`
+- Reused unchanged: `EntityId`, `GodotWorldPosition`, existing asset-free
+  character presentation model fixture
+- Generated/ignored: `.godot`, native DLL, generated resources, caches and
+  proprietary renderer corpus
+
+## Contracts and data
+
+- Contract version: `EntityPresentationSnapshot.CONTRACT_VERSION = 1`
+- Snapshot: valid session-local `EntityId`, typed Godot world position, visual
+  PackedScene path, finite yaw radians, positive finite uniform scale and visibility
+- Public API: `WorldRenderFacade.present_entity`, `remove_entity`,
+  `entity_presentation_snapshot`
+- Presenter behavior: present is idempotent by entity key; same visual updates
+  transform/visibility, changed visual replaces the owned subtree; remove is explicit
+- Schema/cache/coordinate contracts: no persisted schema or cache change
+
+## Dependencies
+
+- Requires: integrated M03 environment facade master `a85e416`, M01 identity and
+  coordinate contracts
+- Blocks: completion of the first M03 facade checklist item and later entity renderer extraction
+- External state: none; tests use a repository-owned asset-free PackedScene fixture
+
+## Verification
+
+- Commands: cold snapshot contract; presenter lifecycle/ownership regression;
+  facade delegation and runtime wiring; identity/coordinate/internal-access;
+  renderer manifest/shutdown/planner/scheduler/focus and repository gates
+- Fixtures: invalid identity/position/yaw/scale/path, spawn, idempotent update,
+  visual replacement, missing asset, removal, detached diagnostic snapshot and teardown
+- Fidelity evidence: no runtime commands are produced yet, so existing scene output
+  and seven baseline plans remain unchanged
+- Performance budget: constant-time entity lookup; synchronous resource load only
+  on first presentation/visual replacement and explicitly excluded from hot-path acceptance
+
+## Documentation deliverables
+
+- Inline public API docs: snapshot, facade commands and presenter lifecycle
+- Module specification: new world-entity-presentation specification
+- Data-flow diagram: read model through facade into owned visual subtree
+- Sequence/state/dependency diagrams: present/update/replace/remove/failure/teardown
+- Source map/status updates: module registry, world renderer and `RENDER.md`
+
+## Simplicity and naming
+
+- Important names introduced: `EntityPresentationSnapshot`, `WorldEntityPresenter`,
+  `present_entity`, `remove_entity`
+- Simplest considered solution: one immutable full visual snapshot and one
+  dictionary-owned Node3D presenter below an explicit scene service
+- Rejected complexity/abstractions: ECS, event bus, command hierarchy, factory
+  registry, pooling, async loader framework or duplicate identity registry
+- Unavoidable complexity and justification: renderer must own and deterministically
+  replace/free visual subtrees while authoritative state remains external
+- Measured optimization evidence: no optimization claim; lifecycle is asset-free tested
+
+## Status
+
+- State: ready-for-review
+- Done: immutable contract-v1 snapshot, presenter ownership lifecycle, facade
+  commands, runtime composition, asset-free regressions and module documentation
+- Next: M03 integrator reviews and merges `1807c3a`
+- Blocked by:
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-FACADE-ENTITY-001:1807c3a -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-FACADE-ENTITY-001:606770c -->
+
+## Handoff
+
+- Commit: `1807c3a`
+- Results: facade now exposes idempotent `present_entity`, explicit
+  `remove_entity` and detached diagnostics. Both runtime scenes compose a
+  `WorldEntityPresenter` that owns one replaceable visual subtree per valid
+  session `EntityId`; local player and authoritative state remain separate.
+- Verification: entity `snapshot_cases=8 lifecycle_cases=14 runtime_scenes=2`;
+  facade `delegation=9 entity_contract=6`; identities `5/5/6/5`; character
+  presentation `9/10/3/1`; coordinate boundary `files=119`; internal access
+  `43/7/9/1`; environment/ground/terrain, manifest `7/7`, shutdown, scheduler
+  (`20000` iterations), planner (`250` iterations), focus, editor parse, dry-run,
+  coordination, documentation and diff gates passed.
+- Fidelity: runtime produces no world-entity commands yet, so all seven baseline
+  plans and existing player/world output remain unchanged. No build-12340
+  display, equipment, animation, effects or visibility parity claim is added.
+- External/local inputs: ignored native DLL and generated ADT scripts supported
+  editor/dry-run only. Missing proprietary ADT/DBC/character corpus produced the
+  expected degraded diagnostics.
+- Remaining risks: PackedScene create/replace loads synchronously and is not an
+  accepted network-scale hot path; resource paths are adapter inputs rather than
+  stable content IDs; animation/equipment/effects and scale profiling remain open.
+- Documentation updated: new world-entity-presentation API/input-output/data-flow/
+  lifecycle/sequence/ownership/failure/configuration/migration/diagnostic/source-map
+  spec; world renderer, module registry and `RENDER.md` updated.
+- Integration: accepted in master merge `606770c`; post-merge entity/facade,
+  character, internal-access, manifest, shutdown, scheduler and planner gates passed.

coordination/claims/M03-RND-FACADE-ENVIRONMENT-001.md

@@ -0,0 +1,120 @@
+# M03-RND-FACADE-ENVIRONMENT-001 — Renderer environment snapshot boundary
+
+<!-- OPENWC_CLAIM:M03-RND-FACADE-ENVIRONMENT-001:sindo-main-codex:2026-07-18 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-facade-environment`
+- Lease expires UTC: 2026-07-18
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Add an immutable world-environment snapshot accepted by `WorldRenderFacade`,
+delegate it to the existing DBC sky controller, and migrate deterministic render
+checkpoint time setup away from direct sky-controller property mutation.
+
+## Non-goals
+
+- Change Light/Area/Skybox DBC selection, interpolation, fog, sun or shader rules.
+- Add weather, indoor lighting, new clock semantics or build-12340 parity claims.
+- Extract the sky service or move its Environment/Node/RID ownership.
+- Change runtime scene defaults, cache formats, streaming behavior or target status.
+
+## Paths
+
+- Exclusive: `src/render/environment/world_environment_snapshot.gd`,
+  `src/tools/verify_world_environment_snapshot.gd`, this claim
+- Shared/hotspots: `src/render/world_render_facade.gd`,
+  `src/scenes/sky/wow_sky_controller.gd`, both runtime streaming scenes,
+  `src/tools/capture_render_checkpoints.gd`,
+  `src/tools/verify_world_render_facade.gd`, `docs/modules/world-renderer.md`,
+  `docs/modules/README.md`, `RENDER.md`, `targets/03-renderer-facade.md`
+- Generated/ignored: `.godot`, native DLL, generated resources, caches and
+  proprietary renderer corpus
+
+## Contracts and data
+
+- Public API: immutable `WorldEnvironmentSnapshot` and
+  `WorldRenderFacade.apply_environment_snapshot`
+- Snapshot input: finite time-of-day hours normalized into one 24-hour day
+- Adapter: explicit `world_environment_controller_path`; facade/controller retain
+  no ownership of caller snapshot
+- Schema/cache/coordinate contracts and runtime defaults: unchanged
+- Consumer: deterministic renderer checkpoint capture; future world-state adapter
+
+## Dependencies
+
+- Requires: integrated M03 facade/ground-query master `cb103e1`
+- Blocks: completion of the facade environment checklist slice and later sky extraction
+- External state: none for contract tests; visual comparison still needs proprietary corpus
+
+## Verification
+
+- Commands: dedicated cold snapshot contract, facade delegation/wiring regression,
+  capture source-boundary regression, renderer manifest/dry-run and repository gates
+- Fixtures: normalization, non-finite rejection, missing/wrong controller,
+  exact snapshot delegation and existing runtime scene wiring
+- Fidelity evidence: preserve existing fixed-time application and all DBC-derived
+  visual logic; seven checkpoint plans remain valid
+- Performance budget: one immutable value allocation per environment update and
+  constant-time main-thread delegation
+
+## Documentation deliverables
+
+- Inline public API docs: snapshot, facade adapter and sky-controller application
+- Module specification: update existing world-renderer specification
+- Data-flow diagram: snapshot producer through facade into DBC sky controller
+- Sequence/state/dependency diagrams: application/failure path and ownership notes
+- Source map/status updates: world-renderer module, module registry if needed, `RENDER.md`
+
+## Simplicity and naming
+
+- Important names introduced: `WorldEnvironmentSnapshot`, `apply_environment_snapshot`
+- Simplest considered solution: one immutable time snapshot over the existing sky implementation
+- Rejected complexity/abstractions: generic weather graph, duplicated lighting DTO,
+  event bus, service container or alternate Environment owner
+- Unavoidable complexity and justification: facade resolves a separate scene-owned
+  sky controller because the streamer does not own outdoor environment rendering
+- Measured optimization evidence: not applicable; bounded constant-time adapter
+
+## Status
+
+- State: ready-for-review
+- Done: immutable value, facade/controller adapter, checkpoint migration,
+  regressions and renderer module documentation
+- Next: M03 integrator reviews and merges `2ee647a`
+- Blocked by:
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-FACADE-ENVIRONMENT-001:2ee647a -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-FACADE-ENVIRONMENT-001:c69abd6 -->
+
+## Handoff
+
+- Commit: `2ee647a`
+- Results: `WorldEnvironmentSnapshot` normalizes finite time into one day and
+  exposes non-finite failure explicitly. `WorldRenderFacade` delegates the
+  immutable value to the existing sky controller; checkpoint capture no longer
+  locates or mutates that controller directly.
+- Verification: snapshot `contract=5`; facade `delegation=6 ground_contract=2
+  environment_contract=7 runtime_scenes=2 tools=3`; internal access `43/7/9/1`;
+  terrain, coordinate (`files=116 consumers=5`), manifest (`7/7`), shutdown,
+  scheduler (`20000` iterations), planner (`250` iterations), focus, editor parse,
+  dry-run capture, coordination, documentation and diff gates passed.
+- Fidelity: applying a snapshot retains the previous three fixed-clock assignments
+  and leaves DBC profile/area/skybox lookup, interpolation, fog, sun, shader,
+  cache and streaming rules unchanged. Dry-run retained all seven plans and
+  reported dusk as `time=19.00`. No build-12340 parity claim is added.
+- External/local inputs: ignored native DLL and generated ADT resource scripts
+  were copied from master for parse/dry-run only. Missing proprietary ADT/DBC/
+  character data produced expected degraded diagnostics.
+- Remaining risks: the snapshot currently covers exact world time only; weather,
+  indoor state and asset-backed paired zone-transition evidence remain open.
+- Documentation updated: inline value/facade/controller API plus world-renderer
+  API/input-output/data-flow/sequence/ownership/failure/capability/source-map and
+  `RENDER.md` implementation notes.
+- Integration: accepted in master merge `c69abd6`; post-merge snapshot, facade,
+  internal-access, manifest, shutdown, scheduler, planner and focus gates passed.

coordination/claims/M03-RND-FACADE-GROUND-QUERY-001.md

@@ -0,0 +1,115 @@
+# M03-RND-FACADE-GROUND-QUERY-001 — Rendered ground query facade
+
+<!-- OPENWC_CLAIM:M03-RND-FACADE-GROUND-QUERY-001:sindo-main-codex:2026-07-18 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-facade-ground-query`
+- Lease expires UTC: 2026-07-18
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Expose typed ground-height sampling and a detached readiness diagnostic through
+`WorldRenderFacade`, using already loaded render terrain meshes, and migrate the
+terrain-height probe away from direct streamer state/queue access.
+
+## Non-goals
+
+- Replace the M02 gameplay-owned `TerrainQuery`/`AdtTerrainQuery` composition.
+- Make rendered mesh sampling authoritative for movement, collision or server state.
+- Add slopes, holes, liquid, WMO/M2 collision or async query callbacks.
+- Change terrain meshes, streaming policy, queue order, cache formats or visuals.
+- Complete environment/entity-visual facade contracts or mark M03 complete.
+
+## Paths
+
+- Exclusive: this claim
+- Shared/hotspots: `src/render/world_render_facade.gd`,
+  `src/scenes/streaming/streaming_world_loader.gd`,
+  `src/tools/probe_render_terrain_height.gd`,
+  `src/tools/verify_world_render_facade.gd`,
+  `src/tools/verify_renderer_internal_access.gd`, `docs/modules/world-renderer.md`,
+  `docs/modules/terrain-query.md`, `RENDER.md`, `targets/03-renderer-facade.md`
+- Generated/ignored: `.godot`, native DLL, generated ADT resource scripts,
+  extracted renderer corpus and probe reports
+
+## Contracts and data
+
+- Input: immutable `GodotWorldPosition` in Godot world units
+- Output: renderer-owned immutable `RenderedGroundSample` plus optional detached diagnostic Dictionary
+- Sampling source: loaded quality or tile-LOD Mesh and its live tile transform
+- M02 ADT query cache, renderer cache versions and coordinate contracts: unchanged
+
+## Dependencies
+
+- Requires: M02 terrain query contract and integrated M03 facade/access gate `53d84cc`
+- Blocks: removal of renderer diagnostic internal-access exception and later terrain service extraction
+- External state: asset-backed probe is optional; contract tests use a facade double
+
+## Verification
+
+- Commands: facade query/snapshot isolation contract, internal-access gate,
+  terrain-query regression, focus/coordinate/manifest/shutdown regressions and repository gates
+- Fixtures: available/unavailable sample, detached diagnostic, probe source migration
+- Fidelity evidence: mesh ray/nearest fallback algorithm moves unchanged from the probe
+- Performance budget: on-demand diagnostic query only; no per-frame query added
+
+## Documentation deliverables
+
+- Inline facade/streamer API docs
+- World-renderer API/data-flow/sequence/ownership/recovery/source-map updates
+- Terrain-query backend status/ownership clarification and renderer implementation note
+
+## Simplicity and naming
+
+- Important names: `sample_ground_height`, `renderer_ground_query_snapshot`
+- Simplest approach: one typed facade query over one existing diagnostic read model
+- Rejected complexity: duplicate ADT cache, physics service, callback bus, query node,
+  generic spatial interface or new dependency
+- Unavoidable complexity: triangle-mesh ray query retains the existing bounded
+  nearby fallback for seam/edge diagnostic behavior
+
+## Status
+
+- State: ready-for-review
+- Done: added renderer-owned typed sample, facade query/snapshot, migrated terrain
+  probe, expanded internal-access/coordinate gates and updated module docs
+- Next: M03 integrator reviews and merges `b697a89` plus cold-start fix `9408d88`
+- Blocked by:
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-FACADE-GROUND-QUERY-001:9408d88 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-FACADE-GROUND-QUERY-001:d6e5b53 -->
+
+## Handoff
+
+- Commits: implementation `b697a89`; cold-start fix `9408d88`
+- Results: `WorldRenderFacade` delegates loaded-mesh ground sampling and returns
+  renderer-owned `RenderedGroundSample`; detached diagnostic snapshots preserve
+  the probe report while hiding queue/tile/Mesh/Node references. Gameplay remains
+  on the independent M02 `TerrainQuery` composition.
+- Verification: facade `delegation=5 ground_contract=2 runtime_scenes=2 tools=3`;
+  cold rendered-ground value `contract=3` from an empty Godot class cache;
+  internal access `private_symbols=43 gameplay=7 editor_sources=9 renderer_tools=1`;
+  terrain query contracts passed; coordinate boundary `files=113 consumers=5`;
+  renderer manifest `7/7`; shutdown ownership, scheduler/planner, coordination,
+  documentation and diff gates passed.
+- Fidelity: the probe's 5000-unit ray height, 3x3 tile search, highest-hit choice,
+  readiness fields and `2/5/10/20/40` nearby fallback moved unchanged. No terrain
+  geometry, streaming, cache, material, placement or visual rule changed. No
+  build-12340 parity claim is added.
+- External/local inputs: ignored native DLL and generated ADT resource scripts
+  were copied from master only for editor/streamer parse and then removed.
+  Proprietary extracted world data was unavailable, producing expected degraded diagnostics.
+- Remaining risks: triangle-mesh generation is on-demand/main-thread and diagnostic;
+  it is unsuitable for per-physics-frame gameplay; exact asset-backed probe output
+  still depends on local corpus readiness; environment/entity facade contracts remain.
+- Documentation: inline facade/loader/value API; world-renderer API/data-flow/
+  sequence/ownership/recovery/capability/source map; terrain-query authority
+  clarification and renderer implementation notes updated.
+- Integration: implementation accepted in master merge `80cb084`; cold-start fix
+  accepted in merge `d6e5b53`. Post-merge cold/facade/access/terrain/coordinate/
+  manifest/shutdown/scheduler/planner/focus and repository gates passed.

coordination/claims/M03-RND-INTERNAL-ACCESS-GATE-001.md

@@ -0,0 +1,106 @@
+# M03-RND-INTERNAL-ACCESS-GATE-001 — Streamer internal access gate
+
+<!-- OPENWC_CLAIM:M03-RND-INTERNAL-ACCESS-GATE-001:sindo-main-codex:2026-07-18 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-streamer-internal-access-gate`
+- Lease expires UTC: 2026-07-18
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Add an automated repository boundary gate proving gameplay code and Godot
+`EditorPlugin` implementations do not access `StreamingWorldLoader` private
+queue, task, cache or tile-state fields.
+
+## Non-goals
+
+- Change renderer behavior, queues, jobs, cache formats or facade contracts.
+- Ban scene composition references to the loader script or facade adapter path.
+- Migrate renderer-only diagnostic probes that inspect internal readiness/terrain;
+  those require the later metrics/ground-query facade contract.
+- Mark M03 complete.
+
+## Paths
+
+- Exclusive: `src/tools/verify_renderer_internal_access.gd`, this claim
+- Shared/hotspots: `docs/modules/world-renderer.md`, `RENDER.md`,
+  `targets/03-renderer-facade.md`
+- Read-only scan scope: `src/gameplay/**/*.gd`, `src/editor/**/*.gd`, Godot
+  `EditorPlugin` package scripts under `src/**/*.gd` and `addons/**/*.gd`, and
+  the streamer field declarations
+
+## Contracts and data
+
+- Input: repository GDScript source and actual private streamer declarations
+- Output: deterministic pass/fail diagnostics with consumer path and symbol
+- Runtime, scene, cache, coordinate and asset contracts: unchanged
+
+## Dependencies
+
+- Requires: integrated facade and scheduler master `a023d76`
+- Blocks: safe service extraction and M03 dependency regression acceptance
+- External state: none
+
+## Verification
+
+- Commands: dedicated internal-access gate, facade regression, coordination,
+  documentation and diff gates
+- Fixtures: gameplay source discovery, EditorPlugin discovery and synthetic
+  forbidden symbol detection
+- Fidelity evidence: source-only enforcement; no runtime or visual code changes
+- Performance budget: one bounded repository source scan in a headless test process
+
+## Documentation deliverables
+
+- World-renderer boundary/verification/known-gap/source-map updates
+- Renderer implementation note documenting diagnostic-tool exception
+- No new module spec because this package adds a verifier to the existing renderer module
+
+## Simplicity and naming
+
+- Important name: `verify_renderer_internal_access.gd`
+- Simplest approach: derive forbidden fields from the current streamer instead
+  of maintaining a second hand-written queue list
+- Rejected complexity: language plugin, custom linter framework or runtime proxy
+- Unavoidable complexity: recursive source discovery expands each actual
+  `EditorPlugin` root to its package scripts while excluding reference mirrors
+
+## Status
+
+- State: ready-for-review
+- Done: derived 43 private renderer symbols, scanned seven gameplay and nine
+  EditorPlugin-package sources, added synthetic positive/negative fixtures and docs
+- Next: M03 integrator reviews and merges `b58bf2c`
+- Blocked by:
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-INTERNAL-ACCESS-GATE-001:b58bf2c -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-INTERNAL-ACCESS-GATE-001:7e35de7 -->
+
+## Handoff
+
+- Commit: `b58bf2c`
+- Results: repository gate derives private queue/task/cache/state declarations
+  from the streamer and rejects external member/reflection access in gameplay and
+  EditorPlugin package sources. Current scope passes with `43/7/9` inventory counts.
+- Verification: internal access, facade and budget scheduler headless contracts;
+  Godot editor scan with local ignored dependencies; coordination, documentation
+  and diff gates passed.
+- Fidelity: source-only enforcement changes no runtime configuration, queue order,
+  cache version, placement, material, animation or visibility behavior. No
+  build-12340 parity claim is added.
+- External/local inputs: ignored native DLL and two generated ADT resource scripts
+  were copied from master only for facade/editor smoke and then removed. Proprietary
+  extracted world data was unavailable, producing expected degraded-data diagnostics.
+- Remaining risks: renderer diagnostic terrain probe remains an explicit exception;
+  whitespace-obfuscated dynamic reflection is outside the lightweight source gate;
+  future non-EditorPlugin authoring code is already prohibited by repository policy.
+- Documentation: world-renderer boundary/verification/capability/known-gap/source
+  map and `RENDER.md` implementation note updated; no new module was introduced.
+- Integration: accepted in master merge `7e35de7`; post-merge access gate
+  `private_symbols=43 gameplay=7 editor_sources=9`, facade/scheduler/planner and
+  repository gates passed.

coordination/claims/M03-RND-M2-UNIQUE-REGISTRY-001.md

@@ -0,0 +1,105 @@
+# M03-RND-M2-UNIQUE-REGISTRY-001 — M2 unique placement registry
+
+<!-- OPENWC_CLAIM:M03-RND-M2-UNIQUE-REGISTRY-001:sindo-main-codex:2026-07-19 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-m2-unique-registry`
+- Lease expires UTC: 2026-07-19
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Extract cross-tile positive `MDDF.uniqueId` reservation ownership from the
+streamer into a scene-free `M2UniquePlacementRegistry`.
+
+## Non-goals
+
+- Move tile state, candidate requeue, group/build tasks or result queues.
+- Move MultiMesh/Node/Mesh/material creation, animation or resource loading.
+- Change unique-key format, first-owner semantics or unkeyed placement behavior.
+- Change placement transforms, detail radius, cache versions or quality profiles.
+- Add dependencies or mark the broad M2 service complete.
+
+## Paths
+
+- Exclusive: `src/render/m2/m2_unique_placement_registry.gd`,
+  `src/tools/verify_m2_unique_placement_registry.gd`,
+  `docs/modules/m2-unique-placement-registry.md`, this claim
+- Shared/hotspots: `src/scenes/streaming/streaming_world_loader.gd`,
+  `src/tools/verify_m2_unique_dedupe.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
+
+- Input: tile key and raw ADT M2 placement dictionaries
+- Reserve output: fresh filtered placements, owned unique keys and skipped keys
+- Release input/output: tile key plus claimed keys; only current owner releases
+- Positive IDs map to `uid:<decimal>`; zero/negative/missing IDs remain untracked
+- Registry is session-memory only and clears on renderer world reset
+- Queue/cache/schema/coordinate versions: unchanged
+
+## Dependencies
+
+- Requires: current master `57ae1b8`
+- Blocks: broader M2 service extraction and dependency/performance acceptance
+- External state: none; tests use synthetic placement dictionaries
+
+## Verification
+
+- Commands: dedicated unkeyed/duplicate/cross-tile/release/clear/detached-
+  diagnostic and bounded timing verifier; loader source boundary; M2 unique-id
+  smoke plus facade/terrain/internal-access/manifest/shutdown/scheduler gates
+- Fidelity evidence: exact positive-ID key format and first-owner/retry behavior
+- Performance budget: dictionary membership over placement count; no Node,
+  Resource, RID, task, file or persistent cache
+
+## Documentation deliverables
+
+- Inline registry API documentation
+- New module spec with inputs/outputs, data-flow, lifecycle, sequence, ownership,
+  failure, recovery, performance and source map
+- World renderer/module registry/`RENDER.md` updates
+
+## Simplicity and naming
+
+- Important name: `M2UniquePlacementRegistry`
+- Simplest solution: one private key-to-owner dictionary and explicit operations
+- Rejected complexity: generic identity registry, signals, callbacks, Resources,
+  locks or ownership graph
+- Unavoidable complexity: raw placement dictionaries remain at ADT adapter boundary
+- Measured optimization evidence: bounded synthetic reserve/release verifier
+
+## Status
+
+- State: accepted
+- Done: stateful registry, loader adapters, migrated smoke, regressions and docs
+- Next: asset-backed boundary traversal and further M2-service extraction later in M03
+- Blocked by:
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-M2-UNIQUE-REGISTRY-001:acb3a80 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-M2-UNIQUE-REGISTRY-001:2342430 -->
+
+## Handoff
+
+- Commit: `acb3a80` (`refactor(M03): extract M2 unique placement registry`)
+- Results: dedicated contract PASS (`cases=10`, `iterations=100`, `35.688 ms`);
+  historical `uid:11785` smoke PASS; terrain/facade/internal-access/manifest/
+  shutdown/scheduler/streaming/focus/terrain-query/coordinate regressions PASS;
+  internal inventory remains `42`; editor parse and documentation/coordination/
+  diff gates PASS; checkpoint dry-run planned `7/7`
+- Remaining risks: private Azeroth corpus was absent, so the asset-backed ADT
+  placement probe could not open the map and is not counted as passed evidence;
+  first ownership remains processing-order based; M2 grouping/build/tasks/caches/
+  finalization and asset-backed p95/p99 remain pending
+- Documentation updated: `m2-unique-placement-registry.md`, module registry,
+  `world-renderer.md`, `RENDER.md`, inline API documentation and data-flow,
+  lifecycle and sequence diagrams
+- Integration: accepted in master merge `2342430`; post-merge registry, legacy
+  smoke, internal-access, facade and manifest gates passed

coordination/claims/M03-RND-SCHEDULER-001.md

@@ -0,0 +1,116 @@
+# M03-RND-SCHEDULER-001 — Bounded render budget scheduler
+
+<!-- OPENWC_CLAIM:M03-RND-SCHEDULER-001:sindo-main-codex:2026-07-18 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-render-budget-scheduler`
+- Lease expires UTC: 2026-07-18
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Extract the streamer's per-frame main-thread operation quotas into a scene-free
+`RenderBudgetScheduler`, preserving existing queue priority and quota values and
+stopping permit issuance after renderer teardown cancellation.
+
+## Non-goals
+
+- Move queue, worker-task, cache, Node, Resource or RID ownership out of the streamer.
+- Change queue ordering, concurrency limits, exported defaults or visual behavior.
+- Add a generic job framework, priority graph, time-based adaptive budgeting or dependency.
+- Change cache formats, renderer profiles or target milestone status.
+
+## Paths
+
+- Exclusive: `src/render/streaming/render_budget_scheduler.gd`,
+  `src/tools/verify_render_budget_scheduler.gd`,
+  `docs/modules/render-budget-scheduler.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 cache resources and
+  proprietary renderer corpus
+
+## Contracts and data
+
+- Input: immutable per-frame map from documented operation lane IDs to
+  non-negative operation limits
+- Output: boolean permits and remaining/consumed diagnostic snapshots
+- Lifecycle: `begin_frame` resets permits; `cancel` permanently rejects permits
+  for the current scheduler instance
+- Queue contents, ordering, task concurrency and schema/cache versions: unchanged
+- Consumer: `StreamingWorldLoader` main-thread queue/finalize drains
+
+## Dependencies
+
+- Requires: integrated M03 facade and streaming planner on master `650d584`
+- Blocks: renderer performance regression gate and per-service extraction
+- External state: none; tests use synthetic lane limits and no world assets
+
+## Verification
+
+- Commands: dedicated scheduler verifier, facade/planner/focus/coordinate
+  regressions, renderer manifest/dry-run and repository gates
+- Fixtures: shared lane priority, independent lanes, zero/negative limits,
+  frame reset, unknown lane and cancellation
+- Fidelity evidence: operation defaults and loop order are captured before
+  migration; all seven renderer checkpoint plans remain valid
+- Performance budget: permit checks are constant-time dictionary operations and
+  create no Node, Resource, worker task, cache entry or RID
+
+## Documentation deliverables
+
+- Inline API docs for scheduler lifecycle, permits and diagnostics
+- New module specification with input/output table, data-flow, sequence and
+  lifecycle diagrams
+- Updated world-renderer flow/ownership/source map, module registry and renderer notes
+
+## Simplicity and naming
+
+- Important name: `RenderBudgetScheduler`
+- Simplest approach: one small main-thread service with named quota lanes
+- Rejected complexity: generic job graph, callbacks, queue ownership, adaptive
+  timing controller, service container or third-party dependency
+- Unavoidable complexity: chunk removal and creation intentionally share one
+  lane so removal retains priority while consuming the same historical budget
+- Measured optimization evidence: no optimization claim; exact bounded extraction
+
+## Status
+
+- State: ready-for-review
+- Done: extracted all 16 historical operation quotas, migrated ordered drains,
+  added terminal teardown cancellation, asset-free verification and module docs
+- Next: M03 integrator reviews and merges `e52f703`
+- Blocked by:
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-SCHEDULER-001:e52f703 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-SCHEDULER-001:7ece2ab -->
+
+## Handoff
+
+- Commit: `e52f703`
+- Results: `RenderBudgetScheduler` owns only per-frame lane counters and terminal
+  cancellation; `StreamingWorldLoader` retains queue order, task/cache/node/RID
+  ownership and operation execution. Chunk removal/create share one historical budget.
+- Verification: scheduler `cases=6 iterations=20000 elapsed_ms=7.495`; planner
+  `cases=5 average_ms=1.879`; facade/focus contracts passed; coordinate boundary
+  `files=111 consumers=6`; renderer manifest `checkpoints=7 coverage=7 caches=7`;
+  shutdown ownership, documentation, coordination and diff gates passed.
+- Fidelity: exported defaults, quality presets, queue order, operation sites,
+  cache versions and visible rendering rules are unchanged. Seven checkpoint
+  plans remain valid. No build-12340 parity claim is added.
+- External/local inputs: ignored native DLL and two generated ADT resource scripts
+  were copied from master only for the worktree parse/smoke and then removed.
+  Proprietary extracted ADT data was unavailable, producing expected degraded-data diagnostics.
+- Remaining risks: queue storage length and worker concurrency remain streamer-owned;
+  cancellation stops permit issuance but does not interrupt in-flight work; exact
+  p95/p99 impact still requires an asset-backed baseline.
+- Documentation: new scheduler module spec with API, input/output, data-flow,
+  sequence, lifecycle, ownership, cancellation, performance and source-map sections;
+  world renderer, module registry and renderer implementation notes updated.
+- Integration: accepted in master merge `7ece2ab`; post-merge scheduler timing
+  `cases=6 iterations=20000 elapsed_ms=10.216`, all listed regressions and gates passed.

coordination/claims/M03-RND-STREAMING-PLANNER-001.md

@@ -0,0 +1,120 @@
+# M03-RND-STREAMING-PLANNER-001 — Pure streaming target planner
+
+<!-- OPENWC_CLAIM:M03-RND-STREAMING-PLANNER-001:sindo-main-codex:2026-07-17 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-streaming-target-planner`
+- Lease expires UTC: 2026-07-17
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Extract runtime/editor ADT wanted/retained-set calculation and boundary prefetch
+selection from `StreamingWorldLoader` into a scene-free, deterministic
+`StreamingTargetPlanner` with typed focus input and asset-free contract tests.
+
+## Non-goals
+
+- Change load/retain radii, boundary thresholds, queue priority or LOD policy.
+- Move queue mutation, async jobs, cache ownership or GPU finalization.
+- Extract `RenderBudgetScheduler` or asset services in this package.
+- Change cache formats, renderer profiles or target milestone status.
+
+## Paths
+
+- Exclusive: `src/render/streaming/streaming_target_planner.gd`,
+  `src/render/streaming/streaming_target_policy.gd`,
+  `src/render/streaming/streaming_target_plan.gd`,
+  `src/tools/verify_streaming_target_planner.gd`,
+  `docs/modules/streaming-target-planner.md`, this claim
+- Shared/hotspots: `src/scenes/streaming/streaming_world_loader.gd`,
+  `src/tools/verify_coordinate_conversion_boundaries.gd`,
+  `docs/modules/world-renderer.md`, `docs/modules/coordinate-mapping.md`,
+  `docs/modules/README.md`, `RENDER.md`
+- Generated/ignored: `.godot`, native DLL, generated cache resources and
+  proprietary renderer corpus
+
+## Contracts and data
+
+- Input: immutable `GodotWorldPosition`, available-tile key set and immutable
+  `StreamingTargetPolicy`
+- Output: immutable `StreamingTargetPlan` with focus tile plus detached
+  wanted/retained tile-key sets
+- Tile-key representation remains the streamer's existing `<x>_<y>` internal key
+- Schema/cache/coordinate versions: unchanged
+- Consumers: `StreamingWorldLoader` runtime/editor refresh paths
+
+## Dependencies
+
+- Requires: M01 typed coordinates/focus and integrated facade package `a100ced`
+- Blocks: budget scheduler extraction and planner performance regression gate
+- External state: none; tests use synthetic tile catalogs
+
+## Verification
+
+- Commands: dedicated planner verifier, facade/focus/coordinate regressions,
+  renderer manifest/dry-run and repository gates
+- Fixtures: center, edge, corner, unavailable-tile, clamped-radius and editor cases
+- Fidelity evidence: expected tile sets are captured from current formulas; full
+  renderer dry-run retains all seven checkpoint plans
+- Performance budget: planner work remains bounded by square radii and creates no
+  Node, Resource, task, cache or RID
+
+## Documentation deliverables
+
+- Inline API docs for planner/policy/plan
+- New module specification with input/output table and data-flow diagram
+- Updated world-renderer data-flow/sequence/ownership/source map
+- Updated module registry and renderer notes
+
+## Simplicity and naming
+
+- Important names: `StreamingTargetPlanner`, `StreamingTargetPolicy`,
+  `StreamingTargetPlan`
+- Simplest approach: one pure calculator plus two immutable value objects
+- Rejected complexity: generic graph planner, priority framework, service
+  container, job ownership or duplicate available-tile catalog
+- Unavoidable complexity: boundary-prefetch cross product must preserve corner
+  behavior and existing string tile keys
+- Measured optimization evidence: no new optimization; exact extraction
+
+## Status
+
+- State: ready-for-review
+- Done: extracted immutable policy/plan and pure planner, migrated runtime/editor
+  target refresh, added behavior/dependency/performance coverage and module docs
+- Next: integrated in master; next M03 package extracts the budget scheduler
+- Blocked by:
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-STREAMING-PLANNER-001:ad8fc41 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-STREAMING-PLANNER-001:643850c -->
+
+## Handoff
+
+- Commit: `e887c3b`; cold-start fix `ad8fc41`
+- Integration: accepted in master merges `d0f74f8` and `643850c`
+- Results: runtime/editor wanted and retained ADT sets plus boundary-prefetch
+  centers are calculated by scene-free `StreamingTargetPlanner`; streamer keeps
+  queue ordering, LOD/detail state, jobs, caches, nodes and RIDs.
+- Verification: planner `cases=5 iterations=250 average_ms=1.765`; facade
+  `delegation=3 runtime_scenes=2 tools=3`; focus `contract=1 runtime_scenes=2
+  capture_tools=3`; coordinate boundary `files=109 consumers=6`; renderer
+  manifest `checkpoints=7 coverage=7 caches=7`; shutdown ownership passed;
+  documentation, coordination and diff gates passed.
+- Fidelity: center/corner/catalog/clamp/editor fixtures preserve the extracted
+  formulas; seven-checkpoint dry-run retained all plans. No radius, threshold,
+  load priority, cache version, placement, material, animation or visibility
+  rule changed. No build-12340 parity claim is added.
+- External/local inputs: ignored native DLL and generated ADT resource scripts
+  were copied from master for worktree smoke only. Proprietary ADT and character
+  assets were unavailable, so the dry-run emitted expected degraded-data diagnostics.
+- Remaining risks: exact p95/p99 impact still needs an asset-backed baseline;
+  pathological custom radii are not benchmarked; tile-key strings remain the
+  existing internal catalog representation; queue/LOD application remains monolithic.
+- Documentation updated: new planner module spec with API/input/output/data-flow/
+  sequence/ownership/recovery/performance/source-map sections; world renderer,
+  coordinate mapping, module registry and renderer implementation notes updated.

coordination/claims/M03-RND-TERRAIN-CACHE-SERVICE-001.md

@@ -0,0 +1,118 @@
+# M03-RND-TERRAIN-CACHE-SERVICE-001 — Terrain quality mesh cache service
+
+<!-- OPENWC_CLAIM:M03-RND-TERRAIN-CACHE-SERVICE-001:sindo-main-codex:2026-07-18 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-terrain-quality-cache`
+- Lease expires UTC: 2026-07-18
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Extract the full-quality terrain revisit Mesh cache, its LRU ownership and
+source-admission rules from `StreamingWorldLoader` into a small scene-free
+`TerrainQualityMeshCache`, preserving all call sites and observable behavior.
+
+## Non-goals
+
+- Move ADT parsing, tile state, quality-upgrade tasks/results or SceneTree/RID finalization.
+- Change cache capacity defaults, quality profiles, source priority or cache formats.
+- Cache control-splat/splat meshes that the current loader deliberately rejects.
+- Extract chunk LOD, terrain material building, ground query or other asset services.
+- Add dependencies, persistence, background work or mark the terrain service complete.
+
+## Paths
+
+- Exclusive: `src/render/terrain/terrain_quality_mesh_cache.gd`,
+  `src/tools/verify_terrain_quality_mesh_cache.gd`,
+  `docs/modules/terrain-quality-mesh-cache.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 resources, caches and
+  proprietary renderer corpus
+
+## Contracts and data
+
+- Public service API: `store`, `restore`, `clear`, detached `diagnostic_snapshot`
+- Entry: tile key, retained Mesh reference and source string
+- Admission: non-empty key, non-null Mesh, source other than
+  `control_splat_cache`, `splat_cache` or `splat`
+- LRU: successful restore touches newest; store touches then trims oldest to
+  `max(0, capacity)`; invalid restored records are removed
+- Persistence/cache format: none; session-memory ownership only
+
+## Dependencies
+
+- Requires: integrated facade contracts master `61bad09`
+- Blocks: later terrain service extraction and cache/finalization acceptance audit
+- External state: none; tests use synthetic ArrayMesh references
+
+## Verification
+
+- Commands: dedicated cache contract/LRU/ownership regression; streamer source
+  boundary; shutdown/facade/internal-access/manifest/planner/scheduler and repository gates
+- Fixtures: admission/rejection, replacement, LRU touch/eviction, zero/negative
+  capacity, invalid record cleanup, clear and detached diagnostics
+- Fidelity evidence: same sources/capacity/call sites; all seven baseline plans unchanged
+- Performance budget: dictionary lookup plus bounded single-entry LRU operations;
+  no Node, task, file, cache serialization or RID creation
+
+## Documentation deliverables
+
+- Inline public API docs: store/restore/clear/diagnostics and ownership
+- Module specification: new terrain quality mesh cache specification
+- Data-flow diagram: upgrade result through cache to revisit state
+- Sequence/state/dependency diagrams: store/restore/evict/reset and failure paths
+- Source map/status updates: module registry, world renderer and `RENDER.md`
+
+## Simplicity and naming
+
+- Important names introduced: `TerrainQualityMeshCache`
+- Simplest considered solution: one RefCounted with dictionary plus ordered tile-key array
+- Rejected complexity/abstractions: generic cache framework, weak references,
+  callbacks, Resource cache integration, background eviction or persistence
+- Unavoidable complexity and justification: Mesh references must survive unloaded
+  tile state while LRU keeps revisit memory bounded
+- Measured optimization evidence: exact ownership extraction, no optimization claim
+
+## Status
+
+- State: ready-for-review
+- Done: scene-free cache ownership/LRU extraction, loader adapter migration,
+  contract regression and module documentation
+- Next: M03 integrator reviews and merges `97480e0`
+- Blocked by:
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-TERRAIN-CACHE-SERVICE-001:97480e0 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-TERRAIN-CACHE-SERVICE-001:630a0c1 -->
+
+## Handoff
+
+- Commit: `97480e0`
+- Results: `TerrainQualityMeshCache` now owns retained full-quality Mesh
+  references, source admission and oldest-to-newest LRU. The loader retains only
+  restore-to-state, store-after-upgrade and clear lifecycle adapters.
+- Verification: cache `contract_cases=15 loader_calls=3`; facade/entity/ground/
+  terrain regressions; internal access `private_symbols=42 gameplay=7
+  editor_sources=9 renderer_tools=1`; manifest `7/7`; shutdown; scheduler
+  `20000` iterations; planner `250` iterations; focus; editor parse; dry-run;
+  coordination, documentation and diff gates passed.
+- Fidelity: `baked_full` revisit retention, three excluded splat sources, LRU
+  touch/trim, profile capacities and all call sites remain unchanged. All seven
+  checkpoint plans remain valid. No visible or build-12340 parity claim is added.
+- External/local inputs: ignored native DLL and generated ADT scripts supported
+  parse/dry-run only; missing proprietary ADT/DBC/character data produced expected diagnostics.
+- Remaining risks: entry count does not measure Mesh bytes; ordered-array touch
+  remains linear; asset-backed revisit flash, memory and p95/p99 evidence remain pending;
+  terrain build/tasks/state/finalization are still monolithic.
+- Documentation updated: new terrain cache API/input-output/data-flow/lifecycle/
+  sequence/ownership/failure/configuration/migration/diagnostic/source-map spec;
+  world renderer, registry and `RENDER.md` updated.
+- Integration: accepted in master merge `630a0c1`; post-merge cache, facade,
+  internal-access, manifest, shutdown, scheduler and planner gates passed.

coordination/claims/M03-RND-TERRAIN-CHUNK-QUEUE-001.md

@@ -0,0 +1,104 @@
+# M03-RND-TERRAIN-CHUNK-QUEUE-001 — Pure terrain chunk geometry queue planner
+
+<!-- OPENWC_CLAIM:M03-RND-TERRAIN-CHUNK-QUEUE-001:sindo-main-codex:2026-07-19 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-terrain-chunk-queue`
+- Lease expires UTC: 2026-07-19
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Extract chunk-geometry create/remove desired-operation calculation from the
+streamer into a scene-free `TerrainChunkGeometryQueuePlanner`.
+
+## Non-goals
+
+- Move queue storage/drains, render budgets, tile-LOD queues or async tasks.
+- Move chunk Mesh/Node/RID creation/removal or terrain state ownership.
+- Change removal-first execution, nearest-first create order or LOD selection.
+- Change coordinate conversions, radii, cache formats or quality profiles.
+- Add dependencies or mark the broad terrain service checklist complete.
+
+## Paths
+
+- Exclusive: `src/render/terrain/terrain_chunk_geometry_queue_planner.gd`,
+  `src/tools/verify_terrain_chunk_geometry_queue_planner.gd`,
+  `docs/modules/terrain-chunk-geometry-queue-planner.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 resources, caches and
+  proprietary renderer corpus
+
+## Contracts and data
+
+- Input: loader-owned tile-state read model plus immutable `GodotWorldPosition`
+- Output: fresh create/remove request arrays; planner retains no queue state
+- Removal: current chunks absent from desired state, or all current chunks while
+  tile LOD is desired
+- Creation: missing or LOD-mismatched chunks, sorted by origin XZ distance
+- Queue/cache/schema/coordinate versions: unchanged
+
+## Dependencies
+
+- Requires: integrated terrain LOD planner master `b568768`
+- Blocks: broader terrain service extraction and dependency/performance acceptance
+- External state: none; tests use synthetic tile/chunk dictionaries
+
+## Verification
+
+- Commands: dedicated removal/create/mismatch/tile-fallback/sparse/order and
+  bounded timing verifier; loader source boundary; facade/cache/LOD/internal-access/
+  manifest/shutdown/scheduler/streaming planner and repository gates
+- Fidelity evidence: extracted branch/order/distance rules and loader drain order
+- Performance budget: bounded linear planning plus existing create sort; no engine
+  resource, task, cache or persistent allocation framework
+
+## Documentation deliverables
+
+- Inline planner API documentation
+- New module spec with inputs/outputs, data-flow, lifecycle, sequence, ownership,
+  failure, performance and source map
+- World renderer/module registry/`RENDER.md` updates
+
+## Simplicity and naming
+
+- Important name: `TerrainChunkGeometryQueuePlanner`
+- Simplest solution: one stateless planner returning two fresh arrays
+- Rejected complexity: generic operation graph, queue class, callback strategy,
+  spatial index or ownership transfer
+- Unavoidable complexity: raw dictionaries remain at the loader/ADT adapter boundary
+- Measured optimization evidence: bounded synthetic multi-tile verifier
+
+## Status
+
+- State: accepted
+- Done: pure planner, loader queue adoption, semantic/timing regressions and docs
+- Next: asset-backed performance acceptance and further terrain-service extraction later in M03
+- Blocked by:
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-TERRAIN-CHUNK-QUEUE-001:f800e11 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-TERRAIN-CHUNK-QUEUE-001:24aef13 -->
+
+## Handoff
+
+- Commit: `f800e11` (`refactor(M03): extract terrain chunk queue planner`)
+- Results: dedicated contract PASS (`cases=8`, `iterations=100`, `235.096 ms`);
+  LOD/cache/facade/internal-access/manifest/shutdown/scheduler/streaming/focus/
+  ground/terrain-query/coordinate regressions PASS; internal inventory remains
+  `42`; editor parse has no script errors; documentation/coordination/diff gates
+  PASS; checkpoint dry-run planned `7/7` entries with expected missing-private-
+  corpus diagnostics
+- Remaining risks: planner adds a second linear tile-state pass; asset-backed
+  p95/p99 and visual acceptance remain pending; queue drains, terrain state and
+  Mesh/Node/RID finalization remain loader-owned
+- Documentation updated: `terrain-chunk-geometry-queue-planner.md`, module
+  registry, `world-renderer.md`, `RENDER.md`, inline API documentation and
+  data-flow/lifecycle/sequence diagrams
+- Integration: accepted in master merge `24aef13`; post-merge planner,
+  internal-access, facade and manifest gates passed

coordination/claims/M03-RND-TERRAIN-LOD-PLANNER-001.md

@@ -0,0 +1,103 @@
+# M03-RND-TERRAIN-LOD-PLANNER-001 — Pure terrain chunk LOD planner
+
+<!-- OPENWC_CLAIM:M03-RND-TERRAIN-LOD-PLANNER-001:sindo-main-codex:2026-07-18 -->
+
+## Ownership
+
+- Target: M03
+- Program: RND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m03-terrain-chunk-lod-planner`
+- Lease expires UTC: 2026-07-18
+- Integrator: M03 milestone integrator
+
+## Outcome
+
+Extract chunk-level terrain LOD desired-state calculation from the streamer into
+a scene-free `TerrainChunkLodPlanner` with immutable policy and typed focus input.
+
+## Non-goals
+
+- Move chunk/tile queues, loaded state, Mesh/Node/RID creation or budget drains.
+- Change radii, chunk size, threshold inclusivity, priority sorting or tile LOD policy.
+- Normalize/reorder custom radii or reinterpret negative values.
+- Move ADT parsing, quality cache/tasks, materials or ground query.
+- Add dependencies, persistence, workers or mark terrain extraction complete.
+
+## Paths
+
+- Exclusive: `src/render/terrain/terrain_chunk_lod_policy.gd`,
+  `src/render/terrain/terrain_chunk_lod_planner.gd`,
+  `src/tools/verify_terrain_chunk_lod_planner.gd`,
+  `docs/modules/terrain-chunk-lod-planner.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 resources, caches and
+  proprietary renderer corpus
+
+## Contracts and data
+
+- Input: ADT chunk adapter records, immutable `GodotWorldPosition`, immutable
+  enabled/radii/chunk-size policy
+- Output: detached Dictionary mapping source chunk index to LOD `0`, `1` or `2`
+- Formula: horizontal distance to `origin + half chunk`; inclusive squared thresholds
+- Disabled policy and empty/sparse chunks return absent entries exactly as before
+- Queue/cache/schema/coordinate versions: unchanged
+
+## Dependencies
+
+- Requires: integrated terrain cache slice master `ea08b8e`
+- Blocks: broader terrain service extraction and dependency/performance acceptance
+- External state: none; tests use synthetic chunk adapter records
+
+## Verification
+
+- Commands: dedicated center/boundary/outside/sparse/disabled/custom-radius and
+  bounded timing verifier; loader source boundary; facade/cache/internal-access/
+  manifest/shutdown/scheduler/streaming planner and repository gates
+- Fidelity evidence: extracted formulas and all seven baseline plans remain unchanged
+- Performance budget: bounded linear scan over at most the ADT chunk record count;
+  no Node, Resource, RID, task, cache entry or allocation framework
+
+## Documentation deliverables
+
+- Inline API docs for policy/planner
+- New module spec with inputs/outputs, data-flow, lifecycle, sequence, ownership,
+  failure, performance and source map
+- World renderer/module registry/`RENDER.md` updates
+
+## Simplicity and naming
+
+- Important names: `TerrainChunkLodPolicy`, `TerrainChunkLodPlanner`
+- Simplest solution: immutable scalar policy plus one pure linear planner
+- Rejected complexity: generic spatial index, quadtree, callback strategy,
+  normalized profile model or queue ownership
+- Unavoidable complexity: raw chunk dictionaries remain at the ADT adapter boundary
+- Measured optimization evidence: verifier records bounded High-like planning time
+
+## Status
+
+- State: accepted
+- Done: immutable policy, pure planner, both loader call sites, regressions and docs
+- Next: asset-backed performance acceptance and further terrain-service extraction later in M03
+- Blocked by:
+
+<!-- OPENWC_HANDOFF:READY:M03-RND-TERRAIN-LOD-PLANNER-001:eb94cfc -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M03-RND-TERRAIN-LOD-PLANNER-001:f36fabb -->
+
+## Handoff
+
+- Commit: `eb94cfc` (`refactor(M03): extract terrain chunk LOD planner`)
+- Results: dedicated contract PASS (`cases=7`, `iterations=250`, `12.726 ms`);
+  cache/facade/internal-access/manifest/shutdown/scheduler/streaming-focus/
+  streaming-planner/ground/terrain-query/coordinate regressions PASS; editor parse
+  has no script errors; documentation and coordination gates PASS; checkpoint
+  dry-run planned `7/7` entries with expected missing-private-corpus diagnostics
+- Remaining risks: asset-backed p95/p99 and visual acceptance remain pending;
+  terrain state, queue, quality-upgrade and finalization ownership remains in loader
+- Documentation updated: `terrain-chunk-lod-planner.md`, module registry,
+  `world-renderer.md`, `RENDER.md`, inline public API documentation and data-flow,
+  lifecycle and sequence diagrams
+- Integration: accepted in master merge `f36fabb`; post-merge planner, facade,
+  internal-access and manifest gates passed

docs/modules/README.md

@@ -12,8 +12,16 @@
 | Player input | Partial | [`player-input.md`](player-input.md) |
 | Local player movement | Implemented | [`local-player-movement.md`](local-player-movement.md) |
 | Terrain query | Implemented | [`terrain-query.md`](terrain-query.md) |
+| 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) |
+| M2 unique placement registry | Implemented extraction | [`m2-unique-placement-registry.md`](m2-unique-placement-registry.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) |
+| World entity presentation | Implemented boundary / Prototype visuals | [`world-entity-presentation.md`](world-entity-presentation.md) |
+| Streaming target planner | Implemented | [`streaming-target-planner.md`](streaming-target-planner.md) |
+| Render budget scheduler | Implemented | [`render-budget-scheduler.md`](render-budget-scheduler.md) |
 | Network/session | Planned | [`../../targets/roadmap/03-network-and-session.md`](../../targets/roadmap/03-network-and-session.md) |
 | Gameplay | Prototype/Planned | [`../../targets/roadmap/04-gameplay-systems.md`](../../targets/roadmap/04-gameplay-systems.md) |
 | UI/Lua/audio | Prototype/Planned | [`../../targets/roadmap/05-ui-lua-audio.md`](../../targets/roadmap/05-ui-lua-audio.md) |

docs/modules/character-presentation.md

@@ -0,0 +1,273 @@
+# Character Presentation
+
+## Metadata
+
+| Field | Value |
+|---|---|
+| Status | Implemented boundary / Partial fidelity |
+| Target/work package | M02 / M02-RND-CHARACTER-PRESENTATION-001 |
+| Owners | Character appearance composition and locomotion animation presentation |
+| Last verified | `97bb53f`, 2026-07-14 |
+| Profiles/capabilities | Current render sandbox character experiment |
+
+## Purpose
+
+Compose the current sandbox character GLB, geosets, skin textures and starter
+outfit below the existing `Visual` node, then independently present its
+stationary or moving animation. Keep visual asset loading and AnimationPlayer
+state out of gameplay movement and the player scene composition root.
+
+## Non-goals
+
+- Define authoritative character identity, equipment or movement state.
+- Change the existing GLB, geoset, texture-compositor, DBC or outfit formats.
+- Implement full build-12340 animation selection, blending or equipment visuals.
+- Load world assets, query terrain, process input or control the camera.
+- Introduce asynchronous streaming, background scene mutation or persistence.
+
+## Context and boundaries
+
+```mermaid
+flowchart LR
+    Scene[ThirdPersonWowController composition] --> Appearance[CharacterAppearancePresenter]
+    Model[Configured PackedScene] --> Appearance
+    DBC[Extracted DBC/item textures] --> Appearance
+    Appearance --> Root[CharacterModel root]
+    Root --> Geosets[Existing geoset controller]
+    Root --> Compositor[Existing texture compositor]
+    Appearance -->|ready root| Scene
+    Scene --> Animation[CharacterAnimationPresenter]
+    Velocity[Movement read model] -->|moving boolean| Animation
+    Animation --> Player[AnimationPlayer below root]
+```
+
+Allowed dependencies:
+
+- configured Godot `PackedScene` character asset;
+- existing `CharacterGeosetController`, `CharacterTextureCompositor` and
+  `WowCharacterOutfitResolver` presentation components;
+- `AnimationPlayer` and animation resources below the composed character root;
+- main-thread player scene composition and movement velocity read model.
+
+Forbidden dependencies:
+
+- `MoveIntent`, input devices or movement integration;
+- `TerrainQuery`, ADT parsing, coordinate conversion or streaming decisions;
+- cameras, network packets, server databases or gameplay reducers;
+- direct production database writes or cache-format ownership.
+
+## Public API
+
+| Symbol | Kind | Purpose | Thread/lifetime | Errors |
+|---|---|---|---|---|
+| `CharacterAppearancePresenter.load_character_appearance(content_root_override)` | Command | Replaces the owned character root and schedules final grounding/outfit composition | Main thread; may be called again during scene lifetime | Returns `false` for empty/invalid model; warning for invalid resource |
+| `CharacterAppearancePresenter.character_root` | Read-only state | Current owned model root or null | Stable until next load | None |
+| `character_appearance_ready(character_root)` | Signal | Publishes a fully attached, grounded root | Deferred main-thread completion | Not emitted for invalid/empty model |
+| `CharacterAnimationPresenter.bind_character_root(character_root)` | Command | Discovers and prepares the first descendant AnimationPlayer | Main thread; binding lifetime | Returns `false` and clears state when absent |
+| `CharacterAnimationPresenter.present_locomotion(is_moving)` | Command | Selects current stationary/moving candidate and starts it once | Main/physics thread | Returns `false` when unavailable, missing or unchanged |
+| `active_animation_name` | Read-only state | Selected animation name | Stable until bind/state transition | Empty when unbound |
+| `has_animation_player` | Read-only state | Whether the presenter has a valid bound player | Stable until bind | None |
+
+## Inputs and outputs
+
+| Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
+|---|---|---|---|---|---|
+| Input | Model resource path, class, scale and yaw | Runtime scene composition | Appearance presenter | Exported configuration | Captured at load |
+| Input | Extracted content root | Player scene configuration | Appearance presenter | Copied string | Captured at load |
+| Input | Packed character scene | Godot resource loader | Appearance presenter | Shared resource; presenter owns instance | Scene lifetime |
+| Output | Composed `CharacterModel` root | Appearance presenter | Scene/animation presenter | Appearance presenter owns node | Until replacement |
+| Output | Ready signal | Appearance presenter | Player composition | Synchronous signal after deferred completion | One per successful load |
+| Input | Moving/stationary boolean | Player adapter from horizontal velocity | Animation presenter | Value copy | One physics tick |
+| Output | AnimationPlayer playback mutation | Animation presenter | Rendered character | Bound root owns player/resources | Until next transition |
+
+Side effects:
+
+- loads and instantiates the configured model on the main thread;
+- adds/removes one owned `CharacterModel` subtree;
+- composes the existing texture/outfit components and reads their extracted inputs;
+- changes model transform for scale, yaw and ground alignment;
+- configures locomotion loop modes and starts AnimationPlayer playback;
+- does not write files, caches, databases or network state.
+
+## Data flow
+
+```mermaid
+flowchart TD
+    Config[Model/class/scale/yaw/content root] --> Load[Load PackedScene]
+    Load --> Replace[Replace owned CharacterModel]
+    Replace --> Attach[Attach model and compositor]
+    Attach --> Ground[Fit mesh bounds to visual ground]
+    DBC[Existing outfit resolver] --> Outfit[Apply starter outfit]
+    Ground --> Ready[Emit ready root]
+    Outfit --> Ready
+    Ready --> Bind[Discover AnimationPlayer]
+    Velocity[Horizontal movement velocity] --> State[Moving or stationary]
+    State --> Select[Run/Walk or Stand/Idle selection]
+    Bind --> Select
+    Select --> Playback[Loop and play with blend]
+```
+
+## Lifecycle/state
+
+```mermaid
+stateDiagram-v2
+    [*] --> Empty
+    Empty --> Loading: valid load command
+    Loading --> Ready: attach + deferred composition
+    Loading --> Empty: invalid resource
+    Ready --> Loading: replacement load
+    Ready --> Empty: empty model command
+
+    state Animation {
+        [*] --> Unbound
+        Unbound --> Stationary: bind root with animations
+        Stationary --> Moving: moving=true
+        Moving --> Stationary: moving=false
+        Stationary --> Unbound: bind missing player
+        Moving --> Unbound: bind missing player
+    }
+```
+
+Appearance replacement removes the old root from the scene immediately and
+queues it for deletion. Deferred completion checks root identity, so a stale
+completion cannot publish a replaced model.
+
+## Main sequence
+
+```mermaid
+sequenceDiagram
+    participant Scene as ThirdPersonWowController
+    participant Appearance as CharacterAppearancePresenter
+    participant Existing as Geoset/Compositor/Outfit
+    participant Animation as CharacterAnimationPresenter
+    participant Player as AnimationPlayer
+    Scene->>Appearance: load_character_appearance(content root)
+    Appearance->>Appearance: load, instantiate and attach root
+    Appearance->>Existing: compose textures and starter outfit
+    Appearance-->>Scene: character_appearance_ready(root)
+    Scene->>Animation: bind_character_root(root)
+    Animation->>Player: prepare loops and play Stand/Idle
+    loop Physics ticks
+        Scene->>Animation: present_locomotion(is moving)
+        Animation->>Player: play only on state/name change
+    end
+```
+
+## Ownership, threading and resources
+
+- The runtime scene owns one appearance presenter on `Visual` and one animation
+  presenter below it.
+- The appearance presenter exclusively owns the generated `CharacterModel`
+  subtree; imported shared resources remain Godot-owned.
+- The animation presenter borrows an AnimationPlayer reference until rebind or
+  subtree replacement; the player scene orders rebind through the ready signal.
+- Loading, node mutation, bounds calculation, outfit setup and playback occur
+  on the main thread. There are no workers, locks, RIDs or cancellation tokens.
+- The player controller owns neither model resources nor animation state.
+
+## Errors, cancellation and recovery
+
+| Failure | Detection | Behavior | Diagnostic | Recovery |
+|---|---|---|---|---|
+| Empty model path | Load guard | Clears old root and returns `false` | Contract regression | Configure a path and retry |
+| Invalid model resource | Failed PackedScene cast | Remains empty | Named warning with path | Correct/extract asset and retry |
+| Replaced deferred completion | Root identity check | Stale completion ignored | Replacement regression | No action required |
+| Missing DBC/outfit inputs | Existing resolver returns false/empty | Base model remains visible | Existing resolver diagnostics | Restore extracted inputs and reload |
+| Missing AnimationPlayer | Recursive discovery returns null | Presenter becomes unbound | Contract return/read state | Bind a root with animations |
+| Missing candidate animation | Candidate selection returns empty | Current playback unchanged | Verifier/source diagnostics | Extend verified candidate policy later |
+
+There is no background load cancellation. Replacement is the recovery path and
+invalid model state is explicit through the return value and null read model.
+
+## Configuration and capabilities
+
+| Setting/capability | Default | Profile | Runtime mutable | Effect |
+|---|---|---|---|---|
+| Character model | Human male sandbox GLB | Current sandbox | Before reload | Model scene input |
+| Character class ID | `1` | Current sandbox | Before reload | Starter outfit lookup |
+| Uniform scale | `1.0` | Current sandbox | Before reload | Character root scale |
+| Yaw offset | `90` degrees | Current sandbox | Before reload | Imported model correction |
+| Extracted content root | `res://data/extracted` | Local content | Per load override | DBC/item texture input |
+| Animation blend | `0.15` seconds | Current sandbox | Before bind/transition | Playback cross-fade/default blend |
+| Stationary candidates | `Stand`, then `Idle` | Current sandbox | Fixed | Exact then substring selection |
+| Moving candidates | `Run`, then `Walk` | Current sandbox | Fixed | Exact then substring selection |
+
+## Persistence, cache and migration
+
+Presenter state is transient. No saved settings, user profile, database schema
+or cache format changes. Existing scene paths remain
+`ThirdPersonPlayer/Visual` and add only `Visual/AnimationPresenter`; model and
+extracted-data paths retain their defaults. Moving the model exports from the
+player node to `Visual` is a scene-authoring ownership change, not persisted
+runtime data migration.
+
+## Diagnostics and observability
+
+- Logs: invalid model path warns with the responsible presenter and path.
+- Read models: current character root, animation binding and active name.
+- Tests: dedicated verifier reports appearance, animation, scene and player boundaries.
+- Metrics/correlation IDs: not applicable to this synchronous sandbox presenter.
+
+## Verification
+
+- Unit/contract: synthetic model fixture verifies load, scale, yaw, grounding,
+  compositor composition, ready signal, replacement and empty-model clearing.
+- Animation: synthetic libraries verify nested discovery, exact and substring
+  candidate selection, loop policy, blend configuration and duplicate suppression.
+- Boundary: player source contains no model loading, outfit, bounds or
+  AnimationPlayer logic; appearance and animation dependencies remain separate.
+- Integration: Eastern Kingdoms, Kalimdor and player regression scenes compose
+  both presenters; existing input/movement/terrain/camera tests remain required.
+- Fidelity evidence: only preservation of the current sandbox defaults and
+  selection rules. No build-12340 appearance or animation parity is claimed.
+- Performance: one synchronous model composition per load and constant-time
+  locomotion calls except on state transition; asset streaming remains future work.
+
+## Extension points
+
+- Replace starter outfit inputs with a versioned appearance/equipment snapshot.
+- Replace boolean locomotion input with a typed presentation state after
+  movement/network contracts define walk, run, jump, fall, swim, mount and emotes.
+- Add asynchronous/preloaded model providers behind the appearance command
+  without moving resource loading back into gameplay.
+- Add verified animation IDs/variation policy after build-12340 fixtures exist.
+
+## Capability status
+
+| Capability | Status | Evidence | Gap/next step |
+|---|---|---|---|
+| Independent appearance composition | Implemented | Synthetic fixture and three scene wirings | Integrator target update |
+| Independent locomotion animation | Implemented | Exact/fallback/loop/blend regression | Add typed presentation state later |
+| Current starter outfit | Partial | Existing resolver reused unchanged | Needs extracted DBC fixture and client comparison |
+| Current skin/geoset composition | Partial | Existing components reused | Full equipment/customization fidelity incomplete |
+| Build-12340 animation semantics | Planned | No original-client fixture | Capture animation IDs/transitions/timing |
+| Runtime equipment/network updates | Planned | No snapshot contract | M08/M09/M12 work |
+
+## Known gaps and risks
+
+- Model loading remains synchronous and can hitch when not preloaded.
+- Exact appearance, equipment, animation choice, playback speed and blending are unverified.
+- The moving input is a sandbox threshold boolean, not authoritative locomotion state.
+- The first descendant AnimationPlayer wins; multi-player imported scenes need a
+  more explicit binding contract if they appear.
+- Existing geoset/compositor/outfit implementations retain their own fidelity gaps.
+
+## Source map
+
+| Path | Responsibility |
+|---|---|
+| `src/scenes/character/character_appearance_presenter.gd` | Model-root ownership, composition, ground fit and outfit setup |
+| `src/scenes/character/character_animation_presenter.gd` | AnimationPlayer binding and locomotion playback state |
+| `src/scenes/character/character_geoset_controller.gd` | Existing geoset visibility and outfit defaults |
+| `src/scenes/character/character_texture_compositor.gd` | Existing skin/equipment texture composition |
+| `src/scenes/character/wow_character_outfit_resolver.gd` | Existing DBC starter outfit lookup |
+| `src/scenes/player/third_person_wow_controller.gd` | Scene composition and moving-state adapter |
+| `src/tests/scenes/character_presentation_model_fixture.tscn` | Asset-free model/grounding fixture |
+| `src/tools/verify_character_presentation.gd` | Presenter, scene and dependency regression |
+
+## Related decisions and references
+
+- ADR: none; current behavior and resource formats are preserved.
+- Upstream/reference: `targets/02-player-decomposition.md`,
+  `targets/roadmap/02-rendering-and-graphics.md`,
+  `targets/roadmap/04-gameplay-systems.md`, `RENDER.md`.

docs/modules/coordinate-mapping.md

@@ -116,9 +116,12 @@ flowchart LR
     Godot -->|typed direct adapter| Tile
     Godot -->|typed direct adapter| Local
     Godot --> TerrainQuery[AdtTerrainQuery consumer]
+    Godot --> TargetPlanner[StreamingTargetPlanner consumer]
     TerrainQuery --> Tile
     TerrainQuery --> Local
     TerrainQuery --> Chunk
+    TargetPlanner --> Tile
+    TargetPlanner --> Local
     Tile -->|tile plus local| Godot
     ServerYaw[ServerWorldYaw] -->|normalize only| CanonicalYaw[CanonicalWowWorldYaw]
     CanonicalYaw -->|same numeric world angle| GodotYaw[GodotWorldYaw]
@@ -249,6 +252,7 @@ raw three-number arrays are not an accepted new persistence contract.
 | `src/tools/verify_coordinate_golden_fixtures.gd` | Cross-source fixture schema and mapper validation |
 | `src/tools/verify_coordinate_conversion_boundaries.gd` | Repository-wide manual conversion and required-consumer gate |
 | `src/gameplay/terrain/adt_terrain_query.gd` | Typed Godot-position consumer for ADT tile/local/chunk lookup |
+| `src/render/streaming/streaming_target_planner.gd` | Typed Godot-position consumer for ADT focus tile and boundary-local lookup |
 | `src/tools/server_spawn_render_manifest.json` | Pinned server-spawn camera, player, marker and expected ADT ownership |
 | `src/tools/verify_server_spawn_renderer.gd` | Fixture-to-renderer manifest contract verifier |
 | `docs/adr/0001-canonical-world-coordinates.md` | Normative axes, units, boundaries and rollout decision |

docs/modules/local-player-movement.md

@@ -5,17 +5,18 @@
 | Field | Value |
 |---|---|
 | Status | Implemented |
-| Target/work package | M02 / M02-GMP-MOVEMENT-001, M02-RND-CAMERA-001 basis producer update |
+| Target/work package | M02 / M02-GMP-MOVEMENT-001, M02-GMP-SANDBOX-CAPABILITIES-001, M02-GMP-INPUT-PROFILE-335-001 and presentation consumers |
 | Owners | Gameplay local movement state; scene composition owns the instance |
-| Last verified | `8c1cf9b`, 2026-07-14 |
-| Profiles/capabilities | Current render sandbox; production/debug profile gate pending |
+| Last verified | M02-GMP-INPUT-PROFILE-335-001 worktree, 2026-07-15 |
+| Profiles/capabilities | `RenderSandbox` debug movement; `Blizzlike335` selected bindings and keyboard turn with debug sprint/flight rejected |
 
 ## Purpose
 
 Own current local velocity, acceleration and sandbox flight state independently
 of the player scene. Convert an immutable `MoveIntent` plus an explicit
-Godot-world movement basis into deterministic per-tick displacement without
-querying terrain, cameras, input devices or visual assets.
+Godot-world movement basis into deterministic per-tick displacement and convert
+signed turn intent into a yaw delta without querying terrain, cameras, input
+devices or visual assets.
 
 ## Non-goals
 
@@ -32,13 +33,16 @@ flowchart LR
     Input[MoveIntent] --> Movement[LocalPlayerMovementController]
     Basis[Explicit local movement Basis] --> Movement
     Delta[Physics delta seconds] --> Movement
+    Profile[Scene profile ID] --> Capabilities[PlayerMovementCapabilities]
+    Capabilities --> Movement
     Movement --> Displacement[Godot-world displacement]
+    Movement --> Yaw[Godot yaw delta radians]
     Movement --> Velocity[Read-only velocity state]
     Scene[ThirdPersonWowController] --> Basis
     Displacement --> Scene
     Scene --> Transform[Player world transform]
     Scene --> Terrain[TerrainQuery and ground snap adapter]
-    Velocity --> Presentation[Visual facing and animation adapter]
+    Velocity --> Presentation[Visual facing and CharacterAnimationPresenter adapter]
 ```
 
 Allowed dependencies:
@@ -57,11 +61,16 @@ Forbidden dependencies:
 
 | Symbol | Kind | Purpose | Thread/lifetime | Errors |
 |---|---|---|---|---|
-| `LocalPlayerMovementController.new(...)` | Constructor | Sets explicit speeds, acceleration and sandbox sprint multiplier | Created by composition root; retained for player scene lifetime | Caller owns configuration validation |
+| `PlayerMovementCapabilities.render_sandbox()` | Factory | Creates the only debug sprint/free-flight capability set | Immutable caller value | None |
+| `PlayerMovementCapabilities.blizzlike_335()` | Factory | Creates the compatibility-safe set with debug movement disabled | Immutable caller value | Name is intent, not a parity claim |
+| `PlayerMovementCapabilities.for_profile_id(...)` | Factory | Maps composition configuration once; unknown IDs fail closed | Immutable caller value | Unknown maps to `Blizzlike335` |
+| `LocalPlayerMovementController.new(...)` | Constructor | Sets explicit speeds, acceleration, sprint multiplier and movement capabilities | Created by composition root; retained for player scene lifetime | Null capability defaults to `Blizzlike335` |
 | `godot_world_velocity_units_per_second` | Read-only state | Current Godot-world velocity after the last update | Stable until next mutation on owning thread | None |
 | `is_flight_enabled` | Read-only state | Current sandbox free-flight mode | Stable until toggle | None |
-| `toggle_sandbox_flight()` | Command | Toggles flight and clears velocity | Owning physics/input thread | Returns new flight state |
+| `movement_profile_id` | Read-only state | Effective capability profile ID | Controller lifetime | None |
+| `toggle_sandbox_flight()` | Command | Toggles flight only when explicitly permitted and clears velocity | Owning physics/input thread | Rejected request returns `false` with state unchanged |
 | `advance(move_intent, godot_world_movement_basis, delta_seconds)` | Stateful update | Accelerates toward requested velocity and returns displacement for the tick | Owning physics thread; one call per tick | Negative delta is treated as zero |
+| `calculate_yaw_delta_radians(move_intent, delta_seconds)` | Pure query | Converts signed turn input to Godot yaw delta | Owning physics thread | Negative delta is treated as zero |
 
 Constructor units:
 
@@ -73,17 +82,20 @@ Constructor units:
 | `flight_vertical_speed_units_per_second` | Sandbox vertical Godot units per second |
 | `acceleration_units_per_second_squared` | Velocity change per second |
 | `sandbox_sprint_multiplier` | Dimensionless debug multiplier |
+| `keyboard_turn_speed_radians_per_second` | Positive keyboard yaw speed; defaults to PI rad/s |
 
 ## Inputs and outputs
 
 | Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
 |---|---|---|---|---|---|
 | Input | `MoveIntent` | `PlayerInputSource` | Movement controller | Immutable caller-held value | One physics tick |
+| Input | `PlayerMovementCapabilities` | Application/player scene composition | Movement controller | Immutable caller-held value | Controller lifetime |
 | Input | Godot-world `Basis` | Player or `ThirdPersonCameraRig` adapter | Movement controller | Value copy | One physics tick |
 | Input | Delta seconds | Godot physics loop | Movement controller | Scalar value | One physics tick |
 | Input | Flight toggle command | Remappable sandbox action via scene adapter | Movement controller | Synchronous command | Input event dispatch |
 | Output | Displacement `Vector3` | Movement controller | Player scene adapter | Value copy | Applied in same tick |
-| Output | Velocity `Vector3` | Movement controller | Facing/animation adapter | Read-only value copy | Until next update |
+| Output | Yaw delta radians | Movement controller | Player scene adapter | Scalar value | Applied before movement basis selection |
+| Output | Velocity `Vector3` | Movement controller | Facing and `CharacterAnimationPresenter` scene adapter | Read-only value copy | Until next update |
 | Output | Flight state | Movement controller | Basis/terrain scene adapter | Read-only boolean | Until next toggle |
 
 Side effects:
@@ -97,9 +109,14 @@ Side effects:
 ```mermaid
 flowchart LR
     Intent[MoveIntent axes] --> Target[Calculate target velocity]
+    Intent --> Turn[Calculate signed yaw delta]
+    Turn --> SceneYaw[Scene applies character yaw]
     Basis[Player or camera-pivot Basis] --> Directions[Forward/right directions]
     Directions --> Target
     Config[Speeds and sprint multiplier] --> Target
+    Profile[RenderSandbox or Blizzlike335] --> Capability[Immutable debug capabilities]
+    Capability -->|allow or reject sprint| Target
+    Capability -->|allow or reject flight toggle| Current
     Previous[Owned velocity] --> Integrate[move_toward by acceleration × delta]
     Target --> Integrate
     Integrate --> Current[Updated velocity]
@@ -112,7 +129,8 @@ flowchart LR
 ```mermaid
 stateDiagram-v2
     [*] --> GroundedSandbox
-    GroundedSandbox --> FlyingSandbox: toggle / clear velocity
+    GroundedSandbox --> FlyingSandbox: toggle [debug flight allowed] / clear velocity
+    GroundedSandbox --> GroundedSandbox: toggle [debug flight rejected]
     FlyingSandbox --> GroundedSandbox: toggle / clear velocity
     GroundedSandbox --> GroundedSandbox: advance
     FlyingSandbox --> FlyingSandbox: advance
@@ -128,8 +146,14 @@ sequenceDiagram
     participant Input as PlayerInputSource
     participant Scene as ThirdPersonWowController
     participant Move as LocalPlayerMovementController
-    participant Present as Facing/Animation adapter
+    participant Cap as PlayerMovementCapabilities
+    participant Present as CharacterAnimationPresenter adapter
     Input-->>Scene: MoveIntent
+    Scene->>Cap: map configured profile once
+    Scene->>Move: construct with immutable capabilities
+    Scene->>Move: calculate_yaw_delta_radians(intent, delta)
+    Move-->>Scene: yaw delta
+    Scene->>Scene: apply yaw and synchronize camera orbit yaw
     Scene->>Move: advance(intent, selected basis, delta)
     Move-->>Scene: displacement
     Scene->>Scene: apply global position and ground snap
@@ -140,6 +164,8 @@ sequenceDiagram
 ## Ownership, threading and resources
 
 - The player scene creates and exclusively owns one movement controller.
+- The composition root creates one immutable capability value; the controller
+  retains it and exposes only its effective profile ID.
 - Velocity and flight state have the same lifetime as that controller.
 - All mutations currently occur on the main input/physics thread.
 - Read-only value returns are copies; consumers cannot mutate owned state.
@@ -153,6 +179,8 @@ sequenceDiagram
 | Negative physics delta | `advance` guard | Returns zero displacement; velocity unchanged | Unit regression | Resume with valid non-negative delta |
 | Missing scene basis owner | Scene composition defect | Controller cannot be called correctly | Scene/parser error or boundary test | Restore explicit scene dependency |
 | Flight toggle during motion | Command path | Velocity clears before next step | State-transition regression | Continue from zero velocity |
+| Flight/sprint request in `Blizzlike335` | Capability check | Request has no effect | Profile regression | Select explicit `RenderSandbox` only for tooling/debug scenes |
+| Unknown/null profile capability | Factory/constructor safe default | Uses `Blizzlike335`; debug movement disabled | Capability regression | Correct composition profile ID |
 | Missing terrain data | `TerrainGroundSample.is_available == false` | Scene skips existing ground snap | Stable terrain failure code | Replace/recover query backend |
 
 There is no asynchronous cancellation, retry or rollback. Recreating the
@@ -169,6 +197,10 @@ controller resets velocity and flight state deterministically.
 | Flight vertical speed | `7.0` units/s | Sandbox debug | Fixed for controller lifetime | Vertical free-flight target |
 | Sprint multiplier | `6.0` | Sandbox debug | Fixed for controller lifetime | Multiplies planar and vertical targets |
 | Camera-relative basis | Selected only while flight is enabled | Sandbox debug | Per tick | Preserves existing pitched flight direction |
+| Debug sprint permission | Enabled | `RenderSandbox` only | Immutable | Allows sprint request multiplier |
+| Debug free-flight permission | Enabled | `RenderSandbox` only | Immutable | Allows toggle and vertical movement |
+| Compatibility-safe debug permissions | Disabled | `Blizzlike335` | Immutable | Ignores sprint/toggle requests |
+| Keyboard turn rate | `3.141594` rad/s | `Blizzlike335` composition | Fixed for controller lifetime | Server-contract default applied to signed turn intent |
 
 ## Persistence, cache and migration
 
@@ -187,13 +219,17 @@ separate versioned movement snapshot contract.
 
 - Unit/contract: `src/tools/verify_local_player_movement.gd` covers forward,
   backward, strafe, rotated basis, acceleration, deceleration, sprint, flight,
-  pitched camera basis, state reset and invalid delta.
+  pitched camera basis, state reset, signed keyboard turn and invalid delta.
+- Capability: `verify_player_movement_capabilities.gd` covers three profile-ID
+  cases, safe defaults, sprint/flight allow/reject behavior and two real scene compositions.
 - Boundary: verifier rejects Node/Input/Camera/ADT dependencies and movement
   integration/state remaining in the player scene.
 - Scene integration: `verify_player_input.gd` drives the asset-free player
   regression scene through forward motion and immediate flight toggle.
-- Fidelity evidence: default values and formulas are regression-locked against
-  the pre-extraction sandbox. No original-client comparison is claimed.
+- Fidelity evidence: translation defaults remain regression-locked against the
+  pre-extraction sandbox. The compatibility keyboard turn default is pinned to
+  TrinityCore 3.3.5 `playerBaseMoveSpeed[MOVE_TURN_RATE]`; that server contract
+  does not alone prove original-client timing parity.
 - Performance budget: constant-time vector math, no per-tick I/O or scene lookup;
   `MoveIntent` allocation remains owned by the input package.
 
@@ -202,7 +238,8 @@ separate versioned movement snapshot contract.
 - Terrain/collision policy can consume displacement without changing input or velocity ownership.
 - A future server-aware predictor may replace this controller behind the scene composition boundary.
 - A typed movement snapshot may expose deterministic replay state when M08/M09 require it.
-- Sandbox debug capability gating can reject sprint/flight before commands reach this controller.
+- A future application profile can map to this narrow capability value without
+  coupling the movement controller to the application shell.
 
 ## Capability status
 
@@ -210,7 +247,9 @@ separate versioned movement snapshot contract.
 |---|---|---|---|
 | Scene-free local velocity state | Implemented | Pure controller and source boundary regression | Integrate target checklist after review |
 | Existing planar acceleration/speeds | Implemented | Exact numeric unit cases and real scene regression | Compare with build 12340 before fidelity claim |
-| Existing camera-relative free flight | Implemented | Pitched-basis and toggle/reset cases | Restrict to sandbox profile |
+| Compatibility keyboard turn | Implemented | Pinned server-core value, signed pure cases and real-scene profile regression | Direct original-client timing comparison remains required |
+| Existing camera-relative free flight | Implemented in `RenderSandbox` | Pitched-basis, profile and toggle/reset cases | Original-client flight semantics remain out of scope |
+| Typed sprint/free-flight exclusion | Implemented | Pure and real-scene profile regressions | Application shell must select profile explicitly later |
 | Terrain height query | Implemented | Typed `TerrainQuery` and injected player regression | Ground-snap policy remains scene-owned |
 | Terrain collision movement policy | Planned | Height-only query does not model collision | Add slopes/holes/collision later |
 | Jump/fall/swim | Planned | M02/M09 roadmap | Requires terrain/liquid and server contracts |
@@ -218,12 +257,15 @@ separate versioned movement snapshot contract.
 
 ## Known gaps and risks
 
-- Numeric defaults preserve the existing sandbox but are not original-client evidence.
+- Translation/acceleration defaults preserve the existing sandbox and are not original-client evidence.
 - Configuration is captured at scene `_ready`; runtime mutation of exported speed
   properties does not reconfigure an existing controller.
 - Ground snap remains in the player scene, but its ADT data access is now behind
   a replaceable `TerrainQuery`.
-- Sprint and free flight still lack a typed sandbox capability gate.
+- Runtime renderer scenes intentionally default to `RenderSandbox`; a future
+  game-client composition must explicitly select `Blizzlike335`.
+- `Blizzlike335` currently means only debug movement exclusion and must not be
+  interpreted as evidence that remaining movement semantics are 1:1.
 - The module uses Godot math value types; a future engine-independent gameplay
   predictor may require scalar/domain movement contracts.
 
@@ -232,12 +274,16 @@ separate versioned movement snapshot contract.
 | Path | Responsibility |
 |---|---|
 | `src/gameplay/movement/local_player_movement_controller.gd` | Owned velocity/flight state and deterministic integration |
+| `src/gameplay/movement/player_movement_capabilities.gd` | Immutable profile-to-debug-capability contract and safe defaults |
 | `src/gameplay/terrain/terrain_query.gd` | Replaceable ground-height input boundary |
 | `src/scenes/player/third_person_camera_rig.gd` | Camera-relative sandbox flight basis producer |
-| `src/scenes/player/third_person_wow_controller.gd` | Composition, basis selection, displacement/terrain/presentation adapters |
+| `src/scenes/character/character_animation_presenter.gd` | Locomotion presentation consumer behind the scene adapter |
+| `src/scenes/player/third_person_wow_controller.gd` | Composition, basis selection, displacement/terrain and presentation-state adapters |
 | `src/tools/verify_local_player_movement.gd` | Pure numeric, state-transition and dependency regression |
+| `src/tools/verify_player_movement_capabilities.gd` | Profile factory, allow/reject and real-scene regression |
 | `src/tests/scenes/player_input_regression.tscn` | Asset-free integrated player fixture |
 | `src/tools/verify_player_input.gd` | Input-to-movement scene regression |
+| `src/tests/fixtures/player_input_profile_335.json` | Turn-rate and selected binding provenance |
 
 ## Related decisions and references
 

docs/modules/m2-unique-placement-registry.md

@@ -0,0 +1,220 @@
+# M2 Unique Placement Registry
+
+## Metadata
+
+| Field | Value |
+|---|---|
+| Status | Implemented extraction |
+| Target/work package | M03 / `M03-RND-M2-UNIQUE-REGISTRY-001` |
+| Owners | Cross-tile positive ADT MDDF unique-ID reservations |
+| Last verified | Worktree `work/sindo-main-codex/m03-m2-unique-registry`, 2026-07-16 |
+| Profiles/capabilities | Existing static M2 placement path; session-memory only |
+
+## Purpose
+
+Ensure a positive ADT `MDDF.uniqueId` has at most one owning streamed tile while
+allowing unkeyed placements through and returning skipped keys for loader-driven
+candidate retry after the owner unloads.
+
+## Non-goals
+
+- Own tile state, retry queues, worker/group/build jobs or detail radius rules.
+- Group placements or create MultiMesh, Mesh, Node, material or RID resources.
+- Validate M2 paths, transforms, animation, materials or build-12340 fidelity.
+- Persist reservations or define a generic identity/ownership framework.
+- Change cache formats, quality profiles or placement visibility.
+
+## Context and boundaries
+
+```mermaid
+flowchart LR
+    ADT[ADT M2 placement dictionaries] --> Loader[StreamingWorldLoader adapter]
+    Loader --> Registry[M2UniquePlacementRegistry]
+    Registry --> Accepted[Filtered placements + owned keys]
+    Registry --> Skipped[Skipped keys]
+    Accepted --> Group[Existing worker grouping/build path]
+    Skipped --> TileState[Loader-owned tile retry state]
+    Unload[Owner tile unload] --> Loader
+    Loader -->|release keys| Registry
+    Loader -->|notify released candidates| Retry[Existing detail sync queue]
+```
+
+Allowed dependencies are scalar/container values from the ADT adapter. Node,
+SceneTree, RenderingServer, ResourceLoader, WorkerThreadPool, gameplay, network,
+editor UI, files and persistent caches are forbidden.
+
+## Public API
+
+| Symbol | Kind | Purpose | Thread/lifetime | Errors |
+|---|---|---|---|---|
+| `reserve(tile_key, m2_placements)` | Command/query | Reserve available positive IDs and return fresh filtered/owned/skipped arrays | Renderer owner thread/session | Invalid non-Dictionary entries are ignored; unkeyed entries pass through |
+| `release(tile_key, unique_keys)` | Command | Release only keys owned by the supplied tile | Renderer owner thread/session | Unknown/non-owner/empty keys are ignored |
+| `clear()` | Lifecycle command | Drop every reservation on world reset/shutdown | Renderer owner thread | Idempotent |
+| `active_count()` | Query | Return current reservation count | Renderer owner thread | No failure state |
+| `diagnostic_snapshot()` | Read model | Return sorted detached key/tile ownership records | Caller-owned result | Exposes no mutable registry reference |
+
+## Inputs and outputs
+
+| Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
+|---|---|---|---|---|---|
+| Input | Tile key | Streamer tile state | Registry reservation owner | Copied string | Reservation lifetime |
+| Input | Raw M2 placement dictionaries | ADT parser result | Registry | Loader-owned; read only | One reserve call |
+| Input | Claimed key array | Tile state | Registry release | Loader-owned; read only | One release call |
+| Output | Filtered placement array | Registry | M2 grouping task adapter | Fresh shallow array; placement dictionaries remain source values | One request |
+| Output | Owned `uid:<decimal>` keys | Registry | Loader tile state | Fresh strings/array | Until release |
+| Output | Skipped keys | Registry | Loader candidate retry state | Fresh strings/array | Until owner release/retry |
+| Output | Released keys | Registry | Loader candidate notifier | Fresh array in input order | One release |
+| Output | Detached diagnostics/count | Registry | Metrics/tests | Caller-owned scalars/dictionaries | One query |
+
+Only `unique_id > 0` enters the registry. Missing, zero and negative values have
+an empty key and remain untracked, matching the prior loader behavior.
+
+## Data flow
+
+```mermaid
+flowchart TD
+    Reserve[reserve tile + placements] --> Placement[Iterate placement order]
+    Placement --> Dict{Dictionary?}
+    Dict -->|no| Placement
+    Dict -->|yes| Positive{unique_id > 0?}
+    Positive -->|no| Pass[Append untracked placement]
+    Positive -->|yes| Owned{Key already owned?}
+    Owned -->|no| Claim[Set owner and append placement/key]
+    Owned -->|same tile + already in this call| Duplicate[Suppress duplicate]
+    Owned -->|same tile + first in this call| PassOwner[Append placement/key]
+    Owned -->|other tile| Skip[Append skipped key once]
+    Pass --> Placement
+    Claim --> Placement
+    Duplicate --> Placement
+    PassOwner --> Placement
+    Skip --> Placement
+    Release[release tile + keys] --> Owner{Tile is current owner?}
+    Owner -->|yes| Erase[Erase and return key]
+    Owner -->|no| Ignore[Leave reservation unchanged]
+```
+
+## Lifecycle/state
+
+```mermaid
+stateDiagram-v2
+    [*] --> Empty
+    Empty --> Reserved: reserve positive unowned ID
+    Reserved --> Reserved: same-owner reserve / competing skip / non-owner release
+    Reserved --> Empty: owner releases final ID
+    Reserved --> Empty: clear world/reset
+    Empty --> Empty: unkeyed reserve / unknown release / clear
+    Empty --> [*]
+    Reserved --> [*]: owner releases registry after clear
+```
+
+## Main sequence
+
+```mermaid
+sequenceDiagram
+    participant TileA as First streamed tile
+    participant Loader as StreamingWorldLoader
+    participant Registry as M2UniquePlacementRegistry
+    participant TileB as Cross-border candidate tile
+    TileA->>Loader: placements include positive unique ID
+    Loader->>Registry: reserve(tile A, placements)
+    Registry-->>Loader: accepted placement + owned key
+    TileB->>Loader: same placement ID
+    Loader->>Registry: reserve(tile B, placements)
+    Registry-->>Loader: skipped key
+    Loader->>Loader: retain skipped key in tile B state
+    TileA->>Loader: unload/remove details
+    Loader->>Registry: release(tile A, owned keys)
+    Registry-->>Loader: released key
+    Loader->>Loader: enqueue eligible tile B detail retry
+```
+
+## Ownership, threading and resources
+
+- The registry owns one private key-to-owner-string dictionary.
+- The loader owns tile-held owned/skipped arrays, retry discovery, task/build
+  lifecycle and every MultiMesh/Node/Mesh/material/RID side effect.
+- Calls currently occur on the renderer main thread. The registry has no lock and
+  must not be mutated concurrently.
+- Returned arrays and diagnostic dictionaries are fresh; source placement
+  dictionaries are passed through shallowly and must remain read-only.
+
+## Errors, cancellation and recovery
+
+| Failure | Detection | Behavior | Diagnostic | Recovery |
+|---|---|---|---|---|
+| Invalid placement variant | Type guard | Ignore entry | Contract test | Repair parser/adapter input |
+| Missing/non-positive ID | Key rule | Pass placement without ownership | Smoke/contract test | Expected legacy behavior |
+| Cross-tile duplicate | Owner lookup | Skip placement and return key once | Tile skipped-key state | Owner release triggers eligible candidate retry |
+| Non-owner release | Owner comparison | Ignore; preserve owner | Contract test | Release from recorded tile |
+| Reset/shutdown | Loader lifecycle | Clear all reservations | Shutdown regression/count | New world reserves afresh |
+
+There is no asynchronous work or cancellation inside the registry. Loader-owned
+tasks are cancelled independently before/reset around registry clearing.
+
+## Configuration and capabilities
+
+The registry introduces no settings. It applies to all positive IDs in the
+existing static M2 placement path. Detail radius, M2 enablement, build budgets
+and animation allowlists remain loader/profile configuration.
+
+## Persistence, cache and migration
+
+Reservations are runtime-only and are not serialized. M2 `.tscn/.glb`, animation,
+mesh/material refresh and ADT cache versions remain unchanged. No rebuild or
+migration is required.
+
+## Diagnostics and observability
+
+- `active_count()` continues to feed `m2_active_unique_ids` baseline metrics.
+- Detached diagnostics sort by unique key for deterministic inspection and expose
+  only strings/counts.
+- Contract timing covers repeated 256-placement reserve/release cycles. Asset-
+  backed streaming p95/p99 remains milestone acceptance work.
+
+## Verification
+
+- `verify_m2_unique_placement_registry.gd`: invalid/unkeyed handling, within-call
+  duplicate suppression, same-owner repeat, cross-tile skip, owner-checked release,
+  retry, idempotent clear, detached/sorted diagnostics, source boundary and timing.
+- `verify_m2_unique_dedupe.gd`: existing `uid:11785` cross-tile smoke now targets
+  the extracted public contract rather than loader-private methods.
+- Facade, terrain, internal-access, manifest, shutdown, scheduler, streaming and
+  coordinate regressions remain required.
+- Fidelity evidence is dedupe behavior preservation only. No new build-12340
+  visual parity claim is made.
+
+## Extension points
+
+- Expose detached ownership diagnostics through facade metrics only if needed.
+- Extract grouping/build orchestration as separate services with explicit budgets.
+
+## Capability status
+
+| Capability | Status | Evidence | Gap/next step |
+|---|---|---|---|
+| Cross-tile positive-ID ownership | Implemented extraction | Dedicated contract plus legacy smoke | Asset-backed boundary traversal timing pending |
+| Candidate retry and M2 build | Remains in loader | Existing release adapter/source boundary | Broader M2 service extraction required |
+
+## Known gaps and risks
+
+- Placement dictionaries are shallow pass-through values at the ADT boundary.
+- Same-owner reservations across separate calls intentionally pass again; the
+  caller's existing root/task guards prevent duplicate build requests.
+- First owner follows tile processing order, matching prior behavior rather than
+  a canonical geometric owner rule.
+- Group/build/load/animation caches and render finalization remain monolithic.
+
+## Source map
+
+| Path | Responsibility |
+|---|---|
+| `src/render/m2/m2_unique_placement_registry.gd` | Positive-ID keying, ownership, release and diagnostics |
+| `src/scenes/streaming/streaming_world_loader.gd` | Reservation adapters, tile state, candidate retry and M2 rendering |
+| `src/tools/verify_m2_unique_placement_registry.gd` | Contract, lifecycle, source and timing regression |
+| `src/tools/verify_m2_unique_dedupe.gd` | Historical cross-tile smoke fixture |
+
+## Related decisions and references
+
+- [`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/player-input.md

@@ -5,24 +5,25 @@
 | Field | Value |
 |---|---|
 | Status | Partial |
-| Target/work package | M02 / M02-GMP-INPUT-001, M02-GMP-MOVEMENT-001 and M02-RND-CAMERA-001 consumer updates |
+| Target/work package | M02 / M02-GMP-INPUT-001, M02-GMP-SANDBOX-CAPABILITIES-001, M02-GMP-INPUT-PROFILE-335-001 |
 | Owners | Gameplay input boundary; `sindo-main-codex` for current package |
-| Last verified | `8c1cf9b`, 2026-07-14 |
-| Profiles/capabilities | Current render-sandbox defaults; `Blizzlike335` binding semantics not yet verified |
+| Last verified | M02-GMP-INPUT-PROFILE-335-001 worktree, 2026-07-15 |
+| Profiles/capabilities | Distinct RenderSandbox and Blizzlike335 action layouts; debug execution remains RenderSandbox-only |
 
 ## Purpose
 
 Convert remappable Godot Input Map actions into an immutable, scene-free
-`MoveIntent` that can be consumed by the current player controller and a later
-independently testable local movement controller.
+`MoveIntent` that can be consumed by the independently testable local movement
+controller. Select either the preserved renderer-sandbox layout or the verified
+build-12340 movement bindings at the scene composition boundary.
 
 ## Non-goals
 
 - Define authoritative server movement, prediction or reconciliation.
 - Own character transform, terrain queries, camera state or animation state.
-- Claim that the current W/S/A/D sandbox mapping exactly matches build 12340.
-- Make sprint or free flight available to the production compatibility profile;
-  their profile gate remains a later M02 package.
+- Implement jump, autorun, left-button select/move or persisted binding settings.
+- Remove process-wide debug actions; Blizzlike335 sampling ignores them and the
+  movement capability boundary also rejects directly constructed debug requests.
 
 ## Context and boundaries
 
@@ -30,8 +31,10 @@ independently testable local movement controller.
 flowchart LR
     Devices[Keyboard and mouse] --> InputMap[Godot Input Map]
     InputMap --> Source[PlayerInputSource]
+    Profile[RenderSandbox or Blizzlike335] --> Source
     Source --> Intent[MoveIntent]
     Intent --> Movement[LocalPlayerMovementController]
+    Profile[PlayerMovementCapabilities] --> Movement
     Movement --> Controller[ThirdPersonWowController adapter]
     Controller --> Camera[ThirdPersonCameraRig]
 ```
@@ -52,11 +55,13 @@ Forbidden dependencies:
 
 | Symbol | Kind | Purpose | Thread/lifetime | Errors |
 |---|---|---|---|---|
-| `MoveIntent` | Immutable value | Carries normalized forward, strafe and vertical axes plus the sandbox sprint request | Created and consumed on the main physics tick; caller retains reference | Constructor clamps axes; no I/O failure |
+| `MoveIntent` | Immutable value | Carries normalized forward, strafe, vertical and turn axes plus the sandbox sprint request | Created and consumed on the main physics tick; caller retains reference | Constructor clamps axes; no I/O failure |
 | `MoveIntent.has_translation()` | Query | Reports whether any translation axis is non-zero | Any thread while value remains immutable | None |
 | `PlayerInputActions` | Constants | Provides stable action names shared by configuration and adapters | Process lifetime | Missing project actions are detected by verification |
-| `PlayerInputSource.sample_move_intent()` | Adapter method | Samples configured actions for one physics tick | Main thread; returned intent is independent of adapter lifetime | Missing actions resolve to zero strength and are a configuration defect |
+| `PlayerInputSource.new(profile_id)` | Constructor | Selects sandbox or compatibility action layout once | Scene lifetime | Unknown IDs fail closed to `Blizzlike335` |
+| `PlayerInputSource.sample_move_intent()` | Adapter method | Samples the selected action layout for one physics tick | Main thread; returned intent is independent of adapter lifetime | Missing actions resolve to zero strength and are a configuration defect |
 | `PlayerInputSource.compose_move_intent(...)` | Pure factory | Clamps strengths, cancels opposites and normalizes diagonal planar input | Any thread with scalar inputs | None |
+| `PlayerInputSource.compose_blizzlike_335_move_intent(...)` | Pure factory | Composes Q/E strafe, A/D turn and right-mouse A/D strafe semantics | Any thread with scalar inputs | None |
 
 ## Inputs and outputs
 
@@ -65,6 +70,8 @@ Forbidden dependencies:
 | Input | Movement action strengths | Godot `InputMap`/`Input` | `PlayerInputSource` | Engine-owned snapshot | Sampled on main physics tick |
 | Input | Mouse action events | Godot `_unhandled_input` dispatch | `ThirdPersonCameraRig` through player dispatch | Engine-owned event | Current input dispatch only |
 | Output | `MoveIntent` | `PlayerInputSource` | `LocalPlayerMovementController` through scene composition | Immutable caller-held value | One physics tick |
+| Output | Debug sprint request/vertical axes | `PlayerInputSource` | Capability-gated movement controller | Immutable intent fields | One physics tick |
+| Output | Signed turn axis | `PlayerInputSource` | `LocalPlayerMovementController` | Immutable scalar | One physics tick |
 | Output | Camera action names | `PlayerInputActions` | `ThirdPersonCameraRig` | Static constants | Process lifetime |
 
 Side effects:
@@ -81,9 +88,11 @@ flowchart LR
     Project[project.godot action defaults] --> Map[InputMap]
     Remap[User or editor remapping] --> Map
     Map -->|movement strengths| Source[PlayerInputSource]
+    Profile[Selected input profile] --> Source
     Map -->|camera events| Camera[ThirdPersonCameraRig]
     Source -->|clamp cancel normalize| Intent[MoveIntent]
     Intent --> Consumer[LocalPlayerMovementController]
+    Profile[PlayerMovementCapabilities] --> Consumer
     Consumer --> Adapter[ThirdPersonWowController]
 ```
 
@@ -92,7 +101,9 @@ flowchart LR
 The adapter is stateless. The scene composition root creates one
 `PlayerInputSource` and `LocalPlayerMovementController` in `_ready`; each physics
 tick produces a new immutable intent. Flight enabled/disabled state is owned by
-the movement controller and is not hidden in the input adapter.
+the movement controller and is not hidden in the input adapter. RenderSandbox
+retains debug requests in its intent; Blizzlike335 does not sample them, and the
+immutable movement capability also rejects directly constructed requests.
 
 ## Main sequence
 
@@ -106,7 +117,7 @@ sequenceDiagram
     Engine->>Source: movement action strengths
     Source->>Intent: compose normalized axes and requests
     Source-->>Player: sample_move_intent()
-    Player->>Move: advance(intent, selected basis, delta)
+    Player->>Move: calculate yaw delta, then advance(intent, selected basis, delta)
     Move-->>Player: displacement and velocity state
 ```
 
@@ -127,6 +138,7 @@ sequenceDiagram
 | Conflicting opposite actions | Pure composition | Strengths cancel deterministically | Covered by contract test | Release/remap one action |
 | Strength outside range | Pure composition | Value clamps to `[0, 1]` before axis calculation | Covered by contract test | Input adapter may be corrected independently |
 | Controller disabled/unloaded | Scene lifecycle | Sampling stops with physics processing | Existing scene lifecycle | Re-enable or recreate scene |
+| Debug request in `Blizzlike335` | Input profile and movement capability checks | Input adapter omits it; directly constructed request has no effect | Profile/capability regressions | Use `RenderSandbox` only when debug movement is intended |
 
 There is no asynchronous operation to cancel and no persisted state to roll back.
 
@@ -134,12 +146,15 @@ There is no asynchronous operation to cancel and no persisted state to roll back
 
 | Setting/capability | Default | Profile | Runtime mutable | Effect |
 |---|---|---|---|---|
-| Forward/backward | Physical W/S | Current render sandbox | Yes, through Input Map | Produces signed forward axis |
-| Strafe left/right | Physical A/D | Current render sandbox | Yes | Produces signed right axis |
+| Forward/backward | Physical W/S and Up/Down | Both | Yes, through Input Map | Produces signed forward axis |
+| Strafe left/right | Physical A/D | `RenderSandbox` | Yes | Preserves renderer baseline |
+| Strafe left/right | Physical Q/E | `Blizzlike335` | Yes | Matches selected build-12340 defaults |
+| Keyboard turn | Physical A/D and Left/Right | `Blizzlike335` | Yes | Produces signed turn axis |
+| Camera-held A/D | Physical A/D while right mouse is held | `Blizzlike335` | Yes | Produces strafe and suppresses keyboard turn |
 | Camera rotate | Right mouse button | Current render sandbox | Yes | Captures/releases mouse for orbit |
 | Camera zoom | Mouse wheel | Current render sandbox | Yes | Adjusts current camera distance |
-| Debug sprint | Shift | Sandbox debug only by intent; profile gate pending | Yes | Requests existing speed multiplier |
-| Debug flight up/down/toggle | E/Q/Space | Sandbox debug only by intent; profile gate pending | Yes | Requests existing free-flight controls |
+| Debug sprint | Shift | Executable only in `RenderSandbox` | Yes | Requests multiplier; `Blizzlike335` ignores it |
+| Debug flight up/down/toggle | E/Q/Space | Executable only in `RenderSandbox` | Yes | Requests free flight; `Blizzlike335` remains grounded |
 
 ## Persistence, cache and migration
 
@@ -157,13 +172,20 @@ provide a settings migration once user settings are persisted.
 ## Verification
 
 - Unit/contract tests: `src/tools/verify_player_input.gd` validates all actions,
-  default bindings, axis cancellation/clamping/normalization and debug request flags.
+  both profile defaults, axis cancellation/clamping/normalization, turn routing,
+  safe profile fallback, fixture provenance and debug request flags.
 - Integration/E2E: `src/tests/scenes/player_input_regression.tscn` is loaded by
-  the verifier, which drives forward, camera-zoom and immediate sandbox-flight
-  actions through the real scene controller and also rejects direct
-  physical-key polling.
-- Fidelity evidence: current sandbox defaults retain W/S/A/D, E/Q, Shift, Space,
-  right mouse and wheel bindings. This is observable-regression coverage only.
+  the verifier, which drives sandbox forward/camera/flight plus compatibility
+  keyboard turn and right-mouse strafe through real scene controllers.
+- Profile integration: `verify_player_movement_capabilities.gd` drives sprint
+  and flight actions through real `RenderSandbox` and `Blizzlike335` scene instances.
+- Fidelity evidence: sanitized fixture `player_input_profile_335.json` pins the
+  private build-12340 `DefaultBindings.wtf`/`Bindings.xml` hashes and selected
+  movement/camera commands. TrinityCore 3.3.5 revision
+  `2853a621d6af91a803787a2b8a509f4ce3e0300d` pins the server-contract player
+  turn rate. WoWee revision `626243e937fb93965fa583a6507ed5a1aa7dda4b`
+  supports right-mouse A/D strafe routing. Both are compatibility references,
+  not direct original-client timing/conditional-behavior proof.
 - Performance budgets: no I/O, jobs or scene lookup per sample; one immutable
   intent allocation per physics tick.
 - Manual diagnostics: run the Eastern Kingdoms scene and remap one movement
@@ -184,15 +206,15 @@ provide a settings migration once user settings are persisted.
 |---|---|---|---|
 | Remappable current sandbox controls | Implemented | `verify_player_input.gd` action/default checks | Add persisted user binding settings later |
 | `PlayerInputSource → MoveIntent` seam | Implemented | Pure composition and controller boundary checks | Local movement consumer is now extracted |
-| Exact 3.3.5a default semantics | Unknown | No original-client binding fixture in this package | Capture build-12340 defaults and mouse-turn/strafe policy |
-| Production profile exclusion of sprint/flight | Partial | Debug actions are named explicitly | Add typed profile/capability gate in M02 |
+| Selected 3.3.5a movement defaults | Implemented | Pinned private-source hashes, sanitized selected bindings and profile regressions | Jump, autorun and left-button behavior remain planned |
+| Compatibility-profile exclusion of sprint/flight | Implemented | Typed capability and two real-scene regressions | Application shell selection remains future work |
 | Jump/fall/swim/fly gameplay semantics | Planned | M02 target and gameplay roadmap | Implement after terrain/movement state extraction |
 
 ## Known gaps and risks
 
-- The defaults preserve the pre-M02 sandbox behavior, not verified original-client semantics.
-- Sprint and free flight are still executable by the sandbox controller until a
-  typed build-profile gate is introduced.
+- Only selected movement/camera binding facts are implemented; the fixture explicitly records unimplemented defaults.
+- Input Map still exposes debug bindings process-wide; the movement consumer now
+  rejects their effects outside `RenderSandbox`.
 - Camera state is extracted; active collision remains an explicit planned policy.
 - There is no persisted user keybinding format or UI yet.
 
@@ -205,13 +227,17 @@ provide a settings migration once user settings are persisted.
 | `src/gameplay/input/player_input_actions.gd` | Stable project action names |
 | `src/gameplay/input/player_input_source.gd` | Engine Input Map adapter and pure composition |
 | `src/gameplay/movement/local_player_movement_controller.gd` | Scene-free movement consumer |
+| `src/gameplay/movement/player_movement_capabilities.gd` | Defense-in-depth execution gate for debug requests |
 | `src/scenes/player/third_person_camera_rig.gd` | Camera-action consumer and orbit/zoom state |
 | `src/scenes/player/third_person_wow_controller.gd` | Composition and input-event dispatcher |
 | `src/tests/scenes/player_input_regression.tscn` | Asset-free controller movement/camera regression fixture |
+| `src/tests/fixtures/player_input_profile_335.json` | Sanitized build-12340 binding and server turn-rate provenance |
 | `src/tools/verify_player_input.gd` | Headless contract/integration regression |
+| `src/tools/verify_player_movement_capabilities.gd` | Sandbox versus compatibility-profile integration regression |
 
 ## Related decisions and references
 
 - ADR: none; this implements the existing architecture and M02 seam.
 - Upstream/reference: `targets/02-player-decomposition.md`,
-  `targets/roadmap/04-gameplay-systems.md`, `docs/ARCHITECTURE.md`.
+  `targets/roadmap/04-gameplay-systems.md`, `docs/ARCHITECTURE.md`, and the
+  pinned sources recorded in `player_input_profile_335.json`.

docs/modules/render-budget-scheduler.md

@@ -0,0 +1,216 @@
+# Render Budget Scheduler
+
+## Metadata
+
+| Field | Value |
+|---|---|
+| Status | Implemented |
+| Target/work package | `M03-RND-SCHEDULER-001` |
+| Owners | Renderer workstream / M03 integrator |
+| Last verified | Worktree `work/sindo-main-codex/m03-render-budget-scheduler`, 2026-07-16 |
+| Profiles/capabilities | Runtime and Editor main-thread operation quotas; profile values supplied by streamer composition |
+
+## Purpose
+
+Issue a bounded number of permits for each renderer operation lane during one
+process frame. The scheduler centralizes quota accounting and teardown
+cancellation without taking ownership of queues or render work.
+
+## Non-goals
+
+- Own, sort, drain or cap the stored length of a renderer queue.
+- Submit, cancel or await worker and `ResourceLoader` tasks.
+- Execute callbacks or mutate the SceneTree, resources, caches or RIDs.
+- Adapt limits from elapsed time or create a general job/dependency framework.
+- Select renderer quality or compatibility profiles.
+
+## Context and boundaries
+
+```mermaid
+flowchart LR
+    Config[Streamer exported per-frame limits] --> Frame[operation limit snapshot]
+    Frame --> Scheduler[RenderBudgetScheduler]
+    Queues[StreamingWorldLoader owned queues] --> Drains[Ordered queue drains]
+    Scheduler -->|boolean permits| Drains
+    Drains --> Render[Main-thread finalize/attach/evict]
+    Shutdown[StreamingWorldLoader exit] -->|cancel| Scheduler
+    Scheduler -. does not own .-> Queues
+```
+
+Allowed dependencies are Godot value containers and `RefCounted`. The module
+must not depend on `Node`, `WorkerThreadPool`, `ResourceLoader`, `RenderingServer`,
+mutexes, renderer assets or streamer queue fields.
+
+## Public API
+
+| Symbol | Kind | Purpose | Thread/lifetime | Failure behavior |
+|---|---|---|---|---|
+| Lane constants | `StringName` constants | Stable operation categories used in the frame limit map | Process lifetime | Unknown lanes have zero permits |
+| `begin_frame` | Method | Replaces all limits and clears consumption diagnostics for one frame | Main thread; once before drains | Negative limits clamp to zero; cannot revive a cancelled instance |
+| `has_remaining_permit` | Query | Tests a lane without consuming | Main thread; current frame | Unknown/exhausted/cancelled returns `false` |
+| `try_consume_permit` | Mutation | Atomically checks and consumes one caller operation permit | Main thread; current frame | Unknown/exhausted/cancelled returns `false` |
+| `remaining_permits` | Query | Returns a lane's current unconsumed count | Main thread; current frame | Unknown/cancelled returns zero |
+| `consumed_permits_snapshot` | Query | Returns detached per-lane diagnostics | Caller owns returned dictionary | Mutation cannot affect scheduler state |
+| `cancel` | Lifecycle method | Permanently stops new permits and clears remaining limits | Main thread; renderer teardown | Idempotent; does not interrupt in-flight caller work |
+| `is_cancelled` | Query | Reports terminal lifecycle state | Scheduler lifetime | No failure |
+
+## Inputs and outputs
+
+| Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
+|---|---|---|---|---|---|
+| Input | `Dictionary[StringName, int]` operation limits | `StreamingWorldLoader` configuration snapshot | Scheduler | Copied by scheduler | One process frame |
+| Input | Lane ID | Ordered streamer drain | Scheduler | Constant value | One permit check |
+| Input | Cancellation | Streamer `_exit_tree` | Scheduler | Terminal flag | Renderer instance lifetime |
+| Output | Permit boolean | Scheduler | Streamer drain loop | Scalar | One attempted operation |
+| Output | Remaining count | Scheduler | Streamer/tests | Scalar | Current frame |
+| Output | Consumed snapshot | Scheduler | Diagnostics/tests | Detached caller-owned copy | Current frame snapshot |
+
+The scheduler has no I/O, logging, SceneTree, task, cache or GPU side effects.
+
+## Data flow
+
+```mermaid
+flowchart TD
+    Exports[Exported operation limits] --> Limits[_render_operation_limits_for_frame]
+    Limits --> Begin[begin_frame]
+    Begin --> Remaining[remaining permits by lane]
+    Queue[Non-empty caller-owned queue] --> Check[try_consume_permit]
+    Remaining --> Check
+    Check -->|true| Execute[Caller performs one operation]
+    Check -->|false| Defer[Operation remains queued]
+    Execute --> Consumed[consumed permits diagnostics]
+```
+
+## Lifecycle and state
+
+```mermaid
+stateDiagram-v2
+    [*] --> Ready
+    Ready --> FrameActive: begin_frame
+    FrameActive --> FrameActive: consume/check
+    FrameActive --> FrameActive: begin_frame resets limits
+    Ready --> Cancelled: cancel
+    FrameActive --> Cancelled: cancel
+    Cancelled --> Cancelled: begin_frame/check/cancel
+    Cancelled --> [*]
+```
+
+Cancellation is intentionally terminal. A new renderer scene creates a new
+scheduler instance; an old instance cannot accidentally resume after teardown.
+
+## Main sequence
+
+```mermaid
+sequenceDiagram
+    participant Stream as StreamingWorldLoader
+    participant Budget as RenderBudgetScheduler
+    participant Queue as Loader-owned queues
+    participant Render as SceneTree/RenderingServer
+    Stream->>Budget: begin_frame(operation limits)
+    loop existing fixed drain order
+        Stream->>Queue: inspect next operation
+        Stream->>Budget: try_consume_permit(lane)
+        Budget-->>Stream: true or false
+        Stream->>Render: execute one operation when true
+    end
+    Stream->>Budget: cancel() during _exit_tree
+    Budget-->>Stream: later permits rejected
+    Stream->>Stream: await tasks and release owned resources
+```
+
+## Ownership, threading and resources
+
+- `StreamingWorldLoader` owns every queue, task registry, cache, Node, Resource and RID.
+- The scheduler owns two small per-frame counter dictionaries and one terminal flag.
+- The streamer preserves operation order. In particular, chunk removals and
+  creations share `CHUNK_GEOMETRY`, with removals drained first.
+- All current scheduler calls occur on the Godot main thread. The service has no
+  mutex and is not safe for concurrent mutation.
+- A scheduler instance lives exactly as long as its loader instance.
+
+## Errors, cancellation and recovery
+
+| Condition | Detection | Behavior | Diagnostic | Recovery |
+|---|---|---|---|---|
+| Negative/zero limit | `begin_frame` clamp | Lane issues no permits | Contract verifier | Correct configuration or accept disabled lane |
+| Unknown lane | Permit lookup miss | Returns `false`/zero | Contract verifier | Add the lane to the frame snapshot |
+| Exhausted lane | Remaining count is zero | Work remains in caller queue for a later frame | Queue-depth/hitch metrics | Next `begin_frame` replenishes permits |
+| Renderer teardown | Streamer calls `cancel` before task waits | New permits stop immediately | Shutdown ownership regression | New scene creates a new scheduler |
+| In-flight operation at cancel | Caller already consumed permit | Scheduler does not interrupt it | Ownership docs | Caller completes/cleans it through existing shutdown path |
+
+This cancellation scope is permit issuance, not worker cancellation. Existing
+task/result staleness and shutdown waits remain streamer responsibilities.
+
+## Configuration and capabilities
+
+The streamer's existing exported values populate 16 lanes: tile finalization,
+terrain upgrade/control-splat/splat-cache/splat-build, water finalization, shared
+chunk geometry, tile-load starts, tile LOD create/remove, M2 animation/mesh
+finalization and build, WMO instance/group build, and detail synchronization.
+Defaults and quality-preset assignments are unchanged. `tile_finalize` retains
+its historical minimum of one; other negative values behave as zero.
+
+## Persistence, cache and migration
+
+The module is runtime-only and serializes nothing. It changes no cache, asset,
+scene, protocol or database format and requires no version bump or migration.
+
+## Diagnostics and observability
+
+- `consumed_permits_snapshot` exposes detached per-frame counts for tests and
+  future facade metrics without exposing mutable scheduler state.
+- Existing queue depths, named hitch sections and `HITCH`/`PERF` logs remain in
+  `StreamingWorldLoader`.
+- No scheduler logging occurs on the hot permit path.
+
+## Verification
+
+- `src/tools/verify_render_budget_scheduler.gd` covers exact exhaustion,
+  independent lanes, shared removal/create priority, frame reset, invalid/unknown
+  lanes, detached diagnostics, terminal cancellation and source boundaries.
+- The verifier performs 20,000 permit checks with a generous 150 ms regression
+  ceiling on the headless runner; this is a guard, not a renderer p95 claim.
+- Integration regressions must retain the seven renderer checkpoint plans and
+  existing focus/planner/facade contracts.
+- Fidelity evidence is behavior-preserving: exported values, process order,
+  cache versions and visual operations are unchanged. No build-12340 parity
+  claim follows from this extraction.
+
+## Extension points
+
+- Add facade consumption metrics using detached snapshots.
+- Move a service's queue drain behind its own boundary while retaining these lane IDs.
+- Add measured time-aware policy only after asset-backed p95/p99 evidence proves
+  fixed operation counts insufficient; do not embed callbacks in this scheduler.
+
+## Capability status
+
+| Capability | Status | Evidence | Gap/next step |
+|---|---|---|---|
+| Per-lane frame bounds | Implemented | Exact exhaustion and independent-lane contracts | Asset-backed p95/p99 baseline remains |
+| Shared removal/create priority | Implemented | Synthetic shared `CHUNK_GEOMETRY` contract | Other service priorities remain streamer-owned |
+| Teardown permit cancellation | Implemented | Terminal cancellation contract and loader source gate | Worker stale-result cancellation remains streamer-owned |
+| Detached consumption diagnostics | Implemented | Snapshot isolation contract | Not yet exposed through facade metrics |
+
+## Known gaps and risks
+
+- Queue storage length is not capped; only per-frame draining is bounded.
+- Worker concurrency and stale-result cancellation remain existing streamer logic.
+- Exact p95/p99 impact requires local extracted assets and paired baseline runs.
+- Lane IDs are dynamic dictionary keys; the verifier guards the current contract.
+
+## Source map
+
+| Path | Responsibility |
+|---|---|
+| `src/render/streaming/render_budget_scheduler.gd` | Scene-free lane counters, permits, diagnostics and cancellation |
+| `src/scenes/streaming/streaming_world_loader.gd` | Limit composition, fixed drain order, queue/resource ownership and operation execution |
+| `src/tools/verify_render_budget_scheduler.gd` | Asset-free behavior, dependency and bounded timing regression |
+
+## Related decisions and references
+
+- [`world-renderer.md`](world-renderer.md)
+- [`streaming-target-planner.md`](streaming-target-planner.md)
+- [`../../targets/03-renderer-facade.md`](../../targets/03-renderer-facade.md)
+- [`../../targets/roadmap/02-rendering-and-graphics.md`](../../targets/roadmap/02-rendering-and-graphics.md)
+- [`../CODING_STANDARD.md`](../CODING_STANDARD.md)

docs/modules/streaming-target-planner.md

@@ -0,0 +1,239 @@
+# Streaming Target Planner
+
+## Metadata
+
+| Field | Value |
+|---|---|
+| Status | Implemented |
+| Target/work package | `M03-RND-STREAMING-PLANNER-001` |
+| Owners | Renderer workstream / M03 integrator |
+| Last verified | `e887c3b`, 2026-07-15 |
+| Profiles/capabilities | Runtime and Editor preview ADT target selection; profile values supplied by caller |
+
+## Purpose
+
+Calculate which available ADT tiles are wanted and retained for one typed focus
+without accessing the SceneTree, worker tasks, renderer queues, caches or GPU
+resources. Runtime planning preserves prewarm, hysteresis and boundary-prefetch
+behavior; editor planning preserves the square preview radius.
+
+## Non-goals
+
+- Mutate load/finalize/eviction queues.
+- Prioritize queued tile paths by world distance.
+- Calculate chunk or tile LOD levels after a tile is loaded.
+- Own the available WDT tile catalog or cache paths.
+- Create, cancel or await jobs.
+- Implement M2, WMO, liquid or terrain attachment.
+
+## Context and boundaries
+
+```mermaid
+flowchart LR
+    Focus[GodotWorldPosition] --> Planner[StreamingTargetPlanner]
+    Policy[StreamingTargetPolicy] --> Planner
+    Catalog[Available tile keys from WDT/directory] --> Planner
+    Planner --> Plan[StreamingTargetPlan]
+    Plan --> Streamer[StreamingWorldLoader queue/state apply]
+    Streamer --> Queue[Tile load queue]
+```
+
+Allowed dependencies:
+
+- typed coordinate values and `CoordinateMapper`;
+- immutable planner policy/result contracts;
+- read-only available-tile key membership.
+
+Forbidden dependencies:
+
+- `Node`, SceneTree and viewport/camera discovery;
+- `WorkerThreadPool`, `ResourceLoader` and filesystem access;
+- `RenderingServer`, meshes, materials, nodes and RIDs;
+- gameplay, network, UI, editor UI or server adapters;
+- streamer queues, tile states and cache dictionaries.
+
+## Public API
+
+| Symbol | Kind | Purpose | Thread/lifetime | Errors |
+|---|---|---|---|---|
+| `StreamingTargetPlanner.plan_runtime` | Pure method | Builds wanted/retained sets with edge/corner prefetch | Any thread if caller does not mutate catalog concurrently; call-scoped | Empty catalog produces empty sets |
+| `StreamingTargetPlanner.plan_editor` | Pure method | Builds identical editor wanted/retained square sets | Same as runtime planning | Negative radius clamps to zero |
+| `StreamingTargetPolicy` | Immutable value | Captures radius margins and boundary threshold for one plan | Caller-owned, shareable | Values retain scene input; effective margins/threshold are clamped |
+| `visible_tile_radius` | Pure query | Resolves chunk-radius versus tile-radius visibility | Any thread/value lifetime | No failure |
+| `load_tile_radius` | Pure query | Adds non-negative prewarm margin | Any thread/value lifetime | No failure |
+| `retained_tile_radius` | Pure query | Adds non-negative hysteresis margin | Any thread/value lifetime | No failure |
+| `StreamingTargetPlan` | Immutable value | Holds focus tile and read-only wanted/retained key sets | Caller-owned plan lifetime | No failure |
+| `wanted_tile_keys` | Read-only query | Returns immutable wanted set | Plan lifetime | Mutation is rejected by Godot read-only Dictionary |
+| `retained_tile_keys` | Read-only query | Returns immutable retained set | Plan lifetime | Mutation is rejected by Godot read-only Dictionary |
+
+## Inputs and outputs
+
+| Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
+|---|---|---|---|---|---|
+| Input | `GodotWorldPosition` | `WorldRenderFacade`/streamer focus adapter | Planner | Immutable caller value | One plan |
+| Input | Available `<tile_x>_<tile_y>` keys | `StreamingWorldLoader` WDT/directory catalog | Planner membership checks | Loader-owned, read-only during call | Map session |
+| Input | `StreamingTargetPolicy` | Streamer configuration snapshot | Planner | Immutable caller value | One or more plans |
+| Input | Editor preview radius | Editor scene configuration | Planner | Scalar copy | One plan |
+| Output | `StreamingTargetPlan.focus_tile` | Planner/`CoordinateMapper` | Streamer diagnostics | Immutable typed coordinate | Plan lifetime |
+| Output | Wanted tile-key set | Planner | Streamer queue/state apply | Plan-owned read-only Dictionary | Plan lifetime |
+| Output | Retained tile-key set | Planner | Streamer hysteresis/state apply | Plan-owned read-only Dictionary | Plan lifetime |
+
+Side effects:
+
+- none;
+- no input mutation;
+- no logging, I/O, task submission, cache access, SceneTree or GPU work.
+
+## Data flow
+
+```mermaid
+flowchart TD
+    Position[GodotWorldPosition] --> Tile[CoordinateMapper.godot_to_adt_tile]
+    Position --> Local[CoordinateMapper.godot_to_adt_tile_local]
+    Policy[StreamingTargetPolicy] --> Radii[load and retained radii]
+    Policy --> Threshold[clamped boundary threshold]
+    Tile --> Centers[base prefetch center]
+    Local --> Centers
+    Threshold --> Centers
+    Centers --> Wanted[available keys within load radius]
+    Centers --> Retained[available keys within retained radius]
+    Catalog[Available tile keys] --> Wanted
+    Catalog --> Retained
+    Wanted --> Plan[StreamingTargetPlan]
+    Retained --> Plan
+    Tile --> Plan
+```
+
+## Lifecycle/state
+
+The planner is stateless. A call creates local center/set dictionaries, freezes
+the result dictionaries in `StreamingTargetPlan`, returns the plan and retains
+no reference to inputs or output. There is no retry, cancellation or shutdown
+state machine.
+
+## Main sequence
+
+```mermaid
+sequenceDiagram
+    participant Stream as StreamingWorldLoader
+    participant Planner as StreamingTargetPlanner
+    participant Mapper as CoordinateMapper
+    participant Plan as StreamingTargetPlan
+    Stream->>Planner: plan_runtime(catalog, typed focus, policy)
+    Planner->>Mapper: focus tile and tile-local position
+    Mapper-->>Planner: typed coordinates
+    Planner->>Planner: prefetch centers and available key sets
+    Planner->>Plan: freeze focus/wanted/retained result
+    Plan-->>Stream: immutable target plan
+    Stream->>Stream: apply queues, LOD and detail state
+```
+
+## Ownership, threading and resources
+
+- `StreamingWorldLoader` owns the available catalog and must not mutate it during a planning call.
+- `StreamingTargetPolicy` and typed focus remain caller-owned immutable values.
+- The planner owns temporary center/set values only until plan construction.
+- `StreamingTargetPlan` owns its read-only result dictionaries.
+- The planner creates no Node, Resource, RID, thread, mutex or task.
+- Current runtime calls occur on the main thread; scene-free contracts permit a
+  future worker call only after catalog publication/ownership is explicit.
+
+## Errors, cancellation and recovery
+
+| Failure | Detection | Behavior | Diagnostic | Recovery |
+|---|---|---|---|---|
+| Empty/unavailable catalog | No membership matches | Valid plan with empty sets | Streamer retains existing missing-data diagnostics | Load a valid WDT/directory catalog and replan |
+| Focus outside catalog/grid | Typed coordinate does not match keys | Valid focus tile with filtered empty/partial sets | Caller diagnostic if required | Supply valid focus/map or catalog |
+| Negative prewarm/retain margin | Policy effective-radius query | Margin clamps to zero | Contract test | Correct configuration if negative value was unintended |
+| Boundary threshold outside range | Policy query | Clamp to `0.0..0.49` | Contract test | Correct configuration or accept safe clamp |
+| Plan no longer current | New focus/config/catalog revision | Caller discards ephemeral plan | Streamer refresh diagnostics | Replan from current inputs |
+
+Cancellation is not applicable: planning is synchronous, bounded and owns no
+external work. A returned stale plan is simply not retained by the planner.
+
+## Configuration and capabilities
+
+| Setting/capability | Default source | Profile | Runtime mutable | Effect |
+|---|---|---|---|---|
+| `lod2_radius_chunks` | Streamer scene/profile | Renderer | Yes at composition/debug boundary | Converts chunk coverage to minimum ADT radius |
+| `lod2_tile_radius` | Streamer scene/profile | Renderer | Yes | Minimum visible ADT radius |
+| `warm_tile_margin` | Streamer scene/profile | Renderer | Yes | Extends chunk-derived visible radius |
+| `prewarm_tile_margin` | Streamer scene/profile | Renderer | Yes | Extends wanted/load radius |
+| `retain_tile_margin` | Streamer scene/profile | Renderer | Yes | Extends retained hysteresis radius |
+| `boundary_prefetch_threshold` | Streamer scene/profile | Renderer | Yes | Adds adjacent/corner prefetch centers near tile boundaries |
+| Editor preview radius | Editor scene | Authoring preview | Yes | Square wanted/retained preview set |
+
+The planner does not select `Blizzlike335` or `Enhanced`; it applies the values
+already selected by renderer composition.
+
+## Persistence, cache and migration
+
+- Planner contracts are runtime-only and are not serialized.
+- Existing tile keys and cache paths are unchanged.
+- No cache/resource/schema version bump or migration is required.
+
+## Diagnostics and observability
+
+- Logs remain emitted by `StreamingWorldLoader` after applying a plan.
+- `StreamingTargetPlan` exposes focus/wanted/retained data for deterministic tests.
+- Dedicated verifier reports case count, iteration count, total time and average plan time.
+- No correlation ID is required for synchronous ephemeral plans.
+
+## Verification
+
+- Unit/contract: `src/tools/verify_streaming_target_planner.gd` covers center
+  radii, edge/corner cross product, catalog filtering, clamps, editor behavior,
+  input/result ownership and scene-free dependencies.
+- Integration: streamer source gate confirms both runtime/editor delegation and
+  removal of `_predictive_focus_tiles` from the monolith.
+- Fidelity evidence: expected sets encode the pre-extraction formulas; renderer
+  checkpoint dry-run must retain all seven checkpoint plans.
+- Performance budget: 250 synthetic High-like corner plans average at most
+  `4.0 ms` each on the headless regression runner; measured result is recorded
+  in test output.
+- Manual diagnostics: unchanged `StreamingWorld` focus/wanted/queued log.
+
+## Extension points
+
+- Direction/velocity/frustum priority can extend policy/input only with fixtures
+  and a compatibility-safe default reproducing the current position-only plan.
+- Multi-focus planning may union additional typed centers without giving the
+  planner ownership of queues or consumers.
+- Queue ordering remains a separate scheduler/application responsibility.
+
+## Capability status
+
+| Capability | Status | Evidence | Gap/next step |
+|---|---|---|---|
+| Runtime wanted/retained sets | Implemented | Center/corner/catalog fixtures | Add paired traversal performance evidence |
+| Boundary prefetch centers | Implemented | Edge/corner cross-product fixture | Direction/velocity prediction not implemented |
+| Editor preview set | Implemented | Negative/radius-one fixtures | Editor viewport integration remains existing adapter |
+| Scene-free deterministic execution | Implemented | Dependency/source gate and 250-iteration run | Worker execution is unnecessary today |
+| Queue priority/LOD | Not in module | Preserved in streamer | Separate extraction packages |
+
+## Known gaps and risks
+
+- Tile-key sets preserve the streamer's internal string representation; a typed
+  catalog migration is deferred until it can remove, rather than duplicate, that source of truth.
+- Planner time scales with the union of square radii/prefetch centers. The
+  current bounded regression covers High-like corner input but not pathological custom radii.
+- Exact p95/p99 frame impact still requires renderer baseline runs with local assets.
+- Direction, velocity and camera frustum do not influence target selection yet.
+
+## Source map
+
+| Path | Responsibility |
+|---|---|
+| `src/render/streaming/streaming_target_planner.gd` | Pure runtime/editor set calculation and boundary centers |
+| `src/render/streaming/streaming_target_policy.gd` | Immutable radius/threshold snapshot and effective clamps |
+| `src/render/streaming/streaming_target_plan.gd` | Immutable typed focus and read-only result sets |
+| `src/scenes/streaming/streaming_world_loader.gd` | Planner composition and plan application to queues/state |
+| `src/tools/verify_streaming_target_planner.gd` | Asset-free behavior/dependency/performance regression |
+
+## Related decisions and references
+
+- [`world-renderer.md`](world-renderer.md)
+- [`../../targets/03-renderer-facade.md`](../../targets/03-renderer-facade.md)
+- [`../../targets/roadmap/02-rendering-and-graphics.md`](../../targets/roadmap/02-rendering-and-graphics.md)
+- [`../GODOT_BEST_PRACTICES.md`](../GODOT_BEST_PRACTICES.md)
+- [`../CODING_STANDARD.md`](../CODING_STANDARD.md)

docs/modules/terrain-chunk-geometry-queue-planner.md

@@ -0,0 +1,195 @@
+# Terrain Chunk Geometry Queue Planner
+
+## Metadata
+
+| Field | Value |
+|---|---|
+| Status | Implemented extraction |
+| Target/work package | M03 / `M03-RND-TERRAIN-CHUNK-QUEUE-001` |
+| Owners | Pure chunk geometry create/remove request calculation |
+| Last verified | Worktree `work/sindo-main-codex/m03-terrain-chunk-queue`, 2026-07-16 |
+| Profiles/capabilities | Existing chunk/tile LOD desired state; all profiles |
+
+## Purpose
+
+Compare loader-owned current chunk geometry with desired chunk/tile LOD state
+and produce fresh removal and nearest-first creation request arrays.
+
+## Non-goals
+
+- Retain, drain or bound queues, or own per-frame operation permits.
+- Create/remove Mesh, Node, material or RID resources.
+- Calculate desired chunk/tile LOD, parse ADT data or schedule worker tasks.
+- Change cache versions, renderer profiles or visible fidelity rules.
+- Provide a generic queue/operation framework.
+
+## Context and boundaries
+
+```mermaid
+flowchart LR
+    Current[Loader-owned tile/chunk state] --> Planner[TerrainChunkGeometryQueuePlanner]
+    Desired[Desired chunk and tile LOD state] --> Planner
+    Focus[GodotWorldPosition] --> Planner
+    Planner --> Remove[Stable-order remove requests]
+    Planner --> Create[Nearest-first create requests]
+    Remove --> Loader[StreamingWorldLoader queues]
+    Create --> Loader
+    Loader --> Budget[RenderBudgetScheduler permit]
+    Budget --> GPU[Existing Mesh/Node/RID side effects]
+```
+
+Allowed dependencies are typed Godot position and call-local scalar/container
+values. SceneTree, RenderingServer, ResourceLoader, worker APIs, gameplay,
+network, editor UI, files and persistent caches are forbidden.
+
+## Public API
+
+| Symbol | Kind | Purpose | Thread/lifetime | Errors |
+|---|---|---|---|---|
+| `TerrainChunkGeometryQueuePlanner.plan(tile_states, focus_position)` | Pure query | Return fresh `create_requests` and `remove_requests` arrays | Synchronous; caller owns result | Null/wrong focus returns two empty arrays |
+
+Script-identity validation uses a preload and therefore works from a cold Godot
+global-class cache.
+
+## Inputs and outputs
+
+| Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
+|---|---|---|---|---|---|
+| Input | Tile-state read model with current chunks and desired LODs | Streamer | Planner | Loader-owned; read only | One rebuild |
+| Input | Desired tile LOD | Tile LOD calculation | Planner | Scalar in loader state | One rebuild |
+| Input | Parsed chunk origins and tile fallback origin | ADT result/loader | Planner | Loader-owned; read only | Map session |
+| Input | `GodotWorldPosition` | Streamer focus adapter | Planner | Immutable caller reference | One rebuild |
+| Output | Remove `{tile, chunk}` records | Planner | Loader removal queue | Fresh caller array/dictionaries | Until drained/rebuilt |
+| Output | Create `{tile, chunk, lod, dist_sq}` records | Planner | Loader creation queue | Fresh nearest-first array/dictionaries | Until drained/rebuilt |
+
+Distance is horizontal XZ squared distance from the chunk origin, not its center.
+Y is intentionally ignored. A missing/sparse parsed origin falls back to the
+tile state's existing origin exactly as before extraction.
+
+## Data flow
+
+```mermaid
+flowchart TD
+    Start[plan] --> FocusValid{Typed focus?}
+    FocusValid -->|no| Empty[Return two empty arrays]
+    FocusValid -->|yes| Tile[Iterate tile state insertion order]
+    Tile --> TileLod{Desired tile LOD active?}
+    TileLod -->|yes| RemoveAll[Append every current chunk removal]
+    TileLod -->|no| Compare[Compare current and desired chunks]
+    Compare --> RemoveMissing[Append current chunks absent from desired]
+    Compare --> CreateMismatch[Append LOD-mismatched creates]
+    Compare --> CreateMissing[Append absent desired creates]
+    CreateMismatch --> Origin[Parsed chunk origin or tile fallback]
+    CreateMissing --> Origin
+    Origin --> Distance[Attach squared XZ distance]
+    RemoveAll --> Next[Next tile]
+    RemoveMissing --> Next
+    Distance --> Next
+    Next --> Sort[Sort creates nearest-first]
+    Sort --> Result[Return fresh arrays]
+```
+
+## Lifecycle/state
+
+The planner is stateless. Each loader queue rebuild supplies current read models
+and receives new arrays. The loader adopts and drains those arrays until another
+rebuild replaces them. Planner destruction requires no cleanup or cancellation.
+
+## Main sequence
+
+```mermaid
+sequenceDiagram
+    participant Loader as StreamingWorldLoader
+    participant Planner as TerrainChunkGeometryQueuePlanner
+    participant Budget as RenderBudgetScheduler
+    participant Render as Existing terrain finalization
+    Loader->>Planner: plan(tile states, typed focus)
+    Planner-->>Loader: fresh create/remove arrays
+    Loader->>Budget: request shared chunk_geometry permit
+    Budget-->>Loader: permit
+    Loader->>Render: pop_back removal first
+    Loader->>Budget: request shared chunk_geometry permit
+    Budget-->>Loader: permit
+    Loader->>Render: pop_front nearest creation
+```
+
+## Ownership, threading and resources
+
+- The planner owns only call-local arrays and dictionaries until return.
+- The loader owns adopted queue storage, drain ordering, tile/chunk state and all
+  Mesh/Node/material/RID side effects.
+- Calls and drains currently run on the renderer main thread. The planner has no
+  lock, task, retained resource or concurrent mutation.
+- Removal and creation continue to share the existing `chunk_geometry` budget lane.
+
+## Errors, cancellation and recovery
+
+| Failure | Detection | Behavior | Diagnostic | Recovery |
+|---|---|---|---|---|
+| Null/wrong focus script | Identity guard | Return empty request arrays | Contract verifier | Supply typed focus and rebuild |
+| Sparse/out-of-range chunk data | Origin resolver | Use tile fallback origin | Synthetic fixture | Normal ADT completion restores precise origin |
+| Tile LOD becomes desired | Desired tile LOD check | Remove every current chunk; no chunk creates | Queue metrics | Existing tile-LOD create path takes over |
+| Queue rebuild before drain | Loader lifecycle | Replace old desired-operation arrays | Existing queue metrics | Latest state wins |
+| Shutdown/map reset | Loader lifecycle | Loader clears queues; planner has nothing to cancel | Shutdown verifier | New session replans |
+
+## Configuration and capabilities
+
+The planner introduces no settings. It consumes already-calculated desired LOD
+state. Operation limits, profile defaults and removal-first drain order remain
+loader/scheduler configuration.
+
+## Persistence, cache and migration
+
+No serialization, cache entry or format changes. Baked terrain, control-splat
+and splat caches require no rebuild or migration.
+
+## Diagnostics and observability
+
+The planner emits no logs. Existing queue metrics observe the adopted arrays.
+The contract verifier reports semantic cases and bounded multi-tile timing.
+Asset-backed p95/p99 remains milestone acceptance work.
+
+## Verification
+
+- `verify_terrain_chunk_geometry_queue_planner.gd`: missing/mismatched/unchanged
+  chunks, tile-LOD removal, sparse origin fallback, XZ-only distance, stable
+  removals, nearest creates, invalid focus, loader boundary and bounded timing.
+- Existing LOD planner, terrain cache, facade, internal-access, manifest,
+  shutdown, scheduler, streaming and coordinate regressions remain required.
+- Fidelity evidence is exact branch/request/order preservation only. No new
+  build-12340 visual parity claim is made.
+
+## Extension points
+
+- Extract tile-LOD operation planning as its own bounded contract if justified.
+- Add explicit typed tile-state adapters only when more than one consumer exists.
+
+## Capability status
+
+| Capability | Status | Evidence | Gap/next step |
+|---|---|---|---|
+| Pure chunk create/remove planning | Implemented extraction | Asset-free semantic/source/timing verifier | Asset-backed p95/p99 pending |
+| Queue execution/resource ownership | Remains in loader | Drain source boundary and scheduler regression | Further terrain decomposition required |
+
+## Known gaps and risks
+
+- Raw tile/chunk dictionaries remain a transitional ADT adapter boundary.
+- The planner performs a second linear tile-state pass beside tile-LOD planning;
+  bounded synthetic timing is green, but asset-backed frame metrics are pending.
+- Equal-distance create ordering retains comparator behavior without a tie-breaker.
+- Terrain geometry finalization and state mutation remain monolithic.
+
+## Source map
+
+| Path | Responsibility |
+|---|---|
+| `src/render/terrain/terrain_chunk_geometry_queue_planner.gd` | Pure request calculation and nearest-first creation order |
+| `src/scenes/streaming/streaming_world_loader.gd` | Queue adoption, tile-LOD planning, budgets and render side effects |
+| `src/tools/verify_terrain_chunk_geometry_queue_planner.gd` | Semantic, boundary and timing regression |
+
+## Related decisions and references
+
+- [`terrain-chunk-lod-planner.md`](terrain-chunk-lod-planner.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/terrain-chunk-lod-planner.md

@@ -0,0 +1,179 @@
+# Terrain Chunk LOD Planner
+
+## Metadata
+
+| Field | Value |
+|---|---|
+| Status | Implemented extraction |
+| Target/work package | M03 / `M03-RND-TERRAIN-LOD-PLANNER-001` |
+| Owners | Pure desired chunk-LOD calculation only |
+| Last verified | Worktree `work/sindo-main-codex/m03-terrain-chunk-lod-planner`, 2026-07-16 |
+| Profiles/capabilities | Existing Performance/Balanced/High/Custom radii |
+
+## Purpose
+
+Calculate the desired terrain LOD for each populated parsed ADT chunk from one
+typed Godot-space focus and one immutable renderer-policy snapshot.
+
+## Non-goals
+
+- Own tile/chunk state, queues, budgets, tasks, Mesh, Node, material or RID.
+- Select tile LOD, create/remove geometry or apply a completed plan.
+- Normalize custom radii, change profile defaults or claim visual parity.
+- Parse ADT data or convert between WoW and Godot coordinate spaces.
+
+## Context and boundaries
+
+```mermaid
+flowchart LR
+    Focus[GodotWorldPosition] --> Planner[TerrainChunkLodPlanner]
+    Chunks[Parsed ADT chunk records] --> Planner
+    Config[Streamer LOD configuration] --> Policy[TerrainChunkLodPolicy]
+    Policy --> Planner
+    Planner --> Desired[chunk index to LOD 0/1/2]
+    Desired --> Loader[StreamingWorldLoader state adapter]
+    Loader --> Queue[Existing create/remove queues and budgets]
+```
+
+Allowed dependencies are the typed Godot position, immutable policy and
+call-local Array/Dictionary/Vector3 values. SceneTree, RenderingServer, gameplay,
+network, files, tasks and persistent caches are forbidden.
+
+## Public API
+
+| Symbol | Kind | Purpose | Thread/lifetime | Errors |
+|---|---|---|---|---|
+| `TerrainChunkLodPolicy.new(...)` | Immutable value | Snapshot enabled flag, three raw radii and chunk size | Caller-owned; one planning refresh | Values are preserved without normalization |
+| `TerrainChunkLodPlanner.plan(chunks, focus_position, policy)` | Pure query | Map populated source indices to LOD 0/1/2 | Synchronous; result caller-owned | Invalid/null typed inputs or disabled policy return empty |
+
+The planner validates scripts by preloaded identity so it works from a cold
+Godot global-class cache.
+
+## Inputs and outputs
+
+| Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
+|---|---|---|---|---|---|
+| Input | Parsed chunk array with `origin: Vector3` | ADT load result | Planner | Loader-owned; read only | One call |
+| Input | `GodotWorldPosition` | Streamer focus adapter | Planner | Immutable caller reference | One call |
+| Input | `TerrainChunkLodPolicy` | Streamer exported configuration | Planner | Immutable caller reference | One call |
+| Output | `{source_chunk_index: 0/1/2}` | Planner | Loader desired state | Fresh caller dictionary | One call |
+
+The Y coordinate is intentionally ignored. Empty chunk records and chunks beyond
+the third radius are absent from the result.
+
+## Data flow
+
+```mermaid
+flowchart TD
+    Start[plan] --> Valid{Typed inputs and enabled?}
+    Valid -->|no| Empty[Return empty dictionary]
+    Valid -->|yes| Radii[Square raw radius times chunk size]
+    Radii --> Iterate[Visit source chunk indices in order]
+    Iterate --> Populated{Record populated?}
+    Populated -->|no| Iterate
+    Populated -->|yes| Center[origin XZ plus half chunk]
+    Center --> Distance[Squared horizontal distance]
+    Distance --> Threshold{First inclusive threshold}
+    Threshold -->|LOD0/1/2| Record[Record source index]
+    Threshold -->|outside| Iterate
+    Record --> Iterate
+    Iterate --> Done[Return desired mapping]
+```
+
+## Lifecycle/state
+
+The planner is stateless. A policy is constructed for one refresh, read during
+synchronous planning and released. The returned dictionary is then owned by the
+loader state. There is no cancellation, recovery state or retained resource.
+
+## Main sequence
+
+```mermaid
+sequenceDiagram
+    participant Stream as StreamingWorldLoader
+    participant Policy as TerrainChunkLodPolicy
+    participant Planner as TerrainChunkLodPlanner
+    Stream->>Policy: snapshot enabled/radii/chunk size
+    Stream->>Planner: plan(chunks, typed focus, policy)
+    Planner-->>Stream: fresh desired LOD dictionary
+    Stream->>Stream: existing tile state, queue and budget application
+```
+
+## Ownership, threading and resources
+
+- Planner and policy own no engine resources, nodes, RIDs, tasks or caches.
+- The loader retains parsed chunks, desired state and every application side effect.
+- Current calls run synchronously on the renderer main thread; the pure inputs
+  also make isolated contract testing possible without a world scene.
+
+## Errors, cancellation and recovery
+
+| Failure | Detection | Behavior | Diagnostic | Recovery |
+|---|---|---|---|---|
+| Null/wrong focus or policy script | Identity guard | Empty plan | Contract verifier | Supply typed values next refresh |
+| Disabled chunk LOD | Policy flag | Empty plan; existing tile-LOD fallback applies | Existing renderer state | Enable profile option |
+| Empty chunk record | Record guard | Preserve sparse source index; omit record | None | Not an error |
+| Custom negative radius | No normalization | Existing squared-radius behavior is retained | Regression fixture | Change caller configuration if undesired |
+
+There is no asynchronous work or cancellation token.
+
+## Configuration and capabilities
+
+The policy snapshots `use_chunk_terrain_lods`, `lod0_radius_chunks`,
+`lod1_radius_chunks`, `lod2_radius_chunks` and the existing `CHUNK_SIZE`. Inclusive
+squared thresholds and raw custom values deliberately preserve prior behavior.
+
+## Persistence, cache and migration
+
+No serialization or cache format changes. Existing baked terrain, control-splat
+and splat cache versions remain unchanged and require no rebuild.
+
+## Diagnostics and observability
+
+The service emits no logs. The contract verifier reports semantic cases and a
+bounded synthetic timing. Asset-backed p95/p99 remains milestone acceptance work.
+
+## Verification
+
+- `verify_terrain_chunk_lod_planner.gd`: center and vertical invariance,
+  inclusive thresholds, sparse/outside chunks, disabled/custom-negative policy,
+  loader delegation and 250-by-256 bounded planning.
+- Renderer cache, facade, internal-access, baseline, scheduler, target-planner,
+  focus, ground-query and coordinate-boundary regressions remain required.
+- Fidelity evidence is formula preservation only; no new build-12340 visual
+  equivalence claim is made.
+
+## Extension points
+
+- Add measured direction/velocity only through an explicit policy/contract change.
+- Keep queue prioritization and LOD application as separately bounded services.
+
+## Capability status
+
+| Capability | Status | Evidence | Gap/next step |
+|---|---|---|---|
+| Pure chunk desired-LOD calculation | Implemented extraction | Asset-free semantic/source-boundary contract | Asset-backed p95/p99 pending |
+| Queue/state/finalization ownership | Remains in loader | Source-boundary regression | Further terrain decomposition required |
+
+## Known gaps and risks
+
+- Raw negative and non-monotonic custom radii retain historical squared/ordered
+  semantics, even though such settings may be surprising.
+- The planner is linear in parsed chunk count and allocates one result dictionary.
+- Terrain build, quality upgrades and geometry lifecycle remain monolithic.
+
+## Source map
+
+| Path | Responsibility |
+|---|---|
+| `src/render/terrain/terrain_chunk_lod_policy.gd` | Immutable configuration snapshot |
+| `src/render/terrain/terrain_chunk_lod_planner.gd` | Pure horizontal-distance plan |
+| `src/scenes/streaming/streaming_world_loader.gd` | Composition and plan application adapter |
+| `src/tools/verify_terrain_chunk_lod_planner.gd` | Contract, dependency and timing regression |
+
+## Related decisions and references
+
+- [`world-renderer.md`](world-renderer.md)
+- [`terrain-quality-mesh-cache.md`](terrain-quality-mesh-cache.md)
+- [`../../RENDER.md`](../../RENDER.md)
+- [`../../targets/roadmap/02-rendering-and-graphics.md`](../../targets/roadmap/02-rendering-and-graphics.md)

docs/modules/terrain-quality-mesh-cache.md

@@ -0,0 +1,198 @@
+# Terrain Quality Mesh Cache
+
+## Metadata
+
+| Field | Value |
+|---|---|
+| Status | Implemented extraction |
+| Target/work package | M03 / `M03-RND-TERRAIN-CACHE-SERVICE-001` |
+| Owners | Full-quality terrain revisit Mesh retention and LRU policy |
+| Last verified | Worktree `work/sindo-main-codex/m03-terrain-quality-cache`, 2026-07-16 |
+| Profiles/capabilities | Performance/Balanced/High/Custom capacity; session-memory only |
+
+## Purpose
+
+Retain eligible full-quality terrain Mesh references after ADT tile state unload,
+so a revisit can restore quality without flashing to a lower-quality fallback,
+while bounding retained references with the existing least-recently-used policy.
+
+## Non-goals
+
+- Parse/build terrain, own tile state or schedule quality-upgrade tasks.
+- Create/finalize Nodes or RIDs, mutate materials or choose terrain LOD.
+- Persist cache entries or change baked/control-splat/splat format versions.
+- Cache control-splat/splat sources whose active radius has separate ownership.
+- Provide a generic cache framework or change profile capacity defaults.
+
+## Context and boundaries
+
+```mermaid
+flowchart LR
+    Upgrade[Full-quality baked upgrade result] --> Loader[StreamingWorldLoader adapter]
+    Loader --> Cache[TerrainQualityMeshCache]
+    Cache -->|retained Mesh reference| Revisit[Reloaded tile state]
+    Revisit --> Finalize[Existing tile LOD/finalization path]
+    Splat[Control/splat quality sources] -. rejected .-> Cache
+```
+
+Allowed dependencies: `Mesh`, Dictionary/Array scalar containers and the loader
+adapter. Forbidden dependencies: Node/SceneTree/RID, tasks/mutexes, ADT parsing,
+gameplay/network/editor UI, files and persistent Resource cache ownership.
+
+## Public API
+
+| Symbol | Kind | Purpose | Thread/lifetime | Errors |
+|---|---|---|---|---|
+| `TerrainQualityMeshCache.store(tile_key, mesh, source, capacity)` | Command | Admit/touch a Mesh and trim oldest entries | Owning renderer thread/session | Returns false for rejected input or immediate zero-capacity eviction |
+| `TerrainQualityMeshCache.restore(tile_key)` | Query/touch | Return a fresh Mesh/source record and mark newest | Owning renderer thread | Empty on miss; invalid record is removed |
+| `TerrainQualityMeshCache.clear()` | Lifecycle command | Release all retained Mesh references and LRU keys | Reset/shutdown | Idempotent |
+| `TerrainQualityMeshCache.diagnostic_snapshot()` | Read model | Detached count and oldest-to-newest key/source list | Caller-owned result | Never exposes Mesh references |
+
+## Inputs and outputs
+
+| Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
+|---|---|---|---|---|---|
+| Input | Tile key | Streamer tile catalog/state | Cache index | Copied string | Map session |
+| Input | Full-quality Mesh | Baked upgrade/fallback path | Cache | Retained shared reference | Until eviction/clear |
+| Input | Quality source | Streamer quality adapter | Admission/restore | Copied string | Entry lifetime |
+| Input | Current capacity | Active renderer profile | Store trim | Scalar copy | One store |
+| Output | Fresh `{mesh, source}` record | Cache | Loader state adapter | Caller dictionary; shared Mesh reference | One restore |
+| Output | Detached diagnostics | Cache | Tests/future metrics | Caller-owned scalars | One query |
+
+Side effects are limited to retained reference and LRU container mutation. There
+is no scene, GPU, task, file, database, network or persistent-cache mutation.
+
+## Data flow
+
+```mermaid
+flowchart TD
+    Store[store tile/mesh/source/capacity] --> Admit{Valid key + Mesh + source?}
+    Admit -->|no| Reject[Return false]
+    Admit -->|yes| Touch[Insert/replace and touch newest]
+    Touch --> Trim[Evict oldest until count <= capacity]
+    Restore[restore tile] --> Hit{Valid admitted entry?}
+    Hit -->|no| Miss[Remove invalid / return empty]
+    Hit -->|yes| TouchRestore[Touch newest and return fresh record]
+    Clear[world reset/shutdown] --> Empty[Release all references and keys]
+```
+
+## Lifecycle/state
+
+```mermaid
+stateDiagram-v2
+    [*] --> Empty
+    Empty --> Populated: admitted store with capacity > 0
+    Populated --> Populated: store / restore touch / bounded eviction
+    Populated --> Empty: capacity zero store evicts all
+    Populated --> Empty: clear on reset/shutdown
+    Empty --> Empty: rejected store / miss / clear
+    Empty --> [*]
+    Populated --> [*]: owner releases cache
+```
+
+## Main sequence
+
+```mermaid
+sequenceDiagram
+    participant Upgrade as Terrain upgrade result
+    participant Loader as StreamingWorldLoader
+    participant Cache as TerrainQualityMeshCache
+    Upgrade->>Loader: full Mesh + baked_full source
+    Loader->>Cache: store(key, mesh, source, profile capacity)
+    Note over Loader,Cache: tile state may later unload
+    Loader->>Cache: restore(key) on tile creation/revisit
+    Cache-->>Loader: fresh record or empty
+    Loader->>Loader: apply Mesh/source to existing tile state
+    Loader->>Cache: clear() on world reset/shutdown
+```
+
+## Ownership, threading and resources
+
+- The cache owns its dictionary, ordered tile keys and retained Mesh references.
+- The loader retains tile state, async tasks/results, quality selection and all
+  Node/RID/material finalization.
+- Returned records are new dictionaries; their Mesh is a shared reference.
+- Calls currently occur on the main renderer thread. The service has no lock and
+  must not be mutated concurrently.
+- `clear` deterministically drops references during the existing world reset path.
+
+## Errors, cancellation and recovery
+
+| Failure | Detection | Behavior | Diagnostic | Recovery |
+|---|---|---|---|---|
+| Empty key/null Mesh | Store guard | Reject unchanged | Boolean/test | Fix caller result |
+| Splat/control source | Admission list | Reject unchanged | Boolean/test | Keep source in active-radius ownership |
+| Zero/negative capacity | Clamp and trim | Entry immediately evicted; cache empty | Snapshot/count | Increase profile capacity |
+| Miss/invalid entry | Restore validation | Remove invalid and return empty | Empty record | Existing loader fallback/rebuild |
+| World reset/shutdown | Loader lifecycle | Clear every reference/key | Shutdown regression | Refill during next session |
+
+There is no asynchronous work or cancellation token inside this service.
+
+## Configuration and capabilities
+
+| Setting/capability | Default | Profile | Runtime mutable | Effect |
+|---|---|---|---|---|
+| `terrain_quality_mesh_cache_limit` | Existing loader value | `0/24/48` in current presets | Read on every store | Maximum retained entries |
+| Admitted source | Non-splat (currently `baked_full`) | All | No hidden override | Revisit retention |
+| Excluded sources | `control_splat_cache`, `splat_cache`, `splat` | All | No | Preserve active quality ownership |
+
+## Persistence, cache and migration
+
+- This is an in-memory reference cache, not a serialized cache format.
+- `REQUIRED_BAKED_TILE_FORMAT_VERSION=5`, control splat v3 and splat v1 remain
+  loader/resource validation contracts and are unchanged.
+- No migration or rebuild is required. Entry keys retain the existing tile-key form.
+
+## Diagnostics and observability
+
+- Detached diagnostics report count and oldest-to-newest tile key/source entries.
+- Mesh, material, Node and RID references are deliberately absent.
+- Performance is bounded dictionary lookup plus one ordered-array erase/append;
+  no new optimization or scale claim is made.
+
+## Verification
+
+- `verify_terrain_quality_mesh_cache.gd`: admission, exclusions, Mesh identity,
+  source, LRU touch/eviction, detached diagnostics, negative capacity and clear.
+- Loader source boundary proves cache composition/delegation and removal of its
+  former LRU array/touch/trim implementation.
+- Existing shutdown, facade, internal-access, manifest, planner and scheduler
+  regressions remain required.
+- Fidelity: source rules, capacities and three loader adapter sites are unchanged;
+  no visible terrain or build-12340 parity change is claimed.
+
+## Extension points
+
+- Expose scalar cache counts through facade metrics when needed.
+- Move additional terrain responsibilities only as separate bounded services.
+- Replace ordered-array LRU only after measured scale evidence.
+
+## Capability status
+
+| Capability | Status | Evidence | Gap/next step |
+|---|---|---|---|
+| Bounded quality Mesh retention | Implemented extraction | Contract/LRU fixtures | Asset-backed memory/revisit timing pending |
+| Deterministic reset ownership | Implemented | Clear path plus shutdown regression | Full terrain service still monolithic |
+| Persistent terrain cache formats | Unchanged | Loader version constants | Separate acceptance audit remains |
+
+## Known gaps and risks
+
+- Ordered-array touch is linear in entry count, matching prior behavior.
+- Mesh memory size is not measured; capacity remains entry-count based.
+- Only revisit Mesh ownership moved; build/tasks/state/finalization remain loader-owned.
+- Asset-backed flash/revisit timing and p95/p99 evidence remain pending.
+
+## Source map
+
+| Path | Responsibility |
+|---|---|
+| `src/render/terrain/terrain_quality_mesh_cache.gd` | Session cache entries, LRU and admission |
+| `src/scenes/streaming/streaming_world_loader.gd` | Store/restore state adapter and reset lifecycle |
+| `src/tools/verify_terrain_quality_mesh_cache.gd` | Scene-free cache and loader-boundary regression |
+
+## Related decisions and references
+
+- [`world-renderer.md`](world-renderer.md)
+- [`terrain-query.md`](terrain-query.md)
+- [`../../RENDER.md`](../../RENDER.md)
+- [`../../targets/roadmap/02-rendering-and-graphics.md`](../../targets/roadmap/02-rendering-and-graphics.md)

docs/modules/terrain-query.md

@@ -5,10 +5,10 @@
 | Field | Value |
 |---|---|
 | Status | Implemented |
-| Target/work package | M02 / M02-GMP-TERRAIN-QUERY-001 |
+| Target/work package | M02 / M02-GMP-TERRAIN-QUERY-001; M03 renderer consumer `M03-RND-FACADE-GROUND-QUERY-001` |
 | Owners | Gameplay terrain-query contract; ADT adapter owns parsed tile cache |
 | Last verified | `a45d521`, 2026-07-14 |
-| Profiles/capabilities | Current sandbox ADT ground height; renderer/physics backend planned |
+| Profiles/capabilities | Current sandbox ADT ground height; loaded-render-mesh diagnostic query; authoritative physics backend planned |
 
 ## Purpose
 
@@ -47,6 +47,8 @@ Allowed dependencies:
 - Existing native `ADTLoader` at the ADT adapter boundary.
 - Dynamic dictionaries only inside the native-format adapter.
 - Player scene composition may inject any `TerrainQuery` implementation.
+- Renderer diagnostics reuse `GodotWorldPosition` through `WorldRenderFacade`
+  but return renderer-owned `RenderedGroundSample`, preserving the render/gameplay boundary.
 
 Forbidden dependencies:
 
@@ -65,6 +67,7 @@ Forbidden dependencies:
 | `AdtTerrainQuery.new(extracted_directory, map_directory_name, loader_override)` | Adapter constructor | Configures one map and optional test/data-source loader | Query lifetime | Production validates native loader and file presence lazily |
 | `AdtTerrainQuery.sample_ground_height(position)` | Adapter method | Loads/caches tile and interpolates ADT outer heights | Main thread; cache lives with query | Returns stable failure code |
 | `ThirdPersonWowController.set_terrain_query(query)` | Composition method | Replaces terrain backend independently of movement/presentation | Call before scene ready or on main thread | Null is rejected and current query retained |
+| `WorldRenderFacade.sample_ground_height(position)` | Separate renderer diagnostic API | Samples already loaded terrain Mesh and returns `RenderedGroundSample` without exposing streamer state | Main thread; immutable sample | Stable `render_terrain_*` unavailable code; not injected into player by default |
 
 ## Inputs and outputs
 
@@ -206,6 +209,9 @@ Existing ADT/native/cache format versions remain unchanged.
 ## Extension points
 
 - Streaming renderer or physics backend may implement `TerrainQuery` without changing player/movement.
+- The current facade intentionally uses a separate renderer-owned result and is
+  not a `TerrainQuery` implementation. A future adapter must explicitly translate
+  readiness/results and define gameplay authority before composition.
 - Future result may grow separate slope, surface, liquid or collision contracts;
   incompatible additions require a versioned contract rather than Dictionary fields.
 - Test/authoring data sources may use constructor loader override.
@@ -218,7 +224,8 @@ Existing ADT/native/cache format versions remain unchanged.
 | Typed replaceable ground-height query | Implemented | Contract and injected player regression | Integrate target checklist after review |
 | Existing ADT height interpolation | Implemented | Synthetic fractional-grid fixture | Compare terrain contact with build 12340 |
 | Per-tile success/failure cache | Implemented | Loader call-count regression | Add explicit invalidation only with authoring/hot reload |
-| Renderer/streaming cache backend | Planned | Boundary permits replacement | M03 renderer facade/public terrain backend |
+| Renderer loaded-mesh diagnostic backend | Implemented | M03 facade typed sample and detached snapshot contract | Not composed into gameplay; triangle Mesh ray is diagnostic only |
+| Authoritative renderer/physics backend | Planned | Boundary permits replacement | Define holes/slopes/collision/readiness semantics before gameplay composition |
 | Holes/slopes/collision | Planned | Outside height-only contract | Later movement/physics package |
 | Liquid/swim query | Planned | Outside contract | M09/M12 world gameplay |
 
@@ -240,6 +247,7 @@ Existing ADT/native/cache format versions remain unchanged.
 | `src/gameplay/terrain/terrain_query.gd` | Replaceable typed query boundary |
 | `src/gameplay/terrain/adt_terrain_query.gd` | Native ADT adapter, cache, chunk selection and interpolation |
 | `src/scenes/player/third_person_wow_controller.gd` | Query composition and existing ground-snap consumer |
+| `src/render/world_render_facade.gd` | Read-only loaded-render-mesh diagnostic consumer of typed position/sample contracts |
 | `src/tools/verify_terrain_query.gd` | Synthetic contract/cache/failure/injection regression |
 | `src/tests/scenes/player_input_regression.tscn` | Asset-free player composition fixture |
 

docs/modules/third-person-camera.md

@@ -5,9 +5,9 @@
 | Field | Value |
 |---|---|
 | Status | Implemented |
-| Target/work package | M02 / M02-RND-CAMERA-001 |
+| Target/work package | M02 / M02-RND-CAMERA-001 and M02-GMP-INPUT-PROFILE-335-001 consumer update |
 | Owners | Camera presentation state and CameraPivot/Camera3D lifecycle |
-| Last verified | `8c1cf9b`, 2026-07-14 |
+| Last verified | M02-GMP-INPUT-PROFILE-335-001 worktree, 2026-07-15 |
 | Profiles/capabilities | Current sandbox orbit/zoom; identity collision policy |
 
 ## Purpose
@@ -60,6 +60,7 @@ Forbidden dependencies:
 |---|---|---|---|---|
 | `ThirdPersonCameraRig` | `Node3D` component | Owns orbit/zoom state on CameraPivot | Main thread; scene-owned | Reports missing Camera3D |
 | `initialize_for_character(character_body)` | Composition method | Attaches yaw target and captures initial character yaw | Main thread after scene ready | Null leaves yaw target absent |
+| `synchronize_yaw_from_character()` | Composition method | Refreshes orbit yaw after keyboard movement turns the character | Main physics thread | Missing character leaves yaw unchanged |
 | `handle_camera_input(event)` | Input adapter | Applies capture/release/zoom/orbit actions | Main input thread | Returns whether camera consumed state |
 | `set_collision_policy(policy)` | Composition method | Replaces distance resolution policy | Main thread | Null rejected; old policy retained |
 | `refresh_camera_transform()` | Presentation update | Applies pivot pose and resolved camera distance | Main/physics thread | Missing camera leaves state but no Camera3D mutation |
@@ -77,6 +78,7 @@ Read-only rig state: `yaw_radians`, `pitch_radians`,
 | Input | Camera action `InputEvent` | Godot/player dispatch | Camera rig | Engine-owned event | One dispatch |
 | Input | Mouse relative pixels | Godot input | Camera rig | Engine-owned event | One dispatch |
 | Input | Character `Node3D` | Player composition | Camera rig | Scene-owned reference | Rig scene lifetime |
+| Input | Keyboard-turn synchronization | Player scene after yaw application | Camera rig | Synchronous notification | Current physics tick |
 | Input | Collision policy | Composition/test | Camera rig | Rig-held RefCounted | Until replacement |
 | Output | Character yaw | Camera rig | Player transform | Scene mutation | Orbit event |
 | Output | Pivot pitch/height | Camera rig | CameraPivot | Scene mutation | Refresh |
@@ -194,6 +196,8 @@ tools require no path migration.
 
 - State regression: initial yaw/pitch/distance/height/far plane, capture/release,
   mouse orbit, character yaw, pitch clamps and zoom clamps.
+- Input-profile integration verifies keyboard yaw synchronization, preventing a
+  later right-mouse orbit from restoring stale character yaw.
 - Policy regression: fixed-distance test policy changes Camera3D Z; identity
   policy restores requested distance; baseline policy contains no physics query.
 - Scene integration: Eastern Kingdoms, Kalimdor and asset-free regression scenes

docs/modules/world-entity-presentation.md

@@ -0,0 +1,254 @@
+# World Entity Presentation
+
+## Metadata
+
+| Field | Value |
+|---|---|
+| Status | Implemented boundary / Prototype visuals |
+| Target/work package | M03 / `M03-RND-FACADE-ENTITY-001` |
+| Owners | Renderer entity-presentation boundary and visual subtree lifecycle |
+| Last verified | Worktree `work/sindo-main-codex/m03-facade-entity`, 2026-07-16 |
+| Profiles/capabilities | Contract version 1; asset-free scene presentation only |
+
+## Purpose
+
+Accept immutable session-local entity visual snapshots through
+`WorldRenderFacade`, create or update renderer-owned visual subtrees idempotently,
+and remove them explicitly without making the renderer authoritative for entity,
+gameplay, network or content state.
+
+## Non-goals
+
+- Allocate `EntityId` or map it to `WowGuid`, display ID or server entry.
+- Present the separately composed local player through this service.
+- Define build-12340 model, equipment, animation, effects or visibility rules.
+- Own gameplay/world state, packet decoding, terrain or streaming decisions.
+- Provide asynchronous loading, pooling, batching, persistence or cache formats.
+
+## Context and boundaries
+
+```mermaid
+flowchart LR
+    WorldState[Future authoritative WorldState] --> Adapter[Entity presentation adapter]
+    Adapter --> Snapshot[EntityPresentationSnapshot v1]
+    Snapshot --> Facade[WorldRenderFacade]
+    Facade --> Presenter[WorldEntityPresenter]
+    Asset[PackedScene visual path] --> Presenter
+    Presenter --> Visual[Owned Node3D visual subtree]
+    LocalPlayer[Local player composition] -. separate boundary .-> Viewport[Rendered world]
+    Visual --> Viewport
+```
+
+Allowed dependencies:
+
+- immutable M01 `EntityId` and `GodotWorldPosition` values;
+- renderer-facing Godot transform and scene APIs;
+- an explicit repository/resource path selected outside the renderer;
+- `WorldRenderFacade` and main-thread runtime scene composition.
+
+Forbidden dependencies:
+
+- gameplay reducers, intents, combat/movement authority or entity allocation;
+- packet codecs, GUID interpretation, server DB access or Content Project writes;
+- streamer queues/tasks/caches, terrain query or camera/input state;
+- hidden autoload, SceneTree group service lookup or persisted session IDs.
+
+## Public API
+
+| Symbol | Kind | Purpose | Thread/lifetime | Errors |
+|---|---|---|---|---|
+| `EntityPresentationSnapshot.CONTRACT_VERSION` | Contract constant | Identifies additive snapshot contract version `1` | Compile/runtime constant | Incompatible changes require migration/ADR |
+| `EntityPresentationSnapshot.create(...)` | Immutable value factory | Captures identity, typed position, visual path, yaw, scale and visibility | Any thread to construct; caller-owned | Invalid value carries stable `entity_presentation_*` failure code |
+| `WorldRenderFacade.present_entity(snapshot)` | Command | Idempotently creates/updates/replaces one world visual | Main thread; world session | Returns `false` for invalid snapshot, missing service or failed scene creation |
+| `WorldRenderFacade.remove_entity(entity_id)` | Command | Removes one known session visual | Main thread; world session | Returns `false` for invalid or unknown identity |
+| `WorldRenderFacade.entity_presentation_snapshot()` | Diagnostic query | Returns detached scalar entity inventory | Main thread; caller-owned copy | Missing/invalid service returns empty snapshot with diagnostic |
+| `WorldEntityPresenter.present_entity(snapshot)` | Internal service command | Owns visual load, attach, transform update and replacement | Main thread; service lifetime | Failed replacement retains prior valid subtree |
+| `WorldEntityPresenter.remove_entity(entity_id)` | Internal service command | Detaches and schedules owned subtree deletion | Main thread | Unknown identity is unchanged/false |
+
+## Inputs and outputs
+
+| Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
+|---|---|---|---|---|---|
+| Input | Valid session-local `EntityId` | Future entity registry/adapter | Snapshot/presenter index | Immutable caller reference | One runtime session |
+| Input | `GodotWorldPosition` | World-state presentation adapter | Snapshot/presenter transform | Immutable caller reference | One snapshot |
+| Input | PackedScene resource path | Asset-selection adapter | Presenter | Copied string; resource remains Godot-owned | Until visual replacement |
+| Input | Finite yaw radians, positive scale, visibility | Presentation adapter | Presenter | Scalar copies | One snapshot |
+| Output | Owned Node3D subtree | Presenter | SceneTree/viewport | Presenter child ownership | Until replacement/removal/world teardown |
+| Output | Detached inventory dictionary | Presenter/facade | Diagnostics/tests | Caller-owned deep copy | One query |
+
+Side effects:
+
+- synchronously loads a PackedScene only for first presentation or visual-path change;
+- instantiates, attaches, transforms, detaches and queues visual Node3D subtrees;
+- does not mutate authoritative state, streamer queues, caches, files, DB or network;
+- does not retain caller snapshots after an entity entry is replaced or removed.
+
+## Data flow
+
+```mermaid
+flowchart TD
+    ReadModel[Entity visual read model] --> Validate[Validate typed immutable snapshot]
+    Validate -->|invalid| Reject[Return false; no scene mutation]
+    Validate -->|valid| Lookup[Lookup by EntityId debug key]
+    Lookup -->|same visual path| Transform[Update world transform and visibility]
+    Lookup -->|new or changed path| Instantiate[Load and instantiate Node3D]
+    Instantiate -->|failure| Retain[Retain previous valid visual]
+    Instantiate -->|success| Replace[Detach old, attach replacement]
+    Replace --> Transform
+    Transform --> Inventory[Detached diagnostics]
+    Remove[remove_entity] --> Detach[Detach and queue_free owned root]
+```
+
+## Lifecycle/state
+
+```mermaid
+stateDiagram-v2
+    [*] --> Absent
+    Absent --> Presented: valid present + successful instantiate
+    Absent --> Absent: invalid/missing visual
+    Presented --> Presented: same-path snapshot update
+    Presented --> Replacing: changed visual path
+    Replacing --> Presented: replacement succeeds
+    Replacing --> Presented: replacement fails; retain old
+    Presented --> Absent: remove_entity
+    Presented --> [*]: world/service teardown
+    Absent --> [*]: world/service teardown
+```
+
+## Main sequence
+
+```mermaid
+sequenceDiagram
+    participant Adapter as World-state adapter
+    participant Facade as WorldRenderFacade
+    participant Presenter as WorldEntityPresenter
+    participant Loader as Godot ResourceLoader
+    participant Tree as SceneTree
+    Adapter->>Facade: present_entity(immutable snapshot)
+    Facade->>Presenter: present_entity(snapshot)
+    alt same identity and visual path
+        Presenter->>Tree: update transform/visibility
+    else new or changed visual
+        Presenter->>Loader: load PackedScene
+        Loader-->>Presenter: scene or failure
+        alt scene is valid Node3D
+            Presenter->>Tree: detach old, attach/configure new
+        else load/shape failure
+            Presenter-->>Facade: false; old visual retained
+        end
+    end
+    Adapter->>Facade: remove_entity(EntityId)
+    Facade->>Presenter: remove_entity(EntityId)
+    Presenter->>Tree: detach + queue_free owned root
+```
+
+## Ownership, threading and resources
+
+- `EntityPresentationSnapshot` owns copied scalars/strings and immutable references
+  to caller-owned identity/position values; it owns no Node, Resource or RID.
+- `WorldEntityPresenter` owns its dictionary and every visual root attached below it.
+- A dictionary entry retains the latest snapshot only while the entity is presented;
+  diagnostics expose no Node, Resource or snapshot reference.
+- Scene load, instantiation, transform mutation, replacement and removal are main-thread only.
+- Successful replacement instantiates first, then detaches the previous root, so an
+  invalid/missing new asset cannot erase the last valid presentation.
+- Parent SceneTree teardown owns attached children; `_exit_tree` drops the index so
+  no stale lookup survives world unload.
+
+## Errors, cancellation and recovery
+
+| Failure | Detection | Behavior | Diagnostic | Recovery |
+|---|---|---|---|---|
+| Invalid identity/type | Snapshot/service validation | Reject without mutation | `entity_presentation_invalid_entity_id` | Supply valid session `EntityId` |
+| Non-finite position/yaw | Snapshot validation | Reject without mutation | Stable position/yaw failure code | Repair adapter read model |
+| Empty path or invalid scale | Snapshot validation | Reject without mutation | Stable path/scale failure code | Supply valid visual descriptor |
+| Missing/non-PackedScene asset | Resource existence/load check | New visual absent; old replacement retained | Named presenter warning | Restore asset mapping and resend snapshot |
+| Non-Node3D scene root | Instance type check | Free invalid instance; retain old | Named presenter warning | Fix visual scene root |
+| Unknown remove | Dictionary lookup | No mutation; return `false` | Caller command result | Reconcile registry/presentation lifecycle |
+| World teardown | Scene lifecycle | SceneTree frees children; index clears | Shutdown regression | Recreate service with next world |
+
+There is no background job to cancel. Synchronous asset load is an explicit
+prototype limitation and must be replaced/budgeted before network-scale use.
+
+## Configuration and capabilities
+
+| Setting/capability | Default | Profile | Runtime mutable | Effect |
+|---|---|---|---|---|
+| Contract version | `1` | All | No | Identity/path/position/yaw/scale/visibility full snapshot |
+| Present semantics | Idempotent by `EntityId` | Runtime/tools | No | Duplicate snapshots do not duplicate roots |
+| Resource loading | Synchronous on create/replace | Prototype only | No | Not accepted as frame-critical production path |
+| Local player | Separate composition | Current sandbox | No | Prevents facade service from owning gameplay player root |
+
+## Persistence, cache and migration
+
+- No snapshot, entity key or resource instance is persisted.
+- `EntityId` remains session-local and must never enter content/cache schemas.
+- Resource paths are current renderer adapter inputs, not stable content identity.
+- Contract version 1 is additive. Changing identity lifetime, coordinate basis or
+  persisted representation requires a migration and ADR.
+
+## Diagnostics and observability
+
+- `entity_presentation_snapshot()` reports contract version, entity count and a
+  sorted list of `EntityId.to_debug_key`, visual path and visibility.
+- The snapshot is deep-detached by the facade and contains no Node/Resource/RID.
+- Load/type failures include the visual path but never proprietary bytes.
+- Future performance telemetry should measure create/replace duration and active
+  entity/material/RID counts before introducing pooling or batching.
+
+## Verification
+
+- `src/tools/verify_world_entity_presentation.gd` covers eight value-contract and
+  fourteen lifecycle/ownership cases with repository-owned asset-free scenes.
+- `src/tools/verify_world_render_facade.gd` covers command delegation, detached
+  diagnostics and both runtime scene service paths.
+- Identity, coordinate, renderer-internal-access, shutdown, manifest, planner,
+  scheduler and documentation gates remain required.
+- Fidelity boundary: runtime emits no entity commands yet, so existing seven
+  checkpoint scenes remain unchanged. No build-12340 display/animation parity is claimed.
+
+## Extension points
+
+- AssetRepository/display-ID adapter that produces validated visual descriptors.
+- Async/budgeted load and main-thread finalize behind the same facade commands.
+- Animation/equipment/effect snapshots after build-12340 fixtures define behavior.
+- Spatial batching/MultiMesh only after profiling proves per-Node overhead.
+- Entity registry adapter that maps `WowGuid` to session `EntityId` outside render.
+
+## Capability status
+
+| Capability | Status | Evidence | Gap/next step |
+|---|---|---|---|
+| Typed entity visual input | Implemented contract | Versioned immutable validation fixtures | Asset/display mapping not implemented |
+| Present/update/remove lifecycle | Implemented boundary | Asset-free create/update/replace/remove tests | Network-scale async/budget path missing |
+| Deterministic ownership | Implemented | One presenter-owned root per EntityId; teardown checks | RID/material budgets remain future work |
+| WoW entity visual fidelity | Planned | No claim | Requires build-12340 display/equipment/animation fixtures |
+
+## Known gaps and risks
+
+- Synchronous PackedScene load may hitch and is not a production hot-path design.
+- Resource path is renderer adapter data, not stable authored content identity.
+- Full snapshots currently cover transform/visibility only, not animation/equipment/effects.
+- One Node3D per entity is unprofiled at world scale; batching is deliberately deferred.
+- The local player remains separately composed until gameplay/network architecture is ready.
+
+## Source map
+
+| Path | Responsibility |
+|---|---|
+| `src/render/entities/entity_presentation_snapshot.gd` | Immutable versioned entity visual input and validation |
+| `src/render/entities/world_entity_presenter.gd` | Main-thread entity visual ownership and lifecycle |
+| `src/render/world_render_facade.gd` | Stable public present/remove/diagnostic commands |
+| `src/tools/verify_world_entity_presentation.gd` | Snapshot and scene lifecycle regression |
+| `src/tests/scenes/character_presentation_model_fixture.tscn` | Primary asset-free visual fixture |
+| `src/tests/scenes/world_entity_visual_replacement_fixture.tscn` | Replacement asset-free visual fixture |
+| `src/scenes/streaming/*_streaming.tscn` | Runtime facade/service composition |
+
+## Related decisions and references
+
+- [`world-renderer.md`](world-renderer.md)
+- [`domain-identities.md`](domain-identities.md)
+- [`coordinate-mapping.md`](coordinate-mapping.md)
+- [`../../targets/roadmap/02-rendering-and-graphics.md`](../../targets/roadmap/02-rendering-and-graphics.md)
+- [`../ARCHITECTURE.md`](../ARCHITECTURE.md)
+- [`../GODOT_BEST_PRACTICES.md`](../GODOT_BEST_PRACTICES.md)

docs/modules/world-renderer.md

@@ -5,9 +5,9 @@
 | Field | Value |
 |---|---|
 | Status | Partial |
-| Target/work package | M00 baseline; `M01-RND-STREAMING-FOCUS-001`; `M01-QAR-SERVER-SPAWN-RENDERER-001`; декомпозиция M02–M03 |
+| 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-RND-M2-UNIQUE-REGISTRY-001` |
 | Owners | Renderer workstream / milestone integrator |
-| Last verified | Worktree `work/sindo-main-codex/m01-server-spawn-renderer`, 2026-07-13 |
+| Last verified | Worktree `work/sindo-main-codex/m03-m2-unique-registry`, 2026-07-16 |
 | Profiles/capabilities | `Performance`, `Balanced`, `High`, `Custom`; Blizzlike fidelity incomplete |
 
 ## Purpose
@@ -32,15 +32,35 @@ flowchart LR
     SpawnFixture[Pinned server spawn fixture] --> SpawnManifest[Spawn render manifest]
     SpawnManifest --> Capture
     Adapter --> Focus
-    Focus --> Loader[StreamingWorldLoader]
+    Focus --> Facade[WorldRenderFacade]
+    Facade --> Loader[StreamingWorldLoader internal]
+    Loader --> Planner[StreamingTargetPlanner]
+    Planner --> TargetPlan[StreamingTargetPlan]
+    TargetPlan --> Loader
+    Loader --> Budget[RenderBudgetScheduler]
     Assets[Extracted WDT/ADT/M2/WMO/BLP] --> Native[Native loaders]
     Cache[Baked terrain/M2/WMO caches] --> Loader
+    Loader --> TerrainCache[TerrainQualityMeshCache]
+    TerrainCache --> Loader
+    Loader --> ChunkLod[TerrainChunkLodPlanner]
+    ChunkLod --> Loader
+    Loader --> ChunkQueue[TerrainChunkGeometryQueuePlanner]
+    ChunkQueue --> Loader
+    Loader --> M2Registry[M2UniquePlacementRegistry]
+    M2Registry --> Loader
     Native --> Parsed[Parsed tile/model data]
     Parsed --> Loader
     Loader --> Scene[SceneTree nodes]
     Loader --> RS[RenderingServer RIDs/MultiMesh]
-    Sky[DBC sky/light data] --> SkyController[WowSkyController]
+    EnvironmentState[World time producer] --> EnvironmentSnapshot[WorldEnvironmentSnapshot]
+    EnvironmentSnapshot --> Facade
+    Facade --> SkyController[WowSkyController]
+    Sky[DBC sky/light data] --> SkyController
     SkyController --> Scene
+    EntityState[Entity visual read model] --> EntitySnapshot[EntityPresentationSnapshot]
+    EntitySnapshot --> Facade
+    Facade --> EntityPresenter[WorldEntityPresenter]
+    EntityPresenter --> Scene
 ```
 
 Allowed dependencies:
@@ -60,36 +80,74 @@ Forbidden dependencies:
 
 ## Public API
 
-Текущая система ещё не имеет стабильного facade. Фактический integration surface — `StreamingWorldLoader` Node3D и exported properties. M03 должен заменить этот surface на `WorldRenderFacade`.
+Runtime, capture and probe callers use `WorldRenderFacade` for focus, immutable
+environment/entity presentation input, metrics and rendered-ground diagnostics.
+`StreamingWorldLoader`, `WowSkyController` and `WorldEntityPresenter` remain
+internal scene implementations.
+Gameplay modules and Godot `EditorPlugin` package sources are repository-gated
+from externally reading/writing loader-private queue, task, cache and tile-state fields.
 
 | Symbol | Kind | Purpose | Thread/lifetime | Errors |
 |---|---|---|---|---|
 | `map_name` | Exported property | WDT/map directory name | Set before world load | Missing WDT produces diagnostic/empty world |
 | `extracted_dir` | Exported property | Root of legally extracted client data | Session lifetime | Missing files reported per loader path |
 | `StreamingFocus` | Immutable value | Typed Godot-basis position without Node/Camera dependency | Any thread; caller-owned reference | Null position is a caller contract violation |
-| `streaming_focus_source_path` | Exported adapter property | Samples any explicit `Node3D` source into `StreamingFocus` | Main thread, scene lifetime | Missing/wrong node warns once and retains prior focus |
-| `set_streaming_focus` | Public method | Accepts focus from app/editor/tool composition | Main thread/session | Null focus is ignored by refresh until replaced |
-| `refresh_streaming_focus` | Public method | Samples configured source and applies refresh thresholds | Main thread/session | Returns `false` when no valid focus exists |
+| `WorldRenderFacade.streaming_focus_source_path` | Exported adapter property | Samples any explicit `Node3D` source into `StreamingFocus` | Main thread, scene lifetime | Missing/wrong node warns once and retains prior focus |
+| `WorldRenderFacade.set_streaming_focus` | Public method | Accepts focus from app/editor/tool composition | Main thread/session | Missing internal renderer is diagnosed; no state is duplicated |
+| `WorldRenderFacade.refresh_streaming_focus` | Public method | Samples configured source and delegates existing refresh thresholds | Main thread/session | Returns `false` when dependency/focus is unavailable |
+| `WorldRenderFacade.renderer_metrics_snapshot` | Public method | Returns a deep-detached queue/cache/activity snapshot | Main thread/caller-owned result | Missing/invalid implementation result returns empty snapshot with diagnostic |
+| `WorldRenderFacade.sample_ground_height` | Public read-only query | Samples already loaded render terrain at a typed Godot world position | Main thread; immutable caller-held result | Stable unavailable code for missing mesh/intersection/facade; not gameplay authority |
+| `WorldRenderFacade.renderer_ground_query_snapshot` | Public diagnostic query | Returns ground height plus detached tile/readiness context without exposing mutable state | Main thread; caller-owned deep copy | Missing/invalid renderer returns empty snapshot with diagnostic |
+| `WorldEnvironmentSnapshot.at_time_of_day` | Immutable value factory | Normalizes a finite authoritative time into `[0, 24)` hours | Any thread; caller-held value | Non-finite input creates invalid value with `environment_time_not_finite` |
+| `WorldRenderFacade.apply_environment_snapshot` | Public command | Delegates exact world time to the scene-owned DBC sky controller | Main thread; snapshot remains caller-owned | Returns `false` for invalid input or missing/incompatible controller |
+| `WorldRenderFacade.streaming_world_loader_path` | Internal adapter property | Resolves the existing implementation without exposing it to consumers | Main thread, scene lifetime | Missing method/path produces one diagnostic until recovery |
+| `WorldRenderFacade.world_environment_controller_path` | Internal adapter property | Resolves the existing `WowSkyController` without exposing it to consumers | Main thread, scene lifetime | Missing method/path produces one diagnostic until recovery |
+| `EntityPresentationSnapshot.create` | Immutable value factory | Validates contract-v1 identity, typed position, visual path, yaw, scale and visibility | Any thread; caller-owned | Stable invalid code; never mutates scene |
+| `WorldRenderFacade.present_entity` | Public command | Idempotently creates/updates/replaces one session entity visual | Main thread/session | Returns false for invalid input, missing service or visual load/type failure |
+| `WorldRenderFacade.remove_entity` | Public command | Removes one known session entity visual | Main thread/session | Invalid/unknown identity returns false |
+| `WorldRenderFacade.entity_presentation_snapshot` | Public diagnostic query | Returns detached scalar entity inventory | Main thread/caller-owned copy | Missing/invalid service returns empty dictionary with diagnostic |
+| `WorldRenderFacade.world_entity_presenter_path` | Internal adapter property | Resolves renderer-owned entity visual service | Main thread/scene lifetime | Missing methods/path produces one diagnostic until recovery |
 | `camera_path` | Exported property | Camera used only by optional automatic overview positioning | Main thread, scene lifetime | Missing camera skips automatic positioning |
 | `quality_preset` | Exported property | Applies renderer budgets/radii | Before/at runtime depending property | Invalid combination should be diagnosed |
 | `runtime_stats_enabled` | Exported property | Enables periodic performance snapshot | Runtime mutable | Logging overhead only |
 | `hitch_profiler_enabled` | Exported property | Enables named hitch sections | Runtime mutable | Logging overhead only |
+| `TerrainQualityMeshCache.store/restore/clear` | Internal terrain service | Owns admitted full-quality revisit Mesh references and LRU | Renderer thread/map session | Rejected/missed entry leaves loader fallback unchanged |
+| `TerrainChunkLodPlanner.plan` | Internal pure terrain query | Maps populated parsed chunk indices to desired LOD 0/1/2 | Synchronous per target refresh | Invalid/disabled input returns empty for existing tile-LOD fallback |
+| `TerrainChunkGeometryQueuePlanner.plan` | Internal pure terrain query | Produces chunk create/remove requests from current and desired state | Synchronous per queue rebuild | Invalid focus returns empty arrays |
+| `M2UniquePlacementRegistry.reserve/release/clear` | Internal M2 service | Owns positive cross-tile ADT placement-ID reservations | Renderer thread/map session | Invalid/unkeyed/non-owner inputs preserve documented fallback |
 
-Публичным contract не считаются внутренние dictionaries, queues, job records и generated node names.
+Публичным contract не считаются `StreamingWorldLoader` methods/properties,
+внутренние dictionaries, queues, job records и generated node names. Scene-owned
+loader configuration remains transitional composition data, not a caller API.
 
 ## Inputs and outputs
 
 | Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
 |---|---|---|---|---|---|
-| Input | `StreamingFocus` | Player/spectator/editor/capture adapter | `StreamingWorldLoader` | Immutable caller value | Main thread/session |
-| Input | Focus-source `NodePath` | Runtime/test scene composition | Loader source adapter | Scene-owned node, sampled position | Main thread/scene lifetime |
+| Input | `StreamingFocus` | Player/spectator/editor/capture adapter | `WorldRenderFacade` | Immutable caller value | Main thread/session |
+| Input | Focus-source `NodePath` | Runtime/test scene composition | `WorldRenderFacade` source adapter | Scene-owned node, sampled position | Main thread/scene lifetime |
+| Input | Ground-query `GodotWorldPosition` | Renderer probe/future adapter | `WorldRenderFacade` | Immutable caller-held value | One main-thread query |
+| Input | `WorldEnvironmentSnapshot` | World-state/capture adapter | `WorldRenderFacade` / `WowSkyController` | Immutable caller-held value; not retained | One main-thread update |
+| Input | `EntityPresentationSnapshot` | Future world-state/preview adapter | `WorldRenderFacade` / entity presenter | Immutable caller-held full visual snapshot | One main-thread present/update |
+| Input | `EntityId` removal command | Future entity registry/adapter | `WorldRenderFacade` / entity presenter | Immutable session-local value | One main-thread removal |
 | Input | Map/configuration | Scene/app/editor | `StreamingWorldLoader` | Caller config, copied/read | Main thread/session |
 | Input | WDT/ADT/M2/WMO/BLP bytes | Extracted asset repository | Native loaders/builders | Loader result owns parsed data | Worker or controlled load |
 | Input | Baked resources | Cache build tools | Streamer/builders | Shared immutable resource/cache entry | Session/cache lifetime |
 | Test input | Server-spawn render manifest | Coordinate fixture/verifier | Checkpoint capture tool | Repository-owned diagnostic data | Test-process lifetime |
-| Output | Desired tile/detail operations | Streaming planner inside loader | Finalize queues | Loader-owned | Cross-frame |
+| Output | `StreamingTargetPlan` | `StreamingTargetPlanner` | Streamer queue/state apply | Immutable ephemeral value | One refresh |
+| Internal control | Per-frame lane limits and boolean permits | Streamer configuration / `RenderBudgetScheduler` | Ordered streamer drains | Scheduler-owned counters | Main thread/frame |
+| Internal cache | Full-quality terrain Mesh/source | Loader terrain upgrade / `TerrainQualityMeshCache` | Revisited tile state | Cache-retained Mesh reference | Map session until eviction/reset |
+| Internal plan | Parsed chunks, typed focus and immutable chunk-LOD policy | Loader / `TerrainChunkLodPlanner` | Loader desired state | Fresh dictionary; no retained resources | One target refresh |
+| Internal plan | Current/desired chunk state and typed focus | Loader / `TerrainChunkGeometryQueuePlanner` | Loader chunk queues | Fresh request arrays; no retained resources | One queue rebuild |
+| Internal registry | Tile key and M2 placement unique IDs | Loader / `M2UniquePlacementRegistry` | Filtered grouping input and tile retry state | Registry-owned strings; fresh result arrays | Map session |
+| 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 | Metrics/diagnostics | Hitch/stat instrumentation | Logs/baseline tools | Immutable records | Periodic/frame |
+| Output | Detached renderer metrics | `WorldRenderFacade` | Capture/baseline tools | Caller-owned deep copy | On demand |
+| Output | `RenderedGroundSample` | `WorldRenderFacade`/loaded terrain | Renderer diagnostics | Immutable caller-held value | One query |
+| Output | Detached rendered-ground snapshot | `WorldRenderFacade` | Terrain-height probe | Caller-owned deep copy | One query |
+| Output | Entity visual Node3D subtree | `WorldEntityPresenter` | SceneTree/viewport | Presenter-owned child | Until replace/remove/teardown |
+| Output | Detached entity inventory | `WorldRenderFacade` | Diagnostics/tests | Caller-owned deep copy | One query |
+| Output | Logs/diagnostics | Hitch/stat instrumentation | Logs/baseline tools | Immutable records | Periodic/frame |
 | Test output | Diagnostic spawn marker and cold/warm PNGs | Checkpoint capture tool | Human/integrator review | SceneTree marker; `user://` files | One capture process |
 
 Side effects:
@@ -104,7 +162,7 @@ Side effects:
 
 ```mermaid
 flowchart TD
-    P[Player/spectator Node3D] --> A[Explicit scene adapter]
+    PlayerSource[Player/spectator Node3D] --> A[Explicit scene adapter]
     C[Capture camera] --> A
     SF[Pinned server spawn] --> SM[Validated spawn manifest]
     SM --> C
@@ -112,23 +170,45 @@ flowchart TD
     E[Editor viewport] --> EA[Editor adapter]
     A --> F[StreamingFocus]
     EA --> F
-    F --> T[Compute desired ADT tiles]
-    WDT[WDT tile catalog] --> T
+    F --> RF[WorldRenderFacade]
+    RF --> Planner[StreamingTargetPlanner]
+    Planner --> T[StreamingTargetPlan apply]
+    WDT[WDT tile catalog] --> Planner
     T --> Q[Tile load queue]
-    Q --> P[Worker parse/cache load]
-    P --> R[Result queues]
-    R --> B[Per-frame budget scheduler]
+    Q --> Parse[Worker parse/cache load]
+    Parse --> R[Result queues]
+    R --> TerrainCache[TerrainQualityMeshCache store]
+    TerrainCache --> Revisit[Revisited tile state restore]
+    R --> ChunkLod[TerrainChunkLodPlanner]
+    ChunkLod --> DesiredChunkLod[Desired chunk LOD state]
+    DesiredChunkLod --> ChunkQueue[TerrainChunkGeometryQueuePlanner]
+    ChunkQueue --> B
+    R --> M2Registry[M2UniquePlacementRegistry reserve]
+    M2Registry --> M2
+    R --> B[RenderBudgetScheduler permits]
     B --> Terrain[Terrain attach/upgrade]
     B --> M2[M2 group/MultiMesh attach]
     B --> WMO[WMO instance/group attach]
     B --> Liquid[Liquid attach]
+    Loaded[Loaded terrain Mesh and Transform] --> Ground[Facade ground query]
+    Ground --> GroundSample[RenderedGroundSample / detached diagnostics]
+    WorldTime[Authoritative/test time] --> EnvironmentSnapshot[WorldEnvironmentSnapshot]
+    EnvironmentSnapshot --> RF
+    RF --> SkyController[WowSkyController]
+    DBC[Light/Area/Skybox DBC] --> SkyController
+    SkyController --> World
+    EntityReadModel[Entity visual read model] --> EntitySnapshot[EntityPresentationSnapshot]
+    EntitySnapshot --> RF
+    RF --> EntityPresenter[WorldEntityPresenter]
+    EntityAsset[PackedScene path] --> EntityPresenter
+    EntityPresenter --> World
     Terrain --> World[Godot world]
     M2 --> World
     WMO --> World
     Liquid --> World
     Marker --> World
-    F --> E[Eviction/retention decisions]
-    E --> World
+    F --> Eviction[Eviction/retention decisions]
+    Eviction --> World
 ```
 
 ## Lifecycle/state
@@ -155,18 +235,37 @@ stateDiagram-v2
 sequenceDiagram
     participant Source as Player/Editor/Capture source
     participant Focus as StreamingFocus adapter
-    participant Stream as StreamingWorldLoader
+    participant Facade as WorldRenderFacade
+    participant Stream as StreamingWorldLoader internal
+    participant Planner as StreamingTargetPlanner
     participant Worker as Worker task
-    participant Budget as Main-thread budget
+    participant Budget as RenderBudgetScheduler
     participant Render as SceneTree/RenderingServer
     Source->>Focus: sample explicit Godot position
-    Focus->>Stream: set/refresh typed focus
-    Stream->>Stream: desired tiles and priorities
+    Focus->>Facade: set/refresh typed focus
+    Facade->>Stream: delegate focus and refresh
+    Stream->>Planner: typed focus, catalog and target policy
+    Planner-->>Stream: immutable wanted/retained plan
+    Stream->>Stream: queue priority and loaded-tile LOD/detail state
     Stream->>Worker: parse/load tile and detail data
     Worker-->>Stream: immutable result
-    Stream->>Budget: enqueue finalize operations
-    Budget->>Render: attach bounded terrain/M2/WMO/liquid work
+    Stream->>Budget: begin_frame(operation limits)
+    Stream->>Budget: try_consume_permit(lane)
+    Budget-->>Stream: true while lane remains bounded
+    Stream->>Render: attach permitted terrain/M2/WMO/liquid work
     Stream->>Render: evict outside retention range
+    Source->>Facade: sample_ground_height(typed position)
+    Facade->>Stream: sample loaded render terrain
+    Stream-->>Facade: RenderedGroundSample / diagnostic snapshot
+    Source->>Facade: apply_environment_snapshot(exact time)
+    Facade->>Render: delegate to WowSkyController
+    Render->>Render: freeze local clock; retain DBC sampling/apply rules
+    Source->>Facade: present_entity(full visual snapshot)
+    Facade->>Render: delegate to WorldEntityPresenter
+    Render->>Render: create/update/replace owned entity root
+    Source->>Facade: remove_entity(EntityId)
+    Facade->>Render: detach and queue_free owned root
+    Stream->>Budget: shutdown: cancel permit issuance
     Stream->>Worker: shutdown: wait for WorkerThreadPool tasks
     Stream->>Stream: shutdown: finish registered ResourceLoader requests
     Stream->>Render: clear queues and owned tree nodes/RIDs
@@ -176,6 +275,38 @@ sequenceDiagram
 ## Ownership, threading and resources
 
 - `StreamingWorldLoader` владеет tile states, queues, task registries, active world instances и render caches session scope.
+- `WorldRenderFacade` owns only scene-relative adapter paths. It does not own the
+  streamer, environment controller, focus source, returned metrics, queues,
+  caches, nodes or RIDs.
+- `WorldEnvironmentSnapshot` is an immutable caller-owned scalar value. Neither
+  facade nor sky controller retains it; the controller copies normalized hours
+  into its existing fixed-clock fields on the main thread.
+- `WowSkyController` continues to own DBC sampling state and mutations of its
+  duplicated Godot `Environment`, sun, skybox node and world shader globals.
+- `WorldEntityPresenter` owns one optional visual Node3D subtree per presented
+  `EntityId`; it owns no authoritative entity state and excludes the local player.
+- Entity presentation snapshots remain caller-owned inputs. Detached diagnostics
+  expose only identity debug keys, paths and visibility, never Node/Resource/RID.
+- `TerrainQualityMeshCache` owns only full-quality revisit Mesh references and
+  LRU keys. The loader retains terrain tasks/results, tile state, source choice,
+  cache versions and every material/Node/RID finalization side effect.
+- `TerrainChunkLodPlanner` is stateless and owns only call-local horizontal
+  distance calculations. The loader retains parsed chunks, desired state,
+  queues, budgets and all Mesh/Node/RID application side effects.
+- `TerrainChunkGeometryQueuePlanner` is stateless and owns only call-local
+  create/remove request calculation and sorting. The loader adopts the fresh
+  arrays and retains removal-first drains, budgets and render side effects.
+- `M2UniquePlacementRegistry` owns only positive unique-key to tile-key strings.
+  The loader retains owned/skipped tile arrays, candidate retry, grouping/build
+  tasks, caches and all MultiMesh/Node/Mesh/material/RID side effects.
+- 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
+  collision. M02 `TerrainQuery` composition and ADT cache ownership remain unchanged.
+- `StreamingTargetPlanner` is stateless and owns only call-local calculations;
+  its immutable plan is consumed synchronously by the streamer.
+- `RenderBudgetScheduler` owns only per-frame lane counters and a terminal
+  cancellation flag. The streamer retains queue ordering and all operation side effects.
 - Focus producers own the immutable `StreamingFocus` reference; the loader retains
   the latest reference and converts it to `Vector3` only inside the render boundary.
 - Worker tasks не должны менять SceneTree и shared Resource concurrently.
@@ -192,10 +323,18 @@ sequenceDiagram
 |---|---|---|---|---|
 | Missing WDT/ADT | File/catalog check | Tile/map unavailable | Loader warning/error | Fix extraction/profile, reload |
 | Missing focus source | Explicit NodePath resolution | Retain current streamed content and prior valid focus | One warning until source recovers | Fix composition path or call `set_streaming_focus` |
+| Missing renderer implementation | Facade path/method validation | Focus/metrics call fails without mutation | One facade diagnostic until recovery | Fix scene composition path/implementation |
+| Invalid metrics result | Facade return-type validation | Return empty caller snapshot | Facade error | Restore `Dictionary` implementation contract |
+| Invalid environment time | Snapshot finite-value validation | Reject update; retain prior sky clock | `environment_time_not_finite` on invalid value | Supply a finite time snapshot |
+| Missing environment controller | Facade path/method validation | Reject environment update; other facade APIs remain available | One facade diagnostic until recovery | Fix scene composition path/implementation |
+| Invalid entity visual snapshot | Contract validation | Reject without scene mutation | Stable `entity_presentation_*` failure code | Repair adapter read model and resend |
+| Missing/invalid entity visual asset | Resource existence/load/root check | New entity absent or prior replacement retained | Named presenter warning | Restore asset mapping and resend snapshot |
+| Missing entity presenter | Facade path/method validation | Reject entity commands; other facade APIs remain available | One facade diagnostic until recovery | Fix runtime scene composition |
 | No focus supplied | Refresh contract | No target recomputation; queues continue draining | `refresh_streaming_focus()` returns `false` | Supply player/editor/capture focus |
 | Cache version mismatch | Required format constant | Reject stale cache/fallback | Version diagnostic | Rebuild matching cache |
 | Worker failure | Task result/empty data | Skip/degrade affected asset | Queue/task warning | Retry/rebuild source |
 | Main-thread hitch | Named section timing | Frame spike, work remains queued | `HITCH` log | Lower budget/fix finalize path |
+| Render terrain unavailable | Facade ground query | Immutable unavailable sample | Stable `render_terrain_*` failure code and optional snapshot | Wait for streaming or use gameplay-owned query backend |
 | D3D12 descriptor exhaustion | Rendering backend error | Render failure/fallback backend | Godot error + baseline report | Dedup resources/fix settings |
 | Teleport/map change | Focus/session transition | Old jobs become stale | Target/session generation | Cancel/drop stale results |
 | Shutdown leak | Godot leak/RID diagnostics | Resource retained | Verbose shutdown report + cache shutdown verifier | Drain requests, preserve tree ownership, then free detached prototypes and clear resource caches |
@@ -225,6 +364,8 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
 ## Diagnostics and observability
 
 - Logs: `HITCH`, `PERF`, `TERRAIN_QUALITY`, `SKY_LIGHT`, `SKYBOX_MODEL`.
+- API snapshot: `WorldRenderFacade.renderer_metrics_snapshot()` returns detached
+  queue/cache/activity counts without exposing mutable renderer state.
 - Metrics: queue depths, active tiles/assets, named finalize times, frame percentiles and max hitch.
 - Debug views: render checkpoint scenes/captures; future streaming/LOD/portal overlays.
 - Correlation IDs: currently mostly tile/path keys; target architecture adds session/job IDs.
@@ -232,6 +373,27 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
 ## Verification
 
 - Unit/contract tests: streaming-focus contract/wiring, material mapping, unique-ID dedupe, placement probes, baseline manifest, five-point coordinate calibration, synthetic perceptual checkpoint diff, camera-pose grid plan.
+- Pure planner contract: center/corner/catalog/clamp/editor cases plus bounded
+  High-like iteration timing without loading a world scene.
+- Terrain chunk LOD contract: horizontal chunk-center distance, inclusive
+  thresholds, sparse indices, disabled/raw-custom policy, loader delegation and
+  bounded 250-by-256 planning without loading a world scene.
+- Terrain chunk geometry queue contract: current/desired comparison, tile-LOD
+  takeover, sparse origin fallback, stable removals, nearest creates, loader
+  drain boundary and bounded multi-tile timing without a world scene.
+- M2 unique placement contract: unkeyed pass-through, within-call/cross-tile
+  dedupe, owner release/retry, clear, detached diagnostics, loader boundary and
+  bounded reserve/release timing without a world scene.
+- 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.
+- Internal-access contract: derives the current streamer's private queue/task/
+  cache/state field inventory and rejects external member/reflection access from
+  gameplay or EditorPlugin package code.
+- Ground-query facade contract: available/unavailable typed result delegation,
+  detached nested diagnostics and terrain-probe source migration without private access.
+- Rendered-ground value contract: available/non-finite/unavailable invariants pass
+  from a cold Godot class cache before editor import.
 - Integration/E2E: Eastern Kingdoms/Kalimdor streaming scenes, seven M00
   cold/warm checkpoints and one dedicated mapped server-spawn checkpoint.
 - Fidelity evidence: семь локальных build 12340 reference JPG покрывают terrain/ADT/M2/WMO/liquid/sky и реальный `GryphonRoost01`; automated cold/warm metrics имеют `compared=14`, `missing=0`. Sky использует приблизительно paired camera, а animated-M2 остаётся asset-paired/placement-unpaired из-за synthetic probe.
@@ -251,13 +413,23 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
 |---|---|---|---|
 | ADT streaming/terrain | Partial | M00 checkpoints and current scenes | Fidelity/performance gaps remain |
 | Static M2 placement | Partial | MultiMesh/dedupe probes | Full materials/animation/effects |
+| M2 unique placement registry | Implemented extraction | Scene-free ownership/lifecycle/timing contract and historical `uid:11785` smoke | Group/build/tasks/finalization and asset-backed p95/p99 remain pending |
 | WMO rendering | Partial | Cached group rendering | Portals/rooms/material parity |
 | 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 |
 | Camera-independent streaming focus | Implemented | Typed contract, two player-focused runtime scenes and three explicitly camera-focused diagnostic tools | Multi-focus/direction/velocity belong to planner extraction |
 | Golden server-spawn visualization | Implemented | Pinned AzerothCore fixture, validated renderer manifest and diagnostic origin-marker capture at ADT `(32,48)`/MCNK `(3,12)` | No TrinityCore row or original-client visual-parity claim |
-| Stable renderer facade | Planned | M03 | Current caller uses monolithic Node API |
+| Stable renderer facade | Implemented boundary / Partial fidelity | Facade contracts cover focus, environment, entity visuals, metrics and loaded-mesh ground query | Production consumers and fidelity remain |
+| Environment snapshot input | Implemented boundary / Partial fidelity | Immutable time contract, facade/controller delegation and checkpoint migration | Weather/indoor state and paired zone-transition fidelity remain |
+| Entity presentation commands | Implemented boundary / Prototype visuals | Versioned typed snapshot plus present/remove lifecycle and runtime service composition | Display/equipment/animation/effects and async scale path remain |
+| Terrain quality Mesh cache service | Implemented extraction | Scene-free admission/LRU/clear contract and loader delegation | Remaining terrain build/state/finalization is monolithic |
+| Terrain chunk LOD planner | Implemented extraction | Scene-free formula/dependency/timing contract and loader delegation | Queue/state/finalization and asset-backed p95/p99 remain pending |
+| Terrain chunk geometry queue planner | Implemented extraction | Scene-free request/order/dependency/timing contract and loader delegation | Queue drains/state/finalization and asset-backed p95/p99 remain pending |
+| Pure streaming target planner | Implemented | `M03-RND-STREAMING-PLANNER-001` asset-free contract/performance regression | Queue scheduling and loaded-tile LOD application remain in streamer |
+| Bounded render budget scheduler | Implemented | `M03-RND-SCHEDULER-001` asset-free permit/cancellation/performance regression | Queue storage, worker concurrency and operation execution remain in streamer/services |
+| Gameplay/editor/tool internal-access boundary | Implemented | Access gate scans gameplay, EditorPlugin packages and terrain probe against actual private streamer declarations | Add future renderer diagnostic tools explicitly to the protected list |
+| Rendered terrain ground query | Implemented | `M03-RND-FACADE-GROUND-QUERY-001` typed result/snapshot isolation and probe migration | Diagnostic Mesh ray only; not movement/collision authority |
 
 ## Known gaps and risks
 
@@ -278,14 +450,35 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
 - D3D12 descriptor issues remain. Explicit shutdown ownership removes the GUI capture's Node/resource/RID leaks in focused and seven-checkpoint runs; a timing-dependent ObjectDB warning for anonymous zero-reference `RefCounted` objects remains as a separate engine-teardown diagnostic.
 - M2/WMO/material/particle/ribbon/portal parity incomplete.
 - Public API is mostly exported configuration rather than stable contracts.
+- Rendered-ground sampling generates a triangle mesh on demand and retains the
+  historical nearby seam fallback. It is appropriate for diagnostics, not a
+  per-physics-frame gameplay query or a claim of exact terrain collision parity.
 
 ## Source map
 
 | Path | Responsibility |
 |---|---|
+| `src/render/world_render_facade.gd` | Stable caller boundary for typed focus/environment, detached metrics and rendered-ground queries |
+| `src/render/environment/world_environment_snapshot.gd` | Immutable normalized world time input with explicit invalid state |
+| `src/render/entities/entity_presentation_snapshot.gd` | Immutable contract-v1 entity visual input and validation |
+| `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/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 |
+| `src/render/streaming/render_budget_scheduler.gd` | Scene-free per-frame operation permits and terminal cancellation |
 | `src/scenes/streaming/streaming_world_loader.gd` | Current runtime orchestration, queues, caches and attachment |
 | `src/domain/streaming/streaming_focus.gd` | Immutable camera-independent streaming position contract |
 | `src/tools/verify_streaming_focus.gd` | Headless contract, dependency and runtime/tool wiring regression |
+| `src/tools/verify_world_render_facade.gd` | Focus/environment/metrics/ground delegation, snapshot isolation and consumer wiring regression |
+| `src/tools/verify_world_environment_snapshot.gd` | Cold-start environment value normalization and invalid-input regression |
+| `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_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 |
 | `addons/mpq_extractor/loaders/adt_builder.gd` | Terrain/material/liquid construction |
 | `addons/mpq_extractor/loaders/m2_builder.gd` | Static M2 mesh/material construction |
 | `addons/mpq_extractor/loaders/m2_native_animated_builder.gd` | Native animated M2 experiment |
@@ -301,7 +494,7 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
 | `src/tools/verify_server_spawn_renderer.gd` | Fixture-to-renderer checkpoint contract verification |
 | `tools/sweep_render_checkpoint_camera_pose.ps1` | Offline yaw/pitch capture grid and paired-error ranking |
 | `src/tools/verify_render_coordinate_calibration.gd` | Build 12340 camera-coordinate golden point round-trip diagnostic |
-| `src/tools/probe_render_terrain_height.gd` | Offline active-mesh terrain height and camera-clearance report |
+| `src/tools/probe_render_terrain_height.gd` | Offline facade-backed active-mesh terrain height and camera-clearance report |
 | `src/tools/probe_render_camera_occluders.gd` | Scene-tree placement containment and camera-to-target AABB intersection report |
 
 ## Related decisions and references

project.godot

@@ -24,11 +24,13 @@ enabled=PackedStringArray("res://addons/mpq_extractor/plugin.cfg")
 openwc_player_move_forward={
 "deadzone": 0.5,
 "events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":87,"key_label":0,"unicode":119,"location":0,"echo":false,"script":null)
+, Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":4194320,"physical_keycode":0,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
 ]
 }
 openwc_player_move_backward={
 "deadzone": 0.5,
 "events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":83,"key_label":0,"unicode":115,"location":0,"echo":false,"script":null)
+, Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":4194322,"physical_keycode":0,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
 ]
 }
 openwc_player_strafe_left={
@@ -41,6 +43,28 @@ openwc_player_strafe_right={
 "events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":68,"key_label":0,"unicode":100,"location":0,"echo":false,"script":null)
 ]
 }
+openwc_player_blizzlike_strafe_left={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":81,"key_label":0,"unicode":113,"location":0,"echo":false,"script":null)
+]
+}
+openwc_player_blizzlike_strafe_right={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":69,"key_label":0,"unicode":101,"location":0,"echo":false,"script":null)
+]
+}
+openwc_player_turn_left={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":65,"key_label":0,"unicode":97,"location":0,"echo":false,"script":null)
+, Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":4194319,"physical_keycode":0,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
+]
+}
+openwc_player_turn_right={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":68,"key_label":0,"unicode":100,"location":0,"echo":false,"script":null)
+, Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":4194321,"physical_keycode":0,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
+]
+}
 openwc_player_debug_fly_up={
 "deadzone": 0.5,
 "events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":69,"key_label":0,"unicode":101,"location":0,"echo":false,"script":null)

reference/.gdignore

@@ -0,0 +1 @@
+# Reference projects are research inputs, not OpenWC runtime resources.

reference/README.md

@@ -2,6 +2,10 @@ Reference-only sources and tools.
 
 This directory contains external projects used to compare WoW file-format behavior and editor pipelines while implementing OpenWC. Runtime code should not depend on anything in this directory.
 
+Godot project scanning is disabled for this directory by `.gdignore`. Reference
+assets remain available to Git, text search and external tooling, but Godot must
+not generate `.import` sidecars inside nested reference repositories.
+
 - `blender-wow-studio-3.4-1.1.0_Experimental/` - Blender add-on sources for M2/WMO import/export reference.
 - `wow.export/` - wow.export source tree and Blender OBJ importer reference.
 - `noggit-red/` - Noggit RED source tree from `https://gitlab.com/dirtbikercj/noggit-red`, used as a reference for WoW 3.3.5 map editing, ADT/WMO/M2 placement behavior, UID handling and editor workflows.

src/domain/input/move_intent.gd

@@ -21,10 +21,16 @@ var is_sprint_requested: bool:
 	get:
 		return _is_sprint_requested
 
+## Signed keyboard turn request: left is negative and right is positive.
+var turn_axis: float:
+	get:
+		return _turn_axis
+
 var _forward_axis: float
 var _strafe_axis: float
 var _vertical_axis: float
 var _is_sprint_requested: bool
+var _turn_axis: float
 
 
 ## Creates one frame's movement request without retaining mutable input state.
@@ -32,12 +38,14 @@ func _init(
 		forward_axis_value: float = 0.0,
 		strafe_axis_value: float = 0.0,
 		vertical_axis_value: float = 0.0,
-		sprint_requested: bool = false
+		sprint_requested: bool = false,
+		turn_axis_value: float = 0.0
 ) -> void:
 	_forward_axis = clampf(forward_axis_value, -1.0, 1.0)
 	_strafe_axis = clampf(strafe_axis_value, -1.0, 1.0)
 	_vertical_axis = clampf(vertical_axis_value, -1.0, 1.0)
 	_is_sprint_requested = sprint_requested
+	_turn_axis = clampf(turn_axis_value, -1.0, 1.0)
 
 
 ## Returns true when the intent requests planar or vertical translation.

src/gameplay/input/player_input_actions.gd

@@ -2,13 +2,17 @@ class_name PlayerInputActions
 extends RefCounted
 
 ## Stable Input Map action names consumed by the runtime player input adapter.
-## Defaults preserve the current render-sandbox controls; users may remap every
-## action through Godot's Input Map without changing gameplay code.
+## Separate translation actions preserve the renderer sandbox while allowing
+## Blizzlike335 defaults to match build-12340 movement bindings.
 
 const MOVE_FORWARD := &"openwc_player_move_forward"
 const MOVE_BACKWARD := &"openwc_player_move_backward"
 const STRAFE_LEFT := &"openwc_player_strafe_left"
 const STRAFE_RIGHT := &"openwc_player_strafe_right"
+const BLIZZLIKE_STRAFE_LEFT := &"openwc_player_blizzlike_strafe_left"
+const BLIZZLIKE_STRAFE_RIGHT := &"openwc_player_blizzlike_strafe_right"
+const TURN_LEFT := &"openwc_player_turn_left"
+const TURN_RIGHT := &"openwc_player_turn_right"
 const DEBUG_FLY_UP := &"openwc_player_debug_fly_up"
 const DEBUG_FLY_DOWN := &"openwc_player_debug_fly_down"
 const DEBUG_SPRINT := &"openwc_player_debug_sprint"
@@ -23,6 +27,10 @@ const REQUIRED_ACTIONS: Array[StringName] = [
 	MOVE_BACKWARD,
 	STRAFE_LEFT,
 	STRAFE_RIGHT,
+	BLIZZLIKE_STRAFE_LEFT,
+	BLIZZLIKE_STRAFE_RIGHT,
+	TURN_LEFT,
+	TURN_RIGHT,
 	DEBUG_FLY_UP,
 	DEBUG_FLY_DOWN,
 	DEBUG_SPRINT,

src/gameplay/input/player_input_source.gd

@@ -5,21 +5,86 @@ extends RefCounted
 ## This adapter owns no movement state and may be replaced independently of the
 ## local movement controller.
 
+const RENDER_SANDBOX_PROFILE_ID := &"RenderSandbox"
+const BLIZZLIKE_335_PROFILE_ID := &"Blizzlike335"
 
-## Samples the current Input singleton state for one physics tick.
-func sample_move_intent() -> MoveIntent:
-	return compose_move_intent(
-		Input.get_action_strength(PlayerInputActions.MOVE_FORWARD),
-		Input.get_action_strength(PlayerInputActions.MOVE_BACKWARD),
-		Input.get_action_strength(PlayerInputActions.STRAFE_LEFT),
-		Input.get_action_strength(PlayerInputActions.STRAFE_RIGHT),
-		Input.get_action_strength(PlayerInputActions.DEBUG_FLY_UP),
-		Input.get_action_strength(PlayerInputActions.DEBUG_FLY_DOWN),
-		Input.is_action_pressed(PlayerInputActions.DEBUG_SPRINT)
+var input_profile_id: StringName:
+	get:
+		return _input_profile_id
+
+var _input_profile_id: StringName
+
+
+## Selects one supported action layout. Unknown profiles fail closed to Blizzlike335.
+func _init(requested_profile_id: StringName = BLIZZLIKE_335_PROFILE_ID) -> void:
+	_input_profile_id = (
+		RENDER_SANDBOX_PROFILE_ID
+		if requested_profile_id == RENDER_SANDBOX_PROFILE_ID
+		else BLIZZLIKE_335_PROFILE_ID
 	)
 
 
-## Builds a normalized intent from action strengths for deterministic tests and
+## Samples the current Input singleton state for one physics tick.
+func sample_move_intent() -> MoveIntent:
+	if _input_profile_id == RENDER_SANDBOX_PROFILE_ID:
+		return compose_move_intent(
+			Input.get_action_strength(PlayerInputActions.MOVE_FORWARD),
+			Input.get_action_strength(PlayerInputActions.MOVE_BACKWARD),
+			Input.get_action_strength(PlayerInputActions.STRAFE_LEFT),
+			Input.get_action_strength(PlayerInputActions.STRAFE_RIGHT),
+			Input.get_action_strength(PlayerInputActions.DEBUG_FLY_UP),
+			Input.get_action_strength(PlayerInputActions.DEBUG_FLY_DOWN),
+			Input.is_action_pressed(PlayerInputActions.DEBUG_SPRINT)
+		)
+	return compose_blizzlike_335_move_intent(
+		Input.get_action_strength(PlayerInputActions.MOVE_FORWARD),
+		Input.get_action_strength(PlayerInputActions.MOVE_BACKWARD),
+		Input.get_action_strength(PlayerInputActions.BLIZZLIKE_STRAFE_LEFT),
+		Input.get_action_strength(PlayerInputActions.BLIZZLIKE_STRAFE_RIGHT),
+		Input.get_action_strength(PlayerInputActions.TURN_LEFT),
+		Input.get_action_strength(PlayerInputActions.TURN_RIGHT),
+		Input.is_action_pressed(PlayerInputActions.CAMERA_ROTATE)
+	)
+
+
+## Builds the compatibility layout: Q/E always strafe; A/D turn unless
+## right-mouse camera rotation is active, when A/D also strafe. Default bindings
+## come from build 12340; conditional routing is reference-implementation evidence.
+static func compose_blizzlike_335_move_intent(
+		forward_strength: float,
+		backward_strength: float,
+		strafe_left_strength: float,
+		strafe_right_strength: float,
+		turn_left_strength: float,
+		turn_right_strength: float,
+		camera_rotate_active: bool
+) -> MoveIntent:
+	var effective_strafe_left := strafe_left_strength
+	var effective_strafe_right := strafe_right_strength
+	var turn_axis := clampf(turn_right_strength, 0.0, 1.0) - clampf(turn_left_strength, 0.0, 1.0)
+	if camera_rotate_active:
+		effective_strafe_left += turn_left_strength
+		effective_strafe_right += turn_right_strength
+		turn_axis = 0.0
+	var move_intent := compose_move_intent(
+		forward_strength,
+		backward_strength,
+		effective_strafe_left,
+		effective_strafe_right,
+		0.0,
+		0.0,
+		false
+	)
+	return MoveIntent.new(
+		move_intent.forward_axis,
+		move_intent.strafe_axis,
+		0.0,
+		false,
+		turn_axis
+	)
+
+
+## Builds a normalized sandbox intent from action strengths for deterministic tests and
 ## alternative input adapters. Strengths outside `[0, 1]` are clamped.
 static func compose_move_intent(
 		forward_strength: float,

src/gameplay/movement/local_player_movement_controller.gd

@@ -13,25 +13,34 @@ var is_flight_enabled: bool:
 	get:
 		return _is_flight_enabled
 
+var movement_profile_id: StringName:
+	get:
+		return _movement_capabilities.profile_id
+
 var _run_speed_units_per_second: float
 var _backward_speed_units_per_second: float
 var _strafe_speed_units_per_second: float
 var _flight_vertical_speed_units_per_second: float
 var _acceleration_units_per_second_squared: float
 var _sandbox_sprint_multiplier: float
+var _keyboard_turn_speed_radians_per_second: float
+var _movement_capabilities: PlayerMovementCapabilities
 var _godot_world_velocity_units_per_second := Vector3.ZERO
 var _is_flight_enabled := false
 
 
-## Creates a movement state with explicit Godot-unit speeds and acceleration.
+## Creates a movement state with explicit Godot-unit speeds, acceleration and capabilities.
 ## The current compatibility renderer treats one Godot unit as one WoW yard.
+## A null capability input fails closed to Blizzlike335 debug permissions.
 func _init(
 		run_speed_units_per_second: float,
 		backward_speed_units_per_second: float,
 		strafe_speed_units_per_second: float,
 		flight_vertical_speed_units_per_second: float,
 		acceleration_units_per_second_squared: float,
-		sandbox_sprint_multiplier: float
+		sandbox_sprint_multiplier: float,
+		movement_capabilities: PlayerMovementCapabilities = null,
+		keyboard_turn_speed_radians_per_second: float = PI
 ) -> void:
 	_run_speed_units_per_second = run_speed_units_per_second
 	_backward_speed_units_per_second = backward_speed_units_per_second
@@ -39,11 +48,32 @@ func _init(
 	_flight_vertical_speed_units_per_second = flight_vertical_speed_units_per_second
 	_acceleration_units_per_second_squared = acceleration_units_per_second_squared
 	_sandbox_sprint_multiplier = sandbox_sprint_multiplier
+	_keyboard_turn_speed_radians_per_second = maxf(
+		keyboard_turn_speed_radians_per_second,
+		0.0
+	)
+	_movement_capabilities = (
+		movement_capabilities
+		if movement_capabilities != null
+		else PlayerMovementCapabilities.blizzlike_335()
+	)
 
 
-## Toggles sandbox free flight and clears velocity exactly like the pre-M02 controller.
-## Returns the new flight state.
+## Returns the Godot yaw delta for one signed keyboard-turn request.
+## Positive intent turns right, which is negative rotation around Godot +Y.
+func calculate_yaw_delta_radians(move_intent: MoveIntent, delta_seconds: float) -> float:
+	return (
+		-move_intent.turn_axis
+		* _keyboard_turn_speed_radians_per_second
+		* maxf(delta_seconds, 0.0)
+	)
+
+
+## Toggles sandbox free flight and clears velocity when the profile permits it.
+## Returns the resulting state; rejected compatibility-profile requests return false.
 func toggle_sandbox_flight() -> bool:
+	if not _movement_capabilities.allows_debug_free_flight:
+		return false
 	_is_flight_enabled = not _is_flight_enabled
 	_godot_world_velocity_units_per_second = Vector3.ZERO
 	return _is_flight_enabled
@@ -83,7 +113,11 @@ func _calculate_target_velocity(move_intent: MoveIntent, godot_world_movement_ba
 		if move_intent.forward_axis > 0.0
 		else _backward_speed_units_per_second
 	)
-	var speed_multiplier := _sandbox_sprint_multiplier if move_intent.is_sprint_requested else 1.0
+	var speed_multiplier := (
+		_sandbox_sprint_multiplier
+		if move_intent.is_sprint_requested and _movement_capabilities.allows_debug_sprint
+		else 1.0
+	)
 	var target_velocity := (
 		forward_direction * move_intent.forward_axis * forward_speed
 		+ right_direction * move_intent.strafe_axis * _strafe_speed_units_per_second

src/gameplay/movement/player_movement_capabilities.gd

@@ -0,0 +1,53 @@
+class_name PlayerMovementCapabilities
+extends RefCounted
+
+## Immutable local-player movement capability selection.
+## Unknown or missing profile identifiers collapse to the safe Blizzlike335
+## capability set; only RenderSandbox enables debug sprint and free flight.
+
+const BLIZZLIKE_335_PROFILE_ID: StringName = &"Blizzlike335"
+const RENDER_SANDBOX_PROFILE_ID: StringName = &"RenderSandbox"
+
+var profile_id: StringName:
+	get:
+		return _profile_id
+
+var allows_debug_sprint: bool:
+	get:
+		return _allows_debug_sprint
+
+var allows_debug_free_flight: bool:
+	get:
+		return _allows_debug_free_flight
+
+var _profile_id: StringName
+var _allows_debug_sprint: bool
+var _allows_debug_free_flight: bool
+
+
+func _init(requested_profile_id: StringName = BLIZZLIKE_335_PROFILE_ID) -> void:
+	if requested_profile_id == RENDER_SANDBOX_PROFILE_ID:
+		_profile_id = RENDER_SANDBOX_PROFILE_ID
+		_allows_debug_sprint = true
+		_allows_debug_free_flight = true
+		return
+	_profile_id = BLIZZLIKE_335_PROFILE_ID
+	_allows_debug_sprint = false
+	_allows_debug_free_flight = false
+
+
+## Returns the debug-enabled capability set used by current renderer scenes.
+static func render_sandbox() -> PlayerMovementCapabilities:
+	return PlayerMovementCapabilities.new(RENDER_SANDBOX_PROFILE_ID)
+
+
+## Returns the compatibility-safe capability set with debug movement disabled.
+## This name identifies the intended compatibility profile, not proven 1:1 movement.
+static func blizzlike_335() -> PlayerMovementCapabilities:
+	return PlayerMovementCapabilities.new(BLIZZLIKE_335_PROFILE_ID)
+
+
+## Maps scene/application profile configuration to a known capability set.
+## Unknown identifiers fail closed to Blizzlike335.
+static func for_profile_id(requested_profile_id: StringName) -> PlayerMovementCapabilities:
+	return PlayerMovementCapabilities.new(requested_profile_id)

src/gameplay/movement/player_movement_capabilities.gd.uid

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

src/render/entities/entity_presentation_snapshot.gd

@@ -0,0 +1,104 @@
+class_name EntityPresentationSnapshot
+extends RefCounted
+
+## Immutable renderer input for one session-local world entity visual.
+## Gameplay authority, identity allocation and asset selection remain external.
+
+const CONTRACT_VERSION := 1
+const SCRIPT_PATH := "res://src/render/entities/entity_presentation_snapshot.gd"
+const ENTITY_ID_SCRIPT := preload("res://src/domain/identity/entity_id.gd")
+const GODOT_WORLD_POSITION_SCRIPT := preload("res://src/domain/coordinates/godot_world_position.gd")
+
+var is_valid: bool:
+	get:
+		return _failure_code.is_empty()
+
+var failure_code: StringName:
+	get:
+		return _failure_code
+
+var entity_id: RefCounted:
+	get:
+		return _entity_id
+
+var world_position: RefCounted:
+	get:
+		return _world_position
+
+var visual_scene_path: String:
+	get:
+		return _visual_scene_path
+
+var yaw_radians: float:
+	get:
+		return _yaw_radians
+
+var uniform_scale: float:
+	get:
+		return _uniform_scale
+
+var is_visible: bool:
+	get:
+		return _is_visible
+
+var _failure_code: StringName
+var _entity_id: RefCounted
+var _world_position: RefCounted
+var _visual_scene_path: String
+var _yaw_radians: float
+var _uniform_scale: float
+var _is_visible: bool
+
+
+## Creates a version-1 full visual snapshot. Invalid values remain inspectable and
+## are rejected without scene mutation by the facade/presenter.
+static func create(
+		entity_id_value: RefCounted,
+		world_position_value: RefCounted,
+		visual_scene_path_value: String,
+		yaw_radians_value: float = 0.0,
+		uniform_scale_value: float = 1.0,
+		is_visible_value: bool = true
+) -> RefCounted:
+	return load(SCRIPT_PATH).new(
+		entity_id_value,
+		world_position_value,
+		visual_scene_path_value,
+		yaw_radians_value,
+		uniform_scale_value,
+		is_visible_value
+	)
+
+
+func _init(
+		entity_id_value: RefCounted,
+		world_position_value: RefCounted,
+		visual_scene_path_value: String,
+		yaw_radians_value: float,
+		uniform_scale_value: float,
+		is_visible_value: bool
+) -> void:
+	_entity_id = entity_id_value
+	_world_position = world_position_value
+	_visual_scene_path = visual_scene_path_value.strip_edges()
+	_yaw_radians = yaw_radians_value
+	_uniform_scale = uniform_scale_value
+	_is_visible = is_visible_value
+	_failure_code = _validate()
+
+
+func _validate() -> StringName:
+	if _entity_id == null or _entity_id.get_script() != ENTITY_ID_SCRIPT or not bool(_entity_id.call("is_valid")):
+		return &"entity_presentation_invalid_entity_id"
+	if _world_position == null or _world_position.get_script() != GODOT_WORLD_POSITION_SCRIPT:
+		return &"entity_presentation_invalid_world_position"
+	for coordinate_name in [&"x_units", &"y_units", &"z_units"]:
+		if not is_finite(float(_world_position.get(coordinate_name))):
+			return &"entity_presentation_position_not_finite"
+	if _visual_scene_path.is_empty():
+		return &"entity_presentation_visual_path_empty"
+	if not is_finite(_yaw_radians):
+		return &"entity_presentation_yaw_not_finite"
+	if not is_finite(_uniform_scale) or _uniform_scale <= 0.0:
+		return &"entity_presentation_scale_invalid"
+	return &""

src/render/entities/entity_presentation_snapshot.gd.uid

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

src/render/entities/world_entity_presenter.gd

@@ -0,0 +1,130 @@
+@tool
+class_name WorldEntityPresenter
+extends Node3D
+
+## Main-thread owner of visual subtrees for session-local world entities.
+## The full immutable snapshot is reapplied idempotently by entity identity.
+
+const ENTITY_PRESENTATION_SNAPSHOT_SCRIPT := preload("res://src/render/entities/entity_presentation_snapshot.gd")
+const ENTITY_ID_SCRIPT := preload("res://src/domain/identity/entity_id.gd")
+
+var _presented_entities: Dictionary = {}
+
+
+## Creates or updates one entity visual. A changed visual path is instantiated
+## successfully before the previous subtree is detached, so failed replacement
+## retains the last valid presentation.
+func present_entity(entity_presentation_snapshot: RefCounted) -> bool:
+	if not _is_valid_snapshot(entity_presentation_snapshot):
+		return false
+	var entity_id: RefCounted = entity_presentation_snapshot.get("entity_id")
+	var entity_key := _entity_key(entity_id)
+	var visual_scene_path := String(entity_presentation_snapshot.get("visual_scene_path"))
+	var current_entry: Dictionary = _presented_entities.get(entity_key, {})
+	var visual_root := current_entry.get("visual_root") as Node3D
+	if visual_root == null or not is_instance_valid(visual_root) or String(current_entry.get("visual_scene_path", "")) != visual_scene_path:
+		var replacement_root := _instantiate_visual_root(entity_id, visual_scene_path)
+		if replacement_root == null:
+			return false
+		if visual_root != null and is_instance_valid(visual_root):
+			remove_child(visual_root)
+		add_child(replacement_root)
+		_apply_snapshot_transform(replacement_root, entity_presentation_snapshot)
+		if visual_root != null and is_instance_valid(visual_root):
+			visual_root.queue_free()
+		visual_root = replacement_root
+	else:
+		_apply_snapshot_transform(visual_root, entity_presentation_snapshot)
+	_presented_entities[entity_key] = {
+		"visual_root": visual_root,
+		"visual_scene_path": visual_scene_path,
+		"snapshot": entity_presentation_snapshot,
+	}
+	return true
+
+
+## Removes one owned entity visual. Returns false for an invalid/unknown identity.
+func remove_entity(entity_id: RefCounted) -> bool:
+	if entity_id == null or entity_id.get_script() != ENTITY_ID_SCRIPT or not bool(entity_id.call("is_valid")):
+		return false
+	var entity_key := _entity_key(entity_id)
+	if not _presented_entities.has(entity_key):
+		return false
+	var entry: Dictionary = _presented_entities[entity_key]
+	var visual_root := entry.get("visual_root") as Node3D
+	_presented_entities.erase(entity_key)
+	if visual_root != null and is_instance_valid(visual_root):
+		remove_child(visual_root)
+		visual_root.queue_free()
+	return true
+
+
+## Returns detached scalar diagnostics without exposing owned Nodes or snapshots.
+func entity_presentation_snapshot() -> Dictionary:
+	var entities: Array[Dictionary] = []
+	var sorted_entity_keys: Array = _presented_entities.keys()
+	sorted_entity_keys.sort()
+	for entity_key_variant in sorted_entity_keys:
+		var entity_key := String(entity_key_variant)
+		var entry: Dictionary = _presented_entities[entity_key]
+		var snapshot: RefCounted = entry.get("snapshot")
+		entities.append({
+			"entity_key": entity_key,
+			"visual_scene_path": String(entry.get("visual_scene_path", "")),
+			"visible": bool(snapshot.get("is_visible")),
+		})
+	return {
+		"contract_version": ENTITY_PRESENTATION_SNAPSHOT_SCRIPT.CONTRACT_VERSION,
+		"entity_count": entities.size(),
+		"entities": entities,
+	}
+
+
+func _exit_tree() -> void:
+	_presented_entities.clear()
+
+
+func _is_valid_snapshot(entity_presentation_snapshot: RefCounted) -> bool:
+	return (
+		entity_presentation_snapshot != null
+		and entity_presentation_snapshot.get_script() == ENTITY_PRESENTATION_SNAPSHOT_SCRIPT
+		and bool(entity_presentation_snapshot.get("is_valid"))
+	)
+
+
+func _entity_key(entity_id: RefCounted) -> String:
+	return String(entity_id.call("to_debug_key"))
+
+
+func _instantiate_visual_root(entity_id: RefCounted, visual_scene_path: String) -> Node3D:
+	if not ResourceLoader.exists(visual_scene_path, "PackedScene"):
+		push_warning("WorldEntityPresenter cannot find visual scene: %s" % visual_scene_path)
+		return null
+	var visual_scene := load(visual_scene_path) as PackedScene
+	if visual_scene == null:
+		push_warning("WorldEntityPresenter cannot load visual scene: %s" % visual_scene_path)
+		return null
+	var visual_instance := visual_scene.instantiate()
+	if not (visual_instance is Node3D):
+		visual_instance.free()
+		push_warning("WorldEntityPresenter visual scene root is not Node3D: %s" % visual_scene_path)
+		return null
+	var visual_root := visual_instance as Node3D
+	visual_root.name = "EntityVisual_%020d" % int(entity_id.get("session_sequence"))
+	return visual_root
+
+
+func _apply_snapshot_transform(visual_root: Node3D, entity_presentation_snapshot: RefCounted) -> void:
+	var world_position: RefCounted = entity_presentation_snapshot.get("world_position")
+	var position_units := Vector3(
+		float(world_position.get("x_units")),
+		float(world_position.get("y_units")),
+		float(world_position.get("z_units"))
+	)
+	var uniform_scale := float(entity_presentation_snapshot.get("uniform_scale"))
+	var yaw_radians := float(entity_presentation_snapshot.get("yaw_radians"))
+	visual_root.global_transform = Transform3D(
+		Basis(Vector3.UP, yaw_radians).scaled(Vector3.ONE * uniform_scale),
+		position_units
+	)
+	visual_root.visible = bool(entity_presentation_snapshot.get("is_visible"))

src/render/entities/world_entity_presenter.gd.uid

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

src/render/environment/world_environment_snapshot.gd

@@ -0,0 +1,40 @@
+class_name WorldEnvironmentSnapshot
+extends RefCounted
+
+## Immutable renderer input describing the authoritative time within one world day.
+## DBC light, area, fog and skybox selection remain owned by the sky controller.
+
+const HOURS_PER_DAY := 24.0
+const SCRIPT_PATH := "res://src/render/environment/world_environment_snapshot.gd"
+
+var is_valid: bool:
+	get:
+		return _is_valid
+
+var time_of_day_hours: float:
+	get:
+		return _time_of_day_hours
+
+var failure_code: StringName:
+	get:
+		return _failure_code
+
+var _is_valid: bool
+var _time_of_day_hours: float
+var _failure_code: StringName
+
+
+## Creates a snapshot and normalizes finite input into the half-open [0, 24) day.
+## Non-finite input produces an explicit invalid value instead of renderer state.
+static func at_time_of_day(time_of_day_hours_value: float) -> RefCounted:
+	return load(SCRIPT_PATH).new(time_of_day_hours_value)
+
+
+func _init(time_of_day_hours_value: float) -> void:
+	_is_valid = is_finite(time_of_day_hours_value)
+	_time_of_day_hours = (
+		fposmod(time_of_day_hours_value, HOURS_PER_DAY)
+		if _is_valid
+		else 0.0
+	)
+	_failure_code = &"" if _is_valid else &"environment_time_not_finite"

src/render/environment/world_environment_snapshot.gd.uid

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

src/render/m2/m2_unique_placement_registry.gd

@@ -0,0 +1,88 @@
+class_name M2UniquePlacementRegistry
+extends RefCounted
+
+## Session-memory ownership registry for positive ADT MDDF unique IDs.
+
+var _owner_tile_by_unique_key: Dictionary = {}
+
+
+## Reserves unowned positive unique IDs for one tile and returns fresh arrays.
+## Unkeyed placements pass through without entering registry ownership.
+func reserve(tile_key: String, m2_placements: Array) -> Dictionary:
+	var filtered_placements: Array = []
+	var unique_keys: Array = []
+	var skipped_unique_keys: Array = []
+	for placement_variant in m2_placements:
+		if not (placement_variant is Dictionary):
+			continue
+		var placement: Dictionary = placement_variant
+		var unique_key := _unique_key_for_placement(placement)
+		if unique_key.is_empty():
+			filtered_placements.append(placement)
+			continue
+		if _owner_tile_by_unique_key.has(unique_key):
+			var owner_tile := String(_owner_tile_by_unique_key[unique_key])
+			if owner_tile == tile_key and unique_keys.has(unique_key):
+				continue
+			if owner_tile != tile_key:
+				if not skipped_unique_keys.has(unique_key):
+					skipped_unique_keys.append(unique_key)
+				continue
+		_owner_tile_by_unique_key[unique_key] = tile_key
+		if not unique_keys.has(unique_key):
+			unique_keys.append(unique_key)
+		filtered_placements.append(placement)
+	return {
+		"placements": filtered_placements,
+		"unique_keys": unique_keys,
+		"skipped_unique_keys": skipped_unique_keys,
+	}
+
+
+## Releases only keys currently owned by the supplied tile and returns them in
+## input order so the loader can notify waiting candidate tiles.
+func release(tile_key: String, unique_keys: Array) -> Array:
+	var released_unique_keys: Array = []
+	for unique_key_variant in unique_keys:
+		var unique_key := String(unique_key_variant)
+		if unique_key.is_empty() or not _owner_tile_by_unique_key.has(unique_key):
+			continue
+		if String(_owner_tile_by_unique_key[unique_key]) != tile_key:
+			continue
+		_owner_tile_by_unique_key.erase(unique_key)
+		released_unique_keys.append(unique_key)
+	return released_unique_keys
+
+
+## Removes all reservations during world reset or renderer shutdown.
+func clear() -> void:
+	_owner_tile_by_unique_key.clear()
+
+
+## Returns the number of currently owned positive unique IDs.
+func active_count() -> int:
+	return _owner_tile_by_unique_key.size()
+
+
+## Returns detached, key-sorted scalar diagnostics without registry references.
+func diagnostic_snapshot() -> Dictionary:
+	var sorted_unique_keys: Array = _owner_tile_by_unique_key.keys()
+	sorted_unique_keys.sort()
+	var owners: Array = []
+	for unique_key_variant in sorted_unique_keys:
+		var unique_key := String(unique_key_variant)
+		owners.append({
+			"unique_key": unique_key,
+			"tile_key": String(_owner_tile_by_unique_key[unique_key]),
+		})
+	return {
+		"active_count": owners.size(),
+		"owners": owners,
+	}
+
+
+func _unique_key_for_placement(placement: Dictionary) -> String:
+	var unique_id := int(placement.get("unique_id", -1))
+	if unique_id <= 0:
+		return ""
+	return "uid:%d" % unique_id

src/render/m2/m2_unique_placement_registry.gd.uid

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

src/render/streaming/render_budget_scheduler.gd

@@ -0,0 +1,84 @@
+## Issues bounded, per-frame permits for renderer main-thread operation lanes.
+##
+## The scheduler owns counters only. Queue contents, operation ordering and the
+## side effects performed after a permit remain owned by the caller. One instance
+## belongs to one renderer lifecycle and must only be used on the main thread.
+class_name RenderBudgetScheduler
+extends RefCounted
+
+const TILE_FINALIZE: StringName = &"tile_finalize"
+const TERRAIN_UPGRADE_FINALIZE: StringName = &"terrain_upgrade_finalize"
+const TERRAIN_CONTROL_SPLAT_FINALIZE: StringName = &"terrain_control_splat_finalize"
+const TERRAIN_SPLAT_CACHE_FINALIZE: StringName = &"terrain_splat_cache_finalize"
+const TERRAIN_SPLAT_BUILD: StringName = &"terrain_splat_build"
+const WATER_FINALIZE: StringName = &"water_finalize"
+const CHUNK_GEOMETRY: StringName = &"chunk_geometry"
+const TILE_LOAD_START: StringName = &"tile_load_start"
+const TILE_LOD_CREATE: StringName = &"tile_lod_create"
+const TILE_LOD_REMOVE: StringName = &"tile_lod_remove"
+const M2_ANIMATION_FINALIZE: StringName = &"m2_animation_finalize"
+const M2_MESH_FINALIZE: StringName = &"m2_mesh_finalize"
+const M2_BUILD: StringName = &"m2_build"
+const WMO_BUILD: StringName = &"wmo_build"
+const WMO_RENDER_GROUP_BUILD: StringName = &"wmo_render_group_build"
+const DETAIL_ASSET_SYNC: StringName = &"detail_asset_sync"
+
+var _remaining_permits_by_lane: Dictionary = {}
+var _consumed_permits_by_lane: Dictionary = {}
+var _is_cancelled := false
+
+
+## Replaces all lane limits for a new frame. Negative limits are treated as zero.
+## Calling this after [method cancel] leaves the scheduler cancelled.
+func begin_frame(operation_limits_by_lane: Dictionary) -> void:
+	_remaining_permits_by_lane.clear()
+	_consumed_permits_by_lane.clear()
+	if _is_cancelled:
+		return
+
+	for lane_variant in operation_limits_by_lane:
+		var lane := StringName(lane_variant)
+		_remaining_permits_by_lane[lane] = maxi(0, int(operation_limits_by_lane[lane_variant]))
+		_consumed_permits_by_lane[lane] = 0
+
+
+## Returns whether a lane can issue another permit without consuming it.
+## Unknown lanes and cancelled schedulers return false.
+func has_remaining_permit(lane: StringName) -> bool:
+	if _is_cancelled:
+		return false
+	return int(_remaining_permits_by_lane.get(lane, 0)) > 0
+
+
+## Consumes one permit from [param lane] and returns true when it was granted.
+## Unknown, exhausted or cancelled lanes return false without changing state.
+func try_consume_permit(lane: StringName) -> bool:
+	if not has_remaining_permit(lane):
+		return false
+	_remaining_permits_by_lane[lane] = int(_remaining_permits_by_lane[lane]) - 1
+	_consumed_permits_by_lane[lane] = int(_consumed_permits_by_lane.get(lane, 0)) + 1
+	return true
+
+
+## Returns the unconsumed permit count for one lane.
+func remaining_permits(lane: StringName) -> int:
+	if _is_cancelled:
+		return 0
+	return int(_remaining_permits_by_lane.get(lane, 0))
+
+
+## Returns a detached diagnostic snapshot of permits consumed in this frame.
+func consumed_permits_snapshot() -> Dictionary:
+	return _consumed_permits_by_lane.duplicate()
+
+
+## Permanently rejects new permits for this scheduler instance and clears limits.
+## In-flight work remains the caller's responsibility and is not interrupted.
+func cancel() -> void:
+	_is_cancelled = true
+	_remaining_permits_by_lane.clear()
+
+
+## Returns whether [method cancel] ended this scheduler lifecycle.
+func is_cancelled() -> bool:
+	return _is_cancelled

src/render/streaming/render_budget_scheduler.gd.uid

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

src/render/streaming/streaming_target_plan.gd

@@ -0,0 +1,37 @@
+class_name StreamingTargetPlan
+extends RefCounted
+
+## Immutable result of one runtime or editor target-planning operation.
+## Tile-key sets use the streamer's existing `<tile_x>_<tile_y>` representation.
+
+var focus_tile: AdtTileCoordinate:
+	get:
+		return _focus_tile
+
+var _focus_tile: AdtTileCoordinate
+var _wanted_tile_keys: Dictionary
+var _retained_tile_keys: Dictionary
+
+
+## Takes ownership of planner-created sets and freezes them. The planner creates
+## these dictionaries independently from its catalog input, so no copy is needed.
+func _init(
+		focus_tile_value: AdtTileCoordinate,
+		wanted_tile_keys_value: Dictionary,
+		retained_tile_keys_value: Dictionary
+) -> void:
+	_focus_tile = focus_tile_value
+	_wanted_tile_keys = wanted_tile_keys_value
+	_retained_tile_keys = retained_tile_keys_value
+	_wanted_tile_keys.make_read_only()
+	_retained_tile_keys.make_read_only()
+
+
+## Returns the immutable wanted tile-key set.
+func wanted_tile_keys() -> Dictionary:
+	return _wanted_tile_keys
+
+
+## Returns the immutable retained tile-key set.
+func retained_tile_keys() -> Dictionary:
+	return _retained_tile_keys

src/render/streaming/streaming_target_plan.gd.uid

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

src/render/streaming/streaming_target_planner.gd

@@ -0,0 +1,104 @@
+class_name StreamingTargetPlanner
+extends RefCounted
+
+## Scene-free deterministic calculator for runtime/editor ADT target sets.
+## It creates no tasks or renderer resources and never mutates its inputs.
+
+const COORDINATE_MAPPER_SCRIPT := preload("res://src/domain/coordinates/coordinate_mapper.gd")
+const ADT_TILE_COORDINATE_SCRIPT := preload("res://src/domain/coordinates/adt_tile_coordinate.gd")
+const TARGET_PLAN_SCRIPT := preload("res://src/render/streaming/streaming_target_plan.gd")
+
+
+## Builds runtime wanted and retained sets, including the existing edge/corner
+## prefetch centers. `available_tile_paths_by_key` is read only for membership.
+func plan_runtime(
+		available_tile_paths_by_key: Dictionary,
+		focus_position: GodotWorldPosition,
+		policy
+):
+	var focus_tile = COORDINATE_MAPPER_SCRIPT.godot_to_adt_tile(focus_position)
+	var prefetch_centers := _prefetch_centers(focus_position, focus_tile, policy)
+	var wanted_tile_keys := _available_keys_within_radius(
+		available_tile_paths_by_key,
+		prefetch_centers,
+		policy.load_tile_radius()
+	)
+	var retained_tile_keys := _available_keys_within_radius(
+		available_tile_paths_by_key,
+		prefetch_centers,
+		policy.retained_tile_radius()
+	)
+	return TARGET_PLAN_SCRIPT.new(focus_tile, wanted_tile_keys, retained_tile_keys)
+
+
+## Builds the editor square preview set. Editor wanted and retained sets are
+## identical and a negative radius is clamped to the focus tile.
+func plan_editor(
+		available_tile_paths_by_key: Dictionary,
+		focus_position: GodotWorldPosition,
+		editor_preview_tile_radius: int
+):
+	var focus_tile = COORDINATE_MAPPER_SCRIPT.godot_to_adt_tile(focus_position)
+	var centers: Array[AdtTileCoordinate] = [focus_tile]
+	var wanted_tile_keys := _available_keys_within_radius(
+		available_tile_paths_by_key,
+		centers,
+		maxi(0, editor_preview_tile_radius)
+	)
+	return TARGET_PLAN_SCRIPT.new(focus_tile, wanted_tile_keys, wanted_tile_keys)
+
+
+func _prefetch_centers(
+		focus_position: GodotWorldPosition,
+		focus_tile: AdtTileCoordinate,
+		policy
+) -> Array[AdtTileCoordinate]:
+	var centers: Array[AdtTileCoordinate] = [focus_tile]
+	var threshold: float = policy.clamped_boundary_prefetch_threshold()
+	if threshold <= 0.0:
+		return centers
+
+	var tile_local_position = COORDINATE_MAPPER_SCRIPT.godot_to_adt_tile_local(focus_position)
+	var local_x_fraction: float = tile_local_position.east_yards / COORDINATE_MAPPER_SCRIPT.ADT_TILE_SIZE_YARDS
+	var local_z_fraction: float = tile_local_position.south_yards / COORDINATE_MAPPER_SCRIPT.ADT_TILE_SIZE_YARDS
+	var tile_x_offsets: Array[int] = [0]
+	var tile_y_offsets: Array[int] = [0]
+
+	if local_x_fraction <= threshold:
+		tile_x_offsets.append(-1)
+	elif local_x_fraction >= 1.0 - threshold:
+		tile_x_offsets.append(1)
+
+	if local_z_fraction <= threshold:
+		tile_y_offsets.append(-1)
+	elif local_z_fraction >= 1.0 - threshold:
+		tile_y_offsets.append(1)
+
+	for tile_x_offset in tile_x_offsets:
+		for tile_y_offset in tile_y_offsets:
+			if tile_x_offset == 0 and tile_y_offset == 0:
+				continue
+			centers.append(ADT_TILE_COORDINATE_SCRIPT.new(
+				focus_tile.tile_x + tile_x_offset,
+				focus_tile.tile_y + tile_y_offset
+			))
+	return centers
+
+
+func _available_keys_within_radius(
+		available_tile_paths_by_key: Dictionary,
+		centers: Array[AdtTileCoordinate],
+		tile_radius: int
+) -> Dictionary:
+	var available_tile_keys: Dictionary = {}
+	for center in centers:
+		for tile_y in range(center.tile_y - tile_radius, center.tile_y + tile_radius + 1):
+			for tile_x in range(center.tile_x - tile_radius, center.tile_x + tile_radius + 1):
+				var tile_key := _tile_key(tile_x, tile_y)
+				if available_tile_paths_by_key.has(tile_key):
+					available_tile_keys[tile_key] = true
+	return available_tile_keys
+
+
+func _tile_key(tile_x: int, tile_y: int) -> String:
+	return "%d_%d" % [tile_x, tile_y]

src/render/streaming/streaming_target_planner.gd.uid

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

src/render/streaming/streaming_target_policy.gd

@@ -0,0 +1,108 @@
+class_name StreamingTargetPolicy
+extends RefCounted
+
+## Immutable runtime tile-radius and boundary-prefetch policy consumed by
+## [StreamingTargetPlanner]. Values preserve scene configuration exactly;
+## effective radii and thresholds apply the existing renderer clamps.
+
+const CHUNKS_PER_ADT_TILE := 16
+
+var lod2_radius_chunks: int:
+	get:
+		return _lod2_radius_chunks
+
+var lod2_tile_radius: int:
+	get:
+		return _lod2_tile_radius
+
+var warm_tile_margin: int:
+	get:
+		return _warm_tile_margin
+
+var prewarm_tile_margin: int:
+	get:
+		return _prewarm_tile_margin
+
+var retain_tile_margin: int:
+	get:
+		return _retain_tile_margin
+
+var boundary_prefetch_threshold: float:
+	get:
+		return _boundary_prefetch_threshold
+
+var _lod2_radius_chunks: int
+var _lod2_tile_radius: int
+var _warm_tile_margin: int
+var _prewarm_tile_margin: int
+var _retain_tile_margin: int
+var _boundary_prefetch_threshold: float
+
+
+## Captures one renderer configuration snapshot for a deterministic plan.
+func _init(
+		lod2_radius_chunks_value: int,
+		lod2_tile_radius_value: int,
+		warm_tile_margin_value: int,
+		prewarm_tile_margin_value: int,
+		retain_tile_margin_value: int,
+		boundary_prefetch_threshold_value: float
+) -> void:
+	_lod2_radius_chunks = lod2_radius_chunks_value
+	_lod2_tile_radius = lod2_tile_radius_value
+	_warm_tile_margin = warm_tile_margin_value
+	_prewarm_tile_margin = prewarm_tile_margin_value
+	_retain_tile_margin = retain_tile_margin_value
+	_boundary_prefetch_threshold = boundary_prefetch_threshold_value
+
+
+## Returns the current visible ADT radius derived from chunk and tile settings.
+func visible_tile_radius() -> int:
+	return calculate_visible_tile_radius(_lod2_radius_chunks, _lod2_tile_radius, _warm_tile_margin)
+
+
+## Returns the visible radius plus the non-negative prewarm margin.
+func load_tile_radius() -> int:
+	return calculate_load_tile_radius(
+		_lod2_radius_chunks,
+		_lod2_tile_radius,
+		_warm_tile_margin,
+		_prewarm_tile_margin
+	)
+
+
+## Returns the load radius plus the non-negative hysteresis margin.
+func retained_tile_radius() -> int:
+	return load_tile_radius() + maxi(0, _retain_tile_margin)
+
+
+## Returns the edge fraction accepted by the existing prefetch policy.
+func clamped_boundary_prefetch_threshold() -> float:
+	return clampf(_boundary_prefetch_threshold, 0.0, 0.49)
+
+
+## Calculates the visible radius without allocating a policy. The streamer uses
+## this hot-path form while finalizing tiles between planning refreshes.
+static func calculate_visible_tile_radius(
+		lod2_radius_chunks_value: int,
+		lod2_tile_radius_value: int,
+		warm_tile_margin_value: int
+) -> int:
+	var chunk_tile_radius := int(ceil(
+		float(lod2_radius_chunks_value) / float(CHUNKS_PER_ADT_TILE)
+	)) + warm_tile_margin_value
+	return maxi(chunk_tile_radius, lod2_tile_radius_value)
+
+
+## Calculates the load radius without allocating a policy.
+static func calculate_load_tile_radius(
+		lod2_radius_chunks_value: int,
+		lod2_tile_radius_value: int,
+		warm_tile_margin_value: int,
+		prewarm_tile_margin_value: int
+) -> int:
+	return calculate_visible_tile_radius(
+		lod2_radius_chunks_value,
+		lod2_tile_radius_value,
+		warm_tile_margin_value
+	) + maxi(0, prewarm_tile_margin_value)

src/render/streaming/streaming_target_policy.gd.uid

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

src/render/terrain/rendered_ground_sample.gd

@@ -0,0 +1,52 @@
+class_name RenderedGroundSample
+extends RefCounted
+
+## Immutable result of sampling currently loaded render terrain in Godot world units.
+## This diagnostic value is renderer-owned and is not authoritative gameplay collision.
+
+var is_available: bool:
+	get:
+		return _is_available
+
+var height_units: float:
+	get:
+		return _height_units
+
+var failure_code: StringName:
+	get:
+		return _failure_code
+
+var _is_available: bool
+var _height_units: float
+var _failure_code: StringName
+
+const SCRIPT_PATH := "res://src/render/terrain/rendered_ground_sample.gd"
+
+
+## Creates an available finite rendered-ground sample in Godot world units.
+static func available(height_units_value: float) -> RefCounted:
+	return load(SCRIPT_PATH).new(true, height_units_value, &"")
+
+
+## Creates an unavailable rendered-ground sample with a stable failure code.
+static func unavailable(failure_code_value: StringName) -> RefCounted:
+	return load(SCRIPT_PATH).new(false, 0.0, failure_code_value)
+
+
+func _init(
+		is_available_value: bool,
+		height_units_value: float,
+		failure_code_value: StringName
+) -> void:
+	_is_available = is_available_value and is_finite(height_units_value)
+	_height_units = height_units_value if _is_available else 0.0
+	if _is_available:
+		_failure_code = &""
+	elif not is_finite(height_units_value):
+		_failure_code = &"render_terrain_height_not_finite"
+	else:
+		_failure_code = (
+			failure_code_value
+			if not failure_code_value.is_empty()
+			else &"render_terrain_unavailable"
+		)

src/render/terrain/rendered_ground_sample.gd.uid

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

src/render/terrain/terrain_chunk_geometry_queue_planner.gd

@@ -0,0 +1,102 @@
+class_name TerrainChunkGeometryQueuePlanner
+extends RefCounted
+
+## Pure desired-operation planner for terrain chunk geometry queues.
+
+const GODOT_WORLD_POSITION_SCRIPT := preload(
+	"res://src/domain/coordinates/godot_world_position.gd"
+)
+
+
+## Returns fresh nearest-first create and stable-order remove request arrays.
+## The caller retains queue storage, execution order and every render side effect.
+func plan(tile_states: Dictionary, focus_position: RefCounted) -> Dictionary:
+	var chunk_create_requests: Array = []
+	var chunk_remove_requests: Array = []
+	if (
+		focus_position == null
+		or focus_position.get_script() != GODOT_WORLD_POSITION_SCRIPT
+	):
+		return _create_plan(chunk_create_requests, chunk_remove_requests)
+
+	var focus_x_units := float(focus_position.get("x_units"))
+	var focus_z_units := float(focus_position.get("z_units"))
+	for tile_key_variant in tile_states.keys():
+		var tile_key := String(tile_key_variant)
+		var tile_state: Dictionary = tile_states[tile_key_variant]
+		var current_chunks: Dictionary = tile_state["chunks"]
+		var desired_lods: Dictionary = tile_state["desired_lods"]
+		var desired_tile_lod := int(tile_state.get("desired_tile_lod", -1))
+
+		if desired_tile_lod >= 0:
+			for chunk_id in current_chunks.keys():
+				chunk_remove_requests.append({"tile": tile_key, "chunk": chunk_id})
+			continue
+
+		for chunk_id in current_chunks.keys():
+			if not desired_lods.has(chunk_id):
+				chunk_remove_requests.append({"tile": tile_key, "chunk": chunk_id})
+				continue
+			if int(current_chunks[chunk_id]["lod"]) != int(desired_lods[chunk_id]):
+				chunk_create_requests.append(_create_chunk_request(
+					tile_key,
+					chunk_id,
+					int(desired_lods[chunk_id]),
+					_resolve_chunk_origin(tile_state, int(chunk_id)),
+					focus_x_units,
+					focus_z_units
+				))
+
+		for chunk_id in desired_lods.keys():
+			if current_chunks.has(chunk_id):
+				continue
+			chunk_create_requests.append(_create_chunk_request(
+				tile_key,
+				chunk_id,
+				int(desired_lods[chunk_id]),
+				_resolve_chunk_origin(tile_state, int(chunk_id)),
+				focus_x_units,
+				focus_z_units
+			))
+
+	chunk_create_requests.sort_custom(func(
+			left_request: Dictionary,
+			right_request: Dictionary
+	) -> bool:
+		return float(left_request["dist_sq"]) < float(right_request["dist_sq"])
+	)
+	return _create_plan(chunk_create_requests, chunk_remove_requests)
+
+
+func _resolve_chunk_origin(tile_state: Dictionary, chunk_id: int) -> Vector3:
+	var chunks: Array = tile_state["data"].get("chunks", [])
+	if chunk_id >= 0 and chunk_id < chunks.size():
+		var chunk: Dictionary = chunks[chunk_id]
+		if not chunk.is_empty():
+			return chunk.get("origin", Vector3.ZERO)
+	return tile_state.get("origin", Vector3.ZERO)
+
+
+func _create_chunk_request(
+		tile_key: String,
+		chunk_id: Variant,
+		desired_lod: int,
+		chunk_origin: Vector3,
+		focus_x_units: float,
+		focus_z_units: float
+) -> Dictionary:
+	var delta_x_units := chunk_origin.x - focus_x_units
+	var delta_z_units := chunk_origin.z - focus_z_units
+	return {
+		"tile": tile_key,
+		"chunk": chunk_id,
+		"lod": desired_lod,
+		"dist_sq": delta_x_units * delta_x_units + delta_z_units * delta_z_units,
+	}
+
+
+func _create_plan(chunk_create_requests: Array, chunk_remove_requests: Array) -> Dictionary:
+	return {
+		"create_requests": chunk_create_requests,
+		"remove_requests": chunk_remove_requests,
+	}

src/render/terrain/terrain_chunk_geometry_queue_planner.gd.uid

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

src/render/terrain/terrain_chunk_lod_planner.gd

@@ -0,0 +1,53 @@
+class_name TerrainChunkLodPlanner
+extends RefCounted
+
+## Pure linear desired-state planner for parsed ADT chunk records.
+
+const POLICY_SCRIPT := preload("res://src/render/terrain/terrain_chunk_lod_policy.gd")
+const GODOT_WORLD_POSITION_SCRIPT := preload("res://src/domain/coordinates/godot_world_position.gd")
+
+
+## Maps source chunk indices to LOD 0/1/2 using horizontal distance from the
+## typed focus to each chunk center. Empty/out-of-range chunks remain absent.
+func plan(
+		chunks: Array,
+		focus_position: RefCounted,
+		policy: RefCounted
+) -> Dictionary:
+	if (
+		focus_position == null
+		or focus_position.get_script() != GODOT_WORLD_POSITION_SCRIPT
+		or policy == null
+		or policy.get_script() != POLICY_SCRIPT
+		or not bool(policy.get("is_enabled"))
+	):
+		return {}
+
+	var chunk_size_units := float(policy.get("chunk_size_units"))
+	var lod0_radius_squared := (float(policy.get("lod0_radius_chunks")) * chunk_size_units) ** 2
+	var lod1_radius_squared := (float(policy.get("lod1_radius_chunks")) * chunk_size_units) ** 2
+	var lod2_radius_squared := (float(policy.get("lod2_radius_chunks")) * chunk_size_units) ** 2
+	var focus_x_units := float(focus_position.get("x_units"))
+	var focus_z_units := float(focus_position.get("z_units"))
+	var desired_lods: Dictionary = {}
+
+	for chunk_id in range(chunks.size()):
+		var chunk: Dictionary = chunks[chunk_id]
+		if chunk.is_empty():
+			continue
+		var origin: Vector3 = chunk.get("origin", Vector3.ZERO)
+		var center_x_units := origin.x + chunk_size_units * 0.5
+		var center_z_units := origin.z + chunk_size_units * 0.5
+		var delta_x_units := center_x_units - focus_x_units
+		var delta_z_units := center_z_units - focus_z_units
+		var distance_squared_units := (
+			delta_x_units * delta_x_units + delta_z_units * delta_z_units
+		)
+		if distance_squared_units <= lod0_radius_squared:
+			desired_lods[chunk_id] = 0
+		elif distance_squared_units <= lod1_radius_squared:
+			desired_lods[chunk_id] = 1
+		elif distance_squared_units <= lod2_radius_squared:
+			desired_lods[chunk_id] = 2
+
+	return desired_lods

src/render/terrain/terrain_chunk_lod_planner.gd.uid

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

src/render/terrain/terrain_chunk_lod_policy.gd

@@ -0,0 +1,45 @@
+class_name TerrainChunkLodPolicy
+extends RefCounted
+
+## Immutable snapshot of the streamer's chunk-terrain LOD configuration.
+
+var is_enabled: bool:
+	get:
+		return _is_enabled
+
+var lod0_radius_chunks: int:
+	get:
+		return _lod0_radius_chunks
+
+var lod1_radius_chunks: int:
+	get:
+		return _lod1_radius_chunks
+
+var lod2_radius_chunks: int:
+	get:
+		return _lod2_radius_chunks
+
+var chunk_size_units: float:
+	get:
+		return _chunk_size_units
+
+var _is_enabled: bool
+var _lod0_radius_chunks: int
+var _lod1_radius_chunks: int
+var _lod2_radius_chunks: int
+var _chunk_size_units: float
+
+
+## Captures one renderer configuration snapshot for a deterministic plan.
+func _init(
+		is_enabled_value: bool,
+		lod0_radius_chunks_value: int,
+		lod1_radius_chunks_value: int,
+		lod2_radius_chunks_value: int,
+		chunk_size_units_value: float
+) -> void:
+	_is_enabled = is_enabled_value
+	_lod0_radius_chunks = lod0_radius_chunks_value
+	_lod1_radius_chunks = lod1_radius_chunks_value
+	_lod2_radius_chunks = lod2_radius_chunks_value
+	_chunk_size_units = chunk_size_units_value

src/render/terrain/terrain_chunk_lod_policy.gd.uid

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

src/render/terrain/terrain_quality_mesh_cache.gd

@@ -0,0 +1,73 @@
+class_name TerrainQualityMeshCache
+extends RefCounted
+
+## Session-memory LRU owner for full-quality terrain Mesh references retained
+## across tile unload/revisit. It owns no tile state, Node, RID, task or file.
+
+const EXCLUDED_QUALITY_SOURCES: Array[String] = [
+	"control_splat_cache",
+	"splat_cache",
+	"splat",
+]
+
+var _entries_by_tile_key: Dictionary = {}
+var _tile_keys_oldest_to_newest: Array[String] = []
+
+
+## Stores an admitted Mesh reference, touches it as newest and trims oldest
+## entries to the supplied non-negative capacity. Returns false when rejected.
+func store(tile_key: String, mesh: Mesh, source: String, capacity: int) -> bool:
+	if tile_key.is_empty() or mesh == null or EXCLUDED_QUALITY_SOURCES.has(source):
+		return false
+	_entries_by_tile_key[tile_key] = {"mesh": mesh, "source": source}
+	_touch(tile_key)
+	_trim(maxi(0, capacity))
+	return _entries_by_tile_key.has(tile_key)
+
+
+## Returns a fresh record containing the retained Mesh/source and touches the key
+## as newest. Missing or invalid records return empty and are removed.
+func restore(tile_key: String) -> Dictionary:
+	if not _entries_by_tile_key.has(tile_key):
+		return {}
+	var entry: Dictionary = _entries_by_tile_key[tile_key]
+	var source := String(entry.get("source", "baked_full"))
+	var mesh := entry.get("mesh") as Mesh
+	if mesh == null or EXCLUDED_QUALITY_SOURCES.has(source):
+		_remove(tile_key)
+		return {}
+	_touch(tile_key)
+	return {"mesh": mesh, "source": source}
+
+
+## Releases every retained Mesh reference and resets LRU order.
+func clear() -> void:
+	_entries_by_tile_key.clear()
+	_tile_keys_oldest_to_newest.clear()
+
+
+## Returns detached scalar diagnostics without exposing retained Mesh references.
+func diagnostic_snapshot() -> Dictionary:
+	var entries: Array[Dictionary] = []
+	for tile_key in _tile_keys_oldest_to_newest:
+		var entry: Dictionary = _entries_by_tile_key.get(tile_key, {})
+		entries.append({"tile_key": tile_key, "source": String(entry.get("source", ""))})
+	return {
+		"entry_count": entries.size(),
+		"entries_oldest_to_newest": entries,
+	}
+
+
+func _touch(tile_key: String) -> void:
+	_tile_keys_oldest_to_newest.erase(tile_key)
+	_tile_keys_oldest_to_newest.append(tile_key)
+
+
+func _trim(capacity: int) -> void:
+	while _tile_keys_oldest_to_newest.size() > capacity:
+		_remove(_tile_keys_oldest_to_newest.front())
+
+
+func _remove(tile_key: String) -> void:
+	_entries_by_tile_key.erase(tile_key)
+	_tile_keys_oldest_to_newest.erase(tile_key)

src/render/terrain/terrain_quality_mesh_cache.gd.uid

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

src/render/world_render_facade.gd

@@ -0,0 +1,243 @@
+@tool
+class_name WorldRenderFacade
+extends Node
+
+## Stable main-thread boundary between runtime/tool callers and the monolithic
+## streaming renderer. The facade owns no queues, caches, nodes or RIDs.
+
+const GODOT_WORLD_POSITION_SCRIPT := preload("res://src/domain/coordinates/godot_world_position.gd")
+const STREAMING_FOCUS_SCRIPT := preload("res://src/domain/streaming/streaming_focus.gd")
+const RENDERED_GROUND_SAMPLE_SCRIPT := preload("res://src/render/terrain/rendered_ground_sample.gd")
+const WORLD_ENVIRONMENT_SNAPSHOT_SCRIPT := preload("res://src/render/environment/world_environment_snapshot.gd")
+const ENTITY_PRESENTATION_SNAPSHOT_SCRIPT := preload("res://src/render/entities/entity_presentation_snapshot.gd")
+const ENTITY_ID_SCRIPT := preload("res://src/domain/identity/entity_id.gd")
+
+## Internal renderer implementation resolved relative to this node.
+## The referenced node remains owned by its scene parent.
+@export var streaming_world_loader_path: NodePath = NodePath("..")
+
+## Scene-owned outdoor environment implementation resolved relative to this node.
+## The facade delegates snapshots but owns neither the controller nor Environment.
+@export var world_environment_controller_path: NodePath = NodePath("../WowSkyController")
+
+## Scene-owned service that creates and owns session-local world entity visuals.
+@export var world_entity_presenter_path: NodePath = NodePath("../WorldEntityPresenter")
+
+## Optional explicit Node3D source sampled in Godot world coordinates.
+## Runtime scenes use the player; capture and probe tools replace it with their camera.
+@export var streaming_focus_source_path: NodePath
+
+var _streaming_world_loader: Node
+var _world_environment_controller: Node
+var _world_entity_presenter: Node
+var _missing_loader_reported := false
+var _missing_environment_controller_reported := false
+var _missing_entity_presenter_reported := false
+var _missing_focus_source_reported := false
+
+
+func _ready() -> void:
+	_resolve_streaming_world_loader()
+	set_process(streaming_focus_source_path != NodePath())
+	if streaming_focus_source_path != NodePath():
+		# Child nodes become ready before their parent StreamingWorldLoader. Only
+		# publish the initial focus here; the loader applies it after initialization.
+		_capture_streaming_focus_from_source()
+
+
+func _process(_delta_seconds: float) -> void:
+	_capture_streaming_focus_from_source()
+
+
+## Replaces the renderer focus. The immutable value remains caller-owned; the
+## internal streamer retains the reference for its next throttled refresh.
+func set_streaming_focus(streaming_focus: StreamingFocus) -> void:
+	var loader := _resolve_streaming_world_loader()
+	if loader == null:
+		return
+	loader.call("set_streaming_focus", streaming_focus)
+
+
+## Samples the configured source and requests target refresh from the internal
+## streamer. Returns false when either dependency or a valid focus is unavailable.
+func refresh_streaming_focus(force: bool = false) -> bool:
+	_capture_streaming_focus_from_source()
+	var loader := _resolve_streaming_world_loader()
+	if loader == null:
+		return false
+	return bool(loader.call("refresh_streaming_focus", force))
+
+
+## Returns a detached read-only metrics snapshot for diagnostics and baselines.
+## Mutating the returned Dictionary cannot mutate renderer-owned state.
+func renderer_metrics_snapshot() -> Dictionary:
+	var loader := _resolve_streaming_world_loader()
+	if loader == null:
+		return {}
+	var metrics_variant = loader.call("render_baseline_snapshot")
+	if not (metrics_variant is Dictionary):
+		push_error("WorldRenderFacade received a non-Dictionary renderer metrics snapshot.")
+		return {}
+	return (metrics_variant as Dictionary).duplicate(true)
+
+
+## Samples the currently loaded render terrain at a typed Godot world position.
+## This read-only renderer view is diagnostic and does not replace authoritative
+## gameplay collision or the independently composed [TerrainQuery].
+func sample_ground_height(godot_world_position: GodotWorldPosition) -> RefCounted:
+	var loader := _resolve_streaming_world_loader()
+	if loader == null:
+		return RENDERED_GROUND_SAMPLE_SCRIPT.unavailable(&"render_facade_unavailable")
+	var sample_variant = loader.call("sample_rendered_ground_height", godot_world_position)
+	if sample_variant is RefCounted and sample_variant.get_script() == RENDERED_GROUND_SAMPLE_SCRIPT:
+		return sample_variant
+	push_error("WorldRenderFacade received an invalid rendered ground sample.")
+	return RENDERED_GROUND_SAMPLE_SCRIPT.unavailable(&"render_ground_sample_invalid")
+
+
+## Returns a detached diagnostic snapshot for one rendered-ground query.
+## Mutating the result cannot mutate streamer queues, tile state or resources.
+func renderer_ground_query_snapshot(godot_world_position: GodotWorldPosition) -> Dictionary:
+	var loader := _resolve_streaming_world_loader()
+	if loader == null:
+		return {}
+	var snapshot_variant = loader.call("render_ground_query_snapshot", godot_world_position)
+	if not (snapshot_variant is Dictionary):
+		push_error("WorldRenderFacade received a non-Dictionary ground query snapshot.")
+		return {}
+	return (snapshot_variant as Dictionary).duplicate(true)
+
+
+## Applies an immutable environment snapshot through the renderer-owned sky path.
+## Returns false for an invalid value or unavailable/incompatible controller.
+func apply_environment_snapshot(world_environment_snapshot: RefCounted) -> bool:
+	if (
+		world_environment_snapshot == null
+		or world_environment_snapshot.get_script() != WORLD_ENVIRONMENT_SNAPSHOT_SCRIPT
+		or not bool(world_environment_snapshot.get("is_valid"))
+	):
+		return false
+	var controller := _resolve_world_environment_controller()
+	if controller == null:
+		return false
+	return bool(controller.call("apply_environment_snapshot", world_environment_snapshot))
+
+
+## Idempotently creates or updates one world entity visual through the renderer-
+## owned presenter. The immutable full snapshot remains caller-owned.
+func present_entity(entity_presentation_snapshot: RefCounted) -> bool:
+	if (
+		entity_presentation_snapshot == null
+		or entity_presentation_snapshot.get_script() != ENTITY_PRESENTATION_SNAPSHOT_SCRIPT
+		or not bool(entity_presentation_snapshot.get("is_valid"))
+	):
+		return false
+	var presenter := _resolve_world_entity_presenter()
+	if presenter == null:
+		return false
+	return bool(presenter.call("present_entity", entity_presentation_snapshot))
+
+
+## Removes one session-local entity visual without changing authoritative state.
+func remove_entity(entity_id: RefCounted) -> bool:
+	if entity_id == null or entity_id.get_script() != ENTITY_ID_SCRIPT or not bool(entity_id.call("is_valid")):
+		return false
+	var presenter := _resolve_world_entity_presenter()
+	if presenter == null:
+		return false
+	return bool(presenter.call("remove_entity", entity_id))
+
+
+## Returns detached entity-presentation diagnostics with no Node references.
+func entity_presentation_snapshot() -> Dictionary:
+	var presenter := _resolve_world_entity_presenter()
+	if presenter == null:
+		return {}
+	var snapshot_variant = presenter.call("entity_presentation_snapshot")
+	if not (snapshot_variant is Dictionary):
+		push_error("WorldRenderFacade received a non-Dictionary entity presentation snapshot.")
+		return {}
+	return (snapshot_variant as Dictionary).duplicate(true)
+
+
+func _capture_streaming_focus_from_source() -> void:
+	if streaming_focus_source_path == NodePath():
+		return
+	var focus_source := get_node_or_null(streaming_focus_source_path) as Node3D
+	if focus_source == null:
+		if not _missing_focus_source_reported:
+			push_warning("WorldRenderFacade focus source is missing or is not Node3D: %s" % streaming_focus_source_path)
+			_missing_focus_source_reported = true
+		return
+
+	_missing_focus_source_reported = false
+	var godot_position: Vector3 = focus_source.global_position
+	var typed_world_position = GODOT_WORLD_POSITION_SCRIPT.new(
+		godot_position.x,
+		godot_position.y,
+		godot_position.z
+	)
+	set_streaming_focus(STREAMING_FOCUS_SCRIPT.new(typed_world_position))
+
+
+func _resolve_streaming_world_loader() -> Node:
+	if is_instance_valid(_streaming_world_loader):
+		return _streaming_world_loader
+	var candidate := get_node_or_null(streaming_world_loader_path)
+	if candidate == null:
+		if not _missing_loader_reported:
+			push_error("WorldRenderFacade cannot resolve StreamingWorldLoader at %s" % streaming_world_loader_path)
+			_missing_loader_reported = true
+		return null
+	for required_method in [
+		&"set_streaming_focus",
+		&"refresh_streaming_focus",
+		&"render_baseline_snapshot",
+		&"sample_rendered_ground_height",
+		&"render_ground_query_snapshot",
+	]:
+		if not candidate.has_method(required_method):
+			if not _missing_loader_reported:
+				push_error("WorldRenderFacade renderer implementation lacks %s" % required_method)
+				_missing_loader_reported = true
+			return null
+	_streaming_world_loader = candidate
+	_missing_loader_reported = false
+	return _streaming_world_loader
+
+
+func _resolve_world_environment_controller() -> Node:
+	if is_instance_valid(_world_environment_controller):
+		return _world_environment_controller
+	var candidate := get_node_or_null(world_environment_controller_path)
+	if candidate == null or not candidate.has_method(&"apply_environment_snapshot"):
+		if not _missing_environment_controller_reported:
+			push_error(
+				"WorldRenderFacade cannot resolve a compatible environment controller at %s"
+				% world_environment_controller_path
+			)
+			_missing_environment_controller_reported = true
+		return null
+	_world_environment_controller = candidate
+	_missing_environment_controller_reported = false
+	return _world_environment_controller
+
+
+func _resolve_world_entity_presenter() -> Node:
+	if is_instance_valid(_world_entity_presenter):
+		return _world_entity_presenter
+	var candidate := get_node_or_null(world_entity_presenter_path)
+	if candidate == null:
+		if not _missing_entity_presenter_reported:
+			push_error("WorldRenderFacade cannot resolve entity presenter at %s" % world_entity_presenter_path)
+			_missing_entity_presenter_reported = true
+		return null
+	for required_method in [&"present_entity", &"remove_entity", &"entity_presentation_snapshot"]:
+		if not candidate.has_method(required_method):
+			if not _missing_entity_presenter_reported:
+				push_error("WorldRenderFacade entity presenter lacks %s" % required_method)
+				_missing_entity_presenter_reported = true
+			return null
+	_world_entity_presenter = candidate
+	_missing_entity_presenter_reported = false
+	return _world_entity_presenter

src/render/world_render_facade.gd.uid

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

src/scenes/character/character_animation_presenter.gd

@@ -0,0 +1,95 @@
+class_name CharacterAnimationPresenter
+extends Node
+
+## Selects and plays the current sandbox idle or moving animation.
+## Animation import, movement simulation and model composition remain external.
+
+const MOVING_ANIMATION_CANDIDATES: Array[String] = ["Run", "Walk"]
+const STATIONARY_ANIMATION_CANDIDATES: Array[String] = ["Stand", "Idle"]
+
+## Cross-fade time retained from the current sandbox controller.
+@export var animation_blend_time_seconds: float = 0.15
+
+var active_animation_name: String:
+	get:
+		return _active_animation_name
+
+var has_animation_player: bool:
+	get:
+		return _animation_player != null and is_instance_valid(_animation_player)
+
+var _animation_player: AnimationPlayer
+var _active_animation_name := ""
+
+
+## Finds the first AnimationPlayer below a newly composed character root.
+## Binding null or a root without animations clears the current presentation.
+func bind_character_root(character_root: Node) -> bool:
+	_animation_player = (
+		_find_animation_player(character_root)
+		if character_root != null and is_instance_valid(character_root)
+		else null
+	)
+	_active_animation_name = ""
+	if _animation_player == null:
+		return false
+	_prepare_animation_player(_animation_player)
+	present_locomotion(false)
+	return true
+
+
+## Presents the current moving/stationary locomotion state.
+## Returns true only when a different animation starts playing.
+func present_locomotion(is_moving: bool) -> bool:
+	if _animation_player == null or not is_instance_valid(_animation_player):
+		_animation_player = null
+		_active_animation_name = ""
+		return false
+	var candidates := MOVING_ANIMATION_CANDIDATES if is_moving else STATIONARY_ANIMATION_CANDIDATES
+	var selected_animation := _choose_animation(candidates)
+	if selected_animation.is_empty() or selected_animation == _active_animation_name:
+		return false
+	_active_animation_name = selected_animation
+	_animation_player.play(selected_animation, animation_blend_time_seconds)
+	return true
+
+
+func _prepare_animation_player(animation_player: AnimationPlayer) -> void:
+	animation_player.playback_default_blend_time = animation_blend_time_seconds
+	for animation_name in animation_player.get_animation_list():
+		var lowercase_name := String(animation_name).to_lower()
+		if (
+			lowercase_name == "stand"
+			or lowercase_name == "idle"
+			or lowercase_name == "run"
+			or lowercase_name == "walk"
+			or lowercase_name.contains("stand")
+			or lowercase_name.contains("run")
+			or lowercase_name.contains("walk")
+		):
+			var animation := animation_player.get_animation(animation_name)
+			if animation != null:
+				animation.loop_mode = Animation.LOOP_LINEAR
+
+
+func _choose_animation(candidates: Array[String]) -> String:
+	for candidate in candidates:
+		if _animation_player.has_animation(candidate):
+			return candidate
+	var animation_names := _animation_player.get_animation_list()
+	for candidate in candidates:
+		var lowercase_candidate := candidate.to_lower()
+		for animation_name in animation_names:
+			if String(animation_name).to_lower().contains(lowercase_candidate):
+				return String(animation_name)
+	return ""
+
+
+func _find_animation_player(root: Node) -> AnimationPlayer:
+	if root is AnimationPlayer:
+		return root
+	for child in root.get_children():
+		var animation_player := _find_animation_player(child)
+		if animation_player != null:
+			return animation_player
+	return null

src/scenes/character/character_animation_presenter.gd.uid

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

src/scenes/character/character_appearance_presenter.gd

@@ -0,0 +1,150 @@
+class_name CharacterAppearancePresenter
+extends Node3D
+
+## Composes one sandbox character model, texture compositor and starter outfit.
+## The presenter owns only nodes below the existing Visual scene boundary.
+
+const GEOSET_CONTROLLER_SCRIPT := preload("res://src/scenes/character/character_geoset_controller.gd")
+const TEXTURE_COMPOSITOR_SCRIPT := preload("res://src/scenes/character/character_texture_compositor.gd")
+const OUTFIT_RESOLVER_SCRIPT := preload("res://src/scenes/character/wow_character_outfit_resolver.gd")
+
+signal character_appearance_ready(character_root: Node3D)
+
+## Packed character scene used by the current render sandbox.
+@export var character_model_path: String = "res://src/resources/characters/HUMAN/MALE/HumanMale.glb"
+## Character class used when resolving the current starter outfit.
+@export var character_class_id: int = 1
+## Uniform scale applied to the composed character root.
+@export var character_scale: float = 1.0
+## Model-space yaw correction retained from the current sandbox.
+@export var character_yaw_offset_degrees: float = 90.0
+## Root containing extracted DBC and item texture inputs.
+@export var extracted_data_directory: String = "res://data/extracted"
+
+var character_root: Node3D:
+	get:
+		return _character_root
+
+var _character_root: Node3D
+
+
+## Loads and composes the configured character model below this Visual node.
+## A non-empty directory argument keeps the player's terrain/content root aligned.
+## Returns false immediately when no model is configured or the resource is invalid.
+func load_character_appearance(content_root_override: String = "") -> bool:
+	if not content_root_override.is_empty():
+		extracted_data_directory = content_root_override
+	_clear_character_root()
+	if character_model_path.is_empty():
+		return false
+	var character_scene := load(character_model_path) as PackedScene
+	if character_scene == null:
+		push_warning("CharacterAppearancePresenter: cannot load character model: %s" % character_model_path)
+		return false
+
+	if is_class("MeshInstance3D"):
+		set("mesh", null)
+	position = Vector3.ZERO
+
+	_character_root = Node3D.new()
+	_character_root.name = "CharacterModel"
+	_character_root.set_script(GEOSET_CONTROLLER_SCRIPT)
+	_character_root.scale = Vector3.ONE * maxf(character_scale, 0.001)
+	_character_root.rotation_degrees.y = character_yaw_offset_degrees
+
+	var character_instance := character_scene.instantiate()
+	character_instance.name = character_model_path.get_file().get_basename()
+	_character_root.add_child(character_instance)
+
+	var texture_compositor := Node.new()
+	texture_compositor.name = "CharacterTextureCompositor"
+	texture_compositor.set_script(TEXTURE_COMPOSITOR_SCRIPT)
+	texture_compositor.set("textures_dir", _character_textures_directory(character_model_path))
+	texture_compositor.set("extracted_dir", extracted_data_directory)
+	_character_root.add_child(texture_compositor)
+	add_child(_character_root)
+	_complete_character_composition.call_deferred(_character_root, texture_compositor)
+	return true
+
+
+func _complete_character_composition(expected_character_root: Node3D, texture_compositor: Node) -> void:
+	if expected_character_root != _character_root or not is_instance_valid(expected_character_root):
+		return
+	_fit_character_to_ground(expected_character_root)
+	_apply_character_starter_outfit(expected_character_root, texture_compositor)
+	character_appearance_ready.emit(expected_character_root)
+
+
+func _clear_character_root() -> void:
+	if _character_root == null or not is_instance_valid(_character_root):
+		_character_root = null
+		return
+	remove_child(_character_root)
+	_character_root.queue_free()
+	_character_root = null
+
+
+func _fit_character_to_ground(root: Node3D) -> void:
+	var character_bounds := _calculate_global_bounds(root)
+	if character_bounds.size == Vector3.ZERO:
+		return
+	var local_minimum_y := character_bounds.position.y - root.global_position.y
+	root.position.y -= local_minimum_y
+
+
+func _apply_character_starter_outfit(root: Node3D, texture_compositor: Node) -> void:
+	if texture_compositor == null:
+		return
+	var outfit_resolver: RefCounted = OUTFIT_RESOLVER_SCRIPT.new()
+	if not outfit_resolver.call("load_dbcs", extracted_data_directory):
+		return
+	var inferred_identity: Dictionary = outfit_resolver.call(
+		"infer_race_gender_from_model_path",
+		character_model_path
+	)
+	var race_name := String(inferred_identity.get("race", "Human"))
+	var gender_name := String(inferred_identity.get("gender", "Male"))
+	var starter_outfit: Dictionary = outfit_resolver.call(
+		"resolve_start_outfit",
+		race_name,
+		gender_name,
+		character_class_id
+	)
+	if starter_outfit.is_empty():
+		return
+	if texture_compositor.has_method("set_equipment_components"):
+		texture_compositor.call(
+			"set_equipment_components",
+			starter_outfit.get("textures", PackedStringArray())
+		)
+	if root.has_method("apply_outfit_defaults"):
+		root.call("apply_outfit_defaults", starter_outfit)
+
+
+func _calculate_global_bounds(root: Node) -> AABB:
+	var combined_bounds := AABB()
+	var has_bounds := false
+	for mesh_instance in _mesh_instances_below(root):
+		if mesh_instance.mesh == null:
+			continue
+		var global_bounds := mesh_instance.global_transform * mesh_instance.mesh.get_aabb()
+		combined_bounds = global_bounds if not has_bounds else combined_bounds.merge(global_bounds)
+		has_bounds = true
+	return combined_bounds if has_bounds else AABB()
+
+
+func _mesh_instances_below(root: Node) -> Array[MeshInstance3D]:
+	var mesh_instances: Array[MeshInstance3D] = []
+	_collect_mesh_instances(root, mesh_instances)
+	return mesh_instances
+
+
+func _collect_mesh_instances(node: Node, mesh_instances: Array[MeshInstance3D]) -> void:
+	if node is MeshInstance3D:
+		mesh_instances.append(node)
+	for child in node.get_children():
+		_collect_mesh_instances(child, mesh_instances)
+
+
+func _character_textures_directory(model_path: String) -> String:
+	return model_path.get_base_dir().path_join(model_path.get_file().get_basename() + "_textures")

src/scenes/character/character_appearance_presenter.gd.uid

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

src/scenes/player/third_person_camera_rig.gd

@@ -94,6 +94,12 @@ func initialize_for_character(character_body: Node3D) -> void:
 	refresh_camera_transform()
 
 
+## Synchronizes orbit yaw after keyboard turning changes the character transform.
+func synchronize_yaw_from_character() -> void:
+	if _character_body != null:
+		_yaw_radians = _character_body.rotation.y
+
+
 ## Replaces camera-distance collision behavior and immediately refreshes the camera.
 ## Passing null is rejected and preserves the current policy.
 func set_collision_policy(collision_policy: CameraCollisionPolicy) -> void:

src/scenes/player/third_person_wow_controller.gd

@@ -1,8 +1,5 @@
 extends CharacterBody3D
 
-const GEOSET_CONTROLLER_SCRIPT := preload("res://src/scenes/character/character_geoset_controller.gd")
-const TEXTURE_COMPOSITOR_SCRIPT := preload("res://src/scenes/character/character_texture_compositor.gd")
-const OUTFIT_RESOLVER_SCRIPT := preload("res://src/scenes/character/wow_character_outfit_resolver.gd")
 const COORDINATE_MAPPER_SCRIPT := preload("res://src/domain/coordinates/coordinate_mapper.gd")
 const GODOT_WORLD_POSITION_SCRIPT := preload("res://src/domain/coordinates/godot_world_position.gd")
 const ADT_TILE_COORDINATE_SCRIPT := preload("res://src/domain/coordinates/adt_tile_coordinate.gd")
@@ -10,6 +7,7 @@ const ADT_TILE_LOCAL_POSITION_SCRIPT := preload("res://src/domain/coordinates/ad
 const PLAYER_INPUT_SOURCE_SCRIPT := preload("res://src/gameplay/input/player_input_source.gd")
 const PLAYER_INPUT_ACTIONS_SCRIPT := preload("res://src/gameplay/input/player_input_actions.gd")
 const LOCAL_PLAYER_MOVEMENT_CONTROLLER_SCRIPT := preload("res://src/gameplay/movement/local_player_movement_controller.gd")
+const PLAYER_MOVEMENT_CAPABILITIES_SCRIPT := preload("res://src/gameplay/movement/player_movement_capabilities.gd")
 const ADT_TERRAIN_QUERY_SCRIPT := preload("res://src/gameplay/terrain/adt_terrain_query.gd")
 
 @export var extracted_dir: String = "res://data/extracted"
@@ -24,22 +22,21 @@ const ADT_TERRAIN_QUERY_SCRIPT := preload("res://src/gameplay/terrain/adt_terrai
 @export var sprint_multiplier: float = 6.0
 @export var flight_vertical_speed: float = 7.0
 @export var acceleration: float = 28.0
+## TrinityCore 3.3.5 player MOVE_TURN_RATE default, in radians per second.
+@export var keyboard_turn_speed_radians_per_second: float = 3.141594
+## Local composition profile. RenderSandbox preserves debug sprint/free flight;
+## Blizzlike335 rejects them but does not yet claim complete movement parity.
+@export_enum("RenderSandbox", "Blizzlike335") var movement_profile_id: String = "RenderSandbox"
 @export var ground_offset: float = 0.05
 @export var ground_snap_speed: float = 24.0
 
 @export var camera_pivot_path: NodePath = NodePath("CameraPivot")
 @export var visual_path: NodePath = NodePath("Visual")
-@export var character_model_path: String = "res://src/resources/characters/HUMAN/MALE/HumanMale.glb"
-@export var character_class_id: int = 1
-@export var character_scale: float = 1.0
-@export var character_yaw_offset_degrees: float = 90.0
-@export var animation_blend_time: float = 0.15
+@export var animation_presenter_path: NodePath = NodePath("Visual/AnimationPresenter")
 
 var _camera_rig: ThirdPersonCameraRig
-var _visual: Node3D
-var _character_root: Node3D
-var _animation_player: AnimationPlayer
-var _active_animation := ""
+var _appearance_presenter: CharacterAppearancePresenter
+var _animation_presenter: CharacterAnimationPresenter
 var _player_input_source: PlayerInputSource
 var _local_movement_controller: LocalPlayerMovementController
 var _terrain_query: TerrainQuery
@@ -55,7 +52,7 @@ func set_terrain_query(terrain_query: TerrainQuery) -> void:
 
 
 func _ready() -> void:
-	_player_input_source = PLAYER_INPUT_SOURCE_SCRIPT.new()
+	_player_input_source = PLAYER_INPUT_SOURCE_SCRIPT.new(StringName(movement_profile_id))
 	if _terrain_query == null:
 		_terrain_query = ADT_TERRAIN_QUERY_SCRIPT.new(extracted_dir, map_name)
 	_local_movement_controller = LOCAL_PLAYER_MOVEMENT_CONTROLLER_SCRIPT.new(
@@ -64,21 +61,30 @@ func _ready() -> void:
 		strafe_speed,
 		flight_vertical_speed,
 		acceleration,
-		sprint_multiplier
+		sprint_multiplier,
+		PLAYER_MOVEMENT_CAPABILITIES_SCRIPT.for_profile_id(StringName(movement_profile_id)),
+		keyboard_turn_speed_radians_per_second
 	)
 	_camera_rig = get_node_or_null(camera_pivot_path) as ThirdPersonCameraRig
-	_visual = get_node_or_null(visual_path) as Node3D
+	_appearance_presenter = get_node_or_null(visual_path) as CharacterAppearancePresenter
+	_animation_presenter = get_node_or_null(animation_presenter_path) as CharacterAnimationPresenter
 	if _camera_rig == null:
 		push_error("ThirdPersonWowController: ThirdPersonCameraRig not found at %s" % camera_pivot_path)
 	else:
 		_camera_rig.initialize_for_character(self)
+	if _appearance_presenter == null:
+		push_error("ThirdPersonWowController: CharacterAppearancePresenter not found at %s" % visual_path)
+	else:
+		_appearance_presenter.character_appearance_ready.connect(_on_character_appearance_ready)
+		_appearance_presenter.load_character_appearance(extracted_dir)
+	if _animation_presenter == null:
+		push_error("ThirdPersonWowController: CharacterAnimationPresenter not found at %s" % animation_presenter_path)
 	if spawn_at_tile_center:
 		var spawn_tile = ADT_TILE_COORDINATE_SCRIPT.new(spawn_tile_x, spawn_tile_y)
 		var half_tile_size := COORDINATE_MAPPER_SCRIPT.ADT_TILE_SIZE_YARDS * 0.5
 		var spawn_local = ADT_TILE_LOCAL_POSITION_SCRIPT.new(half_tile_size, global_position.y, half_tile_size)
 		var spawn_position = COORDINATE_MAPPER_SCRIPT.adt_tile_local_to_godot(spawn_tile, spawn_local)
 		global_position = Vector3(spawn_position.x_units, spawn_position.y_units, spawn_position.z_units)
-	_load_character_visual()
 	var spawn_ground_sample := _sample_ground_height(global_position)
 	if spawn_ground_sample.is_available:
 		global_position.y = spawn_ground_sample.height_units + ground_offset
@@ -93,6 +99,14 @@ func _unhandled_input(event: InputEvent) -> void:
 
 func _physics_process(delta: float) -> void:
 	var move_intent := _player_input_source.sample_move_intent()
+	var yaw_delta_radians := _local_movement_controller.calculate_yaw_delta_radians(
+		move_intent,
+		delta
+	)
+	if not is_zero_approx(yaw_delta_radians):
+		rotation.y += yaw_delta_radians
+		if _camera_rig != null:
+			_camera_rig.synchronize_yaw_from_character()
 	var godot_world_movement_basis := global_basis
 	if _local_movement_controller.is_flight_enabled and _camera_rig != null:
 		godot_world_movement_basis = _camera_rig.godot_world_flight_movement_basis()
@@ -106,160 +120,16 @@ func _physics_process(delta: float) -> void:
 
 	var movement_velocity := _local_movement_controller.godot_world_velocity_units_per_second
 	var horizontal_motion := Vector2(movement_velocity.x, movement_velocity.z)
-	if _visual and horizontal_motion.length_squared() > 0.01:
-		_visual.global_rotation.y = atan2(-movement_velocity.x, -movement_velocity.z)
+	if _appearance_presenter != null and horizontal_motion.length_squared() > 0.01:
+		_appearance_presenter.global_rotation.y = atan2(-movement_velocity.x, -movement_velocity.z)
 
-	_update_character_animation(horizontal_motion.length_squared() > 0.04)
-
-func _load_character_visual() -> void:
-	if character_model_path.is_empty() or _visual == null:
-		return
-	if _visual is MeshInstance3D:
-		(_visual as MeshInstance3D).mesh = null
-	_visual.position = Vector3.ZERO
-
-	if _character_root and is_instance_valid(_character_root):
-		_character_root.queue_free()
-	_character_root = null
-	_animation_player = null
-	_active_animation = ""
-
-	var scene: PackedScene = load(character_model_path)
-	if scene == null:
-		push_warning("ThirdPersonWowController: cannot load character model: %s" % character_model_path)
-		return
-
-	_character_root = Node3D.new()
-	_character_root.name = "CharacterModel"
-	_character_root.set_script(GEOSET_CONTROLLER_SCRIPT)
-	_character_root.scale = Vector3.ONE * maxf(character_scale, 0.001)
-	_character_root.rotation_degrees.y = character_yaw_offset_degrees
-
-	var instance := scene.instantiate()
-	instance.name = character_model_path.get_file().get_basename()
-	_character_root.add_child(instance)
-
-	var compositor := Node.new()
-	compositor.name = "CharacterTextureCompositor"
-	compositor.set_script(TEXTURE_COMPOSITOR_SCRIPT)
-	compositor.set("textures_dir", _character_textures_dir(character_model_path))
-	compositor.set("extracted_dir", extracted_dir)
-	_character_root.add_child(compositor)
-
-	_visual.add_child(_character_root)
-	await get_tree().process_frame
-	_fit_character_to_ground()
-	_apply_character_starter_outfit(compositor)
-	_animation_player = _find_animation_player(_character_root)
-	if _animation_player:
-		_prepare_animation_player(_animation_player)
-	_update_character_animation(false)
+	if _animation_presenter != null:
+		_animation_presenter.present_locomotion(horizontal_motion.length_squared() > 0.04)
 
 
-func _fit_character_to_ground() -> void:
-	if _character_root == null:
-		return
-	var aabb := _calculate_aabb(_character_root)
-	if aabb.size == Vector3.ZERO:
-		return
-	var local_min_y := aabb.position.y - _character_root.global_position.y
-	_character_root.position.y -= local_min_y
-
-
-func _apply_character_starter_outfit(compositor: Node) -> void:
-	if _character_root == null or compositor == null:
-		return
-	var resolver: RefCounted = OUTFIT_RESOLVER_SCRIPT.new()
-	if not resolver.call("load_dbcs", extracted_dir):
-		return
-	var inferred: Dictionary = resolver.call("infer_race_gender_from_model_path", character_model_path)
-	var race := String(inferred.get("race", "Human"))
-	var gender := String(inferred.get("gender", "Male"))
-	var outfit: Dictionary = resolver.call("resolve_start_outfit", race, gender, character_class_id)
-	if outfit.is_empty():
-		return
-	if compositor.has_method("set_equipment_components"):
-		compositor.call("set_equipment_components", outfit.get("textures", PackedStringArray()))
-	if _character_root.has_method("apply_outfit_defaults"):
-		_character_root.call("apply_outfit_defaults", outfit)
-
-
-func _update_character_animation(is_moving: bool) -> void:
-	if _animation_player == null:
-		return
-	var wanted := _choose_animation(["Run", "Walk"]) if is_moving else _choose_animation(["Stand", "Idle"])
-	if wanted.is_empty() or wanted == _active_animation:
-		return
-	_active_animation = wanted
-	_animation_player.play(wanted, animation_blend_time)
-
-
-func _prepare_animation_player(player: AnimationPlayer) -> void:
-	player.playback_default_blend_time = animation_blend_time
-	for animation_name in player.get_animation_list():
-		var lower := String(animation_name).to_lower()
-		if lower == "stand" or lower == "idle" or lower == "run" or lower == "walk" or lower.contains("stand") or lower.contains("run") or lower.contains("walk"):
-			var animation := player.get_animation(animation_name)
-			if animation:
-				animation.loop_mode = Animation.LOOP_LINEAR
-
-
-func _choose_animation(candidates: Array[String]) -> String:
-	if _animation_player == null:
-		return ""
-	for candidate in candidates:
-		if _animation_player.has_animation(candidate):
-			return candidate
-	var list := _animation_player.get_animation_list()
-	for candidate in candidates:
-		var lower := candidate.to_lower()
-		for animation_name in list:
-			if String(animation_name).to_lower().contains(lower):
-				return String(animation_name)
-	return ""
-
-
-func _find_animation_player(root: Node) -> AnimationPlayer:
-	if root is AnimationPlayer:
-		return root
-	for child in root.get_children():
-		var found := _find_animation_player(child)
-		if found:
-			return found
-	return null
-
-
-func _calculate_aabb(root: Node) -> AABB:
-	var result := AABB()
-	var has_aabb := false
-	for mesh_inst in _iter_mesh_instances(root):
-		if mesh_inst.mesh == null:
-			continue
-		var local_aabb := mesh_inst.mesh.get_aabb()
-		var global_aabb := mesh_inst.global_transform * local_aabb
-		if not has_aabb:
-			result = global_aabb
-			has_aabb = true
-		else:
-			result = result.merge(global_aabb)
-	return result if has_aabb else AABB()
-
-
-func _iter_mesh_instances(root: Node) -> Array[MeshInstance3D]:
-	var result: Array[MeshInstance3D] = []
-	_collect_mesh_instances(root, result)
-	return result
-
-
-func _collect_mesh_instances(node: Node, result: Array[MeshInstance3D]) -> void:
-	if node is MeshInstance3D:
-		result.append(node)
-	for child in node.get_children():
-		_collect_mesh_instances(child, result)
-
-
-func _character_textures_dir(model_path: String) -> String:
-	return model_path.get_base_dir().path_join(model_path.get_file().get_basename() + "_textures")
+func _on_character_appearance_ready(character_root: Node3D) -> void:
+	if _animation_presenter != null:
+		_animation_presenter.bind_character_root(character_root)
 
 
 func _sample_ground_height(godot_world_position: Vector3) -> TerrainGroundSample:

src/scenes/sky/wow_sky_controller.gd

@@ -4,6 +4,7 @@ extends Node
 const M2_BUILDER_SCRIPT := preload("res://addons/mpq_extractor/loaders/m2_builder.gd")
 const COORDINATE_MAPPER_SCRIPT := preload("res://src/domain/coordinates/coordinate_mapper.gd")
 const GODOT_WORLD_POSITION_SCRIPT := preload("res://src/domain/coordinates/godot_world_position.gd")
+const WORLD_ENVIRONMENT_SNAPSHOT_SCRIPT := preload("res://src/render/environment/world_environment_snapshot.gd")
 
 const LIGHT_COORD_SCALE := 36.0
 const HALF_MINUTES_PER_DAY := 2880
@@ -133,6 +134,22 @@ func _process(delta: float) -> void:
 	_update_skybox_transform()
 
 
+## Accepts an authoritative time snapshot without moving DBC visual selection out
+## of this controller. Existing fixed-clock behavior is preserved and frozen until
+## another snapshot or explicit local clock configuration is supplied.
+func apply_environment_snapshot(world_environment_snapshot: RefCounted) -> bool:
+	if (
+		world_environment_snapshot == null
+		or world_environment_snapshot.get_script() != WORLD_ENVIRONMENT_SNAPSHOT_SCRIPT
+		or not bool(world_environment_snapshot.get("is_valid"))
+	):
+		return false
+	use_system_time = false
+	time_speed = 0.0
+	fixed_time_hours = float(world_environment_snapshot.get("time_of_day_hours"))
+	return true
+
+
 func _resolve_nodes() -> void:
 	if not world_environment_path.is_empty():
 		_world_environment = get_node_or_null(world_environment_path) as WorldEnvironment

src/scenes/streaming/eastern_kingdoms_streaming.tscn

@@ -3,7 +3,11 @@
 [ext_resource type="Script" uid="uid://yi6lawwjgocg" path="res://src/scenes/streaming/streaming_world_loader.gd" id="1_stream"]
 [ext_resource type="Script" uid="uid://ltn2ko5kxvo4" path="res://src/scenes/player/third_person_wow_controller.gd" id="2_player"]
 [ext_resource type="Script" uid="uid://didjth34ut0v1" path="res://src/scenes/sky/wow_sky_controller.gd" id="3_sky"]
-[ext_resource type="Script" path="res://src/scenes/player/third_person_camera_rig.gd" id="4_camera_rig"]
+[ext_resource type="Script" uid="uid://cq60al4uw0mgo" path="res://src/scenes/player/third_person_camera_rig.gd" id="4_camera_rig"]
+[ext_resource type="Script" uid="uid://bhqbo1ftrt3a3" path="res://src/scenes/character/character_appearance_presenter.gd" id="5_appearance"]
+[ext_resource type="Script" uid="uid://c2jnn0e3mmymc" path="res://src/scenes/character/character_animation_presenter.gd" id="6_animation"]
+[ext_resource type="Script" path="res://src/render/world_render_facade.gd" id="7_render_facade"]
+[ext_resource type="Script" path="res://src/render/entities/world_entity_presenter.gd" id="8_entity_presenter"]
 
 [sub_resource type="CapsuleShape3D" id="PlayerCapsuleShape_1"]
 radius = 0.45
@@ -54,7 +58,6 @@ fog_depth_end = 5200.0
 
 [node name="StreamingWorld" type="Node3D" unique_id=1063159974]
 script = ExtResource("1_stream")
-streaming_focus_source_path = NodePath("ThirdPersonPlayer")
 camera_path = NodePath("ThirdPersonPlayer/CameraPivot/Camera3D")
 quality_preset = "High"
 update_interval = 0.1
@@ -92,11 +95,22 @@ wmo_visibility_range = 3600.0
 debug_streaming = true
 hitch_profiler_enabled = true
 
+[node name="WorldRenderFacade" type="Node" parent="."]
+script = ExtResource("7_render_facade")
+streaming_world_loader_path = NodePath("..")
+streaming_focus_source_path = NodePath("../ThirdPersonPlayer")
+world_environment_controller_path = NodePath("../WowSkyController")
+world_entity_presenter_path = NodePath("../WorldEntityPresenter")
+
+[node name="WorldEntityPresenter" type="Node3D" parent="."]
+script = ExtResource("8_entity_presenter")
+
 [node name="ThirdPersonPlayer" type="CharacterBody3D" parent="." unique_id=502573687]
 transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 16800, 80, 26400)
 script = ExtResource("2_player")
 spawn_tile_x = 31
 spawn_tile_y = 49
+movement_profile_id = "Blizzlike335"
 
 [node name="CollisionShape3D" type="CollisionShape3D" parent="ThirdPersonPlayer" unique_id=1297880621]
 transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1.05, 0)
@@ -105,6 +119,10 @@ shape = SubResource("PlayerCapsuleShape_1")
 [node name="Visual" type="MeshInstance3D" parent="ThirdPersonPlayer" unique_id=1028210492]
 transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1.05, 0)
 mesh = SubResource("PlayerCapsuleMesh_1")
+script = ExtResource("5_appearance")
+
+[node name="AnimationPresenter" type="Node" parent="ThirdPersonPlayer/Visual" unique_id=2131488264]
+script = ExtResource("6_animation")
 
 [node name="CameraPivot" type="Node3D" parent="ThirdPersonPlayer" unique_id=499263249]
 transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1.7, 0)

src/scenes/streaming/kalimdor_streaming.tscn

@@ -4,6 +4,10 @@
 [ext_resource type="Script" uid="uid://ltn2ko5kxvo4" path="res://src/scenes/player/third_person_wow_controller.gd" id="2_puy8r"]
 [ext_resource type="Script" uid="uid://didjth34ut0v1" path="res://src/scenes/sky/wow_sky_controller.gd" id="3_43ha7"]
 [ext_resource type="Script" path="res://src/scenes/player/third_person_camera_rig.gd" id="4_camera_rig"]
+[ext_resource type="Script" path="res://src/scenes/character/character_appearance_presenter.gd" id="5_appearance"]
+[ext_resource type="Script" path="res://src/scenes/character/character_animation_presenter.gd" id="6_animation"]
+[ext_resource type="Script" path="res://src/render/world_render_facade.gd" id="7_render_facade"]
+[ext_resource type="Script" path="res://src/render/entities/world_entity_presenter.gd" id="8_entity_presenter"]
 
 [sub_resource type="CapsuleShape3D" id="PlayerCapsuleShape_1"]
 radius = 0.45
@@ -55,7 +59,6 @@ fog_depth_end = 5200.0
 [node name="StreamingWorld" type="Node3D" unique_id=1063159974]
 script = ExtResource("1_sisqv")
 map_name = "Kalimdor"
-streaming_focus_source_path = NodePath("ThirdPersonPlayer")
 camera_path = NodePath("ThirdPersonPlayer/CameraPivot/Camera3D")
 quality_preset = "High"
 update_interval = 0.1
@@ -93,6 +96,16 @@ wmo_visibility_range = 3600.0
 debug_streaming = true
 hitch_profiler_enabled = true
 
+[node name="WorldRenderFacade" type="Node" parent="."]
+script = ExtResource("7_render_facade")
+streaming_world_loader_path = NodePath("..")
+streaming_focus_source_path = NodePath("../ThirdPersonPlayer")
+world_environment_controller_path = NodePath("../WowSkyController")
+world_entity_presenter_path = NodePath("../WorldEntityPresenter")
+
+[node name="WorldEntityPresenter" type="Node3D" parent="."]
+script = ExtResource("8_entity_presenter")
+
 [node name="ThirdPersonPlayer" type="CharacterBody3D" parent="." unique_id=502573687]
 transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 16800, 80, 26400)
 script = ExtResource("2_puy8r")
@@ -106,6 +119,10 @@ shape = SubResource("PlayerCapsuleShape_1")
 [node name="Visual" type="MeshInstance3D" parent="ThirdPersonPlayer" unique_id=1028210492]
 transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1.05, 0)
 mesh = SubResource("PlayerCapsuleMesh_1")
+script = ExtResource("5_appearance")
+
+[node name="AnimationPresenter" type="Node" parent="ThirdPersonPlayer/Visual"]
+script = ExtResource("6_animation")
 
 [node name="CameraPivot" type="Node3D" parent="ThirdPersonPlayer" unique_id=499263249]
 transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1.7, 0)

src/tests/fixtures/player_input_profile_335.json

@@ -0,0 +1,57 @@
+{
+  "schema_version": 1,
+  "profile_id": "Blizzlike335",
+  "sources": {
+    "original_client_default_bindings": {
+      "status": "verified_private_metadata",
+      "build": 12340,
+      "path": "WTF/DefaultBindings.wtf",
+      "sha256": "35FFA0E4E2356A13A0633A848F9E57ABE7DF9D8A16C2245E15D33013AD2F56A5",
+      "distribution": "Selected binding facts only; proprietary file remains outside Git."
+    },
+    "original_client_binding_commands": {
+      "status": "verified_private_metadata",
+      "build": 12340,
+      "path": "Interface/FrameXML/Bindings.xml",
+      "sha256": "2E01276AFB7462F1417710F13B4BF1A456341F7F28CC8AE0D6D9C7442D7F6793",
+      "distribution": "Hash and selected command names only; proprietary file remains outside Git."
+    },
+    "trinitycore_player_turn_rate": {
+      "status": "verified_public_source",
+      "repository": "TrinityCore/TrinityCore",
+      "revision": "2853a621d6af91a803787a2b8a509f4ce3e0300d",
+      "path": "src/server/game/Entities/Unit/Unit.cpp",
+      "url": "https://raw.githubusercontent.com/TrinityCore/TrinityCore/2853a621d6af91a803787a2b8a509f4ce3e0300d/src/server/game/Entities/Unit/Unit.cpp",
+      "symbol": "playerBaseMoveSpeed[MOVE_TURN_RATE]",
+      "radians_per_second": 3.141594
+    },
+    "wowee_mouse_strafe_reference": {
+      "status": "verified_public_reference_only",
+      "repository": "Kelsidavis/WoWee",
+      "revision": "626243e937fb93965fa583a6507ed5a1aa7dda4b",
+      "path": "src/rendering/camera_controller.cpp",
+      "sha256": "54A41EFDA77629B2EAB432734A94D0F6F58223F3E4752338FF4C321E7835001B",
+      "observation": "A/D turn while right mouse is released and strafe while it is held; Q/E always strafe.",
+      "fidelity_limit": "Reference implementation behavior, not original-client proof."
+    }
+  },
+  "selected_default_bindings": [
+    {"command": "MOVEFORWARD", "keys": ["W", "UP"], "implemented_action": "openwc_player_move_forward"},
+    {"command": "MOVEBACKWARD", "keys": ["S", "DOWN"], "implemented_action": "openwc_player_move_backward"},
+    {"command": "TURNLEFT", "keys": ["A", "LEFT"], "implemented_action": "openwc_player_turn_left"},
+    {"command": "TURNRIGHT", "keys": ["D", "RIGHT"], "implemented_action": "openwc_player_turn_right"},
+    {"command": "STRAFELEFT", "keys": ["Q"], "implemented_action": "openwc_player_blizzlike_strafe_left"},
+    {"command": "STRAFERIGHT", "keys": ["E"], "implemented_action": "openwc_player_blizzlike_strafe_right"},
+    {"command": "JUMP", "keys": ["SPACE", "NUMPAD0"], "implemented_action": null},
+    {"command": "TOGGLEAUTORUN", "keys": ["NUMLOCK", "BUTTON4"], "implemented_action": null},
+    {"command": "CAMERAZOOMIN", "keys": ["MOUSEWHEELUP"], "implemented_action": "openwc_player_camera_zoom_in"},
+    {"command": "CAMERAZOOMOUT", "keys": ["MOUSEWHEELDOWN"], "implemented_action": "openwc_player_camera_zoom_out"},
+    {"command": "TURNORACTION", "keys": ["BUTTON2"], "implemented_action": "openwc_player_camera_rotate"},
+    {"command": "CAMERAORSELECTORMOVE", "keys": ["BUTTON1"], "implemented_action": null}
+  ],
+  "known_gaps": [
+    "Jump, autorun and left-button camera/select behavior are recorded but not implemented by this package.",
+    "The server-core turn-rate default is compatibility evidence, not direct original-client timing proof.",
+    "Right-mouse A/D strafe routing is supported by a public reference implementation, not direct original-client capture."
+  ]
+}

src/tests/scenes/character_presentation_model_fixture.tscn

@@ -0,0 +1,10 @@
+[gd_scene load_steps=2 format=3]
+
+[sub_resource type="BoxMesh" id="BoxMesh_character"]
+size = Vector3(1, 2, 1)
+
+[node name="SyntheticCharacter" type="Node3D"]
+
+[node name="Body" type="MeshInstance3D" parent="."]
+position = Vector3(0, 2, 0)
+mesh = SubResource("BoxMesh_character")

src/tests/scenes/player_input_regression.tscn

@@ -1,14 +1,20 @@
-[gd_scene load_steps=3 format=3]
+[gd_scene load_steps=5 format=3]
 
 [ext_resource type="Script" path="res://src/scenes/player/third_person_wow_controller.gd" id="1_player"]
 [ext_resource type="Script" path="res://src/scenes/player/third_person_camera_rig.gd" id="2_camera_rig"]
+[ext_resource type="Script" path="res://src/scenes/character/character_appearance_presenter.gd" id="3_appearance"]
+[ext_resource type="Script" path="res://src/scenes/character/character_animation_presenter.gd" id="4_animation"]
 
 [node name="PlayerInputRegression" type="CharacterBody3D"]
 script = ExtResource("1_player")
 spawn_at_tile_center = false
-character_model_path = ""
 
 [node name="Visual" type="Node3D" parent="."]
+script = ExtResource("3_appearance")
+character_model_path = ""
+
+[node name="AnimationPresenter" type="Node" parent="Visual"]
+script = ExtResource("4_animation")
 
 [node name="CameraPivot" type="Node3D" parent="."]
 script = ExtResource("2_camera_rig")

src/tests/scenes/world_entity_visual_replacement_fixture.tscn

@@ -0,0 +1,10 @@
+[gd_scene load_steps=2 format=3]
+
+[sub_resource type="SphereMesh" id="SphereMesh_replacement"]
+radius = 0.5
+height = 1.0
+
+[node name="ReplacementVisual" type="Node3D"]
+
+[node name="Marker" type="MeshInstance3D" parent="."]
+mesh = SubResource("SphereMesh_replacement")

src/tools/capture_render_checkpoints.gd

@@ -2,6 +2,7 @@ extends SceneTree
 
 const DEFAULT_MANIFEST_PATH := "res://src/tools/render_baseline_manifest.json"
 const M2_NATIVE_ANIMATED_BUILDER := preload("res://addons/mpq_extractor/loaders/m2_native_animated_builder.gd")
+const WORLD_ENVIRONMENT_SNAPSHOT_SCRIPT := preload("res://src/render/environment/world_environment_snapshot.gd")
 const SHUTDOWN_DRAIN_FRAMES := 2
 
 
@@ -64,7 +65,12 @@ func _capture_async() -> void:
 	camera.far = 50000.0
 	camera.position = _vector3(first.get("camera", [0.0, 0.0, 0.0]))
 	(world as Node3D).add_child(camera)
-	world.set("streaming_focus_source_path", NodePath("CheckpointCamera"))
+	var render_facade := world.get_node_or_null("WorldRenderFacade")
+	if render_facade == null:
+		push_error("Streaming scene has no WorldRenderFacade")
+		quit(1)
+		return
+	render_facade.set("streaming_focus_source_path", NodePath("../CheckpointCamera"))
 	world.set("debug_streaming", true)
 	world.set("runtime_stats_enabled", true)
 	get_root().add_child(world)
@@ -125,9 +131,8 @@ func _capture_async() -> void:
 			camera.make_current()
 			if player != null:
 				player.global_position = _vector3(checkpoint.get("player", checkpoint.get("target", [0.0, 0.0, 0.0])))
-			_set_sky_time(world, float(checkpoint.get("time_hours", 13.0)))
-			if world.has_method("refresh_streaming_focus"):
-				world.call("refresh_streaming_focus", true)
+			_apply_environment_time(render_facade, float(checkpoint.get("time_hours", 13.0)))
+			render_facade.call("refresh_streaming_focus", true)
 
 			if dry_run:
 				print("RENDER_CHECKPOINT dry_run name=%s coverage=%s camera=%s target=%s yaw_offset=%.2f pitch_offset=%.2f time=%.2f" % [
@@ -148,7 +153,7 @@ func _capture_async() -> void:
 			var load_started := Time.get_ticks_usec()
 			await create_timer(maxf(wait_seconds, 0.0)).timeout
 			var load_time_ms := float(Time.get_ticks_usec() - load_started) / 1000.0
-			var metrics := await _measure_frames(maxf(measure_seconds, 0.1), world)
+			var metrics := await _measure_frames(maxf(measure_seconds, 0.1), render_facade)
 			await RenderingServer.frame_post_draw
 
 			var image := get_root().get_texture().get_image()
@@ -189,7 +194,7 @@ func _capture_async() -> void:
 	quit(0)
 
 
-func _measure_frames(seconds: float, world: Node) -> Dictionary:
+func _measure_frames(seconds: float, render_facade: Node) -> Dictionary:
 	var frame_times: Array[float] = []
 	var deadline := Time.get_ticks_usec() + int(seconds * 1000000.0)
 	var previous := Time.get_ticks_usec()
@@ -200,8 +205,8 @@ func _measure_frames(seconds: float, world: Node) -> Dictionary:
 		previous = now
 	frame_times.sort()
 	var snapshot := {}
-	if world.has_method("render_baseline_snapshot"):
-		snapshot = world.call("render_baseline_snapshot")
+	if render_facade.has_method("renderer_metrics_snapshot"):
+		snapshot = render_facade.call("renderer_metrics_snapshot")
 	return {
 		"frames": frame_times.size(),
 		"frame_ms_p50": _percentile(frame_times, 0.50),
@@ -304,12 +309,10 @@ func _create_diagnostic_spawn_marker(checkpoint: Dictionary) -> Node3D:
 	return marker_root
 
 
-func _set_sky_time(world: Node, time_hours: float) -> void:
-	var sky := world.get_node_or_null("WowSkyController")
-	if sky != null:
-		sky.set("use_system_time", false)
-		sky.set("time_speed", 0.0)
-		sky.set("fixed_time_hours", time_hours)
+func _apply_environment_time(render_facade: Node, time_hours: float) -> void:
+	var environment_snapshot: RefCounted = WORLD_ENVIRONMENT_SNAPSHOT_SCRIPT.at_time_of_day(time_hours)
+	if not bool(render_facade.call("apply_environment_snapshot", environment_snapshot)):
+		push_error("Render checkpoint could not apply environment time %.3f" % time_hours)
 
 
 func _environment_metadata() -> Dictionary:

src/tools/compare_render_checkpoints.gd.uid

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

src/tools/probe_render_camera_occluders.gd

@@ -28,7 +28,12 @@ func _run_async() -> void:
 	camera.name = "OccluderProbeCamera"
 	camera.current = true
 	world.add_child(camera)
-	world.set("streaming_focus_source_path", NodePath(camera.name))
+	var render_facade := world.get_node_or_null("WorldRenderFacade")
+	if render_facade == null:
+		push_error("CAMERA_OCCLUDER_PROBE: streaming scene has no WorldRenderFacade")
+		quit(1)
+		return
+	render_facade.set("streaming_focus_source_path", NodePath("../%s" % camera.name))
 	world.set("debug_streaming", false)
 	get_root().add_child(world)
 	await process_frame
@@ -47,8 +52,7 @@ func _run_async() -> void:
 		var camera_position := _vector3(checkpoint.get("camera", []))
 		var target_position := _vector3(checkpoint.get("target", []))
 		camera.global_position = camera_position
-		if world.has_method("refresh_streaming_focus"):
-			world.call("refresh_streaming_focus", true)
+		render_facade.call("refresh_streaming_focus", true)
 		await create_timer(maxf(0.1, wait_seconds)).timeout
 		var geometry_nodes: Array[Node3D] = []
 		_collect_geometry_nodes(world, geometry_nodes)

src/tools/probe_render_camera_occluders.gd.uid

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

src/tools/probe_render_terrain_height.gd

@@ -5,9 +5,7 @@ extends SceneTree
 ##   [--wait 3.0] [--output user://render_terrain_height/report.json]
 
 const MANIFEST_PATH := "res://src/tools/render_baseline_manifest.json"
-const COORDINATE_MAPPER_SCRIPT := preload("res://src/domain/coordinates/coordinate_mapper.gd")
 const GODOT_WORLD_POSITION_SCRIPT := preload("res://src/domain/coordinates/godot_world_position.gd")
-const RAY_HEIGHT := 5000.0
 
 
 func _initialize() -> void:
@@ -37,7 +35,12 @@ func _run_async() -> void:
 	var camera := Camera3D.new()
 	camera.current = true
 	world.add_child(camera)
-	world.set("streaming_focus_source_path", NodePath(camera.name))
+	var render_facade := world.get_node_or_null("WorldRenderFacade")
+	if render_facade == null:
+		push_error("TERRAIN_HEIGHT_PROBE: streaming scene has no WorldRenderFacade")
+		quit(1)
+		return
+	render_facade.set("streaming_focus_source_path", NodePath("../%s" % camera.name))
 	world.set("debug_streaming", false)
 	get_root().add_child(world)
 	await process_frame
@@ -54,10 +57,17 @@ func _run_async() -> void:
 			continue
 		var camera_position := _vector3(checkpoint.get("camera", []))
 		camera.global_position = camera_position
-		if world.has_method("refresh_streaming_focus"):
-			world.call("refresh_streaming_focus", true)
+		render_facade.call("refresh_streaming_focus", true)
 		await create_timer(maxf(0.1, wait_seconds)).timeout
-		var terrain_sample := _sample_terrain(world, camera_position)
+		var typed_camera_position = GODOT_WORLD_POSITION_SCRIPT.new(
+			camera_position.x,
+			camera_position.y,
+			camera_position.z
+		)
+		var terrain_sample: Dictionary = render_facade.call(
+			"renderer_ground_query_snapshot",
+			typed_camera_position
+		)
 		terrain_sample["name"] = checkpoint.get("name", "checkpoint")
 		terrain_sample["camera_y"] = camera_position.y
 		if terrain_sample.has("terrain_height"):
@@ -90,137 +100,6 @@ func _run_async() -> void:
 	quit(1 if failed else 0)
 
 
-func _sample_terrain(world: Node3D, world_position: Vector3) -> Dictionary:
-	var tile_coordinate := _adt_tile_vector2i(world_position)
-	var tile_states: Dictionary = world.get("_tile_states")
-	var highest_terrain_height := -INF
-	var intersected_tile_key := ""
-	var ready_mesh_count := 0
-	for tile_y in range(tile_coordinate.y - 1, tile_coordinate.y + 2):
-		for tile_x in range(tile_coordinate.x - 1, tile_coordinate.x + 2):
-			var tile_key := "%d_%d" % [tile_x, tile_y]
-			if not tile_states.has(tile_key):
-				continue
-			var state: Dictionary = tile_states[tile_key]
-			var terrain_height_variant = _intersect_terrain_state(state, world_position)
-			if terrain_height_variant == null:
-				continue
-			ready_mesh_count += 1
-			var terrain_height := float(terrain_height_variant)
-			if terrain_height > highest_terrain_height:
-				highest_terrain_height = terrain_height
-				intersected_tile_key = tile_key
-	if not is_finite(highest_terrain_height):
-		var missing_result := {
-			"status": "no_intersection" if ready_mesh_count > 0 else "mesh_not_ready",
-			"tile": "%d_%d" % [tile_coordinate.x, tile_coordinate.y],
-		}
-		missing_result.merge(_tile_runtime_diagnostic(world, String(missing_result.tile), world_position), true)
-		if bool(missing_result.get("quality_mesh_present", false)) or bool(missing_result.get("tile_lod_mesh_present", false)):
-			missing_result["status"] = "no_intersection"
-			missing_result.merge(_nearest_terrain_sample(world, world_position), true)
-			if missing_result.get("nearest_sample_distance", null) != null:
-				missing_result["status"] = "sampled_nearby"
-				missing_result["terrain_height"] = float(missing_result.nearest_sample_height)
-		return missing_result
-	return {
-		"status": "sampled",
-		"tile": intersected_tile_key,
-		"terrain_height": highest_terrain_height,
-	}
-
-
-func _intersect_terrain_state(state: Dictionary, world_position: Vector3):
-	var terrain_mesh: Mesh = state.get("quality_terrain_mesh", null)
-	if terrain_mesh == null:
-		terrain_mesh = state.get("tile_lod_mesh", null)
-	if terrain_mesh == null:
-		return null
-	var triangle_mesh := terrain_mesh.generate_triangle_mesh()
-	if triangle_mesh == null:
-		return null
-	var tile_root := state.get("root", null) as Node3D
-	if tile_root == null:
-		return null
-	var inverse_transform := tile_root.global_transform.affine_inverse()
-	var local_ray_origin := inverse_transform * Vector3(world_position.x, RAY_HEIGHT, world_position.z)
-	var local_ray_direction := inverse_transform.basis * Vector3.DOWN
-	var intersection: Dictionary = triangle_mesh.intersect_ray(local_ray_origin, local_ray_direction)
-	if intersection.is_empty():
-		return null
-	var local_hit: Vector3 = intersection.get("position", Vector3.ZERO)
-	var world_hit := tile_root.global_transform * local_hit
-	return world_hit.y
-
-
-func _tile_runtime_diagnostic(world: Node3D, tile_key: String, world_position: Vector3) -> Dictionary:
-	var available_tiles: Dictionary = world.get("_available_tiles")
-	var loading_tasks: Dictionary = world.get("_tile_loading_tasks")
-	var tile_states: Dictionary = world.get("_tile_states")
-	var load_queue: Array = world.get("_tile_load_queue")
-	var queued_index := -1
-	for index in load_queue.size():
-		var request: Dictionary = load_queue[index]
-		if String(request.get("key", "")) == tile_key:
-			queued_index = index
-			break
-	var diagnostic := {
-		"available": available_tiles.has(tile_key),
-		"queued_index": queued_index,
-		"loading": loading_tasks.has(tile_key),
-		"state_present": tile_states.has(tile_key),
-		"load_queue_size": load_queue.size(),
-	}
-	if tile_states.has(tile_key):
-		var state: Dictionary = tile_states[tile_key]
-		var quality_mesh: Mesh = state.get("quality_terrain_mesh", null)
-		var tile_lod_mesh: Mesh = state.get("tile_lod_mesh", null)
-		diagnostic["quality_mesh_present"] = quality_mesh != null
-		diagnostic["tile_lod_mesh_present"] = tile_lod_mesh != null
-		diagnostic["quality_source"] = String(state.get("quality_terrain_source", ""))
-		diagnostic["tile_lod"] = int(state.get("tile_lod", -1))
-		var tile_root := state.get("root", null) as Node3D
-		if tile_root != null:
-			var local_position := tile_root.global_transform.affine_inverse() * world_position
-			diagnostic["tile_root_position"] = _vector3_array(tile_root.global_position)
-			diagnostic["probe_local_position"] = _vector3_array(local_position)
-		var diagnostic_mesh := quality_mesh if quality_mesh != null else tile_lod_mesh
-		if diagnostic_mesh != null:
-			var mesh_aabb := diagnostic_mesh.get_aabb()
-			diagnostic["mesh_aabb_position"] = _vector3_array(mesh_aabb.position)
-			diagnostic["mesh_aabb_size"] = _vector3_array(mesh_aabb.size)
-	return diagnostic
-
-
-func _nearest_terrain_sample(world: Node3D, world_position: Vector3) -> Dictionary:
-	var tile_states: Dictionary = world.get("_tile_states")
-	for radius in [2.0, 5.0, 10.0, 20.0, 40.0]:
-		for offset in [Vector2(radius, 0.0), Vector2(-radius, 0.0), Vector2(0.0, radius), Vector2(0.0, -radius)]:
-			var sample_position := world_position + Vector3(offset.x, 0.0, offset.y)
-			var sample_tile := _adt_tile_vector2i(sample_position)
-			var sample_key := "%d_%d" % [sample_tile.x, sample_tile.y]
-			if not tile_states.has(sample_key):
-				continue
-			var height_variant = _intersect_terrain_state(tile_states[sample_key], sample_position)
-			if height_variant != null:
-				return {
-					"nearest_sample_distance": radius,
-					"nearest_sample_height": float(height_variant),
-					"nearest_sample_tile": sample_key,
-				}
-	return {"nearest_sample_distance": null}
-
-
-func _adt_tile_vector2i(world_position: Vector3) -> Vector2i:
-	var typed_world_position = GODOT_WORLD_POSITION_SCRIPT.new(world_position.x, world_position.y, world_position.z)
-	var tile_coordinate = COORDINATE_MAPPER_SCRIPT.godot_to_adt_tile(typed_world_position)
-	return Vector2i(tile_coordinate.tile_x, tile_coordinate.tile_y)
-
-
-func _vector3_array(value: Vector3) -> Array[float]:
-	return [value.x, value.y, value.z]
-
-
 func _vector3(value_variant) -> Vector3:
 	if not (value_variant is Array) or value_variant.size() != 3:
 		return Vector3.ZERO

src/tools/probe_render_terrain_height.gd.uid

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

src/tools/verify_character_presentation.gd

@@ -0,0 +1,164 @@
+extends SceneTree
+
+## Asset-free M02 appearance, animation and player-boundary regression.
+
+const MODEL_FIXTURE_PATH := "res://src/tests/scenes/character_presentation_model_fixture.tscn"
+const PLAYER_CONTROLLER_PATH := "res://src/scenes/player/third_person_wow_controller.gd"
+const APPEARANCE_PRESENTER_PATH := "res://src/scenes/character/character_appearance_presenter.gd"
+const ANIMATION_PRESENTER_PATH := "res://src/scenes/character/character_animation_presenter.gd"
+const REGRESSION_SCENE_PATH := "res://src/tests/scenes/player_input_regression.tscn"
+const RUNTIME_SCENE_PATHS: Array[String] = [
+	"res://src/scenes/streaming/eastern_kingdoms_streaming.tscn",
+	"res://src/scenes/streaming/kalimdor_streaming.tscn",
+]
+
+
+func _initialize() -> void:
+	_run_verification.call_deferred()
+
+
+func _run_verification() -> void:
+	var failures: Array[String] = []
+	await _verify_appearance_presenter(failures)
+	_verify_animation_presenter(failures)
+	_verify_source_boundaries(failures)
+	_verify_scene_wiring(failures)
+
+	if not failures.is_empty():
+		for failure in failures:
+			push_error("CHARACTER_PRESENTATION: %s" % failure)
+		quit(1)
+		return
+
+	print("CHARACTER_PRESENTATION PASS appearance_cases=9 animation_cases=10 scenes=3 player_boundary=1")
+	quit(0)
+
+
+func _verify_appearance_presenter(failures: Array[String]) -> void:
+	var presenter := CharacterAppearancePresenter.new()
+	presenter.character_model_path = MODEL_FIXTURE_PATH
+	presenter.character_scale = 2.0
+	presenter.character_yaw_offset_degrees = 45.0
+	root.add_child(presenter)
+	var ready_roots: Array[Node3D] = []
+	presenter.character_appearance_ready.connect(func(character_root: Node3D) -> void: ready_roots.append(character_root))
+
+	_expect_true(presenter.load_character_appearance("res://missing-extracted-fixture"), "fixture load starts", failures)
+	await process_frame
+	var character_root := presenter.character_root
+	_expect_true(character_root != null, "character root composed", failures)
+	if character_root != null:
+		_expect_near(character_root.scale.x, 2.0, "uniform character scale", failures)
+		_expect_near(character_root.rotation_degrees.y, 45.0, "character yaw offset", failures)
+		_expect_near(character_root.position.y, -2.0, "character grounded after scale", failures)
+		_expect_true(character_root.has_node("CharacterTextureCompositor"), "texture compositor composed", failures)
+	_expect_true(ready_roots.size() == 1, "appearance ready emitted", failures)
+	_expect_true(presenter.extracted_data_directory == "res://missing-extracted-fixture", "content root override retained", failures)
+
+	var previous_root := character_root
+	_expect_true(presenter.load_character_appearance(), "replacement load starts", failures)
+	_expect_true(presenter.character_root != previous_root, "replacement swaps owned root", failures)
+	await process_frame
+	_expect_true(ready_roots.size() == 2, "replacement ready emitted", failures)
+
+	presenter.character_model_path = ""
+	_expect_true(not presenter.load_character_appearance(), "empty model rejected", failures)
+	_expect_true(presenter.character_root == null, "empty model clears old root", failures)
+	await process_frame
+	presenter.free()
+
+
+func _verify_animation_presenter(failures: Array[String]) -> void:
+	var animation_root := Node.new()
+	var nested_node := Node.new()
+	var animation_player := AnimationPlayer.new()
+	animation_root.add_child(nested_node)
+	nested_node.add_child(animation_player)
+	var animation_library := AnimationLibrary.new()
+	for animation_name in ["Stand", "Run", "Emote"]:
+		animation_library.add_animation(animation_name, Animation.new())
+	animation_player.add_animation_library("", animation_library)
+
+	var presenter := CharacterAnimationPresenter.new()
+	presenter.animation_blend_time_seconds = 0.25
+	_expect_true(presenter.bind_character_root(animation_root), "nested animation player bound", failures)
+	_expect_true(presenter.has_animation_player, "animation player state exposed", failures)
+	_expect_true(presenter.active_animation_name == "Stand", "stationary animation selected", failures)
+	_expect_true(animation_player.current_animation == "Stand", "stationary animation playing", failures)
+	_expect_near(animation_player.playback_default_blend_time, 0.25, "default blend configured", failures)
+	_expect_true(animation_player.get_animation("Stand").loop_mode == Animation.LOOP_LINEAR, "stand loops", failures)
+	_expect_true(animation_player.get_animation("Run").loop_mode == Animation.LOOP_LINEAR, "run loops", failures)
+	_expect_true(animation_player.get_animation("Emote").loop_mode == Animation.LOOP_NONE, "unrelated animation unchanged", failures)
+	_expect_true(presenter.present_locomotion(true), "moving transition starts", failures)
+	_expect_true(presenter.active_animation_name == "Run", "moving animation selected", failures)
+	_expect_true(not presenter.present_locomotion(true), "duplicate moving state ignored", failures)
+
+	var fallback_root := Node.new()
+	var fallback_player := AnimationPlayer.new()
+	fallback_root.add_child(fallback_player)
+	var fallback_library := AnimationLibrary.new()
+	fallback_library.add_animation("CharacterStandLoop", Animation.new())
+	fallback_library.add_animation("FastRunCycle", Animation.new())
+	fallback_player.add_animation_library("", fallback_library)
+	_expect_true(presenter.bind_character_root(fallback_root), "fallback animation player bound", failures)
+	_expect_true(presenter.active_animation_name == "CharacterStandLoop", "substring stationary fallback", failures)
+	presenter.present_locomotion(true)
+	_expect_true(presenter.active_animation_name == "FastRunCycle", "substring moving fallback", failures)
+	fallback_root.free()
+	_expect_true(not presenter.present_locomotion(false), "freed animation root rejected", failures)
+	_expect_true(not presenter.has_animation_player, "freed animation binding cleared", failures)
+	var missing_animation_root := Node.new()
+	_expect_true(not presenter.bind_character_root(missing_animation_root), "missing animation player rejected", failures)
+	_expect_true(not presenter.has_animation_player, "missing binding clears state", failures)
+	presenter.free()
+	animation_root.free()
+	missing_animation_root.free()
+
+
+func _verify_source_boundaries(failures: Array[String]) -> void:
+	var player_source := _read_text(PLAYER_CONTROLLER_PATH, failures)
+	for forbidden_text in [
+		"GEOSET_CONTROLLER_SCRIPT",
+		"TEXTURE_COMPOSITOR_SCRIPT",
+		"OUTFIT_RESOLVER_SCRIPT",
+		"func _load_character_visual",
+		"func _find_animation_player",
+		"func _calculate_aabb",
+		"_animation_player",
+	]:
+		_expect_true(not player_source.contains(forbidden_text), "player omits %s" % forbidden_text, failures)
+	_expect_true(player_source.contains("_appearance_presenter.load_character_appearance"), "player delegates appearance", failures)
+	_expect_true(player_source.contains("_animation_presenter.present_locomotion"), "player delegates animation", failures)
+
+	var appearance_source := _read_text(APPEARANCE_PRESENTER_PATH, failures)
+	for forbidden_text in ["MoveIntent", "TerrainQuery", "ThirdPersonCameraRig", "AnimationPlayer"]:
+		_expect_true(not appearance_source.contains(forbidden_text), "appearance omits %s" % forbidden_text, failures)
+	var animation_source := _read_text(ANIMATION_PRESENTER_PATH, failures)
+	for forbidden_text in ["load(character_model_path)", "TerrainQuery", "MoveIntent", "Camera3D"]:
+		_expect_true(not animation_source.contains(forbidden_text), "animation omits %s" % forbidden_text, failures)
+
+
+func _verify_scene_wiring(failures: Array[String]) -> void:
+	for scene_path in RUNTIME_SCENE_PATHS + [REGRESSION_SCENE_PATH]:
+		var scene_source := _read_text(scene_path, failures)
+		_expect_true(scene_source.contains("character_appearance_presenter.gd"), "%s references appearance presenter" % scene_path, failures)
+		_expect_true(scene_source.contains("character_animation_presenter.gd"), "%s references animation presenter" % scene_path, failures)
+		_expect_true(scene_source.contains('name="AnimationPresenter"'), "%s composes animation presenter" % scene_path, failures)
+
+
+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_near(actual_value: float, expected_value: float, label: String, failures: Array[String]) -> void:
+	if absf(actual_value - expected_value) > 0.000001:
+		failures.append("%s expected %.6f, got %.6f" % [label, expected_value, actual_value])
+
+
+func _expect_true(actual_value: bool, label: String, failures: Array[String]) -> void:
+	if not actual_value:
+		failures.append("%s expected true" % label)

src/tools/verify_character_presentation.gd.uid

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

src/tools/verify_coordinate_conversion_boundaries.gd

@@ -19,10 +19,10 @@ const ALLOWED_LEGACY_NAME_PATHS: Array[String] = [
 ]
 const REQUIRED_MAPPER_CALLS := {
 	"res://src/scenes/sky/wow_sky_controller.gd": ["godot_to_canonical", "godot_to_adt_tile", "godot_to_adt_tile_local"],
-	"res://src/scenes/streaming/streaming_world_loader.gd": ["godot_to_adt_tile", "godot_to_adt_tile_local", "adt_tile_local_to_godot"],
+	"res://src/scenes/streaming/streaming_world_loader.gd": ["godot_to_adt_tile", "adt_tile_local_to_godot"],
+	"res://src/render/streaming/streaming_target_planner.gd": ["godot_to_adt_tile", "godot_to_adt_tile_local"],
 	"res://src/scenes/player/third_person_wow_controller.gd": ["adt_tile_local_to_godot"],
 	"res://src/gameplay/terrain/adt_terrain_query.gd": ["godot_to_adt_tile", "godot_to_adt_tile_local", "adt_tile_local_to_chunk"],
-	"res://src/tools/probe_render_terrain_height.gd": ["godot_to_adt_tile"],
 }
 
 

src/tools/verify_local_player_movement.gd

@@ -12,6 +12,7 @@ func _initialize() -> void:
 	_verify_acceleration_and_deceleration(failures)
 	_verify_sandbox_sprint(failures)
 	_verify_flight_state_and_basis(failures)
+	_verify_keyboard_turn(failures)
 	_verify_invalid_delta(failures)
 	_verify_scene_boundary(failures)
 
@@ -21,7 +22,7 @@ func _initialize() -> void:
 		quit(1)
 		return
 
-	print("LOCAL_PLAYER_MOVEMENT PASS cases=12 state_transitions=2 scene_boundary=1")
+	print("LOCAL_PLAYER_MOVEMENT PASS cases=15 state_transitions=2 scene_boundary=1")
 	quit(0)
 
 
@@ -88,6 +89,13 @@ func _verify_invalid_delta(failures: Array[String]) -> void:
 	_expect_vector_near(controller.godot_world_velocity_units_per_second, Vector3.ZERO, "negative delta state", failures)
 
 
+func _verify_keyboard_turn(failures: Array[String]) -> void:
+	var controller := _new_controller()
+	_expect_near(controller.calculate_yaw_delta_radians(_intent(0.0, 0.0, 0.0, false, 1.0), 0.5), -PI * 0.5, "right turn yaw", failures)
+	_expect_near(controller.calculate_yaw_delta_radians(_intent(0.0, 0.0, 0.0, false, -1.0), 0.5), PI * 0.5, "left turn yaw", failures)
+	_expect_near(controller.calculate_yaw_delta_radians(_intent(0.0, 0.0, 0.0, false, 1.0), -1.0), 0.0, "negative turn delta", failures)
+
+
 func _verify_scene_boundary(failures: Array[String]) -> void:
 	var movement_source := _read_text(MOVEMENT_CONTROLLER_PATH, failures)
 	for forbidden_text in ["extends Node", "extends Resource", "Input.", "Camera3D", "ADTLoader", "global_position"]:
@@ -102,16 +110,25 @@ func _verify_scene_boundary(failures: Array[String]) -> void:
 
 
 func _new_controller() -> LocalPlayerMovementController:
-	return LocalPlayerMovementController.new(7.0, 4.5, 4.5, 7.0, 28.0, 6.0)
+	return LocalPlayerMovementController.new(
+		7.0,
+		4.5,
+		4.5,
+		7.0,
+		28.0,
+		6.0,
+		PlayerMovementCapabilities.render_sandbox()
+	)
 
 
 func _intent(
 		forward_axis: float,
 		strafe_axis: float,
 		vertical_axis: float = 0.0,
-		sprint_requested: bool = false
+		sprint_requested: bool = false,
+		turn_axis: float = 0.0
 ) -> MoveIntent:
-	return MoveIntent.new(forward_axis, strafe_axis, vertical_axis, sprint_requested)
+	return MoveIntent.new(forward_axis, strafe_axis, vertical_axis, sprint_requested, turn_axis)
 
 
 func _read_text(path: String, failures: Array[String]) -> String:
@@ -132,6 +149,11 @@ func _expect_vector_near(
 		failures.append("%s expected %s, got %s" % [label, expected_value, actual_value])
 
 
+func _expect_near(actual_value: float, expected_value: float, label: String, failures: Array[String]) -> void:
+	if absf(actual_value - expected_value) > 0.000001:
+		failures.append("%s expected %.6f, got %.6f" % [label, expected_value, actual_value])
+
+
 func _expect_true(actual_value: bool, label: String, failures: Array[String]) -> void:
 	if not actual_value:
 		failures.append("%s expected true" % label)

src/tools/verify_local_player_movement.gd.uid

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

src/tools/verify_m2_unique_dedupe.gd

@@ -1,12 +1,14 @@
 extends SceneTree
 
-const STREAMING_WORLD_LOADER := preload("res://src/scenes/streaming/streaming_world_loader.gd")
+const M2_UNIQUE_PLACEMENT_REGISTRY := preload(
+	"res://src/render/m2/m2_unique_placement_registry.gd"
+)
 
 var _failures := 0
 
 
 func _initialize() -> void:
-	var loader = STREAMING_WORLD_LOADER.new()
+	var registry: RefCounted = M2_UNIQUE_PLACEMENT_REGISTRY.new()
 	var placement := {
 		"name_id": 0,
 		"unique_id": 11785,
@@ -15,30 +17,24 @@ func _initialize() -> void:
 		"scale": 1.0,
 	}
 
-	var first: Dictionary = loader.call("_reserve_tile_m2_placements", "30_49", [placement])
+	var first: Dictionary = registry.call("reserve", "30_49", [placement])
 	_expect((first.get("placements", []) as Array).size() == 1, "first tile should reserve unique M2 placement")
 	_expect((first.get("unique_keys", []) as Array).has("uid:11785"), "first tile should own uid:11785")
 	_expect((first.get("skipped_unique_keys", []) as Array).is_empty(), "first tile should not skip uid:11785")
 
-	var duplicate: Dictionary = loader.call("_reserve_tile_m2_placements", "31_49", [placement])
+	var duplicate: Dictionary = registry.call("reserve", "31_49", [placement])
 	_expect((duplicate.get("placements", []) as Array).is_empty(), "second tile should skip duplicate uid:11785")
 	_expect((duplicate.get("skipped_unique_keys", []) as Array).has("uid:11785"), "second tile should remember skipped uid:11785")
 
-	loader.call("_release_tile_m2_unique_keys", {
-		"key": "30_49",
-		"m2_unique_keys": ["uid:11785"],
-		"m2_skipped_unique_keys": [],
-	}, false)
-	var after_release: Dictionary = loader.call("_reserve_tile_m2_placements", "31_49", [placement])
+	registry.call("release", "30_49", ["uid:11785"])
+	var after_release: Dictionary = registry.call("reserve", "31_49", [placement])
 	_expect((after_release.get("placements", []) as Array).size() == 1, "second tile should reserve uid:11785 after owner release")
 	_expect((after_release.get("unique_keys", []) as Array).has("uid:11785"), "second tile should own uid:11785 after release")
 
-	var same_tile_loader = STREAMING_WORLD_LOADER.new()
-	var same_tile_duplicate: Dictionary = same_tile_loader.call("_reserve_tile_m2_placements", "31_49", [placement, placement])
+	var same_tile_registry: RefCounted = M2_UNIQUE_PLACEMENT_REGISTRY.new()
+	var same_tile_duplicate: Dictionary = same_tile_registry.call("reserve", "31_49", [placement, placement])
 	_expect((same_tile_duplicate.get("placements", []) as Array).size() == 1, "same tile should keep only one copy of duplicate uid:11785")
 
-	loader.free()
-	same_tile_loader.free()
 	if _failures > 0:
 		push_error("M2 unique dedupe verification failed: %d issue(s)" % _failures)
 		quit(1)

src/tools/verify_m2_unique_placement_registry.gd

@@ -0,0 +1,156 @@
+extends SceneTree
+
+## Asset-free ownership, lifecycle, dependency and timing regression for M2 IDs.
+
+const REGISTRY_SCRIPT := preload("res://src/render/m2/m2_unique_placement_registry.gd")
+const LOADER_PATH := "res://src/scenes/streaming/streaming_world_loader.gd"
+
+
+func _initialize() -> void:
+	var failures: Array[String] = []
+	_verify_unkeyed_and_invalid_placements(failures)
+	_verify_same_tile_and_cross_tile_deduplication(failures)
+	_verify_owner_checked_release_and_retry(failures)
+	_verify_clear_and_detached_diagnostics(failures)
+	_verify_loader_boundary(failures)
+	var elapsed_milliseconds := _verify_bounded_timing(failures)
+	if not failures.is_empty():
+		for failure in failures:
+			push_error("M2_UNIQUE_PLACEMENT_REGISTRY: %s" % failure)
+		quit(1)
+		return
+	print(
+		"M2_UNIQUE_PLACEMENT_REGISTRY PASS cases=10 iterations=100 elapsed_ms=%.3f"
+		% elapsed_milliseconds
+	)
+	quit(0)
+
+
+func _verify_unkeyed_and_invalid_placements(failures: Array[String]) -> void:
+	var registry: RefCounted = REGISTRY_SCRIPT.new()
+	var result: Dictionary = registry.call("reserve", "tile-a", [
+		{"unique_id": -1},
+		{"unique_id": 0},
+		{"name_id": 7},
+		"invalid",
+	])
+	_expect_equal((result["placements"] as Array).size(), 3, "unkeyed placements pass", failures)
+	_expect_true((result["unique_keys"] as Array).is_empty(), "unkeyed placements not owned", failures)
+	_expect_equal(int(registry.call("active_count")), 0, "unkeyed active count", failures)
+
+
+func _verify_same_tile_and_cross_tile_deduplication(failures: Array[String]) -> void:
+	var registry: RefCounted = REGISTRY_SCRIPT.new()
+	var placement := {"unique_id": 11785, "name_id": 0}
+	var first: Dictionary = registry.call("reserve", "30_49", [placement, placement])
+	_expect_equal((first["placements"] as Array).size(), 1, "same call duplicate filtered", failures)
+	_expect_string_array((first["unique_keys"] as Array), ["uid:11785"], "first owner key", failures)
+	var same_owner_retry: Dictionary = registry.call("reserve", "30_49", [placement])
+	_expect_equal((same_owner_retry["placements"] as Array).size(), 1, "same owner later call passes", failures)
+	var competing: Dictionary = registry.call("reserve", "31_49", [placement, placement])
+	_expect_true((competing["placements"] as Array).is_empty(), "competing tile filtered", failures)
+	_expect_string_array(
+		competing["skipped_unique_keys"] as Array,
+		["uid:11785"],
+		"competing skip recorded once",
+		failures
+	)
+
+
+func _verify_owner_checked_release_and_retry(failures: Array[String]) -> void:
+	var registry: RefCounted = REGISTRY_SCRIPT.new()
+	var placement := {"unique_id": 44}
+	registry.call("reserve", "owner", [placement])
+	_expect_true(
+		(registry.call("release", "other", ["uid:44"]) as Array).is_empty(),
+		"non-owner release ignored",
+		failures
+	)
+	_expect_equal(int(registry.call("active_count")), 1, "non-owner keeps reservation", failures)
+	var released: Array = registry.call("release", "owner", ["", "uid:44", "uid:44"])
+	_expect_string_array(released, ["uid:44"], "owner release order and dedupe", failures)
+	var retried: Dictionary = registry.call("reserve", "other", [placement])
+	_expect_equal((retried["placements"] as Array).size(), 1, "waiting tile reserves after release", failures)
+
+
+func _verify_clear_and_detached_diagnostics(failures: Array[String]) -> void:
+	var registry: RefCounted = REGISTRY_SCRIPT.new()
+	registry.call("reserve", "tile-b", [{"unique_id": 20}])
+	registry.call("reserve", "tile-a", [{"unique_id": 10}])
+	var snapshot: Dictionary = registry.call("diagnostic_snapshot")
+	var owners: Array = snapshot["owners"]
+	_expect_equal(int(snapshot["active_count"]), 2, "diagnostic count", failures)
+	_expect_string_equal(String(owners[0]["unique_key"]), "uid:10", "diagnostic sorted", failures)
+	owners[0]["tile_key"] = "mutated"
+	var fresh_snapshot: Dictionary = registry.call("diagnostic_snapshot")
+	_expect_string_equal(
+		String((fresh_snapshot["owners"] as Array)[0]["tile_key"]),
+		"tile-a",
+		"diagnostics detached",
+		failures
+	)
+	registry.call("clear")
+	registry.call("clear")
+	_expect_equal(int(registry.call("active_count")), 0, "clear idempotent", failures)
+
+
+func _verify_loader_boundary(failures: Array[String]) -> void:
+	var source := _read_text(LOADER_PATH, failures)
+	_expect_true(source.contains("M2_UNIQUE_PLACEMENT_REGISTRY_SCRIPT.new()"), "loader composes registry", failures)
+	_expect_true(source.contains("_m2_unique_placement_registry.reserve("), "loader delegates reserve", failures)
+	_expect_true(source.contains("_m2_unique_placement_registry.release("), "loader delegates release", failures)
+	_expect_true(source.contains("_m2_unique_placement_registry.clear()"), "loader delegates clear", failures)
+	_expect_true(not source.contains("var _m2_unique_registry"), "loader omits registry dictionary", failures)
+	_expect_true(not source.contains("func _m2_unique_key("), "loader omits key formula", failures)
+
+
+func _verify_bounded_timing(failures: Array[String]) -> float:
+	var placements: Array = []
+	for placement_index in range(256):
+		placements.append({"unique_id": placement_index + 1})
+	var registry: RefCounted = REGISTRY_SCRIPT.new()
+	var started_microseconds := Time.get_ticks_usec()
+	for _iteration in range(100):
+		var reservation: Dictionary = registry.call("reserve", "owner", placements)
+		registry.call("release", "owner", reservation["unique_keys"])
+	var elapsed_milliseconds := float(Time.get_ticks_usec() - started_microseconds) / 1000.0
+	_expect_true(elapsed_milliseconds < 1000.0, "100 reserve/release 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)