docs(M02): publish camera rig handoff

Work-Package: M02-RND-CAMERA-001
rnd(M02): extract third-person camera rig
2026-07-14 23:27:41 +04:00 · 2026-07-14 23:27:03 +04:00 · 2026-07-14 22:17:12 +03:00 · 2026-07-14 23:11:23 +04:00 · 2026-07-14 23:10:55 +04:00 · 2026-07-14 22:01:21 +03:00
61 changed files with 3482 additions and 249 deletions
@@ -35,3 +35,7 @@
 # CMake build директория
 /src/native/build/
 # Local root-level diagnostic capture logs
 /*.stdout.log
 /*.stderr.log
@@ -857,6 +857,22 @@ $exe = Join-Path $env:TEMP 'godot-4.6.1-openwc\Godot_v4.6.1-stable_win64.exe'
 - Coordinate contract version 2, renderer radii, cache formats and visual
  quality profiles are unchanged.
 ## 2026-07-13 Golden Server Spawn Renderer Evidence
 - The pinned AzerothCore Human Warrior start at server position
  `(-8949.95, -132.493, 83.5312)` maps through `CoordinateMapper` to Godot
  `(17199.159666667, 83.5312, 26016.616666667)`, ADT `(32,48)` and MCNK `(3,12)`.
 - `server_spawn_render_manifest.json` drives the ordinary Eastern Kingdoms
  checkpoint capture pipeline at that location; no live database or production
  spawn entity is introduced.
 - A renderer-native emissive marker starts at the exact mapped origin and keeps
  depth testing enabled so GUI evidence exposes its relationship to terrain.
 - `verify_server_spawn_renderer.gd` rejects drift between the pinned fixture,
  manifest target/player coordinates and expected ADT ownership. The unified
  renderer baseline runs this contract check before capture.
 - This closes a coordinate/renderer integration criterion only. It does not
  claim TrinityCore row equivalence or visual parity with the original client.
 ## 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.
@@ -1,7 +1,7 @@
 # M01-FND-COORD-BOUNDARY-GATE-001 — Coordinate conversion boundary gate
 <!-- OPENWC_CLAIM:M01-FND-COORD-BOUNDARY-GATE-001:sindo-main-codex:2026-07-15 -->
-<!-- OPENWC_HANDOFF:READY:M01-FND-COORD-BOUNDARY-GATE-001:47dec6c -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M01-FND-COORD-BOUNDARY-GATE-001:c8e99f2 -->
 ## Ownership
@@ -1,7 +1,7 @@
 # M01-FND-COORD-TILE-AXIS-002 — ADT filename axis correction
 <!-- OPENWC_CLAIM:M01-FND-COORD-TILE-AXIS-002:sindo-main-codex:2026-07-15 -->
-<!-- OPENWC_HANDOFF:READY:M01-FND-COORD-TILE-AXIS-002:a7072e3 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M01-FND-COORD-TILE-AXIS-002:c8e99f2 -->
 ## Ownership
@@ -1,7 +1,7 @@
 # M01-FND-COORDS-001 — Canonical coordinate contracts
 <!-- OPENWC_CLAIM:M01-FND-COORDS-001:sindo-main-codex:2026-07-15 -->
-<!-- OPENWC_HANDOFF:READY:M01-FND-COORDS-001:f45695c -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M01-FND-COORDS-001:c8e99f2 -->
 ## Ownership
@@ -1,7 +1,7 @@
 # M01-FND-DOMAIN-IDENTITIES-001 — Stable domain identity namespaces
 <!-- OPENWC_CLAIM:M01-FND-DOMAIN-IDENTITIES-001:sindo-main-codex:2026-07-15 -->
-<!-- OPENWC_HANDOFF:READY:M01-FND-DOMAIN-IDENTITIES-001:c1dc07c -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M01-FND-DOMAIN-IDENTITIES-001:c8e99f2 -->
 ## Ownership
@@ -1,7 +1,7 @@
 # M01-QAR-COORD-FIXTURES-001 — Coordinate golden fixtures
 <!-- OPENWC_CLAIM:M01-QAR-COORD-FIXTURES-001:sindo-main-codex:2026-07-15 -->
-<!-- OPENWC_HANDOFF:READY:M01-QAR-COORD-FIXTURES-001:ce4f7ec -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M01-QAR-COORD-FIXTURES-001:c8e99f2 -->
 ## Ownership
@@ -0,0 +1,101 @@
 # M01-QAR-INTEGRATOR-CLOSEOUT-001 — M01 milestone closeout
 <!-- OPENWC_CLAIM:M01-QAR-INTEGRATOR-CLOSEOUT-001:sindo-main-codex:2026-07-16 -->
 <!-- OPENWC_HANDOFF:READY:M01-QAR-INTEGRATOR-CLOSEOUT-001:dd412e6 -->
 ## Ownership
 - Target: M01
 - Program: QAR
 - Owner/Agent ID: sindo-main-codex
 - Branch: `work/sindo-main-codex/m01-integrator-closeout`
 - Lease expires UTC: 2026-07-16
 - Integrator: sindo-main-codex, continuing the user-directed milestone workflow on 2026-07-14
 ## Outcome
 Audit every merged M01 work package on current `master`, record final evidence,
 close M01 and activate M02 only if all target verification and documentation
 criteria pass.
 ## Non-goals
 - Change coordinate, identity, streaming or renderer behavior.
 - Start M02 implementation.
 - Add new compatibility or visual-parity claims.
 - Commit proprietary assets, generated UIDs, caches or capture output.
 ## Paths
 - Exclusive: M01/M02 target status, M01 final Evidence and M01 claim acceptance markers
 - Shared/hotspots: `targets/README.md`, `targets/DEVELOPMENT_ROADMAP.md`, this claim
 - Generated/ignored: local Godot imports, renderer corpus and `user://` reports
 ## Contracts and data
 - Public APIs, schemas, cache formats and migrations: unchanged
 - Coordinate contract remains version 2
 - Fixture schema remains version 1
 - Consumers: milestone sequence and M02 work packages
 ## Dependencies
 - Requires: all seven M01 READY commits integrated through master `c8e99f2`
 - Blocks: M02 activation
 - External state: server-spawn GUI hashes and original-client numeric evidence are recorded; proprietary files remain outside Git
 ## Verification
 - Commands: all M01 domain/fixture/boundary/focus/identity/spawn gates,
  unified renderer dry-run, coordination/documentation checks and diff hygiene
 - Fidelity evidence: five build-12340 points, raw ADT metadata, pinned
  AzerothCore spawn and cache-complete GUI marker capture
 - Performance: no runtime change; preserve recorded renderer cold/warm evidence
 ## Documentation deliverables
 - M01 final target Evidence and checklist
 - M01 claim integration-acceptance markers
 - Target index and roadmap transition to M02
 - API/module specifications and diagrams are audited, not changed unless a gap is found
 ## Simplicity and naming
 - Important names introduced: none beyond the closeout work-package ID
 - Simplest approach: evidence/status-only integrator patch
 - Rejected complexity: new one-off closeout framework or behavioral changes
 - Unavoidable complexity: none
 ## Status
 - State: ready-for-review
 - Done: accepted seven M01 packages, reran post-merge gates, recorded complete
  target Evidence, closed M01 and activated M02
 - Next: merge closeout commit before starting an M02 implementation claim
 - Blocked by:
 ## Handoff
 - Commit: `dd412e6`
 - Branch: `work/sindo-main-codex/m01-integrator-closeout`
 - Outcome: M01 is `DONE` with all seven checklist items and complete Evidence;
  M02 is the only `ACTIVE` target and `targets/README.md` points to it.
 - Integration audit: all seven M01 READY commits are ancestors of master
  `c8e99f2`; their claims now carry `OPENWC_INTEGRATION:ACCEPTED` markers.
 - Verification: unified renderer dry-run passed project load, material/dedupe/
  shutdown gates, manifest `7/7/7`, calibration maximum error `0.000015`,
  coordinate boundary (`84` files) and server-spawn renderer `(32,48)/(3,12)`;
  coordinate mapper, golden fixtures, StreamingFocus and domain identity gates
  passed. Coordination and documentation gates passed; coordination reports
  only five already-expired M00 claim warnings.
 - Fidelity: closeout preserves five build-12340 coordinate observations, raw ADT
  evidence, pinned AzerothCore spawn mapping and cache-complete Northshire GUI
  evidence without claiming original-client visual parity or TrinityCore row
  equivalence.
 - Rebuild/migration: none. Coordinate contract remains version 2; fixture schema
  remains version 1; renderer cache formats are unchanged.
 - Remaining risks: recorded in M01 Evidence—TrinityCore populated spawn,
  placement Euler parity, native parser boundary and broader renderer parity.
 - Documentation: M01 target Evidence/checklist, target index and roadmap current
  state updated. Existing coordinate, identity and renderer module specs/API/
  diagrams were audited and passed the documentation gate.
@@ -0,0 +1,135 @@
 # M01-QAR-SERVER-SPAWN-RENDERER-001 — Golden server spawn renderer evidence
 <!-- OPENWC_CLAIM:M01-QAR-SERVER-SPAWN-RENDERER-001:sindo-main-codex:2026-07-15 -->
 <!-- OPENWC_INTEGRATION:ACCEPTED:M01-QAR-SERVER-SPAWN-RENDERER-001:c8e99f2 -->
 ## Ownership
 - Target: M01
 - Program: QAR/RND
 - Owner/Agent ID: sindo-main-codex
 - Branch: `work/sindo-main-codex/m01-server-spawn-renderer`
 - Lease expires UTC: 2026-07-15
 - Integrator: M01 milestone integrator
 ## Outcome
 Route the pinned AzerothCore Human Warrior spawn fixture through
 `CoordinateMapper` into the live Eastern Kingdoms renderer and produce
 repeatable headless contract checks plus GUI screenshot evidence at the mapped
 ADT tile/chunk.
 ## Non-goals
 - Connecting to a live AzerothCore or TrinityCore database.
 - Claiming TrinityCore spawn equivalence without a pinned populated TDB row.
 - Changing coordinate formulas, streaming radii, terrain, player movement or
  production character presentation.
 - Adding proprietary assets or screenshots to Git.
 ## Paths
 - Exclusive: `src/tools/server_spawn_render_manifest.json`,
  `src/tools/verify_server_spawn_renderer.gd`
 - Shared/hotspots: `src/tools/capture_render_checkpoints.gd`, renderer runner,
  coordinate/world-renderer module documentation, `RENDER.md`, this claim
 - Generated/ignored: Godot UIDs/import metadata and `user://` PNG/JSON evidence
 ## Contracts and data
 - Fixture schema and coordinate contract version remain unchanged.
 - Additive diagnostic checkpoint metadata may request a renderer-native marker;
  existing M00 checkpoints remain byte-for-byte compatible.
 - The spawn remains sourced from pinned AzerothCore revision
  `68fcf0098b16388093989627f37be530fc91f07d`.
 ## Dependencies
 - Requires: merged M01 packages through `a07a487`
 - Blocks: M01 golden server-spawn renderer criterion and milestone closeout
 - External state: GUI capture requires the existing local extracted/cached
  renderer corpus; headless contract verification remains non-proprietary
 ## Verification
 - Commands: dedicated spawn verifier, coordinate fixture/mapper/boundary gates,
  renderer baseline dry-run, GUI checkpoint capture and human inspection
 - Fixture: AzerothCore race `1`, class `1`, map `0`, server position
  `(-8949.95, -132.493, 83.5312)`
 - Expected renderer result: Godot position
  `(17199.159666667, 83.5312, 26016.616666667)`, ADT `(32,48)`, MCNK `(3,12)`
 - Fidelity classification: server/coordinate integration evidence only; it does
  not establish full original-client visual parity
 ## Documentation deliverables
 - Inline API/tool documentation for new verifier and marker metadata
 - Coordinate-mapping module capability/evidence update
 - World-renderer checkpoint input/output/source-map update when marker support is added
 - Existing synchronous coordinate data-flow diagram updated only if flow changes
 ## Simplicity and naming
 - Important names: `server_spawn_render_manifest`,
  `verify_server_spawn_renderer`, `diagnostic_spawn_marker`
 - Simplest approach: reuse the existing checkpoint capture pipeline with one
  dedicated manifest and a renderer-native diagnostic marker
 - Rejected complexity: live DB adapter, new scene-test framework and production
  spawn entity implementation before the network/gameplay milestones
 - Performance: one diagnostic checkpoint outside production runtime
 ## Status
 - State: ready-for-review
 - Done: fixture-to-renderer manifest/verifier, renderer-native marker, unified
  baseline integration, cold/warm GUI evidence, documentation and log cleanup
 - Next: integrator review, merge cleanup/handoff and M01 closeout audit
 - Blocked by:
 ## Handoff
 - Commits: implementation `24ddc99`; required cleanup `318e6ae`
 - Branch: `work/sindo-main-codex/m01-server-spawn-renderer`
 - Outcome: the pinned AzerothCore Human Warrior start is routed through
  `CoordinateMapper` into the ordinary Eastern Kingdoms capture scene. A
  depth-tested magenta marker begins at the exact mapped spawn origin.
 - Contract/schema: additive diagnostic manifest schema 1 and marker metadata;
  coordinate contract version 2, production renderer APIs, cache formats and
  `Blizzlike335` behavior are unchanged.
 - Verification: `SERVER_SPAWN_RENDERER PASS spawn=1 checkpoint=1 tile=32_48
  chunk=3_12 profile=Blizzlike335`; unified renderer dry-run passed project,
  materials, M2 dedupe, shutdown, `7/7/7` manifest, five-point calibration,
  coordinate-boundary and server-spawn steps; coordinate golden fixtures,
  mapper, StreamingFocus, domain identities, documentation and whitespace gates
  passed. Coordination passed with five expired M00-claim warnings only.
 - GUI evidence: two `1280x900` cold/warm PNGs captured under
  `user://server_spawn_renderer_m01_gui_run2`; focus tile `(32,48)`, terrain
  quality `100/100`, missing cache `0`, queues drained, report results `2`.
  Human inspection confirms the marker is on rendered terrain beside the road
  at Northshire Abbey rather than below terrain or in an adjacent tile. PNG
  hashes: cold `c08c43bcb75e5b3277105afb0d4e5a76caae9db91a7db64488770ffa03e32589`,
  warm `1b75237a090ea163836372a8e39e778c909773f4508063adc3f70a3e12a85a62`.
 - Fidelity: source remains AzerothCore revision
  `68fcf0098b16388093989627f37be530fc91f07d`; server
  `(-8949.95,-132.493,83.5312)` maps to Godot
  `(17199.159666667,83.5312,26016.616666667)`, ADT `(32,48)`, MCNK `(3,12)`.
  This proves coordinate/renderer integration, not original-client visual parity
  or TrinityCore populated-row equivalence.
 - Runtime notes: D3D12 descriptor-heap initialization fell back to Vulkan;
  optional ignored character/ambient GLB imports were unavailable. Neither
  affected terrain/marker evidence. The known anonymous ObjectDB teardown
  warning remained; no Node, renderer resource or RID leak diagnostic occurred
  in the cache-complete run.
 - Repository hygiene: four accidentally committed local GUI logs are removed by
  `318e6ae`; root `*.stdout.log`/`*.stderr.log` files are now ignored. Generated
  PNG/JSON evidence and proprietary corpus remain outside Git.
 - Remaining risks: the diagnostic marker is not a production network entity;
  live server adapters belong to M06/M08. Exact original-client character spawn
  presentation and TrinityCore database equivalence remain unverified.
 - Documentation: `RENDER.md`, renderer-baseline procedure, coordinate-mapping
  and world-renderer module API/input-output/data-flow/capability/source-map
  sections updated. No lifecycle/state diagram changed because the verifier and
  mapper path are synchronous; capture reuses the documented renderer lifecycle.
 - Recommended merge order: `318e6ae` after master merge `747fae8`. Then the M01
  milestone integrator may accept all M01 claims, update target Evidence/checks
  and evaluate `OPENWC_TARGET_DONE`.
@@ -1,7 +1,7 @@
 # M01-RND-STREAMING-FOCUS-001 — Explicit streaming focus contract
 <!-- OPENWC_CLAIM:M01-RND-STREAMING-FOCUS-001:sindo-main-codex:2026-07-15 -->
-<!-- OPENWC_HANDOFF:READY:M01-RND-STREAMING-FOCUS-001:7815385 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M01-RND-STREAMING-FOCUS-001:c8e99f2 -->
 ## Ownership
@@ -0,0 +1,112 @@
 # M02-GMP-INPUT-001 — Player input intent seam
 <!-- OPENWC_CLAIM:M02-GMP-INPUT-001:sindo-main-codex:2026-07-16 -->
 <!-- OPENWC_HANDOFF:READY:M02-GMP-INPUT-001:6bd2e84 -->
 ## Ownership
 - Target: M02
 - Program: GMP/FND
 - Owner/Agent ID: sindo-main-codex
 - Branch: `work/sindo-main-codex/m02-player-input`
 - Lease expires UTC: 2026-07-16
 - Integrator: M02 milestone integrator
 ## Outcome
 Replace direct keyboard polling in the runtime player with remappable Input Map
 actions and an immutable `PlayerInputSource → MoveIntent` boundary while
 preserving the current render-sandbox movement behavior.
 ## Non-goals
 - Extract local movement, terrain query, camera rig or character presenters.
 - Claim exact build-12340 movement/keybinding parity before original-client fixtures.
 - Change movement speeds, camera geometry, terrain sampling or renderer behavior.
 - Mark M02 complete or edit its checklist/Evidence.
 ## Paths
 - Exclusive: `src/domain/input/`, `src/gameplay/input/`,
  `src/tests/scenes/player_input_regression.tscn`,
  `src/tools/verify_player_input.gd`, `docs/modules/player-input.md`, this claim
 - Shared/hotspots: `project.godot`,
  `src/scenes/player/third_person_wow_controller.gd`, `docs/modules/README.md`
 - Generated/ignored: Godot import metadata, `.uid` files and local renderer corpus
 ## Contracts and data
 - Public API: immutable `MoveIntent`; `PlayerInputSource.sample_move_intent`
 - Configuration: additive `openwc_player_*` Input Map actions
 - Persistence/schema/cache: unchanged
 - Consumers: current sandbox player controller; later local movement controller
 ## Dependencies
 - Requires: merged M01 coordinate/streaming-focus contracts on master `62eece9`
 - Blocks: later M02 movement-controller extraction
 - External state: none; tests use synthetic Input Map events
 ## Verification
 - Commands: dedicated player-input verifier, headless project load, coordinate
  boundary gate, coordination/documentation gates and diff hygiene
 - Fixtures: synthetic action strengths and configured default bindings
 - Fidelity evidence: current W/S/A/D, Shift, E/Q and Space sandbox behavior remains
  mapped through actions; exact 3.3.5a semantics remain unverified
 - Performance budget: one immutable intent allocation per physics tick; no I/O
 ## Documentation deliverables
 - Inline API documentation for `MoveIntent`, `PlayerInputActions` and
  `PlayerInputSource`
 - Player-input module specification with inputs/outputs, data-flow and sequence diagrams
 - Module registry/source map and honest capability status
 ## Simplicity and naming
 - Important names: `MoveIntent`, `PlayerInputSource`, `PlayerInputActions`
 - Simplest approach: immutable value, one input adapter and one controller consumer
 - Rejected complexity: input provider hierarchy, event bus and generic command framework
 - Unavoidable complexity: none
 - Measured optimization evidence: not applicable
 ## Status
 - State: ready-for-review
 - Done: twelve remappable actions, immutable `MoveIntent`, stateless
  `PlayerInputSource`, controller migration, asset-free regression scene,
  dedicated verifier and module specification
 - Next: M02 integrator reviews and merges before local movement extraction
 - Blocked by:
 ## Handoff
 - Commit: `6bd2e84`
 - Branch: `work/sindo-main-codex/m02-player-input`
 - Outcome: the runtime player no longer polls physical keyboard keys. Movement
  action strengths cross an immutable `MoveIntent` seam; camera and immediate
  sandbox-flight events use the same remappable action catalog.
 - Public contract: additive `MoveIntent`, `PlayerInputActions` and
  `PlayerInputSource`; no schema, cache, coordinate or renderer contract change.
 - Verification: `PLAYER_INPUT PASS actions=12 intent_cases=6 controller=1
  regression_scene=1`; asset-free scene smoke exited `0`; coordinate boundary
  (`88` files) and StreamingFocus gates passed; unified renderer dry-run passed
  all eight pre-capture gates and produced seven dry-run checkpoint results;
  coordination/documentation/diff gates passed.
 - Fidelity: W/S/A/D, Shift, E/Q, Space, right mouse, wheel and Escape remain the
  default sandbox bindings. Regression drives forward movement, camera zoom and
  immediate flight toggle through the real controller. This does not establish
  exact build-12340 default bindings, turn/strafe policy or gameplay movement parity.
 - Local verification inputs: the isolated worktree reused the existing ignored
  native DLL and generated ADT resource scripts. Proprietary extracted data and
  the character GLB were absent, so the renderer dry-run logged the expected
  missing-corpus diagnostics while all contract steps returned success.
 - Rebuild/migration: none. Action names are additive; persisted user-binding
  migration does not exist yet and is documented as a gap.
 - Remaining risks: production profile gating for sprint/free flight, exact
  3.3.5a bindings, local movement/terrain/camera/presentation extraction and
  broader movement/camera state tests remain M02 work.
 - Documentation: inline API comments plus `docs/modules/player-input.md` with
  inputs/outputs, data-flow and sequence diagrams, ownership, recovery,
  capability status, known gaps and source map.
@@ -0,0 +1,117 @@
 # M02-GMP-MOVEMENT-001 — Local movement state/controller
 <!-- OPENWC_CLAIM:M02-GMP-MOVEMENT-001:sindo-main-codex:2026-07-16 -->
 <!-- OPENWC_HANDOFF:READY:M02-GMP-MOVEMENT-001:435e1c9 -->
 ## Ownership
 - Target: M02
 - Program: GMP
 - Owner/Agent ID: sindo-main-codex
 - Branch: `work/sindo-main-codex/m02-local-movement`
 - Lease expires UTC: 2026-07-16
 - Integrator: M02 milestone integrator
 ## Outcome
 Move local velocity, sandbox flight state, acceleration and directional speed
 calculation from `ThirdPersonWowController` into a scene-free,
 independently-testable local movement controller without changing current
 sandbox motion.
 ## Non-goals
 - Extract terrain queries, camera rig, character presentation or animation.
 - Add jump/fall/swim, server prediction or reconciliation.
 - Change current movement speeds, acceleration, camera-relative flight or ground snap.
 - Gate debug movement by build profile; that remains a separate M02 package.
 - Mark M02 complete or edit its checklist/Evidence.
 ## Paths
 - Exclusive: `src/gameplay/movement/`,
  `src/tools/verify_local_player_movement.gd`,
  `docs/modules/local-player-movement.md`, this claim
 - Shared/hotspots: `src/scenes/player/third_person_wow_controller.gd`,
  `src/tools/verify_player_input.gd`, `docs/modules/player-input.md`,
  `docs/modules/README.md`
 - Generated/ignored: local `.godot`, native DLL, generated ADT resources and renderer corpus
 ## Contracts and data
 - Public API: stateful `LocalPlayerMovementController`
 - Inputs: immutable `MoveIntent`, local Godot movement basis and physics delta seconds
 - Outputs: local Godot displacement and read-only velocity/flight state
 - Schema/cache/coordinate contracts: unchanged
 - Consumer: current sandbox player scene; later gameplay composition root
 ## Dependencies
 - Requires: merged input seam on master `14dead1`
 - Blocks: terrain query and camera/presentation extraction from the player hotspot
 - External state: none; unit tests use synthetic intents and bases
 ## Verification
 - Commands: dedicated pure movement verifier, player-input regression, asset-free
  scene smoke, coordinate/StreamingFocus gates, renderer dry-run and repository gates
 - Fixtures: identity/rotated/pitched bases, acceleration steps, sprint and flight transitions
 - Fidelity evidence: exact current 7.0/4.5/4.5 speeds, 28.0 acceleration,
  6x sandbox sprint and camera-relative free flight are regression-locked only
 - Performance budget: one small state update per physics tick; no allocation, I/O or scene lookup
 ## Documentation deliverables
 - Inline public API docs for movement state/configuration and update methods
 - Local movement module specification with data-flow, state and sequence diagrams
 - Updated player-input consumer diagram/status and module registry
 ## Simplicity and naming
 - Important name: `LocalPlayerMovementController`
 - Simplest approach: one stateful RefCounted owning velocity and flight toggle
 - Rejected complexity: generic locomotion framework, ECS component hierarchy and event bus
 - Unavoidable complexity: movement basis remains an explicit local-space input
  so the pure controller does not discover player/camera Nodes
 - Measured optimization evidence: not applicable
 ## Status
 - State: ready-for-review
 - Done: scene-free movement state/controller, player scene migration, twelve
  numeric cases, two flight transitions, integrated regression and module documentation
 - Next: M02 integrator reviews and merges before TerrainQuery extraction
 - Blocked by:
 ## Handoff
 - Commit: `435e1c9`
 - Branch: `work/sindo-main-codex/m02-local-movement`
 - Outcome: `ThirdPersonWowController` no longer owns velocity, flight state,
  acceleration or directional speed calculation. It selects an explicit
  Godot-world basis, applies returned displacement, and retains terrain and
  presentation adapters for later M02 packages.
 - Public contract: additive `LocalPlayerMovementController` with read-only
  Godot-world velocity/flight state, `toggle_sandbox_flight` and `advance`.
  Input, coordinate, cache and renderer contracts remain unchanged.
 - Verification: `LOCAL_PLAYER_MOVEMENT PASS cases=12 state_transitions=2
  scene_boundary=1`; `PLAYER_INPUT PASS actions=12 intent_cases=6 controller=1
  regression_scene=1`; asset-free scene smoke exited `0`; coordinate boundary
  and StreamingFocus passed; renderer dry-run passed all eight pre-capture gates
  and seven checkpoint plans; coordination/documentation/diff gates passed.
 - Fidelity: exact existing defaults are regression-locked—forward `7.0`,
  backward/strafe `4.5`, acceleration `28.0`, sandbox sprint `6x`, vertical
  flight `7.0`, velocity reset on toggle and camera-relative pitched flight.
  This preserves the sandbox baseline but is not original-client evidence.
 - Local verification inputs: the isolated worktree reused the existing ignored
  native DLL and generated ADT resource scripts. Proprietary extracted data and
  character GLB were absent, so renderer dry-run logged expected missing-corpus
  diagnostics while every contract step returned success.
 - Rebuild/migration: none; transient movement state is not persisted.
 - Remaining risks: exported speed changes after `_ready` do not reconfigure the
  controller; exact build-12340 movement semantics, terrain/collision state,
  jump/fall/swim, server prediction and debug profile gating remain open.
 - Documentation: inline public API plus `docs/modules/local-player-movement.md`
  with inputs/outputs, data-flow, state and sequence diagrams, ownership,
  recovery, capability status, risks and source map; player-input consumer
  diagrams/status were updated.
@@ -0,0 +1,118 @@
 # M02-GMP-TERRAIN-QUERY-001 — Player terrain query boundary
 <!-- OPENWC_CLAIM:M02-GMP-TERRAIN-QUERY-001:sindo-main-codex:2026-07-16 -->
 <!-- OPENWC_HANDOFF:READY:M02-GMP-TERRAIN-QUERY-001:a45d521 -->
 ## Ownership
 - Target: M02
 - Program: GMP/RND
 - Owner/Agent ID: sindo-main-codex
 - Branch: `work/sindo-main-codex/m02-terrain-query`
 - Lease expires UTC: 2026-07-16
 - Integrator: M02 milestone integrator
 ## Outcome
 Introduce a typed `TerrainQuery` boundary and move ADT loading, caching, chunk
 selection and height interpolation out of `ThirdPersonWowController` without
 changing current spawn/ground-snap behavior.
 ## Non-goals
 - Change ADT topology, coordinate formulas, terrain mesh or renderer caches.
 - Add physics collision, slopes, water, jump/fall/swim or server movement.
 - Reuse the streaming renderer cache before its public terrain-query contract exists.
 - Extract camera or character presentation.
 - Mark M02 complete or edit its checklist/Evidence.
 ## Paths
 - Exclusive: `src/gameplay/terrain/`, `src/tools/verify_terrain_query.gd`,
  `docs/modules/terrain-query.md`, this claim
 - Shared/hotspots: `src/scenes/player/third_person_wow_controller.gd`,
  `src/tools/verify_player_input.gd`,
  `src/tools/verify_coordinate_conversion_boundaries.gd`,
  `docs/modules/local-player-movement.md`,
  `docs/modules/README.md`
 - Generated/ignored: local `.godot`, native DLL, generated ADT resources and renderer corpus
 ## Contracts and data
 - Public API: `TerrainQuery.sample_ground_height(GodotWorldPosition)` returning
  immutable `TerrainGroundSample`
 - Production adapter: `AdtTerrainQuery` with owned per-tile parse cache
 - Test/data-source seam: optional ADT tile loader callable at construction
 - Coordinate contract version, ADT format, renderer cache and persistence: unchanged
 - Consumers: current player scene; future movement/collision policies
 ## Dependencies
 - Requires: merged movement controller on master `5206c42`
 - Blocks: camera/presentation extraction from the player hotspot
 - External state: production uses existing native `ADTLoader`; synthetic tests need no proprietary data
 ## Verification
 - Commands: synthetic height/cache/failure verifier, player input/movement
  regressions, asset-free scene, coordinate/StreamingFocus gates, renderer dry-run
  and repository gates
 - Fixtures: synthetic 145-height chunk payload and injected flat terrain query
 - Fidelity evidence: preserves existing outer-grid bilinear interpolation,
  spawn ground offset and per-tick snap formula only
 - Performance budget: one cached tile lookup and local interpolation per ground query;
  no new I/O after first tile load
 ## Documentation deliverables
 - Inline public API docs for query, sample and ADT adapter
 - Terrain-query module spec with inputs/outputs, data-flow, cache lifecycle and sequence diagrams
 - Updated movement/coordinate consumer boundaries, source maps and module registry
 ## Simplicity and naming
 - Important names: `TerrainQuery`, `TerrainGroundSample`, `AdtTerrainQuery`
 - Simplest approach: one narrow query contract, one typed result and one existing-format adapter
 - Rejected complexity: general collision framework, terrain service locator and renderer-cache coupling
 - Unavoidable complexity: ADT 145-height layout and chunk lookup stay isolated in adapter
 - Measured optimization evidence: existing per-tile cache retained; no new optimization
 ## Status
 - State: ready-for-review
 - Done: typed query/sample contract, cached ADT adapter, player migration,
  synthetic interpolation/cache/failure tests, injected scene regression and documentation
 - Next: M02 integrator reviews and merges before camera-rig extraction
 - Blocked by:
 ## Handoff
 - Commit: `a45d521`
 - Branch: `work/sindo-main-codex/m02-terrain-query`
 - Outcome: `ThirdPersonWowController` no longer loads ADTs, caches tile
  dictionaries, selects chunks or interpolates height grids. It consumes a
  replaceable typed `TerrainQuery` and retains only existing offset/snap policy.
 - Public contracts: additive immutable `TerrainGroundSample`, replaceable
  `TerrainQuery`, cached `AdtTerrainQuery` and player `set_terrain_query`.
  Coordinate contract version, ADT/native format and renderer caches are unchanged.
 - Verification: `TERRAIN_QUERY PASS contract=4 interpolation=1 cache=1
  failures=2 player_injection=1`; player-input and local-movement regressions
  passed; asset-free scene exited `0`; coordinate boundary passed with five
  required consumers and StreamingFocus passed; renderer dry-run passed eight
  pre-capture gates and seven checkpoint plans; coordination/documentation/diff gates passed.
 - Fidelity: synthetic fractional-grid fixture locks the inherited 145-height
  outer-grid bilinear result within `0.002` Godot units; injected scene locks
  spawn offset `0.05` and physics snap. This is sandbox-regression evidence,
  not build-12340 triangle/hole/collision parity.
 - Local verification inputs: isolated worktree reused the existing ignored
  native DLL and generated ADT resource scripts. Proprietary extracted data and
  character GLB were absent, so renderer dry-run logged expected missing-corpus
  diagnostics while all contract steps returned success.
 - Rebuild/migration: none; caches are transient and existing formats remain unchanged.
 - Remaining risks: first ADT parse remains synchronous as before; unavailable
  tiles cache until query replacement; player still owns snap policy; exact
  ADT triangle choice, holes, slopes, liquids and collision remain open.
 - Documentation: inline public APIs plus `docs/modules/terrain-query.md` with
  inputs/outputs, data-flow, cache state and cross-boundary sequence diagrams,
  ownership, failure/recovery, capability status and source map. Coordinate and
  movement consumer specifications were updated.
@@ -0,0 +1,118 @@
 # M02-RND-CAMERA-001 — Third-person camera rig boundary
 <!-- OPENWC_CLAIM:M02-RND-CAMERA-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-camera-rig`
 - Lease expires UTC: 2026-07-16
 - Integrator: M02 milestone integrator
 ## Outcome
 Move mouse capture, orbit yaw/pitch, zoom state and Camera3D transforms from
 `ThirdPersonWowController` into a reusable `ThirdPersonCameraRig`, with an
 explicit replaceable camera-collision policy that preserves the current
 no-collision sandbox baseline.
 ## Non-goals
 - Enable a new collision/raycast behavior before build-12340 comparison.
 - Change initial yaw/pitch, zoom limits, sensitivity, FOV, far plane or camera path.
 - Implement first-person, follow lag, shoulder offsets or cinematic cameras.
 - Change movement, terrain query, character presentation or renderer streaming focus.
 - Mark M02 complete or edit its checklist/Evidence.
 ## Paths
 - Exclusive: `src/scenes/player/third_person_camera_rig.gd`,
  `src/scenes/player/camera_collision_policy.gd`,
  `src/scenes/player/no_camera_collision_policy.gd`,
  `src/tools/verify_third_person_camera_rig.gd`,
  `docs/modules/third-person-camera.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/player-input.md`,
  `docs/modules/local-player-movement.md`, `docs/modules/README.md`
 - Generated/ignored: local `.godot`, native DLL, generated resources and renderer corpus
 ## Contracts and data
 - Public API: `ThirdPersonCameraRig.initialize_for_character`,
  `handle_camera_input`, `godot_world_flight_movement_basis`, state getters and
  `set_collision_policy`
 - Policy: `CameraCollisionPolicy.resolve_camera_distance`; default
  `NoCameraCollisionPolicy` returns requested distance unchanged
 - Scene paths and renderer camera path remain unchanged
 - Schema/cache/coordinate contracts: unchanged
 - Consumers: player composition, sandbox flight movement and renderer viewport
 ## Dependencies
 - Requires: merged TerrainQuery package on master `f5bb64e`
 - Blocks: character appearance/animation extraction from remaining player hotspot
 - External state: none; tests use asset-free camera/player scene
 ## Verification
 - Commands: dedicated orbit/zoom/clamp/policy verifier, input/movement/terrain
  regressions, asset-free scene, coordinate/StreamingFocus gates, renderer dry-run
  and repository gates
 - Fixtures: initial state, remappable action events, mouse deltas and fixed-distance policy
 - Fidelity evidence: preserve current `-18°` pitch, `8` distance, `1` zoom step,
  `2..18` clamp, `0.003` sensitivity and no-collision output
 - Performance budget: constant-time state/transform update; no raycast in baseline policy
 ## Documentation deliverables
 - Inline API/export documentation for rig and collision policies
 - Camera module spec with inputs/outputs, data-flow, state and sequence diagrams
 - Updated input/movement consumer diagrams/source maps and module registry
 ## Simplicity and naming
 - Important names: `ThirdPersonCameraRig`, `CameraCollisionPolicy`,
  `NoCameraCollisionPolicy`
 - Simplest approach: one Node3D rig on existing CameraPivot and one explicit identity policy
 - Rejected complexity: generic camera framework, spring arm migration and hidden physics raycast
 - Unavoidable complexity: rig mutates Camera3D/character Node transforms on main thread
 - Measured optimization evidence: not applicable
 ## Status
 - State: ready-for-review
 - Done: extracted rig and collision policy, migrated all three scene compositions,
  added regressions and completed required module documentation
 - Next: milestone integrator reviews and merges `8c1cf9b`
 - Blocked by:
 <!-- OPENWC_HANDOFF:READY:M02-RND-CAMERA-001:8c1cf9b -->
 ## Handoff
 - Outcome: `ThirdPersonCameraRig` now owns capture, orbit, zoom and camera
  transforms; `ThirdPersonWowController` only dispatches camera events and
  consumes the rig basis for sandbox flight.
 - Public contracts: `initialize_for_character`, `handle_camera_input`,
  `godot_world_flight_movement_basis`, `set_collision_policy`, read-only state,
  and `CameraCollisionPolicy.resolve_camera_distance`.
 - Verification: camera `state_cases=12 policy_cases=3 scenes=3`, input
  `actions=12 intent_cases=6`, movement `cases=12 state_transitions=2`, terrain
  `contract=4 interpolation=1 cache=1 failures=2`, coordinate boundary
  `files=98 consumers=5`; documentation, coordination and diff checks passed.
 - Renderer dry-run: seven checkpoint plans and report completed; expected
  diagnostics only for unavailable proprietary corpus/character GLB.
 - Fidelity: preserves the sandbox defaults (`-18 degrees`, distance `8`, zoom
  `2..18` step `1`, sensitivity `0.003`, pivot `1.7`, far `50000`) and the prior
  no-collision behavior. No build-12340 parity claim is made.
 - Local ignored inputs: native extension DLL and generated ADT resource scripts
  were used for the renderer dry-run and are not part of the commit.
 - Migration: none; `ThirdPersonPlayer/CameraPivot/Camera3D` remains stable.
 - Risks: active collision and exact original-client camera semantics remain
  unverified; exported initial values are captured at ready; mouse mode is
  process-global.
 - Documentation: added the camera API/module spec plus data-flow, state and
  sequence diagrams; updated player-input and local-movement consumer maps.
@@ -10,7 +10,10 @@
 .\tools\run_render_baseline.ps1
 ```
-Скрипт последовательно проверяет headless-загрузку проекта, renderer materials, M2 unique-id dedupe, regression manifest и затем снимает checkpoint-ы. Для CI или быстрой проверки контракта без PNG:
+Скрипт последовательно проверяет headless-загрузку проекта, renderer materials,
 M2 unique-id dedupe, regression manifest, coordinate boundaries и dedicated
 server-spawn renderer contract, затем снимает checkpoint-ы. Для CI или быстрой
 проверки контракта без PNG:
 ```powershell
 .\tools\run_render_baseline.ps1 -DryRun -WaitSeconds 0.1 -MeasureSeconds 0.1
@@ -18,6 +21,21 @@
 Если `godot` отсутствует в `PATH`, скрипт использует локальный executable, указанный в `RENDER.md`. Другой executable задаётся через `-GodotPath`.
 Отдельный M01 server-spawn checkpoint использует тот же capture pipeline, но не
 расширяет семичастный M00 visual baseline:
 ```powershell
 godot --headless --path . --script res://src/tools/verify_server_spawn_renderer.gd
 godot --path . --script res://src/tools/capture_render_checkpoints.gd -- `
  --manifest res://src/tools/server_spawn_render_manifest.json `
  --output user://server_spawn_renderer
 ```
 Manifest связывает pinned AzerothCore Human Warrior spawn с Godot position,
 ADT tile/chunk и renderer-native diagnostic marker. Маркер начинается точно в
 spawn origin и проходит обычный depth test, поэтому screenshot показывает его
 отношение к terrain; это integration evidence, а не заявление visual parity.
 Результат по умолчанию находится в `user://render_baseline`:
 - `report.json` — Godot, OS, CPU, GPU/backend, viewport, revision, cache inventory, cache versions, параметры checkpoint-ов и результаты;
@@ -9,6 +9,10 @@
 | Foundation/data | Planned/Partial | [`../../targets/roadmap/01-foundation-and-data.md`](../../targets/roadmap/01-foundation-and-data.md) |
 | Coordinate mapping | Implemented | [`coordinate-mapping.md`](coordinate-mapping.md) |
 | Domain identities | Implemented contract | [`domain-identities.md`](domain-identities.md) |
 | 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) |
 | Third-person camera | Implemented | [`third-person-camera.md`](third-person-camera.md) |
 | Renderer | Partial | [`world-renderer.md`](world-renderer.md), [`../../RENDER.md`](../../RENDER.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) |
@@ -5,9 +5,9 @@
 | Field | Value |
 |---|---|
 | Status | Implemented |
-| Target/work package | `M01-FND-COORDS-001`, `M01-FND-COORD-TILE-AXIS-002`, `M01-QAR-COORD-FIXTURES-001`, `M01-FND-COORD-BOUNDARY-GATE-001` |
+| Target/work package | `M01-FND-COORDS-001`, `M01-FND-COORD-TILE-AXIS-002`, `M01-QAR-COORD-FIXTURES-001`, `M01-FND-COORD-BOUNDARY-GATE-001`, `M01-QAR-SERVER-SPAWN-RENDERER-001`, `M02-GMP-TERRAIN-QUERY-001` consumer migration |
 | Owners | Foundation/domain |
-| Last verified | Worktree `work/sindo-main-codex/m01-coordinate-boundary-gate`, 2026-07-13 |
+| Last verified | `a45d521`, 2026-07-14 |
 | Profiles/capabilities | All profiles; contract version 2 |
 ## Purpose
@@ -86,7 +86,7 @@ Forbidden dependencies:
 | Input | `AdtPlacementPosition` | Future ADT adapter | `CoordinateMapper` | Immutable caller value | Any thread, call duration |
 | Input | `CanonicalWowWorldPosition`, `CanonicalWowWorldYaw` | Gameplay/content/domain | `CoordinateMapper` | Immutable caller value | Any thread, call duration |
 | Output | `CanonicalWowWorldPosition` | `CoordinateMapper` | Gameplay/content/adapters | New immutable value | Caller-owned reference |
-| Output | `AdtTileCoordinate`, `AdtTileLocalPosition`, `AdtChunkCoordinate` | `CoordinateMapper` | Streaming/content adapters | New immutable values | Caller-owned references |
+| Output | `AdtTileCoordinate`, `AdtTileLocalPosition`, `AdtChunkCoordinate` | `CoordinateMapper` | Streaming/content/terrain-query adapters | New immutable values | Caller-owned references |
 | Output | `GodotWorldPosition`, `GodotWorldYaw` | `CoordinateMapper` | Future render/scene adapter | New immutable values | Caller-owned references |
 | Test input | `coordinate_golden_points.json` schema 1 | Pinned public server row plus private numeric observations | Headless fixture verifier | Versioned repository fixture | Test-process lifetime |
@@ -103,6 +103,10 @@ flowchart LR
    RawADTFixture[Raw ADT numeric metadata] --> FixtureVerifier
    ClientFixture[Build 12340 observations] --> FixtureVerifier
    FixtureVerifier --> Mapper
    ServerFixture --> SpawnManifest[Server spawn render manifest]
    SpawnManifest --> SpawnVerifier[Renderer checkpoint verifier]
    SpawnVerifier --> Capture[Live renderer capture]
    Capture --> Marker[Diagnostic marker at mapped spawn]
    Server[ServerWorldPosition X,Y,Z] -->|identity components| Canonical[CanonicalWowWorldPosition]
    ADT[AdtPlacementPosition X,height,Z] -->|half extent - horizontal| Canonical
    Canonical -->|tileX from Y; tileY from X| Tile[AdtTileCoordinate]
@@ -111,6 +115,10 @@ flowchart LR
    Canonical -->|half extent - Y; Z; half extent - X| Godot[GodotWorldPosition]
    Godot -->|typed direct adapter| Tile
    Godot -->|typed direct adapter| Local
    Godot --> TerrainQuery[AdtTerrainQuery consumer]
    TerrainQuery --> Tile
    TerrainQuery --> Local
    TerrainQuery --> Chunk
    Tile -->|tile plus local| Godot
    ServerYaw[ServerWorldYaw] -->|normalize only| CanonicalYaw[CanonicalWowWorldYaw]
    CanonicalYaw -->|same numeric world angle| GodotYaw[GodotWorldYaw]
@@ -179,8 +187,13 @@ raw three-number arrays are not an accepted new persistence contract.
 - Unit/contract tests: `src/tools/verify_coordinate_mapper.gd`.
 - Cross-source golden test: `src/tools/verify_coordinate_golden_fixtures.gd`.
 - Boundary enforcement: `src/tools/verify_coordinate_conversion_boundaries.gd`.
- Integration/E2E: sky, player, streamer and terrain probe use mapper boundaries;
+- Server-spawn renderer contract: `src/tools/verify_server_spawn_renderer.gd`
-  `StreamingFocus` provides typed renderer focus.
+  validates the dedicated manifest against the same pinned fixture before GUI capture.
 - Integration/E2E: sky, player spawn, streamer, terrain probe and the extracted
  `AdtTerrainQuery` use mapper boundaries;
  `StreamingFocus` provides typed renderer focus, and the pinned AzerothCore
  Human Warrior spawn is captured in the Eastern Kingdoms renderer at ADT
  `(32,48)`, chunk `(3,12)`.
 - Fidelity evidence: five build-12340 camera positions from the M00 manifest map
  within `0.002` yard; a pinned AzerothCore human-warrior spawn and one raw MCNK
  header observation independently confirm tile `(32,48)` and chunk `(3,12)`;
@@ -207,7 +220,7 @@ raw three-number arrays are not an accepted new persistence contract.
 | Scene-free production contract | Implemented | Source boundary, headless tests and repository-wide conversion gate | Maintain gate with new consumers |
 | Cross-source coordinate fixture | Implemented | Pinned AzerothCore spawn, raw ADT MCNK metadata and five build-12340 points pass one headless verifier | Add live adapter/renderer integration |
 | TrinityCore populated spawn equivalence | Not verified | The base development schema has no pinned populated row used by this fixture | Pin and verify a TDB snapshot before claiming parity |
-| Visual/server-spawn integration | Planned | M01 target criteria | Route the fixture through migrated adapters and renderer |
+| Visual/server-spawn integration | Implemented | Dedicated manifest/verifier plus cold/warm GUI capture of the mapped AzerothCore spawn | This is coordinate/renderer integration evidence, not original-client visual parity |
 ## Known gaps and risks
@@ -235,6 +248,9 @@ raw three-number arrays are not an accepted new persistence contract.
 | `src/tests/fixtures/coordinate_golden_points.json` | Versioned cross-source values, provenance and tolerances |
 | `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/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 |
 ## Related decisions and references
@@ -0,0 +1,246 @@
 # Local Player Movement
 ## Metadata
 | Field | Value |
 |---|---|
 | Status | Implemented |
 | Target/work package | M02 / M02-GMP-MOVEMENT-001, M02-RND-CAMERA-001 basis producer update |
 | 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 |
 ## 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.
 ## Non-goals
 - Apply world transforms or own a `CharacterBody3D`.
 - Query terrain height, collision, water or slopes.
 - Implement jump, fall, swim, server prediction or reconciliation.
 - Select the player basis versus camera-pivot basis; the scene adapter owns that decision.
 - Claim build-12340 movement fidelity from sandbox regression alone.
 ## Context and boundaries
 ```mermaid
 flowchart LR
    Input[MoveIntent] --> Movement[LocalPlayerMovementController]
    Basis[Explicit local movement Basis] --> Movement
    Delta[Physics delta seconds] --> Movement
    Movement --> Displacement[Godot-world displacement]
    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]
 ```
 Allowed dependencies:
 - `MoveIntent` from the gameplay input boundary.
 - Godot value types `Basis` and `Vector3` for renderer world-space direction math.
 - Main-thread scene adapter for basis selection and displacement application.
 Forbidden dependencies:
 - `Node`, `Resource`, `Input`, `Camera3D`, `ADTLoader` or scene lookup.
 - World-coordinate conversion or manual ADT/tile formulas.
 - Character assets, animation players, materials, packets or server state.
 ## Public API
 | 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 |
 | `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 |
 | `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 |
 Constructor units:
 | Parameter | Unit/meaning |
 |---|---|
 | `run_speed_units_per_second` | Forward Godot units per second |
 | `backward_speed_units_per_second` | Backward Godot units per second |
 | `strafe_speed_units_per_second` | Lateral Godot units per second |
 | `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 |
 ## Inputs and outputs
 | Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
 |---|---|---|---|---|---|
 | Input | `MoveIntent` | `PlayerInputSource` | Movement controller | Immutable caller-held value | One physics tick |
 | 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 | Flight state | Movement controller | Basis/terrain scene adapter | Read-only boolean | Until next toggle |
 Side effects:
 - Mutates only controller-owned velocity and flight state.
 - Does not mutate scene tree, transforms, resources, filesystem, network or cache.
 - The scene adapter remains responsible for transform mutation and ground snap.
 ## Data flow
 ```mermaid
 flowchart LR
    Intent[MoveIntent axes] --> Target[Calculate target velocity]
    Basis[Player or camera-pivot Basis] --> Directions[Forward/right directions]
    Directions --> Target
    Config[Speeds and sprint multiplier] --> Target
    Previous[Owned velocity] --> Integrate[move_toward by acceleration × delta]
    Target --> Integrate
    Integrate --> Current[Updated velocity]
    Current --> Step[velocity × delta]
    Step --> Displacement[Scene-applied displacement]
 ```
 ## Lifecycle/state
 ```mermaid
 stateDiagram-v2
    [*] --> GroundedSandbox
    GroundedSandbox --> FlyingSandbox: toggle / clear velocity
    FlyingSandbox --> GroundedSandbox: toggle / clear velocity
    GroundedSandbox --> GroundedSandbox: advance
    FlyingSandbox --> FlyingSandbox: advance
 ```
 The names describe the existing sandbox mode only. They are not authoritative
 gameplay movement states and do not imply terrain contact or server permission.
 ## Main sequence
 ```mermaid
 sequenceDiagram
    participant Input as PlayerInputSource
    participant Scene as ThirdPersonWowController
    participant Move as LocalPlayerMovementController
    participant Present as Facing/Animation adapter
    Input-->>Scene: MoveIntent
    Scene->>Move: advance(intent, selected basis, delta)
    Move-->>Scene: displacement
    Scene->>Scene: apply global position and ground snap
    Scene->>Move: godot_world_velocity_units_per_second
    Scene->>Present: horizontal motion
 ```
 ## Ownership, threading and resources
 - The player scene creates and exclusively owns one movement controller.
 - 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.
 - No Nodes, Resources, RIDs, files, jobs or worker threads are created.
 - The supplied `Basis` is a Godot-world direction basis, not a typed world-position contract or coordinate conversion.
 ## Errors, cancellation and recovery
 | Failure | Detection | Behavior | Diagnostic | Recovery |
 |---|---|---|---|---|
 | 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 |
 | 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
 controller resets velocity and flight state deterministically.
 ## Configuration and capabilities
 | Setting/capability | Default | Profile | Runtime mutable | Effect |
 |---|---|---|---|---|
 | Forward speed | `7.0` units/s | Current sandbox | Fixed for controller lifetime | Target forward velocity |
 | Backward speed | `4.5` units/s | Current sandbox | Fixed for controller lifetime | Target backward velocity |
 | Strafe speed | `4.5` units/s | Current sandbox | Fixed for controller lifetime | Target lateral velocity |
 | Acceleration | `28.0` units/s² | Current sandbox | Fixed for controller lifetime | Acceleration and deceleration |
 | 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 |
 ## Persistence, cache and migration
 Movement state is transient and not serialized. No schema, cache, migration or
 saved settings change is introduced. Future reconnect/replay state requires a
 separate versioned movement snapshot contract.
 ## Diagnostics and observability
 - Logs: verifier emits `LOCAL_PLAYER_MOVEMENT PASS` or named invariant failures.
 - Metrics: none yet; update is constant-time vector math.
 - Debug views: current character facing and animation remain observable scene outputs.
 - Correlation IDs: not applicable to synchronous local sandbox state.
 ## Verification
 - 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.
 - 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.
 - Performance budget: constant-time vector math, no per-tick I/O or scene lookup;
  `MoveIntent` allocation remains owned by the input package.
 ## Extension points
 - 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.
 ## Capability status
 | Capability | Status | Evidence | Gap/next step |
 |---|---|---|---|
 | 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 |
 | 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 |
 | Prediction/reconciliation | Planned | M08/M09 roadmap | Requires movement snapshot/network contract |
 ## Known gaps and risks
 - Numeric defaults preserve the existing sandbox but 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.
 - The module uses Godot math value types; a future engine-independent gameplay
  predictor may require scalar/domain movement contracts.
 ## Source map
 | Path | Responsibility |
 |---|---|
 | `src/gameplay/movement/local_player_movement_controller.gd` | Owned velocity/flight state and deterministic integration |
 | `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/tools/verify_local_player_movement.gd` | Pure numeric, state-transition and dependency regression |
 | `src/tests/scenes/player_input_regression.tscn` | Asset-free integrated player fixture |
 | `src/tools/verify_player_input.gd` | Input-to-movement scene regression |
 ## Related decisions and references
 - ADR: none; this follows the existing M02 decomposition boundary.
 - Upstream/reference: `targets/02-player-decomposition.md`,
  `targets/roadmap/04-gameplay-systems.md`, `docs/ARCHITECTURE.md`.
@@ -0,0 +1,217 @@
 # Player Input
 ## Metadata
 | Field | Value |
 |---|---|
 | Status | Partial |
 | Target/work package | M02 / M02-GMP-INPUT-001, M02-GMP-MOVEMENT-001 and M02-RND-CAMERA-001 consumer updates |
 | 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 |
 ## 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.
 ## 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.
 ## Context and boundaries
 ```mermaid
 flowchart LR
    Devices[Keyboard and mouse] --> InputMap[Godot Input Map]
    InputMap --> Source[PlayerInputSource]
    Source --> Intent[MoveIntent]
    Intent --> Movement[LocalPlayerMovementController]
    Movement --> Controller[ThirdPersonWowController adapter]
    Controller --> Camera[ThirdPersonCameraRig]
 ```
 Allowed dependencies:
 - `PlayerInputSource` may read Godot's process-wide `Input` adapter.
 - The scene controller may consume `MoveIntent` and camera-specific action names.
 - `MoveIntent` may contain scalar axes and request flags only.
 Forbidden dependencies:
 - `MoveIntent` must not read `Input`, inherit `Node`/`Resource`, or contain world coordinates.
 - The input source must not mutate player transforms, camera nodes or animation state.
 - Renderer, terrain parsers and network codecs must not read Input Map actions.
 ## Public API
 | 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.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.compose_move_intent(...)` | Pure factory | Clamps strengths, cancels opposites and normalizes diagonal planar input | Any thread with scalar inputs | None |
 ## Inputs and outputs
 | Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
 |---|---|---|---|---|---|
 | 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 | Camera action names | `PlayerInputActions` | `ThirdPersonCameraRig` | Static constants | Process lifetime |
 Side effects:
 - `PlayerInputSource` has no side effects beyond reading current engine input.
 - `ThirdPersonCameraRig` owns mouse mode, orbit state and camera transforms;
  player remains only the event-dispatch composition boundary.
 - No filesystem, cache, network, database or renderer-resource mutation occurs.
 ## Data flow
 ```mermaid
 flowchart LR
    Project[project.godot action defaults] --> Map[InputMap]
    Remap[User or editor remapping] --> Map
    Map -->|movement strengths| Source[PlayerInputSource]
    Map -->|camera events| Camera[ThirdPersonCameraRig]
    Source -->|clamp cancel normalize| Intent[MoveIntent]
    Intent --> Consumer[LocalPlayerMovementController]
    Consumer --> Adapter[ThirdPersonWowController]
 ```
 ## Lifecycle/state
 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.
 ## Main sequence
 ```mermaid
 sequenceDiagram
    participant Engine as Godot Input
    participant Source as PlayerInputSource
    participant Intent as MoveIntent
    participant Move as LocalPlayerMovementController
    participant Player as ThirdPersonWowController adapter
    Engine->>Source: movement action strengths
    Source->>Intent: compose normalized axes and requests
    Source-->>Player: sample_move_intent()
    Player->>Move: advance(intent, selected basis, delta)
    Move-->>Player: displacement and velocity state
 ```
 ## Ownership, threading and resources
 - The controller owns the input-source reference for its scene lifetime.
 - Each `MoveIntent` is immutable and retained only by its consumer.
 - Sampling and controller mutation occur on the main physics thread.
 - The module creates no Nodes, Resources, RIDs, workers or background jobs.
 - Input Map definitions are project configuration; runtime remapping remains
  engine-owned and does not mutate the domain value.
 ## Errors, cancellation and recovery
 | Failure | Detection | Behavior | Diagnostic | Recovery |
 |---|---|---|---|---|
 | Required action missing | Headless contract verifier | Godot returns zero input for that action | `PLAYER_INPUT` failure naming action | Restore action or user mapping |
 | 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 |
 There is no asynchronous operation to cancel and no persisted state to roll back.
 ## Configuration and capabilities
 | 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 |
 | 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 |
 ## Persistence, cache and migration
 The action names are additive project configuration. No saved binding schema,
 cache or migration exists yet. Renaming an action is a contract change and must
 provide a settings migration once user settings are persisted.
 ## Diagnostics and observability
 - Logs: dedicated verifier emits `PLAYER_INPUT PASS` or one failure per invariant.
 - Metrics: none; sampling cost is one small value allocation per physics tick.
 - Debug views: none.
 - Correlation IDs: not applicable to local synchronous input.
 ## Verification
 - Unit/contract tests: `src/tools/verify_player_input.gd` validates all actions,
  default bindings, axis cancellation/clamping/normalization 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.
 - 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
  action in Project Settings before checking movement.
 ## Extension points
 - A gamepad/accessibility adapter may call `compose_move_intent` without changing
  movement consumers.
 - A later input-context owner may suppress gameplay actions while preserving the
  same intent contract.
 - A future server-aware movement predictor may replace the current local
  movement consumer without changing `PlayerInputSource`.
 ## Capability status
 | Capability | Status | Evidence | Gap/next step |
 |---|---|---|---|
 | 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 |
 | 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.
 - Camera state is extracted; active collision remains an explicit planned policy.
 - There is no persisted user keybinding format or UI yet.
 ## Source map
 | Path | Responsibility |
 |---|---|
 | `project.godot` | Additive default Input Map bindings |
 | `src/domain/input/move_intent.gd` | Immutable locomotion request contract |
 | `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/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/tools/verify_player_input.gd` | Headless contract/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`.
@@ -0,0 +1,251 @@
 # Terrain Query
 ## Metadata
 | Field | Value |
 |---|---|
 | Status | Implemented |
 | Target/work package | M02 / M02-GMP-TERRAIN-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 |
 ## Purpose
 Provide a replaceable, scene-free ground-height query for player movement.
 Isolate native ADT loading, per-tile caching, chunk selection and legacy outer
 height-grid interpolation from the player scene behind a typed
 `GodotWorldPosition → TerrainGroundSample` contract.
 ## Non-goals
 - Own player transforms, movement velocity or ground-snap policy.
 - Provide collision normals, slopes, holes, liquids, WMO/M2 collision or ray queries.
 - Change ADT topology, coordinate conversion, renderer caches or native parser format.
 - Claim original-client terrain-contact parity from height regression alone.
 - Couple gameplay to the monolithic streaming renderer before a public backend exists.
 ## Context and boundaries
 ```mermaid
 flowchart LR
    Scene[ThirdPersonWowController adapter] --> Position[GodotWorldPosition]
    Position --> Contract[TerrainQuery]
    Contract --> Adapter[AdtTerrainQuery]
    Adapter --> Mapper[CoordinateMapper]
    Adapter --> Native[ADTLoader]
    Native --> Tile[ADT tile Dictionary]
    Tile --> Cache[Owned tile cache]
    Cache --> Sample[TerrainGroundSample]
    Sample --> Scene
    Scene --> Snap[Existing ground-snap policy]
 ```
 Allowed dependencies:
 - Typed `GodotWorldPosition` and `CoordinateMapper` contracts.
 - Existing native `ADTLoader` at the ADT adapter boundary.
 - Dynamic dictionaries only inside the native-format adapter.
 - Player scene composition may inject any `TerrainQuery` implementation.
 Forbidden dependencies:
 - `TerrainQuery` contract depending on Nodes, cameras, input or renderer state.
 - Player scene loading/parsing ADT data or owning a parsed tile cache.
 - Manual WoW/Godot/ADT world-coordinate conversion outside `CoordinateMapper`.
 - Terrain query mutating transforms, gameplay movement state or visual meshes.
 ## Public API
 | Symbol | Kind | Purpose | Thread/lifetime | Errors |
 |---|---|---|---|---|
 | `TerrainGroundSample.available(height_units)` | Immutable value factory | Creates a finite Godot-world ground height | Any thread; caller-held value | Non-finite height becomes unavailable |
 | `TerrainGroundSample.unavailable(failure_code)` | Immutable value factory | Creates explicit unavailable result | Any thread; caller-held value | Empty code normalizes to `terrain_unavailable` |
 | `TerrainQuery.sample_ground_height(position)` | Replaceable boundary | Samples ground at typed Godot world position | Implementation-defined; current adapter main-thread owned | Base reports `terrain_query_not_implemented` |
 | `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 |
 ## Inputs and outputs
 | Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
 |---|---|---|---|---|---|
 | Input | `GodotWorldPosition` | Player scene adapter | `TerrainQuery` | Immutable caller-held value | One query |
 | Input | Extracted directory/map name | Scene composition | `AdtTerrainQuery` | Copied strings | Query lifetime |
 | Input | ADT file/dictionary | Filesystem/native loader or injected loader | `AdtTerrainQuery` | Adapter-owned cached dictionary | Query lifetime |
 | Output | `TerrainGroundSample` | Terrain query | Player ground-snap adapter | Immutable caller-held value | One query |
 | Output | Failure code | Terrain query | Diagnostics/tests | Immutable `StringName` | Sample lifetime |
 Side effects:
 - Production adapter performs lazy file existence check and native ADT parse on first tile query.
 - Adapter mutates only its per-query tile/failure caches.
 - No scene tree, transform, renderer RID, network, database or persisted setting mutation occurs.
 ## Data flow
 ```mermaid
 flowchart LR
    Position[GodotWorldPosition] --> TileCoord[CoordinateMapper tile/local/chunk]
    TileCoord --> Lookup{Tile cached?}
    Lookup -->|no| Load[ADTLoader or injected loader]
    Load --> Cache[Cache Dictionary or unavailable result]
    Lookup -->|yes| Cache
    Cache --> Chunk[Select MCNK by origin]
    Chunk --> Heights[Validate 145 heights]
    Heights --> Bilinear[Interpolate 9x9 outer grid]
    Bilinear --> Available[TerrainGroundSample available]
    Cache -->|missing/invalid| Unavailable[TerrainGroundSample unavailable]
 ```
 ## Lifecycle/state
 ```mermaid
 stateDiagram-v2
    [*] --> TileUnknown
    TileUnknown --> TileAvailable: first query / successful load
    TileUnknown --> TileUnavailable: first query / missing or failed
    TileAvailable --> TileAvailable: cached queries
    TileUnavailable --> TileUnavailable: cached queries
    TileAvailable --> [*]: query released
    TileUnavailable --> [*]: query released
 ```
 Unavailable tiles are cached intentionally to avoid repeated filesystem/native
 work each physics tick. Recovery after files appear requires replacing the query
 instance; hot-reload invalidation is outside this M02 package.
 ## Main sequence
 ```mermaid
 sequenceDiagram
    participant Player as ThirdPersonWowController
    participant Query as TerrainQuery
    participant ADT as AdtTerrainQuery
    participant Mapper as CoordinateMapper
    participant Native as ADTLoader
    Player->>Query: sample_ground_height(GodotWorldPosition)
    Query->>ADT: implementation dispatch
    ADT->>Mapper: tile/local/chunk coordinates
    alt tile not cached
        ADT->>Native: load_adt(absolute path)
        Native-->>ADT: ADT Dictionary
    end
    ADT->>ADT: select chunk and interpolate heights
    ADT-->>Player: TerrainGroundSample
    Player->>Player: apply existing offset/snap if available
 ```
 ## Ownership, threading and resources
 - Player scene owns the active `TerrainQuery` reference.
 - `AdtTerrainQuery` exclusively owns tile/failure dictionaries until released.
 - Current production calls and cache mutations occur on the main physics thread.
 - Native loader result dictionaries do not cross the adapter boundary.
 - Samples and typed positions are immutable caller-held values.
 - The module creates no Nodes, Resources, RIDs or background jobs.
 - Future worker-backed queries require an explicit async/result contract rather
  than concurrent mutation of the current dictionaries.
 ## Errors, cancellation and recovery
 | Failure | Detection | Behavior | Diagnostic | Recovery |
 |---|---|---|---|---|
 | Base contract used directly | Base method | Unavailable sample | `terrain_query_not_implemented` | Inject implementation |
 | Native loader absent | ClassDB check | Cache unavailable tile | `adt_loader_unavailable` | Load extension and replace query |
 | ADT file absent | File check | Cache unavailable tile | `adt_source_missing` | Restore corpus and replace query |
 | Native parse empty/fails | Result validation | Cache unavailable tile | `adt_load_failed` | Inspect source/parser; replace query |
 | Injected loader returns wrong type | Type check | Cache unavailable tile | `adt_loader_result_invalid` | Fix adapter |
 | Chunk absent | Chunk lookup | Unavailable sample | `adt_chunk_missing` | Validate ADT dictionary |
 | Height array shorter than 145 | Size check | Unavailable sample | `adt_chunk_heights_invalid` | Fix parser/source |
 | Non-finite interpolated height | Sample invariant | Unavailable sample | `terrain_height_not_finite` | Inspect source values |
 | Null query injection | Scene guard | Existing query retained | Player composition error | Pass valid query |
 There are no asynchronous operations to cancel. Replacing/releasing the query
 is the deterministic cache-reset and recovery path.
 ## Configuration and capabilities
 | Setting/capability | Default | Profile | Runtime mutable | Effect |
 |---|---|---|---|---|
 | Extracted directory | Player `extracted_dir` | Current sandbox | Captured at creation | ADT source root |
 | Map directory name | Player `map_name` | Current sandbox | Captured at creation | ADT filename/path |
 | Loader override | Invalid callable | Test/custom data source | Constructor only | Bypasses production ClassDB/file loading |
 | Tile cache | Enabled | All current uses | Cleared by replacing query | Avoids repeated parse/failure work |
 | Height policy | 9x9 outer-grid bilinear | Current sandbox | Fixed | Preserves pre-extraction behavior |
 ## Persistence, cache and migration
 The cache is in-memory and unversioned because it holds native loader output for
 one query lifetime. No disk cache, schema or migration changes are introduced.
 Existing ADT/native/cache format versions remain unchanged.
 ## Diagnostics and observability
 - Logs: dedicated verifier emits `TERRAIN_QUERY PASS` or named failures.
 - Structured status: every unavailable sample has a stable `failure_code`.
 - Metrics: synthetic verifier counts loader calls to prove one load per tile.
 - Debug views: none.
 - Correlation IDs: not applicable to synchronous local query.
 ## Verification
 - Contract: available/unavailable/base/non-finite result invariants.
 - Pure synthetic adapter: typed coordinate mapping, exact chunk selection,
  145-height layout and bilinear interpolation within `0.002` units (Vector3
  source precision), plus cached second query.
 - Failures: empty tile and invalid height array produce stable codes.
 - Integration: asset-free player scene accepts injected flat query and preserves
  spawn offset `0.05` plus physics ground snap.
 - Boundary: source regression rejects ADT loader/cache/chunk helpers in player.
 - Fidelity evidence: existing interpolation and snap behavior only; no
  original-client or collision parity claim.
 - Performance budget: one dictionary cache lookup and scalar interpolation per
  cached query; native parse only on first tile access.
 ## Extension points
 - Streaming renderer or physics backend may implement `TerrainQuery` without changing player/movement.
 - 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.
 - Async streaming requires a separate availability/update model.
 ## Capability status
 | Capability | Status | Evidence | Gap/next step |
 |---|---|---|---|
 | 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 |
 | Holes/slopes/collision | Planned | Outside height-only contract | Later movement/physics package |
 | Liquid/swim query | Planned | Outside contract | M09/M12 world gameplay |
 ## Known gaps and risks
 - Bilinear outer-grid height is the inherited sandbox approximation; exact ADT
  triangle choice, holes and collision are not represented.
 - Query is synchronous; first access may parse an ADT on the main thread exactly
  as before extraction. A streaming/backend replacement is future work.
 - Unavailable results remain cached until query replacement.
 - Player still owns ground offset/snap policy; only data access is extracted.
 - Existing native dictionaries remain dynamic inside the adapter.
 ## Source map
 | Path | Responsibility |
 |---|---|
 | `src/gameplay/terrain/terrain_ground_sample.gd` | Immutable available/unavailable result |
 | `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/tools/verify_terrain_query.gd` | Synthetic contract/cache/failure/injection regression |
 | `src/tests/scenes/player_input_regression.tscn` | Asset-free player composition fixture |
 ## Related decisions and references
 - ADR: none; no coordinate, format or authority decision changed.
 - Upstream/reference: `targets/02-player-decomposition.md`,
  `targets/roadmap/02-rendering-and-graphics.md`,
  `targets/roadmap/04-gameplay-systems.md`, `docs/ARCHITECTURE.md`.
@@ -0,0 +1,253 @@
 # Third-Person Camera
 ## Metadata
 | Field | Value |
 |---|---|
 | Status | Implemented |
 | Target/work package | M02 / M02-RND-CAMERA-001 |
 | Owners | Camera presentation state and CameraPivot/Camera3D lifecycle |
 | Last verified | `8c1cf9b`, 2026-07-14 |
 | Profiles/capabilities | Current sandbox orbit/zoom; identity collision policy |
 ## Purpose
 Own third-person mouse capture, orbit yaw/pitch, zoom state and Camera3D local
 transforms on the existing `CameraPivot` node. Expose an explicit replaceable
 camera-distance collision policy while preserving the current no-collision
 sandbox baseline.
 ## Non-goals
 - Implement an unverified physics raycast or claim build-12340 collision parity.
 - Own player movement, terrain queries, streaming focus or character visuals.
 - Implement first-person, follow lag, shoulder camera, cinematics or view modes.
 - Change current sensitivity, pitch/zoom limits, FOV or far plane.
 ## Context and boundaries
 ```mermaid
 flowchart LR
    InputMap[Remappable camera actions] --> Player[ThirdPersonWowController dispatch]
    Player --> Rig[ThirdPersonCameraRig]
    Mouse[Mouse motion] --> Player
    Rig --> Character[Character yaw transform]
    Rig --> Pivot[CameraPivot local transform]
    Rig --> Policy[CameraCollisionPolicy]
    Policy --> Distance[Resolved distance]
    Distance --> Camera[Camera3D local transform]
    Rig --> FlightBasis[Godot-world pivot basis]
    FlightBasis --> Movement[LocalPlayerMovementController adapter]
 ```
 Allowed dependencies:
 - Existing `PlayerInputActions` names and Godot input events.
 - Explicit character, pivot and Camera3D Node references on the main thread.
 - Replaceable `CameraCollisionPolicy` selected by composition/tests.
 - Movement adapter may read the rig's Godot-world basis during sandbox flight.
 Forbidden dependencies:
 - ADT/terrain parsing, movement velocity, gameplay state or animation ownership.
 - Camera rig discovering renderer/network/server services.
 - Default collision policy performing hidden raycasts or changing baseline distance.
 - Collision policy mutating rig/camera/character nodes.
 ## Public API
 | Symbol | Kind | Purpose | Thread/lifetime | Errors |
 |---|---|---|---|---|
 | `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 |
 | `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 |
 | `godot_world_flight_movement_basis()` | Read model | Returns pivot global basis for sandbox flight | Main thread | None |
 | `CameraCollisionPolicy.resolve_camera_distance(pivot, requested)` | Policy boundary | Resolves camera distance in Godot units | Main thread in current implementation | Rig clamps output to `[0, requested]` |
 | `NoCameraCollisionPolicy` | Identity policy | Preserves requested distance with no physics query | Any main-thread call | None |
 Read-only rig state: `yaw_radians`, `pitch_radians`,
 `requested_distance_units`, `resolved_distance_units` and `is_mouse_captured`.
 ## Inputs and outputs
 | Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
 |---|---|---|---|---|---|
 | 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 | 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 |
 | Output | Requested/resolved distance | Camera rig/policy | Camera3D | Rig-owned scalar/read model | Until next input/refresh |
 | Output | Godot-world `Basis` | Camera rig | Flight movement adapter | Value copy | Physics tick |
 Side effects:
 - Mutates mouse mode, character yaw, CameraPivot local transform and Camera3D local transform.
 - Marks Camera3D current and sets its far plane once at ready.
 - Releases captured mouse on rig removal.
 - Creates no files, caches, RIDs, workers, network messages or gameplay state.
 ## Data flow
 ```mermaid
 flowchart LR
    Action[Camera action or mouse delta] --> State[Yaw pitch requested distance capture]
    State --> Clamp[Pitch/zoom clamps]
    Clamp --> Pivot[Pivot height and pitch]
    Clamp --> Request[Requested distance]
    Request --> Policy[CameraCollisionPolicy]
    Policy --> Safe[Clamp 0..requested]
    Safe --> Camera[Camera3D Z distance]
    State --> Character[Character yaw]
 ```
 ## Lifecycle/state
 ```mermaid
 stateDiagram-v2
    [*] --> MouseVisible
    MouseVisible --> MouseCaptured: camera rotate pressed
    MouseCaptured --> MouseVisible: camera rotate released
    MouseCaptured --> MouseVisible: release cursor
    MouseCaptured --> MouseCaptured: mouse motion / orbit and clamp
    MouseVisible --> MouseVisible: zoom and clamp
    MouseCaptured --> [*]: rig removed / release mouse
    MouseVisible --> [*]: rig removed
 ```
 Zoom and collision distance are orthogonal to capture state. The requested zoom
 persists while a policy may temporarily choose a shorter resolved distance.
 ## Main sequence
 ```mermaid
 sequenceDiagram
    participant Engine as Godot Input
    participant Player as ThirdPersonWowController
    participant Rig as ThirdPersonCameraRig
    participant Policy as CameraCollisionPolicy
    participant Camera as Camera3D
    Engine->>Player: InputEvent
    Player->>Rig: handle_camera_input(event)
    Rig->>Rig: update capture/orbit/zoom state
    Rig->>Policy: resolve_camera_distance(pivot, requested)
    Policy-->>Rig: resolved distance
    Rig->>Camera: apply local position/rotation
    opt captured mouse motion
        Rig->>Player: mutate character yaw transform
    end
 ```
 ## Ownership, threading and resources
 - Parent player scene owns the CameraPivot rig and Camera3D child.
 - Rig holds non-owning scene references to character and camera.
 - Rig owns scalar camera state and the RefCounted collision policy.
 - All input/state/scene mutations occur on the main thread.
 - Policy output is a scalar; policies must not mutate supplied nodes.
 - No background tasks, resources, RIDs or caches are created.
 ## Errors, cancellation and recovery
 | Failure | Detection | Behavior | Diagnostic | Recovery |
 |---|---|---|---|---|
 | Camera3D missing | `_ready` lookup | State continues; transform application skipped | `ThirdPersonCameraRig` error with path | Restore child/path and recreate scene |
 | Character missing | Initialization | Orbit state updates without character yaw mutation | Composition/test failure | Call initializer with player node |
 | Null collision policy | Setter guard | Current policy retained | Rig error | Pass valid policy |
 | Policy returns negative/too large | Rig clamp | Distance clamped to `[0, requested]` | Policy regression tests | Fix/replace policy |
 | Rig removed while captured | `_exit_tree` | Mouse made visible | Lifecycle regression | Recreate rig normally |
 There is no asynchronous cancellation or persisted rollback. Recreating the rig
 restores configured defaults.
 ## Configuration and capabilities
 | Setting/capability | Default | Profile | Runtime mutable | Effect |
 |---|---|---|---|---|
 | Initial pitch | `-18°` | Current sandbox | State-owned after ready | Initial orbit elevation |
 | Pitch limits | `-65°..35°` | Current sandbox | Exported | Mouse clamp |
 | Mouse sensitivity | `0.003` rad/pixel | Current sandbox | Exported | Orbit delta |
 | Pivot height | `1.7` units | Current sandbox | Exported | Camera eye origin |
 | Initial distance | `8` units | Current sandbox | Exported before ready | Requested zoom |
 | Zoom limits/step | `2..18`, step `1` | Current sandbox | Exported | Requested distance clamp |
 | Far plane | `50000` units | Renderer sandbox | Exported | Camera far plane |
 | Collision policy | `NoCameraCollisionPolicy` | Current sandbox | Replaceable | Identity distance/no raycast |
 ## Persistence, cache and migration
 Camera state and policy are transient. No SavedVariables/settings schema, cache
 or migration is introduced. Scene paths remain
 `ThirdPersonPlayer/CameraPivot/Camera3D`, so renderer diagnostics and capture
 tools require no path migration.
 ## Diagnostics and observability
 - Logs: missing camera/null policy emit explicit component errors.
 - Read models: yaw, pitch, requested/resolved distance and capture state.
 - Tests: dedicated verifier reports state/policy/scene counts.
 - Metrics/correlation IDs: not applicable to constant-time local presentation.
 ## Verification
 - State regression: initial yaw/pitch/distance/height/far plane, capture/release,
  mouse orbit, character yaw, pitch clamps and zoom clamps.
 - 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
  attach the rig to the existing CameraPivot.
 - Boundary: player no longer owns capture/yaw/pitch/distance or camera transform helper.
 - Existing input/movement/terrain regressions and renderer dry-run remain required.
 - Fidelity evidence: current numeric defaults and identity collision behavior
  only; original-client orbit/collision comparison remains open.
 - Performance: constant-time scalar/transform work once per physics tick and
  input event; no default raycast.
 ## Extension points
 - Add an opt-in raycast collision policy after reference fixtures define mask,
  margin, recovery smoothing and first-person limit.
 - Add follow/shoulder/cinematic rigs as separate components, not branches inside this rig.
 - Persist user camera settings through a future versioned settings module.
 - Input contexts may suppress camera actions before dispatch without changing rig state.
 ## Capability status
 | Capability | Status | Evidence | Gap/next step |
 |---|---|---|---|
 | Independent third-person rig | Implemented | Three scene wirings and player boundary regression | Integrate target checklist after review |
 | Existing orbit/zoom behavior | Implemented | Numeric state/transform regression | Compare against build 12340 |
 | Camera-relative sandbox flight basis | Implemented | Basis and movement regressions | Restrict flight to sandbox profile |
 | Replaceable collision policy | Implemented | Fixed and identity policy tests | Implement verified collision policy |
 | Active camera collision | Planned | Identity policy intentionally preserves baseline | Capture original-client occluder fixtures first |
 | First-person/follow policies | Planned | Outside current sandbox baseline | Later completeness work |
 ## Known gaps and risks
 - Default collision policy performs no occluder avoidance, matching the previous sandbox.
 - Exact WoW camera orbit direction, pitch limits, zoom curve, collision margin and
  recovery smoothing are unverified.
 - Exported initial values are captured at ready; runtime mutation may require an
  explicit reconfiguration API later.
 - Mouse mode remains process-global Godot state and must be coordinated with future UI contexts.
 ## Source map
 | Path | Responsibility |
 |---|---|
 | `src/scenes/player/third_person_camera_rig.gd` | CameraPivot state, input and transforms |
 | `src/scenes/player/camera_collision_policy.gd` | Replaceable distance-policy boundary |
 | `src/scenes/player/no_camera_collision_policy.gd` | Identity baseline policy |
 | `src/scenes/player/third_person_wow_controller.gd` | Camera event dispatch and movement-basis consumer |
 | `src/scenes/streaming/*_streaming.tscn` | Runtime rig composition |
 | `src/tests/scenes/player_input_regression.tscn` | Asset-free rig/player composition |
 | `src/tools/verify_third_person_camera_rig.gd` | State, policy, scene and boundary regression |
 ## Related decisions and references
 - ADR: none; current behavior and scene paths are preserved.
 - Upstream/reference: `targets/02-player-decomposition.md`,
  `targets/roadmap/02-rendering-and-graphics.md`,
  `targets/roadmap/04-gameplay-systems.md`, `docs/ARCHITECTURE.md`.
@@ -5,9 +5,9 @@
 | Field | Value |
 |---|---|
 | Status | Partial |
-| Target/work package | M00 baseline; `M01-RND-STREAMING-FOCUS-001`; декомпозиция M02–M03 |
+| Target/work package | M00 baseline; `M01-RND-STREAMING-FOCUS-001`; `M01-QAR-SERVER-SPAWN-RENDERER-001`; декомпозиция M02–M03 |
 | Owners | Renderer workstream / milestone integrator |
-| Last verified | Worktree `work/sindo-main-codex/m01-streaming-focus`, 2026-07-13 |
+| Last verified | Worktree `work/sindo-main-codex/m01-server-spawn-renderer`, 2026-07-13 |
 | Profiles/capabilities | `Performance`, `Balanced`, `High`, `Custom`; Blizzlike fidelity incomplete |
 ## Purpose
@@ -29,6 +29,8 @@ flowchart LR
    Player[Player or spectator Node3D] --> Adapter[Explicit source adapter]
    Editor[Editor viewport adapter] --> Focus[StreamingFocus]
    Capture[Capture tool] --> Adapter
    SpawnFixture[Pinned server spawn fixture] --> SpawnManifest[Spawn render manifest]
    SpawnManifest --> Capture
    Adapter --> Focus
    Focus --> Loader[StreamingWorldLoader]
    Assets[Extracted WDT/ADT/M2/WMO/BLP] --> Native[Native loaders]
@@ -84,9 +86,11 @@ Forbidden dependencies:
 | 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 | 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 |
 | Test output | Diagnostic spawn marker and cold/warm PNGs | Checkpoint capture tool | Human/integrator review | SceneTree marker; `user://` files | One capture process |
 Side effects:
@@ -102,6 +106,9 @@ Side effects:
 flowchart TD
    P[Player/spectator Node3D] --> A[Explicit scene adapter]
    C[Capture camera] --> A
    SF[Pinned server spawn] --> SM[Validated spawn manifest]
    SM --> C
    SM --> Marker[Renderer-native origin marker]
    E[Editor viewport] --> EA[Editor adapter]
    A --> F[StreamingFocus]
    EA --> F
@@ -119,6 +126,7 @@ flowchart TD
    M2 --> World
    WMO --> World
    Liquid --> World
    Marker --> World
    F --> E[Eviction/retention decisions]
    E --> World
 ```
@@ -224,7 +232,8 @@ 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.
- Integration/E2E: Eastern Kingdoms/Kalimdor streaming scenes and seven cold/warm checkpoints.
+- 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.
 - Performance budgets: M00 report records cold/warm p95 and max hitch; no final acceptance threshold yet.
 - Manual diagnostics: [`../RENDER_BASELINE.md`](../RENDER_BASELINE.md) and [`../../RENDER.md`](../../RENDER.md).
@@ -247,6 +256,7 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
 | 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 |
 ## Known gaps and risks
@@ -287,6 +297,8 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
 | `src/tools/compare_render_checkpoints.gd` | Offline JPG/PNG paired-image perceptual metrics and JSON pass/fail report |
 | `src/tools/verify_render_runtime_cache_shutdown.gd` | Headless ownership regression for detached runtime prototypes, resource caches and empty liquid roots |
 | `src/tools/capture_render_checkpoints.gd` | Deterministic no-roll checkpoint camera, performance and visual capture |
 | `src/tools/server_spawn_render_manifest.json` | Dedicated mapped AzerothCore spawn checkpoint and diagnostic marker configuration |
 | `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 |
@@ -19,6 +19,69 @@ config/icon="res://icon.svg"
 enabled=PackedStringArray("res://addons/mpq_extractor/plugin.cfg")
 [input]
 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)
 ]
 }
 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)
 ]
 }
 openwc_player_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":65,"key_label":0,"unicode":97,"location":0,"echo":false,"script":null)
 ]
 }
 openwc_player_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":68,"key_label":0,"unicode":100,"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)
 ]
 }
 openwc_player_debug_fly_down={
 "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_debug_sprint={
 "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":4194325,"physical_keycode":0,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
 ]
 }
 openwc_player_debug_toggle_flight={
 "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":32,"physical_keycode":32,"key_label":32,"unicode":32,"location":0,"echo":false,"script":null)
 ]
 }
 openwc_player_camera_rotate={
 "deadzone": 0.5,
 "events": [Object(InputEventMouseButton,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"button_mask":0,"position":Vector2(0, 0),"global_position":Vector2(0, 0),"factor":1.0,"button_index":2,"canceled":false,"pressed":false,"double_click":false,"script":null)
 ]
 }
 openwc_player_camera_zoom_in={
 "deadzone": 0.5,
 "events": [Object(InputEventMouseButton,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"button_mask":0,"position":Vector2(0, 0),"global_position":Vector2(0, 0),"factor":1.0,"button_index":4,"canceled":false,"pressed":false,"double_click":false,"script":null)
 ]
 }
 openwc_player_camera_zoom_out={
 "deadzone": 0.5,
 "events": [Object(InputEventMouseButton,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"button_mask":0,"position":Vector2(0, 0),"global_position":Vector2(0, 0),"factor":1.0,"button_index":5,"canceled":false,"pressed":false,"double_click":false,"script":null)
 ]
 }
 openwc_player_release_cursor={
 "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":4194305,"physical_keycode":0,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
 ]
 }
 [physics]
 3d/physics_engine="Jolt Physics"
@@ -0,0 +1,47 @@
 class_name MoveIntent
 extends RefCounted
 ## Immutable player locomotion request expressed in character-local axes.
 ## Axis values are normalized to `[-1, 1]`: forward/right/up are positive.
 ## The intent contains no world coordinates, engine input events or presentation state.
 var forward_axis: float:
 	get:
 		return _forward_axis
 var strafe_axis: float:
 	get:
 		return _strafe_axis
 var vertical_axis: float:
 	get:
 		return _vertical_axis
 var is_sprint_requested: bool:
 	get:
 		return _is_sprint_requested
 var _forward_axis: float
 var _strafe_axis: float
 var _vertical_axis: float
 var _is_sprint_requested: bool
 ## Creates one frame's movement request without retaining mutable input state.
 func _init(
 		forward_axis_value: float = 0.0,
 		strafe_axis_value: float = 0.0,
 		vertical_axis_value: float = 0.0,
 		sprint_requested: bool = false
 ) -> 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
 ## Returns true when the intent requests planar or vertical translation.
 func has_translation() -> bool:
 	return not is_zero_approx(_forward_axis) \
 		or not is_zero_approx(_strafe_axis) \
 		or not is_zero_approx(_vertical_axis)
@@ -0,0 +1 @@
 uid://btk7brcavbeec
@@ -0,0 +1,34 @@
 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.
 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 DEBUG_FLY_UP := &"openwc_player_debug_fly_up"
 const DEBUG_FLY_DOWN := &"openwc_player_debug_fly_down"
 const DEBUG_SPRINT := &"openwc_player_debug_sprint"
 const DEBUG_TOGGLE_FLIGHT := &"openwc_player_debug_toggle_flight"
 const CAMERA_ROTATE := &"openwc_player_camera_rotate"
 const CAMERA_ZOOM_IN := &"openwc_player_camera_zoom_in"
 const CAMERA_ZOOM_OUT := &"openwc_player_camera_zoom_out"
 const RELEASE_CURSOR := &"openwc_player_release_cursor"
 const REQUIRED_ACTIONS: Array[StringName] = [
 	MOVE_FORWARD,
 	MOVE_BACKWARD,
 	STRAFE_LEFT,
 	STRAFE_RIGHT,
 	DEBUG_FLY_UP,
 	DEBUG_FLY_DOWN,
 	DEBUG_SPRINT,
 	DEBUG_TOGGLE_FLIGHT,
 	CAMERA_ROTATE,
 	CAMERA_ZOOM_IN,
 	CAMERA_ZOOM_OUT,
 	RELEASE_CURSOR,
 ]
@@ -0,0 +1 @@
 uid://bbhtyxm428bkm
@@ -0,0 +1,45 @@
 class_name PlayerInputSource
 extends RefCounted
 ## Converts remappable Godot Input Map actions into immutable [MoveIntent] values.
 ## This adapter owns no movement state and may be replaced independently of the
 ## local movement controller.
 ## 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)
 	)
 ## Builds a normalized 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,
 		backward_strength: float,
 		strafe_left_strength: float,
 		strafe_right_strength: float,
 		fly_up_strength: float,
 		fly_down_strength: float,
 		sprint_requested: bool
 ) -> MoveIntent:
 	var planar_axis := Vector2(
 		clampf(strafe_right_strength, 0.0, 1.0) - clampf(strafe_left_strength, 0.0, 1.0),
 		clampf(forward_strength, 0.0, 1.0) - clampf(backward_strength, 0.0, 1.0)
 	)
 	if planar_axis.length_squared() > 1.0:
 		planar_axis = planar_axis.normalized()
 	var vertical_axis := clampf(fly_up_strength, 0.0, 1.0) - clampf(fly_down_strength, 0.0, 1.0)
 	return MoveIntent.new(
 		planar_axis.y,
 		planar_axis.x,
 		vertical_axis,
 		sprint_requested
 	)
@@ -0,0 +1 @@
 uid://b050i2lnei8qq
@@ -0,0 +1,97 @@
 class_name LocalPlayerMovementController
 extends RefCounted
 ## Scene-free state and velocity integrator for the current local sandbox player.
 ## Direction inputs use a Godot-world movement basis selected by the scene
 ## adapter. This class does not discover Nodes, query terrain or mutate transforms.
 var godot_world_velocity_units_per_second: Vector3:
 	get:
 		return _godot_world_velocity_units_per_second
 var is_flight_enabled: bool:
 	get:
 		return _is_flight_enabled
 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 _godot_world_velocity_units_per_second := Vector3.ZERO
 var _is_flight_enabled := false
 ## Creates a movement state with explicit Godot-unit speeds and acceleration.
 ## The current compatibility renderer treats one Godot unit as one WoW yard.
 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
 ) -> void:
 	_run_speed_units_per_second = run_speed_units_per_second
 	_backward_speed_units_per_second = backward_speed_units_per_second
 	_strafe_speed_units_per_second = strafe_speed_units_per_second
 	_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
 ## Toggles sandbox free flight and clears velocity exactly like the pre-M02 controller.
 ## Returns the new flight state.
 func toggle_sandbox_flight() -> bool:
 	_is_flight_enabled = not _is_flight_enabled
 	_godot_world_velocity_units_per_second = Vector3.ZERO
 	return _is_flight_enabled
 ## Advances velocity by one physics step and returns local-world displacement.
 ## `godot_world_movement_basis` is the player basis on ground and camera-pivot basis in flight.
 ## Negative delta values are treated as zero and do not mutate velocity.
 func advance(
 		move_intent: MoveIntent,
 		godot_world_movement_basis: Basis,
 		delta_seconds: float
 ) -> Vector3:
 	var safe_delta_seconds := maxf(delta_seconds, 0.0)
 	if is_zero_approx(safe_delta_seconds):
 		return Vector3.ZERO
 	var target_velocity := _calculate_target_velocity(move_intent, godot_world_movement_basis)
 	_godot_world_velocity_units_per_second = _godot_world_velocity_units_per_second.move_toward(
 		target_velocity,
 		_acceleration_units_per_second_squared * safe_delta_seconds
 	)
 	return _godot_world_velocity_units_per_second * safe_delta_seconds
 func _calculate_target_velocity(move_intent: MoveIntent, godot_world_movement_basis: Basis) -> Vector3:
 	var forward_direction := -godot_world_movement_basis.z
 	var right_direction := godot_world_movement_basis.x
 	if not _is_flight_enabled:
 		forward_direction.y = 0.0
 		right_direction.y = 0.0
 	forward_direction = forward_direction.normalized()
 	right_direction = right_direction.normalized()
 	var forward_speed := (
 		_run_speed_units_per_second
 		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 target_velocity := (
 		forward_direction * move_intent.forward_axis * forward_speed
 		+ right_direction * move_intent.strafe_axis * _strafe_speed_units_per_second
 	) * speed_multiplier
 	if _is_flight_enabled:
 		target_velocity.y += (
 			move_intent.vertical_axis
 			* _flight_vertical_speed_units_per_second
 			* speed_multiplier
 		)
 	return target_velocity
@@ -0,0 +1 @@
 uid://dxlx5kloh7p5c
@@ -0,0 +1,166 @@
 class_name AdtTerrainQuery
 extends TerrainQuery
 ## TerrainQuery adapter for existing native ADT dictionaries.
 ## Parsed tiles, including unavailable results, are cached for this query's
 ## lifetime. The adapter is main-thread owned and creates no scene resources.
 const COORDINATE_MAPPER_SCRIPT := preload("res://src/domain/coordinates/coordinate_mapper.gd")
 const CHUNK_SIZE_UNITS := COORDINATE_MAPPER_SCRIPT.ADT_CHUNK_SIZE_YARDS
 const OUTER_GRID_UNIT_SIZE := CHUNK_SIZE_UNITS / 8.0
 var _extracted_directory: String
 var _map_directory_name: String
 var _adt_tile_loader_override: Callable
 var _adt_tile_cache: Dictionary = {}
 var _failure_code_by_tile_key: Dictionary = {}
 ## Creates an ADT query for one map. `adt_tile_loader_override` is an optional
 ## test/data-source seam receiving the absolute ADT path and returning a Dictionary.
 func _init(
 		extracted_directory: String,
 		map_directory_name: String,
 		adt_tile_loader_override: Callable = Callable()
 ) -> void:
 	_extracted_directory = extracted_directory
 	_map_directory_name = map_directory_name
 	_adt_tile_loader_override = adt_tile_loader_override
 ## Samples the existing 9x9 outer-height grid with bilinear interpolation.
 func sample_ground_height(godot_world_position: GodotWorldPosition) -> TerrainGroundSample:
 	var tile_coordinate = COORDINATE_MAPPER_SCRIPT.godot_to_adt_tile(godot_world_position)
 	var tile_local_position = COORDINATE_MAPPER_SCRIPT.godot_to_adt_tile_local(godot_world_position)
 	var chunk_coordinate = COORDINATE_MAPPER_SCRIPT.adt_tile_local_to_chunk(
 		tile_coordinate,
 		tile_local_position
 	)
 	var tile_key := _tile_key(tile_coordinate.tile_x, tile_coordinate.tile_y)
 	var adt_tile_data := _load_adt_tile(tile_coordinate.tile_x, tile_coordinate.tile_y)
 	if adt_tile_data.is_empty():
 		return TerrainGroundSample.unavailable(
 			_failure_code_by_tile_key.get(tile_key, &"adt_tile_unavailable")
 		)
 	var tile_origin := _find_tile_origin(adt_tile_data)
 	var chunk := _find_chunk(
 		adt_tile_data,
 		clampi(chunk_coordinate.chunk_x, 0, 15),
 		clampi(chunk_coordinate.chunk_y, 0, 15),
 		tile_origin
 	)
 	if chunk.is_empty():
 		return TerrainGroundSample.unavailable(&"adt_chunk_missing")
 	var heights: PackedFloat32Array = chunk.get("heights", PackedFloat32Array())
 	if heights.size() < 145:
 		return TerrainGroundSample.unavailable(&"adt_chunk_heights_invalid")
 	var chunk_origin: Vector3 = chunk.get("origin", Vector3.ZERO)
 	var chunk_local_x := godot_world_position.x_units - chunk_origin.x
 	var chunk_local_z := godot_world_position.z_units - chunk_origin.z
 	var grid_x := clampf(chunk_local_x / OUTER_GRID_UNIT_SIZE, 0.0, 8.0)
 	var grid_z := clampf(chunk_local_z / OUTER_GRID_UNIT_SIZE, 0.0, 8.0)
 	var x0 := clampi(int(floor(grid_x)), 0, 8)
 	var z0 := clampi(int(floor(grid_z)), 0, 8)
 	var x1 := mini(x0 + 1, 8)
 	var z1 := mini(z0 + 1, 8)
 	var fraction_x := grid_x - float(x0)
 	var fraction_z := grid_z - float(z0)
 	var height_x0 := lerpf(
 		heights[_outer_height_index(z0, x0)],
 		heights[_outer_height_index(z0, x1)],
 		fraction_x
 	)
 	var height_x1 := lerpf(
 		heights[_outer_height_index(z1, x0)],
 		heights[_outer_height_index(z1, x1)],
 		fraction_x
 	)
 	return TerrainGroundSample.available(
 		chunk_origin.y + lerpf(height_x0, height_x1, fraction_z)
 	)
 func _load_adt_tile(tile_x: int, tile_y: int) -> Dictionary:
 	var tile_key := _tile_key(tile_x, tile_y)
 	if _adt_tile_cache.has(tile_key):
 		return _adt_tile_cache[tile_key]
 	var resource_path := _extracted_directory.path_join(
 		"World/Maps/%s/%s_%d_%d.adt" % [_map_directory_name, _map_directory_name, tile_x, tile_y]
 	)
 	var absolute_path := ProjectSettings.globalize_path(resource_path)
 	var adt_tile_data: Dictionary = {}
 	var failure_code: StringName = &""
 	if _adt_tile_loader_override.is_valid():
 		var override_result = _adt_tile_loader_override.call(absolute_path)
 		if override_result is Dictionary:
 			adt_tile_data = override_result
 		else:
 			failure_code = &"adt_loader_result_invalid"
 	elif not ClassDB.class_exists("ADTLoader"):
 		failure_code = &"adt_loader_unavailable"
 	elif not FileAccess.file_exists(absolute_path):
 		failure_code = &"adt_source_missing"
 	else:
 		var loader = ClassDB.instantiate("ADTLoader")
 		if loader != null:
 			var load_result = loader.call("load_adt", absolute_path)
 			if load_result is Dictionary:
 				adt_tile_data = load_result
 		if adt_tile_data.is_empty():
 			failure_code = &"adt_load_failed"
 	if adt_tile_data.is_empty() and failure_code.is_empty():
 		failure_code = &"adt_tile_unavailable"
 	_adt_tile_cache[tile_key] = adt_tile_data
 	_failure_code_by_tile_key[tile_key] = failure_code
 	return adt_tile_data
 func _find_chunk(
 		adt_tile_data: Dictionary,
 		chunk_x: int,
 		chunk_y: int,
 		tile_origin: Vector3
 ) -> Dictionary:
 	for chunk in adt_tile_data.get("chunks", []) as Array:
 		if chunk.is_empty():
 			continue
 		var chunk_origin: Vector3 = chunk.get("origin", Vector3.ZERO)
 		var local_origin := chunk_origin - tile_origin
 		var candidate_chunk_x := clampi(int(round(local_origin.x / CHUNK_SIZE_UNITS)), 0, 15)
 		var candidate_chunk_y := clampi(int(round(local_origin.z / CHUNK_SIZE_UNITS)), 0, 15)
 		if candidate_chunk_x == chunk_x and candidate_chunk_y == chunk_y:
 			return chunk
 	return {}
 func _find_tile_origin(adt_tile_data: Dictionary) -> Vector3:
 	var has_origin := false
 	var minimum_x := 0.0
 	var minimum_z := 0.0
 	for chunk in adt_tile_data.get("chunks", []) as Array:
 		if chunk.is_empty():
 			continue
 		var chunk_origin: Vector3 = chunk.get("origin", Vector3.ZERO)
 		if not has_origin:
 			minimum_x = chunk_origin.x
 			minimum_z = chunk_origin.z
 			has_origin = true
 		else:
 			minimum_x = minf(minimum_x, chunk_origin.x)
 			minimum_z = minf(minimum_z, chunk_origin.z)
 	return Vector3(minimum_x, 0.0, minimum_z) if has_origin else Vector3.ZERO
 func _tile_key(tile_x: int, tile_y: int) -> String:
 	return "%d_%d" % [tile_x, tile_y]
 func _outer_height_index(row: int, column: int) -> int:
 	return row * 17 + column
@@ -0,0 +1 @@
 uid://cq7scvxqw6ffm
@@ -0,0 +1,49 @@
 class_name TerrainGroundSample
 extends RefCounted
 ## Immutable result of a terrain ground-height query in Godot world units.
 ## An unavailable sample carries a stable failure code instead of overloading a
 ## numeric height with `NAN` at the public boundary.
 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
 ## Creates an available ground sample in Godot world units.
 static func available(height_units_value: float) -> TerrainGroundSample:
 	return TerrainGroundSample.new(true, height_units_value, &"")
 ## Creates an unavailable sample with a stable diagnostic code.
 static func unavailable(failure_code_value: StringName) -> TerrainGroundSample:
 	return TerrainGroundSample.new(false, 0.0, failure_code_value)
 ## Normalizes factory inputs so available samples are finite and unavailable
 ## samples always carry a non-empty failure code.
 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 = &"terrain_height_not_finite"
 	else:
 		_failure_code = failure_code_value if not failure_code_value.is_empty() else &"terrain_unavailable"
@@ -0,0 +1 @@
 uid://boe5qkip6ffku
@@ -0,0 +1,12 @@
 class_name TerrainQuery
 extends RefCounted
 ## Replaceable scene-free boundary for gameplay terrain height sampling.
 ## Implementations receive a typed Godot world position and must return an
 ## explicit available/unavailable result without mutating the caller.
 ## Samples terrain ground height at a typed Godot world position.
 ## The base implementation reports `terrain_query_not_implemented`.
 func sample_ground_height(_godot_world_position: GodotWorldPosition) -> TerrainGroundSample:
 	return TerrainGroundSample.unavailable(&"terrain_query_not_implemented")
@@ -0,0 +1 @@
 uid://d3f2hetuo342q
@@ -0,0 +1,15 @@
 class_name CameraCollisionPolicy
 extends RefCounted
 ## Replaceable third-person camera-distance policy.
 ## Implementations may inspect the explicit pivot/world boundary but must return
 ## a distance in Godot units without mutating the rig or camera nodes.
 ## Resolves the camera distance for the current pivot and requested zoom.
 ## The base policy preserves the request unchanged.
 func resolve_camera_distance(
 		_camera_pivot: Node3D,
 		requested_distance_units: float
 ) -> float:
 	return requested_distance_units
@@ -0,0 +1 @@
 uid://bgd41bb3hvbl1
@@ -0,0 +1,12 @@
 class_name NoCameraCollisionPolicy
 extends CameraCollisionPolicy
 ## Identity collision policy preserving the pre-M02 sandbox camera behavior.
 ## Returns the requested distance without physics queries or allocations.
 func resolve_camera_distance(
 		_camera_pivot: Node3D,
 		requested_distance_units: float
 ) -> float:
 	return requested_distance_units
@@ -0,0 +1 @@
 uid://csts45n5rnxro
@@ -0,0 +1,169 @@
 class_name ThirdPersonCameraRig
 extends Node3D
 ## Third-person orbit/zoom state and Camera3D presentation adapter.
 ## The rig owns camera input state and local transforms. Character movement,
 ## terrain, rendering and collision-policy decisions remain external boundaries.
 const NO_CAMERA_COLLISION_POLICY_SCRIPT := preload("res://src/scenes/player/no_camera_collision_policy.gd")
 ## Relative Camera3D child used by this rig.
@export var camera_path: NodePath = NodePath("Camera3D")
 ## Mouse radians applied per input pixel.
@export var mouse_sensitivity_radians_per_pixel: float = 0.003
 ## Minimum orbit pitch in radians.
@export var minimum_pitch_radians: float = deg_to_rad(-65.0)
 ## Maximum orbit pitch in radians.
@export var maximum_pitch_radians: float = deg_to_rad(35.0)
 ## Pivot height above the character origin in Godot units.
@export var pivot_height_units: float = 1.7
 ## Initial requested camera distance in Godot units.
@export var initial_distance_units: float = 8.0
 ## Minimum user-requested zoom distance in Godot units.
@export var minimum_distance_units: float = 2.0
 ## Maximum user-requested zoom distance in Godot units.
@export var maximum_distance_units: float = 18.0
 ## Distance change per zoom action in Godot units.
@export var zoom_step_units: float = 1.0
 ## Camera far plane retained from the renderer sandbox baseline.
@export var camera_far_plane_units: float = 50000.0
 var yaw_radians: float:
 	get:
 		return _yaw_radians
 var pitch_radians: float:
 	get:
 		return _pitch_radians
 var requested_distance_units: float:
 	get:
 		return _requested_distance_units
 var resolved_distance_units: float:
 	get:
 		return _resolved_distance_units
 var is_mouse_captured: bool:
 	get:
 		return _is_mouse_captured
 var _character_body: Node3D
 var _camera: Camera3D
 var _collision_policy: CameraCollisionPolicy
 var _yaw_radians := 0.0
 var _pitch_radians := deg_to_rad(-18.0)
 var _requested_distance_units := 8.0
 var _resolved_distance_units := 8.0
 var _is_mouse_captured := false
 func _ready() -> void:
 	_camera = get_node_or_null(camera_path) as Camera3D
 	if _camera == null:
 		push_error("ThirdPersonCameraRig: Camera3D not found at %s" % camera_path)
 	if _collision_policy == null:
 		_collision_policy = NO_CAMERA_COLLISION_POLICY_SCRIPT.new()
 	_pitch_radians = clampf(_pitch_radians, minimum_pitch_radians, maximum_pitch_radians)
 	_requested_distance_units = clampf(
 		initial_distance_units,
 		minimum_distance_units,
 		maximum_distance_units
 	)
 	if _camera != null:
 		_camera.current = true
 		_camera.far = camera_far_plane_units
 	refresh_camera_transform()
 func _physics_process(_delta_seconds: float) -> void:
 	refresh_camera_transform()
 func _exit_tree() -> void:
 	if _is_mouse_captured:
 		_is_mouse_captured = false
 		Input.mouse_mode = Input.MOUSE_MODE_VISIBLE
 ## Attaches the character transform rotated by orbit input and captures its initial yaw.
 func initialize_for_character(character_body: Node3D) -> void:
 	_character_body = character_body
 	if _character_body != null:
 		_yaw_radians = _character_body.rotation.y
 	refresh_camera_transform()
 ## 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:
 	if collision_policy == null:
 		push_error("ThirdPersonCameraRig: collision policy cannot be null")
 		return
 	_collision_policy = collision_policy
 	refresh_camera_transform()
 ## Applies remappable camera actions and orbit mouse motion.
 ## Returns true when the event changed or consumed camera state.
 func handle_camera_input(event: InputEvent) -> bool:
 	if event.is_action_pressed(PlayerInputActions.CAMERA_ROTATE):
 		_is_mouse_captured = true
 		Input.mouse_mode = Input.MOUSE_MODE_CAPTURED
 		return true
 	if event.is_action_released(PlayerInputActions.CAMERA_ROTATE):
 		_is_mouse_captured = false
 		Input.mouse_mode = Input.MOUSE_MODE_VISIBLE
 		return true
 	if event.is_action_pressed(PlayerInputActions.CAMERA_ZOOM_IN):
 		_requested_distance_units = clampf(
 			_requested_distance_units - zoom_step_units,
 			minimum_distance_units,
 			maximum_distance_units
 		)
 		refresh_camera_transform()
 		return true
 	if event.is_action_pressed(PlayerInputActions.CAMERA_ZOOM_OUT):
 		_requested_distance_units = clampf(
 			_requested_distance_units + zoom_step_units,
 			minimum_distance_units,
 			maximum_distance_units
 		)
 		refresh_camera_transform()
 		return true
 	if event.is_action_pressed(PlayerInputActions.RELEASE_CURSOR):
 		_is_mouse_captured = false
 		Input.mouse_mode = Input.MOUSE_MODE_VISIBLE
 		return true
 	if _is_mouse_captured and event is InputEventMouseMotion:
 		_yaw_radians -= event.relative.x * mouse_sensitivity_radians_per_pixel
 		_pitch_radians = clampf(
 			_pitch_radians - event.relative.y * mouse_sensitivity_radians_per_pixel,
 			minimum_pitch_radians,
 			maximum_pitch_radians
 		)
 		if _character_body != null:
 			_character_body.rotation.y = _yaw_radians
 		refresh_camera_transform()
 		return true
 	return false
 ## Returns the pivot's Godot-world basis for camera-relative sandbox flight.
 func godot_world_flight_movement_basis() -> Basis:
 	return global_basis
 ## Applies pivot and Camera3D local transforms using the active collision policy.
 func refresh_camera_transform() -> void:
 	position = Vector3(0.0, pivot_height_units, 0.0)
 	rotation.x = _pitch_radians
 	if _camera == null:
 		return
 	var policy_distance := _collision_policy.resolve_camera_distance(
 		self,
 		_requested_distance_units
 	) if _collision_policy != null else _requested_distance_units
 	_resolved_distance_units = clampf(policy_distance, 0.0, _requested_distance_units)
 	_camera.position = Vector3(0.0, 0.0, _resolved_distance_units)
 	_camera.rotation = Vector3.ZERO
@@ -0,0 +1 @@
 uid://cq60al4uw0mgo
@@ -7,9 +7,10 @@ const COORDINATE_MAPPER_SCRIPT := preload("res://src/domain/coordinates/coordina
 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")
 const ADT_TILE_LOCAL_POSITION_SCRIPT := preload("res://src/domain/coordinates/adt_tile_local_position.gd")
-
+const PLAYER_INPUT_SOURCE_SCRIPT := preload("res://src/gameplay/input/player_input_source.gd")
-const CHUNK_SIZE := COORDINATE_MAPPER_SCRIPT.ADT_CHUNK_SIZE_YARDS
+const PLAYER_INPUT_ACTIONS_SCRIPT := preload("res://src/gameplay/input/player_input_actions.gd")
-const UNIT_SIZE := CHUNK_SIZE / 8.0
+const LOCAL_PLAYER_MOVEMENT_CONTROLLER_SCRIPT := preload("res://src/gameplay/movement/local_player_movement_controller.gd")
 const ADT_TERRAIN_QUERY_SCRIPT := preload("res://src/gameplay/terrain/adt_terrain_query.gd")
@export var extracted_dir: String = "res://data/extracted"
@export var map_name: String = "Azeroth"
@@ -23,19 +24,10 @@ const UNIT_SIZE := CHUNK_SIZE / 8.0
@export var sprint_multiplier: float = 6.0
@export var flight_vertical_speed: float = 7.0
@export var acceleration: float = 28.0
@export var mouse_sensitivity: float = 0.003
@export var camera_pitch_min: float = deg_to_rad(-65.0)
@export var camera_pitch_max: float = deg_to_rad(35.0)
@export var camera_height: float = 1.7
@export var camera_distance: float = 8.0
@export var camera_min_distance: float = 2.0
@export var camera_max_distance: float = 18.0
@export var camera_zoom_step: float = 1.0
@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 camera_path: NodePath = NodePath("CameraPivot/Camera3D")
@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
@@ -43,27 +35,43 @@ const UNIT_SIZE := CHUNK_SIZE / 8.0
@export var character_yaw_offset_degrees: float = 90.0
@export var animation_blend_time: float = 0.15
-var _camera_pivot: Node3D
+var _camera_rig: ThirdPersonCameraRig
 var _camera: Camera3D
 var _visual: Node3D
 var _character_root: Node3D
 var _animation_player: AnimationPlayer
 var _active_animation := ""
-var _captured := false
+var _player_input_source: PlayerInputSource
-var _yaw := 0.0
+var _local_movement_controller: LocalPlayerMovementController
-var _pitch := deg_to_rad(-18.0)
+var _terrain_query: TerrainQuery
-var _horizontal_velocity := Vector3.ZERO
+
-var _flight_enabled := false
+
-var _adt_cache: Dictionary = {}
+## Replaces the ground-height backend without changing player movement or presentation.
 ## Passing null is a composition error and leaves the current query unchanged.
 func set_terrain_query(terrain_query: TerrainQuery) -> void:
 	if terrain_query == null:
 		push_error("ThirdPersonWowController: terrain query cannot be null")
 		return
 	_terrain_query = terrain_query
 func _ready() -> void:
-	_camera_pivot = get_node_or_null(camera_pivot_path) as Node3D
+	_player_input_source = PLAYER_INPUT_SOURCE_SCRIPT.new()
-	_camera = get_node_or_null(camera_path) as Camera3D
+	if _terrain_query == null:
 		_terrain_query = ADT_TERRAIN_QUERY_SCRIPT.new(extracted_dir, map_name)
 	_local_movement_controller = LOCAL_PLAYER_MOVEMENT_CONTROLLER_SCRIPT.new(
 		run_speed,
 		backward_speed,
 		strafe_speed,
 		flight_vertical_speed,
 		acceleration,
 		sprint_multiplier
 	)
 	_camera_rig = get_node_or_null(camera_pivot_path) as ThirdPersonCameraRig
 	_visual = get_node_or_null(visual_path) as Node3D
-	if _camera:
+	if _camera_rig == null:
-		_camera.current = true
+		push_error("ThirdPersonWowController: ThirdPersonCameraRig not found at %s" % camera_pivot_path)
-		_camera.far = 50000.0
+	else:
 		_camera_rig.initialize_for_character(self)
 	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
@@ -71,104 +79,38 @@ func _ready() -> void:
 		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 ground := _sample_ground_height(global_position)
+	var spawn_ground_sample := _sample_ground_height(global_position)
-	if is_finite(ground):
+	if spawn_ground_sample.is_available:
-		global_position.y = ground + ground_offset
+		global_position.y = spawn_ground_sample.height_units + ground_offset
 	_yaw = rotation.y
 	_apply_camera_transform()
 func _unhandled_input(event: InputEvent) -> void:
-	if event is InputEventMouseButton and event.button_index == MOUSE_BUTTON_RIGHT:
+	if _camera_rig != null:
-		_captured = event.pressed
+		_camera_rig.handle_camera_input(event)
-		Input.mouse_mode = Input.MOUSE_MODE_CAPTURED if _captured else Input.MOUSE_MODE_VISIBLE
+	if event.is_action_pressed(PLAYER_INPUT_ACTIONS_SCRIPT.DEBUG_TOGGLE_FLIGHT) and not event.is_echo():
-	elif event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_WHEEL_UP:
+		_local_movement_controller.toggle_sandbox_flight()
 		camera_distance = clampf(camera_distance - camera_zoom_step, camera_min_distance, camera_max_distance)
 		_apply_camera_transform()
 	elif event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_WHEEL_DOWN:
 		camera_distance = clampf(camera_distance + camera_zoom_step, camera_min_distance, camera_max_distance)
 		_apply_camera_transform()
 	elif event is InputEventKey and event.pressed and event.keycode == KEY_ESCAPE:
 		_captured = false
 		Input.mouse_mode = Input.MOUSE_MODE_VISIBLE
 	elif event is InputEventKey and event.pressed and not event.echo and event.keycode == KEY_SPACE:
 		_flight_enabled = not _flight_enabled
 		_horizontal_velocity = Vector3.ZERO
 	if _captured and event is InputEventMouseMotion:
 		_yaw -= event.relative.x * mouse_sensitivity
 		_pitch = clampf(_pitch - event.relative.y * mouse_sensitivity, camera_pitch_min, camera_pitch_max)
 		rotation.y = _yaw
 		_apply_camera_transform()
 func _physics_process(delta: float) -> void:
-	var input_dir := _get_input_dir()
+	var move_intent := _player_input_source.sample_move_intent()
-	var target_velocity := Vector3.ZERO
+	var godot_world_movement_basis := global_basis
-	if input_dir.length_squared() > 0.0:
+	if _local_movement_controller.is_flight_enabled and _camera_rig != null:
-		target_velocity = _movement_vector(input_dir)
+		godot_world_movement_basis = _camera_rig.godot_world_flight_movement_basis()
-	if _flight_enabled:
+	global_position += _local_movement_controller.advance(move_intent, godot_world_movement_basis, delta)
 		target_velocity.y += _flight_vertical_velocity()
-	_horizontal_velocity = _horizontal_velocity.move_toward(target_velocity, acceleration * delta)
+	if not _local_movement_controller.is_flight_enabled:
-	global_position += _horizontal_velocity * delta
+		var ground_sample := _sample_ground_height(global_position)
-
+		if ground_sample.is_available:
-	if not _flight_enabled:
+			var target_y := ground_sample.height_units + ground_offset
 		var ground := _sample_ground_height(global_position)
 		if is_finite(ground):
 			var target_y := ground + ground_offset
 			global_position.y = lerpf(global_position.y, target_y, clampf(ground_snap_speed * delta, 0.0, 1.0))
-	var horizontal_motion := Vector2(_horizontal_velocity.x, _horizontal_velocity.z)
+	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(-_horizontal_velocity.x, -_horizontal_velocity.z)
+		_visual.global_rotation.y = atan2(-movement_velocity.x, -movement_velocity.z)
 	_update_character_animation(horizontal_motion.length_squared() > 0.04)
 	_apply_camera_transform()
 func _get_input_dir() -> Vector2:
 	var dir := Vector2.ZERO
 	if Input.is_key_pressed(KEY_W):
 		dir.y -= 1.0
 	if Input.is_key_pressed(KEY_S):
 		dir.y += 1.0
 	if Input.is_key_pressed(KEY_A):
 		dir.x -= 1.0
 	if Input.is_key_pressed(KEY_D):
 		dir.x += 1.0
 	return dir.normalized()
 func _movement_vector(input_dir: Vector2) -> Vector3:
 	var forward := -global_basis.z
 	var right := global_basis.x
 	if _flight_enabled and _camera_pivot:
 		forward = -_camera_pivot.global_basis.z
 		right = _camera_pivot.global_basis.x
 	else:
 		forward.y = 0.0
 		right.y = 0.0
 	forward = forward.normalized()
 	right = right.normalized()
 	var speed_z := run_speed if input_dir.y < 0.0 else backward_speed
 	var speed_x := strafe_speed
 	var sprint := sprint_multiplier if Input.is_key_pressed(KEY_SHIFT) else 1.0
 	return (forward * -input_dir.y * speed_z + right * input_dir.x * speed_x) * sprint
 func _flight_vertical_velocity() -> float:
 	var dir := 0.0
 	if Input.is_key_pressed(KEY_E):
 		dir += 1.0
 	if Input.is_key_pressed(KEY_Q):
 		dir -= 1.0
 	var sprint := sprint_multiplier if Input.is_key_pressed(KEY_SHIFT) else 1.0
 	return dir * flight_vertical_speed * sprint
 func _load_character_visual() -> void:
 	if character_model_path.is_empty() or _visual == null:
 		return
@@ -320,104 +262,11 @@ func _character_textures_dir(model_path: String) -> String:
 	return model_path.get_base_dir().path_join(model_path.get_file().get_basename() + "_textures")
-func _apply_camera_transform() -> void:
+func _sample_ground_height(godot_world_position: Vector3) -> TerrainGroundSample:
-	if _camera_pivot:
+	return _terrain_query.sample_ground_height(
-		_camera_pivot.position = Vector3(0.0, camera_height, 0.0)
+		GODOT_WORLD_POSITION_SCRIPT.new(
-		_camera_pivot.rotation.x = _pitch
+			godot_world_position.x,
-	if _camera:
+			godot_world_position.y,
-		_camera.position = Vector3(0.0, 0.0, camera_distance)
+			godot_world_position.z
-		_camera.rotation = Vector3.ZERO
+		)
-
+	)
 func _sample_ground_height(world_pos: Vector3) -> float:
 	var typed_world_position = GODOT_WORLD_POSITION_SCRIPT.new(world_pos.x, world_pos.y, world_pos.z)
 	var tile_coordinate = COORDINATE_MAPPER_SCRIPT.godot_to_adt_tile(typed_world_position)
 	var tile_local_position = COORDINATE_MAPPER_SCRIPT.godot_to_adt_tile_local(typed_world_position)
 	var chunk_coordinate = COORDINATE_MAPPER_SCRIPT.adt_tile_local_to_chunk(tile_coordinate, tile_local_position)
 	var data := _load_adt(tile_coordinate.tile_x, tile_coordinate.tile_y)
 	if data.is_empty():
 		return NAN
 	var tile_origin := _get_tile_origin(data)
 	var chunk_x := clampi(chunk_coordinate.chunk_x, 0, 15)
 	var chunk_y := clampi(chunk_coordinate.chunk_y, 0, 15)
 	var chunk := _find_chunk(data, chunk_x, chunk_y, tile_origin)
 	if chunk.is_empty():
 		return NAN
 	var origin: Vector3 = chunk.get("origin", Vector3.ZERO)
 	var chunk_local := world_pos - origin
 	var gx := clampf(chunk_local.x / UNIT_SIZE, 0.0, 8.0)
 	var gz := clampf(chunk_local.z / UNIT_SIZE, 0.0, 8.0)
 	var x0 := clampi(int(floor(gx)), 0, 8)
 	var z0 := clampi(int(floor(gz)), 0, 8)
 	var x1 := mini(x0 + 1, 8)
 	var z1 := mini(z0 + 1, 8)
 	var fx := gx - float(x0)
 	var fz := gz - float(z0)
 	var heights: PackedFloat32Array = chunk.get("heights", PackedFloat32Array())
 	if heights.size() < 145:
 		return NAN
 	var h00 := heights[_outer(z0, x0)]
 	var h10 := heights[_outer(z0, x1)]
 	var h01 := heights[_outer(z1, x0)]
 	var h11 := heights[_outer(z1, x1)]
 	var hx0 := lerpf(h00, h10, fx)
 	var hx1 := lerpf(h01, h11, fx)
 	return origin.y + lerpf(hx0, hx1, fz)
 func _load_adt(tx: int, ty: int) -> Dictionary:
 	var key := "%d_%d" % [tx, ty]
 	if _adt_cache.has(key):
 		return _adt_cache[key]
 	if not ClassDB.class_exists("ADTLoader"):
 		_adt_cache[key] = {}
 		return {}
 	var res_path := extracted_dir.path_join("World/Maps/%s/%s_%d_%d.adt" % [map_name, map_name, tx, ty])
 	var abs_path := ProjectSettings.globalize_path(res_path)
 	if not FileAccess.file_exists(abs_path):
 		_adt_cache[key] = {}
 		return {}
 	var loader = ClassDB.instantiate("ADTLoader")
 	var data: Dictionary = loader.call("load_adt", abs_path) if loader else {}
 	_adt_cache[key] = data
 	return data
 func _find_chunk(data: Dictionary, chunk_x: int, chunk_y: int, tile_origin: Vector3) -> Dictionary:
 	for chunk in data.get("chunks", []) as Array:
 		if chunk.is_empty():
 			continue
 		var origin: Vector3 = chunk.get("origin", Vector3.ZERO)
 		var local := origin - tile_origin
 		var cx := clampi(int(round(local.x / CHUNK_SIZE)), 0, 15)
 		var cy := clampi(int(round(local.z / CHUNK_SIZE)), 0, 15)
 		if cx == chunk_x and cy == chunk_y:
 			return chunk
 	return {}
 func _get_tile_origin(data: Dictionary) -> Vector3:
 	var found := false
 	var min_x := 0.0
 	var min_z := 0.0
 	for chunk in data.get("chunks", []) as Array:
 		if chunk.is_empty():
 			continue
 		var origin: Vector3 = chunk.get("origin", Vector3.ZERO)
 		if not found:
 			min_x = origin.x
 			min_z = origin.z
 			found = true
 		else:
 			min_x = minf(min_x, origin.x)
 			min_z = minf(min_z, origin.z)
 	return Vector3(min_x, 0.0, min_z) if found else Vector3.ZERO
 func _outer(row: int, col: int) -> int:
 	return row * 17 + col
@@ -3,6 +3,7 @@
 [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"]
 [sub_resource type="CapsuleShape3D" id="PlayerCapsuleShape_1"]
 radius = 0.45
@@ -107,6 +108,7 @@ mesh = SubResource("PlayerCapsuleMesh_1")
 [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)
 script = ExtResource("4_camera_rig")
 [node name="Camera3D" type="Camera3D" parent="ThirdPersonPlayer/CameraPivot" unique_id=2142337971]
 transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 8)
@@ -3,6 +3,7 @@
 [ext_resource type="Script" uid="uid://yi6lawwjgocg" path="res://src/scenes/streaming/streaming_world_loader.gd" id="1_sisqv"]
 [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"]
 [sub_resource type="CapsuleShape3D" id="PlayerCapsuleShape_1"]
 radius = 0.45
@@ -108,6 +109,7 @@ mesh = SubResource("PlayerCapsuleMesh_1")
 [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)
 script = ExtResource("4_camera_rig")
 [node name="Camera3D" type="Camera3D" parent="ThirdPersonPlayer/CameraPivot" unique_id=2142337971]
 transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 8)
@@ -0,0 +1,16 @@
 [gd_scene load_steps=3 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"]
 [node name="PlayerInputRegression" type="CharacterBody3D"]
 script = ExtResource("1_player")
 spawn_at_tile_center = false
 character_model_path = ""
 [node name="Visual" type="Node3D" parent="."]
 [node name="CameraPivot" type="Node3D" parent="."]
 script = ExtResource("2_camera_rig")
 [node name="Camera3D" type="Camera3D" parent="CameraPivot"]
@@ -246,6 +246,8 @@ func _result_record(checkpoint: Dictionary, pass_name: String, load_time_ms: flo
 func _create_probe(checkpoint: Dictionary, dry_run: bool) -> Node3D:
 	if bool(checkpoint.get("diagnostic_spawn_marker", false)):
 		return null if dry_run else _create_diagnostic_spawn_marker(checkpoint)
 	var rel_path := String(checkpoint.get("probe_model", ""))
 	if rel_path.is_empty() or dry_run:
 		return null
@@ -265,6 +267,43 @@ func _create_probe(checkpoint: Dictionary, dry_run: bool) -> Node3D:
 	return M2_NATIVE_ANIMATED_BUILDER.build(data, extracted_dir)
 ## Creates a renderer-native marker whose origin is the exact mapped server
 ## spawn. The vertical mast grows upward from that origin, so terrain occlusion
 ## remains visible instead of being hidden by an always-on-top overlay.
 func _create_diagnostic_spawn_marker(checkpoint: Dictionary) -> Node3D:
 	var marker_root := Node3D.new()
 	marker_root.name = "DiagnosticServerSpawnMarker"
 	var marker_height := maxf(float(checkpoint.get("diagnostic_marker_height", 6.0)), 0.5)
 	var marker_radius := maxf(float(checkpoint.get("diagnostic_marker_radius", 0.35)), 0.05)
 	var marker_material := StandardMaterial3D.new()
 	marker_material.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
 	marker_material.albedo_color = Color(1.0, 0.05, 0.7, 1.0)
 	marker_material.emission_enabled = true
 	marker_material.emission = Color(1.0, 0.01, 0.35, 1.0)
 	var mast_mesh := CylinderMesh.new()
 	mast_mesh.height = marker_height
 	mast_mesh.top_radius = marker_radius
 	mast_mesh.bottom_radius = marker_radius
 	mast_mesh.material = marker_material
 	var mast := MeshInstance3D.new()
 	mast.name = "SpawnOriginMast"
 	mast.mesh = mast_mesh
 	mast.position.y = marker_height * 0.5
 	marker_root.add_child(mast)
 	var origin_mesh := SphereMesh.new()
 	origin_mesh.radius = marker_radius * 1.8
 	origin_mesh.height = marker_radius * 3.6
 	origin_mesh.material = marker_material
 	var origin := MeshInstance3D.new()
 	origin.name = "SpawnOrigin"
 	origin.mesh = origin_mesh
 	marker_root.add_child(origin)
 	return marker_root
 func _set_sky_time(world: Node, time_hours: float) -> void:
 	var sky := world.get_node_or_null("WowSkyController")
 	if sky != null:
@@ -0,0 +1,29 @@
 {
  "schema_version": 1,
  "profile": "Blizzlike335",
  "scene": "res://src/scenes/streaming/eastern_kingdoms_streaming.tscn",
  "map": "Azeroth",
  "quality_preset": "High",
  "viewport": [1280, 900],
  "camera_fov": 62.0,
  "default_wait_seconds": 10.0,
  "default_measure_seconds": 1.0,
  "source_fixture": "res://src/tests/fixtures/coordinate_golden_points.json",
  "source_spawn_name": "azerothcore_human_warrior_start",
  "required_coverage": ["server_spawn"],
  "checkpoints": [
    {
      "name": "azerothcore_human_warrior_start",
      "coverage": ["server_spawn"],
      "camera": [17168.0, 105.0, 25984.0],
      "target": [17199.159666667, 83.5312, 26016.616666667],
      "player": [17199.159666667, 83.5312, 26016.616666667],
      "time_hours": 13.0,
      "diagnostic_spawn_marker": true,
      "diagnostic_marker_height": 6.0,
      "diagnostic_marker_radius": 0.35,
      "expected_adt_tile": [32, 48],
      "expected_adt_chunk": [3, 12]
    }
  ]
 }
@@ -20,7 +20,8 @@ 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/player/third_person_wow_controller.gd": ["godot_to_adt_tile", "adt_tile_local_to_godot"],
+	"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"],
 }
@@ -59,7 +60,7 @@ func _initialize() -> void:
 		quit(1)
 		return
-	print("COORDINATE_CONVERSION_BOUNDARIES PASS files=%d native_boundary=1 oracle=1 consumers=4 classifier_cases=6" % source_paths.size())
+	print("COORDINATE_CONVERSION_BOUNDARIES PASS files=%d native_boundary=1 oracle=1 consumers=5 classifier_cases=6" % source_paths.size())
 	quit(0)
@@ -0,0 +1,137 @@
 extends SceneTree
 ## Headless M02 unit and boundary regression for local player movement state.
 const MOVEMENT_CONTROLLER_PATH := "res://src/gameplay/movement/local_player_movement_controller.gd"
 const PLAYER_CONTROLLER_PATH := "res://src/scenes/player/third_person_wow_controller.gd"
 func _initialize() -> void:
 	var failures: Array[String] = []
 	_verify_directional_speeds(failures)
 	_verify_acceleration_and_deceleration(failures)
 	_verify_sandbox_sprint(failures)
 	_verify_flight_state_and_basis(failures)
 	_verify_invalid_delta(failures)
 	_verify_scene_boundary(failures)
 	if not failures.is_empty():
 		for failure in failures:
 			push_error("LOCAL_PLAYER_MOVEMENT: %s" % failure)
 		quit(1)
 		return
 	print("LOCAL_PLAYER_MOVEMENT PASS cases=12 state_transitions=2 scene_boundary=1")
 	quit(0)
 func _verify_directional_speeds(failures: Array[String]) -> void:
 	var forward_controller := _new_controller()
 	var forward_displacement := forward_controller.advance(_intent(1.0, 0.0), Basis.IDENTITY, 1.0)
 	_expect_vector_near(forward_controller.godot_world_velocity_units_per_second, Vector3(0.0, 0.0, -7.0), "forward velocity", failures)
 	_expect_vector_near(forward_displacement, Vector3(0.0, 0.0, -7.0), "forward displacement", failures)
 	var backward_controller := _new_controller()
 	backward_controller.advance(_intent(-1.0, 0.0), Basis.IDENTITY, 1.0)
 	_expect_vector_near(backward_controller.godot_world_velocity_units_per_second, Vector3(0.0, 0.0, 4.5), "backward velocity", failures)
 	var strafe_controller := _new_controller()
 	strafe_controller.advance(_intent(0.0, 1.0), Basis.IDENTITY, 1.0)
 	_expect_vector_near(strafe_controller.godot_world_velocity_units_per_second, Vector3(4.5, 0.0, 0.0), "strafe velocity", failures)
 	var rotated_controller := _new_controller()
 	var rotated_basis := Basis(Vector3.UP, deg_to_rad(90.0))
 	rotated_controller.advance(_intent(1.0, 0.0), rotated_basis, 1.0)
 	_expect_vector_near(
 		rotated_controller.godot_world_velocity_units_per_second,
 		(-rotated_basis.z).normalized() * 7.0,
 		"rotated character basis",
 		failures
 	)
 func _verify_acceleration_and_deceleration(failures: Array[String]) -> void:
 	var controller := _new_controller()
 	var forward_intent := _intent(1.0, 0.0)
 	_expect_vector_near(controller.advance(forward_intent, Basis.IDENTITY, 0.1), Vector3(0.0, 0.0, -0.28), "first acceleration displacement", failures)
 	_expect_vector_near(controller.godot_world_velocity_units_per_second, Vector3(0.0, 0.0, -2.8), "first acceleration velocity", failures)
 	controller.advance(forward_intent, Basis.IDENTITY, 0.1)
 	_expect_vector_near(controller.godot_world_velocity_units_per_second, Vector3(0.0, 0.0, -5.6), "second acceleration velocity", failures)
 	controller.advance(_intent(0.0, 0.0), Basis.IDENTITY, 0.1)
 	_expect_vector_near(controller.godot_world_velocity_units_per_second, Vector3(0.0, 0.0, -2.8), "deceleration velocity", failures)
 func _verify_sandbox_sprint(failures: Array[String]) -> void:
 	var controller := _new_controller()
 	controller.advance(_intent(1.0, 0.0, 0.0, true), Basis.IDENTITY, 2.0)
 	_expect_vector_near(controller.godot_world_velocity_units_per_second, Vector3(0.0, 0.0, -42.0), "sandbox sprint velocity", failures)
 func _verify_flight_state_and_basis(failures: Array[String]) -> void:
 	var controller := _new_controller()
 	controller.advance(_intent(1.0, 0.0), Basis.IDENTITY, 1.0)
 	_expect_true(controller.toggle_sandbox_flight(), "flight toggles on", failures)
 	_expect_vector_near(controller.godot_world_velocity_units_per_second, Vector3.ZERO, "flight toggle clears velocity", failures)
 	var pitched_basis := Basis(Vector3.RIGHT, deg_to_rad(30.0))
 	controller.advance(_intent(1.0, 0.0, 1.0), pitched_basis, 1.0)
 	var expected_flight_velocity := (-pitched_basis.z).normalized() * 7.0 + Vector3.UP * 7.0
 	_expect_vector_near(controller.godot_world_velocity_units_per_second, expected_flight_velocity, "camera-relative flight velocity", failures)
 	_expect_true(not controller.toggle_sandbox_flight(), "flight toggles off", failures)
 	_expect_vector_near(controller.godot_world_velocity_units_per_second, Vector3.ZERO, "landing toggle clears velocity", failures)
 func _verify_invalid_delta(failures: Array[String]) -> void:
 	var controller := _new_controller()
 	var displacement := controller.advance(_intent(1.0, 0.0), Basis.IDENTITY, -1.0)
 	_expect_vector_near(displacement, Vector3.ZERO, "negative delta displacement", failures)
 	_expect_vector_near(controller.godot_world_velocity_units_per_second, Vector3.ZERO, "negative delta state", 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"]:
 		_expect_true(not movement_source.contains(forbidden_text), "movement controller omits %s" % forbidden_text, failures)
 	var player_source := _read_text(PLAYER_CONTROLLER_PATH, failures)
 	_expect_true(player_source.contains("_local_movement_controller.advance"), "scene delegates movement update", failures)
 	_expect_true(not player_source.contains("move_toward(target_velocity"), "scene omits velocity integration", failures)
 	_expect_true(not player_source.contains("func _movement_vector"), "scene omits movement-vector calculation", failures)
 	_expect_true(not player_source.contains("_horizontal_velocity"), "scene omits movement velocity state", failures)
 	_expect_true(not player_source.contains("var _flight_enabled"), "scene omits flight state", failures)
 func _new_controller() -> LocalPlayerMovementController:
 	return LocalPlayerMovementController.new(7.0, 4.5, 4.5, 7.0, 28.0, 6.0)
 func _intent(
 		forward_axis: float,
 		strafe_axis: float,
 		vertical_axis: float = 0.0,
 		sprint_requested: bool = false
 ) -> MoveIntent:
 	return MoveIntent.new(forward_axis, strafe_axis, vertical_axis, sprint_requested)
 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_vector_near(
 		actual_value: Vector3,
 		expected_value: Vector3,
 		label: String,
 		failures: Array[String]
 ) -> void:
 	if not actual_value.is_equal_approx(expected_value):
 		failures.append("%s expected %s, got %s" % [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)
@@ -0,0 +1,163 @@
 extends SceneTree
 ## Headless M02 contract regression for remappable actions and MoveIntent composition.
 const MOVE_INTENT_PATH := "res://src/domain/input/move_intent.gd"
 const PLAYER_INPUT_SOURCE_PATH := "res://src/gameplay/input/player_input_source.gd"
 const PLAYER_CONTROLLER_PATH := "res://src/scenes/player/third_person_wow_controller.gd"
 const REGRESSION_SCENE_PATH := "res://src/tests/scenes/player_input_regression.tscn"
 func _initialize() -> void:
 	_run_verification.call_deferred()
 func _run_verification() -> void:
 	var failures: Array[String] = []
 	_verify_default_input_actions(failures)
 	_verify_move_intent_composition(failures)
 	_verify_controller_boundary(failures)
 	_verify_regression_scene(failures)
 	if not failures.is_empty():
 		for failure in failures:
 			push_error("PLAYER_INPUT: %s" % failure)
 		quit(1)
 		return
 	print("PLAYER_INPUT PASS actions=%d intent_cases=6 controller=1 regression_scene=1" % PlayerInputActions.REQUIRED_ACTIONS.size())
 	quit(0)
 func _verify_default_input_actions(failures: Array[String]) -> void:
 	for action_name in PlayerInputActions.REQUIRED_ACTIONS:
 		_expect_true(InputMap.has_action(action_name), "Input Map contains %s" % action_name, failures)
 	_expect_key_binding(PlayerInputActions.MOVE_FORWARD, KEY_W, true, failures)
 	_expect_key_binding(PlayerInputActions.MOVE_BACKWARD, KEY_S, true, failures)
 	_expect_key_binding(PlayerInputActions.STRAFE_LEFT, KEY_A, true, failures)
 	_expect_key_binding(PlayerInputActions.STRAFE_RIGHT, KEY_D, true, failures)
 	_expect_key_binding(PlayerInputActions.DEBUG_FLY_UP, KEY_E, true, failures)
 	_expect_key_binding(PlayerInputActions.DEBUG_FLY_DOWN, KEY_Q, true, failures)
 	_expect_key_binding(PlayerInputActions.DEBUG_SPRINT, KEY_SHIFT, false, failures)
 	_expect_key_binding(PlayerInputActions.DEBUG_TOGGLE_FLIGHT, KEY_SPACE, true, failures)
 	_expect_key_binding(PlayerInputActions.RELEASE_CURSOR, KEY_ESCAPE, false, failures)
 	_expect_mouse_binding(PlayerInputActions.CAMERA_ROTATE, MOUSE_BUTTON_RIGHT, failures)
 	_expect_mouse_binding(PlayerInputActions.CAMERA_ZOOM_IN, MOUSE_BUTTON_WHEEL_UP, failures)
 	_expect_mouse_binding(PlayerInputActions.CAMERA_ZOOM_OUT, MOUSE_BUTTON_WHEEL_DOWN, failures)
 func _verify_move_intent_composition(failures: Array[String]) -> void:
 	var neutral := PlayerInputSource.compose_move_intent(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, false)
 	_expect_near(neutral.forward_axis, 0.0, "neutral forward", failures)
 	_expect_true(not neutral.has_translation(), "neutral has no translation", failures)
 	var forward := PlayerInputSource.compose_move_intent(1.0, 0.0, 0.0, 0.0, 0.0, 0.0, false)
 	_expect_near(forward.forward_axis, 1.0, "forward axis", failures)
 	var canceled := PlayerInputSource.compose_move_intent(1.0, 1.0, 1.0, 1.0, 1.0, 1.0, false)
 	_expect_true(not canceled.has_translation(), "opposite actions cancel", failures)
 	var diagonal := PlayerInputSource.compose_move_intent(1.0, 0.0, 0.0, 1.0, 0.0, 0.0, false)
 	_expect_near(Vector2(diagonal.strafe_axis, diagonal.forward_axis).length(), 1.0, "diagonal normalized", failures)
 	var vertical := PlayerInputSource.compose_move_intent(0.0, 0.0, 0.0, 0.0, 1.5, -0.5, false)
 	_expect_near(vertical.vertical_axis, 1.0, "vertical strengths clamped", failures)
 	var debug_requests := PlayerInputSource.compose_move_intent(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, true)
 	_expect_true(debug_requests.is_sprint_requested, "sprint request retained", failures)
 func _verify_controller_boundary(failures: Array[String]) -> void:
 	var controller_source := _read_text(PLAYER_CONTROLLER_PATH, failures)
 	_expect_true(controller_source.contains("sample_move_intent()"), "controller samples PlayerInputSource", failures)
 	_expect_true(not controller_source.contains("Input.is_key_pressed"), "controller omits direct keyboard polling", failures)
 	_expect_true(not controller_source.contains("KEY_"), "controller omits hardcoded key constants", failures)
 	var move_intent_source := _read_text(MOVE_INTENT_PATH, failures)
 	_expect_true(not move_intent_source.contains("extends Node"), "MoveIntent does not inherit Node", failures)
 	_expect_true(not move_intent_source.contains("extends Resource"), "MoveIntent does not inherit Resource", failures)
 	_expect_true(not move_intent_source.contains("Input."), "MoveIntent does not read engine input", failures)
 	var input_source := _read_text(PLAYER_INPUT_SOURCE_PATH, failures)
 	_expect_true(input_source.contains("Input.get_action_strength"), "input source reads action strengths", failures)
 	_expect_true(not input_source.contains("is_key_pressed"), "input source omits physical-key polling", failures)
 func _verify_regression_scene(failures: Array[String]) -> void:
 	var packed_scene := load(REGRESSION_SCENE_PATH) as PackedScene
 	_expect_true(packed_scene != null, "regression scene loads", failures)
 	if packed_scene == null:
 		return
 	var player := packed_scene.instantiate() as CharacterBody3D
 	_expect_true(player != null, "regression player instantiates", failures)
 	if player == null:
 		return
 	root.add_child(player)
 	player.set_physics_process(false)
 	Input.action_press(PlayerInputActions.MOVE_FORWARD)
 	player.call("_physics_process", 1.0)
 	Input.action_release(PlayerInputActions.MOVE_FORWARD)
 	_expect_near(player.position.z, -7.0, "forward action moves current sandbox controller", failures)
 	var camera_rig := player.get_node("CameraPivot") as ThirdPersonCameraRig
 	var camera_distance_before := camera_rig.requested_distance_units
 	var zoom_event := InputEventMouseButton.new()
 	zoom_event.button_index = MOUSE_BUTTON_WHEEL_UP
 	zoom_event.pressed = true
 	player.call("_unhandled_input", zoom_event)
 	_expect_near(camera_rig.requested_distance_units, camera_distance_before - 1.0, "zoom action updates camera distance", failures)
 	var flight_toggle_event := InputEventAction.new()
 	flight_toggle_event.action = PlayerInputActions.DEBUG_TOGGLE_FLIGHT
 	flight_toggle_event.pressed = true
 	player.call("_unhandled_input", flight_toggle_event)
 	var movement_controller: LocalPlayerMovementController = player.get("_local_movement_controller")
 	_expect_true(movement_controller.is_flight_enabled, "flight action preserves immediate sandbox toggle", failures)
 	player.free()
 func _expect_key_binding(
 		action_name: StringName,
 		expected_keycode: Key,
 		uses_physical_keycode: bool,
 		failures: Array[String]
 ) -> void:
 	for input_event in InputMap.action_get_events(action_name):
 		if input_event is InputEventKey:
 			var key_event := input_event as InputEventKey
 			var configured_keycode := key_event.physical_keycode if uses_physical_keycode else key_event.keycode
 			if configured_keycode == expected_keycode:
 				return
 	failures.append("%s missing expected key binding %s" % [action_name, expected_keycode])
 func _expect_mouse_binding(
 		action_name: StringName,
 		expected_button: MouseButton,
 		failures: Array[String]
 ) -> void:
 	for input_event in InputMap.action_get_events(action_name):
 		if input_event is InputEventMouseButton and input_event.button_index == expected_button:
 			return
 	failures.append("%s missing expected mouse binding %s" % [action_name, expected_button])
 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)
@@ -0,0 +1,138 @@
 extends SceneTree
 ## Verifies that the pinned AzerothCore spawn is routed through the coordinate
 ## contract into an executable renderer checkpoint. GUI capture is performed by
 ## capture_render_checkpoints.gd with the validated dedicated manifest.
 const COORDINATE_MAPPER_SCRIPT := preload("res://src/domain/coordinates/coordinate_mapper.gd")
 const SERVER_WORLD_POSITION_SCRIPT := preload("res://src/domain/coordinates/server_world_position.gd")
 const MANIFEST_PATH := "res://src/tools/server_spawn_render_manifest.json"
 const EXPECTED_FIXTURE_PATH := "res://src/tests/fixtures/coordinate_golden_points.json"
 const EXPECTED_SPAWN_NAME := "azerothcore_human_warrior_start"
 const EXPECTED_PROFILE := "Blizzlike335"
 const POSITION_TOLERANCE_YARDS := 0.002
 func _initialize() -> void:
 	var failures: Array[String] = []
 	var manifest := _load_json_object(MANIFEST_PATH, failures)
 	var fixture_path := String(manifest.get("source_fixture", ""))
 	_expect_equal(fixture_path, EXPECTED_FIXTURE_PATH, "source fixture path", failures)
 	var fixture := _load_json_object(fixture_path, failures) if not fixture_path.is_empty() else {}
 	if manifest.is_empty() or fixture.is_empty():
 		_report_and_quit(failures)
 		return
 	_expect_equal(int(manifest.get("schema_version", -1)), 1, "manifest schema version", failures)
 	_expect_equal(String(manifest.get("profile", "")), EXPECTED_PROFILE, "renderer profile", failures)
 	_expect_equal(String(manifest.get("map", "")), "Azeroth", "renderer map", failures)
 	_expect_true(ResourceLoader.exists(String(manifest.get("scene", ""))), "renderer scene exists", failures)
 	_expect_equal(String(manifest.get("source_spawn_name", "")), EXPECTED_SPAWN_NAME, "source spawn name", failures)
 	var spawn := _find_named_dictionary(fixture.get("server_spawns", []), EXPECTED_SPAWN_NAME)
 	_expect_true(not spawn.is_empty(), "pinned server spawn exists", failures)
 	var checkpoints: Array = manifest.get("checkpoints", [])
 	_expect_equal(checkpoints.size(), 1, "renderer checkpoint count", failures)
 	if spawn.is_empty() or checkpoints.size() != 1 or not (checkpoints[0] is Dictionary):
 		_report_and_quit(failures)
 		return
 	var checkpoint: Dictionary = checkpoints[0]
 	var server_values := _three_floats(spawn.get("server_position", null), "server position", failures)
 	if server_values.is_empty():
 		_report_and_quit(failures)
 		return
 	var server_position = SERVER_WORLD_POSITION_SCRIPT.new(server_values[0], server_values[1], server_values[2])
 	var canonical_position = COORDINATE_MAPPER_SCRIPT.server_to_canonical(server_position)
 	var godot_position = COORDINATE_MAPPER_SCRIPT.canonical_to_godot(canonical_position)
 	var tile_coordinate = COORDINATE_MAPPER_SCRIPT.canonical_to_adt_tile(canonical_position)
 	var tile_local_position = COORDINATE_MAPPER_SCRIPT.canonical_to_adt_tile_local(canonical_position)
 	var chunk_coordinate = COORDINATE_MAPPER_SCRIPT.adt_tile_local_to_chunk(tile_coordinate, tile_local_position)
 	var mapped_position := [godot_position.x_units, godot_position.y_units, godot_position.z_units]
 	_expect_equal(String(checkpoint.get("name", "")), EXPECTED_SPAWN_NAME, "checkpoint name", failures)
 	_expect_true("server_spawn" in checkpoint.get("coverage", []), "server-spawn coverage", failures)
 	_expect_true(bool(checkpoint.get("diagnostic_spawn_marker", false)), "diagnostic spawn marker enabled", failures)
 	_expect_three_near(checkpoint.get("target", null), mapped_position, "checkpoint target", failures)
 	_expect_three_near(checkpoint.get("player", null), mapped_position, "checkpoint player", failures)
 	_expect_pair(checkpoint.get("expected_adt_tile", null), [tile_coordinate.tile_x, tile_coordinate.tile_y], "ADT tile", failures)
 	_expect_pair(checkpoint.get("expected_adt_chunk", null), [chunk_coordinate.chunk_x, chunk_coordinate.chunk_y], "ADT chunk", failures)
 	_expect_three_near(spawn.get("expected_godot_position", null), mapped_position, "fixture Godot position", failures)
 	var camera_values := _three_floats(checkpoint.get("camera", null), "checkpoint camera", failures)
 	if not camera_values.is_empty():
 		_expect_true(camera_values[1] > godot_position.y_units, "checkpoint camera is above spawn", failures)
 		_expect_true(Vector3(camera_values[0], camera_values[1], camera_values[2]).distance_to(Vector3(mapped_position[0], mapped_position[1], mapped_position[2])) > 1.0, "checkpoint camera is distinct from spawn", failures)
 	if not failures.is_empty():
 		_report_and_quit(failures)
 		return
 	print("SERVER_SPAWN_RENDERER PASS spawn=1 checkpoint=1 tile=%d_%d chunk=%d_%d profile=%s" % [
 		tile_coordinate.tile_x,
 		tile_coordinate.tile_y,
 		chunk_coordinate.chunk_x,
 		chunk_coordinate.chunk_y,
 		EXPECTED_PROFILE,
 	])
 	quit(0)
 func _find_named_dictionary(entries: Array, expected_name: String) -> Dictionary:
 	for entry_variant in entries:
 		if entry_variant is Dictionary and String(entry_variant.get("name", "")) == expected_name:
 			return entry_variant
 	return {}
 func _load_json_object(path: String, failures: Array[String]) -> Dictionary:
 	var file := FileAccess.open(path, FileAccess.READ)
 	if file == null:
 		failures.append("cannot open JSON: %s" % path)
 		return {}
 	var parsed = JSON.parse_string(file.get_as_text())
 	if not (parsed is Dictionary):
 		failures.append("JSON is not an object: %s" % path)
 		return {}
 	return parsed
 func _three_floats(value_variant, label: String, failures: Array[String]) -> Array[float]:
 	if not (value_variant is Array) or value_variant.size() != 3:
 		failures.append("%s must contain three numbers" % label)
 		return []
 	return [float(value_variant[0]), float(value_variant[1]), float(value_variant[2])]
 func _expect_three_near(actual_variant, expected_values: Array, label: String, failures: Array[String]) -> void:
 	var actual_values := _three_floats(actual_variant, label, failures)
 	if actual_values.is_empty() or expected_values.size() != 3:
 		return
 	for component_index in range(3):
 		if absf(actual_values[component_index] - float(expected_values[component_index])) > POSITION_TOLERANCE_YARDS:
 			failures.append("%s[%d] expected %.9f, got %.9f" % [label, component_index, expected_values[component_index], actual_values[component_index]])
 func _expect_pair(actual_variant, expected_values: Array, label: String, failures: Array[String]) -> void:
 	if not (actual_variant is Array) or actual_variant.size() != 2:
 		failures.append("%s must contain two integers" % label)
 		return
 	for component_index in range(2):
 		_expect_equal(int(actual_variant[component_index]), int(expected_values[component_index]), "%s[%d]" % [label, component_index], failures)
 func _expect_equal(actual_value, expected_value, 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_true(actual_value: bool, label: String, failures: Array[String]) -> void:
 	if not actual_value:
 		failures.append("%s expected true" % label)
 func _report_and_quit(failures: Array[String]) -> void:
 	if failures.is_empty():
 		failures.append("verification stopped without a diagnostic")
 	for failure in failures:
 		push_error("SERVER_SPAWN_RENDERER: %s" % failure)
 	quit(1)
@@ -0,0 +1 @@
 uid://c7f2rpfey0vrs
@@ -0,0 +1,198 @@
 extends SceneTree
 ## Headless M02 contract, interpolation, cache and player-injection regression.
 const TERRAIN_QUERY_PATH := "res://src/gameplay/terrain/terrain_query.gd"
 const ADT_TERRAIN_QUERY_PATH := "res://src/gameplay/terrain/adt_terrain_query.gd"
 const PLAYER_CONTROLLER_PATH := "res://src/scenes/player/third_person_wow_controller.gd"
 const REGRESSION_SCENE_PATH := "res://src/tests/scenes/player_input_regression.tscn"
 var _synthetic_adt_tile_data: Dictionary = {}
 var _synthetic_loader_call_count := 0
 class FlatTerrainQuery extends TerrainQuery:
 	var _height_units: float
 	func _init(height_units: float) -> void:
 		_height_units = height_units
 	func sample_ground_height(_godot_world_position: GodotWorldPosition) -> TerrainGroundSample:
 		return TerrainGroundSample.available(_height_units)
 func _initialize() -> void:
 	_run_verification.call_deferred()
 func _run_verification() -> void:
 	var failures: Array[String] = []
 	_verify_typed_result_contract(failures)
 	_verify_synthetic_adt_interpolation_and_cache(failures)
 	_verify_unavailable_tile(failures)
 	_verify_player_injection(failures)
 	_verify_source_boundaries(failures)
 	if not failures.is_empty():
 		for failure in failures:
 			push_error("TERRAIN_QUERY: %s" % failure)
 		quit(1)
 		return
 	print("TERRAIN_QUERY PASS contract=4 interpolation=1 cache=1 failures=2 player_injection=1")
 	quit(0)
 func _verify_typed_result_contract(failures: Array[String]) -> void:
 	var available_sample := TerrainGroundSample.available(123.5)
 	_expect_true(available_sample.is_available, "available sample state", failures)
 	_expect_near(available_sample.height_units, 123.5, "available sample height", failures)
 	_expect_true(available_sample.failure_code.is_empty(), "available sample has no failure", failures)
 	var unavailable_sample := TerrainGroundSample.unavailable(&"synthetic_failure")
 	_expect_true(not unavailable_sample.is_available, "unavailable sample state", failures)
 	_expect_equal(unavailable_sample.failure_code, &"synthetic_failure", "unavailable failure code", failures)
 	var base_sample := TerrainQuery.new().sample_ground_height(GodotWorldPosition.new(0.0, 0.0, 0.0))
 	_expect_equal(base_sample.failure_code, &"terrain_query_not_implemented", "base query failure", failures)
 	var non_finite_sample := TerrainGroundSample.available(NAN)
 	_expect_true(not non_finite_sample.is_available, "non-finite sample unavailable", failures)
 	_expect_equal(non_finite_sample.failure_code, &"terrain_height_not_finite", "non-finite failure code", failures)
 func _verify_synthetic_adt_interpolation_and_cache(failures: Array[String]) -> void:
 	var query_position := GodotWorldPosition.new(17000.0, 999.0, 26525.0)
 	_synthetic_adt_tile_data = _build_synthetic_adt_tile(query_position)
 	_synthetic_loader_call_count = 0
 	var terrain_query := AdtTerrainQuery.new("res://synthetic", "Azeroth", _load_synthetic_adt_tile)
 	var first_sample := terrain_query.sample_ground_height(query_position)
 	_expect_true(first_sample.is_available, "synthetic ADT sample available", failures)
 	_expect_near_with_tolerance(first_sample.height_units, 137.0, 0.002, "synthetic bilinear height", failures)
 	var second_sample := terrain_query.sample_ground_height(query_position)
 	_expect_near_with_tolerance(second_sample.height_units, 137.0, 0.002, "cached synthetic height", failures)
 	_expect_equal(_synthetic_loader_call_count, 1, "ADT tile loaded once", failures)
 func _verify_unavailable_tile(failures: Array[String]) -> void:
 	var query_position := GodotWorldPosition.new(17000.0, 0.0, 26525.0)
 	var empty_query := AdtTerrainQuery.new("res://synthetic", "Azeroth", func(_path: String) -> Dictionary: return {})
 	var empty_sample := empty_query.sample_ground_height(query_position)
 	_expect_true(not empty_sample.is_available, "empty ADT unavailable", failures)
 	_expect_equal(empty_sample.failure_code, &"adt_tile_unavailable", "empty ADT failure", failures)
 	var invalid_heights_data := _build_synthetic_adt_tile(query_position)
 	var invalid_chunks: Array = invalid_heights_data.get("chunks", [])
 	(invalid_chunks[invalid_chunks.size() - 1] as Dictionary)["heights"] = PackedFloat32Array()
 	var invalid_query := AdtTerrainQuery.new(
 		"res://synthetic",
 		"Azeroth",
 		func(_path: String) -> Dictionary: return invalid_heights_data
 	)
 	var invalid_sample := invalid_query.sample_ground_height(query_position)
 	_expect_equal(invalid_sample.failure_code, &"adt_chunk_heights_invalid", "invalid heights failure", failures)
 func _verify_player_injection(failures: Array[String]) -> void:
 	var packed_scene := load(REGRESSION_SCENE_PATH) as PackedScene
 	_expect_true(packed_scene != null, "regression scene loads", failures)
 	if packed_scene == null:
 		return
 	var player := packed_scene.instantiate() as CharacterBody3D
 	player.set_terrain_query(FlatTerrainQuery.new(20.0))
 	root.add_child(player)
 	player.set_physics_process(false)
 	_expect_near(player.position.y, 20.05, "injected spawn ground height", failures)
 	player.position.y = 30.0
 	player.call("_physics_process", 1.0)
 	_expect_near(player.position.y, 20.05, "injected physics ground snap", failures)
 	player.free()
 func _verify_source_boundaries(failures: Array[String]) -> void:
 	var terrain_contract_source := _read_text(TERRAIN_QUERY_PATH, failures)
 	_expect_true(not terrain_contract_source.contains("extends Node"), "TerrainQuery omits Node", failures)
 	_expect_true(not terrain_contract_source.contains("Vector3"), "TerrainQuery omits untyped Vector3 position", failures)
 	var adt_query_source := _read_text(ADT_TERRAIN_QUERY_PATH, failures)
 	_expect_true(adt_query_source.contains("ADTLoader"), "ADT adapter owns native loader", failures)
 	_expect_true(adt_query_source.contains("_adt_tile_cache"), "ADT adapter owns tile cache", failures)
 	var player_source := _read_text(PLAYER_CONTROLLER_PATH, failures)
 	for forbidden_text in ["ADTLoader", "load_adt", "_adt_cache", "_find_chunk", "_outer_height_index"]:
 		_expect_true(not player_source.contains(forbidden_text), "player omits %s" % forbidden_text, failures)
 	_expect_true(player_source.contains("set_terrain_query"), "player exposes terrain query injection", failures)
 	_expect_true(player_source.contains("_terrain_query.sample_ground_height"), "player delegates ground sampling", failures)
 func _build_synthetic_adt_tile(query_position: GodotWorldPosition) -> Dictionary:
 	var tile_coordinate := CoordinateMapper.godot_to_adt_tile(query_position)
 	var tile_local_position := CoordinateMapper.godot_to_adt_tile_local(query_position)
 	var chunk_coordinate := CoordinateMapper.adt_tile_local_to_chunk(tile_coordinate, tile_local_position)
 	var chunk_size := CoordinateMapper.ADT_CHUNK_SIZE_YARDS
 	var outer_grid_unit_size := chunk_size / 8.0
 	var target_chunk_origin := Vector3(
 		query_position.x_units - outer_grid_unit_size * 4.5,
 		100.0,
 		query_position.z_units - outer_grid_unit_size * 3.25
 	)
 	var tile_origin := target_chunk_origin - Vector3(
 		chunk_coordinate.chunk_x * chunk_size,
 		0.0,
 		chunk_coordinate.chunk_y * chunk_size
 	)
 	var heights := PackedFloat32Array()
 	heights.resize(145)
 	for row in range(9):
 		for column in range(9):
 			heights[row * 17 + column] = float(row * 10 + column)
 	var target_chunk := {"origin": target_chunk_origin, "heights": heights}
 	if chunk_coordinate.chunk_x == 0 and chunk_coordinate.chunk_y == 0:
 		return {"chunks": [target_chunk]}
 	return {
 		"chunks": [
 			{"origin": tile_origin, "heights": PackedFloat32Array()},
 			target_chunk,
 		]
 	}
 func _load_synthetic_adt_tile(_absolute_path: String) -> Dictionary:
 	_synthetic_loader_call_count += 1
 	return _synthetic_adt_tile_data
 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_near_with_tolerance(
 		actual_value: float,
 		expected_value: float,
 		tolerance: float,
 		label: String,
 		failures: Array[String]
 ) -> void:
 	if absf(actual_value - expected_value) > tolerance:
 		failures.append("%s expected %.6f ± %.6f, got %.6f" % [label, expected_value, tolerance, actual_value])
 func _expect_equal(actual_value: Variant, expected_value: Variant, 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_true(actual_value: bool, label: String, failures: Array[String]) -> void:
 	if not actual_value:
 		failures.append("%s expected true" % label)
@@ -0,0 +1,174 @@
 extends SceneTree
 ## Headless M02 camera state, scene wiring and collision-policy regression.
 const PLAYER_CONTROLLER_PATH := "res://src/scenes/player/third_person_wow_controller.gd"
 const CAMERA_RIG_PATH := "res://src/scenes/player/third_person_camera_rig.gd"
 const NO_COLLISION_POLICY_PATH := "res://src/scenes/player/no_camera_collision_policy.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",
 ]
 class FixedDistanceCameraCollisionPolicy extends CameraCollisionPolicy:
 	var _fixed_distance_units: float
 	func _init(fixed_distance_units: float) -> void:
 		_fixed_distance_units = fixed_distance_units
 	func resolve_camera_distance(
 			_camera_pivot: Node3D,
 			_requested_distance_units: float
 	) -> float:
 		return _fixed_distance_units
 func _initialize() -> void:
 	_run_verification.call_deferred()
 func _run_verification() -> void:
 	var failures: Array[String] = []
 	var player := _instantiate_regression_player(failures)
 	if player != null:
 		_verify_initial_state(player, failures)
 		_verify_zoom_clamps(player, failures)
 		_verify_orbit_and_capture(player, failures)
 		_verify_collision_policy(player, failures)
 		player.free()
 	_verify_source_boundaries(failures)
 	_verify_scene_wiring(failures)
 	if not failures.is_empty():
 		for failure in failures:
 			push_error("THIRD_PERSON_CAMERA: %s" % failure)
 		quit(1)
 		return
 	print("THIRD_PERSON_CAMERA PASS state_cases=12 policy_cases=3 scenes=3 player_boundary=1")
 	quit(0)
 func _instantiate_regression_player(failures: Array[String]) -> CharacterBody3D:
 	var packed_scene := load(REGRESSION_SCENE_PATH) as PackedScene
 	_expect_true(packed_scene != null, "regression scene loads", failures)
 	if packed_scene == null:
 		return null
 	var player := packed_scene.instantiate() as CharacterBody3D
 	_expect_true(player != null, "regression player instantiates", failures)
 	if player == null:
 		return null
 	root.add_child(player)
 	player.set_physics_process(false)
 	var camera_rig := player.get_node("CameraPivot") as ThirdPersonCameraRig
 	camera_rig.set_physics_process(false)
 	return player
 func _verify_initial_state(player: CharacterBody3D, failures: Array[String]) -> void:
 	var camera_rig := player.get_node("CameraPivot") as ThirdPersonCameraRig
 	var camera := camera_rig.get_node("Camera3D") as Camera3D
 	_expect_near(camera_rig.yaw_radians, 0.0, "initial yaw", failures)
 	_expect_near(camera_rig.pitch_radians, deg_to_rad(-18.0), "initial pitch", failures)
 	_expect_near(camera_rig.requested_distance_units, 8.0, "initial requested distance", failures)
 	_expect_near(camera_rig.resolved_distance_units, 8.0, "initial resolved distance", failures)
 	_expect_near(camera_rig.position.y, 1.7, "initial pivot height", failures)
 	_expect_near(camera.position.z, 8.0, "initial camera local Z", failures)
 	_expect_near(camera.far, 50000.0, "camera far plane", failures)
 	_expect_true(camera_rig.godot_world_flight_movement_basis().is_equal_approx(camera_rig.global_basis), "flight basis is pivot basis", failures)
 func _verify_zoom_clamps(player: CharacterBody3D, failures: Array[String]) -> void:
 	var camera_rig := player.get_node("CameraPivot") as ThirdPersonCameraRig
 	var zoom_in_event := _action_event(PlayerInputActions.CAMERA_ZOOM_IN, true)
 	for _step in range(20):
 		camera_rig.handle_camera_input(zoom_in_event)
 	_expect_near(camera_rig.requested_distance_units, 2.0, "minimum zoom clamp", failures)
 	for _step in range(30):
 		camera_rig.handle_camera_input(_action_event(PlayerInputActions.CAMERA_ZOOM_OUT, true))
 	_expect_near(camera_rig.requested_distance_units, 18.0, "maximum zoom clamp", failures)
 func _verify_orbit_and_capture(player: CharacterBody3D, failures: Array[String]) -> void:
 	var camera_rig := player.get_node("CameraPivot") as ThirdPersonCameraRig
 	_expect_true(camera_rig.handle_camera_input(_action_event(PlayerInputActions.CAMERA_ROTATE, true)), "capture action consumed", failures)
 	_expect_true(camera_rig.is_mouse_captured, "mouse capture state", failures)
 	var mouse_motion := InputEventMouseMotion.new()
 	mouse_motion.relative = Vector2(100.0, -50.0)
 	_expect_true(camera_rig.handle_camera_input(mouse_motion), "captured mouse motion consumed", failures)
 	_expect_near(camera_rig.yaw_radians, -0.3, "orbit yaw", failures)
 	_expect_near(camera_rig.pitch_radians, deg_to_rad(-18.0) + 0.15, "orbit pitch", failures)
 	_expect_near(player.rotation.y, -0.3, "character follows orbit yaw", failures)
 	var clamp_up_motion := InputEventMouseMotion.new()
 	clamp_up_motion.relative = Vector2(0.0, -100000.0)
 	camera_rig.handle_camera_input(clamp_up_motion)
 	_expect_near(camera_rig.pitch_radians, deg_to_rad(35.0), "maximum pitch clamp", failures)
 	var clamp_down_motion := InputEventMouseMotion.new()
 	clamp_down_motion.relative = Vector2(0.0, 100000.0)
 	camera_rig.handle_camera_input(clamp_down_motion)
 	_expect_near(camera_rig.pitch_radians, deg_to_rad(-65.0), "minimum pitch clamp", failures)
 	camera_rig.handle_camera_input(_action_event(PlayerInputActions.CAMERA_ROTATE, false))
 	_expect_true(not camera_rig.is_mouse_captured, "mouse release state", failures)
 func _verify_collision_policy(player: CharacterBody3D, failures: Array[String]) -> void:
 	var camera_rig := player.get_node("CameraPivot") as ThirdPersonCameraRig
 	var camera := camera_rig.get_node("Camera3D") as Camera3D
 	camera_rig.set_collision_policy(FixedDistanceCameraCollisionPolicy.new(3.0))
 	_expect_near(camera_rig.resolved_distance_units, 3.0, "fixed policy distance", failures)
 	_expect_near(camera.position.z, 3.0, "fixed policy camera transform", failures)
 	camera_rig.set_collision_policy(NoCameraCollisionPolicy.new())
 	_expect_near(camera_rig.resolved_distance_units, 18.0, "identity policy restores request", failures)
 func _verify_source_boundaries(failures: Array[String]) -> void:
 	var player_source := _read_text(PLAYER_CONTROLLER_PATH, failures)
 	for forbidden_text in ["var _captured", "var _yaw", "var _pitch", "func _apply_camera_transform", "camera_distance"]:
 		_expect_true(not player_source.contains(forbidden_text), "player omits %s" % forbidden_text, failures)
 	_expect_true(player_source.contains("_camera_rig.handle_camera_input"), "player delegates camera input", failures)
 	var rig_source := _read_text(CAMERA_RIG_PATH, failures)
 	_expect_true(rig_source.contains("extends Node3D"), "camera rig owns pivot Node3D", failures)
 	for forbidden_text in ["ADTLoader", "TerrainQuery", "MoveIntent", "AnimationPlayer"]:
 		_expect_true(not rig_source.contains(forbidden_text), "camera rig omits %s" % forbidden_text, failures)
 	var no_collision_source := _read_text(NO_COLLISION_POLICY_PATH, failures)
 	for forbidden_text in ["intersect_ray", "direct_space_state", "PhysicsRayQueryParameters3D"]:
 		_expect_true(not no_collision_source.contains(forbidden_text), "baseline policy 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("third_person_camera_rig.gd"), "%s references camera rig" % scene_path, failures)
 		_expect_true(scene_source.contains('script = ExtResource("4_camera_rig")') or scene_source.contains('script = ExtResource("2_camera_rig")'), "%s wires CameraPivot script" % scene_path, failures)
 func _action_event(action_name: StringName, is_pressed: bool) -> InputEventAction:
 	var input_event := InputEventAction.new()
 	input_event.action = action_name
 	input_event.pressed = is_pressed
 	return input_event
 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)
@@ -1,6 +1,7 @@
 # M01 — Coordinates and Architecture Seams
-<!-- OPENWC_TARGET:ACTIVE -->
+<!-- OPENWC_TARGET:DONE -->
 <!-- OPENWC_TARGET_DONE:M01:work/sindo-main-codex/m01-integrator-closeout:2026-07-14 -->
 ## Outcome
@@ -8,13 +9,13 @@
 ## Steps
- [ ] Создать domain/value-object слой без `Node`/`Resource` dependencies.
+- [x] Создать domain/value-object слой без `Node`/`Resource` dependencies.
- [ ] Определить canonical WoW, Godot, ADT tile/chunk и local coordinate types.
+- [x] Определить canonical WoW, Godot, ADT tile/chunk и local coordinate types.
- [ ] Реализовать единственный `CoordinateMapper` для position и orientation.
+- [x] Реализовать единственный `CoordinateMapper` для position и orientation.
- [ ] Собрать golden points из ADT, server spawn и оригинального клиента.
+- [x] Собрать golden points из ADT, server spawn и оригинального клиента.
- [ ] Ввести `StreamingFocus` вместо неявной зависимости от active Camera3D.
+- [x] Ввести `StreamingFocus` вместо неявной зависимости от active Camera3D.
- [ ] Ввести stable `ContentId`, `EntityId` и отличить их от WoW GUID/server entry.
+- [x] Ввести stable `ContentId`, `EntityId` и отличить их от WoW GUID/server entry.
- [ ] Запретить ручные axis conversion через code review rule/test search.
+- [x] Запретить ручные axis conversion через code review rule/test search.
 ## Verification
@@ -28,10 +29,35 @@ Renderer/test scene получают focus через контракт; коор
 ## Evidence
- Date:
+- Date: 2026-07-14
- Revision/worktree:
+- Revision/worktree: merged master `c8e99f2`; closeout
- Commands:
+  `work/sindo-main-codex/m01-integrator-closeout`
- Results:
+- Commands: `tools/run_render_baseline.ps1 -DryRun -WaitSeconds 0.1
- Fidelity comparison:
+  -MeasureSeconds 0.1`; `verify_coordinate_mapper.gd`;
- Changed files:
+  `verify_coordinate_golden_fixtures.gd`; `verify_streaming_focus.gd`;
- Remaining risks:
+  `verify_domain_identities.gd`; coordination/documentation/diff gates.
 - Results: CoordinateMapper PASS (`5` golden points, `8` tile boundaries,
  `2` raw MCNK, `5` yaw); golden fixtures PASS (`1` server spawn, `1` raw ADT,
  `5` original-client points); StreamingFocus PASS (`1` contract, `2` runtime
  scenes, `3` capture tools); identities PASS (`5/5/6/5`); conversion boundary
  PASS (`84` files, one native boundary, one oracle, four consumers, six
  classifiers); server-spawn renderer PASS at ADT `(32,48)`, MCNK `(3,12)`;
  renderer manifest PASS (`7/7/7`) and calibration maximum error `0.000015`.
 - Fidelity comparison: five build-12340 camera observations, pinned AzerothCore
  Human Warrior spawn and private raw ADT metadata agree through coordinate
  contract version 2. Cache-complete cold/warm GUI capture places the mapped
  spawn marker on rendered Northshire terrain with focus `(32,48)`, quality
  `100/100`, missing cache `0`; PNG SHA-256 values are recorded in the server
  spawn handoff. The final ADT-boundary regression passed `2/2`; the full M01
  regression captured `14/14`, with `11` strict passes and three low-mean
  timing/animation-phase differences rather than coordinate drift.
 - Changed files: `src/domain/coordinates/`, `src/domain/identity/`,
  `src/domain/streaming/`, migrated sky/player/streaming/terrain consumers,
  coordinate/renderer fixtures and tools, runtime scenes, ADR 0001/0002,
  coordinate/domain/renderer module specs, coding/render documentation and
  M01 coordination claims.
 - Remaining risks: TrinityCore populated spawn equivalence is not verified;
  native parser conversion remains one separately calibrated boundary; MDDF/
  MODF placement Euler parity is outside world-yaw scope; renderer visual parity
  gaps and the known anonymous ObjectDB teardown warning continue. No `1:1`
  compatibility claim is made by M01.
@@ -1,6 +1,6 @@
 # M02 — Player Decomposition
-<!-- OPENWC_TARGET:OPEN -->
+<!-- OPENWC_TARGET:ACTIVE -->
 ## Outcome
@@ -21,7 +21,7 @@ OpenWC должен предоставить четыре согласованн
 - MPQ/BLP/ADT/WDT/M2/WMO native parsing и renderer vertical slice уже существуют.
 - Runtime streaming, terrain quality, MultiMesh M2, WMO caches, liquids, sky и character experiments находятся в рабочем состоянии, но сосредоточены в крупных orchestration scripts.
- Renderer baseline M00 завершён: paired comparison с оригинальным клиентом записывает измеренные gaps без заявления parity, а обязательные diagnostic gaps закрыты или явно классифицированы. Текущая работа M01 вводит coordinate и architecture seams.
+- Renderer baseline M00 завершён: paired comparison с оригинальным клиентом записывает измеренные gaps без заявления parity, а обязательные diagnostic gaps закрыты или явно классифицированы. M01 завершил coordinate, identity и streaming-focus seams; текущая работа M02 декомпозирует player input, movement, terrain query, camera и presentation без observable regression.
 - Gameplay domain, network protocol, production UI/Lua, audio orchestration и server adapters в основном предстоит реализовать.
 - Editor plugin пока решает extraction/preview задачи, но не является полноценной authoring platform.
@@ -10,7 +10,7 @@
 ## Current target
-`M01` — [01-coordinates-and-seams.md](01-coordinates-and-seams.md)
+`M02` — [02-player-decomposition.md](02-player-decomposition.md)
 Одновременно `ACTIVE` может быть только одна цель. Следующая цель становится `ACTIVE` после появления валидной `OPENWC_TARGET_DONE` метки у предыдущей.
@@ -34,8 +34,8 @@
 | ID | Цель | Зависит от | Статус |
 |---|---|---|---|
 | M00 | [Renderer baseline](00-render-baseline.md) | — | DONE |
-| M01 | [Coordinates and architecture seams](01-coordinates-and-seams.md) | M00 | ACTIVE |
+| M01 | [Coordinates and architecture seams](01-coordinates-and-seams.md) | M00 | DONE |
-| M02 | [Player decomposition](02-player-decomposition.md) | M01 | OPEN |
+| M02 | [Player decomposition](02-player-decomposition.md) | M01 | ACTIVE |
 | M03 | [Renderer facade and extraction](03-renderer-facade.md) | M02 | OPEN |
 | M04 | [Godot Editor shell](04-editor-shell.md) | M03 | OPEN |
 | M05 | [Content Project](05-content-project.md) | M04 | OPEN |
@@ -58,6 +58,7 @@ try {
    Invoke-GodotStep "baseline-manifest" @("--headless", "--path", ".", "--script", "res://src/tools/verify_render_baseline_manifest.gd")
    Invoke-GodotStep "coordinate-calibration" @("--headless", "--path", ".", "--script", "res://src/tools/verify_render_coordinate_calibration.gd")
    Invoke-GodotStep "coordinate-boundaries" @("--headless", "--path", ".", "--script", "res://src/tools/verify_coordinate_conversion_boundaries.gd")
    Invoke-GodotStep "server-spawn-renderer" @("--headless", "--path", ".", "--script", "res://src/tools/verify_server_spawn_renderer.gd")
    $captureArgs = @(
        "--path", ".",
Author	SHA1	Message	Date
sindoring	02dec23c2a	docs(M02): publish camera rig handoff Work-Package: M02-RND-CAMERA-001	2026-07-14 23:27:41 +04:00
sindoring	8c1cf9be36	rnd(M02): extract third-person camera rig Work-Package: M02-RND-CAMERA-001	2026-07-14 23:27:03 +04:00
sindoring	f5bb64e6c7	Merge pull request 'gmp(M02): extract player terrain query' (#23 ) from work/sindo-main-codex/m02-terrain-query into master Reviewed-on: #23	2026-07-14 22:17:12 +03:00
sindoring	0ce3cae208	docs(M02): publish terrain query handoff Work-Package: M02-GMP-TERRAIN-QUERY-001 Agent: sindo-main-codex Tests: coordination and documentation gates; diff check Fidelity: documents inherited height/snap regression and remaining collision evidence gap	2026-07-14 23:11:23 +04:00
sindoring	a45d521567	gmp(M02): extract player terrain query Work-Package: M02-GMP-TERRAIN-QUERY-001 Agent: sindo-main-codex Tests: terrain query, player input and movement regressions; asset-free scene; renderer dry-run; coordinate, streaming, documentation and coordination gates Fidelity: preserves existing ADT outer-grid interpolation and player ground snap; build-12340 collision parity remains unverified	2026-07-14 23:10:55 +04:00
sindoring	5206c42cf0	Merge pull request 'gmp(M02): extract local player movement' (#22 ) from work/sindo-main-codex/m02-local-movement into master Reviewed-on: #22	2026-07-14 22:01:21 +03:00
sindoring	d2d6df3655	docs(M02): publish local movement handoff Work-Package: M02-GMP-MOVEMENT-001 Agent: sindo-main-codex Tests: coordination and documentation gates; diff check Fidelity: documents preserved sandbox behavior and remaining build-12340 evidence gap	2026-07-14 22:59:59 +04:00
sindoring	435e1c95d2	gmp(M02): extract local player movement Work-Package: M02-GMP-MOVEMENT-001 Agent: sindo-main-codex Tests: local movement and player input regressions; asset-free scene; renderer dry-run; coordinate, streaming, documentation and coordination gates Fidelity: preserves current sandbox speed, acceleration, sprint and camera-relative flight behavior; build-12340 parity remains unverified	2026-07-14 22:59:33 +04:00
sindoring	14dead194b	Merge pull request 'gmp(M02): add player input intent seam' (#21 ) from work/sindo-main-codex/m02-player-input into master Reviewed-on: #21	2026-07-14 21:52:26 +03:00
sindoring	e794764269	docs(M02): publish player input handoff Work-Package: M02-GMP-INPUT-001 Agent: sindo-main-codex Tests: coordination and documentation gates; diff check Fidelity: documents regression evidence and unverified build-12340 semantics	2026-07-14 22:45:14 +04:00
sindoring	6bd2e84048	gmp(M02): add player input intent seam Work-Package: M02-GMP-INPUT-001 Agent: sindo-main-codex Tests: verify_player_input; renderer baseline dry-run; coordinate, streaming, documentation and coordination gates Fidelity: preserves current sandbox bindings and movement/camera behavior; exact build-12340 semantics remain unverified	2026-07-14 22:44:44 +04:00
sindoring	62eece991c	Merge pull request 'docs(M01): claim milestone closeout' (#20 ) from work/sindo-main-codex/m01-integrator-closeout into master Reviewed-on: #20	2026-07-14 12:55:09 +03:00
sindoring	fc81059dfa	docs(M01): mark milestone closeout ready Work-Package: M01-QAR-INTEGRATOR-CLOSEOUT-001 Agent: sindo-main-codex	2026-07-14 12:14:39 +04:00
sindoring	dd412e6d0d	test(M01): close coordinates and seams milestone Work-Package: M01-QAR-INTEGRATOR-CLOSEOUT-001 Agent: sindo-main-codex Tests: all M01 domain gates, unified renderer dry-run, coordination and documentation gates Fidelity: five build-12340 points, raw ADT and mapped AzerothCore spawn evidence; no 1:1 claim	2026-07-14 12:13:43 +04:00
sindoring	07f08044f4	docs(M01): claim milestone closeout Work-Package: M01-QAR-INTEGRATOR-CLOSEOUT-001 Agent: sindo-main-codex	2026-07-14 12:01:49 +04:00
sindoring	c8e99f28d6	Merge pull request 'chore(M01): remove local spawn capture logs' (#19 ) from work/sindo-main-codex/m01-server-spawn-renderer into master Reviewed-on: #19	2026-07-14 10:58:37 +03:00
sindoring	48cc976ba0	docs(M01): mark server spawn renderer ready Work-Package: M01-QAR-SERVER-SPAWN-RENDERER-001 Agent: sindo-main-codex Tests: server spawn GUI cold/warm, unified renderer dry-run, domain and documentation gates	2026-07-14 11:56:39 +04:00
sindoring	318e6ae757	chore(M01): remove local spawn capture logs Work-Package: M01-QAR-SERVER-SPAWN-RENDERER-001 Agent: sindo-main-codex Tests: renderer dry-run, coordinate/domain gates, GUI cold/warm inspection	2026-07-14 11:55:05 +04:00
sindoring	747fae8e2e	Merge pull request 'координаты' (#18 ) from work/sindo-main-codex/m01-server-spawn-renderer into master Reviewed-on: #18	2026-07-14 10:48:53 +03:00
sindoring	24ddc99a7b	координаты	2026-07-14 11:48:14 +04:00
sindoring	52b6fa2ebb	Merge pull request 'docs(M01): claim server spawn renderer evidence' (#17 ) from work/sindo-main-codex/m01-server-spawn-renderer into master Reviewed-on: #17	2026-07-14 10:42:14 +03:00
sindoring	3933dbfc47	docs(M01): claim server spawn renderer evidence Work-Package: M01-QAR-SERVER-SPAWN-RENDERER-001 Agent: sindo-main-codex	2026-07-13 17:41:02 +04:00