fix: Unify SyncVar and SyncCollection replay across host visibility, scene re-observation, and pooled respawn

Assets/Mirror/Core/NetworkClient.cs

@@ -1092,6 +1092,8 @@ internal static void InternalAddPlayer(NetworkIdentity identity)
         {
             //Debug.Log("NetworkClient.InternalAddPlayer");
 
+            bool hadLocalPlayer = localPlayer != null;
+
             // NOTE: It can be "normal" when changing scenes for the player to be destroyed and recreated.
             // But, the player structures are not cleaned up, we'll just replace the old player
             localPlayer = identity;
@@ -1107,6 +1109,34 @@ internal static void InternalAddPlayer(NetworkIdentity identity)
                 connection.identity = identity;
             }
             else Debug.LogWarning("NetworkClient can't AddPlayer before being ready. Please call NetworkClient.Ready() first. Clients are considered ready after joining the game world.");
+
+            if (NetworkServer.activeHost && !hadLocalPlayer)
+                FlushHostVisibilityDeferredCallbacks();
+        }
+
+        static void FlushHostVisibilityDeferredCallbacks()
+        {
+            if (NetworkServer.localConnection == null || localPlayer == null)
+                return;
+
+            // Hooks may change visibility/ownership, so iterate a snapshot.
+            List<NetworkIdentity> observed = new List<NetworkIdentity>(NetworkServer.localConnection.observing);
+            foreach (NetworkIdentity identity in observed)
+            {
+                if (identity == null || !spawned.ContainsKey(identity.netId))
+                    continue;
+
+                identity.hostInitialSpawn = true;
+                try
+                {
+                    foreach (NetworkBehaviour comp in identity.NetworkBehaviours)
+                        comp.InvokeHostVisibilityDeferredCallbacks();
+                }
+                finally
+                {
+                    identity.hostInitialSpawn = false;
+                }
+            }
         }
 
         /// <summary>Sends AddPlayer message to the server, indicating that we want to join the world.</summary>
@@ -1182,7 +1212,15 @@ internal static void ApplySpawnPayload(NetworkIdentity identity, SpawnMessage me
             {
                 using (NetworkReaderPooled payloadReader = NetworkReaderPool.Get(message.payload))
                 {
-                    identity.DeserializeClient(payloadReader, true);
+                    identity.clientInitialSpawnActive = true;
+                    try
+                    {
+                        identity.DeserializeClient(payloadReader, true);
+                    }
+                    finally
+                    {
+                        identity.clientInitialSpawnActive = false;
+                    }
                 }
             }
 
@@ -1368,18 +1406,7 @@ internal static void OnObjectSpawnFinished(ObjectSpawnFinishedMessage _)
                     // This ensures all objects are in spawned dictionary (cross-references work)
                     // and hooks fire in declaration order, before user OnStartClient logic runs.
                     foreach (NetworkBehaviour comp in identity.NetworkBehaviours)
-                    {
-                        foreach (Action hook in comp.deferredSyncVarHooks)
-                            hook?.Invoke();
-
-                        comp.deferredSyncVarHooks.Clear();
-
-                        // Invoke deferred SyncCollection Actions AFTER SyncVar hooks
-                        foreach (Action action in comp.deferredSyncCollectionActions)
-                            action?.Invoke();
-
-                        comp.deferredSyncCollectionActions.Clear();
-                    }
+                        comp.InvokeDeferredSyncCallbacks();
 
                     BootstrapIdentity(identity);
                 }
@@ -1397,6 +1424,12 @@ static void OnHostClientObjectHide(ObjectHideMessage message)
             if (spawned.TryGetValue(message.netId, out NetworkIdentity identity) &&
                 identity != null)
             {
+                foreach (NetworkBehaviour component in identity.NetworkBehaviours)
+                {
+                    component.MarkAllSyncVarHostVisibilityReplayPending();
+                    component.MarkAllSyncObjectHostVisibilityReplayPending();
+                }
+
                 if (aoi != null)
                     aoi.SetHostVisibility(identity, false);
             }
@@ -1421,28 +1454,21 @@ internal static void OnHostClientSpawn(SpawnMessage message)
 
                 identity.isOwned = message.isOwner;
 
-                // Ensure SyncVar hooks fire during deserialization for host client initial spawn.
-                // Fields were already set server-side, but hooks haven't fired yet because the
-                // object wasn't in NetworkClient.spawned when setters ran during OnStartServer().
+                // Ensure host-visible SyncVar hooks and SyncCollection Add replays flush now.
+                // Fields were already set server-side, but host callbacks may have been deferred
+                // until the object was actually visible to the host client.
                 identity.hostInitialSpawn = true;
 
-                // Configure flags before deserializing
+                // Configure flags before invoking host-visible callbacks.
                 InitializeIdentityFlags(identity);
 
-                // Deserialize components if any payload.
-                // This will trigger SyncVar hooks via GeneratedSyncVarDeserialize.
-                if (message.payload.Count > 0)
-                {
-                    using (NetworkReaderPooled payloadReader = NetworkReaderPool.Get(message.payload))
-                    {
-                        identity.DeserializeClient(payloadReader, true);
-                    }
-                }
+                foreach (NetworkBehaviour comp in identity.NetworkBehaviours)
+                    comp.InvokeHostVisibilityDeferredCallbacks();
 
-                // Clear flag after deserialization
+                // Clear flag after host-visible callbacks replay.
                 identity.hostInitialSpawn = false;
 
-                // Invoke callbacks after deserializing
+                // Invoke callbacks after host-visible state is ready.
                 InvokeIdentityCallbacks(identity);
             }
         }
@@ -1588,7 +1614,7 @@ static void OnRPCMessage(RpcMessage message)
             // Rpcs often can't be applied if interest management unspawned them
         }
 
-        static void OnObjectHide(ObjectHideMessage message) => DestroyObject(message.netId);
+        internal static void OnObjectHide(ObjectHideMessage message) => DestroyObject(message.netId);
 
         internal static void OnObjectDestroy(ObjectDestroyMessage message) => DestroyObject(message.netId);
 
@@ -1937,6 +1963,7 @@ public static void DestroyAllClientObjects()
                                 // they always stay in the scene, we don't destroy them.
                                 if (identity.sceneId != 0)
                                 {
+                                    identity.ResetSyncObjectCallbacks();
                                     identity.ResetState();
                                     identity.gameObject.SetActive(false);
                                 }
@@ -1964,6 +1991,8 @@ static void DestroyObject(uint netId)
             // Debug.Log($"NetworkClient.OnObjDestroy netId: {netId}");
             if (spawned.TryGetValue(netId, out NetworkIdentity identity) && identity != null)
             {
+                ulong sceneId = identity.sceneId;
+
                 if (identity.isLocalPlayer)
                     identity.OnStopLocalPlayer();
 
@@ -1976,7 +2005,7 @@ static void DestroyObject(uint netId)
                     identity.ResetState();
                 }
                 // otherwise fall back to default Destroy
-                else if (identity.sceneId == 0)
+                else if (sceneId == 0)
                 {
                     // don't call reset before destroy so that values are still set in OnDestroy
                     GameObject.Destroy(identity.gameObject);
@@ -1985,9 +2014,10 @@ static void DestroyObject(uint netId)
                 else
                 {
                     identity.gameObject.SetActive(false);
-                    spawnableObjects[identity.sceneId] = identity;
                     // reset for scene objects
+                    identity.ResetSyncObjectCallbacks();
                     identity.ResetState();
+                    spawnableObjects[sceneId] = identity;
                 }
 
                 // remove from dictionary no matter how it is unspawned

Assets/Mirror/Core/NetworkIdentity.cs

@@ -123,6 +123,11 @@ public sealed class NetworkIdentity : MonoBehaviour
         // only set temporarily during OnHostClientSpawn deserialization.
         internal bool hostInitialSpawn;
 
+        // flag to indicate a remote client is deserializing an initial spawn.
+        // scene objects may be re-used across hide/show cycles, so hook logic
+        // needs to treat each re-observation like a fresh first observation.
+        internal bool clientInitialSpawnActive;
+
         /// <summary>The set of network connections (players) that can see this object.</summary>
         public readonly Dictionary<int, NetworkConnectionToClient> observers =
             new Dictionary<int, NetworkConnectionToClient>();
@@ -1689,6 +1694,12 @@ internal void ResetState()
             isLocalPlayer = false;
         }
 
+        internal void ResetSyncObjectCallbacks()
+        {
+            foreach (NetworkBehaviour comp in NetworkBehaviours)
+                comp.ResetSyncObjectCallbacks();
+        }
+
         bool hadAuthority;
         internal void NotifyAuthority()
         {

Assets/Mirror/Core/NetworkServer.cs

@@ -1884,6 +1884,12 @@ static void UnSpawnInternal(GameObject obj, bool resetState)
             // in host mode, call OnStopClient/OnStopLocalPlayer manually
             if (NetworkClient.active && activeHost)
             {
+                foreach (NetworkBehaviour component in identity.NetworkBehaviours)
+                {
+                    component.MarkAllSyncVarHostVisibilityReplayPending();
+                    component.MarkAllSyncObjectHostVisibilityReplayPending();
+                }
+
                 // fix: #3962 custom unspawn handler for this prefab (for prefab pools etc.)
                 NetworkClient.InvokeUnSpawnHandler(identity.assetId, identity.gameObject);
 

Assets/Mirror/Core/SyncDictionary.cs

@@ -131,12 +131,30 @@ public override void OnDeserializeAll(NetworkReader reader)
                 objects.Add(key, obj);
             }
 
+            QueueHostVisibilityReplay();
+
             // We will need to skip all these changes
             // the next time the list is synchronized
             // because they have already been applied
             changesAhead = (int)reader.ReadUInt();
         }
 
+        public override void QueueHostVisibilityReplay()
+        {
+            if (!(NetworkServer.activeHost &&
+                  networkBehaviour.syncDirection == SyncDirection.ServerToClient &&
+                  networkBehaviour.netIdentity.hostInitialSpawn))
+                return;
+
+            foreach (KeyValuePair<TKey, TValue> entry in objects)
+            {
+                TKey capturedKey = entry.Key;
+                TValue capturedValue = entry.Value;
+                networkBehaviour.deferredSyncCollectionActions.Add(() =>
+                    InvokeActions(Operation.OP_ADD, capturedKey, capturedValue, default));
+            }
+        }
+
         public override void OnDeserializeDelta(NetworkReader reader)
         {
             int changesCount = (int)reader.ReadUInt();
@@ -260,6 +278,15 @@ public override void Reset()
             objects.Clear();
         }
 
+        public override void ResetCallbacks()
+        {
+            OnAdd = null;
+            OnSet = null;
+            OnRemove = null;
+            OnClear = null;
+            OnChange = null;
+        }
+
         public TValue this[TKey i]
         {
             get => objects[i];
@@ -359,15 +386,21 @@ void AddOperation(Operation op, TKey key, TValue item, TValue oldItem, bool chec
             bool hostInitialSpawnInHostMode = NetworkServer.activeHost && networkBehaviour.netIdentity.hostInitialSpawn;
             bool shouldFireActions = shouldApplyChanges || hostInitialSpawnInHostMode;
 
-            // IMPORTANT:  For ServerToClient mode, only fire Actions if object is visible to host client
-            // This prevents Actions from firing at spawn for objects out of AOI range
-            if (shouldFireActions && NetworkServer.activeHost && networkBehaviour.syncDirection == SyncDirection.ServerToClient)
-            {
-                shouldFireActions = NetworkClient.spawned.ContainsKey(networkBehaviour.netIdentity.netId);
-            }
-
             if (shouldFireActions)
             {
+                if (NetworkServer.activeHost &&
+                    networkBehaviour.syncDirection == SyncDirection.ServerToClient)
+                {
+                    if (!networkBehaviour.IsHostClientObserved())
+                    {
+                        MarkHostVisibilityReplayPending();
+                        return;
+                    }
+
+                    if (hostVisibilityReplayPending)
+                        return;
+                }
+
                 // Defer Actions during initial spawn on pure client to eliminate
                 // cross-object reference race conditions. All objects will be in
                 // NetworkClient.spawned before any Actions fire.

Assets/Mirror/Core/SyncList.cs

@@ -97,6 +97,17 @@ public override void Reset()
             objects.Clear();
         }
 
+        public override void ResetCallbacks()
+        {
+            OnAdd = null;
+            OnInsert = null;
+            OnSet = null;
+            OnRemove = null;
+            OnClear = null;
+            OnChange = null;
+            Callback = null;
+        }
+
         void AddOperation(Operation op, int itemIndex, T oldItem, T newItem, bool checkAccess, bool shouldApplyChanges)
         {
             if (checkAccess && IsReadOnly)
@@ -120,15 +131,21 @@ void AddOperation(Operation op, int itemIndex, T oldItem, T newItem, bool checkA
             bool hostInitialSpawnInHostMode = NetworkServer.activeHost && networkBehaviour.netIdentity.hostInitialSpawn;
             bool shouldFireActions = shouldApplyChanges || hostInitialSpawnInHostMode;
 
-            // IMPORTANT: For ServerToClient mode, only fire Actions if object is visible to host client
-            // This prevents Actions from firing at spawn for objects out of AOI range
-            if (shouldFireActions && NetworkServer.activeHost && networkBehaviour.syncDirection == SyncDirection.ServerToClient)
-            {
-                shouldFireActions = NetworkClient.spawned.ContainsKey(networkBehaviour.netIdentity.netId);
-            }
-
             if (shouldFireActions)
             {
+                if (NetworkServer.activeHost &&
+                    networkBehaviour.syncDirection == SyncDirection.ServerToClient)
+                {
+                    if (!networkBehaviour.IsHostClientObserved())
+                    {
+                        MarkHostVisibilityReplayPending();
+                        return;
+                    }
+
+                    if (hostVisibilityReplayPending)
+                        return;
+                }
+
                 // Defer Actions during initial spawn on pure client to eliminate
                 // cross-object reference race conditions.  All objects will be in
                 // NetworkClient.spawned before any Actions fire.
@@ -247,12 +264,30 @@ public override void OnDeserializeAll(NetworkReader reader)
                 objects.Add(obj);
             }
 
+            QueueHostVisibilityReplay();
+
             // We will need to skip all these changes
             // the next time the list is synchronized
             // because they have already been applied
             changesAhead = (int)reader.ReadUInt();
         }
 
+        public override void QueueHostVisibilityReplay()
+        {
+            if (!(NetworkServer.activeHost &&
+                  networkBehaviour.syncDirection == SyncDirection.ServerToClient &&
+                  networkBehaviour.netIdentity.hostInitialSpawn))
+                return;
+
+            for (int i = 0; i < objects.Count; i++)
+            {
+                int capturedIndex = i;
+                T capturedValue = objects[i];
+                networkBehaviour.deferredSyncCollectionActions.Add(() =>
+                    InvokeActions(Operation.OP_ADD, capturedIndex, default, capturedValue));
+            }
+        }
+
         public override void OnDeserializeDelta(NetworkReader reader)
         {
             int changesCount = (int)reader.ReadUInt();