docs(M01): mark milestone closeout ready

Work-Package: M01-QAR-INTEGRATOR-CLOSEOUT-001

Agent: sindo-main-codex

.gitignore

@@ -35,3 +35,7 @@
 
 # CMake build директория
 /src/native/build/
+
+# Local root-level diagnostic capture logs
+/*.stdout.log
+/*.stderr.log

RENDER.md

@@ -822,6 +822,57 @@ $exe = Join-Path $env:TEMP 'godot-4.6.1-openwc\Godot_v4.6.1-stable_win64.exe'
 - Added `src/tools/capture_render_checkpoints.gd` to load the Eastern Kingdoms streaming scene, move a dedicated camera to fixed regression viewpoints and save PNGs under `user://render_checkpoints`.
 - Current checkpoints cover the Elwynn waterfall from front/side and Goldshire Inn/Blacksmith windows. Headless runs are dry-run only because the headless display server cannot produce viewport PNGs.
 
+## 2026-07-13 Renderer Shutdown Ownership
+
+- `StreamingWorldLoader` drains its asynchronous work before teardown, leaves parented streamed nodes to SceneTree ownership, then explicitly frees detached M2/WMO prototype nodes and clears resource caches.
+- `ADTBuilder` explicitly frees a temporary `Water` root when an ADT liquid payload produces no child geometry. Dry tiles must not leave empty nodes in ObjectDB.
+- `src/tools/verify_render_runtime_cache_shutdown.gd` regression-checks detached prototype and resource-cache release plus empty-liquid-root ownership. The unified render-baseline runner executes it before capture.
+- A focused 8-second GUI checkpoint and a seven-checkpoint single-pass GUI run finish without Node, renderer resource or RID leak diagnostics. A timing-dependent anonymous zero-reference `RefCounted` ObjectDB warning can remain at engine teardown; it is tracked separately and is not suppressed.
+- This is shutdown-only ownership behavior and does not alter checkpoint rendering, cache formats or the `Blizzlike335` compatibility profile.
+
+## 2026-07-13 Explicit Streaming Focus
+
+- `StreamingWorldLoader` consumes an immutable `StreamingFocus` containing a
+  typed `GodotWorldPosition`; runtime streaming no longer discovers the active
+  `Camera3D` from the viewport or child nodes.
+- Eastern Kingdoms and Kalimdor runtime scenes explicitly use the player as the
+  streaming source. Checkpoint capture and terrain/occluder probes explicitly
+  use their dedicated camera through the same public refresh path.
+- The editor viewport camera remains behind a dedicated editor-only adapter.
+  `camera_path` is retained solely for optional automatic overview positioning.
+- Streaming radii, LOD decisions, cache formats and renderer quality profiles
+  are unchanged by this migration.
+
+## 2026-07-13 Coordinate Conversion Boundary Gate
+
+- Sky/area lookup, streaming tile ownership, player spawn/terrain sampling and
+  terrain diagnostics now cross world-coordinate spaces through typed
+  `CoordinateMapper` methods.
+- Renderer distance, LOD, ray and model-local M2/WMO calculations remain in
+  their existing Godot/local spaces; they are not axis conversions.
+- The repository gate rejects new manual world-center, WoW/Godot and
+  Godot-position-to-ADT formulas. The unified renderer baseline runs this gate.
+- Native ADT/WDT parsers keep one shared world conversion in
+  `wow_chunk_reader.h`; the independent M00 calibration formula remains a test oracle.
+- 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.

addons/mpq_extractor/loaders/adt_builder.gd

@@ -788,7 +788,10 @@ static func _build_tile_water_root(data: Dictionary, origin_offset: Vector3) ->
 		mi.cast_shadow = GeometryInstance3D.SHADOW_CASTING_SETTING_OFF
 		root.add_child(mi)
 
-	return root if root.get_child_count() > 0 else null
+	if root.get_child_count() > 0:
+		return root
+	root.free()
+	return null
 
 
 static func _append_liquid_geometry(

coordination/claims/M00-QAR-ANIMATION-SKY-EVIDENCE-001.md

@@ -0,0 +1,79 @@
+# M00-QAR-ANIMATION-SKY-EVIDENCE-001 — Animation and sky evidence
+
+<!-- OPENWC_CLAIM:M00-QAR-ANIMATION-SKY-EVIDENCE-001:sindo-main-codex:2026-07-15 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M00-QAR-ANIMATION-SKY-EVIDENCE-001:d1df794 -->
+
+## Ownership
+
+- Target: M00
+- Program: QAR
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m00-animation-sky-evidence`
+- Lease expires UTC: 2026-07-15
+- Integrator: milestone integrator
+
+## Outcome
+
+Add private build 12340 evidence for the remaining sky-transition and native animated-M2 coverage, rerun all paired comparisons, and hand the resulting audit to the milestone integrator.
+
+## Non-goals
+
+- Committing proprietary screenshots or extracted assets.
+- Claiming renderer parity from mismatched world placement or animation phase.
+- Marking M00 DONE; only the milestone integrator may change target status or Evidence.
+
+## Paths
+
+- Exclusive: this claim and animation/sky evidence documentation
+- Shared/hotspots: `docs/M00_FINAL_PAIRED_EVIDENCE.md`, `docs/modules/world-renderer.md`
+- Generated/ignored: normalized private references under `sources/OpenWCReferenceCheckpoints`; captures and reports under `user://`
+
+## Contracts and data
+
+- Public API/events: unchanged
+- Schema/format version: unchanged
+- Migration/compatibility: existing five-reference comparison remains valid
+- Consumers: M00 milestone integrator
+
+## Dependencies
+
+- Requires: user-captured build 12340 screenshots at 19:00 and two real `GryphonRoost01` animation phases
+- Blocks: final integrator decision on M00 completion
+- External state: private screenshots remain outside Git
+
+## Verification
+
+- Commands: private-reference preparation, full baseline runner, comparator self-test, coordination and documentation gates
+- Fixtures: seven private build 12340 checkpoint references plus a second animation-phase provenance frame
+- Fidelity evidence: sky-transition screenshot and observed wing pose change over three seconds
+- Performance budget: existing M00 capture budgets
+
+## Documentation deliverables
+
+- Inline public API docs: unchanged
+- Module specification: paired coverage and remaining limitations
+- Data-flow diagram: unchanged
+- Sequence/state/dependency diagrams: unchanged
+- Source map/status updates: final paired evidence audit
+
+## Simplicity and naming
+
+- Important names introduced: none
+- Simplest considered solution: normalize private captures outside Git and reuse the existing comparator
+- Rejected complexity/abstractions: adding a video comparator or committing an asset corpus
+- Unavoidable complexity and justification: animation phase and synthetic placement require human evidence classification alongside pixel metrics
+- Measured optimization evidence: not applicable
+
+## Status
+
+- State: ready-for-review
+- Done: exact-size private references registered; real ADT placement verified; canonical and visual captures completed; fourteen comparisons audited
+- Next: milestone integrator reviews synthetic/real placement classification and GUI RID risk
+- Blocked by:
+
+## Handoff
+
+- Commit: this work-package commit
+- Results: `compared=14`, `failed=14`, `missing=0`; mean error `0.066893..0.176955`; original-client Gryphon wing phase changed over three seconds
+- Remaining risks: synthetic probe placement differs from the original-client world placement; GUI RID/resource diagnostics remain separate
+- Documentation updated: `docs/M00_FINAL_PAIRED_EVIDENCE.md`, `docs/modules/world-renderer.md`

coordination/claims/M00-QAR-CAMERA-FRAMING-REFINEMENT-001.md

@@ -0,0 +1,79 @@
+# M00-QAR-CAMERA-FRAMING-REFINEMENT-001 — Goldshire pitch/FOV refinement
+
+<!-- OPENWC_CLAIM:M00-QAR-CAMERA-FRAMING-REFINEMENT-001:sindo-main-codex:2026-07-14 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M00-QAR-CAMERA-FRAMING-REFINEMENT-001:3172f41 -->
+
+## Ownership
+
+- Target: M00
+- Program: QAR
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m00-camera-framing-refinement`
+- Lease expires UTC: 2026-07-14
+- Integrator: milestone integrator
+
+## Outcome
+
+Jointly refine Goldshire checkpoint pitch and FOV against a WMO-ready build 12340 reference.
+
+## Non-goals
+
+- Changing runtime player camera defaults.
+- Changing manifest values without an interior optimum and human approval.
+- Optimizing yaw beyond the ready-scene coarse result.
+
+## Paths
+
+- Exclusive: joint FOV option in camera-pose sweep and framing evidence
+- Shared/hotspots: camera-pose operational documentation and renderer module findings
+- Generated/ignored: candidate PNGs and ranking JSON under `user://`
+
+## Contracts and data
+
+- Public API/events: additive `-CameraFovValues`; scalar `-CameraFov` remains compatible
+- Schema/format version: ranking schema remains version 1 with existing per-candidate FOV field
+- Migration/compatibility: scalar sweeps retain existing candidate paths
+- Consumers: M00 fidelity workflow
+
+## Dependencies
+
+- Requires: WMO-ready 8-second capture contract
+- Blocks: Goldshire manifest framing decision
+- External state: private build 12340 reference remains outside Git
+
+## Verification
+
+- Commands: joint-grid plan regression, real ready-scene sweep, comparator self-test, repository gates
+- Fixtures: private Goldshire Inn reference
+- Fidelity evidence: joint pitch/FOV ranking and human inspection
+- Performance budget: offline diagnostic
+
+## Documentation deliverables
+
+- Inline public API docs: PowerShell parameter
+- Module specification: framing finding
+- Data-flow diagram: FOV joins pose grid
+- Sequence/state/dependency diagrams: unchanged
+- Source map/status updates: operational guide
+
+## Simplicity and naming
+
+- Important names introduced: `CameraFovValues`, `effectiveCameraFovValues`
+- Simplest considered solution: one additional loop around the existing grid
+- Rejected complexity/abstractions: generic optimizer
+- Unavoidable complexity and justification: projection and pitch jointly affect framing
+- Measured optimization evidence: bounded 1x5x3 grid
+
+## Status
+
+- State: ready-for-review
+- Done: additive joint FOV grid, compatibility-preserving paths, plan regression, ready-scene 15-candidate ranking and human inspection
+- Next: add approved landmark/region scoring before any manifest camera calibration
+- Blocked by:
+
+## Handoff
+
+- Commit: this work-package commit
+- Results: numeric best FOV 62/yaw 10/pitch -25 at mean 0.078843 and ratio 0.667721 was visually rejected as grass-dominated; FOV 38/yaw 10/pitch -10 better matched building scale at mean 0.084220
+- Remaining risks: full-frame metric does not preserve landmark framing; no manifest values were changed
+- Documentation updated: `docs/CAMERA_POSE_SWEEP.md`, `docs/modules/world-renderer.md`

coordination/claims/M00-QAR-CAMERA-OCCLUDERS-001.md

@@ -1,6 +1,7 @@
 # M00-QAR-CAMERA-OCCLUDERS-001 — Camera occluder diagnostic
 
 <!-- OPENWC_CLAIM:M00-QAR-CAMERA-OCCLUDERS-001:sindo-main-codex:2026-07-13 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M00-QAR-CAMERA-OCCLUDERS-001:9d34a47 -->
 
 ## Ownership
 

coordination/claims/M00-QAR-CAMERA-POSE-EVIDENCE-001.md

@@ -0,0 +1,79 @@
+# M00-QAR-CAMERA-POSE-EVIDENCE-001 — Goldshire camera pose evidence
+
+<!-- OPENWC_CLAIM:M00-QAR-CAMERA-POSE-EVIDENCE-001:sindo-main-codex:2026-07-14 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M00-QAR-CAMERA-POSE-EVIDENCE-001:eca76c5 -->
+
+## Ownership
+
+- Target: M00
+- Program: QAR
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m00-camera-pose-evidence`
+- Lease expires UTC: 2026-07-14
+- Integrator: milestone integrator
+
+## Outcome
+
+Produce coarse-to-fine yaw/pitch evidence for the build 12340 Goldshire Inn reference and classify whether framing dominates the paired-image gap.
+
+## Non-goals
+
+- Changing manifest camera defaults before human approval.
+- Treating minimum perceptual error as proof of exact camera parity.
+- Committing proprietary reference images or generated candidates.
+
+## Paths
+
+- Exclusive: camera-pose evidence record
+- Shared/hotspots: renderer baseline and module fidelity findings
+- Generated/ignored: all sweep PNGs and JSON under `user://`
+
+## Contracts and data
+
+- Public API/events: none
+- Schema/format version: unchanged
+- Migration/compatibility: none
+- Consumers: M00 fidelity review
+
+## Dependencies
+
+- Requires: merged camera-pose sweep and local build 12340 reference
+- Blocks: classification of the Goldshire WMO paired gap
+- External state: `sources/OpenWCReferenceCheckpoints/goldshire_inn_large_wmo.jpg`
+
+## Verification
+
+- Commands: coarse and fine real sweeps, ranking inspection, repository gates
+- Fixtures: private Goldshire Inn build 12340 screenshot
+- Fidelity evidence: ranked mean perceptual error and changed-pixel ratio
+- Performance budget: offline diagnostic only
+
+## Documentation deliverables
+
+- Inline public API docs: unchanged
+- Module specification: fidelity finding and remaining risk
+- Data-flow diagram: unchanged
+- Sequence/state/dependency diagrams: unchanged
+- Source map/status updates: baseline evidence
+
+## Simplicity and naming
+
+- Important names introduced: none
+- Simplest considered solution: use the merged bounded grid runner
+- Rejected complexity/abstractions: optimizer or renderer changes
+- Unavoidable complexity and justification: real images must be rendered for each candidate
+- Measured optimization evidence: single pass per candidate
+
+## Status
+
+- State: ready-for-review
+- Done: private reference dimensions verified; coarse, extended and limit sweeps completed; representative candidates inspected; runner failure handling hardened
+- Next: investigate Goldshire Inn spatial/placement composition separately; do not change manifest yaw/pitch from this metric
+- Blocked by:
+
+## Handoff
+
+- Commit: this work-package commit
+- Results: zero offset mean error 0.099632; coarse best (-10,-20) 0.077575; metric decreased monotonically to (0,-60) 0.063574/changed ratio 0.549556, while visual inspection showed only grass and no inn
+- Remaining risks: full-frame color error cannot register a missing landmark; WMO placement/streaming at this checkpoint remains unresolved
+- Documentation updated: `docs/CAMERA_POSE_SWEEP.md`, `docs/modules/world-renderer.md`

coordination/claims/M00-QAR-CAMERA-POSE-SWEEP-001.md

@@ -0,0 +1,79 @@
+# M00-QAR-CAMERA-POSE-SWEEP-001 — Empirical camera pose sweep
+
+<!-- OPENWC_CLAIM:M00-QAR-CAMERA-POSE-SWEEP-001:sindo-main-codex:2026-07-14 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M00-QAR-CAMERA-POSE-SWEEP-001:657a1d8 -->
+
+## Ownership
+
+- Target: M00
+- Program: QAR
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m00-camera-pose-sweep`
+- Lease expires UTC: 2026-07-14
+- Integrator: milestone integrator
+
+## Outcome
+
+Recover reproducible checkpoint framing by sweeping bounded yaw/pitch offsets and ranking paired-image error.
+
+## Non-goals
+
+- Changing runtime player camera defaults.
+- Claiming an exact original-client camera pose from perceptual score alone.
+- Adding computer-vision registration or image warping.
+
+## Paths
+
+- Exclusive: camera-pose CLI and sweep orchestration
+- Shared/hotspots: renderer baseline documentation
+- Generated/ignored: local candidate PNGs and JSON reports
+
+## Contracts and data
+
+- Public API/events: additive camera yaw/pitch offset and single-pass capture options; new PowerShell sweep command
+- Schema/format version: capture report schema remains version 1 with additive camera-offset fields
+- Migration/compatibility: existing capture commands retain zero offsets and two passes
+- Consumers: M00 paired-fidelity workflow
+
+## Dependencies
+
+- Requires: build 12340 reference image, capture tool, paired-image comparator
+- Blocks: reproducible manual-reference framing
+- External state: original screenshots remain outside Git
+
+## Verification
+
+- Commands: capture dry-run offset regression, comparator self-test, bounded local sweep when a display/reference is available, repository gates
+- Fixtures: one named M00 checkpoint
+- Fidelity evidence: ranked yaw/pitch candidates with explicit human-approval requirement
+- Performance budget: offline diagnostic; single-pass mode avoids redundant warm capture
+
+## Documentation deliverables
+
+- Inline public API docs: capture and sweep usage
+- Module specification: camera-pose data flow, verification and source map
+- Data-flow diagram: updated pose-sweep flow
+- Sequence/state/dependency diagrams: unchanged
+- Source map/status updates: baseline workflow and findings
+
+## Simplicity and naming
+
+- Important names introduced: `camera_yaw_offset_degrees`, `camera_pitch_offset_degrees`, `single_pass`
+- Simplest considered solution: bounded grid over existing capture/comparator tools
+- Rejected complexity/abstractions: feature matching, optimizer framework, image transforms
+- Unavoidable complexity and justification: original-client camera angles are not exposed by tested APIs
+- Measured optimization evidence: single-pass mode halves captures per candidate
+
+## Status
+
+- State: ready-for-review
+- Done: additive capture offsets, single-pass calibration mode, bounded grid runner, ranked JSON contract, grid-plan regression and documentation
+- Next: run a coarse-to-fine real sweep with the private build 12340 reference directory, then obtain human framing approval
+- Blocked by:
+
+## Handoff
+
+- Commit: this work-package commit
+- Results: dry-run reported yaw 12.50/pitch -7.50; comparator self-test passed; a 3x2 plan produced six unique candidates; full seven-checkpoint M00 dry-run passed with default zero offsets
+- Remaining risks: no private reference directory was available in this worktree, so real perceptual ranking and human approval remain external evidence
+- Documentation updated: `docs/CAMERA_POSE_SWEEP.md`; renderer module verification, risk and source map

coordination/claims/M00-QAR-CAPTURE-SHUTDOWN-001.md

@@ -0,0 +1,79 @@
+# M00-QAR-CAPTURE-SHUTDOWN-001 — Capture shutdown drain
+
+<!-- OPENWC_CLAIM:M00-QAR-CAPTURE-SHUTDOWN-001:sindo-main-codex:2026-07-14 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M00-QAR-CAPTURE-SHUTDOWN-001:8d4641a -->
+
+## Ownership
+
+- Target: M00
+- Program: QAR
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m00-capture-shutdown`
+- Lease expires UTC: 2026-07-14
+- Integrator: milestone integrator
+
+## Outcome
+
+Eliminate the reproducible capture-tool ObjectDB leak by completing owned threaded resource requests and draining deferred scene deletion before process exit.
+
+## Non-goals
+
+- Refactoring renderer resource ownership.
+- Hiding genuine RID or worker-task leaks.
+- Changing capture images, metrics, or streaming behavior.
+
+## Paths
+
+- Exclusive: capture tool shutdown sequence
+- Shared/hotspots: renderer baseline documentation
+- Generated/ignored: verbose Godot logs
+
+## Contracts and data
+
+- Public API/events: none
+- Schema/format version: unchanged
+- Migration/compatibility: none
+- Consumers: M00 baseline runner
+
+## Dependencies
+
+- Requires: reproducible verbose leak diagnostic
+- Blocks: clean M00 capture shutdown evidence
+- External state: none
+
+## Verification
+
+- Commands: identical verbose dry-run before/after, M00 dry-run, repository gates
+- Fixtures: ADT-boundary filtered capture
+- Fidelity evidence: no visual behavior change
+- Performance budget: blocking resource completion is restricted to shutdown; two SceneTree drain frames only
+
+## Documentation deliverables
+
+- Inline public API docs: shutdown rationale comment
+- Module specification: recovery/known-risk update
+- Data-flow diagram: unchanged
+- Sequence/state/dependency diagrams: shutdown sequence documented in baseline
+- Source map/status updates: baseline evidence
+
+## Simplicity and naming
+
+- Important names introduced: none
+- Simplest considered solution: await two SceneTree frames after `queue_free` and finish registered in-flight ResourceLoader requests during loader shutdown
+- Rejected complexity/abstractions: resource registry or manual child traversal
+- Unavoidable complexity and justification: deferred deletion requires frame drain
+- Measured optimization evidence: not applicable
+
+## Status
+
+- State: ready-for-review
+- Done: one leaked RefCounted reproduced; isolation attributed it to `StreamingWorldLoader`; active threaded tile request was confirmed as the retained object; all owned threaded resource registries now finish in-progress requests before clearing; two identical verbose ADT-boundary runs and the full M00 dry-run completed without ObjectDB leak diagnostics
+- Next: integrator review and merge
+- Blocked by:
+
+## Handoff
+
+- Commit: this work-package commit
+- Results: verbose filtered capture returned one report and zero `Leaked instance`/`ObjectDB instances leaked` lines on two consecutive runs; `run_render_baseline.ps1 -DryRun` passed all gates and seven checkpoints
+- Remaining risks:
+- Documentation updated: `docs/modules/world-renderer.md` shutdown sequence, ownership contract, recovery table and known-risk status

coordination/claims/M00-QAR-COORD-CALIBRATION-001.md

@@ -1,6 +1,7 @@
 # M00-QAR-COORD-CALIBRATION-001 — Renderer coordinate calibration
 
 <!-- OPENWC_CLAIM:M00-QAR-COORD-CALIBRATION-001:sindo-main-codex:2026-07-13 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M00-QAR-COORD-CALIBRATION-001:dfc1031 -->
 
 ## Ownership
 

coordination/claims/M00-QAR-FINAL-PAIRED-EVIDENCE-001.md

@@ -0,0 +1,79 @@
+# M00-QAR-FINAL-PAIRED-EVIDENCE-001 — Final paired evidence audit
+
+<!-- OPENWC_CLAIM:M00-QAR-FINAL-PAIRED-EVIDENCE-001:sindo-main-codex:2026-07-14 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M00-QAR-FINAL-PAIRED-EVIDENCE-001:239cb24 -->
+
+## Ownership
+
+- Target: M00
+- Program: QAR
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m00-final-paired-evidence`
+- Lease expires UTC: 2026-07-14
+- Integrator: milestone integrator
+
+## Outcome
+
+Produce one final WMO-ready paired report for all available build 12340 references and reconcile the remaining M00 acceptance gaps.
+
+## Non-goals
+
+- Achieving renderer parity inside M00.
+- Calibrating unknown manual camera parameters.
+- Marking the target DONE; only the milestone integrator may do so.
+
+## Paths
+
+- Exclusive: paired-run exit handling and final evidence record
+- Shared/hotspots: renderer baseline/module findings
+- Generated/ignored: final captures and reports under `user://`
+
+## Contracts and data
+
+- Public API/events: visual comparison exit 0/1 both count as completed report generation
+- Schema/format version: unchanged
+- Migration/compatibility: comparator infrastructure errors remain fatal
+- Consumers: M00 integrator
+
+## Dependencies
+
+- Requires: merged region diagnostic and five private reference images
+- Blocks: integrator decision on M00 completion
+- External state: private images remain outside Git
+
+## Verification
+
+- Commands: complete paired baseline run, report audit, repository gates
+- Fixtures: five build 12340 references
+- Fidelity evidence: cold/warm comparison metrics and human gap classification
+- Performance budget: existing M00 capture budgets
+
+## Documentation deliverables
+
+- Inline public API docs: PowerShell comparison step semantics
+- Module specification: final evidence status
+- Data-flow diagram: unchanged
+- Sequence/state/dependency diagrams: unchanged
+- Source map/status updates: baseline acceptance summary
+
+## Simplicity and naming
+
+- Important names introduced: `Invoke-GodotComparisonStep`
+- Simplest considered solution: allow only comparator exit codes 0 and 1
+- Rejected complexity/abstractions: suppressing all process failures
+- Unavoidable complexity and justification: threshold exceedance is evidence, not infrastructure failure
+- Measured optimization evidence: not applicable
+
+## Status
+
+- State: ready-for-review
+- Done: paired-run exit contract fixed; full baseline and visual capture completed; ten pairs audited; final acceptance document written
+- Next: integrator decides animated/sky reference policy and GUI RID-risk disposition
+- Blocked by:
+
+## Handoff
+
+- Commit: this work-package commit
+- Results: compared=10, failed=10, missing=0; mean error 0.066892..0.176952; cold/warm gaps stable; full workflow returned success with threshold evidence preserved
+- Remaining risks: no build 12340 animated-M2 or sky-transition reference; GUI renderer RID/resources still reported at exit
+- Documentation updated: `docs/M00_FINAL_PAIRED_EVIDENCE.md`, `docs/modules/world-renderer.md`

coordination/claims/M00-QAR-FOV-SWEEP-001.md

@@ -0,0 +1,79 @@
+# M00-QAR-FOV-SWEEP-001 — Empirical camera FOV sweep
+
+<!-- OPENWC_CLAIM:M00-QAR-FOV-SWEEP-001:sindo-main-codex:2026-07-14 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M00-QAR-FOV-SWEEP-001:f548507 -->
+
+## Ownership
+
+- Target: M00
+- Program: QAR
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m00-fov-sweep`
+- Lease expires UTC: 2026-07-14
+- Integrator: milestone integrator
+
+## Outcome
+
+Support a bounded empirical FOV sweep when build 12340 does not expose a readable camera FOV CVar.
+
+## Non-goals
+
+- Claiming exact WoW FOV from a single manually aimed screenshot.
+- Changing runtime player camera defaults.
+- Automating yaw/pitch registration or image warping.
+
+## Paths
+
+- Exclusive: FOV/filter CLI additions in checkpoint tools
+- Shared/hotspots: renderer baseline documentation
+- Generated/ignored: local sweep PNGs and JSON reports
+
+## Contracts and data
+
+- Public API/events: additive `--camera-fov` and comparator `--only` CLI options
+- Schema/format version: unchanged
+- Migration/compatibility: existing commands retain defaults
+- Consumers: M00 fidelity workflow
+
+## Dependencies
+
+- Requires: build 12340 reference JPG and paired-image comparator
+- Blocks: empirical projection ranking
+- External state: original screenshots remain outside Git
+
+## Verification
+
+- Commands: synthetic comparator test, capture dry-run with override, bounded real sweep
+- Fixtures: `elwynn_adt_boundary` reference
+- Fidelity evidence: ranked perceptual metrics with manual-direction limitation
+- Performance budget: offline diagnostic
+
+## Documentation deliverables
+
+- Inline public API docs: CLI headers
+- Module specification: verification/source map if needed
+- Data-flow diagram: FOV sweep flow
+- Sequence/state/dependency diagrams: not applicable
+- Source map/status updates: baseline findings
+
+## Simplicity and naming
+
+- Important names introduced: `camera_fov_override`, `only_filter`
+- Simplest considered solution: reuse capture and comparator
+- Rejected complexity/abstractions: computer vision registration framework
+- Unavoidable complexity and justification: multiple captures are required because client FOV is inaccessible
+- Measured optimization evidence: not applicable
+
+## Status
+
+- State: ready
+- Done: client FOV access audit, capture override, comparator filter/regression, dedicated-camera ownership fix and bounded sweep
+- Next: integrator review; obtain reproducible yaw/pitch/zoom metadata before changing normative FOV
+- Blocked by:
+
+## Handoff
+
+- Commit: branch HEAD
+- Results: corrected ranking 26=0.079588, 38=0.079633, 50=0.084353, 62=0.088360, 86=0.097993; plateau is inconclusive
+- Remaining risks: build 12340 FOV is inaccessible through tested APIs; manual direction/framing dominates metrics
+- Documentation updated: `docs/RENDER_BASELINE.md`, `docs/modules/world-renderer.md`

coordination/claims/M00-QAR-GUI-RID-SHUTDOWN-001.md

@@ -0,0 +1,79 @@
+# M00-QAR-GUI-RID-SHUTDOWN-001 — GUI capture RID shutdown
+
+<!-- OPENWC_CLAIM:M00-QAR-GUI-RID-SHUTDOWN-001:sindo-main-codex:2026-07-15 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M00-QAR-GUI-RID-SHUTDOWN-001:f19c0c4 -->
+
+## Ownership
+
+- Target: M00
+- Program: QAR
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m00-gui-rid-shutdown`
+- Lease expires UTC: 2026-07-15
+- Integrator: milestone integrator
+
+## Outcome
+
+Identify ownership of GUI render-baseline shutdown leaks and apply the smallest regression-covered fix that lets queued world resources release before engine teardown.
+
+## Non-goals
+
+- Renderer architecture decomposition.
+- Hiding or filtering Godot leak diagnostics.
+- Changing M00 status, Evidence or `OPENWC_TARGET_DONE`.
+
+## Paths
+
+- Exclusive: capture shutdown sequencing and its regression diagnostic
+- Shared/hotspots: `src/tools/capture_render_checkpoints.gd`, renderer module shutdown documentation
+- Generated/ignored: GUI capture output and verbose logs under `user://`
+
+## Contracts and data
+
+- Public API/events: unchanged
+- Schema/format version: unchanged
+- Migration/compatibility: capture images and report schema remain unchanged
+- Consumers: M00 baseline runner and milestone integrator
+
+## Dependencies
+
+- Requires: merged seven-reference evidence audit
+- Blocks: integrator disposition of the final GUI renderer leak risk
+- External state: proprietary references are not required for the focused shutdown regression
+
+## Verification
+
+- Commands: focused GUI single-checkpoint capture with verbose shutdown, headless project load, manifest/self-tests, repository gates
+- Fixtures: existing non-proprietary render-baseline manifest and local extracted corpus
+- Fidelity evidence: no visual behavior change; focused PNG hash/report remains valid
+- Performance budget: shutdown-only change
+
+## Documentation deliverables
+
+- Inline public API docs: shutdown method semantics if introduced
+- Module specification: shutdown ownership and observed leak status
+- Data-flow diagram: unchanged
+- Sequence/state/dependency diagrams: update shutdown sequence only if behavior changes
+- Source map/status updates: capture tool if changed
+
+## Simplicity and naming
+
+- Important names introduced: `_release_runtime_caches_for_shutdown`, `_free_detached_node_cache`, `_queue_free_streamed_node`
+- Simplest considered solution: explicitly release capture-owned scene references and drain deferred deletion
+- Rejected complexity/abstractions: global RID registry or suppressed engine diagnostics
+- Unavoidable complexity and justification: async streaming jobs must finish before resource ownership can drain
+- Measured optimization evidence: not applicable
+
+## Status
+
+- State: ready-for-review
+- Done: reproduced the focused leak; assigned detached prototype/resource caches and empty liquid roots to explicit owners; added a headless regression; verified zero Node/resource/RID leak lines in focused and seven-checkpoint GUI captures
+- Next: integrator review and disposition of the residual engine-level zero-reference `RefCounted` diagnostic
+- Blocked by:
+
+## Handoff
+
+- Commit: this work-package commit
+- Results: before the fix the focused capture retained 6 mesh, 6 material, 4 shader, 6 texture, 6 instance and RenderingDevice RIDs (30 resources); after the fix focused and seven-checkpoint captures retained none
+- Remaining risks: D3D12 descriptor fallback remains unrelated; Godot can report a timing-dependent anonymous `RefCounted` whose reference count is already zero, without retained Node/resource/RID ownership
+- Documentation updated: `RENDER.md`, `docs/modules/world-renderer.md`, `docs/M00_FINAL_PAIRED_EVIDENCE.md`; existing renderer shutdown sequence updated, no new diagram required

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

@@ -0,0 +1,79 @@
+# M00-QAR-INTEGRATOR-CLOSEOUT-001 — M00 milestone closeout
+
+<!-- OPENWC_CLAIM:M00-QAR-INTEGRATOR-CLOSEOUT-001:sindo-main-codex:2026-07-15 -->
+<!-- OPENWC_HANDOFF:READY:M00-QAR-INTEGRATOR-CLOSEOUT-001:ba81098 -->
+
+## Ownership
+
+- Target: M00
+- Program: QAR
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m00-integrator-closeout`
+- Lease expires UTC: 2026-07-15
+- Integrator: sindo-main-codex, assigned by the user on 2026-07-13
+
+## Outcome
+
+Audit merged M00 work packages, refresh final Evidence, close the milestone and activate M01.
+
+## Non-goals
+
+- Change renderer behavior or compatibility claims.
+- Start M01 implementation.
+- Commit proprietary references or generated capture output.
+
+## Paths
+
+- Exclusive: M00/M01 target status and final M00 Evidence
+- Shared/hotspots: `targets/README.md`, `targets/DEVELOPMENT_ROADMAP.md`, completed M00 claims
+- Generated/ignored: `user://` post-merge reports
+
+## Contracts and data
+
+- Public API/events: unchanged
+- Schema/format version: unchanged
+- Migration/compatibility: none
+- Consumers: milestone integrator and M01 work packages
+
+## Dependencies
+
+- Requires: merged M00 PRs #1 through #15 and final paired evidence
+- Blocks: M01 activation
+- External state: private reference images remain outside Git; their hashes and metrics are already recorded
+
+## Verification
+
+- Commands: post-merge render baseline dry-run, coordination gate, documentation gate
+- Fixtures: seven-checkpoint non-proprietary manifest and recorded private-reference hashes/metrics
+- Fidelity evidence: closeout preserves the explicit non-parity classification in `docs/M00_FINAL_PAIRED_EVIDENCE.md`
+- Performance budget: no runtime change
+
+## Documentation deliverables
+
+- Inline public API docs: unchanged
+- Module specification: unchanged
+- Data-flow diagram: unchanged
+- Sequence/state/dependency diagrams: unchanged
+- Source map/status updates: target index, roadmap current state and M00 Evidence
+
+## Simplicity and naming
+
+- Important names introduced: none
+- Simplest considered solution: status and Evidence-only integrator patch
+- Rejected complexity/abstractions: new closeout tooling for a one-time milestone transition
+- Unavoidable complexity and justification: none
+- Measured optimization evidence: not applicable
+
+## Status
+
+- State: ready-for-review
+- Done: verified all M00 PRs and merge commits, refreshed final Evidence, closed M00, activated M01 and passed transition gates
+- Next: review and merge the closeout PR before starting an M01 implementation claim
+- Blocked by:
+
+## Handoff
+
+- Commit: `ba81098`
+- Results: exactly one ACTIVE target (M01); M00 DONE marker accepted; post-merge baseline, comparator self-test, coordination and documentation gates passed
+- Remaining risks: documented renderer fidelity gaps and D3D12 fallback continue beyond M00
+- Documentation updated: target status/index, development-roadmap current state and final M00 Evidence

coordination/claims/M00-QAR-LANDMARK-REGION-DIFF-001.md

@@ -0,0 +1,79 @@
+# M00-QAR-LANDMARK-REGION-DIFF-001 — Landmark-region visual diff
+
+<!-- OPENWC_CLAIM:M00-QAR-LANDMARK-REGION-DIFF-001:sindo-main-codex:2026-07-14 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M00-QAR-LANDMARK-REGION-DIFF-001:3d90c6d -->
+
+## Ownership
+
+- Target: M00
+- Program: QAR
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m00-landmark-region-diff`
+- Lease expires UTC: 2026-07-14
+- Integrator: milestone integrator
+
+## Outcome
+
+Rank camera candidates inside an approved common screen region so unrelated grass/sky coverage cannot dominate landmark framing.
+
+## Non-goals
+
+- Automatic feature detection or image warping.
+- Different crops for reference and candidate.
+- Changing manifest camera values without human approval.
+
+## Paths
+
+- Exclusive: comparator common-region option and sweep pass-through
+- Shared/hotspots: camera-pose documentation and renderer fidelity findings
+- Generated/ignored: local ROI sweep images/reports
+
+## Contracts and data
+
+- Public API/events: additive comparator `--region x,y,width,height` and sweep `-ComparisonRegion`
+- Schema/format version: report/ranking schema remains version 1 with additive region metadata
+- Migration/compatibility: omitted region preserves full-frame behavior
+- Consumers: M00 paired camera calibration
+
+## Dependencies
+
+- Requires: ready-scene joint pitch/FOV sweep
+- Blocks: landmark-weighted Goldshire framing decision
+- External state: private build 12340 reference
+
+## Verification
+
+- Commands: comparator synthetic ROI regression, invalid-bound regression, sweep plan, bounded real ROI sweep, repository gates
+- Fixtures: synthetic 2x2 images and private Goldshire reference
+- Fidelity evidence: facade-region ranking plus human inspection
+- Performance budget: region comparison visits only selected pixels
+
+## Documentation deliverables
+
+- Inline public API docs: comparator usage and PowerShell parameter
+- Module specification: ROI finding
+- Data-flow diagram: approved region into comparator
+- Sequence/state/dependency diagrams: unchanged
+- Source map/status updates: camera-pose guide
+
+## Simplicity and naming
+
+- Important names introduced: `ComparisonRegion`, `comparison_region`
+- Simplest considered solution: one common integer rectangle
+- Rejected complexity/abstractions: masks, feature detectors, separate movable crops
+- Unavoidable complexity and justification: full-frame color error is biased by large terrain regions
+- Measured optimization evidence: bounded pixel loop
+
+## Status
+
+- State: ready-for-review
+- Done: common ROI parser/validation/reporting, synthetic inclusion/exclusion regression, sweep pass-through, 15-candidate Goldshire rescoring and human inspection
+- Next: define explicit approved landmark coordinates or mask; do not calibrate manifest from the common rectangle alone
+- Blocked by:
+
+## Handoff
+
+- Commit: this work-package commit
+- Results: ROI [300,100,1400,650] ranked FOV 38/yaw 10/pitch -15 first at mean 0.081777 and ratio 0.697185; visually the facade remains oversized and cropped
+- Remaining risks: rectangle includes non-semantic road/terrain pixels and cannot prove landmark alignment
+- Documentation updated: `docs/CAMERA_POSE_SWEEP.md`, `docs/modules/world-renderer.md`

coordination/claims/M00-QAR-TERRAIN-HEIGHT-001.md

@@ -1,6 +1,7 @@
 # M00-QAR-TERRAIN-HEIGHT-001 — Terrain height diagnostic
 
 <!-- OPENWC_CLAIM:M00-QAR-TERRAIN-HEIGHT-001:sindo-main-codex:2026-07-13 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M00-QAR-TERRAIN-HEIGHT-001:f8538ba -->
 
 ## Ownership
 

coordination/claims/M00-QAR-TILE-OWNERSHIP-001.md

@@ -1,6 +1,7 @@
 # M00-QAR-TILE-OWNERSHIP-001 — Waterfall terrain tile ownership
 
 <!-- OPENWC_CLAIM:M00-QAR-TILE-OWNERSHIP-001:sindo-main-codex:2026-07-13 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M00-QAR-TILE-OWNERSHIP-001:2306200 -->
 
 ## Ownership
 

coordination/claims/M00-QAR-VISUAL-DIFF-001.md

@@ -1,6 +1,7 @@
 # M00-QAR-VISUAL-DIFF-001 — Renderer checkpoint visual diff
 
 <!-- OPENWC_CLAIM:M00-QAR-VISUAL-DIFF-001:sindo-main-codex:2026-07-13 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M00-QAR-VISUAL-DIFF-001:19df5b7 -->
 
 ## Ownership
 

coordination/claims/M00-QAR-WMO-READINESS-001.md

@@ -0,0 +1,79 @@
+# M00-QAR-WMO-READINESS-001 — Goldshire WMO readiness
+
+<!-- OPENWC_CLAIM:M00-QAR-WMO-READINESS-001:sindo-main-codex:2026-07-14 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M00-QAR-WMO-READINESS-001:5092995 -->
+
+## Ownership
+
+- Target: M00
+- Program: QAR
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m00-wmo-readiness`
+- Lease expires UTC: 2026-07-14
+- Integrator: milestone integrator
+
+## Outcome
+
+Prevent pose calibration against an under-loaded WMO scene and replace invalid Goldshire evidence with a baseline-ready comparison.
+
+## Non-goals
+
+- Changing runtime streaming budgets.
+- Claiming all WMO queues must globally drain before a checkpoint.
+- Changing manifest camera pose without valid paired evidence.
+
+## Paths
+
+- Exclusive: pose-sweep readiness default and Goldshire timing evidence
+- Shared/hotspots: renderer baseline/module fidelity findings
+- Generated/ignored: timing and sweep images under `user://`
+
+## Contracts and data
+
+- Public API/events: pose sweep default wait becomes 8 seconds, matching the M00 manifest
+- Schema/format version: unchanged
+- Migration/compatibility: explicit `-WaitSeconds` remains supported
+- Consumers: M00 paired-fidelity workflow
+
+## Dependencies
+
+- Requires: Goldshire pose evidence and private build 12340 reference
+- Blocks: valid Goldshire camera-pose ranking
+- External state: private reference and generated captures remain outside Git
+
+## Verification
+
+- Commands: 2/8/15 second timing audit, ready-scene 3x3 pose sweep, baseline dry-run, repository gates
+- Fixtures: private Goldshire Inn screenshot
+- Fidelity evidence: visual WMO presence plus streaming snapshot and paired metrics
+- Performance budget: offline diagnostic
+
+## Documentation deliverables
+
+- Inline public API docs: PowerShell default
+- Module specification: corrected readiness/fidelity finding
+- Data-flow diagram: readiness precondition
+- Sequence/state/dependency diagrams: unchanged
+- Source map/status updates: camera-pose operational guide
+
+## Simplicity and naming
+
+- Important names introduced: none
+- Simplest considered solution: reuse the manifest's measured 8-second stabilization default
+- Rejected complexity/abstractions: global queue barrier that would include unrelated distant work
+- Unavoidable complexity and justification: WMO publication is asynchronous
+- Measured optimization evidence: 2/8/15 second snapshots
+
+## Status
+
+- State: ready-for-review
+- Done: timing audit invalidated the 2-second evidence; sweep default now matches the 8-second manifest; ready-scene 3x3 grid and human inspection completed
+- Next: jointly refine negative pitch and FOV around the ready-scene Goldshire candidate
+- Blocked by:
+
+## Handoff
+
+- Commit: this work-package commit
+- Results: WMO instances 9/113/328 at 2/8/15 seconds; inn absent at 2 and visible at 8/15; ready grid improved mean error from 0.101402 at (0,0) to 0.087952 at (10,-10)
+- Remaining risks: global WMO queues still contain unrelated work; best pitch is at the tested boundary and building scale indicates unresolved FOV/framing
+- Documentation updated: `docs/CAMERA_POSE_SWEEP.md`, `docs/modules/world-renderer.md`

coordination/claims/M01-FND-COORD-BOUNDARY-GATE-001.md

@@ -0,0 +1,131 @@
+# 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_INTEGRATION:ACCEPTED:M01-FND-COORD-BOUNDARY-GATE-001:c8e99f2 -->
+
+## Ownership
+
+- Target: M01
+- Program: FND/QAR
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m01-coordinate-boundary-gate`
+- Lease expires UTC: 2026-07-15
+- Integrator: M01 milestone integrator
+
+## Outcome
+
+Route remaining GDScript world/tile axis conversions through `CoordinateMapper`
+and add a repository-wide gate that rejects new manual world-center, axis-swap
+or world-to-ADT tile formulas outside explicit contract/native-oracle boundaries.
+
+## Non-goals
+
+- Rewriting model-local M2/WMO vertex or placement orientation transforms.
+- Moving renderer distance/LOD geometry out of Godot space.
+- Replacing the native parser boundary with GDScript calls from worker threads.
+- Changing coordinate contract semantics, renderer radii or cache formats.
+
+## Paths
+
+- Exclusive: `src/tools/verify_coordinate_conversion_boundaries.gd`
+- Shared/hotspots: `src/domain/coordinates/coordinate_mapper.gd`, coordinate
+  tests/docs/ADR, streamer/player/sky/terrain-probe consumers,
+  `docs/CODING_STANDARD.md`, this claim
+- Generated/ignored: Godot import metadata, extracted assets and renderer caches
+
+## Contracts and data
+
+- Additive mapper methods: Godot position to ADT tile/local and ADT tile/local
+  to Godot position
+- Native exception: one formula definition in `src/native/src/wow_chunk_reader.h`;
+  ADT/WDT loaders may call it but may not define copies
+- Oracle exception: `verify_render_coordinate_calibration.gd` retains one
+  independent M00 formula to detect common-mode mapper regressions
+- Model-local transforms are outside the world-coordinate gate
+
+## Dependencies
+
+- Requires: coordinate contract v2 and M01 seams through `7c64e8d`
+- Blocks: M01 coordinate-centralization exit criterion and milestone evidence audit
+- External state: no dependency or proprietary input
+
+## Verification
+
+- Commands: conversion-boundary gate, mapper/golden fixtures, streaming focus,
+  identities, renderer calibration/manifest and repository gates
+- Fixtures: Godot/ADT tile center, local offsets and exact boundaries
+- Fidelity evidence: existing build-12340 points and raw ADT/server fixture remain unchanged
+- Performance budget: mapper allocations occur only at adapter/update boundaries;
+  renderer distance/LOD math remains in Godot scalars
+
+## Documentation deliverables
+
+- Inline public API docs: new mapper methods
+- Module specification/ADR: boundary APIs, allowed exceptions and gate behavior
+- Coding standard: mandatory review rule for cross-space conversions
+- Data-flow diagram: existing coordinate module diagram updated for direct adapters
+- State/sequence diagrams: unchanged; pure synchronous mapping
+
+## Simplicity and naming
+
+- Important names introduced: `godot_to_adt_tile`, `godot_to_adt_tile_local`,
+  `adt_tile_local_to_godot`, `verify_coordinate_conversion_boundaries`
+- Simplest considered solution: extend the existing mapper and scan source text
+  for narrow high-signal formula signatures
+- Rejected complexity/abstractions: generic coordinate algebra framework,
+  native-to-GDScript calls on parser workers and a broad numeric-literal ban
+- Unavoidable complexity and justification: one native boundary and one
+  independent test oracle must remain explicit to avoid worker coupling and common-mode tests
+- Measured optimization evidence: existing renderer distance/LOD scalar math is unchanged
+
+## Status
+
+- State: ready-for-review
+- Done: mapper extensions, consumer migration, repository gate, review rule,
+  integrated renderer gate, regression fixtures and documentation
+- Next: integrator review, merge and M01 completion-evidence audit
+- Blocked by:
+
+## Handoff
+
+- Commit: `47dec6c`
+- Branch: `work/sindo-main-codex/m01-coordinate-boundary-gate`
+- Outcome: all audited GDScript world/tile conversions in sky, streaming,
+  player spawn/ground sampling and terrain probes route through typed
+  `CoordinateMapper` boundaries. A repository scan rejects new manual
+  world-center, legacy axis-conversion, world-to-tile, tile-local and
+  tile-center formulas.
+- Contract/schema: additive `godot_to_adt_tile`,
+  `godot_to_adt_tile_local` and `adt_tile_local_to_godot` APIs; no persisted
+  format, cache version or renderer radius changes.
+- Verification: CoordinateConversionBoundaries PASS (`83` files, one native
+  boundary, one independent oracle, four consumers, six classifier guards);
+  CoordinateMapper PASS (`5` golden points, `8` tile boundaries, `2` raw MCNK,
+  `5` yaw cases); renderer calibration PASS (`5` points, maximum error
+  `0.000015`); renderer manifest PASS (`7/7/7`); unified render baseline dry-run,
+  headless project load, runtime cache shutdown, coordination, documentation
+  and whitespace gates passed.
+- GUI regression: final ADT-boundary capture compared `2/2`, missing `0`,
+  failed `0` (cold mean `0.0002324`, changed ratio `0.0013741`; warm mean
+  `0.0000226`, changed ratio `0.0001285`). Earlier full capture produced all
+  `14` images; `11/14` met the strict changed-pixel threshold. The three
+  threshold-only differences retained low mean error (`<= 0.00622`) and were
+  visually classified as cold M2 readiness and liquid animation phase, with
+  unchanged camera, geometry alignment, area and streaming focus.
+- Fidelity: existing build-12340 calibrated points, raw ADT fixture and server
+  spawn fixture remain unchanged. Native parser workers retain exactly one
+  formula in `wow_chunk_reader.h`; the calibration verifier retains exactly one
+  independent formula so mapper and oracle cannot share a common-mode defect.
+- Rebuild: none. Local ignored extracted assets/native binary/cache junctions
+  were used for runtime checks and are not part of the commit.
+- Remaining risks: source scanning intentionally recognizes narrow high-signal
+  formula signatures rather than parsing arbitrary algebra; native formula
+  parity still relies on calibration/raw fixtures. Model-local M2/WMO basis
+  transforms and Godot-space LOD distance math are intentionally outside scope.
+- Recommended merge order: after `7c64e8d`; this package closes the remaining
+  M01 manual axis-conversion checklist item, but only the milestone integrator
+  may update target Evidence/status or set `OPENWC_TARGET_DONE`.
+- Documentation: coding review rule, coordinate-mapping module API/input-output/
+  data-flow/capability/risk/source-map sections, ADR 0001 and `RENDER.md` were
+  updated. Existing pure synchronous data-flow diagram remains authoritative;
+  no state/sequence diagram changed.

coordination/claims/M01-FND-COORD-TILE-AXIS-002.md

@@ -0,0 +1,104 @@
+# 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_INTEGRATION:ACCEPTED:M01-FND-COORD-TILE-AXIS-002:c8e99f2 -->
+
+## Ownership
+
+- Target: M01
+- Program: FND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m01-coordinate-tile-axis-fix`
+- Lease expires UTC: 2026-07-15
+- Integrator: M01 milestone integrator
+
+## Outcome
+
+Correct the additive coordinate contract so `AdtTileCoordinate(tile_x, tile_y)`
+matches actual `Map_tileX_tileY.adt` filenames and MCNK `indexX/indexY` axes.
+
+## Non-goals
+
+- Migrating renderer/native consumers.
+- Changing canonical, server, Godot or ADT placement position arithmetic.
+- Adding server-spawn fixtures or `StreamingFocus`.
+- Committing proprietary ADT bytes.
+
+## Paths
+
+- Exclusive: `src/domain/coordinates/coordinate_mapper.gd`,
+  `src/domain/coordinates/adt_chunk_coordinate.gd`,
+  `src/tools/verify_coordinate_mapper.gd`
+- Shared/hotspots: `docs/adr/0001-canonical-world-coordinates.md`,
+  `docs/modules/coordinate-mapping.md`, this claim
+- Generated/ignored: local extracted ADT and Godot import metadata
+
+## Contracts and data
+
+- Public API/events: method names unchanged; corrected tile/chunk axis semantics
+- Schema/format version: coordinate contract version increments from 1 to 2
+- Migration/compatibility: no released consumer exists; contract was merged but
+  not yet consumed, so correction precedes consumer rollout
+- Consumers: future renderer, network, gameplay and server-data adapters
+
+## Dependencies
+
+- Requires: merged `M01-FND-COORDS-001` at `1c0dfc7`
+- Blocks: coordinate golden fixtures and all coordinate consumers
+- External state: private `Azeroth_31_49.adt` used read-only for evidence
+
+## Verification
+
+- Commands: coordinate mapper probe, M00 calibration, manifest, documentation
+  and coordination gates
+- Fixtures: build 12340 Elwynn point must resolve to `Azeroth_31_49.adt`;
+  MCNK `(0,0)` and `(15,15)` establish chunk-axis direction
+- Fidelity evidence: local ADT SHA-256
+  `18185B5FAC9566D9C57A9C19ABD75F108370D1795639B6077167C0EFD3672FAE`;
+  OpenRealm independently indexes filename X from world Y and filename Y from world X
+- Performance budget: unchanged constant-time scalar arithmetic
+
+## Documentation deliverables
+
+- Inline public API docs: corrected tile/chunk direction comments
+- Module specification: contract version, formulas, capability evidence and risk
+- Data-flow diagram: corrected filename/chunk axes
+- ADR: corrected decision and evidence
+- Sequence/state diagrams: not applicable; pure synchronous mapper
+
+## Simplicity and naming
+
+- Important names introduced: none
+- Simplest considered solution: swap the two filename formulas and corresponding
+  local/chunk ownership calculations
+- Rejected complexity/abstractions: compatibility flag for a contract with no consumers
+- Unavoidable complexity and justification: ADT filename axes differ from client X/Y order
+- Measured optimization evidence: not applicable
+
+## Status
+
+- State: ready-for-review
+- Done: raw-corpus diagnosis, filename/local/chunk axis correction, contract
+  version 2 documentation and regression fixtures
+- Next: integrator review and merge before coordinate consumer work
+- Blocked by:
+
+## Handoff
+
+- Commit: `a7072e3`
+- Branch: `work/sindo-main-codex/m01-coordinate-tile-axis-fix`
+- Outcome: `tile_x/chunk_x` now grow east from canonical Y and
+  `tile_y/chunk_y` grow south from canonical X; public method names unchanged
+- Contract/schema: coordinate contract version 2; no persisted format, cache or migration
+- Verification: coordinate mapper PASS (5 build-12340 points, 8 boundaries,
+  2 recorded raw MCNK origins, 5 yaw cases); M00 calibration PASS with maximum
+  error `0.000015`; renderer manifest, coordination, documentation, dependency
+  and whitespace checks passed
+- Fidelity: private `Azeroth_31_49.adt` hash and raw MCNK origins recorded in
+  ADR 0001; OpenRealm independently uses the same filename-axis ordering
+- Rebuild: none; private/generated prerequisites remain outside Git
+- Remaining risks: server spawn fixture, native placement conversion and
+  MDDF/MODF Euler semantics remain subsequent M01 packages
+- Recommended merge order: merge this correction before golden fixture or consumer migration
+- Documentation: ADR 0001 and coordinate-mapping module data flow, contract
+  version, capability evidence and known risks updated

coordination/claims/M01-FND-COORDS-001.md

@@ -0,0 +1,111 @@
+# M01-FND-COORDS-001 — Canonical coordinate contracts
+
+<!-- OPENWC_CLAIM:M01-FND-COORDS-001:sindo-main-codex:2026-07-15 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M01-FND-COORDS-001:c8e99f2 -->
+
+## Ownership
+
+- Target: M01
+- Program: FND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m01-coordinate-mapper`
+- Lease expires UTC: 2026-07-15
+- Integrator: M01 milestone integrator
+
+## Outcome
+
+Introduce scene-free value objects for canonical WoW, server, ADT placement,
+ADT tile/chunk/local and Godot world coordinate spaces, plus the single pure
+`CoordinateMapper` contract for position and world-yaw conversions.
+
+## Non-goals
+
+- Migrating `StreamingWorldLoader`, native parsers, sky, player or renderer code.
+- Defining model-specific MDDF/MODF Euler rotation corrections.
+- Introducing `StreamingFocus`, typed IDs or a test framework dependency.
+- Claiming visual parity from arithmetic round trips.
+
+## Paths
+
+- Exclusive: `src/domain/coordinates/**`, `src/tools/verify_coordinate_mapper.gd`,
+  `docs/modules/coordinate-mapping.md`, `docs/adr/0001-canonical-world-coordinates.md`
+- Shared/hotspots: `docs/modules/README.md`, this claim
+- Generated/ignored: Godot import metadata and local test output
+
+## Contracts and data
+
+- Public API/events: immutable coordinate value objects and pure mapper methods
+- Schema/format version: no persisted format; contract version 1 in module docs
+- Migration/compatibility: additive contract; existing renderer conversions remain
+  unchanged until a later consumer migration package
+- Consumers: future renderer, network, gameplay and server-data adapters
+- Rollout order: contract and fixtures first, then native/parser and renderer consumers
+
+## Dependencies
+
+- Requires: merged M00 build 12340 coordinate calibration evidence
+- Blocks: M01 renderer coordinate migration and `StreamingFocus`
+- External state: no proprietary inputs; reference formulas are source-only evidence
+
+## Verification
+
+- Commands: headless coordinate contract probe, headless project load,
+  coordination and documentation gates
+- Fixtures: five build 12340 camera points, ADT map center/edge/boundary points,
+  server/ADT/Godot round trips and yaw normalization cases
+- Fidelity evidence: M00 observed build 12340 positions plus independent
+  OpenRealm/WoWee and TrinityCore grid formulas
+- Performance budget: constant-time scalar arithmetic with no allocation beyond result values
+
+## Documentation deliverables
+
+- Inline public API docs: every public value object and mapper method
+- Module specification: purpose, public API, inputs/outputs, ownership, errors and source map
+- Data-flow diagram: server/ADT/canonical/Godot mappings
+- Dependency diagram: canonical contract consumers and forbidden scene dependency
+- Sequence/state diagrams: not applicable; mapper is synchronous and stateless
+- ADR: coordinate axes, units, tile indexing and compatibility rollout
+
+## Simplicity and naming
+
+- Important names introduced: `CanonicalWowWorldPosition`, `ServerWorldPosition`,
+  `AdtPlacementPosition`, `AdtTileCoordinate`, `AdtChunkCoordinate`,
+  `AdtTileLocalPosition`, `GodotWorldPosition`, `WorldYaw`, `CoordinateMapper`
+- Simplest considered solution: scalar immutable value objects and one pure mapper
+- Rejected complexity/abstractions: generic vector-space framework, matrices,
+  dependency injection and a third-party test framework
+- Unavoidable complexity and justification: distinct source spaces prevent silent axis swaps
+- Measured optimization evidence: not applicable
+
+## Status
+
+- State: ready-for-review
+- Done: repository/reference audit, ADR, immutable value objects, pure mapper,
+  build 12340/boundary/yaw fixtures, module specification and repository gates
+- Next: integrator review and merge before renderer/native consumer migration
+- Blocked by:
+
+## Handoff
+
+- Commit: `f45695c`
+- Branch: `work/sindo-main-codex/m01-coordinate-mapper`
+- Outcome: additive contract for canonical/server/ADT/Godot positions, ADT
+  tile/chunk/local ownership and world-facing yaw; no existing consumer changed
+- Public contracts: contract version 1 documented in
+  `docs/modules/coordinate-mapping.md`; no persisted schema or cache change
+- Verification: coordinate mapper PASS (5 golden points, 8 tile boundaries,
+  5 yaw cases); M00 coordinate calibration PASS (5 points, maximum error
+  `0.000015`); renderer manifest, coordination, documentation, dependency and
+  whitespace checks passed; headless project load completed with expected
+  missing proprietary-data diagnostics in the isolated worktree
+- Fidelity: observed build 12340 positions match within `0.002` yard; formulas
+  cross-checked against TrinityCore, OpenRealm and WoWee; visual parity is not claimed
+- Migration/rebuild: none for this additive package; consumers migrate only
+  after merge and must preserve renderer checkpoints
+- Remaining risks: native loaders and renderer still use manual conversions;
+  MDDF/MODF Euler mapping is intentionally unresolved; server-spawn integration
+  and finite-value adapter validation remain later M01 packages
+- Recommended merge order: this contract first, coordinate fixtures/server-spawn
+  audit second, renderer/native consumers third, manual-conversion search gate last
+- Documentation: ADR 0001; coordinate-mapping module spec with data-flow and
+  dependency diagrams; inline API documentation on all public symbols

coordination/claims/M01-FND-DOMAIN-IDENTITIES-001.md

@@ -0,0 +1,112 @@
+# M01-FND-DOMAIN-IDENTITIES-001 — Stable domain identity namespaces
+
+<!-- OPENWC_CLAIM:M01-FND-DOMAIN-IDENTITIES-001:sindo-main-codex:2026-07-15 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M01-FND-DOMAIN-IDENTITIES-001:c8e99f2 -->
+
+## Ownership
+
+- Target: M01
+- Program: FND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m01-domain-identities`
+- Lease expires UTC: 2026-07-15
+- Integrator: M01 milestone integrator
+
+## Outcome
+
+Add scene-free, immutable identity values for stable authored content,
+session-local entities, opaque WoW wire GUIDs and namespaced server entries so
+callers cannot silently interchange their numeric/string representations.
+
+## Non-goals
+
+- Allocating Content IDs, Entity IDs or server entries.
+- Decoding WoW GUID high types before the build-12340 protocol package.
+- Defining map/spell/item/quest/display/sound IDs in this package.
+- Migrating gameplay, network or Content Project consumers that do not exist yet.
+
+## Paths
+
+- Exclusive: `src/domain/identity/`, `src/tools/verify_domain_identities.gd`,
+  `docs/modules/domain-identities.md`, `docs/adr/0002-domain-identity-namespaces.md`
+- Shared/hotspots: `docs/ARCHITECTURE.md`, this claim
+- Generated/ignored: Godot import metadata
+
+## Contracts and data
+
+- `ContentId`: canonical lowercase UUID text persisted with schema-owned content
+- `EntityId`: positive session-local integer, never a persisted content/server identity
+- `WowGuid`: opaque high/low unsigned 32-bit words preserving wire bits
+- `ServerEntryId`: positive integer plus non-empty adapter/table namespace
+- Migration: additive types only; no existing persisted data changes
+
+## Dependencies
+
+- Requires: M01 coordinate/focus seams through `77cd17a`
+- Blocks: Content Project schemas, server adapters, network entity mapping and gameplay registry
+- External state: no dependency or proprietary input
+
+## Verification
+
+- Commands: identity contract/boundary verifier, dependency search,
+  coordination/documentation gates and headless project load
+- Fixtures: valid/invalid UUIDs, session IDs, full unsigned GUID words and
+  duplicate numeric server entries in different namespaces
+- Fidelity evidence: GUID words remain opaque and lossless until build-12340
+  packet fixtures establish semantic decomposition
+- Performance budget: constant-time scalar/string validation outside frame loops
+
+## Documentation deliverables
+
+- Inline public API docs: every value and validation/equality method
+- Module specification: persistence, ownership, namespace mapping and recovery
+- Data-flow diagram: authored/runtime/wire/server identities into adapters
+- State/sequence diagrams: lifecycle diagram for content/session/wire/server identity
+- ADR: namespace separation and UUID persistence decision
+
+## Simplicity and naming
+
+- Important names introduced: `ContentId`, `EntityId`, `WowGuid`, `ServerEntryId`
+- Simplest considered solution: four independent values with explicit fields
+- Rejected complexity/abstractions: generic ID base class, registry service,
+  UUID generator and speculative GUID high-type enum
+- Unavoidable complexity and justification: server entry namespace and split GUID
+  words prevent collisions and signed 64-bit loss
+- Measured optimization evidence: not applicable
+
+## Status
+
+- State: ready-for-review
+- Done: four identity values, boundary verifier, ADR, module specification,
+  architecture mapping and repository gates
+- Next: integrator review and merge before the manual axis-conversion gate
+- Blocked by:
+
+## Handoff
+
+- Commit: `c1dc07c`
+- Branch: `work/sindo-main-codex/m01-domain-identities`
+- Outcome: authored content, runtime entities, WoW wire GUIDs and namespaced
+  server entries now have separate immutable scene-free value objects
+- Contract/schema: identity contract version 1; `ContentId` uses canonical
+  lowercase UUID text. No existing schema/cache is migrated; containing future
+  schemas still require their own version and duplicate/reference policy
+- Verification: DomainIdentities PASS (`5` ContentId, `5` EntityId, `6` WowGuid,
+  `5` ServerEntryId cases); StreamingFocus, coordinate golden fixtures and
+  CoordinateMapper PASS; M00 calibration PASS with maximum error `0.000015`;
+  renderer manifest PASS (`7` checkpoints); headless project load exit `0`;
+  coordination, documentation, naming/dependency and whitespace checks passed
+- Fidelity: `WowGuid` preserves two complete unsigned 32-bit wire words and
+  explicitly does not claim build-12340 high-type semantics without packet
+  fixtures; zero GUID remains an uninterpreted observable sentinel
+- Rebuild: none; no dependency or proprietary input. Clean-worktree project
+  load reports expected missing ignored extracted assets/character resources
+- Remaining risks: no ID allocator, mapping registry or server namespace
+  vocabulary exists yet; UUID shape does not enforce generator version/variant;
+  GDScript callers must use domain `equals` or canonical keys rather than
+  reference `==`
+- Recommended merge order: after StreamingFocus at `77cd17a`, before the M01
+  manual axis-conversion rule/search gate
+- Documentation: ADR 0002, domain-identities module API/input-output/data-flow/
+  lifecycle/persistence/recovery/capability/source-map sections, module registry
+  and architecture Domain mapping added or updated

coordination/claims/M01-QAR-COORD-FIXTURES-001.md

@@ -0,0 +1,109 @@
+# M01-QAR-COORD-FIXTURES-001 — Coordinate golden fixtures
+
+<!-- OPENWC_CLAIM:M01-QAR-COORD-FIXTURES-001:sindo-main-codex:2026-07-15 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M01-QAR-COORD-FIXTURES-001:c8e99f2 -->
+
+## Ownership
+
+- Target: M01
+- Program: QAR
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m01-coordinate-fixtures`
+- Lease expires UTC: 2026-07-15
+- Integrator: M01 milestone integrator
+
+## Outcome
+
+Add a versioned, non-proprietary fixture and headless validator joining one
+pinned AzerothCore player spawn, raw ADT/MCNK metadata and the five M00
+original-client coordinate observations through coordinate contract version 2.
+
+## Non-goals
+
+- Committing ADT files, SQL dumps or original-client screenshots.
+- Claiming TrinityCore spawn equivalence without a pinned populated TDB source.
+- Migrating renderer/native consumers or rendering a live server spawn.
+- Changing coordinate formulas, IDs or `StreamingFocus`.
+
+## Paths
+
+- Exclusive: `src/tests/fixtures/coordinate_golden_points.json`,
+  `src/tools/verify_coordinate_golden_fixtures.gd`
+- Shared/hotspots: `docs/modules/coordinate-mapping.md`, this claim
+- Generated/ignored: extracted ADT data, server database downloads and Godot metadata
+
+## Contracts and data
+
+- Public API/events: no new production API; fixture schema version 1
+- Coordinate contract: version 2, unchanged
+- Migration/compatibility: additive test data; fixture consumers reject unknown schema versions
+- Consumers: M01 coordinate mapper, future native/renderer/server adapter migrations
+
+## Dependencies
+
+- Requires: merged coordinate contract version 2 at `b55bfca`
+- Blocks: coordinate consumer migration and golden server-spawn renderer integration
+- External state: source evidence reduced to pinned revision, numeric rows and SHA-256 hashes
+
+## Verification
+
+- Commands: fixture validator, coordinate mapper probe, M00 calibration,
+  manifest, coordination and documentation gates
+- Fixtures: AzerothCore Human Warrior start; raw `Azeroth_32_48.adt` MCNK
+  `(3,12)`; five build 12340 camera points
+- Fidelity evidence: exact source provenance and mapper outputs with bounded tolerances
+- Performance budget: negligible headless JSON and scalar arithmetic
+
+## Documentation deliverables
+
+- Inline public API docs: fixture-validator header and field validation functions
+- Module specification: fixture schema, provenance, verification and source map
+- Data-flow diagram: server/raw/client fixtures into mapper assertions
+- State/sequence/dependency diagrams: unchanged; synchronous stateless validation
+
+## Simplicity and naming
+
+- Important names introduced: `coordinate_golden_points`,
+  `verify_coordinate_golden_fixtures`
+- Simplest considered solution: one JSON fixture and one existing-style headless script
+- Rejected complexity/abstractions: test framework dependency, SQL parser, ADT bytes in Git
+- Unavoidable complexity and justification: three independent source categories need explicit provenance
+- Measured optimization evidence: not applicable
+
+## Status
+
+- State: ready-for-review
+- Done: pinned source research, schema 1 fixture, headless validator, module
+  documentation and all package gates
+- Next: integrator review and merge before coordinate consumer migration
+- Blocked by:
+
+## Handoff
+
+- Commit: `ce4f7ec`
+- Branch: `work/sindo-main-codex/m01-coordinate-fixtures`
+- Outcome: one versioned fixture now joins a pinned AzerothCore Human Warrior
+  spawn, private raw MCNK metadata and five original-client build 12340 points
+  through coordinate contract version 2
+- Contract/schema: additive test fixture schema 1; production coordinate API and
+  contract version 2 are unchanged; proprietary bytes remain outside Git
+- Verification: golden fixture PASS (`1` server spawn, `1` raw ADT chunk, `5`
+  original-client points); CoordinateMapper PASS (`5` golden points, `8` tile
+  boundaries, `2` raw MCNK cases, `5` yaw cases); M00 calibration PASS with
+  maximum error `0.000015`; renderer manifest PASS (`7` checkpoints); coordination,
+  documentation, dependency and whitespace checks passed
+- Fidelity: AzerothCore source pinned at revision
+  `68fcf0098b16388093989627f37be530fc91f07d`; private
+  `Azeroth_32_48.adt` SHA-256
+  `D66E27FD82B461AE38B78562952AED428E619777A3F3E35DD8FF97444644770A`;
+  server and raw data independently resolve tile `(32,48)` and chunk `(3,12)`
+- Rebuild: no proprietary input is required to rerun the committed fixture;
+  local ignored renderer resources are still required by the inherited M00
+  manifest probe
+- Remaining risks: TrinityCore equivalence needs a pinned populated TDB snapshot;
+  live server adapter, renderer integration and MDDF/MODF Euler semantics remain
+  subsequent M01 work
+- Recommended merge order: after coordinate contract version 2 (`b55bfca`) and
+  before live coordinate consumer migration
+- Documentation: coordinate-mapping module inputs/outputs, persistence, data-flow
+  diagram, verification, capability matrix, risks and source map updated

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

@@ -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.

coordination/claims/M01-QAR-SERVER-SPAWN-RENDERER-001.md

@@ -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`.

coordination/claims/M01-RND-STREAMING-FOCUS-001.md

@@ -0,0 +1,120 @@
+# M01-RND-STREAMING-FOCUS-001 — Explicit streaming focus contract
+
+<!-- OPENWC_CLAIM:M01-RND-STREAMING-FOCUS-001:sindo-main-codex:2026-07-15 -->
+<!-- OPENWC_INTEGRATION:ACCEPTED:M01-RND-STREAMING-FOCUS-001:c8e99f2 -->
+
+## Ownership
+
+- Target: M01
+- Program: RND/FND
+- Owner/Agent ID: sindo-main-codex
+- Branch: `work/sindo-main-codex/m01-streaming-focus`
+- Lease expires UTC: 2026-07-15
+- Integrator: M01 milestone integrator
+
+## Outcome
+
+Introduce a scene-free `StreamingFocus` value and make runtime/test streaming
+consume it through an explicit source or public setter instead of discovering
+the active `Camera3D` from a viewport.
+
+## Non-goals
+
+- Extracting `WorldRenderFacade` or `StreamingTargetPlanner` from the monolithic loader.
+- Adding direction, velocity, frustum or multi-focus planning.
+- Decomposing the player controller before M02.
+- Changing terrain, M2, WMO, liquid, cache or LOD formulas.
+
+## Paths
+
+- Exclusive: `src/domain/streaming/`, `src/tools/verify_streaming_focus.gd`
+- Shared/hotspots: `src/scenes/streaming/streaming_world_loader.gd`,
+  `src/scenes/streaming/eastern_kingdoms_streaming.tscn`,
+  `src/scenes/streaming/kalimdor_streaming.tscn`, renderer diagnostic tools,
+  `docs/modules/world-renderer.md`, this claim
+- Generated/ignored: local extracted assets, renderer caches and Godot import metadata
+
+## Contracts and data
+
+- Public API: immutable `StreamingFocus`; loader `set_streaming_focus` and
+  `refresh_streaming_focus`
+- Source adapter: explicit `streaming_focus_source_path` may reference any `Node3D`
+- Migration: runtime scenes use player focus; capture/probe tools explicitly use
+  their dedicated camera as the source
+- Compatibility: streaming radii/LOD/cache behavior and coordinate contract v2 unchanged
+
+## Dependencies
+
+- Requires: coordinate contract version 2 and golden fixtures at `52e1b2b`
+- Blocks: M01 renderer/test focus exit criterion and later renderer facade extraction
+- External state: no new dependency or proprietary input
+
+## Verification
+
+- Commands: streaming focus contract/integration verifier, renderer baseline
+  manifest/calibration, headless scene smoke, coordination/documentation gates
+- Fixtures: Node3D player-style source and explicit capture-style setter
+- Fidelity evidence: existing seven renderer checkpoints and build-12340 coordinate
+  calibration must remain unchanged
+- Performance budget: one scalar focus snapshot per configured streaming interval;
+  no new per-tile or per-chunk work
+
+## Documentation deliverables
+
+- Inline public API docs: focus value and loader public methods
+- Module specification: inputs/outputs, ownership, lifecycle, failure/recovery and source map
+- Data-flow diagram: player/editor/capture source to focus contract to loader
+- State/sequence diagram: focus sampling and refresh threshold sequence
+
+## Simplicity and naming
+
+- Important names introduced: `StreamingFocus`, `streaming_focus_source_path`,
+  `set_streaming_focus`, `refresh_streaming_focus`
+- Simplest considered solution: one immutable value plus one explicit scene adapter path
+- Rejected complexity/abstractions: provider interface hierarchy, service locator,
+  multi-focus registry and predictive motion fields
+- Unavoidable complexity and justification: editor viewport remains a separate
+  adapter because its camera is owned by `EditorInterface`
+- Measured optimization evidence: not applicable
+
+## Status
+
+- State: ready-for-review
+- Done: contract, runtime/editor/capture migration, headless regression,
+  module diagrams, renderer documentation and cold/warm GUI capture
+- Next: integrator review and merge before typed identity work
+- Blocked by:
+
+## Handoff
+
+- Commit: `7815385`
+- Branch: `work/sindo-main-codex/m01-streaming-focus`
+- Outcome: runtime streaming consumes immutable `StreamingFocus`; Eastern
+  Kingdoms and Kalimdor scenes explicitly follow the player, while capture and
+  terrain/occluder probes explicitly follow their dedicated camera
+- Contract/API: new scene-free `StreamingFocus(GodotWorldPosition)` plus loader
+  `set_streaming_focus`, `refresh_streaming_focus` and
+  `streaming_focus_source_path`; `camera_path` remains only for optional overview positioning
+- Verification: StreamingFocus PASS (`1` contract, `2` runtime scenes, `3`
+  capture tools); coordinate golden fixtures and CoordinateMapper PASS; M00
+  calibration PASS with maximum error `0.000015`; manifest PASS (`7`
+  checkpoints); runtime-cache shutdown PASS; headless runtime scene exit `0`;
+  coordination, documentation, dependency and whitespace checks passed
+- Renderer checkpoint: standard 8-second GUI capture completed `14` images
+  (`7` cold + `7` warm) and wrote schema-1 `report.json`; focus tiles changed
+  through the public contract; no Node/resource/RID leak diagnostic appeared
+- Fidelity: checkpoint camera positions, coordinate contract v2, streaming radii,
+  LOD formulas, cache formats and quality profiles are unchanged; this is
+  regression evidence, not a new `1:1` parity claim
+- Rebuild: none; GUI verification used local ignored extracted assets/cache
+  junctions. Missing worktree `.godot/imported` copies for several incidental M2
+  GLBs produced existing cache-load fallback diagnostics only
+- Remaining risks: the monolithic loader still owns planning/jobs/presentation;
+  direction, velocity, frustum and multiple foci remain M03 planner work. The
+  known timing-dependent zero-reference `ObjectDB` shutdown warning occurred,
+  without Node/resource/RID leak diagnostics
+- Recommended merge order: after coordinate fixtures at `52e1b2b`, before typed
+  identity and renderer-facade extraction
+- Documentation: `world-renderer.md` inputs/outputs, public API, lifecycle,
+  data-flow and sequence diagrams, ownership, recovery, verification,
+  capability matrix, risks and source map updated; `RENDER.md` updated

docs/ARCHITECTURE.md

@@ -36,7 +36,12 @@ TrinityCore/AzerothCore ◄── Network Adapter ◄── Runtime Client
 
 ### Domain
 
-Содержит идентификаторы, value objects, команды и события: `EntityId`, `WowGuid`, `MapPosition`, `SpellId`, `MoveIntent`, `EntityMoved`. Не содержит side effects.
+Содержит идентификаторы, value objects, команды и события: stable authored
+`ContentId`, session-local `EntityId`, opaque wire `WowGuid`, namespaced
+`ServerEntryId`, typed coordinates, `SpellId`, `MoveIntent`, `EntityMoved`.
+Эти identity namespaces не конвертируются неявно и не содержат side effects;
+их lifecycle и mapping определены в
+[`modules/domain-identities.md`](modules/domain-identities.md).
 
 ### Gameplay
 

docs/CAMERA_POSE_SWEEP.md

@@ -0,0 +1,63 @@
+# Renderer Camera Pose Sweep
+
+This offline M00 diagnostic recovers reproducible checkpoint framing when an original-client screenshot has no recorded camera yaw or pitch. It ranks a bounded grid; it does not change renderer or player-camera defaults and does not prove the exact build 12340 camera pose without human approval.
+
+## Camera contract
+
+`capture_render_checkpoints.gd` accepts additive `--camera-yaw-offset` and `--camera-pitch-offset` values in degrees. Yaw rotates the no-roll checkpoint basis around Godot world `Vector3.UP`; pitch then rotates around the camera-local right axis. Zero offsets preserve the manifest target exactly. `--single-pass` captures only `cold_process` and is intended for pose calibration, not performance baselines.
+
+## Workflow
+
+```powershell
+.\tools\sweep_render_checkpoint_camera_pose.ps1 `
+  -ReferenceDirectory 'D:\private-fixtures\wow-3.3.5a-checkpoints' `
+  -Checkpoint elwynn_adt_boundary `
+  -YawOffsets -15,-10,-5,0,5,10,15 `
+  -PitchOffsets -10,-5,0,5,10 `
+  -CameraFovValues 38,50,62 `
+  -ViewportWidth 1280 -ViewportHeight 960 `
+  -WaitSeconds 8
+```
+
+Each candidate receives its own output directory and comparison report. `-CameraFovValues` adds FOV as another bounded grid dimension; omit it to retain the scalar `-CameraFov` workflow and legacy candidate paths. The viewport must exactly match the reference image dimensions; the runner fails on `size_mismatch` instead of inventing a score. The default 8-second wait matches the M00 manifest and is a readiness precondition: lowering it requires evidence that the checkpoint's WMO/M2 content has already appeared. `ranking.json` sorts candidates by mean perceptual error and then changed-pixel ratio. Use `-PlanOnly` to validate the Cartesian grid and output paths without rendering. Run a coarse grid first, then a finer grid around the best candidate.
+
+```mermaid
+flowchart LR
+    Y[Yaw offsets in degrees] --> G[Bounded Cartesian grid]
+    P[Pitch offsets in degrees] --> G
+    G --> C[Single-pass checkpoint captures]
+    R[Original-client reference] --> D[Perceptual comparator]
+    C --> D
+    D --> J[ranking.json]
+    J --> H[Human framing approval]
+```
+
+## Interpretation and recovery
+
+The smallest error is a candidate, not automatic fidelity approval. Geometry, materials, lighting and FOV can move the perceptual optimum away from the true original-client pose. Inspect the best images manually and retain the original reference outside Git. A missing matching reference or candidate is a hard error; correct the checkpoint filter or filenames and rerun. Generated PNG and JSON outputs are disposable local evidence.
+
+## Verification
+
+The headless capture dry-run must report requested yaw and pitch offsets. Comparator `--self-test` covers paired metrics. Sweep `-PlanOnly` covers deterministic grid expansion and output naming without requiring a display. A real ranked sweep requires a display and a private build 12340 reference image.
+
+## Goldshire Inn evidence — 2026-07-12
+
+The private `2560x1440` build 12340 `goldshire_inn_large_wmo` reference was evaluated at FOV 62 degrees. A coarse 5x5 grid over yaw/pitch `[-20, -10, 0, 10, 20]` reduced mean error from `0.099632` at `(0, 0)` to `0.077575` at `(-10, -20)`. Extending pitch produced `0.070901` at `(0, -40)` and `0.063574` at `(0, -60)` with changed-pixel ratio `0.549556`.
+
+These values are invalid camera-pose evidence because the sweep used a 2-second wait. A subsequent readiness audit showed 9 WMO instances and no inn after 2 seconds, 113 instances with the inn visible after 8 seconds, and 328 instances after 15 seconds. The apparent monotonic improvement rewarded grass while the landmark was still absent; it does not demonstrate a spatial/placement defect. The manifest pose remains unchanged pending a ready-scene rerun.
+
+The ready-scene 3x3 rerun at FOV 62 degrees ranked `(yaw=10, pitch=-10)` first with mean error `0.087952` and changed-pixel ratio `0.665527`, compared with `0.101402`/`0.702489` at zero offsets. Human inspection confirms that the inn is present and the direction is plausible. Pitch remains on the tested boundary and the building scale differs from the reference, so these offsets are coarse evidence only; a joint pitch/FOV refinement is required before changing manifest camera values.
+
+## Goldshire joint pitch/FOV refinement — 2026-07-12
+
+A WMO-ready joint grid fixed yaw at 10 degrees and evaluated pitch `[-25, -20, -15, -10, -5]` across FOV `[38, 50, 62]`. Full-frame error ranked FOV 62/pitch -25 first at `0.078843` with changed-pixel ratio `0.667721`. Human inspection rejects it as a manifest calibration: the view is dominated by grass and crops the inn. FOV 38/pitch -10 is closer to the reference building scale but ranks only `0.084220`, and horizontal landmark alignment remains different.
+
+The grid therefore has no approved joint optimum. Full-frame color error continues to trade landmark framing against large terrain regions. The manifest remains unchanged. The next registration method must score an approved inn/road/tree landmark region or explicit landmark coordinates rather than the entire image.
+
+## Common landmark region — 2026-07-12
+
+The comparator accepts an optional common screen rectangle through `--region x,y,width,height`; the sweep runner exposes it as `-ComparisonRegion x,y,width,height`. Coordinates are integer pixels in the shared reference/candidate image space. Both images must have identical dimensions and the rectangle must be fully inside them. Omitting the option preserves full-frame behavior.
+
+The existing 15 WMO-ready Goldshire candidates were rescored inside `[300,100,1400,650]`, covering the reference facade/chimney and nearby trees. ROI error ranked FOV 38/yaw 10/pitch -15 first at `0.081777` with changed-pixel ratio `0.697185`. This is an interior pitch candidate and improves on the full-frame grass preference, but human inspection still rejects manifest calibration: the facade is too large, its upper part is cropped, and the rectangle retains substantial road/terrain pixels. A common rectangle is useful diagnostic weighting, not semantic landmark registration. Explicit approved landmark coordinates or a mask remain necessary.
+
+During this run the sweep orchestration was hardened in two ways: expected comparator exit code `1` is now collected through an explicit child process, and viewport dimensions are explicit. A reference/candidate `size_mismatch` now fails before ranking instead of producing an empty metric.

docs/CODING_STANDARD.md

@@ -237,6 +237,23 @@ TODO/FIXME обязан содержать target/work-package ID или diagnos
 - Медленный понятный reference implementation полезен как oracle для optimized implementation.
 - Сложная оптимизация удаляется или упрощается, если она не даёт измеримого результата.
 
+## Coordinate conversion boundary
+
+- Cross-space world conversions выполняются только через typed API
+  `CoordinateMapper`; ручные world-center offsets, swaps осей и вычисление ADT
+  filename indices из Godot position запрещены.
+- Scene/render adapter МОЖЕТ создать `Vector3` только после получения
+  `GodotWorldPosition` или перевести engine vector в typed scalar value на своей границе.
+- Единственная native world-position формула находится в
+  `src/native/src/wow_chunk_reader.h`, поскольку parser workers не вызывают
+  GDScript. Новая native копия требует отдельного boundary decision и parity fixture.
+- `verify_render_coordinate_calibration.gd` остаётся независимым test oracle;
+  production code не копирует его формулы.
+- Model-local M2/WMO vertex basis и placement orientation не являются world
+  coordinate conversion. Они документируются и тестируются своим format adapter.
+- `verify_coordinate_conversion_boundaries.gd` обязателен при изменении
+  coordinates, native parsers, sky, player, streaming или renderer diagnostics.
+
 ## Review checklist
 
 - Можно ли понять назначение сущности по имени?
@@ -245,6 +262,8 @@ TODO/FIXME обязан содержать target/work-package ID или diagnos
 - Можно ли убрать abstraction без потери correctness/boundary?
 - Есть ли скрытый mutable state или side effect?
 - Не появился ли второй источник истины?
+- Все ли cross-space world coordinates проходят через `CoordinateMapper` или
+  документированную native boundary?
 - Измерена ли сложная optimization?
 - Изолирована и документирована ли неизбежная сложность?
 - Соответствуют ли API docs и diagrams фактическому коду?

docs/M00_FINAL_PAIRED_EVIDENCE.md

@@ -0,0 +1,76 @@
+# M00 Final Paired Evidence — 2026-07-13
+
+## Scope and result
+
+The final local M00 audit used Godot 4.6.1, the existing cache state, the manifest-standard 8-second readiness wait, and `2560x1440` visual candidates. Seven private WoW 3.3.5a build 12340 references produced fourteen cold/warm comparisons with no missing pair. Private images and generated reports remain outside Git.
+
+Every pair exceeded the strict regression tolerance. Comparator exit code `1` means a valid report with measured visual gaps; only codes outside `0/1` are infrastructure failures. This evidence establishes coverage and current differences, not renderer parity.
+
+```powershell
+.\tools\run_render_baseline.ps1 `
+  -Output user://render_baseline_m00_complete_2026-07-13 `
+  -CacheState existing `
+  -WaitSeconds 8 `
+  -MeasureSeconds 0.5 `
+  -ReferenceCheckpointDirectory .\sources\OpenWCReferenceCheckpoints `
+  -VisualComparisonReport user://render_baseline_m00_complete_2026-07-13/visual_comparison.json `
+  -VisualComparisonWidth 2560 `
+  -VisualComparisonHeight 1440
+```
+
+The initial shell timeout detached the canonical capture process after it started. The process completed all fourteen canonical captures and wrote `report.json`; the documented visual-capture and comparator stages were then invoked separately with the same arguments. The final output directory contains both complete reports.
+
+## Paired metrics
+
+| Checkpoint | Pass | Mean perceptual error | Changed-pixel ratio | Classification |
+|---|---|---:|---:|---|
+| `elwynn_adt_boundary` | cold | 0.087258 | 0.634580 | Composition plus terrain/vegetation/material gaps |
+| `elwynn_adt_boundary` | warm | 0.087255 | 0.634598 | Stable against revisit |
+| `elwynn_sky_dusk` | cold | 0.094778 | 0.575956 | Approximate paired camera; sky color, lighting and scene-composition gaps |
+| `elwynn_sky_dusk` | warm | 0.094757 | 0.575898 | Stable against revisit |
+| `elwynn_terrain_overview` | cold | 0.174137 | 0.851791 | Largest composition/framing gap |
+| `elwynn_terrain_overview` | warm | 0.176955 | 0.861271 | Stable gap, not a cold-load artifact |
+| `elwynn_waterfall_liquid` | cold | 0.088629 | 0.706522 | Framing, terrain, liquid and lighting gaps |
+| `elwynn_waterfall_liquid` | warm | 0.087398 | 0.693690 | Stable against revisit |
+| `goldshire_dense_m2` | cold | 0.066893 | 0.575257 | Smallest available paired gap; vegetation/material differences remain |
+| `goldshire_dense_m2` | warm | 0.066927 | 0.575592 | Stable against revisit |
+| `goldshire_inn_large_wmo` | cold | 0.101224 | 0.701835 | WMO is ready; manual framing and presentation gaps remain |
+| `goldshire_inn_large_wmo` | warm | 0.101206 | 0.701855 | Stable against revisit |
+| `gryphon_roost_native_animation` | cold | 0.119467 | 0.882073 | Same build-12340 asset, different real/synthetic placement and uncontrolled animation phase |
+| `gryphon_roost_native_animation` | warm | 0.119471 | 0.882076 | Full-frame metric is diagnostic only; animation observation is human evidence |
+
+Cold and warm values are close for all seven references. The measured gaps are therefore not explained by first-visit cache readiness. Goldshire timing evidence separately demonstrated that the 8-second wait is necessary for WMO publication.
+
+## Animation and sky provenance
+
+The private source corpus preserves exact screenshot bytes; no resize, crop or generated content was used:
+
+| Evidence | SHA-256 | Interpretation |
+|---|---|---|
+| `elwynn_sky_dusk.jpg` | `1fb06836cacae714c76eaf9b8bf7c292fd5e2f2df33eef821bfe4c4a6bd97072` | Build 12340, Elwynn camera position, server time approximately 19:00, UI hidden |
+| `gryphon_roost_native_animation.jpg` | `d3488c741cb8dfe7212198e48332842631a951862a4388b67045338f37357447` | Build 12340 real-world `GryphonRoost01` placement, first visible wing phase |
+| diagnostic animation phase B | `1025572c7ab9fa0d2e500ff026be46eb9c1e6e5447116dbdc3675dd5f44574ab` | Same camera three seconds later; visibly raised wing phase |
+| diagnostic placement context | `b12c0b713a7d75123ed30f5a316b33537331442cd56615aea69214c7cc4e7a42` | Two real Lakeshire placements and surrounding build-12340 scene |
+
+An ADT scan found no `GryphonRoost01` placement in Goldshire. The M00 checkpoint deliberately injects the model there as a synthetic probe. The original-client observation therefore uses two real Lakeshire placements. The three-second pose change establishes `Observed` native animation behavior, but the full-frame comparison cannot establish spatial or animation-phase parity.
+
+## Fidelity interpretation
+
+M00 now has private build 12340 evidence for every required coverage category: terrain, ADT boundary, dense M2, large WMO, liquid, animated M2 and sky transition. The sky reference is approximately paired by map position/time and manually approved composition. Animated-M2 evidence is asset-paired but placement-unpaired because the OpenWC probe is synthetic.
+
+The reports demonstrate current differences and do not claim `1:1`. Camera calibration experiments also show that unknown manual yaw/pitch/FOV cannot be recovered reliably from full-frame color error alone. Region scoring reduces terrain bias but still requires semantic landmark approval.
+
+## Operational risks
+
+A follow-up shutdown ownership fix removed the GUI renderer leaks found by the final visual capture. Before the fix, the focused animated-M2 checkpoint retained 6 mesh, 6 material, 4 shader, 6 texture, 6 instance and associated RenderingDevice RIDs, for 30 resources in use. After the fix, both the focused 8-second capture and a seven-checkpoint single-pass capture completed without Node, resource or RID leak diagnostics.
+
+Godot can still emit a timing-dependent ObjectDB warning for one or more anonymous `RefCounted` objects whose reported reference count is already zero. The warning has no retained Node, renderer resource or RID ownership in the verified captures. It remains recorded as an engine-teardown diagnostic rather than being hidden, but it is distinct from the resolved GUI renderer leak.
+
+## Integrator decision checklist
+
+- Seven required reference checkpoints: cold/warm report complete, `compared=14`, `missing=0`.
+- Animated M2: build-12340 native motion observed in two phases; synthetic/real placement mismatch explicitly classified.
+- Sky transition: build-12340 19:00 evidence present with approximate paired camera and human-approved composition.
+- Renderer visual differences: registered as gaps, not parity claims.
+- GUI renderer RID/resource diagnostics: resolved by explicit shutdown ownership and covered by a headless regression verifier; the residual zero-reference `RefCounted` engine-teardown warning remains tracked separately.
+- Target status, target Evidence and `OPENWC_TARGET_DONE` marker: integrator-only actions.

docs/RENDER_BASELINE.md

@@ -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-ов и результаты;
@@ -179,3 +197,18 @@ flowchart LR
 ```
 
 Ни одна из пяти камер не находится внутри опубликованной scene-tree geometry. Terrain-overview segment пересекает четыре Stormwind WMO groups, large-WMO segment — три Goldshire Inn groups, waterfall segment — liquid surface; ADT boundary и dense-M2 segments не пересекают placement AABB. Поэтому прежнее визуальное впечатление «камера внутри WMO/placements» не подтверждается. Основной paired gap сейчас — неточно воспроизведённые manual look direction/target/FOV reference-кадров: например, автоматический Goldshire target направляет луч через фасад внутрь WMO, тогда как reference был вручную скадрирован на весь фасад. Probe охватывает только scene-tree MeshInstance/MultiMesh; RID-only instances не имеют доступного semantic path и явно исключены из coverage.
+
+## Empirical FOV sweep
+
+В build 12340 `GetCVar("cameraFoV")` возвращает `nil`, а `/console cameraFoV` и `ConsoleExec("cameraFoV")` не выдают значения. Поэтому capture tool поддерживает additive `--camera-fov`, а comparator — `--only`, позволяющий ограничить sweep одним reference checkpoint.
+
+```mermaid
+flowchart LR
+    F[Candidate vertical FOV] --> C[Dedicated checkpoint camera]
+    C --> P[Filtered checkpoint PNGs]
+    R[One original-client reference] --> D[Perceptual comparator --only]
+    P --> D
+    D --> M[Ranked metrics]
+```
+
+Первый sweep обнаружил capture defect: разные FOV иногда создавали одинаковые hashes, потому что scene camera могла перехватить viewport после входа в tree. Capture теперь вызывает `camera.make_current()` после добавления world и перед каждым checkpoint. После исправления ADT-boundary ranking стал: `26° → 0.079588`, `38° → 0.079633`, `50° → 0.084353`, `62° → 0.088360`, `86° → 0.097993` mean error. Plateau `26–38°` и несовпавший changed-pixel optimum показывают доминирование manual look direction/framing; эти данные не обосновывают изменение нормативного manifest FOV `62°`. Для настоящей калибровки reference capture должен сохранять воспроизводимые yaw/pitch/zoom или независимый projection fixture.

docs/adr/0001-canonical-world-coordinates.md

@@ -0,0 +1,183 @@
+# ADR 0001: Canonical world coordinate contract
+
+- Status: Accepted for M01 contract implementation
+- Date: 2026-07-13
+- Work packages: `M01-FND-COORDS-001`, corrected by `M01-FND-COORD-TILE-AXIS-002`
+- Decision owners: M01 foundation/integration owners
+
+## Context
+
+OpenWC currently performs coordinate conversion in native ADT/WDT loaders,
+`StreamingWorldLoader`, sky, player and renderer diagnostic scripts. The same
+numbers are frequently carried in `Vector3` or dictionaries, so the coordinate
+space is implicit. Existing names also mix ADT filename indices, renderer X/Z
+indices and MDDF/MODF placement fields.
+
+M00 recorded five positions observed in WoW 3.3.5a build 12340. They verify the
+current client-position to Godot-position arithmetic within `0.002` yard, but
+they do not define a cross-layer contract and do not prove camera composition
+or visual parity.
+
+Independent references agree on a 64 by 64 ADT grid and an approximately
+`533.3333` yard tile size. They do not all use the word “canonical” for the same
+axis order. OpenWC therefore needs names tied to observable formats instead of
+adopting an internal convention from one reference project.
+
+## Decision
+
+### Canonical position
+
+`CanonicalWowWorldPosition(X, Y, Z)` preserves the numeric X/Y/Z order used by
+the WoW client, movement protocol and TrinityCore/AzerothCore world positions.
+X and Y are horizontal; Z is height. Units are WoW yards.
+
+`ServerWorldPosition` is a distinct type but converts component-for-component
+to canonical. The type boundary prevents a server record from being passed
+directly to renderer code and leaves room for adapter validation without a
+silent axis swap.
+
+### World extent and ADT indices
+
+The contract uses:
+
+```text
+ADT_TILE_SIZE_YARDS = 1600 / 3
+ADT_TILES_PER_MAP_AXIS = 64
+WOW_WORLD_HALF_EXTENT_YARDS = 32 * ADT_TILE_SIZE_YARDS
+
+tileX = floor(32 - canonical.Y / ADT_TILE_SIZE_YARDS)
+tileY = floor(32 - canonical.X / ADT_TILE_SIZE_YARDS)
+```
+
+`AdtTileCoordinate(tile_x, tile_y)` always means the indices in
+`Map_tileX_tileY.adt`. Results are intentionally not clamped: the exact
+south-east extent produces index 64 and remains diagnosable as out of bounds.
+Normal valid indices are 0 through 63.
+
+An `AdtTileLocalPosition` is measured east and south from the tile's
+north-west corner. Filename `tile_x` and MCNK `chunk_x` grow east; filename
+`tile_y` and MCNK `chunk_y` grow south, with valid indices 0 through 15. These
+direction names avoid pretending that ADT file axes are Godot X/Z axes.
+
+### ADT placement fields
+
+MDDF/MODF position fields are represented in on-disk X/height/Z order:
+
+```text
+adt.X      = halfExtent - canonical.X
+adt.height = canonical.Z
+adt.Z      = halfExtent - canonical.Y
+```
+
+Model-local MDDF/MODF Euler corrections are not world orientation. They remain
+outside this contract until a placement-orientation package has format- and
+model-specific fixtures.
+
+### Godot renderer basis
+
+The compatibility renderer keeps one Godot unit equal to one WoW yard and uses
+Y-up coordinates from the north-west map extent:
+
+```text
+godot.X = halfExtent - canonical.Y  # east
+godot.Y = canonical.Z               # up
+godot.Z = halfExtent - canonical.X  # south
+```
+
+`GodotWorldPosition` contains scalars rather than `Vector3`. A scene/render
+adapter may construct `Vector3` only at its boundary.
+
+### World yaw
+
+Server/canonical yaw zero faces increasing WoW X; positive yaw turns toward
+increasing WoW Y. In the mapped Godot basis, Godot forward `-Z` and positive
+Y-axis yaw produce the same numeric world angle. Mapper conversions therefore
+normalize the value to `[-PI, PI)` without adding an offset.
+
+This identity applies to world-facing yaw only. It does not apply to M2/WMO
+asset axes or placement Euler triples.
+
+### Contract version 2 correction evidence
+
+Contract version 1 incorrectly calculated filename `tile_x` from canonical X
+and `tile_y` from canonical Y. The private WotLK corpus contains the observed
+Elwynn point in `Azeroth_31_49.adt`, SHA-256
+`18185B5FAC9566D9C57A9C19ABD75F108370D1795639B6077167C0EFD3672FAE`; the
+transposed `Azeroth_49_31.adt` does not exist. Raw MCNK headers in that file
+show `indexX` decreasing world Y (east) and `indexY` decreasing world X (south).
+OpenRealm independently calculates filename X from world Y and filename Y from
+world X. Contract version 2 corrects the formulas before any consumer migration.
+
+### Enforced conversion boundaries
+
+GDScript production consumers use `CoordinateMapper` for canonical/Godot and
+Godot/ADT tile-local conversion. `StreamingWorldLoader`, player spawn/terrain
+sampling, sky/area lookup and terrain diagnostics may construct `Vector3` only
+at their scene/tool boundary.
+
+The native ADT/WDT parser path retains one equivalent formula definition in
+`src/native/src/wow_chunk_reader.h`; worker parsers cannot call GDScript. The
+M00 renderer calibration keeps one independent formula as a test oracle so a
+shared mapper defect cannot make both implementation and evidence agree.
+Repository verification rejects additional world-center, world/tile or named
+WoW/Godot formulas outside those explicit exceptions. Model-local M2/WMO basis
+transforms are separate format contracts and are not classified as world-space mapping.
+
+## Alternatives considered
+
+### Make renderer coordinates canonical
+
+Rejected because protocol, database and ADT adapters would silently inherit a
+presentation-specific offset and Y-up basis.
+
+### Adopt WoWee's internal canonical axis names unchanged
+
+Rejected because that reference swaps server X/Y into its chosen north/west
+ordering. OpenWC preserves observable client/server field names and makes the
+render/ADT transformations explicit instead.
+
+### Use `Vector3` plus comments
+
+Rejected because comments cannot prevent server, ADT and Godot values from
+being passed across the wrong boundary.
+
+### Generic vector-space or matrix framework
+
+Rejected as unnecessary complexity for fixed affine transforms and integer
+grid ownership rules.
+
+## Consequences
+
+- Network and server-data adapters can expose typed positions without knowing
+  Godot.
+- Renderer consumers must explicitly map and then create Godot vectors at their
+  own boundary.
+- ADT filename indices can no longer be confused with renderer X/Z tile names.
+- GDScript world/tile consumers use mapper APIs; renderer distance and LOD math
+  remains ordinary Godot-space geometry.
+- Native ADT/WDT loaders share one boundary formula and the M00 calibration
+  keeps one independent non-production oracle.
+- New manual axis conversions are review/test violations enforced by the
+  repository-wide source gate.
+- Persisted schemas are unchanged. Future serialized positions must include an
+  explicit coordinate-space/version discriminator.
+
+## Verification
+
+- Five M00 build-12340 client camera positions map to the recorded Godot
+  checkpoints within `0.002` yard.
+- Server, ADT placement, Godot and tile-local conversions round-trip.
+- Exact center, tile, chunk and world-extent boundaries have explicit tests.
+- The observed Elwynn position resolves to the real `Azeroth_31_49.adt` file;
+  MCNK `(0,0)` to `(15,15)` origins confirm X-east and Y-south chunk growth.
+- World-yaw normalization and round-trip cases cover cardinal angles and wrap.
+- Direct Godot/ADT tile-local conversions round-trip and production consumers
+  are checked by `verify_coordinate_conversion_boundaries.gd`.
+
+## References
+
+- [TrinityCore GridDefines](https://github.com/TrinityCore/TrinityCore/blob/master/src/server/game/Grids/GridDefines.h)
+- `reference/open-realm/games/world-of-warcraft/renderer/wow/r_wowmap_adt.c`
+- `reference/open-realm/games/world-of-warcraft/renderer/wow/r_wowmap_objects.c`
+- `reference/WoWee/include/core/coordinates.hpp`
+- [`../M00_FINAL_PAIRED_EVIDENCE.md`](../M00_FINAL_PAIRED_EVIDENCE.md)

docs/adr/0002-domain-identity-namespaces.md

@@ -0,0 +1,122 @@
+# ADR 0002: Separate domain identity namespaces
+
+- Status: Accepted for M01 contract implementation
+- Date: 2026-07-13
+- Work package: `M01-FND-DOMAIN-IDENTITIES-001`
+- Decision owners: M01 foundation/integration owners
+
+## Context
+
+OpenWC must relate authored content, runtime objects, WoW protocol objects and
+TrinityCore/AzerothCore rows. All four domains can expose an integer or string,
+but their identity lifetimes and collision rules are different. A raw `int`, a
+generic `id` field or one universal ID class would allow an entity sequence to
+be persisted as content identity, a database entry to be sent as a wire GUID,
+or equal entry numbers from different tables to collide.
+
+The Content Project requires stable references before server entries are
+allocated. Runtime entities require cheap session-local identity even when no
+server object exists. WoW 3.3.5a GUIDs carry opaque 64 wire bits whose semantic
+decomposition must be established by protocol fixtures. Server templates use
+numeric entries scoped by an adapter/table namespace.
+
+## Decision
+
+### ContentId
+
+`ContentId` stores canonical lowercase UUID text in the `8-4-4-4-12` shape.
+It is the only identity in this decision intended for stable authored-content
+references and serialization. Construction normalizes whitespace and letter
+case; `is_valid()` reports malformed input without crashing an import.
+
+The value validates text shape, not UUID version or variant bits. A future
+Content Project allocator chooses the UUID generation policy and owns duplicate
+detection. Every persisted schema that contains a `ContentId` still declares
+its own schema version and field migration.
+
+### EntityId
+
+`EntityId` stores a positive integer allocated by one runtime session owner.
+It is valid only inside that session and must not be persisted as content,
+protocol or server identity. Sequence reuse policy belongs to the future entity
+registry, not the value object.
+
+### WowGuid
+
+`WowGuid` stores opaque `high_32_bits` and `low_32_bits` integers. Each word is
+validated against `0..0xffffffff`, preserving every unsigned wire bit without
+combining it into GDScript's signed 64-bit integer. The all-zero value remains
+an observable protocol sentinel and receives no gameplay interpretation here.
+
+High-type masks, packed-GUID codecs and object-kind extraction are explicitly
+deferred to the build-12340 protocol package and require packet fixtures.
+
+### ServerEntryId
+
+`ServerEntryId` stores a positive numeric entry together with a normalized,
+non-empty adapter/table namespace. Equal numbers in different namespaces are
+different identities. Mapping a server entry to a `ContentId` is explicit
+adapter/snapshot data; neither value derives the other.
+
+### Equality and keys
+
+The types expose domain-named `equals` methods because `RefCounted` `==`
+compares object references. Stable keys are available only where their lifetime
+allows them: `ContentId.to_key()`, `WowGuid.to_hex_string()` and
+`ServerEntryId.to_key()`. `EntityId` exposes only `to_debug_key()` to discourage
+persistence.
+
+## Alternatives considered
+
+### One generic `Id<T>` abstraction
+
+Rejected because GDScript has no compile-time generic type distinction and the
+shared API would obscure different validation, lifetime and persistence rules.
+
+### Use strings everywhere
+
+Rejected because prefixes are a convention rather than a type boundary and
+would still permit accidental cross-layer assignment.
+
+### Store WowGuid in one integer
+
+Rejected because unsigned 64-bit GUIDs can exceed GDScript's positive signed
+integer range. Split words preserve the wire representation losslessly.
+
+### Use server entries as ContentId
+
+Rejected because entries are allocated by a particular backend/table, can
+collide between namespaces and do not exist while authoring offline content.
+
+### Generate UUIDs inside ContentId
+
+Rejected because randomness/allocation is a side effect requiring duplicate,
+fixture and deterministic-build policy. This value object only normalizes and
+validates an allocator-provided value.
+
+## Consequences
+
+- Cross-layer contracts must name the identity type they accept.
+- Content references remain stable before and after server deployment.
+- Runtime entity registries need explicit mappings to wire GUIDs/content IDs.
+- Server adapters must supply a namespace and maintain entry-to-content maps.
+- Malformed external values remain representable long enough for adapters to
+  produce diagnostics, but consumers must call the relevant validation method.
+- Additional typed IDs such as map, spell, item and quest remain separate
+  follow-up contracts rather than aliases of these four values.
+
+## Verification
+
+- UUID normalization, shape validation and value equality are fixture-tested.
+- Zero/positive session sequences establish `EntityId` validity boundaries.
+- Maximum unsigned GUID words round-trip to exactly sixteen hexadecimal digits;
+  overflow is rejected and zero remains detectable.
+- Equal server entry numbers in creature/gameobject namespaces do not compare equal.
+- Dependency search verifies that identity values do not inherit Node/Resource
+  or expose `Vector3`.
+
+## References
+
+- [RFC 9562: Universally Unique IDentifiers](https://www.rfc-editor.org/rfc/rfc9562.html)
+- [`../ARCHITECTURE.md`](../ARCHITECTURE.md)
+- [`../../targets/roadmap/01-foundation-and-data.md`](../../targets/roadmap/01-foundation-and-data.md)

docs/modules/README.md

@@ -7,6 +7,8 @@
 | Module | Current status | Primary specification |
 |---|---|---|
 | 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) |
 | 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) |

docs/modules/coordinate-mapping.md

@@ -0,0 +1,255 @@
+# Coordinate Mapping
+
+## Metadata
+
+| 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`, `M01-QAR-SERVER-SPAWN-RENDERER-001` |
+| Owners | Foundation/domain |
+| Last verified | Worktree `work/sindo-main-codex/m01-server-spawn-renderer`, 2026-07-13 |
+| Profiles/capabilities | All profiles; contract version 2 |
+
+## Purpose
+
+Provide scene-free value objects and one pure `CoordinateMapper` for positions,
+ADT grid ownership and world-facing yaw. The module makes every source space
+explicit before renderer, network, gameplay and authoring consumers migrate.
+
+## Non-goals
+
+- Reading ADT, packet, SQL or scene data.
+- Constructing `Vector3`, `Transform3D`, Node or Resource values.
+- Correcting M2/WMO local axes or MDDF/MODF Euler rotations.
+- Selecting maps, validating terrain height or owning streaming focus.
+- Persisting coordinate values in this work package.
+
+## Context and boundaries
+
+```mermaid
+flowchart LR
+    Server[Server / movement X,Y,Z] --> ServerPosition[ServerWorldPosition]
+    ADT[MDDF/MODF X,height,Z] --> AdtPosition[AdtPlacementPosition]
+    ServerPosition --> Mapper[CoordinateMapper]
+    AdtPosition --> Mapper
+    Mapper --> Canonical[CanonicalWowWorldPosition]
+    Canonical --> Tile[AdtTileCoordinate + AdtTileLocalPosition]
+    Canonical --> GodotPosition[GodotWorldPosition]
+    GodotPosition --> Adapter[Future scene/render adapter]
+    Adapter --> Vector[Vector3 at boundary]
+    Scene[Node / Camera3D / scene lookup] -. forbidden .-> Mapper
+```
+
+Allowed dependencies:
+
+- GDScript scalar math and `RefCounted` lifetime;
+- other value objects in `src/domain/coordinates`;
+- callers in network, gameplay, render and server-data adapters.
+
+Forbidden dependencies:
+
+- `Node`, `Resource`, SceneTree, Camera3D and global scene lookup;
+- packet buffers, SQL rows, asset parsers and renderer state;
+- `Vector3` as a public mapper input or output;
+- model-specific placement corrections.
+
+## Public API
+
+| Symbol | Kind | Purpose | Thread/lifetime | Errors |
+|---|---|---|---|---|
+| `CanonicalWowWorldPosition` | Immutable value | Client/server X/Y/Z in yards | Any thread; caller-owned reference | No bounds validation |
+| `ServerWorldPosition` | Immutable value | Server/wire X/Y/Z in yards | Any thread; caller-owned reference | No adapter validation |
+| `AdtPlacementPosition` | Immutable value | MDDF/MODF X/height/Z fields | Any thread; caller-owned reference | No file validation |
+| `GodotWorldPosition` | Immutable value | Godot east/up/south scalars | Any thread; caller-owned reference | Does not create `Vector3` |
+| `AdtTileCoordinate` | Immutable value | `Map_tileX_tileY.adt` indices | Any thread; caller-owned reference | `is_within_map_grid()` reports invalid indices |
+| `AdtTileLocalPosition` | Immutable value | East/height/south offsets from tile north-west corner | Any thread; caller-owned reference | Values are intentionally unclamped |
+| `AdtChunkCoordinate` | Immutable value | MCNK X-east/Y-south indices inside one tile | Any thread; caller-owned reference | `is_within_map_grid()` reports invalid indices |
+| `CanonicalWowWorldYaw` | Immutable value | Canonical world yaw in radians | Any thread; caller-owned reference | Constructor does not normalize |
+| `ServerWorldYaw` | Immutable value | Movement orientation in radians | Any thread; caller-owned reference | Constructor does not normalize |
+| `GodotWorldYaw` | Immutable value | Godot Y-axis world yaw in radians | Any thread; caller-owned reference | Constructor does not normalize |
+| `CoordinateMapper.server_to_canonical` / inverse | Pure static methods | Preserve server X/Y/Z as canonical | Synchronous; new result value | Null input is a caller contract violation |
+| `CoordinateMapper.canonical_to_godot` / inverse | Pure static methods | Apply Y-up renderer basis and map offset | Synchronous; new result value | Non-finite scalars propagate |
+| `CoordinateMapper.godot_to_adt_tile` | Pure static method | Resolve filename indices from typed renderer position | Synchronous; new result value | Result remains unclamped |
+| `CoordinateMapper.godot_to_adt_tile_local` | Pure static method | Resolve east/height/south offsets from typed renderer position | Synchronous; new result value | Caller validates ownership/range |
+| `CoordinateMapper.adt_tile_local_to_godot` | Pure static method | Compose typed renderer position from tile/local values | Synchronous; new result value | Non-finite scalars propagate |
+| `CoordinateMapper.canonical_to_adt_placement` / inverse | Pure static methods | Convert ADT placement field basis | Synchronous; new result value | Non-finite scalars propagate |
+| `CoordinateMapper.canonical_to_adt_tile` | Pure static method | Compute unclamped filename indices | Synchronous; new result value | Out-of-map result remains invalid |
+| `CoordinateMapper.canonical_to_adt_tile_local` / inverse | Pure static methods | Split/reconstruct tile-local position | Synchronous; new result value | Caller validates tile ownership |
+| `CoordinateMapper.adt_tile_local_to_chunk` | Pure static method | Compute unclamped MCNK indices | Synchronous; new result value | Boundary/out-of-range remains diagnosable |
+| World-yaw mapper methods | Pure static methods | Normalize and cross the world-basis boundary | Synchronous; new result value | Non-finite input is unsupported |
+
+## Inputs and outputs
+
+| Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
+|---|---|---|---|---|---|
+| Input | `ServerWorldPosition`, `ServerWorldYaw` | Future protocol/server adapter | `CoordinateMapper` | Immutable caller value | Any thread, call duration |
+| 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 | `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 |
+
+Side effects:
+
+- none;
+- no scene mutation, file/cache write, network send, database access or logging.
+
+## Data flow
+
+```mermaid
+flowchart LR
+    ServerFixture[Pinned AzerothCore spawn] --> FixtureVerifier[Golden fixture verifier]
+    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]
+    Canonical -->|north-west edge offsets| Local[AdtTileLocalPosition]
+    Local -->|floor offset / chunk size| Chunk[AdtChunkCoordinate]
+    Canonical -->|half extent - Y; Z; half extent - X| Godot[GodotWorldPosition]
+    Godot -->|typed direct adapter| Tile
+    Godot -->|typed direct adapter| Local
+    Tile -->|tile plus local| Godot
+    ServerYaw[ServerWorldYaw] -->|normalize only| CanonicalYaw[CanonicalWowWorldYaw]
+    CanonicalYaw -->|same numeric world angle| GodotYaw[GodotWorldYaw]
+```
+
+## Lifecycle/state
+
+The module is stateless. Each call reads immutable scalar inputs and returns a
+new value object. There is no initialization, shutdown, cancellation or retry
+state machine.
+
+## Main sequence
+
+No cross-layer asynchronous sequence occurs inside this module. Producers parse
+or validate their external format first, call the mapper synchronously, and
+then pass only typed results across the next boundary.
+
+## Ownership, threading and resources
+
+- Value objects own only scalar fields and, for chunks, one immutable tile reference.
+- Callers own returned `RefCounted` references.
+- Methods do not mutate inputs or shared state and are safe for worker use.
+- No Node, RID, file, socket, database or cache resource is acquired.
+
+## Errors, cancellation and recovery
+
+| Failure | Detection | Behavior | Diagnostic | Recovery |
+|---|---|---|---|---|
+| Tile/chunk outside standard grid | `is_within_map_grid()` | Unclamped indices are preserved | Caller reports source and map context | Reject or apply explicit map policy |
+| Tile-local value outside half-open tile | Consumer boundary validation | Value is preserved | Caller reports source coordinate | Recompute ownership or reject malformed input |
+| Null value object | Static typing/call failure | Programming contract violation | GDScript error with call site | Fix producer; no fallback value |
+| NaN/infinite scalar | Adapter validation | Arithmetic propagates invalid value | Adapter must report source field | Reject malformed external input |
+
+There is no cancellation because every conversion is constant-time scalar math.
+
+## Configuration and capabilities
+
+| Setting/capability | Default | Profile | Runtime mutable | Effect |
+|---|---|---|---|---|
+| Contract version | 2 | All | No | Corrected filename/chunk axes in ADR 0001 |
+| Godot units per WoW yard | 1 | `Blizzlike335` and current tools | No | Preserves current renderer scale |
+| ADT grid | 64 tiles/axis, 16 chunks/tile | WotLK 3.3.5a | No | Defines index and boundary math |
+
+## Persistence, cache and migration
+
+Production code adds no persisted format, cache or migration. Test schema 1 in
+`coordinate_golden_points.json` persists explicit source provenance, coordinate
+contract version 2, tolerances, source-space values and expected outputs. It
+contains no proprietary bytes, database dump or original-client image. Existing
+dictionaries, native `Vector3` payloads and renderer conversion helpers remain compatible.
+Consumer migration is ordered after this contract and must remove old manual
+conversions only after its producer/consumer tests pass.
+
+Any future serialized coordinate must store a schema version and explicit space;
+raw three-number arrays are not an accepted new persistence contract.
+
+## Diagnostics and observability
+
+- Logs: none in production mapper.
+- Metrics: none; conversion cost is constant and outside frame-budget concern.
+- Debug views: headless contract probe prints one PASS summary.
+- Correlation IDs: supplied by external adapters if an invalid source is reported.
+
+## Verification
+
+- 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`.
+- Server-spawn renderer contract: `src/tools/verify_server_spawn_renderer.gd`
+  validates the dedicated manifest against the same pinned fixture before GUI capture.
+- Integration/E2E: sky, player, streamer and terrain probe 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)`;
+  independent reference formulas are recorded in ADR 0001.
+- Performance budgets: constant-time arithmetic; no scene or file access.
+- Manual diagnostics: not required for the pure contract; renderer checkpoints
+  are required when consumers migrate.
+
+## Extension points
+
+- Add typed map IDs around positions without changing axis semantics.
+- Add a format-specific placement-orientation adapter with its own fixtures.
+- Add serialization only with explicit space/version fields and migrations.
+- Add consumer adapters that construct engine-native vectors at their boundary.
+
+## Capability status
+
+| Capability | Status | Evidence | Gap/next step |
+|---|---|---|---|
+| Canonical/server/Godot position mapping | Implemented | Headless round-trip, five M00 golden points and migrated GDScript consumers | Network/server adapters remain future consumers |
+| ADT placement mapping | Implemented | Synthetic/direct round-trip fixtures | Compare native parsed placements during migration |
+| ADT tile/local/chunk ownership | Implemented | Center/extent boundaries, raw `Azeroth_31_49.adt` evidence and direct Godot adapter round-trip | Native parser remains explicit boundary |
+| World-facing yaw mapping | Implemented | Cardinal/wrap round-trip fixtures | Placement Euler remains separate |
+| 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 | 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
+
+- Native ADT/WDT parsing retains one shared boundary formula because worker
+  parsers cannot call GDScript; the gate prevents additional definitions.
+- Contract version 1 briefly transposed ADT filename/chunk axes; version 2 fixes
+  the defect before any consumer migration.
+- MDDF/MODF rotation comments and implementations disagree across existing paths;
+  this package deliberately does not generalize them into world yaw.
+- Finite-number validation belongs to external format adapters and is not yet implemented.
+- Arithmetic agreement does not prove terrain, placement, camera direction or visual parity.
+- The golden server row is verified against pinned AzerothCore data only; no
+  TrinityCore equivalence claim is made without a pinned populated TDB snapshot.
+
+## Source map
+
+| Path | Responsibility |
+|---|---|
+| `src/domain/coordinates/coordinate_mapper.gd` | Constants and all coordinate-axis conversions |
+| `src/domain/coordinates/*_position.gd` | Immutable typed position values |
+| `src/domain/coordinates/adt_tile_coordinate.gd` | ADT filename tile indices and bounds |
+| `src/domain/coordinates/adt_chunk_coordinate.gd` | MCNK indices and bounds |
+| `src/domain/coordinates/*_yaw.gd` | Immutable typed world-facing yaw values |
+| `src/tools/verify_coordinate_mapper.gd` | Headless fixtures and boundary regressions |
+| `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/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
+
+- ADR: [`../adr/0001-canonical-world-coordinates.md`](../adr/0001-canonical-world-coordinates.md)
+- M00 evidence: [`../M00_FINAL_PAIRED_EVIDENCE.md`](../M00_FINAL_PAIRED_EVIDENCE.md)
+- Architecture: [`../ARCHITECTURE.md`](../ARCHITECTURE.md)
+- Testing rules: [`../TESTING.md`](../TESTING.md)

docs/modules/domain-identities.md

@@ -0,0 +1,232 @@
+# Domain Identities
+
+## Metadata
+
+| Field | Value |
+|---|---|
+| Status | Implemented |
+| Target/work package | `M01-FND-DOMAIN-IDENTITIES-001` |
+| Owners | Foundation/domain |
+| Last verified | Worktree `work/sindo-main-codex/m01-domain-identities`, 2026-07-13 |
+| Profiles/capabilities | All profiles; identity contract version 1 |
+
+## Purpose
+
+Provide non-interchangeable, scene-free identity values for authored content,
+runtime entities, WoW wire objects and namespaced server entries. Each value
+states its lifetime and serialization rules instead of exposing a generic `id`.
+
+## Non-goals
+
+- Allocating, reserving or globally registering IDs.
+- Parsing packet bytes or server database rows.
+- Mapping GUID high types or server entries to gameplay object kinds.
+- Defining Content Project, snapshot or replay schemas.
+- Replacing future typed map/spell/item/quest/display/sound IDs.
+
+## Context and boundaries
+
+```mermaid
+flowchart LR
+    Authoring[Content Project allocator] --> ContentId[ContentId]
+    Session[Entity registry] --> EntityId[EntityId]
+    Wire[Build 12340 packet adapter] --> WowGuid[WowGuid]
+    Server[Core snapshot adapter] --> ServerEntry[ServerEntryId]
+    ContentId --> Mapping[Explicit identity mapping records]
+    EntityId --> Mapping
+    WowGuid --> Mapping
+    ServerEntry --> Mapping
+    Mapping --> Consumers[Gameplay / network / authoring consumers]
+    Raw[Raw int or string] -. forbidden across boundary .-> Consumers
+```
+
+Allowed dependencies:
+
+- GDScript scalar/string operations and `RefCounted` lifetime;
+- callers in content, gameplay, network and server adapter layers.
+
+Forbidden dependencies:
+
+- Node, Resource, SceneTree, renderer and UI state;
+- packet buffers, SQL connections or database table implementations;
+- implicit conversion between identity namespaces;
+- random/global allocation inside the value objects.
+
+## Public API
+
+| Symbol | Kind | Purpose | Thread/lifetime | Errors |
+|---|---|---|---|---|
+| `ContentId` | Immutable value | Stable authored identity as canonical lowercase UUID text | Any thread; persisted content lifetime | `is_valid()` reports malformed shape |
+| `ContentId.equals` | Pure method | Value equality across references | Call duration | Null compares false |
+| `ContentId.to_key` | Pure method | Canonical serialization/dictionary key | Stable across schema lifetime | Caller must validate first |
+| `EntityId` | Immutable value | Positive session-local runtime sequence | One runtime session | `is_valid()` rejects zero/negative |
+| `EntityId.equals` | Pure method | Equality within an explicitly shared session | Call duration | Cross-session comparison is a caller error |
+| `EntityId.to_debug_key` | Pure method | Non-persistent diagnostic label | Session/log lifetime | Must not be serialized as content |
+| `WowGuid` | Immutable value | Opaque unsigned high/low wire words | Packet/replay/entity mapping lifetime | `has_valid_word_ranges()` reports overflow |
+| `WowGuid.is_empty` | Pure method | Detect all-zero wire sentinel | Call duration | Does not assign semantic meaning |
+| `WowGuid.to_hex_string` | Pure method | Sixteen-digit diagnostic/replay key | Wire/replay lifetime | Caller validates ranges first |
+| `ServerEntryId` | Immutable value | Adapter/table namespace plus positive entry | Snapshot/deployment mapping lifetime | `is_valid()` rejects missing namespace/non-positive entry |
+| `ServerEntryId.to_key` | Pure method | Namespaced mapping key | Snapshot/schema lifetime | Caller validates first |
+
+## Inputs and outputs
+
+| Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
+|---|---|---|---|---|---|
+| Input | UUID text | Future Content Project allocator/parser | `ContentId` | Copied normalized string | Build/content lifetime |
+| Input | Session sequence | Future entity registry | `EntityId` | Copied integer | One runtime session |
+| Input | Two unsigned 32-bit words | Future build-12340 packet codec | `WowGuid` | Copied integers | Packet/replay/entity lifetime |
+| Input | Namespace and numeric entry | Future core snapshot adapter | `ServerEntryId` | Copied normalized string/integer | Snapshot/deployment lifetime |
+| Output | Validation/equality/key results | Identity values | Adapters/registries/schemas | Returned scalar/string | Call duration |
+
+Side effects:
+
+- none;
+- no allocation registry, random generation, file/cache write, packet read,
+  database query, scene mutation or logging.
+
+## Data flow
+
+```mermaid
+flowchart TD
+    ContentSource[Authored document] -->|UUID text| ContentId
+    ServerRow[Backend table row] -->|adapter + table + entry| ServerEntryId
+    Packet[World packet] -->|high/low wire words| WowGuid
+    Registry[Session entity allocator] -->|positive sequence| EntityId
+    ServerEntryId --> DeployMap[Explicit deployment mapping]
+    ContentId --> DeployMap
+    WowGuid --> RuntimeMap[Explicit runtime mapping]
+    EntityId --> RuntimeMap
+    DeployMap --> Snapshot[Versioned snapshot/change set]
+    RuntimeMap --> WorldState[Session world state]
+```
+
+## Lifecycle/state
+
+```mermaid
+stateDiagram-v2
+    state ContentIdentity {
+        [*] --> Parsed
+        Parsed --> Persisted: valid ContentId
+        Persisted --> Referenced
+    }
+    state RuntimeIdentity {
+        [*] --> Allocated
+        Allocated --> Active
+        Active --> Released: session owner removes entity
+        Released --> [*]
+    }
+    state ExternalIdentity {
+        [*] --> Observed
+        Observed --> Mapped: WowGuid or ServerEntryId
+        Mapped --> Stale: disconnect or snapshot replacement
+        Stale --> [*]
+    }
+```
+
+The values themselves are stateless and immutable. Allocation, release,
+mapping and stale-state ownership belong to future registries/adapters.
+
+## Main sequence
+
+Identity construction and validation are synchronous. An external adapter reads
+its format, constructs the matching value, validates it, then publishes an
+explicit mapping or typed domain event. No value object performs I/O or retries.
+
+## Ownership, threading and resources
+
+- Values own only copied strings/integers and are caller-owned `RefCounted` references.
+- Public methods do not mutate values or shared state and are worker-safe.
+- Content/session/wire/server mapping records are owned by their future layer,
+  not by these values.
+- No Node, RID, file, socket, database, lock or cache resource is acquired.
+
+## Errors, cancellation and recovery
+
+| Failure | Detection | Behavior | Diagnostic | Recovery |
+|---|---|---|---|---|
+| Malformed ContentId | `is_valid()` | Invalid value remains inspectable | Source field/path supplied by parser | Regenerate or repair authored ID |
+| Invalid EntityId sequence | `is_valid()` | Registry must reject publication | Session/correlation context | Fix allocator/session mapping |
+| GUID word overflow | `has_valid_word_ranges()` | Codec must reject packet/replay value | Packet offset/opcode context | Reject malformed input; do not truncate |
+| Empty GUID | `is_empty()` | Preserved as protocol sentinel | Adapter decides whether field permits empty | Apply opcode/field-specific rule |
+| Missing server namespace/entry | `is_valid()` | Snapshot adapter rejects mapping | Backend/table/row context | Correct adapter schema mapping |
+| Unknown/stale mapping | Registry/snapshot lookup | No implicit numeric fallback | Typed IDs in diagnostic | Refresh snapshot/session or reject event |
+
+There is no cancellation inside constant-time value operations.
+
+## Configuration and capabilities
+
+| Setting/capability | Default | Profile | Runtime mutable | Effect |
+|---|---|---|---|---|
+| Identity contract version | 1 | All | No | Four separate namespaces and validation rules |
+| ContentId text form | Lowercase `8-4-4-4-12` UUID | Authoring/runtime/tools | No | Stable persisted key |
+| GUID decomposition | Opaque two-word storage | `wotlk_335a_build_12340` | No | Prevents unverified high-type assumptions |
+
+## Persistence, cache and migration
+
+- `ContentId.uuid_text` is the only stable persisted identity introduced here.
+- Containing schemas must store their own schema version and duplicate/reference policy.
+- `EntityId` must never be persisted across sessions.
+- `WowGuid` may appear in versioned packet replays as explicit high/low words or
+  the exact sixteen-digit hex form; a replay schema owns that choice.
+- `ServerEntryId` may appear in snapshots only with both namespace and entry.
+- This package is additive and migrates no existing data or cache.
+
+## Diagnostics and observability
+
+- Stable diagnostics use `ContentId.to_key`, `WowGuid.to_hex_string` and
+  `ServerEntryId.to_key`.
+- Runtime diagnostics may use `EntityId.to_debug_key` with a session correlation ID.
+- Production metrics/logging belong to registries and adapters; values emit none.
+
+## Verification
+
+- Contract test: `src/tools/verify_domain_identities.gd`.
+- Fixtures cover UUID normalization/malformed shape, positive/zero session IDs,
+  maximum/overflow GUID words, zero GUID and cross-table server entry collisions.
+- Dependency gate confirms no Node/Resource/Vector3 exposure.
+- Fidelity boundary: GUID bit meaning remains unclaimed until build-12340 packet fixtures.
+- Performance: constant-time integer checks and a bounded 36-character UUID scan.
+
+## Extension points
+
+- Content Project allocator and duplicate/reference validation.
+- Session-owned entity registry and explicit `WowGuid ↔ EntityId` mappings.
+- Backend capability adapters that define server entry namespaces.
+- Separate typed map/spell/item/quest/display/sound values.
+- Fixture-backed build-12340 GUID high-type decoding in the protocol layer.
+
+## Capability status
+
+| Capability | Status | Evidence | Gap/next step |
+|---|---|---|---|
+| Stable authored ContentId | Implemented contract | UUID normalization/validation fixtures | Allocator and schema arrive with Content Project |
+| Session-local EntityId | Implemented contract | Positive/zero/equality fixtures | Registry lifecycle arrives with gameplay world state |
+| Lossless opaque WowGuid | Implemented contract | Full unsigned words and hex fixture | Packet codec/high-type semantics need build-12340 fixtures |
+| Namespaced ServerEntryId | Implemented contract | Cross-table collision fixture | Backend namespace capability mapping arrives with server adapters |
+| Cross-namespace mappings | Planned | Architecture/ADR boundary | Implement only in owning registries/adapters |
+
+## Known gaps and risks
+
+- No allocator or duplicate registry exists yet.
+- GDScript `==` compares references; consumers must use domain `equals` methods
+  or canonical keys until a registry owns keying.
+- UUID shape validation deliberately does not enforce generation version/variant.
+- Server namespace vocabulary is adapter-owned and not yet centrally catalogued.
+- GUID high-type/object-kind semantics remain unverified rather than guessed.
+
+## Source map
+
+| Path | Responsibility |
+|---|---|
+| `src/domain/identity/content_id.gd` | Stable canonical UUID content identity |
+| `src/domain/identity/entity_id.gd` | Session-local runtime identity |
+| `src/domain/identity/wow_guid.gd` | Opaque unsigned WoW wire identity |
+| `src/domain/identity/server_entry_id.gd` | Namespaced backend entry identity |
+| `src/tools/verify_domain_identities.gd` | Headless value/boundary regression |
+| `docs/adr/0002-domain-identity-namespaces.md` | Normative namespace/lifetime decision |
+
+## Related decisions and references
+
+- ADR: [`../adr/0002-domain-identity-namespaces.md`](../adr/0002-domain-identity-namespaces.md)
+- Architecture: [`../ARCHITECTURE.md`](../ARCHITECTURE.md)
+- Foundation plan: [`../../targets/roadmap/01-foundation-and-data.md`](../../targets/roadmap/01-foundation-and-data.md)

docs/modules/world-renderer.md

@@ -5,9 +5,9 @@
 | Field | Value |
 |---|---|
 | Status | Partial |
-| Target/work package | M00 active; декомпозиция M01–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 | M00 visual-diff worktree, 2026-07-11 |
+| Last verified | Worktree `work/sindo-main-codex/m01-server-spawn-renderer`, 2026-07-13 |
 | Profiles/capabilities | `Performance`, `Balanced`, `High`, `Custom`; Blizzlike fidelity incomplete |
 
 ## Purpose
@@ -26,7 +26,13 @@
 
 ```mermaid
 flowchart LR
-    Focus[Camera/player/editor focus] --> Loader[StreamingWorldLoader]
+    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]
     Cache[Baked terrain/M2/WMO caches] --> Loader
     Native --> Parsed[Parsed tile/model data]
@@ -60,7 +66,11 @@ Forbidden dependencies:
 |---|---|---|---|---|
 | `map_name` | Exported property | WDT/map directory name | Set before world load | Missing WDT produces diagnostic/empty world |
 | `extracted_dir` | Exported property | Root of legally extracted client data | Session lifetime | Missing files reported per loader path |
-| `camera_path` | Exported property | Current streaming focus compatibility path | Main thread, scene lifetime | Missing camera prevents normal focus update |
+| `StreamingFocus` | Immutable value | Typed Godot-basis position without Node/Camera dependency | Any thread; caller-owned reference | Null position is a caller contract violation |
+| `streaming_focus_source_path` | Exported adapter property | Samples any explicit `Node3D` source into `StreamingFocus` | Main thread, scene lifetime | Missing/wrong node warns once and retains prior focus |
+| `set_streaming_focus` | Public method | Accepts focus from app/editor/tool composition | Main thread/session | Null focus is ignored by refresh until replaced |
+| `refresh_streaming_focus` | Public method | Samples configured source and applies refresh thresholds | Main thread/session | Returns `false` when no valid focus exists |
+| `camera_path` | Exported property | Camera used only by optional automatic overview positioning | Main thread, scene lifetime | Missing camera skips automatic positioning |
 | `quality_preset` | Exported property | Applies renderer budgets/radii | Before/at runtime depending property | Invalid combination should be diagnosed |
 | `runtime_stats_enabled` | Exported property | Enables periodic performance snapshot | Runtime mutable | Logging overhead only |
 | `hitch_profiler_enabled` | Exported property | Enables named hitch sections | Runtime mutable | Logging overhead only |
@@ -71,12 +81,16 @@ Forbidden dependencies:
 
 | Direction | Contract/data | Producer | Consumer | Ownership | Thread/lifetime |
 |---|---|---|---|---|---|
-| Input | Map/focus/configuration | Scene/app/editor | `StreamingWorldLoader` | Caller config, copied/read | Main thread/session |
+| Input | `StreamingFocus` | Player/spectator/editor/capture adapter | `StreamingWorldLoader` | Immutable caller value | Main thread/session |
+| Input | Focus-source `NodePath` | Runtime/test scene composition | Loader source adapter | Scene-owned node, sampled position | Main thread/scene lifetime |
+| Input | 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:
 
@@ -90,7 +104,15 @@ Side effects:
 
 ```mermaid
 flowchart TD
-    F[Streaming focus] --> T[Compute desired ADT tiles]
+    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
+    F --> T[Compute desired ADT tiles]
     WDT[WDT tile catalog] --> T
     T --> Q[Tile load queue]
     Q --> P[Worker parse/cache load]
@@ -104,6 +126,7 @@ flowchart TD
     M2 --> World
     WMO --> World
     Liquid --> World
+    Marker --> World
     F --> E[Eviction/retention decisions]
     E --> World
 ```
@@ -113,13 +136,14 @@ flowchart TD
 ```mermaid
 stateDiagram-v2
     [*] --> Initializing
-    Initializing --> Ready: WDT/catalog/config ready
+    Initializing --> WaitingForFocus: WDT/catalog/config ready
     Initializing --> Degraded: missing loaders/data/cache
-    Ready --> Streaming: focus update
+    WaitingForFocus --> Streaming: valid StreamingFocus
     Streaming --> Streaming: load/finalize/evict ticks
+    Streaming --> WaitingForFocus: world reset without replacement focus
     Streaming --> SwitchingMap: map/focus reset
     SwitchingMap --> Initializing
-    Ready --> ShuttingDown
+    WaitingForFocus --> ShuttingDown
     Degraded --> ShuttingDown
     Streaming --> ShuttingDown
     ShuttingDown --> [*]
@@ -129,27 +153,37 @@ stateDiagram-v2
 
 ```mermaid
 sequenceDiagram
-    participant Focus as Camera/Player/Editor
+    participant Source as Player/Editor/Capture source
+    participant Focus as StreamingFocus adapter
     participant Stream as StreamingWorldLoader
     participant Worker as Worker task
     participant Budget as Main-thread budget
     participant Render as SceneTree/RenderingServer
-    Focus->>Stream: focus position changed
+    Source->>Focus: sample explicit Godot position
+    Focus->>Stream: set/refresh typed focus
     Stream->>Stream: desired tiles and priorities
     Stream->>Worker: parse/load tile and detail data
     Worker-->>Stream: immutable result
     Stream->>Budget: enqueue finalize operations
     Budget->>Render: attach bounded terrain/M2/WMO/liquid work
     Stream->>Render: evict outside retention range
+    Stream->>Worker: shutdown: wait for WorkerThreadPool tasks
+    Stream->>Stream: shutdown: finish registered ResourceLoader requests
+    Stream->>Render: clear queues and owned tree nodes/RIDs
+    Stream->>Stream: free detached prototypes and release resource caches
 ```
 
 ## Ownership, threading and resources
 
 - `StreamingWorldLoader` владеет tile states, queues, task registries, active world instances и render caches session scope.
+- Focus producers own the immutable `StreamingFocus` reference; the loader retains
+  the latest reference and converts it to `Vector3` only inside the render boundary.
 - Worker tasks не должны менять SceneTree и shared Resource concurrently.
 - Parsed/grouped results передаются обратно через guarded result queues.
 - Mesh/material/node/RID finalization выполняется main thread и ограничивается exported budgets.
-- Shutdown/map switch обязан отменить/дождаться jobs и освободить RIDs; M00 всё ещё фиксирует leaked-resource risk.
+- Shutdown/map switch обязан дождаться WorkerThreadPool jobs и зарегистрированных threaded ResourceLoader requests до очистки очередей, nodes, caches и RIDs.
+- Parented streamed nodes остаются owned by SceneTree during shutdown; detached M2/WMO prototype caches are explicitly `free()`d after asynchronous work drains.
+- A temporary liquid root with no generated child geometry is explicitly freed by `ADTBuilder` instead of being returned or abandoned.
 - Cache resources считаются immutable после публикации.
 
 ## Errors, cancellation and recovery
@@ -157,12 +191,14 @@ sequenceDiagram
 | Failure | Detection | Behavior | Diagnostic | Recovery |
 |---|---|---|---|---|
 | Missing WDT/ADT | File/catalog check | Tile/map unavailable | Loader warning/error | Fix extraction/profile, reload |
+| Missing focus source | Explicit NodePath resolution | Retain current streamed content and prior valid focus | One warning until source recovers | Fix composition path or call `set_streaming_focus` |
+| No focus supplied | Refresh contract | No target recomputation; queues continue draining | `refresh_streaming_focus()` returns `false` | Supply player/editor/capture focus |
 | Cache version mismatch | Required format constant | Reject stale cache/fallback | Version diagnostic | Rebuild matching cache |
 | Worker failure | Task result/empty data | Skip/degrade affected asset | Queue/task warning | Retry/rebuild source |
 | Main-thread hitch | Named section timing | Frame spike, work remains queued | `HITCH` log | Lower budget/fix finalize path |
 | D3D12 descriptor exhaustion | Rendering backend error | Render failure/fallback backend | Godot error + baseline report | Dedup resources/fix settings |
 | Teleport/map change | Focus/session transition | Old jobs become stale | Target/session generation | Cancel/drop stale results |
-| Shutdown leak | Godot leak/RID diagnostics | Resource retained | Shutdown report | Ownership cleanup before DONE |
+| Shutdown leak | Godot leak/RID diagnostics | Resource retained | Verbose shutdown report + cache shutdown verifier | Drain requests, preserve tree ownership, then free detached prototypes and clear resource caches |
 
 ## Configuration and capabilities
 
@@ -178,6 +214,9 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
 
 ## Persistence, cache and migration
 
+- `StreamingFocus` is runtime-only and is not serialized. Scene migration adds
+  `streaming_focus_source_path`; existing `camera_path` remains valid only for
+  optional automatic overview positioning.
 - Renderer reads caches under `data/cache`; caches are not committed.
 - Format changes require `FORMAT_VERSION`/required-version bump and rebuild instructions.
 - Atomic cache publication and unified manifest are target-state work from FND/M03.
@@ -192,16 +231,17 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
 
 ## Verification
 
-- Unit/contract tests: material mapping, unique-ID dedupe, placement probes, baseline manifest, five-point coordinate calibration, synthetic perceptual checkpoint diff.
-- Integration/E2E: Eastern Kingdoms/Kalimdor streaming scenes and seven cold/warm checkpoints.
-- Fidelity evidence: пять локальных build 12340 reference JPG откалибровали terrain/ADT/M2/WMO/liquid viewpoints; automated paired-image metrics exist, но synthetic animation/dusk и полный human approval ещё не закрыты.
+- 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, 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).
 
 ## Extension points
 
 - Target `WorldRenderFacade` for runtime/editor/capture callers.
-- Target `StreamingFocus` independent of Camera3D.
+- Extend `StreamingFocus` with measured direction/velocity needs when the pure planner is extracted.
 - Extracted planner, budget scheduler, terrain, M2, WMO, liquid, sky and character services.
 - Separate Blizzlike/Enhanced material and quality profiles.
 
@@ -215,17 +255,27 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
 | Liquids | Partial | MH2O/MLIQ paths | LiquidType/depth/shore fidelity |
 | Sky/light | Partial | DBC controller/logs | Zone transition paired validation |
 | Character presentation | Prototype | Character creator/player experiment | Full customization/equipment states |
+| Camera-independent streaming focus | Implemented | Typed contract, two player-focused runtime scenes and three explicitly camera-focused diagnostic tools | Multi-focus/direction/velocity belong to planner extraction |
+| Golden server-spawn visualization | Implemented | Pinned AzerothCore fixture, validated renderer manifest and diagnostic origin-marker capture at ADT `(32,48)`/MCNK `(3,12)` | No TrinityCore row or original-client visual-parity claim |
 | Stable renderer facade | Planned | M03 | Current caller uses monolithic Node API |
 
 ## Known gaps and risks
 
 - Monolithic streamer mixes planning, jobs, caches and presentation.
-- Direct camera path remains until M01/M03.
+- `camera_path` remains only for optional automatic overview positioning; it no
+  longer drives runtime streaming or discovers the active viewport camera.
 - Original-client paired fidelity evidence incomplete.
 - Первый paired run выявил coordinate/placement mismatch: несколько совпадающих server-derived camera positions оказываются под terrain или внутри WMO/rocks OpenWC.
 - Terrain-height probe исключил under-terrain состояние для всех пяти точек; waterfall exact-XZ miss классифицирован как TriangleMesh seam/edge и подтверждён nearby sample в 2 units.
 - Camera-occluder probe не нашёл camera containment в пяти точках; paired mismatch локализован прежде всего в manual look direction/target/FOV calibration, с явным ограничением по RID-only geometry.
-- D3D12 descriptor and shutdown RID/resource issues remain.
+- Empirical FOV sweep выявил, что checkpoint camera должна явно вызывать `make_current()`; после исправления projection ranking остаётся inconclusive из-за неизвестного manual yaw/pitch/framing reference.
+- Camera-pose sweep can now rank bounded yaw/pitch grids without changing manifest defaults; perceptual ranking remains diagnostic and requires human framing approval.
+- The first Goldshire pose grid was invalidated by WMO readiness: the inn is absent after 2 seconds but visible after the manifest-standard 8-second wait. Pose comparisons must stabilize asynchronous checkpoint content first.
+- A ready-scene Goldshire 3x3 grid improved mean error from `0.101402` at zero offsets to `0.087952` at yaw `10`/pitch `-10`; pitch/FOV refinement remains required before manifest calibration.
+- Joint Goldshire pitch/FOV refinement had no human-approved optimum: full-frame error preferred grass-heavy FOV 62/pitch -25, while FOV 38/pitch -10 better matched building scale. Landmark/region scoring is required before calibration.
+- Common-region scoring `[300,100,1400,650]` moved Goldshire's numeric optimum to FOV 38/yaw 10/pitch -15, but human inspection still found an oversized/cropped facade; semantic landmarks or masks remain required.
+- Final paired audit compared fourteen cold/warm images for seven private build 12340 references with zero missing pairs; mean error ranges `0.066893..0.176955`. Animated-M2 native motion is observed across two original-client phases, but its real Lakeshire placement differs from the synthetic Goldshire probe. Sky-transition evidence uses the checkpoint map position/time with manually approved approximate framing.
+- D3D12 descriptor issues remain. Explicit shutdown ownership removes the GUI capture's Node/resource/RID leaks in focused and seven-checkpoint runs; a timing-dependent ObjectDB warning for anonymous zero-reference `RefCounted` objects remains as a separate engine-teardown diagnostic.
 - M2/WMO/material/particle/ribbon/portal parity incomplete.
 - Public API is mostly exported configuration rather than stable contracts.
 
@@ -234,6 +284,8 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
 | Path | Responsibility |
 |---|---|
 | `src/scenes/streaming/streaming_world_loader.gd` | Current runtime orchestration, queues, caches and attachment |
+| `src/domain/streaming/streaming_focus.gd` | Immutable camera-independent streaming position contract |
+| `src/tools/verify_streaming_focus.gd` | Headless contract, dependency and runtime/tool wiring regression |
 | `addons/mpq_extractor/loaders/adt_builder.gd` | Terrain/material/liquid construction |
 | `addons/mpq_extractor/loaders/m2_builder.gd` | Static M2 mesh/material construction |
 | `addons/mpq_extractor/loaders/m2_native_animated_builder.gd` | Native animated M2 experiment |
@@ -243,7 +295,11 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
 | `src/tools/build_*cache.gd`, `src/tools/bake_*cache.gd` | Offline cache generation |
 | `tools/run_render_baseline.ps1` | Unified M00 baseline runner |
 | `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 |
 | `src/tools/probe_render_camera_occluders.gd` | Scene-tree placement containment and camera-to-target AABB intersection report |
@@ -252,5 +308,7 @@ Exact exported settings and cache versions remain documented in [`../../RENDER.m
 
 - [`../../RENDER.md`](../../RENDER.md)
 - [`../RENDER_BASELINE.md`](../RENDER_BASELINE.md)
+- [`../CAMERA_POSE_SWEEP.md`](../CAMERA_POSE_SWEEP.md)
+- [`../M00_FINAL_PAIRED_EVIDENCE.md`](../M00_FINAL_PAIRED_EVIDENCE.md)
 - [`../../targets/roadmap/02-rendering-and-graphics.md`](../../targets/roadmap/02-rendering-and-graphics.md)
 - [`../GODOT_BEST_PRACTICES.md`](../GODOT_BEST_PRACTICES.md)

src/domain/coordinates/adt_chunk_coordinate.gd

@@ -0,0 +1,44 @@
+class_name AdtChunkCoordinate
+extends RefCounted
+
+## Immutable MCNK chunk indices inside one ADT tile.
+## `chunk_x` grows east and `chunk_y` grows south, matching the ADT header and
+## tile conversion contract rather than Godot's X/Z member names.
+
+const MINIMUM_CHUNK_INDEX: int = 0
+const MAXIMUM_CHUNK_INDEX: int = 15
+
+var tile_coordinate: AdtTileCoordinate:
+	get:
+		return _tile_coordinate
+
+var chunk_x: int:
+	get:
+		return _chunk_x
+
+var chunk_y: int:
+	get:
+		return _chunk_y
+
+var _tile_coordinate: AdtTileCoordinate
+var _chunk_x: int
+var _chunk_y: int
+
+
+## Creates chunk indices without clamping so invalid parser input is visible.
+func _init(tile_coordinate_value: AdtTileCoordinate, chunk_x_value: int, chunk_y_value: int) -> void:
+	_tile_coordinate = tile_coordinate_value
+	_chunk_x = chunk_x_value
+	_chunk_y = chunk_y_value
+
+
+## Returns whether the tile and both chunk indices are inside standard bounds.
+func is_within_map_grid() -> bool:
+	return (
+		_tile_coordinate != null
+		and _tile_coordinate.is_within_map_grid()
+		and _chunk_x >= MINIMUM_CHUNK_INDEX
+		and _chunk_x <= MAXIMUM_CHUNK_INDEX
+		and _chunk_y >= MINIMUM_CHUNK_INDEX
+		and _chunk_y <= MAXIMUM_CHUNK_INDEX
+	)

src/domain/coordinates/adt_chunk_coordinate.gd.uid

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

src/domain/coordinates/adt_placement_position.gd

@@ -0,0 +1,29 @@
+class_name AdtPlacementPosition
+extends RefCounted
+
+## Immutable MDDF/MODF position in ADT file field order.
+## `x_offset_yards` and `z_offset_yards` are measured from the north-west map
+## extent; `height_yards` is the vertical field stored between them.
+
+var x_offset_yards: float:
+	get:
+		return _x_offset_yards
+
+var height_yards: float:
+	get:
+		return _height_yards
+
+var z_offset_yards: float:
+	get:
+		return _z_offset_yards
+
+var _x_offset_yards: float
+var _height_yards: float
+var _z_offset_yards: float
+
+
+## Creates an ADT placement position in on-disk X/height/Z field order.
+func _init(x_offset_yards_value: float, height_yards_value: float, z_offset_yards_value: float) -> void:
+	_x_offset_yards = x_offset_yards_value
+	_height_yards = height_yards_value
+	_z_offset_yards = z_offset_yards_value

src/domain/coordinates/adt_placement_position.gd.uid

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

src/domain/coordinates/adt_tile_coordinate.gd

@@ -0,0 +1,35 @@
+class_name AdtTileCoordinate
+extends RefCounted
+
+## Immutable indices from an ADT filename `Map_tileX_tileY.adt`.
+## Both axes use the inclusive range 0..63 for a normal WotLK world map.
+
+const MINIMUM_TILE_INDEX: int = 0
+const MAXIMUM_TILE_INDEX: int = 63
+
+var tile_x: int:
+	get:
+		return _tile_x
+
+var tile_y: int:
+	get:
+		return _tile_y
+
+var _tile_x: int
+var _tile_y: int
+
+
+## Creates file indices without clamping so out-of-map input remains diagnosable.
+func _init(tile_x_value: int, tile_y_value: int) -> void:
+	_tile_x = tile_x_value
+	_tile_y = tile_y_value
+
+
+## Returns whether both file indices address the standard 64 by 64 ADT grid.
+func is_within_map_grid() -> bool:
+	return (
+		_tile_x >= MINIMUM_TILE_INDEX
+		and _tile_x <= MAXIMUM_TILE_INDEX
+		and _tile_y >= MINIMUM_TILE_INDEX
+		and _tile_y <= MAXIMUM_TILE_INDEX
+	)

src/domain/coordinates/adt_tile_coordinate.gd.uid

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

src/domain/coordinates/adt_tile_local_position.gd

@@ -0,0 +1,29 @@
+class_name AdtTileLocalPosition
+extends RefCounted
+
+## Immutable position relative to the north-west corner of one ADT tile.
+## East and south offsets are normally in `[0, ADT_TILE_SIZE_YARDS)`; height
+## remains in the canonical vertical space.
+
+var east_yards: float:
+	get:
+		return _east_yards
+
+var height_yards: float:
+	get:
+		return _height_yards
+
+var south_yards: float:
+	get:
+		return _south_yards
+
+var _east_yards: float
+var _height_yards: float
+var _south_yards: float
+
+
+## Creates a tile-local position without clamping boundary values.
+func _init(east_yards_value: float, height_yards_value: float, south_yards_value: float) -> void:
+	_east_yards = east_yards_value
+	_height_yards = height_yards_value
+	_south_yards = south_yards_value

src/domain/coordinates/adt_tile_local_position.gd.uid

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

src/domain/coordinates/canonical_wow_world_position.gd

@@ -0,0 +1,29 @@
+class_name CanonicalWowWorldPosition
+extends RefCounted
+
+## Immutable WoW 3.3.5a world position in client/server axis order and yards.
+## X and Y are the horizontal coordinates reported by the client and world
+## server; Z is height. This type deliberately does not expose a [Vector3].
+
+var x_yards: float:
+	get:
+		return _x_yards
+
+var y_yards: float:
+	get:
+		return _y_yards
+
+var z_yards: float:
+	get:
+		return _z_yards
+
+var _x_yards: float
+var _y_yards: float
+var _z_yards: float
+
+
+## Creates a canonical position without changing precision or validating map bounds.
+func _init(x_yards_value: float, y_yards_value: float, z_yards_value: float) -> void:
+	_x_yards = x_yards_value
+	_y_yards = y_yards_value
+	_z_yards = z_yards_value

src/domain/coordinates/canonical_wow_world_position.gd.uid

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

src/domain/coordinates/canonical_wow_world_yaw.gd

@@ -0,0 +1,16 @@
+class_name CanonicalWowWorldYaw
+extends RefCounted
+
+## Immutable canonical world-facing yaw in radians.
+## Zero faces increasing WoW X and positive rotation turns toward increasing Y.
+
+var radians: float:
+	get:
+		return _radians
+
+var _radians: float
+
+
+## Creates a yaw without normalization; [CoordinateMapper] normalizes conversions.
+func _init(radians_value: float) -> void:
+	_radians = radians_value

src/domain/coordinates/canonical_wow_world_yaw.gd.uid

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

src/domain/coordinates/coordinate_mapper.gd

@@ -0,0 +1,167 @@
+class_name CoordinateMapper
+extends RefCounted
+
+## Pure, stateless conversions between OpenWC coordinate value objects.
+## This is the only domain contract allowed to change coordinate axes. It does
+## not depend on Node, Resource, scene state, map assets or renderer globals.
+
+const ADT_TILES_PER_MAP_AXIS: int = 64
+const ADT_CHUNKS_PER_TILE_AXIS: int = 16
+const ADT_TILE_SIZE_YARDS: float = 1600.0 / 3.0
+const ADT_CHUNK_SIZE_YARDS: float = ADT_TILE_SIZE_YARDS / float(ADT_CHUNKS_PER_TILE_AXIS)
+const WOW_WORLD_HALF_EXTENT_YARDS: float = ADT_TILE_SIZE_YARDS * float(ADT_TILES_PER_MAP_AXIS) * 0.5
+
+
+## Converts server/wire X/Y/Z to canonical WoW X/Y/Z without an axis swap.
+static func server_to_canonical(server_position: ServerWorldPosition) -> CanonicalWowWorldPosition:
+	return CanonicalWowWorldPosition.new(
+		server_position.x_yards,
+		server_position.y_yards,
+		server_position.z_yards
+	)
+
+
+## Converts canonical WoW X/Y/Z to server/wire X/Y/Z without an axis swap.
+static func canonical_to_server(canonical_position: CanonicalWowWorldPosition) -> ServerWorldPosition:
+	return ServerWorldPosition.new(
+		canonical_position.x_yards,
+		canonical_position.y_yards,
+		canonical_position.z_yards
+	)
+
+
+## Converts canonical WoW world axes to the Godot Y-up compatibility basis.
+static func canonical_to_godot(canonical_position: CanonicalWowWorldPosition) -> GodotWorldPosition:
+	return GodotWorldPosition.new(
+		WOW_WORLD_HALF_EXTENT_YARDS - canonical_position.y_yards,
+		canonical_position.z_yards,
+		WOW_WORLD_HALF_EXTENT_YARDS - canonical_position.x_yards
+	)
+
+
+## Converts the Godot Y-up compatibility basis to canonical WoW world axes.
+static func godot_to_canonical(godot_position: GodotWorldPosition) -> CanonicalWowWorldPosition:
+	return CanonicalWowWorldPosition.new(
+		WOW_WORLD_HALF_EXTENT_YARDS - godot_position.z_units,
+		WOW_WORLD_HALF_EXTENT_YARDS - godot_position.x_units,
+		godot_position.y_units
+	)
+
+
+## Returns ADT filename indices directly from a Godot renderer position.
+static func godot_to_adt_tile(godot_position: GodotWorldPosition) -> AdtTileCoordinate:
+	return AdtTileCoordinate.new(
+		int(floor(godot_position.x_units / ADT_TILE_SIZE_YARDS)),
+		int(floor(godot_position.z_units / ADT_TILE_SIZE_YARDS))
+	)
+
+
+## Returns east/height/south offsets inside the owning ADT tile.
+static func godot_to_adt_tile_local(godot_position: GodotWorldPosition) -> AdtTileLocalPosition:
+	var tile_coordinate := godot_to_adt_tile(godot_position)
+	return AdtTileLocalPosition.new(
+		godot_position.x_units - float(tile_coordinate.tile_x) * ADT_TILE_SIZE_YARDS,
+		godot_position.y_units,
+		godot_position.z_units - float(tile_coordinate.tile_y) * ADT_TILE_SIZE_YARDS
+	)
+
+
+## Converts an ADT tile/local pair directly to the Godot renderer basis.
+static func adt_tile_local_to_godot(
+		tile_coordinate: AdtTileCoordinate,
+		local_position: AdtTileLocalPosition
+) -> GodotWorldPosition:
+	return GodotWorldPosition.new(
+		float(tile_coordinate.tile_x) * ADT_TILE_SIZE_YARDS + local_position.east_yards,
+		local_position.height_yards,
+		float(tile_coordinate.tile_y) * ADT_TILE_SIZE_YARDS + local_position.south_yards
+	)
+
+
+## Converts canonical WoW coordinates to MDDF/MODF X/height/Z file fields.
+static func canonical_to_adt_placement(canonical_position: CanonicalWowWorldPosition) -> AdtPlacementPosition:
+	return AdtPlacementPosition.new(
+		WOW_WORLD_HALF_EXTENT_YARDS - canonical_position.x_yards,
+		canonical_position.z_yards,
+		WOW_WORLD_HALF_EXTENT_YARDS - canonical_position.y_yards
+	)
+
+
+## Converts MDDF/MODF X/height/Z file fields to canonical WoW coordinates.
+static func adt_placement_to_canonical(adt_position: AdtPlacementPosition) -> CanonicalWowWorldPosition:
+	return CanonicalWowWorldPosition.new(
+		WOW_WORLD_HALF_EXTENT_YARDS - adt_position.x_offset_yards,
+		WOW_WORLD_HALF_EXTENT_YARDS - adt_position.z_offset_yards,
+		adt_position.height_yards
+	)
+
+
+## Returns unclamped ADT filename indices for a canonical position.
+## Exact south/east boundaries belong to the next tile by floor semantics.
+static func canonical_to_adt_tile(canonical_position: CanonicalWowWorldPosition) -> AdtTileCoordinate:
+	return AdtTileCoordinate.new(
+		int(floor(float(ADT_TILES_PER_MAP_AXIS) * 0.5 - canonical_position.y_yards / ADT_TILE_SIZE_YARDS)),
+		int(floor(float(ADT_TILES_PER_MAP_AXIS) * 0.5 - canonical_position.x_yards / ADT_TILE_SIZE_YARDS))
+	)
+
+
+## Converts a canonical position to east/south offsets inside its ADT tile.
+static func canonical_to_adt_tile_local(canonical_position: CanonicalWowWorldPosition) -> AdtTileLocalPosition:
+	var tile_coordinate := canonical_to_adt_tile(canonical_position)
+	var tile_west_edge_y_yards := (float(ADT_TILES_PER_MAP_AXIS) * 0.5 - float(tile_coordinate.tile_x)) * ADT_TILE_SIZE_YARDS
+	var tile_north_edge_x_yards := (float(ADT_TILES_PER_MAP_AXIS) * 0.5 - float(tile_coordinate.tile_y)) * ADT_TILE_SIZE_YARDS
+	return AdtTileLocalPosition.new(
+		tile_west_edge_y_yards - canonical_position.y_yards,
+		canonical_position.z_yards,
+		tile_north_edge_x_yards - canonical_position.x_yards
+	)
+
+
+## Reconstructs canonical coordinates from an ADT tile and tile-local offsets.
+static func adt_tile_local_to_canonical(
+		tile_coordinate: AdtTileCoordinate,
+		local_position: AdtTileLocalPosition
+) -> CanonicalWowWorldPosition:
+	var tile_west_edge_y_yards := (float(ADT_TILES_PER_MAP_AXIS) * 0.5 - float(tile_coordinate.tile_x)) * ADT_TILE_SIZE_YARDS
+	var tile_north_edge_x_yards := (float(ADT_TILES_PER_MAP_AXIS) * 0.5 - float(tile_coordinate.tile_y)) * ADT_TILE_SIZE_YARDS
+	return CanonicalWowWorldPosition.new(
+		tile_north_edge_x_yards - local_position.south_yards,
+		tile_west_edge_y_yards - local_position.east_yards,
+		local_position.height_yards
+	)
+
+
+## Returns unclamped MCNK indices for a tile-local position.
+static func adt_tile_local_to_chunk(
+		tile_coordinate: AdtTileCoordinate,
+		local_position: AdtTileLocalPosition
+) -> AdtChunkCoordinate:
+	return AdtChunkCoordinate.new(
+		tile_coordinate,
+		int(floor(local_position.east_yards / ADT_CHUNK_SIZE_YARDS)),
+		int(floor(local_position.south_yards / ADT_CHUNK_SIZE_YARDS))
+	)
+
+
+## Converts server movement yaw to canonical yaw and normalizes it to [-PI, PI).
+static func server_to_canonical_yaw(server_yaw: ServerWorldYaw) -> CanonicalWowWorldYaw:
+	return CanonicalWowWorldYaw.new(_normalize_yaw(server_yaw.radians))
+
+
+## Converts canonical yaw to server movement yaw and normalizes it to [-PI, PI).
+static func canonical_to_server_yaw(canonical_yaw: CanonicalWowWorldYaw) -> ServerWorldYaw:
+	return ServerWorldYaw.new(_normalize_yaw(canonical_yaw.radians))
+
+
+## Converts canonical world yaw to Godot Y-axis yaw in the mapped world basis.
+static func canonical_to_godot_yaw(canonical_yaw: CanonicalWowWorldYaw) -> GodotWorldYaw:
+	return GodotWorldYaw.new(_normalize_yaw(canonical_yaw.radians))
+
+
+## Converts Godot Y-axis world yaw to canonical yaw in the mapped world basis.
+static func godot_to_canonical_yaw(godot_yaw: GodotWorldYaw) -> CanonicalWowWorldYaw:
+	return CanonicalWowWorldYaw.new(_normalize_yaw(godot_yaw.radians))
+
+
+static func _normalize_yaw(radians: float) -> float:
+	return fposmod(radians + PI, TAU) - PI

src/domain/coordinates/coordinate_mapper.gd.uid

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

src/domain/coordinates/godot_world_position.gd

@@ -0,0 +1,29 @@
+class_name GodotWorldPosition
+extends RefCounted
+
+## Immutable Godot Y-up renderer position.
+## One Godot unit equals one WoW yard in the compatibility renderer. X grows
+## east, Y grows up and Z grows south from the north-west map extent.
+
+var x_units: float:
+	get:
+		return _x_units
+
+var y_units: float:
+	get:
+		return _y_units
+
+var z_units: float:
+	get:
+		return _z_units
+
+var _x_units: float
+var _y_units: float
+var _z_units: float
+
+
+## Creates a renderer position without exposing it as a cross-layer [Vector3].
+func _init(x_units_value: float, y_units_value: float, z_units_value: float) -> void:
+	_x_units = x_units_value
+	_y_units = y_units_value
+	_z_units = z_units_value

src/domain/coordinates/godot_world_position.gd.uid

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

src/domain/coordinates/godot_world_yaw.gd

@@ -0,0 +1,17 @@
+class_name GodotWorldYaw
+extends RefCounted
+
+## Immutable Godot Y-axis yaw in radians for the canonical world basis.
+## With Godot forward `-Z`, the numeric angle equals WoW world yaw after the
+## position basis conversion. Model-local MDDF/MODF corrections are separate.
+
+var radians: float:
+	get:
+		return _radians
+
+var _radians: float
+
+
+## Creates a Godot world yaw without normalization.
+func _init(radians_value: float) -> void:
+	_radians = radians_value

src/domain/coordinates/godot_world_yaw.gd.uid

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

src/domain/coordinates/server_world_position.gd

@@ -0,0 +1,29 @@
+class_name ServerWorldPosition
+extends RefCounted
+
+## Immutable TrinityCore/AzerothCore world position in wire/database X/Y/Z order.
+## Units are WoW yards. A distinct type prevents server positions from being
+## passed directly to renderer APIs even though the scalar values are canonical.
+
+var x_yards: float:
+	get:
+		return _x_yards
+
+var y_yards: float:
+	get:
+		return _y_yards
+
+var z_yards: float:
+	get:
+		return _z_yards
+
+var _x_yards: float
+var _y_yards: float
+var _z_yards: float
+
+
+## Creates a server position without changing precision or validating map bounds.
+func _init(x_yards_value: float, y_yards_value: float, z_yards_value: float) -> void:
+	_x_yards = x_yards_value
+	_y_yards = y_yards_value
+	_z_yards = z_yards_value

src/domain/coordinates/server_world_position.gd.uid

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

src/domain/coordinates/server_world_yaw.gd

@@ -0,0 +1,16 @@
+class_name ServerWorldYaw
+extends RefCounted
+
+## Immutable TrinityCore/AzerothCore movement orientation in radians.
+## It uses the WoW client convention: zero faces +X and positive turns toward +Y.
+
+var radians: float:
+	get:
+		return _radians
+
+var _radians: float
+
+
+## Creates a server yaw without normalization.
+func _init(radians_value: float) -> void:
+	_radians = radians_value

src/domain/coordinates/server_world_yaw.gd.uid

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

src/domain/identity/content_id.gd

@@ -0,0 +1,43 @@
+class_name ContentId
+extends RefCounted
+
+## Stable authored-content identity serialized as canonical lowercase UUID text.
+## It is independent of runtime entities, server database entries and wire GUIDs.
+
+var uuid_text: String:
+	get:
+		return _uuid_text
+
+var _uuid_text: String
+
+
+## Normalizes surrounding whitespace and hexadecimal letter case.
+func _init(uuid_text_value: String) -> void:
+	_uuid_text = uuid_text_value.strip_edges().to_lower()
+
+
+## Reports whether the value has the canonical 8-4-4-4-12 UUID text shape.
+func is_valid() -> bool:
+	if _uuid_text.length() != 36:
+		return false
+	for character_index in range(_uuid_text.length()):
+		if character_index in [8, 13, 18, 23]:
+			if _uuid_text[character_index] != "-":
+				return false
+		elif not _is_lowercase_hexadecimal_character(_uuid_text[character_index]):
+			return false
+	return true
+
+
+## Compares stable content identity by normalized UUID text.
+func equals(other_content_id: ContentId) -> bool:
+	return other_content_id != null and _uuid_text == other_content_id.uuid_text
+
+
+## Returns the canonical dictionary/serialization key.
+func to_key() -> String:
+	return _uuid_text
+
+
+func _is_lowercase_hexadecimal_character(character: String) -> bool:
+	return (character >= "0" and character <= "9") or (character >= "a" and character <= "f")

src/domain/identity/content_id.gd.uid

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

src/domain/identity/entity_id.gd

@@ -0,0 +1,31 @@
+class_name EntityId
+extends RefCounted
+
+## Session-local runtime entity identity.
+## This sequence is never a stable content ID, server entry or WoW wire GUID.
+
+var session_sequence: int:
+	get:
+		return _session_sequence
+
+var _session_sequence: int
+
+
+## Stores an allocator-issued session sequence without persistence semantics.
+func _init(session_sequence_value: int) -> void:
+	_session_sequence = session_sequence_value
+
+
+## Reports whether this is a positive allocator-issued sequence.
+func is_valid() -> bool:
+	return _session_sequence > 0
+
+
+## Compares identity inside the same explicitly owned runtime session.
+func equals(other_entity_id: EntityId) -> bool:
+	return other_entity_id != null and _session_sequence == other_entity_id.session_sequence
+
+
+## Returns a diagnostic key; it must not be persisted across sessions.
+func to_debug_key() -> String:
+	return "entity:%d" % _session_sequence

src/domain/identity/entity_id.gd.uid

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

src/domain/identity/server_entry_id.gd

@@ -0,0 +1,41 @@
+class_name ServerEntryId
+extends RefCounted
+
+## Adapter-namespaced numeric entry from a server database or canonical snapshot.
+## Equal numbers in different template tables are intentionally different IDs.
+
+var entry_namespace: String:
+	get:
+		return _entry_namespace
+
+var entry_value: int:
+	get:
+		return _entry_value
+
+var _entry_namespace: String
+var _entry_value: int
+
+
+## Normalizes a table/adapter namespace and preserves its positive entry value.
+func _init(entry_namespace_value: String, entry_value_value: int) -> void:
+	_entry_namespace = entry_namespace_value.strip_edges().to_lower()
+	_entry_value = entry_value_value
+
+
+## Reports whether both collision-prevention fields are present.
+func is_valid() -> bool:
+	return not _entry_namespace.is_empty() and _entry_value > 0
+
+
+## Compares both namespace and numeric entry.
+func equals(other_server_entry_id: ServerEntryId) -> bool:
+	return (
+		other_server_entry_id != null
+		and _entry_namespace == other_server_entry_id.entry_namespace
+		and _entry_value == other_server_entry_id.entry_value
+	)
+
+
+## Returns the stable adapter key without implying a ContentId mapping.
+func to_key() -> String:
+	return "%s:%d" % [_entry_namespace, _entry_value]

src/domain/identity/server_entry_id.gd.uid

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

src/domain/identity/wow_guid.gd

@@ -0,0 +1,53 @@
+class_name WowGuid
+extends RefCounted
+
+## Opaque 64-bit WoW wire GUID stored as two lossless unsigned 32-bit words.
+## Build-specific high-type decoding belongs to the protocol adapter and must be
+## fixture-backed before becoming a domain contract.
+
+const MAXIMUM_UNSIGNED_32_BIT_VALUE := 0xffffffff
+
+var high_32_bits: int:
+	get:
+		return _high_32_bits
+
+var low_32_bits: int:
+	get:
+		return _low_32_bits
+
+var _high_32_bits: int
+var _low_32_bits: int
+
+
+## Preserves both wire words without signed 64-bit conversion.
+func _init(high_32_bits_value: int, low_32_bits_value: int) -> void:
+	_high_32_bits = high_32_bits_value
+	_low_32_bits = low_32_bits_value
+
+
+## Reports whether both words fit their unsigned wire ranges.
+func has_valid_word_ranges() -> bool:
+	return _is_unsigned_32_bit_word(_high_32_bits) and _is_unsigned_32_bit_word(_low_32_bits)
+
+
+## Reports the all-zero protocol sentinel without assigning gameplay meaning.
+func is_empty() -> bool:
+	return _high_32_bits == 0 and _low_32_bits == 0
+
+
+## Compares all 64 opaque wire bits.
+func equals(other_wow_guid: WowGuid) -> bool:
+	return (
+		other_wow_guid != null
+		and _high_32_bits == other_wow_guid.high_32_bits
+		and _low_32_bits == other_wow_guid.low_32_bits
+	)
+
+
+## Returns exactly sixteen lowercase hexadecimal digits for diagnostics/replays.
+func to_hex_string() -> String:
+	return "%08x%08x" % [_high_32_bits, _low_32_bits]
+
+
+func _is_unsigned_32_bit_word(word_value: int) -> bool:
+	return word_value >= 0 and word_value <= MAXIMUM_UNSIGNED_32_BIT_VALUE

src/domain/identity/wow_guid.gd.uid

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

src/domain/streaming/streaming_focus.gd

@@ -0,0 +1,17 @@
+class_name StreamingFocus
+extends RefCounted
+
+## Immutable world-streaming point independent of cameras and the scene tree.
+## Renderer adapters may obtain this position from a player, spectator, editor
+## viewport or capture tool, but streaming consumers receive only this value.
+
+var world_position: GodotWorldPosition:
+	get:
+		return _world_position
+
+var _world_position: GodotWorldPosition
+
+
+## Creates a focus at an explicit position in the Godot renderer basis.
+func _init(world_position_value: GodotWorldPosition) -> void:
+	_world_position = world_position_value

src/domain/streaming/streaming_focus.gd.uid

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

src/scenes/player/third_person_wow_controller.gd

@@ -3,9 +3,12 @@ extends CharacterBody3D
 const GEOSET_CONTROLLER_SCRIPT := preload("res://src/scenes/character/character_geoset_controller.gd")
 const TEXTURE_COMPOSITOR_SCRIPT := preload("res://src/scenes/character/character_texture_compositor.gd")
 const OUTFIT_RESOLVER_SCRIPT := preload("res://src/scenes/character/wow_character_outfit_resolver.gd")
+const COORDINATE_MAPPER_SCRIPT := preload("res://src/domain/coordinates/coordinate_mapper.gd")
+const GODOT_WORLD_POSITION_SCRIPT := preload("res://src/domain/coordinates/godot_world_position.gd")
+const ADT_TILE_COORDINATE_SCRIPT := preload("res://src/domain/coordinates/adt_tile_coordinate.gd")
+const ADT_TILE_LOCAL_POSITION_SCRIPT := preload("res://src/domain/coordinates/adt_tile_local_position.gd")
 
-const TILE_SIZE := 533.33333
-const CHUNK_SIZE := TILE_SIZE / 16.0
+const CHUNK_SIZE := COORDINATE_MAPPER_SCRIPT.ADT_CHUNK_SIZE_YARDS
 const UNIT_SIZE := CHUNK_SIZE / 8.0
 
 @export var extracted_dir: String = "res://data/extracted"
@@ -62,8 +65,11 @@ func _ready() -> void:
 		_camera.current = true
 		_camera.far = 50000.0
 	if spawn_at_tile_center:
-		global_position.x = (float(spawn_tile_x) + 0.5) * TILE_SIZE
-		global_position.z = (float(spawn_tile_y) + 0.5) * TILE_SIZE
+		var spawn_tile = ADT_TILE_COORDINATE_SCRIPT.new(spawn_tile_x, spawn_tile_y)
+		var half_tile_size := COORDINATE_MAPPER_SCRIPT.ADT_TILE_SIZE_YARDS * 0.5
+		var spawn_local = ADT_TILE_LOCAL_POSITION_SCRIPT.new(half_tile_size, global_position.y, half_tile_size)
+		var spawn_position = COORDINATE_MAPPER_SCRIPT.adt_tile_local_to_godot(spawn_tile, spawn_local)
+		global_position = Vector3(spawn_position.x_units, spawn_position.y_units, spawn_position.z_units)
 	_load_character_visual()
 	var ground := _sample_ground_height(global_position)
 	if is_finite(ground):
@@ -324,16 +330,17 @@ func _apply_camera_transform() -> void:
 
 
 func _sample_ground_height(world_pos: Vector3) -> float:
-	var tx := int(floor(world_pos.x / TILE_SIZE))
-	var ty := int(floor(world_pos.z / TILE_SIZE))
-	var data := _load_adt(tx, ty)
+	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 local := world_pos - tile_origin
-	var chunk_x := clampi(int(floor(local.x / CHUNK_SIZE)), 0, 15)
-	var chunk_y := clampi(int(floor(local.z / CHUNK_SIZE)), 0, 15)
+	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

src/scenes/sky/wow_sky_controller.gd

@@ -2,9 +2,9 @@
 extends Node
 
 const M2_BUILDER_SCRIPT := preload("res://addons/mpq_extractor/loaders/m2_builder.gd")
+const COORDINATE_MAPPER_SCRIPT := preload("res://src/domain/coordinates/coordinate_mapper.gd")
+const GODOT_WORLD_POSITION_SCRIPT := preload("res://src/domain/coordinates/godot_world_position.gd")
 
-const TILE_SIZE := 533.33333
-const WOW_WORLD_CENTER := 17066.666
 const LIGHT_COORD_SCALE := 36.0
 const HALF_MINUTES_PER_DAY := 2880
 
@@ -701,28 +701,30 @@ func _get_target_wow_position() -> Vector3:
 	var world_pos := Vector3.ZERO
 	if _target:
 		world_pos = _target.global_position
-	return Vector3(
-		WOW_WORLD_CENTER - world_pos.z,
-		WOW_WORLD_CENTER - world_pos.x,
-		world_pos.y)
+	var canonical_position = COORDINATE_MAPPER_SCRIPT.godot_to_canonical(_typed_godot_position(world_pos))
+	return Vector3(canonical_position.x_yards, canonical_position.y_yards, canonical_position.z_yards)
 
 
 func _get_target_area_id() -> int:
 	if not _target or map_name.is_empty():
 		return 0
 	var world_pos := _target.global_position
-	var tile_x := int(floor(world_pos.x / TILE_SIZE))
-	var tile_y := int(floor(world_pos.z / TILE_SIZE))
-	var local_x := world_pos.x - float(tile_x) * TILE_SIZE
-	var local_y := world_pos.z - float(tile_y) * TILE_SIZE
-	var chunk_x := clampi(int(floor(local_x / (TILE_SIZE / 16.0))), 0, 15)
-	var chunk_y := clampi(int(floor(local_y / (TILE_SIZE / 16.0))), 0, 15)
-	var areas := _load_adt_area_grid(tile_x, tile_y)
+	var typed_world_position = _typed_godot_position(world_pos)
+	var tile_coordinate = COORDINATE_MAPPER_SCRIPT.godot_to_adt_tile(typed_world_position)
+	var 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, local_position)
+	var areas := _load_adt_area_grid(tile_coordinate.tile_x, tile_coordinate.tile_y)
 	if areas.is_empty():
 		return 0
+	var chunk_x := clampi(chunk_coordinate.chunk_x, 0, 15)
+	var chunk_y := clampi(chunk_coordinate.chunk_y, 0, 15)
 	return int(areas[chunk_y * 16 + chunk_x])
 
 
+func _typed_godot_position(world_position: Vector3):
+	return GODOT_WORLD_POSITION_SCRIPT.new(world_position.x, world_position.y, world_position.z)
+
+
 func _load_adt_area_grid(tile_x: int, tile_y: int) -> PackedInt32Array:
 	var key := "%d_%d" % [tile_x, tile_y]
 	if _adt_area_cache.has(key):

src/scenes/streaming/eastern_kingdoms_streaming.tscn

@@ -53,6 +53,7 @@ fog_depth_end = 5200.0
 
 [node name="StreamingWorld" type="Node3D" unique_id=1063159974]
 script = ExtResource("1_stream")
+streaming_focus_source_path = NodePath("ThirdPersonPlayer")
 camera_path = NodePath("ThirdPersonPlayer/CameraPivot/Camera3D")
 quality_preset = "High"
 update_interval = 0.1

src/scenes/streaming/kalimdor_streaming.tscn

@@ -54,6 +54,7 @@ fog_depth_end = 5200.0
 [node name="StreamingWorld" type="Node3D" unique_id=1063159974]
 script = ExtResource("1_sisqv")
 map_name = "Kalimdor"
+streaming_focus_source_path = NodePath("ThirdPersonPlayer")
 camera_path = NodePath("ThirdPersonPlayer/CameraPivot/Camera3D")
 quality_preset = "High"
 update_interval = 0.1

src/scenes/streaming/streaming_world_loader.gd

@@ -1,5 +1,5 @@
 @tool
-## Streams Azeroth terrain around the active camera with chunk-based LODs.
+## Streams Azeroth terrain around an explicit [StreamingFocus] with chunk-based LODs.
 extends Node3D
 
 const ADT_BUILDER_SCRIPT := preload("res://addons/mpq_extractor/loaders/adt_builder.gd")
@@ -12,14 +12,19 @@ const WMO_BUILDER_SCRIPT := preload("res://addons/mpq_extractor/loaders/wmo_buil
 const M2_BUILDER_SCRIPT := preload("res://addons/mpq_extractor/loaders/m2_builder.gd")
 const M2_NATIVE_ANIMATED_BUILDER_SCRIPT := preload("res://addons/mpq_extractor/loaders/m2_native_animated_builder.gd")
 const M2_NATIVE_ANIMATOR_SCRIPT := preload("res://src/scenes/streaming/m2_native_animator.gd")
+const STREAMING_FOCUS_SCRIPT := preload("res://src/domain/streaming/streaming_focus.gd")
+const GODOT_WORLD_POSITION_SCRIPT := preload("res://src/domain/coordinates/godot_world_position.gd")
+const COORDINATE_MAPPER_SCRIPT := preload("res://src/domain/coordinates/coordinate_mapper.gd")
+const ADT_TILE_COORDINATE_SCRIPT := preload("res://src/domain/coordinates/adt_tile_coordinate.gd")
+const ADT_TILE_LOCAL_POSITION_SCRIPT := preload("res://src/domain/coordinates/adt_tile_local_position.gd")
 const REQUIRED_BAKED_TILE_FORMAT_VERSION := 5
 const REQUIRED_SPLAT_TILE_FORMAT_VERSION := 1
 const REQUIRED_CONTROL_SPLAT_TILE_FORMAT_VERSION := 3
 const M2_MATERIAL_REFRESH_VERSION := 2
 const WMO_MATERIAL_REFRESH_VERSION := 10
 
-const TILE_SIZE := 533.33333
-const CHUNK_SIZE := TILE_SIZE / 16.0
+const TILE_SIZE := COORDINATE_MAPPER_SCRIPT.ADT_TILE_SIZE_YARDS
+const CHUNK_SIZE := COORDINATE_MAPPER_SCRIPT.ADT_CHUNK_SIZE_YARDS
 const ADT_CLIFFROCK_WORLD_YAW_OFFSET := PI
 const ADT_WATERFALL_WORLD_YAW_OFFSET := PI * 0.5
 const QUALITY_CUSTOM := "Custom"
@@ -29,6 +34,9 @@ const QUALITY_HIGH := "High"
 
 @export var extracted_dir: String = "res://data/extracted"
 @export var map_name: String = "Azeroth"
+## Optional scene adapter source. Any Node3D may provide the runtime focus.
+@export var streaming_focus_source_path: NodePath
+## Camera used only by the optional automatic overview positioning feature.
 @export var camera_path: NodePath
 @export_enum("Custom", "Performance", "Balanced", "High") var quality_preset: String = QUALITY_CUSTOM
 
@@ -213,6 +221,8 @@ var _tile_min := Vector2i(63, 63)
 var _tile_max := Vector2i(0, 0)
 var _camera_initialized := false
 var _editor_signature := ""
+var _streaming_focus: StreamingFocus
+var _missing_focus_source_reported := false
 var _last_focus_pos := Vector3.ZERO
 var _dbg_chunks_created := 0
 var _dbg_chunks_null := 0
@@ -293,6 +303,8 @@ func _ready() -> void:
 		_tick_editor_streaming()
 	elif auto_position_camera:
 		_position_camera_over_world()
+	if not Engine.is_editor_hint():
+		_capture_streaming_focus_from_source()
 
 	set_process(true)
 	call_deferred("_refresh_streaming_targets_after_ready")
@@ -364,7 +376,7 @@ func _process(delta: float) -> void:
 	if Engine.is_editor_hint():
 		_tick_editor_streaming()
 	else:
-		_refresh_streaming_targets(false)
+		refresh_streaming_focus(false)
 	did_refresh = true
 	_profile_section(timings, "refresh", section_start, profile_enabled)
 	_log_hitch_profile(profile_start, timings, did_refresh, profile_enabled)
@@ -374,6 +386,39 @@ func _exit_tree() -> void:
 	_shutting_down = true
 	_wait_for_tile_tasks()
 	_clear_streamed_world()
+	_release_runtime_caches_for_shutdown()
+
+
+## Frees detached prototype nodes and releases render resources owned by this
+## loader after all asynchronous work has completed. Map refreshes retain these
+## caches; only scene shutdown destroys them.
+func _release_runtime_caches_for_shutdown() -> void:
+	_free_detached_node_cache(_m2_scene_cache)
+	_free_detached_node_cache(_m2_animated_scene_cache)
+	_free_detached_node_cache(_wmo_prototype_cache)
+	_m2_mesh_cache.clear()
+	_m2_static_animation_cache.clear()
+	_m2_missing_cache.clear()
+	_wmo_render_cache.clear()
+	_wmo_scene_resource_cache.clear()
+	_wmo_render_missing_cache.clear()
+	_wmo_scene_cache_missing.clear()
+	_wmo_missing_cache.clear()
+	_shared_tex_cache.clear()
+
+
+func _free_detached_node_cache(node_cache: Dictionary) -> void:
+	for cached_value in node_cache.values():
+		if not (cached_value is Node):
+			continue
+		var cached_node := cached_value as Node
+		if not is_instance_valid(cached_node):
+			continue
+		if cached_node.is_inside_tree():
+			cached_node.queue_free()
+		else:
+			cached_node.free()
+	node_cache.clear()
 
 
 func _apply_quality_preset() -> void:
@@ -557,10 +602,11 @@ func _tick_editor_streaming() -> void:
 
 	var focus_world := _tile_center_to_world(editor_preview_center_x, editor_preview_center_y)
 	if editor_follow_view_camera:
-		var editor_camera := _get_stream_camera()
+		var editor_camera := _get_editor_view_camera()
 		if editor_camera:
 			focus_world += editor_camera.global_position
-	_refresh_editor_streaming_targets_at(focus_world, false)
+	_set_streaming_focus_from_vector3(focus_world)
+	_refresh_editor_streaming_targets_at(_streaming_focus_to_vector3(), false)
 
 
 func _scan_available_tiles() -> void:
@@ -648,24 +694,28 @@ func _load_tiles_from_directory() -> void:
 		_tile_max.y = max(_tile_max.y, ty)
 
 
-func _refresh_streaming_targets(force: bool) -> void:
-	var camera := _get_stream_camera()
-	if camera == null:
-		return
+## Replaces the current streaming point without requiring a Node or Camera3D.
+func set_streaming_focus(streaming_focus: StreamingFocus) -> void:
+	_streaming_focus = streaming_focus
+
+
+## Samples the configured scene source, then refreshes streaming from the typed focus.
+## Returns false when no valid focus is available; existing streamed content is retained.
+func refresh_streaming_focus(force: bool = false) -> bool:
+	_capture_streaming_focus_from_source()
+	if _streaming_focus == null or _streaming_focus.world_position == null:
+		return false
 	_terrain_root.position = Vector3.ZERO
-	_refresh_streaming_targets_at(camera.global_position, force)
+	_refresh_streaming_targets_at(_streaming_focus_to_vector3(), force)
+	return true
 
 
 func _refresh_streaming_targets_after_ready() -> void:
-	var camera := _get_stream_camera()
-	if camera == null:
-		return
-	_terrain_root.position = Vector3.ZERO
 	_has_refresh_focus = false
-	_refresh_streaming_targets_at(camera.global_position, false)
+	refresh_streaming_focus(false)
 
 
-## Core streaming update — works for both game (camera pos) and editor (preview center pos).
+## Core streaming update for runtime and editor focus positions.
 func _refresh_editor_streaming_targets_at(focus_pos: Vector3, force: bool) -> void:
 	if not force and not _should_refresh_focus(focus_pos):
 		return
@@ -739,10 +789,9 @@ func _apply_streaming_target(wanted_tiles: Dictionary, retained_tiles: Dictionar
 			var parts: PackedStringArray = key.split("_")
 			var tx: int = int(parts[0])
 			var ty: int = int(parts[1])
-			var tcx: float = (tx + 0.5) * TILE_SIZE
-			var tcz: float = (ty + 0.5) * TILE_SIZE
-			var dx: float = tcx - focus_pos.x
-			var dz: float = tcz - focus_pos.z
+			var tile_center := _tile_center_to_world(tx, ty)
+			var dx: float = tile_center.x - focus_pos.x
+			var dz: float = tile_center.z - focus_pos.z
 			_tile_load_queue.append({
 				"key":      key,
 				"tx":       tx,
@@ -2073,7 +2122,7 @@ func _wait_for_tile_tasks() -> void:
 			var path: String = String(pending.get("path", ""))
 			if not path.is_empty():
 				var status := ResourceLoader.load_threaded_get_status(path)
-				if status == ResourceLoader.THREAD_LOAD_LOADED:
+				if status == ResourceLoader.THREAD_LOAD_IN_PROGRESS or status == ResourceLoader.THREAD_LOAD_LOADED:
 					ResourceLoader.load_threaded_get(path)
 	_tile_loading_tasks.clear()
 
@@ -2094,7 +2143,7 @@ func _wait_for_tile_tasks() -> void:
 		if path.is_empty():
 			continue
 		var status := ResourceLoader.load_threaded_get_status(path)
-		if status == ResourceLoader.THREAD_LOAD_LOADED:
+		if status == ResourceLoader.THREAD_LOAD_IN_PROGRESS or status == ResourceLoader.THREAD_LOAD_LOADED:
 			ResourceLoader.load_threaded_get(path)
 	_m2_mesh_load_requests.clear()
 	_m2_mesh_finalize_queue.clear()
@@ -2105,7 +2154,7 @@ func _wait_for_tile_tasks() -> void:
 		if path.is_empty():
 			continue
 		var status := ResourceLoader.load_threaded_get_status(path)
-		if status == ResourceLoader.THREAD_LOAD_LOADED:
+		if status == ResourceLoader.THREAD_LOAD_IN_PROGRESS or status == ResourceLoader.THREAD_LOAD_LOADED:
 			ResourceLoader.load_threaded_get(path)
 	_m2_animation_load_requests.clear()
 	_m2_animation_finalize_queue.clear()
@@ -2115,7 +2164,7 @@ func _wait_for_tile_tasks() -> void:
 		if path.is_empty():
 			continue
 		var status := ResourceLoader.load_threaded_get_status(path)
-		if status == ResourceLoader.THREAD_LOAD_LOADED:
+		if status == ResourceLoader.THREAD_LOAD_IN_PROGRESS or status == ResourceLoader.THREAD_LOAD_LOADED:
 			ResourceLoader.load_threaded_get(path)
 	_wmo_scene_load_requests.clear()
 
@@ -2124,7 +2173,7 @@ func _wait_for_tile_tasks() -> void:
 		if path.is_empty():
 			continue
 		var status := ResourceLoader.load_threaded_get_status(path)
-		if status == ResourceLoader.THREAD_LOAD_LOADED:
+		if status == ResourceLoader.THREAD_LOAD_IN_PROGRESS or status == ResourceLoader.THREAD_LOAD_LOADED:
 			ResourceLoader.load_threaded_get(path)
 	_wmo_render_load_requests.clear()
 	_wmo_render_missing_cache.clear()
@@ -2137,7 +2186,7 @@ func _wait_for_tile_tasks() -> void:
 		if path.is_empty():
 			continue
 		var status := ResourceLoader.load_threaded_get_status(path)
-		if status == ResourceLoader.THREAD_LOAD_LOADED:
+		if status == ResourceLoader.THREAD_LOAD_IN_PROGRESS or status == ResourceLoader.THREAD_LOAD_LOADED:
 			ResourceLoader.load_threaded_get(path)
 	_terrain_upgrade_tasks.clear()
 
@@ -2148,7 +2197,7 @@ func _wait_for_tile_tasks() -> void:
 		if path.is_empty():
 			continue
 		var status := ResourceLoader.load_threaded_get_status(path)
-		if status == ResourceLoader.THREAD_LOAD_LOADED:
+		if status == ResourceLoader.THREAD_LOAD_IN_PROGRESS or status == ResourceLoader.THREAD_LOAD_LOADED:
 			ResourceLoader.load_threaded_get(path)
 	_terrain_control_splat_cache_tasks.clear()
 
@@ -2162,7 +2211,7 @@ func _wait_for_tile_tasks() -> void:
 		if path.is_empty():
 			continue
 		var status := ResourceLoader.load_threaded_get_status(path)
-		if status == ResourceLoader.THREAD_LOAD_LOADED:
+		if status == ResourceLoader.THREAD_LOAD_IN_PROGRESS or status == ResourceLoader.THREAD_LOAD_LOADED:
 			ResourceLoader.load_threaded_get(path)
 	_terrain_splat_cache_tasks.clear()
 	_terrain_splat_result_mutex.lock()
@@ -2781,15 +2830,27 @@ func _clear_streamed_world() -> void:
 				_free_render_instance(chunk_rid)
 		var tile_root: Node = state.get("root", null)
 		if tile_root:
-			tile_root.queue_free()
+			_queue_free_streamed_node(tile_root)
 
 	_tile_states.clear()
 	_clear_tile_mesh_cache()
 	_clear_quality_terrain_mesh_cache()
 	_clear_wmo_registry()
-	_ensure_world_wmo_root()
-	if enable_wmo:
-		_place_global_wmo()
+	if not _shutting_down:
+		_ensure_world_wmo_root()
+		if enable_wmo:
+			_place_global_wmo()
+
+
+## During world shutdown, parented nodes are recursively owned by the world
+## root. Queueing them separately from `_exit_tree()` can detach them from that
+## deletion and leave empty Node objects alive at engine teardown.
+func _queue_free_streamed_node(node: Node) -> void:
+	if node == null or not is_instance_valid(node):
+		return
+	if _shutting_down and node.is_inside_tree():
+		return
+	node.queue_free()
 
 
 func _reset_terrain_root_children() -> void:
@@ -2850,8 +2911,10 @@ func _predictive_focus_tiles(focus_pos: Vector3) -> Array[Vector2i]:
 	if threshold <= 0.0:
 		return result
 
-	var local_x := fposmod(focus_pos.x, TILE_SIZE) / TILE_SIZE
-	var local_z := fposmod(focus_pos.z, TILE_SIZE) / TILE_SIZE
+	var typed_focus_position = GODOT_WORLD_POSITION_SCRIPT.new(focus_pos.x, focus_pos.y, focus_pos.z)
+	var tile_local_position = COORDINATE_MAPPER_SCRIPT.godot_to_adt_tile_local(typed_focus_position)
+	var local_x: float = tile_local_position.east_yards / TILE_SIZE
+	var local_z: float = tile_local_position.south_yards / TILE_SIZE
 	var x_offsets: Array[int] = [0]
 	var z_offsets: Array[int] = [0]
 
@@ -2974,10 +3037,17 @@ func _is_tile_chunk_set_ready(state: Dictionary) -> bool:
 
 
 func _tile_dist_sq(state: Dictionary, cam_pos: Vector3) -> float:
-	var min_x: float = float(state["tx"]) * TILE_SIZE
-	var max_x: float = min_x + TILE_SIZE
-	var min_z: float = float(state["ty"]) * TILE_SIZE
-	var max_z: float = min_z + TILE_SIZE
+	var tile_coordinate = ADT_TILE_COORDINATE_SCRIPT.new(int(state["tx"]), int(state["ty"]))
+	var north_west_position = COORDINATE_MAPPER_SCRIPT.adt_tile_local_to_godot(
+		tile_coordinate,
+		ADT_TILE_LOCAL_POSITION_SCRIPT.new(0.0, 0.0, 0.0))
+	var south_east_position = COORDINATE_MAPPER_SCRIPT.adt_tile_local_to_godot(
+		tile_coordinate,
+		ADT_TILE_LOCAL_POSITION_SCRIPT.new(TILE_SIZE, 0.0, TILE_SIZE))
+	var min_x: float = north_west_position.x_units
+	var max_x: float = south_east_position.x_units
+	var min_z: float = north_west_position.z_units
+	var max_z: float = south_east_position.z_units
 
 	var dx := 0.0
 	if cam_pos.x < min_x:
@@ -3003,32 +3073,46 @@ func _is_tile_queued(key: String) -> bool:
 	return false
 
 
-func _get_stream_camera() -> Camera3D:
-	if Engine.is_editor_hint():
-		# The 3D editor viewport camera lives in EditorInterface, not get_viewport().
-		# get_viewport().get_camera_3d() from a @tool script returns whichever Camera3D
-		# belongs to the edited scene (often null), so editor-view movement is invisible
-		# unless we reach into EditorInterface.
-		var vp := EditorInterface.get_editor_viewport_3d(0)
-		if vp != null:
-			var cam := vp.get_camera_3d()
-			if cam:
-				return cam
+func _capture_streaming_focus_from_source() -> void:
+	if streaming_focus_source_path == NodePath():
+		return
+	var focus_source := get_node_or_null(streaming_focus_source_path) as Node3D
+	if focus_source == null:
+		if not _missing_focus_source_reported:
+			push_warning("Streaming focus source is missing or is not Node3D: %s" % streaming_focus_source_path)
+			_missing_focus_source_reported = true
+		return
+	_missing_focus_source_reported = false
+	_set_streaming_focus_from_vector3(focus_source.global_position)
 
-	if camera_path != NodePath():
-		var from_path := get_node_or_null(camera_path)
-		if from_path is Camera3D:
-			return from_path
 
-	var viewport_camera := get_viewport().get_camera_3d()
-	if viewport_camera:
-		return viewport_camera
+func _set_streaming_focus_from_vector3(world_position: Vector3) -> void:
+	var typed_world_position = GODOT_WORLD_POSITION_SCRIPT.new(
+		world_position.x,
+		world_position.y,
+		world_position.z
+	)
+	set_streaming_focus(STREAMING_FOCUS_SCRIPT.new(typed_world_position))
 
-	for child in get_children():
-		if child is Camera3D and child.current:
-			return child
 
-	return null
+func _streaming_focus_to_vector3() -> Vector3:
+	var world_position: GodotWorldPosition = _streaming_focus.world_position
+	return Vector3(world_position.x_units, world_position.y_units, world_position.z_units)
+
+
+func _get_editor_view_camera() -> Camera3D:
+	# EditorInterface owns this camera. This method is the explicit editor adapter;
+	# runtime streaming never discovers a viewport camera.
+	var editor_viewport := EditorInterface.get_editor_viewport_3d(0)
+	if editor_viewport == null:
+		return null
+	return editor_viewport.get_camera_3d()
+
+
+func _get_auto_position_camera() -> Camera3D:
+	if camera_path == NodePath():
+		return null
+	return get_node_or_null(camera_path) as Camera3D
 
 
 func _can_use_baked_tile_cache() -> bool:
@@ -3889,10 +3973,10 @@ func _clear_wmo_registry() -> void:
 		var entry: Dictionary = entry_variant
 		var node: Node = entry.get("node", null)
 		if node and is_instance_valid(node):
-			node.queue_free()
+			_queue_free_streamed_node(node)
 	_wmo_registry.clear()
 	if _world_wmo_root and is_instance_valid(_world_wmo_root):
-		_world_wmo_root.queue_free()
+		_queue_free_streamed_node(_world_wmo_root)
 	_world_wmo_root = null
 
 
@@ -4458,7 +4542,7 @@ func _cancel_m2_build_job(key: String) -> void:
 	var job: Dictionary = _m2_build_jobs[key]
 	var root: Node = job.get("root", null)
 	if root != null and is_instance_valid(root):
-		root.queue_free()
+		_queue_free_streamed_node(root)
 	_m2_build_jobs.erase(key)
 
 
@@ -5320,13 +5404,13 @@ func _position_camera_over_world() -> void:
 	if _camera_initialized:
 		return
 
-	var camera := _get_stream_camera()
+	var camera := _get_auto_position_camera()
 	if camera == null:
 		return
 
-	var center_tx: float = (_tile_min.x + _tile_max.x) * 0.5
-	var center_ty: float = (_tile_min.y + _tile_max.y) * 0.5
-	var center := _tile_center_to_world(center_tx, center_ty)
+	var minimum_tile_center := _tile_center_to_world(_tile_min.x, _tile_min.y)
+	var maximum_tile_center := _tile_center_to_world(_tile_max.x, _tile_max.y)
+	var center := (minimum_tile_center + maximum_tile_center) * 0.5
 	var tile_span: int = int(max(_tile_max.x - _tile_min.x + 1, _tile_max.y - _tile_min.y + 1))
 	var height: float = max(2000.0, float(tile_span) * TILE_SIZE * 0.18)
 
@@ -5335,19 +5419,19 @@ func _position_camera_over_world() -> void:
 	_camera_initialized = true
 
 
-## Tile (tx, ty) NW corner sits at Godot (tx*TILE_SIZE, 0, ty*TILE_SIZE).
-## This matches wow_to_godot output: chunk origins ≈ (TX*TILE_SIZE, h, TY*TILE_SIZE).
-func _tile_center_to_world(tile_x: float, tile_y: float) -> Vector3:
-	return Vector3(
-		(tile_x + 0.5) * TILE_SIZE,
-		0.0,
-		(tile_y + 0.5) * TILE_SIZE)
+func _tile_center_to_world(tile_x: int, tile_y: int) -> Vector3:
+	var tile_coordinate = ADT_TILE_COORDINATE_SCRIPT.new(tile_x, tile_y)
+	var half_tile_size := TILE_SIZE * 0.5
+	var tile_center_position = COORDINATE_MAPPER_SCRIPT.adt_tile_local_to_godot(
+		tile_coordinate,
+		ADT_TILE_LOCAL_POSITION_SCRIPT.new(half_tile_size, 0.0, half_tile_size))
+	return Vector3(tile_center_position.x_units, tile_center_position.y_units, tile_center_position.z_units)
 
 
 func _world_to_tile(world_pos: Vector3) -> Vector2i:
-	return Vector2i(
-		int(floor(world_pos.x / TILE_SIZE)),
-		int(floor(world_pos.z / TILE_SIZE)))
+	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)
+	return Vector2i(tile_coordinate.tile_x, tile_coordinate.tile_y)
 
 
 func _tile_key(tx: int, ty: int) -> String:

src/tests/fixtures/coordinate_golden_points.json

@@ -0,0 +1,99 @@
+{
+  "schema_version": 1,
+  "coordinate_contract_version": 2,
+  "tolerances": {
+    "position_yards": 0.002,
+    "yaw_radians": 0.000001
+  },
+  "sources": {
+    "azerothcore_playercreateinfo": {
+      "status": "verified",
+      "repository": "azerothcore/database-wotlk",
+      "revision": "68fcf0098b16388093989627f37be530fc91f07d",
+      "path": "sql/base/playercreateinfo.sql",
+      "url": "https://raw.githubusercontent.com/azerothcore/database-wotlk/68fcf0098b16388093989627f37be530fc91f07d/sql/base/playercreateinfo.sql"
+    },
+    "trinitycore_playercreateinfo": {
+      "status": "not_verified",
+      "repository": "TrinityCore/TrinityCore",
+      "branch": "3.3.5",
+      "reason": "The base development schema does not provide a pinned populated playercreateinfo row; verify against a pinned TDB snapshot before claiming equivalence."
+    },
+    "azeroth_32_48_adt": {
+      "status": "verified_private_metadata",
+      "file_name": "Azeroth_32_48.adt",
+      "sha256": "D66E27FD82B461AE38B78562952AED428E619777A3F3E35DD8FF97444644770A",
+      "distribution": "Numeric metadata only; proprietary file remains outside Git."
+    },
+    "original_client_build_12340": {
+      "status": "verified_private_observation",
+      "build": 12340,
+      "manifest": "res://src/tools/render_baseline_manifest.json",
+      "evidence_document": "docs/M00_FINAL_PAIRED_EVIDENCE.md"
+    }
+  },
+  "server_spawns": [
+    {
+      "name": "azerothcore_human_warrior_start",
+      "source": "azerothcore_playercreateinfo",
+      "backend": "AzerothCore",
+      "table": "playercreateinfo",
+      "key": {"race": 1, "class": 1},
+      "map_id": 0,
+      "map_directory": "Azeroth",
+      "zone_id": 12,
+      "server_position": [-8949.95, -132.493, 83.5312],
+      "server_yaw_radians": 0.0,
+      "expected_adt_placement": [26016.616666667, 83.5312, 17199.159666667],
+      "expected_adt_tile": [32, 48],
+      "expected_adt_chunk": [3, 12],
+      "expected_adt_tile_local": [132.493, 83.5312, 416.616666667],
+      "expected_godot_position": [17199.159666667, 83.5312, 26016.616666667],
+      "expected_godot_yaw_radians": 0.0
+    }
+  ],
+  "raw_adt_chunks": [
+    {
+      "name": "azeroth_32_48_mcnk_3_12",
+      "source": "azeroth_32_48_adt",
+      "map_directory": "Azeroth",
+      "adt_tile": [32, 48],
+      "mcnk_index": [3, 12],
+      "raw_header_canonical_origin": [-8933.33203125, -100.0, 84.238929749],
+      "sample_position": "chunk_center",
+      "expected_godot_chunk_center": [17183.333333333, 84.238929749, 26016.665364583]
+    }
+  ],
+  "original_client_points": [
+    {
+      "name": "elwynn_terrain_overview",
+      "source": "original_client_build_12340",
+      "client_position": [-9153.334, 386.666, 180.0],
+      "expected_godot_position": [16680.0, 180.0, 26220.0]
+    },
+    {
+      "name": "elwynn_adt_boundary",
+      "source": "original_client_build_12340",
+      "client_position": [-9523.334, 46.666, 105.0],
+      "expected_godot_position": [17020.0, 105.0, 26590.0]
+    },
+    {
+      "name": "goldshire_dense_m2",
+      "source": "original_client_build_12340",
+      "client_position": [-9400.0, 110.0, 150.0],
+      "expected_godot_position": [16956.666, 150.0, 26466.666]
+    },
+    {
+      "name": "goldshire_inn_large_wmo",
+      "source": "original_client_build_12340",
+      "client_position": [-9385.0, 53.0, 72.0],
+      "expected_godot_position": [17013.666, 72.0, 26451.666]
+    },
+    {
+      "name": "elwynn_waterfall_liquid",
+      "source": "original_client_build_12340",
+      "client_position": [-9300.0, 585.0, 190.0],
+      "expected_godot_position": [16481.666, 190.0, 26366.666]
+    }
+  ]
+}

src/tools/capture_render_checkpoints.gd

@@ -2,6 +2,7 @@ extends SceneTree
 
 const DEFAULT_MANIFEST_PATH := "res://src/tools/render_baseline_manifest.json"
 const M2_NATIVE_ANIMATED_BUILDER := preload("res://addons/mpq_extractor/loaders/m2_native_animated_builder.gd")
+const SHUTDOWN_DRAIN_FRAMES := 2
 
 
 func _initialize() -> void:
@@ -22,6 +23,10 @@ func _capture_async() -> void:
 	var measure_seconds := float(_arg(args, "--measure", str(manifest.get("default_measure_seconds", 3.0))))
 	var revision := _arg(args, "--revision", "worktree")
 	var cache_state := _arg(args, "--cache-state", "existing")
+	var camera_fov_override := float(_arg(args, "--camera-fov", str(manifest.get("camera_fov", 62.0))))
+	var camera_yaw_offset_degrees := float(_arg(args, "--camera-yaw-offset", "0.0"))
+	var camera_pitch_offset_degrees := float(_arg(args, "--camera-pitch-offset", "0.0"))
+	var single_pass := args.has("--single-pass")
 	var headless := DisplayServer.get_name().to_lower() == "headless"
 	var dry_run := args.has("--dry-run") or headless
 	var viewport: Array = manifest.get("viewport", [1280, 900])
@@ -55,16 +60,17 @@ func _capture_async() -> void:
 	var camera := Camera3D.new()
 	camera.name = "CheckpointCamera"
 	camera.current = true
-	camera.fov = float(manifest.get("camera_fov", 62.0))
+	camera.fov = camera_fov_override
 	camera.far = 50000.0
 	camera.position = _vector3(first.get("camera", [0.0, 0.0, 0.0]))
 	(world as Node3D).add_child(camera)
-	world.set("camera_path", NodePath("CheckpointCamera"))
+	world.set("streaming_focus_source_path", NodePath("CheckpointCamera"))
 	world.set("debug_streaming", true)
 	world.set("runtime_stats_enabled", true)
 	get_root().add_child(world)
 	await process_frame
 	await process_frame
+	camera.make_current()
 
 	var player := world.get_node_or_null("ThirdPersonPlayer") as Node3D
 	if player != null:
@@ -82,6 +88,9 @@ func _capture_async() -> void:
 		"created_utc": Time.get_datetime_string_from_system(true, true),
 		"dry_run": dry_run,
 		"cache_state": cache_state,
+		"camera_fov": camera_fov_override,
+		"camera_yaw_offset_degrees": camera_yaw_offset_degrees,
+		"camera_pitch_offset_degrees": camera_pitch_offset_degrees,
 		"environment": _environment_metadata(),
 		"comparison_budgets": manifest.get("comparison_budgets", {}),
 		"cache_contract": manifest.get("cache_contract", {}),
@@ -90,6 +99,8 @@ func _capture_async() -> void:
 	}
 	var captured := 0
 	var passes := ["cold_process", "warm_revisit"]
+	if single_pass:
+		passes = ["cold_process"]
 	if dry_run:
 		passes = ["dry_run"]
 
@@ -110,18 +121,22 @@ func _capture_async() -> void:
 
 			camera.global_position = _vector3(checkpoint.get("camera", [0.0, 0.0, 0.0]))
 			_orient_camera_without_roll(camera, _vector3(checkpoint.get("target", [0.0, 0.0, 0.0])))
+			_apply_camera_pose_offsets(camera, camera_yaw_offset_degrees, camera_pitch_offset_degrees)
+			camera.make_current()
 			if player != null:
 				player.global_position = _vector3(checkpoint.get("player", checkpoint.get("target", [0.0, 0.0, 0.0])))
 			_set_sky_time(world, float(checkpoint.get("time_hours", 13.0)))
-			if world.has_method("_refresh_streaming_targets_at"):
-				world.call("_refresh_streaming_targets_at", camera.global_position, true)
+			if world.has_method("refresh_streaming_focus"):
+				world.call("refresh_streaming_focus", true)
 
 			if dry_run:
-				print("RENDER_CHECKPOINT dry_run name=%s coverage=%s camera=%s target=%s time=%.2f" % [
+				print("RENDER_CHECKPOINT dry_run name=%s coverage=%s camera=%s target=%s yaw_offset=%.2f pitch_offset=%.2f time=%.2f" % [
 					checkpoint_name,
 					str(checkpoint.get("coverage", [])),
 					camera.global_position,
 					_vector3(checkpoint.get("target", [0.0, 0.0, 0.0])),
+					camera_yaw_offset_degrees,
+					camera_pitch_offset_degrees,
 					float(checkpoint.get("time_hours", 13.0)),
 				])
 				(report["results"] as Array).append(_result_record(checkpoint, pass_name, 0.0, {}, ""))
@@ -163,6 +178,10 @@ func _capture_async() -> void:
 	print("RENDER_BASELINE report=%s results=%d" % [report_path, captured])
 
 	world.queue_free()
+	# SceneTree deletion is deferred. Allow the world and its queued children
+	# to run their shutdown paths before engine teardown.
+	for unused_frame in SHUTDOWN_DRAIN_FRAMES:
+		await process_frame
 	if captured <= 0:
 		push_error("No checkpoints selected. --only filter was: %s" % only)
 		quit(1)
@@ -206,6 +225,11 @@ func _orient_camera_without_roll(camera: Camera3D, target_position: Vector3) ->
 	camera.global_basis = Basis(right, corrected_up, -forward)
 
 
+func _apply_camera_pose_offsets(camera: Camera3D, yaw_offset_degrees: float, pitch_offset_degrees: float) -> void:
+	camera.global_rotate(Vector3.UP, deg_to_rad(yaw_offset_degrees))
+	camera.rotate_object_local(Vector3.RIGHT, deg_to_rad(pitch_offset_degrees))
+
+
 func _result_record(checkpoint: Dictionary, pass_name: String, load_time_ms: float, metrics: Dictionary, sha256: String) -> Dictionary:
 	return {
 		"name": checkpoint.get("name", "checkpoint"),
@@ -222,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
@@ -241,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:

src/tools/compare_render_checkpoints.gd

@@ -3,6 +3,7 @@ extends SceneTree
 ## Compares original-client JPG/PNG references with OpenWC checkpoint PNGs.
 ## Usage: godot --headless --path . --script res://src/tools/compare_render_checkpoints.gd --
 ##   --reference <directory> --candidate <directory> [--output <report.json>]
+##   [--region x,y,width,height]
 ##   [--pixel-threshold 0.04] [--mean-threshold 0.015] [--changed-ratio-threshold 0.01]
 ## Use --self-test for a synthetic regression check that writes only under user://.
 
@@ -56,13 +57,18 @@ func _parse_arguments(raw_arguments: PackedStringArray) -> Dictionary:
 			parsed.self_test = true
 			index += 1
 			continue
-		if argument not in ["--reference", "--candidate", "--output", "--pixel-threshold", "--mean-threshold", "--changed-ratio-threshold"]:
+		if argument not in ["--reference", "--candidate", "--output", "--only", "--region", "--pixel-threshold", "--mean-threshold", "--changed-ratio-threshold"]:
 			return {"error": "unknown argument: %s" % argument}
 		if index + 1 >= raw_arguments.size():
 			return {"error": "missing value for %s" % argument}
 		var key := argument.trim_prefix("--").replace("-", "_")
 		var value := raw_arguments[index + 1]
-		if key.ends_with("threshold"):
+		if key == "region":
+			var region_parse_result := _parse_comparison_region(value)
+			if region_parse_result.has("error"):
+				return region_parse_result
+			parsed[key] = region_parse_result.region
+		elif key.ends_with("threshold"):
 			if not value.is_valid_float():
 				return {"error": "%s requires a number" % argument}
 			parsed[key] = float(value)
@@ -72,14 +78,35 @@ func _parse_arguments(raw_arguments: PackedStringArray) -> Dictionary:
 	return parsed
 
 
+func _parse_comparison_region(value: String) -> Dictionary:
+	var components := value.split(",", false)
+	if components.size() != 4:
+		return {"error": "--region requires x,y,width,height"}
+	for component in components:
+		if not component.strip_edges().is_valid_int():
+			return {"error": "--region components must be integers"}
+	var region := Rect2i(
+		int(components[0]),
+		int(components[1]),
+		int(components[2]),
+		int(components[3])
+	)
+	if region.position.x < 0 or region.position.y < 0 or region.size.x <= 0 or region.size.y <= 0:
+		return {"error": "--region requires non-negative x/y and positive width/height"}
+	return {"region": region}
+
+
 func _compare_directories(reference_directory: String, candidate_directory: String, options: Dictionary) -> Dictionary:
 	reference_directory = ProjectSettings.globalize_path(reference_directory)
 	candidate_directory = ProjectSettings.globalize_path(candidate_directory)
 	var reference_files := _reference_image_file_names(reference_directory)
+	var only_filter := String(options.get("only", "")).to_lower()
 	var results: Array[Dictionary] = []
 	var failed_count := 0
 	var missing_count := 0
 	for file_name in reference_files:
+		if not only_filter.is_empty() and not file_name.get_basename().to_lower().contains(only_filter):
+			continue
 		var reference_path := reference_directory.path_join(file_name)
 		var checkpoint_name := file_name.get_basename()
 		var candidate_file_names := _candidate_file_names(candidate_directory, checkpoint_name)
@@ -105,6 +132,7 @@ func _compare_directories(reference_directory: String, candidate_directory: Stri
 		"pixel_threshold": options.pixel_threshold,
 		"mean_threshold": options.mean_threshold,
 		"changed_ratio_threshold": options.changed_ratio_threshold,
+		"comparison_region": _region_array(options.get("region", Rect2i())),
 		"compared_count": results.size() - missing_count,
 		"failed_count": failed_count,
 		"missing_count": missing_count,
@@ -124,12 +152,22 @@ func _compare_images(reference_path: String, candidate_path: String, options: Di
 			"reference_size": [reference_image.get_width(), reference_image.get_height()],
 			"candidate_size": [candidate_image.get_width(), candidate_image.get_height()],
 		}
+	var comparison_region: Rect2i = options.get("region", Rect2i(Vector2i.ZERO, reference_image.get_size()))
+	if comparison_region == Rect2i():
+		comparison_region = Rect2i(Vector2i.ZERO, reference_image.get_size())
+	var image_region := Rect2i(Vector2i.ZERO, reference_image.get_size())
+	if not image_region.encloses(comparison_region):
+		return {
+			"status": "region_out_of_bounds",
+			"region": _region_array(comparison_region),
+			"image_size": [reference_image.get_width(), reference_image.get_height()],
+		}
 
 	var error_sum := 0.0
 	var changed_pixel_count := 0
-	var pixel_count := reference_image.get_width() * reference_image.get_height()
-	for y in reference_image.get_height():
-		for x in reference_image.get_width():
+	var pixel_count := comparison_region.size.x * comparison_region.size.y
+	for y in range(comparison_region.position.y, comparison_region.end.y):
+		for x in range(comparison_region.position.x, comparison_region.end.x):
 			var perceptual_error := _perceptual_color_error(reference_image.get_pixel(x, y), candidate_image.get_pixel(x, y))
 			error_sum += perceptual_error
 			if perceptual_error > float(options.pixel_threshold):
@@ -141,11 +179,18 @@ func _compare_images(reference_path: String, candidate_path: String, options: Di
 		"status": "passed" if passed else "threshold_exceeded",
 		"width": reference_image.get_width(),
 		"height": reference_image.get_height(),
+		"region": _region_array(comparison_region),
 		"mean_perceptual_error": mean_perceptual_error,
 		"changed_pixel_ratio": changed_pixel_ratio,
 	}
 
 
+func _region_array(region: Rect2i) -> Array[int]:
+	if region == Rect2i():
+		return []
+	return [region.position.x, region.position.y, region.size.x, region.size.y]
+
+
 func _perceptual_color_error(reference_color: Color, candidate_color: Color) -> float:
 	var reference_linear := reference_color.srgb_to_linear()
 	var candidate_linear := candidate_color.srgb_to_linear()
@@ -203,6 +248,7 @@ func _run_self_test() -> int:
 	var changed_directory := root.path_join("changed")
 	for directory_path in [reference_directory, identical_directory, changed_directory]:
 		DirAccess.make_dir_recursive_absolute(ProjectSettings.globalize_path(directory_path))
+		_clear_directory_files(directory_path)
 	var reference_image := Image.create(2, 2, false, Image.FORMAT_RGBA8)
 	reference_image.fill(Color(0.25, 0.5, 0.75, 1.0))
 	var changed_image := reference_image.duplicate()
@@ -225,5 +271,37 @@ func _run_self_test() -> int:
 	if not identical_report.passed or changed_report.passed:
 		push_error("RENDER_CHECKPOINT_DIFF SELF_TEST: expected identical pass and changed failure")
 		return 1
+	var region_options := options.duplicate()
+	region_options["region"] = Rect2i(1, 1, 1, 1)
+	var excluded_change_report := _compare_directories(reference_directory, changed_directory, region_options)
+	if not excluded_change_report.passed or excluded_change_report.comparison_region != [1, 1, 1, 1]:
+		push_error("RENDER_CHECKPOINT_DIFF SELF_TEST: region must exclude pixels outside the rectangle")
+		return 1
+	var out_of_bounds_options := options.duplicate()
+	out_of_bounds_options["region"] = Rect2i(1, 1, 2, 2)
+	var out_of_bounds_result := _compare_images(
+		reference_directory.path_join("synthetic.jpg"),
+		changed_directory.path_join("synthetic__cold_process.png"),
+		out_of_bounds_options
+	)
+	if out_of_bounds_result.status != "region_out_of_bounds":
+		push_error("RENDER_CHECKPOINT_DIFF SELF_TEST: out-of-bounds region must fail")
+		return 1
+	if reference_image.save_jpg(reference_directory.path_join("ignored.jpg"), 1.0) != OK:
+		return 1
+	var filtered_options := options.duplicate()
+	filtered_options["only"] = "synthetic"
+	var filtered_report := _compare_directories(reference_directory, identical_directory, filtered_options)
+	if not filtered_report.passed or filtered_report.compared_count != 2:
+		push_error("RENDER_CHECKPOINT_DIFF SELF_TEST: --only must exclude unrelated references")
+		return 1
 	print("RENDER_CHECKPOINT_DIFF SELF_TEST PASS")
 	return 0
+
+
+func _clear_directory_files(directory_path: String) -> void:
+	var directory := DirAccess.open(directory_path)
+	if directory == null:
+		return
+	for file_name in directory.get_files():
+		directory.remove(file_name)

src/tools/probe_render_camera_occluders.gd

@@ -28,7 +28,7 @@ func _run_async() -> void:
 	camera.name = "OccluderProbeCamera"
 	camera.current = true
 	world.add_child(camera)
-	world.set("camera_path", NodePath(camera.name))
+	world.set("streaming_focus_source_path", NodePath(camera.name))
 	world.set("debug_streaming", false)
 	get_root().add_child(world)
 	await process_frame
@@ -47,8 +47,8 @@ func _run_async() -> void:
 		var camera_position := _vector3(checkpoint.get("camera", []))
 		var target_position := _vector3(checkpoint.get("target", []))
 		camera.global_position = camera_position
-		if world.has_method("_refresh_streaming_targets_at"):
-			world.call("_refresh_streaming_targets_at", camera_position, true)
+		if world.has_method("refresh_streaming_focus"):
+			world.call("refresh_streaming_focus", true)
 		await create_timer(maxf(0.1, wait_seconds)).timeout
 		var geometry_nodes: Array[Node3D] = []
 		_collect_geometry_nodes(world, geometry_nodes)

src/tools/probe_render_terrain_height.gd

@@ -5,7 +5,8 @@ extends SceneTree
 ##   [--wait 3.0] [--output user://render_terrain_height/report.json]
 
 const MANIFEST_PATH := "res://src/tools/render_baseline_manifest.json"
-const TILE_SIZE := 533.33333
+const COORDINATE_MAPPER_SCRIPT := preload("res://src/domain/coordinates/coordinate_mapper.gd")
+const GODOT_WORLD_POSITION_SCRIPT := preload("res://src/domain/coordinates/godot_world_position.gd")
 const RAY_HEIGHT := 5000.0
 
 
@@ -36,7 +37,7 @@ func _run_async() -> void:
 	var camera := Camera3D.new()
 	camera.current = true
 	world.add_child(camera)
-	world.set("camera_path", NodePath(camera.name))
+	world.set("streaming_focus_source_path", NodePath(camera.name))
 	world.set("debug_streaming", false)
 	get_root().add_child(world)
 	await process_frame
@@ -53,8 +54,8 @@ func _run_async() -> void:
 			continue
 		var camera_position := _vector3(checkpoint.get("camera", []))
 		camera.global_position = camera_position
-		if world.has_method("_refresh_streaming_targets_at"):
-			world.call("_refresh_streaming_targets_at", camera_position, true)
+		if world.has_method("refresh_streaming_focus"):
+			world.call("refresh_streaming_focus", true)
 		await create_timer(maxf(0.1, wait_seconds)).timeout
 		var terrain_sample := _sample_terrain(world, camera_position)
 		terrain_sample["name"] = checkpoint.get("name", "checkpoint")
@@ -90,9 +91,7 @@ func _run_async() -> void:
 
 
 func _sample_terrain(world: Node3D, world_position: Vector3) -> Dictionary:
-	var tile_coordinate := Vector2i(
-		int(floor(world_position.x / TILE_SIZE)),
-		int(floor(world_position.z / TILE_SIZE)))
+	var tile_coordinate := _adt_tile_vector2i(world_position)
 	var tile_states: Dictionary = world.get("_tile_states")
 	var highest_terrain_height := -INF
 	var intersected_tile_key := ""
@@ -198,9 +197,7 @@ func _nearest_terrain_sample(world: Node3D, world_position: Vector3) -> Dictiona
 	for radius in [2.0, 5.0, 10.0, 20.0, 40.0]:
 		for offset in [Vector2(radius, 0.0), Vector2(-radius, 0.0), Vector2(0.0, radius), Vector2(0.0, -radius)]:
 			var sample_position := world_position + Vector3(offset.x, 0.0, offset.y)
-			var sample_tile := Vector2i(
-				int(floor(sample_position.x / TILE_SIZE)),
-				int(floor(sample_position.z / TILE_SIZE)))
+			var sample_tile := _adt_tile_vector2i(sample_position)
 			var sample_key := "%d_%d" % [sample_tile.x, sample_tile.y]
 			if not tile_states.has(sample_key):
 				continue
@@ -214,6 +211,12 @@ func _nearest_terrain_sample(world: Node3D, world_position: Vector3) -> Dictiona
 	return {"nearest_sample_distance": null}
 
 
+func _adt_tile_vector2i(world_position: Vector3) -> Vector2i:
+	var typed_world_position = GODOT_WORLD_POSITION_SCRIPT.new(world_position.x, world_position.y, world_position.z)
+	var tile_coordinate = COORDINATE_MAPPER_SCRIPT.godot_to_adt_tile(typed_world_position)
+	return Vector2i(tile_coordinate.tile_x, tile_coordinate.tile_y)
+
+
 func _vector3_array(value: Vector3) -> Array[float]:
 	return [value.x, value.y, value.z]
 

src/tools/server_spawn_render_manifest.json

@@ -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]
+    }
+  ]
+}

src/tools/verify_coordinate_conversion_boundaries.gd

@@ -0,0 +1,140 @@
+extends SceneTree
+
+## Repository-wide M01 gate against manual cross-space world coordinate formulas.
+## Model-local M2/WMO basis transforms and ordinary Godot-space geometry are not
+## world-space conversions and are intentionally outside these signatures.
+
+const SCAN_ROOTS: Array[String] = ["res://src", "res://addons"]
+const SOURCE_EXTENSIONS: Array[String] = ["gd", "cpp", "h", "hpp"]
+const EXCLUDED_DIRECTORY_PREFIXES: Array[String] = ["res://src/native/build/"]
+const GATE_PATH := "res://src/tools/verify_coordinate_conversion_boundaries.gd"
+const COORDINATE_MAPPER_PATH := "res://src/domain/coordinates/coordinate_mapper.gd"
+const CALIBRATION_ORACLE_PATH := "res://src/tools/verify_render_coordinate_calibration.gd"
+const NATIVE_BOUNDARY_PATH := "res://src/native/src/wow_chunk_reader.h"
+const ALLOWED_LEGACY_NAME_PATHS: Array[String] = [
+	NATIVE_BOUNDARY_PATH,
+	"res://src/native/src/adt_loader.cpp",
+	"res://src/native/src/wdt_loader.cpp",
+	CALIBRATION_ORACLE_PATH,
+]
+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/tools/probe_render_terrain_height.gd": ["godot_to_adt_tile"],
+}
+
+
+func _initialize() -> void:
+	var failures: Array[String] = []
+	var source_paths: Array[String] = []
+	for scan_root in SCAN_ROOTS:
+		_collect_source_paths(scan_root, source_paths, failures)
+
+	var native_boundary_definition_count := 0
+	var independent_oracle_definition_count := 0
+	for source_path in source_paths:
+		if source_path == GATE_PATH:
+			continue
+		var source := _read_text(source_path, failures)
+		var source_lines := source.split("\n")
+		for line_index in range(source_lines.size()):
+			var source_line := String(source_lines[line_index])
+			var violation := _coordinate_violation(source_path, source_line)
+			if not violation.is_empty():
+				failures.append("%s:%d %s" % [source_path, line_index + 1, violation])
+			if source_path == NATIVE_BOUNDARY_PATH and source_line.contains("inline void wow_to_godot"):
+				native_boundary_definition_count += 1
+			if source_path == CALIBRATION_ORACLE_PATH and source_line.contains("func _wow_to_godot"):
+				independent_oracle_definition_count += 1
+
+	_expect_equal(native_boundary_definition_count, 1, "native world conversion definition count", failures)
+	_expect_equal(independent_oracle_definition_count, 1, "independent calibration oracle count", failures)
+	_verify_required_mapper_calls(failures)
+	_verify_classifier_guards(failures)
+
+	if not failures.is_empty():
+		for failure in failures:
+			push_error("COORDINATE_CONVERSION_BOUNDARIES: %s" % failure)
+		quit(1)
+		return
+
+	print("COORDINATE_CONVERSION_BOUNDARIES PASS files=%d native_boundary=1 oracle=1 consumers=4 classifier_cases=6" % source_paths.size())
+	quit(0)
+
+
+func _coordinate_violation(source_path: String, source_line: String) -> String:
+	var stripped_line := source_line.strip_edges()
+	if stripped_line.is_empty():
+		return ""
+	if (source_line.contains("wow_to_godot") or source_line.contains("godot_to_wow")) and source_path not in ALLOWED_LEGACY_NAME_PATHS:
+		return "manual WoW/Godot conversion name outside mapper boundary"
+	if (source_line.contains("17066.666") or source_line.contains("WOW_WORLD_CENTER")) and source_path not in [NATIVE_BOUNDARY_PATH, CALIBRATION_ORACLE_PATH]:
+		return "manual WoW world-center formula outside native boundary/oracle"
+	if source_line.contains("1600.0 / 3.0") and source_path != COORDINATE_MAPPER_PATH:
+		return "duplicated ADT tile-size formula outside CoordinateMapper"
+	if source_path != COORDINATE_MAPPER_PATH and source_line.contains("floor(") and source_line.contains("TILE_SIZE") and (source_line.contains(".x") or source_line.contains(".z")):
+		return "manual Godot world-position to ADT tile formula"
+	if source_path != COORDINATE_MAPPER_PATH and source_line.contains("fposmod(") and source_line.contains("TILE_SIZE"):
+		return "manual Godot world-position to ADT tile-local formula"
+	if source_path != COORDINATE_MAPPER_PATH and source_line.contains("+ 0.5) * TILE_SIZE"):
+		return "manual ADT tile-center to Godot world-position formula"
+	return ""
+
+
+func _verify_required_mapper_calls(failures: Array[String]) -> void:
+	for source_path in REQUIRED_MAPPER_CALLS:
+		var source := _read_text(source_path, failures)
+		for required_call in REQUIRED_MAPPER_CALLS[source_path]:
+			if not source.contains(String(required_call)):
+				failures.append("%s must call CoordinateMapper.%s" % [source_path, required_call])
+
+
+func _verify_classifier_guards(failures: Array[String]) -> void:
+	_expect_true(not _coordinate_violation("res://src/example.gd", "const CENTER := 17066.666").is_empty(), "world-center classifier", failures)
+	_expect_true(not _coordinate_violation("res://src/example.gd", "func wow_to_godot():").is_empty(), "conversion-name classifier", failures)
+	_expect_true(not _coordinate_violation("res://src/example.gd", "floor(world_position.x / TILE_SIZE)").is_empty(), "world-to-tile classifier", failures)
+	_expect_true(not _coordinate_violation("res://src/example.gd", "fposmod(world_position.z, TILE_SIZE)").is_empty(), "world-to-tile-local classifier", failures)
+	_expect_true(not _coordinate_violation("res://src/example.gd", "(tile_x + 0.5) * TILE_SIZE").is_empty(), "tile-center classifier", failures)
+	_expect_true(_coordinate_violation(NATIVE_BOUNDARY_PATH, "inline void wow_to_godot(float wx) { gx = -(wx - 17066.666f); }").is_empty(), "native boundary exception", failures)
+
+
+func _collect_source_paths(directory_path: String, source_paths: Array[String], failures: Array[String]) -> void:
+	var directory := DirAccess.open(directory_path)
+	if directory == null:
+		failures.append("cannot scan directory %s" % directory_path)
+		return
+	for entry_name in directory.get_files():
+		var source_path := directory_path.path_join(entry_name)
+		if entry_name.get_extension().to_lower() in SOURCE_EXTENSIONS:
+			source_paths.append(source_path)
+	for child_directory_name in directory.get_directories():
+		var child_directory_path := directory_path.path_join(child_directory_name) + "/"
+		if _has_excluded_prefix(child_directory_path):
+			continue
+		_collect_source_paths(child_directory_path.trim_suffix("/"), source_paths, failures)
+
+
+func _has_excluded_prefix(path: String) -> bool:
+	for excluded_prefix in EXCLUDED_DIRECTORY_PREFIXES:
+		if path.begins_with(excluded_prefix):
+			return true
+	return false
+
+
+func _read_text(path: String, failures: Array[String]) -> String:
+	var file := FileAccess.open(path, FileAccess.READ)
+	if file == null:
+		failures.append("cannot open %s" % path)
+		return ""
+	return file.get_as_text()
+
+
+func _expect_equal(actual_value, 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)

src/tools/verify_coordinate_conversion_boundaries.gd.uid

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

src/tools/verify_coordinate_golden_fixtures.gd

@@ -0,0 +1,197 @@
+extends SceneTree
+
+## Validates the non-proprietary M01 coordinate fixture against coordinate
+## contract version 2 and the existing M00 build-12340 manifest. The script does
+## not read server databases, proprietary ADT bytes or original-client images.
+
+const CoordinateMapperScript = preload("res://src/domain/coordinates/coordinate_mapper.gd")
+const CanonicalWowWorldPositionScript = preload("res://src/domain/coordinates/canonical_wow_world_position.gd")
+const ServerWorldPositionScript = preload("res://src/domain/coordinates/server_world_position.gd")
+const ServerWorldYawScript = preload("res://src/domain/coordinates/server_world_yaw.gd")
+
+const FIXTURE_PATH := "res://src/tests/fixtures/coordinate_golden_points.json"
+const RENDER_MANIFEST_PATH := "res://src/tools/render_baseline_manifest.json"
+const SUPPORTED_FIXTURE_SCHEMA_VERSION := 1
+const REQUIRED_COORDINATE_CONTRACT_VERSION := 2
+
+
+func _initialize() -> void:
+	var failures: Array[String] = []
+	var fixture := _load_json_object(FIXTURE_PATH, failures)
+	var render_manifest := _load_json_object(RENDER_MANIFEST_PATH, failures)
+	if fixture.is_empty() or render_manifest.is_empty():
+		_report_and_quit(failures)
+		return
+
+	_expect_equal(fixture.get("schema_version", -1), SUPPORTED_FIXTURE_SCHEMA_VERSION, "fixture schema version", failures)
+	_expect_equal(fixture.get("coordinate_contract_version", -1), REQUIRED_COORDINATE_CONTRACT_VERSION, "coordinate contract version", failures)
+	var position_tolerance_yards := float(fixture.get("tolerances", {}).get("position_yards", 0.0))
+	var yaw_tolerance_radians := float(fixture.get("tolerances", {}).get("yaw_radians", 0.0))
+	_expect_true(position_tolerance_yards > 0.0, "positive position tolerance", failures)
+	_expect_true(yaw_tolerance_radians > 0.0, "positive yaw tolerance", failures)
+	_verify_source_provenance(fixture.get("sources", {}), failures)
+	_verify_server_spawns(fixture.get("server_spawns", []), position_tolerance_yards, yaw_tolerance_radians, failures)
+	_verify_raw_adt_chunks(fixture.get("raw_adt_chunks", []), position_tolerance_yards, failures)
+	_verify_original_client_points(fixture.get("original_client_points", []), render_manifest, position_tolerance_yards, failures)
+
+	if not failures.is_empty():
+		_report_and_quit(failures)
+		return
+	print("COORDINATE_GOLDEN_FIXTURES PASS server_spawns=1 raw_adt_chunks=1 original_client_points=5")
+	quit(0)
+
+
+func _verify_source_provenance(sources: Dictionary, failures: Array[String]) -> void:
+	var azerothcore_source: Dictionary = sources.get("azerothcore_playercreateinfo", {})
+	_expect_equal(azerothcore_source.get("status", ""), "verified", "AzerothCore source status", failures)
+	_expect_equal(String(azerothcore_source.get("revision", "")).length(), 40, "AzerothCore pinned revision length", failures)
+	_expect_true(String(azerothcore_source.get("url", "")).contains(String(azerothcore_source.get("revision", ""))), "AzerothCore URL contains pinned revision", failures)
+
+	var trinitycore_source: Dictionary = sources.get("trinitycore_playercreateinfo", {})
+	_expect_equal(trinitycore_source.get("status", ""), "not_verified", "TrinityCore source status", failures)
+	_expect_true(not String(trinitycore_source.get("reason", "")).is_empty(), "TrinityCore gap reason", failures)
+
+	var adt_source: Dictionary = sources.get("azeroth_32_48_adt", {})
+	_expect_equal(adt_source.get("status", ""), "verified_private_metadata", "ADT source status", failures)
+	_expect_equal(String(adt_source.get("sha256", "")).length(), 64, "ADT SHA-256 length", failures)
+
+
+func _verify_server_spawns(server_spawns: Array, position_tolerance_yards: float, yaw_tolerance_radians: float, failures: Array[String]) -> void:
+	_expect_equal(server_spawns.size(), 1, "server spawn count", failures)
+	for spawn_variant in server_spawns:
+		if not (spawn_variant is Dictionary):
+			failures.append("server spawn must be an object")
+			continue
+		var spawn: Dictionary = spawn_variant
+		var name := String(spawn.get("name", "server_spawn"))
+		var server_position_values := _require_three_numbers(spawn.get("server_position", null), "%s server_position" % name, failures)
+		if server_position_values.is_empty():
+			continue
+		var server_position = ServerWorldPositionScript.new(server_position_values[0], server_position_values[1], server_position_values[2])
+		var canonical_position = CoordinateMapperScript.server_to_canonical(server_position)
+		var godot_position = CoordinateMapperScript.canonical_to_godot(canonical_position)
+		var adt_placement = CoordinateMapperScript.canonical_to_adt_placement(canonical_position)
+		var adt_tile = CoordinateMapperScript.canonical_to_adt_tile(canonical_position)
+		var adt_local = CoordinateMapperScript.canonical_to_adt_tile_local(canonical_position)
+		var adt_chunk = CoordinateMapperScript.adt_tile_local_to_chunk(adt_tile, adt_local)
+
+		_expect_three_near([godot_position.x_units, godot_position.y_units, godot_position.z_units], spawn.get("expected_godot_position", null), position_tolerance_yards, "%s Godot position" % name, failures)
+		_expect_three_near([adt_placement.x_offset_yards, adt_placement.height_yards, adt_placement.z_offset_yards], spawn.get("expected_adt_placement", null), position_tolerance_yards, "%s ADT placement" % name, failures)
+		_expect_three_near([adt_local.east_yards, adt_local.height_yards, adt_local.south_yards], spawn.get("expected_adt_tile_local", null), position_tolerance_yards, "%s ADT local" % name, failures)
+		_expect_pair([adt_tile.tile_x, adt_tile.tile_y], spawn.get("expected_adt_tile", null), "%s ADT tile" % name, failures)
+		_expect_pair([adt_chunk.chunk_x, adt_chunk.chunk_y], spawn.get("expected_adt_chunk", null), "%s ADT chunk" % name, failures)
+
+		var server_yaw = ServerWorldYawScript.new(float(spawn.get("server_yaw_radians", 0.0)))
+		var godot_yaw = CoordinateMapperScript.canonical_to_godot_yaw(CoordinateMapperScript.server_to_canonical_yaw(server_yaw))
+		_expect_near(godot_yaw.radians, float(spawn.get("expected_godot_yaw_radians", 0.0)), yaw_tolerance_radians, "%s Godot yaw" % name, failures)
+
+
+func _verify_raw_adt_chunks(raw_adt_chunks: Array, position_tolerance_yards: float, failures: Array[String]) -> void:
+	_expect_equal(raw_adt_chunks.size(), 1, "raw ADT chunk count", failures)
+	for chunk_variant in raw_adt_chunks:
+		if not (chunk_variant is Dictionary):
+			failures.append("raw ADT chunk must be an object")
+			continue
+		var chunk: Dictionary = chunk_variant
+		var name := String(chunk.get("name", "raw_adt_chunk"))
+		var origin_values := _require_three_numbers(chunk.get("raw_header_canonical_origin", null), "%s raw origin" % name, failures)
+		if origin_values.is_empty():
+			continue
+		var half_chunk_size_yards := CoordinateMapperScript.ADT_CHUNK_SIZE_YARDS * 0.5
+		var chunk_center = CanonicalWowWorldPositionScript.new(
+			origin_values[0] - half_chunk_size_yards,
+			origin_values[1] - half_chunk_size_yards,
+			origin_values[2]
+		)
+		var tile_coordinate = CoordinateMapperScript.canonical_to_adt_tile(chunk_center)
+		var local_position = CoordinateMapperScript.canonical_to_adt_tile_local(chunk_center)
+		var chunk_coordinate = CoordinateMapperScript.adt_tile_local_to_chunk(tile_coordinate, local_position)
+		_expect_pair([tile_coordinate.tile_x, tile_coordinate.tile_y], chunk.get("adt_tile", null), "%s ADT tile" % name, failures)
+		_expect_pair([chunk_coordinate.chunk_x, chunk_coordinate.chunk_y], chunk.get("mcnk_index", null), "%s MCNK index" % name, failures)
+		var godot_center = CoordinateMapperScript.canonical_to_godot(chunk_center)
+		_expect_three_near([godot_center.x_units, godot_center.y_units, godot_center.z_units], chunk.get("expected_godot_chunk_center", null), position_tolerance_yards, "%s Godot center" % name, failures)
+
+
+func _verify_original_client_points(original_client_points: Array, render_manifest: Dictionary, position_tolerance_yards: float, failures: Array[String]) -> void:
+	_expect_equal(original_client_points.size(), 5, "original-client point count", failures)
+	var manifest_checkpoint_by_name: Dictionary = {}
+	for checkpoint_variant in render_manifest.get("checkpoints", []):
+		if checkpoint_variant is Dictionary:
+			manifest_checkpoint_by_name[String(checkpoint_variant.get("name", ""))] = checkpoint_variant
+
+	for point_variant in original_client_points:
+		if not (point_variant is Dictionary):
+			failures.append("original-client point must be an object")
+			continue
+		var point: Dictionary = point_variant
+		var name := String(point.get("name", "original_client_point"))
+		var client_position_values := _require_three_numbers(point.get("client_position", null), "%s client position" % name, failures)
+		if client_position_values.is_empty():
+			continue
+		var canonical_position = CanonicalWowWorldPositionScript.new(client_position_values[0], client_position_values[1], client_position_values[2])
+		var godot_position = CoordinateMapperScript.canonical_to_godot(canonical_position)
+		_expect_three_near([godot_position.x_units, godot_position.y_units, godot_position.z_units], point.get("expected_godot_position", null), position_tolerance_yards, "%s mapped position" % name, failures)
+
+		var manifest_checkpoint: Dictionary = manifest_checkpoint_by_name.get(name, {})
+		_expect_true(not manifest_checkpoint.is_empty(), "%s exists in render manifest" % name, failures)
+		if not manifest_checkpoint.is_empty():
+			_expect_three_near(client_position_values, manifest_checkpoint.get("reference_wow_camera", null), position_tolerance_yards, "%s manifest client position" % name, failures)
+			_expect_three_near(point.get("expected_godot_position", null), manifest_checkpoint.get("camera", null), position_tolerance_yards, "%s manifest Godot position" % name, failures)
+
+
+func _require_three_numbers(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_values, expected_variant, tolerance: float, label: String, failures: Array[String]) -> void:
+	var expected_values := _require_three_numbers(expected_variant, label, failures)
+	if expected_values.is_empty() or not (actual_values is Array) or actual_values.size() != 3:
+		return
+	for component_index in range(3):
+		_expect_near(float(actual_values[component_index]), expected_values[component_index], tolerance, "%s[%d]" % [label, component_index], failures)
+
+
+func _expect_pair(actual_values: Array, expected_variant, label: String, failures: Array[String]) -> void:
+	if not (expected_variant is Array) or expected_variant.size() != 2:
+		failures.append("%s must contain two integers" % label)
+		return
+	_expect_equal(actual_values[0], int(expected_variant[0]), "%s[0]" % label, failures)
+	_expect_equal(actual_values[1], int(expected_variant[1]), "%s[1]" % label, failures)
+
+
+func _expect_near(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 %.9f, got %.9f" % [label, expected_value, actual_value])
+
+
+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 _load_json_object(path: String, failures: Array[String]) -> Dictionary:
+	var file := FileAccess.open(path, FileAccess.READ)
+	if file == null:
+		failures.append("cannot open JSON fixture: %s" % path)
+		return {}
+	var parsed = JSON.parse_string(file.get_as_text())
+	if not (parsed is Dictionary):
+		failures.append("JSON fixture is not an object: %s" % path)
+		return {}
+	return parsed
+
+
+func _report_and_quit(failures: Array[String]) -> void:
+	if failures.is_empty():
+		failures.append("fixture validation stopped without a diagnostic")
+	for failure in failures:
+		push_error("COORDINATE_GOLDEN_FIXTURES: %s" % failure)
+	quit(1)

src/tools/verify_coordinate_golden_fixtures.gd.uid

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

src/tools/verify_coordinate_mapper.gd

@@ -0,0 +1,231 @@
+extends SceneTree
+
+## Headless contract verification for M01 canonical coordinate value objects and
+## [CoordinateMapper]. Uses synthetic boundaries plus five positions observed in
+## the original WoW 3.3.5a build 12340 during the M00 paired renderer session.
+## The Elwynn filename case regression-checks a raw `Azeroth_31_49.adt` corpus.
+
+const CoordinateMapperScript = preload("res://src/domain/coordinates/coordinate_mapper.gd")
+const CanonicalWowWorldPositionScript = preload("res://src/domain/coordinates/canonical_wow_world_position.gd")
+const ServerWorldPositionScript = preload("res://src/domain/coordinates/server_world_position.gd")
+const AdtPlacementPositionScript = preload("res://src/domain/coordinates/adt_placement_position.gd")
+const AdtTileCoordinateScript = preload("res://src/domain/coordinates/adt_tile_coordinate.gd")
+const AdtTileLocalPositionScript = preload("res://src/domain/coordinates/adt_tile_local_position.gd")
+const CanonicalWowWorldYawScript = preload("res://src/domain/coordinates/canonical_wow_world_yaw.gd")
+const ServerWorldYawScript = preload("res://src/domain/coordinates/server_world_yaw.gd")
+
+const RENDER_BASELINE_MANIFEST_PATH := "res://src/tools/render_baseline_manifest.json"
+const GOLDEN_POSITION_TOLERANCE_YARDS := 0.002
+const ROUND_TRIP_TOLERANCE_YARDS := 0.000001
+const BOUNDARY_EPSILON_YARDS := 0.001
+
+
+func _initialize() -> void:
+	var failures: Array[String] = []
+	_verify_build_12340_golden_positions(failures)
+	_verify_server_and_adt_round_trips(failures)
+	_verify_tile_and_chunk_boundaries(failures)
+	_verify_recorded_raw_adt_chunk_axes(failures)
+	_verify_world_yaw_conversions(failures)
+
+	if not failures.is_empty():
+		for failure in failures:
+			push_error("COORDINATE_MAPPER: %s" % failure)
+		quit(1)
+		return
+
+	print("COORDINATE_MAPPER PASS golden_points=5 tile_boundaries=8 raw_mcnk=2 yaw_cases=5")
+	quit(0)
+
+
+func _verify_build_12340_golden_positions(failures: Array[String]) -> void:
+	var manifest := _load_json_object(RENDER_BASELINE_MANIFEST_PATH, failures)
+	if manifest.is_empty():
+		return
+
+	var golden_point_count := 0
+	for checkpoint_variant in manifest.get("checkpoints", []):
+		if not (checkpoint_variant is Dictionary):
+			continue
+		var checkpoint: Dictionary = checkpoint_variant
+		var reference_wow_camera_variant = checkpoint.get("reference_wow_camera", null)
+		if not (reference_wow_camera_variant is Array) or reference_wow_camera_variant.size() != 3:
+			continue
+
+		var expected_godot_camera_variant = checkpoint.get("camera", null)
+		if not (expected_godot_camera_variant is Array) or expected_godot_camera_variant.size() != 3:
+			failures.append("%s has no three-component renderer camera" % checkpoint.get("name", "checkpoint"))
+			continue
+
+		var canonical_position = CanonicalWowWorldPositionScript.new(
+			float(reference_wow_camera_variant[0]),
+			float(reference_wow_camera_variant[1]),
+			float(reference_wow_camera_variant[2])
+		)
+		var godot_position = CoordinateMapperScript.canonical_to_godot(canonical_position)
+		var checkpoint_name := String(checkpoint.get("name", "checkpoint"))
+		_expect_near(godot_position.x_units, float(expected_godot_camera_variant[0]), GOLDEN_POSITION_TOLERANCE_YARDS, "%s Godot X" % checkpoint_name, failures)
+		_expect_near(godot_position.y_units, float(expected_godot_camera_variant[1]), GOLDEN_POSITION_TOLERANCE_YARDS, "%s Godot Y" % checkpoint_name, failures)
+		_expect_near(godot_position.z_units, float(expected_godot_camera_variant[2]), GOLDEN_POSITION_TOLERANCE_YARDS, "%s Godot Z" % checkpoint_name, failures)
+
+		var round_trip_position = CoordinateMapperScript.godot_to_canonical(godot_position)
+		_expect_canonical_position(round_trip_position, canonical_position, ROUND_TRIP_TOLERANCE_YARDS, "%s Godot round trip" % checkpoint_name, failures)
+		golden_point_count += 1
+
+	_expect_equal(golden_point_count, 5, "build 12340 golden point count", failures)
+
+
+func _verify_server_and_adt_round_trips(failures: Array[String]) -> void:
+	var server_position = ServerWorldPositionScript.new(-9153.334, 386.666, 180.0)
+	var canonical_position = CoordinateMapperScript.server_to_canonical(server_position)
+	_expect_near(canonical_position.x_yards, server_position.x_yards, ROUND_TRIP_TOLERANCE_YARDS, "server X remains canonical X", failures)
+	_expect_near(canonical_position.y_yards, server_position.y_yards, ROUND_TRIP_TOLERANCE_YARDS, "server Y remains canonical Y", failures)
+	_expect_near(canonical_position.z_yards, server_position.z_yards, ROUND_TRIP_TOLERANCE_YARDS, "server Z remains canonical Z", failures)
+
+	var round_trip_server = CoordinateMapperScript.canonical_to_server(canonical_position)
+	_expect_near(round_trip_server.x_yards, server_position.x_yards, ROUND_TRIP_TOLERANCE_YARDS, "server X round trip", failures)
+	_expect_near(round_trip_server.y_yards, server_position.y_yards, ROUND_TRIP_TOLERANCE_YARDS, "server Y round trip", failures)
+	_expect_near(round_trip_server.z_yards, server_position.z_yards, ROUND_TRIP_TOLERANCE_YARDS, "server Z round trip", failures)
+
+	var adt_position = CoordinateMapperScript.canonical_to_adt_placement(canonical_position)
+	_expect_near(adt_position.x_offset_yards, 26220.000666666667, GOLDEN_POSITION_TOLERANCE_YARDS, "ADT placement X offset", failures)
+	_expect_near(adt_position.height_yards, 180.0, ROUND_TRIP_TOLERANCE_YARDS, "ADT placement height", failures)
+	_expect_near(adt_position.z_offset_yards, 16680.000666666667, GOLDEN_POSITION_TOLERANCE_YARDS, "ADT placement Z offset", failures)
+	var adt_round_trip = CoordinateMapperScript.adt_placement_to_canonical(adt_position)
+	_expect_canonical_position(adt_round_trip, canonical_position, ROUND_TRIP_TOLERANCE_YARDS, "ADT placement round trip", failures)
+
+	var direct_adt_position = AdtPlacementPositionScript.new(26220.000666666667, 180.0, 16680.000666666667)
+	var direct_canonical = CoordinateMapperScript.adt_placement_to_canonical(direct_adt_position)
+	_expect_canonical_position(direct_canonical, canonical_position, GOLDEN_POSITION_TOLERANCE_YARDS, "direct ADT placement conversion", failures)
+
+
+func _verify_tile_and_chunk_boundaries(failures: Array[String]) -> void:
+	var half_extent := CoordinateMapperScript.WOW_WORLD_HALF_EXTENT_YARDS
+	var tile_size := CoordinateMapperScript.ADT_TILE_SIZE_YARDS
+
+	_expect_tile(CoordinateMapperScript.canonical_to_adt_tile(CanonicalWowWorldPositionScript.new(half_extent, half_extent, 0.0)), 0, 0, true, "north-west extent", failures)
+	_expect_tile(CoordinateMapperScript.canonical_to_adt_tile(CanonicalWowWorldPositionScript.new(0.0, 0.0, 0.0)), 32, 32, true, "map center", failures)
+	_expect_tile(CoordinateMapperScript.canonical_to_adt_tile(CanonicalWowWorldPositionScript.new(BOUNDARY_EPSILON_YARDS, BOUNDARY_EPSILON_YARDS, 0.0)), 31, 31, true, "north-west of center boundary", failures)
+	_expect_tile(CoordinateMapperScript.canonical_to_adt_tile(CanonicalWowWorldPositionScript.new(-BOUNDARY_EPSILON_YARDS, -BOUNDARY_EPSILON_YARDS, 0.0)), 32, 32, true, "south-east of center boundary", failures)
+	_expect_tile(CoordinateMapperScript.canonical_to_adt_tile(CanonicalWowWorldPositionScript.new(-half_extent + BOUNDARY_EPSILON_YARDS, -half_extent + BOUNDARY_EPSILON_YARDS, 0.0)), 63, 63, true, "inside south-east extent", failures)
+	_expect_tile(CoordinateMapperScript.canonical_to_adt_tile(CanonicalWowWorldPositionScript.new(-half_extent, -half_extent, 0.0)), 64, 64, false, "exclusive south-east extent", failures)
+	_expect_tile(CoordinateMapperScript.canonical_to_adt_tile(CanonicalWowWorldPositionScript.new(tile_size, -tile_size, 0.0)), 33, 31, true, "whole-tile offsets", failures)
+	_expect_tile(CoordinateMapperScript.canonical_to_adt_tile(CanonicalWowWorldPositionScript.new(-9153.334, 386.666, 180.0)), 31, 49, true, "raw Azeroth_31_49 filename", failures)
+
+	var tile_coordinate = AdtTileCoordinateScript.new(31, 49)
+	var local_position = CoordinateMapperScript.canonical_to_adt_tile_local(CanonicalWowWorldPositionScript.new(-9153.334, 386.666, 180.0))
+	var local_round_trip = CoordinateMapperScript.adt_tile_local_to_canonical(tile_coordinate, local_position)
+	_expect_canonical_position(local_round_trip, CanonicalWowWorldPositionScript.new(-9153.334, 386.666, 180.0), ROUND_TRIP_TOLERANCE_YARDS, "ADT tile-local round trip", failures)
+	_expect_true(local_position.east_yards >= 0.0 and local_position.east_yards < tile_size, "tile-local east offset is half-open", failures)
+	_expect_true(local_position.south_yards >= 0.0 and local_position.south_yards < tile_size, "tile-local south offset is half-open", failures)
+
+	var godot_position = CoordinateMapperScript.canonical_to_godot(CanonicalWowWorldPositionScript.new(-9153.334, 386.666, 180.0))
+	var direct_godot_tile = CoordinateMapperScript.godot_to_adt_tile(godot_position)
+	var direct_godot_local = CoordinateMapperScript.godot_to_adt_tile_local(godot_position)
+	var direct_godot_round_trip = CoordinateMapperScript.adt_tile_local_to_godot(direct_godot_tile, direct_godot_local)
+	_expect_equal(direct_godot_tile.tile_x, 31, "direct Godot ADT tile X", failures)
+	_expect_equal(direct_godot_tile.tile_y, 49, "direct Godot ADT tile Y", failures)
+	_expect_near(direct_godot_local.east_yards, 146.66677, GOLDEN_POSITION_TOLERANCE_YARDS, "direct Godot tile-local east", failures)
+	_expect_near(direct_godot_local.south_yards, 86.66677, GOLDEN_POSITION_TOLERANCE_YARDS, "direct Godot tile-local south", failures)
+	_expect_near(direct_godot_round_trip.x_units, godot_position.x_units, ROUND_TRIP_TOLERANCE_YARDS, "direct Godot tile-local X round trip", failures)
+	_expect_near(direct_godot_round_trip.y_units, godot_position.y_units, ROUND_TRIP_TOLERANCE_YARDS, "direct Godot tile-local Y round trip", failures)
+	_expect_near(direct_godot_round_trip.z_units, godot_position.z_units, ROUND_TRIP_TOLERANCE_YARDS, "direct Godot tile-local Z round trip", failures)
+
+	var chunk_local_position = AdtTileLocalPositionScript.new(
+		CoordinateMapperScript.ADT_CHUNK_SIZE_YARDS * 2.0,
+		180.0,
+		CoordinateMapperScript.ADT_CHUNK_SIZE_YARDS
+	)
+	var chunk_coordinate = CoordinateMapperScript.adt_tile_local_to_chunk(tile_coordinate, chunk_local_position)
+	_expect_equal(chunk_coordinate.chunk_x, 2, "exact east chunk boundary", failures)
+	_expect_equal(chunk_coordinate.chunk_y, 1, "exact south chunk boundary", failures)
+	_expect_true(chunk_coordinate.is_within_map_grid(), "chunk coordinate is inside map grid", failures)
+
+
+func _verify_recorded_raw_adt_chunk_axes(failures: Array[String]) -> void:
+	var half_chunk_size_yards := CoordinateMapperScript.ADT_CHUNK_SIZE_YARDS * 0.5
+	var recorded_chunk_origins := [
+		{
+			"label": "raw MCNK 0,0",
+			"chunk_x": 0,
+			"chunk_y": 0,
+			"canonical_x_origin": -9066.666015625,
+			"canonical_y_origin": 533.333984375,
+		},
+		{
+			"label": "raw MCNK 15,15",
+			"chunk_x": 15,
+			"chunk_y": 15,
+			"canonical_x_origin": -9566.666015625,
+			"canonical_y_origin": 33.333984375,
+		},
+	]
+	for recorded_chunk_origin in recorded_chunk_origins:
+		var chunk_center = CanonicalWowWorldPositionScript.new(
+			float(recorded_chunk_origin.canonical_x_origin) - half_chunk_size_yards,
+			float(recorded_chunk_origin.canonical_y_origin) - half_chunk_size_yards,
+			0.0
+		)
+		var tile_coordinate = CoordinateMapperScript.canonical_to_adt_tile(chunk_center)
+		_expect_tile(tile_coordinate, 31, 49, true, String(recorded_chunk_origin.label), failures)
+		var local_position = CoordinateMapperScript.canonical_to_adt_tile_local(chunk_center)
+		var chunk_coordinate = CoordinateMapperScript.adt_tile_local_to_chunk(tile_coordinate, local_position)
+		_expect_equal(chunk_coordinate.chunk_x, int(recorded_chunk_origin.chunk_x), "%s chunk X" % recorded_chunk_origin.label, failures)
+		_expect_equal(chunk_coordinate.chunk_y, int(recorded_chunk_origin.chunk_y), "%s chunk Y" % recorded_chunk_origin.label, failures)
+
+
+func _verify_world_yaw_conversions(failures: Array[String]) -> void:
+	var yaw_cases := [0.0, PI * 0.5, -PI * 0.5, PI, TAU + 0.25]
+	for yaw_radians in yaw_cases:
+		var server_yaw = ServerWorldYawScript.new(float(yaw_radians))
+		var canonical_yaw = CoordinateMapperScript.server_to_canonical_yaw(server_yaw)
+		var godot_yaw = CoordinateMapperScript.canonical_to_godot_yaw(canonical_yaw)
+		var canonical_round_trip = CoordinateMapperScript.godot_to_canonical_yaw(godot_yaw)
+		var server_round_trip = CoordinateMapperScript.canonical_to_server_yaw(canonical_round_trip)
+		var expected_normalized_yaw := fposmod(float(yaw_radians) + PI, TAU) - PI
+		_expect_near(canonical_yaw.radians, expected_normalized_yaw, ROUND_TRIP_TOLERANCE_YARDS, "canonical yaw normalization", failures)
+		_expect_near(godot_yaw.radians, expected_normalized_yaw, ROUND_TRIP_TOLERANCE_YARDS, "Godot yaw basis", failures)
+		_expect_near(server_round_trip.radians, expected_normalized_yaw, ROUND_TRIP_TOLERANCE_YARDS, "server yaw round trip", failures)
+
+	var canonical_pi_yaw = CanonicalWowWorldYawScript.new(PI)
+	var normalized_godot_yaw = CoordinateMapperScript.canonical_to_godot_yaw(canonical_pi_yaw)
+	_expect_near(normalized_godot_yaw.radians, -PI, ROUND_TRIP_TOLERANCE_YARDS, "positive PI normalizes to negative PI", failures)
+
+
+func _expect_tile(tile_coordinate, expected_x: int, expected_y: int, expected_valid: bool, label: String, failures: Array[String]) -> void:
+	_expect_equal(tile_coordinate.tile_x, expected_x, "%s tile X" % label, failures)
+	_expect_equal(tile_coordinate.tile_y, expected_y, "%s tile Y" % label, failures)
+	_expect_equal(tile_coordinate.is_within_map_grid(), expected_valid, "%s validity" % label, failures)
+
+
+func _expect_canonical_position(actual_position, expected_position, tolerance: float, label: String, failures: Array[String]) -> void:
+	_expect_near(actual_position.x_yards, expected_position.x_yards, tolerance, "%s X" % label, failures)
+	_expect_near(actual_position.y_yards, expected_position.y_yards, tolerance, "%s Y" % label, failures)
+	_expect_near(actual_position.z_yards, expected_position.z_yards, tolerance, "%s Z" % label, failures)
+
+
+func _expect_near(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 %.9f, got %.9f" % [label, expected_value, actual_value])
+
+
+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 _load_json_object(path: String, failures: Array[String]) -> Dictionary:
+	var file := FileAccess.open(path, FileAccess.READ)
+	if file == null:
+		failures.append("cannot open JSON fixture: %s" % path)
+		return {}
+	var parsed = JSON.parse_string(file.get_as_text())
+	if not (parsed is Dictionary):
+		failures.append("JSON fixture is not an object: %s" % path)
+		return {}
+	return parsed

src/tools/verify_coordinate_mapper.gd.uid

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

src/tools/verify_domain_identities.gd

@@ -0,0 +1,87 @@
+extends SceneTree
+
+## Headless M01 contract verification for non-interchangeable identity values.
+
+const ContentIdScript = preload("res://src/domain/identity/content_id.gd")
+const EntityIdScript = preload("res://src/domain/identity/entity_id.gd")
+const WowGuidScript = preload("res://src/domain/identity/wow_guid.gd")
+const ServerEntryIdScript = preload("res://src/domain/identity/server_entry_id.gd")
+
+
+func _initialize() -> void:
+	var failures: Array[String] = []
+	_verify_content_id(failures)
+	_verify_entity_id(failures)
+	_verify_wow_guid(failures)
+	_verify_server_entry_id(failures)
+	_verify_scene_free_sources(failures)
+
+	if not failures.is_empty():
+		for failure in failures:
+			push_error("DOMAIN_IDENTITIES: %s" % failure)
+		quit(1)
+		return
+
+	print("DOMAIN_IDENTITIES PASS content=5 entity=5 wow_guid=6 server_entry=5")
+	quit(0)
+
+
+func _verify_content_id(failures: Array[String]) -> void:
+	var normalized = ContentIdScript.new(" 123E4567-E89B-42D3-A456-426614174000 ")
+	_expect_true(normalized.is_valid(), "normalized ContentId is valid", failures)
+	_expect_equal(normalized.to_key(), "123e4567-e89b-42d3-a456-426614174000", "ContentId canonical key", failures)
+	_expect_true(normalized.equals(ContentIdScript.new("123e4567-e89b-42d3-a456-426614174000")), "equal ContentIds", failures)
+	_expect_true(not normalized.equals(ContentIdScript.new("123e4567-e89b-42d3-a456-426614174001")), "different ContentIds", failures)
+	_expect_true(not ContentIdScript.new("123e4567e89b42d3a456426614174000").is_valid(), "malformed ContentId", failures)
+
+
+func _verify_entity_id(failures: Array[String]) -> void:
+	var entity_id = EntityIdScript.new(42)
+	_expect_true(entity_id.is_valid(), "positive EntityId", failures)
+	_expect_true(not EntityIdScript.new(0).is_valid(), "zero EntityId", failures)
+	_expect_true(not EntityIdScript.new(-1).is_valid(), "negative EntityId", failures)
+	_expect_true(entity_id.equals(EntityIdScript.new(42)), "equal EntityIds", failures)
+	_expect_equal(entity_id.to_debug_key(), "entity:42", "EntityId diagnostic key", failures)
+
+
+func _verify_wow_guid(failures: Array[String]) -> void:
+	var guid = WowGuidScript.new(0xf1300000, 0xffffffff)
+	_expect_true(guid.has_valid_word_ranges(), "maximum GUID low word", failures)
+	_expect_equal(guid.to_hex_string(), "f1300000ffffffff", "GUID hexadecimal form", failures)
+	_expect_true(guid.equals(WowGuidScript.new(0xf1300000, 0xffffffff)), "equal GUID words", failures)
+	_expect_true(WowGuidScript.new(0, 0).is_empty(), "zero GUID sentinel", failures)
+	_expect_true(not WowGuidScript.new(-1, 0).has_valid_word_ranges(), "negative GUID word", failures)
+	_expect_true(not WowGuidScript.new(0x100000000, 0).has_valid_word_ranges(), "overflow GUID word", failures)
+
+
+func _verify_server_entry_id(failures: Array[String]) -> void:
+	var creature_entry = ServerEntryIdScript.new(" Creature_Template ", 123)
+	var gameobject_entry = ServerEntryIdScript.new("gameobject_template", 123)
+	_expect_true(creature_entry.is_valid(), "namespaced server entry", failures)
+	_expect_equal(creature_entry.to_key(), "creature_template:123", "server entry key", failures)
+	_expect_true(not creature_entry.equals(gameobject_entry), "cross-table entry collision prevented", failures)
+	_expect_true(not ServerEntryIdScript.new("", 123).is_valid(), "missing entry namespace", failures)
+	_expect_true(not ServerEntryIdScript.new("creature_template", 0).is_valid(), "zero server entry", failures)
+
+
+func _verify_scene_free_sources(failures: Array[String]) -> void:
+	for file_name in ["content_id.gd", "entity_id.gd", "wow_guid.gd", "server_entry_id.gd"]:
+		var path := "res://src/domain/identity/%s" % file_name
+		var file := FileAccess.open(path, FileAccess.READ)
+		if file == null:
+			failures.append("cannot open %s" % path)
+			continue
+		var source := file.get_as_text()
+		_expect_true(not source.contains("extends Node"), "%s does not inherit Node" % file_name, failures)
+		_expect_true(not source.contains("extends Resource"), "%s does not inherit Resource" % file_name, failures)
+		_expect_true(not source.contains("Vector3"), "%s does not expose Vector3" % file_name, 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)

src/tools/verify_domain_identities.gd.uid

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

src/tools/verify_render_runtime_cache_shutdown.gd

@@ -0,0 +1,77 @@
+extends SceneTree
+
+const STREAMING_WORLD_LOADER := preload("res://src/scenes/streaming/streaming_world_loader.gd")
+const ADT_BUILDER := preload("res://addons/mpq_extractor/loaders/adt_builder.gd")
+
+var _failures := 0
+
+
+func _initialize() -> void:
+	_verify_empty_water_root_ownership()
+	_verify_runtime_cache_ownership()
+
+	if _failures > 0:
+		push_error("Render runtime cache shutdown verification failed: %d issue(s)" % _failures)
+		quit(1)
+		return
+	print("Render runtime cache shutdown verification passed.")
+	quit(0)
+
+
+func _verify_empty_water_root_ownership() -> void:
+	var node_count_before := int(Performance.get_monitor(Performance.OBJECT_NODE_COUNT))
+	var empty_water_root: Node3D = ADT_BUILDER.build_tile_water_scene({"chunks": []}, Vector3.ZERO)
+	var node_count_after := int(Performance.get_monitor(Performance.OBJECT_NODE_COUNT))
+	_expect(empty_water_root == null, "empty ADT liquid payload should not produce a water root")
+	_expect(node_count_after == node_count_before, "empty ADT liquid payload should release its temporary water root")
+
+
+func _verify_runtime_cache_ownership() -> void:
+	var loader: Node = STREAMING_WORLD_LOADER.new()
+	var static_m2_prototype := Node3D.new()
+	var animated_m2_prototype := Node3D.new()
+	var wmo_prototype := Node3D.new()
+
+	loader.set("_m2_scene_cache", {"static": static_m2_prototype})
+	loader.set("_m2_animated_scene_cache", {"animated": animated_m2_prototype})
+	loader.set("_wmo_prototype_cache", {"wmo": wmo_prototype})
+	loader.set("_m2_mesh_cache", {"mesh": ArrayMesh.new()})
+	loader.set("_m2_static_animation_cache", {"static": true})
+	loader.set("_m2_missing_cache", {"missing": true})
+	loader.set("_wmo_render_cache", {"render": Resource.new()})
+	loader.set("_wmo_scene_resource_cache", {"scene": PackedScene.new()})
+	loader.set("_wmo_render_missing_cache", {"missing": true})
+	loader.set("_wmo_scene_cache_missing", {"missing": true})
+	loader.set("_wmo_missing_cache", {"missing": true})
+	loader.set("_shared_tex_cache", {"texture": ImageTexture.new()})
+
+	loader.call("_release_runtime_caches_for_shutdown")
+
+	_expect(not is_instance_valid(static_m2_prototype), "static M2 prototype should be freed")
+	_expect(not is_instance_valid(animated_m2_prototype), "animated M2 prototype should be freed")
+	_expect(not is_instance_valid(wmo_prototype), "WMO prototype should be freed")
+	for cache_name in [
+		"_m2_scene_cache",
+		"_m2_animated_scene_cache",
+		"_wmo_prototype_cache",
+		"_m2_mesh_cache",
+		"_m2_static_animation_cache",
+		"_m2_missing_cache",
+		"_wmo_render_cache",
+		"_wmo_scene_resource_cache",
+		"_wmo_render_missing_cache",
+		"_wmo_scene_cache_missing",
+		"_wmo_missing_cache",
+		"_shared_tex_cache",
+	]:
+		var cache: Dictionary = loader.get(cache_name)
+		_expect(cache.is_empty(), "%s should be empty after shutdown" % cache_name)
+
+	loader.free()
+
+
+func _expect(condition: bool, message: String) -> void:
+	if condition:
+		return
+	_failures += 1
+	push_error(message)

src/tools/verify_server_spawn_renderer.gd

@@ -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)

src/tools/verify_server_spawn_renderer.gd.uid

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

src/tools/verify_streaming_focus.gd

@@ -0,0 +1,101 @@
+extends SceneTree
+
+## Headless M01 contract and wiring regression for camera-independent streaming.
+
+const StreamingFocusScript = preload("res://src/domain/streaming/streaming_focus.gd")
+const GodotWorldPositionScript = preload("res://src/domain/coordinates/godot_world_position.gd")
+
+const LOADER_PATH := "res://src/scenes/streaming/streaming_world_loader.gd"
+const RUNTIME_SCENE_PATHS: Array[String] = [
+	"res://src/scenes/streaming/eastern_kingdoms_streaming.tscn",
+	"res://src/scenes/streaming/kalimdor_streaming.tscn",
+]
+const CAPTURE_TOOL_PATHS: Array[String] = [
+	"res://src/tools/capture_render_checkpoints.gd",
+	"res://src/tools/probe_render_camera_occluders.gd",
+	"res://src/tools/probe_render_terrain_height.gd",
+]
+
+
+func _initialize() -> void:
+	var failures: Array[String] = []
+	_verify_scene_free_focus_value(failures)
+	_verify_loader_boundary(failures)
+	_verify_runtime_scene_wiring(failures)
+	_verify_capture_tool_wiring(failures)
+
+	if not failures.is_empty():
+		for failure in failures:
+			push_error("STREAMING_FOCUS: %s" % failure)
+		quit(1)
+		return
+
+	print("STREAMING_FOCUS PASS contract=1 runtime_scenes=2 capture_tools=3")
+	quit(0)
+
+
+func _verify_scene_free_focus_value(failures: Array[String]) -> void:
+	var position = GodotWorldPositionScript.new(17199.159666667, 83.5312, 26016.616666667)
+	var focus = StreamingFocusScript.new(position)
+	_expect_true(focus.world_position == position, "focus retains typed position", failures)
+	_expect_near(focus.world_position.x_units, 17199.159666667, "focus X", failures)
+	_expect_near(focus.world_position.y_units, 83.5312, "focus Y", failures)
+	_expect_near(focus.world_position.z_units, 26016.616666667, "focus Z", failures)
+
+	var focus_source := _read_text("res://src/domain/streaming/streaming_focus.gd", failures)
+	_expect_true(not focus_source.contains("extends Node"), "focus does not inherit Node", failures)
+	_expect_true(not focus_source.contains("extends Resource"), "focus does not inherit Resource", failures)
+	_expect_true(not focus_source.contains("Vector3"), "focus does not expose Vector3", failures)
+
+
+func _verify_loader_boundary(failures: Array[String]) -> void:
+	var loader_source := _read_text(LOADER_PATH, failures)
+	for required_text in [
+		"@export var streaming_focus_source_path: NodePath",
+		"func set_streaming_focus(streaming_focus: StreamingFocus) -> void:",
+		"func refresh_streaming_focus(force: bool = false) -> bool:",
+	]:
+		_expect_true(loader_source.contains(required_text), "loader contains %s" % required_text, failures)
+
+	for forbidden_text in [
+		"get_viewport().get_camera_3d()",
+		"child is Camera3D and child.current",
+		"func _get_stream_camera()",
+	]:
+		_expect_true(not loader_source.contains(forbidden_text), "loader omits %s" % forbidden_text, failures)
+
+
+func _verify_runtime_scene_wiring(failures: Array[String]) -> void:
+	for scene_path in RUNTIME_SCENE_PATHS:
+		var scene_source := _read_text(scene_path, failures)
+		_expect_true(
+			scene_source.contains('streaming_focus_source_path = NodePath("ThirdPersonPlayer")'),
+			"%s uses player focus" % scene_path,
+			failures
+		)
+
+
+func _verify_capture_tool_wiring(failures: Array[String]) -> void:
+	for tool_path in CAPTURE_TOOL_PATHS:
+		var tool_source := _read_text(tool_path, failures)
+		_expect_true(tool_source.contains('world.set("streaming_focus_source_path"'), "%s sets explicit focus source" % tool_path, failures)
+		_expect_true(tool_source.contains('world.call("refresh_streaming_focus", true)'), "%s uses public refresh" % tool_path, failures)
+		_expect_true(not tool_source.contains('world.call("_refresh_streaming_targets_at"'), "%s avoids private refresh" % tool_path, failures)
+
+
+func _read_text(path: String, failures: Array[String]) -> String:
+	var file := FileAccess.open(path, FileAccess.READ)
+	if file == null:
+		failures.append("cannot open %s" % path)
+		return ""
+	return file.get_as_text()
+
+
+func _expect_near(actual_value: float, expected_value: float, label: String, failures: Array[String]) -> void:
+	if absf(actual_value - expected_value) > 0.000001:
+		failures.append("%s expected %.9f, got %.9f" % [label, expected_value, actual_value])
+
+
+func _expect_true(actual_value: bool, label: String, failures: Array[String]) -> void:
+	if not actual_value:
+		failures.append("%s expected true" % label)

src/tools/verify_streaming_focus.gd.uid

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

targets/00-render-baseline.md

@@ -1,6 +1,7 @@
 # M00 — Renderer Baseline
 
-<!-- OPENWC_TARGET:ACTIVE -->
+<!-- OPENWC_TARGET:DONE -->
+<!-- OPENWC_TARGET_DONE:M00:work/sindo-main-codex/m00-integrator-closeout:2026-07-13 -->
 
 ## Outcome
 
@@ -38,10 +39,10 @@ godot --headless --path . --script res://src/tools/capture_render_checkpoints.gd
 
 ## Evidence
 
-- Date: 2026-07-10
-- Revision/worktree: `93bfe11` + worktree baseline changes.
-- Commands: `.\tools\run_render_baseline.ps1 -DryRun -WaitSeconds 0.1 -MeasureSeconds 0.1 -Output user://render_baseline_runner_test`; `.\tools\run_render_baseline.ps1 -Output user://render_baseline_m00_2026-07-10 -CacheState existing`.
-- Results: headless load, renderer material smoke, M2 unique-id dedupe and manifest contract passed. Full run produced 14 PNGs and 14 result records for 7 cold/warm checkpoints. Actual renderer was Godot 4.6.1, Vulkan Forward+, NVIDIA RTX 5070, 1280x900, High profile, with all seven cache families present. Cold p95 range was 31.585..86.537 ms with max hitch 258.456 ms; warm p95 range was 18.824..38.085 ms with max hitch 163.363 ms. The final streaming snapshots had an empty tile queue. Report: `user://render_baseline_m00_2026-07-10/report.json`.
-- Fidelity comparison: fixed positions/time/profile and current visual gaps are recorded, but no approved paired screenshots from the original WoW 3.3.5a build 12340 were available. This baseline does not claim parity.
-- Changed files: `RENDER.md`, `docs/RENDER_BASELINE.md`, `src/scenes/streaming/streaming_world_loader.gd`, `src/tools/capture_render_checkpoints.gd`, `src/tools/render_baseline_manifest.json`, `src/tools/verify_render_baseline_manifest.gd`, `tools/run_render_baseline.ps1`, `targets/00-render-baseline.md`.
-- Remaining risks: original-client paired comparison is still required before DONE; D3D12 descriptor heap creation failed and the measured run fell back to Vulkan; shutdown reported leaked renderer RIDs/resources; current captures intentionally preserve visible terrain/placement/material/animation gaps, including the synthetic native animated M2 probe; perceptual image diff/tolerance is documented but not automated yet.
+- Date: 2026-07-13
+- Revision/worktree: merged M00 implementation through `f19c0c4`; closeout worktree `work/sindo-main-codex/m00-integrator-closeout`.
+- Commands: `.\tools\run_render_baseline.ps1 -Output user://render_baseline_m00_complete_2026-07-13 -CacheState existing -WaitSeconds 8 -MeasureSeconds 0.5 -ReferenceCheckpointDirectory .\sources\OpenWCReferenceCheckpoints -VisualComparisonReport user://render_baseline_m00_complete_2026-07-13/visual_comparison.json -VisualComparisonWidth 2560 -VisualComparisonHeight 1440`; `.\tools\run_render_baseline.ps1 -DryRun -WaitSeconds 0.1 -MeasureSeconds 0.1 -Output user://render_baseline_m00_post_merge`; `.\tools\verify_coordination.ps1`; `.\tools\verify_documentation.ps1`.
+- Results: the final GUI run produced fourteen cold/warm captures for seven checkpoints and all seven required coverage categories, with `compared=14` and `missing=0`. The post-merge dry-run passed project load, material, M2 unique-id dedupe, runtime-cache shutdown, manifest and five-point coordinate calibration checks. Coordination and documentation gates passed. Renderer shutdown follow-up removed retained Node/resource/RID diagnostics in focused and seven-checkpoint GUI runs.
+- Fidelity comparison: private original-client WoW 3.3.5a build 12340 references cover terrain, ADT boundary, dense M2, large WMO, liquid, animated M2 and sky transition. Every measured pair exceeds the strict visual tolerance and is recorded as a current gap rather than parity. Sky framing is approximately paired; animated M2 is asset-paired but placement-unpaired because the OpenWC Goldshire probe is synthetic. Full metrics and provenance are recorded in `docs/M00_FINAL_PAIRED_EVIDENCE.md`.
+- Changed files: `RENDER.md`, `docs/RENDER_BASELINE.md`, `docs/M00_FINAL_PAIRED_EVIDENCE.md`, `docs/modules/world-renderer.md`, renderer baseline scripts/verifiers, manifest/capture tooling, streaming shutdown ownership and M00 coordination claims.
+- Remaining risks: renderer parity is not claimed; documented terrain/material/placement/animation/lighting/liquid/culling gaps remain future renderer work. D3D12 descriptor heap creation can fall back to Vulkan. Godot can emit a timing-dependent anonymous zero-reference `RefCounted` teardown warning without retained Node/resource/RID ownership.

targets/01-coordinates-and-seams.md

@@ -1,6 +1,7 @@
 # M01 — Coordinates and Architecture Seams
 
-<!-- OPENWC_TARGET:OPEN -->
+<!-- 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.
-- [ ] Определить canonical WoW, Godot, ADT tile/chunk и local coordinate types.
-- [ ] Реализовать единственный `CoordinateMapper` для position и orientation.
-- [ ] Собрать golden points из ADT, server spawn и оригинального клиента.
-- [ ] Ввести `StreamingFocus` вместо неявной зависимости от active Camera3D.
-- [ ] Ввести stable `ContentId`, `EntityId` и отличить их от WoW GUID/server entry.
-- [ ] Запретить ручные axis conversion через code review rule/test search.
+- [x] Создать domain/value-object слой без `Node`/`Resource` dependencies.
+- [x] Определить canonical WoW, Godot, ADT tile/chunk и local coordinate types.
+- [x] Реализовать единственный `CoordinateMapper` для position и orientation.
+- [x] Собрать golden points из ADT, server spawn и оригинального клиента.
+- [x] Ввести `StreamingFocus` вместо неявной зависимости от active Camera3D.
+- [x] Ввести stable `ContentId`, `EntityId` и отличить их от WoW GUID/server entry.
+- [x] Запретить ручные axis conversion через code review rule/test search.
 
 ## Verification
 
@@ -28,10 +29,35 @@ Renderer/test scene получают focus через контракт; коор
 
 ## Evidence
 
-- Date:
-- Revision/worktree:
-- Commands:
-- Results:
-- Fidelity comparison:
-- Changed files:
-- Remaining risks:
+- Date: 2026-07-14
+- Revision/worktree: merged master `c8e99f2`; closeout
+  `work/sindo-main-codex/m01-integrator-closeout`
+- Commands: `tools/run_render_baseline.ps1 -DryRun -WaitSeconds 0.1
+  -MeasureSeconds 0.1`; `verify_coordinate_mapper.gd`;
+  `verify_coordinate_golden_fixtures.gd`; `verify_streaming_focus.gd`;
+  `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.

targets/02-player-decomposition.md

@@ -1,6 +1,6 @@
 # M02 — Player Decomposition
 
-<!-- OPENWC_TARGET:OPEN -->
+<!-- OPENWC_TARGET:ACTIVE -->
 
 ## Outcome
 

targets/DEVELOPMENT_ROADMAP.md

@@ -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 создан; до `DONE` не хватает paired comparison с оригинальным клиентом и закрытия известных diagnostic gaps.
+- 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.
 

targets/README.md

@@ -10,7 +10,7 @@
 
 ## Current target
 
-`M00` — [00-render-baseline.md](00-render-baseline.md)
+`M02` — [02-player-decomposition.md](02-player-decomposition.md)
 
 Одновременно `ACTIVE` может быть только одна цель. Следующая цель становится `ACTIVE` после появления валидной `OPENWC_TARGET_DONE` метки у предыдущей.
 
@@ -33,9 +33,9 @@
 
 | ID | Цель | Зависит от | Статус |
 |---|---|---|---|
-| M00 | [Renderer baseline](00-render-baseline.md) | — | ACTIVE |
-| M01 | [Coordinates and architecture seams](01-coordinates-and-seams.md) | M00 | OPEN |
-| M02 | [Player decomposition](02-player-decomposition.md) | M01 | OPEN |
+| M00 | [Renderer baseline](00-render-baseline.md) | — | DONE |
+| M01 | [Coordinates and architecture seams](01-coordinates-and-seams.md) | M00 | DONE |
+| 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 |

tools/run_render_baseline.ps1

@@ -40,13 +40,25 @@ function Invoke-GodotStep {
     }
 }
 
+function Invoke-GodotComparisonStep {
+    param([string]$Name, [string[]]$Arguments)
+    Write-Host "[$Name] $GodotPath $($Arguments -join ' ')"
+    $process = Start-Process -FilePath $GodotPath -ArgumentList $Arguments -NoNewWindow -Wait -PassThru
+    if ($process.ExitCode -notin @(0, 1)) {
+        throw "$Name failed with exit code $($process.ExitCode)"
+    }
+}
+
 Push-Location $repoRoot
 try {
     Invoke-GodotStep "project-load" @("--headless", "--path", ".", "--quit")
     Invoke-GodotStep "render-materials" @("--headless", "--path", ".", "--script", "res://src/tools/verify_render_materials.gd")
     Invoke-GodotStep "m2-unique-dedupe" @("--headless", "--path", ".", "--script", "res://src/tools/verify_m2_unique_dedupe.gd")
+    Invoke-GodotStep "runtime-cache-shutdown" @("--headless", "--path", ".", "--script", "res://src/tools/verify_render_runtime_cache_shutdown.gd")
     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", ".",
@@ -80,7 +92,7 @@ try {
 			"--viewport-height", $VisualComparisonHeight.ToString()
 		)
 		Invoke-GodotStep "visual-capture" $visualCaptureArgs
-        Invoke-GodotStep "visual-comparison" @(
+        Invoke-GodotComparisonStep "visual-comparison" @(
             "--headless", "--path", ".",
             "--script", "res://src/tools/compare_render_checkpoints.gd",
             "--",