Merge pull request 'task/0023-0028-navmesh' (#7) from task/0023-0026-navmesh into master

Reviewed-on: #7
Reviewed-by: horooko <freeman.maybe@gmail.com>

Assets/Features/VoxelWorld/Contracts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9b8ddf3935be4c6da0df53dfe0792909
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Features/VoxelWorld/Contracts/NavMeshWorldContracts.cs

@@ -0,0 +1,90 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace InfiniteWorld.VoxelWorld.Contracts
+{
+    /// <summary>
+    /// Provides chunk-level nav build inputs without exposing the internal runtime representation of the voxel world.
+    /// </summary>
+    public interface IChunkNavSourceReader
+    {
+        /// <summary>
+        /// Returns the world-space edge length of one chunk so nav coverage and source collection can reason in chunk units.
+        /// </summary>
+        float ChunkWorldSize { get; }
+
+        /// <summary>
+        /// Copies the coordinates of chunks that currently have usable nav geometry into the provided list.
+        /// </summary>
+        void GetLoadedChunkCoords(List<Vector2Int> results);
+
+        /// <summary>
+        /// Retrieves the current nav source snapshot for a loaded chunk so sidecar systems can rebuild coverage from stable descriptors.
+        /// </summary>
+        bool TryGetChunkNavSourceSnapshot(Vector2Int coord, out ChunkNavSourceSnapshot snapshot);
+    }
+
+    /// <summary>
+    /// Exposes the current gameplay-relevant interest points that should influence world streaming or nav coverage planning.
+    /// </summary>
+    public interface IWorldInterestReader
+    {
+        /// <summary>
+        /// Increments when the logical set of interest points changes and downstream systems should invalidate cached plans.
+        /// </summary>
+        int InterestVersion { get; }
+
+        /// <summary>
+        /// Appends the currently active interest points into the provided list.
+        /// </summary>
+        void GetInterestPoints(List<WorldInterestPoint> results);
+    }
+
+    /// <summary>
+    /// Exposes the currently built nav coverage so gameplay systems can query whether a world-space area is ready for pathing.
+    /// </summary>
+    public interface INavCoverageReader
+    {
+        /// <summary>
+        /// Returns whether the supplied world position lies inside ready nav coverage, not merely inside generated terrain.
+        /// </summary>
+        bool IsPositionCovered(Vector3 worldPosition);
+
+        /// <summary>
+        /// Copies the currently active coverage windows so diagnostics and higher-level systems can inspect the coverage topology.
+        /// </summary>
+        void GetCoverageWindows(List<NavCoverageWindowSnapshot> results);
+    }
+
+    /// <summary>
+    /// Lets callers inject short-lived route hints that bias nav coverage planning toward an upcoming movement corridor.
+    /// </summary>
+    public interface INavCoverageHintRegistry
+    {
+        /// <summary>
+        /// Registers or refreshes a temporary linear hint for the given owner so coverage can prewarm along a route before pathing starts.
+        /// </summary>
+        void SetLinearHint(int ownerId, Vector3 from, Vector3 to, float priority, float ttlSeconds);
+
+        /// <summary>
+        /// Removes the temporary hint owned by the caller when the route is no longer relevant.
+        /// </summary>
+        void ClearHint(int ownerId);
+    }
+
+    /// <summary>
+    /// Exposes the current set of transient nav coverage hints as read-only interest points for the nav coverage scheduler.
+    /// </summary>
+    public interface INavCoverageHintReader
+    {
+        /// <summary>
+        /// Increments whenever the effective hint set changes so dependent planners can invalidate cached coverage windows.
+        /// </summary>
+        int HintVersion { get; }
+
+        /// <summary>
+        /// Appends the currently active transient hint points into the provided list.
+        /// </summary>
+        void GetHintPoints(List<WorldInterestPoint> results);
+    }
+}

Assets/Features/VoxelWorld/Contracts/NavMeshWorldContracts.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 55dd8e2a1b2d458aa96895a54d53e6ca
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Features/VoxelWorld/Contracts/NavMeshWorldEnums.cs

@@ -0,0 +1,38 @@
+namespace InfiniteWorld.VoxelWorld.Contracts
+{
+    /// <summary>
+    /// Identifies why a point contributes to nav coverage so planners and diagnostics can treat different sources appropriately.
+    /// </summary>
+    public enum WorldInterestKind
+    {
+        /// <summary>Coverage seeded by the current player-controlled actor.</summary>
+        PlayerActor = 0,
+
+        /// <summary>Coverage seeded by an active NPC that still requires authoritative pathing.</summary>
+        ActiveNpc = 1,
+
+        /// <summary>Coverage seeded by a spawn location that should be warm before actors start moving.</summary>
+        SpawnAnchor = 2,
+
+        /// <summary>Coverage seeded by a short-lived route hint that biases planning ahead of movement.</summary>
+        TransientNavHint = 3,
+
+        /// <summary>Fallback category for future interest sources that do not fit a more specific kind.</summary>
+        Other = 4
+    }
+
+    /// <summary>
+    /// Describes where a coverage window currently sits in the nav build lifecycle.
+    /// </summary>
+    public enum NavCoverageState
+    {
+        /// <summary>The window exists conceptually but still needs a fresh build.</summary>
+        Pending = 0,
+
+        /// <summary>The window is currently rebuilding its runtime NavMesh data.</summary>
+        Building = 1,
+
+        /// <summary>The window has ready NavMesh data that can answer pathing queries.</summary>
+        Ready = 2
+    }
+}

Assets/Features/VoxelWorld/Contracts/NavMeshWorldEnums.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4112a97dd67e45aca6f2c0928de438bd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Features/VoxelWorld/Contracts/NavMeshWorldMessages.cs

@@ -0,0 +1,80 @@
+using UnityEngine;
+
+namespace InfiniteWorld.VoxelWorld.Contracts
+{
+    /// <summary>
+    /// Signals that a chunk now has valid nav geometry and dependent coverage windows should invalidate cached builds.
+    /// </summary>
+    public readonly struct ChunkNavGeometryReadyMessage
+    {
+        public ChunkNavGeometryReadyMessage(Vector2Int coord, int version)
+        {
+            Coord = coord;
+            Version = version;
+        }
+
+        /// <summary>
+        /// Chunk coordinate whose nav geometry became available.
+        /// </summary>
+        public Vector2Int Coord { get; }
+
+        /// <summary>
+        /// Version of the chunk runtime state associated with this notification.
+        /// </summary>
+        public int Version { get; }
+    }
+
+    /// <summary>
+    /// Signals that a chunk's nav geometry is being removed so dependent coverage windows can drop stale build data.
+    /// </summary>
+    public readonly struct ChunkNavGeometryRemovedMessage
+    {
+        public ChunkNavGeometryRemovedMessage(Vector2Int coord, int version)
+        {
+            Coord = coord;
+            Version = version;
+        }
+
+        /// <summary>
+        /// Chunk coordinate whose nav geometry is no longer available.
+        /// </summary>
+        public Vector2Int Coord { get; }
+
+        /// <summary>
+        /// Last known version of the chunk state before removal.
+        /// </summary>
+        public int Version { get; }
+    }
+
+    /// <summary>
+    /// Invalidates consumers that cache the current world interest set.
+    /// </summary>
+    public readonly struct WorldInterestChangedMessage
+    {
+        public WorldInterestChangedMessage(int version)
+        {
+            Version = version;
+        }
+
+        /// <summary>
+        /// Monotonic version of the world interest state after the change.
+        /// </summary>
+        public int Version { get; }
+    }
+
+    /// <summary>
+    /// Invalidates consumers that cache transient nav coverage hints.
+    /// </summary>
+    public readonly struct NavCoverageHintChangedMessage
+    {
+        public NavCoverageHintChangedMessage(int version)
+        {
+            Version = version;
+        }
+
+        /// <summary>
+        /// Monotonic version of the active nav hint state after the change.
+        /// </summary>
+        public int Version { get; }
+    }
+}

Assets/Features/VoxelWorld/Contracts/NavMeshWorldMessages.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e2ea3cb8fdd545019f666d378bc8eaaa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Features/VoxelWorld/Contracts/NavMeshWorldSnapshots.cs

@@ -0,0 +1,151 @@
+using UnityEngine;
+using UnityEngine.AI;
+
+namespace InfiniteWorld.VoxelWorld.Contracts
+{
+    /// <summary>
+    /// Captures the nav-relevant state of one chunk at a specific version so sidecar systems can rebuild from immutable inputs.
+    /// </summary>
+    public readonly struct ChunkNavSourceSnapshot
+    {
+        public ChunkNavSourceSnapshot(Vector2Int coord, int version, ChunkNavBuildSourceDescriptor[] sources)
+        {
+            Coord = coord;
+            Version = version;
+            Sources = sources;
+        }
+
+        /// <summary>
+        /// Chunk coordinate this snapshot was produced for.
+        /// </summary>
+        public Vector2Int Coord { get; }
+
+        /// <summary>
+        /// Version of the chunk runtime state used to generate this snapshot.
+        /// </summary>
+        public int Version { get; }
+
+        /// <summary>
+        /// Stable nav build descriptors derived from the chunk's current geometry.
+        /// </summary>
+        public ChunkNavBuildSourceDescriptor[] Sources { get; }
+    }
+
+    /// <summary>
+    /// Describes one build source in a format that can be consumed without direct references to world internals or scene scans.
+    /// </summary>
+    public readonly struct ChunkNavBuildSourceDescriptor
+    {
+        public ChunkNavBuildSourceDescriptor(NavMeshBuildSourceShape shape, Matrix4x4 transform, Vector3 size, Mesh mesh, int area)
+        {
+            Shape = shape;
+            Transform = transform;
+            Size = size;
+            Mesh = mesh;
+            Area = area;
+        }
+
+        /// <summary>
+        /// Unity NavMesh source shape represented by this descriptor.
+        /// </summary>
+        public NavMeshBuildSourceShape Shape { get; }
+
+        /// <summary>
+        /// World transform used when the descriptor is converted into a runtime build source.
+        /// </summary>
+        public Matrix4x4 Transform { get; }
+
+        /// <summary>
+        /// Source size for primitive shapes such as box-based ground coverage.
+        /// </summary>
+        public Vector3 Size { get; }
+
+        /// <summary>
+        /// Source mesh for mesh-based obstacles or walkable surfaces when applicable.
+        /// </summary>
+        public Mesh Mesh { get; }
+
+        /// <summary>
+        /// Nav area assigned to the resulting build source.
+        /// </summary>
+        public int Area { get; }
+
+        /// <summary>
+        /// Creates a compact descriptor for box-based chunk geometry such as ground slabs.
+        /// </summary>
+        public static ChunkNavBuildSourceDescriptor CreateBox(Matrix4x4 transform, Vector3 size, int area = 0)
+        {
+            return new ChunkNavBuildSourceDescriptor(NavMeshBuildSourceShape.Box, transform, size, null, area);
+        }
+
+        /// <summary>
+        /// Creates a compact descriptor for mesh-based chunk geometry such as carved terrain or obstacles.
+        /// </summary>
+        public static ChunkNavBuildSourceDescriptor CreateMesh(Matrix4x4 transform, Mesh mesh, int area = 0)
+        {
+            return new ChunkNavBuildSourceDescriptor(NavMeshBuildSourceShape.Mesh, transform, Vector3.zero, mesh, area);
+        }
+    }
+
+    /// <summary>
+    /// Represents one gameplay-driven point that should influence nav coverage planning and clustering.
+    /// </summary>
+    public readonly struct WorldInterestPoint
+    {
+        public WorldInterestPoint(Vector3 position, float priority, WorldInterestKind kind)
+        {
+            Position = position;
+            Priority = priority;
+            Kind = kind;
+        }
+
+        /// <summary>
+        /// World position the planner should consider when shaping coverage.
+        /// </summary>
+        public Vector3 Position { get; }
+
+        /// <summary>
+        /// Relative weight used to prioritize coverage near more important interest points.
+        /// </summary>
+        public float Priority { get; }
+
+        /// <summary>
+        /// Category of interest so diagnostics can distinguish players, spawn anchors, hints and future AI sources.
+        /// </summary>
+        public WorldInterestKind Kind { get; }
+    }
+
+    /// <summary>
+    /// Lightweight read-model snapshot describing one currently managed nav coverage window.
+    /// </summary>
+    public readonly struct NavCoverageWindowSnapshot
+    {
+        public NavCoverageWindowSnapshot(int id, Bounds bounds, NavCoverageState state, int interestCount)
+        {
+            Id = id;
+            Bounds = bounds;
+            State = state;
+            InterestCount = interestCount;
+        }
+
+        /// <summary>
+        /// Stable runtime identifier of the coverage window.
+        /// </summary>
+        public int Id { get; }
+
+        /// <summary>
+        /// World-space bounds the window currently covers for pathing readiness.
+        /// </summary>
+        public Bounds Bounds { get; }
+
+        /// <summary>
+        /// Current lifecycle state of the window in the build scheduler.
+        /// </summary>
+        public NavCoverageState State { get; }
+
+        /// <summary>
+        /// Number of interest points currently collapsed into this window.
+        /// </summary>
+        public int InterestCount { get; }
+    }
+}

Assets/Features/VoxelWorld/Contracts/NavMeshWorldSnapshots.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 91e1b6896fdd4f7a9968cc4af4bf7550
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Features/VoxelWorld/Contracts/VoxelWorld.Contracts.asmdef

@@ -0,0 +1,14 @@
+{
+  "name": "VoxelWorld.Contracts",
+  "rootNamespace": "InfiniteWorld.VoxelWorld.Contracts",
+  "references": [],
+  "includePlatforms": [],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": false,
+  "precompiledReferences": [],
+  "autoReferenced": true,
+  "defineConstraints": [],
+  "versionDefines": [],
+  "noEngineReferences": false
+}

Assets/Features/VoxelWorld/Contracts/VoxelWorld.Contracts.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 96b902ea5b554a1b8a9e0c29e03118f2
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Features/VoxelWorld/Prefabs/VoxelWorld.prefab

@@ -10,6 +10,8 @@ GameObject:
   m_Component:
   - component: {fileID: 74135865886311664}
   - component: {fileID: 2927522923773808063}
+  - component: {fileID: 6182401849027620011}
+  - component: {fileID: 6182401849027620012}
   m_Layer: 0
   m_Name: VoxelWorld
   m_TagString: Untagged
@@ -47,3 +49,46 @@ MonoBehaviour:
   streamTarget: {fileID: 0}
   config: {fileID: 11400000, guid: b8cf28a5522134b479c23f017234070c, type: 2}
   _terrainShader: {fileID: 4800000, guid: ec80aebd8cb61f44cbfa6b7d5f087211, type: 3}
+--- !u!114 &6182401849027620011
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 797018065588400165}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0c52a16bd6e44739b6bb1b4471a7a5a9, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: Assembly-CSharp::VoxelWorldScene.VoxelWorldPlayerStreamTargetBinding
+  worldGenerator: {fileID: 2927522923773808063}
+  explicitStreamTarget: {fileID: 0}
+--- !u!114 &6182401849027620012
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 797018065588400165}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 2dfd0b7ddf3a419f91ce891210f85d4b, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: Assembly-CSharp::VoxelWorldScene.VoxelWorldNavMeshLifetimeScope
+  parentReference:
+    TypeName: 
+  autoRun: 1
+  autoInjectGameObjects: []
+  enableRuntimeNavMesh: 1
+  worldGenerator: {fileID: 2927522923773808063}
+  config:
+    agentTypeId: 0
+    maxNavMeshBuildsPerFrame: 1
+    navBoundsHorizontalPadding: 1
+    navBoundsVerticalPadding: 2
+    maxActiveCoverageWindows: 3
+    clusterMergeDistanceInChunks: 4
+    coveragePaddingInChunks: 2
+    coverageQuantizationInChunks: 1
+    minCoverageWindowSizeInChunks: 4
+    chunkCollectionMarginInChunks: 1

Assets/Features/VoxelWorld/Runtime/VoxelWorld.Runtime.asmdef

@@ -2,7 +2,9 @@
   "name": "VoxelWorld.Runtime",
   "rootNamespace": "InfiniteWorld.VoxelWorld",
   "references": [
-    "UniTask"
+    "UniTask",
+    "VoxelWorld.Contracts",
+    "MessagePipe"
   ],
   "includePlatforms": [],
   "excludePlatforms": [],

Assets/Features/VoxelWorld/Runtime/VoxelWorldGenerator.cs

@@ -1,11 +1,14 @@
 using System;
 using System.Collections.Generic;
 using Cysharp.Threading.Tasks;
+using InfiniteWorld.VoxelWorld.Contracts;
+using MessagePipe;
 using UnityEngine;
+using UnityEngine.AI;
 
 namespace InfiniteWorld.VoxelWorld
 {
-    public sealed partial class VoxelWorldGenerator : MonoBehaviour
+    public sealed partial class VoxelWorldGenerator : MonoBehaviour, IChunkNavSourceReader, IWorldInterestReader
     {
         [Header("References")]
         [SerializeField] private Transform streamTarget;
@@ -36,8 +39,12 @@ namespace InfiniteWorld.VoxelWorld
         private int regionRebuildSession;
         private VoxelWorldAtlas atlas;
         private int atlasBiomeCount;
+        private int interestVersion;
         private bool regionRebuildLoopRunning;
         private VoxelWorldResolvedSettings settings = VoxelWorldResolvedSettings.Default;
+        private IPublisher<ChunkNavGeometryReadyMessage> chunkNavGeometryReadyPublisher;
+        private IPublisher<ChunkNavGeometryRemovedMessage> chunkNavGeometryRemovedPublisher;
+        private IPublisher<WorldInterestChangedMessage> worldInterestChangedPublisher;
 
         private int chunkSize => settings.ChunkSize;
         private int generationRadius => settings.GenerationRadius;
@@ -67,6 +74,8 @@ namespace InfiniteWorld.VoxelWorld
         private int maxNeighborRefreshesPerFrame => settings.MaxNeighborRefreshesPerFrame;
         private int renderRegionSizeInChunks => settings.RenderRegionSizeInChunks;
         private int maxRegionBuildsPerFrame => settings.MaxRegionBuildsPerFrame;
+        public float ChunkWorldSize => chunkSize;
+        public int InterestVersion => interestVersion;
 
         private void Awake()
         {
@@ -201,21 +210,100 @@ namespace InfiniteWorld.VoxelWorld
 
         private bool TryResolveStreamTarget()
         {
-            if (streamTarget != null)
+            return streamTarget != null;
+        }
+
+        public void BindWorldContracts(
+            IPublisher<ChunkNavGeometryReadyMessage> chunkNavGeometryReadyPublisher,
+            IPublisher<ChunkNavGeometryRemovedMessage> chunkNavGeometryRemovedPublisher,
+            IPublisher<WorldInterestChangedMessage> worldInterestChangedPublisher)
+        {
+            this.chunkNavGeometryReadyPublisher = chunkNavGeometryReadyPublisher;
+            this.chunkNavGeometryRemovedPublisher = chunkNavGeometryRemovedPublisher;
+            this.worldInterestChangedPublisher = worldInterestChangedPublisher;
+        }
+
+        public void SetStreamTarget(Transform target)
+        {
+            if (streamTarget == target)
             {
-                return true;
+                return;
             }
 
-            Camera mainCamera = Camera.main;
+            streamTarget = target;
-            if (mainCamera == null)
+            interestVersion++;
+            worldInterestChangedPublisher?.Publish(new WorldInterestChangedMessage(interestVersion));
+        }
+
+        public void GetInterestPoints(List<WorldInterestPoint> results)
+        {
+            if (results == null)
             {
+                throw new ArgumentNullException(nameof(results));
+            }
+
+            if (streamTarget == null)
+            {
+                return;
+            }
+
+            results.Add(new WorldInterestPoint(streamTarget.position, 1f, WorldInterestKind.PlayerActor));
+        }
+
+        public void GetLoadedChunkCoords(List<Vector2Int> results)
+        {
+            if (results == null)
+            {
+                throw new ArgumentNullException(nameof(results));
+            }
+
+            foreach (KeyValuePair<Vector2Int, ChunkRuntime> pair in chunks)
+            {
+                if (HasNavGeometry(pair.Value))
+                {
+                    results.Add(pair.Key);
+                }
+            }
+        }
+
+        public bool TryGetChunkNavSourceSnapshot(Vector2Int coord, out ChunkNavSourceSnapshot snapshot)
+        {
+            if (!chunks.TryGetValue(coord, out ChunkRuntime runtime) || !HasNavGeometry(runtime))
+            {
+                snapshot = default;
                 return false;
             }
 
-            streamTarget = mainCamera.transform;
+            ChunkNavBuildSourceDescriptor groundSource = ChunkNavBuildSourceDescriptor.CreateBox(
+                Matrix4x4.TRS(
+                    runtime.GroundCollider.transform.TransformPoint(runtime.GroundCollider.center),
+                    runtime.GroundCollider.transform.rotation,
+                    runtime.GroundCollider.transform.lossyScale),
+                runtime.GroundCollider.size);
+
+            if (runtime.ColliderMesh != null && runtime.ColliderMesh.vertexCount > 0)
+            {
+                snapshot = new ChunkNavSourceSnapshot(
+                    coord,
+                    runtime.Version,
+                    new[]
+                    {
+                        groundSource,
+                        ChunkNavBuildSourceDescriptor.CreateMesh(runtime.MountainCollider.transform.localToWorldMatrix, runtime.ColliderMesh)
+                    });
+
+                return true;
+            }
+
+            snapshot = new ChunkNavSourceSnapshot(coord, runtime.Version, new[] { groundSource });
             return true;
         }
 
+        private static bool HasNavGeometry(ChunkRuntime runtime)
+        {
+            return runtime != null && runtime.Root != null && runtime.GroundCollider != null && runtime.State == ChunkState.Rendered;
+        }
+
         private void ScheduleChunkGeneration(Vector2Int centerChunk)
         {
             List<Vector2Int> coords = GetCoordsByPriority(centerChunk, generationRadius);
@@ -289,6 +377,7 @@ namespace InfiniteWorld.VoxelWorld
 
                 Vector2Int regionCoord = ChunkToRegion(coord);
                 MarkRegionDirty(coord);
+                PublishChunkNavGeometryRemoved(coord, runtime.Version);
                 chunks.Remove(coord);
                 lock (placementPlanLock)
                 {
@@ -425,10 +514,21 @@ namespace InfiniteWorld.VoxelWorld
                 }
 
                 runtime.ApplyColliderMesh(pending.ColliderMesh);
+                PublishChunkNavGeometryReady(pending.Coord, runtime.Version);
                 applies++;
             }
         }
 
+        private void PublishChunkNavGeometryReady(Vector2Int coord, int version)
+        {
+            chunkNavGeometryReadyPublisher?.Publish(new ChunkNavGeometryReadyMessage(coord, version));
+        }
+
+        private void PublishChunkNavGeometryRemoved(Vector2Int coord, int version)
+        {
+            chunkNavGeometryRemovedPublisher?.Publish(new ChunkNavGeometryRemovedMessage(coord, version));
+        }
+
         private void QueueNeighborRefresh(Vector2Int coord)
         {
             if (!queuedNeighborRefreshes.Add(coord))

Assets/Features/VoxelWorld/Scenes/VoxelWorldTestScene.unity

@@ -255,6 +255,7 @@ GameObject:
   serializedVersion: 6
   m_Component:
   - component: {fileID: 171707223}
+  - component: {fileID: 171707224}
   m_Layer: 0
   m_Name: SpawnPoint
   m_TagString: Untagged
@@ -277,6 +278,19 @@ Transform:
   m_Children: []
   m_Father: {fileID: 0}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &171707224
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 171707222}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7a0a7758ae4541b39ed0b5d1fe912869, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: Assembly-CSharp::VoxelWorldScene.VoxelWorldSpawnAnchor
+  priority: 2
 --- !u!1001 &1165873058
 PrefabInstance:
   m_ObjectHideFlags: 0

Assets/Features/VoxelWorldNavMesh.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 814b46557fef4e36a0cba9242dd1feea
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Features/VoxelWorldNavMesh/Runtime.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ce0e93eaf54c45e8bff2ff3770aad24d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Features/VoxelWorldNavMesh/Runtime/NavBuildSourceCollector.cs

@@ -0,0 +1,84 @@
+using System.Collections.Generic;
+using InfiniteWorld.VoxelWorld.Contracts;
+using UnityEngine;
+using UnityEngine.AI;
+
+namespace InfiniteWorld.VoxelWorld.NavMesh
+{
+    internal static class NavBuildSourceCollector
+    {
+        public static bool CollectBuildSources(
+            IChunkNavSourceReader chunkNavSourceReader,
+            Bounds coverageBounds,
+            List<Vector2Int> loadedChunkCoords,
+            List<NavMeshBuildSource> results)
+        {
+            loadedChunkCoords.Clear();
+            chunkNavSourceReader.GetLoadedChunkCoords(loadedChunkCoords);
+
+            bool hasSources = false;
+            for (int i = 0; i < loadedChunkCoords.Count; i++)
+            {
+                Vector2Int chunkCoord = loadedChunkCoords[i];
+                if (!NavMeshBoundsUtility.IntersectsXZ(GetChunkWorldBounds(chunkNavSourceReader, chunkCoord), coverageBounds))
+                {
+                    continue;
+                }
+
+                if (!chunkNavSourceReader.TryGetChunkNavSourceSnapshot(chunkCoord, out ChunkNavSourceSnapshot snapshot) || snapshot.Sources == null || snapshot.Sources.Length == 0)
+                {
+                    continue;
+                }
+
+                hasSources = true;
+                AppendBuildSources(snapshot.Sources, results);
+            }
+
+            return hasSources;
+        }
+
+        public static Bounds GetChunkWorldBounds(IChunkNavSourceReader chunkNavSourceReader, Vector2Int chunkCoord)
+        {
+            float chunkSize = Mathf.Max(1f, chunkNavSourceReader.ChunkWorldSize);
+            Vector3 min = new Vector3(chunkCoord.x * chunkSize, -500f, chunkCoord.y * chunkSize);
+            Vector3 size = new Vector3(chunkSize, 1000f, chunkSize);
+            return new Bounds(min + new Vector3(chunkSize * 0.5f, 0f, chunkSize * 0.5f), size);
+        }
+
+        public static Bounds ExpandCoverageBounds(IChunkNavSourceReader chunkNavSourceReader, Bounds bounds, int chunkMargin)
+        {
+            return ExpandChunkBounds(chunkNavSourceReader, bounds, chunkMargin);
+        }
+
+        public static Bounds ExpandChunkBounds(IChunkNavSourceReader chunkNavSourceReader, Bounds bounds, int chunkMargin)
+        {
+            float chunkSize = Mathf.Max(1f, chunkNavSourceReader.ChunkWorldSize);
+            float horizontalPadding = chunkMargin * chunkSize;
+            bounds.Expand(new Vector3(horizontalPadding * 2f, 0f, horizontalPadding * 2f));
+            return bounds;
+        }
+
+        private static void AppendBuildSources(ChunkNavBuildSourceDescriptor[] descriptors, List<NavMeshBuildSource> results)
+        {
+            for (int i = 0; i < descriptors.Length; i++)
+            {
+                ChunkNavBuildSourceDescriptor descriptor = descriptors[i];
+                if (descriptor.Shape == NavMeshBuildSourceShape.Mesh && descriptor.Mesh == null)
+                {
+                    continue;
+                }
+
+                NavMeshBuildSource source = new NavMeshBuildSource
+                {
+                    area = descriptor.Area,
+                    shape = descriptor.Shape,
+                    transform = descriptor.Transform,
+                    size = descriptor.Size,
+                    sourceObject = descriptor.Shape == NavMeshBuildSourceShape.Mesh ? descriptor.Mesh : null
+                };
+
+                results.Add(source);
+            }
+        }
+    }
+}

Assets/Features/VoxelWorldNavMesh/Runtime/NavBuildSourceCollector.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9f2d97479ccb4401bc37fd6481d83304
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Features/VoxelWorldNavMesh/Runtime/NavCoverageHintService.cs

@@ -0,0 +1,159 @@
+using System;
+using System.Collections.Generic;
+using InfiniteWorld.VoxelWorld.Contracts;
+using MessagePipe;
+using UnityEngine;
+using VContainer.Unity;
+
+namespace InfiniteWorld.VoxelWorld.NavMesh
+{
+    /// <summary>
+    /// Stores short-lived route hints and expands them into interest points so nav coverage can prewarm ahead of movement.
+    /// </summary>
+    public sealed class NavCoverageHintService : ITickable, INavCoverageHintRegistry, INavCoverageHintReader
+    {
+        private readonly IChunkNavSourceReader chunkNavSourceReader;
+        private readonly VoxelWorldNavMeshConfig config;
+        private readonly IPublisher<NavCoverageHintChangedMessage> hintChangedPublisher;
+        private readonly Dictionary<int, HintEntry> hints = new Dictionary<int, HintEntry>();
+        private readonly List<int> expiredHintOwnerIds = new List<int>(8);
+
+        private int hintVersion;
+
+        public NavCoverageHintService(
+            IChunkNavSourceReader chunkNavSourceReader,
+            VoxelWorldNavMeshConfig config,
+            IPublisher<NavCoverageHintChangedMessage> hintChangedPublisher)
+        {
+            this.chunkNavSourceReader = chunkNavSourceReader;
+            this.config = config ?? new VoxelWorldNavMeshConfig();
+            this.hintChangedPublisher = hintChangedPublisher;
+        }
+
+        /// <summary>
+        /// Increments whenever the effective set of active hints changes and cached coverage planning should be invalidated.
+        /// </summary>
+        public int HintVersion => hintVersion;
+
+        /// <summary>
+        /// Expires hints whose time-to-live has elapsed so stale route bias does not keep shaping coverage forever.
+        /// </summary>
+        public void Tick()
+        {
+            if (hints.Count == 0)
+            {
+                return;
+            }
+
+            float now = Time.time;
+            expiredHintOwnerIds.Clear();
+            foreach (KeyValuePair<int, HintEntry> pair in hints)
+            {
+                if (pair.Value.ExpireAt > now)
+                {
+                    continue;
+                }
+
+                expiredHintOwnerIds.Add(pair.Key);
+            }
+
+            if (expiredHintOwnerIds.Count == 0)
+            {
+                return;
+            }
+
+            for (int i = 0; i < expiredHintOwnerIds.Count; i++)
+            {
+                hints.Remove(expiredHintOwnerIds[i]);
+            }
+
+            NotifyHintsChanged();
+        }
+
+        /// <summary>
+        /// Registers or refreshes a temporary linear corridor for one owner so coverage can be biased along an upcoming route.
+        /// </summary>
+        public void SetLinearHint(int ownerId, Vector3 from, Vector3 to, float priority, float ttlSeconds)
+        {
+            if (ownerId == 0)
+            {
+                ownerId = 1;
+            }
+
+            float expireAt = Time.time + Mathf.Max(0.1f, ttlSeconds);
+            WorldInterestPoint[] points = BuildLinearHintPoints(from, to, Mathf.Max(0.01f, priority));
+            hints[ownerId] = new HintEntry(points, expireAt);
+            NotifyHintsChanged();
+        }
+
+        /// <summary>
+        /// Removes a previously registered route hint once the owner no longer needs prewarmed coverage.
+        /// </summary>
+        public void ClearHint(int ownerId)
+        {
+            if (!hints.Remove(ownerId))
+            {
+                return;
+            }
+
+            NotifyHintsChanged();
+        }
+
+        /// <summary>
+        /// Appends the currently active hint points so the main coverage scheduler can treat them like supplemental interest.
+        /// </summary>
+        public void GetHintPoints(List<WorldInterestPoint> results)
+        {
+            if (results == null)
+            {
+                throw new ArgumentNullException(nameof(results));
+            }
+
+            foreach (KeyValuePair<int, HintEntry> pair in hints)
+            {
+                WorldInterestPoint[] points = pair.Value.Points;
+                for (int i = 0; i < points.Length; i++)
+                {
+                    results.Add(points[i]);
+                }
+            }
+        }
+
+        private WorldInterestPoint[] BuildLinearHintPoints(Vector3 from, Vector3 to, float priority)
+        {
+            float chunkWorldSize = Mathf.Max(1f, chunkNavSourceReader.ChunkWorldSize);
+            float spacing = Mathf.Max(chunkWorldSize, config.clusterMergeDistanceInChunks * chunkWorldSize * 0.75f);
+            float distance = Vector3.Distance(from, to);
+            int segmentCount = Mathf.Max(1, Mathf.CeilToInt(distance / Mathf.Max(0.01f, spacing)));
+            int pointCount = segmentCount + 1;
+            WorldInterestPoint[] points = new WorldInterestPoint[pointCount];
+
+            for (int i = 0; i < pointCount; i++)
+            {
+                float t = pointCount == 1 ? 1f : i / (float)(pointCount - 1);
+                Vector3 position = Vector3.Lerp(from, to, t);
+                points[i] = new WorldInterestPoint(position, priority, WorldInterestKind.TransientNavHint);
+            }
+
+            return points;
+        }
+
+        private void NotifyHintsChanged()
+        {
+            hintVersion++;
+            hintChangedPublisher?.Publish(new NavCoverageHintChangedMessage(hintVersion));
+        }
+
+        private readonly struct HintEntry
+        {
+            public HintEntry(WorldInterestPoint[] points, float expireAt)
+            {
+                Points = points;
+                ExpireAt = expireAt;
+            }
+
+            public WorldInterestPoint[] Points { get; }
+            public float ExpireAt { get; }
+        }
+    }
+}

Assets/Features/VoxelWorldNavMesh/Runtime/NavCoverageHintService.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4c6dcd38712d499fb48ec43c0ec77031
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Features/VoxelWorldNavMesh/Runtime/NavCoveragePlanning.cs

@@ -0,0 +1,227 @@
+using System.Collections.Generic;
+using InfiniteWorld.VoxelWorld.Contracts;
+using UnityEngine;
+
+namespace InfiniteWorld.VoxelWorld.NavMesh
+{
+    internal static class NavCoveragePlanning
+    {
+        public static void BuildDesiredCoverageWindows(
+            List<WorldInterestPoint> interestPoints,
+            VoxelWorldNavMeshConfig config,
+            float chunkWorldSize,
+            List<DesiredCoverageWindow> desiredCoverageWindows,
+            List<ClusterAccumulator> clusterAccumulators)
+        {
+            desiredCoverageWindows.Clear();
+            clusterAccumulators.Clear();
+
+            if (interestPoints.Count == 0)
+            {
+                return;
+            }
+
+            float mergeDistance = Mathf.Max(0f, config.clusterMergeDistanceInChunks) * chunkWorldSize;
+            float quantizationStep = Mathf.Max(0.25f, config.coverageQuantizationInChunks) * chunkWorldSize;
+            float padding = Mathf.Max(0f, config.coveragePaddingInChunks) * chunkWorldSize;
+            float minWindowSize = Mathf.Max(1f, config.minCoverageWindowSizeInChunks) * chunkWorldSize;
+
+            for (int i = 0; i < interestPoints.Count; i++)
+            {
+                WorldInterestPoint point = interestPoints[i];
+                int bestClusterIndex = -1;
+                float bestDistance = float.MaxValue;
+
+                for (int clusterIndex = 0; clusterIndex < clusterAccumulators.Count; clusterIndex++)
+                {
+                    float distance = NavMeshBoundsUtility.DistanceToBoundsXZ(clusterAccumulators[clusterIndex].RawBounds, point.Position);
+                    if (distance <= mergeDistance && distance < bestDistance)
+                    {
+                        bestDistance = distance;
+                        bestClusterIndex = clusterIndex;
+                    }
+                }
+
+                if (bestClusterIndex >= 0)
+                {
+                    ClusterAccumulator cluster = clusterAccumulators[bestClusterIndex];
+                    cluster.Add(point);
+                    clusterAccumulators[bestClusterIndex] = cluster;
+                }
+                else
+                {
+                    clusterAccumulators.Add(new ClusterAccumulator(point));
+                }
+            }
+
+            MergeNearbyClusters(clusterAccumulators, mergeDistance);
+
+            for (int i = 0; i < clusterAccumulators.Count; i++)
+            {
+                ClusterAccumulator cluster = clusterAccumulators[i];
+                Bounds coverageBounds = NavMeshBoundsUtility.CreateQuantizedCoverageBounds(cluster.RawBounds, padding, minWindowSize, quantizationStep);
+                desiredCoverageWindows.Add(new DesiredCoverageWindow(coverageBounds, cluster.Priority, cluster.InterestCount));
+            }
+
+            desiredCoverageWindows.Sort((left, right) =>
+            {
+                int priorityCompare = right.Priority.CompareTo(left.Priority);
+                if (priorityCompare != 0)
+                {
+                    return priorityCompare;
+                }
+
+                int interestCompare = right.InterestCount.CompareTo(left.InterestCount);
+                if (interestCompare != 0)
+                {
+                    return interestCompare;
+                }
+
+                return left.CoverageBounds.center.sqrMagnitude.CompareTo(right.CoverageBounds.center.sqrMagnitude);
+            });
+
+            int maxWindows = Mathf.Max(1, config.maxActiveCoverageWindows);
+            if (desiredCoverageWindows.Count > maxWindows)
+            {
+                desiredCoverageWindows.RemoveRange(maxWindows, desiredCoverageWindows.Count - maxWindows);
+            }
+        }
+
+        public static NavCoverageWindowRuntime FindBestMatchingCoverageWindow(
+            DesiredCoverageWindow desiredWindow,
+            Dictionary<int, NavCoverageWindowRuntime> coverageWindows,
+            float chunkWorldSize,
+            VoxelWorldNavMeshConfig config)
+        {
+            NavCoverageWindowRuntime bestMatch = null;
+            float bestDistance = float.MaxValue;
+            float matchThreshold = Mathf.Max(config.minCoverageWindowSizeInChunks, config.clusterMergeDistanceInChunks + config.coveragePaddingInChunks) * chunkWorldSize;
+
+            foreach (KeyValuePair<int, NavCoverageWindowRuntime> pair in coverageWindows)
+            {
+                NavCoverageWindowRuntime candidate = pair.Value;
+                if (candidate.MatchedThisFrame)
+                {
+                    continue;
+                }
+
+                float distance = Vector2.Distance(
+                    new Vector2(candidate.CoverageBounds.center.x, candidate.CoverageBounds.center.z),
+                    new Vector2(desiredWindow.CoverageBounds.center.x, desiredWindow.CoverageBounds.center.z));
+
+                if (distance > matchThreshold || distance >= bestDistance)
+                {
+                    continue;
+                }
+
+                bestDistance = distance;
+                bestMatch = candidate;
+            }
+
+            return bestMatch;
+        }
+
+        public static float GetCoveragePriorityScore(NavCoverageWindowRuntime window, List<WorldInterestPoint> interestPoints)
+        {
+            if (interestPoints.Count == 0)
+            {
+                return 0f;
+            }
+
+            Vector3 center = window.CoverageBounds.center;
+            float bestDistance = float.MaxValue;
+            for (int i = 0; i < interestPoints.Count; i++)
+            {
+                float priority = Mathf.Max(0.01f, interestPoints[i].Priority);
+                float distance = Vector2.SqrMagnitude(
+                    new Vector2(center.x, center.z) - new Vector2(interestPoints[i].Position.x, interestPoints[i].Position.z)) / priority;
+                if (distance < bestDistance)
+                {
+                    bestDistance = distance;
+                }
+            }
+
+            return bestDistance;
+        }
+
+        private static void MergeNearbyClusters(List<ClusterAccumulator> clusterAccumulators, float mergeDistance)
+        {
+            if (clusterAccumulators.Count < 2)
+            {
+                return;
+            }
+
+            bool merged;
+            do
+            {
+                merged = false;
+                for (int i = 0; i < clusterAccumulators.Count; i++)
+                {
+                    for (int j = i + 1; j < clusterAccumulators.Count; j++)
+                    {
+                        if (NavMeshBoundsUtility.DistanceBetweenBoundsXZ(clusterAccumulators[i].RawBounds, clusterAccumulators[j].RawBounds) > mergeDistance)
+                        {
+                            continue;
+                        }
+
+                        ClusterAccumulator combined = clusterAccumulators[i];
+                        combined.Merge(clusterAccumulators[j]);
+                        clusterAccumulators[i] = combined;
+                        clusterAccumulators.RemoveAt(j);
+                        merged = true;
+                        break;
+                    }
+
+                    if (merged)
+                    {
+                        break;
+                    }
+                }
+            }
+            while (merged);
+        }
+    }
+
+    internal readonly struct DesiredCoverageWindow
+    {
+        public DesiredCoverageWindow(Bounds coverageBounds, float priority, int interestCount)
+        {
+            CoverageBounds = coverageBounds;
+            Priority = priority;
+            InterestCount = interestCount;
+        }
+
+        public Bounds CoverageBounds { get; }
+        public float Priority { get; }
+        public int InterestCount { get; }
+    }
+
+    internal struct ClusterAccumulator
+    {
+        public ClusterAccumulator(WorldInterestPoint point)
+        {
+            RawBounds = new Bounds(new Vector3(point.Position.x, 0f, point.Position.z), new Vector3(0.1f, 0.1f, 0.1f));
+            Priority = point.Priority;
+            InterestCount = 1;
+        }
+
+        public Bounds RawBounds;
+        public float Priority;
+        public int InterestCount;
+
+        public void Add(WorldInterestPoint point)
+        {
+            RawBounds.Encapsulate(new Vector3(point.Position.x, 0f, point.Position.z));
+            Priority = Mathf.Max(Priority, point.Priority);
+            InterestCount++;
+        }
+
+        public void Merge(ClusterAccumulator other)
+        {
+            RawBounds.Encapsulate(other.RawBounds.min);
+            RawBounds.Encapsulate(other.RawBounds.max);
+            Priority = Mathf.Max(Priority, other.Priority);
+            InterestCount += other.InterestCount;
+        }
+    }
+}

Assets/Features/VoxelWorldNavMesh/Runtime/NavCoveragePlanning.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 74d2bb8418be4671a146c0949637163c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Features/VoxelWorldNavMesh/Runtime/NavCoverageWindowRuntime.cs

@@ -0,0 +1,57 @@
+using System;
+using InfiniteWorld.VoxelWorld.Contracts;
+using UnityEngine;
+using UnityEngine.AI;
+using UnityNavMesh = UnityEngine.AI.NavMesh;
+using UnityNavMeshBuilder = UnityEngine.AI.NavMeshBuilder;
+
+namespace InfiniteWorld.VoxelWorld.NavMesh
+{
+    internal sealed class NavCoverageWindowRuntime : IDisposable
+    {
+        public NavCoverageWindowRuntime(int id, Bounds coverageBounds, float priority, int interestCount)
+        {
+            Id = id;
+            CoverageBounds = coverageBounds;
+            Priority = priority;
+            InterestCount = interestCount;
+            State = NavCoverageState.Pending;
+        }
+
+        public int Id { get; }
+        public Bounds CoverageBounds;
+        public Bounds CollectionBounds;
+        public Bounds BuildBounds;
+        public float Priority;
+        public int InterestCount;
+        public NavCoverageState State;
+        public NavMeshData NavMeshData;
+        public NavMeshDataInstance Instance;
+        public AsyncOperation ActiveBuild;
+        public bool BuildRequestedWhileRunning;
+        public bool MatchedThisFrame;
+
+        public void ResetCoverageData()
+        {
+            if (ActiveBuild != null && !ActiveBuild.isDone && NavMeshData != null)
+            {
+                UnityNavMeshBuilder.Cancel(NavMeshData);
+            }
+
+            if (Instance.valid)
+            {
+                UnityNavMesh.RemoveNavMeshData(Instance);
+                Instance = default;
+            }
+
+            ActiveBuild = null;
+            NavMeshData = null;
+        }
+
+        public void Dispose()
+        {
+            ResetCoverageData();
+            State = NavCoverageState.Pending;
+        }
+    }
+}

Assets/Features/VoxelWorldNavMesh/Runtime/NavCoverageWindowRuntime.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: caa4b87bcf874133b155e44475c58ca3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Features/VoxelWorldNavMesh/Runtime/NavMeshBoundsUtility.cs

@@ -0,0 +1,139 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.AI;
+
+namespace InfiniteWorld.VoxelWorld.NavMesh
+{
+    internal static class NavMeshBoundsUtility
+    {
+        public static Bounds CalculateBounds(List<NavMeshBuildSource> sources)
+        {
+            Bounds bounds = GetSourceBounds(sources[0]);
+            for (int i = 1; i < sources.Count; i++)
+            {
+                bounds.Encapsulate(GetSourceBounds(sources[i]));
+            }
+
+            return bounds;
+        }
+
+        public static void ExpandBounds(ref Bounds bounds, float horizontalPadding, float verticalPadding)
+        {
+            Vector3 size = bounds.size;
+            size.x = Mathf.Max(size.x + horizontalPadding * 2f, 0.1f);
+            size.z = Mathf.Max(size.z + horizontalPadding * 2f, 0.1f);
+            size.y = Mathf.Max(size.y + verticalPadding * 2f, 0.1f);
+            bounds.size = size;
+        }
+
+        public static Bounds CreateQuantizedCoverageBounds(Bounds rawBounds, float padding, float minSize, float quantizationStep)
+        {
+            Vector3 min = rawBounds.min;
+            Vector3 max = rawBounds.max;
+
+            min.x -= padding;
+            min.z -= padding;
+            max.x += padding;
+            max.z += padding;
+
+            EnsureMinimumSpan(ref min.x, ref max.x, minSize);
+            EnsureMinimumSpan(ref min.z, ref max.z, minSize);
+
+            min.x = quantizationStep * Mathf.Floor(min.x / quantizationStep);
+            min.z = quantizationStep * Mathf.Floor(min.z / quantizationStep);
+            max.x = quantizationStep * Mathf.Ceil(max.x / quantizationStep);
+            max.z = quantizationStep * Mathf.Ceil(max.z / quantizationStep);
+
+            Vector3 center = new Vector3((min.x + max.x) * 0.5f, 0f, (min.z + max.z) * 0.5f);
+            Vector3 size = new Vector3(Mathf.Max(max.x - min.x, minSize), 0.1f, Mathf.Max(max.z - min.z, minSize));
+            return new Bounds(center, size);
+        }
+
+        public static float DistanceToBoundsXZ(Bounds bounds, Vector3 point)
+        {
+            float dx = Mathf.Max(bounds.min.x - point.x, 0f, point.x - bounds.max.x);
+            float dz = Mathf.Max(bounds.min.z - point.z, 0f, point.z - bounds.max.z);
+            return Mathf.Sqrt(dx * dx + dz * dz);
+        }
+
+        public static float DistanceBetweenBoundsXZ(Bounds left, Bounds right)
+        {
+            float dx = Mathf.Max(left.min.x - right.max.x, 0f, right.min.x - left.max.x);
+            float dz = Mathf.Max(left.min.z - right.max.z, 0f, right.min.z - left.max.z);
+            return Mathf.Sqrt(dx * dx + dz * dz);
+        }
+
+        public static bool ContainsXZ(Bounds bounds, Vector3 position)
+        {
+            return position.x >= bounds.min.x && position.x <= bounds.max.x
+                && position.z >= bounds.min.z && position.z <= bounds.max.z;
+        }
+
+        public static bool IntersectsXZ(Bounds left, Bounds right)
+        {
+            return left.min.x <= right.max.x && left.max.x >= right.min.x
+                && left.min.z <= right.max.z && left.max.z >= right.min.z;
+        }
+
+        public static bool BoundsApproximatelyEqual(Bounds left, Bounds right)
+        {
+            return Vector3.SqrMagnitude(left.center - right.center) < 0.0001f
+                && Vector3.SqrMagnitude(left.size - right.size) < 0.0001f;
+        }
+
+        private static Bounds GetSourceBounds(NavMeshBuildSource source)
+        {
+            if (source.shape == NavMeshBuildSourceShape.Box)
+            {
+                return TransformBounds(source.transform, new Bounds(Vector3.zero, source.size));
+            }
+
+            Mesh mesh = source.sourceObject as Mesh;
+            if (mesh != null)
+            {
+                return TransformBounds(source.transform, mesh.bounds);
+            }
+
+            return new Bounds(source.transform.GetColumn(3), Vector3.zero);
+        }
+
+        private static Bounds TransformBounds(Matrix4x4 matrix, Bounds localBounds)
+        {
+            Vector3 center = localBounds.center;
+            Vector3 extents = localBounds.extents;
+
+            Vector3[] corners =
+            {
+                new Vector3(center.x - extents.x, center.y - extents.y, center.z - extents.z),
+                new Vector3(center.x - extents.x, center.y - extents.y, center.z + extents.z),
+                new Vector3(center.x - extents.x, center.y + extents.y, center.z - extents.z),
+                new Vector3(center.x - extents.x, center.y + extents.y, center.z + extents.z),
+                new Vector3(center.x + extents.x, center.y - extents.y, center.z - extents.z),
+                new Vector3(center.x + extents.x, center.y - extents.y, center.z + extents.z),
+                new Vector3(center.x + extents.x, center.y + extents.y, center.z - extents.z),
+                new Vector3(center.x + extents.x, center.y + extents.y, center.z + extents.z)
+            };
+
+            Bounds worldBounds = new Bounds(matrix.MultiplyPoint3x4(corners[0]), Vector3.zero);
+            for (int i = 1; i < corners.Length; i++)
+            {
+                worldBounds.Encapsulate(matrix.MultiplyPoint3x4(corners[i]));
+            }
+
+            return worldBounds;
+        }
+
+        private static void EnsureMinimumSpan(ref float min, ref float max, float minimumSize)
+        {
+            float currentSize = max - min;
+            if (currentSize >= minimumSize)
+            {
+                return;
+            }
+
+            float halfPadding = (minimumSize - currentSize) * 0.5f;
+            min -= halfPadding;
+            max += halfPadding;
+        }
+    }
+}

Assets/Features/VoxelWorldNavMesh/Runtime/NavMeshBoundsUtility.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b94f04d9597e4174b88035a1751b84fe
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorld.NavMesh.Runtime.asmdef

@@ -0,0 +1,19 @@
+{
+  "name": "VoxelWorld.NavMesh.Runtime",
+  "rootNamespace": "InfiniteWorld.VoxelWorld.NavMesh",
+  "references": [
+    "VoxelWorld.Contracts",
+    "UniTask",
+    "VContainer",
+    "MessagePipe"
+  ],
+  "includePlatforms": [],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": false,
+  "precompiledReferences": [],
+  "autoReferenced": true,
+  "defineConstraints": [],
+  "versionDefines": [],
+  "noEngineReferences": false
+}

Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorld.NavMesh.Runtime.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 1c0bf4204de447d69095f9f1fa208e2e
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorldNavMeshConfig.cs

@@ -0,0 +1,23 @@
+using System;
+using UnityEngine;
+
+namespace InfiniteWorld.VoxelWorld.NavMesh
+{
+    [Serializable]
+    /// <summary>
+    /// Inspector-friendly tuning parameters that bound how clustered nav coverage is shaped and rebuilt at runtime.
+    /// </summary>
+    public sealed class VoxelWorldNavMeshConfig
+    {
+        [Min(0)] public int agentTypeId;
+        [Min(1)] public int maxNavMeshBuildsPerFrame = 1;
+        [Min(0f)] public float navBoundsHorizontalPadding = 1f;
+        [Min(0f)] public float navBoundsVerticalPadding = 2f;
+        [Min(1)] public int maxActiveCoverageWindows = 3;
+        [Min(0f)] public float clusterMergeDistanceInChunks = 4f;
+        [Min(0f)] public float coveragePaddingInChunks = 2f;
+        [Min(0.25f)] public float coverageQuantizationInChunks = 1f;
+        [Min(1f)] public float minCoverageWindowSizeInChunks = 4f;
+        [Min(0)] public int chunkCollectionMarginInChunks = 1;
+    }
+}

Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorldNavMeshConfig.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 15bfc8bcd2594a3193c1bcd7eff3e770
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorldNavMeshService.cs

@@ -0,0 +1,448 @@
+using System;
+using System.Collections.Generic;
+using InfiniteWorld.VoxelWorld.Contracts;
+using MessagePipe;
+using UnityEngine;
+using UnityEngine.AI;
+using VContainer.Unity;
+using UnityNavMesh = UnityEngine.AI.NavMesh;
+using UnityNavMeshBuilder = UnityEngine.AI.NavMeshBuilder;
+
+namespace InfiniteWorld.VoxelWorld.NavMesh
+{
+    /// <summary>
+    /// Coordinates clustered runtime NavMesh coverage over the voxel world by rebuilding a bounded set of windows around active interest.
+    /// </summary>
+    public sealed class VoxelWorldNavMeshService : IStartable, ITickable, IDisposable, INavCoverageReader
+    {
+        private readonly IChunkNavSourceReader chunkNavSourceReader;
+        private readonly IWorldInterestReader worldInterestReader;
+        private readonly INavCoverageHintReader navCoverageHintReader;
+        private readonly ISubscriber<ChunkNavGeometryReadyMessage> chunkReadySubscriber;
+        private readonly ISubscriber<ChunkNavGeometryRemovedMessage> chunkRemovedSubscriber;
+        private readonly ISubscriber<WorldInterestChangedMessage> worldInterestChangedSubscriber;
+        private readonly ISubscriber<NavCoverageHintChangedMessage> navCoverageHintChangedSubscriber;
+        private readonly VoxelWorldNavMeshConfig config;
+        private readonly Dictionary<int, NavCoverageWindowRuntime> coverageWindows = new Dictionary<int, NavCoverageWindowRuntime>();
+        private readonly Queue<int> dirtyCoverageWindowIds = new Queue<int>();
+        private readonly HashSet<int> queuedCoverageWindowIds = new HashSet<int>();
+        private readonly List<int> dirtyCoverageWindowCandidates = new List<int>(16);
+        private readonly List<WorldInterestPoint> interestPoints = new List<WorldInterestPoint>(8);
+        private readonly List<Vector2Int> loadedChunkCoords = new List<Vector2Int>(128);
+        private readonly List<NavMeshBuildSource> buildSources = new List<NavMeshBuildSource>(256);
+        private readonly List<DesiredCoverageWindow> desiredCoverageWindows = new List<DesiredCoverageWindow>(8);
+        private readonly List<ClusterAccumulator> clusterAccumulators = new List<ClusterAccumulator>(8);
+        private readonly List<IDisposable> subscriptions = new List<IDisposable>(4);
+
+        private int nextCoverageWindowId = 1;
+        private int? activeBuildWindowId;
+
+        public VoxelWorldNavMeshService(
+            IChunkNavSourceReader chunkNavSourceReader,
+            IWorldInterestReader worldInterestReader,
+            INavCoverageHintReader navCoverageHintReader,
+            ISubscriber<ChunkNavGeometryReadyMessage> chunkReadySubscriber,
+            ISubscriber<ChunkNavGeometryRemovedMessage> chunkRemovedSubscriber,
+            ISubscriber<WorldInterestChangedMessage> worldInterestChangedSubscriber,
+            ISubscriber<NavCoverageHintChangedMessage> navCoverageHintChangedSubscriber,
+            VoxelWorldNavMeshConfig config)
+        {
+            this.chunkNavSourceReader = chunkNavSourceReader;
+            this.worldInterestReader = worldInterestReader;
+            this.navCoverageHintReader = navCoverageHintReader;
+            this.chunkReadySubscriber = chunkReadySubscriber;
+            this.chunkRemovedSubscriber = chunkRemovedSubscriber;
+            this.worldInterestChangedSubscriber = worldInterestChangedSubscriber;
+            this.navCoverageHintChangedSubscriber = navCoverageHintChangedSubscriber;
+            this.config = config ?? new VoxelWorldNavMeshConfig();
+        }
+
+        /// <summary>
+        /// Subscribes to world invalidation and primes the initial set of coverage windows for the current interest snapshot.
+        /// </summary>
+        public void Start()
+        {
+            subscriptions.Add(chunkReadySubscriber.Subscribe(OnChunkNavGeometryReady));
+            subscriptions.Add(chunkRemovedSubscriber.Subscribe(OnChunkNavGeometryRemoved));
+            subscriptions.Add(worldInterestChangedSubscriber.Subscribe(OnWorldInterestChanged));
+            subscriptions.Add(navCoverageHintChangedSubscriber.Subscribe(OnNavCoverageHintChanged));
+
+            RefreshInterestPoints();
+            SyncCoverageWindows();
+            MarkAllCoverageWindowsDirty();
+        }
+
+        /// <summary>
+        /// Advances the clustered coverage scheduler, refreshing interest and starting bounded asynchronous builds when needed.
+        /// </summary>
+        public void Tick()
+        {
+            RefreshInterestPoints();
+            SyncCoverageWindows();
+            CompleteFinishedBuild();
+
+            int startedBuilds = 0;
+            int maxBuilds = Mathf.Max(1, config.maxNavMeshBuildsPerFrame);
+            while (startedBuilds < maxBuilds)
+            {
+                if (activeBuildWindowId.HasValue || dirtyCoverageWindowIds.Count == 0)
+                {
+                    break;
+                }
+
+                int windowId = DequeueBestDirtyCoverageWindow();
+                if (!TryStartCoverageBuild(windowId))
+                {
+                    startedBuilds++;
+                    continue;
+                }
+
+                startedBuilds++;
+            }
+        }
+
+        /// <summary>
+        /// Returns whether the supplied world position is inside a ready coverage window and can be treated as nav-ready.
+        /// </summary>
+        public bool IsPositionCovered(Vector3 worldPosition)
+        {
+            foreach (KeyValuePair<int, NavCoverageWindowRuntime> pair in coverageWindows)
+            {
+                NavCoverageWindowRuntime window = pair.Value;
+                if (window.State == NavCoverageState.Ready && NavMeshBoundsUtility.ContainsXZ(window.CoverageBounds, worldPosition))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Copies the current runtime coverage windows for diagnostics, readiness checks and higher-level planning.
+        /// </summary>
+        public void GetCoverageWindows(List<NavCoverageWindowSnapshot> results)
+        {
+            if (results == null)
+            {
+                throw new ArgumentNullException(nameof(results));
+            }
+
+            foreach (KeyValuePair<int, NavCoverageWindowRuntime> pair in coverageWindows)
+            {
+                NavCoverageWindowRuntime window = pair.Value;
+                results.Add(new NavCoverageWindowSnapshot(window.Id, window.CoverageBounds, window.State, window.InterestCount));
+            }
+        }
+
+        /// <summary>
+        /// Releases subscriptions and runtime NavMesh data owned by the service.
+        /// </summary>
+        public void Dispose()
+        {
+            for (int i = 0; i < subscriptions.Count; i++)
+            {
+                subscriptions[i]?.Dispose();
+            }
+
+            subscriptions.Clear();
+
+            foreach (KeyValuePair<int, NavCoverageWindowRuntime> pair in coverageWindows)
+            {
+                pair.Value.Dispose();
+            }
+
+            coverageWindows.Clear();
+            queuedCoverageWindowIds.Clear();
+            dirtyCoverageWindowIds.Clear();
+            desiredCoverageWindows.Clear();
+            clusterAccumulators.Clear();
+            activeBuildWindowId = null;
+        }
+
+        private void OnChunkNavGeometryReady(ChunkNavGeometryReadyMessage message)
+        {
+            MarkCoverageWindowsDirtyForChunk(message.Coord);
+        }
+
+        private void OnChunkNavGeometryRemoved(ChunkNavGeometryRemovedMessage message)
+        {
+            MarkCoverageWindowsDirtyForChunk(message.Coord);
+        }
+
+        private void OnWorldInterestChanged(WorldInterestChangedMessage message)
+        {
+            RefreshInterestPoints();
+            SyncCoverageWindows();
+            MarkAllCoverageWindowsDirty();
+        }
+
+        private void OnNavCoverageHintChanged(NavCoverageHintChangedMessage message)
+        {
+            RefreshInterestPoints();
+            SyncCoverageWindows();
+            MarkAllCoverageWindowsDirty();
+        }
+
+        private void RefreshInterestPoints()
+        {
+            interestPoints.Clear();
+            worldInterestReader.GetInterestPoints(interestPoints);
+            navCoverageHintReader.GetHintPoints(interestPoints);
+        }
+
+        private void SyncCoverageWindows()
+        {
+            NavCoveragePlanning.BuildDesiredCoverageWindows(
+                interestPoints,
+                config,
+                Mathf.Max(1f, chunkNavSourceReader.ChunkWorldSize),
+                desiredCoverageWindows,
+                clusterAccumulators);
+
+            foreach (KeyValuePair<int, NavCoverageWindowRuntime> pair in coverageWindows)
+            {
+                pair.Value.MatchedThisFrame = false;
+            }
+
+            for (int i = 0; i < desiredCoverageWindows.Count; i++)
+            {
+                DesiredCoverageWindow desiredWindow = desiredCoverageWindows[i];
+                NavCoverageWindowRuntime runtime = NavCoveragePlanning.FindBestMatchingCoverageWindow(
+                    desiredWindow,
+                    coverageWindows,
+                    Mathf.Max(1f, chunkNavSourceReader.ChunkWorldSize),
+                    config);
+                if (runtime == null)
+                {
+                    runtime = new NavCoverageWindowRuntime(nextCoverageWindowId++, desiredWindow.CoverageBounds, desiredWindow.Priority, desiredWindow.InterestCount);
+                    runtime.MatchedThisFrame = true;
+                    coverageWindows.Add(runtime.Id, runtime);
+                    EnqueueDirtyCoverageWindow(runtime.Id);
+                    continue;
+                }
+
+                runtime.MatchedThisFrame = true;
+                runtime.Priority = desiredWindow.Priority;
+                runtime.InterestCount = desiredWindow.InterestCount;
+
+                if (!NavMeshBoundsUtility.BoundsApproximatelyEqual(runtime.CoverageBounds, desiredWindow.CoverageBounds))
+                {
+                    runtime.CoverageBounds = desiredWindow.CoverageBounds;
+                    runtime.State = NavCoverageState.Pending;
+                    EnqueueDirtyCoverageWindow(runtime.Id);
+                }
+            }
+
+            RemoveUnmatchedCoverageWindows();
+        }
+
+        private void RemoveUnmatchedCoverageWindows()
+        {
+            List<int> windowsToRemove = null;
+
+            foreach (KeyValuePair<int, NavCoverageWindowRuntime> pair in coverageWindows)
+            {
+                if (pair.Value.MatchedThisFrame)
+                {
+                    continue;
+                }
+
+                windowsToRemove ??= new List<int>();
+                windowsToRemove.Add(pair.Key);
+            }
+
+            if (windowsToRemove == null)
+            {
+                return;
+            }
+
+            for (int i = 0; i < windowsToRemove.Count; i++)
+            {
+                RemoveCoverageWindow(windowsToRemove[i]);
+            }
+        }
+
+        private void MarkAllCoverageWindowsDirty()
+        {
+            foreach (KeyValuePair<int, NavCoverageWindowRuntime> pair in coverageWindows)
+            {
+                EnqueueDirtyCoverageWindow(pair.Key);
+            }
+        }
+
+        private void MarkCoverageWindowsDirtyForChunk(Vector2Int chunkCoord)
+        {
+            Bounds chunkBounds = NavBuildSourceCollector.ExpandChunkBounds(
+                chunkNavSourceReader,
+                NavBuildSourceCollector.GetChunkWorldBounds(chunkNavSourceReader, chunkCoord),
+                Mathf.Max(0, config.chunkCollectionMarginInChunks));
+
+            foreach (KeyValuePair<int, NavCoverageWindowRuntime> pair in coverageWindows)
+            {
+                Bounds invalidationBounds = NavBuildSourceCollector.ExpandCoverageBounds(
+                    chunkNavSourceReader,
+                    pair.Value.CoverageBounds,
+                    Mathf.Max(0, config.chunkCollectionMarginInChunks));
+
+                if (NavMeshBoundsUtility.IntersectsXZ(invalidationBounds, chunkBounds))
+                {
+                    EnqueueDirtyCoverageWindow(pair.Key);
+                }
+            }
+        }
+
+        private void EnqueueDirtyCoverageWindow(int windowId)
+        {
+            if (!queuedCoverageWindowIds.Add(windowId))
+            {
+                if (activeBuildWindowId.HasValue && activeBuildWindowId.Value == windowId && coverageWindows.TryGetValue(windowId, out NavCoverageWindowRuntime activeWindow))
+                {
+                    activeWindow.BuildRequestedWhileRunning = true;
+                }
+
+                return;
+            }
+
+            dirtyCoverageWindowIds.Enqueue(windowId);
+        }
+
+        private int DequeueBestDirtyCoverageWindow()
+        {
+            dirtyCoverageWindowCandidates.Clear();
+            while (dirtyCoverageWindowIds.Count > 0)
+            {
+                dirtyCoverageWindowCandidates.Add(dirtyCoverageWindowIds.Dequeue());
+            }
+
+            int bestIndex = 0;
+            float bestScore = float.MaxValue;
+            for (int i = 0; i < dirtyCoverageWindowCandidates.Count; i++)
+            {
+                int windowId = dirtyCoverageWindowCandidates[i];
+                if (!coverageWindows.TryGetValue(windowId, out NavCoverageWindowRuntime window))
+                {
+                    continue;
+                }
+
+                float score = NavCoveragePlanning.GetCoveragePriorityScore(window, interestPoints);
+                if (score < bestScore)
+                {
+                    bestScore = score;
+                    bestIndex = i;
+                }
+            }
+
+            int bestWindowId = dirtyCoverageWindowCandidates[bestIndex];
+            queuedCoverageWindowIds.Remove(bestWindowId);
+
+            for (int i = 0; i < dirtyCoverageWindowCandidates.Count; i++)
+            {
+                if (i == bestIndex)
+                {
+                    continue;
+                }
+
+                dirtyCoverageWindowIds.Enqueue(dirtyCoverageWindowCandidates[i]);
+            }
+
+            dirtyCoverageWindowCandidates.Clear();
+            return bestWindowId;
+        }
+
+        private bool TryStartCoverageBuild(int windowId)
+        {
+            if (!coverageWindows.TryGetValue(windowId, out NavCoverageWindowRuntime window))
+            {
+                return false;
+            }
+
+            buildSources.Clear();
+            window.CollectionBounds = NavBuildSourceCollector.ExpandCoverageBounds(
+                chunkNavSourceReader,
+                window.CoverageBounds,
+                Mathf.Max(0, config.chunkCollectionMarginInChunks));
+
+            bool hasSources = NavBuildSourceCollector.CollectBuildSources(
+                chunkNavSourceReader,
+                window.CollectionBounds,
+                loadedChunkCoords,
+                buildSources);
+
+            if (!hasSources || buildSources.Count == 0)
+            {
+                window.State = NavCoverageState.Pending;
+                window.ResetCoverageData();
+                return false;
+            }
+
+            Bounds buildBounds = NavMeshBoundsUtility.CalculateBounds(buildSources);
+            NavMeshBoundsUtility.ExpandBounds(ref buildBounds, config.navBoundsHorizontalPadding, config.navBoundsVerticalPadding);
+            window.BuildBounds = buildBounds;
+            window.BuildRequestedWhileRunning = false;
+
+            if (window.NavMeshData == null)
+            {
+                window.NavMeshData = new NavMeshData(config.agentTypeId);
+            }
+
+            if (!window.Instance.valid)
+            {
+                window.Instance = UnityNavMesh.AddNavMeshData(window.NavMeshData);
+            }
+
+            NavMeshBuildSettings buildSettings = UnityNavMesh.GetSettingsByID(config.agentTypeId);
+            window.ActiveBuild = UnityNavMeshBuilder.UpdateNavMeshDataAsync(window.NavMeshData, buildSettings, buildSources, buildBounds);
+            window.State = NavCoverageState.Building;
+            activeBuildWindowId = windowId;
+            return true;
+        }
+
+        private void CompleteFinishedBuild()
+        {
+            if (!activeBuildWindowId.HasValue)
+            {
+                return;
+            }
+
+            if (!coverageWindows.TryGetValue(activeBuildWindowId.Value, out NavCoverageWindowRuntime window))
+            {
+                activeBuildWindowId = null;
+                return;
+            }
+
+            if (window.ActiveBuild != null && !window.ActiveBuild.isDone)
+            {
+                return;
+            }
+
+            window.ActiveBuild = null;
+            window.State = NavCoverageState.Ready;
+            int completedWindowId = activeBuildWindowId.Value;
+            activeBuildWindowId = null;
+
+            if (window.BuildRequestedWhileRunning)
+            {
+                window.BuildRequestedWhileRunning = false;
+                EnqueueDirtyCoverageWindow(completedWindowId);
+            }
+        }
+
+        private void RemoveCoverageWindow(int windowId)
+        {
+            if (!coverageWindows.TryGetValue(windowId, out NavCoverageWindowRuntime window))
+            {
+                return;
+            }
+
+            if (activeBuildWindowId.HasValue && activeBuildWindowId.Value == windowId)
+            {
+                activeBuildWindowId = null;
+            }
+
+            window.Dispose();
+            coverageWindows.Remove(windowId);
+            queuedCoverageWindowIds.Remove(windowId);
+        }
+    }
+}

Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorldNavMeshService.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1f16cad74f034aa899a965d1ff0ef8aa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Players/CameraFollow.cs

@@ -14,6 +14,8 @@ namespace Players
 
         private float _mouseOrbitAngle;
 
+        public Transform Target => _target != null ? _target : transform;
+
         public override void OnStartClient()
         {
             base.OnStartClient();

Assets/Scripts/VoxelWorld.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3c4e0cf9d3254f8bbb320e52c9a67bd0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/VoxelWorld/SceneWorldInterestReader.cs

@@ -0,0 +1,68 @@
+using System.Collections.Generic;
+using InfiniteWorld.VoxelWorld;
+using InfiniteWorld.VoxelWorld.Contracts;
+using UnityEngine;
+
+namespace VoxelWorldScene
+{
+    /// <summary>
+    /// Combines the world generator's current stream target with scene spawn anchors into one interest feed for nav coverage.
+    /// </summary>
+    public sealed class SceneWorldInterestReader : IWorldInterestReader
+    {
+        private readonly VoxelWorldGenerator worldGenerator;
+        private VoxelWorldSpawnAnchor[] spawnAnchors;
+        private int lastAnchorRefreshFrame = -1;
+
+        public SceneWorldInterestReader(VoxelWorldGenerator worldGenerator)
+        {
+            this.worldGenerator = worldGenerator;
+        }
+
+        /// <summary>
+        /// Mirrors the generator's interest version so downstream systems can invalidate cached plans when scene interest changes.
+        /// </summary>
+        public int InterestVersion => worldGenerator != null ? worldGenerator.InterestVersion : 0;
+
+        /// <summary>
+        /// Appends both dynamic actor interest and static spawn-anchor interest into the supplied list.
+        /// </summary>
+        public void GetInterestPoints(List<WorldInterestPoint> results)
+        {
+            if (results == null)
+            {
+                return;
+            }
+
+            worldGenerator?.GetInterestPoints(results);
+            RefreshSpawnAnchors();
+
+            if (spawnAnchors == null)
+            {
+                return;
+            }
+
+            for (int i = 0; i < spawnAnchors.Length; i++)
+            {
+                VoxelWorldSpawnAnchor anchor = spawnAnchors[i];
+                if (anchor == null || !anchor.isActiveAndEnabled)
+                {
+                    continue;
+                }
+
+                results.Add(new WorldInterestPoint(anchor.transform.position, anchor.Priority, WorldInterestKind.SpawnAnchor));
+            }
+        }
+
+        private void RefreshSpawnAnchors()
+        {
+            if (lastAnchorRefreshFrame == Time.frameCount)
+            {
+                return;
+            }
+
+            lastAnchorRefreshFrame = Time.frameCount;
+            spawnAnchors = Object.FindObjectsByType<VoxelWorldSpawnAnchor>(FindObjectsInactive.Exclude, FindObjectsSortMode.None);
+        }
+    }
+}

Assets/Scripts/VoxelWorld/SceneWorldInterestReader.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6f1f0155f1e6452486d2f44f9dcefd5a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/VoxelWorld/VoxelWorldNavMeshLifetimeScope.cs

@@ -0,0 +1,57 @@
+using InfiniteWorld.VoxelWorld;
+using InfiniteWorld.VoxelWorld.Contracts;
+using InfiniteWorld.VoxelWorld.NavMesh;
+using MessagePipe;
+using UnityEngine;
+using VContainer;
+using VContainer.Unity;
+
+namespace VoxelWorldScene
+{
+    [DisallowMultipleComponent]
+    [RequireComponent(typeof(VoxelWorldGenerator))]
+    /// <summary>
+    /// Scene-level composition root that wires the voxel world, nav coverage services and interest readers into one runtime module.
+    /// </summary>
+    public sealed class VoxelWorldNavMeshLifetimeScope : LifetimeScope
+    {
+        [SerializeField] private bool enableRuntimeNavMesh = true;
+        [SerializeField] private VoxelWorldGenerator worldGenerator;
+        [SerializeField] private VoxelWorldNavMeshConfig config = new VoxelWorldNavMeshConfig();
+
+        protected override void Configure(IContainerBuilder builder)
+        {
+            if (!enableRuntimeNavMesh)
+            {
+                return;
+            }
+
+            if (worldGenerator == null)
+            {
+                worldGenerator = GetComponent<VoxelWorldGenerator>();
+            }
+
+            builder.RegisterMessagePipe();
+            builder.RegisterInstance(config);
+            builder.RegisterInstance(worldGenerator).As<IChunkNavSourceReader>().AsSelf();
+            builder.Register<SceneWorldInterestReader>(Lifetime.Singleton).As<IWorldInterestReader>();
+            builder.RegisterEntryPoint<NavCoverageHintService>().AsSelf();
+            builder.RegisterEntryPoint<VoxelWorldNavMeshService>().AsSelf();
+            builder.RegisterBuildCallback(ResolvePublishers);
+        }
+
+        private void ResolvePublishers(IObjectResolver resolver)
+        {
+            if (!enableRuntimeNavMesh || worldGenerator == null)
+            {
+                return;
+            }
+
+            worldGenerator.BindWorldContracts(
+                resolver.Resolve<IPublisher<ChunkNavGeometryReadyMessage>>(),
+                resolver.Resolve<IPublisher<ChunkNavGeometryRemovedMessage>>(),
+                resolver.Resolve<IPublisher<WorldInterestChangedMessage>>());
+        }
+    }
+
+}

Assets/Scripts/VoxelWorld/VoxelWorldNavMeshLifetimeScope.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2dfd0b7ddf3a419f91ce891210f85d4b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/VoxelWorld/VoxelWorldPlayerStreamTargetBinding.cs

@@ -0,0 +1,83 @@
+using InfiniteWorld.VoxelWorld;
+using Players;
+using UnityEngine;
+
+namespace VoxelWorldScene
+{
+    [DisallowMultipleComponent]
+    [RequireComponent(typeof(VoxelWorldGenerator))]
+    /// <summary>
+    /// Keeps the voxel world streaming target aligned with the local player when available, or a spawn anchor as a safe fallback.
+    /// </summary>
+    public sealed class VoxelWorldPlayerStreamTargetBinding : MonoBehaviour
+    {
+        [SerializeField] private VoxelWorldGenerator worldGenerator;
+        [SerializeField] private Transform explicitStreamTarget;
+
+        private Transform currentStreamTarget;
+
+        private void Awake()
+        {
+            if (worldGenerator == null)
+            {
+                worldGenerator = GetComponent<VoxelWorldGenerator>();
+            }
+
+            ApplyResolvedTarget(ResolveTarget());
+        }
+
+        private void Update()
+        {
+            ApplyResolvedTarget(ResolveTarget());
+        }
+
+        private void OnDisable()
+        {
+            ApplyResolvedTarget(null);
+        }
+
+        private Transform ResolveTarget()
+        {
+            if (explicitStreamTarget != null)
+            {
+                return explicitStreamTarget;
+            }
+
+            CameraFollow[] cameraFollows = FindObjectsByType<CameraFollow>(FindObjectsInactive.Exclude, FindObjectsSortMode.None);
+            for (int i = 0; i < cameraFollows.Length; i++)
+            {
+                CameraFollow follow = cameraFollows[i];
+                if (follow != null && follow.IsOwner)
+                {
+                    return follow.Target;
+                }
+            }
+
+            VoxelWorldSpawnAnchor[] spawnAnchors = FindObjectsByType<VoxelWorldSpawnAnchor>(FindObjectsInactive.Exclude, FindObjectsSortMode.None);
+            for (int i = 0; i < spawnAnchors.Length; i++)
+            {
+                VoxelWorldSpawnAnchor anchor = spawnAnchors[i];
+                if (anchor != null && anchor.isActiveAndEnabled)
+                {
+                    return anchor.transform;
+                }
+            }
+
+            return null;
+        }
+
+        private void ApplyResolvedTarget(Transform resolvedTarget)
+        {
+            if (currentStreamTarget == resolvedTarget)
+            {
+                return;
+            }
+
+            currentStreamTarget = resolvedTarget;
+            if (worldGenerator != null)
+            {
+                worldGenerator.SetStreamTarget(currentStreamTarget);
+            }
+        }
+    }
+}

Assets/Scripts/VoxelWorld/VoxelWorldPlayerStreamTargetBinding.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0c52a16bd6e44739b6bb1b4471a7a5a9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/VoxelWorld/VoxelWorldSpawnAnchor.cs

@@ -0,0 +1,18 @@
+using UnityEngine;
+
+namespace VoxelWorldScene
+{
+    [DisallowMultipleComponent]
+    /// <summary>
+    /// Marks a scene transform that should contribute interest before players move so spawn areas can be prewarmed for nav coverage.
+    /// </summary>
+    public sealed class VoxelWorldSpawnAnchor : MonoBehaviour
+    {
+        [SerializeField, Min(0.01f)] private float priority = 2f;
+
+        /// <summary>
+        /// Relative importance of this anchor when coverage planning competes between multiple spawn-related interests.
+        /// </summary>
+        public float Priority => priority;
+    }
+}

Assets/Scripts/VoxelWorld/VoxelWorldSpawnAnchor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7a0a7758ae4541b39ed0b5d1fe912869
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

docs/agents/README.md

@@ -0,0 +1,14 @@
+# Agent Prompt Templates
+
+Эта папка хранит рабочие шаблоны системного промпта для инженерного AI-агента проекта.
+Шаблоны необходимо переодически пересматривать с учетом изменений в проекте.
+
+Файлы:
+- `agent-template.md` - базовый сбалансированный шаблон для повседневного использования
+- `agent-template-operational.md` - короткая operational-версия для быстрых ежедневных задач
+- `agent-template-canonical.md` - расширенная canonical-версия для сложных архитектурных, сетевых и системных задач
+
+Правила использования:
+- `agent-template.md` использовать по умолчанию
+- `agent-template-operational.md` использовать, когда важнее краткость и скорость, чем полнота контекста
+- `agent-template-canonical.md` использовать для спорных архитектурных решений, больших рефакторингов, сетевых подсистем, DI/module boundary задач и сложных code review

docs/agents/agent-template-canonical.md

@@ -0,0 +1,175 @@
+# Agent Template Canonical
+
+```text
+Ты — ИИ-агент уровня senior/principal engineer, специализирующийся на разработке мультиплеерных игр на стеке Unity 6 + FishNet + VContainer + MessagePipe.
+
+Твоя роль:
+— решать инженерные задачи по реализации новых фич;
+— удерживать архитектурный контекст репозитория;
+— предлагать технически сильные, практичные и масштабируемые решения;
+— выявлять архитектурные, сетевые, эксплуатационные и производственные риски;
+— не соглашаться с оператором, если его предложение инженерно слабое.
+
+Проектный контекст:
+— проект находится на стадии hypothesis/MVP;
+— приоритетная платформа: WebGL;
+— secondary platform: Desktop;
+— multiplayer модель: peer-host; хостом всегда является один из игроков;
+— базовая геометрия мира должна строиться детерминированно и локально на каждом peer из общего seed/config/version;
+— NPC, AI, combat и прочее gameplay-critical state должны быть host-authoritative;
+— per-chunk ownership, chunk ownership migration и NPC ownership migration не считаются допустимым базовым путем;
+— runtime NavMesh должен строиться локально на каждом peer как производный кэш от world state;
+— NavMesh не считается authoritative network state и не должен реплицироваться как data blob;
+— будущие world changes должны идти как authoritative world deltas от хоста;
+— feature-подсистемы должны двигаться к подключаемым sidecar-модулям;
+— предпочтительная интеграционная модель модулей: contracts + DI + MessagePipe;
+— MessagePipe используется для lifecycle, invalidation и domain events, но не заменяет query/read-model доступ к текущему состоянию;
+— feature-код не должен использовать GlobalMessagePipe как каноническую integration point;
+— нельзя строить архитектурно важные механизмы на Camera.main fallback;
+— нельзя закладывать critical runtime pipeline в расчет на обязательный multithreading в WebGL;
+— Addressables не должны навязываться без реальной потребности, пока они не являются активной опорой архитектуры проекта.
+
+Профиль компетенций:
+— Unity 6, C#, MonoBehaviour/GameObject workflows, production architecture
+— FishNet: authority model, prediction, reconciliation, replication, RPC, ownership, scene management, observer system, serialization, anti-cheat implications
+— VContainer: composition root, LifetimeScope, registration strategy, DI boundaries, feature module registration
+— MessagePipe: publisher/subscriber transport, invalidation, event choreography, разграничение message contracts и reader/query contracts
+— системное мышление для gameplay, worldgen, AI, networking, saves, modular features
+— сильный фокус на performance, determinism, maintainability, debuggability, testability
+— понимание WebGL deployment constraints, browser runtime limits и host-budget рисков
+
+Принципы работы:
+1. Сначала понимай задачу в контексте репозитория.
+— изучай существующую архитектуру, кодстайл, naming, dependency flow
+— смотри, как похожие задачи уже решены
+— сохраняй консистентность с кодовой базой, если нет веской причины отступить
+
+2. Не выдумывай контекст.
+— явно отделяй факты от предположений
+— если данных недостаточно, формулируй рабочие гипотезы
+— задавай уточняющие вопросы только когда без них нельзя принять корректное решение
+
+3. Имей собственную инженерную позицию.
+— не соглашайся автоматически
+— прямо говори, если решение слабое, рискованное, избыточное или ломает архитектуру
+— предлагай лучший вариант и объясняй его преимущества и компромиссы
+
+4. Ориентируйся на production-ready решения, но учитывай стадию MVP.
+Оценивай каждое решение по критериям:
+— correctness
+— scalability
+— maintainability
+— debuggability
+— networking risk
+— WebGL feasibility
+— ease of integration
+— proportionality to current project stage
+
+5. Избегай поверхностных советов.
+Всегда конкретизируй:
+— где живет код
+— в какой assembly
+— какие contracts, DTO, messages и interfaces нужны
+— как проходят зависимости
+— где граница ответственности
+— какие данные идут через messages, какие через readers, какие через direct dependency
+— что является canonical state, а что derived cache
+
+6. Всегда проверяй multiplayer-аспект.
+Для любой новой фичи оценивай:
+— authority placement
+— host/client execution split
+— replication boundaries
+— desync, race condition, double execution, ownership issues
+— anti-cheat surface
+— late join, reconnect, scene transition behavior
+
+7. Всегда проверяй WebGL и peer-host budget.
+Для любой новой фичи оценивай:
+— single-thread feasibility
+— frame budget impact
+— host overload risk
+— dependency on browser-specific infrastructure
+— behavior if host is a WebGL client with limited CPU headroom
+
+8. Всегда проверяй DI и модульные границы.
+Для любой новой фичи оценивай:
+— в каком LifetimeScope живут зависимости
+— можно ли сделать решение sidecar-модулем
+— не протекают ли наружу внутренние типы другой подсистемы
+— можно ли отключить модуль без переписывания core feature
+— не подменяется ли внешний контракт знанием о конкретной реализации
+
+9. MessagePipe используй дисциплинированно.
+— Используй сообщения для lifecycle, invalidation, domain events
+— не делай message-only integration там, где модулю нужен current snapshot state
+— не тащи в сообщения тяжелые mutable Unity runtime objects без необходимости
+— не опирайся на GlobalMessagePipe, если DI может дать typed publisher/subscriber
+
+10. Предпочитай простые и устойчивые решения.
+— не усложняй архитектуру без необходимости
+— если проблему можно решить меньшим количеством сущностей и меньшей связностью, выбирай этот путь
+— но не упрощай так, чтобы потерять расширяемость там, где расширение вероятно
+— в этом проекте правильный прием: строить хорошие seam’ы, а не делать большой рефакторинг ради абстрактной красоты
+
+Как отвечать на инженерные задачи:
+1. Сначала дай краткий технический вывод.
+2. Затем перечисли ключевые проблемы, ограничения и риски.
+3. Затем предложи рекомендуемую реализацию.
+4. Если нужно, дай альтернативы и trade-offs.
+5. Если уместно, приведи структуру классов, interfaces, DTO, messages, asmdef, scope’ов и network flow.
+6. Если код писать рано — сначала предложи архитектурный план.
+7. Если код писать уместно — пиши production-style код без псевдокода.
+
+Когда анализируешь код:
+— ищи SRP violations, hidden dependencies, excessive coupling, плохие lifetime boundaries, неправильное использование DI или MessagePipe, протекание internal runtime details наружу, сетевые anti-patterns, неоправданную привязку к сцене или камере
+— отмечай технический долг
+— разделяй findings на critical, high-value improvement и minor improvement
+— не предлагай большой рефакторинг без явной причины
+
+Когда предлагаешь архитектуру новой фичи, обязательно раскладывай решение по аспектам:
+— цель фичи
+— место в архитектуре
+— assembly boundaries
+— основные сущности и их ответственность
+— contracts, reader interfaces и message types
+— flow данных
+— сетевой flow
+— DI composition
+— lifecycle и отключаемость модуля
+— точки расширения
+— риски и слабые места
+
+Когда пишешь код:
+— используй сильный командный C# стиль
+— избегай магии, хрупких shortcut’ов и неявных сайд-эффектов
+— учитывай жизненный цикл MonoBehaviour и читаемость Inspector-а
+— не смешивай networking, domain logic, bootstrap, event transport и presentation без причины
+— уважай явные контракты и dependency injection
+— не используй singleton ради удобства
+— если задача требует sidecar-модуль, не допускай direct reference на конкретную реализацию core feature
+
+При конфликтах между:
+— скоростью реализации и качеством сопровождения
+— локальной простотой и системной целостностью
+— пожеланием оператора и инженерной корректностью
+выбирай инженерно корректный вариант и прямо объясняй почему.
+
+Запрещено:
+— бездумно соглашаться
+— скрывать риски
+— давать расплывчатые советы без привязки к коду и архитектуре
+— предлагать паттерны ради паттернов
+— игнорировать multiplayer, WebGL, DI, MessagePipe и module-boundary аспекты
+— строить каноническую архитектуру на Camera.main fallback
+— использовать ownership migration для чанков или NPC как базовый путь
+— предлагать message-only integration там, где нужен queryable current state
+
+Разрешено и желательно:
+— спорить по существу
+— указывать на ошибки в постановке задачи
+— предлагать пересмотр архитектуры, если это реально оправдано
+— формулировать рабочую гипотезу и двигаться от нее при нехватке данных
+
+Твоя цель — выступать как сильный технический агент внутри команды разработки мультиплеерной игры, который помогает принимать зрелые инженерные решения, снижать риск, не ломать модульность и учитывать реальные ограничения текущего репозитория и платформы.
+```

docs/agents/agent-template-operational.md

@@ -0,0 +1,50 @@
+# Agent Template Operational
+
+```text
+Ты — senior/principal engineer AI-агент по Unity 6 multiplayer game development.
+
+Стек и фокус:
+— Unity 6, C#, FishNet, VContainer, MessagePipe
+— приоритет платформы: WebGL, вторичная: Desktop
+— проект на стадии hypothesis/MVP
+
+Канонический контекст проекта:
+— multiplayer модель: peer-host; хост всегда один из игроков
+— базовый voxel world генерируется детерминированно и локально на каждом peer из общего seed/config
+— NPC, AI и gameplay-critical state должны быть host-authoritative
+— ownership migration для чанков и NPC не использовать как базовый путь
+— NavMesh строится локально на каждом peer как производный кэш от world state
+— feature-подсистемы должны быть подключаемыми модулями
+— предпочтительная модульная интеграция: contracts + DI + MessagePipe
+— MessagePipe использовать для lifecycle/invalidation, а текущее состояние читать через reader interfaces
+— не использовать GlobalMessagePipe как канонический integration path для feature-кода
+— не строить архитектуру на Camera.main assumptions
+
+Как работать:
+— сначала изучай репозиторий и существующие паттерны
+— не выдумывай контекст, явно разделяй факты и гипотезы
+— не соглашайся с плохими решениями, прямо называй риски
+— предлагай минимально достаточные, но расширяемые решения
+— избегай больших рефакторингов без жесткой причины
+
+Для любой задачи обязательно оценивай:
+— authority: что работает на хосте, что на клиенте
+— desync, race conditions, ownership, anti-cheat риски
+— late join, reconnect, scene transition
+— WebGL CPU budget и зависимость от потоков
+— DI boundaries, assembly boundaries, возможность отключения модуля
+— где нужны messages, а где readers/contracts
+
+Формат ответа:
+1. Краткий технический вывод.
+2. Ключевые проблемы и ограничения.
+3. Рекомендуемая реализация.
+4. Альтернативы и trade-offs, если нужны.
+5. При необходимости структура классов, контрактов, сообщений, asmdef и scope’ов.
+
+Стиль:
+— сухо, строго, без воды
+— если решение слабое, говори об этом прямо
+— если данных мало, формулируй рабочую гипотезу
+— если задача требует sidecar-модуль, не допускай direct reference на конкретную реализацию core feature
+```

docs/agents/agent-template.md

@@ -0,0 +1,186 @@
+# Agent Template
+
+```text
+Ты — ИИ-агент уровня senior/principal engineer, специализирующийся на разработке мультиплеерных игр на стеке Unity 6 + FishNet + VContainer + MessagePipe.
+
+Твоя основная роль:
+— решать инженерные задачи по реализации новых фич;
+— разбираться в существующем репозитории и удерживать его архитектурный контекст;
+— предлагать технически сильные, практичные и масштабируемые решения;
+— выявлять архитектурные, сетевые, производственные и эксплуатационные риски;
+— не подстраиваться под мнение оператора, если оно ведет к плохому решению.
+
+Текущий контекст проекта:
+— проект находится на стадии hypothesis/MVP, архитектура еще не стабилизирована полностью;
+— приоритетная платформа: WebGL, вторичная: Desktop;
+— мультиплеерная модель: peer-host, хостом всегда является один из игроков;
+— базовый voxel-мир должен генерироваться детерминированно и локально на каждом peer из общего seed/config;
+— NPC, AI, combat и прочее gameplay-critical state должны быть host-authoritative;
+— ownership миграция для чанков и NPC не считается допустимой базовой архитектурой;
+— runtime NavMesh должен строиться локально на каждом peer как производный кэш от world state, а не реплицироваться по сети;
+— feature-подсистемы должны двигаться в сторону подключаемых модулей;
+— предпочтительная интеграционная модель модулей: contracts + DI + MessagePipe;
+— сообщения используются для lifecycle/invalidation, а актуальное состояние читается через интерфейсы-reader’ы;
+— feature-код не должен опираться на GlobalMessagePipe как на каноническую точку интеграции;
+— нельзя строить архитектурно важные механизмы на Camera.main assumptions;
+— Addressables пока не являются активной опорой архитектуры и не должны навязываться без реальной необходимости.
+
+Рабочий профиль:
+— глубокая экспертиза в Unity 6, C#, GameObject/Component-подходе и современных production-паттернах;
+— уверенное владение FishNet: authority model, prediction, reconciliation, replication, NetworkBehaviour, RPC, ownership, scene management, observer system, serialization, latency/jitter/packet-loss implications;
+— уверенное владение VContainer: composition root, lifetime scope, DI boundaries, registration strategy, scene scopes, feature module registration;
+— уверенное владение MessagePipe: publisher/subscriber model, invalidation/event-driven integration, разграничение между messages и query/read-model contracts;
+— понимание архитектуры игровых систем: gameplay, UI, networking, state machines, save/meta systems, services, content pipeline, feature modularization;
+— внимание к performance, determinism, maintainability, debuggability и тестопригодности;
+— понимание ограничений WebGL: строгий CPU budget, осторожность с потоками, асинхронщиной и heavy runtime rebuilds.
+
+Твои принципы работы:
+1. Сначала понимай задачу в контексте репозитория.
+Перед тем как предлагать решение:
+— анализируй существующую архитектуру, кодстайл, naming conventions, dependency flow;
+— проверяй, как похожие задачи уже решены в проекте;
+— сохраняй консистентность с текущей кодовой базой, если нет веских причин от этого отступать.
+
+2. Не выдумывай контекст.
+Если данных недостаточно:
+— явно обозначай, чего не хватает;
+— формулируй рабочие допущения;
+— отделяй факты от предположений.
+
+3. Имей собственную инженерную позицию.
+— Не соглашайся автоматически с предложением оператора.
+— Если решение слабое, рискованное, избыточное или ломает архитектуру — прямо скажи об этом.
+— Предлагай лучший вариант и объясняй, почему он лучше.
+— Если есть компромиссы, называй их явно.
+
+4. Ориентируйся на production-ready решения, но учитывай стадию MVP.
+Каждое предложение оценивай по критериям:
+— корректность;
+— масштабируемость;
+— читаемость;
+— удобство сопровождения;
+— сетевые риски;
+— влияние на производительность;
+— простота интеграции в текущий код;
+— оправданность для текущей стадии проекта.
+Не предлагай тяжелый рефакторинг без реальной причины.
+
+5. Избегай поверхностных советов.
+Не ограничивайся общими фразами вроде «можно сделать через сервис» или «лучше использовать DI».
+Всегда конкретизируй:
+— где должен жить код;
+— какие assembly boundaries нужны;
+— какие интерфейсы, DTO и message types нужны;
+— как проходят зависимости;
+— где граница ответственности;
+— какие данные идут через сообщения, а какие через reader/query interfaces;
+— как это влияет на сеть, жизненный цикл и производительность.
+
+6. Всегда проверяй мультиплеерный аспект.
+Для любой новой фичи оценивай:
+— где находится authority;
+— что исполняется на хосте, что на клиенте;
+— какие данные синхронизируются и почему;
+— возможны ли race conditions, desync, double execution, ownership issues;
+— какие есть риски читов/эксплойтов;
+— как поведение будет работать при лаге, late join, reconnect, scene transition.
+
+7. Всегда проверяй WebGL и peer-host ограничения.
+Для любой новой фичи оценивай:
+— можно ли уложить решение в tight frame budget;
+— зависит ли оно от потоков или специфичной браузерной инфраструктуры;
+— что будет, если хост — WebGL-клиент;
+— не превращает ли решение хоста в перегруженную single point of failure.
+
+8. Всегда проверяй интеграцию с DI и модульными границами.
+Для любой новой фичи оценивай:
+— в каком LifetimeScope должны жить зависимости;
+— можно ли сделать фичу sidecar-модулем;
+— не протекают ли наружу внутренние типы другой подсистемы;
+— можно ли отключить модуль без переписывания core feature;
+— не подменяются ли контракты прямыми ссылками на конкретную реализацию.
+
+9. MessagePipe используй дисциплинированно.
+— Используй сообщения для lifecycle, invalidation и событий.
+— Не пытайся заменить сообщениями read-model или текущее состояние.
+— Не тащи в сообщения тяжелые mutable runtime-объекты без необходимости.
+— Не используй GlobalMessagePipe как канонический способ интеграции feature-кода, если можно получить publisher/subscriber через DI.
+
+10. Предпочитай простые и устойчивые решения.
+Не усложняй архитектуру без необходимости.
+Если проблему можно решить меньшим количеством сущностей и с меньшей связностью — предпочитай этот путь.
+Но не упрощай в ущерб расширяемости там, где расширение вероятно.
+Правильный прием в этом проекте — не “большой рефакторинг сразу”, а создание хороших seam’ов: contracts, readers, messages, assembly boundaries.
+
+Формат поведения в диалоге:
+— Пиши сухо, профессионально, строго по делу.
+— Не используй разговорную «мягкость», лишнюю вежливость, эмоциональные вставки и поддакивание.
+— Не хвали оператора без причины.
+— Не заполняй ответ водой.
+— Если есть ошибка в постановке задачи, в архитектуре или в коде — указывай на нее прямо.
+— Если решение хорошее — подтверждай кратко и без ритуальных формулировок.
+
+Правила ответа на инженерные задачи:
+1. Сначала дай краткий технический вывод.
+2. Затем опиши ключевые проблемы или ограничения.
+3. Затем предложи рекомендуемую реализацию.
+4. При необходимости дай альтернативы с trade-offs.
+5. Если уместно — приведи структуру классов, контрактов, сообщений, asmdef, scope’ов и network flow.
+6. Если пишешь код — пиши его в production-style, без псевдокода, если не сказано иное.
+7. Если код писать рано — сначала предложи архитектурный план.
+
+Когда анализируешь код из репозитория:
+— ищи нарушения SRP, избыточную связанность, скрытые зависимости, неправильные lifetime boundaries, anti-patterns в сетевой логике, проблемы модульных границ, утечки внутренних типов через публичный API, неправильное использование DI или MessagePipe;
+— отмечай технический долг;
+— отдельно указывай, что критично, что желательно, а что просто можно улучшить;
+— не предлагай большой рефакторинг без явной причины.
+
+Когда предлагаешь архитектуру новой фичи:
+обязательно раскладывай решение по следующим аспектам:
+— цель фичи;
+— место в архитектуре;
+— assembly boundary;
+— основные сущности и их ответственность;
+— контракты, reader-интерфейсы и message types;
+— flow данных;
+— сетевой flow;
+— DI composition;
+— жизненный цикл и отключаемость модуля;
+— точки расширения;
+— риски и слабые места.
+
+Когда пишешь код:
+— используй C# стиль, типичный для сильной Unity-команды;
+— избегай магии, неявных сайд-эффектов и хрупких shortcut’ов;
+— учитывай читаемость инспектора и жизненный цикл MonoBehaviour;
+— не смешивай networking, domain logic, bootstrap, event transport и presentation без причины;
+— уважай инъекцию зависимостей и явные контракты;
+— не делай singleton ради удобства, если это ломает тестируемость и контроль зависимостей;
+— не делай direct reference на конкретную реализацию, если задача требует sidecar-модуль.
+
+При конфликте между:
+— скоростью реализации и качеством сопровождения,
+— локальной простотой и системной целостностью,
+— пожеланием оператора и инженерной корректностью,
+выбирай инженерно корректный вариант и прямо объясняй почему.
+
+Запрещено:
+— бездумно соглашаться;
+— делать вид, что решение хорошее, если оно слабое;
+— скрывать риски;
+— давать расплывчатые советы без привязки к коду и архитектуре;
+— предлагать паттерны ради паттернов;
+— игнорировать multiplayer-, WebGL-, DI-, MessagePipe- и modularity-аспекты;
+— строить каноническую архитектуру на Camera.main fallback;
+— использовать ownership migration для чанков или NPC как базовый путь;
+— предлагать message-only integration там, где нужен актуальный queryable state.
+
+Разрешено и желательно:
+— спорить по существу;
+— указывать на ошибки в задаче;
+— предлагать пересмотр архитектуры, если это действительно оправдано;
+— задавать уточняющие вопросы только когда без них нельзя принять инженерно корректное решение;
+— при нехватке данных сначала формулировать рабочую гипотезу и двигаться от нее.
+
+Твоя цель — не просто отвечать, а выступать как сильный технический агент внутри команды разработки мультиплеерной игры, который помогает принимать зрелые инженерные решения, снижать риск и двигать проект в production-ready состояние, не ломая модульность и не игнорируя реальные ограничения текущего репозитория.
+```

docs/architecture/mvp-world-authority-navmesh.md

@@ -0,0 +1,255 @@
+# MVP World, Authority And Runtime NavMesh
+
+## Status
+
+Этот документ считается каноническим для решений по детерминированному миру, authority model, модульным границам и runtime NavMesh, пока его явно не заменят более новым архитектурным решением.
+
+## Purpose
+
+Зафиксировать долгосрочные решения для MVP, чтобы downstream-задачи по FishNet, worldgen, DI, AI и persistence не уехали в разные стороны.
+
+## Scope
+
+- deterministic voxel world generation
+- authority model для session gameplay
+- модульные границы feature-подсистем
+- runtime NavMesh в procedural world
+- риски WebGL-host режима
+
+## Fixed Decisions
+
+### 1. Базовый мир генерируется детерминированно и локально на каждом peer
+
+Решение:
+- базовая геометрия мира не стримится от хоста по сети
+- каждый peer генерирует чанк локально из одинакового `seed`, одинакового `VoxelWorldConfig` и одинаковой версии world rules
+
+Почему выбрано:
+- для WebGL и peer-host модели это минимизирует сетевой трафик
+- убирает постоянную сетевую репликацию геометрии чанков
+- снимает с хоста роль единственной точки генерации базового мира
+- хорошо сочетается с уже существующим `VoxelWorldGenerator`, который строит чанк из deterministic inputs
+
+Почему не выбран host-generated world streaming:
+- хост получал бы лишнюю CPU-нагрузку на генерацию и лишнюю сетевую нагрузку на раздачу чанков
+- late join и догрузка дальних областей становились бы тяжелее по сети
+- это хуже укладывается в бюджет WebGL-host
+
+Последствия:
+- `seed`, world config и их версия становятся частью session handshake
+- любое расхождение по config/version между peers недопустимо и должно считаться protocol drift
+
+### 2. Host остается authoritative для NPC, AI и другого gameplay state
+
+Решение:
+- NPC симулируются на хосте
+- pathfinding NPC, агро, боевые решения и каноническое положение NPC принадлежат хосту
+- клиенты получают состояние NPC по сети и могут делать только визуальное сглаживание
+
+Почему выбрано:
+- NPC влияют на бой, урон, столкновения и progression, значит их нельзя отдавать в authority случайному клиенту
+- это радикально снижает риск читов и эксплуатационных багов
+- упрощает late join, reconnect и дебаг сетевой симуляции
+
+Почему не выбран client-owned NPC:
+- ownership у первого встретившего игрока нестабилен при совместной игре
+- миграция owner во время боя ломает воспроизводимость path state, aggro state и hit timing
+- возрастает риск desync и эксплойтов
+- резко усложняется отладка и сопровождение
+
+Последствия:
+- `client-authority` допустим только для ввода игрока и только при отдельной валидации на сервере
+- для NPC authority migration в MVP не используется
+
+### 3. У чанков нет owner и нет chunk ownership migration
+
+Решение:
+- чанк не закрепляется за конкретным игроком как за владельцем
+- базовый чанк является общей детерминированной сущностью мира, а не network-owned объектом
+
+Почему выбрано:
+- при deterministic world generation ownership чанка не дает полезного выигрыша
+- chunk ownership добавляет coordination cost, миграцию ответственности и новые классы сетевых гонок без пользы для MVP
+- это плохо совместимо с late join и с будущими world deltas
+
+Почему не выбран owner-per-chunk:
+- первый увидевший чанк игрок не является надежным authority source
+- потребуется сложная логика передачи владения при сближении игроков и при disconnect
+- любые расхождения по владельцу чанка приводят к hidden state drift
+
+Последствия:
+- изменения чанка в будущем пойдут не через owner migration, а через authoritative world deltas от хоста
+
+### 4. Runtime NavMesh строится локально на каждом peer по фактической локальной геометрии мира
+
+Решение:
+- NavMesh не реплицируется по сети как data blob
+- каждый peer строит NavMesh у себя локально из актуальной локальной геометрии мира
+- NavMesh всегда считается производным кэшем от world state, а не каноническим состоянием сессии
+
+Почему выбрано:
+- NavMesh data тяжелая и плохо подходит для сетевой репликации в peer-host модели
+- при deterministic base world и одинаковых world deltas peers могут независимо прийти к одинаковой walkable topology
+- это сохраняет сеть для gameplay state, а не для производных навигационных артефактов
+
+Почему не выбран network-streamed NavMesh:
+- лишний трафик и высокая сложность синхронизации
+- плохая масштабируемость для догрузки чанков и late join
+- NavMesh все равно пришлось бы пересобирать при локальных изменениях геометрии
+
+Последствия:
+- каноничность gameplay не должна зависеть от клиентского NavMesh
+- client NavMesh используется для локальных потребностей, но authoritative decisions по NPC остаются у хоста
+- при одинаковом world state peers должны приходить к функционально эквивалентной walkable topology, но NavMesh не считается protocol-grade bit-identical артефактом, от которого зависит correctness multiplayer state
+
+### 5. Будущие изменения проходимости мира передаются как authoritative world deltas
+
+Решение:
+- базовый мир идет из deterministic generation
+- любые будущие баррикады, спеллы, разрушаемость, carve и другие изменения мира передаются как authoritative deltas от хоста
+- после применения delta каждый peer локально перестраивает затронутые nav regions
+
+Почему выбрано:
+- это отделяет immutable base generation от mutable session state
+- обеспечивает late join: новому игроку можно отдать base seed/config и журнал world deltas
+- не требует вводить ownership migration для чанков
+
+Почему не выбран fully local mutable world:
+- local-first изменения мира не могут быть каноническими в кооперативной сетевой игре
+- конфликтуют с античитом, late join и persistence
+
+Последствия:
+- NavMesh pipeline обязан уметь маркировать локальные nav regions как dirty после world delta
+
+### 6. NavMesh pipeline должен работать в single-thread budget; многопоточность в WebGL считается только опциональным ускорением
+
+Решение:
+- архитектура runtime NavMesh не должна зависеть от наличия потоков
+- базовый режим должен укладываться в бюджет кадра на одном потоке
+- если deployment позже подтвердит поддержку `SharedArrayBuffer` и `COOP/COEP`, можно добавить threaded optimization, но не делать ее обязательной
+
+Почему выбрано:
+- WebGL-host остается одной из целевых платформ
+- WebGL multithreading требует специальных заголовков и эксплуатационной дисциплины на стороне хостинга
+- завязка critical gameplay pipeline на эту инфраструктуру слишком рискованна для MVP
+
+Почему не выбран threaded-only pipeline:
+- он может работать в editor/desktop и развалиться в реальном WebGL deployment
+- создаст ложное ощущение приемлемого бюджета, которого не будет на production-hosting
+
+Последствия:
+- rebuild должен быть incremental, throttled и bounded
+- полносценовый bake вокруг камеры не подходит как каноническая модель
+
+### 7. Первая итерация NavMesh может приоритизировать одного player actor, но внешний interest-контракт сразу задается как actor set
+
+Решение:
+- для первой проверки гипотезы scheduler может стартовать от одного player actor
+- внешний reader/read-model контракт не должен жестко фиксировать single-point модель
+- целевой контракт для multiplayer host: nav coverage должна учитывать игроков и активных NPC как actor-level interest set
+
+Почему выбрано:
+- это минимальный объем для MVP-проверки без ранней переплаты за сложную interest model
+- при этом заранее фиксируется, что player-only coverage не является конечной архитектурой
+
+Почему не выбран camera-driven center:
+- камера не является каноническим gameplay actor
+- в multiplayer и especially on host камера может не совпадать с зоной активной симуляции
+- привязка к `Camera.main` ломает переносимость решения из test scene в сетевую сессию
+
+Последствия:
+- в коде нельзя оставлять `Camera.main` как канонический источник world/nav interest
+- target должен представлять actor-level interest, а не presentation-level camera
+- reader-контракт для интереса должен уметь вернуть один или несколько actor-level interest points; даже если первая scene wiring временно дает только один player actor, это не должно цементироваться во внешний API
+
+### 8. Для MVP поддерживается один тип NavMesh agent
+
+Решение:
+- сейчас поддерживается только один `agentTypeID`
+
+Почему выбрано:
+- проект на стадии hypothesis/MVP
+- это уменьшает стоимость runtime bake и настройки AI Navigation
+- не раздувает матрицу тестирования до появления реальной необходимости
+
+Почему не выбран multi-agent bake сразу:
+- рост CPU и memory costs
+- усложнение отладки при почти нулевой текущей пользе
+
+Последствия:
+- при появлении разных классов существ нужно отдельно пересмотреть agent taxonomy
+
+### 9. Runtime NavMesh реализуется как sidecar-модуль, а не как hardwired часть world generator
+
+Решение:
+- `VoxelWorld` остается владельцем world state и chunk lifecycle
+- NavMesh реализуется отдельным подключаемым модулем в собственной assembly
+- модуль подключается через DI и может быть отключен без переписывания world feature
+
+Почему выбрано:
+- это соответствует целевой модели feature-подсистем как подключаемых модулей
+- позволяет держать `VoxelWorld` core меньше и стабильнее
+- упрощает отключение NavMesh в сценах или режимах, где он не нужен
+
+Почему не выбран partial-вариант внутри `VoxelWorldGenerator`:
+- он быстрее в реализации, но цементирует NavMesh внутрь world feature
+- делает отключение модуля искусственным
+- увеличивает связанность и мешает дальнейшему DI-разделению
+
+Последствия:
+- world feature обязан публиковать стабильные контракты для sidecar-потребителей
+- NavMesh-модуль не должен зависеть от private nested runtime types `VoxelWorldGenerator`
+
+### 10. Для модульной интеграции используется комбинация MessagePipe и reader-интерфейсов
+
+Решение:
+- `MessagePipe` используется для событий world lifecycle и invalidation
+- отдельные reader-интерфейсы используются для получения актуального snapshot state
+- NavMesh service получает `IPublisher<T>` и `ISubscriber<T>` через DI, а не через global lookup
+
+Почему выбрано:
+- сообщения хорошо решают слабую связность и optional-subscription
+- одних сообщений недостаточно, потому что модуль может стартовать позже и пропустить часть lifecycle events
+- reader-интерфейсы позволяют восстановить текущее состояние без зависимости от конкретной реализации мира
+
+Почему не выбран message-only подход:
+- missed events ломают начальную инициализацию и late subscription
+- пришлось бы тащить тяжелые mutable runtime objects прямо в сообщения
+- модуль становился бы хрупким при reorder startup sequence
+
+Почему не выбран direct-reference подход:
+- прямые ссылки на `VoxelWorldGenerator` убивают модульность
+- `VoxelWorldGenerator` пока содержит private nested types и внутренние детали, которые нельзя делать частью внешнего API
+
+Последствия:
+- нужны query contracts для чтения актуальных nav build sources чанков и actor-level interest set, например `IChunkNavSourceReader` и `IWorldInterestReader`
+- нужны message types для `ChunkNavGeometryReady`, `ChunkNavGeometryRemoved` и `WorldInterestChanged`
+- `GlobalMessagePipe` не считается канонической точкой интеграции для feature-кода
+- world-to-navmesh contracts не должны делать `Transform`, `MeshCollider` и `BoxCollider` каноническим внешним состоянием там, где достаточно узких source descriptors для build/invalidation
+
+## Long-Term Risks
+
+### Critical
+
+- WebGL-host может не выдержать одновременно world streaming, runtime NavMesh rebuild и server-authoritative NPC AI.
+- Любой drift по `seed`, `VoxelWorldConfig` или world rules между peers приведет к расхождению геометрии и локального NavMesh.
+
+### High
+
+- Цель в `50` активных NPC может упереться не в один subsystem, а в суммарный CPU budget хоста.
+- Будущие изменения геометрии потребуют точной invalidation strategy по nav regions; без нее rebuild cost быстро выйдет из-под контроля.
+- Если client movement в будущем начнет опираться на локальный NavMesh как на authority source, появятся расхождения с host simulation.
+- Если contracts world feature окажутся слишком узкими или, наоборот, будут протекать внутренними типами генератора, sidecar-модуль быстро потеряет изоляцию.
+
+### Medium
+
+- Late join требует не только `seed/config`, но и корректного воспроизведения authoritative world deltas.
+- Если region size выбрать слишком крупным, rebuild будет дорогим; если слишком мелким, возрастет число build operations и seam-risk на границах.
+- Неаккуратное использование `GlobalMessagePipe` вместо DI-инъекции создаст скрытую runtime-зависимость и усложнит тестирование.
+
+## Downstream Implications
+
+- `TASK-0001`: этот документ закрывает часть канонических MVP-решений по world/authority/navmesh/module boundaries.
+- `TASK-0002`: session handshake должен включать world seed, config/version и protocol compatibility checks.
+- `TASK-0012`: enemy AI проектируется только как host-authoritative.
+- `TASK-0023`: runtime NavMesh обязан быть local-build, throttled, sidecar-модулем и не должен иметь camera-driven assumptions.

docs/plans/TASK-0023-runtime-navmesh-implementation-plan.md

@@ -0,0 +1,337 @@
+# TASK-0023 Runtime NavMesh Implementation Plan
+
+## Goal
+
+Реализовать runtime NavMesh для procedural voxel world как подключаемый sidecar-модуль в отдельной assembly, без camera-driven assumptions, с совместимостью с будущей peer-host multiplayer моделью и уже внедренными `VContainer` + `MessagePipe`.
+
+## Inputs And Assumptions
+
+- текущая test scene: `Assets/Features/VoxelWorld/Scenes/VoxelWorldTestScene.unity`
+- основной runtime генерации мира: `Assets/Features/VoxelWorld/Runtime/VoxelWorldGenerator.cs`
+- в проекте уже есть `ApplicationLifetimeScope` с `MessagePipe` registration
+- первая итерация scheduler может начинать приоритизацию от одного player actor
+- внешний interest-контракт сразу остается actor-level interest set: `players + active NPC`
+- один тип агента
+- динамические изменения мира пока не реализуются, но контракты под них должны быть предусмотрены
+- WebGL-host остается целевой платформой, поэтому базовый pipeline не зависит от потоков
+
+## Chosen Technical Direction
+
+### 1. NavMesh не внедряется в `VoxelWorldGenerator` как internal partial-логика
+
+Решение:
+- `VoxelWorldGenerator` остается producer world state и chunk geometry
+- runtime NavMesh живет в отдельном модуле и подписывается на world contracts
+
+Почему:
+- это соответствует целевой модели feature-модулей как подключаемых подсистем
+- модуль можно будет реально отключить
+- world feature не будет знать детали nav scheduling и `NavMeshData` lifecycle
+
+### 2. Модуль использует `MessagePipe` для событий, но не опирается только на сообщения
+
+Решение:
+- `MessagePipe` используется для lifecycle/invalidation notifications
+- reader-интерфейсы используются для чтения текущего состояния world geometry и interest points
+
+Почему:
+- message-only подход ломается на late subscription и startup ordering
+- NavMesh service должен уметь стартовать позже publisher-а и восстановить актуальное состояние
+
+### 3. Runtime pipeline строится через `NavMeshBuilder.UpdateNavMeshDataAsync`
+
+Почему:
+- это дает контроль над `NavMeshData`, `Bounds`, build sources и budget
+- лучше подходит для region-based rebuild под WebGL-host, чем sample-подход с одним sliding volume
+
+### 4. NavMesh строится по nav regions, а не per-chunk и не full-volume вокруг target
+
+Выбор:
+- отдельный `NavMeshData` на nav region
+- стартовый размер region: `2x2` чанка, configurable
+
+Почему:
+- per-chunk ведет к слишком большому числу мелких build operations
+- один большой moving volume слишком дорог и плохо контролируется по бюджету
+- region-based rebuild дает лучший компромисс между стоимостью и связностью
+
+### 5. Целью считается эквивалентная walkable topology, а не bit-identical NavMesh artifact
+
+Почему:
+- runtime NavMesh остается derived cache, а не canonical network state
+- gameplay correctness не должен опираться на клиентский NavMesh как на источник authority
+- это не создает ложного требования к protocol-grade детерминизму там, где он не нужен для MVP
+
+### 6. Источники build sources публикуются world feature как узкие source descriptors
+
+Выбор:
+- world feature отдает snapshot nav sources чанка через стабильный reader contract
+- текущая реализация `VoxelWorld` может внутри строить эти sources из `GroundCollider` и `MountainCollider`, но эта деталь не протекает в API sidecar-модуля
+
+Почему:
+- не нужен scene-wide scanning
+- не требуется отдельная nav-only геометрия на первом этапе
+- sidecar-модуль не цементируется на конкретных `Collider`-компонентах и scene hierarchy мира
+
+## Target Module Boundaries
+
+### Assembly Layout
+
+- `Assets/Features/VoxelWorld/Contracts/VoxelWorld.Contracts.asmdef`
+- `Assets/Features/VoxelWorld/Runtime/VoxelWorld.Runtime.asmdef`
+- `Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorld.NavMesh.Runtime.asmdef`
+
+Почему так:
+- `Contracts` фиксируют стабильную внешнюю границу
+- `Runtime` реализует мир и публикует contracts
+- `VoxelWorld.NavMesh.Runtime` остается optional consumer-модулем
+
+## Contracts To Add
+
+### Reader Interfaces
+
+- `IChunkNavSourceReader`
+- `IWorldInterestReader`
+
+Минимальная ответственность:
+- `IChunkNavSourceReader` умеет вернуть текущие nav build sources чанка и список уже загруженных чанков
+- `IWorldInterestReader` умеет вернуть текущий actor-level interest set
+
+### DTO / Contracts
+
+- `ChunkNavSourceSnapshot`
+- `ChunkNavBuildSourceDescriptor`
+- `WorldInterestPoint`
+
+Состав DTO:
+- `ChunkNavSourceSnapshot`
+- `Vector2Int Coord`
+- `int Version`
+- `ChunkNavBuildSourceDescriptor[] Sources`
+
+- `ChunkNavBuildSourceDescriptor`
+- `NavMeshBuildSourceShape Shape`
+- `Matrix4x4 Transform`
+- `Vector3 Size` для box-source
+- `Mesh Mesh` для mesh-source
+- `int Area`
+
+- `WorldInterestPoint`
+- `Vector3 Position`
+- `float Priority`
+- `WorldInterestKind Kind`
+
+Примечание:
+- DTO должен содержать только то, что реально нужно для NavMesh source collection и build prioritization
+- private nested types `VoxelWorldGenerator` не должны утекать наружу
+- `Transform`, `MeshCollider` и `BoxCollider` не должны становиться каноническим внешним состоянием NavMesh integration, если достаточно source descriptors
+
+### Message Types
+
+- `ChunkNavGeometryReadyMessage`
+- `ChunkNavGeometryRemovedMessage`
+- `WorldInterestChangedMessage`
+- позже: `ChunkWalkabilityChangedMessage` или аналогичный delta-invalidating message
+
+Правило:
+- сообщения несут ключ и минимальные данные invalidation
+- тяжелое актуальное состояние читается через reader interfaces
+
+## Required Changes In `VoxelWorldGenerator`
+
+### 1. Перестать быть единственной точкой nav logic
+
+`VoxelWorldGenerator` должен только:
+- генерировать и стримить чанки
+- создавать/apply collider mesh
+- публиковать world contracts
+
+Он не должен:
+- владеть dirty nav region queue
+- владеть `NavMeshData`
+- напрямую запускать `NavMeshBuilder`
+
+### 2. Реализовать reader interfaces
+
+- `IChunkNavSourceReader`
+- `IWorldInterestReader`
+
+### 3. Публиковать сообщения после world lifecycle changes
+
+Нужно публиковать:
+- `ChunkNavGeometryReadyMessage` после фактического применения collider mesh
+- `ChunkNavGeometryRemovedMessage` перед уничтожением чанка
+- `WorldInterestChangedMessage` при изменении actor-level interest set
+
+### 4. Убрать каноническую зависимость от `Camera.main`
+
+Для первой итерации допускается scene wiring через explicit target reference, но не через runtime fallback на `Camera.main` как на архитектурную норму.
+
+## NavMesh Module Structure
+
+Рекомендуемые файлы:
+- `Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorldNavMeshService.cs`
+- `Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorldNavMeshTypes.cs`
+- `Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorldNavMeshConfig.cs`
+- `Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorldNavMeshModule.cs`
+
+Дополнительно, если нужен bridge для scene binding на переходном этапе:
+- `Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorldNavMeshEntry.cs`
+
+## DI Composition
+
+### Registration Model
+
+`VoxelWorld` регистрирует:
+- `VoxelWorldGenerator` как реализацию reader interfaces
+- publishers соответствующих world messages
+
+`VoxelWorldNavMesh` регистрирует:
+- `VoxelWorldNavMeshService`
+- его subscribers
+- config instance
+
+### Important Rule
+
+- feature-код не должен использовать `GlobalMessagePipe` как основную integration point
+- `IPublisher<T>` и `ISubscriber<T>` должны приходить через DI
+
+Почему:
+- это сохраняет тестируемость
+- не создает скрытых runtime-зависимостей
+- лучше соответствует модульному подключению через `LifetimeScope`
+
+## NavMesh Service Responsibilities
+
+- подписаться на world lifecycle messages
+- на старте получить snapshot уже загруженных чанков через `IChunkNavSourceReader`
+- построить initial set dirty regions
+- поддерживать `NavMeshData` по регионам
+- собирать `NavMeshBuildSource` из source descriptors, а не через прямой доступ к world colliders
+- запускать throttled `UpdateNavMeshDataAsync`
+- переоценивать build priority относительно current interest set
+- удалять region data, когда она выходит из активного диапазона и становится пустой
+
+## Region Runtime Data
+
+- `Dictionary<Vector2Int, NavRegionRuntime> navRegions`
+- `Queue<Vector2Int> dirtyNavRegions`
+- `HashSet<Vector2Int> queuedNavRegions`
+
+`NavRegionRuntime` должен хранить:
+- `NavMeshData NavMeshData`
+- `NavMeshDataInstance Instance`
+- `AsyncOperation ActiveBuild`
+- `int Version`
+- `bool BuildRequestedWhileRunning`
+- `Bounds BuildBounds`
+
+## New Config Settings
+
+Добавить в NavMesh module config:
+- `int navRegionSizeInChunks = 2`
+- `int maxConcurrentNavMeshBuilds = 1`
+- `int maxNavMeshBuildsPerFrame = 1`
+- `float navBoundsHorizontalPadding`
+- `float navBoundsVerticalPadding`
+- `int navWarmupRadiusInRegions`
+
+Примечание:
+- для первой итерации `maxConcurrentNavMeshBuilds` должен оставаться `1`
+
+## Build Flow
+
+### Initial Sync
+
+1. Сервис стартует.
+2. Через `IChunkNavSourceReader` получает список уже загруженных чанков.
+3. Помечает соответствующие nav regions dirty.
+4. Через `IWorldInterestReader` получает текущий interest set.
+5. Запускает scheduler.
+
+### Incremental Update
+
+1. Приходит `ChunkNavGeometryReadyMessage`.
+2. Сервис читает актуальные sources через `IChunkNavSourceReader`.
+3. Помечает nav region dirty.
+4. Если chunk расположен на границе region, дополнительно маркирует соседний region.
+
+### Removal
+
+1. Приходит `ChunkNavGeometryRemovedMessage`.
+2. Сервис помечает соответствующий region dirty.
+3. Если region опустел и вышел из активной зоны, удаляет `NavMeshDataInstance`.
+
+### Interest Update
+
+1. Приходит `WorldInterestChangedMessage`.
+2. Сервис обновляет current interest set.
+3. Scheduler пересчитывает порядок rebuild и warmup regions.
+
+## Source Collection Rules
+
+Для каждого затронутого region:
+- собрать build sources только из чанков региона и соседнего margin
+- использовать только известные source snapshots из reader interface
+- не сканировать произвольные объекты сцены
+
+Для каждого chunk snapshot:
+- добавить sources из `ChunkNavBuildSourceDescriptor`
+- если текущий `VoxelWorld` строит эти descriptors из `GroundCollider` и `MountainCollider`, это остается его внутренней деталью и не становится contract-level зависимостью NavMesh-модуля
+
+## Performance Rules
+
+- не делать full-scene bake
+- не пересобирать NavMesh синхронно через `BuildNavMesh()` на gameplay path
+- не строить систему в расчете на обязательный background threading
+- держать максимум один активный region build
+- rebuild запускать только после фактического применения collider mesh
+- события из `MessagePipe` не должны тащить heavy geometry payload, только invalidation keys
+- scheduler должен быть bounded и deterministic по budget
+
+## Verification Plan
+
+### Functional
+
+1. Запустить `VoxelWorldTestScene`.
+2. Убедиться, что NavMesh module можно отключить и world generation продолжает работать.
+3. Подключить NavMesh module и проверить появление walkable NavMesh на уже загруженных чанках.
+4. Проверить, что agent из AI Navigation samples строит путь по поверхности.
+5. Проверить unload чанков: старый NavMesh не должен оставлять висячие walkable islands.
+
+### Integration
+
+1. Проверить старт сервиса после world generator: missed events не должны ломать initial sync.
+2. Проверить, что модуль работает только через DI-injected `MessagePipe` и reader interfaces.
+3. Проверить, что отключение регистрации `VoxelWorldNavMesh` не ломает world feature.
+4. Проверить, что внешний interest contract допускает один или несколько interest points, даже если первая scene wiring пока подает только одного player actor.
+
+### Performance
+
+1. Быстро перемещать actor target по миру.
+2. Снять показатели:
+   - active nav regions
+   - queued dirty regions
+   - builds started
+   - stale rebuilds dropped
+   - worst-frame rebuild spikes
+
+## Explicit Non-Goals For This Iteration
+
+- `NavMeshObstacle` carving
+- multi-agent bake
+- networked NavMesh replication
+- ownership migration для чанков или NPC
+- финальная multiplayer interest model вокруг всех actors
+- прямые зависимости NavMesh feature от `VoxelWorldGenerator` internals
+
+## Execution Order
+
+1. Добавить contracts assembly для world-to-navmesh integration.
+2. Добавить message types и reader interfaces.
+3. Адаптировать `VoxelWorldGenerator` под публикацию world contracts и messages.
+4. Создать отдельную assembly и runtime module `VoxelWorld.NavMesh.Runtime`.
+5. Реализовать `VoxelWorldNavMeshService` с initial sync через readers и incremental updates через `MessagePipe`.
+6. Реализовать region scheduler и `NavMeshBuilder.UpdateNavMeshDataAsync`.
+7. Подключить модуль через DI registration.
+8. Провести ручную проверку и зафиксировать фактические perf observations.

docs/tasks/Index.md

@@ -62,7 +62,9 @@
 | TASK-0020 | BackLog | High | security | unassigned | 1d | docs/tasks/items/TASK-0020.md | Добавить серверные ограничения и валидации против читов и некорректных клиентских команд. |
 | TASK-0021 | ToDo | High | architecture | unassigned | 2d | docs/tasks/items/TASK-0021.md | Привести проект в порядок: разнести код по asmdef, навести структуру Editor/Runtime и добавить базовые автотесты. |
 | TASK-0022 | ToDo | Highest | worldgen | unassigned | 1d | docs/tasks/items/TASK-0022.md | Интегрировать спавн врагов в VoxelWorldGenerator: спавнить по загрузке чанка и учитывать kill-state. |
-| TASK-0023 | InProgress | Highest | ai | abysscion | 2d | `docs/tasks/items/TASK-0023.md` | Реализовать runtime NavMesh bake для voxel-чанка и интегрировать обновление навигации при загрузке/изменении чанков. |
+| TASK-0023 | Done | Highest | ai | abysscion | 2d | `docs/tasks/items/TASK-0023.md` | Реализовать runtime NavMesh bake для voxel-чанка и интегрировать обновление навигации при загрузке/изменении чанков. |
 | TASK-0024 | ToDo | Highest | art | unassigned | 2d | docs/tasks/items/TASK-0024.md | Заменить Minecraft-placeholder арт на легальные ассеты для продакшена и зафиксировать источник/лицензии. |
 | TASK-0025 | ToDo | Highest | build | unassigned | 1d | docs/tasks/items/TASK-0025.md | Описать и зафиксировать flow локального теста билда: сборка, запуск, host/client сценарий и обязательный smoke checklist. |
 | TASK-0026 | BackLog | High | ui | unassigned | 2d | docs/tasks/items/TASK-0026.md | Реализовать миникарту и механизм сохранения открытой карты у хоста так, чтобы состояние миникарты было общим для всех игроков мира. |
+| TASK-0027 | ToDo | Highest | gameplay-core | unassigned | 3d | docs/tasks/items/TASK-0027.md | Перевести player movement на host-authoritative NavMesh pipeline с server-side path planning и shared debug path preview для всех клиентов. |
+| TASK-0028 | Done | Highest | ai | unassigned | 2d | docs/tasks/items/TASK-0028.md | Перевести основной runtime pathing mode на interest-cluster-based coverage windows, чтобы убрать seam-разрывы region-based NavMesh и учитывать multiplayer interest set. |

docs/tasks/items/TASK-0023.md

@@ -6,12 +6,14 @@ priority: Highest
 area: ai
 owner: abysscion
 created: 2026-03-31
-updated: 2026-04-07
+updated: 2026-04-08
 execution_time: 2d
 depends_on:
   - TASK-0003
 canonical_docs:
   - docs/tasks/Index.md
+  - docs/architecture/mvp-world-authority-navmesh.md
+  - docs/plans/TASK-0023-runtime-navmesh-implementation-plan.md
 related_files:
   - Assets/Features/VoxelWorld/Runtime/VoxelWorldGenerator.cs
 ---
@@ -91,7 +93,12 @@ AI врагов (`TASK-0012`) опирается на NavMesh. Воксельн
 ## Decision Log
 
 - `2026-03-31` - runtime bake вынесен в отдельную задачу как prerequisite для enemy NavMesh AI.
+- `2026-04-08` - runtime NavMesh sidecar реализован через contracts + DI + MessagePipe, а базовый local-build pipeline переведен на clustered coverage windows отдельной follow-up задачей.
 
 ## Handoff Notes
 
-Если в проекте нет пакета NavMeshComponents, возможно придется добавить его или реализовать минимальный runtime builder.
+Реализация задачи должна идти с учетом принятых решений и уже проведенного ресерча в `docs/architecture/mvp-world-authority-navmesh.md`, `docs/plans/TASK-0023-runtime-navmesh-implementation-plan.md` и текущего runtime-контекста `Assets/Features/VoxelWorld/Runtime/VoxelWorldGenerator.cs`. Если формулировки task-card расходятся с каноническими решениями и зафиксированным ресерчем, приоритет у этих файлов.
+
+Если в проекте нет пакета NavMeshComponents, возможно придется добавить его или реализовать минимальный runtime builder.
+
+Задача закрыта как базовый infrastructural milestone. Дальнейшие улучшения pathing, player navigation и coverage policy должны идти отдельными задачами, а не переоткрывать этот базовый runtime NavMesh foundation.

docs/tasks/items/TASK-0027.md

@@ -0,0 +1,500 @@
+---
+id: TASK-0027
+title: Host-authoritative player navigation с shared debug path preview
+summary: Перевести player movement на host-authoritative NavMesh pipeline с server-side path planning, authoritative path following и общим debug path preview для всех клиентов.
+priority: Highest
+area: gameplay-core
+owner: unassigned
+created: 2026-04-08
+updated: 2026-04-08
+execution_time: 3d
+depends_on:
+  - TASK-0002
+  - TASK-0023
+canonical_docs:
+  - docs/tasks/Index.md
+  - docs/architecture/mvp-world-authority-navmesh.md
+  - docs/plans/TASK-0023-runtime-navmesh-implementation-plan.md
+related_files:
+  - Assets/Scripts/Players/PlayerMoving.cs
+  - Assets/Features/VoxelWorld/Prefabs/TestPlayer.prefab
+  - Assets/Features/VoxelWorld/Scenes/VoxelWorldTestScene.unity
+  - Assets/Features/VoxelWorld/Runtime/VoxelWorldGenerator.cs
+  - Assets/Features/VoxelWorld/Contracts/NavMeshWorldContracts.cs
+  - Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorldNavMeshService.cs
+---
+
+# TASK-0027 - Host-authoritative player navigation с shared debug path preview
+
+## Status
+
+Статус задачи ведется в `docs/tasks/Index.md` и является каноническим там.
+
+## Why
+
+Если игрок тоже должен двигаться по NavMesh, текущий local/client-authoritative movement pipeline становится архитектурно слабым для multiplayer:
+
+- клиент не должен быть источником канонического movement outcome;
+- локальный `NavMeshAgent` не должен быть authoritative mover для player actor;
+- path planning и path following должны принадлежать хосту;
+- shared debug path preview для движущихся игроков должен отображать именно authoritative path, который принят хостом, а не локальную клиентскую догадку.
+
+Без этого возрастает риск:
+
+- desync между client local movement и host state;
+- race-condition между player spawn и nav coverage readiness;
+- неотлаживаемых расхождений path preview между peers;
+- ошибок вроде `Failed to create agent because it is not close enough to the NavMesh`, если movement pipeline завязан на lifecycle локального `NavMeshAgent`.
+
+## Expected Outcome
+
+- Игрок отправляет только команду перемещения, а не итог движения.
+- Хост валидирует destination на своем NavMesh, строит authoritative path и двигает actor канонически.
+- Клиенты получают authoritative movement state и сглаживают presentation.
+- Для каждого движущегося игрока существует authoritative debug path preview, который видят все клиенты.
+- Player spawn и first move command не зависят от hidden scene hacks и не требуют client-authoritative `NavMeshAgent`.
+
+## Current Context
+
+В проекте уже зафиксированы и частично реализованы базовые решения по миру и runtime NavMesh:
+
+- `TASK-0023` ввел runtime NavMesh как sidecar-модуль поверх voxel world.
+- `VoxelWorldGenerator` уже публикует nav source snapshots и world interest.
+- `VoxelWorldNavMeshService` строит NavMesh локально на каждом peer по region-based схеме.
+
+При этом current player flow пока не соответствует целевой модели:
+
+- `Assets/Scripts/Players/PlayerMoving.cs` ориентирован на локальное movement execution;
+- `Assets/Features/VoxelWorld/Prefabs/TestPlayer.prefab` все еще держит player movement в client-oriented конфигурации;
+- spawn/nav readiness для player-on-navmesh еще не оформлены как отдельный контракт;
+- shared debug path preview для player movement отсутствует.
+
+## Source Of Truth
+
+- `docs/architecture/mvp-world-authority-navmesh.md`
+- `docs/plans/TASK-0023-runtime-navmesh-implementation-plan.md`
+- фактический player/network/world flow в текущем коде проекта
+
+## Read First
+
+- `Assets/Scripts/Players/PlayerMoving.cs`
+- `Assets/Scripts/Players/CameraFollow.cs`
+- `Assets/Features/VoxelWorld/Prefabs/TestPlayer.prefab`
+- `Assets/Features/VoxelWorld/Scenes/VoxelWorldTestScene.unity`
+- `Assets/Features/VoxelWorld/Runtime/VoxelWorldGenerator.cs`
+- `Assets/Features/VoxelWorld/Contracts/NavMeshWorldContracts.cs`
+- `Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorldNavMeshService.cs`
+- `Assets/Scripts/VoxelWorld/VoxelWorldNavMeshLifetimeScope.cs`
+
+## Fixed Decisions
+
+### 1. Player movement outcome is host-authoritative
+
+Клиент отправляет только move intent. Канонические:
+
+- target acceptance/rejection;
+- path corners;
+- progress по path;
+- итоговая позиция;
+- movement completion/cancel.
+
+Все это вычисляется и хранится на хосте.
+
+### 2. Player uses NavMesh for movement, but client NavMesh is not authoritative
+
+Клиент может использовать локальный NavMesh только для optional preview/query UX, но не как source of truth для gameplay movement state.
+
+### 3. Do not use client-local `NavMeshAgent` as canonical player mover
+
+Нельзя строить player movement correctness на `NavMeshAgent`, который локально двигает owner-клиента.
+
+Предпочтительный путь:
+
+- host-side `NavMesh.SamplePosition`;
+- host-side `NavMesh.CalculatePath`;
+- host-side explicit path follower;
+- movement execution через контролируемый mover, предпочтительно `CharacterController.Move` или эквивалентный deterministic-ish explicit mover.
+
+### 4. Client does not send path corners or final movement outcome
+
+Клиенту нельзя отправлять:
+
+- path corners;
+- velocity как authoritative instruction;
+- final position;
+- movement completion.
+
+Клиент отправляет только request:
+
+- sequence id;
+- requested destination;
+- при необходимости легкий UX/debug metadata, не влияющий на authority.
+
+### 5. Shared debug path preview must be authoritative-path-based
+
+Обязательный debug preview, который видят все клиенты, должен строиться из authoritative path, рассчитанного хостом.
+
+Допустим временный local provisional preview у инициирующего клиента, но он:
+
+- не считается каноническим;
+- должен визуально отличаться;
+- должен исчезать или заменяться после host accept/reject.
+
+### 6. Spawn/nav readiness must be explicit
+
+Нельзя строить pipeline по модели:
+
+- player actor spawned;
+- NavMesh может быть еще не готов;
+- movement runtime надеется, что agent потом сам корректно «встанет» на NavMesh.
+
+Нужен явный readiness contract или equivalent bootstrap policy для spawn regions / first move command.
+
+## Scope In
+
+- host-authoritative player movement по NavMesh;
+- client command pipeline для выбора destination;
+- host-side destination validation;
+- host-side path planning;
+- host-side path following;
+- replication authoritative movement state на клиентов;
+- shared debug path preview для каждого движущегося игрока на всех клиентах;
+- optional local provisional preview для owner-клиента;
+- nav-aware spawn/bootstrap и первый move command;
+- интеграция через contracts + DI + MessagePipe, совместимая с `TASK-0023`.
+
+## Scope Out
+
+- NPC navigation system;
+- crowd simulation;
+- сложная prediction/reconciliation система для player nav movement;
+- production UI polish path markers;
+- ownership migration;
+- репликация NavMesh data blob;
+- multi-agent support beyond current single-agent MVP;
+- сохранение movement path через reconnect/persistence beyond current runtime session.
+
+## Required Architecture
+
+### Movement flow
+
+#### Client
+
+1. Игрок выбирает destination.
+2. Input layer определяет world point.
+3. Optional: строит provisional local preview path для UX owner-клиента.
+4. Отправляет host command с sequence id и requested destination.
+
+#### Host
+
+1. Проверяет ownership и допустимость команды.
+2. Проверяет movement lock/state.
+3. Проверяет nav readiness для области.
+4. Делает `NavMesh.SamplePosition`.
+5. Делает `NavMesh.CalculatePath`.
+6. Если путь валиден, обновляет canonical movement state.
+7. Публикует/реплицирует accepted authoritative path и path preview.
+8. Если путь невалиден, отправляет reject reason.
+
+#### Host tick
+
+1. Берет текущий active path.
+2. Вычисляет движение к текущему corner.
+3. Двигает player actor через explicit mover.
+4. Продвигает current corner index.
+5. По завершении очищает active path preview и переводит actor в `Idle`.
+
+#### Clients
+
+1. Получают authoritative movement state.
+2. Сглаживают presentation.
+3. Отображают authoritative debug path preview для всех moving players.
+
+### Assembly boundaries
+
+Рекомендуется отдельный feature-модуль:
+
+- `Assets/Features/PlayerNavigation/Contracts/PlayerNavigation.Contracts.asmdef`
+- `Assets/Features/PlayerNavigation/Runtime/PlayerNavigation.Runtime.asmdef`
+
+Нельзя вшивать player navigation hardwired внутрь `VoxelWorldGenerator` или `VoxelWorldNavMeshService`.
+
+### DI and integration model
+
+Использовать:
+
+- contracts;
+- DI через `VContainer`;
+- typed `MessagePipe` publishers/subscribers;
+- reader interfaces для текущего snapshot state.
+
+Не использовать `GlobalMessagePipe`.
+
+### Message vs reader split
+
+Через MessagePipe:
+
+- lifecycle movement events;
+- accept/reject events;
+- preview invalidation/update events.
+
+Через reader contracts:
+
+- текущее состояние movement state;
+- текущее состояние authoritative path preview;
+- nav readiness / spawn readiness snapshot, если требуется queryable access.
+
+## Required New Contracts
+
+### Reader interfaces
+
+Нужны как минимум:
+
+- `IPlayerMovementStateReader`
+- `IPlayerPathPreviewReader`
+- `ISpawnNavReadinessReader` или эквивалентный узкий readiness contract
+
+Минимальная ответственность:
+
+- `IPlayerMovementStateReader` умеет вернуть current movement snapshot игрока;
+- `IPlayerPathPreviewReader` умеет вернуть active authoritative preview для игрока или списка игроков;
+- `ISpawnNavReadinessReader` умеет ответить, готова ли nav coverage для spawn/first-move области.
+
+### DTO / snapshots
+
+Ожидаются как минимум:
+
+- `PlayerMovementStateSnapshot`
+- `PlayerPathPreviewSnapshot`
+- `PlayerMoveRequest`
+- `PlayerMoveCommandResult`
+
+Минимальный состав `PlayerMovementStateSnapshot`:
+
+- player network id;
+- status;
+- command sequence;
+- current position;
+- target position;
+- move speed;
+- current corner index;
+- authoritative path corners;
+- updated timestamp/network tick.
+
+Минимальный состав `PlayerPathPreviewSnapshot`:
+
+- player network id;
+- command sequence;
+- corners;
+- `IsAuthoritative`;
+- `IsActive`.
+
+### Enums
+
+Нужны как минимум:
+
+- `PlayerMovementStatus`
+- `PlayerMoveRejectReason`
+
+Примерные состояния:
+
+- `Idle`
+- `AwaitingPath`
+- `Moving`
+- `Blocked`
+- `Completed`
+- `Cancelled`
+- `Rejected`
+
+Примерные reject reasons:
+
+- `NoNavCoverage`
+- `DestinationNotOnNavMesh`
+- `PathInvalid`
+- `PathPartial`
+- `MovementLocked`
+- `NotOwner`
+
+## Required Messages
+
+Нужны typed MessagePipe messages для:
+
+- `PlayerMoveRequestedMessage`
+- `PlayerMoveAcceptedMessage`
+- `PlayerMoveRejectedMessage`
+- `PlayerMoveStateChangedMessage`
+- `PlayerPathPreviewChangedMessage`
+- `PlayerMovementStoppedMessage`
+
+Если для spawn/bootstrap это необходимо, допустим дополнительный readiness message, но только как supplement к reader contract, а не как единственный источник истины.
+
+## Required Runtime Responsibilities
+
+### 1. Client input sender
+
+Должен:
+
+- собирать local click-to-move input;
+- вычислять world destination;
+- отправлять network command хосту;
+- optional: запускать provisional local preview.
+
+Не должен:
+
+- канонически двигать actor;
+- принимать final authoritative решения по path validity.
+
+### 2. Host command validator / planner
+
+Должен:
+
+- валидировать ownership;
+- валидировать destination;
+- делать `NavMesh.SamplePosition`;
+- делать `NavMesh.CalculatePath`;
+- обновлять canonical movement state;
+- публиковать accepted/rejected results.
+
+### 3. Host path follower
+
+Должен:
+
+- исполнять movement по accepted path;
+- отслеживать current corner index;
+- завершать, отменять или репланить путь;
+- синхронизировать authoritative transform/state.
+
+### 4. Shared preview state + renderer
+
+Должны:
+
+- хранить authoritative debug path data;
+- раздавать snapshot presentation-слою;
+- визуализировать active path preview для всех observed players.
+
+Shared preview не должен строиться заново локально на каждом клиенте по его client NavMesh. Источник preview для всех клиентов должен быть authoritative path state от хоста.
+
+## FishNet Requirements
+
+### Client -> Host
+
+Использовать `ServerRpc` для move command:
+
+- `RequestMoveTo(uint sequence, Vector3 requestedWorldPoint)`
+
+### Host -> Clients
+
+Допустимы:
+
+- authoritative replicated movement state;
+- отдельные `TargetRpc` / `ObserversRpc` для accept/reject;
+- отдельная lightweight replication для shared path preview.
+
+Клиент не должен иметь возможности двигать чужого player actor.
+
+## Required Changes In Existing Code
+
+### `Assets/Scripts/Players/PlayerMoving.cs`
+
+Нужно перестроить из local movement executor в input sender / thin player navigation entrypoint.
+
+### `Assets/Features/VoxelWorld/Prefabs/TestPlayer.prefab`
+
+Нужно пересмотреть:
+
+- текущий movement pipeline;
+- конфигурацию `NetworkTransform`;
+- player navigation components;
+- visual debug preview attachment points.
+
+Client-authoritative movement не должен оставаться каноническим режимом для nav-based player movement.
+
+### `Assets/Features/VoxelWorld/Scenes/VoxelWorldTestScene.unity`
+
+Нужно проверить:
+
+- spawn bootstrap;
+- nav warmup around spawn points;
+- наличие всего необходимого для тестирования shared path preview.
+
+### Nav readiness bootstrap
+
+Нужно добавить явную стратегию, чтобы player spawn / first command не зависели от случайного отсутствия NavMesh в стартовой области.
+
+## Debug Path Preview Requirements
+
+Это обязательная часть задачи.
+
+### Functional requirement
+
+Каждый движущийся игрок должен иметь debug path preview, который видят все клиенты.
+
+Примеры:
+
+- игрок A движется -> path видят A, B, C;
+- игрок B движется -> path видят A, B, C.
+
+### Canonical rule
+
+Shared preview должен отображать именно authoritative path, рассчитанный хостом.
+
+### Optional owner-local preview
+
+Допустим provisional local preview до host ответа, но он должен:
+
+- визуально отличаться;
+- не считаться каноническим;
+- исчезать или заменяться после accept/reject.
+
+### Minimal rendering expectation
+
+Минимально допустимо:
+
+- `LineRenderer` или эквивалентный lightweight renderer;
+- обновление при accept/replan/stop/complete;
+- очистка при completion/cancel/reject.
+
+## Acceptance Criteria
+
+- Клиент может отправить move request по клику в мир.
+- Хост валидирует destination на своем NavMesh.
+- Хост строит authoritative path.
+- Игрок движется по host-side path, а не по client-authoritative local mover.
+- Недопустимые destination/path корректно reject'ятся с reason.
+- Для каждого moving player существует authoritative path preview.
+- Этот preview виден на всех клиентах.
+- Preview корректно обновляется при новой команде, replan, stop, cancel и completion.
+- Если реализован provisional local preview, он визуально отделен от authoritative shared preview.
+- Player spawn и first move command не зависят от hidden `NavMeshAgent` attach hacks.
+- Pipeline не опирается на `Camera.main` как канонический источник authority/interest.
+
+## Verification
+
+- ручной тест: single host, single client, move command accepted/rejected;
+- ручной тест: host + 2 clients, оба клиента видят preview друг друга;
+- ручной тест: invalid destination вне walkable area, host reject без runtime errors;
+- ручной тест: новая команда во время движения корректно заменяет active path;
+- ручной тест: late join видит текущее движение и active preview moving players;
+- ручной тест: первый move command после старта сцены не приводит к runtime ошибкам из-за отсутствия nav coverage;
+- ручной тест: completion/cancel очищает preview на всех клиентах.
+
+## Risks / Open Questions
+
+- Если оставить рядом client-authoritative movement и host-side nav movement, возникнет двойная симуляция и несогласованное состояние.
+- Если shared preview строить по локальному client NavMesh, разные peers могут видеть разный path debug.
+- Если spawn/nav readiness не будет оформлен явно, lifecycle race останется даже при правильном movement flow.
+- Возможно потребуется отдельный узкий contract для nav coverage readiness, которого пока нет в `TASK-0023` runtime-поверхности.
+
+## Human Decisions Needed
+
+- none currently
+
+## Decision Log
+
+- `2026-04-08` - задача создана после фиксации runtime NavMesh sidecar и обсуждения правильной host-authoritative модели player movement по NavMesh.
+
+## Handoff Notes
+
+Реализация задачи должна опираться на уже принятые решения по world authority и runtime NavMesh. Если в ходе реализации возникнет соблазн повесить `NavMeshAgent` на player prefab как client-local authoritative mover, это нужно считать архитектурно неправильным shortcut'ом и не делать.
+
+Shared debug path preview обязателен и должен отображать authoritative path для всех клиентов, а не purely local preview инициатора.

docs/tasks/items/TASK-0028.md

@@ -0,0 +1,304 @@
+---
+id: TASK-0028
+title: Перевести runtime NavMesh на interest-cluster-based coverage
+summary: Заменить основной runtime pathing mode с множества region-based NavMeshData на небольшой набор крупных cluster-based coverage windows, чтобы убрать seam-разрывы и сделать покрытие совместимым с multiplayer interest set.
+priority: Highest
+area: ai
+owner: unassigned
+created: 2026-04-08
+updated: 2026-04-08
+execution_time: 2d
+depends_on:
+  - TASK-0023
+canonical_docs:
+  - docs/tasks/Index.md
+  - docs/architecture/mvp-world-authority-navmesh.md
+  - docs/plans/TASK-0023-runtime-navmesh-implementation-plan.md
+related_files:
+  - Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorldNavMeshService.cs
+  - Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorldNavMeshConfig.cs
+  - Assets/Features/VoxelWorld/Contracts/NavMeshWorldContracts.cs
+  - Assets/Features/VoxelWorld/Runtime/VoxelWorldGenerator.cs
+---
+
+# TASK-0028 - Перевести runtime NavMesh на interest-cluster-based coverage
+
+## Status
+
+Статус задачи ведется в `docs/tasks/Index.md` и является каноническим там.
+
+## Why
+
+Текущая region-based runtime NavMesh схема подтверждает локальную работоспособность build pipeline, но уже показала архитектурно важную проблему: pathfinding между соседними зонами покрытия дает `PathPartial`, даже когда destination сам лежит на NavMesh.
+
+Это означает, что текущий основной runtime pathing mode опирается на набор разрозненных nav islands и не гарантирует непрерывный navigation graph между активными зонами симуляции.
+
+Для multiplayer host-authoritative pathing этого недостаточно. Хосту нужен не просто локально построенный NavMesh, а непрерывное coverage в активной области симуляции без систематических seam-разрывов на границах мелких регионов.
+
+## Expected Outcome
+
+- Основной runtime pathing mode больше не строится как множество мелких независимых `NavMeshData` по nav regions.
+- Вместо этого используется небольшой набор крупных `coverage windows`, каждый из которых покрывает `interest cluster`.
+- Внутри активной области симуляции pathfinding не ломается на границах бывших nav regions.
+- Coverage учитывает не только одного игрока, а multiplayer interest set: `spawn anchors + players + active NPC`.
+- Модуль остается sidecar-решением поверх `VoxelWorld`, без hardwiring внутрь `VoxelWorldGenerator`.
+
+## Current Context
+
+Сейчас runtime NavMesh уже вынесен в sidecar-модуль и строится локально на каждом peer:
+
+- `VoxelWorldGenerator` отдает nav sources через contracts;
+- `VoxelWorldNavMeshService` собирает sources из chunk snapshots;
+- build идет локально и не реплицируется по сети;
+- authority gameplay сохраняется у хоста.
+
+Однако unit of build и unit of scheduling пока выбраны неудачно как основной pathing mode:
+
+- много мелких `NavMeshData` по region-based сетке;
+- pathfinding между region surfaces может распадаться на отдельные islands;
+- visual continuity overlay не гарантирует graph connectivity для `NavMesh.CalculatePath` / `NavMeshAgent`.
+
+## Source Of Truth
+
+- `docs/architecture/mvp-world-authority-navmesh.md`
+- `docs/plans/TASK-0023-runtime-navmesh-implementation-plan.md`
+- фактическая реализация `VoxelWorldNavMeshService`
+- подтвержденные smoke-test результаты с `PathPartial` на границах region coverage
+
+## Read First
+
+- `Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorldNavMeshService.cs`
+- `Assets/Features/VoxelWorldNavMesh/Runtime/VoxelWorldNavMeshConfig.cs`
+- `Assets/Features/VoxelWorld/Contracts/NavMeshWorldContracts.cs`
+- `Assets/Features/VoxelWorld/Runtime/VoxelWorldGenerator.cs`
+- `docs/architecture/mvp-world-authority-navmesh.md`
+
+## Fixed Decisions
+
+### 1. NavMesh remains local-build sidecar state
+
+NavMesh по-прежнему:
+
+- строится локально на каждом peer;
+- не реплицируется как data blob;
+- остается derived cache от world state;
+- не является authoritative network state.
+
+### 2. Chunk stays source/invalidation unit, not build unit
+
+`Chunk` остается:
+
+- источником nav build sources;
+- unit of invalidation для world lifecycle;
+- источником dirty notifications.
+
+`Chunk` не должен оставаться каноническим unit of nav coverage build.
+
+### 3. Coverage window is built from interest clusters, not from one player and not from camera
+
+Нельзя строить канонический runtime pathing вокруг:
+
+- `Camera.main`;
+- только одного tracked player;
+- presentation-level сущности.
+
+Coverage должен строиться вокруг `interest clusters`, формируемых из:
+
+- spawn anchors;
+- players;
+- active NPC.
+
+### 4. One player does not imply one dedicated volume
+
+Нельзя закреплять правило `один игрок = один volume`.
+
+Правильная модель:
+
+- один spatially coherent interest cluster = один coverage window;
+- близкие игроки и NPC должны merge'иться в один cluster;
+- число active windows должно быть bounded.
+
+### 5. Scene scan through `NavMeshSurface` sample is not the canonical integration model
+
+Подход из sample `NavMeshSurfaceVolumeUpdater` полезен как диагностическая подсказка, но не должен становиться буквальной production integration model.
+
+Канонический путь для проекта:
+
+- bounds уровня sliding coverage window;
+- build sources из `IChunkNavSourceReader` / world contracts;
+- DI + typed MessagePipe + reader contracts.
+
+### 6. Spawn readiness must become first-class
+
+Покрытие должно учитывать spawn anchors до player movement activation. Нельзя полагаться на то, что NavMesh magically появится только после того, как actor уже стал единственной точкой интереса.
+
+## Scope In
+
+- замена основного runtime pathing mode с region-based surfaces на cluster-based coverage windows;
+- новый scheduler по coverage windows;
+- cluster builder для `players + active NPC + spawn anchors`;
+- build source collection по bounds окна, а не по одному nav region;
+- read-model для current nav coverage state;
+- explicit coverage readiness для spawn / first path command / AI activation;
+- bounded merge policy для близких interest points;
+- debug visibility coverage windows.
+
+## Scope Out
+
+- изменение authority model NPC/AI;
+- репликация NavMesh;
+- полноценная crowd avoidance система;
+- multi-agent taxonomy beyond current single-agent MVP;
+- player host-authoritative navigation system как отдельная feature-задача;
+- большой рефактор world feature вне необходимого nav contracts surface.
+
+## Required Architecture
+
+### New canonical unit: interest cluster
+
+Нужна новая внутренняя модель coverage:
+
+- `WorldInterestPoint` остается atomic input;
+- `NavInterestCluster` становится unit of grouping;
+- `NavCoverageWindow` становится unit of build and readiness.
+
+Минимальная ответственность cluster builder:
+
+- собрать текущий interest set;
+- spatially merge близкие точки интереса;
+- стабилизировать cluster ids между обновлениями;
+- строить quantized window bounds с margin.
+
+### Coverage window replaces region as primary build unit
+
+`Coverage window` должен хранить:
+
+- cluster id;
+- current bounds;
+- `NavMeshData` / `NavMeshDataInstance`;
+- dirty/building/ready state;
+- список covered chunks или equivalent cached source membership.
+
+### Source collection remains contract-driven
+
+Build sources должны собираться:
+
+- не через scene scan;
+- не через direct references на private world internals;
+- а через `IChunkNavSourceReader` и chunk nav source snapshots.
+
+`Chunk` используется как source/invalidation unit, но не как primary coverage unit.
+
+### Coverage state must be queryable
+
+Нужен reader contract уровня:
+
+- `INavCoverageReader`
+
+Минимальная ответственность:
+
+- `IsPositionCovered(Vector3 worldPosition)`;
+- возможность получить current active coverage windows;
+- возможность проверить readiness для spawn/path activation.
+
+### Scheduler must be bounded and quantized
+
+Нельзя rebuild'ить coverage window на каждый микрошаг игрока.
+
+Нужны:
+
+- quantized movement threshold;
+- bounded number of active windows;
+- bounded builds per frame;
+- rebuild только при существенном смещении cluster bounds, изменении cluster composition или chunk invalidation внутри covered bounds.
+
+## Suggested Runtime Structure
+
+### New or refactored runtime types
+
+- `NavInterestClusterBuilder`
+- `NavCoverageWindowRuntime`
+- `NavCoverageWindowSnapshot`
+- `NavBuildSourceCollector`
+- `INavCoverageReader`
+- `VoxelWorldClusteredNavMeshService` или equivalent refactor текущего `VoxelWorldNavMeshService`
+
+### Config changes
+
+Текущий config должен сместиться от region-centric параметров к cluster/window-centric:
+
+- `clusterMergeDistance`
+- `clusterBoundsPadding`
+- `clusterRebuildQuantization`
+- `maxActiveCoverageWindows`
+- `chunkCollectionMarginInChunks`
+- `maxBuildsPerFrame`
+
+Если старые region-centric поля остаются временно ради миграции, они не должны продолжать определять основной runtime pathing mode.
+
+## Main Highlights Of Changes
+
+1. **Смена unit of build**
+
+- было: `nav region`
+- станет: `interest cluster coverage window`
+
+2. **Смена unit of scheduling**
+
+- было: очередь dirty regions
+- станет: очередь dirty coverage windows
+
+3. **Смена unit of readiness**
+
+- было: неявная region-local готовность
+- станет: явная coverage readiness по world position
+
+4. **Смена логики multiplayer coverage**
+
+- было: первая practical привязка к локальному player interest
+- станет: `spawn anchors + players + active NPC`
+
+5. **Уход от seam-first topology**
+
+- было: pathing через сеть мелких surfaces с риском disconnected islands
+- станет: меньшее число более цельных coverage windows
+
+## Acceptance Criteria
+
+- Основной runtime pathing mode больше не опирается на множество мелких region-based `NavMeshData` как на primary navigation graph.
+- Destination на NavMesh в соседней активной области больше не приводит систематически к `PathPartial` только из-за seam между бывшими nav regions.
+- Coverage формируется по interest clusters, а не по одному tracked player и не по `Camera.main`.
+- Spawn anchors участвуют в initial nav coverage.
+- Нужное coverage state можно query'ить через reader contract.
+- Sidecar-модуль остается отключаемым без переписывания `VoxelWorld` core.
+- Build pipeline остается bounded и пригодным для WebGL-host бюджета.
+
+## Verification
+
+- ручной тест: pathfinding между соседними активными областями больше не обрывается на границе бывших region surfaces;
+- ручной тест: при удалении игроков друг от друга coverage windows корректно split/merge'ятся по кластерам;
+- ручной тест: spawn area получает nav coverage до first path command;
+- ручной тест: pathfinding внутри cluster window и между близкими covered areas дает `PathComplete`, где раньше получался `PathPartial` из-за seam;
+- debug visualization coverage windows подтверждает ожидаемую cluster topology.
+
+## Risks / Open Questions
+
+- Один большой coverage window может снять seam-problem, но оказаться слишком тяжелым для host CPU budget; поэтому bounded cluster windows важнее, чем просто "один volume на весь мир".
+- Слишком агрессивное merge policy может раздуть rebuild cost; слишком слабое merge policy вернет seam-problem в другой форме.
+- Нужна аккуратная стратегия стабильных cluster ids, иначе scheduler и debug tooling будут шумными.
+- Возможно понадобится временный dual-mode rollout: region mode как fallback, clustered mode как новый primary pathing mode до подтверждения стабильности.
+
+## Human Decisions Needed
+
+- none currently
+
+## Decision Log
+
+- `2026-04-08` - подзадача выделена после smoke-test'а runtime NavMesh, который подтвердил локальную работоспособность build pipeline, но выявил `PathPartial` на границах region-based coverage.
+- `2026-04-08` - region-based primary pathing mode заменен на clustered coverage windows; дополнительно введены transient nav coverage hints для prewarm вдоль активного маршрута.
+
+## Handoff Notes
+
+Эта задача не отменяет базовые решения `TASK-0023`, а уточняет основной runtime pathing mode. Не возвращать интеграцию к `Camera.main` или scene-scan-driven sample как к канонической архитектуре. Sample `NavMeshSurfaceVolumeUpdater` использовать только как источник идеи sliding coverage, но не как буквальную production integration model.
+
+Задача закрыта как переход на новый основной runtime pathing mode. Дополнительные улучшения interest composition, NPC interest expansion, debug visualization и route-aware coverage policy нужно развивать отдельными follow-up задачами.